axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From aj...@apache.org
Subject svn commit: r306583 [3/9] - in /webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2: databinding/ databinding/gen/ databinding/gen/impl/ databinding/symbolTable/ databinding/toJava/ databinding/utils/ databinding/utils/support/ wsdl/codeg...
Date Thu, 06 Oct 2005 10:55:27 GMT
Added: webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2/databinding/symbolTable/SymTabEntry.java
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2/databinding/symbolTable/SymTabEntry.java?rev=306583&view=auto
==============================================================================
--- webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2/databinding/symbolTable/SymTabEntry.java (added)
+++ webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2/databinding/symbolTable/SymTabEntry.java Thu Oct  6 03:54:18 2005
@@ -0,0 +1,166 @@
+/*
+ * 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.axis2.databinding.symbolTable;
+
+import javax.xml.namespace.QName;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+/**
+ * SymTabEntry is the base class for all symbol table entries.  It contains four things:
+ * - a QName
+ * - space for a Writer-specific name (for example, in Wsdl2java, this will be the Java name)
+ * - isReferenced flag indicating whether this entry is referenced by other entries
+ * - dynamicVars; a mechanism for Writers to add additional context information onto entries.
+ */
+public abstract class SymTabEntry {
+
+    // The QName of this entry is immutable.  There is no setter for  it.
+
+    /** Field qname */
+    protected QName qname;
+
+    // The name is Writer implementation dependent.  For example, in Wsdl2java, this will become
+    // the Java name.
+
+    /** Field name */
+    protected String name;
+
+    // Is this entry referenced by any other entry?
+
+    /** Field isReferenced */
+    private boolean isReferenced = false;
+
+    /** Field dynamicVars */
+    private HashMap dynamicVars = new HashMap();
+
+    /**
+     * Construct a symbol table entry with the given QName.
+     * 
+     * @param qname 
+     */
+    protected SymTabEntry(QName qname) {
+        this.qname = qname;
+    }    // ctor
+
+    /**
+     * Get the QName of this entry.
+     * 
+     * @return 
+     */
+    public final QName getQName() {
+        return qname;
+    }    // getQName
+
+    /**
+     * Get the name of this entry.  The name is Writer-implementation-dependent.  For example, in
+     * Wsdl2java, this will become the Java name.
+     * 
+     * @return 
+     */
+    public String getName() {
+        return name;
+    }    // getName
+
+    /**
+     * Set the name of this entry.  This method is not called by the framework, it is only called
+     * by the Writer implementation.
+     * 
+     * @param name 
+     */
+    public void setName(String name) {
+        this.name = name;
+    }    // setName
+
+    /**
+     * Is this entry referenced by any other entry in the symbol table?
+     * 
+     * @return 
+     */
+    public final boolean isReferenced() {
+        return isReferenced;
+    }    // isReferenced
+
+    /**
+     * Set the isReferenced variable, default value is true.
+     * 
+     * @param isReferenced 
+     */
+    public final void setIsReferenced(boolean isReferenced) {
+        this.isReferenced = isReferenced;
+    }    // setIsReferenced
+
+    /**
+     * There may be information that does not exist in WSDL4J/DOM
+     * structures and does not exist in
+     * our additional structures, but that Writer implementation
+     * will need.  This information is
+     * most likely context-relative, so the DynamicVar map is
+     * provided for the Writers to store and
+     * retrieve their particular information.
+     * 
+     * @param key 
+     * @return 
+     */
+    public Object getDynamicVar(Object key) {
+        return dynamicVars.get(key);
+    }    // getDynamicVar
+
+    /**
+     * Method setDynamicVar
+     * 
+     * @param key   
+     * @param value 
+     */
+    public void setDynamicVar(Object key, Object value) {
+        dynamicVars.put(key, value);
+    }    // setDynamicVar
+
+    /**
+     * Collate the info in this object in string form.
+     * 
+     * @return 
+     */
+    public String toString() {
+        return toString("");
+    }    // toString
+
+    /**
+     * Collate the info in this object in string form with indentation.
+     * 
+     * @param indent 
+     * @return 
+     */
+    protected String toString(String indent) {
+
+        String string = indent + "QName:         " + qname + '\n' + indent
+                + "name:          " + name + '\n' + indent
+                + "isReferenced?  " + isReferenced + '\n';
+        String prefix = indent + "dynamicVars:   ";
+        Iterator entries = dynamicVars.entrySet().iterator();
+
+        while (entries.hasNext()) {
+            Map.Entry entry = (Map.Entry) entries.next();
+            Object key = entry.getKey();
+
+            string += prefix + key + " = " + entry.getValue() + '\n';
+            prefix = indent + "               ";
+        }
+
+        return string;
+    }    // toString
+}    // abstract class SymTabEntry

Added: webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2/databinding/symbolTable/SymbolTable.java
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2/databinding/symbolTable/SymbolTable.java?rev=306583&view=auto
==============================================================================
--- webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2/databinding/symbolTable/SymbolTable.java (added)
+++ webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2/databinding/symbolTable/SymbolTable.java Thu Oct  6 03:54:18 2005
@@ -0,0 +1,1147 @@
+/*
+ * 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.axis2.databinding.symbolTable;
+
+
+import org.apache.axis2.wsdl.WSDLVersionWrapper;
+import org.apache.axis2.databinding.Constants;
+import org.apache.axis2.databinding.utils.support.BooleanHolder;
+import org.apache.axis2.databinding.utils.support.IntHolder;
+import org.apache.axis2.databinding.utils.support.QNameHolder;
+import org.apache.wsdl.WSDLDescription;
+import org.apache.wsdl.WSDLTypes;
+import org.apache.wsdl.extensions.Schema;
+import org.w3c.dom.*;
+import org.xml.sax.SAXException;
+
+import javax.xml.namespace.QName;
+import javax.xml.parsers.ParserConfigurationException;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.Vector;
+
+/**
+ * This class represents a table of all of the top-level symbols from a set of WSDL Definitions and
+ * DOM Documents:  XML types; WSDL messages, portTypes, bindings, and services.
+ * <p/>
+ * This symbolTable contains entries of the form <key, value> where key is of type QName and value is
+ * of type Vector.  The Vector's elements are all of the objects that have the given QName.  This is
+ * necessary since names aren't unique among the WSDL types.  message, portType, binding, service,
+ * could all have the same QName and are differentiated merely by type.  SymbolTable contains
+ * type-specific getters to bypass the Vector layer:
+ * public PortTypeEntry getPortTypeEntry(QName name), etc.
+ */
+public class SymbolTable {
+
+    // used to cache dervied types
+    protected HashMap derivedTypes = new HashMap();
+
+    // Should the contents of imported files be added to the symbol table?
+
+    /** Field addImports */
+    private boolean addImports;
+
+
+    /** Field symbolTable */
+    private HashMap symbolTable = new HashMap();
+
+    // a map of qnames -> Elements in the symbol table
+
+    /** Field elementTypeEntries */
+    private final Map elementTypeEntries = new HashMap();
+
+    // an unmodifiable wrapper so that we can share the index with others, safely
+
+    /** Field elementIndex */
+    private final Map elementIndex =
+            Collections.unmodifiableMap(elementTypeEntries);
+
+    // a map of qnames -> Types in the symbol table
+
+    /** Field typeTypeEntries */
+    private final Map typeTypeEntries = new HashMap();
+
+    // an unmodifiable wrapper so that we can share the index with others, safely
+
+    /** Field typeIndex */
+    private final Map typeIndex = Collections.unmodifiableMap(typeTypeEntries);
+
+    /**
+     * cache of nodes -> base types for complexTypes.  The cache is
+     * built on nodes because multiple TypeEntry objects may use the
+     * same node.
+     */
+    protected final Map node2ExtensionBase =
+            new HashMap();    // allow friendly access
+
+
+    /** Field quiet */
+    protected boolean quiet;
+
+    /** Field btm */
+    private BaseTypeMapping btm = null;
+
+    /** Field ANON_TOKEN */
+    public static final String ANON_TOKEN = ">";
+
+
+    /** Field wsdlURI */
+    private String wsdlURI = null;
+
+    /** If this is false, we will "unwrap" literal arrays, generating a plan "String[]" instead
+     * of "ArrayOfString" when encountering an element containing a single maxOccurs="unbounded"
+     * inner element.
+     */
+    private boolean wrapArrays;
+
+    Set arrayTypeQNames = new HashSet();
+
+    /**
+     * Construct a symbol table with the given Namespaces.
+     * 
+     * @param btm
+     * @param addImports
+     * @param verbose
+     * @param nowrap
+     */
+    public SymbolTable(BaseTypeMapping btm, boolean addImports ) {
+
+        this.btm = btm;
+        this.addImports = addImports;
+
+    }    // ctor
+
+    /**
+     * Method isQuiet
+     * 
+     * @return
+     */
+    public boolean isQuiet() {
+        return quiet;
+    }
+
+    /**
+     * Method setQuiet
+     * 
+     * @param quiet
+     */
+    public void setQuiet(boolean quiet) {
+        this.quiet = quiet;
+    }
+
+    /**
+     * Get the raw symbol table HashMap.
+     * 
+     * @return
+     */
+    public HashMap getHashMap() {
+        return symbolTable;
+    }    // getHashMap
+
+    /**
+     * Get the list of entries with the given QName.  Since symbols can share QNames, this list is
+     * necessary.  This list will not contain any more than one element of any given SymTabEntry.
+     * 
+     * @param qname
+     * @return
+     */
+    public Vector getSymbols(QName qname) {
+        return (Vector) symbolTable.get(qname);
+    }    // get
+
+    /**
+     * Get the entry with the given QName of the given class.  If it does not exist, return null.
+     * 
+     * @param qname
+     * @param cls
+     * @return
+     */
+    public SymTabEntry get(QName qname, Class cls) {
+
+        Vector v = (Vector) symbolTable.get(qname);
+
+        if (v == null) {
+            return null;
+        } else {
+            for (int i = 0; i < v.size(); ++i) {
+                SymTabEntry entry = (SymTabEntry) v.elementAt(i);
+
+                if (cls.isInstance(entry)) {
+                    return entry;
+                }
+            }
+
+            return null;
+        }
+    }    // get
+
+    /**
+     * Get the type entry for the given qname.
+     * 
+     * @param qname
+     * @param wantElementType boolean that indicates type or element (for type= or ref=)
+     * @return
+     */
+    public TypeEntry getTypeEntry(QName qname, boolean wantElementType) {
+
+        if (wantElementType) {
+            return getElement(qname);
+        } else {
+            return getType(qname);
+        }
+    }    // getTypeEntry
+
+    /**
+     * Get the Type TypeEntry with the given QName.  If it doesn't
+     * exist, return null.
+     * 
+     * @param qname
+     * @return
+     */
+    public Type getType(QName qname) {
+        return (Type) typeTypeEntries.get(qname);
+    }    // getType
+
+    /**
+     * Get the Element TypeEntry with the given QName.  If it doesn't
+     * exist, return null.
+     * 
+     * @param qname
+     * @return
+     */
+    public Element getElement(QName qname) {
+        return (Element) elementTypeEntries.get(qname);
+    }    // getElement
+
+
+
+    /**
+     * Get the list of all the XML schema types in the symbol table.  In other words, all entries
+     * that are instances of TypeEntry.
+     * 
+     * @return
+     * @deprecated use specialized get{Element,Type}Index() methods instead
+     */
+    public Vector getTypes() {
+
+        Vector v = new Vector();
+
+        v.addAll(elementTypeEntries.values());
+        v.addAll(typeTypeEntries.values());
+
+        return v;
+    }    // getTypes
+
+    /**
+     * Return an unmodifiable map of qnames -> Elements in the symbol
+     * table.
+     * 
+     * @return an unmodifiable <code>Map</code> value
+     */
+    public Map getElementIndex() {
+        return elementIndex;
+    }
+
+    /**
+     * Return an unmodifiable map of qnames -> Elements in the symbol
+     * table.
+     * 
+     * @return an unmodifiable <code>Map</code> value
+     */
+    public Map getTypeIndex() {
+        return typeIndex;
+    }
+
+    /**
+     * Return the count of TypeEntries in the symbol table.
+     * 
+     * @return an <code>int</code> value
+     */
+    public int getTypeEntryCount() {
+        return elementTypeEntries.size() + typeTypeEntries.size();
+    }
+
+
+
+    /**
+     * Get the WSDL URI.  The WSDL URI is null until populate
+     * is called, and ONLY if a WSDL URI is provided.
+     * 
+     * @return
+     */
+    public String getWSDLURI() {
+        return wsdlURI;
+    }    // getWSDLURI
+
+
+
+    /**
+     * Dump the contents of the symbol table.  For debugging purposes only.
+     * 
+     * @param out
+     */
+    public void dump(java.io.PrintStream out) {
+        out.println("-----------------------");
+        Iterator it = symbolTable.values().iterator();
+
+        while (it.hasNext()) {
+            Vector v = (Vector) it.next();
+
+            for (int i = 0; i < v.size(); ++i) {
+                out.println(v.elementAt(i).getClass().getName());
+                out.println(v.elementAt(i));
+            }
+        }
+
+        out.println("-----------------------");
+    }    // dump
+
+
+    /**
+     *
+     * @param versionWrapper
+     * @throws IOException
+     * @throws SAXException
+     * @throws ParserConfigurationException
+     */
+    public void populate(WSDLVersionWrapper versionWrapper)
+            throws IOException, SAXException, ParserConfigurationException {
+        if (versionWrapper.getDescription()!=null) {
+            populate(versionWrapper.getDescription());
+        }
+    }    // populate
+
+
+    /**
+     *
+     * @param description
+     * @throws IOException
+     * @throws SAXException
+     * @throws ParserConfigurationException
+     */
+    public void populate(WSDLDescription description)
+            throws IOException, SAXException, ParserConfigurationException {
+
+        //go through the types section and populate the types
+        WSDLTypes types = description.getTypes();
+        List elementsList = types.getExtensibilityElements();
+        for (int i = 0; i < elementsList.size(); i++) {
+            Object o =  elementsList.get(i);
+            if (o instanceof Schema){
+                populateTypes(null, ((Schema)o).getElement());
+            }else{
+                //ignore the non-schema elements
+            }
+
+        }
+
+    }    // populate
+
+
+
+
+
+
+
+
+    /**
+     * This is essentially a call to "new URL(contextURL, spec)" with extra handling in case spec is
+     * a file.
+     * 
+     * @param contextURL
+     * @param spec
+     * @return
+     * @throws IOException
+     */
+    private static URL getURL(URL contextURL, String spec) throws IOException {
+
+        // First, fix the slashes as windows filenames may have backslashes
+        // in them, but the URL class wont do the right thing when we later
+        // process this URL as the contextURL.
+        String path = spec.replace('\\', '/');
+
+        // See if we have a good URL.
+        URL url = null;
+
+        try {
+
+            // first, try to treat spec as a full URL
+            url = new URL(contextURL, path);
+
+            // if we are deail with files in both cases, create a url
+            // by using the directory of the context URL.
+            if ((contextURL != null) && url.getProtocol().equals("file")
+                    && contextURL.getProtocol().equals("file")) {
+                url = getFileURL(contextURL, path);
+            }
+        } catch (MalformedURLException me) {
+
+            // try treating is as a file pathname
+            url = getFileURL(contextURL, path);
+        }
+
+        // Everything is OK with this URL, although a file url constructed
+        // above may not exist.  This will be caught later when the URL is
+        // accessed.
+        return url;
+    }    // getURL
+
+    /**
+     * Method getFileURL
+     * 
+     * @param contextURL
+     * @param path
+     * @return
+     * @throws IOException
+     */
+    private static URL getFileURL(URL contextURL, String path)
+            throws IOException {
+
+        if (contextURL != null) {
+
+            // get the parent directory of the contextURL, and append
+            // the spec string to the end.
+            String contextFileName = contextURL.getFile();
+            URL parent = null;
+            File parentFile = new File(contextFileName).getParentFile();
+            if ( parentFile != null ) {
+                parent = parentFile.toURL();
+            }
+            if (parent != null) {
+                return new URL(parent, path);
+            }
+        }
+
+        return new URL("file", "", path);
+    }    // getFileURL
+
+    /**
+     * Check if this is a known namespace (soap-enc or schema xsd or schema xsi or xml)
+     * 
+     * @param namespace
+     * @return true if this is a know namespace.
+     */
+    public boolean isKnownNamespace(String namespace) {
+
+        if (Constants.isSOAP_ENC(namespace)) {
+            return true;
+        }
+
+        if (Constants.isSchemaXSD(namespace)) {
+            return true;
+        }
+
+        if (Constants.isSchemaXSI(namespace)) {
+            return true;
+        }
+
+        if (namespace.equals(Constants.NS_URI_XML)) {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Populate the symbol table with all of the Types from the Document.
+     * 
+     * @param context
+     * @param doc
+     * @throws IOException
+     * @throws SAXException
+     * @throws WSDLException
+     * @throws ParserConfigurationException
+     */
+    public void populateTypes(URL context, org.w3c.dom.Element doc)
+            throws IOException, SAXException,
+            ParserConfigurationException {
+        addTypes(context, doc, ABOVE_SCHEMA_LEVEL);
+    }    // populateTypes
+
+    /**
+     * Utility method which walks the Document and creates Type objects for
+     * each complexType, simpleType, attributeGroup or element referenced or defined.
+     * <p/>
+     * What goes into the symbol table?  In general, only the top-level types
+     * (ie., those just below
+     * the schema tag).  But base types and references can
+     * appear below the top level.  So anything
+     * at the top level is added to the symbol table,
+     * plus non-Element types (ie, base and refd)
+     * that appear deep within other types.
+     */
+    private static final int ABOVE_SCHEMA_LEVEL = -1;
+
+    /** Field SCHEMA_LEVEL */
+    private static final int SCHEMA_LEVEL = 0;
+
+    /**
+     * Method addTypes
+     * 
+     * @param context
+     * @param node
+     * @param level
+     * @throws IOException
+     * @throws ParserConfigurationException
+     * @throws WSDLException
+     * @throws SAXException
+     */
+    private void addTypes(URL context, Node node, int level)
+            throws IOException, ParserConfigurationException,
+            SAXException {
+
+        if (node == null) {
+            return;
+        }
+
+        // Get the kind of node (complexType, wsdl:part, etc.)
+        String localPart = node.getLocalName();
+
+        if (localPart != null) {
+            boolean isXSD =
+                    Constants.isSchemaXSD(node.getNamespaceURI());
+
+            if (((isXSD && localPart.equals("complexType"))
+                    || localPart.equals("simpleType"))) {
+
+                // If an extension or restriction is present,
+                // create a type for the reference
+                Node re = SchemaUtils.getRestrictionOrExtensionNode(node);
+
+                if ((re != null) && (Utils.getAttribute(re, "base") != null)) {
+                    createTypeFromRef(re);
+                }
+
+                Node list = SchemaUtils.getListNode(node);
+                if (list != null && Utils.getAttribute(list,"itemType") != null) {
+                    createTypeFromRef(list);
+                }
+
+                Node union = SchemaUtils.getUnionNode(node);
+                if (union != null) {
+                    QName [] memberTypes = Utils.getMemberTypeQNames(union);
+                    if (memberTypes != null) {
+                        for (int i=0;i<memberTypes.length;i++) {
+                            if (SchemaUtils.isSimpleSchemaType(memberTypes[i]) &&
+                                    getType(memberTypes[i]) == null) {
+                                symbolTablePut(new BaseType(memberTypes[i]));
+                            }
+                        }
+                    }
+                }
+
+                // This is a definition of a complex type.
+                // Create a Type.
+                createTypeFromDef(node, false, false);
+            } else if (isXSD && localPart.equals("element")) {
+
+                // Create a type entry for the referenced type
+                createTypeFromRef(node);
+
+                // If an extension or restriction is present,
+                // create a type for the reference
+                Node re = SchemaUtils.getRestrictionOrExtensionNode(node);
+
+                if ((re != null) && (Utils.getAttribute(re, "base") != null)) {
+                    createTypeFromRef(re);
+                }
+
+                // Create a type representing an element.  (This may
+                // seem like overkill, but is necessary to support ref=
+                // and element=.
+                createTypeFromDef(node, true, level > SCHEMA_LEVEL);
+            } else if (isXSD && localPart.equals("attributeGroup")) {
+
+                // bug 23145: support attributeGroup (Brook Richan)
+                // Create a type entry for the referenced type
+                createTypeFromRef(node);
+
+                // Create a type representing an attributeGroup.
+                createTypeFromDef(node, false, level > SCHEMA_LEVEL);
+            }  else if (isXSD && localPart.equals("group")) {
+                // Create a type entry for the referenced type
+                createTypeFromRef(node);
+                // Create a type representing an group
+                createTypeFromDef(node, false, level > SCHEMA_LEVEL);
+            } else if (isXSD && localPart.equals("attribute")) {
+                //todo this is disabled for now
+//                // Create a type entry for the referenced type
+//                BooleanHolder forElement = new BooleanHolder();
+//                QName refQName = Utils.getTypeQName(node, forElement,
+//                        false);
+//
+//                if ((refQName != null) && !forElement.value) {
+//                    createTypeFromRef(node);
+//
+//                    // Get the symbol table entry and make sure it is a simple
+//                    // type
+//                    if (refQName != null) {
+//                        TypeEntry refType = getTypeEntry(refQName, false);
+//
+//                        if ((refType != null)
+//                                && (refType instanceof Undefined)) {
+//
+//                            // Don't know what the type is.
+//                            // It better be simple so set it as simple
+//                            refType.setSimpleType(true);
+//                        } else if ((refType == null)
+//                                || (!(refType instanceof BaseType)
+//                                && !refType.isSimpleType())) {
+//
+//                            // Problem if not simple
+//                            throw new IOException();
+////                                    Messages.getMessage(
+////                                            "AttrNotSimpleType01",
+////                                            refQName.toString()));
+//                        }
+//                    }
+//                }
+//                createTypeFromDef(node, true, level > SCHEMA_LEVEL);
+            } else if (isXSD && localPart.equals("any")) {
+
+                // Map xsd:any element to special xsd:any "type"
+                if (getType(Constants.XSD_ANY) == null) {
+                    Type type = new BaseType(Constants.XSD_ANY);
+
+                    symbolTablePut(type);
+                }
+            } else if (localPart.equals("part")
+                    && Constants.isWSDL(node.getNamespaceURI())) {
+
+                // This is a wsdl part.  Create an TypeEntry representing the reference
+                createTypeFromRef(node);
+            } else if (isXSD && localPart.equals("include")) {
+               //todo This is also disabled for now
+//                String includeName = Utils.getAttribute(node, "schemaLocation");
+//
+//                if (includeName != null) {
+//                    URL url = getURL(context, includeName);
+//                    Document includeDoc = XMLUtils.newDocument(url.toString());
+//
+//                    // Vidyanand : Fix for Bug #15124
+//                    org.w3c.dom.Element schemaEl =
+//                            includeDoc.getDocumentElement();
+//
+//                    if (!schemaEl.hasAttribute("targetNamespace")) {
+//                        org.w3c.dom.Element parentSchemaEl =
+//                                (org.w3c.dom.Element) node.getParentNode();
+//
+//                        if (parentSchemaEl.hasAttribute("targetNamespace")) {
+//
+//                            // we need to set two things in here
+//                            // 1. targetNamespace
+//                            // 2. setup the xmlns=<targetNamespace> attribute
+//                            String tns =
+//                                    parentSchemaEl.getAttribute("targetNamespace");
+//
+//                            schemaEl.setAttribute("targetNamespace", tns);
+//                            schemaEl.setAttribute("xmlns", tns);
+//                        }
+//                    }
+//
+//                    populate(url, null, includeDoc, url.toString());
+//                }
+            }
+        }
+
+        if (level == ABOVE_SCHEMA_LEVEL) {
+            if ((localPart != null)
+                    && localPart.equals("schema")) {
+                level = SCHEMA_LEVEL;
+            }
+        } else {
+            ++level;
+        }
+
+        // Recurse through children nodes
+        NodeList children = node.getChildNodes();
+
+        for (int i = 0; i < children.getLength(); i++) {
+            addTypes(context, children.item(i), level);
+        }
+    }    // addTypes
+
+    /**
+     * Create a TypeEntry from the indicated node, which defines a type
+     * that represents a complexType, simpleType or element (for ref=).
+     * 
+     * @param node
+     * @param isElement
+     * @param belowSchemaLevel
+     * @throws IOException
+     */
+    private void createTypeFromDef(
+            Node node, boolean isElement, boolean belowSchemaLevel)
+            throws IOException {
+
+        // Get the QName of the node's name attribute value
+        QName qName = Utils.getNodeNameQName(node);
+
+        if (qName != null) {
+
+            // If the qname is already registered as a base type,
+            // don't create a defining type/element.
+            if (!isElement && (btm.getBaseName(qName) != null)) {
+                return;
+            }
+
+            // If the node has a type or ref attribute, get the
+            // qname representing the type
+            BooleanHolder forElement = new BooleanHolder();
+            QName refQName = Utils.getTypeQName(node, forElement,
+                    false);
+
+            if (refQName != null) {
+
+                // Error check - bug 12362
+                if (qName.getLocalPart().length() == 0) {
+                    String name = Utils.getAttribute(node, "name");
+
+                    if (name == null) {
+                        name = "unknown";
+                    }
+
+                    throw new IOException();//Messages.getMessage("emptyref00",
+//                            name));
+                }
+
+                // Now get the TypeEntry
+                TypeEntry refType = getTypeEntry(refQName, forElement.value);
+
+                if (!belowSchemaLevel) {
+                    if (refType == null) {
+                        throw new IOException( );
+//                                Messages.getMessage(
+//                                        "absentRef00", refQName.toString(),
+//                                        qName.toString()));
+                    }
+
+                    symbolTablePut(new DefinedElement(qName, refType, node,
+                            ""));
+                }
+            } else {
+
+                // Flow to here indicates no type= or ref= attribute.
+                // See if this is an array or simple type definition.
+                IntHolder numDims = new IntHolder();
+
+                // If we're supposed to unwrap arrays, supply someplace to put the "inner" QName
+                // so we can propagate it into the appropriate metadata container.
+                QNameHolder itemQName = wrapArrays ? null : new QNameHolder();
+
+                numDims.value = 0;
+
+                QName arrayEQName =
+                        SchemaUtils.getArrayComponentQName(node,
+                                numDims,
+                                itemQName,
+                                this);
+
+                if (arrayEQName != null) {
+
+                    // Get the TypeEntry for the array element type
+                    refQName = arrayEQName;
+
+                    TypeEntry refType = getTypeEntry(refQName, false);
+
+                    if (refType == null) {
+//                        arrayTypeQNames.add(refQName);
+
+                        // Not defined yet, add one
+                        String baseName = btm.getBaseName(refQName);
+
+                        if (baseName != null) {
+                            refType = new BaseType(refQName);
+                        } else {
+                            refType = new UndefinedType(refQName);
+                        }
+
+                        symbolTablePut(refType);
+                    }
+
+                    // Create a defined type or element that references refType
+                    String dims = "";
+
+                    while (numDims.value > 0) {
+                        dims += "[]";
+
+                        numDims.value--;
+                    }
+
+                    TypeEntry defType = null;
+
+                    if (isElement) {
+                        if (!belowSchemaLevel) {
+                            defType =
+                                    new DefinedElement(qName, refType, node, dims);
+                            // Save component type for ArraySerializer
+                            defType.setComponentType(arrayEQName);
+                            if (itemQName != null)
+                                defType.setItemQName(itemQName.value);
+                        }
+                    } else {
+                        defType = new DefinedType(qName, refType, node, dims);
+                        // Save component type for ArraySerializer
+                        defType.setComponentType(arrayEQName);
+                        if (itemQName != null)
+                            defType.setItemQName(itemQName.value);
+                    }
+
+                    if (defType != null) {
+                        symbolTablePut(defType);
+                    }
+                } else {
+
+                    // Create a TypeEntry representing this  type/element
+                    String baseName = btm.getBaseName(qName);
+
+                    if (baseName != null) {
+                        symbolTablePut(new BaseType(qName));
+                    } else {
+
+                        // Create a type entry, set whether it should
+                        // be mapped as a simple type, and put it in the
+                        // symbol table.
+                        TypeEntry te = null;
+                        TypeEntry parentType = null;
+
+                        if (!isElement) {
+                            te = new DefinedType(qName, node);
+
+                            // check if we are an anonymous type underneath
+                            // an element.  If so, we point the refType of the
+                            // element to us (the real type).
+                            if (qName.getLocalPart().indexOf(ANON_TOKEN) >= 0) {
+                                Node parent = node.getParentNode();
+                                QName parentQName =
+                                        Utils.getNodeNameQName(parent);
+                                parentType = getElement(parentQName);
+                            }
+                        } else {
+                            if (!belowSchemaLevel) {
+                                te = new DefinedElement(qName, node);
+                            }
+                        }
+
+                        if (te != null) {
+                            if (SchemaUtils.isSimpleTypeOrSimpleContent(node)) {
+                                te.setSimpleType(true);
+                            }
+                            te = (TypeEntry)symbolTablePut(te);
+
+                            if (parentType != null) {
+                                parentType.setRefType(te);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }    // createTypeFromDef
+
+    /**
+     * Node may contain a reference (via type=, ref=, or element= attributes) to
+     * another type.  Create a Type object representing this referenced type.
+     * 
+     * @param node
+     * @throws IOException
+     */
+    private void createTypeFromRef(Node node) throws IOException {
+
+        // Get the QName of the node's type attribute value
+        BooleanHolder forElement = new BooleanHolder();
+        QName qName = Utils.getTypeQName(node, forElement, false);
+
+        if (qName == null || (Constants.isSchemaXSD(qName.getNamespaceURI()) &&
+                qName.getLocalPart().equals("simpleRestrictionModel"))) {
+            return;
+        }
+
+        // Error check - bug 12362
+        if (qName.getLocalPart().length() == 0) {
+            String name = Utils.getAttribute(node, "name");
+
+            if (name == null) {
+                name = "unknown";
+            }
+
+            throw new IOException();//Messages.getMessage("emptyref00", name));
+        }
+
+        // Get Type or Element depending on whether type attr was used.
+        TypeEntry type = getTypeEntry(qName, forElement.value);
+
+        // A symbol table entry is created if the TypeEntry is not found
+        if (type == null) {
+
+            // See if this is a special QName for collections
+            if (qName.getLocalPart().indexOf("[") > 0) {
+                QName containedQName = Utils.getTypeQName(node,
+                        forElement, true);
+                TypeEntry containedTE = getTypeEntry(containedQName,
+                        forElement.value);
+
+                if (!forElement.value) {
+
+                    // Case of type and maxOccurs
+                    if (containedTE == null) {
+
+                        // Collection Element Type not defined yet, add one.
+                        String baseName = btm.getBaseName(containedQName);
+
+                        if (baseName != null) {
+                            containedTE = new BaseType(containedQName);
+                        } else {
+                            containedTE = new UndefinedType(containedQName);
+                        }
+
+                        symbolTablePut(containedTE);
+                    }
+
+                    symbolTablePut(new CollectionType(qName, containedTE,
+                            node, "[]"));
+                } else {
+
+                    // Case of ref and maxOccurs
+                    if (containedTE == null) {
+                        containedTE = new UndefinedElement(containedQName);
+
+                        symbolTablePut(containedTE);
+                    }
+
+                    symbolTablePut(new CollectionElement(qName,
+                            containedTE, node,
+                            "[]"));
+                }
+            } else {
+
+                // Add a BaseType or Undefined Type/Element
+                String baseName = btm.getBaseName(qName);
+
+                if (baseName != null) {
+                    symbolTablePut(new BaseType(qName));
+
+                    // bugzilla 23145: handle attribute groups
+                    // soap/encoding is treated as a "known" schema
+                    // so now let's act like we know it
+                } else if (qName.equals(Constants.SOAP_COMMON_ATTRS11)) {
+                    symbolTablePut(new BaseType(qName));
+
+                    // the 1.1 commonAttributes type contains two attributes
+                    // make sure those attributes' types are in the symbol table
+                    // attribute name = "id" type = "xsd:ID"
+                    if (getTypeEntry(Constants.XSD_ID, false) == null) {
+                        symbolTablePut(new BaseType(Constants.XSD_ID));
+                    }
+
+                    // attribute name = "href" type = "xsd:anyURI"
+                    if (getTypeEntry(Constants.XSD_ANYURI, false) == null) {
+                        symbolTablePut(new BaseType(Constants.XSD_ANYURI));
+                    }
+                } else if (qName.equals(Constants.SOAP_COMMON_ATTRS12)) {
+                    symbolTablePut(new BaseType(qName));
+
+                    // the 1.2 commonAttributes type contains one attribute
+                    // make sure the attribute's type is in the symbol table
+                    // attribute name = "id" type = "xsd:ID"
+                    if (getTypeEntry(Constants.XSD_ID, false) == null) {
+                        symbolTablePut(new BaseType(Constants.XSD_ID));
+                    }
+                } else if (qName.equals(Constants.SOAP_ARRAY_ATTRS11)) {
+                    symbolTablePut(new BaseType(qName));
+
+                    // the 1.1 arrayAttributes type contains two attributes
+                    // make sure the attributes' types are in the symbol table
+                    // attribute name = "arrayType" type = "xsd:string"
+                    if (getTypeEntry(Constants.XSD_STRING, false) == null) {
+                        symbolTablePut(new BaseType(Constants.XSD_STRING));
+                    }
+
+                    // attribute name = "offset" type = "soapenc:arrayCoordinate"
+                    // which is really an xsd:string
+                } else if (qName.equals(Constants.SOAP_ARRAY_ATTRS12)) {
+                    symbolTablePut(new BaseType(qName));
+
+                    // the 1.2 arrayAttributes type contains two attributes
+                    // make sure the attributes' types are in the symbol table
+                    // attribute name = "arraySize" type = "2003soapenc:arraySize"
+                    // which is really a hairy beast that is not
+                    // supported, yet; so let's just use string
+                    if (getTypeEntry(Constants.XSD_STRING, false) == null) {
+                        symbolTablePut(new BaseType(Constants.XSD_STRING));
+                    }
+
+                    // attribute name = "itemType" type = "xsd:QName"
+                    if (getTypeEntry(Constants.XSD_QNAME, false) == null) {
+                        symbolTablePut(new BaseType(Constants.XSD_QNAME));
+                    }
+                } else if (forElement.value == false) {
+                    symbolTablePut(new UndefinedType(qName));
+                } else {
+                    symbolTablePut(new UndefinedElement(qName));
+                }
+            }
+        }
+    }    // createTypeFromRef
+
+       /**
+     * Put the given SymTabEntry into the symbol table, if appropriate.
+     * 
+     * @param entry
+     * @throws IOException
+     */
+    private SymTabEntry symbolTablePut(SymTabEntry entry) throws IOException {
+
+        QName name = entry.getQName();
+
+        SymTabEntry e = get(name, entry.getClass());
+
+        if (e == null) {
+            e = entry;
+
+            // An entry of the given qname of the given type doesn't exist yet.
+            if ((entry instanceof Type)
+                    && (get(name, UndefinedType.class) != null)) {
+
+                // A undefined type exists in the symbol table, which means
+                // that the type is used, but we don't yet have a definition for
+                // the type.  Now we DO have a definition for the type, so
+                // replace the existing undefined type with the real type.
+                if (((TypeEntry) get(name, UndefinedType.class)).isSimpleType()
+                        && !((TypeEntry) entry).isSimpleType()) {
+
+                    // Problem if the undefined type was used in a
+                    // simple type context.
+                    throw new IOException();
+//                            Messages.getMessage(
+//                                    "AttrNotSimpleType01", name.toString()));
+                }
+
+                Vector v = (Vector) symbolTable.get(name);
+
+                for (int i = 0; i < v.size(); ++i) {
+                    Object oldEntry = v.elementAt(i);
+
+                    if (oldEntry instanceof UndefinedType) {
+
+                        // Replace it in the symbol table
+                        v.setElementAt(entry, i);
+
+                        // Replace it in the types index
+                        typeTypeEntries.put(name, entry);
+
+                        // Update all of the entries that refer to the unknown type
+                        ((UndefinedType) oldEntry).update((Type) entry);
+                    }
+                }
+            } else if ((entry instanceof Element)
+                    && (get(name, UndefinedElement.class) != null)) {
+
+                // A undefined element exists in the symbol table, which means
+                // that the element is used, but we don't yet have a definition for
+                // the element.  Now we DO have a definition for the element, so
+                // replace the existing undefined element with the real element.
+                Vector v = (Vector) symbolTable.get(name);
+
+                for (int i = 0; i < v.size(); ++i) {
+                    Object oldEntry = v.elementAt(i);
+
+                    if (oldEntry instanceof UndefinedElement) {
+
+                        // Replace it in the symbol table
+                        v.setElementAt(entry, i);
+
+                        // Replace it in the elements index
+                        elementTypeEntries.put(name, entry);
+
+                        // Update all of the entries that refer to the unknown type
+                        ((Undefined) oldEntry).update((Element) entry);
+                    }
+                }
+            } else {
+
+                // Add this entry to the symbol table
+                Vector v = (Vector) symbolTable.get(name);
+
+                if (v == null) {
+                    v = new Vector();
+
+                    symbolTable.put(name, v);
+                }
+
+                v.add(entry);
+
+                // add TypeEntries to specialized indices for
+                // fast lookups during reference resolution.
+                if (entry instanceof Element) {
+                    elementTypeEntries.put(name, entry);
+                } else if (entry instanceof Type) {
+                    typeTypeEntries.put(name, entry);
+                }
+            }
+        } else {
+            if (!quiet) {
+//                System.out.println(Messages.getMessage("alreadyExists00",
+//                        "" + name));
+            }
+        }
+
+        return e;
+    }    // symbolTablePut
+
+
+
+
+
+    protected void processTypes() {
+        for (Iterator i = typeTypeEntries.values().iterator(); i.hasNext(); ) {
+            Type type = (Type) i.next();
+            Node node = type.getNode();
+
+            // Process the attributes
+            Vector attributes =
+                    SchemaUtils.getContainedAttributeTypes(node, this);
+
+            if (attributes != null) {
+                type.setContainedAttributes(attributes);
+            }
+
+            // Process the elements
+            Vector elements =
+                    SchemaUtils.getContainedElementDeclarations(node, this);
+
+            if (elements != null) {
+                type.setContainedElements(elements);
+            }
+        }
+    }
+
+
+
+    public void setWrapArrays(boolean wrapArrays) {
+        this.wrapArrays = wrapArrays;
+    }
+}    // class SymbolTable

Added: webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2/databinding/symbolTable/Type.java
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2/databinding/symbolTable/Type.java?rev=306583&view=auto
==============================================================================
--- webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2/databinding/symbolTable/Type.java (added)
+++ webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2/databinding/symbolTable/Type.java Thu Oct  6 03:54:18 2005
@@ -0,0 +1,68 @@
+/*
+ * 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.axis2.databinding.symbolTable;
+
+import org.w3c.dom.Node;
+
+import javax.xml.namespace.QName;
+
+/**
+ * This class represents a TypeEntry that is a type (complexType, simpleType, etc.
+ * 
+ * @author Rich Scheuerle  (scheu@us.ibm.com)
+ */
+public abstract class Type extends TypeEntry {
+    private boolean generated;	// true if java class is generated during WSDL->Java processing
+    
+    /**
+     * Create a Type object for an xml construct name that represents a base type
+     * 
+     * @param pqName 
+     */
+    protected Type(QName pqName) {
+        super(pqName);
+    }
+
+    /**
+     * Create a TypeEntry object for an xml construct that references a type that has
+     * not been defined yet.  Defer processing until refType is known.
+     * 
+     * @param pqName  
+     * @param refType 
+     * @param pNode   
+     * @param dims    
+     */
+    protected Type(QName pqName, TypeEntry refType, Node pNode, String dims) {
+        super(pqName, refType, pNode, dims);
+    }
+
+    /**
+     * Create a Type object for an xml construct that is not a base type
+     * 
+     * @param pqName 
+     * @param pNode  
+     */
+    protected Type(QName pqName, Node pNode) {
+        super(pqName, pNode);
+    }
+    public void setGenerated(boolean b) {
+        generated = b;        
+    }
+    
+    public boolean isGenerated() {
+        return generated;
+    }
+}

Added: webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2/databinding/symbolTable/TypeEntry.java
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2/databinding/symbolTable/TypeEntry.java?rev=306583&view=auto
==============================================================================
--- webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2/databinding/symbolTable/TypeEntry.java (added)
+++ webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2/databinding/symbolTable/TypeEntry.java Thu Oct  6 03:54:18 2005
@@ -0,0 +1,487 @@
+/*
+ * 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.axis2.databinding.symbolTable;
+
+//import org.apache.axis.utils.Messages;
+import org.w3c.dom.Node;
+
+import javax.xml.namespace.QName;
+import java.io.IOException;
+import java.io.Serializable;
+import java.util.HashSet;
+import java.util.Vector;
+
+/**
+ * This class represents a wsdl types entry that is supported by the WSDL2Java emitter.
+ * A TypeEntry has a QName representing its XML name and a name, which in the
+ * WSDL2Java back end is its full java name.  The TypeEntry may also have a Node,
+ * which locates the definition of the emit type in the xml.
+ * A TypeEntry object extends SymTabEntry and is built by the SymbolTable class for
+ * each supported root complexType, simpleType, and elements that are
+ * defined or encountered.
+ * <p/>
+ * SymTabEntry
+ * |
+ * TypeEntry
+ * /           \
+ * Type                Element
+ * |                     |
+ * (BaseType,                    (DefinedElement,
+ * CollectionType                CollectionElement,
+ * DefinedType,                  UndefinedElement)
+ * UndefinedType)
+ * <p/>
+ * UndefinedType and UndefinedElement are placeholders when the real type or element
+ * is not encountered yet.  Both of these implement the Undefined interface.
+ * <p/>
+ * A TypeEntry whose java (or other language) name depends on an Undefined type, will
+ * have its name initialization deferred until the Undefined type is replaced with
+ * a defined type.  The updateUndefined() method is invoked by the UndefinedDelegate to
+ * update the information.
+ * <p/>
+ * Each TypeEntry whose language name depends on another TypeEntry will have the refType
+ * field set.  For example:
+ * <element name="foo" type="bar" />
+ * The TypeEntry for "foo" will have a refType set to the TypeEntry of "bar".
+ * <p/>
+ * Another Example:
+ * <xsd:complexType name="hobbyArray">
+ * <xsd:complexContent>
+ * <xsd:restriction base="soapenc:Array">
+ * <xsd:attribute ref="soapenc:arrayType" wsdl:arrayType="xsd:string[]"/>
+ * </xsd:restriction>
+ * </xsd:complexContent>
+ * </xsd:complexType>
+ * The TypeEntry for "hobbyArray" will have a refType that locates the TypeEntry for xsd:string
+ * and the dims field will be "[]"
+ * 
+ * @author Rich Scheuerle  (scheu@us.ibm.com)
+ */
+public abstract class TypeEntry extends SymTabEntry implements Serializable {
+
+    /** Field node */
+    protected Node node;                               // Node
+
+    /** Field refType */
+    protected TypeEntry refType;                       // Some TypeEntries refer to other types.
+
+    /** Field dims */
+    protected String dims = "";                        // If refType is an element, dims indicates
+
+                                                       // the array dims (for example "[]").
+
+    protected QName componentType = null;              // If this is an array, the component type
+
+    /** If this TypeEntry represents an array with elements inside a "wrapper"
+     * this field can optionally change the inner QName (default is <item>).
+     */
+    protected QName itemQName = null;
+
+    /** Field undefined */
+    protected boolean undefined;                       // If refType is an Undefined type
+
+    // (or has a refType that is Undefined)
+    // then the undefined flag is set.
+    // The name cannot be determined
+    // until the Undefined type is found.
+
+    /** Field isBaseType */
+    protected boolean isBaseType;                      // Indicates if represented by a
+
+    // primitive or util class
+
+    /** Field isSimpleType */
+    protected boolean isSimpleType =
+            false;                                         // Indicates if this type is a simple type
+
+    /** Field onlyLiteralReference */
+    protected boolean onlyLiteralReference = false;    // Indicates
+    
+    /** Field types */
+    protected HashSet types = null;
+    
+    /** contained elements in the schema's type definition */
+    protected Vector containedElements;
+
+    /** contained attributes in the schema's type definition */
+    protected Vector containedAttributes;
+
+    // whether this type is only referenced
+    // via a binding's literal use.
+
+    /**
+     * Create a TypeEntry object for an xml construct that references another type.
+     * Defer processing until refType is known.
+     * 
+     * @param pqName  
+     * @param refType 
+     * @param pNode   
+     * @param dims    
+     */
+    protected TypeEntry(QName pqName, TypeEntry refType, Node pNode,
+                        String dims) {
+
+        super(pqName);
+
+        node = pNode;
+        this.undefined = refType.undefined;
+        this.refType = refType;
+
+        if (dims == null) {
+            dims = "";
+        }
+
+        this.dims = dims;
+
+        if (refType.undefined) {
+
+            // Need to defer processing until known.
+            TypeEntry uType = refType;
+
+            while (!(uType instanceof Undefined)) {
+                uType = uType.refType;
+            }
+
+            ((Undefined) uType).register(this);
+        } else {
+            isBaseType = (refType.isBaseType && refType.dims.equals("")
+                    && dims.equals(""));
+        }
+    }
+
+    /**
+     * Create a TypeEntry object for an xml construct that is not a base type
+     * 
+     * @param pqName 
+     * @param pNode  
+     */
+    protected TypeEntry(QName pqName, Node pNode) {
+
+        super(pqName);
+
+        node = pNode;
+        refType = null;
+        undefined = false;
+        dims = "";
+        isBaseType = false;
+    }
+
+    /**
+     * Create a TypeEntry object for an xml construct name that represents a base type
+     * 
+     * @param pqName 
+     */
+    protected TypeEntry(QName pqName) {
+
+        super(pqName);
+
+        node = null;
+        undefined = false;
+        dims = "";
+        isBaseType = true;
+    }
+
+    /**
+     * Query the node for this type.
+     * 
+     * @return 
+     */
+    public Node getNode() {
+        return node;
+    }
+
+    /**
+     * Returns the Base Type Name.
+     * For example if the Type represents a schema integer, "int" is returned.
+     * If this is a user defined type, null is returned.
+     * 
+     * @return 
+     */
+    public String getBaseType() {
+
+        if (isBaseType) {
+            return name;
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Method isBaseType
+     * 
+     * @return 
+     */
+    public boolean isBaseType() {
+        return isBaseType;
+    }
+
+    /**
+     * Method setBaseType
+     * 
+     * @param baseType 
+     */
+    public void setBaseType(boolean baseType) {
+        isBaseType = baseType;
+    }
+    
+    /**
+     * Method isSimpleType
+     * 
+     * @return 
+     */
+    public boolean isSimpleType() {
+        return isSimpleType;
+    }
+
+    /**
+     * Method setSimpleType
+     * 
+     * @param simpleType 
+     */
+    public void setSimpleType(boolean simpleType) {
+        isSimpleType = simpleType;
+    }
+
+    /**
+     * Is this type references ONLY as a literal type?  If a binding's
+     * message's soapBody says:  use="literal", then a type is referenced
+     * literally.  Note that that type's contained types (ie., an address
+     * contains a phone#) are not referenced literally.  Since a type
+     * that is ONLY referenced as a literal may cause a generator to act
+     * differently (like WSDL2Java), this extra reference distinction is
+     * needed.
+     * 
+     * @return 
+     */
+    public boolean isOnlyLiteralReferenced() {
+        return onlyLiteralReference;
+    }    // isOnlyLiteralReferenced
+
+    /**
+     * Set the isOnlyLiteralReference flag.
+     * 
+     * @param set 
+     */
+    public void setOnlyLiteralReference(boolean set) {
+        onlyLiteralReference = set;
+    }    // setOnlyLiteralRefeerence
+
+    /**
+     * getUndefinedTypeRef returns the Undefined TypeEntry that this entry depends on or NULL.
+     * 
+     * @return 
+     */
+    protected TypeEntry getUndefinedTypeRef() {
+
+        if (this instanceof Undefined) {
+            return this;
+        }
+
+        if (undefined && (refType != null)) {
+            if (refType.undefined) {
+                TypeEntry uType = refType;
+
+                while (!(uType instanceof Undefined)) {
+                    uType = uType.refType;
+                }
+
+                return uType;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * UpdateUndefined is called when the ref TypeEntry is finally known.
+     * 
+     * @param oldRef The TypeEntry representing the Undefined TypeEntry
+     * @param newRef The replacement TypeEntry
+     * @return true if TypeEntry is changed in any way.
+     * @throws IOException 
+     */
+    protected boolean updateUndefined(TypeEntry oldRef, TypeEntry newRef)
+            throws IOException {
+
+        boolean changedState = false;
+
+        // Replace refType with the new one if applicable
+        if (refType == oldRef) {
+            refType = newRef;
+            changedState = true;
+
+            // Detect a loop
+            TypeEntry te = refType;
+
+            while ((te != null) && (te != this)) {
+                te = te.refType;
+            }
+
+            if (te == this) {
+
+                // Detected a loop.
+                undefined = false;
+                isBaseType = false;
+                node = null;
+
+                throw new IOException( );
+//                        Messages.getMessage(
+//                                "undefinedloop00", getQName().toString()));
+            }
+        }
+
+        // Update information if refType is now defined
+        if ((refType != null) && undefined && (refType.undefined == false)) {
+            undefined = false;
+            changedState = true;
+            isBaseType = (refType.isBaseType && refType.dims.equals("")
+                    && dims.equals(""));
+        }
+
+        return changedState;
+    }
+
+    /**
+     * If this type references another type, return that type, otherwise return null.
+     * 
+     * @return 
+     */
+    public TypeEntry getRefType() {
+        return refType;
+    }    // getRefType
+
+    /**
+     * Method setRefType
+     * 
+     * @param refType 
+     */
+    public void setRefType(TypeEntry refType) {
+        this.refType = refType;
+    }
+
+    /**
+     * Return the dimensions of this type, which can be 0 or more "[]".
+     * 
+     * @return 
+     */
+    public String getDimensions() {
+        return dims;
+    }    // getDimensions
+
+    /**
+     * Return the QName of the component if this is an array type
+     * @return QName of array elements or null
+     */
+    public QName getComponentType()
+    {
+        return componentType;
+    }
+
+    /**
+     * Set the QName of the component if this is an array type
+     */ 
+    public void setComponentType(QName componentType)
+    {
+        this.componentType = componentType;
+    }
+
+    public QName getItemQName() {
+        return itemQName;
+    }
+
+    public void setItemQName(QName itemQName) {
+        this.itemQName = itemQName;
+    }
+
+    /**
+     * Get string representation.
+     * 
+     * @return 
+     */
+    public String toString() {
+        return toString("");
+    }
+
+    /**
+     * Get string representation with indentation
+     * 
+     * @param indent 
+     * @return 
+     */
+    protected String toString(String indent) {
+
+        String refString = indent + "RefType:       null \n";
+
+        if (refType != null) {
+            refString = indent + "RefType:\n" + refType.toString(indent + "  ")
+                    + "\n";
+        }
+
+        return super.toString(indent) 
+                + indent + "Class:         " + this.getClass().getName() + "\n" 
+                + indent + "Base?:         " + isBaseType + "\n" 
+                + indent + "Undefined?:    " + undefined + "\n" 
+                + indent + "isSimpleType?  " + isSimpleType + "\n"
+                + indent + "Node:          " + getNode() + "\n" 
+                + indent + "Dims:          " + dims + "\n"              
+                + indent + "isOnlyLiteralReferenced: " + onlyLiteralReference + "\n"
+                + refString;
+    }
+
+    /**
+     * This method returns a set of all the nested types.
+     * Nested types are types declared within this TypeEntry (or descendents)
+     * plus any extended types and the extended type nested types
+     * The elements of the returned HashSet are Types.
+     * 
+     * @param symbolTable is the symbolTable
+     * @param derivedFlag should be set if all dependendent derived types should also be
+     *                    returned.
+     * @return 
+     */
+    public HashSet getNestedTypes(SymbolTable symbolTable,
+                                         boolean derivedFlag) {
+        if( types == null) {
+            types = Utils.getNestedTypes(this, symbolTable, derivedFlag);
+        }
+        return types;
+    }    // getNestedTypes
+
+    /**
+     * @return Returns the containedAttributes.
+     */
+    public Vector getContainedAttributes() {
+        return containedAttributes;
+    }
+    /**
+     * @param containedAttributes The containedAttributes to set.
+     */
+    public void setContainedAttributes(Vector containedAttributes) {
+        this.containedAttributes = containedAttributes;
+    }
+    /**
+     * @return Returns the containedElements.
+     */
+    public Vector getContainedElements() {
+        return containedElements;
+    }
+    /**
+     * @param containedElements The containedElements to set.
+     */
+    public void setContainedElements(Vector containedElements) {
+        this.containedElements = containedElements;
+    }
+}

Added: webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2/databinding/symbolTable/Undefined.java
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2/databinding/symbolTable/Undefined.java?rev=306583&view=auto
==============================================================================
--- webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2/databinding/symbolTable/Undefined.java (added)
+++ webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2/databinding/symbolTable/Undefined.java Thu Oct  6 03:54:18 2005
@@ -0,0 +1,41 @@
+/*
+ * 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.axis2.databinding.symbolTable;
+
+import java.io.IOException;
+
+/**
+ * This Undefined interface is implemented by UndefinedType and UndefinedElement.
+ */
+public interface Undefined {
+
+    /**
+     * Register referrant TypeEntry so that
+     * the code can update the TypeEntry when the Undefined Element or Type is defined
+     * 
+     * @param referrant 
+     */
+    public void register(TypeEntry referrant);
+
+    /**
+     * Call update with the actual TypeEntry.  This updates all of the
+     * referrant TypeEntry's that were registered.
+     * 
+     * @param def 
+     * @throws IOException 
+     */
+    public void update(TypeEntry def) throws IOException;
+}

Added: webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2/databinding/symbolTable/UndefinedDelegate.java
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2/databinding/symbolTable/UndefinedDelegate.java?rev=306583&view=auto
==============================================================================
--- webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2/databinding/symbolTable/UndefinedDelegate.java (added)
+++ webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2/databinding/symbolTable/UndefinedDelegate.java Thu Oct  6 03:54:18 2005
@@ -0,0 +1,91 @@
+/*
+ * 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.axis2.databinding.symbolTable;
+
+import java.io.IOException;
+import java.util.Vector;
+
+/**
+ * This UndefinedDelegate class implements the common functions of UndefinedType and UndefinedElement.
+ */
+public class UndefinedDelegate implements Undefined {
+
+    /** Field list */
+    private Vector list;
+
+    /** Field undefinedType */
+    private TypeEntry undefinedType;
+
+    /**
+     * Constructor
+     * 
+     * @param te 
+     */
+    UndefinedDelegate(TypeEntry te) {
+        list = new Vector();
+        undefinedType = te;
+    }
+
+    /**
+     * Register referrant TypeEntry so that
+     * the code can update the TypeEntry when the Undefined Element or Type is defined
+     * 
+     * @param referrant 
+     */
+    public void register(TypeEntry referrant) {
+        list.add(referrant);
+    }
+
+    /**
+     * Call update with the actual TypeEntry.  This updates all of the
+     * referrant TypeEntry's that were registered.
+     * 
+     * @param def 
+     * @throws IOException 
+     */
+    public void update(TypeEntry def) throws IOException {
+
+        boolean done = false;
+
+        while (!done) {
+            done = true;             // Assume this is the last pass
+
+            // Call updatedUndefined for all items on the list
+            // updateUndefined returns true if the state of the te TypeEntry
+            // is changed.  The outer loop is traversed until there are no more
+            // state changes.
+            for (int i = 0; i < list.size(); i++) {
+                TypeEntry te = (TypeEntry) list.elementAt(i);
+
+                if (te.updateUndefined(undefinedType, def)) {
+                    done = false;    // Items still undefined, need another pass
+                }
+            }
+        }
+
+        // It is possible that the def TypeEntry depends on an Undefined type.
+        // If so, register all of the entries with the undefined type.
+        TypeEntry uType = def.getUndefinedTypeRef();
+
+        if (uType != null) {
+            for (int i = 0; i < list.size(); i++) {
+                TypeEntry te = (TypeEntry) list.elementAt(i);
+
+                ((Undefined) uType).register(te);
+            }
+        }
+    }
+}

Added: webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2/databinding/symbolTable/UndefinedElement.java
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2/databinding/symbolTable/UndefinedElement.java?rev=306583&view=auto
==============================================================================
--- webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2/databinding/symbolTable/UndefinedElement.java (added)
+++ webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2/databinding/symbolTable/UndefinedElement.java Thu Oct  6 03:54:18 2005
@@ -0,0 +1,63 @@
+/*
+ * 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.axis2.databinding.symbolTable;
+
+import javax.xml.namespace.QName;
+import java.io.IOException;
+
+/**
+ * This represents a QName found in a reference but is not defined.
+ * If the type is later defined, the UndefinedType is replaced with a new Type
+ */
+public class UndefinedElement extends Element implements Undefined {
+
+    /** Field delegate */
+    private UndefinedDelegate delegate = null;
+
+    /**
+     * Construct a referenced (but as of yet undefined) element
+     * 
+     * @param pqName 
+     */
+    public UndefinedElement(QName pqName) {
+
+        super(pqName, null);
+
+        undefined = true;
+        delegate = new UndefinedDelegate(this);
+    }
+
+    /**
+     * Register referrant TypeEntry so that
+     * the code can update the TypeEntry when the Undefined Element or Type is defined
+     * 
+     * @param referrant 
+     */
+    public void register(TypeEntry referrant) {
+        delegate.register(referrant);
+    }
+
+    /**
+     * Call update with the actual TypeEntry.  This updates all of the
+     * referrant TypeEntry's that were registered.
+     * 
+     * @param def 
+     * @throws IOException 
+     */
+    public void update(TypeEntry def) throws IOException {
+        delegate.update(def);
+    }
+}

Added: webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2/databinding/symbolTable/UndefinedType.java
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2/databinding/symbolTable/UndefinedType.java?rev=306583&view=auto
==============================================================================
--- webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2/databinding/symbolTable/UndefinedType.java (added)
+++ webservices/axis2/trunk/java/modules/codegen/src/org/apache/axis2/databinding/symbolTable/UndefinedType.java Thu Oct  6 03:54:18 2005
@@ -0,0 +1,63 @@
+/*
+ * 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.axis2.databinding.symbolTable;
+
+import javax.xml.namespace.QName;
+import java.io.IOException;
+
+/**
+ * This represents a QName found in a reference but is not defined.
+ * If the type is later defined, the UndefinedType is replaced with a new Type
+ */
+public class UndefinedType extends Type implements Undefined {
+
+    /** Field delegate */
+    private UndefinedDelegate delegate = null;
+
+    /**
+     * Construct a referenced (but as of yet undefined) type
+     * 
+     * @param pqName 
+     */
+    public UndefinedType(QName pqName) {
+
+        super(pqName, null);
+
+        undefined = true;
+        delegate = new UndefinedDelegate(this);
+    }
+
+    /**
+     * Register referrant TypeEntry so that
+     * the code can update the TypeEntry when the Undefined Element or Type is defined
+     * 
+     * @param referrant 
+     */
+    public void register(TypeEntry referrant) {
+        delegate.register(referrant);
+    }
+
+    /**
+     * Call update with the actual TypeEntry.  This updates all of the
+     * referrant TypeEntry's that were registered.
+     * 
+     * @param def 
+     * @throws IOException 
+     */
+    public void update(TypeEntry def) throws IOException {
+        delegate.update(def);
+    }
+}



Mime
View raw message