#include "qversitwriter_p.h"

#include <QTextCodec>

QTM_USE_NAMESPACE

  \preliminary 

  \brief The QVersitWriter class writes Versit documents such as vCards to a device.

  The writing can be done asynchronously and the waitForFinished()

  function can be used to implement a blocking write.

  The serialization of the document is done in accordance with the type of the QVersitDocument

  being written.  The value of each QVersitProperty is encoded according to the type of object:

  \list

  \o \l{QString}{QStrings} are serialized verbatim, unless the default codec of the writer cannot

  encode the string: in this case, UTF-8 is used to encode it (and the CHARSET parameter added to

  the property, as per the vCard 2.1 specification).  If the document type is vCard 2.1,

  quoted-printable encoding may also be performed.

  \o \l{QByteArray}{QByteArrays} are assumed to be binary data and are serialized as base-64 encoded

  values.

  \o \l{QVersitDocument}{QVersitDocuments} are serialized as a nested document (eg. as per the

  AGENT property in vCard).

  \endlist

 * \enum QVersitWriter::Error

 * This enum specifies an error that occurred during the most recent operation:

 * \value NoError The most recent operation was successful

 * \value UnspecifiedError The most recent operation failed for an undocumented reason

 * \value IOError The most recent operation failed because of a problem with the device

 * \value OutOfMemoryError The most recent operation failed due to running out of memory

 * \value NotReadyError The most recent operation failed because there is an operation in progress

 */

/*!

 * \enum QVersitWriter::State

 * Enumerates the various states that a reader may be in at any given time

 * \value InactiveState Write operation not yet started

 * \value ActiveState Write operation started, not yet finished

 * \value CanceledState Write operation is finished due to cancelation

 * \value FinishedState Write operation successfully completed

 */

/*!

 * \fn QVersitWriter::stateChanged(QVersitWriter::State state)

 * The signal is emitted by the writer when its state has changed (eg. when it has finished

 * writing to the device).

 * \a state is the new state of the writer.

QVersitWriter::QVersitWriter() : d(new QVersitWriterPrivate)

    connect(d, SIGNAL(stateChanged(QVersitWriter::State)),

            this, SIGNAL(stateChanged(QVersitWriter::State)), Qt::DirectConnection);

 * Sets the default codec for the writer to use for writing the entire output.

 *

 * If \a codec is NULL, the writer uses the codec according to the specification prescribed default.

 * (for vCard 2.1, ASCII; for vCard 3.0, UTF-8).

 */

void QVersitWriter::setDefaultCodec(QTextCodec *codec)

{

    d->mDefaultCodec = codec;

}

/*!

 * Returns the document's codec.

 */

QTextCodec* QVersitWriter::defaultCodec() const

{

    return d->mDefaultCodec;

}

/*!

 * Starts writing \a input to device() asynchronously.

 * Signal \l stateChanged() is emitted with parameter FinishedState

 * when the writing has finished.

bool QVersitWriter::startWriting(const QList<QVersitDocument>& input)

    d->mInput = input;

    if (d->state() == ActiveState || d->isRunning()) {

        d->setError(QVersitWriter::NotReadyError);

        return false;

    } else if (!d->mIoDevice || !d->mIoDevice->isWritable()) {

        d->setError(QVersitWriter::IOError);

        return false;

    } else {

        d->setState(ActiveState);

        d->setError(NoError);

        return true;

}

/*!

 * Attempts to asynchronously cancel the write request.

 */

void QVersitWriter::cancel()

{

    d->setCanceling(true);

 * If the state is ActiveState, blocks until the writer has finished writing or \a msec milliseconds

 * has elapsed, returning true if it successfully finishes or is cancelled by the user.

 * If the state is FinishedState, returns true immediately.

 * Otherwise, returns false immediately.

 */

bool QVersitWriter::waitForFinished(int msec)

{

    State state = d->state();

    if (state == ActiveState) {

        return d->wait(msec);

    } else if (state == FinishedState) {

        return true;

    } else {

        return false;

    }

}

/*!

 * Returns the state of the writer.

 */

QVersitWriter::State QVersitWriter::state() const

{

    return d->state();

}

/*!

 * Returns the error encountered by the last operation.

QVersitWriter::Error QVersitWriter::error() const

{

    return d->error();

}

/*! \internal */

void QVersitWriter::setVersitDocument(const QVersitDocument& versitDocument)

{

    QList<QVersitDocument> documents;

    documents.append(versitDocument);

    d->mInput = documents;

}

/*! \internal */

QVersitDocument QVersitWriter::versitDocument() const

{

    return QVersitDocument();

}

/*! \internal */

bool QVersitWriter::startWriting()

{

    return startWriting(d->mInput);

}

/*! \internal */

    startWriting(d->mInput);

    return waitForFinished();