Subversion Repositories spk

#pragma once

#include <string>

#include "../spkdll.h"

#include "../spkdef.h"

//#define STRING_WCHAR

enum {

	COMPARE_SAME		= 0,

	COMPARE_NEWER		= 1,

	COMPARE_OLDER		= -1,

};

#pragma warning( push )

#pragma warning( disable : 4251)

namespace Utils {

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

	std::string ws2s(const std::wstring& wstr);

/**

 * String wrapper class

 */

#ifdef STRING_WCHAR

	class SPKEXPORT String : public std::wstring

#else

	class SPKEXPORT String : public std::string

#endif

{

private:

#ifdef STRING_WCHAR

	std::string		_str;

#else

	std::wstring	_str;

#endif

public:

	// constructors

	String(void);

	String(const char *str);

	String(const unsigned char *str);

	String(const std::string &str);

	String(const char c);

	String(const unsigned char c);

	String(const String &str);

	String(long l);

	String(unsigned long l);

	String(float f);

	String(double f);

	String(wchar_t* str, int len = -1)

	{

		if(len > 0)

			this->_assign(str, len);

		else

			this->_assign(str);

	}

	virtual ~String(void);

	// conversion functions

	void fromLong(long l);

	const String &fromFloat(float f, int dp = -1);

	void fromDouble(double f);

	const String &fromDouble(double f, int dp);

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

	const String args(const String *args, int max) const;

	const String &arg(const String &s1);

	const String &arg(const String &s1, const String &s2);

	const String &arg(const String &s1, const String &s2, const String &s3);

	const String &arg(const String &s1, const String &s2, const String &s3, const String &s4);

	const String &arg(const String &s1, const String &s2, const String &s3, const String &s4, const String &s5);

	static String PadNumber(long iNum, int iAmount);

	static String Number(long l) { return String(l); }

	static String Format(const char *sFormat, ...);

	static String Null();

	static String FromFloat(float f, int dp = -1);

	bool toBool() const;

	long toLong() const;

	int toInt() const;

	double toDouble() const;

	float toFloat() const;

#ifdef STRING_WCHAR

	inline const std::wstring& toWString() const { return *this; }

	inline const std::string& toString() const { return _str; }

	inline const wchar_t* toWChar() const { return this->c_str(); }

	inline const char* toChar() const { return _str.c_str(); }

#else

	inline const std::wstring& toWString() const { return _str; }

	inline const std::string& toString() const { return *this; }

	inline const wchar_t* toWChar() const { return _str.c_str(); }

	inline const char* toChar() const { return this->c_str(); }

#endif

	// casting operators

	inline operator const char *() const			{ return (const char *)toChar(); }

	inline operator char *() const					{ return (char *)toChar(); }

	inline operator const unsigned char *() const	{ return (const unsigned char *)toChar(); }

	inline operator unsigned char *() const			{ return (unsigned char *)toChar(); }

	inline operator const std::string &() const		{ return (const std::string &)toString(); }

	inline operator const int () const				{ return this->toLong(); }

	inline operator const long () const				{ return this->toLong(); }

	inline operator const double () const			{ return this->toDouble(); }

	inline operator const float () const			{ return this->toFloat(); }

	inline operator const bool () const				{ return (this->empty() ? false : ((this->toLong()) ? true : false)); }

	// assignment operators

	const String &operator= ( const String &str );

	const String &operator= ( const std::string &str );

	const String &operator= ( const char *str );

	const String &operator= ( const unsigned char *str );

	const String &operator= ( unsigned char c );

	const String &operator= ( char c );

	const String &operator= ( long l );

	const String &operator= ( unsigned long l );

	const String &operator= ( float l );

	const String &operator= ( double l );

	// subscript operators

	const unsigned char operator[] ( int num ) const;

	unsigned char &operator[] ( int num );

	// addition operators

	String operator+ ( const char *str ) const;

	String operator+ ( const unsigned char *str ) const;

	String operator+ ( const std::string &str ) const;

	String operator+ ( const String &str ) const;

	String operator+ ( const char c ) const;

	String operator+ ( const unsigned char c ) const;

	String operator+ ( const long l ) const;

	String operator+ ( const unsigned long l ) const;

	String operator+ ( const float f ) const;

	String operator+ ( const double f ) const;

	// compound operators

	const String &operator+= ( const char *str );

	const String &operator+= ( const unsigned char *str );

	const String &operator+= ( const std::string &str );

	const String &operator+= ( const String &str );

	const String &operator+= ( const char c );

	const String &operator+= ( const unsigned char c );

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

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

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

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

	// comparison operators

	bool operator== ( const char *str ) const;

	bool operator== ( const unsigned char *str ) const;

	bool operator== ( const std::string &str ) const;

	bool operator== ( const String &str ) const;

	bool operator!= ( const char *str ) const;

	bool operator!= ( const unsigned char *str ) const;

	bool operator!= ( const std::string &str ) const;

	bool operator!= ( const String &str ) const;

	bool operator !() const;

	bool Compare(const String &str, bool bCaseSensative = false) const;

	bool Compare(const unsigned char *str, bool bCaseSensative = false) const;

	bool Compare(const char *str, bool bCaseSensative = false) const;

	// file handling

	unsigned char *readToEndOfLine(unsigned char *data);

	char *readToEndOfLine(char *data);

	const String &readToEndOfLine(FILE *id, int *line, bool upper);

	// tokens

	int countToken(const char *token) const;

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

	String tokens(const char *token, int from, int to = 0) const;

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

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

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

	String remTokens(const char* token, int from, int to = -1) const;

	String word(int word) const;

	String words(int from, int to = 0) const;

	String addToken(const char *token, const Utils::String &str) const;

	// find/replacement

	int findPos(const String &find, int iStartPos = 0) const;

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

	String remove(char c) const;

	const String &removeChar(char c);

	const String &removeChar(const char *cs);

	String findRemove(const String &find) const;

	String stripHtml() const;

	String removeIf(int iChar, char c) const;

	bool containsAny(const String &str, bool bCaseSensative = false) const;

	bool contains(const String &str, bool bCaseSensative = false) const;

	bool contains(char c, bool bCaseSensative = false) const;

	bool isin(const String &str, bool bCaseSensative = false) const;

	bool isin(char c, bool bCaseSensative = false) const;

	int compareVersion(const Utils::String &v) const;

	bool match(const Utils::String &pattern) const;

	// sub string

	String left(long num) const;

	String right(int num) const;

	String mid(int start, int end) const;

	String between(const String &before, const String &after) const;

	bool isNumber(bool integer = false) const;

	bool isCharNumber(int c) const;

	const String &removeFirstSpace();

	const String &removeEndSpace();

	const String &truncate(int iNum);

	const String &padNumber(int iNum);

	const String &pad(int iAmoumt, char cWith);

	String lower() const;

	String upper() const;

	const String &toLower();

	const String &toUpper();

	const String &toFilename();

	String asFilename() const;

private:

#ifdef STRING_WCHAR

	void _assign(const std::string& str) { this->assign(s2ws(str)); _str = str; }

	void _assign(const std::wstring& str) { this->assign(str); _str = ws2s(str); }

	void _assign(const wchar_t* str) { this->assign(str); _str = ws2s(*this); }

	void _assign(const wchar_t* str, size_t len) { this->assign(str, len); _str = ws2s(*this); }

	void _assign(const char c) { this->assign(1, c); _str = ws2s(*this); }

//	void _assign(const wchar_t c) { this->assign(1, c); _str = ws2s(*this); }

#else

	void _assign(const std::string& str) { this->assign(str); /*_str = s2ws(str); */}

	void _assign(const char *str) 

	{ 

		this->assign(str);

		//_str = s2ws(str);

	}

	//void _assign(const std::wstring& str) { this->assign(ws2s(str)); _str = str; }

	void _assign(const wchar_t* str) { this->assign(ws2s(str)); _str = str; }

	void _assign(const wchar_t* str, size_t len) { this->assign(ws2s(str), len); _str = str; }

	void _assign(const char c) { this->assign(1, c); /*_str = s2ws(*this);*/ }

//	void _assign(const wchar_t c) { _str.assign(1, c); this->assign(ws2s(_str)); }

#endif

	bool _isCharNumber(char c) const;

	Utils::String::size_type _token_nextPos(const char *token, Utils::String::size_type curPos) const;

};

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

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

#pragma warning( pop )

}