diff --git a/AlgebraicDataflowArchitectureModel/src/generators/CodeGenerator.java b/AlgebraicDataflowArchitectureModel/src/generators/CodeGenerator.java index 44cf225..40caf08 100644 --- a/AlgebraicDataflowArchitectureModel/src/generators/CodeGenerator.java +++ b/AlgebraicDataflowArchitectureModel/src/generators/CodeGenerator.java @@ -27,6 +27,7 @@ import models.algebra.Term; import models.algebra.Type; import models.algebra.Variable; +import models.controlFlowModel.StatefulObjectNode; import models.dataConstraintModel.Channel; import models.dataConstraintModel.ChannelMember; import models.dataConstraintModel.DataConstraintModel; @@ -144,7 +145,7 @@ ArrayList codes = new ArrayList<>(); Map> dependedRootComponentGraph = null; - Collection components = null; + Collection> components = null; if (platformSpec.isMonolithic()) { // To build monolithic application, the dependency of the components should be resolved in advance. @@ -155,7 +156,7 @@ components = determineComponentOrder(flowGraph, dependedRootComponentGraph); } else { // Get the all components. - components = flowGraph.getResourceNodes(); + components = flowGraph.getAllComponentNodes().values(); } // Generate the other components. @@ -164,25 +165,25 @@ return codes; } - public abstract void generateCodeFromFlowGraph(DataTransferModel model, IFlowGraph flowGraph, Collection components, ArrayList codes, + public abstract void generateCodeFromFlowGraph(DataTransferModel model, IFlowGraph flowGraph, Collection> components, ArrayList codes, Map> dependedRootComponentGraph, IPlatformSpecific platformSpec, ILanguageSpecific langSpec); private static Map> getDependedRootComponentGraph(DataTransferModel model) { Map> dependedComponentGraph = new HashMap<>(); for (Channel ch: model.getChannels()) { - Set inRes = new HashSet<>(); - Set outRes = new HashSet<>(); - getDependedRootComponentGraphSub(ch, inRes, outRes, true); - if (outRes.size() > 0 && inRes.size() > 0) { - for (ResourceHierarchy out: outRes) { - for (ResourceHierarchy in: inRes) { - Set dependings = dependedComponentGraph.get(out.getRoot()); + Set insideRes = new HashSet<>(); + Set outsideRes = new HashSet<>(); + getDependedRootComponentGraphSub(ch, insideRes, outsideRes, true); + if (outsideRes.size() > 0 && insideRes.size() > 0) { + for (ResourceHierarchy outside: outsideRes) { + for (ResourceHierarchy inside: insideRes) { + Set dependings = dependedComponentGraph.get(outside.getRoot()); if (dependings == null) { dependings = new HashSet<>(); - dependedComponentGraph.put(out.getRoot(), dependings); + dependedComponentGraph.put(outside.getRoot(), dependings); } - if (!out.getRoot().equals(in.getRoot())) { - dependings.add(in.getRoot()); + if (!outside.getRoot().equals(inside.getRoot())) { + dependings.add(inside.getRoot()); } } } @@ -191,75 +192,85 @@ return dependedComponentGraph; } - private static void getDependedRootComponentGraphSub(Channel ch, Set inRes, Set outRes, boolean isRoot) { + private static void getDependedRootComponentGraphSub(Channel ch, Set insideRes, Set outsideRes, boolean isRoot) { DataTransferChannel dtCh = (DataTransferChannel) ch; for (ChannelMember cm: dtCh.getChannelMembers()) { if (!isRoot && !cm.isOutside()) { - outRes.add(cm.getResource().getResourceHierarchy()); // dependency to a descendant channel resource. + outsideRes.add(cm.getResource().getResourceHierarchy()); // dependency to a descendant channel resource. } if (cm.isOutside()) { - outRes.add(cm.getResource().getResourceHierarchy()); // dependency to an outside resource. + outsideRes.add(cm.getResource().getResourceHierarchy()); // dependency to an outside resource. } else { - inRes.add(cm.getResource().getResourceHierarchy()); // dependency from an inside resource. + insideRes.add(cm.getResource().getResourceHierarchy()); // dependency from an inside resource. } } for (Channel childCh: ch.getChildren()) { - getDependedRootComponentGraphSub(childCh, inRes, outRes, false); + getDependedRootComponentGraphSub(childCh, insideRes, outsideRes, false); } } - private static ArrayList determineComponentOrder(IFlowGraph graph, Map> dependedRootComponentGraph) { - ArrayList objects = new ArrayList<>(); - Set visited = new HashSet<>(); - Collection allNodes = graph.getResourceNodes(); - for (ResourceNode resNode: allNodes) { - topologicalSort(resNode, allNodes, dependedRootComponentGraph, visited, objects); + private static ArrayList> determineComponentOrder(IFlowGraph graph, Map> dependedRootComponentGraph) { + ArrayList> objectList = new ArrayList<>(); + Set> visited = new HashSet<>(); + Map> allNodes = graph.getAllComponentNodes(); + for (Set nodeSet: allNodes.values()) { + topologicalSort(nodeSet, allNodes, dependedRootComponentGraph, visited, objectList); } - return objects; + return objectList; } - private static void topologicalSort(ResourceNode curResNode, Collection allNodes, Map> dependedRootComponentGraph, Set visited, List orderedList) { - if (visited.contains(curResNode)) return; - visited.add(curResNode); + private static void topologicalSort(Set curNodeSet, Map> allNodeSets, Map> dependedRootComponentGraph, Set> visited, List> orderedList) { + if (visited.contains(curNodeSet)) return; + visited.add(curNodeSet); // A caller is before the callee // For each incoming PUSH transfer. - for (Edge chToRes: curResNode.getInEdges()) { - for (Edge resToCh: chToRes.getSource().getInEdges()) { - if (!(resToCh instanceof DataFlowEdge) || ((PushPullAttribute)((DataFlowEdge) resToCh).getAttribute()).getSelectedOption() == PushPullValue.PUSH) { - topologicalSort((ResourceNode) resToCh.getSource(), allNodes, dependedRootComponentGraph, visited, orderedList); + for (Node curNode: curNodeSet) { + for (Edge chToRes: curNode.getInEdges()) { + for (Edge resToCh: chToRes.getSource().getInEdges()) { + if (!(resToCh instanceof DataFlowEdge) || ((PushPullAttribute)((DataFlowEdge) resToCh).getAttribute()).getSelectedOption() == PushPullValue.PUSH) { + topologicalSort(allNodeSets.get(resToCh.getSource()), allNodeSets, dependedRootComponentGraph, visited, orderedList); + } } } } // For each outgoing PULL transfer. - if (curResNode instanceof ResourceNode) { - for (Edge resToCh: curResNode.getOutEdges()) { - DataFlowEdge de = (DataFlowEdge) resToCh; - if (((PushPullAttribute) de.getAttribute()).getSelectedOption() != PushPullValue.PUSH) { - for (Edge chToRes : resToCh.getDestination().getOutEdges()) { - topologicalSort((ResourceNode) chToRes.getDestination(), allNodes, dependedRootComponentGraph, visited, orderedList); + if (curNodeSet.iterator().next() instanceof ResourceNode) { + for (Node curNode: curNodeSet) { + for (Edge resToCh: curNode.getOutEdges()) { + DataFlowEdge de = (DataFlowEdge) resToCh; + if (((PushPullAttribute) de.getAttribute()).getSelectedOption() != PushPullValue.PUSH) { + for (Edge chToRes : resToCh.getDestination().getOutEdges()) { + topologicalSort(allNodeSets.get(chToRes.getDestination()), allNodeSets, dependedRootComponentGraph, visited, orderedList); + } } } } } // For each depending root node. - if (curResNode instanceof ResourceNode && dependedRootComponentGraph.get(curResNode.getResourceHierarchy()) != null) { - for (ResourceHierarchy dependingRes: dependedRootComponentGraph.get(curResNode.getResourceHierarchy())) { - for (ResourceNode rootNode: allNodes) { - ResourceHierarchy rootRes = rootNode.getResourceHierarchy(); - if (rootRes.getParent() == null && rootRes.equals(dependingRes)) { - topologicalSort(rootNode, allNodes, dependedRootComponentGraph, visited, orderedList); + Node curNode = curNodeSet.iterator().next(); + if (curNode instanceof ResourceNode && dependedRootComponentGraph.get(((ResourceNode) curNode).getResourceHierarchy()) != null) { + for (ResourceHierarchy dependingRes: dependedRootComponentGraph.get(((ResourceNode) curNode).getResourceHierarchy())) { + for (Node node: allNodeSets.keySet()) { + if (node instanceof ResourceNode) { + ResourceNode rootNode = (ResourceNode) node; + ResourceHierarchy rootRes = rootNode.getResourceHierarchy(); + if (rootRes.getParent() == null && rootRes.equals(dependingRes)) { + topologicalSort(allNodeSets.get(rootNode), allNodeSets, dependedRootComponentGraph, visited, orderedList); + } } } } } // For each reference resource. ResourceNode cn = null; - if (curResNode instanceof ResourceNode) { - cn = (ResourceNode) curResNode; + if (curNode instanceof ResourceNode) { + cn = (ResourceNode) curNode; + } else if (curNode instanceof StatefulObjectNode) { + cn = ((StatefulObjectNode) curNode).getResource(); } if (cn != null) { - for (Node n: allNodes) { + for (Node n: allNodeSets.keySet()) { ResourceNode resNode = null; if (n instanceof ResourceNode) { resNode = (ResourceNode) n; @@ -268,15 +279,15 @@ for (Edge resToCh: resNode.getOutEdges()) { ChannelNode chNode = (ChannelNode) resToCh.getDestination(); for (ChannelMember m: chNode.getChannel().getReferenceChannelMembers()) { - if (curResNode.getOutSideResources().contains(m.getResource())) { - topologicalSort(resNode, allNodes, dependedRootComponentGraph, visited, orderedList); + if (cn.getOutSideResources().contains(m.getResource())) { + topologicalSort(allNodeSets.get(resNode), allNodeSets, dependedRootComponentGraph, visited, orderedList); } } } } } } - orderedList.add(0, curResNode); + orderedList.add(0, curNodeSet); } protected void updateMainComponent(TypeDeclaration mainType, MethodDeclaration mainConstructor, Node componentNode, diff --git a/AlgebraicDataflowArchitectureModel/src/generators/CodeGeneratorFromDataFlowGraph.java b/AlgebraicDataflowArchitectureModel/src/generators/CodeGeneratorFromDataFlowGraph.java index 875a141..f6ad47d 100644 --- a/AlgebraicDataflowArchitectureModel/src/generators/CodeGeneratorFromDataFlowGraph.java +++ b/AlgebraicDataflowArchitectureModel/src/generators/CodeGeneratorFromDataFlowGraph.java @@ -61,7 +61,7 @@ public class CodeGeneratorFromDataFlowGraph extends CodeGenerator { - public void generateCodeFromFlowGraph(DataTransferModel model, IFlowGraph flowGraph, Collection components, ArrayList codes, + public void generateCodeFromFlowGraph(DataTransferModel model, IFlowGraph flowGraph, Collection> components, ArrayList codes, Map> dependedRootComponentGraph, IPlatformSpecific platformSpec, ILanguageSpecific langSpec) { Map resourceComponents = new HashMap<>(); Map resourceConstructors = new HashMap<>(); @@ -84,7 +84,8 @@ } // For each components (1st pass). - for (Node componentNode: components) { + for (Set componentNodeSet: components) { + Node componentNode = componentNodeSet.iterator().next(); ResourceNode resourceNode = (ResourceNode) componentNode; TypeDeclaration component = null; if (generatesComponent(resourceNode.getResourceHierarchy())) { @@ -153,7 +154,8 @@ // For each components (2nd pass). Map priorMemberForInputChannel = new HashMap<>(); Set generatedResources = new HashSet<>(); - for (Node componentNode: components) { + for (Set componentNodeSet: components) { + Node componentNode = componentNodeSet.iterator().next(); // Declare this resource. ResourceNode resourceNode = (ResourceNode) componentNode; Type resStateType = getImplStateType(resourceNode.getResourceHierarchy(), langSpec); @@ -218,7 +220,7 @@ } // Add constructor parameters to the ancestor components. - for (ResourceNode root: flowGraph.getRootResourceNodes()) { + for (ResourceNode root: ((DataFlowGraph) flowGraph).getRootResourceNodes()) { addConstructorParameters(root.getResourceHierarchy(), resourceComponents, resourceConstructors, constructorParams, langSpec); } diff --git a/AlgebraicDataflowArchitectureModel/src/models/Node.java b/AlgebraicDataflowArchitectureModel/src/models/Node.java index 3fa1e28..2954012 100644 --- a/AlgebraicDataflowArchitectureModel/src/models/Node.java +++ b/AlgebraicDataflowArchitectureModel/src/models/Node.java @@ -1,11 +1,12 @@ package models; +import java.util.Collection; import java.util.HashSet; import java.util.Set; public class Node implements Cloneable { - private Set inEdges = null; - private Set outEdges = null; + protected Collection inEdges = null; + protected Collection outEdges = null; private NodeAttribute attribute; public Node() { @@ -13,7 +14,7 @@ outEdges = new HashSet<>(); } - public Set getInEdges() { + public Collection getInEdges() { return inEdges; } @@ -21,7 +22,7 @@ this.inEdges = inEdges; } - public Set getOutEdges() { + public Collection getOutEdges() { return outEdges; } diff --git a/AlgebraicDataflowArchitectureModel/src/models/controlFlowModel/CallEdge.java b/AlgebraicDataflowArchitectureModel/src/models/controlFlowModel/CallEdge.java new file mode 100644 index 0000000..e19986e --- /dev/null +++ b/AlgebraicDataflowArchitectureModel/src/models/controlFlowModel/CallEdge.java @@ -0,0 +1,17 @@ +package models.controlFlowModel; + +import models.Edge; +import models.dataFlowModel.PushPullValue; + +public class CallEdge extends Edge { + private PushPullValue selectedOption = PushPullValue.PUSHorPULL; + + public CallEdge(ObjectNode src, ObjectNode dst, PushPullValue selectedOption) { + super(src, dst); + this.selectedOption = selectedOption; + } + + public PushPullValue getSelectedOption() { + return this.selectedOption; + } +} diff --git a/AlgebraicDataflowArchitectureModel/src/models/controlFlowModel/CallGraph.java b/AlgebraicDataflowArchitectureModel/src/models/controlFlowModel/CallGraph.java new file mode 100644 index 0000000..8928877 --- /dev/null +++ b/AlgebraicDataflowArchitectureModel/src/models/controlFlowModel/CallGraph.java @@ -0,0 +1,66 @@ +package models.controlFlowModel; + +import java.util.HashMap; +import java.util.HashSet; +import java.util.Map; +import java.util.Set; + +import models.DirectedGraph; +import models.Node; +import models.dataFlowModel.PushPullValue; +import models.dataFlowModel.ResourceNode; + +public class CallGraph extends DirectedGraph { + protected Map statefulObjMap = null; + + public CallGraph() { + statefulObjMap = new HashMap<>(); + } + + public void addNode(Node node) { + if (node instanceof ResourceNode) { + ResourceNode resNode = (ResourceNode) node; + StatefulObjectNode objNode = statefulObjMap.get(resNode); + if (objNode == null) { + objNode = new StatefulObjectNode(resNode); + statefulObjMap.put(resNode, objNode); + super.addNode(objNode); + } + } else if (node instanceof StatefulObjectNode) { + StatefulObjectNode objNode = (StatefulObjectNode) node; + if (statefulObjMap.get(objNode.getResource()) == null) { + statefulObjMap.put(objNode.getResource(), objNode); + super.addNode(objNode); + } + } else { + super.addNode(node); + } + } + + public void addEdge(ResourceNode srcResNode, ResourceNode dstResNode, PushPullValue selectedOption) { + addNode(srcResNode); + addNode(dstResNode); + addEdge(new CallEdge(getStatefulObjectNode(srcResNode), getStatefulObjectNode(dstResNode), selectedOption)); + } + + public void insertEdge(ObjectNode srcObjNode, ObjectNode dstObjNode, PushPullValue selectedOption, int n) { + CallEdge edge = new CallEdge(srcObjNode, dstObjNode, selectedOption); + simpleAddEdge(edge); + addNode(srcObjNode); + addNode(dstObjNode); + srcObjNode.insertOutEdge(edge, n); + dstObjNode.addInEdge(edge); + } + + public StatefulObjectNode getStatefulObjectNode(ResourceNode resNode) { + return statefulObjMap.get(resNode); + } + + public Set getRootNodes() { + Set roots = new HashSet<>(getNodes()); + for (Node n: getNodes()) { + roots.removeAll(n.getSuccessors()); + } + return roots; + } +} diff --git a/AlgebraicDataflowArchitectureModel/src/models/controlFlowModel/ControlFlowGraph.java b/AlgebraicDataflowArchitectureModel/src/models/controlFlowModel/ControlFlowGraph.java index 2948d89..083d3b0 100644 --- a/AlgebraicDataflowArchitectureModel/src/models/controlFlowModel/ControlFlowGraph.java +++ b/AlgebraicDataflowArchitectureModel/src/models/controlFlowModel/ControlFlowGraph.java @@ -1,16 +1,64 @@ package models.controlFlowModel; import java.util.Collection; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Map; import java.util.Set; +import models.Edge; +import models.Node; +import models.algebra.Expression; +import models.algebra.Term; +import models.algebra.Variable; +import models.dataConstraintModel.Channel; +import models.dataConstraintModel.ChannelMember; import models.DirectedGraph; import models.dataFlowModel.*; public class ControlFlowGraph extends DirectedGraph implements IFlowGraph { private DataFlowGraph dataFlowGraph; + private CallGraph pushCallGraph; + private CallGraph pullCallGraph; public ControlFlowGraph(DataFlowGraph dataFlowGraph, DataTransferModel model) { this.dataFlowGraph = dataFlowGraph; + this.pushCallGraph = new CallGraph(); + this.pullCallGraph = new CallGraph(); + for (Edge e: dataFlowGraph.getEdges()) { + PushPullAttribute pushPull = ((PushPullAttribute) ((DataFlowEdge) e).getAttribute()); + ResourceNode srcNode = (ResourceNode) e.getSource(); + ResourceNode dstNode = (ResourceNode) e.getDestination(); + if (pushPull.getOptions().get(0) == PushPullValue.PUSH) { + // same direction as the data flow + pushCallGraph.addEdge(srcNode, dstNode, PushPullValue.PUSH); + } else { + // reverse direction to the data flow + pullCallGraph.addEdge(dstNode, srcNode, PushPullValue.PULL); + } + } + for (Channel ch: model.getInputChannels()) { + DataTransferChannel cio = (DataTransferChannel) ch; + EventChannelObjectNode srcNode = new EventChannelObjectNode(cio); + for (ChannelMember cm: cio.getChannelMembers()) { + if (srcNode.getName() == null) { + Expression exp = cm.getStateTransition().getMessageExpression(); + if (exp instanceof Term) { + srcNode.setName(((Term) exp).getSymbol().getName()); + } else if (exp instanceof Variable) { + srcNode.setName(((Variable) exp).getName()); + } + } + ResourceNode dstResNode = dataFlowGraph.getResourceNode(cm.getResource()); + StatefulObjectNode dstNode = pushCallGraph.getStatefulObjectNode(dstResNode); + if (dstNode == null) { + pushCallGraph.addNode(dstResNode); + dstNode = pushCallGraph.getStatefulObjectNode(dstResNode); + } + // from an I/O channel to a resource + pushCallGraph.insertEdge(srcNode, dstNode, PushPullValue.PUSH, 0); + } + } } public DataFlowGraph getDataFlowGraph() { @@ -18,12 +66,31 @@ } @Override - public Collection getResourceNodes() { - return dataFlowGraph.getResourceNodes(); - } - - @Override - public Set getRootResourceNodes() { - return dataFlowGraph.getRootResourceNodes(); + public Map> getAllComponentNodes() { + Map> allNodeSets = new HashMap<>(); + for (Node n: pushCallGraph.getNodes()) { + Set nodeSet = new HashSet<>(); + nodeSet.add(n); + allNodeSets.put(n, nodeSet); + } + for (Node n: pullCallGraph.getNodes()) { + if (n instanceof StatefulObjectNode) { + ResourceNode resNode = ((StatefulObjectNode) n).getResource(); + Set nodeSet = null; + if (pushCallGraph.getStatefulObjectNode(resNode) != null) { + // Merge a stateful object node in the push call graph and that in the pull call graph. + nodeSet = allNodeSets.get(pushCallGraph.getStatefulObjectNode(resNode)); + } else { + nodeSet = new HashSet<>(); + } + nodeSet.add(n); + allNodeSets.put(n, nodeSet); + } else { + Set nodeSet = new HashSet<>(); + nodeSet.add(n); + allNodeSets.put(n, nodeSet); + } + } + return allNodeSets; } } diff --git a/AlgebraicDataflowArchitectureModel/src/models/controlFlowModel/EventChannelObjectNode.java b/AlgebraicDataflowArchitectureModel/src/models/controlFlowModel/EventChannelObjectNode.java new file mode 100644 index 0000000..913ead5 --- /dev/null +++ b/AlgebraicDataflowArchitectureModel/src/models/controlFlowModel/EventChannelObjectNode.java @@ -0,0 +1,26 @@ +package models.controlFlowModel; + +import models.dataFlowModel.DataTransferChannel; + +public class EventChannelObjectNode extends ObjectNode { + DataTransferChannel eventChannel = null; + + public EventChannelObjectNode(DataTransferChannel ioChannel) { + super(null); + this.eventChannel = ioChannel; + } + + public EventChannelObjectNode(String name, DataTransferChannel ioChannel) { + super(name); + this.eventChannel = ioChannel; + } + + public DataTransferChannel getIOChannel() { + return eventChannel; + } + + public void setIOChannel(DataTransferChannel ioChannel) { + this.eventChannel = ioChannel; + } + +} diff --git a/AlgebraicDataflowArchitectureModel/src/models/controlFlowModel/ObjectNode.java b/AlgebraicDataflowArchitectureModel/src/models/controlFlowModel/ObjectNode.java new file mode 100644 index 0000000..b754e72 --- /dev/null +++ b/AlgebraicDataflowArchitectureModel/src/models/controlFlowModel/ObjectNode.java @@ -0,0 +1,75 @@ +package models.controlFlowModel; + +import java.util.ArrayList; +import java.util.List; + +import models.Edge; +import models.Node; + +public class ObjectNode extends Node { + protected String name = ""; + + public ObjectNode(String name) { + inEdges = new ArrayList<>(); + outEdges = new ArrayList<>(); + + this.name = name; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public CallEdge getInEdge(int i) { + return (CallEdge) ((List) inEdges).get(i); + } + + public CallEdge getOutEdge(int i) { + return (CallEdge) ((List) outEdges).get(i); + } + + public CallEdge findEdgeInInEdges(final CallEdge edge) { + for (Edge e : inEdges) { + if (e instanceof CallEdge) return (CallEdge)e; + } + return null; + } + + public void insertOutEdge(CallEdge edge, int n) { + ((List) outEdges).add(n, edge); + } + + public int getChildrenNum() { + return outEdges.size(); + } + + public int getOutEdgeCallOrder(final CallEdge callEdge) { + for (int i = 0; i < outEdges.size(); i++) { + if (callEdge.equals(getOutEdge(i))) return i; + } + return -1; + } + + public ObjectNode getChildren(int i) { + return (ObjectNode) ((List) outEdges).get(i).getDestination(); + } + + /************************************************************* + * 指定したエッジ（出力側）の呼び出し順を変更する. + * @param curOrder 現在の呼び出し順 + * @param newCallOrder 新しい呼び出し順 + */ + public void sortOutEdgesByCallOrder(final int curOrder, final int newCallOrder) { + ArrayList edges = ((ArrayList)outEdges); + Edge selectedEdge = ((List)outEdges).get(curOrder); + + Edge tempEdge = ((List)outEdges).get(newCallOrder - 1); + + edges.set(newCallOrder - 1, selectedEdge); + edges.set(curOrder, tempEdge); + } +} diff --git a/AlgebraicDataflowArchitectureModel/src/models/controlFlowModel/StatefulObjectNode.java b/AlgebraicDataflowArchitectureModel/src/models/controlFlowModel/StatefulObjectNode.java new file mode 100644 index 0000000..a1e50cd --- /dev/null +++ b/AlgebraicDataflowArchitectureModel/src/models/controlFlowModel/StatefulObjectNode.java @@ -0,0 +1,17 @@ +package models.controlFlowModel; + +import models.dataFlowModel.ResourceNode; + +public class StatefulObjectNode extends ObjectNode { + private ResourceNode resource; + + public StatefulObjectNode(ResourceNode resource) { + super(resource.getResourceName()); + this.resource = resource; + } + + public ResourceNode getResource() { + return resource; + } + +} diff --git a/AlgebraicDataflowArchitectureModel/src/models/dataFlowModel/DataFlowGraph.java b/AlgebraicDataflowArchitectureModel/src/models/dataFlowModel/DataFlowGraph.java index 3edaace..1722d40 100644 --- a/AlgebraicDataflowArchitectureModel/src/models/dataFlowModel/DataFlowGraph.java +++ b/AlgebraicDataflowArchitectureModel/src/models/dataFlowModel/DataFlowGraph.java @@ -8,6 +8,7 @@ import java.util.Set; import models.DirectedGraph; +import models.Node; import models.dataConstraintModel.ResourceHierarchy; import models.dataConstraintModel.ResourcePath; @@ -130,6 +131,17 @@ public ChannelNode getChannelNode(DataTransferChannel channel) { return channelNodeMap.get(channel); } + + @Override + public Map> getAllComponentNodes() { + Map> allNodeSets = new HashMap<>(); + for (Node n: getResourceNodes()) { + Set nodeSet = new HashSet<>(); + nodeSet.add(n); + allNodeSets.put(n, nodeSet); + } + return allNodeSets; + } public Collection getResourceNodes() { HashSet result = new HashSet<>(resourceNodeMap.values()); diff --git a/AlgebraicDataflowArchitectureModel/src/models/dataFlowModel/IFlowGraph.java b/AlgebraicDataflowArchitectureModel/src/models/dataFlowModel/IFlowGraph.java index 40b107f..06a950b 100644 --- a/AlgebraicDataflowArchitectureModel/src/models/dataFlowModel/IFlowGraph.java +++ b/AlgebraicDataflowArchitectureModel/src/models/dataFlowModel/IFlowGraph.java @@ -1,9 +1,11 @@ package models.dataFlowModel; import java.util.Collection; +import java.util.Map; import java.util.Set; +import models.Node; + public interface IFlowGraph { - public Collection getResourceNodes(); - public Set getRootResourceNodes(); + public Map> getAllComponentNodes(); }