docs: @Override
      public Sequence<T> next() {
          Sequence<T> sequence = new Sequence<>();
  
          int startPosition = position.getAndIncrement();
          int lastId = -1;
          int currentPoint = order[startPosition];
          int startPoint = currentPoint;
          for (int i = 0; i < walkLength; i++) {
  
              if (alpha > 0 && lastId != startPoint && lastId != -1 && alpha > rng.nextDouble()) {
                  startPosition = startPoint;
                  continue;
              }
  
  
              Vertex<T> vertex = sourceGraph.getVertex(currentPoint);
              sequence.addElement(vertex.getValue());
  
              List<? extends Edge<? extends Number>> edges = sourceGraph.getEdgesOut(currentPoint);
  
              if (edges == null || edges.isEmpty()) {
                  switch (noEdgeHandling) {
                      case CUTOFF_ON_DISCONNECTED:
                          // we just break this sequence
                          i = walkLength;
                          break;
                      case EXCEPTION_ON_DISCONNECTED:
                          throw new NoEdgesException("No available edges left");
                      case PADDING_ON_DISCONNECTED:
                          // TODO: implement padding
                          throw new UnsupportedOperationException("Padding isn't implemented yet");
                      case RESTART_ON_DISCONNECTED:
                          currentPoint = order[startPosition];
                          break;
                      case SELF_LOOP_ON_DISCONNECTED:
                          // we pad walk with this vertex, to do that - we just don't do anything, and currentPoint will be the same till the end of walk
                          break;
                  }
              } else {
                  double totalWeight = 0.0;
                  for (Edge<? extends Number> edge : edges) {
                      totalWeight += edge.getValue().doubleValue();
                  }
  
                  double d = rng.nextDouble();
                  double threshold = d * totalWeight;
                  double sumWeight = 0.0;
                  for (Edge<? extends Number> edge : edges) {
                      sumWeight += edge.getValue().doubleValue();
                      if (sumWeight >= threshold) {
                          if (edge.isDirected()) {
                              currentPoint = edge.getTo();
                          } else {
                              if (edge.getFrom() == currentPoint) {
                                  currentPoint = edge.getTo();
                              } else {
                                  currentPoint = edge.getFrom(); //Undirected edge: might be next--currVertexIdx instead of currVertexIdx--next
                              }
                          }
                          lastId = currentPoint;
                          break;
                      }
                  }
              }
          }
  
          return sequence;
      }