You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 

431 lines
9.7 KiB

/*==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