elimintated the system assembler.

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

diff --git a/system/general/src/main/java/org/wamblee/system/Container.java b/system/general/src/main/java/org/wamblee/system/Container.java
index a1bb29c24554967812b739636c4ebf443b96e1ee..bd059902d5f2a5995c5bfe6cf283fbe95f315536 100644 (file)
--- a/system/general/src/main/java/org/wamblee/system/Container.java
+++ b/system/general/src/main/java/org/wamblee/system/Container.java
@@ -17,13 +17,14 @@ package org.wamblee.system;
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 
-import sun.util.LocaleServiceProviderPool.LocalizedObjectGetter;
-
 /**
  * Composite system consisting of multiple subsystems. 
  *
@@ -35,6 +36,30 @@ public class Container extends AbstractComponent {
 
        private Component[] _systems;
 
+       public static RequiredInterface[] filterRequiredServices(
+                       ProvidedInterface aProvided,
+                       Collection<RequiredInterface> aDescriptors) {
+               List<RequiredInterface> required = new ArrayList<RequiredInterface>();
+               for (RequiredInterface descriptor : aDescriptors) {
+                       if (descriptor.implementedBy(aProvided)) {
+                               required.add(descriptor);
+                       }
+               }
+               return required.toArray(new RequiredInterface[0]);
+       }
+
+       public static ProvidedInterface[] filterProvidedServices(
+                       RequiredInterface aRequired,
+                       Collection<ProvidedInterface> aProvided) {
+               List<ProvidedInterface> provided = new ArrayList<ProvidedInterface>();
+               for (ProvidedInterface descriptor : aProvided) {
+                       if (aRequired.implementedBy(descriptor)) {
+                               provided.add(descriptor);
+                       }
+               }
+               return provided.toArray(new ProvidedInterface[0]);
+       }
+       
        /**
         * Construcst the composite system. 
         * @param aName Name of the system. 
@@ -87,7 +112,7 @@ public class Container extends AbstractComponent {
                // Compute all required interfaces that are not provided
                for (ProvidedInterface service : provided) {
                        List<RequiredInterface> fulfilled = 
-                               Arrays.asList(SystemAssembler.filterRequiredServices(service, 
+                               Arrays.asList(filterRequiredServices(service, 
                                        reallyRequired));
                        reallyRequired.removeAll(fulfilled); 
                }
@@ -119,11 +144,65 @@ public class Container extends AbstractComponent {
                        provided.add(intf.getProvider());
                }
                
-               SystemAssembler assembler = new SystemAssembler( _systems, 
-                               provided.toArray(new ProvidedInterface[0]));
-               assembler.start();
+               startImpl();
        }
        
+       /**
+        * Starts the subsystems.
+        * 
+        * @param aRequiredServices
+        *            Services that are available from other systems that have been
+        *            started before.
+        */
+       private void startImpl() {
+               LOG.info("Starting '" + "'");
+               List<ProvidedInterface> allProvided = new ArrayList<ProvidedInterface>();
+               
+               // Add the provides of all externally required interfaces to the list of available
+               // interfaces
+               for (RequiredInterface required: getRequiredServices()) { 
+                       allProvided.add(required.getProvider());
+               }
+               
+               for (Component system : _systems) {
+                       // Check if all required services are already provided by earlier
+                       // systems.
+                       RequiredInterface[] required = system.getRequiredServices();
+
+                       for (RequiredInterface descriptor : required) {
+                               ProvidedInterface[] filtered = filterProvidedServices(
+                                               descriptor, allProvided);
+
+                               if (filtered.length == 0) {
+                                       throw new SystemAssemblyException(
+                                                       "Service '"
+                                                                       + descriptor
+                                                                       + "' required by system '"
+                                                                       + system
+                                                                       + "' is not provided by systems that are started earlier");
+                               }
+                               if (filtered.length > 1) {
+                                       throw new SystemAssemblyException(
+                                                       "Service '"
+                                                                       + descriptor
+                                                                       + "' required by system '"
+                                                                       + system
+                                                                       + "' matches multiple services provided by other systems: " + 
+                                                                       Arrays.asList(filtered));
+                               }
+                               descriptor.setProvider(filtered[0]);
+                       }
+                       
+                       // Start the service. 
+                       system.start(getQualifiedName());
+
+                       // add all provided services
+                       ProvidedInterface[] provided = system.getProvidedServices();
+                       allProvided.addAll(Arrays.asList(provided));
+               }
+       }
+
+       
        @Override
        protected void doStop() {
                for (int i = _systems.length-1; i >= 0; i--) {