String.h

/* This file is Copyright 2000-2008 Meyer Sound Laboratories Inc.  See the included LICENSE.txt file for details. */
/* This class was derived from the String class written by Michael Olivero (mike95@mike95.com) */
 
/* NOTE TO MACOS/X X-CODE USERS:  If you are trying to #include <string.h>
 * and X-Code is "helpfully" pulling in this file instead (because the
 * OS/X filesystem is case-insensitive), you can get around that problem
 * by adding "USE_HEADERMAP = NO" to your X-Code target settings.
 * ref:  http://lists.apple.com/archives/xcode-users/2004/Aug/msg00934.html
 *  --Jeremy
 */

#ifndef MuscleString_h
#define MuscleString_h

#include <ctype.h> 
#include "support/Flattenable.h"
#include "system/GlobalMemoryAllocator.h"  // for muscleFree()

BEGIN_NAMESPACE(muscle);

#ifndef SMALL_MUSCLE_STRING_LENGTH
# define SMALL_MUSCLE_STRING_LENGTH 7  // strings shorter than this length can be stored inline, without requiring an extra new[].
#endif

uint32 CStringHashFunc(const char * str); 

class String : public Flattenable
{
public:
   String(const char * str = NULL, uint32 maxLen = MUSCLE_NO_LIMIT) : Flattenable(), _buffer(NULL), _bufferLen(0), _length(0) {if (str) (void) SetCstr(str, maxLen); else _smallBuffer[0] = '\0';}

   String(const String & str) : Flattenable(), _buffer(NULL), _bufferLen(0), _length(0) {(void) SetFromString(str);}

   String(const String & str, uint32 beginIndex, uint32 endIndex=MUSCLE_NO_LIMIT) : Flattenable(), _buffer(NULL), _bufferLen(0), _length(0) {(void) SetFromString(str, beginIndex, endIndex);}

   virtual ~String() {if (_buffer != _smallBuffer) muscleFree(_buffer);}

   String & operator = (char val) {(void) SetCstr(&val, 1); return *this;}

   String & operator = (const char * val) {(void) SetCstr(val); return *this;}

   String & operator = (const String &rhs) {(void) SetFromString(rhs); return *this;}

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

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

   String & operator += (char ch)
   {
      if (EnsureBufferSize(Length()+2, true) == B_NO_ERROR)
      {
         _buffer[_length++] = ch;
         _buffer[_length]   = '\0';
      }
      return *this;
   }
   
   String & operator -= (const String &rhs);

   String & operator -= (const char ch);
   
   String & operator << (const String& rhs) {return (*this += rhs);}

   String & operator << (const char* rhs) {return (*this += rhs);}
   
   String & operator << (int rhs);   

   String & operator << (float rhs);   

   String & operator << (bool rhs);

   bool operator == (const String &rhs) const {return ((this == &rhs)||((Length() == rhs.Length())&&(strcmp(Cstr(), rhs.Cstr()) == 0)));}

   bool operator == (const char * rhs) const {return (strcmp(Cstr(), rhs?rhs:"") == 0);}

   bool operator != (const String &rhs) const {return !(*this == rhs);}

   bool operator != (const char * rhs) const {return (strcmp(Cstr(), rhs?rhs:"") != 0);}

   bool operator < (const String &rhs) const {return (this == &rhs) ? false : (strcmp(Cstr(), rhs.Cstr()) < 0);}

   bool operator < (const char * rhs) const {return (strcmp(Cstr(), rhs?rhs:"") < 0);}

   bool operator > (const String &rhs) const {return (this == &rhs) ? false : (strcmp(Cstr(), rhs.Cstr()) > 0);}

   bool operator > (const char * rhs) const {return (strcmp(Cstr(), rhs?rhs:"") > 0);}

   bool operator <= (const String &rhs) const {return (this == &rhs) ? true : (strcmp(Cstr(), rhs.Cstr()) <= 0);}

   bool operator <= (const char * rhs) const {return (strcmp(Cstr(), rhs?rhs:"") <= 0);}

   bool operator >= (const String &rhs) const {return (this == &rhs) ? true : (strcmp(Cstr(), rhs.Cstr()) >= 0);}

   bool operator >= (const char * rhs) const {return (strcmp(Cstr(), rhs?rhs:"") >= 0);}

   char operator [] (uint32 index) const {VerifyIndex(index); return _buffer[index];}

   char & operator [] (uint32 index) {VerifyIndex(index); return _buffer[index];}

   char CharAt(uint32 index) const {return operator[](index);}
 
   int CompareTo(const String & rhs) const {return strcmp(Cstr(), rhs.Cstr());}

   int CompareTo(const char * rhs) const {return strcmp(Cstr(), rhs?rhs:"");}

   const char * Cstr() const {return _buffer ? _buffer : "";}

   const char * operator()() const {return Cstr();}  

   void Clear() {if (_buffer) _buffer[0] = '\0'; _length = 0;}

   status_t SetCstr(const char * str, uint32 maxLen = MUSCLE_NO_LIMIT);

   status_t SetFromString(const String & str, uint32 beginIndex = 0, uint32 endIndex = MUSCLE_NO_LIMIT);

   bool IsEmpty() const {return (_length == 0);}

   bool HasChars() const {return (_length > 0);}

   bool EndsWith(char c) const {return (_length > 0)&&(_buffer[_length-1] == c);}

   bool EndsWith(const String &suffix) const {return (Length() < suffix.Length()) ? false : (strcmp(Cstr()+(Length()-suffix.Length()), suffix.Cstr()) == 0);}

   bool EndsWith(const char * suffix) const
   { 
      if (suffix == NULL) suffix = "";
      uint32 suffixLen = strlen(suffix);
      return (Length() < suffixLen) ? false : (strcmp(Cstr()+(Length()-suffixLen), suffix) == 0); 
   }

   bool Equals(const String & str) const {return (*this == str);}

   bool Equals(const char * str) const {return (*this == str);}

   bool Equals(char c) const {return (_length == 1)&&(_buffer[0] == c);}

   int IndexOf(char ch, uint32 fromIndex = 0) const
   {
      const char * temp = (fromIndex < Length()) ? strchr(Cstr()+fromIndex, ch) : NULL; 
      return temp ? (temp - Cstr()) : -1; 
   }

   int IndexOf(const String &str, uint32 fromIndex = 0) const
   {
      const char * temp = (fromIndex < Length()) ? strstr(Cstr()+fromIndex, str()) : NULL;
      return temp ? (temp - Cstr()) : -1;
   }

   int IndexOf(const char * str, uint32 fromIndex = 0) const
   {
      const char * temp = (fromIndex < Length()) ? strstr(Cstr()+fromIndex, str?str:"") : NULL;
      return temp ? (temp - Cstr()) : -1;
   }

   int LastIndexOf(char ch, uint32 fromIndex = 0) const
   {
      const char * lio = (fromIndex < Length()) ? strrchr(Cstr()+fromIndex, ch) : NULL;
      return lio ? (lio - Cstr()) : -1;
   }

   int LastIndexOf(const String &str) const {return (str.Length() <= Length()) ? LastIndexOf(str, Length()-str.Length()) : -1;}

   int LastIndexOf(const char * str) const
   {
      if (str == NULL) str = "";
      uint32 strLen = strlen(str);
      return (strLen <= Length()) ? LastIndexOf(str, Length()-strLen) : -1;
   }

   int LastIndexOf(const String &str, uint32 fromIndex) const;

   int LastIndexOf(const char * str, uint32 fromIndex) const;

   uint32 Length() const {return _length;}

   uint32 GetNumInstancesOf(char ch) const;

   uint32 GetNumInstancesOf(const String & substring) const;

   uint32 GetNumInstancesOf(const char * substring) const;

   bool StartsWith(char c) const {return (_length > 0)&&(_buffer[0] == c);}

   bool StartsWith(const String &prefix) const {return ((Length() >= prefix.Length())&&(strncmp(Cstr(), prefix(), prefix.Length()) == 0));}

   bool StartsWith(const char * prefix) const
   {
      if (prefix == NULL) prefix = "";
      uint32 prefixLen = strlen(prefix);
      return (Length() < prefixLen) ? false : (strncmp(Cstr(), prefix, prefixLen) == 0);
   }

   bool StartsWith(const String &prefix, uint32 offset) const {return ((offset+prefix.Length()<=Length())&&(strncmp(Cstr()+offset, prefix.Cstr(), prefix.Length()) == 0));}

   bool StartsWith(const char * prefix, uint32 offset) const
   {
      if (prefix == NULL) prefix = "";
      uint32 prefixLen = strlen(prefix);
      return ((offset+prefixLen<=Length())&&(strncmp(Cstr()+offset, prefix, prefixLen) == 0));
   }

   String Prepend(const String & str, uint32 count = 1) const;

   String Prepend(const char * str, uint32 count = 1) const;

   String Append(const String & str, uint32 count = 1) const;

   String Append(const char * str, uint32 count = 1) const;

   String Pad(uint32 minLength, bool padOnRight = false, char padChar = ' ') const;

   String Substring(uint32 beginIndex) const {return String(*this, beginIndex);}

   String Substring(uint32 beginIndex, uint32 endIndex) const {return String(*this, beginIndex, endIndex);}

   String Substring(const String & markerString) const
   {
      int idx = LastIndexOf(markerString);
      return (idx >= 0) ? String(*this, idx+markerString.Length()) : *this;
   }

   String Substring(const char * markerString) const
   {
      int idx = LastIndexOf(markerString);
      return (idx >= 0) ? String(*this, idx+strlen(markerString)) : *this;  // if (idx >= 0), then we know markerString is non-NULL
   }

   String Substring(uint32 beginIndex, const String & markerString) const {return String(*this, beginIndex, (uint32) IndexOf(markerString, beginIndex));}

   String Substring(uint32 beginIndex, const char * markerString) const {return String(*this, beginIndex, (uint32) IndexOf(markerString, beginIndex));}

   String ToLowerCase() const; 

   String ToUpperCase() const; 

   String Trim() const;  

   void SwapContents(String & swapWithMe);

   int CompareToIgnoreCase(const String &s) const             {return ToLowerCase().CompareTo(s.ToLowerCase());}

   bool EndsWithIgnoreCase(char c) const                      {return (_length > 0)&&(tolower(_buffer[_length-1]) == tolower(c));}

   bool EndsWithIgnoreCase(const String &s) const             {return ToLowerCase().EndsWith(s.ToLowerCase());}

   bool EqualsIgnoreCase(const String &s) const               {return ToLowerCase().Equals(s.ToLowerCase());}

   bool EqualsIgnoreCase(char c) const                        {return (_length==1)&&(tolower(_buffer[0])==tolower(c));}

   int IndexOfIgnoreCase(const String &s) const               {return ToLowerCase().IndexOf(s.ToLowerCase());}

   int IndexOfIgnoreCase(const String &s, uint32 f) const     {return ToLowerCase().IndexOf(s.ToLowerCase(),f);}

   int IndexOfIgnoreCase(char ch) const                       {return ToLowerCase().IndexOf((char)tolower(ch));}

   int IndexOfIgnoreCase(char ch, uint32 f) const             {return ToLowerCase().IndexOf((char)tolower(ch),f);}

   int LastIndexOfIgnoreCase(const String &s) const           {return ToLowerCase().LastIndexOf(s.ToLowerCase());}

   int LastIndexOfIgnoreCase(const String &s, uint32 f) const {return ToLowerCase().LastIndexOf(s.ToLowerCase(),f);}

   int LastIndexOfIgnoreCase(char ch) const                   {return ToLowerCase().LastIndexOf((char)tolower(ch));}

   int LastIndexOfIgnoreCase(char ch, uint32 f) const         {return ToLowerCase().LastIndexOf((char)tolower(ch),f);}

   bool StartsWithIgnoreCase(char c) const                    {return (_length > 0)&&(tolower(_buffer[0]) == tolower(c));}

   bool StartsWithIgnoreCase(const String &s) const           {return ToLowerCase().StartsWith(s.ToLowerCase());}

   bool StartsWithIgnoreCase(const String &s, uint32 o) const {return ToLowerCase().StartsWith(s.ToLowerCase(),o);}

   inline uint32 HashCode() const {return CStringHashFunc(Cstr());}

   uint32 Replace(char replaceMe, char withMe); 

   int32 Replace(const String & replaceMe, const String & withMe); 
 
   void Reverse();

   virtual bool IsFixedSize() const {return false;}

   virtual uint32 TypeCode() const {return B_STRING_TYPE;}

   virtual uint32 FlattenedSize() const;

   virtual void Flatten(uint8 *buffer) const;

   virtual status_t Unflatten(const uint8 *buf, uint32 size);

   status_t Prealloc(uint32 numChars) {return EnsureBufferSize(numChars+1, true);}

   String Arg(int8 value,   const char * fmt = "%i")   const;

   String Arg(uint8 value,  const char * fmt = "%u")   const;

   String Arg(int16 value,  const char * fmt = "%i")   const;

   String Arg(uint16 value, const char * fmt = "%u")   const;

   String Arg(int32 value,  const char * fmt = INT32_FORMAT_SPEC)  const;

   String Arg(uint32 value, const char * fmt = UINT32_FORMAT_SPEC) const;

   String Arg(int64 value,  const char * fmt = INT64_FORMAT_SPEC)  const;

   String Arg(uint64 value, const char * fmt = UINT64_FORMAT_SPEC) const;

   String Arg(double value, const char * fmt = "%f")   const;

   String Arg(const String & value) const;

   String Arg(const char * value) const;

#ifdef MUSCLE_AVOID_NAMESPACES
   uint32 CalculateChecksum() const {return ::CalculateChecksum((const uint8 *) Cstr(), Length());}
#else
   uint32 CalculateChecksum() const {return muscle::CalculateChecksum((const uint8 *) Cstr(), Length());}
#endif

private:
   bool IsSpaceChar(char c) const {return ((c==' ')||(c=='\t')||(c=='\r')||(c=='\n'));}
   status_t EnsureBufferSize(uint32 newBufLen, bool retainValue);
   String ArgAux(const char * buf) const;

   char _smallBuffer[SMALL_MUSCLE_STRING_LENGTH+1];  // store very small strings in-line, to avoid dynamic allocation
   char * _buffer;            // Stores the chars.  May point at (_smallBuffer), or a dynamically allocated buffer
   uint32 _bufferLen;         // Number of bytes pointed to by (_buffer)
   uint32 _length;            // cached strlen(_buffer)

   void VerifyIndex(uint32 index) const 
   {
#ifdef MUSCLE_AVOID_ASSERTIONS
      (void) index;  // avoid compiler warnings
#else
      MASSERT(index < _length, "Index Out Of Bounds Exception");
#endif
   }
};
DECLARE_HASHTABLE_KEY_CLASS(String);

// Also we want to allow C Strings to be used as keys in a Hashtable too
template <> class HashFunctor<const char *>
{
public:
   uint32 operator () (const char * str) const {return CStringHashFunc(str);}
};

const String & GetEmptyString();

int StringCompareFunc(const String &, const String &, void *);

int StringCompareFunc(const String * const &, const String * const &, void *);

int CStringCompareFunc(const char * const &, const char * const &, void *);

inline String operator+(const String & lhs, const String &rhs)  {String ret(lhs); ret += rhs; return ret;}
inline String operator+(const String & lhs, const char *rhs)    {String ret(lhs); ret += rhs; return ret;}
inline String operator+(const char * lhs,   const String & rhs) {String ret(lhs); ret += rhs; return ret;}
inline String operator+(const String & lhs, char rhs)           {String ret(lhs); ret += rhs; return ret;}
inline String operator-(const String & lhs, const String &rhs)  {String ret(lhs); ret -= rhs; return ret;}
inline String operator-(const String & lhs, const char *rhs)    {String ret(lhs); ret -= rhs; return ret;}
inline String operator-(const char *lhs,    const String &rhs)  {String ret(lhs); ret -= rhs; return ret;}
inline String operator-(const String & lhs, char rhs)           {String ret(lhs); ret -= rhs; return ret;}

END_NAMESPACE(muscle);

#endif

---