func p(packer intern.Packer, xs ...interface{}) intern.Packed {
args := make([]intern.Packed, len(xs))
for i, x := range xs {
args[i] = pack(packer, x)
}
return packer.PackList(args)
}
func pair(packer intern.Packer, a, b interface{}) intern.Packed {
args := make([]intern.Packed, 2)
for i, x := range []interface{}{a, b} {
args[i] = pack(packer, x)
}
return packer.PackPair(args[0], args[1])
}
func unpickleC(packer intern.Packer, kind int, packed intern.Packed) (C, bool) {
switch kind {
case compoundC:
result := &CompoundC{}
if packed, args, ok := packer.UnpackPair(packed); ok {
if args, ok := packer.UnpackList(args); ok {
result.args = make([]C, len(args))
for i, arg := range args {
unpacked, ok := packer.UnpackPickler(arg, &CompoundC{})
if !ok {
return nil, false
}
result.args[i] = unpacked.(C)
}
id, ok := unpickleTemplateID(packer, packed)
if !ok {
return nil, false
}
result.TemplateID = id
return result, true
}
}
case referenceC:
n, ok := packer.UnpackInt(packed)
return ReferenceC{n}, ok
case constantC:
unpacked, ok := packer.UnpackPickler(packed, &CompoundT{})
if !ok {
return nil, false
}
return ConstC{unpacked.(T)}, ok
}
return nil, false
}
func unpickleTemplateID(packer intern.Packer, packed intern.Packed) (TemplateID, bool) {
unpickled, ok := packer.UnpackPickler(packed, TemplateID(0))
if !ok {
unpickled, ok = packer.UnpackPickler(packed, &Template{})
if !ok {
return TemplateID(0), false
}
unpickled = unpickled.(*Template).ID()
}
return unpickled.(TemplateID), true
}
func (s *Setting) Unpickle(packer intern.Packer, pickled intern.Packed) (intern.Pickler, bool) {
lines, ok := packer.UnpackList(pickled)
if !ok {
return nil, false
}
result := Init()
for _, packedLine := range lines {
line, slots, ok := unpickleSettingLine(packer, packedLine)
if !ok {
return nil, false
}
result = result.Append(line, slots)
}
return result, true
}
func unpickleSettingLine(packer intern.Packer, x intern.Packed) (SettingLine, int, bool) {
result, ok := packer.UnpackPickler(x, ActionCID(0))
if ok {
return result.(ActionCID), 0, true
}
id, ok := unpickleTemplateID(packer, x)
if ok {
return id, id.Template().Slots(), true
}
result, ok = packer.UnpackPickler(x, ActionC{})
if ok {
return result.(ActionC).ID(), 0, true
}
return nil, 0, false
}
func (c *CompoundC) Unpickle(packer intern.Packer, pickled intern.Packed) (intern.Pickler, bool) {
if v, val, ok := packer.UnpackPair(pickled); ok {
if v, ok := packer.UnpackInt(v); ok && v == v1C {
if kind, val, ok := packer.UnpackPair(val); ok {
if kind, ok := packer.UnpackInt(kind); ok {
return unpickleC(packer, kind, val)
}
}
}
}
return nil, false
}
func (s *Setting) Pickle(packer intern.Packer) intern.Packed {
if s.Size == 0 {
return packer.PackList([]intern.Packed{})
}
previous := s.Previous.Pickle(packer)
return packer.AppendToPacked(previous, packer.PackPickler(s.Last))
}
func (t *CompoundT) Unpickle(packer intern.Packer, pickled intern.Packed) (intern.Pickler, bool) {
if v, val, ok := packer.UnpackPair(pickled); ok {
if v, ok := packer.UnpackInt(v); ok && v == v1T {
if kind, val, ok := packer.UnpackPair(val); ok {
if kind, ok := packer.UnpackInt(kind); ok {
return unpickleT(packer, kind, val)
}
}
//panic(fmt.Errorf("failed to unpack pair from %v", val))
}
}
//panic(fmt.Errorf("faield to unpack from pickled %v", pickled))
return nil, false
}
func (t *Template) Unpickle(packer intern.Packer, pickled intern.Packed) (intern.Pickler, bool) {
result := &Template{}
if v, parts, ok := packer.UnpackPair(pickled); ok {
if v, ok := packer.UnpackInt(v); ok && v == v1Template {
if parts, ok := packer.UnpackList(parts); ok {
result.Parts = make([]string, len(parts))
for i, part := range parts {
if part, ok := packer.UnpackString(part); ok {
result.Parts[i] = part
}
}
return result, true
}
}
}
return nil, false
}
func (a ActionCID) Unpickle(packer intern.Packer, pickled intern.Packed) (intern.Pickler, bool) {
if v, action, ok := packer.UnpackPair(pickled); ok {
if v, ok := packer.UnpackInt(v); ok && v == v1ActionCID {
if action, ok := packer.UnpackPickler(action, ActionC{}); ok {
return action.(ActionC).ID(), true
}
}
}
return nil, false
}
func (t TemplateID) Unpickle(packer intern.Packer, pickled intern.Packed) (intern.Pickler, bool) {
if v, template, ok := packer.UnpackPair(pickled); ok {
if v, ok := packer.UnpackInt(v); ok && v == v1TemplateID {
if template, ok := packer.UnpackPickler(template, &Template{}); ok {
return template.(*Template).ID(), true
}
}
}
return nil, false
}
func pack(packer intern.Packer, x interface{}) intern.Packed {
switch x := x.(type) {
case intern.Packed:
return x
case int:
return packer.PackInt(x)
case string:
return packer.PackString(x)
case intern.Pickler:
return packer.PackPickler(x)
case []int:
args := make([]interface{}, len(x))
for i, y := range x {
args[i] = interface{}(y)
}
return p(packer, args...)
case []string:
args := make([]interface{}, len(x))
for i, y := range x {
args[i] = interface{}(y)
}
return p(packer, args...)
case []intern.Pickler:
args := make([]interface{}, len(x))
for i, y := range x {
args[i] = interface{}(y)
}
return p(packer, args...)
case []T:
args := make([]interface{}, len(x))
for i, y := range x {
args[i] = interface{}(y)
}
return p(packer, args...)
case []C:
args := make([]interface{}, len(x))
for i, y := range x {
args[i] = interface{}(y)
}
return p(packer, args...)
case []intern.Packed:
args := make([]interface{}, len(x))
for i, y := range x {
args[i] = interface{}(y)
}
return p(packer, args...)
case []interface{}:
return p(packer, x...)
}
panic(fmt.Errorf("bad argument %v to p(...) (type %T)", x, x))
}
func (s *SettingT) Unpickle(packer intern.Packer, pickled intern.Packed) (intern.Pickler, bool) {
if v, val, ok := packer.UnpackPair(pickled); ok {
if v, ok := packer.UnpackInt(v); ok && v == v1SettingT {
if setting, packedArgs, ok := packer.UnpackPair(val); ok {
result := &SettingT{}
unpacked, ok := packer.UnpackPickler(setting, &Setting{})
if !ok {
return nil, false
}
result.Setting = unpacked.(*Setting)
args, ok := packer.UnpackList(packedArgs)
if !ok {
return nil, false
}
result.Args = make([]T, len(args))
for i, arg := range args {
unpacked, ok := packer.UnpackPickler(arg, &CompoundT{})
if !ok {
return nil, false
}
result.Args[i] = unpacked.(T)
}
return result, true
}
}
}
return nil, false
}
func (a ActionC) Unpickle(packer intern.Packer, pickled intern.Packed) (intern.Pickler, bool) {
if v, val, ok := packer.UnpackPair(pickled); ok {
if v, ok := packer.UnpackInt(v); ok && v == v1ActionC {
if act, allArgs, ok := packer.UnpackPair(val); ok {
result := ActionC{}
if act, ok := packer.UnpackInt(act); ok {
result.Act = Action(act)
} else {
return nil, false
}
if intArgs, args, ok := packer.UnpackPair(allArgs); ok {
if intArgs, ok := packer.UnpackList(intArgs); ok {
result.IntArgs = make([]int, len(intArgs))
for i, packedArg := range intArgs {
arg, ok := packer.UnpackInt(packedArg)
if !ok {
panic(fmt.Errorf("failed to unpack int! %v", val))
return nil, false
}
result.IntArgs[i] = arg
}
} else {
panic(fmt.Errorf("failed to unpack list of int args! %v", val))
return nil, false
}
if args, ok := packer.UnpackList(args); ok {
result.Args = make([]C, len(args))
for i, arg := range args {
unpacked, ok := packer.UnpackPickler(arg, &CompoundC{})
if !ok {
return nil, false
}
result.Args[i] = unpacked.(C)
}
} else {
return nil, false
}
return result, true
}
}
}
}
return nil, false
}
func unpickleT(packer intern.Packer, kind int, packed intern.Packed) (T, bool) {
switch kind {
case chanT:
unpickled, ok := packer.UnpackPickler(packed, &SettingT{})
if !ok {
return nil, false
}
setting, ok := unpickled.(*SettingT)
return MakeChannel(setting), ok
case intT:
result, ok := packer.UnpackInt(packed)
if !ok {
//panic(fmt.Errorf("failed to unpickle int from %v", packed))
}
return Int(result), ok
case strT:
result, ok := packer.UnpackString(packed)
return Str(result), ok
case quotedT:
unpickled, ok := packer.UnpackPickler(packed, &CompoundT{})
if !ok {
return nil, false
}
return Quote(unpickled.(T)), true
case wrapperT:
return Make("a term that stands in for a wrapped go object that could not be pickled").T(), true
case compoundT:
result := &CompoundT{}
if packed, args, ok := packer.UnpackPair(packed); ok {
if args, ok := packer.UnpackList(args); ok {
result.args = make([]T, len(args))
for i, arg := range args {
unpacked, ok := packer.UnpackPickler(arg, &CompoundT{})
if !ok {
return nil, false
}
result.args[i] = unpacked.(T)
}
id, ok := unpickleTemplateID(packer, packed)
if !ok {
return nil, false
}
result.TemplateID = id
return result, true
}
}
}
return nil, false
}