View Javadoc

1   /*
2    * Copyright 2004,2007 The Apache Software Foundation.
3    * Portions Copyright 2006 International Business Machines Corp.
4    *
5    * Licensed under the Apache License, Version 2.0 (the "License");
6    * you may not use this file except in compliance with the License.
7    * You may obtain a copy of the License at
8    *
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  package org.apache.ws.commons.schema.extensions;
18  
19  import org.apache.ws.commons.schema.XmlSchemaObject;
20  import org.w3c.dom.Node;
21  
22  import javax.xml.namespace.QName;
23  import java.util.HashMap;
24  import java.util.Map;
25  
26  /**
27   * The task of the extension serializer is to delegate the serilization of
28   * the extensions. The extension serializers/deserializers are retained in seperate
29   * maps and there are also two seperate references to default serializers and deserializers
30   * which would jump into action when there are no specifically attached
31   * serializers/deserializers
32   */
33  public class ExtensionRegistry {
34  
35      /**
36       * Maps for the storage of extension serializers /deserializers
37       */
38      private Map extensionSerializers = new HashMap();
39      private Map extensionDeserializers = new HashMap();
40  
41      /**
42       * Default serializer and serializer
43       */
44      private ExtensionSerializer defaultExtensionSerializer  =new DefaultExtensionSerializer();
45      private ExtensionDeserializer defaultExtensionDeserializer = new DefaultExtensionDeserializer();
46  
47  
48      public ExtensionSerializer getDefaultExtensionSerializer() {
49          return defaultExtensionSerializer;
50      }
51  
52      public void setDefaultExtensionSerializer(ExtensionSerializer defaultExtensionSerializer) {
53          this.defaultExtensionSerializer = defaultExtensionSerializer;
54      }
55  
56      public ExtensionDeserializer getDefaultExtensionDeserializer() {
57          return defaultExtensionDeserializer;
58      }
59  
60      public void setDefaultExtensionDeserializer(ExtensionDeserializer defaultExtensionDeserializer) {
61          this.defaultExtensionDeserializer = defaultExtensionDeserializer;
62      }
63  
64      /**
65       * Register a deserializer with a QName
66       * @param name  - the QName of the element/attribute
67       * @param deserializer - an instance of the deserializer
68       */
69      public void registerDeserializer(QName name,ExtensionDeserializer deserializer){
70          extensionDeserializers.put(name,deserializer);
71      }
72      /**
73       * Register a serializer with a Class
74       * @param classOfType  - the class of the object that would be serialized
75       * @param serializer - an instance of the deserializer
76       */
77      public void registerSerializer(Class classOfType,ExtensionSerializer serializer){
78          extensionSerializers.put(classOfType,serializer);
79      }
80  
81  
82      /**
83       * remove the registration for a serializer with a QName
84       * @param name  - the QName of the element/attribute the
85       * serializer is associated with
86       */
87      public void unregisterSerializer(QName name){
88          extensionSerializers.remove(name);
89      }
90  
91      /**
92       * remove the registration for a deserializer with a QName
93       * @param classOfType  - the  the
94       * deserializer is associated with
95       */
96      public void unregisterDeserializer(Class classOfType){
97          extensionDeserializers.remove(classOfType);
98      }
99  
100 
101     /**
102      * Serialize a given extension element
103      * @param parentSchemaObject - the parent schema object. This is what
104      * would contain the extension object, probably in side its meta information
105      * map
106      * @param classOfType - The class of type to be serialized
107      * @param  node - the parent DOM Node that will ultimately be serialized. The XMLSchema
108      * serialization mechanism is to create a DOM tree first and serialize it
109      */
110     public void serializeExtension(XmlSchemaObject parentSchemaObject,
111                              Class classOfType,
112                              Node node){
113         Object serializerObject = extensionSerializers.get(classOfType);
114         if (serializerObject!=null){
115             //perform the serialization
116             ExtensionSerializer ser = (ExtensionSerializer)serializerObject;
117             ser.serialize(parentSchemaObject,classOfType,node);
118         }else if (defaultExtensionSerializer!=null) {
119             defaultExtensionSerializer.serialize(parentSchemaObject,classOfType,node);
120         }
121 
122 
123     }
124 
125 
126     /**
127      * Deserialize a given extension element
128      * @param parentSchemaObject - the parent schema object. This is anticipated
129      * to be created already and the relevant object would contain the extension
130      * object, probably in side its meta information map
131      * @param name - The qname of the element/attribute to be deserialized. This will be used to
132      * search for the extension as well as by the deserializer if a single deserializer is
133      * registered against a number of qnames
134      * @param  rawNode  - the raw DOM Node read from the source. This will be the
135      * extension element itself if for an element or extension attribute itself
136      * in case of an attribute
137      */
138     public void deserializeExtension(XmlSchemaObject parentSchemaObject,
139                              QName name,
140                              Node rawNode){
141         Object deserializerObject = extensionDeserializers.get(name);
142         if (deserializerObject !=null){
143             //perform the serialization
144             ExtensionDeserializer deser = (ExtensionDeserializer)deserializerObject;
145             deser.deserialize(parentSchemaObject,name,rawNode);
146         } else if (defaultExtensionDeserializer!=null){
147             defaultExtensionDeserializer.deserialize(parentSchemaObject,name,rawNode);
148         }
149     }
150 
151 }