(no commit message)

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

diff --git a/system/general/src/main/java/org/wamblee/system/SystemAssembler.java b/system/general/src/main/java/org/wamblee/system/SystemAssembler.java
index 5cdb3890cc5a3b810345f0dc114b424d143af7e6..90a98440ca877d7d98e02fed010a1a6017fa4cb1 100644 (file)
--- a/system/general/src/main/java/org/wamblee/system/SystemAssembler.java
+++ b/system/general/src/main/java/org/wamblee/system/SystemAssembler.java
@@ -1,11 +1,28 @@
+/*
+ * Copyright 2007 the original author or authors.
+ * 
+ * Licensed 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.wamblee.system;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
@@ -23,6 +40,7 @@ public class SystemAssembler {
        private static final String ROOT_CONTEXT_NAME = "root";
        private String _context;
        private Component[] _systems;
+       private ProvidedInterface[] _required; 
 
        public static RequiredInterface[] filterRequiredServices(
                        ProvidedInterface aProvided,
@@ -77,18 +95,19 @@ public class SystemAssembler {
                        ProvidedInterface[] aAvailableServices) {
                _context = aContext;
                _systems = aSystems;
-               validate(aAvailableServices);
+               _required = aAvailableServices; 
+               validate();
        }
 
        /**
         * Determines if the systems are ordered appropriately so that all
         * dependencies are met.
         */
-       private void validate(ProvidedInterface[] aDescriptors)
+       private void validate()
                        throws SystemAssemblyException {
 
                List<ProvidedInterface> allProvided = new ArrayList<ProvidedInterface>();
-               for (ProvidedInterface descriptor : aDescriptors) {
+               for (ProvidedInterface descriptor : _required) {
                        allProvided.add(descriptor);
                }
                for (Component system : _systems) {
@@ -128,39 +147,36 @@ public class SystemAssembler {
        /**
         * Starts the subsystems.
         * 
-        * @param aRegistry
-        *            Service registry to which created services must be registered.
         * @param aRequiredServices
         *            Services that are available from other systems that have been
         *            started before.
         */
-       public void start(ServiceRegistry aRegistry, Service[] aRequiredServices) {
+       public void start() {
                LOG.info("Starting '" + _context + "'");
-               Map<ProvidedInterface, Service> allProvided = new HashMap<ProvidedInterface, Service>();
-
-               for (Service service : aRequiredServices) {
-                       allProvided.put(service.getDescriptor(), service);
-               }
+               Set<ProvidedInterface> allProvided = new HashSet<ProvidedInterface>();
+               allProvided.addAll(Arrays.asList(_required));
+               
                for (Component system : _systems) {
                        
                        // Compose a list of the required services required for the subsystem.
                        
                        RequiredInterface[] descriptors = system
                                        .getRequiredServices();
-                       List<Service> services = new ArrayList<Service>();
-                       for (RequiredInterface descriptor : descriptors) {
+                       List<ProvidedInterface> services = new ArrayList<ProvidedInterface>();
+                       for (RequiredInterface required : descriptors) {
                                ProvidedInterface[] provided = filterProvidedServices(
-                                               descriptor, allProvided.keySet());
-                               services.add(allProvided.get(provided[0]));
+                                               required, allProvided);
+                               assert provided.length == 1;    
+                               services.add(provided[0]);
+                               required.setProvider(provided[0]);
                        }
                        
                        // Start the service. 
-                       Service[] provided = system.start(_context, services
-                                       .toArray(new Service[0]));
+                       system.start(_context);
                        
-                       // Add started services to the map of started services.
-                       for (Service service : provided) {
-                               allProvided.put(service.getDescriptor(), service);
+                       // Add started services to the set of started services.
+                       for (ProvidedInterface service : system.getProvidedServices()) {
+                               allProvided.add(service);
                        }
 
                }