Graph.java

package com.dragome.compiler.graph;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Set;

import com.dragome.compiler.ast.Block;
import com.dragome.compiler.ast.BooleanExpression;
import com.dragome.compiler.ast.BreakStatement;
import com.dragome.compiler.ast.IfStatement;
import com.dragome.compiler.utils.Log;

public abstract class Graph
{

	private Map<String, Node> nodes= new LinkedHashMap<String, Node>(); //super bug!!!

	int nodeIdSequence= 0;

	Log logger= Log.getLogger();

	public Graph()
	{
	}

	public Node getNodeById(String id)
	{
		return nodes.get(id);
	}

	public Node createNode(Class nodeClass)
	{
		return createNode(nodeClass, Integer.toString(nodeIdSequence++, 26));
	}

	public Node createNode(Class nodeClass, String id)
	{
		Node node;
		try
		{
			Constructor constructor= nodeClass.getConstructor(new Class[] { Graph.class });
			node= (Node) constructor.newInstance(new Object[] { this });
		}
		catch (InstantiationException e)
		{
			throw new RuntimeException(e);
		}
		catch (IllegalAccessException e)
		{
			throw new RuntimeException(e);
		}
		catch (NoSuchMethodException e)
		{
			throw new RuntimeException(e);
		}
		catch (InvocationTargetException e)
		{
			throw new RuntimeException(e);
		}
		node.id= id;
		nodes.put(id, node);
		return node;
	}

	public boolean isContained(Set nodesA, Node[] nodesB)
	{
		Set<Node> foo= new LinkedHashSet<Node>(Arrays.asList(nodesB));
		return foo.containsAll(nodesA);
	}

	public void replaceAsTarget(Node oldTarget, Node newTarget)
	{
		for (Edge edge : new ArrayList<Edge>(oldTarget.getInEdges()))
		{
			edge.redirect(newTarget);
		}
	}

	public Edge removeEdge(Node source, Node target)
	{
		Edge edge= getEdge(source, target);
		return removeEdge(edge);
	}

	public Edge removeEdge(Edge edge)
	{
		edge.source.getOutEdges().remove(edge);
		edge.target.getInEdges().remove(edge);
		return edge;
	}

	public String getEdgeId(Node source, Node target)
	{
		return source.getId() + "->" + target.getId();
	}

	public void addIfElseEdge(Node source, Node ifTarget, Node elseTarget, BooleanExpression be)
	{
		ConditionalEdge ifEdge= (ConditionalEdge) addEdge(source, ifTarget, ConditionalEdge.class);
		ifEdge.setBooleanExpression(be);
		ConditionalEdge elseEdge= (ConditionalEdge) addEdge(source, elseTarget, ConditionalEdge.class);
		elseEdge.setBooleanExpression(be);
		elseEdge.setNegate(true);
	}

	public Edge addEdge(Node source, Node target)
	{
		return addEdge(source, target, Edge.class);
	}

	public Edge addEdge(Node source, Node target, Class clazz)
	{
		Edge edge= getEdge(source, target);
		if (edge != null)
		{

			throw new RuntimeException("Edge already exists");
		}
		if (clazz.equals(Edge.class))
		{
			edge= new Edge(this, source, target);
		}
		else if (clazz.equals(SwitchEdge.class))
		{
			edge= new SwitchEdge(this, source, target);
		}
		else if (clazz.equals(ConditionalEdge.class))
		{
			edge= new ConditionalEdge(this, source, target);
		}
		else
		{
			throw new RuntimeException("Illegal edge class " + clazz);
		}
		source.addEdge(edge);
		if (source != target)
		{
			target.addEdge(edge);
		}
		return edge;
	}

	public Edge getEdge(Node source, Node target)
	{
		for (Edge edge : source.getOutEdges())
		{
			if (edge.target == target)
				return edge;
		}
		return null;
	}

	public void removeNode(Node node)
	{
		replaceNode(node, null);
	}

	public Set<Edge> removeOutEdges(Node node)
	{
		Set<Edge> outEdges= new LinkedHashSet<Edge>(node.outEdges);
		Iterator iter= outEdges.iterator();
		while (iter.hasNext())
		{
			Edge edge= (Edge) iter.next();
			removeEdge(edge);
		}

		return outEdges;
	}

	public Set removeInEdges(Node node)
	{
		Set<Edge> inEdges= new LinkedHashSet<Edge>(node.inEdges);
		Iterator<Edge> iter= inEdges.iterator();
		while (iter.hasNext())
		{
			Edge edge= iter.next();
			removeEdge(edge);
		}

		return inEdges;
	}

	public Set removeSelfEdges(Node node)
	{
		Set<Edge> selfEdges= new LinkedHashSet<Edge>();

		for (Edge edge : new LinkedHashSet<Edge>(node.outEdges))
		{
			if (edge.target != node)
				continue;
			removeEdge(edge);
			selfEdges.add(edge);
		}

		return selfEdges;
	}

	public void rerootGlobalOutEdges(Node node, Node newSource)
	{
		Edge[] edges= node.getOutEdgesArray();
		for (int i= 0; i < edges.length; i++)
		{
			Edge edge= edges[i];
			if (edge.isGlobal())
			{
				edge.reroot(newSource);
			}
		}
	}

	public void rerootOutEdges(Node node, Node newSource, boolean localToGlobal)
	{
		Edge[] edges= node.getOutEdgesArray();
		for (int i= 0; i < edges.length; i++)
		{
			Edge edge= edges[i];
			edge.reroot(newSource);
			if (localToGlobal && !edge.isGlobal())
			{
				edge.setOrgSource(node);
			}
		}
	}

	public void replaceNode(Node oldNode, Node newNode)
	{
		nodes.remove(oldNode.getId());

		if (newNode != null)
		{

			replaceAsTarget(oldNode, newNode);

			rerootOutEdges(oldNode, newNode, true);

			newNode.setDomParent(oldNode.getDomParent());
			for (Node child : new ArrayList<Node>(oldNode.getDomChildren()))
			{
				child.setDomParent(newNode);
			}
		}

		if (oldNode.inEdges.size() > 0 || oldNode.outEdges.size() > 0)
			throw new RuntimeException("Cannot replace node with edges");

		oldNode.setDomParent(null);
	}

	public Collection<Node> getNodes()
	{
		return nodes.values();
	}

	public int size()
	{
		return getNodes().size();
	}

	public Block reduceDumb()
	{
		Block block= new Block();

		for (Node node : getNodes())
		{
			block.appendChild(node.block);

			if (node.isBranch())
			{
				IfStatement ifStmt= new IfStatement();
				ConditionalEdge cEdge= node.getConditionalEdge(true);
				ifStmt.setExpression(cEdge.getBooleanExpression().getExpression());
				ifStmt.setIfBlock(new Block());
				Block targetBlock= cEdge.target.block;
				ifStmt.getIfBlock().appendChild(new BreakStatement(targetBlock));
				ifStmt.setElseBlock(new Block());
				targetBlock= node.getConditionalEdge(false).target.block;
				ifStmt.getElseBlock().appendChild(new BreakStatement(targetBlock));
				block.appendChild(ifStmt);
			}
			else
			{
				for (Edge e : node.getOutEdges())
				{
					BreakStatement bStmt= new BreakStatement(e.target.block);
					node.block.appendChild(bStmt);
				}
			}
		}
		return block;
	}

	boolean isTarget(Node n, Set edgeSet)
	{
		Iterator iter= edgeSet.iterator();
		while (iter.hasNext())
		{
			Edge e= (Edge) iter.next();
			if (n == e.target)
				return true;
		}
		return false;
	}

	public void rollOut(Node node, Block targetBlock)
	{
		if (node.trans != null)
		{
			node.trans.rollOut(targetBlock);
		}
		else
		{
			targetBlock.appendChildren(node.block);
		}
	}

	public void dump(String msg)
	{
		StringBuffer sb= new StringBuffer();
		sb.append(msg + " ...\n");
		for (Node node : getNodes())
		{
			sb.append(node.describe() + "\n");

		}
		sb.append("... " + msg);
		logger.debug(sb.toString());
	}
}