String.h

Go to the documentation of this file.

#ifndef MY_STRING_H
#define MY_STRING_H
// don't want a collision with another string macro, so I have
// not used STRING_H.

#include <stdexcept>

#include <stdio.h>

#include "SubString.h"
#include "RCArray.h"

typedef RCArray<char> CharArray;

class String : public CharArray
{
  // Make SubString a "friend" so it can access the protected read() and
  // write functions.
  friend SubString;
protected:
  void init(const char *initCstr );
  size_t length();
  void appendCString( const char *CStr );
  void appendString( String &Str );
  void newEmptyString();
  void newSharedData();
  int Cstrcmp( const char *s1, const char *s2 );
  int compareTo( String &s );

public:

  String();
  String( const char ch );
  String( const char *initCstr );
  String( const String &Str );

  // sub-string operator (can be used on both lhs and rhs)
  SubString operator()(const size_t start, const size_t len);

  size_t strlen();

  size_t getRefCnt();

  int compareTo( const char *Cstr );

  String &resize(const size_t new_size );

  //
  // operators
  //
  operator const char*() const;

  String &operator =(const char ch);        // String = char
  String &operator =(const char *Cstr);     // String = C-string
  String &operator =(const SubString &sub); // String = SubString

  String operator +(const char *Cstr ); // concatenate a String and a C string
  String operator +(String &s );        // concatenate two Strings
  String operator +(const char ch );    // concatenate a String and a char
  // concatenate a String and a SubString
  String operator +(const SubString &sub); 

  String &operator +=(const char *Cstr ); // concatenate a C string to a String
  String &operator +=(String &s );        // concatenate a String to a String
  String &operator +=(const char ch);     // concatenate a char to a String

  bool operator ==(const char *Cstr ) { return (compareTo( Cstr ) == 0); }
  bool operator ==(String &s )  { return (compareTo( s ) == 0); }
  bool operator !=(const char *Cstr ) { return (compareTo( Cstr ) != 0); }
  bool operator !=(String &s )  { return (compareTo( s ) != 0); }
  bool operator <=(const char *Cstr ) { return (compareTo( Cstr ) <= 0); }
  bool operator <=(String &s )  { return (compareTo( s ) <= 0); }
  bool operator >=(const char *Cstr ) { return (compareTo( Cstr ) >= 0); }
  bool operator >=(String &s )  { return (compareTo( s ) >= 0); }
  bool operator <(const char *Cstr )  { return (compareTo( Cstr ) < 0); }
  bool operator <(String &s )   { return (compareTo( s ) < 0); }
  bool operator >(const char *Cstr )  { return (compareTo( Cstr ) > 0); }
  bool operator >(String &s )   { return (compareTo( s ) > 0); }

}; // String

/*
 * Global operators
 *
 */
String operator +(const char *Cstr, String &s);
String operator +(const char ch, String &s);

bool operator ==(const char *Cstr, String &s);
bool operator !=(const char *Cstr, String &s);
bool operator <=(const char *Cstr, String &s);
bool operator >=(const char *Cstr, String &s);
bool operator <(const char *Cstr, String &s);
bool operator >(const char *Cstr, String &s);

inline
String::String() : CharArray() {}

inline
String::String( const char ch ) : CharArray()
{ 
  if (ch != '\0') {
    value->data.append( ch );
    value->data.append('\0');
  }
}

inline
String::String( const char *initCstr ) : CharArray()
{
  init( initCstr );
}

inline
String::String( const String &Str ) : CharArray()
{
  value = Str.value;
}


inline
size_t String::length()
{
  return CharArray::length();
}


inline
size_t String::getRefCnt()
{
  return CharArray::getRefCnt();
}




inline
SubString String::operator ()(const size_t start, const size_t len)
{
  SubString subStr( *this, start, len );

  return subStr;
}


inline
String String::operator +(const SubString &sub)
{
  String section = sub;
  String result = *this + section;
  return result;
} // operator +



inline
String &String::operator =(const SubString &sub)
{
  *this = (String)sub;
  return *this;
} // operator =


inline
void String::newSharedData()
{
  value = new SharedData( value->data );
}



inline 
int String::compareTo( const char *Cstr )
{
  const char *pThisCStr = *this;
  
  return Cstrcmp( pThisCStr, Cstr );
}



inline 
String &String::operator +=(const char ch)
{
  char buf[4];

  buf[0] = ch;
  buf[1] = '\0';

  *this += buf;   // call String += Cstr
  return *this;
} // operator +=



inline 
String String::operator +( const char *Cstr )
{
  String tmp;
  
  tmp.appendString( *this );
  tmp.appendCString( Cstr );

  return tmp;
} // operator +


inline 
String String::operator +(String &s)
{
  String tmp;
  
  tmp.newSharedData();

  tmp.appendString( *this );
  tmp.appendString( s );
  
  return tmp;
} // operator +


inline 
String String::operator +(const char ch)
{
  char buf[4];

  buf[0] = ch;
  buf[1] = '\0';

  String tmp;

  tmp = *this + buf;  // call String + Cstr

  return tmp;
} // operator +



inline
size_t String::strlen()
{
  int len = value->data.length(); 
  if (len > 0 && value->data[len-1] == '\0')
    len--;
  return len;
}


#endif

---