diff options
Diffstat (limited to 'tqtinterface/qt4/src/tools/tqcstring.h')
| -rw-r--r-- | tqtinterface/qt4/src/tools/tqcstring.h | 792 |
1 files changed, 792 insertions, 0 deletions
diff --git a/tqtinterface/qt4/src/tools/tqcstring.h b/tqtinterface/qt4/src/tools/tqcstring.h new file mode 100644 index 0000000..8568713 --- /dev/null +++ b/tqtinterface/qt4/src/tools/tqcstring.h @@ -0,0 +1,792 @@ +/**************************************************************************** +** +** Definition of the extended char array operations, +** and TQByteArray and TQCString classes +** +** Created : 920609 +** +** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA. +** +** This file is part of the tools module of the TQt GUI Toolkit. +** +** This file may be used under the terms of the GNU General +** Public License versions 2.0 or 3.0 as published by the Free +** Software Foundation and appearing in the files LICENSE.GPL2 +** and LICENSE.GPL3 included in the packaging of this file. +** Alternatively you may (at your option) use any later version +** of the GNU General Public License if such license has been +** publicly approved by Trolltech ASA (or its successors, if any) +** and the KDE Free TQt Foundation. +** +** Please review the following information to ensure GNU General +** Public Licensing requirements will be met: +** http://trolltech.com/products/qt/licenses/licensing/opensource/. +** If you are unsure which license is appropriate for your use, please +** review the following information: +** http://trolltech.com/products/qt/licenses/licensing/licensingoverview +** or contact the sales department at sales@trolltech.com. +** +** This file may be used under the terms of the Q Public License as +** defined by Trolltech ASA and appearing in the file LICENSE.TQPL +** included in the packaging of this file. Licensees holding valid TQt +** Commercial licenses may use this file in accordance with the TQt +** Commercial License Agreement provided with the Software. +** +** This file is provided "AS IS" with NO WARRANTY OF ANY KIND, +** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted +** herein. +** +**********************************************************************/ + +#ifndef TQCSTRING_H +#define TQCSTRING_H + +#include "tqtglobaldefines.h" + +#ifndef TQT_H +#include "tqmemarray.h" +#endif // TQT_H + +#include <string.h> + +#ifdef USE_QT4 + +#include <Qt/qbytearray.h> +#include <Qt/qregexp.h> +#include <Qt/qstring.h> + +#endif // USE_QT4 + +/***************************************************************************** + Safe and portable C string functions; extensions to standard string.h + *****************************************************************************/ + +TQ_EXPORT void *tqmemmove( void *dst, const void *src, uint len ); + +TQ_EXPORT char *tqstrdup( const char * ); + +TQ_EXPORT inline uint tqstrlen( const char *str ) +{ return str ? (uint)strlen(str) : 0u; } + +TQ_EXPORT inline char *tqstrcpy( char *dst, const char *src ) +{ return src ? strcpy(dst, src) : 0; } + +TQ_EXPORT char *tqstrncpy( char *dst, const char *src, uint len ); + +TQ_EXPORT inline int tqstrcmp( const char *str1, const char *str2 ) +{ + return ( str1 && str2 ) ? strcmp( str1, str2 ) + : ( str1 ? 1 : ( str2 ? -1 : 0 ) ); +} + +TQ_EXPORT inline int tqstrncmp( const char *str1, const char *str2, uint len ) +{ + return ( str1 && str2 ) ? strncmp( str1, str2, len ) + : ( str1 ? 1 : ( str2 ? -1 : 0 ) ); +} + +TQ_EXPORT int tqstricmp( const char *, const char * ); + +TQ_EXPORT int tqstrnicmp( const char *, const char *, uint len ); + +#ifndef TQT_CLEAN_NAMESPACE +TQ_EXPORT inline uint cstrlen( const char *str ) +{ return (uint)strlen(str); } + +TQ_EXPORT inline char *cstrcpy( char *dst, const char *src ) +{ return strcpy(dst,src); } + +TQ_EXPORT inline int cstrcmp( const char *str1, const char *str2 ) +{ return strcmp(str1,str2); } + +TQ_EXPORT inline int cstrncmp( const char *str1, const char *str2, uint len ) +{ return strncmp(str1,str2,len); } +#endif + + +// qChecksum: Internet checksum + +TQ_EXPORT TQ_UINT16 qChecksum( const char *s, uint len ); + +/***************************************************************************** + TQByteArray class + *****************************************************************************/ + +#ifdef USE_QT4 + +// NOTE: Qt4 uses implicit sharing +// Qt3 used explicit sharing + +class TQ_EXPORT TQByteArray : public QByteArray +{ +public: + TQByteArray() : QByteArray() {} + TQByteArray( int size ) : QByteArray( size, '\0' ) {} + ~TQByteArray(); + + TQByteArray(const char *cs) : QByteArray( cs ) {} + TQByteArray(const char *cs, int size) : QByteArray( cs, size ) {} + TQByteArray(int size, char c) : QByteArray( size, c ) {} + TQByteArray(int size, Qt::Initialization init ) : QByteArray( size, init ) {} + TQByteArray(const TQByteArray &ba ) : QByteArray( ba/*.data(), ba.size()*/ ) {} + TQByteArray(const QByteArray &ba ) : QByteArray( ba/*.data(), ba.size()*/ ) {} + + inline char *data() { if (isNull()) return 0; return QByteArray::data(); } + inline const char *data() const { if (isNull()) return 0; return QByteArray::data(); } + inline const char *constData() const { if (isNull()) return 0; return QByteArray::constData(); } + + inline TQByteArray& assign( const TQByteArray& a ) { *this->operator=(a); return *this; } + inline TQByteArray& assign( const char *a, uint n ) { clear(); resize(n); insert(0, a, n); return *this; } + inline TQByteArray& duplicate(const TQByteArray& a) { *this = a; return *this; } + inline TQByteArray& duplicate(const char *a, uint n) { *this = TQByteArray(a, n); return *this; } + inline bool fill( char ch, int size = -1 ) { QByteArray::fill(ch, size); return TRUE; } + inline void resetRawData(const char *, uint) { clear(); } + inline QByteArray& setRawData(const char *a, uint n) { *this = fromRawData(a, n); return *this; } // Yes, I know about the built-in Qt4 version of this function. It is potentially unstable (corrupts memory) as of Qt4.7 and should not yet be used. Reevaluate this at Qt4.8 or above. [FIXME] + inline QByteArray lower() const { return toLower(); } + inline QByteArray upper() const { return toUpper(); } + inline QByteArray stripWhiteSpace() const { return trimmed(); } + inline QByteArray simplifyWhiteSpace() const { return simplified(); } + inline int tqfind(int c, int from = 0) const { return indexOf(c, from); } + inline int tqfind(char c, int from = 0) const { return indexOf(c, from); } + inline int tqfind(const char *c, int from = 0) const { return indexOf(c, from); } + inline int tqfind(const QByteArray &ba, int from = 0) const { return indexOf(ba, from); } + inline int tqfindRev(char c, int from = -1) const { return lastIndexOf(c, from); } + inline int tqfindRev(const char *c, int from = -1) const { return lastIndexOf(c, from); } + inline int tqfindRev(const QByteArray &ba, int from = -1) const { return lastIndexOf(ba, from); } +#ifndef QT_NO_CAST_TO_ASCII + inline int tqfind(const QString &s, int from = 0) const; + inline int tqfindRev(const QString &s, int from = -1) const; +#endif + inline TQByteArray copy() const { return TQByteArray(*this); } + inline QByteRef tqat( int i ) { +// #ifdef TQT_CHECK_RANGE + if ( (i >= size()) || (i < 0) ) { + qWarning( "TQByteArray::tqat: Absolute index %d out of range", i ); + i = 0; + } +// #endif + return QByteArray::operator[](i); + } + inline bool tqresize( uint newlen ) { resize(newlen); return true; } + inline bool tqresize( uint newlen, TQGArray::Optimization ) { resize(newlen); return true; } + + inline char &operator[]( int i ) { +// #ifdef TQT_CHECK_RANGE + if ( (i >= size()) || (i < 0) ) { + qWarning( "TQByteArray::operator[]: Absolute index %d out of range", i ); + i = 0; + } +// #endif + return *(this->data()+i); + } + + using QByteArray::operator=; + + // Interoperability +// static const TQByteArray& convertFromQByteArray( QByteArray& qba ); + static const TQByteArray convertFromQByteArray( QByteArray& qba ); +}; + +// Interoperability +// inline static const TQByteArray& convertFromQByteArray( const QByteArray& qba ) { +// return (*static_cast<const TQByteArray*>(&qba)); +// } +inline static const TQByteArray convertFromQByteArray( const QByteArray& qba ) { + return TQByteArray(qba); +} + +#ifndef TQT_NO_COMPRESS +TQ_EXPORT TQByteArray tqCompress( const uchar* data, int nbytes ); +TQ_EXPORT TQByteArray tqUncompress( const uchar* data, int nbytes ); +TQ_EXPORT inline TQByteArray tqCompress( const TQByteArray& data) +{ return tqCompress( (const uchar*)data.data(), data.size() ); } +TQ_EXPORT inline TQByteArray tqUncompress( const TQByteArray& data ) +{ return tqUncompress( (const uchar*)data.data(), data.size() ); } +#endif + +/***************************************************************************** + TQByteArray stream functions + *****************************************************************************/ +#ifndef TQT_NO_DATASTREAM +TQ_EXPORT TQDataStream &operator<<( TQDataStream &tqds, const TQByteArray &tqba ); +TQ_EXPORT TQDataStream &operator>>( TQDataStream &tqds, TQByteArray &tqba ); +#endif + +#else // USE_QT4 + +#if defined(TQ_TQDOC) +/* + We want qdoc to document TQByteArray as a real class that inherits + TQMemArray<char> and that is inherited by TQBitArray. +*/ +class TQByteArray : public TQMemArray<char> +{ +public: + TQByteArray(); + TQByteArray( int size ); +}; +#else +typedef TQMemArray<char> TQByteArray; +#endif + +#ifndef TQT_NO_COMPRESS +TQ_EXPORT TQByteArray tqCompress( const uchar* data, int nbytes ); +TQ_EXPORT TQByteArray tqUncompress( const uchar* data, int nbytes ); +TQ_EXPORT inline TQByteArray tqCompress( const TQByteArray& data) +{ return tqCompress( (const uchar*)data.data(), data.size() ); } +TQ_EXPORT inline TQByteArray tqUncompress( const TQByteArray& data ) +{ return tqUncompress( (const uchar*)data.data(), data.size() ); } +#endif + +/***************************************************************************** + TQByteArray stream functions + *****************************************************************************/ +#ifndef TQT_NO_DATASTREAM +TQ_EXPORT TQDataStream &operator<<( TQDataStream &, const TQByteArray & ); +TQ_EXPORT TQDataStream &operator>>( TQDataStream &, TQByteArray & ); +#endif + +#endif // USE_QT4 + +/***************************************************************************** + TQCString class + *****************************************************************************/ + +// #ifdef USE_QT4 +#if 0 + +#include <QtCore/qbytearray.h> +#include <QtCore/qdatastream.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Qt3SupportLight) + +/***************************************************************************** + QCString class + *****************************************************************************/ + +class QRegExp; + +class TQCString : public TQByteArray +{ +public: + TQCString() : TQByteArray() {} + TQCString(int size); + TQCString(const TQCString &s) : TQByteArray(s) {} + TQCString(const QByteArray &ba) : TQByteArray(ba.constData()) {} + TQCString(const char *str); + TQCString(const char *str, uint maxlen); + + ~TQCString(); + + TQCString &operator=(const TQCString &s); + TQCString &operator=(const char *str); + TQCString &operator=(const QByteArray &ba); + + TQCString copy() const { return *this; } + TQCString &sprintf(const char *format, ...); + + TQCString left(uint len) const { return QByteArray::left(len); } + TQCString right(uint len) const { return QByteArray::right(len); } + TQCString mid(uint index, uint len=0xffffffff) const { return QByteArray::mid(index, len); } + + TQCString leftJustify(uint width, char fill=' ', bool trunc=false)const; + TQCString rightJustify(uint width, char fill=' ',bool trunc=false)const; + + TQCString lower() const { return QByteArray::toLower(); } + TQCString upper() const { return QByteArray::toUpper(); } + + TQCString stripWhiteSpace() const { return QByteArray::trimmed(); } + TQCString simplifyWhiteSpace() const { return QByteArray::simplified(); } + + uint length() const; + bool truncate( uint pos ); + + TQCString &insert(uint index, const char *c) { QByteArray::insert(index, c); return *this; } + TQCString &insert(uint index, char c) { QByteArray::insert(index, c); return *this; } + TQCString &append(const char *c) { QByteArray::append(c); return *this; } + TQCString &prepend(const char *c) { QByteArray::prepend(c); return *this; } + TQCString &remove(uint index, uint len) { QByteArray::remove(index, len); return *this; } + TQCString &tqreplace(uint index, uint len, const char *c) + { TQByteArray::replace(index, len, c); return *this; } + TQCString &tqreplace(char c, const TQCString &after) { return tqreplace(c, after.constData()); } + TQCString &tqreplace(char c, const char *after) { QByteArray::replace(c, after); return *this; } + TQCString &tqreplace(const TQCString &b, const TQCString &a) + { return tqreplace(b.constData(), a.constData()); } + TQCString &tqreplace(const char *b, const char *a) { QByteArray::replace(b, a); return *this; } + TQCString &tqreplace(char b, char a) { QByteArray::replace(b, a); return *this; } + + short toShort(bool *ok=0) const; + ushort toUShort(bool *ok=0) const; + int toInt(bool *ok=0) const; + uint toUInt(bool *ok=0) const; + long toLong(bool *ok=0) const; + ulong toULong(bool *ok=0) const; + float toFloat(bool *ok=0) const; + double toDouble(bool *ok=0) const; + + TQCString &setStr(const char *s) { *this = s; return *this; } + TQCString &setNum(short); + TQCString &setNum(ushort); + TQCString &setNum(int); + TQCString &setNum(uint); + TQCString &setNum(long); + TQCString &setNum(ulong); + TQCString &setNum(float, char f='g', int prec=6); + TQCString &setNum(double, char f='g', int prec=6); + + bool setExpand(uint index, char c); + + int tqcontains( char c, bool cs=TRUE ) const; + int tqcontains( const char *str, bool cs=TRUE ) const; +#ifndef TQT_NO_REGEXP + int tqcontains( const QRegExp & ) const; +#endif + + int tqfind( char c, int index=0, bool cs=TRUE ) const; + int tqfind( const char *str, int index=0, bool cs=TRUE ) const; +#ifndef TQT_NO_REGEXP + int tqfind( const QRegExp &re, int index=0 ) const; +#endif + +#ifndef TQT_NO_REGEXP + TQCString &tqreplace( const QRegExp &, const char * ); +#endif + +// inline const char * tqstringFromPos( int index ) { const char & ref = (*this)[index]; return &ref; } + inline const char * tqstringFromPos( int index ) { return constData() + index; } + + operator const char *() const; + + TQCString &operator+=( const char *str ); + TQCString &operator+=( char c ); + TQCString &operator+=( const QString qs ); + TQCString &operator+=( const QByteArray qba ); + TQCString &operator+=( const TQCString tqcs ); + +private: + int tqfind( const char *str, int index, bool cs, uint l ) const; +}; + +inline TQCString::operator const char *() const +{ return (const char *)data(); } + +/***************************************************************************** + TQCString stream functions + *****************************************************************************/ +#ifndef QT_NO_DATASTREAM +QDataStream &operator<<(QDataStream &d, const TQCString &s); +QDataStream &operator>>(QDataStream &d, TQCString &s); + +TQDataStream &operator<<(TQDataStream &d, const TQCString &s); +TQDataStream &operator>>(TQDataStream &d, TQCString &s); +#endif + +/***************************************************************************** + TQCString inline functions + *****************************************************************************/ + +inline TQCString &TQCString::setNum(short n) +{ return setNum(long(n)); } + +inline TQCString &TQCString::setNum(ushort n) +{ return setNum(ulong(n)); } + +inline TQCString &TQCString::setNum(int n) +{ return setNum(long(n)); } + +inline TQCString &TQCString::setNum(uint n) +{ return setNum(ulong(n)); } + +inline TQCString &TQCString::setNum(float n, char f, int prec) +{ return setNum(double(n),f,prec); } + +/***************************************************************************** + TQCString non-member operators + *****************************************************************************/ + +Q_COMPAT_EXPORT inline bool operator==(const TQCString &s1, const TQCString &s2) +{ return tqstrcmp(s1, s2) == 0; } + +Q_COMPAT_EXPORT inline bool operator==(const TQCString &s1, const char *s2) +{ return tqstrcmp(s1, s2) == 0; } + +Q_COMPAT_EXPORT inline bool operator==(const char *s1, const TQCString &s2) +{ return tqstrcmp(s1, s2) == 0; } + +Q_COMPAT_EXPORT inline bool operator!=(const TQCString &s1, const TQCString &s2) +{ return tqstrcmp(s1, s2) != 0; } + +Q_COMPAT_EXPORT inline bool operator!=(const TQCString &s1, const char *s2) +{ return tqstrcmp(s1, s2) != 0; } + +Q_COMPAT_EXPORT inline bool operator!=(const char *s1, const TQCString &s2) +{ return tqstrcmp(s1, s2) != 0; } + +Q_COMPAT_EXPORT inline bool operator<(const TQCString &s1, const TQCString& s2) +{ return tqstrcmp(s1, s2) < 0; } + +Q_COMPAT_EXPORT inline bool operator<(const TQCString &s1, const char *s2) +{ return tqstrcmp(s1, s2) < 0; } + +Q_COMPAT_EXPORT inline bool operator<(const char *s1, const TQCString &s2) +{ return tqstrcmp(s1, s2) < 0; } + +Q_COMPAT_EXPORT inline bool operator<=(const TQCString &s1, const TQCString &s2) +{ return tqstrcmp(s1, s2) <= 0; } + +Q_COMPAT_EXPORT inline bool operator<=(const TQCString &s1, const char *s2) +{ return tqstrcmp(s1, s2) <= 0; } + +Q_COMPAT_EXPORT inline bool operator<=(const char *s1, const TQCString &s2) +{ return tqstrcmp(s1, s2) <= 0; } + +Q_COMPAT_EXPORT inline bool operator>(const TQCString &s1, const TQCString &s2) +{ return tqstrcmp(s1, s2) > 0; } + +Q_COMPAT_EXPORT inline bool operator>(const TQCString &s1, const char *s2) +{ return tqstrcmp(s1, s2) > 0; } + +Q_COMPAT_EXPORT inline bool operator>(const char *s1, const TQCString &s2) +{ return tqstrcmp(s1, s2) > 0; } + +Q_COMPAT_EXPORT inline bool operator>=(const TQCString &s1, const TQCString& s2) +{ return tqstrcmp(s1, s2) >= 0; } + +Q_COMPAT_EXPORT inline bool operator>=(const TQCString &s1, const char *s2) +{ return tqstrcmp(s1, s2) >= 0; } + +Q_COMPAT_EXPORT inline bool operator>=(const char *s1, const TQCString &s2) +{ return tqstrcmp(s1, s2) >= 0; } + +Q_COMPAT_EXPORT inline const TQCString operator+(const TQCString &s1, + const TQCString &s2) +{ + TQCString tmp(s1); + tmp += s2; + return tmp; +} +Q_COMPAT_EXPORT inline const TQCString operator+(const TQCString &s1, + const QByteArray &s2) +{ + QByteArray tmp(s1); + tmp += s2; + return tmp; +} +Q_COMPAT_EXPORT inline const TQCString operator+(const QByteArray &s1, + const TQCString &s2) +{ + QByteArray tmp(s1); + tmp += s2; + return tmp; +} + +Q_COMPAT_EXPORT inline const TQCString operator+(const TQCString &s1, const char *s2) +{ + TQCString tmp(s1); + tmp += s2; + return tmp; +} + +Q_COMPAT_EXPORT inline const TQCString operator+(const char *s1, const TQCString &s2) +{ + TQCString tmp(s1); + tmp += s2; + return tmp; +} + +Q_COMPAT_EXPORT inline const TQCString operator+(const TQCString &s1, char c2) +{ + TQCString tmp(s1); + tmp += c2; + return tmp; +} + +Q_COMPAT_EXPORT inline const TQCString operator+(char c1, const TQCString &s2) +{ + TQCString tmp; + tmp += c1; + tmp += s2; + return tmp; +} + +inline uint TQCString::length() const +{ + return tqstrlen( data() ); +} + +inline bool TQCString::truncate( uint pos ) +{ + return tqresize(pos+1); +} + +QT_END_NAMESPACE + +QT_END_HEADER + +#else // USE_QT4 + +class TQRegExp; + +class TQ_EXPORT TQCString : public TQByteArray // C string class +{ +public: + TQCString() {} // make null string + TQCString( int size ); // allocate size incl. \0 + TQCString( const TQCString &s ) : TQByteArray( s ) {} + TQCString( const QByteArray ba ) : TQByteArray( ba ) {} + TQCString( const char *str ); // deep copy + TQCString( const char *str, uint maxlen ); // deep copy, max length + ~TQCString(); + + TQCString &operator=( const TQCString &s );// shallow copy + TQCString &operator=( const char *str ); // deep copy + TQCString &operator=(const QByteArray &ba); + + bool isNull() const; + bool isEmpty() const; + uint length() const; + bool resize( uint newlen ) { return tqresize(newlen); } + bool tqresize( uint newlen ); + bool truncate( uint pos ); + bool fill( char c, int len = -1 ); + + TQCString copy() const; + + TQCString &sprintf( const char *format, ... ); + + int tqfind( char c, int index=0, bool cs=TRUE ) const; + int tqfind( const char *str, int index=0, bool cs=TRUE ) const; +#ifndef TQT_NO_REGEXP + int tqfind( const TQRegExp &, int index=0 ) const; +#endif + int tqfindRev( char c, int index=-1, bool cs=TRUE) const; + int tqfindRev( const char *str, int index=-1, bool cs=TRUE) const; +#ifndef TQT_NO_REGEXP_CAPTURE + int tqfindRev( const TQRegExp &, int index=-1 ) const; +#endif + int tqcontains( char c, bool cs=TRUE ) const; + int tqcontains( const char *str, bool cs=TRUE ) const; +#ifndef TQT_NO_REGEXP + int tqcontains( const TQRegExp & ) const; +#endif + TQCString left( uint len ) const; + TQCString right( uint len ) const; + TQCString mid( uint index, uint len=0xffffffff) const; + + TQCString leftJustify( uint width, char fill=' ', bool trunc=FALSE)const; + TQCString rightJustify( uint width, char fill=' ',bool trunc=FALSE)const; + + TQCString lower() const; + TQCString upper() const; + + TQCString stripWhiteSpace() const; + TQCString simplifyWhiteSpace() const; + + TQCString &insert( uint index, const char * ); + TQCString &insert( uint index, char ); + TQCString &append( const char * ); + TQCString &prepend( const char * ); + TQCString &remove( uint index, uint len ); + TQCString &tqreplace( uint index, uint len, const char * ); +#ifndef TQT_NO_REGEXP + TQCString &tqreplace( const TQRegExp &, const char * ); +#endif + TQCString &tqreplace( char c, const char *after ); + TQCString &tqreplace( const char *, const char * ); + TQCString &tqreplace( char, char ); + + short toShort( bool *ok=0 ) const; + ushort toUShort( bool *ok=0 ) const; + int toInt( bool *ok=0 ) const; + uint toUInt( bool *ok=0 ) const; + long toLong( bool *ok=0 ) const; + ulong toULong( bool *ok=0 ) const; + float toFloat( bool *ok=0 ) const; + double toDouble( bool *ok=0 ) const; + + TQCString &setStr( const char *s ); + TQCString &setNum( short ); + TQCString &setNum( ushort ); + TQCString &setNum( int ); + TQCString &setNum( uint ); + TQCString &setNum( long ); + TQCString &setNum( ulong ); + TQCString &setNum( float, char f='g', int prec=6 ); + TQCString &setNum( double, char f='g', int prec=6 ); + + inline const char * tqstringFromPos( int index ) { return constData() + index; } + + bool setExpand( uint index, char c ); + + operator const char *() const; + TQCString &operator+=( const char *str ); + TQCString &operator+=( char c ); + TQCString &operator+=( const QString qs ); + TQCString &operator+=( const QByteArray qba ); + TQCString &operator+=( const TQCString tqcs ); +private: + int tqfind( const char *str, int index, bool cs, uint l ) const; +}; + +/***************************************************************************** + TQCString stream functions + *****************************************************************************/ +#ifndef TQT_NO_DATASTREAM +TQ_EXPORT TQDataStream &operator<<( TQDataStream &, const TQCString & ); +TQ_EXPORT TQDataStream &operator>>( TQDataStream &, TQCString & ); +#endif + +/***************************************************************************** + TQCString inline functions + *****************************************************************************/ + +inline TQCString &TQCString::operator=( const TQCString &s ) +{ return (TQCString&)assign( s ); } + +inline TQCString &TQCString::operator=( const char *str ) +{ return (TQCString&)duplicate( str, tqstrlen(str)+1 ); } + +inline bool TQCString::isNull() const +{ return data() == 0; } + +inline bool TQCString::isEmpty() const +{ return data() == 0 || *data() == '\0'; } + +inline uint TQCString::length() const +{ return tqstrlen( data() ); } + +inline bool TQCString::truncate( uint pos ) +{ return resize(pos+1); } + +inline TQCString TQCString::copy() const +{ return TQCString( data() ); } + +inline TQCString &TQCString::prepend( const char *s ) +{ return insert(0,s); } + +inline TQCString &TQCString::append( const char *s ) +{ return operator+=(s); } + +inline TQCString &TQCString::setNum( short n ) +{ return setNum((long)n); } + +inline TQCString &TQCString::setNum( ushort n ) +{ return setNum((ulong)n); } + +inline TQCString &TQCString::setNum( int n ) +{ return setNum((long)n); } + +inline TQCString &TQCString::setNum( uint n ) +{ return setNum((ulong)n); } + +inline TQCString &TQCString::setNum( float n, char f, int prec ) +{ return setNum((double)n,f,prec); } + +inline TQCString::operator const char *() const +{ return (const char *)data(); } + + +/***************************************************************************** + TQCString non-member operators + *****************************************************************************/ + +TQ_EXPORT inline bool operator==( const TQCString &s1, const TQCString &s2 ) +{ return tqstrcmp( s1.data(), s2.data() ) == 0; } + +TQ_EXPORT inline bool operator==( const TQCString &s1, const char *s2 ) +{ return tqstrcmp( s1.data(), s2 ) == 0; } + +TQ_EXPORT inline bool operator==( const char *s1, const TQCString &s2 ) +{ return tqstrcmp( s1, s2.data() ) == 0; } + +TQ_EXPORT inline bool operator!=( const TQCString &s1, const TQCString &s2 ) +{ return tqstrcmp( s1.data(), s2.data() ) != 0; } + +TQ_EXPORT inline bool operator!=( const TQCString &s1, const char *s2 ) +{ return tqstrcmp( s1.data(), s2 ) != 0; } + +TQ_EXPORT inline bool operator!=( const char *s1, const TQCString &s2 ) +{ return tqstrcmp( s1, s2.data() ) != 0; } + +TQ_EXPORT inline bool operator<( const TQCString &s1, const TQCString& s2 ) +{ return tqstrcmp( s1.data(), s2.data() ) < 0; } + +TQ_EXPORT inline bool operator<( const TQCString &s1, const char *s2 ) +{ return tqstrcmp( s1.data(), s2 ) < 0; } + +TQ_EXPORT inline bool operator<( const char *s1, const TQCString &s2 ) +{ return tqstrcmp( s1, s2.data() ) < 0; } + +TQ_EXPORT inline bool operator<=( const TQCString &s1, const TQCString &s2 ) +{ return tqstrcmp( s1.data(), s2.data() ) <= 0; } + +TQ_EXPORT inline bool operator<=( const TQCString &s1, const char *s2 ) +{ return tqstrcmp( s1.data(), s2 ) <= 0; } + +TQ_EXPORT inline bool operator<=( const char *s1, const TQCString &s2 ) +{ return tqstrcmp( s1, s2.data() ) <= 0; } + +TQ_EXPORT inline bool operator>( const TQCString &s1, const TQCString &s2 ) +{ return tqstrcmp( s1.data(), s2.data() ) > 0; } + +TQ_EXPORT inline bool operator>( const TQCString &s1, const char *s2 ) +{ return tqstrcmp( s1.data(), s2 ) > 0; } + +TQ_EXPORT inline bool operator>( const char *s1, const TQCString &s2 ) +{ return tqstrcmp( s1, s2.data() ) > 0; } + +TQ_EXPORT inline bool operator>=( const TQCString &s1, const TQCString& s2 ) +{ return tqstrcmp( s1.data(), s2.data() ) >= 0; } + +TQ_EXPORT inline bool operator>=( const TQCString &s1, const char *s2 ) +{ return tqstrcmp( s1.data(), s2 ) >= 0; } + +TQ_EXPORT inline bool operator>=( const char *s1, const TQCString &s2 ) +{ return tqstrcmp( s1, s2.data() ) >= 0; } + +TQ_EXPORT inline const TQCString operator+( const TQCString &s1, + const TQCString &s2 ) +{ + TQCString tmp( s1.data() ); + tmp += static_cast<const char *>(s2); + return tmp; +} + +TQ_EXPORT inline const TQCString operator+( const TQCString &s1, const char *s2 ) +{ + TQCString tmp( s1.data() ); + tmp += s2; + return tmp; +} + +TQ_EXPORT inline const TQCString operator+( const char *s1, const TQCString &s2 ) +{ + TQCString tmp( s1 ); + tmp += static_cast<const char *>(s2); + return tmp; +} + +TQ_EXPORT inline const TQCString operator+( const TQCString &s1, char c2 ) +{ + TQCString tmp( s1.data() ); + tmp += c2; + return tmp; +} + +TQ_EXPORT inline const TQCString operator+( char c1, const TQCString &s2 ) +{ + TQCString tmp; + tmp += c1; + tmp += static_cast<const char *>(s2); + return tmp; +} +#include "tqwinexport.h" + +#endif // USE_QT4 + +#endif // TQCSTRING_H |