Removes a Channel from the ChannelList.
774930
def remove(channel_or_channel_name)
      @mutex.synchronize do
        if channel_or_channel_name.is_a?(String)
          channel_or_channel_name = find(channel_or_channel_name)
        end
 
        @channels.delete(channel_or_channel_name)
      end
    end
926982
@Handler(channels = Channel.class)
    public void discard(DiscardSession event) {
        removeSession(event.session().id());
    }
458092
def _cleanup_channel(self, channel_id):
        
        with self.lock:
            if channel_id not in self._channels:
                return
            del self._channels[channel_id]
1329612
def unsubscribe(self, channel_name):
        
        if channel_name in self.channels:
            self.connection.send_event(
                'pusher:unsubscribe', {
                    'channel': channel_name,
                }
            )
            del self.channels[channel_name]
1266017
def __unregister_driver(self, channel):
        ""
        driver = self.__get_driver_for_channel(channel)

        if self.__registered_drivers.has_key(channel) \
                and driver in self.__registered_drivers[channel]:

            self.__registered_drivers[channel].remove(driver)

        self.__webdriver[channel] = None
875617
function(client, subscriptions, channel, callback, done_callback) {
    if (subscriptions[channel]===undefined)
        return;
    subscriptions[channel].splice(subscriptions[channel].indexOf(callback), 1);
    if (subscriptions[channel].length===0) {
        delete subscriptions[channel];
        client.unsubscribe(channel, function() {
            // If there is a done_callback defined, execute it
            if (done_callback!==undefined) done_callback();
        });
    }
}
1223927
public void destroy() {
        this.existingChannels.clear();
        this.existingChannels = null;
        try {
            this.vcFactory.destroy();
        } catch (Exception e) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
                Tr.event(this, tc, "Error disconnecting from vc factory; " + e);
            }
        }
        this.vcFactory = null;
    }
34593
public synchronized void removeProtocol(String productString, ChannelListener<? super StreamConnection> openListener) {
        List<Holder> holders = handlers.get(productString);
        if (holders == null) {
            return;
        }
        Iterator<Holder> it = holders.iterator();
        while (it.hasNext()) {
            Holder holder = it.next();
            if (holder.channelListener == openListener) {
                holders.remove(holder);
                break;
            }
        }
        if (holders.isEmpty()) {
            handlers.remove(productString);
        }
    }
578630
function(channelName) {
    var channel = Radio.channel(channelName);
    channel._tunedIn = false;
    channel.off('all', _partial(channelName));
    delete _logs[channelName];
    return this;
  }
1116883
@Deprecated
	public void delete(Collection<Channel.Builder> channels)
			throws ChannelFinderException {
		for (Channel.Builder channel : channels) {
			deleteChannel(channel.build().getName());
		}
	}
733056
void removeClientChannel(HttpRoute httpRoute, Http2ClientChannel http2ClientChannel) {
        EventLoopPool.PerRouteConnectionPool perRouteConnectionPool = fetchPerRoutePool(httpRoute,
                                                                                        http2ClientChannel.getChannel()
                                                                                            .eventLoop());
        if (perRouteConnectionPool != null) {
            perRouteConnectionPool.removeChannel(http2ClientChannel);
        }
    }
1268079
def channels_remove_owner(self, room_id, user_id, **kwargs):
        """"""
        return self.__call_api_post('channels.removeOwner', roomId=room_id, userId=user_id, kwargs=kwargs)
1025878
public function removeChannel($channel)
    {
        if ($channel instanceof ChannelInterface) {
            $channel = $channel->getId();
        }

        $channel = (string) $channel;

        if (false !== ($key = array_search($channel, $this->channels))) {
            unset($this->channels[$key]);
        }

        return $this;
    }
85279
def delete_channel_cb(self, viewer, channel):
        """"""
        chname_del = channel.name
        # TODO: delete thumbs for this channel!
        self.logger.debug("deleting thumbs for channel '%s'" % (chname_del))
        with self.thmblock:
            new_thumb_list = []
            un_hilite_set = set([])
            for thumbkey in self.thumb_list:
                chname = thumbkey[0]
                if chname != chname_del:
                    new_thumb_list.append(thumbkey)
                else:
                    if thumbkey in self.thumb_dict:
                        del self.thumb_dict[thumbkey]
                    un_hilite_set.add(thumbkey)

            self.thumb_list = new_thumb_list
            self._tkf_highlight -= un_hilite_set  # Unhighlight

        self.fv.gui_do_oneshot('thumbs-reorder', self.reorder_thumbs)
249429
def delete_channel(self, chname):
        """"""
        name = chname.lower()

        if len(self.channel_names) < 1:
            self.logger.error('Delete channel={0} failed. '
                              'No channels left.'.format(chname))
            return

        with self.lock:
            channel = self.channel[name]

            # Close local plugins open on this channel
            self.close_plugins(channel)

            try:
                idx = self.channel_names.index(chname)
            except ValueError:
                idx = 0

            # Update the channels control
            self.channel_names.remove(channel.name)
            self.channel_names.sort()

            self.ds.remove_tab(chname)
            del self.channel[name]
            self.prefs.remove_settings('channel_' + chname)

            # pick new channel
            num_channels = len(self.channel_names)
            if num_channels > 0:
                if idx >= num_channels:
                    idx = num_channels - 1
                self.change_channel(self.channel_names[idx])
            else:
                self.cur_channel = None

        self.make_gui_callback('delete-channel', channel)
493094
def quit(self):
        
        
        for c in self.channels:
            c.users.remove(self.nick)
        self.channels = []
1274015
public void removeChannel(
            T channel,
            String functionalityName,
            String requesterID,
            String conversationID)
    {
        synchronized (this.channelsWithId)
        {
            this.channelsWithId.remove(calculateId(functionalityName, requesterID, conversationID));
        }
        synchronized (this.channelsWithFunctionalityName)
        {
            this.channelsWithFunctionalityName.get(functionalityName).remove(channel);
        }
    }