Example #1
0
 @Override
 public Void visitFormalParameterList(FormalParameterList node) {
   String groupEnd = null;
   writer.print('(');
   NodeList<FormalParameter> parameters = node.getParameters();
   int size = parameters.size();
   for (int i = 0; i < size; i++) {
     FormalParameter parameter = parameters.get(i);
     if (i > 0) {
       writer.print(", ");
     }
     if (groupEnd == null && parameter instanceof DefaultFormalParameter) {
       if (parameter.getKind() == ParameterKind.NAMED) {
         groupEnd = "}";
         writer.print('{');
       } else {
         groupEnd = "]";
         writer.print('[');
       }
     }
     parameter.accept(this);
   }
   if (groupEnd != null) {
     writer.print(groupEnd);
   }
   writer.print(')');
   return null;
 }
 public void test_get_tooBig() {
   NodeList<ASTNode> list = new NodeList<ASTNode>(argumentList());
   try {
     list.get(1);
     fail("Expected IndexOutOfBoundsException");
   } catch (IndexOutOfBoundsException exception) {
     // Expected
   }
 }
 /** @see org.eclipse.graph.HorizontalPlacement#applyGPrime() */
 void applyGPrime() {
   super.applyGPrime();
   NodeList subgraphs = ((CompoundDirectedGraph) graph).subgraphs;
   for (int i = 0; i < subgraphs.size(); i++) {
     Subgraph s = (Subgraph) subgraphs.get(i);
     s.x = s.left.x;
     s.width = s.right.x + s.right.width - s.x;
   }
 }
  public void test_set() {
    ArrayList<ASTNode> nodes = new ArrayList<ASTNode>();
    ASTNode firstNode = booleanLiteral(true);
    ASTNode secondNode = booleanLiteral(false);
    ASTNode thirdNode = booleanLiteral(true);
    nodes.add(firstNode);
    nodes.add(secondNode);
    nodes.add(thirdNode);
    NodeList<ASTNode> list = new NodeList<ASTNode>(argumentList());
    list.addAll(nodes);
    assertSize(3, list);

    ASTNode fourthNode = integer(0);
    assertSame(secondNode, list.set(1, fourthNode));
    assertSize(3, list);
    assertSame(firstNode, list.get(0));
    assertSame(fourthNode, list.get(1));
    assertSame(thirdNode, list.get(2));
  }
Example #5
0
 /**
  * Print a list of nodes, separated by the given separator.
  *
  * @param nodes the nodes to be printed
  * @param separator the separator to be printed between adjacent nodes
  */
 private void visitList(NodeList<? extends ASTNode> nodes, String separator) {
   if (nodes != null) {
     int size = nodes.size();
     for (int i = 0; i < size; i++) {
       if (i > 0) {
         writer.print(separator);
       }
       nodes.get(i).accept(this);
     }
   }
 }
 private int buildNestingTreeIndices(NodeList nodes, int base) {
   for (int i = 0; i < nodes.size(); i++) {
     Node node = (Node) nodes.get(i);
     if (node instanceof Subgraph) {
       Subgraph s = (Subgraph) node;
       s.nestingTreeMin = base;
       base = buildNestingTreeIndices(s.members, base);
     }
     node.nestingIndex = base++;
   }
   return base++;
 }
  public void test_addAll() {
    ASTNode parent = argumentList();
    ArrayList<ASTNode> firstNodes = new ArrayList<ASTNode>();
    ASTNode firstNode = booleanLiteral(true);
    ASTNode secondNode = booleanLiteral(false);
    firstNodes.add(firstNode);
    firstNodes.add(secondNode);
    NodeList<ASTNode> list = new NodeList<ASTNode>(parent);
    list.addAll(firstNodes);
    assertSize(2, list);
    assertSame(firstNode, list.get(0));
    assertSame(secondNode, list.get(1));
    assertSame(parent, firstNode.getParent());
    assertSame(parent, secondNode.getParent());

    ArrayList<ASTNode> secondNodes = new ArrayList<ASTNode>();
    ASTNode thirdNode = booleanLiteral(true);
    ASTNode fourthNode = booleanLiteral(false);
    secondNodes.add(thirdNode);
    secondNodes.add(fourthNode);
    list.addAll(secondNodes);
    assertSize(4, list);
    assertSame(firstNode, list.get(0));
    assertSame(secondNode, list.get(1));
    assertSame(thirdNode, list.get(2));
    assertSame(fourthNode, list.get(3));
    assertSame(parent, firstNode.getParent());
    assertSame(parent, secondNode.getParent());
    assertSame(parent, thirdNode.getParent());
    assertSame(parent, fourthNode.getParent());
  }
  public void test_add() {
    ASTNode parent = argumentList();
    ASTNode firstNode = booleanLiteral(true);
    ASTNode secondNode = booleanLiteral(false);
    NodeList<ASTNode> list = new NodeList<ASTNode>(parent);
    list.add(0, secondNode);
    list.add(0, firstNode);
    assertSize(2, list);
    assertSame(firstNode, list.get(0));
    assertSame(secondNode, list.get(1));
    assertSame(parent, firstNode.getParent());
    assertSame(parent, secondNode.getParent());

    ASTNode thirdNode = booleanLiteral(false);
    list.add(1, thirdNode);
    assertSize(3, list);
    assertSame(firstNode, list.get(0));
    assertSame(thirdNode, list.get(1));
    assertSame(secondNode, list.get(2));
    assertSame(parent, firstNode.getParent());
    assertSame(parent, secondNode.getParent());
    assertSame(parent, thirdNode.getParent());
  }
  /*
   * Execution of the modified greedy cycle removal algorithm.
   */
  private void cycleRemove(NodeList children) {
    NodeList sR = new NodeList();
    do {
      findSinks(children, sR);
      findSources(children);

      // all sinks and sources added, find node with highest
      // outDegree - inDegree
      Node max = findNodeWithMaxDegree(children);
      if (max != null) {
        for (int i = 0; i < children.size(); i++) {
          Node child = (Node) children.get(i);
          if (child.flag) continue;
          if (child == max) restoreSinks(max, sR);
          else restoreSources(child);
        }
        remove(max);
      }
    } while (!allFlagged(children));
    while (!sR.isEmpty()) sL.add(sR.remove(sR.size() - 1));
  }