| /** |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You 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.apache.oodt.cas.workflow.gui.util; |
| |
| //OODT imports |
| import org.apache.oodt.cas.workflow.gui.model.ModelGraph; |
| import org.apache.oodt.cas.workflow.gui.model.ModelNode; |
| import org.apache.oodt.cas.workflow.gui.perspective.view.ViewState; |
| |
| //JDK imports |
| import java.io.File; |
| import java.util.List; |
| import java.util.Set; |
| import java.util.Stack; |
| import java.util.Vector; |
| import java.util.concurrent.atomic.AtomicInteger; |
| |
| /** |
| * |
| * |
| * Generic utility functions helpful for the Workflow Editor GUI. |
| * |
| * @author bfoster |
| * @author mattmann |
| * |
| */ |
| public class GuiUtils { |
| |
| protected static AtomicInteger untitledIter = new AtomicInteger(0); |
| protected static AtomicInteger dummyUntitledIter = new AtomicInteger(0); |
| |
| public static boolean isSubGraph(ModelGraph graph, ModelGraph subGraph) { |
| if (graph.equals(subGraph)) |
| return true; |
| for (ModelGraph child : graph.getChildren()) |
| if (isSubGraph(child, subGraph)) |
| return true; |
| if (graph.getPreConditions() != null) |
| if (isSubGraph(graph.getPreConditions(), subGraph)) |
| return true; |
| if (graph.getPostConditions() != null) |
| if (isSubGraph(graph.getPostConditions(), subGraph)) |
| return true; |
| return false; |
| } |
| |
| public static void updateGraphModelId(ViewState state, String id, |
| String newModelId) { |
| ModelGraph graph = find(state.getGraphs(), id); |
| if (graph.getParent() != null |
| && graph.getParent().getModel().getExcusedSubProcessorIds() |
| .contains(graph.getModel().getModelId())) { |
| graph.getParent().getModel().getExcusedSubProcessorIds() |
| .remove(graph.getModel().getModelId()); |
| graph.getParent().getModel().getExcusedSubProcessorIds().add(newModelId); |
| } |
| graph.getModel().setModelId(newModelId); |
| } |
| |
| public static void addChild(List<ModelGraph> graphs, String parentId, |
| ModelGraph child) { |
| ModelGraph parent = find(graphs, parentId); |
| if (parent != null) |
| parent.addChild(child); |
| } |
| |
| public static List<ModelGraph> findRootGraphs(List<ModelGraph> graphs) { |
| List<ModelGraph> rootGraphs = new Vector<ModelGraph>(); |
| for (ModelGraph graph : graphs) { |
| if (rootGraphs.size() == 0) { |
| rootGraphs.add(graph); |
| } else { |
| if (find(rootGraphs, graph.getModel().getModelId()) == null) { |
| rootGraphs.add(graph); |
| } |
| } |
| } |
| for (int i = 0; i < rootGraphs.size(); i++) { |
| ModelGraph rootGraph = rootGraphs.get(i); |
| for (int j = 0; j < rootGraphs.size(); j++) { |
| if (i != j |
| && rootGraphs.get(j).recursiveFind( |
| rootGraph.getModel().getModelId()) != null) { |
| rootGraphs.remove(i--); |
| break; |
| } |
| } |
| |
| } |
| return rootGraphs; |
| } |
| |
| public static ModelGraph findRoot(List<ModelGraph> rootGraphs, |
| ModelGraph graph) { |
| for (ModelGraph rootGraph : rootGraphs) { |
| if (graph.equals(rootGraph)) { |
| return rootGraph; |
| } else if (graph.getParent() != null) { |
| ModelGraph root = findRoot(rootGraphs, graph.getParent()); |
| if (root != null) |
| return root; |
| } |
| } |
| return null; |
| } |
| |
| public static List<ModelGraph> find(List<ModelGraph> graphs, Set<String> ids) { |
| Vector<ModelGraph> foundGraphs = new Vector<ModelGraph>(); |
| for (String id : ids) { |
| ModelGraph graph = find(graphs, id); |
| if (graph != null) |
| foundGraphs.add(graph); |
| } |
| return foundGraphs; |
| } |
| |
| public static ModelGraph find(List<ModelGraph> graphs, String id) { |
| for (ModelGraph graph : graphs) { |
| ModelGraph found = graph.recursiveFind(id); |
| if (found != null) |
| return found; |
| } |
| return null; |
| } |
| |
| public static ModelGraph removeNode(List<ModelGraph> graphs, ModelNode node) { |
| for (int i = 0; i < graphs.size(); i++) { |
| if (graphs.get(i).getModel().equals(node)) { |
| return graphs.remove(i); |
| } else { |
| ModelGraph graph = removeNode(graphs.get(i), node); |
| if (graph != null) |
| return graph; |
| } |
| } |
| return null; |
| } |
| |
| public static ModelGraph removeNode(ModelGraph graph, ModelNode node) { |
| Stack<ModelGraph> stack = new Stack<ModelGraph>(); |
| stack.add(graph); |
| while (!stack.empty()) { |
| ModelGraph curGraph = stack.pop(); |
| if (curGraph.getModel().equals(node)) { |
| curGraph.setParent(null); |
| return curGraph; |
| } else { |
| stack.addAll(curGraph.getChildren()); |
| if (curGraph.getPreConditions() != null) |
| stack.add(curGraph.getPreConditions()); |
| if (curGraph.getPostConditions() != null) |
| stack.add(curGraph.getPostConditions()); |
| } |
| } |
| return null; |
| } |
| |
| public static List<Line> findSequentialLines(List<ModelGraph> graphs) { |
| Vector<Line> lines = new Vector<Line>(); |
| for (ModelGraph graph : graphs) |
| lines.addAll(findSequentialLines(graph)); |
| return lines; |
| } |
| |
| public static List<Line> findSequentialLines(final ModelGraph graph) { |
| Vector<Line> lines = new Vector<Line>(); |
| if (graph.getChildren().size() > 0) { |
| Stack<ModelGraph> stack = new Stack<ModelGraph>(); |
| stack.add(graph); |
| while (!stack.empty()) { |
| ModelGraph curGraph = stack.pop(); |
| if (curGraph.getModel().getExecutionType().equals("sequential")) { |
| for (int i = 0; i < curGraph.getChildren().size() - 1; i++) |
| lines.add(new Line(curGraph.getChildren().get(i).getModel(), |
| curGraph.getChildren().get(i + 1).getModel())); |
| } |
| stack.addAll(curGraph.getChildren()); |
| } |
| } |
| return lines; |
| } |
| |
| public static List<Line> findLines(final List<ModelGraph> graphs) { |
| Vector<Line> lines = new Vector<Line>(); |
| for (ModelGraph graph : graphs) |
| lines.addAll(findLines(graph)); |
| return lines; |
| } |
| |
| public static List<Line> findLines(final ModelGraph graph) { |
| Vector<Line> lines = new Vector<Line>(); |
| if (graph.getChildren().size() > 0) { |
| Stack<ModelGraph> graphs = new Stack<ModelGraph>(); |
| graphs.add(graph); |
| while (!graphs.empty()) { |
| ModelGraph curGraph = graphs.pop(); |
| if (curGraph.getModel().isParentType()) { |
| |
| if (curGraph.getChildren().size() == 0) |
| curGraph.addChild(new ModelGraph(createDummyNode())); |
| |
| List<Line> relaventLines = getRelaventLines(lines, curGraph |
| .getModel().getId()); |
| for (Line relaventLine : relaventLines) { |
| int index = lines.indexOf(relaventLine); |
| if (curGraph.getModel().getExecutionType().toLowerCase() |
| .equals("sequential")) { |
| lines.remove(index); |
| if (curGraph.getChildren().size() > 0) { |
| if (relaventLine.getFromModel().equals(curGraph.getModel())) |
| lines.add(new Line(curGraph.getChildren() |
| .get(curGraph.getChildren().size() - 1).getModel(), |
| relaventLine.getToModel())); |
| else |
| lines.add(new Line(relaventLine.getFromModel(), curGraph |
| .getChildren().get(0).getModel())); |
| } |
| } else if (curGraph.getModel().getExecutionType().toLowerCase() |
| .equals("parallel")) { |
| lines.remove(index); |
| if (relaventLine.getFromModel().equals(curGraph.getModel())) |
| for (ModelGraph child : curGraph.getChildren()) |
| lines.add(new Line(child.getModel(), relaventLine |
| .getToModel())); |
| else |
| for (ModelGraph child : curGraph.getChildren()) |
| lines.add(new Line(relaventLine.getFromModel(), child |
| .getModel())); |
| } |
| } |
| |
| if (curGraph.getModel().getExecutionType().toLowerCase() |
| .equals("sequential")) { |
| for (int i = 0; i < curGraph.getChildren().size(); i++) { |
| if (i == curGraph.getChildren().size() - 1) |
| lines.add(new Line(curGraph.getChildren().get(i).getModel(), |
| null)); |
| else |
| lines.add(new Line(curGraph.getChildren().get(i).getModel(), |
| curGraph.getChildren().get(i + 1).getModel())); |
| } |
| } else if (curGraph.getModel().getExecutionType().toLowerCase() |
| .equals("parallel")) { |
| for (int i = 0; i < curGraph.getChildren().size(); i++) |
| lines |
| .add(new Line(curGraph.getChildren().get(i).getModel(), null)); |
| } |
| graphs.addAll(curGraph.getChildren()); |
| } |
| } |
| } else { |
| lines.add(new Line(graph.getModel(), null)); |
| } |
| return lines; |
| } |
| |
| public static boolean isDummyNode(ModelNode node) { |
| return node.getModelId().startsWith("DUMMY-"); |
| } |
| |
| public static ModelNode createDummyNode() { |
| ModelNode dummy = new ModelNode(null, "DUMMY-" |
| + dummyUntitledIter.getAndIncrement()); |
| dummy.setTextVisible(false); |
| return dummy; |
| } |
| |
| public static List<ModelGraph> getGraphsInFile(File file, |
| List<ModelGraph> graphs) { |
| List<ModelGraph> graphsInFile = new Vector<ModelGraph>(); |
| for (ModelGraph graph : graphs) { |
| if (graph.getModel().getFile().equals(file)) { |
| graphsInFile.add(graph); |
| } else { |
| graphsInFile.addAll(getGraphsInFile(file, graph.getChildren())); |
| } |
| } |
| return graphsInFile; |
| } |
| |
| public static String createUniqueName() { |
| return "Untitled-" + untitledIter.getAndIncrement(); |
| } |
| |
| public static Line getLine(List<Line> lines, ModelNode fromModel, |
| ModelNode toModel) { |
| for (Line line : lines) |
| if (line.getFromModel().equals(fromModel) |
| && line.getToModel().equals(toModel)) |
| return line; |
| return null; |
| } |
| |
| public static List<Line> getRelaventLines(List<Line> lines, String id) { |
| List<Line> relaventLines = new Vector<Line>(); |
| for (Line line : lines) |
| if ((line.getFromModel() != null && line.getFromModel().getId() |
| .equals(id)) |
| || (line.getToModel() != null && line.getToModel().getId().equals(id))) |
| relaventLines.add(line); |
| return relaventLines; |
| } |
| |
| public static List<Line> getChildrenLines(List<Line> lines, String id) { |
| List<Line> relaventLines = new Vector<Line>(); |
| for (Line line : lines) |
| if (line.getFromModel().getId().equals(id)) |
| relaventLines.add(line); |
| return relaventLines; |
| } |
| |
| public static List<Line> getParentLines(List<Line> lines, String id) { |
| List<Line> relaventLines = new Vector<Line>(); |
| for (Line line : lines) |
| if (line.getToModel().getId().equals(id)) |
| relaventLines.add(line); |
| return relaventLines; |
| } |
| |
| public static List<Line> getStartingLines(List<Line> lines) { |
| Vector<Line> startingLines = new Vector<Line>(); |
| for (Line line : lines) |
| if (getParentLines(lines, line.getFromModel().getId()).size() == 0) |
| startingLines.add(line); |
| return startingLines; |
| } |
| |
| } |
