(no commit message)

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

diff --git a/system/general/src/main/java/org/wamblee/system/core/AbstractComponent.java b/system/general/src/main/java/org/wamblee/system/core/AbstractComponent.java
index 9608f4179d2aca1a07b4ed4ed81d96d6217d9113..31e50ed58ad251bf90a1cd8afdffde7656aadf89 100644 (file)
--- a/system/general/src/main/java/org/wamblee/system/core/AbstractComponent.java
+++ b/system/general/src/main/java/org/wamblee/system/core/AbstractComponent.java
@@ -17,6 +17,7 @@ package org.wamblee.system.core;
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
@@ -55,7 +56,7 @@ public abstract class AbstractComponent<Type> implements Component<Type> {
                _name = aName;
                _provided = new ArrayList<ProvidedInterface>();
                _provided.addAll(Arrays.asList(aProvided));
-               _required = new ArrayList<RequiredInterface>();
+               _required = new ArrayList<RequiredInterface>(); 
                _required.addAll(Arrays.asList(aRequired));
        }
        
@@ -63,12 +64,12 @@ public abstract class AbstractComponent<Type> implements Component<Type> {
                this(aName, new ProvidedInterface[0], new RequiredInterface[0]);
        }
        
-       protected AbstractComponent addProvidedInterface(ProvidedInterface aProvided) { 
+       public AbstractComponent addProvidedInterface(ProvidedInterface aProvided) { 
                _provided.add(aProvided);
                return this; 
        }
        
-       protected AbstractComponent addRequiredInterface(RequiredInterface aRequired) { 
+       public AbstractComponent addRequiredInterface(RequiredInterface aRequired) { 
                _required.add(aRequired);
                return this;
        }
@@ -87,6 +88,7 @@ public abstract class AbstractComponent<Type> implements Component<Type> {
                }
        }
        
+       @Override
        public String getContext() {
                return _context;
        }
@@ -100,23 +102,24 @@ public abstract class AbstractComponent<Type> implements Component<Type> {
        }
 
        @Override
-       public final ProvidedInterface[] getProvidedInterfaces() {
-               return _provided.toArray(new ProvidedInterface[0]);
+       public final ProvidedInterfaces getProvidedInterfaces() {
+               return new ProvidedInterfaces(Collections.unmodifiableList(_provided));
        }
 
        @Override
-       public final RequiredInterface[] getRequiredInterfaces() {
-               return _required.toArray(new RequiredInterface[0]);
+       public final RequiredInterfaces getRequiredInterfaces() {
+               return new RequiredInterfaces(Collections.unmodifiableList(_required));
        }
 
        @Override
        public final Type start(Scope aScope) {
-               LOG.info("Initializing '" + getQualifiedName() + "'");
+               LOG.info("Initialization starting '" + getQualifiedName() + "'");
                List<ProvidedInterface> oldRemaining = _remaining.get();
-               _remaining.set(new ArrayList<ProvidedInterface>(Arrays.asList(getProvidedInterfaces())));
+               _remaining.set(new ArrayList<ProvidedInterface>(Arrays.asList(getProvidedInterfaces().toArray())));
                try {
                        Type runtime = doStart(aScope);
                        checkNotStartedInterfaces();
+                       LOG.info("Initialization finished '" + getQualifiedName() + "'");
                        return runtime;
                } finally {
                        _remaining.set(oldRemaining);
@@ -157,13 +160,18 @@ public abstract class AbstractComponent<Type> implements Component<Type> {
                        Object aService, Scope aScope) {
                LOG.info("Interface '" + getQualifiedName() + "."
                                + aDescriptor.getName() + "' started.");
-               _remaining.get().remove(aDescriptor);
+               if ( !_remaining.get().remove(aDescriptor) ) { 
+                   throw new SystemAssemblyException("Component '" + getQualifiedName() + "' started an unexpected interface '" + 
+                           aDescriptor + "' that was not registerd as a provided interface before");
+               }
                aScope.publishInterface(aDescriptor, aService);
        }
 
        @Override
        public void stop(Type aRuntime) {
+           LOG.info("Stopping initiated '" + getQualifiedName() + "'");
                doStop(aRuntime);
+               LOG.info("Stopping completed '" + getQualifiedName() + "'");
        }
 
        protected abstract void doStop(Type aRuntime);
@@ -172,5 +180,23 @@ public abstract class AbstractComponent<Type> implements Component<Type> {
        public String toString() {
                return getQualifiedName();
        }
+       
+       public ProvidedInterface findProvidedInterface(String aName) { 
+           for (ProvidedInterface provided: getProvidedInterfaces()) { 
+               if ( provided.getName().equals(aName)) { 
+                   return provided; 
+               }
+           }
+           return null; 
+       }
+       
+       public RequiredInterface findRequiredInterface(String aName) { 
+           for (RequiredInterface required: getRequiredInterfaces()) { 
+               if ( required.getName().equals(aName)) { 
+                   return required; 
+               }
+           }
+           return null; 
+       }
 
 }