// setFieldVal first converts v to the type of structField, then uses reflection
// to set the field to the converted value.
func setFieldVal(structField reflect.Value, name string, v string) error {
switch structField.Kind() {
case reflect.String:
structField.SetString(v)
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
vInt, err := strconv.Atoi(v)
if err != nil {
return fmt.Errorf("envvar: Error parsing environment variable %s: %s\n%s", name, v, err.Error())
}
structField.SetInt(int64(vInt))
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
vUint, err := strconv.ParseUint(v, 10, 64)
if err != nil {
return fmt.Errorf("envvar: Error parsing environment variable %s: %s\n%s", name, v, err.Error())
}
structField.SetUint(uint64(vUint))
case reflect.Float32, reflect.Float64:
vFloat, err := strconv.ParseFloat(v, 64)
if err != nil {
return fmt.Errorf("envvar: Error parsing environment variable %s: %s\n%s", name, v, err.Error())
}
structField.SetFloat(vFloat)
case reflect.Bool:
vBool, err := strconv.ParseBool(v)
if err != nil {
return fmt.Errorf("envvar: Error parsing environment variable %s: %s\n%s", name, v, err.Error())
}
structField.SetBool(vBool)
default:
return fmt.Errorf("envvar: Unsupported struct field type: %s", structField.Type().String())
}
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
}
func convertAssignInt(d reflect.Value, s int64) (err error) {
switch d.Type().Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
d.SetInt(s)
if d.Int() != s {
err = strconv.ErrRange
d.SetInt(0)
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
if s < 0 {
err = strconv.ErrRange
} else {
x := uint64(s)
d.SetUint(x)
if d.Uint() != x {
err = strconv.ErrRange
d.SetUint(0)
}
}
case reflect.Bool:
d.SetBool(s != 0)
default:
err = cannotConvert(d, s)
}
return
}
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 (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 boolAsUintDecoder(dv, sv reflect.Value) {
if sv.Bool() {
dv.SetUint(1)
} else {
dv.SetUint(0)
}
}
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
}
// type(1) | name length(1) | raw name bytes | 0x00 | value bytes(8)
func (d *decodeState) uint64(v reflect.Value) {
d.off += 1 // type
klen := int(Int8(d.data[d.off:]))
d.off += 1 // name length
if klen > 0 {
key := d.data[d.off : d.off+klen-1]
d.off += klen
v = fieldByTag(v, key)
u, pv := d.indirect(v, false)
if u != nil {
d.off -= 1 + 1 + klen
if err := u.UnmarshalMCPACK(d.next()); err != nil {
d.error(err)
}
return
}
v = pv
}
val := Uint64(d.data[d.off:])
d.off += 8 // value
if !v.IsValid() {
return
}
v.SetUint(val)
}
// 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
}
// 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 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
}
func (decoder *Decoder) readInteger(value reflect.Value) error {
uv, err := decoder.readU29()
if err != nil {
return err
}
vv := int32(uv)
if uv > 0xfffffff {
vv = int32(uv - 0x20000000)
}
switch value.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
value.SetInt(int64(vv))
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
value.SetUint(uint64(uv))
case reflect.Interface:
value.Set(reflect.ValueOf(uv))
default:
return errors.New("invalid type:" + value.Type().String() + " for integer")
}
return nil
}
func (decoder *Decoder) readFloat(value reflect.Value) error {
bytes, err := decoder.readBytes(8)
if err != nil {
return err
}
n := uint64(0)
for _, b := range bytes {
n <<= 8
n |= uint64(b)
}
v := math.Float64frombits(n)
switch value.Kind() {
case reflect.Float32, reflect.Float64:
value.SetFloat(v)
case reflect.Int32, reflect.Int, reflect.Int64:
value.SetInt(int64(v))
case reflect.Uint32, reflect.Uint, reflect.Uint64:
value.SetUint(uint64(v))
case reflect.Interface:
value.Set(reflect.ValueOf(v))
default:
return errors.New("invalid type:" + value.Type().String() + " for double")
}
return nil
}
func (d *decoder) unmarshalInt32(size uint, offset uint, result reflect.Value) (uint, error) {
if size > 4 {
return 0, newInvalidDatabaseError("the MaxMind DB file's data section contains bad data (int32 size of %v)", size)
}
value, newOffset, err := d.decodeInt(size, offset)
if err != nil {
return 0, err
}
switch result.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
n := int64(value)
if !result.OverflowInt(n) {
result.SetInt(n)
return newOffset, nil
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
n := uint64(value)
if !result.OverflowUint(n) {
result.SetUint(n)
return newOffset, nil
}
case reflect.Interface:
if result.NumMethod() == 0 {
result.Set(reflect.ValueOf(value))
return newOffset, nil
}
}
return newOffset, newUnmarshalTypeError(value, result.Type())
}
func setUint(rv reflect.Value, u uint64) error {
switch rv.Kind() {
case reflect.Ptr:
if rv.IsNil() {
if rv.CanSet() {
rv.Set(reflect.New(rv.Type().Elem()))
// fall through to set indirect below
} else {
return fmt.Errorf("trying to put uint into unsettable nil ptr")
}
}
return setUint(reflect.Indirect(rv), u)
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
if rv.OverflowUint(u) {
return fmt.Errorf("value %d does not fit into target of type %s", u, rv.Kind().String())
}
rv.SetUint(u)
return nil
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
if (u == 0xffffffffffffffff) || rv.OverflowInt(int64(u)) {
return fmt.Errorf("value %d does not fit into target of type %s", u, rv.Kind().String())
}
rv.SetInt(int64(u))
return nil
case reflect.Interface:
rv.Set(reflect.ValueOf(u))
return nil
default:
return fmt.Errorf("cannot assign uint into Kind=%s Type=%#v %#v", rv.Kind().String(), rv.Type(), rv)
}
}
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 unifyInt(data interface{}, rv reflect.Value) error {
if num, ok := data.(int64); ok {
switch rv.Kind() {
case reflect.Int:
fallthrough
case reflect.Int8:
fallthrough
case reflect.Int16:
fallthrough
case reflect.Int32:
fallthrough
case reflect.Int64:
rv.SetInt(int64(num))
case reflect.Uint:
fallthrough
case reflect.Uint8:
fallthrough
case reflect.Uint16:
fallthrough
case reflect.Uint32:
fallthrough
case reflect.Uint64:
rv.SetUint(uint64(num))
default:
panic("bug")
}
return nil
}
return badtype("integer", data)
}
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
}
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 (db *DataBinder) submitProperty(prop Property, field reflect.Value) error {
value := prop.Get()
if value == nil {
// This happens e.g. if CurrentIndex() of a ComboBox returns -1.
// FIXME: Should we handle this differently?
return nil
}
if err, ok := value.(error); ok {
return err
}
if f64, ok := value.(float64); ok {
switch field.Kind() {
case reflect.Float32, reflect.Float64:
field.SetFloat(f64)
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
field.SetInt(int64(f64))
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
field.SetUint(uint64(f64))
default:
return newError(fmt.Sprintf("Field '%s': Can't convert float64 to %s.", prop.Source().(string), field.Type().Name()))
}
return nil
}
field.Set(reflect.ValueOf(value))
return nil
}
// decUint32 decodes an unsigned integer and stores it as a uint32 in value.
func decUint32(i *decInstr, state *decoderState, value reflect.Value) {
v := state.decodeUint()
if math.MaxUint32 < v {
error_(i.ovfl)
}
value.SetUint(v)
}
func (d *decoder) unmarshalUint(size uint, offset uint, result reflect.Value, uintType uint) (uint, error) {
if size > uintType/8 {
return 0, newInvalidDatabaseError("the MaxMind DB file's data section contains bad data (uint%v size of %v)", uintType, size)
}
value, newOffset, err := d.decodeUint(size, offset)
if err != nil {
return 0, err
}
switch result.Kind() {
default:
return newOffset, newUnmarshalTypeError(value, result.Type())
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
n := int64(value)
if result.OverflowInt(n) {
return 0, newUnmarshalTypeError(value, result.Type())
}
result.SetInt(n)
return newOffset, nil
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
if result.OverflowUint(value) {
return 0, newUnmarshalTypeError(value, result.Type())
}
result.SetUint(value)
return newOffset, nil
case reflect.Interface:
result.Set(reflect.ValueOf(value))
return newOffset, nil
}
}
func unmarshalInteger(i int64, v reflect.Value) {
switch v.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
if v.OverflowInt(i) {
panic(&UnmarshalOverflowError{"integer " + strconv.FormatInt(i, 10), v.Type()})
}
v.SetInt(i)
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
if i < 0 {
panic(&UnmarshalOverflowError{"integer " + strconv.FormatInt(i, 10), v.Type()})
}
u := uint64(i)
if v.OverflowUint(u) {
panic(&UnmarshalOverflowError{"integer " + strconv.FormatUint(u, 10), v.Type()})
}
v.SetUint(u)
case reflect.Interface:
if v.NumMethod() == 0 {
v.Set(reflect.ValueOf(i))
return
}
fallthrough
default:
panic(&UnmarshalTypeError{"integer " + strconv.FormatInt(i, 10), v.Type()})
}
}
// setFieldValue in a json object, there is only the number type, which defaults to float64. This method convertes float64 to the value
// of the underlying struct field, for example uint64, or int32 etc...
// If the field type is not one of the integers, it just sets the value
func setFieldValue(field *reflect.Value, value reflect.Value) (err error) {
// catch all invalid types and return an error
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("Value '%v' had wrong type", value.Interface())
}
}()
switch field.Type().Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
field.SetInt(int64(value.Float()))
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
field.SetUint(uint64(value.Float()))
default:
// try to set it with json.Unmarshaler interface, if that does not work, set value directly
switch target := field.Addr().Interface().(type) {
case json.Unmarshaler:
marshaledValue, err := json.Marshal(value.Interface())
if err != nil {
return err
}
err = target.UnmarshalJSON(marshaledValue)
if err != nil {
return err
}
default:
field.Set(value)
}
}
return nil
}
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 (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 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 luaU_FetchUint(l Lua_State, v *reflect.Value) (ok bool) {
if ok = Lua_isnumber(l, -1); ok {
v.SetUint(uint64(Lua_tointegerx(l, -1, nil)))
}
Lua_pop(l, 1)
return
}
func (p *Decoder) unmarshalLaxString(s string, val reflect.Value) {
switch val.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
i := mustParseInt(s, 10, 64)
val.SetInt(i)
return
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
i := mustParseUint(s, 10, 64)
val.SetUint(i)
return
case reflect.Float32, reflect.Float64:
f := mustParseFloat(s, 64)
val.SetFloat(f)
return
case reflect.Bool:
b := mustParseBool(s)
val.SetBool(b)
return
case reflect.Struct:
if val.Type() == timeType {
t, err := time.Parse(textPlistTimeLayout, s)
if err != nil {
panic(err)
}
val.Set(reflect.ValueOf(t.In(time.UTC)))
return
}
fallthrough
default:
panic(&incompatibleDecodeTypeError{val.Type(), String})
}
}
func setVal(val string, field reflect.Value) error {
switch field.Kind() {
case reflect.String:
field.SetString(val)
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
intVal, err := strconv.Atoi(val)
if err != nil {
return err
}
field.SetInt(int64(intVal))
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
intVal, err := strconv.Atoi(val)
if err != nil {
return err
}
field.SetUint(uint64(intVal))
case reflect.Bool:
boolVal, err := strconv.ParseBool(val)
if err != nil {
return err
}
field.SetBool(boolVal)
}
return nil
}
