SequenceType SequenceType::createAtomicOrUnionType(
const StaticContext_t& sctx,
const String& uri,
const String& localName,
Quantifier quant)
{
TypeManager* tm;
if (sctx == NULL)
{
tm = &GENV_TYPESYSTEM;
}
else
{
static_context* sctx2 = Unmarshaller::getInternalStaticContext(sctx);
tm = sctx2->get_typemanager();
}
zstring& ns = Unmarshaller::getInternalString(uri);
zstring& local = Unmarshaller::getInternalString(localName);
store::Item_t qname;
GENV_ITEMFACTORY->createQName(qname, ns, "", local);
xqtref_t type = tm->create_named_type(qname, quant, QueryLoc::null, false);
if (type->isGenAtomicAny())
return Unmarshaller::createSequenceType(type.getp());
return Unmarshaller::createSequenceType(NULL);
}
SequenceType SequenceType::createElementType(
const StaticContext_t& sctx,
const String& nodeUri,
const String& nodeLocalName,
const String& typeUri,
const String& typeLocalName,
bool nillable,
Quantifier quant)
{
TypeManager* tm;
if (sctx == NULL)
{
tm = &GENV_TYPESYSTEM;
}
else
{
static_context* sctx2 = Unmarshaller::getInternalStaticContext(sctx);
tm = sctx2->get_typemanager();
}
zstring& nodeNS = Unmarshaller::getInternalString(nodeUri);
zstring& nodeLocal = Unmarshaller::getInternalString(nodeLocalName);
store::Item_t nodeQName;
if (!nodeLocal.empty())
GENV_ITEMFACTORY->createQName(nodeQName, nodeNS, "", nodeLocal);
zstring& typeNS = Unmarshaller::getInternalString(typeUri);
zstring& typeLocal = Unmarshaller::getInternalString(typeLocalName);
store::Item_t typeQName;
xqtref_t contentType;
if (!typeLocal.empty())
{
GENV_ITEMFACTORY->createQName(typeQName, typeNS, "", typeLocal);
contentType = tm->create_named_type(typeQName, QUANT_ONE, QueryLoc::null, false);
if (contentType == NULL)
return Unmarshaller::createSequenceType(NULL);
}
xqtref_t res = tm->create_node_type(store::StoreConsts::elementNode,
nodeQName,
contentType,
quant,
nillable,
false);
return Unmarshaller::createSequenceType(res.getp());
}
bool deepEqualNodes(
const QueryLoc& loc,
static_context* sctx,
const store::Item* item1,
const store::Item* item2,
XQPCollator* collator,
int timezone,
bool raiseError)
{
if (item1->getNodeKind() != item2->getNodeKind())
return false;
switch (item1->getNodeKind())
{
case store::StoreConsts::documentNode:
{
return deepEqualChildren(loc,
sctx,
item1->getChildren(),
item2->getChildren(),
collator,
timezone,
raiseError);
break;
}
case store::StoreConsts::elementNode:
{
if (! item1->getNodeName()->equals(item2->getNodeName()))
return false;
if (!deepEqualAttributes(loc,
sctx,
item1->getAttributes(),
item2->getAttributes(),
collator,
timezone,
raiseError))
return false;
if (item1->haveSimpleContent())
{
if (!item2->haveSimpleContent())
return false;
store::Item_t value1, value2;
store::Iterator_t ite1, ite2;
item1->getTypedValue(value1, ite1);
item2->getTypedValue(value2, ite2);
if (ite1 == NULL && ite2 == NULL)
{
return deepEqual(loc, sctx, value1, value2, collator, timezone, raiseError);
}
else if (ite1 != NULL && ite2 != NULL)
{
ite1->open();
ite2->open();
while (1)
{
bool c1Valid = ite1->next(value1);
bool c2Valid = ite2->next(value2);
if (!c1Valid && !c2Valid)
return true;
else if (!c1Valid || !c2Valid)
return false;
else if (!deepEqual(loc, sctx, value1, value2, collator, timezone, raiseError))
return false;
}
}
else
{
return false;
}
}
else if (item2->haveSimpleContent())
{
return false;
}
else
{
store::Item* typename1 = item1->getType();
store::Item* typename2 = item2->getType();
if (typename1->equals(typename2))
{
return deepEqualChildren(loc,
sctx,
item1->getChildren(),
item2->getChildren(),
collator,
timezone,
raiseError);
}
else
{
TypeManager* tm = sctx->get_typemanager();
xqtref_t type1 =
tm->create_named_type(typename1, SequenceType::QUANT_ONE, loc, raiseError);
xqtref_t type2 =
tm->create_named_type(typename2, SequenceType::QUANT_ONE, loc, raiseError);
ZORBA_ASSERT(type1->isComplex() && type2->isComplex());
if (type1->contentKind() != type2->contentKind())
return false;
return deepEqualChildren(loc,
sctx,
item1->getChildren(),
item2->getChildren(),
collator,
timezone,
raiseError);
}
}
break;
}
case store::StoreConsts::attributeNode:
{
if (! item1->getNodeName()->equals(item2->getNodeName()))
return false;
store::Item_t value1, value2;
store::Iterator_t ite1, ite2;
item1->getTypedValue(value1, ite1);
item2->getTypedValue(value2, ite2);
if (ite1 == NULL && ite2 == NULL)
{
return deepEqual(loc, sctx, value1, value2, collator, timezone, raiseError);
}
else if (ite1 != NULL && ite2 != NULL)
{
ite1->open();
ite2->open();
while (1)
{
bool c1Valid = ite1->next(value1);
bool c2Valid = ite2->next(value2);
if (!c1Valid && !c2Valid)
return true;
else if (!c1Valid || !c2Valid)
return false;
else if (!deepEqual(loc, sctx, value1, value2, collator, timezone, raiseError))
return false;
}
}
else
{
return false;
}
break;
}
case store::StoreConsts::textNode:
case store::StoreConsts::commentNode:
{
return (0 == utf8::compare(item1->getStringValue(),
item2->getStringValue(),
collator));
}
case store::StoreConsts::piNode:
{
if (utf8::compare(item1->getNodeName()->getStringValue(),
item2->getNodeName()->getStringValue(),
collator))
return false;
return (0 == utf8::compare(item1->getStringValue(),
item2->getStringValue(),
collator));
}
case store::StoreConsts::namespaceNode:
{
if (utf8::compare(item1->getNamespacePrefix(),
item2->getNamespacePrefix(),
collator))
return false;
return (0 == utf8::compare(item1->getStringValue(),
item2->getStringValue(),
collator));
}
default:
ZORBA_ASSERT(false);
}
return true;
}
