public int compareTo(Collator collator, AtomicValue other) throws XPathException {
   if (other.getType() == getType()) {
     // filling in missing timezones with local timezone, should be total order as per XPath 2.0
     // 10.4
     int r = getImplicitCalendar().compare(((AbstractDateTimeValue) other).getImplicitCalendar());
     if (r == DatatypeConstants.INDETERMINATE)
       throw new RuntimeException("indeterminate order between " + this + " and " + other);
     return r;
   }
   throw new XPathException(
       "Type error: cannot compare "
           + Type.getTypeName(getType())
           + " to "
           + Type.getTypeName(other.getType()));
 }
예제 #2
0
 /* (non-Javadoc)
  * @see org.exist.xquery.value.AtomicValue#compareTo(int, org.exist.xquery.value.AtomicValue)
  */
 public boolean compareTo(Collator collator, int operator, AtomicValue other)
     throws XPathException {
   if (other.isEmpty()) return false;
   if (Type.subTypeOf(other.getType(), Type.STRING)
       || Type.subTypeOf(other.getType(), Type.UNTYPED_ATOMIC)) {
     int cmp = Collations.compare(collator, value, other.getStringValue());
     switch (operator) {
       case Constants.EQ:
         return cmp == 0;
       case Constants.NEQ:
         return cmp != 0;
       case Constants.LT:
         return cmp < 0;
       case Constants.LTEQ:
         return cmp <= 0;
       case Constants.GT:
         return cmp > 0;
       case Constants.GTEQ:
         return cmp >= 0;
       default:
         throw new XPathException("Type error: cannot apply operand to string value");
     }
   }
   throw new XPathException(
       "Type error: operands are not comparable; expected xdt:untypedAtomic; got "
           + Type.getTypeName(other.getType()));
 }
 // override for xs:time
 public ComputableValue plus(ComputableValue other) throws XPathException {
   switch (other.getType()) {
     case Type.YEAR_MONTH_DURATION:
     case Type.DAY_TIME_DURATION:
       return other.plus(this);
     default:
       throw new XPathException(
           "Operand to plus should be of type xdt:dayTimeDuration or xdt:yearMonthDuration; got: "
               + Type.getTypeName(other.getType()));
   }
 }
  public Object toJavaObject(Class target) throws XPathException {
    if (target == Object.class || target.isAssignableFrom(DateValue.class)) return this;
    else if (target.isAssignableFrom(XMLGregorianCalendar.class)) return calendar.clone();
    else if (target.isAssignableFrom(GregorianCalendar.class))
      return calendar.toGregorianCalendar();
    else if (target == Date.class) return calendar.toGregorianCalendar().getTime();

    throw new XPathException(
        "cannot convert value of type "
            + Type.getTypeName(getType())
            + " to Java object of type "
            + target.getName());
  }
예제 #5
0
 public AtomicValue convertTo(int requiredType) throws XPathException {
   switch (requiredType) {
     case Type.GDAY:
     case Type.ATOMIC:
     case Type.ITEM:
       return this;
     case Type.STRING:
       return new StringValue(getStringValue());
     case Type.UNTYPED_ATOMIC:
       return new UntypedAtomicValue(getStringValue());
     default:
       throw new XPathException(
           "Type error: cannot cast xs:time to " + Type.getTypeName(requiredType));
   }
 }
예제 #6
0
 public int compareTo(Collator collator, AtomicValue other) throws XPathException {
   if (other.getType() == getType()) {
     if (!getTimezone().isEmpty()) {
       if (!((AbstractDateTimeValue) other).getTimezone().isEmpty()) {
         if (!((DayTimeDurationValue) getTimezone().itemAt(0))
             .compareTo(
                 null,
                 Constants.EQ,
                 (DayTimeDurationValue) ((AbstractDateTimeValue) other).getTimezone().itemAt(0)))
           return DatatypeConstants.LESSER;
       } else {
         if (!((DayTimeDurationValue) getTimezone().itemAt(0)).getStringValue().equals("PT0S"))
           return DatatypeConstants.LESSER;
       }
     } else {
       if (!((AbstractDateTimeValue) other).getTimezone().isEmpty()) {
         if (!((DayTimeDurationValue) ((AbstractDateTimeValue) other).getTimezone().itemAt(0))
             .getStringValue()
             .equals("PT0S")) return DatatypeConstants.LESSER;
       }
     }
     // filling in missing timezones with local timezone, should be total order as per XPath 2.0
     // 10.4
     int r =
         this.getImplicitCalendar().compare(((AbstractDateTimeValue) other).getImplicitCalendar());
     // getImplicitCalendar().compare(((AbstractDateTimeValue) other).getImplicitCalendar());
     if (r == DatatypeConstants.INDETERMINATE)
       throw new RuntimeException("indeterminate order between " + this + " and " + other);
     return r;
   }
   throw new XPathException(
       "Type error: cannot compare "
           + Type.getTypeName(getType())
           + " to "
           + Type.getTypeName(other.getType()));
 }
예제 #7
0
 public MemoryNodeSet toMemNodeSet() throws XPathException {
   if (count == 0) {
     return MemoryNodeSet.EMPTY;
   }
   if (itemType == Type.ANY_TYPE || !Type.subTypeOf(itemType, Type.NODE)) {
     throw new XPathException(
         "Type error: the sequence cannot be converted into"
             + " a node set. Item type is "
             + Type.getTypeName(itemType));
   }
   NodeValue v;
   for (int i = 0; i <= count; i++) {
     v = (NodeValue) items[i];
     if (v.getImplementationType() == NodeValue.PERSISTENT_NODE) {
       return null;
     }
   }
   return new ValueSequence(this);
 }
예제 #8
0
  /* (non-Javadoc)
   * @see org.exist.xquery.value.Item#toJavaObject(java.lang.Class)
   */
  public Object toJavaObject(Class target) throws XPathException {
    if (target.isAssignableFrom(UntypedAtomicValue.class)) return this;
    else if (target == Object.class || target == String.class || target == CharSequence.class)
      return value;
    else if (target == double.class || target == Double.class) {
      DoubleValue v = (DoubleValue) convertTo(Type.DOUBLE);
      return new Double(v.getValue());
    } else if (target == float.class || target == Float.class) {
      FloatValue v = (FloatValue) convertTo(Type.FLOAT);
      return new Float(v.value);
    } else if (target == long.class || target == Long.class) {
      IntegerValue v = (IntegerValue) convertTo(Type.LONG);
      return new Long(v.getInt());
    } else if (target == int.class || target == Integer.class) {
      IntegerValue v = (IntegerValue) convertTo(Type.INT);
      return new Integer(v.getInt());
    } else if (target == short.class || target == Short.class) {
      IntegerValue v = (IntegerValue) convertTo(Type.SHORT);
      return new Short((short) v.getInt());
    } else if (target == byte.class || target == Byte.class) {
      IntegerValue v = (IntegerValue) convertTo(Type.BYTE);
      return new Byte((byte) v.getInt());
    } else if (target == boolean.class || target == Boolean.class) {
      return Boolean.valueOf(effectiveBooleanValue());
    } else if (target == char.class || target == Character.class) {
      if (value.length() > 1 || value.length() == 0)
        throw new XPathException(
            "cannot convert string with length = 0 or length > 1 to Java character");
      return new Character(value.charAt(0));
    }

    throw new XPathException(
        "cannot convert value of type "
            + Type.getTypeName(getType())
            + " to Java object of type "
            + target.getName());
  }
예제 #9
0
 /* (non-Javadoc)
  * @see org.exist.xquery.value.Sequence#toNodeSet()
  */
 public NodeSet toNodeSet() throws XPathException {
   // for this method to work, all items have to be nodes
   if (itemType != Type.ANY_TYPE && Type.subTypeOf(itemType, Type.NODE)) {
     final NodeSet set = new ExtArrayNodeSet();
     // We can't make it from an ExtArrayNodeSet (probably because it is sorted ?)
     // NodeSet set = new ArraySet(100);
     for (int i = 0; i < this.count; i++) {
       NodeValue v = null;
       final Entry temp = items[i];
       v = (NodeValue) temp.item;
       if (v.getImplementationType() != NodeValue.PERSISTENT_NODE) {
         set.add((NodeProxy) v);
       } else {
         set.add((NodeProxy) v);
       }
     }
     return set;
   } else {
     throw new XPathException(
         "Type error: the sequence cannot be converted into"
             + " a node set. Item type is "
             + Type.getTypeName(itemType));
   }
 }
예제 #10
0
 /* (non-Javadoc)
  * @see org.exist.xquery.value.Sequence#convertTo(int)
  */
 public AtomicValue convertTo(int requiredType) throws XPathException {
   switch (requiredType) {
     case Type.ATOMIC:
     case Type.ITEM:
     case Type.UNTYPED_ATOMIC:
       return this;
     case Type.STRING:
       return new StringValue(value);
     case Type.ANY_URI:
       return new AnyURIValue(value);
     case Type.BOOLEAN:
       String trimmed = StringValue.trimWhitespace(value);
       if (trimmed.equals("0") || trimmed.equals("false")) return BooleanValue.FALSE;
       else if (trimmed.equals("1") || trimmed.equals("true")) return BooleanValue.TRUE;
       else
         throw new XPathException(
             "FORG0001: cannot cast '"
                 + Type.getTypeName(this.getItemType())
                 + "(\""
                 + getStringValue()
                 + "\")' to "
                 + Type.getTypeName(requiredType));
     case Type.FLOAT:
       return new FloatValue(value);
     case Type.DOUBLE:
       return new DoubleValue(this);
     case Type.NUMBER:
       // TODO : more complicated
       return new DoubleValue(this);
     case Type.DECIMAL:
       return new DecimalValue(getStringValue());
     case Type.INTEGER:
     case Type.NON_POSITIVE_INTEGER:
     case Type.NEGATIVE_INTEGER:
     case Type.LONG:
     case Type.INT:
     case Type.SHORT:
     case Type.BYTE:
     case Type.NON_NEGATIVE_INTEGER:
     case Type.UNSIGNED_LONG:
     case Type.UNSIGNED_INT:
     case Type.UNSIGNED_SHORT:
     case Type.UNSIGNED_BYTE:
       return new IntegerValue(value, requiredType);
     case Type.BASE64_BINARY:
       return new Base64Binary(value);
     case Type.HEX_BINARY:
       return new HexBinary(value);
     case Type.DATE_TIME:
       return new DateTimeValue(value);
     case Type.TIME:
       return new TimeValue(value);
     case Type.DATE:
       return new DateValue(value);
     case Type.GYEAR:
       return new GYearValue(value);
     case Type.GMONTH:
       return new GMonthValue(value);
     case Type.GDAY:
       return new GDayValue(value);
     case Type.GYEARMONTH:
       return new GYearMonthValue(value);
     case Type.GMONTHDAY:
       return new GMonthDayValue(value);
     case Type.DURATION:
       return new DurationValue(value);
     case Type.YEAR_MONTH_DURATION:
       return new YearMonthDurationValue(value);
     case Type.DAY_TIME_DURATION:
       DayTimeDurationValue dtdv = new DayTimeDurationValue(value);
       return new DayTimeDurationValue(dtdv.getCanonicalDuration());
     default:
       throw new XPathException(
           "FORG0001: cannot cast '"
               + Type.getTypeName(this.getItemType())
               + "(\""
               + getStringValue()
               + "\")' to "
               + Type.getTypeName(requiredType));
   }
 }
예제 #11
0
 public ComputableValue minus(ComputableValue other) throws XPathException {
   throw new XPathException(
       "Subtraction is not supported on values of type " + Type.getTypeName(getType()));
 }
 public ComputableValue div(ComputableValue other) throws XPathException {
   throw new XPathException("division is not supported for type " + Type.getTypeName(getType()));
 }
 public ComputableValue mult(ComputableValue other) throws XPathException {
   throw new XPathException(
       "multiplication is not supported for type " + Type.getTypeName(getType()));
 }
 public boolean effectiveBooleanValue() throws XPathException {
   throw new XPathException(
       "FORG0006: effective boolean value invalid operand type: " + Type.getTypeName(getType()));
 }