// Values returns the GroupsRenameCall object as url.Values
186144
func (c *GroupsRenameCall) Values() (url.Values, error) {
	if err := c.ValidateArgs(); err != nil {
		return nil, errors.Wrap(err, `failed validation`)
	}
	v := url.Values{}
	v.Set(`token`, c.service.token)

	v.Set("channel", c.channel)

	v.Set("name", c.name)

	if c.validate {
		v.Set("validate", "true")
	}
	return v, nil
}
143382
func (b *InsertStmt) Values(value ...interface{}) *InsertStmt {
	b.Value = append(b.Value, value)
	return b
}
464807
func (c *GroupsArchiveCall) Values() (url.Values, error) {
	if err := c.ValidateArgs(); err != nil {
		return nil, errors.Wrap(err, `failed validation`)
	}
	v := url.Values{}
	v.Set(`token`, c.service.token)

	v.Set("channel", c.channel)
	return v, nil
}
905266
func (c *AuthRevokeCall) FromValues(v url.Values) error {
	var tmp AuthRevokeCall
	if raw := strings.TrimSpace(v.Get("test")); len(raw) > 0 {
		parsed, err := strconv.ParseBool(raw)
		if err != nil {
			return errors.Wrap(err, `failed to parse boolean value "test"`)
		}
		tmp.test = parsed
	}
	*c = tmp
	return nil
}
1254077
func (m *SyncIdentityMap) Values() []interface{} {
	m.RLock()
	defer m.RUnlock()
	list := make([]interface{}, len(m.m))
	i := 0
	for _, v := range m.m {
		list[i] = v
		i++
	}
	return list
}
51712
func Values(linter *support.Linter) {
	file := "values.yaml"
	vf := filepath.Join(linter.ChartDir, file)
	fileExists := linter.RunLinterRule(support.InfoSev, file, validateValuesFileExistence(linter, vf))

	if !fileExists {
		return
	}

	linter.RunLinterRule(support.ErrorSev, file, validateValuesFile(linter, vf))
}
1359768
func (s *SampleSnapshot) Values() []int64 {
	values := make([]int64, len(s.values))
	copy(values, s.values)
	return values
}
425621
func (sm StringMap) Values() []string {
	values := []string{}
	for _, v := range sm {
		values = append(values, v)
	}
	return values
}
520639
func Values(values cty.Value) (cty.Value, error) {
	return ValuesFunc.Call([]cty.Value{values})
}
938195
func (c *UsersProfileGetCall) Values() (url.Values, error) {
	if err := c.ValidateArgs(); err != nil {
		return nil, errors.Wrap(err, `failed validation`)
	}
	v := url.Values{}
	v.Set(`token`, c.service.token)

	if c.includeLabels {
		v.Set("include_labels", "true")
	}

	if len(c.user) > 0 {
		v.Set("user", c.user)
	}
	return v, nil
}
10978
func (s *ExpDecaySample) Values() []int64 {
	s.mutex.Lock()
	defer s.mutex.Unlock()
	vals := s.values.Values()
	values := make([]int64, len(vals))
	for i, v := range vals {
		values[i] = v.v
	}
	return values
}
767921
func (om *OrdMap) Values() interface{} {
	mlen := om.Len()
	tvals := reflect.SliceOf(om.vtype)
	rvals := reflect.MakeSlice(tvals, mlen, mlen)
	for i := 0; i < mlen; i++ {
		rvals.Index(i).Set(om.m.MapIndex(om.keys.Index(i)))
	}
	return rvals.Interface()
}
1118335
func mapValues(params map[string]string) url.Values {
	values := url.Values{}
	for key, val := range params {
		values.Add(key, val)
	}
	return values
}
678634
func GetAllValues(req *http.Request) map[string]string {
	globalVars.RLock()
	values := globalVars.v[req]
	globalVars.RUnlock()
	return values
}
1269038
func (c *UsergroupsEnableCall) Values() (url.Values, error) {
	if err := c.ValidateArgs(); err != nil {
		return nil, errors.Wrap(err, `failed validation`)
	}
	v := url.Values{}
	v.Set(`token`, c.service.token)

	if c.includeCount {
		v.Set("include_count", "true")
	}

	v.Set("usergroup", c.usergroup)
	return v, nil
}
1096117
func (c *Context) Value(key fmt.Stringer) interface{} {
	value := c.values[key]
	return value
}
202404
func (v Map) Values() List {
	var valueList List
	for _, value := range v {
		valueList = append(valueList, value)
	}
	return valueList
}