// PutParams returns a map of parameters for a TCPCheck that can be sent along
// with an HTTP PUT request.
510707
func (ck *TCPCheck) PutParams() map[string]string {
	m := map[string]string{
		"name":             ck.Name,
		"host":             ck.Hostname,
		"resolution":       strconv.Itoa(ck.Resolution),
		"paused":           strconv.FormatBool(ck.Paused),
		"notifyagainevery": strconv.Itoa(ck.NotifyAgainEvery),
		"notifywhenbackup": strconv.FormatBool(ck.NotifyWhenBackup),
		"integrationids":   intListToCDString(ck.IntegrationIds),
		"probe_filters":    ck.ProbeFilters,
		"tags":             ck.Tags,
		"userids":          intListToCDString(ck.UserIds),
		"teamids":          intListToCDString(ck.TeamIds),
		"port":             strconv.Itoa(ck.Port),
	}

	if ck.SendNotificationWhenDown != 0 {
		m["sendnotificationwhendown"] = strconv.Itoa(ck.SendNotificationWhenDown)
	}

	if ck.StringToSend != "" {
		m["stringtosend"] = ck.StringToSend
	}

	if ck.StringToExpect != "" {
		m["stringtoexpect"] = ck.StringToExpect
	}

	return m
}
975573
func (c *Client) Put(endpoint string) (tumblr.Response, error) {
	return c.PutWithParams(endpoint, url.Values{})
}
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)
}
1302785
func (G *global_data) SetParams(params map[string]string) *global_data {
	if G.Req.Params == nil {
		G.Req.Params = make(map[string]string)
	}
	for key, value := range params {
		G.Req.Params[key] = value
	}
	return G
}
1018221
func (m *MockIndex) Put(arg0 string, arg1 interface{}) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Put", arg0, arg1)
}
1367100
func (r *Report) AddParam(k string, v interface{}) {
	r.Request.Params[k] = v
}
866196
func (m *HashMap) PutQuiet(key []byte, val interface{}) {
	m.put(key, val, false)
}
373795
func (r *Route) Put(handler http.Handler) *Route {
	r.handlers[http.MethodPut] = handler
	return r
}
218714
func (u *User) PutParams() map[string]string {
	m := map[string]string{
		"name": u.Username,
	}

	if u.Primary != "" {
		m["primary"] = u.Primary
	}

	if u.Paused != "" {
		m["paused"] = u.Paused
	}

	return m
}
67810
func (m *MockRCHTTPClienter) Put(arg0 context.Context, arg1, arg2 string, arg3 io.Reader) (*http.Response, error) {
	ret := m.ctrl.Call(m, "Put", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(*http.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
811705
func Params(r *http.Request) map[string]string {
	v := r.Context().Value(routeParamsID)
	if v == nil {
		return map[string]string{}
	}
	if v, ok := v.(map[string]string); ok {
		return v
	}
	return map[string]string{}
}
305670
func (m *Mux) Put(pattern string, handler http.HandlerFunc) {
	m.Handle(http.MethodPut, pattern, handler)
}
1123243
func (h HashedUpdateBatch) Put(ns, coll string, key []byte, value []byte, version *version.Height) {
	h.PutValHashAndMetadata(ns, coll, key, value, nil, version)
}
1020385
func (cmd *CLI) Params() values.Map {
	params := make(values.Map)
	for param, value := range cmd.paramValues {
		params[param.Name] = value
	}
	return params
}
177296
func Params(req *http.Request) httprouter.Params {
	if value, ok := httpcontext.GetOk(req, paramsKey); ok {
		if params, ok := value.(httprouter.Params); ok {
			return params
		}
	}
	return httprouter.Params{}
}
1156424
func (node *ClientNode) UpdateParams(params ServerParams) {
	node.lock.Lock()
	defer node.lock.Unlock()

	now := node.cm.clock.Now()
	node.update(now)
	if params.MinRecharge >= node.params.MinRecharge {
		node.updateSchedule = nil
		node.updateParams(params, now)
	} else {
		for i, s := range node.updateSchedule {
			if params.MinRecharge >= s.params.MinRecharge {
				s.params = params
				node.updateSchedule = node.updateSchedule[:i+1]
				return
			}
		}
		node.updateSchedule = append(node.updateSchedule, scheduledUpdate{time: now + mclock.AbsTime(DecParamDelay), params: params})
	}
}
957103
func (p *protoSyncPublisherKafka) Put(key string, message proto.Message, opts ...datasync.PutOption) error {
	_, err := p.conn.sendSyncMessage(p.topic, DefPartition, key, message, false)
	return err
}