Item::Ptr UTransform::TransformResult::next(DynamicContext *context)
{
context->testInterrupt();
AutoVariableStoreReset reset(context, &scope_);
if(toDo_) {
toDo_ = false;
NodeSet copiedNodes = NodeSet(nodecompare(context));
VectorOfCopyBinding::const_iterator end = transform_->getBindings()->end();
for(VectorOfCopyBinding::const_iterator it = transform_->getBindings()->begin();
it != end; ++it) {
if((*it)->qname_ == 0) continue;
Sequence values = (*it)->expr_->createResult(context)->toSequence(context);
// Keep a record of the nodes that have been copied
Result valIt = values;
Item::Ptr val;
while((val = valIt->next(context)).notNull()) {
copiedNodes.insert((Node*)val.get());
}
scope_.setVar((*it)->uri_, (*it)->name_, values);
}
// Get the pending update list
PendingUpdateList pul = transform_->getModifyExpr()->createUpdateList(context);
// Check that the targets of the pending updates are copied nodes
for(PendingUpdateList::const_iterator i = pul.begin(); i != pul.end(); ++i) {
Node::Ptr target = i->getTarget();
while(copiedNodes.find(target) == copiedNodes.end()) {
target = target->dmParent(context);
if(target.isNull()) {
XQThrow3(StaticErrorException,X("UTransform::staticTyping"),
X("The target node of an update expression in the transform expression is not a node from the copy clauses [err:XUDY0014]"), &(*i));
}
}
}
// Apply the updates
AutoDelete<UpdateFactory> ufactory(context->createUpdateFactory());
ufactory->applyUpdates(pul, context, transform_->getRevalidationMode());
// Execute the return expression
result_ = transform_->getReturnExpr()->createResult(context);
}
Item::Ptr result = result_->next(context);
if(result.isNull()) {
result_ = 0;
return 0;
}
return result;
}
Sequence FunctionBaseURI::createSequence(DynamicContext* context, int flags) const
{
Node::Ptr node = (Node*)getParamNumber(1, context)->next(context).get();
if(node.isNull()) return Sequence(context->getMemoryManager());
return node->dmBaseURI(context);
}
bool SequenceType::ItemType::matches(const Node::Ptr &toBeTested, DynamicContext* context) const
{
switch(m_nTestType) {
case TEST_ELEMENT:
{
if(toBeTested->dmNodeKind() != Node::element_string)
return false;
if(!matchesNameType(toBeTested, context))
return false;
// if the element has xsi:nil="true", m_bAllowNil MUST be true
if(toBeTested->dmNilled(context)->isTrue() && !m_bAllowNil)
return false;
return true;
}
case TEST_ATTRIBUTE:
{
if(toBeTested->dmNodeKind() != Node::attribute_string)
return false;
if(!matchesNameType(toBeTested, context))
return false;
return true;
}
case TEST_SCHEMA_ELEMENT:
{
if(toBeTested->dmNodeKind() != Node::element_string)
return false;
return matchesSchemaElement(toBeTested, context);
}
case TEST_SCHEMA_ATTRIBUTE:
{
if(toBeTested->dmNodeKind() != Node::attribute_string)
return false;
// retrieve the type of the attribute name
assert(m_pName!=NULL);
const XMLCh* attributeNS=m_NameURI;
const XMLCh* attributeName=m_pName->getName();
SchemaAttDef* attrDecl=context->getDocumentCache()->getAttributeDecl(attributeNS, attributeName);
assert(attrDecl != NULL);
// 1. The name of the candidate node matches the specified AttributeName
ATQNameOrDerived::Ptr name = toBeTested->dmNodeName(context);
if(name.isNull()) return false;
const XMLCh *node_uri = ((const ATQNameOrDerived*)name.get())->getURI();
const XMLCh *node_name = ((const ATQNameOrDerived*)name.get())->getName();
if(!(XPath2Utils::equals(attributeName, node_name)) ||
!(XPath2Utils::equals(attributeNS, node_uri)))
return false;
// 2. derives-from(AT, ET) is true, where AT is the type of the candidate node and ET is the type declared
// for attribute AttributeName in the in-scope attribute declarations.
DatatypeValidator* pDV=attrDecl->getDatatypeValidator();
if(pDV && !toBeTested->hasInstanceOfType(pDV->getTypeUri(), pDV->getTypeLocalName(), context))
return false;
return true;
}
case TEST_PI:
{
if(toBeTested->dmNodeKind() != Node::processing_instruction_string)
return false;
if(!matchesNameType(toBeTested, context))
return false;
return true;
}
case TEST_COMMENT:
{
return (toBeTested->dmNodeKind() == Node::comment_string);
}
case TEST_TEXT:
{
return (toBeTested->dmNodeKind() == Node::text_string);
}
case TEST_SCHEMA_DOCUMENT:
case TEST_DOCUMENT:
{
if(toBeTested->dmNodeKind() != Node::document_string)
return false;
if(m_pName == NULL && m_pType == NULL)
return true;
// if we have a constraint on name/type, they apply to the document element
Result children = toBeTested->dmChildren(context, 0);
Node::Ptr docElement;
while((docElement = children->next(context)).notNull() &&
docElement->dmNodeKind() != Node::element_string) {}
if(docElement.isNull()) return false;
if(m_nTestType == TEST_DOCUMENT)
return matchesNameType(docElement, context);
else
return matchesSchemaElement(docElement, context);
}
case TEST_NODE:
case TEST_ANYTHING:
{
return true;
}
case TEST_ATOMIC_TYPE:
case TEST_FUNCTION:
{
return false;
}
}
return true;
}