// return the next n permuations, if n>p.Left(),return all the left permuations // if all permutaions generated or n is illegal(n<=0),return a empty slice func (p *Permutator) NextN(count int) interface{} { if count <= 0 || p.left() == 0 { return reflect.MakeSlice(reflect.SliceOf(p.value.Type()), 0, 0).Interface() } cap := p.left() if cap > count { cap = count } result := reflect.MakeSlice(reflect.SliceOf(p.value.Type()), cap, cap) length := 0 for index := 0; index < cap; index++ { if _, ok := p.Next(); ok { length++ list := p.copySliceValue() result.Index(index).Set(list) } } list := reflect.MakeSlice(result.Type(), length, length) reflect.Copy(list, result) return list.Interface() }
// Remove removes the first occurence of the given val. It returns true // if an element was removed, false otherwise. Note that the first argument // must a pointer to a slice, while the second one must be a valid element // of the slice. Otherwise, this function will panic. func Remove(slicePtr interface{}, val interface{}) bool { s := reflect.ValueOf(slicePtr) if s.Kind() != reflect.Ptr || s.Type().Elem().Kind() != reflect.Slice { panic(fmt.Errorf("first argument to Remove must be pointer to slice, not %T", slicePtr)) } if s.IsNil() { return false } itr := s.Elem() v := reflect.ValueOf(val) if itr.Type().Elem() != v.Type() { panic(fmt.Errorf("second argument to Remove must be %s, not %s", itr.Type().Elem(), v.Type())) } vi := v.Interface() for ii := 0; ii < itr.Len(); ii++ { if reflect.DeepEqual(itr.Index(ii).Interface(), vi) { newSlice := reflect.MakeSlice(itr.Type(), itr.Len()-1, itr.Len()-1) reflect.Copy(newSlice, itr.Slice(0, ii)) reflect.Copy(newSlice.Slice(ii, newSlice.Len()), itr.Slice(ii+1, itr.Len())) s.Elem().Set(newSlice) return true } } return false }
func main() { src := reflect.ValueOf([]int{1, 2, 3}) /* make sure the dest space is larger than src */ dest := reflect.ValueOf([]int{10, 20, 30}) cnt := reflect.Copy(dest, src) data := dest.Interface().([]int) data[0] = 100 fmt.Println(cnt) fmt.Println(src) fmt.Println(dest) elmt := map[string]int{"age": 10} data2 := make([]map[string]int, 1) data2[0] = elmt src2 := reflect.ValueOf(data2) dest2 := reflect.ValueOf(make([]map[string]int, 1)) cnt2 := reflect.Copy(dest2, src2) data2[0]["age"] = 100 /* they share the same map */ fmt.Println(cnt2) fmt.Println(src2) fmt.Println(dest2) }
func (this *SpecificDatumReader) mapArray(field Schema, reflectField reflect.Value, dec Decoder) (reflect.Value, error) { if arrayLength, err := dec.ReadArrayStart(); err != nil { return reflect.ValueOf(arrayLength), err } else { array := reflect.MakeSlice(reflectField.Type(), 0, 0) for { arrayPart := reflect.MakeSlice(reflectField.Type(), int(arrayLength), int(arrayLength)) var i int64 = 0 for ; i < arrayLength; i++ { val, err := this.readValue(field.(*ArraySchema).Items, arrayPart.Index(int(i)), dec) if err != nil { return reflect.ValueOf(arrayLength), err } if val.Kind() == reflect.Ptr { arrayPart.Index(int(i)).Set(val.Elem()) } else { arrayPart.Index(int(i)).Set(val) } } //concatenate arrays concatArray := reflect.MakeSlice(reflectField.Type(), array.Len()+int(arrayLength), array.Cap()+int(arrayLength)) reflect.Copy(concatArray, array) reflect.Copy(concatArray, arrayPart) array = concatArray arrayLength, err = dec.ArrayNext() if err != nil { return reflect.ValueOf(arrayLength), err } else if arrayLength == 0 { break } } return array, nil } }
func (s RSlice) overwrite(offset int, source *reflect.Value) { if offset == 0 { reflect.Copy(*s.Value, *source) } else { reflect.Copy(s.Slice(offset, s.Len()), *source) } }
//return the next n permuations, if n>p.Left(),return all the left permuations //if all permutaions generated or n is illegal(n<=0),return a empty slice func (p *Permutator) NextN(n int) interface{} { <-p.idle //if n<=0 or we generate all pemutations,just return a empty slice if n <= 0 || p.left() == 0 { p.idle <- true return reflect.MakeSlice(reflect.SliceOf(p.value.Type()), 0, 0).Interface() } var i, j int cap := p.left() if cap > n { cap = n } result := reflect.MakeSlice(reflect.SliceOf(p.value.Type()), cap, cap) if p.length == 1 { p.index++ l := reflect.MakeSlice(p.value.Type(), p.length, p.length) reflect.Copy(l, p.value) p.idle <- true result.Index(0).Set(l) return result.Interface() } if p.index == 1 { p.index++ l := reflect.MakeSlice(p.value.Type(), p.length, p.length) reflect.Copy(l, p.value) result.Index(0).Set(l) } for k := 1; k < cap; k++ { for i = p.length - 2; i >= 0; i-- { if p.less(p.value.Index(i).Interface(), p.value.Index(i+1).Interface()) { break } } for j = p.length - 1; j >= 0; j-- { if p.less(p.value.Index(i).Interface(), p.value.Index(j).Interface()) { break } } //swap temp := reflect.ValueOf(p.value.Index(i).Interface()) p.value.Index(i).Set(p.value.Index(j)) p.value.Index(j).Set(temp) //reverse reverse(p.value, i+1, p.length-1) //increase the counter p.index++ l := reflect.MakeSlice(p.value.Type(), p.length, p.length) reflect.Copy(l, p.value) result.Index(k).Set(l) } p.idle <- true return result.Interface() }
func TestRaceReflectCopyWW(t *testing.T) { ch := make(chan bool, 1) a := make([]byte, 2) v := reflect.ValueOf(a) go func() { reflect.Copy(v, v) ch <- true }() reflect.Copy(v, v) <-ch }
// 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 }
func (fs *FlagSet) parseNextItem(args []string) ([]string, error) { if strings.HasPrefix(args[0], "--") { return fs.parseLongFlag(args) } else if strings.HasPrefix(args[0], "-") { return fs.parseShortFlagCluster(args) } if fs.Verbs != nil { verb, ok := fs.Verbs[args[0]] if !ok { return args, fmt.Errorf("Unknown verb: %s", args[0]) } err := verb.Parse(args[1:]) if err != nil { return args, err } return []string{}, nil } if fs.remainderFlag != nil { remainder := reflect.MakeSlice(fs.remainderFlag.value.Type(), len(args), len(args)) reflect.Copy(remainder, reflect.ValueOf(args)) fs.remainderFlag.value.Set(remainder) return []string{}, nil } return args, fmt.Errorf("Invalid trailing arguments: %v", args) }
func decodeSlice(d *decodeState, kind int, value reflect.Value) { if kind != kindArray { d.saveErrorAndSkip(kind, value.Type()) return } v := value.(*reflect.SliceValue) t := v.Type().(*reflect.SliceType) offset := d.beginDoc() i := 0 for { kind, _ := d.scanKindName() if kind == 0 { break } if i >= v.Cap() { newcap := v.Cap() + v.Cap()/2 if newcap < 4 { newcap = 4 } newv := reflect.MakeSlice(t, v.Len(), newcap) reflect.Copy(newv, v) v.Set(newv) } if i >= v.Len() { v.SetLen(i + 1) } d.decodeValue(kind, v.Elem(i)) i += 1 } d.endDoc(offset) }
/* Create a new memory container and copy contents across to it. Returns nil when reallocation fails. */ func Reallocate(container interface{}, length, capacity int) (r interface{}) { switch c := container.(type) { case Resizeable: c.Reallocate(length, capacity) r = c default: if c := reflect.ValueOf(container); c.Kind() == reflect.Slice { if length > capacity { length = capacity } if c.Cap() != capacity { n := reflect.MakeSlice(c.Type(), length, capacity) reflect.Copy(n, c) c = n } if c.Len() != length { c = makeAddressable(c) c.SetLen(length) } r = c.Interface() } } return }
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 ArraySort(data interface{}) interface{} { //建立一份拷贝数据 dataValue := reflect.ValueOf(data) dataType := dataValue.Type() dataValueLen := dataValue.Len() dataResult := reflect.MakeSlice(dataType, dataValueLen, dataValueLen) reflect.Copy(dataResult, dataValue) //排序 dataElemType := dataType.Elem() var result interface{} if dataElemType.Kind() == reflect.Int { intArray := dataResult.Interface().([]int) sort.Sort(sort.IntSlice(intArray)) result = intArray } else if dataElemType.Kind() == reflect.String { stringArray := dataResult.Interface().([]string) sort.Sort(sort.StringSlice(stringArray)) result = stringArray } else { panic("invalid sort type " + fmt.Sprintf("%v", dataElemType)) } return result }
func (p *Decoder) unmarshalArray(pval *plistValue, val reflect.Value) { subvalues := pval.value.([]*plistValue) var n int if val.Kind() == reflect.Slice { // Slice of element values. // Grow slice. cnt := len(subvalues) + val.Len() if cnt >= val.Cap() { ncap := 2 * cnt if ncap < 4 { ncap = 4 } new := reflect.MakeSlice(val.Type(), val.Len(), ncap) reflect.Copy(new, val) val.Set(new) } n = val.Len() val.SetLen(cnt) } else if val.Kind() == reflect.Array { if len(subvalues) > val.Cap() { panic(fmt.Errorf("plist: attempted to unmarshal %d values into an array of size %d", len(subvalues), val.Cap())) } } else { panic(&incompatibleDecodeTypeError{val.Type(), pval.kind}) } // Recur to read element into slice. for _, sval := range subvalues { p.unmarshal(sval, val.Index(n)) n++ } return }
func decodeSliceElems(s *Stream, val reflect.Value, elemdec decoder) error { i := 0 for ; ; i++ { // grow slice if necessary if i >= val.Cap() { newcap := val.Cap() + val.Cap()/2 if newcap < 4 { newcap = 4 } newv := reflect.MakeSlice(val.Type(), val.Len(), newcap) reflect.Copy(newv, val) val.Set(newv) } if i >= val.Len() { val.SetLen(i + 1) } // decode into element if err := elemdec(s, val.Index(i)); err == EOL { break } else if err != nil { return addErrorContext(err, fmt.Sprint("[", i, "]")) } } if i < val.Len() { val.SetLen(i) } return nil }
func copyAny(out, in reflect.Value) { 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 } out.Set(reflect.New(in.Type().Elem())) copyAny(out.Elem(), in.Elem()) case reflect.Slice: if in.IsNil() { return } n := in.Len() out.Set(reflect.MakeSlice(in.Type(), n, n)) switch in.Type().Elem().Kind() { case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64, reflect.String, reflect.Uint32, reflect.Uint64, reflect.Uint8: reflect.Copy(out, in) default: for i := 0; i < n; i++ { copyAny(out.Index(i), in.Index(i)) } } case reflect.Struct: copyStruct(out, in) default: // unknown type, so not a protocol buffer log.Printf("proto: don't know how to copy %v", in) } }
func setCustomType(base structPointer, f field, value interface{}) { if value == nil { return } v := reflect.ValueOf(value).Elem() t := reflect.TypeOf(value).Elem() kind := t.Kind() switch kind { case reflect.Slice: slice := reflect.MakeSlice(t, v.Len(), v.Cap()) reflect.Copy(slice, v) oldHeader := structPointer_GetSliceHeader(base, f) oldHeader.Data = slice.Pointer() oldHeader.Len = v.Len() oldHeader.Cap = v.Cap() default: l := 1 size := reflect.TypeOf(value).Elem().Size() if kind == reflect.Array { l = reflect.TypeOf(value).Elem().Len() size = reflect.TypeOf(value).Size() } total := int(size) * l structPointer_Copy(toStructPointer(reflect.ValueOf(value)), structPointer_Add(base, f), total) } }
// 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 }
// set attempts to assign src to dst by either setting, copying or otherwise. // // set is a bit more lenient when it comes to assignment and doesn't force an as // strict ruleset as bare `reflect` does. func set(dst, src reflect.Value, output Argument) error { dstType := dst.Type() srcType := src.Type() switch { case dstType.AssignableTo(src.Type()): dst.Set(src) case dstType.Kind() == reflect.Array && srcType.Kind() == reflect.Slice: if !dstType.Elem().AssignableTo(r_byte) { return fmt.Errorf("abi: cannot unmarshal %v in to array of elem %v", src.Type(), dstType.Elem()) } if dst.Len() < output.Type.SliceSize { return fmt.Errorf("abi: cannot unmarshal src (len=%d) in to dst (len=%d)", output.Type.SliceSize, dst.Len()) } reflect.Copy(dst, src) case dstType.Kind() == reflect.Interface: dst.Set(src) case dstType.Kind() == reflect.Ptr: return set(dst.Elem(), src, output) default: return fmt.Errorf("abi: cannot unmarshal %v in to %v", src.Type(), dst.Type()) } return nil }
// FormatSmart marshals value into a []byte according to the following rules: // * string: untouched // * bool: converted to `True` or `False` (to match pyjuju) // * int or float: converted to sensible strings // * []string: joined by `\n`s into a single string // * anything else: delegate to FormatYaml func FormatSmart(value interface{}) ([]byte, error) { if value == nil { return nil, nil } v := reflect.ValueOf(value) switch kind := v.Kind(); kind { case reflect.String: return []byte(value.(string)), nil case reflect.Array: if v.Type().Elem().Kind() == reflect.String { slice := reflect.MakeSlice(reflect.TypeOf([]string(nil)), v.Len(), v.Len()) reflect.Copy(slice, v) return []byte(strings.Join(slice.Interface().([]string), "\n")), nil } case reflect.Slice: if v.Type().Elem().Kind() == reflect.String { return []byte(strings.Join(value.([]string), "\n")), nil } case reflect.Bool: if value.(bool) { return []byte("True"), nil } return []byte("False"), nil case reflect.Map, reflect.Float32, reflect.Float64: case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: default: return nil, fmt.Errorf("cannot marshal %#v", value) } return FormatYaml(value) }
func (upckr *unpacker) unpackBlob(count int, isMapKey bool) (interface{}, error) { theType := upckr.buffer[upckr.offset] & 0xff upckr.offset++ count-- var val interface{} switch theType { case ParticleType.STRING: val = string(upckr.buffer[upckr.offset : upckr.offset+count]) case ParticleType.BLOB: if isMapKey { b := reflect.Indirect(reflect.New(reflect.ArrayOf(count, reflect.TypeOf(byte(0))))) reflect.Copy(b, reflect.ValueOf(upckr.buffer[upckr.offset:upckr.offset+count])) val = b.Interface() } else { b := make([]byte, count) copy(b, upckr.buffer[upckr.offset:upckr.offset+count]) val = b } case ParticleType.GEOJSON: val = NewGeoJSONValue(string(upckr.buffer[upckr.offset : upckr.offset+count])) default: panic(NewAerospikeError(SERIALIZE_ERROR, fmt.Sprintf("Error while unpacking BLOB. Type-header with code `%d` not recognized.", theType))) } upckr.offset += count return val, nil }
func (self *structBuilder) Elem(i int) Builder { if self == nil || i < 0 { return nobuilder } switch v := self.val.(type) { case *reflect.ArrayValue: if i < v.Len() { return &structBuilder{val: v.Elem(i)} } case *reflect.SliceValue: if i > v.Cap() { n := v.Cap() if n < 8 { n = 8 } for n <= i { n *= 2 } nv := reflect.MakeSlice(v.Type().(*reflect.SliceType), v.Len(), n) reflect.Copy(nv, v) v.Set(nv) } if v.Len() <= i && i < v.Cap() { v.SetLen(i + 1) } if i < v.Len() { return &structBuilder{val: v.Elem(i)} } } return nobuilder }
func CopyExact(dest interface{}, src interface{}) { dV := reflect.ValueOf(dest) sV := reflect.ValueOf(src) if dV.Kind() == reflect.Ptr { dV = dV.Elem() } if dV.Kind() == reflect.Array && !dV.CanAddr() { panic(fmt.Sprintf("dest not addressable: %T", dest)) } if sV.Kind() == reflect.Ptr { sV = sV.Elem() } if sV.Kind() == reflect.String { sV = sV.Convert(reflect.SliceOf(dV.Type().Elem())) } if !sV.IsValid() { panic("invalid source, probably nil") } if dV.Len() != sV.Len() { panic(fmt.Sprintf("dest len (%d) != src len (%d)", dV.Len(), sV.Len())) } if dV.Len() != reflect.Copy(dV, sV) { panic("dammit") } }
func (b *structBuilder) Elem(i int) builder { if b == nil || i < 0 { return nobuilder } switch v := b.val; v.Kind() { case reflect.Array: if i < v.Len() { return &structBuilder{val: v.Index(i)} } case reflect.Slice: if i >= v.Cap() { n := v.Cap() if n < 8 { n = 8 } for n <= i { n *= 2 } nv := reflect.MakeSlice(v.Type(), v.Len(), n) reflect.Copy(nv, v) v.Set(nv) } if v.Len() <= i && i < v.Cap() { v.SetLen(i + 1) } if i < v.Len() { return &structBuilder{val: v.Index(i)} } } return nobuilder }
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} }
func (builder *valueBuilder) Elem(i int) *valueBuilder { if i < 0 { panic(NewBsonError("negative index %v for array element", i)) } switch builder.val.Kind() { case reflect.Array: if i < builder.val.Len() { return ValueBuilder(builder.val.Index(i)) } else { panic(NewBsonError("array index %v out of bounds", i)) } case reflect.Slice: if i >= builder.val.Cap() { n := builder.val.Cap() if n < 8 { n = 8 } for n <= i { n *= 2 } nv := reflect.MakeSlice(builder.val.Type(), builder.val.Len(), n) reflect.Copy(nv, builder.val) builder.val.Set(nv) } if builder.val.Len() <= i && i < builder.val.Cap() { builder.val.SetLen(i + 1) } if i < builder.val.Len() { return ValueBuilder(builder.val.Index(i)) } else { panic(NewBsonError("internal error, realloc failed?")) } } panic(NewBsonError("unexpected type %s, expecting slice or array", builder.val.Type())) }
func (d *Decoder) decodeBinary(b []byte, v reflect.Value) error { if v.Kind() == reflect.Interface { buf := make([]byte, len(b)) copy(buf, b) v.Set(reflect.ValueOf(buf)) return nil } switch v.Interface().(type) { case []byte: if v.IsNil() || v.Cap() < len(b) { v.Set(reflect.MakeSlice(byteSliceType, len(b), len(b))) } else if v.Len() != len(b) { v.SetLen(len(b)) } copy(v.Interface().([]byte), b) default: if v.Kind() == reflect.Array && v.Type().Elem().Kind() == reflect.Uint8 { reflect.Copy(v, reflect.ValueOf(b)) break } return &UnmarshalTypeError{Value: "binary", Type: v.Type()} } return nil }
func TestSort(t *testing.T) { tests := []interface{}{ []int{3, 4, 6, 7, 2}, []uint{3, 4, 6, 7, 2}, []float64{3, 4, 6, 7, 2}, []string{"f", "d", "a", "c"}, []int{1}, []int{}, } for _, v := range tests { vv := reflect.ValueOf(v) cpy := reflect.MakeSlice(vv.Type(), vv.Len(), vv.Len()) reflect.Copy(cpy, vv) switch x := v.(type) { case []int: sort.Ints(x) case []uint: sort.Sort(uintslice(x)) case []float64: sort.Float64s(x) case []string: sort.Strings(x) } reflectSortCompare(t, v, cpy) } }
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 main() { var a A a.A0 = append(a.A0, []int{1, 2, 3, 4, 5, 6, 7, 8, 9}...) a.A1 = append(a.A1, 9, 8, 7, 6) var n = reflect.Copy(reflect.ValueOf(a.A0), reflect.ValueOf(a.A1)) fmt.Println(n, a) // 4 {[9 8 7 6 5 6 7 8 9] [9 8 7 6]} }