This is the verbatim text of the qstring.h include file. It is is provided only for illustration; the copyright remains with Troll Tech.


/****************************************************************************
** $Id: qstring.h,v 1.18 1995/05/16 07:16:01 eiriken Exp $
**
** Definition of extended char array operations, and QByteArray and
** QString classes
**
** Author  : Haavard Nord
** Created : 920609
**
** Copyright (C) 1992-1995 by Troll Tech AS.  All rights reserved.
**
*****************************************************************************/

#ifndef QSTRING_H
#define QSTRING_H

#include "qarray.h"
#include <string.h>


// --------------------------------------------------------------------------
// Safe and portable C string functions; extensions to standard string.h
//

#if defined(_OS_SUN_) && !defined(_CC_GNU_)
#include <strings.h>
inline int stricmp( const char *s1, const char *s2 )
{ return strcasecmp( (char*)s1, (char*)s2 ); }  // use native strcasecmp
inline int strnicmp( const char *s1, const char *s2, uint sz )
{ return strncasecmp( (char*)s1, (char*)s2, sz ); }

#elif defined(_CC_GNU_)
extern "C" int strcasecmp( const char *, const char * );
extern "C" int strncasecmp( const char *, const char *, uint );
#define stricmp  strcasecmp                     // use native strcasecmp
#define strnicmp strncasecmp

#elif defined(_OS_MAC_) || defined(VXWORKS)
#define stricmp  qstricmp                       // use our own qstricmp
#define strnicmp qstrnicmp                      // use our own qstrnicmp

#elif defined(_CC_MSC_)
#define stricmp  _stricmp
#define strnicmp _strnicmp

#elif defined(_CC_BOR_)
extern "C" int stricmp( const char *, const char * );
extern "C" int strnicmp( const char *, const char *, uint );

#endif


void *qmemmove( void *dst, const void *src, uint len );

#if defined(_OS_SUN_) || defined(_CC_OC_)
#define memmove qmemmove
#endif

char *q_strdup( const char *src );              // safe duplicate string
#define strdup q_strdup

inline int q_strlen( const char *src )          // safe get string length
{
    return src ? strlen( src ) : 0;
}

#define strlen q_strlen

inline char *q_strcpy( char *dest, const char *src )
{                                               // safe copy string
    return src ? strcpy(dest, src) : 0;
}

#define strcpy q_strcpy

inline void qstrdel( char *&s )                 // safe delete and set to null
{
    delete s;
    s = 0;
}

inline char *qstrcpy( char *&dest, const char *src )
{                                               // delete and copy
    delete dest;
    return dest = strdup( src );
}


// qstrncpy: Same as strncpy, but guarantees that the result is 0-terminated,
//           possibly by overwriting the last character copied by strncpy.

inline char *qstrncpy( char *dest, const char *src, int len )
{
    strncpy( dest, src, len );
    if (len > 0)
        dest[len-1] = '\0';
    return dest;
}


// qstr.cmp:  Can handle null pointers. The result is zero when both pointers
//            are null, and an undefined non-zero value when only one of the
//            pointers is null.

inline int qstrcmp( const char *s1, const char *s2 )
{
    return (s1 && s2) ? strcmp(s1,s2) : (int)((long)s2 - (long)s1);
}

#define strcmp qstrcmp

inline int qstrncmp( const char *s1, const char *s2, uint len )
{
    return (s1 && s2) ? strncmp(s1,s2,len) : (int)((long)s2 - (long)s1);
}

#define strncmp qstrncmp

// qstricmp:  Case-insensitive string comparision
// qstrnicmp: Case-insensitive string comparision, compares max len chars

int qstricmp( const char *s1, const char *s2 );
int qstrnicmp( const char *s1, const char *s2, uint len );


// qchecksum: Internet checksum

UINT16 qchecksum( const char *s, uint len );


// --------------------------------------------------------------------------
// QByteArray class
//

declare(QArrayM,char);

#define QByteArray QArrayM(char)                // byte array class


// --------------------------------------------------------------------------
// QByteArray stream functions
//

QDataStream &operator<<( QDataStream &, const QByteArray & );
QDataStream &operator>>( QDataStream &, QByteArray & );


// --------------------------------------------------------------------------
// QString class
//

class QRegExp;

class QString : public QByteArray               // string class
{
public:
    QString() {}                                // make null string
    QString( int size );                        // allocate size incl. \0
    QString( const QString &s ) : QByteArray( s ) {}
    QString( const char *str );                 // deep copy

    QString    &operator=( const QString &s )   // shallow copy
        { return (QString&)assign( s ); }
    QString    &operator=( const char *str )    // deep copy
        { return (QString&)duplicate( str, strlen(str)+1 ); }

    bool        isEmpty() const { return QGArray::size() <= 1; }
    uint        length()  const;                // length of QString excl. \0
    bool        resize( uint newlen );          // resize incl. \0 terminator
    bool        truncate( uint pos );           // truncate excl. \0 terminator
    bool        fill( char c, int len = -1 );   // resize and fill string

    QString     copy() const                    // get deep copy
                  { QString tmp( (const char *)this->data() ); return tmp; }

    QString    &sprintf( const char *format, ... );
    QString    &stripWhiteSpace();              // removes white space
    QString    &simplifyWhiteSpace();           // removes more white space

    int         find( char c, int index=0, bool cs=TRUE ) const;
    int         find( const char *str, int index=0, bool cs=TRUE ) const;
    int         find( const QRegExp &, int index=0 ) const;
    int         findRev( char c, int index=-1, bool cs=TRUE) const;
    int         findRev( const char *str, int index=-1, bool cs=TRUE) const;
    int         findRev( const QRegExp &, int index=-1 ) const;
    int         contains( char c, bool cs=TRUE ) const;
    int         contains( const char *str, bool cs=TRUE ) const;
    int         contains( const QRegExp & ) const;

    QString     left( uint len )        const;  // get left substring
    QString     right( uint len )       const;  // get right substring
    QString     mid( uint index, uint len) const; // get mid substring

    QString     leftJustify( uint width, char fill=' ' )  const;
    QString     rightJustify( uint width, char fill=' ' ) const;

    QString    &lower();
    QString    &upper();

    QString    &insert( uint index, const char * );
    QString    &insert( uint index, char );
    QString    &remove( uint index, uint len );
    QString    &replace( uint index, uint len, const char * );
    QString    &replace( const QRegExp &, const char * );

    short       toShort( bool *ok=0 )   const;  // convert string to short
    ushort      toUShort( bool *ok=0 )  const;  // convert string to ushort
    int         toInt( bool *ok=0 )     const;  // convert string to int
    uint        toUInt( bool *ok=0 )    const;  // convert string to uint
    long        toLong( bool *ok=0 )    const;  // convert string to long
    ulong       toULong( bool *ok=0 )   const;  // convert string to ulong    
    float       toFloat( bool *ok=0 )   const;  // convert string to float
    double      toDouble( bool *ok=0 )  const;  // convert string to double

    QString    &setStr( const char *s );        // copy s, but not deref
    QString    &setNum( short );                // set string from short
    QString    &setNum( ushort );               // set string from ushort
    QString    &setNum( int );                  // set string from int
    QString    &setNum( uint );                 // set string from uint
    QString    &setNum( long );                 // set string from long
    QString    &setNum( ulong );                // set string from ulong
    QString    &setNum( float, char f='g', int prec=6 );
    QString    &setNum( double, char f='g', int prec=6 );

    bool        setExpand( uint index, char c );// set and expand if necessary

                operator char *() const       { return data(); }
                operator const char *() const { return (pcchar)data(); }
    bool        operator!() const             { return isNull(); }
    QString    &operator+=( const char *str );  // append str to this string
    QString    &operator+=( char c );           // append c to this string
};


// --------------------------------------------------------------------------
// QString inline functions
//

inline bool QString::truncate( uint pos )
{ return resize(pos+1); }

inline short QString::toShort( bool *ok ) const
{ return (short)toLong(ok); }

inline ushort QString::toUShort( bool *ok ) const
{ return (ushort)toULong(ok); }

inline int QString::toInt( bool *ok ) const
{ return (int)toLong(ok); }

inline uint QString::toUInt( bool *ok ) const
{ return (uint)toLong(ok); }

inline float QString::toFloat( bool *ok ) const
{ return (float)toDouble(ok); }

inline QString &QString::setNum( short n )
{ return setNum((long)n); }

inline QString &QString::setNum( ushort n )
{ return setNum((ulong)n); }

inline QString &QString::setNum( int n )
{ return setNum((long)n); }

inline QString &QString::setNum( uint n )
{ return setNum((ulong)n); }

inline QString &QString::setNum( float n, char f, int prec )
{ return setNum((double)n,f,prec); }


// --------------------------------------------------------------------------
// QString non-member operators
//

inline bool operator==( const QString &s1, const QString &s2 )
{ return strcmp(s1,s2) == 0; }

inline bool operator==( const QString &s1, const char* s2 )
{ return strcmp(s1,s2) == 0; }

inline bool operator==( const char* s1, const QString &s2 )
{ return strcmp(s1,s2) == 0; }

inline bool operator!=( const QString &s1, const QString &s2 )
{ return strcmp(s1,s2) != 0; }

inline bool operator!=( const QString &s1, const char* s2 )
{ return strcmp(s1,s2) != 0; }

inline bool operator!=( const char* s1, const QString &s2 )
{ return strcmp(s1,s2) != 0; }

inline bool operator<( const QString &s1, const QString &s2 )
{ return strcmp(s1,s2) < 0; }

inline bool operator<( const QString &s1, const char* s2 )
{ return strcmp(s1,s2) < 0; }

inline bool operator<( const char* s1, const QString &s2 )
{ return strcmp(s1,s2) < 0; }

inline bool operator>( const QString &s1, const QString &s2 )
{ return strcmp(s1,s2) > 0; }

inline bool operator>( const QString &s1, const char* s2 )
{ return strcmp(s1,s2) > 0; }

inline bool operator>( const char* s1, const QString &s2 )
{ return strcmp(s1,s2) > 0; }

inline bool operator<=( const QString &s1, const QString &s2 )
{ return strcmp(s1,s2) <= 0; }

inline bool operator<=( const QString &s1, const char* s2 )
{ return strcmp(s1,s2) <= 0; }

inline bool operator<=( const char* s1, const QString &s2 )
{ return strcmp(s1,s2) <= 0; }

inline bool operator>=( const QString &s1, const QString &s2 )
{ return strcmp(s1,s2) >= 0; }

inline bool operator>=( const QString &s1, const char* s2 )
{ return strcmp(s1,s2) >= 0; }

inline bool operator>=( const char* s1, const QString &s2 )
{ return strcmp(s1,s2) >= 0; }


inline QString operator+( const QString &s1, const QString &s2 )
{
    QString tmp( s1.data() );
    tmp += s2;
    return tmp;
}

inline QString operator+( const QString &s1, const char *s2 )
{
    QString tmp( s1.data() );
    tmp += s2;
    return tmp;
}

inline QString operator+( const char *s1, const QString &s2 )
{
    QString tmp( s1 );
    tmp += s2;
    return tmp;
}


#endif // QSTRING_H


Generated at 04:27, 1995/05/20 by the webmaster at Troll Tech