protected Object convertToValue(String txt) { if (datatype instanceof DatabindableDatatype) { DatabindableDatatype bindable = (DatabindableDatatype) datatype; return bindable.createJavaObject(txt, this); } else { return datatype.createValue(txt, this); } } }
public void setData(Object data) { String s = datatype.convertToLexicalValue(data, this); validate(s); this.text = s; this.data = data; }
protected void validate(String txt) throws IllegalArgumentException { try { datatype.checkValid(txt, this); } catch (DatatypeException e) { throw new IllegalArgumentException(e.getMessage()); } }
TypeIncubator incubator = new TypeIncubator(baseType); ValidationContext context = null; incubator.addFacet(name, value, fixed, context); return incubator.derive("", newTypeName); } catch (DatatypeException e) { onSchemaError("Invalid restriction: " + e.getMessage()
/** test singleton-ness of built-in datatypes. */ public void testSingletonness() throws Exception { for( int i=0; i<Const.builtinTypeNames.length; i++ ) { String name = Const.builtinTypeNames[i]; XSDatatype dt = DatatypeFactory.getTypeByName(name); assertNotNull(dt); assertEquals("freeze dry test for "+dt.getName(), freezeDry(dt), dt); // it must be singleton. } }
dataType = DatatypeFactory.getTypeByName(localName); } catch (DatatypeException e) { dataType = DatatypeFactory.getTypeByName(type); } catch (DatatypeException e) {
public final Object _createValue( String literal, ValidationContext context ) { Object o = baseType._createValue(literal,context); if(o==null) return null; int r = ((Comparator)concreteType).compare(limitValue,o); if(!rangeCheck(r)) return null; return o; }
public Object _createValue( String lexicalValue, ValidationContext context ) { Object o = super._createValue(lexicalValue,context); if(o==null) return null; final IntegerValueType v = (IntegerValueType)o; if( !v.isNegative() ) return null; return v; }
public Object _createValue( String lexicalValue, ValidationContext context ) { byte[] buf = load(lexicalValue); if(buf==null) return null; else return new BinaryValueType(buf); }
public Object _createValue( String literal, ValidationContext context ) { Object o = baseType._createValue(literal,context); if(o==null || ((Discrete)concreteType).countLength(o)<minLength) return null; return o; }
private NonNegativeIntegerType() { super("nonNegativeInteger", createRangeFacet(IntegerType.theInstance, IntegerValueType.create("0"),null)); }
final public Object _createJavaObject( String literal, ValidationContext context ) { // TODO: this can be more efficient if(isValid(literal,context)) return baseType.createJavaObject(literal,context); else return null; } public String serializeJavaObject( Object value, SerializationContext context ) {
final protected void _checkValid(String content, ValidationContext context ) throws DatatypeException { // let the base type complain first. baseType._checkValid(content,context); // then see if the facet is satisfied. diagnoseByFacet(content,context); }
private NonPositiveIntegerType() { super("nonPositiveInteger",createRangeFacet( IntegerType.theInstance, null, IntegerValueType.create("0"))); }
public final Object _createValue( String literal, ValidationContext context ) { Object o = baseType._createValue(literal,context); if(o==null) return null; int r = ((Comparator)concreteType).compare(limitValue,o); if(!rangeCheck(r)) return null; return o; }
public void setData(Object data) { String s = datatype.convertToLexicalValue(data, this); validate(s); this.data = data; setText(s); }
public Object getData() { if (data == null) { String text = getTextTrim(); if ((text != null) && (text.length() > 0)) { if (datatype instanceof DatabindableDatatype) { DatabindableDatatype bind = (DatabindableDatatype) datatype; data = bind.createJavaObject(text, this); } else { data = datatype.createValue(text, this); } } } return data; }
protected void validate(String text) throws IllegalArgumentException { try { datatype.checkValid(text, this); } catch (DatatypeException e) { throw new IllegalArgumentException(e.getMessage()); } } }
public final Object _createValue( String literal, ValidationContext context ) { Object o = baseType._createValue(literal,context); if(o==null) return null; int r = ((Comparator)concreteType).compare(limitValue,o); if(!rangeCheck(r)) return null; return o; }