📄 xsddatatype.java
字号:
* in default mode for load which may provide diagnostic output direct to stderr)
*/
public static List loadUserDefined(String uri, String encoding, TypeMapper tm) throws DatatypeFormatException {
return loadUserDefined(new XMLInputSource(null, uri, uri), tm);
}
/**
* Internal implementation of loadUserDefined
*
* @param uri the absolute uri of the schema file to be loaded
* @param reader the Reader stream onto the file (useful if you wish to load a cached copy of the schema file)
* @param encoding the encoding of the source file (can be null)
* @param tm the type mapper into which to load the definitions
* @return a List of strings giving the uri's of the newly defined datatypes
* @throws DatatypeFormatException if there is a problem during load (not that we use Xerces
* in default mode for load which may provide diagnostic output direct to stderr)
*/
private static List loadUserDefined(XMLInputSource source, TypeMapper tm) throws DatatypeFormatException {
XMLGrammarPreparser parser = new XMLGrammarPreparser();
parser.registerPreparser(XMLGrammarDescription.XML_SCHEMA, null);
try {
XSGrammar xsg = (XSGrammar) parser.preparseGrammar(XMLGrammarDescription.XML_SCHEMA, source);
org.apache.xerces.xs.XSModel xsm = xsg.toXSModel();
XSNamedMap map = xsm.getComponents(XSTypeDefinition.SIMPLE_TYPE);
int numDefs = map.getLength();
ArrayList names = new ArrayList(numDefs);
for (int i = 0; i < numDefs; i++) {
XSSimpleType xstype = (XSSimpleType) map.item(i);
// Filter built in types - only needed for 2.6.0
if ( ! XSD.equals(xstype.getNamespace()) ) {
//xstype.derivedFrom()
XSDDatatype definedType = new XSDGenericType(xstype, source.getSystemId());
tm.registerDatatype(definedType);
names.add(definedType.getURI());
}
}
return names;
} catch (Exception e) {
e.printStackTrace(); // Temp
throw new DatatypeFormatException(e.toString());
}
}
/**
* Convert a validated xerces data value into the corresponding java data value.
* This function is currently the most blatently xerces-version dependent part
* of this subsystem. In many cases it also involves reparsing data which has
* already been parsed as part of the validation.
*
* @param validatedInfo a fully populated Xerces data validation context
* @return the appropriate java wrapper type
*/
public Object convertValidatedDataValue(ValidatedInfo validatedInfo) throws DatatypeFormatException {
switch (validatedInfo.actualValueType) {
case XSConstants.BASE64BINARY_DT:
byte[] decoded = Base64.decode(validatedInfo.normalizedValue);
return (Object)(decoded);
case XSConstants.BOOLEAN_DT:
return (Boolean)validatedInfo.actualValue;
case XSConstants.HEXBINARY_DT:
decoded = HexBin.decode(validatedInfo.normalizedValue);
return (Object)(decoded);
case XSConstants.UNSIGNEDSHORT_DT:
case XSConstants.INT_DT:
return Integer.valueOf(trimPlus(validatedInfo.normalizedValue));
case XSConstants.UNSIGNEDINT_DT:
case XSConstants.LONG_DT:
return suitableInteger( trimPlus(validatedInfo.normalizedValue) );
case XSConstants.UNSIGNEDBYTE_DT:
case XSConstants.SHORT_DT:
case XSConstants.BYTE_DT:
return Integer.valueOf(trimPlus(validatedInfo.normalizedValue));
case XSConstants.UNSIGNEDLONG_DT:
case XSConstants.INTEGER_DT:
case XSConstants.NONNEGATIVEINTEGER_DT:
case XSConstants.NONPOSITIVEINTEGER_DT:
case XSConstants.POSITIVEINTEGER_DT:
case XSConstants.NEGATIVEINTEGER_DT:
case XSConstants.DECIMAL_DT:
Object xsdValue = validatedInfo.actualValue;
if (decimalDV.getTotalDigits(xsdValue) == 0) {
return new Integer(0);
}
if (decimalDV.getFractionDigits(xsdValue) >= 1) {
return new BigDecimal(trimPlus(validatedInfo.normalizedValue));
}
// Can have 0 fractionDigits but still have a trailing .000
String lexical = trimPlus(validatedInfo.normalizedValue);
int dotx = lexical.indexOf('.');
if (dotx != -1) {
lexical = lexical.substring(0, dotx);
}
if (decimalDV.getTotalDigits(xsdValue) > 18) {
return new BigInteger(lexical);
} else {
return suitableInteger( lexical );
}
default:
return parseValidated(validatedInfo.normalizedValue);
}
}
/**
@param lexical
@return
*/
protected Number suitableInteger( String lexical )
{
long number = Long.parseLong( lexical );
return suitableInteger( number );
}
/**
@param number
@return
*/
protected Number suitableInteger( long number )
{
if (number > Integer.MAX_VALUE || number < Integer.MIN_VALUE)
return new Long( number );
else
return new Integer( (int) number );
}
/**
* Parse a validated lexical form. Subclasses which use the default
* parse implementation and are not convered by the explicit convertValidatedData
* cases should override this.
*/
public Object parseValidated(String lexical) {
return lexical;
}
/**
* Test whether the given LiteralLabel is a valid instance
* of this datatype. This takes into accound typing information
* as well as lexical form - for example an xsd:string is
* never considered valid as an xsd:integer (even if it is
* lexically legal like "1").
*/
public boolean isValidLiteral(LiteralLabel lit) {
return isBaseTypeCompatible(lit) && isValid(lit.getLexicalForm());
}
/**
* Test if the given typed value is in the right partition of the XSD type space.
* If this test passes then if the typed value has a legal lexical form for
* this type then it is a legal instance.
*/
public boolean isBaseTypeCompatible(LiteralLabel lit) {
XSTypeDefinition base = getFoundingType();
RDFDatatype litDT = lit.getDatatype();
if (litDT instanceof XSDDatatype) {
XSTypeDefinition litBase = ((XSDDatatype)litDT).getFoundingType();
return base.equals(litBase);
} else if (litDT == null && lit.language().equals("")) {
// Special RDF case, a plain literal is type compatible with and xsd:string-based type
return base.equals(XSDstring.typeDeclaration);
} else {
return false;
}
}
/**
* Return the most specific type below xsd:anySimpleType that this type is derived from.
*/
private XSTypeDefinition getFoundingType() {
XSTypeDefinition founding = typeDeclaration;
XSTypeDefinition parent = founding.getBaseType();
while (parent.getBaseType() != null) {
founding = parent;
parent = founding.getBaseType();
}
return founding;
}
/**
* Helper function to return the substring of a validated number string
* omitting any leading + sign.
*/
public static String trimPlus(String str) {
int i = str.indexOf('+');
if (i == -1) {
return str;
} else {
return str.substring(i+1);
}
}
/**
* Add all of the XSD pre-defined simple types to the given
* type mapper registry.
*/
public static void loadXSDSimpleTypes(TypeMapper tm) {
tm.registerDatatype(new XSDDatatype("anySimpleType"));
tm.registerDatatype(XSDdecimal);
tm.registerDatatype(XSDinteger);
tm.registerDatatype(XSDnonPositiveInteger);
tm.registerDatatype(XSDnonNegativeInteger);
tm.registerDatatype(XSDpositiveInteger);
tm.registerDatatype(XSDnegativeInteger);
tm.registerDatatype(XSDbyte);
tm.registerDatatype(XSDunsignedByte);
tm.registerDatatype(XSDdouble);
tm.registerDatatype(XSDfloat);
tm.registerDatatype(XSDlong);
tm.registerDatatype(XSDunsignedInt);
tm.registerDatatype(XSDunsignedShort);
tm.registerDatatype(XSDunsignedLong);
tm.registerDatatype(XSDint);
tm.registerDatatype(XSDshort);
tm.registerDatatype(XSDboolean);
tm.registerDatatype(XSDbase64Binary);
tm.registerDatatype(XSDhexBinary);
tm.registerDatatype(XSDdate);
tm.registerDatatype(XSDtime);
tm.registerDatatype(XSDdateTime);
tm.registerDatatype(XSDduration);
tm.registerDatatype(XSDgYearMonth);
tm.registerDatatype(XSDgMonthDay);
tm.registerDatatype(XSDgMonth);
tm.registerDatatype(XSDgDay);
tm.registerDatatype(XSDgYear);
tm.registerDatatype(XSDnormalizedString);
tm.registerDatatype(XSDstring);
tm.registerDatatype(XSDanyURI);
tm.registerDatatype(XSDtoken);
tm.registerDatatype(XSDName);
tm.registerDatatype(XSDlanguage);
tm.registerDatatype(XSDQName);
tm.registerDatatype(XSDNMTOKEN);
tm.registerDatatype(XSDID);
tm.registerDatatype(XSDENTITY);
tm.registerDatatype(XSDNCName);
tm.registerDatatype(XSDNOTATION);
tm.registerDatatype(XSDIDREF);
// tm.registerDatatype(XSDIDREFS);
// tm.registerDatatype(XSDENTITIES);
// tm.registerDatatype(XSDNMTOKENS);
}
// Temporary - used bootstrap the above initialization code
public static void main(String[] args) {
SymbolHash types = SchemaDVFactory.getInstance().getBuiltInTypes();
int len = types.getLength();
Object[] values = new Object[len];
types.getValues(values, 0);
for (int i = 0; i < values.length; i++) {
if (values[i] instanceof XSSimpleTypeDecl) {
XSSimpleTypeDecl decl = (XSSimpleTypeDecl)values[i];
System.out.println("tm.registerDatatype(new XSDDatatype(\""
+ decl.getName()
+ "\"));");
} else {
System.out.println(" - " + values[i]);
}
}
}
public int getHashCode( byte [] bytes )
{
int length = bytes.length;
return length == 0
? 0
: (bytes[0] << 12) ^ (bytes[length / 2] << 6) ^ (bytes[length - 1]) ^ length
;
}
}
/*
(c) Copyright 2002, 2003, 2004, 2005, 2006, 2007 Hewlett-Packard Development Company, LP
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. The name of the author may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -