Beispiel #1
0
// reflectSliceWithProperType does the opposite thing as setSliceWithProperType.
func reflectSliceWithProperType(key *Key, field reflect.Value, delim string) error {
	slice := field.Slice(0, field.Len())
	if field.Len() == 0 {
		return nil
	}

	var buf bytes.Buffer
	sliceOf := field.Type().Elem().Kind()
	for i := 0; i < field.Len(); i++ {
		switch sliceOf {
		case reflect.String:
			buf.WriteString(slice.Index(i).String())
		case reflect.Int, reflect.Int64:
			buf.WriteString(fmt.Sprint(slice.Index(i).Int()))
		case reflect.Uint, reflect.Uint64:
			buf.WriteString(fmt.Sprint(slice.Index(i).Uint()))
		case reflect.Float64:
			buf.WriteString(fmt.Sprint(slice.Index(i).Float()))
		case reflectTime:
			buf.WriteString(slice.Index(i).Interface().(time.Time).Format(time.RFC3339))
		default:
			return fmt.Errorf("unsupported type '[]%s'", sliceOf)
		}
		buf.WriteString(delim)
	}
	key.SetValue(buf.String()[:buf.Len()-1])
	return nil
}
Beispiel #2
0
func decComplex128Array(state *decoderState, v reflect.Value, length int, ovfl error) bool {
	// Can only slice if it is addressable.
	if !v.CanAddr() {
		return false
	}
	return decComplex128Slice(state, v.Slice(0, v.Len()), length, ovfl)
}
Beispiel #3
0
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}
}
Beispiel #4
0
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)
	}
}
Beispiel #5
0
// grow grows the slice s so that it can hold extra more values, allocating
// more capacity if needed. It also returns the old and new slice lengths.
func grow(s reflect.Value, extra int) (reflect.Value, int, int) {
	i0 := s.Len()
	i1 := i0 + extra
	if i1 < i0 {
		panic("reflect.Append: slice overflow")
	}
	m := s.Cap()
	if i1 <= m {
		return s.Slice(0, i1), i0, i1
	}
	if m == 0 {
		m = extra
	} else {
		for m < i1 {
			if i0 < 1024 {
				m += m
			} else {
				m += m / 4
			}
		}
	}
	t := reflect.MakeSlice(s.Type(), i1, m)
	reflect.Copy(t, s)
	return t, i0, i1
}
Beispiel #6
0
func (d *decoder) sequence(n *node, out reflect.Value) (good bool) {
	l := len(n.children)

	var iface reflect.Value
	switch out.Kind() {
	case reflect.Slice:
		out.Set(reflect.MakeSlice(out.Type(), l, l))
	case reflect.Interface:
		// No type hints. Will have to use a generic sequence.
		iface = out
		out = settableValueOf(make([]interface{}, l))
	default:
		d.terror(n, yaml_SEQ_TAG, out)
		return false
	}
	et := out.Type().Elem()

	j := 0
	for i := 0; i < l; i++ {
		e := reflect.New(et).Elem()
		if ok := d.unmarshal(n.children[i], e); ok {
			out.Index(j).Set(e)
			j++
		}
	}
	out.Set(out.Slice(0, j))
	if iface.IsValid() {
		iface.Set(out)
	}
	return true
}
Beispiel #7
0
func encodeByteArray(b []byte, v reflect.Value) []byte {
	n := v.Len()

	if n < (0xec - 0xe0) {
		b = append(b, byte(0xe0+n))
	} else {
		b = encodeK4(b, 0xec, uint64(n))
	}

	// Fast path for when the array is addressable (which it almost
	// always will be).
	if v.CanAddr() {
		return append(b, v.Slice(0, n).Bytes()...)
	}

	i := len(b)
	j := i + n

	if j > cap(b) {
		t := make([]byte, i, j)
		copy(t, b)
		b = t
	}

	reflect.Copy(reflect.ValueOf(b[i:j]), v)
	return b[:j]
}
func Slice(expectedSlice reflect.Value, actualSlice reflect.Value) (bool, diff.Difference) {
	for i := 0; i < actualSlice.Len(); i++ {
		if i >= expectedSlice.Len() {
			return false, diff.SliceExtraElements{
				ExtraElements: actualSlice.Slice(i, actualSlice.Len()),
				AllElements:   actualSlice,
			}
		}

		equal, difference := Compare(expectedSlice.Index(i).Interface(), actualSlice.Index(i).Interface())
		if !equal {
			return false, diff.SliceNested{
				Index:            i,
				NestedDifference: difference,
			}
		}
	}

	if expectedSlice.Len() > actualSlice.Len() {
		return false, diff.SliceMissingElements{
			MissingElements: expectedSlice.Slice(actualSlice.Len(), expectedSlice.Len()),
			AllElements:     actualSlice,
		}
	}

	return true, diff.NoDifference{}
}
Beispiel #9
0
// reflectWithProperType does the opposite thing with setWithProperType.
func reflectWithProperType(t reflect.Type, key *Key, field reflect.Value, delim string) error {
	switch t.Kind() {
	case reflect.String:
		key.SetValue(field.String())
	case reflect.Bool,
		reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
		reflect.Float64,
		reflectTime:
		key.SetValue(fmt.Sprint(field))
	case reflect.Slice:
		vals := field.Slice(0, field.Len())
		if field.Len() == 0 {
			return nil
		}

		var buf bytes.Buffer
		isTime := fmt.Sprint(field.Type()) == "[]time.Time"
		for i := 0; i < field.Len(); i++ {
			if isTime {
				buf.WriteString(vals.Index(i).Interface().(time.Time).Format(time.RFC3339))
			} else {
				buf.WriteString(fmt.Sprint(vals.Index(i)))
			}
			buf.WriteString(delim)
		}
		key.SetValue(buf.String()[:buf.Len()-1])
	default:
		return fmt.Errorf("unsupported type '%s'", t)
	}
	return nil
}
Beispiel #10
0
func decodeSliceValue(d *Decoder, v reflect.Value) error {
	n, err := d.DecodeArrayLen()
	if err != nil {
		return err
	}

	if n == -1 {
		v.Set(reflect.Zero(v.Type()))
		return nil
	}
	if n == 0 && v.IsNil() {
		v.Set(reflect.MakeSlice(v.Type(), 0, 0))
		return nil
	}

	if v.Cap() >= n {
		v.Set(v.Slice(0, n))
	} else if v.Len() < v.Cap() {
		v.Set(v.Slice(0, v.Cap()))
	}

	for i := 0; i < n; i++ {
		if i >= v.Len() {
			v.Set(growSliceValue(v, n))
		}
		sv := v.Index(i)
		if err := d.DecodeValue(sv); err != nil {
			return err
		}
	}

	return nil
}
Beispiel #11
0
func encComplex64Array(state *encoderState, v reflect.Value) bool {
	// Can only slice if it is addressable.
	if !v.CanAddr() {
		return false
	}
	return encComplex64Slice(state, v.Slice(0, v.Len()))
}
Beispiel #12
0
func (encoder *Encoder) encode(v reflect.Value) error {

	switch v.Kind() {
	case reflect.Map:
		return encoder.encodeMap(v)
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
		return encoder.encodeUint(v.Uint())
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		return encoder.encodeInt(v.Int())
	case reflect.String:
		return encoder.encodeString(v.String())
	case reflect.Array:
		v = v.Slice(0, v.Len())
		return encoder.encodeSlice(v)
	case reflect.Slice:
		return encoder.encodeSlice(v)
	case reflect.Float64, reflect.Float32:
		return encoder.encodeFloat(v.Float())
	case reflect.Interface:
		v = reflect.ValueOf(v.Interface())
		return encoder.encode(v)
	case reflect.Ptr:
		if v.IsNil() {
			return encoder.encodeNull()
		}
		vv := reflect.Indirect(v)
		if vv.Kind() == reflect.Struct {
			return encoder.encodeStruct(v)
		}
		return encoder.encode(vv)
	}

	return errors.New("unsupported type:" + v.Type().String())
}
Beispiel #13
0
// encodeFixedArray writes the XDR encoded representation of each element
// in the passed array represented by the reflection value to the encapsulated
// writer and returns the number of bytes written.  The ignoreOpaque flag
// controls whether or not uint8 (byte) elements should be encoded individually
// or as a fixed sequence of opaque data.
//
// A MarshalError is returned if any issues are encountered while encoding
// the array elements.
//
// Reference:
// 	RFC Section 4.12 - Fixed-Length Array
// 	Individually XDR encoded array elements
func (enc *Encoder) encodeFixedArray(v reflect.Value, ignoreOpaque bool) (int, error) {
	// Treat [#]byte (byte is alias for uint8) as opaque data unless ignored.
	if !ignoreOpaque && v.Type().Elem().Kind() == reflect.Uint8 {
		// Create a slice of the underlying array for better efficiency
		// when possible.  Can't create a slice of an unaddressable
		// value.
		if v.CanAddr() {
			return enc.EncodeFixedOpaque(v.Slice(0, v.Len()).Bytes())
		}

		// When the underlying array isn't addressable fall back to
		// copying the array into a new slice.  This is rather ugly, but
		// the inability to create a constant slice from an
		// unaddressable array is a limitation of Go.
		slice := make([]byte, v.Len(), v.Len())
		reflect.Copy(reflect.ValueOf(slice), v)
		return enc.EncodeFixedOpaque(slice)
	}

	// Encode each array element.
	var n int
	for i := 0; i < v.Len(); i++ {
		n2, err := enc.encode(v.Index(i))
		n += n2
		if err != nil {
			return n, err
		}
	}

	return n, nil
}
Beispiel #14
0
func DeleteSliceElementVal(sliceVal reflect.Value, idx int) reflect.Value {
	if idx < 0 || idx >= sliceVal.Len() {
		return sliceVal
	}
	before := sliceVal.Slice(0, idx)
	after := sliceVal.Slice(idx+1, sliceVal.Len())
	sliceVal = reflect.AppendSlice(before, after)
	return sliceVal
}
Beispiel #15
0
func reflectAppend(i int, iface interface{}, slicev reflect.Value) reflect.Value {
	iv := reflect.ValueOf(iface)
	if slicev.Len() == i {
		slicev = reflect.Append(slicev, iv)
		slicev = slicev.Slice(0, slicev.Cap())
	} else {
		slicev.Index(i).Set(iv)
	}
	return slicev
}
Beispiel #16
0
// Sets the length of a slice by sub-slicing a slice that's too long,
// or appending empty fields if slice is too short.
func SetSliceLengh(slice reflect.Value, length int) reflect.Value {
	if length > slice.Len() {
		for i := slice.Len(); i < length; i++ {
			slice = AppendEmptySliceField(slice)
		}
	} else if length < slice.Len() {
		slice = slice.Slice(0, length)
	}
	return slice
}
Beispiel #17
0
// Create the pages we expect to see.
func wantedPages(vWant reflect.Value, pageSize int) []interface{} {
	var pages []interface{}
	for i, j := 0, pageSize; i < vWant.Len(); i, j = j, j+pageSize {
		if j > vWant.Len() {
			j = vWant.Len()
		}
		pages = append(pages, vWant.Slice(i, j).Interface())
	}
	return pages
}
Beispiel #18
0
func slicefmt(v reflect.Value) string {
	length := v.Len()
	slice := v.Slice(0, length)

	str := "["
	for i := 0; i < length; i += 1 {
		str = fmt.Sprintf("%s%v, ", str, format(slice.Index(i)))
	}
	str += "\b\b]"
	return fmt.Sprintf("%v(%s[%d])", str, v.Type().String(), length)
}
Beispiel #19
0
func nextSlice(s Stream, sliceValue reflect.Value, toInterface func(reflect.Value) interface{}) bool {
	length := sliceValue.Len()
	numCopied := copyToSlice(s, sliceValue, toInterface)
	if numCopied == 0 {
		return false
	}
	if numCopied < length {
		sliceValue.Set(sliceValue.Slice(0, numCopied))
	}
	return true
}
Beispiel #20
0
func slicefmt(v reflect.Value) (string, string) {
	length := v.Len()
	slice := v.Slice(0, length)

	str := "["
	for i := 0; i < length; i += 1 {
		v, _ := format(slice.Index(i))
		str = fmt.Sprintf("%s%v, ", str, v)
	}
	str += "\b\b]"
	return fmt.Sprintf("%v", str), fmt.Sprintf("%s[%d]", v.Type().String(), length)
}
Beispiel #21
0
func setString(slice reflect.Value, b []byte) {

	switch slice.Kind() {

	case reflect.Array, reflect.Slice:
		reflect.Copy(slice.Slice(0, slice.Len()), reflect.ValueOf(b))
	case reflect.String:
		slice.SetString(string(b))
	default:
		panic("bad type for setString: " + slice.Kind().String())
	}
}
Beispiel #22
0
func writeByteArray(val reflect.Value, w *encbuf) error {
	if !val.CanAddr() {
		// Slice requires the value to be addressable.
		// Make it addressable by copying.
		copy := reflect.New(val.Type()).Elem()
		copy.Set(val)
		val = copy
	}
	size := val.Len()
	slice := val.Slice(0, size).Bytes()
	w.encodeString(slice)
	return nil
}
Beispiel #23
0
func (f *protoFuzzer) Fuzz(v reflect.Value) {
	if !v.CanSet() {
		return
	}

	switch v.Kind() {
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		f.FuzzInt(v)
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
		f.FuzzUint(v)
	case reflect.String:
		str := ""
		for i := 0; i < v.Len(); i++ {
			str = str + string(' '+rune(f.r.Intn(94)))
		}
		v.SetString(str)
		return
	case reflect.Ptr:
		if !v.IsNil() {
			f.Fuzz(v.Elem())
		}
		return
	case reflect.Slice:
		mode := f.r.Intn(3)
		switch {
		case v.Len() > 0 && mode == 0:
			// fuzz entry
			f.Fuzz(v.Index(f.r.Intn(v.Len())))
		case v.Len() > 0 && mode == 1:
			// remove entry
			entry := f.r.Intn(v.Len())
			pre := v.Slice(0, entry)
			post := v.Slice(entry+1, v.Len())
			v.Set(reflect.AppendSlice(pre, post))
		default:
			// add entry
			entry := reflect.MakeSlice(v.Type(), 1, 1)
			f.Fuzz(entry) // XXX fill all fields
			v.Set(reflect.AppendSlice(v, entry))
		}
		return
	case reflect.Struct:
		f.Fuzz(v.Field(f.r.Intn(v.NumField())))
		return
	case reflect.Map:
		// TODO fuzz map
	default:
		panic(fmt.Sprintf("Not fuzzing %v %+v", v.Kind(), v))
	}
}
Beispiel #24
0
func encodeByteArrayValue(e *Encoder, v reflect.Value) error {
	if err := e.encodeBytesLen(v.Len()); err != nil {
		return err
	}

	if v.CanAddr() {
		b := v.Slice(0, v.Len()).Bytes()
		return e.write(b)
	}

	b := make([]byte, v.Len())
	reflect.Copy(reflect.ValueOf(b), v)
	return e.write(b)
}
Beispiel #25
0
// decUint8Slice decodes a byte slice and stores in value a slice header
// describing the data.
// uint8 slices are encoded as an unsigned count followed by the raw bytes.
func decUint8Slice(i *decInstr, state *decoderState, value reflect.Value) {
	n, ok := state.getLength()
	if !ok {
		errorf("bad %s slice length: %d", value.Type(), n)
	}
	if value.Cap() < n {
		value.Set(reflect.MakeSlice(value.Type(), n, n))
	} else {
		value.Set(value.Slice(0, n))
	}
	if _, err := state.b.Read(value.Bytes()); err != nil {
		errorf("error decoding []byte: %s", err)
	}
}
Beispiel #26
0
func main() {
	var a []int
	var value reflect.Value = reflect.ValueOf(&a)

	//判断指针是否指向内存地址
	if !value.CanSet() {
		value = value.Elem() //使指针指向内存地址
	}

	value = reflect.AppendSlice(value, reflect.ValueOf([]int{1, 2}))                //支持切片
	value = reflect.AppendSlice(value, reflect.ValueOf([]int{3, 4, 5, 6, 7, 8, 9})) //支持切片
	fmt.Println(value.Kind(), value.Slice(0, value.Len()).Interface())
	/////  >> slice [1 2 3 4 5 6 7 8 9]

}
Beispiel #27
0
func (f *encFnInfo) kArray(rv reflect.Value) {
	// We cannot share kSlice method, because the array may be non-addressable.
	// E.g. type struct S{B [2]byte}; Encode(S{}) will bomb on "panic: slice of unaddressable array".
	// So we have to duplicate the functionality here.
	// f.e.encodeValue(rv.Slice(0, rv.Len()))
	// f.kSlice(rv.Slice(0, rv.Len()))

	l := rv.Len()
	// Handle an array of bytes specially (in line with what is done for slices)
	rtelem := f.ti.rt.Elem()
	if rtelem.Kind() == reflect.Uint8 {
		if l == 0 {
			f.ee.encodeStringBytes(c_RAW, nil)
			return
		}
		var bs []byte
		if rv.CanAddr() {
			bs = rv.Slice(0, l).Bytes()
		} else {
			bs = make([]byte, l)
			for i := 0; i < l; i++ {
				bs[i] = byte(rv.Index(i).Uint())
			}
		}
		f.ee.encodeStringBytes(c_RAW, bs)
		return
	}

	if f.ti.mbs {
		if l%2 == 1 {
			encErr("mapBySlice: invalid length (must be divisible by 2): %v", l)
		}
		f.ee.encodeMapPreamble(l / 2)
	} else {
		f.ee.encodeArrayPreamble(l)
	}
	if l == 0 {
		return
	}
	for rtelem.Kind() == reflect.Ptr {
		rtelem = rtelem.Elem()
	}
	fn := f.e.getEncFn(rtelem)
	for j := 0; j < l; j++ {
		// TODO: Consider perf implication of encoding odd index values as symbols if type is string
		f.e.encodeValue(rv.Index(j), fn)
	}
}
Beispiel #28
0
func DeleteEmptySliceElementsVal(sliceVal reflect.Value) reflect.Value {
	if sliceVal.Kind() != reflect.Slice {
		panic("Argument is not a slice: " + sliceVal.String())
	}
	zeroVal := reflect.Zero(sliceVal.Type().Elem())
	for i := 0; i < sliceVal.Len(); i++ {
		elemVal := sliceVal.Index(i)
		if reflect.DeepEqual(elemVal.Interface(), zeroVal.Interface()) {
			before := sliceVal.Slice(0, i)
			after := sliceVal.Slice(i+1, sliceVal.Len())
			sliceVal = reflect.AppendSlice(before, after)
			i--
		}
	}
	return sliceVal
}
Beispiel #29
0
func (e *Encoder) encodeBytes(v reflect.Value, ln int) error {
	if ln <= 0xff {
		e.WriteByte(0xc4)
		e.WriteByte(byte(ln))
	} else if ln <= 0xffff {
		e.WriteByte(0xc5)
		binary.Write(e.writer, binary.BigEndian, uint16(ln))
	} else if ln <= 0xffffffff {
		e.WriteByte(0xc6)
		binary.Write(e.writer, binary.BigEndian, uint16(ln))
	} else {
		return fmt.Errorf("bytes overflow length: %d", ln)
	}
	e.writer.Write(v.Slice(0, ln).Bytes())
	return nil
}
Beispiel #30
0
func decodeByteArray(b []byte, v reflect.Value) []byte {
	var n uint64

	switch k := b[0]; {
	case k == 0x10:
		return b[1:]
	case 0xe0 <= k && k <= 0xeb:
		n, b = uint64(k-0xe0), b[1:]
	case 0xe0 <= k && k <= 0xef:
		n, b = decodeK4(b, 0xec)
	default:
		throwf("binn: cannot unmarshal %s into %s", describe(b), v.Type())
	}

	copy(v.Slice(0, v.Len()).Bytes(), b[:n])
	return b[n:]
}