Search  

---

C:/temp/src/j2k/Deprecated/old_18mar_diff/Str14dec/StrLinux.cpp

Go to the documentation of this file.

#ifndef __J2K__JString_Linux_CPP__
#define __J2K__JString_Linux_CPP__

// Extra stuff for compatibility with the widely used Linux String class

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

void JString::Add( const char* s1, ULONG Len1, \
                   const char* s2, ULONG Len2, \
                   const char* s3, ULONG Len3, \
                   const char* s4, ULONG Len4, \
                   const char* s5, ULONG Len5, \
                   const char* s6, ULONG Len6, \
                   const char* s7, ULONG Len7, \
                   const char* s8, ULONG Len8, \
                   const char* s9, ULONG Len9, \
                   ULONG LenExtra )
{
  // -- Modify THIS JString Object.

  // Take care of NULL JString parameters, if any.
  if ( s1 == NULL  ||  *s1 == '\0' ) { Len1 = 0; }
  if ( s2 == NULL  ||  *s2 == '\0' ) { Len2 = 0; }
  if ( s3 == NULL  ||  *s3 == '\0' ) { Len3 = 0; }
  if ( s4 == NULL  ||  *s4 == '\0' ) { Len4 = 0; }
  if ( s5 == NULL  ||  *s5 == '\0' ) { Len5 = 0; }
  if ( s6 == NULL  ||  *s6 == '\0' ) { Len6 = 0; }
  if ( s7 == NULL  ||  *s7 == '\0' ) { Len7 = 0; }
  if ( s8 == NULL  ||  *s8 == '\0' ) { Len8 = 0; }
  if ( s9 == NULL  ||  *s9 == '\0' ) { Len9 = 0; }

  ULONG newLen = Len1 + Len2 + Len3 + Len4 + Len5 + Len6 + Len7 + Len8 + Len9;

  // Don't delete now, since memcpy will occur
  // in the case we delete ourself before copy !
  JStringData* sd = pData;

  if ( newLen > 0 ) {

  pData = new JStringData( newLen + LenExtra );

  ULONG pos = 0;

  if ( Len1 > 0 ) {  memcpy( pData->data + pos, s1, Len1 );  pos += Len1;  }
  if ( Len2 > 0 ) {  memcpy( pData->data + pos, s2, Len2 );  pos += Len2;  }
  if ( Len3 > 0 ) {  memcpy( pData->data + pos, s3, Len3 );  pos += Len3;  }
  if ( Len4 > 0 ) {  memcpy( pData->data + pos, s4, Len4 );  pos += Len4;  }
  if ( Len5 > 0 ) {  memcpy( pData->data + pos, s5, Len5 );  pos += Len5;  }
  if ( Len6 > 0 ) {  memcpy( pData->data + pos, s6, Len6 );  pos += Len6;  }
  if ( Len7 > 0 ) {  memcpy( pData->data + pos, s7, Len7 );  pos += Len7;  }
  if ( Len8 > 0 ) {  memcpy( pData->data + pos, s8, Len8 );  pos += Len8;  }
  if ( Len9 > 0 ) {  memcpy( pData->data + pos, s9, Len9 );  pos += Len9;  }

  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!

     i.e. If we pass a 'char c' as &c instead of a char* s = { c, 0 }
   */   

  } else { // strNull
    pData = strNull;
  }

  sd->Dec(); // Now you can suicide, we don't care.
}

const JString& JString::Add( const JString& S1, const JString& S2, const JString& S3, \
                             const JString& S4, const JString& S5, const JString& S6, \
                             const JString& S7, const JString& S8 ) 
{
    Add(    pData->data,      pData->length, S1.pData->data,   S1.pData->length, \
         S2.pData->data,   S2.pData->length, \
         S3.pData->data,   S3.pData->length, S4.pData->data,   S4.pData->length, \
         S5.pData->data,   S5.pData->length, S6.pData->data,   S6.pData->length, \
         S7.pData->data,   S7.pData->length, S8.pData->data,   S8.pData->length, 0 );

  return *this;
}


const JString& JString::Add( const JString& S1, const JString& S2, const JString& S3, \
                             const JString& S4, const JString& S5, const JString& S6, \
                             const JString& S7 )
{
    Add(    pData->data,      pData->length, S1.pData->data,   S1.pData->length, \
         S2.pData->data,   S2.pData->length, \
         S3.pData->data,   S3.pData->length, S4.pData->data,   S4.pData->length, \
         S5.pData->data,   S5.pData->length, S6.pData->data,   S6.pData->length, \
         S7.pData->data,   S7.pData->length );
  
  return *this;
}

const JString& JString::Add( const JString& S1, const JString& S2, const JString& S3, \
                             const JString& S4, const JString& S5, const JString& S6 )
{
    Add(    pData->data,      pData->length, S1.pData->data,   S1.pData->length, \
         S2.pData->data,   S2.pData->length, \
         S3.pData->data,   S3.pData->length, S4.pData->data,   S4.pData->length, \
         S5.pData->data,   S5.pData->length, S6.pData->data,   S6.pData->length );
  
  return *this;
}

const JString& JString::Add( const JString& S1, const JString& S2, const JString& S3,
                             const JString& S4, const JString& S5 )
{
    Add(    pData->data,      pData->length, S1.pData->data,   S1.pData->length, \
         S2.pData->data,   S2.pData->length, \
         S3.pData->data,   S3.pData->length, S4.pData->data,   S4.pData->length, \
         S5.pData->data,   S5.pData->length );

  return *this;
}

const JString& JString::Add( const JString& S1, const JString& S2,
                             const JString& S3, const JString& S4 )                   
{
    Add(    pData->data,      pData->length, S1.pData->data,   S1.pData->length, \
         S2.pData->data,   S2.pData->length, \
         S3.pData->data,   S3.pData->length, S4.pData->data,   S4.pData->length );
           
  return *this;
}

const JString& JString::Add( const JString& S1, const JString& S2, const JString& S3 )
{
    Add(    pData->data,      pData->length, S1.pData->data,   S1.pData->length, \
         S2.pData->data,   S2.pData->length, \
         S3.pData->data,   S3.pData->length );
  
  return *this;
}

// With Find(), it's VERY EASY to implement the derivates!

inline BOOL JString::contains( const JString& S, ULONG offset ) const
{
  return( Find( S, offset ) >= 0 );
}

inline BOOL JString::contains( const char* s, ULONG offset ) const
{
  return( Find( s, offset ) >= 0 );
}

inline BOOL JString::contains( char c, ULONG offset ) const
{
  return( Find( c, offset ) >= 0 );
}

inline BOOL JString::contains( const JString& S ) const
{
  return( Find( S, 0 ) >= 0 );
}
  
inline BOOL JString::contains( const char* s ) const   
{        
  return( Find( s, 0 ) >= 0 );
} 
    
inline BOOL JString::contains( char c ) const          
{
  return( Find( c, 0 ) >= 0 );
}

// Append BEFORE (at the head)
// JString s("world").prepend("hello") == "helloworld"

inline const JString& JString::append( const JString& S )
{
  Add( pData->data, S.pData->data, pData->length, S.pData->length );
  return *this;
}

inline const JString& JString::prepend( const JString& S )
{
  Add( S.pData->data, pData->data, S.pData->length, pData->length );
  return *this;
}

inline const JString& JString::append( const char* s )
{
  if ( s != NULL && *s != '\0' ) {
    Add( pData->data, s, pData->length, strlen( s ) );
  }
  return *this;
}   

inline const JString& JString::prepend( const char* s )
{
  if ( s != NULL && *s != '\0' ) {
    Add( s, pData->data, strlen( s ), pData->length );
  }
  return *this;
}

// WARNING:
// This works because Add() suppose 
// that the string is not NULL terminated!
inline const JString& JString::append( char c )   
{
  if ( c != '\0' ) {
    Add( pData->data, &c, pData->length, 1 );
  }
  return *this;
}
  
inline const JString& JString::prepend( char c )
{
  if ( c != '\0' ) {
    Add( &c, pData->data, 1, pData->length );
  }
  return *this;
}

#endif

---