// The object that will store and convert the DJ
// traversal object to the AspectJ aspect code.

package edu.neu.ccs.demeter.tools.daj;

import edu.neu.ccs.demeter.dj.*;
import edu.neu.ccs.demeter.aplib.EdgeI;
import java.util.*;
import java.io.*;

class AspectJTraversal {
  // the traversal graph that we have translated
  TraversalGraph traversalGraph;
  
  // the name of the traversal
  String traversalName;

  // the name of the aspect
  String aspectName;

  // the buffer containing the traversal code in aspectj
  StringBuffer aspectjTraversalCode;

  // the number of copies stored within a traversal graph
  int copies;

  // the debug mode
  static boolean debug=false;
  static boolean debug2=false;
  static boolean addPrintingAdvice=false;

  AspectJTraversal(String tn, TraversalGraph tg) 
    throws edu.neu.ccs.demeter.aplib.NoSuchClassGraphNodeException{

    traversalGraph = tg;
    copies = getNumberOfCopies();
    traversalName = tn;
    aspectjTraversalCode = traversal2AspectJ(tn, tg);
    aspectName = tn;

  }


  AspectJTraversal(ClassGraph cg, String tn, String st) 
    throws edu.neu.ccs.demeter.aplib.NoSuchClassGraphNodeException{
    
    TraversalGraph tg = new TraversalGraph(st, cg);

    traversalGraph = tg;
    copies = getNumberOfCopies();

    traversalName = tn;
    aspectjTraversalCode = traversal2AspectJ(tn, tg);

    aspectName = tn;
  }

  public String processTraversal(ClassGraph cg, String tn, String st) 
    throws edu.neu.ccs.demeter.aplib.NoSuchClassGraphNodeException{
    
    TraversalGraph tg = new TraversalGraph(st, cg);
    
    traversalGraph = tg;
    traversalName = tn;
    
    appendDefaultTraversalWrapper(tn, getSourceClassFromStrategy(st));

    
    StringBuffer newCode = traversal2AspectJ(tn, tg);
    aspectjTraversalCode.append(newCode);
    aspectName = tn;
    
    return newCode.toString();
  }

  AspectJTraversal() {
    traversalGraph = null;
    traversalName = null;
    aspectjTraversalCode = new StringBuffer();
  }

  public void appendDefaultTraversalWrapper(String tname, String className) {
    String addString = "  void " + className + "." + tname + "() {\n"
      + "  " + tname + "_copy0();\n" + "  }\n";
    appendToTraversalCode(addString);
  }

  public void appendToTraversalCode(String code) {
    aspectjTraversalCode.append(code);
  }

  public void setAspectName(String an) {
    aspectName = an ;
  }

  // get the aspect name
  public String getAspectName() {
    return aspectName;
  }
  
  // get the name of the traversal
  public String getTraversalName() {
    return traversalName;
  }

  // given the startegy get the source node
  public static String getSourceClassFromStrategy(String strategyStr) {

    if (!strategyStr.startsWith("from")) {
      System.out.println("Strategy does not start with from: " + strategyStr);
      return "";
    } else {
      String startName = strategyStr.substring(5,strategyStr.indexOf(' ', 5));    
      if (startName.indexOf("*")> -1) {
        System.out.println("%Error : You can not have * in the source node of a \n"
                   + "traversal in DAJ. DAJ can not know the "
                   + "classname to which it should create the stub.");
        
      }

      return startName;
    }
  }

  // get the traversal string
  public String toString() {

    String aspectHeader = new String("public aspect " + aspectName + " { \n");
    String aspectFooter = new String("} // " + aspectName + "\n");
    return aspectHeader + aspectjTraversalCode.toString() + aspectFooter;
  }


  // output the generated code to file
  public String toFile(File f) throws IOException
  {
    String outString = toString();
    PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter(f)));
    pw.print(outString);
    pw.close();
    return outString;
  }
  
  static protected String cleanStrategyString(String travString) {
    
    StringBuffer newStr = new StringBuffer(100);
    int lastNext = 0;
    for (int nextLine = travString.indexOf('\n');
       nextLine > -1;
       nextLine = travString.indexOf('\n', nextLine+1)) {
      newStr.append(travString.substring(lastNext,nextLine).trim());
      lastNext = nextLine +1;
      //System.out.println(newStr);
    }
    newStr.append(travString.substring(lastNext, travString.length()).trim());
    //System.out.println("output: " + newStr);
    return newStr.toString();
  }
  
  // Convert the traversal to AspectJ code
  protected StringBuffer traversal2AspectJ(String tn, TraversalGraph tg) 
    throws edu.neu.ccs.demeter.aplib.NoSuchClassGraphNodeException{
    // the string buffers
    StringBuffer returnBuffer = new StringBuffer();
    
    // intialize the traversal declaration
    String travString =  cleanStrategyString(tg.getStrategy().toString());
    returnBuffer.append("  // traversal " + tn + " : " + travString + "\n");
    
    if (debug) {
      System.out.println("----------------------------------");
      System.out.println("Processing " + tn + ":" + travString);
      System.out.println(tg);
    }

    // set up the node sets
    List nodeSets = tg.getNodeSets();
    
    if (debug) 
      System.out.println("nodesets: " + nodeSets);
    
    // loop through each node in the traversal graph
    for (Iterator iter = nodeSets.iterator();
       iter.hasNext();
       ) {
      Object node = iter.next();
      TraversalGraph.NodeSet nodeset = (TraversalGraph.NodeSet) node;
      
      String nodeName = getNodeName(node);
      if (debug) System.out.println("processing node: " + nodeName + " nodeset=" + node);
      
      List incomingEdgeSets = getIncomingEdges(node);

      if (debug) System.out.println("Incoming edges\n" + incomingEdgeSets);


      // process each copy edges for this node.
      for (int copyNum = 0; copyNum <= getNumberOfCopies(); copyNum++) {
        if (debug) 
          System.out.println("  Processing copy#" + copyNum);
        if (nodeset.hasIndex(copyNum)
          || isSourceToIntercopyEdge(nodeset, copyNum)){
          String srcCopyString = "_copy" + copyNum;
          
          // set up the buffers for the code that we'll be adding
          StringBuffer travBodyStr = new StringBuffer();
          StringBuffer travBodyHeaderStr = new StringBuffer("  public void " + nodeName + "." + tn 
                                    + srcCopyString + "(){\n");
          StringBuffer travWrapperMethods = new StringBuffer();
          
          boolean hasAddedCode = false;

          TraversalGraph.EdgeSet inheritanceEdge = getInheritanceEdge(nodeset, copyNum);
          TraversalGraph.EdgeSet alternationEdge = getAlternationEdge(nodeset, copyNum);

          // if there's some inheritance going on for this node in this copy
          // then add the super call
          if (inheritanceEdge != null) {
            TraversalGraph.EdgeSet edgeset = inheritanceEdge;
            int targetCopyNumber = getTargetCopyNumber(edgeset, copyNum);
            String targetCopyString = "_copy" + targetCopyNumber;
            
            hasAddedCode = true;

            travBodyStr.append("  super."+ tn + targetCopyString + "();\n");
            
            if (debug) System.out.println("  Processing: " + edgeset);
          }

          if (alternationEdge != null 
            && !alternationEdgeEquivalentToInheritanceEdge(alternationEdge,
                                    inheritanceEdge,
                                    copyNum)) {

            TraversalGraph.EdgeSet edgeset = alternationEdge;
            int targetCopyNumber = getTargetCopyNumber(edgeset, copyNum);
            String targetCopyString = "_copy" + targetCopyNumber;
            
            hasAddedCode = true;

            travBodyStr.append("  super."+ tn + targetCopyString + "();\n");
            
            if (debug) System.out.println("  Processing: " + edgeset);

          }



          List outgoingConstructionEdgeSets = getOutgoingConstructionEdges(nodeset, copyNum);
          if (debug) System.out.println("  outgoing edges: \n  " + outgoingConstructionEdgeSets);

          
          
          // loop through each outgoing edge and process it
          for (Iterator iterEdge = outgoingConstructionEdgeSets.iterator();
             iterEdge.hasNext();
             ) {

            hasAddedCode=true;

            TraversalGraph.EdgeSet edgeset = (TraversalGraph.EdgeSet)iterEdge.next();
            edu.neu.ccs.demeter.aplib.EdgeI currentEdge = edgeset.getEdge();
            
            int targetCopyNumber = getTargetCopyNumber(edgeset, copyNum);
            String targetCopyString = "_copy" + targetCopyNumber;
            
            if (debug) System.out.println("  Processing edge: " + edgeset);
            // add the actual traversal call, i.e. if (edgename!=null) trv_edgename();
            travBodyStr.append("  if (" + currentEdge.getLabel() + " != null) " 
                       + tn + srcCopyString
                       + "_crossing_" + currentEdge.getLabel()
                       + "();\n");
            
            // add method for wrapper method call, i.e. class.trv_crossing_edgename()
            travWrapperMethods.append("  public void " + nodeName + "." + tn 
                          + srcCopyString
                          + "_crossing_" 
                          + currentEdge.getLabel() + "() { "
                          + currentEdge.getLabel() + "." + tn 
                          + targetCopyString + "();}\n");
            
          }
          
          // now add all the traversal code into the string buffer
          // that we're going to return
          travBodyStr.append("  }\n");
          
          // if the wrapper methods is empty then there's no edges outgoing
          // from this node and make sure that there's no outgoing edges.
          if (hasAddedCode || hasIncomingConstructionEdge(nodeset, copyNum)) {
            if (debug) {
              System.out.println("  Adding generated code....");
              System.out.println(travBodyHeaderStr.toString() 
                         + travBodyStr.toString() 
                         + travWrapperMethods.toString());
            }
            returnBuffer.append(travBodyHeaderStr);
            returnBuffer.append(travBodyStr);
            returnBuffer.append(travWrapperMethods);
          } else {
            if (debug) System.out.println("Skipping: " + nodeName);
          }
        }
      }
    }
    
    // add code for the point cut and advice that will print out
    // the traversal as it goes along
    // the form of the point cut and advice:
    // pointcut pointcut_tname () : call(public void tname*());
    // before () : pointcut_tname () {
    //   System.out.println(thisJoinPoint);
    // }
    if (addPrintingAdvice) {
      String pointcutname = "pointcut_" + tn;
      returnBuffer.append("  pointcut " + pointcutname + "() : call(public void " + tn + "*());\n");
      returnBuffer.append("  before () : " + pointcutname + " () { \n");
      returnBuffer.append("  System.out.println(thisJoinPoint);\n");
      returnBuffer.append("  }\n");
    }
    
    if (debug) {
      System.out.println("+++++++++Generated Code+++++++++++++++++");
      System.out.println(returnBuffer);
      System.out.println("+++++++++Generated Code End+++++++++++++");
    }

         return returnBuffer;
  }
  
  
  
  protected List getOutgoingConstructionEdges(Object node, int copyNum) {
    List edgeList = traversalGraph.getEdgeSets();
    LinkedList newList = new LinkedList();
    for (Iterator iter = edgeList.iterator();
       iter.hasNext();
       ){
      TraversalGraph.EdgeSet edgeset = (TraversalGraph.EdgeSet)iter.next();
      EdgeI edge = edgeset.getEdge();
      
      Object edgeNode = null;
      edgeNode = edge.getSource();
      if (debug2) {
        System.out.println("    outgoingEdgeSets: " + edgeset);
        //System.out.println("    compare: " + getSourceCopyNumber(edgeset) + "==" + copyNum 
        //           + "&&" + edgeNode + " == " + node);
      }
      if (isEdgeSetInCopy(edgeset,copyNum) 
        && edgeNode.toString().compareTo(getNodeName(node))==0
        && edge.isConstructionEdge()) {
        
        newList.add(edgeset);
      }
    }
    return newList;
  }

  protected TraversalGraph.EdgeSet getInheritanceEdge(Object node, int copyNum) {
    List edgeList = traversalGraph.getEdgeSets();
    TraversalGraph.EdgeSet returnEdge = null;

    for (Iterator iter = edgeList.iterator();
       iter.hasNext();
       ){
      TraversalGraph.EdgeSet edgeset = (TraversalGraph.EdgeSet)iter.next();
      EdgeI edge = edgeset.getEdge();
      
      Object edgeNode = null;
      edgeNode = edge.getSource();
      if (debug2) {
        System.out.println("    get inheritance edge: " + edgeset);
        //System.out.println("    compare: " + getSourceCopyNumber(edgeset) + "==" + copyNum 
        //           + "&&" + edgeNode + " == " + node);
      }
      if (isEdgeSetInCopy(edgeset,copyNum) 
        && edgeNode.toString().compareTo(getNodeName(node))==0
        && edge.isInheritanceEdge()) {
        
        if (returnEdge != null) 
          System.out.println("%Error: More than one inheritance "
                     + "edge for a copy detected.\n"
                     + returnEdge + " and " + edgeset
                     + " in same copy.");
        returnEdge = edgeset;
      }
    }
    return returnEdge;
  }

  protected TraversalGraph.EdgeSet getAlternationEdge(Object node, int copyNum) {
    List edgeList = traversalGraph.getEdgeSets();
    TraversalGraph.EdgeSet returnEdge = null;

    for (Iterator iter = edgeList.iterator();
       iter.hasNext();
       ){
      TraversalGraph.EdgeSet edgeset = (TraversalGraph.EdgeSet)iter.next();
      EdgeI edge = edgeset.getEdge();
      
      Object edgeNode = null;
      edgeNode = edge.getTarget();
      if (debug2) {
        System.out.println("    get alternation edge: " + edgeset);
        //System.out.println("    compare: " + getSourceCopyNumber(edgeset) + "==" + copyNum 
        //           + "&&" + edgeNode + " == " + node);
      }
      if (isEdgeSetInCopy(edgeset,copyNum) 
        && edgeNode.toString().compareTo(getNodeName(node))==0
        && edge.isAlternationEdge()) {
        
        if (returnEdge != null) 
          System.out.println("%Error: More than one inheritance "
                     + "edge for a copy detected.\n"
                     + returnEdge + " and " + edgeset
                     + " in same copy.");
        returnEdge = edgeset;
      }
    }
    return returnEdge;
  }

  protected boolean isEdgeSetInCopy(TraversalGraph.EdgeSet edgeset, int copyNum) {
    Integer num = new Integer(copyNum);
    List nums = getCopyNumberList(edgeset);
    return (nums.indexOf(num)>= 0);
  }

  protected List getCopyNumberList(TraversalGraph.EdgeSet edgeset) {
    LinkedList list = new LinkedList();
    String edgeStr = edgeset.toString();
    if (debug2) System.out.println("  getCopyNumberList: " + edgeset.toString());
    
    // first parse the node list
    int beginIndex = edgeStr.indexOf('{')+1;
    int commaIndex = edgeStr.indexOf(',', beginIndex);
    int endIndex = edgeStr.indexOf('}', beginIndex);

    while (commaIndex >0 && commaIndex < endIndex) {
      //System.out.println("beginIndex: " + beginIndex + " commaIndex: " + commaIndex);
      String intStr = edgeStr.substring(beginIndex, commaIndex).trim();
      
      if (debug2) System.out.println("  int string = " + intStr);
      
      list.add(new Integer(intStr));
      beginIndex = commaIndex + 1;
      commaIndex = edgeStr.indexOf(',', beginIndex);
    }
    if (beginIndex != endIndex)
      list.add(new Integer(edgeStr.substring(beginIndex, endIndex).trim()));
    
    // next go through the intercopy indices and add the sources
    Set indices = edgeset.getIntercopyIndices();

    for (Iterator iter = indices.iterator(); iter.hasNext();) {
      int num = ((TraversalGraph.IndexPair) iter.next()).getSource();
      list.add(new Integer(num));
    }
    //    if (edgeset.getIntercopyIndices().size() == 0) {
    //} else { 
    
    //int copyNum =((TraversalGraph.IndexPair)(edgeset.getIntercopyIndices().iterator().next())).getSource();
    //list.add(new Integer(copyNum));
    //}

    return list;
  }
  

  protected boolean alternationEdgeEquivalentToInheritanceEdge(TraversalGraph.EdgeSet alterEdge,
                                 TraversalGraph.EdgeSet inherEdge,
                                 int copyNum) {

    if (alterEdge == null || inherEdge == null)
      return false;

    if (alterEdge.getEdge().getSource().toString().compareTo(inherEdge.getEdge().getTarget().toString()) == 0
      && alterEdge.getEdge().getTarget().toString().compareTo(inherEdge.getEdge().getSource().toString()) == 0) {
     
      TraversalGraph.IndexPair alterPair = getIndexPair(alterEdge, copyNum);
      TraversalGraph.IndexPair inherPair = getIndexPair(inherEdge, copyNum);

      if (alterPair == inherPair 
        || ((alterPair != null) 
          && (inherPair != null) 
          && alterPair.equals(inherPair)))
        return true;

    }
    return false;
  }

  protected TraversalGraph.IndexPair getIndexPair(TraversalGraph.EdgeSet edgeset, int copyNum) {
    Set intercopySet = edgeset.getIntercopyIndices();
    
    if (intercopySet.size() == 0)
      return null;

    for (Iterator iter = intercopySet.iterator(); iter.hasNext();) {
      TraversalGraph.IndexPair ip = (TraversalGraph.IndexPair)iter.next();
      if (ip.getSource() == copyNum)
        return ip;
    } 

    return null;

  }
    

  protected int getTargetCopyNumber(TraversalGraph.EdgeSet edgeset, int copyNum) {
    TraversalGraph.IndexPair ip = getIndexPair(edgeset, copyNum);

    if (ip == null)
      return copyNum;
    
    return ip.getTarget();
    
  }

  protected int getSourceCopyNumber(TraversalGraph.EdgeSet edgeset, int copyNum) {
    TraversalGraph.IndexPair ip = getIndexPair(edgeset, copyNum);

    if (ip == null)
      return copyNum;
    
    return ip.getSource();
    
  }

  protected boolean hasIncomingConstructionEdge(Object node, int copyNum) {
    List edgeList = traversalGraph.getEdgeSets();
    LinkedList newList = new LinkedList();
    for (Iterator iter = edgeList.iterator();
       iter.hasNext();
       ){
      TraversalGraph.EdgeSet edgeset = (TraversalGraph.EdgeSet)iter.next();
      EdgeI edge = edgeset.getEdge();
      
      Object edgeNode = null;
      edgeNode = edge.getTarget();
    
      if (getTargetCopyNumber(edgeset, copyNum) == copyNum 
        && edgeNode.toString().compareTo(getNodeName(node))==0
        && edge.isConstructionEdge()) {
        
        return true;
      }
    }
    return false;
  }


  protected boolean isSourceToIntercopyEdge(TraversalGraph.NodeSet nodeset, int copyNum) {

    List edgeList = traversalGraph.getEdgeSets();

    // go through each edge
    for (Iterator edgeIter = edgeList.iterator();
       edgeIter.hasNext();
       ) {

      TraversalGraph.EdgeSet edgeset = (TraversalGraph.EdgeSet) edgeIter.next();
      Set pairSet = edgeset.getIntercopyIndices();
      
      // go through the list of indexed pairs
      for (Iterator pairIter = pairSet.iterator();
         pairIter.hasNext();
         ) {
        int num = ((TraversalGraph.IndexPair) pairIter.next()).getSource();

        // see if the source matches this copy number
        if (copyNum == num) {
          // System.out.println("Found edge:" + edgeset);

          EdgeI edge = edgeset.getEdge();
          
          Object edgeNode = null;
          if (edge.isAlternationEdge())
            edgeNode = edge.getTarget();
          else
            edgeNode = edge.getSource();

          // System.out.println("comparing nodes " + edgeNode + " == " + getNodeName(nodeset));
          // see if the sourcenode is the same as the given node
          if (edgeNode.toString().compareTo(getNodeName(nodeset)) == 0)
            return true;
          
        }
      }
      
    }
    
    return false;
  }

  //////////////////////////////////////////////////////////////////////////////////////////////
  // Old code for reference. Most of this is not used because of change in how
  // the main traversal generation code works. Before the code processed each 
  // edge at a time, but now it first processes the inheritance and alternation edges
  // then it processes the construction edges.

  protected boolean hasOneAndOnlyAlternationEdge(TraversalGraph.NodeSet node, int copyNum) {
    // if there's only one edge and that's an inheritance edge
    // then we should return true
    LinkedList allEdges = new LinkedList();
    allEdges.addAll(getProperOutgoingEdges(node, copyNum));

    if (debug2)
      System.out.println("  hasOneAndOnlyAlternationEdge edges: " + allEdges);

    if (allEdges.size() == 1){
      TraversalGraph.EdgeSet edgeset = (TraversalGraph.EdgeSet) allEdges.getFirst();
      edu.neu.ccs.demeter.aplib.EdgeI currentEdge = edgeset.getEdge();
      if (currentEdge.isAlternationEdge())
        return true;
    }
      
    return false;
  }

  protected boolean hasInheritanceEdgeInSameCopy(TraversalGraph.EdgeSet leftEdgeset) {
    List inheritanceEdges = getInheritanceEdgeSets();
    Object srcEdgeNode = leftEdgeset.getEdge().getSource();
    Object targetEdgeNode = leftEdgeset.getEdge().getTarget();

    int copyNum = getSourceCopyNumber(leftEdgeset);
    for (Iterator iter = inheritanceEdges.iterator();
       iter.hasNext();
       ) {
      
      TraversalGraph.EdgeSet edgeset = (TraversalGraph.EdgeSet)iter.next();
      EdgeI edge = edgeset.getEdge();
      
      Object thisSrcEdgeNode = edge.getSource();
      Object thisTargetEdgeNode = edge.getTarget();      

      if (debug) 
        System.out.println(srcEdgeNode + " " + targetEdgeNode + "\n"
                   + thisSrcEdgeNode + " " + thisTargetEdgeNode + "\n"
                   + copyNum + "==" + getTargetCopyNumber(edgeset)+ "\n");
      
      if (srcEdgeNode.toString().compareTo(thisTargetEdgeNode.toString()) == 0
        && targetEdgeNode.toString().compareTo(thisSrcEdgeNode.toString()) == 0
        && copyNum == getTargetCopyNumber(edgeset)){
        // System.out.println("add to list");
        return true;
      }
      
    }
    return false;
  }

  protected boolean hasInheritanceOrAlternationEdge(TraversalGraph.NodeSet nodeset, int copyNum) {

    List edgeList = traversalGraph.getEdgeSets();
    LinkedList newList = new LinkedList();
    for (Iterator iter = edgeList.iterator();
       iter.hasNext();
       ){
      TraversalGraph.EdgeSet edgeset = (TraversalGraph.EdgeSet)iter.next();
      EdgeI edge = edgeset.getEdge();
      
      if (debug2) 
        System.out.println("  hasInheritanceOrAlternationEdge: " + edgeset);
      Object edgeNode = null;
      int thisCopyNum = getSourceCopyNumber(edgeset);
      if (edgeset.getEdge().isAlternationEdge()) {
        edgeNode = edge.getTarget();
        
      }else{
        edgeNode = edge.getSource();
      }

      if (debug2) 
        System.out.println("  hasInheritanceOrAlternationEdge: " + edgeNode);

      if (thisCopyNum == copyNum 
        && edgeNode.toString().compareTo(getNodeName(edgeNode))==0) {
        if (edge.isInheritanceEdge()
          || edge.isAlternationEdge()) {
          return true;
        }
      }
    }
    return false;
  }

  protected TraversalGraph.EdgeSet getInheritanceOrAlternationEdge(TraversalGraph.NodeSet nodeset, 
                                   int copyNum) {

    List edgeList = traversalGraph.getEdgeSets();
    LinkedList newList = new LinkedList();
    for (Iterator iter = edgeList.iterator();
       iter.hasNext();
       ){
      TraversalGraph.EdgeSet edgeset = (TraversalGraph.EdgeSet)iter.next();
      EdgeI edge = edgeset.getEdge();
      
      
      Object edgeNode = null;
      int thisCopyNum = getSourceCopyNumber(edgeset);
      if (edgeset.getEdge().isAlternationEdge()) {
        edgeNode = edge.getTarget();
        
      }else{
        edgeNode = edge.getSource();
      }

      if (thisCopyNum == copyNum 
        && edgeNode.toString().compareTo(getNodeName(edgeNode))==0) {
        if (edge.isInheritanceEdge()
          || edge.isAlternationEdge()) {
          return edgeset;
        }
      }
    }
    return null;
  }


  protected List getInheritanceEdgeSets() {

    List edgeList = traversalGraph.getEdgeSets();
    LinkedList newList = new LinkedList();
    for (Iterator iter = edgeList.iterator();
       iter.hasNext();
       ){
      TraversalGraph.EdgeSet edgeset = (TraversalGraph.EdgeSet)iter.next();
      EdgeI edge = edgeset.getEdge();
      
      if (edge.isInheritanceEdge()) {
        newList.add(edgeset);
      }
    }
    return newList;
  }

  protected List getOutgoingEdges(Object node) {
    List edgeList = traversalGraph.getEdgeSets();
    LinkedList newList = new LinkedList();
    for (Iterator iter = edgeList.iterator();
       iter.hasNext();
       ){
      TraversalGraph.EdgeSet edgeset = (TraversalGraph.EdgeSet)iter.next();
      EdgeI edge = edgeset.getEdge();
      
      Object edgeNode = null;
      edgeNode = edge.getSource();

      //System.out.println("compare = " + edgeNode + " == " + node);
      if (edgeNode.toString().compareTo(getNodeName(node))==0) {
        // System.out.println("add to list");
        newList.add(edgeset);
      }
    }
    return newList;
  }

  protected List getOutgoingEdges(Object node, int copyNum) {
    List edgeList = traversalGraph.getEdgeSets();
    LinkedList newList = new LinkedList();
    for (Iterator iter = edgeList.iterator();
       iter.hasNext();
       ){
      TraversalGraph.EdgeSet edgeset = (TraversalGraph.EdgeSet)iter.next();
      EdgeI edge = edgeset.getEdge();
      
      Object edgeNode = null;
      edgeNode = edge.getSource();
      if (debug) {
        System.out.println("    outgoingEdgeSets: " + edgeset);
        System.out.println("    compare: " + getSourceCopyNumber(edgeset) + "==" + copyNum 
                   + "&&" + edgeNode + " == " + node);
      }
      if (getSourceCopyNumber(edgeset) == copyNum 
        && edgeNode.toString().compareTo(getNodeName(node))==0) {
        //System.out.println("add to list: " + edgeset);
        newList.add(edgeset);
      }
    }
    return newList;
  }
  protected List getProperOutgoingEdges(Object node, int copyNum) {
    List edgeList = traversalGraph.getEdgeSets();
    LinkedList newList = new LinkedList();
    for (Iterator iter = edgeList.iterator();
       iter.hasNext();
       ){
      TraversalGraph.EdgeSet edgeset = (TraversalGraph.EdgeSet)iter.next();
      EdgeI edge = edgeset.getEdge();
      
      Object edgeNode = null;
      if (edgeset.getEdge().isAlternationEdge())
        edgeNode = edge.getTarget();
      else
        edgeNode = edge.getSource();
      if (debug2) {
        System.out.println("    outgoingEdgeSets: " + edgeset);
        System.out.println("    compare: " + getSourceCopyNumber(edgeset) + "==" + copyNum 
                   + "&&" + edgeNode + " == " + node);
      }
      if (getSourceCopyNumber(edgeset) == copyNum 
        && edgeNode.toString().compareTo(getNodeName(node))==0) {
        //System.out.println("add to list: " + edgeset);
        newList.add(edgeset);
      }
    }
    return newList;
  }



  protected List getIncomingEdges(Object node) {
    List edgeList = traversalGraph.getEdgeSets();
    LinkedList newList = new LinkedList();
    for (Iterator iter = edgeList.iterator();
       iter.hasNext();
       ){
      TraversalGraph.EdgeSet edgeset = (TraversalGraph.EdgeSet)iter.next();
      EdgeI edge = edgeset.getEdge();

      //System.out.println("intercopy indices for " + edgeset + ": " + edgeset.getIntercopyIndices());
      Object edgeNode = null;
      edgeNode = edge.getTarget();

      //System.out.println("compare = " + edgeNode + " == " + node);
      if (edgeNode.toString().compareTo(getNodeName(node))==0) {
        //System.out.println("add to list");
        newList.add(edgeset);
      }
    }
    return newList;
  }


  protected String getNodeName(Object node) {
    String nodeNameRaw = new String(node.toString());
    String nodeName;
    if (nodeNameRaw.indexOf(':') < 0)
      nodeName = nodeNameRaw;
    else
      nodeName = nodeNameRaw.substring(0, nodeNameRaw.indexOf(':'));
    return nodeName;
  }

  public int getNumberOfCopies() {
    List edgeList = traversalGraph.getEdgeSets();
    int returnVal = 0;
    for (Iterator iter = edgeList.iterator();
       iter.hasNext();
       ){
      TraversalGraph.EdgeSet edgeset = (TraversalGraph.EdgeSet)iter.next();
      Set intercopy = edgeset.getIntercopyIndices();
      for (Iterator iter2 = intercopy.iterator();
         iter2.hasNext();
         ) {
        TraversalGraph.IndexPair ip = (TraversalGraph.IndexPair) iter2.next();
        // System.out.println("ip = " + ip);
        if (ip.getTarget() > returnVal)
          returnVal = ip.getTarget();
      }
    }
    if (debug) System.out.println("  total copies : " + returnVal);
    return returnVal;
  }

  protected int getCopyNumber(TraversalGraph.EdgeSet edgeset) {
    String edgeStr = edgeset.toString();
    if (debug) System.out.println("  getCopyNumber: " + edgeset.toString());
    int copyNum = 0;

    if (edgeset.getIntercopyIndices().size() == 0)
      copyNum = Integer.parseInt(edgeStr.substring(edgeStr.indexOf('{')+1, edgeStr.indexOf('}')));
    else 
      copyNum =((TraversalGraph.IndexPair)(edgeset.getIntercopyIndices().iterator().next())).getSource();
    return copyNum;
  }


  protected int getCopyNumber(EdgeI edge) {
    TraversalGraph.EdgeSet edgeset = traversalGraph.getEdgeSet(edge);
    int returnVal = getCopyNumber(edgeset);
    if (debug) System.out.println("  getCopyNumber: " + returnVal + " for: " + edgeset);
    return returnVal;
  }

  protected int getTargetCopyNumber(TraversalGraph.EdgeSet edgeset) {
    Set indexpair = edgeset.getIntercopyIndices();
    
    //if (debug) System.out.println("indexpair: " + indexpair 
    //                + " targetcopy=" + edgeset.getTargetNodeSet());
    if (indexpair.size() == 0) {
      int num = getCopyNumber(edgeset.getEdge());
      //if(debug) System.out.println("getTargetCopyNumber = " + num);
      return num;
    }
    else if (indexpair.size() > 1)
      System.out.println("%Error: There are more than one intercopy indicies.\n"
                 + "Please notify the developer of this expected error.");
    int returnVal = 0;
    for (Iterator iter = indexpair.iterator();
       iter.hasNext();
       ) {
      
      TraversalGraph.IndexPair ip = (TraversalGraph.IndexPair) iter.next();
      returnVal = ip.getTarget();
    }
    //if(debug) System.out.println("getTargetCopyNumber = " + returnVal);
    
    return returnVal;
  }

  protected int getSourceCopyNumber(TraversalGraph.EdgeSet edgeset) {
    Set indexpair = edgeset.getIntercopyIndices();
    
    //if (debug) System.out.println("indexpair: " + indexpair 
    //                + " sourcecopy=" + edgeset);
    if (indexpair.size() == 0) {
      int num = getCopyNumber(edgeset.getEdge());
      //if(debug) System.out.println("-getSourceCopyNumber = " + num);
      return num;
    }
    else if (indexpair.size() > 1)
      System.out.println("%Error: There are more than one intercopy indicies.\n"
                 + "Please notify the developer of this error.");
    int returnVal = 0;
    for (Iterator iter = indexpair.iterator();
       iter.hasNext();
       ) {
      
      TraversalGraph.IndexPair ip = (TraversalGraph.IndexPair) iter.next();
      returnVal = ip.getSource();
    }
    //if(debug) System.out.println("getSourceCopyNumber = " + returnVal);
    
    return returnVal;
  }

  static protected String getTargetNodeName(TraversalGraph.EdgeSet edgeset) {
    if (debug) System.out.println("getTargetNodeName : " + edgeset.getEdge().getTarget());
    return edgeset.getEdge().getTarget().toString();
  }
}