QPatternist::AccelTree Class Reference

Stores an XML document using the XPath Accelerator scheme, also known as pre/post numbering. More...

#include <qacceltree_p.h>

Inheritance diagram for QPatternist::AccelTree:

Classes
class	BasicNodeData
	Houses data for a node, and that all node kinds have. More...

Public Types
enum	Constants { IsCompressed = 1 }
typedef qint8	Depth
typedef PreNumber	PostNumber
typedef qint32	PreNumber
typedef QExplicitlySharedDataPointer< AccelTree >	Ptr
Public Types inherited from QAbstractXmlNodeModel
typedef QList< Ptr >	List
	A list of smart pointers to instances of QAbstractXmlNodeModel. More...
enum	NodeCopySetting { InheritNamespaces = 0x1, PreserveNamespaces = 0x2 }
typedef QFlags< NodeCopySetting >	NodeCopySettings
typedef QExplicitlySharedDataPointer< QAbstractXmlNodeModel >	Ptr
	A QExplicitlySharedDataPointer {smart pointer} to an instance of QAbstractXmlNodeModel. More...
enum	SimpleAxis { Parent, FirstChild, PreviousSibling, NextSibling }
	Four axes that each contain one node only. More...

Public Functions
	AccelTree (const QUrl &docURI, const QUrl &bURI)
virtual QUrl	baseUri (const QXmlNodeModelIndex &ni) const
	Returns the base URI for the node whose index is n. More...
QUrl	baseUri () const
virtual QXmlNodeModelIndex::DocumentOrder	compareOrder (const QXmlNodeModelIndex &ni1, const QXmlNodeModelIndex &ni2) const
	This function returns the relative document order for the nodes indexed by ni1 and ni2. More...
virtual void	copyNodeTo (const QXmlNodeModelIndex &node, QAbstractXmlReceiver *const receiver, const NodeCopySettings &settings) const
Depth	depth (const PreNumber pre) const
virtual QUrl	documentUri (const QXmlNodeModelIndex &ni) const
	Returns the document URI of n. More...
QUrl	documentUri () const
virtual QXmlNodeModelIndex	elementById (const QXmlName &id) const
	Returns the index of the element identified as id. More...
bool	hasChildren (const PreNumber pre) const
	Returns true if the node identified by pre has child nodes(in the sense of the XDM), but also if it has namespace nodes, or attribute nodes. More...
bool	hasFollowingSibling (const PreNumber pre) const
bool	hasParent (const PreNumber pre) const
bool	isCompressed (const PreNumber pre) const
virtual QXmlNodeModelIndex::Iterator::Ptr	iterate (const QXmlNodeModelIndex &ni, QXmlNodeModelIndex::Axis axis) const
	Performs navigation, starting from ni, by returning an QAbstractXmlForwardIterator that returns nodes the axis emanating from ni. More...
virtual QXmlNodeModelIndex::NodeKind	kind (const QXmlNodeModelIndex &ni) const
	Returns a value indicating the kind of node identified by ni. More...
QXmlNodeModelIndex::NodeKind	kind (const PreNumber pre) const
PreNumber	maximumPreNumber () const
virtual QXmlName	name (const QXmlNodeModelIndex &ni) const
	Returns the name of ni. More...
QXmlName	name (const PreNumber pre) const
virtual QVector< QXmlName >	namespaceBindings (const QXmlNodeModelIndex &n) const
	Returns the in-scope namespaces of n. More...
virtual QVector< QXmlNodeModelIndex >	nodesByIdref (const QXmlName &idref) const
	Returns the elements and/or attributes that have an IDREF value equal to idref. More...
virtual QXmlNodeModelIndex	parent (const QXmlNodeModelIndex &ni) const
PreNumber	parent (const PreNumber pre) const
	Returns the parent node of pre. More...
PostNumber	postNumber (const PreNumber pre) const
void	printStats (const NamePool::Ptr &np) const
virtual QXmlNodeModelIndex	root (const QXmlNodeModelIndex &n) const
	Returns the root node. More...
virtual void	sendNamespaces (const QXmlNodeModelIndex &n, QAbstractXmlReceiver *const receiver) const
virtual Item::Iterator::Ptr	sequencedTypedValue (const QXmlNodeModelIndex &n) const
PreNumber	size (const PreNumber pre) const
virtual QString	stringValue (const QXmlNodeModelIndex &n) const
	Returns the string value for node n. More...
PreNumber	toPreNumber (const QXmlNodeModelIndex n) const
virtual ItemType::Ptr	type (const QXmlNodeModelIndex &ni) const
virtual QVariant	typedValue (const QXmlNodeModelIndex &n) const
	Returns the typed value for node node. More...
Public Functions inherited from QAbstractXmlNodeModel
virtual void	copyNodeTo (const QXmlNodeModelIndex &node, QAbstractXmlReceiver *const receiver, const NodeCopySettings &) const
virtual bool	isDeepEqual (const QXmlNodeModelIndex &ni1, const QXmlNodeModelIndex &ni2) const
	Determines whether ni1 is deep equal to ni2. More...
virtual QXmlName::NamespaceCode	namespaceForPrefix (const QXmlNodeModelIndex &ni, const QXmlName::PrefixCode prefix) const
	Returns the namespace URI on ni that corresponds to prefix. More...
	QAbstractXmlNodeModel ()
	Default constructor. More...
virtual void	sendNamespaces (const QXmlNodeModelIndex &n, QAbstractXmlReceiver *const receiver) const
	Sends the namespaces declared on n to receiver. More...
QSourceLocation	sourceLocation (const QXmlNodeModelIndex &index) const
	Returns the source location for the object with the given index or a default constructed QSourceLocation in case no location information is available. More...
virtual	~QAbstractXmlNodeModel ()
	Destructor. More...
Public Functions inherited from QSharedData
	QSharedData ()
	Constructs a QSharedData object with a reference count of 0. More...
	QSharedData (const QSharedData &)
	Constructs a QSharedData object with reference count 0. More...

Static Public Functions
static bool	hasPrefix (const QVector< QXmlName > &nbs, const QXmlName::PrefixCode prefix)

Public Variables
QVector< BasicNodeData >	basicData
QHash< PreNumber, QString >	data
QUrl	m_baseURI
QUrl	m_documentURI
QHash< PreNumber, QVector< QXmlName > >	namespaces
QHash< PreNumber, QPair< qint64, qint64 > >	sourcePositions
Public Variables inherited from QSharedData
QAtomicInt	ref

Protected Functions
virtual QVector< QXmlNodeModelIndex >	attributes (const QXmlNodeModelIndex &element) const
	Returns the attributes of element. More...
virtual QXmlNodeModelIndex	nextFromSimpleAxis (QAbstractXmlNodeModel::SimpleAxis, const QXmlNodeModelIndex &) const
	When QtXmlPatterns evaluate path expressions, it emulate them through a combination of calls with QSimpleXmlNodeModel::SimpleAxis values. More...
Protected Functions inherited from QAbstractXmlNodeModel
QXmlNodeModelIndex	createIndex (qint64 data) const
	Creates a node index with data as its internal data. More...
QXmlNodeModelIndex	createIndex (void *pointer, qint64 additionalData=0) const
	Creates a node index with pointer and additionalData as its internal data. More...
QXmlNodeModelIndex	createIndex (qint64 data, qint64 additionalData) const
	Creates a QXmlNodeModelIndex containing data and additionalData. More...
	QAbstractXmlNodeModel (QAbstractXmlNodeModelPrivate *d)

Private Functions
void	copyChildren (const QXmlNodeModelIndex &node, QAbstractXmlReceiver *const receiver, const NodeCopySettings &settings) const
QSourceLocation	sourceLocation (const QXmlNodeModelIndex &index) const

Properties
QHash< QXmlName::LocalNameCode, PreNumber >	m_IDs

Friends
class	AccelTreeBuilder< false >
class	AccelTreeBuilder< true >
class	AccelTreePrivate

Additional Inherited Members
Protected Variables inherited from QAbstractXmlNodeModel
QScopedPointer< QAbstractXmlNodeModelPrivate >	d_ptr

Detailed Description

Stores an XML document using the XPath Accelerator scheme, also known as pre/post numbering.

Working on this code will be destructive without a proper understanding of the Accelerator scheme, so do check out the links. We don't implement any form of staircase join, although that is only due to time constraints.

Author

Frans Englich frans.nosp@m..eng.nosp@m.lich@.nosp@m.noki.nosp@m.a.com

See also

XPath Accelerator

Accelerating XPath Location Steps, Torsten Grust

Staircase Join: Teach a Relational DBMS to Watch its (Axis) Steps

Loop-lifted staircase join: from XPath to XQuery, Torsten Grust

xmlstat, Frans Englich

<a href"http://www.inf.uni-konstanz.de/dbis/publications/download/accelerating-locsteps.pdf">Accelerating XPath Evaluation in Any RDBMS, Torsten Grust

Definition at line 92 of file qacceltree_p.h.

Typedefs

Depth

typedef qint8 QPatternist::AccelTree::Depth

Definition at line 101 of file qacceltree_p.h.

PostNumber

typedef PreNumber QPatternist::AccelTree::PostNumber

Definition at line 100 of file qacceltree_p.h.

PreNumber

typedef qint32 QPatternist::AccelTree::PreNumber

Definition at line 99 of file qacceltree_p.h.

Ptr

typedef QExplicitlySharedDataPointer<AccelTree> QPatternist::AccelTree::Ptr

Definition at line 98 of file qacceltree_p.h.

Enumerations

Constants

enum QPatternist::AccelTree::Constants

Enumerator
IsCompressed

Definition at line 256 of file qacceltree_p.h.

        {
            IsCompressed = 1
        };

Constructors and Destructors

AccelTree()

AccelTree::AccelTree	(	const QUrl &	docURI,
		const QUrl &	bURI
	)

Definition at line 79 of file qacceltree.cpp.

     : QAbstractXmlNodeModel(new AccelTreePrivate(this))
     , m_documentURI(docURI)
     , m_baseURI(bURI)
{
    /* Pre-allocate at least a little bit. */
    // TODO. Do it according to what an average 4 KB doc contains.
    basicData.reserve(100);
    data.reserve(30);
}

Functions

attributes()

QVector< QXmlNodeModelIndex > AccelTree::attributes ( const QXmlNodeModelIndex &  element ) const

protectedvirtual

Returns the attributes of element.

The caller guarantees that element is an element in this node model.

Implements QAbstractXmlNodeModel.

Definition at line 372 of file qacceltree.cpp.

Referenced by copyNodeTo().

{
    Q_ASSERT_X(false, Q_FUNC_INFO, "This function is not supposed to be called.");
    Q_UNUSED(element);
    return QVector<QXmlNodeModelIndex>();
}

baseUri() [1/2]

QUrl AccelTree::baseUri ( const QXmlNodeModelIndex &  n ) const

virtual

Returns the base URI for the node whose index is n.

The caller guarantees that n is not null and that it belongs to a node in this node model.

The base URI of a node can be extracted using the fn:base-uri() function. The base URI is typically used for resolving relative URIs that appear in the node or its children. It is conformant to just return the document URI, although that might not properly reflect the underlying data.

This function maps to the dm:base-uri accessor, which returns a base URI according to the following:

• For document nodes, the base URI and the document URI are the same.

• For elements, the base URI is the URI appearing in the element's xml:base attribute, if present, or it is resolved to the parent element's base URI.

• Namespace nodes have no base URI.

• The base URI for a processing instruction, comment, attribute, or text node is the base URI of the node's parent element.

The implementation guarantees to return a valid QUrl, or a default constructed QUrl. If a node has no base URI, as in the case where a comment has no parent, a default constructed QUrl is returned.

See also

{http://www.w3.org/TR/xpath-datamodel/#dm-base-uri}{XQuery 1.0 and XPath 2.0 Data Model (XDM), 5.2 base-uri Accessor}

Implements QAbstractXmlNodeModel.

Definition at line 140 of file qacceltree.cpp.

{
    switch(kind(toPreNumber(ni)))
    {
        case QXmlNodeModelIndex::Document:
            return baseUri();
        case QXmlNodeModelIndex::Element:
        {
            const QXmlNodeModelIndex::Iterator::Ptr it(iterate(ni, QXmlNodeModelIndex::AxisAttribute));
            QXmlNodeModelIndex next(it->next());

            while(!next.isNull())
            {
                if(next.name() == QXmlName(StandardNamespaces::xml, StandardLocalNames::base))
                {
                    const QUrl candidate(next.stringValue());
                    //  TODO. The xml:base spec says to do URI escaping here.

                    if(!candidate.isValid())
                        return QUrl();
                    else if(candidate.isRelative())
                    {
                        const QXmlNodeModelIndex par(parent(ni));

                        if(par.isNull())
                            return baseUri().resolved(candidate);
                        else
                            return par.baseUri().resolved(candidate);
                    }
                    else
                        return candidate;
                }

                next = it->next();
            }

            /* We have no xml:base-attribute. Can any parent supply us a base URI? */
            const QXmlNodeModelIndex par(parent(ni));

            if(par.isNull())
                return baseUri();
            else
                return par.baseUri();
        }
        case QXmlNodeModelIndex::ProcessingInstruction:
        /* Fallthrough. */
        case QXmlNodeModelIndex::Comment:
        /* Fallthrough. */
        case QXmlNodeModelIndex::Attribute:
        /* Fallthrough. */
        case QXmlNodeModelIndex::Text:
        {
            const QXmlNodeModelIndex par(ni.iterate(QXmlNodeModelIndex::AxisParent)->next());
            if(par.isNull())
                return QUrl();
            else
                return par.baseUri();
        }
        case QXmlNodeModelIndex::Namespace:
            return QUrl();
    }

    Q_ASSERT_X(false, Q_FUNC_INFO, "This line is never supposed to be reached.");
    return QUrl();
}

baseUri() [2/2]

QUrl QPatternist::AccelTree::baseUri ( ) const

inline

Definition at line 284 of file qacceltree_p.h.

Referenced by baseUri().

        {
            return m_baseURI;
        }

compareOrder()

QXmlNodeModelIndex::DocumentOrder AccelTree::compareOrder ( const QXmlNodeModelIndex &  ni1, const QXmlNodeModelIndex &  ni2  ) const

virtual

This function returns the relative document order for the nodes indexed by ni1 and ni2.

It is used for the Is operator and for sorting nodes in document order.

The caller guarantees that ni1 and ni2 are not null and that both identify nodes in this node model.

If ni1 is identical to ni2, QXmlNodeModelIndex::Is is returned. If ni1 precedes ni2 in document order, QXmlNodeModelIndex::Precedes is returned. If ni1 follows ni2 in document order, QXmlNodeModelIndex::Follows is returned.

See also

{http://www.w3.org/TR/xpath-datamodel/#document-order}{XQuery 1.0 and XPath 2.0 Data Model (XDM), 2.4 Document Order}

Implements QAbstractXmlNodeModel.

Definition at line 219 of file qacceltree.cpp.

{
    Q_ASSERT_X(ni1.model() == ni2.model(), Q_FUNC_INFO,
               "The API docs guarantees the two nodes are from the same model");

    const PreNumber p1 = ni1.data();
    const PreNumber p2 = ni2.data();

    if(p1 == p2)
        return QXmlNodeModelIndex::Is;
    else if(p1 < p2)
        return QXmlNodeModelIndex::Precedes;
    else
        return QXmlNodeModelIndex::Follows;
}

copyChildren()

void AccelTree::copyChildren ( const QXmlNodeModelIndex &  node, QAbstractXmlReceiver *const  receiver, const NodeCopySettings &  settings  ) const

inlineprivate

Copies the children of node to receiver.

Definition at line 720 of file qacceltree.cpp.

Referenced by copyNodeTo().

{
    QXmlNodeModelIndex::Iterator::Ptr children(node.iterate(QXmlNodeModelIndex::AxisChild));
    QXmlNodeModelIndex child(children->next());

    while(!child.isNull())
    {
        copyNodeTo(child, receiver, settings);
        child = children->next();
    }
}

copyNodeTo()

void AccelTree::copyNodeTo ( const QXmlNodeModelIndex &  node, QAbstractXmlReceiver *const  receiver, const NodeCopySettings &  settings  ) const

virtual

Definition at line 622 of file qacceltree.cpp.

Referenced by copyChildren().

{
    /* This code piece can be seen as a customized version of
     * QAbstractXmlReceiver::item/sendAsNode(). */
    Q_ASSERT(receiver);
    Q_ASSERT(!node.isNull());

    typedef QHash<QXmlName::PrefixCode, QXmlName::NamespaceCode> Binding;
    QStack<Binding> outputted;

    switch(node.kind())
    {
        case QXmlNodeModelIndex::Element:
        {
            outputted.push(Binding());

            /* Add the namespace for our element name. */
            const QXmlName elementName(node.name());

            receiver->startElement(elementName);

            if(!settings.testFlag(InheritNamespaces))
                receiver->namespaceBinding(QXmlName(StandardNamespaces::StopNamespaceInheritance, 0,
                                                    StandardPrefixes::StopNamespaceInheritance));

            if(settings.testFlag(PreserveNamespaces))
                node.sendNamespaces(receiver);
            else
            {
                /* Find the namespaces that we actually use and add them to outputted. These are drawn
                 * from the element name, and the node's attributes. */
                outputted.top().insert(elementName.prefix(), elementName.namespaceURI());

                const QXmlNodeModelIndex::Iterator::Ptr attributes(iterate(node, QXmlNodeModelIndex::AxisAttribute));
                QXmlNodeModelIndex attr(attributes->next());

                while(!attr.isNull())
                {
                    const QXmlName &attrName = attr.name();
                    outputted.top().insert(attrName.prefix(), attrName.namespaceURI());
                    attr = attributes->next();
                }

                Binding::const_iterator it(outputted.top().constBegin());
                const Binding::const_iterator end(outputted.top().constEnd());

                for(; it != end; ++it)
                    receiver->namespaceBinding(QXmlName(it.value(), 0, it.key()));
            }

            /* Send the attributes of the element. */
            {
                QXmlNodeModelIndex::Iterator::Ptr attributes(node.iterate(QXmlNodeModelIndex::AxisAttribute));
                QXmlNodeModelIndex attribute(attributes->next());

                while(!attribute.isNull())
                {
                    const QString &v = attribute.stringValue();
                    receiver->attribute(attribute.name(), QStringRef(&v));
                    attribute = attributes->next();
                }
            }

            /* Send the children of the element. */
            copyChildren(node, receiver, settings);

            receiver->endElement();
            outputted.pop();
            break;
        }
        case QXmlNodeModelIndex::Document:
        {
            /* We need to intercept and grab the elements of the document node, such
             * that we preserve/inherit preference applies to them. */
            receiver->startDocument();
            copyChildren(node, receiver, settings);
            receiver->endDocument();
            break;
        }
        default:
            receiver->item(node);
    }

}

depth()

Depth QPatternist::AccelTree::depth ( const PreNumber  pre ) const

inline

Definition at line 350 of file qacceltree_p.h.

Referenced by QPatternist::ChildIterator::ChildIterator(), QPatternist::ChildIterator::next(), and QPatternist::SiblingIterator< IsFollowing >::next().

        {
            return basicData.at(pre).depth();
        }

documentUri() [1/2]

QUrl AccelTree::documentUri ( const QXmlNodeModelIndex &  n ) const

virtual

Returns the document URI of n.

The document URI identifies the resource which is the document. For example, the document could be a regular file, e.g., file:/, or it could be the http:// URL of the location of a file. The document URI is used for resolving URIs and to simply know where the document is.

If the node model maps to a URI in a natural way, return that URI. Otherwise, return the company or product URI. The document URI can be any URI as long as its valid and absolute.

The caller guarantees that n is not null and that it belongs to this QAbstractXmlNodeModel.

This function maps to the dm:document-uri accessor, which returns a document URI according to the following:

• If n is a document node, return an absolute QUrl containing the document URI, or a default constructed QUrl. The latter signals that no document URI is available for the document node.

• For all other nodes, return a default constructed QUrl.

See also

{http://www.w3.org/TR/xpath-datamodel/#dm-document-uri}{XQuery 1.0 and XPath 2.0 Data Model (XDM), 5.4 document-uri Accessor}

QUrl::isValid(), QUrl::isRelative()

Implements QAbstractXmlNodeModel.

Definition at line 206 of file qacceltree.cpp.

{
    if(kind(toPreNumber(ni)) == QXmlNodeModelIndex::Document)
        return documentUri();
    else
        return QUrl();
}

documentUri() [2/2]

QUrl QPatternist::AccelTree::documentUri ( ) const

inline

Definition at line 279 of file qacceltree_p.h.

Referenced by documentUri().

        {
            return m_documentURI;
        }

elementById()

QXmlNodeModelIndex AccelTree::elementById ( const QXmlName &  id ) const

virtual

Returns the index of the element identified as id.

XQuery's id() function calls this function.

The node index returned will be the element node whose value is of type ID and equals id, or it will be the element node that has an attribute whose typed value is of type ID and equals id. If there is no such element, a default constructed QXmlNodeModelIndex instance is returned. The implementor guarantees that if the returned node index is not null, it identifies an element.

It is not sufficient for an attribute or element to merely be called id. Its value type must also be ID. However, the reserved name xml:id is sufficient.

In id, the namespace URI and the prefix are undefined, and the local name is the ID that should be looked up.

See also

{http://www.w3.org/TR/xpath-functions/#func-id}{XQuery 1.0 and XPath 2.0 Functions and Operators, 15.5.2 fn:id}

Implements QAbstractXmlNodeModel.

Definition at line 734 of file qacceltree.cpp.

{
    const PreNumber pre = m_IDs.value(id.localName(), -1);
    if(pre == -1)
        return QXmlNodeModelIndex();
    else
        return createIndex(pre);
}

hasChildren()

bool QPatternist::AccelTree::hasChildren ( const PreNumber  pre ) const

inline

Returns true if the node identified by pre has child nodes(in the sense of the XDM), but also if it has namespace nodes, or attribute nodes.

Definition at line 294 of file qacceltree_p.h.

Referenced by QPatternist::AttributeIterator::AttributeIterator(), QPatternist::ChildIterator::ChildIterator(), QPatternist::DescendantIterator< IncludeSelf >::DescendantIterator(), iterate(), and stringValue().

        {
            return basicData.at(pre).size() > 0;
        }

hasFollowingSibling()

bool QPatternist::AccelTree::hasFollowingSibling ( const PreNumber  pre ) const

inline

Definition at line 317 of file qacceltree_p.h.

        {
            return pre < maximumPreNumber();
        }

hasParent()

bool QPatternist::AccelTree::hasParent ( const PreNumber  pre ) const

inline

Definition at line 312 of file qacceltree_p.h.

Referenced by QPatternist::AncestorIterator< IncludeSelf >::AncestorIterator(), and iterate().

        {
            return basicData.at(pre).depth() > 0;
        }

hasPrefix()

bool AccelTree::hasPrefix ( const QVector< QXmlName > &  nbs, const QXmlName::PrefixCode  prefix  )

inlinestatic

Definition at line 574 of file qacceltree.cpp.

Referenced by namespaceBindings().

{
    const int size = nbs.size();

    for(int i = 0; i < size; ++i)
    {
        if(nbs.at(i).prefix() == prefix)
            return true;
    }

    return false;
}

isCompressed()

bool QPatternist::AccelTree::isCompressed ( const PreNumber  pre ) const

inline

Definition at line 362 of file qacceltree_p.h.

Referenced by printStats(), and stringValue().

        {
            return basicData.at(pre).isCompressed();
        }

iterate()

QXmlNodeModelIndex::Iterator::Ptr AccelTree::iterate ( const QXmlNodeModelIndex &  ni, QXmlNodeModelIndex::Axis  axis  ) const

virtual

Performs navigation, starting from ni, by returning an QAbstractXmlForwardIterator that returns nodes the axis emanating from ni.

Warning

This function is not part of the public interface.

The implementation returns the nodes on the axis, without duplicates and in axis order. This means that if axis is a reverse axis, which is the case for the parent, ancestor, ancestor-or-self, preceding, and preceding-sibling, the nodes are delivered in reverse document order. Otherwise the nodes are delivered in document order.

The implementor guarantees that the nodes delivered for the axes are consistent with the XPath Data Model. This just implies common sense, e.g., The child axis for a comment node can't contain any children; a document node can't be a child of an element, etc. Attributes aren't considered children of an element, but are only available on AxisAttribute.

The value past in axis is not guaranteed based on what is used in a query. QtXmlPatterns may call this function arbitrarily with any value for axis. This is because QtXmlPatterns may rewrite queries to be more efficient, using axes in different ways from the original query.

QAbstractXmlNodeModel::Axis has a good overview of the axes and what they select.

The caller guarantees that ni is not null and that it belongs to this QAbstractXmlNodeModel instance.

Implementing iterate() can involve significant work, since it requires different iterators for all the axes used. In the worst case, it could require writing as many QAbstractXmlForwardIterator subclasses as there are axes, but the number can often be reduced with clever use of lists and template classes. It is better to use or subclass QSimpleXmlNodeModel, which makes it easier to write the node navigation code without loss of efficiency or flexibility.

See also

QSimpleXmlNodeModel

QXmlNodeModelIndex::Axis

{http://www.w3.org/TR/xquery/#axes}{XQuery 1.0: An XML Query Language, 3.2.1.1 Axes}

{http://www.w3.org/TR/xpath-datamodel/}{W3CXQuery 1.0 and XPath 2.0 Data Model (XDM)}

Reimplemented from QAbstractXmlNodeModel.

Definition at line 251 of file qacceltree.cpp.

Referenced by baseUri(), copyNodeTo(), and sendNamespaces().

{
    const PreNumber preNumber = toPreNumber(ni);

    switch(axis)
    {
        case QXmlNodeModelIndex::AxisChildOrTop:
        {
            if(!hasParent(preNumber))
            {
                switch(kind(preNumber))
                {
                    case QXmlNodeModelIndex::Comment:
                    /* Fallthrough. */
                    case QXmlNodeModelIndex::ProcessingInstruction:
                    /* Fallthrough. */
                    case QXmlNodeModelIndex::Element:
                    /* Fallthrough. */
                    case QXmlNodeModelIndex::Text:
                        return makeSingletonIterator(ni);
                    case QXmlNodeModelIndex::Attribute:
                    /* Fallthrough. */
                    case QXmlNodeModelIndex::Document:
                    /* Fallthrough. */
                    case QXmlNodeModelIndex::Namespace:
                        /* Do nothing. */;
                }
            }
            /* Else, fallthrough to AxisChild. */
        }
        case QXmlNodeModelIndex::AxisChild:
        {
            if(hasChildren(preNumber))
                return QXmlNodeModelIndex::Iterator::Ptr(new ChildIterator(this, preNumber));
            else
                return makeEmptyIterator<QXmlNodeModelIndex>();
        }
        case QXmlNodeModelIndex::AxisAncestor:
        {
            if(hasParent(preNumber))
                return QXmlNodeModelIndex::Iterator::Ptr(new AncestorIterator<false>(this, preNumber));
            else
                return makeEmptyIterator<QXmlNodeModelIndex>();
        }
        case QXmlNodeModelIndex::AxisAncestorOrSelf:
            return QXmlNodeModelIndex::Iterator::Ptr(new AncestorIterator<true>(this, preNumber));
        case QXmlNodeModelIndex::AxisParent:
        {
            if(hasParent(preNumber))
                return makeSingletonIterator(createIndex(parent(preNumber)));
            else
                return makeEmptyIterator<QXmlNodeModelIndex>();
        }
        case QXmlNodeModelIndex::AxisDescendant:
        {
            if(hasChildren(preNumber))
                return QXmlNodeModelIndex::Iterator::Ptr(new DescendantIterator<false>(this, preNumber));
            else
                return makeEmptyIterator<QXmlNodeModelIndex>();
        }
        case QXmlNodeModelIndex::AxisDescendantOrSelf:
            return QXmlNodeModelIndex::Iterator::Ptr(new DescendantIterator<true>(this, preNumber));
        case QXmlNodeModelIndex::AxisFollowing:
        {
            if(preNumber == maximumPreNumber())
                return makeEmptyIterator<QXmlNodeModelIndex>();
            else
                return QXmlNodeModelIndex::Iterator::Ptr(new FollowingIterator(this, preNumber));
        }
        case QXmlNodeModelIndex::AxisAttributeOrTop:
        {
            if(!hasParent(preNumber) && kind(preNumber) == QXmlNodeModelIndex::Attribute)
                return makeSingletonIterator(ni);
            /* Else, falthrough to AxisAttribute. */
        }
        case QXmlNodeModelIndex::AxisAttribute:
        {
            if(hasChildren(preNumber) && kind(preNumber + 1) == QXmlNodeModelIndex::Attribute)
                return QXmlNodeModelIndex::Iterator::Ptr(new AttributeIterator(this, preNumber));
            else
                return makeEmptyIterator<QXmlNodeModelIndex>();
        }
        case QXmlNodeModelIndex::AxisPreceding:
        {
            if(preNumber == 0)
                return makeEmptyIterator<QXmlNodeModelIndex>();
            else
                return QXmlNodeModelIndex::Iterator::Ptr(new PrecedingIterator(this, preNumber));
        }
        case QXmlNodeModelIndex::AxisSelf:
            return makeSingletonIterator(createIndex(toPreNumber(ni)));
        case QXmlNodeModelIndex::AxisFollowingSibling:
        {
            if(preNumber == maximumPreNumber())
                return makeEmptyIterator<QXmlNodeModelIndex>();
            else
                return QXmlNodeModelIndex::Iterator::Ptr(new SiblingIterator<true>(this, preNumber));
        }
        case QXmlNodeModelIndex::AxisPrecedingSibling:
        {
            if(preNumber == 0)
                return makeEmptyIterator<QXmlNodeModelIndex>();
            else
                return QXmlNodeModelIndex::Iterator::Ptr(new SiblingIterator<false>(this, preNumber));
        }
        case QXmlNodeModelIndex::AxisNamespace:
            return makeEmptyIterator<QXmlNodeModelIndex>();
    }

    Q_ASSERT(false);
    return QXmlNodeModelIndex::Iterator::Ptr();
}

kind() [1/2]

QXmlNodeModelIndex::NodeKind AccelTree::kind ( const QXmlNodeModelIndex &  ni ) const

virtual

Returns a value indicating the kind of node identified by ni.

The caller guarantees that ni is not null and that it identifies a node in this node model. This function maps to the dm:node-kind() accessor.

See also

{http://www.w3.org/TR/xpath-datamodel/#dm-node-kind}{XQuery 1.0 and XPath 2.0 Data Model (XDM), 5.10 node-kind Accessor}

Implements QAbstractXmlNodeModel.

Definition at line 214 of file qacceltree.cpp.

Referenced by QPatternist::AttributeIterator::AttributeIterator(), baseUri(), QPatternist::ChildIterator::ChildIterator(), QPatternist::DescendantIterator< IncludeSelf >::DescendantIterator(), documentUri(), iterate(), QPatternist::SiblingIterator< IsFollowing >::next(), QPatternist::DescendantIterator< IncludeSelf >::next(), QPatternist::FollowingIterator::next(), QPatternist::PrecedingIterator::next(), QPatternist::AttributeIterator::next(), sequencedTypedValue(), and stringValue().

{
    return kind(toPreNumber(ni));
}

kind() [2/2]

QXmlNodeModelIndex::NodeKind QPatternist::AccelTree::kind ( const PreNumber  pre ) const

inline

Definition at line 328 of file qacceltree_p.h.

        {
            return basicData.at(pre).kind();
        }

maximumPreNumber()

PreNumber QPatternist::AccelTree::maximumPreNumber ( ) const

inline

Definition at line 333 of file qacceltree_p.h.

Referenced by QPatternist::ChildIterator::ChildIterator(), QPatternist::DescendantIterator< IncludeSelf >::DescendantIterator(), iterate(), QPatternist::ChildIterator::next(), QPatternist::SiblingIterator< IsFollowing >::next(), QPatternist::DescendantIterator< IncludeSelf >::next(), QPatternist::FollowingIterator::next(), QPatternist::AttributeIterator::next(), printStats(), QPatternist::SiblingIterator< IsFollowing >::SiblingIterator(), and stringValue().

        {
            return basicData.count() - 1;
        }

name() [1/2]

QXmlName AccelTree::name ( const QXmlNodeModelIndex &  ni ) const

virtual

Returns the name of ni.

The caller guarantees that ni is not null and that it belongs to this QAbstractXmlNodeModel.

If a node does not have a name, e.g., comment nodes, a null QXmlName is returned. QXmlNames must be created with the instance of QXmlQuery that is being used for evaluating queries using this QAbstractXmlNodeModel.

This function maps to the dm:node-name() accessor.

If ni is a processing instruction, a QXmlName is returned with the local name as the target name and the namespace URI and prefix both empty.

See also

{http://www.w3.org/TR/xpath-datamodel/#dm-node-name}{XQuery 1.0 and XPath 2.0 Data Model (XDM), 5.11 node-name Accessor}

QXmlName

Implements QAbstractXmlNodeModel.

Definition at line 379 of file qacceltree.cpp.

Referenced by sendNamespaces().

{
    /* If this node type does not have a name(for instance, it's a comment)
     * we will return the default constructed value, which is conformant with
     * this function's contract. */
    return name(toPreNumber(ni));
}

name() [2/2]

QXmlName QPatternist::AccelTree::name ( const PreNumber  pre ) const

inline

Definition at line 357 of file qacceltree_p.h.

        {
            return basicData.at(pre).name();
        }

namespaceBindings()

QVector< QXmlName > AccelTree::namespaceBindings ( const QXmlNodeModelIndex &  n ) const

virtual

Returns the in-scope namespaces of n.

The caller guarantees that n is not null and that it belongs to this QAbstractXmlNodeModel.

This function corresponds to the dm:namespace-nodes accessor.

The returned vector of namespace declarations includes namespaces of the ancestors of n.

The caller guarantees that n is an Element that belongs to this QAbstractXmlNodeModel.

Implements QAbstractXmlNodeModel.

Definition at line 387 of file qacceltree.cpp.

{
    /* We get a hold of the ancestor, and loop them in reverse document
     * order(first the parent, then the parent's parent, etc). As soon
     * we find a binding that hasn't already been added, we add it to the
     * result list. In that way, declarations appearing further down override
     * those further up. */

    const PreNumber preNumber = toPreNumber(ni);

    const QXmlNodeModelIndex::Iterator::Ptr it(new AncestorIterator<true>(this, preNumber));
    QVector<QXmlName> result;
    QXmlNodeModelIndex n(it->next());

    /* Whether xmlns="" has been encountered. */
    bool hasUndeclaration = false;

    while(!n.isNull())
    {
        const QVector<QXmlName> &forNode = namespaces.value(toPreNumber(n));
        const int len = forNode.size();
        bool stopInheritance = false;

        for(int i = 0; i < len; ++i)
        {
            const QXmlName &nsb = forNode.at(i);

            if(nsb.namespaceURI() == StandardNamespaces::StopNamespaceInheritance)
            {
                stopInheritance = true;
                continue;
            }

            if(nsb.prefix() == StandardPrefixes::empty &&
               nsb.namespaceURI() == StandardNamespaces::empty)
            {
                hasUndeclaration = true;
                continue;
            }

            if(!hasPrefix(result, nsb.prefix()))
            {
                /* We've already encountered an undeclaration, so we're supposed to skip
                 * them. */
                if(hasUndeclaration && nsb.prefix() == StandardPrefixes::empty)
                    continue;
                else
                    result.append(nsb);
            }
        }

        if(stopInheritance)
            break;
        else
            n = it->next();
    }

    result.append(QXmlName(StandardNamespaces::xml, StandardLocalNames::empty, StandardPrefixes::xml));

    return result;
}

nextFromSimpleAxis()

QXmlNodeModelIndex AccelTree::nextFromSimpleAxis ( QAbstractXmlNodeModel::SimpleAxis  axis, const QXmlNodeModelIndex &  origin  ) const

protectedvirtual

When QtXmlPatterns evaluate path expressions, it emulate them through a combination of calls with QSimpleXmlNodeModel::SimpleAxis values.

Therefore, the implementation of this function must return the node, if any, that appears on the axis emanating from the origin.

If no such node is available, a default constructed QXmlNodeModelIndex is returned.

QSimpleXmlNodeModel eliminates the need to handle redundant corner cases by guaranteeing that it will never ask for:

• Children or siblings for attributes.
• Children for comments, processing instructions, and text nodes.
• Siblings or parents for document nodes.

A typical implementation performs a switch on the value of axis:

QXmlNodeModelIndex MyTreeModel::nextFromSimpleAxis(SimpleAxis axis, const QXmlNodeModelIndex &origin) const
{
  // Convert the QXmlNodeModelIndex to a value that is specific to what we represent.
  const MyValue value = toMyValue(ni);

  switch(axis)
  {
      case Parent:
          return toNodeIndex(value.parent());
      case FirstChild:
      case PreviousSibling:
      case NextSibling:
          // and so on
  }
}

Implements QAbstractXmlNodeModel.

Definition at line 365 of file qacceltree.cpp.

{
    Q_ASSERT_X(false, Q_FUNC_INFO, "This function is not supposed to be called.");
    return QXmlNodeModelIndex();
}

nodesByIdref()

QVector< QXmlNodeModelIndex > AccelTree::nodesByIdref ( const QXmlName &  idref ) const

virtual

Returns the elements and/or attributes that have an IDREF value equal to idref.

XQuery's idref() function calls this function.

The implementor guarantees that the nodes identified by the returned indexes are elements or attributes.

It is not sufficient for an attribute or element to merely be called idref. It must also be of type IDREF. Elements must be typed as xs:IDREF or xs:IDREFS, or, in the case of attributes, as IDREF or IDREFS in the schema.

In idref, the namespace URI and the prefix are undefined, and the local name is the ID that should be looked up.

See also

{http://www.w3.org/TR/xpath-functions/#func-idref}{XQuery 1.0 and XPath 2.0 Functions and Operators, 15.5.3 fn:idref}

Implements QAbstractXmlNodeModel.

Definition at line 743 of file qacceltree.cpp.

{
    return QVector<QXmlNodeModelIndex>();
}

parent() [1/2]

QXmlNodeModelIndex AccelTree::parent ( const QXmlNodeModelIndex &  ni ) const

virtual

Definition at line 241 of file qacceltree.cpp.

Referenced by baseUri(), and iterate().

{
    const AccelTree::PreNumber p = basicData.at(toPreNumber(ni)).parent();

    if(p == -1)
        return QXmlNodeModelIndex();
    else
        return createIndex(p);
}

parent() [2/2]

PreNumber QPatternist::AccelTree::parent ( const PreNumber  pre ) const

inline

Returns the parent node of pre.

If pre parent doesn't have a parent node, the return value is undefined.

See also

hasParent()

Definition at line 307 of file qacceltree_p.h.

        {
            return basicData.at(pre).parent();
        }

postNumber()

PostNumber QPatternist::AccelTree::postNumber ( const PreNumber  pre ) const

inline

Definition at line 322 of file qacceltree_p.h.

Referenced by QPatternist::DescendantIterator< IncludeSelf >::DescendantIterator(), QPatternist::DescendantIterator< IncludeSelf >::next(), QPatternist::PrecedingIterator::next(), and printStats().

        {
            const BasicNodeData &b = basicData.at(pre);
            return pre + b.size() - b.depth();
        }

printStats()

void AccelTree::printStats

(

const NamePool::Ptr &

np

)

const

Definition at line 90 of file qacceltree.cpp.

{
    Q_ASSERT(np);
#ifdef QT_NO_DEBUG
    Q_UNUSED(np); /* Needed when compiling in release mode. */
#else
    const int len = basicData.count();

    pDebug() << "AccelTree stats for" << (m_documentURI.isEmpty() ? QString::fromLatin1("<empty URI>") : m_documentURI.toString());
    pDebug() << "Maximum pre number:" << maximumPreNumber();
    pDebug() << "+---------------+-------+-------+---------------+-------+--------------+-------+";
    pDebug() << "| Pre number    | Depth | Size  | Post Number   | Kind  | Name         | Value |";
    pDebug() << "+---------------+-------+-------+---------------+-------+--------------+-------+";
    for(int i = 0; i < len; ++i)
    {
        const BasicNodeData &v = basicData.at(i);
        pDebug() << '|' << i
                 << "\t\t|" << v.depth()
                 << "\t|" << v.size()
                 << "\t|" << postNumber(i)
                 << "\t|" << v.kind()
                 << "\t\t|" << (v.name().isNull() ? QString::fromLatin1("(none)") : np->displayName(v.name()))
                 << "\t\t|" << ((v.kind() == QXmlNodeModelIndex::Text && isCompressed(i)) ? CompressedWhitespace::decompress(data.value(i))
                                                                                          : data.value(i))
                 << "\t|";
        /*
        pDebug() << '|' << QString().arg(i, 14)
                 << '|' << QString().arg(v.depth(), 6)
                 << '|' << QString().arg(v.size(), 6)
                 << '|' << QString().arg(postNumber(i), 14)
                 << '|' << QString().arg(v.kind(), 6)
                 << '|';
                 */
    }
    pDebug() << "+---------------+-------+-------+---------------+-------+--------------+";
    pDebug() << "Namespaces(" << namespaces.count() << "):";

    QHashIterator<PreNumber, QVector<QXmlName> > it(namespaces);
    while(it.hasNext())
    {
        it.next();

        pDebug() << "PreNumber: " << QString::number(it.key());
        for(int i = 0; i < it.value().count(); ++i)
            pDebug() << "\t\t" << np->stringForPrefix(it.value().at(i).prefix()) << " = " << np->stringForNamespace(it.value().at(i).namespaceURI());
    }

#endif
}

root()

QXmlNodeModelIndex AccelTree::root ( const QXmlNodeModelIndex &  n ) const

virtual

Returns the root node.

This function does not use n, so a default constructed QXmlNodeModelIndex may be passed.

Implements QAbstractXmlNodeModel.

Definition at line 236 of file qacceltree.cpp.

Referenced by QPatternist::AccelTreeResourceLoader::openDocument().

{
    return createIndex(qint64(0));
}

sendNamespaces()

void AccelTree::sendNamespaces ( const QXmlNodeModelIndex &  n, QAbstractXmlReceiver *const  receiver  ) const

virtual

Definition at line 449 of file qacceltree.cpp.

{
    Q_ASSERT(n.kind() == QXmlNodeModelIndex::Element);

    const QXmlNodeModelIndex::Iterator::Ptr it(iterate(n, QXmlNodeModelIndex::AxisAncestorOrSelf));
    QXmlNodeModelIndex next(it->next());
    QVector<QXmlName::PrefixCode> alreadySent;

    while(!next.isNull())
    {
        const PreNumber preNumber = toPreNumber(next);

        const QVector<QXmlName> &nss = namespaces.value(preNumber);

        /* This is by far the most common case. */
        if(nss.isEmpty())
        {
            next = it->next();
            continue;
        }

        const int len = nss.count();
        bool stopInheritance = false;

        for(int i = 0; i < len; ++i)
        {
            const QXmlName &name = nss.at(i);

            if(name.namespaceURI() == StandardNamespaces::StopNamespaceInheritance)
            {
                stopInheritance = true;
                continue;
            }

            if(!alreadySent.contains(name.prefix()))
            {
                alreadySent.append(name.prefix());
                receiver->namespaceBinding(name);
            }
        }

        if(stopInheritance)
            break;
        else
            next = it->next();
    }
}

sequencedTypedValue()

Item::Iterator::Ptr AccelTree::sequencedTypedValue ( const QXmlNodeModelIndex &  ni ) const

virtual

Warning

This function is not part of the public interface.

Reimplemented from QAbstractXmlNodeModel.

Definition at line 593 of file qacceltree.cpp.

{
    const PreNumber preNumber = toPreNumber(n);

    switch(kind(preNumber))
    {
        case QXmlNodeModelIndex::Element:
        /* Fallthrough. */
        case QXmlNodeModelIndex::Document:
        /* Fallthrough. */
        case QXmlNodeModelIndex::Attribute:
            return makeSingletonIterator(Item(UntypedAtomic::fromValue(stringValue(n))));

        case QXmlNodeModelIndex::Text:
        /* Fallthrough. */
        case QXmlNodeModelIndex::ProcessingInstruction:
        /* Fallthrough. */
        case QXmlNodeModelIndex::Comment:
            return makeSingletonIterator(Item(AtomicString::fromValue(stringValue(n))));
        default:
        {
            Q_ASSERT_X(false, Q_FUNC_INFO,
                       qPrintable(QString::fromLatin1("A node type that doesn't exist "
                                                      "in the XPath Data Model was encountered.").arg(kind(preNumber))));
            return Item::Iterator::Ptr(); /* Dummy, silence compiler warning. */
        }
    }
}

size()

PreNumber QPatternist::AccelTree::size ( const PreNumber  pre ) const

inline

Definition at line 343 of file qacceltree_p.h.

Referenced by hasPrefix(), QPatternist::ChildIterator::next(), QPatternist::SiblingIterator< IsFollowing >::next(), QPatternist::FollowingIterator::next(), and stringValue().

        {
            Q_ASSERT_X(basicData.at(pre).size() != -1, Q_FUNC_INFO,
                       "The size cannot be -1. That means an uninitialized value is attempted to be used.");
            return basicData.at(pre).size();
        }

sourceLocation()

QSourceLocation AccelTree::sourceLocation ( const QXmlNodeModelIndex &  index ) const

private

Returns the source location for the object with the given index.

Definition at line 709 of file qacceltree.cpp.

Referenced by QPatternist::AccelTreePrivate::sourceLocation().

{
    const PreNumber key = toPreNumber(index);
    if (sourcePositions.contains(key)) {
        const QPair<qint64, qint64> position = sourcePositions.value(key);
        return QSourceLocation(m_documentURI, position.first, position.second);
    } else {
        return QSourceLocation();
    }
}

stringValue()

QString AccelTree::stringValue ( const QXmlNodeModelIndex &  n ) const

virtual

Returns the string value for node n.

The caller guarantees that n is not null and that it belong to this QAbstractXmlNodeModel instance.

This function maps to the dm:string-value() accessor, which the specification completely specifies. Here's a summary:

• For processing instructions, the string value is the data section(excluding any whitespace appearing between the name and the data).

• For text nodes, the string value equals the text node.

• For comments, the content of the comment

• For elements, the concatenation of all text nodes that are descendants. Note, this is not only the children, but the childrens' childrens' text nodes, and so forth.

• For document nodes, the concatenation of all text nodes in the document.

See also

{http://www.w3.org/TR/xpath-datamodel/#dm-string-value}{XQuery 1.0 and XPath 2.0 Data Model (XDM), 5.13 string-value Accessor}

Implements QAbstractXmlNodeModel.

Definition at line 498 of file qacceltree.cpp.

Referenced by sequencedTypedValue(), and typedValue().

{
    const PreNumber preNumber = toPreNumber(ni);

    switch(kind(preNumber))
    {
        case QXmlNodeModelIndex::Element:
        {
            /* Concatenate all text nodes that are descendants of this node. */
            if(!hasChildren(preNumber))
                return QString();

            const AccelTree::PreNumber stop = preNumber + size(preNumber);
            AccelTree::PreNumber pn = preNumber + 1; /* Jump over ourselves. */
            QString result;

            for(; pn <= stop; ++pn)
            {
                if(kind(pn) == QXmlNodeModelIndex::Text)
                {
                    if(isCompressed(pn))
                        result += CompressedWhitespace::decompress(data.value(pn));
                    else
                        result += data.value(pn);
                }
            }

            return result;
        }
        case QXmlNodeModelIndex::Text:
        {
            if(isCompressed(preNumber))
                return CompressedWhitespace::decompress(data.value(preNumber));
            /* Else, fallthrough. It's not compressed so use it as it is. */
        }
        case QXmlNodeModelIndex::Attribute:
        /* Fallthrough */
        case QXmlNodeModelIndex::ProcessingInstruction:
        /* Fallthrough */
        case QXmlNodeModelIndex::Comment:
            return data.value(preNumber);
        case QXmlNodeModelIndex::Document:
        {
            /* Concatenate all text nodes in the whole document. */

            QString result;
            // Perhaps we can QString::reserve() the result based on the size?
            const AccelTree::PreNumber max = maximumPreNumber();

            for(AccelTree::PreNumber i = 0; i <= max; ++i)
            {
                if(kind(i) == QXmlNodeModelIndex::Text)
                {
                    if(isCompressed(i))
                        result += CompressedWhitespace::decompress(data.value(i));
                    else
                        result += data.value(i);
                }
            }

            return result;
        }
        default:
        {
            Q_ASSERT_X(false, Q_FUNC_INFO,
                       "A node type that doesn't exist in the XPath Data Model was encountered.");
            return QString(); /* Dummy, silence compiler warning. */
        }
    }
}

toPreNumber()

PreNumber QPatternist::AccelTree::toPreNumber ( const QXmlNodeModelIndex  n ) const

inline

Definition at line 338 of file qacceltree_p.h.

Referenced by baseUri(), documentUri(), iterate(), kind(), name(), namespaceBindings(), parent(), sendNamespaces(), sequencedTypedValue(), sourceLocation(), stringValue(), and type().

        {
            return n.data();
        }

type()

ItemType::Ptr AccelTree::type ( const QXmlNodeModelIndex &  ni ) const

virtual

Warning

This function is not part of the public interface.

Reimplemented from QAbstractXmlNodeModel.

Definition at line 587 of file qacceltree.cpp.

{
    /* kind() is manually inlined here to avoid a virtual call. */
    return XPathHelper::typeFromKind(basicData.at(toPreNumber(ni)).kind());
}

typedValue()

QVariant AccelTree::typedValue ( const QXmlNodeModelIndex &  node ) const

virtual

Returns the typed value for node node.

The typed value is an atomic value, which an element or attribute contains.

The caller guarantees that node is either an element or an attribute. The implementor guarantees that the returned QVariant has a value which is supported in XQuery. It cannot be an arbitrary QVariant value. The implementor also guarantees that stringValue() returns a lexical representation of typedValue()(this is guaranteed by QSimpleXmlNodeModel::stringValue()).

If the return QVariant is a default constructed variant, it signals that node has no typed value.

Implements QAbstractXmlNodeModel.

Definition at line 569 of file qacceltree.cpp.

{
    return stringValue(n);
}

Friends and Related Functions

AccelTreeBuilder< false >

friend class AccelTreeBuilder< false >

friend

Definition at line 253 of file qacceltree_p.h.

AccelTreeBuilder< true >

friend class AccelTreeBuilder< true >

friend

Definition at line 254 of file qacceltree_p.h.

AccelTreePrivate

friend class AccelTreePrivate

friend

Definition at line 94 of file qacceltree_p.h.

Properties

basicData

QVector<BasicNodeData> QPatternist::AccelTree::basicData

Definition at line 276 of file qacceltree_p.h.

Referenced by AccelTree(), QPatternist::AncestorIterator< IncludeSelf >::next(), parent(), printStats(), and type().

data

QHash<PreNumber, QString> QPatternist::AccelTree::data

Stores data for nodes. The QHash's value is the data of the processing instruction, and the content of a text node or comment.

Definition at line 274 of file qacceltree_p.h.

Referenced by AccelTree(), printStats(), and stringValue().

m_baseURI

QUrl QPatternist::AccelTree::m_baseURI

Definition at line 370 of file qacceltree_p.h.

m_documentURI

QUrl QPatternist::AccelTree::m_documentURI

Definition at line 369 of file qacceltree_p.h.

Referenced by printStats(), and sourceLocation().

m_IDs

QHash<QXmlName::LocalNameCode, PreNumber> QPatternist::AccelTree::m_IDs

private

The key is the xml:id value, and the value is the element with that value.

Definition at line 394 of file qacceltree_p.h.

Referenced by elementById().

namespaces

QHash<PreNumber, QVector<QXmlName> > QPatternist::AccelTree::namespaces

The key is the pre number of an element, and the value is a vector containing the namespace declarations being declared on that element. Therefore, it does not reflect the namespaces being in scope for that element. For that, a walk along axis ancestor is necessary.

Definition at line 268 of file qacceltree_p.h.

Referenced by namespaceBindings(), printStats(), and sendNamespaces().

sourcePositions

QHash<PreNumber, QPair<qint64, qint64> > QPatternist::AccelTree::sourcePositions

Definition at line 277 of file qacceltree_p.h.

Referenced by sourceLocation().

---

The documentation for this class was generated from the following files:

• /src/xmlpatterns/acceltree/qacceltree_p.h
• /src/xmlpatterns/acceltree/qacceltree.cpp