// Postings returns the postings list iterator for the label pair.
554354
func (h *headIndexReader) Postings(name, value string) (index.Postings, error) {
	return h.head.postings.Get(name, value), nil
}
996664
func (post *UserPost) Revisions() (modifications []string) {
	Db().Model(UserPostRevision{}).Where(&UserPostRevision{Hpid: post.ID()}).Pluck("message", &modifications)
	return
}
689761
func (s *Service) Post(ctx context.Context, v interface{}, path string, body interface{}) error {
	return s.Do(ctx, v, "POST", path, body, nil, nil)
}
165676
func (a *Client) PostLookups(params *PostLookupsParams, authInfo runtime.ClientAuthInfoWriter) (*PostLookupsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostLookupsParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "PostLookups",
		Method:             "POST",
		PathPattern:        "/lookups",
		ProducesMediaTypes: []string{"application/json", "application/x-gzip"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http", "https"},
		Params:             params,
		Reader:             &PostLookupsReader{formats: a.formats},
		AuthInfo:           authInfo,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PostLookupsOK), nil
}
679809
func (c *Client) Post(url string, bodyType string, body io.Reader) (resp *http.Response, err error) {
	return c.pester(params{method: "Post", url: url, bodyType: bodyType, body: body, verb: "POST"})
}
959464
func (r *Reader) LabelNames() ([]string, error) {
	labelNamesMap := make(map[string]struct{}, len(r.labels))
	for key := range r.labels {
		// 'key' contains the label names concatenated with the
		// delimiter 'labelNameSeperator'.
		names := strings.Split(key, labelNameSeperator)
		for _, name := range names {
			if name == allPostingsKey.Name {
				// This is not from any metric.
				// It is basically an empty label name.
				continue
			}
			labelNamesMap[name] = struct{}{}
		}
	}
	labelNames := make([]string, 0, len(labelNamesMap))
	for name := range labelNamesMap {
		labelNames = append(labelNames, name)
	}
	sort.Strings(labelNames)
	return labelNames, nil
}
817479
func (k *KeyringMembersClient) Post(ctx context.Context, member KeyringMember) error {
	keyringID := member.Member.Body.KeyringID
	members := []KeyringMember{member}
	return k.client.RoundTrip(ctx, "POST", "/keyrings/"+keyringID.String()+"/members", nil, members, nil)
}
838599
func (s *MultiTermvectorItem) Positions(positions bool) *MultiTermvectorItem {
	s.positions = &positions
	return s
}
824109
func (issue *Issue) AddLabels(doer *User, labels []*Label) error {
	if err := NewIssueLabels(issue, labels); err != nil {
		return err
	}

	issue.sendLabelUpdatedWebhook(doer)
	return nil
}
1080874
func queryPosts(client ClientInterface, path, name string, params url.Values) (*Posts, error) {
	response, err := client.GetWithParams(blogPath(path, name), params)
	if err != nil {
		return nil, err
	}
	posts := struct {
		Response Posts `json:"response"`
	}{}
	if err = json.Unmarshal(response.body, &posts); err == nil {
		posts.Response.response = response
		posts.Response.client = client
		// store
		return &posts.Response, nil
	}
	return nil, err
}
555091
func Post(message string, photos ...vkutil.Photo) (int, error) {
	api.VkApi.AccessToken = setting.VkAccessToken

	api.SetDebug(true)

	params := url.Values{}
	if len(photos) > 0 {
		att := []string{}
		for _, v := range photos {
			att = append(att, getPhotoString(v.Id, v.OwnerId))
		}
		params.Set("attachments", strings.Join(att, ","))
	}

	return api.WallPost(vkutil.OptsWallPost{
		OwnerId:   -setting.VkGroupID,
		Message:   message,
		FromGroup: true,
	}, params)
}
278046
func (F *Frisby) Post(url string) *Frisby {
	F.Method = "POST"
	F.Url = url
	return F
}
222163
func (o *GetEndpointParams) WithLabels(labels models.Labels) *GetEndpointParams {
	o.SetLabels(labels)
	return o
}
39592
func (b *BlogRef) GetPosts(params url.Values) (*Posts, error) {
	return GetPosts(b.client, b.Name, params)
}
322766
func (sem *Sem) Post() error {
	ret := int(C.SDL_SemPost(sem.cptr()))
	if ret != 0 {
		return GetError()
	}
	return nil
}
231767
func (prj *Project) Postlist(options PostlistOptions) *[]ExistingPost {
	var posts []ProjectPost
	var projectPost ProjectPost
	projectPosts := projectPost.TableName()
	users := new(User).TableName()

	query := Db().Model(projectPost).Order("hpid DESC").
		Joins("JOIN "+users+" ON "+users+".counter = "+projectPosts+".to"). //PostListOptions.Language support
		Where(`"to" = ?`, prj.ID())

	options.Model = projectPost
	query = postlistQueryBuilder(query, options)
	query.Scan(&posts)

	var retPosts []ExistingPost
	for _, p := range posts {
		projectPost := p
		retPosts = append(retPosts, ExistingPost(&projectPost))
	}

	return &retPosts
}
886579
func (c *CredentialGraphClient) Post(ctx context.Context, t *CredentialGraph) (CredentialGraph, error) {
	resp := rawGraph{}
	err := c.client.RoundTrip(ctx, "POST", "/credentialgraph", nil, t, &resp)
	if err != nil {
		return nil, err
	}

	return resp.convert()
}