// This sets the value in a struct of an indeterminate type to the // matching value from the request (via Form middleware) in the // same type, so that not all deserialized values have to be strings. // Supported types are string, int, float, and bool. func setWithProperType(valueKind reflect.Kind, val string, structField reflect.Value, nameInTag string, errors Errors) { if scan, ok := structField.Addr().Interface().(sql.Scanner); ok { scan.Scan(val) return } switch valueKind { case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: if val == "" { val = "0" } intVal, err := strconv.ParseInt(val, 10, 64) if err != nil { errors.Add([]string{nameInTag}, TypeError, "Value could not be parsed as integer") } else { structField.SetInt(intVal) } case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: if val == "" { val = "0" } uintVal, err := strconv.ParseUint(val, 10, 64) if err != nil { errors.Add([]string{nameInTag}, TypeError, "Value could not be parsed as unsigned integer") } else { structField.SetUint(uintVal) } case reflect.Bool: if val == "" { val = "false" } boolVal, err := strconv.ParseBool(val) if err != nil { errors.Add([]string{nameInTag}, TypeError, "Value could not be parsed as boolean") } else { structField.SetBool(boolVal) } case reflect.Float32: if val == "" { val = "0.0" } floatVal, err := strconv.ParseFloat(val, 32) if err != nil { errors.Add([]string{nameInTag}, TypeError, "Value could not be parsed as 32-bit float") } else { structField.SetFloat(floatVal) } case reflect.Float64: if val == "" { val = "0.0" } floatVal, err := strconv.ParseFloat(val, 64) if err != nil { errors.Add([]string{nameInTag}, TypeError, "Value could not be parsed as 64-bit float") } else { structField.SetFloat(floatVal) } case reflect.String: structField.SetString(val) } }
func parseAndSet(target reflect.Value, val string) error { if !target.CanSet() { return fmt.Errorf("Cannot set %v to %v", target, val) } switch kind := target.Type().Kind(); kind { case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: intVal, err := strconv.ParseInt(val, 10, 64) if err == nil { target.SetInt(intVal) } return err case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: intVal, err := strconv.ParseUint(val, 10, 64) if err == nil { target.SetUint(intVal) } return err case reflect.Float32, reflect.Float64: floatVal, err := strconv.ParseFloat(val, 64) if err == nil { target.SetFloat(floatVal) } return err case reflect.String: target.SetString(val) return nil } return fmt.Errorf("Field %v has type %v, cannot set to %v", target, target.Type(), val) }
func setValue(elmv *reflect.Value, f Field) { switch f.Kind { case "int", "int64", "long": itemValue, innerr := strconv.ParseInt(f.Value, 10, 64) if innerr != nil { itemValue = 0 } elmv.SetInt(itemValue) case "float", "float64", "double": itemValue, innerr := strconv.ParseFloat(f.Value, 64) if innerr != nil { itemValue = 0 } elmv.SetFloat(itemValue) case "bool": itemValue, innerr := strconv.ParseBool(f.Value) if innerr != nil { itemValue = false } elmv.SetBool(itemValue) default: itemValue := f.Value elmv.SetString(itemValue) } }
// Fill a single reflected field if it has the conf tag. // func (c *Config) getField(elem reflect.Value, group, key string) { var e error switch elem.Interface().(type) { case bool: var val bool val, e = c.Bool(group, key) elem.SetBool(val) case int: var val int val, e = c.Int(group, key) elem.SetInt(int64(val)) case string: var val string val, e = c.String(group, key) elem.SetString(val) case float64: var val float64 val, e = c.Float(group, key) elem.SetFloat(val) default: c.logError(errors.New("Parse conf: wrong type: " + elem.Kind().String())) } if e != nil { c.logError(errors.New("Parse conf: " + e.Error())) } }
func (d *Decoder) decodeString(s *string, v reflect.Value, fieldTag tag) error { if fieldTag.AsString { return d.decodeNumber(s, v) } // To maintain backwards compatibility with ConvertFrom family of methods which // converted strings to time.Time structs if _, ok := v.Interface().(time.Time); ok { t, err := time.Parse(time.RFC3339, *s) if err != nil { return err } v.Set(reflect.ValueOf(t)) return nil } switch v.Kind() { case reflect.String: v.SetString(*s) case reflect.Interface: // Ensure type aliasing is handled properly v.Set(reflect.ValueOf(*s).Convert(v.Type())) default: return &UnmarshalTypeError{Value: "string", Type: v.Type()} } return nil }
func (f *Field) Unpack(buf []byte, val reflect.Value, length int, options *Options) error { typ := f.Type.Resolve(options) if typ == Pad || f.kind == reflect.String { if typ == Pad { return nil } else { val.SetString(string(buf)) return nil } } else if f.Slice { if val.Cap() < length { val.Set(reflect.MakeSlice(val.Type(), length, length)) } else if val.Len() < length { val.Set(val.Slice(0, length)) } // special case byte slices for performance if !f.Array && typ == Uint8 && f.defType == Uint8 { copy(val.Bytes(), buf[:length]) return nil } pos := 0 size := typ.Size() for i := 0; i < length; i++ { if err := f.unpackVal(buf[pos:pos+size], val.Index(i), 1, options); err != nil { return err } pos += size } return nil } else { return f.unpackVal(buf, val, length, options) } }
func (defaultMarshaler) Marshal(v reflect.Value, s string) error { if v.Kind() == reflect.Slice { n := reflect.New(v.Type().Elem()) m := valueMarshaler(n.Elem()) err := m.Marshal(n.Elem(), s) if err != nil { return err } v.Set(reflect.Append(v, n.Elem())) return nil } switch v.Kind() { case reflect.Int: x, err := strconv.ParseInt(s, 0, 0) v.SetInt(x) return err case reflect.Uint: x, err := strconv.ParseUint(s, 0, 0) v.SetUint(x) return err case reflect.Int64: x, err := strconv.ParseInt(s, 0, 64) v.SetInt(x) return err case reflect.String: v.SetString(s) return nil default: return fmt.Errorf("unhandled builtin type: %s", v.Type().String()) } }
func setFieldDefaults(v reflect.Value, sf reflect.StructField, s reflect.Value) { if v.CanInterface() && reflect.DeepEqual( v.Interface(), reflect.Zero(v.Type()).Interface()) { tag := sf.Tag.Get("ebmldef") if tag != "" { switch v.Kind() { case reflect.Int, reflect.Int64: u, _ := strconv.ParseInt(tag, 10, 0) v.SetInt(int64(u)) case reflect.Uint, reflect.Uint64: u, _ := strconv.ParseUint(tag, 10, 0) v.SetUint(u) case reflect.Float32, reflect.Float64: f, _ := strconv.ParseFloat(tag, 64) v.SetFloat(f) case reflect.String: v.SetString(tag) default: log.Panic("Unsupported default value") } } ltag := sf.Tag.Get("ebmldeflink") if ltag != "" { v.Set(s.FieldByName(ltag)) } } }
func (e *Element) readField(v reflect.Value) (err error) { switch v.Kind() { case reflect.Struct: err = e.readStruct(v) case reflect.Slice: err = e.readSlice(v) case reflect.Array: for i, l := 0, v.Len(); i < l && err == nil; i++ { err = e.readStruct(v.Index(i)) } case reflect.String: var s string s, err = e.readString() v.SetString(s) case reflect.Int, reflect.Int64: var u uint64 u, err = e.readUint64() v.SetInt(int64(u)) case reflect.Uint, reflect.Uint64: var u uint64 u, err = e.readUint64() v.SetUint(u) case reflect.Float32, reflect.Float64: var f float64 f, err = e.readFloat() v.SetFloat(f) default: err = errors.New("Unknown type: " + v.String()) } return }
// setValue updates the field value in fv to the data extracted from config // with key. func setValue(fv *reflect.Value, c *Config, key string) error { // Update the value with the correct type switch fv.Kind() { case reflect.Int: val, err := c.GetInt(key) if err != nil { return err } fv.SetInt(int64(val)) case reflect.Float64: val, err := c.GetFloat(key) if err != nil { return err } fv.SetFloat(val) case reflect.Bool: val, err := c.GetBool(key) if err != nil { return err } fv.SetBool(val) case reflect.String: val, err := c.GetString(key) if err != nil { return err } fv.SetString(val) } return nil }
// setWithProperType sets proper value to field based on its type, // but it does not return error for failing parsing, // because we want to use default value that is already assigned to strcut. func setWithProperType(t reflect.Type, key *Key, field reflect.Value, delim string) error { switch t.Kind() { case reflect.String: if len(key.String()) == 0 { return nil } field.SetString(key.String()) case reflect.Bool: boolVal, err := key.Bool() if err != nil { return nil } field.SetBool(boolVal) case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: durationVal, err := key.Duration() // Skip zero value if err == nil && int(durationVal) > 0 { field.Set(reflect.ValueOf(durationVal)) return nil } intVal, err := key.Int64() if err != nil || intVal == 0 { return nil } field.SetInt(intVal) // byte is an alias for uint8, so supporting uint8 breaks support for byte case reflect.Uint, reflect.Uint16, reflect.Uint32, reflect.Uint64: durationVal, err := key.Duration() // Skip zero value if err == nil && int(durationVal) > 0 { field.Set(reflect.ValueOf(durationVal)) return nil } uintVal, err := key.Uint64() if err != nil { return nil } field.SetUint(uintVal) case reflect.Float64: floatVal, err := key.Float64() if err != nil { return nil } field.SetFloat(floatVal) case reflectTime: timeVal, err := key.Time() if err != nil { return nil } field.Set(reflect.ValueOf(timeVal)) case reflect.Slice: return setSliceWithProperType(key, field, delim) default: return fmt.Errorf("unsupported type '%s'", t) } return nil }
// type(1) | name length(1) | content length(1) | raw name bytes | // 0x00 | content bytes | 0x00 func (d *decodeState) shortString(v reflect.Value) { d.off += 1 // type klen := int(Int8(d.data[d.off:])) d.off += 1 // name length vlen := int(Int8(d.data[d.off:])) d.off += 1 // content length if klen > 0 { key := d.data[d.off : d.off+klen-1] d.off += klen // name and 0x00 v = fieldByTag(v, key) u, pv := d.indirect(v, false) if u != nil { d.off -= 1 + 1 + 1 + klen if err := u.UnmarshalMCPACK(d.next()); err != nil { d.error(err) } return } v = pv } val := string(d.data[d.off : d.off+vlen-1]) d.off += vlen // value and 0x00 if !v.IsValid() { return } v.SetString(val) }
func setConfigVal(str string, field reflect.Value) error { t := field.Kind() switch { case t == reflect.String: field.SetString(str) case t >= reflect.Int && t <= reflect.Int64: if x, err := strconv.ParseInt(str, 10, 64); err != nil { return err } else { field.SetInt(x) } case t >= reflect.Uint && t <= reflect.Uint64: if x, err := strconv.ParseUint(str, 10, 64); err != nil { return err } else { field.SetUint(x) } case t >= reflect.Float32 && t <= reflect.Float64: if x, err := strconv.ParseFloat(str, 64); err != nil { return err } else { field.SetFloat(x) } case t == reflect.Bool: if x, err := strconv.ParseBool(str); err != nil { return err } else { field.SetBool(x) } default: return nil } return nil }
// decodeString decodes a string of size s into a v. // If s is zero, the size of a string is read from a stream. // The return value n indicates the number of bytes decoded. func (d *Decoder) decodeString(s int, v reflect.Value) (n int, err error) { // Read the size if it is a zero if s == 0 { s, err = d.readSize() if err != nil { return 0, err } // We have successfully read one byte of size already n++ if s == 0 { return n, nil } } // Decode data of size s data := make([]byte, s) if err := binary.Read(d.r, d.bo, data); err != nil { return n, err } n += s // Trim null bytes data = bytes.TrimRight(data, "\x00") // Set the string v.SetString(string(data)) return n, nil }
func setWithProperType(valueKind reflect.Kind, val string, structField reflect.Value) error { switch valueKind { case reflect.Int: return setIntField(val, 0, structField) case reflect.Int8: return setIntField(val, 8, structField) case reflect.Int16: return setIntField(val, 16, structField) case reflect.Int32: return setIntField(val, 32, structField) case reflect.Int64: return setIntField(val, 64, structField) case reflect.Uint: return setUintField(val, 0, structField) case reflect.Uint8: return setUintField(val, 8, structField) case reflect.Uint16: return setUintField(val, 16, structField) case reflect.Uint32: return setUintField(val, 32, structField) case reflect.Uint64: return setUintField(val, 64, structField) case reflect.Bool: return setBoolField(val, structField) case reflect.Float32: return setFloatField(val, 32, structField) case reflect.Float64: return setFloatField(val, 64, structField) case reflect.String: structField.SetString(val) default: return errors.New("Unknown type") } return nil }
func (t *Transport) decodeArrayish(r reader, val reflect.Value) error { usize, err := binary.ReadUvarint(r) if err != nil { return err } size := int(usize) // Special cases: []byte, string isByteArr := val.Kind() == reflect.Array && val.Type().Elem().Kind() == reflect.Uint8 isString := val.Kind() == reflect.String if isByteArr || isString { raw := make([]byte, size) if _, err := io.ReadFull(r, raw); err != nil { return err } switch { case isString: val.SetString(string(raw)) case isByteArr: val.SetBytes(raw) } return nil } slice := reflect.MakeSlice(val.Type(), size, size) for i := 0; i < size; i++ { if err := t.decodeValue(r, slice.Index(i)); err != nil { return err } } val.Set(slice) return nil }
func (d *MySQL) ValueToField(value reflect.Value, field reflect.Value) error { switch field.Type().Kind() { case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: field.SetInt(value.Elem().Int()) case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: // reading uint from int value causes panic switch value.Elem().Kind() { case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: field.SetUint(uint64(value.Elem().Int())) default: field.SetUint(value.Elem().Uint()) } case reflect.Float32, reflect.Float64: field.SetFloat(value.Elem().Float()) case reflect.String: if !value.Elem().IsValid() { field.SetString("") return nil } field.SetString(string(value.Elem().Bytes())) case reflect.Slice: if reflect.TypeOf(value.Interface()).Elem().Kind() == reflect.Uint8 { field.SetBytes(value.Elem().Bytes()) } case reflect.Struct: if field.Type() == reflect.TypeOf(time.Time{}) { field.Set(value.Elem()) } } return nil }
func (tbl *Table) setVal(field *reflect.Value, val interface{}) { str, ok := val.(string) log.Println("trying to set") if ok { log.Println("setting string") field.SetString(str) return } i, ok := val.(int64) if ok { field.SetInt(i) return } ui, ok := val.(uint64) if ok { field.SetUint(ui) return } b, ok := val.(bool) if ok { field.SetBool(b) return } f, ok := val.(float64) if ok { field.SetFloat(f) return } t, ok := val.(time.Time) if ok { field.Set(reflect.ValueOf(t)) return } }
func setValueFromBytes(t []uint8, to reflect.Value) { switch to.Interface().(type) { case bool: n, _ := strconv.ParseInt(string(t), 10, 32) convertAndSet(bool(n == 1), to) case int, int8, int16, int32, int64: n, _ := strconv.ParseInt(string(t), 10, 64) convertAndSet(n, to) case uint, uint8, uint16, uint32, uint64: n, _ := strconv.ParseUint(string(t), 10, 64) convertAndSet(n, to) case float32: n, _ := strconv.ParseFloat(string(t), 32) convertAndSet(n, to) case float64: n, _ := strconv.ParseFloat(string(t), 64) convertAndSet(n, to) case string: to.SetString(string(t)) case map[string]interface{}: to.Set(reflect.ValueOf(parseHstoreColumn(string(t)))) default: convertAndSet(t, to) } }
func luaU_FetchString(l Lua_State, v *reflect.Value) (ok bool) { if ok = Lua_isstring(l, -1); ok { v.SetString(Lua_tostring(l, -1)) } Lua_pop(l, 1) return }
func (md *MetaData) unifyString(data interface{}, rv reflect.Value) error { if s, ok := data.(string); ok { rv.SetString(s) return nil } return badtype("string", data) }
func (d *Decoder) decodeField(v reflect.Value, val string) error { switch v.Type() { case reflect.TypeOf(time.Duration(0)): a, err := time.ParseDuration(val) if err != nil { return err } v.SetInt(int64(a)) default: switch v.Kind() { case reflect.String: v.SetString(val) case reflect.Int, reflect.Int32, reflect.Int64: v.Type() nv, err := strconv.ParseInt(val, 10, 64) if err != nil { return err } v.SetInt(nv) case reflect.Bool: b, err := strconv.ParseBool(val) if err != nil { return err } v.SetBool(b) case reflect.Float32, reflect.Float64: f, err := strconv.ParseFloat(val, 64) if err != nil { return err } v.SetFloat(f) } } return nil }
func read(lex *lexer, v reflect.Value) { switch lex.token { case scanner.Ident: // The only valid identifiers are // "nil" and struct field names. if lex.text() == "nil" { v.Set(reflect.Zero(v.Type())) lex.next() return } case scanner.String: s, _ := strconv.Unquote(lex.text()) // NOTE: ignoring errors v.SetString(s) lex.next() return case scanner.Int: i, _ := strconv.Atoi(lex.text()) // NOTE: ignoring errors v.SetInt(int64(i)) lex.next() return case '(': lex.next() readList(lex, v) lex.next() // consume ')' return } panic(fmt.Sprintf("unexpected token %q", lex.text())) }
func boolAsStringDecoder(dv, sv reflect.Value) { if sv.Bool() { dv.SetString("1") } else { dv.SetString("0") } }
func (d *base) SetModelValue(driverValue, fieldValue reflect.Value) error { // ignore zero types if !driverValue.Elem().IsValid() { return nil } switch fieldValue.Type().Kind() { case reflect.Bool: fieldValue.SetBool(d.Dialect.ParseBool(driverValue.Elem())) case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: fieldValue.SetInt(driverValue.Elem().Int()) case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: // reading uint from int value causes panic switch driverValue.Elem().Kind() { case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: fieldValue.SetUint(uint64(driverValue.Elem().Int())) default: fieldValue.SetUint(driverValue.Elem().Uint()) } case reflect.Float32, reflect.Float64: fieldValue.SetFloat(driverValue.Elem().Float()) case reflect.String: fieldValue.SetString(string(driverValue.Elem().Bytes())) case reflect.Slice: if reflect.TypeOf(driverValue.Interface()).Elem().Kind() == reflect.Uint8 { fieldValue.SetBytes(driverValue.Elem().Bytes()) } case reflect.Struct: if _, ok := fieldValue.Interface().(time.Time); ok { fieldValue.Set(driverValue.Elem()) } } return nil }
func (me Record) GetValue(key string, value reflect.Value) (err error) { /*stringer, ok := value.Interface().(fmt.Stringer) if ok { me.Gut(key, stringer.String()) return }*/ monolog.Debug("GetValue: %s %v", key, value) switch value.Kind() { case reflect.Int, reflect.Int32, reflect.Int64: value.SetInt(int64(me.GetIntDefault(key, 0))) case reflect.Uint, reflect.Uint32, reflect.Uint64: value.SetUint(uint64(me.GetIntDefault(key, 0))) case reflect.Float32, reflect.Float64: f, err := me.GetFloat(key) if err != nil { return err } value.SetFloat(f) case reflect.String: s, ok := me.MayGet(key) if !ok { return fmt.Errorf("Could not get string for key %s", key) } value.SetString(s) case reflect.Struct: me.GetStruct(key+".", value.Addr().Interface()) default: monolog.Warning("Don't know what to do with %v", value) } return nil }
func (d base) setModelValue(driverValue, fieldValue reflect.Value) error { switch fieldValue.Type().Kind() { case reflect.Bool: fieldValue.SetBool(d.dialect.parseBool(driverValue.Elem())) case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: fieldValue.SetInt(driverValue.Elem().Int()) case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: // reading uint from int value causes panic switch driverValue.Elem().Kind() { case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: fieldValue.SetUint(uint64(driverValue.Elem().Int())) default: fieldValue.SetUint(driverValue.Elem().Uint()) } case reflect.Float32, reflect.Float64: fieldValue.SetFloat(driverValue.Elem().Float()) case reflect.String: fieldValue.SetString(string(driverValue.Elem().Bytes())) case reflect.Slice: if reflect.TypeOf(driverValue.Interface()).Elem().Kind() == reflect.Uint8 { fieldValue.SetBytes(driverValue.Elem().Bytes()) } case reflect.Struct: switch fieldValue.Interface().(type) { case time.Time: fieldValue.Set(driverValue.Elem()) default: if scanner, ok := fieldValue.Addr().Interface().(sql.Scanner); ok { return scanner.Scan(driverValue.Interface()) } } } return nil }
// inflate the results of a match into a string func inflateScalar(dest reflect.Value, match *match, captureIndex int) error { if captureIndex == -1 { // This means the field generated a regex but we did not want the results return nil } region := match.captures[captureIndex] if !region.wasMatched() { // This means the region was optional and was not matched return nil } buf := match.input[region.begin:region.end] dest = ensureAlloc(dest) switch dest.Type() { case stringType: dest.SetString(string(buf)) return nil case byteArrayType: dest.SetBytes(buf) return nil case emptyType: // ignore the value return nil } return fmt.Errorf("unable to capture into %s", dest.Type().String()) }
func convertAssignBulkString(d reflect.Value, s []byte) (err error) { switch d.Type().Kind() { case reflect.Float32, reflect.Float64: var x float64 x, err = strconv.ParseFloat(string(s), d.Type().Bits()) d.SetFloat(x) case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: var x int64 x, err = strconv.ParseInt(string(s), 10, d.Type().Bits()) d.SetInt(x) case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: var x uint64 x, err = strconv.ParseUint(string(s), 10, d.Type().Bits()) d.SetUint(x) case reflect.Bool: var x bool x, err = strconv.ParseBool(string(s)) d.SetBool(x) case reflect.String: d.SetString(string(s)) case reflect.Slice: if d.Type().Elem().Kind() != reflect.Uint8 { err = cannotConvert(d, s) } else { d.SetBytes(s) } default: err = cannotConvert(d, s) } return }
func read(lex *lexer, v reflect.Value) { switch lex.token { case scanner.Ident: if lex.text() == "nil" { v.Set(reflect.Zero(v.Type())) lex.next() return } case scanner.String: s, _ := strconv.Unquote(lex.text()) v.SetString(s) lex.next() return case scanner.Int: i, _ := strconv.Atoi(lex.text()) v.SetInt(int64(i)) lex.next() return case '(': lex.next() readList(lex, v) lex.next() return } panic(fmt.Sprintf("unexpected token %q", lex.text())) }