diff options
Diffstat (limited to 'sca-java-2.x/tags/2.0.1-RC1/modules/assembly/src/main/java/org/apache/tuscany/sca/definitions/impl/DefinitionsBuilderImpl.java')
| -rw-r--r-- | sca-java-2.x/tags/2.0.1-RC1/modules/assembly/src/main/java/org/apache/tuscany/sca/definitions/impl/DefinitionsBuilderImpl.java | 307 |
1 files changed, 307 insertions, 0 deletions
diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/assembly/src/main/java/org/apache/tuscany/sca/definitions/impl/DefinitionsBuilderImpl.java b/sca-java-2.x/tags/2.0.1-RC1/modules/assembly/src/main/java/org/apache/tuscany/sca/definitions/impl/DefinitionsBuilderImpl.java new file mode 100644 index 0000000000..d87d45b27a --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/assembly/src/main/java/org/apache/tuscany/sca/definitions/impl/DefinitionsBuilderImpl.java @@ -0,0 +1,307 @@ +/* + * 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.HashMap; +import java.util.List; +import java.util.Map; + +import javax.xml.namespace.QName; + +import org.apache.tuscany.sca.definitions.Definitions; +import org.apache.tuscany.sca.definitions.DefinitionsBuilder; +import org.apache.tuscany.sca.definitions.DefinitionsBuilderException; +import org.apache.tuscany.sca.policy.BindingType; +import org.apache.tuscany.sca.policy.ExtensionType; +import org.apache.tuscany.sca.policy.ImplementationType; +import org.apache.tuscany.sca.policy.Intent; +import org.apache.tuscany.sca.policy.IntentMap; +import org.apache.tuscany.sca.policy.PolicySet; +import org.apache.tuscany.sca.policy.Qualifier; + +/** + * Provides a concrete implementation for a SCADefinitionsBuilder + * + * @version $Rev$ $Date$ + */ +public class DefinitionsBuilderImpl implements DefinitionsBuilder { + + public void build(Definitions scaDefns) throws DefinitionsBuilderException { + Map<QName, Intent> definedIntents = new HashMap<QName, Intent>(); + for (Intent intent : scaDefns.getIntents()) { + 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, BindingType> definedBindingTypes = new HashMap<QName, BindingType>(); + for (BindingType bindingType : scaDefns.getBindingTypes()) { + definedBindingTypes.put(bindingType.getType(), bindingType); + } + + Map<QName, ImplementationType> definedImplTypes = new HashMap<QName, ImplementationType>(); + for (ImplementationType implType : scaDefns.getImplementationTypes()) { + definedImplTypes.put(implType.getType(), implType); + } + + //filling up the maps removes all duplicate entries... so fill this unique lists + //into the scaDefns. + scaDefns.getIntents().clear(); + scaDefns.getPolicySets().clear(); + scaDefns.getBindingTypes().clear(); + scaDefns.getImplementationTypes().clear(); + + scaDefns.getIntents().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(Definitions scaDefns, + Map<QName, BindingType> definedBindingTypes, + Map<QName, Intent> definedIntents) throws DefinitionsBuilderException { + for (BindingType bindingType : scaDefns.getBindingTypes()) { + buildAlwaysProvidedIntents(bindingType, definedIntents); + buildMayProvideIntents(bindingType, definedIntents); + } + + } + + private void buildImplementationTypes(Definitions scaDefns, + Map<QName, ImplementationType> definedImplTypes, + Map<QName, Intent> definedIntents) throws DefinitionsBuilderException { + for (ImplementationType implType : scaDefns.getImplementationTypes()) { + buildAlwaysProvidedIntents(implType, definedIntents); + buildMayProvideIntents(implType, definedIntents); + } + } + + private void buildPolicyIntents(Definitions scaDefns, Map<QName, Intent> definedIntents) + throws DefinitionsBuilderException { + for (Intent policyIntent : scaDefns.getIntents()) { + if (!policyIntent.getRequiredIntents().isEmpty()) { + buildProfileIntent(policyIntent, definedIntents); + } + + if (!policyIntent.getQualifiedIntents().isEmpty()) { + buildQualifiedIntent(policyIntent, definedIntents); + } + } + } + + private void buildPolicySets(Definitions scaDefns, + Map<QName, PolicySet> definedPolicySets, + Map<QName, Intent> definedIntents) throws DefinitionsBuilderException { + + 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(Intent policyIntent, Map<QName, Intent> definedIntents) + throws DefinitionsBuilderException { + //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 DefinitionsBuilderException("Required Intent - " + requiredIntent + + " not found for ProfileIntent " + + policyIntent); + + } + } else { + requiredIntents.add(requiredIntent); + } + } + policyIntent.getRequiredIntents().clear(); + policyIntent.getRequiredIntents().addAll(requiredIntents); + } + } + + private void buildQualifiedIntent(Intent policyIntent, Map<QName, Intent> definedIntents) + throws DefinitionsBuilderException { + /* + 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 DefinitionsBuilderException("Qualifiable Intent - " + qualifiableIntent + + " not found for QualifiedIntent " + + policyIntent); + } + + } + } + */ + } + + private void buildAlwaysProvidedIntents(ExtensionType extensionType, Map<QName, Intent> definedIntents) + throws DefinitionsBuilderException { + 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 DefinitionsBuilderException("Always Provided Intent - " + providedIntent + + " not found for ExtensionType " + + extensionType); + + } + } else { + alwaysProvided.add(providedIntent); + } + } + extensionType.getAlwaysProvidedIntents().clear(); + extensionType.getAlwaysProvidedIntents().addAll(alwaysProvided); + } + } + + private void buildMayProvideIntents(ExtensionType extensionType, Map<QName, Intent> definedIntents) + throws DefinitionsBuilderException { + if (extensionType != null) { + // resolve all provided intents + List<Intent> mayProvide = new ArrayList<Intent>(); + for (Intent providedIntent : extensionType.getMayProvidedIntents()) { + if (providedIntent.isUnresolved()) { + Intent resolvedProvidedIntent = definedIntents.get(providedIntent.getName()); + if (resolvedProvidedIntent != null) { + mayProvide.add(resolvedProvidedIntent); + } else { + throw new DefinitionsBuilderException("May Provide Intent - " + providedIntent + + " not found for ExtensionType " + + extensionType); + + } + } else { + mayProvide.add(providedIntent); + } + } + extensionType.getMayProvidedIntents().clear(); + extensionType.getMayProvidedIntents().addAll(mayProvide); + } + } + + private void buildProvidedIntents(PolicySet policySet, Map<QName, Intent> definedIntents) + throws DefinitionsBuilderException { + 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 DefinitionsBuilderException("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 DefinitionsBuilderException { + for (IntentMap intentMap : policySet.getIntentMaps()) { + for (Qualifier qualifier : intentMap.getQualifiers()) { + Intent mappedIntent = qualifier.getIntent(); + if (mappedIntent.isUnresolved()) { + Intent resolvedMappedIntent = definedIntents.get(mappedIntent.getName()); + + if (resolvedMappedIntent != null) { + qualifier.setIntent(resolvedMappedIntent); + } else { + throw new DefinitionsBuilderException("Mapped Intent - " + mappedIntent + + " not found for PolicySet " + + policySet); + + } + } + } + } + } + + private void buildReferredPolicySets(PolicySet policySet, Map<QName, PolicySet> definedPolicySets) + throws DefinitionsBuilderException { + + 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 DefinitionsBuilderException("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.getIntentMaps().addAll(referredPolicySet.getIntentMaps()); + } +} |