Returns the next element in the iteration.

@return the next element in the iteration
326382
@Override
    public MultiDataSet next() {
        val features = new ArrayList<INDArray>();
        val labels = new ArrayList<INDArray>();
        val featuresMask = new ArrayList<INDArray>();
        val labelsMask = new ArrayList<INDArray>();

        boolean hasFM = false;
        boolean hasLM = false;

        int cnt = 0;
        for (val i: iterators) {
            val ds = i.next();

            features.add(ds.getFeatures());
            featuresMask.add(ds.getFeaturesMaskArray());

            if (outcome < 0 || cnt == outcome) {
                labels.add(ds.getLabels());
                labelsMask.add(ds.getLabelsMaskArray());
            }

            if (ds.getFeaturesMaskArray() != null)
                hasFM = true;

            if (ds.getLabelsMaskArray() != null)
                hasLM = true;

            cnt++;
        }

        INDArray[] fm = hasFM ? featuresMask.toArray(new INDArray[0]) : null;
        INDArray[] lm = hasLM ? labelsMask.toArray(new INDArray[0]) : null;

        val mds = new org.nd4j.linalg.dataset.MultiDataSet(features.toArray(new INDArray[0]), labels.toArray(new INDArray[0]), fm, lm);

        if (preProcessor != null)
            preProcessor.preProcess(mds);

        return mds;
    }
456408
public String getNextString()
    {
        Object data = this.getNextData();
        if (data instanceof String)
            return (String)data;
        return null;    // EOF
    }
852398
public synchronized Object next()
    {
        if (position < scrolled)
        {
            position++;
            return elements.get(position - 1);
        }
        else
        {
            Object next = ojbIterator.next();
            elements.add(next);
            position++;
            scrolled++;
            return next;
        }
    }
1142984
public function next() {
    // copy current permutation
    $rval = $this->list;

    /* Calculate the next permutation using the Steinhaus-Johnson-Trotter
     permutation algorithm. */

    // get largest mobile element k
    // (mobile: element is greater than the one it is looking at)
    $k = null;
    $pos = 0;
    $length = count($this->list);
    for($i = 0; $i < $length; ++$i) {
      $element = $this->list[$i];
      $left = $this->left->{$element};
      if(($k === null || $element > $k) &&
        (($left && $i > 0 && $element > $this->list[$i - 1]) ||
        (!$left && $i < ($length - 1) && $element > $this->list[$i + 1]))) {
        $k = $element;
        $pos = $i;
      }
    }

    // no more permutations
    if($k === null) {
      $this->done = true;
    } else {
      // swap k and the element it is looking at
      $swap = $this->left->{$k} ? $pos - 1 : $pos + 1;
      $this->list[$pos] = $this->list[$swap];
      $this->list[$swap] = $k;

      // reverse the direction of all elements larger than k
      for($i = 0; $i < $length; ++$i) {
        if($this->list[$i] > $k) {
          $this->left->{$this->list[$i]} = !$this->left->{$this->list[$i]};
        }
      }
    }

    return $rval;
  }
840660
public int[] next() {
		if (!hasNext) return null;
		int[] result = new int[r];
		for (int i=0; i<r; i++) result[i] = index[i];
		moveIndex();
		return result;
	}
1154141
@Override
    public Sequence<T> nextSequence() {
        Sequence<T> sequence = currentIterator.next();
        sequence.setSequenceId(tagger.getAndIncrement());
        return sequence;
    }
481753
public synchronized T next() {
	if (current == null) {
	    throw new NoSuchElementException();
	}
	T t = current.next();
        // Once an element has been drawn from the iterator, the current
        // iterator should be used for any subsequent remove call.
        if (toRemoveFrom != current)
            toRemoveFrom = current;
	advance();
	return t;
    }
337703
public NodeT getNext() {
        String nextItemKey = queue.poll();
        if (nextItemKey == null) {
            return null;
        }
        return nodeTable.get(nextItemKey);
    }
443834
@Override
    public Object next() {
        try {
            mEvent = nextEvent();
        } catch (final XMLStreamException exc) {
            exc.printStackTrace();
        }

        return mEvent;
    }
765012
@Override
    public Object next() {
        Object retVal = null;
        try {
            retVal = nextEvent();
        } catch (final XMLStreamException e) {
            retVal = null;
        }
        return retVal;
    }
7997
public Node nextNode() throws NoSuchElementException
   {
      initialize();
      if (next == null)
      {
         throw new NoSuchElementException();
      }
      NodeImpl n = next;
      fetchNext();
      return n;
   }
1316192
def next(self):
        
        if self.row < self.data.num_instances:
            index = self.row
            self.row += 1
            return self.data.get_instance(index)
        else:
            raise StopIteration()
543254
public String next() {
        if (entry == null) return null;
        entry = entry.next;
        return entry.element;
    }
616177
@Override
  public T next() {
    final Object value = iterator.next();
    final T entity = mapper.fromReadValue(value);
    return entity;
  }
1012542
@Override
  public Iterator<T> iterator() {
    return new Iterator<T>() {

      /** The index of the next item. */
      private int next = ArrayQueue.this.next;

      /* (non-Javadoc)
       * @see java.util.Iterator#hasNext()
       */
      public boolean hasNext() {
        return next < items.length;
      }

      /* (non-Javadoc)
       * @see java.util.Iterator#next()
       */
      public T next() {
        if (next >= items.length) {
          throw new NoSuchElementException();
        }
        return items[next++];
      }

      /* (non-Javadoc)
       * @see java.util.Iterator#remove()
       */
      public void remove() {
        throw new UnsupportedOperationException();
      }

    };
  }
315981
def next(self):
        
        if self.index < self.length:
            index = self.index
            self.index += 1
            return self.data[index]
        else:
            raise StopIteration()
278399
@Override
	public String next() {
		Long current = next;
		next += 1;

		return String.format(format, current);
	}