void
GraphvizFunction::printTypeAndAttr(
ItemFactory* aFactory,
const Item& in,
std::fstream& os)
{
Item lItem;
Item lTypeQName = aFactory->createQName("", "", "type");
Item lAttrQName = aFactory->createQName("", "", "attr");
Iterator_t lChildren = in.getChildren();
lChildren->open();
while (lChildren->next(lItem)) {
// needed?
if (!lItem.isNode())
continue;
Item lNodeName;
lItem.getNodeName(lNodeName);
if (lNodeName.getLocalName() != lAttrQName.getLocalName()) {
Item lNameAttr;
if (!getAttribute(aFactory, "name", lItem, lNameAttr)) {
GraphvizFunction::throwErrorWithQName(aFactory, "IM003", "GXL parse error: attr node does not have a name attribute");
}
os << " \"" << lNameAttr.getStringValue() << "\"=\"";
// get the values of all bool, string, float, and int elements
Iterator_t lAttrChildren = lItem.getChildren();
Item lChild;
lAttrChildren->open();
while (lAttrChildren->next(lChild)) {
if (!lChild.isNode())
continue;
Item lNodeName;
lChild.getNodeName(lNodeName);
String lChildName = lNodeName.getLocalName();
if ( (lChildName == "bool") || (lChildName == "string")
|| (lChildName == "float") || (lChildName == "int")) {
os << lChild.getStringValue();
}
}
os << "\"" << std::endl;
} else if (lNodeName.getStringValue() == lTypeQName.getStringValue()) {
Item lHRefAttr;
if (!getAttribute(aFactory, "href", lItem, lHRefAttr)) {
GraphvizFunction::throwErrorWithQName(aFactory, "IM003", "GXL parse error: type node does not have a href attribute");
}
os << " _gxl_type=\"" << lHRefAttr.getStringValue() << "\"" << std::endl;
}
}
}
bool DeepEqualFN::evaluateEBV(const DynamicContext::Ptr &context) const
{
const Item::Iterator::Ptr it1(m_operands.first()->evaluateSequence(context));
const Item::Iterator::Ptr it2(m_operands.at(1)->evaluateSequence(context));
while(true)
{
const Item item1(it1->next());
const Item item2(it2->next());
if(!item1)
{
if(item2)
return false;
else
return true;
}
else if(!item2)
{
if(item1)
return false;
else
return true;
}
else if(item1.isNode())
{
if(item2.isNode())
{
if(item1.asNode().isDeepEqual(item2.asNode()))
continue;
else
return false;
}
else
return false;
}
else if(item2.isNode())
{
/* We know that item1 is not a node due to the check above. */
return false;
}
else if(flexibleCompare(item1, item2, context))
continue;
else if(BuiltinTypes::numeric->itemMatches(item1) &&
item1.as<Numeric>()->isNaN() &&
item2.as<Numeric>()->isNaN())
{
// TODO
/* Handle the specific NaN circumstances. item2 isn't checked whether it's of
* type numeric, since the AtomicComparator lookup would have failed if both weren't
* numeric. */
continue;
}
else
return false;
};
}
void
GraphvizFunction::gxl2dot(
ItemFactory* aFactory,
const Item& in, std::fstream& os)
{
Item lGXLQName = aFactory->createQName("", "", "gxl");
Item lGraphQName = aFactory->createQName("", "", "graph");
if (!in.isNode()) {
GraphvizFunction::throwErrorWithQName(aFactory, "IM003", "GXL parse error: item is not a node");
}
Item lNodeName;
in.getNodeName(lNodeName);
if (lNodeName.getLocalName() != lGXLQName.getLocalName()) {
Item lNodeName;
in.getNodeName(lNodeName);
std::ostringstream lErrorMsg;
lErrorMsg << "GXL parse error: only element with name "
<< lGXLQName.getStringValue() << " allowed (got " << lNodeName.getStringValue()
<< ").";
GraphvizFunction::throwErrorWithQName(aFactory, "IM003", lErrorMsg.str());
}
Iterator_t lGraphs = in.getChildren();
lGraphs->open();
Item lGraph;
while(lGraphs->next(lGraph)) {
if (!lGraph.isNode()) {
GraphvizFunction::throwErrorWithQName(aFactory, "IM003", "GXL parse error: item is not a node");
}
lGraph.getNodeName(lNodeName);
if (lNodeName.getLocalName() != lGraphQName.getLocalName()) {
std::ostringstream lErrorMsg;
Item lNodeName;
lGraph.getNodeName(lNodeName);
lErrorMsg << "GXL parse error: only elements with name "
<< lGraphQName.getStringValue() << " allowed (got "
<< lNodeName.getLocalName() << ").";
GraphvizFunction::throwErrorWithQName(aFactory, "IM003", lErrorMsg.str());
}
printGraph(aFactory, lGraph, os);
}
} /* GraphvizFunction::gxl2dot */
bool Boolean::evaluateEBV(const Item &first,
const Item::Iterator::Ptr &it,
const QExplicitlySharedDataPointer<DynamicContext> &context)
{
Q_ASSERT(it);
Q_ASSERT(context);
if(!first)
return false;
else if(first.isNode())
return true;
const Item second(it->next());
if(second)
{
Q_ASSERT(context);
context->error(QtXmlPatterns::tr("Effective Boolean Value cannot be calculated for a sequence "
"containing two or more atomic values."),
ReportContext::FORG0006,
QSourceLocation());
return false;
}
else
return first.as<AtomicValue>()->evaluateEBV(context);
}
bool XSLTNodeTest::itemMatches(const Item &item) const
{
Q_ASSERT(item);
return item.isNode() &&
item.asNode().kind() != QXmlNodeModelIndex::Document;
}
Item GenericPredicate::mapToItem(const Item &item,
const DynamicContext::Ptr &context) const
{
const Item::Iterator::Ptr it(m_operand2->evaluateSequence(context));
const Item pcateItem(it->next());
if(!pcateItem)
return Item(); /* The predicate evaluated to the empty sequence */
else if(pcateItem.isNode())
return item;
/* Ok, now it must be an AtomicValue */
else if(BuiltinTypes::numeric->xdtTypeMatches(pcateItem.type()))
{ /* It's a positional predicate. */
if(it->next())
{
context->error(QtXmlPatterns::tr("A positional predicate must "
"evaluate to a single numeric "
"value."),
ReportContext::FORG0006, this);
return Item();
}
if(Double::isEqual(static_cast<xsDouble>(context->contextPosition()),
pcateItem.as<Numeric>()->toDouble()))
{
return item;
}
else
return Item();
}
else if(Boolean::evaluateEBV(pcateItem, it, context)) /* It's a truth predicate. */
return item;
else
return Item();
}
bool BuiltinNodeType<kind>::itemMatches(const Item &item) const
{
Q_ASSERT(item);
return item.isNode() &&
item.asNode().kind() == kind;
}
bool NodeSortExpression::lessThanUsingNodeModel(const Item &n1,
const Item &n2)
{
Q_ASSERT(n1.isNode());
Q_ASSERT(n2.isNode());
if(n1.asNode().model() == n2.asNode().model())
return n1.asNode().compareOrder(n2.asNode()) == QXmlNodeModelIndex::Precedes;
else
{
/* The two nodes are from different trees. The sort order is implementation
* defined, but it must be stable.
*
* We do this by looking at the pointer difference. The value means nothing,
* but it is stable, and that's what we're looking for. */
return n1.asNode().model() - n2.asNode().model() < 0;
}
}
bool NumericType::itemMatches(const Item &item) const
{
if(item.isNode())
return false;
return BuiltinTypes::xsDouble->itemMatches(item) ||
BuiltinTypes::xsDecimal->itemMatches(item) ||
BuiltinTypes::xsFloat->itemMatches(item);
}
bool Boolean::evaluateEBV(const Item &item,
const QExplicitlySharedDataPointer<DynamicContext> &context)
{
if(!item)
return false;
else if(item.isNode())
return true;
else
return item.as<AtomicValue>()->evaluateEBV(context);
}
bool AtomicType::itemMatches(const Item &item) const
{
Q_ASSERT(item);
if(item.isNode())
return false;
else
{
const SchemaType::Ptr t(static_cast<AtomicType *>(item.type().data()));
return wxsTypeMatches(t);
}
}
void DocumentContentValidator::item(const Item &outputItem)
{
/* We can't send outputItem directly to m_receiver since its item() function
* won't dispatch to this DocumentContentValidator, but to itself. We're not sub-classing here,
* we're delegating. */
if(outputItem.isNode())
sendAsNode(outputItem);
else
m_receiver->item(outputItem);
}
bool EBVType::itemMatches(const Item &item) const
{
if(item.isNode())
return false;
return BuiltinTypes::xsBoolean->itemMatches(item) ||
BuiltinTypes::numeric->itemMatches(item) ||
BuiltinTypes::xsString->itemMatches(item) ||
BuiltinTypes::xsAnyURI->itemMatches(item) ||
CommonSequenceTypes::Empty->itemMatches(item) ||
BuiltinTypes::xsUntypedAtomic->itemMatches(item);
}
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");
}
}
void OutputValidator::item(const Item &outputItem)
{
/* We can't send outputItem directly to m_receiver since its item() function
* won't dispatch to this OutputValidator, but to itself. We're not sub-classing here,
* we're delegating. */
if(outputItem.isNode())
sendAsNode(outputItem);
else
{
m_hasReceivedChildren = true;
m_receiver->item(outputItem);
}
}
QString XSLTSimpleContentConstructor::processItem(const Item &item,
bool &discard,
bool &isText)
{
if(item.isNode())
{
isText = (item.asNode().kind() == QXmlNodeModelIndex::Text);
if(isText)
{
const QString value(item.stringValue());
/* "1. Zero-length text nodes in the sequence are discarded." */
discard = value.isEmpty();
return value;
}
else
{
Item::Iterator::Ptr it(item.sequencedTypedValue()); /* Atomic values. */
Item next(it->next());
QString result;
if(next)
result = next.stringValue();
next = it->next();
while(next)
{
result += next.stringValue();
result += QLatin1Char(' ');
next = it->next();
}
return result;
}
}
else
{
discard = false;
isText = false;
return item.stringValue();
}
}
bool AnyNodeType::itemMatches(const Item &item) const
{
return item.isNode();
}
bool LocalNameTest::itemMatches(const Item &item) const
{
Q_ASSERT(item.isNode());
return m_primaryType->itemMatches(item) &&
item.asNode().name().localName() == m_ncName;
}
bool NamespaceNameTest::itemMatches(const Item &item) const
{
Q_ASSERT(item.isNode());
return m_primaryType->itemMatches(item) &&
item.asNode().name().namespaceURI() == m_namespaceURI;
}
