// DecoderContainer supports common cases for decoding into a nil
// interface{} depending on the context.
//
// When decoding into a nil interface{}, the following rules apply as we have
// to make assumptions about the specific types you want.
// - Maps are decoded as map[interface{}]interface{}
// unless you provide a default map type when creating your decoder.
// option: MapType
// - Lists are always decoded as []interface{}
// unless you provide a default slice type when creating your decoder.
// option: SliceType
// - raw bytes are decoded into []byte or string depending on setting of:
// option: BytesStringMapValue (if within a map value, use this setting)
// option: BytesStringSliceElement (else if within a slice, use this setting)
// option: BytesStringLiteral (else use this setting)
func (d SimpleDecoderContainerResolver) DecoderContainer(
parentcontainer reflect.Value, parentkey interface{},
length int, ct ContainerType) (rvn reflect.Value) {
switch ct {
case ContainerMap:
if d.MapType != nil {
rvn = reflect.MakeMap(d.MapType)
} else {
rvn = reflect.MakeMap(mapIntfIntfTyp)
}
case ContainerList:
if d.SliceType != nil {
rvn = reflect.MakeSlice(d.SliceType, length, length)
} else {
rvn = reflect.MakeSlice(intfSliceTyp, length, length)
}
case ContainerRawBytes:
rk := parentcontainer.Kind()
if (rk == reflect.Invalid && d.BytesStringLiteral) ||
(rk == reflect.Slice && d.BytesStringSliceElement) ||
(rk == reflect.Map && d.BytesStringMapValue) {
rvm := ""
rvn = reflect.ValueOf(&rvm)
} else {
rvn = reflect.MakeSlice(byteSliceTyp, length, length)
}
}
// fmt.Printf("DecoderContainer: %T, %v\n", rvn.Interface(), rvn.Interface())
return
}
func makeMapFrom(from interface{}) reflect.Value {
if isPointer(from) {
return reflect.MakeMap(reflect.TypeOf(from).Elem())
}
return reflect.MakeMap(reflect.TypeOf(from))
}
// indirectAlloc indirects all interfaces/pointers and allocates a value if
// needed. If value is nil then a Map is allocated.
func indirectAlloc(v reflect.Value) reflect.Value {
loop:
for {
switch v.Kind() {
case reflect.Interface:
if v.IsNil() {
// If nil interface default to Map.
v.Set(reflect.MakeMap(reflect.TypeOf(Map{})))
}
v = v.Elem()
case reflect.Ptr:
if v.IsNil() {
v.Set(reflect.New(v.Type().Elem()))
}
v = v.Elem()
case reflect.Map:
if v.IsNil() {
v.Set(reflect.MakeMap(v.Type()))
}
break loop
case reflect.Slice:
if v.IsNil() {
v.Set(reflect.MakeSlice(v.Type(), v.Len(), 0))
}
break loop
default:
break loop
}
}
return v
}
func (n dictNode) Value(sig Signature) (interface{}, error) {
set := n.Sigs()
if set.Empty() {
// no type information -> empty dict
return reflect.MakeMap(typeFor(sig.str)).Interface(), nil
}
if !set[sig] {
return nil, varTypeError{n.String(), sig}
}
m := reflect.MakeMap(typeFor(sig.str))
ksig := Signature{sig.str[2:3]}
vsig := Signature{sig.str[3 : len(sig.str)-1]}
for _, v := range n.children {
kv, err := v.key.Value(ksig)
if err != nil {
return nil, err
}
vv, err := v.val.Value(vsig)
if err != nil {
return nil, err
}
m.SetMapIndex(reflect.ValueOf(kv), reflect.ValueOf(vv))
}
return m.Interface(), nil
}
func decodeMap(v reflect.Value, x interface{}) {
t := v.Type()
if v.IsNil() {
v.Set(reflect.MakeMap(t))
}
for k, c := range getNode(x) {
i := reflect.New(t.Key()).Elem()
decodeValue(i, k)
w := v.MapIndex(i)
if w.IsValid() { // We have an actual element value to decode into.
if w.Kind() == reflect.Interface {
w = w.Elem()
}
w = reflect.New(w.Type()).Elem()
} else if t.Elem().Kind() != reflect.Interface { // The map's element type is concrete.
w = reflect.New(t.Elem()).Elem()
} else {
// The best we can do here is to decode as either a string (for scalars) or a map[string]interface {} (for the rest).
// We could try to guess the type based on the string (e.g. true/false => bool) but that'll get ugly fast,
// especially if we have to guess the kind (slice vs. array vs. map) and index type (e.g. string, int, etc.)
switch c.(type) {
case node:
w = reflect.MakeMap(stringMapType)
case string:
w = reflect.New(stringType).Elem()
default:
panic("value is neither node nor string")
}
}
decodeValue(w, c)
v.SetMapIndex(i, w)
}
}
func initializeMap(target *reflect.Value) {
// Initialize the map. Can't add keys without this.
if target.Kind() == reflect.Interface {
target.Set(reflect.MakeMap(reflect.TypeOf(map[string]interface{}{})))
*target = target.Elem()
} else {
target.Set(reflect.MakeMap(target.Type()))
}
}
func ArrayColumnMap(data interface{}, columnNames string) interface{} {
//提取信息
name := Explode(columnNames, ",")
nameInfo := []arrayColumnMapInfo{}
dataValue := reflect.ValueOf(data)
dataType := dataValue.Type().Elem()
for _, singleName := range name {
singleField, ok := getFieldByName(dataType, singleName)
if !ok {
panic(dataType.Name() + " struct has not field " + singleName)
}
nameInfo = append(nameInfo, arrayColumnMapInfo{
Index: singleField.Index,
Type: singleField.Type,
})
}
prevType := dataType
for i := len(nameInfo) - 1; i >= 0; i-- {
nameInfo[i].MapType = reflect.MapOf(
nameInfo[i].Type,
prevType,
)
prevType = nameInfo[i].MapType
}
//整合map
result := reflect.MakeMap(nameInfo[0].MapType)
dataLen := dataValue.Len()
for i := 0; i != dataLen; i++ {
singleValue := dataValue.Index(i)
prevValue := result
for singleNameIndex, singleNameInfo := range nameInfo {
var nextValue reflect.Value
singleField := singleValue.FieldByIndex(singleNameInfo.Index)
nextValue = prevValue.MapIndex(singleField)
if !nextValue.IsValid() {
if singleNameIndex+1 < len(nameInfo) {
nextValue = reflect.MakeMap(nameInfo[singleNameIndex+1].MapType)
} else {
nextValue = singleValue
}
prevValue.SetMapIndex(singleField, nextValue)
}
prevValue = nextValue
}
}
return result.Interface()
}
// decodeMap treats the next bytes as an XDR encoded variable array of 2-element
// structures whose fields are of the same type as the map keys and elements
// represented by the passed reflection value. Pointers are automatically
// indirected and allocated as necessary. It returns the the number of bytes
// actually read.
//
// An UnmarshalError is returned if any issues are encountered while decoding
// the elements.
func (d *Decoder) decodeMap(v reflect.Value) (int, error) {
dataLen, n, err := d.DecodeUint()
if err != nil {
return n, err
}
// Allocate storage for the underlying map if needed.
vt := v.Type()
if v.IsNil() {
v.Set(reflect.MakeMap(vt))
}
// Decode each key and value according to their type.
keyType := vt.Key()
elemType := vt.Elem()
for i := uint32(0); i < dataLen; i++ {
key := reflect.New(keyType).Elem()
n2, err := d.decode(key)
n += n2
if err != nil {
return n, err
}
val := reflect.New(elemType).Elem()
n2, err = d.decode(val)
n += n2
if err != nil {
return n, err
}
v.SetMapIndex(key, val)
}
return n, nil
}
// MakeMap examines the key type from a Hash and create a map with builtin type if possible.
// The idea is to avoid generating map[interface{}]interface{}, which cannot be handled by json.Marshal.
func (h *Hash) MakeMap(m map[interface{}]interface{}) interface{} {
hash := reflect.MakeMap(toReflectType(h))
for key, value := range m {
hash.SetMapIndex(reflect.ValueOf(key), reflect.ValueOf(value))
}
return hash.Interface()
}
func (w *walker) Map(m reflect.Value) error {
t := m.Type()
newMap := reflect.MakeMap(reflect.MapOf(t.Key(), t.Elem()))
w.cs = append(w.cs, newMap)
w.valPush(newMap)
return nil
}
func (s *S) TestUnmarshal(c *C) {
for _, item := range unmarshalTests {
t := reflect.ValueOf(item.value).Type()
var value interface{}
switch t.Kind() {
case reflect.Map:
value = reflect.MakeMap(t).Interface()
case reflect.String:
value = reflect.New(t).Interface()
case reflect.Ptr:
value = reflect.New(t.Elem()).Interface()
default:
c.Fatalf("missing case for %s", t)
}
err := yaml.Unmarshal([]byte(item.data), value)
if _, ok := err.(*yaml.TypeError); !ok {
c.Assert(err, IsNil)
}
if t.Kind() == reflect.String {
c.Assert(*value.(*string), Equals, item.value)
} else {
c.Assert(value, DeepEquals, item.value)
}
}
}
func (this *SpecificDatumReader) mapMap(field Schema, reflectField reflect.Value, dec Decoder) (reflect.Value, error) {
if mapLength, err := dec.ReadMapStart(); err != nil {
return reflect.ValueOf(mapLength), err
} else {
resultMap := reflect.MakeMap(reflectField.Type())
for {
var i int64 = 0
for ; i < mapLength; i++ {
key, err := this.readValue(&StringSchema{}, reflectField, dec)
if err != nil {
return reflect.ValueOf(mapLength), err
}
val, err := this.readValue(field.(*MapSchema).Values, reflectField, dec)
if err != nil {
return reflect.ValueOf(mapLength), nil
}
if val.Kind() == reflect.Ptr {
resultMap.SetMapIndex(key, val.Elem())
} else {
resultMap.SetMapIndex(key, val)
}
}
mapLength, err = dec.MapNext()
if err != nil {
return reflect.ValueOf(mapLength), err
} else if mapLength == 0 {
break
}
}
return resultMap, nil
}
}
func (d *Decoder) mapValue(v reflect.Value) error {
n, err := d.DecodeMapLen()
if err != nil {
return err
}
if n == -1 {
return nil
}
typ := v.Type()
if v.IsNil() {
v.Set(reflect.MakeMap(typ))
}
keyType := typ.Key()
valueType := typ.Elem()
for i := 0; i < n; i++ {
mk := reflect.New(keyType).Elem()
if err := d.DecodeValue(mk); err != nil {
return err
}
mv := reflect.New(valueType).Elem()
if err := d.DecodeValue(mv); err != nil {
return err
}
v.SetMapIndex(mk, mv)
}
return nil
}
func decodeMapStringInterface(d *decodeState, kind int, v reflect.Value) {
if kind != kindDocument {
d.saveErrorAndSkip(kind, v.Type())
}
if v.IsNil() {
v.Set(reflect.MakeMap(v.Type()))
}
var m map[string]interface{}
switch mm := v.Interface().(type) {
case map[string]interface{}:
m = mm
case M:
m = (map[string]interface{})(mm)
}
offset := d.beginDoc()
for {
kind, name := d.scanKindName()
if kind == 0 {
break
}
if kind == kindNull {
continue
}
m[string(name)] = d.decodeValueInterface(kind)
}
d.endDoc(offset)
}
// rv must be a non-nil pointer or a settable value
func indirect(rv reflect.Value) (reflect.Value, error) {
for {
if rv.Kind() == reflect.Interface && !rv.IsNil() {
if e := rv.Elem(); e.Kind() == reflect.Ptr && !e.IsNil() {
rv = e.Elem()
}
}
if rv.Kind() == reflect.Map && rv.IsNil() {
rv.Set(reflect.MakeMap(rv.Type()))
}
if rv.Kind() != reflect.Ptr {
break
}
if rv.IsNil() {
rv.Set(reflect.New(rv.Type().Elem()))
}
rv = rv.Elem()
}
if k := rv.Kind(); k != reflect.Struct && k != reflect.Map {
return reflect.Value{}, &InvalidIndirectError{rv.Type()}
}
if rv.Kind() == reflect.Map {
if t := rv.Type(); t.Key().Kind() != reflect.String || t.Elem().Kind() != reflect.String {
return reflect.Value{}, &InvalidIndirectError{t}
}
}
return rv, nil
}
func copyTableToMap(L *lua.State, t reflect.Type, idx int, visited map[uintptr]interface{}) interface{} {
if t == nil {
t = tmap
}
te, tk := t.Elem(), t.Key()
m := reflect.MakeMap(t)
// See copyTableToSlice.
ptr := L.ToPointer(idx)
if !luaIsEmpty(L, idx) {
visited[ptr] = m.Interface()
}
L.PushNil()
if idx < 0 {
idx--
}
for L.Next(idx) != 0 {
// key at -2, value at -1
key := reflect.ValueOf(luaToGo(L, tk, -2, visited))
val := reflect.ValueOf(luaToGo(L, te, -1, visited))
if val.Interface() == nullv.Interface() {
val = reflect.Zero(te)
}
m.SetMapIndex(key, val)
L.Pop(1)
}
return m.Interface()
}
func (p *Decoder) unmarshalDictionary(pval *plistValue, val reflect.Value) {
typ := val.Type()
switch val.Kind() {
case reflect.Struct:
tinfo, err := getTypeInfo(typ)
if err != nil {
panic(err)
}
subvalues := pval.value.(*dictionary).m
for _, finfo := range tinfo.fields {
p.unmarshal(subvalues[finfo.name], finfo.value(val))
}
case reflect.Map:
if val.IsNil() {
val.Set(reflect.MakeMap(typ))
}
subvalues := pval.value.(*dictionary).m
for k, sval := range subvalues {
keyv := reflect.ValueOf(k).Convert(typ.Key())
mapElem := val.MapIndex(keyv)
if !mapElem.IsValid() {
mapElem = reflect.New(typ.Elem()).Elem()
}
p.unmarshal(sval, mapElem)
val.SetMapIndex(keyv, mapElem)
}
default:
panic(&incompatibleDecodeTypeError{typ, pval.kind})
}
}
func unmarshalMap(data string, v reflect.Value) error {
mapType := v.Type()
if mapType.Key().Kind() != reflect.String {
return errors.New("tnetstring: only maps with string keys can be unmarshaled")
}
if v.IsNil() {
v.Set(reflect.MakeMap(mapType))
}
vtype := mapType.Elem()
var s string
key := reflect.ValueOf(&s).Elem()
for len(data) > 0 {
val := reflect.New(vtype).Elem()
typ, content, n := readElement(data)
data = data[n:]
if typ != ',' {
return errors.New("tnetstring: non-string key in dictionary")
}
s = content
n, err := unmarshal(data, val)
data = data[n:]
if err != nil {
return err
}
v.SetMapIndex(key, val)
}
return nil
}
func (d *mapAsMapDecoder) decode(dv, sv reflect.Value) {
dt := dv.Type()
dv.Set(reflect.MakeMap(reflect.MapOf(dt.Key(), dt.Elem())))
var mapKey reflect.Value
var mapElem reflect.Value
keyType := dv.Type().Key()
elemType := dv.Type().Elem()
for _, sElemKey := range sv.MapKeys() {
var dElemKey reflect.Value
var dElemVal reflect.Value
if !mapKey.IsValid() {
mapKey = reflect.New(keyType).Elem()
} else {
mapKey.Set(reflect.Zero(keyType))
}
dElemKey = mapKey
if !mapElem.IsValid() {
mapElem = reflect.New(elemType).Elem()
} else {
mapElem.Set(reflect.Zero(elemType))
}
dElemVal = mapElem
d.keyDec(dElemKey, sElemKey)
d.elemDec(dElemVal, sv.MapIndex(sElemKey))
dv.SetMapIndex(dElemKey, dElemVal)
}
}
func (p Pages) GroupBy(key string, order ...string) (PagesGroup, error) {
if len(p) < 1 {
return nil, nil
}
direction := "asc"
if len(order) > 0 && (strings.ToLower(order[0]) == "desc" || strings.ToLower(order[0]) == "rev" || strings.ToLower(order[0]) == "reverse") {
direction = "desc"
}
ppt := reflect.TypeOf(&Page{})
ft, ok := ppt.Elem().FieldByName(key)
if !ok {
return nil, errors.New("No such field in Page struct")
}
tmp := reflect.MakeMap(reflect.MapOf(ft.Type, reflect.SliceOf(ppt)))
for _, e := range p {
ppv := reflect.ValueOf(e)
fv := ppv.Elem().FieldByName(key)
if !tmp.MapIndex(fv).IsValid() {
tmp.SetMapIndex(fv, reflect.MakeSlice(reflect.SliceOf(ppt), 0, 0))
}
tmp.SetMapIndex(fv, reflect.Append(tmp.MapIndex(fv), ppv))
}
var r []PageGroup
for _, k := range sortKeys(tmp.MapKeys(), direction) {
r = append(r, PageGroup{Key: k.Interface(), Pages: tmp.MapIndex(k).Interface().([]*Page)})
}
return r, nil
}
// get into map pointed at by v
func getMap(data *C.pn_data_t, v interface{}) {
mapValue := reflect.ValueOf(v).Elem()
mapValue.Set(reflect.MakeMap(mapValue.Type())) // Clear the map
switch pnType := C.pn_data_type(data); pnType {
case C.PN_MAP:
count := int(C.pn_data_get_map(data))
if bool(C.pn_data_enter(data)) {
defer C.pn_data_exit(data)
for i := 0; i < count/2; i++ {
if bool(C.pn_data_next(data)) {
key := reflect.New(mapValue.Type().Key())
unmarshal(key.Interface(), data)
if bool(C.pn_data_next(data)) {
val := reflect.New(mapValue.Type().Elem())
unmarshal(val.Interface(), data)
mapValue.SetMapIndex(key.Elem(), val.Elem())
}
}
}
}
case C.PN_INVALID: // Leave the map empty
default:
panic(newUnmarshalError(pnType, v))
}
}
func deepCopyStruct(src, dst reflect.Value, t reflect.Type) {
for i := 0; i < t.NumField(); i++ {
sv := src.Field(i)
if sv.CanSet() && sv.IsValid() {
switch sv.Kind() {
case reflect.Ptr:
if !sv.IsNil() {
dst.Field(i).Set(reflect.New(sv.Elem().Type()))
}
case reflect.Array, reflect.Slice:
if !sv.IsNil() {
dst.Field(i).Set(reflect.MakeSlice(sv.Type(), sv.Len(), sv.Cap()))
}
case reflect.Map:
if !sv.IsNil() {
dst.Field(i).Set(reflect.MakeMap(sv.Type()))
}
}
sf := reflect.Indirect(sv)
df := reflect.Indirect(dst.Field(i))
tt := sf.Type()
deepCopy(sf, df, tt)
}
}
}
// tryCustom searches for custom handlers, and returns true iff it finds a match
// and successfully randomizes v.
func (f *Fuzzer) tryCustom(v reflect.Value) bool {
doCustom, ok := f.fuzzFuncs[v.Type()]
if !ok {
return false
}
switch v.Kind() {
case reflect.Ptr:
if v.IsNil() {
if !v.CanSet() {
return false
}
v.Set(reflect.New(v.Type().Elem()))
}
case reflect.Map:
if v.IsNil() {
if !v.CanSet() {
return false
}
v.Set(reflect.MakeMap(v.Type()))
}
default:
return false
}
doCustom.Call([]reflect.Value{v, reflect.ValueOf(Continue{
f: f,
Rand: f.r,
})})
return true
}
func (g *Group) storeDefaults() {
for _, option := range g.options {
// First. empty out the value
if len(option.Default) > 0 {
option.clear()
}
for _, d := range option.Default {
option.set(&d)
}
if !option.value.CanSet() {
continue
}
if option.value.Kind() == reflect.Map {
option.defaultValue = reflect.MakeMap(option.value.Type())
for _, k := range option.value.MapKeys() {
option.defaultValue.SetMapIndex(k, option.value.MapIndex(k))
}
} else {
option.defaultValue = reflect.ValueOf(option.value.Interface())
}
}
}
func testSetNilMapsToEmpties(curr reflect.Value) {
actualCurrValue := curr
if curr.Kind() == reflect.Ptr {
actualCurrValue = curr.Elem()
}
switch actualCurrValue.Kind() {
case reflect.Map:
for _, mapKey := range actualCurrValue.MapKeys() {
currMapValue := actualCurrValue.MapIndex(mapKey)
testSetNilMapsToEmpties(currMapValue)
}
case reflect.Struct:
for fieldIndex := 0; fieldIndex < actualCurrValue.NumField(); fieldIndex++ {
currFieldValue := actualCurrValue.Field(fieldIndex)
if currFieldValue.Kind() == reflect.Map && currFieldValue.IsNil() {
newValue := reflect.MakeMap(currFieldValue.Type())
currFieldValue.Set(newValue)
} else {
testSetNilMapsToEmpties(currFieldValue.Addr())
}
}
}
}
func unmarshalMap(value reflect.Value, data interface{}, tag reflect.StructTag) error {
if data == nil {
return nil
}
mapData, ok := data.(map[string]interface{})
if !ok {
return fmt.Errorf("JSON value is not a map (%#v)", data)
}
t := value.Type()
if value.Kind() == reflect.Ptr {
t = t.Elem()
if value.IsNil() {
value.Set(reflect.New(t))
value.Elem().Set(reflect.MakeMap(t))
}
value = value.Elem()
}
for k, v := range mapData {
kvalue := reflect.ValueOf(k)
vvalue := reflect.New(value.Type().Elem()).Elem()
unmarshalAny(vvalue, v, "")
value.SetMapIndex(kvalue, vvalue)
}
return nil
}
func decodeMap(d *decodeState, kind int, v reflect.Value) {
t := v.Type()
if t.Key().Kind() != reflect.String || kind != kindDocument {
d.saveErrorAndSkip(kind, t)
return
}
if v.IsNil() {
v.Set(reflect.MakeMap(t))
}
subv := reflect.New(t.Elem()).Elem()
offset := d.beginDoc()
for {
kind, name := d.scanKindName()
if kind == 0 {
break
}
if kind == kindNull {
continue
}
subv.Set(reflect.Zero(t.Elem()))
d.decodeValue(kind, subv)
v.SetMapIndex(reflect.ValueOf(string(name)), subv)
}
d.endDoc(offset)
}
func reifyMap(opts *options, to reflect.Value, from *Config) Error {
if to.Type().Key().Kind() != reflect.String {
return raiseKeyInvalidTypeUnpack(to.Type(), from)
}
if len(from.fields.fields) == 0 {
return nil
}
if to.IsNil() {
to.Set(reflect.MakeMap(to.Type()))
}
for k, value := range from.fields.fields {
key := reflect.ValueOf(k)
old := to.MapIndex(key)
var v reflect.Value
var err Error
if !old.IsValid() {
v, err = reifyValue(fieldOptions{opts: opts}, to.Type().Elem(), value)
} else {
v, err = reifyMergeValue(fieldOptions{opts: opts}, old, value)
}
if err != nil {
return err
}
to.SetMapIndex(key, v)
}
return nil
}
func (s *S) TestUnmarshal(c *C) {
for i, item := range unmarshalTests {
t := reflect.ValueOf(item.value).Type()
var value interface{}
switch t.Kind() {
case reflect.Map:
value = reflect.MakeMap(t).Interface()
case reflect.String:
t := reflect.ValueOf(item.value).Type()
v := reflect.New(t)
value = v.Interface()
default:
pt := reflect.ValueOf(item.value).Type()
pv := reflect.New(pt.Elem())
value = pv.Interface()
}
err := goyaml.Unmarshal([]byte(item.data), value)
c.Assert(err, IsNil, Commentf("Item #%d", i))
if t.Kind() == reflect.String {
c.Assert(*value.(*string), Equals, item.value, Commentf("Item #%d", i))
} else {
c.Assert(value, DeepEquals, item.value, Commentf("Item #%d", i))
}
}
}
func evalBuiltinMakeExpr(ctx *Ctx, call *CallExpr, env *Env) ([]reflect.Value, error) {
resT := call.KnownType()[0]
length, capacity := 0, 0
var err error
if len(call.Args) > 1 {
if length, err = evalInteger(ctx, call.Args[1].(Expr), env); err != nil {
return nil, err
}
}
if len(call.Args) > 2 {
if capacity, err = evalInteger(ctx, call.Args[2].(Expr), env); err != nil {
return nil, err
}
}
var res reflect.Value
switch resT.Kind() {
case reflect.Slice:
res = reflect.MakeSlice(resT, length, capacity)
case reflect.Map:
res = reflect.MakeMap(resT)
case reflect.Chan:
res = reflect.MakeChan(resT, length)
default:
panic(dytc("make(bad type)"))
}
return []reflect.Value{res}, nil
}