---

TString.hh

#ifndef _T_STRING_HH
#define _T_STRING_HH

#include <stdlib.h>
#include <string.h>
#include "TMapping.hh"
#include "TSingletonDestroyerT.hh"

class TString
{
public:
  
  TString ();
  
  TString (const char *cs);
  
  TString (const char *cs, int n);
  
  TString (const TString& str);
  
  TString (char c);
  
  TString (char c, int n);
  
  ~TString ();
  
  inline operator const char*() const { return myMappingEntry->key; }
  
  inline operator int() const { return Integer (); }
  
  inline operator unsigned int() const { return UnsignedInteger (); }
  
  TString& operator=(const char* cs);
  
  TString& operator=(const TString& str);
  
  inline bool operator==(const TString& str) const
  {
    return myMappingEntry == str.myMappingEntry;
  }
  
  inline bool operator==(const char *cs) const
  {
    return ! strcmp (myMappingEntry->key, cs);
  }
  
  inline bool operator!=(const TString& str)
  {
    return myMappingEntry != str.myMappingEntry;
  }
  
  inline TString& operator+=(const char* cs)
  {
    return Append (cs, Length (cs));
  }
  
  inline TString& operator+=(const TString& str)
  {
    return Append (str.myMappingEntry->key, str.myMappingEntry->bytes_used);
  }
  
  inline TString& operator+=(char c)
  {
    return Append (&c, 1);
  }
  
  inline TString operator+(const char *cs)
  {
    TString t (*this);
    t.Append (cs, Length (cs));
    return t;
  }
  
  inline TString operator+(const TString& str)
  {
    TString t (*this);
    t.Append (str);
    return t;
  }
  
  inline char operator[](int i) const
  {
    return ((char *)myMappingEntry->key)[i];
  }
  
  inline TString& Append (char c)
  {
    return Append (&c, 1);
  }
  
  TString& Append (char c, int n);

  inline TString& Append (const char* cs)
  {
    return Append (cs, Length (cs));
  }
  
  TString& Append (const char* cs, int n);
  
  inline TString& Append (const TString& str)
  {
    return Append (str.myMappingEntry->key, str.myMappingEntry->bytes_used);
  }

#if ! (defined (_WIN32) || defined (__CYGWIN__))  

  TString BaseName () const;
  
  TString DirName () const;
#endif

  inline const char *Data () const { return myMappingEntry->key; }

  TString& Clear ();
  
  inline bool Empty () const { return !myMappingEntry->bytes_used; }
  
  TString& Format (const char *fmt, ...);
  
  inline TString& Insert (int pos, char c)
  {
    return Insert (pos, c, 1);
  }
  
  TString& Insert (int pos, char c, int n);
  
  inline TString& Insert (int pos, const char *cs)
  {
    return Insert (pos, cs, TString::Length (cs));
  }
  
  TString& Insert (int pos, const char *cs, int n);
  
  inline TString& Insert (int pos, const TString& str)
  {
    return Insert (pos, str.myMappingEntry->key,
                   str.myMappingEntry->bytes_used);
  }
  
  inline unsigned int Hash () const { return myMappingEntry->hash; }
  
  bool IsAscii () const;
  
  bool IsDigits () const;
  
  bool IsXDigits () const;
  
  inline int Length () const { return myMappingEntry->bytes_used; }
  
  static inline int Length (const char *cs)
  {
    int n = 0;
    while (*cs++)
      n++;
    
    return n;
  }
  
  int Integer () const;
  
  TString& Lower ();
  
  inline TString& Prepend (char c)
  {
    return Insert (0, c, 1);
  }
  
  inline TString& Prepend (char c, int n)
  {
    return Insert (0, c, n);
  }
  
  inline TString& Prepend (const char *cs)
  {
    return Insert (0, cs, TString::Length (cs));
  }
  
  inline TString& Prepend (const char *cs, int n)
  {
    return Insert (0, cs, n);
  }
  
  inline TString& Prepend (const TString& str)
  {
    return Insert (0, str.myMappingEntry->key,
                   str.myMappingEntry->bytes_used);
  }
  
  void Print (bool newline = true) const;
  
  static void PrintStatus ()
  {
    ConstructMapping ();
    myMapping->PrintStatus ();
  }
  
  TString& Trim ();
  
  TString& TrimLeft ();
  
  TString& TrimRight ();

  TString& Truncate (int pos);
  
  unsigned int UnsignedInteger () const;  
  
  TString& Upper ();
  
  
private:
  
  inline void GetEntry (const char *cs, int n)
  {
    unsigned int hash = TUtil::Hash (cs, n);
    
    myMappingEntry = myMapping->Find (cs, n, hash);
    if (myMappingEntry)
      myMappingEntry->ref_count++;
    else
      myMappingEntry = myMapping->Insert (cs, n, hash);
  }
  
  static void ConstructMapping ();
  
  /* Mapping used to store all strings in.
     Not an object because of static object construction order
     dependencies. */
  static TMapping* myMapping;
  
  /* Mapping entry for the NULL string. */
  static TMappingEntry_t* myNullString;
  
  /* Singleton destroyer to delete our mapping on program exit.
     Easier to spot real memory leaks if we clean up this way. */
  static TSingletonDestroyerT<TMapping> myMappingDestroyer;
  
  /* Mapping entry for our string. */
  TMappingEntry_t* myMappingEntry;
};

#endif // _T_STRING_HH

---