| /******************************************************************************* |
| * 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.resource; |
| |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.StringReader; |
| import java.lang.reflect.Method; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.StringTokenizer; |
| |
| import javax.wsdl.WSDLException; |
| import javax.wsdl.extensions.ExtensibilityElement; |
| import javax.xml.namespace.QName; |
| import javax.xml.parsers.DocumentBuilder; |
| |
| import org.apache.xerces.parsers.DOMParser; |
| import org.eclipse.bpel.model.Activity; |
| import org.eclipse.bpel.model.Assign; |
| import org.eclipse.bpel.model.BPELFactory; |
| import org.eclipse.bpel.model.BPELPackage; |
| import org.eclipse.bpel.model.BPELPlugin; |
| import org.eclipse.bpel.model.Branches; |
| import org.eclipse.bpel.model.Catch; |
| import org.eclipse.bpel.model.CatchAll; |
| import org.eclipse.bpel.model.Compensate; |
| import org.eclipse.bpel.model.CompensateScope; |
| import org.eclipse.bpel.model.CompensationHandler; |
| import org.eclipse.bpel.model.CompletionCondition; |
| import org.eclipse.bpel.model.Condition; |
| import org.eclipse.bpel.model.Copy; |
| import org.eclipse.bpel.model.Correlation; |
| import org.eclipse.bpel.model.CorrelationPattern; |
| import org.eclipse.bpel.model.CorrelationSet; |
| import org.eclipse.bpel.model.CorrelationSets; |
| import org.eclipse.bpel.model.Correlations; |
| import org.eclipse.bpel.model.Documentation; |
| import org.eclipse.bpel.model.Else; |
| import org.eclipse.bpel.model.ElseIf; |
| import org.eclipse.bpel.model.Empty; |
| import org.eclipse.bpel.model.EndpointReferenceRole; |
| import org.eclipse.bpel.model.EventHandler; |
| import org.eclipse.bpel.model.Exit; |
| import org.eclipse.bpel.model.Expression; |
| import org.eclipse.bpel.model.BPELExtensibleElement; |
| import org.eclipse.bpel.model.Extension; |
| import org.eclipse.bpel.model.Extensions; |
| import org.eclipse.bpel.model.FaultHandler; |
| import org.eclipse.bpel.model.Flow; |
| import org.eclipse.bpel.model.ForEach; |
| import org.eclipse.bpel.model.From; |
| import org.eclipse.bpel.model.FromPart; |
| import org.eclipse.bpel.model.FromParts; |
| import org.eclipse.bpel.model.If; |
| import org.eclipse.bpel.model.Import; |
| import org.eclipse.bpel.model.Invoke; |
| import org.eclipse.bpel.model.Link; |
| import org.eclipse.bpel.model.Links; |
| import org.eclipse.bpel.model.MessageExchange; |
| import org.eclipse.bpel.model.MessageExchanges; |
| import org.eclipse.bpel.model.OnAlarm; |
| import org.eclipse.bpel.model.OnEvent; |
| import org.eclipse.bpel.model.OnMessage; |
| import org.eclipse.bpel.model.OpaqueActivity; |
| import org.eclipse.bpel.model.PartnerActivity; |
| import org.eclipse.bpel.model.PartnerLink; |
| import org.eclipse.bpel.model.PartnerLinks; |
| import org.eclipse.bpel.model.Pick; |
| import org.eclipse.bpel.model.Process; |
| import org.eclipse.bpel.model.Query; |
| import org.eclipse.bpel.model.Receive; |
| import org.eclipse.bpel.model.RepeatUntil; |
| import org.eclipse.bpel.model.Reply; |
| import org.eclipse.bpel.model.Rethrow; |
| import org.eclipse.bpel.model.Scope; |
| import org.eclipse.bpel.model.Sequence; |
| import org.eclipse.bpel.model.ServiceRef; |
| import org.eclipse.bpel.model.Source; |
| import org.eclipse.bpel.model.Sources; |
| import org.eclipse.bpel.model.Target; |
| import org.eclipse.bpel.model.Targets; |
| import org.eclipse.bpel.model.TerminationHandler; |
| import org.eclipse.bpel.model.Throw; |
| import org.eclipse.bpel.model.To; |
| import org.eclipse.bpel.model.ToPart; |
| import org.eclipse.bpel.model.ToParts; |
| import org.eclipse.bpel.model.Validate; |
| import org.eclipse.bpel.model.Variable; |
| import org.eclipse.bpel.model.Variables; |
| import org.eclipse.bpel.model.Wait; |
| import org.eclipse.bpel.model.While; |
| import org.eclipse.bpel.model.extensions.BPELActivityDeserializer; |
| import org.eclipse.bpel.model.extensions.BPELExtensionDeserializer; |
| import org.eclipse.bpel.model.extensions.BPELExtensionRegistry; |
| import org.eclipse.bpel.model.extensions.BPELUnknownExtensionDeserializer; |
| import org.eclipse.bpel.model.extensions.ServiceReferenceDeserializer; |
| import org.eclipse.bpel.model.impl.FromImpl; |
| import org.eclipse.bpel.model.impl.FromPartImpl; |
| import org.eclipse.bpel.model.impl.OnEventImpl; |
| import org.eclipse.bpel.model.impl.OnMessageImpl; |
| import org.eclipse.bpel.model.impl.PartnerActivityImpl; |
| import org.eclipse.bpel.model.impl.ToImpl; |
| import org.eclipse.bpel.model.impl.ToPartImpl; |
| import org.eclipse.bpel.model.messageproperties.Property; |
| import org.eclipse.bpel.model.messageproperties.util.MessagepropertiesConstants; |
| import org.eclipse.bpel.model.proxy.CorrelationSetProxy; |
| import org.eclipse.bpel.model.proxy.LinkProxy; |
| import org.eclipse.bpel.model.proxy.MessageExchangeProxy; |
| import org.eclipse.bpel.model.proxy.MessageProxy; |
| import org.eclipse.bpel.model.proxy.PartnerLinkProxy; |
| import org.eclipse.bpel.model.proxy.PartnerLinkTypeProxy; |
| import org.eclipse.bpel.model.proxy.PropertyProxy; |
| import org.eclipse.bpel.model.proxy.RoleProxy; |
| import org.eclipse.bpel.model.proxy.VariableProxy; |
| import org.eclipse.bpel.model.proxy.XSDElementDeclarationProxy; |
| import org.eclipse.bpel.model.proxy.XSDTypeDefinitionProxy; |
| import org.eclipse.bpel.model.util.BPELConstants; |
| import org.eclipse.bpel.model.util.BPELUtils; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.emf.common.util.BasicEList; |
| import org.eclipse.emf.common.util.WrappedException; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.EReference; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.wst.wsdl.Message; |
| import org.eclipse.wst.wsdl.PortType; |
| import org.eclipse.xsd.XSDElementDeclaration; |
| import org.eclipse.xsd.XSDTypeDefinition; |
| import org.eclipse.xsd.util.XSDConstants; |
| import org.w3c.dom.Attr; |
| import org.w3c.dom.CDATASection; |
| import org.w3c.dom.Document; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.NamedNodeMap; |
| import org.w3c.dom.Node; |
| import org.w3c.dom.NodeList; |
| import org.w3c.dom.Text; |
| import org.xml.sax.ErrorHandler; |
| import org.xml.sax.InputSource; |
| import org.xml.sax.SAXException; |
| import org.xml.sax.SAXNotRecognizedException; |
| import org.xml.sax.SAXNotSupportedException; |
| import org.xml.sax.SAXParseException; |
| |
| /** |
| * BPELReader is invoked from BPELResourceImpl to parse the BPEL file and |
| * create a Process object. |
| */ |
| |
| @SuppressWarnings("nls") |
| |
| public class BPELReader implements ErrorHandler { |
| |
| // The process we are reading |
| private Process process = null; |
| // Bugzilla 324165 |
| // The resource we are reading from |
| private Resource fCurrentResource = null; |
| // The successfully loaded resource |
| private Resource fResource = null; |
| // The document builder controls various DOM characteristics |
| private DocumentBuilder docBuilder = null; |
| // Registry for extensibility element serializers and deserializers |
| private BPELExtensionRegistry extensionRegistry = BPELExtensionRegistry.getInstance(); |
| |
| private DOMParser fDOMParser; |
| |
| /** The XML Error handler */ |
| ErrorHandler fErrorHandler = null; |
| |
| |
| /** The WS-BPEL Specification says how to resolve variables, taking into |
| * account scopes, etc. Technically, no one should override this behavior, |
| * but replacing this field with another implementation could allow |
| * you to optimize the search or provide different behavior. |
| */ |
| public static VariableResolver VARIABLE_RESOLVER = new BPELVariableResolver(); |
| |
| /** |
| * The WS-BPEL Specification says how to resolve links, taking into |
| * account scopes, etc. Technically, no one should override this behavior, |
| * but replacing this field with another implementation could allow |
| * you to optimize the search or provide different behavior. |
| */ |
| |
| public static LinkResolver LINK_RESOLVER = new BPELLinkResolver(); |
| |
| |
| List<Runnable> fPass2Runnables = new ArrayList<Runnable>(); |
| |
| /** |
| * Construct a new BPELReader using the given DocumentBuilder to determine |
| * how the DOM tree is constructed. |
| * |
| * @param builder the document builder to use when parsing the file |
| * @throws IOException if no document builder is specified |
| */ |
| public BPELReader (DocumentBuilder builder) throws IOException { |
| if (builder == null) { |
| throw new IOException(BPELPlugin.INSTANCE.getString("%BPELReader.missing_doc_builder")); |
| } |
| this.docBuilder = builder; |
| } |
| |
| /** |
| * @param parser |
| */ |
| public BPELReader (DOMParser parser ) { |
| this.fDOMParser = parser; |
| } |
| |
| /** |
| * Read from the given Document into the given resource. |
| * |
| * @param resource the EMF resource to construct |
| * @param Document the document to read the BPEL from |
| */ |
| public void read(BPELResource resource, Document doc) { |
| this.fResource = resource; |
| // Pass 1 and 2 are inside the try so they don't occur if |
| // an error happens during parsing. |
| // In pass 1 we parse and create the structural elements and attributes. |
| pass1(doc); |
| // In pass 2, we run any postLoadRunnables which need to happen after |
| // pass 1 (for example, establishing object links to variables). |
| pass2(); |
| } |
| |
| /** |
| * |
| */ |
| |
| public BPELReader () { |
| this.fDOMParser = new LineCapturingDOMParser(); |
| |
| // domParser.setProperty("http://xml.org/sax/features/namespaces",true); |
| try { |
| fDOMParser.setFeature( "http://apache.org/xml/features/dom/defer-node-expansion", false ); |
| fDOMParser.setFeature( "http://apache.org/xml/features/xinclude", false); |
| } catch (SAXNotRecognizedException e) { |
| BPELPlugin.log("Not Recognized DOM Parser Feature",e ); |
| } catch (SAXNotSupportedException e) { |
| BPELPlugin.log("Not Supported DOM Parser Feature",e ); |
| } |
| } |
| |
| /** |
| * Set the error handler |
| * @param errorHandler |
| */ |
| |
| public void setErrorHandler ( ErrorHandler errorHandler ) { |
| fErrorHandler = errorHandler; |
| } |
| |
| void armErrorHandler ( ) { |
| |
| assert (docBuilder != null || fDOMParser != null); |
| |
| if (docBuilder != null) { |
| docBuilder.setErrorHandler(fErrorHandler != null ? fErrorHandler : this); |
| } else { |
| fDOMParser.setErrorHandler(fErrorHandler != null ? fErrorHandler : this); |
| } |
| } |
| |
| |
| Document read ( InputSource inputSource ) throws IOException, SAXException { |
| assert (docBuilder != null || fDOMParser != null) : "No document builder/parser set"; |
| |
| if (docBuilder != null) { |
| return docBuilder.parse(inputSource); |
| } |
| fDOMParser.parse(inputSource); |
| return fDOMParser.getDocument(); |
| } |
| |
| |
| /** |
| * Read from the given input stream into the given resource. |
| * |
| * @param resource the EMF resource to construct |
| * @param inputStream the input stream to read the BPEL from |
| */ |
| |
| public void read (BPELResource resource, InputStream inputStream) { |
| |
| armErrorHandler (); |
| |
| Document doc = null; |
| try { |
| InputSource inputSource = new InputSource(inputStream); |
| inputSource.setPublicId( resource.getURI().toString() ); |
| inputSource.setSystemId( resource.getURI().toString() ); |
| |
| resource.setErrorHandler(fErrorHandler != null ? fErrorHandler : this); |
| // Bugzilla 324165 |
| // set the resource currently being loaded so the error handler can |
| // attach diagnostics to it |
| fCurrentResource = resource; |
| doc = read ( inputSource ); |
| // After the document has successfully parsed, it's okay |
| // to assign the resource. |
| fResource = resource; |
| } catch (SAXException sax) { |
| // the error handlers will catch this. |
| } catch (IOException ioe) { |
| BPELPlugin.log("I/O Error Reading BPEL XML", ioe ) ; |
| } finally { |
| |
| } |
| |
| // Bugzilla 324165 |
| if (doc != null) { |
| pass1(doc); |
| pass2(); |
| } |
| fCurrentResource = null; |
| } |
| |
| |
| /** |
| * Return the resource that was used to read in this BPEL process. |
| * |
| * @return the resource that was used to read in this BPEL process. |
| */ |
| |
| public Resource getResource () { |
| return fResource; |
| } |
| |
| |
| /** |
| * @param xmlSource the XML source |
| * @param sourceDescription some textual description of the source (for example Clipboard). |
| * @return a list of objects |
| */ |
| |
| public List<EObject> fromXML ( String xmlSource , String sourceDescription , Resource resource ) { |
| |
| armErrorHandler (); |
| |
| if (sourceDescription == null) { |
| sourceDescription = "String"; |
| } |
| |
| Document doc = null; |
| try { |
| InputSource inputSource = new InputSource(new StringReader ( xmlSource )); |
| inputSource.setPublicId( sourceDescription ); |
| // Bugzilla 324165 |
| // set the resource currently being loaded so the error handler can |
| // attach diagnostics to it |
| fCurrentResource = resource; |
| doc = read (inputSource); |
| |
| } catch (SAXException sax) { |
| // done by the handler. |
| } catch (IOException ioe) { |
| BPELPlugin.log("I/O Error Reading BPEL XML", ioe ) ; |
| } finally { |
| |
| } |
| |
| if (doc == null) { |
| fCurrentResource = null; |
| return Collections.emptyList(); |
| } |
| |
| fResource = resource; |
| |
| // Pass 1 and 2 are inside the try so they don't occur if |
| // an error happens during parsing. |
| // In pass 1 we parse and create the structural elements and attributes. |
| List<EObject> result = parseDocument(doc); |
| // In pass 2, we run any postLoadRunnables which need to happen after |
| // pass 1 (for example, establishing object links to variables). |
| pass2(); |
| |
| fCurrentResource = null; |
| return result; |
| } |
| |
| |
| /** |
| * In pass 1, we parse and create the structural elements and attributes, |
| * and add the process to the EMF resource's contents |
| * @param document the DOM document to parse |
| */ |
| protected void pass1 (Document document) { |
| Process p = xml2Resource(document); |
| if (p != null) { |
| fResource.getContents().add(p); |
| } |
| } |
| |
| /** |
| * In pass 2, we run any post load runnables which were queued during pass 1. |
| */ |
| protected void pass2() { |
| try { |
| for(Runnable r : fPass2Runnables) { |
| r.run(); |
| } |
| } finally { |
| fPass2Runnables.clear(); |
| } |
| } |
| |
| |
| /** |
| * Returns a list of child nodes of <code>parentElement</code> that are |
| * {@link Element}s. |
| * Returns an empty list if no elements are found. |
| * |
| * @param parentElement the element to find the children of |
| * @return a node list of the children of parentElement |
| */ |
| protected List<Element> getChildElements(Element parentElement) { |
| List<Element> list = new ArrayList<Element>(); |
| NodeList children = parentElement.getChildNodes(); |
| for (int i=0; i < children.getLength(); i++) { |
| if (children.item(i).getNodeType() == Node.ELEMENT_NODE) |
| list.add( (Element) children.item(i)); |
| } |
| return list; |
| } |
| |
| /** |
| * Returns a list of child nodes of <code>parentElement</code> that are |
| * {@link Element}s with a BPEL namespace that have the given <code>localName</code>. |
| * Returns an empty list if no matching elements are found. |
| * |
| * @param parentElement the element to find the children of |
| * @param localName the localName to match against |
| * @return a node list of the matching children of parentElement |
| */ |
| public List<Element> getBPELChildElementsByLocalName(Element parentElement, String localName) { |
| List<Element> list = new ArrayList<Element>(); |
| NodeList children = parentElement.getChildNodes(); |
| for (int i = 0; i < children.getLength(); i++) { |
| Node node = children.item(i); |
| if (localName.equals(node.getLocalName()) && BPELUtils.isBPELElement(node)) { |
| list.add((Element) node); |
| } |
| } |
| return list; |
| } |
| |
| /** |
| * Returns the first child node of <code>parentElement</code> that is an {@link Element} |
| * with a BPEL namespace and the given <code>localName</code>, or <code>null</code> |
| * if a matching element is not found. |
| * |
| * @param parentElement the element to find the children of |
| * @param localName the localName to match against |
| * @return the first matching element, or null if no element was found |
| */ |
| public Element getBPELChildElementByLocalName(Element parentElement, String localName) { |
| NodeList children = parentElement.getChildNodes(); |
| for (int i = 0; i < children.getLength(); i++) { |
| Node node = children.item(i); |
| if (localName.equals(node.getLocalName()) && BPELUtils.isBPELElement(node)) { |
| return (Element) node; |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Walk from the given element up through its parents, looking for any |
| * xmlns definitions. Collect them all in a map (mapping the prefix to |
| * the namespace value) and return the map. |
| * |
| * @param element the element to get the xmlns definitions for |
| * @return a map of visible xmlns definitions |
| */ |
| protected Map<String,String> getAllNamespacesForElement (Element element) { |
| Map<String,String> nsMap = new HashMap<String,String>(); |
| Node tempNode = element; |
| while (tempNode != null && tempNode.getNodeType() == Node.ELEMENT_NODE) { |
| NamedNodeMap attrs = ((Element)tempNode).getAttributes(); |
| for (int i = 0; i < attrs.getLength(); i++) { |
| Attr attr = (Attr)attrs.item(i); |
| // XML namespace attributes use the reserved namespace "http://www.w3.org/2000/xmlns/". |
| if (XSDConstants.XMLNS_URI_2000.equalsIgnoreCase(attr.getNamespaceURI())) { |
| final String key = BPELUtils.getNSPrefixMapKey(attr.getLocalName()); |
| if (!nsMap.containsKey(key)) { |
| nsMap.put(key, attr.getValue()); |
| } |
| } |
| } |
| tempNode = tempNode.getParentNode(); |
| } |
| return nsMap; |
| } |
| |
| /** |
| * For all attributes of the given element, ensure that their namespace |
| * prefixes are in the resource's prefix-to-namespace-map. |
| * |
| * @param eObject |
| * @param element |
| */ |
| protected void saveNamespacePrefix(EObject eObject, Element element) { |
| Map<String,String> nsMap = null; // lazy init since it may require a new map |
| NamedNodeMap attrs = element.getAttributes(); |
| |
| for (int i=0; i < attrs.getLength(); i++) { |
| Attr attr = (Attr) attrs.item(i); |
| // XML namespace attributes use the reserved namespace "http://www.w3.org/2000/xmlns/". |
| if (XSDConstants.XMLNS_URI_2000.equals(attr.getNamespaceURI())) { |
| if (nsMap == null) { |
| nsMap = BPELUtils.getNamespaceMap(eObject); |
| } |
| nsMap.put(BPELUtils.getNSPrefixMapKey(attr.getLocalName()), attr.getValue()); |
| } |
| } |
| } |
| |
| /** |
| * Given a DOM Element, find the child element which is a BPEL activity |
| * (of some type), parse it, and return the Activity. |
| * |
| * @param element the element in which to find an activity |
| * @return the activity, or null if no activity could be found |
| */ |
| protected Activity getChildActivity(Element element) { |
| NodeList activityElements = element.getChildNodes(); |
| for (int i = 0; i < activityElements.getLength(); i++) { |
| if (activityElements.item(i).getNodeType() != Node.ELEMENT_NODE) { |
| continue; |
| } |
| |
| Element activityElement = (Element)activityElements.item(i); |
| Activity activity = xml2Activity(activityElement); |
| |
| if (activity != null) { |
| return activity; |
| } |
| } |
| return null; |
| } |
| |
| |
| /** |
| * Sets a PartnerLink element for a given EObject. The given activity element |
| * must contain an attribute named "partnerLink". |
| * |
| * @param activityElement the DOM element of the activity |
| * @param eObject the EObject in which to set the partner link |
| */ |
| protected void setPartnerLink(Element activityElement, final EObject eObject, final EReference reference) { |
| if (!activityElement.hasAttribute("partnerLink")) { |
| return; |
| } |
| |
| final String partnerLinkName = activityElement.getAttribute("partnerLink"); |
| // We must do this as a post load runnable because the partner link might not |
| // exist yet. |
| fPass2Runnables.add(new Runnable() { |
| public void run() { |
| PartnerLink targetPartnerLink = BPELUtils.getPartnerLink(eObject, partnerLinkName); |
| if (targetPartnerLink == null) { |
| targetPartnerLink = new PartnerLinkProxy(getResource().getURI(), partnerLinkName); |
| } |
| eObject.eSet(reference, targetPartnerLink); |
| } |
| }); |
| } |
| |
| /** |
| * Sets a Variable element for a given EObject. The given activity element |
| * must contain an attribute with the given name |
| * |
| * @param activityElement the DOM element of the activity |
| * @param eObject the EObject in which to set the variable |
| * @param variableAttrName the name of the attribute containing the variable name |
| * @param reference the EReference which is the variable pointer in EObject |
| */ |
| protected void setVariable(Element activityElement, final EObject eObject, String variableNameAttr, final EReference reference) { |
| if (!activityElement.hasAttribute(variableNameAttr)) { |
| return; |
| } |
| |
| final String variableName = activityElement.getAttribute(variableNameAttr); |
| // We must do this as a post load runnable because the variable might not |
| // exist yet. |
| fPass2Runnables.add(new Runnable() { |
| public void run() { |
| Variable targetVariable = getVariable(eObject, variableName); |
| if (targetVariable == null) { |
| targetVariable = new VariableProxy(getResource().getURI(), variableName); |
| } |
| eObject.eSet(reference, targetVariable); |
| } |
| }); |
| } |
| |
| /** |
| * Find a Property name in element (in the named attribute) and set it |
| * into the given EObject. If EObject is a CorrelationSet, add the property |
| * to the list of properties. If it is a To, set the property. |
| * |
| * @param element the DOM element containing the property name |
| * @param eObject the EObject in which to set the property |
| * @param propertyName the name of the attribute containing the property name |
| */ |
| protected void setProperties(Element element, EObject eObject, String propertyName) { |
| String propertyAttribute = element.getAttribute(propertyName); |
| |
| // added by Grid.Qian |
| // we should permit user add a correlation without properties |
| if(propertyAttribute == null){ |
| return; |
| } |
| StringTokenizer st = new StringTokenizer(propertyAttribute); |
| |
| while (st.hasMoreTokens()) { |
| QName qName = BPELUtils.createQName(element, st.nextToken()); |
| Property property = new PropertyProxy(getResource().getURI(), qName); |
| if (eObject instanceof CorrelationSet) { |
| ((CorrelationSet)eObject).getProperties().add(property); |
| } else if (eObject instanceof To) { |
| ((To)eObject).setProperty(property); |
| } |
| } |
| } |
| |
| /** |
| * Sets a CompensationHandler element for a given eObject. |
| */ |
| protected void setCompensationHandler(Element element, EObject eObject) { |
| Element compensationHandlerElement = getBPELChildElementByLocalName(element, "compensationHandler"); |
| |
| if (compensationHandlerElement != null) { |
| CompensationHandler compensationHandler = xml2CompensationHandler(compensationHandlerElement); |
| xml2ExtensibleElement(compensationHandler, compensationHandlerElement); |
| |
| if (eObject instanceof Invoke) |
| ((Invoke)eObject).setCompensationHandler(compensationHandler); |
| else if (eObject instanceof Scope) |
| ((Scope)eObject).setCompensationHandler(compensationHandler); |
| } |
| } |
| |
| /** |
| * Sets a FaultHandler element for a given extensibleElement. |
| */ |
| protected void setFaultHandler(Element element, BPELExtensibleElement extensibleElement) { |
| List<Element> faultHandlerElements = getBPELChildElementsByLocalName(element, "faultHandlers"); |
| |
| if (faultHandlerElements.size() > 0) { |
| FaultHandler faultHandler = xml2FaultHandler(faultHandlerElements.get(0)); |
| |
| if (extensibleElement instanceof Process) { |
| ((Process)extensibleElement).setFaultHandlers(faultHandler); |
| } else if (extensibleElement instanceof Invoke) { |
| ((Invoke)extensibleElement).setFaultHandler(faultHandler); |
| } |
| } |
| } |
| |
| /** |
| * Sets a EventHandler element for a given extensibleElement. |
| */ |
| protected void setEventHandler(Element element, BPELExtensibleElement extensibleElement) { |
| List<Element> eventHandlerElements = getBPELChildElementsByLocalName(element, "eventHandlers"); |
| |
| if (eventHandlerElements.size() > 0) { |
| EventHandler eventHandler = xml2EventHandler(eventHandlerElements.get(0)); |
| |
| if (extensibleElement instanceof Process) ((Process)extensibleElement).setEventHandlers(eventHandler); |
| else if (extensibleElement instanceof Scope) ((Scope)extensibleElement).setEventHandlers(eventHandler); |
| } |
| } |
| |
| |
| /** |
| * Sets the standard attributes (name, joinCondition, and suppressJoinFailure). |
| */ |
| protected void setStandardAttributes(Element activityElement, Activity activity) { |
| |
| // Set name |
| Attr name = activityElement.getAttributeNode("name"); |
| |
| if (name != null && name.getSpecified()) |
| activity.setName(name.getValue()); |
| |
| // Set suppress join failure |
| Attr suppressJoinFailure = activityElement.getAttributeNode("suppressJoinFailure"); |
| |
| if (suppressJoinFailure != null && suppressJoinFailure.getSpecified()) |
| activity.setSuppressJoinFailure( Boolean.valueOf( suppressJoinFailure.getValue().equals("yes"))); |
| } |
| |
| |
| /** |
| * Sets name, portType, operation, partner, variable and correlation for a given PartnerActivity object. |
| */ |
| protected void setOperationParms(final Element activityElement, |
| final PartnerActivity activity, |
| EReference variableReference, |
| EReference inputVariableReference, |
| EReference outputVariableReference, |
| EReference partnerReference) { |
| // Set partnerLink |
| setPartnerLink(activityElement, activity, partnerReference); |
| |
| // Set portType |
| PortType portType = null; |
| if (activityElement.hasAttribute("portType")) { |
| portType = BPELUtils.getPortType(getResource().getURI(), activityElement, "portType"); |
| activity.setPortType(portType); |
| } |
| |
| // Set operation |
| if (activityElement.hasAttribute("operation")) { |
| if (portType != null) { |
| activity.setOperation(BPELUtils.getOperation(getResource().getURI(), portType, activityElement, "operation")); |
| } else { |
| ((PartnerActivityImpl) activity).setOperationName(activityElement.getAttribute("operation")); |
| } |
| } |
| |
| // Set variable |
| if (variableReference != null) { |
| setVariable(activityElement, activity, "variable", variableReference); |
| } |
| if (inputVariableReference != null) { |
| setVariable(activityElement, activity, "inputVariable", inputVariableReference); |
| } |
| if (outputVariableReference != null) { |
| setVariable(activityElement, activity, "outputVariable", outputVariableReference); |
| } |
| |
| // Set correlations |
| Element correlationsElement = getBPELChildElementByLocalName(activityElement, "correlations"); |
| if (correlationsElement != null) { |
| Correlations correlations = xml2Correlations(correlationsElement); |
| activity.setCorrelations(correlations); |
| } |
| } |
| |
| /** |
| * Sets name, portType, operation, partner, variable and correlation for a given PartnerActivity object. |
| */ |
| protected void setOperationParmsOnMessage(final Element activityElement, final OnMessage onMessage) { |
| // Set partnerLink |
| setPartnerLink(activityElement, onMessage, BPELPackage.eINSTANCE.getOnMessage_PartnerLink()); |
| |
| // Set portType |
| PortType portType = null; |
| if (activityElement.hasAttribute("portType")) { |
| portType = BPELUtils.getPortType(getResource().getURI(), activityElement, "portType"); |
| onMessage.setPortType(portType); |
| } |
| |
| // Set operation |
| if (activityElement.hasAttribute("operation")) { |
| if (portType != null) { |
| onMessage.setOperation(BPELUtils.getOperation(getResource().getURI(), portType, activityElement, "operation")); |
| } else { |
| // If portType is not specified it will be resolved lazily and so will the operation. |
| // Save the deserialized name so the operation can be later resolved. |
| ((OnMessageImpl) onMessage).setOperationName(activityElement.getAttribute("operation")); |
| } |
| } |
| |
| // Set variable |
| setVariable(activityElement, onMessage, "variable", BPELPackage.eINSTANCE.getOnMessage_Variable()); |
| |
| // Set correlations |
| Element correlationsElement = getBPELChildElementByLocalName(activityElement, "correlations"); |
| if (correlationsElement != null) { |
| Correlations correlations = xml2Correlations(correlationsElement); |
| onMessage.setCorrelations(correlations); |
| } |
| } |
| |
| /** |
| * Sets name, portType, operation, partner, variable, messageType and correlation for a given PartnerActivity object. |
| */ |
| protected void setOperationParmsOnEvent(final Element activityElement, final OnEvent onEvent) { |
| // Set partnerLink |
| setPartnerLink(activityElement, onEvent, BPELPackage.eINSTANCE.getOnEvent_PartnerLink()); |
| |
| // Set portType |
| PortType portType = null; |
| if (activityElement.hasAttribute("portType")) { |
| portType = BPELUtils.getPortType(getResource().getURI(), activityElement, "portType"); |
| onEvent.setPortType(portType); |
| } |
| |
| // Set operation |
| if (activityElement.hasAttribute("operation")) { |
| if (portType != null) { |
| onEvent.setOperation(BPELUtils.getOperation(getResource().getURI(), portType, activityElement, "operation")); |
| } else { |
| ((OnEventImpl) onEvent).setOperationName(activityElement.getAttribute("operation")); |
| } |
| } |
| |
| // Set variable |
| if (activityElement.hasAttribute("variable")) { |
| Variable variable = BPELFactory.eINSTANCE.createVariable(); |
| |
| // Set name |
| String name = activityElement.getAttribute("variable"); |
| variable.setName(name); |
| onEvent.setVariable(variable); |
| // Don't set the message type of the variable, this will happen |
| // in the next step. |
| } |
| |
| // Set message type |
| if (activityElement.hasAttribute("messageType")) { |
| QName qName = BPELUtils.createAttributeValue(activityElement, "messageType"); |
| Message messageType = new MessageProxy(getResource().getURI(), qName); |
| onEvent.setMessageType(messageType); |
| } |
| |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=336003 |
| // "element" attribute was missing from original model |
| // Set xsd element |
| if (activityElement.hasAttribute("element")) { |
| QName qName = BPELUtils.createAttributeValue(activityElement, |
| "element"); |
| XSDElementDeclaration element = new XSDElementDeclarationProxy( |
| getResource().getURI(), qName); |
| onEvent.setXSDElement(element); |
| } else { |
| onEvent.setXSDElement(null); |
| } |
| |
| // Set correlations |
| Element correlationsElement = getBPELChildElementByLocalName(activityElement, "correlations"); |
| if (correlationsElement != null) { |
| Correlations correlations = xml2Correlations(correlationsElement); |
| onEvent.setCorrelations(correlations); |
| } |
| } |
| |
| /** |
| * |
| */ |
| protected List<EObject> parseDocument (Document document) { |
| |
| Element element = (document != null)? document.getDocumentElement(): null; |
| List<EObject> list = new ArrayList<EObject>(); |
| if (element == null) { |
| return list; |
| } |
| |
| if (element.getLocalName().equals("bag")) { |
| |
| for(Node n = element.getFirstChild(); n != null; n = n.getNextSibling()) { |
| if (n instanceof Element == false) { |
| continue; |
| } |
| EObject next = parseElement ( (Element) n ); |
| if (next != null) { |
| list.add(next); |
| } |
| } |
| |
| } else { |
| EObject next = parseElement(element); |
| if (next != null) { |
| list.add(next); |
| } |
| } |
| return list; |
| } |
| |
| |
| EObject parseElement ( Element element ) { |
| |
| Method parseMethod = getParseMethod ( element ); |
| if (parseMethod == null) { |
| return null; |
| } |
| try { |
| return (EObject) parseMethod.invoke(this, element) ; |
| } catch (Throwable t) { |
| t.printStackTrace(); |
| // |
| } |
| return null; |
| } |
| |
| Method getParseMethod ( Element element ) { |
| if (BPELUtils.isBPELElement( element ) == false) { |
| return null; |
| } |
| |
| String methodName = element.getLocalName(); |
| methodName = "xml2" + Character.toUpperCase(methodName.charAt(0)) + methodName.substring(1); |
| |
| return lookupMethod ( getClass(), methodName, Element.class ); |
| } |
| |
| Method lookupMethod ( Class<?> target, String methodName, Class<?> ... args ) { |
| if (target == null || target == Object.class) { |
| return null ; |
| } |
| |
| for(Method m : target.getDeclaredMethods()) { |
| if (methodName.equals(m.getName()) == false || m.getParameterTypes().length != args.length ) { |
| continue; |
| } |
| Class<?> argTypes[] = m.getParameterTypes(); |
| for(int i=0; i < args.length; i++) { |
| if (argTypes[i].isAssignableFrom(args[i]) == false) { |
| continue; |
| } |
| } |
| return m; |
| } |
| return lookupMethod(target.getSuperclass(), methodName, args); |
| |
| } |
| |
| /** |
| * Converts an XML document to a BPEL Resource object. |
| */ |
| protected Process xml2Resource(Document document) { |
| Element processElement = (document != null)? document.getDocumentElement(): null; |
| if (processElement == null) { |
| return null; |
| } |
| return xml2Process(processElement); |
| } |
| |
| |
| /** |
| * Converts an XML process to a BPEL Process object. |
| */ |
| @SuppressWarnings("nls") |
| protected Process xml2Process(Element processElement) { |
| if (!processElement.getLocalName().equals("process")) { |
| return null; |
| } |
| if (!BPELConstants.isBPELNamespace(processElement.getNamespaceURI())) { |
| return null; |
| } |
| |
| process = BPELFactory.eINSTANCE.createProcess(); |
| process.setElement(processElement); |
| |
| // Save all the references to external namespaces |
| saveNamespacePrefix(process, processElement); |
| |
| // Handle Process element |
| if (processElement.hasAttribute("name")) |
| process.setName(processElement.getAttribute("name")); |
| |
| if (processElement.hasAttribute("targetNamespace")) |
| process.setTargetNamespace(processElement.getAttribute("targetNamespace")); |
| |
| if (processElement.hasAttribute("suppressJoinFailure")) |
| process.setSuppressJoinFailure( Boolean.valueOf( processElement.getAttribute("suppressJoinFailure").equals("yes"))); |
| |
| if (processElement.hasAttribute("exitOnStandardFault")) |
| process.setExitOnStandardFault( Boolean.valueOf( processElement.getAttribute("exitOnStandardFault").equals("yes"))); |
| |
| if (processElement.hasAttribute("variableAccessSerializable")) |
| process.setVariableAccessSerializable( Boolean.valueOf( processElement.getAttribute("variableAccessSerializable").equals("yes"))); |
| |
| if (processElement.hasAttribute("queryLanguage")) |
| process.setQueryLanguage(processElement.getAttribute("queryLanguage")); |
| |
| if (processElement.hasAttribute("expressionLanguage")) |
| process.setExpressionLanguage(processElement.getAttribute("expressionLanguage")); |
| |
| // Handle Import Elements |
| for(Element e : getBPELChildElementsByLocalName(processElement, "import")) { |
| process.getImports().add(xml2Import(e)); |
| } |
| |
| |
| // Handle PartnerLinks Element |
| Element partnerLinksElement = getBPELChildElementByLocalName(processElement, "partnerLinks"); |
| if (partnerLinksElement != null) |
| process.setPartnerLinks(xml2PartnerLinks(partnerLinksElement)); |
| |
| // Handle Variables Element |
| Element variablesElement = getBPELChildElementByLocalName(processElement, "variables"); |
| if (variablesElement != null) |
| process.setVariables(xml2Variables(variablesElement)); |
| |
| // Handle CorrelationSets Element |
| Element correlationSetsElement = getBPELChildElementByLocalName(processElement, "correlationSets"); |
| if (correlationSetsElement != null) |
| process.setCorrelationSets(xml2CorrelationSets(correlationSetsElement)); |
| |
| // Handle MessageExchanges Element |
| Element messageExchangesElements = getBPELChildElementByLocalName(processElement, "messageExchanges"); |
| if (messageExchangesElements != null) |
| process.setMessageExchanges(xml2MessageExchanges(messageExchangesElements)); |
| |
| // Handle Extensions Element |
| Element extensionsElement = getBPELChildElementByLocalName(processElement, "extensions"); |
| if (extensionsElement != null) |
| process.setExtensions(xml2Extensions(extensionsElement)); |
| |
| // Handle FaultHandler element |
| setFaultHandler(processElement, process); |
| |
| // Handle CompensationHandler element |
| // In BPEL 2.0, there is no compensation handler on process |
| //setCompensationHandler(processElement, process); |
| |
| // Handle EventHandler element |
| setEventHandler(processElement, process); |
| |
| // Handle Activity elements |
| Activity activity = xml2Activity(processElement); |
| process.setActivity(activity); |
| |
| xml2ExtensibleElement(process,processElement); |
| |
| return process; |
| } |
| |
| /** |
| * Converts an XML partnerLinks |
| */ |
| public PartnerLinks xml2PartnerLinks(Element partnerLinksElement) { |
| if (!partnerLinksElement.getLocalName().equals("partnerLinks")) { |
| return null; |
| } |
| |
| PartnerLinks partnerLinks = BPELFactory.eINSTANCE.createPartnerLinks(); |
| partnerLinks.setElement(partnerLinksElement); |
| |
| // Save all the references to external namespaces |
| saveNamespacePrefix(partnerLinks, partnerLinksElement); |
| |
| for(Element e : getBPELChildElementsByLocalName(partnerLinksElement, "partnerLink")) { |
| partnerLinks.getChildren().add( xml2PartnerLink(e) ); |
| } |
| xml2ExtensibleElement(partnerLinks, partnerLinksElement); |
| |
| return partnerLinks; |
| } |
| |
| |
| public Variables xml2Variables(Element variablesElement) { |
| if (!variablesElement.getLocalName().equals("variables")) |
| return null; |
| |
| Variables variables = BPELFactory.eINSTANCE.createVariables(); |
| variables.setElement(variablesElement); |
| |
| // Save all the references to external namespaces |
| saveNamespacePrefix(variables, variablesElement); |
| for(Element e : getBPELChildElementsByLocalName(variablesElement, "variable")) { |
| variables.getChildren().add( xml2Variable( e ) ); |
| } |
| xml2ExtensibleElement(variables, variablesElement); |
| |
| // Move variables that are extensibility elements to the list of children |
| // JM: What is this supposed to accomplish? |
| List<Variable> toBeMoved = new BasicEList<Variable>(); |
| for (Object next : variables.getExtensibilityElements() ) { |
| if (next instanceof Variable) { |
| toBeMoved.add((Variable) next); |
| } |
| } |
| |
| List<?> extensibility = variables.getExtensibilityElements(); |
| List<Variable> children = variables.getChildren(); |
| for(Variable element : toBeMoved) { |
| extensibility.remove(element); |
| children.add(element); |
| } |
| |
| return variables; |
| } |
| |
| public CorrelationSets xml2CorrelationSets(Element correlationSetsElement) { |
| if (!correlationSetsElement.getLocalName().equals("correlationSets")) |
| return null; |
| |
| CorrelationSets correlationSets = BPELFactory.eINSTANCE.createCorrelationSets(); |
| correlationSets.setElement(correlationSetsElement); |
| |
| // Save all the references to external namespaces |
| saveNamespacePrefix(correlationSets, correlationSetsElement); |
| |
| for(Element e : getBPELChildElementsByLocalName(correlationSetsElement, "correlationSet")) { |
| correlationSets.getChildren().add(xml2CorrelationSet(e)); |
| } |
| |
| xml2ExtensibleElement(correlationSets, correlationSetsElement); |
| |
| return correlationSets; |
| } |
| |
| protected FromParts xml2FromParts(Element fromPartsElement) { |
| if (!fromPartsElement.getLocalName().equals("fromParts")) |
| return null; |
| |
| FromParts fromParts = BPELFactory.eINSTANCE.createFromParts(); |
| fromParts.setElement(fromPartsElement); |
| |
| // Save all the references to external namespaces |
| saveNamespacePrefix(fromParts, fromPartsElement); |
| |
| for(Element e : getBPELChildElementsByLocalName(fromPartsElement, "fromPart")) { |
| fromParts.getChildren().add(xml2FromPart(e)); |
| } |
| |
| xml2ExtensibleElement(fromParts, fromPartsElement); |
| |
| return fromParts; |
| } |
| |
| protected ToParts xml2ToParts(Element toPartsElement) { |
| if (!toPartsElement.getLocalName().equals("toParts")) |
| return null; |
| |
| ToParts toParts = BPELFactory.eINSTANCE.createToParts(); |
| toParts.setElement(toPartsElement); |
| |
| // Save all the references to external namespaces |
| saveNamespacePrefix(toParts, toPartsElement); |
| |
| for(Element e : getBPELChildElementsByLocalName(toPartsElement, "toPart")) { |
| toParts.getChildren().add(xml2ToPart(e)); |
| } |
| |
| xml2ExtensibleElement(toParts, toPartsElement); |
| |
| return toParts; |
| } |
| |
| public MessageExchanges xml2MessageExchanges(Element messageExchangesElement) { |
| if (!messageExchangesElement.getLocalName().equals("messageExchanges")) |
| return null; |
| |
| MessageExchanges messageExchanges = BPELFactory.eINSTANCE.createMessageExchanges(); |
| messageExchanges.setElement(messageExchangesElement); |
| |
| // Save all the references to external namespaces |
| saveNamespacePrefix(messageExchanges, messageExchangesElement); |
| |
| for(Element e : getBPELChildElementsByLocalName(messageExchangesElement, "messageExchange")) { |
| messageExchanges.getChildren().add(xml2MessageExchange(e)); |
| } |
| |
| xml2ExtensibleElement(messageExchanges, messageExchangesElement); |
| |
| return messageExchanges; |
| } |
| |
| protected Extensions xml2Extensions(Element extensionsElement) { |
| if (!extensionsElement.getLocalName().equals("extensions")) |
| return null; |
| |
| Extensions extensions = BPELFactory.eINSTANCE.createExtensions(); |
| extensions.setElement(extensionsElement); |
| |
| // Save all the references to external namespaces |
| saveNamespacePrefix(extensions, extensionsElement); |
| for(Element e : getBPELChildElementsByLocalName(extensionsElement, "extension")) { |
| extensions.getChildren().add(xml2Extension(e)); |
| } |
| |
| xml2ExtensibleElement(extensions, extensionsElement); |
| |
| return extensions; |
| } |
| |
| /** |
| * Converts an XML compensationHandler element to a BPEL CompensationHandler object. |
| */ |
| protected CompensationHandler xml2CompensationHandler(Element activityElement) { |
| CompensationHandler compensationHandler = BPELFactory.eINSTANCE.createCompensationHandler(); |
| compensationHandler.setElement(activityElement); |
| |
| // Save all the references to external namespaces |
| saveNamespacePrefix(compensationHandler, activityElement); |
| |
| compensationHandler.setActivity(getChildActivity(activityElement)); |
| |
| return compensationHandler; |
| } |
| |
| |
| /** |
| * Converts an XML correlationSet element to a BPEL CorrelationSet object. |
| */ |
| protected CorrelationSet xml2CorrelationSet(Element correlationSetElement) { |
| CorrelationSet correlationSet = BPELFactory.eINSTANCE.createCorrelationSet(); |
| correlationSet.setElement(correlationSetElement); |
| |
| // Save all the references to external namespaces |
| saveNamespacePrefix(correlationSet, correlationSetElement); |
| |
| if (correlationSetElement == null) return correlationSet; |
| |
| // Set name |
| Attr name = correlationSetElement.getAttributeNode("name"); |
| |
| if (name != null && name.getSpecified()) |
| correlationSet.setName(name.getValue()); |
| |
| setProperties(correlationSetElement, correlationSet, "properties"); |
| |
| xml2ExtensibleElement(correlationSet, correlationSetElement); |
| |
| return correlationSet; |
| } |
| |
| /** |
| * Converts an XML messageExchange element to a BPEL MessageExchange object. |
| */ |
| protected MessageExchange xml2MessageExchange(Element messageExchangeElement) { |
| if (!messageExchangeElement.getLocalName().equals("messageExchange")) |
| return null; |
| |
| MessageExchange messageExchange = BPELFactory.eINSTANCE.createMessageExchange(); |
| messageExchange.setElement(messageExchangeElement); |
| |
| // Save all the references to external namespaces |
| saveNamespacePrefix(messageExchange, messageExchangeElement); |
| |
| // Set name |
| if (messageExchangeElement.hasAttribute("name")) |
| messageExchange.setName(messageExchangeElement.getAttribute("name")); |
| |
| xml2ExtensibleElement(messageExchange, messageExchangeElement); |
| |
| return messageExchange; |
| } |
| |
| /** |
| * Converts an XML extension element to a BPEL Extension object. |
| */ |
| protected Extension xml2Extension(Element extensionElement) { |
| Extension extension = BPELFactory.eINSTANCE.createExtension(); |
| extension.setElement(extensionElement); |
| |
| // Save all the references to external namespaces |
| saveNamespacePrefix(extension, extensionElement); |
| |
| if (extensionElement == null) return extension; |
| |
| // Set namespace |
| if (extensionElement.hasAttribute("namespace")) |
| extension.setNamespace(extensionElement.getAttribute("namespace")); |
| |
| // Set mustUnderstand |
| if (extensionElement.hasAttribute("mustUnderstand")) |
| extension.setMustUnderstand( Boolean.valueOf( extensionElement.getAttribute("mustUnderstand").equals("yes"))); |
| |
| xml2ExtensibleElement(extension, extensionElement); |
| |
| return extension; |
| } |
| |
| /** |
| * Converts an XML partnerLink element to a BPEL PartnerLink object. |
| */ |
| protected PartnerLink xml2PartnerLink(Element partnerLinkElement) { |
| if (!partnerLinkElement.getLocalName().equals("partnerLink")) |
| return null; |
| |
| PartnerLink partnerLink = BPELFactory.eINSTANCE.createPartnerLink(); |
| partnerLink.setElement(partnerLinkElement); |
| |
| // Save all the references to external namespaces |
| saveNamespacePrefix(partnerLink, partnerLinkElement); |
| |
| // Set name |
| if (partnerLinkElement.hasAttribute("name")) |
| partnerLink.setName(partnerLinkElement.getAttribute("name")); |
| |
| if (partnerLinkElement.hasAttribute("initializePartnerRole")) |
| partnerLink.setInitializePartnerRole( Boolean.valueOf( partnerLinkElement.getAttribute("initializePartnerRole").equals("yes"))); |
| |
| Attr partnerLinkTypeName = partnerLinkElement.getAttributeNode("partnerLinkType"); |
| if (partnerLinkTypeName != null && partnerLinkTypeName.getSpecified()) { |
| QName sltQName = BPELUtils.createAttributeValue(partnerLinkElement, "partnerLinkType"); |
| |
| PartnerLinkTypeProxy slt = new PartnerLinkTypeProxy(getResource().getURI(), sltQName); |
| partnerLink.setPartnerLinkType(slt); |
| |
| if(slt != null) { |
| partnerLink.setPartnerLinkType(slt); |
| |
| if (partnerLinkElement.hasAttribute("myRole")) { |
| RoleProxy role = new RoleProxy(getResource(), slt, partnerLinkElement.getAttribute("myRole")); |
| partnerLink.setMyRole(role); |
| } |
| if (partnerLinkElement.hasAttribute("partnerRole")) { |
| RoleProxy role = new RoleProxy(getResource(), slt, partnerLinkElement.getAttribute("partnerRole")); |
| partnerLink.setPartnerRole(role); |
| } |
| } |
| } |
| |
| xml2ExtensibleElement(partnerLink,partnerLinkElement); |
| |
| return partnerLink; |
| } |
| |
| |
| /** |
| * Converts an XML variable element to a BPEL Variable object. |
| */ |
| protected Variable xml2Variable(Element variableElement) { |
| if (!variableElement.getLocalName().equals("variable")) |
| return null; |
| |
| Variable variable = BPELFactory.eINSTANCE.createVariable(); |
| variable.setElement(variableElement); |
| |
| // Save all the references to external namespaces |
| saveNamespacePrefix(variable, variableElement); |
| |
| // Set name |
| if (variableElement.hasAttribute("name")) { |
| String name = variableElement.getAttribute("name"); |
| variable.setName(name); |
| } |
| |
| if (variableElement.hasAttribute("messageType")) { |
| QName qName = BPELUtils.createAttributeValue(variableElement,"messageType"); |
| Message messageType = new MessageProxy(getResource().getURI(), qName); |
| variable.setMessageType(messageType); |
| } |
| |
| // Set xsd type |
| if (variableElement.hasAttribute("type")) { |
| QName qName = BPELUtils.createAttributeValue(variableElement, "type"); |
| XSDTypeDefinition type = new XSDTypeDefinitionProxy(getResource().getURI(), qName); |
| variable.setType(type); |
| } |
| |
| // Set xsd element |
| if (variableElement.hasAttribute("element")) { |
| QName qName = BPELUtils.createAttributeValue(variableElement, "element"); |
| XSDElementDeclaration element = new XSDElementDeclarationProxy(getResource().getURI(), qName); |
| variable.setXSDElement(element); |
| } |
| |
| // from-spec |
| Element fromElement = getBPELChildElementByLocalName(variableElement, "from"); |
| if (fromElement != null) { |
| From from = BPELFactory.eINSTANCE.createFrom(); |
| from.setElement(fromElement); |
| |
| xml2From(from, fromElement); |
| variable.setFrom(from); |
| } |
| |
| xml2ExtensibleElement(variable,variableElement); |
| |
| return variable; |
| } |
| |
| /** |
| * Converts an XML faultHandler element to a BPEL FaultHandler object. |
| */ |
| protected FaultHandler xml2FaultHandler(Element faultHandlerElement) { |
| String localName = faultHandlerElement.getLocalName(); |
| if (!(localName.equals("faultHandlers") || |
| localName.equals("invoke"))) |
| return null; |
| |
| FaultHandler faultHandler = BPELFactory.eINSTANCE.createFaultHandler(); |
| |
| if (localName.equals("faultHandlers")) { |
| // This is "overloaded", what's the proper facade for the fault handler element in this case. |
| faultHandler.setElement(faultHandlerElement); |
| } |
| |
| // Save all the references to external namespaces |
| saveNamespacePrefix(faultHandler, faultHandlerElement); |
| |
| for(Element e : getBPELChildElementsByLocalName(faultHandlerElement, "catch")) { |
| faultHandler.getCatch().add( xml2Catch(e)); |
| } |
| |
| Element catchAllElement = getBPELChildElementByLocalName(faultHandlerElement, "catchAll"); |
| if (catchAllElement != null) { |
| CatchAll catchAll = xml2CatchAll(catchAllElement); |
| faultHandler.setCatchAll(catchAll); |
| } |
| |
| // Only do this for an element named faultHandlers. If the element is named |
| // invoke, then there really is no fault handler, only a series of catches. |
| if (faultHandlerElement.getLocalName().equals("faultHandlers")) { |
| xml2ExtensibleElement(faultHandler, faultHandlerElement); |
| } |
| |
| return faultHandler; |
| } |
| |
| /** |
| * Converts an XML catchAll element to a BPEL CatchAll object. |
| */ |
| protected CatchAll xml2CatchAll(Element catchAllElement) { |
| if (!catchAllElement.getLocalName().equals("catchAll")) |
| return null; |
| |
| CatchAll catchAll = BPELFactory.eINSTANCE.createCatchAll(); |
| catchAll.setElement(catchAllElement); |
| |
| // Save all the references to external namespaces |
| saveNamespacePrefix(catchAll, catchAllElement); |
| |
| for(Element e : getChildElements(catchAllElement)) { |
| Activity activity = xml2Activity(e); |
| if (activity != null) { |
| catchAll.setActivity(activity); |
| break; |
| } |
| } |
| |
| xml2ExtensibleElement(catchAll, catchAllElement); |
| |
| return catchAll; |
| } |
| |
| /** |
| * Converts an XML catch element to a BPEL Catch object. |
| */ |
| protected Catch xml2Catch(Element catchElement) { |
| Catch _catch = BPELFactory.eINSTANCE.createCatch(); |
| _catch.setElement(catchElement); |
| |
| // Save all the references to external namespaces |
| saveNamespacePrefix(_catch, catchElement); |
| |
| if (catchElement == null) return _catch; |
| |
| if (catchElement.hasAttribute("faultName")) { |
| QName qName = BPELUtils.createAttributeValue(catchElement, "faultName"); |
| _catch.setFaultName(qName); |
| } |
| |
| if (catchElement.hasAttribute("faultVariable")) { |
| // Set fault variable |
| Variable variable = BPELFactory.eINSTANCE.createVariable(); |
| // TODO: Should not this be the variable proxy ? |
| variable.setName(catchElement.getAttribute("faultVariable")); |
| _catch.setFaultVariable(variable); |
| } |
| |
| if (catchElement.hasAttribute("faultMessageType")) { |
| QName qName = BPELUtils.createAttributeValue(catchElement,"faultMessageType"); |
| Message messageType = new MessageProxy(getResource().getURI(), qName); |
| _catch.setFaultMessageType(messageType); |
| } |
| |
| if (catchElement.hasAttribute("faultElement")) { |
| QName qName = BPELUtils.createAttributeValue(catchElement,"faultElement"); |
| XSDElementDeclaration element = new XSDElementDeclarationProxy(getResource().getURI(), qName); |
| _catch.setFaultElement(element); |
| } |
| |
| // Set Activities |
| NodeList catchElements = catchElement.getChildNodes(); |
| |
| Element activityElement = null; |
| |
| if (catchElements != null && catchElements.getLength() > 0) { |
| |
| for (int i = 0; i < catchElements.getLength(); i++) { |
| if (catchElements.item(i).getNodeType() != Node.ELEMENT_NODE) { |
| continue; |
| } |
| |
| activityElement = (Element)catchElements.item(i); |
| Activity activity = xml2Activity(activityElement); |
| if (activity != null) { |
| _catch.setActivity(activity); |
| break; |
| } |
| } |
| } |
| |
| xml2ExtensibleElement(_catch, catchElement); |
| return _catch; |
| } |
| |
| /** |
| * Converts an XML activity element to a BPEL Activity object. |
| */ |
| public Activity xml2Activity(Element activityElement) { |
| Activity activity = null; |
| boolean checkExtensibility = true; |
| |
| if (!BPELUtils.isBPELElement(activityElement)) |
| return null; |
| |
| String localName = activityElement.getLocalName(); |
| if (localName.equals("process")){ |
| activity = getChildActivity(activityElement); |
| checkExtensibility = false; |
| } else if (localName.equals("receive")) { |
| activity = xml2Receive(activityElement); |
| } else if (localName.equals("reply")) { |
| activity = xml2Reply(activityElement); |
| } else if (localName.equals("invoke")) { |
| activity = xml2Invoke(activityElement); |
| } else if (localName.equals("assign")) { |
| activity = xml2Assign(activityElement); |
| } else if (localName.equals("throw")) { |
| activity = xml2Throw(activityElement); |
| } else if (localName.equals("exit")) { |
| activity = xml2Exit(activityElement); |
| } else if (localName.equals("wait")) { |
| activity = xml2Wait(activityElement); |
| } else if (localName.equals("empty")) { |
| activity = xml2Empty(activityElement); |
| } else if (localName.equals("sequence")) { |
| activity = xml2Sequence(activityElement); |
| } else if (localName.equals("if")) { |
| activity = xml2If(activityElement); |
| } else if (localName.equals("while")) { |
| activity = xml2While(activityElement); |
| } else if (localName.equals("pick")) { |
| activity = xml2Pick(activityElement); |
| } else if (localName.equals("flow")) { |
| activity = xml2Flow(activityElement); |
| } else if (localName.equals("scope")) { |
| activity = xml2Scope(activityElement); |
| } else if (localName.equals("compensate")) { |
| activity = xml2Compensate(activityElement); |
| } else if (localName.equals("compensateScope")) { |
| activity = xml2CompensateScope(activityElement); |
| } else if (localName.equals("rethrow")) { |
| activity = xml2Rethrow(activityElement); |
| } else if (localName.equals("extensionActivity")) { |
| // extensionActivity is a special case. It does not have any standard |
| // attributes or elements, nor is it an extensible element. |
| // Return immediately. |
| activity = xml2ExtensionActivity(activityElement); |
| return activity; |
| } else if (localName.equals("opaqueActivity")) { |
| activity = xml2OpaqueActivity(activityElement); |
| } else if (localName.equals("forEach")) { |
| activity = xml2ForEach(activityElement); |
| } else if (localName.equals("repeatUntil")) { |
| activity = xml2RepeatUntil(activityElement); |
| } else if (localName.equals("validate")) { |
| activity = xml2Validate(activityElement); |
| } else { |
| return null; |
| } |
| |
| setStandardElements(activityElement, activity); |
| |
| if (checkExtensibility) { |
| xml2ExtensibleElement(activity, activityElement); |
| // Save all the references to external namespaces |
| saveNamespacePrefix(activity, activityElement); |
| } |
| |
| return activity; |
| } |
| |
| protected void setStandardElements(Element activityElement, Activity activity) { |
| // Handle targets |
| Element targetsElement = getBPELChildElementByLocalName(activityElement, "targets"); |
| if (targetsElement != null) { |
| activity.setTargets(xml2Targets(targetsElement)); |
| } |
| |
| // Handle sources |
| Element sourcesElement = getBPELChildElementByLocalName(activityElement, "sources"); |
| if (sourcesElement != null) { |
| activity.setSources(xml2Sources(sourcesElement)); |
| } |
| } |
| |
| protected Targets xml2Targets(Element targetsElement) { |
| Targets targets = BPELFactory.eINSTANCE.createTargets(); |
| targets.setElement(targetsElement); |
| |
| for(Element e : getBPELChildElementsByLocalName(targetsElement, "target")) { |
| targets.getChildren().add( xml2Target(e)); |
| } |
| // Join condition |
| Element joinConditionElement = getBPELChildElementByLocalName(targetsElement, "joinCondition"); |
| if (joinConditionElement != null) { |
| targets.setJoinCondition(xml2Condition(joinConditionElement)); |
| } |
| xml2ExtensibleElement(targets, targetsElement); |
| |
| return targets; |
| } |
| |
| protected Target xml2Target(Element targetElement) { |
| |
| final Target target = BPELFactory.eINSTANCE.createTarget(); |
| target.setElement(targetElement); |
| |
| // Save all the references to external namespaces |
| saveNamespacePrefix(target, targetElement); |
| |
| xml2ExtensibleElement(target, targetElement); |
| |
| if (targetElement.hasAttribute("linkName")) { |
| final String linkName = targetElement.getAttribute("linkName"); |
| fPass2Runnables.add(new Runnable() { |
| public void run() { |
| Link link = getLink(target.getActivity(), linkName); |
| if (link != null) |
| target.setLink(link); |
| else |
| target.setLink(new LinkProxy(getResource().getURI(), linkName)); |
| } |
| }); |
| } |
| return target; |
| } |
| |
| protected Sources xml2Sources(Element sourcesElement) { |
| Sources sources = BPELFactory.eINSTANCE.createSources(); |
| sources.setElement(sourcesElement); |
| for(Element e : getBPELChildElementsByLocalName(sourcesElement, "source")) { |
| sources.getChildren().add( xml2Source(e)); |
| } |
| xml2ExtensibleElement(sources, sourcesElement); |
| |
| return sources; |
| } |
| |
| protected Source xml2Source(Element sourceElement) { |
| final String linkName = sourceElement.getAttribute("linkName"); |
| final Source source = BPELFactory.eINSTANCE.createSource(); |
| source.setElement(sourceElement); |
| |
| // Save all the references to external namespaces |
| saveNamespacePrefix(source, sourceElement); |
| |
| // Read transitionCondition element |
| Element transitionConditionElement = getBPELChildElementByLocalName(sourceElement, "transitionCondition"); |
| if (transitionConditionElement != null) { |
| Condition transitionCondition = xml2Condition(transitionConditionElement); |
| source.setTransitionCondition(transitionCondition); |
| } |
| |
| |
| xml2ExtensibleElement(source, sourceElement); |
| |
| fPass2Runnables.add(new Runnable() { |
| public void run() { |
| Link link = getLink(source.getActivity(), linkName); |
| if (link != null) |
| source.setLink(link); |
| else |
| source.setLink(new LinkProxy(getResource().getURI(), linkName)); |
| } |
| }); |
| return source; |
| } |
| |
| /** |
| * Converts an XML scope element to a BPEL Scope object. |
| */ |
| protected Activity xml2Scope(Element scopeElement) { |
| |
| Scope scope = BPELFactory.eINSTANCE.createScope(); |
| scope.setElement(scopeElement); |
| |
| //if (scopeElement == null) { |
| // return scope; |
| //} |
| |
| Attr name = scopeElement.getAttributeNode("name"); |
| |
| if (name != null && name.getSpecified()) { |
| scope.setName(name.getValue()); |
| } |
| |
| Attr isolated = scopeElement.getAttributeNode("isolated"); |
| |
| if (isolated != null && isolated.getSpecified()) |
| scope.setIsolated( Boolean.valueOf( isolated.getValue().equals("yes"))); |
| |
| // Handle attribute exitOnStandardFault |
| Attr exitOnStandardFault = scopeElement.getAttributeNode("exitOnStandardFault"); |
| if (exitOnStandardFault != null && exitOnStandardFault.getSpecified()) |
| scope.setExitOnStandardFault( Boolean.valueOf( exitOnStandardFault.getValue().equals("yes"))); |
| |
| // Handle Variables element |
| Element variablesElement = getBPELChildElementByLocalName(scopeElement, "variables"); |
| if (variablesElement != null) { |
| Variables variables = xml2Variables(variablesElement); |
| scope.setVariables(variables); |
| } |
| |
| // Handle CorrelationSet element |
| Element correlationSetsElement = getBPELChildElementByLocalName(scopeElement, "correlationSets"); |
| if (correlationSetsElement != null) { |
| CorrelationSets correlationSets = xml2CorrelationSets(correlationSetsElement); |
| scope.setCorrelationSets(correlationSets); |
| } |
| |
| // Handle PartnerLinks element |
| Element partnerLinksElement = getBPELChildElementByLocalName(scopeElement, "partnerLinks"); |
| if (partnerLinksElement != null) { |
| PartnerLinks partnerLinks = xml2PartnerLinks(partnerLinksElement); |
| scope.setPartnerLinks(partnerLinks); |
| } |
| |
| // MessageExchanges element |
| Element messageExchangesElement = getBPELChildElementByLocalName(scopeElement, "messageExchanges"); |
| if (messageExchangesElement != null) { |
| MessageExchanges messageExchanges = xml2MessageExchanges(messageExchangesElement); |
| scope.setMessageExchanges(messageExchanges); |
| } |
| |
| // Handle FaultHandler element |
| Element faultHandlerElement = getBPELChildElementByLocalName(scopeElement, "faultHandlers"); |
| if (faultHandlerElement != null) { |
| FaultHandler faultHandler = xml2FaultHandler(faultHandlerElement); |
| scope.setFaultHandlers(faultHandler); |
| } |
| |
| // Handle CompensationHandler element |
| setCompensationHandler(scopeElement, scope); |
| |
| // Handler TerminationHandler element |
| Element terminationHandlerElement = getBPELChildElementByLocalName(scopeElement, "terminationHandler"); |
| if (terminationHandlerElement != null) { |
| TerminationHandler terminationHandler = xml2TerminationHandler(terminationHandlerElement); |
| scope.setTerminationHandler(terminationHandler); |
| } |
| |
| // Handler EventHandler element |
| setEventHandler(scopeElement, scope); |
| |
| setStandardAttributes(scopeElement, scope); |
| |
| // Handle activities |
| NodeList scopeElements = scopeElement.getChildNodes(); |
| |
| Element activityElement = null; |
| |
| if (scopeElements != null && scopeElements.getLength() > 0) { |
| |
| for (int i = 0; i < scopeElements.getLength(); i++) { |
| if (scopeElements.item(i).getNodeType() != Node.ELEMENT_NODE) { |
| continue; |
| } |
| |
| activityElement = (Element)scopeElements.item(i); |
| |
| if (activityElement.getLocalName().equals("faultHandlers") || |
| activityElement.getLocalName().equals("compensationHandler")) |
| { |
| continue; |
| } |
| |
| Activity activity = xml2Activity(activityElement); |
| if (activity != null) { |
| scope.setActivity(activity); |
| break; |
| } |
| } |
| } |
| |
| return scope; |
| } |
| |
| /** |
| * Converts an XML flow element to a BPEL Flow object. |
| */ |
| protected Activity xml2Flow(Element flowElement) { |
| |
| Flow flow = BPELFactory.eINSTANCE.createFlow(); |
| flow.setElement(flowElement); |
| |
| // if (flowElement == null) { |
| // return flow; |
| // } |
| |
| Attr name = flowElement.getAttributeNode("name"); |
| |
| if (name != null && name.getSpecified()) |
| flow.setName(name.getValue()); |
| |
| Element linksElement = getBPELChildElementByLocalName(flowElement, "links"); |
| if (linksElement != null) { |
| Links links = xml2Links(linksElement); |
| flow.setLinks(links); |
| } |
| |
| Element completionConditionElement = getBPELChildElementByLocalName(flowElement, "completionCondition"); |
| if (completionConditionElement != null) { |
| CompletionCondition completionCondition = xml2CompletionCondition(completionConditionElement); |
| flow.setCompletionCondition(completionCondition); |
| } |
| |
| setStandardAttributes(flowElement, flow); |
| |
| NodeList flowElements = flowElement.getChildNodes(); |
| |
| Element activityElement = null; |
| |
| if (flowElements != null && flowElements.getLength() > 0) { |
| |
| for (int i = 0; i < flowElements.getLength(); i++) { |
| if ((flowElements.item(i).getNodeType() != Node.ELEMENT_NODE) || |
| ((Element)flowElements.item(i)).getLocalName().equals("links")) |
| continue; |
| |
| activityElement = (Element)flowElements.item(i); |
| Activity activity = xml2Activity(activityElement); |
| if (activity != null) { |
| flow.getActivities().add(activity); |
| } |
| } |
| } |
| |
| return flow; |
| } |
| |
| protected Links xml2Links(Element linksElement) { |
| if (!linksElement.getLocalName().equals("links")) |
| return null; |
| |
| Links links = BPELFactory.eINSTANCE.createLinks(); |
| links.setElement(linksElement); |
| |
| // Save all the references to external namespaces |
| saveNamespacePrefix(links, linksElement); |
| |
| for(Element e : getBPELChildElementsByLocalName(linksElement, "link")) { |
| links.getChildren().add( xml2Link (e)); |
| } |
| |
| // extensibility elements |
| xml2ExtensibleElement(links, linksElement); |
| |
| return links; |
| } |
| |
| /** |
| * Converts an XML link element to a BPEL Link object. |
| */ |
| protected Link xml2Link(Element linkElement) { |
| Link link = BPELFactory.eINSTANCE.createLink(); |
| link.setElement(linkElement); |
| |
| // Save all the references to external namespaces |
| saveNamespacePrefix(link, linkElement); |
| |
| Attr name = linkElement.getAttributeNode("name"); |
| |
| if (name != null && name.getSpecified()) |
| link.setName(name.getValue()); |
| |
| xml2ExtensibleElement(link,linkElement); |
| |
| return link; |
| } |
| |
| /** |
| * Converts an XML pick element to a BPEL Pick object. |
| */ |
| protected Activity xml2Pick(Element pickElement) { |
| Pick pick = BPELFactory.eINSTANCE.createPick(); |
| pick.setElement(pickElement); |
| |
| // Set name |
| Attr name = pickElement.getAttributeNode("name"); |
| |
| if (name != null && name.getSpecified()) |
| pick.setName(name.getValue()); |
| |
| // Set createInstance |
| Attr createInstance = pickElement.getAttributeNode("createInstance"); |
| |
| if (createInstance != null && createInstance.getSpecified()) |
| pick.setCreateInstance(Boolean.valueOf(createInstance.getValue().equals("yes") ? "True":"False")); |
| |
| NodeList pickElements = pickElement.getChildNodes(); |
| |
| Element pickInstanceElement = null; |
| |
| if (pickElements != null && pickElements.getLength() > 0) { |
| |
| for (int i = 0; i < pickElements.getLength(); i++) { |
| if (pickElements.item(i).getNodeType() != Node.ELEMENT_NODE) |
| continue; |
| |
| pickInstanceElement = (Element)pickElements.item(i); |
| |
| if (pickInstanceElement.getLocalName().equals("onAlarm")) { |
| OnAlarm onAlarm = xml2OnAlarm( pickInstanceElement ); |
| |
| pick.getAlarm().add(onAlarm); |
| } |
| else |
| if (pickInstanceElement.getLocalName().equals("onMessage")) { |
| OnMessage onMessage = xml2OnMessage(pickInstanceElement); |
| |
| pick.getMessages().add(onMessage); |
| } |
| } |
| } |
| |
| setStandardAttributes(pickElement, pick); |
| |
| return pick; |
| } |
| |
| /** |
| * Converts an XML eventHandler element to a BPEL eventHandler object. |
| */ |
| protected EventHandler xml2EventHandler(Element eventHandlerElement) { |
| EventHandler eventHandler = BPELFactory.eINSTANCE.createEventHandler(); |
| eventHandler.setElement(eventHandlerElement); |
| |
| // Save all the references to external namespaces |
| saveNamespacePrefix(eventHandler, eventHandlerElement); |
| |
| NodeList eventHandlerElements = eventHandlerElement.getChildNodes(); |
| Element eventHandlerInstanceElement = null; |
| if (eventHandlerElements != null && eventHandlerElements.getLength() > 0) { |
| |
| for (int i = 0; i < eventHandlerElements.getLength(); i++) { |
| if (eventHandlerElements.item(i).getNodeType() != Node.ELEMENT_NODE) |
| continue; |
| eventHandlerInstanceElement = (Element)eventHandlerElements.item(i); |
| |
| if (eventHandlerInstanceElement.getLocalName().equals("onAlarm")) { |
| OnAlarm onAlarm = xml2OnAlarm(eventHandlerInstanceElement); |
| eventHandler.getAlarm().add(onAlarm); |
| } |
| else if (eventHandlerInstanceElement.getLocalName().equals("onEvent")) { |
| OnEvent onEvent = xml2OnEvent(eventHandlerInstanceElement); |
| eventHandler.getEvents().add(onEvent); |
| } |
| } |
| } |
| |
| xml2ExtensibleElement(eventHandler, eventHandlerElement); |
| return eventHandler; |
| } |
| |
| /** |
| * Converts an XML onMessage element to a BPEL OnMessage object. |
| */ |
| protected OnMessage xml2OnMessage(Element onMessageElement) { |
| OnMessage onMessage = BPELFactory.eINSTANCE.createOnMessage(); |
| onMessage.setElement(onMessageElement); |
| |
| // Save all the references to external namespaces |
| saveNamespacePrefix(onMessage, onMessageElement); |
| |
| // Set several parms |
| setOperationParmsOnMessage(onMessageElement, onMessage); |
| |
| // Set activity |
| onMessage.setActivity(getChildActivity(onMessageElement)); |
| |
| // Set fromParts |
| Element fromPartsElement = getBPELChildElementByLocalName(onMessageElement, "fromParts"); |
| if (fromPartsElement != null) { |
| FromParts fromParts = xml2FromParts(fromPartsElement); |
| onMessage.setFromParts(fromParts); |
| } |
| |
| // Set messageExchange |
| setMessageExchange(onMessageElement, onMessage, BPELPackage.eINSTANCE.getOnMessage_MessageExchange()); |
| |
| xml2ExtensibleElement(onMessage, onMessageElement); |
| |
| return onMessage; |
| } |
| |
| /** |
| * Converts an XML onEvent element to a BPEL OnEvent object. |
| */ |
| protected OnEvent xml2OnEvent(Element onEventElement) { |
| OnEvent onEvent = BPELFactory.eINSTANCE.createOnEvent(); |
| onEvent.setElement(onEventElement); |
| |
| // Save all the references to external namespaces |
| saveNamespacePrefix(onEvent, onEventElement); |
| |
| // Set several parms |
| setOperationParmsOnEvent(onEventElement, onEvent); |
| |
| // Set activity |
| onEvent.setActivity(getChildActivity(onEventElement)); |
| |
| // Set fromParts |
| Element fromPartsElement = getBPELChildElementByLocalName(onEventElement, "fromParts"); |
| if (fromPartsElement != null) { |
| FromParts fromParts = xml2FromParts(fromPartsElement); |
| onEvent.setFromParts(fromParts); |
| } |
| |
| // Handle CorrelationSets Element |
| Element correlationSetsElement = getBPELChildElementByLocalName(onEventElement, "correlationSets"); |
| if (correlationSetsElement != null) |
| onEvent.setCorrelationSets(xml2CorrelationSets(correlationSetsElement)); |
| |
| // Set messageExchange |
| setMessageExchange(onEventElement, onEvent, BPELPackage.eINSTANCE.getOnEvent_MessageExchange()); |
| |
| xml2ExtensibleElement(onEvent, onEventElement); |
| |
| return onEvent; |
| } |
| |
| /** |
| * Converts an XML onAlarm element to a BPEL OnAlarm object. |
| */ |
| protected OnAlarm xml2OnAlarm(Element onAlarmElement) { |
| OnAlarm onAlarm = BPELFactory.eINSTANCE.createOnAlarm(); |
| onAlarm.setElement(onAlarmElement); |
| |
| // Save all the references to external namespaces |
| saveNamespacePrefix(onAlarm, onAlarmElement); |
| |
| // Set for element |
| Element forElement = getBPELChildElementByLocalName(onAlarmElement, "for"); |
| if (forElement != null) { |
| Expression expression = xml2Expression(forElement); |
| onAlarm.setFor(expression); |
| } |
| |
| // Set until element |
| Element untilElement = getBPELChildElementByLocalName(onAlarmElement, "until"); |
| if (untilElement != null) { |
| Expression expression = xml2Expression(untilElement); |
| onAlarm.setUntil(expression); |
| } |
| |
| // Set repeatEvery element |
| Element repeatEveryElement = getBPELChildElementByLocalName(onAlarmElement, "repeatEvery"); |
| if (repeatEveryElement != null) { |
| Expression expression = xml2Expression(repeatEveryElement); |
| onAlarm.setRepeatEvery(expression); |
| } |
| |
| // Set activity |
| onAlarm.setActivity(getChildActivity(onAlarmElement)); |
| |
| xml2ExtensibleElement(onAlarm, onAlarmElement); |
| |
| return onAlarm; |
| } |
| |
| /** |
| * Converts an XML while element to a BPEL While object. |
| */ |
| protected Activity xml2While(Element whileElement) { |
| While _while = BPELFactory.eINSTANCE.createWhile(); |
| _while.setElement(whileElement); |
| |
| // Handle condition element |
| Element conditionElement = getBPELChildElementByLocalName(whileElement, "condition"); |
| if (conditionElement != null) { |
| Condition condition = xml2Condition(conditionElement); |
| _while.setCondition(condition); |
| } |
| |
| NodeList whileElements = whileElement.getChildNodes(); |
| |
| Element activityElement = null; |
| |
| if (whileElements != null && whileElements.getLength() > 0) { |
| |
| for (int i = 0; i < whileElements.getLength(); i++) { |
| if (whileElements.item(i).getNodeType() != Node.ELEMENT_NODE) { |
| continue; |
| } |
| |
| activityElement = (Element) whileElements.item(i); |
| Activity activity = xml2Activity(activityElement); |
| if (activity != null) { |
| _while.setActivity(activity); |
| // only the first one |
| break ; |
| } |
| |
| } |
| } |
| |
| setStandardAttributes(whileElement, _while); |
| |
| return _while; |
| } |
| |
| /** |
| * Converts an XML terminationHandler element to a BPEL TerminationHandler object. |
| */ |
| protected TerminationHandler xml2TerminationHandler(Element terminationHandlerElement) { |
| TerminationHandler terminationHandler = BPELFactory.eINSTANCE.createTerminationHandler(); |
| terminationHandler.setElement(terminationHandlerElement); |
| |
| // Save all the references to external namespaces |
| saveNamespacePrefix(terminationHandler, terminationHandlerElement); |
| |
| terminationHandler.setActivity(getChildActivity(terminationHandlerElement)); |
| |
| xml2ExtensibleElement(terminationHandler, terminationHandlerElement); |
| |
| return terminationHandler; |
| } |
| |
| |
| |
| /** |
| * Converts an XML if element to a BPEL If object. |
| */ |
| protected Activity xml2If(Element ifElement) { |
| If _if = BPELFactory.eINSTANCE.createIf(); |
| _if.setElement(ifElement); |
| |
| // Set activity |
| Activity activity = getChildActivity(ifElement); |
| if (activity != null) { |
| _if.setActivity(activity); |
| } |
| |
| // Handle condition element |
| Element conditionElement = getBPELChildElementByLocalName(ifElement, "condition"); |
| if (conditionElement != null) { |
| Condition condition = xml2Condition(conditionElement); |
| _if.setCondition(condition); |
| } |
| |
| // Handle elseif |
| for(Element e : getBPELChildElementsByLocalName(ifElement, "elseif")) { |
| _if.getElseIf().add( xml2ElseIf ( e )); |
| } |
| |
| // Handle else |
| Element elseElement = getBPELChildElementByLocalName(ifElement, "else"); |
| if (elseElement != null) { |
| Else _else = xml2Else(elseElement); |
| _if.setElse(_else); |
| } |
| |
| setStandardAttributes(ifElement, _if); |
| |
| return _if; |
| } |
| |
| /** |
| * Converts an XML elseIf element to a BPEL ElseIf object. |
| */ |
| protected ElseIf xml2ElseIf(Element elseIfElement) { |
| ElseIf elseIf = BPELFactory.eINSTANCE.createElseIf(); |
| elseIf.setElement(elseIfElement); |
| |
| // Save all the references to external namespaces |
| saveNamespacePrefix(elseIf, elseIfElement); |
| |
| // Handle condition element |
| Element conditionElement = getBPELChildElementByLocalName(elseIfElement, "condition"); |
| if (conditionElement != null) { |
| Condition condition = xml2Condition(conditionElement); |
| elseIf.setCondition(condition); |
| } |
| |
| // Set activity |
| Activity activity = getChildActivity(elseIfElement); |
| if (activity != null) { |
| elseIf.setActivity(activity); |
| } |
| |
| return elseIf; |
| } |
| |
| /** |
| * Converts an XML condition element to a BPEL Condition object. |
| */ |
| protected Condition xml2Condition(Element conditionElement) { |
| Condition condition = BPELFactory.eINSTANCE.createCondition(); |
| condition.setElement(conditionElement); |
| xml2Expression(conditionElement, condition); |
| return condition; |
| } |
| |
| /** |
| * Converts an XML expression element to a BPEL Expression object. |
| * |
| * Accept a pre-constructed argument. This is good for sub-types |
| * of expression. |
| * |
| * Returns the second argument as a convenience. |
| * |
| */ |
| protected Expression xml2Expression(Element expressionElement, Expression expression) { |
| |
| // Save all the references to external namespaces |
| saveNamespacePrefix(expression, expressionElement); |
| |
| if (expressionElement == null) { |
| return expression; |
| } |
| |
| // Set expressionLanguage |
| if (expressionElement.hasAttribute("expressionLanguage")) { |
| expression.setExpressionLanguage(expressionElement.getAttribute("expressionLanguage")); |
| } |
| |
| // Set opaque |
| if (expressionElement.hasAttribute("opaque")) { |
| expression.setOpaque( Boolean.valueOf( expressionElement.getAttribute("opaque").equals("yes"))); |
| } |
| |
| String data = getText(expressionElement); |
| if (data != null) { |
| expression.setBody(data); |
| } |
| |
| return expression; |
| } |
| |
| /** |
| * Converts an XML expression element to a BPEL Expression object. |
| */ |
| protected Expression xml2Expression(Element expressionElement) { |
| Expression expression = BPELFactory.eINSTANCE.createExpression(); |
| expression.setElement(expressionElement); |
| |
| return xml2Expression(expressionElement, expression); |
| } |
| |
| protected Else xml2Else(Element elseElement) { |
| Else _else = BPELFactory.eINSTANCE.createElse(); |
| _else.setElement(elseElement); |
| |
| // Save all the references to external namespaces |
| saveNamespacePrefix(_else, elseElement); |
| |
| Activity activity = getChildActivity(elseElement); |
| _else.setActivity(activity); |
| |
| return _else; |
| } |
| |
| |
| /** |
| * Converts an XML sequence element to a BPEL Sequence object. |
| */ |
| protected Activity xml2Sequence(Element sequenceElement) { |
| Sequence sequence = BPELFactory.eINSTANCE.createSequence(); |
| sequence.setElement(sequenceElement); |
| |
| // Set name |
| Attr name = sequenceElement.getAttributeNode("name"); |
| |
| if (name != null && name.getSpecified()) { |
| sequence.setName(name.getValue()); |
| } |
| |
| NodeList sequenceElements = sequenceElement.getChildNodes(); |
| |
| Element activityElement = null; |
| |
| if (sequenceElements != null && sequenceElements.getLength() > 0) { |
| |
| for (int i = 0; i < sequenceElements.getLength(); i++) { |
| if (sequenceElements.item(i).getNodeType() != Node.ELEMENT_NODE) { |
| continue; |
| } |
| |
| activityElement = (Element)sequenceElements.item(i); |
| Activity activity = xml2Activity(activityElement); |
| if (activity != null) { |
| sequence.getActivities().add(activity); |
| } |
| } |
| } |
| |
| setStandardAttributes(sequenceElement, sequence); |
| |
| return sequence; |
| } |
| |
| /** |
| * Converts an XML empty element to a BPEL Empty object. |
| */ |
| protected Activity xml2Empty(Element emptyElement) { |
| Empty empty = BPELFactory.eINSTANCE.createEmpty(); |
| empty.setElement(emptyElement); |
| |
| setStandardAttributes(emptyElement, empty); |
| |
| return empty; |
| } |
| |
| /** |
| * Converts an XML opaqueActivity element to a BPEL OpaqueActivity object. |
| */ |
| protected Activity xml2OpaqueActivity(Element opaqueActivityElement) { |
| OpaqueActivity opaqueActivity = BPELFactory.eINSTANCE.createOpaqueActivity(); |
| opaqueActivity.setElement(opaqueActivityElement); |
| |
| setStandardAttributes(opaqueActivityElement, opaqueActivity); |
| |
| return opaqueActivity; |
| } |
| |
| /** |
| * Converts an XML valdateXML element to a BPEL ValidateXML object. |
| */ |
| protected Activity xml2Validate(Element validateElement) { |
| final Validate validate = BPELFactory.eINSTANCE.createValidate(); |
| validate.setElement(validateElement); |
| |
| setStandardAttributes(validateElement, validate); |
| if (validateElement.hasAttribute("variables")) { |
| String variables = validateElement.getAttribute("variables"); |
| StringTokenizer st = new StringTokenizer(variables); |
| |
| while (st.hasMoreTokens()) { |
| final String variableName = st.nextToken(); |
| // We must do this as a post load runnable because the variable might not |
| // exist yet. |
| fPass2Runnables.add(new Runnable() { |
| public void run() { |
| Variable targetVariable = getVariable(validate, variableName); |
| if (targetVariable == null) { |
| targetVariable = new VariableProxy(getResource().getURI(), variableName); |
| } |
| validate.getVariables().add(targetVariable); |
| } |
| }); |
| } |
| } |
| return validate; |
| } |
| |
| /** |
| * Converts an XML rethrow element to a BPEL Rethrow object. |
| */ |
| protected Activity xml2Rethrow(Element rethrowElement) { |
| Rethrow rethrow = BPELFactory.eINSTANCE.createRethrow(); |
| rethrow.setElement(rethrowElement); |
| |
| setStandardAttributes(rethrowElement, rethrow); |
| |
| return rethrow; |
| } |
| |
| /** |
| * Converts an XML extensionactivity element to a BPEL ExtensionActivity object. |
| */ |
| protected Activity xml2ExtensionActivity(Element extensionActivityElement) { |
| // Do not call setStandardAttributes here because extensionActivityElement |
| // doesn't have them. |
| Activity extensionActivity = BPELFactory.eINSTANCE.createExtensionActivity(); |
| |
| // Find the child element. |
| List<Element> nodeList = getChildElements(extensionActivityElement); |
| |
| if (nodeList.size() == 1) { |
| final Element child = nodeList.get(0); |
| // We found a child element. Look up a deserializer for this |
| // activity and call it. |
| String localName = child.getLocalName(); |
| String namespace = child.getNamespaceURI(); |
| final QName qname = new QName(namespace, localName); |
| final BPELActivityDeserializer deserializer = extensionRegistry.getActivityDeserializer(qname); |
| if (deserializer != null) { |
| // Deserialize the DOM element and return the new Activity |
| final Map<String,String> nsMap = getAllNamespacesForElement(child); |
| // https://bugs.eclipse.org/bugs/show_bug.cgi?id=334424 |
| extensionActivity = deserializer.unmarshall(qname,child,extensionActivity,process,nsMap,extensionRegistry, getResource().getURI(), this); |
| // Now let's do the standard attributes and elements |
| setStandardAttributes(child, extensionActivity); |
| setStandardElements(child, extensionActivity); |
| |
| // Don't do extensibility because extensionActivity is not extensible. |
| // If individual extensionActivity subclasses are actually extensible, they |
| // have to do this themselves in their deserializer. |
| |
| // The created Activity that extends from ExtensioActivity should get the |
| // whole <extensionActivity>-DOM-Fragment, this is done here. |
| extensionActivity.setElement(extensionActivityElement); |
| final Activity ea = extensionActivity; |
| |
| // Bug 120110 - run the deserializer again so it can resolve references to |
| // objects that were not fully realized in pass 1. |
| fPass2Runnables.add(new Runnable() { |
| public void run() { |
| deserializer.unmarshall(qname,child,ea,process,nsMap,extensionRegistry, getResource().getURI(), BPELReader.this); |
| } |
| }); |
| return extensionActivity; |
| } |
| } |
| // Fallback is to create a new extensionActivity. |
| // Bugzilla 324115 |
| setStandardAttributes(extensionActivityElement, extensionActivity); |
| setStandardElements(extensionActivityElement, extensionActivity); |
| extensionActivity.setElement(extensionActivityElement); |
| return extensionActivity; |
| } |
| |
| |
| /** |
| * Converts an XML wait element to a BPEL Wait object. |
| */ |
| protected Activity xml2Wait(Element waitElement) { |
| Wait wait = BPELFactory.eINSTANCE.createWait(); |
| wait.setElement(waitElement); |
| |
| // Set name |
| Attr name = waitElement.getAttributeNode("name"); |
| |
| if (name != null && name.getSpecified()) |
| wait.setName(name.getValue()); |
| |
| // Set for element |
| Element forElement = getBPELChildElementByLocalName(waitElement, "for"); |
| if (forElement != null) { |
| Expression expression = xml2Expression(forElement); |
| wait.setFor(expression); |
| } |
| |
| // Set until element |
| Element untilElement = getBPELChildElementByLocalName(waitElement, "until"); |
| if (untilElement != null) { |
| Expression expression = xml2Expression(untilElement); |
| wait.setUntil(expression); |
| } |
| |
| setStandardAttributes(waitElement, wait); |
| |
| return wait; |
| } |
| |
| /** |
| * Converts an XML exit element to a BPEL Exit object. |
| */ |
| protected Activity xml2Exit(Element exitElement) { |
| Exit exit = BPELFactory.eINSTANCE.createExit(); |
| exit.setElement(exitElement); |
| |
| Attr name = exitElement.getAttributeNode("name"); |
| |
| if (name != null && name.getSpecified()) |
| exit.setName(name.getValue()); |
| |
| setStandardAttributes(exitElement, exit); |
| |
| return exit; |
| } |
| |
| /** |
| * Converts an XML throw element to a BPEL Throw object. |
| */ |
| protected Activity xml2Throw(Element throwElement) { |
| Throw _throw = BPELFactory.eINSTANCE.createThrow(); |
| _throw.setElement(throwElement); |
| |
| if (throwElement.hasAttribute("name")) { |
| _throw.setName(throwElement.getAttribute("name")); |
| } |
| if (throwElement.hasAttribute("faultName")) { |
| QName qName = BPELUtils.createAttributeValue(throwElement, "faultName"); |
| _throw.setFaultName(qName); |
| } |
| |
| // Set fault variable name |
| setVariable(throwElement, _throw, "faultVariable", BPELPackage.eINSTANCE.getThrow_FaultVariable()); |
| |
| setStandardAttributes(throwElement, _throw); |
| |
| return _throw; |
| } |
| |
| /** |
| * Converts an XML assign element to a BPEL Assign object. |
| */ |
| protected Activity xml2Assign(Element assignElement) { |
| Assign assign = BPELFactory.eINSTANCE.createAssign(); |
| assign.setElement(assignElement); |
| |
| if (assignElement.hasAttribute("validate")) { |
| assign.setValidate( Boolean.valueOf( assignElement.getAttribute("validate").equals("yes"))); |
| } |
| |
| for (Element copyElement : getBPELChildElementsByLocalName(assignElement, "copy") ) { |
| assign.getCopy().add( xml2Copy ( copyElement )); |
| } |
| |
| setStandardAttributes(assignElement, assign); |
| |
| return assign; |
| } |
| |
| /** |
| * Converts an XML copy element to a BPEL Copy object. |
| */ |
| protected Copy xml2Copy(Element copyElement) { |
| Copy copy = BPELFactory.eINSTANCE.createCopy(); |
| copy.setElement(copyElement); |
| |
| |
| // Save all the references to external namespaces |
| saveNamespacePrefix(copy, copyElement); |
| |
| Element fromElement = getBPELChildElementByLocalName(copyElement, "from"); |
| if (fromElement != null) { |
| From from = BPELFactory.eINSTANCE.createFrom(); |
| from.setElement(fromElement); |
| |
| xml2From(from, fromElement); |
| copy.setFrom(from); |
| } |
| |
| Element toElement = getBPELChildElementByLocalName(copyElement, "to"); |
| if (toElement != null) { |
| To to = BPELFactory.eINSTANCE.createTo(); |
| to.setElement(toElement); |
| |
| xml2To(to, toElement); |
| copy.setTo(to); |
| } |
| |
| if (copyElement.hasAttribute("keepSrcElementName")) |
| copy.setKeepSrcElementName( Boolean.valueOf( copyElement.getAttribute("keepSrcElementName").equals("yes"))); |
| |
| if (copyElement.hasAttribute("ignoreMissingFromData")) |
| copy.setIgnoreMissingFromData( Boolean.valueOf( copyElement.getAttribute("ignoreMissingFromData").equals("yes"))); |
| |
| xml2ExtensibleElement(copy, copyElement); |
| |
| return copy; |
| } |
| |
| /** |
| * Converts an XML toPart element to a BPEL ToPart object. |
| */ |
| protected ToPart xml2ToPart(Element toPartElement) { |
| ToPart toPart = BPELFactory.eINSTANCE.createToPart(); |
| |
| toPart.setElement(toPartElement); |
| |
| // Save all the references to external namespaces |
| saveNamespacePrefix(toPart, toPartElement); |
| |
| // Set part |
| Attr part = toPartElement.getAttributeNode("part"); |
| |
| if (part != null && part.getSpecified()) { |
| final String partAttr = toPartElement.getAttribute("part"); |
| ((ToPartImpl) toPart).setPartName(partAttr); |
| } |
| |
| // Set fromVariable |
| setVariable(toPartElement, toPart, "fromVariable", BPELPackage.eINSTANCE.getToPart_FromVariable()); |
| |
| |
| return toPart; |
| } |
| |
| /** |
| * Converts an XML fromPart element to a BPEL FromPart object. |
| */ |
| protected FromPart xml2FromPart(Element fromPartElement) { |
| FromPart fromPart = BPELFactory.eINSTANCE.createFromPart(); |
| fromPart.setElement(fromPartElement); |
| |
| // Save all the references to external namespaces |
| saveNamespacePrefix(fromPart, fromPartElement); |
| |
| // Set part |
| Attr part = fromPartElement.getAttributeNode("part"); |
| |
| if (part != null && part.getSpecified()) { |
| final String partAttr = fromPartElement.getAttribute("part"); |
| ((FromPartImpl) fromPart).setPartName(partAttr); |
| } |
| |
| // Set toVariable |
| setVariable(fromPartElement, fromPart, "toVariable", BPELPackage.eINSTANCE.getFromPart_ToVariable()); |
| |
| return fromPart; |
| } |
| |
| /** |
| * Converts an XML "to" element to a BPEL To object. |
| */ |
| protected To xml2To(To to, Element toElement) { |
| // The to-spec MUST be one of the following variants: |
| // 1. <to variable="BPELVariableName" part="NCName"?> |
| // <query queryLanguage="anyURI"?>? |
| // queryContent |
| // </query> |
| // </to> |
| // |
| // 2. <to partnerLink="NCName" /> |
| // |
| // 3. <to variable="BPELVariableName" property="QName" /> |
| // |
| // 4. <to expressionLanguage="anyURI"?>expression</to> |
| // |
| // 5. <to/> |
| |
| // Save all the references to external namespaces |
| saveNamespacePrefix(to, toElement); |
| |
| // Set variable |
| Attr variable = toElement.getAttributeNode("variable"); |
| |
| if (variable != null && variable.getSpecified()) { |
| setVariable(toElement, to, "variable", BPELPackage.eINSTANCE.getAbstractAssignBound_Variable()); |
| } |
| |
| // Set part |
| Attr part = toElement.getAttributeNode("part"); |
| |
| if (part != null && part.getSpecified()) { |
| final String partAttr = toElement.getAttribute("part"); |
| ((ToImpl) to).setPartName(partAttr); |
| } |
| |
| // Set partnerLink |
| Attr partnerLink = toElement.getAttributeNode("partnerLink"); |
| |
| if (partnerLink != null && partnerLink.getSpecified()) { |
| setPartnerLink(toElement, to, BPELPackage.eINSTANCE.getAbstractAssignBound_PartnerLink()); |
| } |
| |
| // Set property |
| Attr property = toElement.getAttributeNode("property"); |
| |
| if (property != null && property.getSpecified()) { |
| setProperties(toElement, to, "property"); |
| } |
| |
| // Set query element |
| Element queryElement = getBPELChildElementByLocalName(toElement, "query"); |
| if (queryElement != null) { |
| Query queryObject = BPELFactory.eINSTANCE.createQuery(); |
| |
| queryObject.setElement(queryElement); |
| to.setQuery(queryObject); |
| |
| // Set queryLanguage |
| if (queryElement.hasAttribute("queryLanguage")) { |
| String queryLanguage = queryElement.getAttribute("queryLanguage"); |
| queryObject.setQueryLanguage(queryLanguage); |
| } |
| |
| // Set query text |
| // Get the condition text |
| String data = getText( queryElement ); |
| if (data != null) { |
| queryObject.setValue(data); |
| } |
| } else { |
| |
| if (partnerLink == null && variable == null){ |
| |
| // must be expression |
| Expression expressionObject = BPELFactory.eINSTANCE.createExpression(); |
| |
| to.setExpression(expressionObject); |
| |
| // Set expressionLanguage |
| if (toElement.hasAttribute("expressionLanguage")) { |
| expressionObject.setExpressionLanguage(toElement.getAttribute("expressionLanguage")); |
| } |
| |
| // Set expression text |
| // Get the condition text |
| String data = getText( toElement ); |
| if (data != null) { |
| expressionObject.setBody(data); |
| } |
| } |
| } |
| return to; |
| } |
| |
| /** |
| * Converts an XML "from" element to a BPEL From object. |
| */ |
| protected From xml2From(From from, Element fromElement) { |
| |
| /** This is basically what's in xml2To */ |
| |
| // Save all the references to external namespaces |
| saveNamespacePrefix(from, fromElement); |
| |
| // Set variable |
| Attr variable = fromElement.getAttributeNode("variable"); |
| |
| if (variable != null && variable.getSpecified()) { |
| setVariable(fromElement, from, "variable", BPELPackage.eINSTANCE.getAbstractAssignBound_Variable() ); |
| } |
| |
| // Set part |
| Attr part = fromElement.getAttributeNode("part"); |
| |
| if (part != null && part.getSpecified()) { |
| final String partAttr = fromElement.getAttribute("part"); |
| ((FromImpl) from).setPartName(partAttr); |
| } |
| |
| // Set partnerLink |
| Attr partnerLink = fromElement.getAttributeNode("partnerLink"); |
| |
| if (partnerLink != null && partnerLink.getSpecified()) { |
| setPartnerLink(fromElement, from, BPELPackage.eINSTANCE.getAbstractAssignBound_PartnerLink()); |
| } |
| |
| // Set property |
| Attr property = fromElement.getAttributeNode("property"); |
| |
| if (property != null && property.getSpecified()) { |
| setProperties(fromElement, from, "property"); |
| } |
| |
| // Set query element |
| Element queryElement = getBPELChildElementByLocalName(fromElement, "query"); |
| if (queryElement != null) { |
| Query queryObject = BPELFactory.eINSTANCE.createQuery(); |
| |
| queryObject.setElement(queryElement); |
| from.setQuery(queryObject); |
| |
| // Set queryLanguage |
| if (queryElement.hasAttribute("queryLanguage")) { |
| String queryLanguage = queryElement.getAttribute("queryLanguage"); |
| queryObject.setQueryLanguage(queryLanguage); |
| } |
| |
| // Set query text |
| // Get the condition text |
| String data = getText ( queryElement ); |
| if (data != null) { |
| queryObject.setValue(data); |
| } |
| } |
| |
| |
| Attr endpointReference = fromElement.getAttributeNode("endpointReference"); |
| |
| if (endpointReference != null && endpointReference.getSpecified()) { |
| from.setEndpointReference(EndpointReferenceRole.get(endpointReference.getValue())); |
| } |
| |
| // Set service-ref element |
| Element serviceRefElement = getBPELChildElementByLocalName(fromElement, "service-ref"); |
| Element literalElement = getBPELChildElementByLocalName(fromElement, "literal"); |
| |
| |
| if (serviceRefElement != null) { |
| |
| ServiceRef serviceRef = BPELFactory.eINSTANCE.createServiceRef(); |
| // TODO: ? serviceRef.setElement(serviceRefElement); |
| |
| from.setServiceRef(serviceRef); |
| |
| // Set reference scheme |
| if (serviceRefElement.hasAttribute("reference-scheme")) { |
| String scheme = serviceRefElement.getAttribute("reference-scheme"); |
| serviceRef.setReferenceScheme(scheme); |
| } |
| |
| // Set the value of the service reference |
| |
| // Determine whether or not there is an element in the child list. |
| Node candidateChild = null; |
| NodeList nodeList = serviceRefElement.getChildNodes(); |
| int length = nodeList.getLength(); |
| for (int i = 0; i < length; i++) { |
| Node child = nodeList.item(i); |
| if (child.getNodeType() == Node.ELEMENT_NODE) { |
| candidateChild = child; |
| break; |
| } |
| } |
| if (candidateChild == null) { |
| candidateChild = serviceRefElement.getFirstChild(); |
| } |
| String data = getText(candidateChild); |
| |
| if (data == null) { |
| // No text or CDATA node. If it's an element node, then |
| // deserialize and install. |
| if (candidateChild != null && candidateChild.getNodeType() == Node.ELEMENT_NODE) { |
| // Look if there's an ExtensibilityElement deserializer for this element |
| Element childElement = (Element)candidateChild; |
| QName qname = new QName(childElement.getNamespaceURI(), childElement.getLocalName()); |
| BPELExtensionDeserializer deserializer=null; |
| try { |
| deserializer = (BPELExtensionDeserializer)extensionRegistry.queryDeserializer(BPELExtensibleElement.class,qname); |
| } catch (WSDLException e) { |
| // nothing |
| } |
| |
| if (deserializer != null && !(deserializer instanceof BPELUnknownExtensionDeserializer)) { |
| // Deserialize the DOM element and add the new Extensibility element to the parent |
| // BPELExtensibleElement |
| try { |
| Map<String,String> nsMap = getAllNamespacesForElement(serviceRefElement); |
| ExtensibilityElement extensibilityElement=deserializer.unmarshall(BPELExtensibleElement.class,qname,childElement,process,nsMap,extensionRegistry,getResource().getURI(),this); |
| serviceRef.setValue(extensibilityElement); |
| } catch (WSDLException e) { |
| throw new WrappedException(e); |
| } |
| } else { |
| ServiceReferenceDeserializer referenceDeserializer = extensionRegistry.getServiceReferenceDeserializer(serviceRef.getReferenceScheme()); |
| if (referenceDeserializer != null) { |
| Object serviceReference = referenceDeserializer.unmarshall(childElement, process); |
| serviceRef.setValue(serviceReference); |
| } |
| } |
| } |
| } else { |
| serviceRef.setValue(data); |
| } |
| |
| } |
| |
| |
| // Literal node |
| if (literalElement != null) { |
| StringBuilder elementData = new StringBuilder(256); |
| |
| NodeList nl = literalElement.getChildNodes(); |
| |
| outer : for (int i=0; i < nl.getLength(); i++) { |
| |
| Node n = nl.item(i); |
| switch (n.getNodeType()) { |
| case Node.ELEMENT_NODE : |
| elementData.setLength(0); |
| elementData.append(BPELUtils.elementToString((Element)n)); |
| break outer; |
| |
| case Node.TEXT_NODE : |
| case Node.CDATA_SECTION_NODE : |
| // elementData.append( n.getTextContent() ); |
| elementData.append( getText(n) ); |
| break; |
| } |
| } |
| |
| from.setUnsafeLiteral(Boolean.FALSE); |
| String elementDataFinal = elementData.toString(); |
| if (isEmptyOrWhitespace(elementDataFinal) == false) { |
| from.setUnsafeLiteral(Boolean.TRUE); |
| from.setLiteral( elementDataFinal ); |
| } |
| |
| } else { |
| |
| // must be expression |
| Expression expressionObject = BPELFactory.eINSTANCE.createExpression(); |
| |
| from.setExpression(expressionObject); |
| |
| // Set expressionLanguage |
| if (fromElement.hasAttribute("expressionLanguage")) { |
| expressionObject.setExpressionLanguage(fromElement.getAttribute("expressionLanguage")); |
| } |
| |
| // Set expression text |
| // Get the condition text |
| String data = getText( fromElement ); |
| if (data != null) { |
| expressionObject.setBody(data); |
| } |
| } |
| |
| // Set opaque |
| Attr opaque = fromElement.getAttributeNode("opaque"); |
| |
| if (opaque != null && opaque.getSpecified()) { |
| from.setOpaque( Boolean.valueOf( opaque.getValue().equals("yes"))); |
| } |
| |
| |
| // See if there is an xsi:type attribue. |
| if (fromElement.hasAttribute("xsi:type")) { |
| QName qName = BPELUtils.createAttributeValue(fromElement, "xsi:type"); |
| XSDTypeDefinition type = new XSDTypeDefinitionProxy(getResource().getURI(), qName); |
| from.setType(type); |
| } |
| return from; |
| } |
| |
| |
| /** |
| * Converts an XML import element to a BPEL Import object. |
| */ |
| protected Import xml2Import(Element importElement) { |
| if (!importElement.getLocalName().equals("import")) |
| return null; |
| |
| Import imp = BPELFactory.eINSTANCE.createImport(); |
| imp.setElement(importElement); |
| |
| // Save all the references to external namespaces |
| saveNamespacePrefix(imp, importElement); |
| |
| // namespace |
| if (importElement.hasAttribute("namespace")) |
| imp.setNamespace(importElement.getAttribute("namespace")); |
| |
| // location |
| if (importElement.hasAttribute("location")) |
| imp.setLocation(importElement.getAttribute("location")); |
| |
| // importType |
| if (importElement.hasAttribute("importType")) |
| imp.setImportType(importElement.getAttribute("importType")); |
| |
| return imp; |
| } |
| |
| |
| /** |
| * Converts an XML invoke element to a BPEL Invoke object. |
| */ |
| protected Activity xml2Invoke(Element invokeElement) { |
| Invoke invoke = BPELFactory.eINSTANCE.createInvoke(); |
| invoke.setElement(invokeElement); |
| |
| // Set several parms |
| setStandardAttributes(invokeElement, invoke); |
| setOperationParms(invokeElement, invoke, null, BPELPackage.eINSTANCE.getInvoke_InputVariable(), BPELPackage.eINSTANCE.getInvoke_OutputVariable(), BPELPackage.eINSTANCE.getPartnerActivity_PartnerLink()); |
| |
| // Set compensationHandler |
| setCompensationHandler(invokeElement, invoke); |
| |
| // Set the fault handler (for catche-s and catchAll-s) |
| FaultHandler faultHandler = xml2FaultHandler(invokeElement); |
| if (faultHandler != null && (!faultHandler.getCatch().isEmpty() || faultHandler.getCatchAll() != null)) { |
| // Only set this on the activity if there is at least one catch clause, or a catchAll clause |
| invoke.setFaultHandler(faultHandler); |
| } |
| |
| Element toPartsElement = getBPELChildElementByLocalName(invokeElement, "toParts"); |
| if (toPartsElement != null) { |
| ToParts toParts = xml2ToParts(toPartsElement); |
| invoke.setToParts(toParts); |
| } |
| // Set fromParts |
| Element fromPartsElement = getBPELChildElementByLocalName(invokeElement, "fromParts"); |
| if (fromPartsElement != null) { |
| FromParts fromParts = xml2FromParts(fromPartsElement); |
| invoke.setFromParts(fromParts); |
| } |
| return invoke; |
| } |
| |
| |
| /** |
| * Converts an XML reply element to a BPEL Reply object. |
| */ |
| protected Activity xml2Reply(Element replyElement) { |
| Reply reply = BPELFactory.eINSTANCE.createReply(); |
| reply.setElement(replyElement); |
| |
| // Set several parms |
| setStandardAttributes(replyElement, reply); |
| setOperationParms(replyElement, reply, BPELPackage.eINSTANCE.getReply_Variable(), null, null, BPELPackage.eINSTANCE.getPartnerActivity_PartnerLink()); |
| |
| if (replyElement.hasAttribute("faultName")) { |
| QName qName = BPELUtils.createAttributeValue(replyElement, "faultName"); |
| reply.setFaultName(qName); |
| } |
| |
| Element toPartsElement = getBPELChildElementByLocalName(replyElement, "toParts"); |
| if (toPartsElement != null) { |
| ToParts toParts = xml2ToParts(toPartsElement); |
| reply.setToParts(toParts); |
| } |
| |
| // Set messageExchange |
| setMessageExchange(replyElement, reply, BPELPackage.eINSTANCE.getReply_MessageExchange()); |
| |
| return reply; |
| } |
| |
| |
| /** |
| * Converts an XML receive element to a BPEL Receive object. |
| */ |
| protected Activity xml2Receive(Element receiveElement) { |
| Receive receive = BPELFactory.eINSTANCE.createReceive(); |
| receive.setElement(receiveElement); |
| |
| // Set several parms |
| setStandardAttributes(receiveElement, receive); |
| setOperationParms(receiveElement, receive, BPELPackage.eINSTANCE.getReceive_Variable(), null, null, BPELPackage.eINSTANCE.getPartnerActivity_PartnerLink()); |
| |
| // Set createInstance |
| if (receiveElement.hasAttribute("createInstance")) { |
| String createInstance = receiveElement.getAttribute("createInstance"); |
| receive.setCreateInstance( Boolean.valueOf( createInstance.equals("yes"))); |
| } |
| |
| Element fromPartsElement = getBPELChildElementByLocalName(receiveElement, "fromParts"); |
| if (fromPartsElement != null) { |
| FromParts fromParts = xml2FromParts(fromPartsElement); |
| receive.setFromParts(fromParts); |
| } |
| |
| // Set messageExchange |
| setMessageExchange(receiveElement, receive, BPELPackage.eINSTANCE.getReceive_MessageExchange()); |
| |
| return receive; |
| } |
| |
| /** |
| * Sets a MessageExchange element for a given EObject. The given activity |
| * element must contain an attribute named "messageExchange". |
| * |
| * @param activityElement |
| * the DOM element of the activity |
| * @param eObject |
| * the EObject in which to set the partner link |
| */ |
| protected void setMessageExchange(Element activityElement, final EObject eObject, final EReference reference) { |
| if (!activityElement.hasAttribute("messageExchange")) { |
| return; |
| } |
| final String messageExchangeName = activityElement.getAttribute("messageExchange"); |
| |
| // We must do this as a post load runnable because the partner link might not |
| // exist yet. |
| fPass2Runnables.add(new Runnable() { |
| public void run() { |
| MessageExchange targetMessageExchange = BPELUtils.getMessageExchange(eObject, messageExchangeName); |
| if (targetMessageExchange == null) { |
| targetMessageExchange = new MessageExchangeProxy(getResource().getURI(), messageExchangeName); |
| } |
| eObject.eSet(reference, targetMessageExchange); |
| } |
| }); |
| } |
| |
| /** |
| * Converts an XML forEach element to a BPEL ForEach object. |
| */ |
| protected Activity xml2ForEach(Element forEachElement) { |
| ForEach forEach = BPELFactory.eINSTANCE.createForEach(); |
| forEach.setElement(forEachElement); |
| |
| // Set several parms |
| setStandardAttributes(forEachElement, forEach); |
| |
| if (forEachElement.hasAttribute("parallel")) { |
| forEach.setParallel(forEachElement.getAttribute("parallel").equals("yes")); |
| } |
| |
| // Set counterName variable |
| if (forEachElement.hasAttribute("counterName")) { |
| Variable variable = BPELFactory.eINSTANCE.createVariable(); |
| // TODO: How to facade this ? |
| variable.setName(forEachElement.getAttribute("counterName")); |
| QName qName = new QName(XSDConstants.SCHEMA_FOR_SCHEMA_URI_2001, "unsignedInt"); |
| XSDTypeDefinition type = new XSDTypeDefinitionProxy(getResource().getURI(), qName); |
| variable.setType(type); |
| forEach.setCounterName(variable); |
| } |
| |
| // Set startCounterValue element |
| Element startCounterValueElement = getBPELChildElementByLocalName(forEachElement, "startCounterValue"); |
| if (startCounterValueElement != null) { |
| Expression expression = xml2Expression(startCounterValueElement); |
| forEach.setStartCounterValue(expression); |
| } |
| |
| // Set finalCounterValue element |
| Element finalCounterValueElement = getBPELChildElementByLocalName(forEachElement, "finalCounterValue"); |
| if (finalCounterValueElement != null) { |
| Expression expression = xml2Expression(finalCounterValueElement); |
| forEach.setFinalCounterValue(expression); |
| } |
| |
| // Set completionCondition element |
| Element completionConditionElement = getBPELChildElementByLocalName(forEachElement, "completionCondition"); |
| if (completionConditionElement != null) { |
| CompletionCondition completionCondition = xml2CompletionCondition(completionConditionElement); |
| forEach.setCompletionCondition(completionCondition); |
| } |
| |
| // Set activity |
| Activity activity = getChildActivity(forEachElement); |
| if (activity instanceof Scope) { |
| forEach.setActivity(activity); |
| } |
| |
| return forEach; |
| } |
| |
| /** |
| * Converts an XML completionCondition element to a BPEL CompletionCondition object. |
| */ |
| protected CompletionCondition xml2CompletionCondition(Element completionConditionElement) { |
| CompletionCondition completionCondition = BPELFactory.eINSTANCE.createCompletionCondition(); |
| completionCondition.setElement(completionConditionElement); |
| |
| // Set branches element |
| Element branchesElement = getBPELChildElementByLocalName(completionConditionElement, "branches"); |
| if (branchesElement != null) { |
| Branches branches = xml2Branches(branchesElement); |
| completionCondition.setBranches(branches); |
| } |
| |
| return completionCondition; |
| } |
| |
| /** |
| * Converts an XML branches element to a BPEL Branches object. |
| */ |
| protected Branches xml2Branches(Element branchesElement) { |
| Branches branches = BPELFactory.eINSTANCE.createBranches(); |
| branches.setElement(branchesElement); |
| |
| xml2Expression(branchesElement, branches); |
| |
| if (branchesElement.hasAttribute("successfulBranchesOnly")) |
| branches.setCountCompletedBranchesOnly( Boolean.valueOf( branchesElement.getAttribute("successfulBranchesOnly").equals("yes"))); |
| |
| return branches; |
| } |
| |
| /** |
| * Converts an XML documentation element to a BPEL Documentation object. |
| */ |
| protected Documentation xml2Documentation(Element documentationElement) { |
| Documentation documentation = BPELFactory.eINSTANCE.createDocumentation(); |
| documentation.setElement(documentationElement); |
| |
| if (documentationElement.hasAttribute("xml:lang")) { |
| documentation.setLang(documentationElement.getAttribute("xml:lang")); |
| } |
| if (documentationElement.hasAttribute("source")) { |
| documentation.setSource(documentationElement.getAttribute("source")); |
| } |
| String text = getText(documentationElement); |
| if (text != null) { |
| documentation.setValue(text); |
| } |
| |
| return documentation; |
| } |
| |
| /** |
| * Converts an XML repeatUntil element to a BPEL RepeatUntil object. |
| */ |
| protected Activity xml2RepeatUntil(Element repeatUntilElement) { |
| RepeatUntil repeatUntil = BPELFactory.eINSTANCE.createRepeatUntil(); |
| repeatUntil.setElement(repeatUntilElement); |
| |
| // Set several parms |
| setStandardAttributes(repeatUntilElement, repeatUntil); |
| |
| // Handle condition element |
| Element conditionElement = getBPELChildElementByLocalName(repeatUntilElement, "condition"); |
| if (conditionElement != null) { |
| Condition condition = xml2Condition(conditionElement); |
| repeatUntil.setCondition(condition); |
| } |
| |
| NodeList repeatUntilElements = repeatUntilElement.getChildNodes(); |
| |
| Element activityElement = null; |
| |
| if (repeatUntilElements != null && repeatUntilElements.getLength() > 0) { |
| for (int i = 0; i < repeatUntilElements.getLength(); i++) { |
| |
| if (repeatUntilElements.item(i).getNodeType() != Node.ELEMENT_NODE) { |
| continue; |
| } |
| |
| activityElement = (Element)repeatUntilElements.item(i); |
| Activity activity = xml2Activity(activityElement); |
| if (activity != null) { |
| repeatUntil.setActivity(activity); |
| break; |
| } |
| } |
| } |
| |
| return repeatUntil; |
| } |
| |
| protected Correlations xml2Correlations(Element correlationsElement) { |
| if (!correlationsElement.getLocalName().equals("correlations")) |
| return null; |
| |
| Correlations correlations = BPELFactory.eINSTANCE.createCorrelations(); |
| correlations.setElement(correlationsElement); |
| |
| // Save all the references to external namespaces |
| saveNamespacePrefix(correlations, correlationsElement); |
| |
| for(Element e : getBPELChildElementsByLocalName(correlationsElement, "correlation")) { |
| correlations.getChildren().add( xml2Correlation(e)); |
| } |
| |
| // extensibility elements |
| xml2ExtensibleElement(correlations, correlationsElement); |
| |
| return correlations; |
| } |
| |
| /** |
| * Converts an XML correlation element to a BPEL Correlation object. |
| */ |
| protected Correlation xml2Correlation(Element correlationElement) { |
| final Correlation correlation = BPELFactory.eINSTANCE.createCorrelation(); |
| correlation.setElement(correlationElement); |
| |
| // Save all the references to external namespaces |
| saveNamespacePrefix(correlation, correlationElement); |
| |
| if (correlationElement == null) return correlation; |
| |
| // Set set |
| if (correlationElement.hasAttribute("set")) { |
| final String correlationSetName = correlationElement.getAttribute("set"); |
| fPass2Runnables.add(new Runnable() { |
| public void run() { |
| CorrelationSet cSet = BPELUtils.getCorrelationSetForActivity(correlation, correlationSetName); |
| if (cSet == null) { |
| cSet = new CorrelationSetProxy(getResource().getURI(), correlationSetName); |
| } |
| correlation.setSet(cSet); |
| } |
| }); |
| } |
| |
| |
| // Set initiation |
| Attr initiation = correlationElement.getAttributeNode("initiate"); |
| if (initiation != null && initiation.getSpecified()) { |
| if (initiation.getValue().equals("yes")) |
| correlation.setInitiate("yes"); |
| else if (initiation.getValue().equals("no")) |
| correlation.setInitiate("no"); |
| else if (initiation.getValue().equals("join")) |
| correlation.setInitiate("join"); |
| } |
| |
| // Set pattern |
| Attr pattern = correlationElement.getAttributeNode("pattern"); |
| |
| if (pattern != null && pattern.getSpecified()) { |
| if (pattern.getValue().equals("request")) |
| correlation.setPattern(CorrelationPattern.REQUEST_LITERAL); |
| else if (pattern.getValue().equals("response")) |
| correlation.setPattern(CorrelationPattern.RESPONSE_LITERAL); |
| else if (pattern.getValue().equals("request-response")) |
| correlation.setPattern(CorrelationPattern.REQUESTRESPONSE_LITERAL); |
| } |
| |
| xml2ExtensibleElement(correlation, correlationElement); |
| |
| return correlation; |
| } |
| |
| protected Compensate xml2Compensate(Element compensateElement) { |
| final Compensate compensate = BPELFactory.eINSTANCE.createCompensate(); |
| compensate.setElement(compensateElement); |
| setStandardAttributes(compensateElement, compensate); |
| return compensate; |
| } |
| |
| |
| protected CompensateScope xml2CompensateScope (Element compensateScopeElement) { |
| |
| final CompensateScope compensateScope = BPELFactory.eINSTANCE.createCompensateScope(); |
| compensateScope.setElement(compensateScopeElement); |
| |
| final String target = compensateScopeElement.getAttribute("target"); |
| |
| if (target != null && target.length() > 0) { |
| fPass2Runnables.add(new Runnable() { |
| public void run() { |
| compensateScope.setTarget(target); |
| } |
| }); |
| } |
| |
| setStandardAttributes(compensateScopeElement, compensateScope); |
| |
| return compensateScope; |
| } |
| |
| /** |
| * Converts an XML extensible element to a BPEL extensible element |
| */ |
| |
| protected void xml2ExtensibleElement (BPELExtensibleElement extensibleElement, Element element) { |
| |
| if (extensionRegistry == null) { |
| return; |
| } |
| |
| // Handle the documentation element first |
| Element documentationElement = getBPELChildElementByLocalName(element, "documentation"); |
| if (documentationElement != null) { |
| Documentation documentation = xml2Documentation(documentationElement); |
| extensibleElement.setDocumentation(documentation); |
| } |
| |
| // Get the child nodes, elements and attributes |
| List<Node> nodes=new ArrayList<Node>(); |
| |
| NodeList nodeList = element.getChildNodes(); |
| for (int i=0, n=nodeList.getLength(); i<n; i++) { |
| if (nodeList.item(i) instanceof Element) { |
| final String namespaceURI = ((Element)nodeList.item(i)).getNamespaceURI(); |
| if (!(BPELConstants.isBPELNamespace(namespaceURI))) |
| nodes.add(nodeList.item(i)); |
| } |
| } |
| |
| NamedNodeMap nodeMap=element.getAttributes(); |
| for (int i=0, n=nodeMap.getLength(); i<n; i++) { |
| Attr attr = (Attr)nodeMap.item(i); |
| if (attr.getNamespaceURI() != null && !attr.getNamespaceURI().equals(XSDConstants.XMLNS_URI_2000)) { |
| nodes.add(attr); |
| } |
| } |
| |
| for (Node node : nodes ) { |
| |
| // TODO What is this check for? If we're actually checking for |
| // the BPEL namespace, use BPELConstants instead. |
| if (MessagepropertiesConstants.isMessagePropertiesNamespace(node.getNamespaceURI())) { |
| continue; |
| } |
| |
| if (node.getNodeType() == Node.ELEMENT_NODE) { |
| deserialize ( extensibleElement, (Element) node); |
| } else if (node.getNodeType() == Node.ATTRIBUTE_NODE) { |
| deserialize ( extensibleElement, (Attr) node); |
| } |
| } |
| } |
| |
| |
| protected void deserialize ( BPELExtensibleElement ee, Element elm ) { |
| |
| QName qname = new QName(elm.getNamespaceURI(),elm.getLocalName()); |
| BPELExtensionDeserializer deserializer = null; |
| try { |
| deserializer = (BPELExtensionDeserializer)extensionRegistry.queryDeserializer (BPELExtensibleElement.class,qname); |
| } catch (WSDLException e) { |
| // we don't have one. |
| } |
| if (deserializer == null) { |
| return ; |
| } |
| // Deserialize the DOM element and add the new Extensibility element to the parent |
| // BPELExtensibleElement |
| Map<String,String> nsMap = getAllNamespacesForElement (elm); |
| try { |
| ExtensibilityElement extensibilityElement = deserializer.unmarshall(ee.getClass(),qname,elm,process,nsMap,extensionRegistry,getResource().getURI(),this); |
| ee.addExtensibilityElement(extensibilityElement); |
| } catch (WSDLException e) { |
| throw new WrappedException(e); |
| } |
| } |
| |
| |
| protected void deserialize ( BPELExtensibleElement ee, Attr attr) { |
| |
| if (attr.getSpecified() == false) { |
| return ; |
| } |
| |
| QName qname = new QName (attr.getNamespaceURI(),"extensibilityAttributes"); |
| BPELExtensionDeserializer deserializer = null; |
| try { |
| deserializer = (BPELExtensionDeserializer) extensionRegistry.queryDeserializer(BPELExtensibleElement.class,qname); |
| } catch (WSDLException e) { |
| // ignore |
| } |
| if (deserializer == null) { |
| return ; |
| } |
| |
| // Create a temp element to host the extensibility attribute |
| // |
| // This turns something that looks like this: |
| // <bpws:X someNS:Y="Z"/> |
| // into something that looks like this: |
| // <someNS:extensibilityAttributes xmlns:someNS="http://the.namespace" Y="Z"/> |
| |
| Element tempElement = attr.getOwnerDocument().createElementNS(attr.getNamespaceURI(), attr.getPrefix() + ":extensibilityAttributes"); |
| tempElement.setAttribute(BPELUtils.ATTR_XMLNS + ":" + attr.getPrefix(), attr.getNamespaceURI()); |
| tempElement.setAttribute(attr.getLocalName(), attr.getNodeValue()); |
| |
| // Deserialize the temp DOM element and add the new Extensibility element to the parent |
| // BPELExtensibleElement |
| Map<String,String> nsMap = getAllNamespacesForElement( (Element) attr.getParentNode() ); |
| try { |
| ExtensibilityElement extensibilityElement = deserializer.unmarshall(BPELExtensibleElement.class,qname,tempElement,process,nsMap,extensionRegistry,getResource().getURI(),this); |
| if (extensibilityElement!=null) { |
| ee.addExtensibilityElement (extensibilityElement); |
| } |
| } catch (WSDLException e) { |
| throw new WrappedException(e); |
| } |
| } |
| |
| /** |
| * Checks for process type |
| * @param processElement |
| * @return true if process is abstract, false otherwise |
| */ |
| public boolean isAbstractProcess(Element processElement) |
| { |
| |
| if (processElement != null) { |
| Map<String, String> nsMap = this.getAllNamespacesForElement(processElement); |
| |
| if (nsMap.containsValue(BPELConstants.NAMESPACE_ABSTRACT_2007)) |
| { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * returns abstract process profile |
| * @param processElement |
| * @return namespace of abstract process profile |
| */ |
| public String getProfileNamespace(Element processElement) |
| { |
| if (processElement.getAttribute(BPELConstants.AT_ABSTRACT_PROFILES) != null){ |
| |
| return processElement.getAttribute(BPELConstants.AT_ABSTRACT_PROFILES); |
| } |
| return null; |
| } |
| |
| |
| /** |
| * Returns true if the string is either null or contains just whitespace. |
| * @param value |
| * @return true if empty or whitespace, false otherwise. |
| */ |
| |
| static public boolean isEmptyOrWhitespace( String value ) |
| { |
| if( value == null || value.length() == 0) { |
| return true; |
| } |
| for( int i = 0, j = value.length(); i < j; i++ ) |
| { |
| if( ! Character.isWhitespace( value.charAt(i) ) ) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| |
| /** |
| * Returns the text of the given node. If the node is an element node, its |
| * children text value is returned. Otherwise, the node is assumed to be |
| * the first child node and the siblings sequence is scanned. |
| * |
| * |
| */ |
| |
| String getText (Node node) { |
| |
| StringBuilder sb = new StringBuilder(128); |
| |
| if (node instanceof Element) { |
| node = ((Element)node).getFirstChild(); |
| } |
| |
| boolean bCData = false; |
| |
| while (node != null) { |
| switch (node.getNodeType()) { |
| case Node.TEXT_NODE : |
| if (bCData) { |
| break; |
| } |
| Text text = (Text) node; |
| sb.append(text.getData()); |
| break; |
| case Node.CDATA_SECTION_NODE : |
| if (bCData == false) { |
| sb.setLength(0); |
| bCData = true; |
| } |
| CDATASection cdata = (CDATASection) node; |
| sb.append( cdata.getData() ); |
| break; |
| } |
| node = node.getNextSibling(); |
| } |
| String data = sb.toString(); |
| if (isEmptyOrWhitespace(data)) { |
| return null; |
| } |
| return data; |
| } |
| |
| /** |
| * @param eObject |
| * @param variableName |
| * @return the resolved variable |
| */ |
| public static Variable getVariable(EObject eObject, String variableName) { |
| return VARIABLE_RESOLVER.getVariable(eObject, variableName); |
| } |
| |
| /** |
| * @param activity |
| * @param linkName |
| * @return the resolved link |
| */ |
| public static Link getLink(Activity activity, String linkName) { |
| return LINK_RESOLVER.getLink(activity, linkName); |
| } |
| |
| |
| |
| /** |
| * @see org.xml.sax.ErrorHandler#error(org.xml.sax.SAXParseException) |
| */ |
| @SuppressWarnings("boxing") |
| public void error (SAXParseException exception) { |
| |
| String message = java.text.MessageFormat.format( |
| "Error in {0} [{2}:{3}] {4}", |
| exception.getPublicId(), |
| exception.getSystemId(), |
| exception.getLineNumber(), |
| exception.getColumnNumber(), |
| exception.getLocalizedMessage() |
| ); |
| BPELPlugin.logMessage(message, exception, IStatus.ERROR); |
| // Bugzilla 324165 |
| // add the error to resource |
| if (fCurrentResource!=null) |
| fCurrentResource.getErrors().add(new SAXParseDiagnostic(exception, SAXParseDiagnostic.ERROR)); |
| } |
| |
| /** |
| * @see org.xml.sax.ErrorHandler#fatalError(org.xml.sax.SAXParseException) |
| */ |
| @SuppressWarnings("boxing") |
| public void fatalError(SAXParseException exception) { |
| String message = java.text.MessageFormat.format( |
| "Fatal Error in {0} [{2}:{3}] {4}", |
| exception.getPublicId(), |
| exception.getSystemId(), |
| exception.getLineNumber(), |
| exception.getColumnNumber(), |
| exception.getLocalizedMessage() |
| ); |
| BPELPlugin.logMessage(message, exception, IStatus.ERROR); |
| // Bugzilla 324165 |
| // add the error to resource |
| if (fCurrentResource!=null) |
| fCurrentResource.getErrors().add(new SAXParseDiagnostic(exception, SAXParseDiagnostic.FATAL_ERROR)); |
| } |
| |
| /** |
| * @see org.xml.sax.ErrorHandler#warning(org.xml.sax.SAXParseException) |
| */ |
| @SuppressWarnings("boxing") |
| public void warning (SAXParseException exception) { |
| String message = java.text.MessageFormat.format( |
| "Warning in {0} [{2}:{3}] {4}", |
| exception.getPublicId(), |
| exception.getSystemId(), |
| exception.getLineNumber(), |
| exception.getColumnNumber(), |
| exception.getLocalizedMessage() |
| ); |
| BPELPlugin.logMessage(message, exception, IStatus.WARNING); |
| |
| |
| // Bugzilla 324165 |
| // add the error to resource |
| if (fCurrentResource!=null) |
| fCurrentResource.getErrors().add(new SAXParseDiagnostic(exception, SAXParseDiagnostic.WARNING)); |
| } |
| } |