Search  

---

C:/temp/src/j2k/Fred/String/StrANSI.cpp

Go to the documentation of this file.

#ifndef __J2K__JString_ANSI_CPP__
#define __J2K__JString_ANSI_CPP__

#include <j2k/Fred/String/String.hpp>
#include <j2k/Fred/String/Str-fn.hpp>

char* JString::getConcatenate( const char* src ) {
  size_t newLen = pData->length + strlen( src ) + 1;
  char* buffer = new char[ newLen ];
  strcpy( buffer, pData->data );
  strcat( buffer, src );
  buffer[ newLen ] = '\0';       // Safety Net.
  return buffer;
}

JString& JString::setConcatenate( const char* src ) {
  if ( src == NULL ) return *this;
  size_t newLen = pData->length + strlen(src);
  JStringData* sd = new JStringData( pData->data, newLen );
  JStringData* bsd = pData;      // Late delete
  pData = sd;
  strcat( pData->data, src );
  pData->data[ newLen ] = '\0';  // Safety Net.
  pData->length = strlen( sd->data );
  bsd->Dec();
  return ( *this );
}

long JString::firstCharFound( const int c ) {
  if ( pData->data == NULL ) return (-1);
  // Direct (Forward search)
  char* where = strchr( pData->data, c );
  if ( where == NULL ) return (-1);

  // e.g. 0xfff10 -= 0xfff00 => position 0x10
  long w = (long)where;
  w -= (long)pData->data;
  return w;
}

long JString::lastCharFound( const int c ) {
  if ( pData->data == NULL) return (-1);
  // Reverse (Backward search)
  char* where = strrchr( pData->data, c );
  if ( where == NULL ) return (-1);

  // e.g. 0xfff10 -= 0xfff00 => position 0x10
  long w = (long)where;
  w -= (long)pData->data;
  return w;
}

/* Defined in StrComp.cpp
int JString::compare( const char* src ) {
  return strcmp( pData->data, src );
}
*/

int JString::compareIgnoreCase( const char* src ) 
{
// GNU C++ compiler. Bug fixed. Submitted by Dog/Wolf.
#if defined(__sun) || defined(__SUN__) || defined (__GNUC__) 
  return strcasecmp( pData->data, src );
#else 
   return strcmpi( pData->data, src );
#endif

   // return stricmp( pData->data, src );
}

int JString::compareUsingLocaleCollate( const char* src ) {
  return strcoll( pData->data, src );  // Useless, if extern "C" or "C++"
}

char* JString::copy() {
  char* dst = new char[ pData->length + 1 ];
  return strcpy( dst, pData->data );
}

JString JString::getCopy() {
  JStringData* sd = new JStringData( pData->length );
  strcpy( sd->data, pData->data );
  return JString( sd );
}

size_t JString::getNbCharNotFromCharSet( const char* charset ) {
  return strcspn( pData->data, charset );
}

JString JString::getDate() {  // MM/DD/YY format (not Y2K complient !)
   JStringData* sd = new JStringData( 9 );
   _strdate( sd->data );
   return JString( sd );
}

JString& JString::setDate() {  // MM/DD/YY format (not Y2K complient !)
   JStringData* sd = new JStringData( 9 );
   _strdate( sd->data );
   pData->Dec();
   pData = sd;
   return ( *this );
}

JString& JString::setTime( size_t maxSize, const char* format,
                  const struct tm* currTime )
{
   JStringData* sd = new JStringData( maxSize );
   strftime( sd->data, maxSize, format, currTime );
   pData->Dec();
   pData = sd;
   return ( *this );
}

char* JString::duplicate() {
   return strdup( pData->data );
}

JString JString::duplicateString() {
   return JString( strdup( pData->data ) );
}

JString JString::getError( int errnb ) {
   char* err = strerror( errnb );
   return JString( err );
}

JString& JString::setError( int errnb ) {
   char* err = strerror( errnb );
// this = new JString( err );  // To Be FIXED

   if ( pData != NULL ) delete pData;
   pData = new JStringData( err );
   return ( *this );
}

JString JString::getTimeFormat( size_t maxSize, const char* format, const struct tm* currTime )
{
   JStringData* sd = new JStringData( maxSize );
   strftime( sd->data, maxSize, format, currTime );
   return JString( sd );
}

JString& JString::setTimeFormat( size_t maxSize, const char* format, const struct tm* currTime )
{
   JStringData* sd = new JStringData( maxSize );
   strftime( sd->data, maxSize, format, currTime );
   pData->Dec();
   pData = sd;
   return ( *this );
}

JString JString::getTime() {  // HH:MM:SS  (24h)
   JStringData* sd = new JStringData( 8 );
   _strtime( sd->data );
   return JString( sd );
}

JString& JString::setTime() {  // HH:MM:SS  (24h)
   JStringData* sd = new JStringData( 8 );
   _strtime( sd->data );
   pData->Dec();
   pData = sd;
   return ( *this );
}

char* JString::getConcatenateWithLimits( const char* src, size_t n ) {
  size_t newLen = pData->length + n + 1;
  char* buffer = new char[ newLen ];
  strcpy( buffer, pData->data );
  strncat( buffer, src, n );
  buffer[ newLen ] = '\0';  // Safety Net.
  return buffer;
}

JString& JString::setConcatenateWithLimits( const char* src, size_t n ) {
  if ( src == NULL ) return *this;
  size_t newLen = pData->length + n;
  JStringData* sd = new JStringData( pData->data, newLen );
  pData->Dec();
  pData = sd;
  strncat( pData->data, src, n );
  pData->data[ newLen ] = '\0';  // Safety Net.
  pData->length = strlen( sd->data );
  return ( *this );
}

int JString::compareWithLimits( const char* src, size_t n ) {
  return strncmp( pData->data, src, n );
}

int JString::compareIgnoreCaseWithLimits( const char* src, size_t n ) {
#if defined(__sun) || defined(__SUN__)
  return strncasecmp( pData->data, src, n );
#else
        return strnicmp( pData->data, src, n );
#endif
}

char* JString::copyWithLimits( size_t n ) {
  char* dst = new char[ pData->length + 1 ];
  return strncpy( dst, pData->data, n );
}

JString JString::getCopyWithLimits( size_t n ) {
  JStringData* sd = new JStringData( pData->length );
  strncpy( sd->data, pData->data, n );
  return JString( sd );
}

char* JString::getFillWithChar( const int ch ) {
  return getFillWithChar( ch, pData->length );
} // Same as strset()

JString& JString::setFillWithChar( const int ch ) {
  return setFillWithChar( ch, pData->length );
} // Same as strset()

// Fill the begin up to n with an ASCII character
char* JString::getFillWithChar( const int ch, size_t n ) {
  size_t newLen = pData->length + 1;
  char* buffer = new char[ newLen ];
  strcpy( buffer, pData->data );
  strnset( buffer, ch, n );
  buffer[ newLen ] = '\0';  // Safety Net.
  return buffer;
}

JString& JString::setFillWithChar( const int ch, size_t n ) {
  size_t newLen = pData->length;
  JStringData* sd = new JStringData( pData->data, newLen );
  pData->Dec();
  pData = sd;
  strnset( pData->data, ch, n );
  pData->data[ newLen ] = '\0';  // Safety Net.
  pData->length = strlen( sd->data );
  return ( *this );
}

long JString::locateCharSet( const char* charset ) {
  return locateCharSet( charset, 0 );
}

// Return Where is the first charset in String
long JString::locateCharSet( const char* charset, size_t startAt ) {
  if ( startAt >= pData->length ) return -1;
  char* p = pData->data + startAt;
  char* f = strpbrk( p, charset );
  return (long)( f - pData->data );
}

size_t JString::findCharset( const char* charset ) {
  return findCharset( charset, 0 );
}

// Return How much of charset in String
size_t JString::findCharset( const char* charset, size_t startAt ) {
  if ( startAt >= pData->length ) return 0;
  char* p = pData->data + startAt;
  return strspn( p, charset );
}

long JString::findString( const char* s ) {
  return findString( s, 0 );
}

// Return Where is the first String given in String
long JString::findString( const char* s, size_t startAt ) {
  if ( startAt >= pData->length ) return 0;
  char* p = pData->data + startAt;
  char* f = strstr( p, s );
  return (long)( f - pData->data );
}

double JString::toDouble() {
  return toDouble( 0 );
}

double JString::toDouble( size_t startAt ) {
  if ( startAt >= pData->length ) return 0;
  char* p = pData->data + startAt;
  return strtod( p, NULL );
}

long JString::toLong() {
  return toLong( 0, 10 );  // No OffSet, Decimal
}

long JString::toLong( size_t base ) {
  return toLong( 0, base );  // No OffSet, Base chosen
}

long JString::toLong( size_t startAt, size_t base ) {
  if ( startAt >= pData->length ) return 0;
  char* p = pData->data + startAt;
  return strtol( p, NULL, base );
}

ULONG JString::toULONG() {
  return toULONG( 0, 10 );  // No OffSet, Decimal
}

ULONG JString::toULONG( size_t base ) {
  return toULONG( 0, base );  // No OffSet, Base chosen
}

ULONG JString::toULONG( size_t startAt, size_t base ) {
  if ( startAt >= pData->length ) return 0;
  char* p = pData->data + startAt;
  return strtoul( p, NULL, base );
}

char* JString::getTransform( const char* src, size_t n ) {
  size_t newLen = pData->length + n + 1;
  char* buffer = new char[ newLen ];
  strcpy( buffer, pData->data );
  strxfrm( buffer, src, n );
  buffer[ newLen ] = '\0';  // Safety Net.
  return buffer;
}

JString& JString::setTransform( const char* src, size_t n ) {
  size_t newLen = pData->length + n;
  JStringData* sd = new JStringData( pData->data, newLen );
  pData->Dec();
  pData = sd;
  strxfrm( pData->data, src, n );
  pData->data[ newLen ] = '\0';  // Safety Net.
  pData->length = strlen( sd->data );
  return ( *this );
}

char* JString::getTokens( const char* delims, size_t startAt ) {
  if ( startAt >= pData->length ) return NULL;
  char* p = pData->data + startAt;
  char* buffer = strdup( p );
  char* f = strtok( buffer, delims );
  return f;
}

char* JString::getMoreTokens( const char* delims ) {
  return strtok( NULL, delims );
}

JString JString::getStringTokens( const char* delims, size_t startAt ) {
  if ( startAt >= pData->length ) return JString();
  char* p = pData->data + startAt;
  char* buffer = strdup( p );
  char* f = strtok( buffer, delims );
  return JString( f );
}

JString JString::getMoreStringTokens( const char* delims ) {
  return JString( strtok( NULL, delims ) );
}

#endif

---