Delete a playlist.
966507
def deletePlaylist(playlist)
      method = 'deletePlaylist'
      type = Boolean
      args = {:playlist=>playlist}
      return_object type,method,args,true
    end
258866
def loadlist(self, playlist, mode='replace'):
        """"""
        self.command('loadlist', playlist.encode(fs_enc), mode)
1297124
def delete(self):
        """"""
        if lib.EnvDeleteInstance(self._env, self._ist) != 1:
            raise CLIPSError(self._env)
979627
def songs_delete(self, songs):
		

		mutations = [mc_calls.TrackBatch.delete(song['id']) for song in songs]
		response = self._call(
			mc_calls.TrackBatch,
			mutations
		)

		success_ids = [
			res['id']
			for res in response.body['mutate_response']
			if res['response_code'] == 'OK'
		]

		# TODO: Report failures.
		# failure_ids = [
		# 	res['id']
		# 	for res in response.body['mutate_response']
		# 	if res['response_code'] != 'OK'
		# ]

		return success_ids
893454
def delete(self):
        """"""
        self.__class__.objects.filter(pk=self.pk).delete()
558939
public void removeTrack(int playlistIndex) {
        checkState();
        SoundCloudTrack currentTrack = mPlayerPlaylist.getCurrentTrack();
        SoundCloudTrack removedTrack = mPlayerPlaylist.remove(playlistIndex);

        if (removedTrack == null) {
            // nothing removed
            return;
        }

        if (mPlayerPlaylist.isEmpty()) {
            // playlist empty after deletion, stop player;
            PlaybackService.stop(getContext(), mClientKey);
        } else if (currentTrack != null && currentTrack.equals(removedTrack) && mState == STATE_PLAYING) {
            // play next track if removed one was the current and playing
            play(mPlayerPlaylist.getCurrentTrackIndex());
        }

        for (CheerleaderPlaylistListener listener : mCheerleaderPlaylistListeners) {
            listener.onTrackRemoved(removedTrack, mPlayerPlaylist.isEmpty());
        }
    }
968245
def DeleteList(self, listName):
        """"""

        # Build Request
        soap_request = soap('DeleteList')
        soap_request.add_parameter('listName', listName)
        self.last_request = str(soap_request)

        # Send Request
        response = self._session.post(url=self._url('Lists'),
                                      headers=self._headers('DeleteList'),
                                      data=str(soap_request),
                                      verify=self._verify_ssl,
                                      timeout=self.timeout)

        # Parse Request
        if response == 200:
            return response.text
        else:
            return response
1178379
def clear(self):
        """"""

        r = self._h._http_resource(
            method='DELETE',
            resource=('user', 'keys'),
        )

        return r.ok
1282400
def _delete(self, c, context, hm):
        """"""
        pools = hm.get("pools", [])

        for pool in pools:
            pool_id = pool.get("pool_id")
            self._dissociate(c, context, hm, pool_id)

        self._delete_unused(c, context, hm)
129271
private void doChangeSelectionInList(int moveBy)
	{
		PlayListEntry [] selected = playList.getSelectedEntries();
		if (selected==null || selected.length == 0)
		{
			playList.setSelectedElement(0);
			doMakeIndexVisible(0);
		}
		else
		{
			int firstIndex = selected[0].getIndexInPlaylist(); 
			int lastIndex = selected[selected.length - 1].getIndexInPlaylist();
			if (moveBy < 0)
			{
				firstIndex += moveBy;
				if (firstIndex<0) firstIndex = 0;
			}
			else
			{
				lastIndex += moveBy;
				if (lastIndex >= playList.size()) lastIndex = playList.size() - 1; 
			}
			playList.setSelectedElements(firstIndex, lastIndex);
			if (moveBy < 0) doMakeIndexVisible(firstIndex); else doMakeIndexVisible(lastIndex);
		}
	}
381129
public function remove() : void
    {
        if ($this->onlineIdParameter() === 'me') return;

        $this->delete(sprintf(self::USERS_ENDPOINT . 'friendList/%s', $this->client->onlineId(), $this->onlineId()));
    }
611253
def delete(self):
        """"""
        if lib.EnvDeleteActivation(self._env, self._act) != 1:
            raise CLIPSError(self._env)

        self._env = None
361373
private void fireMusicSwapped(Music newMusic) {
		playing = false;
		for (int i=0;i<listeners.size();i++) {
			((MusicListener) listeners.get(i)).musicSwapped(this, newMusic);
		}
	}
1249974
public void unload()
    {
        if (mAudioListener != null)
        {
            Log.d("SOUND", "unloading audio source %d %s", getSourceId(), getSoundFile());
            mAudioListener.getAudioEngine().unloadSoundFile(getSoundFile());
        }
        mSoundFile = null;
        mSourceId = GvrAudioEngine.INVALID_ID;
    }
1196952
function (handle) {
        if (handle) {
            var topic = handle.topic, list = listeners[topic];
            if (list) {
                for (var i = list.length - 1; i >= 0; i--) {
                    if (list[i] === handle) {
                        list.splice(i, 1);
                    }
                }
                if (!list.length) {
                    delete listeners[topic];
                }
            }
        }
    }
1094332
def delete(self, changelist=0):
        
        cmd = ['delete']

        if changelist:
            cmd += ['-c', str(changelist)]

        cmd.append(self.depotFile)
        self._connection.run(cmd)

        self.query()
255152
def playlist_song_delete(self, playlist_song):
		

		self.playlist_songs_delete([playlist_song])

		return self.playlist(playlist_song['playlistId'], include_songs=True)