remove members from chat room

@param roomId  chat room id
@param members {@link Members}
@return No content
@throws APIConnectionException connect exception
@throws APIRequestException    request exception
320191
public ResponseWrapper removeChatRoomMembers(long roomId, Members members)
            throws APIConnectionException, APIRequestException {
        return _chatRoomClient.removeChatRoomMembers(roomId, members);
    }
451753
public Response deleteOwner(String roomName, String jid) {
		return restClient.delete("chatrooms/" + roomName + "/owners/" + jid,
				new HashMap<String, String>());
	}
989547
public void removeMember(JSConsumerKey key)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "removeMember", key);

    LocalQPConsumerKey anyKey = null;

    // We lock the CD so other members are not added/removed while
    // we do this
    synchronized(consumerDispatcher.getDestination().getReadyConsumerPointLock())
    {
      if(singleMember != null)
      {
        if(!(key.isSpecific()))
          generalMemberCount--;

        if(singleMember == key)
          singleMember = null;
        else
        {
          // We must be the only member
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "removeMember", "SIErrorException");
            throw new SIErrorException(
              nls.getFormattedMessage(
                "INTERNAL_MESSAGING_ERROR_CWSIP0001",
                new Object[] {
                  "com.ibm.ws.sib.processor.impl.LocalQPConsumerKeyGroup",
                  "1:453:1.6.1.14" },
                null));
        }
      }
      else
      {
        if(key.isSpecific())
          specificKeyMembers.remove(key);
        else
        {
          generalKeyMembers.remove(key);
          generalMemberCount--;
          // As we've modified the list we need a new iterator
          generalMemberIndex = 0;
        }
      }

      memberCount--;

      // If that was the last member, we can remove this group
      if(memberCount == 0)
      {
        consumerDispatcher.removeKeyGroup(this);
        // Drive finished against the set of cursors
        
        if(classifyingMessages)
        {
          // Take the classifications read lock
          consumerSet.takeClassificationReadLock();
          
          int numFilters = consumerKeyFilter.length;    
          for(int i=0;i<numFilters;i++)
            consumerKeyFilter[i].detach(); 

          // Free the classifications read lock
          consumerSet.freeClassificationReadLock();          
        }
        else
        {
          consumerKeyFilter[0].detach();  
        }
      }
      // If all the remaining members are started we can start receiving
      // messages again (we couldn't have been before because the member
      // was in stopped state.
      else if(memberCount == startedCount)
      {
        if(generalMemberCount > 0)
          anyKey = generalKeyMembers.get(0);
        else
          anyKey = specificKeyMembers.get(0);
      }
    } // synchronized

    //  Start the member up
    if(anyKey!=null)
      anyKey.getConsumerPoint().checkForMessages();

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "removeMember");
  }
77845
def channels_delete(self, room_id=None, channel=None, **kwargs):
        """"""
        if room_id:
            return self.__call_api_post('channels.delete', roomId=room_id, kwargs=kwargs)
        elif channel:
            return self.__call_api_post('channels.delete', roomName=channel, kwargs=kwargs)
        else:
            raise RocketMissingParamException('roomId or channel required')
382702
void removeMember(MemberImpl member) {
        heartbeatFailureDetector.remove(member);
        if (icmpParallelMode) {
            icmpFailureDetector.remove(member);
        }
    }
553130
public ResponseWrapper addChatRoomMember(long roomId, Members members)
            throws APIConnectionException, APIRequestException {
        return _chatRoomClient.addChatRoomMember(roomId, members);
    }
459187
public ChatRoomMemberList getChatRoomMembers(long roomId, int start, int count)
            throws APIConnectionException, APIRequestException {
        Preconditions.checkArgument(roomId > 0, "room id is invalid");
        Preconditions.checkArgument(start >= 0 && count > 0, "Illegal argument");
        ResponseWrapper responseWrapper = _httpClient.sendGet(_baseUrl + mChatRoomPath + "/" + roomId + "/members"
                + "?start=" + start + "&count=" + count);
        return ChatRoomMemberList.fromResponse(responseWrapper, ChatRoomMemberList.class);
    }
609862
public void removeMember (FormationMember<T> member) {
		// Find the member's slot
		int slot = findMemberSlot(member);

		// Make sure we've found a valid result
		if (slot >= 0) {
			// Remove the slot
			// slotAssignments.removeIndex(slot);
			slotAssignmentStrategy.removeSlotAssignment(slotAssignments, slot);

			// Update the assignments
			updateSlotAssignments();
		}
	}
944590
public synchronized void removeMember(BalancerMember member) {
        if (members.remove(member)) {
            logger.info("Removing balancer member '{}' from balancer '{}'", member.getName(), name);
        }
    }
487322
public static Single<Long> remove(String key, Object member) {
        return remove(CacheService.CACHE_CONFIG_BEAN, key, member);
    }
54505
def remove_member(self, member, api=None):
        
        api = api or self._API
        username = Transform.to_member(member)

        api.delete(
            url=self._URL['member'].format(
                id=self.id,
                username=username
            )
        )
362372
public ChatRoomMemberList getChatRoomMembers(long roomId, int start, int count)
            throws APIConnectionException, APIRequestException {
        return _chatRoomClient.getChatRoomMembers(roomId, start, count);
    }
187772
private void fireMemberRemoved(MemberId exMember) {
        GL.debug(GL.CLUSTER_LOGGER_NAME, "Firing member removed for: {}", exMember);
        for (MembershipEventListener listener : membershipEventListeners) {
            try {
                listener.memberRemoved(exMember);
            } catch (Throwable e) {
                GL.error(GL.CLUSTER_LOGGER_NAME, "Error in member removed event {}", e);
            }
        }
    }
599826
public Response deleteAdmin(String roomName, String jid) {
		return restClient.delete("chatrooms/" + roomName + "/admins/" + jid,
				new HashMap<String, String>());
	}
1142371
def remove_member(self, member_id):
        
        member_rm_request = etcdrpc.MemberRemoveRequest(ID=member_id)
        self.clusterstub.MemberRemove(
            member_rm_request,
            self.timeout,
            credentials=self.call_credentials,
            metadata=self.metadata
        )
308342
public Response deleteMemberGroup(String roomName, String groupName) {
        return restClient.delete("chatrooms/" + roomName + "/members/group/" + groupName,
                new HashMap<String, String>());
    }
901926
public void deleteGroupMember(Integer groupId, Integer userId) throws IOException {
        String tailUrl = GitlabGroup.URL + "/" + groupId + "/" + GitlabGroupMember.URL + "/" + userId;
        retrieve().method(DELETE).to(tailUrl, Void.class);
    }