mirror of
https://github.com/k3s-io/kubernetes.git
synced 2025-07-25 04:33:26 +00:00
bump(github.com/ugorji/go): 1e4b55517031c729d47ad7397bbc4ce36646166e
This commit is contained in:
parent
524aaa2f7f
commit
056ef49c76
2
Godeps/Godeps.json
generated
2
Godeps/Godeps.json
generated
@ -926,7 +926,7 @@
|
||||
},
|
||||
{
|
||||
"ImportPath": "github.com/ugorji/go/codec",
|
||||
"Rev": "4a79e5b7b21e51ae8d61641bca20399b79735a32"
|
||||
"Rev": "f4485b318aadd133842532f841dc205a8e339d74"
|
||||
},
|
||||
{
|
||||
"ImportPath": "github.com/vishvananda/netlink",
|
||||
|
2
Godeps/_workspace/src/github.com/ugorji/go/codec/0doc.go
generated
vendored
2
Godeps/_workspace/src/github.com/ugorji/go/codec/0doc.go
generated
vendored
@ -186,7 +186,7 @@ package codec
|
||||
// Name string
|
||||
// Ys []Y
|
||||
// Ys chan <- Y
|
||||
// Ys func(interface{}) -> call this interface for each entry in there.
|
||||
// Ys func(Y) -> call this function for each entry
|
||||
// }
|
||||
// - Consider adding a isZeroer interface { isZero() bool }
|
||||
// It is used within isEmpty, for omitEmpty support.
|
||||
|
2
Godeps/_workspace/src/github.com/ugorji/go/codec/cbor.go
generated
vendored
2
Godeps/_workspace/src/github.com/ugorji/go/codec/cbor.go
generated
vendored
@ -508,7 +508,7 @@ func (d *cborDecDriver) DecodeNaked() {
|
||||
n.v = valueTypeExt
|
||||
n.u = d.decUint()
|
||||
n.l = nil
|
||||
d.bdRead = false
|
||||
// d.bdRead = false
|
||||
// d.d.decode(&re.Value) // handled by decode itself.
|
||||
// decodeFurther = true
|
||||
default:
|
||||
|
19
Godeps/_workspace/src/github.com/ugorji/go/codec/decode.go
generated
vendored
19
Godeps/_workspace/src/github.com/ugorji/go/codec/decode.go
generated
vendored
@ -583,14 +583,16 @@ func (f *decFnInfo) kInterfaceNaked() (rvn reflect.Value) {
|
||||
if d.mtid == 0 || d.mtid == mapIntfIntfTypId {
|
||||
l := len(n.ms)
|
||||
n.ms = append(n.ms, nil)
|
||||
d.decode(&n.ms[l])
|
||||
rvn = reflect.ValueOf(&n.ms[l]).Elem()
|
||||
var v2 interface{} = &n.ms[l]
|
||||
d.decode(v2)
|
||||
rvn = reflect.ValueOf(v2).Elem()
|
||||
n.ms = n.ms[:l]
|
||||
} else if d.mtid == mapStrIntfTypId { // for json performance
|
||||
l := len(n.ns)
|
||||
n.ns = append(n.ns, nil)
|
||||
d.decode(&n.ns[l])
|
||||
rvn = reflect.ValueOf(&n.ns[l]).Elem()
|
||||
var v2 interface{} = &n.ns[l]
|
||||
d.decode(v2)
|
||||
rvn = reflect.ValueOf(v2).Elem()
|
||||
n.ns = n.ns[:l]
|
||||
} else {
|
||||
rvn = reflect.New(d.h.MapType).Elem()
|
||||
@ -601,8 +603,9 @@ func (f *decFnInfo) kInterfaceNaked() (rvn reflect.Value) {
|
||||
if d.stid == 0 || d.stid == intfSliceTypId {
|
||||
l := len(n.ss)
|
||||
n.ss = append(n.ss, nil)
|
||||
d.decode(&n.ss[l])
|
||||
rvn = reflect.ValueOf(&n.ss[l]).Elem()
|
||||
var v2 interface{} = &n.ss[l]
|
||||
d.decode(v2)
|
||||
rvn = reflect.ValueOf(v2).Elem()
|
||||
n.ss = n.ss[:l]
|
||||
} else {
|
||||
rvn = reflect.New(d.h.SliceType).Elem()
|
||||
@ -615,9 +618,9 @@ func (f *decFnInfo) kInterfaceNaked() (rvn reflect.Value) {
|
||||
l := len(n.is)
|
||||
n.is = append(n.is, nil)
|
||||
v2 := &n.is[l]
|
||||
n.is = n.is[:l]
|
||||
d.decode(v2)
|
||||
v = *v2
|
||||
n.is = n.is[:l]
|
||||
}
|
||||
bfn := d.h.getExtForTag(tag)
|
||||
if bfn == nil {
|
||||
@ -1453,8 +1456,8 @@ func (d *Decoder) swallow() {
|
||||
l := len(n.is)
|
||||
n.is = append(n.is, nil)
|
||||
v2 := &n.is[l]
|
||||
n.is = n.is[:l]
|
||||
d.decode(v2)
|
||||
n.is = n.is[:l]
|
||||
}
|
||||
}
|
||||
}
|
||||
|
7
Godeps/_workspace/src/github.com/ugorji/go/codec/encode.go
generated
vendored
7
Godeps/_workspace/src/github.com/ugorji/go/codec/encode.go
generated
vendored
@ -473,7 +473,7 @@ func (f *encFnInfo) kSlice(rv reflect.Value) {
|
||||
for j := 0; j < l; j++ {
|
||||
if cr != nil {
|
||||
if ti.mbs {
|
||||
if l%2 == 0 {
|
||||
if j%2 == 0 {
|
||||
cr.sendContainerState(containerMapKey)
|
||||
} else {
|
||||
cr.sendContainerState(containerMapValue)
|
||||
@ -1188,7 +1188,8 @@ func (e *Encoder) doEncodeValue(rv reflect.Value, fn *encFn, sptr uintptr,
|
||||
if fn == nil {
|
||||
rt := rv.Type()
|
||||
rtid := reflect.ValueOf(rt).Pointer()
|
||||
fn = e.getEncFn(rtid, rt, true, true)
|
||||
// fn = e.getEncFn(rtid, rt, true, true)
|
||||
fn = e.getEncFn(rtid, rt, checkFastpath, checkCodecSelfer)
|
||||
}
|
||||
fn.f(&fn.i, rv)
|
||||
if sptr != 0 {
|
||||
@ -1265,7 +1266,7 @@ func (e *Encoder) getEncFn(rtid uintptr, rt reflect.Type, checkFastpath, checkCo
|
||||
} else {
|
||||
rk := rt.Kind()
|
||||
if fastpathEnabled && checkFastpath && (rk == reflect.Map || rk == reflect.Slice) {
|
||||
if rt.PkgPath() == "" {
|
||||
if rt.PkgPath() == "" { // un-named slice or map
|
||||
if idx := fastpathAV.index(rtid); idx != -1 {
|
||||
fn.f = fastpathAV[idx].encfn
|
||||
}
|
||||
|
495
Godeps/_workspace/src/github.com/ugorji/go/codec/fast-path.generated.go
generated
vendored
495
Godeps/_workspace/src/github.com/ugorji/go/codec/fast-path.generated.go
generated
vendored
@ -3124,7 +3124,11 @@ func fastpathEncodeTypeSwitchMap(iv interface{}, e *Encoder) bool {
|
||||
// -- -- fast path functions
|
||||
|
||||
func (f *encFnInfo) fastpathEncSliceIntfR(rv reflect.Value) {
|
||||
fastpathTV.EncSliceIntfV(rv.Interface().([]interface{}), fastpathCheckNilFalse, f.e)
|
||||
if f.ti.mbs {
|
||||
fastpathTV.EncAsMapSliceIntfV(rv.Interface().([]interface{}), fastpathCheckNilFalse, f.e)
|
||||
} else {
|
||||
fastpathTV.EncSliceIntfV(rv.Interface().([]interface{}), fastpathCheckNilFalse, f.e)
|
||||
}
|
||||
}
|
||||
func (_ fastpathT) EncSliceIntfV(v []interface{}, checkNil bool, e *Encoder) {
|
||||
ee := e.e
|
||||
@ -3145,8 +3149,39 @@ func (_ fastpathT) EncSliceIntfV(v []interface{}, checkNil bool, e *Encoder) {
|
||||
}
|
||||
}
|
||||
|
||||
func (_ fastpathT) EncAsMapSliceIntfV(v []interface{}, checkNil bool, e *Encoder) {
|
||||
ee := e.e
|
||||
cr := e.cr
|
||||
if checkNil && v == nil {
|
||||
ee.EncodeNil()
|
||||
return
|
||||
}
|
||||
if len(v)%2 == 1 {
|
||||
e.errorf("mapBySlice requires even slice length, but got %v", len(v))
|
||||
return
|
||||
}
|
||||
ee.EncodeMapStart(len(v) / 2)
|
||||
for j, v2 := range v {
|
||||
if cr != nil {
|
||||
if j%2 == 0 {
|
||||
cr.sendContainerState(containerMapKey)
|
||||
} else {
|
||||
cr.sendContainerState(containerMapValue)
|
||||
}
|
||||
}
|
||||
e.encode(v2)
|
||||
}
|
||||
if cr != nil {
|
||||
cr.sendContainerState(containerMapEnd)
|
||||
}
|
||||
}
|
||||
|
||||
func (f *encFnInfo) fastpathEncSliceStringR(rv reflect.Value) {
|
||||
fastpathTV.EncSliceStringV(rv.Interface().([]string), fastpathCheckNilFalse, f.e)
|
||||
if f.ti.mbs {
|
||||
fastpathTV.EncAsMapSliceStringV(rv.Interface().([]string), fastpathCheckNilFalse, f.e)
|
||||
} else {
|
||||
fastpathTV.EncSliceStringV(rv.Interface().([]string), fastpathCheckNilFalse, f.e)
|
||||
}
|
||||
}
|
||||
func (_ fastpathT) EncSliceStringV(v []string, checkNil bool, e *Encoder) {
|
||||
ee := e.e
|
||||
@ -3167,8 +3202,39 @@ func (_ fastpathT) EncSliceStringV(v []string, checkNil bool, e *Encoder) {
|
||||
}
|
||||
}
|
||||
|
||||
func (_ fastpathT) EncAsMapSliceStringV(v []string, checkNil bool, e *Encoder) {
|
||||
ee := e.e
|
||||
cr := e.cr
|
||||
if checkNil && v == nil {
|
||||
ee.EncodeNil()
|
||||
return
|
||||
}
|
||||
if len(v)%2 == 1 {
|
||||
e.errorf("mapBySlice requires even slice length, but got %v", len(v))
|
||||
return
|
||||
}
|
||||
ee.EncodeMapStart(len(v) / 2)
|
||||
for j, v2 := range v {
|
||||
if cr != nil {
|
||||
if j%2 == 0 {
|
||||
cr.sendContainerState(containerMapKey)
|
||||
} else {
|
||||
cr.sendContainerState(containerMapValue)
|
||||
}
|
||||
}
|
||||
ee.EncodeString(c_UTF8, v2)
|
||||
}
|
||||
if cr != nil {
|
||||
cr.sendContainerState(containerMapEnd)
|
||||
}
|
||||
}
|
||||
|
||||
func (f *encFnInfo) fastpathEncSliceFloat32R(rv reflect.Value) {
|
||||
fastpathTV.EncSliceFloat32V(rv.Interface().([]float32), fastpathCheckNilFalse, f.e)
|
||||
if f.ti.mbs {
|
||||
fastpathTV.EncAsMapSliceFloat32V(rv.Interface().([]float32), fastpathCheckNilFalse, f.e)
|
||||
} else {
|
||||
fastpathTV.EncSliceFloat32V(rv.Interface().([]float32), fastpathCheckNilFalse, f.e)
|
||||
}
|
||||
}
|
||||
func (_ fastpathT) EncSliceFloat32V(v []float32, checkNil bool, e *Encoder) {
|
||||
ee := e.e
|
||||
@ -3189,8 +3255,39 @@ func (_ fastpathT) EncSliceFloat32V(v []float32, checkNil bool, e *Encoder) {
|
||||
}
|
||||
}
|
||||
|
||||
func (_ fastpathT) EncAsMapSliceFloat32V(v []float32, checkNil bool, e *Encoder) {
|
||||
ee := e.e
|
||||
cr := e.cr
|
||||
if checkNil && v == nil {
|
||||
ee.EncodeNil()
|
||||
return
|
||||
}
|
||||
if len(v)%2 == 1 {
|
||||
e.errorf("mapBySlice requires even slice length, but got %v", len(v))
|
||||
return
|
||||
}
|
||||
ee.EncodeMapStart(len(v) / 2)
|
||||
for j, v2 := range v {
|
||||
if cr != nil {
|
||||
if j%2 == 0 {
|
||||
cr.sendContainerState(containerMapKey)
|
||||
} else {
|
||||
cr.sendContainerState(containerMapValue)
|
||||
}
|
||||
}
|
||||
ee.EncodeFloat32(v2)
|
||||
}
|
||||
if cr != nil {
|
||||
cr.sendContainerState(containerMapEnd)
|
||||
}
|
||||
}
|
||||
|
||||
func (f *encFnInfo) fastpathEncSliceFloat64R(rv reflect.Value) {
|
||||
fastpathTV.EncSliceFloat64V(rv.Interface().([]float64), fastpathCheckNilFalse, f.e)
|
||||
if f.ti.mbs {
|
||||
fastpathTV.EncAsMapSliceFloat64V(rv.Interface().([]float64), fastpathCheckNilFalse, f.e)
|
||||
} else {
|
||||
fastpathTV.EncSliceFloat64V(rv.Interface().([]float64), fastpathCheckNilFalse, f.e)
|
||||
}
|
||||
}
|
||||
func (_ fastpathT) EncSliceFloat64V(v []float64, checkNil bool, e *Encoder) {
|
||||
ee := e.e
|
||||
@ -3211,8 +3308,39 @@ func (_ fastpathT) EncSliceFloat64V(v []float64, checkNil bool, e *Encoder) {
|
||||
}
|
||||
}
|
||||
|
||||
func (_ fastpathT) EncAsMapSliceFloat64V(v []float64, checkNil bool, e *Encoder) {
|
||||
ee := e.e
|
||||
cr := e.cr
|
||||
if checkNil && v == nil {
|
||||
ee.EncodeNil()
|
||||
return
|
||||
}
|
||||
if len(v)%2 == 1 {
|
||||
e.errorf("mapBySlice requires even slice length, but got %v", len(v))
|
||||
return
|
||||
}
|
||||
ee.EncodeMapStart(len(v) / 2)
|
||||
for j, v2 := range v {
|
||||
if cr != nil {
|
||||
if j%2 == 0 {
|
||||
cr.sendContainerState(containerMapKey)
|
||||
} else {
|
||||
cr.sendContainerState(containerMapValue)
|
||||
}
|
||||
}
|
||||
ee.EncodeFloat64(v2)
|
||||
}
|
||||
if cr != nil {
|
||||
cr.sendContainerState(containerMapEnd)
|
||||
}
|
||||
}
|
||||
|
||||
func (f *encFnInfo) fastpathEncSliceUintR(rv reflect.Value) {
|
||||
fastpathTV.EncSliceUintV(rv.Interface().([]uint), fastpathCheckNilFalse, f.e)
|
||||
if f.ti.mbs {
|
||||
fastpathTV.EncAsMapSliceUintV(rv.Interface().([]uint), fastpathCheckNilFalse, f.e)
|
||||
} else {
|
||||
fastpathTV.EncSliceUintV(rv.Interface().([]uint), fastpathCheckNilFalse, f.e)
|
||||
}
|
||||
}
|
||||
func (_ fastpathT) EncSliceUintV(v []uint, checkNil bool, e *Encoder) {
|
||||
ee := e.e
|
||||
@ -3233,8 +3361,39 @@ func (_ fastpathT) EncSliceUintV(v []uint, checkNil bool, e *Encoder) {
|
||||
}
|
||||
}
|
||||
|
||||
func (_ fastpathT) EncAsMapSliceUintV(v []uint, checkNil bool, e *Encoder) {
|
||||
ee := e.e
|
||||
cr := e.cr
|
||||
if checkNil && v == nil {
|
||||
ee.EncodeNil()
|
||||
return
|
||||
}
|
||||
if len(v)%2 == 1 {
|
||||
e.errorf("mapBySlice requires even slice length, but got %v", len(v))
|
||||
return
|
||||
}
|
||||
ee.EncodeMapStart(len(v) / 2)
|
||||
for j, v2 := range v {
|
||||
if cr != nil {
|
||||
if j%2 == 0 {
|
||||
cr.sendContainerState(containerMapKey)
|
||||
} else {
|
||||
cr.sendContainerState(containerMapValue)
|
||||
}
|
||||
}
|
||||
ee.EncodeUint(uint64(v2))
|
||||
}
|
||||
if cr != nil {
|
||||
cr.sendContainerState(containerMapEnd)
|
||||
}
|
||||
}
|
||||
|
||||
func (f *encFnInfo) fastpathEncSliceUint16R(rv reflect.Value) {
|
||||
fastpathTV.EncSliceUint16V(rv.Interface().([]uint16), fastpathCheckNilFalse, f.e)
|
||||
if f.ti.mbs {
|
||||
fastpathTV.EncAsMapSliceUint16V(rv.Interface().([]uint16), fastpathCheckNilFalse, f.e)
|
||||
} else {
|
||||
fastpathTV.EncSliceUint16V(rv.Interface().([]uint16), fastpathCheckNilFalse, f.e)
|
||||
}
|
||||
}
|
||||
func (_ fastpathT) EncSliceUint16V(v []uint16, checkNil bool, e *Encoder) {
|
||||
ee := e.e
|
||||
@ -3255,8 +3414,39 @@ func (_ fastpathT) EncSliceUint16V(v []uint16, checkNil bool, e *Encoder) {
|
||||
}
|
||||
}
|
||||
|
||||
func (_ fastpathT) EncAsMapSliceUint16V(v []uint16, checkNil bool, e *Encoder) {
|
||||
ee := e.e
|
||||
cr := e.cr
|
||||
if checkNil && v == nil {
|
||||
ee.EncodeNil()
|
||||
return
|
||||
}
|
||||
if len(v)%2 == 1 {
|
||||
e.errorf("mapBySlice requires even slice length, but got %v", len(v))
|
||||
return
|
||||
}
|
||||
ee.EncodeMapStart(len(v) / 2)
|
||||
for j, v2 := range v {
|
||||
if cr != nil {
|
||||
if j%2 == 0 {
|
||||
cr.sendContainerState(containerMapKey)
|
||||
} else {
|
||||
cr.sendContainerState(containerMapValue)
|
||||
}
|
||||
}
|
||||
ee.EncodeUint(uint64(v2))
|
||||
}
|
||||
if cr != nil {
|
||||
cr.sendContainerState(containerMapEnd)
|
||||
}
|
||||
}
|
||||
|
||||
func (f *encFnInfo) fastpathEncSliceUint32R(rv reflect.Value) {
|
||||
fastpathTV.EncSliceUint32V(rv.Interface().([]uint32), fastpathCheckNilFalse, f.e)
|
||||
if f.ti.mbs {
|
||||
fastpathTV.EncAsMapSliceUint32V(rv.Interface().([]uint32), fastpathCheckNilFalse, f.e)
|
||||
} else {
|
||||
fastpathTV.EncSliceUint32V(rv.Interface().([]uint32), fastpathCheckNilFalse, f.e)
|
||||
}
|
||||
}
|
||||
func (_ fastpathT) EncSliceUint32V(v []uint32, checkNil bool, e *Encoder) {
|
||||
ee := e.e
|
||||
@ -3277,8 +3467,39 @@ func (_ fastpathT) EncSliceUint32V(v []uint32, checkNil bool, e *Encoder) {
|
||||
}
|
||||
}
|
||||
|
||||
func (_ fastpathT) EncAsMapSliceUint32V(v []uint32, checkNil bool, e *Encoder) {
|
||||
ee := e.e
|
||||
cr := e.cr
|
||||
if checkNil && v == nil {
|
||||
ee.EncodeNil()
|
||||
return
|
||||
}
|
||||
if len(v)%2 == 1 {
|
||||
e.errorf("mapBySlice requires even slice length, but got %v", len(v))
|
||||
return
|
||||
}
|
||||
ee.EncodeMapStart(len(v) / 2)
|
||||
for j, v2 := range v {
|
||||
if cr != nil {
|
||||
if j%2 == 0 {
|
||||
cr.sendContainerState(containerMapKey)
|
||||
} else {
|
||||
cr.sendContainerState(containerMapValue)
|
||||
}
|
||||
}
|
||||
ee.EncodeUint(uint64(v2))
|
||||
}
|
||||
if cr != nil {
|
||||
cr.sendContainerState(containerMapEnd)
|
||||
}
|
||||
}
|
||||
|
||||
func (f *encFnInfo) fastpathEncSliceUint64R(rv reflect.Value) {
|
||||
fastpathTV.EncSliceUint64V(rv.Interface().([]uint64), fastpathCheckNilFalse, f.e)
|
||||
if f.ti.mbs {
|
||||
fastpathTV.EncAsMapSliceUint64V(rv.Interface().([]uint64), fastpathCheckNilFalse, f.e)
|
||||
} else {
|
||||
fastpathTV.EncSliceUint64V(rv.Interface().([]uint64), fastpathCheckNilFalse, f.e)
|
||||
}
|
||||
}
|
||||
func (_ fastpathT) EncSliceUint64V(v []uint64, checkNil bool, e *Encoder) {
|
||||
ee := e.e
|
||||
@ -3299,8 +3520,39 @@ func (_ fastpathT) EncSliceUint64V(v []uint64, checkNil bool, e *Encoder) {
|
||||
}
|
||||
}
|
||||
|
||||
func (_ fastpathT) EncAsMapSliceUint64V(v []uint64, checkNil bool, e *Encoder) {
|
||||
ee := e.e
|
||||
cr := e.cr
|
||||
if checkNil && v == nil {
|
||||
ee.EncodeNil()
|
||||
return
|
||||
}
|
||||
if len(v)%2 == 1 {
|
||||
e.errorf("mapBySlice requires even slice length, but got %v", len(v))
|
||||
return
|
||||
}
|
||||
ee.EncodeMapStart(len(v) / 2)
|
||||
for j, v2 := range v {
|
||||
if cr != nil {
|
||||
if j%2 == 0 {
|
||||
cr.sendContainerState(containerMapKey)
|
||||
} else {
|
||||
cr.sendContainerState(containerMapValue)
|
||||
}
|
||||
}
|
||||
ee.EncodeUint(uint64(v2))
|
||||
}
|
||||
if cr != nil {
|
||||
cr.sendContainerState(containerMapEnd)
|
||||
}
|
||||
}
|
||||
|
||||
func (f *encFnInfo) fastpathEncSliceUintptrR(rv reflect.Value) {
|
||||
fastpathTV.EncSliceUintptrV(rv.Interface().([]uintptr), fastpathCheckNilFalse, f.e)
|
||||
if f.ti.mbs {
|
||||
fastpathTV.EncAsMapSliceUintptrV(rv.Interface().([]uintptr), fastpathCheckNilFalse, f.e)
|
||||
} else {
|
||||
fastpathTV.EncSliceUintptrV(rv.Interface().([]uintptr), fastpathCheckNilFalse, f.e)
|
||||
}
|
||||
}
|
||||
func (_ fastpathT) EncSliceUintptrV(v []uintptr, checkNil bool, e *Encoder) {
|
||||
ee := e.e
|
||||
@ -3321,8 +3573,39 @@ func (_ fastpathT) EncSliceUintptrV(v []uintptr, checkNil bool, e *Encoder) {
|
||||
}
|
||||
}
|
||||
|
||||
func (_ fastpathT) EncAsMapSliceUintptrV(v []uintptr, checkNil bool, e *Encoder) {
|
||||
ee := e.e
|
||||
cr := e.cr
|
||||
if checkNil && v == nil {
|
||||
ee.EncodeNil()
|
||||
return
|
||||
}
|
||||
if len(v)%2 == 1 {
|
||||
e.errorf("mapBySlice requires even slice length, but got %v", len(v))
|
||||
return
|
||||
}
|
||||
ee.EncodeMapStart(len(v) / 2)
|
||||
for j, v2 := range v {
|
||||
if cr != nil {
|
||||
if j%2 == 0 {
|
||||
cr.sendContainerState(containerMapKey)
|
||||
} else {
|
||||
cr.sendContainerState(containerMapValue)
|
||||
}
|
||||
}
|
||||
e.encode(v2)
|
||||
}
|
||||
if cr != nil {
|
||||
cr.sendContainerState(containerMapEnd)
|
||||
}
|
||||
}
|
||||
|
||||
func (f *encFnInfo) fastpathEncSliceIntR(rv reflect.Value) {
|
||||
fastpathTV.EncSliceIntV(rv.Interface().([]int), fastpathCheckNilFalse, f.e)
|
||||
if f.ti.mbs {
|
||||
fastpathTV.EncAsMapSliceIntV(rv.Interface().([]int), fastpathCheckNilFalse, f.e)
|
||||
} else {
|
||||
fastpathTV.EncSliceIntV(rv.Interface().([]int), fastpathCheckNilFalse, f.e)
|
||||
}
|
||||
}
|
||||
func (_ fastpathT) EncSliceIntV(v []int, checkNil bool, e *Encoder) {
|
||||
ee := e.e
|
||||
@ -3343,8 +3626,39 @@ func (_ fastpathT) EncSliceIntV(v []int, checkNil bool, e *Encoder) {
|
||||
}
|
||||
}
|
||||
|
||||
func (_ fastpathT) EncAsMapSliceIntV(v []int, checkNil bool, e *Encoder) {
|
||||
ee := e.e
|
||||
cr := e.cr
|
||||
if checkNil && v == nil {
|
||||
ee.EncodeNil()
|
||||
return
|
||||
}
|
||||
if len(v)%2 == 1 {
|
||||
e.errorf("mapBySlice requires even slice length, but got %v", len(v))
|
||||
return
|
||||
}
|
||||
ee.EncodeMapStart(len(v) / 2)
|
||||
for j, v2 := range v {
|
||||
if cr != nil {
|
||||
if j%2 == 0 {
|
||||
cr.sendContainerState(containerMapKey)
|
||||
} else {
|
||||
cr.sendContainerState(containerMapValue)
|
||||
}
|
||||
}
|
||||
ee.EncodeInt(int64(v2))
|
||||
}
|
||||
if cr != nil {
|
||||
cr.sendContainerState(containerMapEnd)
|
||||
}
|
||||
}
|
||||
|
||||
func (f *encFnInfo) fastpathEncSliceInt8R(rv reflect.Value) {
|
||||
fastpathTV.EncSliceInt8V(rv.Interface().([]int8), fastpathCheckNilFalse, f.e)
|
||||
if f.ti.mbs {
|
||||
fastpathTV.EncAsMapSliceInt8V(rv.Interface().([]int8), fastpathCheckNilFalse, f.e)
|
||||
} else {
|
||||
fastpathTV.EncSliceInt8V(rv.Interface().([]int8), fastpathCheckNilFalse, f.e)
|
||||
}
|
||||
}
|
||||
func (_ fastpathT) EncSliceInt8V(v []int8, checkNil bool, e *Encoder) {
|
||||
ee := e.e
|
||||
@ -3365,8 +3679,39 @@ func (_ fastpathT) EncSliceInt8V(v []int8, checkNil bool, e *Encoder) {
|
||||
}
|
||||
}
|
||||
|
||||
func (_ fastpathT) EncAsMapSliceInt8V(v []int8, checkNil bool, e *Encoder) {
|
||||
ee := e.e
|
||||
cr := e.cr
|
||||
if checkNil && v == nil {
|
||||
ee.EncodeNil()
|
||||
return
|
||||
}
|
||||
if len(v)%2 == 1 {
|
||||
e.errorf("mapBySlice requires even slice length, but got %v", len(v))
|
||||
return
|
||||
}
|
||||
ee.EncodeMapStart(len(v) / 2)
|
||||
for j, v2 := range v {
|
||||
if cr != nil {
|
||||
if j%2 == 0 {
|
||||
cr.sendContainerState(containerMapKey)
|
||||
} else {
|
||||
cr.sendContainerState(containerMapValue)
|
||||
}
|
||||
}
|
||||
ee.EncodeInt(int64(v2))
|
||||
}
|
||||
if cr != nil {
|
||||
cr.sendContainerState(containerMapEnd)
|
||||
}
|
||||
}
|
||||
|
||||
func (f *encFnInfo) fastpathEncSliceInt16R(rv reflect.Value) {
|
||||
fastpathTV.EncSliceInt16V(rv.Interface().([]int16), fastpathCheckNilFalse, f.e)
|
||||
if f.ti.mbs {
|
||||
fastpathTV.EncAsMapSliceInt16V(rv.Interface().([]int16), fastpathCheckNilFalse, f.e)
|
||||
} else {
|
||||
fastpathTV.EncSliceInt16V(rv.Interface().([]int16), fastpathCheckNilFalse, f.e)
|
||||
}
|
||||
}
|
||||
func (_ fastpathT) EncSliceInt16V(v []int16, checkNil bool, e *Encoder) {
|
||||
ee := e.e
|
||||
@ -3387,8 +3732,39 @@ func (_ fastpathT) EncSliceInt16V(v []int16, checkNil bool, e *Encoder) {
|
||||
}
|
||||
}
|
||||
|
||||
func (_ fastpathT) EncAsMapSliceInt16V(v []int16, checkNil bool, e *Encoder) {
|
||||
ee := e.e
|
||||
cr := e.cr
|
||||
if checkNil && v == nil {
|
||||
ee.EncodeNil()
|
||||
return
|
||||
}
|
||||
if len(v)%2 == 1 {
|
||||
e.errorf("mapBySlice requires even slice length, but got %v", len(v))
|
||||
return
|
||||
}
|
||||
ee.EncodeMapStart(len(v) / 2)
|
||||
for j, v2 := range v {
|
||||
if cr != nil {
|
||||
if j%2 == 0 {
|
||||
cr.sendContainerState(containerMapKey)
|
||||
} else {
|
||||
cr.sendContainerState(containerMapValue)
|
||||
}
|
||||
}
|
||||
ee.EncodeInt(int64(v2))
|
||||
}
|
||||
if cr != nil {
|
||||
cr.sendContainerState(containerMapEnd)
|
||||
}
|
||||
}
|
||||
|
||||
func (f *encFnInfo) fastpathEncSliceInt32R(rv reflect.Value) {
|
||||
fastpathTV.EncSliceInt32V(rv.Interface().([]int32), fastpathCheckNilFalse, f.e)
|
||||
if f.ti.mbs {
|
||||
fastpathTV.EncAsMapSliceInt32V(rv.Interface().([]int32), fastpathCheckNilFalse, f.e)
|
||||
} else {
|
||||
fastpathTV.EncSliceInt32V(rv.Interface().([]int32), fastpathCheckNilFalse, f.e)
|
||||
}
|
||||
}
|
||||
func (_ fastpathT) EncSliceInt32V(v []int32, checkNil bool, e *Encoder) {
|
||||
ee := e.e
|
||||
@ -3409,8 +3785,39 @@ func (_ fastpathT) EncSliceInt32V(v []int32, checkNil bool, e *Encoder) {
|
||||
}
|
||||
}
|
||||
|
||||
func (_ fastpathT) EncAsMapSliceInt32V(v []int32, checkNil bool, e *Encoder) {
|
||||
ee := e.e
|
||||
cr := e.cr
|
||||
if checkNil && v == nil {
|
||||
ee.EncodeNil()
|
||||
return
|
||||
}
|
||||
if len(v)%2 == 1 {
|
||||
e.errorf("mapBySlice requires even slice length, but got %v", len(v))
|
||||
return
|
||||
}
|
||||
ee.EncodeMapStart(len(v) / 2)
|
||||
for j, v2 := range v {
|
||||
if cr != nil {
|
||||
if j%2 == 0 {
|
||||
cr.sendContainerState(containerMapKey)
|
||||
} else {
|
||||
cr.sendContainerState(containerMapValue)
|
||||
}
|
||||
}
|
||||
ee.EncodeInt(int64(v2))
|
||||
}
|
||||
if cr != nil {
|
||||
cr.sendContainerState(containerMapEnd)
|
||||
}
|
||||
}
|
||||
|
||||
func (f *encFnInfo) fastpathEncSliceInt64R(rv reflect.Value) {
|
||||
fastpathTV.EncSliceInt64V(rv.Interface().([]int64), fastpathCheckNilFalse, f.e)
|
||||
if f.ti.mbs {
|
||||
fastpathTV.EncAsMapSliceInt64V(rv.Interface().([]int64), fastpathCheckNilFalse, f.e)
|
||||
} else {
|
||||
fastpathTV.EncSliceInt64V(rv.Interface().([]int64), fastpathCheckNilFalse, f.e)
|
||||
}
|
||||
}
|
||||
func (_ fastpathT) EncSliceInt64V(v []int64, checkNil bool, e *Encoder) {
|
||||
ee := e.e
|
||||
@ -3431,8 +3838,39 @@ func (_ fastpathT) EncSliceInt64V(v []int64, checkNil bool, e *Encoder) {
|
||||
}
|
||||
}
|
||||
|
||||
func (_ fastpathT) EncAsMapSliceInt64V(v []int64, checkNil bool, e *Encoder) {
|
||||
ee := e.e
|
||||
cr := e.cr
|
||||
if checkNil && v == nil {
|
||||
ee.EncodeNil()
|
||||
return
|
||||
}
|
||||
if len(v)%2 == 1 {
|
||||
e.errorf("mapBySlice requires even slice length, but got %v", len(v))
|
||||
return
|
||||
}
|
||||
ee.EncodeMapStart(len(v) / 2)
|
||||
for j, v2 := range v {
|
||||
if cr != nil {
|
||||
if j%2 == 0 {
|
||||
cr.sendContainerState(containerMapKey)
|
||||
} else {
|
||||
cr.sendContainerState(containerMapValue)
|
||||
}
|
||||
}
|
||||
ee.EncodeInt(int64(v2))
|
||||
}
|
||||
if cr != nil {
|
||||
cr.sendContainerState(containerMapEnd)
|
||||
}
|
||||
}
|
||||
|
||||
func (f *encFnInfo) fastpathEncSliceBoolR(rv reflect.Value) {
|
||||
fastpathTV.EncSliceBoolV(rv.Interface().([]bool), fastpathCheckNilFalse, f.e)
|
||||
if f.ti.mbs {
|
||||
fastpathTV.EncAsMapSliceBoolV(rv.Interface().([]bool), fastpathCheckNilFalse, f.e)
|
||||
} else {
|
||||
fastpathTV.EncSliceBoolV(rv.Interface().([]bool), fastpathCheckNilFalse, f.e)
|
||||
}
|
||||
}
|
||||
func (_ fastpathT) EncSliceBoolV(v []bool, checkNil bool, e *Encoder) {
|
||||
ee := e.e
|
||||
@ -3453,6 +3891,33 @@ func (_ fastpathT) EncSliceBoolV(v []bool, checkNil bool, e *Encoder) {
|
||||
}
|
||||
}
|
||||
|
||||
func (_ fastpathT) EncAsMapSliceBoolV(v []bool, checkNil bool, e *Encoder) {
|
||||
ee := e.e
|
||||
cr := e.cr
|
||||
if checkNil && v == nil {
|
||||
ee.EncodeNil()
|
||||
return
|
||||
}
|
||||
if len(v)%2 == 1 {
|
||||
e.errorf("mapBySlice requires even slice length, but got %v", len(v))
|
||||
return
|
||||
}
|
||||
ee.EncodeMapStart(len(v) / 2)
|
||||
for j, v2 := range v {
|
||||
if cr != nil {
|
||||
if j%2 == 0 {
|
||||
cr.sendContainerState(containerMapKey)
|
||||
} else {
|
||||
cr.sendContainerState(containerMapValue)
|
||||
}
|
||||
}
|
||||
ee.EncodeBool(v2)
|
||||
}
|
||||
if cr != nil {
|
||||
cr.sendContainerState(containerMapEnd)
|
||||
}
|
||||
}
|
||||
|
||||
func (f *encFnInfo) fastpathEncMapIntfIntfR(rv reflect.Value) {
|
||||
fastpathTV.EncMapIntfIntfV(rv.Interface().(map[interface{}]interface{}), fastpathCheckNilFalse, f.e)
|
||||
}
|
||||
|
31
Godeps/_workspace/src/github.com/ugorji/go/codec/fast-path.go.tmpl
generated
vendored
31
Godeps/_workspace/src/github.com/ugorji/go/codec/fast-path.go.tmpl
generated
vendored
@ -165,7 +165,11 @@ func fastpathEncodeTypeSwitchMap(iv interface{}, e *Encoder) bool {
|
||||
{{range .Values}}{{if not .Primitive}}{{if not .MapKey }}
|
||||
|
||||
func (f *encFnInfo) {{ .MethodNamePfx "fastpathEnc" false }}R(rv reflect.Value) {
|
||||
fastpathTV.{{ .MethodNamePfx "Enc" false }}V(rv.Interface().([]{{ .Elem }}), fastpathCheckNilFalse, f.e)
|
||||
if f.ti.mbs {
|
||||
fastpathTV.{{ .MethodNamePfx "EncAsMap" false }}V(rv.Interface().([]{{ .Elem }}), fastpathCheckNilFalse, f.e)
|
||||
} else {
|
||||
fastpathTV.{{ .MethodNamePfx "Enc" false }}V(rv.Interface().([]{{ .Elem }}), fastpathCheckNilFalse, f.e)
|
||||
}
|
||||
}
|
||||
func (_ fastpathT) {{ .MethodNamePfx "Enc" false }}V(v []{{ .Elem }}, checkNil bool, e *Encoder) {
|
||||
ee := e.e
|
||||
@ -182,6 +186,31 @@ func (_ fastpathT) {{ .MethodNamePfx "Enc" false }}V(v []{{ .Elem }}, checkNil b
|
||||
if cr != nil { cr.sendContainerState(containerArrayEnd) }{{/* ee.EncodeEnd() */}}
|
||||
}
|
||||
|
||||
func (_ fastpathT) {{ .MethodNamePfx "EncAsMap" false }}V(v []{{ .Elem }}, checkNil bool, e *Encoder) {
|
||||
ee := e.e
|
||||
cr := e.cr
|
||||
if checkNil && v == nil {
|
||||
ee.EncodeNil()
|
||||
return
|
||||
}
|
||||
if len(v)%2 == 1 {
|
||||
e.errorf("mapBySlice requires even slice length, but got %v", len(v))
|
||||
return
|
||||
}
|
||||
ee.EncodeMapStart(len(v) / 2)
|
||||
for j, v2 := range v {
|
||||
if cr != nil {
|
||||
if j%2 == 0 {
|
||||
cr.sendContainerState(containerMapKey)
|
||||
} else {
|
||||
cr.sendContainerState(containerMapValue)
|
||||
}
|
||||
}
|
||||
{{ encmd .Elem "v2"}}
|
||||
}
|
||||
if cr != nil { cr.sendContainerState(containerMapEnd) }
|
||||
}
|
||||
|
||||
{{end}}{{end}}{{end}}
|
||||
|
||||
{{range .Values}}{{if not .Primitive}}{{if .MapKey }}
|
||||
|
5
Godeps/_workspace/src/github.com/ugorji/go/codec/gen-dec-array.go.tmpl
generated
vendored
5
Godeps/_workspace/src/github.com/ugorji/go/codec/gen-dec-array.go.tmpl
generated
vendored
@ -1,6 +1,7 @@
|
||||
{{var "v"}} := {{if not isArray}}*{{end}}{{ .Varname }}
|
||||
{{var "h"}}, {{var "l"}} := z.DecSliceHelperStart() {{/* // helper, containerLenS */}}
|
||||
{{var "h"}}, {{var "l"}} := z.DecSliceHelperStart() {{/* // helper, containerLenS */}}{{if not isArray}}
|
||||
var {{var "c"}} bool {{/* // changed */}}
|
||||
_ = {{var "c"}}{{end}}
|
||||
if {{var "l"}} == 0 {
|
||||
{{if isSlice }}if {{var "v"}} == nil {
|
||||
{{var "v"}} = []{{ .Typ }}{}
|
||||
@ -26,6 +27,8 @@ if {{var "l"}} == 0 {
|
||||
}
|
||||
{{ else }} var {{var "rr"}}, {{var "rl"}} int {{/* // num2read, length of slice/array/chan */}}
|
||||
var {{var "rt"}} bool {{/* truncated */}}
|
||||
_, _ = {{var "rl"}}, {{var "rt"}}
|
||||
{{var "rr"}} = {{var "l"}} // len({{var "v"}})
|
||||
if {{var "l"}} > cap({{var "v"}}) {
|
||||
{{if isArray }}z.DecArrayCannotExpand(len({{var "v"}}), {{var "l"}})
|
||||
{{ else }}{{if not .Immutable }}
|
||||
|
5
Godeps/_workspace/src/github.com/ugorji/go/codec/gen.generated.go
generated
vendored
5
Godeps/_workspace/src/github.com/ugorji/go/codec/gen.generated.go
generated
vendored
@ -68,8 +68,9 @@ z.DecSendContainerState(codecSelfer_containerMapEnd{{ .Sfx }})
|
||||
|
||||
const genDecListTmpl = `
|
||||
{{var "v"}} := {{if not isArray}}*{{end}}{{ .Varname }}
|
||||
{{var "h"}}, {{var "l"}} := z.DecSliceHelperStart() {{/* // helper, containerLenS */}}
|
||||
{{var "h"}}, {{var "l"}} := z.DecSliceHelperStart() {{/* // helper, containerLenS */}}{{if not isArray}}
|
||||
var {{var "c"}} bool {{/* // changed */}}
|
||||
_ = {{var "c"}}{{end}}
|
||||
if {{var "l"}} == 0 {
|
||||
{{if isSlice }}if {{var "v"}} == nil {
|
||||
{{var "v"}} = []{{ .Typ }}{}
|
||||
@ -95,6 +96,8 @@ if {{var "l"}} == 0 {
|
||||
}
|
||||
{{ else }} var {{var "rr"}}, {{var "rl"}} int {{/* // num2read, length of slice/array/chan */}}
|
||||
var {{var "rt"}} bool {{/* truncated */}}
|
||||
_, _ = {{var "rl"}}, {{var "rt"}}
|
||||
{{var "rr"}} = {{var "l"}} // len({{var "v"}})
|
||||
if {{var "l"}} > cap({{var "v"}}) {
|
||||
{{if isArray }}z.DecArrayCannotExpand(len({{var "v"}}), {{var "l"}})
|
||||
{{ else }}{{if not .Immutable }}
|
||||
|
115
Godeps/_workspace/src/github.com/ugorji/go/codec/gen.go
generated
vendored
115
Godeps/_workspace/src/github.com/ugorji/go/codec/gen.go
generated
vendored
@ -21,6 +21,8 @@ import (
|
||||
"sync"
|
||||
"text/template"
|
||||
"time"
|
||||
"unicode"
|
||||
"unicode/utf8"
|
||||
)
|
||||
|
||||
// ---------------------------------------------------
|
||||
@ -266,6 +268,7 @@ func Gen(w io.Writer, buildTags, pkgName, uid string, useUnsafe bool, ti *TypeIn
|
||||
x.line("type " + x.hn + " struct{}")
|
||||
x.line("")
|
||||
|
||||
x.varsfxreset()
|
||||
x.line("func init() {")
|
||||
x.linef("if %sGenVersion != %v {", x.cpfx, GenVersion)
|
||||
x.line("_, file, _, _ := runtime.Caller(0)")
|
||||
@ -309,6 +312,7 @@ func Gen(w io.Writer, buildTags, pkgName, uid string, useUnsafe bool, ti *TypeIn
|
||||
for _, t := range x.ts {
|
||||
rtid := reflect.ValueOf(t).Pointer()
|
||||
// generate enc functions for all these slice/map types.
|
||||
x.varsfxreset()
|
||||
x.linef("func (x %s) enc%s(v %s%s, e *%sEncoder) {", x.hn, x.genMethodNameT(t), x.arr2str(t, "*"), x.genTypeName(t), x.cpfx)
|
||||
x.genRequiredMethodVars(true)
|
||||
switch t.Kind() {
|
||||
@ -323,6 +327,7 @@ func Gen(w io.Writer, buildTags, pkgName, uid string, useUnsafe bool, ti *TypeIn
|
||||
x.line("")
|
||||
|
||||
// generate dec functions for all these slice/map types.
|
||||
x.varsfxreset()
|
||||
x.linef("func (x %s) dec%s(v *%s, d *%sDecoder) {", x.hn, x.genMethodNameT(t), x.genTypeName(t), x.cpfx)
|
||||
x.genRequiredMethodVars(false)
|
||||
switch t.Kind() {
|
||||
@ -377,7 +382,7 @@ func (x *genRunner) genRefPkgs(t reflect.Type) {
|
||||
x.imn[tpkg] = tpkg
|
||||
} else {
|
||||
x.imc++
|
||||
x.imn[tpkg] = "pkg" + strconv.FormatUint(x.imc, 10) + "_" + tpkg[idx+1:]
|
||||
x.imn[tpkg] = "pkg" + strconv.FormatUint(x.imc, 10) + "_" + genGoIdentifier(tpkg[idx+1:], false)
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -408,6 +413,10 @@ func (x *genRunner) varsfx() string {
|
||||
return strconv.FormatUint(x.c, 10)
|
||||
}
|
||||
|
||||
func (x *genRunner) varsfxreset() {
|
||||
x.c = 0
|
||||
}
|
||||
|
||||
func (x *genRunner) out(s string) {
|
||||
if _, err := io.WriteString(x.w, s); err != nil {
|
||||
panic(err)
|
||||
@ -494,6 +503,7 @@ func (x *genRunner) selfer(encode bool) {
|
||||
// always make decode use a pointer receiver,
|
||||
// and structs always use a ptr receiver (encode|decode)
|
||||
isptr := !encode || t.Kind() == reflect.Struct
|
||||
x.varsfxreset()
|
||||
fnSigPfx := "func (x "
|
||||
if isptr {
|
||||
fnSigPfx += "*"
|
||||
@ -566,9 +576,28 @@ func (x *genRunner) xtraSM(varname string, encode bool, t reflect.Type) {
|
||||
} else {
|
||||
x.linef("h.dec%s((*%s)(%s), d)", x.genMethodNameT(t), x.genTypeName(t), varname)
|
||||
}
|
||||
if _, ok := x.tm[t]; !ok {
|
||||
x.tm[t] = struct{}{}
|
||||
x.ts = append(x.ts, t)
|
||||
x.registerXtraT(t)
|
||||
}
|
||||
|
||||
func (x *genRunner) registerXtraT(t reflect.Type) {
|
||||
// recursively register the types
|
||||
if _, ok := x.tm[t]; ok {
|
||||
return
|
||||
}
|
||||
var tkey reflect.Type
|
||||
switch t.Kind() {
|
||||
case reflect.Chan, reflect.Slice, reflect.Array:
|
||||
case reflect.Map:
|
||||
tkey = t.Key()
|
||||
default:
|
||||
return
|
||||
}
|
||||
x.tm[t] = struct{}{}
|
||||
x.ts = append(x.ts, t)
|
||||
// check if this refers to any xtra types eg. a slice of array: add the array
|
||||
x.registerXtraT(t.Elem())
|
||||
if tkey != nil {
|
||||
x.registerXtraT(tkey)
|
||||
}
|
||||
}
|
||||
|
||||
@ -608,22 +637,33 @@ func (x *genRunner) encVar(varname string, t reflect.Type) {
|
||||
|
||||
}
|
||||
|
||||
// enc will encode a variable (varname) of type T,
|
||||
// except t is of kind reflect.Struct or reflect.Array, wherein varname is of type *T (to prevent copying)
|
||||
// enc will encode a variable (varname) of type t,
|
||||
// except t is of kind reflect.Struct or reflect.Array, wherein varname is of type ptrTo(T) (to prevent copying)
|
||||
func (x *genRunner) enc(varname string, t reflect.Type) {
|
||||
// varName here must be to a pointer to a struct/array, or to a value directly.
|
||||
rtid := reflect.ValueOf(t).Pointer()
|
||||
// We call CodecEncodeSelf if one of the following are honored:
|
||||
// - the type already implements Selfer, call that
|
||||
// - the type has a Selfer implementation just created, use that
|
||||
// - the type is in the list of the ones we will generate for, but it is not currently being generated
|
||||
|
||||
mi := x.varsfx()
|
||||
tptr := reflect.PtrTo(t)
|
||||
tk := t.Kind()
|
||||
if x.checkForSelfer(t, varname) {
|
||||
if t.Implements(selferTyp) || (tptr.Implements(selferTyp) && (tk == reflect.Array || tk == reflect.Struct)) {
|
||||
x.line(varname + ".CodecEncodeSelf(e)")
|
||||
return
|
||||
if tk == reflect.Array || tk == reflect.Struct { // varname is of type *T
|
||||
if tptr.Implements(selferTyp) || t.Implements(selferTyp) {
|
||||
x.line(varname + ".CodecEncodeSelf(e)")
|
||||
return
|
||||
}
|
||||
} else { // varname is of type T
|
||||
if t.Implements(selferTyp) {
|
||||
x.line(varname + ".CodecEncodeSelf(e)")
|
||||
return
|
||||
} else if tptr.Implements(selferTyp) {
|
||||
x.linef("%ssf%s := &%s", genTempVarPfx, mi, varname)
|
||||
x.linef("%ssf%s.CodecEncodeSelf(e)", genTempVarPfx, mi)
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
if _, ok := x.te[rtid]; ok {
|
||||
@ -653,7 +693,6 @@ func (x *genRunner) enc(varname string, t reflect.Type) {
|
||||
// check if
|
||||
// - type is RawExt
|
||||
// - the type implements (Text|JSON|Binary)(Unm|M)arshal
|
||||
mi := x.varsfx()
|
||||
x.linef("%sm%s := z.EncBinary()", genTempVarPfx, mi)
|
||||
x.linef("_ = %sm%s", genTempVarPfx, mi)
|
||||
x.line("if false {") //start if block
|
||||
@ -676,15 +715,31 @@ func (x *genRunner) enc(varname string, t reflect.Type) {
|
||||
// first check if extensions are configued, before doing the interface conversion
|
||||
x.linef("} else if z.HasExtensions() && z.EncExt(%s) {", varname)
|
||||
}
|
||||
if t.Implements(binaryMarshalerTyp) || tptr.Implements(binaryMarshalerTyp) {
|
||||
x.linef("} else if %sm%s { z.EncBinaryMarshal(%v) ", genTempVarPfx, mi, varname)
|
||||
if tk == reflect.Array || tk == reflect.Struct { // varname is of type *T
|
||||
if t.Implements(binaryMarshalerTyp) || tptr.Implements(binaryMarshalerTyp) {
|
||||
x.linef("} else if %sm%s { z.EncBinaryMarshal(%v) ", genTempVarPfx, mi, varname)
|
||||
}
|
||||
if t.Implements(jsonMarshalerTyp) || tptr.Implements(jsonMarshalerTyp) {
|
||||
x.linef("} else if !%sm%s && z.IsJSONHandle() { z.EncJSONMarshal(%v) ", genTempVarPfx, mi, varname)
|
||||
} else if t.Implements(textMarshalerTyp) || tptr.Implements(textMarshalerTyp) {
|
||||
x.linef("} else if !%sm%s { z.EncTextMarshal(%v) ", genTempVarPfx, mi, varname)
|
||||
}
|
||||
} else { // varname is of type T
|
||||
if t.Implements(binaryMarshalerTyp) {
|
||||
x.linef("} else if %sm%s { z.EncBinaryMarshal(%v) ", genTempVarPfx, mi, varname)
|
||||
} else if tptr.Implements(binaryMarshalerTyp) {
|
||||
x.linef("} else if %sm%s { z.EncBinaryMarshal(&%v) ", genTempVarPfx, mi, varname)
|
||||
}
|
||||
if t.Implements(jsonMarshalerTyp) {
|
||||
x.linef("} else if !%sm%s && z.IsJSONHandle() { z.EncJSONMarshal(%v) ", genTempVarPfx, mi, varname)
|
||||
} else if tptr.Implements(jsonMarshalerTyp) {
|
||||
x.linef("} else if !%sm%s && z.IsJSONHandle() { z.EncJSONMarshal(&%v) ", genTempVarPfx, mi, varname)
|
||||
} else if t.Implements(textMarshalerTyp) {
|
||||
x.linef("} else if !%sm%s { z.EncTextMarshal(%v) ", genTempVarPfx, mi, varname)
|
||||
} else if tptr.Implements(textMarshalerTyp) {
|
||||
x.linef("} else if !%sm%s { z.EncTextMarshal(&%v) ", genTempVarPfx, mi, varname)
|
||||
}
|
||||
}
|
||||
if t.Implements(jsonMarshalerTyp) || tptr.Implements(jsonMarshalerTyp) {
|
||||
x.linef("} else if !%sm%s && z.IsJSONHandle() { z.EncJSONMarshal(%v) ", genTempVarPfx, mi, varname)
|
||||
} else if t.Implements(textMarshalerTyp) || tptr.Implements(textMarshalerTyp) {
|
||||
x.linef("} else if !%sm%s { z.EncTextMarshal(%v) ", genTempVarPfx, mi, varname)
|
||||
}
|
||||
|
||||
x.line("} else {")
|
||||
|
||||
switch t.Kind() {
|
||||
@ -1020,6 +1075,8 @@ func (x *genRunner) decVar(varname string, t reflect.Type, canBeNil bool) {
|
||||
}
|
||||
}
|
||||
|
||||
// dec will decode a variable (varname) of type ptrTo(t).
|
||||
// t is always a basetype (i.e. not of kind reflect.Ptr).
|
||||
func (x *genRunner) dec(varname string, t reflect.Type) {
|
||||
// assumptions:
|
||||
// - the varname is to a pointer already. No need to take address of it
|
||||
@ -1592,6 +1649,26 @@ func genImportPath(t reflect.Type) (s string) {
|
||||
return
|
||||
}
|
||||
|
||||
// A go identifier is (letter|_)[letter|number|_]*
|
||||
func genGoIdentifier(s string, checkFirstChar bool) string {
|
||||
b := make([]byte, 0, len(s))
|
||||
t := make([]byte, 4)
|
||||
var n int
|
||||
for i, r := range s {
|
||||
if checkFirstChar && i == 0 && !unicode.IsLetter(r) {
|
||||
b = append(b, '_')
|
||||
}
|
||||
// r must be unicode_letter, unicode_digit or _
|
||||
if unicode.IsLetter(r) || unicode.IsDigit(r) {
|
||||
n = utf8.EncodeRune(t, r)
|
||||
b = append(b, t[:n]...)
|
||||
} else {
|
||||
b = append(b, '_')
|
||||
}
|
||||
}
|
||||
return string(b)
|
||||
}
|
||||
|
||||
func genNonPtr(t reflect.Type) reflect.Type {
|
||||
for t.Kind() == reflect.Ptr {
|
||||
t = t.Elem()
|
||||
|
42
Godeps/_workspace/src/github.com/ugorji/go/codec/json.go
generated
vendored
42
Godeps/_workspace/src/github.com/ugorji/go/codec/json.go
generated
vendored
@ -206,10 +206,22 @@ func (e *jsonEncDriver) EncodeFloat64(f float64) {
|
||||
}
|
||||
|
||||
func (e *jsonEncDriver) EncodeInt(v int64) {
|
||||
if x := e.h.IntegerAsString; x == 'A' || x == 'L' && (v > 1<<53 || v < -(1<<53)) {
|
||||
e.w.writen1('"')
|
||||
e.w.writeb(strconv.AppendInt(e.b[:0], v, 10))
|
||||
e.w.writen1('"')
|
||||
return
|
||||
}
|
||||
e.w.writeb(strconv.AppendInt(e.b[:0], v, 10))
|
||||
}
|
||||
|
||||
func (e *jsonEncDriver) EncodeUint(v uint64) {
|
||||
if x := e.h.IntegerAsString; x == 'A' || x == 'L' && v > 1<<53 {
|
||||
e.w.writen1('"')
|
||||
e.w.writeb(strconv.AppendUint(e.b[:0], v, 10))
|
||||
e.w.writen1('"')
|
||||
return
|
||||
}
|
||||
e.w.writeb(strconv.AppendUint(e.b[:0], v, 10))
|
||||
}
|
||||
|
||||
@ -636,6 +648,11 @@ func (d *jsonDecDriver) decNum(storeBytes bool) {
|
||||
d.tok = b
|
||||
}
|
||||
b := d.tok
|
||||
var str bool
|
||||
if b == '"' {
|
||||
str = true
|
||||
b = d.r.readn1()
|
||||
}
|
||||
if !(b == '+' || b == '-' || b == '.' || (b >= '0' && b <= '9')) {
|
||||
d.d.errorf("json: decNum: got first char '%c'", b)
|
||||
return
|
||||
@ -650,6 +667,10 @@ func (d *jsonDecDriver) decNum(storeBytes bool) {
|
||||
n.reset()
|
||||
d.bs = d.bs[:0]
|
||||
|
||||
if str && storeBytes {
|
||||
d.bs = append(d.bs, '"')
|
||||
}
|
||||
|
||||
// The format of a number is as below:
|
||||
// parsing: sign? digit* dot? digit* e? sign? digit*
|
||||
// states: 0 1* 2 3* 4 5* 6 7
|
||||
@ -740,6 +761,14 @@ LOOP:
|
||||
default:
|
||||
break LOOP
|
||||
}
|
||||
case '"':
|
||||
if str {
|
||||
if storeBytes {
|
||||
d.bs = append(d.bs, '"')
|
||||
}
|
||||
b, eof = r.readn1eof()
|
||||
}
|
||||
break LOOP
|
||||
default:
|
||||
break LOOP
|
||||
}
|
||||
@ -1110,6 +1139,19 @@ type JsonHandle struct {
|
||||
// - If positive, indent by that number of spaces.
|
||||
// - If negative, indent by that number of tabs.
|
||||
Indent int8
|
||||
|
||||
// IntegerAsString controls how integers (signed and unsigned) are encoded.
|
||||
//
|
||||
// Per the JSON Spec, JSON numbers are 64-bit floating point numbers.
|
||||
// Consequently, integers > 2^53 cannot be represented as a JSON number without losing precision.
|
||||
// This can be mitigated by configuring how to encode integers.
|
||||
//
|
||||
// IntegerAsString interpretes the following values:
|
||||
// - if 'L', then encode integers > 2^53 as a json string.
|
||||
// - if 'A', then encode all integers as a json string
|
||||
// containing the exact integer representation as a decimal.
|
||||
// - else encode all integers as a json number (default)
|
||||
IntegerAsString uint8
|
||||
}
|
||||
|
||||
func (h *JsonHandle) SetInterfaceExt(rt reflect.Type, tag uint64, ext InterfaceExt) (err error) {
|
||||
|
2
Godeps/_workspace/src/github.com/ugorji/go/codec/prebuild.sh
generated
vendored
2
Godeps/_workspace/src/github.com/ugorji/go/codec/prebuild.sh
generated
vendored
@ -171,7 +171,7 @@ do
|
||||
'xf') zforce=1;;
|
||||
'xb') zbak=1;;
|
||||
'xx') zexternal=1;;
|
||||
*) echo "prebuild.sh accepts [-fb] only"; return 1;;
|
||||
*) echo "prebuild.sh accepts [-fbx] only"; return 1;;
|
||||
esac
|
||||
done
|
||||
shift $((OPTIND-1))
|
||||
|
18
Godeps/_workspace/src/github.com/ugorji/go/codec/test.py
generated
vendored
18
Godeps/_workspace/src/github.com/ugorji/go/codec/test.py
generated
vendored
@ -9,6 +9,8 @@
|
||||
# sudo apt-get install python-pip
|
||||
# pip install --user msgpack-python msgpack-rpc-python cbor
|
||||
|
||||
# Ensure all "string" keys are utf strings (else encoded as bytes)
|
||||
|
||||
import cbor, msgpack, msgpackrpc, sys, os, threading
|
||||
|
||||
def get_test_data_list():
|
||||
@ -26,35 +28,39 @@ def get_test_data_list():
|
||||
-3232.0,
|
||||
-6464646464.0,
|
||||
3232.0,
|
||||
6464.0,
|
||||
6464646464.0,
|
||||
False,
|
||||
True,
|
||||
u"null",
|
||||
None,
|
||||
u"someday",
|
||||
u"",
|
||||
u"bytestring",
|
||||
1328176922000002000,
|
||||
u"",
|
||||
-2206187877999998000,
|
||||
u"bytestring",
|
||||
270,
|
||||
u"none",
|
||||
-2013855847999995777,
|
||||
#-6795364578871345152,
|
||||
]
|
||||
l1 = [
|
||||
{ "true": True,
|
||||
"false": False },
|
||||
{ "true": "True",
|
||||
{ "true": u"True",
|
||||
"false": False,
|
||||
"uint16(1616)": 1616 },
|
||||
{ "list": [1616, 32323232, True, -3232.0, {"TRUE":True, "FALSE":False}, [True, False] ],
|
||||
"int32":32323232, "bool": True,
|
||||
"LONG STRING": "123456789012345678901234567890123456789012345678901234567890",
|
||||
"SHORT STRING": "1234567890" },
|
||||
{ True: "true", 8: False, "false": 0 }
|
||||
"LONG STRING": u"123456789012345678901234567890123456789012345678901234567890",
|
||||
"SHORT STRING": u"1234567890" },
|
||||
{ True: "true", 138: False, "false": 200 }
|
||||
]
|
||||
|
||||
l = []
|
||||
l.extend(l0)
|
||||
l.append(l0)
|
||||
l.append(1)
|
||||
l.extend(l1)
|
||||
return l
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user