(no commit message)

[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 a80aa1a21f0c7136b2acd66d8c2b8f9eff6091bf..a1bb29c24554967812b739636c4ebf443b96e1ee 100644 (file)
--- a/system/general/src/main/java/org/wamblee/system/Container.java
+++ b/system/general/src/main/java/org/wamblee/system/Container.java
@@ -1,3 +1,18 @@
+/*
+ * 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;
@@ -28,11 +43,11 @@ public class Container extends AbstractComponent {
         * @param aProvided Provided services of the system. 
         * @param aRequired Required services by the system. 
         */
-       public Container(String aName, ServiceRegistry aRegistry, Component[] aSystems,
-                       ProvidedInterfaceDescriptor[] aProvided, RequiredInterfaceDescriptor[] aRequired) {
-               super(aName, aRegistry, aProvided, aRequired);
+       public Container(String aName, Component[] aSystems,
+                       ProvidedInterface[] aProvided, RequiredInterface[] aRequired) {
+               super(aName, aProvided, aRequired);
                _systems = aSystems;
-               validate();
+               validate(aRequired);
        }
 
        /**
@@ -41,25 +56,25 @@ public class Container extends AbstractComponent {
         * no services in the provided list that cannot be provided. 
         * Also logs a warning in case of superfluous requirements.  
         */
-       private void validate() {
-               List<InterfaceDescriptor> provided = new ArrayList<InterfaceDescriptor>();
+       private void validate(RequiredInterface[] aRequired) {
+               List<ProvidedInterface> provided = new ArrayList<ProvidedInterface>();
                for (Component system : _systems) {
                        provided.addAll(Arrays.asList(system.getProvidedServices()));
                }
 
-               List<InterfaceDescriptor> required = new ArrayList<InterfaceDescriptor>();
+               List<RequiredInterface> required = new ArrayList<RequiredInterface>();
                for (Component system : _systems) {
                        required.addAll(Arrays.asList(system.getRequiredServices()));
                }
 
-               for (InterfaceDescriptor service : getProvidedServices()) {
+               for (ProvidedInterface service : getProvidedServices()) {
                        if (!(provided.contains(service))) {
                                throw new SystemAssemblyException(getName() + ": Service '" + service
                                                + "' is not provided by any of the subsystems");
                        }
                }
 
-               for (InterfaceDescriptor service : getRequiredServices()) {
+               for (RequiredInterface service : getRequiredServices()) {
                        if (!(required.contains(service))) {
                                info("Service '"
                                                + service
@@ -67,16 +82,21 @@ public class Container extends AbstractComponent {
                        }
                }
 
-               List<InterfaceDescriptor> reallyRequired = new ArrayList<InterfaceDescriptor>(
+               List<RequiredInterface> reallyRequired = new ArrayList<RequiredInterface>(
                                required);
-               for (InterfaceDescriptor service : provided) {
-                       reallyRequired.remove(service); 
-               }
-               for (InterfaceDescriptor service: getRequiredServices()) { 
-                       reallyRequired.remove(service); 
+               // Compute all required interfaces that are not provided
+               for (ProvidedInterface service : provided) {
+                       List<RequiredInterface> fulfilled = 
+                               Arrays.asList(SystemAssembler.filterRequiredServices(service, 
+                                       reallyRequired));
+                       reallyRequired.removeAll(fulfilled); 
                }
+               // Now the remaining interfaces should be covered by the required
+               // list. 
+               reallyRequired.removeAll(Arrays.asList(aRequired));
+               
                String missingRequired = "";
-               for (InterfaceDescriptor service: reallyRequired) {
+               for (RequiredInterface service: reallyRequired) {
                        missingRequired += service + "\n";
                }
                if ( missingRequired.length() > 0 ) { 
@@ -85,14 +105,23 @@ public class Container extends AbstractComponent {
        }
 
        @Override
-       protected void doStart(String aContext, Service[] aRequiredServices) {
-               List<ProvidedInterfaceDescriptor> descriptors = new ArrayList<ProvidedInterfaceDescriptor>();
-               for (Service service : aRequiredServices) {
-                       descriptors.add(service.getDescriptor());
+       protected void doStart(String aContext) {
+               List<ProvidedInterface> provided = new ArrayList<ProvidedInterface>();
+               
+               // all interfaces from the required list of this container are
+               // provided to the components inside it.
+               RequiredInterface[] required = getRequiredServices();
+               for (RequiredInterface intf: required) { 
+                   ProvidedInterface provider = intf.getProvider(); 
+                   if ( provider == null ) { 
+                       throw new SystemAssemblyException(aContext + ": required interface '" + intf +"' is not provided");
+                   }
+                       provided.add(intf.getProvider());
                }
-               SystemAssembler assembler = new SystemAssembler(aContext + "." + getName(), _systems,
-                               descriptors.toArray(new ProvidedInterfaceDescriptor[0]));
-               assembler.start(getRegistry(), aRequiredServices);
+               
+               SystemAssembler assembler = new SystemAssembler( _systems, 
+                               provided.toArray(new ProvidedInterface[0]));
+               assembler.start();
        }
        
        @Override