//Given a QbsRestPost return a RestPost
172993
func QbsWrapPost(poster QbsRestPost, s *QbsStore) RestPost {
	return &qbsWrapped{post: poster, store: s}
}
86260
func QbsWrapPutUdid(puter QbsRestPutUdid, s *QbsStore) RestPutUdid {
	return &qbsWrappedUdid{put: puter, store: s}
}
643978
func requestToMsgPost(req *http.Request) (*dns.Msg, error) {
	defer req.Body.Close()
	return toMsg(req.Body)
}
338030
func (l *pageLexer) ignoreEscapesAndEmit(t ItemType) {
	val := bytes.Map(func(r rune) rune {
		if r == '\\' {
			return -1
		}
		return r
	}, l.input[l.start:l.pos])
	l.items = append(l.items, Item{t, l.start, val})
	l.start = l.pos
}
39592
func (b *BlogRef) GetPosts(params url.Values) (*Posts, error) {
	return GetPosts(b.client, b.Name, params)
}
860365
func Post(url string, opts Options) error {
	r, err := Request("POST", url, opts)
	if opts.Response != nil {
		*opts.Response = r
	}
	return err
}
627931
func (p *Posts) All() ([]PostInterface, error) {
	var err error = nil
	if p.parsedPosts == nil {
		r := struct {
			Response struct {
				Posts []PostInterface `json:"posts"`
			} `json:"response"`
		}{}
		r.Response.Posts = makePostsFromMinis(p.Posts, p.client)
		if err = json.Unmarshal(p.response.body, &r); err != nil {
			p.parsedPosts = []PostInterface{}
		} else {
			p.parsedPosts = r.Response.Posts
		}
	}
	return p.parsedPosts, err
}
1347865
func (c *Client) Post(fmr *FullRequest, resp interface{}, options ...RequestOptions) (err error) {
	url := buildURL(c.apiBase, fmr.Info)
	req, err := createRequest("POST", url, fmr.Payload, nil, options...)
	if err != nil {
		return err
	}

	headers := map[string]string{"Content-Type": "application/json"}
	c.Lock()
	defer c.Unlock()
	_, _, err = c.httpClient.Send(req).With(headers).Read(resp).Call()
	return err
}
131459
func (c *ContivClient) BgpPost(obj *Bgp) error {
	// build key and URL
	keyStr := obj.Hostname
	url := c.baseURL + "/api/v1/Bgps/" + keyStr + "/"

	// http post the object
	err := c.httpPost(url, obj)
	if err != nil {
		log.Debugf("Error creating Bgp %+v. Err: %v", obj, err)
		return err
	}

	return nil
}
360850
func (c *Client) GetPost(id uint64, blogName string) *tumblr.PostRef {
	return tumblr.NewPostRef(c, &tumblr.MiniPost{
		Id:       id,
		BlogName: blogName,
	})
}
1166898
func Post(url string, bodyType string, body io.Reader) (resp *http.Response, err error) {
	c := New()
	return c.Post(url, bodyType, body)
}
1316825
func (c *Client) NewSearchRequest(index, q string) *RpbSearchQueryReq {
	return &RpbSearchQueryReq{
		Q:     []byte(q),
		Index: []byte(index),
	}
}
353416
func (r *Reader) PostingsRanges() (map[labels.Label]Range, error) {
	m := map[labels.Label]Range{}

	for k, e := range r.postings {
		for v, start := range e {
			d := encoding.NewDecbufAt(r.b, int(start), castagnoliTable)
			if d.Err() != nil {
				return nil, d.Err()
			}
			m[labels.Label{Name: k, Value: v}] = Range{
				Start: int64(start) + 4,
				End:   int64(start) + 4 + int64(d.Len()),
			}
		}
	}
	return m, nil
}
958654
func Post(baseURL string, object *jsh.Object) (*jsh.Document, *http.Response, error) {
	request, err := PostRequest(baseURL, object)
	if err != nil {
		return nil, nil, err
	}

	return Do(request, jsh.ObjectMode)
}
365495
func QbsWrapAllUdid(a QbsRestAllUdid, s *QbsStore) RestAllUdid {
	return &qbsWrappedUdid{store: s, index: a, find: a, del: a, put: a, post: a}
}
524210
func Post(url string, v ...interface{}) (*Resp, error) {
	return std.Post(url, v...)
}
1333846
func QbsWrapIndex(indexer QbsRestIndex, s *QbsStore) RestIndex {
	return &qbsWrapped{index: indexer, store: s}
}