| -rw-r--r-- | qmake/tools/qstringlist.cpp | 376 |
1 files changed, 376 insertions, 0 deletions
diff --git a/qmake/tools/qstringlist.cpp b/qmake/tools/qstringlist.cpp new file mode 100644 index 0000000..0720e7f --- a/dev/null +++ b/qmake/tools/qstringlist.cpp @@ -0,0 +1,376 @@ +/**************************************************************************** +** $Id$ +** +** Implementation of QStringList +** +** Created : 990406 +** +** Copyright (C) 1992-2000 Trolltech AS. All rights reserved. +** +** This file is part of the tools module of the Qt GUI Toolkit. +** +** This file may be distributed under the terms of the Q Public License +** as defined by Trolltech AS of Norway and appearing in the file +** LICENSE.QPL included in the packaging of this file. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition +** licenses may use this file in accordance with the Qt Commercial License +** Agreement provided with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about Qt Commercial License Agreements. +** See http://www.trolltech.com/qpl/ for QPL licensing information. +** See http://www.trolltech.com/gpl/ for GPL licensing information. +** +** Contact info@trolltech.com if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +#include "qstringlist.h" + +#ifndef QT_NO_STRINGLIST +#include "qregexp.h" +#include "qstrlist.h" +#include "qdatastream.h" +#include "qtl.h" + +/*! + \class QStringList qstringlist.h + \reentrant + \brief The QStringList class provides a list of strings. + + \ingroup tools + \ingroup shared + \ingroup text + \mainclass + + It is used to store and manipulate strings that logically belong + together. Essentially QStringList is a QValueList of QString + objects. Unlike QStrList, which stores pointers to characters, + QStringList holds real QString objects. It is the class of choice + whenever you work with Unicode strings. QStringList is part of the + \link qtl.html Qt Template Library\endlink. + + Like QString itself, QStringList objects are implicitly shared. + Passing them around as value-parameters is both fast and safe. + + Strings can be added to a list using append(), operator+=() or + operator<<(), e.g. + \code + QStringList fonts; + fonts.append( "Times" ); + fonts += "Courier"; + fonts += "Courier New"; + fonts << "Helvetica [Cronyx]" << "Helvetica [Adobe]"; + \endcode + + String lists have an iterator, QStringList::Iterator(), e.g. + \code + for ( QStringList::Iterator it = fonts.begin(); it != fonts.end(); ++it ) { + cout << *it << ":"; + } + cout << endl; + // Output: + // Times:Courier:Courier New:Helvetica [Cronyx]:Helvetica [Adobe]: + \endcode + + Many Qt functions return const string lists; to iterate over these + you should make a copy and iterate over the copy. + + You can concatenate all the strings in a string list into a single + string (with an optional separator) using join(), e.g. + \code + QString allFonts = fonts.join( ", " ); + cout << allFonts << endl; + // Output: + // Times, Courier, Courier New, Helvetica [Cronyx], Helvetica [Adobe] + \endcode + + You can sort the list with sort(), and extract a new list which + contains only those strings which contain a particular substring + (or match a particular regular expression) using the grep() + functions, e.g. + \code + fonts.sort(); + cout << fonts.join( ", " ) << endl; + // Output: + // Courier, Courier New, Helvetica [Adobe], Helvetica [Cronyx], Times + + QStringList helveticas = fonts.grep( "Helvetica" ); + cout << helveticas.join( ", " ) << endl; + // Output: + // Helvetica [Adobe], Helvetica [Cronyx] + \endcode + + Existing strings can be split into string lists with character, + string or regular expression separators, e.g. + \code + QString s = "Red\tGreen\tBlue"; + QStringList colors = QStringList::split( "\t", s ); + cout << colors.join( ", " ) << endl; + // Output: + // Red, Green, Blue + \endcode +*/ + +/*! + \fn QStringList::QStringList() + + Creates an empty string list. +*/ + +/*! + \fn QStringList::QStringList( const QStringList& l ) + + Creates a copy of the list \a l. This function is very fast + because QStringList is implicitly shared. In most situations this + acts like a deep copy, for example, if this list or the original + one or some other list referencing the same shared data is + modified, the modifying list first makes a copy, i.e. + copy-on-write. + In a threaded environment you may require a real deep copy + \omit see \l QDeepCopy\endomit. +*/ + +/*! + \fn QStringList::QStringList (const QString & i) + + Constructs a string list consisting of the single string \a i. + Longer lists are easily created as follows: + + \code + QStringList items; + items << "Buy" << "Sell" << "Update" << "Value"; + \endcode +*/ + +/*! + \fn QStringList::QStringList (const char* i) + + Constructs a string list consisting of the single latin-1 string \a i. +*/ + +/*! + \fn QStringList::QStringList( const QValueList<QString>& l ) + + Constructs a new string list that is a copy of \a l. +*/ + +/*! + Sorts the list of strings in ascending case-sensitive order. + + Sorting is very fast. It uses the \link qtl.html Qt Template + Library's\endlink efficient HeapSort implementation that has a + time complexity of O(n*log n). + + If you want to sort your strings in an arbitrary order consider + using a QMap. For example you could use a QMap\<QString,QString\> + to create a case-insensitive ordering (e.g. mapping the lowercase + text to the text), or a QMap\<int,QString\> to sort the strings by + some integer index, etc. +*/ +void QStringList::sort() +{ + qHeapSort( *this ); +} + +/*! + \overload + + This version of the function uses a QChar as separator, rather + than a regular expression. + + \sa join() QString::section() +*/ + +QStringList QStringList::split( const QChar &sep, const QString &str, + bool allowEmptyEntries ) +{ + return split( QString(sep), str, allowEmptyEntries ); +} + +/*! + \overload + + This version of the function uses a QString as separator, rather + than a regular expression. + + If \a sep is an empty string, the return value is a list of + one-character strings: split( QString( "" ), "four" ) returns the + four-item list, "f", "o", "u", "r". + + If \a allowEmptyEntries is TRUE, an empty string is inserted in + the list wherever the separator matches twice without intervening + text. + + \sa join() QString::section() +*/ + +QStringList QStringList::split( const QString &sep, const QString &str, + bool allowEmptyEntries ) +{ + QStringList lst; + + int j = 0; + int i = str.find( sep, j ); + + while ( i != -1 ) { + if ( i > j && i <= (int)str.length() ) + lst << str.mid( j, i - j ); + else if ( allowEmptyEntries ) + lst << QString::null; + j = i + sep.length(); + i = str.find( sep, sep.length() > 0 ? j : j+1 ); + } + + int l = str.length() - 1; + if ( str.mid( j, l - j + 1 ).length() > 0 ) + lst << str.mid( j, l - j + 1 ); + else if ( allowEmptyEntries ) + lst << QString::null; + + return lst; +} + +#ifndef QT_NO_REGEXP +/*! + Splits the string \a str into strings wherever the regular + expression \a sep occurs, and returns the list of those strings. + + If \a allowEmptyEntries is TRUE, an empty string is inserted in + the list wherever the separator matches twice without intervening + text. + + For example, if you split the string "a,,b,c" on commas, split() + returns the three-item list "a", "b", "c" if \a allowEmptyEntries + is FALSE (the default), and the four-item list "a", "", "b", "c" + if \a allowEmptyEntries is TRUE. + + If \a sep does not match anywhere in \a str, split() returns a + list consisting of the single string \a str. + + \sa join() QString::section() +*/ + +QStringList QStringList::split( const QRegExp &sep, const QString &str, + bool allowEmptyEntries ) +{ + QStringList lst; + + QRegExp tep = sep; + + int j = 0; + int i = tep.search( str, j ); + + while ( i != -1 ) { + if ( str.mid( j, i - j ).length() > 0 ) + lst << str.mid( j, i - j ); + else if ( allowEmptyEntries ) + lst << QString::null; + if ( tep.matchedLength() == 0 ) + j = i + 1; + else + j = i + tep.matchedLength(); + i = tep.search( str, j ); + } + + int l = str.length() - 1; + if ( str.mid( j, l - j + 1 ).length() > 0 ) + lst << str.mid( j, l - j + 1 ); + else if ( allowEmptyEntries ) + lst << QString::null; + + return lst; +} +#endif + +/*! + Returns a list of all strings containing the substring \a str. + + If \a cs is TRUE, the grep is done case-sensitively; otherwise + case is ignored. +*/ + +QStringList QStringList::grep( const QString &str, bool cs ) const +{ + QStringList res; + for ( QStringList::ConstIterator it = begin(); it != end(); ++it ) + if ( (*it).contains(str, cs) ) + res << *it; + + return res; +} + +#ifndef QT_NO_REGEXP +/*! + \overload + + Returns a list of all the strings that match the regular + expression \a expr. +*/ + +QStringList QStringList::grep( const QRegExp &expr ) const +{ + QStringList res; + for ( QStringList::ConstIterator it = begin(); it != end(); ++it ) + if ( (*it).contains(expr) ) + res << *it; + + return res; +} +#endif + +/*! + Joins the string list into a single string with each element + separated by the string \a sep (which can be empty). + + \sa split() +*/ +QString QStringList::join( const QString &sep ) const +{ + QString res; + bool alredy = FALSE; + for ( QStringList::ConstIterator it = begin(); it != end(); ++it ) { + if ( alredy ) + res += sep; + alredy = TRUE; + res += *it; + } + + return res; +} + +#ifndef QT_NO_DATASTREAM +Q_EXPORT QDataStream &operator>>( QDataStream & s, QStringList& l ) +{ + return s >> (QValueList<QString>&)l; +} + +Q_EXPORT QDataStream &operator<<( QDataStream & s, const QStringList& l ) +{ + return s << (const QValueList<QString>&)l; +} +#endif + +/*! + Converts from an ASCII-QStrList \a ascii to a QStringList (Unicode). +*/ +QStringList QStringList::fromStrList(const QStrList& ascii) +{ + QStringList res; + const char * s; + for ( QStrListIterator it(ascii); (s=it.current()); ++it ) + res << s; + return res; +} + +#endif //QT_NO_STRINGLIST |