(no commit message)

[utils] / system / general / src / main / java / org / wamblee / system / container / Container.java

diff --git a/system/general/src/main/java/org/wamblee/system/container/Container.java b/system/general/src/main/java/org/wamblee/system/container/Container.java
index 92aba2144c3286f49ef0554fa5b537b6acf9e1b3..60456c5e4cdb98f84b74ab811eeab0c96cac53bf 100644 (file)
--- a/system/general/src/main/java/org/wamblee/system/container/Container.java
+++ b/system/general/src/main/java/org/wamblee/system/container/Container.java
@@ -16,6 +16,7 @@
 package org.wamblee.system.container;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
@@ -30,7 +31,11 @@ import org.wamblee.system.core.ProvidedInterface;
 import org.wamblee.system.core.RequiredInterface;
 import org.wamblee.system.core.Scope;
 import org.wamblee.system.core.SystemAssemblyException;
+import org.wamblee.system.graph.CompositeEdgeFilter;
 import org.wamblee.system.graph.component.ComponentGraph;
+import org.wamblee.system.graph.component.ConnectExternalProvidedProvidedFilter;
+import org.wamblee.system.graph.component.ConnectRequiredExternallyRequiredEdgeFilter;
+import org.wamblee.system.graph.component.ConnectRequiredProvidedEdgeFilter;
 
 /**
  * Container consisting of multiple components.
@@ -43,7 +48,7 @@ public class Container extends AbstractComponent<Scope> {
 
     private List<Component> _components;
     private Set<String> _componentNames;
-    private CompositeInterfaceRestriction _restriction;
+    private CompositeEdgeFilter _edgeFilter; 
     private boolean _sealed;
 
     /**
@@ -59,17 +64,34 @@ public class Container extends AbstractComponent<Scope> {
      *            Required services by the container.
      */
     public Container(String aName, Component[] aComponents,
-            ProvidedInterface[] aProvided, RequiredInterface[] aRequired) {
+            List<ProvidedInterface> aProvided, List<RequiredInterface> aRequired) {
         super(aName, aProvided, aRequired);
         _components = new ArrayList<Component>();
 
         _componentNames = new HashSet<String>();
-        _restriction = new CompositeInterfaceRestriction();
+        _edgeFilter = new CompositeEdgeFilter();
         _sealed = false;
         for (Component component : aComponents) {
             addComponent(component);
         }
     }
+    
+    /**
+     * Constructs the container
+     * 
+     * @param aName
+     *            Name of the container
+     * @param aComponents
+     *            Components.
+     * @param aProvided
+     *            Provided services of the container
+     * @param aRequired
+     *            Required services by the container.
+     */
+    public Container(String aName, Component[] aComponents,
+            ProvidedInterface[] aProvided, RequiredInterface[] aRequired) {
+        this(aName, aComponents, Arrays.asList(aProvided), Arrays.asList(aRequired));
+    }
 
     public Container(String aName) {
         this(aName, new Component[0], new ProvidedInterface[0],
@@ -93,20 +115,43 @@ public class Container extends AbstractComponent<Scope> {
         aComponent.addContext(getQualifiedName());
         return this;
     }
-
+    
     /**
-     * Adds an interface restriction for explicitly configuring the relations
-     * between components.
-     * 
-     * @param aRestriction
-     *            Restriction to add.
-     * @return Reference to this to allow call chaining.
+     * Explictly connects required and provided interfaces. 
+     * @param aClientComponent Client component, may not be null. 
+     * @param aRequiredInterface Required interface. If null it means all required interfaces. 
+     * @param aServerComponent Server component to connect to. If null, it means that no server components
+     *         may be connected to and the provider of the required interface will be null. 
+     * @param aProvidedInterface Provided interface. If null, it means that there is no restriction on the 
+     *   name of the provided interface and that it is automatically selected. 
      */
-    public Container addRestriction(InterfaceRestriction aRestriction) {
+    public void connectRequiredProvided(String aClientComponent, String aRequiredInterface, 
+            String aServerComponent, String aProvidedInterface) {
         checkSealed();
-        _restriction.add(aRestriction);
-        return this;
+        // TODO validate 
+        _edgeFilter.add(new ConnectRequiredProvidedEdgeFilter(aClientComponent, aRequiredInterface, aServerComponent, aProvidedInterface));
     }
+    
+    /**
+     * Explicitly connects a externally required interface to an internally required interface. 
+     * @param aComponent Component requiring the interface (must be non-null). 
+     * @param aRequiredInterface Required interface of the component (must be non-null).
+     * @param aExternalRequiredInterface Externally required interface (must be non-null).
+     */
+    public void connectExternalRequired(String aComponent, String aRequiredInterface, 
+            String aExternalRequiredInterface) {
+        checkSealed();
+        // TODO validate
+        _edgeFilter.add(new ConnectRequiredExternallyRequiredEdgeFilter(
+                aComponent, aRequiredInterface, aExternalRequiredInterface));
+    }
+    
+    public void connectExternalProvided(String aExternalProvided, String aComponent, String aProvidedInterface) {
+        checkSealed();
+        // TODO validate
+        _edgeFilter.add(new ConnectExternalProvidedProvidedFilter(aExternalProvided, aComponent, aProvidedInterface));
+    }
+
 
     @Override
     public Container addProvidedInterface(ProvidedInterface aProvided) {
@@ -175,7 +220,7 @@ public class Container extends AbstractComponent<Scope> {
     protected Scope doStart(Scope aExternalScope) {
         checkSealed();
         validate();
-        Scope scope = new DefaultScope(getProvidedInterfaces(), aExternalScope);
+        Scope scope = new DefaultScope(getProvidedInterfaces().toArray(new ProvidedInterface[0]), aExternalScope);
         ComponentGraph graph = doStartOptionalDryRun(scope, false);
         exposeProvidedInterfaces(graph, aExternalScope, scope);
         seal();
@@ -233,7 +278,7 @@ public class Container extends AbstractComponent<Scope> {
             graph.addProvidedInterface(this, prov);
         }
 
-        graph.addRestriction(_restriction);
+        graph.addEdgeFilter(_edgeFilter);
         return graph;
     }