/*******************************************************************************
* Copyright (c) 2005 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.bpel.model.util;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import javax.xml.namespace.QName;
import org.eclipse.bpel.model.messageproperties.MessagepropertiesPackage;
import org.eclipse.bpel.model.messageproperties.Property;
import org.eclipse.bpel.model.partnerlinktype.PartnerLinkType;
import org.eclipse.bpel.model.partnerlinktype.PartnerlinktypePackage;
import org.eclipse.bpel.model.partnerlinktype.Role;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.wst.wsdl.Definition;
import org.eclipse.wst.wsdl.Message;
import org.eclipse.wst.wsdl.Operation;
import org.eclipse.wst.wsdl.Part;
import org.eclipse.wst.wsdl.PortType;
import org.eclipse.wst.wsdl.Service;
import org.eclipse.wst.wsdl.Types;
import org.eclipse.wst.wsdl.WSDLPackage;
import org.eclipse.wst.wsdl.XSDSchemaExtensibilityElement;
import org.eclipse.wst.wsdl.internal.impl.ImportImpl;
import org.eclipse.xsd.XSDElementDeclaration;
import org.eclipse.xsd.XSDPackage;
import org.eclipse.xsd.XSDSchema;
import org.eclipse.xsd.XSDTypeDefinition;
import org.eclipse.xsd.impl.XSDSchemaImpl;
import org.eclipse.xsd.util.XSDConstants;
/**
* WSDLUtil supplies resolution (lookup) of various things that are useful in the BPEL
* world.
*
*/
public class WSDLUtil
{
/** The WSDL Message attribute/name, most likely "message" */
public static final String WSDL_MESSAGE = WSDLPackage.eINSTANCE.getMessage().getName();
/** The WSDL Port Type attribute/name, most likely "portType" */
public static final String WSDL_PORT_TYPE = WSDLPackage.eINSTANCE.getPortType().getName();
/** The WSDL Operation attribute/name, most likely "operation" */
public static final String WSDL_OPERATION = WSDLPackage.eINSTANCE.getOperation().getName();
/** The WSDL Part attribute/name, most likely "part" */
public static final String WSDL_PART = WSDLPackage.eINSTANCE.getPart().getName();
/** The WSDL Service attribute/name, most likely "service" */
public static final String WSDL_SERVICE = WSDLPackage.eINSTANCE.getService().getName();
/** The XSD Type Definition attribute/name, most likely "type" */
public static final String XSD_TYPE_DEFINITION = XSDPackage.eINSTANCE.getXSDTypeDefinition().getName();
/** The XSD Element Declaration attribute/name, most likely "element" */
public static final String XSD_ELEMENT_DECLARATION = XSDPackage.eINSTANCE.getXSDElementDeclaration().getName();
/** The BPEL Partner Link Type attribute/name, most likely "partnerLinkType" */
public static final String BPEL_PARTNER_LINK_TYPE = PartnerlinktypePackage.eINSTANCE.getPartnerLinkType().getName();
/** The BPEL Role attribute/name, most likely "role" */
public static final String BPEL_ROLE = PartnerlinktypePackage.eINSTANCE.getRole().getName();
/** The BPEL Property attribute/name, most likely "property" */
public static final String BPEL_PROPERTY = MessagepropertiesPackage.eINSTANCE.getProperty().getName();
/** This should be a preference that can be easily turned on/off */
private static boolean RESOLVING_DEEPLY = true; // TODO: Preference based ?
/**
* Answer true if the type name passed is a WSDL thing.
*
* @param typeName
* @return true if yes, false if no.
*/
public static boolean isWSDLType(String typeName)
{
return typeName == null ? false :
WSDL_MESSAGE.equals(typeName)
|| WSDL_PORT_TYPE.equals(typeName)
|| WSDL_OPERATION.equals(typeName)
|| WSDL_PART.equals(typeName)
|| WSDL_SERVICE.equals(typeName)
|| XSD_TYPE_DEFINITION.equals(typeName)
|| XSD_ELEMENT_DECLARATION.equals(typeName)
|| BPEL_PARTNER_LINK_TYPE.equals(typeName)
|| BPEL_ROLE.equals(typeName)
|| BPEL_PROPERTY.equals(typeName);
}
/**
* Set to resolve deeply.
* @param resolveDeeply
*/
public static void setResolveDeeply ( boolean resolveDeeply ) {
RESOLVING_DEEPLY = resolveDeeply;
}
/**
* Answer if resolving deeply.
* @return answer true if resolving deeply, false otherwise.
*/
public static boolean isResolvingDeeply () {
return RESOLVING_DEEPLY;
}
/**
* Resolve with the given definition the QName given.
* @param definition the definition to use.
* @param qname the QName to resolve.
* @param name
* @param refType what to resolve (that things from WSDL that we can resolve).
* @return the EMF object that the QName resolves to.
*/
public static EObject resolveWSDLReference(Definition definition, QName qname, String name, String refType)
{
EObject resolvedObject = null;
if (WSDL_PORT_TYPE.equals(refType)) {
resolvedObject = resolvePortType(definition, qname);
} else if (WSDL_MESSAGE.equals(refType)) {
resolvedObject = resolveMessage(definition, qname);
} else if (WSDL_OPERATION.equals(refType)) {
resolvedObject = resolveOperation(definition, qname, name);
} else if (WSDL_PART.equals(refType)) {
resolvedObject = resolvePart(definition, qname, name);
} else if (WSDL_SERVICE.equals(refType)) {
resolvedObject = resolveService(definition, qname);
} else if (XSD_TYPE_DEFINITION.equals(refType)) {
resolvedObject = resolveXSDTypeDefinition(definition, qname);
} else if (XSD_ELEMENT_DECLARATION.equals(refType)) {
resolvedObject = resolveXSDElementDeclaration(definition, qname);
} else if (BPEL_PARTNER_LINK_TYPE.equals(refType)) {
resolvedObject = resolveBPELPartnerLinkType(definition, qname);
} else if (BPEL_ROLE.equals(refType)) {
resolvedObject = resolveBPELRole(definition, qname, name);
} else if (BPEL_PROPERTY.equals(refType)) {
resolvedObject = resolveBPELProperty(definition, qname);
} else {
System.err.println(WSDLUtil.class.getName() + ": unrecognized refType: " + refType); //$NON-NLS-1$
}
return resolvedObject;
}
/**
* Use Java generics to write the "finders" of various elements, so that the general code
* which does the lookups and follows imports does not need to be repeated.
*
* @author Michal Chmielewski (michal.chmielewski@oracle.com)
* @date Feb 27, 2007
*
* @param <T> the type that we are looking up (PortType, Message, PartnerLinkType)
*/
interface Finder<S,T> {
/**
* Find the thing in the container
*
* @param source the source where to look (definition, schema)
* @param qname the QName to lookup
* @return the resolved entity, or null
*/
T find (S source, QName qname);
}
/** Generic way of looking up port types */
static final Finder<Definition,PortType> PORT_TYPE_FINDER = new Finder<Definition, PortType>() {
@Override
public PortType find (Definition defn, QName qname) {
return (PortType) defn.getPortType(qname) ;
}
};
/** Generic way of looking up messages */
static final Finder<Definition,Message> MESSAGE_FINDER = new Finder<Definition,Message> () {
@Override
public Message find (Definition defn, QName qname) {
return (Message) defn.getMessage(qname);
}
};
/** Generic way of looking up partner link types */
static final Finder<Definition,PartnerLinkType> PARTNER_LINK_TYPE_FINDER = new Finder<Definition,PartnerLinkType>() {
@Override
public PartnerLinkType find (Definition defn, QName qname) {
if (defn.getTargetNamespace() == null)
return null;
if (defn.getTargetNamespace().equals(qname.getNamespaceURI()) == false) {
return null;
}
Iterator<?> it = defn.getExtensibilityElements().iterator();
while (it.hasNext()) {
Object e = it.next();
if (e instanceof PartnerLinkType) {
PartnerLinkType plt = (PartnerLinkType) e;
if (plt.getName().equals(qname.getLocalPart())) {
return plt;
}
}
}
return null;
}
};
/** Generic way of lookup up BPEL properties */
static final Finder<Definition,Property> PROPERTY_FINDER = new Finder<Definition,Property>() {
@Override
public Property find(Definition defn, QName qname) {
if (defn.getTargetNamespace().equals(qname.getNamespaceURI()) == false) {
return null;
}
Iterator<?> it = defn.getExtensibilityElements().iterator();
while (it.hasNext()) {
Object e = it.next();
if (e instanceof Property) {
Property property = (Property) e;
if (property.getName().equals(qname.getLocalPart())) {
return property;
}
}
}
return null;
}
};
/** Type definition finder */
static private final Finder<XSDSchema,XSDTypeDefinition> TYPE_DEFINITION_FINDER = new Finder<XSDSchema,XSDTypeDefinition>() {
@Override
public XSDTypeDefinition find(XSDSchema schema, QName typeName) {
// Perhaps this is what we want ...
// http://www.eclipse.org/modeling/emf/faq/#dev20040602-1383194195
//
XSDTypeDefinition typeDef = schema.resolveTypeDefinition(typeName.getNamespaceURI(), typeName.getLocalPart());
if (typeDef.getContainer() == null) {
return null;
}
return typeDef;
}
};
/** Element declaration finder */
static private final Finder<XSDSchema,XSDElementDeclaration> ELEMENT_DECLARATION_FINDER = new Finder<XSDSchema,XSDElementDeclaration> () {
@Override
public XSDElementDeclaration find(XSDSchema schema, QName qn) {
XSDElementDeclaration decl = schema.resolveElementDeclaration( qn.getNamespaceURI(), qn.getLocalPart());
// TODO: (Hack)
// Why has this started returning instances of XSDElementDeclrarion that are not proxies or null
// if the element declaration is missing in the schema ?
// Perhaps this is what we want: http://www.eclipse.org/modeling/emf/faq/#dev20040602-1383194195
if (decl.getContainer() == null) {
return null;
}
return decl;
}
};
/**
* Resolve the port type in the definition given.
*
* @param definition the WSDL definition
* @param qname the QName of the portType
* @return the resolved portType, or null
*/
public static PortType resolvePortType (Definition definition, QName qname)
{
return resolveUsingFinder ( definition, qname, PORT_TYPE_FINDER, new HashSet<Definition>() );
}
/**
* Resolve using finder resolves the QName in the definitions passed. The return object
* extends from EObject (so PortType, Message, PartnerLinkType, etc). The finder has the actual lookup
* code while the general code flow that deals with following the imports is shared among the lookup
* methods in this class.
*
* @param <T> the type
* @param defn the definition to use as the lookup
* @param qname the QName to lookup
* @param finder the finder to use.
* @param seen the seen set
* @return the object to be resolved.
*/
@SuppressWarnings("restriction")
static <T extends EObject> T resolveUsingFinder ( Definition defn, QName qname, Finder<Definition,T> finder , Set<Definition> seen) {
if (seen.contains(defn)) {
return null;
}
seen.add(defn);
T result = finder.find ( defn, qname );
if (result != null || RESOLVING_DEEPLY == false) {
return result;
}
Iterator<?> it = defn.getImports(qname.getNamespaceURI()).iterator();
while (it.hasNext() && result == null) {
ImportImpl imp = (ImportImpl) it.next();
imp.importDefinitionOrSchema();
Definition importedDefinition = (Definition) imp.getDefinition();
if (importedDefinition != null) {
result = resolveUsingFinder (importedDefinition, qname, finder, seen );
}
}
return result;
}
/**
* Resolve the message name in the definitions passed.
* @param definition the definitions
* @param qname the message name
* @return the message name or null
*/
public static Message resolveMessage(Definition definition, QName qname)
{
return resolveUsingFinder(definition, qname, MESSAGE_FINDER, new HashSet<Definition>());
}
/**
* Resolve operation within a portType. First lookup portType, then find the operation by name given.
* @param definition the definition to search
* @param portTypeQName QName of the portType to lookup operation on
* @param operationName the operation name.
* @return the operation or null
*/
public static Operation resolveOperation(Definition definition, QName portTypeQName, String operationName)
{
PortType portType = resolvePortType(definition, portTypeQName);
return findOperation(portType, operationName);
}
/**
* Resolve the part within a message.
* @param definition the definition to use
* @param qname QName of the message
* @param name the name of the message part.
* @return the part, or null
*/
public static Part resolvePart(Definition definition, QName qname, String name)
{
return findPart( resolveMessage(definition, qname) , name );
}
/**
* Resolve (lookup) a partner link type in the definitions given.
* @param defn the definitions to use
* @param qname the QName to lookup
* @return the partner link type or null
*/
public static PartnerLinkType resolveBPELPartnerLinkType(Definition defn, QName qname)
{
return resolveUsingFinder(defn, qname, PARTNER_LINK_TYPE_FINDER, new HashSet<Definition>() );
}
/**
* Resolve BPEL Role on the partner link specified.
*
* @param definition the definition to use
* @param qname QNAme of the partner link type
* @param name the name of the role on that partner link type
* @return the BPEL role, or null
*/
public static EObject resolveBPELRole(Definition definition, QName qname, String name)
{
return findRole ( resolveBPELPartnerLinkType(definition, qname) , name );
}
/**
* Lookup the BPEL property in the definition given.
*
* @param defn the definition
* @param qname the property QName to lookup
* @return the property or null
*/
public static Property resolveBPELProperty(Definition defn, QName qname)
{
return resolveUsingFinder(defn, qname, PROPERTY_FINDER, new HashSet<Definition>());
}
private static Service resolveService(Definition definition, QName qname) {
return (Service) definition.getService(qname);
}
/**
* Common code for resolving XSDTypeDefinitions and XSDElementDeclarations
*/
@SuppressWarnings("restriction")
static <T> T resolveXSD (Definition definition, QName qname, Finder<XSDSchema,T> finder, Set<Definition> seen )
{
T result = null;
if (seen.contains(definition)) {
return result;
}
seen.add(definition);
// Check for built-in types
// TODO Slightly inefficient to evaluate this when recursing
XSDSchema schema = null;
String namespace = qname.getNamespaceURI();
if ("".equals(namespace)) { //$NON-NLS-1$
namespace = null;
}
if (XSDConstants.isSchemaForSchemaNamespace(namespace)) {
schema = XSDSchemaImpl.getSchemaForSchema(namespace);
} else if (XSDConstants.isSchemaInstanceNamespace(namespace)) {
schema = XSDSchemaImpl.getSchemaInstance(namespace);
}
if (schema != null) {
result = finder.find(schema, qname);
if (result != null) {
return result;
}
}
// Check in-line schema
Types types = definition.getETypes();
if (types != null) {
Iterator<?> it = types.getExtensibilityElements().iterator();
while (it.hasNext()) {
Object e = it.next();
if (e instanceof XSDSchemaExtensibilityElement == false) {
continue;
}
XSDSchemaExtensibilityElement schemaEE = (XSDSchemaExtensibilityElement) e;
schema = schemaEE.getSchema();
if (schema != null) {
result = finder.find(schema, qname);
if (result != null)
return result;
}
}
}
/**
* Check imported schemas and definitions.
* If we are here, then result is still null
*/
// TODO: I think I need to check all imports, not just those
// matching the same namespace...
Iterator<?> it = definition.getImports(qname.getNamespaceURI()).iterator();
while (it.hasNext()) {
ImportImpl imp = (ImportImpl) it.next();
imp.importDefinitionOrSchema();
schema = imp.getESchema();
if (schema != null) {
result = finder.find(schema, qname);
if (result != null)
return result;
}
Definition importedDefinition = imp.getEDefinition();
if (importedDefinition != null) {
result = resolveXSD(importedDefinition, qname, finder, seen );
if (result != null) {
return result;
}
}
}
return result;
}
/**
* Resolve type definition. Basically lookup type by QName.
*
* @param definition
* @param qname
* @return the XSDTypeDefinition found or null if it does not exist.
*/
public static XSDTypeDefinition resolveXSDTypeDefinition(Definition definition, QName qname)
{
return resolveXSD(definition, qname ,TYPE_DEFINITION_FINDER, new HashSet<Definition>() );
}
/**
* Resolve the XSDElement declaration in this definition. Basically, lookup element declaration using the
* QName specified in the definition indicated.
*
* @param definition
* @param qname
* @return the XSDElement declaration if found. null otherwise.
*/
public static XSDElementDeclaration resolveXSDElementDeclaration(Definition definition, QName qname)
{
return resolveXSD(definition, qname, ELEMENT_DECLARATION_FINDER, new HashSet<Definition>() );
}
/**
* Find a role in the partner link type.
* @param plt the partner link type
* @param name the role name to find.
* @return the found role or null if it does not exist.
*/
public static Role findRole ( PartnerLinkType plt, String name ) {
if (plt != null) {
Iterator<Role> it = plt.getRole().iterator();
while (it.hasNext()) {
Role role = it.next();
if (name.equals(role.getName())) {
return role;
}
}
}
return null;
}
/**
* Find the operation in the port type.
* @param portType the port type
* @param operationName the operation name
* @return return the operation in the port type or null
*/
@SuppressWarnings("unchecked")
public static Operation findOperation (PortType portType, String operationName) {
if (portType != null) {
Iterator<Operation> it = portType.getOperations().iterator();
while (it.hasNext()) {
Operation operation = it.next();
if (operation.getName().equals(operationName)) {
return operation;
}
}
}
return null;
}
/**
* Find the message part in the message structure.
* @param message
* @param name
* @return the part or null
*/
public static Part findPart(Message message, String name) {
Part result = null;
if (message != null) {
result = (Part) message.getPart(name);
}
return result;
}
}