---

CTBstring.cxx

Go to the documentation of this file.

/*----------------------------------------------------------------------------*/
/* C Tool Box: Designed and implemented by:                                   */
/*    Walter F.J. Mueller   Gesellschaft fuer Schwerionenforschung (GSI)      */
/*                          Planckstrasse 1, D-64291 Darmstadt, Germany       */
/*                  Email:  W.F.J.Mueller@gsi.de                              */
/*                  WWW:    http://www-kp3.gsi.de/www/kp3/people/mueller.html */
/*----------------------------------------------------------------------------*/

#include <string.h>
#include <ctype.h>

#include "CTB.hxx"
#include "CTB_Trace.hxx"
#include "CTBosFill.hxx"
#include "CTBstring.hxx"
#include "CTBnum.hxx"
#include "CTBcstringBase.hxx"

//------------------------------------------+-----------------------------------

static CTBint string_length(const char* c_str) 
{
  return c_str ? strlen(c_str) : 0;
}

//------------------------------------------+-----------------------------------

static CTBint string_length(const char* c_str, CTBint i_max) 
{
  CTBint i_len = 0;

  while(i_max-- > 0 && *c_str++) i_len++;   // isn't C wonderful ...

  return i_len;
}

//------------------------------------------+-----------------------------------

CTBstring::CTBstring(const CTBstring& rhs)
  : m_sbuf(rhs.m_sbuf),
    mi_offset(rhs.mi_offset),
    mi_length(rhs.mi_length)
{
  CTB_Trace("CTBstring(const CTBstring&)");
}

//------------------------------------------+-----------------------------------

CTBstring::CTBstring(const CTBstring& rhs, CTBint i_length)
  : m_sbuf(rhs.m_sbuf),
    mi_offset(rhs.mi_offset),
    mi_length(CTBmin(CTBmax(0,i_length),rhs.Length()))
{
  CTB_Trace("CTBstring(const CTBstring&, CTBint)");
}

//------------------------------------------+-----------------------------------

CTBstring::CTBstring(const CTBstring& rhs, CTBint i_offset, CTBint i_length)
  : m_sbuf(rhs.m_sbuf),
    mi_offset(0),
    mi_length(0)
{
  CTB_Trace("CTBstring(const CTBstring&, CTBint, CTBint)");
  CTBint i_doff = CTBmin(CTBmax(0,i_offset),rhs.Length());

  mi_offset = rhs.mi_offset + i_doff;
  mi_length = CTBmin(CTBmax(0,i_length),rhs.Length()-i_doff);
}

//------------------------------------------+-----------------------------------

CTBstring::CTBstring(const char* c_rhs)
  : m_sbuf(),                               // init as empty
    mi_offset(0),
    mi_length(0)
{
  CTB_Trace("CTBstring(const char*)");
  NewString(c_rhs,string_length(c_rhs));
}

//------------------------------------------+-----------------------------------

CTBstring::CTBstring(const char* c_rhs, CTBint i_length)
  : m_sbuf(),                               // init as empty
    mi_offset(0),
    mi_length(0)
{
  CTB_Trace("CTBstring(const char*, CTBint)");
  NewString(c_rhs,string_length(c_rhs,i_length));
}

//------------------------------------------+-----------------------------------

void CTBstring::Copy(const CTBstring& rhs)
{
  CTB_Trace("CTBstring::Copy(const CTBstring&)");

  m_sbuf    = rhs.m_sbuf;
  mi_offset = rhs.mi_offset;
  mi_length = rhs.mi_length;
  return;
}

//------------------------------------------+-----------------------------------

void CTBstring::Copy(const char* c_rhs)
{
  CTB_Trace("CTBstring::Copy(const char*)");
  NewString(c_rhs,string_length(c_rhs));
  return;
}

//------------------------------------------+-----------------------------------

void CTBstring::Copy(char c_rhs)
{
  CTB_Trace("CTBstring::Copy(char)");
  char  text[1];

  text[0] = c_rhs;
  NewString(text,c_rhs ? 1 : 0);            // protect against null character 
  return;
}

//------------------------------------------+-----------------------------------

void CTBstring::Append(const CTBstring& rhs)
{
  CTB_Trace("CTBstring::Append(const CTBstring&)");
  AppendData(rhs.Data(),rhs.Length());
  return;
}

//------------------------------------------+-----------------------------------

void CTBstring::Append(const char* c_rhs)
{
  CTB_Trace("CTBstring::Append(const char*)");
  AppendData(c_rhs,string_length(c_rhs));
  return;
}

//------------------------------------------+-----------------------------------

void CTBstring::Append(const char* c_rhs, CTBint i_length)
{
  CTB_Trace("CTBstring::Append(const char*, CTBint)");
  AppendData(c_rhs,string_length(c_rhs,i_length));
  return;
}

//------------------------------------------+-----------------------------------

void CTBstring::Append(char c_rhs)
{
  CTB_Trace("CTBstring::Append(char)");

  if (c_rhs != 0) {                         // protect against null char

    if (mi_offset == 0 &&                   // direct append possible ?
        mi_length+2 <= m_sbuf.Size() &&
        m_sbuf.IsUnique()) {
      m_sbuf[mi_length] = c_rhs;
      mi_length        += 1;
      m_sbuf[mi_length] = 0;

    } else {                                // otherwise call generic method
      char text[1];
      text[0] = c_rhs;
      AppendData(text,1);
    }
  }
  return;
} 

//------------------------------------------+-----------------------------------

int CTBstring::Compare(const CTBstring& rhs) const
{
  CTB_Trace("CTBstring::Compare(const CTBstring&)");
  CTBint i_len = CTBmin(Length(),rhs.Length());     // minimal common length
  CTBint i_dif = strncmp(Data(),rhs.Data(),i_len);  // compare over min com lgt

  if (i_dif == 0 && Length() != rhs.Length())    // if that's equal
    i_dif = (Length() < rhs.Length()) ? 1 : -1;  // make longer > smaller
  
  return i_dif;
}

//------------------------------------------+-----------------------------------

int CTBstring::Compare(const char* c_rhs) const
{
  CTB_Trace("CTBstring::Compare(const char*)");
  CTBint i_rhslen = string_length(c_rhs);
  CTBint i_len    = CTBmin(Length(),i_rhslen); // minimal common length
  CTBint i_dif    = strncmp(Data(),c_rhs,i_len); // compare over min. com lgt

  if (i_dif == 0 && Length() != i_rhslen)   // if that's equal
    i_dif = (Length() < i_rhslen) ? 1 : -1; // make longer > smaller
  return i_dif;
}

//------------------------------------------+-----------------------------------

int CTBstring::CompareCaseBlind(const CTBstring& rhs) const
{
  CTB_Trace("CTBstring::CompareCaseBlind(const CTBstring&)");
  CTBint i_len      = CTBmin(Length(),rhs.Length()); // minimal common length
  const char* c_lhs = Data();
  const char* c_rhs = rhs.Data();
  int i_dif         = 0;
  
  for (CTBint i = 0; i < i_len; i++) {
    i_dif = tolower(*c_lhs++) - tolower(*c_rhs++);
    if (i_dif != 0) break;
  }
  return i_dif;
}

//------------------------------------------+-----------------------------------

int CTBstring::CompareCaseBlind(const char* c_rhs) const
{
  CTB_Trace("CTBstring::CompareCaseBlind(const char*)");
  CTBint i_rhslen   = string_length(c_rhs);
  CTBint i_len      = CTBmin(Length(),i_rhslen); // minimal common length
  const char* c_lhs = Data();
  int i_dif         = 0;
  
  for (CTBint i = 0; i < i_len; i++) {
    i_dif = tolower(*c_lhs++) - tolower(*c_rhs++);
    if (i_dif != 0) break;
  }
  return i_dif;
}

//------------------------------------------+-----------------------------------

bool CTBstring::IsWhite() const
{
  CTB_Trace("CTBstring::IsWhite()");
  if (mi_length > 0) {
    const char* p = Data();
    for (CTBint i = 0; i < mi_length; i++) if (!(isspace(*p++))) return false;
  }
  return true;
}

//------------------------------------------+-----------------------------------

bool CTBstring::IsUpperCase() const
{
  CTB_Trace("CTBstring::IsUpperCase()");
  if (mi_length > 0) {
    const char* p = Data();
    for (CTBint i = 0; i < mi_length; i++) {
      char c = *p++;
      if (isalpha(c) && !(isupper(c))) return false;
    }
  }
  return true;
}

//------------------------------------------+-----------------------------------

bool CTBstring::IsLowerCase() const
{
  CTB_Trace("CTBstring::IsLowerCase()");
  if (mi_length > 0) {
    const char* p = Data();
    for (CTBint i = 0; i < mi_length; i++) {
      char c = *p++;
      if (isalpha(c) && !(islower(c))) return false;
    }
  }
  return true;
}

//------------------------------------------+-----------------------------------

void CTBstring::TrimWhite()
{
  CTB_Trace("CTBstring::TrimWhite()");

  while (mi_length > 0) {                   // trim head
    if (!(isspace(m_sbuf[mi_offset]))) break;
    mi_offset += 1;
    mi_length -= 1;
  }
  while (mi_length > 0) {                   // trim tail
    if (!(isspace(m_sbuf[mi_offset+mi_length-1]))) break;
    mi_length -= 1;
  }
  return;
}

//------------------------------------------+-----------------------------------

void CTBstring::CollapseWhite()
{
  CTB_Trace("CTBstring::CollapseWhite()");

  if (Length() == 0) return;                // if null or empty, quit
  Unshare();                                // ensure not shared or substring

  char* pc_src = &m_sbuf[0];                // read pointer
  char* pc_dst = &m_sbuf[0];                // write pointer
  bool  b_skip = false;                     // true if next whte to be skipped

  for (CTBint i = 0; i < mi_length; i++) {  // loop over string
    char c = *pc_src++;
    if (isspace(c)) {                       // if white space character
      if (!b_skip) *pc_dst++ = ' ';         // write one blank
      b_skip = true;
    } else {                                // otherwise copy character
      *pc_dst++ = c;
      b_skip   = false;
    }
  }
  mi_length = pc_dst - &m_sbuf[0];          // set new string length
  return;
}

//------------------------------------------+-----------------------------------

void CTBstring::ToUpperCase()
{
  CTB_Trace("CTBstring::ToUpperCase()");

  if (Length() == 0) return;                // if null or empty, quit
  Unshare();                                // ensure not shared or substring

  for (CTBint i = 0; i < mi_length; i++) m_sbuf[i] = toupper(m_sbuf[i]);

  return;
}

//------------------------------------------+-----------------------------------

void CTBstring::ToLowerCase()
{
  CTB_Trace("CTBstring::ToLowerCase()");

  if (Length() == 0) return;                // if null or empty, quit
  Unshare();                                // ensure not shared or substring

  for (CTBint i = 0; i < mi_length; i++) m_sbuf[i] = tolower(m_sbuf[i]);

  return;
}

//------------------------------------------+-----------------------------------

bool CTBstring::Get(long& i_val, int i_base) const
{
  CTB_Trace("CTBstring::Get(long&,int)");
  CTBint i_size = (mi_length > 0 && Data()[mi_length] == 0) ? -1 : mi_length;

  return CTBcstringBase::Get(Data(),i_size,i_val,i_base);
}

//------------------------------------------+-----------------------------------

bool CTBstring::Get(unsigned long& i_val, int i_base) const
{
  CTB_Trace("CTBstring::Get(unsigned long&,int)");
  CTBint i_size = (mi_length > 0 && Data()[mi_length] == 0) ? -1 : mi_length;

  return CTBcstringBase::Get(Data(),i_size,i_val,i_base);
}

//------------------------------------------+-----------------------------------

bool CTBstring::Get(int& i_val, int i_base) const
{
  CTB_Trace("CTBstring::Get(int&,int)");
  CTBint i_size = (mi_length > 0 && Data()[mi_length] == 0) ? -1 : mi_length;

  return CTBcstringBase::Get(Data(),i_size,i_val,i_base);
}

//------------------------------------------+-----------------------------------

bool CTBstring::Get(unsigned int& i_val, int i_base) const
{
  CTB_Trace("CTBstring::Get(unsigned int&,int)");
  CTBint i_size = (mi_length > 0 && Data()[mi_length] == 0) ? -1 : mi_length;

  return CTBcstringBase::Get(Data(),i_size,i_val,i_base);
}

//------------------------------------------+-----------------------------------

bool CTBstring::Get(double& d_val) const
{
  CTB_Trace("CTBstring::Get(double&)");
  CTBint i_size = (mi_length > 0 && Data()[mi_length] == 0) ? -1 : mi_length;

  return CTBcstringBase::Get(Data(),i_size,d_val);
}

//------------------------------------------+-----------------------------------

bool CTBstring::Get(float& f_val) const
{
  CTB_Trace("CTBstring::Get(float&)");
  CTBint i_size = (mi_length > 0 && Data()[mi_length] == 0) ? -1 : mi_length;

  return CTBcstringBase::Get(Data(),i_size,f_val);
}

//------------------------------------------+-----------------------------------

CTBint CTBstring::FindCharacter(const char* c_set, CTBint i_offset) const
{
  return FindCharacter(c_set,string_length(c_set),i_offset);
}

//------------------------------------------+-----------------------------------

CTBstring CTBstring::Escape() const
{
  CTB_Trace("CTBstring::Escape()");

  if (Length() > 0 && FindCharacter("\f\n\r\t\v\\") != Length()) {
    CTBstring    res;
    const char*  p = Data();

    for (CTBint i = 0; i < mi_length; i++) {
      char c = *p++;
      switch (c) {
      case '\f':
        res += "\\f";
        break;
      case '\n':
        res += "\\n";
        break;
      case '\r':
        res += "\\r";
        break;
      case '\t':
        res += "\\t";
        break;
      case '\v':
        res += "\\v";
        break;
      case '\\':
        res += "\\";
        break;
      default:
        res += c;
        break;
      }      
    }
    return res;
  }
  return *this;
}

//------------------------------------------+-----------------------------------

CTBstring CTBstring::Unescape() const
{
  CTB_Trace("CTBstring::Unscape()");

  if (Length() > 0 && FindCharacter('\\') != Length()) {
    CTBstring    res;
    const char*  p = Data();

    for (CTBint i = 0; i < mi_length; i++) {
      char c = *p++;

      if (c == '\\' && i+1 < mi_length) {
        char c1 = *p++;
        i += 1;

        switch (c1) {

        case 'f':
          res += '\f';
          break;
        case 'n':
          res += '\n';
          break;
        case 'r':
          res += '\r';
          break;
        case 't':
          res += '\t';
          break;
        case 'v':
          res += '\v';
          break;
        case '\\':
          res += '\\';
          break;

        case '\n':                          // simply eat a \ followed by \n
          break;

        default:                            // passthrough all unknown's
          res += c;
          res += c1;
          break;
        }

      } else {                              // if no \ found, just pass
        res += c;
      }
    }
    return res;
  }
  return *this;
}

//------------------------------------------+-----------------------------------

bool CTBstring::GetLine(istream& is)
{
  CTB_Trace("CTBstring::GetLine(istream&)");
  char  buf[1024];
  
  if (!is) return false;

  buf[0] = 0;
  is.getline(buf,1024);
  
  if (is.good() || (is.gcount() > 0 && is.eof())) {
    *this = buf;
    return true;
  }
  return false;
}

//------------------------------------------+-----------------------------------

void CTBstring::Dump(int i_indent, ostream& os, const char* p_text) const
{
  CTBosFill bl(i_indent);
  
  os << bl << "--CTBstring ";
  if (p_text) os << p_text;
  os << " @ " << this << endl;
  m_sbuf.Dump(i_indent+2,os,"m_sbuf");
  os << bl << "    mi_offset:     " << mi_offset << endl;
  os << bl << "    mi_length:     " << mi_length << endl;
  return;
}

//------------------------------------------+-----------------------------------

char CTBstring::operator[](CTBint i_ind) const
{
  CTB_Trace("CTBstring::operator[](CTBint)");

  if (i_ind < 0 && i_ind >= Length()) return 0;   // return 0 if out-of-range 
  return Data()[i_ind];    
}

//------------------------------------------+-----------------------------------

CTBstring::operator const char*() const
{
  CTB_Trace("CTBstring::operator const char*()");

  if (m_sbuf.IsNull()) return "";

  ((CTBstring*) this) -> Terminate();
  return Data();
}

// Note:
//  1. Even though the const char* conversion does not change the value of
//     the string it might force a change of it's internal representation.
//     This happens for substrings, which have to be converted to a null
//     terminated format.
//
//     Therefore, there is a conflict between logical and physical const-ness.
//     The const char* clearly has to be a const member function to be useful,
//     but it has to be able to change the object !
//
//     The confict is resolved here by doing the `dirt work' in a separate
//     member function Terminate(), which is not const, which is called by
//     simply casting away the const....

//------------------------------------------+-----------------------------------
CTBstring operator+(const CTBstring& lhs, const CTBstring& rhs)
{
  CTB_Trace("operator+(const CTBstring&, const CTBstring&)");
  CTBstring res;

  res.NewString(lhs.Data(),lhs.Length(),rhs.Data(),rhs.Length());
  return res;
}

//------------------------------------------+-----------------------------------
CTBstring operator+(const CTBstring& lhs, const char* c_rhs)
{
  CTB_Trace("operator+(const CTBstring&, const char*)");
  CTBstring res;

  res.NewString(lhs.Data(),lhs.Length(),c_rhs,string_length(c_rhs));
  return res;  
}

//------------------------------------------+-----------------------------------
CTBstring operator+(const char* c_lhs, const CTBstring& rhs)
{
  CTB_Trace("operator+(const char*, const CTBstring&)");
  CTBstring res;

  res.NewString(c_lhs,string_length(c_lhs),rhs.Data(),rhs.Length());
  return res;  
}

//------------------------------------------+-----------------------------------
ostream& operator<<(ostream& os, const CTBstring& rhs)
{
  if (rhs.Length() > 0) os.write(rhs.Data(),rhs.Length());
  return os;
}

//------------------------------------------+-----------------------------------

const CTBstring& CTBstring::NullString()
{
  static const CTBstring nullstring;
  return nullstring;
}

//------------------------------------------+-----------------------------------

const CTBstring& CTBstring::EmptyString()
{
  static const CTBstring emptystring("");
  return emptystring;
}

//------------------------------------------+-----------------------------------

void CTBstring::Unshare()
{
  CTB_Trace("CTBstring::Unshare()");
  if (mi_offset > 0 ||                      // is substring
      m_sbuf.IsShared()) {                  // or shared
    CTBstring lhs(*this);
    NewString(lhs.Data(),lhs.Length());     // recreate
  }
  return;
}

//------------------------------------------+-----------------------------------

void CTBstring::EnsureUnsharedCapacity(CTBint i_capacity)
{
  CTB_Trace("CTBstring::EnsureUnsharedCapacity(CTBint)");
  CTBint i_size = i_capacity + 1;           // take care of trailing null char

  i_size = i_size + 7;
  i_size = i_size - (i_size & 7);           // round up so that mod(8) = 0

  if (m_sbuf.IsShared()) {                  // if buffer shared
    m_sbuf.Resize(i_size);                  // resize will create a new one !
  } else {
    CTBint i_oldsize = m_sbuf.Size();
    if (i_oldsize < i_size) {               // buffer too small ?
      CTBint i_incsize = (i_oldsize <= 512) ? i_oldsize : i_oldsize/2;
      CTBint i_newsize = CTBmax(i_size,i_oldsize+i_incsize);
      m_sbuf.Resize(i_newsize);
    }
  }
  return;
}

//------------------------------------------+-----------------------------------

void CTBstring::NewString(const char* c_str, CTBint i_len)
{
  CTB_Trace("CTBstring::NewString(const char*, CTBint)");

  if (c_str) {                              // if non-null string
    EnsureUnsharedCapacity(i_len);
    if (i_len > 0) strncpy(&m_sbuf[0],c_str,i_len);
    m_sbuf[i_len] = 0;
    mi_length     = i_len;
    mi_offset     = 0;

  } else {                                  // if null string
    m_sbuf.Release();
    mi_length = 0;
    mi_offset = 0;
  }
  
  return;
}

//------------------------------------------+-----------------------------------

void CTBstring::NewString(const char* c_str1, CTBint i_len1,
                          const char* c_str2, CTBint i_len2)
{
  CTB_Trace("CTBstring::NewString(const char*, CTBint, const char*, CTBint)");

  if (c_str1 || c_str2) {                   // at least one non-null string
    CTBint i_length = i_len1 + i_len2;

    EnsureUnsharedCapacity(i_length);
    if (i_len1 > 0) strncpy(&m_sbuf[0],c_str1,i_len1);
    if (i_len2 > 0) strncpy(&m_sbuf[i_len1],c_str2,i_len2);
    m_sbuf[i_length] = 0;
    mi_length        = i_length;
    mi_offset        = 0;

  } else {                                  // both input string are null
    m_sbuf.Release();
    mi_length = 0;
    mi_offset = 0;
  }
  
  return;
}

//------------------------------------------+-----------------------------------

void CTBstring::AppendData(const char* c_str, CTBint i_len)
{
  CTB_Trace("CTBstring::AppendData(const char*, CTBint");

  if (i_len > 0) {                          // no action on zero length string
    CTBint i_oldlen = mi_length;
    CTBint i_newlen = i_oldlen + i_len;

    if (mi_offset == 0 &&                   // is no substring
        i_newlen+1 <= m_sbuf.Size() &&      // buffer large enough
        m_sbuf.IsUnique() ) {               // and not shared
      strncpy(&m_sbuf[mi_length],c_str,i_len);
      m_sbuf[i_newlen] = 0;
      mi_length        = i_newlen;

    } else {
      CTBstring lhs(*this, true);
      CTBint    i_newcap = CTBmax(2*i_oldlen, i_newlen);
      
      EnsureUnsharedCapacity(i_newcap);
      if (i_oldlen > 0) strncpy(&m_sbuf[0],lhs.Data(),i_oldlen);
      strncpy(&m_sbuf[i_oldlen],c_str,i_len);
      m_sbuf[i_newlen] = 0;
      mi_length        = i_newlen;
      mi_offset        = 0;
    }
  }

  return;
}

//------------------------------------------+-----------------------------------

void CTBstring::Terminate()
{
  CTB_Trace("CTBstring::Terminate()");

  if (m_sbuf.IsNull()) return;

  if (Data()[Length()] != 0) {              // string not terminated ?
    if (m_sbuf.IsUnique()) {                // if buffer not shared
      m_sbuf[mi_offset+mi_length] = 0;      // just terminate string
    } else {                                // if shared
      NewString(Data(),Length());           // recreate it
    }
  }
  return;
}

//------------------------------------------+-----------------------------------

CTBint CTBstring::FindCharacter(const char* c_set, CTBint i_len, 
                                CTBint i_offset) const
{
  CTB_Trace("CTBstring::FindCharacter(const char*, CTBint, CTBint)");

  if (mi_length > 0 && i_offset < mi_length && i_len > 0) {
    CTBint      i_off   = CTBmax(0,i_offset);

    for (CTBint i = i_off; i < mi_length; i++) {
      char c = m_sbuf[mi_offset+i];

      for (CTBint j = 0; j < i_len; j++) {
        if (c == c_set[j]) return i;
      }
    }
  }
  return mi_length;
}

---