public Set reduceNodesDegree()

in graphLayout/jetbrains.mps.graphLayout.orthogonalLayout/source_gen/jetbrains/mps/graphLayout/flowOrthogonalLayout/EmbeddedGraphModifier.java [287:366]
79 lines of code
13 McCabe index (conditional complexity)

  public Set<Edge> reduceNodesDegree(Map<Node, List<Node>> nodeMap, Map<Edge, Edge> edgeMap, boolean splitAllNodes) {
    Set<Edge> addedEdges = SetSequence.fromSet(new HashSet<Edge>());
    List<Node> realNodes = ListSequence.fromList(new ArrayList<Node>());
    ListSequence.fromList(realNodes).addSequence(ListSequence.fromList(myGraph.getNodes()));
    for (final Node node : ListSequence.fromList(realNodes)) {
      List<Edge> edges = node.getEdges();
      if (!(splitAllNodes) && ListSequence.fromList(edges).count() <= 4) {
        continue;
      }
      List<Node> newNodes = ListSequence.fromList(new ArrayList<Node>());
      MapSequence.fromMap(nodeMap).put(node, newNodes);
      Edge firstEdge = ListSequence.fromList(edges).first();
      Dart firstDart = ListSequence.fromList(myEmbeddedGraph.getDarts(firstEdge)).findFirst(new IWhereFilter<Dart>() {
        public boolean accept(Dart dart) {
          return dart.getSource() == node;
        }
      });
      Dart curDart = firstDart;
      Node firstNewNode = myGraph.createDummyNode();
      Node curNewNode = firstNewNode;
      Edge firstNewEdge = myGraph.connect(firstNewNode, firstEdge.getOpposite(node));
      if (firstEdge.getSource() == node) {
        myGraph.removeEdge(firstEdge);
      }
      ListSequence.fromList(newNodes).addElement(firstNewNode);
      MapSequence.fromMap(edgeMap).put(firstEdge, firstNewEdge);
      Edge curNewEdge = firstNewEdge;
      Face newFace = new Face(myGraph);
      do {
        Face curFace = myEmbeddedGraph.getFace(curDart);
        List<Dart> darts = curFace.getDarts();
        int curPos = ListSequence.fromList(darts).indexOf(curDart);
        int nextPos = curPos - 1;
        if (nextPos == -1) {
          nextPos = ListSequence.fromList(darts).count() - 1;
        }
        Dart nextDart = myEmbeddedGraph.getOpposite(ListSequence.fromList(darts).getElement(nextPos));
        if (nextDart == null) {
          nextDart = firstDart;
        }
        Node oppositeNode = nextDart.getEdge().getOpposite(node);
        Node nextNewNode;
        if (nextDart == firstDart) {
          nextNewNode = firstNewNode;
        } else {
          nextNewNode = myGraph.createDummyNode();
          ListSequence.fromList(newNodes).addElement(nextNewNode);
        }
        Edge nextNewEdge;
        if (nextDart == firstDart) {
          nextNewEdge = firstNewEdge;
        } else {
          nextNewEdge = myGraph.connect(nextNewNode, oppositeNode);
          if (firstEdge.getSource() == node) {
            myGraph.removeEdge(firstEdge);
          }
          MapSequence.fromMap(edgeMap).put(nextDart.getEdge(), nextNewEdge);
        }
        Edge edgeBetweenNewNodes = myGraph.connect(curNewNode, nextNewNode);
        SetSequence.fromSet(addedEdges).addElement(edgeBetweenNewNodes);
        newFace.addLast(new Dart(edgeBetweenNewNodes, curNewNode));
        myEmbeddedGraph.setDart(curFace, nextPos, new Dart(nextNewEdge, oppositeNode));
        myEmbeddedGraph.setDart(curFace, curPos, new Dart(curNewEdge, curNewNode));
        myEmbeddedGraph.insertDart(curFace, nextPos + 1, new Dart(edgeBetweenNewNodes, nextNewNode));
        curDart = nextDart;
        curNewNode = nextNewNode;
        curNewEdge = nextNewEdge;
      } while (curDart != firstDart);
      myEmbeddedGraph.addFace(newFace);
      myGraph.deleteNode(node);
    }
    // edge has been modified two times 
    for (Edge edge : SetSequence.fromSet(MapSequence.fromMap(edgeMap).keySet())) {
      Edge newEdge = MapSequence.fromMap(edgeMap).get(edge);
      if (MapSequence.fromMap(edgeMap).containsKey(newEdge)) {
        MapSequence.fromMap(edgeMap).put(edge, MapSequence.fromMap(edgeMap).get(newEdge));
      }
    }
    return addedEdges;
  }