Item::Ptr Divide::execute(const AnyAtomicType::Ptr &atom1, const AnyAtomicType::Ptr &atom2, DynamicContext *context) const
{
if(atom1 == NULLRCP || atom2 == NULLRCP) return 0;
if(atom1->isNumericValue()) {
if(atom2->isNumericValue()) {
return (const Item::Ptr)((Numeric*)(const AnyAtomicType*)atom1)->divide((const Numeric::Ptr )atom2, context);
}
else {
XQThrow(XPath2ErrorException,X("Divide::createSequence"), X("An attempt to divide a numeric type by a non-numeric type has occurred [err:XPTY0004]"));
}
}
if(atom1->getPrimitiveTypeIndex() == AnyAtomicType::DAY_TIME_DURATION ||
atom1->getPrimitiveTypeIndex() == AnyAtomicType::YEAR_MONTH_DURATION) {
const ATDurationOrDerived* duration = (const ATDurationOrDerived*)atom1.get();
if(atom2->isNumericValue()) {
return (const Item::Ptr)duration->divide((const Numeric *)atom2.get(), context);
}
else if(atom2->getPrimitiveTypeIndex() == AnyAtomicType::DAY_TIME_DURATION ||
atom2->getPrimitiveTypeIndex() == AnyAtomicType::YEAR_MONTH_DURATION) {
return (const Item::Ptr)duration->divide((const ATDurationOrDerived*)atom2.get(), context);
}
else {
XQThrow(XPath2ErrorException,X("Divide::createSequence"), X("An attempt to divide an xs:duration by an invalid type has occured [err:XPTY0004]"));
}
}
else {
XQThrow(XPath2ErrorException,X("Divide::createSequence"), X("The operator div has been called on invalid operand types [err:XPTY0004]"));
}
return 0;
}
Item::Ptr Multiply::execute(const AnyAtomicType::Ptr &atom1, const AnyAtomicType::Ptr &atom2, DynamicContext *context) const
{
if(atom1.isNull() || atom2.isNull()) return 0;
// xs:double * xs:duration (only xdt:dayTimeDuration and xdt:yearMonthDuration)
if(atom1->isNumericValue() &&
(atom2->getPrimitiveTypeIndex() == AnyAtomicType::DAY_TIME_DURATION ||
atom2->getPrimitiveTypeIndex() == AnyAtomicType::YEAR_MONTH_DURATION)) {
return ((const ATDurationOrDerived*)atom2.get())->multiply((const Numeric*)atom1.get(), context);
}
// xs:duration * xs:double (only xdt:dayTimeDuration and xdt:yearMonthDuration)
if(atom2->isNumericValue() &&
(atom1->getPrimitiveTypeIndex() == AnyAtomicType::DAY_TIME_DURATION ||
atom1->getPrimitiveTypeIndex() == AnyAtomicType::YEAR_MONTH_DURATION)) {
return ((const ATDurationOrDerived*)atom1.get())->multiply((const Numeric*)atom2.get(), context);
}
// numeric * numeric
if(atom1->isNumericValue()) {
if(atom2->isNumericValue()) {
return ((const Numeric*)atom1.get())->multiply((const Numeric*)atom2.get(), context);
}
else {
XQThrow(XPath2ErrorException,X("Multiply::createSequence"), X("An attempt to multiply a non numeric type to a numeric type has occurred [err:XPTY0004]"));
}
}
XQThrow(XPath2ErrorException,X("Multiply::createSequence"), X("The operator * has been called on invalid operand types [err:XPTY0004]"));
}
/* returns true if the two objects
* false otherwise */
bool ATGYearOrDerivedImpl::equals(const AnyAtomicType::Ptr &target, const DynamicContext* context) const {
if(this->getPrimitiveTypeIndex() != target->getPrimitiveTypeIndex()) {
XQThrow2(::IllegalArgumentException,X("ATGYearOrDerivedImpl::equals"),
X("Equality operator for given types not supported [err:XPTY0004]"));
}
return compare((const ATGYearOrDerived *)target.get(), context) == 0;
}
static inline AnyAtomicType::AtomicObjectType getSortType(const AnyAtomicType::Ptr &a)
{
switch(a->getPrimitiveTypeIndex()) {
case AnyAtomicType::ANY_URI:
case AnyAtomicType::UNTYPED_ATOMIC:
case AnyAtomicType::STRING: return AnyAtomicType::STRING;
case AnyAtomicType::DECIMAL:
case AnyAtomicType::FLOAT:
case AnyAtomicType::DOUBLE: return AnyAtomicType::DOUBLE;
case AnyAtomicType::DAY_TIME_DURATION:
case AnyAtomicType::YEAR_MONTH_DURATION:
case AnyAtomicType::DURATION: return AnyAtomicType::DURATION;
case AnyAtomicType::BASE_64_BINARY: return AnyAtomicType::BASE_64_BINARY;
case AnyAtomicType::BOOLEAN: return AnyAtomicType::BOOLEAN;
case AnyAtomicType::DATE: return AnyAtomicType::DATE;
case AnyAtomicType::DATE_TIME: return AnyAtomicType::DATE_TIME;
case AnyAtomicType::G_DAY: return AnyAtomicType::G_DAY;
case AnyAtomicType::G_MONTH: return AnyAtomicType::G_MONTH;
case AnyAtomicType::G_MONTH_DAY: return AnyAtomicType::G_MONTH_DAY;
case AnyAtomicType::G_YEAR: return AnyAtomicType::G_YEAR;
case AnyAtomicType::G_YEAR_MONTH: return AnyAtomicType::G_YEAR_MONTH;
case AnyAtomicType::HEX_BINARY: return AnyAtomicType::HEX_BINARY;
case AnyAtomicType::NOTATION: return AnyAtomicType::NOTATION;
case AnyAtomicType::QNAME: return AnyAtomicType::QNAME;
case AnyAtomicType::TIME: return AnyAtomicType::TIME;
default: break;
}
assert(false); // Not supported
return AnyAtomicType::STRING;
}
Result XQNameExpression::createResult(DynamicContext* context, int flags) const
{
AnyAtomicType::Ptr itemName = getExpression()->createResult(context)->next(context);
switch(itemName->getPrimitiveTypeIndex()) {
case AnyAtomicType::QNAME:
return (Item::Ptr)itemName;
case AnyAtomicType::STRING:
case AnyAtomicType::UNTYPED_ATOMIC:
try {
return (Item::Ptr)context->getItemFactory()->createDerivedFromAtomicType(AnyAtomicType::QNAME, itemName->asString(context), context);
}
catch(XQException &) {
XQThrow(ASTException,X("XQNameExpression::NameExpressionResult::createResult"),
X("The name expression cannot be converted to a xs:QName [err:XQDY0074]"));
}
default:
break;
}
XMLBuffer buf;
buf.set(X("The name expression must be a single xs:QName, xs:string or xs:untypedAtomic"));
buf.append(X(" - found item of type "));
itemName->typeToBuffer(context, buf);
buf.append(X(" [err:XPTY0004]"));
XQThrow(XPath2TypeMatchException, X("XQNameExpression::NameExpressionResult::createResult"), buf.getRawBuffer());
}
/*static*/ bool Equals::equals(const AnyAtomicType::Ptr &atom1, const AnyAtomicType::Ptr &atom2, Collation* collation, DynamicContext* context, const LocationInfo *info)
{
try {
// take care of the special case first
if(atom1->getPrimitiveTypeIndex() == AnyAtomicType::STRING) {
if(atom2->getPrimitiveTypeIndex() != AnyAtomicType::STRING &&
atom2->getPrimitiveTypeIndex() != AnyAtomicType::ANY_URI) {
XQThrow3(XPath2ErrorException,X("Equals::equals"), X("An attempt to compare a string type to a non string type has occurred [err:XPTY0004]"), info);
}
// if the function returns 0, then they are equal
return (collation->compare(atom1->asString(context),atom2->asString(context))==0);
}
return atom1->equals(atom2, context);
}
catch(XQException &e) {
if(e.getXQueryLine() == 0)
e.setXQueryPosition(info);
throw;
}
}
bool GeneralComp::compare(GeneralComp::ComparisonOperation operation, AnyAtomicType::Ptr first, AnyAtomicType::Ptr second,
Collation* collation, DynamicContext *context, bool xpath1compat, const LocationInfo *info)
{
// The magnitude relationship between two atomic values is determined as follows:
// 1) If either atomic value has the dynamic type xdt:untypedAtomic, that value is cast to a required type,
// which is determined as follows:
// - If the dynamic type of the other atomic value is a numeric type, the required type is xs:double.
// - If the dynamic type of the other atomic value is xdt:untypedAtomic, the required type is xs:string.
// - Otherwise, the required type is the dynamic type of the other atomic value.
// If the cast to the required type fails, a dynamic error is raised.
// 2) If XPath 1.0 compatibility mode is true, and at least one of the atomic values has a numeric type,
// then both atomic values are cast to to the type xs:double.
// 3) After any necessary casting, the atomic values are compared using one of the value comparison operators
// eq, ne, lt, le, gt, or ge, depending on whether the general comparison operator was
// =, !=, <, <=, >, or >=. The values have the required magnitude relationship if the result of this
// value comparison is true.
if(first->getPrimitiveTypeIndex() == AnyAtomicType::UNTYPED_ATOMIC) {
if (second->isNumericValue()) {
first = first->castAs(AnyAtomicType::DOUBLE, context);
}
else if(second->getPrimitiveTypeIndex() == AnyAtomicType::UNTYPED_ATOMIC) {
first = first->castAs(AnyAtomicType::STRING, context);
}
else {
first = first->castAs(second->getPrimitiveTypeIndex(),
second->getTypeURI(),
second->getTypeName(), context);
}
}
if(second->getPrimitiveTypeIndex() == AnyAtomicType::UNTYPED_ATOMIC) {
if(first->isNumericValue()) {
second = second->castAs(AnyAtomicType::DOUBLE, context);
}
else if(first->getPrimitiveTypeIndex() == AnyAtomicType::UNTYPED_ATOMIC) {
second = second->castAs(AnyAtomicType::STRING, context);
}
else {
second = second->castAs(first->getPrimitiveTypeIndex(),
first->getTypeURI(),
first->getTypeName(), context);
}
}
if(xpath1compat && (first->isNumericValue() || second->isNumericValue())) {
first = first->castAs(AnyAtomicType::DOUBLE, context);
second = second->castAs(AnyAtomicType::DOUBLE, context);
}
bool result = false;
switch(operation) {
case GeneralComp::EQUAL: result = Equals::equals(first,second,collation,context,info); break;
case GeneralComp::NOT_EQUAL: result = NotEquals::not_equals(first,second,collation,context,info); break;
case GeneralComp::LESS_THAN: result = LessThan::less_than(first,second,collation,context,info); break;
case GeneralComp::LESS_THAN_EQUAL: result = LessThanEqual::less_than_equal(first,second,collation,context,info); break;
case GeneralComp::GREATER_THAN: result = GreaterThan::greater_than(first,second,collation,context,info); break;
case GeneralComp::GREATER_THAN_EQUAL: result = GreaterThanEqual::greater_than_equal(first,second,collation,context,info); break;
default: assert(false);
}
return result;
}
/* returns true if the two objects' URI are equal (string comparison)
* false otherwise */
bool ATUntypedAtomicImpl::equals(const AnyAtomicType::Ptr &target, const DynamicContext* context) const {
if(this->getPrimitiveTypeIndex() != target->getPrimitiveTypeIndex()) {
XQThrow2(IllegalArgumentException,X("ATUntypedAtomicImpl::equals"), X("Equality operator for given types not supported [err:XPTY0004]"));
}
return XPath2Utils::equals(target->asString(context), _value);
}
/*static*/ bool GreaterThan::greater_than(const AnyAtomicType::Ptr &atom1, const AnyAtomicType::Ptr &atom2, Collation* collation, DynamicContext* context, const LocationInfo *info)
{
try {
// take care of Numeric types first
if(atom1->isNumericValue()) {
if(atom2->isNumericValue()) {
return ((Numeric*)(const AnyAtomicType*)atom1)->greaterThan((const Numeric::Ptr )atom2, context);
} else {
XQThrow2(XPath2ErrorException,X("GreaterThan::greater_than"), X("An attempt to compare a numeric type to a non numeric type has occurred [err:XPTY0004]"));
}
}
switch(atom1->getPrimitiveTypeIndex()) {
case AnyAtomicType::BOOLEAN:
{
// op:boolean-greater-than(A, B)
if(atom2->getPrimitiveTypeIndex() != AnyAtomicType::BOOLEAN)
XQThrow2(XPath2ErrorException,X("GreaterThan::greater_than"), X("An attempt to compare a boolean type to a non boolean type has occurred [err:XPTY0004]"));
return ((const ATBooleanOrDerived*)atom1.get())->compare((const ATBooleanOrDerived*)atom2.get(), context) > 0;
}
case AnyAtomicType::STRING:
case AnyAtomicType::ANY_URI:
{
// use function compare
if(atom2->getPrimitiveTypeIndex() != AnyAtomicType::STRING &&
atom2->getPrimitiveTypeIndex() != AnyAtomicType::ANY_URI)
XQThrow2(XPath2ErrorException,X("GreaterThan::greater_than"), X("An attempt to compare a string type to a non string type has occurred [err:XPTY0004]"));
// if the function returns 1, then atom1 is greater
return collation->compare(atom1->asString(context),atom2->asString(context))>0;
}
case AnyAtomicType::DATE:
{
// op:date-greater-than(A, B)
if(atom2->getPrimitiveTypeIndex() != AnyAtomicType::DATE)
XQThrow2(XPath2ErrorException,X("GreaterThan::greater_than"), X("An attempt to compare a date type to a non date type has occurred [err:XPTY0004]"));
return ((ATDateOrDerived*)atom1.get())->compare((const ATDateOrDerived::Ptr )atom2, context) > 0;
}
case AnyAtomicType::TIME:
{
// op:time-greater-than(A, B)
if(atom2->getPrimitiveTypeIndex() != AnyAtomicType::TIME)
XQThrow2(XPath2ErrorException,X("GreaterThan::greater_than"), X("An attempt to compare a time type to a non time type has occurred [err:XPTY0004]"));
return ((ATTimeOrDerived*)atom1.get())->compare((const ATTimeOrDerived::Ptr )atom2, context) > 0;
}
case AnyAtomicType::DATE_TIME:
{
// op:datetime-greater-than(A, B)
if(atom2->getPrimitiveTypeIndex() != AnyAtomicType::DATE_TIME)
XQThrow2(XPath2ErrorException,X("GreaterThan::greater_than"), X("An attempt to compare a dateTime type to a non dateTime type has occurred [err:XPTY0004]"));
return ((ATDateTimeOrDerived*)atom1.get())->compare((const ATDateTimeOrDerived::Ptr)atom2, context) > 0;
}
case AnyAtomicType::DAY_TIME_DURATION:
{
if(atom2->getPrimitiveTypeIndex() != AnyAtomicType::DAY_TIME_DURATION)
XQThrow2(XPath2ErrorException,X("GreaterThan::greater_than"), X("An attempt to compare a duration type to a non duration type has occurred [err:XPTY0004]"));
return ((const ATDurationOrDerived*)atom1.get())->compare((const ATDurationOrDerived*)atom2.get(), context) > 0;
}
case AnyAtomicType::YEAR_MONTH_DURATION:
{
if(atom2->getPrimitiveTypeIndex() != AnyAtomicType::YEAR_MONTH_DURATION)
XQThrow2(XPath2ErrorException,X("GreaterThan::greater_than"), X("An attempt to compare a duration type to a non duration type has occurred [err:XPTY0004]"));
return ((const ATDurationOrDerived*)atom1.get())->compare((const ATDurationOrDerived*)atom2.get(), context) > 0;
}
default:
XQThrow2(XPath2ErrorException,X("GreaterThan::greater_than"), X("Unexpected data type in operator 'gt' [err:XPTY0004]"));
}
XQThrow2(FunctionException,X("GreaterThan::greater_than"), X("An equality operator is not defined for the provided arguments [err:XPTY0004]"));
}
catch(XQException &e) {
if(e.getXQueryLine() == 0)
e.setXQueryPosition(info);
throw;
}
}