incubator-yoko-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From br...@apache.org
Subject svn commit: r494510 [3/3] - in /incubator/yoko/trunk: bindings/src/main/java/org/apache/yoko/bindings/corba/ bindings/src/main/java/org/apache/yoko/bindings/corba/interceptors/ bindings/src/main/java/org/apache/yoko/bindings/corba/types/ bindings/src/t...
Date Tue, 09 Jan 2007 18:29:44 GMT
Added: incubator/yoko/trunk/tools/src/main/java/org/apache/yoko/tools/processors/wsdl/WSDLToCorbaHelper.java
URL: http://svn.apache.org/viewvc/incubator/yoko/trunk/tools/src/main/java/org/apache/yoko/tools/processors/wsdl/WSDLToCorbaHelper.java?view=auto&rev=494510
==============================================================================
--- incubator/yoko/trunk/tools/src/main/java/org/apache/yoko/tools/processors/wsdl/WSDLToCorbaHelper.java (added)
+++ incubator/yoko/trunk/tools/src/main/java/org/apache/yoko/tools/processors/wsdl/WSDLToCorbaHelper.java Tue Jan  9 10:29:42 2007
@@ -0,0 +1,1359 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.yoko.tools.processors.wsdl;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.wsdl.Binding;
+import javax.wsdl.Definition;
+import javax.wsdl.Part;
+
+import javax.xml.namespace.QName;
+
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.schemas.yoko.bindings.corba.CaseType;
+import org.apache.schemas.yoko.bindings.corba.Enum;
+import org.apache.schemas.yoko.bindings.corba.Enumerator;
+import org.apache.schemas.yoko.bindings.corba.MemberType;
+import org.apache.schemas.yoko.bindings.corba.Struct;
+import org.apache.schemas.yoko.bindings.corba.TypeMappingType;
+import org.apache.schemas.yoko.bindings.corba.Union;
+import org.apache.schemas.yoko.bindings.corba.Unionbranch;
+
+import org.apache.ws.commons.schema.XmlSchema;
+import org.apache.ws.commons.schema.XmlSchemaAll;
+import org.apache.ws.commons.schema.XmlSchemaAnnotation;
+import org.apache.ws.commons.schema.XmlSchemaAttribute;
+import org.apache.ws.commons.schema.XmlSchemaChoice;
+import org.apache.ws.commons.schema.XmlSchemaComplexContent;
+import org.apache.ws.commons.schema.XmlSchemaComplexContentExtension;
+import org.apache.ws.commons.schema.XmlSchemaComplexType;
+import org.apache.ws.commons.schema.XmlSchemaElement;
+import org.apache.ws.commons.schema.XmlSchemaEnumerationFacet;
+import org.apache.ws.commons.schema.XmlSchemaFacet;
+import org.apache.ws.commons.schema.XmlSchemaLengthFacet;
+import org.apache.ws.commons.schema.XmlSchemaMaxLengthFacet;
+import org.apache.ws.commons.schema.XmlSchemaParticle;
+import org.apache.ws.commons.schema.XmlSchemaSequence;
+import org.apache.ws.commons.schema.XmlSchemaSimpleContent;
+import org.apache.ws.commons.schema.XmlSchemaSimpleContentExtension;
+import org.apache.ws.commons.schema.XmlSchemaSimpleContentRestriction;
+import org.apache.ws.commons.schema.XmlSchemaSimpleType;
+import org.apache.ws.commons.schema.XmlSchemaSimpleTypeList;
+import org.apache.ws.commons.schema.XmlSchemaSimpleTypeRestriction;
+import org.apache.ws.commons.schema.XmlSchemaType;
+import org.apache.yoko.tools.common.CorbaPrimitiveMap;
+import org.apache.yoko.tools.common.ReferenceConstants;
+import org.apache.yoko.tools.common.W3CConstants;
+import org.apache.yoko.wsdl.CorbaConstants;
+import org.apache.yoko.wsdl.CorbaTypeImpl;
+
+public class WSDLToCorbaHelper {
+
+    public static final String REPO_STRING = "IDL:";
+    public static final String IDL_VERSION = ":1.0";
+
+    protected static final Logger LOG = LogUtils.getL7dLogger(WSDLToCorbaHelper.class);
+    protected static final String DISCRIMINATORTYPES[] 
+        = new String[] {"long", "short", "boolean", "char"};
+    protected static final Set<String> SUPPORTEDDISTYPES = 
+        new TreeSet<String>(Arrays.asList(DISCRIMINATORTYPES)); 
+
+    protected static final CorbaPrimitiveMap CORBAPRIMITIVEMAP = new CorbaPrimitiveMap();
+
+    String idlNamespace;
+    XmlSchema xmlSchemaType;
+    List<XmlSchema> xmlSchemaList;
+    TypeMappingType typeMappingType;
+    Definition def;
+
+    public void setXMLSchema(XmlSchema schema) {
+        xmlSchemaType = schema;
+    }
+
+    public void setTypeMap(TypeMappingType map) {
+        typeMappingType = map;
+    }
+
+    public void setIdlNamespace(String ns) {
+        idlNamespace = ns;
+    }
+
+    public String getIdlNamespace() {
+        return idlNamespace;
+    }
+
+    public void setXMLSchemaList(List<XmlSchema> list) {
+        xmlSchemaList = list;
+    }
+
+    public void setWsdlDefinition(Definition defn) {
+        def = defn;
+    }
+
+    public CorbaTypeImpl convertSchemaToCorbaType(XmlSchemaType stype, 
+                                                  QName defaultName,
+                                                  XmlSchemaType parent,
+                                                  XmlSchemaAnnotation annotation, 
+                                                  boolean anonymous)
+        throws Exception {
+        CorbaTypeImpl corbaTypeImpl = null;
+        if (!isAddressingNamespace(stype.getQName())) {
+            // need to determine if its a primitive type.
+            if (stype.getBaseSchemaType() != null) {
+                corbaTypeImpl = processPrimitiveType(stype.getQName());
+            }
+
+            if (stype instanceof XmlSchemaComplexType) {
+                return corbaTypeImpl = processComplexType((XmlSchemaComplexType)stype, 
+                                                          defaultName, annotation, anonymous);
+            } else if (stype instanceof XmlSchemaSimpleType) {            
+                return corbaTypeImpl = processSimpleType((XmlSchemaSimpleType)stype, 
+                                                         defaultName, anonymous);
+            }  else if (xmlSchemaType.getElementByName(stype.getQName()) != null) {
+                XmlSchemaElement el = xmlSchemaType.getElementByName(stype.getQName());
+                return corbaTypeImpl = processElementType(el, defaultName);
+            } else {
+                throw new Exception("Couldn't convert schema " + stype.getQName() + " to corba type");
+            }
+        }
+        return corbaTypeImpl;
+    }
+
+    protected List processContainerAsMembers(XmlSchemaParticle particle,
+                                             QName defaultName,
+                                             QName schemaTypeName)
+        throws Exception {
+        List<MemberType> members = new ArrayList<MemberType>();
+
+        Iterator iterL = null;
+        if (particle instanceof XmlSchemaSequence) {
+            XmlSchemaSequence scontainer = (XmlSchemaSequence)particle;
+            iterL = scontainer.getItems().getIterator();
+        } else if (particle instanceof XmlSchemaChoice) {
+            XmlSchemaChoice scontainer = (XmlSchemaChoice)particle;
+            iterL = scontainer.getItems().getIterator();
+        } else if (particle instanceof XmlSchemaAll) {
+            XmlSchemaAll acontainer = (XmlSchemaAll)particle;
+            iterL = acontainer.getItems().getIterator();
+        }
+
+        while (iterL.hasNext()) {
+            XmlSchemaParticle container = (XmlSchemaParticle)iterL.next();
+            
+            if (container instanceof XmlSchemaSequence) {
+                XmlSchemaSequence sequence = (XmlSchemaSequence)container;
+                CorbaTypeImpl memberType = processSequenceType(sequence, defaultName, schemaTypeName);
+                QName typeName = memberType.getQName();
+                if (memberType instanceof Struct) {
+                    memberType.setQName(null);                  
+                    if (memberType != null && !isDuplicate(memberType)) {
+                        typeMappingType.getStructOrExceptionOrUnion().add(memberType);
+                    }                    
+                }
+                
+                MemberType member = new MemberType(); 
+                member.setName(memberType.getName() + "_f");
+                member.setIdltype(typeName);
+                members.add(member);
+
+            } else if (container instanceof XmlSchemaChoice) {
+                XmlSchemaChoice choice = (XmlSchemaChoice)container;
+                CorbaTypeImpl corbatype = processChoice(choice, defaultName, schemaTypeName);
+                MemberType member = new MemberType(); 
+                member.setName(corbatype.getQName().getLocalPart());
+                member.setIdltype(corbatype.getQName());
+                members.add(member);
+            } else if (container instanceof XmlSchemaAll) {
+                XmlSchemaAll all = (XmlSchemaAll)container;
+                CorbaTypeImpl corbatype = processAllType(all, defaultName, schemaTypeName);
+                MemberType member = new MemberType(); 
+                member.setName(corbatype.getQName().getLocalPart());
+                member.setIdltype(corbatype.getQName());
+                members.add(member);
+            } else if (container instanceof XmlSchemaElement) {
+                XmlSchemaElement element = (XmlSchemaElement)container;
+                CorbaTypeImpl corbatype = processLocalElement(element);
+
+                if (corbatype != null) {
+                    MemberType member;
+                    String memberName = element.getQName().getLocalPart();
+
+                    member = new MemberType();
+                    member.setName(memberName);
+                    member.setIdltype(corbatype.getQName());                    
+                    members.add(member);
+                } else {
+                    String msg = "Unsupported Element Found in CORBA Binding Generation:"
+                                 + element.getQName();
+                    LOG.log(Level.WARNING, msg.toString());
+                }
+            }
+        }
+        return members;
+    }
+    
+    private CorbaTypeImpl processChoice(XmlSchemaChoice choice,
+                                        QName defaultName, 
+                                        QName schemaTypeName)
+        throws Exception {        
+        QName choicename = null;
+
+        if (schemaTypeName == null) {
+            choicename = createQNameTargetNamespace(defaultName.getLocalPart());
+        } else {
+            choicename = createQNameTargetNamespace(schemaTypeName.getLocalPart());
+        }
+        choicename = checkPrefix(choicename);
+
+        CorbaTypeImpl corbatype = createUnion(choicename, choice, defaultName, schemaTypeName);
+        String repoId = REPO_STRING + corbatype.getQName().getLocalPart().replace('.', '/') 
+            + IDL_VERSION;
+        ((Union)corbatype).setRepositoryID(repoId);                                
+
+        if (!(choice.getMaxOccurs() == 1) || !(choice.getMinOccurs() == 1)) {
+            QName name = createQNameTargetNamespace(corbatype.getQName().getLocalPart() + "Array");
+            CorbaTypeImpl arrayType = 
+                createArray(name, corbatype.getQName(), corbatype.getQName(), 
+                    choice.getMaxOccurs(), choice.getMinOccurs(), false);
+            
+            if (arrayType != null) {
+                arrayType.setQName(null);                
+                if (!isDuplicate(arrayType)) {
+                    typeMappingType.getStructOrExceptionOrUnion().add(arrayType);
+                }
+            }
+        }
+        return corbatype;
+    }
+    
+    private CorbaTypeImpl processLocalElement(XmlSchemaElement element) throws Exception {
+        CorbaTypeImpl membertype = new CorbaTypeImpl();
+        CorbaTypeImpl memtype = new CorbaTypeImpl();
+
+        QName memName = null;
+        if (element.isNillable()) {
+
+            CorbaTypeImpl elemtype = convertSchemaToCorbaType(element.getSchemaType(), element.getQName(),
+                                                              element.getSchemaType(), null, true);
+            QName name = createQNameTargetNamespace(elemtype.getQName().getLocalPart() + "_nil");
+            QName elName = checkPrefix(element.getQName());
+            if (elName ==  null) {
+                elName = createQNameTargetNamespace(element.getQName().getLocalPart());
+            }
+            memtype = createNillableUnion(name, elName, 
+                                             elemtype.getQName());
+            memName = createQNameCorbaNamespace(memtype.getQName().getLocalPart());
+                                    
+            if (memtype != null) {                          
+                memtype.setQName(null);
+                if (!isDuplicate(memtype)) {
+                    typeMappingType.getStructOrExceptionOrUnion().add(memtype);
+                }
+            }
+            membertype.setQName(memName);
+            membertype.setName(memtype.getName());
+            membertype.setType(memtype.getType());
+            
+        } else {
+            // Need TO DO
+            // Need to check if its referencing a type first refname=""
+            //if (element.getRefName()
+            if (element.getSchemaType() != null) {
+                XmlSchemaType st = element.getSchemaType();
+                boolean anonymous = WSDLTypes.isAnonymous(st.getName());            
+                membertype = convertSchemaToCorbaType(st, element.getQName(), st, null, anonymous);
+            } else {                
+                if (element.getSchemaTypeName() != null) {
+                    QName name = checkPrefix(element.getSchemaTypeName());
+                    membertype = getLocalType(name);                    
+                }
+            }
+        }
+
+        if (!(element.getMaxOccurs() == 1) || !(element.getMinOccurs() == 1)) {
+            QName name = createQNameCorbaNamespace(getModulePrefix(membertype) 
+                                                    + element.getQName().getLocalPart() + "Array");
+            
+            // workaround for now - sent bug to WSCommons - the elements
+            // QName should have its namespace included.
+            QName schemaName = element.getQName();
+            if (schemaName.getNamespaceURI().equals("")) {
+                schemaName = new QName(xmlSchemaList.get(0).getTargetNamespace(), 
+                                       schemaName.getLocalPart());                
+            }
+            
+            CorbaTypeImpl arraytype = null;
+            if (memName != null) {
+                arraytype = createArray(name, schemaName, memName, 
+                                        element.getMaxOccurs(), element.getMinOccurs(), false);
+            } else {
+                arraytype = createArray(name, schemaName, membertype.getQName(), 
+                                        element.getMaxOccurs(), element.getMinOccurs(), false);
+            }
+                        
+            membertype.setName(arraytype.getName());
+            membertype.setQName(arraytype.getQName());
+            membertype.setType(arraytype.getType());
+                        
+            if (arraytype != null) {                
+                arraytype.setQName(null);
+                if (!isDuplicate(arraytype)) {
+                    typeMappingType.getStructOrExceptionOrUnion().add(arraytype);               
+                }                
+            }                   
+        }
+
+        return membertype;
+    }
+
+    
+    public XmlSchemaType getSchemaType(QName name) throws Exception {                
+        XmlSchemaType type = null;
+        Iterator i = xmlSchemaList.iterator();
+        while (i.hasNext()) {
+            XmlSchema xmlSchema = (XmlSchema)i.next();      
+            String nspace = xmlSchema.getTargetNamespace();
+            QName tname = createQName(nspace, name.getLocalPart(), "xsd");
+            type = findSchemaType(tname);                            
+            if (type != null) {
+                break;
+            }
+        }       
+        return type;
+    }
+          
+    private String getModulePrefix(CorbaTypeImpl type) {
+        String name = type.getQName().getLocalPart();
+        int dotPos = name.lastIndexOf(".");
+        return dotPos == -1 ? "" : name.substring(0, dotPos + 1);
+    }
+
+    
+    protected CorbaTypeImpl processSequenceType(XmlSchemaSequence seq, 
+                                                QName defaultName, QName schemaTypeName)
+        throws Exception {
+        CorbaTypeImpl type = null;
+        QName seqName = null;
+
+        if (schemaTypeName == null) {
+            seqName = createQNameTargetNamespace(defaultName.getLocalPart() + "SequenceStruct");        
+        } else {        
+            seqName = createQName(schemaTypeName.getNamespaceURI(),
+                                  schemaTypeName.getLocalPart() + "SequenceStruct", 
+                                  schemaTypeName.getPrefix());
+        }
+        
+        schemaTypeName = checkPrefix(schemaTypeName);
+        Struct struct = new Struct();       
+        struct.setName(seqName.getLocalPart());
+        struct.setQName(seqName);
+        struct.setRepositoryID(REPO_STRING + seqName.getLocalPart().replace('.', '/') + IDL_VERSION);
+        struct.setType(schemaTypeName);
+        
+        List members = processContainerAsMembers(seq, defaultName, schemaTypeName);
+        for (Iterator iterator = members.iterator(); iterator.hasNext();) {
+            MemberType memberType = (MemberType)iterator.next();
+            struct.getMember().add(memberType);            
+        }        
+        
+        type = struct;
+                              
+        if (!"1".equals(seq.getMaxOccurs()) || !"1".equals(seq.getMinOccurs())) {
+            QName name = createQNameTargetNamespace(type.getQName().getLocalPart() + "Array");            
+            CorbaTypeImpl atype = createArray(name, type.getQName(), type.getQName(),
+                                           seq.getMaxOccurs(), seq.getMinOccurs(), false);
+            
+            if (atype != null) {
+                atype.setQName(null);               
+                if (!isDuplicate(atype)) {
+                    typeMappingType.getStructOrExceptionOrUnion().add(atype);               
+                }
+            }
+        }
+        
+        if ((type instanceof Struct) && (struct.getMember().size() == 0)) {
+            String msgStr = "Cannot create CORBA Struct" + struct.getName()
+                            + "from container with no members";
+            org.apache.cxf.common.i18n.Message msg = new org.apache.cxf.common.i18n.Message(
+                                      msgStr, LOG);
+            throw new Exception(msg.toString());
+        }        
+                
+        return type;
+    }
+    
+    
+    protected CorbaTypeImpl processAllType(XmlSchemaAll seq, QName defaultName, 
+                                           QName schematypeName) throws Exception {
+        QName allName = null;
+        Struct type = null;
+
+        if (schematypeName == null) {
+            allName = createQNameCorbaNamespace(defaultName.getLocalPart() + "AllStruct");
+        } else {
+            allName = createQNameCorbaNamespace(schematypeName.getLocalPart() + "AllStruct");
+        }
+
+        type = new Struct();
+        type.setName(allName.getLocalPart());
+        type.setQName(allName);
+        type.setType(schematypeName);
+        
+        List members = processContainerAsMembers(seq, defaultName, schematypeName);
+        for (Iterator iterator = members.iterator(); iterator.hasNext();) {
+            MemberType memberType = (MemberType)iterator.next();
+            type.getMember().add(memberType);
+        }
+                
+        String repoId = REPO_STRING + type.getQName().getLocalPart().replace('.', '/') + IDL_VERSION;
+        type.setRepositoryID(repoId);
+        return type;
+    }
+    
+    private CorbaTypeImpl processPrimitiveType(QName typeName) {
+        QName qName = createQNameXmlSchemaNamespace(typeName.getLocalPart());        
+        CorbaTypeImpl corbatype = (CorbaTypeImpl)CORBAPRIMITIVEMAP.get(qName);
+        if (corbatype == null) {
+            if (typeName.equals(W3CConstants.NT_SCHEMA_DECIMAL)) {
+                QName name = new QName(idlNamespace, "fixed_1");
+                corbatype = WSDLTypes.getFixedCorbaType(name, typeName, 31, 6);
+            } else if (typeName.equals(W3CConstants.NT_SCHEMA_BASE64)
+                       || typeName.equals(W3CConstants.NT_SCHEMA_HBIN)) {
+                       //|| typeName.equals(SOAPConstants.NT_SOAP_BASE64)
+                       //|| typeName.equals(SOAPConstants.NT_SOAP_HBIN)) {
+                QName name = new QName(idlNamespace, typeName.getLocalPart() + "Seq");
+                corbatype = WSDLTypes.getOctetCorbaType(name, typeName, 0);
+            }
+
+        }
+        return corbatype;
+    }
+
+    protected List<MemberType> processAttributesAsMembers(Iterator attrs) throws Exception {
+        QName memName = null;
+        List <MemberType>members = new ArrayList<MemberType>();
+
+        while (attrs.hasNext()) {
+            XmlSchemaAttribute attribute = (XmlSchemaAttribute)attrs.next();
+            CorbaTypeImpl membertype = null;
+
+            if (attribute.getUse().getValue().equals("none")
+                || attribute.getUse().getValue().equals(W3CConstants.USE_OPTIONAL)) {                
+                CorbaTypeImpl attType = null;
+                if (attribute.getSchemaType() != null) {                    
+                    attType = convertSchemaToCorbaType(attribute.getSchemaType(), 
+                                                       attribute.getQName(), 
+                                              attribute.getSchemaType(), null, true);                   
+                    if (attType != null) {
+                        QName typeName = attType.getQName();
+                        attType.setQName(null);           
+                        if (!isDuplicate(attType)) {
+                            typeMappingType.getStructOrExceptionOrUnion().add(attType);
+                        }
+                        QName name =  createQNameTargetNamespace(typeName.getLocalPart() + "_nil");
+                        membertype = createNillableUnion(name, attribute.getQName(), 
+                                     createQNameCorbaNamespace(typeName.getLocalPart()));
+                    }
+                } else {
+                    attType = processPrimitiveType(attribute.getSchemaTypeName());
+                    //REVISIT, bravi, attType is null for the wsaddr type
+                    //{http://www.w3.org/2005/08/addressing}RelationshipTypeOpenEnum
+                    if (attType != null) {
+                        QName name =  createQNameTargetNamespace(attType.getQName().getLocalPart() + "_nil");
+                        membertype = createNillableUnion(name, attribute.getQName(), 
+                                                         attType.getQName());
+                    }
+
+                }
+                if (membertype != null) {
+                    memName = createQNameCorbaNamespace(membertype.getQName().getLocalPart());
+                    membertype.setQName(null);           
+                    if (!isDuplicate(membertype)) {
+                        typeMappingType.getStructOrExceptionOrUnion().add(membertype);
+                    }
+                }
+            } else {
+                if (attribute.getSchemaType() != null) {
+                    membertype = convertSchemaToCorbaType(attribute.getSchemaType(), attribute.getQName(), 
+                                                      attribute.getSchemaType(), null, false);
+                } else {
+                    membertype = processPrimitiveType(attribute.getSchemaTypeName());
+                }
+            }
+
+            if (membertype != null) {
+                MemberType member;
+                String memberName = attribute.getQName().getLocalPart();
+
+                member = new MemberType();
+                member.setName(memberName);
+                if (memName != null) {
+                    member.setIdltype(memName);
+                } else {
+                    member.setIdltype(membertype.getQName());
+                }
+                members.add(member);
+            } else {
+                String msg = "Unsupported Attribute Found in CORBA Binding Generation:" 
+                    + attribute.getQName();
+                LOG.log(Level.WARNING, msg.toString());            
+            }
+        }
+
+        return members;
+    }
+
+    
+    private CorbaTypeImpl processElementType(XmlSchemaElement stype, QName defaultName) 
+        throws Exception {
+
+        QName schematypeName;
+
+        if (stype.getName() == null) {
+            schematypeName = defaultName;
+        } else {
+            schematypeName = createQNameTargetNamespace(stype.getName());
+        }
+
+        return convertSchemaToCorbaType(stype.getSchemaType(), schematypeName, 
+                                        stype.getSchemaType(), null, false);
+
+    }
+
+    private CorbaTypeImpl processSimpleType(XmlSchemaSimpleType stype, QName defaultName, 
+                                            boolean anonymous)
+        throws Exception {
+
+        CorbaTypeImpl corbaTypeImpl = null;
+        QName name;
+        QName schematypeName = null; 
+        
+        if (stype.getQName() == null) {
+            schematypeName = defaultName;
+            name = createQNameTargetNamespace(defaultName.getLocalPart() + "Type");
+        } else {
+            schematypeName = checkPrefix(stype.getQName());
+            if (schematypeName == null) {
+                schematypeName = stype.getQName();
+            }
+            name = createQNameCorbaNamespace(schematypeName.getLocalPart());
+        }        
+        
+        if (stype.getContent() instanceof XmlSchemaSimpleTypeRestriction) {
+            corbaTypeImpl = processSimpleRestrictionType(stype, name, schematypeName, anonymous);
+        } else if (stype.getContent() instanceof XmlSchemaSimpleTypeList) {
+            XmlSchemaSimpleTypeList ltype = (XmlSchemaSimpleTypeList)stype.getContent();
+            CorbaTypeImpl itemType = null;
+            if (ltype.getItemType() != null) {
+                itemType = convertSchemaToCorbaType(ltype.getItemType(), name, stype, null, false);
+                if (itemType != null) {
+                    return WSDLTypes.mapToSequence(name, checkPrefix(schematypeName), 
+                                                   itemType.getQName(), 0, false);
+                }
+                return itemType;
+            }
+            QName ltypeName = createQNameXmlSchemaNamespace(ltype.getItemTypeName().getLocalPart());
+            itemType = processPrimitiveType(ltypeName);
+            return WSDLTypes.mapToSequence(name, checkPrefix(schematypeName), itemType.getQName(), 0, false);
+        } else if (stype.getContent() == null) {
+            // elements primitive type
+            QName stypeName = createQNameXmlSchemaNamespace(stype.getName());
+            corbaTypeImpl = getLocalType(stypeName);            
+        } else {
+            System.out.println("SimpleType Union Not Supported in CORBA Binding");
+        }
+        return corbaTypeImpl;
+ 
+    }
+    
+    private CorbaTypeImpl processSimpleRestrictionType(XmlSchemaSimpleType stype,
+                                                       QName name, QName schematypeName,
+                                                       boolean anonymous) 
+        throws Exception {
+        CorbaTypeImpl corbaTypeImpl = null;
+    
+        // checks if enumeration
+        XmlSchemaSimpleTypeRestriction restrictionType = (XmlSchemaSimpleTypeRestriction)stype
+            .getContent();
+        
+        QName baseName = checkPrefix(restrictionType.getBaseTypeName());
+        
+        String maxLength = null;
+        String length = null;
+
+        Iterator i = restrictionType.getFacets().getIterator();
+        while (i.hasNext()) {
+            XmlSchemaFacet val = (XmlSchemaFacet)i.next();
+            if (val instanceof XmlSchemaMaxLengthFacet) {                
+                maxLength = val.getValue().toString();
+            }
+            if (val instanceof XmlSchemaLengthFacet) {
+                length = val.getValue().toString();
+            }
+        }
+        
+        if (isEnumeration(restrictionType)) {
+            corbaTypeImpl = createCorbaEnum(restrictionType, name, schematypeName);
+        } else {
+            if (restrictionType.getBaseType() != null) {
+                corbaTypeImpl = convertSchemaToCorbaType(restrictionType.getBaseType(), schematypeName,
+                                                         stype, null, false);
+            } else {                
+                corbaTypeImpl = processPrimitiveType(baseName);                
+                if (corbaTypeImpl == null) {
+                    XmlSchemaType schematype = findSchemaType(baseName);
+                    corbaTypeImpl = convertSchemaToCorbaType(schematype, schematypeName,
+                                                             schematype, null, false); 
+                }
+            }
+
+            if (corbaTypeImpl != null) {
+                if (corbaTypeImpl.getType().equals(W3CConstants.NT_SCHEMA_STRING)
+                    || (baseName.equals(W3CConstants.NT_SCHEMA_STRING))) {                
+                    corbaTypeImpl = 
+                        WSDLTypes.processStringType(corbaTypeImpl, name, maxLength, length);                
+                } else if (corbaTypeImpl.getType().equals(W3CConstants.NT_SCHEMA_DECIMAL)
+                    || (baseName.equals(W3CConstants.NT_SCHEMA_DECIMAL))) {                
+                    corbaTypeImpl = WSDLTypes.processDecimalType(restrictionType, name, 
+                                                             corbaTypeImpl, anonymous);
+                } else if ((corbaTypeImpl.getType().equals(W3CConstants.NT_SCHEMA_BASE64))
+                    || (baseName.equals(W3CConstants.NT_SCHEMA_BASE64))
+                    || (corbaTypeImpl.getType().equals(W3CConstants.NT_SCHEMA_HBIN))
+                    || (corbaTypeImpl.getType().equals(W3CConstants.NT_SCHEMA_HBIN))) {                
+                    corbaTypeImpl = WSDLTypes.processBase64Type(corbaTypeImpl, 
+                                                                name, maxLength, length);          
+                }            
+            }
+        }
+        
+        return corbaTypeImpl;
+    }               
+ 
+    private CorbaTypeImpl getLocalType(QName qname) {
+        return processPrimitiveType(qname);
+    }
+
+    private Enum createCorbaEnum(XmlSchemaSimpleTypeRestriction restrictionType, QName name,
+                                 QName schematypeName) {
+        Enum corbaEnum = new Enum();
+        corbaEnum.setType(schematypeName);
+        corbaEnum.setName(name.getLocalPart());
+        corbaEnum.setQName(name);
+
+        corbaEnum.setRepositoryID(REPO_STRING + name.getLocalPart().replace('.', '/') + IDL_VERSION);
+        Iterator enums = restrictionType.getFacets().getIterator();
+
+        while (enums.hasNext()) {
+            XmlSchemaEnumerationFacet val = (XmlSchemaEnumerationFacet)enums.next();
+            Enumerator enumerator = new Enumerator();
+            enumerator.setValue(val.getValue().toString());
+            corbaEnum.getEnumerator().add(enumerator);
+        }
+        return corbaEnum;
+    }
+
+    private boolean isEnumeration(XmlSchemaSimpleTypeRestriction restriction) {
+
+        if ((restriction == null) || (restriction.getFacets().getCount() == 0)
+            || (restriction.getBaseTypeName() == null)) {
+            return false;
+        }
+
+        Iterator it = restriction.getFacets().getIterator();
+        while (it.hasNext()) {
+            XmlSchemaFacet facet = (XmlSchemaFacet)it.next();
+            if (facet instanceof XmlSchemaEnumerationFacet) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    
+    protected XmlSchemaType lookUpType(Part part) {
+        XmlSchemaType schemaType = null;
+        
+        Iterator i = xmlSchemaList.iterator();
+        while (i.hasNext()) {
+            XmlSchema xmlSchema = (XmlSchema)i.next();
+        
+            if (part.getElementName() != null) {
+                XmlSchemaElement schemaElement = xmlSchema.getElementByName(part.getElementName());
+                if (schemaElement != null) {
+                    schemaType = schemaElement.getSchemaType();
+                }
+            } else {
+                if (part.getTypeName() != null) {
+                    schemaType = xmlSchema.getTypeByName(part.getTypeName());
+                }
+            }
+            if (schemaType != null) {
+                return schemaType;
+            }
+        }
+            
+        return schemaType;
+    }
+    
+    private XmlSchemaType findSchemaType(QName typeName) {
+        XmlSchemaType schemaType = null;
+        
+        Iterator i = xmlSchemaList.iterator();
+        while (i.hasNext()) {
+            XmlSchema xmlSchema = (XmlSchema)i.next();        
+            if (xmlSchema.getElementByName(typeName) != null) {
+                XmlSchemaElement schemaElement = xmlSchema.getElementByName(typeName);                
+                schemaType = schemaElement.getSchemaType();                
+            } else if (xmlSchema.getTypeByName(typeName) != null) {                
+                schemaType = xmlSchema.getTypeByName(typeName);                
+            }
+            if (schemaType != null) {
+                return schemaType;
+            } 
+        }            
+        return schemaType;
+    }
+    
+    protected boolean isSchemaTypeException(XmlSchemaType stype) {
+        boolean exception = false;
+        XmlSchemaComplexType complex = null;
+
+        if (stype instanceof XmlSchemaComplexType) {           
+            complex = (XmlSchemaComplexType)stype;
+
+            if (!isLiteralArray(complex)   
+                && !WSDLTypes.isOMGUnion(complex) 
+                && !WSDLTypes.isUnion(complex)) {
+                exception = true;
+            }
+        }         
+        return exception;
+    }
+
+    
+    public boolean isLiteralArray(XmlSchemaComplexType type) {
+        boolean array = false;
+
+        if ((type.getAttributes().getCount() == 0) 
+            && (type.getParticle() instanceof XmlSchemaSequence)) {
+            XmlSchemaSequence stype = (XmlSchemaSequence)type.getParticle();
+                    
+            if ((stype.getItems().getCount() == 1)
+                && (stype.getItems().getIterator().next() instanceof XmlSchemaElement)) {
+                XmlSchemaElement el = (XmlSchemaElement)stype.getItems().getIterator().next();
+                if (!(el.getMaxOccurs() == 1)) {
+                    // it's a literal array
+                    array = true;
+                }                
+                if (el.getMaxOccurs() == 1 && el.getMinOccurs() == 1) {
+                    if (type.getName() != null &&  WSDLTypes.isAnonymous(type.getName())) {                
+                        array = true;
+                    }
+                }
+            }
+        }
+        return array;
+    }
+    
+    /**
+     * Create a CORBA Array or Sequence based on min and max Occurs If minOccurs ==
+     * maxOccurs == 1 then log warning and return null. Else if minOccurs is
+     * equal to maxOccurs then create an Array. Else create a Sequence
+     */
+    protected CorbaTypeImpl createArray(QName name, QName schematypeName, QName arrayType,
+                                        Long maxOccurs, Long minOccurs, boolean anonymous) {
+        
+        int max = maxOccurs.intValue();
+        if (max == -1) {
+            return WSDLTypes.mapToSequence(name, schematypeName, arrayType, 0, anonymous);
+        }
+        
+        int min = minOccurs.intValue();        
+        
+        if (min == max) {
+            if (max == 1) {
+                if (!anonymous) {
+                    String msg = "Couldn't Map to Array:" + name + ":minOccurs=" 
+                        + minOccurs + ":maxOccurs=" + maxOccurs;
+                    LOG.log(Level.WARNING, msg.toString());
+                    return null;
+                } else {
+                    return WSDLTypes.mapToArray(name, checkPrefix(schematypeName), arrayType, max, anonymous);
+                }
+            } else {
+                return WSDLTypes.mapToArray(name, checkPrefix(schematypeName), arrayType, max, anonymous);
+            }
+        } else {
+            return WSDLTypes.mapToSequence(name, checkPrefix(schematypeName), arrayType, max, anonymous);
+        }
+    }
+
+    
+    private CorbaTypeImpl processComplexType(XmlSchemaComplexType complex, QName defaultName, 
+                                             XmlSchemaAnnotation annotation, 
+                                             boolean anonymous) throws Exception {
+        CorbaTypeImpl corbatype = null;
+        if (isLiteralArray(complex)) {
+            corbatype = processLiteralArray(complex, defaultName, anonymous);
+        } else if (WSDLTypes.isOMGUnion(complex)) {
+            corbatype = processOMGUnion(complex, defaultName);
+        } else if (WSDLTypes.isUnion(complex)) {
+            corbatype = processRegularUnion(complex, defaultName);                                           
+        } else if (complex.getQName() != null && isIDLObjectType(complex.getQName())) {
+            // process it.
+            corbatype = WSDLTypes.processObject(def, complex, annotation, checkPrefix(complex.getQName()), 
+                                                defaultName, idlNamespace);
+        } else {
+            // Deal the ComplexType as Struct
+            corbatype = processStruct(complex, defaultName);
+        }
+        return corbatype;
+    }
+    
+        
+    private CorbaTypeImpl processStruct(XmlSchemaComplexType complex, QName defaultName)
+        throws Exception {
+        QName name;
+        Struct corbaStruct = null;
+        
+        QName schematypeName = checkPrefix(complex.getQName());               
+        if (schematypeName == null) {
+            schematypeName = checkPrefix(defaultName);
+            name = checkPrefix(createQNameCorbaNamespace(defaultName.getLocalPart()));            
+        } else {
+            name = checkPrefix(createQNameCorbaNamespace(schematypeName.getLocalPart()));            
+        }
+
+        corbaStruct = new Struct();
+        corbaStruct.setName(name.getLocalPart());
+        corbaStruct.setQName(name);
+        String repoId = REPO_STRING + name.getLocalPart().replace('.', '/') + IDL_VERSION;
+        corbaStruct.setRepositoryID(repoId);
+        corbaStruct.setType(schematypeName);
+          
+        if (complex.getContentModel() instanceof XmlSchemaSimpleContent) {
+            corbaStruct = processSimpleContentStruct((XmlSchemaSimpleContent)complex.getContentModel(), 
+                                                     defaultName, corbaStruct, schematypeName);
+        } else if (complex.getContentModel() instanceof XmlSchemaComplexContent) {
+            corbaStruct = processComplexContentStruct((XmlSchemaComplexContent)complex.getContentModel(), 
+                                                      defaultName, corbaStruct, schematypeName);        
+        } 
+        
+        // Process attributes at ComplexType level
+        if (complex.getAttributes().getIterator() != null) {
+            Iterator iterator = complex.getAttributes().getIterator();
+            List attlist2 = processAttributesAsMembers(iterator);
+            MemberType member = new MemberType();
+            for (int i = 0; i < attlist2.size(); i++) {
+                member = (MemberType)attlist2.get(i);
+                corbaStruct.getMember().add(member);
+            }
+        }
+
+        if (complex.getParticle() != null) {
+            List members = processContainerAsMembers(complex.getParticle(), defaultName, schematypeName);
+
+            for (Iterator it = members.iterator(); it.hasNext();) {
+                MemberType memberType = (MemberType)it.next();
+                corbaStruct.getMember().add(memberType);
+            }
+        }
+
+        return corbaStruct;
+    }
+        
+    protected Struct processSimpleContentStruct(XmlSchemaSimpleContent simpleContent, 
+                                                QName defaultName, Struct corbaStruct, QName schematypeName)
+        throws Exception {        
+        XmlSchemaType base = null;        
+        List attrMembers = null;
+        CorbaTypeImpl basetype = null;
+
+        if (simpleContent.getContent() instanceof XmlSchemaSimpleContentExtension) {        
+            XmlSchemaSimpleContentExtension ext = 
+                (XmlSchemaSimpleContentExtension)simpleContent.getContent();
+                        
+            if (ext.getBaseTypeName() != null) {
+                basetype = processPrimitiveType(ext.getBaseTypeName());
+            }
+            
+            // process  ext types ????                      
+            MemberType basemember = new MemberType();
+            basemember.setName("_simpleTypeValue");
+            basemember.setIdltype(basetype.getType());
+            corbaStruct.getMember().add(basemember);
+            attrMembers = processAttributesAsMembers(ext.getAttributes().getIterator());
+        } else if (simpleContent.getContent() instanceof XmlSchemaSimpleContentRestriction) {
+            XmlSchemaSimpleContentRestriction restrict 
+                = (XmlSchemaSimpleContentRestriction)simpleContent.getContent();
+            basetype = convertSchemaToCorbaType(base, base.getQName(), base, null, false);
+            base = restrict.getBaseType();
+            basetype = convertSchemaToCorbaType(base, base.getQName(), base, null, false);
+            MemberType basemember = new MemberType();
+            basemember.setName("_simpleTypeValue");
+            basemember.setIdltype(basetype.getType());
+            corbaStruct.getMember().add(basemember);
+            attrMembers = processAttributesAsMembers(restrict.getAttributes().getIterator());
+        }
+
+        //Deal with Attributes defined in Extension
+        MemberType member = new MemberType();
+        for (int i = 0; i < attrMembers.size(); i++) {
+            member = (MemberType)attrMembers.get(i);
+            corbaStruct.getMember().add(member);
+        }
+
+        //Process attributes at ComplexType level
+        //List attlist2 = processAttributesAsMembers(simpleContent.unhandledAttributes.);
+        //corbaStruct.getMembers().addAll(attlist2);      
+
+        return corbaStruct;
+    }
+    
+    protected Struct processComplexContentStruct(XmlSchemaComplexContent complex, QName defaultName,
+                                                 Struct corbaStruct, QName schematypeName)
+        throws Exception {        
+
+        if (complex.getContent() instanceof XmlSchemaComplexContentExtension) {
+            XmlSchemaComplexContentExtension extype 
+                = (XmlSchemaComplexContentExtension)complex.getContent();
+            
+            // Add base as a member of this struct
+            MemberType memberType = new MemberType();     
+            QName extName = extype.getBaseTypeName();
+            memberType.setName(extName.getLocalPart() + "_f");
+            if (extName.getLocalPart().equals("anyType")) {
+                memberType.setIdltype(processPrimitiveType(extName).getQName());                
+            } else {
+                memberType.setIdltype(createQNameCorbaNamespace(extName.getLocalPart()));
+            }            
+            corbaStruct.getMember().add(memberType);
+            
+            // process attributes at complexContent level
+            List attlist1 = processAttributesAsMembers(extype.getAttributes().getIterator());
+            MemberType member = new MemberType();
+            for (int i = 0; i < attlist1.size(); i++) {
+                member = (MemberType)attlist1.get(i);
+                corbaStruct.getMember().add(member);
+            }
+            
+            // Process members of Current Type
+            if (extype.getParticle() instanceof XmlSchemaChoice) {
+                XmlSchemaChoice choice = (XmlSchemaChoice)extype.getParticle();
+                MemberType choicemem = processComplexContentStructChoice(choice, schematypeName, defaultName);
+                corbaStruct.getMember().add(choicemem);                                
+            } else if (extype.getParticle() instanceof  XmlSchemaSequence) {
+                XmlSchemaSequence seq = (XmlSchemaSequence)extype.getParticle();
+                CorbaTypeImpl seqtype = 
+                    processSequenceType(seq, defaultName, schematypeName);                               
+
+                if (seqtype != null) {                    
+                    MemberType seqmem = new MemberType();
+                    seqmem.setName(seqtype.getQName().getLocalPart() + "_f");
+                    QName type = createQNameCorbaNamespace(seqtype.getQName().getLocalPart());
+                    seqmem.setIdltype(type);
+                    corbaStruct.getMember().add(seqmem);
+                    if (!isDuplicate(seqtype)) {
+                        seqtype.setQName(null);
+                        typeMappingType.getStructOrExceptionOrUnion().add(seqtype);
+                    }
+                } else {                    
+                    LOG.log(Level.WARNING, "Couldnt map Sequence inside extension");
+                }
+
+            } else if (extype.getParticle() instanceof  XmlSchemaAll) {
+                XmlSchemaAll all = (XmlSchemaAll)extype.getParticle();
+                
+                CorbaTypeImpl alltype = processAllType(all, defaultName, schematypeName);
+                if (alltype != null) {
+                    MemberType allmem = new MemberType();
+                    allmem.setName(alltype.getQName().getLocalPart() + "_f");
+                    allmem.setIdltype(alltype.getQName());
+                    corbaStruct.getMember().add(allmem);
+                    if (!isDuplicate(alltype)) {
+                        alltype.setQName(null);
+                        typeMappingType.getStructOrExceptionOrUnion().add(alltype);
+                    }
+                } else {
+                    LOG.log(Level.WARNING, "Couldnt map All inside extension");
+                }
+            }
+            
+        } else {
+            org.apache.cxf.common.i18n.Message msg = new org.apache.cxf.common.i18n.Message(
+                               "Restriction inside ComplexContent is not yet Supported.", LOG);
+            //throw new Exception(msg.toString());            
+            return null;
+        }
+
+        return corbaStruct;
+    }
+    
+    protected MemberType processComplexContentStructChoice(XmlSchemaChoice choice, 
+                                                     QName schematypeName, QName defaultName) 
+        throws Exception {
+        QName choicename = createQNameTargetNamespace(schematypeName.getLocalPart() + "ChoiceType");
+        Union choiceunion = createUnion(choicename, choice,
+                                        defaultName, schematypeName);
+
+        String repoId = REPO_STRING + choiceunion.getQName().getLocalPart().replace('.', '/')
+            + IDL_VERSION;
+        choiceunion.setRepositoryID(repoId);                                
+        
+        MemberType choicemem = new MemberType();
+        choicemem.setName(choiceunion.getQName().getLocalPart() + "_f");
+        choicemem.setIdltype(createQNameCorbaNamespace(choiceunion.getQName().getLocalPart()));          
+        
+        if ((choiceunion != null) && (!isDuplicate(choiceunion))) {
+            choiceunion.setQName(null);
+            typeMappingType.getStructOrExceptionOrUnion().add(choiceunion);
+        }
+        
+        return choicemem;
+    }                    
+    
+    protected CorbaTypeImpl createNillableUnion(QName name, QName schemaType, QName membertype) {        
+        
+        Union nilUnion = new Union();
+        nilUnion.setName(name.getLocalPart());
+        nilUnion.setType(schemaType);
+        nilUnion.setQName(name);
+        nilUnion.setDiscriminator(CorbaConstants.NT_CORBA_BOOLEAN);
+        String id = REPO_STRING + nilUnion.getQName().getLocalPart().replace('.', '/') + IDL_VERSION;
+        nilUnion.setRepositoryID(id);
+
+        Unionbranch branch = new Unionbranch();
+        branch.setName("value");
+        branch.setIdltype(membertype);
+        branch.setDefault(false);
+        CaseType caseType = new CaseType();
+        caseType.setLabel("TRUE");
+        branch.getCase().add(caseType);
+        nilUnion.getUnionbranch().add(branch);       
+        
+        return nilUnion;
+    }
+    
+    private CorbaTypeImpl processLiteralArray(XmlSchemaComplexType complex, QName defaultName, 
+                                              boolean anonymous) throws Exception {
+        // NEED TO DO    
+        QName name;
+        QName typeName = null;
+        QName schematypeName = checkPrefix(complex.getQName());
+
+        if (schematypeName == null) {
+            schematypeName = defaultName;
+            name = createQNameCorbaNamespace(defaultName.getLocalPart() + "Type");
+            schematypeName = checkPrefix(schematypeName);
+            name = checkPrefix(name);
+        } else {
+            name = createQNameCorbaNamespace(schematypeName.getLocalPart());
+            name = checkPrefix(name);
+        }
+
+        CorbaTypeImpl arrayType = null;
+        XmlSchemaElement arrayEl = null;
+        if (complex.getParticle() instanceof XmlSchemaSequence) {
+            XmlSchemaSequence seq = (XmlSchemaSequence)complex.getParticle();
+            
+            Iterator iterator = seq.getItems().getIterator();
+            Iterator iter = seq.getItems().getIterator();
+            while (iterator.hasNext()) {
+                if (iter.next() instanceof XmlSchemaElement) {
+                    arrayEl = (XmlSchemaElement)iterator.next();
+                    XmlSchemaType atype = arrayEl.getSchemaType();
+                    if (atype == null) {
+                        atype = getSchemaType(arrayEl.getSchemaTypeName());
+                    }
+                    arrayType = convertSchemaToCorbaType(atype, arrayEl.getQName(), 
+                                                         atype, null, true);
+                    typeName = arrayType.getQName();
+                }
+            }
+        }
+
+        
+        if (arrayEl.isNillable()) {
+            QName nilunionname = createQNameTargetNamespace(arrayType.getQName().getLocalPart() + "_nil");
+            arrayType = createNillableUnion(nilunionname, arrayEl.getQName(), 
+                            arrayType.getQName());
+            typeName = createQNameCorbaNamespace(arrayType.getQName().getLocalPart());
+            if (arrayType != null) {
+                arrayType.setQName(null);           
+                if (!isDuplicate(arrayType)) {
+                    typeMappingType.getStructOrExceptionOrUnion().add(arrayType);
+                }
+            }
+        }
+        
+        Long maxOccurs = null;
+        Long minOccurs = null;
+        if (arrayEl != null) {
+            maxOccurs = arrayEl.getMaxOccurs();
+            minOccurs = arrayEl.getMinOccurs();
+        }
+        
+        return createArray(name, schematypeName, 
+                           checkPrefix(typeName), maxOccurs, minOccurs, anonymous);     
+    }
+    
+    private CorbaTypeImpl processOMGUnion(XmlSchemaComplexType complex, QName defaultName) throws Exception {
+        QName name;
+        Union corbaUnion = null;
+        QName schematypeName = checkPrefix(complex.getQName());                
+
+        if (schematypeName == null) {
+            schematypeName = defaultName;
+            name = createQNameTargetNamespace(defaultName.getLocalPart() + "Type");
+        } else {
+            name = createQNameTargetNamespace(schematypeName.getLocalPart());
+        }
+
+        corbaUnion = new Union();
+        corbaUnion.setName(name.getLocalPart());
+        corbaUnion.setQName(name);
+        String id = REPO_STRING + name.getLocalPart().replace('.', '/') + IDL_VERSION;
+        corbaUnion.setRepositoryID(id);
+        corbaUnion.setType(schematypeName);
+
+        XmlSchemaSequence stype = (XmlSchemaSequence)complex.getParticle();
+        Iterator it = stype.getItems().getIterator();
+        XmlSchemaParticle st1 = (XmlSchemaParticle)it.next();
+        XmlSchemaParticle st2 = (XmlSchemaParticle)it.next();
+        XmlSchemaElement discEl = null;
+        XmlSchemaChoice choice = null;
+
+        if (st1 instanceof XmlSchemaElement) {
+            discEl = (XmlSchemaElement)st1;
+            choice = (XmlSchemaChoice)st2;
+        } else {
+            discEl = (XmlSchemaElement)st2;
+            choice = (XmlSchemaChoice)st1;
+        }
+
+        CorbaTypeImpl disctype = convertSchemaToCorbaType(discEl.getSchemaType(), discEl.getQName(), discEl
+            .getSchemaType(), null, false);
+        corbaUnion.setDiscriminator(disctype.getQName());
+
+        List fields = processContainerAsMembers(choice, defaultName, schematypeName);
+
+        List<String> caselist = new ArrayList<String>();
+
+        if (disctype instanceof Enum) {
+            Enum corbaenum = (Enum)disctype;
+            Iterator iterator = corbaenum.getEnumerator().iterator();
+
+            while (iterator.hasNext()) {
+                Enumerator enumerator = (Enumerator)iterator.next();
+                caselist.add(enumerator.getValue());
+            }
+        } else if (SUPPORTEDDISTYPES.contains(disctype.getQName().getLocalPart())) {
+            if (disctype.getQName().getLocalPart().equals("long")
+                || disctype.getQName().getLocalPart().equals("short")) {
+                for (int i = 0; i < fields.size(); i++) {
+                    caselist.add(Integer.toString(i));
+                }
+            } else if (disctype.getQName().getLocalPart().equals("char")) {
+                for (int i = 0; i < fields.size(); i++) {
+                    caselist.add(Integer.toString(i));
+                }
+            } else if (disctype.getQName().getLocalPart().equals("char")) {
+                for (int i = 0; i < fields.size(); i++) {
+                    caselist.add(Integer.toString(i));
+                }
+            } else if (disctype.getQName().getLocalPart().equals("boolean")) {
+                if (fields.size() == 2) {
+                    caselist.add("TRUE");
+                    caselist.add("FALSE");
+                } else if (fields.size() == 1) {
+                    caselist.add("TRUE");
+                } else {
+                    String msg = "Discriminator Type doesnt match number of Choices in Union:" + name;
+                    LOG.log(Level.WARNING, msg.toString());
+                }
+            }
+        }
+
+        WSDLTypes.processUnionBranches(corbaUnion, fields, caselist);
+
+        return corbaUnion;
+    }           
+
+    
+    private CorbaTypeImpl processRegularUnion(XmlSchemaComplexType complex, 
+                                              QName defaultName) throws Exception {
+        //NEED TO DO
+        QName name = null;
+        QName schematypeName = complex.getQName();
+        
+        if (schematypeName == null) {
+            schematypeName = defaultName;
+            name = createQNameTargetNamespace(defaultName.getLocalPart() + "Type");
+        } else {
+            name = createQNameTargetNamespace(schematypeName.getLocalPart());
+        }
+
+        return createUnion(name, (XmlSchemaChoice)complex.getParticle(), defaultName, schematypeName);        
+    }
+    
+    protected Union createUnion(QName name, XmlSchemaChoice choice, QName defaultName,
+                                QName schematypeName)
+        throws Exception {
+        Union corbaUnion = new Union();
+        corbaUnion.setName(name.getLocalPart());
+        corbaUnion.setQName(name);        
+        corbaUnion.setType(schematypeName);
+        String id = REPO_STRING + name.getLocalPart().replace('.', '/') + IDL_VERSION;
+        corbaUnion.setRepositoryID(id); 
+
+        //Set Integer as Discriminator
+        corbaUnion.setDiscriminator(CorbaConstants.NT_CORBA_LONG);
+
+        List fields = processContainerAsMembers(choice, defaultName, schematypeName);
+
+        //Choose an Integer as a Discriminator
+        List<String> caselist = new ArrayList<String>();        
+
+        for (int i = 0; i < fields.size(); i++) {
+            caselist.add(Integer.toString(i));
+        }
+
+        return WSDLTypes.processUnionBranches(corbaUnion, fields, caselist);
+    }
+                       
+    protected boolean isDuplicate(CorbaTypeImpl corbaTypeImpl) {        
+        String corbaName = corbaTypeImpl.getName();
+        QName corbaType = corbaTypeImpl.getType();
+        
+        QName primName = createQNameXmlSchemaNamespace(corbaName);
+        if ((CorbaTypeImpl)CORBAPRIMITIVEMAP.get(primName) != null) {              
+            return true;
+        }        
+        if (!typeMappingType.getStructOrExceptionOrUnion().isEmpty()) {
+            Iterator i = typeMappingType.getStructOrExceptionOrUnion().iterator();
+            while (i.hasNext()) {
+                CorbaTypeImpl type = (CorbaTypeImpl)i.next();
+                if ((corbaName != null) && type.getType() != null && corbaType != null
+                    && (corbaName.equals(type.getName()))
+                    && (corbaType.getLocalPart().equals(type.getType().getLocalPart()))
+                    && (corbaTypeImpl.getClass().getName().equals(type.getClass().getName()))) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    
+    
+    protected CorbaTypeImpl isDuplicateException(CorbaTypeImpl corbaTypeImpl) {
+        CorbaTypeImpl duplicate = null;
+        String corbaName = corbaTypeImpl.getName();
+        String corbaType = corbaTypeImpl.getType().getLocalPart();
+        if (!typeMappingType.getStructOrExceptionOrUnion().isEmpty()) {
+            Iterator i = typeMappingType.getStructOrExceptionOrUnion().iterator();
+            while (i.hasNext()) {
+                CorbaTypeImpl type = (CorbaTypeImpl)i.next();
+                if (corbaName.equals(type.getName())
+                                     && corbaType.equals(type.getType().getLocalPart())) {                    
+                    if (type instanceof Struct) {                        
+                        return type;
+                    }
+                }
+            }
+        }
+        return duplicate;
+    }
+    
+    protected QName checkPrefix(QName schematypeName) {
+        QName name = schematypeName;
+        if ((name != null) && (name.getPrefix() == null || name.getPrefix().equals(""))) {
+            String prefix = def.getPrefix(name.getNamespaceURI());
+            if (prefix == null) {
+                prefix = xmlSchemaType.getNamespaceContext().getPrefix(name.getNamespaceURI());
+            }
+            if (prefix != null) {
+                return new QName(name.getNamespaceURI(),
+                                 name.getLocalPart(),
+                                 prefix);
+            } else {
+                return null;
+            }
+        }
+     
+        return name;
+    }
+
+    public QName createQNameTargetNamespace(String name) {       
+        return new QName(def.getTargetNamespace(), name, def.getPrefix(def.getTargetNamespace()));
+    }
+
+    public QName createQNameCorbaNamespace(String name) {
+        return new QName(getIdlNamespace(), name, def.getPrefix(getIdlNamespace()));
+    }
+
+    public QName createQName(String name, String namespaceName, String prefix) {
+        return new QName(name, namespaceName, prefix);
+    }
+    
+    public QName createQNameXmlSchemaNamespace(String name) {
+        return new QName(W3CConstants.NU_SCHEMA_XSD, name, W3CConstants.NP_SCHEMA_XSD);
+    }
+
+    private boolean isIDLObjectType(QName typeName) {
+        if (typeName.equals(ReferenceConstants.REFERENCE_TYPE)
+            || typeName.equals(ReferenceConstants.WSADDRESSING_TYPE)) {
+            return true;
+        }
+
+        return false;
+    }
+    
+    private boolean isAddressingNamespace(QName typeName) {
+        if ((typeName != null) && (!isIDLObjectType(typeName))) {
+            if (typeName.getNamespaceURI().equals(ReferenceConstants.REFERENCE_NAMESPACE)
+                || typeName.getNamespaceURI().equals(ReferenceConstants.WSADDRESSING_NAMESPACE)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    protected static boolean queryBinding(Definition definition, QName bqname) {
+        Map bindings = definition.getBindings();
+        Iterator i = bindings.values().iterator();
+        while (i.hasNext()) {
+            Binding binding = (Binding)i.next();
+            if (binding.getQName().getLocalPart().equals(bqname.getLocalPart())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+}

Propchange: incubator/yoko/trunk/tools/src/main/java/org/apache/yoko/tools/processors/wsdl/WSDLToCorbaHelper.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: incubator/yoko/trunk/tools/src/main/java/org/apache/yoko/tools/processors/wsdl/WSDLToCorbaHelper.java
------------------------------------------------------------------------------
    svn:keywords = Rev Date

Modified: incubator/yoko/trunk/tools/src/main/java/org/apache/yoko/tools/processors/wsdl/WSDLToProcessor.java
URL: http://svn.apache.org/viewvc/incubator/yoko/trunk/tools/src/main/java/org/apache/yoko/tools/processors/wsdl/WSDLToProcessor.java?view=diff&rev=494510&r1=494509&r2=494510
==============================================================================
--- incubator/yoko/trunk/tools/src/main/java/org/apache/yoko/tools/processors/wsdl/WSDLToProcessor.java (original)
+++ incubator/yoko/trunk/tools/src/main/java/org/apache/yoko/tools/processors/wsdl/WSDLToProcessor.java Tue Jan  9 10:29:42 2007
@@ -91,7 +91,6 @@
             }
             wsdlDefinition = reader.readWSDL(wsdlUrl);
 
-            //bravi, Why are we doing this?
             parseImports(wsdlDefinition);
             buildWSDLDefinition();    
         } catch (WSDLException we) {
@@ -160,7 +159,7 @@
                     }
                 }
                 if (schemaElem != null) {
-                    schematype = schemaCol.read(schemaElem);                       
+                    schematype = schemaCol.read(schemaElem);                    
                     schematypeList.add(schematype);
                 }
             }
@@ -177,12 +176,6 @@
         extractSchema(wsdlDefinition);
         for (Definition def : importedDefinitions) {
             extractSchema(def);
-        }
-        if (schemaList.size() == 0) {
-            if (env.isVerbose()) {
-                System.err.println("No schema provided in the wsdl file");
-            }
-            return;
         }
         schemaTargetNamespaces.clear();     
     }

Modified: incubator/yoko/trunk/tools/src/main/java/org/apache/yoko/tools/processors/wsdl/WSDLTypes.java
URL: http://svn.apache.org/viewvc/incubator/yoko/trunk/tools/src/main/java/org/apache/yoko/tools/processors/wsdl/WSDLTypes.java?view=diff&rev=494510&r1=494509&r2=494510
==============================================================================
--- incubator/yoko/trunk/tools/src/main/java/org/apache/yoko/tools/processors/wsdl/WSDLTypes.java (original)
+++ incubator/yoko/trunk/tools/src/main/java/org/apache/yoko/tools/processors/wsdl/WSDLTypes.java Tue Jan  9 10:29:42 2007
@@ -61,18 +61,16 @@
 import org.apache.yoko.wsdl.CorbaConstants;
 import org.apache.yoko.wsdl.CorbaTypeImpl;
 
-public class WSDLTypes extends WSDLToCorbaBinding {
+public final class WSDLTypes {
     
     protected static final Logger LOG = LogUtils.getL7dLogger(WSDLTypes.class);
-    static String idlversion = ":1.0";    
-    static String repoString = "IDL:";     
 
-    public WSDLTypes() {            
+    private WSDLTypes() {
     }
-    
-    public CorbaTypeImpl processObject(Definition definition, XmlSchemaComplexType complex,  
-                                       XmlSchemaAnnotation annotation, QName typeName,
-                                       QName defaultName, String idlNamespace) 
+
+    public static CorbaTypeImpl processObject(Definition definition, XmlSchemaComplexType complex,  
+                                              XmlSchemaAnnotation annotation, QName typeName,
+                                              QName defaultName, String idlNamespace) 
         throws Exception {
         CorbaTypeImpl corbaTypeImpl = null;
                 
@@ -93,7 +91,7 @@
 
                         //Check if the Binding with name already exists
                         Binding binding = null;
-                        if (queryBinding(definition, bqname)) {
+                        if (WSDLToCorbaHelper.queryBinding(definition, bqname)) {
                             binding = definition.getBinding(bqname);
                         }
 
@@ -143,8 +141,8 @@
     }         
 
     
-    public CorbaTypeImpl processStringType(CorbaTypeImpl corbaTypeImpl, QName name, 
-                                           String maxLength, String length) throws Exception {
+    public static CorbaTypeImpl processStringType(CorbaTypeImpl corbaTypeImpl, QName name, 
+                                                  String maxLength, String length) throws Exception {
         boolean boundedString = true;             
         int bound = 0;
 
@@ -174,8 +172,8 @@
         return corbaTypeImpl;
     }
     
-    public CorbaTypeImpl mapToArray(QName name, QName schematypeName, QName arrayType, int bound,
-                                     boolean anonymous) {
+    public static CorbaTypeImpl mapToArray(QName name, QName schematypeName, QName arrayType, int bound,
+                                           boolean anonymous) {
         CorbaTypeImpl corbatype = null;
             
         //schematypeName = checkPrefix(schematypeName);
@@ -187,7 +185,9 @@
             corbaArray.setType(schematypeName);
             corbaArray.setElemtype(arrayType);
             corbaArray.setBound(bound);
-            corbaArray.setRepositoryID(repoString + name.getLocalPart().replace('.', '/') + idlversion);
+            corbaArray.setRepositoryID(WSDLToCorbaHelper.REPO_STRING
+                                       + name.getLocalPart().replace('.', '/')
+                                       + WSDLToCorbaHelper.IDL_VERSION);
             corbaArray.setQName(name);            
             corbatype = corbaArray;
         } else {
@@ -203,8 +203,8 @@
         return corbatype;
     }
 
-    public CorbaTypeImpl mapToSequence(QName name, QName schematypeName, QName arrayType, int bound,
-                                        boolean anonymous) {
+    public static CorbaTypeImpl mapToSequence(QName name, QName schematypeName, QName arrayType, int bound,
+                                              boolean anonymous) {
         CorbaTypeImpl corbaTypeImpl = null;
 
         //schematypeName = checkPrefix(schematypeName);
@@ -216,7 +216,9 @@
             corbaSeq.setType(schematypeName);
             corbaSeq.setElemtype(arrayType);
             corbaSeq.setBound(bound);
-            corbaSeq.setRepositoryID(repoString + name.getLocalPart().replace('.', '/') + idlversion);
+            corbaSeq.setRepositoryID(WSDLToCorbaHelper.REPO_STRING
+                                     + name.getLocalPart().replace('.', '/')
+                                     + WSDLToCorbaHelper.IDL_VERSION);
             corbaTypeImpl = corbaSeq;
         } else {
             // Create a Anonymous Sequence
@@ -232,7 +234,7 @@
         return corbaTypeImpl;
     }
     
-    public Union processUnionBranches(Union corbaUnion, List fields, List<String> caselist) {
+    public static Union processUnionBranches(Union corbaUnion, List fields, List<String> caselist) {
         int caseIndex = 0;
 
         for (int i = 0; i < fields.size(); i++) {
@@ -252,7 +254,7 @@
     }    
 
     
-    public boolean isOMGUnion(XmlSchemaComplexType type) {
+    public static boolean isOMGUnion(XmlSchemaComplexType type) {
         boolean isUnion = false;
 
         if (type.getParticle() instanceof XmlSchemaSequence 
@@ -281,7 +283,7 @@
         return isUnion;
     }
         
-    public boolean isUnion(XmlSchemaComplexType type) {
+    public static boolean isUnion(XmlSchemaComplexType type) {
         boolean isUnion = false;
         
         if (type.getParticle() instanceof XmlSchemaChoice && type.getAttributes().getCount() == 0) {
@@ -292,9 +294,9 @@
     }
 
     
-    public CorbaTypeImpl processDecimalType(XmlSchemaSimpleTypeRestriction restrictionType, 
-                                             QName name, CorbaTypeImpl corbaTypeImpl,
-                                             boolean anonymous) throws Exception {
+    public static CorbaTypeImpl processDecimalType(XmlSchemaSimpleTypeRestriction restrictionType, 
+                                                   QName name, CorbaTypeImpl corbaTypeImpl,
+                                                   boolean anonymous) throws Exception {
                 
         String tdigits = null;
         String fdigits = null;
@@ -387,8 +389,8 @@
     }   
     
     
-    public CorbaTypeImpl processBase64Type(CorbaTypeImpl corbaTypeImpl, QName name, 
-                                           String maxLength, String length) 
+    public static CorbaTypeImpl processBase64Type(CorbaTypeImpl corbaTypeImpl, QName name, 
+                                                  String maxLength, String length) 
         throws Exception {
         int bound = 0;
         boolean boundedOctet = true;    
@@ -415,7 +417,7 @@
     }
     
     //  checks if the type is an anonymous type.
-    public boolean isAnonymous(String typeName) {
+    public static boolean isAnonymous(String typeName) {
         boolean anonymous = false;
         
         if (typeName == null) {
@@ -435,7 +437,7 @@
         return anonymous;
     }
     
-    public CorbaTypeImpl getFixedCorbaType(QName name, QName stype, int digits, int scale) {        
+    public static CorbaTypeImpl getFixedCorbaType(QName name, QName stype, int digits, int scale) {        
         Fixed fixed = new Fixed();
         fixed.setName(name.getLocalPart());
         fixed.setQName(name);
@@ -445,7 +447,7 @@
         return fixed;
     }
     
-    public CorbaTypeImpl getAnonFixedCorbaType(QName name, QName stype, int digits, int scale) {
+    public static CorbaTypeImpl getAnonFixedCorbaType(QName name, QName stype, int digits, int scale) {
         Anonfixed fixed = new Anonfixed();
         fixed.setName(name.getLocalPart());
         fixed.setQName(name);
@@ -455,7 +457,7 @@
         return fixed;
     }
     
-    public CorbaTypeImpl getOctetCorbaType(QName name, QName stype, int bound) {
+    public static CorbaTypeImpl getOctetCorbaType(QName name, QName stype, int bound) {
         Sequence seq = new Sequence();
         seq.setName(name.getLocalPart());
         seq.setQName(name);



Mime
View raw message