/* | |
* 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.axis2.corba.deployer; | |
import org.apache.axis2.corba.exceptions.SchemaGeneratorException; | |
import org.apache.axis2.corba.idl.types.AbstractCollectionType; | |
import org.apache.axis2.corba.idl.types.ArrayType; | |
import org.apache.axis2.corba.idl.types.CompositeDataType; | |
import org.apache.axis2.corba.idl.types.DataType; | |
import org.apache.axis2.corba.idl.types.EnumType; | |
import org.apache.axis2.corba.idl.types.ExceptionType; | |
import org.apache.axis2.corba.idl.types.IDL; | |
import org.apache.axis2.corba.idl.types.Interface; | |
import org.apache.axis2.corba.idl.types.Member; | |
import org.apache.axis2.corba.idl.types.Operation; | |
import org.apache.axis2.corba.idl.types.PrimitiveDataType; | |
import org.apache.axis2.corba.idl.types.Typedef; | |
import org.apache.axis2.corba.idl.types.UnionType; | |
import org.apache.axis2.corba.receivers.CorbaUtil; | |
import org.apache.axis2.description.java2wsdl.DefaultNamespaceGenerator; | |
import org.apache.axis2.description.java2wsdl.Java2WSDLConstants; | |
import org.apache.axis2.description.java2wsdl.NamespaceGenerator; | |
import org.apache.axis2.description.java2wsdl.TypeTable; | |
import org.apache.ws.commons.schema.XmlSchema; | |
import org.apache.ws.commons.schema.XmlSchemaChoice; | |
import org.apache.ws.commons.schema.XmlSchemaCollection; | |
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.XmlSchemaForm; | |
import org.apache.ws.commons.schema.XmlSchemaImport; | |
import org.apache.ws.commons.schema.XmlSchemaObjectCollection; | |
import org.apache.ws.commons.schema.XmlSchemaSequence; | |
import org.apache.ws.commons.schema.XmlSchemaSimpleType; | |
import org.apache.ws.commons.schema.XmlSchemaSimpleTypeRestriction; | |
import org.apache.ws.commons.schema.utils.NamespaceMap; | |
import javax.xml.namespace.QName; | |
import java.util.ArrayList; | |
import java.util.Collection; | |
import java.util.HashMap; | |
import java.util.Hashtable; | |
import java.util.List; | |
import java.util.Locale; | |
import java.util.Map; | |
public class SchemaGenerator implements CorbaConstants { | |
private static int prefixCount = 1; | |
protected Map targetNamespacePrefixMap = new Hashtable(); | |
protected Map schemaMap = new Hashtable(); | |
protected XmlSchemaCollection xmlSchemaCollection = new XmlSchemaCollection(); | |
private IDL idl; | |
private String interfaceName; | |
private TypeTable typeTable = new TypeTable(); | |
private String schemaTargetNameSpace; | |
private String schema_namespace_prefix; | |
private String attrFormDefault = null; | |
private String elementFormDefault = null; | |
private ArrayList excludeMethods = new ArrayList(); | |
private ArrayList extraClasses = null; | |
private boolean useWSDLTypesNamespace = false; | |
private Map pkg2nsmap = null; | |
private NamespaceGenerator nsGen = null; | |
private String targetNamespace = null; | |
private ArrayList nonRpcMethods = new ArrayList(); | |
public NamespaceGenerator getNsGen() throws SchemaGeneratorException { | |
if ( nsGen == null ) { | |
nsGen = new DefaultNamespaceGenerator(); | |
} | |
return nsGen; | |
} | |
public void setNsGen(NamespaceGenerator nsGen) { | |
this.nsGen = nsGen; | |
} | |
public SchemaGenerator(IDL idl, | |
String interfaceName, String schematargetNamespace, | |
String schematargetNamespacePrefix) | |
throws Exception { | |
this.idl = idl; | |
this.interfaceName = interfaceName; | |
StringBuffer stringBuffer = namespaceFromModuleName(interfaceName, getNsGen()); | |
if (stringBuffer.length() == 0) { | |
stringBuffer.append(Java2WSDLConstants.DEFAULT_TARGET_NAMESPACE); | |
} | |
this.targetNamespace = stringBuffer.toString(); | |
if (schematargetNamespace != null | |
&& schematargetNamespace.trim().length() != 0) { | |
this.schemaTargetNameSpace = schematargetNamespace; | |
} else { | |
stringBuffer = namespaceFromModuleName(interfaceName, getNsGen()); | |
if (stringBuffer.length() == 0) { | |
stringBuffer.append(Java2WSDLConstants.DEFAULT_TARGET_NAMESPACE); | |
} | |
stringBuffer.append(SCHEMA_NAMESPACE_EXTN); | |
this.schemaTargetNameSpace = stringBuffer.toString(); | |
} | |
if (schematargetNamespacePrefix != null | |
&& schematargetNamespacePrefix.trim().length() != 0) { | |
this.schema_namespace_prefix = schematargetNamespacePrefix; | |
} else { | |
this.schema_namespace_prefix = Java2WSDLConstants.SCHEMA_NAMESPACE_PRFIX; | |
} | |
} | |
private static StringBuffer namespaceFromModuleName(String interfaceName, | |
NamespaceGenerator nsGen) throws Exception { | |
String moduleName = null; | |
if (interfaceName != null) { | |
int i = interfaceName.lastIndexOf("::"); | |
if (i > 0) | |
moduleName = interfaceName.substring(0, i); | |
} | |
if (moduleName==null) { | |
return new StringBuffer(); | |
} else { | |
return nsGen.namespaceFromPackageName(moduleName); | |
} | |
} | |
/** | |
* Generates schema for all the parameters in method. First generates schema for all different | |
* parameter type and later refers to them. | |
* | |
* @return Returns XmlSchema. | |
* @throws SchemaGeneratorException if failed | |
*/ | |
public Collection generateSchema() throws SchemaGeneratorException { | |
Map interfaces = idl.getInterfaces(); | |
if (interfaces==null) | |
throw new SchemaGeneratorException("No interfaces defined"); | |
if (interfaceName==null) | |
throw new SchemaGeneratorException("Interface name required"); | |
Interface intf = (Interface) interfaces.get(interfaceName); | |
/** | |
* Schema genertaion done in two stage 1. Load all the methods and | |
* create type for methods parameters (if the parameters are Beans | |
* then it will create Complex types for those , and if the | |
* parameters are simple type which decribe in SimpleTypeTable | |
* nothing will happen) 2. In the next stage for all the methods | |
* messages and port types will be creteated | |
*/ | |
if (intf==null) | |
throw new SchemaGeneratorException("Interface " + interfaceName + " does not exists"); | |
Operation[] operations = intf.getOperations(); | |
// since we do not support overload | |
HashMap uniqueMethods = new HashMap(); | |
XmlSchemaComplexType methodSchemaType; | |
XmlSchemaSequence sequence = null; | |
List processedExs = new ArrayList(); | |
for (int i = 0; i < operations.length; i++) { | |
Operation operation = operations[i]; | |
String operationName = operation.getName(); | |
if (excludeMethods.contains(operationName)) { | |
continue; | |
} | |
if (uniqueMethods.get(operationName) != null) { | |
throw new SchemaGeneratorException( | |
" Sorry we don't support methods overloading !!!! "); | |
} | |
if (operation.hasRaises()) { | |
List extypes = operation.getRaises(); | |
for (int j = 0; j < extypes.size(); j++) { | |
ExceptionType extype = (ExceptionType) extypes.get(j); | |
if (processedExs.contains(extype.getName())) | |
continue; | |
processedExs.add(extype.getName()); | |
methodSchemaType = createSchemaTypeForMethodPart(extype.getName()+ "Fault"); | |
sequence = new XmlSchemaSequence(); | |
generateSchemaForType(sequence, extype, extype.getName()); | |
methodSchemaType.setParticle(sequence); | |
} | |
} | |
uniqueMethods.put(operationName, operation); | |
//create the schema type for the method wrapper | |
List paras = operation.getParams(); | |
if (paras != null && paras.size() > 0) { | |
sequence = new XmlSchemaSequence(); | |
methodSchemaType = createSchemaTypeForMethodPart(operationName); | |
methodSchemaType.setParticle(sequence); | |
} | |
List outparas = null; | |
if (paras != null) { | |
for (int j = 0; j < paras.size(); j++) { | |
Member param = (Member) paras.get(j); | |
String parameterName = param.getName(); | |
DataType paraType = param.getDataType(); | |
if (Member.MODE_INOUT.equals(param.getMode())) { | |
if (outparas==null) | |
outparas = new ArrayList(); | |
outparas.add(param); | |
} else if (Member.MODE_OUT.equals(param.getMode())) { | |
if (outparas==null) | |
outparas = new ArrayList(); | |
outparas.add(param); | |
continue; | |
} | |
if(nonRpcMethods.contains(operationName)){ | |
generateSchemaForType(sequence, null, operationName); | |
break; | |
} else { | |
generateSchemaForType(sequence, paraType, parameterName); | |
} | |
} | |
} | |
DataType returnType = operation.getReturnType(); | |
if ((returnType != null && !CorbaUtil.getQualifiedName(returnType).equals(VOID)) || outparas!=null) { | |
methodSchemaType = createSchemaTypeForMethodPart(operationName + RESPONSE); | |
sequence = new XmlSchemaSequence(); | |
methodSchemaType.setParticle(sequence); | |
if (returnType != null && !CorbaUtil.getQualifiedName(returnType).equals(VOID)) { | |
String returnName ="return"; | |
if(nonRpcMethods.contains(operationName)){ | |
generateSchemaForType(sequence, null, returnName); | |
} else { | |
generateSchemaForType(sequence, returnType, returnName); | |
} | |
} | |
if (outparas != null) { | |
for (int j = 0; j < outparas.size(); j++) { | |
Member param = (Member) outparas.get(j); | |
String parameterName = param.getName(); | |
DataType paraType = param.getDataType(); | |
if(nonRpcMethods.contains(operationName)){ | |
generateSchemaForType(sequence, null, operationName); | |
break; | |
} else { | |
generateSchemaForType(sequence, paraType, parameterName); | |
} | |
} | |
} | |
} | |
} | |
/*} else { | |
//generate the schema type for extra classes | |
extraSchemaTypeName = typeTable.getSimpleSchemaTypeName(getQualifiedName(jclass)); | |
if (extraSchemaTypeName == null) { | |
generateSchema(jclass); | |
}*/ | |
return schemaMap.values(); | |
} | |
/** | |
* JAM convert first name of an attribute into UpperCase as an example if there is a instance | |
* variable called foo in a bean , then Jam give that as Foo so this method is to correct that | |
* error | |
* | |
* @param wrongName wrong name | |
* @return the right name, using english as the locale for case conversion | |
*/ | |
public static String getCorrectName(String wrongName) { | |
if (wrongName.length() > 1) { | |
return wrongName.substring(0, 1).toLowerCase(Locale.ENGLISH) | |
+ wrongName.substring(1, wrongName.length()); | |
} else { | |
return wrongName.substring(0, 1).toLowerCase(Locale.ENGLISH); | |
} | |
} | |
/** | |
* Generate schema construct for given type | |
* | |
* @param dataType object | |
* @return Qname | |
* @throws SchemaGeneratorException if fails | |
*/ | |
//private QName generateSchema(JClass dataType) throws Exception { | |
private QName generateSchema(CompositeDataType dataType) throws SchemaGeneratorException { | |
String name = CorbaUtil.getQualifiedName(dataType); | |
QName schemaTypeName = typeTable.getComplexSchemaType(name); | |
if (schemaTypeName == null) { | |
String simpleName = getSimpleName(dataType); | |
String packageName = getModuleName(dataType); | |
String targetNameSpace = resolveSchemaNamespace(packageName); | |
XmlSchema xmlSchema = getXmlSchema(targetNameSpace); | |
String targetNamespacePrefix = (String) targetNamespacePrefixMap.get(targetNameSpace); | |
schemaTypeName = new QName(targetNameSpace, simpleName, targetNamespacePrefix); | |
if (dataType instanceof EnumType) { | |
XmlSchemaSimpleType simpleType = new XmlSchemaSimpleType(xmlSchema); | |
XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction(); | |
restriction.setBaseTypeName(typeTable.getSimpleSchemaTypeName("java.lang.String")); | |
simpleType.setContent(restriction); | |
simpleType.setName(simpleName); | |
XmlSchemaObjectCollection facets = restriction.getFacets(); | |
EnumType enumType = (EnumType) dataType; | |
List enumMembers = enumType.getEnumMembers(); | |
for (int i = 0; i < enumMembers.size(); i++) { | |
facets.add(new XmlSchemaEnumerationFacet(enumMembers.get(i), false)); | |
} | |
XmlSchemaElement eltOuter = new XmlSchemaElement(); | |
eltOuter.setName(simpleName); | |
eltOuter.setQName(schemaTypeName); | |
xmlSchema.getItems().add(eltOuter); | |
xmlSchema.getElements().add(schemaTypeName, eltOuter); | |
eltOuter.setSchemaTypeName(simpleType.getQName()); | |
xmlSchema.getItems().add(simpleType); | |
xmlSchema.getSchemaTypes().add(schemaTypeName, simpleType); | |
// adding this type to the table | |
typeTable.addComplexSchema(name, eltOuter.getQName()); | |
} else if (dataType instanceof UnionType) { | |
XmlSchemaComplexType complexType = new XmlSchemaComplexType(xmlSchema); | |
XmlSchemaChoice choice = new XmlSchemaChoice(); | |
XmlSchemaObjectCollection items = choice.getItems(); | |
UnionType unionType = (UnionType) dataType; | |
Member[] members = unionType.getMembers(); | |
for (int i = 0; i < members.length; i++) { | |
items.add(generateSchemaforFieldsandProperties(xmlSchema, members[i].getDataType(), | |
members[i].getName(), true)); | |
} | |
complexType.setParticle(choice); | |
complexType.setName(simpleName); | |
XmlSchemaElement eltOuter = new XmlSchemaElement(); | |
eltOuter.setName(simpleName); | |
eltOuter.setQName(schemaTypeName); | |
xmlSchema.getItems().add(eltOuter); | |
xmlSchema.getElements().add(schemaTypeName, eltOuter); | |
eltOuter.setSchemaTypeName(complexType.getQName()); | |
xmlSchema.getItems().add(complexType); | |
xmlSchema.getSchemaTypes().add(schemaTypeName, complexType); | |
typeTable.addComplexSchema(name, eltOuter.getQName()); | |
} else { | |
XmlSchemaComplexType complexType = new XmlSchemaComplexType(xmlSchema); | |
XmlSchemaSequence sequence = new XmlSchemaSequence(); | |
XmlSchemaElement eltOuter = new XmlSchemaElement(); | |
eltOuter.setName(simpleName); | |
eltOuter.setQName(schemaTypeName); | |
complexType.setParticle(sequence); | |
complexType.setName(simpleName); | |
xmlSchema.getItems().add(eltOuter); | |
xmlSchema.getElements().add(schemaTypeName, eltOuter); | |
eltOuter.setSchemaTypeName(complexType.getQName()); | |
xmlSchema.getItems().add(complexType); | |
xmlSchema.getSchemaTypes().add(schemaTypeName, complexType); | |
// adding this type to the table | |
typeTable.addComplexSchema(name, eltOuter.getQName()); | |
if (dataType instanceof Typedef) { | |
Typedef typedef = (Typedef) dataType; | |
DataType aliasType = typedef.getDataType(); | |
sequence.getItems().add(generateSchemaforFieldsandProperties(xmlSchema, aliasType, "item", false)); | |
} else { | |
//Set propertiesNames = new HashSet() ; | |
Member[] members = dataType.getMembers(); | |
for (int i = 0; i < members.length; i++) { | |
Member member = members[i]; | |
String propertyName = member.getName(); | |
DataType propertyType = member.getDataType(); | |
//String propname = getCorrectName(property.getSimpleName()) ; | |
//propertiesNames.add(propertyName) ; | |
sequence.getItems().add(generateSchemaforFieldsandProperties(xmlSchema, propertyType, | |
propertyName, false)); | |
} | |
} | |
} | |
} | |
return schemaTypeName; | |
} | |
// moved code common to Fields & properties out of above method | |
private XmlSchemaElement generateSchemaforFieldsandProperties(XmlSchema xmlSchema, | |
DataType type, | |
String name, boolean forceNotNillable) throws SchemaGeneratorException { | |
boolean isArryType = false; | |
long maxOccurs = 0; | |
long minOccurs = 0; | |
if (type instanceof AbstractCollectionType) { | |
AbstractCollectionType collectionType = (AbstractCollectionType) type; | |
type = collectionType.getDataType(); | |
isArryType = true; | |
int elementCount = collectionType.getElementCount(); | |
if (collectionType.isArray()) { | |
minOccurs = maxOccurs = elementCount; | |
} else if (collectionType.isSequence()) { | |
minOccurs = 0; | |
maxOccurs = (elementCount == 0) ? Long.MAX_VALUE : elementCount; | |
} | |
if (type instanceof AbstractCollectionType) { | |
AbstractCollectionType child = (AbstractCollectionType) type; | |
Typedef typedef = new Typedef(); | |
typedef.setDataType(type); | |
typedef.setModule(child.getElementModule()); | |
typedef.setName("_" + (child.getDepth() - 1) + "_" + child.getElementName()); | |
type = typedef; | |
} | |
} | |
String propertyTypeName = CorbaUtil.getQualifiedName(type); | |
if(isArryType&&"byte".equals(propertyTypeName)){ | |
propertyTypeName = "base64Binary"; | |
} | |
XmlSchemaElement elt1 = new XmlSchemaElement(); | |
elt1.setName(name); | |
if (isArryType && (!propertyTypeName.equals("base64Binary"))){ | |
elt1.setMaxOccurs(maxOccurs); | |
elt1.setMinOccurs(minOccurs); | |
} | |
if(isNillable(type) && !forceNotNillable) | |
elt1.setNillable(true) ; | |
if (typeTable.isSimpleType(propertyTypeName)) { | |
elt1.setSchemaTypeName(typeTable.getSimpleSchemaTypeName(propertyTypeName)); | |
} else if (type instanceof CompositeDataType) { | |
generateSchema((CompositeDataType) type); | |
elt1.setSchemaTypeName(typeTable.getComplexSchemaType(propertyTypeName)); | |
if (!((NamespaceMap) xmlSchema.getNamespaceContext()).values(). | |
contains(typeTable.getComplexSchemaType(propertyTypeName).getNamespaceURI())) { | |
XmlSchemaImport importElement = new XmlSchemaImport(); | |
importElement.setNamespace( | |
typeTable.getComplexSchemaType(propertyTypeName).getNamespaceURI()); | |
xmlSchema.getItems().add(importElement); | |
((NamespaceMap) xmlSchema.getNamespaceContext()). | |
put(generatePrefix(), | |
typeTable.getComplexSchemaType(propertyTypeName).getNamespaceURI()); | |
} | |
} else { | |
throw new SchemaGeneratorException("Unsupported type:" + type); | |
} | |
return elt1; | |
} | |
private boolean isNillable(DataType type) { | |
if (type instanceof CompositeDataType) { | |
return true; | |
} else if (type instanceof PrimitiveDataType) { | |
PrimitiveDataType primitiveDataType = (PrimitiveDataType) type; | |
if (primitiveDataType.getTypeName().equals("java.lang.String")) | |
return true; | |
} | |
return false; | |
} | |
private QName generateSchemaForType(XmlSchemaSequence sequence, DataType type, String partName) | |
throws SchemaGeneratorException { | |
boolean isArrayType = false; | |
if(type!=null){ | |
isArrayType = (type instanceof ArrayType); | |
} | |
if (isArrayType) { | |
ArrayType arrayType = (ArrayType) type; | |
type = arrayType.getDataType(); | |
} | |
String classTypeName; | |
if(type==null){ | |
classTypeName = "java.lang.Object"; | |
} else { | |
classTypeName = CorbaUtil.getQualifiedName(type); | |
} | |
if (isArrayType && "byte".equals(classTypeName)) { | |
classTypeName = "base64Binary"; | |
isArrayType = false; | |
} | |
if("javax.activation.DataHandler".equals(classTypeName)){ | |
classTypeName = "base64Binary"; | |
} | |
QName schemaTypeName = typeTable.getSimpleSchemaTypeName(classTypeName); | |
if (schemaTypeName == null && type instanceof CompositeDataType) { | |
schemaTypeName = generateSchema((CompositeDataType) type); | |
addContentToMethodSchemaType(sequence, | |
schemaTypeName, | |
partName, | |
isArrayType); | |
String schemaNamespace; | |
schemaNamespace = resolveSchemaNamespace(getModuleName(type)); | |
addImport(getXmlSchema(schemaNamespace), schemaTypeName); | |
} else { | |
addContentToMethodSchemaType(sequence, | |
schemaTypeName, | |
partName, | |
isArrayType); | |
} | |
return schemaTypeName; | |
} | |
private void addContentToMethodSchemaType(XmlSchemaSequence sequence, | |
QName schemaTypeName, | |
String paraName, | |
boolean isArray) { | |
XmlSchemaElement elt1 = new XmlSchemaElement(); | |
elt1.setName(paraName); | |
elt1.setSchemaTypeName(schemaTypeName); | |
sequence.getItems().add(elt1); | |
if (isArray) { | |
elt1.setMaxOccurs(Long.MAX_VALUE); | |
elt1.setMinOccurs(1); | |
} | |
elt1.setNillable(true); | |
} | |
private XmlSchemaComplexType createSchemaTypeForMethodPart(String localPartName) { | |
XmlSchema xmlSchema = getXmlSchema(schemaTargetNameSpace); | |
QName elementName = | |
new QName(this.schemaTargetNameSpace, localPartName, this.schema_namespace_prefix); | |
XmlSchemaComplexType complexType = new XmlSchemaComplexType(xmlSchema); | |
XmlSchemaElement globalElement = new XmlSchemaElement(); | |
globalElement.setSchemaType(complexType); | |
globalElement.setName(localPartName); | |
globalElement.setQName(elementName); | |
xmlSchema.getItems().add(globalElement); | |
xmlSchema.getElements().add(elementName, globalElement); | |
typeTable.addComplexSchema(localPartName, elementName); | |
return complexType; | |
} | |
private XmlSchema getXmlSchema(String targetNamespace) { | |
XmlSchema xmlSchema; | |
if ((xmlSchema = (XmlSchema) schemaMap.get(targetNamespace)) == null) { | |
String targetNamespacePrefix; | |
if ( targetNamespace.equals(schemaTargetNameSpace) && | |
schema_namespace_prefix != null ) { | |
targetNamespacePrefix = schema_namespace_prefix; | |
} else { | |
targetNamespacePrefix = generatePrefix(); | |
} | |
xmlSchema = new XmlSchema(targetNamespace, xmlSchemaCollection); | |
xmlSchema.setAttributeFormDefault(getAttrFormDefaultSetting()); | |
xmlSchema.setElementFormDefault(getElementFormDefaultSetting()); | |
targetNamespacePrefixMap.put(targetNamespace, targetNamespacePrefix); | |
schemaMap.put(targetNamespace, xmlSchema); | |
NamespaceMap prefixmap = new NamespaceMap(); | |
prefixmap.put(DEFAULT_SCHEMA_NAMESPACE_PREFIX, URI_2001_SCHEMA_XSD); | |
prefixmap.put(targetNamespacePrefix, targetNamespace); | |
xmlSchema.setNamespaceContext(prefixmap); | |
} | |
return xmlSchema; | |
} | |
public TypeTable getTypeTable() { | |
return typeTable; | |
} | |
private String generatePrefix() { | |
return NAME_SPACE_PREFIX + prefixCount++; | |
} | |
public void setExcludeMethods(ArrayList excludeMethods) { | |
if (excludeMethods == null) excludeMethods = new ArrayList(); | |
this.excludeMethods = excludeMethods; | |
} | |
public String getSchemaTargetNameSpace() { | |
return schemaTargetNameSpace; | |
} | |
private void addImport(XmlSchema xmlSchema, QName schemaTypeName) { | |
if (!((NamespaceMap) xmlSchema.getNamespaceContext()).values(). | |
contains(schemaTypeName.getNamespaceURI())) { | |
XmlSchemaImport importElement = new XmlSchemaImport(); | |
importElement.setNamespace(schemaTypeName.getNamespaceURI()); | |
xmlSchema.getItems().add(importElement); | |
((NamespaceMap) xmlSchema.getNamespaceContext()). | |
put(generatePrefix(), schemaTypeName.getNamespaceURI()); | |
} | |
} | |
public String getAttrFormDefault() { | |
return attrFormDefault; | |
} | |
public void setAttrFormDefault(String attrFormDefault) { | |
this.attrFormDefault = attrFormDefault; | |
} | |
public String getElementFormDefault() { | |
return elementFormDefault; | |
} | |
public void setElementFormDefault(String elementFormDefault) { | |
this.elementFormDefault = elementFormDefault; | |
} | |
private XmlSchemaForm getAttrFormDefaultSetting() { | |
if (FORM_DEFAULT_UNQUALIFIED.equals(getAttrFormDefault())) { | |
return new XmlSchemaForm(XmlSchemaForm.UNQUALIFIED); | |
} else { | |
return new XmlSchemaForm(XmlSchemaForm.QUALIFIED); | |
} | |
} | |
private XmlSchemaForm getElementFormDefaultSetting() { | |
if (FORM_DEFAULT_UNQUALIFIED.equals(getElementFormDefault())) { | |
return new XmlSchemaForm(XmlSchemaForm.UNQUALIFIED); | |
} else { | |
return new XmlSchemaForm(XmlSchemaForm.QUALIFIED); | |
} | |
} | |
public ArrayList getExtraClasses() { | |
if (extraClasses == null) { | |
extraClasses = new ArrayList(); | |
} | |
return extraClasses; | |
} | |
public void setExtraClasses(ArrayList extraClasses) { | |
this.extraClasses = extraClasses; | |
} | |
private String resolveSchemaNamespace(String packageName) throws SchemaGeneratorException { | |
if (useWSDLTypesNamespace) { | |
return (String) pkg2nsmap.get("all"); | |
} else { | |
if (pkg2nsmap != null && !pkg2nsmap.isEmpty()) { | |
//if types should go into namespaces that are mapped against the package name for the type | |
if (pkg2nsmap.get(packageName) != null) { | |
//return that mapping | |
return (String) pkg2nsmap.get(packageName); | |
} else { | |
return getNsGen().schemaNamespaceFromPackageName(packageName).toString(); | |
} | |
} else { | |
// if pkg2nsmap is null and if not default schema ns found for the custom bean | |
return getNsGen().schemaNamespaceFromPackageName(packageName).toString(); | |
} | |
} | |
} | |
public boolean isUseWSDLTypesNamespace() { | |
return useWSDLTypesNamespace; | |
} | |
public void setUseWSDLTypesNamespace(boolean useWSDLTypesNamespace) { | |
this.useWSDLTypesNamespace = useWSDLTypesNamespace; | |
} | |
public Map getPkg2nsmap() { | |
return pkg2nsmap; | |
} | |
public void setPkg2nsmap(Map pkg2nsmap) { | |
this.pkg2nsmap = pkg2nsmap; | |
} | |
public String getTargetNamespace() { | |
return targetNamespace; | |
} | |
protected String getSimpleName(DataType type){ | |
if (type instanceof CompositeDataType) { | |
CompositeDataType compositeType = (CompositeDataType) type; | |
return compositeType.getName(); | |
} else { | |
return CorbaUtil.getQualifiedName(type); | |
} | |
} | |
public void setNonRpcMethods(ArrayList nonRpcMethods) { | |
if(nonRpcMethods!=null){ | |
this.nonRpcMethods = nonRpcMethods; | |
} | |
} | |
private String getModuleName(DataType type) { | |
if (type instanceof CompositeDataType) { | |
CompositeDataType compositeType = (CompositeDataType) type; | |
String module = compositeType.getModule(); | |
module = module.replaceAll("::", "."); | |
if (module.endsWith(".")) { | |
module = module.substring(0, module.length() - 1); | |
} | |
return module; | |
} else { | |
return ""; | |
} | |
} | |
} |