plugins/org.eclipse.emf.henshin.sam.invcheck/src/org/eclipse/emf/henshin/sam/invcheck/algorithm/GraphMerger.java

package org.eclipse.emf.henshin.sam.invcheck.algorithm;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.eclipse.emf.henshin.sam.invcheck.InvariantCheckerUtil;
import org.eclipse.emf.henshin.sam.invcheck.nac.PatternEdge;
import org.eclipse.emf.henshin.sam.invcheck.nac.PatternNode;
import org.eclipse.emf.henshin.sam.model.samannotation.AnnotatedElem;
import org.eclipse.emf.henshin.sam.model.samgraph.Edge;
import org.eclipse.emf.henshin.sam.model.samgraph.Graph;
import org.eclipse.emf.henshin.sam.model.samgraph.Node;
import org.eclipse.emf.henshin.sam.model.samrules.RuleGraph;
import org.eclipse.emf.henshin.sam.model.samrules.SamrulesFactory;
import org.eclipse.emf.henshin.sam.model.samtrace.Match;

/**
 * Merges two graphs and a graph matching to a merged graph.
 * The typical inputs are a forbidden subgraph, a part of the right side of a graph rule and their matching. 
 *  
 * The following diagram shows the behaviour of the merge method.
 * 
 * <p><img src="../../../../../doc/diagrams/graphMerger.png" alt="Graph merger"></p>
 *
 */
public class GraphMerger implements AlgorithmComponent
{
	
	private Map<Graph, Map<AnnotatedElem, AnnotatedElem>> refItems = new HashMap<Graph, Map<AnnotatedElem, AnnotatedElem>>();
	//private Map<Graph, Map<AnnotatedElem, AnnotatedElem>> inverseSameInRuleProp = new HashMap<Graph, Map<AnnotatedElem, AnnotatedElem>>();

   /**
    * No comment provided by developer, please add a comment to improve documentation.
    *
    * @param forbiddenSubGraph  No description provided
    * @param rule       No description provided
    * @param matching   No description provided
    * @return           No description provided
    */
   public RuleGraph merge (Graph forbiddenSubGraph, Graph rule, Match matching)
   {
	  refItems.put(forbiddenSubGraph, new HashMap<AnnotatedElem, AnnotatedElem>());
	  refItems.put(rule, new HashMap<AnnotatedElem, AnnotatedElem>());
      RuleGraph result = null;
      if (forbiddenSubGraph != null && rule != null && matching != null)
      {
         result = SamrulesFactory.eINSTANCE.createRuleGraph();//new Graph();
         result.setTypedOver(rule.getTypedOver());
         copyItems (forbiddenSubGraph, result, true);
         createAssocs (forbiddenSubGraph, result);
         /*
          *  this for loop ensures that items mentioned by the given matching, won't be copied twice.
          */
         for (Iterator<Map.Entry<Node, Node>> iter = matching.getNodeMatching().iterator(); iter.hasNext(); )
         {
            Map.Entry<Node, Node> tmpEntry = iter.next();
            Node ruleNode = tmpEntry.getKey();
            Node resultNode = (Node) refItems.get(forbiddenSubGraph).get(tmpEntry.getValue());
            assert resultNode != null;
            refItems.get(rule).put(ruleNode, resultNode);
            ((PatternNode) resultNode).setSameInRule(ruleNode);
         }
         for (Iterator<Map.Entry<Edge, Edge>> iter = matching.getEdgeMatching().iterator(); iter.hasNext(); ) {
        	 Map.Entry<Edge, Edge> tmpEntry = iter.next();
        	 Edge ruleEdge = tmpEntry.getKey();
        	 Edge resultEdge = (Edge) refItems.get(forbiddenSubGraph).get(tmpEntry.getValue());
        	 assert resultEdge != null;
        	 refItems.get(rule).put(ruleEdge, resultEdge);
        	 ((PatternEdge) resultEdge).setSameInRule(ruleEdge);
         }
         copyItems (rule, result, false);
         createAssocs (rule, result);
      }
      return result;
   }

   /**
    * copies all graph items from srcGraph to resultGraph. thereby the qualified assocs for copies of
    * elements are set.
    *
    * @param srcGraph
    * @param resultGraph
    */
   private void copyItems (Graph srcGraph, Graph resultGraph, boolean isForbidden)
   {
      for (Iterator<Node> iter = srcGraph.getNodes().iterator(); iter.hasNext(); )
      {
         final Node srcNode = iter.next();
         if (!refItems.get(srcGraph).containsKey(srcNode))
         {        	 
        	PatternNode resultNode = InvariantCheckerUtil.copyAsPattern(srcNode);
        	 
            resultGraph.getNodes().add(resultNode);
            refItems.get(srcGraph).put(srcNode, resultNode);
            if (isForbidden) {
            	resultNode.setSameInProp(srcNode);
            } else {
            	resultNode.setSameInRule(srcNode);
            }            
         }
      }
      for (Iterator<Edge> iter = srcGraph.getEdges().iterator(); iter.hasNext(); )
      {
         final Edge srcEdge = iter.next();
         if (!refItems.get(srcGraph).containsKey(srcEdge))
         {
        	PatternEdge resultEdge = InvariantCheckerUtil.copyAsPattern(srcEdge);
            resultGraph.getEdges().add(resultEdge);
            refItems.get(srcGraph).put(srcEdge, resultEdge);
            if (isForbidden) {
            	resultEdge.setSameInProp(srcEdge);
            } else {
            	resultEdge.setSameInRule(srcEdge);
            }
         }
      }
   }


   /**
    * creates the assocs between the nodes and edges of srcGraph between the elements of resultGraph.
    * to make this work, all elements have be copied first before calling this method
    *
    * @param srcGraph     the source Graph
    * @param resultGraph  the resulting graph containing then the assoc from srcGraph
    */
   private void createAssocs (Graph srcGraph, Graph resultGraph)
   {
      for (Iterator<Edge> iter = srcGraph.getEdges().iterator(); iter.hasNext(); )
      {
         final Edge srcEdge = iter.next();
         Node srcTargetNode = srcEdge.getTarget();
         Node srcSourceNode = srcEdge.getSource();
         assert srcTargetNode != null : srcEdge + ": sourceNode equals null!";
         assert srcSourceNode != null : srcEdge + ": targetNode quals null!";

         Edge resultEdge = (Edge) refItems.get(srcGraph).get(srcEdge);
         Node resultTargetNode = (Node) refItems.get(srcGraph).get(srcTargetNode);
         Node resultSourceNode = (Node) refItems.get(srcGraph).get(srcSourceNode);
         
         resultEdge.setSource (resultSourceNode);
         resultEdge.setTarget (resultTargetNode);
      }
   }
   
   public void reset(){
	   refItems = new HashMap<Graph, Map<AnnotatedElem, AnnotatedElem>>();
   }

}

/*
 * $Log$
 * Revision 1.4  2007/06/25 17:48:20  basilb
 * fixed a lot of these bugs testing does not find but evaluating ;)
 *
 * Revision 1.3  2007/01/11 14:44:23  basilb
 * even more usage of generics
 *
 * Revision 1.2  2007/01/03 09:27:48  basilb
 * removed compile errors caused by wrong import declarations; introduced empty plugin class to ensure correct loading
 *
 */