Create a {@link KeyRangeType#BACKWARD_CLOSED} range.

@param <T>   buffer type
@param start start key (required)
@param stop  stop key (required)
@return a key range (never null)
330254
public static <T> KeyRange<T> closedBackward(final T start, final T stop) {
    return new KeyRange<>(KeyRangeType.BACKWARD_CLOSED, start, stop);
  }
433315
function range(start, stop, step){
  utils.assertType(start, 'unit', 'start');
  utils.assertType(stop, 'unit', 'stop');
  if (step) {
    utils.assertType(step, 'unit', 'step');
    if (0 == step.val) {
      throw new Error('ArgumentError: "step" argument must not be zero');
    }
  } else {
    step = new nodes.Unit(1);
  }
  var list = new nodes.Expression;
  for (var i = start.val; i <= stop.val; i += step.val) {
    list.push(new nodes.Unit(i, start.type));
  }
  return list;
}
1032476
public static <T> KeyRange<T> greaterThan(final T start) {
    return new KeyRange<>(KeyRangeType.FORWARD_GREATER_THAN, start, null);
  }
1360260
public static KeyRange openClosed(Key start, Key end) {
    return new KeyRange(checkNotNull(start), Endpoint.OPEN, checkNotNull(end), Endpoint.CLOSED);
  }
879311
function lrange(key, start, stop, req) {
  var val = this.getKey(key, req);
  if(val === undefined) return null;
  return val.lrange(start, stop);
}
843792
public function zRemRangeByRank($key, $start, $stop) {
        return $this->getHandler($this->judge(__FUNCTION__))->zRemRangeByRank($key, $start, $stop);
    }
381344
public Range<T> reset() {
		lock.lock();
		try {
			this.current = this.start;
			this.index = 0;
		} finally {
			lock.unlock();
		}
		return this;
	}
422713
def ranges(self, start=None, stop=None):
		
		_check_start_stop(start, stop)
		start_loc = self._bisect_right(start)
		if stop is None:
			stop_loc = len(self._keys)
		else:
			stop_loc = self._bisect_left(stop)
		start_val = self._values[start_loc - 1]
		candidate_keys = [start] + self._keys[start_loc:stop_loc] + [stop]
		candidate_values = [start_val] + self._values[start_loc:stop_loc]
		for i, value in enumerate(candidate_values):
			if value is not NOT_SET:
				start_key = candidate_keys[i]
				stop_key = candidate_keys[i + 1]
				yield MappedRange(start_key, stop_key, value)
1339956
public HSlicePredicate<N> setStartOn(N start) {
    this.start = start;
    predicateType = PredicateType.Range;
    return this;
  }
136247
static KeyRange keyRangeSingleRow(byte[] rowKey) {
        KeyRange keyRange = new KeyRange();
        keyRange.setStart_key(rowKey);
        keyRange.setEnd_key(rowKey);
        keyRange.setCount(1);
        return keyRange;
    }
103421
function getrange(key, start, end, req) {
  var val = this.getKey(key, req);
  if(!val) return '';
  start = parseInt(start);
  end = parseInt(end);
  if(start < 0) start = val.length + start;
  if(end < 0) end = val.length + end;
  // TODO: buffer compat
  return (val + '').substr(start, end + 1);
}
96704
public static <T> KeyRange<T> closed(final T start, final T stop) {
    return new KeyRange<>(KeyRangeType.FORWARD_CLOSED, start, stop);
  }
748363
public static RubyRange<LocalDateTime> range(LocalDateTime start,
      LocalDateTime end) {
    return new RubyRange<>(LocalDateTimeSuccessor.getInstance(), start, end,
        Interval.CLOSED);
  }
1267164
TokenRange range(Node begin, JavaToken end) {
        if (storeTokens) {
            return new TokenRange(begin.getTokenRange().get().getBegin(), end);
        }
        return null;
    }
64046
public static <T> List<T> slice(List<T> list, Integer start, Integer stop) {
        int size = list.size();

        if (start == null) {
            start = 0;
        } else if (start < 0) {
            start = size + start;
        }

        if (stop == null) {
            stop = size;
        } else if (stop < 0) {
            stop = size + stop;
        }

        if (start >= size || stop <= 0 || start >= stop) {
            return Collections.emptyList();
        }

        start = Math.max(0, start);
        stop = Math.min(size, stop);

        return list.subList(start, stop);
    }
565908
public static int[] range(int start, int end) {
    int[] out = new int[end - start];
    for(int i = 0, j = start; j < end; i++, j++) {
      out[i] = j;
    }
    return out;
  }
37319
function range(start, stop) {
  if (arguments.length <= 1) {
    stop = start || 0;
    start = 0;
  }

  var length = Math.max(stop - start, 0);
  var idx = 0;
  var arr = new Array(length);

  while(idx < length) {
    arr[idx++] = start;
    start += 1;
  }

  return arr;
}