String.C

Go to the documentation of this file.

#include <strstream>
#include <iostream>

using namespace std;

#include <string.h>

#include "String.h"


void String::init( const char *initCstr )
{
  if (initCstr != 0) {
    char ch;
    for (ch = *initCstr; ch != '\0'; ch = *initCstr) {
      value->data.append( ch );
      initCstr++;
    }
    value->data.append( ch );
  }
}



void String::appendCString( const char *CStr )
{
  if (CStr != 0) {
    size_t len = length();
    if (len > 0) {
      // if there is a null at the end of the string
      // (which there should be) write over it.
      if (value->data[len-1] == '\0') {
        value->data[len-1] = *CStr++;
      }
    }
    while (*CStr) {
      value->data.append( *CStr++ );
    }
    value->data.append('\0');
  }
} // appendCString


void String::appendString( String &s )
{
  size_t i = 0;
  size_t len = s.length();
  size_t thisLen = length(); // length of "this" String
  
  if (thisLen > 0 && len > 0) {
    // write over the null character
    if (value->data[thisLen-1] == '\0') {
      value->data[thisLen-1] = s.value->data[i];
      i++;
    }
  } // if
  while (i < len) {
    char ch = s.value->data[i];
    value->data.append( ch );
    i++;
  } // while
} // appendString



int String::compareTo( String &s )
{
  if (length() == 0 && s.length() == 0) {
    // Both String objects contain no data and so are
    // equal
    return 0;
  }

  if (value == s.value) {
      // The two String objects point to the same shared data
      return 0;
  }

  const char *pThisCStr = *this;
  const char *Cstr = s;

  return Cstrcmp( pThisCStr, Cstr );
} // compareTo


String &String::resize( const size_t newSize )
{
  if (newSize == 0) {
    newEmptyString();
  }
  else { // newSize > 0
    size_t new_len = newSize + 1;
    size_t old_len = length();

    if (value->isShared()) {
      if (new_len >= old_len) {
        // this will copy the data into a new shared data object
        newSharedData();
        value->data.set_size( new_len );
      }
      else { // new_len < old_len
        RCPtr<SharedData> new_value = new SharedData();
        for (size_t i = 0; i < newSize; i++) {
          new_value->data.append( value->data[i] );
        }
        new_value->data.append('\0');
        // note: smart pointer assignment
        value = new_value;
      }
    }
    else {
      value->data.set_size( new_len );
    }

    for (size_t i = old_len-1; i < new_len-1; i++) {
      value->data[i] = ' ';
    }
    value->data[ new_len-1 ] = '\0';
  }
  return *this;
} // resize



int String::Cstrcmp(const char *pThisCStr, const char *Cstr )
{
  int rslt;

  if (pThisCStr == 0) {
    if (Cstr == 0)
      rslt = 0; // both this and CStr are null
    else {
      if (::strlen( Cstr ) == 0)
        rslt = 0;  // compare to an empty string ("")
      else
        rslt = -1; // this < Cstr
    }
  }
  else { // pThisCStr != 0
    if (Cstr == 0)
      rslt = 1; // this > Cstr
    else // pThis != 0 && Cstr != 0
      rslt = strcmp(pThisCStr, Cstr );
  }

  return rslt;
}  // Cstrcmp



String::operator const char *() const
{
  const char *pCstr = "";
  size_t len = value->data.length();

  if (len > 0) {
    if (value->data[len-1] != '\0') {
      // then add a NULL terminator
      value->data.append('\0');
    }
    pCstr = value->data.getData();
  }

  return pCstr;
} // operator const char *


void String::newEmptyString()
{
  if (value->isShared()) {
    value = new SharedData();
  }
  else {
    value->data.set_size(0);
  }
} // newEmptyString



String &String::operator =(const char ch)
{
  newEmptyString();
  if (ch != '\0') {
    value->data.append( ch );
    value->data.append('\0');
  }
  return *this;
} // operator= (String = char)



String &String::operator =(const char *Cstr)
{
  newEmptyString();
  if (Cstr != 0) {
    char ch;
    for (ch = *Cstr; ch != '\0'; ch = *Cstr) {
      value->data.append(ch);
      Cstr++;
    }
    value->data.append(ch);
  }
  return *this;
} // operator= (String = C-string)



String &String::operator +=( const char *Cstr )
{
  if (value->isShared()) {
    newSharedData();
  }

  // If there is a null character, delete it so we don't
  // append after the null.
  size_t len = value->data.length();
  if (len > 0 && value->data[len-1] == '\0')
    value->data.remove();

  appendCString( Cstr );

  return *this;
} // operator +=



String &String::operator +=(String &s )
{
  if (s.value->data.length() > 0) {
    if (value->isShared()) {
       newSharedData();
    }

    // If there is a null character, delete it so we don't
    // append after the null.
    size_t len = value->data.length();
    if (len > 0 && value->data[len-1] == '\0') {
      value->data.remove();
    }

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


/*
 * ======== Global binary operators ========
 *
 */

String operator +(const char *Cstr, String &s)
{
  String tmp;
  if (Cstr != 0) {
    tmp = Cstr;
  }
  
  tmp += s;
  return tmp;
} // global operator +


String operator +(const char ch, String &s)
{
  String tmp;

  tmp = ch;
  tmp += s;

  return tmp;
} // global operator +


bool operator ==(const char *Cstr, String &s)
{
  return (s == Cstr);
} // global operator ==


bool operator !=(const char *Cstr, String &s)
{
  return (s != Cstr);
} // operator !=


bool operator <=(const char *Cstr, String &s)
{
  return (s >= Cstr);
} // global operator <=


bool operator >=(const char *Cstr, String &s)
{
  return (s <= Cstr);
} // global operator >=


bool operator <(const char *Cstr, String &s)
{
  return (s > Cstr);
} // global operator <


bool operator >(const char *Cstr, String &s)
{
  return (s < Cstr);
} // global operator >

---