Add Qt3 development HEAD version

1 files changed, 761 insertions, 0 deletions

diff --git a/src/kernel/qurlinfo.cpp b/src/kernel/qurlinfo.cpp
new file mode 100644
index 0000000..7c6155a
--- /dev/null
+++ b/src/kernel/qurlinfo.cpp
@@ -0,0 +1,761 @@
+/****************************************************************************
+**
+** Implementation of QUrlInfo class
+**
+** Created : 950429
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the kernel module of the Qt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free Qt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.QPL
+** included in the packaging of this file.  Licensees holding valid Qt
+** Commercial 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 WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "qurlinfo.h"
+
+#ifndef QT_NO_NETWORKPROTOCOL
+
+#include "qurloperator.h"
+#include "qdir.h"
+#include <limits.h>
+
+class QUrlInfoPrivate
+{
+public:
+    QUrlInfoPrivate() :
+	permissions(0),
+	size(0),
+	isDir(FALSE),
+	isFile(TRUE),
+	isSymLink(FALSE),
+	isWritable(TRUE),
+	isReadable(TRUE),
+	isExecutable(FALSE)
+    {}
+
+    QString name;
+    int permissions;
+    QString owner;
+    QString group;
+#if defined(QT_LARGEFILE_SUPPORT)
+    QIODevice::Offset size;
+#else
+    uint size;
+#endif
+    QDateTime lastModified;
+    QDateTime lastRead;
+    bool isDir;
+    bool isFile;
+    bool isSymLink;
+    bool isWritable;
+    bool isReadable;
+    bool isExecutable;
+};
+
+
+/*!
+    \class QUrlInfo qurlinfo.h
+    \brief The QUrlInfo class stores information about URLs.
+
+    \ingroup io
+    \ingroup misc
+
+    This class is just a container for storing information about URLs,
+    which is why all information must be passed in the constructor.
+
+    Unless you're reimplementing a network protocol you're unlikely to
+    create QUrlInfo objects yourself, but you may receive QUrlInfo
+    objects from functions, e.g. QUrlOperator::info().
+
+    The information that can be retrieved includes name(),
+    permissions(), owner(), group(), size(), lastModified(),
+    lastRead(), isDir(), isFile(), isSymLink(), isWritable(),
+    isReadable() and isExecutable().
+*/
+
+/*!
+    \enum QUrlInfo::PermissionSpec
+
+    This enum is used by the permissions() function to report the
+    permissions of a file.
+
+    \value ReadOwner The file is readable by the owner of the file.
+    \value WriteOwner The file is writable by the owner of the file.
+    \value ExeOwner The file is executable by the owner of the file.
+    \value ReadGroup The file is readable by the group.
+    \value WriteGroup The file is writable by the group.
+    \value ExeGroup The file is executable by the group.
+    \value ReadOther The file is readable by anyone.
+    \value WriteOther The file is writable by anyone.
+    \value ExeOther The file is executable by anyone.
+*/
+
+/*!
+    Constructs an invalid QUrlInfo object with default values.
+
+    \sa isValid()
+*/
+
+QUrlInfo::QUrlInfo()
+{
+    d = 0;
+}
+
+/*!
+    Constructs a QUrlInfo object with information about the file \a
+    file in the \a path. It tries to find the information about the \a
+    file in the QUrlOperator \a path.
+
+    If the information is not found, this constructor creates an
+    invalid QUrlInfo, i.e. isValid() returns FALSE. You should always
+    check if the URL info is valid before relying on the return values
+    of any getter functions.
+
+    If \a file is empty, it defaults to the QUrlOperator \a path, i.e.
+    to the directory.
+
+    \sa isValid() QUrlOperator::info()
+*/
+
+QUrlInfo::QUrlInfo( const QUrlOperator &path, const QString &file )
+{
+    QString file_ = file;
+    if ( file_.isEmpty() )
+	file_ = ".";
+
+    QUrlInfo inf = path.info( file_ );
+    if ( inf.d ) {
+	d = new QUrlInfoPrivate;
+	*d = *inf.d;
+    } else {
+	d = 0;
+    }
+}
+
+/*!
+    Copy constructor, copies \a ui to this URL info object.
+*/
+
+QUrlInfo::QUrlInfo( const QUrlInfo &ui )
+{
+    if ( ui.d ) {
+	d = new QUrlInfoPrivate;
+	*d = *ui.d;
+    } else {
+	d = 0;
+    }
+}
+
+/*!
+    Constructs a QUrlInfo object by specifying all the URL's
+    information.
+
+    The information that is passed is the \a name, file \a
+    permissions, \a owner and \a group and the file's \a size. Also
+    passed is the \a lastModified date/time and the \a lastRead
+    date/time. Flags are also passed, specifically, \a isDir, \a
+    isFile, \a isSymLink, \a isWritable, \a isReadable and \a
+    isExecutable.
+*/
+
+#if defined(QT_ABI_QT4)
+QUrlInfo::QUrlInfo( const QString &name, int permissions, const QString &owner,
+		    const QString &group, QIODevice::Offset size, const QDateTime &lastModified,
+		    const QDateTime &lastRead, bool isDir, bool isFile, bool isSymLink,
+		    bool isWritable, bool isReadable, bool isExecutable )
+#else
+QUrlInfo::QUrlInfo( const QString &name, int permissions, const QString &owner,
+		    const QString &group, uint size, const QDateTime &lastModified,
+		    const QDateTime &lastRead, bool isDir, bool isFile, bool isSymLink,
+		    bool isWritable, bool isReadable, bool isExecutable )
+#endif
+{
+    d = new QUrlInfoPrivate;
+    d->name = name;
+    d->permissions = permissions;
+    d->owner = owner;
+    d->group = group;
+    d->size = size;
+    d->lastModified = lastModified;
+    d->lastRead = lastRead;
+    d->isDir = isDir;
+    d->isFile = isFile;
+    d->isSymLink = isSymLink;
+    d->isWritable = isWritable;
+    d->isReadable = isReadable;
+    d->isExecutable = isExecutable;
+}
+
+
+/*!
+    Constructs a QUrlInfo object by specifying all the URL's
+    information.
+
+    The information that is passed is the \a url, file \a
+    permissions, \a owner and \a group and the file's \a size. Also
+    passed is the \a lastModified date/time and the \a lastRead
+    date/time. Flags are also passed, specifically, \a isDir, \a
+    isFile, \a isSymLink, \a isWritable, \a isReadable and \a
+    isExecutable.
+*/
+
+#if defined(QT_ABI_QT4)
+QUrlInfo::QUrlInfo( const QUrl &url, int permissions, const QString &owner,
+		    const QString &group, QIODevice::Offset size, const QDateTime &lastModified,
+		    const QDateTime &lastRead, bool isDir, bool isFile, bool isSymLink,
+		    bool isWritable, bool isReadable, bool isExecutable )
+#else
+QUrlInfo::QUrlInfo( const QUrl &url, int permissions, const QString &owner,
+		    const QString &group, uint size, const QDateTime &lastModified,
+		    const QDateTime &lastRead, bool isDir, bool isFile, bool isSymLink,
+		    bool isWritable, bool isReadable, bool isExecutable )
+#endif
+{
+    d = new QUrlInfoPrivate;
+    d->name = QFileInfo( url.path() ).fileName();
+    d->permissions = permissions;
+    d->owner = owner;
+    d->group = group;
+    d->size = size;
+    d->lastModified = lastModified;
+    d->lastRead = lastRead;
+    d->isDir = isDir;
+    d->isFile = isFile;
+    d->isSymLink = isSymLink;
+    d->isWritable = isWritable;
+    d->isReadable = isReadable;
+    d->isExecutable = isExecutable;
+}
+
+
+/*!
+    Sets the name of the URL to \a name. The name is the full text,
+    for example, "http://doc.trolltech.com/qurlinfo.html".
+
+    If you call this function for an invalid URL info, this function
+    turns it into a valid one.
+
+    \sa isValid()
+*/
+
+void QUrlInfo::setName( const QString &name )
+{
+    if ( !d )
+	d = new QUrlInfoPrivate;
+    d->name = name;
+}
+
+
+/*!
+    If \a b is TRUE then the URL is set to be a directory; if \b is
+    FALSE then the URL is set not to be a directory (which normally
+    means it is a file). (Note that a URL can refer to both a file and
+    a directory even though most file systems do not support this.)
+
+    If you call this function for an invalid URL info, this function
+    turns it into a valid one.
+
+    \sa isValid()
+*/
+
+void QUrlInfo::setDir( bool b )
+{
+    if ( !d )
+	d = new QUrlInfoPrivate;
+    d->isDir = b;
+}
+
+
+/*!
+    If \a b is TRUE then the URL is set to be a file; if \b is FALSE
+    then the URL is set not to be a file (which normally means it is a
+    directory). (Note that a URL can refer to both a file and a
+    directory even though most file systems do not support this.)
+
+    If you call this function for an invalid URL info, this function
+    turns it into a valid one.
+
+    \sa isValid()
+*/
+
+void QUrlInfo::setFile( bool b )
+{
+    if ( !d )
+	d = new QUrlInfoPrivate;
+    d->isFile = b;
+}
+
+
+/*!
+    Specifies that the URL refers to a symbolic link if \a b is TRUE
+    and that it does not if \a b is FALSE.
+
+    If you call this function for an invalid URL info, this function
+    turns it into a valid one.
+
+    \sa isValid()
+*/
+
+void QUrlInfo::setSymLink( bool b )
+{
+    if ( !d )
+	d = new QUrlInfoPrivate;
+    d->isSymLink = b;
+}
+
+
+/*!
+    Specifies that the URL is writable if \a b is TRUE and not
+    writable if \a b is FALSE.
+
+    If you call this function for an invalid URL info, this function
+    turns it into a valid one.
+
+    \sa isValid()
+*/
+
+void QUrlInfo::setWritable( bool b )
+{
+    if ( !d )
+	d = new QUrlInfoPrivate;
+    d->isWritable = b;
+}
+
+
+/*!
+    Specifies that the URL is readable if \a b is TRUE and not
+    readable if \a b is FALSE.
+
+    If you call this function for an invalid URL info, this function
+    turns it into a valid one.
+
+    \sa isValid()
+*/
+
+void QUrlInfo::setReadable( bool b )
+{
+    if ( !d )
+	d = new QUrlInfoPrivate;
+    d->isReadable = b;
+}
+
+/*!
+    Specifies that the owner of the URL is called \a s.
+
+    If you call this function for an invalid URL info, this function
+    turns it into a valid one.
+
+    \sa isValid()
+*/
+
+void QUrlInfo::setOwner( const QString &s )
+{
+    if ( !d )
+	d = new QUrlInfoPrivate;
+    d->owner = s;
+}
+
+/*!
+    Specifies that the owning group of the URL is called \a s.
+
+    If you call this function for an invalid URL info, this function
+    turns it into a valid one.
+
+    \sa isValid()
+*/
+
+void QUrlInfo::setGroup( const QString &s )
+{
+    if ( !d )
+	d = new QUrlInfoPrivate;
+    d->group = s;
+}
+
+/*!
+    Specifies the \a size of the URL.
+
+    If you call this function for an invalid URL info, this function
+    turns it into a valid one.
+
+    \sa isValid()
+*/
+
+#if defined(QT_ABI_QT4)
+void QUrlInfo::setSize( QIODevice::Offset size )
+#else
+void QUrlInfo::setSize( uint size )
+#endif
+{
+    if ( !d )
+	d = new QUrlInfoPrivate;
+    d->size = size;
+}
+
+
+// ### reggie - what's the permission type? As in Unix?
+
+/*!
+    Specifies that the URL has access permisions, \a p.
+
+    If you call this function for an invalid URL info, this function
+    turns it into a valid one.
+
+    \sa isValid()
+*/
+
+void QUrlInfo::setPermissions( int p )
+{
+    if ( !d )
+	d = new QUrlInfoPrivate;
+    d->permissions = p;
+}
+
+/*!
+    Specifies that the object the URL refers to was last modified at
+    \a dt.
+
+    If you call this function for an invalid URL info, this function
+    turns it into a valid one.
+
+    \sa isValid()
+*/
+
+void QUrlInfo::setLastModified( const QDateTime &dt )
+{
+    if ( !d )
+	d = new QUrlInfoPrivate;
+    d->lastModified = dt;
+}
+
+/*!
+    Destroys the URL info object.
+
+    The QUrlOperator object to which this URL referred (if any) is not
+    affected.
+*/
+
+QUrlInfo::~QUrlInfo()
+{
+    delete d;
+}
+
+/*!
+    Assigns the values of \a ui to this QUrlInfo object.
+*/
+
+QUrlInfo &QUrlInfo::operator=( const QUrlInfo &ui )
+{
+    if ( ui.d ) {
+	if ( !d )
+	    d= new QUrlInfoPrivate;
+	*d = *ui.d;
+    } else {
+	delete d;
+	d = 0;
+    }
+    return *this;
+}
+
+/*!
+    Returns the file name of the URL.
+
+    \sa isValid()
+*/
+
+QString QUrlInfo::name() const
+{
+    if ( !d )
+	return QString::null;
+    return d->name;
+}
+
+/*!
+    Returns the permissions of the URL. You can use the \c PermissionSpec flags
+    to test for certain permissions.
+
+    \sa isValid()
+*/
+
+int QUrlInfo::permissions() const
+{
+    if ( !d )
+	return 0;
+    return d->permissions;
+}
+
+/*!
+    Returns the owner of the URL.
+
+    \sa isValid()
+*/
+
+QString QUrlInfo::owner() const
+{
+    if ( !d )
+	return QString::null;
+    return d->owner;
+}
+
+/*!
+    Returns the group of the URL.
+
+    \sa isValid()
+*/
+
+QString QUrlInfo::group() const
+{
+    if ( !d )
+	return QString::null;
+    return d->group;
+}
+
+/*!
+    Returns the size of the URL.
+
+    \sa isValid()
+*/
+
+#if defined(QT_ABI_QT4)
+QIODevice::Offset QUrlInfo::size() const
+#else
+uint QUrlInfo::size() const
+#endif
+{
+    if ( !d )
+	return 0;
+#if defined(QT_LARGEFILE_SUPPORT) && !defined(QT_ABI_QT4)
+    return d->size > UINT_MAX ? UINT_MAX : (uint)d->size;
+#else
+    return d->size;
+#endif
+}
+
+/*!
+    Returns the last modification date of the URL.
+
+    \sa isValid()
+*/
+
+QDateTime QUrlInfo::lastModified() const
+{
+    if ( !d )
+	return QDateTime();
+    return d->lastModified;
+}
+
+/*!
+    Returns the date when the URL was last read.
+
+    \sa isValid()
+*/
+
+QDateTime QUrlInfo::lastRead() const
+{
+    if ( !d )
+	return QDateTime();
+    return d->lastRead;
+}
+
+/*!
+    Returns TRUE if the URL is a directory; otherwise returns FALSE.
+
+    \sa isValid()
+*/
+
+bool QUrlInfo::isDir() const
+{
+    if ( !d )
+	return FALSE;
+    return d->isDir;
+}
+
+/*!
+    Returns TRUE if the URL is a file; otherwise returns FALSE.
+
+    \sa isValid()
+*/
+
+bool QUrlInfo::isFile() const
+{
+    if ( !d )
+	return FALSE;
+    return d->isFile;
+}
+
+/*!
+    Returns TRUE if the URL is a symbolic link; otherwise returns FALSE.
+
+    \sa isValid()
+*/
+
+bool QUrlInfo::isSymLink() const
+{
+    if ( !d )
+	return FALSE;
+    return d->isSymLink;
+}
+
+/*!
+    Returns TRUE if the URL is writable; otherwise returns FALSE.
+
+    \sa isValid()
+*/
+
+bool QUrlInfo::isWritable() const
+{
+    if ( !d )
+	return FALSE;
+    return d->isWritable;
+}
+
+/*!
+    Returns TRUE if the URL is readable; otherwise returns FALSE.
+
+    \sa isValid()
+*/
+
+bool QUrlInfo::isReadable() const
+{
+    if ( !d )
+	return FALSE;
+    return d->isReadable;
+}
+
+/*!
+    Returns TRUE if the URL is executable; otherwise returns FALSE.
+
+    \sa isValid()
+*/
+
+bool QUrlInfo::isExecutable() const
+{
+    if ( !d )
+	return FALSE;
+    return d->isExecutable;
+}
+
+/*!
+    Returns TRUE if \a i1 is greater than \a i2; otherwise returns
+    FALSE. The objects are compared by the value, which is specified
+    by \a sortBy. This must be one of QDir::Name, QDir::Time or
+    QDir::Size.
+*/
+
+bool QUrlInfo::greaterThan( const QUrlInfo &i1, const QUrlInfo &i2,
+			    int sortBy )
+{
+    switch ( sortBy ) {
+    case QDir::Name:
+	return i1.name() > i2.name();
+    case QDir::Time:
+	return i1.lastModified() > i2.lastModified();
+    case QDir::Size:
+	return i1.size() > i2.size();
+    default:
+	return FALSE;
+    }
+}
+
+/*!
+    Returns TRUE if \a i1 is less than \a i2; otherwise returns FALSE.
+    The objects are compared by the value, which is specified by \a
+    sortBy. This must be one of QDir::Name, QDir::Time or QDir::Size.
+*/
+
+bool QUrlInfo::lessThan( const QUrlInfo &i1, const QUrlInfo &i2,
+			 int sortBy )
+{
+    return !greaterThan( i1, i2, sortBy );
+}
+
+/*!
+    Returns TRUE if \a i1 equals to \a i2; otherwise returns FALSE.
+    The objects are compared by the value, which is specified by \a
+    sortBy. This must be one of QDir::Name, QDir::Time or QDir::Size.
+*/
+
+bool QUrlInfo::equal( const QUrlInfo &i1, const QUrlInfo &i2,
+		      int sortBy )
+{
+    switch ( sortBy ) {
+    case QDir::Name:
+	return i1.name() == i2.name();
+    case QDir::Time:
+	return i1.lastModified() == i2.lastModified();
+    case QDir::Size:
+	return i1.size() == i2.size();
+    default:
+	return FALSE;
+    }
+}
+
+/*!
+    Compares this QUrlInfo with \a i and returns TRUE if they are
+    equal; otherwise returns FALSE.
+*/
+
+bool QUrlInfo::operator==( const QUrlInfo &i ) const
+{
+    if ( !d )
+	return i.d == 0;
+    if ( !i.d )
+	return FALSE;
+
+    return ( d->name == i.d->name &&
+	     d->permissions == i.d->permissions &&
+	     d->owner == i.d->owner &&
+	     d->group == i.d->group &&
+	     d->size == i.d->size &&
+	     d->lastModified == i.d->lastModified &&
+	     d->lastRead == i.d->lastRead &&
+	     d->isDir == i.d->isDir &&
+	     d->isFile == i.d->isFile &&
+	     d->isSymLink == i.d->isSymLink &&
+	     d->isWritable == i.d->isWritable &&
+	     d->isReadable == i.d->isReadable &&
+	     d->isExecutable == i.d->isExecutable );
+}
+
+/*!
+    Returns TRUE if the URL info is valid; otherwise returns FALSE.
+    Valid means that the QUrlInfo contains real information. For
+    example, a call to QUrlOperator::info() might return a an invalid
+    QUrlInfo, if no information about the requested entry is
+    available.
+
+    You should always check if the URL info is valid before relying on
+    the values.
+*/
+bool QUrlInfo::isValid() const
+{
+    return d != 0;
+}
+
+#endif // QT_NO_NETWORKPROTOCOL