func (d *decoder) mapCopy(src reflect.Value, dst reflect.Value) error {
sv := src.MapKeys()
dt := dst.Type().Elem()
for i := range sv {
ot := reflect.New(dt)
if dt.Kind() == reflect.Ptr {
ot = reflect.New(ot.Type().Elem())
}
d.pushPath(sv[i].String())
err := d.decode(src.MapIndex(sv[i]), ot)
if err != nil && err != ErrIncompatStruct {
err = errors.New(d.pathString() + err.Error())
d.path = nil
return err
}
d.popPath()
if err == nil {
dst.SetMapIndex(sv[i], ot.Elem())
}
}
return nil
}
// ReadTargets reads targets into map entries.
func (n *MapNode) ReadTargets(c ReadContext, val Val) error {
list := c.List()
for _, keyStr := range list {
keyVal := reflect.New(n.KeyType).Elem()
if err := n.UnmarshalKey(keyStr, keyVal); err != nil {
return errors.Wrapf(err, "unmarshaling key")
}
elem := *n.ElemNode
elemContext := c.Push(keyStr)
elemVal := elem.NewKeyedVal(keyVal)
err := elem.Read(elemContext, elemVal)
// Set key field.
if n.Field != nil && n.Field.KeyField != "" {
n.Field.SetKeyFunc.Call([]reflect.Value{elemVal.Ptr, elemVal.Key})
}
if err != nil {
return errors.Wrapf(err, "reading child %s", keyStr)
}
// TODO: Don't calculate these values every time.
if reflect.DeepEqual(elemVal.Ptr.Elem().Interface(), reflect.New(elemVal.Ptr.Type().Elem()).Elem().Interface()) {
nv := reflect.New(elemVal.Ptr.Type()).Elem()
val.Ptr.Elem().SetMapIndex(elemVal.Key, nv)
} else {
val.Ptr.Elem().SetMapIndex(elemVal.Key, elemVal.Final())
}
}
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))
}
}
}
// Init initializes the container runtime given a JSON configuration that
// conforms to the Config set type.
func (c *CRT) Init(configStr string) error {
cfg := &Config{}
err := json.Unmarshal([]byte(configStr), cfg)
if err != nil {
return err
}
if _, ok := containerIfRegistry[cfg.CRT.Type]; !ok {
return core.Errorf("unregistered container run time")
}
crtConfigType := containerIfRegistry[cfg.CRT.Type].ConfigType
crtConfig := reflect.New(crtConfigType).Interface()
err = json.Unmarshal([]byte(configStr), crtConfig)
if err != nil {
return err
}
crtType := containerIfRegistry[cfg.CRT.Type].CRTType
crtif := reflect.New(crtType).Interface()
c.ContainerIf = crtif.(crtclient.ContainerIf)
err = c.ContainerIf.Init(&core.Config{V: crtConfig})
if err != nil {
return err
}
return nil
}
// mapEncodeScratch returns a new reflect.Value matching the map's value type,
// and a structPointer suitable for passing to an encoder or sizer.
func mapEncodeScratch(mapType reflect.Type) (keycopy, valcopy reflect.Value, keybase, valbase structPointer) {
// Prepare addressable doubly-indirect placeholders for the key and value types.
// This is needed because the element-type encoders expect **T, but the map iteration produces T.
keycopy = reflect.New(mapType.Key()).Elem() // addressable K
keyptr := reflect.New(reflect.PtrTo(keycopy.Type())).Elem() // addressable *K
keyptr.Set(keycopy.Addr()) //
keybase = toStructPointer(keyptr.Addr()) // **K
// Value types are more varied and require special handling.
switch mapType.Elem().Kind() {
case reflect.Slice:
// []byte
var dummy []byte
valcopy = reflect.ValueOf(&dummy).Elem() // addressable []byte
valbase = toStructPointer(valcopy.Addr())
case reflect.Ptr:
// message; the generated field type is map[K]*Msg (so V is *Msg),
// so we only need one level of indirection.
valcopy = reflect.New(mapType.Elem()).Elem() // addressable V
valbase = toStructPointer(valcopy.Addr())
default:
// everything else
valcopy = reflect.New(mapType.Elem()).Elem() // addressable V
valptr := reflect.New(reflect.PtrTo(valcopy.Type())).Elem() // addressable *V
valptr.Set(valcopy.Addr()) //
valbase = toStructPointer(valptr.Addr()) // **V
}
return
}
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 TestUnmarshal(t *testing.T) {
for i, tt := range unmarshalTests {
var scan Scanner
in := []byte(tt.in)
if err := checkValid(in, &scan); err != nil {
if !reflect.DeepEqual(err, tt.err) {
t.Errorf("#%d: checkValid: %#v", i, err)
continue
}
}
if tt.ptr == nil {
continue
}
// v = new(right-type)
v := reflect.New(reflect.TypeOf(tt.ptr).Elem())
dec := NewDecoder(bytes.NewReader(in))
if tt.useNumber {
dec.UseNumber()
}
if err := dec.Decode(v.Interface()); !reflect.DeepEqual(err, tt.err) {
t.Errorf("#%d: %v, want %v", i, err, tt.err)
continue
} else if err != nil {
continue
}
if !reflect.DeepEqual(v.Elem().Interface(), tt.out) {
t.Errorf("#%d: mismatch\nhave: %#+v\nwant: %#+v", i, v.Elem().Interface(), tt.out)
data, _ := Marshal(v.Elem().Interface())
println(string(data))
data, _ = Marshal(tt.out)
println(string(data))
continue
}
// Check round trip.
if tt.err == nil {
enc, err := Marshal(v.Interface())
if err != nil {
t.Errorf("#%d: error re-marshaling: %v", i, err)
continue
}
vv := reflect.New(reflect.TypeOf(tt.ptr).Elem())
dec = NewDecoder(bytes.NewReader(enc))
if tt.useNumber {
dec.UseNumber()
}
if err := dec.Decode(vv.Interface()); err != nil {
t.Errorf("#%d: error re-unmarshaling %#q: %v", i, enc, err)
continue
}
if !reflect.DeepEqual(v.Elem().Interface(), vv.Elem().Interface()) {
t.Errorf("#%d: mismatch\nhave: %#+v\nwant: %#+v", i, v.Elem().Interface(), vv.Elem().Interface())
t.Errorf(" In: %q", strings.Map(noSpace, string(in)))
t.Errorf("Marshal: %q", strings.Map(noSpace, string(enc)))
continue
}
}
}
}
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
}
// callCustom calls 'custom' with sv & dv. custom must be a conversion function.
func (c *Converter) callCustom(sv, dv, custom reflect.Value, scope *scope) error {
if !sv.CanAddr() {
sv2 := reflect.New(sv.Type())
sv2.Elem().Set(sv)
sv = sv2
} else {
sv = sv.Addr()
}
if !dv.CanAddr() {
if !dv.CanSet() {
return scope.errorf("can't addr or set dest.")
}
dvOrig := dv
dv := reflect.New(dvOrig.Type())
defer func() { dvOrig.Set(dv) }()
} else {
dv = dv.Addr()
}
args := []reflect.Value{sv, dv, reflect.ValueOf(scope)}
ret := custom.Call(args)[0].Interface()
// This convolution is necessary because nil interfaces won't convert
// to errors.
if ret == nil {
return nil
}
return ret.(error)
}
// Internal function to bind receive operations for a channel.
func (c *EncodedConn) bindRecvChan(subject, queue string, channel interface{}) error {
chVal := reflect.ValueOf(channel)
if chVal.Kind() != reflect.Chan {
return ErrChanArg
}
argType := chVal.Type().Elem()
cb := func(m *Msg) {
var oPtr reflect.Value
if argType.Kind() != reflect.Ptr {
oPtr = reflect.New(argType)
} else {
oPtr = reflect.New(argType.Elem())
}
if err := c.Enc.Decode(m.Subject, m.Data, oPtr.Interface()); err != nil {
c.Conn.err = errors.New("nats: Got an error trying to unmarshal: " + err.Error())
if c.Conn.Opts.AsyncErrorCB != nil {
go c.Conn.Opts.AsyncErrorCB(c.Conn, m.Sub, c.Conn.err)
}
return
}
if argType.Kind() != reflect.Ptr {
oPtr = reflect.Indirect(oPtr)
}
chVal.Send(oPtr)
}
_, err := c.Conn.subscribe(subject, queue, cb)
return err
}
func RegisterRpcParams(name string, obj interface{}) {
objType := reflect.TypeOf(obj)
if name == "" {
val := reflect.ValueOf(obj)
name = objType.Name()
if val.Kind() == reflect.Ptr {
name = objType.Elem().Name()
}
}
for i := 0; i < objType.NumMethod(); i++ {
method := objType.Method(i)
methodType := method.Type
if methodType.NumIn() == 3 { // if it has three parameters (one is self and two are rpc params)
out := methodType.In(2)
if out.Kind() == reflect.Ptr {
out = out.Elem()
}
rpcParamsMap[name+"."+method.Name] = &RpcParams{
Object: obj,
InParam: reflect.New(methodType.In(1)).Interface(),
OutParam: reflect.New(out).Interface(),
}
}
}
}
func (d *Decoder) decodeSlice(s *decodStatus, v reflect.Value, t reflect.Type, tg tag) error {
if _, isInline := tg.Modifiers["inline"]; isInline {
val, ok := s.GetValue(d.env)
if !ok {
return nil
}
elements := d.arrSep.Split(val, -1)
slice := reflect.MakeSlice(t, 0, len(elements))
for _, s := range elements {
mv := reflect.New(t.Elem())
err := d.decodeField(mv.Elem(), s)
if err != nil {
return err
}
slice = reflect.Append(slice, mv.Elem())
}
v.Set(slice)
return nil
}
index := s.GetIndex()
slice := reflect.MakeSlice(t, 0, len(index))
for _, i := range index {
mv := reflect.New(t.Elem())
err := d.decodeElement(s, mv.Elem(), mv.Elem().Type(), tag{Name: strconv.Itoa(i), Modifiers: tg.Modifiers})
if err != nil {
return err
}
slice = reflect.Append(slice, mv.Elem())
}
v.Set(slice)
return nil
}
func (d *decoder) mapping(n *node, out reflect.Value) (good bool) {
if set := d.setter("!!map", &out, &good); set != nil {
defer set()
}
if out.Kind() == reflect.Struct {
return d.mappingStruct(n, out)
}
if out.Kind() == reflect.Interface {
// No type hints. Will have to use a generic map.
iface := out
out = settableValueOf(make(map[interface{}]interface{}))
iface.Set(out)
}
if out.Kind() != reflect.Map {
return false
}
outt := out.Type()
kt := outt.Key()
et := outt.Elem()
l := len(n.children)
for i := 0; i < l; i += 2 {
k := reflect.New(kt).Elem()
if d.unmarshal(n.children[i], k) {
e := reflect.New(et).Elem()
if d.unmarshal(n.children[i+1], e) {
out.SetMapIndex(k, e)
}
}
}
return true
}
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)
}
}
// 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
}
func lookup(v reflect.Value, s string) reflect.Value {
var ret reflect.Value
v = reflect.Indirect(v)
switch v.Kind() {
case reflect.Array, reflect.Slice:
if idx, err := strconv.Atoi(s); err == nil {
ret = v.Index(idx)
}
case reflect.Map:
keyt := v.Type().Key()
switch keyt.Kind() {
case reflect.String:
ret = v.MapIndex(reflect.ValueOf(s))
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
if idx, err := strconv.ParseInt(s, 10, 64); err == nil {
idxVal := reflect.New(keyt).Elem()
idxVal.SetInt(idx)
ret = v.MapIndex(idxVal)
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
if idx, err := strconv.ParseUint(s, 10, 64); err == nil {
idxVal := reflect.New(keyt).Elem()
idxVal.SetUint(idx)
ret = v.MapIndex(idxVal)
}
}
case reflect.Struct:
ret = v.FieldByName(s)
}
// TODO: Find a way to look up methods by name
return ret
}
// 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 (scope *Scope) createJoinTable(field *StructField) {
if relationship := field.Relationship; relationship != nil && relationship.JoinTableHandler != nil {
joinTableHandler := relationship.JoinTableHandler
joinTable := joinTableHandler.Table(scope.db)
if !scope.Dialect().HasTable(scope, joinTable) {
toScope := &Scope{Value: reflect.New(field.Struct.Type).Interface()}
var sqlTypes []string
for idx, fieldName := range relationship.ForeignFieldNames {
if field, ok := scope.Fields()[fieldName]; ok {
value := reflect.Indirect(reflect.New(field.Struct.Type))
primaryKeySqlType := scope.Dialect().SqlTag(value, 255, false)
sqlTypes = append(sqlTypes, scope.Quote(relationship.ForeignDBNames[idx])+" "+primaryKeySqlType)
}
}
for idx, fieldName := range relationship.AssociationForeignFieldNames {
if field, ok := toScope.Fields()[fieldName]; ok {
value := reflect.Indirect(reflect.New(field.Struct.Type))
primaryKeySqlType := scope.Dialect().SqlTag(value, 255, false)
sqlTypes = append(sqlTypes, scope.Quote(relationship.AssociationForeignDBNames[idx])+" "+primaryKeySqlType)
}
}
scope.Err(scope.NewDB().Exec(fmt.Sprintf("CREATE TABLE %v (%v) %s", scope.Quote(joinTable), strings.Join(sqlTypes, ","), scope.getTableOptions())).Error)
}
scope.NewDB().Table(joinTable).AutoMigrate(joinTableHandler)
}
}
func (scope *Scope) getColumnsAsScope(column string) *Scope {
values := scope.IndirectValue()
switch values.Kind() {
case reflect.Slice:
modelType := values.Type().Elem()
if modelType.Kind() == reflect.Ptr {
modelType = modelType.Elem()
}
fieldStruct, _ := modelType.FieldByName(column)
var columns reflect.Value
if fieldStruct.Type.Kind() == reflect.Slice || fieldStruct.Type.Kind() == reflect.Ptr {
columns = reflect.New(reflect.SliceOf(reflect.PtrTo(fieldStruct.Type.Elem()))).Elem()
} else {
columns = reflect.New(reflect.SliceOf(reflect.PtrTo(fieldStruct.Type))).Elem()
}
for i := 0; i < values.Len(); i++ {
column := reflect.Indirect(values.Index(i)).FieldByName(column)
if column.Kind() == reflect.Ptr {
column = column.Elem()
}
if column.Kind() == reflect.Slice {
for i := 0; i < column.Len(); i++ {
columns = reflect.Append(columns, column.Index(i).Addr())
}
} else {
columns = reflect.Append(columns, column.Addr())
}
}
return scope.New(columns.Interface())
case reflect.Struct:
return scope.New(values.FieldByName(column).Addr().Interface())
}
return nil
}
func SelectOne(res interface{}, query string, args ...interface{}) error {
if strings.Index(query, "SELECT") == -1 {
query = selectWhere(res, query)
}
// Handler pointer to pointer
t := reflect.TypeOf(res).Elem()
if t.Kind() == reflect.Ptr {
t = t.Elem() // User
val := reflect.New(t) // *User
dest := reflect.ValueOf(res).Elem() // *User
_, err := db.QueryOne(val.Interface(), query, args...)
h(err)
if err != nil {
return err
}
if dest.IsNil() {
dest.Set(reflect.New(t))
}
dest.Elem().Set(val.Elem()) // User = User
return err
}
var err error
timeout(func() {
_, err = db.QueryOne(res, query, args...)
h(err)
})
return err
}
func (orm *Model) FindAll(rowsSlicePtr interface{}) error {
orm.ScanPK(rowsSlicePtr)
sliceValue := reflect.Indirect(reflect.ValueOf(rowsSlicePtr))
if sliceValue.Kind() != reflect.Slice {
return errors.New("needs a pointer to a slice")
}
sliceElementType := sliceValue.Type().Elem()
st := reflect.New(sliceElementType)
var keys []string
results, _ := scanStructIntoMap(st.Interface())
if orm.TableName == "" {
orm.TableName = getTableName(rowsSlicePtr)
}
for key, _ := range results {
keys = append(keys, key)
}
orm.ColumnStr = strings.Join(keys, ", ")
resultsSlice, err := orm.FindMap()
if err != nil {
return err
}
for _, results := range resultsSlice {
newValue := reflect.New(sliceElementType)
scanMapIntoStruct(newValue.Interface(), results)
sliceValue.Set(reflect.Append(sliceValue, reflect.Indirect(reflect.ValueOf(newValue.Interface()))))
}
return nil
}
// This is a helper that initializes (zeros) a new app controller value.
// Generally, everything is set to its zero value, except:
// 1. Embedded controller pointers are newed up.
// 2. The rev.Controller embedded type is set to the value provided.
// Returns a value representing a pointer to the new app controller.
func initNewAppController(appControllerType reflect.Type, c *Controller) reflect.Value {
// It might be a multi-level embedding, so we have to create new controllers
// at every level of the hierarchy.
// ASSUME: the first field in each type is the way up to rev.Controller.
appControllerPtr := reflect.New(appControllerType)
ptr := appControllerPtr
for {
var (
embeddedField reflect.Value = ptr.Elem().Field(0)
embeddedFieldType reflect.Type = embeddedField.Type()
)
// Check if it's the controller.
if embeddedFieldType == controllerType {
embeddedField.Set(reflect.ValueOf(c).Elem())
break
} else if embeddedFieldType == controllerPtrType {
embeddedField.Set(reflect.ValueOf(c))
break
}
// If the embedded field is a pointer, then instantiate an object and set it.
// (If it's not a pointer, then it's already initialized)
if embeddedFieldType.Kind() == reflect.Ptr {
embeddedField.Set(reflect.New(embeddedFieldType.Elem()))
ptr = embeddedField
} else {
ptr = embeddedField.Addr()
}
}
return appControllerPtr
}
func (server *Server) readRequest(codec ServerCodec) (service *service, mtype *methodType, req *Request, argv, replyv reflect.Value, err os.Error) {
service, mtype, req, err = server.readRequestHeader(codec)
if err != nil {
if err == os.EOF || err == io.ErrUnexpectedEOF {
return
}
// discard body
codec.ReadRequestBody(nil)
return
}
// Decode the argument value.
argIsValue := false // if true, need to indirect before calling.
if mtype.ArgType.Kind() == reflect.Ptr {
argv = reflect.New(mtype.ArgType.Elem())
} else {
argv = reflect.New(mtype.ArgType)
argIsValue = true
}
// argv guaranteed to be a pointer now.
if err = codec.ReadRequestBody(argv.Interface()); err != nil {
return
}
if argIsValue {
argv = argv.Elem()
}
replyv = reflect.New(mtype.ReplyType.Elem())
return
}
func (ju *jsonUnmarshaler) UnmarshalPayload(msg Message) error {
var result interface{}
_body := msg.Body()
var err error
if bodyT := reflect.TypeOf(_body); bodyT != nil && bodyT.AssignableTo(ju.T) {
// The message already has an appropriate body; unmarshal into it
err = json.Unmarshal(msg.Payload(), result)
} else {
// No body (or an inappropriate type); overwrite with a new object
if t := ju.T; t.Kind() == reflect.Ptr {
result = reflect.New(t.Elem()).Interface()
err = json.Unmarshal(msg.Payload(), result)
} else {
result = reflect.New(t).Interface()
err = json.Unmarshal(msg.Payload(), result)
result = reflect.Indirect(reflect.ValueOf(result)).Interface()
}
}
if err == nil {
msg.SetBody(result)
}
return err
}
func stringTypeOf(i interface{}) (string, error) {
_, isByteSlice := i.([]byte)
if !isByteSlice {
// Check if we found a higher kinded type
switch reflect.ValueOf(i).Kind() {
case reflect.Slice:
elemVal := reflect.Indirect(reflect.New(reflect.TypeOf(i).Elem())).Interface()
ct := cassaType(elemVal)
if ct == gocql.TypeCustom {
return "", fmt.Errorf("Unsupported type %T", i)
}
return fmt.Sprintf("list<%v>", ct), nil
case reflect.Map:
keyVal := reflect.Indirect(reflect.New(reflect.TypeOf(i).Key())).Interface()
elemVal := reflect.Indirect(reflect.New(reflect.TypeOf(i).Elem())).Interface()
keyCt := cassaType(keyVal)
elemCt := cassaType(elemVal)
if keyCt == gocql.TypeCustom || elemCt == gocql.TypeCustom {
return "", fmt.Errorf("Unsupported map key or value type %T", i)
}
return fmt.Sprintf("map<%v, %v>", keyCt, elemCt), nil
}
}
ct := cassaType(i)
if ct == gocql.TypeCustom {
return "", fmt.Errorf("Unsupported type %T", i)
}
return cassaTypeToString(ct)
}
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 (processor *processor) decode() (errors []error) {
if processor.checkSkipLeft() || processor.MetaValues == nil {
return
}
for _, metaValue := range processor.MetaValues.Values {
meta := metaValue.Meta
if meta == nil {
continue
}
if processor.newRecord && !meta.HasPermission(roles.Create, processor.Context) {
continue
} else if !meta.HasPermission(roles.Update, processor.Context) {
continue
}
if setter := meta.GetSetter(); setter != nil {
setter(processor.Result, metaValue, processor.Context)
continue
}
res := metaValue.Meta.GetResource()
if res == nil {
continue
}
field := reflect.Indirect(reflect.ValueOf(processor.Result)).FieldByName(meta.GetFieldName())
if field.Kind() == reflect.Struct {
value := reflect.New(field.Type())
associationProcessor := DecodeToResource(res, value.Interface(), metaValue.MetaValues, processor.Context)
associationProcessor.Start()
if !associationProcessor.SkipLeft {
field.Set(value.Elem())
}
} else if field.Kind() == reflect.Slice {
var fieldType = field.Type().Elem()
var isPtr bool
if fieldType.Kind() == reflect.Ptr {
fieldType = fieldType.Elem()
isPtr = true
}
value := reflect.New(fieldType)
associationProcessor := DecodeToResource(res, value.Interface(), metaValue.MetaValues, processor.Context)
associationProcessor.Start()
if !associationProcessor.SkipLeft {
if !reflect.DeepEqual(reflect.Zero(fieldType).Interface(), value.Elem().Interface()) {
if isPtr {
field.Set(reflect.Append(field, value))
} else {
field.Set(reflect.Append(field, value.Elem()))
}
}
}
}
}
return
}
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)
}
}
}
// defaultExtensionValue returns the default value for extension.
// If no default for an extension is defined ErrMissingExtension is returned.
func defaultExtensionValue(extension *ExtensionDesc) (interface{}, error) {
t := reflect.TypeOf(extension.ExtensionType)
props := extensionProperties(extension)
sf, _, err := fieldDefault(t, props)
if err != nil {
return nil, err
}
if sf == nil || sf.value == nil {
// There is no default value.
return nil, ErrMissingExtension
}
if t.Kind() != reflect.Ptr {
// We do not need to return a Ptr, we can directly return sf.value.
return sf.value, nil
}
// We need to return an interface{} that is a pointer to sf.value.
value := reflect.New(t).Elem()
value.Set(reflect.New(value.Type().Elem()))
if sf.kind == reflect.Int32 {
// We may have an int32 or an enum, but the underlying data is int32.
// Since we can't set an int32 into a non int32 reflect.value directly
// set it as a int32.
value.Elem().SetInt(int64(sf.value.(int32)))
} else {
value.Elem().Set(reflect.ValueOf(sf.value))
}
return value.Interface(), nil
}
func (m *reflectedMethod) NewInput() reflect.Value {
if m.InputType.Kind() == reflect.Ptr {
return reflect.New(m.InputType.Elem())
} else {
return reflect.New(m.InputType)
}
}