//	Since this is a non-string scalar type, sets its current value obtained from parsing the specified string.
7759
func (me *PositiveInteger) Set(s string) {
	v, _ := strconv.ParseUint(s, 0, 64)
	*me = PositiveInteger(v)
}
670422
func yaml_parser_set_input_string(parser *yaml_parser_t, input []byte) {
	if parser.read_handler != nil {
		panic("must set the input source only once")
	}
	parser.read_handler = yaml_string_read_handler
	parser.input = input
	parser.input_pos = 0
}
684254
func (ia *IntValue) Set(s string) error {
	i, err := strconv.ParseInt(s, 10, 64)
	if err != nil {
		return err
	}
	*ia = IntValue(int(i))
	return nil
}
925671
func (c *keyValueChanger) SetValue(value interface{}) (interface{}, error) {
	if c.err != nil {
		return nil, c.err
	}
	current := c.node.content.value()
	c.node.content = keyValue{c.node.content.key(), value}
	return current, nil
}
1160745
func (d *Descriptor) SetValue(b []byte) {
	if d.ReadHandler != nil {
		panic("descriptor has been configured with a read handler")
	}
	d.Property |= CharRead
	d.Value = make([]byte, len(b))
	copy(d.Value, b)
}
912247
func Set(key string, value interface{}, args ...interface{}) error {
	return std.Set(key, value, args...)
}
547042
func SetValueFromStrings(f reflect.Value, values []string) error {
	ft := f.Type()

	if ft.Kind() != reflect.Slice && len(values) == 1 {
		err := SetValueFromString(f, values[0])
		if err != nil {
			return err
		}
		return nil
	}

	switch el := ft.Elem(); el.Kind() {
	case reflect.String:
		f.Set(reflect.ValueOf(values))
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		{
			resultList := reflect.MakeSlice(ft, 0, len(values))
			for _, value := range values {
				v, err := strconv.ParseInt(value, 0, el.Bits())
				if err != nil {
					return newBadRequestf("%s is not int format", value)
				}

				resultList = reflect.Append(resultList, reflect.ValueOf(v).Convert(el))
			}
			f.Set(resultList)
		}
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
		{
			resultList := reflect.MakeSlice(ft, 0, len(values))
			for _, value := range values {
				v, err := strconv.ParseUint(value, 0, el.Bits())
				if err != nil {
					return newBadRequestf("%s is not uint format", value)
				}

				resultList = reflect.Append(resultList, reflect.ValueOf(v).Convert(el))
			}
			f.Set(resultList)
		}
	case reflect.Float32, reflect.Float64:
		{
			resultList := reflect.MakeSlice(ft, 0, len(values))
			for _, value := range values {
				v, err := strconv.ParseFloat(value, el.Bits())
				if err != nil {
					return newBadRequestf("%s is not float format", value)
				}

				resultList = reflect.Append(resultList, reflect.ValueOf(v).Convert(el))
			}
			f.Set(resultList)
		}
	case reflect.Bool:
		{
			resultList := make([]bool, 0, len(values))
			for _, value := range values {
				v, err := strconv.ParseBool(value)
				if err != nil {
					return newBadRequestf("%s is not bool format", value)
				}
				resultList = append(resultList, v)
			}
			f.Set(reflect.ValueOf(resultList))
		}
	default:
		return fmt.Errorf("unsupported format %s", el.Name())
	}

	return nil
}
840938
func (me *Double) Set(s string) {
	v, _ := strconv.ParseFloat(s, 64)
	*me = Double(v)
}
570972
func (context *BaseContext) SetString(key string, value string) {
	context.userData[key] = value
}
297233
func (m *ColonSeparatedMultimapStringString) Set(value string) error {
	if m.Multimap == nil {
		return fmt.Errorf("no target (nil pointer to map[string][]string)")
	}
	if !m.initialized || *m.Multimap == nil {
		// clear default values, or allocate if no existing map
		*m.Multimap = make(map[string][]string)
		m.initialized = true
	}
	for _, pair := range strings.Split(value, ",") {
		if len(pair) == 0 {
			continue
		}
		kv := strings.SplitN(pair, ":", 2)
		if len(kv) != 2 {
			return fmt.Errorf("malformed pair, expect string:string")
		}
		k := strings.TrimSpace(kv[0])
		v := strings.TrimSpace(kv[1])
		(*m.Multimap)[k] = append((*m.Multimap)[k], v)
	}
	return nil
}
138530
func (da *DateVar) Set(input string) error {
	t, err := dateutil.Parse(input)
	(*da) = DateVar(t)
	return err
}
393522
func (s *String) Set(val string) error {
	*s = String(val)
	return nil
}
573212
func (s *Resource) SetStringSetValue(v []*string) *Resource {
	s.StringSetValue = v
	return s
}
965155
func (s *Variable) SetStringValue(v string) *Variable {
	s.StringValue = &v
	return s
}
1074597
func (la *ListVar) Set(input string) error {
	*la = strings.Split(input, ",")
	return nil
}
538931
func (me *Int) Set(s string) {
	v, _ := strconv.ParseInt(s, 0, 32)
	*me = Int(v)
}
280965
func (f *File) SetString(in string, typ StringType) (err error) {
	s := C.CString(in)
	defer C.free(unsafe.Pointer(s))
	if C.sf_set_string(f.s, C.int(typ), s) != 0 {
		err = errors.New(C.GoString(C.sf_strerror(f.s)))
	}
	return
}