WebSVN – spk – Diff – //libspk/src/Utils/String.cpp



#include <stdarg.h>
#include <algorithm>
#include <iomanip>
#include <locale>
#include <codecvt>

#include "WString.h"

namespace Utils {

	std::wstring s2ws(const std::string& str)
	{


		return converterX.to_bytes(wstr);
	}


	SString operator+(const char* str1, const SString& str2)
	{
		return SString(str1) + str2;
	}
	SString operator+(const unsigned char* str1, const SString& str2)
	{
		return SString(str1) + str2;
	}

SString::SString(void)						{ this->assign(""); }
SString::SString(const char *str)			{ this->assign(str); }
SString::SString(const unsigned char *str)	{ this->assign((const char *)str); }
SString::SString(const std::string &str)	{ this->assign(str);}
SString::SString(const unsigned char c)		{ this->assign(1, c); }
SString::SString(const char c)				{ this->assign(1, c); }
SString::SString(const SString &str)		{ this->assign(str); }
SString::SString(long l)					{ this->fromLong(l); }
SString::SString(unsigned long l)			{ this->fromLong((long)l); }
SString::SString(float f)					{ this->fromFloat(f); }
SString::SString(double f)					{ this->fromDouble(f); }

SString::~SString(void)
{
}

SString SString::PadNumber(long iNumber, int iAmount)
{
	SString str(iNumber);
	return str.padNumber(iAmount);
}

const SString &SString::padNumber(int iAmount)
{
	return this->pad(iAmount, '0');
}

const SString &SString::pad(int iAmount, char cWith)
{
	std::stringstream strm;
	strm << std::setw(iAmount) << std::setfill(cWith) << *this;
	*this = strm.str();
	return (*this);



/////////////////////////////////////////////////////////////////
// Conversion functions

void SString::fromLong(long l)
{
	std::stringstream strstream;
	strstream << l;
	*this = strstream.str();
}

const SString &SString::fromFloat(float f, int dp)
{
	std::stringstream strstream;
	if ( dp != -1 ) {
		strstream.precision(dp);
		strstream << std::fixed << f;
	}
	else
		strstream << f;
	*this = strstream.str();
	return (*this);
}

void SString::fromDouble(double f)
{
	std::stringstream strstream;
	strstream << f;
	*this = strstream.str();
}

const SString &SString::fromDouble(double f, int dp)
{
	std::stringstream strstream;
	if (dp != -1) {
		strstream.precision(dp);
		strstream << std::fixed << f;

		strstream << f;
	*this = strstream.str();
	return (*this);
}

const SString &SString::format(const char *sFormat, ...)
{
	char buffer[1024];
	va_list args;
	va_start (args, sFormat);
	vsprintf (buffer, sFormat, args);


	this->assign(buffer);
	return (*this);
}

const SString SString::args(const SString *args, int max) const
{
	Utils::SString str = (*this);
	for (int i = 0; i < max; i++)
	{
		Utils::SString find("%");
		find += Utils::SString::Number(i + 1);

		str = str.findReplace(find, args[i]);
	}

	return str;
}
const SString &SString::arg(const SString &s1)
{
	(*this) = this->findReplace("%1", s1);
	return (*this);
}

const SString &SString::arg(const SString &s1, const SString &s2)
{
	(*this) = this->arg(s1).findReplace("%2", s2);
	return (*this);
}
const SString &SString::arg(const SString &s1, const SString &s2, const SString &s3)
{
	(*this) = this->arg(s1, s1).findReplace("%3", s3);
	return (*this);
}
const SString &SString::arg(const SString &s1, const SString &s2, const SString &s3, const SString &s4)
{
	(*this) = this->arg(s1, s2, s3).findReplace("%4", s4);
	return (*this);
}
const SString &SString::arg(const SString &s1, const SString &s2, const SString &s3, const SString &s4, const SString &s5)
{
	(*this) = this->arg(s1, s2, s3, s4).findReplace("%5", s5);
	return (*this);
}


SString SString::Null()
{
	return Utils::SString();
}

SString SString::FromFloat(float f, int dp)
{ 
	SString str;
	str.fromFloat(f, dp); 
	return str;
}

SString SString::Format(const char *sFormat, ...)
{
	char buffer[1024];
	va_list args;
	va_start (args, sFormat);
	vsprintf (buffer, sFormat, args);
	va_end (args);

	return SString(buffer);
}

bool SString::toBool() const
{
	return atoi(this->c_str()) ? true : false;
}
long SString::toLong() const
{
	return static_cast<long>(atoi(this->c_str()));
}
int SString::toInt() const
{
	return static_cast<int>(atoi(this->c_str()));
}
double SString::toDouble() const
{
	return atof(this->c_str());
}
float SString::toFloat() const
{
	return (float)atof(this->c_str());
}

const Utils::WString SString::toWString() const 
{ 
	return s2ws(*this); 
}


const SString &SString::operator= ( const char *str )				{ this->assign(str); return (*this); }
const SString &SString::operator= ( const unsigned char *str )		{ this->assign((const char *)str); return (*this); }
const SString &SString::operator= ( const SString &str )			{ this->assign((std::string &)str); return (*this); }
const SString &SString::operator= ( const std::string &str )		{ this->assign(str); return (*this); }
const SString &SString::operator= ( unsigned char c )				{ this->assign(1, c); return (*this); }
const SString &SString::operator= ( char c )						{ this->assign(1, c); return (*this); }
const SString &SString::operator= ( long l )						{ this->fromLong(l); return (*this); }
const SString &SString::operator= ( unsigned long l )				{ this->fromLong(l); return (*this); }
const SString &SString::operator= ( float f )						{ this->fromFloat(f); return (*this); }
const SString &SString::operator= ( double f )						{ this->fromDouble(f); return (*this); }

const unsigned char SString::operator[] ( int num ) const			{ return this->at(num); }
unsigned char &SString::operator[] ( int num )						{ return (unsigned char &)this->at(num); }

const SString &SString::operator+= ( const char *str )				{ this->append(str); return (*this); }
const SString &SString::operator+= ( const unsigned char *str ) 	{ this->append((const char *)str); return (*this); }
const SString &SString::operator+= ( const std::string &str )		{ this->append(str); return (*this); }
const SString &SString::operator+= ( const SString &str )			{ this->append(str); return (*this); }
const SString &SString::operator+= ( const char c )					{ this->append(1, c); return (*this); }
const SString &SString::operator+= ( const unsigned char c )		{ this->append(1, c); return (*this); }
const SString &SString::operator+= ( const unsigned long l )		
{ 
	std::stringstream strm;
	strm << (*this) << l;
	strm >> (*this);
	return (*this); 
}
const SString &SString::operator+= ( const long l )		
{ 
	std::stringstream strm;
	strm << (*this) << l;
	*this = strm.str();
	return (*this); 
}
const SString &SString::operator+= ( const float f )		
{ 
	std::stringstream strm;
	strm << (*this) << f;
	*this = strm.str();
	return (*this); 
}
const SString &SString::operator+= ( const double f )		
{ 
	std::stringstream strm;
	strm << (*this) << f;
	*this = strm.str();
	return (*this); 
}


SString SString::operator+ ( const char *str ) const			{ return SString(*this) += str; }
SString SString::operator+ ( const unsigned char *str ) const	{ return SString(*this) += str; }
SString SString::operator+ ( const std::string &str ) const		{ return SString(*this) += str; }
SString SString::operator+ ( const SString &str ) const			{ return SString(*this) += str; }
SString SString::operator+ ( const char c ) const				{ return SString(*this) += c; }
SString SString::operator+ ( const unsigned char c ) const		{ return SString(*this) += c; }
SString SString::operator+ ( const long l ) const				{ return SString(*this) += l; }
SString SString::operator+ ( const unsigned long l ) const		{ return SString(*this) += l; }
SString SString::operator+ ( const float f ) const				{ return SString(*this) += f; }
SString SString::operator+ ( const double f ) const				{ return SString(*this) += f; }

bool SString::operator== ( const char *str ) const				{ return (this->compare(str)) ? false : true; }
bool SString::operator== ( const unsigned char *str ) const		{ return (this->compare((const char *)str)) ? false : true; }
bool SString::operator== ( const std::string &str ) const		{ return (this->compare(str)) ? false : true; }
bool SString::operator== ( const SString &str ) const			{ return (this->compare(str)) ? false : true; }

bool SString::operator!= ( const char *str ) const				{ return (this->compare(str)) ? true : false; }
bool SString::operator!= ( const unsigned char *str ) const		{ return (this->compare((const char *)str)) ? true : false; }
bool SString::operator!= ( const std::string &str ) const		{ return (this->compare(str)) ? true : false; }
bool SString::operator!= ( const SString &str ) const			{ return (this->compare(str)) ? true : false; }

bool SString::operator !() const
{
	return this->empty();
}

bool SString::Compare(const SString &str, bool bCaseSensative) const
{
	if ( bCaseSensative ) {
		return (this->compare(str) == 0) ? true : false;
	}


		}
	}
	return true;
}

bool SString::Compare(const unsigned char *str, bool bCaseSensative) const
{
	return this->Compare((const char *)str, bCaseSensative);
}

bool SString::Compare(const char *str, bool bCaseSensative) const
{
	if ( bCaseSensative ) {
		return (this->compare(str) == 0) ? true : false;
	}


	}

	return true;
}

SString SString::token(const char *token, int tok) const
{
	return this->tokens(token, tok, tok);
}

SString SString::tokens(const char *token, int from, int to) const
{
	if ( this->empty() ) return "";

	int max = this->countToken(token);

	Utils::SString newstr;

	int whichtok = 1;
	Utils::SString::size_type lastPos = 0;
	Utils::SString::size_type pos     = _token_nextPos(token, 0);

	if ( from < 0 )
		from = max + (from + 1);
	if ( to < 0 )
		to = max + (to + 1);

	while (Utils::SString::npos != pos || Utils::SString::npos != lastPos)
	{
		if ( to == 0 )
		{
			if ( whichtok >= from )
			{
				if ( newstr != "" ) newstr = newstr + token;
				newstr = newstr + Utils::SString(this->substr(lastPos, pos - lastPos));
			}
		}
		else
		{
			if ( (whichtok >= from) && (whichtok <= to) )
			{
				if ( newstr != "" ) newstr = newstr + token;
				newstr = newstr + Utils::SString(this->substr(lastPos, pos - lastPos));
			}
			if ( whichtok > to )
				break;
		}
		// Found a token, add it to the vector.

		pos = _token_nextPos(token, lastPos);
	}
	return newstr;
}

SString SString::remToken(const char* token, int from) const
{
	Utils::SString newstr;

	if (from < 0)
	{
		int maxT = this->countToken(token);
		from = maxT + (from + 1);
	}

	int whichtok = 1;
	Utils::SString::size_type lastPos = 0;
	Utils::SString::size_type pos = _token_nextPos(token, 0);

	while (Utils::SString::npos != pos || Utils::SString::npos != lastPos)
	{
		if (whichtok != from)
		{
			if (newstr != "") newstr = newstr + token;
			newstr = newstr + Utils::SString(this->substr(lastPos, pos - lastPos));
		}

		// Found a token, add it to the vector.
		whichtok++;


		pos = _token_nextPos(token, lastPos);
	}
	return newstr;
}

SString SString::remTokens(const char* token, int from, int to) const
{
	Utils::SString newstr;

	if (from < 0)
	{
		int maxT = this->countToken(token);
		from = maxT + (from + 1);

		int maxT = this->countToken(token);
		to = maxT + (to + 1);
	}

	int whichtok = 1;
	Utils::SString::size_type lastPos = 0;
	Utils::SString::size_type pos = _token_nextPos(token, 0);

	while (Utils::SString::npos != pos || Utils::SString::npos != lastPos)
	{
		if (!(whichtok >= from && whichtok <= to))
		{
			if (newstr != "") newstr = newstr + token;
			newstr = newstr + Utils::SString(this->substr(lastPos, pos - lastPos));
		}

		// Found a token, add it to the vector.
		whichtok++;


		pos = _token_nextPos(token, lastPos);
	}
	return newstr;
}

SString SString::word(int word) const
{
	return this->token(" ", word);
}
SString SString::words(int from, int to) const
{
	return this->tokens(" ", from, to);
}

SString SString::addToken(const char *token, const Utils::SString &str) const
{
	if (this->empty())
		return str;

	Utils::SString s = (*this);
	s += token;
	s += str;

	return s;
}

int SString::countToken(const char *token) const
{
	if ( this->empty() )
		return 0;

	// finds the number of tokens in a string
	int found = 1;

	Utils::SString tmpstr = *this;

	// ignore the initial spaces
	Utils::SString::size_type pos = this->find_first_not_of(token, 0);

	// remove end spaces
	size_t i = tmpstr.size() - 1;
	while ( tmpstr[i] == ' ' && i > 0 )
		i--;
	if ( i <= 0 ) return 0;
	tmpstr.erase ( i + 1, tmpstr.size() - i );

	// count tokens
	pos = tmpstr.find (token,pos + 1);
	while ( pos < Utils::SString::npos )
	{
		while (tmpstr[pos] == ' ')
			pos++;
		found++;
		pos = tmpstr.find (token,pos + 1);


	// return number of tokens
	return found;
}

Utils::SString::size_type SString::_token_nextPos(const char *token, Utils::SString::size_type curPos) const
{
	bool found = false;
	Utils::SString::size_type startPos = 0;
	size_t max = strlen(token);
	while ( !found ) {
		found = true;
		startPos = this->find_first_of(token[0], curPos);
		if ( startPos == Utils::SString::npos ) {
			startPos = this->length();
			break;
		}

		Utils::SString::size_type pos = startPos;
		size_t i = 1;
		while ( i < max )
		{
			++pos;
			if ( this->at(pos) != token[i] )

		curPos = pos;
	}
	return startPos;
}

SString SString::findReplace(const SString &find, const SString &replace ) const
{
	Utils::SString newstr = *this;
	Utils::SString::size_type pos = newstr.find(find, 0);
	while ( pos < Utils::SString::npos ) {
		newstr.replace(pos, find.length(), replace);
		pos = newstr.find(find, pos + replace.length());
	}

	return newstr;
}

SString SString::findRemove(const SString &find) const
{
	Utils::SString replace = *this;

	Utils::SString::size_type pos = replace.find(find, 0 );
	while ( pos != Utils::SString::npos ) {
		replace.erase ( pos, find.length() );
		pos = replace.find(find, pos);
	}

	return replace;
}

SString SString::removeIf(int iChar, char c) const
{
	Utils::SString newStr = *this;
	if ( newStr.empty() ) return newStr;
	if ( this->at(iChar) == c ) newStr.erase(iChar, 1);
	return newStr;
}

SString SString::stripHtml() const
{
	// if empty, theres no to strip
	if ( this->empty() ) return "";

	// replace break line with a new line
	Utils::SString newStr = (*this);
	newStr = newStr.findReplace("<br/>", "\n");
	newStr = newStr.findReplace("<br />", "\n");
	newStr = newStr.findReplace("<p>", "\n\t");
	newStr = newStr.findReplace("</p>", "\n");

	// find any remaining tags and remove them
	Utils::SString::size_type pos     = newStr.find_first_of('<', 0);
	Utils::SString::size_type lastPos = newStr.find_first_of('>', pos);

	while (Utils::SString::npos != pos || Utils::SString::npos != lastPos)
	{
		if ( lastPos > newStr.length() ) break;
		// remove the tag
		newStr.erase(pos, lastPos + 1);


	// now remove all the starting new lines
	while ( newStr[0] == '\n' || newStr[0] == '\t' ) newStr.erase(0, 1);
	return newStr;
}

bool SString::contains(const SString &str, bool bCaseSensative) const
{
	if (bCaseSensative) return (this->find(str, 0) == Utils::SString::npos) ? false : true;

	SString thisLower = this->lower();
	SString strLower = str.lower();
	return (thisLower.find(strLower, 0) == Utils::SString::npos) ? false : true;
}
bool SString::containsAny(const SString &str, bool bCaseSensative) const
{
	char *c = (char *)str.c_str();
	while (*c != 0)
	{
		char c1 = *c;

		c++;
	}

	return false;
}
bool SString::isin(const SString &str, bool bCaseSensative) const
{
	return contains(str, bCaseSensative);
}

int SString::findPos(const SString &find, int iStartPos) const
{
	Utils::SString::size_type pos = this->find(find, iStartPos);
	if ( pos == Utils::SString::npos ) return -1;
	return pos;
}

bool SString::isin(char c, bool bCaseSensative) const
{
	return contains(c, bCaseSensative);
}
bool SString::contains(char c, bool bCaseSensative) const
{
	bool f = false;
	for ( unsigned int i = 0; i < this->length(); i++ )
	{
		bool bCheck = (bCaseSensative) ? (this->at(i) == c) : (tolower(this->at(i)) == tolower(c));

		}
	}
	return f;
}

SString SString::between(const SString &before, const SString &after) const
{
	int pos = this->findPos(before);
	if ( pos >= 0 ) {
		pos += before.length();
		int end = this->findPos(after, pos);

	}

	return "";
}

SString SString::mid(int start, int end) const
{
	if (end <= 0)
		end = this->length() + end;
	return this->substr(start, end - start);
}
SString SString::left(long num) const
{
	if ( num < 0 )
		num = (long)this->length() + num;
	if ( num > (long)this->length() )
		num = (long)this->length();

	return this->substr(0, num);
}

SString SString::right(int num) const
{
	if ( num > 0 ) num -= (int)this->length();
	if ( num < -(int)this->length() ) num = -(int)this->length();

	return this->substr(-num);
}

const SString &SString::readToEndOfLine(FILE *id, int *line, bool upper)
{
	(*this) = "";
	char c = fgetc ( id );
	if ( c == -1 )
		return (*this);

	//	ToUpper ();

	return (*this);
}

char *SString::readToEndOfLine(char *data)
{
	return (char *)this->readToEndOfLine((unsigned char *)data);
}
unsigned char *SString::readToEndOfLine(unsigned char *data)
{
	int pos = 0;

	// do until we get a line break
	while ( (data[pos] != 13) && (data[pos] != 0) && (data[pos] != '\n') ) {


	if ( data[pos] == 0 ) return NULL;
	return data + (pos + 1);
}

SString SString::replaceToken(const char *token, int from, const SString &replace) const
{
	Utils::SString newstr;

	int whichtok = 1;
	Utils::SString::size_type lastPos = 0;
	Utils::SString::size_type pos     = _token_nextPos(token, 0);

	while (Utils::SString::npos != pos || Utils::SString::npos != lastPos)
	{
		if ( whichtok == from )
		{
			if ( newstr != "" ) newstr = newstr + token;
			newstr = newstr + replace;
		}
		else
		{
			if ( newstr != "" ) newstr = newstr + token;
			newstr = newstr + Utils::SString(this->substr(lastPos, pos - lastPos));
		}

		// Found a token, add it to the vector.
		whichtok++;


	}
	return newstr;
}


SString *SString::tokenise(const char *token, int *max) const
{
	if ( empty() ) {
		*max = 0;
		return NULL;
	}

	if ( (*max) <= 0 ) {
		*max = 0;
		return NULL;
	}

	SString *newstr = (*max == 1) ? new SString : new SString[*max];

	int whichtok = 0;
	// get first token
	Utils::SString::size_type lastPos = 0;
	Utils::SString::size_type pos     = this->_token_nextPos(token, 0);

	while (Utils::SString::npos != pos || Utils::SString::npos != lastPos)
	{
		// set token
		if ( *max == 1 ) *newstr = this->substr(lastPos, pos - lastPos);
		else			  newstr[whichtok] = this->substr(lastPos, pos - lastPos);


	}

	return newstr;
}

const SString &SString::removeChar(const char *cs)
{
	char *current = const_cast<char *>(cs);
	while ( current[0] != '\0' ) {
		removeChar(current[0]);
		++current;
	}

	return (*this);
}

const SString &SString::removeChar(char c)
{
	Utils::SString::size_type pos = this->find_first_of(c, 0);
	while(pos != Utils::SString::npos) {
		this->erase(pos, 1);
		pos = this->find_first_of(c, 0);
	}

	return (*this);
}

SString SString::remove(char c) const
{
	SString newStr = *this;

	Utils::SString::size_type pos = newStr.find_first_of(c, 0);
	while(pos != Utils::SString::npos) {
		newStr.erase(pos, 1);
		pos = newStr.find_first_of(c, 0);
	}

	return newStr;
}

bool SString::_isCharNumber(char c) const
{
	return (c >= '0' && c <= '9') ? true : false;
}

bool SString::isCharNumber(int c) const
{
	return _isCharNumber(this->at(c));
}

bool SString::isNumber(bool integer) const
{
	bool foundpoint = integer;
	for ( int i = 0; i < (int)this->length(); i++ )
	{
		// check for a decimal point (floating point value)

		else if ( !this->isCharNumber(i) ) return false;
	}
	return true;
}

const SString &SString::removeFirstSpace()
{
	Utils::SString::size_type pos = this->find_first_not_of(" \t\f\v\n\r", 0);
	if ( pos != Utils::SString::npos ) {
		this->erase(0, pos);
	}
	else
		this->clear();
	return (*this);
}
const SString &SString::removeEndSpace()
{
	Utils::SString::size_type pos = this->find_last_not_of(" \t\f\v\n\r");
	if ( pos != Utils::SString::npos ) {
		this->erase(pos + 1);
	}
	else
		this->clear();
	return (*this);
}

const SString &SString::truncate(int iNum)
{
	size_t pos = iNum;
	if ( iNum < 0 ) pos = this->length() + iNum;
	this->erase(pos, this->length() - pos);
	return (*this);
}

SString SString::lower() const
{
	Utils::SString newStr(*this);
	std::transform(this->begin(), this->end(), newStr.begin(), tolower);
	return newStr;
}

SString SString::upper() const
{
	Utils::SString newStr(*this);
	std::transform(this->begin(), this->end(), newStr.begin(), toupper);
	return newStr;
}
const SString &SString::toLower()
{
	std::transform(this->begin(), this->end(), this->begin(), tolower);
	return (*this);
}

const SString &SString::toUpper()
{
	std::transform(this->begin(), this->end(), this->begin(), toupper);
	return (*this);
}

const SString &SString::toFilename()
{
	(*this) = (*this).findReplace("\\", "/").findReplace("//", "/");
	return (*this);
}
SString SString::asFilename() const
{
	Utils::SString sFile(*this);
	return sFile.toFilename();
}

int SString::compareVersion(const Utils::SString &sV) const
{
	Utils::SString thisStr = (*this);
	Utils::SString checkStr = sV;

	int section = 1;

	// remove any rc/beta version
	int beta1 = 0;

	}

	bool isDecimal = thisStr.countToken(".") == 2 && checkStr.countToken(".") == 2;

	while ( true ) {
		Utils::SString sNum1 = thisStr.token(".", section);
		Utils::SString sNum2 = checkStr.token(".", section);

		// no number nubmers, must be the same
		if ( sNum1.empty() && sNum2.empty() ) {
			// compare the beta/rc version
			if ( beta1 == beta2 )

	}

	return COMPARE_SAME;
}

bool SString::match(const Utils::SString &pattern) const
{
	enum State {
		Exact,      // exact match
		Any,		// ?
		AnyRepeat   // *

Rev 186	Rev 188
Line 4...	Line 4...
4	`#include <stdarg.h>`	4	`#include <stdarg.h>`
5	`#include <algorithm>`	5	`#include <algorithm>`
6	`#include <iomanip>`	6	`#include <iomanip>`
7	`#include <locale>`	7	`#include <locale>`
8	`#include <codecvt>`	8	`#include <codecvt>`
-		9
-		10	`#include "WString.h"`
9		11
10	`namespace Utils {`	12	`namespace Utils {`
11		13
12	`std::wstring s2ws(const std::string& str)`	14	`std::wstring s2ws(const std::string& str)`
13	`{`	15	`{`
Line 31...	Line 33...
31		33
32	`return converterX.to_bytes(wstr);`	34	`return converterX.to_bytes(wstr);`
33	`}`	35	`}`
34		36
35		37
36	`String operator+(const char* str1, const String& str2)`	38	`SString operator+(const char* str1, const SString& str2)`
37	`{`	39	`{`
38	`return String(str1) + str2;`	40	`return SString(str1) + str2;`
39	`}`	41	`}`
40	`String operator+(const unsigned char* str1, const String& str2)`	42	`SString operator+(const unsigned char* str1, const SString& str2)`
41	`{`	43	`{`
42	`return String(str1) + str2;`	44	`return SString(str1) + str2;`
43	`}`	45	`}`
44		46
45	`String::String(void) { this->assign(""); }`	47	`SString::SString(void) { this->assign(""); }`
46	`String::String(const char *str) { this->assign(str); }`	48	`SString::SString(const char *str) { this->assign(str); }`
47	`String::String(const unsigned char str) { this->assign((const char )str); }`	49	`SString::SString(const unsigned char str) { this->assign((const char )str); }`
48	`String::String(const std::string &str) { this->assign(str);}`	50	`SString::SString(const std::string &str) { this->assign(str);}`
49	`String::String(const unsigned char c) { this->assign(1, c); }`	51	`SString::SString(const unsigned char c) { this->assign(1, c); }`
50	`String::String(const char c) { this->assign(1, c); }`	52	`SString::SString(const char c) { this->assign(1, c); }`
51	`String::String(const String &str) { this->assign(str); }`	53	`SString::SString(const SString &str) { this->assign(str); }`
52	`String::String(long l) { this->fromLong(l); }`	54	`SString::SString(long l) { this->fromLong(l); }`
53	`String::String(unsigned long l) { this->fromLong((long)l); }`	55	`SString::SString(unsigned long l) { this->fromLong((long)l); }`
54	`String::String(float f) { this->fromFloat(f); }`	56	`SString::SString(float f) { this->fromFloat(f); }`
55	`String::String(double f) { this->fromDouble(f); }`	57	`SString::SString(double f) { this->fromDouble(f); }`
56		58
57	`String::~String(void)`	59	`SString::~SString(void)`
58	`{`	60	`{`
59	`}`	61	`}`
60		62
61	`String String::PadNumber(long iNumber, int iAmount)`	63	`SString SString::PadNumber(long iNumber, int iAmount)`
62	`{`	64	`{`
63	`String str(iNumber);`	65	`SString str(iNumber);`
64	`return str.padNumber(iAmount);`	66	`return str.padNumber(iAmount);`
65	`}`	67	`}`
66		68
67	`const String &String::padNumber(int iAmount)`	69	`const SString &SString::padNumber(int iAmount)`
68	`{`	70	`{`
69	`return this->pad(iAmount, '0');`	71	`return this->pad(iAmount, '0');`
70	`}`	72	`}`
71		73
72	`const String &String::pad(int iAmount, char cWith)`	74	`const SString &SString::pad(int iAmount, char cWith)`
73	`{`	75	`{`
74	`std::stringstream strm;`	76	`std::stringstream strm;`
75	`strm << std::setw(iAmount) << std::setfill(cWith) << *this;`	77	`strm << std::setw(iAmount) << std::setfill(cWith) << *this;`
76	`*this = strm.str();`	78	`*this = strm.str();`
77	`return (*this);`	79	`return (*this);`
Line 79...	Line 81...
79		81
80		82
81	`/////////////////////////////////////////////////////////////////`	83	`/////////////////////////////////////////////////////////////////`
82	`// Conversion functions`	84	`// Conversion functions`
83		85
84	`void String::fromLong(long l)`	86	`void SString::fromLong(long l)`
85	`{`	87	`{`
86	`std::stringstream strstream;`	88	`std::stringstream strstream;`
87	`strstream << l;`	89	`strstream << l;`
88	`*this = strstream.str();`	90	`*this = strstream.str();`
89	`}`	91	`}`
90		92
91	`const String &String::fromFloat(float f, int dp)`	93	`const SString &SString::fromFloat(float f, int dp)`
92	`{`	94	`{`
93	`std::stringstream strstream;`	95	`std::stringstream strstream;`
94	`if ( dp != -1 ) {`	96	`if ( dp != -1 ) {`
95	`strstream.precision(dp);`	97	`strstream.precision(dp);`
96	`strstream << std::fixed << f;`	98	`strstream << std::fixed << f;`
97	`}`	99	`}`
98	`else`	100	`else`
99	`strstream << f;`	101	`strstream << f;`
100	`*this = strstream.str();`	102	`*this = strstream.str();`
101	`return (*this);`	103	`return (*this);`
102	`}`	104	`}`
103		105
104	`void String::fromDouble(double f)`	106	`void SString::fromDouble(double f)`
105	`{`	107	`{`
106	`std::stringstream strstream;`	108	`std::stringstream strstream;`
107	`strstream << f;`	109	`strstream << f;`
108	`*this = strstream.str();`	110	`*this = strstream.str();`
109	`}`	111	`}`
110		112
111	`const String &String::fromDouble(double f, int dp)`	113	`const SString &SString::fromDouble(double f, int dp)`
112	`{`	114	`{`
113	`std::stringstream strstream;`	115	`std::stringstream strstream;`
114	`if (dp != -1) {`	116	`if (dp != -1) {`
115	`strstream.precision(dp);`	117	`strstream.precision(dp);`
116	`strstream << std::fixed << f;`	118	`strstream << std::fixed << f;`
Line 119...	Line 121...
119	`strstream << f;`	121	`strstream << f;`
120	`*this = strstream.str();`	122	`*this = strstream.str();`
121	`return (*this);`	123	`return (*this);`
122	`}`	124	`}`
123		125
124	`const String &String::format(const char *sFormat, ...)`	126	`const SString &SString::format(const char *sFormat, ...)`
125	`{`	127	`{`
126	`char buffer[1024];`	128	`char buffer[1024];`
127	`va_list args;`	129	`va_list args;`
128	`va_start (args, sFormat);`	130	`va_start (args, sFormat);`
129	`vsprintf (buffer, sFormat, args);`	131	`vsprintf (buffer, sFormat, args);`
Line 131...	Line 133...
131		133
132	`this->assign(buffer);`	134	`this->assign(buffer);`
133	`return (*this);`	135	`return (*this);`
134	`}`	136	`}`
135		137
136	`const String String::args(const String *args, int max) const`	138	`const SString SString::args(const SString *args, int max) const`
137	`{`	139	`{`
138	`Utils::String str = (*this);`	140	`Utils::SString str = (*this);`
139	`for (int i = 0; i < max; i++)`	141	`for (int i = 0; i < max; i++)`
140	`{`	142	`{`
141	`Utils::String find("%");`	143	`Utils::SString find("%");`
142	`find += Utils::String::Number(i + 1);`	144	`find += Utils::SString::Number(i + 1);`
143		145
144	`str = str.findReplace(find, args[i]);`	146	`str = str.findReplace(find, args[i]);`
145	`}`	147	`}`
146		148
147	`return str;`	149	`return str;`
148	`}`	150	`}`
149	`const String &String::arg(const String &s1)`	151	`const SString &SString::arg(const SString &s1)`
150	`{`	152	`{`
151	`(*this) = this->findReplace("%1", s1);`	153	`(*this) = this->findReplace("%1", s1);`
152	`return (*this);`	154	`return (*this);`
153	`}`	155	`}`
154		156
155	`const String &String::arg(const String &s1, const String &s2)`	157	`const SString &SString::arg(const SString &s1, const SString &s2)`
156	`{`	158	`{`
157	`(*this) = this->arg(s1).findReplace("%2", s2);`	159	`(*this) = this->arg(s1).findReplace("%2", s2);`
158	`return (*this);`	160	`return (*this);`
159	`}`	161	`}`
160	`const String &String::arg(const String &s1, const String &s2, const String &s3)`	162	`const SString &SString::arg(const SString &s1, const SString &s2, const SString &s3)`
161	`{`	163	`{`
162	`(*this) = this->arg(s1, s1).findReplace("%3", s3);`	164	`(*this) = this->arg(s1, s1).findReplace("%3", s3);`
163	`return (*this);`	165	`return (*this);`
164	`}`	166	`}`
165	`const String &String::arg(const String &s1, const String &s2, const String &s3, const String &s4)`	167	`const SString &SString::arg(const SString &s1, const SString &s2, const SString &s3, const SString &s4)`
166	`{`	168	`{`
167	`(*this) = this->arg(s1, s2, s3).findReplace("%4", s4);`	169	`(*this) = this->arg(s1, s2, s3).findReplace("%4", s4);`
168	`return (*this);`	170	`return (*this);`
169	`}`	171	`}`
170	`const String &String::arg(const String &s1, const String &s2, const String &s3, const String &s4, const String &s5)`	172	`const SString &SString::arg(const SString &s1, const SString &s2, const SString &s3, const SString &s4, const SString &s5)`
171	`{`	173	`{`
172	`(*this) = this->arg(s1, s2, s3, s4).findReplace("%5", s5);`	174	`(*this) = this->arg(s1, s2, s3, s4).findReplace("%5", s5);`
173	`return (*this);`	175	`return (*this);`
174	`}`	176	`}`
175		177
176		178
177	`String String::Null()`	179	`SString SString::Null()`
178	`{`	180	`{`
179	`return Utils::String();`	181	`return Utils::SString();`
180	`}`	182	`}`
181		183
182	`String String::FromFloat(float f, int dp)`	184	`SString SString::FromFloat(float f, int dp)`
183	`{`	185	`{`
184	`String str;`	186	`SString str;`
185	`str.fromFloat(f, dp);`	187	`str.fromFloat(f, dp);`
186	`return str;`	188	`return str;`
187	`}`	189	`}`
188		190
189	`String String::Format(const char *sFormat, ...)`	191	`SString SString::Format(const char *sFormat, ...)`
190	`{`	192	`{`
191	`char buffer[1024];`	193	`char buffer[1024];`
192	`va_list args;`	194	`va_list args;`
193	`va_start (args, sFormat);`	195	`va_start (args, sFormat);`
194	`vsprintf (buffer, sFormat, args);`	196	`vsprintf (buffer, sFormat, args);`
195	`va_end (args);`	197	`va_end (args);`
196		198
197	`return String(buffer);`	199	`return SString(buffer);`
198	`}`	200	`}`
199		201
200	`bool String::toBool() const`	202	`bool SString::toBool() const`
201	`{`	203	`{`
202	`return atoi(this->c_str()) ? true : false;`	204	`return atoi(this->c_str()) ? true : false;`
203	`}`	205	`}`
204	`long String::toLong() const`	206	`long SString::toLong() const`
205	`{`	207	`{`
206	`return static_cast<long>(atoi(this->c_str()));`	208	`return static_cast<long>(atoi(this->c_str()));`
207	`}`	209	`}`
208	`int String::toInt() const`	210	`int SString::toInt() const`
209	`{`	211	`{`
210	`return static_cast<int>(atoi(this->c_str()));`	212	`return static_cast<int>(atoi(this->c_str()));`
211	`}`	213	`}`
212	`double String::toDouble() const`	214	`double SString::toDouble() const`
213	`{`	215	`{`
214	`return atof(this->c_str());`	216	`return atof(this->c_str());`
215	`}`	217	`}`
216	`float String::toFloat() const`	218	`float SString::toFloat() const`
217	`{`	219	`{`
218	`return (float)atof(this->c_str());`	220	`return (float)atof(this->c_str());`
-		221	`}`
-		222
-		223	`const Utils::WString SString::toWString() const`
-		224	`{`
-		225	`return s2ws(*this);`
219	`}`	226	`}`
220		227
221		228
222	`const String &String::operator= ( const char str ) { this->assign(str); return (this); }`	229	`const SString &SString::operator= ( const char str ) { this->assign(str); return (this); }`
223	`const String &String::operator= ( const unsigned char str ) { this->assign((const char )str); return (*this); }`	230	`const SString &SString::operator= ( const unsigned char str ) { this->assign((const char )str); return (*this); }`
224	`const String &String::operator= ( const String &str ) { this->assign((std::string &)str); return (*this); }`	231	`const SString &SString::operator= ( const SString &str ) { this->assign((std::string &)str); return (*this); }`
225	`const String &String::operator= ( const std::string &str ) { this->assign(str); return (*this); }`	232	`const SString &SString::operator= ( const std::string &str ) { this->assign(str); return (*this); }`
226	`const String &String::operator= ( unsigned char c ) { this->assign(1, c); return (*this); }`	233	`const SString &SString::operator= ( unsigned char c ) { this->assign(1, c); return (*this); }`
227	`const String &String::operator= ( char c ) { this->assign(1, c); return (*this); }`	234	`const SString &SString::operator= ( char c ) { this->assign(1, c); return (*this); }`
228	`const String &String::operator= ( long l ) { this->fromLong(l); return (*this); }`	235	`const SString &SString::operator= ( long l ) { this->fromLong(l); return (*this); }`
229	`const String &String::operator= ( unsigned long l ) { this->fromLong(l); return (*this); }`	236	`const SString &SString::operator= ( unsigned long l ) { this->fromLong(l); return (*this); }`
230	`const String &String::operator= ( float f ) { this->fromFloat(f); return (*this); }`	237	`const SString &SString::operator= ( float f ) { this->fromFloat(f); return (*this); }`
231	`const String &String::operator= ( double f ) { this->fromDouble(f); return (*this); }`	238	`const SString &SString::operator= ( double f ) { this->fromDouble(f); return (*this); }`
232		239
233	`const unsigned char String::operator[] ( int num ) const { return this->at(num); }`	240	`const unsigned char SString::operator[] ( int num ) const { return this->at(num); }`
234	`unsigned char &String::operator[] ( int num ) { return (unsigned char &)this->at(num); }`	241	`unsigned char &SString::operator[] ( int num ) { return (unsigned char &)this->at(num); }`
235		242
236	`const String &String::operator+= ( const char str ) { this->append(str); return (this); }`	243	`const SString &SString::operator+= ( const char str ) { this->append(str); return (this); }`
237	`const String &String::operator+= ( const unsigned char str ) { this->append((const char )str); return (*this); }`	244	`const SString &SString::operator+= ( const unsigned char str ) { this->append((const char )str); return (*this); }`
238	`const String &String::operator+= ( const std::string &str ) { this->append(str); return (*this); }`	245	`const SString &SString::operator+= ( const std::string &str ) { this->append(str); return (*this); }`
239	`const String &String::operator+= ( const String &str ) { this->append(str); return (*this); }`	246	`const SString &SString::operator+= ( const SString &str ) { this->append(str); return (*this); }`
240	`const String &String::operator+= ( const char c ) { this->append(1, c); return (*this); }`	247	`const SString &SString::operator+= ( const char c ) { this->append(1, c); return (*this); }`
241	`const String &String::operator+= ( const unsigned char c ) { this->append(1, c); return (*this); }`	248	`const SString &SString::operator+= ( const unsigned char c ) { this->append(1, c); return (*this); }`
242	`const String &String::operator+= ( const unsigned long l )`	249	`const SString &SString::operator+= ( const unsigned long l )`
243	`{`	250	`{`
244	`std::stringstream strm;`	251	`std::stringstream strm;`
245	`strm << (*this) << l;`	252	`strm << (*this) << l;`
246	`strm >> (*this);`	253	`strm >> (*this);`
247	`return (*this);`	254	`return (*this);`
248	`}`	255	`}`
249	`const String &String::operator+= ( const long l )`	256	`const SString &SString::operator+= ( const long l )`
250	`{`	257	`{`
251	`std::stringstream strm;`	258	`std::stringstream strm;`
252	`strm << (*this) << l;`	259	`strm << (*this) << l;`
253	`*this = strm.str();`	260	`*this = strm.str();`
254	`return (*this);`	261	`return (*this);`
255	`}`	262	`}`
256	`const String &String::operator+= ( const float f )`	263	`const SString &SString::operator+= ( const float f )`
257	`{`	264	`{`
258	`std::stringstream strm;`	265	`std::stringstream strm;`
259	`strm << (*this) << f;`	266	`strm << (*this) << f;`
260	`*this = strm.str();`	267	`*this = strm.str();`
261	`return (*this);`	268	`return (*this);`
262	`}`	269	`}`
263	`const String &String::operator+= ( const double f )`	270	`const SString &SString::operator+= ( const double f )`
264	`{`	271	`{`
265	`std::stringstream strm;`	272	`std::stringstream strm;`
266	`strm << (*this) << f;`	273	`strm << (*this) << f;`
267	`*this = strm.str();`	274	`*this = strm.str();`
268	`return (*this);`	275	`return (*this);`
269	`}`	276	`}`
270		277
271		278
272	`String String::operator+ ( const char str ) const { return String(this) += str; }`	279	`SString SString::operator+ ( const char str ) const { return SString(this) += str; }`
273	`String String::operator+ ( const unsigned char str ) const { return String(this) += str; }`	280	`SString SString::operator+ ( const unsigned char str ) const { return SString(this) += str; }`
274	`String String::operator+ ( const std::string &str ) const { return String(*this) += str; }`	281	`SString SString::operator+ ( const std::string &str ) const { return SString(*this) += str; }`
275	`String String::operator+ ( const String &str ) const { return String(*this) += str; }`	282	`SString SString::operator+ ( const SString &str ) const { return SString(*this) += str; }`
276	`String String::operator+ ( const char c ) const { return String(*this) += c; }`	283	`SString SString::operator+ ( const char c ) const { return SString(*this) += c; }`
277	`String String::operator+ ( const unsigned char c ) const { return String(*this) += c; }`	284	`SString SString::operator+ ( const unsigned char c ) const { return SString(*this) += c; }`
278	`String String::operator+ ( const long l ) const { return String(*this) += l; }`	285	`SString SString::operator+ ( const long l ) const { return SString(*this) += l; }`
279	`String String::operator+ ( const unsigned long l ) const { return String(*this) += l; }`	286	`SString SString::operator+ ( const unsigned long l ) const { return SString(*this) += l; }`
280	`String String::operator+ ( const float f ) const { return String(*this) += f; }`	287	`SString SString::operator+ ( const float f ) const { return SString(*this) += f; }`
281	`String String::operator+ ( const double f ) const { return String(*this) += f; }`	288	`SString SString::operator+ ( const double f ) const { return SString(*this) += f; }`
282		289
283	`bool String::operator== ( const char *str ) const { return (this->compare(str)) ? false : true; }`	290	`bool SString::operator== ( const char *str ) const { return (this->compare(str)) ? false : true; }`
284	`bool String::operator== ( const unsigned char str ) const { return (this->compare((const char )str)) ? false : true; }`	291	`bool SString::operator== ( const unsigned char str ) const { return (this->compare((const char )str)) ? false : true; }`
285	`bool String::operator== ( const std::string &str ) const { return (this->compare(str)) ? false : true; }`	292	`bool SString::operator== ( const std::string &str ) const { return (this->compare(str)) ? false : true; }`
286	`bool String::operator== ( const String &str ) const { return (this->compare(str)) ? false : true; }`	293	`bool SString::operator== ( const SString &str ) const { return (this->compare(str)) ? false : true; }`
287		294
288	`bool String::operator!= ( const char *str ) const { return (this->compare(str)) ? true : false; }`	295	`bool SString::operator!= ( const char *str ) const { return (this->compare(str)) ? true : false; }`
289	`bool String::operator!= ( const unsigned char str ) const { return (this->compare((const char )str)) ? true : false; }`	296	`bool SString::operator!= ( const unsigned char str ) const { return (this->compare((const char )str)) ? true : false; }`
290	`bool String::operator!= ( const std::string &str ) const { return (this->compare(str)) ? true : false; }`	297	`bool SString::operator!= ( const std::string &str ) const { return (this->compare(str)) ? true : false; }`
291	`bool String::operator!= ( const String &str ) const { return (this->compare(str)) ? true : false; }`	298	`bool SString::operator!= ( const SString &str ) const { return (this->compare(str)) ? true : false; }`
292		299
293	`bool String::operator !() const`	300	`bool SString::operator !() const`
294	`{`	301	`{`
295	`return this->empty();`	302	`return this->empty();`
296	`}`	303	`}`
297		304
298	`bool String::Compare(const String &str, bool bCaseSensative) const`	305	`bool SString::Compare(const SString &str, bool bCaseSensative) const`
299	`{`	306	`{`
300	`if ( bCaseSensative ) {`	307	`if ( bCaseSensative ) {`
301	`return (this->compare(str) == 0) ? true : false;`	308	`return (this->compare(str) == 0) ? true : false;`
302	`}`	309	`}`
303		310
Line 308...	Line 315...
308	`}`	315	`}`
309	`}`	316	`}`
310	`return true;`	317	`return true;`
311	`}`	318	`}`
312		319
313	`bool String::Compare(const unsigned char *str, bool bCaseSensative) const`	320	`bool SString::Compare(const unsigned char *str, bool bCaseSensative) const`
314	`{`	321	`{`
315	`return this->Compare((const char *)str, bCaseSensative);`	322	`return this->Compare((const char *)str, bCaseSensative);`
316	`}`	323	`}`
317		324
318	`bool String::Compare(const char *str, bool bCaseSensative) const`	325	`bool SString::Compare(const char *str, bool bCaseSensative) const`
319	`{`	326	`{`
320	`if ( bCaseSensative ) {`	327	`if ( bCaseSensative ) {`
321	`return (this->compare(str) == 0) ? true : false;`	328	`return (this->compare(str) == 0) ? true : false;`
322	`}`	329	`}`
323		330
Line 329...	Line 336...
329	`}`	336	`}`
330		337
331	`return true;`	338	`return true;`
332	`}`	339	`}`
333		340
334	`String String::token(const char *token, int tok) const`	341	`SString SString::token(const char *token, int tok) const`
335	`{`	342	`{`
336	`return this->tokens(token, tok, tok);`	343	`return this->tokens(token, tok, tok);`
337	`}`	344	`}`
338		345
339	`String String::tokens(const char *token, int from, int to) const`	346	`SString SString::tokens(const char *token, int from, int to) const`
340	`{`	347	`{`
341	`if ( this->empty() ) return "";`	348	`if ( this->empty() ) return "";`
342		349
343	`int max = this->countToken(token);`	350	`int max = this->countToken(token);`
344		351
345	`Utils::String newstr;`	352	`Utils::SString newstr;`
346		353
347	`int whichtok = 1;`	354	`int whichtok = 1;`
348	`Utils::String::size_type lastPos = 0;`	355	`Utils::SString::size_type lastPos = 0;`
349	`Utils::String::size_type pos = _token_nextPos(token, 0);`	356	`Utils::SString::size_type pos = _token_nextPos(token, 0);`
350		357
351	`if ( from < 0 )`	358	`if ( from < 0 )`
352	`from = max + (from + 1);`	359	`from = max + (from + 1);`
353	`if ( to < 0 )`	360	`if ( to < 0 )`
354	`to = max + (to + 1);`	361	`to = max + (to + 1);`
355		362
356	`while (Utils::String::npos != pos \|\| Utils::String::npos != lastPos)`	363	`while (Utils::SString::npos != pos \|\| Utils::SString::npos != lastPos)`
357	`{`	364	`{`
358	`if ( to == 0 )`	365	`if ( to == 0 )`
359	`{`	366	`{`
360	`if ( whichtok >= from )`	367	`if ( whichtok >= from )`
361	`{`	368	`{`
362	`if ( newstr != "" ) newstr = newstr + token;`	369	`if ( newstr != "" ) newstr = newstr + token;`
363	`newstr = newstr + Utils::String(this->substr(lastPos, pos - lastPos));`	370	`newstr = newstr + Utils::SString(this->substr(lastPos, pos - lastPos));`
364	`}`	371	`}`
365	`}`	372	`}`
366	`else`	373	`else`
367	`{`	374	`{`
368	`if ( (whichtok >= from) && (whichtok <= to) )`	375	`if ( (whichtok >= from) && (whichtok <= to) )`
369	`{`	376	`{`
370	`if ( newstr != "" ) newstr = newstr + token;`	377	`if ( newstr != "" ) newstr = newstr + token;`
371	`newstr = newstr + Utils::String(this->substr(lastPos, pos - lastPos));`	378	`newstr = newstr + Utils::SString(this->substr(lastPos, pos - lastPos));`
372	`}`	379	`}`
373	`if ( whichtok > to )`	380	`if ( whichtok > to )`
374	`break;`	381	`break;`
375	`}`	382	`}`
376	`// Found a token, add it to the vector.`	383	`// Found a token, add it to the vector.`
Line 393...	Line 400...
393	`pos = _token_nextPos(token, lastPos);`	400	`pos = _token_nextPos(token, lastPos);`
394	`}`	401	`}`
395	`return newstr;`	402	`return newstr;`
396	`}`	403	`}`
397		404
398	`String String::remToken(const char* token, int from) const`	405	`SString SString::remToken(const char* token, int from) const`
399	`{`	406	`{`
400	`Utils::String newstr;`	407	`Utils::SString newstr;`
401		408
402	`if (from < 0)`	409	`if (from < 0)`
403	`{`	410	`{`
404	`int maxT = this->countToken(token);`	411	`int maxT = this->countToken(token);`
405	`from = maxT + (from + 1);`	412	`from = maxT + (from + 1);`
406	`}`	413	`}`
407		414
408	`int whichtok = 1;`	415	`int whichtok = 1;`
409	`Utils::String::size_type lastPos = 0;`	416	`Utils::SString::size_type lastPos = 0;`
410	`Utils::String::size_type pos = _token_nextPos(token, 0);`	417	`Utils::SString::size_type pos = _token_nextPos(token, 0);`
411		418
412	`while (Utils::String::npos != pos \|\| Utils::String::npos != lastPos)`	419	`while (Utils::SString::npos != pos \|\| Utils::SString::npos != lastPos)`
413	`{`	420	`{`
414	`if (whichtok != from)`	421	`if (whichtok != from)`
415	`{`	422	`{`
416	`if (newstr != "") newstr = newstr + token;`	423	`if (newstr != "") newstr = newstr + token;`
417	`newstr = newstr + Utils::String(this->substr(lastPos, pos - lastPos));`	424	`newstr = newstr + Utils::SString(this->substr(lastPos, pos - lastPos));`
418	`}`	425	`}`
419		426
420	`// Found a token, add it to the vector.`	427	`// Found a token, add it to the vector.`
421	`whichtok++;`	428	`whichtok++;`
422		429
Line 437...	Line 444...
437	`pos = _token_nextPos(token, lastPos);`	444	`pos = _token_nextPos(token, lastPos);`
438	`}`	445	`}`
439	`return newstr;`	446	`return newstr;`
440	`}`	447	`}`
441		448
442	`String String::remTokens(const char* token, int from, int to) const`	449	`SString SString::remTokens(const char* token, int from, int to) const`
443	`{`	450	`{`
444	`Utils::String newstr;`	451	`Utils::SString newstr;`
445		452
446	`if (from < 0)`	453	`if (from < 0)`
447	`{`	454	`{`
448	`int maxT = this->countToken(token);`	455	`int maxT = this->countToken(token);`
449	`from = maxT + (from + 1);`	456	`from = maxT + (from + 1);`
Line 453...	Line 460...
453	`int maxT = this->countToken(token);`	460	`int maxT = this->countToken(token);`
454	`to = maxT + (to + 1);`	461	`to = maxT + (to + 1);`
455	`}`	462	`}`
456		463
457	`int whichtok = 1;`	464	`int whichtok = 1;`
458	`Utils::String::size_type lastPos = 0;`	465	`Utils::SString::size_type lastPos = 0;`
459	`Utils::String::size_type pos = _token_nextPos(token, 0);`	466	`Utils::SString::size_type pos = _token_nextPos(token, 0);`
460		467
461	`while (Utils::String::npos != pos \|\| Utils::String::npos != lastPos)`	468	`while (Utils::SString::npos != pos \|\| Utils::SString::npos != lastPos)`
462	`{`	469	`{`
463	`if (!(whichtok >= from && whichtok <= to))`	470	`if (!(whichtok >= from && whichtok <= to))`
464	`{`	471	`{`
465	`if (newstr != "") newstr = newstr + token;`	472	`if (newstr != "") newstr = newstr + token;`
466	`newstr = newstr + Utils::String(this->substr(lastPos, pos - lastPos));`	473	`newstr = newstr + Utils::SString(this->substr(lastPos, pos - lastPos));`
467	`}`	474	`}`
468		475
469	`// Found a token, add it to the vector.`	476	`// Found a token, add it to the vector.`
470	`whichtok++;`	477	`whichtok++;`
471		478
Line 486...	Line 493...
486	`pos = _token_nextPos(token, lastPos);`	493	`pos = _token_nextPos(token, lastPos);`
487	`}`	494	`}`
488	`return newstr;`	495	`return newstr;`
489	`}`	496	`}`
490		497
491	`String String::word(int word) const`	498	`SString SString::word(int word) const`
492	`{`	499	`{`
493	`return this->token(" ", word);`	500	`return this->token(" ", word);`
494	`}`	501	`}`
495	`String String::words(int from, int to) const`	502	`SString SString::words(int from, int to) const`
496	`{`	503	`{`
497	`return this->tokens(" ", from, to);`	504	`return this->tokens(" ", from, to);`
498	`}`	505	`}`
499		506
500	`String String::addToken(const char *token, const Utils::String &str) const`	507	`SString SString::addToken(const char *token, const Utils::SString &str) const`
501	`{`	508	`{`
502	`if (this->empty())`	509	`if (this->empty())`
503	`return str;`	510	`return str;`
504		511
505	`Utils::String s = (*this);`	512	`Utils::SString s = (*this);`
506	`s += token;`	513	`s += token;`
507	`s += str;`	514	`s += str;`
508		515
509	`return s;`	516	`return s;`
510	`}`	517	`}`
511		518
512	`int String::countToken(const char *token) const`	519	`int SString::countToken(const char *token) const`
513	`{`	520	`{`
514	`if ( this->empty() )`	521	`if ( this->empty() )`
515	`return 0;`	522	`return 0;`
516		523
517	`// finds the number of tokens in a string`	524	`// finds the number of tokens in a string`
518	`int found = 1;`	525	`int found = 1;`
519		526
520	`Utils::String tmpstr = *this;`	527	`Utils::SString tmpstr = *this;`
521		528
522	`// ignore the initial spaces`	529	`// ignore the initial spaces`
523	`Utils::String::size_type pos = this->find_first_not_of(token, 0);`	530	`Utils::SString::size_type pos = this->find_first_not_of(token, 0);`
524		531
525	`// remove end spaces`	532	`// remove end spaces`
526	`size_t i = tmpstr.size() - 1;`	533	`size_t i = tmpstr.size() - 1;`
527	`while ( tmpstr[i] == ' ' && i > 0 )`	534	`while ( tmpstr[i] == ' ' && i > 0 )`
528	`i--;`	535	`i--;`
529	`if ( i <= 0 ) return 0;`	536	`if ( i <= 0 ) return 0;`
530	`tmpstr.erase ( i + 1, tmpstr.size() - i );`	537	`tmpstr.erase ( i + 1, tmpstr.size() - i );`
531		538
532	`// count tokens`	539	`// count tokens`
533	`pos = tmpstr.find (token,pos + 1);`	540	`pos = tmpstr.find (token,pos + 1);`
534	`while ( pos < Utils::String::npos )`	541	`while ( pos < Utils::SString::npos )`
535	`{`	542	`{`
536	`while (tmpstr[pos] == ' ')`	543	`while (tmpstr[pos] == ' ')`
537	`pos++;`	544	`pos++;`
538	`found++;`	545	`found++;`
539	`pos = tmpstr.find (token,pos + 1);`	546	`pos = tmpstr.find (token,pos + 1);`
Line 541...	Line 548...
541		548
542	`// return number of tokens`	549	`// return number of tokens`
543	`return found;`	550	`return found;`
544	`}`	551	`}`
545		552
546	`Utils::String::size_type String::_token_nextPos(const char *token, Utils::String::size_type curPos) const`	553	`Utils::SString::size_type SString::_token_nextPos(const char *token, Utils::SString::size_type curPos) const`
547	`{`	554	`{`
548	`bool found = false;`	555	`bool found = false;`
549	`Utils::String::size_type startPos = 0;`	556	`Utils::SString::size_type startPos = 0;`
550	`size_t max = strlen(token);`	557	`size_t max = strlen(token);`
551	`while ( !found ) {`	558	`while ( !found ) {`
552	`found = true;`	559	`found = true;`
553	`startPos = this->find_first_of(token[0], curPos);`	560	`startPos = this->find_first_of(token[0], curPos);`
554	`if ( startPos == Utils::String::npos ) {`	561	`if ( startPos == Utils::SString::npos ) {`
555	`startPos = this->length();`	562	`startPos = this->length();`
556	`break;`	563	`break;`
557	`}`	564	`}`
558		565
559	`Utils::String::size_type pos = startPos;`	566	`Utils::SString::size_type pos = startPos;`
560	`size_t i = 1;`	567	`size_t i = 1;`
561	`while ( i < max )`	568	`while ( i < max )`
562	`{`	569	`{`

Subversion Repositories spk

(root)//libspk/src/Utils/String.cpp – Rev 186 → 188