Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Licensed to the Apache Software Foundation (ASF) under one
   * or more contributor license agreements.  See the NOTICE file
   * distributed with this work for additional information
   * regarding copyright ownership.  The ASF licenses this file
   * to you under the Apache License, Version 2.0 (the
   * "License"); you may not use this file except in compliance
   * with the License.  You may obtain a copy of the License at
   * 
  *   http://www.apache.org/licenses/LICENSE-2.0
  * 
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.    
  */
 
 package org.apache.tuscany.sca.databinding.impl;
 
 import java.util.Date;
 import java.util.Map;
 
 
Simple type mapper that maps from XSD types to Java Classes and Java Classes to XSD types.

Version:
$Rev: 937310 $ $Date: 2010-04-23 15:27:50 +0100 (Fri, 23 Apr 2010) $
Tuscany.spi.extension.asclient:
 
 public class SimpleTypeMapperImpl extends XSDDataTypeConverter implements SimpleTypeMapper {
 
     public static final Map<ClassStringJAVA2XML = new HashMap<ClassString>();
 
     public static final String URI_2001_SCHEMA_XSD = "http://www.w3.org/2001/XMLSchema";
 
     public static final Map<StringClassXML2JAVA = new HashMap<StringClass>();
 
     public static final QName XSD_ANY = new QName("any");
 
     public static final QName XSD_ANYSIMPLETYPE = new QName("anySimpleType");
 
     public static final QName XSD_ANYTYPE = new QName("anyType");
 
     public static final QName XSD_ANYURI = new QName("anyURI");
 
     public static final QName XSD_BASE64 = new QName("base64Binary");
 
     public static final QName XSD_BOOLEAN = new QName("boolean");
 
     public static final QName XSD_BYTE = new QName("byte");
 
     public static final QName XSD_DATE = new QName("date");
 
     public static final QName XSD_DATETIME = new QName("dateTime");
 
     public static final QName XSD_DAY = new QName("gDay");
 
     public static final QName XSD_DECIMAL = new QName("decimal");
 
     public static final QName XSD_DOUBLE = new QName("double");
 
     public static final QName XSD_DURATION = new QName("duration");
 
     public static final QName XSD_ENTITIES = new QName("ENTITIES");
 
     public static final QName XSD_ENTITY = new QName("ENTITY");
 
     public static final QName XSD_FLOAT = new QName("float");
 
     public static final QName XSD_HEXBIN = new QName("hexBinary");
 
     public static final QName XSD_IDREF = new QName("IDREF");
 
     public static final QName XSD_IDREFS = new QName("IDREFS");
 
     public static final QName XSD_INT = new QName("int");
 
     public static final QName XSD_INTEGER = new QName("integer");
 
     public static final QName XSD_LONG = new QName("long");
 
     public static final QName XSD_MONTH = new QName("gMonth");
 
     public static final QName XSD_MONTHDAY = new QName("gMonthDay");
 
     public static final QName XSD_NAME = new QName("Name");
    public static final QName XSD_NCNAME = new QName("NCName");
    public static final QName XSD_NEGATIVEINTEGER = new QName("negativeInteger");
    public static final QName XSD_NMTOKEN = new QName("NMTOKEN");
    public static final QName XSD_NMTOKENS = new QName("NMTOKENS");
    public static final QName XSD_NONNEGATIVEINTEGER = new QName("nonNegativeInteger");
    public static final QName XSD_NONPOSITIVEINTEGER = new QName("nonPositiveInteger");
    public static final QName XSD_NORMALIZEDSTRING = new QName("normalizedString");
    public static final QName XSD_NOTATION = new QName("NOTATION");
    public static final QName XSD_POSITIVEINTEGER = new QName("positiveInteger");
    public static final QName XSD_QNAME = new QName("QName");
    public static final QName XSD_SHORT = new QName("short");
    public static final Map<StringTypeInfoXSD_SIMPLE_TYPES = new HashMap<StringTypeInfo>();
    public static final QName XSD_STRING = new QName("string");
    public static final QName XSD_TIME = new QName("time");
    public static final QName XSD_TOKEN = new QName("token");
    public static final QName XSD_UNSIGNEDBYTE = new QName("unsignedByte");
    public static final QName XSD_UNSIGNEDINT = new QName("unsignedInt");
    public static final QName XSD_UNSIGNEDLONG = new QName("unsignedLong");
    public static final QName XSD_UNSIGNEDSHORT = new QName("unsignedShort");
    public static final QName XSD_YEAR = new QName("gYear");
    public static final QName XSD_YEARMONTH = new QName("gYearMonth");
    private static final String[] XSD_TYPE_NAMES =
    {"string""boolean""double""float""int""integer""long""short""byte""decimal""base64Binary",
     "hexBinary""anySimpleType""anyType""any""QName""dateTime""date""time""normalizedString",
     "token""unsignedLong""unsignedInt""unsignedShort""unsignedByte""positiveInteger""negativeInteger",
     "nonNegativeInteger""nonPositiveInteger""gYearMonth""gMonthDay""gYear""gMonth""gDay""duration",
     "Name""NCName""NMTOKEN""NMTOKENS""NOTATION""ENTITY""ENTITIES""IDREF""IDREFS""anyURI",
     "language""ID"};
    static {
        for (String type : ) {
            TypeInfo simpleType = new TypeInfo(new QName(type), truenull);
            .put(typesimpleType);
        }
    }
    static {
        .put(boolean.class"boolean");
        .put(byte.class"byte");
        .put(short.class"short");
        .put(int.class"int");
        .put(long.class"long");
        .put(float.class"float");
        .put(double.class"double");
        .put(Boolean.class"boolean");
        .put(Byte.class"byte");
        .put(Short.class"short");
        .put(Integer.class"int");
        .put(Long.class"long");
        .put(Float.class"float");
        .put(Double.class"double");
        .put(java.lang.String.class"string");
        .put(java.math.BigInteger.class"integer");
        .put(java.math.BigDecimal.class"decimal");
        .put(java.util.Calendar.class"dateTime");
        .put(java.util.Date.class"dateTime");
        .put(javax.xml.namespace.QName.class"QName");
        .put(java.net.URI.class"string");
        .put(javax.xml.datatype.XMLGregorianCalendar.class"anySimpleType");
        .put(javax.xml.datatype.Duration.class"duration");
        .put(java.lang.Object.class"anyType");
        .put(java.awt.Image.class"base64Binary");
        .put(byte[].class"base64Binary");
        // java2XSD.put(javax.activation.DataHandler.class, "base64Binary");
        .put(javax.xml.transform.Source.class"base64Binary");
        .put(java.util.UUID.class"string");
    }
    static {
        .put("string"java.lang.String.class);
        .put("integer"java.math.BigInteger.class);
        .put("int"int.class);
        .put("long"long.class);
        .put("short"short.class);
        .put("decimal"java.math.BigDecimal.class);
        .put("float"float.class);
        .put("double"double.class);
        .put("boolean"boolean.class);
        .put("byte"byte.class);
        .put("QName"javax.xml.namespace.QName.class);
        .put("dateTime"javax.xml.datatype.XMLGregorianCalendar.class);
        .put("base64Binary"byte[].class);
        .put("hexBinary"byte[].class);
        .put("unsignedInt"long.class);
        .put("unsignedShort"int.class);
        .put("unsignedByte"short.class);
        .put("time"javax.xml.datatype.XMLGregorianCalendar.class);
        .put("date"javax.xml.datatype.XMLGregorianCalendar.class);
        .put("gDay"javax.xml.datatype.XMLGregorianCalendar.class);
        .put("gMonth"javax.xml.datatype.XMLGregorianCalendar.class);
        .put("gYear"javax.xml.datatype.XMLGregorianCalendar.class);
        .put("gYearMonth"javax.xml.datatype.XMLGregorianCalendar.class);
        .put("gMonthDay"javax.xml.datatype.XMLGregorianCalendar.class);
        .put("anySimpleType"java.lang.Object.class); // For elements
        // XML2JAVA.put("anySimpleType", java.lang.String.class); // For
        // attributes
        .put("duration"javax.xml.datatype.Duration.class);
        .put("NOTATION"javax.xml.namespace.QName.class);
    }
    private DatatypeFactory factory;
    public SimpleTypeMapperImpl() {
        super();
        try {
            this. = DatatypeFactory.newInstance();
        } catch (DatatypeConfigurationException e) {
            throw new IllegalArgumentException(e);
        }
    }
    public Class<?> getJavaType(QName xmlType) {
         if (xmlType != null && .equals(xmlType.getNamespaceURI())) {
            return .get(xmlType.getLocalPart());
        } else {
            return null;
        }
    }
    public TypeInfo getXMLType(Class javaType) {
        return .get(.get(javaType));
    }
    public Object toJavaObject(QName simpleTypeString literalTransformationContext context) {
        
  • xsd:string --- java.lang.String
  • xsd:integer --- java.math.BigInteger
  • xsd:int --- int
  • xsd:long --- long
  • xsd:short --- short
  • xsd:decimal --- java.math.BigDecimal
  • xsd:float --- float
  • xsd:double --- double
  • xsd:boolean --- boolean
  • xsd:byte --- byte
  • xsd:QName --- javax.xml.namespace.QName
  • xsd:dateTime --- javax.xml.datatype.XMLGregorianCalendar
  • xsd:base64Binary --- byte[]
  • xsd:hexBinary --- byte[]
  • xsd:unsignedInt --- long
  • xsd:unsignedShort --- int
  • xsd:unsignedByte --- short
  • xsd:time --- javax.xml.datatype.XMLGregorianCalendar
  • xsd:date --- javax.xml.datatype.XMLGregorianCalendar
  • xsd:g* --- javax.xml.datatype.XMLGregorianCalendar
  • xsd:anySimpleType (for xsd:element of this type)a java.lang.Object
  • xsd:anySimpleType (for xsd:attribute of this type) java.lang.String
  • xsd:duration javax.xml.datatype.Duration
  • xsd:NOTATION javax.xml.namespace.QName
        if (literal == null) {
            return null;
        }
        String value = literal.trim();
        QName type = simpleType;
        if (type.equals()) {
            return parseString(value);
        } else if (type.equals()) {
            return parseInt(value);
        } else if (type.equals()) {
            return parseInteger(value);
        } else if (type.equals()) {
            return parseInt(value);
        } else if (type.equals()) {
            return parseFloat(value);
        } else if (type.equals()) {
            return parseDouble(value);
        } else if (type.equals()) {
            return parseShort(value);
        } else if (type.equals()) {
            return parseDecimal(value);
        } else if (type.equals()) {
            return parseBoolean(value);
        } else if (type.equals()) {
            return parseByte(value);
        } else if (type.equals()) {
            return parseLong(value);
        } else if (type.equals()) {
            return parseUnsignedShort(value);
        } else if (type.equals()) {
            return parseUnsignedShort(value);
        } else if (type.equals()) {
            return parseUnsignedInt(value);
        } else if (type.equals()) {
            return parseUnsignedInt(value);
        } else if (type.equals()) {
            return parseDateTime(value);
        } else if (type.equals()) {
            return parseDate(value);
        } else if (type.equals()) {
            return parseTime(value);
        } else if (type.equals()) {
            return parseDuration(value);
        } else if (type.equals()) {
            return parseHexBinary(value);
        } else if (type.equals()) {
            return parseBase64Binary(value);
        } else if (type.equals()) {
            NamespaceContext namespaceContext =
                (NamespaceContext)((context != null) ? context.getMetadata().get(NamespaceContext.class.getName()) : null);
            return parseQName(valuenamespaceContext);
        } else if (type.equals()) {
            NamespaceContext namespaceContext =
                (NamespaceContext)((context != null) ? context.getMetadata().get(NamespaceContext.class.getName()) : null);
            return parseQName(valuenamespaceContext);
        } else if (type.equals()) {
            return .newXMLGregorianCalendar(value);
        } else if (type.equals()) {
            return .newXMLGregorianCalendar(value);
        } else if (type.equals()) {
            return .newXMLGregorianCalendar(value);
        } else if (type.equals()) {
            return .newXMLGregorianCalendar(value);
        } else if (type.equals()) {
            return .newXMLGregorianCalendar(value);
        } else {
            return value;
        }
    }
    @SuppressWarnings("deprecation")
        GregorianCalendar c =
            new GregorianCalendar(date.getYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(),
                                  date.getSeconds());
        return .newXMLGregorianCalendar(c);
    }
        return .newXMLGregorianCalendar(calendar);
    }
    public String toXMLLiteral(QName simpleTypeObject objTransformationContext context) {
        if(obj == null) {
            // It could be null if nilable=true
            return null;
        }
        if (obj instanceof Float || obj instanceof Double) {
            if (obj instanceof Float) {
                return printDouble(((Float)obj).floatValue());
            } else {
                return printDouble(((Double)obj).doubleValue());
            }
        } else if (obj instanceof GregorianCalendar) {
            GregorianCalendar calendar = (GregorianCalendar)obj;
            return toXMLGregorianCalendar(calendar).toXMLFormat();
        } else if (obj instanceof Date) {
            return toXMLGregorianCalendar((Date)obj).toXMLFormat();
        } else if (obj instanceof XMLGregorianCalendar) {
            return ((XMLGregorianCalendar)obj).toXMLFormat();
        } else if (obj instanceof byte[]) {
            if (simpleType != null) {
                if (simpleType.equals()) {
                    return printBase64Binary((byte[])obj);
                } else if (simpleType.equals()) {
                    return printHexBinary((byte[])obj);
                }
            }
        } else if (obj instanceof QName) {
            NamespaceContext namespaceContext =
                (NamespaceContext)((context != null) ? context.getMetadata().get(NamespaceContext.class.getName()) : null);
            return printQName((QName)objnamespaceContext);
        }
        return obj.toString();
    }
    public boolean isSimpleXSDType(QName typeName) {
        if (typeName == null) {
            return false;
        }
        return typeName.getNamespaceURI().equals(
            && .get(typeName.getLocalPart()) != null;
    }
New to GrepCode? Check out our FAQ X