Search  

---

C:/temp/src/j2k/Fred/String/StringAt.inl

Go to the documentation of this file.

#ifndef __J2K__JString_At_INL__
#define __J2K__JString_At_INL__

#include <j2k/Fred/String/String.hpp>

// TODO:  Check for effects of LOCK functions !
// StrAdd also !

// Use CopyBeforeWrite();

/** ANDREA ***************************************************

  This module defines a few inline and a few regular
  methods. How do you think one can use it ? #including
  a .cpp (so recompiling all the functions every time) ?
**************************************************************/

// same as getAt
inline char JString::operator[](long index) const {
  if ( index < 0 ) return (char)NULL;
  return getAt( (size_t)index );
}

inline char JString::getAt( size_t index ) const {
  if ( (long)index == -1 ) return (char)NULL;
  if ( index >= pData->length ) {
    return (char)NULL;
  }
 
  return pData->data[ index ];
}

inline char JString::charAt() {
  JString temp = at( (size_t)0, (size_t)1 );
  register char c = temp.pData->data[0];
  temp.pData->Dec();
  return c;
}

inline char JString::charAt( const char* s ) {
  JString temp = at( s, (size_t)0, (size_t)1 );
  register char c = temp.pData->data[0];
  temp.pData->Dec();
  return c;
}

inline char JString::charAt( const JString& S ) {
  JString temp = at( S.pData->data, (size_t)0, (size_t)1 );
  register char c = temp.pData->data[0];
  temp.pData->Dec();
  return c;
}

inline const JString& JString::modifyAt( const JString& S )
{
  return modifyAt( S.pData->data, (size_t)0, S.pData->length );
}
               
inline const JString& JString::modifyAt( const JString& S, size_t offset )
{
  return modifyAt( S.pData->data, offset, S.pData->length );
}

inline const JString& JString::modifyAt( const JString& S, size_t offset, size_t length )
{
   return modifyAt( S.pData->data, offset, S.pData->length );
}

inline const JString& JString::modifyAt( const char* s )
{
   return modifyAt( s, (size_t)0, (size_t)0 );
}   

inline const JString& JString::modifyAt( const char* s, size_t offset )
{
   return modifyAt( s, offset, (size_t)0 );
}   

inline const JString& JString::modifyAt( const char* s, size_t offset, size_t length )
{
  if ( s == NULL || *s == '\0' ) return *this;

  long where = Find( s, offset );

  if ( where >= 0 ) 
  {
    // -- Modify THIS JString Object.

    JStringData* sd = pData;

    size_t l = strlen( s );
    long len = (long)length;

    if ( length > l || length == 0 ) len = l;

    long delta = (long)length - (long)offset - len;

    if ( delta >= 0 ) { // No buffer increase
      CopyBeforeWrite();
      memcpy( pData->data + where, s, len ); 

      pData->data[ pData->length ] = '\0';  

    } else {
      size_t newLen = sd->length - delta;
      pData = new JStringData( sd->data, newLen );  // It's  -(delta < 0) give us a +     
      memcpy( pData->data + where, s, len ); 

      pData->length = newLen;
      pData->data[ newLen ] = '\0';  

   /*
     This Null ending is needed since the last string
     might not be ended by '\0' or in case the copy
     doesn't go up to Zero. To be checked!
   */

      sd->Dec();  // Suicide we don't care.
    }
  }

  return *this;
}  

inline JString JString::at() { return JString( *this ); } // get a copy

inline JString JString::at( const char* s) {    return at( s, (size_t)0 ); }
inline JString JString::at( const JString& S) { return at( S.pData->data, (size_t)0 ); }

inline JString JString::at( const JString& S, size_t startpos ) {
  return at( S.pData->data, startpos );
}

inline JString JString::at( const JString& S, size_t startpos, size_t length ) {
  return at( S.pData->data, startpos, length );
}

inline JString JString::right( size_t length ) { 
  return at( pData->length - length, length ); 
}

inline JString JString::after( const char* s ) {
  if ( s == NULL || *s == '\0' ) return *this;
  long where = Find( s, (size_t)0 );
  if ( where >= 0 ) 
  {
    return at( (size_t)where );
  } else {
    return *this;
  }
}

inline JString JString::after( const char* s, size_t startpos ) {
  if ( s == NULL || *s == '\0' ) return *this;
  long where = Find( (char*)(s + startpos), (size_t)0 );
  if ( where >= 0 )
  {
    return at( (size_t)where + startpos );
  } else {
    return *this;
  }
}

inline JString JString::after( const char* s, size_t startpos, size_t length ) {
  if ( s == NULL || *s == '\0' ) return *this;
  long where = Find( (char*)(s + startpos), (size_t)0 );
  if ( where >= 0 )
  {
    return at( (size_t)where + startpos + 1, length );
  } else {
    return *this;
  }
}

inline JString JString::before( const char* s ) {
  if ( s == NULL || *s == '\0' ) return *this;
  long where = Find( s, (size_t)0 );
  if ( where >= 0 )
  {
    return at( (size_t)0, (size_t)where );
  } else {
    return *this;
  }
}

// startpos of Search not String!
// Design decision since it's more useful like that.
// startpos of String can be obtained in few steps or with mid
inline JString JString::before( const char* s, size_t startpos ) {
  if ( s == NULL || *s == '\0' ) return *this;
  long where = Find( s + startpos, 0 );
  if ( where >= 0 )
  {
    return at( (size_t)0, (size_t)where );
  } else {
    return *this;
  }
}

inline JString JString::beforeStr( const char* s, size_t startpos ) {
  if ( s == NULL || *s == '\0' ) return *this;
  long where = Find( s + startpos, (size_t)0 );
  if ( where >= 0 )
  {
    return at( startpos, (size_t)where );
  } else {
    return *this;
  }
}

inline JString JString::before( const char* s, size_t startpos, size_t length ) {
  if ( s == NULL || *s == '\0' ) return *this;
  long where = Find( s + startpos, (size_t)0 );
  if ( where >= 0 )
  {
    long ini = where - (long)length;
    if ( ini < 0 ) ini = 0;
    return at( (size_t)ini , (size_t)where );
  } else {
    return *this;
  }
}

inline JString JString::left( size_t length )  { 
  return at( (size_t)0, length ); 
}

inline JString JString::mid( const JString& S, size_t startpos, size_t length ) {
  return at( S.pData->data, startpos, length );
}

inline JString JString::mid( const char* s, size_t startpos, size_t length ) {
  return at( s, startpos, length );
}

inline JString JString::ltrim( char ch ) const {
  // find first single character
  // return -1 if not found and index otherwise
  for( size_t l = 0; l < pData->length; l++ ) {
    if ( pData->data[l] == ch ) return JString( pData->data+l );
  }
  return JString();
}

// Same as at:
// operator()(...) -> at(...)

inline JString JString::operator()( size_t startpos, size_t length ) { 
  return at( startpos, length ); 
}

inline JString JString::operator()( size_t startpos  ) { return at( startpos ); }
inline JString JString::operator()( const char* s    ) { return at( s, 0 ); }
inline JString JString::operator()( const JString& S ) { return at( S.pData->data, 0 ); }

inline JString JString::operator()( const char* s,    size_t startpos ) { 
  return at( s, startpos ); 
}

inline JString JString::operator()( const JString& S, size_t startpos ) { 
  return at( S.pData->data, startpos ); 
}

inline JString JString::operator()( const char* s,    size_t startpos, size_t length ) { 
  return at( s, startpos, length ); 
}

inline JString JString::operator()( const JString& S, size_t startpos, size_t length ) {
  return at( S.pData->data, startpos, length ); 
}

#endif

---