/****************************************************************************

**

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the Qt3Support module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "q3urloperator.h"

#ifndef QT_NO_NETWORKPROTOCOL

#include "qurlinfo.h"

#include "q3networkprotocol.h"

#include "qmap.h"

#include "qdir.h"

#include "q3ptrdict.h"

#include "qpointer.h"

#include "q3valuelist.h"

#include "qapplication.h"

QT_BEGIN_NAMESPACE

//#define Q3URLOPERATOR_DEBUG

class Q3UrlOperatorPrivate

{

public:

    Q3UrlOperatorPrivate()

    {

	oldOps.setAutoDelete( false );

	networkProtocol = 0;

	nameFilter = QLatin1String("*");

	currPut = 0;

    }

    ~Q3UrlOperatorPrivate()

    {

	delete networkProtocol;

	while ( oldOps.first() ) {

	    oldOps.first()->free();

	    oldOps.removeFirst();

	}

    }

    QMap<QString, QUrlInfo> entryMap;

    Q3NetworkProtocol *networkProtocol;

    QString nameFilter;

    QDir dir;

    // maps needed for copy/move operations

    Q3PtrDict<Q3NetworkOperation> getOpPutOpMap;

    Q3PtrDict<Q3NetworkProtocol> getOpPutProtMap;

    Q3PtrDict<Q3NetworkProtocol> getOpGetProtMap;

    Q3PtrDict<Q3NetworkOperation> getOpRemoveOpMap;

    QPointer<Q3NetworkProtocol> currPut;

    QStringList waitingCopies;

    QString waitingCopiesDest;

    bool waitingCopiesMove;

    Q3PtrList< Q3NetworkOperation > oldOps;

};

/*!

    \class Q3UrlOperator

    \brief The Q3UrlOperator class provides common operations on URLs.

    \compat

    \module network

    This class operates on hierarchical structures (such as

    filesystems) using URLs. Its API facilitates all the common

    operations:

    \table

    \header \i Operation	\i Function

    \row \i List files		\i \l listChildren()

    \row \i Make a directory	\i \l mkdir()

    \row \i Remove a file	\i \l remove()

    \row \i Rename a file	\i \l rename()

    \row \i Get a file		\i \l get()

    \row \i Put a file		\i \l put()

    \row \i Copy a file		\i \l copy()

    \endtable

    You can obtain additional information about the URL with isDir()

    and info(). If a directory is to be traversed using

    listChildren(), a name filter can be set with setNameFilter().

    A Q3UrlOperator can be used like this, for example to download a

    file (and assuming that the FTP protocol is registered):

    \snippet doc/src/snippets/code/src_qt3support_network_q3urloperator.cpp 0

    If you want to be notified about success/failure, progress, etc.,

    you can connect to Q3UrlOperator's signals, e.g. to start(),

    newChildren(), createdDirectory(), removed(), data(),

    dataTransferProgress(), startedNextCopy(),

    connectionStateChanged(), finished(), etc. A network operation can

    be stopped with stop().

    The class uses the functionality of registered network protocols

    to perform these operations. Depending of the protocol of the URL,

    it uses an appropriate network protocol class for the operations.

    Each of the operation functions of Q3UrlOperator creates a

    Q3NetworkOperation object that describes the operation and puts it

    into the operation queue for the network protocol used. If no

    suitable protocol could be found (because no implementation of the

    necessary network protocol is registered), the URL operator emits

    errors. Not every protocol supports every operation, but error

    handling deals with this problem.

    To register the available network protocols, use the

    qInitNetworkProtocols() function. The protocols currently

    supported are:

    \list

    \i \link Q3Ftp FTP\endlink,

    \i \link Q3Http HTTP\endlink,

    \i \link Q3LocalFs local file system\endlink.

    \endlist

    \sa Q3NetworkProtocol, Q3NetworkOperation

*/

/*!

    \fn void Q3UrlOperator::newChildren( const Q3ValueList<QUrlInfo> &i, Q3NetworkOperation *op )

    This signal is emitted after listChildren() was called and new

    children (i.e. files) have been read from a list of files. \a i

    holds the information about the new files. \a op is a pointer

    to the operation object which contains all the information about

    the operation, including the state.

    \sa Q3NetworkOperation, Q3NetworkProtocol

*/

/*!

    \fn void Q3UrlOperator::finished( Q3NetworkOperation *op )

    This signal is emitted when an operation of some sort finishes,

    whether with success or failure. \a op is a pointer to the

    operation object, which contains all the information, including

    the state, of the operation which has been finished. Check the

    state and error code of the operation object to see whether or not

    the operation was successful.

    \sa Q3NetworkOperation, Q3NetworkProtocol

*/

/*!

    \fn void Q3UrlOperator::start( Q3NetworkOperation *op )

    Some operations (such as listChildren()) emit this signal when

    they start processing the operation. \a op is a pointer to the

    operation object which contains all the information about the

    operation, including the state.

    \sa Q3NetworkOperation, Q3NetworkProtocol

*/

/*!

    \fn void Q3UrlOperator::createdDirectory( const QUrlInfo &i, Q3NetworkOperation *op )

    This signal is emitted when mkdir() succeeds and the directory has

    been created. \a i holds the information about the new directory.

    \a op is a pointer to the operation object, which contains all the

    information about the operation, including the state.

    \c op->arg(0) holds the new directory's name.

    \sa Q3NetworkOperation, Q3NetworkProtocol

*/

/*!

    \fn void Q3UrlOperator::removed( Q3NetworkOperation *op )

    This signal is emitted when remove() has been successful and the

    file has been removed.

    \a op is a pointer to the operation object which contains all the

    information about the operation, including the state.

    \c op->arg(0) holds the name of the file that was removed.

    \sa Q3NetworkOperation, Q3NetworkProtocol

*/

/*!

    \fn void Q3UrlOperator::itemChanged( Q3NetworkOperation *op )

    This signal is emitted whenever a file which is a child of the URL

    has been changed, for example by successfully calling rename().

    \a op is a pointer to the operation object which contains all the

    information about the operation, including the state.

    \c op->arg(0) holds the original file name and \c op->arg(1) holds

    the new file name (if it was changed).

    \sa Q3NetworkOperation, Q3NetworkProtocol

*/

/*!

    \fn void Q3UrlOperator::data( const QByteArray &data, Q3NetworkOperation *op )

    This signal is emitted when new \a data has been received after calling

    get() or put().

    \a op is a pointer to the operation object which contains all

    the information about the operation, including the state.

    \c op->arg(0) holds the name of the file whose data is retrieved

    and op->rawArg(1) holds the (raw) data.

    \sa Q3NetworkOperation, Q3NetworkProtocol

*/

/*!

    \fn void Q3UrlOperator::dataTransferProgress( int bytesDone, int bytesTotal, Q3NetworkOperation *op )

    This signal is emitted during data transfer (using put() or

    get()). \a bytesDone specifies how many bytes of \a bytesTotal have

    been transferred. More information about the operation is stored in

    \a op, a pointer to the network operation that is processed.

    \a bytesTotal may be -1, which means that the total number of bytes

    is not known.

    \sa Q3NetworkOperation, Q3NetworkProtocol

*/

/*!

    \fn void Q3UrlOperator::startedNextCopy( const Q3PtrList<Q3NetworkOperation> &lst )

    This signal is emitted if copy() starts a new copy operation. \a

    lst contains all Q3NetworkOperations related to this copy

    operation.

    \sa copy()

*/

/*!

    \fn void Q3UrlOperator::connectionStateChanged( int state, const QString &data )

    This signal is emitted whenever the URL operator's connection

    state changes. \a state describes the new state, which is a

    \l{Q3NetworkProtocol::ConnectionState} value.

    \a data is a string that describes the change of the connection.

    This can be used to display a message to the user.

*/

/*!

    Constructs a Q3UrlOperator with an empty (i.e. invalid) URL.

*/

Q3UrlOperator::Q3UrlOperator()

    : Q3Url()

{

#ifdef Q3URLOPERATOR_DEBUG

    qDebug( "Q3UrlOperator: cstr 1" );

#endif

    d = new Q3UrlOperatorPrivate;

}

/*!

    Constructs a Q3UrlOperator using \a url and parses this string.

    If you pass strings like "/home/qt" the "file" protocol is

    assumed.

*/

Q3UrlOperator::Q3UrlOperator( const QString &url )

    : Q3Url( url )

{

#ifdef Q3URLOPERATOR_DEBUG

    qDebug( "Q3UrlOperator: cstr 2" );

#endif

    d = new Q3UrlOperatorPrivate;

    getNetworkProtocol();

}

/*!

    Constructs a copy of \a url.

*/

Q3UrlOperator::Q3UrlOperator( const Q3UrlOperator& url )

    : QObject(), Q3Url( url )

{

#ifdef Q3URLOPERATOR_DEBUG

    qDebug( "Q3UrlOperator: cstr 3" );

#endif

    d = new Q3UrlOperatorPrivate;

    *d = *url.d;

    d->networkProtocol = 0;

    getNetworkProtocol();

    d->nameFilter = QLatin1String("*");

    d->currPut = 0;

}

/*!

    Constructs a Q3UrlOperator. The URL on which this Q3UrlOperator

    operates is constructed out of the arguments \a url, \a relUrl and

    \a checkSlash: see the corresponding Q3Url constructor for an

    explanation of these arguments.

*/

Q3UrlOperator::Q3UrlOperator( const Q3UrlOperator& url, const QString& relUrl, bool checkSlash )

    : Q3Url( url, relUrl, checkSlash )

{

#ifdef Q3URLOPERATOR_DEBUG

    qDebug( "Q3UrlOperator: cstr 4" );

#endif

    d = new Q3UrlOperatorPrivate;

    if ( relUrl == QLatin1String(".") )

	*d = *url.d;

    d->networkProtocol = 0;

    getNetworkProtocol();

    d->currPut = 0;

}

/*!

    Destructor.

*/

Q3UrlOperator::~Q3UrlOperator()

{

#ifdef Q3URLOPERATOR_DEBUG

    qDebug( "Q3UrlOperator: dstr" );

#endif

    delete d;

}

/*!

    This private function is used by the simple operation functions,

    i.e. listChildren(), mkdir(), remove(), rename(), get() and put(),

    to really start the operation. \a op is a pointer to the network

    operation that should be started. Returns \a op on success;

    otherwise returns 0.

*/

const Q3NetworkOperation *Q3UrlOperator::startOperation( Q3NetworkOperation *op )

{

    if ( !d->networkProtocol )

        getNetworkProtocol();

    if ( d->networkProtocol && (d->networkProtocol->supportedOperations()&op->operation()) ) {

	d->networkProtocol->addOperation( op );

	if ( op->operation() == Q3NetworkProtocol::OpListChildren )

	    clearEntries();

        return op;

    }

    // error

    QString msg;

    if ( !d->networkProtocol ) {

	msg = tr( "The protocol `%1' is not supported" ).arg( protocol() );

    } else {

	switch ( op->operation() ) {

	case Q3NetworkProtocol::OpListChildren:

	    msg = tr( "The protocol `%1' does not support listing directories" ).arg( protocol() );

	    break;

	case Q3NetworkProtocol::OpMkDir:

	    msg = tr( "The protocol `%1' does not support creating new directories" ).arg( protocol() );

	    break;

	case Q3NetworkProtocol::OpRemove:

	    msg = tr( "The protocol `%1' does not support removing files or directories" ).arg( protocol() );

	    break;

	case Q3NetworkProtocol::OpRename:

	    msg = tr( "The protocol `%1' does not support renaming files or directories" ).arg( protocol() );

	    break;

	case Q3NetworkProtocol::OpGet:

	    msg = tr( "The protocol `%1' does not support getting files" ).arg( protocol() );

	    break;

	case Q3NetworkProtocol::OpPut:

	    msg = tr( "The protocol `%1' does not support putting files" ).arg( protocol() );

	    break;

	default:

	    // this should never happen

	    break;

	}

    }

    op->setState( Q3NetworkProtocol::StFailed );

    op->setProtocolDetail( msg );

    op->setErrorCode( (int)Q3NetworkProtocol::ErrUnsupported );

    emit finished( op );

    deleteOperation( op );

    return 0;

}

/*!

    Starts listing the children of this URL (e.g. the files in the

    directory). The start() signal is emitted before the first entry

    is listed and finished() is emitted after the last one. The

    newChildren() signal is emitted for each list of new entries. If

    an error occurs, the signal finished() is emitted, so be sure to

    check the state of the network operation pointer.

    Because the operation may not be executed immediately, a pointer

    to the Q3NetworkOperation object created by this function is

    returned. This object contains all the data about the operation

    and is used to refer to this operation later (e.g. in the signals

    that are emitted by the Q3UrlOperator). The return value can also

    be 0 if the operation object couldn't be created.

    The path of this Q3UrlOperator must to point to a directory

    (because the children of this directory will be listed), not to a

    file.

*/

const Q3NetworkOperation *Q3UrlOperator::listChildren()

{

    if ( !checkValid() )

	return 0;

    Q3NetworkOperation *res = new Q3NetworkOperation( Q3NetworkProtocol::OpListChildren, QString(), QString(), QString() );

    return startOperation( res );

}

/*!

    Tries to create a directory (child) with the name \a dirname. If

    it is successful, a newChildren() signal with the new child is

    emitted, and the createdDirectory() signal with the information

    about the new child is also emitted. The finished() signal (with

    success or failure) is emitted after the operation has been

    processed, so check the state of the network operation object to

    see whether or not the operation was successful.

    Because the operation will not be executed immediately, a pointer

    to the Q3NetworkOperation object created by this function is

    returned. This object contains all the data about the operation

    and is used to refer to this operation later (e.g. in the signals

    that are emitted by the Q3UrlOperator). The return value can also

    be 0 if the operation object couldn't be created.

    The path of this Q3UrlOperator must to point to a directory (not a

    file) because the new directory will be created in this path.

*/

const Q3NetworkOperation *Q3UrlOperator::mkdir( const QString &dirname )

{

    if ( !checkValid() )

	return 0;

    Q3NetworkOperation *res = new Q3NetworkOperation( Q3NetworkProtocol::OpMkDir, dirname, QString(), QString() );

    return startOperation( res );

}

/*!

    Tries to remove the file (child) \a filename. If it succeeds the

    removed() signal is emitted. finished() (with success or failure)

    is also emitted after the operation has been processed, so check

    the state of the network operation object to see whether or not

    the operation was successful.

    Because the operation will not be executed immediately, a pointer

    to the Q3NetworkOperation object created by this function is

    returned. This object contains all the data about the operation

    and is used to refer to this operation later (e.g. in the signals

    that are emitted by the Q3UrlOperator). The return value can also

    be 0 if the operation object couldn't be created.

    The path of this Q3UrlOperator must point to a directory; because

    if \a filename is relative, it will try to remove it in this

    directory.

*/

const Q3NetworkOperation *Q3UrlOperator::remove( const QString &filename )

{

    if ( !checkValid() )

	return 0;

    Q3NetworkOperation *res = new Q3NetworkOperation( Q3NetworkProtocol::OpRemove, filename, QString(), QString() );

    return startOperation( res );

}

/*!

    Tries to rename the file (child) called \a oldname to \a newname.

    If it succeeds, the itemChanged() signal is emitted. finished()

    (with success or failure) is also emitted after the operation has

    been processed, so check the state of the network operation object

    to see whether or not the operation was successful.

    Because the operation may not be executed immediately, a pointer

    to the Q3NetworkOperation object created by this function is

    returned. This object contains all the data about the operation

    and is used to refer to this operation later (e.g. in the signals

    that are emitted by the Q3UrlOperator). The return value can also

    be 0 if the operation object couldn't be created.

    This path of this Q3UrlOperator must to point to a directory

    because \a oldname and \a newname are handled relative to this

    directory.

*/

const Q3NetworkOperation *Q3UrlOperator::rename( const QString &oldname, const QString &newname )

{

    if ( !checkValid() )

	return 0;