func decodeSliceValue(dst reflect.Value, f []byte) error {
elemType := dst.Type().Elem()
switch elemType.Kind() {
case reflect.Uint8:
b, err := decodeBytes(f)
if err != nil {
return err
}
dst.SetBytes(b)
return nil
case reflect.String:
s, err := decodeStringSlice(f)
if err != nil {
return err
}
dst.Set(reflect.ValueOf(s))
return nil
case reflect.Int:
s, err := decodeIntSlice(f)
if err != nil {
return err
}
dst.Set(reflect.ValueOf(s))
return nil
case reflect.Int64:
s, err := decodeInt64Slice(f)
if err != nil {
return err
}
dst.Set(reflect.ValueOf(s))
return nil
}
return errorf("pg: unsupported dst: %s", dst)
}
func (f *decFnInfo) kSlice(rv reflect.Value) {
// A slice can be set from a map or array in stream.
currEncodedType := f.dd.currentEncodedType()
switch currEncodedType {
case valueTypeBytes, valueTypeString:
if f.ti.rtid == uint8SliceTypId || f.ti.rt.Elem().Kind() == reflect.Uint8 {
if bs2, changed2 := f.dd.decodeBytes(rv.Bytes()); changed2 {
rv.SetBytes(bs2)
}
return
}
}
if shortCircuitReflectToFastPath && rv.CanAddr() {
switch f.ti.rtid {
case intfSliceTypId:
f.d.decSliceIntf(rv.Addr().Interface().(*[]interface{}), currEncodedType, f.array)
return
case uint64SliceTypId:
f.d.decSliceUint64(rv.Addr().Interface().(*[]uint64), currEncodedType, f.array)
return
case int64SliceTypId:
f.d.decSliceInt64(rv.Addr().Interface().(*[]int64), currEncodedType, f.array)
return
case strSliceTypId:
f.d.decSliceStr(rv.Addr().Interface().(*[]string), currEncodedType, f.array)
return
}
}
containerLen, containerLenS := decContLens(f.dd, currEncodedType)
// an array can never return a nil slice. so no need to check f.array here.
if rv.IsNil() {
rv.Set(reflect.MakeSlice(f.ti.rt, containerLenS, containerLenS))
}
if containerLen == 0 {
return
}
if rvcap, rvlen := rv.Len(), rv.Cap(); containerLenS > rvcap {
if f.array { // !rv.CanSet()
decErr(msgDecCannotExpandArr, rvcap, containerLenS)
}
rvn := reflect.MakeSlice(f.ti.rt, containerLenS, containerLenS)
if rvlen > 0 {
reflect.Copy(rvn, rv)
}
rv.Set(rvn)
} else if containerLenS > rvlen {
rv.SetLen(containerLenS)
}
for j := 0; j < containerLenS; j++ {
f.d.decodeValue(rv.Index(j))
}
}
func (d *Decoder) sliceValue(v reflect.Value) error {
elemType := v.Type().Elem()
switch elemType.Kind() {
case reflect.Uint8:
b, err := d.DecodeBytes()
if err != nil {
return err
}
v.SetBytes(b)
return nil
}
n, err := d.DecodeSliceLen()
if err != nil {
return err
}
if v.Len() < n || (v.Kind() == reflect.Slice && v.IsNil()) {
v.Set(reflect.MakeSlice(v.Type(), n, n))
}
for i := 0; i < n; i++ {
sv := v.Index(i)
if err := d.DecodeValue(sv); err != nil {
return err
}
}
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 (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 (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 rewrite(nodeVal reflect.Value, rewriter Rewriter) {
if !nodeVal.IsValid() {
return
}
nodeTyp := nodeVal.Type()
switch nodeTyp.Kind() {
case reflect.Slice:
if nodeTyp == typeOfBytes && !nodeVal.IsNil() {
val := rewriter(nodeVal.Bytes()) //use rewriter to rewrite the bytes
nodeVal.SetBytes(val)
} else if nodeTyp.Implements(typeOfSQLNode) {
for i := 0; i < nodeVal.Len(); i++ {
m := nodeVal.Index(i)
rewrite(m, rewriter)
}
}
case reflect.Struct:
for i := 0; i < nodeVal.NumField(); i++ {
f := nodeVal.Field(i)
rewrite(f, rewriter)
}
case reflect.Ptr, reflect.Interface:
rewrite(nodeVal.Elem(), rewriter)
}
}
// type(1) | name length(1) | content length(1) | raw name bytes |
// 0x00 | content bytes
func (d *decodeState) shortBinary(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 := d.data[d.off : d.off+vlen]
d.off += vlen // value
if !v.IsValid() {
return
}
v.SetBytes(val)
}
func decodeSlice(v reflect.Value, x interface{}) {
t := v.Type()
if t.Elem().Kind() == reflect.Uint8 {
// Allow, but don't require, byte slices to be encoded as a single string.
if s, ok := x.(string); ok {
v.SetBytes([]byte(s))
return
}
}
// NOTE: Implicit indexing is currently done at the parseValues level,
// so if if an implicitKey reaches here it will always replace the last.
implicit := 0
for k, c := range getNode(x) {
var i int
if k == implicitKey {
i = implicit
implicit++
} else {
explicit, err := strconv.Atoi(k)
if err != nil {
panic(k + " is not a valid index for type " + t.String())
}
i = explicit
implicit = explicit + 1
}
// "Extend" the slice if it's too short.
if l := v.Len(); i >= l {
delta := i - l + 1
v.Set(reflect.AppendSlice(v, reflect.MakeSlice(t, delta, delta)))
}
decodeValue(v.Index(i), c)
}
}
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 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
}
// 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 (d *Decoder) bytesValue(value reflect.Value) error {
v, err := d.DecodeBytes()
if err != nil {
return err
}
value.SetBytes(v)
return nil
}
func (ep entityProtector) encrypt(field reflect.Value) {
switch field.Interface().(type) {
case []byte:
field.SetBytes(ep.cipher.Encrypt(field.Bytes()))
case string:
field.SetString(string(ep.cipher.Encrypt([]byte(field.String()))))
}
}
func decodeByteSlice(s *Stream, val reflect.Value) error {
b, err := s.Bytes()
if err != nil {
return wrapStreamError(err, val.Type())
}
val.SetBytes(b)
return nil
}
func decodeBytesValue(v reflect.Value, b []byte) error {
bs, err := decodeBytes(b)
if err != nil {
return err
}
v.SetBytes(bs)
return nil
}
func decodeRawValue(s *Stream, val reflect.Value) error {
r, err := s.Raw()
if err != nil {
return err
}
val.SetBytes(r)
return nil
}
func setStringValue(v reflect.Value, value string) (err error) {
s := value
// if type is []byte
if v.Kind() == reflect.Slice && v.Type().Elem().Kind() == reflect.Uint8 {
v.SetBytes([]byte(s))
return
}
switch v.Kind() {
case reflect.String:
v.SetString(s)
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
var n int64
n, err = strconv.ParseInt(s, 10, 64)
if err != nil {
return
}
if v.OverflowInt(n) {
err = fmt.Errorf("overflow int64 for %d.", n)
return
}
v.SetInt(n)
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
var n uint64
n, err = strconv.ParseUint(s, 10, 64)
if err != nil {
return
}
if v.OverflowUint(n) {
err = fmt.Errorf("overflow uint64 for %d.", n)
return
}
v.SetUint(n)
case reflect.Float32, reflect.Float64:
var n float64
n, err = strconv.ParseFloat(s, v.Type().Bits())
if err != nil {
return
}
if v.OverflowFloat(n) {
err = fmt.Errorf("overflow float64 for %d.", n)
return
}
v.SetFloat(n)
case reflect.Bool:
var n bool
n, err = strconv.ParseBool(s)
if err != nil {
return
}
v.SetBool(n)
default:
err = errors.New(fmt.Sprintf("value %+v can only been set to primary type but was %+v", value, v))
}
return
}
func parseBytesValue(v reflect.Value, str string) error {
val, err := base64.StdEncoding.DecodeString(str)
if err != nil {
return err
}
v.SetBytes(val)
return nil
}
func copyValue(dst reflect.Value, src []byte) (err error) {
if dst.Kind() == reflect.Ptr {
if dst.IsNil() {
dst.Set(reflect.New(dst.Type().Elem()))
}
dst = dst.Elem()
}
// Save accumulated data.
switch dst.Kind() {
case reflect.Invalid:
// Probably a commendst.
default:
return errors.New("cannot happen: unknown type " + dst.Type().String())
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
itmp, err := strconv.ParseInt(string(src), 10, dst.Type().Bits())
if err != nil {
return err
}
dst.SetInt(itmp)
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
utmp, err := strconv.ParseUint(string(src), 10, dst.Type().Bits())
if err != nil {
return err
}
dst.SetUint(utmp)
case reflect.Float32, reflect.Float64:
ftmp, err := strconv.ParseFloat(string(src), dst.Type().Bits())
if err != nil {
return err
}
dst.SetFloat(ftmp)
case reflect.Bool:
value, err := strconv.ParseBool(strings.TrimSpace(string(src)))
if err != nil {
return err
}
dst.SetBool(value)
case reflect.String:
dst.SetString(string(src))
case reflect.Slice:
if len(src) == 0 {
// non-nil to flag presence
src = []byte{}
}
dst.SetBytes(src)
case reflect.Struct:
if dst.Type() == timeType {
tv, err := time.Parse(time.RFC3339, string(src))
if err != nil {
return err
}
dst.Set(reflect.ValueOf(tv))
}
}
return nil
}
func mergeAny(out, in reflect.Value) {
if in.Type() == protoMessageType {
if !in.IsNil() {
if out.IsNil() {
out.Set(reflect.ValueOf(Clone(in.Interface().(Message))))
} else {
Merge(out.Interface().(Message), in.Interface().(Message))
}
}
return
}
switch in.Kind() {
case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64,
reflect.String, reflect.Uint32, reflect.Uint64:
out.Set(in)
case reflect.Ptr:
if in.IsNil() {
return
}
if out.IsNil() {
out.Set(reflect.New(in.Elem().Type()))
}
mergeAny(out.Elem(), in.Elem())
case reflect.Slice:
if in.IsNil() {
return
}
if in.Type().Elem().Kind() == reflect.Uint8 {
// []byte is a scalar bytes field, not a repeated field.
// Make a deep copy.
// Append to []byte{} instead of []byte(nil) so that we never end up
// with a nil result.
out.SetBytes(append([]byte{}, in.Bytes()...))
return
}
n := in.Len()
if out.IsNil() {
out.Set(reflect.MakeSlice(in.Type(), 0, n))
}
switch in.Type().Elem().Kind() {
case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64,
reflect.String, reflect.Uint32, reflect.Uint64:
out.Set(reflect.AppendSlice(out, in))
default:
for i := 0; i < n; i++ {
x := reflect.Indirect(reflect.New(in.Type().Elem()))
mergeAny(x, in.Index(i))
out.Set(reflect.Append(out, x))
}
}
case reflect.Struct:
mergeStruct(out, in)
default:
// unknown type, so not a protocol buffer
log.Printf("proto: don't know how to copy %v", in)
}
}
func decodePacketValue(buf []byte, v reflect.Value) (int, error) {
n := 0
switch v.Kind() {
default:
return n, ErrUnhandledFieldType
case reflect.Struct:
for i := 0; i < v.NumField(); i++ {
field := v.Field(i)
n2, err := decodePacketValue(buf[n:], field)
n += n2
if err != nil {
return n, err
}
}
case reflect.Bool:
v.SetBool(buf[n] != 0)
n += 1
case reflect.Int32:
v.SetInt(int64(binary.BigEndian.Uint32(buf[n : n+4])))
n += 4
case reflect.Int64:
v.SetInt(int64(binary.BigEndian.Uint64(buf[n : n+8])))
n += 8
case reflect.String:
ln := int(binary.BigEndian.Uint32(buf[n : n+4]))
v.SetString(string(buf[n+4 : n+4+ln]))
n += 4 + ln
case reflect.Slice:
switch v.Type().Elem().Kind() {
default:
count := int(binary.BigEndian.Uint32(buf[n : n+4]))
n += 4
values := reflect.MakeSlice(v.Type(), count, count)
v.Set(values)
for i := 0; i < count; i++ {
n2, err := decodePacketValue(buf[n:], values.Index(i))
n += n2
if err != nil {
return n, err
}
}
case reflect.Uint8:
ln := int(binary.BigEndian.Uint32(buf[n : n+4]))
if ln < 0 {
n += 4
v.SetBytes(nil)
} else {
bytes := make([]byte, ln)
copy(bytes, buf[n+4:n+4+ln])
v.SetBytes(bytes)
n += 4 + ln
}
}
}
return n, nil
}
func unmarshalString(s string, v reflect.Value, options tagOptions) {
u, v := indirectValue(v)
if u != nil {
err := u.UnmarshalText([]byte(s))
if err != nil {
panic(err)
}
if v.Type().ConvertibleTo(datetimeType) {
t := v.Addr().Convert(reflect.PtrTo(datetimeType)).Interface().(*time.Time)
if t.IsZero() {
*t = time.Time{}
}
}
return
}
switch v.Kind() {
case reflect.String:
if options.Has("string") {
t, err := strconv.Unquote(s)
if err != nil {
panic(err)
}
v.SetString(t)
break
}
v.SetString(s)
case reflect.Slice:
if v.Type().Elem().Kind() != reflect.Uint8 {
goto typeError
}
b := make([]byte, base64.StdEncoding.DecodedLen(len(s)))
n, err := base64.StdEncoding.Decode(b, []byte(s))
if err != nil {
panic(err)
}
v.SetBytes(b[:n])
case reflect.Bool,
reflect.Float32, reflect.Float64,
reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
if !options.Has("string") {
goto typeError
}
unmarshalQuoted(s, v)
case reflect.Interface:
if v.NumMethod() != 0 {
goto typeError
}
v.Set(reflect.ValueOf(s))
default:
goto typeError
}
return
typeError:
panic(&UnmarshalTypeError{fmt.Sprintf("string: %q", s), v.Type()})
}
// unmarshal for when rv's Kind is Slice
func unmarshalSlice(av *dynamodb.AttributeValue, rv reflect.Value) error {
switch {
case av.B != nil:
rv.SetBytes(av.B)
return nil
case av.L != nil:
slicev := reflect.MakeSlice(rv.Type(), 0, len(av.L))
for _, innerAV := range av.L {
innerRV := reflect.New(rv.Type().Elem()).Elem()
if err := unmarshalReflect(innerAV, innerRV); err != nil {
return err
}
slicev = reflect.Append(slicev, innerRV)
}
rv.Set(slicev)
return nil
// there's probably a better way to do these
case av.BS != nil:
slicev := reflect.MakeSlice(rv.Type(), 0, len(av.L))
for _, b := range av.BS {
innerRV := reflect.New(rv.Type().Elem()).Elem()
if err := unmarshalReflect(&dynamodb.AttributeValue{B: b}, innerRV); err != nil {
return err
}
slicev = reflect.Append(slicev, innerRV)
}
rv.Set(slicev)
return nil
case av.SS != nil:
slicev := reflect.MakeSlice(rv.Type(), 0, len(av.L))
for _, str := range av.SS {
innerRV := reflect.New(rv.Type().Elem()).Elem()
if err := unmarshalReflect(&dynamodb.AttributeValue{S: str}, innerRV); err != nil {
return err
}
slicev = reflect.Append(slicev, innerRV)
}
rv.Set(slicev)
return nil
case av.NS != nil:
slicev := reflect.MakeSlice(rv.Type(), 0, len(av.L))
for _, n := range av.NS {
innerRV := reflect.New(rv.Type().Elem()).Elem()
if err := unmarshalReflect(&dynamodb.AttributeValue{N: n}, innerRV); err != nil {
return err
}
slicev = reflect.Append(slicev, innerRV)
}
rv.Set(slicev)
return nil
}
return errors.New("dynamo: unmarshal slice: B, L, BS, SS, NS are nil")
}
// Handle decoding of slices
func (de *decoder) slice(slval reflect.Value, vb []byte) error {
// Find the element type, and create a temporary instance of it.
eltype := slval.Type().Elem()
val := reflect.New(eltype).Elem()
// Decide on the wiretype to use for decoding.
var wiretype int
switch eltype.Kind() {
case reflect.Bool, reflect.Int32, reflect.Int64,
reflect.Uint32, reflect.Uint64:
switch eltype {
case sfixed32type:
wiretype = 5 // Packed 32-bit representation
case sfixed64type:
wiretype = 1 // Packed 64-bit representation
case ufixed32type:
wiretype = 5 // Packed 32-bit representation
case ufixed64type:
wiretype = 1 // Packed 64-bit representation
default:
wiretype = 0 // Packed varint representation
}
case reflect.Float32:
wiretype = 5 // Packed 32-bit representation
case reflect.Float64:
wiretype = 1 // Packed 64-bit representation
case reflect.Uint8: // Unpacked byte-slice
slval.SetBytes(vb)
return nil
default: // Other unpacked repeated types
// Just unpack and append one value from vb.
if err := de.putvalue(2, val, 0, vb); err != nil {
return err
}
slval.Set(reflect.Append(slval, val))
return nil
}
// Decode packed values from the buffer and append them to the slice.
for len(vb) > 0 {
rem, err := de.value(wiretype, vb, val)
if err != nil {
return err
}
slval.Set(reflect.Append(slval, val))
vb = rem
}
return nil
}
func convertAssignBytes(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)
}
case reflect.Struct:
if buf := []byte(s); len(buf) == 0 {
err = nil
return
} else if d.CanAddr() {
addr := d.Addr().Interface()
if dc, ok := addr.(gob.GobDecoder); ok {
if err = dc.GobDecode(buf); err == nil {
return nil
}
} else if dc, ok := addr.(json.Unmarshaler); ok {
if err = dc.UnmarshalJSON(buf); err == nil {
return nil
}
} else if dc, ok := addr.(encoding.BinaryUnmarshaler); ok {
if err = dc.UnmarshalBinary(buf); err == nil {
return nil
}
}
}
err = cannotConvert(d, s)
default:
err = cannotConvert(d, s)
}
return
}
func decodeSlice(r io.Reader, v reflect.Value) (err error) {
switch v.Interface().(type) {
case []byte:
var result []byte
if result, err = read.Binary(r); err == nil {
v.SetBytes(result)
}
default:
err = decodeList(r, v)
}
return
}
func decodeBytesValue(d *Decoder, v reflect.Value) error {
c, err := d.readByte()
if err != nil {
return err
}
b, err := d.bytes(c, v.Bytes())
if err != nil {
return err
}
v.SetBytes(b)
return nil
}
func (f *decFnInfo) kSlice(rv reflect.Value) {
// A slice can be set from a map or array in stream.
currEncodedType := f.dd.currentEncodedType()
switch currEncodedType {
case valueTypeBytes, valueTypeString:
if f.ti.rtid == uint8SliceTypId || f.ti.rt.Elem().Kind() == reflect.Uint8 {
if bs2, changed2 := f.dd.decodeBytes(rv.Bytes()); changed2 {
rv.SetBytes(bs2)
}
return
}
}
containerLen, containerLenS := decContLens(f.dd, currEncodedType)
// an array can never return a nil slice. so no need to check f.array here.
if rv.IsNil() {
rv.Set(reflect.MakeSlice(f.ti.rt, containerLenS, containerLenS))
}
if containerLen == 0 {
return
}
if rvcap, rvlen := rv.Len(), rv.Cap(); containerLenS > rvcap {
if f.array { // !rv.CanSet()
decErr(msgDecCannotExpandArr, rvcap, containerLenS)
}
rvn := reflect.MakeSlice(f.ti.rt, containerLenS, containerLenS)
if rvlen > 0 {
reflect.Copy(rvn, rv)
}
rv.Set(rvn)
} else if containerLenS > rvlen {
rv.SetLen(containerLenS)
}
rtelem := f.ti.rt.Elem()
for rtelem.Kind() == reflect.Ptr {
rtelem = rtelem.Elem()
}
fn := f.d.getDecFn(rtelem)
for j := 0; j < containerLenS; j++ {
f.d.decodeValue(rv.Index(j), fn)
}
}
func (d *decoder) unmarshalBytes(size uint, offset uint, result reflect.Value) (uint, error) {
value, newOffset, err := d.decodeBytes(size, offset)
if err != nil {
return 0, err
}
switch result.Kind() {
default:
return newOffset, newUnmarshalTypeError(value, result.Type())
case reflect.Slice:
result.SetBytes(value)
return newOffset, nil
case reflect.Interface:
result.Set(reflect.ValueOf(value))
return newOffset, nil
}
}