diff options
Diffstat (limited to 'tests/auto/qabstractxmlnodemodel/LoadingModel.cpp')
| -rw-r--r-- | tests/auto/qabstractxmlnodemodel/LoadingModel.cpp | 360 |
1 files changed, 360 insertions, 0 deletions
diff --git a/tests/auto/qabstractxmlnodemodel/LoadingModel.cpp b/tests/auto/qabstractxmlnodemodel/LoadingModel.cpp new file mode 100644 index 0000000..fbc28d6 --- /dev/null +++ b/tests/auto/qabstractxmlnodemodel/LoadingModel.cpp @@ -0,0 +1,360 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the test suite 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 <QFile> +#include <QStack> + +#ifdef QTEST_XMLPATTERNS +#include <QXmlNamePool> +#include <QXmlStreamReader> +#include <QtDebug> +#include <QTest> + +#include "LoadingModel.h" +LoadingModel::LoadingModel(const Node::Vector &content, + const QXmlNamePool &np) : QSimpleXmlNodeModel(np) + , m_nodes(content) +{ + Q_ASSERT(!content.isEmpty()); + /* + foreach(const Node *n, content) + qDebug() << "this:" << n + << "kind:" << n->kind + << "parent: " << n->parent + << "preceding: " << n->precedingSibling + << "following: " << n->followingSibling + << "firstChild: " << n->firstChild + << "value: " << n->value; + */ +} + +LoadingModel::~LoadingModel() +{ + qDeleteAll(m_nodes); +} + +const LoadingModel::Node *LoadingModel::toInternal(const QXmlNodeModelIndex &ni) const +{ + return static_cast<const Node *>(ni.internalPointer()); +} + +QXmlNodeModelIndex LoadingModel::createIndex(const Node *const internal) const +{ + Q_ASSERT_X(internal, Q_FUNC_INFO, + "We shouldn't construct from null pointers."); + return QAbstractXmlNodeModel::createIndex(const_cast<Node *>(internal)); +} + +QUrl LoadingModel::documentUri(const QXmlNodeModelIndex &) const +{ + Q_ASSERT(false); + return QUrl(); +} + +QXmlNodeModelIndex::NodeKind LoadingModel::kind(const QXmlNodeModelIndex &ni) const +{ + Q_ASSERT(!ni.isNull()); + return toInternal(ni)->kind; +} + +QXmlNodeModelIndex::DocumentOrder LoadingModel::compareOrder(const QXmlNodeModelIndex &n1, const QXmlNodeModelIndex &n2) const +{ + const Node *const in1 = toInternal(n1); + const Node *const in2 = toInternal(n2); + Q_ASSERT(m_nodes.indexOf(in1) != -1); + Q_ASSERT(m_nodes.indexOf(in2) != -1); + + if(in1 == in2) + return QXmlNodeModelIndex::Is; + else if(m_nodes.indexOf(in1) < m_nodes.indexOf(in2)) + return QXmlNodeModelIndex::Precedes; + else + return QXmlNodeModelIndex::Follows; +} + +QXmlNodeModelIndex LoadingModel::root(const QXmlNodeModelIndex &) const +{ + Q_ASSERT(kind(createIndex(m_nodes.first())) == QXmlNodeModelIndex::Document); + return createIndex(m_nodes.first()); +} + +QXmlName LoadingModel::name(const QXmlNodeModelIndex &ni) const +{ + return toInternal(ni)->name; +} + +QVariant LoadingModel::typedValue(const QXmlNodeModelIndex &ni) const +{ + const Node *const internal = toInternal(ni); + + Q_ASSERT(internal->kind == QXmlNodeModelIndex::Attribute + || internal->kind == QXmlNodeModelIndex::Element); + + return internal->value; +} + +QString LoadingModel::stringValue(const QXmlNodeModelIndex &ni) const +{ + const Node *const internal = toInternal(ni); + + switch(internal->kind) + { + case QXmlNodeModelIndex::Text: + /* Fallthrough. */ + case QXmlNodeModelIndex::ProcessingInstruction: + /* Fallthrough. */ + case QXmlNodeModelIndex::Comment: + /* Fallthrough. */ + case QXmlNodeModelIndex::Attribute: + return internal->value; + default: + return QString(); + } +} + +QXmlNodeModelIndex LoadingModel::nextFromSimpleAxis(QAbstractXmlNodeModel::SimpleAxis axis, + const QXmlNodeModelIndex &ni) const +{ + const Node *const internal = toInternal(ni); + + /* Note that a QXmlNodeModelIndex containing a null pointer is not a null node. */ + switch(axis) + { + case Parent: + return internal->parent ? createIndex(internal->parent) : QXmlNodeModelIndex(); + case FirstChild: + return internal->firstChild ? createIndex(internal->firstChild) : QXmlNodeModelIndex(); + case PreviousSibling: + return internal->precedingSibling ? createIndex(internal->precedingSibling) : QXmlNodeModelIndex(); + case NextSibling: + return internal->followingSibling ? createIndex(internal->followingSibling) : QXmlNodeModelIndex(); + } + + Q_ASSERT(false); + return QXmlNodeModelIndex(); +} + +QVector<QXmlNodeModelIndex> LoadingModel::attributes(const QXmlNodeModelIndex &ni) const +{ + QVector<QXmlNodeModelIndex> retval; + foreach(const Node *n, toInternal(ni)->attributes) + retval.append(createIndex(n)); + + return retval; +} + +class Loader +{ +public: + inline Loader(const QXmlNamePool &namePool) : m_namePool(namePool) + , m_currentNode(0) + { + m_parentStack.push(0); + } + +private: + inline void adjustSiblings(LoadingModel::Node *const justBorn); + friend class LoadingModel; + Q_DISABLE_COPY(Loader); + + void load(); + + QXmlNamePool m_namePool; + QXmlStreamReader m_reader; + LoadingModel::Node::Vector m_result; + LoadingModel::Node * m_currentNode; + QStack<LoadingModel::Node *> m_parentStack; +}; + +inline void Loader::adjustSiblings(LoadingModel::Node *const justBorn) +{ + if(m_currentNode) + { + if(m_currentNode->parent == justBorn->parent) + justBorn->precedingSibling = m_currentNode; + + m_currentNode->followingSibling = justBorn; + } + + m_currentNode = justBorn; + + /* Otherwise we're the first child, and our precedingSibling should remain null. */ + + if(m_parentStack.top() && !m_parentStack.top()->firstChild) + m_parentStack.top()->firstChild = justBorn; +} + +void Loader::load() +{ + QFile in(QLatin1String("tree.xml")); + + /* LoadingModel::m_result will be null, signalling failure. */ + if(!in.open(QIODevice::ReadOnly)) + return; + + QXmlStreamReader reader(&in); + while(!reader.atEnd()) + { + reader.readNext(); + + switch(reader.tokenType()) + { + case QXmlStreamReader::StartDocument: + /* Fallthrough. */ + case QXmlStreamReader::StartElement: + { + QXmlName name; + if(reader.tokenType() == QXmlStreamReader::StartElement) + { + name = QXmlName(m_namePool, + reader.name().toString(), + reader.namespaceUri().toString(), + reader.prefix().toString()); + } + /* Else, the name is null. */ + + LoadingModel::Node *const tmp = new LoadingModel::Node(reader.tokenType() == QXmlStreamReader::StartElement + ? QXmlNodeModelIndex::Element + : QXmlNodeModelIndex::Document, + m_parentStack.top(), + QString(), + name); + m_result.append(tmp); + + if(m_currentNode) + { + if(m_currentNode->parent == m_parentStack.top()) + m_currentNode->followingSibling = tmp; + } + + const QXmlStreamAttributes attributes(reader.attributes()); + const int len = attributes.count(); + + for(int i = 0; i < len; ++i) + { + const QXmlStreamAttribute &attr = attributes.at(i); + const LoadingModel::Node *const a = new LoadingModel::Node(QXmlNodeModelIndex::Attribute, + m_parentStack.top(), + attr.value().toString(), + QXmlName(m_namePool, + attr.name().toString(), + attr.namespaceUri().toString(), + attr.prefix().toString())); + /* We add it also to m_result such that compareOrder() is correct + * for attributes. m_result owns a. */ + tmp->attributes.append(a); + m_result.append(a); + } + + adjustSiblings(tmp); + m_parentStack.push(m_currentNode); + break; + } + case QXmlStreamReader::EndDocument: + /* Fallthrough. */ + case QXmlStreamReader::EndElement: + { + m_currentNode->followingSibling = 0; + m_currentNode = m_parentStack.pop(); + + if(reader.tokenType() == QXmlStreamReader::EndDocument) + const_cast<LoadingModel::Node *>(m_result.first())->followingSibling = 0; + + break; + } + case QXmlStreamReader::Characters: + { + LoadingModel::Node *const tmp = new LoadingModel::Node(QXmlNodeModelIndex::Text, m_parentStack.top(), reader.text().toString()); + m_result.append(tmp); + adjustSiblings(tmp); + break; + } + case QXmlStreamReader::ProcessingInstruction: + { + LoadingModel::Node *const tmp = new LoadingModel::Node(QXmlNodeModelIndex::ProcessingInstruction, + m_parentStack.top(), + reader.processingInstructionData().toString(), + QXmlName(m_namePool, reader.processingInstructionTarget().toString())); + m_result.append(tmp); + adjustSiblings(tmp); + break; + } + case QXmlStreamReader::Comment: + { + LoadingModel::Node *const tmp = new LoadingModel::Node(QXmlNodeModelIndex::Comment, m_parentStack.top(), reader.text().toString()); + m_result.append(tmp); + adjustSiblings(tmp); + break; + } + case QXmlStreamReader::DTD: + /* Fallthrough. */ + case QXmlStreamReader::EntityReference: + { + Q_ASSERT_X(false, Q_FUNC_INFO, + "We don't support this."); + /* Fallthrough. */ + } + case QXmlStreamReader::NoToken: + /* Fallthrough. */ + case QXmlStreamReader::Invalid: + { + qWarning(qPrintable(reader.errorString())); + m_result.clear(); + return; + } + } + } + + if(reader.hasError()) + { + qWarning(qPrintable(reader.errorString())); + m_result.clear(); + } +} + +QAbstractXmlNodeModel::Ptr LoadingModel::create(const QXmlNamePool &np) +{ + Loader loader(np); + loader.load(); + return Ptr(new LoadingModel(loader.m_result, np)); +} +#endif //QTEST_XMLPATTERNS |