Java XMLDatatypeUtil类代码示例

import org.openrdf.model.datatypes.XMLDatatypeUtil; //导入依赖的package包/类
/**
 * Compares two literal datatypes and indicates if one should be ordered after the other. This
 * algorithm ensures that compatible ordered datatypes (numeric and date/time) are grouped
 * together so that {@link QueryEvaluationUtil#compareLiterals(Literal, Literal, CompareOp)} is
 * used in consecutive ordering steps.
 */
private int compareDatatypes(URI leftDatatype, URI rightDatatype) {
  if (XMLDatatypeUtil.isNumericDatatype(leftDatatype)) {
    if (XMLDatatypeUtil.isNumericDatatype(rightDatatype)) {
      // both are numeric datatypes
      return compareURIs(leftDatatype, rightDatatype);
    } else {
      return -1;
    }
  } else if (XMLDatatypeUtil.isNumericDatatype(rightDatatype)) {
    return 1;
  } else if (XMLDatatypeUtil.isCalendarDatatype(leftDatatype)) {
    if (XMLDatatypeUtil.isCalendarDatatype(rightDatatype)) {
      // both are calendar datatypes
      return compareURIs(leftDatatype, rightDatatype);
    } else {
      return -1;
    }
  } else if (XMLDatatypeUtil.isCalendarDatatype(rightDatatype)) {
    return 1;
  } else {
    // incompatible or unordered datatypes
    return compareURIs(leftDatatype, rightDatatype);
  }
}
 

import org.openrdf.model.datatypes.XMLDatatypeUtil; //导入依赖的package包/类
/**
 * Parse the data type of an XML entity based on its string content
 *
 * @param input The XML entity, in string form
 * @return The entity instance, properly classed
 */
public static Object parseXMLDatatype( String input ) {
	if ( input == null ) {
		return null;
	}
	input = input.trim();
	String[] pieces = input.split( "\"" );
	if ( pieces.length != 3 ) {
		return removeExtraneousDoubleQuotes( input );
	}
	Class<?> theClass = null;
	for ( URI datatypeUri : TYPELOOKUP.keySet() ) {
		if ( pieces[2].contains( datatypeUri.stringValue() ) ) {
			theClass = TYPELOOKUP.get( datatypeUri );
		}
	}
	String dataPiece = pieces[1];
	if ( theClass == Double.class && XMLDatatypeUtil.isValidDouble( dataPiece ) ) {
		return XMLDatatypeUtil.parseDouble( dataPiece );
	}
	if ( theClass == Float.class && XMLDatatypeUtil.isValidFloat( dataPiece ) ) {
		return XMLDatatypeUtil.parseFloat( dataPiece );
	}
	if ( theClass == Integer.class && XMLDatatypeUtil.isValidInteger( dataPiece ) ) {
		return XMLDatatypeUtil.parseInteger( dataPiece );
	}
	if ( theClass == Boolean.class && XMLDatatypeUtil.isValidBoolean( dataPiece ) ) {
		return XMLDatatypeUtil.parseBoolean( dataPiece );
	}
	if ( theClass == Date.class && XMLDatatypeUtil.isValidDate( dataPiece ) ) {
		return XMLDatatypeUtil.parseCalendar( dataPiece );
	}
	return removeExtraneousDoubleQuotes( input );
}
 

import org.openrdf.model.datatypes.XMLDatatypeUtil; //导入依赖的package包/类
private Instant convertToInstant(Literal literal) {
    String stringVal = literal.getLabel();
    URI dataType = literal.getDatatype();
    checkArgument(dataType.equals(XMLSchema.DATETIME) || dataType.equals(XMLSchema.DATE),
            String.format("Invalid data type for date time. Data Type must be of type %s or %s .", XMLSchema.DATETIME, XMLSchema.DATE));
    checkArgument(XMLDatatypeUtil.isValidDateTime(stringVal) || XMLDatatypeUtil.isValidDate(stringVal), "Invalid date time value.");
    return literal.calendarValue().toGregorianCalendar().toInstant();
}
 

import org.openrdf.model.datatypes.XMLDatatypeUtil; //导入依赖的package包/类
private long convertPeriodToMillis(Literal literal, URI unit) {
    String stringVal = literal.getLabel();
    URI dataType = literal.getDatatype();
    checkArgument(dataType.equals(XMLSchema.INTEGER) || dataType.equals(XMLSchema.INT), String
            .format("Invalid data type for period duration. Data Type must be of type %s or %s .", XMLSchema.INTEGER, XMLSchema.INT));
    checkArgument(XMLDatatypeUtil.isValidInteger(stringVal) || XMLDatatypeUtil.isValidInt(stringVal), "Invalid duration value.");
    return convertToMillis(Integer.parseInt(stringVal), unit);
}
 

import org.openrdf.model.datatypes.XMLDatatypeUtil; //导入依赖的package包/类
public boolean isDatatype() {
	if (self instanceof URI
			&& XMLDatatypeUtil.isBuiltInDatatype((URI) self))
		return true;
	if (self.equals(RDFS.LITERAL))
		return true;
	if (self instanceof URI) {
		URI uri = (URI) self;
		if (uri.getNamespace().equals(RDF.NAMESPACE)
				&& uri.getLocalName().equals("PlainLiteral"))
			return true;
	}
	return isA(RDFS.DATATYPE);
}
 

import org.openrdf.model.datatypes.XMLDatatypeUtil; //导入依赖的package包/类
private GeneralDBSqlExpr valueOf(Value value) {
  if (value instanceof Literal) {
    Literal lit = (Literal) value;
    URI dt = lit.getDatatype();
    if (dt != null && XMLDatatypeUtil.isCalendarDatatype(dt)) {
      try {
        return new GeneralDBNumberValue(getCalendarValue(lit.calendarValue()));
      } catch (IllegalArgumentException e) {
        return null;
      }
    }
  }
  return null;
}
 

import org.openrdf.model.datatypes.XMLDatatypeUtil; //导入依赖的package包/类
private GeneralDBSqlExpr valueOf(Value value) {
  if (value instanceof Literal) {
    Literal lit = (Literal) value;
    URI dt = lit.getDatatype();
    if (dt != null && XMLDatatypeUtil.isNumericDatatype(dt)) {
      try {
        return new GeneralDBDoubleValue(lit.doubleValue());
      } catch (NumberFormatException e) {
        return null;
      }
    }
  }
  return null;
}
 

import org.openrdf.model.datatypes.XMLDatatypeUtil; //导入依赖的package包/类
@Override
public void update(final AggregationElement aggregation, final AggregationState state, final VisibilityBindingSet childBindingSet) {
    checkArgument(aggregation.getAggregationType() == AggregationType.AVERAGE, "The AverageFunction only accepts AVERAGE AggregationElements.");
    requireNonNull(state);
    requireNonNull(childBindingSet);

    // Only update the average if the child contains the binding that we are averaging.
    final String aggregatedName = aggregation.getAggregatedBindingName();
    if(childBindingSet.hasBinding(aggregatedName)) {
        final MapBindingSet result = state.getBindingSet();
        final String resultName = aggregation.getResultBindingName();
        final boolean newBinding = !result.hasBinding(resultName);

        // Get the state of the average.
        final Map<String, AverageState> averageStates = state.getAverageStates();
        AverageState averageState = newBinding ? new AverageState() : averageStates.get(resultName);

        // Update the state of the average.
        final Value childValue = childBindingSet.getValue(aggregatedName);
        if(childValue instanceof Literal) {
            final Literal childLiteral = (Literal) childValue;
            if (childLiteral.getDatatype() != null && XMLDatatypeUtil.isNumericDatatype(childLiteral.getDatatype())) {
                try {
                    // Update the sum.
                    final Literal oldSum = new DecimalLiteralImpl(averageState.getSum());
                    final BigDecimal sum = MathUtil.compute(oldSum, childLiteral, MathOp.PLUS).decimalValue();

                    // Update the count.
                    final BigInteger count = averageState.getCount().add( BigInteger.ONE );

                    // Update the BindingSet to include the new average.
                    final Literal sumLiteral = new DecimalLiteralImpl(sum);
                    final Literal countLiteral = new IntegerLiteralImpl(count);
                    final Literal average = MathUtil.compute(sumLiteral, countLiteral, MathOp.DIVIDE);
                    result.addBinding(resultName, average);

                    // Update the average state that is stored.
                    averageState = new AverageState(sum, count);
                    averageStates.put(resultName, averageState);
                } catch (final ValueExprEvaluationException e) {
                    log.error("A problem was encountered while updating an Average Aggregation. This binding set will be ignored: " + childBindingSet);
                    return;
                }
            }
        }
    }
}
 

import org.openrdf.model.datatypes.XMLDatatypeUtil; //导入依赖的package包/类
@Override
public Literal createLiteral(final String label, final URI datatype) {
    try {
        if (datatype == null) {
            return new StringLiteral(label, (String) null);
        } else if (datatype.equals(XMLSchema.STRING)) {
            return new StringLiteral(label, XMLSchema.STRING);
        } else if (datatype.equals(XMLSchema.BOOLEAN)) {
            final boolean value = XMLDatatypeUtil.parseBoolean(label);
            return value ? BooleanLiteralImpl.TRUE : BooleanLiteralImpl.FALSE;
        } else if (datatype.equals(XMLSchema.INT)) {
            return new LongLiteral(XMLSchema.INT, XMLDatatypeUtil.parseInt(label));
        } else if (datatype.equals(XMLSchema.LONG)) {
            return new LongLiteral(XMLSchema.LONG, XMLDatatypeUtil.parseLong(label));
        } else if (datatype.equals(XMLSchema.SHORT)) {
            return new LongLiteral(XMLSchema.SHORT, XMLDatatypeUtil.parseShort(label));
        } else if (datatype.equals(XMLSchema.BYTE)) {
            return new LongLiteral(XMLSchema.BYTE, XMLDatatypeUtil.parseByte(label));
        } else if (datatype.equals(XMLSchema.DOUBLE)) {
            return new DoubleLiteral(XMLSchema.DOUBLE, XMLDatatypeUtil.parseDouble(label));
        } else if (datatype.equals(XMLSchema.FLOAT)) {
            return new DoubleLiteral(XMLSchema.FLOAT, XMLDatatypeUtil.parseFloat(label));
        } else if (datatype.equals(XMLSchema.DATETIME) || datatype.equals(XMLSchema.DATE)
                || datatype.equals(XMLSchema.TIME) || datatype.equals(XMLSchema.GYEARMONTH)
                || datatype.equals(XMLSchema.GMONTHDAY) || datatype.equals(XMLSchema.GYEAR)
                || datatype.equals(XMLSchema.GMONTH) || datatype.equals(XMLSchema.GDAY)) {
            return createLiteral(XMLDatatypeUtil.parseCalendar(label));
        } else if (datatype.equals(XMLSchema.DECIMAL)) {
            return new BigDecimalLiteral(datatype, XMLDatatypeUtil.parseDecimal(label));
        } else if (datatype.equals(XMLSchema.INTEGER)
                || datatype.equals(XMLSchema.NON_NEGATIVE_INTEGER)
                || datatype.equals(XMLSchema.POSITIVE_INTEGER)
                || datatype.equals(XMLSchema.NEGATIVE_INTEGER)) {
            return new BigIntegerLiteral(datatype, XMLDatatypeUtil.parseInteger(label));
        } else {
            return new StringLiteral(label, datatype);
        }
    } catch (final Throwable ex) {
        LOGGER.warn("Illegal literal: '" + label + "'^^<" + datatype + "> (dropping datatype)");
        return createLiteral(label);
    }
}
 

import org.openrdf.model.datatypes.XMLDatatypeUtil; //导入依赖的package包/类
@Override
public boolean booleanValue() {
    return XMLDatatypeUtil.parseBoolean(getLabel());
}
 

import org.openrdf.model.datatypes.XMLDatatypeUtil; //导入依赖的package包/类
@Override
public BigInteger integerValue() {
    return XMLDatatypeUtil.parseInteger(getLabel());
}
 

import org.openrdf.model.datatypes.XMLDatatypeUtil; //导入依赖的package包/类
@Override
public BigDecimal decimalValue() {
    return XMLDatatypeUtil.parseDecimal(getLabel());
}
 

import org.openrdf.model.datatypes.XMLDatatypeUtil; //导入依赖的package包/类
@Override
public XMLGregorianCalendar calendarValue() {
    return XMLDatatypeUtil.parseCalendar(getLabel());
}
 

import org.openrdf.model.datatypes.XMLDatatypeUtil; //导入依赖的package包/类
/**
 * Returns the {@link javax.xml.datatype.XMLGregorianCalendar} value of this literal. A calendar
 * representation can be given for literals whose label conforms to the
 * syntax of the following <a href="http://www.w3.org/TR/xmlschema-2/">XML
 * Schema datatypes</a>: <tt>dateTime</tt>, <tt>time</tt>,
 * <tt>date</tt>, <tt>gYearMonth</tt>, <tt>gMonthDay</tt>,
 * <tt>gYear</tt>, <tt>gMonth</tt> or <tt>gDay</tt>.
 *
 * @return The calendar value of the literal.
 * @throws IllegalArgumentException If the literal cannot be represented by a
 *                                  {@link javax.xml.datatype.XMLGregorianCalendar}.
 */
@Override
public XMLGregorianCalendar calendarValue() {
    try {
        return XMLDatatypeUtil.parseCalendar(getLabel());
    } catch(IllegalArgumentException ex) {
        // try harder to parse the label, sometimes they have stupid formats ...
        Date cv = DateUtils.parseDate(getLabel());
        return DateUtils.getXMLCalendar(cv);
    }
}