QVariant QObjectXmlModel::typedValue(const QXmlNodeModelIndex &n) const
{
switch (toNodeType(n))
{
case QObjectProperty:
{
const QVariant &candidate = toMetaProperty(n).read(asQObject(n));
if (isTypeSupported(candidate.type()))
return candidate;
else
return QVariant();
}
case MetaObjectClassName:
return QVariant(static_cast<QMetaObject*>(n.internalPointer())->className());
case MetaObjectSuperClass:
{
const QMetaObject *const superClass = static_cast<QMetaObject*>(n.internalPointer())->superClass();
if (superClass)
return QVariant(superClass->className());
else
return QVariant();
}
case QObjectClassName:
return QVariant(asQObject(n)->metaObject()->className());
default:
return QVariant();
}
}
void tst_QXmlNodeModelIndex::internalPointer() const
{
/* Check default value. */
{
const QXmlNodeModelIndex index;
QCOMPARE(index.internalPointer(), static_cast<void *>(0));
}
}
void tst_QXmlNodeModelIndex::model() const
{
/* Check default value. */
{
const QXmlNodeModelIndex index;
QCOMPARE(index.model(), static_cast<const QAbstractXmlNodeModel *>(0));
}
}
void tst_QXmlNodeModelIndex::additionalData() const
{
/* Check default value. */
{
const QXmlNodeModelIndex index;
QCOMPARE(index.additionalData(), qint64(0));
}
// TODO check that the return value for data() is qint64.
}
void QAbstractXmlReceiver::sendFromAxis(const QXmlNodeModelIndex &node)
{
Q_ASSERT(!node.isNull());
const QXmlNodeModelIndex::Iterator::Ptr it(node.iterate(axis));
QXmlNodeModelIndex next(it->next());
while(!next.isNull())
{
sendAsNode(next);
next = it->next();
}
}
QXmlNodeModelIndex QObjectXmlModel::metaObjectSibling(const int pos, const QXmlNodeModelIndex &n) const
{
Q_ASSERT(pos == 1 || pos == -1);
Q_ASSERT(!n.isNull());
const int indexOf = m_allMetaObjects.indexOf(static_cast<const QMetaObject *>(n.internalPointer())) + pos;
if (indexOf >= 0 && indexOf < m_allMetaObjects.count())
return createIndex(const_cast<QMetaObject *>(m_allMetaObjects.at(indexOf)), MetaObject);
else
return QXmlNodeModelIndex();
}
void tst_QXmlNodeModelIndex::isNull() const
{
/* Check default value. */
{
const QXmlNodeModelIndex index;
QVERIFY(index.isNull());
}
/* Test default value on a temporary object. */
{
QVERIFY(QXmlNodeModelIndex().isNull());
}
}
bool XsdInstanceReader::hasChildElement() const
{
const QXmlNodeModelIndex index = m_model.index();
QXmlNodeModelIndex::Iterator::Ptr it = index.model()->iterate(index, QXmlNodeModelIndex::AxisChild);
QXmlNodeModelIndex currentIndex = it->next();
while (!currentIndex.isNull()) {
if (currentIndex.kind() == QXmlNodeModelIndex::Element)
return true;
currentIndex = it->next();
}
return false;
}
QXmlNodeModelIndex::DocumentOrder AccelTree::compareOrder(const QXmlNodeModelIndex &ni1,
const QXmlNodeModelIndex &ni2) const
{
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;
}
/*!
Returns the typed value for \a node, which must be either an
attribute or an element. The QVariant returned represents the atomic
value of an attribute or the atomic value contained in an element.
If the QVariant is returned as a default constructed variant,
it means that \a node has no typed value.
*/
QVariant FileTree::typedValue(const QXmlNodeModelIndex &node) const
{
const QFileInfo &fi = toFileInfo(node);
switch (Type(node.additionalData())) {
case Directory:
// deliberate fall through.
case File:
return QString();
case AttributeFileName:
return fi.fileName();
case AttributeFilePath:
return fi.filePath();
case AttributeSize:
return fi.size();
case AttributeMIMEType:
{
/* We don't have any MIME detection code currently, so return
* the most generic one. */
return QLatin1String("application/octet-stream");
}
case AttributeSuffix:
return fi.suffix();
}
Q_ASSERT_X(false, Q_FUNC_INFO, "This line should never be reached.");
return QString();
}
/*!
\internal
Treats \a outputItem as a node and calls the appropriate function,
e.g., attribute() or comment(), depending on its
QXmlNodeModelIndex::NodeKind.
This is a helper function that subclasses can use to multiplex
Nodes received via item().
*/
void QAbstractXmlReceiver::sendAsNode(const QPatternist::Item &outputItem)
{
Q_ASSERT(outputItem);
Q_ASSERT(outputItem.isNode());
const QXmlNodeModelIndex asNode = outputItem.asNode();
switch(asNode.kind())
{
case QXmlNodeModelIndex::Attribute:
{
const QString &v = outputItem.stringValue();
attribute(asNode.name(), QStringRef(&v));
return;
}
case QXmlNodeModelIndex::Element:
{
startElement(asNode.name());
/* First the namespaces, then attributes, then the children. */
asNode.sendNamespaces(this);
sendFromAxis<QXmlNodeModelIndex::AxisAttribute>(asNode);
sendFromAxis<QXmlNodeModelIndex::AxisChild>(asNode);
endElement();
return;
}
case QXmlNodeModelIndex::Text:
{
const QString &v = asNode.stringValue();
characters(QStringRef(&v));
return;
}
case QXmlNodeModelIndex::ProcessingInstruction:
{
processingInstruction(asNode.name(), outputItem.stringValue());
return;
}
case QXmlNodeModelIndex::Comment:
{
comment(outputItem.stringValue());
return;
}
case QXmlNodeModelIndex::Document:
{
startDocument();
sendFromAxis<QXmlNodeModelIndex::AxisChild>(asNode);
endDocument();
return;
}
case QXmlNodeModelIndex::Namespace:
Q_ASSERT_X(false, Q_FUNC_INFO, "Not implemented");
}
Q_ASSERT_X(false, Q_FUNC_INFO,
QString::fromLatin1("Unknown node type: %1").arg(asNode.kind()).toUtf8().constData());
}
QHash<QXmlName, QXmlItem> PullBridge::attributeItems()
{
Q_ASSERT(m_current == StartElement);
QHash<QXmlName, QXmlItem> attributes;
QXmlNodeModelIndex::Iterator::Ptr it = m_index.iterate(QXmlNodeModelIndex::AxisAttribute);
QXmlNodeModelIndex index = it->next();
while (!index.isNull()) {
const Item attribute(index);
attributes.insert(index.name(), QXmlItem(index));
index = it->next();
}
return attributes;
}
QString XsdInstanceReader::text() const
{
const QXmlNodeModelIndex index = m_model.index();
QXmlNodeModelIndex::Iterator::Ptr it = index.model()->iterate(index, QXmlNodeModelIndex::AxisChild);
QString result;
QXmlNodeModelIndex currentIndex = it->next();
while (!currentIndex.isNull()) {
if (currentIndex.kind() == QXmlNodeModelIndex::Text) {
result.append(Item(currentIndex).stringValue());
}
currentIndex = it->next();
}
return result;
}
/*!
This function returns QXmlNodeModelIndex::Element if \a node
is a directory or a file, and QXmlNodeModelIndex::Attribute
otherwise.
*/
QXmlNodeModelIndex::NodeKind
FileTree::kind(const QXmlNodeModelIndex &node) const
{
switch (Type(node.additionalData())) {
case Directory:
case File:
return QXmlNodeModelIndex::Element;
default:
return QXmlNodeModelIndex::Attribute;
}
}
/*!
Returns the attributes of \a element. The caller guarantees
that \a element is an element in this node model.
*/
QVector<QXmlNodeModelIndex>
FileTree::attributes(const QXmlNodeModelIndex &element) const
{
QVector<QXmlNodeModelIndex> result;
/* Both elements has this attribute. */
const QFileInfo &forElement = toFileInfo(element);
result.append(toNodeIndex(forElement, AttributeFilePath));
result.append(toNodeIndex(forElement, AttributeFileName));
if (Type(element.additionalData() == File)) {
result.append(toNodeIndex(forElement, AttributeSize));
result.append(toNodeIndex(forElement, AttributeSuffix));
//result.append(toNodeIndex(forElement, AttributeMIMEType));
}
else {
Q_ASSERT(element.additionalData() == Directory);
}
return result;
}
Item AxisStep::mapToItem(const QXmlNodeModelIndex &node,
const DynamicContext::Ptr &context) const
{
Q_ASSERT(!node.isNull());
Q_ASSERT(Item(node).isNode());
Q_ASSERT(Item(node));
Q_UNUSED(context);
if(m_nodeTest->itemMatches(Item(node)))
return Item(node);
else
return Item();
}
void AccelTree::copyChildren(const QXmlNodeModelIndex &node,
QAbstractXmlReceiver *const receiver,
const NodeCopySettings &settings) const
{
QXmlNodeModelIndex::Iterator::Ptr children(node.iterate(QXmlNodeModelIndex::AxisChild));
QXmlNodeModelIndex child(children->next());
while(!child.isNull())
{
copyNodeTo(child, receiver, settings);
child = children->next();
}
}
void ContextNodeChecker::checkTargetNode(const QXmlNodeModelIndex &node,
const DynamicContext::Ptr &context,
const ReportContext::ErrorCode code) const
{
if(node.root().kind() != QXmlNodeModelIndex::Document)
{
context->error(QtXmlPatterns::tr("The root node of the second argument "
"to function %1 must be a document "
"node. %2 is not a document node.")
.arg(formatFunction(context->namePool(), signature()),
formatData(node)),
code, this);
}
}
Item LangFN::evaluateSingleton(const DynamicContext::Ptr &context) const
{
const Item langArg(m_operands.first()->evaluateSingleton(context));
const QString lang(langArg ? langArg.stringValue() : QString());
const QXmlName xmlLang(StandardNamespaces::xml, StandardLocalNames::lang, StandardPrefixes::xml);
const QXmlNodeModelIndex langNode(m_operands.at(1)->evaluateSingleton(context).asNode());
const QXmlNodeModelIndex::Iterator::Ptr ancestors(langNode.iterate(QXmlNodeModelIndex::AxisAncestorOrSelf));
QXmlNodeModelIndex ancestor(ancestors->next());
while(!ancestor.isNull())
{
const QXmlNodeModelIndex::Iterator::Ptr attributes(ancestor.iterate(QXmlNodeModelIndex::AxisAttribute));
QXmlNodeModelIndex attribute(attributes->next());
while(!attribute.isNull())
{
Q_ASSERT(attribute.kind() == QXmlNodeModelIndex::Attribute);
if(attribute.name() == xmlLang)
{
if(isLangMatch(attribute.stringValue(), lang))
return CommonValues::BooleanTrue;
else
return CommonValues::BooleanFalse;
}
attribute = attributes->next();
}
ancestor = ancestors->next();
}
return CommonValues::BooleanFalse;
}
void AccelTree::sendNamespaces(const QXmlNodeModelIndex &n,
QAbstractXmlReceiver *const receiver) const
{
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();
}
}
void tst_QXmlNodeModelIndex::constCorrectness() const
{
const QXmlNodeModelIndex index;
/* All these functions should be const. */
index.internalPointer();
index.data();
index.additionalData();
index.isNull();
index.model();
}
//! [4]
QXmlNodeModelIndex
FileTree::nextFromSimpleAxis(SimpleAxis axis, const QXmlNodeModelIndex &nodeIndex) const
{
const QFileInfo fi(toFileInfo(nodeIndex));
const Type type = Type(nodeIndex.additionalData());
if (type != File && type != Directory) {
Q_ASSERT_X(axis == Parent, Q_FUNC_INFO, "An attribute only has a parent!");
return toNodeIndex(fi, Directory);
}
switch (axis) {
case Parent:
return toNodeIndex(QFileInfo(fi.path()), Directory);
case FirstChild:
{
if (type == File) // A file has no children.
return QXmlNodeModelIndex();
else {
Q_ASSERT(type == Directory);
Q_ASSERT_X(fi.isDir(), Q_FUNC_INFO, "It isn't really a directory!");
const QDir dir(fi.absoluteFilePath());
Q_ASSERT(dir.exists());
const QFileInfoList children(dir.entryInfoList(QStringList(),
m_filterAllowAll,
m_sortFlags));
if (children.isEmpty())
return QXmlNodeModelIndex();
const QFileInfo firstChild(children.first());
return toNodeIndex(firstChild);
}
}
case PreviousSibling:
return nextSibling(nodeIndex, fi, -1);
case NextSibling:
return nextSibling(nodeIndex, fi, 1);
}
Q_ASSERT_X(false, Q_FUNC_INFO, "Don't ever get here!");
return QXmlNodeModelIndex();
}
void QAbstractXmlReceiver::sendAsNode(const Item &outputItem)
{
Q_ASSERT(outputItem);
Q_ASSERT(outputItem.isNode());
const QXmlNodeModelIndex asNode = outputItem.asNode();
switch(asNode.kind())
{
case QXmlNodeModelIndex::Attribute:
{
attribute(asNode.name(), outputItem.stringValue());
break;
}
case QXmlNodeModelIndex::Element:
{
startElement(asNode.name());
/* First the namespaces, then attributes, then the children. */
asNode.sendNamespaces(Ptr(const_cast<QAbstractXmlReceiver *>(this)));
sendFromAxis<QXmlNodeModelIndex::AxisAttribute>(asNode);
sendFromAxis<QXmlNodeModelIndex::AxisChild>(asNode);
endElement();
break;
}
case QXmlNodeModelIndex::Text:
{
characters(outputItem.stringValue());
break;
}
case QXmlNodeModelIndex::ProcessingInstruction:
{
processingInstruction(asNode.name(), outputItem.stringValue());
break;
}
case QXmlNodeModelIndex::Comment:
{
comment(outputItem.stringValue());
break;
}
case QXmlNodeModelIndex::Document:
{
sendFromAxis<QXmlNodeModelIndex::AxisChild>(asNode);
break;
}
case QXmlNodeModelIndex::Namespace:
Q_ASSERT_X(false, Q_FUNC_INFO, "Not implemented");
}
}
QXmlNodeModelIndex::NodeKind LoadingModel::kind(const QXmlNodeModelIndex &ni) const
{
Q_ASSERT(!ni.isNull());
return toInternal(ni)->kind;
}
QVector<QXmlName> XsdInstanceReader::namespaceBindings(const QXmlNodeModelIndex &index) const
{
return index.namespaceBindings();
}
bool QObjectXmlModel::isProperty(const QXmlNodeModelIndex n)
{
return n.additionalData() & QObjectProperty;
}
void AccelTree::copyNodeTo(const QXmlNodeModelIndex &node,
QAbstractXmlReceiver *const receiver,
const NodeCopySettings &settings) const
{
/* 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);
}
}
QMetaProperty QObjectXmlModel::toMetaProperty(const QXmlNodeModelIndex &n)
{
const int propertyOffset = n.additionalData() & (~QObjectProperty);
const QObject *const qo = asQObject(n);
return qo->metaObject()->property(propertyOffset);
}
QUrl AccelTree::baseUri(const QXmlNodeModelIndex &ni) const
{
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();
}
//! [1]
QObjectXmlModel::QObjectNodeType QObjectXmlModel::toNodeType(const QXmlNodeModelIndex &n)
{
return QObjectNodeType(n.additionalData() & (15 << 26));
}
