Returns the track number, as converted into
an integer, or -1 if not available / not numeric
507065
public int getTrackNumberNumeric() {
        String number = getTrackNumber();

        if(number == null) return -1;
        try {
            return Integer.parseInt(number);
        } catch(NumberFormatException e) {
            return -1;
        }
    }
20326
def get_run_number():
    
    try:
        f = open(os.path.join(os.getenv('DATA_HOME', "."), 'RUNNUM'), 'r')
        num = int(f.read())
        f.close()
    except Exception:
        num = 1
    f = open(os.path.join(os.getenv('DATA_HOME', "."), 'RUNNUM'), 'w')
    f.write(str(num + 1))
    f.close()
    return num
1363582
public int getHighestReferenceNumber() {
		int max = -1;
        for (Object o : m_tunes.keySet()) {
            Integer i = (Integer) o;
            if (i > max)
                max = i;
        }
		return max;
	}
320224
def get_not_num(self, seq, num=0):
        ''''''
        ind = next((i for i, x in enumerate(seq) if x != num), None)
        if ind == None:
            return self.board_size
        else:
            return ind
744498
def header(self):
        
        chunk_size = a2b_hex('%08x' % (len(self.track_data)
                              + len(self.end_of_track())))
        return TRACK_HEADER + chunk_size
1245391
@SuppressWarnings("WeakerAccess")
    public int findBeatAtTime(long milliseconds) {
        int found = Arrays.binarySearch(timeWithinTrackValues, milliseconds);
        if (found >= 0) {  // An exact match, just change 0-based array index to 1-based beat number
            return found + 1;
        } else if (found == -1) {  // We are before the first beat
            return found;
        } else {  // We are after some beat, report its beat number
            return -(found + 1);
        }
    }
1168815
function (offset) {
    for (var i = beatmap.timingPoints.length - 1; i >= 0; i--) {
      if (beatmap.timingPoints[i].offset <= offset) { return beatmap.timingPoints[i]; }
    }
    return beatmap.timingPoints[0];
  }
1324117
public Track getTrack(int trackID) throws MusixMatchException {
		Track track = new Track();
		Map<String, Object> params = new HashMap<String, Object>();

		params.put(Constants.API_KEY, apiKey);
		params.put(Constants.TRACK_ID, new String("" + trackID));

		track = getTrackResponse(Methods.TRACK_GET, params);

		return track;
	}
931388
def get_line_number(line_map, offset):
    """"""
    for lineno, line_offset in enumerate(line_map, start=1):
        if line_offset > offset:
            return lineno
    return -1
869295
private TrackType findTrackType() {
        TrackType result = TRACK_TYPE_MAP.get(packetBytes[42]);
        if (result == null) {
            return TrackType.UNKNOWN;
        }
        return result;
    }
578590
def parse_track_header(self, fp):
        """"""
        # Check the header
        try:
            h = fp.read(4)
            self.bytes_read += 4
        except:
            raise IOError("Couldn't read track header from file. Byte %d."
                    % self.bytes_read)
        if h != 'MTrk':
            raise HeaderError('Not a valid Track header. Byte %d.'
                    % self.bytes_read)

        # Parse the size of the header
        try:
            chunk_size = fp.read(4)
            self.bytes_read += 4
        except:
            raise IOError("Couldn't read track chunk size from file.")
        chunk_size = self.bytes_to_int(chunk_size)
        return chunk_size
374957
def get_slide_number(self):
		
		a, slide_number, b = self.get_id_parts()
		if slide_number > 5000:
			slide_number = 5000 - slide_number
		return slide_number
463455
int getNextSentencePosition(int numberOfParagraph, int startOfSentencePosition) {
    for (CacheEntry anEntry : entries) {
      if (anEntry.numberOfParagraph == numberOfParagraph && anEntry.startOfSentencePosition == startOfSentencePosition) {
        return anEntry.nextSentencePosition;
      }
    }
    return -1;
  }
1090114
public long[] getTrackNumbers() {

        List<TrackFragmentBox> trackBoxes = this.getBoxes(TrackFragmentBox.class, false);
        long[] trackNumbers = new long[trackBoxes.size()];
        for (int trackCounter = 0; trackCounter < trackBoxes.size(); trackCounter++) {
            TrackFragmentBox trackBoxe = trackBoxes.get(trackCounter);
            trackNumbers[trackCounter] = trackBoxe.getTrackFragmentHeaderBox().getTrackId();
        }
        return trackNumbers;
    }
822588
def get_number(self, num, table=None):
        """"""
        if table is None: table = self.main_table
        self.own_cursor.execute('SELECT * from "%s" LIMIT 1 OFFSET %i;' % (self.main_table, num))
        return self.own_cursor.fetchone()
449451
public int getNumberOfAttempts() {
        String value = Optional.fromNullable(getParameter(SignalParameters.NUMBER_OF_ATTEMPTS.symbol())).or("1");
        return Integer.parseInt(value);
    }
248403
function parseTrack(cursor) {
    var chunk, events = [],
        result, runningStatus = null;

    chunk = parseChunk('MTrk', cursor);

    while (!chunk.eof()) {
        result = parseEvent(chunk, runningStatus);
        runningStatus = result.runningStatus;

        events.push(result.event);
    }

    return new Track(events);
}