// convert to float64 func ToFloat(input reflect.Value) (output float64, err error) { //defer checkError(err) if !input.IsValid() { return 0, newTypeErr(methodName(), "input is invalid", input) } input = Underlying(input) k := input.Kind() switch { case IsBool(k): if input.Bool() { return 1, nil } return 0, nil case IsInt(k): return float64(input.Int()), nil case IsUint(k): return float64(input.Uint()), nil case IsFloat(k): return input.Float(), nil case IsString(k): return strconv.ParseFloat(input.String(), 32) default: } return 0, newTypeErr(methodName(), "input can not convert to float", input) }
func (p *printer) marshalSimple(typ reflect.Type, val reflect.Value) (string, []byte, error) { switch val.Kind() { case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: return strconv.FormatInt(val.Int(), 10), nil, nil case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: return strconv.FormatUint(val.Uint(), 10), nil, nil case reflect.Float32, reflect.Float64: return strconv.FormatFloat(val.Float(), 'g', -1, val.Type().Bits()), nil, nil case reflect.String: return val.String(), nil, nil case reflect.Bool: return strconv.FormatBool(val.Bool()), nil, nil case reflect.Array: if typ.Elem().Kind() != reflect.Uint8 { break } // [...]byte var bytes []byte if val.CanAddr() { bytes = val.Slice(0, val.Len()).Bytes() } else { bytes = make([]byte, val.Len()) reflect.Copy(reflect.ValueOf(bytes), val) } return "", bytes, nil case reflect.Slice: if typ.Elem().Kind() != reflect.Uint8 { break } // []byte return "", val.Bytes(), nil } return "", nil, &UnsupportedTypeError{typ} }
// for insert and update // If already assigned, then just ignore tag func GetValQuoteStr(val reflect.Value) (string, error) { switch val.Kind() { case reflect.Bool: boolStr := "N" if val.Bool() { boolStr = "Y" } return boolStr, nil case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: return strconv.FormatInt(val.Int(), 10), nil case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: return strconv.FormatUint(val.Uint(), 10), nil case reflect.Float32, reflect.Float64: return strconv.FormatFloat(val.Float(), 'f', -1, 64), nil case reflect.String: return QuoteStr(val.String()), nil case reflect.Slice: //[]byte if val.Type().Elem().Name() != "uint8" { return "", fmt.Errorf("GetValQuoteStr> slicetype is not []byte: %v", val.Interface()) } return QuoteStr(string(val.Interface().([]byte))), nil default: return "", fmt.Errorf("GetValQuoteStr> reflect.Value is not a string/int/uint/float/bool/[]byte!\nval: %v", val) } return "", nil }
func (c *FlatMapConfig) flatten(result map[string]interface{}, prefix string, v reflect.Value) error { var err error if v.Kind() == reflect.Interface { v = v.Elem() } // Set as type interface // https://golang.org/pkg/reflect/#Kind switch v.Kind() { case reflect.Bool: result[c.keyDelim+prefix] = v.Bool() case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32: result[c.keyDelim+prefix] = v.Int() case reflect.String: result[c.keyDelim+prefix] = v.String() case reflect.Map: err = c.flattenMap(result, prefix, v) case reflect.Slice, reflect.Array: err = c.flattenSlice(result, prefix, v) default: err = fmt.Errorf("Unknown primitive type found for value: '%q'", v) } return err }
func (this *databaseImplement) value2Interface(fieldValue reflect.Value) (interface{}, error) { fieldType := fieldValue.Type() fieldTypeKind := fieldType.Kind() switch fieldTypeKind { case reflect.Bool: return fieldValue.Bool(), nil case reflect.String: return fieldValue.String(), nil case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int: return fieldValue.Int(), nil case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint: return fieldValue.Uint(), nil case reflect.Float32, reflect.Float64: return fieldValue.Float(), nil case reflect.Struct: if fieldType == reflect.TypeOf(time.Time{}) { t := fieldValue.Interface().(time.Time) tf := t.Format("2006-01-02 15:04:05") return tf, nil } else { return nil, fmt.Errorf("Unsupported type %v", fieldType) } default: return nil, fmt.Errorf("Unsupported type %v", fieldType) } }
func boolEncoder(v reflect.Value) interface{} { if v.Bool() { return true } else { return false } }
// valueString returns the string representation of a value. func valueString(v reflect.Value, opts tagOptions) string { for v.Kind() == reflect.Ptr { if v.IsNil() { return "" } v = v.Elem() } if v.Kind() == reflect.Bool && opts.Contains("int") { if v.Bool() { return "1" } return "0" } if v.Type() == timeType { t := v.Interface().(time.Time) if opts.Contains("unix") { return strconv.FormatInt(t.Unix(), 10) } return t.Format(time.RFC3339) } return fmt.Sprint(v.Interface()) }
func boolAsStringDecoder(dv, sv reflect.Value) { if sv.Bool() { dv.SetString("1") } else { dv.SetString("0") } }
func boolEncoder(e *encodeState, v reflect.Value) { if v.Bool() { e.WriteString("true") } else { e.WriteString("false") } }
func boolAsUintDecoder(dv, sv reflect.Value) { if sv.Bool() { dv.SetUint(1) } else { dv.SetUint(0) } }
func boolAsFloatDecoder(dv, sv reflect.Value) { if sv.Bool() { dv.SetFloat(1) } else { dv.SetFloat(0) } }
func isZero(v reflect.Value) bool { switch v.Kind() { case reflect.String: return len(v.String()) == 0 case reflect.Ptr, reflect.Interface: return v.IsNil() case reflect.Slice: return v.Len() == 0 case reflect.Map: return v.Len() == 0 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: return v.Int() == 0 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: return v.Uint() == 0 case reflect.Float32, reflect.Float64: return v.Float() == 0 case reflect.Bool: return !v.Bool() case reflect.Struct: vt := v.Type() if vt == typeTime { return v.Interface().(time.Time).IsZero() } for i := 0; i < v.NumField(); i++ { if vt.Field(i).PkgPath != "" && !vt.Field(i).Anonymous { continue // Private field } if !isZero(v.Field(i)) { return false } } return true } return false }
// formatAtom formats a value without inspecting its internal structure. // It is a copy of the the function in gopl.io/ch11/format. func formatAtom(v reflect.Value) string { switch v.Kind() { case reflect.Invalid: return "invalid" case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: return strconv.FormatInt(v.Int(), 10) case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: return strconv.FormatUint(v.Uint(), 10) // ...floating-point and complex cases omitted for brevity... case reflect.Bool: if v.Bool() { return "true" } return "false" case reflect.String: return strconv.Quote(v.String()) case reflect.Chan, reflect.Func, reflect.Ptr, reflect.Slice, reflect.Map: return v.Type().String() + " 0x" + strconv.FormatUint(uint64(v.Pointer()), 16) default: // reflect.Array, reflect.Struct, reflect.Interface return v.Type().String() + " value" } }
func (p *printer) marshalSimple(typ reflect.Type, val reflect.Value) error { // Normally we don't see structs, but this can happen for an attribute. if val.Type() == timeType { p.WriteString(val.Interface().(time.Time).Format(time.RFC3339Nano)) return nil } switch val.Kind() { case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: p.WriteString(strconv.FormatInt(val.Int(), 10)) case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: p.WriteString(strconv.FormatUint(val.Uint(), 10)) case reflect.Float32, reflect.Float64: p.WriteString(strconv.FormatFloat(val.Float(), 'g', -1, 64)) case reflect.String: // TODO: Add EscapeString. Escape(p, []byte(val.String())) case reflect.Bool: p.WriteString(strconv.FormatBool(val.Bool())) case reflect.Array: // will be [...]byte bytes := make([]byte, val.Len()) for i := range bytes { bytes[i] = val.Index(i).Interface().(byte) } Escape(p, bytes) case reflect.Slice: // will be []byte Escape(p, val.Bytes()) default: return &UnsupportedTypeError{typ} } return p.cachedWriteError() }
func encodeValue(buf []byte, prefix, name string, fv reflect.Value, inArray, arrayTable bool) ([]byte, error) { switch t := fv.Interface().(type) { case Marshaler: b, err := t.MarshalTOML() if err != nil { return nil, err } return appendNewline(append(appendKey(buf, name, inArray, arrayTable), b...), inArray, arrayTable), nil case time.Time: return appendNewline(encodeTime(appendKey(buf, name, inArray, arrayTable), t), inArray, arrayTable), nil } switch fv.Kind() { case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: return appendNewline(encodeInt(appendKey(buf, name, inArray, arrayTable), fv.Int()), inArray, arrayTable), nil case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: return appendNewline(encodeUint(appendKey(buf, name, inArray, arrayTable), fv.Uint()), inArray, arrayTable), nil case reflect.Float32, reflect.Float64: return appendNewline(encodeFloat(appendKey(buf, name, inArray, arrayTable), fv.Float()), inArray, arrayTable), nil case reflect.Bool: return appendNewline(encodeBool(appendKey(buf, name, inArray, arrayTable), fv.Bool()), inArray, arrayTable), nil case reflect.String: return appendNewline(encodeString(appendKey(buf, name, inArray, arrayTable), fv.String()), inArray, arrayTable), nil case reflect.Slice, reflect.Array: ft := fv.Type().Elem() for ft.Kind() == reflect.Ptr { ft = ft.Elem() } if ft.Kind() == reflect.Struct { name := tableName(prefix, name) var err error for i := 0; i < fv.Len(); i++ { if buf, err = marshal(append(append(append(buf, '[', '['), name...), ']', ']', '\n'), name, fv.Index(i), false, true); err != nil { return nil, err } } return buf, nil } buf = append(appendKey(buf, name, inArray, arrayTable), '[') var err error for i := 0; i < fv.Len(); i++ { if i != 0 { buf = append(buf, ',') } if buf, err = encodeValue(buf, prefix, name, fv.Index(i), true, false); err != nil { return nil, err } } return appendNewline(append(buf, ']'), inArray, arrayTable), nil case reflect.Struct: name := tableName(prefix, name) return marshal(append(append(append(buf, '['), name...), ']', '\n'), name, fv, inArray, arrayTable) case reflect.Interface: var err error if buf, err = encodeInterface(appendKey(buf, name, inArray, arrayTable), fv.Interface()); err != nil { return nil, err } return appendNewline(buf, inArray, arrayTable), nil } return nil, fmt.Errorf("toml: marshal: unsupported type %v", fv.Kind()) }
func indexBytes(typ reflect.Type, value reflect.Value) (b []byte, err error) { switch typ.Kind() { case reflect.String: b = []byte(value.String()) case reflect.Int: buf := new(bytes.Buffer) if err = binary.Write(buf, binary.BigEndian, value.Int()); err != nil { return } b = buf.Bytes() case reflect.Slice: switch typ.Elem().Kind() { case reflect.Uint8: b = value.Bytes() default: err = fmt.Errorf("%v is not an indexable type", typ) } case reflect.Bool: if value.Bool() { b = []byte{1} } else { b = []byte{0} } default: err = fmt.Errorf("%v is not an indexable type", typ) return } if len(b) == 0 { b = []byte{0} } return }
func encodeBasic(v reflect.Value) string { t := v.Type() switch k := t.Kind(); k { case reflect.Bool: return strconv.FormatBool(v.Bool()) case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: return strconv.FormatInt(v.Int(), 10) case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: return strconv.FormatUint(v.Uint(), 10) case reflect.Float32: return strconv.FormatFloat(v.Float(), 'g', -1, 32) case reflect.Float64: return strconv.FormatFloat(v.Float(), 'g', -1, 64) case reflect.Complex64, reflect.Complex128: s := fmt.Sprintf("%g", v.Complex()) return strings.TrimSuffix(strings.TrimPrefix(s, "("), ")") case reflect.String: return v.String() } panic(t.String() + " has unsupported kind " + t.Kind().String()) }
func (p *printer) marshalSimple(typ reflect.Type, val reflect.Value) error { switch val.Kind() { case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: p.WriteString(strconv.FormatInt(val.Int(), 10)) case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: p.WriteString(strconv.FormatUint(val.Uint(), 10)) case reflect.Float32, reflect.Float64: p.WriteString(strconv.FormatFloat(val.Float(), 'g', -1, 64)) case reflect.String: // TODO: Add EscapeString. Escape(p, []byte(val.String())) case reflect.Bool: p.WriteString(strconv.FormatBool(val.Bool())) case reflect.Array: // will be [...]byte bytes := make([]byte, val.Len()) for i := range bytes { bytes[i] = val.Index(i).Interface().(byte) } Escape(p, bytes) case reflect.Slice: // will be []byte Escape(p, val.Bytes()) default: return &UnsupportedTypeError{typ} } return nil }
// isZero reports whether the value is the zero of its type. func isZero(val reflect.Value) bool { switch val.Kind() { case reflect.Array: for i := 0; i < val.Len(); i++ { if !isZero(val.Index(i)) { return false } } return true case reflect.Map, reflect.Slice, reflect.String: return val.Len() == 0 case reflect.Bool: return !val.Bool() case reflect.Complex64, reflect.Complex128: return val.Complex() == 0 case reflect.Chan, reflect.Func, reflect.Ptr: return val.IsNil() case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: return val.Int() == 0 case reflect.Float32, reflect.Float64: return val.Float() == 0 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: return val.Uint() == 0 case reflect.Struct: for i := 0; i < val.NumField(); i++ { if !isZero(val.Field(i)) { return false } } return true } panic("unknown type in isZero " + val.Type().String()) }
// valueSortLess returns whether the first value should sort before the second // value. It is used by valueSorter.Less as part of the sort.Interface // implementation. func valueSortLess(a, b reflect.Value) bool { switch a.Kind() { case reflect.Bool: return !a.Bool() && b.Bool() case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int: return a.Int() < b.Int() case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint: return a.Uint() < b.Uint() case reflect.Float32, reflect.Float64: return a.Float() < b.Float() case reflect.String: return a.String() < b.String() case reflect.Uintptr: return a.Uint() < b.Uint() case reflect.Array: // Compare the contents of both arrays. l := a.Len() for i := 0; i < l; i++ { av := a.Index(i) bv := b.Index(i) if av.Interface() == bv.Interface() { continue } return valueSortLess(av, bv) } } return a.String() < b.String() }
func formatValue(value reflect.Value, indentation uint) string { if indentation > MaxDepth { return "..." } if isNilValue(value) { return "nil" } if UseStringerRepresentation { if value.CanInterface() { obj := value.Interface() switch x := obj.(type) { case fmt.GoStringer: return x.GoString() case fmt.Stringer: return x.String() } } } switch value.Kind() { case reflect.Bool: return fmt.Sprintf("%v", value.Bool()) case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: return fmt.Sprintf("%v", value.Int()) case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: return fmt.Sprintf("%v", value.Uint()) case reflect.Uintptr: return fmt.Sprintf("0x%x", value.Uint()) case reflect.Float32, reflect.Float64: return fmt.Sprintf("%v", value.Float()) case reflect.Complex64, reflect.Complex128: return fmt.Sprintf("%v", value.Complex()) case reflect.Chan: return fmt.Sprintf("0x%x", value.Pointer()) case reflect.Func: return fmt.Sprintf("0x%x", value.Pointer()) case reflect.Ptr: return formatValue(value.Elem(), indentation) case reflect.Slice: return formatSlice(value, indentation) case reflect.String: return formatString(value.String(), indentation) case reflect.Array: return formatSlice(value, indentation) case reflect.Map: return formatMap(value, indentation) case reflect.Struct: return formatStruct(value, indentation) case reflect.Interface: return formatValue(value.Elem(), indentation) default: if value.CanInterface() { return fmt.Sprintf("%#v", value.Interface()) } else { return fmt.Sprintf("%#v", value) } } }
func refToVal(ref reflect.Value) Value { switch ref.Kind() { case reflect.Bool: return boolValue(ref.Bool()) case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: return intValue(ref.Int()) case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: return intValue(ref.Uint()) case reflect.Float32, reflect.Float64: return floatValue(ref.Float()) case reflect.Complex64, reflect.Complex128: return complexValue(ref.Complex()) case reflect.Array, reflect.Slice: return arrayValue{reflectValue(ref)} case reflect.Chan: return chanValue{reflectValue(ref)} case reflect.Map: return mapValue{reflectValue(ref)} case reflect.Ptr: return pointerValue{reflectValue(ref)} case reflect.String: return stringValue(ref.String()) case reflect.Struct: return structValue{reflectValue(ref)} } return nilValue(0) }
func plain_extract_value(name string, field reflect.Value) url.Values { values := make(url.Values) switch field.Kind() { case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: values.Add(name, strconv.FormatInt(field.Int(), 10)) case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: values.Add(name, strconv.FormatUint(field.Uint(), 10)) case reflect.Bool: values.Add(name, strconv.FormatBool(field.Bool())) case reflect.Struct: values = merge(values, plain_extract_struct(field)) case reflect.Slice: for i := 0; i < field.Len(); i++ { sv := field.Index(i) values = merge(values, plain_extract_value(name, sv)) } case reflect.String: values.Add(name, field.String()) case reflect.Float32, reflect.Float64: values.Add(name, strconv.FormatFloat(field.Float(), 'f', -1, 64)) case reflect.Ptr, reflect.Interface: values = merge(values, plain_extract_pointer(field)) } return values }
func (e *Encoder) encodeScalar(av *dynamodb.AttributeValue, v reflect.Value, fieldTag tag) error { if v.Type() == numberType { s := v.String() if fieldTag.AsString { av.S = &s } else { av.N = &s } return nil } switch v.Kind() { case reflect.Bool: av.BOOL = new(bool) *av.BOOL = v.Bool() case reflect.String: if err := e.encodeString(av, v); err != nil { return err } default: // Fallback to encoding numbers, will return invalid type if not supported if err := e.encodeNumber(av, v); err != nil { return err } if fieldTag.AsString && av.NULL == nil && av.N != nil { av.S = av.N av.N = nil } } return nil }
// isTrue reports whether the value is 'true', in the sense of not the zero of its type, // and whether the value has a meaningful truth value. func isTrue(val reflect.Value) (truth, ok bool) { if !val.IsValid() { // Something like var x interface{}, never set. It's a form of nil. return false, true } switch val.Kind() { case reflect.Array, reflect.Map, reflect.Slice, reflect.String: truth = val.Len() > 0 case reflect.Bool: truth = val.Bool() case reflect.Complex64, reflect.Complex128: truth = val.Complex() != 0 case reflect.Chan, reflect.Func, reflect.Ptr, reflect.Interface: truth = !val.IsNil() case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: truth = val.Int() != 0 case reflect.Float32, reflect.Float64: truth = val.Float() != 0 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: truth = val.Uint() != 0 case reflect.Struct: truth = true // Struct values are always true. default: return } return truth, true }
func encode(b []byte, rv reflect.Value) ([]byte, error) { switch rk := rv.Kind(); rk { case reflect.Bool: b = encodeBool(b, rv.Bool()) case reflect.Int, reflect.Int8, reflect.Int64, reflect.Int32, reflect.Int16: b = encodeInt(b, rv.Int()) case reflect.Uint8, reflect.Uint64, reflect.Uint, reflect.Uint32, reflect.Uint16: b = encodeInt(b, int64(rv.Uint())) case reflect.String: b = encodeString(b, rv.String()) case reflect.Array, reflect.Slice: if rv.Len() == 0 && rv.Type().Elem().Kind() == reflect.Uint8 { b = encodeBytes(b, rv.Bytes()) } else if rv.Index(0).Kind() == reflect.Uint8 { b = encodeBytes(b, rv.Bytes()) } else { b = encodeArray(b, rv) } case reflect.Map: b = encodeMap(b, rv) case reflect.Struct: b = encodeStruct(b, rv) default: panic("no support for type") } return b, nil }
func encodeBool(b []byte, v reflect.Value) []byte { if v.Bool() { return append(b, 0x12) } else { return append(b, 0x11) } }
// Returns the string representation of the field value func (enc *encoder) encodeCol(fv reflect.Value, st reflect.StructTag) string { switch fv.Kind() { case reflect.String: return fv.String() case reflect.Int, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int8: return fmt.Sprintf("%v", fv.Int()) case reflect.Float32: return encodeFloat(32, fv) case reflect.Float64: return encodeFloat(64, fv) case reflect.Bool: return encodeBool(fv.Bool(), st) case reflect.Uint, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint8: return fmt.Sprintf("%v", fv.Uint()) case reflect.Complex64, reflect.Complex128: return fmt.Sprintf("%+.3g", fv.Complex()) case reflect.Interface: return encodeInterface(fv, st) case reflect.Struct: return encodeInterface(fv, st) default: panic(fmt.Sprintf("Unsupported type %s", fv.Kind())) } return "" }
func isZero(v reflect.Value) bool { switch v.Kind() { case reflect.String: return len(v.String()) == 0 case reflect.Interface, reflect.Ptr: return v.IsNil() case reflect.Slice: return v.Len() == 0 case reflect.Map: return v.Len() == 0 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: return v.Int() == 0 case reflect.Float32, reflect.Float64: return v.Float() == 0 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: return v.Uint() == 0 case reflect.Bool: return !v.Bool() case reflect.Struct: vt := v.Type() for i := v.NumField() - 1; i >= 0; i-- { if vt.Field(i).PkgPath != "" { continue // Private field } if !isZero(v.Field(i)) { return false } } return true } return false }
func encodeString(v reflect.Value, opts *Options) string { switch v.Kind() { case reflect.String: return v.String() case reflect.Bool: return strconv.FormatBool(v.Bool()) case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: return strconv.FormatInt(v.Int(), 10) case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: return strconv.FormatUint(v.Uint(), 10) case reflect.Float32, reflect.Float64: return strconv.FormatFloat(v.Float(), 'f', -1, v.Type().Bits()) case reflect.Slice: l := v.Len() vals := make([]string, l) for i := 0; i < l; i++ { sv := v.Index(i) vals[i] = encodeString(sv, opts) } return strings.Join(vals, opts.SliceSeparator) } panic("EncodeString unsupported val kind " + v.Kind().String()) }