/*
 * Copyright 2001-2004 The Apache Software Foundation.
 * 
 * Licensed 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.axis.encoding;

import org.apache.axis.Constants;
import org.apache.axis.attachments.OctetStream;
import org.apache.axis.encoding.ser.ArrayDeserializerFactory;
import org.apache.axis.encoding.ser.ArraySerializerFactory;
import org.apache.axis.encoding.ser.Base64DeserializerFactory;
import org.apache.axis.encoding.ser.Base64SerializerFactory;
import org.apache.axis.encoding.ser.BeanDeserializerFactory;
import org.apache.axis.encoding.ser.BeanSerializerFactory;
import org.apache.axis.encoding.ser.DateDeserializerFactory;
import org.apache.axis.encoding.ser.DateSerializerFactory;
import org.apache.axis.encoding.ser.DocumentDeserializerFactory;
import org.apache.axis.encoding.ser.DocumentSerializerFactory;
import org.apache.axis.encoding.ser.ElementDeserializerFactory;
import org.apache.axis.encoding.ser.ElementSerializerFactory;
import org.apache.axis.encoding.ser.HexDeserializerFactory;
import org.apache.axis.encoding.ser.HexSerializerFactory;
import org.apache.axis.encoding.ser.JAFDataHandlerDeserializerFactory;
import org.apache.axis.encoding.ser.JAFDataHandlerSerializerFactory;
import org.apache.axis.encoding.ser.MapDeserializerFactory;
import org.apache.axis.encoding.ser.MapSerializerFactory;
import org.apache.axis.encoding.ser.QNameDeserializerFactory;
import org.apache.axis.encoding.ser.QNameSerializerFactory;
import org.apache.axis.encoding.ser.SimpleDeserializerFactory;
import org.apache.axis.encoding.ser.SimpleSerializerFactory;
import org.apache.axis.encoding.ser.VectorDeserializerFactory;
import org.apache.axis.encoding.ser.VectorSerializerFactory;
import org.apache.axis.schema.SchemaVersion;
import org.apache.axis.types.HexBinary;
import org.apache.axis.utils.JavaUtils;
import org.apache.axis.utils.Messages;

import javax.xml.namespace.QName;
import javax.xml.rpc.JAXRPCException;
import javax.xml.rpc.encoding.DeserializerFactory;

/**
 * This is the implementation of the axis Default TypeMapping (which extends
 * the JAX-RPC TypeMapping interface) for SOAP 1.1.
 *
 * A TypeMapping contains tuples as follows:
 * {Java type, SerializerFactory, DeserializerFactory, Type QName)
 *
 * In other words, it serves to map Java types to and from XML types using
 * particular Serializers/Deserializers.  Each TypeMapping is associated with
 * one or more encodingStyle URIs.
 *
 * The wsdl in your web service will use a number of types.  The tuple
 * information for each of these will be accessed via the TypeMapping.
 *
 * This TypeMapping is the "default" one, which includes all the standard
 * SOAP and schema XSD types.  Individual TypeMappings (associated with
 * AxisEngines and SOAPServices) will delegate to this one, so if you haven't
 * overriden a default mapping we'll end up getting it from here.
 *
 * @author Rich Scheuerle (scheu@us.ibm.com)
 */
public class DefaultTypeMappingImpl extends TypeMappingImpl {

    private static DefaultTypeMappingImpl tm = null;
    private boolean inInitMappings = false;

    /**
     * Obtain the singleton default typemapping.
     */
    public static synchronized TypeMappingDelegate getSingletonDelegate() {
        if (tm == null) {
            tm = new DefaultTypeMappingImpl();
        }
        return new TypeMappingDelegate(tm);
    }

    protected DefaultTypeMappingImpl() {
        initMappings();
    }

    protected DefaultTypeMappingImpl(boolean noMappings) {
        if (!noMappings) {
            initMappings();
        }
    }

    protected void initMappings() {
        inInitMappings = true;

        // Notes:
        // 1) The registration statements are order dependent.  The last one
        //    wins.  So if two javaTypes of String are registered, the
        //    ser factory for the last one registered will be chosen.  Likewise
        //    if two javaTypes for XSD_DATE are registered, the deserializer
        //    factory for the last one registered will be chosen.
        //    Corollary:  Please be very careful with the order.  The
        //                runtime, Java2WSDL and WSDL2Java emitters all
        //                use this code to get type mapping information.
        // 2) Even if the SOAP 1.1 format is used over the wire, an
        //    attempt is made to receive SOAP 1.2 format from the wire.
        //    This is the reason why the soap encoded primitives are
        //    registered without serializers.

        // Since the last-registered type wins, I want to add the mime
        // String FIRST.
        if (JavaUtils.isAttachmentSupported()) {
            myRegister(Constants.MIME_PLAINTEXT, java.lang.String.class,
                    new JAFDataHandlerSerializerFactory(
                            java.lang.String.class,
                            Constants.MIME_PLAINTEXT),
                    new JAFDataHandlerDeserializerFactory(
                            java.lang.String.class,
                            Constants.MIME_PLAINTEXT));
        }

        // HexBinary binary data needs to use the hex binary serializer/deserializer
        myRegister(Constants.XSD_HEXBIN,     HexBinary.class,
                   new HexSerializerFactory(
                        HexBinary.class, Constants.XSD_HEXBIN),
                   new HexDeserializerFactory(
                        HexBinary.class, Constants.XSD_HEXBIN));
        myRegister(Constants.XSD_HEXBIN,     byte[].class,
                   new HexSerializerFactory(
                        byte[].class, Constants.XSD_HEXBIN),
                   new HexDeserializerFactory(
                        byte[].class, Constants.XSD_HEXBIN));

        // SOAP 1.1
        // byte[] -ser-> XSD_BASE64
        // XSD_BASE64 -deser-> byte[]
        // SOAP_BASE64 -deser->byte[]
        //
        // Special case:
        // If serialization is requested for xsd:byte with byte[],
        // the array serializer is used.  If deserialization
        // is specifically requested for xsd:byte with byte[], the
        // simple deserializer is used.  This is necessary
        // to support the serialization/deserialization
        // of <element name="a" type="xsd:byte" maxOccurs="unbounded" />
        // as discrete bytes without interference with XSD_BASE64.
        myRegister(Constants.XSD_BYTE,       byte[].class,
                   new ArraySerializerFactory(),
                   null
        );

        myRegister(Constants.XSD_BASE64,     byte[].class,
                   new Base64SerializerFactory(byte[].class,
                                               Constants.XSD_BASE64 ),
                   new Base64DeserializerFactory(byte[].class,
                                           Constants.XSD_BASE64));

        // anySimpleType is mapped to java.lang.String according to JAX-RPC 1.1 spec.
        myRegisterSimple(Constants.XSD_ANYSIMPLETYPE, java.lang.String.class);
        
        // If SOAP 1.1 over the wire, map wrapper classes to XSD primitives.
        myRegisterSimple(Constants.XSD_STRING, java.lang.String.class);
        myRegisterSimple(Constants.XSD_BOOLEAN, java.lang.Boolean.class);
        myRegisterSimple(Constants.XSD_DOUBLE, java.lang.Double.class);
        myRegisterSimple(Constants.XSD_FLOAT, java.lang.Float.class);
        myRegisterSimple(Constants.XSD_INT, java.lang.Integer.class);
        myRegisterSimple(Constants.XSD_INTEGER, java.math.BigInteger.class
        );
        myRegisterSimple(Constants.XSD_DECIMAL, java.math.BigDecimal.class
        );
        myRegisterSimple(Constants.XSD_LONG, java.lang.Long.class);
        myRegisterSimple(Constants.XSD_SHORT, java.lang.Short.class);
        myRegisterSimple(Constants.XSD_BYTE, java.lang.Byte.class);

        // The XSD Primitives are mapped to java primitives.
        myRegisterSimple(Constants.XSD_BOOLEAN, boolean.class);
        myRegisterSimple(Constants.XSD_DOUBLE, double.class);
        myRegisterSimple(Constants.XSD_FLOAT, float.class);
        myRegisterSimple(Constants.XSD_INT, int.class);
        myRegisterSimple(Constants.XSD_LONG, long.class);
        myRegisterSimple(Constants.XSD_SHORT, short.class);
        myRegisterSimple(Constants.XSD_BYTE, byte.class);

        // Map QNAME to the jax rpc QName class
        myRegister(Constants.XSD_QNAME,
              javax.xml.namespace.QName.class,
              new QNameSerializerFactory(javax.xml.namespace.QName.class,
                                        Constants.XSD_QNAME),
              new QNameDeserializerFactory(javax.xml.namespace.QName.class,
                                        Constants.XSD_QNAME)
        );

        // The closest match for anytype is Object
        myRegister(Constants.XSD_ANYTYPE,    java.lang.Object.class,
                   null, null);

        // See the SchemaVersion classes for where the registration of
        // dateTime (for 2001) and timeInstant (for 1999 & 2000) happen.
        myRegister(Constants.XSD_DATE,       java.sql.Date.class,
                   new DateSerializerFactory(java.sql.Date.class,
                                             Constants.XSD_DATE),
                   new DateDeserializerFactory(java.sql.Date.class,
                                               Constants.XSD_DATE)
        );

        // See the SchemaVersion classes for where the registration of
        // dateTime (for 2001) and timeInstant (for 1999 & 2000) happen.
        myRegister(Constants.XSD_DATE,       java.util.Date.class,
                   new DateSerializerFactory(java.util.Date.class,
                                             Constants.XSD_DATE),
                   new DateDeserializerFactory(java.util.Date.class,
                                               Constants.XSD_DATE)
        );

        // Mapping for xsd:time.  Map to Axis type Time
        myRegister(Constants.XSD_TIME,       org.apache.axis.types.Time.class,
                   new SimpleSerializerFactory(org.apache.axis.types.Time.class,
                                             Constants.XSD_TIME),
                   new SimpleDeserializerFactory(org.apache.axis.types.Time.class,
                                               Constants.XSD_TIME)
        );
        // These are the g* types (gYearMonth, etc) which map to Axis types
        myRegister(Constants.XSD_YEARMONTH, org.apache.axis.types.YearMonth.class,
                   new SimpleSerializerFactory(org.apache.axis.types.YearMonth.class,
                                             Constants.XSD_YEARMONTH),
                   new SimpleDeserializerFactory(org.apache.axis.types.YearMonth.class,
                                             Constants.XSD_YEARMONTH)
        );
        myRegister(Constants.XSD_YEAR, org.apache.axis.types.Year.class,
                   new SimpleSerializerFactory(org.apache.axis.types.Year.class,
                                             Constants.XSD_YEAR),
                   new SimpleDeserializerFactory(org.apache.axis.types.Year.class,
                                             Constants.XSD_YEAR)
        );
        myRegister(Constants.XSD_MONTH, org.apache.axis.types.Month.class,
                   new SimpleSerializerFactory(org.apache.axis.types.Month.class,
                                             Constants.XSD_MONTH),
                   new SimpleDeserializerFactory(org.apache.axis.types.Month.class,
                                             Constants.XSD_MONTH)
        );
        myRegister(Constants.XSD_DAY, org.apache.axis.types.Day.class,
                   new SimpleSerializerFactory(org.apache.axis.types.Day.class,
                                             Constants.XSD_DAY),
                   new SimpleDeserializerFactory(org.apache.axis.types.Day.class,
                                             Constants.XSD_DAY)
        );
        myRegister(Constants.XSD_MONTHDAY, org.apache.axis.types.MonthDay.class,
                   new SimpleSerializerFactory(org.apache.axis.types.MonthDay.class,
                                             Constants.XSD_MONTHDAY),
                   new SimpleDeserializerFactory(org.apache.axis.types.MonthDay.class,
                                             Constants.XSD_MONTHDAY)
        );

        // Serialize all extensions of Map to SOAP_MAP
        // Order counts here, HashMap should be last.
        myRegister(Constants.SOAP_MAP,       java.util.Hashtable.class,
                   new MapSerializerFactory(java.util.Hashtable.class,
                                            Constants.SOAP_MAP),
                   null  // Make sure not to override the deser mapping
        );
        myRegister(Constants.SOAP_MAP,       java.util.Map.class,
                   new MapSerializerFactory(java.util.Map.class,
                                            Constants.SOAP_MAP),
                   null  // Make sure not to override the deser mapping
        );
        // The SOAP_MAP will be deserialized into a HashMap by default.
        myRegister(Constants.SOAP_MAP,       java.util.HashMap.class,
                   new MapSerializerFactory(java.util.Map.class,
                                            Constants.SOAP_MAP),
                   new MapDeserializerFactory(java.util.HashMap.class,
                                              Constants.SOAP_MAP)
        );

        // Use the Element Serializeration for elements
        myRegister(Constants.SOAP_ELEMENT,   org.w3c.dom.Element.class,
                   new ElementSerializerFactory(),
                   new ElementDeserializerFactory());

        // Use the Document Serializeration for Document's
        myRegister(Constants.SOAP_DOCUMENT,   org.w3c.dom.Document.class,
                   new DocumentSerializerFactory(),
                   new DocumentDeserializerFactory());

        myRegister(Constants.SOAP_VECTOR,    java.util.Vector.class,
                   new VectorSerializerFactory(java.util.Vector.class,
                                               Constants.SOAP_VECTOR),
                   new VectorDeserializerFactory(java.util.Vector.class,
                                                 Constants.SOAP_VECTOR)
        );

        // Register all the supported MIME types
        // (note that MIME_PLAINTEXT was registered near the top)
        if (JavaUtils.isAttachmentSupported()) {
            myRegister(Constants.MIME_IMAGE, java.awt.Image.class,
                    new JAFDataHandlerSerializerFactory(
                            java.awt.Image.class,
                            Constants.MIME_IMAGE),
                    new JAFDataHandlerDeserializerFactory(
                            java.awt.Image.class,
                            Constants.MIME_IMAGE));
            myRegister(Constants.MIME_MULTIPART, javax.mail.internet.MimeMultipart.class,
                    new JAFDataHandlerSerializerFactory(
                            javax.mail.internet.MimeMultipart.class,
                            Constants.MIME_MULTIPART),
                    new JAFDataHandlerDeserializerFactory(
                            javax.mail.internet.MimeMultipart.class,
                            Constants.MIME_MULTIPART));
            myRegister(Constants.MIME_SOURCE, javax.xml.transform.Source.class,
                    new JAFDataHandlerSerializerFactory(
                            javax.xml.transform.Source.class,
                            Constants.MIME_SOURCE),
                    new JAFDataHandlerDeserializerFactory(
                            javax.xml.transform.Source.class,
                            Constants.MIME_SOURCE));
            myRegister(Constants.MIME_OCTETSTREAM, OctetStream.class,
                    new JAFDataHandlerSerializerFactory(
                            OctetStream.class,
                            Constants.MIME_OCTETSTREAM),
                    new JAFDataHandlerDeserializerFactory(
                            OctetStream.class,
                            Constants.MIME_OCTETSTREAM));
            myRegister(Constants.MIME_DATA_HANDLER, javax.activation.DataHandler.class,
                    new JAFDataHandlerSerializerFactory(),
                    new JAFDataHandlerDeserializerFactory());
        }

        // xsd:token
        myRegister(Constants.XSD_TOKEN, org.apache.axis.types.Token.class,
                   new SimpleSerializerFactory(org.apache.axis.types.Token.class,
                                             Constants.XSD_TOKEN),
                   new SimpleDeserializerFactory(org.apache.axis.types.Token.class,
                                             Constants.XSD_TOKEN)
        );

        // a xsd:normalizedString
        myRegister(Constants.XSD_NORMALIZEDSTRING, org.apache.axis.types.NormalizedString.class,
                   new SimpleSerializerFactory(org.apache.axis.types.NormalizedString.class,
                                             Constants.XSD_NORMALIZEDSTRING),
                   new SimpleDeserializerFactory(org.apache.axis.types.NormalizedString.class,
                                             Constants.XSD_NORMALIZEDSTRING)
        );

        // a xsd:unsignedLong
        myRegister(Constants.XSD_UNSIGNEDLONG, org.apache.axis.types.UnsignedLong.class,
             new SimpleSerializerFactory(org.apache.axis.types.UnsignedLong.class,
                                                  Constants.XSD_UNSIGNEDLONG),
             new SimpleDeserializerFactory(org.apache.axis.types.UnsignedLong.class,
                                           Constants.XSD_UNSIGNEDLONG)
        );

        // a xsd:unsignedInt
        myRegister(Constants.XSD_UNSIGNEDINT, org.apache.axis.types.UnsignedInt.class,
             new SimpleSerializerFactory(org.apache.axis.types.UnsignedInt.class,
                                                  Constants.XSD_UNSIGNEDINT),
             new SimpleDeserializerFactory(org.apache.axis.types.UnsignedInt.class,
                                           Constants.XSD_UNSIGNEDINT)
        );

        // a xsd:unsignedShort
        myRegister(Constants.XSD_UNSIGNEDSHORT, org.apache.axis.types.UnsignedShort.class,
             new SimpleSerializerFactory(org.apache.axis.types.UnsignedShort.class,
                                                  Constants.XSD_UNSIGNEDSHORT),
             new SimpleDeserializerFactory(org.apache.axis.types.UnsignedShort.class,
                                           Constants.XSD_UNSIGNEDSHORT)
        );

        // a xsd:unsignedByte
        myRegister(Constants.XSD_UNSIGNEDBYTE, org.apache.axis.types.UnsignedByte.class,
                   new SimpleSerializerFactory(org.apache.axis.types.UnsignedByte.class,
                                             Constants.XSD_UNSIGNEDBYTE),
                   new SimpleDeserializerFactory(org.apache.axis.types.UnsignedByte.class,
                                             Constants.XSD_UNSIGNEDBYTE)
        );

        // a xsd:nonNegativeInteger
        myRegister(Constants.XSD_NONNEGATIVEINTEGER, org.apache.axis.types.NonNegativeInteger.class,
             new SimpleSerializerFactory(org.apache.axis.types.NonNegativeInteger.class,
                                                  Constants.XSD_NONNEGATIVEINTEGER),
             new SimpleDeserializerFactory(org.apache.axis.types.NonNegativeInteger.class,
                                           Constants.XSD_NONNEGATIVEINTEGER)
        );

        // a xsd:negativeInteger
        myRegister(Constants.XSD_NEGATIVEINTEGER, org.apache.axis.types.NegativeInteger.class,
             new SimpleSerializerFactory(org.apache.axis.types.NegativeInteger.class,
                                                  Constants.XSD_NEGATIVEINTEGER),
             new SimpleDeserializerFactory(org.apache.axis.types.NegativeInteger.class,
                                           Constants.XSD_NEGATIVEINTEGER)
        );

        // a xsd:positiveInteger
        myRegister(Constants.XSD_POSITIVEINTEGER, org.apache.axis.types.PositiveInteger.class,
             new SimpleSerializerFactory(org.apache.axis.types.PositiveInteger.class,
                                                  Constants.XSD_POSITIVEINTEGER),
             new SimpleDeserializerFactory(org.apache.axis.types.PositiveInteger.class,
                                           Constants.XSD_POSITIVEINTEGER)
        );

        // a xsd:nonPositiveInteger
        myRegister(Constants.XSD_NONPOSITIVEINTEGER, org.apache.axis.types.NonPositiveInteger.class,
             new SimpleSerializerFactory(org.apache.axis.types.NonPositiveInteger.class,
                                                  Constants.XSD_NONPOSITIVEINTEGER),
             new SimpleDeserializerFactory(org.apache.axis.types.NonPositiveInteger.class,
                                           Constants.XSD_NONPOSITIVEINTEGER)
        );

        // a xsd:Name
        myRegister(Constants.XSD_NAME, org.apache.axis.types.Name.class,
                   new SimpleSerializerFactory(org.apache.axis.types.Name.class,
                                             Constants.XSD_NAME),
                   new SimpleDeserializerFactory(org.apache.axis.types.Name.class,
                                             Constants.XSD_NAME)
        );

        // a xsd:NCName
        myRegister(Constants.XSD_NCNAME, org.apache.axis.types.NCName.class,
                   new SimpleSerializerFactory(org.apache.axis.types.NCName.class,
                                             Constants.XSD_NCNAME),
                   new SimpleDeserializerFactory(org.apache.axis.types.NCName.class,
                                             Constants.XSD_NCNAME)
        );

         // a xsd:ID
        myRegister(Constants.XSD_ID, org.apache.axis.types.Id.class,
                   new SimpleSerializerFactory(org.apache.axis.types.Id.class,
                                             Constants.XSD_ID),
                   new SimpleDeserializerFactory(org.apache.axis.types.Id.class,
                                             Constants.XSD_ID)
        );

        // a xml:lang
        myRegister(Constants.XML_LANG, org.apache.axis.types.Language.class,
                   new SimpleSerializerFactory(org.apache.axis.types.Language.class,
                                             Constants.XML_LANG),
                   new SimpleDeserializerFactory(org.apache.axis.types.Language.class,
                                             Constants.XML_LANG)
        );
        
        // a xsd:language
        myRegister(Constants.XSD_LANGUAGE, org.apache.axis.types.Language.class,
                   new SimpleSerializerFactory(org.apache.axis.types.Language.class,
                                             Constants.XSD_LANGUAGE),
                   new SimpleDeserializerFactory(org.apache.axis.types.Language.class,
                                             Constants.XSD_LANGUAGE)
        );

        // a xsd:NmToken
        myRegister(Constants.XSD_NMTOKEN, org.apache.axis.types.NMToken.class,
                   new SimpleSerializerFactory(org.apache.axis.types.NMToken.class,
                                             Constants.XSD_NMTOKEN),
                   new SimpleDeserializerFactory(org.apache.axis.types.NMToken.class,
                                             Constants.XSD_NMTOKEN)
        );

        // a xsd:NmTokens
        myRegister(Constants.XSD_NMTOKENS, org.apache.axis.types.NMTokens.class,
                   new SimpleSerializerFactory(org.apache.axis.types.NMTokens.class,
                                             Constants.XSD_NMTOKENS),
                   new SimpleDeserializerFactory(org.apache.axis.types.NMTokens.class,
                                             Constants.XSD_NMTOKENS)
        );

        // a xsd:NOTATION
        myRegister(Constants.XSD_NOTATION, org.apache.axis.types.Notation.class,
                   new BeanSerializerFactory(org.apache.axis.types.Notation.class,
                                             Constants.XSD_NOTATION),
                   new BeanDeserializerFactory(org.apache.axis.types.Notation.class,
                                             Constants.XSD_NOTATION)
        );

        // a xsd:XSD_ENTITY
        myRegister(Constants.XSD_ENTITY, org.apache.axis.types.Entity.class,
                   new SimpleSerializerFactory(org.apache.axis.types.Entity.class,
                                             Constants.XSD_ENTITY),
                   new SimpleDeserializerFactory(org.apache.axis.types.Entity.class,
                                             Constants.XSD_ENTITY)
        );

        // a xsd:XSD_ENTITIES
        myRegister(Constants.XSD_ENTITIES, org.apache.axis.types.Entities.class,
                   new SimpleSerializerFactory(org.apache.axis.types.Entities.class,
                                             Constants.XSD_ENTITIES),
                   new SimpleDeserializerFactory(org.apache.axis.types.Entities.class,
                                             Constants.XSD_ENTITIES)
        );

        // a xsd:XSD_IDREF
        myRegister(Constants.XSD_IDREF, org.apache.axis.types.IDRef.class,
                   new SimpleSerializerFactory(org.apache.axis.types.IDRef.class,
                                             Constants.XSD_IDREF),
                   new SimpleDeserializerFactory(org.apache.axis.types.IDRef.class,
                                             Constants.XSD_IDREF)
        );

        // a xsd:XSD_XSD_IDREFS
        myRegister(Constants.XSD_IDREFS, org.apache.axis.types.IDRefs.class,
                   new SimpleSerializerFactory(org.apache.axis.types.IDRefs.class,
                                             Constants.XSD_IDREFS),
                   new SimpleDeserializerFactory(org.apache.axis.types.IDRefs.class,
                                             Constants.XSD_IDREFS)
        );
        
        // a xsd:Duration
        myRegister(Constants.XSD_DURATION, org.apache.axis.types.Duration.class,
                   new SimpleSerializerFactory(org.apache.axis.types.Duration.class,
                                             Constants.XSD_DURATION),
                   new SimpleDeserializerFactory(org.apache.axis.types.Duration.class,
                                             Constants.XSD_DURATION)
        );
        
        // a xsd:anyURI
        myRegister(Constants.XSD_ANYURI, org.apache.axis.types.URI.class,
                   new SimpleSerializerFactory(org.apache.axis.types.URI.class,
                                             Constants.XSD_ANYURI),
                   new SimpleDeserializerFactory(org.apache.axis.types.URI.class,
                                             Constants.XSD_ANYURI)
        );

        // a xsd:schema
        myRegister(Constants.XSD_SCHEMA, org.apache.axis.types.Schema.class,
                   new BeanSerializerFactory(org.apache.axis.types.Schema.class,
                                             Constants.XSD_SCHEMA),
                   new BeanDeserializerFactory(org.apache.axis.types.Schema.class,
                                             Constants.XSD_SCHEMA)
        );
        
        // Need this at the default TypeMapping level so that we can correctly
        // obtain the ArraySerializer when in doc/lit mode and only have a
        // Java class available (no XML type metadata) - see TypeMappingImpl
        // (getSerializer())
        myRegister(Constants.SOAP_ARRAY,     java.util.ArrayList.class,
                   new ArraySerializerFactory(),
                   new ArrayDeserializerFactory()
        );

        //
        // Now register the schema specific types
        //
        SchemaVersion.SCHEMA_1999.registerSchemaSpecificTypes(this);
        SchemaVersion.SCHEMA_2000.registerSchemaSpecificTypes(this);
        SchemaVersion.SCHEMA_2001.registerSchemaSpecificTypes(this);

        inInitMappings = false;
    }

    /**
     * Register a "simple" type mapping - in other words, a
     * @param xmlType
     * @param javaType
     */
    protected void myRegisterSimple(QName xmlType, Class javaType) {
        SerializerFactory sf = new SimpleSerializerFactory(javaType, xmlType);
        DeserializerFactory df = null;
        if (javaType != java.lang.Object.class) {
            df = new SimpleDeserializerFactory(javaType, xmlType);
        }
        
        myRegister(xmlType, javaType, sf, df);        
    }

    /**
     * Construct TypeMapping for all the [xmlType, javaType] for all of the
     * known xmlType namespaces.  This is the shotgun approach, which works
     * in 99% of the cases.  The other cases that are Schema version specific
     * (i.e. timeInstant vs. dateTime) are handled by the SchemaVersion
     * Interface registerSchemaSpecificTypes().
     *
     * @param xmlType is the QName type
     * @param javaType is the java type
     * @param sf is the ser factory (if null, the simple factory is used)
     * @param df is the deser factory (if null, the simple factory is used)
     */
    protected void myRegister(QName xmlType, Class javaType,
                              SerializerFactory sf, DeserializerFactory df) {
        // Register all known flavors of the namespace.
        try {
            if (xmlType.getNamespaceURI().equals(
                    Constants.URI_DEFAULT_SCHEMA_XSD)) {
                for (int i=0; i < Constants.URIS_SCHEMA_XSD.length; i++) {
                    QName qName = new QName(Constants.URIS_SCHEMA_XSD[i],
                                            xmlType.getLocalPart());
                    super.internalRegister(javaType, qName, sf, df);
                }
            }
            else if (xmlType.getNamespaceURI().equals(
                    Constants.URI_DEFAULT_SOAP_ENC)) {
                for (int i=0; i < Constants.URIS_SOAP_ENC.length; i++) {
                    QName qName = new QName(Constants.URIS_SOAP_ENC[i],
                                            xmlType.getLocalPart());
                    super.internalRegister(javaType, qName, sf, df);
                }
            } else {
                // Register with the specified xmlType.
                // This is the prefered mapping and the last registed one wins
                super.internalRegister(javaType, xmlType, sf, df);
            }
        } catch (JAXRPCException e) { }
    }

    // Don't allow anyone to muck with the default type mapping because
    // it is a singleton used for the whole system.
    public void register(Class javaType, QName xmlType,
                         javax.xml.rpc.encoding.SerializerFactory sf,
                         javax.xml.rpc.encoding.DeserializerFactory dsf)
        throws JAXRPCException {
        super.register(javaType, xmlType, sf, dsf);
    }
    public void removeSerializer(Class javaType, QName xmlType)
        throws JAXRPCException {
        throw new JAXRPCException(Messages.getMessage("fixedTypeMapping"));
    }
    public void removeDeserializer(Class javaType, QName xmlType)
        throws JAXRPCException {
        throw new JAXRPCException(Messages.getMessage("fixedTypeMapping"));
    }
    public void setSupportedEncodings(String[] namespaceURIs) {
    }
}