Removes a User from all Channels from the ChannelList.
 Returning a Set of Channels in which the User was.
2935
def remove_user(nick)
      @mutex.synchronize do
        channels = Set.new

        @channels.each do |channel|
          if channel.remove_user(nick)
            channels << channel
          end
        end

        channels
      end
    end
1136982
def remove_list_members(self, screen_name=None, user_id=None, slug=None,
                            list_id=None, owner_id=None, owner_screen_name=None):
        
        return self._remove_list_members(list_to_csv(screen_name),
                                         list_to_csv(user_id),
                                         slug, list_id, owner_id,
                                         owner_screen_name)
1010493
def delete_channel_cb(self, gshell, chinfo):
        """"""
        chname = chinfo.name

        if chname not in self.name_dict:
            return

        del self.name_dict[chname]
        self.logger.debug('{0} removed from ChangeHistory'.format(chname))

        if not self.gui_up:
            return False

        self.clear_selected_history()
        self.recreate_toc()
70153
private User removeUser(Session session, String userName, boolean broadcast) throws Exception
   {
      Node userNode = utils.getUserNode(session, userName);
      User user = readUser(userNode);

      if (broadcast)
      {
         preDelete(user);
      }

      removeMemberships(userNode, broadcast);

      userNode.remove();
      session.save();

      removeFromCache(userName);
      removeAllRelatedFromCache(userName);

      if (broadcast)
      {
         postDelete(user);
      }

      return user;
   }
340581
def finish(request, socket, context):
    
    try:
        user = context["user"]
    except KeyError:
        return
    left = {"action": "leave", "name": user.name, "id": user.id}
    socket.broadcast_channel(left)
    user.delete()
1269382
def clear_uservars(self, user=None):
        

        if user is None:
            # All the users!
            self._session.reset_all()
        else:
            # Just this one.
            self._session.reset(user)
1154173
def remove_user(self, name):
        
        user = self.get_user(name)
        users = self.get_users()
        users.remove(user)
1330933
function Session_delChannel(channel) {
  var index = this.channels.indexOf(channel)
  if (-1 == index) return

  this.channels.splice(index, 1)
}
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
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);
        }
    }
73861
def channels_remove_moderator(self, room_id, user_id, **kwargs):
        """"""
        return self.__call_api_post('channels.removeModerator', roomId=room_id, userId=user_id, kwargs=kwargs)
58585
def disconnect(self, user):
        
        self.remove_user(user)
        self.send_message(create_message('RoomServer', 'Please all say goodbye to {name}!'.format(name=user.id.name)))
        self.send_message(create_disconnect(user.id.name))
50464
def _remove(client)
      return unless @clients.include? client
      channel = @clients.delete(client)
      debug { "Removing #{client} from #{channel}." }
      @channels[channel] -= 1
      @channels.delete(channel) if @channels[channel].zero?
    end
1277908
def remove_user(self, user):
        
        org_user = self._org_user_model.objects.get(user=user, organization=self)
        org_user.delete()

        # User removed signal
        user_removed.send(sender=self, user=user)
265633
public void removeMember(User user) {
        long userId = user.getId();
        members.remove(userId);
        nicknames.remove(userId);
        selfMuted.remove(userId);
        selfDeafened.remove(userId);
        muted.remove(userId);
        deafened.remove(userId);
        getRoles().forEach(role -> ((RoleImpl) role).removeUserFromCache(user));
        joinedAtTimestamps.remove(userId);
    }
374357
def delete_channel(data)
      channel = Channel.new(data, self)
      server = channel.server

      # Handle normal and private channels separately
      if server
        @channels.delete(channel.id)
        server.delete_channel(channel.id)
      elsif channel.pm?
        @pm_channels.delete(channel.recipient.id)
      elsif channel.group?
        @channels.delete(channel.id)
      end
    end
187322
function clear() {
        if($this !== $this->client->channels) {
            foreach($this->data as $key => $val) {
                $this->client->channels->delete($key);
                unset($val);
            }
        }
        
        parent::clear();
        return $this;
    }