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

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

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

**

** This file is part of the QtXmlPatterns 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$

**

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

#ifndef QABSTRACTXMLNODEMODEL_H

#define QABSTRACTXMLNODEMODEL_H

#include <QtXmlPatterns/QXmlName>

#include <QtCore/QSharedData>

#include <QtCore/QScopedPointer>

QT_BEGIN_HEADER

QT_BEGIN_NAMESPACE

QT_MODULE(XmlPatterns)

/* This file contains the classes QXmlNodeModelIndex, QAbstractXmlNodeModel,

 * QXmlItem and QPatternist::NodeIndexStorage. */

class QAbstractXmlNodeModel;

class QAbstractXmlNodeModelPrivate;

class QAbstractXmlReceiver;

class QSourceLocation;

class QUrl;

class QXmlName;

class QXmlNodeModelIndex;

template<typename T> class QAbstractXmlForwardIterator;

template<typename T> class QVector;

/* The members in the namespace QPatternist are internal, not part of the public API, and

 * unsupported. Using them leads to undefined behavior. */

namespace QPatternist

{

    class DynamicContext;

    class Item;

    class ItemType;

    class XsdValidatedXmlNodeModel;

    template<typename TResult, typename TSource, typename TMapper, typename Context> class ItemMappingIterator;

    template<typename TResult, typename TSource, typename TMapper> class SequenceMappingIterator;

    typedef QExplicitlySharedDataPointer<ItemType> ItemTypePtr;

    typedef QExplicitlySharedDataPointer<QAbstractXmlForwardIterator<Item> > ItemIteratorPtr;

    typedef QVector<QXmlName> QXmlNameVector;

    class NodeIndexStorage

    {

    public:

        typedef qint64 Data;

        /*!

          \note Changing merely the order of these two members, ptr and data,

                is a binary incompatible change on Mac Power PC.

         */

        union

        {

            void *ptr; // Do not use ptr directy, use pointer() instead.

            Data data;

        };

        void *pointer() const

        {

            /* Constructing to qptrdiff means we avoid the warning "cast to pointer

             * from integer of different size."

             */

            return (void *)qptrdiff(data);

        }

        Data additionalData;

        const QAbstractXmlNodeModel *model;

        /* Implementation is in qabstractxmlnodemodel.cpp. */

        inline bool operator!=(const NodeIndexStorage &other) const;

    };

}

class Q_XMLPATTERNS_EXPORT QXmlNodeModelIndex

{

    enum Constants

    {

        ForwardAxis         = 8192,

        ReverseAxis         = 16384

    };

public:

    inline QXmlNodeModelIndex()

    {

        reset();

    }

    inline QXmlNodeModelIndex(const QXmlNodeModelIndex &other) : m_storage(other.m_storage)

    {

    }

    bool operator==(const QXmlNodeModelIndex &other) const;

    bool operator!=(const QXmlNodeModelIndex &other) const;

    typedef QAbstractXmlForwardIterator<QXmlNodeModelIndex> Iterator;

    typedef QList<QXmlNodeModelIndex> List;

    enum NodeKind

    {

        Attribute               = 1,

        Comment                 = 2,

        Document                = 4,

        Element                 = 8,

        Namespace               = 16,

        ProcessingInstruction   = 32,

        Text                    = 64

    };

    enum DocumentOrder

    {

        Precedes = -1,

        Is       = 0,

        Follows  = 1

    };

    enum Axis

    {

        AxisChild               = 1 | ForwardAxis,

        AxisDescendant          = 2 | ForwardAxis,

        AxisAttribute           = 4 | ForwardAxis,

        AxisSelf                = 8 | ForwardAxis,

        AxisDescendantOrSelf    = 16 | ForwardAxis,

        AxisFollowingSibling    = 32 | ForwardAxis,

        AxisNamespace           = 64 | ForwardAxis,

        AxisFollowing           = 128 | ReverseAxis,

        AxisParent              = 256 | ReverseAxis,

        AxisAncestor            = 512 | ReverseAxis,

        AxisPrecedingSibling    = 1024 | ReverseAxis,

        AxisPreceding           = 2048 | ReverseAxis,

        AxisAncestorOrSelf      = 4096 | ReverseAxis,

        /* Note that we cannot clash with the values of ForwardAxis and

         * ReverseAxis. */

        AxisChildOrTop          = 32768 | ForwardAxis,

        AxisAttributeOrTop      = 65536 | ForwardAxis

    };

    inline qint64 data() const

    {

        return m_storage.data;

    }

    inline void *internalPointer() const

    {

        return m_storage.pointer();

    }

    inline const QAbstractXmlNodeModel *model() const

    {

        return m_storage.model;

    }

    inline qint64 additionalData() const

    {

        return m_storage.additionalData;

    }

    inline bool isNull() const

    {

        return !m_storage.model;

    }

    /* The members below are internal, not part of the public API, and

     * unsupported. Using them leads to undefined behavior. */

    inline QXmlName name() const;

    inline QXmlNodeModelIndex root() const;

    inline QExplicitlySharedDataPointer<QAbstractXmlForwardIterator<QXmlNodeModelIndex> > iterate(const Axis axis) const;

    inline QExplicitlySharedDataPointer<QAbstractXmlForwardIterator<QPatternist::Item> > sequencedTypedValue() const;

    inline QUrl documentUri() const;

    inline QUrl baseUri() const;

    inline NodeKind kind() const;

    inline bool isDeepEqual(const QXmlNodeModelIndex &other) const;

    inline DocumentOrder compareOrder(const QXmlNodeModelIndex &other) const;

    inline void sendNamespaces(QAbstractXmlReceiver *const receiver) const;

    inline QVector<QXmlName> namespaceBindings() const;

    inline QXmlName::NamespaceCode namespaceForPrefix(const QXmlName::PrefixCode prefix) const;

    inline QString stringValue() const;

    inline QPatternist::ItemTypePtr type() const;

    inline bool is(const QXmlNodeModelIndex &other) const;

    inline void reset()

    {

        m_storage.data = 0;

        m_storage.additionalData = 0;

        m_storage.model = 0;

    }

private:

    static inline QXmlNodeModelIndex create(const qint64 d,

                                            const QAbstractXmlNodeModel *const nm)

    {

        QXmlNodeModelIndex n;

        n.m_storage.data = d;

        n.m_storage.model = nm;

        n.m_storage.additionalData = 0;

        return n;

    }

    static inline QXmlNodeModelIndex create(const qint64 data,

                                            const QAbstractXmlNodeModel *const nm,

                                            const qint64 addData)

    {

        QXmlNodeModelIndex n;

        n.m_storage.data = data;

        n.m_storage.model = nm;

        n.m_storage.additionalData = addData;

        return n;

    }

    inline QXmlNodeModelIndex(const QPatternist::NodeIndexStorage &storage) : m_storage(storage)

    {

    }

    friend class QAbstractXmlNodeModel;

    friend class QPatternist::Item;

    friend class QXmlItem;

    inline operator int() const; // Disable

    QPatternist::NodeIndexStorage m_storage;

};

Q_XMLPATTERNS_EXPORT uint qHash(const QXmlNodeModelIndex &index);

inline bool qIsForwardIteratorEnd(const QXmlNodeModelIndex &item)

{

    return item.isNull();

}

class Q_XMLPATTERNS_EXPORT QAbstractXmlNodeModel : public QSharedData

{

public:

    enum SimpleAxis

    {

        Parent,

        FirstChild,

        PreviousSibling,

        NextSibling

    };

    typedef QExplicitlySharedDataPointer<QAbstractXmlNodeModel> Ptr;

    typedef QList<Ptr> List;

    QAbstractXmlNodeModel();

    virtual ~QAbstractXmlNodeModel();

    virtual QUrl baseUri(const QXmlNodeModelIndex &ni) const = 0;

    virtual QUrl documentUri(const QXmlNodeModelIndex &ni) const = 0;

    virtual QXmlNodeModelIndex::NodeKind kind(const QXmlNodeModelIndex &ni) const = 0;

    virtual QXmlNodeModelIndex::DocumentOrder compareOrder(const QXmlNodeModelIndex &ni1,

                                                           const QXmlNodeModelIndex &ni2) const = 0;

    virtual QXmlNodeModelIndex root(const QXmlNodeModelIndex &n) const = 0;

    virtual QXmlName name(const QXmlNodeModelIndex &ni) const = 0;

    virtual QString stringValue(const QXmlNodeModelIndex &n) const = 0;

    virtual QVariant typedValue(const QXmlNodeModelIndex &n) const = 0;

    /* The members below are internal, not part of the public API, and

     * unsupported. Using them leads to undefined behavior. */

    virtual QExplicitlySharedDataPointer<QAbstractXmlForwardIterator<QXmlNodeModelIndex> > iterate(const QXmlNodeModelIndex &ni, QXmlNodeModelIndex::Axis axis) const;

    virtual QPatternist::ItemIteratorPtr sequencedTypedValue(const QXmlNodeModelIndex &ni) const;

    virtual QPatternist::ItemTypePtr type(const QXmlNodeModelIndex &ni) const;

    virtual QXmlName::NamespaceCode namespaceForPrefix(const QXmlNodeModelIndex &ni,

                                                       const QXmlName::PrefixCode prefix) const;

    virtual bool isDeepEqual(const QXmlNodeModelIndex &ni1,

                             const QXmlNodeModelIndex &ni2) const;

    virtual void sendNamespaces(const QXmlNodeModelIndex &n,

                                QAbstractXmlReceiver *const receiver) const;

    virtual QVector<QXmlName> namespaceBindings(const QXmlNodeModelIndex &n) const = 0;

    virtual QXmlNodeModelIndex elementById(const QXmlName &NCName) const = 0;

    virtual QVector<QXmlNodeModelIndex> nodesByIdref(const QXmlName &NCName) const = 0;

    enum NodeCopySetting

    {

        InheritNamespaces   = 0x1,

        PreserveNamespaces  = 0x2

    };

    typedef QFlags<NodeCopySetting> NodeCopySettings;

    virtual void copyNodeTo(const QXmlNodeModelIndex &node,

                            QAbstractXmlReceiver *const receiver,

                            const NodeCopySettings &) const;

    QSourceLocation sourceLocation(const QXmlNodeModelIndex &index) const;

protected:

    virtual QXmlNodeModelIndex nextFromSimpleAxis(SimpleAxis axis, const QXmlNodeModelIndex &origin) const = 0;

    virtual QVector<QXmlNodeModelIndex> attributes(const QXmlNodeModelIndex &element) const = 0;

    QAbstractXmlNodeModel(QAbstractXmlNodeModelPrivate *d);

    inline QXmlNodeModelIndex createIndex(qint64 data) const

    {

        return QXmlNodeModelIndex::create(data, this);

    }

    inline QXmlNodeModelIndex createIndex(void * pointer,

                                          qint64 additionalData = 0) const

    {

        return QXmlNodeModelIndex::create(qptrdiff(pointer), this, additionalData);

    }

    inline QXmlNodeModelIndex createIndex(qint64 data,

                                          qint64 additionalData) const

    {

        return QXmlNodeModelIndex::create(data, this, additionalData);

    }

    QScopedPointer<QAbstractXmlNodeModelPrivate> d_ptr;

private:

    friend class QPatternist::ItemMappingIterator<QXmlNodeModelIndex, QXmlNodeModelIndex, const QAbstractXmlNodeModel *, QExplicitlySharedDataPointer<QPatternist::DynamicContext> >;

    friend class QPatternist::SequenceMappingIterator<QXmlNodeModelIndex, QXmlNodeModelIndex, const QAbstractXmlNodeModel *>;

    friend class QPatternist::XsdValidatedXmlNodeModel;

    inline QExplicitlySharedDataPointer<QAbstractXmlForwardIterator<QXmlNodeModelIndex> > mapToSequence(const QXmlNodeModelIndex &ni,

                                                                           const QExplicitlySharedDataPointer<QPatternist::DynamicContext> &) const;

    static inline bool isIgnorableInDeepEqual(const QXmlNodeModelIndex &n);

    Q_DISABLE_COPY(QAbstractXmlNodeModel)

};

Q_DECLARE_TYPEINFO(QXmlNodeModelIndex, Q_MOVABLE_TYPE);

template<typename T> class QAbstractXmlForwardIterator;

class QVariant;

class QXmlItemPrivate;

namespace QPatternist

{

    class AtomicValue;

    class VariableLoader;

    class IteratorBridge;

    class ToQXmlItemMapper;

    class ToItemMapper;

}

class Q_XMLPATTERNS_EXPORT QXmlItem

{

public:

    typedef QAbstractXmlForwardIterator<QXmlItem> Iterator;

    QXmlItem();

    QXmlItem(const QXmlItem &other);

    QXmlItem(const QXmlNodeModelIndex &node);

    QXmlItem(const QVariant &atomicValue);

    ~QXmlItem();

    QXmlItem &operator=(const QXmlItem &other);

    bool isNull() const;

    bool isNode() const;

    bool isAtomicValue() const;

    QVariant toAtomicValue() const;

    QXmlNodeModelIndex toNodeModelIndex() const;

private:

    friend class QPatternist::IteratorBridge;

    friend class QPatternist::VariableLoader;

    friend class QPatternist::ToQXmlItemMapper;

    friend class QPatternist::ToItemMapper;

    friend class QPatternist::Item;

    inline bool internalIsAtomicValue() const;

    inline QXmlItem(const QPatternist::Item &i);

    union

    {

        QPatternist::NodeIndexStorage   m_node;

        /* These two sits at the position of NodeIndexStorage::data.

         * NodeIndexStorage::{additionalData,model} are free. */

        const QPatternist::AtomicValue *m_atomicValue;

        QXmlItemPrivate *               m_ptr; /* Not currently used. */

    };

};

inline bool qIsForwardIteratorEnd(const QXmlItem &item)

{

    return item.isNull();

}

Q_DECLARE_TYPEINFO(QXmlItem, Q_MOVABLE_TYPE);

QT_END_NAMESPACE

Q_DECLARE_METATYPE(QXmlItem) /* This macro must appear after QT_END_NAMESPACE. */

QT_END_HEADER

#endif