/*******************************************************************************
 *	BString.h		BString Handling
 *				T.Barnaby,	BEAM Ltd, 29/10/91
 *	Copyright (c) 2012 All Right Reserved, Beam Ltd, http://www.beam.ltd.uk
 *******************************************************************************
 */
#ifndef BSTRING_H
#define BSTRING_H	1

#include	<BTypes.h>
#include	<BRefData.h>
#include	<BList.h>
#include	<BArray.h>
#include	<iostream>

class BError;

class BString {
public:
			BString();
			BString(const BString& string);
			BString(const char* str);
			BString(const char* str, unsigned int len);
			BString(char ch);
			BString(BInt v);
			BString(BUInt v);
			BString(BUInt64 v);
			BString(double v);

			~BString();

	static		BString convert(char ch);			///< Converts char to string
	static		BString	convert(BInt value);			///< Converts int to string
	static		BString	convert(BUInt value);			///< Converts uint to string
	static		BString	convert(double value, int eFormat = 0);	///< Converts double to string
	static		BString	convert(BUInt64 value);			///< Converts long long to string
	static		BString	convertHex(BInt value);			///< Converts int to string as hex value
	static		BString	convertHex(BUInt value);		///< Converts uint to string as hex value

	BString		copy() const;						///< Return an independant copy
	
	int		len() const;						///< Length of string
	const char*	retStr() const;						///< Ptr to char* representation
	char*		retStrDup() const;					///< Ptr to newly malloc'd char*
	int		retInt() const;						///< Return string as a int
	unsigned int	retUInt() const;					///< Return string as a int
	double		retDouble() const;					///< Return string as a double

	int		compare(const BString& string) const;			///< Compare strings
	int		compareWild(const BString& string) const;		///< Compare string to string with wildcards 
	int		compareWildExpression(const BString& string) const;	///< Compare string to space deliminated patterns
	int		compareRegex(const BString& pattern, int ignoreCase = 0) const;		///< Compare strings
	BString&	truncate(int len);					///< Truncate to length len
	BString&	pad(int len);						///< Pad to length len
	void		clear();						///< Clear the string
	
	BString&	toUpper();						///< Convert to uppercase
	BString&	toLower();						///< Convert to lowercase
	BString		lowerFirst();						///< Return string with lowercase  first character
	void		removeNL();						///< Remove if present NL from last char 
	BString		justify(int leftMargin, int width);			///< Justify the string to the given width
	BString		fixedLen(int length, int rightJustify = 0);		///< return string formated to fixed length
	BString		firstLine();						///< Return first line
	BString		translateChar(char ch, BString replace = " ");		///< Translate character converting them to the given string
	BString		reverse() const;					///< Reverse character order
	
	BString		subString(int start, int len) const;			///< Returns substring
	int		del(int start, int len);				///< Delete substring
	int		insert(int start, BString str);				///< Insert substring
	int		append(const BString& str);				///< Append a string
	BString		add(const BString& str) const;				///< Add strings returning result
	BString&	printf(const char* fmt, ...) ;				///< Formated print into the string

	int		find(char ch) const;					///< Find ch in string searching forwards
	int		find(BString str) const;				///< Find string in string searching forwards
	int		findReverse(char ch) const;				///< Find ch in string searching backwards
	
	BString		csvEncode() const;					///< Encode a string for CSV
	BString&	csvDecode(const BString str);				///< Decode a string from CSV
	
	BString		base64Encode() const;					///< Encode a string to base64
	BError		base64Decode(BString& str) const;			///< Decode a string from base64
	

	BList<BString>	getTokenList(BString separators);			///< Break string into tokens 
	BList<BString>	getTokenList(char separator);				///< Break string into tokens 
	BString		removeSeparators(BString separators);			///< Remove any char from sepatators from string
	BString		pullToken(BString terminators);				///< Pull token from start of string
	BString		pullSeparators(BString separators);			///< Pull separators from start of string
	BString		pullWord();						///< Pull a word out of the head of the string
	BString		pullLine();						///< Pull a line out of the head of the string
	BList<BString>	split(char splitChar);					///< Split string into an array based on the character separator

	// Filename operations
	BString		dirname();
	BString		basename();
	BString		extension();
	
	// Misc functions
	BUInt32		hash() const;
	char&		get(int pos);
	const char&	get(int pos) const;
	
	/* Operator functions */
	BString&	operator=(const BString& string);
	char&		operator[](int pos);
	
	int		operator==(const BString& s) const{
				return (compare(s) == 0);
			}
	int		operator==(const char* s) const{
				return (compare(s) == 0);
			}
	int		operator>(const BString& s) const{
				return (compare(s) > 0);
			}
	int		operator>(const char* s) const{
				return (compare(s) > 0);
			}
	int		operator<(const BString& s) const{
				return (compare(s) < 0);
			}
	int		operator<(const char* s) const{
				return (compare(s) < 0);
			}
	int		operator>=(const BString& s) const{
				return (compare(s) >= 0);
			}
	int		operator<=(const BString& s) const{
				return (compare(s) <= 0);
			}
	int		operator!=(const BString& s) const{
				return (compare(s) != 0);
			}
	int		operator!=(const char* s) const{
				return (compare(s) != 0);
			}
	BString 	operator+(const BString& s) const {
				return add(s);
			}
	BString 	operator+(const char* s) const {
				return add(s);
			}
	BString 	operator+=(const BString& s){
				*this = add(s);
				return *this;
			}
	BString 	operator+=(const char* s){
				*this = add(s);
				return *this;
			}
			
	/* Special operators */
	BString 	operator+(char ch) const {
				return add(convert(ch));
			}
	BString 	operator+(BInt i) const {
				return add(convert(i));
			}
	BString 	operator+(BUInt i) const {
				return add(convert(i));
			}
	BString 	operator+(BUInt64 i) const {
				return add(convert(i));
			}
			operator const char* () const {
				return retStr();
			}
#ifdef QSTRING_H
	// QT support
			BString(const QString& str){
#if QT_VERSION >= 0x040000
				init(str.toAscii());
#else
				init(str);
#endif
			}
#ifndef ZAP
			operator QString (){		// QString support
				return QString(retStr());
			}
#endif
#endif

	// For compatibility
	BString		field(int field) const;
	char**		fields();

protected:
	BRefData*	ostr;	

private:
	void		init(const char* str);
	int		inString(int pos) const;
	int		isSpace(char ch) const;
};

/* OStream Functions */
std::ostream& operator<<(std::ostream& o, BString& s);
std::istream& operator>>(std::istream& i, BString& s);

#ifdef BLIST_H
typedef BList<BString>	BStringList;
typedef BArray<BString>	BStringArray;

int bstringListinList(BStringList& l, BString s);

BString blistToString(const BStringList& list);			///< Convert a string list to a comma separated string
BStringList bstringToList(BString str, int stripSpaces = 0);	///< Convert a comma separated string to a string list
BStringList charToList(const char** str);

BString barrayToString(const BStringArray& list);		///< Convert a string array to a comma separated string
BStringArray bstringToArray(BString str, int stripSpaces = 0);	///< Convert a comma separated string to a string array
BStringArray charToArray(const char** str);

#endif

// String conversion functions
void toBString(BString& v, BString& s);
void toBString(BStringList& v, BString& s);
void toBString(BInt32& v, BString& s);
void toBString(BUInt32& v, BString& s);
void toBString(BUInt64& v, BString& s);
void toBString(BFloat64& v, BString& s);
void fromBString(BString& s, BString& v);
void fromBString(BString& s, BStringList& v);
void fromBString(BString& s, BInt32& v);
void fromBString(BString& s, BUInt32& v);
void fromBString(BString& s, BUInt64& v);
void fromBString(BString& s, BFloat64& v);

#endif