// OKFull sends a HTTP response with status code 200.
510116
func (ctx *ShowBottleContext) OKFull(r *BottleFull) error {
	if ctx.ResponseData.Header().Get("Content-Type") == "" {
		ctx.ResponseData.Header().Set("Content-Type", "application/vnd.bottle+json")
	}
	return ctx.ResponseData.Service.Send(ctx.Context, 200, r)
}
1122917
func (c *UserController) SayHelloWorld() {
	c.Ctx.ResponseWriter.Status = 200
	c.Ctx.ResponseWriter.Write([]byte("Hello, World"))
}
289603
func (c *ConfigFile) Bool(section, key string) (bool, error) {
	value, err := c.GetValue(section, key)
	if err != nil {
		return false, err
	}
	return strconv.ParseBool(value)
}
854675
func (self *Config) Bool(section string, option string) (value bool, err error) {
	sv, err := self.String(section, option)
	if err != nil {
		return false, err
	}

	value, ok := boolString[strings.ToLower(sv)]
	if !ok {
		return false, errors.New("could not parse bool value: " + sv)
	}

	return value, nil
}
312354
func (ctx *Context) OkRender(name string, val interface{}) error {
	return ctx.Render(http.StatusOK, name, val)
}
779095
func (spec MutateInSpec) RemoveFull() (*MutateInOp, error) {
	op := gocbcore.SubDocOp{
		Op:    gocbcore.SubDocOpDeleteDoc,
		Flags: gocbcore.SubdocFlag(SubdocFlagNone),
	}

	return &MutateInOp{op: op}, nil
}
80498
func (ctx *Context) OkJSON(val interface{}) error {
	return ctx.JSON(http.StatusOK, val)
}
1160453
func CheckResponse(r *http.Response) error {
	if c := r.StatusCode; 200 <= c && c <= 299 {
		return nil
	}
	errorResponse := &ErrorResponse{Response: r}
	data, err := ioutil.ReadAll(r.Body)
	if err == nil && data != nil {
		json.Unmarshal(data, errorResponse)
	}
	return errorResponse
}
86246
func (s *Status) Err() error {
	if s.Code() == codes.OK {
		return nil
	}
	return (*statusError)(s.s)
}
96727
func NotImplemented(w http.ResponseWriter, response interface{}) {
	Respond(w, http.StatusNotImplemented, response)
}
1314532
func (rp *Reply) OKValue() error {
	if rp.Type == ErrorReply {
		return errors.New(rp.Error)
	}
	if rp.Type != StatusReply {
		return errors.New("invalid reply type, not status")
	}
	if rp.Status == "OK" {
		return nil
	}
	return errors.New(rp.Status)
}
1194863
func (m MessageUnboxed) IsValidFull() bool {
	if !m.IsValid() {
		return false
	}
	valid := m.Valid()
	headerType := valid.ClientHeader.MessageType
	switch headerType {
	case MessageType_NONE:
		return false
	case MessageType_TLFNAME:
		// Skip body check
		return true
	}
	bodyType, err := valid.MessageBody.MessageType()
	if err != nil {
		return false
	}
	return bodyType == headerType
}
110358
func (s *Client) CheckServerFinal(sfinal []byte) error {
	b64ver, err := extractParameter(sfinal, 'v')
	if err != nil {
		return err
	}

	verification, err := base64.StdEncoding.DecodeString(string(b64ver))
	if err != nil {
		return err
	}

	if !bytes.Equal(s.verification(), verification) {
		return WrongServerMessage("Wrong verification provided")
	}
	return nil
}
245147
func (c PublicClient) ListFull(patterns ...string) ([]payload.FullPayloadInfo, error) {
	var result params.PayloadListResults

	args := params.PayloadListArgs{
		Patterns: patterns,
	}
	if err := c.FacadeCall("List", &args, &result); err != nil {
		return nil, errors.Trace(err)
	}

	payloads := make([]payload.FullPayloadInfo, len(result.Results))
	for i, apiInfo := range result.Results {
		payload, err := api.API2Payload(apiInfo)
		if err != nil {
			// We should never see this happen; we control the input safely.
			return nil, errors.Trace(err)
		}
		payloads[i] = payload
	}
	return payloads, nil
}
163918
func (ctx *HealthHealthContext) OK(resp []byte) error {
	if ctx.ResponseData.Header().Get("Content-Type") == "" {
		ctx.ResponseData.Header().Set("Content-Type", "text/plain")
	}
	ctx.ResponseData.WriteHeader(200)
	_, err := ctx.ResponseData.Write(resp)
	return err
}
699498
func (b *Buffer) IsFull() bool {
	return (b.end+1)%b.size == b.start
}
248365
func (r *Response) Rels() (hypermedia.Relations, bool) {
	if r.rels != nil {
		return r.rels, true
	}
	return nil, false
}