示例#1
0
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
}
示例#2
0
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
}
示例#3
0
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
}
示例#4
0
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
}
示例#5
0
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
}
示例#6
0
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
}
示例#7
0
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
}
示例#8
0
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
}
示例#9
0
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
}