Subversion Repositories spk

#include "String.h"

#include <sstream>

#include <stdarg.h>

#include <algorithm>

namespace Utils {

String operator+(const char *str1, const String &str2)

{

	return String(str1) + str2;

}

String::String(void)						{ this->assign(""); }

String::String(const char *str)				{ this->assign(str); }

String::String(const unsigned char *str)	{ this->assign((const char *)str); }

String::String(const std::string &str)		{ this->assign(str);}

String::String(const unsigned char c)		{ this->assign(1, c); }

String::String(const char c)				{ this->assign(1, c); }

String::String(const String &str)			{ this->assign(str); }

String::String(long l)						{ this->fromLong(l); }

String::String(unsigned long l)				{ this->fromLong((long)l); }

String::String(float f)						{ this->fromFloat(f); }

String::String(double f)					{ this->fromDouble(f); }

String::~String(void)

{

}

/////////////////////////////////////////////////////////////////

// Conversion functions

void String::fromLong(long l)

{

	std::stringstream strstream;

	strstream << l;

	*this = strstream.str();

}

void String::fromFloat(float f, int dp)

{

	std::stringstream strstream;

	strstream.precision(dp);

	strstream << std::fixed << f;

	*this = strstream.str();

}

void String::fromFloat(float f)

{

	std::stringstream strstream;

	strstream << f;

	*this = strstream.str();

}

void String::fromDouble(double f)

{

	std::stringstream strstream;

	strstream << f;

	*this = strstream.str();

}

const String &String::format(const char *sFormat, ...)

{

	char buffer[1024];

	va_list args;

	va_start (args, sFormat);

	vsprintf (buffer, sFormat, args);

	va_end (args);

	this->assign(buffer);

	return (*this);

}

String String::fromFormat(const char *sFormat, ...)

{

	char buffer[1024];

	va_list args;

	va_start (args, sFormat);

	vsprintf (buffer, sFormat, args);

	va_end (args);

	return String(buffer);

}

long String::toLong() const

{

	return atoi(this->c_str());

}

double String::toDouble() const

{

	return atof(this->c_str());

}

float String::toFloat() const

{

	return (float)atof(this->c_str());

}

const String &String::operator= ( const char *str )				{ this->assign(str); return (*this); }

const String &String::operator= ( const unsigned char *str )	{ this->assign((const char *)str); return (*this); }

const String &String::operator= ( const String &str )			{ this->assign((std::string &)str); return (*this); }

const String &String::operator= ( const std::string &str )		{ this->assign(str); return (*this); }

const String &String::operator= ( unsigned char c )				{ this->assign(1, c); return (*this); }

const String &String::operator= ( char c )						{ this->assign(1, c); return (*this); }

const String &String::operator= ( long l )						{ this->fromLong(l); return (*this); }

const String &String::operator= ( unsigned long l )				{ this->fromLong(l); return (*this); }

const String &String::operator= ( float f )						{ this->fromFloat(f); return (*this); }

const String &String::operator= ( double f )					{ this->fromDouble(f); return (*this); }

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

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

const String &String::operator+= ( const char *str )			{ this->append(str); return (*this); }

const String &String::operator+= ( const unsigned char *str ) 	{ this->append((const char *)str); return (*this); }

const String &String::operator+= ( const std::string &str )		{ this->append(str); return (*this); }

const String &String::operator+= ( const String &str )		{ this->append(str); return (*this); }

const String &String::operator+= ( const char c )				{ this->append(1, c); return (*this); }

const String &String::operator+= ( const unsigned char c )		{ this->append(1, c); return (*this); }

const String &String::operator+= ( const unsigned long l )		

{ 

	std::stringstream strm;

	strm << (*this) << l;

	strm >> (*this);

	return (*this); 

}

const String &String::operator+= ( const long l )		

{ 

	std::stringstream strm;

	strm << (*this) << l;

	*this = strm.str();

	return (*this); 

}

const String &String::operator+= ( const float f )		

{ 

	std::stringstream strm;

	strm << (*this) << f;

	*this = strm.str();

	return (*this); 

}

const String &String::operator+= ( const double f )		

{ 

	std::stringstream strm;

	strm << (*this) << f;

	*this = strm.str();

	return (*this); 

}

String String::operator+ ( const char *str ) const			{ return String(*this) += str; }

String String::operator+ ( const unsigned char *str ) const	{ return String(*this) += str; }

String String::operator+ ( const std::string &str ) const	{ return String(*this) += str; }

String String::operator+ ( const String &str ) const		{ return String(*this) += str; }

String String::operator+ ( const char c ) const				{ return String(*this) += c; }

String String::operator+ ( const unsigned char c ) const	{ return String(*this) += c; }

String String::operator+ ( const long l ) const				{ return String(*this) += l; }

String String::operator+ ( const unsigned long l ) const	{ return String(*this) += l; }

String String::operator+ ( const float f ) const			{ return String(*this) += f; }

String String::operator+ ( const double f ) const			{ return String(*this) += f; }

bool String::operator== ( const char *str ) const				{ return (this->compare(str)) ? false : true; }

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

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

bool String::operator== ( const String &str ) const			{ return (this->compare(str)) ? false : true; }

bool String::operator!= ( const char *str ) const				{ return (this->compare(str)) ? true : false; }

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

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

bool String::operator!= ( const String &str ) const			{ return (this->compare(str)) ? true : false; }

bool String::Compare(const String &str, bool bCaseSensative) const

{

	if ( bCaseSensative ) {

		return (this->compare(str) == 0) ? true : false;

	}

	if ( str.length() != this->length() ) return false;

	for ( unsigned int i = 0; i < str.length(); i++ ) {

		if ( tolower(this->at(i)) != tolower(str[i]) ) {

			return false;

		}

	}

	return true;

}

bool String::Compare(const unsigned char *str, bool bCaseSensative) const

{

	return this->Compare((const char *)str, bCaseSensative);

}

bool String::Compare(const char *str, bool bCaseSensative) const

{

	if ( bCaseSensative ) {

		return (this->compare(str) == 0) ? true : false;

	}

	if ( strlen(str) != this->length() ) return false;

	for ( unsigned int i = 0; i < this->length(); i++ ) {

		if ( tolower(this->at(i)) != tolower(*(str + i)) ) {

			return false;

		}

	}

	return true;

}

String String::token(const char *token, int tok) const

{

	return this->tokens(token, tok, tok);

}

String String::tokens(const char *token, int from, int to) const

{

	if ( this->empty() ) return "";

	int max = this->countToken(token);

	std::string newstr;

	int whichtok = 1;

	std::string::size_type lastPos = 0;

	std::string::size_type pos     = _token_nextPos(token, 0);

	if ( from < 0 )

		from = max + (from + 1);

	if ( to < 0 )

		to = max + (to + 1);

	while (std::string::npos != pos || std::string::npos != lastPos)

	{

		if ( to == 0 )

		{

			if ( whichtok >= from )

			{

				if ( newstr != "" ) newstr = newstr + token;

				newstr = newstr + this->substr(lastPos, pos - lastPos);

			}

		}

		else

		{

			if ( (whichtok >= from) && (whichtok <= to) )

			{

				if ( newstr != "" ) newstr = newstr + token;

				newstr = newstr + this->substr(lastPos, pos - lastPos);

			}

			if ( whichtok > to )

				break;

		}

		// Found a token, add it to the vector.

		whichtok++;

		if ( pos >= this->length() )

			break;

		// skip past token

		size_t i = 0;

		size_t max = strlen(token);

		lastPos = pos;

		while ( (i < max) && (token[i] == this->at(lastPos)) )

		{

			++i;

			++lastPos;

		}

		// get the next token

		pos = _token_nextPos(token, lastPos);

	}

	return newstr;

}

String String::remToken(const char *token, int from) const

{

	std::string newstr;

	int whichtok = 1;

	std::string::size_type lastPos = 0;

	std::string::size_type pos     = _token_nextPos(token, 0);

	while (std::string::npos != pos || std::string::npos != lastPos)

	{

		if ( whichtok != from )

		{

			if ( newstr != "" ) newstr = newstr + token;

			newstr = newstr + this->substr(lastPos, pos - lastPos);

		}

		// Found a token, add it to the vector.

		whichtok++;

		if ( pos >= this->length() )

			break;

		// skip past token

		size_t i = 0;

		size_t max = strlen(token);

		lastPos = pos;

		while ( (i < max) && (token[i] == this->at(lastPos)) )

		{

			++i;

			++lastPos;

		}

		// get the next token

		pos = _token_nextPos(token, lastPos);

	}

	return newstr;

}

String String::word(int word) const

{

	return this->token(" ", word);

}

String String::words(int from, int to) const

{

	return this->tokens(" ", from, to);

}

int String::countToken(const char *token) const

{

	if ( this->empty() )

		return 0;

	// finds the number of tokens in a string

	int found = 1;

	std::string tmpstr = *this;

	// ignore the initial spaces

	std::string::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 < std::string::npos )

	{

		while (tmpstr[pos] == ' ')

			pos++;

		found++;

		pos = tmpstr.find (token,pos + 1);

	}

	// return number of tokens

	return found;

}

std::string::size_type String::_token_nextPos(const char *token, std::string::size_type curPos) const

{

	bool found = false;

	std::string::size_type startPos = 0;

	size_t max = strlen(token);

	while ( !found ) {

		found = true;

		startPos = this->find_first_of(token[0], curPos);

		if ( startPos == std::string::npos ) {

			startPos = this->length();

			break;

		}

		std::string::size_type pos = startPos;

		size_t i = 1;

		while ( i < max )

		{

			++pos;

			if ( this->at(pos) != token[i] )

			{

				found = false;

				break;

			}

			++i;

		}

		curPos = pos;

	}

	return startPos;

}

String String::findReplace(const String &find, const String &replace ) const

{

	std::string newstr = *this;

	std::string::size_type pos = newstr.find(find, 0);

	while ( pos < std::string::npos ) {

		newstr.replace(pos, find.length(), replace);

		pos = newstr.find(find, pos + replace.length());

	}

	return newstr;

}

bool String::isin(const String &str, bool bCaseSensative) const

{

	unsigned int check = 0;

	for ( unsigned int i = 0; i < this->length(); i++ )

	{

		bool bCheck	= (bCaseSensative) ? (this->at(i) == str[check]) : (tolower(this->at(i)) == tolower(str[check]));

		if ( bCheck )

			++check;

		else

			check = 0;

		if ( check >= str.length() )

			return true;

	}

	return false;

}

int String::findPos(const String &find, int iStartPos) const

{

	std::string::size_type pos = this->find(find, iStartPos);

	if ( pos == std::string::npos ) return -1;

	return pos;

}

bool String::isin(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));

		if ( bCheck ) {

			f = true;

			break;

		}

	}

	return f;

}

String String::mid(int start, int end) const

{

	return this->substr(start, end - start);

}

String String::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);

}

String String::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 String &String::readToEndOfLine(FILE *id, int *line, bool upper)

{

	(*this) == "";

	char c = fgetc ( id );

	if ( c == -1 )

		return (*this);

	while ( (c != 13) && (!feof(id)) && (c != '\n') )

	{

		(*this) += c;

		c = fgetc ( id );

	}

	if ( line )

		++(*line);

//	if ( upper )

	//	ToUpper ();

	return (*this);

}

char *String::readToEndOfLine(char *data)

{

	return (char *)this->readToEndOfLine((unsigned char *)data);

}

unsigned char *String::readToEndOfLine(unsigned char *data)

{

	int pos = 0;

	// do until we get a line break

	while ( (data[pos] != 13) && (data[pos] != 0) && (data[pos] != '\n') ) {

		++pos;

	}

	if ( !pos ) {

		this->clear();

	}

	else {

		if ( pos > 2000 ) {

			char *d = new char[pos + 1];

			memcpy(d, data, pos);

			d[pos] = 0;

			*this = d;

			delete d;

		}

		else {

			char d[2000];

			memcpy(d, data, pos);

			d[pos] = 0;

			*this = d;

		}

	}

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

	return data + (pos + 1);

}

String String::replaceToken(const char *token, int from, const String &replace) const

{

	std::string newstr;

	int whichtok = 1;

	std::string::size_type lastPos = 0;

	std::string::size_type pos     = _token_nextPos(token, 0);

	while (std::string::npos != pos || std::string::npos != lastPos)

	{

		if ( whichtok == from )

		{

			if ( newstr != "" ) newstr = newstr + token;

			newstr = newstr + replace;

		}

		else

		{

			if ( newstr != "" ) newstr = newstr + token;

			newstr = newstr + this->substr(lastPos, pos - lastPos);

		}

		// Found a token, add it to the vector.

		whichtok++;

		if ( pos >= this->length() )

			break;

		// skip past token

		size_t i = 0;

		size_t max = strlen(token);

		lastPos = pos;

		while ( (i < max) && (token[i] == this->at(lastPos)) )

		{

			++i;

			++lastPos;

		}

		// get the next token

		pos = _token_nextPos(token, lastPos);

	}

	return newstr;

}

String *String::tokenise(const char *token, int *max) const

{

	if ( empty() ) {

		*max = 0;

		return NULL;

	}

	*max = this->countToken(token);

	if ( (*max) <= 0 ) {

		*max = 0;

		return NULL;

	}

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

	int whichtok = 0;

	// get first token

	std::string::size_type lastPos = 0;

	std::string::size_type pos     = this->_token_nextPos(token, 0);

	while (std::string::npos != pos || std::string::npos != lastPos)

	{

		// set token

		if ( *max == 1 ) *newstr = this->substr(lastPos, pos - lastPos);

		else			  newstr[whichtok] = this->substr(lastPos, pos - lastPos);

		// move to next token

		whichtok++;

		if ( whichtok >= *max )

			break;

		if ( pos >= this->length() )

			break;

		// skip past token

		size_t i = 0;

		size_t max = strlen(token);

		lastPos = pos;

		while ( (i < max) && (token[i] == this->at(lastPos)) ) {

			++i;

			++lastPos;

		}

		// get the next token

		pos = _token_nextPos(token, lastPos);

	}

	return newstr;

}

const String &String::removeChar(char c)

{

	std::string::size_type pos = this->find_first_of(c, 0);

	while(pos != std::string::npos) {

		this->erase(pos, 1);

		pos = this->find_first_of(c, 0);

	}

	return (*this);

}

String String::remove(char c) const

{

	String newStr = *this;

	std::string::size_type pos = newStr.find_first_of(c, 0);

	while(pos != std::string::npos) {

		newStr.erase(pos, 1);

		pos = newStr.find_first_of(c, 0);

	}

	return newStr;

}

bool String::_isCharNumber(char c) const

{

	return (c >= '0' && c <= '9') ? true : false;

}

bool String::isCharNumber(int c) const

{

	return _isCharNumber(this->at(c));

}

bool String::isNumber(bool integer) const

{

	bool foundpoint = integer;

	for ( int i = 0; i < (int)this->length(); i++ )

	{

		// check for a decimal point (floating point value)

		// only allow 1 decimal point, or none if just checking for an integer

		if ( this->at(i) == '.' && !foundpoint ) foundpoint = true;

		// check if it is a number, 0-9

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

	}

	return true;

}

const String &String::removeFirstSpace()

{

	std::string::size_type pos = this->find_first_not_of(" \t\f\v\n\r", 0);

	if ( pos != std::string::npos ) {

		this->erase(0, pos);

	}

	return (*this);

}

const String &String::removeEndSpace()

{

	std::string::size_type pos = this->find_last_not_of(" \t\f\v\n\r");

	if ( pos != std::string::npos ) {

		this->erase(pos + 1);

	}

	return (*this);

}

const String &String::truncate(int iNum)

{

	size_t pos = iNum;

	if ( iNum < 0 ) pos = this->length() + iNum;

	this->erase(pos, this->length() - pos);

	return (*this);

}

String String::lower() const

{

	Utils::String newStr(*this);

	std::transform(this->begin(), this->end(), newStr.begin(), tolower);

	return newStr;

}

String String::upper() const

{

	Utils::String newStr(*this);

	std::transform(this->begin(), this->end(), newStr.begin(), toupper);

	return newStr;

}

const String &String::toLower()

{

	std::transform(this->begin(), this->end(), this->begin(), tolower);

	return (*this);

}

const String &String::toUpper()

{

	std::transform(this->begin(), this->end(), this->begin(), toupper);

	return (*this);

}

}//NAMESPACE