// Set is required to set parameters from command line string
6653
func (p *IntParam) Set(s string) error {
	v, err := strconv.ParseInt(s, 0, 64)
	if err != nil {
		return err
	}
	p.val = &v
	return nil
}
853806
func (t *TeeType) Set(v string) error {
	return TeeTypeFlagEnum.FlagSet(t, v)
}
1262925
func (tags *tagList) Set(value string) error {
	err := common.ValidateInstanceTag(value)
	if err != nil {
		return commandLineError{err}
	}
	*tags = append(*tags, value)
	return nil
}
99591
func (p *Params) Set(key, value string) {
	if len(key) == 0 {
		return
	}
	if key[0] != ':' && key[0] != '*' {
		key = ":" + key
	}

	for i, v := range *p {
		if v.Name == key {
			(*p)[i].Value = value
			return
		}
	}

	*p = append(*p, param{key, value})
}
106434
func (h Handler) Set(cmd common.SetRequest) error {
	return h.handleSetCommon(cmd, common.RequestSet)
}
538931
func (me *Int) Set(s string) {
	v, _ := strconv.ParseInt(s, 0, 32)
	*me = Int(v)
}
136521
func (s *SliceStrings) Set(str string) error {
	fargs := func(c rune) bool {
		return c == ',' || c == ';'
	}
	// get function
	slice := strings.FieldsFunc(str, fargs)
	*s = append(*s, slice...)
	return nil
}
142970
func (g *Graph) Set(s string, val interface{}) *Graph {
	if g == nil {
		return nil
	}

	// Parse the input string into a Path graph.
	path := NewPath(s)

	if path == nil {
		return nil
	}
	return g.set(path, val)
}
289129
func (s *Synth) Set(ctls map[string]float32) error {
	msg := osc.Message{
		Address: setSynthNodeAddress,
		Arguments: osc.Arguments{
			osc.Int(s.ID),
		},
	}
	for name, value := range ctls {
		msg.Arguments = append(msg.Arguments, osc.String(name))
		msg.Arguments = append(msg.Arguments, osc.Float(value))
	}
	return s.client.oscConn.Send(msg)
}
1230329
func (s *StringFlag) Set(in string) error {
	s.string = &in
	return nil
}
1264458
func (i *Int64Value) Set(s string) error {
	v, err := strconv.ParseInt(s, 0, 64)
	*i = Int64Value(v)
	return err
}
1084942
func (value *StringListValue) Set(v string) error {
	*value = parseListWithEscapes(v, ',')
	return nil
}
901326
func (m *MapStringString) Set(value string) error {
	if m.Map == nil {
		return fmt.Errorf("no target (nil pointer to map[string]string)")
	}
	if !m.initialized || *m.Map == nil {
		// clear default values, or allocate if no existing map
		*m.Map = make(map[string]string)
		m.initialized = true
	}

	// account for comma-separated key-value pairs in a single invocation
	if !m.NoSplit {
		for _, s := range strings.Split(value, ",") {
			if len(s) == 0 {
				continue
			}
			arr := strings.SplitN(s, "=", 2)
			if len(arr) != 2 {
				return fmt.Errorf("malformed pair, expect string=string")
			}
			k := strings.TrimSpace(arr[0])
			v := strings.TrimSpace(arr[1])
			(*m.Map)[k] = v
		}
		return nil
	}

	// account for only one key-value pair in a single invocation
	arr := strings.SplitN(value, "=", 2)
	if len(arr) != 2 {
		return fmt.Errorf("malformed pair, expect string=string")
	}
	k := strings.TrimSpace(arr[0])
	v := strings.TrimSpace(arr[1])
	(*m.Map)[k] = v
	return nil

}
546890
func (pm PkgMap) Set(k string, v *dt.Plugin) {
	pm.mutex.Lock()
	pm.plugins[k] = v
	pm.mutex.Unlock()
	runtime.Gosched()
}
743637
func (ip *Interpreter) set(args []string) {
	ip.simpleResponder(ip.Backend.SetUserData(args[0], args[1], args[2]))
}
713246
func (v IPVar) Set(s string) error {
	if len(s) == 0 {
		v.Val = nil
		return nil
	}
	if net.ParseIP(s) == nil {
		return fmt.Errorf("%q is not a valid IP address", s)
	}
	if v.Val == nil {
		// it's okay to panic here since this is programmer error
		panic("the string pointer passed into IPVar should not be nil")
	}
	*v.Val = s
	return nil
}
1299089
func (t *Task) Set(k string, v interface{}) *Task {
	t.Params[k] = v
	return t
}