Пример #1
0
func (t *TDecoder) decode(val reflect.Value) (e error) {
	var (
		part []byte
		bt   byte
	)
	switch val.Kind() {
	case reflect.Uint8:
		bt, e = t.buf.ReadByte()
		if e == nil {
			*(*uint8)(val.Ptr()) = uint8(bt)
		}
	case reflect.Uint16:
		part, e = t.buf.ReadNext(WORD16)
		if e == nil {
			*(*uint16)(val.Ptr()) = Pack.Uint16(part)
		}
	case reflect.Uint32:
		part, e = t.buf.ReadNext(WORD32)
		if e == nil {
			*(*uint32)(val.Ptr()) = Pack.Uint32(part)
		}
	case reflect.Uint64:
		part, e = t.buf.ReadNext(WORD64)
		if e == nil {
			*(*uint64)(val.Ptr()) = Pack.Uint64(part)
		}
	case reflect.Uint:
		part, e = t.buf.ReadNext(WORD64)
		if e == nil {
			*(*uint)(val.Ptr()) = uint(Pack.Uint64(part))
		}
	case reflect.Int8:
		bt, e = t.buf.ReadByte()
		if e == nil {
			*(*int8)(val.Ptr()) = int8(bt)
		}
	case reflect.Int16:
		part, e = t.buf.ReadNext(WORD16)
		if e == nil {
			*(*int16)(val.Ptr()) = int16(Pack.Uint16(part))
		}
	case reflect.Int32:
		part, e = t.buf.ReadNext(WORD32)
		if e == nil {
			*(*int32)(val.Ptr()) = int32(Pack.Uint32(part))
		}
	case reflect.Int64:
		part, e = t.buf.ReadNext(WORD64)
		if e == nil {
			*(*int64)(val.Ptr()) = int64(Pack.Uint64(part))
		}
	case reflect.Int:
		part, e = t.buf.ReadNext(WORD64)
		if e == nil {
			*(*int)(val.Ptr()) = int(Pack.Uint64(part))
		}
	case reflect.Float32:
		part, e = t.buf.ReadNext(WORD32)
		if e == nil {
			*(*float32)(val.Ptr()) = math.Float32frombits(Pack.Uint32(part))
		}
	case reflect.Float64:
		part, e = t.buf.ReadNext(WORD64)
		if e == nil {
			*(*float64)(val.Ptr()) = math.Float64frombits(Pack.Uint64(part))
		}
	case reflect.Complex64:
		part, e = t.buf.ReadNext(WORD64)
		if e == nil {
			*(*complex64)(val.Ptr()) = Complex64(part)
		}
	case reflect.Complex128:
		part, e = t.buf.ReadNext(16)
		if e == nil {
			*(*complex128)(val.Ptr()) = Complex128(part)
		}
	case reflect.Bool:
		bt, e = t.buf.ReadByte()
		if bt != 0 {
			*(*bool)(val.Ptr()) = true
		}
	case reflect.String:
		part, e = t.buf.ReadNext(WORD32)
		if e != nil {
			return
		}
		ln := int(Pack.Uint32(part))

		if ln == 0 {
			*(*string)(val.Ptr()) = ""
			return
		}
		part, e = t.buf.ReadNext(ln)
		if e == nil {
			*(*string)(val.Ptr()) = string(part)
		}

	case reflect.Array:
		// get length
		part, e = t.buf.ReadNext(WORD32)
		if e != nil {
			return
		}
		ln := int(Pack.Uint32(part))
		for i := 0; i < ln; i++ {
			e = t.decode(val.Index(i))
			if e != nil {
				return
			}
		}
	case reflect.Slice:
		// check nil
		bt, e = t.buf.ReadByte()
		if e != nil || bt == 0 {
			return
		}
		// get length
		part, e = t.buf.ReadNext(WORD32)
		if e != nil {
			return
		}
		ln := int(Pack.Uint32(part))

		if val.Type().Elem().Kind() == reflect.Uint8 {
			part, e = t.buf.ReadNext(ln)
			if e != nil {
				return
			}
			*(*[]byte)(val.Ptr()) = part
		} else {
			if val.IsNil() || val.Cap() < ln {
				val.Set(reflect.MakeSlice(val.Type(), ln, ln))
			} else {
				val.SetLen(ln)
			}
			for i := 0; i < ln; i++ {
				e = t.decode(val.Index(i))
				if e != nil {
					return
				}
			}
		}
	case reflect.Ptr:
		bt, e = t.buf.ReadByte()
		if e != nil {
			return
		}
		// if nil
		if bt == 0 {
			val.Set(reflect.Zero(val.Type()))
			return
		}
		// interface
		if val.Elem().Kind() == reflect.Invalid {
			val.Set(reflect.New(val.Type().Elem()))
		}

		val = val.Elem()
		e = t.decode(val)
	case reflect.Struct:
		vType := val.Type()
		if vType == TimeType {
			part, e = t.buf.ReadNext(WORD64)
			if e != nil {
				return
			}
			val.Set(reflect.ValueOf(Time(part)))
		} else {
			ln := val.NumField()
			for i := 0; i < ln; i++ {
				if vType.Field(i).PkgPath != "" {
					continue
				}
				e = t.decode(val.Field(i))
				if e != nil {
					return
				}
			}
		}
	case reflect.Map:
		bt, e = t.buf.ReadByte()
		// if nil
		if e != nil || bt == 0 {
			return
		}
		// get len
		part, e = t.buf.ReadNext(WORD32)
		if e != nil {
			return
		}
		ln := int(Pack.Uint32(part))

		vtype := val.Type()

		if val.IsNil() {
			val.Set(reflect.MakeMap(vtype))
		}
		var (
			mapKey, mapVal reflect.Value
		)

		for i := 0; i < ln; i++ {
			mapVal = reflect.New(vtype.Elem()).Elem()
			mapKey = reflect.New(vtype.Key()).Elem()
			e = t.decode(mapKey)
			if e != nil {
				return
			}
			e = t.decode(mapVal)
			if e != nil {
				return
			}
			val.SetMapIndex(mapKey, mapVal)
		}
	case reflect.Interface:
		// check nil
		bt, e = t.buf.ReadByte()
		if e != nil {
			return
		}
		if bt == 0 {
			val.Set(reflect.Zero(val.Type()))
			return
		}

		// get type name
		bt, e = t.buf.ReadByte()
		if e != nil {
			return
		}
		part, e = t.buf.ReadNext(int(bt))
		if e != nil {
			return
		}

		vType, ok := t.typeBase[string(part)]
		if !ok {
			e = errors.New("type '" + string(part) + "' not found, you need to register.")
			return
		}
		valInner := reflect.New(vType).Elem()
		e = t.decode(valInner)
		if e != nil {
			return
		}
		val.Set(valInner)
	}
	return
}