SubString.C

Go to the documentation of this file.

#include <string.h>

#include "String.h"
#include "SubString.h"

SubString::operator String() const
{ 
  return this->string(); 
}


void SubString::rangeCheck(String &s, const size_t start, const size_t len)
     throw(std::out_of_range)
{
  char *errMsg = 0;
  bool rangeError = false;
  size_t sLen = s.strlen();
  if (start >= sLen) {
    errMsg = "SubString: start >= String length";
    rangeError = true;
  }
  else if (start + len > sLen) {
    errMsg = "SubString: start + len >= String length";
    rangeError = true;
  }

  if (rangeError) {
    throw std::out_of_range( errMsg );
  }
} // rangeCheck


SubString::SubString( String &s, const size_t start, const size_t len )
          throw(std::out_of_range)
          : value( new SharedData() )
{
  try {
    rangeCheck(s, start, len);
    size_t sLen = s.strlen();
    value->pStr( &s );
    value->start( start );
    value->subStrLen(len);
  }
  catch (std::out_of_range e) {
    throw e;
  }
} // SubString constructor



void SubString::createCopySpace(size_t start, size_t charsToCopy)
{
    size_t subStrLen = value->subStrLen();

    if (charsToCopy != subStrLen) {
      size_t strlen = value->pStr()->strlen();
      if (charsToCopy < subStrLen) {
        // The end of the copy region will be start+charsToCopy
        // The end of the SubString section is start+subStrLen
        size_t dest = start+charsToCopy;
        for (size_t i = start+subStrLen; i < strlen; i++, dest++) {
          char ch = value->pStr()->read(i);
          value->pStr()->write(dest, ch );
        }
        size_t shrink = subStrLen - charsToCopy;
        size_t newLen = strlen - shrink;
        value->pStr()->resize( newLen );
      }
      else if (charsToCopy > subStrLen) {
        size_t expand = charsToCopy - subStrLen;
        size_t newLen = strlen + expand;
        value->pStr()->resize( newLen );

        size_t dest = newLen-1;
        for (int i = strlen-1; i >= (int)start; i--, dest--) {
          char ch = value->pStr()->read(i);
          value->pStr()->write(dest, ch );
        }
      }
    }
} // createCopySpace

String SubString::operator +(const char *Cstr)
{
  String result = *this;
  if (Cstr != 0) {
    result += Cstr;
  }
  return result;
}


String SubString::operator +(const SubString& sub)
{
  String s1 = *this;
  String s2 = sub;
  String result = s1 + s2;
  return result;
}


String SubString::operator +(const String &str)
{
  String s1 = *this;
  String result = s1 + str;
  return result;
}


String SubString::operator =( const char *Cstr )
{
  size_t charsToCopy;

  if (Cstr && (charsToCopy = ::strlen( Cstr)) > 0) {
    size_t start = value->start();

    // create a copy region that is the correct size
    createCopySpace( start, charsToCopy );

    size_t cnt = 0;
    for (size_t i = start; i < start + charsToCopy; i++, cnt++) {
      value->pStr()->write(i, Cstr[ cnt ] );
    }
  }

  //
  // C/C++ allows chained assignment, so one can do something like
  //
  //    String a = b(2,4) = "abcd";
  //
  // So the string that results from the substring assignment should
  // be returned.
  //
  String retStr( *(value->pStr()) );

  return retStr;
} // operator = (Cstr)



String SubString::operator =( String& str )
{
  size_t charsToCopy;

  if ((charsToCopy = str.strlen()) > 0) {
    size_t start = value->start();

    // create a copy region that is the correct size
    createCopySpace(start, charsToCopy );

    if (value->pStr()) {
      size_t i, cnt;
      for (i = start, cnt = 0; i < start + charsToCopy; i++,cnt++) {
        value->pStr()->write(i, str[cnt]);
      }
    }
  }

  if (value->pStr())
    return *(value->pStr());
  else {
    String empty;

    return empty;
  }
} // operator = (String)


String SubString::operator =(const SubString& str )
{
  // convert to a SubStr = String
  *this = str.string();
  return (*this).string();
} // operator=



String SubString::string() const
{
  String retVal;

  if (value->pStr()) {
    size_t sLen = value->pStr()->strlen();
    size_t start = value->start();
    size_t subStrLen = value->subStrLen();
    size_t subStrEnd = start + subStrLen;

    for (size_t i = start; i < subStrEnd; i++) {
      retVal += (*(value->pStr()))[i];
    }

  }
  return retVal;
} // SubString::string


int SubString::compareTo( const char *CStr )
{
  int result;
  const char *pThisCStr = *(value->pStr());
  if (pThisCStr == 0 && CStr == 0) {
    result = 0;
  } else if (pThisCStr == 0 && CStr != 0) {
    result = -1;
  } else if (pThisCStr != 0 && CStr == 0) {
    result = 1;
  } else { // both pThisCStr and CStr are non-NULL
    size_t subStrLen = value->subStrLen();
    size_t start = value->start();
    result = strncmp((pThisCStr + start), CStr, subStrLen);
    if (result == 0) {
      size_t CStrLen = strlen( CStr );
      if (CStrLen > subStrLen) {
        result = -1; // ThisCStr < CStr
      }
    }
  }
  return result;
} // compareTo for const char *


int SubString::compareTo( String &s )
{
  const char *pCStr = s;
  return compareTo( pCStr );
} // compareTo for String



int SubString::compareTo( SubString &subStr)
{
  int result;
  const char *pThisCStr = *(value->pStr());
  const char *pRhsCStr = *(subStr.value->pStr());

  // The Strings in both SubStrings are NULL
  if (pThisCStr == 0 && pRhsCStr == 0) {
    result = 0;
  }
  else if (pThisCStr != 0 && pRhsCStr == 0) {
    result = 1;
  }
  else if (pThisCStr == 0 && pRhsCStr != 0) {
    result = -1;
  }
  else {
    size_t thisLen = value->subStrLen();
    size_t rhsLen = subStr.value->subStrLen();
    size_t compareLen = thisLen;
    if (compareLen > rhsLen) {
      compareLen = rhsLen;
    }
    size_t thisStart = value->start();
    size_t rhsStart = subStr.value->start();

    result = strncmp( pThisCStr+thisStart,
                      pRhsCStr+rhsStart,
                      compareLen );
    if (result == 0) {
      if (thisLen < rhsLen) {
        result = -1;
      }
      else if (thisLen > rhsLen) {
        result = 1;
      }
    }
  }
  return result;
} // compareTo for SubString


//
// Global Operators
//

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

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


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


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

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

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

---