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;
* @param aRequired
* Required services.
*/
- protected AbstractComponent(String aName, ProvidedInterface[] aProvided,
- RequiredInterface[] aRequired) {
+ protected AbstractComponent(String aName, List<ProvidedInterface> aProvided,
+ List<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));
+ _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]);
}
- protected AbstractComponent addProvidedInterface(ProvidedInterface aProvided) {
+ public AbstractComponent<Type> addProvidedInterface(ProvidedInterface aProvided) {
_provided.add(aProvided);
return this;
}
- protected AbstractComponent addRequiredInterface(RequiredInterface aRequired) {
+ public AbstractComponent<Type> addRequiredInterface(RequiredInterface aRequired) {
_required.add(aRequired);
return this;
}
}
}
+ @Override
public String getContext() {
return _context;
}
}
@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() + "'");
+ LOG.info("Initialization starting '" + getQualifiedName() + "'");
List<ProvidedInterface> oldRemaining = _remaining.get();
- _remaining.set(new ArrayList<ProvidedInterface>(Arrays.asList(getProvidedInterfaces())));
+ _remaining.set(new ArrayList<ProvidedInterface>(getProvidedInterfaces()));
try {
Type runtime = doStart(aScope);
checkNotStartedInterfaces();
+ LOG.info("Initialization finished '" + getQualifiedName() + "'");
return runtime;
} finally {
_remaining.set(oldRemaining);
/**
* 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.
*/
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);
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;
+ }
}