Returns the next data value.
    :return: (float|int) the next data value
339747
def next(self):
    
    out = self.peek()[self._headers.index(self._field)]
    self._cursor += 1
    if out is not None:
      self._lastValue = out
    return out
1304522
def next(self):
        """"""
        item = six.next(self._item_iter)
        result = self._item_to_value(self._parent, item)
        # Since we've successfully got the next value from the
        # iterator, we update the number of remaining.
        self._remaining -= 1
        return result
613745
def next(self):
        
        try:
            return self.dict_to_xn(self.csvreader.next())
        except MetadataException:
            # row was metadata; proceed to next row
            return next(self)
220892
def next(self):
        
        if self._cur_item is not None:
            res = self._cur_item
            self._cur_item = None
            return res
        
        return next(self._ex_context)
960662
public int next() {
        int curIndex = _index;
        // Compute the next index.
        if( _index >= 0 ) {
            int i = _state.length - 1;

            while( i >= 0 ) {
                _index += _sum[i];
                if( ++_state[i] < _ranges[i] )
                    break;
                _index -= _sum[i] * _ranges[i];
                _state[i] = 0;
                i--;
            }

            if( i == -1 )
                _index = -1;
        }
        // Return the current index.
        return curIndex;
    }
273316
def next(self):
        
        if not self._cache:
            self._cache = self._get_results()
            self._retrieved += len(self._cache)

        # If we don't have any other data to return, we just
        # stop the iteration.
        if not self._cache:
            raise StopIteration()

        # Consuming the cache and updating the "cursor"
        return self._cache.pop(0)
878243
def next(self, val):
        
        self.queue.append(val)
        return sum(self.queue) / len(self.queue)
1279119
def next(self):
        
        while True:
            x, y = next(self.scan)
            self.index += 1
            if (self.index < self.start): continue
            if (self.index > self.stop): raise StopIteration("skip stopping")
            if ((self.index-self.start) % self.step != 0): continue
            return x, y
979825
def _next(self):
        

        self.top += 1

        while self._occupied and self.top >= self._occupied[0][0]:
            if self.top <= self._occupied[0][1]:
                self.top = self._occupied[0][1] + 1

            self._occupied.pop(0)

        return self.top
1124359
def value(self):
        
        try:
            value = self.lastValue
        except IndexError:
            value = "NaN"
        except ValueError:
            value = "NaN"
        return value
749264
def next(self):
        
        try:
            res, excp = self._stride_buffer.next()
        except (StopIteration, AttributeError):
            try:
                self._stride_buffer = izip(*self._repeat_buffer.next())
            except (StopIteration, AttributeError):
                self._rebuffer()
                self._stride_buffer = izip(*self._repeat_buffer.next())
            res, excp = self._stride_buffer.next()
        if excp:
            raise res
        else:
            return res
632370
def next(self):
        
        if self.current_token == len(self.tokens):
            return None
        token = self.tokens[self.current_token]
        if token["type"] == "newline":
            self.line += 1
            self.line_start = token["start"]
        self.current_token += 1
        if token["type"] == "unknown":
            self.error("Unknown token")
        return token
156125
def grab_next(self, timeout: float=None) -> typing.List[DataAndMetadata.DataAndMetadata]:
        """"""
        with self.__buffer_lock:
            self.__buffer = list()
        return self.grab_latest(timeout)
148579
def min(self):
        
        if len(self._data) == 0:
            return 10
        return next(iter(sorted(self._data.keys())))
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()
314678
def next(self):
        
        return self.iterator.next(task=self.task, timeout=self.timeout,
                                                    block=self.block)
1204841
def next(self):
        
        try:
            if self.next_id:
                return Chart(self.next_id)
            else:
                log.debug('attempted to get next chart, but none was found')
                return
        except AttributeError:
            #chart does not implement next pointer
            log.debug('attempted to get next chart from a chart without a next attribute')
            return None