src/utils/IdealGraphVisualizer/Data/src/com/sun/hotspot/igv/data/InputGraph.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  *
  */
 package com.sun.hotspot.igv.data;

 import java.util.*;

 /**
  *
  * @author Thomas Wuerthinger
  */
 public class InputGraph extends Properties.Entity implements FolderElement {

     private Map<Integer, InputNode> nodes;
     private List<InputEdge> edges;
     private Folder parent;
     private Group parentGroup;
     private Map<String, InputBlock> blocks;
     private List<InputBlockEdge> blockEdges;
     private Map<Integer, InputBlock> nodeToBlock;

     public InputGraph(String name) {
         setName(name);
         nodes = new LinkedHashMap<>();
         edges = new ArrayList<>();
         blocks = new LinkedHashMap<>();
         blockEdges = new ArrayList<>();
         nodeToBlock = new LinkedHashMap<>();
     }

     @Override
     public void setParent(Folder parent) {
         this.parent = parent;
         if (parent instanceof Group) {
             assert this.parentGroup == null;
             this.parentGroup = (Group) parent;
         }
     }

     public InputBlockEdge addBlockEdge(InputBlock left, InputBlock right) {
         InputBlockEdge edge = new InputBlockEdge(left, right);
         blockEdges.add(edge);
         left.addSuccessor(right);
         return edge;
     }

     public List<InputNode> findRootNodes() {
         List<InputNode> result = new ArrayList<>();
         Set<Integer> nonRoot = new HashSet<>();
         for(InputEdge curEdges : getEdges()) {
             nonRoot.add(curEdges.getTo());
         }

         for(InputNode node : getNodes()) {
             if(!nonRoot.contains(node.getId())) {
                 result.add(node);
             }
         }

         return result;
     }

     public Map<InputNode, List<InputEdge>> findAllOutgoingEdges() {
         Map<InputNode, List<InputEdge>> result = new HashMap<>(getNodes().size());
         for(InputNode n : this.getNodes()) {
             result.put(n, new ArrayList<InputEdge>());
         }

         for(InputEdge e : this.edges) {
             int from = e.getFrom();
             InputNode fromNode = this.getNode(from);
             List<InputEdge> fromList = result.get(fromNode);
             assert fromList != null;
             fromList.add(e);
         }

         for(InputNode n : this.getNodes()) {
             List<InputEdge> list = result.get(n);
             Collections.sort(list, InputEdge.OUTGOING_COMPARATOR);
         }

         return result;
     }

     public Map<InputNode, List<InputEdge>> findAllIngoingEdges() {
         Map<InputNode, List<InputEdge>> result = new HashMap<>(getNodes().size());
         for(InputNode n : this.getNodes()) {
             result.put(n, new ArrayList<InputEdge>());
         }

         for(InputEdge e : this.edges) {
             int to = e.getTo();
             InputNode toNode = this.getNode(to);
             List<InputEdge> toList = result.get(toNode);
             assert toList != null;
             toList.add(e);
         }

         for(InputNode n : this.getNodes()) {
             List<InputEdge> list = result.get(n);
             Collections.sort(list, InputEdge.INGOING_COMPARATOR);
         }

         return result;
     }

     public List<InputEdge> findOutgoingEdges(InputNode n) {
         List<InputEdge> result = new ArrayList<>();

         for(InputEdge e : this.edges) {
             if(e.getFrom() == n.getId()) {
                 result.add(e);
             }
         }

         Collections.sort(result, InputEdge.OUTGOING_COMPARATOR);

         return result;
     }

     public void clearBlocks() {
         blocks.clear();
         nodeToBlock.clear();
     }

     public void setEdge(int fromIndex, int toIndex, int from, int to) {
         assert fromIndex == ((char)fromIndex) : "Downcast must be safe";
         assert toIndex == ((char)toIndex) : "Downcast must be safe";

         InputEdge edge = new InputEdge((char)fromIndex, (char)toIndex, from, to);
         if(!this.getEdges().contains(edge)) {
             this.addEdge(edge);
         }
     }

     public void ensureNodesInBlocks() {
         InputBlock noBlock = null;
         Set<InputNode> scheduledNodes = new HashSet<>();

         for (InputBlock b : getBlocks()) {
             for (InputNode n : b.getNodes()) {
                 assert !scheduledNodes.contains(n);
                 scheduledNodes.add(n);
             }
         }

         for (InputNode n : this.getNodes()) {
             assert nodes.get(n.getId()) == n;
             if (!scheduledNodes.contains(n)) {
                 if (noBlock == null) {
                     noBlock = this.addBlock("(no block)");
                 }
                 noBlock.addNode(n.getId());
             }
             assert this.getBlock(n) != null;
         }
     }

     public void setBlock(InputNode node, InputBlock block) {
         nodeToBlock.put(node.getId(), block);
     }

     public InputBlock getBlock(int nodeId) {
         return nodeToBlock.get(nodeId);
     }

     public InputBlock getBlock(InputNode node) {
         assert nodes.containsKey(node.getId());
         assert nodes.get(node.getId()).equals(node);
         return getBlock(node.getId());
     }

     public InputGraph getNext() {
         return parentGroup.getNext(this);
     }

     public InputGraph getPrev() {
         return parentGroup.getPrev(this);
     }

     private void setName(String name) {
         this.getProperties().setProperty("name", name);
     }

     @Override
     public String getName() {
         return getProperties().get("name");
     }

     public Collection<InputNode> getNodes() {
         return Collections.unmodifiableCollection(nodes.values());
     }

     public Set<Integer> getNodesAsSet() {
         return Collections.unmodifiableSet(nodes.keySet());
     }

     public Collection<InputBlock> getBlocks() {
         return Collections.unmodifiableCollection(blocks.values());
     }

     public void addNode(InputNode node) {
         nodes.put(node.getId(), node);
     }

     public InputNode getNode(int id) {
         return nodes.get(id);
     }

     public InputNode removeNode(int index) {
         return nodes.remove(index);
     }

     public Collection<InputEdge> getEdges() {
         return Collections.unmodifiableList(edges);
     }

     public void removeEdge(InputEdge c) {
         boolean removed = edges.remove(c);
         assert removed;
     }

     public void addEdge(InputEdge c) {
         edges.add(c);
     }

     public Group getGroup() {
         return parentGroup;
     }

     @Override
     public String toString() {
         StringBuilder sb = new StringBuilder();
         sb.append("Graph ").append(getName()).append(" ").append(getProperties().toString()).append("\n");
         for (InputNode n : nodes.values()) {
             sb.append(n.toString());
             sb.append("\n");
         }

         for (InputEdge c : edges) {
             sb.append(c.toString());
             sb.append("\n");
         }

         for (InputBlock b : getBlocks()) {
             sb.append(b.toString());
             sb.append("\n");
         }

         return sb.toString();
     }

     public InputBlock addBlock(String name) {
         final InputBlock b = new InputBlock(this, name);
         blocks.put(b.getName(), b);
         return b;
     }

     public InputBlock getBlock(String s) {
         return blocks.get(s);
     }

     public Collection<InputBlockEdge> getBlockEdges() {
         return Collections.unmodifiableList(blockEdges);
     }

     @Override
     public Folder getParent() {
         return parent;
     }
 }
	/*
	* Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*
	*/
	package com.sun.hotspot.igv.data;

	import java.util.*;

	/**
	*
	* @author Thomas Wuerthinger
	*/
	public class InputGraph extends Properties.Entity implements FolderElement {

	private Map<Integer, InputNode> nodes;
	private List<InputEdge> edges;
	private Folder parent;
	private Group parentGroup;
	private Map<String, InputBlock> blocks;
	private List<InputBlockEdge> blockEdges;
	private Map<Integer, InputBlock> nodeToBlock;

	public InputGraph(String name) {
	setName(name);
	nodes = new LinkedHashMap<>();
	edges = new ArrayList<>();
	blocks = new LinkedHashMap<>();
	blockEdges = new ArrayList<>();
	nodeToBlock = new LinkedHashMap<>();
	}

	@Override
	public void setParent(Folder parent) {
	this.parent = parent;
	if (parent instanceof Group) {
	assert this.parentGroup == null;
	this.parentGroup = (Group) parent;
	}
	}

	public InputBlockEdge addBlockEdge(InputBlock left, InputBlock right) {
	InputBlockEdge edge = new InputBlockEdge(left, right);
	blockEdges.add(edge);
	left.addSuccessor(right);
	return edge;
	}

	public List<InputNode> findRootNodes() {
	List<InputNode> result = new ArrayList<>();
	Set<Integer> nonRoot = new HashSet<>();
	for(InputEdge curEdges : getEdges()) {
	nonRoot.add(curEdges.getTo());
	}

	for(InputNode node : getNodes()) {
	if(!nonRoot.contains(node.getId())) {
	result.add(node);
	}
	}

	return result;
	}

	public Map<InputNode, List<InputEdge>> findAllOutgoingEdges() {
	Map<InputNode, List<InputEdge>> result = new HashMap<>(getNodes().size());
	for(InputNode n : this.getNodes()) {
	result.put(n, new ArrayList<InputEdge>());
	}

	for(InputEdge e : this.edges) {
	int from = e.getFrom();
	InputNode fromNode = this.getNode(from);
	List<InputEdge> fromList = result.get(fromNode);
	assert fromList != null;
	fromList.add(e);
	}

	for(InputNode n : this.getNodes()) {
	List<InputEdge> list = result.get(n);
	Collections.sort(list, InputEdge.OUTGOING_COMPARATOR);
	}

	return result;
	}

	public Map<InputNode, List<InputEdge>> findAllIngoingEdges() {
	Map<InputNode, List<InputEdge>> result = new HashMap<>(getNodes().size());
	for(InputNode n : this.getNodes()) {
	result.put(n, new ArrayList<InputEdge>());
	}

	for(InputEdge e : this.edges) {
	int to = e.getTo();
	InputNode toNode = this.getNode(to);
	List<InputEdge> toList = result.get(toNode);
	assert toList != null;
	toList.add(e);
	}

	for(InputNode n : this.getNodes()) {
	List<InputEdge> list = result.get(n);
	Collections.sort(list, InputEdge.INGOING_COMPARATOR);
	}

	return result;
	}

	public List<InputEdge> findOutgoingEdges(InputNode n) {
	List<InputEdge> result = new ArrayList<>();

	for(InputEdge e : this.edges) {
	if(e.getFrom() == n.getId()) {
	result.add(e);
	}
	}

	Collections.sort(result, InputEdge.OUTGOING_COMPARATOR);

	return result;
	}

	public void clearBlocks() {
	blocks.clear();
	nodeToBlock.clear();
	}

	public void setEdge(int fromIndex, int toIndex, int from, int to) {
	assert fromIndex == ((char)fromIndex) : "Downcast must be safe";
	assert toIndex == ((char)toIndex) : "Downcast must be safe";

	InputEdge edge = new InputEdge((char)fromIndex, (char)toIndex, from, to);
	if(!this.getEdges().contains(edge)) {
	this.addEdge(edge);
	}
	}

	public void ensureNodesInBlocks() {
	InputBlock noBlock = null;
	Set<InputNode> scheduledNodes = new HashSet<>();

	for (InputBlock b : getBlocks()) {
	for (InputNode n : b.getNodes()) {
	assert !scheduledNodes.contains(n);
	scheduledNodes.add(n);
	}
	}

	for (InputNode n : this.getNodes()) {
	assert nodes.get(n.getId()) == n;
	if (!scheduledNodes.contains(n)) {
	if (noBlock == null) {
	noBlock = this.addBlock("(no block)");
	}
	noBlock.addNode(n.getId());
	}
	assert this.getBlock(n) != null;
	}
	}

	public void setBlock(InputNode node, InputBlock block) {
	nodeToBlock.put(node.getId(), block);
	}

	public InputBlock getBlock(int nodeId) {
	return nodeToBlock.get(nodeId);
	}

	public InputBlock getBlock(InputNode node) {
	assert nodes.containsKey(node.getId());
	assert nodes.get(node.getId()).equals(node);
	return getBlock(node.getId());
	}

	public InputGraph getNext() {
	return parentGroup.getNext(this);
	}

	public InputGraph getPrev() {
	return parentGroup.getPrev(this);
	}

	private void setName(String name) {
	this.getProperties().setProperty("name", name);
	}

	@Override
	public String getName() {
	return getProperties().get("name");
	}

	public Collection<InputNode> getNodes() {
	return Collections.unmodifiableCollection(nodes.values());
	}

	public Set<Integer> getNodesAsSet() {
	return Collections.unmodifiableSet(nodes.keySet());
	}

	public Collection<InputBlock> getBlocks() {
	return Collections.unmodifiableCollection(blocks.values());
	}

	public void addNode(InputNode node) {
	nodes.put(node.getId(), node);
	}

	public InputNode getNode(int id) {
	return nodes.get(id);
	}

	public InputNode removeNode(int index) {
	return nodes.remove(index);
	}

	public Collection<InputEdge> getEdges() {
	return Collections.unmodifiableList(edges);
	}

	public void removeEdge(InputEdge c) {
	boolean removed = edges.remove(c);
	assert removed;
	}

	public void addEdge(InputEdge c) {
	edges.add(c);
	}

	public Group getGroup() {
	return parentGroup;
	}

	@Override
	public String toString() {
	StringBuilder sb = new StringBuilder();
	sb.append("Graph ").append(getName()).append(" ").append(getProperties().toString()).append("\n");
	for (InputNode n : nodes.values()) {
	sb.append(n.toString());
	sb.append("\n");
	}

	for (InputEdge c : edges) {
	sb.append(c.toString());
	sb.append("\n");
	}

	for (InputBlock b : getBlocks()) {
	sb.append(b.toString());
	sb.append("\n");
	}

	return sb.toString();
	}

	public InputBlock addBlock(String name) {
	final InputBlock b = new InputBlock(this, name);
	blocks.put(b.getName(), b);
	return b;
	}

	public InputBlock getBlock(String s) {
	return blocks.get(s);
	}

	public Collection<InputBlockEdge> getBlockEdges() {
	return Collections.unmodifiableList(blockEdges);
	}

	@Override
	public Folder getParent() {
	return parent;
	}
	}