View Javadoc

1   /*
2    * Copyright 2001-2004 The Apache Software Foundation.
3    * 
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    * 
8    *      http://www.apache.org/licenses/LICENSE-2.0
9    * 
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  package org.apache.geronimo.ews.jaxrpcmapping;
17  
18  import org.apache.axis.wsdl.gen.Generator;
19  import org.apache.axis.wsdl.symbolTable.SchemaUtils;
20  import org.apache.axis.wsdl.symbolTable.SymTabEntry;
21  import org.apache.axis.wsdl.symbolTable.SymbolTable;
22  import org.apache.axis.wsdl.symbolTable.TypeEntry;
23  import org.apache.axis.wsdl.toJava.JavaGeneratorFactory;
24  import org.apache.axis.wsdl.toJava.JavaWriter;
25  import org.apache.axis.wsdl.toJava.Utils;
26  import org.w3c.dom.Node;
27  
28  import javax.xml.namespace.QName;
29  import java.io.IOException;
30  import java.util.Vector;
31  
32  /***
33   * This is Wsdl2java's Type Writer.  It writes the following files, as appropriate:
34   * <typeName>.java, <typeName>Holder.java.
35   *
36   * @author Ias (iasandcb@tmax.co.kr)
37   * @deprecated no more used by J2eeGeneratorFactory
38   */
39  public class J2eeTypeWriter implements Generator {
40      public static final String HOLDER_IS_NEEDED = "Holder is needed";
41  
42      private Generator typeWriter = null;
43      private Generator holderWriter = null;
44  
45      /***
46       * Constructor.
47       */
48      public J2eeTypeWriter(J2eeEmitter emitter,
49                            TypeEntry type,
50                            SymbolTable symbolTable) {
51          if (type.isReferenced() && !type.isOnlyLiteralReferenced()) {
52              // Determine what sort of type this is and instantiate 
53              // the appropriate Writer.
54              Node node = type.getNode();
55  
56              // If it's an array, don't emit a class
57              if (!type.getName().endsWith("[]")) {
58                  // Generate the proper class for either "complex" or "enumeration" types
59                  Vector v = Utils.getEnumerationBaseAndValues(node, symbolTable);
60                  if (v != null) {
61                      typeWriter = getEnumTypeWriter(emitter, type, v);
62                  } else {
63                      TypeEntry base = SchemaUtils.getComplexElementExtensionBase(node, symbolTable);
64                      if (base == null) {
65                          base = SchemaUtils.getComplexElementRestrictionBase(node, symbolTable);
66                      }
67                      if (base == null) {
68                          QName baseQName = SchemaUtils.getSimpleTypeBase(node);
69                          if (baseQName != null) {
70                              base = symbolTable.getType(baseQName);
71                          }
72                      }
73                      typeWriter = getBeanWriter(emitter,
74                              type,
75                              SchemaUtils.getContainedElementDeclarations(node,
76                                      symbolTable),
77                              base,
78                              SchemaUtils.getContainedAttributeTypes(node,
79                                      symbolTable));
80                  }
81              }
82  
83              // If the holder is needed (ie., something uses this type as an out or inout
84              // parameter), instantiate the holder writer.
85              if (holderIsNeeded(type)) {
86                  holderWriter = getHolderWriter(emitter, type);
87              }
88          }
89      } // ctor
90  
91      /***
92       * Write all the service bindnigs:  service and testcase.
93       */
94      public void generate() throws IOException {
95          if (typeWriter != null) {
96              typeWriter.generate();
97          }
98          if (holderWriter != null) {
99              holderWriter.generate();
100         }
101     } // generate
102 
103     /***
104      * Does anything use this type as an inout/out parameter?  Query the Type dynamicVar
105      */
106     private boolean holderIsNeeded(SymTabEntry entry) {
107         Boolean holderIsNeeded =
108                 (Boolean) entry.getDynamicVar(HOLDER_IS_NEEDED);
109         return (holderIsNeeded != null && holderIsNeeded.booleanValue());
110     } // holderIsNeeded
111 
112     /***
113      * getEnumWriter
114      */
115     protected JavaWriter getEnumTypeWriter(J2eeEmitter emitter, TypeEntry type, Vector v) {
116         return new J2eeEnumTypeWriter(emitter, type, v);
117     }
118 
119     /***
120      * getBeanWriter
121      */
122     protected JavaWriter getBeanWriter(J2eeEmitter emitter, TypeEntry type,
123                                        Vector elements, TypeEntry base,
124                                        Vector attributes) {
125         JavaWriter helperWriter = getBeanHelperWriter(emitter, type, elements, base,
126                 attributes);
127         // If this complexType is referenced in a
128         // fault context, emit a bean-like exception 
129         // class
130         Boolean isComplexFault = (Boolean)
131                 type.getDynamicVar(JavaGeneratorFactory.COMPLEX_TYPE_FAULT);
132         if (isComplexFault != null &&
133                 isComplexFault.booleanValue()) {
134             return new J2eeBeanFaultWriter(emitter, type,
135                     elements, base, attributes,
136                     helperWriter);
137         }
138         return new J2eeBeanWriter(emitter, type,
139                 elements, base, attributes,
140                 helperWriter);
141     }
142 
143     /***
144      * getHelperWriter
145      */
146     protected JavaWriter getBeanHelperWriter(J2eeEmitter emitter, TypeEntry type,
147                                              Vector elements, TypeEntry base,
148                                              Vector attributes) {
149         return new J2eeBeanHelperWriter(emitter, type, elements, base, attributes);
150     }
151 
152     /***
153      * getHolderWriter
154      */
155     protected Generator getHolderWriter(J2eeEmitter emitter, TypeEntry type) {
156         return new J2eeHolderWriter(emitter, type);
157     }
158 }