/*
GetChatMembersCount returns the number of members in chat
*/
171379
func (c *Client) GetChatMembersCount(chatID string) (int, error) {
	req := url.Values{}
	req.Set("chat_id", chatID)
	var count int
	err := c.doRequest("getChatMembersCount", req, &count)
	return count, err
}
286582
func (c *Client) GetChatMember(chatID string, userID int) (*ChatMember, error) {
	req := url.Values{}
	req.Set("chat_id", chatID)
	req.Set("user_id", fmt.Sprint(userID))
	member := &ChatMember{}
	err := c.doRequest("getChatMember", req, member)
	return member, err
}
851881
func (s *TeamsService) GetTeamMembership(ctx context.Context, team int64, user string) (*Membership, *Response, error) {
	u := fmt.Sprintf("teams/%v/memberships/%v", team, user)
	req, err := s.client.NewRequest("GET", u, nil)
	if err != nil {
		return nil, nil, err
	}

	req.Header.Set("Accept", mediaTypeNestedTeamsPreview)

	t := new(Membership)
	resp, err := s.client.Do(ctx, req, t)
	if err != nil {
		return nil, resp, err
	}

	return t, resp, nil
}
78322
func (b *Bslack) getUsersInConversation(channelID string) ([]string, error) {
	channelMembers := []string{}
	for {
		queryParams := &slack.GetUsersInConversationParameters{
			ChannelID: channelID,
		}

		members, nextCursor, err := b.sc.GetUsersInConversation(queryParams)
		if err != nil {
			if err = handleRateLimit(b.Log, err); err != nil {
				return channelMembers, fmt.Errorf("Could not retrieve users in channels: %#v", err)
			}
			continue
		}

		channelMembers = append(channelMembers, members...)

		if nextCursor == "" {
			break
		}
		queryParams.Cursor = nextCursor
	}
	return channelMembers, nil
}
1363496
func (o *Organization) GetMembers(args Arguments) (members []*Member, err error) {
	path := fmt.Sprintf("organizations/%s/members", o.ID)
	err = o.client.Get(path, args, &members)
	for i := range members {
		members[i].client = o.client
	}
	return
}
1355079
func (v *EchoRequest) GetCount() (o int16) {
	if v != nil {
		o = v.Count
	}
	return
}
278280
func (c *Commit) GetCommentCount() int {
	if c == nil || c.CommentCount == nil {
		return 0
	}
	return *c.CommentCount
}
97717
func (m *memberlist) CountMembers(predicates ...MemberPredicate) int {
	count := 0

	m.members.RLock()
	for _, member := range m.members.list {
		if MemberMatchesPredicates(*member, predicates...) {
			count++
		}
	}
	m.members.RUnlock()

	return count
}
1244796
func (m *memberlist) NumPingableMembers() (n int) {
	m.members.RLock()
	for _, member := range m.members.list {
		if m.Pingable(*member) {
			n++
		}
	}
	m.members.RUnlock()

	return n
}
463607
func (r *Repository) GetNetworkCount() int {
	if r == nil || r.NetworkCount == nil {
		return 0
	}
	return *r.NetworkCount
}
1075485
public void getMemberCount(AVIMConversationMemberCountCallback callback) {
    if (StringUtil.isEmpty(getConversationId())) {
      if (null != callback) {
        callback.internalDone(new AVException(AVException.INVALID_QUERY, "ConversationId is empty"));
      } else {
        LOGGER.w("ConversationId is empty");
      }
      return;
    }
    InternalConfiguration.getOperationTube().processMembers(client.getClientId(), conversationId, getType(), null,
            Conversation.AVIMOperation.CONVERSATION_MEMBER_COUNT_QUERY, callback);
  }
1068791
func (bot *BotAPI) UnbanChatMember(config ChatMemberConfig) (APIResponse, error) {
	v := url.Values{}

	if config.SuperGroupUsername != "" {
		v.Add("chat_id", config.SuperGroupUsername)
	} else if config.ChannelUsername != "" {
		v.Add("chat_id", config.ChannelUsername)
	} else {
		v.Add("chat_id", strconv.FormatInt(config.ChatID, 10))
	}
	v.Add("user_id", strconv.Itoa(config.UserID))

	bot.debugLog("unbanChatMember", v, nil)

	return bot.MakeRequest("unbanChatMember", v)
}
842883
func (mf *membershipFilter) GetMembership() []discovery.NetworkMember {
	if mf.hasLeftChannel() {
		return nil
	}

	var members []discovery.NetworkMember
	for _, mem := range mf.adapter.GetMembership() {
		if mf.eligibleForChannelAndSameOrg(mem) {
			members = append(members, mem)
		}
	}
	return members
}
1092247
def get_chat_members_count(self, *args, **kwargs):
        """"""
        return get_chat_members_count(*args, **self._merge_overrides(**kwargs)).run()
277577
func (rpc *EthRPC) EthGetTransactionCount(address, block string) (int, error) {
	var response string

	if err := rpc.call("eth_getTransactionCount", &response, address, block); err != nil {
		return 0, err
	}

	return ParseInt(response)
}
211344
func (rp *Ringpop) CountReachableMembers(predicates ...swim.MemberPredicate) (int, error) {
	if !rp.Ready() {
		return 0, ErrNotBootstrapped
	}
	return rp.node.CountReachableMembers(predicates...), nil
}
1149158
func (mg *MailgunImpl) GetMember(ctx context.Context, s, l string) (Member, error) {
	r := newHTTPRequest(generateMemberApiUrl(mg, listsEndpoint, l) + "/" + s)
	r.setClient(mg.Client())
	r.setBasicAuth(basicAuthUser, mg.APIKey())
	response, err := makeGetRequest(ctx, r)
	if err != nil {
		return Member{}, err
	}
	var resp memberResponse
	err = response.parseFromJSON(&resp)
	return resp.Member, err
}