diff options
Diffstat (limited to 'tqtinterface/qt4/src/tools')
47 files changed, 646 insertions, 656 deletions
diff --git a/tqtinterface/qt4/src/tools/tqasciicache.h b/tqtinterface/qt4/src/tools/tqasciicache.h index 9a8d820..d783a95 100644 --- a/tqtinterface/qt4/src/tools/tqasciicache.h +++ b/tqtinterface/qt4/src/tools/tqasciicache.h @@ -75,10 +75,10 @@ public: { return TQGCache::remove_other(k); } type *take( const char *k ) { return (type *)TQGCache::take_other(k); } - type *tqfind( const char *k, bool ref=TRUE ) const - { return (type *)TQGCache::tqfind_other(k,ref);} + type *find( const char *k, bool ref=TRUE ) const + { return (type *)TQGCache::find_other(k,ref);} type *operator[]( const char *k ) const - { return (type *)TQGCache::tqfind_other(k);} + { return (type *)TQGCache::find_other(k);} void statistics() const { TQGCache::statistics(); } private: void deleteItem( Item d ); diff --git a/tqtinterface/qt4/src/tools/tqasciidict.h b/tqtinterface/qt4/src/tools/tqasciidict.h index fdab8b2..266d894 100644 --- a/tqtinterface/qt4/src/tools/tqasciidict.h +++ b/tqtinterface/qt4/src/tools/tqasciidict.h @@ -66,11 +66,11 @@ public: void insert( const char *k, const type *d ) { TQGDict::look_ascii(k,(Item)d,1); } - void tqreplace( const char *k, const type *d ) + void replace( const char *k, const type *d ) { TQGDict::look_ascii(k,(Item)d,2); } bool remove( const char *k ) { return TQGDict::remove_ascii(k); } type *take( const char *k ) { return (type *)TQGDict::take_ascii(k); } - type *tqfind( const char *k ) const + type *find( const char *k ) const { return (type *)((TQGDict*)this)->TQGDict::look_ascii(k,0,0); } type *operator[]( const char *k ) const { return (type *)((TQGDict*)this)->TQGDict::look_ascii(k,0,0); } diff --git a/tqtinterface/qt4/src/tools/tqbitarray.cpp b/tqtinterface/qt4/src/tools/tqbitarray.cpp index a741314..93bc527 100644 --- a/tqtinterface/qt4/src/tools/tqbitarray.cpp +++ b/tqtinterface/qt4/src/tools/tqbitarray.cpp @@ -507,7 +507,7 @@ TQBitArray &TQBitArray::operator^=( const TQBitArray &a ) } /*! - Returns a bit array that tqcontains the inverted bits of this bit array. + Returns a bit array that contains the inverted bits of this bit array. Example: \code diff --git a/tqtinterface/qt4/src/tools/tqcache.h b/tqtinterface/qt4/src/tools/tqcache.h index 72881d4..dd50b57 100644 --- a/tqtinterface/qt4/src/tools/tqcache.h +++ b/tqtinterface/qt4/src/tools/tqcache.h @@ -73,10 +73,10 @@ public: { return TQGCache::remove_string(k); } type *take( const TQString &k ) { return (type *)TQGCache::take_string(k); } - type *tqfind( const TQString &k, bool ref=TRUE ) const - { return (type *)TQGCache::tqfind_string(k,ref);} + type *find( const TQString &k, bool ref=TRUE ) const + { return (type *)TQGCache::find_string(k,ref);} type *operator[]( const TQString &k ) const - { return (type *)TQGCache::tqfind_string(k);} + { return (type *)TQGCache::find_string(k);} void statistics() const { TQGCache::statistics(); } private: void deleteItem( Item d ); diff --git a/tqtinterface/qt4/src/tools/tqcleanuphandler.h b/tqtinterface/qt4/src/tools/tqcleanuphandler.h index a7e5ea1..47e3484 100644 --- a/tqtinterface/qt4/src/tools/tqcleanuphandler.h +++ b/tqtinterface/qt4/src/tools/tqcleanuphandler.h @@ -60,7 +60,7 @@ public: void remove( Type **object ) { if ( !cleanupObjects ) return; - if ( cleanupObjects->tqfindRef( object ) >= 0 ) + if ( cleanupObjects->findRef( object ) >= 0 ) (void) cleanupObjects->take(); } diff --git a/tqtinterface/qt4/src/tools/tqcomlibrary.cpp b/tqtinterface/qt4/src/tools/tqcomlibrary.cpp index 253f9bf..4bbeee3 100644 --- a/tqtinterface/qt4/src/tools/tqcomlibrary.cpp +++ b/tqtinterface/qt4/src/tools/tqcomlibrary.cpp @@ -273,11 +273,11 @@ static bool tqt_parse_pattern( const char *s, uint *version, uint *flags, # include <sys/mman.h> #endif // TQ_OS_FREEBSD || TQ_OS_LINUX -static long qt_tqfind_pattern( const char *s, ulong s_len, +static long qt_find_pattern( const char *s, ulong s_len, const char *pattern, ulong p_len ) { /* - this uses the same algorithm as TQString::tqfindRev... + this uses the same algorithm as TQString::findRev... we search from the end of the file because on the supported systems, the read-only data/text segments are placed at the end @@ -358,7 +358,7 @@ static bool tqt_unix_query( const TQString &library, uint *version, uint *flags, // verify that the pattern is present in the plugin const char *pattern = "pattern=TQT_UCM_VERIFICATION_DATA"; const ulong plen = tqstrlen( pattern ); - long pos = qt_tqfind_pattern( filedata, fdlen, pattern, plen ); + long pos = qt_find_pattern( filedata, fdlen, pattern, plen ); bool ret = FALSE; if ( pos >= 0 ) { diff --git a/tqtinterface/qt4/src/tools/tqcomponentfactory.cpp b/tqtinterface/qt4/src/tools/tqcomponentfactory.cpp index 800e2b6..6aea36e 100644 --- a/tqtinterface/qt4/src/tools/tqcomponentfactory.cpp +++ b/tqtinterface/qt4/src/tools/tqcomponentfactory.cpp @@ -318,7 +318,7 @@ bool TQComponentFactory::unregisterComponent( const TQUuid &cid ) TQString version = vName.right( vName.length() - name.length() - 1 ); TQString newVerName; TQString newCidStr; - if ( version.tqfind( '.' ) == -1 ) { + if ( version.find( '.' ) == -1 ) { int ver = version.toInt(); // see if a lesser version is installed, and make that the CurVer while ( ver-- ) { diff --git a/tqtinterface/qt4/src/tools/tqcstring.cpp b/tqtinterface/qt4/src/tools/tqcstring.cpp index f81348f..4227c82 100644 --- a/tqtinterface/qt4/src/tools/tqcstring.cpp +++ b/tqtinterface/qt4/src/tools/tqcstring.cpp @@ -663,7 +663,7 @@ TQCString::TQCString( const char *str ) TQCString str( "helloworld", 6 ); // assigns "hello" to str \endcode - If \a str tqcontains a 0 byte within the first \a maxsize bytes, the + If \a str contains a 0 byte within the first \a maxsize bytes, the resulting TQCString will be terminated by this 0. If \a str is 0 a null string is created. @@ -736,7 +736,7 @@ TQCString &TQCString::operator=(const QByteArray &ba) { \note However, if you ask for the data pointer of a null TQCString by calling data(), then because the internal representation of the - null TQCString is shared, it will be detached and tqreplaced with a + null TQCString is shared, it will be detached and replaced with a non-shared, empty representation, a non-null data pointer will be returned, and subsequent calls to isNull() will return false. But if you ask for the data pointer of a null TQCString by calling @@ -755,12 +755,12 @@ TQCString &TQCString::operator=(const QByteArray &ba) { or right padded with characters using leftJustify() and rightJustify(). Characters, strings and regular expressions can be searched for using find() and findRev(), and counted using - tqcontains(). + contains(). Strings and characters can be inserted with insert() and appended with append(). A string can be prepended with prepend(). Characters can be removed from the string with remove() and - tqreplaced with tqreplace(). + replaced with replace(). Portions of a string can be extracted using left(), right() and mid(). Whitespace can be removed using stripWhiteSpace() and @@ -784,7 +784,7 @@ TQCString &TQCString::operator=(const QByteArray &ba) { Case insensitive operations and comparisons will be accurate if both strings contain only ASCII characters. (If \c $LC_CTYPE is set, most Unix systems do "the right thing".) Functions that this - affects include tqcontains(), find(), findRev(), \l operator<(), \l + affects include contains(), find(), findRev(), \l operator<(), \l operator<=(), \l operator>(), \l operator>=(), lower() and upper(). @@ -867,37 +867,37 @@ TQCString &TQCString::operator=(const QByteArray &ba) { */ /*! - \fn TQCString& TQCString::tqreplace(uint index, uint len, const char *c) + \fn TQCString& TQCString::replace(uint index, uint len, const char *c) \internal */ /*! - \fn TQCString& TQCString::tqreplace(char c, const TQCString &after) + \fn TQCString& TQCString::replace(char c, const TQCString &after) \internal */ /*! - \fn TQCString& TQCString::tqreplace(char c, const char *after) + \fn TQCString& TQCString::replace(char c, const char *after) \internal */ /*! - \fn TQCString& TQCString::tqreplace(const TQCString &b, const TQCString &a) + \fn TQCString& TQCString::replace(const TQCString &b, const TQCString &a) \internal */ /*! - \fn TQCString& TQCString::tqreplace(const char *b, const char *a) + \fn TQCString& TQCString::replace(const char *b, const char *a) \internal */ /*! - \fn TQCString& TQCString::tqreplace(char b, char a) + \fn TQCString& TQCString::replace(char b, char a) \internal */ @@ -949,7 +949,7 @@ TQCString &TQCString::operator=(const QByteArray &ba) { Example: \snippet doc/src/snippets/code/src_qt3support_tools_q3cstring.cpp 0 - If \a str tqcontains a 0 byte within the first \a maxsize bytes, the + If \a str contains a 0 byte within the first \a maxsize bytes, the resulting TQCString will be terminated by this 0. If \a str is 0 a null string is created. @@ -989,7 +989,7 @@ TQCString &TQCString::operator=(const QByteArray &ba) { \note If you ask for the data pointer of a null TQCString by calling data(), then because the internal representation of the - null TQCString is shared, it will be detached and tqreplaced with a + null TQCString is shared, it will be detached and replaced with a non-shared, empty representation, a non-null data pointer will be returned, and subsequent calls to isNull() will return false. But if you ask for the data pointer of a null TQCString by calling @@ -1093,7 +1093,7 @@ TQCString &TQCString::sprintf(const char *format, ...) /*! Returns a string of length \a width (plus one for the terminating - '\0') that tqcontains this string padded with the \a fill character. + '\0') that contains this string padded with the \a fill character. If the length of the string exceeds \a width and \a truncate is false (the default), then the returned string is a copy of the @@ -1126,7 +1126,7 @@ TQCString TQCString::leftJustify(uint width, char fill, bool truncate) const /*! Returns a string of length \a width (plus one for the terminating - '\0') that tqcontains zero or more of the \a fill character followed + '\0') that contains zero or more of the \a fill character followed by this string. If the length of the string exceeds \a width and \a truncate is @@ -1829,7 +1829,7 @@ TQDataStream &operator>>( TQDataStream &s, TQCString &str ) \sa \link #asciinotion Note on character comparisons \endlink */ -int TQCString::tqcontains( char c, bool cs ) const +int TQCString::contains( char c, bool cs ) const { int count = 0; const char *d = data(); @@ -1859,20 +1859,20 @@ int TQCString::tqcontains( char c, bool cs ) const \code TQString s = "banana and panama"; TQRegExp r = TQRegExp( "a[nm]a", TRUE, FALSE ); - s.tqcontains( r ); // 4 matches + s.contains( r ); // 4 matches \endcode - \sa tqfind(), tqfindRev() + \sa find(), findRev() \warning If you want to apply this function repeatedly to the same string it is more efficient to convert the string to a TQString and apply the function to that. */ -int TQCString::tqcontains( const QRegExp &rx ) const +int TQCString::contains( const QRegExp &rx ) const { TQString d = TQString::fromAscii( data() ); - return d.tqcontains( rx ); + return d.contains( rx ); } /*! @@ -1884,19 +1884,19 @@ int TQCString::tqcontains( const QRegExp &rx ) const if \a cs if FALSE. This function counts overlapping substrings, for example, "banana" - tqcontains two occurrences of "ana". + contains two occurrences of "ana". - \sa tqfindRev() + \sa findRev() \link #asciinotion Note on character comparisons \endlink */ -int TQCString::tqcontains( const char *str, bool cs ) const +int TQCString::contains( const char *str, bool cs ) const { int count = 0; int i = -1; uint l = length(); - // use tqfind for the faster hashing algorithm - while ( ( i = tqfind ( str, i+1, cs, l ) ) != -1 ) + // use find for the faster hashing algorithm + while ( ( i = find ( str, i+1, cs, l ) ) != -1 ) count++; return count; } @@ -1918,7 +1918,7 @@ int TQCString::tqcontains( const char *str, bool cs ) const \sa \link #asciinotion Note on character comparisons \endlink */ -int TQCString::tqfind( char c, int index, bool cs ) const +int TQCString::find( char c, int index, bool cs ) const { if ( (uint)index >= size() ) // index outside string return -1; @@ -1951,9 +1951,9 @@ int TQCString::tqfind( char c, int index, bool cs ) const \sa \link #asciinotion Note on character comparisons \endlink */ -int TQCString::tqfind( const char *str, int index, bool cs ) const +int TQCString::find( const char *str, int index, bool cs ) const { - return tqfind( str, index, cs, length() ); + return find( str, index, cs, length() ); } #ifndef TQT_NO_REGEXP_CAPTURE @@ -1971,14 +1971,14 @@ int TQCString::tqfind( const char *str, int index, bool cs ) const apply the function to that. */ -int TQCString::tqfind( const QRegExp& rx, int index ) const +int TQCString::find( const QRegExp& rx, int index ) const { TQString d = TQString::fromAscii( data() ); - return d.tqfind( rx, index ); + return d.find( rx, index ); } #endif // TQT_NO_REGEXP_CAPTURE -int TQCString::tqfind( const char *str, int index, bool cs, uint l ) const +int TQCString::find( const char *str, int index, bool cs, uint l ) const { if ( (uint)index >= size() ) return -1; @@ -1991,10 +1991,10 @@ int TQCString::tqfind( const char *str, int index, bool cs, uint l ) const return -1; if ( sl == 1 ) - return tqfind( *str, index, cs ); + return find( *str, index, cs ); /* - See TQString::tqfind() for details. + See TQString::find() for details. */ const char* needle = str; const char* haystack = data() + index; @@ -2050,13 +2050,13 @@ int TQCString::tqfind( const char *str, int index, bool cs, uint l ) const Example: \code TQString s = "banana"; - s.tqreplace( TQRegExp("a.*a"), "" ); // becomes "b" + s.replace( TQRegExp("a.*a"), "" ); // becomes "b" s = "banana"; - s.tqreplace( TQRegExp("^[bn]a"), "X" ); // becomes "Xnana" + s.replace( TQRegExp("^[bn]a"), "X" ); // becomes "Xnana" s = "banana"; - s.tqreplace( TQRegExp("^[bn]a"), "" ); // becomes "nana" + s.replace( TQRegExp("^[bn]a"), "" ); // becomes "nana" \endcode \warning If you want to apply this function repeatedly to the same @@ -2064,11 +2064,11 @@ int TQCString::tqfind( const char *str, int index, bool cs, uint l ) const apply the function to that. */ -TQCString &TQCString::tqreplace( const QRegExp &rx, const char *str ) +TQCString &TQCString::replace( const QRegExp &rx, const char *str ) { TQString d = TQString::fromAscii( data() ); TQString r = TQString::fromAscii( str ); - d.tqreplace( rx, r ); + d.replace( rx, r ); setStr( d.ascii() ); return *this; } @@ -2181,13 +2181,13 @@ QT_END_NAMESPACE can be filled with a character using fill(). Strings can be left or right padded with characters using leftJustify() and rightJustify(). Characters, strings and regular expressions can be - searched for using tqfind() and tqfindRev(), and counted using - tqcontains(). + searched for using find() and findRev(), and counted using + contains(). Strings and characters can be inserted with insert() and appended with append(). A string can be prepended with prepend(). Characters can be removed from the string with remove() and - tqreplaced with tqreplace(). + replaced with replace(). Portions of a string can be extracted using left(), right() and mid(). Whitespace can be removed using stripWhiteSpace() and @@ -2212,7 +2212,7 @@ QT_END_NAMESPACE Case insensitive operations and comparisons will be accurate if both strings contain only ASCII characters. (If \c $LC_CTYPE is set, most Unix systems do "the right thing".) Functions that this - affects include tqcontains(), tqfind(), tqfindRev(), \l operator<(), \l + affects include contains(), find(), findRev(), \l operator<(), \l operator<=(), \l operator>(), \l operator>=(), lower() and upper(). @@ -2286,7 +2286,7 @@ TQCString::TQCString( const char *str ) TQCString str( "helloworld", 6 ); // assigns "hello" to str \endcode - If \a str tqcontains a 0 byte within the first \a maxsize bytes, the + If \a str contains a 0 byte within the first \a maxsize bytes, the resulting TQCString will be terminated by this 0. If \a str is 0 a null string is created. @@ -2515,7 +2515,7 @@ bool TQCString::fill( char c, int len ) \sa \link #asciinotion Note on character comparisons \endlink */ -int TQCString::tqfind( char c, int index, bool cs ) const +int TQCString::find( char c, int index, bool cs ) const { if ( (uint)index >= size() ) // index outside string return -1; @@ -2553,12 +2553,12 @@ int TQCString::tqfind( char c, int index, bool cs ) const \sa \link #asciinotion Note on character comparisons \endlink */ -int TQCString::tqfind( const char *str, int index, bool cs ) const +int TQCString::find( const char *str, int index, bool cs ) const { - return tqfind( str, index, cs, length() ); + return find( str, index, cs, length() ); } -int TQCString::tqfind( const char *str, int index, bool cs, uint l ) const +int TQCString::find( const char *str, int index, bool cs, uint l ) const { if ( (uint)index >= size() ) return -1; @@ -2571,10 +2571,10 @@ int TQCString::tqfind( const char *str, int index, bool cs, uint l ) const return -1; if ( sl == 1 ) - return tqfind( *str, index, cs ); + return find( *str, index, cs ); /* - See TQString::tqfind() for details. + See TQString::find() for details. */ const char* needle = str; const char* haystack = data() + index; @@ -2633,7 +2633,7 @@ int TQCString::tqfind( const char *str, int index, bool cs, uint l ) const \sa \link #asciinotion Note on character comparisons \endlink */ -int TQCString::tqfindRev( char c, int index, bool cs ) const +int TQCString::findRev( char c, int index, bool cs ) const { register const char *b = data(); register const char *d; @@ -2668,10 +2668,10 @@ int TQCString::tqfindRev( char c, int index, bool cs ) const \sa \link #asciinotion Note on character comparisons \endlink */ -int TQCString::tqfindRev( const char *str, int index, bool cs ) const +int TQCString::findRev( const char *str, int index, bool cs ) const { /* - See TQString::tqfind() for explanations. + See TQString::find() for explanations. */ const uint sl = tqstrlen( str ); const uint l = length(); @@ -2684,7 +2684,7 @@ int TQCString::tqfindRev( const char *str, int index, bool cs ) const index = delta; if ( sl == 1 ) - return tqfindRev( *str, index, cs ); + return findRev( *str, index, cs ); const char* needle = str; const char* haystack = data() + index; @@ -2735,7 +2735,7 @@ int TQCString::tqfindRev( const char *str, int index, bool cs ) const \sa \link #asciinotion Note on character comparisons \endlink */ -int TQCString::tqcontains( char c, bool cs ) const +int TQCString::contains( char c, bool cs ) const { int count = 0; const char *d = data(); @@ -2765,25 +2765,25 @@ int TQCString::tqcontains( char c, bool cs ) const if \a cs if FALSE. This function counts overlapping substrings, for example, "banana" - tqcontains two occurrences of "ana". + contains two occurrences of "ana". - \sa tqfindRev() + \sa findRev() \link #asciinotion Note on character comparisons \endlink */ -int TQCString::tqcontains( const char *str, bool cs ) const +int TQCString::contains( const char *str, bool cs ) const { int count = 0; int i = -1; uint l = length(); - // use tqfind for the faster hashing algorithm - while ( ( i = tqfind ( str, i+1, cs, l ) ) != -1 ) + // use find for the faster hashing algorithm + while ( ( i = find ( str, i+1, cs, l ) ) != -1 ) count++; return count; } /*! - Returns a substring that tqcontains the \a len leftmost characters + Returns a substring that contains the \a len leftmost characters of the string. The whole string is returned if \a len exceeds the length of the @@ -2814,7 +2814,7 @@ TQCString TQCString::left( uint len ) const } /*! - Returns a substring that tqcontains the \a len rightmost characters + Returns a substring that contains the \a len rightmost characters of the string. The whole string is returned if \a len exceeds the length of the @@ -2844,7 +2844,7 @@ TQCString TQCString::right( uint len ) const } /*! - Returns a substring that tqcontains at most \a len characters from + Returns a substring that contains at most \a len characters from this string, starting at position \a index. Returns a null string if the string is empty or if \a index is out @@ -2879,7 +2879,7 @@ TQCString TQCString::mid( uint index, uint len ) const /*! Returns a string of length \a width (plus one for the terminating - '\0') that tqcontains this string padded with the \a fill character. + '\0') that contains this string padded with the \a fill character. If the length of the string exceeds \a width and \a truncate is FALSE (the default), then the returned string is a copy of the @@ -2916,7 +2916,7 @@ TQCString TQCString::leftJustify( uint width, char fill, bool truncate ) const /*! Returns a string of length \a width (plus one for the terminating - '\0') that tqcontains zero or more of the \a fill character followed + '\0') that contains zero or more of the \a fill character followed by this string. If the length of the string exceeds \a width and \a truncate is @@ -3053,7 +3053,7 @@ TQCString TQCString::stripWhiteSpace() const /*! Returns a new string that has white space removed from the start - and the end, plus any sequence of internal white space tqreplaced + and the end, plus any sequence of internal white space replaced with a single space (ASCII 32). White space means the decimal ASCII codes 9, 10, 11, 12, 13 and @@ -3148,7 +3148,7 @@ TQCString &TQCString::insert( uint index, const char *s ) s.insert( 3, '!'); // s == "Yes!" \endcode - \sa remove(), tqreplace() + \sa remove(), replace() */ TQCString &TQCString::insert( uint index, char c ) // insert char @@ -3180,7 +3180,7 @@ TQCString &TQCString::insert( uint index, char c ) // insert char s.remove( 1, 4 ); // s == "Meal" \endcode - \sa insert(), tqreplace() + \sa insert(), replace() */ TQCString &TQCString::remove( uint index, uint len ) @@ -3206,17 +3206,17 @@ TQCString &TQCString::remove( uint index, uint len ) If \a index is out of range, nothing is removed and \a str is appended at the end of the string. If \a index is valid, but \a index + \a len is larger than the length of the string, \a str - tqreplaces the rest of the string from position \a index. + replaces the rest of the string from position \a index. \code TQCString s = "Say yes!"; - s.tqreplace( 4, 3, "NO" ); // s == "Say NO!" + s.replace( 4, 3, "NO" ); // s == "Say NO!" \endcode \sa insert(), remove() */ -TQCString &TQCString::tqreplace( uint index, uint len, const char *str ) +TQCString &TQCString::replace( uint index, uint len, const char *str ) { remove( index, len ); insert( index, str ); @@ -3232,16 +3232,16 @@ TQCString &TQCString::tqreplace( uint index, uint len, const char *str ) Example: \code TQCString s = "a,b,c"; - s.tqreplace( ',', " or " ); + s.replace( ',', " or " ); // s == "a or b or c" \endcode */ -TQCString &TQCString::tqreplace( char c, const char *after ) +TQCString &TQCString::replace( char c, const char *after ) { char str[2]; str[0] = c; str[1] = '\0'; - return tqreplace( str, after ); + return replace( str, after ); } /*! \overload @@ -3252,12 +3252,12 @@ TQCString &TQCString::tqreplace( char c, const char *after ) Example: \code TQCString s = "Greek is Greek"; - s.tqreplace( "Greek", "English" ); + s.replace( "Greek", "English" ); // s == "English is English" \endcode */ -TQCString &TQCString::tqreplace( const char *before, const char *after ) +TQCString &TQCString::replace( const char *before, const char *after ) { if ( before == after || isNull() ) return *this; @@ -3272,7 +3272,7 @@ TQCString &TQCString::tqreplace( const char *before, const char *after ) if ( bl == al ) { if ( bl ) { - while( (index = tqfind( before, index, TRUE, len ) ) != -1 ) { + while( (index = find( before, index, TRUE, len ) ) != -1 ) { memcpy( d+index, after, al ); index += bl; } @@ -3281,7 +3281,7 @@ TQCString &TQCString::tqreplace( const char *before, const char *after ) uint to = 0; uint movestart = 0; uint num = 0; - while( (index = tqfind( before, index, TRUE, len ) ) != -1 ) { + while( (index = find( before, index, TRUE, len ) ) != -1 ) { if ( num ) { int msize = index - movestart; if ( msize > 0 ) { @@ -3312,7 +3312,7 @@ TQCString &TQCString::tqreplace( const char *before, const char *after ) uint indices[4096]; uint pos = 0; while( pos < 4095 ) { - index = tqfind(before, index, TRUE, len); + index = find(before, index, TRUE, len); if ( index == -1 ) break; indices[pos++] = index; @@ -3324,7 +3324,7 @@ TQCString &TQCString::tqreplace( const char *before, const char *after ) if ( !pos ) break; - // we have a table of tqreplacement positions, use them for fast replacing + // we have a table of replacement positions, use them for fast replacing int adjust = pos*(al-bl); // index has to be adjusted in case we get back into the loop above. if ( index != -1 ) @@ -3357,7 +3357,7 @@ TQCString &TQCString::tqreplace( const char *before, const char *after ) Replaces every occurrence of \a c1 with the char \a c2. Returns a reference to the string. */ -TQCString &TQCString::tqreplace( char c1, char c2 ) +TQCString &TQCString::replace( char c1, char c2 ) { detach(); uint i = 0; @@ -3387,10 +3387,10 @@ TQCString &TQCString::tqreplace( char c1, char c2 ) apply the function to that. */ -int TQCString::tqfind( const TQRegExp& rx, int index ) const +int TQCString::find( const TQRegExp& rx, int index ) const { TQString d = TQString::fromAscii( data() ); - return d.tqfind( rx, index ); + return d.find( rx, index ); } /*! @@ -3407,10 +3407,10 @@ int TQCString::tqfind( const TQRegExp& rx, int index ) const apply the function to that. */ -int TQCString::tqfindRev( const TQRegExp& rx, int index ) const +int TQCString::findRev( const TQRegExp& rx, int index ) const { TQString d = TQString::fromAscii( data() ); - return d.tqfindRev( rx, index ); + return d.findRev( rx, index ); } /*! @@ -3422,20 +3422,20 @@ int TQCString::tqfindRev( const TQRegExp& rx, int index ) const \code TQString s = "banana and panama"; TQRegExp r = TQRegExp( "a[nm]a", TRUE, FALSE ); - s.tqcontains( r ); // 4 matches + s.contains( r ); // 4 matches \endcode - \sa tqfind(), tqfindRev() + \sa find(), findRev() \warning If you want to apply this function repeatedly to the same string it is more efficient to convert the string to a TQString and apply the function to that. */ -int TQCString::tqcontains( const TQRegExp &rx ) const +int TQCString::contains( const TQRegExp &rx ) const { TQString d = TQString::fromAscii( data() ); - return d.tqcontains( rx ); + return d.contains( rx ); } @@ -3448,13 +3448,13 @@ int TQCString::tqcontains( const TQRegExp &rx ) const Example: \code TQString s = "banana"; - s.tqreplace( TQRegExp("a.*a"), "" ); // becomes "b" + s.replace( TQRegExp("a.*a"), "" ); // becomes "b" s = "banana"; - s.tqreplace( TQRegExp("^[bn]a"), "X" ); // becomes "Xnana" + s.replace( TQRegExp("^[bn]a"), "X" ); // becomes "Xnana" s = "banana"; - s.tqreplace( TQRegExp("^[bn]a"), "" ); // becomes "nana" + s.replace( TQRegExp("^[bn]a"), "" ); // becomes "nana" \endcode \warning If you want to apply this function repeatedly to the same @@ -3462,11 +3462,11 @@ int TQCString::tqcontains( const TQRegExp &rx ) const apply the function to that. */ -TQCString &TQCString::tqreplace( const TQRegExp &rx, const char *str ) +TQCString &TQCString::replace( const TQRegExp &rx, const char *str ) { TQString d = TQString::fromAscii( data() ); TQString r = TQString::fromAscii( str ); - d.tqreplace( rx, r ); + d.replace( rx, r ); setStr( d.ascii() ); return *this; } diff --git a/tqtinterface/qt4/src/tools/tqcstring.h b/tqtinterface/qt4/src/tools/tqcstring.h index 8568713..2b6a28d 100644 --- a/tqtinterface/qt4/src/tools/tqcstring.h +++ b/tqtinterface/qt4/src/tools/tqcstring.h @@ -147,16 +147,16 @@ public: 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); } + inline int find(int c, int from = 0) const { return indexOf(c, from); } + inline int find(char c, int from = 0) const { return indexOf(c, from); } + inline int find(const char *c, int from = 0) const { return indexOf(c, from); } + inline int find(const QByteArray &ba, int from = 0) const { return indexOf(ba, from); } + inline int findRev(char c, int from = -1) const { return lastIndexOf(c, from); } + inline int findRev(const char *c, int from = -1) const { return lastIndexOf(c, from); } + inline int findRev(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; + inline int find(const QString &s, int from = 0) const; + inline int findRev(const QString &s, int from = -1) const; #endif inline TQByteArray copy() const { return TQByteArray(*this); } inline QByteRef tqat( int i ) { @@ -311,14 +311,14 @@ public: 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) + TQCString &replace(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; } + TQCString &replace(char c, const TQCString &after) { return TQByteArray::replace(c, after.constData()); } + TQCString &replace(char c, const char *after) { QByteArray::replace(c, after); return *this; } + TQCString &replace(const TQCString &b, const TQCString &a) + { return TQByteArray::replace(b.constData(), a.constData()); } + TQCString &replace(const char *b, const char *a) { QByteArray::replace(b, a); return *this; } + TQCString &replace(char b, char a) { QByteArray::replace(b, a); return *this; } short toShort(bool *ok=0) const; ushort toUShort(bool *ok=0) const; @@ -341,20 +341,20 @@ public: bool setExpand(uint index, char c); - int tqcontains( char c, bool cs=TRUE ) const; - int tqcontains( const char *str, bool cs=TRUE ) const; + int contains( char c, bool cs=TRUE ) const; + int contains( const char *str, bool cs=TRUE ) const; #ifndef TQT_NO_REGEXP - int tqcontains( const QRegExp & ) const; + int contains( 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; + int find( char c, int index=0, bool cs=TRUE ) const; + int find( const char *str, int index=0, bool cs=TRUE ) const; #ifndef TQT_NO_REGEXP - int tqfind( const QRegExp &re, int index=0 ) const; + int find( const QRegExp &re, int index=0 ) const; #endif #ifndef TQT_NO_REGEXP - TQCString &tqreplace( const QRegExp &, const char * ); + TQCString &replace( const QRegExp &, const char * ); #endif // inline const char * tqstringFromPos( int index ) { const char & ref = (*this)[index]; return &ref; } @@ -369,7 +369,7 @@ public: TQCString &operator+=( const TQCString tqcs ); private: - int tqfind( const char *str, int index, bool cs, uint l ) const; + int find( const char *str, int index, bool cs, uint l ) const; }; inline TQCString::operator const char *() const @@ -559,20 +559,20 @@ public: 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; + int find( char c, int index=0, bool cs=TRUE ) const; + int find( const char *str, int index=0, bool cs=TRUE ) const; #ifndef TQT_NO_REGEXP - int tqfind( const TQRegExp &, int index=0 ) const; + int find( 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; + int findRev( char c, int index=-1, bool cs=TRUE) const; + int findRev( const char *str, int index=-1, bool cs=TRUE) const; #ifndef TQT_NO_REGEXP_CAPTURE - int tqfindRev( const TQRegExp &, int index=-1 ) const; + int findRev( const TQRegExp &, int index=-1 ) const; #endif - int tqcontains( char c, bool cs=TRUE ) const; - int tqcontains( const char *str, bool cs=TRUE ) const; + int contains( char c, bool cs=TRUE ) const; + int contains( const char *str, bool cs=TRUE ) const; #ifndef TQT_NO_REGEXP - int tqcontains( const TQRegExp & ) const; + int contains( const TQRegExp & ) const; #endif TQCString left( uint len ) const; TQCString right( uint len ) const; @@ -592,13 +592,13 @@ public: TQCString &append( const char * ); TQCString &prepend( const char * ); TQCString &remove( uint index, uint len ); - TQCString &tqreplace( uint index, uint len, const char * ); + TQCString &replace( uint index, uint len, const char * ); #ifndef TQT_NO_REGEXP - TQCString &tqreplace( const TQRegExp &, const char * ); + TQCString &replace( const TQRegExp &, const char * ); #endif - TQCString &tqreplace( char c, const char *after ); - TQCString &tqreplace( const char *, const char * ); - TQCString &tqreplace( char, char ); + TQCString &replace( char c, const char *after ); + TQCString &replace( const char *, const char * ); + TQCString &replace( char, char ); short toShort( bool *ok=0 ) const; ushort toUShort( bool *ok=0 ) const; @@ -630,7 +630,7 @@ public: TQCString &operator+=( const QByteArray qba ); TQCString &operator+=( const TQCString tqcs ); private: - int tqfind( const char *str, int index, bool cs, uint l ) const; + int find( const char *str, int index, bool cs, uint l ) const; }; /***************************************************************************** diff --git a/tqtinterface/qt4/src/tools/tqdatetime.cpp b/tqtinterface/qt4/src/tools/tqdatetime.cpp index 4f95dd1..2b28868 100644 --- a/tqtinterface/qt4/src/tools/tqdatetime.cpp +++ b/tqtinterface/qt4/src/tools/tqdatetime.cpp @@ -161,7 +161,7 @@ static TQString fmtDateTime( const TQString& f, const TQTime* dt = 0, const TQDa if ( dd && !dd->isValid() ) return TQString::null; - bool ap = ( f.tqcontains( "AP" ) || f.tqcontains( "ap" ) ); + bool ap = ( f.contains( "AP" ) || f.contains( "ap" ) ); TQString buf; TQString frm; @@ -213,7 +213,7 @@ static TQString fmtDateTime( const TQString& f, const TQTime* dt = 0, const TQDa \ingroup time \mainclass - A TQDate object tqcontains a calendar date, i.e. year, month, and day + A TQDate object contains a calendar date, i.e. year, month, and day numbers, in the modern Western (Gregorian) calendar. It can read the current date from the system clock. It provides functions for comparing dates and for manipulating dates, e.g. by adding a @@ -270,7 +270,7 @@ static TQString fmtDateTime( const TQString& f, const TQTime* dt = 0, const TQDa \enum TQt::TimeSpec \value LocalTime Locale dependent time (Timezones and Daylight Savings Time) - \value UTC Coordinated Universal Time, tqreplaces Greenwich Time + \value UTC Coordinated Universal Time, replaces Greenwich Time */ /*! @@ -1101,8 +1101,8 @@ TQDate TQDate::fromString( const TQString& s, TQt::DateFormat f ) This will fail gracefully if the input string doesn't contain any space. */ - int monthPos = s.tqfind( ' ' ) + 1; - int dayPos = s.tqfind( ' ', monthPos ) + 1; + int monthPos = s.find( ' ' ) + 1; + int dayPos = s.find( ' ', monthPos ) + 1; TQString monthName( s.mid(monthPos, dayPos - monthPos - 1) ); int month = -1; @@ -1252,7 +1252,7 @@ void TQDate::julianToGregorian( uint jd, int &y, int &m, int &d ) \ingroup time \mainclass - A TQTime object tqcontains a clock time, i.e. the number of hours, + A TQTime object contains a clock time, i.e. the number of hours, minutes, seconds, and milliseconds since midnight. It can read the current time from the system clock and measure a span of elapsed time. It provides functions for comparing times and for @@ -1265,7 +1265,7 @@ void TQDate::julianToGregorian( uint jd, int &y, int &m, int &d ) A TQTime object is typically created either by giving the number of hours, minutes, seconds, and milliseconds explicitly, or by using the static function currentTime(), which creates a TQTime object - that tqcontains the system's clock time. Note that the accuracy + that contains the system's clock time. Note that the accuracy depends on the accuracy of the underlying operating system; not all systems provide 1-millisecond accuracy. @@ -1458,9 +1458,9 @@ TQString TQTime::toString( TQt::DateFormat f ) const \row \i z \i the milliseconds without leading zeroes (0..999) \row \i zzz \i the milliseconds with leading zeroes (000..999) \row \i AP - \i use AM/PM display. \e AP will be tqreplaced by either "AM" or "PM". + \i use AM/PM display. \e AP will be replaced by either "AM" or "PM". \row \i ap - \i use am/pm display. \e ap will be tqreplaced by either "am" or "pm". + \i use am/pm display. \e ap will be replaced by either "am" or "pm". \endtable All other input characters will be ignored. @@ -1873,7 +1873,7 @@ int TQTime::elapsed() const \ingroup time \mainclass - A TQDateTime object tqcontains a calendar date and a clock time (a + A TQDateTime object contains a calendar date and a clock time (a "datetime"). It is a combination of the TQDate and TQTime classes. It can read the current datetime from the system clock. It provides functions for comparing datetimes and for manipulating a @@ -2200,9 +2200,9 @@ TQString TQDateTime::toString( TQt::DateFormat f ) const \row \i z \i the milliseconds without leading zeroes (0..999) \row \i zzz \i the milliseconds with leading zeroes (000..999) \row \i AP - \i use AM/PM display. \e AP will be tqreplaced by either "AM" or "PM". + \i use AM/PM display. \e AP will be replaced by either "AM" or "PM". \row \i ap - \i use am/pm display. \e ap will be tqreplaced by either "am" or "pm". + \i use am/pm display. \e ap will be replaced by either "am" or "pm". \endtable All other input characters will be ignored. @@ -2465,7 +2465,7 @@ TQDateTime TQDateTime::fromString( const TQString& s, TQt::DateFormat f ) } #if !defined(TQT_NO_REGEXP) && !defined(TQT_NO_TEXTDATE) else if ( f == TQt::TextDate ) { - const int firstSpace = s.tqfind(' '); + const int firstSpace = s.find(' '); TQString monthName( s.mid( firstSpace + 1, 3 ) ); int month = -1; // Assume that English monthnames are the default @@ -2497,7 +2497,7 @@ TQDateTime TQDateTime::fromString( const TQString& s, TQt::DateFormat f ) TQDate date( year, month, day ); TQTime time; int hour, minute, second; - int pivot = s.tqfind( TQRegExp(TQString::tqfromLatin1("[0-9][0-9]:[0-9][0-9]:[0-9][0-9]")) ); + int pivot = s.find( TQRegExp(TQString::tqfromLatin1("[0-9][0-9]:[0-9][0-9]:[0-9][0-9]")) ); if ( pivot != -1 ) { hour = s.mid( pivot, 2 ).toInt(); minute = s.mid( pivot+3, 2 ).toInt(); diff --git a/tqtinterface/qt4/src/tools/tqdict.h b/tqtinterface/qt4/src/tools/tqdict.h index 1dc8a48..b9fab7f 100644 --- a/tqtinterface/qt4/src/tools/tqdict.h +++ b/tqtinterface/qt4/src/tools/tqdict.h @@ -66,11 +66,11 @@ public: void insert( const TQString &k, const type *d ) { TQGDict::look_string(k,(Item)d,1); } - void tqreplace( const TQString &k, const type *d ) + void replace( const TQString &k, const type *d ) { TQGDict::look_string(k,(Item)d,2); } bool remove( const TQString &k ) { return TQGDict::remove_string(k); } type *take( const TQString &k ) { return (type *)TQGDict::take_string(k); } - type *tqfind( const TQString &k ) const + type *find( const TQString &k ) const { return (type *)((TQGDict*)this)->TQGDict::look_string(k,0,0); } type *operator[]( const TQString &k ) const { return (type *)((TQGDict*)this)->TQGDict::look_string(k,0,0); } diff --git a/tqtinterface/qt4/src/tools/tqdir.cpp b/tqtinterface/qt4/src/tools/tqdir.cpp index 796162d..99c9094 100644 --- a/tqtinterface/qt4/src/tools/tqdir.cpp +++ b/tqtinterface/qt4/src/tools/tqdir.cpp @@ -304,7 +304,7 @@ void TQDir::setPath( const TQString &path ) \fn TQString TQDir::path() const Returns the path, this may contain symbolic links, but never - tqcontains redundant ".", ".." or multiple separators. + contains redundant ".", ".." or multiple separators. The returned path can be either absolute or relative (see setPath()). @@ -316,7 +316,7 @@ void TQDir::setPath( const TQString &path ) /*! Returns the absolute path (a path that starts with "/" or with a drive specification), which may contain symbolic links, but never - tqcontains redundant ".", ".." or multiple separators. + contains redundant ".", ".." or multiple separators. \sa setPath(), canonicalPath(), exists(), cleanDirPath(), dirName(), absFilePath() @@ -349,7 +349,7 @@ TQString TQDir::absPath() const TQString TQDir::dirName() const { - int pos = dPath.tqfindRev( '/' ); + int pos = dPath.findRev( '/' ); if ( pos == -1 ) return dPath; return dPath.right( dPath.length() - pos - 1 ); @@ -465,7 +465,7 @@ TQString TQDir::convertSeparators( const TQString &pathName ) if ( n[i] == '/' ) n[i] = ':'; } - if(n.tqcontains(':') && n.left(1) != ':') + if(n.contains(':') && n.left(1) != ':') n.prepend(':'); #endif return n; @@ -508,7 +508,7 @@ bool TQDir::cd( const TQString &dirName, bool acceptAbsPath ) } dPath += dirName; - if ( dirName.tqfind('/') >= 0 + if ( dirName.find('/') >= 0 || old == TQString::tqfromLatin1(".") || dirName == TQString::tqfromLatin1("..") ) { dPath = cleanDirPath( dPath ); @@ -1166,8 +1166,8 @@ TQValueList<TQRegExp> qt_makeFilterList( const TQString &filter ) return regExps; TQChar sep( ';' ); - int i = filter.tqfind( sep, 0 ); - if ( i == -1 && filter.tqfind( ' ', 0 ) != -1 ) + int i = filter.find( sep, 0 ); + if ( i == -1 && filter.find( ' ', 0 ) != -1 ) sep = TQChar( ' ' ); TQStringList list = TQStringList::split( sep, filter ); @@ -1263,7 +1263,7 @@ TQString TQDir::cleanDirPath( const TQString &filePath ) upLevel = 0; int len; - while ( pos && (pos = name.tqfindRev('/', pos - 1)) != -1 ) { + while ( pos && (pos = name.findRev('/', pos - 1)) != -1 ) { len = ePos - pos - 1; if ( len == 2 && name.at(pos + 1) == '.' && name.at(pos + 2) == '.' ) { diff --git a/tqtinterface/qt4/src/tools/tqfile_unix.cpp b/tqtinterface/qt4/src/tools/tqfile_unix.cpp index b76a2aa..5e680d4 100644 --- a/tqtinterface/qt4/src/tools/tqfile_unix.cpp +++ b/tqtinterface/qt4/src/tools/tqfile_unix.cpp @@ -553,7 +553,7 @@ bool TQFile::at( Offset pos ) \warning We have experienced problems with some C libraries when a buffered file is opened for both reading and writing. If a read operation takes place - immediately after a write operation, the read buffer tqcontains garbage data. + immediately after a write operation, the read buffer contains garbage data. Worse, the same garbage is written to the file. Calling flush() before readBlock() solved this problem. */ diff --git a/tqtinterface/qt4/src/tools/tqfileinfo.cpp b/tqtinterface/qt4/src/tools/tqfileinfo.cpp index fbc1278..0c937eb 100644 --- a/tqtinterface/qt4/src/tools/tqfileinfo.cpp +++ b/tqtinterface/qt4/src/tools/tqfileinfo.cpp @@ -128,8 +128,8 @@ extern bool qt_file_access( const TQString& fn, int t ); unfortunately not platform independent: on Unix, the rights of the owner of the file are returned and on Windows the rights of the current user are returned. This behavior might change in a future TQt version. If you want to - tqfind the rights of the owner of the file, you should use the flags \c - ReadOwner, \c WriteOwner and \c ExeOwner. If you want to tqfind out the + find the rights of the owner of the file, you should use the flags \c + ReadOwner, \c WriteOwner and \c ExeOwner. If you want to find out the rights of the current user, you should use isReadable(), isWritable() and isExecutable(). */ @@ -435,7 +435,7 @@ TQString TQFileInfo::filePath() const TQString TQFileInfo::baseName( bool complete ) const { TQString tmp = fileName(); - int pos = complete ? tmp.tqfindRev( '.' ) : tmp.tqfind( '.' ); + int pos = complete ? tmp.findRev( '.' ) : tmp.find( '.' ); if ( pos == -1 ) return tmp; else @@ -466,7 +466,7 @@ TQString TQFileInfo::baseName( bool complete ) const TQString TQFileInfo::extension( bool complete ) const { TQString s = fileName(); - int pos = complete ? s.tqfind( '.' ) : s.tqfindRev( '.' ); + int pos = complete ? s.find( '.' ) : s.findRev( '.' ); if ( pos < 0 ) return TQString::tqfromLatin1( "" ); else diff --git a/tqtinterface/qt4/src/tools/tqfileinfo_unix.cpp b/tqtinterface/qt4/src/tools/tqfileinfo_unix.cpp index 3be62bf..4a08916 100644 --- a/tqtinterface/qt4/src/tools/tqfileinfo_unix.cpp +++ b/tqtinterface/qt4/src/tools/tqfileinfo_unix.cpp @@ -366,7 +366,7 @@ TQString TQFileInfo::dirPath( bool absPath ) const s = absFilePath(); else s = fn; - int pos = s.tqfindRev( '/' ); + int pos = s.findRev( '/' ); if ( pos == -1 ) { return TQString::tqfromLatin1( "." ); } else { @@ -391,7 +391,7 @@ TQString TQFileInfo::dirPath( bool absPath ) const TQString TQFileInfo::fileName() const { - int p = fn.tqfindRev( '/' ); + int p = fn.findRev( '/' ); if ( p == -1 ) { return fn; } else { diff --git a/tqtinterface/qt4/src/tools/tqgarray.cpp b/tqtinterface/qt4/src/tools/tqgarray.cpp index f0e89f9..ca26750 100644 --- a/tqtinterface/qt4/src/tools/tqgarray.cpp +++ b/tqtinterface/qt4/src/tools/tqgarray.cpp @@ -84,7 +84,7 @@ \internal - It only tqcontains a reference count and member functions to increment and + It only contains a reference count and member functions to increment and decrement it. Shared classes normally have internal classes that inherit TQShared and @@ -105,7 +105,7 @@ TQGArray is a strictly internal class that acts as base class for the TQMemArray template array. - It tqcontains an array of bytes and has no notion of an array element. + It contains an array of bytes and has no notion of an array element. */ @@ -364,7 +364,7 @@ TQGArray &TQGArray::assign( const TQGArray &a ) /*! Shallow copy. Dereference the current array and references the - array data \a d, which tqcontains \a len bytes. + array data \a d, which contains \a len bytes. Returns a reference to this array. Do not delete \a d later, because TQGArray takes care of that. @@ -596,12 +596,12 @@ void TQGArray::resetRawData( const char *d, uint len ) This function only compares whole cells, not bytes. */ -int TQGArray::tqfind( const char *d, uint index, uint sz ) const +int TQGArray::find( const char *d, uint index, uint sz ) const { index *= sz; if ( index >= shd->len ) { #if defined(TQT_CHECK_RANGE) - qWarning( "TQGArray::tqfind: Index %d out of range", index/sz ); + qWarning( "TQGArray::find: Index %d out of range", index/sz ); #endif return -1; } @@ -657,7 +657,7 @@ int TQGArray::tqfind( const char *d, uint index, uint sz ) const This function only compares whole cells, not bytes. */ -int TQGArray::tqcontains( const char *d, uint sz ) const +int TQGArray::contains( const char *d, uint sz ) const { register uint i = shd->len; int count = 0; diff --git a/tqtinterface/qt4/src/tools/tqgarray.h b/tqtinterface/qt4/src/tools/tqgarray.h index b581621..bfe1f86 100644 --- a/tqtinterface/qt4/src/tools/tqgarray.h +++ b/tqtinterface/qt4/src/tools/tqgarray.h @@ -99,8 +99,8 @@ protected: TQGArray &setRawData( const char *d, uint len ); void resetRawData( const char *d, uint len ); - int tqfind( const char *d, uint index, uint sz ) const; - int tqcontains( const char *d, uint sz ) const; + int find( const char *d, uint index, uint sz ) const; + int contains( const char *d, uint sz ) const; void sort( uint sz ); int bsearch( const char *d, uint sz ) const; diff --git a/tqtinterface/qt4/src/tools/tqgcache.cpp b/tqtinterface/qt4/src/tools/tqgcache.cpp index 1d2d3bb..4e16ad7 100644 --- a/tqtinterface/qt4/src/tools/tqgcache.cpp +++ b/tqtinterface/qt4/src/tools/tqgcache.cpp @@ -106,7 +106,7 @@ public: int inserts; // variables for statistics int insertCosts; int insertMisses; - int tqfinds; + int finds; int hits; int hitCosts; int dumps; @@ -199,11 +199,11 @@ public: void clear() { TQGDict::clear(); } - TQCacheItem *tqfind_string(const TQString &key) const + TQCacheItem *find_string(const TQString &key) const { return (TQCacheItem*)((TQCDict*)this)->look_string(key, 0, 0); } - TQCacheItem *tqfind_ascii(const char *key) const + TQCacheItem *find_ascii(const char *key) const { return (TQCacheItem*)((TQCDict*)this)->look_ascii(key, 0, 0); } - TQCacheItem *tqfind_int(long key) const + TQCacheItem *find_int(long key) const { return (TQCacheItem*)((TQCDict*)this)->look_int(key, 0, 0); } TQCacheItem *take_string(const TQString &key) @@ -267,7 +267,7 @@ TQGCache::TQGCache( int maxCost, uint size, KeyType kt, bool caseSensitive, lruList->inserts = 0; lruList->insertCosts = 0; lruList->insertMisses = 0; - lruList->tqfinds = 0; + lruList->finds = 0; lruList->hits = 0; lruList->hitCosts = 0; lruList->dumps = 0; @@ -536,11 +536,11 @@ void TQGCache::clear() Finds an item for \a key in the cache and adds a reference if \a ref is TRUE. */ -TQPtrCollection::Item TQGCache::tqfind_string( const TQString &key, bool ref ) const +TQPtrCollection::Item TQGCache::find_string( const TQString &key, bool ref ) const { - TQCacheItem *ci = dict->tqfind_string( key ); + TQCacheItem *ci = dict->find_string( key ); #if defined(TQT_DEBUG) - lruList->tqfinds++; + lruList->finds++; #endif if ( ci ) { #if defined(TQT_DEBUG) @@ -559,12 +559,12 @@ TQPtrCollection::Item TQGCache::tqfind_string( const TQString &key, bool ref ) c Finds an item for \a key in the cache and adds a reference if \a ref is TRUE. */ -TQPtrCollection::Item TQGCache::tqfind_other( const char *key, bool ref ) const +TQPtrCollection::Item TQGCache::find_other( const char *key, bool ref ) const { - TQCacheItem *ci = keytype == AsciiKey ? dict->tqfind_ascii(key) - : dict->tqfind_int((long)key); + TQCacheItem *ci = keytype == AsciiKey ? dict->find_ascii(key) + : dict->find_int((long)key); #if defined(TQT_DEBUG) - lruList->tqfinds++; + lruList->finds++; #endif if ( ci ) { #if defined(TQT_DEBUG) @@ -643,12 +643,12 @@ void TQGCache::statistics() const line.fill( '*', 80 ); qDebug( line.ascii() ); qDebug( "CACHE STATISTICS:" ); - qDebug( "cache tqcontains %d item%s, with a total cost of %d", + qDebug( "cache contains %d item%s, with a total cost of %d", count(), count() != 1 ? "s" : "", tCost ); qDebug( "maximum cost is %d, cache is %d%% full.", mCost, (200*tCost + mCost) / (mCost*2) ); - qDebug( "tqfind() has been called %d time%s", - lruList->tqfinds, lruList->tqfinds != 1 ? "s" : "" ); + qDebug( "find() has been called %d time%s", + lruList->finds, lruList->finds != 1 ? "s" : "" ); qDebug( "%d of these were hits, items found had a total cost of %d.", lruList->hits,lruList->hitCosts ); qDebug( "%d item%s %s been inserted with a total cost of %d.", diff --git a/tqtinterface/qt4/src/tools/tqgcache.h b/tqtinterface/qt4/src/tools/tqgcache.h index 7d54656..27887c3 100644 --- a/tqtinterface/qt4/src/tools/tqgcache.h +++ b/tqtinterface/qt4/src/tools/tqgcache.h @@ -82,8 +82,8 @@ protected: TQPtrCollection::Item take_string( const TQString &key ); TQPtrCollection::Item take_other( const char *key ); - TQPtrCollection::Item tqfind_string( const TQString &key, bool ref=TRUE ) const; - TQPtrCollection::Item tqfind_other( const char *key, bool ref=TRUE ) const; + TQPtrCollection::Item find_string( const TQString &key, bool ref=TRUE ) const; + TQPtrCollection::Item find_other( const char *key, bool ref=TRUE ) const; void statistics() const; diff --git a/tqtinterface/qt4/src/tools/tqgdict.cpp b/tqtinterface/qt4/src/tools/tqgdict.cpp index c4c21d9..dc4d450 100644 --- a/tqtinterface/qt4/src/tools/tqgdict.cpp +++ b/tqtinterface/qt4/src/tools/tqgdict.cpp @@ -64,9 +64,9 @@ Normally, you do not have to reimplement any of these functions. */ -static const int op_tqfind = 0; +static const int op_find = 0; static const int op_insert = 1; -static const int op_tqreplace = 2; +static const int op_replace = 2; class TQGDItList : public TQPtrList<TQGDictIterator> @@ -324,7 +324,7 @@ TQGDict &TQGDict::operator=( const TQGDict &dict ) */ /*! - The do-it-all function; \a op is one of op_tqfind, op_insert, op_tqreplace. + The do-it-all function; \a op is one of op_find, op_insert, op_replace. The key is \a key and the item is \a d. */ @@ -333,7 +333,7 @@ TQPtrCollection::Item TQGDict::look_string( const TQString &key, TQPtrCollection { TQStringBucket *n = 0; int index = hashKeyString(key) % vlen; - if ( op == op_tqfind ) { // tqfind + if ( op == op_find ) { // find if ( cases ) { n = (TQStringBucket*)vec[index]; while( n != 0 ) { @@ -352,11 +352,11 @@ TQPtrCollection::Item TQGDict::look_string( const TQString &key, TQPtrCollection } return 0; // not found } - if ( op == op_tqreplace ) { // tqreplace + if ( op == op_replace ) { // replace if ( vec[index] != 0 ) // maybe something there remove_string( key ); } - // op_insert or op_tqreplace + // op_insert or op_replace n = new TQStringBucket(key,newItem(d),vec[index]); TQ_CHECK_PTR( n ); #if defined(TQT_CHECK_NULL) @@ -372,7 +372,7 @@ TQPtrCollection::Item TQGDict::look_ascii( const char *key, TQPtrCollection::Ite { TQAsciiBucket *n; int index = hashKeyAscii(key) % vlen; - if ( op == op_tqfind ) { // tqfind + if ( op == op_find ) { // find if ( cases ) { for ( n=(TQAsciiBucket*)vec[index]; n; n=(TQAsciiBucket*)n->getNext() ) { @@ -388,11 +388,11 @@ TQPtrCollection::Item TQGDict::look_ascii( const char *key, TQPtrCollection::Ite } return 0; // not found } - if ( op == op_tqreplace ) { // tqreplace + if ( op == op_replace ) { // replace if ( vec[index] != 0 ) // maybe something there remove_ascii( key ); } - // op_insert or op_tqreplace + // op_insert or op_replace n = new TQAsciiBucket(copyk ? qstrdup(key) : key,newItem(d),vec[index]); TQ_CHECK_PTR( n ); #if defined(TQT_CHECK_NULL) @@ -408,7 +408,7 @@ TQPtrCollection::Item TQGDict::look_int( long key, TQPtrCollection::Item d, int { TQIntBucket *n; int index = (int)((ulong)key % vlen); // simple hash - if ( op == op_tqfind ) { // tqfind + if ( op == op_find ) { // find for ( n=(TQIntBucket*)vec[index]; n; n=(TQIntBucket*)n->getNext() ) { if ( n->getKey() == key ) @@ -416,11 +416,11 @@ TQPtrCollection::Item TQGDict::look_int( long key, TQPtrCollection::Item d, int } return 0; // not found } - if ( op == op_tqreplace ) { // tqreplace + if ( op == op_replace ) { // replace if ( vec[index] != 0 ) // maybe something there remove_int( key ); } - // op_insert or op_tqreplace + // op_insert or op_replace n = new TQIntBucket(key,newItem(d),vec[index]); TQ_CHECK_PTR( n ); #if defined(TQT_CHECK_NULL) @@ -436,7 +436,7 @@ TQPtrCollection::Item TQGDict::look_ptr( void *key, TQPtrCollection::Item d, int { TQPtrBucket *n; int index = (int)((ulong)key % vlen); // simple hash - if ( op == op_tqfind ) { // tqfind + if ( op == op_find ) { // find for ( n=(TQPtrBucket*)vec[index]; n; n=(TQPtrBucket*)n->getNext() ) { if ( n->getKey() == key ) @@ -444,11 +444,11 @@ TQPtrCollection::Item TQGDict::look_ptr( void *key, TQPtrCollection::Item d, int } return 0; // not found } - if ( op == op_tqreplace ) { // tqreplace + if ( op == op_replace ) { // replace if ( vec[index] != 0 ) // maybe something there remove_ptr( key ); } - // op_insert or op_tqreplace + // op_insert or op_replace n = new TQPtrBucket(key,newItem(d),vec[index]); TQ_CHECK_PTR( n ); #if defined(TQT_CHECK_NULL) diff --git a/tqtinterface/qt4/src/tools/tqglist.cpp b/tqtinterface/qt4/src/tools/tqglist.cpp index 944c27c..07851ba 100644 --- a/tqtinterface/qt4/src/tools/tqglist.cpp +++ b/tqtinterface/qt4/src/tools/tqglist.cpp @@ -371,7 +371,7 @@ void TQGList::inSort( TQPtrCollection::Item d ) { int index = 0; register TQLNode *n = firstNode; - while ( n && compareItems(n->data,d) < 0 ){ // tqfind position in list + while ( n && compareItems(n->data,d) < 0 ){ // find position in list n = n->next; index++; } @@ -530,14 +530,14 @@ bool TQGList::removeNode( TQLNode *n ) } /*! - Removes the item \a d from the list. Uses compareItems() to tqfind the item. + Removes the item \a d from the list. Uses compareItems() to find the item. If \a d is 0, removes the current item. */ bool TQGList::remove( TQPtrCollection::Item d ) { - if ( d && tqfind(d) == -1 ) + if ( d && find(d) == -1 ) return FALSE; TQLNode *n = unlink(); if ( !n ) @@ -553,7 +553,7 @@ bool TQGList::remove( TQPtrCollection::Item d ) bool TQGList::removeRef( TQPtrCollection::Item d ) { - if ( tqfindRef(d) == -1 ) + if ( findRef(d) == -1 ) return FALSE; TQLNode *n = unlink(); if ( !n ) @@ -595,7 +595,7 @@ bool TQGList::removeAt( uint index ) /*! Replaces the item at index \a index with \a d. */ -bool TQGList::tqreplaceAt( uint index, TQPtrCollection::Item d ) +bool TQGList::replaceAt( uint index, TQPtrCollection::Item d ) { TQLNode *n = locate( index ); if ( !n ) @@ -714,7 +714,7 @@ void TQGList::clear() begins at the first node; otherwise it begins at the current node. */ -int TQGList::tqfindRef( TQPtrCollection::Item d, bool fromStart ) +int TQGList::findRef( TQPtrCollection::Item d, bool fromStart ) { register TQLNode *n; int index; @@ -725,7 +725,7 @@ int TQGList::tqfindRef( TQPtrCollection::Item d, bool fromStart ) n = curNode; index = curIndex; } - while ( n && n->data != d ) { // tqfind exact match + while ( n && n->data != d ) { // find exact match n = n->next; index++; } @@ -740,7 +740,7 @@ int TQGList::tqfindRef( TQPtrCollection::Item d, bool fromStart ) current node. */ -int TQGList::tqfind( TQPtrCollection::Item d, bool fromStart ) +int TQGList::find( TQPtrCollection::Item d, bool fromStart ) { register TQLNode *n; int index; @@ -751,7 +751,7 @@ int TQGList::tqfind( TQPtrCollection::Item d, bool fromStart ) n = curNode; index = curIndex; } - while ( n && compareItems(n->data,d) ){ // tqfind equal match + while ( n && compareItems(n->data,d) ){ // find equal match n = n->next; index++; } @@ -765,7 +765,7 @@ int TQGList::tqfind( TQPtrCollection::Item d, bool fromStart ) Counts the number item \a d occurs in the list. */ -uint TQGList::tqcontainsRef( TQPtrCollection::Item d ) const +uint TQGList::containsRef( TQPtrCollection::Item d ) const { register TQLNode *n = firstNode; uint count = 0; @@ -782,7 +782,7 @@ uint TQGList::tqcontainsRef( TQPtrCollection::Item d ) const compareItems(). */ -uint TQGList::tqcontains( TQPtrCollection::Item d ) const +uint TQGList::contains( TQPtrCollection::Item d ) const { register TQLNode *n = firstNode; uint count = 0; diff --git a/tqtinterface/qt4/src/tools/tqglist.h b/tqtinterface/qt4/src/tools/tqglist.h index 4c91453..ebbd616 100644 --- a/tqtinterface/qt4/src/tools/tqglist.h +++ b/tqtinterface/qt4/src/tools/tqglist.h @@ -91,7 +91,7 @@ protected: bool removeFirst(); // remove first item bool removeLast(); // remove last item bool removeAt( uint ); // remove item at i'th position - bool tqreplaceAt( uint, TQPtrCollection::Item ); // tqreplace item at position i with item + bool replaceAt( uint, TQPtrCollection::Item ); // replace item at position i with item TQPtrCollection::Item takeNode( TQLNode * ); // take out node TQPtrCollection::Item take(); // take out current item TQPtrCollection::Item takeAt( uint index ); // take out item at i'th pos @@ -101,11 +101,11 @@ protected: void sort(); // sort all items; void clear(); // remove all items - int tqfindRef( TQPtrCollection::Item, bool = TRUE ); // tqfind exact item in list - int tqfind( TQPtrCollection::Item, bool = TRUE ); // tqfind equal item in list + int findRef( TQPtrCollection::Item, bool = TRUE ); // find exact item in list + int find( TQPtrCollection::Item, bool = TRUE ); // find equal item in list - uint tqcontainsRef( TQPtrCollection::Item ) const; // get number of exact matches - uint tqcontains( TQPtrCollection::Item ) const; // get number of equal matches + uint containsRef( TQPtrCollection::Item ) const; // get number of exact matches + uint contains( TQPtrCollection::Item ) const; // get number of equal matches TQPtrCollection::Item at( uint index ); // access item at i'th pos int at() const; // get current index diff --git a/tqtinterface/qt4/src/tools/tqglobal.cpp b/tqtinterface/qt4/src/tools/tqglobal.cpp index 0d548ed..dd5528b 100644 --- a/tqtinterface/qt4/src/tools/tqglobal.cpp +++ b/tqtinterface/qt4/src/tools/tqglobal.cpp @@ -784,7 +784,7 @@ static bool firstObsoleteWarning(const char *obj, const char *oldfunc ) TQCString s( obj ); s += "::"; s += oldfunc; - if ( obsoleteDict->tqfind(s.data()) == 0 ) { + if ( obsoleteDict->find(s.data()) == 0 ) { obsoleteDict->insert( s.data(), (int*)1 ); // anything different from 0 return TRUE; } @@ -842,7 +842,7 @@ void qObsolete( const char *message ) The message handler is a function that prints out debug messages, warnings and fatal error messages. The TQt library (debug version) - tqcontains hundreds of warning messages that are printed when + contains hundreds of warning messages that are printed when internal errors (usually invalid function arguments) occur. If you implement your own message handler, you get total control of these messages. @@ -898,7 +898,7 @@ TQtMsgHandler tqInstallMsgHandler( TQtMsgHandler h ) /* - Dijkstra's bisection algorithm to tqfind the square root as an integer. + Dijkstra's bisection algorithm to find the square root as an integer. Deliberately not exported as part of the TQt API, but used in both qsimplerichtext.cpp and qgfxraster_qws.cpp */ diff --git a/tqtinterface/qt4/src/tools/tqglobal.h b/tqtinterface/qt4/src/tools/tqglobal.h index 693da3f..6dbb122 100644 --- a/tqtinterface/qt4/src/tools/tqglobal.h +++ b/tqtinterface/qt4/src/tools/tqglobal.h @@ -603,7 +603,7 @@ /* Some classes do not permit copies to be made of an object. - These classes tqcontains a private copy constructor and operator= + These classes contains a private copy constructor and operator= to disable copying (the compiler gives an error message). Undefine TQ_DISABLE_COPY to turn off this checking. */ diff --git a/tqtinterface/qt4/src/tools/tqgpluginmanager.cpp b/tqtinterface/qt4/src/tools/tqgpluginmanager.cpp index ef0ab02..969d424 100644 --- a/tqtinterface/qt4/src/tools/tqgpluginmanager.cpp +++ b/tqtinterface/qt4/src/tools/tqgpluginmanager.cpp @@ -330,7 +330,7 @@ void TQGPluginManager::addLibraryPath( const TQString& path ) TQStringList plugins = TQDir(path).entryList( filter ); for ( TQStringList::Iterator p = plugins.begin(); p != plugins.end(); ++p ) { TQString lib = TQDir::cleanDirPath( path + "/" + *p ); - if ( libList.tqcontains( lib ) ) + if ( libList.contains( lib ) ) continue; libList.append( lib ); } @@ -376,14 +376,14 @@ const TQLibrary* TQGPluginManager::library( const TQString& feature ) const group.sort(); // sort according to the base name TQStringList::ConstIterator git = group.begin(); while ( git != group.end() ) { - TQString lib = (*git).mid( (*git).tqfind( TQChar(0xfffd) ) + 1 ); - TQString basename = (*git).left( (*git).tqfind( TQChar(0xfffd) ) ); + TQString lib = (*git).mid( (*git).find( TQChar(0xfffd) ) + 1 ); + TQString basename = (*git).left( (*git).find( TQChar(0xfffd) ) ); ++git; TQStringList sameBasename; while( git != group.end() && - basename == (*git).left( (*git).tqfind( TQChar(0xfffd) ) ) ) { - sameBasename << (*git).mid( (*git).tqfind( TQChar(0xfffd) ) + 1 ); + basename == (*git).left( (*git).find( TQChar(0xfffd) ) ) ) { + sameBasename << (*git).mid( (*git).find( TQChar(0xfffd) ) + 1 ); ++git; } @@ -402,7 +402,7 @@ const TQLibrary* TQGPluginManager::library( const TQString& feature ) const && ( !bestMatch || candidate->qtVersion() > bestMatch->qtVersion() ) ) bestMatch = candidate; if ( bestMatch ) { - same.tqfind( bestMatch ); + same.find( bestMatch ); that->addLibrary( same.take() ); } } @@ -444,7 +444,7 @@ TQStringList TQGPluginManager::featureList() const } } for ( it = phase2Libs.begin(); it != phase2Libs.end(); ++it ) - if ( !phase2Deny.tqcontains( TQFileInfo( *it ).baseName() ) ) + if ( !phase2Deny.contains( TQFileInfo( *it ).baseName() ) ) that->addLibrary( new TQComLibrary( *it ) ); for ( TQDictIterator<TQLibrary> pit( plugDict ); pit.current(); ++pit ) @@ -485,7 +485,7 @@ bool TQGPluginManager::addLibrary( TQLibrary* lib ) TQLibrary *old = plugDict[*f]; if ( !old ) { useful = TRUE; - plugDict.tqreplace( *f, plugin ); + plugDict.replace( *f, plugin ); } else { // we have old *and* plugin, which one to pick? TQComLibrary* first = (TQComLibrary*)old; @@ -500,7 +500,7 @@ bool TQGPluginManager::addLibrary( TQLibrary* lib ) } if ( !takeFirst ) { useful = TRUE; - plugDict.tqreplace( *f, plugin ); + plugDict.replace( *f, plugin ); qWarning("%s: Discarding feature %s in %s!", (const char*) TQFile::encodeName( plugin->library()), (*f).latin1(), @@ -521,8 +521,8 @@ bool TQGPluginManager::addLibrary( TQLibrary* lib ) } if ( useful ) { - libDict.tqreplace( plugin->library(), plugin ); - if ( !libList.tqcontains( plugin->library() ) ) + libDict.replace( plugin->library(), plugin ); + if ( !libList.contains( plugin->library() ) ) libList.append( plugin->library() ); return TRUE; } diff --git a/tqtinterface/qt4/src/tools/tqgvector.cpp b/tqtinterface/qt4/src/tools/tqgvector.cpp index e30c172..4151d54 100644 --- a/tqtinterface/qt4/src/tools/tqgvector.cpp +++ b/tqtinterface/qt4/src/tools/tqgvector.cpp @@ -453,11 +453,11 @@ int TQGVector::bsearch( Item d ) const // binary search; when sorted return mid; } -int TQGVector::tqfindRef( Item d, uint index) const // tqfind exact item in vector +int TQGVector::findRef( Item d, uint index) const // find exact item in vector { #if defined(TQT_CHECK_RANGE) if ( index > len ) { // range error - qWarning( "TQGVector::tqfindRef: Index %d out of range", index ); + qWarning( "TQGVector::findRef: Index %d out of range", index ); return -1; } #endif @@ -468,11 +468,11 @@ int TQGVector::tqfindRef( Item d, uint index) const // tqfind exact item in vect return -1; } -int TQGVector::tqfind( Item d, uint index ) const // tqfind equal item in vector +int TQGVector::find( Item d, uint index ) const // find equal item in vector { #if defined(TQT_CHECK_RANGE) if ( index >= len ) { // range error - qWarning( "TQGVector::tqfind: Index %d out of range", index ); + qWarning( "TQGVector::find: Index %d out of range", index ); return -1; } #endif @@ -485,7 +485,7 @@ int TQGVector::tqfind( Item d, uint index ) const // tqfind equal item in vector return -1; } -uint TQGVector::tqcontainsRef( Item d ) const // get number of exact matches +uint TQGVector::containsRef( Item d ) const // get number of exact matches { uint count = 0; for ( uint i=0; i<len; i++ ) { @@ -495,7 +495,7 @@ uint TQGVector::tqcontainsRef( Item d ) const // get number of exact matches return count; } -uint TQGVector::tqcontains( Item d ) const // get number of equal matches +uint TQGVector::contains( Item d ) const // get number of equal matches { uint count = 0; for ( uint i=0; i<len; i++ ) { diff --git a/tqtinterface/qt4/src/tools/tqgvector.h b/tqtinterface/qt4/src/tools/tqgvector.h index 1cc5937..ebb5e03 100644 --- a/tqtinterface/qt4/src/tools/tqgvector.h +++ b/tqtinterface/qt4/src/tools/tqgvector.h @@ -81,10 +81,10 @@ protected: void sort(); // sort vector int bsearch( Item ) const; // binary search (when sorted) - int tqfindRef( Item, uint index ) const; // tqfind exact item in vector - int tqfind( Item, uint index ) const; // tqfind equal item in vector - uint tqcontainsRef( Item ) const; // get number of exact matches - uint tqcontains( Item ) const; // get number of equal matches + int findRef( Item, uint index ) const; // find exact item in vector + int find( Item, uint index ) const; // find equal item in vector + uint containsRef( Item ) const; // get number of exact matches + uint contains( Item ) const; // get number of equal matches Item at( uint index ) const // return indexed item { diff --git a/tqtinterface/qt4/src/tools/tqintcache.h b/tqtinterface/qt4/src/tools/tqintcache.h index ed48fc3..239a40c 100644 --- a/tqtinterface/qt4/src/tools/tqintcache.h +++ b/tqtinterface/qt4/src/tools/tqintcache.h @@ -74,10 +74,10 @@ public: type *take( long k ) { return (type *)TQGCache::take_other((const char*)k);} void clear() { TQGCache::clear(); } - type *tqfind( long k, bool ref=TRUE ) const - { return (type *)TQGCache::tqfind_other( (const char*)k,ref);} + type *find( long k, bool ref=TRUE ) const + { return (type *)TQGCache::find_other( (const char*)k,ref);} type *operator[]( long k ) const - { return (type *)TQGCache::tqfind_other( (const char*)k); } + { return (type *)TQGCache::find_other( (const char*)k); } void statistics() const { TQGCache::statistics(); } private: void deleteItem( Item d ); diff --git a/tqtinterface/qt4/src/tools/tqintdict.h b/tqtinterface/qt4/src/tools/tqintdict.h index dc6cc2e..35a821f 100644 --- a/tqtinterface/qt4/src/tools/tqintdict.h +++ b/tqtinterface/qt4/src/tools/tqintdict.h @@ -64,11 +64,11 @@ public: bool isEmpty() const { return TQGDict::count() == 0; } void insert( long k, const type *d ) { TQGDict::look_int(k,(Item)d,1); } - void tqreplace( long k, const type *d ) + void replace( long k, const type *d ) { TQGDict::look_int(k,(Item)d,2); } bool remove( long k ) { return TQGDict::remove_int(k); } type *take( long k ) { return (type*)TQGDict::take_int(k); } - type *tqfind( long k ) const + type *find( long k ) const { return (type *)((TQGDict*)this)->TQGDict::look_int(k,0,0); } type *operator[]( long k ) const { return (type *)((TQGDict*)this)->TQGDict::look_int(k,0,0); } diff --git a/tqtinterface/qt4/src/tools/tqiodevice.cpp b/tqtinterface/qt4/src/tools/tqiodevice.cpp index 299d949..c2e48ce 100644 --- a/tqtinterface/qt4/src/tools/tqiodevice.cpp +++ b/tqtinterface/qt4/src/tools/tqiodevice.cpp @@ -381,7 +381,7 @@ TQIODevice::~TQIODevice() The I/O tqdevice status returns an error code. If open() returns FALSE or readBlock() or writeBlock() return -1, this function can - be called to tqfind out the reason why the operation failed. + be called to find out the reason why the operation failed. \keyword IO_Ok \keyword IO_ReadError diff --git a/tqtinterface/qt4/src/tools/tqlibrary.cpp b/tqtinterface/qt4/src/tools/tqlibrary.cpp index cf34295..5236cd5 100644 --- a/tqtinterface/qt4/src/tools/tqlibrary.cpp +++ b/tqtinterface/qt4/src/tools/tqlibrary.cpp @@ -140,7 +140,7 @@ TQLibraryPrivate::TQLibraryPrivate( TQLibrary *lib ) TQLibrary::TQLibrary( const TQString& filename ) : libfile( filename ), aunload( TRUE ) { - libfile.tqreplace( '\\', '/' ); + libfile.replace( '\\', '/' ); d = new TQLibraryPrivate( this ); } @@ -399,7 +399,7 @@ TQString TQLibrary::library() const TQString filename = libfile; #if defined(TQ_WS_WIN) - if ( filename.tqfindRev( '.' ) <= filename.tqfindRev( '/' ) ) + if ( filename.findRev( '.' ) <= filename.findRev( '/' ) ) filename += ".dll"; #else TQStringList filters = ""; @@ -421,7 +421,7 @@ TQString TQLibrary::library() const break; } else if(!filter.isEmpty()) { TQString tmpfilename = filename; - const int x = tmpfilename.tqfindRev( "/" ); + const int x = tmpfilename.findRev( "/" ); if ( x != -1 ) { TQString path = tmpfilename.left( x + 1 ); TQString file = tmpfilename.right( tmpfilename.length() - x - 1 ); @@ -429,7 +429,7 @@ TQString TQLibrary::library() const } else { tmpfilename = TQString( "lib%1" ).arg( filename ); } - if ( !filename.tqcontains(".so") ) + if ( !filename.contains(".so") ) tmpfilename += filter; if(TQFile::exists(tmpfilename) || it == filters.end()) { filename = tmpfilename; diff --git a/tqtinterface/qt4/src/tools/tqlibrary_unix.cpp b/tqtinterface/qt4/src/tools/tqlibrary_unix.cpp index 62c909c..271a897 100644 --- a/tqtinterface/qt4/src/tools/tqlibrary_unix.cpp +++ b/tqtinterface/qt4/src/tools/tqlibrary_unix.cpp @@ -95,7 +95,7 @@ void* TQLibraryPrivate::resolveSymbol( const char* symbol ) return 0; void* address = 0; - if ( shl_tqfindsym( (shl_t*)&pHnd, symbol, TYPE_UNDEFINED, &address ) < 0 ) { + if ( shl_findsym( (shl_t*)&pHnd, symbol, TYPE_UNDEFINED, &address ) < 0 ) { #if defined(TQT_DEBUG_COMPONENT) TQString filename = library->library(); qWarning( "%s: couldn't resolve symbol \"%s\"", filename.latin1(), symbol ); diff --git a/tqtinterface/qt4/src/tools/tqlocale.cpp b/tqtinterface/qt4/src/tools/tqlocale.cpp index 69c8c39..e91cab8 100644 --- a/tqtinterface/qt4/src/tools/tqlocale.cpp +++ b/tqtinterface/qt4/src/tools/tqlocale.cpp @@ -1903,7 +1903,7 @@ const char* TQLocalePrivate::systemLocaleName() return lang; } -static const TQLocalePrivate *tqfindLocale(TQLocale::Language language, +static const TQLocalePrivate *findLocale(TQLocale::Language language, TQLocale::Country country) { unsigned language_id = (unsigned)language; @@ -1965,7 +1965,7 @@ static const TQLocalePrivate *tqfindLocale(TQLocale::Language language, \i TQString::toDouble() interprets the string according to the default locale. If this fails, it falls back on the "C" locale. \i TQString::arg() uses the default locale to format a number when - its position specifier in the format string tqcontains an 'L', + its position specifier in the format string contains an 'L', e.g. "%L1". \endlist @@ -2504,7 +2504,7 @@ TQLocale::TQLocale(const TQString &name) cntry = codeToCountry(name.mid(3, 2)); } while (FALSE); - d = tqfindLocale(lang, cntry); + d = findLocale(lang, cntry); } /*! @@ -2542,7 +2542,7 @@ TQLocale::TQLocale() TQLocale::TQLocale(Language language, Country country) { - d = tqfindLocale(language, country); + d = findLocale(language, country); // If not found, should default to system if (d->languageId() == TQLocale::C && language != TQLocale::C) { diff --git a/tqtinterface/qt4/src/tools/tqmap.h b/tqtinterface/qt4/src/tools/tqmap.h index fe36e97..006f490 100644 --- a/tqtinterface/qt4/src/tools/tqmap.h +++ b/tqtinterface/qt4/src/tools/tqmap.h @@ -392,7 +392,6 @@ public: ConstIterator end() const { return ConstIterator( header ); } ConstIterator find(const Key& k) const; - ConstIterator tqfind(const Key& k) const; void remove( Iterator it ) { NodePtr del = (NodePtr) removeAndRebalance( it.node, header->tqparent, header->left, header->right ); @@ -508,12 +507,6 @@ TQ_INLINE_TEMPLATES void TQMapPrivate<Key,T>::clear( TQ_TYPENAME TQMapPrivate<Ke template <class Key, class T> TQ_INLINE_TEMPLATES TQ_TYPENAME TQMapPrivate<Key,T>::ConstIterator TQMapPrivate<Key,T>::find(const Key& k) const { - return tqfind(k); -} - -template <class Key, class T> -TQ_INLINE_TEMPLATES TQ_TYPENAME TQMapPrivate<Key,T>::ConstIterator TQMapPrivate<Key,T>::tqfind(const Key& k) const -{ TQMapNodeBase* y = header; // Last node TQMapNodeBase* x = header->tqparent; // Root node. @@ -560,7 +553,7 @@ TQ_INLINE_TEMPLATES TQ_TYPENAME TQMapPrivate<Key,T>::Iterator TQMapPrivate<Key,T // Really bigger ? if ( (j.node->key) < k ) return insert(x, y, k ); - // We are going to tqreplace a node + // We are going to replace a node return j; } @@ -709,7 +702,7 @@ public: const_iterator constBegin() const { return begin(); } const_iterator constEnd() const { return end(); } - iterator tqreplace( const Key& k, const T& v ) + iterator replace( const Key& k, const T& v ) { remove( k ); return insert( k, v ); @@ -735,21 +728,18 @@ public: T& operator[] ( const Key& k ); void clear(); - iterator tqfind ( const Key& k ) + iterator find ( const Key& k ) { detach(); - return iterator( sh->tqfind( k ).node ); + return iterator( sh->find( k ).node ); } - const_iterator tqfind ( const Key& k ) const { return sh->tqfind( k ); } - - iterator find ( const Key& k ) { return tqfind(k); } - const_iterator find ( const Key& k ) const { return tqfind(k); } + const_iterator find ( const Key& k ) const { return sh->find( k ); } const T& operator[] ( const Key& k ) const - { TQT_CHECK_INVALID_MAP_ELEMENT; return sh->tqfind( k ).data(); } - bool tqcontains ( const Key& k ) const - { return tqfind( k ) != end(); } - //{ return sh->tqfind( k ) != ((const Priv*)sh)->end(); } + { TQT_CHECK_INVALID_MAP_ELEMENT; return sh->find( k ).data(); } + bool contains ( const Key& k ) const + { return find( k ) != end(); } + //{ return sh->find( k ) != ((const Priv*)sh)->end(); } size_type count() const { return sh->node_count; } @@ -847,7 +837,7 @@ template<class Key, class T> TQ_INLINE_TEMPLATES void TQMap<Key,T>::erase( const Key& k ) { detach(); - iterator it( sh->tqfind( k ).node ); + iterator it( sh->find( k ).node ); if ( it != end() ) sh->remove( it ); } @@ -855,7 +845,7 @@ TQ_INLINE_TEMPLATES void TQMap<Key,T>::erase( const Key& k ) template<class Key, class T> TQ_INLINE_TEMPLATES TQ_TYPENAME TQMap<Key,T>::size_type TQMap<Key,T>::count( const Key& k ) const { - const_iterator it( sh->tqfind( k ).node ); + const_iterator it( sh->find( k ).node ); if ( it != end() ) { size_type c = 0; while ( it != end() ) { @@ -871,7 +861,7 @@ template<class Key, class T> TQ_INLINE_TEMPLATES T& TQMap<Key,T>::operator[] ( const Key& k ) { detach(); - TQMapNode<Key,T>* p = sh->tqfind( k ).node; + TQMapNode<Key,T>* p = sh->find( k ).node; if ( p != sh->end().node ) return p->data; return insert( k, T() ).data(); @@ -903,7 +893,7 @@ template<class Key, class T> TQ_INLINE_TEMPLATES void TQMap<Key,T>::remove( const Key& k ) { detach(); - iterator it( sh->tqfind( k ).node ); + iterator it( sh->find( k ).node ); if ( it != end() ) sh->remove( it ); } diff --git a/tqtinterface/qt4/src/tools/tqmemarray.h b/tqtinterface/qt4/src/tools/tqmemarray.h index 99e00b0..df76c98 100644 --- a/tqtinterface/qt4/src/tools/tqmemarray.h +++ b/tqtinterface/qt4/src/tools/tqmemarray.h @@ -91,10 +91,10 @@ public: n*sizeof(type)); } void resetRawData( const type *a, uint n ) { TQGArray::resetRawData((char*)a,n*sizeof(type)); } - int tqfind( const type &d, uint i=0 ) const - { return TQGArray::tqfind((char*)&d,i,sizeof(type)); } - int tqcontains( const type &d ) const - { return TQGArray::tqcontains((char*)&d,sizeof(type)); } + int find( const type &d, uint i=0 ) const + { return TQGArray::find((char*)&d,i,sizeof(type)); } + int contains( const type &d ) const + { return TQGArray::contains((char*)&d,sizeof(type)); } void sort() { TQGArray::sort(sizeof(type)); } int bsearch( const type &d ) const { return TQGArray::bsearch((const char*)&d,sizeof(type)); } diff --git a/tqtinterface/qt4/src/tools/tqptrcollection.cpp b/tqtinterface/qt4/src/tools/tqptrcollection.cpp index 38bbeef..481c272 100644 --- a/tqtinterface/qt4/src/tools/tqptrcollection.cpp +++ b/tqtinterface/qt4/src/tools/tqptrcollection.cpp @@ -114,7 +114,7 @@ if the collection has the only pointer to the items. The default setting is FALSE, for safety. If you turn it on, be - careful about copying the collection - you might tqfind yourself + careful about copying the collection - you might find yourself with two collections deleting the same items. Note that the auto-delete setting may also affect other functions diff --git a/tqtinterface/qt4/src/tools/tqptrdict.h b/tqtinterface/qt4/src/tools/tqptrdict.h index 908907d..882872e 100644 --- a/tqtinterface/qt4/src/tools/tqptrdict.h +++ b/tqtinterface/qt4/src/tools/tqptrdict.h @@ -64,11 +64,11 @@ public: bool isEmpty() const { return TQGDict::count() == 0; } void insert( void *k, const type *d ) { TQGDict::look_ptr(k,(Item)d,1); } - void tqreplace( void *k, const type *d ) + void replace( void *k, const type *d ) { TQGDict::look_ptr(k,(Item)d,2); } bool remove( void *k ) { return TQGDict::remove_ptr(k); } type *take( void *k ) { return (type*)TQGDict::take_ptr(k); } - type *tqfind( void *k ) const + type *find( void *k ) const { return (type *)((TQGDict*)this)->TQGDict::look_ptr(k,0,0); } type *operator[]( void *k ) const { return (type *)((TQGDict*)this)->TQGDict::look_ptr(k,0,0); } diff --git a/tqtinterface/qt4/src/tools/tqptrlist.h b/tqtinterface/qt4/src/tools/tqptrlist.h index 2839df6..25f7e1b 100644 --- a/tqtinterface/qt4/src/tools/tqptrlist.h +++ b/tqtinterface/qt4/src/tools/tqptrlist.h @@ -95,14 +95,14 @@ public: type *takeNode( TQLNode *n ) { return (type *)TQGList::takeNode(n); } void clear() { TQGList::clear(); } void sort() { TQGList::sort(); } - int tqfind( const type *d ) { return TQGList::tqfind((TQPtrCollection::Item)d); } - int tqfindNext( const type *d ) { return TQGList::tqfind((TQPtrCollection::Item)d,FALSE); } - int tqfindRef( const type *d ) { return TQGList::tqfindRef((TQPtrCollection::Item)d); } - int tqfindNextRef( const type *d ){ return TQGList::tqfindRef((TQPtrCollection::Item)d,FALSE);} - uint tqcontains( const type *d ) const { return TQGList::tqcontains((TQPtrCollection::Item)d); } - uint tqcontainsRef( const type *d ) const - { return TQGList::tqcontainsRef((TQPtrCollection::Item)d); } - bool tqreplace( uint i, const type *d ) { return TQGList::tqreplaceAt( i, (TQPtrCollection::Item)d ); } + int find( const type *d ) { return TQGList::find((TQPtrCollection::Item)d); } + int findNext( const type *d ) { return TQGList::find((TQPtrCollection::Item)d,FALSE); } + int findRef( const type *d ) { return TQGList::findRef((TQPtrCollection::Item)d); } + int findNextRef( const type *d ){ return TQGList::findRef((TQPtrCollection::Item)d,FALSE);} + uint contains( const type *d ) const { return TQGList::contains((TQPtrCollection::Item)d); } + uint containsRef( const type *d ) const + { return TQGList::containsRef((TQPtrCollection::Item)d); } + bool replace( uint i, const type *d ) { return TQGList::replaceAt( i, (TQPtrCollection::Item)d ); } type *at( uint i ) { return (type *)TQGList::at(i); } type *tqat( uint i ) { return (type *)TQGList::at(i); } int at() const { return TQGList::at(); } diff --git a/tqtinterface/qt4/src/tools/tqptrvector.h b/tqtinterface/qt4/src/tools/tqptrvector.h index 97934d4..14164ca 100644 --- a/tqtinterface/qt4/src/tools/tqptrvector.h +++ b/tqtinterface/qt4/src/tools/tqptrvector.h @@ -75,14 +75,14 @@ public: { return TQGVector::fill((Item)d,size);} void sort() { TQGVector::sort(); } int bsearch( const type *d ) const{ return TQGVector::bsearch((Item)d); } - int tqfindRef( const type *d, uint i=0 ) const - { return TQGVector::tqfindRef((Item)d,i);} - int tqfind( const type *d, uint i= 0 ) const - { return TQGVector::tqfind((Item)d,i); } - uint tqcontainsRef( const type *d ) const - { return TQGVector::tqcontainsRef((Item)d); } - uint tqcontains( const type *d ) const - { return TQGVector::tqcontains((Item)d); } + int findRef( const type *d, uint i=0 ) const + { return TQGVector::findRef((Item)d,i);} + int find( const type *d, uint i= 0 ) const + { return TQGVector::find((Item)d,i); } + uint containsRef( const type *d ) const + { return TQGVector::containsRef((Item)d); } + uint contains( const type *d ) const + { return TQGVector::contains((Item)d); } type *operator[]( int i ) const { return (type *)TQGVector::at(i); } type *at( uint i ) const { return (type *)TQGVector::at(i); } type *tqat( uint i ) const { return (type *)TQGVector::at(i); } diff --git a/tqtinterface/qt4/src/tools/tqregexp.cpp b/tqtinterface/qt4/src/tools/tqregexp.cpp index cac50e5..5f73872 100644 --- a/tqtinterface/qt4/src/tools/tqregexp.cpp +++ b/tqtinterface/qt4/src/tools/tqregexp.cpp @@ -140,23 +140,23 @@ void TQRegExp::setCaseSensitive( bool sensitive ) \mainclass \keyword regular expression - Regular expressions, or "regexps", provide a way to tqfind patterns + Regular expressions, or "regexps", provide a way to find patterns within text. This is useful in many contexts, for example: \table \row \i Validation \i A regexp can be used to check whether a piece of text - meets some criteria, e.g. is an integer or tqcontains no + meets some criteria, e.g. is an integer or contains no whitespace. \row \i Searching \i Regexps provide a much more powerful means of searching text than simple string matching does. For example we can - create a regexp which says "tqfind one of the words 'mail', + create a regexp which says "find one of the words 'mail', 'letter' or 'correspondence' but not any of the words 'email', 'mailman' 'mailer', 'letterbox' etc." \row \i Search and Replace - \i A regexp can be used to tqreplace a pattern with a piece of - text, for example tqreplace all occurrences of '&' with + \i A regexp can be used to replace a pattern with a piece of + text, for example replace all occurrences of '&' with '\&' except where the '&' is already followed by 'amp;'. \row \i String Splitting \i A regexp can be used to identify where a string should be @@ -227,9 +227,9 @@ void TQRegExp::setCaseSensitive( bool sensitive ) If you've seen regexps elsewhere they may have looked different from the ones above. This is because some sets of characters and some quantifiers are so common that they have special symbols to - represent them. <b>[0-9]</b> can be tqreplaced with the symbol + represent them. <b>[0-9]</b> can be replaced with the symbol <b>\d</b>. The quantifier to match exactly one occurrence, - <b>{1,1}</b>, can be tqreplaced with the expression itself. This means + <b>{1,1}</b>, can be replaced with the expression itself. This means that <b>x{1,1}</b> is exactly the same as <b>x</b> alone. So our 0 to 99 matcher could be written <b>^\d{1,2}$</b>. Another way of writing it would be <b>^\d\d{0,1}$</b>, i.e. from the start of the @@ -250,8 +250,8 @@ void TQRegExp::setCaseSensitive( bool sensitive ) followed by an 'i' followed by an 'l'. The symbol '|' (bar) is used for \e alternation, so our regexp now becomes <b>mail|letter|correspondence</b> which means match 'mail' \e or - 'letter' \e or 'correspondence'. Whilst this regexp will tqfind the - words we want it will also tqfind words we don't want such as + 'letter' \e or 'correspondence'. Whilst this regexp will find the + words we want it will also find words we don't want such as 'email'. We will start by putting our regexp in parentheses, <b>(mail|letter|correspondence)</b>. Parentheses have two effects, firstly they group expressions together and secondly they identify @@ -268,16 +268,16 @@ void TQRegExp::setCaseSensitive( bool sensitive ) boundary is any non-word character such as a space a newline or the beginning or end of the string. - For our third example we want to tqreplace ampersands with the HTML + For our third example we want to replace ampersands with the HTML entity '\&'. The regexp to match is simple: <b>\&</b>, i.e. match one ampersand. Unfortunately this will mess up our text if some of the ampersands have already been turned into HTML - entities. So what we really want to say is tqreplace an ampersand + entities. So what we really want to say is replace an ampersand providing it is not followed by 'amp;'. For this we need the negative lookahead assertion and our regexp becomes: <b>\&(?!amp;)</b>. The negative lookahead assertion is introduced with '(?!' and finishes at the ')'. It means that the text it - tqcontains, 'amp;' in our example, must \e not follow the expression + contains, 'amp;' in our example, must \e not follow the expression that preceeds it. Regexps provide a rich language that can be used in a variety of @@ -403,7 +403,7 @@ void TQRegExp::setCaseSensitive( bool sensitive ) occurrences it will match no occurrences at all. For example if we want to match strings that end in whitespace and use the regexp <b>\s*$</b> we would get a match on every string. - This is because we have said tqfind zero or more whitespace + This is because we have said find zero or more whitespace followed by the end of string, so even strings that don't end in whitespace will match. The regexp we want in this case is <b>\s+$</b> to match strings that have at least one @@ -439,7 +439,7 @@ void TQRegExp::setCaseSensitive( bool sensitive ) Note that quantifiers are "greedy". They will match as much text as they can. For example, <b>0+</b> will match as many zeros as it - can from the first zero it tqfinds, e.g. '2.<u>000</u>5'. + can from the first zero it finds, e.g. '2.<u>000</u>5'. Quantifiers can be made non-greedy, see setMinimal(). \target capturing-text @@ -605,7 +605,7 @@ void TQRegExp::setCaseSensitive( bool sensitive ) ... correspond to cap(1) or capturedTexts()[1], cap(2) or capturedTexts()[2], etc. - To substitute a pattern use TQString::tqreplace(). + To substitute a pattern use TQString::replace(). Perl's extended \c{/x} syntax is not supported, nor are directives, e.g. (?i), or regexp comments, e.g. (?#comment). On @@ -680,15 +680,15 @@ void TQRegExp::setCaseSensitive( bool sensitive ) \code TQRegExp rx( "&(?!amp;)" ); // match ampersands but not & TQString line1 = "This & that"; - line1.tqreplace( rx, "&" ); + line1.replace( rx, "&" ); // line1 == "This & that" TQString line2 = "His & hers & theirs"; - line2.tqreplace( rx, "&" ); + line2.replace( rx, "&" ); // line2 == "His & hers & theirs" \endcode - Here we've passed the TQRegExp to TQString's tqreplace() function to - tqreplace the matched text with new text. + Here we've passed the TQRegExp to TQString's replace() function to + replace the matched text with new text. \code TQString str = "One Eric another Eirik, and an Ericsson." @@ -847,7 +847,7 @@ static void mergeInto( TQMap<int, int> *a, const TQMap<int, int>& b ) */ static int at( const TQMap<int, int>& m, int k ) { - TQMap<int, int>::ConstIterator it = m.tqfind( k ); + TQMap<int, int>::ConstIterator it = m.find( k ); if ( it == m.end() ) return 0; else @@ -1336,7 +1336,7 @@ void TQRegExpEngine::match( const TQString& str, int pos, bool minimal, #ifndef TQT_NO_REGEXP_OPTIM if ( trivial && !oneTest ) { - mmPos = str.tqfind( goodStr, pos, cs ); + mmPos = str.find( goodStr, pos, cs ); mmMatchLen = goodStr.length(); matched = ( mmPos != -1 ); } else @@ -1457,7 +1457,7 @@ void TQRegExpEngine::addPlusTransitions( const TQMemArray<int>& from, if ( st->reenter == 0 ) st->reenter = new TQMap<int, int>; for ( int j = 0; j < (int) to.size(); j++ ) { - if ( !st->reenter->tqcontains(to[j]) && + if ( !st->reenter->contains(to[j]) && oldOuts.bsearch(to[j]) < 0 ) st->reenter->insert( to[j], atom ); } @@ -1512,7 +1512,7 @@ void TQRegExpEngine::addAnchors( int from, int to, int a ) State *st = s[from]; if ( st->anchors == 0 ) st->anchors = new TQMap<int, int>; - if ( st->anchors->tqcontains(to) ) + if ( st->anchors->contains(to) ) a = anchorAlternation( (*st->anchors)[to], a ); st->anchors->insert( to, a ); } @@ -1595,7 +1595,7 @@ void TQRegExpEngine::dump() const for ( j = 0; j < (int) s[i]->outs.size(); j++ ) { int next = s[i]->outs[j]; qDebug( " -> %d", next ); - if ( s[i]->reenter != 0 && s[i]->reenter->tqcontains(next) ) + if ( s[i]->reenter != 0 && s[i]->reenter->contains(next) ) qDebug( " [reenter %d]", (*s[i]->reenter)[next] ); if ( s[i]->anchors != 0 && at(*s[i]->anchors, next) != 0 ) qDebug( " [anchors 0x%.8x]", (*s[i]->anchors)[next] ); @@ -1790,7 +1790,7 @@ bool TQRegExpEngine::testAnchor( int i, int a, const int *capBegin ) bool TQRegExpEngine::goodStringMatch() { int k = mmPos + goodEarlyStart; - while ( (k = mmStr->tqfind(goodStr, k, cs)) != -1 ) { + while ( (k = mmStr->find(goodStr, k, cs)) != -1 ) { int from = k - goodLateStart; int to = k - goodEarlyStart; if ( from > mmPos ) @@ -2097,7 +2097,7 @@ bool TQRegExpEngine::matchHere() for c and n. We go up along c's and n's ancestry until - we tqfind x. + we find x. */ } else { p = c; @@ -3239,7 +3239,7 @@ void TQRegExpEngine::parseExpression( Box *box ) } /* - The struct TQRegExpPrivate tqcontains the private data of a regular + The struct TQRegExpPrivate contains the private data of a regular expression other than the automaton. It makes it possible for many TQRegExp objects to use the same TQRegExpEngine object with different TQRegExpPrivate objects. @@ -3685,7 +3685,7 @@ int TQRegExp::search( const TQString& str, int offset ) const } /*! - Attempts to tqfind a match in \a str from position \a offset (0 by + Attempts to find a match in \a str from position \a offset (0 by default). If \a offset is -1, the search starts at the last character; if -2, at the next to last character; etc. @@ -3695,9 +3695,9 @@ int TQRegExp::search( const TQString& str, int offset ) const The \a caretMode parameter can be used to instruct whether <b>^</b> should match at index 0 or at \a offset. - You might prefer to use TQString::tqfind(), TQString::tqcontains() or - even TQStringList::grep(). To tqreplace matches use - TQString::tqreplace(). + You might prefer to use TQString::find(), TQString::contains() or + even TQStringList::grep(). To replace matches use + TQString::replace(). Example: \code @@ -3735,7 +3735,7 @@ int TQRegExp::searchRev( const TQString& str, int offset ) const } /*! - Attempts to tqfind a match backwards in \a str from position \a + Attempts to find a match backwards in \a str from position \a offset. If \a offset is -1 (the default), the search starts at the last character; if -2, at the next to last character; etc. @@ -3801,7 +3801,7 @@ int TQRegExp::numCaptures() const Returns a list of the captured text strings. The first string in the list is the entire matched string. Each - subsequent list element tqcontains a string that matched a + subsequent list element contains a string that matched a (capturing) subexpression of the regexp. For example: @@ -3906,7 +3906,7 @@ TQStringList TQRegExp::capturedTexts() pos += rx.matchedLength(); } } - // list tqcontains "12", "14", "99", "231", "7" + // list contains "12", "14", "99", "231", "7" \endcode \sa capturedTexts() pos() exactMatch() search() searchRev() diff --git a/tqtinterface/qt4/src/tools/tqsettings.cpp b/tqtinterface/qt4/src/tools/tqsettings.cpp index 3ef5e5e..d949940 100644 --- a/tqtinterface/qt4/src/tools/tqsettings.cpp +++ b/tqtinterface/qt4/src/tools/tqsettings.cpp @@ -150,13 +150,13 @@ static inline int qt_open( const char *pathname, int flags, mode_t mode ) \code TQStringList keys = settings.entryList( "/MyApplication" ); - // keys tqcontains 'background color' and 'foreground color'. + // keys contains 'background color' and 'foreground color'. TQStringList keys = settings.entryList( "/MyApplication/recent files" ); - // keys tqcontains '1', '2' and '3'. + // keys contains '1', '2' and '3'. TQStringList subkeys = settings.subkeyList( "/MyApplication" ); - // subkeys tqcontains 'tqgeometry' and 'recent files' + // subkeys contains 'tqgeometry' and 'recent files' TQStringList subkeys = settings.subkeyList( "/MyApplication/recent files" ); // subkeys is empty. @@ -385,9 +385,9 @@ void TQSettingsHeading::parseLine(TQTextStream &stream) if (gname[(int)gname.length() - 1] == TQChar(']')) gname = gname.remove(gname.length() - 1, 1); - git = tqfind(gname); + git = find(gname); if (git == end()) - git = tqreplace(gname, TQSettingsGroup()); + git = replace(gname, TQSettingsGroup()); } else { if (git == end()) { #if defined(TQT_CHECK_STATE) @@ -396,7 +396,7 @@ void TQSettingsHeading::parseLine(TQTextStream &stream) return; } - int i = line.tqfind('='); + int i = line.find('='); if (i == -1) { #if defined(TQT_CHECK_STATE) qWarning("TQSettings: malformed line '%s' in group '%s'", @@ -529,27 +529,27 @@ TQSettingsGroup TQSettingsPrivate::readGroup() TQSettingsHeading hd; TQSettingsGroup grp; - TQMap<TQString,TQSettingsHeading>::Iterator headingsit = headings.tqfind(heading); + TQMap<TQString,TQSettingsHeading>::Iterator headingsit = headings.find(heading); if (headingsit != headings.end()) hd = *headingsit; - TQSettingsHeading::Iterator grpit = hd.tqfind(group); + TQSettingsHeading::Iterator grpit = hd.find(group); if (grpit == hd.end()) { TQStringList::Iterator it = searchPaths.begin(); if ( !globalScope ) ++it; while (it != searchPaths.end()) { - TQString filebase = heading.lower().tqreplace(TQRegExp(TQString::tqfromLatin1("\\s+")), "_"); + TQString filebase = heading.lower().replace(TQRegExp(TQString::tqfromLatin1("\\s+")), "_"); TQString fn((*it++) + "/" + filebase + "rc"); - if (! hd.tqcontains(fn + "cached")) { + if (! hd.contains(fn + "cached")) { hd.read(fn); hd.insert(fn + "cached", TQSettingsGroup()); } } - headings.tqreplace(heading, hd); + headings.replace(heading, hd); - grpit = hd.tqfind(group); + grpit = hd.find(group); if (grpit != hd.end()) grp = *grpit; } else if (hd.count() != 0) @@ -565,27 +565,27 @@ void TQSettingsPrivate::removeGroup(const TQString &key) TQSettingsGroup grp; bool found = FALSE; - TQMap<TQString,TQSettingsHeading>::Iterator headingsit = headings.tqfind(heading); + TQMap<TQString,TQSettingsHeading>::Iterator headingsit = headings.find(heading); if (headingsit != headings.end()) hd = *headingsit; - TQSettingsHeading::Iterator grpit = hd.tqfind(group); + TQSettingsHeading::Iterator grpit = hd.find(group); if (grpit == hd.end()) { TQStringList::Iterator it = searchPaths.begin(); if ( !globalScope ) ++it; while (it != searchPaths.end()) { - TQString filebase = heading.lower().tqreplace(TQRegExp(TQString::tqfromLatin1("\\s+")), "_"); + TQString filebase = heading.lower().replace(TQRegExp(TQString::tqfromLatin1("\\s+")), "_"); TQString fn((*it++) + "/" + filebase + "rc"); - if (! hd.tqcontains(fn + "cached")) { + if (! hd.contains(fn + "cached")) { hd.read(fn); hd.insert(fn + "cached", TQSettingsGroup()); } } - headings.tqreplace(heading, hd); + headings.replace(heading, hd); - grpit = hd.tqfind(group); + grpit = hd.find(group); if (grpit != hd.end()) { found = TRUE; grp = *grpit; @@ -599,12 +599,12 @@ void TQSettingsPrivate::removeGroup(const TQString &key) grp.remove(key); if (grp.count() > 0) - hd.tqreplace(group, grp); + hd.replace(group, grp); else hd.remove(group); if (hd.count() > 0) - headings.tqreplace(heading, hd); + headings.replace(heading, hd); else headings.remove(heading); @@ -618,36 +618,36 @@ void TQSettingsPrivate::writeGroup(const TQString &key, const TQString &value) TQSettingsHeading hd; TQSettingsGroup grp; - TQMap<TQString,TQSettingsHeading>::Iterator headingsit = headings.tqfind(heading); + TQMap<TQString,TQSettingsHeading>::Iterator headingsit = headings.find(heading); if (headingsit != headings.end()) hd = *headingsit; - TQSettingsHeading::Iterator grpit = hd.tqfind(group); + TQSettingsHeading::Iterator grpit = hd.find(group); if (grpit == hd.end()) { TQStringList::Iterator it = searchPaths.begin(); if ( !globalScope ) ++it; while (it != searchPaths.end()) { - TQString filebase = heading.lower().tqreplace(TQRegExp(TQString::tqfromLatin1("\\s+")), "_"); + TQString filebase = heading.lower().replace(TQRegExp(TQString::tqfromLatin1("\\s+")), "_"); TQString fn((*it++) + "/" + filebase + "rc"); - if (! hd.tqcontains(fn + "cached")) { + if (! hd.contains(fn + "cached")) { hd.read(fn); hd.insert(fn + "cached", TQSettingsGroup()); } } - headings.tqreplace(heading, hd); + headings.replace(heading, hd); - grpit = hd.tqfind(group); + grpit = hd.find(group); if (grpit != hd.end()) grp = *grpit; } else if (hd.count() != 0) grp = *grpit; grp.modified = TRUE; - grp.tqreplace(key, value); - hd.tqreplace(group, grp); - headings.tqreplace(heading, hd); + grp.replace(key, value); + hd.replace(group, grp); + headings.replace(heading, hd); modified = TRUE; } @@ -674,7 +674,7 @@ TQDateTime TQSettingsPrivate::modificationTime() bool qt_verify_key( const TQString &key ) { - if ( key.isEmpty() || key[0] != '/' || key.tqcontains( TQRegExp(TQString::tqfromLatin1("[=\\r\\n]")) ) ) + if ( key.isEmpty() || key[0] != '/' || key.contains( TQRegExp(TQString::tqfromLatin1("[=\\r\\n]")) ) ) return FALSE; return TRUE; } @@ -683,7 +683,7 @@ static TQString groupKey( const TQString &group, const TQString &key ) { TQString grp_key; if ( group.isEmpty() || ( group.length() == 1 && group[0] == '/' ) ) { - // group is empty, or it tqcontains a single '/', so we just return the key + // group is empty, or it contains a single '/', so we just return the key if ( key.startsWith( "/" ) ) grp_key = key; else @@ -775,7 +775,7 @@ static TQString groupKey( const TQString &group, const TQString &key ) Settings under Unix are stored in files whose names are based on the first subkey of the key (not including the search path). The algorithm - for creating names is essentially: lowercase the first subkey, tqreplace + for creating names is essentially: lowercase the first subkey, replace spaces with underscores and add 'rc', e.g. <tt>/MyCompany/MyApplication/background color</tt> will be stored in <tt>myapplicationrc</tt> (assuming that <tt>/MyCompany</tt> is part of @@ -826,7 +826,7 @@ void TQSettings::insertSearchPath( System s, const TQString &path) realPath = defPath + path; #endif - TQStringList::Iterator it = d->searchPaths.tqfind(d->searchPaths.last()); + TQStringList::Iterator it = d->searchPaths.find(d->searchPaths.last()); if (it != d->searchPaths.end()) { d->searchPaths.insert(it, realPath); } @@ -958,7 +958,7 @@ bool TQSettings::sync() if ( !d->globalScope ) ++pit; while (pit != d->searchPaths.end()) { - TQString filebase = it.key().lower().tqreplace(TQRegExp(TQString::tqfromLatin1("\\s+")), "_"); + TQString filebase = it.key().lower().replace(TQRegExp(TQString::tqfromLatin1("\\s+")), "_"); TQFileInfo di(*pit); if ( !di.exists() ) { TQDir dir; @@ -1024,8 +1024,8 @@ bool TQSettings::sync() if ( v.isNull() ) { v = TQString::tqfromLatin1("\\0"); // escape null string } else { - v.tqreplace('\\', TQString::tqfromLatin1("\\\\")); // escape backslash - v.tqreplace('\n', TQString::tqfromLatin1("\\n")); // escape newlines + v.replace('\\', TQString::tqfromLatin1("\\\\")); // escape backslash + v.replace('\n', TQString::tqfromLatin1("\\n")); // escape newlines } stream << grpit.key() << "=" << v << endl; @@ -1290,7 +1290,7 @@ TQString TQSettings::readEntry(const TQString &key, const TQString &def, bool *o } TQSettingsGroup grp = d->readGroup(); - TQSettingsGroup::const_iterator it = grp.tqfind( realkey ), end = grp.end(); + TQSettingsGroup::const_iterator it = grp.find( realkey ), end = grp.end(); TQString retval = def; if ( it != end ) { // found the value we needed @@ -1401,7 +1401,7 @@ bool TQSettings::writeEntry(const TQString &key, int value) Writes the entry specified by \a key with the string-literal \a value, replacing any previous setting. If \a value is zero-length or null, the - entry is tqreplaced by an empty setting. + entry is replaced by an empty setting. \e NOTE: This function is provided because some compilers use the writeEntry (const TQString &, bool) overload for this code: @@ -1564,7 +1564,7 @@ bool TQSettings::removeEntry(const TQString &key) In the above example, \c keys will contain 'background color' and 'foreground color'. It will not contain 'tqgeometry' because this key - tqcontains subkeys not entries. + contains subkeys not entries. To access the tqgeometry values, you could either use subkeyList() to read the keys then read each entry, or simply read each entry @@ -1633,7 +1633,7 @@ TQStringList TQSettings::entryList(const TQString &key) const itkey.remove( 0, realkey.length() + 1 ); } - if ( itkey.tqfind( '/' ) != -1 ) + if ( itkey.find( '/' ) != -1 ) continue; ret << itkey; @@ -1734,7 +1734,7 @@ TQStringList TQSettings::subkeyList(const TQString &key) const if ( subkeycount == 1 ) { TQMap<TQString,TQSettingsHeading>::Iterator it = d->headings.begin(); while ( it != d->headings.end() ) { - if ( it.key() != "General" && ! ret.tqcontains( it.key() ) ) + if ( it.key() != "General" && ! ret.contains( it.key() ) ) ret << it.key(); ++it; } @@ -1758,12 +1758,12 @@ TQStringList TQSettings::subkeyList(const TQString &key) const itkey.remove( 0, realkey.length() + 1 ); } - int slash = itkey.tqfind( '/' ); + int slash = itkey.find( '/' ); if ( slash == -1 ) continue; itkey.truncate( slash ); - if ( ! ret.tqcontains( itkey ) ) + if ( ! ret.contains( itkey ) ) ret << itkey; } @@ -1868,7 +1868,7 @@ bool TQSettings::writeEntry(const TQString &key, const TQStringList &value) if ( el.isNull() ) { el = "^0"; } else { - el.tqreplace("^", "^^"); + el.replace("^", "^^"); } s+=el; s+="^e"; // end of element @@ -2005,7 +2005,7 @@ void TQSettings::setPath( const TQString &domain, const TQString &product, Scope // scope. // // On MacOS X, if there is no "." in domain, append ".com", then reverse the -// order of the elements (Mac OS uses "com.apple.tqfinder" as domain+product). +// order of the elements (Mac OS uses "com.apple.finder" as domain+product). // The Global scope corresponds to /Library/Preferences/*.plist, while the // User scope corresponds to ~/Library/Preferences/*.plist. // Note that on most installations, not all users can write to the System @@ -2013,7 +2013,7 @@ void TQSettings::setPath( const TQString &domain, const TQString &product, Scope d->globalScope = scope == Global; TQString actualSearchPath; - int lastDot = domain.tqfindRev( '.' ); + int lastDot = domain.findRev( '.' ); #if defined(TQ_WS_WIN) actualSearchPath = "/" + domain.mid( 0, lastDot ) + "/" + product; diff --git a/tqtinterface/qt4/src/tools/tqstring.cpp b/tqtinterface/qt4/src/tools/tqstring.cpp index 9c31fcc..c57b539 100644 --- a/tqtinterface/qt4/src/tools/tqstring.cpp +++ b/tqtinterface/qt4/src/tools/tqstring.cpp @@ -86,7 +86,7 @@ // static QHash<void *, QByteArray> *asciiCache = 0; TQT_STATIC_CONST_IMPL TQChar TQChar::null; -TQT_STATIC_CONST_IMPL TQChar TQChar::tqreplacement((ushort)0xfffd); +TQT_STATIC_CONST_IMPL TQChar TQChar::replacement((ushort)0xfffd); TQT_STATIC_CONST_IMPL TQChar TQChar::byteOrderMark((ushort)0xfeff); TQT_STATIC_CONST_IMPL TQChar TQChar::byteOrderSwapped((ushort)0xfffe); TQT_STATIC_CONST_IMPL TQChar TQChar::nbsp((ushort)0x00a0); @@ -610,10 +610,10 @@ struct ArgEscapeData uint locale_occurrences; // number of occurences of the lowest escape // sequence number which contain 'L' uint escape_len; // total length of escape sequences which will - // be tqreplaced + // be replaced }; -static ArgEscapeData tqfindArgEscapes(const TQString &s) +static ArgEscapeData findArgEscapes(const TQString &s) { const TQChar *uc_begin = s.tqunicode(); const TQChar *uc_end = uc_begin + s.length(); @@ -658,7 +658,7 @@ static ArgEscapeData tqfindArgEscapes(const TQString &s) #if TQT_VERSION < 0x040000 // ### remove preprocessor in TQt 4.0 - /* Since in TQt < 4.0 only the first instance is tqreplaced, + /* Since in TQt < 4.0 only the first instance is replaced, escape_len should hold the length of only the first escape sequence */ if (d.occurrences == 0) @@ -677,7 +677,7 @@ static ArgEscapeData tqfindArgEscapes(const TQString &s) return d; } -static TQString tqreplaceArgEscapes(const TQString &s, const ArgEscapeData &d, int field_width, +static TQString replaceArgEscapes(const TQString &s, const ArgEscapeData &d, int field_width, const TQString &arg, const TQString &larg) { const TQChar *uc_begin = s.tqunicode(); @@ -766,7 +766,7 @@ static TQString tqreplaceArgEscapes(const TQString &s, const ArgEscapeData &d, i } /*! - This function will return a string that tqreplaces the lowest + This function will return a string that replaces the lowest numbered occurrence of \c %1, \c %2, ..., \c %9 with \a a. The \a fieldWidth value specifies the minimum amount of space that @@ -796,7 +796,7 @@ static TQString tqreplaceArgEscapes(const TQString &s, const ArgEscapeData &d, i */ TQString TQString::tqarg( const TQString& a, int fieldWidth ) const { - ArgEscapeData d = tqfindArgEscapes(*this); + ArgEscapeData d = findArgEscapes(*this); if (d.occurrences == 0) { qWarning( "TQString::tqarg(): Argument missing: %s, %s", latin1(), @@ -804,7 +804,7 @@ TQString TQString::tqarg( const TQString& a, int fieldWidth ) const return *this; } - return tqreplaceArgEscapes(*this, d, fieldWidth, a, a); + return replaceArgEscapes(*this, d, fieldWidth, a, a); } /*! @@ -813,8 +813,8 @@ TQString TQString::tqarg( const TQString& a, int fieldWidth ) const \overload This is the same as str.tqarg(\a a1).tqarg(\a a2), except that - the strings are tqreplaced in one pass. This can make a difference - if \a a1 tqcontains e.g. \c{%1}: + the strings are replaced in one pass. This can make a difference + if \a a1 contains e.g. \c{%1}: \code TQString str( "%1 %2" ); @@ -832,7 +832,7 @@ TQString TQString::tqarg( const TQString& a, int fieldWidth ) const \overload This is the same as calling str.tqarg(\a a1).tqarg(\a a2).tqarg(\a a3), - except that the strings are tqreplaced in one pass. + except that the strings are replaced in one pass. */ /*! @@ -842,7 +842,7 @@ TQString TQString::tqarg( const TQString& a, int fieldWidth ) const This is the same as calling str.tqarg(\a a1).tqarg(\a a2).tqarg(\a a3).tqarg(\a a4), - except that the strings are tqreplaced in one pass. + except that the strings are replaced in one pass. */ /*! @@ -857,7 +857,7 @@ TQString TQString::tqarg( const TQString& a, int fieldWidth ) const be between 2 and 36. The '%' can be followed by an 'L', in which case the sequence is - tqreplaced with a localized representation of \a a. The conversion + replaced with a localized representation of \a a. The conversion uses the default locale. The default locale is determined from the system's locale settings at application startup. It can be changed using TQLocale::setDefault(). The 'L' flag is ignored if \a base is @@ -903,7 +903,7 @@ TQString TQString::tqarg( ulong a, int fieldWidth, int base ) const */ TQString TQString::tqarg( TQ_LLONG a, int fieldWidth, int base ) const { - ArgEscapeData d = tqfindArgEscapes(*this); + ArgEscapeData d = findArgEscapes(*this); if (d.occurrences == 0) { qWarning( "TQString::tqarg(): Argument missing: %s, %lld", latin1(), @@ -921,7 +921,7 @@ TQString TQString::tqarg( TQ_LLONG a, int fieldWidth, int base ) const locale_arg = locale.d->longLongToString(a, -1, base, -1, TQLocalePrivate::ThousandsGroup); } - return tqreplaceArgEscapes(*this, d, fieldWidth, arg, locale_arg); + return replaceArgEscapes(*this, d, fieldWidth, arg, locale_arg); } /*! @@ -933,7 +933,7 @@ TQString TQString::tqarg( TQ_LLONG a, int fieldWidth, int base ) const */ TQString TQString::tqarg( TQ_ULLONG a, int fieldWidth, int base ) const { - ArgEscapeData d = tqfindArgEscapes(*this); + ArgEscapeData d = findArgEscapes(*this); if (d.occurrences == 0) { qWarning( "TQString::tqarg(): Argument missing: %s, %llu", latin1(), @@ -951,7 +951,7 @@ TQString TQString::tqarg( TQ_ULLONG a, int fieldWidth, int base ) const locale_arg = locale.d->unsLongLongToString(a, -1, base, -1, TQLocalePrivate::ThousandsGroup); } - return tqreplaceArgEscapes(*this, d, fieldWidth, arg, locale_arg); + return replaceArgEscapes(*this, d, fieldWidth, arg, locale_arg); } /*! @@ -1049,7 +1049,7 @@ TQString TQString::tqarg( TQChar a, int fieldWidth ) const */ TQString TQString::tqarg( double a, int fieldWidth, char fmt, int prec ) const { - ArgEscapeData d = tqfindArgEscapes(*this); + ArgEscapeData d = findArgEscapes(*this); if (d.occurrences == 0) { qWarning( "TQString::tqarg(): Argument missing: %s, %g", latin1(), @@ -1094,7 +1094,7 @@ TQString TQString::tqarg( double a, int fieldWidth, char fmt, int prec ) const locale_arg = locale.d->doubleToString(a, prec, form, -1, flags); } - return tqreplaceArgEscapes(*this, d, fieldWidth, arg, locale_arg); + return replaceArgEscapes(*this, d, fieldWidth, arg, locale_arg); } TQString TQString::tqmultiArg( int numArgs, const TQString& a1, const TQString& a2, const TQString& a3, const TQString& a4 ) const @@ -1267,7 +1267,7 @@ TQString TQString::setUnicodeCodes( const ushort* tqunicode_as_ushorts, uint len double d = TQString( "1,234,567.89" ).toDouble(&ok); // ok == false \endcode - \warning If the string tqcontains trailing whitespace this function + \warning If the string contains trailing whitespace this function will fail, and set \a *ok to false if \a ok is not 0. Leading whitespace is ignored. @@ -1317,7 +1317,7 @@ double TQString::toDouble( bool *ok ) const For information on how string-to-number functions in TQString handle localized input, see toDouble(). - \warning If the string tqcontains trailing whitespace this function + \warning If the string contains trailing whitespace this function will fail, settings \a *ok to false if \a ok is not 0. Leading whitespace is ignored. @@ -2345,8 +2345,8 @@ void TQString::compose() // joining info is only needed for Arabic if (format(ligature.tag(), *this, index, len)) { //printf("using ligature 0x%x, len=%d\n",code,len); - // tqreplace letter - composed.tqreplace(cindex, len, TQChar(head)); + // replace letter + composed.replace(cindex, len, TQChar(head)); index += len-1; // we continue searching in case we have a final // form because medial ones are preferred. @@ -2541,11 +2541,11 @@ char* TQString::tqunicodeToLatin1(const TQChar *uc, uint l) check for a non-null string rather than \c{if ( !str )}; see \l operator!() for an explanation. - Note that if you tqfind that you are mixing usage of \l TQCString, + Note that if you find that you are mixing usage of \l TQCString, TQString, and \l TQByteArray, this causes lots of unnecessary copying and might indicate that the true nature of the data you are dealing with is uncertain. If the data is '\0'-terminated 8-bit - data, use \l TQCString; if it is unterminated (i.e. tqcontains '\0's) + data, use \l TQCString; if it is unterminated (i.e. contains '\0's) 8-bit data, use \l TQByteArray; if it is text, use TQString. Lists of strings are handled by the TQStringList class. You can @@ -2618,7 +2618,7 @@ char* TQString::tqunicodeToLatin1(const TQChar *uc, uint l) \value ExactMatch The target and search strings must match exactly. \value BeginsWith The target string begins with the search string. \value EndsWith The target string ends with the search string. - \value Contains The target string tqcontains the search string. + \value Contains The target string contains the search string. If you OR these flags together (excluding \c CaseSensitive), the search criteria be applied in the following order: \c ExactMatch, @@ -2632,7 +2632,7 @@ char* TQString::tqunicodeToLatin1(const TQChar *uc, uint l) TQ_EXPORT TQStringData *TQString::shared_null = 0; TQT_STATIC_CONST_IMPL TQString TQString::null; TQT_STATIC_CONST_IMPL TQChar TQChar::null; -TQT_STATIC_CONST_IMPL TQChar TQChar::tqreplacement((ushort)0xfffd); +TQT_STATIC_CONST_IMPL TQChar TQChar::replacement((ushort)0xfffd); TQT_STATIC_CONST_IMPL TQChar TQChar::byteOrderMark((ushort)0xfeff); TQT_STATIC_CONST_IMPL TQChar TQChar::byteOrderSwapped((ushort)0xfffe); TQT_STATIC_CONST_IMPL TQChar TQChar::nbsp((ushort)0x00a0); @@ -3005,7 +3005,7 @@ void TQString::truncate( uint newLen ) /*! Ensures that at least \a newLen characters are allocated to the string, and sets the length of the string to \a newLen. Any new - space allocated tqcontains arbitrary data. + space allocated contains arbitrary data. \sa reserve(), truncate() */ @@ -3121,10 +3121,10 @@ struct ArgEscapeData uint locale_occurrences; // number of occurences of the lowest escape // sequence number which contain 'L' uint escape_len; // total length of escape sequences which will - // be tqreplaced + // be replaced }; -static ArgEscapeData tqfindArgEscapes(const TQString &s) +static ArgEscapeData findArgEscapes(const TQString &s) { const TQChar *uc_begin = s.tqunicode(); const TQChar *uc_end = uc_begin + s.length(); @@ -3169,7 +3169,7 @@ static ArgEscapeData tqfindArgEscapes(const TQString &s) #if TQT_VERSION < 0x040000 // ### remove preprocessor in TQt 4.0 - /* Since in TQt < 4.0 only the first instance is tqreplaced, + /* Since in TQt < 4.0 only the first instance is replaced, escape_len should hold the length of only the first escape sequence */ if (d.occurrences == 0) @@ -3188,7 +3188,7 @@ static ArgEscapeData tqfindArgEscapes(const TQString &s) return d; } -static TQString tqreplaceArgEscapes(const TQString &s, const ArgEscapeData &d, int field_width, +static TQString replaceArgEscapes(const TQString &s, const ArgEscapeData &d, int field_width, const TQString &arg, const TQString &larg) { const TQChar *uc_begin = s.tqunicode(); @@ -3275,7 +3275,7 @@ static TQString tqreplaceArgEscapes(const TQString &s, const ArgEscapeData &d, i } /*! - This function will return a string that tqreplaces the lowest + This function will return a string that replaces the lowest numbered occurrence of \c %1, \c %2, ..., \c %9 with \a a. The \a fieldWidth value specifies the minimum amount of space that @@ -3305,7 +3305,7 @@ static TQString tqreplaceArgEscapes(const TQString &s, const ArgEscapeData &d, i */ TQString TQString::arg( const TQString& a, int fieldWidth ) const { - ArgEscapeData d = tqfindArgEscapes(*this); + ArgEscapeData d = findArgEscapes(*this); if (d.occurrences == 0) { qWarning( "TQString::arg(): Argument missing: %s, %s", latin1(), @@ -3313,7 +3313,7 @@ TQString TQString::arg( const TQString& a, int fieldWidth ) const return *this; } - return tqreplaceArgEscapes(*this, d, fieldWidth, a, a); + return replaceArgEscapes(*this, d, fieldWidth, a, a); } /*! @@ -3322,8 +3322,8 @@ TQString TQString::arg( const TQString& a, int fieldWidth ) const \overload This is the same as str.arg(\a a1).arg(\a a2), except that - the strings are tqreplaced in one pass. This can make a difference - if \a a1 tqcontains e.g. \c{%1}: + the strings are replaced in one pass. This can make a difference + if \a a1 contains e.g. \c{%1}: \code TQString str( "%1 %2" ); @@ -3341,7 +3341,7 @@ TQString TQString::arg( const TQString& a, int fieldWidth ) const \overload This is the same as calling str.arg(\a a1).arg(\a a2).arg(\a a3), - except that the strings are tqreplaced in one pass. + except that the strings are replaced in one pass. */ /*! @@ -3351,7 +3351,7 @@ TQString TQString::arg( const TQString& a, int fieldWidth ) const This is the same as calling str.arg(\a a1).arg(\a a2).arg(\a a3).arg(\a a4), - except that the strings are tqreplaced in one pass. + except that the strings are replaced in one pass. */ /*! @@ -3366,7 +3366,7 @@ TQString TQString::arg( const TQString& a, int fieldWidth ) const be between 2 and 36. The '%' can be followed by an 'L', in which case the sequence is - tqreplaced with a localized representation of \a a. The conversion + replaced with a localized representation of \a a. The conversion uses the default locale. The default locale is determined from the system's locale settings at application startup. It can be changed using TQLocale::setDefault(). The 'L' flag is ignored if \a base is @@ -3412,7 +3412,7 @@ TQString TQString::arg( ulong a, int fieldWidth, int base ) const */ TQString TQString::arg( TQ_LLONG a, int fieldWidth, int base ) const { - ArgEscapeData d = tqfindArgEscapes(*this); + ArgEscapeData d = findArgEscapes(*this); if (d.occurrences == 0) { qWarning( "TQString::arg(): Argument missing: %s, %lld", latin1(), @@ -3430,7 +3430,7 @@ TQString TQString::arg( TQ_LLONG a, int fieldWidth, int base ) const locale_arg = locale.d->longLongToString(a, -1, base, -1, TQLocalePrivate::ThousandsGroup); } - return tqreplaceArgEscapes(*this, d, fieldWidth, arg, locale_arg); + return replaceArgEscapes(*this, d, fieldWidth, arg, locale_arg); } /*! @@ -3442,7 +3442,7 @@ TQString TQString::arg( TQ_LLONG a, int fieldWidth, int base ) const */ TQString TQString::arg( TQ_ULLONG a, int fieldWidth, int base ) const { - ArgEscapeData d = tqfindArgEscapes(*this); + ArgEscapeData d = findArgEscapes(*this); if (d.occurrences == 0) { qWarning( "TQString::arg(): Argument missing: %s, %llu", latin1(), @@ -3460,7 +3460,7 @@ TQString TQString::arg( TQ_ULLONG a, int fieldWidth, int base ) const locale_arg = locale.d->unsLongLongToString(a, -1, base, -1, TQLocalePrivate::ThousandsGroup); } - return tqreplaceArgEscapes(*this, d, fieldWidth, arg, locale_arg); + return replaceArgEscapes(*this, d, fieldWidth, arg, locale_arg); } /*! @@ -3558,7 +3558,7 @@ TQString TQString::arg( TQChar a, int fieldWidth ) const */ TQString TQString::arg( double a, int fieldWidth, char fmt, int prec ) const { - ArgEscapeData d = tqfindArgEscapes(*this); + ArgEscapeData d = findArgEscapes(*this); if (d.occurrences == 0) { qWarning( "TQString::arg(): Argument missing: %s, %g", latin1(), @@ -3603,7 +3603,7 @@ TQString TQString::arg( double a, int fieldWidth, char fmt, int prec ) const locale_arg = locale.d->doubleToString(a, prec, form, -1, flags); } - return tqreplaceArgEscapes(*this, d, fieldWidth, arg, locale_arg); + return replaceArgEscapes(*this, d, fieldWidth, arg, locale_arg); } TQString TQString::multiArg( int numArgs, const TQString& a1, const TQString& a2, @@ -3685,9 +3685,9 @@ TQString TQString::multiArg( int numArgs, const TQString& a1, const TQString& a2 \endcode For \link TQObject::tr() translations,\endlink especially if the - strings tqcontains more than one escape sequence, you should + strings contains more than one escape sequence, you should consider using the arg() function instead. This allows the order - of the tqreplacements to be controlled by the translator, and has + of the replacements to be controlled by the translator, and has Unicode support. The %lc escape sequence expects a tqunicode character of type ushort @@ -3770,7 +3770,7 @@ TQString &TQString::sprintf( const char* cformat, ... ) width_str.append(*c++); // can't be negative - started with a digit - // tqcontains at least one digit + // contains at least one digit width = width_str.toInt(); } else if (*c == '*') { @@ -3795,7 +3795,7 @@ TQString &TQString::sprintf( const char* cformat, ... ) precision_str.append(*c++); // can't be negative - started with a digit - // tqcontains at least one digit + // contains at least one digit precision = precision_str.toInt(); } else if (*c == '*') { @@ -4080,7 +4080,7 @@ TQString& TQString::fill( TQChar c, int len ) Finds the first occurrence of the character \a c, starting at position \a index. If \a index is -1, the search starts at the last character; if -2, at the next to last character and so on. - (See tqfindRev() for searching backwards.) + (See findRev() for searching backwards.) If \a cs is TRUE (the default), the search is case sensitive; otherwise the search is case insensitive. @@ -4088,7 +4088,7 @@ TQString& TQString::fill( TQChar c, int len ) Returns the position of \a c or -1 if \a c could not be found. */ -int TQString::tqfind( TQChar c, int index, bool cs ) const +int TQString::find( TQChar c, int index, bool cs ) const { const uint l = length(); if ( index < 0 ) @@ -4144,7 +4144,7 @@ static void bm_init_skiptable( const TQString &pattern, uint *skiptable, bool cs } } -static int bm_tqfind( const TQString &str, int index, const TQString &pattern, uint *skiptable, bool cs ) +static int bm_find( const TQString &str, int index, const TQString &pattern, uint *skiptable, bool cs ) { const uint l = str.length(); if ( pattern.isEmpty() ) @@ -4217,7 +4217,7 @@ static int bm_tqfind( const TQString &str, int index, const TQString &pattern, u Finds the first occurrence of the string \a str, starting at position \a index. If \a index is -1, the search starts at the last character, if it is -2, at the next to last character and so - on. (See tqfindRev() for searching backwards.) + on. (See findRev() for searching backwards.) If \a cs is TRUE (the default), the search is case sensitive; otherwise the search is case insensitive. @@ -4225,7 +4225,7 @@ static int bm_tqfind( const TQString &str, int index, const TQString &pattern, u Returns the position of \a str or -1 if \a str could not be found. */ -int TQString::tqfind( const TQString& str, int index, bool cs ) const +int TQString::find( const TQString& str, int index, bool cs ) const { const uint l = length(); const uint sl = str.length(); @@ -4240,7 +4240,7 @@ int TQString::tqfind( const TQString& str, int index, bool cs ) const #if defined(TQ_OS_MACX) && defined(TQT_MACOSX_VERSION) && TQT_MACOSX_VERSION >= 0x1020 if ( sl == 1 ) - return tqfind( *str.tqunicode(), index, cs ); + return find( *str.tqunicode(), index, cs ); #endif // we use the Boyer-Moore algorithm in cases where the overhead @@ -4249,7 +4249,7 @@ int TQString::tqfind( const TQString& str, int index, bool cs ) const if ( l > 500 && sl > 5 ) { uint skiptable[0x100]; bm_init_skiptable( str, skiptable, cs ); - return bm_tqfind( *this, index, str, skiptable, cs ); + return bm_find( *this, index, str, skiptable, cs ); } /* @@ -4303,17 +4303,17 @@ int TQString::tqfind( const TQString& str, int index, bool cs ) const } /*! - \fn int TQString::tqfindRev( const char* str, int index ) const + \fn int TQString::findRev( const char* str, int index ) const - Equivalent to tqfindRev(TQString(\a str), \a index). + Equivalent to findRev(TQString(\a str), \a index). */ /*! - \fn int TQString::tqfind( const char* str, int index ) const + \fn int TQString::find( const char* str, int index ) const \overload - Equivalent to tqfind(TQString(\a str), \a index). + Equivalent to find(TQString(\a str), \a index). */ /*! @@ -4331,14 +4331,14 @@ int TQString::tqfind( const TQString& str, int index, bool cs ) const \code TQString string( "bananas" ); - int i = string.tqfindRev( 'a' ); // i == 5 + int i = string.findRev( 'a' ); // i == 5 \endcode */ -int TQString::tqfindRev( TQChar c, int index, bool cs ) const +int TQString::findRev( TQChar c, int index, bool cs ) const { #if defined(TQ_OS_MACX) && defined(TQT_MACOSX_VERSION) && TQT_MACOSX_VERSION < 0x1020 - return tqfindRev( TQString( c ), index, cs ); + return findRev( TQString( c ), index, cs ); #else const uint l = length(); if ( index < 0 ) @@ -4374,14 +4374,14 @@ int TQString::tqfindRev( TQChar c, int index, bool cs ) const \code TQString string("bananas"); - int i = string.tqfindRev( "ana" ); // i == 3 + int i = string.findRev( "ana" ); // i == 3 \endcode */ -int TQString::tqfindRev( const TQString& str, int index, bool cs ) const +int TQString::findRev( const TQString& str, int index, bool cs ) const { /* - See TQString::tqfind() for explanations. + See TQString::find() for explanations. */ const uint l = length(); if ( index < 0 ) @@ -4395,7 +4395,7 @@ int TQString::tqfindRev( const TQString& str, int index, bool cs ) const #if defined(TQ_OS_MACX) && defined(TQT_MACOSX_VERSION) && TQT_MACOSX_VERSION >= 0x1020 if ( sl == 1 ) - return tqfindRev( *str.tqunicode(), index, cs ); + return findRev( *str.tqunicode(), index, cs ); #endif const TQChar* needle = str.tqunicode(); @@ -4718,12 +4718,12 @@ TQString TQString::section( const TQRegExp ®, int start, int end, int flags ) \code TQString string( "Trolltech and TQt" ); - int n = string.tqcontains( 't', FALSE ); + int n = string.contains( 't', FALSE ); // n == 3 \endcode */ -int TQString::tqcontains( TQChar c, bool cs ) const +int TQString::contains( TQChar c, bool cs ) const { int count = 0; const TQChar *uc = tqunicode(); @@ -4755,19 +4755,19 @@ int TQString::tqcontains( TQChar c, bool cs ) const If \a cs is TRUE (the default), the search is case sensitive; otherwise the search is case insensitive. */ -int TQString::tqcontains( const char* str, bool cs ) const +int TQString::contains( const char* str, bool cs ) const { - return tqcontains( TQString(str), cs ); + return contains( TQString(str), cs ); } /*! - \fn int TQString::tqcontains( char c, bool cs ) const + \fn int TQString::contains( char c, bool cs ) const \overload */ /*! - \fn int TQString::tqfind( char c, int index, bool cs ) const + \fn int TQString::find( char c, int index, bool cs ) const \overload @@ -4778,7 +4778,7 @@ int TQString::tqcontains( const char* str, bool cs ) const */ /*! - \fn int TQString::tqfindRev( char c, int index, bool cs ) const + \fn int TQString::findRev( char c, int index, bool cs ) const \overload @@ -4802,13 +4802,13 @@ int TQString::tqcontains( const char* str, bool cs ) const \code TQString str( "bananas" ); - int i = str.tqcontains( "ana" ); // i == 2 + int i = str.contains( "ana" ); // i == 2 \endcode - \sa tqfindRev() + \sa findRev() */ -int TQString::tqcontains( const TQString &str, bool cs ) const +int TQString::contains( const TQString &str, bool cs ) const { if ( isNull() ) return 0; @@ -4817,13 +4817,13 @@ int TQString::tqcontains( const TQString &str, bool cs ) const bm_init_skiptable( str, skiptable, cs ); int i = -1; // use boyer-moore for the ultimate speed experience - while ( ( i = bm_tqfind( *this, i + 1, str, skiptable, cs ) ) != -1 ) + while ( ( i = bm_find( *this, i + 1, str, skiptable, cs ) ) != -1 ) count++; return count; } /*! - Returns a substring that tqcontains the \a len leftmost characters + Returns a substring that contains the \a len leftmost characters of the string. The whole string is returned if \a len exceeds the length of the @@ -4854,7 +4854,7 @@ TQString TQString::left( uint len ) const } /*! - Returns a string that tqcontains the \a len rightmost characters of + Returns a string that contains the \a len rightmost characters of the string. If \a len is greater than the length of the string then the whole @@ -4886,7 +4886,7 @@ TQString TQString::right( uint len ) const } /*! - Returns a string that tqcontains the \a len characters of this + Returns a string that contains the \a len characters of this string, starting at position \a index. Returns a null string if the string is empty or \a index is out of @@ -4922,7 +4922,7 @@ TQString TQString::mid( uint index, uint len ) const } /*! - Returns a string of length \a width that tqcontains this string + Returns a string of length \a width that contains this string padded by the \a fill character. If \a truncate is FALSE and the length of the string is more than @@ -4962,7 +4962,7 @@ TQString TQString::leftJustify( uint width, TQChar fill, bool truncate ) const } /*! - Returns a string of length \a width that tqcontains the \a fill + Returns a string of length \a width that contains the \a fill character followed by the string. If \a truncate is FALSE and the length of the string is more than @@ -5115,7 +5115,7 @@ TQString TQString::stripWhiteSpace() const /*! Returns a string that has whitespace removed from the start and the end, and which has each sequence of internal whitespace - tqreplaced with a single space. + replaced with a single space. Whitespace means any character for which TQChar::isSpace() returns TRUE. This includes Unicode characters with decimal values 9 @@ -5170,7 +5170,7 @@ TQString TQString::simplifyWhiteSpace() const // str == "I don't like fish" \endcode - \sa remove(), tqreplace() + \sa remove(), replace() */ TQString &TQString::insert( uint index, const TQString &s ) @@ -5388,7 +5388,7 @@ TQString &TQString::prepend( const char *s ) string.remove( 1, 4 ); // string == "Meal" \endcode - \sa insert(), tqreplace() + \sa insert(), replace() */ TQString &TQString::remove( uint index, uint len ) @@ -5412,7 +5412,7 @@ TQString &TQString::remove( uint index, uint len ) Removes every occurrence of the character \a c in the string. Returns a reference to the string. - This is the same as tqreplace(\a c, ""). + This is the same as replace(\a c, ""). */ TQString &TQString::remove( TQChar c ) { @@ -5434,7 +5434,7 @@ TQString &TQString::remove( TQChar c ) Removes every occurrence of the character \a c in the string. Returns a reference to the string. - This is the same as tqreplace(\a c, ""). + This is the same as replace(\a c, ""). */ /*! \overload @@ -5445,7 +5445,7 @@ TQString &TQString::remove( TQChar c ) If \a cs is TRUE (the default), the search is case sensitive; otherwise the search is case insensitive. - This is the same as tqreplace(\a str, "", \a cs). + This is the same as replace(\a str, "", \a cs). */ TQString &TQString::remove( const TQString & str, bool cs ) { @@ -5454,7 +5454,7 @@ TQString &TQString::remove( const TQString & str, bool cs ) real_detach(); } else { int index = 0; - while ( (index = tqfind(str, index, cs)) != -1 ) + while ( (index = find(str, index, cs)) != -1 ) remove( index, str.length() ); } return *this; @@ -5470,7 +5470,7 @@ TQString &TQString::remove( const TQString & str ) Replaces every occurrence of \a c1 with the char \a c2. Returns a reference to the string. */ -TQString &TQString::tqreplace( TQChar c1, TQChar c2 ) +TQString &TQString::replace( TQChar c1, TQChar c2 ) { if ( isEmpty() ) return *this; @@ -5492,12 +5492,12 @@ TQString &TQString::tqreplace( TQChar c1, TQChar c2 ) Removes every occurrence of the regular expression \a rx in the string. Returns a reference to the string. - This is the same as tqreplace(\a rx, ""). + This is the same as replace(\a rx, ""). */ TQString &TQString::remove( const TQRegExp & rx ) { - return tqreplace( rx, TQString::null ); + return replace( rx, TQString::null ); } #endif @@ -5525,7 +5525,7 @@ TQString &TQString::remove( const char *str ) \code TQString string( "Say yes!" ); - string = string.tqreplace( 4, 3, "NO" ); + string = string.replace( 4, 3, "NO" ); // string == "Say NO!" \endcode @@ -5538,24 +5538,24 @@ TQString &TQString::remove( const char *str ) \sa insert(), remove() */ -TQString &TQString::tqreplace( uint index, uint len, const TQString &s ) +TQString &TQString::replace( uint index, uint len, const TQString &s ) { - return tqreplace( index, len, s.tqunicode(), s.length() ); + return replace( index, len, s.tqunicode(), s.length() ); } /*! \overload - This is the same as tqreplace(\a index, \a len, TQString(\a c)). + This is the same as replace(\a index, \a len, TQString(\a c)). */ -TQString &TQString::tqreplace( uint index, uint len, TQChar c ) +TQString &TQString::replace( uint index, uint len, TQChar c ) { - return tqreplace( index, len, &c, 1 ); + return replace( index, len, &c, 1 ); } /*! \overload - \fn TQString &TQString::tqreplace( uint index, uint len, char c ) + \fn TQString &TQString::replace( uint index, uint len, char c ) - This is the same as tqreplace(\a index, \a len, TQChar(\a c)). + This is the same as replace(\a index, \a len, TQChar(\a c)). */ /*! @@ -5568,19 +5568,19 @@ TQString &TQString::tqreplace( uint index, uint len, TQChar c ) \sa insert(), remove() */ -TQString &TQString::tqreplace( uint index, uint len, const TQChar* s, uint slen ) +TQString &TQString::replace( uint index, uint len, const TQChar* s, uint slen ) { if (index > length()) index = length(); real_detach(); if ( len == slen && index + len <= length() ) { - // Optimized common case: tqreplace without size change + // Optimized common case: replace without size change memcpy( d->tqunicode+index, s, len * sizeof(TQChar) ); } else if ( s >= d->tqunicode && (uint)(s - d->tqunicode) < d->maxl ) { // Part of me - take a copy. TQChar *tmp = TQT_ALLOC_TQCHAR_VEC( slen ); memcpy( tmp, s, slen * sizeof(TQChar) ); - tqreplace( index, len, tmp, slen ); + replace( index, len, tmp, slen ); TQT_DELETE_TQCHAR_VEC( tmp ); } else { remove( index, len ); @@ -5600,22 +5600,22 @@ TQString &TQString::tqreplace( uint index, uint len, const TQChar* s, uint slen Example: \code TQString s = "a,b,c"; - s.tqreplace( TQChar(','), " or " ); + s.replace( TQChar(','), " or " ); // s == "a or b or c" \endcode */ -TQString &TQString::tqreplace( TQChar c, const TQString & after, bool cs ) +TQString &TQString::replace( TQChar c, const TQString & after, bool cs ) { - return tqreplace( TQString( c ), after, cs ); + return replace( TQString( c ), after, cs ); } -TQString &TQString::tqreplace( TQChar c, const TQString & after ) +TQString &TQString::replace( TQChar c, const TQString & after ) { - return tqreplace( TQString( c ), after, TRUE ); + return replace( TQString( c ), after, TRUE ); } /*! \overload - \fn TQString &TQString::tqreplace( char c, const TQString & after, bool cs ) + \fn TQString &TQString::replace( char c, const TQString & after, bool cs ) Replaces every occurrence of the character \a c in the string with \a after. Returns a reference to the string. @@ -5635,11 +5635,11 @@ TQString &TQString::tqreplace( TQChar c, const TQString & after ) Example: \code TQString s = "Greek is Greek"; - s.tqreplace( "Greek", "English" ); + s.replace( "Greek", "English" ); // s == "English is English" \endcode */ -TQString &TQString::tqreplace( const TQString & before, const TQString & after, +TQString &TQString::replace( const TQString & before, const TQString & after, bool cs ) { if ( isEmpty() ) { @@ -5661,7 +5661,7 @@ TQString &TQString::tqreplace( const TQString & before, const TQString & after, if ( bl == al ) { if ( bl ) { const TQChar *auc = after.tqunicode(); - while ( (index = bm_tqfind(*this, index, before, skiptable, cs) ) != -1 ) { + while ( (index = bm_find(*this, index, before, skiptable, cs) ) != -1 ) { memcpy( d->tqunicode + index, auc, al * sizeof(TQChar) ); index += bl; } @@ -5671,7 +5671,7 @@ TQString &TQString::tqreplace( const TQString & before, const TQString & after, uint to = 0; uint movestart = 0; uint num = 0; - while ( (index = bm_tqfind(*this, index, before, skiptable, cs)) != -1 ) { + while ( (index = bm_find(*this, index, before, skiptable, cs)) != -1 ) { if ( num ) { int msize = index - movestart; if ( msize > 0 ) { @@ -5702,7 +5702,7 @@ TQString &TQString::tqreplace( const TQString & before, const TQString & after, uint indices[4096]; uint pos = 0; while ( pos < 4095 ) { - index = bm_tqfind( *this, index, before, skiptable, cs ); + index = bm_find( *this, index, before, skiptable, cs ); if ( index == -1 ) break; indices[pos++] = index; @@ -5714,7 +5714,7 @@ TQString &TQString::tqreplace( const TQString & before, const TQString & after, if ( !pos ) break; - // we have a table of tqreplacement positions, use them for fast replacing + // we have a table of replacement positions, use them for fast replacing int adjust = pos*(al-bl); // index has to be adjusted in case we get back into the loop above. if ( index != -1 ) @@ -5738,9 +5738,9 @@ TQString &TQString::tqreplace( const TQString & before, const TQString & after, return *this; } -TQString &TQString::tqreplace( const TQString & before, const TQString & after ) +TQString &TQString::replace( const TQString & before, const TQString & after ) { - return tqreplace( before, after, TRUE ); + return replace( before, after, TRUE ); } #ifndef TQT_NO_REGEXP_CAPTURE @@ -5750,24 +5750,24 @@ TQString &TQString::tqreplace( const TQString & before, const TQString & after ) \a after. Returns a reference to the string. For example: \code TQString s = "banana"; - s.tqreplace( TQRegExp("an"), "" ); + s.replace( TQRegExp("an"), "" ); // s == "ba" \endcode For regexps containing \link tqregexp.html#capturing-text capturing parentheses \endlink, occurrences of <b>\\1</b>, <b>\\2</b>, ..., - in \a after are tqreplaced with \a{rx}.cap(1), cap(2), ... + in \a after are replaced with \a{rx}.cap(1), cap(2), ... \code TQString t = "A <i>bon mot</i>."; - t.tqreplace( TQRegExp("<i>([^<]*)</i>"), "\\emph{\\1}" ); + t.replace( TQRegExp("<i>([^<]*)</i>"), "\\emph{\\1}" ); // t == "A \\emph{bon mot}." \endcode - \sa tqfind(), tqfindRev(), TQRegExp::cap() + \sa find(), findRev(), TQRegExp::cap() */ -TQString &TQString::tqreplace( const TQRegExp &rx, const TQString &after ) +TQString &TQString::replace( const TQRegExp &rx, const TQString &after ) { TQRegExp rx2 = rx; @@ -5823,10 +5823,10 @@ TQString &TQString::tqreplace( const TQRegExp &rx, const TQString &after ) TQString after2 = after; for ( j = numBackRefs - 1; j >= 0; j-- ) - after2.tqreplace( capturePositions[j], 2, + after2.replace( capturePositions[j], 2, rx2.cap(captureNumbers[j]) ); - tqreplace( index, rx2.matchedLength(), after2 ); + replace( index, rx2.matchedLength(), after2 ); index += after2.length(); if ( rx2.matchedLength() == 0 ) { @@ -5849,7 +5849,7 @@ TQString &TQString::tqreplace( const TQRegExp &rx, const TQString &after ) struct { int pos; int length; - } tqreplacements[2048]; + } replacements[2048]; uint pos = 0; int adjust = 0; @@ -5858,8 +5858,8 @@ TQString &TQString::tqreplace( const TQRegExp &rx, const TQString &after ) if ( index == -1 ) break; int ml = rx2.matchedLength(); - tqreplacements[pos].pos = index; - tqreplacements[pos++].length = ml; + replacements[pos].pos = index; + replacements[pos++].length = ml; index += ml; adjust += al - ml; // avoid infinite loop @@ -5868,11 +5868,11 @@ TQString &TQString::tqreplace( const TQRegExp &rx, const TQString &after ) } if ( !pos ) break; - tqreplacements[pos].pos = d->len; + replacements[pos].pos = d->len; uint newlen = d->len + adjust; // to continue searching at the right position after we did - // the first round of tqreplacements + // the first round of replacements if ( index != -1 ) index += adjust; TQChar *newuc = TQT_ALLOC_TQCHAR_VEC( newlen + 1 ); @@ -5880,13 +5880,13 @@ TQString &TQString::tqreplace( const TQRegExp &rx, const TQString &after ) int copystart = 0; uint i = 0; while ( i < pos ) { - int copyend = tqreplacements[i].pos; + int copyend = replacements[i].pos; int size = copyend - copystart; memcpy( uc, d->tqunicode + copystart, size * sizeof(TQChar) ); uc += size; memcpy( uc, after.tqunicode(), al * sizeof(TQChar) ); uc += al; - copystart = copyend + tqreplacements[i].length; + copystart = copyend + replacements[i].length; i++; } memcpy( uc, d->tqunicode + copystart, @@ -5907,20 +5907,20 @@ TQString &TQString::tqreplace( const TQRegExp &rx, const TQString &after ) Finds the first match of the regular expression \a rx, starting from position \a index. If \a index is -1, the search starts at the last character; if -2, at the next to last character and so - on. (See tqfindRev() for searching backwards.) + on. (See findRev() for searching backwards.) Returns the position of the first match of \a rx or -1 if no match was found. \code TQString string( "bananas" ); - int i = string.tqfind( TQRegExp("an"), 0 ); // i == 1 + int i = string.find( TQRegExp("an"), 0 ); // i == 1 \endcode - \sa tqfindRev() tqreplace() tqcontains() + \sa findRev() replace() contains() */ -int TQString::tqfind( const TQRegExp &rx, int index ) const +int TQString::find( const TQRegExp &rx, int index ) const { return rx.search( *this, index ); } @@ -5931,19 +5931,19 @@ int TQString::tqfind( const TQRegExp &rx, int index ) const Finds the first match of the regexp \a rx, starting at position \a index and searching backwards. If the index is -1, the search starts at the last character, if it is -2, at the next to last - character and so on. (See tqfindRev() for searching backwards.) + character and so on. (See findRev() for searching backwards.) Returns the position of the match or -1 if no match was found. \code TQString string( "bananas" ); - int i = string.tqfindRev( TQRegExp("an") ); // i == 3 + int i = string.findRev( TQRegExp("an") ); // i == 3 \endcode - \sa tqfind() + \sa find() */ -int TQString::tqfindRev( const TQRegExp &rx, int index ) const +int TQString::findRev( const TQRegExp &rx, int index ) const { return rx.searchRev( *this, index ); } @@ -5960,13 +5960,13 @@ int TQString::tqfindRev( const TQRegExp &rx, int index ) const \code TQString str = "banana and panama"; TQRegExp rxp = TQRegExp( "a[nm]a", TRUE, FALSE ); - int i = str.tqcontains( rxp ); // i == 4 + int i = str.contains( rxp ); // i == 4 \endcode - \sa tqfind() tqfindRev() + \sa find() findRev() */ -int TQString::tqcontains( const TQRegExp &rx ) const +int TQString::contains( const TQRegExp &rx ) const { int count = 0; int index = -1; @@ -6376,7 +6376,7 @@ uint TQString::toUInt( bool *ok, int base ) const double d = TQString( "1,234,567.89" ).toDouble(&ok); // ok == false \endcode - \warning If the string tqcontains trailing whitespace this function + \warning If the string contains trailing whitespace this function will fail, and set \a *ok to false if \a ok is not 0. Leading whitespace is ignored. @@ -6426,7 +6426,7 @@ double TQString::toDouble( bool *ok ) const For information on how string-to-number functions in TQString handle localized input, see toDouble(). - \warning If the string tqcontains trailing whitespace this function + \warning If the string contains trailing whitespace this function will fail, settings \a *ok to false if \a ok is not 0. Leading whitespace is ignored. @@ -6975,7 +6975,7 @@ TQString &TQString::operator+=( char c ) /*! Returns a Latin-1 representation of the string. The - returned value is undefined if the string tqcontains non-Latin-1 + returned value is undefined if the string contains non-Latin-1 characters. If you want to convert strings into formats other than Unicode, see the TQTextCodec classes. diff --git a/tqtinterface/qt4/src/tools/tqstring.h b/tqtinterface/qt4/src/tools/tqstring.h index 91ceb9d..c82af1f 100644 --- a/tqtinterface/qt4/src/tools/tqstring.h +++ b/tqtinterface/qt4/src/tools/tqstring.h @@ -89,7 +89,7 @@ public: ByteOrderSwapped = ByteOrderSwapped, // null = Null, -// tqreplacement = ReplacementCharacter, +// replacement = ReplacementCharacter, // byteOrderMark = ByteOrderMark, // byteOrderSwapped = ByteOrderSwapped, // nbsp = Nbsp, @@ -99,7 +99,7 @@ public: }; TQT_STATIC_CONST TQChar null; - TQT_STATIC_CONST TQChar tqreplacement; + TQT_STATIC_CONST TQChar replacement; TQT_STATIC_CONST TQChar byteOrderMark; TQT_STATIC_CONST TQChar byteOrderSwapped; TQT_STATIC_CONST TQChar nbsp; @@ -169,23 +169,23 @@ public: TQString( const std::string &str ) : QString(str.c_str()) {} #endif - int tqfind( QChar c, int index=0, bool cs=TRUE ) const { return indexOf(c, index, (Qt::CaseSensitivity)cs); } - int tqfind( char c, int index=0, bool cs=TRUE ) const { return indexOf(c, index, (Qt::CaseSensitivity)cs); } - int tqfind( const QString &str, int index=0, bool cs=TRUE ) const { return indexOf(str, index, (Qt::CaseSensitivity)cs); } + int find( QChar c, int index=0, bool cs=TRUE ) const { return indexOf(c, index, (Qt::CaseSensitivity)cs); } + int find( char c, int index=0, bool cs=TRUE ) const { return indexOf(c, index, (Qt::CaseSensitivity)cs); } + int find( const QString &str, int index=0, bool cs=TRUE ) const { return indexOf(str, index, (Qt::CaseSensitivity)cs); } #ifndef TQT_NO_REGEXP - int tqfind( const QRegExp &qr, int index=0 ) const { return indexOf(qr, index); } + int find( const QRegExp &qr, int index=0 ) const { return indexOf(qr, index); } #endif #ifndef TQT_NO_CAST_ASCII - int tqfind( const char* str, int index=0 ) const { return indexOf(str, index); } + int find( const char* str, int index=0 ) const { return indexOf(str, index); } #endif - int tqfindRev( QChar c, int index=-1, bool cs=TRUE) const { return lastIndexOf(c, index, (Qt::CaseSensitivity)cs); } - int tqfindRev( char c, int index=-1, bool cs=TRUE) const { return lastIndexOf(c, index, (Qt::CaseSensitivity)cs); } - int tqfindRev( const QString &str, int index=-1, bool cs=TRUE) const { return lastIndexOf(str, index, (Qt::CaseSensitivity)cs); } + int findRev( QChar c, int index=-1, bool cs=TRUE) const { return lastIndexOf(c, index, (Qt::CaseSensitivity)cs); } + int findRev( char c, int index=-1, bool cs=TRUE) const { return lastIndexOf(c, index, (Qt::CaseSensitivity)cs); } + int findRev( const QString &str, int index=-1, bool cs=TRUE) const { return lastIndexOf(str, index, (Qt::CaseSensitivity)cs); } #ifndef TQT_NO_REGEXP - int tqfindRev( const QRegExp &qr, int index=-1 ) const { return lastIndexOf(qr, index); } + int findRev( const QRegExp &qr, int index=-1 ) const { return lastIndexOf(qr, index); } #endif #ifndef TQT_NO_CAST_ASCII - int tqfindRev( const char* str, int index=-1 ) const { return lastIndexOf(str, index); } + int findRev( const char* str, int index=-1 ) const { return lastIndexOf(str, index); } #endif const char* latin1() const { return latin1_helper(); } @@ -209,53 +209,53 @@ public: inline TQString(const Null &) : QString() {} inline TQString &operator=(const Null &) { *this = TQString(); return *this; } - int tqcontains( QChar c, bool cs=TRUE ) const { return count(c, (Qt::CaseSensitivity)cs); } - int tqcontains( char c, bool cs=TRUE ) const { return tqcontains(TQChar(c), cs); } + int contains( QChar c, bool cs=TRUE ) const { return count(c, (Qt::CaseSensitivity)cs); } + int contains( char c, bool cs=TRUE ) const { return contains(TQChar(c), cs); } #ifndef TQT_NO_CAST_ASCII - int tqcontains( const char* str, bool cs=TRUE ) const { return count(str, (Qt::CaseSensitivity)cs); } + int contains( const char* str, bool cs=TRUE ) const { return count(str, (Qt::CaseSensitivity)cs); } #endif - int tqcontains( const QString &str, bool cs=TRUE ) const { return count(str, (Qt::CaseSensitivity)cs); } + int contains( const QString &str, bool cs=TRUE ) const { return count(str, (Qt::CaseSensitivity)cs); } #ifndef TQT_NO_REGEXP - int tqcontains( const QRegExp &re ) const { return count(re); } + int contains( const QRegExp &re ) const { return count(re); } #endif #ifndef QT_NO_CAST_TO_ASCII inline operator const char *() const { return ascii_helper(); } #endif - inline bool tqstartsWith( const TQString& str ) const { return startsWith(str); } - inline bool tqstartsWith( const TQString& str, bool cs ) const { return startsWith(str, (cs)?Qt::CaseSensitive:Qt::CaseInsensitive); } - inline bool tqendsWith( const TQString& str ) const { return endsWith(str); } - inline bool tqendsWith( const TQString& str, bool cs ) const { return endsWith(str, (cs)?Qt::CaseSensitive:Qt::CaseInsensitive); } + inline bool tqstartsWith( const TQString& str ) const { return QString::startsWith(str); } + inline bool tqstartsWith( const TQString& str, bool cs ) const { return QString::startsWith(str, (cs)?Qt::CaseSensitive:Qt::CaseInsensitive); } + inline bool tqendsWith( const TQString& str ) const { return QString::endsWith(str); } + inline bool tqendsWith( const TQString& str, bool cs ) const { return QString::endsWith(str, (cs)?Qt::CaseSensitive:Qt::CaseInsensitive); } TQCString utf8() const; inline TQChar constref(uint i) const { return tqat(i); } - inline TQString leftJustify(int width, QChar aFill = QLatin1Char(' '), bool trunc=false) const { return leftJustified(width, aFill, trunc); } - inline TQString rightJustify(int width, QChar aFill = QLatin1Char(' '), bool trunc=false) const { return rightJustified(width, aFill, trunc); } + inline TQString leftJustify(int width, QChar aFill = QLatin1Char(' '), bool trunc=false) const { return QString::leftJustified(width, aFill, trunc); } + inline TQString rightJustify(int width, QChar aFill = QLatin1Char(' '), bool trunc=false) const { return QString::rightJustified(width, aFill, trunc); } inline const TQChar* tqunicode() const { if (length() > 0) return static_cast<const TQChar*>(unicode()); else return static_cast<const TQChar*>(QString().unicode()); } TQCString local8Bit() const; - inline TQString tqreplace(int i, int len, QChar after) { return tqreplace( i, len, &after, 1 ); } - inline TQString tqreplace(int i, int len, const QChar *s, int slen) { + inline TQString replace(int i, int len, QChar after) { return QString::replace( i, len, &after, 1 ); } + inline TQString replace(int i, int len, const QChar *s, int slen) { // Mimic the old (undocumented) behavior int newindex = i; if (newindex > length()) newindex = length(); - return replace( newindex, len, s, slen ); + return QString::replace( newindex, len, s, slen ); } - inline TQString tqreplace(int i, int len, const QString &after) { return tqreplace( i, len, TQString(after).tqunicode(), after.length() ); } - inline TQString tqreplace(QChar before, QChar after, Qt::CaseSensitivity cs = Qt::CaseSensitive) { return replace( before, after, cs ); } - inline TQString tqreplace(const QChar *before, int blen, const QChar *after, int alen, Qt::CaseSensitivity cs = Qt::CaseSensitive) { return replace( before, blen, after, alen, cs ); } - inline TQString tqreplace(const QLatin1String &before, const QLatin1String &after, Qt::CaseSensitivity cs = Qt::CaseSensitive) { return replace( before, after, cs ); } - inline TQString tqreplace(const QLatin1String &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive) { return replace( before, after, cs ); } - inline TQString tqreplace(const QString &before, const QLatin1String &after, Qt::CaseSensitivity cs = Qt::CaseSensitive) { return replace( before, after, cs ); } - inline TQString tqreplace(const QString &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive) { return replace( before, after, cs ); } - inline TQString tqreplace(QChar c, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive) { return replace( c, after, cs ); } - inline TQString tqreplace(QChar c, const QLatin1String &after, Qt::CaseSensitivity cs = Qt::CaseSensitive) { return replace( c, after, cs ); } + inline TQString replace(int i, int len, const QString &after) { return QString::replace( i, len, TQString(after).tqunicode(), after.length() ); } + inline TQString replace(QChar before, QChar after, Qt::CaseSensitivity cs = Qt::CaseSensitive) { return QString::replace( before, after, cs ); } + inline TQString replace(const QChar *before, int blen, const QChar *after, int alen, Qt::CaseSensitivity cs = Qt::CaseSensitive) { return QString::replace( before, blen, after, alen, cs ); } + inline TQString replace(const QLatin1String &before, const QLatin1String &after, Qt::CaseSensitivity cs = Qt::CaseSensitive) { return QString::replace( before, after, cs ); } + inline TQString replace(const QLatin1String &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive) { return QString::replace( before, after, cs ); } + inline TQString replace(const QString &before, const QLatin1String &after, Qt::CaseSensitivity cs = Qt::CaseSensitive) { return QString::replace( before, after, cs ); } + inline TQString replace(const QString &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive) { return QString::replace( before, after, cs ); } + inline TQString replace(QChar c, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive) { return QString::replace( c, after, cs ); } + inline TQString replace(QChar c, const QLatin1String &after, Qt::CaseSensitivity cs = Qt::CaseSensitive) { return QString::replace( c, after, cs ); } #ifndef QT_NO_REGEXP - inline TQString tqreplace(const QRegExp &rx, const QString &after) { return replace( rx, after ); } + inline TQString replace(const QRegExp &rx, const QString &after) { return QString::replace( rx, after ); } #endif - inline TQString tqreplace(const QString &before, const QString &after, bool cs) { return tqreplace(before, after, cs?Qt::CaseSensitive:Qt::CaseInsensitive); } + inline TQString replace(const QString &before, const QString &after, bool cs) { return QString::replace(before, after, cs?Qt::CaseSensitive:Qt::CaseInsensitive); } inline TQString tqsetNum( short a, int base=10 ) { return setNum(a, base); } inline TQString tqsetNum( ushort a, int base=10 ) { return setNum(a, base); } @@ -440,7 +440,7 @@ inline bool operator!=(const TQString &s, TQString::Null) { return !s.isNull(); #ifndef TQT_NO_CAST_ASCII inline TQString &TQString::operator+=( const TQByteArray &s ) { - int pos = s.tqfind( 0 ); + int pos = s.find( 0 ); return operatorPlusEqHelper( s, pos==-1 ? s.size() : pos ); } #endif @@ -646,7 +646,7 @@ public: TQChar( int rc ); TQT_STATIC_CONST TQChar null; // 0000 - TQT_STATIC_CONST TQChar tqreplacement; // FFFD + TQT_STATIC_CONST TQChar replacement; // FFFD TQT_STATIC_CONST TQChar byteOrderMark; // FEFF TQT_STATIC_CONST TQChar byteOrderSwapped; // FFFE TQT_STATIC_CONST TQChar nbsp; // 00A0 @@ -1027,33 +1027,33 @@ public: ; #endif - int tqfind( TQChar c, int index=0, bool cs=TRUE ) const; - int tqfind( char c, int index=0, bool cs=TRUE ) const; - int tqfind( const TQString &str, int index=0, bool cs=TRUE ) const; + int find( TQChar c, int index=0, bool cs=TRUE ) const; + int find( char c, int index=0, bool cs=TRUE ) const; + int find( const TQString &str, int index=0, bool cs=TRUE ) const; #ifndef TQT_NO_REGEXP - int tqfind( const TQRegExp &, int index=0 ) const; + int find( const TQRegExp &, int index=0 ) const; #endif #ifndef TQT_NO_CAST_ASCII - int tqfind( const char* str, int index=0 ) const; + int find( const char* str, int index=0 ) const; #endif - int tqfindRev( TQChar c, int index=-1, bool cs=TRUE) const; - int tqfindRev( char c, int index=-1, bool cs=TRUE) const; - int tqfindRev( const TQString &str, int index=-1, bool cs=TRUE) const; + int findRev( TQChar c, int index=-1, bool cs=TRUE) const; + int findRev( char c, int index=-1, bool cs=TRUE) const; + int findRev( const TQString &str, int index=-1, bool cs=TRUE) const; #ifndef TQT_NO_REGEXP - int tqfindRev( const TQRegExp &, int index=-1 ) const; + int findRev( const TQRegExp &, int index=-1 ) const; #endif #ifndef TQT_NO_CAST_ASCII - int tqfindRev( const char* str, int index=-1 ) const; + int findRev( const char* str, int index=-1 ) const; #endif - int tqcontains( TQChar c, bool cs=TRUE ) const; - int tqcontains( char c, bool cs=TRUE ) const - { return tqcontains(TQChar(c), cs); } + int contains( TQChar c, bool cs=TRUE ) const; + int contains( char c, bool cs=TRUE ) const + { return contains(TQChar(c), cs); } #ifndef TQT_NO_CAST_ASCII - int tqcontains( const char* str, bool cs=TRUE ) const; + int contains( const char* str, bool cs=TRUE ) const; #endif - int tqcontains( const TQString &str, bool cs=TRUE ) const; + int contains( const TQString &str, bool cs=TRUE ) const; #ifndef TQT_NO_REGEXP - int tqcontains( const TQRegExp & ) const; + int contains( const TQRegExp & ) const; #endif enum SectionFlags { @@ -1131,35 +1131,35 @@ public: #ifndef TQT_NO_REGEXP TQString &remove( const TQRegExp & ); #endif - TQString &tqreplace( uint index, uint len, const TQString & ); - TQString &tqreplace( uint index, uint len, const TQChar*, uint clen ); - TQString &tqreplace( uint index, uint len, TQChar ); - TQString &tqreplace( uint index, uint len, char c ) - { return tqreplace( index, len, TQChar(c) ); } + TQString &replace( uint index, uint len, const TQString & ); + TQString &replace( uint index, uint len, const TQChar*, uint clen ); + TQString &replace( uint index, uint len, TQChar ); + TQString &replace( uint index, uint len, char c ) + { return replace( index, len, TQChar(c) ); } #if defined(TQ_TQDOC) - TQString &tqreplace( TQChar c, const TQString & after, bool cs = TRUE ); - TQString &tqreplace( char c, const TQString & after, bool cs = TRUE ); - TQString &tqreplace( const TQString & before, const TQString & after, + TQString &replace( TQChar c, const TQString & after, bool cs = TRUE ); + TQString &replace( char c, const TQString & after, bool cs = TRUE ); + TQString &replace( const TQString & before, const TQString & after, bool cs = TRUE ); #else // ### TQt 4.0: merge these two into one, and remove TQ_TQDOC hack - TQString &tqreplace( TQChar c, const TQString & ); - TQString &tqreplace( TQChar c, const TQString &, bool ); + TQString &replace( TQChar c, const TQString & ); + TQString &replace( TQChar c, const TQString &, bool ); // ### TQt 4.0: merge these two into one, and remove TQ_TQDOC hack - TQString &tqreplace( char c, const TQString & after ) - { return tqreplace( TQChar(c), after, TRUE ); } - TQString &tqreplace( char c, const TQString & after, bool cs ) - { return tqreplace( TQChar(c), after, cs ); } + TQString &replace( char c, const TQString & after ) + { return replace( TQChar(c), after, TRUE ); } + TQString &replace( char c, const TQString & after, bool cs ) + { return replace( TQChar(c), after, cs ); } // ### TQt 4.0: merge these two into one, and remove TQ_TQDOC hack - TQString &tqreplace( const TQString &, const TQString & ); - TQString &tqreplace( const TQString &, const TQString &, bool ); + TQString &replace( const TQString &, const TQString & ); + TQString &replace( const TQString &, const TQString &, bool ); #endif #ifndef TQT_NO_REGEXP_CAPTURE - TQString &tqreplace( const TQRegExp &, const TQString & ); + TQString &replace( const TQRegExp &, const TQString & ); #endif - TQString &tqreplace( TQChar, TQChar ); + TQString &replace( TQChar, TQChar ); short toShort( bool *ok=0, int base=10 ) const; ushort toUShort( bool *ok=0, int base=10 ) const; @@ -1464,7 +1464,7 @@ inline TQString &TQString::insert( uint index, const char *s ) inline TQString &TQString::insert( uint index, const TQByteArray &s ) { - int pos = s.tqfind( 0 ); + int pos = s.find( 0 ); return insertHelper( index, s, pos==-1 ? s.size() : pos ); } #endif @@ -1486,7 +1486,7 @@ inline TQString &TQString::prepend( const TQByteArray & s ) #ifndef TQT_NO_CAST_ASCII inline TQString &TQString::operator+=( const TQByteArray &s ) { - int pos = s.tqfind( 0 ); + int pos = s.find( 0 ); return operatorPlusEqHelper( s, pos==-1 ? s.size() : pos ); } #endif @@ -1562,18 +1562,18 @@ inline TQString TQString::arg( const TQString& a1, const TQString& a2, return multiArg( 4, a1, a2, a3, a4 ); } -inline int TQString::tqfind( char c, int index, bool cs ) const -{ return tqfind(TQChar(c), index, cs); } +inline int TQString::find( char c, int index, bool cs ) const +{ return find(TQChar(c), index, cs); } -inline int TQString::tqfindRev( char c, int index, bool cs ) const -{ return tqfindRev( TQChar(c), index, cs ); } +inline int TQString::findRev( char c, int index, bool cs ) const +{ return findRev( TQChar(c), index, cs ); } #ifndef TQT_NO_CAST_ASCII -inline int TQString::tqfind( const char* str, int index ) const -{ return tqfind(TQString::fromAscii(str), index); } +inline int TQString::find( const char* str, int index ) const +{ return find(TQString::fromAscii(str), index); } -inline int TQString::tqfindRev( const char* str, int index ) const -{ return tqfindRev(TQString::fromAscii(str), index); } +inline int TQString::findRev( const char* str, int index ) const +{ return findRev(TQString::fromAscii(str), index); } #endif diff --git a/tqtinterface/qt4/src/tools/tqstringlist.cpp b/tqtinterface/qt4/src/tools/tqstringlist.cpp index 6a10959..502b5dc 100644 --- a/tqtinterface/qt4/src/tools/tqstringlist.cpp +++ b/tqtinterface/qt4/src/tools/tqstringlist.cpp @@ -105,7 +105,7 @@ \endcode You can sort the list with sort(), and extract a new list which - tqcontains only those strings which contain a particular substring + contains only those strings which contain a particular substring (or match a particular regular expression) using the grep() functions, e.g. \code @@ -230,7 +230,7 @@ TQStringList TQStringList::split( const TQString &sep, const TQString &str, TQStringList lst; int j = 0; - int i = str.tqfind( sep, j ); + int i = str.find( sep, j ); while ( i != -1 ) { if ( i > j && i <= (int)str.length() ) @@ -238,7 +238,7 @@ TQStringList TQStringList::split( const TQString &sep, const TQString &str, else if ( allowEmptyEntries ) lst << TQString::null; j = i + sep.length(); - i = str.tqfind( sep, sep.length() > 0 ? j : j+1 ); + i = str.find( sep, sep.length() > 0 ? j : j+1 ); } int l = str.length() - 1; @@ -316,14 +316,14 @@ TQStringList TQStringList::split( const TQRegExp &sep, const TQString &str, // list == ["Bill Gates", "Bill Clinton"] \endcode - \sa TQString::tqfind() + \sa TQString::find() */ TQStringList TQStringList::grep( const TQString &str, bool cs ) const { TQStringList res; for ( TQStringList::ConstIterator it = begin(); it != end(); ++it ) - if ( (*it).tqcontains(str, cs) ) + if ( (*it).contains(str, cs) ) res << *it; return res; @@ -336,14 +336,14 @@ TQStringList TQStringList::grep( const TQString &str, bool cs ) const Returns a list of all the strings that match the regular expression \a rx. - \sa TQString::tqfind() + \sa TQString::find() */ TQStringList TQStringList::grep( const TQRegExp &rx ) const { TQStringList res; for ( TQStringList::ConstIterator it = begin(); it != end(); ++it ) - if ( (*it).tqfind(rx) != -1 ) + if ( (*it).find(rx) != -1 ) res << *it; return res; @@ -366,14 +366,14 @@ TQStringList TQStringList::grep( const TQRegExp &rx ) const // list == ["olpho", "beto", "gommo", "epsilon"] \endcode - \sa TQString::tqreplace() + \sa TQString::replace() */ TQStringList& TQStringList::gres( const TQString &before, const TQString &after, bool cs ) { TQStringList::Iterator it = begin(); while ( it != end() ) { - (*it).tqreplace( before, after, cs ); + (*it).replace( before, after, cs ); ++it; } return *this; @@ -396,7 +396,7 @@ TQStringList& TQStringList::gres( const TQString &before, const TQString &after, For regexps containing \link tqregexp.html#capturing-text capturing parentheses \endlink, occurrences of <b>\\1</b>, - <b>\\2</b>, ..., in \a after are tqreplaced with \a{rx}.cap(1), + <b>\\2</b>, ..., in \a after are replaced with \a{rx}.cap(1), cap(2), ... Example: @@ -407,13 +407,13 @@ TQStringList& TQStringList::gres( const TQString &before, const TQString &after, // list == ["Bill Clinton", "Bill Gates"] \endcode - \sa TQString::tqreplace() + \sa TQString::replace() */ TQStringList& TQStringList::gres( const TQRegExp &rx, const TQString &after ) { TQStringList::Iterator it = begin(); while ( it != end() ) { - (*it).tqreplace( rx, after ); + (*it).replace( rx, after ); ++it; } return *this; diff --git a/tqtinterface/qt4/src/tools/tqtextstream.cpp b/tqtinterface/qt4/src/tools/tqtextstream.cpp index 842cb7e..1225f7b 100644 --- a/tqtinterface/qt4/src/tools/tqtextstream.cpp +++ b/tqtinterface/qt4/src/tools/tqtextstream.cpp @@ -150,7 +150,7 @@ \endcode The setprecision() function returns a TQTSManip object. - The TQTSManip object tqcontains a pointer to a member function in + The TQTSManip object contains a pointer to a member function in TQTextStream and an integer argument. When serializing a TQTSManip into a TQTextStream, the function is executed with the argument. @@ -480,7 +480,7 @@ TQ_LONG TQStringBuffer::writeBlock( const char *p, TQ_ULONG len ) return -1; } #endif - s->tqreplace(pos()/2, len/2, (TQChar*)p, len/2); + s->replace(pos()/2, len/2, (TQChar*)p, len/2); seek(pos()+len); return len; } diff --git a/tqtinterface/qt4/src/tools/tqunicodetables.cpp b/tqtinterface/qt4/src/tools/tqunicodetables.cpp index 750dcd5..df592c8 100644 --- a/tqtinterface/qt4/src/tools/tqunicodetables.cpp +++ b/tqtinterface/qt4/src/tools/tqunicodetables.cpp @@ -315,7 +315,7 @@ for $lig_row ( 0..255 ) { # we need to sort ligatures according to their length. # long ones have to come first! @ligature_sort = sort { $decomposition_len{$b} <=> $decomposition_len{$a} } @ligature; -# now tqreplace each code by its position in +# now replace each code by its position in # the decomposition map. undef(@lig_pos); for $n (@ligature_sort) { diff --git a/tqtinterface/qt4/src/tools/tqvaluelist.h b/tqtinterface/qt4/src/tools/tqvaluelist.h index 799473a..0928f38 100644 --- a/tqtinterface/qt4/src/tools/tqvaluelist.h +++ b/tqtinterface/qt4/src/tools/tqvaluelist.h @@ -247,9 +247,9 @@ public: Iterator insert( Iterator it, const T& x ); Iterator remove( Iterator it ); - NodePtr tqfind( NodePtr start, const T& x ) const; - int tqfindIndex( NodePtr start, const T& x ) const; - uint tqcontains( const T& x ) const; + NodePtr find( NodePtr start, const T& x ) const; + int findIndex( NodePtr start, const T& x ) const; + uint contains( const T& x ) const; uint remove( const T& x ); NodePtr at( size_type i ) const; void clear(); @@ -313,7 +313,7 @@ TQ_INLINE_TEMPLATES TQ_TYPENAME TQValueListPrivate<T>::Iterator TQValueListPriva } template <class T> -TQ_INLINE_TEMPLATES TQ_TYPENAME TQValueListPrivate<T>::NodePtr TQValueListPrivate<T>::tqfind( TQ_TYPENAME TQValueListPrivate<T>::NodePtr start, const T& x ) const +TQ_INLINE_TEMPLATES TQ_TYPENAME TQValueListPrivate<T>::NodePtr TQValueListPrivate<T>::find( TQ_TYPENAME TQValueListPrivate<T>::NodePtr start, const T& x ) const { ConstIterator first( start ); ConstIterator last( node ); @@ -326,7 +326,7 @@ TQ_INLINE_TEMPLATES TQ_TYPENAME TQValueListPrivate<T>::NodePtr TQValueListPrivat } template <class T> -TQ_INLINE_TEMPLATES int TQValueListPrivate<T>::tqfindIndex( TQ_TYPENAME TQValueListPrivate<T>::NodePtr start, const T& x ) const +TQ_INLINE_TEMPLATES int TQValueListPrivate<T>::findIndex( TQ_TYPENAME TQValueListPrivate<T>::NodePtr start, const T& x ) const { ConstIterator first( start ); ConstIterator last( node ); @@ -341,7 +341,7 @@ TQ_INLINE_TEMPLATES int TQValueListPrivate<T>::tqfindIndex( TQ_TYPENAME TQValueL } template <class T> -TQ_INLINE_TEMPLATES uint TQValueListPrivate<T>::tqcontains( const T& x ) const +TQ_INLINE_TEMPLATES uint TQValueListPrivate<T>::contains( const T& x ) const { uint result = 0; Iterator first = Iterator( node->next ); @@ -543,12 +543,12 @@ public: const_iterator at( size_type i ) const { TQT_CHECK_INVALID_LIST_ELEMENT; return const_iterator( sh->at(i) ); } iterator tqat( size_type i ) { TQT_CHECK_INVALID_LIST_ELEMENT; detach(); return iterator( sh->at(i) ); } const_iterator tqat( size_type i ) const { TQT_CHECK_INVALID_LIST_ELEMENT; return const_iterator( sh->at(i) ); } - iterator tqfind ( const T& x ) { detach(); return iterator( sh->tqfind( sh->node->next, x) ); } - const_iterator tqfind ( const T& x ) const { return const_iterator( sh->tqfind( sh->node->next, x) ); } - iterator tqfind ( iterator it, const T& x ) { detach(); return iterator( sh->tqfind( it.node, x ) ); } - const_iterator tqfind ( const_iterator it, const T& x ) const { return const_iterator( sh->tqfind( it.node, x ) ); } - int tqfindIndex( const T& x ) const { return sh->tqfindIndex( sh->node->next, x) ; } - size_type tqcontains( const T& x ) const { return sh->tqcontains( x ); } + iterator find ( const T& x ) { detach(); return iterator( sh->find( sh->node->next, x) ); } + const_iterator find ( const T& x ) const { return const_iterator( sh->find( sh->node->next, x) ); } + iterator find ( iterator it, const T& x ) { detach(); return iterator( sh->find( it.node, x ) ); } + const_iterator find ( const_iterator it, const T& x ) const { return const_iterator( sh->find( it.node, x ) ); } + int findIndex( const T& x ) const { return sh->findIndex( sh->node->next, x) ; } + size_type contains( const T& x ) const { return sh->contains( x ); } size_type count() const { return sh->nodes; } |