tuscany-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From adrianocrest...@apache.org
Subject svn commit: r653133 [10/33] - in /incubator/tuscany/sandbox/mobile-android: android-jdk-classes/ android-jdk-classes/src/ android-jdk-classes/src/javax/ android-jdk-classes/src/javax/xml/ android-jdk-classes/src/javax/xml/namespace/ android-jdk-classes...
Date Sat, 03 May 2008 20:52:58 GMT
Added: incubator/tuscany/sandbox/mobile-android/tuscany-assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/ComponentTypeProcessor.java
URL: http://svn.apache.org/viewvc/incubator/tuscany/sandbox/mobile-android/tuscany-assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/ComponentTypeProcessor.java?rev=653133&view=auto
==============================================================================
--- incubator/tuscany/sandbox/mobile-android/tuscany-assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/ComponentTypeProcessor.java (added)
+++ incubator/tuscany/sandbox/mobile-android/tuscany-assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/ComponentTypeProcessor.java Sat May  3 13:52:41 2008
@@ -0,0 +1,355 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.assembly.xml;
+
+import static javax.xml.stream.XMLStreamConstants.END_ELEMENT;
+import static javax.xml.stream.XMLStreamConstants.START_ELEMENT;
+
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.XMLStreamWriter;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.assembly.Binding;
+import org.apache.tuscany.sca.assembly.Callback;
+import org.apache.tuscany.sca.assembly.ComponentType;
+import org.apache.tuscany.sca.assembly.Contract;
+import org.apache.tuscany.sca.assembly.Extensible;
+import org.apache.tuscany.sca.assembly.Property;
+import org.apache.tuscany.sca.assembly.Reference;
+import org.apache.tuscany.sca.assembly.Service;
+import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor;
+import org.apache.tuscany.sca.contribution.resolver.ModelResolver;
+import org.apache.tuscany.sca.contribution.service.ContributionReadException;
+import org.apache.tuscany.sca.contribution.service.ContributionResolveException;
+import org.apache.tuscany.sca.contribution.service.ContributionWriteException;
+import org.apache.tuscany.sca.interfacedef.InterfaceContract;
+import org.apache.tuscany.sca.interfacedef.Operation;
+import org.apache.tuscany.sca.interfacedef.impl.OperationImpl;
+import org.apache.tuscany.sca.policy.IntentAttachPoint;
+import org.apache.tuscany.sca.policy.PolicyFactory;
+import org.apache.tuscany.sca.policy.PolicySetAttachPoint;
+import org.w3c.dom.Document;
+
+/**
+ * A componentType processor.
+ * 
+ * @version $Rev: 637192 $ $Date: 2008-03-14 11:13:01 -0700 (Fri, 14 Mar 2008) $
+ */
+public class ComponentTypeProcessor extends BaseAssemblyProcessor implements StAXArtifactProcessor<ComponentType> {
+    
+    /**
+     * Constructs a new componentType processor.
+     * @param factory
+     * @param policyFactory
+     * @param registry
+     */
+    public ComponentTypeProcessor(AssemblyFactory factory, PolicyFactory policyFactory, StAXArtifactProcessor extensionProcessor) {
+        super(factory, policyFactory, extensionProcessor);
+    }
+    
+    public ComponentType read(XMLStreamReader reader) throws ContributionReadException, XMLStreamException {
+        ComponentType componentType = null;
+        Service service = null;
+        Reference reference = null;
+        Contract contract = null;
+        Property property = null;
+        Callback callback = null;
+        QName name = null;
+        
+        // Read the componentType document
+        while (reader.hasNext()) {
+            int event = reader.getEventType();
+            switch (event) {
+                case START_ELEMENT:
+                    name = reader.getName();
+
+                    if (Constants.COMPONENT_TYPE_QNAME.equals(name)) {
+
+                        // Read a <componentType>
+                        componentType = assemblyFactory.createComponentType();
+                        componentType.setConstrainingType(readConstrainingType(reader));
+
+                    } else if (Constants.SERVICE_QNAME.equals(name)) {
+
+                        // Read a <service>
+                        service = assemblyFactory.createService();
+                        contract = service;
+                        service.setName(getString(reader, Constants.NAME));
+                        componentType.getServices().add(service);
+                        policyProcessor.readPolicies(service, reader);
+
+                    } else if (Constants.REFERENCE_QNAME.equals(name)) {
+
+                        // Read a <reference>
+                        reference = assemblyFactory.createReference();
+                        contract = reference;
+                        reference.setName(getString(reader, Constants.NAME));
+                        reference.setWiredByImpl(getBoolean(reader, Constants.WIRED_BY_IMPL));
+                        readMultiplicity(reference, reader);
+                        readTargets(reference, reader);
+                        componentType.getReferences().add(reference);
+                        policyProcessor.readPolicies(reference, reader);
+
+                    } else if (Constants.PROPERTY_QNAME.equals(name)) {
+
+                        // Read a <property>
+                        property = assemblyFactory.createProperty();
+                        readAbstractProperty(property, reader);
+                        policyProcessor.readPolicies(property, reader);
+                        
+                        // Read the property value
+                        Document value = readPropertyValue(property.getXSDElement(), property.getXSDType(), reader);
+                        property.setValue(value);
+                        
+                        componentType.getProperties().add(property);
+                        
+                    } else if (Constants.IMPLEMENTATION_QNAME.equals(name)) {
+                        
+                        // Read an <implementation> element
+                        policyProcessor.readPolicies(componentType, reader);
+                        
+                    } else if (Constants.CALLBACK_QNAME.equals(name)) {
+
+                        // Read a <callback>
+                        callback = assemblyFactory.createCallback();
+                        contract.setCallback(callback);
+                        policyProcessor.readPolicies(callback, reader);
+
+                    } else if (OPERATION.equals(name)) {
+
+                        // Read an <operation>
+                        Operation operation = new OperationImpl();
+                        operation.setName(getString(reader, NAME));
+                        operation.setUnresolved(true);
+                        if (callback != null) {
+                            policyProcessor.readPolicies(callback, operation, reader);
+                        } else {
+                            policyProcessor.readPolicies(contract, operation, reader);
+                        }
+                    } else {
+
+                        // Read an extension element
+                        Object extension = extensionProcessor.read(reader);
+                        if (extension != null) {
+                            if (extension instanceof InterfaceContract) {
+
+                                // <service><interface> and <reference><interface>
+                                contract.setInterfaceContract((InterfaceContract)extension);
+
+                            } else if (extension instanceof Binding) {
+
+                                // <service><binding> and <reference><binding>
+                                if (callback != null) {
+                                    callback.getBindings().add((Binding)extension);
+                                } else {
+                                    contract.getBindings().add((Binding)extension);
+                                }
+                            } else {
+                                
+                                // Add the extension element to the current element
+                                if (callback != null) {
+                                    callback.getExtensions().add(extension);
+                                } else if (contract != null) {
+                                    contract.getExtensions().add(extension);
+                                } else if (property != null) {
+                                    property.getExtensions().add(extension);
+                                } else {
+                                    if (componentType instanceof Extensible) {
+                                        ((Extensible)componentType).getExtensions().add(extension);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    break;
+
+                case END_ELEMENT:
+                    name = reader.getName();
+
+                    // Clear current state when reading reaching end element
+                    if (SERVICE_QNAME.equals(name)) {
+                        service = null;
+                        contract = null;
+                    } else if (REFERENCE_QNAME.equals(name)) {
+                        reference = null;
+                        contract = null;
+                    } else if (PROPERTY_QNAME.equals(name)) {
+                        property = null;
+                    } else if (CALLBACK_QNAME.equals(name)) {
+                        callback = null;
+                    }
+                    break;
+            }
+            
+            // Read the next element
+            if (reader.hasNext()) {
+                reader.next();
+            }
+        }
+        return componentType;
+    }
+    
+    public void write(ComponentType componentType, XMLStreamWriter writer) throws ContributionWriteException, XMLStreamException {
+        
+        // Write <componentType> element
+        writeStartDocument(writer, COMPONENT_TYPE,
+               writeConstrainingType(componentType));
+
+        // Write <service> elements
+        for (Service service : componentType.getServices()) {
+            writeStart(writer, SERVICE, new XAttr(NAME, service.getName()),
+                       policyProcessor.writePolicies(service));
+
+            if (service.getInterfaceContract() != null) {
+                extensionProcessor.write(service.getInterfaceContract(), writer);
+            }
+            
+            for (Binding binding: service.getBindings()) {
+                extensionProcessor.write(binding, writer);
+            }
+            
+            if (service.getCallback() != null) {
+                Callback callback = service.getCallback();
+                writeStart(writer, CALLBACK, policyProcessor.writePolicies(callback));
+
+                for (Binding binding: callback.getBindings()) {
+                    extensionProcessor.write(binding, writer);
+                }
+                for (Object extension: callback.getExtensions()) {
+                    extensionProcessor.write(extension, writer);
+                }
+                
+                writeEnd(writer);
+            }
+            
+            for (Object extension: service.getExtensions()) {
+                extensionProcessor.write(extension, writer);
+            }
+            
+            writeEnd(writer);
+        }
+
+        // Write <reference> elements
+        for (Reference reference : componentType.getReferences()) {
+            
+            writeStart(writer, REFERENCE,
+                  new XAttr(NAME, reference.getName()),
+                  writeTargets(reference),
+                  policyProcessor.writePolicies(reference));
+
+            extensionProcessor.write(reference.getInterfaceContract(), writer);
+            
+            for (Binding binding: reference.getBindings()) {
+                extensionProcessor.write(binding, writer);
+            }
+            
+            if (reference.getCallback() != null) {
+                Callback callback = reference.getCallback();
+                writeStart(writer, CALLBACK,
+                           policyProcessor.writePolicies(callback));
+
+                for (Binding binding: callback.getBindings()) {
+                    extensionProcessor.write(binding, writer);
+                }
+                for (Object extension: callback.getExtensions()) {
+                    extensionProcessor.write(extension, writer);
+                }
+                
+                writeEnd(writer);
+            }
+
+            for (Object extension: reference.getExtensions()) {
+                extensionProcessor.write(extension, writer);
+            }
+            
+            writeEnd(writer);
+        }
+
+        // Write <property> elements
+        for (Property property : componentType.getProperties()) {
+            writeStart(writer,
+                       PROPERTY,
+                       new XAttr(NAME, property.getName()),
+                       new XAttr(MUST_SUPPLY, property.isMustSupply()),
+                       new XAttr(MANY, property.isMany()),
+                       new XAttr(TYPE, property.getXSDType()),
+                       new XAttr(ELEMENT, property.getXSDElement()),
+                       policyProcessor.writePolicies(property));
+
+            // Write property value
+            writePropertyValue(property.getValue(), property.getXSDElement(), property.getXSDType(), writer);
+
+            // Write extensions
+            for (Object extension : property.getExtensions()) {
+                extensionProcessor.write(extension, writer);
+            }
+
+            writeEnd(writer);
+        }
+
+        // Write extension elements
+        if (componentType instanceof Extensible) {
+            for (Object extension: ((Extensible)componentType).getExtensions()) {
+                extensionProcessor.write(extension, writer);
+            }
+        }
+        
+        // Write <implementation> elements if the componentType has
+        // any intents or policySets
+        boolean writeImplementation = false;
+        if (componentType instanceof IntentAttachPoint) {
+            if (!((IntentAttachPoint)componentType).getRequiredIntents().isEmpty()) {
+                writeImplementation = true;
+            }
+        }
+        if (componentType instanceof PolicySetAttachPoint) {
+            if (!((PolicySetAttachPoint)componentType).getPolicySets().isEmpty()) {
+                writeImplementation = true;
+            }
+        }
+        if (writeImplementation) {
+            writeStart(writer, IMPLEMENTATION,
+                       policyProcessor.writePolicies(componentType));
+        }
+        
+        writeEndDocument(writer);
+    }
+    
+    public void resolve(ComponentType componentType, ModelResolver resolver) throws ContributionResolveException {
+
+        // Resolve component type services and references
+        resolveContracts(componentType.getServices(), resolver);
+        resolveContracts(componentType.getReferences(), resolver);
+        if ( componentType instanceof PolicySetAttachPoint ) {
+            resolveIntents(((PolicySetAttachPoint)componentType).getRequiredIntents(), resolver);
+            resolvePolicySets(((PolicySetAttachPoint)componentType).getPolicySets(), resolver);
+        }
+    }
+    
+    public QName getArtifactType() {
+        return COMPONENT_TYPE_QNAME;
+    }
+    
+    public Class<ComponentType> getModelType() {
+        return ComponentType.class;
+    }
+}

Added: incubator/tuscany/sandbox/mobile-android/tuscany-assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/CompositeDocumentProcessor.java
URL: http://svn.apache.org/viewvc/incubator/tuscany/sandbox/mobile-android/tuscany-assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/CompositeDocumentProcessor.java?rev=653133&view=auto
==============================================================================
--- incubator/tuscany/sandbox/mobile-android/tuscany-assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/CompositeDocumentProcessor.java (added)
+++ incubator/tuscany/sandbox/mobile-android/tuscany-assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/CompositeDocumentProcessor.java Sat May  3 13:52:41 2008
@@ -0,0 +1,174 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.assembly.xml;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URI;
+import java.net.URL;
+import java.net.URLConnection;
+import java.util.Collection;
+import java.util.Hashtable;
+import java.util.List;
+import java.util.Map;
+
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+
+import org.apache.tuscany.sca.assembly.Composite;
+import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor;
+import org.apache.tuscany.sca.contribution.processor.URLArtifactProcessor;
+import org.apache.tuscany.sca.contribution.resolver.ModelResolver;
+import org.apache.tuscany.sca.contribution.service.ContributionReadException;
+import org.apache.tuscany.sca.contribution.service.ContributionResolveException;
+import org.apache.tuscany.sca.definitions.SCADefinitions;
+import org.apache.tuscany.sca.policy.PolicySet;
+import org.apache.tuscany.sca.policy.util.PolicyComputationUtils;
+
+/**
+ * A composite processor.
+ * 
+ * @version $Rev: 643489 $ $Date: 2008-04-01 10:06:42 -0800 (Tue, 01 Apr 2008) $
+ */
+public class CompositeDocumentProcessor extends BaseAssemblyProcessor implements URLArtifactProcessor<Composite> {
+    private XMLInputFactory inputFactory;
+    private List scaDefnSink;
+    private Collection<PolicySet> domainPolicySets = null;
+    private int scaDefnsCount = 0;
+
+    /**
+     * Construct a new composite processor
+     * @param assemblyFactory
+     * @param policyFactory
+     * @param staxProcessor
+     */
+    public CompositeDocumentProcessor(StAXArtifactProcessor staxProcessor, XMLInputFactory inputFactory, List scaDefnsSink) {
+        super(null, null, staxProcessor);
+        this.inputFactory = inputFactory;
+        this.scaDefnSink = scaDefnsSink;
+    }
+
+    public Composite read(URL contributionURL, URI uri, URL url) throws ContributionReadException {
+        InputStream scdlStream = null;
+        try {
+            if (scaDefnSink != null ) {
+                fillDomainPolicySets(scaDefnSink);
+            }
+
+            
+            byte[] transformedArtifactContent = null;
+            try {
+                if ( domainPolicySets != null ) {
+                    transformedArtifactContent =
+                        PolicyComputationUtils.addApplicablePolicySets(url, domainPolicySets);
+                    scdlStream = new ByteArrayInputStream(transformedArtifactContent);
+                } else {
+                    URLConnection connection = url.openConnection();
+                    connection.setUseCaches(false);
+                    scdlStream = connection.getInputStream();
+                }
+            } catch ( Exception e ) {
+                throw new ContributionReadException(e);
+            }
+            
+            XMLStreamReader reader = inputFactory.createXMLStreamReader(scdlStream);
+            
+            reader.nextTag();
+            
+            // Read the composite model
+            Composite composite = (Composite)extensionProcessor.read(reader);
+            if (composite != null) {
+                composite.setURI(uri.toString());
+            }
+
+            // For debugging purposes, write it back to XML
+//            if (composite != null) {
+//                try {
+//                    ByteArrayOutputStream bos = new ByteArrayOutputStream();
+//                    XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
+//                    outputFactory.setProperty(XMLOutputFactory.IS_REPAIRING_NAMESPACES, Boolean.TRUE);
+//                    extensionProcessor.write(composite, outputFactory.createXMLStreamWriter(bos));
+//                    Document document = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(new ByteArrayInputStream(bos.toByteArray()));
+//                    OutputFormat format = new OutputFormat();
+//                    format.setIndenting(true);
+//                    format.setIndent(2);
+//                    XMLSerializer serializer = new XMLSerializer(System.out, format);
+//                    serializer.serialize(document);
+//                } catch (Exception e) {
+//                    e.printStackTrace();
+//                }
+//            }
+            
+            return composite;
+            
+        } catch (XMLStreamException e) {
+            throw new ContributionReadException(e);
+        } finally {
+            try {
+                if (scdlStream != null) {
+                    scdlStream.close();
+                    scdlStream = null;
+                }
+            } catch (IOException ioe) {
+                //ignore
+            }
+        }
+    }
+    
+    public void resolve(Composite composite, ModelResolver resolver) throws ContributionResolveException {
+        extensionProcessor.resolve(composite, resolver);
+    }
+
+    public String getArtifactType() {
+        return ".composite";
+    }
+    
+    public Class<Composite> getModelType() {
+        return Composite.class;
+    }
+    
+    private void fillDomainPolicySets(List scaDefnsSink) {
+        Map<QName, PolicySet> domainPolicySetMap = null;
+        if ( scaDefnsSink.size() > scaDefnsCount ) {
+        //if ( !scaDefnsSink.isEmpty() ) {
+            domainPolicySetMap = new Hashtable<QName, PolicySet>();
+            
+            if ( domainPolicySets != null ) {
+                for ( PolicySet policySet : domainPolicySets ) {
+                    domainPolicySetMap.put(policySet.getName(), policySet);
+                } 
+            }
+            
+            for ( Object object : scaDefnsSink ) {
+                if ( object instanceof SCADefinitions ) {
+                    for ( PolicySet policySet : ((SCADefinitions)object).getPolicySets() ) {
+                        domainPolicySetMap.put( policySet.getName(), policySet);
+                    }
+                }
+            }
+            domainPolicySets =  domainPolicySetMap.values();
+            //scaDefnsSink.clear();
+            scaDefnsCount = scaDefnsSink.size();
+        }
+    }
+}

Added: incubator/tuscany/sandbox/mobile-android/tuscany-assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/CompositeModelResolver.java
URL: http://svn.apache.org/viewvc/incubator/tuscany/sandbox/mobile-android/tuscany-assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/CompositeModelResolver.java?rev=653133&view=auto
==============================================================================
--- incubator/tuscany/sandbox/mobile-android/tuscany-assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/CompositeModelResolver.java (added)
+++ incubator/tuscany/sandbox/mobile-android/tuscany-assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/CompositeModelResolver.java Sat May  3 13:52:41 2008
@@ -0,0 +1,83 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.assembly.xml;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.xml.namespace.QName;
+
+import org.apache.tuscany.sca.assembly.Composite;
+import org.apache.tuscany.sca.contribution.Contribution;
+import org.apache.tuscany.sca.contribution.Import;
+import org.apache.tuscany.sca.contribution.ModelFactoryExtensionPoint;
+import org.apache.tuscany.sca.contribution.namespace.NamespaceImport;
+import org.apache.tuscany.sca.contribution.resolver.ModelResolver;
+
+/**
+ * A Model Resolver for Composite models.
+ *
+ * @version $Rev: 572482 $ $Date: 2007-09-03 18:28:31 -0700 (Mon, 03 Sep 2007) $
+ */
+public class CompositeModelResolver implements ModelResolver {
+
+    private Contribution contribution;
+    private Map<QName, Composite> map = new HashMap<QName, Composite>();
+    
+    public CompositeModelResolver(Contribution contribution, ModelFactoryExtensionPoint modelFactories) {
+        this.contribution = contribution;
+    }
+
+    public void addModel(Object resolved) {
+        Composite composite = (Composite)resolved;
+        map.put(composite.getName(), composite);
+    }
+    
+    public Object removeModel(Object resolved) {
+        return map.remove(((Composite)resolved).getName());
+    }
+    
+    public <T> T resolveModel(Class<T> modelClass, T unresolved) {
+        
+        // Lookup a definition for the given namespace
+        QName qname = ((Composite)unresolved).getName();
+        Composite resolved = (Composite) map.get(qname);
+        if (resolved != null) {
+            return modelClass.cast(resolved);
+        }
+        
+        // No definition found, delegate the resolution to the imports
+        for (Import import_ : this.contribution.getImports()) {
+            if (import_ instanceof NamespaceImport) {
+                NamespaceImport namespaceImport = (NamespaceImport)import_;
+                if (namespaceImport.getNamespace().equals(qname.getNamespaceURI())) {
+                    
+                    // Delegate the resolution to the import resolver
+                    resolved = namespaceImport.getModelResolver().resolveModel(Composite.class, (Composite)unresolved);
+                    if (!resolved.isUnresolved()) {
+                        return modelClass.cast(resolved);
+                    }
+                }
+            }
+        }
+        return (T)unresolved;
+    }
+    
+}

Added: incubator/tuscany/sandbox/mobile-android/tuscany-assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/CompositeProcessor.java
URL: http://svn.apache.org/viewvc/incubator/tuscany/sandbox/mobile-android/tuscany-assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/CompositeProcessor.java?rev=653133&view=auto
==============================================================================
--- incubator/tuscany/sandbox/mobile-android/tuscany-assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/CompositeProcessor.java (added)
+++ incubator/tuscany/sandbox/mobile-android/tuscany-assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/CompositeProcessor.java Sat May  3 13:52:41 2008
@@ -0,0 +1,989 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.assembly.xml;
+
+import static javax.xml.stream.XMLStreamConstants.END_ELEMENT;
+import static javax.xml.stream.XMLStreamConstants.START_ELEMENT;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.StringTokenizer;
+
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLStreamConstants;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.XMLStreamWriter;
+import javax.xml.xpath.XPath;
+import javax.xml.xpath.XPathExpressionException;
+import javax.xml.xpath.XPathFactory;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.assembly.Binding;
+import org.apache.tuscany.sca.assembly.Callback;
+import org.apache.tuscany.sca.assembly.Component;
+import org.apache.tuscany.sca.assembly.ComponentProperty;
+import org.apache.tuscany.sca.assembly.ComponentReference;
+import org.apache.tuscany.sca.assembly.ComponentService;
+import org.apache.tuscany.sca.assembly.Composite;
+import org.apache.tuscany.sca.assembly.CompositeReference;
+import org.apache.tuscany.sca.assembly.CompositeService;
+import org.apache.tuscany.sca.assembly.ConfiguredOperation;
+import org.apache.tuscany.sca.assembly.ConstrainingType;
+import org.apache.tuscany.sca.assembly.Contract;
+import org.apache.tuscany.sca.assembly.Implementation;
+import org.apache.tuscany.sca.assembly.OperationsConfigurator;
+import org.apache.tuscany.sca.assembly.Property;
+import org.apache.tuscany.sca.assembly.Reference;
+import org.apache.tuscany.sca.assembly.Service;
+import org.apache.tuscany.sca.assembly.Wire;
+import org.apache.tuscany.sca.contribution.Artifact;
+import org.apache.tuscany.sca.contribution.ContributionFactory;
+import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor;
+import org.apache.tuscany.sca.contribution.resolver.ModelResolver;
+import org.apache.tuscany.sca.contribution.service.ContributionReadException;
+import org.apache.tuscany.sca.contribution.service.ContributionResolveException;
+import org.apache.tuscany.sca.contribution.service.ContributionWriteException;
+import org.apache.tuscany.sca.interfacedef.InterfaceContract;
+import org.apache.tuscany.sca.interfacedef.InterfaceContractMapper;
+import org.apache.tuscany.sca.policy.Intent;
+import org.apache.tuscany.sca.policy.IntentAttachPointType;
+import org.apache.tuscany.sca.policy.PolicyFactory;
+import org.apache.tuscany.sca.policy.PolicySet;
+import org.apache.tuscany.sca.policy.PolicySetAttachPoint;
+import org.apache.tuscany.sca.policy.util.PolicyValidationException;
+import org.apache.tuscany.sca.policy.util.PolicyValidationUtils;
+import org.w3c.dom.Document;
+
+/**
+ * A composite processor. 
+ * 
+ * @version $Rev: 639226 $ $Date: 2008-03-20 02:45:37 -0700 (Thu, 20 Mar 2008) $
+ */
+public class CompositeProcessor extends BaseAssemblyProcessor implements StAXArtifactProcessor<Composite> {
+    // FIXME: to be refactored
+   // private XPathFactory xPathFactory = XPathFactory.newInstance();
+    
+    /**
+     * Construct a new composite processor
+     * 
+     * @param contributionFactory
+     * @param assemblyFactory
+     * @param policyFactory
+     * @param extensionProcessor
+     */
+    public CompositeProcessor(ContributionFactory contributionFactory,
+                              AssemblyFactory factory,
+                              PolicyFactory policyFactory,
+                              InterfaceContractMapper interfaceContractMapper,
+                              StAXArtifactProcessor extensionProcessor) {
+        super(contributionFactory, factory, policyFactory, extensionProcessor);
+        
+    }
+
+    /**
+     * Construct a new composite processor
+     * 
+     * @param contributionFactory
+     * @param assemblyFactory
+     * @param policyFactory
+     * @param extensionProcessor
+     */
+    public CompositeProcessor(ContributionFactory contributionFactory,
+                              AssemblyFactory factory,
+                              PolicyFactory policyFactory,
+                              StAXArtifactProcessor extensionProcessor) {
+        super(contributionFactory, factory, policyFactory, extensionProcessor);
+    }
+
+    public Composite read(XMLStreamReader reader) throws ContributionReadException, XMLStreamException {
+        Composite composite = null;
+        Composite include = null;
+        Component component = null;
+        Property property = null;
+        ComponentService componentService = null;
+        ComponentReference componentReference = null;
+        ComponentProperty componentProperty = null;
+        CompositeService compositeService = null;
+        CompositeReference compositeReference = null;
+        Contract contract = null;
+        Wire wire = null;
+        Callback callback = null;
+        QName name = null;
+
+        // Read the composite document
+        while (reader.hasNext()) {
+            int event = reader.getEventType();
+            switch (event) {
+                case START_ELEMENT:
+                    name = reader.getName();
+
+                    if (COMPOSITE_QNAME.equals(name)) {
+
+                        // Read a <composite>
+                        composite = assemblyFactory.createComposite();
+                        composite.setName(new QName(getString(reader, TARGET_NAMESPACE), getString(reader, NAME)));
+                        if(isSet(reader, AUTOWIRE)) {
+                            composite.setAutowire(getBoolean(reader, AUTOWIRE));
+                        }
+                        composite.setLocal(getBoolean(reader, LOCAL));
+                        composite.setConstrainingType(readConstrainingType(reader));
+                        policyProcessor.readPolicies(composite, reader);
+
+                    } else if (INCLUDE_QNAME.equals(name)) {
+
+                        // Read an <include>
+                        include = assemblyFactory.createComposite();
+                        include.setName(getQName(reader, NAME));
+                        include.setURI(getString(reader, URI));
+                        include.setUnresolved(true);
+                        composite.getIncludes().add(include);
+
+                    } else if (SERVICE_QNAME.equals(name)) {
+                        if (component != null) {
+
+                            // Read a <component><service>
+                            componentService = assemblyFactory.createComponentService();
+                            contract = componentService;
+                            componentService.setName(getString(reader, NAME));
+                            component.getServices().add(componentService);
+                            policyProcessor.readPolicies(contract, reader);
+                        } else {
+
+                            // Read a <composite><service>
+                            compositeService = assemblyFactory.createCompositeService();
+                            contract = compositeService;
+                            compositeService.setName(getString(reader, NAME));
+
+                            String promoted = getString(reader, PROMOTE);
+                            String promotedComponentName;
+                            String promotedServiceName;
+                            int s = promoted.indexOf('/');
+                            if (s == -1) {
+                                promotedComponentName = promoted;
+                                promotedServiceName = null;
+                            } else {
+                                promotedComponentName = promoted.substring(0, s);
+                                promotedServiceName = promoted.substring(s + 1);
+                            }
+
+                            Component promotedComponent = assemblyFactory.createComponent();
+                            promotedComponent.setUnresolved(true);
+                            promotedComponent.setName(promotedComponentName);
+                            compositeService.setPromotedComponent(promotedComponent);
+
+                            ComponentService promotedService = assemblyFactory.createComponentService();
+                            promotedService.setUnresolved(true);
+                            promotedService.setName(promotedServiceName);
+                            compositeService.setPromotedService(promotedService);
+
+                            composite.getServices().add(compositeService);
+                            policyProcessor.readPolicies(contract, reader);
+                        }
+
+                    } else if (REFERENCE_QNAME.equals(name)) {
+                        if (component != null) {
+                            // Read a <component><reference>
+                            componentReference = assemblyFactory.createComponentReference();
+                            contract = componentReference;
+                            componentReference.setName(getString(reader, NAME));
+                            readMultiplicity(componentReference, reader);
+                            if (isSet(reader, AUTOWIRE)) {
+                                componentReference.setAutowire(getBoolean(reader, AUTOWIRE));
+                            }
+                            readTargets(componentReference, reader);
+                            componentReference.setWiredByImpl(getBoolean(reader, WIRED_BY_IMPL));
+                            component.getReferences().add(componentReference);
+                            policyProcessor.readPolicies(contract, reader);
+                        } else {
+                            // Read a <composite><reference>
+                            compositeReference = assemblyFactory.createCompositeReference();
+                            contract = compositeReference;
+                            compositeReference.setName(getString(reader, NAME));
+                            readMultiplicity(compositeReference, reader);
+                            readTargets(compositeReference, reader);
+                            String promote = reader.getAttributeValue(null, Constants.PROMOTE);
+                            if (promote != null) {
+                                for (StringTokenizer tokens = new StringTokenizer(promote); tokens.hasMoreTokens();) {
+                                    ComponentReference promotedReference =
+                                        assemblyFactory.createComponentReference();
+                                    promotedReference.setUnresolved(true);
+                                    promotedReference.setName(tokens.nextToken());
+                                    compositeReference.getPromotedReferences().add(promotedReference);
+                                }
+                            }
+                            compositeReference.setWiredByImpl(getBoolean(reader, WIRED_BY_IMPL));
+                            composite.getReferences().add(compositeReference);
+                            policyProcessor.readPolicies(contract, reader);
+                        }
+
+                    } else if (PROPERTY_QNAME.equals(name)) {
+                        if (component != null) {
+
+                            // Read a <component><property>
+                            componentProperty = assemblyFactory.createComponentProperty();
+                            property = componentProperty;
+                            String source = getString(reader, SOURCE);
+                            if(source!=null) {
+                                source = source.trim();
+                            }
+                            componentProperty.setSource(source);
+                            if (source != null) {
+                                // $<name>/...
+                                if (source.charAt(0) == '$') {
+                                    int index = source.indexOf('/');
+                                    if (index == -1) {
+                                        // Tolerating $prop
+                                        source = source + "/";
+                                        index = source.length() - 1;
+                                    }
+                                    source = source.substring(index + 1);
+                                    if ("".equals(source)) {
+                                        source = ".";
+                                    }
+                                }
+                                
+                                throw new IllegalArgumentException("not implemented in Android!");
+                                
+                               /* XPath xpath = xPathFactory.newXPath();
+                                xpath.setNamespaceContext(reader.getNamespaceContext());
+                                try {
+                                    componentProperty.setSourceXPathExpression(xpath.compile(source));
+                                } catch (XPathExpressionException e) {
+                                    throw new ContributionReadException(e);
+                                }*/
+                            }
+                            componentProperty.setFile(getString(reader, FILE));
+                            policyProcessor.readPolicies(property, reader);
+                            readAbstractProperty(componentProperty, reader);
+                            
+                            // Read the property value
+                            Document value = readPropertyValue(property.getXSDElement(), property.getXSDType(), reader);
+                            property.setValue(value);
+                            
+                            component.getProperties().add(componentProperty);
+                        } else {
+
+                            // Read a <composite><property>
+                            property = assemblyFactory.createProperty();
+                            policyProcessor.readPolicies(property, reader);
+                            readAbstractProperty(property, reader);
+                            
+                            // Read the property value
+                            Document value = readPropertyValue(property.getXSDElement(), property.getXSDType(), reader);
+                            property.setValue(value);
+                            
+                            composite.getProperties().add(property);
+                        }
+                        
+                        // TUSCANY-1949
+                        // If the property doesn't have a value, the END_ELEMENT event is read by the readPropertyValue
+                        if (reader.getEventType() == END_ELEMENT && PROPERTY_QNAME.equals(reader.getName())) {
+                            property = null;
+                            componentProperty = null;
+                        }
+
+                    } else if (COMPONENT_QNAME.equals(name)) {
+
+                        // Read a <component>
+                        component = assemblyFactory.createComponent();
+                        component.setName(getString(reader, NAME));
+                        if (isSet(reader, AUTOWIRE)) {
+                            component.setAutowire(getBoolean(reader, AUTOWIRE));
+                        }
+                        if (isSet(reader, URI)) {
+                            component.setURI(getString(reader, URI));
+                        }
+                        component.setConstrainingType(readConstrainingType(reader));
+                        composite.getComponents().add(component);
+                        policyProcessor.readPolicies(component, reader);
+
+                    } else if (WIRE_QNAME.equals(name)) {
+
+                        // Read a <wire>
+                        wire = assemblyFactory.createWire();
+                        ComponentReference source = assemblyFactory.createComponentReference();
+                        source.setUnresolved(true);
+                        source.setName(getString(reader, SOURCE));
+                        wire.setSource(source);
+
+                        ComponentService target = assemblyFactory.createComponentService();
+                        target.setUnresolved(true);
+                        target.setName(getString(reader, TARGET));
+                        wire.setTarget(target);
+
+                        composite.getWires().add(wire);
+                        policyProcessor.readPolicies(wire, reader);
+
+                    } else if (CALLBACK_QNAME.equals(name)) {
+
+                        // Read a <callback>
+                        callback = assemblyFactory.createCallback();
+                        contract.setCallback(callback);
+                        policyProcessor.readPolicies(callback, reader);
+
+                    } else if (OPERATION_QNAME.equals(name)) {
+
+                        // Read an <operation>
+                        ConfiguredOperation operation = assemblyFactory.createConfiguredOperation();
+                        operation.setName(getString(reader, NAME));
+                        operation.setUnresolved(true);
+                        if (callback != null) {
+                            policyProcessor.readPolicies(operation, reader);
+                        } else {
+                            policyProcessor.readPolicies(operation, reader);
+                        }
+                        
+                        OperationsConfigurator opConfigurator = null;
+                        if ( compositeService != null ) {
+                            opConfigurator = compositeService;
+                        } else if ( componentService != null ) {
+                            opConfigurator = componentService;
+                        } else if ( compositeReference != null ) {
+                            opConfigurator = compositeReference;
+                        } else if ( componentReference != null ) {
+                            opConfigurator = componentReference;
+                        }
+                        
+                        opConfigurator.getConfiguredOperations().add(operation);
+                    } else if (IMPLEMENTATION_COMPOSITE_QNAME.equals(name)) {
+
+                        // Read an implementation.composite
+                        Composite implementation = assemblyFactory.createComposite();
+                        implementation.setName(getQName(reader, NAME));
+                        implementation.setUnresolved(true);
+                        component.setImplementation(implementation);
+                        policyProcessor.readPolicies(implementation, reader);
+                    } else {
+
+                        // Read an extension element
+                        Object extension = extensionProcessor.read(reader);
+                        if (extension != null) {
+                            if (extension instanceof InterfaceContract) {
+
+                                // <service><interface> and
+                                // <reference><interface>
+                                if (contract != null) {
+                                    contract.setInterfaceContract((InterfaceContract)extension);
+                                } else {
+                                    if (name.getNamespaceURI().equals(SCA10_NS)) {
+                                        throw new ContributionReadException(
+                                                                            "Unexpected <interface> element found. It should appear inside a <service> or <reference> element");
+                                    } else {
+                                        composite.getExtensions().add(extension);
+                                    }
+                                }
+                            } else if (extension instanceof Binding) {
+                                if ( extension instanceof PolicySetAttachPoint ) {
+                                    IntentAttachPointType bindingType = intentAttachPointTypeFactory.createBindingType();
+                                    bindingType.setName(name);
+                                    bindingType.setUnresolved(true);
+                                    ((PolicySetAttachPoint)extension).setType(bindingType);
+                                }
+                                // <service><binding> and
+                                // <reference><binding>
+                                if (callback != null) {
+                                    callback.getBindings().add((Binding)extension);
+                                } else {
+                                    if (contract != null) {
+                                        contract.getBindings().add((Binding)extension);
+                                    } else {
+                                        if (name.getNamespaceURI().equals(SCA10_NS)) {
+                                            throw new ContributionReadException(
+                                                                                "Unexpected <binding> element found. It should appear inside a <service> or <reference> element");
+                                        } else {
+                                            composite.getExtensions().add(extension);
+                                        }
+                                    }
+                                }
+
+                            } else if (extension instanceof Implementation) {
+                                if ( extension instanceof PolicySetAttachPoint ) {
+                                    IntentAttachPointType implType = intentAttachPointTypeFactory.createImplementationType();
+                                    implType.setName(name);
+                                    implType.setUnresolved(true);
+                                    ((PolicySetAttachPoint)extension).setType(implType);
+                                }
+                                // <component><implementation>
+                                if (component != null) {
+                                    component.setImplementation((Implementation)extension);
+                                } else {
+                                    if (name.getNamespaceURI().equals(SCA10_NS)) {
+                                        throw new ContributionReadException(
+                                                                            "Unexpected <implementation> element found. It should appear inside a <component> element");
+                                    } else {
+                                        composite.getExtensions().add(extension);
+                                    }
+                                }
+                            } else {
+
+                                // Add the extension element to the current
+                                // element
+                                if (callback != null) {
+                                    callback.getExtensions().add(extension);
+                                } else if (contract != null) {
+                                    contract.getExtensions().add(extension);
+                                } else if (property != null) {
+                                    property.getExtensions().add(extension);
+                                } else if (component != null) {
+                                    component.getExtensions().add(extension);
+                                } else {
+                                    composite.getExtensions().add(extension);
+                                }
+                            }
+                        }
+                    }
+                    break;
+
+                case XMLStreamConstants.CHARACTERS:
+                    break;
+
+                case END_ELEMENT:
+                    name = reader.getName();
+
+                    // Clear current state when reading reaching end element
+                    if (SERVICE_QNAME.equals(name)) {
+                        componentService = null;
+                        compositeService = null;
+                        contract = null;
+                    } else if (INCLUDE_QNAME.equals(name)) {
+                        include = null;
+                    } else if (REFERENCE_QNAME.equals(name)) {
+                        componentReference = null;
+                        compositeReference = null;
+                        contract = null;
+                    } else if (PROPERTY_QNAME.equals(name)) {
+                        componentProperty = null;
+                        property = null;
+                    } else if (COMPONENT_QNAME.equals(name)) {
+                        component = null;
+                    } else if (WIRE_QNAME.equals(name)) {
+                        wire = null;
+                    } else if (CALLBACK_QNAME.equals(name)) {
+                        callback = null;
+                    }
+                    break;
+            }
+
+            // Read the next element
+            if (reader.hasNext()) {
+                reader.next();
+            }
+        }
+        return composite;
+    }
+
+    public void write(Composite composite, XMLStreamWriter writer) throws ContributionWriteException, XMLStreamException {
+
+        // Write <composite> element
+        writeStartDocument(writer,
+                           COMPOSITE,
+                           writeConstrainingType(composite),
+                           new XAttr(TARGET_NAMESPACE, composite.getName().getNamespaceURI()),
+                           new XAttr(NAME, composite.getName().getLocalPart()),
+                           new XAttr(AUTOWIRE, composite.getAutowire()),
+                           policyProcessor.writePolicies(composite));
+
+        // Write <include> elements
+        for (Composite include : composite.getIncludes()) {
+            String uri = include.isUnresolved()? include.getURI() : null;
+            writeStart(writer,
+                       INCLUDE,
+                       new XAttr(NAME, include.getName()),
+                       new XAttr(URI, uri));
+            writeEnd(writer);
+        }
+
+        // Write <service> elements
+        for (Service service : composite.getServices()) {
+            CompositeService compositeService = (CompositeService)service;
+            Component promotedComponent = compositeService.getPromotedComponent();
+            ComponentService promotedService = compositeService.getPromotedService();
+            String promote;
+            if (promotedService != null) {
+                if (promotedService.getName() != null) {
+                    promote = promotedComponent.getName() + '/' + promotedService.getService();
+                } else {
+                    promote = promotedComponent.getName();
+                }
+            } else {
+                promote = null;
+            }
+            writeStart(writer, SERVICE, new XAttr(NAME, service.getName()), new XAttr(PROMOTE, promote),
+                       policyProcessor.writePolicies(service));
+            
+            // Write service interface
+            extensionProcessor.write(service.getInterfaceContract(), writer);
+
+            // Write bindings
+            for (Binding binding : service.getBindings()) {
+                extensionProcessor.write(binding, writer);
+            }
+
+            // Write <callback> element
+            if (service.getCallback() != null) {
+                Callback callback = service.getCallback();
+                writeStart(writer, CALLBACK,
+                           policyProcessor.writePolicies(callback));
+            
+                // Write callback bindings
+                for (Binding binding : callback.getBindings()) {
+                    extensionProcessor.write(binding, writer);
+                }
+                
+                // Write extensions 
+                for (Object extension : callback.getExtensions()) {
+                    extensionProcessor.write(extension, writer);
+                }
+            
+                writeEnd(writer);
+            }
+
+            // Write extensions
+            for (Object extension : service.getExtensions()) {
+                extensionProcessor.write(extension, writer);
+            }
+            
+            writeEnd(writer);
+        }
+
+        // Write <component> elements
+        for (Component component : composite.getComponents()) {
+            writeStart(writer, COMPONENT, new XAttr(NAME, component.getName()),
+                       new XAttr(URI, component.getURI()),
+                       new XAttr(AUTOWIRE, component.getAutowire()),
+                       policyProcessor.writePolicies(component));
+            
+            // Write the component implementation
+            Implementation implementation = component.getImplementation();
+            if (implementation instanceof Composite) {
+                writeStart(writer, IMPLEMENTATION_COMPOSITE, new XAttr(NAME, composite.getName()));
+                writeEnd(writer);
+            } else {
+                extensionProcessor.write(component.getImplementation(), writer);
+            }
+            
+            // Write <service> elements
+            for (ComponentService service : component.getServices()) {
+                writeStart(writer, SERVICE, new XAttr(NAME, service.getName()),
+                           policyProcessor.writePolicies(service));
+
+                // Write service interface
+                extensionProcessor.write(service.getInterfaceContract(), writer);
+                
+                // Write bindings
+                for (Binding binding : service.getBindings()) {
+                    extensionProcessor.write(binding, writer);
+                }
+                
+                // Write <callback> element
+                if (service.getCallback() != null) {
+                    Callback callback = service.getCallback();
+                    writeStart(writer, CALLBACK, policyProcessor.writePolicies(callback));
+                
+                    // Write bindings
+                    for (Binding binding : callback.getBindings()) {
+                        extensionProcessor.write(binding, writer);
+                    }
+                    
+                    // Write extensions 
+                    for (Object extension : callback.getExtensions()) {
+                        extensionProcessor.write(extension, writer);
+                    }
+                
+                    writeEnd(writer);
+                }
+                
+                // Write extensions
+                for (Object extension : service.getExtensions()) {
+                    extensionProcessor.write(extension, writer);
+                }
+                
+                writeEnd(writer);
+            }
+            
+            // Write <reference> elements
+            for (ComponentReference reference : component.getReferences()) {
+                writeStart(writer, REFERENCE, new XAttr(NAME, reference.getName()),
+                           new XAttr(AUTOWIRE, reference.getAutowire()),
+                           writeTargets(reference),
+                           policyProcessor.writePolicies(reference));
+
+                // Write reference interface
+                extensionProcessor.write(reference.getInterfaceContract(), writer);
+
+                // Write bindings
+                for (Binding binding : reference.getBindings()) {
+                    extensionProcessor.write(binding, writer);
+                }
+                
+                // Write callback
+                if (reference.getCallback() != null) {
+                    Callback callback = reference.getCallback();
+                    writeStart(writer, CALLBACK, policyProcessor.writePolicies(callback));
+                
+                    // Write callback bindings
+                    for (Binding binding : callback.getBindings()) {
+                        extensionProcessor.write(binding, writer);
+                    }
+                    
+                    // Write extensions
+                    for (Object extensions : callback.getExtensions()) {
+                        extensionProcessor.write(extensions, writer);
+                    }
+                
+                    writeEnd(writer);
+                }
+                
+                // Write extensions
+                for (Object extensions : reference.getExtensions()) {
+                    extensionProcessor.write(extensions, writer);
+                }
+                
+                writeEnd(writer);
+            }
+            
+            // Write <property> elements
+            for (ComponentProperty property : component.getProperties()) {
+                writeStart(writer,
+                           PROPERTY,
+                           new XAttr(NAME, property.getName()),
+                           new XAttr(MUST_SUPPLY, property.isMustSupply()),
+                           new XAttr(MANY, property.isMany()),
+                           new XAttr(TYPE, property.getXSDType()),
+                           new XAttr(ELEMENT, property.getXSDElement()),
+                           new XAttr(SOURCE, property.getSource()),
+                           new XAttr(FILE, property.getFile()),
+                           policyProcessor.writePolicies(property));
+
+                // Write property value
+                writePropertyValue(property.getValue(), property.getXSDElement(), property.getXSDType(), writer);
+
+                // Write extensions
+                for (Object extension : property.getExtensions()) {
+                    extensionProcessor.write(extension, writer);
+                }
+
+                writeEnd(writer);
+            }
+    
+            writeEnd(writer);
+        }
+
+        // Write <reference> elements
+        for (Reference reference : composite.getReferences()) {
+            CompositeReference compositeReference = (CompositeReference)reference;
+
+            // Write list of promoted references
+            List<String> promote = new ArrayList<String>();
+            for (ComponentReference promoted: compositeReference.getPromotedReferences()) {
+                promote.add(promoted.getName());
+            }
+            
+            // Write <reference> element
+            writeStart(writer, REFERENCE, new XAttr(NAME, reference.getName()),
+                       new XAttr(PROMOTE, promote),
+                       policyProcessor.writePolicies(reference));
+
+            // Write reference interface
+            extensionProcessor.write(reference.getInterfaceContract(), writer);
+            
+            // Write bindings
+            for (Binding binding : reference.getBindings()) {
+                extensionProcessor.write(binding, writer);
+            }
+            
+            // Write <callback> element
+            if (reference.getCallback() != null) {
+                Callback callback = reference.getCallback();
+                writeStart(writer, CALLBACK);
+            
+                // Write callback bindings
+                for (Binding binding : callback.getBindings()) {
+                    extensionProcessor.write(binding, writer);
+                }
+                
+                // Write extensions
+                for (Object extension : callback.getExtensions()) {
+                    extensionProcessor.write(extension, writer);
+                }
+            
+                writeEnd(writer);
+            }
+            
+            // Write extensions
+            for (Object extension : reference.getExtensions()) {
+                extensionProcessor.write(extension, writer);
+            }
+            
+            writeEnd(writer);
+        }
+
+        // Write <property> elements
+        for (Property property : composite.getProperties()) {
+            writeStart(writer,
+                       PROPERTY,
+                       new XAttr(NAME, property.getName()),
+                       new XAttr(MUST_SUPPLY, property.isMustSupply()),
+                       new XAttr(MANY, property.isMany()),
+                       new XAttr(TYPE, property.getXSDType()),
+                       new XAttr(ELEMENT, property.getXSDElement()),
+                       policyProcessor.writePolicies(property));
+
+            // Write property value
+            writePropertyValue(property.getValue(), property.getXSDElement(), property.getXSDType(), writer);
+
+            // Write extensions
+            for (Object extension : property.getExtensions()) {
+                extensionProcessor.write(extension, writer);
+            }
+
+            writeEnd(writer);
+        }
+
+        // Write <wire> elements
+        for (Wire wire : composite.getWires()) {
+            writeStart(writer, WIRE, new XAttr(SOURCE, wire.getSource().getName()), new XAttr(TARGET, wire
+                .getTarget().getName()));
+            
+            // Write extensions
+            for (Object extension : wire.getExtensions()) {
+                extensionProcessor.write(extension, writer);
+            }
+            writeEnd(writer);
+        }
+
+        for (Object extension : composite.getExtensions()) {
+            extensionProcessor.write(extension, writer);
+        }
+
+        writeEndDocument(writer);
+    }
+
+    public void resolve(Composite composite, ModelResolver resolver) throws ContributionResolveException {
+
+        // Resolve constraining type
+        ConstrainingType constrainingType = composite.getConstrainingType();
+        if (constrainingType != null) {
+            constrainingType = resolver.resolveModel(ConstrainingType.class, constrainingType);
+            composite.setConstrainingType(constrainingType);
+        }
+
+        // Resolve includes in the composite
+        for (int i = 0, n = composite.getIncludes().size(); i < n; i++) {
+            Composite include = composite.getIncludes().get(i);
+            if (include != null) {
+                include = resolver.resolveModel(Composite.class, include);
+                composite.getIncludes().set(i, include);
+            }
+        }
+
+        // Resolve extensions
+        for (Object extension : composite.getExtensions()) {
+            if (extension != null) {
+                extensionProcessor.resolve(extension, resolver);
+            }
+        }
+        
+        //resolve intents and policysets first as they are going to be copied over
+        //to child elements as and when the child elements are being resolved
+        List<Intent> compositeIntents = null;
+        List<PolicySet> compositePolicySets = null;
+        List<PolicySet> compositeApplicablePolicySets = null;
+        if (composite instanceof PolicySetAttachPoint) { 
+            resolveIntents(((PolicySetAttachPoint)composite).getRequiredIntents(), resolver);
+            resolvePolicySets(((PolicySetAttachPoint)composite).getPolicySets(), resolver);
+            resolvePolicySets(((PolicySetAttachPoint)composite).getApplicablePolicySets(), resolver);
+            compositeIntents = ((PolicySetAttachPoint)composite).getRequiredIntents();
+            compositePolicySets = ((PolicySetAttachPoint)composite).getPolicySets();
+            compositeApplicablePolicySets = ((PolicySetAttachPoint)composite).getApplicablePolicySets();
+        } else {
+            compositeIntents = new ArrayList<Intent>();
+            compositePolicySets = new ArrayList<PolicySet>();
+            compositeApplicablePolicySets = new ArrayList<PolicySet>();
+        }
+        
+        //Resolve composite services and references
+        resolveContracts(composite, composite.getServices(), resolver);
+        resolveContracts(composite, composite.getReferences(), resolver);
+
+        // Resolve component implementations, services and references
+        for (Component component : composite.getComponents()) {
+            constrainingType = component.getConstrainingType();
+            if (constrainingType != null) {
+                constrainingType = resolver.resolveModel(ConstrainingType.class, constrainingType);
+                component.setConstrainingType(constrainingType);
+            }
+            
+            //resolve intents and policysets first as they are going to be copied over
+            //to child elements as and when the child elements are being resolved
+            resolveIntents(component.getRequiredIntents(), resolver);
+            resolvePolicySets(component.getPolicySets(), resolver);
+            resolvePolicySets(component.getApplicablePolicySets(), resolver);
+            
+            //inherit composite intents and policysets
+            addInheritedIntents(compositeIntents, component.getRequiredIntents());
+            addInheritedPolicySets(compositePolicySets, component.getPolicySets());
+            addInheritedPolicySets(compositeApplicablePolicySets, component.getApplicablePolicySets());
+
+            //resolve component services and references 
+            resolveContracts(component, component.getServices(), resolver);
+            resolveContracts(component, component.getReferences(), resolver);
+            
+            for (ComponentProperty componentProperty : component.getProperties()) {
+                if (componentProperty.getFile() != null) {
+                    Artifact artifact = contributionFactory.createArtifact();
+                    artifact.setURI(componentProperty.getFile());
+                    artifact = resolver.resolveModel(Artifact.class, artifact);
+                    if (artifact.getLocation() != null) {
+                        componentProperty.setFile(artifact.getLocation());
+                    }
+                }
+            }
+            
+            //resolve component implementation
+            Implementation implementation = component.getImplementation();
+            if (implementation != null) {
+                try {
+                    //resolve intents and policysets specified on this implementation
+                    //before copying them over to the component.  Before that, from the component
+                    //copy over the applicablePolicySets alone as it might have to be
+                    //used to validate the policysets specified on the implementation
+                    
+                    resolveImplIntentsAndPolicySets(implementation, 
+                                                    component.getApplicablePolicySets(), 
+                                                    resolver);
+                    
+                    copyPoliciesToComponent(component, implementation, resolver, true);
+                    
+                    //now resolve the implementation so that even if there is a shared instance
+                    //for this that is resolved, the specified intents and policysets are safe in the
+                    //component and not lost
+                    implementation = resolveImplementation(implementation, resolver);
+                    
+                    //resolved implementation may contain intents and policysets specified at 
+                    //componentType (either in the componentType side file or in annotations if its a 
+                    //java implementation).  This has to be consolidated in to the component.
+                    copyPoliciesToComponent(component, implementation, resolver, false);
+                    
+                    component.setImplementation(implementation);
+                } catch ( PolicyValidationException e ) {
+                    throw new ContributionResolveException("PolicyValidation exception when processing implementation of component '" 
+                                                           + component.getName() + "' due to " + e.getMessage(), e);
+                }
+            
+            }
+        }
+    }
+    
+    private void resolveImplIntentsAndPolicySets(Implementation implementation,
+                                                 List<PolicySet> inheritedApplicablePolicySets,
+                                                 ModelResolver resolver) throws ContributionResolveException,
+                                                                                 PolicyValidationException
+                                                        {
+        if ( implementation instanceof PolicySetAttachPoint ) {
+            PolicySetAttachPoint policiedImpl = (PolicySetAttachPoint)implementation;
+            
+            policiedImpl.getApplicablePolicySets().addAll(inheritedApplicablePolicySets);
+            
+            resolveIntents(policiedImpl.getRequiredIntents(), resolver);
+            PolicyValidationUtils.validateIntents(policiedImpl, policiedImpl.getType());
+            
+            resolvePolicySets(policiedImpl.getPolicySets(), resolver);
+            resolvePolicySets(policiedImpl.getApplicablePolicySets(), resolver);
+            
+            PolicyValidationUtils.validatePolicySets(policiedImpl);
+            
+            if ( implementation instanceof OperationsConfigurator ) {
+                for ( ConfiguredOperation implConfOp : ((OperationsConfigurator)implementation).getConfiguredOperations() ) {
+                    resolveIntents(implConfOp.getRequiredIntents(), resolver);
+                    PolicyValidationUtils.validateIntents(implConfOp, policiedImpl.getType());
+                    
+                    resolvePolicySets(implConfOp.getPolicySets(), resolver);
+                    resolvePolicySets(implConfOp.getApplicablePolicySets(), resolver);
+                    //add the inherited applicablePolicysets
+                    addInheritedPolicySets(policiedImpl.getApplicablePolicySets(), implConfOp.getApplicablePolicySets());
+                    
+                    PolicyValidationUtils.validatePolicySets(implConfOp, policiedImpl.getType());
+                    
+                    addInheritedIntents(((PolicySetAttachPoint)implementation).getRequiredIntents(), 
+                                        implConfOp.getRequiredIntents());
+                    addInheritedPolicySets(((PolicySetAttachPoint)implementation).getPolicySets(), 
+                                           implConfOp.getPolicySets());
+                }
+            }
+        }
+    }
+    
+    private void copyPoliciesToComponent(Component component, 
+                                         Implementation implementation, 
+                                         ModelResolver resolver,
+                                         boolean clearImplSettings) throws ContributionResolveException {
+        if (implementation instanceof PolicySetAttachPoint) {
+            //add implementation policies into component... since implementation instance are 
+            //reused and its likely that this implementation instance will not hold after its resolution
+            component.getRequiredIntents().addAll(((PolicySetAttachPoint)implementation).getRequiredIntents());
+            component.getPolicySets().addAll(((PolicySetAttachPoint)implementation).getPolicySets());
+            component.getApplicablePolicySets().addAll(((PolicySetAttachPoint)implementation).getApplicablePolicySets());
+            
+            if ( implementation instanceof OperationsConfigurator ) {
+                boolean notFound;
+                List<ConfiguredOperation> opsFromImplementation = new ArrayList<ConfiguredOperation>();
+                List<ConfiguredOperation> implConfOperations = 
+                    new ArrayList<ConfiguredOperation>(((OperationsConfigurator)implementation).getConfiguredOperations());
+                for ( ConfiguredOperation implConfOp : implConfOperations ) {
+                    notFound = true;
+                    for ( ConfiguredOperation compConfOp : ((OperationsConfigurator)component).getConfiguredOperations() ) {
+                        if ( implConfOp.getName().equals(compConfOp.getName()) ) {
+                            notFound = false;
+                            addInheritedIntents(implConfOp.getRequiredIntents(), compConfOp.getRequiredIntents());
+                            addInheritedPolicySets(implConfOp.getPolicySets(), compConfOp.getPolicySets());
+                            addInheritedPolicySets(implConfOp.getApplicablePolicySets(), compConfOp.getApplicablePolicySets());
+                            notFound = false;
+                        }
+                    }
+                    
+                    if ( notFound ) {
+                        opsFromImplementation.add(implConfOp);
+                    }
+                    
+                    if ( clearImplSettings ) {
+                        ((OperationsConfigurator)implementation).getConfiguredOperations().remove(implConfOp);
+                    }
+                }
+                ((OperationsConfigurator)component).getConfiguredOperations().addAll(opsFromImplementation);
+            }
+            
+            if ( clearImplSettings ) {
+                ((PolicySetAttachPoint)implementation).getRequiredIntents().clear();
+                ((PolicySetAttachPoint)implementation).getPolicySets().clear();
+            }
+        }
+    }
+    
+    
+    public QName getArtifactType() {
+        return COMPOSITE_QNAME;
+    }
+
+    public Class<Composite> getModelType() {
+        return Composite.class;
+    }
+}

Added: incubator/tuscany/sandbox/mobile-android/tuscany-assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/ConfiguredOperationProcessor.java
URL: http://svn.apache.org/viewvc/incubator/tuscany/sandbox/mobile-android/tuscany-assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/ConfiguredOperationProcessor.java?rev=653133&view=auto
==============================================================================
--- incubator/tuscany/sandbox/mobile-android/tuscany-assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/ConfiguredOperationProcessor.java (added)
+++ incubator/tuscany/sandbox/mobile-android/tuscany-assembly-xml/src/main/java/org/apache/tuscany/sca/assembly/xml/ConfiguredOperationProcessor.java Sat May  3 13:52:41 2008
@@ -0,0 +1,104 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.    
+ */
+
+package org.apache.tuscany.sca.assembly.xml;
+
+import static javax.xml.stream.XMLStreamConstants.END_ELEMENT;
+
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.XMLStreamWriter;
+
+import org.apache.tuscany.sca.assembly.AssemblyFactory;
+import org.apache.tuscany.sca.assembly.ConfiguredOperation;
+import org.apache.tuscany.sca.contribution.ModelFactoryExtensionPoint;
+import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor;
+import org.apache.tuscany.sca.contribution.resolver.ModelResolver;
+import org.apache.tuscany.sca.contribution.service.ContributionReadException;
+import org.apache.tuscany.sca.contribution.service.ContributionResolveException;
+import org.apache.tuscany.sca.contribution.service.ContributionWriteException;
+import org.apache.tuscany.sca.policy.PolicyFactory;
+
+/**
+ * Processor for dealing with  'operation' elements from composite definitions
+ */
+public class ConfiguredOperationProcessor implements StAXArtifactProcessor<ConfiguredOperation>, Constants{
+    
+    private AssemblyFactory assemblyFactory;
+    private PolicyAttachPointProcessor policyProcessor;
+    private PolicyFactory policyFactory;
+    
+    public ConfiguredOperationProcessor(ModelFactoryExtensionPoint modelFactories) {
+        this.assemblyFactory = modelFactories.getFactory(AssemblyFactory.class);
+        this.policyFactory = modelFactories.getFactory(PolicyFactory.class);
+        this.policyProcessor = new PolicyAttachPointProcessor(policyFactory);
+    }
+    
+    public ConfiguredOperation read(XMLStreamReader reader) throws ContributionReadException, XMLStreamException {
+        ConfiguredOperation  configuredOp = assemblyFactory.createConfiguredOperation();
+        
+        //Read an <operation>
+        configuredOp.setName(reader.getAttributeValue(null, NAME));
+        configuredOp.setContractName(reader.getAttributeValue(null, SERVICE));
+        configuredOp.setUnresolved(true);
+        
+        // Read policies
+        policyProcessor.readPolicies(configuredOp, reader);
+
+        //Skip to end element
+        while (reader.hasNext()) {
+            if (reader.next() == END_ELEMENT && OPERATION_QNAME.equals(reader.getName())) {
+                break;
+            }
+        }
+        
+        return configuredOp;
+    }
+    
+    public void write(ConfiguredOperation configuredOperation, XMLStreamWriter writer)
+        throws ContributionWriteException, XMLStreamException {
+
+        // Write an <operation>
+        policyProcessor.writePolicyPrefixes(configuredOperation, writer);
+        writer.writeStartElement(Constants.SCA10_NS, OPERATION);
+        policyProcessor.writePolicyAttributes(configuredOperation, writer);
+
+        writer.writeAttribute(NAME, configuredOperation.getName());
+        if ( configuredOperation.getContractName() != null ) {
+            writer.writeAttribute(SERVICE, configuredOperation.getContractName());
+        }
+        writer.writeEndElement();
+    }
+    
+    public void resolve(ConfiguredOperation configuredOperation, ModelResolver resolver)
+        throws ContributionResolveException {
+    }
+    
+    public QName getArtifactType() {
+        return OPERATION_QNAME;
+    }
+    
+    public Class<ConfiguredOperation> getModelType() {
+        return ConfiguredOperation.class;
+    }
+
+}
+
+



Mime
View raw message