CWE-ou-minkata/Sources/Plasma/PubUtilLib/plContainer/plKeysAndValues.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#include "plKeysAndValues.h"
#include "hsStream.h"
#include <algorithm>


plKeysAndValues::plKeysAndValues()
{
}

plKeysAndValues::plKeysAndValues(const plKeysAndValues & src)
:   fKeys(src.fKeys)
{
}

plKeysAndValues & plKeysAndValues::operator =(const plKeysAndValues & src)
{
    fKeys = src.fKeys;
    return *this;
}


void plKeysAndValues::Clear()
{
    fKeys.clear();
}

void plKeysAndValues::RemoveKey(const std::string & key)
{
    fKeys.erase(key.c_str());
}

bool plKeysAndValues::HasKey(const std::string & key) const
{
    return (fKeys.find(key.c_str()) != fKeys.end());
}

bool plKeysAndValues::KeyHasValue(const std::string & key, const std::string & value)
{
    Keys::const_iterator ki = fKeys.find(key.c_str());
    if (ki==fKeys.end())
        return false;
    return std::find(ki->second.begin(),ki->second.end(), value.c_str()) != ki->second.end();
}

bool plKeysAndValues::KeyHasValue(const std::string & key, int value)
{
    char buf[20];
    sprintf(buf, "%d", value);
    std::string v(buf);
    return KeyHasValue(key, v);    
}

bool plKeysAndValues::KeyHasValue(const std::string & key, double value)
{
    char buf[30];
    sprintf(buf, "%f", value);
    std::string v(buf);
    return KeyHasValue(key, v);    
}

bool plKeysAndValues::AddValue(const std::string & key, const std::string & value, KAddValueMode mode)
{
    switch (mode)
    {
    case kFailIfExists:
        if (HasKey(key))
            return false;
        break;
    case kReplaceIfExists:
        if (HasKey(key))
            RemoveKey(key);
        break;
    }
    fKeys[key.c_str()].push_front(value.c_str());
    return true;
}

bool plKeysAndValues::AddValue(const std::string & key, int value, KAddValueMode mode)
{
    char buf[20];
    sprintf(buf, "%d", value);
    std::string v(buf);
    return AddValue(key,v,mode);
}

bool plKeysAndValues::AddValue(const std::string & key, double value, KAddValueMode mode)
{
    char buf[30];
    sprintf(buf, "%f", value);
    std::string v(buf);
    return AddValue(key,v,mode);    
}

bool plKeysAndValues::AddValues(const std::string & key, const std::vector<std::string> & values, KAddValueMode mode)
{
    for (int i=0; i<values.size(); i++)
        AddValue(key,values[i],mode);
    return true;
}

bool plKeysAndValues::SetValue(const std::string & key, const std::string & value)
{
    fKeys[key.c_str()].clear();
    return AddValue(key,value);
}

bool plKeysAndValues::SetValue(const std::string & key, int value)
{
    char buf[20];
    sprintf(buf, "%d", value);
    std::string v(buf);
    return SetValue(key, v);    
}

bool plKeysAndValues::SetValue(const std::string & key, double value)
{
    char buf[30];
    sprintf(buf, "%f", value);
    std::string v(buf);
    return SetValue(key, v);    
}

std::string plKeysAndValues::GetValue(const std::string & key, const std::string & defval, bool * outFound) const
{
    Keys::const_iterator ki = fKeys.find(key.c_str());
    if (outFound)
        *outFound = (ki!=fKeys.end());
    if(ki != fKeys.end())
        return ki->second.front().c_str();
//  fKeys[key.c_str()].push_front(defval.c_str());
    return defval;
}

UInt32 plKeysAndValues::GetValue(const std::string & key, UInt32 defval, bool * outFound) const
{
    char buf[20];
    sprintf(buf, "%ul", defval);
    std::string v(buf);
    return strtoul(GetValue(key,v,outFound).c_str(), nil, 0);
}

int plKeysAndValues::GetValue(const std::string & key, int defval, bool * outFound) const
{
    char buf[20];
    sprintf(buf, "%d", defval);
    std::string v(buf);
    return atol(GetValue(key,v,outFound).c_str());
}

double plKeysAndValues::GetValue(const std::string & key, double defval, bool * outFound) const
{
    char buf[30];
    sprintf(buf, "%f", defval);
    std::string v(buf);
    return atof(GetValue(key,v,outFound).c_str());
}

std::vector<std::string> plKeysAndValues::GetAllValues(const std::string & key)
{
    std::vector<std::string> result;
    xtl::istring xkey = key.c_str();
    if (HasKey(key))
        for (Values::const_iterator vi=fKeys[xkey].begin(); vi!=fKeys[xkey].end(); ++vi)
            result.push_back(vi->c_str());
    return result;
}

bool plKeysAndValues::GetKeyIterators(Keys::const_iterator & iter, Keys::const_iterator & end) const
{
    iter = fKeys.begin();
    end = fKeys.end();
    return true;
}

bool plKeysAndValues::GetValueIterators(const xtl::istring & key, Values::const_iterator & iter, Values::const_iterator & end) const
{
    Keys::const_iterator ki = fKeys.find(key);
    if(ki != fKeys.end())
    {
        iter = ki->second.begin();
        end  = ki->second.end();
        return true;
    }
    return false;
}

void plKeysAndValues::Read(hsStream * s)
{
    UInt16 nkeys;
    s->ReadSwap(&nkeys);
    for (int ki=0; ki<nkeys; ki++)
    {
        UInt16 strlen;
        s->ReadSwap(&strlen);
        std::string key;
        key.assign(strlen+1,'\0');
        s->Read(strlen,(void*)key.data());
        key.resize(strlen);
        UInt16 nvalues;
        s->ReadSwap(&nvalues);
        for (int vi=0; vi<nvalues; vi++)
        {
            s->ReadSwap(&strlen);
            std::string value;
            value.assign(strlen+1,'\0');
            s->Read(strlen,(void*)value.data());
            value.resize(strlen);
            // for now, only single value for key on stream is allowed.
            SetValue(key,value);
        }
    }
}

void plKeysAndValues::Write(hsStream * s)
{
    // write nkeys
    s->WriteSwap((UInt16)fKeys.size());
    // iterate through keys
    Keys::const_iterator ki,ke;
    GetKeyIterators(ki,ke);
    for (ki;ki!=ke;++ki)
    {
        // write key string
        s->WriteSwap((UInt16)ki->first.size());
        s->Write(ki->first.size(),ki->first.c_str());
        // write nvalues for this key
        s->WriteSwap((UInt16)ki->second.size());
        // iterate through values for this key
        Values::const_iterator vi,ve;
        GetValueIterators(ki->first,vi,ve);
        for (vi;vi!=ve;++vi)
        {
            // write value string
            s->WriteSwap((UInt16)vi->size());
            s->Write(vi->size(),vi->c_str());
        }
    }
}