/**
*  Copyright Mikael Högdahl - triyana@users.sourceforge.net
*
*  This source is distributed under the terms of the Q Public License version 1.0,
*  created by Trolltech (www.trolltech.com).
*/

#ifndef MHString_h
#define MHString_h

#include <math.h>
#include "MH.h"
#include "MHUtil.h"



/**
*  A string class.
*/
class MHString : public MH {
public:
    enum {
                        SORT_STRING = 0,
                        SORT_NUM,
    };

                        MHString () : MH() {aData = 0; allocate((const char*)"");}
                        MHString (const MHString& s) : MH() {if (&s == this) return; aData = 0; allocate(s.Get());}
                        MHString (const char* s) : MH() {aData = 0; allocate(s);}
                        MHString (int n) : MH() {aData = 0; allocate(n);}
                        MHString (double n) : MH() {aData = 0; allocate(n);}
                        MHString (int size, const char *str, ...);
    virtual             ~MHString () {Clear();}

    //friend ostream&     operator<< (ostream& os, MHString& s) {os << s(); return os;}
    //friend ostream&     operator<< (ostream& os, MHString* s) {os << (*s)(); return os;}

    MHString&           operator= (const MHString& s) {if (&s == this) return *this; allocate(s);return *this;}
    MHString&           operator= (const char* s) {allocate(s);return *this;}
    MHString&           operator= (int n) {allocate(n);return *this;}
    MHString&           operator= (double n) {allocate(n);return *this;}

    MHString&           operator+= (const MHString& s) {allocate(aData, s.Get());return *this;}
    MHString&           operator+= (const char* s) {allocate(aData, s);return *this;}
    MHString&           operator+= (int n) {allocate(aData, n);return *this;}
    MHString&           operator+= (double n) {allocate(aData, n);return *this;}

    MHString            operator+ (const MHString& s) {MHString s3(aData); s3 += s; return s3;}
    MHString            operator+ (const char* s) {MHString s3(aData); s3 += s; return s3;}
    MHString            operator+ (int n) {MHString s3(aData); s3 += n; return s3;}
    MHString            operator+ (double n) {MHString s3(aData); s3 += n; return s3;}

    bool                operator== (const MHString& s) {return (Compare (s.Get ()) == 0) ? true : false;}
    bool                operator== (const char* s) {return (Compare (s) == 0) ? true : false;}
    bool                operator!= (const MHString& s) {return (Compare (s.Get ()) != 0) ? true : false;}
    bool                operator!= (const char* s) {return (Compare (s) != 0) ? true : false;}
    bool                operator< (const MHString& s) {return (Compare (s.Get ()) < 0) ? true : false;}
    bool                operator< (const char* s) {return (Compare (s) < 0) ? true : false;}
    bool                operator> (const MHString& s) {return (Compare (s.Get ()) > 0) ? true : false;}
    bool                operator> (const char* s) {return (Compare (s) > 0) ? true : false;}
    bool                operator<= (const MHString& s) {return (Compare (s.Get ()) < 1) ? true : false;}
    bool                operator<= (const char* s) {return (Compare (s) < 1) ? true : false;}
    bool                operator>= (const MHString& s) {return (Compare (s.Get ()) >= 0) ? true : false;}
    bool                operator>= (const char* s) {return (Compare (s) >= 0) ? true : false;}

    char                operator[] (int i) {return aData[i];}
    const char*         operator() () {return aData;}

    void                AlignLeft (int nWidth, char pad) {align (false, nWidth, pad);}
    void                AlignRight (int nWidth, char pad) {align (true, nWidth, pad);}
    void                CapitalizeAll ();
    void                CapitalizeFirst ();
    const char*         Class () {return "MHString";}
    int                 Compare (const char* pBuffer);
    int                 Compare (const MH* o, int type);
    int                 CompareIgnoreCase (const char* pBuffer);
    double              Double () {return (aLen > 0) ? strtod(aData, 0) : HUGE_VAL;}
    void                Erase () {*this = "";}
    const char*         Escape () {return Get();}
    int                 Find (const MHString& s, int nStart = 0) {return find (s.Get(), nStart, true);}
    int                 Find (const char* s, int nStart = 0) {return find (s, nStart, true);}
    int                 FindIgnoreCase (const char* s, int nStart = 0) {return find (s, nStart, false);}
    int                 FindIgnoreCase (const MHString& s, int nStart = 0) {return find (s.Get(), nStart, false);}
    const char*         Get () const {return aData;}
    char                GetChar (int i) {return (i >= 0 && i < aLen) ? aData[i] : '\0';}
    char                GetLastChar () {return (aLen > 0) ? aData[aLen - 1] : '\0';}
    const char*         HashKey () {return ((aData && *aData) ? aData : "MHString");}
    MHString            Left (int count);
    int                 Int () {return (aLen > 0) ? atoi (aData) : 0;}
    MHString            Mid (int nStart, int nCount);
    char                Pop () {if (aLen > 0) {char c = aData[aLen - 1]; aData[aLen - 1] = '\0'; aLen--; return c;} else return '\0';}
    void                Remove (char Char);
    void                RemoveHead (char Char);
    void                RemoveTail (char Char);
    MHString            Right (int nCount);
    void                Shrink (int size);
    static void         Save (const char* fileName, MHVector* v, bool nl = false, bool row = false);
    void                SetChar (int i, int c) {if (i >= 0 && i < aLen) aData[i] = c;}
    int                 Size () {return aLen;}
    int                 Split (char c, MHVector* ve);
    int                 Split (MHVector* ve, int nFirstPos, ...);
    void                Sprintf (int len, const char *str, ...);
    void                Strip ();
    int                 Subst (char OldChar, char NewChar, int nKeepMinOldChar);
    double              ToDouble () {return (aData) ? atof (aData) : 0.0;}
    int                 ToInt () {return (aData) ? atoi (aData) : 0;}
    void                ToLower ();
    void                ToUpper ();

private:
    char*               aData;
    int                 aLen;

    void                align (bool right, int nWidth, char pad);
    void                allocate (const MHString& s) {allocate (s.Get());}
    void                allocate (const char* s);
    void                allocate (char* s);
    void                allocate (int n);
    void                allocate (double n);
    void                allocate (const char* s, const char* s2);
    void                allocate (const char* s, int n);
    void                allocate (const char* s, double n);

    void                Clear ();
    char*               createAndConcat (const char* string1, const char* string2);
    int                 find (const char* word, int start, bool compareCase);
};

#endif