v2/src/common/org/apache/xmlbeans/impl/common/XsTypeConverter.java - xmlbeans - Git at Google

 /*
 * The Apache Software License, Version 1.1
 *
 *
 * Copyright (c) 2003 The Apache Software Foundation.  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 end-user documentation included with the redistribution,
 *    if any, must include the following acknowledgment:
 *       "This product includes software developed by the
 *        Apache Software Foundation (http://www.apache.org/)."
 *    Alternately, this acknowledgment may appear in the software itself,
 *    if and wherever such third-party acknowledgments normally appear.
 *
 * 4. The names "Apache" and "Apache Software Foundation" must
 *    not be used to endorse or promote products derived from this
 *    software without prior written permission. For written
 *    permission, please contact apache@apache.org.
 *
 * 5. Products derived from this software may not be called "Apache
 *    XMLBeans", nor may "Apache" appear in their name, without prior
 *    written permission of the Apache Software Foundation.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 APACHE SOFTWARE FOUNDATION OR
 * ITS CONTRIBUTORS 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.
 * ====================================================================
 *
 * This software consists of voluntary contributions made by many
 * individuals on behalf of the Apache Software Foundation and was
 * originally based on software copyright (c) 2000-2003 BEA Systems
 * Inc., <http://www.bea.com/>. For more information on the Apache Software
 * Foundation, please see <http://www.apache.org/>.
 */

 package org.apache.xmlbeans.impl.common;

 import org.apache.xmlbeans.XmlError;

 import javax.xml.namespace.QName;
 import javax.xml.namespace.NamespaceContext;
 import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.util.Collection;

 public final class XsTypeConverter
 {
   private static final String POS_INF_LEX = "INF";
   private static final String NEG_INF_LEX = "-INF";
   private static final String NAN_LEX = "NaN";

   private static final char NAMESPACE_SEP = ':';
   private static final String EMPTY_PREFIX = "";

   // ======================== float ========================
   public static float lexFloat(String v, Collection errors)
   {
     try {
       //current jdk impl of parseFloat calls trim() on the string.
       //Any other space is illegal anyway, whether there are one or more spaces.
       //so no need to do a collapse pass through the string.
       return Float.parseFloat(v);
     } catch (NumberFormatException e) {
       if (v.equals(POS_INF_LEX)) return Float.POSITIVE_INFINITY;
       if (v.equals(NEG_INF_LEX)) return Float.NEGATIVE_INFINITY;
       if (v.equals(NAN_LEX)) return Float.NaN;

       //TODO: i18n
       String msg = "invalid float: " + v;
       errors.add(XmlError.forMessage(msg));

       return Float.NaN;
     }
   }

   public static String printFloat(float value)
   {
     if (value == Float.POSITIVE_INFINITY)
       return POS_INF_LEX;
     else if (value == Float.NEGATIVE_INFINITY)
       return NEG_INF_LEX;
     else if (value == Float.NaN)
       return NAN_LEX;
     else
       return Float.toString(value);
   }


   // ======================== double ========================
   public static double lexDouble(String v, Collection errors)
   {
     try {
       //current jdk impl of parseDouble calls trim() on the string.
       //Any other space is illegal anyway, whether there are one or more spaces.
       //so no need to do a collapse pass through the string.
       return Double.parseDouble(v);
     } catch (NumberFormatException e) {
       if (v.equals(POS_INF_LEX)) return Double.POSITIVE_INFINITY;
       if (v.equals(NEG_INF_LEX)) return Double.NEGATIVE_INFINITY;
       if (v.equals(NAN_LEX)) return Double.NaN;

       //TODO: i18n
       String msg = "invalid double: " + v;
       errors.add(XmlError.forMessage(msg));

       return Double.NaN;
     }
   }

   public static String printDouble(double value)
   {
     if (value == Double.POSITIVE_INFINITY)
       return POS_INF_LEX;
     else if (value == Double.NEGATIVE_INFINITY)
       return NEG_INF_LEX;
     else if (value == Double.NaN)
       return NAN_LEX;
     else
       return Double.toString(value);
   }


   // ======================== decimal ========================
   public static BigDecimal lexDecimal(String v, Collection errors)
   {
     try {
       //TODO: review this
       //NOTE: we trim unneeded zeros from the string because
       //java.math.BigDecimal considers them significant for its
       //equals() method, but the xml value
       //space does not consider them significant.
       //See http://www.w3.org/2001/05/xmlschema-errata#e2-44
       return new BigDecimal(trimTrailingZeros(v));
     } catch (NumberFormatException e) {
       //TODO: i18n
       String msg = "invalid long: " + v;
       errors.add(XmlError.forMessage(msg));
       return new BigDecimal(trimTrailingZeros(v));
     }
   }

   public static String printDecimal(BigDecimal value)
   {
     return value.toString();
   }

   // ======================== integer ========================
   public static BigInteger lexInteger(String v, Collection errors)
   {
     try {
       //TODO: consider special casing zero and one to return static values
       //from BigInteger to avoid object creation.
       return new BigInteger(trimInitialPlus(v));
     } catch (NumberFormatException e) {
       //TODO: i18n
       String msg = "invalid long: " + v;
       errors.add(XmlError.forMessage(msg));
       return BigInteger.ZERO;
     }
   }

   public static String printInteger(BigInteger value)
   {
     return value.toString();
   }

   // ======================== long ========================
   public static long lexLong(String v, Collection errors)
   {
     try {
       return Long.parseLong(trimInitialPlus(v));
     } catch (NumberFormatException e) {
       //TODO: i18n
       String msg = "invalid long: " + v;
       errors.add(XmlError.forMessage(msg));
       return 0L;
     }
   }

   public static String printLong(long value)
   {
     return Long.toString(value);
   }


   // ======================== short ========================
   public static short lexShort(String v, Collection errors)
   {
     try {
       return Short.parseShort(trimInitialPlus(v));
     } catch (NumberFormatException e) {
       //TODO: i18n
       String msg = "invalid short: " + v;
       errors.add(XmlError.forMessage(msg));
       return 0;
     }
   }

   public static String printShort(short value)
   {
     return Short.toString(value);
   }


   // ======================== int ========================
   public static int lexInt(String v, Collection errors)
   {
     try {
       return Integer.parseInt(trimInitialPlus(v));
     } catch (NumberFormatException e) {
       //TODO: i18n
       String msg = "invalid int: " + v;
       errors.add(XmlError.forMessage(msg));
       return 0;
     }
   }

   public static String printInt(int value)
   {
     return Integer.toString(value);
   }


   // ======================== byte ========================
   public static byte lexByte(String v, Collection errors)
   {
     try {
       return Byte.parseByte(trimInitialPlus(v));
     } catch (NumberFormatException e) {
       //TODO: i18n
       String msg = "invalid byte: " + v;
       errors.add(XmlError.forMessage(msg));
       return 0;
     }
   }

   public static String printByte(byte value)
   {
     return Byte.toString(value);
   }


   // ======================== boolean ========================
   public static boolean lexBoolean(String v, Collection errors)
   {
     if ("true".equals(v) || "1".equals(v)) {
       return true;
     } else if ("false".equals(v) || "0".equals(v)) {
       return false;
     } else {
       //TODO: i18n
       String msg = "invalid boolean: " + v;
       errors.add(XmlError.forMessage(msg));
       return false;
     }
   }

   public static String printBoolean(boolean value)
   {
     return (value ? "true" : "false");
   }


   // ======================== string ========================
   public static String lexString(String v, Collection errors)
   {
     return v;
   }

   public static String printString(String value)
   {
     return value;
   }


   // ======================== QName ========================
   public static QName lexQName(String xsd_qname, Collection errors,
                                NamespaceContext nscontext)
   {

     final int idx = indexOfNamespaceSeperator(xsd_qname, errors);
     String prefix;
     String localpart;
     if (idx < 0) {
       prefix = EMPTY_PREFIX;
       localpart = xsd_qname;
     } else {
       prefix = xsd_qname.substring(0, idx);
       localpart = xsd_qname.substring(1 + idx);
     }
     String namespaceUri = getUriFromContext(prefix, xsd_qname,
                                             nscontext, errors);
     return new QName(namespaceUri, localpart, prefix);
   }

   public static String printQName(QName qname, NamespaceContext nsContext,
                                   Collection errors)
   {
     final String uri = qname.getNamespaceURI();
     String prefix = nsContext.getPrefix(uri);
     if (prefix == null) {
       String msg = "NamespaceContext does not provide" +
         " prefix for namespaceURI " + uri;
       errors.add(XmlError.forMessage(msg));
     }
     return getQNameString(uri, qname.getLocalPart(), prefix);
   }

   public static String getQNameString(String uri,
                                       String localpart,
                                       String prefix)
   {
     if (uri != null &&
       prefix != null &&
       prefix.length() > 0) {
       return (prefix + NAMESPACE_SEP + localpart);
     } else {
       return localpart;
     }
   }


   private static String trimInitialPlus(String xml)
   {
     if (xml.charAt(0) == '+') {
       return xml.substring(1);
     } else {
       return xml;
     }
   }

   private static int indexOfNamespaceSeperator(String xml, Collection errors)
   {
     final int idx = xml.indexOf(NAMESPACE_SEP);

     if (idx == 0) {
       String msg = "an empty prefix is not allowed in an xsd:QName value";
       errors.add(XmlError.forMessage(msg));
     }
     return idx;
   }

   private static String getUriFromContext(String prefix,
                                           String original_xml,
                                           NamespaceContext nscontext,
                                           Collection errors)
   {
     String uri = nscontext.getNamespaceURI(prefix);
     if (uri == null) {
       String msg = "invalid qname: " + original_xml;
       errors.add(XmlError.forMessage(msg));
     }

     return uri;
   }


   private static String trimTrailingZeros(String xsd_decimal)
   {
     final int last_char_idx = xsd_decimal.length() - 1;
     if (xsd_decimal.charAt(last_char_idx) == '0') {
       final int last_point = xsd_decimal.lastIndexOf('.');
       if (last_point >= 0) {
         //find last trailing zero
         for (int idx = last_char_idx; idx > last_point; idx--) {
           if (xsd_decimal.charAt(idx) != '0') {
             return xsd_decimal.substring(0, idx + 1);
           }
         }
         //reaching here means the string matched xxx.0*
         return xsd_decimal.substring(0, last_point);
       }
     }
     return xsd_decimal;
   }

   //use only as needed
   public static String stringValue(CharSequence value)
   {
     return value.toString();
   }

 }
	/*
	* The Apache Software License, Version 1.1
	*
	*
	* Copyright (c) 2003 The Apache Software Foundation. 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 end-user documentation included with the redistribution,
	* if any, must include the following acknowledgment:
	* "This product includes software developed by the
	* Apache Software Foundation (http://www.apache.org/)."
	* Alternately, this acknowledgment may appear in the software itself,
	* if and wherever such third-party acknowledgments normally appear.
	*
	* 4. The names "Apache" and "Apache Software Foundation" must
	* not be used to endorse or promote products derived from this
	* software without prior written permission. For written
	* permission, please contact apache@apache.org.
	*
	* 5. Products derived from this software may not be called "Apache
	* XMLBeans", nor may "Apache" appear in their name, without prior
	* written permission of the Apache Software Foundation.
	*
	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 APACHE SOFTWARE FOUNDATION OR
	* ITS CONTRIBUTORS 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.
	* ====================================================================
	*
	* This software consists of voluntary contributions made by many
	* individuals on behalf of the Apache Software Foundation and was
	* originally based on software copyright (c) 2000-2003 BEA Systems
	* Inc., <http://www.bea.com/>. For more information on the Apache Software
	* Foundation, please see <http://www.apache.org/>.
	*/

	package org.apache.xmlbeans.impl.common;

	import org.apache.xmlbeans.XmlError;

	import javax.xml.namespace.QName;
	import javax.xml.namespace.NamespaceContext;
	import java.math.BigDecimal;
	import java.math.BigInteger;
	import java.util.Collection;

	public final class XsTypeConverter
	{
	private static final String POS_INF_LEX = "INF";
	private static final String NEG_INF_LEX = "-INF";
	private static final String NAN_LEX = "NaN";

	private static final char NAMESPACE_SEP = ':';
	private static final String EMPTY_PREFIX = "";

	// ======================== float ========================
	public static float lexFloat(String v, Collection errors)
	{
	try {
	//current jdk impl of parseFloat calls trim() on the string.
	//Any other space is illegal anyway, whether there are one or more spaces.
	//so no need to do a collapse pass through the string.
	return Float.parseFloat(v);
	} catch (NumberFormatException e) {
	if (v.equals(POS_INF_LEX)) return Float.POSITIVE_INFINITY;
	if (v.equals(NEG_INF_LEX)) return Float.NEGATIVE_INFINITY;
	if (v.equals(NAN_LEX)) return Float.NaN;

	//TODO: i18n
	String msg = "invalid float: " + v;
	errors.add(XmlError.forMessage(msg));

	return Float.NaN;
	}
	}

	public static String printFloat(float value)
	{
	if (value == Float.POSITIVE_INFINITY)
	return POS_INF_LEX;
	else if (value == Float.NEGATIVE_INFINITY)
	return NEG_INF_LEX;
	else if (value == Float.NaN)
	return NAN_LEX;
	else
	return Float.toString(value);
	}


	// ======================== double ========================
	public static double lexDouble(String v, Collection errors)
	{
	try {
	//current jdk impl of parseDouble calls trim() on the string.
	//Any other space is illegal anyway, whether there are one or more spaces.
	//so no need to do a collapse pass through the string.
	return Double.parseDouble(v);
	} catch (NumberFormatException e) {
	if (v.equals(POS_INF_LEX)) return Double.POSITIVE_INFINITY;
	if (v.equals(NEG_INF_LEX)) return Double.NEGATIVE_INFINITY;
	if (v.equals(NAN_LEX)) return Double.NaN;

	//TODO: i18n
	String msg = "invalid double: " + v;
	errors.add(XmlError.forMessage(msg));

	return Double.NaN;
	}
	}

	public static String printDouble(double value)
	{
	if (value == Double.POSITIVE_INFINITY)
	return POS_INF_LEX;
	else if (value == Double.NEGATIVE_INFINITY)
	return NEG_INF_LEX;
	else if (value == Double.NaN)
	return NAN_LEX;
	else
	return Double.toString(value);
	}


	// ======================== decimal ========================
	public static BigDecimal lexDecimal(String v, Collection errors)
	{
	try {
	//TODO: review this
	//NOTE: we trim unneeded zeros from the string because
	//java.math.BigDecimal considers them significant for its
	//equals() method, but the xml value
	//space does not consider them significant.
	//See http://www.w3.org/2001/05/xmlschema-errata#e2-44
	return new BigDecimal(trimTrailingZeros(v));
	} catch (NumberFormatException e) {
	//TODO: i18n
	String msg = "invalid long: " + v;
	errors.add(XmlError.forMessage(msg));
	return new BigDecimal(trimTrailingZeros(v));
	}
	}

	public static String printDecimal(BigDecimal value)
	{
	return value.toString();
	}

	// ======================== integer ========================
	public static BigInteger lexInteger(String v, Collection errors)
	{
	try {
	//TODO: consider special casing zero and one to return static values
	//from BigInteger to avoid object creation.
	return new BigInteger(trimInitialPlus(v));
	} catch (NumberFormatException e) {
	//TODO: i18n
	String msg = "invalid long: " + v;
	errors.add(XmlError.forMessage(msg));
	return BigInteger.ZERO;
	}
	}

	public static String printInteger(BigInteger value)
	{
	return value.toString();
	}

	// ======================== long ========================
	public static long lexLong(String v, Collection errors)
	{
	try {
	return Long.parseLong(trimInitialPlus(v));
	} catch (NumberFormatException e) {
	//TODO: i18n
	String msg = "invalid long: " + v;
	errors.add(XmlError.forMessage(msg));
	return 0L;
	}
	}

	public static String printLong(long value)
	{
	return Long.toString(value);
	}


	// ======================== short ========================
	public static short lexShort(String v, Collection errors)
	{
	try {
	return Short.parseShort(trimInitialPlus(v));
	} catch (NumberFormatException e) {
	//TODO: i18n
	String msg = "invalid short: " + v;
	errors.add(XmlError.forMessage(msg));
	return 0;
	}
	}

	public static String printShort(short value)
	{
	return Short.toString(value);
	}


	// ======================== int ========================
	public static int lexInt(String v, Collection errors)
	{
	try {
	return Integer.parseInt(trimInitialPlus(v));
	} catch (NumberFormatException e) {
	//TODO: i18n
	String msg = "invalid int: " + v;
	errors.add(XmlError.forMessage(msg));
	return 0;
	}
	}

	public static String printInt(int value)
	{
	return Integer.toString(value);
	}


	// ======================== byte ========================
	public static byte lexByte(String v, Collection errors)
	{
	try {
	return Byte.parseByte(trimInitialPlus(v));
	} catch (NumberFormatException e) {
	//TODO: i18n
	String msg = "invalid byte: " + v;
	errors.add(XmlError.forMessage(msg));
	return 0;
	}
	}

	public static String printByte(byte value)
	{
	return Byte.toString(value);
	}


	// ======================== boolean ========================
	public static boolean lexBoolean(String v, Collection errors)
	{
	if ("true".equals(v) \|\| "1".equals(v)) {
	return true;
	} else if ("false".equals(v) \|\| "0".equals(v)) {
	return false;
	} else {
	//TODO: i18n
	String msg = "invalid boolean: " + v;
	errors.add(XmlError.forMessage(msg));
	return false;
	}
	}

	public static String printBoolean(boolean value)
	{
	return (value ? "true" : "false");
	}


	// ======================== string ========================
	public static String lexString(String v, Collection errors)
	{
	return v;
	}

	public static String printString(String value)
	{
	return value;
	}


	// ======================== QName ========================
	public static QName lexQName(String xsd_qname, Collection errors,
	NamespaceContext nscontext)
	{

	final int idx = indexOfNamespaceSeperator(xsd_qname, errors);
	String prefix;
	String localpart;
	if (idx < 0) {
	prefix = EMPTY_PREFIX;
	localpart = xsd_qname;
	} else {
	prefix = xsd_qname.substring(0, idx);
	localpart = xsd_qname.substring(1 + idx);
	}
	String namespaceUri = getUriFromContext(prefix, xsd_qname,
	nscontext, errors);
	return new QName(namespaceUri, localpart, prefix);
	}

	public static String printQName(QName qname, NamespaceContext nsContext,
	Collection errors)
	{
	final String uri = qname.getNamespaceURI();
	String prefix = nsContext.getPrefix(uri);
	if (prefix == null) {
	String msg = "NamespaceContext does not provide" +
	" prefix for namespaceURI " + uri;
	errors.add(XmlError.forMessage(msg));
	}
	return getQNameString(uri, qname.getLocalPart(), prefix);
	}

	public static String getQNameString(String uri,
	String localpart,
	String prefix)
	{
	if (uri != null &&
	prefix != null &&
	prefix.length() > 0) {
	return (prefix + NAMESPACE_SEP + localpart);
	} else {
	return localpart;
	}
	}


	private static String trimInitialPlus(String xml)
	{
	if (xml.charAt(0) == '+') {
	return xml.substring(1);
	} else {
	return xml;
	}
	}

	private static int indexOfNamespaceSeperator(String xml, Collection errors)
	{
	final int idx = xml.indexOf(NAMESPACE_SEP);

	if (idx == 0) {
	String msg = "an empty prefix is not allowed in an xsd:QName value";
	errors.add(XmlError.forMessage(msg));
	}
	return idx;
	}

	private static String getUriFromContext(String prefix,
	String original_xml,
	NamespaceContext nscontext,
	Collection errors)
	{
	String uri = nscontext.getNamespaceURI(prefix);
	if (uri == null) {
	String msg = "invalid qname: " + original_xml;
	errors.add(XmlError.forMessage(msg));
	}

	return uri;
	}


	private static String trimTrailingZeros(String xsd_decimal)
	{
	final int last_char_idx = xsd_decimal.length() - 1;
	if (xsd_decimal.charAt(last_char_idx) == '0') {
	final int last_point = xsd_decimal.lastIndexOf('.');
	if (last_point >= 0) {
	//find last trailing zero
	for (int idx = last_char_idx; idx > last_point; idx--) {
	if (xsd_decimal.charAt(idx) != '0') {
	return xsd_decimal.substring(0, idx + 1);
	}
	}
	//reaching here means the string matched xxx.0*
	return xsd_decimal.substring(0, last_point);
	}
	}
	return xsd_decimal;
	}

	//use only as needed
	public static String stringValue(CharSequence value)
	{
	return value.toString();
	}

	}