updated coding rules.

[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 28bb6ff19b28b0f93988695525f672d9fec35bb5..579fd27435907d4ee9c0db8466fb1bb12db71270 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,9 +17,8 @@ package org.wamblee.system.core;
 
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.HashSet;
+import java.util.Collections;
 import java.util.List;
-import java.util.Set;
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
@@ -31,12 +30,12 @@ public abstract class AbstractComponent<Type> implements Component<Type> {
 
        private static final Log LOG = LogFactory.getLog(AbstractComponent.class);
 
-       private ThreadLocal<List<ProvidedInterface>> _remaining;
+       private ThreadLocal<List<ProvidedInterface>> remaining;
 
-       private String _context;
-       private String _name;
-       private List<ProvidedInterface> _provided;
-       private List<RequiredInterface> _required;
+       private String context;
+       private String name;
+       private List<ProvidedInterface> provided;
+       private List<RequiredInterface> required;
 
        /**
         * Constructs the subsystem.
@@ -48,86 +47,100 @@ public abstract class AbstractComponent<Type> implements Component<Type> {
         * @param aRequired
         *            Required services.
         */
-       protected AbstractComponent(String aName, ProvidedInterface[] aProvided,
-                       RequiredInterface[] aRequired) {
-               _remaining = new ThreadLocal<List<ProvidedInterface>>();
-               _context = null;
-               _name = aName;
-               _provided = new ArrayList<ProvidedInterface>();
-               _provided.addAll(Arrays.asList(aProvided));
-               _required = new ArrayList<RequiredInterface>();
-               _required.addAll(Arrays.asList(aRequired));
+       protected AbstractComponent(String aName, List<ProvidedInterface> aProvided,
+                       List<RequiredInterface> aRequired) {
+               remaining = new ThreadLocal<List<ProvidedInterface>>();
+               context = null;
+               name = aName;
+               provided = new ArrayList<ProvidedInterface>(aProvided);
+               required = new ArrayList<RequiredInterface>(aRequired); 
        }
        
+       /**
+     * Constructs the subsystem.
+     * 
+     * @param aName
+     *            Name of the system.
+     * @param aProvided
+     *            Provided services.
+     * @param aRequired
+     *            Required services.
+     */
+    protected AbstractComponent(String aName, ProvidedInterface[] aProvided,
+            RequiredInterface[] aRequired) {
+        this(aName, Arrays.asList(aProvided), Arrays.asList(aRequired));
+    }
+       
        protected AbstractComponent(String aName) {
                this(aName, new ProvidedInterface[0], new RequiredInterface[0]);
        }
        
-       public AbstractComponent addProvidedInterface(ProvidedInterface aProvided) { 
-               _provided.add(aProvided);
+       public AbstractComponent<Type> addProvidedInterface(ProvidedInterface aProvided) { 
+               provided.add(aProvided);
                return this; 
        }
        
-       public AbstractComponent addRequiredInterface(RequiredInterface aRequired) { 
-               _required.add(aRequired);
+       public AbstractComponent<Type> addRequiredInterface(RequiredInterface aRequired) { 
+               required.add(aRequired);
                return this;
        }
        
        @Override
        public final String getName() {
-               return _name;
+               return name;
        }
 
        @Override
        public void addContext(String aContext) {
-               if (_context == null) {
-                       _context = aContext;
+               if (context == null) {
+                       context = aContext;
                } else {
-                       _context = aContext + "." + _context;
+                       context = aContext + "." + context;
                }
        }
        
        @Override
        public String getContext() {
-               return _context;
+               return context;
        }
 
        @Override
        public String getQualifiedName() {
-               if (_context == null) {
+               if (context == null) {
                        return getName();
                }
-               return _context + "." + getName();
+               return context + "." + getName();
        }
 
        @Override
-       public final ProvidedInterface[] getProvidedInterfaces() {
-               return _provided.toArray(new ProvidedInterface[0]);
+       public final List<ProvidedInterface> getProvidedInterfaces() {
+               return Collections.unmodifiableList(provided);
        }
 
        @Override
-       public final RequiredInterface[] getRequiredInterfaces() {
-               return _required.toArray(new RequiredInterface[0]);
+       public final List<RequiredInterface> getRequiredInterfaces() {
+               return Collections.unmodifiableList(required);
        }
 
        @Override
        public final Type start(Scope aScope) {
-               LOG.info("Initializing '" + getQualifiedName() + "'");
-               List<ProvidedInterface> oldRemaining = _remaining.get();
-               _remaining.set(new ArrayList<ProvidedInterface>(Arrays.asList(getProvidedInterfaces())));
+               LOG.info("Initialization starting '" + getQualifiedName() + "'");
+               List<ProvidedInterface> oldRemaining = remaining.get();
+               remaining.set(new ArrayList<ProvidedInterface>(getProvidedInterfaces()));
                try {
                        Type runtime = doStart(aScope);
                        checkNotStartedInterfaces();
+                       LOG.info("Initialization finished '" + getQualifiedName() + "'");
                        return runtime;
                } finally {
-                       _remaining.set(oldRemaining);
+                       remaining.set(oldRemaining);
                }
        }
 
        private void checkNotStartedInterfaces() {
-               if (_remaining.get().size() > 0) {
+               if (remaining.get().size() > 0) {
                        String notProvided = "";
-                       for (ProvidedInterface provided : _remaining.get()) {
+                       for (ProvidedInterface provided : remaining.get()) {
                                notProvided += "\nComponent " + getQualifiedName()
                                                + " did not start interface " + provided;
                        }
@@ -137,7 +150,7 @@ public abstract class AbstractComponent<Type> implements Component<Type> {
 
        /**
         * Must be implemented for initializing the subsystem. The implementation
-        * must call {@link #addService(Service)} for each service that is started.
+        * must call {@link #addInterface(ProvidedInterface, Object, Scope)} for each service that is started.
         * 
         * @return Returns the runtime of the component.
         */
@@ -158,13 +171,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);
@@ -173,5 +191,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; 
+       }
 
 }