// values returns a url.Values representation of VideoConfig.
972753
func (config VideoConfig) values() (url.Values, error) {
	v, err := config.BaseChat.values()
	if err != nil {
		return v, err
	}

	v.Add(config.name(), config.FileID)
	if config.Duration != 0 {
		v.Add("duration", strconv.Itoa(config.Duration))
	}
	if config.Caption != "" {
		v.Add("caption", config.Caption)
		if config.ParseMode != "" {
			v.Add("parse_mode", config.ParseMode)
		}
	}

	return v, nil
}
397594
func (s *SinkYARPCServer) Values() []string {
	s.RLock()
	values := make([]string, len(s.values))
	copy(values, s.values)
	s.RUnlock()
	return values
}
1070036
func (me Notation) Values() (list []Qname) {
	spl := ListValues(string(me))
	list = make([]Qname, len(spl))
	for i, s := range spl {
		list[i].Set(s)
	}
	return
}
786706
func (config VideoNoteConfig) params() (map[string]string, error) {
	params, _ := config.BaseFile.params()

	if config.Length != 0 {
		params["length"] = strconv.Itoa(config.Length)
	}
	if config.Duration != 0 {
		params["duration"] = strconv.Itoa(config.Duration)
	}

	return params, nil
}
887667
func (lcs *lcs) Values() (values []interface{}) {
	values, _ = lcs.ValuesContext(context.Background())
	return values
}
469154
func (config ForwardConfig) values() (url.Values, error) {
	v, err := config.BaseChat.values()
	if err != nil {
		return v, err
	}
	v.Add("from_chat_id", strconv.FormatInt(config.FromChatID, 10))
	v.Add("message_id", strconv.Itoa(config.MessageID))
	return v, nil
}
808403
func (i *Interpolater) Values(
	scope *InterpolationScope,
	vars map[string]config.InterpolatedVariable) (map[string]ast.Variable, error) {
	return nil, fmt.Errorf("type Interpolator is no longer supported; use the evaluator API instead")
}
1076904
func (t *CommonThread) ReturnValues(cfg LoadConfig) []*Variable {
	loadValues(t.returnValues, cfg)
	return t.returnValues
}
666523
func (v Vars) Value() (driver.Value, error) {
	m := make(map[string]sql.NullString)

	for k, v := range v {
		m[string(k)] = sql.NullString{
			Valid:  true,
			String: *v,
		}
	}

	h := hstore.Hstore{
		Map: m,
	}

	return h.Value()
}
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()
}
803112
func Values(name string, values ...Value) Options {
	return group{
		name:   name,
		values: values,
	}
}
127453
func (m Metadata) Values() []string {
	values := make([]string, len(m))
	var i int
	for _, value := range m {
		values[i] = value
		i += 1
	}
	return values
}
971749
func (d *Database) Values(src interface{}, includePk bool) ([]interface{}, error) {
	columns, err := d.Columns(src, includePk)
	if err != nil {
		return nil, err
	}
	return d.SomeValues(src, columns)
}
147786
func (c *ChatPostMessageCall) 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.asUser {
		v.Set("as_user", "true")
	}

	if len(c.attachments) > 0 {
		attachmentsEncoded, err := c.attachments.Encode()
		if err != nil {
			return nil, errors.Wrap(err, `failed to encode field`)
		}
		v.Set("attachments", attachmentsEncoded)
	}

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

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

	if len(c.iconEmoji) > 0 {
		v.Set("iconEmoji", c.iconEmoji)
	}

	if len(c.iconURL) > 0 {
		v.Set("iconURL", c.iconURL)
	}

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

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

	if len(c.parse) > 0 {
		v.Set("parse", c.parse)
	}

	if len(c.text) > 0 {
		v.Set("text", c.text)
	}

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

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

	if len(c.username) > 0 {
		v.Set("username", c.username)
	}
	return v, nil
}
137662
func (qb *MySQLQueryBuilder) Values(vals ...string) QueryBuilder {
	valsStr := strings.Join(vals, CommaSpace)
	qb.Tokens = append(qb.Tokens, "VALUES", "(", valsStr, ")")
	return qb
}
147598
func (f *Flash) Values(key string) []interface{} {
	if !f.Has(key) {
		return []interface{}{}
	}

	f.changed = true
	r := f.v[key]
	delete(f.v, key)
	return r
}
666775
func (c *UsersListCall) 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.includeLocale {
		v.Set("include_locale", "true")
	}

	if c.limit > 0 {
		v.Set("limit", strconv.Itoa(c.limit))
	}

	if c.presence {
		v.Set("presence", "true")
	}
	return v, nil
}