/*
* 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
*/
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 "";
}
}
}