Used internally to get the current track and make sure it exists.
181744
def _get_song(self):
        '''
        
        '''
        # Try to get the current track from the start metasong
        if self.at_beginning:
            # Make sure it exists.
            if self.pos < len(self.start):
                # It exists, so return it.
                return self.start[self.pos]
            # It doesn't exist, so let's move on!
            self.at_beginning = False
            # Generate a new track selection
            self._new_track()
        # A bit more difficult than using the start metasong, 
        # because we could have a beginning part. Call a function that gets all 
        # applicable tracks from the metasong.
        s = self._get_selectable()
        # Make sure it is long enough
        while self.pos >= len(s):
            # Or pick a new metasong.
            self._new_song()
            # And repeat.
            s = self._get_selectable()
        # Found a track, return it.
        return s[self.pos]
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);
}
839851
private TrackSourceSlot findTrackSourceSlot() {
        TrackSourceSlot result = TRACK_SOURCE_SLOT_MAP.get(packetBytes[41]);
        if (result == null) {
            return TrackSourceSlot.UNKNOWN;
        }
        return result;
    }
1129305
def value(self, name):
        """"""
        return self.tracks.get(name).row_value(self.controller.row)
1170427
def add_tracks(self, track):
        
        from trackhub import BaseTrack
        if isinstance(track, BaseTrack):
            self.add_child(track)
            self._tracks.append(track)
        else:
            for t in track:
                self.add_child(t)
                self._tracks.append(t)
1082540
def previous_track(self):
        """"""
        # Use previous track button only for sources which support NETAUDIO
        if self._input_func in self._netaudio_func_list:
            body = {"cmd0": "PutNetAudioCommand/CurUp",
                    "cmd1": "aspMainZone_WebUpdateStatus/",
                    "ZoneName": "MAIN ZONE"}
            try:
                return bool(self.send_post_command(
                    self._urls.command_netaudio_post, body))
            except requests.exceptions.RequestException:
                _LOGGER.error(
                    "Connection error: previous track command not sent.")
                return False
1093661
def get_now_playing(self):
        

        params = self._get_params()
        params["limit"] = "1"

        doc = self._request(self.ws_prefix + ".getRecentTracks", False, params)

        tracks = doc.getElementsByTagName("track")

        if len(tracks) == 0:
            return None

        e = tracks[0]

        if not e.hasAttribute("nowplaying"):
            return None

        artist = _extract(e, "artist")
        title = _extract(e, "name")

        return Track(artist, title, self.network, self.name)
110187
function (obj) {
                shared.utils.dassert(getTracker(obj) === this);
                for(var prop in obj) {
                    if(!isPropTracked(obj, prop)) {
                        this.track(obj, prop);
                    }
                }
                this._type = shared.types.TypeStore.instance().type(obj);
            }
789965
public SoundCloudTrack getCurrentTrack() {
        if (mCurrentTrackIndex > -1 && mCurrentTrackIndex < mSoundCloudPlaylist.getTracks().size()) {
            return mSoundCloudPlaylist.getTracks().get(mCurrentTrackIndex);
        }
        return null;
    }
707347
async def load_tracks(self, query) -> LoadResult:
        
        self.__check_node_ready()
        url = self._uri + quote(str(query))

        data = await self._get(url)

        if isinstance(data, dict):
            return LoadResult(data)
        elif isinstance(data, list):
            modified_data = {
                "loadType": LoadType.V2_COMPAT,
                "tracks": data
            }
            return LoadResult(modified_data)
520401
private void trackUsingKlt(List<CombinedTrack<TD>> tracks) {
		for( int i = 0; i < tracks.size();  ) {
			CombinedTrack<TD> track = tracks.get(i);

			if( !trackerKlt.performTracking(track.track) ) {
				// handle the dropped track
				tracks.remove(i);
				tracksDormant.add(track);
			} else {
				track.set(track.track.x,track.track.y);
				i++;
			}
		}
	}
152735
def play_Track(self, track):
        """"""
        if hasattr(track, 'name'):
            self.set_track_name(track.name)
        self.delay = 0
        instr = track.instrument
        if hasattr(instr, 'instrument_nr'):
            self.change_instrument = True
            self.instrument = instr.instrument_nr
        for bar in track:
            self.play_Bar(bar)
465031
public static function allow_track() {
        $DoNotTrackHeader = "DNT";
        $DoNotTrackValue = "1";

        $phpHeader = "HTTP_" . strtoupper(str_replace("-", "_", $DoNotTrackHeader));

        $retval = ! ((array_key_exists($phpHeader, $_SERVER)) and ($_SERVER[$phpHeader] == $DoNotTrackValue));
        return $retval;
    }
1237785
def getTracksForAlbumInCollection(album,user=nil,extras=nil)
      method = 'getTracksForAlbumInCollection'
      type = Track
      args = {:album=>album}
      args[:user] = user if user
      args[:extras] = extras if extras
      return_object type,method,args
    end
625407
public function checkAllAction()
    {
        $batch = $this->loader->getTracker()->checkTrackRounds('trackCheckRoundsAll', $this->currentUser->getUserId());
        $this->_helper->BatchRunner($batch, $this->_('Checking round assignments for all tracks.'), $this->accesslog);

        $this->addSnippet('Track\\CheckRoundsInformation');
    }
869295
private TrackType findTrackType() {
        TrackType result = TRACK_TYPE_MAP.get(packetBytes[42]);
        if (result == null) {
            return TrackType.UNKNOWN;
        }
        return result;
    }
1078537
def store(self):
        '''
        
        '''
        for var_name in self.track_vars:
            value_now = getattr(self,var_name)
            getattr(self,var_name + '_hist').append(value_now)