Get the start key of the first range.

		None if RangeMap is empty or unbounded to the left.
771285
def start(self):
		
		if self._values[0] is NOT_SET:
			try:
				return self._keys[1]
			except IndexError:
				# This is empty or everything is mapped to a single value
				return None
		else:
			# This is unbounded to the left
			return self._keys[0]
1055062
def get_range_start_coord(self,rng):
    
    sys.stderr.write("error unimplemented get_range_start_coord\n")
    sys.exit()
    if rng.chr not in self._chrs: return None
    for l in [self._lines[x-1] for x in self._chrs[rng.chr]]:
      ####
      y = l['rng']
      c = y.cmp(rng)
      if c > 0: return None
      if c == 0:
        x = y.get_payload()
        return [x[1],x[2]] # don't need the name
    return None
1279394
public String getFirst(final String key) {
    final ArrayList<String> values = super.get(key);
    return values == null ? null : values.get(0);
  }
620733
public Query range(ByteString start, ByteString end) {
    RowRange.Builder rangeBuilder = RowRange.newBuilder();
    if (start != null) {
      rangeBuilder.setStartKeyClosed(start);
    }
    if (end != null) {
      rangeBuilder.setEndKeyOpen(end);
    }
    builder.getRowsBuilder().addRowRanges(rangeBuilder.build());
    return this;
  }
1367110
public void handleInitialKey()                  // init this field override for other value
    {
        KeyArea keyArea = this.getKeyArea(-1);
        if (keyArea == null)
            return;
        BaseBuffer buffer = new VectorBuffer(null);
        boolean[] rgbModified = keyArea.getModified();
        boolean[] rgbNullable = keyArea.setNullable(true);
        keyArea.setupKeyBuffer(buffer, DBConstants.FILE_KEY_AREA);
        keyArea.zeroKeyFields(DBConstants.START_SELECT_KEY);        // Zero out the key fields
        BaseListener  nextListener = this.getNextEnabledListener();
        if (nextListener != null)
            ((FileListener)nextListener).doInitialKey();
        else
            this.doInitialKey();
        keyArea.setNullable(rgbNullable);
        keyArea.setModified(rgbModified);
        keyArea.reverseKeyBuffer(buffer, DBConstants.FILE_KEY_AREA);
    }
1063085
def get_section_key_line(self, data, key, opt_extension=''):
        
        start = 0
        init = 0
        while start != -1:
            start = self.get_next_section_start_line(data[init:])
            init += start
            if start != -1:
                if data[init].strip().lower() == self.opt[key] + opt_extension:
                    break
                init += 1
        if start != -1:
            start = init
        return start
963759
public static <T> KeyRange<T> atLeast(final T start) {
    return new KeyRange<>(KeyRangeType.FORWARD_AT_LEAST, start, null);
  }
765301
def get_range_kwargs(self):
        
        range_kwargs = {}
        if self.start_key is not None:
            start_key_key = "start_key_open"
            if self.start_inclusive:
                start_key_key = "start_key_closed"
            range_kwargs[start_key_key] = _to_bytes(self.start_key)

        if self.end_key is not None:
            end_key_key = "end_key_open"
            if self.end_inclusive:
                end_key_key = "end_key_closed"
            range_kwargs[end_key_key] = _to_bytes(self.end_key)
        return range_kwargs
417602
function getMax(range, key) {
    if (!RANGEREGEX.test(range)) {
      throw new NotAcceptableException("Length bad formated at " + key);
    } else {
      var start = range.indexOf("-");
      var last = range.indexOf("]");
      if (start != -1 && last > start) {
        var max = parseInt(range.substring(start + 1, last));
        return max;
      }
      throw new NotAcceptableException("Length bad formated at " + key);
    }
  }
783262
private Range<RangeTimeUUID> toRange(@Nullable UUID start, @Nullable UUID end, boolean reversed) {
        // If the range is reversed then start and end will also be reversed and must therefore be swapped.
        if (reversed) {
            UUID tmp = start;
            start = end;
            end = tmp;
        }

        if (start == null) {
            if (end == null) {
                return Range.all();
            } else {
                return Range.atMost(new RangeTimeUUID(end));
            }
        } else if (end == null) {
            return Range.atLeast(new RangeTimeUUID(start));
        }
        return Range.closed(new RangeTimeUUID(start), new RangeTimeUUID(end));
    }
915409
public static <T> KeyRange<T> closedOpenBackward(final T start, final T stop) {
    return new KeyRange<>(KeyRangeType.BACKWARD_CLOSED_OPEN, start, stop);
  }
255867
public static KeyRange closedClosed(Key start, Key end) {
    return new KeyRange(checkNotNull(start), Endpoint.CLOSED, checkNotNull(end), Endpoint.CLOSED);
  }
544142
public static int getSlot(ByteBuffer key) {

        int limit = key.limit();
        int position = key.position();

        int start = indexOf(key, SUBKEY_START);
        if (start != -1) {
            int end = indexOf(key, start + 1, SUBKEY_END);
            if (end != -1 && end != start + 1) {
                key.position(start + 1).limit(end);
            }
        }

        try {
            if (key.hasArray()) {
                return CRC16.crc16(key.array(), key.position(), key.limit() - key.position()) % SLOT_COUNT;
            }
            return CRC16.crc16(key) % SLOT_COUNT;
        } finally {
            key.position(position).limit(limit);
        }
    }
54145
private int findRow(int rangeStart) {
        int index = 0;

        // check the vicinity of the last-seen row (start
        // searching with an unrolled loop)

        index = prevRow * columns;
        if (rangeStart >= v[index]) {
            if (rangeStart < v[index + 1]) {
                // same row as last seen
                return index;
            } else {
                index += columns;
                if (rangeStart < v[index + 1]) {
                    ++prevRow;
                    return index;
                } else {
                    index += columns;
                    if (rangeStart < v[index + 1]) {
                        prevRow += 2;
                        return index;
                    } else if ((rangeStart - v[index + 1]) < 10) {
                        // we are close, continue looping
                        prevRow += 2;
                        do {
                            ++prevRow;
                            index += columns;
                        } while (rangeStart >= v[index + 1]);
                        return index;
                    }
                }
            }
        } else if (rangeStart < v[1]) {
            // the very first row
            prevRow = 0;
            return 0;
        }

        // do a binary search for the start of the range
        int start = 0;
        int mid = 0;
        int limit = rows;
        while (start < limit - 1) {
            mid = (start + limit) / 2;
            index = columns * mid;
            if (rangeStart < v[index]) {
                limit = mid;
            } else if (rangeStart < v[index + 1]) {
                prevRow = mid;
                return index;
            } else {
                start = mid;
            }
        }

        // must be found because all ranges together always cover
        // all of Unicode
        prevRow = start;
        index = start * columns;
        return index;
    }
473033
def range(self, start='-', stop='+', count=None):
        
        return self.database.xrange(self.key, start, stop, count)
156506
public KeyGroupRange getIntersection(KeyGroupRange other) {
		int start = Math.max(startKeyGroup, other.startKeyGroup);
		int end = Math.min(endKeyGroup, other.endKeyGroup);
		return start <= end ? new KeyGroupRange(start, end) : EMPTY_KEY_GROUP_RANGE;
	}
986495
@Override
    public Object get(Symbol key, Scriptable start)
    {
        Slot slot = slotMap.query(key, 0);
        if (slot == null) {
            return Scriptable.NOT_FOUND;
        }
        return slot.getValue(start);
    }