// Put registers a versioned route for the Put http method
777097
func (g *Group) Put(path string, handler context.Handler) {
	g.Handle(http.MethodPut, path, handler)
}
866761
func (s *Bucket) Put() (*PutBucketOutput, error) {
	r, x, err := s.PutRequest()

	if err != nil {
		return x, err
	}

	err = r.Send()
	if err != nil {
		return nil, err
	}

	requestID := r.HTTPResponse.Header.Get(http.CanonicalHeaderKey("X-QS-Request-ID"))
	x.RequestID = &requestID

	return x, err
}
636151
func (r *BeeResource) Put(context smolder.APIContext, data interface{}, request *restful.Request, response *restful.Response) {
	resp := BeeResponse{}
	resp.Init(context)

	pps := data.(*BeePostStruct)
	id := request.PathParameter("bee-id")
	bee := bees.GetBee(id)
	if bee == nil {
		r.NotFound(request, response)
		return
	}

	(*bee).SetDescription(pps.Bee.Description)
	(*bee).ReloadOptions(pps.Bee.Options)

	if pps.Bee.Active {
		bees.RestartBee(bee)
	} else {
		(*bee).Stop()
	}

	resp.AddBee(bee)
	resp.Send(response)
}
565506
func (c *container) Put(name string, r io.Reader, size int64, metadata map[string]interface{}) (stow.Item, error) {
	// Convert map[string]interface{} to map[string]string
	mdPrepped, err := prepMetadata(metadata)
	if err != nil {
		return nil, errors.Wrap(err, "unable to create or update item, preparing metadata")
	}

	file, err := c.bucket.UploadFile(name, mdPrepped, r)
	if err != nil {
		return nil, err
	}

	return &item{
		id:     file.ID,
		name:   file.Name,
		size:   file.ContentLength,
		bucket: c.bucket,
	}, nil
}
334685
func (s *Service) Put(apiputrequestmessage *ApiPutRequestMessage) *PutCall {
	c := &PutCall{s: s, urlParams_: make(gensupport.URLParams)}
	c.apiputrequestmessage = apiputrequestmessage
	return c
}
1004028
func (p *Putter) Put(ch chunk.Chunk) (err error) {
	return p.db.put(p.mode, chunkToItem(ch))
}
703142
func (e *Echo) Put(path string, h interface{}, m ...interface{}) {
	e.add(PUT, "", path, h, m...)
}
1107740
func (bridge *Bridge) Put(path string, params interface{}) ([]byte, io.Reader, error) {
	uri := fmt.Sprintf("http://" + bridge.IPAddress + path)
	client := &http.Client{Timeout: time.Second * 5}

	data, err := json.Marshal(params)
	if err != nil {
		err = errors.New("unable to marshal PUT request interface")
		return []byte{}, nil, err
	}
	//fmt.Println("\n\nPARAMS: ", params)

	request, _ := http.NewRequest("PUT", uri, bytes.NewReader(data))
	resp, err := client.Do(request)
	if err != nil {
		err = errors.New("unable to access bridge")
		return []byte{}, nil, err
	}
	return HandleResponse(resp)
}
1264922
func (g *Group) PUT(path string, h HandlerFunc, m ...MiddlewareFunc) *Route {
	return g.Add(http.MethodPut, path, h, m...)
}
633727
func (s *Server) Put(path string, h HandlerFunc, opts ...HandlerOption) {
	s.register(http.MethodPut, path, h, opts...)
}
180995
func (ng *etcdv3AutoCertCache) Put(ctx context.Context, rawKey string, data []byte) error {
	key := ng.normalize(rawKey)
	_, err := ng.client.Put(ctx, key, string(data))
	return err
}
271294
func (s *Sling) Put(pathURL string) *Sling {
	s.method = "PUT"
	return s.Path(pathURL)
}
1251221
func (r *Router) Put(pattern string, handlers ...Middleware) *Router {
	return r.Handle(http.MethodPut, pattern, handlers...)
}
467426
func (f *Request) Put(url string) *Request {
	f.Url(url).Method("PUT")
	return f
}
758479
func (w *MockSafePointKV) Put(k string, v string) error {
	w.mockLock.Lock()
	defer w.mockLock.Unlock()
	w.store[k] = v
	return nil
}
18215
func (e *Expect) PUT(path string, pathargs ...interface{}) *Request {
	return e.Request("PUT", path, pathargs...)
}
522644
func (r *router) PUT(path string, handler Route) {
	r.group.PUT(path, handler)
}