import java.util.ArrayList;
import java.util.Arrays;
+import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
-import java.util.TreeMap;
-import java.util.UUID;
public class DefaultScope implements Scope {
- private List<Scope> _parents;
- private Map<String, Object> _properties;
- private Map<String, Object> _runtimes;
- private Map<String, ProvidedInterfaceImplementation> _provided;
- private ProvidedInterface[] _externallyProvided;
+ private List<Scope> parents;
+ private Map<String, Object> properties;
+ private Map<String, Object> runtimes;
+ private Map<ProvidedInterface, ProvidedInterfaceImplementation> provided;
+ private List<ProvidedInterface> externallyProvided;
+
+ public DefaultScope(List<ProvidedInterface>aExternallyProvided) {
+ this(aExternallyProvided.toArray(new ProvidedInterface[0]));
+ }
public DefaultScope(ProvidedInterface[] aExternallyProvided) {
this(aExternallyProvided, new ArrayList<Scope>());
public DefaultScope(ProvidedInterface[] aExternallyProvided,
List<Scope> aParent) {
- _parents = new ArrayList<Scope>(aParent);
- _properties = new HashMap<String, Object>();
- _runtimes = new HashMap<String, Object>();
- _provided = new HashMap<String, ProvidedInterfaceImplementation>();
- _externallyProvided = aExternallyProvided;
+ parents = new ArrayList<Scope>(aParent);
+ properties = new HashMap<String, Object>();
+ runtimes = new HashMap<String, Object>();
+ provided = new HashMap<ProvidedInterface, ProvidedInterfaceImplementation>();
+ externallyProvided = new ArrayList<ProvidedInterface>();
+ externallyProvided.addAll(Arrays.asList(aExternallyProvided));
}
@Override
- public ProvidedInterface[] getProvidedInterfaces() {
- return _externallyProvided;
+ public List<ProvidedInterface> getProvidedInterfaces() {
+ return Collections.unmodifiableList(externallyProvided);
}
@Override
public Object get(String aKey) {
- return _properties.get(aKey);
+ return properties.get(aKey);
}
@Override
public void put(String aKey, Object aValue) {
- _properties.put(aKey, aValue);
+ properties.put(aKey, aValue);
}
@Override
public void addRuntime(Component aComponent, Object aRuntime) {
- _runtimes.put(aComponent.getName(), aRuntime);
+ runtimes.put(aComponent.getName(), aRuntime);
}
@Override
public Object getRuntime(Component aComponent) {
- return _runtimes.get(aComponent.getName());
+ return runtimes.get(aComponent.getName());
}
@Override
public Object getRuntime(String aName) {
- return _runtimes.get(aName);
+ return runtimes.get(aName);
}
@Override
synchronized public void publishInterface(ProvidedInterface aInterface,
Object aImplementation) {
- _provided.put(aInterface.getUniqueId(), new ProvidedInterfaceImplementation(aInterface,
+ provided.put(aInterface, new ProvidedInterfaceImplementation(aInterface,
aImplementation));
}
Class<T> aType) {
if ( aInterface == null ) {
return null;
- }
- String id = aInterface.getUniqueId();
- if ( id == null ) {
- // optional interface that was not published.
- return null;
- }
- ProvidedInterfaceImplementation provided = _provided.get(id);
- if (provided == null) {
- for (Scope parent : _parents) {
+ }
+ ProvidedInterfaceImplementation providedIntf = provided.get(aInterface);
+ if (providedIntf == null) {
+ for (Scope parent : parents) {
T impl = parent.getInterfaceImplementation(aInterface, aType);
if ( impl != null ) {
return impl;
}
return null;
} else {
- return provided.getImplementation(aType);
+ return providedIntf.getImplementation(aType);
}
}
}