package org.jboss.axis.wsdl.symbolTable;
import org.jboss.axis.Constants;
import org.jboss.axis.enums.Style;
import org.jboss.axis.enums.Use;
import org.jboss.axis.utils.LinkedHashMap;
import org.jboss.axis.utils.Messages;
import org.jboss.axis.utils.URLHashSet;
import org.jboss.axis.utils.XMLUtils;
import org.jboss.logging.Logger;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
import javax.wsdl.Binding;
import javax.wsdl.BindingFault;
import javax.wsdl.BindingInput;
import javax.wsdl.BindingOperation;
import javax.wsdl.BindingOutput;
import javax.wsdl.Definition;
import javax.wsdl.Fault;
import javax.wsdl.Import;
import javax.wsdl.Input;
import javax.wsdl.Message;
import javax.wsdl.Operation;
import javax.wsdl.Output;
import javax.wsdl.Part;
import javax.wsdl.Port;
import javax.wsdl.PortType;
import javax.wsdl.Service;
import javax.wsdl.WSDLException;
import javax.wsdl.extensions.UnknownExtensibilityElement;
import javax.wsdl.extensions.http.HTTPBinding;
import javax.wsdl.extensions.mime.MIMEContent;
import javax.wsdl.extensions.mime.MIMEMultipartRelated;
import javax.wsdl.extensions.mime.MIMEPart;
import javax.wsdl.extensions.soap.SOAPBinding;
import javax.wsdl.extensions.soap.SOAPBody;
import javax.wsdl.extensions.soap.SOAPFault;
import javax.wsdl.extensions.soap.SOAPHeader;
import javax.wsdl.extensions.soap.SOAPHeaderFault;
import javax.wsdl.factory.WSDLFactory;
import javax.wsdl.xml.WSDLReader;
import javax.xml.namespace.QName;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.rpc.holders.BooleanHolder;
import javax.xml.rpc.holders.IntHolder;
import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Vector;
public class SymbolTable
{
private static final Logger log = Logger.getLogger(SymbolTable.class);
private boolean addImports;
private HashMap symbolTable = new HashMap();
private final Map elementTypeEntries = new HashMap();
private final Map elementIndex = Collections.unmodifiableMap(elementTypeEntries);
private final Map typeTypeEntries = new HashMap();
private final Map typeIndex = Collections.unmodifiableMap(typeTypeEntries);
protected final Map node2ExtensionBase = new HashMap();
private boolean verbose;
private BaseTypeMapping btm = null;
private boolean nowrap;
private boolean wrapped = false;
public static final String ANON_TOKEN = ">";
private Definition def = null;
private String wsdlURI = null;
public SymbolTable(BaseTypeMapping btm, boolean addImports,
boolean verbose, boolean nowrap)
{
this.btm = btm;
this.addImports = addImports;
this.verbose = verbose;
this.nowrap = nowrap;
}
public HashMap getHashMap()
{
return symbolTable;
}
public Vector getSymbols(QName qname)
{
return (Vector)symbolTable.get(qname);
}
public SymTabEntry get(QName qname, Class cls)
{
Vector v = (Vector)symbolTable.get(qname);
if (v == null)
{
return null;
}
else
{
for (int i = 0; i < v.size(); ++i)
{
SymTabEntry entry = (SymTabEntry)v.elementAt(i);
if (cls.isInstance(entry))
{
return entry;
}
}
return null;
}
}
public TypeEntry getTypeEntry(QName qname, boolean wantElementType)
{
if (wantElementType)
{
return getElement(qname);
}
else
return getType(qname);
}
public Type getType(QName qname)
{
return (Type)typeTypeEntries.get(qname);
}
public Element getElement(QName qname)
{
return (Element)elementTypeEntries.get(qname);
}
public MessageEntry getMessageEntry(QName qname)
{
return (MessageEntry)get(qname, MessageEntry.class);
}
public PortTypeEntry getPortTypeEntry(QName qname)
{
return (PortTypeEntry)get(qname, PortTypeEntry.class);
}
public BindingEntry getBindingEntry(QName qname)
{
return (BindingEntry)get(qname, BindingEntry.class);
}
public ServiceEntry getServiceEntry(QName qname)
{
return (ServiceEntry)get(qname, ServiceEntry.class);
}
public Vector getTypes()
{
Vector v = new Vector();
v.addAll(elementTypeEntries.values());
v.addAll(typeTypeEntries.values());
return v;
}
public Map getElementIndex()
{
return elementIndex;
}
public Map getTypeIndex()
{
return typeIndex;
}
public int getTypeEntryCount()
{
return elementTypeEntries.size() + typeTypeEntries.size();
}
public Definition getDefinition()
{
return def;
}
public String getWSDLURI()
{
return wsdlURI;
}
public boolean isWrapped()
{
return wrapped;
}
public void setWrapped(boolean wrapped)
{
this.wrapped = wrapped;
}
public void dump(java.io.PrintStream out)
{
out.println();
out.println(Messages.getMessage("symbolTable00"));
out.println("-----------------------");
Iterator it = symbolTable.values().iterator();
while (it.hasNext())
{
Vector v = (Vector)it.next();
for (int i = 0; i < v.size(); ++i)
{
out.println(v.elementAt(i).getClass().getName());
out.println(v.elementAt(i));
}
}
out.println("-----------------------");
}
public void populate(String uri)
throws IOException, WSDLException,
SAXException, ParserConfigurationException
{
populate(uri, null, null);
}
public void populate(String uri, String username, String password)
throws IOException, WSDLException,
SAXException, ParserConfigurationException
{
if (verbose)
System.out.println(Messages.getMessage("parsing00", uri));
Document doc = XMLUtils.newDocument(uri, username, password);
this.wsdlURI = uri;
try
{
File f = new File(uri);
if (f.exists())
{
uri = f.toURL().toString();
}
}
catch (Exception e)
{
}
populate(uri, doc);
}
public void populate(String context, Document doc)
throws IOException, SAXException, WSDLException,
ParserConfigurationException
{
WSDLReader reader = WSDLFactory.newInstance().newWSDLReader();
reader.setFeature("javax.wsdl.verbose", verbose);
this.def = reader.readWSDL(context, doc);
add(context, def, doc);
}
protected void add(String context, Definition def, Document doc)
throws IOException, SAXException, WSDLException,
ParserConfigurationException
{
URL contextURL = context == null ? null : getURL(null, context);
populate(contextURL, def, doc, null);
checkForUndefined();
populateParameters();
setReferences(def, doc); }
private void checkForUndefined(Definition def, String filename) throws IOException
{
if (def != null)
{
Iterator ib = def.getBindings().values().iterator();
while (ib.hasNext())
{
Binding binding = (Binding)ib.next();
if (binding.isUndefined())
{
if (filename == null)
{
throw new IOException(Messages.getMessage("emitFailtUndefinedBinding01",
binding.getQName().getLocalPart()));
}
else
{
throw new IOException(Messages.getMessage("emitFailtUndefinedBinding02",
binding.getQName().getLocalPart(), filename));
}
}
}
Iterator ip = def.getPortTypes().values().iterator();
while (ip.hasNext())
{
PortType portType = (PortType)ip.next();
if (portType.isUndefined())
{
if (filename == null)
{
throw new IOException(Messages.getMessage("emitFailtUndefinedPort01",
portType.getQName().getLocalPart()));
}
else
{
throw new IOException(Messages.getMessage("emitFailtUndefinedPort02",
portType.getQName().getLocalPart(), filename));
}
}
}
}
}
private void checkForUndefined() throws IOException
{
Iterator it = symbolTable.values().iterator();
while (it.hasNext())
{
Vector v = (Vector)it.next();
for (int i = 0; i < v.size(); ++i)
{
SymTabEntry entry = (SymTabEntry)v.get(i);
if (entry instanceof UndefinedType)
{
QName qn = entry.getQName();
if ((qn.getLocalPart().equals("dateTime") &&
!qn.getNamespaceURI().equals(Constants.URI_2001_SCHEMA_XSD)) ||
(qn.getLocalPart().equals("timeInstant") &&
qn.getNamespaceURI().equals(Constants.URI_2001_SCHEMA_XSD)))
{
throw new IOException(Messages.getMessage("wrongNamespace00",
qn.getLocalPart(),
qn.getNamespaceURI()));
}
if (SchemaUtils.isSimpleSchemaType(entry.getQName()))
{
throw new IOException(Messages.getMessage("unsupportedSchemaType00",
qn.getLocalPart()));
}
throw new IOException(Messages.getMessage("undefined00",
entry.getQName().toString()));
} else if (entry instanceof UndefinedElement)
{
throw new IOException(Messages.getMessage("undefinedElem00",
entry.getQName().toString()));
}
}
}
}
private URLHashSet importedFiles = new URLHashSet();
private void populate(URL context, Definition def, Document doc,
String filename)
throws IOException, ParserConfigurationException,
SAXException, WSDLException
{
if (doc != null)
{
populateTypes(context, doc);
if (addImports)
{
lookForImports(context, doc);
}
}
if (def != null)
{
checkForUndefined(def, filename);
if (addImports)
{
Map imports = def.getImports();
Object[] importKeys = imports.keySet().toArray();
for (int i = 0; i < importKeys.length; ++i)
{
Vector v = (Vector)imports.get(importKeys[i]);
for (int j = 0; j < v.size(); ++j)
{
Import imp = (Import)v.get(j);
if (!importedFiles.contains(imp.getLocationURI()))
{
importedFiles.add(imp.getLocationURI());
URL url = getURL(context, imp.getLocationURI());
populate(url, imp.getDefinition(),
XMLUtils.newDocument(url.toString()),
url.toString());
}
}
}
}
populateMessages(def);
populatePortTypes(def);
populateBindings(def);
populateServices(def);
}
}
private static URL getURL(URL contextURL, String spec) throws IOException
{
String path = spec.replace('\\', '/');
URL url = null;
try
{
url = new URL(contextURL, path);
if (contextURL != null &&
url.getProtocol().equals("file") &&
contextURL.getProtocol().equals("file"))
{
url = getFileURL(contextURL, path);
}
}
catch (MalformedURLException me)
{
url = getFileURL(contextURL, path);
}
return url;
}
private static URL getFileURL(URL contextURL, String path)
throws IOException
{
if (contextURL != null)
{
String contextFileName = contextURL.getFile();
URL parent = new File(contextFileName).getParentFile().toURL();
if (parent != null)
{
return new URL(parent, path);
}
}
return new URL("file", "", path);
}
private void lookForImports(URL context, Node node)
throws IOException, ParserConfigurationException,
SAXException, WSDLException
{
NodeList children = node.getChildNodes();
for (int i = 0; i < children.getLength(); i++)
{
Node child = children.item(i);
if ("import".equals(child.getLocalName()))
{
NamedNodeMap attributes = child.getAttributes();
Node namespace = attributes.getNamedItem("namespace");
if (namespace != null &&
isKnownNamespace(namespace.getNodeValue()))
{
continue;
}
Node importFile = attributes.getNamedItem("schemaLocation");
if (importFile != null)
{
URL url = getURL(context,
importFile.getNodeValue());
if (!importedFiles.contains(url))
{
importedFiles.add(url);
String filename = url.toString();
populate(url, null,
XMLUtils.newDocument(filename), filename);
}
}
}
lookForImports(context, child);
}
}
public boolean isKnownNamespace(String namespace)
{
if (Constants.isSOAP_ENC(namespace))
return true;
if (Constants.isSchemaXSD(namespace))
return true;
if (Constants.isSchemaXSI(namespace))
return true;
if (namespace.equals(Constants.NS_URI_XML))
return true;
return false;
}
public void populateTypes(URL context, Document doc)
throws IOException, SAXException, WSDLException,
ParserConfigurationException
{
addTypes(context, doc, ABOVE_SCHEMA_LEVEL);
}
private static final int ABOVE_SCHEMA_LEVEL = -1;
private static final int SCHEMA_LEVEL = 0;
private void addTypes(URL context, Node node, int level)
throws IOException, ParserConfigurationException,
WSDLException, SAXException
{
if (node == null)
{
return;
}
QName nodeKind = Utils.getNodeQName(node);
if (nodeKind != null)
{
String localPart = nodeKind.getLocalPart();
boolean isXSD = Constants.isSchemaXSD(nodeKind.getNamespaceURI());
if ((isXSD && localPart.equals("complexType") ||
localPart.equals("simpleType")))
{
Node re = SchemaUtils.getRestrictionOrExtensionNode(node);
if (re != null &&
Utils.getAttribute(re, "base") != null)
{
createTypeFromRef(re);
}
createTypeFromDef(node, false, false);
}
else if (isXSD && localPart.equals("element"))
{
createTypeFromRef(node);
Node re = SchemaUtils.getRestrictionOrExtensionNode(node);
if (re != null &&
Utils.getAttribute(re, "base") != null)
{
createTypeFromRef(re);
}
createTypeFromDef(node, true, level > SCHEMA_LEVEL);
}
else if (isXSD && localPart.equals("attribute"))
{
BooleanHolder forElement = new BooleanHolder();
QName refQName = Utils.getTypeQName(node, forElement, false);
if (refQName != null && !forElement.value)
{
createTypeFromRef(node);
if (refQName != null)
{
TypeEntry refType = getTypeEntry(refQName, false);
if (refType != null &&
refType instanceof Undefined)
{
refType.setSimpleType(true);
}
else if (refType == null ||
(!(refType instanceof BaseType) &&
!refType.isSimpleType()))
{
throw new IOException(Messages.getMessage("AttrNotSimpleType01",
refQName.toString()));
}
}
}
}
else if (isXSD && localPart.equals("any"))
{
if (getType(Constants.XSD_ANY) == null)
{
Type type = new BaseType(Constants.XSD_ANY);
symbolTablePut(type);
}
}
else if (localPart.equals("part") &&
Constants.isWSDL(nodeKind.getNamespaceURI()))
{
createTypeFromRef(node);
}
else if (isXSD && localPart.equals("include"))
{
String includeName = Utils.getAttribute(node, "schemaLocation");
if (includeName != null)
{
URL url = getURL(context, includeName);
Document includeDoc = XMLUtils.newDocument(url.toString());
org.w3c.dom.Element schemaEl = includeDoc.getDocumentElement();
if (!schemaEl.hasAttribute("targetNamespace"))
{
org.w3c.dom.Element parentSchemaEl = (org.w3c.dom.Element)node.getParentNode();
if (parentSchemaEl.hasAttribute("targetNamespace"))
{
String tns = parentSchemaEl.getAttribute("targetNamespace");
schemaEl.setAttribute("targetNamespace", tns);
schemaEl.setAttribute("xmlns", tns);
}
}
populate(url, null, includeDoc, url.toString());
}
}
}
if (level == ABOVE_SCHEMA_LEVEL)
{
if (nodeKind != null && nodeKind.getLocalPart().equals("schema"))
{
level = SCHEMA_LEVEL;
}
}
else
{
++level;
}
NodeList children = node.getChildNodes();
for (int i = 0; i < children.getLength(); i++)
{
addTypes(context, children.item(i), level);
}
}
private void createTypeFromDef(Node node, boolean isElement,
boolean belowSchemaLevel) throws IOException
{
QName qName = Utils.getNodeNameQName(node);
if (qName != null)
{
if (!isElement && btm.getBaseName(qName) != null)
{
return;
}
BooleanHolder forElement = new BooleanHolder();
QName refQName = Utils.getTypeQName(node, forElement, false);
if (refQName != null)
{
if (qName.getLocalPart().length() == 0)
{
String name = Utils.getAttribute(node, "name");
if (name == null)
{
name = "unknown";
}
throw new IOException(Messages.getMessage("emptyref00", name));
}
TypeEntry refType = getTypeEntry(refQName, forElement.value);
if (!belowSchemaLevel)
{
if (refType == null)
{
throw new IOException(Messages.getMessage("absentRef00", refQName.toString(), qName.toString()));
}
symbolTablePut(new DefinedElement(qName, refType, node, ""));
}
}
else
{
IntHolder numDims = new IntHolder();
numDims.value = 0;
QName arrayEQName = SchemaUtils.getArrayComponentQName(node, numDims);
if (arrayEQName != null)
{
refQName = arrayEQName;
TypeEntry refType = getTypeEntry(refQName, false);
if (refType == null)
{
String baseName = btm.getBaseName(refQName);
if (baseName != null)
refType = new BaseType(refQName);
else
refType = new UndefinedType(refQName);
symbolTablePut(refType);
}
String dims = "";
while (numDims.value > 0)
{
dims += "[]";
numDims.value--;
}
TypeEntry defType = null;
if (isElement)
{
if (!belowSchemaLevel)
{
defType = new DefinedElement(qName, refType, node, dims);
}
}
else
{
defType = new DefinedType(qName, refType, node, dims);
}
if (defType != null)
{
symbolTablePut(defType);
}
}
else
{
String baseName = btm.getBaseName(qName);
if (baseName != null)
{
symbolTablePut(new BaseType(qName));
}
else
{
TypeEntry te = null;
if (!isElement)
{
te = new DefinedType(qName, node);
if (qName.getLocalPart().indexOf(ANON_TOKEN) >= 0)
{
Node parent = node.getParentNode();
QName parentQName = Utils.getNodeNameQName(parent);
TypeEntry parentType = getElement(parentQName);
if (parentType != null)
{
parentType.setRefType(te);
}
}
}
else
{
if (!belowSchemaLevel)
{
te = new DefinedElement(qName, node);
}
}
if (te != null)
{
if (SchemaUtils.isSimpleTypeOrSimpleContent(node))
{
te.setSimpleType(true);
}
symbolTablePut(te);
}
}
}
}
}
}
private void createTypeFromRef(Node node) throws IOException
{
BooleanHolder forElement = new BooleanHolder();
QName qName = Utils.getTypeQName(node, forElement, false);
if (qName != null)
{
if (qName.getLocalPart().length() == 0)
{
String name = Utils.getAttribute(node, "name");
if (name == null)
{
name = "unknown";
}
throw new IOException(Messages.getMessage("emptyref00", name));
}
TypeEntry type = getTypeEntry(qName, forElement.value);
if (type == null)
{
if (qName.getLocalPart().indexOf("[") > 0)
{
QName containedQName = Utils.getTypeQName(node, forElement, true);
TypeEntry containedTE = getTypeEntry(containedQName, forElement.value);
if (!forElement.value)
{
if (containedTE == null)
{
String baseName = btm.getBaseName(containedQName);
if (baseName != null)
{
containedTE = new BaseType(containedQName);
}
else
{
containedTE = new UndefinedType(containedQName);
}
symbolTablePut(containedTE);
}
symbolTablePut(new CollectionType(qName, containedTE, node, "[]"));
}
else
{
if (containedTE == null)
{
containedTE = new UndefinedElement(containedQName);
symbolTablePut(containedTE);
}
symbolTablePut(new CollectionElement(qName, containedTE, node, "[]"));
}
}
else
{
String baseName = btm.getBaseName(qName);
if (baseName != null)
symbolTablePut(new BaseType(qName));
else if (forElement.value == false)
symbolTablePut(new UndefinedType(qName));
else
symbolTablePut(new UndefinedElement(qName));
}
}
}
}
private void populateMessages(Definition def) throws IOException
{
Iterator i = def.getMessages().values().iterator();
while (i.hasNext())
{
Message message = (Message)i.next();
MessageEntry mEntry = new MessageEntry(message);
symbolTablePut(mEntry);
}
}
protected void ensureOperationMessageValid(Message message) throws IOException
{
if (message == null)
{
throw new IOException("<input>,<output>, or <fault> in <operation ..> without attribute 'message' found. Attribute 'message' is required.");
}
if (message.isUndefined())
{
throw new IOException("<input ..>, <output ..> or <fault ..> in <portType> with undefined message found. message name is '"
+ message.getQName().toString()
+ "'");
}
}
protected void ensureOperationValid(Operation operation) throws IOException
{
if (operation == null)
{
throw new IllegalArgumentException("parameter 'operation' must not be null");
}
Input input = operation.getInput();
if (input != null)
{
ensureOperationMessageValid(input.getMessage());
}
Output output = operation.getOutput();
if (output != null)
{
ensureOperationMessageValid(output.getMessage());
}
Map faults = operation.getFaults();
if (faults != null)
{
Iterator it = faults.values().iterator();
while (it.hasNext())
{
ensureOperationMessageValid(((Fault)it.next()).getMessage());
}
}
}
protected void ensureOperationsOfPortTypeValid(PortType portType) throws IOException
{
if (portType == null)
throw new IllegalArgumentException("parameter 'portType' must not be null");
List operations = portType.getOperations();
if (operations == null || operations.size() == 0) return;
Iterator it = operations.iterator();
while (it.hasNext())
{
Operation operation = (Operation)it.next();
ensureOperationValid(operation);
}
}
private void populatePortTypes(Definition def) throws IOException
{
Iterator i = def.getPortTypes().values().iterator();
while (i.hasNext())
{
PortType portType = (PortType)i.next();
if (!portType.isUndefined())
{
ensureOperationsOfPortTypeValid(portType);
PortTypeEntry ptEntry = new PortTypeEntry(portType);
symbolTablePut(ptEntry);
}
}
}
private void populateParameters() throws IOException
{
Iterator it = symbolTable.values().iterator();
while (it.hasNext())
{
Vector v = (Vector)it.next();
for (int i = 0; i < v.size(); ++i)
{
if (v.get(i) instanceof BindingEntry)
{
BindingEntry bEntry = (BindingEntry)v.get(i);
if (bEntry.getBindingType() != BindingEntry.TYPE_SOAP)
continue;
Binding binding = bEntry.getBinding();
Collection bindOperations = bEntry.getOperations();
PortType portType = binding.getPortType();
LinkedHashMap parameters = new LinkedHashMap();
Iterator operations = portType.getOperations().iterator();
while (operations.hasNext())
{
Operation operation = (Operation)operations.next();
if (!bindOperations.contains(operation))
{
throw new IOException(Messages.getMessage("emitFailNoMatchingBindOperation01",
operation.getName(),
portType.getQName().getLocalPart()));
}
String namespace = portType.getQName().getNamespaceURI();
Parameters parms = getOperationParameters(operation,
namespace,
bEntry);
parameters.put(operation, parms);
}
bEntry.setParameters(parameters);
}
}
}
}
public Parameters getOperationParameters(Operation operation,
String namespace,
BindingEntry bindingEntry) throws IOException
{
Parameters parameters = new Parameters();
Vector inputs = new Vector();
Vector outputs = new Vector();
List parameterOrder = operation.getParameterOrdering();
if (parameterOrder != null && parameterOrder.isEmpty())
{
parameterOrder = null;
}
if (parameterOrder != null)
{
Input input = operation.getInput();
if (input != null)
{
Message inputMsg = input.getMessage();
Map allInputs = inputMsg.getParts();
Collection orderedInputs = inputMsg.getOrderedParts(parameterOrder);
if (allInputs.size() != orderedInputs.size())
{
throw new IOException(Messages.getMessage("emitFail00", operation.getName()));
}
}
}
boolean literalInput = false;
boolean literalOutput = false;
if (bindingEntry != null)
{
literalInput = (bindingEntry.getInputBodyType(operation) == Use.LITERAL);
literalOutput = (bindingEntry.getOutputBodyType(operation) == Use.LITERAL);
}
Input input = operation.getInput();
if (input != null && input.getMessage() != null)
{
getParametersFromParts(inputs,
input.getMessage().getOrderedParts(null),
literalInput,
operation.getName(),
bindingEntry);
}
Output output = operation.getOutput();
if (output != null && output.getMessage() != null)
{
getParametersFromParts(outputs,
output.getMessage().getOrderedParts(null),
literalOutput,
operation.getName(),
bindingEntry);
}
if (parameterOrder != null)
{
for (int i = 0; i < parameterOrder.size(); ++i)
{
String name = (String)parameterOrder.get(i);
int index = getPartIndex(name, inputs);
int outdex = getPartIndex(name, outputs);
if (index >= 0)
{
addInishParm(inputs, outputs, index, outdex, parameters, true);
}
else if (outdex >= 0)
{
addOutParm(outputs, outdex, parameters, true);
}
else
{
System.err.println(Messages.getMessage("noPart00", name));
}
}
}
if (wrapped && inputs.size() == 1 && outputs.size() == 1 &&
((Parameter)inputs.get(0)).getName().equals(((Parameter)outputs.get(0)).getName()))
{
addInishParm(inputs, null, 0, -1, parameters, false);
}
else
{
for (int i = 0; i < inputs.size(); i++)
{
Parameter p = (Parameter)inputs.get(i);
int outdex = getPartIndex(p.getName(), outputs);
addInishParm(inputs, outputs, i, outdex, parameters, false);
}
}
if (outputs.size() == 1)
{
parameters.returnParam = (Parameter)outputs.get(0);
parameters.returnParam.setMode(Parameter.OUT);
if (parameters.returnParam.getType() instanceof DefinedElement)
{
parameters.returnParam.setQName(parameters.returnParam.getType()
.getQName());
}
++parameters.outputs;
}
else
{
for (int i = 0; i < outputs.size(); i++)
{
addOutParm(outputs, i, parameters, false);
}
}
parameters.faults = operation.getFaults();
Vector used = new Vector(parameters.list.size());
Iterator i = parameters.list.iterator();
while (i.hasNext())
{
Parameter parameter = (Parameter)i.next();
int count = 2;
while (used.contains(parameter.getName()))
{
parameter.setName(parameter.getName() + Integer.toString(count++));
}
used.add(parameter.getName());
}
return parameters;
}
private boolean isInParameterList(Vector params, String partName)
{
for (int i = 0; i < params.size(); i++)
{
Parameter parameter = (Parameter)params.get(i);
if (partName.equals(parameter.getName()))
return true;
}
return false;
}
private int getPartIndex(String name, Vector v)
{
for (int i = 0; i < v.size(); i++)
{
if (name.equals(((Parameter)v.get(i)).getName()))
{
return i;
}
}
return -1;
}
private void addInishParm(Vector inputs,
Vector outputs,
int index,
int outdex,
Parameters parameters,
boolean trimInput)
{
Parameter p = (Parameter)inputs.get(index);
if (p.getType() instanceof DefinedElement)
{
DefinedElement de = (DefinedElement)p.getType();
p.setQName(de.getQName());
}
if (p.getType() instanceof CollectionElement)
{
p.setQName(p.getType().getRefType().getQName());
}
if (trimInput)
{
inputs.remove(index);
}
if (outdex >= 0)
{
Parameter outParam = (Parameter)outputs.get(outdex);
if (p.getType().equals(outParam.getType()))
{
outputs.remove(outdex);
p.setMode(Parameter.INOUT);
++parameters.inouts;
}
else
{
++parameters.inputs;
}
}
else
{
++parameters.inputs;
}
parameters.list.add(p);
}
private void addOutParm(Vector outputs,
int outdex,
Parameters parameters,
boolean trim)
{
Parameter p = (Parameter)outputs.get(outdex);
if (p.getType() instanceof DefinedElement)
{
DefinedElement de = (DefinedElement)p.getType();
p.setQName(de.getQName());
}
if (p.getType() instanceof CollectionElement)
{
p.setQName(p.getType().getRefType().getQName());
}
if (trim)
{
outputs.remove(outdex);
}
p.setMode(Parameter.OUT);
++parameters.outputs;
parameters.list.add(p);
}
public void getParametersFromParts(Vector v,
Collection parts,
boolean literal,
String opName,
BindingEntry bindingEntry)
throws IOException
{
int numberOfElements = 0;
boolean possiblyWrapped = false;
Iterator i = parts.iterator();
while (i.hasNext())
{
Part part = (Part)i.next();
if (part.getElementName() != null)
{
++numberOfElements;
if (part.getElementName().getLocalPart().equals(opName))
{
possiblyWrapped = true;
}
}
}
if (!nowrap &&
literal &&
numberOfElements == 1 &&
possiblyWrapped)
{
wrapped = true;
}
i = parts.iterator();
while (i.hasNext())
{
Parameter param = new Parameter();
Part part = (Part)i.next();
QName elementName = part.getElementName();
QName typeName = part.getTypeName();
String partName = part.getName();
if (!literal || !wrapped || elementName == null)
{
param.setName(partName);
if (typeName != null)
{
param.setType(getType(typeName));
}
else if (elementName != null)
{
param.setType(getElement(elementName));
}
else
{
throw new IOException(Messages.getMessage("noTypeOrElement00",
new String[]{partName,
opName}));
}
setMIMEInfo(param, bindingEntry == null ? null :
bindingEntry.getMIMEInfo(opName, partName));
if (bindingEntry != null &&
bindingEntry.isInHeaderPart(opName, partName))
{
param.setInHeader(true);
}
if (bindingEntry != null &&
bindingEntry.isOutHeaderPart(opName, partName))
{
param.setOutHeader(true);
}
v.add(param);
continue; }
Node node = null;
if (typeName != null && bindingEntry.getMIMETypes().size() == 0)
{
String bindingName =
bindingEntry == null ? "unknown" : bindingEntry.getBinding().getQName().toString();
throw new IOException(Messages.getMessage("literalTypePart00",
new String[]{partName,
opName,
bindingName}));
}
node = getTypeEntry(elementName, true).getNode();
BooleanHolder forElement = new BooleanHolder();
QName type = Utils.getTypeQName(node, forElement, false);
if (type != null && !forElement.value)
{
node = getTypeEntry(type, false).getNode();
}
Vector vTypes = null;
if (node == null)
{
if (bindingEntry.isInHeaderPart(opName, partName))
{
wrapped = false;
}
else
{
}
}
else
{
Vector vAttrs = SchemaUtils.getContainedAttributeTypes(node, this);
if (vAttrs != null)
{
wrapped = false;
}
vTypes = SchemaUtils.getContainedElementDeclarations(node, this);
}
if (vTypes != null && wrapped)
{
for (int j = 0; j < vTypes.size(); j++)
{
ElementDecl elem = (ElementDecl)vTypes.elementAt(j);
Parameter p = new Parameter();
p.setQName(elem.getName());
p.setType(elem.getType());
setMIMEInfo(p, bindingEntry == null ? null :
bindingEntry.getMIMEInfo(opName, partName));
if (bindingEntry.isInHeaderPart(opName, partName))
{
p.setInHeader(true);
}
if (bindingEntry.isOutHeaderPart(opName, partName))
{
p.setOutHeader(true);
}
v.add(p);
}
}
else
{
param.setName(partName);
if (typeName != null)
{
param.setType(getType(typeName));
}
else if (elementName != null)
{
param.setType(getElement(elementName));
}
setMIMEInfo(param, bindingEntry == null ? null :
bindingEntry.getMIMEInfo(opName, partName));
if (bindingEntry.isInHeaderPart(opName, partName))
{
param.setInHeader(true);
}
if (bindingEntry.isOutHeaderPart(opName, partName))
{
param.setOutHeader(true);
}
v.add(param);
}
}
}
private void setMIMEInfo(Parameter p, MimeInfo mimeInfo)
{
if (mimeInfo == null)
{
QName mimeQName = p.getType().getQName();
if (mimeQName.getNamespaceURI().equals(Constants.NS_URI_XMLSOAP))
{
if (Constants.MIME_IMAGE.equals(mimeQName))
{
mimeInfo = new MimeInfo("image/jpeg", "");
}
else if (Constants.MIME_PLAINTEXT.equals(mimeQName))
{
mimeInfo = new MimeInfo("text/plain", "");
}
else if (Constants.MIME_MULTIPART.equals(mimeQName))
{
mimeInfo = new MimeInfo("multipart/related", "");
}
else if (Constants.MIME_SOURCE.equals(mimeQName))
{
mimeInfo = new MimeInfo("text/xml", "");
}
else if (Constants.MIME_OCTETSTREAM.equals(mimeQName))
{
mimeInfo = new MimeInfo("application/octetstream", "");
}
}
}
p.setMIMEInfo(mimeInfo);
}
private void populateBindings(Definition def) throws IOException
{
Iterator i = def.getBindings().values().iterator();
while (i.hasNext())
{
Binding binding = (Binding)i.next();
BindingEntry bEntry = new BindingEntry(binding);
symbolTablePut(bEntry);
Iterator extensibilityElementsIterator = binding.getExtensibilityElements().iterator();
while (extensibilityElementsIterator.hasNext())
{
Object obj = extensibilityElementsIterator.next();
if (obj instanceof SOAPBinding)
{
bEntry.setBindingType(BindingEntry.TYPE_SOAP);
SOAPBinding sb = (SOAPBinding)obj;
String style = sb.getStyle();
if ("rpc".equalsIgnoreCase(style))
{
bEntry.setBindingStyle(Style.RPC);
}
}
else if (obj instanceof HTTPBinding)
{
HTTPBinding hb = (HTTPBinding)obj;
if (hb.getVerb().equalsIgnoreCase("post"))
{
bEntry.setBindingType(BindingEntry.TYPE_HTTP_POST);
}
else
{
bEntry.setBindingType(BindingEntry.TYPE_HTTP_GET);
}
}
else if (obj instanceof UnknownExtensibilityElement)
{
UnknownExtensibilityElement unkElement = (UnknownExtensibilityElement)obj;
QName name = unkElement.getElementType();
if (name.getNamespaceURI().equals(Constants.URI_WSDL12_SOAP) &&
name.getLocalPart().equals("binding"))
{
bEntry.setBindingType(BindingEntry.TYPE_SOAP);
String style = unkElement.getElement().getAttribute("style");
if ("rpc".equalsIgnoreCase(style))
{
bEntry.setBindingStyle(Style.RPC);
}
}
}
}
HashMap attributes = new HashMap();
List bindList = binding.getBindingOperations();
HashMap faultMap = new HashMap(); for (Iterator opIterator = bindList.iterator(); opIterator.hasNext();)
{
BindingOperation bindOp = (BindingOperation)opIterator.next();
Operation operation = bindOp.getOperation();
BindingInput bindingInput = bindOp.getBindingInput();
BindingOutput bindingOutput = bindOp.getBindingOutput();
String opName = bindOp.getName();
String inputName = bindingInput == null ? null :
bindingInput.getName();
String outputName = bindingOutput == null ? null :
bindingOutput.getName();
if (binding.getPortType().getOperation(opName, inputName, outputName) == null)
{
throw new IOException(Messages.getMessage("unmatchedOp",
new String[]{opName, inputName, outputName}));
}
ArrayList faults = new ArrayList();
if (bindingInput != null)
{
if (bindingInput.getExtensibilityElements() != null)
{
Iterator inIter = bindingInput.
getExtensibilityElements().iterator();
fillInBindingInfo(bEntry, operation, inIter, faults,
true);
}
}
if (bindingOutput != null)
{
if (bindingOutput.getExtensibilityElements() != null)
{
Iterator outIter = bindingOutput.
getExtensibilityElements().iterator();
fillInBindingInfo(bEntry, operation, outIter, faults,
false);
}
}
faultsFromSOAPFault(binding, bindOp, operation, faults);
faultMap.put(bindOp, faults);
Use inputBodyType = bEntry.getInputBodyType(operation);
Use outputBodyType = bEntry.getOutputBodyType(operation);
attributes.put(bindOp.getOperation(),
new BindingEntry.OperationAttr(inputBodyType, outputBodyType, faultMap));
if (inputBodyType == Use.LITERAL ||
outputBodyType == Use.LITERAL)
{
bEntry.setHasLiteral(true);
}
bEntry.setFaultBodyTypeMap(operation, faultMap);
}
bEntry.setFaults(faultMap);
}
}
private void fillInBindingInfo(BindingEntry bEntry, Operation operation,
Iterator it, ArrayList faults, boolean input) throws IOException
{
for (; it.hasNext();)
{
Object obj = it.next();
if (obj instanceof SOAPBody)
{
setBodyType(((SOAPBody)obj).getUse(), bEntry, operation,
input);
}
else if (obj instanceof SOAPHeader)
{
SOAPHeader header = (SOAPHeader)obj;
setBodyType(header.getUse(), bEntry, operation, input);
bEntry.setHeaderPart(operation.getName(), header.getPart(), header,
input ? BindingEntry.IN_HEADER : BindingEntry.OUT_HEADER);
Iterator headerFaults = header.getSOAPHeaderFaults().iterator();
while (headerFaults.hasNext())
{
SOAPHeaderFault headerFault =
(SOAPHeaderFault)headerFaults.next();
faults.add(new FaultInfo(headerFault, this));
}
}
else if (obj instanceof MIMEMultipartRelated)
{
bEntry.setBodyType(operation,
addMIMETypes(bEntry, (MIMEMultipartRelated)obj,
operation), input);
}
else if (obj instanceof UnknownExtensibilityElement)
{
UnknownExtensibilityElement unkElement = (UnknownExtensibilityElement)obj;
QName name = unkElement.getElementType();
if (name.getNamespaceURI().equals(Constants.URI_DIME_WSDL) &&
name.getLocalPart().equals("message"))
{
fillInDIMEInformation(unkElement, input, operation, bEntry);
}
if (name.getNamespaceURI().equals(Constants.URI_WSDL12_SOAP) &&
name.getLocalPart().equals("body"))
{
setBodyType(unkElement.getElement().getAttribute("use"), bEntry, operation,
input);
}
if (name.getNamespaceURI().equals(Constants.URI_WSDL12_SOAP) &&
name.getLocalPart().equals("header"))
{
setBodyType(unkElement.getElement().getAttribute("use"), bEntry, operation, input);
String partName = unkElement.getElement().getAttribute("part");
bEntry.setHeaderPart(operation.getName(), partName, null,
input ? BindingEntry.IN_HEADER : BindingEntry.OUT_HEADER);
NodeList headerFaults = unkElement.getElement().getChildNodes();
for (int i = 0; i < headerFaults.getLength(); i++)
{
String faultMessage = unkElement.getElement().getAttribute("message");
String faultPart = unkElement.getElement().getAttribute("part");
String faultUse = unkElement.getElement().getAttribute("use");
String faultNamespaceURI = unkElement.getElement().getAttribute("namespace");
QName faultMessageQName = null;
int sep = faultMessage.indexOf(':');
if (sep == -1)
{
faultMessageQName = new QName(faultMessage);
}
else
{
faultMessageQName = new QName(faultMessage.substring(0, sep), faultMessage.substring(sep + 1));
}
faults.add(new FaultInfo(faultMessageQName, faultPart, faultUse, faultNamespaceURI, this));
}
}
}
}
}
private void fillInDIMEInformation(UnknownExtensibilityElement unkElement, boolean input, Operation operation, BindingEntry bEntry)
{
String layout = unkElement.getElement().getAttribute("layout");
if (layout.equals(Constants.URI_DIME_CLOSED_LAYOUT))
{
}
else if (layout.equals(Constants.URI_DIME_OPEN_LAYOUT))
{
}
Map parts = null;
if (input)
{
parts = operation.getInput().getMessage().getParts();
}
else
{
parts = operation.getOutput().getMessage().getParts();
}
if (parts != null)
{
Iterator iterator = parts.values().iterator();
while (iterator.hasNext())
{
Part part = (Part)iterator.next();
if (part != null)
{
String dims = "";
org.w3c.dom.Element element = null;
if (part.getTypeName() != null)
{
TypeEntry partType = getType(part.getTypeName());
if (partType.getDimensions().length() > 0)
{
dims = partType.getDimensions();
partType = partType.getRefType();
}
element = (org.w3c.dom.Element)partType.getNode();
}
else if (part.getElementName() != null)
{
TypeEntry partElement = getElement(part.getElementName()).getRefType();
element = (org.w3c.dom.Element)partElement.getNode();
QName name = getInnerCollectionComponentQName(element);
if (name != null)
{
dims += "[]";
partElement = getType(name);
element = (org.w3c.dom.Element)partElement.getNode();
}
else
{
name = getInnerTypeQName(element);
if (name != null)
{
partElement = getType(name);
element = (org.w3c.dom.Element)partElement.getNode();
}
}
}
if (element != null)
{
org.w3c.dom.Element e = (org.w3c.dom.Element)XMLUtils.findNode(element, new QName(Constants.URI_DIME_CONTENT, "mediaType"));
if (e != null)
{
String value = e.getAttribute("value");
bEntry.setOperationDIME(operation.getName());
bEntry.setMIMEInfo(operation.getName(), part.getName(), value, dims);
}
}
}
}
}
}
private void faultsFromSOAPFault(Binding binding, BindingOperation bindOp,
Operation operation, ArrayList faults) throws IOException
{
Iterator faultMapIter = bindOp.getBindingFaults().values().iterator();
for (; faultMapIter.hasNext();)
{
BindingFault bFault = (BindingFault)faultMapIter.next();
String faultName = bFault.getName();
if (faultName == null || faultName.length() == 0)
{
throw new IOException(Messages.getMessage("unNamedFault00",
bindOp.getName(),
binding.getQName().toString()));
}
boolean foundSOAPFault = false;
String soapFaultUse = "";
String soapFaultNamespace = "";
Iterator faultIter = bFault.getExtensibilityElements().iterator();
for (; faultIter.hasNext();)
{
Object obj = faultIter.next();
if (obj instanceof SOAPFault)
{
foundSOAPFault = true;
soapFaultUse = ((SOAPFault)obj).getUse();
soapFaultNamespace = ((SOAPFault)obj).getNamespaceURI();
break;
}
else if (obj instanceof UnknownExtensibilityElement)
{
UnknownExtensibilityElement unkElement = (UnknownExtensibilityElement)obj;
QName name = unkElement.getElementType();
if (name.getNamespaceURI().equals(Constants.URI_WSDL12_SOAP) &&
name.getLocalPart().equals("fault"))
{
if (unkElement.getElement().getAttribute("use") != null)
{
soapFaultUse = unkElement.getElement().getAttribute("use");
}
if (unkElement.getElement().getAttribute("namespace") != null)
{
soapFaultNamespace = unkElement.getElement().getAttribute("namespace");
}
}
}
}
if (!foundSOAPFault)
{
throw new IOException(Messages.getMessage("missingSoapFault00",
faultName,
bindOp.getName(),
binding.getQName().toString()));
}
Fault opFault = operation.getFault(bFault.getName());
if (opFault == null)
{
throw new IOException(Messages.getMessage("noPortTypeFault",
new String[]{bFault.getName(),
bindOp.getName(),
binding.getQName().toString()}));
}
faults.add(new FaultInfo(opFault,
Use.getUse(soapFaultUse),
soapFaultNamespace,
this));
}
}
private void setBodyType(String use, BindingEntry bEntry,
Operation operation, boolean input)
{
if (use == null)
{
use = "literal"; }
if (use.equalsIgnoreCase("literal"))
{
bEntry.setBodyType(operation, Use.LITERAL,
input);
}
}
private Use addMIMETypes(BindingEntry bEntry, MIMEMultipartRelated mpr,
Operation op) throws IOException
{
Use bodyType = Use.ENCODED;
List parts = mpr.getMIMEParts();
Iterator i = parts.iterator();
while (i.hasNext())
{
MIMEPart part = (MIMEPart)i.next();
List elems = part.getExtensibilityElements();
Iterator j = elems.iterator();
while (j.hasNext())
{
Object obj = j.next();
if (obj instanceof MIMEContent)
{
MIMEContent content = (MIMEContent)obj;
TypeEntry typeEntry = findPart(op, content.getPart());
String dims = typeEntry.getDimensions();
if (dims.length() <= 0 && typeEntry.getRefType() != null)
{
Node node = typeEntry.getRefType().getNode();
if (getInnerCollectionComponentQName(node) != null)
dims += "[]";
}
String type = content.getType();
if (type == null || type.length() == 0)
type = "text/plain";
bEntry.setMIMEInfo(op.getName(), content.getPart(), type, dims);
}
else if (obj instanceof SOAPBody)
{
String use = ((SOAPBody)obj).getUse();
if (use == null)
{
use = "literal";
}
if (use.equalsIgnoreCase("literal"))
{
bodyType = Use.LITERAL;
}
}
else if (obj instanceof UnknownExtensibilityElement)
{
UnknownExtensibilityElement unkElement = (UnknownExtensibilityElement)obj;
QName name = unkElement.getElementType();
if (name.getNamespaceURI().equals(Constants.URI_WSDL12_SOAP) &&
name.getLocalPart().equals("body"))
{
String use = unkElement.getElement().getAttribute("use");
if (use == null)
{
use = "literal";
}
if (use.equalsIgnoreCase("literal"))
{
bodyType = Use.LITERAL;
}
}
}
}
}
return bodyType;
}
private TypeEntry findPart(Operation operation, String partName)
{
Map parts = operation.getInput().getMessage().getParts();
Iterator iterator = parts.values().iterator();
TypeEntry part = findPart(iterator, partName);
if (part == null)
{
parts = operation.getOutput().getMessage().getParts();
iterator = parts.values().iterator();
part = findPart(iterator, partName);
}
return part;
}
private TypeEntry findPart(Iterator iterator, String partName)
{
while (iterator.hasNext())
{
Part part = (Part)iterator.next();
if (part != null)
{
String typeName = part.getName();
if (partName.equals(typeName))
{
if (part.getTypeName() != null)
{
return getType(part.getTypeName());
}
else if (part.getElementName() != null)
{
return getElement(part.getElementName());
}
}
}
}
return null;
}
private void populateServices(Definition def) throws IOException
{
Iterator i = def.getServices().values().iterator();
while (i.hasNext())
{
Service service = (Service)i.next();
if (service.getQName() == null ||
service.getQName().getLocalPart() == null ||
service.getQName().getLocalPart().equals(""))
{
throw new IOException(Messages.getMessage("BadServiceName00"));
}
ServiceEntry sEntry = new ServiceEntry(service);
symbolTablePut(sEntry);
populatePorts(service.getPorts());
}
}
private void populatePorts(Map ports) throws IOException
{
if (ports == null) return;
Iterator it = ports.values().iterator();
while (it.hasNext())
{
Port port = (Port)it.next();
String portName = port.getName();
Binding portBinding = port.getBinding();
if (portName == null)
{
throw new IOException(Messages.getMessage("missingPortNameException"));
}
if (portBinding == null)
{
throw new IOException(Messages.getMessage("missingBindingException"));
}
if (existsPortWithName(new QName(portName)))
{
throw new IOException(Messages.getMessage("twoPortsWithSameName", portName));
}
PortEntry portEntry = new PortEntry(port);
symbolTablePut(portEntry);
}
}
private void setReferences(Definition def, Document doc)
{
Map stuff = def.getServices();
if (stuff.isEmpty())
{
stuff = def.getBindings();
if (stuff.isEmpty())
{
stuff = def.getPortTypes();
if (stuff.isEmpty())
{
stuff = def.getMessages();
if (stuff.isEmpty())
{
for (Iterator i = elementTypeEntries.values().iterator();
i.hasNext();)
{
setTypeReferences((TypeEntry)i.next(), doc, false);
}
for (Iterator i = typeTypeEntries.values().iterator();
i.hasNext();)
{
setTypeReferences((TypeEntry)i.next(), doc, false);
}
}
else
{
Iterator i = stuff.values().iterator();
while (i.hasNext())
{
Message message = (Message)i.next();
MessageEntry mEntry =
getMessageEntry(message.getQName());
setMessageReferences(mEntry, def, doc, false);
}
}
}
else
{
Iterator i = stuff.values().iterator();
while (i.hasNext())
{
PortType portType = (PortType)i.next();
PortTypeEntry ptEntry =
getPortTypeEntry(portType.getQName());
setPortTypeReferences(ptEntry, null, def, doc);
}
}
}
else
{
Iterator i = stuff.values().iterator();
while (i.hasNext())
{
Binding binding = (Binding)i.next();
BindingEntry bEntry = getBindingEntry(binding.getQName());
setBindingReferences(bEntry, def, doc);
}
}
}
else
{
Iterator i = stuff.values().iterator();
while (i.hasNext())
{
Service service = (Service)i.next();
ServiceEntry sEntry = getServiceEntry(service.getQName());
setServiceReferences(sEntry, def, doc);
}
}
}
private void setTypeReferences(TypeEntry entry, Document doc,
boolean literal)
{
if ((entry.isReferenced() && !literal) ||
(entry.isOnlyLiteralReferenced() && literal))
{
return;
}
if (wrapped)
{
if (!entry.isReferenced() && literal)
{
entry.setOnlyLiteralReference(true);
}
else if (entry.isOnlyLiteralReferenced() && !literal)
{
entry.setOnlyLiteralReference(false);
}
}
Node node = entry.getNode();
if (addImports || node == null || node.getOwnerDocument() == doc)
{
entry.setIsReferenced(true);
if (entry instanceof DefinedElement)
{
BooleanHolder forElement = new BooleanHolder();
QName referentName = Utils.getTypeQName(node, forElement, false);
if (referentName != null)
{
TypeEntry referent = getTypeEntry(referentName, forElement.value);
if (referent != null)
{
setTypeReferences(referent, doc, literal);
}
}
QName anonQName = SchemaUtils.getElementAnonQName(entry.getNode());
if (anonQName != null)
{
TypeEntry anonType = getType(anonQName);
if (anonType != null)
{
setTypeReferences(anonType, doc, literal);
return;
}
}
}
}
HashSet nestedTypes = Utils.getNestedTypes(entry, this, true);
Iterator it = nestedTypes.iterator();
while (it.hasNext())
{
TypeEntry nestedType = (TypeEntry)it.next();
if (!nestedType.isReferenced())
{
if (nestedType != entry)
setTypeReferences(nestedType, doc, false);
}
}
}
private void setMessageReferences(MessageEntry entry, Definition def, Document doc, boolean literal)
{
Message message = entry.getMessage();
if (addImports)
{
entry.setIsReferenced(true);
}
else
{
Map messages = def.getMessages();
if (messages.containsValue(message))
{
entry.setIsReferenced(true);
}
}
Iterator parts = message.getParts().values().iterator();
while (parts.hasNext())
{
Part part = (Part)parts.next();
TypeEntry type = getType(part.getTypeName());
if (type != null)
{
setTypeReferences(type, doc, literal);
}
type = getElement(part.getElementName());
if (type != null)
{
setTypeReferences(type, doc, literal);
TypeEntry refType = type.getRefType();
if (refType != null)
{
setTypeReferences(refType, doc, literal);
}
}
}
}
private void setPortTypeReferences(PortTypeEntry entry, BindingEntry bEntry,
Definition def, Document doc)
{
PortType portType = entry.getPortType();
if (addImports)
{
entry.setIsReferenced(true);
}
else
{
Map portTypes = def.getPortTypes();
if (portTypes.containsValue(portType))
{
entry.setIsReferenced(true);
}
}
Iterator operations = portType.getOperations().iterator();
while (operations.hasNext())
{
Operation operation = (Operation)operations.next();
Input input = operation.getInput();
Output output = operation.getOutput();
boolean literalInput = false;
boolean literalOutput = false;
if (bEntry != null)
{
literalInput = bEntry.getInputBodyType(operation) ==
Use.LITERAL;
literalOutput = bEntry.getOutputBodyType(operation) ==
Use.LITERAL;
}
if (input != null)
{
Message message = input.getMessage();
if (message != null)
{
MessageEntry mEntry = getMessageEntry(message.getQName());
if (mEntry != null)
{
setMessageReferences(mEntry, def, doc, literalInput);
}
}
}
if (output != null)
{
Message message = output.getMessage();
if (message != null)
{
MessageEntry mEntry = getMessageEntry(message.getQName());
if (mEntry != null)
{
setMessageReferences(mEntry, def, doc, literalOutput);
}
}
}
Iterator faults =
operation.getFaults().values().iterator();
while (faults.hasNext())
{
Message message = ((Fault)faults.next()).getMessage();
if (message != null)
{
MessageEntry mEntry = getMessageEntry(message.getQName());
if (mEntry != null)
{
setMessageReferences(mEntry, def, doc, false);
}
}
}
}
}
private void setBindingReferences(BindingEntry entry, Definition def, Document doc)
{
if (entry.getBindingType() == BindingEntry.TYPE_SOAP)
{
Binding binding = entry.getBinding();
if (addImports)
{
entry.setIsReferenced(true);
}
else
{
Map bindings = def.getBindings();
if (bindings.containsValue(binding))
{
entry.setIsReferenced(true);
}
}
PortType portType = binding.getPortType();
PortTypeEntry ptEntry = getPortTypeEntry(portType.getQName());
if (ptEntry != null)
{
setPortTypeReferences(ptEntry, entry, def, doc);
}
}
}
private void setServiceReferences(ServiceEntry entry, Definition def, Document doc)
{
Service service = entry.getService();
if (addImports)
{
entry.setIsReferenced(true);
}
else
{
Map services = def.getServices();
if (services.containsValue(service))
{
entry.setIsReferenced(true);
}
}
Iterator ports = service.getPorts().values().iterator();
while (ports.hasNext())
{
Port port = (Port)ports.next();
Binding binding = port.getBinding();
if (binding != null)
{
BindingEntry bEntry = getBindingEntry(binding.getQName());
if (bEntry != null)
{
setBindingReferences(bEntry, def, doc);
}
}
}
}
private void symbolTablePut(SymTabEntry entry) throws IOException
{
QName name = entry.getQName();
if (get(name, entry.getClass()) == null)
{
if (entry instanceof Type &&
get(name, UndefinedType.class) != null)
{
if (((TypeEntry)get(name, UndefinedType.class)).isSimpleType() &&
!((TypeEntry)entry).isSimpleType())
{
throw new IOException(Messages.getMessage("AttrNotSimpleType01",
name.toString()));
}
Vector v = (Vector)symbolTable.get(name);
for (int i = 0; i < v.size(); ++i)
{
Object oldEntry = v.elementAt(i);
if (oldEntry instanceof UndefinedType)
{
v.setElementAt(entry, i);
typeTypeEntries.put(name, entry);
((UndefinedType)oldEntry).update((Type)entry);
}
}
}
else if (entry instanceof Element &&
get(name, UndefinedElement.class) != null)
{
Vector v = (Vector)symbolTable.get(name);
for (int i = 0; i < v.size(); ++i)
{
Object oldEntry = v.elementAt(i);
if (oldEntry instanceof UndefinedElement)
{
v.setElementAt(entry, i);
elementTypeEntries.put(name, entry);
((Undefined)oldEntry).update((Element)entry);
}
}
}
else
{
Vector v = (Vector)symbolTable.get(name);
if (v == null)
{
v = new Vector();
symbolTable.put(name, v);
}
v.add(entry);
if (entry instanceof Element)
{
elementTypeEntries.put(name, entry);
}
else if (entry instanceof Type)
{
typeTypeEntries.put(name, entry);
}
}
}
else
{
System.out.println(Messages.getMessage("alreadyExists00", "" + name));
}
}
protected boolean existsPortWithName(QName name)
{
Vector v = (Vector)symbolTable.get(name);
if (v == null) return false;
Iterator it = v.iterator();
while (it.hasNext())
{
Object o = it.next();
if (o instanceof PortEntry) return true;
}
return false;
}
private static QName getInnerCollectionComponentQName(Node node)
{
if (node == null)
{
return null;
}
QName name = SchemaUtils.getCollectionComponentQName(node);
if (name != null)
return name;
NodeList children = node.getChildNodes();
for (int i = 0; i < children.getLength(); i++)
{
name = getInnerCollectionComponentQName(children.item(i));
if (name != null)
return name;
}
return null;
}
private static QName getInnerTypeQName(Node node)
{
if (node == null)
{
return null;
}
BooleanHolder forElement = new BooleanHolder();
QName name = Utils.getTypeQName(node, forElement, true);
if (name != null)
return name;
NodeList children = node.getChildNodes();
for (int i = 0; i < children.getLength(); i++)
{
name = getInnerTypeQName(children.item(i));
if (name != null)
return name;
}
return null;
}
}