X-Git-Url: http://wamblee.org/gitweb/?a=blobdiff_plain;f=system%2Fgeneral%2Fsrc%2Fmain%2Fjava%2Forg%2Fwamblee%2Fsystem%2FSystemAssembler.java;h=90a98440ca877d7d98e02fed010a1a6017fa4cb1;hb=7526813969742844aefbd25e8a4a056985dc7f65;hp=561e3f9569ebcf39db1770a5bcda7ee517075e16;hpb=6528585feb4b95cd50d63d5f4230b5eeb3e606d9;p=utils

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 561e3f95..90a98440 100644
--- 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,29 +40,30 @@ public class SystemAssembler {
 	private static final String ROOT_CONTEXT_NAME = "root";
 	private String _context;
 	private Component[] _systems;
+	private ProvidedInterface[] _required; 
 
-	public static RequiredInterfaceDescriptor[] filterRequiredServices(
-			ProvidedInterfaceDescriptor aProvided,
-			Collection<RequiredInterfaceDescriptor> aDescriptors) {
-		List<RequiredInterfaceDescriptor> required = new ArrayList<RequiredInterfaceDescriptor>();
-		for (RequiredInterfaceDescriptor descriptor : aDescriptors) {
+	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 RequiredInterfaceDescriptor[0]);
+		return required.toArray(new RequiredInterface[0]);
 	}
 
-	public static ProvidedInterfaceDescriptor[] filterProvidedServices(
-			RequiredInterfaceDescriptor aRequired,
-			Collection<ProvidedInterfaceDescriptor> aProvided) {
-		List<ProvidedInterfaceDescriptor> provided = new ArrayList<ProvidedInterfaceDescriptor>();
-		for (ProvidedInterfaceDescriptor descriptor : aProvided) {
+	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 ProvidedInterfaceDescriptor[0]);
+		return provided.toArray(new ProvidedInterface[0]);
 	}
 
 	/**
@@ -58,7 +76,7 @@ public class SystemAssembler {
 	 *            that this assembler manages.
 	 */
 	public SystemAssembler(Component[] aSystems,
-			ProvidedInterfaceDescriptor[] aAvailableServices) {
+			ProvidedInterface[] aAvailableServices) {
 		this(ROOT_CONTEXT_NAME, aSystems, aAvailableServices);
 	}
 
@@ -74,30 +92,31 @@ public class SystemAssembler {
 	 *            that this assembler manages.
 	 */
 	public SystemAssembler(String aContext, Component[] aSystems,
-			ProvidedInterfaceDescriptor[] aAvailableServices) {
+			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(ProvidedInterfaceDescriptor[] aDescriptors)
+	private void validate()
 			throws SystemAssemblyException {
 
-		List<ProvidedInterfaceDescriptor> allProvided = new ArrayList<ProvidedInterfaceDescriptor>();
-		for (ProvidedInterfaceDescriptor descriptor : aDescriptors) {
+		List<ProvidedInterface> allProvided = new ArrayList<ProvidedInterface>();
+		for (ProvidedInterface descriptor : _required) {
 			allProvided.add(descriptor);
 		}
 		for (Component system : _systems) {
 			// Check if all required services are already provided by earlier
 			// systems.
-			RequiredInterfaceDescriptor[] required = system.getRequiredServices();
+			RequiredInterface[] required = system.getRequiredServices();
 
-			for (RequiredInterfaceDescriptor descriptor : required) {
-				ProvidedInterfaceDescriptor[] filtered = filterProvidedServices(
+			for (RequiredInterface descriptor : required) {
+				ProvidedInterface[] filtered = filterProvidedServices(
 						descriptor, allProvided);
 
 				if (filtered.length == 0) {
@@ -120,7 +139,7 @@ public class SystemAssembler {
 			}
 
 			// add all provided services
-			ProvidedInterfaceDescriptor[] provided = system.getProvidedServices();
+			ProvidedInterface[] provided = system.getProvidedServices();
 			allProvided.addAll(Arrays.asList(provided));
 		}
 	}
@@ -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<ProvidedInterfaceDescriptor, Service> allProvided = new HashMap<ProvidedInterfaceDescriptor, 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.
 			
-			RequiredInterfaceDescriptor[] descriptors = system
+			RequiredInterface[] descriptors = system
 					.getRequiredServices();
-			List<Service> services = new ArrayList<Service>();
-			for (RequiredInterfaceDescriptor descriptor : descriptors) {
-				ProvidedInterfaceDescriptor[] provided = filterProvidedServices(
-						descriptor, allProvided.keySet());
-				services.add(allProvided.get(provided[0]));
+			List<ProvidedInterface> services = new ArrayList<ProvidedInterface>();
+			for (RequiredInterface required : descriptors) {
+				ProvidedInterface[] provided = filterProvidedServices(
+						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);
 			}
 
 		}