diff options
Diffstat (limited to 'branches/sca-java-1.2/modules/definitions/src/main/java/org/apache/tuscany')
10 files changed, 792 insertions, 0 deletions
diff --git a/branches/sca-java-1.2/modules/definitions/src/main/java/org/apache/tuscany/sca/definitions/SCADefinitions.java b/branches/sca-java-1.2/modules/definitions/src/main/java/org/apache/tuscany/sca/definitions/SCADefinitions.java new file mode 100644 index 0000000000..c1b8b03a19 --- /dev/null +++ b/branches/sca-java-1.2/modules/definitions/src/main/java/org/apache/tuscany/sca/definitions/SCADefinitions.java @@ -0,0 +1,74 @@ + /* + * 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.definitions; + +import java.util.List; + +import org.apache.tuscany.sca.policy.Intent; +import org.apache.tuscany.sca.policy.IntentAttachPointType; +import org.apache.tuscany.sca.policy.PolicySet; + + +/** + * Represents SCA Definitions. + * + */ +public interface SCADefinitions { + /** + * Returns the target namespace for this SCA Definition + * @return the target namespace + */ + String getTargetNamespace(); + + /** + * Sets the target names for this SCA Definition + * + * @param the target namespace for this SCA Definition + */ + void setTargetNamespace(String ns); + + /** + * Returns a list of domain wide Policy Intents + * + * @return a list of domain wide Policy Intents + */ + List<Intent> getPolicyIntents(); + + /** + * Returns a list of domain wide PolicySets + * + * @return a list of domain wide PolicySets + */ + List<PolicySet> getPolicySets(); + + /** + * Returns a list of domain wide Binding Types + * + * @return a list of domain wide Binding Types + */ + List<IntentAttachPointType> getBindingTypes(); + + + /** + * Returns a list of domain wide Implementation Types + * + * @return a list of domain wide Implementation Types + */ + List<IntentAttachPointType> getImplementationTypes(); +} diff --git a/branches/sca-java-1.2/modules/definitions/src/main/java/org/apache/tuscany/sca/definitions/SCADefinitionsBuilder.java b/branches/sca-java-1.2/modules/definitions/src/main/java/org/apache/tuscany/sca/definitions/SCADefinitionsBuilder.java new file mode 100644 index 0000000000..0fad38b554 --- /dev/null +++ b/branches/sca-java-1.2/modules/definitions/src/main/java/org/apache/tuscany/sca/definitions/SCADefinitionsBuilder.java @@ -0,0 +1,33 @@ +/* + * 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.definitions; + + +/** + * Interface to abstract building of SCA Defintions for a Domain + * + */ +public interface SCADefinitionsBuilder { + /** + * Builds the sca definitions + * + * @param scaDefns + */ + void build(SCADefinitions scaDefns) throws SCADefinitionsBuilderException; +} diff --git a/branches/sca-java-1.2/modules/definitions/src/main/java/org/apache/tuscany/sca/definitions/SCADefinitionsBuilderException.java b/branches/sca-java-1.2/modules/definitions/src/main/java/org/apache/tuscany/sca/definitions/SCADefinitionsBuilderException.java new file mode 100644 index 0000000000..aeef85b45a --- /dev/null +++ b/branches/sca-java-1.2/modules/definitions/src/main/java/org/apache/tuscany/sca/definitions/SCADefinitionsBuilderException.java @@ -0,0 +1,42 @@ +/* + * 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.definitions; + +/** + * Builder Exception + * + */ +public class SCADefinitionsBuilderException extends Exception { + private static final long serialVersionUID = 2513219325230252783L; + + public SCADefinitionsBuilderException() { + } + + public SCADefinitionsBuilderException(String message) { + super(message); + } + + public SCADefinitionsBuilderException(Throwable cause) { + super(cause); + } + + public SCADefinitionsBuilderException(String message, Throwable cause) { + super(message, cause); + } +} diff --git a/branches/sca-java-1.2/modules/definitions/src/main/java/org/apache/tuscany/sca/definitions/SCADefinitionsBuilderImpl.java b/branches/sca-java-1.2/modules/definitions/src/main/java/org/apache/tuscany/sca/definitions/SCADefinitionsBuilderImpl.java new file mode 100644 index 0000000000..42f6acb3e2 --- /dev/null +++ b/branches/sca-java-1.2/modules/definitions/src/main/java/org/apache/tuscany/sca/definitions/SCADefinitionsBuilderImpl.java @@ -0,0 +1,308 @@ +/* + * 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.definitions; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Hashtable; +import java.util.List; +import java.util.Map; + +import javax.xml.namespace.QName; + +import org.apache.tuscany.sca.policy.Intent; +import org.apache.tuscany.sca.policy.IntentAttachPointType; +import org.apache.tuscany.sca.policy.PolicySet; +import org.apache.tuscany.sca.policy.ProfileIntent; +import org.apache.tuscany.sca.policy.QualifiedIntent; + +/** + * Provides a concrete implementation for a SCADefinitionsBuilder + * + */ +public class SCADefinitionsBuilderImpl implements SCADefinitionsBuilder { + + public void build(SCADefinitions scaDefns) throws SCADefinitionsBuilderException { + Map<QName, Intent> definedIntents = new HashMap<QName, Intent>(); + for (Intent intent : scaDefns.getPolicyIntents()) { + definedIntents.put(intent.getName(), intent); + } + + Map<QName, PolicySet> definedPolicySets = new HashMap<QName, PolicySet>(); + for (PolicySet policySet : scaDefns.getPolicySets()) { + definedPolicySets.put(policySet.getName(), policySet); + } + + Map<QName, IntentAttachPointType> definedBindingTypes = new HashMap<QName, IntentAttachPointType>(); + for (IntentAttachPointType bindingType : scaDefns.getBindingTypes()) { + definedBindingTypes.put(bindingType.getName(), bindingType); + } + + Map<QName, IntentAttachPointType> definedImplTypes = new HashMap<QName, IntentAttachPointType>(); + for (IntentAttachPointType implType : scaDefns.getImplementationTypes()) { + definedImplTypes.put(implType.getName(), implType); + } + + //filling up the maps removes all duplicate entries... so fill this unique lists + //into the scaDefns. + scaDefns.getPolicyIntents().clear(); + scaDefns.getPolicySets().clear(); + scaDefns.getBindingTypes().clear(); + scaDefns.getImplementationTypes().clear(); + + scaDefns.getPolicyIntents().addAll(definedIntents.values()); + scaDefns.getPolicySets().addAll(definedPolicySets.values()); + scaDefns.getBindingTypes().addAll(definedBindingTypes.values()); + scaDefns.getImplementationTypes().addAll(definedImplTypes.values()); + + buildPolicyIntents(scaDefns, definedIntents); + buildPolicySets(scaDefns, definedPolicySets, definedIntents); + buildBindingTypes(scaDefns, definedBindingTypes, definedIntents); + buildImplementationTypes(scaDefns, definedImplTypes, definedIntents); + } + + private void buildBindingTypes(SCADefinitions scaDefns, + Map<QName, IntentAttachPointType> definedBindingTypes, + Map<QName, Intent> definedIntents) throws SCADefinitionsBuilderException { + for (IntentAttachPointType bindingType : scaDefns.getBindingTypes()) { + buildAlwaysProvidedIntents(bindingType, definedIntents); + buildMayProvideIntents(bindingType, definedIntents); + } + + } + + private void buildImplementationTypes(SCADefinitions scaDefns, + Map<QName, IntentAttachPointType> definedImplTypes, + Map<QName, Intent> definedIntents) throws SCADefinitionsBuilderException { + for (IntentAttachPointType implType : scaDefns.getImplementationTypes()) { + buildAlwaysProvidedIntents(implType, definedIntents); + buildMayProvideIntents(implType, definedIntents); + } + } + + + private void buildPolicyIntents(SCADefinitions scaDefns, Map<QName, Intent> definedIntents) + throws SCADefinitionsBuilderException { + for (Intent policyIntent : scaDefns.getPolicyIntents()) { + if (policyIntent instanceof ProfileIntent) { + buildProfileIntent((ProfileIntent)policyIntent, definedIntents); + } + + if (policyIntent instanceof QualifiedIntent) { + buildQualifiedIntent((QualifiedIntent)policyIntent, definedIntents); + } + } + } + + private void buildPolicySets(SCADefinitions scaDefns, + Map<QName, PolicySet> definedPolicySets, + Map<QName, Intent> definedIntents) throws SCADefinitionsBuilderException { + + for (PolicySet policySet : scaDefns.getPolicySets()) { + buildProvidedIntents(policySet, definedIntents); + buildIntentsInMappedPolicies(policySet, definedIntents); + buildReferredPolicySets(policySet, definedPolicySets); + } + + for (PolicySet policySet : scaDefns.getPolicySets()) { + for (PolicySet referredPolicySet : policySet.getReferencedPolicySets()) { + includeReferredPolicySets(policySet, referredPolicySet); + } + } + } + + private void buildProfileIntent(ProfileIntent policyIntent, Map<QName, Intent> definedIntents) + throws SCADefinitionsBuilderException { + //FIXME: Need to check for cyclic references first i.e an A requiring B and then B requiring A... + if (policyIntent != null) { + //resolve all required intents + List<Intent> requiredIntents = new ArrayList<Intent>(); + for (Intent requiredIntent : policyIntent.getRequiredIntents()) { + if (requiredIntent.isUnresolved()) { + Intent resolvedRequiredIntent = definedIntents.get(requiredIntent.getName()); + if (resolvedRequiredIntent != null) { + requiredIntents.add(resolvedRequiredIntent); + } else { + throw new SCADefinitionsBuilderException("Required Intent - " + requiredIntent + + " not found for ProfileIntent " + + policyIntent); + + } + } else { + requiredIntents.add(requiredIntent); + } + } + policyIntent.getRequiredIntents().clear(); + policyIntent.getRequiredIntents().addAll(requiredIntents); + } + } + + private void buildQualifiedIntent(QualifiedIntent policyIntent, Map<QName, Intent> definedIntents) + throws SCADefinitionsBuilderException { + if (policyIntent != null) { + //resolve the qualifiable intent + Intent qualifiableIntent = policyIntent.getQualifiableIntent(); + if (qualifiableIntent.isUnresolved()) { + Intent resolvedQualifiableIntent = definedIntents.get(qualifiableIntent.getName()); + + if (resolvedQualifiableIntent != null) { + policyIntent.setQualifiableIntent(resolvedQualifiableIntent); + } else { + throw new SCADefinitionsBuilderException("Qualifiable Intent - " + qualifiableIntent + + " not found for QualifiedIntent " + + policyIntent); + } + + } + } + } + + + private void buildAlwaysProvidedIntents(IntentAttachPointType extensionType, + Map<QName, Intent> definedIntents) throws SCADefinitionsBuilderException { + if (extensionType != null) { + // resolve all provided intents + List<Intent> alwaysProvided = new ArrayList<Intent>(); + for (Intent providedIntent : extensionType.getAlwaysProvidedIntents()) { + if (providedIntent.isUnresolved()) { + Intent resolvedProvidedIntent = definedIntents.get(providedIntent.getName()); + if (resolvedProvidedIntent != null) { + alwaysProvided.add(resolvedProvidedIntent); + } else { + throw new SCADefinitionsBuilderException( + "Always Provided Intent - " + providedIntent + + " not found for ExtensionType " + + extensionType); + + } + } else { + alwaysProvided.add(providedIntent); + } + } + extensionType.getAlwaysProvidedIntents().clear(); + extensionType.getAlwaysProvidedIntents().addAll(alwaysProvided); + } + } + + private void buildMayProvideIntents(IntentAttachPointType extensionType, + Map<QName, Intent> definedIntents) throws SCADefinitionsBuilderException { + if (extensionType != null) { + // resolve all provided intents + List<Intent> mayProvide = new ArrayList<Intent>(); + for (Intent providedIntent : extensionType.getMayProvideIntents()) { + if (providedIntent.isUnresolved()) { + Intent resolvedProvidedIntent = definedIntents.get(providedIntent.getName()); + if (resolvedProvidedIntent != null) { + mayProvide.add(resolvedProvidedIntent); + } else { + throw new SCADefinitionsBuilderException( + "May Provide Intent - " + providedIntent + + " not found for ExtensionType " + + extensionType); + + } + } else { + mayProvide.add(providedIntent); + } + } + extensionType.getMayProvideIntents().clear(); + extensionType.getMayProvideIntents().addAll(mayProvide); + } + } + + private void buildProvidedIntents(PolicySet policySet, Map<QName, Intent> definedIntents) + throws SCADefinitionsBuilderException { + if (policySet != null) { + //resolve all provided intents + List<Intent> providedIntents = new ArrayList<Intent>(); + for (Intent providedIntent : policySet.getProvidedIntents()) { + if (providedIntent.isUnresolved()) { + Intent resolvedProvidedIntent = definedIntents.get(providedIntent.getName()); + if (resolvedProvidedIntent != null) { + providedIntents.add(resolvedProvidedIntent); + } else { + throw new SCADefinitionsBuilderException("Provided Intent - " + providedIntent + + " not found for PolicySet " + + policySet); + + } + } else { + providedIntents.add(providedIntent); + } + } + policySet.getProvidedIntents().clear(); + policySet.getProvidedIntents().addAll(providedIntents); + } + } + + private void buildIntentsInMappedPolicies(PolicySet policySet, Map<QName, Intent> definedIntents) + throws SCADefinitionsBuilderException { + Map<Intent, List<Object>> mappedPolicies = new Hashtable<Intent, List<Object>>(); + for (Map.Entry<Intent, List<Object>> entry : policySet.getMappedPolicies().entrySet()) { + Intent mappedIntent = entry.getKey(); + if (mappedIntent.isUnresolved()) { + Intent resolvedMappedIntent = definedIntents.get(mappedIntent.getName()); + + if (resolvedMappedIntent != null) { + mappedPolicies.put(resolvedMappedIntent, entry.getValue()); + } else { + throw new SCADefinitionsBuilderException("Mapped Intent - " + mappedIntent + + " not found for PolicySet " + + policySet); + + } + } else { + mappedPolicies.put(mappedIntent, entry.getValue()); + } + } + + policySet.getMappedPolicies().clear(); + policySet.getMappedPolicies().putAll(mappedPolicies); + } + + private void buildReferredPolicySets(PolicySet policySet, Map<QName, PolicySet> definedPolicySets) + throws SCADefinitionsBuilderException { + + List<PolicySet> referredPolicySets = new ArrayList<PolicySet>(); + for (PolicySet referredPolicySet : policySet.getReferencedPolicySets()) { + if (referredPolicySet.isUnresolved()) { + PolicySet resolvedReferredPolicySet = definedPolicySets.get(referredPolicySet.getName()); + if (resolvedReferredPolicySet != null) { + referredPolicySets.add(resolvedReferredPolicySet); + } else { + throw new SCADefinitionsBuilderException("Referred PolicySet - " + referredPolicySet + + "not found for PolicySet - " + + policySet); + } + } else { + referredPolicySets.add(referredPolicySet); + } + } + policySet.getReferencedPolicySets().clear(); + policySet.getReferencedPolicySets().addAll(referredPolicySets); + } + + private void includeReferredPolicySets(PolicySet policySet, PolicySet referredPolicySet) { + for (PolicySet furtherReferredPolicySet : referredPolicySet.getReferencedPolicySets()) { + includeReferredPolicySets(referredPolicySet, furtherReferredPolicySet); + } + policySet.getPolicies().addAll(referredPolicySet.getPolicies()); + policySet.getMappedPolicies().putAll(referredPolicySet.getMappedPolicies()); + } +} diff --git a/branches/sca-java-1.2/modules/definitions/src/main/java/org/apache/tuscany/sca/definitions/SCADefinitionsProvider.java b/branches/sca-java-1.2/modules/definitions/src/main/java/org/apache/tuscany/sca/definitions/SCADefinitionsProvider.java new file mode 100644 index 0000000000..f53cf8cd3b --- /dev/null +++ b/branches/sca-java-1.2/modules/definitions/src/main/java/org/apache/tuscany/sca/definitions/SCADefinitionsProvider.java @@ -0,0 +1,31 @@ +/* + * 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.definitions; + +import org.apache.tuscany.sca.definitions.SCADefinitions; + +/** + * Models a provider of SCA Definitions. Typically SCA Definitions providers + * may either load a definitions.xml file or create the SCA Definitions model + * programmatically. + */ +public interface SCADefinitionsProvider { + SCADefinitions getSCADefinition() throws SCADefinitionsProviderException ; +} diff --git a/branches/sca-java-1.2/modules/definitions/src/main/java/org/apache/tuscany/sca/definitions/SCADefinitionsProviderException.java b/branches/sca-java-1.2/modules/definitions/src/main/java/org/apache/tuscany/sca/definitions/SCADefinitionsProviderException.java new file mode 100644 index 0000000000..dbf463f2b0 --- /dev/null +++ b/branches/sca-java-1.2/modules/definitions/src/main/java/org/apache/tuscany/sca/definitions/SCADefinitionsProviderException.java @@ -0,0 +1,30 @@ +/* + * 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.definitions; + +/** + * @version $Rev$ $Date$ + */ +public class SCADefinitionsProviderException extends Exception { + + public SCADefinitionsProviderException(Throwable e) { + super(e); + } +} diff --git a/branches/sca-java-1.2/modules/definitions/src/main/java/org/apache/tuscany/sca/definitions/SCADefinitionsProviderExtensionPoint.java b/branches/sca-java-1.2/modules/definitions/src/main/java/org/apache/tuscany/sca/definitions/SCADefinitionsProviderExtensionPoint.java new file mode 100644 index 0000000000..2e6b9ed137 --- /dev/null +++ b/branches/sca-java-1.2/modules/definitions/src/main/java/org/apache/tuscany/sca/definitions/SCADefinitionsProviderExtensionPoint.java @@ -0,0 +1,33 @@ +/* + * 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.definitions; + +import java.util.List; + +/** + * An extension point for SCA Definitions Providers. SCA Definition providers, load SCA Definitions + * items that are being specifically contributed by the module that hosts the provider in question. + */ +public interface SCADefinitionsProviderExtensionPoint { + + void addSCADefinitionsProvider(SCADefinitionsProvider provider); + void removeSCADefinitionsProvider(SCADefinitionsProvider provider); + List<SCADefinitionsProvider> getSCADefinitionsProviders(); +} diff --git a/branches/sca-java-1.2/modules/definitions/src/main/java/org/apache/tuscany/sca/definitions/impl/DefaultSCADefinitionsProviderExtensionPoint.java b/branches/sca-java-1.2/modules/definitions/src/main/java/org/apache/tuscany/sca/definitions/impl/DefaultSCADefinitionsProviderExtensionPoint.java new file mode 100644 index 0000000000..c36411e4bd --- /dev/null +++ b/branches/sca-java-1.2/modules/definitions/src/main/java/org/apache/tuscany/sca/definitions/impl/DefaultSCADefinitionsProviderExtensionPoint.java @@ -0,0 +1,91 @@ +/* + * 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.definitions.impl; + +import java.lang.reflect.Constructor; +import java.util.ArrayList; +import java.util.List; +import java.util.Set; + +import org.apache.tuscany.sca.core.ExtensionPointRegistry; +import org.apache.tuscany.sca.definitions.SCADefinitionsProvider; +import org.apache.tuscany.sca.definitions.SCADefinitionsProviderExtensionPoint; +import org.apache.tuscany.sca.extensibility.ServiceDeclaration; +import org.apache.tuscany.sca.extensibility.ServiceDiscovery; + +/** + * Concrete Implementation for the SCADefinitionsProviderExtensionPoint + */ +public class DefaultSCADefinitionsProviderExtensionPoint implements + SCADefinitionsProviderExtensionPoint { + + private ExtensionPointRegistry extensionPointRegistry = null; + + private List<SCADefinitionsProvider> scaDefnsProviders = new ArrayList<SCADefinitionsProvider>(); + + public DefaultSCADefinitionsProviderExtensionPoint(ExtensionPointRegistry extnPtReg) { + this.extensionPointRegistry = extnPtReg; + } + + public void addSCADefinitionsProvider(SCADefinitionsProvider provider) { + scaDefnsProviders.add(provider); + } + + public void removeSCADefinitionsProvider(SCADefinitionsProvider provider) { + scaDefnsProviders.remove(provider); + } + + public List<SCADefinitionsProvider> getSCADefinitionsProviders() { + if (scaDefnsProviders.isEmpty()) { + loadProviders(); + } + return scaDefnsProviders; + } + + private void loadProviders() { + // Get the provider service declarations + Set<ServiceDeclaration> defnProviderDecls; + SCADefinitionsProvider aProvider = null; + Class providerClass = null; + Constructor constructor = null; + + try { + defnProviderDecls = + ServiceDiscovery.getInstance().getServiceDeclarations(SCADefinitionsProvider.class); + + for (ServiceDeclaration aDefnProviderDecl : defnProviderDecls) { + providerClass = aDefnProviderDecl.loadClass(); + + try { + constructor = providerClass.getConstructor(); + aProvider = (SCADefinitionsProvider)constructor.newInstance(); + } catch (NoSuchMethodException e1) { + constructor = providerClass.getConstructor(ExtensionPointRegistry.class); + aProvider = (SCADefinitionsProvider)constructor.newInstance(extensionPointRegistry); + } + + scaDefnsProviders.add(aProvider); + } + } catch (Exception e) { + throw new RuntimeException(e); + } + + } +} diff --git a/branches/sca-java-1.2/modules/definitions/src/main/java/org/apache/tuscany/sca/definitions/impl/SCADefinitionsImpl.java b/branches/sca-java-1.2/modules/definitions/src/main/java/org/apache/tuscany/sca/definitions/impl/SCADefinitionsImpl.java new file mode 100644 index 0000000000..f46883d888 --- /dev/null +++ b/branches/sca-java-1.2/modules/definitions/src/main/java/org/apache/tuscany/sca/definitions/impl/SCADefinitionsImpl.java @@ -0,0 +1,66 @@ +/* + * 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.definitions.impl; + +import java.util.ArrayList; +import java.util.List; + +import org.apache.tuscany.sca.definitions.SCADefinitions; +import org.apache.tuscany.sca.policy.Intent; +import org.apache.tuscany.sca.policy.IntentAttachPointType; +import org.apache.tuscany.sca.policy.PolicySet; + +/** + * Provides a concrete implementation for SCADefinitions + * + */ +public class SCADefinitionsImpl implements SCADefinitions { + private String targetNamespace = null; + private List<Intent> policyIntents = new ArrayList<Intent>(); + private List<PolicySet> policySets = new ArrayList<PolicySet>(); + private List<IntentAttachPointType> bindingTypes = new ArrayList<IntentAttachPointType>(); + private List<IntentAttachPointType> implementationTypes = new ArrayList<IntentAttachPointType>(); + + + public List<IntentAttachPointType> getBindingTypes() { + return bindingTypes; + } + + public List<IntentAttachPointType> getImplementationTypes() { + return implementationTypes; + } + + public List<Intent> getPolicyIntents() { + return policyIntents; + } + + public List<PolicySet> getPolicySets() { + return policySets; + } + + public String getTargetNamespace() { + return targetNamespace; + } + + public void setTargetNamespace(String ns) { + this.targetNamespace = ns; + } + +} diff --git a/branches/sca-java-1.2/modules/definitions/src/main/java/org/apache/tuscany/sca/definitions/util/SCADefinitionsUtil.java b/branches/sca-java-1.2/modules/definitions/src/main/java/org/apache/tuscany/sca/definitions/util/SCADefinitionsUtil.java new file mode 100644 index 0000000000..66a9803fae --- /dev/null +++ b/branches/sca-java-1.2/modules/definitions/src/main/java/org/apache/tuscany/sca/definitions/util/SCADefinitionsUtil.java @@ -0,0 +1,84 @@ +/* + * 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.definitions.util; + +import java.net.URI; +import java.util.HashMap; +import java.util.Map; + +import javax.xml.namespace.QName; + +import org.apache.tuscany.sca.definitions.SCADefinitions; +import org.apache.tuscany.sca.policy.Intent; +import org.apache.tuscany.sca.policy.IntentAttachPointType; +import org.apache.tuscany.sca.policy.PolicySet; + +/** + * Some utility funtions to deal with SCADefinitions + */ +public class SCADefinitionsUtil { + + public static void stripDuplicates(SCADefinitions scaDefns) { + Map<QName, Intent> definedIntents = new HashMap<QName, Intent>(); + for (Intent intent : scaDefns.getPolicyIntents()) { + definedIntents.put(intent.getName(), intent); + } + + Map<QName, PolicySet> definedPolicySets = new HashMap<QName, PolicySet>(); + for (PolicySet policySet : scaDefns.getPolicySets()) { + definedPolicySets.put(policySet.getName(), policySet); + } + + Map<QName, IntentAttachPointType> definedBindingTypes = new HashMap<QName, IntentAttachPointType>(); + for (IntentAttachPointType bindingType : scaDefns.getBindingTypes()) { + definedBindingTypes.put(bindingType.getName(), bindingType); + } + + Map<QName, IntentAttachPointType> definedImplTypes = new HashMap<QName, IntentAttachPointType>(); + for (IntentAttachPointType implType : scaDefns.getImplementationTypes()) { + definedImplTypes.put(implType.getName(), implType); + } + + scaDefns.getPolicyIntents().clear(); + scaDefns.getPolicyIntents().addAll(definedIntents.values()); + scaDefns.getPolicySets().clear(); + scaDefns.getPolicySets().addAll(definedPolicySets.values()); + scaDefns.getBindingTypes().clear(); + scaDefns.getBindingTypes().addAll(definedBindingTypes.values()); + scaDefns.getImplementationTypes().clear(); + scaDefns.getImplementationTypes().addAll(definedImplTypes.values()); + } + + public static void aggregateSCADefinitions(SCADefinitions source, SCADefinitions target) { + target.getPolicyIntents().addAll(source.getPolicyIntents()); + target.getPolicySets().addAll(source.getPolicySets()); + target.getBindingTypes().addAll(source.getBindingTypes()); + target.getImplementationTypes().addAll(source.getImplementationTypes()); + } + + public static boolean isSCADefnsFile(URI uri) { + int index = uri.toString().lastIndexOf("/"); + + index = (index != -1) ? index + 1 : 0; + + return uri.toString().substring(index).equals("definitions.xml"); + } + +} |