CWE-ou-minkata/Sources/Plasma/CoreLib/hsStlUtils.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 "hsStlUtils.h"

// stl extensions
namespace xtl {

//std::string
std::string & trimleft(std::string & s, const char * charset)
{
    s.erase(0, s.find_first_not_of(charset));
    return s;
}

std::wstring & trimleft(std::wstring & s, const wchar_t * charset)
{
    s.erase(0, s.find_first_not_of(charset));
    return s;
}

std::string & trimright(std::string & s, const char * charset)
{
    int idx = s.find_last_not_of(charset);
    
    if (std::string::npos == idx)
    {
        s.erase();
    }
    else
    {
        char c    = s.at(idx);
        s.erase(idx, std::string::npos);    
        s.append(1, c);
    }
    
    return s;
}

std::wstring & trimright(std::wstring & s, const wchar_t * charset)
{
    int idx = s.find_last_not_of(charset);

    if (std::wstring::npos == idx)
    {
        s.erase();
    }
    else
    {
        wchar_t c = s.at(idx);
        s.erase(idx, std::string::npos);
        s.append(1, c);
    }

    return s;
}

std::string & trim(std::string & s, const char * charset)
{
    trimleft(s,charset);
    trimright(s,charset);
    return s;
}

std::wstring & trim(std::wstring & s, const wchar_t * charset)
{
    trimleft(s,charset);
    trimright(s,charset);
    return s;
}

//xtl::istring
xtl::istring & trimleft(xtl::istring & s, const char * charset)
{
    s.erase(0, s.find_first_not_of(charset));
    return s;
}

xtl::iwstring & trimleft(xtl::iwstring & s, const wchar_t * charset)
{
    s.erase(0, s.find_first_not_of(charset));
    return s;
}

xtl::istring & trimright(xtl::istring & s, const char * charset)
{
    int idx = s.find_last_not_of(charset);
    
    if (xtl::istring::npos == idx)
    {
        s.erase();
    }
    else
    {
        char c    = s.at(idx);
        s.erase(idx, xtl::istring::npos);    
        s.append(1, c);
    }
    
    return s;
}

xtl::iwstring & trimright(xtl::iwstring & s, const wchar_t * charset)
{
    int idx = s.find_last_not_of(charset);

    if (xtl::iwstring::npos == idx)
    {
        s.erase();
    }
    else
    {
        wchar_t c = s.at(idx);
        s.erase(idx, xtl::iwstring::npos);
        s.append(1, c);
    }
    
    return s;
}

xtl::istring & trim(xtl::istring & s, const char * charset)
{
    trimleft(s,charset);
    trimright(s,charset);
    return s;
}

xtl::iwstring & trim(xtl::iwstring & s, const wchar_t * charset)
{
    trimleft(s,charset);
    trimright(s,charset);
    return s;
}

// c-string
std::string trim(const char * s, const char * charset)
{
    std::string result  = s;
    trimleft(result,charset);
    trimright(result,charset);
    return result;
}

std::wstring trim(const wchar_t * s, const wchar_t * charset)
{
    std::wstring result = s;
    trimleft(result,charset);
    trimright(result,charset);
    return result;
}


// format
std::string format(const char * fmt, ...)
{
    std::string result;
    va_list args;
    va_start(args,fmt);
    formatv(result,fmt,args);
    va_end(args);
    return result;
}

std::wstring format(const wchar_t * fmt, ...)
{
    std::wstring result;
    va_list args;
    va_start(args,fmt);
    formatv(result,fmt,args);
    va_end(args);
    return result;
}

std::string formatv(const char * fmt, va_list args)
{
    std::string result;
    formatv( result, fmt, args );
    return result;
}

std::wstring formatv(const wchar_t * fmt, va_list args)
{
    std::wstring result;
    formatv( result, fmt, args );
    return result;
}

bool format(std::string & out, const char * fmt, ...)
{
    va_list args;
    va_start(args,fmt);
    bool r = formatv(out,fmt,args);
    va_end(args);
    return r;
}

bool format(std::wstring & out, const wchar_t * fmt, ...)
{
    va_list args;
    va_start(args,fmt);
    bool r = formatv(out,fmt,args);
    va_end(args);
    return r;
}

bool formatv(std::string & out, const char * fmt, va_list args)
{
#define kBufSz 2048

    char buf[kBufSz];
    char * pbuf = buf;
    int len = 0;
    int attempts = 0;
    bool success = false;
    const int kMaxAttempts = 40;

    do
    {
        int maxlen = kBufSz*attempts+kBufSz-1;
        len = hsVsnprintf(pbuf,maxlen,fmt,args);
        attempts++;
        success = (len>=0 && len<maxlen);
        if (!success)
        {
            if (pbuf!=buf)
                delete [] pbuf;
            pbuf = TRACKED_NEW char[kBufSz+kBufSz*attempts];
        }
    }
    while (!success && attempts<kMaxAttempts);

    if (success)
    {
        pbuf[len] = '\0';
        out = pbuf;
    }

    if (success)
    {
        pbuf[len] = '\0';
        out = pbuf;
    }
    else
    {
        out = "";
        if ( attempts==kMaxAttempts )
        {
            hsDebugMessage( "xtl::formatv - Max reallocs occurred while formatting string. Result is likely truncated!", 0 );
        }
    }

    if (pbuf!=buf)
        delete [] pbuf;

    return success;
}

bool formatv(std::wstring & out, const wchar_t * fmt, va_list args)
{
#define kBufSz 2048
    
    wchar_t buf[kBufSz];
    wchar_t * pbuf = buf;
    int len = 0;
    int attempts = 0;
    bool success = false;
    const int kMaxAttempts = 40;
    
    do
    {
        int maxlen = kBufSz*attempts+kBufSz-1;
        len = hsVsnwprintf(pbuf,maxlen,fmt,args);
        attempts++;
        success = (len>=0 && len<maxlen);
        if (!success)
        {
            if (pbuf!=buf)
                delete [] pbuf;
            pbuf = TRACKED_NEW wchar_t[kBufSz+kBufSz*attempts];
        }
    }
    while (!success && attempts<kMaxAttempts);
    
    if (success)
    {
        pbuf[len] = L'\0';
        out = pbuf;
    }
    
    if (success)
    {
        pbuf[len] = L'\0';
        out = pbuf;
    }
    else
    {
        out = L"";
        if ( attempts==kMaxAttempts )
        {
            hsDebugMessage( "xtl::formatv - Max reallocs occurred while formatting wstring. Result is likely truncated!", 0 );
        }
    }
    
    if (pbuf!=buf)
        delete [] pbuf;
    
    return success;
}

typedef std::vector<std::string> StringVector;
typedef std::vector<std::wstring> WStringVector;
typedef std::list<std::string> StringList;
typedef std::list<std::wstring> WStringList;
typedef std::set<std::string> StringSet;
typedef std::set<std::wstring> WStringSet;

template bool GetStringGroup<StringList>(const std::string& s, StringList& group, char sep);
template bool GetStringGroup<WStringList>(const std::wstring& s, WStringList& group, wchar_t sep);
template bool GetStringGroup<StringVector>(const std::string& s, StringVector& group, char sep);
template bool GetStringGroup<WStringVector>(const std::wstring& s, WStringVector& group, wchar_t sep);
template bool GetStringGroup<StringSet>(const std::string& s, StringSet& group, char sep);
template bool GetStringGroup<WStringSet>(const std::wstring& s, WStringSet& group, wchar_t sep);

template <typename T> bool GetStringGroup(const std::string& s, T& group, char sep)
{
    bool ret = false;
    std::string::size_type oldpos = 0, newpos = 0;
    
    if (!(s.empty()))
    {
        do 
        {
            newpos = s.find(',',oldpos);
            group.insert(group.end(),s.substr(oldpos,newpos));
            if (newpos != s.npos)
                oldpos = newpos+1;
        } 
        while(newpos != s.npos);
        ret = true;
    }

    return ret;
}

template <typename T> bool GetStringGroup(const std::wstring& s, T& group, wchar_t sep)
{
    bool ret = false;
    std::wstring::size_type oldpos = 0, newpos = 0;

    if (!(s.empty()))
    {
        do
        {
            newpos = s.find(L',',oldpos);
            group.insert(group.end(),s.substr(oldpos,newpos));
            if (newpos != s.npos)
                oldpos = newpos+1;
        } while(newpos != s.npos);
        ret = true;
    }

    return ret;
}


template bool GetStringGroupAsString<StringList>(const StringList& group, std::string& s, char sep);
template bool GetStringGroupAsString<WStringList>(const WStringList& group, std::wstring& s, wchar_t sep);
template bool GetStringGroupAsString<StringVector>(const StringVector& group, std::string& s, char sep);
template bool GetStringGroupAsString<WStringVector>(const WStringVector& group, std::wstring& s, wchar_t sep);
template bool GetStringGroupAsString<StringSet>(const StringSet& group, std::string& s, char sep);
template bool GetStringGroupAsString<WStringSet>(const WStringSet& group, std::wstring& s, wchar_t sep);

template <typename T> bool GetStringGroupAsString(const T& group, std::string& s, char sep)
{
    typename T::const_iterator it = group.begin();
    bool fst = true;
    while (it != group.end())
    {
        if (!fst)
            s += ",";
        else
            fst = false;
        s+= (*it).c_str();
        it++;
    }

    return true;
}

template <typename T> bool GetStringGroupAsString(const T& group, std::wstring& s, wchar_t sep)
{
    typename T::const_iterator it = group.begin();
    bool fst = true;
    while (it != group.end())
    {
        if (!fst)
            s += L",";
        else
            fst = false;
        s+= (*it).c_str();
        it++;
    }
    
    return true;
}


} // namespace std