import java.util.List;
import org.wamblee.general.Pair;
-import org.wamblee.system.container.CompositeInterfaceRestriction;
-import org.wamblee.system.container.InterfaceRestriction;
import org.wamblee.system.core.Component;
import org.wamblee.system.core.ProvidedInterface;
import org.wamblee.system.core.RequiredInterface;
+import org.wamblee.system.graph.CompositeEdgeFilter;
import org.wamblee.system.graph.DefaultEdge;
import org.wamblee.system.graph.Edge;
import org.wamblee.system.graph.Graph;
import org.wamblee.system.graph.Node;
-
-// TODO info superfluous required interfaces
-// TODO check optional external required but mandatory internal.
-
+/**
+ * Represents a component graph and provides the bridge from the
+ * component model to a graph model. The graph model is easier
+ * to work with to implement specific actions and validations than
+ * the component model.
+ */
public class ComponentGraph extends Graph {
- private CompositeInterfaceRestriction _restriction;
+ private boolean isLinked;
+ private CompositeEdgeFilter edgeFilter;
- public ComponentGraph() {
- _restriction = new CompositeInterfaceRestriction();
- }
-
- public void addRestriction(InterfaceRestriction aRestriction) {
- _restriction.add(aRestriction);
+ /**
+ * Constructs an empty component graph.
+ */
+ public ComponentGraph() {
+ isLinked = false;
+ edgeFilter = new CompositeEdgeFilter();
}
- public void addRequiredInterface(RequiredInterface aInterface) {
- addNode(new ExternalRequiredInterfaceNode(aInterface));
+ /**
+ * Adds an externally required interface of a container.
+ * This should be called before any components of the container are
+ * added.
+ * @param aComponent Component requiring the interface.
+ * @param aInterface Required interface.
+ */
+ public void addRequiredInterface(Component aComponent, RequiredInterface aInterface) {
+ addNode(new ExternalRequiredInterfaceNode(aComponent, aInterface));
}
- public void addProvidedInterface(ProvidedInterface aInterface) {
- addNode(new ExternalProvidedInterfaceNode(aInterface));
+ /**
+ * Adds an externally provided interface of a container.
+ * This should be called after all components of the container have been added.
+ * @param aComponent Component providing the interface.
+ * @param aInterface Provided interface.
+ */
+ public void addProvidedInterface(Component aComponent, ProvidedInterface aInterface) {
+ addNode(new ExternalProvidedInterfaceNode(aComponent, aInterface));
}
+ /**
+ * Validates the component graph.
+ */
public void validate() {
extend(new RequiredProvidedEdgeFactory());
- accept(new ApplyRestrictionsVisitor(this, _restriction));
+ applyFilter(edgeFilter);
accept(new CheckRequiredProvidedMultiplicityVisitor(this));
- accept(new CheckExternallyRequiredVisitor());
+ accept(new CheckExternallyRequiredVisitor(this));
accept(new CheckExternallyProvidedVisitor(this));
accept(new CheckStartupDependenciesVisitor(this));
}
- public void link() {
+ /**
+ * Links provided and required interfaces together in the component
+ * model based on the graph model.
+ */
+ public void link() {
+ if ( isLinked ) {
+ return;
+ }
accept(new LinkVisitor());
+ isLinked = true;
}
/**
return result;
}
- public void addComponent(Component aComponent) {
+ /**
+ * Adds a component by adding required interfaces, components, and
+ * provided interfaces.
+ * @param aComponent Component to add.
+ */
+ public void addComponent(Component<?> aComponent) {
// Add required interfaces.
Node compNode = new ComponentNode(aComponent);
List<Node> requiredNodes = new ArrayList<Node>();
addEdge(new DefaultEdge(provNode, compNode));
}
}
+
+ public void addEdgeFilter(CompositeEdgeFilter aEdgeFilter) {
+ edgeFilter.add(aEdgeFilter);
+ }
}