Returns the next range object
344891
public RangeObject getNext()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(this, tc, "getNext", Integer.valueOf(cursor));

    int curr = cursor;
    cursor = cursor < (blockVector.size() - 1) ? cursor + 1 : cursor;

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "getNext", new Object[] {blockVector.get(curr), Integer.valueOf(cursor)});

    return (RangeObject) blockVector.get(curr);
  }
1202303
def range(start, stop):
    

    length = stop - start

    out = list(length=length)

    index = 0

    orig_start = start

    while start < stop:
        val = index + orig_start
        out[index] = val
        index = index + 1
        start = orig_start + index

    return out
104020
def GetTimeRange(cls):
    """"""
    first = getattr(cls, '_lower', 0)
    last = getattr(cls, '_upper', cls.MAX_INT64)

    if first < last:
      return first, last

    return last, first
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()
465714
def next(self) -> mx.io.DataBatch:
        
        if self.iter_next():
            return self.next_batch
        raise StopIteration
638679
def range(self):
        
        data = clips.data.DataObject(self._env)

        lib.EnvSlotRange(self._env, self._cls, self._name, data.byref)

        return tuple(data.value) if isinstance(data.value, list) else ()
1048637
def next(self, *args):
        """"""
        self.initialize()
        self.future = asyncio.Future(loop=self.loop)
        self.handle = self.loop.call_at(self.get_next(), self.call_func, *args)
        return self.future
2861
def _combine_lists_of_ranges_on_length(self, data_len, first, *range_list):
        '''
        
        '''
        current_range = first
        for next_range in range_list:
            current_range = self._combine_ranges_on_length(data_len, current_range, next_range)
        return current_range
1227641
def _read_range(self, start, end=0):
        
        # Get object part
        response = self._client.request(
            'GET', self.name, headers=dict(Range=self._http_range(start, end)),
            timeout=self._TIMEOUT)

        if response.status_code == 416:
            # EOF
            return b''

        # Get object content
        return _handle_http_errors(response).content
477212
function range(start, end) {
  return {
    start: start,
    end: end === undefined ? start : end
  };
}
1094797
def range(self, count):
        
        if count <= 1:
            raise ValueError("Range size must be greater than 1.")
        dom = self._domain
        distance = dom[-1] - dom[0]
        props = [ self(dom[0] + distance * float(x)/(count-1))
            for x in range(count) ]
        return props
284295
def next(self):
        
        try:
            results = self._stride_buffer.pop()
        except (IndexError, AttributeError):
            self._rebuffer()
            results = self._stride_buffer.pop()
        if not results:
            raise StopIteration
        return results
118993
def range_end(self):
        '''
        '''
        count = self.count
        range_end = self.range_start + self.limit - 1
        if count < range_end:
            range_end = count
        return range_end
315981
def next(self):
        
        if self.index < self.length:
            index = self.index
            self.index += 1
            return self.data[index]
        else:
            raise StopIteration()
501627
def next(self):
        ''
        if self.__g_object is None:
            self.__g_object = self.__g_function( *self.__v_args, **self.__d_args )
        try:
            return self.__g_object.next()
        except StopIteration:
            self.__g_object = None
            raise
1198399
function range (start, stop, step) {
  var index, len
  var result = []
  var args = arguments
  if (args.length < 2) {
    stop = args[0]
    start = 0
  }
  index = start >> 0
  len = stop >> 0
  if (index < stop) {
    step = step >> 0 || 1
    for (; index < len; index += step) {
      result.push(index)
    }
  }
  return result
}
287035
def _next_class(cls):
        
        return next(
            class_
            for class_ in cls.__mro__
            if not issubclass(class_, Multi)
        )