| /******************************************************************************* |
| * Copyright (c) 2006 Oracle 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: |
| * Oracle Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.bpel.validator; |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| import javax.xml.XMLConstants; |
| import javax.xml.namespace.QName; |
| |
| import org.eclipse.bpel.model.Import; |
| import org.eclipse.bpel.model.PartnerLink; |
| import org.eclipse.bpel.model.Process; |
| import org.eclipse.bpel.model.Variable; |
| import org.eclipse.bpel.model.partnerlinktype.PartnerLinkType; |
| import org.eclipse.bpel.model.partnerlinktype.Role; |
| import org.eclipse.bpel.model.proxy.MessageProxy; |
| import org.eclipse.bpel.model.proxy.OperationProxy; |
| import org.eclipse.bpel.model.proxy.PartProxy; |
| import org.eclipse.bpel.model.proxy.PartnerLinkTypeProxy; |
| import org.eclipse.bpel.model.proxy.PortTypeProxy; |
| import org.eclipse.bpel.model.proxy.PropertyProxy; |
| import org.eclipse.bpel.model.proxy.RoleProxy; |
| import org.eclipse.bpel.model.proxy.XSDElementDeclarationProxy; |
| import org.eclipse.bpel.model.proxy.XSDTypeDefinitionProxy; |
| import org.eclipse.bpel.model.util.ImportResolver; |
| import org.eclipse.bpel.model.util.ImportResolverRegistry; |
| import org.eclipse.bpel.model.util.WSDLUtil; |
| import org.eclipse.bpel.model.util.XSDComparer; |
| import org.eclipse.bpel.model.util.XSDUtil; |
| import org.eclipse.bpel.validator.factory.AdapterFactory; |
| import org.eclipse.emf.common.util.EList; |
| import org.eclipse.emf.common.util.URI; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.wst.wsdl.Definition; |
| import org.eclipse.wst.wsdl.Fault; |
| import org.eclipse.wst.wsdl.Input; |
| import org.eclipse.wst.wsdl.Message; |
| import org.eclipse.wst.wsdl.Operation; |
| import org.eclipse.wst.wsdl.Output; |
| import org.eclipse.wst.wsdl.Part; |
| import org.eclipse.wst.wsdl.PortType; |
| import org.eclipse.xsd.XSDAttributeDeclaration; |
| import org.eclipse.xsd.XSDComplexTypeDefinition; |
| import org.eclipse.xsd.XSDElementDeclaration; |
| import org.eclipse.xsd.XSDSchema; |
| import org.eclipse.xsd.XSDSimpleTypeDefinition; |
| import org.eclipse.xsd.XSDTypeDefinition; |
| |
| /** |
| * |
| * This class glues the validator code to the EMF model and performs various queries |
| * on the model. |
| * |
| * @author Michal Chmielewski (michal.chmielewski@oracle.com) |
| * @date Dec 13, 2006 |
| * |
| */ |
| |
| @SuppressWarnings("nls") |
| |
| public class EmfModelQuery { |
| |
| static final String CONTEXT_MSG = "The EMF context object object cannot be null"; |
| |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=330813 |
| // https://jira.jboss.org/browse/JBIDE-7351 |
| // we need an instance of this so we can get diagnostics for error reporting |
| XSDComparer xsdComparer; |
| |
| |
| public EmfModelQuery() { |
| xsdComparer = new XSDComparer(); |
| // if debug mode is set in the builder, force XSD comparison |
| xsdComparer.setDebug(AdapterFactory.DEBUG); |
| } |
| |
| public XSDComparer getXSDComparer() { |
| return xsdComparer; |
| } |
| |
| /** |
| * @param eObj |
| * @param qname |
| * @return the partner link type |
| */ |
| |
| public static EObject lookupPartnerLinkType (EObject eObj, QName qname) { |
| |
| EObject top = getRoot ( eObj ); |
| |
| if (top instanceof Definition) { |
| return WSDLUtil.resolveBPELPartnerLinkType((Definition) top, qname); |
| } |
| if (top instanceof Process) { |
| return scanImports ( (Process) top, qname, WSDLUtil.BPEL_PARTNER_LINK_TYPE ); |
| } |
| return null; |
| } |
| |
| /** |
| * @param eObj |
| * @param qname |
| * @return the port type, or null if it cannot be found. |
| */ |
| |
| public static EObject lookupPortType (EObject eObj, QName qname) { |
| |
| EObject top = getRoot ( eObj ); |
| |
| // Look within this definition |
| if (top instanceof Definition) { |
| return WSDLUtil.resolvePortType((Definition) top, qname); |
| } |
| |
| // Look within imports of process |
| if (top instanceof Process) { |
| return scanImports ( (Process) top, qname, WSDLUtil.WSDL_PORT_TYPE ); |
| } |
| return null; |
| } |
| |
| /** |
| * Lookup the XSD type by the QName given. |
| * |
| * @param eObj |
| * @param qname |
| * @return the XSD Type |
| */ |
| |
| public static EObject lookupXSDType (EObject eObj, QName qname) { |
| |
| EObject top = getRoot ( eObj ); |
| |
| // Look within this definition |
| if (top instanceof Definition) { |
| return WSDLUtil.resolveXSDTypeDefinition((Definition) top, qname); |
| } |
| // They could be in a schema as well |
| if (top instanceof XSDSchema) { |
| return XSDUtil.resolveTypeDefinition((XSDSchema) top, qname); |
| } |
| |
| // Look within imports of process |
| if (top instanceof Process) { |
| return scanImports ( (Process) top, qname, XSDUtil.XSD_TYPE_DEFINITION ); |
| } |
| return null; |
| } |
| |
| |
| /** |
| * Lookup message by the QName given. |
| * |
| * @param eObj the the object to query |
| * @param qname |
| * @return the message EOBject |
| */ |
| |
| public static EObject lookupMessage (EObject eObj, QName qname) { |
| |
| EObject top = getRoot ( eObj ); |
| |
| // Look within this definition |
| if (top instanceof Definition) { |
| return WSDLUtil.resolveMessage( (Definition) top, qname); |
| } |
| |
| // Look within imports of process |
| if (top instanceof Process) { |
| return scanImports ( (Process) top, qname, WSDLUtil.WSDL_MESSAGE ); |
| } |
| return null; |
| } |
| |
| |
| /** |
| * |
| * @param eObj the reference context object. |
| * @param qname the QName of the declaration. |
| * @return the XSDElement for for the given name or null if it does not exist |
| */ |
| |
| public static EObject lookupXSDElement(EObject eObj, QName qname) { |
| |
| EObject top = getRoot(eObj); |
| |
| // Look within this definition |
| if (top instanceof Definition) { |
| return WSDLUtil.resolveXSDElementDeclaration((Definition) top, qname); |
| } |
| // They could be in a schema as well |
| if (top instanceof XSDSchema) { |
| return XSDUtil.resolveElementDeclaration((XSDSchema) top, qname); |
| } |
| // Look within imports of process |
| if (top instanceof Process) { |
| return scanImports ( (Process) top, qname, XSDUtil.XSD_ELEMENT_DECLARATION ); |
| } |
| return null; |
| } |
| |
| |
| /** |
| * Since roles are part of a partner link type, the context object in this |
| * case must be the partner link type object. |
| * |
| * @param eObj |
| * @param name |
| * @return the role object. |
| */ |
| |
| |
| @SuppressWarnings("nls") |
| public static EObject lookupRole (EObject eObj, String name) { |
| assertTrue(eObj != null, "Context object cannot be null"); |
| |
| if (eObj instanceof PartnerLink) { |
| eObj = ((PartnerLink)eObj).getPartnerLinkType(); |
| } |
| |
| if (eObj instanceof PartnerLinkType) { |
| return WSDLUtil.findRole ( (PartnerLinkType) eObj , name ); |
| } |
| |
| return null; |
| } |
| |
| |
| |
| /** |
| * |
| * @param eObj the context object. |
| * @param name the name of the operation. |
| * @return the operation or null |
| */ |
| |
| @SuppressWarnings("nls") |
| public static EObject lookupOperation (EObject eObj, String name) { |
| |
| assertTrue(eObj != null, CONTEXT_MSG); |
| |
| // partner link -> partner link type |
| if (eObj instanceof PartnerLink) { |
| eObj = ((PartnerLink) eObj).getPartnerLinkType(); |
| } |
| |
| // if partner link type -> it has to be an operation on one of the roles |
| // |
| if (eObj instanceof PartnerLinkType) { |
| PartnerLinkType plt = (PartnerLinkType) eObj; |
| // This is a bit screwy. The partner link can have potentially 2 roles. |
| for(Object n : plt.getRole()) { |
| Role r = (Role) n; |
| eObj = lookupOperation(r, name); |
| if (eObj != null) { |
| return eObj; |
| } |
| } |
| } |
| |
| if (eObj instanceof Role) { |
| return lookupOperation((Role) eObj, name); |
| } |
| return null; |
| } |
| |
| |
| |
| static EObject lookupOperation (Role role, String name) { |
| |
| // a role has the port type which must have the operation |
| PortType portType = (PortType) role.getPortType(); |
| return WSDLUtil.findOperation(portType,name); |
| } |
| |
| |
| |
| /** |
| * @param eObj |
| * @param qname |
| * @param axis the axis to use |
| * @return the reference to the name step lookup. |
| */ |
| |
| public static EObject lookupNameStep (EObject eObj, QName qname, int axis ) { |
| |
| assertTrue(eObj != null,CONTEXT_MSG); |
| |
| eObj = resolveNameStepContext (eObj); |
| |
| /** |
| * This is the meat of this method. Once we have the element declaration and |
| * type we should be able to ascertain if the QName step passed is correct. |
| */ |
| |
| if (eObj instanceof XSDElementDeclaration) { |
| // This is the case where we may have something like (^^ denotes context) |
| // $foo.payload/tns:bar/tns:foo |
| // ^^^^^^^ |
| XSDElementDeclaration elm = (XSDElementDeclaration) eObj; |
| // check if this step is valid or not |
| eObj = elm.getType(); |
| } |
| |
| eObj = XSDUtils.getEnclosingTypeDefinition(eObj); |
| |
| String localName = qname.getLocalPart(); |
| String nsURI = qname.getNamespaceURI(); |
| |
| // (VZ) FIXME: this condition will always be true. To be reviewed! |
| if (eObj instanceof XSDComplexTypeDefinition) { |
| |
| XSDComplexTypeDefinition type = (XSDComplexTypeDefinition) eObj; |
| |
| // System.out.println("_______ Looking for: " + qname ); |
| // System.out.println("Type: " + type.getName() + "{" + type.getTargetNamespace() + "}"); |
| |
| if (axis == 0) { |
| // Look in the child elements |
| for(Object item : XSDUtils.getChildElements(type)) { |
| XSDElementDeclaration next = (XSDElementDeclaration) item; |
| // System.out.println("Element Declaration: " + next.getName() + "{" + next.getTargetNamespace() + "}"); |
| if (localName.equals( next.getName()) && sameNamespace(nsURI,next.getTargetNamespace())) { |
| return next.getType(); |
| } |
| } |
| } else if (axis == 1) { |
| |
| // Look in attributes |
| for(XSDAttributeDeclaration next : XSDUtils.getChildAttributes( type )) { |
| if (localName.equals( next.getName()) && sameNamespace(nsURI,next.getTargetNamespace())) { |
| return next.getType(); |
| } |
| } |
| |
| } |
| |
| |
| } else if (eObj instanceof XSDSimpleTypeDefinition) { |
| |
| XSDSimpleTypeDefinition type = (XSDSimpleTypeDefinition) eObj; |
| if (localName.equals ( type.getName() ) && sameNamespace(nsURI,type.getTargetNamespace()) ) { |
| return type; |
| } |
| |
| } |
| |
| return null; |
| } |
| |
| |
| |
| static EObject resolveNameStepContext ( EObject eObj ) { |
| |
| if (eObj instanceof Variable) { |
| // This is the case where we may have something like (^^ denotes context) |
| // $foo/tns:bar |
| // ^^^ |
| Variable v = (Variable) eObj; |
| eObj = v.getXSDElement(); |
| if (eObj == null) { |
| eObj = v.getType(); |
| } |
| if (eObj == null) { |
| eObj = v.getMessageType(); |
| } |
| } |
| |
| // WSDL Message |
| if (eObj instanceof Message) { |
| Message msg = (Message) eObj; |
| List<?> parts = msg.getEParts(); |
| if (parts.size() == 1) { |
| eObj = (Part) parts.get(0); |
| } |
| } |
| |
| // Part of a message |
| if (eObj instanceof Part) { |
| // This is the case where we may have something like (^^ denotes context) |
| // $foo.payload/tns:bar |
| // ^^^^^^^ |
| Part part = (Part) eObj; |
| eObj = part.getElementDeclaration(); |
| if (eObj == null) { |
| eObj = part.getTypeDefinition(); |
| } |
| } |
| |
| return eObj; |
| } |
| |
| |
| /** |
| * @param eObj |
| * @param name |
| * @return the message part |
| */ |
| |
| @SuppressWarnings("nls") |
| public static EObject lookupMessagePart (EObject eObj, String name) { |
| assertTrue(eObj != null,CONTEXT_MSG); |
| |
| if (eObj instanceof Variable) { |
| eObj = ((Variable)eObj).getMessageType(); |
| } |
| if (eObj instanceof Message) { |
| return WSDLUtil.findPart( (Message) eObj, name ); |
| } |
| |
| if (eObj instanceof Part) { |
| return eObj; |
| } |
| return null; |
| } |
| |
| |
| /** |
| * Look up the import. Here we lookup the import to get either the schema or |
| * the WSDL definitions. If the context node is Import and the name is |
| * @param eObj the reference object. |
| * @param name |
| * |
| * @return the root of the model represented by this import. |
| */ |
| |
| @SuppressWarnings("nls") |
| public static EObject lookupImport (EObject eObj, String name) { |
| |
| assertTrue( eObj != null, CONTEXT_MSG ); |
| |
| if (eObj instanceof Import) { |
| |
| Import imp = (Import) eObj; |
| |
| for (ImportResolver r : ImportResolverRegistry.INSTANCE.getResolvers(imp.getImportType()) ) { |
| EObject result = r.resolve(imp,null,null,ImportResolver.TOP); |
| if (result != null) { |
| return result; |
| } |
| } |
| } |
| |
| return null; |
| } |
| |
| |
| |
| /** |
| * Get the root element in the resource. |
| * |
| * @param eObj |
| * @return the root object |
| * @see https://issues.jboss.org/browse/JBIDE-8088 - made public |
| */ |
| @SuppressWarnings("nls") |
| public static EObject getRoot ( EObject eObj ) { |
| |
| assertTrue( eObj != null, CONTEXT_MSG ); |
| EObject top = eObj; |
| while( top != null && top.eContainer() != null ) { |
| top = top.eContainer(); |
| } |
| |
| assertTrue( top != null, "The top object cannot be null" ); |
| return top ; |
| } |
| |
| /** |
| * Scan the imports and resolve the items requested. |
| * |
| * @param process |
| * @param qname |
| * @param refType |
| * @return the object resolved by scanning the imports. |
| */ |
| |
| static EObject scanImports ( Process process, QName qname , String refType ) { |
| |
| EObject result = null; |
| |
| for(Object n : process.getImports()) { |
| Import imp = (Import) n; |
| if (imp.getLocation() == null ) { |
| continue; |
| } |
| |
| ImportResolver[] resolvers = ImportResolverRegistry.INSTANCE.getResolvers(imp.getImportType()); |
| for(ImportResolver r : resolvers) { |
| result = r.resolve(imp, qname, null, refType); |
| if (result != null) { |
| return result; |
| } |
| } |
| |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Search all process imports for the given QName reference |
| * |
| * @param process |
| * @param qname |
| * @param refType |
| * @return list of Imports |
| * @see https://issues.jboss.org/browse/JBIDE-8088 - added |
| */ |
| public static List<Import> scanAllImports ( Process process, QName qname , String refType ) { |
| |
| List<Import> imports = new ArrayList<Import>(); |
| EObject result = null; |
| |
| for(Object n : process.getImports()) { |
| Import imp = (Import) n; |
| if (imp.getLocation() == null ) { |
| continue; |
| } |
| |
| ImportResolver[] resolvers = ImportResolverRegistry.INSTANCE.getResolvers(imp.getImportType()); |
| for(ImportResolver r : resolvers) { |
| result = r.resolve(imp, qname, null, refType); |
| if (result != null) { |
| imports.add(imp); |
| } |
| } |
| |
| } |
| |
| return imports; |
| } |
| |
| public static EObject resolveProxy( Process process, EObject obj) { |
| if (obj instanceof MessageProxy) { |
| return scanImports ( process, ((MessageProxy)obj).getQName(), WSDLUtil.WSDL_MESSAGE ); |
| } |
| else if (obj instanceof PortTypeProxy) { |
| return scanImports ( process, ((PortTypeProxy)obj).getQName(), WSDLUtil.WSDL_PORT_TYPE ); |
| } |
| else if (obj instanceof PartnerLinkTypeProxy) { |
| return scanImports ( process, ((PartnerLinkTypeProxy)obj).getQName(), WSDLUtil.BPEL_PARTNER_LINK_TYPE ); |
| } |
| else if (obj instanceof RoleProxy) { |
| return scanImports ( process, ((RoleProxy)obj).getQName(), WSDLUtil.BPEL_ROLE ); |
| } |
| else if (obj instanceof PropertyProxy) { |
| return scanImports ( process, ((PropertyProxy)obj).getQName(), WSDLUtil.BPEL_PROPERTY ); |
| } |
| else if (obj instanceof OperationProxy) { |
| QName qname = new QName(((OperationProxy)obj).getName()); |
| return scanImports ( process, qname, WSDLUtil.WSDL_OPERATION ); |
| } |
| else if (obj instanceof PartProxy) { |
| QName qname = new QName(((PartProxy)obj).getName()); |
| return scanImports ( process, qname, WSDLUtil.WSDL_PART ); |
| } |
| else if (obj instanceof XSDTypeDefinitionProxy) { |
| QName qname = new QName(((XSDTypeDefinitionProxy)obj).getName()); |
| return scanImports ( process, qname, WSDLUtil.XSD_TYPE_DEFINITION ); |
| } |
| else if (obj instanceof XSDElementDeclarationProxy) { |
| QName qname = new QName(((XSDElementDeclarationProxy)obj).getName()); |
| return scanImports ( process, qname, WSDLUtil.XSD_ELEMENT_DECLARATION ); |
| } |
| return obj; |
| } |
| |
| static void assertTrue ( boolean mustBeTrue , String msg ) { |
| if (!mustBeTrue) { |
| throw new RuntimeException( msg ); |
| } |
| } |
| |
| |
| static boolean isEmpty ( String value ) { |
| return value == null || value.length() == 0; |
| } |
| |
| /** |
| * Check compatible partner activity type. |
| * |
| * @param src |
| * @param dst |
| * @return true if compatible, false if not. |
| */ |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=330813 |
| // https://jira.jboss.org/browse/JBIDE-7351 |
| // no longer static because of xsdComparer object |
| public boolean compatiblePartnerActivityMessages (EObject src, EObject dst) { |
| |
| assertTrue(src != null, CONTEXT_MSG); |
| assertTrue(dst != null, CONTEXT_MSG); |
| |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=330813 |
| // https://jira.jboss.org/browse/JBIDE-7116 |
| // quick exit |
| // https://jira.jboss.org/browse/JBIDE-7351 |
| // ...unless we're in debug mode! |
| if (AdapterFactory.DEBUG==false) |
| if (src==dst) |
| return true; |
| |
| Message srcMsg = null; |
| Message dstMsg = null; |
| |
| if (src instanceof Message) { |
| srcMsg = (Message) src; |
| } |
| if (dst instanceof Message) { |
| dstMsg = (Message) dst; |
| } |
| |
| // both messages, and both non null - check if same. |
| if (srcMsg != null && dstMsg != null) { |
| // https://jira.jboss.org/browse/JBIDE-7116 |
| return compatibleType(srcMsg, dstMsg); |
| } |
| |
| // either source OR destination is not a message, check for the XSDElement variant. |
| |
| XSDElementDeclaration srcXSD = null; |
| XSDElementDeclaration dstXSD = null; |
| |
| if (src instanceof XSDElementDeclaration) { |
| srcXSD = (XSDElementDeclaration) src; |
| } |
| if (dst instanceof XSDElementDeclaration) { |
| dstXSD = (XSDElementDeclaration) dst; |
| } |
| |
| // source is XSD element, destination message may have 1 part defined as that element |
| if (srcXSD != null && dstMsg != null) { |
| |
| List<?> parts = dstMsg.getEParts(); |
| if (parts.size() != 1) { |
| return false; |
| } |
| |
| Part part = (Part) parts.get(0); |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=330813 |
| // https://jira.jboss.org/browse/JBIDE-7116 |
| return compatibleType(srcXSD, part.getElementDeclaration()); |
| } |
| |
| // destination is XSD element, source message may have 1 part defined as that element |
| if (dstXSD != null && srcMsg != null) { |
| |
| List<?> parts = srcMsg.getEParts(); |
| if (parts.size() != 1) { |
| return false; |
| } |
| |
| Part part = (Part) parts.get(0); |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=330813 |
| // https://jira.jboss.org/browse/JBIDE-7116 |
| return compatibleType(dstXSD, part.getElementDeclaration()); |
| } |
| |
| // otherwise, incompatible partner activity messages |
| return false; |
| } |
| |
| /** |
| * Lookup property by name. |
| * |
| * @param eObj the reference object |
| * @param qname QName the name of the property |
| * @return the property |
| */ |
| public static EObject lookupProperty(EObject eObj, QName qname) { |
| |
| EObject top = getRoot(eObj); |
| |
| // Look within this definition |
| if (top instanceof Definition) { |
| return WSDLUtil.resolveBPELProperty((Definition) top, qname); |
| } |
| // Look within imports of process |
| if (top instanceof Process) { |
| return scanImports ( (Process) top, qname, WSDLUtil.BPEL_PROPERTY ); |
| } |
| return null; |
| } |
| |
| /** |
| * @param src the source type |
| * @param dst the destination type |
| * @return if the types are compatible, false otherwise |
| */ |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=330813 |
| // https://jira.jboss.org/browse/JBIDE-7351 |
| // no longer static because of xsdComparer object |
| public boolean compatibleType(EObject src, EObject dst) { |
| assertTrue(src != null, CONTEXT_MSG); |
| assertTrue(dst != null, CONTEXT_MSG); |
| |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=330813 |
| // https://jira.jboss.org/browse/JBIDE-7116 |
| // quick exit |
| if (AdapterFactory.DEBUG==false) |
| if (src==dst) |
| return true; |
| |
| Message srcMsg = null; |
| Message dstMsg = null; |
| |
| if (src instanceof Message) { |
| srcMsg = (Message) src; |
| } |
| if (dst instanceof Message) { |
| dstMsg = (Message) dst; |
| } |
| |
| // both messages, and both non null - check if same. |
| if (srcMsg != null && dstMsg != null) { |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=330813 |
| // https://jira.jboss.org/browse/JBIDE-7116 |
| return compatibleType(srcMsg, dstMsg); |
| } |
| |
| // either source OR destination is not a message, check for the XSDElement variant. |
| |
| XSDElementDeclaration srcXSD = null; |
| XSDElementDeclaration dstXSD = null; |
| |
| if (src instanceof XSDElementDeclaration) { |
| srcXSD = (XSDElementDeclaration) src; |
| } |
| if (dst instanceof XSDElementDeclaration) { |
| dstXSD = (XSDElementDeclaration) dst; |
| } |
| |
| if (srcXSD != null && dstXSD != null) { |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=330813 |
| // https://jira.jboss.org/browse/JBIDE-7116 |
| return compatibleType(srcXSD, dstXSD); |
| } |
| |
| XSDTypeDefinition srcType = null; |
| XSDTypeDefinition dstType = null; |
| |
| if (src instanceof XSDTypeDefinition) { |
| srcType = (XSDTypeDefinition) src; |
| } |
| if (dst instanceof XSDTypeDefinition) { |
| dstType = (XSDTypeDefinition) dst; |
| } |
| |
| if (srcType != null && dstType != null) { |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=330813 |
| // https://jira.jboss.org/browse/JBIDE-7116 |
| // https://jira.jboss.org/browse/JBIDE-7351 |
| // use XSDComparer |
| if (xsdComparer.compare(srcType,dstType)) { |
| return true; |
| } |
| |
| // construct a new comparer to prevent the original |
| // diagnostics from being cleared |
| XSDComparer comp = new XSDComparer(); |
| |
| // check if src is derived from dst. |
| // 1) src is NCName, dst is string --> compatible. |
| // 2) reverse is not always true |
| XSDTypeDefinition baseType = srcType.getBaseType(); |
| do { |
| // System.out.println("Checking: " + dstType + " against baseType: " + baseType); |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=330813 |
| // https://jira.jboss.org/browse/JBIDE-7116 |
| if (comp.compare(baseType,dstType)) { |
| return true; |
| } |
| baseType = baseType.getBaseType(); |
| } while (baseType!=baseType.getBaseType()); |
| |
| return false; |
| } |
| |
| PortType srcPort = null; |
| PortType dstPort = null; |
| if (src instanceof PortType) |
| srcPort = (PortType)src; |
| if (dst instanceof PortType) |
| dstPort = (PortType)dst; |
| if (srcPort != null && dstPort != null) |
| return compatibleType(srcPort, dstPort); |
| |
| // otherwise, incompatible partner activity messages |
| return false; |
| } |
| |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=330813 |
| // https://jira.jboss.org/browse/JBIDE-7116 |
| // new: compare contents of messages |
| // https://jira.jboss.org/browse/JBIDE-7351 |
| // no longer static because of xsdComparer object |
| public boolean compatibleType(Message src, Message dst) { |
| assertTrue(src != null, CONTEXT_MSG); |
| assertTrue(dst != null, CONTEXT_MSG); |
| |
| if (AdapterFactory.DEBUG==false) |
| if (src==dst) |
| return true; |
| |
| if (!src.getQName().equals(dst.getQName())) |
| return false; |
| |
| if (src.eResource().getURI().equals(dst.eResource().getURI())) |
| return true; |
| |
| EList<Part> parts1 = src.getEParts(); |
| EList<Part> parts2 = dst.getEParts(); |
| if (parts1.size() != parts2.size()) |
| return false; |
| |
| for (int i=0; i<parts1.size(); ++i) { |
| Part part1 = parts1.get(i); |
| Part part2 = parts2.get(i); |
| if (!part1.getName().equals(part2.getName())) |
| return false; |
| if (!compatibleType(part1.getTypeDefinition(), part2.getTypeDefinition())) |
| return false; |
| } |
| |
| return true; |
| } |
| |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=330813 |
| // https://jira.jboss.org/browse/JBIDE-7116 |
| // new: compare XSDElementDeclaractions |
| // https://jira.jboss.org/browse/JBIDE-7351 |
| // no longer static because of xsdComparer object |
| public boolean compatibleType(XSDElementDeclaration src, XSDElementDeclaration dst) { |
| assertTrue(src != null, CONTEXT_MSG); |
| assertTrue(dst != null, CONTEXT_MSG); |
| |
| if (AdapterFactory.DEBUG==false) |
| if (src==dst) |
| return true; |
| |
| return compatibleType(src.getTypeDefinition(),dst.getTypeDefinition()); |
| } |
| |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=330813 |
| // https://jira.jboss.org/browse/JBIDE-7116 |
| // new: compare XSDTypeDefinitions |
| // https://jira.jboss.org/browse/JBIDE-7351 |
| // no longer static because of xsdComparer object |
| public boolean compatibleType(XSDTypeDefinition src, XSDTypeDefinition dst) { |
| assertTrue(src != null, CONTEXT_MSG); |
| assertTrue(dst != null, CONTEXT_MSG); |
| |
| if (AdapterFactory.DEBUG==false) |
| if (src==dst) |
| return true; |
| |
| return xsdComparer.compare(src,dst); |
| } |
| |
| // https://jira.jboss.org/browse/JBIDE-7116 |
| // new: compare PortTypes |
| // https://jira.jboss.org/browse/JBIDE-7351 |
| // no longer static because of xsdComparer object |
| public boolean compatibleType(PortType src, PortType dst) { |
| assertTrue(src != null, CONTEXT_MSG); |
| assertTrue(dst != null, CONTEXT_MSG); |
| |
| if (AdapterFactory.DEBUG==false) |
| if (src==dst) |
| return true; |
| |
| // do portTypes have to be defined in the same WSDL? |
| // URI uri1 = src.eResource().getURI(); |
| // URI uri2 = dst.eResource().getURI(); |
| // if ( !src.eResource().getURI().equals(dst.eResource().getURI()) ) |
| // return false; |
| |
| // check names |
| if (src.getQName()==null || !src.getQName().equals(dst.getQName())) |
| return false; |
| |
| // check operations |
| EList<Operation> ops1 = src.getEOperations(); |
| EList<Operation> ops2 = dst.getEOperations(); |
| if (ops1.size()!=ops2.size()) |
| return false; |
| for (int i=0; i<ops1.size(); ++i) { |
| Operation op1 = ops1.get(i); |
| Operation op2 = ops2.get(i); |
| if (!compatibleType(op1, op2)) |
| return false; |
| } |
| return true; |
| } |
| |
| // https://jira.jboss.org/browse/JBIDE-7116 |
| // new: compare Operations |
| // https://jira.jboss.org/browse/JBIDE-7351 |
| // no longer static because of xsdComparer object |
| public boolean compatibleType(Operation src, Operation dst) { |
| assertTrue(src != null, CONTEXT_MSG); |
| assertTrue(dst != null, CONTEXT_MSG); |
| |
| if (AdapterFactory.DEBUG==false) |
| if (src==dst) |
| return true; |
| |
| if (src.getName()==null || !src.getName().equals(dst.getName())) |
| return false; |
| |
| if (!src.getStyle().equals(dst.getStyle())) |
| return false; |
| |
| // check inputs, outputs and faults |
| Input in1 = src.getEInput(); |
| Input in2 = dst.getEInput(); |
| if (in1!=null && in2!=null) { |
| if (!compatibleType(in1.getEMessage(), in2.getEMessage())) |
| return false; |
| } |
| else if ( (in1==null) != (in2==null) ) |
| return false; |
| |
| Output out1 = src.getEOutput(); |
| Output out2 = dst.getEOutput(); |
| if (out1!=null && out2!=null) { |
| if (!compatibleType(out1.getEMessage(), out2.getEMessage())) |
| return false; |
| } |
| else if ( (out1==null) != (out2==null) ) |
| return false; |
| |
| EList<Fault> faults1 = src.getEFaults(); |
| EList<Fault> faults2 = dst.getEFaults(); |
| if (faults1.size() != faults2.size()) |
| return false; |
| for (int i=0; i<faults1.size(); ++i) { |
| if (!compatibleType(faults1.get(i).getEMessage(), faults2.get(i).getEMessage())) |
| return false; |
| } |
| return true; |
| } |
| /** |
| * @param eObj the object |
| * @return returns if simple type, false otherwise. |
| */ |
| |
| public static boolean isSimpleType(EObject eObj) { |
| assertTrue(eObj != null, CONTEXT_MSG); |
| |
| if (eObj instanceof XSDSimpleTypeDefinition) { |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * Lookup type of the part of the message. |
| * @param eObj the reference object |
| * @param qname the part name. |
| * @return the type of the part |
| */ |
| |
| public static EObject lookupTypeOfPart (EObject eObj, QName qname) { |
| EObject obj = lookupMessagePart(eObj, qname.getLocalPart()); |
| if (obj == null || obj instanceof Part == false) { |
| return null; |
| } |
| Part part = (Part) obj; |
| if (part.getElementDeclaration() != null) { |
| return part.getElementDeclaration().getTypeDefinition(); |
| } |
| return part.getTypeDefinition(); |
| } |
| |
| |
| /** |
| * An null NS URI is the default namespace "". |
| * EMF seems to return null as the default target namespace. |
| * |
| * @param nsURI |
| * @param nsURI2 |
| * @return true if the namespaces are the same, false otherwise. |
| */ |
| static boolean sameNamespace ( String nsURI, String nsURI2 ) { |
| |
| if (nsURI == null) { |
| nsURI = XMLConstants.NULL_NS_URI; |
| } |
| if (nsURI2 == null) { |
| nsURI2 = XMLConstants.NULL_NS_URI; |
| } |
| return nsURI.equals(nsURI2); |
| } |
| |
| } |