X-Git-Url: http://wamblee.org/gitweb/?a=blobdiff_plain;f=system%2Fgeneral%2Fsrc%2Fmain%2Fjava%2Forg%2Fwamblee%2Fsystem%2Fcore%2FAbstractComponent.java;h=1ac464d0ce1033d9552cd8acca72c74453680921;hb=ddd261f331280640c5b53c7128230b629ebcd268;hp=01eff741ac362aa13e6b0d3280c9ae9975b001d6;hpb=e73828b054b0734ddce0ff9194fca75ed3c98b7a;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 01eff741..1ac464d0 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
@@ -1,161 +1,341 @@
 /*
  * 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.core;
 
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
 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;
 
 /**
  * Abstract subsystem class making it easy to implement new subsystems.
+ *
+ * @param <Type> DOCUMENT ME!
  */
-public abstract class AbstractComponent implements Component {
-
-	private static final Log LOG = LogFactory.getLog(AbstractComponent.class);
-
-	private String _context; 
-	private String _name; 
-	private List<ProvidedInterface> _provided;
-	private List<RequiredInterface> _required;
-	private Set<ProvidedInterface> _running;
-	
-	/**
-	 * 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) {
-		_context = null; 
-		_name = aName;
-		_provided = new ArrayList<ProvidedInterface>();
-		_provided.addAll(Arrays.asList(aProvided));
-		_required = new ArrayList<RequiredInterface>();
-		_required.addAll(Arrays.asList(aRequired));
-		_running = new HashSet<ProvidedInterface>();
-	}
-
-	@Override
-	public final String getName() {
-		return _name;
-	}
-	
-	@Override
-	public void addContext(String aContext) {
-		if (_context == null ) { 
-			_context = aContext; 
-		}
-		else { 
-			_context = aContext + "." + _context;
-		}
-	}
-	
-	@Override
-	public String getQualifiedName() {
-		if ( _context == null ) { 
-			return getName(); 
-		}
-		return _context + "." + getName(); 
-	}
-
-	@Override
-	public final ProvidedInterface[] getProvidedInterfaces() {
-		return _provided.toArray(new ProvidedInterface[0]);
-	}
-
-	@Override
-	public final RequiredInterface[] getRequiredInterfaces() {
-		return _required.toArray(new RequiredInterface[0]);
-	}
-
-	@Override
-	public final void start() {
-		LOG.info("Initializing '" + getQualifiedName() + "'");
-		doStart();
-		if ( _running.size() != _provided.size()) { 
-			List<ProvidedInterface> remaining = 
-				new ArrayList<ProvidedInterface>(_provided);
-			remaining.removeAll(_running);
-			throw new SystemAssemblyException(getQualifiedName() + ": not all services were started, missing " + remaining);
-		}
-	}
-
-	/**
-	 * Must be implemented for initializing the subsystem. The implementation
-	 * must call {@link #addService(Service)} for each service that is started.
-	 */
-	protected abstract void doStart();
-
-	/**
-	 * Implementations must call this method to indicate that a new service has
-	 * been started.
-	 * 
-	 * @param aService
-	 *            Service.
-	 */
-	protected final void addInterface(
-			ProvidedInterface aDescriptor, Object aService) {
-		LOG.info("Interface '" + getQualifiedName() + "." + aDescriptor.getName() + "' started.");
-		_running.add(aDescriptor);
-		aDescriptor.publish(aService);
-	}
-
-	@Override
-	public ProvidedInterface[] getRunningInterfaces() {
-		return _running.toArray(new ProvidedInterface[0]);
-	}
-	
-	@Override
-	public void stop() {
-		doStop();
-		if ( _running.size() > 0 ) { 
-			// programming error.
-			throw new RuntimeException(getQualifiedName() + ": still services running after the stop call.");
-		}
-	}
-	
-	protected abstract void doStop();
-	
-	/**
-	 * Implementations must call this method to indicate that a running service has
-	 * been stopped.
-	 * 
-	 * @param aService
-	 *            Service.
-	 */
-	protected final void removeInterface(
-			ProvidedInterface aDescriptor) {
-		LOG.info("Interface '" + getQualifiedName() + "." + aDescriptor.getName() + "' stopped.");
-		_running.remove(aDescriptor);
-		aDescriptor.publish(null);
-	}
-
-	@Override
-	public String toString() {
-		return getQualifiedName();
-	}
+public abstract class AbstractComponent<Type> implements Component<Type> {
+    /**
+     * DOCUMENT ME!
+     */
+    private static final Log LOG = LogFactory.getLog(AbstractComponent.class);
+
+    /**
+     * DOCUMENT ME!
+     */
+    private ThreadLocal<List<ProvidedInterface>> remaining;
+
+    /**
+     * DOCUMENT ME!
+     */
+    private String context;
+
+    /**
+     * DOCUMENT ME!
+     */
+    private String name;
+
+    /**
+     * DOCUMENT ME!
+     */
+    private List<ProvidedInterface> provided;
+
+    /**
+     * DOCUMENT ME!
+     */
+    private List<RequiredInterface> required;
+
+/**
+         * Constructs the subsystem.
+         * 
+         * @param aName
+         *            Name of the system.
+         * @param aProvided
+         *            Provided services.
+         * @param aRequired
+         *            Required services.
+         */
+    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));
+    }
+
+    /**
+     * Creates a new AbstractComponent object.
+     *
+     * @param aName DOCUMENT ME!
+     */
+    protected AbstractComponent(String aName) {
+        this(aName, new ProvidedInterface[0], new RequiredInterface[0]);
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param aProvided DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public AbstractComponent<Type> addProvidedInterface(
+        ProvidedInterface aProvided) {
+        provided.add(aProvided);
+
+        return this;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param aRequired DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public AbstractComponent<Type> addRequiredInterface(
+        RequiredInterface aRequired) {
+        required.add(aRequired);
+
+        return this;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    @Override
+    public final String getName() {
+        return name;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param aContext DOCUMENT ME!
+     */
+    @Override
+    public void addContext(String aContext) {
+        if (context == null) {
+            context = aContext;
+        } else {
+            context = aContext + "." + context;
+        }
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    @Override
+    public String getContext() {
+        return context;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    @Override
+    public String getQualifiedName() {
+        if (context == null) {
+            return getName();
+        }
+
+        return context + "." + getName();
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    @Override
+    public final List<ProvidedInterface> getProvidedInterfaces() {
+        return Collections.unmodifiableList(provided);
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    @Override
+    public final List<RequiredInterface> getRequiredInterfaces() {
+        return Collections.unmodifiableList(required);
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param aScope DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    @Override
+    public final Type start(Scope aScope) {
+        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);
+        }
+    }
+
+    /**
+     * DOCUMENT ME!
+     */
+    private void checkNotStartedInterfaces() {
+        if (remaining.get().size() > 0) {
+            String notProvided = "";
+
+            for (ProvidedInterface provided : remaining.get()) {
+                notProvided += ("\nComponent " + getQualifiedName()
+                + " did not start interface " + provided);
+            }
+
+            throw new SystemAssemblyException(notProvided);
+        }
+    }
+
+    /**
+     * Must be implemented for initializing the subsystem. The
+     * implementation must call {@link #addInterface(ProvidedInterface,
+     * Object, Scope)} for each service that is started.
+     *
+     * @param aScope DOCUMENT ME!
+     *
+     * @return Returns the runtime of the component.
+     */
+    protected abstract Type doStart(Scope aScope);
+
+    /**
+     * Implementations must call this method to indicate that a new
+     * service has been started.
+     *
+     * @param aDescriptor Provided interface.
+     * @param aService Implementation of the interface.
+     * @param aScope scope in which to publish the implementation.
+     *
+     * @throws SystemAssemblyException DOCUMENT ME!
+     */
+    protected final void addInterface(ProvidedInterface aDescriptor,
+        Object aService, Scope aScope) {
+        LOG.info("Interface '" + getQualifiedName() + "."
+            + aDescriptor.getName() + "' started.");
+
+        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);
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param aRuntime DOCUMENT ME!
+     */
+    @Override
+    public void stop(Type aRuntime) {
+        LOG.info("Stopping initiated '" + getQualifiedName() + "'");
+        doStop(aRuntime);
+        LOG.info("Stopping completed '" + getQualifiedName() + "'");
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param aRuntime DOCUMENT ME!
+     */
+    protected abstract void doStop(Type aRuntime);
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    @Override
+    public String toString() {
+        return getQualifiedName();
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param aName DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public ProvidedInterface findProvidedInterface(String aName) {
+        for (ProvidedInterface provided : getProvidedInterfaces()) {
+            if (provided.getName().equals(aName)) {
+                return provided;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * DOCUMENT ME!
+     *
+     * @param aName DOCUMENT ME!
+     *
+     * @return DOCUMENT ME!
+     */
+    public RequiredInterface findRequiredInterface(String aName) {
+        for (RequiredInterface required : getRequiredInterfaces()) {
+            if (required.getName().equals(aName)) {
+                return required;
+            }
+        }
 
+        return null;
+    }
 }