public void reduceToOrthogonalRepresentation()

in graphLayout/jetbrains.mps.graphLayout.orthogonalLayout/source_gen/jetbrains/mps/graphLayout/flowOrthogonalLayout/QuasiRepresentationModifier.java [39:158]
108 lines of code
11 McCabe index (conditional complexity)

  public void reduceToOrthogonalRepresentation() {
    Graph graph = myEmbeddedGraph.getGraph();
    Map<Edge, Edge> edgeTransform = MapSequence.fromMap(new HashMap<Edge, Edge>());
    List<Node> initialNodes = ListSequence.fromList(new ArrayList<Node>());
    ListSequence.fromList(initialNodes).addSequence(ListSequence.fromList(myGraph.getNodes()));
    for (final Node node : ListSequence.fromList(initialNodes)) {
      List<Dart> darts = getOrderedDarts(node);
      Iterator<Dart> dartItr = ListSequence.fromList(darts).iterator();
      Set<Dart> removed = SetSequence.fromSet(new HashSet<Dart>());
      while (dartItr.hasNext()) {
        Dart curDart;
        curDart = dartItr.next();
        if ((Integer) MapSequence.fromMap(myAngles).get(curDart) == 0) {
          List<Dart> sameDirectionDarts = ListSequence.fromList(new LinkedList<Dart>());
          while ((Integer) MapSequence.fromMap(myAngles).get(curDart) == 0) {
            ListSequence.fromList(sameDirectionDarts).addElement(curDart);
            curDart = dartItr.next();
          }
          List<Edge> modifiedEdges = ListSequence.fromList(new LinkedList<Edge>());
          for (Dart dart : ListSequence.fromList(sameDirectionDarts)) {
            Edge edge = dart.getEdge();
            if (MapSequence.fromMap(edgeTransform).containsKey(edge)) {
              edge = MapSequence.fromMap(edgeTransform).get(edge);
            }
            ListSequence.fromList(modifiedEdges).addElement(edge);
          }
          Edge edge = curDart.getEdge();
          if (MapSequence.fromMap(edgeTransform).containsKey(edge)) {
            edge = MapSequence.fromMap(edgeTransform).get(edge);
          }
          ListSequence.fromList(modifiedEdges).addElement(edge);
          final Wrappers._T<Edge> curEdge = new Wrappers._T<Edge>(curDart.getEdge());
          int curNum = 0;
          List<Edge> newEdges = ListSequence.fromList(new LinkedList<Edge>());
          for (Dart dart : ListSequence.fromList(sameDirectionDarts).reversedList()) {
            SetSequence.fromSet(removed).addElement(curDart);
            SetSequence.fromSet(removed).addElement(myEmbeddedGraph.getOpposite(curDart));
            Dart backCurDart = myEmbeddedGraph.getOpposite(curDart);
            List<Edge> edgesFromSplit = ListSequence.fromList(new ArrayList<Edge>());
            Node newNode = myEmbeddedGraph.splitEdge(curEdge.value, edgesFromSplit);
            Edge nextEdge = ListSequence.fromList(edgesFromSplit).findFirst(new IWhereFilter<Edge>() {
              public boolean accept(Edge it) {
                return ListSequence.fromList(it.getAdjacentNodes()).contains(node);
              }
            });
            Dart tempDart;
            tempDart = myEmbeddedGraph.getSourceDart(nextEdge, node);
            MapSequence.fromMap(myAngles).put(tempDart, MapSequence.fromMap(myAngles).get(curDart));
            MapSequence.fromMap(myBends).put(tempDart, 0);
            tempDart = myEmbeddedGraph.getOpposite(tempDart);
            MapSequence.fromMap(myAngles).put(tempDart, 1);
            MapSequence.fromMap(myBends).put(tempDart, 0);

            Edge anotherEdge = ListSequence.fromList(edgesFromSplit).findFirst(new IWhereFilter<Edge>() {
              public boolean accept(Edge it) {
                return ListSequence.fromList(it.getAdjacentNodes()).contains(curEdge.value.getOpposite(node));
              }
            });
            if (dart == ListSequence.fromList(sameDirectionDarts).last()) {
              MapSequence.fromMap(edgeTransform).put(anotherEdge, curEdge.value);
              ListSequence.fromList(newEdges).addElement(anotherEdge);
            }
            tempDart = myEmbeddedGraph.getSourceDart(anotherEdge, newNode);
            MapSequence.fromMap(myAngles).put(tempDart, 2);
            MapSequence.fromMap(myBends).put(tempDart, MapSequence.fromMap(myBends).get(curDart));
            tempDart = myEmbeddedGraph.getOpposite(tempDart);
            MapSequence.fromMap(myAngles).put(tempDart, MapSequence.fromMap(myAngles).get(backCurDart));
            MapSequence.fromMap(myBends).put(tempDart, MapSequence.fromMap(myBends).get(backCurDart));

            Face face = myEmbeddedGraph.getFace(dart);
            Dart oppositeDart = myEmbeddedGraph.getOpposite(dart);
            Face anotherFace = myEmbeddedGraph.getFace(oppositeDart);
            Edge oldEdge = dart.getEdge();
            Dart frontOldDart = myEmbeddedGraph.getSourceDart(oldEdge, node);
            Dart backOldDart = myEmbeddedGraph.getOpposite(frontOldDart);
            SetSequence.fromSet(removed).addElement(frontOldDart);
            SetSequence.fromSet(removed).addElement(backOldDart);

            /*
              face.makeEndsWith(node);
            */
            face.makeStartsWith(dart);

            graph.removeEdge(oldEdge);
            Edge newEdge = graph.connect(newNode, oldEdge.getOpposite(node));
            ListSequence.fromList(newEdges).addElement(newEdge);
            MapSequence.fromMap(edgeTransform).put(newEdge, oldEdge);
            Dart lastFaceDart = ListSequence.fromList(face.getDarts()).last();
            myEmbeddedGraph.removeDart(face, lastFaceDart);
            Dart frontNewDart = new Dart(newEdge, newNode);
            myEmbeddedGraph.setDart(face, 0, frontNewDart);
            MapSequence.fromMap(myAngles).put(frontNewDart, 1);
            MapSequence.fromMap(myBends).put(frontNewDart, MapSequence.fromMap(myBends).get(frontOldDart));

            /*
              anotherFace.makeEndsWith(node);
            */
            anotherFace.makeEndsWith(oppositeDart);
            Dart backNewDart = new Dart(newEdge, oldEdge.getOpposite(node));
            myEmbeddedGraph.setDart(anotherFace, ListSequence.fromList(anotherFace.getDarts()).count() - 1, backNewDart);
            myEmbeddedGraph.insertDart(anotherFace, ListSequence.fromList(anotherFace.getDarts()).count(), lastFaceDart);
            MapSequence.fromMap(myAngles).put(backNewDart, MapSequence.fromMap(myAngles).get(backOldDart));
            MapSequence.fromMap(myBends).put(backNewDart, MapSequence.fromMap(myBends).get(backOldDart) - 1);

            List<Edge> historyEdgesList = ListSequence.fromListAndArray(new ArrayList<Edge>(), nextEdge, newEdge);
            GraphModificationEvent splitEvent = new GraphModificationEvent(GraphModificationEvent.Type.EDGE_SPLITTED, oldEdge, historyEdgesList);
            myGraph.getModificationProcessor().fire(splitEvent);
            curEdge.value = nextEdge;
            curDart = myEmbeddedGraph.getSourceDart(curEdge.value, node);
            curNum++;
          }
          ListSequence.fromList(myModifications).addElement(new QuasiRepresentationModifier.Modification(ListSequence.fromList(modifiedEdges).reversedList(), newEdges, node, curDart));
        }
      }
      for (Dart dart : SetSequence.fromSet(removed)) {
        MapSequence.fromMap(myAngles).removeKey(dart);
        MapSequence.fromMap(myBends).removeKey(dart);
      }
    }
  }