X-Git-Url: http://wamblee.org/gitweb/?a=blobdiff_plain;f=system%2Fgeneral%2Fsrc%2Fmain%2Fjava%2Forg%2Fwamblee%2Fsystem%2Fcore%2FAbstractComponent.java;h=579fd27435907d4ee9c0db8466fb1bb12db71270;hb=0d8d8f24656e585ee75558cfd6a4c661f8f14985;hp=3c6be957ff78034e49f59e02284d8653600e77f2;hpb=207768f2ce440fb0359582e1e4d39ddaf7e2b989;p=utils

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 3c6be957..579fd274 100644
--- 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,14 +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 '" + getQualifiedName() + "'");
+	    LOG.info("Stopping initiated '" + getQualifiedName() + "'");
 		doStop(aRuntime);
+		LOG.info("Stopping completed '" + getQualifiedName() + "'");
 	}
 
 	protected abstract void doStop(Type aRuntime);
@@ -174,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; 
+	}
 
 }