Skip to content

N
neoppod
Commit 0ad51ec1 authored by Levin Zimmermann's avatar Levin Zimmermann
Browse files
Options

proto fix, see comment in protogen

parent d64f1baf
Hide whitespace changes
Inline Side-by-side
Showing with 1217 additions and 340 deletions
go/neo/proto/protogen.go
View file @ 0ad51ec1
......@@ -1735,7 +1735,36 @@ func (d *decoderM) genStructHead(path string, typ *types.Struct, userType types.
d.emit("return 0, &mstructDecodeError{%q, op, opOk}", d.pathName(path))
d.emit("}")
d.n += 1
// Arrays can have 1 or more bytes as a header:
//
// "Array format family stores a sequence of elements in 1, 3, or 5
// bytes of extra bytes in addition to the elements."
//
// see https://github.com/msgpack/msgpack/blob/master/spec.md
//
// Therefore it's better to use "ReadArrayHeaderBytes" than using
//
// >>> data = data[1:] // <- this fails in case we have array with 3 or 5 header bytes
//
// But there is another case, where this fix fails now, see:
//
// W0406 14:26:25.116792 2317874 mastered.go:127] C?: talk master(127.0.0.1:32747): C?: talk M1: after identification: expect nodeTab: 127.0.0.1:52480 - 127.0.0.1:32747 .0: decode: decode: M: NotifyNodeInformation.Addr: msgp: attempted to decode type "ext" with method for "array"
//
// So here we seem to use "genStructHead", because we create code for Addr decoding.
// But it doesn't work as expected, because we don't have an array, but an extension
// type. This means:
//
// Addr isn't an Array/Struct but an extension type and this needs to be adjusted in proto.go?
// We need to differentiate in 'genStructHead' between them?
d.emit("{")
d.emit("_, tail, err := msgp.ReadArrayHeaderBytes(data)")
d.emit("if err != nil {")
d.emit(fmt.Sprintf("return 0, mdecodeErr(%q, err)", d.pathName(path)))
d.emit("}")
d.emit("data = tail")
d.emit("}")
d.overflow.Add(1)
}
......
go/neo/proto/zproto-marshal.go
View file @ 0ad51ec1
......@@ -90,20 +90,27 @@ func (p *Error) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|2; op != opOk {
return 0, &mstructDecodeError{"Error", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.FixExt1 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("Error", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.FixExt1 {
return 0, mdecodeOpErr("Error.Code", op, msgpack.FixExt1)
}
if enumType := data[2]; enumType != 2 {
if enumType := data[1]; enumType != 2 {
return 0, mdecodeEnumTypeErr("Error.Code", enumType, 2)
}
{
v := data[3]
v := data[2]
if !(0 <= v && v <= 0x7f) {
return 0, mdecodeEnumValueErr("Error.Code", v)
}
p.Code = ErrorCode(v)
}
data = data[4:]
data = data[3:]
{
b, tail, err := msgp.ReadBytesZC(data)
if err != nil {
......@@ -347,20 +354,27 @@ func (p *RequestIdentification) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|7; op != opOk {
return 0, &mstructDecodeError{"RequestIdentification", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.FixExt1 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("RequestIdentification", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.FixExt1 {
return 0, mdecodeOpErr("RequestIdentification.NodeType", op, msgpack.FixExt1)
}
if enumType := data[2]; enumType != 4 {
if enumType := data[1]; enumType != 4 {
return 0, mdecodeEnumTypeErr("RequestIdentification.NodeType", enumType, 4)
}
{
v := data[3]
v := data[2]
if !(0 <= v && v <= 0x7f) {
return 0, mdecodeEnumValueErr("RequestIdentification.NodeType", v)
}
p.NodeType = NodeType(v)
}
data = data[4:]
data = data[3:]
{
v, tail, err := msgp.ReadInt32Bytes(data)
if err != nil {
......@@ -376,7 +390,13 @@ func (p *RequestIdentification) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|2; op != opOk {
return 0, &mstructDecodeError{"RequestIdentification.Address", op, opOk}
}
data = data[1:]
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("RequestIdentification.Address", err)
}
data = tail
}
{
b, tail, err := msgp.ReadBytesZC(data)
if err != nil {
......@@ -520,20 +540,27 @@ func (p *AcceptIdentification) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|3; op != opOk {
return 0, &mstructDecodeError{"AcceptIdentification", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.FixExt1 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AcceptIdentification", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.FixExt1 {
return 0, mdecodeOpErr("AcceptIdentification.NodeType", op, msgpack.FixExt1)
}
if enumType := data[2]; enumType != 4 {
if enumType := data[1]; enumType != 4 {
return 0, mdecodeEnumTypeErr("AcceptIdentification.NodeType", enumType, 4)
}
{
v := data[3]
v := data[2]
if !(0 <= v && v <= 0x7f) {
return 0, mdecodeEnumValueErr("AcceptIdentification.NodeType", v)
}
p.NodeType = NodeType(v)
}
data = data[4:]
data = data[3:]
{
v, tail, err := msgp.ReadInt32Bytes(data)
if err != nil {
......@@ -590,6 +617,13 @@ func (p *Ping) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|0; op != opOk {
return 0, &mstructDecodeError{"Ping", op, opOk}
}
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("Ping", err)
}
data = tail
}
return 1, nil
overflow:
......@@ -628,6 +662,13 @@ func (p *Pong) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|0; op != opOk {
return 0, &mstructDecodeError{"Pong", op, opOk}
}
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("Pong", err)
}
data = tail
}
return 1, nil
overflow:
......@@ -666,6 +707,13 @@ func (p *CloseClient) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|0; op != opOk {
return 0, &mstructDecodeError{"CloseClient", op, opOk}
}
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("CloseClient", err)
}
data = tail
}
return 1, nil
overflow:
......@@ -704,6 +752,13 @@ func (p *PrimaryMaster) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|0; op != opOk {
return 0, &mstructDecodeError{"PrimaryMaster", op, opOk}
}
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("PrimaryMaster", err)
}
data = tail
}
return 1, nil
overflow:
......@@ -755,7 +810,13 @@ func (p *AnswerPrimary) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|1; op != opOk {
return 0, &mstructDecodeError{"AnswerPrimary", op, opOk}
}
data = data[1:]
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerPrimary", err)
}
data = tail
}
{
v, tail, err := msgp.ReadInt32Bytes(data)
if err != nil {
......@@ -876,7 +937,13 @@ func (p *NotPrimaryMaster) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|2; op != opOk {
return 0, &mstructDecodeError{"NotPrimaryMaster", op, opOk}
}
data = data[1:]
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("NotPrimaryMaster", err)
}
data = tail
}
{
v, tail, err := msgp.ReadInt32Bytes(data)
if err != nil {
......@@ -902,10 +969,23 @@ func (p *NotPrimaryMaster) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|1; op != opOk {
return 0, &mstructDecodeError{"NotPrimaryMaster", op, opOk}
}
if op, opOk := msgpack.Op(data[1]), msgpack.FixArray_4|2; op != opOk {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("NotPrimaryMaster", err)
}
data = tail
}
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|2; op != opOk {
return 0, &mstructDecodeError{"NotPrimaryMaster.Address", op, opOk}
}
data = data[2:]
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("NotPrimaryMaster.Address", err)
}
data = tail
}
{
b, tail, err := msgp.ReadBytesZC(data)
if err != nil {
......@@ -1092,7 +1172,13 @@ func (p *NotifyNodeInformation) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|2; op != opOk {
return 0, &mstructDecodeError{"NotifyNodeInformation", op, opOk}
}
data = data[1:]
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("NotifyNodeInformation", err)
}
data = tail
}
{
v, tail, err := msgp.ReadFloat64Bytes(data)
if err != nil {
......@@ -1118,23 +1204,37 @@ func (p *NotifyNodeInformation) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|5; op != opOk {
return 0, &mstructDecodeError{"NotifyNodeInformation", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.FixExt1 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("NotifyNodeInformation", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.FixExt1 {
return 0, mdecodeOpErr("NotifyNodeInformation.Type", op, msgpack.FixExt1)
}
if enumType := data[2]; enumType != 4 {
if enumType := data[1]; enumType != 4 {
return 0, mdecodeEnumTypeErr("NotifyNodeInformation.Type", enumType, 4)
}
{
v := data[3]
v := data[2]
if !(0 <= v && v <= 0x7f) {
return 0, mdecodeEnumValueErr("NotifyNodeInformation.Type", v)
}
(*a).Type = NodeType(v)
}
if op, opOk := msgpack.Op(data[4]), msgpack.FixArray_4|2; op != opOk {
if op, opOk := msgpack.Op(data[3]), msgpack.FixArray_4|2; op != opOk {
return 0, &mstructDecodeError{"NotifyNodeInformation.Addr", op, opOk}
}
data = data[5:]
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("NotifyNodeInformation.Addr", err)
}
data = tail
}
data = data[3:]
{
b, tail, err := msgp.ReadBytesZC(data)
if err != nil {
......@@ -1229,6 +1329,13 @@ func (p *Recovery) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|0; op != opOk {
return 0, &mstructDecodeError{"Recovery", op, opOk}
}
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("Recovery", err)
}
data = tail
}
return 1, nil
overflow:
......@@ -1290,7 +1397,13 @@ func (p *AnswerRecovery) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|3; op != opOk {
return 0, &mstructDecodeError{"AnswerRecovery", op, opOk}
}
data = data[1:]
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerRecovery", err)
}
data = tail
}
{
v, tail, err := msgp.ReadUint64Bytes(data)
if err != nil {
......@@ -1355,6 +1468,13 @@ func (p *LastIDs) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|0; op != opOk {
return 0, &mstructDecodeError{"LastIDs", op, opOk}
}
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("LastIDs", err)
}
data = tail
}
return 1, nil
overflow:
......@@ -1409,20 +1529,27 @@ func (p *AnswerLastIDs) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|2; op != opOk {
return 0, &mstructDecodeError{"AnswerLastIDs", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerLastIDs", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("AnswerLastIDs.LastOid", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("AnswerLastIDs.LastOid", l, 8)
}
p.LastOid = zodb.Oid(binary.BigEndian.Uint64(data[3:]))
if op := msgpack.Op(data[11]); op != msgpack.Bin8 {
p.LastOid = zodb.Oid(binary.BigEndian.Uint64(data[2:]))
if op := msgpack.Op(data[10]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("AnswerLastIDs.LastTid", op, msgpack.Bin8)
}
if l := data[12]; l != 8 {
if l := data[11]; l != 8 {
return 0, mdecodeLen8Err("AnswerLastIDs.LastTid", l, 8)
}
p.LastTid = zodb.Tid(binary.BigEndian.Uint64(data[13:]))
p.LastTid = zodb.Tid(binary.BigEndian.Uint64(data[12:]))
return 21, nil
overflow:
......@@ -1461,6 +1588,13 @@ func (p *AskPartitionTable) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|0; op != opOk {
return 0, &mstructDecodeError{"AskPartitionTable", op, opOk}
}
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AskPartitionTable", err)
}
data = tail
}
return 1, nil
overflow:
......@@ -1608,7 +1742,13 @@ func (p *AnswerPartitionTable) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|3; op != opOk {
return 0, &mstructDecodeError{"AnswerPartitionTable", op, opOk}
}
data = data[1:]
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerPartitionTable", err)
}
data = tail
}
{
v, tail, err := msgp.ReadUint64Bytes(data)
if err != nil {
......@@ -1644,7 +1784,13 @@ func (p *AnswerPartitionTable) neoMsgDecodeM(data []byte) (int, error) {
return 0, &mstructDecodeError{"AnswerPartitionTable", op, opOk}
}
{
data = data[1:]
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerPartitionTable", err)
}
data = tail
}
{
l, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerPartitionTable.CellList", err)
......@@ -1660,7 +1806,13 @@ func (p *AnswerPartitionTable) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|2; op != opOk {
return 0, &mstructDecodeError{"AnswerPartitionTable", op, opOk}
}
data = data[1:]
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerPartitionTable", err)
}
data = tail
}
{
v, tail, err := msgp.ReadInt32Bytes(data)
if err != nil {
......@@ -1840,7 +1992,13 @@ func (p *SendPartitionTable) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|3; op != opOk {
return 0, &mstructDecodeError{"SendPartitionTable", op, opOk}
}
data = data[1:]
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("SendPartitionTable", err)
}
data = tail
}
{
v, tail, err := msgp.ReadUint64Bytes(data)
if err != nil {
......@@ -1876,7 +2034,13 @@ func (p *SendPartitionTable) neoMsgDecodeM(data []byte) (int, error) {
return 0, &mstructDecodeError{"SendPartitionTable", op, opOk}
}
{
data = data[1:]
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("SendPartitionTable", err)
}
data = tail
}
{
l, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("SendPartitionTable.CellList", err)
......@@ -1892,7 +2056,13 @@ func (p *SendPartitionTable) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|2; op != opOk {
return 0, &mstructDecodeError{"SendPartitionTable", op, opOk}
}
data = data[1:]
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("SendPartitionTable", err)
}
data = tail
}
{
v, tail, err := msgp.ReadInt32Bytes(data)
if err != nil {
......@@ -2044,7 +2214,13 @@ func (p *NotifyPartitionChanges) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|3; op != opOk {
return 0, &mstructDecodeError{"NotifyPartitionChanges", op, opOk}
}
data = data[1:]
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("NotifyPartitionChanges", err)
}
data = tail
}
{
v, tail, err := msgp.ReadUint64Bytes(data)
if err != nil {
......@@ -2082,7 +2258,13 @@ func (p *NotifyPartitionChanges) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|2; op != opOk {
return 0, &mstructDecodeError{"NotifyPartitionChanges", op, opOk}
}
data = data[1:]
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("NotifyPartitionChanges", err)
}
data = tail
}
{
v, tail, err := msgp.ReadUint32Bytes(data)
if err != nil {
......@@ -2098,7 +2280,13 @@ func (p *NotifyPartitionChanges) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|2; op != opOk {
return 0, &mstructDecodeError{"NotifyPartitionChanges.CellInfo", op, opOk}
}
data = data[1:]
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("NotifyPartitionChanges.CellInfo", err)
}
data = tail
}
{
v, tail, err := msgp.ReadInt32Bytes(data)
if err != nil {
......@@ -2175,7 +2363,14 @@ func (p *StartOperation) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|1; op != opOk {
return 0, &mstructDecodeError{"StartOperation", op, opOk}
}
switch op := msgpack.Op(data[1]); op {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("StartOperation", err)
}
data = tail
}
switch op := msgpack.Op(data[0]); op {
default:
return 0, mdecodeOpErr("StartOperation.Backup", op, msgpack.True, msgpack.False)
case msgpack.True:
......@@ -2221,6 +2416,13 @@ func (p *StopOperation) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|0; op != opOk {
return 0, &mstructDecodeError{"StopOperation", op, opOk}
}
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("StopOperation", err)
}
data = tail
}
return 1, nil
overflow:
......@@ -2310,7 +2512,13 @@ func (p *UnfinishedTransactions) neoMsgDecodeM(data []byte) (int, error) {
return 0, &mstructDecodeError{"UnfinishedTransactions", op, opOk}
}
{
data = data[1:]
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("UnfinishedTransactions", err)
}
data = tail
}
{
l, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("UnfinishedTransactions.RowList", err)
......@@ -2326,7 +2534,13 @@ func (p *UnfinishedTransactions) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|1; op != opOk {
return 0, &mstructDecodeError{"UnfinishedTransactions", op, opOk}
}
data = data[1:]
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("UnfinishedTransactions", err)
}
data = tail
}
{
v, tail, err := msgp.ReadUint32Bytes(data)
if err != nil {
......@@ -2427,15 +2641,22 @@ func (p *AnswerUnfinishedTransactions) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|2; op != opOk {
return 0, &mstructDecodeError{"AnswerUnfinishedTransactions", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerUnfinishedTransactions", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("AnswerUnfinishedTransactions.MaxTID", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("AnswerUnfinishedTransactions.MaxTID", l, 8)
}
p.MaxTID = zodb.Tid(binary.BigEndian.Uint64(data[3:]))
p.MaxTID = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
{
data = data[11:]
data = data[10:]
l, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerUnfinishedTransactions.TidList", err)
......@@ -2452,14 +2673,21 @@ func (p *AnswerUnfinishedTransactions) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|1; op != opOk {
return 0, &mstructDecodeError{"AnswerUnfinishedTransactions", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerUnfinishedTransactions", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("AnswerUnfinishedTransactions.UnfinishedTID", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("AnswerUnfinishedTransactions.UnfinishedTID", l, 8)
}
(*a).UnfinishedTID = zodb.Tid(binary.BigEndian.Uint64(data[3:]))
data = data[11:]
(*a).UnfinishedTID = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
data = data[10:]
}
}
return 11 + int(nread), nil
......@@ -2500,6 +2728,13 @@ func (p *LockedTransactions) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|0; op != opOk {
return 0, &mstructDecodeError{"LockedTransactions", op, opOk}
}
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("LockedTransactions", err)
}
data = tail
}
return 1, nil
overflow:
......@@ -2597,7 +2832,13 @@ func (p *AnswerLockedTransactions) neoMsgDecodeM(data []byte) (int, error) {
return 0, &mstructDecodeError{"AnswerLockedTransactions", op, opOk}
}
{
data = data[1:]
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerLockedTransactions", err)
}
data = tail
}
{
l, tail, err := msgp.ReadMapHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerLockedTransactions.TidDict", err)
......@@ -2678,13 +2919,20 @@ func (p *FinalTID) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|1; op != opOk {
return 0, &mstructDecodeError{"FinalTID", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("FinalTID", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("FinalTID.TTID", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("FinalTID.TTID", l, 8)
}
p.TTID = zodb.Tid(binary.BigEndian.Uint64(data[3:]))
p.TTID = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
return 11, nil
overflow:
......@@ -2734,13 +2982,20 @@ func (p *AnswerFinalTID) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|1; op != opOk {
return 0, &mstructDecodeError{"AnswerFinalTID", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerFinalTID", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("AnswerFinalTID.Tid", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("AnswerFinalTID.Tid", l, 8)
}
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[3:]))
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
return 11, nil
overflow:
......@@ -2795,20 +3050,27 @@ func (p *ValidateTransaction) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|2; op != opOk {
return 0, &mstructDecodeError{"ValidateTransaction", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("ValidateTransaction", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("ValidateTransaction.TTID", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("ValidateTransaction.TTID", l, 8)
}
p.TTID = zodb.Tid(binary.BigEndian.Uint64(data[3:]))
if op := msgpack.Op(data[11]); op != msgpack.Bin8 {
p.TTID = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
if op := msgpack.Op(data[10]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("ValidateTransaction.Tid", op, msgpack.Bin8)
}
if l := data[12]; l != 8 {
if l := data[11]; l != 8 {
return 0, mdecodeLen8Err("ValidateTransaction.Tid", l, 8)
}
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[13:]))
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[12:]))
return 21, nil
overflow:
......@@ -2858,13 +3120,20 @@ func (p *BeginTransaction) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|1; op != opOk {
return 0, &mstructDecodeError{"BeginTransaction", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("BeginTransaction", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("BeginTransaction.Tid", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("BeginTransaction.Tid", l, 8)
}
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[3:]))
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
return 11, nil
overflow:
......@@ -2914,13 +3183,20 @@ func (p *AnswerBeginTransaction) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|1; op != opOk {
return 0, &mstructDecodeError{"AnswerBeginTransaction", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerBeginTransaction", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("AnswerBeginTransaction.Tid", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("AnswerBeginTransaction.Tid", l, 8)
}
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[3:]))
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
return 11, nil
overflow:
......@@ -3013,15 +3289,22 @@ func (p *FailedVote) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|2; op != opOk {
return 0, &mstructDecodeError{"FailedVote", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("FailedVote", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("FailedVote.Tid", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("FailedVote.Tid", l, 8)
}
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[3:]))
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
{
data = data[11:]
data = data[10:]
l, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("FailedVote.NodeList", err)
......@@ -3165,15 +3448,22 @@ func (p *FinishTransaction) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|3; op != opOk {
return 0, &mstructDecodeError{"FinishTransaction", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("FinishTransaction", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("FinishTransaction.Tid", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("FinishTransaction.Tid", l, 8)
}
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[3:]))
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
{
data = data[11:]
data = data[10:]
l, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("FinishTransaction.OIDList", err)
......@@ -3275,20 +3565,27 @@ func (p *AnswerTransactionFinished) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|2; op != opOk {
return 0, &mstructDecodeError{"AnswerTransactionFinished", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerTransactionFinished", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("AnswerTransactionFinished.TTid", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("AnswerTransactionFinished.TTid", l, 8)
}
p.TTid = zodb.Tid(binary.BigEndian.Uint64(data[3:]))
if op := msgpack.Op(data[11]); op != msgpack.Bin8 {
p.TTid = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
if op := msgpack.Op(data[10]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("AnswerTransactionFinished.Tid", op, msgpack.Bin8)
}
if l := data[12]; l != 8 {
if l := data[11]; l != 8 {
return 0, mdecodeLen8Err("AnswerTransactionFinished.Tid", l, 8)
}
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[13:]))
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[12:]))
return 21, nil
overflow:
......@@ -3343,20 +3640,27 @@ func (p *LockInformation) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|2; op != opOk {
return 0, &mstructDecodeError{"LockInformation", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("LockInformation", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("LockInformation.Ttid", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("LockInformation.Ttid", l, 8)
}
p.Ttid = zodb.Tid(binary.BigEndian.Uint64(data[3:]))
if op := msgpack.Op(data[11]); op != msgpack.Bin8 {
p.Ttid = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
if op := msgpack.Op(data[10]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("LockInformation.Tid", op, msgpack.Bin8)
}
if l := data[12]; l != 8 {
if l := data[11]; l != 8 {
return 0, mdecodeLen8Err("LockInformation.Tid", l, 8)
}
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[13:]))
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[12:]))
return 21, nil
overflow:
......@@ -3406,13 +3710,20 @@ func (p *AnswerInformationLocked) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|1; op != opOk {
return 0, &mstructDecodeError{"AnswerInformationLocked", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerInformationLocked", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("AnswerInformationLocked.Ttid", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("AnswerInformationLocked.Ttid", l, 8)
}
p.Ttid = zodb.Tid(binary.BigEndian.Uint64(data[3:]))
p.Ttid = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
return 11, nil
overflow:
......@@ -3500,15 +3811,22 @@ func (p *InvalidateObjects) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|2; op != opOk {
return 0, &mstructDecodeError{"InvalidateObjects", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("InvalidateObjects", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("InvalidateObjects.Tid", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("InvalidateObjects.Tid", l, 8)
}
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[3:]))
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
{
data = data[11:]
data = data[10:]
l, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("InvalidateObjects.OidList", err)
......@@ -3581,13 +3899,20 @@ func (p *NotifyUnlockInformation) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|1; op != opOk {
return 0, &mstructDecodeError{"NotifyUnlockInformation", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("NotifyUnlockInformation", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("NotifyUnlockInformation.TTID", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("NotifyUnlockInformation.TTID", l, 8)
}
p.TTID = zodb.Tid(binary.BigEndian.Uint64(data[3:]))
p.TTID = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
return 11, nil
overflow:
......@@ -3639,7 +3964,13 @@ func (p *AskNewOIDs) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|1; op != opOk {
return 0, &mstructDecodeError{"AskNewOIDs", op, opOk}
}
data = data[1:]
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AskNewOIDs", err)
}
data = tail
}
{
v, tail, err := msgp.ReadUint32Bytes(data)
if err != nil {
......@@ -3732,7 +4063,13 @@ func (p *AnswerNewOIDs) neoMsgDecodeM(data []byte) (int, error) {
return 0, &mstructDecodeError{"AnswerNewOIDs", op, opOk}
}
{
data = data[1:]
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerNewOIDs", err)
}
data = tail
}
{
l, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerNewOIDs.OidList", err)
......@@ -3810,20 +4147,27 @@ func (p *NotifyDeadlock) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|2; op != opOk {
return 0, &mstructDecodeError{"NotifyDeadlock", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("NotifyDeadlock", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("NotifyDeadlock.TTid", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("NotifyDeadlock.TTid", l, 8)
}
p.TTid = zodb.Tid(binary.BigEndian.Uint64(data[3:]))
if op := msgpack.Op(data[11]); op != msgpack.Bin8 {
p.TTid = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
if op := msgpack.Op(data[10]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("NotifyDeadlock.LockingTid", op, msgpack.Bin8)
}
if l := data[12]; l != 8 {
if l := data[11]; l != 8 {
return 0, mdecodeLen8Err("NotifyDeadlock.LockingTid", l, 8)
}
p.LockingTid = zodb.Tid(binary.BigEndian.Uint64(data[13:]))
p.LockingTid = zodb.Tid(binary.BigEndian.Uint64(data[12:]))
return 21, nil
overflow:
......@@ -3878,20 +4222,27 @@ func (p *RebaseTransaction) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|2; op != opOk {
return 0, &mstructDecodeError{"RebaseTransaction", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("RebaseTransaction", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("RebaseTransaction.TTid", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("RebaseTransaction.TTid", l, 8)
}
p.TTid = zodb.Tid(binary.BigEndian.Uint64(data[3:]))
if op := msgpack.Op(data[11]); op != msgpack.Bin8 {
p.TTid = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
if op := msgpack.Op(data[10]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("RebaseTransaction.LockingTid", op, msgpack.Bin8)
}
if l := data[12]; l != 8 {
if l := data[11]; l != 8 {
return 0, mdecodeLen8Err("RebaseTransaction.LockingTid", l, 8)
}
p.LockingTid = zodb.Tid(binary.BigEndian.Uint64(data[13:]))
p.LockingTid = zodb.Tid(binary.BigEndian.Uint64(data[12:]))
return 21, nil
overflow:
......@@ -3975,7 +4326,13 @@ func (p *AnswerRebaseTransaction) neoMsgDecodeM(data []byte) (int, error) {
return 0, &mstructDecodeError{"AnswerRebaseTransaction", op, opOk}
}
{
data = data[1:]
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerRebaseTransaction", err)
}
data = tail
}
{
l, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerRebaseTransaction.OidList", err)
......@@ -4053,20 +4410,27 @@ func (p *RebaseObject) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|2; op != opOk {
return 0, &mstructDecodeError{"RebaseObject", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("RebaseObject", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("RebaseObject.TTid", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("RebaseObject.TTid", l, 8)
}
p.TTid = zodb.Tid(binary.BigEndian.Uint64(data[3:]))
if op := msgpack.Op(data[11]); op != msgpack.Bin8 {
p.TTid = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
if op := msgpack.Op(data[10]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("RebaseObject.Oid", op, msgpack.Bin8)
}
if l := data[12]; l != 8 {
if l := data[11]; l != 8 {
return 0, mdecodeLen8Err("RebaseObject.Oid", l, 8)
}
p.Oid = zodb.Oid(binary.BigEndian.Uint64(data[13:]))
p.Oid = zodb.Oid(binary.BigEndian.Uint64(data[12:]))
return 21, nil
overflow:
......@@ -4156,21 +4520,28 @@ func (p *AnswerRebaseObject) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|5; op != opOk {
return 0, &mstructDecodeError{"AnswerRebaseObject", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerRebaseObject", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("AnswerRebaseObject.Serial", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("AnswerRebaseObject.Serial", l, 8)
}
p.Serial = zodb.Tid(binary.BigEndian.Uint64(data[3:]))
if op := msgpack.Op(data[11]); op != msgpack.Bin8 {
p.Serial = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
if op := msgpack.Op(data[10]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("AnswerRebaseObject.ConflictSerial", op, msgpack.Bin8)
}
if l := data[12]; l != 8 {
if l := data[11]; l != 8 {
return 0, mdecodeLen8Err("AnswerRebaseObject.ConflictSerial", l, 8)
}
p.ConflictSerial = zodb.Tid(binary.BigEndian.Uint64(data[13:]))
switch op := msgpack.Op(data[21]); op {
p.ConflictSerial = zodb.Tid(binary.BigEndian.Uint64(data[12:]))
switch op := msgpack.Op(data[20]); op {
default:
return 0, mdecodeOpErr("AnswerRebaseObject.Compression", op, msgpack.True, msgpack.False)
case msgpack.True:
......@@ -4178,14 +4549,14 @@ func (p *AnswerRebaseObject) neoMsgDecodeM(data []byte) (int, error) {
case msgpack.False:
p.Compression = false
}
if op := msgpack.Op(data[22]); op != msgpack.Bin8 {
if op := msgpack.Op(data[21]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("AnswerRebaseObject.Checksum", op, msgpack.Bin8)
}
if l := data[23]; l != 20 {
if l := data[22]; l != 20 {
return 0, mdecodeLen8Err("AnswerRebaseObject.Checksum", l, 20)
}
copy(p.Checksum[:], data[24:44])
data = data[44:]
copy(p.Checksum[:], data[23:43])
data = data[43:]
{
b, tail, err := msgp.ReadBytesZC(data)
if err != nil {
......@@ -4295,21 +4666,28 @@ func (p *StoreObject) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|7; op != opOk {
return 0, &mstructDecodeError{"StoreObject", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("StoreObject", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("StoreObject.Oid", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("StoreObject.Oid", l, 8)
}
p.Oid = zodb.Oid(binary.BigEndian.Uint64(data[3:]))
if op := msgpack.Op(data[11]); op != msgpack.Bin8 {
p.Oid = zodb.Oid(binary.BigEndian.Uint64(data[2:]))
if op := msgpack.Op(data[10]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("StoreObject.Serial", op, msgpack.Bin8)
}
if l := data[12]; l != 8 {
if l := data[11]; l != 8 {
return 0, mdecodeLen8Err("StoreObject.Serial", l, 8)
}
p.Serial = zodb.Tid(binary.BigEndian.Uint64(data[13:]))
switch op := msgpack.Op(data[21]); op {
p.Serial = zodb.Tid(binary.BigEndian.Uint64(data[12:]))
switch op := msgpack.Op(data[20]); op {
default:
return 0, mdecodeOpErr("StoreObject.Compression", op, msgpack.True, msgpack.False)
case msgpack.True:
......@@ -4317,14 +4695,14 @@ func (p *StoreObject) neoMsgDecodeM(data []byte) (int, error) {
case msgpack.False:
p.Compression = false
}
if op := msgpack.Op(data[22]); op != msgpack.Bin8 {
if op := msgpack.Op(data[21]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("StoreObject.Checksum", op, msgpack.Bin8)
}
if l := data[23]; l != 20 {
if l := data[22]; l != 20 {
return 0, mdecodeLen8Err("StoreObject.Checksum", l, 20)
}
copy(p.Checksum[:], data[24:44])
data = data[44:]
copy(p.Checksum[:], data[23:43])
data = data[43:]
{
b, tail, err := msgp.ReadBytesZC(data)
if err != nil {
......@@ -4401,13 +4779,20 @@ func (p *AnswerStoreObject) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|1; op != opOk {
return 0, &mstructDecodeError{"AnswerStoreObject", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerStoreObject", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("AnswerStoreObject.Conflict", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("AnswerStoreObject.Conflict", l, 8)
}
p.Conflict = zodb.Tid(binary.BigEndian.Uint64(data[3:]))
p.Conflict = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
return 11, nil
overflow:
......@@ -4500,15 +4885,22 @@ func (p *AbortTransaction) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|2; op != opOk {
return 0, &mstructDecodeError{"AbortTransaction", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AbortTransaction", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("AbortTransaction.Tid", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("AbortTransaction.Tid", l, 8)
}
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[3:]))
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
{
data = data[11:]
data = data[10:]
l, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AbortTransaction.NodeList", err)
......@@ -4688,14 +5080,21 @@ func (p *StoreTransaction) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|5; op != opOk {
return 0, &mstructDecodeError{"StoreTransaction", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("StoreTransaction", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("StoreTransaction.Tid", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("StoreTransaction.Tid", l, 8)
}
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[3:]))
data = data[11:]
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
data = data[10:]
{
b, tail, err := msgp.ReadBytesZC(data)
if err != nil {
......@@ -4785,6 +5184,13 @@ func (p *AnswerStoreTransaction) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|0; op != opOk {
return 0, &mstructDecodeError{"AnswerStoreTransaction", op, opOk}
}
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerStoreTransaction", err)
}
data = tail
}
return 1, nil
overflow:
......@@ -4834,13 +5240,20 @@ func (p *VoteTransaction) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|1; op != opOk {
return 0, &mstructDecodeError{"VoteTransaction", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("VoteTransaction", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("VoteTransaction.Tid", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("VoteTransaction.Tid", l, 8)
}
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[3:]))
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
return 11, nil
overflow:
......@@ -4879,6 +5292,13 @@ func (p *AnswerVoteTransaction) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|0; op != opOk {
return 0, &mstructDecodeError{"AnswerVoteTransaction", op, opOk}
}
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerVoteTransaction", err)
}
data = tail
}
return 1, nil
overflow:
......@@ -4938,27 +5358,34 @@ func (p *GetObject) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|3; op != opOk {
return 0, &mstructDecodeError{"GetObject", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("GetObject", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("GetObject.Oid", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("GetObject.Oid", l, 8)
}
p.Oid = zodb.Oid(binary.BigEndian.Uint64(data[3:]))
if op := msgpack.Op(data[11]); op != msgpack.Bin8 {
p.Oid = zodb.Oid(binary.BigEndian.Uint64(data[2:]))
if op := msgpack.Op(data[10]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("GetObject.At", op, msgpack.Bin8)
}
if l := data[12]; l != 8 {
if l := data[11]; l != 8 {
return 0, mdecodeLen8Err("GetObject.At", l, 8)
}
p.At = zodb.Tid(binary.BigEndian.Uint64(data[13:]))
if op := msgpack.Op(data[21]); op != msgpack.Bin8 {
p.At = zodb.Tid(binary.BigEndian.Uint64(data[12:]))
if op := msgpack.Op(data[20]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("GetObject.Before", op, msgpack.Bin8)
}
if l := data[22]; l != 8 {
if l := data[21]; l != 8 {
return 0, mdecodeLen8Err("GetObject.Before", l, 8)
}
p.Before = zodb.Tid(binary.BigEndian.Uint64(data[23:]))
p.Before = zodb.Tid(binary.BigEndian.Uint64(data[22:]))
return 31, nil
overflow:
......@@ -5058,28 +5485,35 @@ func (p *AnswerObject) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|7; op != opOk {
return 0, &mstructDecodeError{"AnswerObject", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerObject", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("AnswerObject.Oid", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("AnswerObject.Oid", l, 8)
}
p.Oid = zodb.Oid(binary.BigEndian.Uint64(data[3:]))
if op := msgpack.Op(data[11]); op != msgpack.Bin8 {
p.Oid = zodb.Oid(binary.BigEndian.Uint64(data[2:]))
if op := msgpack.Op(data[10]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("AnswerObject.Serial", op, msgpack.Bin8)
}
if l := data[12]; l != 8 {
if l := data[11]; l != 8 {
return 0, mdecodeLen8Err("AnswerObject.Serial", l, 8)
}
p.Serial = zodb.Tid(binary.BigEndian.Uint64(data[13:]))
if op := msgpack.Op(data[21]); op != msgpack.Bin8 {
p.Serial = zodb.Tid(binary.BigEndian.Uint64(data[12:]))
if op := msgpack.Op(data[20]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("AnswerObject.NextSerial", op, msgpack.Bin8)
}
if l := data[22]; l != 8 {
if l := data[21]; l != 8 {
return 0, mdecodeLen8Err("AnswerObject.NextSerial", l, 8)
}
p.NextSerial = zodb.Tid(binary.BigEndian.Uint64(data[23:]))
switch op := msgpack.Op(data[31]); op {
p.NextSerial = zodb.Tid(binary.BigEndian.Uint64(data[22:]))
switch op := msgpack.Op(data[30]); op {
default:
return 0, mdecodeOpErr("AnswerObject.Compression", op, msgpack.True, msgpack.False)
case msgpack.True:
......@@ -5087,14 +5521,14 @@ func (p *AnswerObject) neoMsgDecodeM(data []byte) (int, error) {
case msgpack.False:
p.Compression = false
}
if op := msgpack.Op(data[32]); op != msgpack.Bin8 {
if op := msgpack.Op(data[31]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("AnswerObject.Checksum", op, msgpack.Bin8)
}
if l := data[33]; l != 20 {
if l := data[32]; l != 20 {
return 0, mdecodeLen8Err("AnswerObject.Checksum", l, 20)
}
copy(p.Checksum[:], data[34:54])
data = data[54:]
copy(p.Checksum[:], data[33:53])
data = data[53:]
{
b, tail, err := msgp.ReadBytesZC(data)
if err != nil {
......@@ -5178,7 +5612,13 @@ func (p *AskTIDs) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|3; op != opOk {
return 0, &mstructDecodeError{"AskTIDs", op, opOk}
}
data = data[1:]
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AskTIDs", err)
}
data = tail
}
{
v, tail, err := msgp.ReadUint64Bytes(data)
if err != nil {
......@@ -5289,7 +5729,13 @@ func (p *AnswerTIDs) neoMsgDecodeM(data []byte) (int, error) {
return 0, &mstructDecodeError{"AnswerTIDs", op, opOk}
}
{
data = data[1:]
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerTIDs", err)
}
data = tail
}
{
l, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerTIDs.TIDList", err)
......@@ -5362,13 +5808,20 @@ func (p *TransactionInformation) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|1; op != opOk {
return 0, &mstructDecodeError{"TransactionInformation", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("TransactionInformation", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("TransactionInformation.Tid", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("TransactionInformation.Tid", l, 8)
}
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[3:]))
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
return 11, nil
overflow:
......@@ -5531,14 +5984,21 @@ func (p *AnswerTransactionInformation) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|6; op != opOk {
return 0, &mstructDecodeError{"AnswerTransactionInformation", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerTransactionInformation", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("AnswerTransactionInformation.Tid", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("AnswerTransactionInformation.Tid", l, 8)
}
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[3:]))
data = data[11:]
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
data = data[10:]
{
b, tail, err := msgp.ReadBytesZC(data)
if err != nil {
......@@ -5664,14 +6124,21 @@ func (p *ObjectHistory) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|3; op != opOk {
return 0, &mstructDecodeError{"ObjectHistory", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("ObjectHistory", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("ObjectHistory.Oid", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("ObjectHistory.Oid", l, 8)
}
p.Oid = zodb.Oid(binary.BigEndian.Uint64(data[3:]))
data = data[11:]
p.Oid = zodb.Oid(binary.BigEndian.Uint64(data[2:]))
data = data[10:]
{
v, tail, err := msgp.ReadUint64Bytes(data)
if err != nil {
......@@ -5791,15 +6258,22 @@ func (p *AnswerObjectHistory) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|2; op != opOk {
return 0, &mstructDecodeError{"AnswerObjectHistory", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerObjectHistory", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("AnswerObjectHistory.Oid", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("AnswerObjectHistory.Oid", l, 8)
}
p.Oid = zodb.Oid(binary.BigEndian.Uint64(data[3:]))
p.Oid = zodb.Oid(binary.BigEndian.Uint64(data[2:]))
{
data = data[11:]
data = data[10:]
l, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerObjectHistory.HistoryList", err)
......@@ -5818,14 +6292,21 @@ func (p *AnswerObjectHistory) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|2; op != opOk {
return 0, &mstructDecodeError{"AnswerObjectHistory", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerObjectHistory", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("AnswerObjectHistory.Serial", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("AnswerObjectHistory.Serial", l, 8)
}
(*a).Serial = zodb.Tid(binary.BigEndian.Uint64(data[3:]))
data = data[11:]
(*a).Serial = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
data = data[10:]
{
v, tail, err := msgp.ReadUint32Bytes(data)
if err != nil {
......@@ -5901,7 +6382,13 @@ func (p *PartitionList) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|3; op != opOk {
return 0, &mstructDecodeError{"PartitionList", op, opOk}
}
data = data[1:]
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("PartitionList", err)
}
data = tail
}
{
v, tail, err := msgp.ReadUint32Bytes(data)
if err != nil {
......@@ -6076,7 +6563,13 @@ func (p *AnswerPartitionList) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|3; op != opOk {
return 0, &mstructDecodeError{"AnswerPartitionList", op, opOk}
}
data = data[1:]
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerPartitionList", err)
}
data = tail
}
{
v, tail, err := msgp.ReadUint64Bytes(data)
if err != nil {
......@@ -6112,7 +6605,13 @@ func (p *AnswerPartitionList) neoMsgDecodeM(data []byte) (int, error) {
return 0, &mstructDecodeError{"AnswerPartitionList", op, opOk}
}
{
data = data[1:]
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerPartitionList", err)
}
data = tail
}
{
l, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerPartitionList.CellList", err)
......@@ -6128,7 +6627,13 @@ func (p *AnswerPartitionList) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|2; op != opOk {
return 0, &mstructDecodeError{"AnswerPartitionList", op, opOk}
}
data = data[1:]
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerPartitionList", err)
}
data = tail
}
{
v, tail, err := msgp.ReadInt32Bytes(data)
if err != nil {
......@@ -6213,14 +6718,21 @@ func (p *NodeList) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|1; op != opOk {
return 0, &mstructDecodeError{"NodeList", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.FixExt1 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("NodeList", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.FixExt1 {
return 0, mdecodeOpErr("NodeList.NodeType", op, msgpack.FixExt1)
}
if enumType := data[2]; enumType != 4 {
if enumType := data[1]; enumType != 4 {
return 0, mdecodeEnumTypeErr("NodeList.NodeType", enumType, 4)
}
{
v := data[3]
v := data[2]
if !(0 <= v && v <= 0x7f) {
return 0, mdecodeEnumValueErr("NodeList.NodeType", v)
}
......@@ -6378,7 +6890,13 @@ func (p *AnswerNodeList) neoMsgDecodeM(data []byte) (int, error) {
return 0, &mstructDecodeError{"AnswerNodeList", op, opOk}
}
{
data = data[1:]
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerNodeList", err)
}
data = tail
}
{
l, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerNodeList.NodeList", err)
......@@ -6394,23 +6912,37 @@ func (p *AnswerNodeList) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|5; op != opOk {
return 0, &mstructDecodeError{"AnswerNodeList", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.FixExt1 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerNodeList", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.FixExt1 {
return 0, mdecodeOpErr("AnswerNodeList.Type", op, msgpack.FixExt1)
}
if enumType := data[2]; enumType != 4 {
if enumType := data[1]; enumType != 4 {
return 0, mdecodeEnumTypeErr("AnswerNodeList.Type", enumType, 4)
}
{
v := data[3]
v := data[2]
if !(0 <= v && v <= 0x7f) {
return 0, mdecodeEnumValueErr("AnswerNodeList.Type", v)
}
(*a).Type = NodeType(v)
}
if op, opOk := msgpack.Op(data[4]), msgpack.FixArray_4|2; op != opOk {
if op, opOk := msgpack.Op(data[3]), msgpack.FixArray_4|2; op != opOk {
return 0, &mstructDecodeError{"AnswerNodeList.Addr", op, opOk}
}
data = data[5:]
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerNodeList.Addr", err)
}
data = tail
}
data = data[3:]
{
b, tail, err := msgp.ReadBytesZC(data)
if err != nil {
......@@ -6526,7 +7058,13 @@ func (p *SetNodeState) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|2; op != opOk {
return 0, &mstructDecodeError{"SetNodeState", op, opOk}
}
data = data[1:]
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("SetNodeState", err)
}
data = tail
}
{
v, tail, err := msgp.ReadInt32Bytes(data)
if err != nil {
......@@ -6640,7 +7178,13 @@ func (p *AddPendingNodes) neoMsgDecodeM(data []byte) (int, error) {
return 0, &mstructDecodeError{"AddPendingNodes", op, opOk}
}
{
data = data[1:]
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AddPendingNodes", err)
}
data = tail
}
{
l, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AddPendingNodes.NodeList", err)
......@@ -6751,7 +7295,14 @@ func (p *TweakPartitionTable) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|2; op != opOk {
return 0, &mstructDecodeError{"TweakPartitionTable", op, opOk}
}
switch op := msgpack.Op(data[1]); op {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("TweakPartitionTable", err)
}
data = tail
}
switch op := msgpack.Op(data[0]); op {
default:
return 0, mdecodeOpErr("TweakPartitionTable.DryRun", op, msgpack.True, msgpack.False)
case msgpack.True:
......@@ -6760,7 +7311,7 @@ func (p *TweakPartitionTable) neoMsgDecodeM(data []byte) (int, error) {
p.DryRun = false
}
{
data = data[2:]
data = data[1:]
l, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("TweakPartitionTable.NodeList", err)
......@@ -6919,7 +7470,14 @@ func (p *AnswerTweakPartitionTable) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|2; op != opOk {
return 0, &mstructDecodeError{"AnswerTweakPartitionTable", op, opOk}
}
switch op := msgpack.Op(data[1]); op {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerTweakPartitionTable", err)
}
data = tail
}
switch op := msgpack.Op(data[0]); op {
default:
return 0, mdecodeOpErr("AnswerTweakPartitionTable.Changed", op, msgpack.True, msgpack.False)
case msgpack.True:
......@@ -6928,7 +7486,7 @@ func (p *AnswerTweakPartitionTable) neoMsgDecodeM(data []byte) (int, error) {
p.Changed = false
}
{
data = data[2:]
data = data[1:]
l, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerTweakPartitionTable.RowList", err)
......@@ -6945,7 +7503,13 @@ func (p *AnswerTweakPartitionTable) neoMsgDecodeM(data []byte) (int, error) {
return 0, &mstructDecodeError{"AnswerTweakPartitionTable", op, opOk}
}
{
data = data[1:]
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerTweakPartitionTable", err)
}
data = tail
}
{
l, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerTweakPartitionTable.CellList", err)
......@@ -6961,7 +7525,13 @@ func (p *AnswerTweakPartitionTable) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|2; op != opOk {
return 0, &mstructDecodeError{"AnswerTweakPartitionTable", op, opOk}
}
data = data[1:]
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerTweakPartitionTable", err)
}
data = tail
}
{
v, tail, err := msgp.ReadInt32Bytes(data)
if err != nil {
......@@ -7045,7 +7615,13 @@ func (p *SetNumReplicas) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|1; op != opOk {
return 0, &mstructDecodeError{"SetNumReplicas", op, opOk}
}
data = data[1:]
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("SetNumReplicas", err)
}
data = tail
}
{
v, tail, err := msgp.ReadUint32Bytes(data)
if err != nil {
......@@ -7107,14 +7683,21 @@ func (p *SetClusterState) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|1; op != opOk {
return 0, &mstructDecodeError{"SetClusterState", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.FixExt1 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("SetClusterState", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.FixExt1 {
return 0, mdecodeOpErr("SetClusterState.State", op, msgpack.FixExt1)
}
if enumType := data[2]; enumType != 1 {
if enumType := data[1]; enumType != 1 {
return 0, mdecodeEnumTypeErr("SetClusterState.State", enumType, 1)
}
{
v := data[3]
v := data[2]
if !(0 <= v && v <= 0x7f) {
return 0, mdecodeEnumValueErr("SetClusterState.State", v)
}
......@@ -7212,7 +7795,13 @@ func (p *Repair) neoMsgDecodeM(data []byte) (int, error) {
return 0, &mstructDecodeError{"Repair", op, opOk}
}
{
data = data[1:]
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("Repair", err)
}
data = tail
}
{
l, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("Repair.NodeList", err)
......@@ -7239,7 +7828,14 @@ func (p *Repair) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|1; op != opOk {
return 0, &mstructDecodeError{"Repair.repairFlags", op, opOk}
}
switch op := msgpack.Op(data[1]); op {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("Repair.repairFlags", err)
}
data = tail
}
switch op := msgpack.Op(data[0]); op {
default:
return 0, mdecodeOpErr("Repair.repairFlags.DryRun", op, msgpack.True, msgpack.False)
case msgpack.True:
......@@ -7295,10 +7891,24 @@ func (p *RepairOne) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|1; op != opOk {
return 0, &mstructDecodeError{"RepairOne", op, opOk}
}
if op, opOk := msgpack.Op(data[1]), msgpack.FixArray_4|1; op != opOk {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("RepairOne", err)
}
data = tail
}
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|1; op != opOk {
return 0, &mstructDecodeError{"RepairOne.repairFlags", op, opOk}
}
switch op := msgpack.Op(data[2]); op {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("RepairOne.repairFlags", err)
}
data = tail
}
switch op := msgpack.Op(data[0]); op {
default:
return 0, mdecodeOpErr("RepairOne.repairFlags.DryRun", op, msgpack.True, msgpack.False)
case msgpack.True:
......@@ -7358,14 +7968,21 @@ func (p *NotifyClusterState) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|1; op != opOk {
return 0, &mstructDecodeError{"NotifyClusterState", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.FixExt1 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("NotifyClusterState", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.FixExt1 {
return 0, mdecodeOpErr("NotifyClusterState.State", op, msgpack.FixExt1)
}
if enumType := data[2]; enumType != 1 {
if enumType := data[1]; enumType != 1 {
return 0, mdecodeEnumTypeErr("NotifyClusterState.State", enumType, 1)
}
{
v := data[3]
v := data[2]
if !(0 <= v && v <= 0x7f) {
return 0, mdecodeEnumValueErr("NotifyClusterState.State", v)
}
......@@ -7409,6 +8026,13 @@ func (p *AskClusterState) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|0; op != opOk {
return 0, &mstructDecodeError{"AskClusterState", op, opOk}
}
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AskClusterState", err)
}
data = tail
}
return 1, nil
overflow:
......@@ -7461,14 +8085,21 @@ func (p *AnswerClusterState) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|1; op != opOk {
return 0, &mstructDecodeError{"AnswerClusterState", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.FixExt1 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerClusterState", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.FixExt1 {
return 0, mdecodeOpErr("AnswerClusterState.State", op, msgpack.FixExt1)
}
if enumType := data[2]; enumType != 1 {
if enumType := data[1]; enumType != 1 {
return 0, mdecodeEnumTypeErr("AnswerClusterState.State", enumType, 1)
}
{
v := data[3]
v := data[2]
if !(0 <= v && v <= 0x7f) {
return 0, mdecodeEnumValueErr("AnswerClusterState.State", v)
}
......@@ -7571,29 +8202,36 @@ func (p *ObjectUndoSerial) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|4; op != opOk {
return 0, &mstructDecodeError{"ObjectUndoSerial", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("ObjectUndoSerial", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("ObjectUndoSerial.Tid", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("ObjectUndoSerial.Tid", l, 8)
}
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[3:]))
if op := msgpack.Op(data[11]); op != msgpack.Bin8 {
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
if op := msgpack.Op(data[10]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("ObjectUndoSerial.LTID", op, msgpack.Bin8)
}
if l := data[12]; l != 8 {
if l := data[11]; l != 8 {
return 0, mdecodeLen8Err("ObjectUndoSerial.LTID", l, 8)
}
p.LTID = zodb.Tid(binary.BigEndian.Uint64(data[13:]))
if op := msgpack.Op(data[21]); op != msgpack.Bin8 {
p.LTID = zodb.Tid(binary.BigEndian.Uint64(data[12:]))
if op := msgpack.Op(data[20]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("ObjectUndoSerial.UndoneTID", op, msgpack.Bin8)
}
if l := data[22]; l != 8 {
if l := data[21]; l != 8 {
return 0, mdecodeLen8Err("ObjectUndoSerial.UndoneTID", l, 8)
}
p.UndoneTID = zodb.Tid(binary.BigEndian.Uint64(data[23:]))
p.UndoneTID = zodb.Tid(binary.BigEndian.Uint64(data[22:]))
{
data = data[31:]
data = data[30:]
l, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("ObjectUndoSerial.OidList", err)
......@@ -7733,7 +8371,13 @@ func (p *AnswerObjectUndoSerial) neoMsgDecodeM(data []byte) (int, error) {
return 0, &mstructDecodeError{"AnswerObjectUndoSerial", op, opOk}
}
{
data = data[1:]
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerObjectUndoSerial", err)
}
data = tail
}
{
l, tail, err := msgp.ReadMapHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerObjectUndoSerial.ObjectTIDDict", err)
......@@ -7767,21 +8411,28 @@ func (p *AnswerObjectUndoSerial) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[10]), msgpack.FixArray_4|3; op != opOk {
return 0, &mstructDecodeError{"AnswerObjectUndoSerial", op, opOk}
}
if op := msgpack.Op(data[11]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerObjectUndoSerial", err)
}
data = tail
}
if op := msgpack.Op(data[10]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("AnswerObjectUndoSerial.CurrentSerial", op, msgpack.Bin8)
}
if l := data[12]; l != 8 {
if l := data[11]; l != 8 {
return 0, mdecodeLen8Err("AnswerObjectUndoSerial.CurrentSerial", l, 8)
}
mv.CurrentSerial = zodb.Tid(binary.BigEndian.Uint64(data[13:]))
if op := msgpack.Op(data[21]); op != msgpack.Bin8 {
mv.CurrentSerial = zodb.Tid(binary.BigEndian.Uint64(data[12:]))
if op := msgpack.Op(data[20]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("AnswerObjectUndoSerial.UndoSerial", op, msgpack.Bin8)
}
if l := data[22]; l != 8 {
if l := data[21]; l != 8 {
return 0, mdecodeLen8Err("AnswerObjectUndoSerial.UndoSerial", l, 8)
}
mv.UndoSerial = zodb.Tid(binary.BigEndian.Uint64(data[23:]))
switch op := msgpack.Op(data[31]); op {
mv.UndoSerial = zodb.Tid(binary.BigEndian.Uint64(data[22:]))
switch op := msgpack.Op(data[30]); op {
default:
return 0, mdecodeOpErr("AnswerObjectUndoSerial.IsCurrent", op, msgpack.True, msgpack.False)
case msgpack.True:
......@@ -7790,7 +8441,7 @@ func (p *AnswerObjectUndoSerial) neoMsgDecodeM(data []byte) (int, error) {
mv.IsCurrent = false
}
m[key] = mv
data = data[32:]
data = data[31:]
}
}
return 1 + int(nread), nil
......@@ -7860,21 +8511,28 @@ func (p *AskTIDsFrom) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|4; op != opOk {
return 0, &mstructDecodeError{"AskTIDsFrom", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AskTIDsFrom", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("AskTIDsFrom.MinTID", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("AskTIDsFrom.MinTID", l, 8)
}
p.MinTID = zodb.Tid(binary.BigEndian.Uint64(data[3:]))
if op := msgpack.Op(data[11]); op != msgpack.Bin8 {
p.MinTID = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
if op := msgpack.Op(data[10]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("AskTIDsFrom.MaxTID", op, msgpack.Bin8)
}
if l := data[12]; l != 8 {
if l := data[11]; l != 8 {
return 0, mdecodeLen8Err("AskTIDsFrom.MaxTID", l, 8)
}
p.MaxTID = zodb.Tid(binary.BigEndian.Uint64(data[13:]))
data = data[21:]
p.MaxTID = zodb.Tid(binary.BigEndian.Uint64(data[12:]))
data = data[20:]
{
v, tail, err := msgp.ReadUint32Bytes(data)
if err != nil {
......@@ -7976,7 +8634,13 @@ func (p *AnswerTIDsFrom) neoMsgDecodeM(data []byte) (int, error) {
return 0, &mstructDecodeError{"AnswerTIDsFrom", op, opOk}
}
{
data = data[1:]
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerTIDsFrom", err)
}
data = tail
}
{
l, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerTIDsFrom.TidList", err)
......@@ -8049,13 +8713,20 @@ func (p *Pack) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|1; op != opOk {
return 0, &mstructDecodeError{"Pack", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("Pack", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("Pack.Tid", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("Pack.Tid", l, 8)
}
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[3:]))
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
return 11, nil
overflow:
......@@ -8103,7 +8774,14 @@ func (p *AnswerPack) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|1; op != opOk {
return 0, &mstructDecodeError{"AnswerPack", op, opOk}
}
switch op := msgpack.Op(data[1]); op {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerPack", err)
}
data = tail
}
switch op := msgpack.Op(data[0]); op {
default:
return 0, mdecodeOpErr("AnswerPack.Status", op, msgpack.True, msgpack.False)
case msgpack.True:
......@@ -8223,7 +8901,13 @@ func (p *CheckReplicas) neoMsgDecodeM(data []byte) (int, error) {
return 0, &mstructDecodeError{"CheckReplicas", op, opOk}
}
{
data = data[1:]
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("CheckReplicas", err)
}
data = tail
}
{
l, tail, err := msgp.ReadMapHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("CheckReplicas.PartitionDict", err)
......@@ -8385,7 +9069,13 @@ func (p *CheckPartition) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|4; op != opOk {
return 0, &mstructDecodeError{"CheckPartition", op, opOk}
}
data = data[1:]
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("CheckPartition", err)
}
data = tail
}
{
v, tail, err := msgp.ReadUint32Bytes(data)
if err != nil {
......@@ -8401,7 +9091,13 @@ func (p *CheckPartition) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|2; op != opOk {
return 0, &mstructDecodeError{"CheckPartition.Source", op, opOk}
}
data = data[1:]
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("CheckPartition.Source", err)
}
data = tail
}
{
b, tail, err := msgp.ReadBytesZC(data)
if err != nil {
......@@ -8417,7 +9113,13 @@ func (p *CheckPartition) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|2; op != opOk {
return 0, &mstructDecodeError{"CheckPartition.Source.Address", op, opOk}
}
data = data[1:]
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("CheckPartition.Source.Address", err)
}
data = tail
}
{
b, tail, err := msgp.ReadBytesZC(data)
if err != nil {
......@@ -8520,7 +9222,13 @@ func (p *CheckTIDRange) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|4; op != opOk {
return 0, &mstructDecodeError{"CheckTIDRange", op, opOk}
}
data = data[1:]
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("CheckTIDRange", err)
}
data = tail
}
{
v, tail, err := msgp.ReadUint32Bytes(data)
if err != nil {
......@@ -8617,7 +9325,13 @@ func (p *AnswerCheckTIDRange) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|3; op != opOk {
return 0, &mstructDecodeError{"AnswerCheckTIDRange", op, opOk}
}
data = data[1:]
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerCheckTIDRange", err)
}
data = tail
}
{
v, tail, err := msgp.ReadUint32Bytes(data)
if err != nil {
......@@ -8716,7 +9430,13 @@ func (p *CheckSerialRange) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|5; op != opOk {
return 0, &mstructDecodeError{"CheckSerialRange", op, opOk}
}
data = data[1:]
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("CheckSerialRange", err)
}
data = tail
}
{
v, tail, err := msgp.ReadUint32Bytes(data)
if err != nil {
......@@ -8830,7 +9550,13 @@ func (p *AnswerCheckSerialRange) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|5; op != opOk {
return 0, &mstructDecodeError{"AnswerCheckSerialRange", op, opOk}
}
data = data[1:]
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerCheckSerialRange", err)
}
data = tail
}
{
v, tail, err := msgp.ReadUint32Bytes(data)
if err != nil {
......@@ -8964,7 +9690,13 @@ func (p *PartitionCorrupted) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|2; op != opOk {
return 0, &mstructDecodeError{"PartitionCorrupted", op, opOk}
}
data = data[1:]
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("PartitionCorrupted", err)
}
data = tail
}
{
v, tail, err := msgp.ReadUint32Bytes(data)
if err != nil {
......@@ -9033,6 +9765,13 @@ func (p *NotifyReady) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|0; op != opOk {
return 0, &mstructDecodeError{"NotifyReady", op, opOk}
}
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("NotifyReady", err)
}
data = tail
}
return 1, nil
overflow:
......@@ -9071,6 +9810,13 @@ func (p *LastTransaction) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|0; op != opOk {
return 0, &mstructDecodeError{"LastTransaction", op, opOk}
}
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("LastTransaction", err)
}
data = tail
}
return 1, nil
overflow:
......@@ -9120,13 +9866,20 @@ func (p *AnswerLastTransaction) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|1; op != opOk {
return 0, &mstructDecodeError{"AnswerLastTransaction", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerLastTransaction", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("AnswerLastTransaction.Tid", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("AnswerLastTransaction.Tid", l, 8)
}
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[3:]))
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
return 11, nil
overflow:
......@@ -9186,27 +9939,34 @@ func (p *CheckCurrentSerial) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|3; op != opOk {
return 0, &mstructDecodeError{"CheckCurrentSerial", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("CheckCurrentSerial", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("CheckCurrentSerial.Tid", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("CheckCurrentSerial.Tid", l, 8)
}
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[3:]))
if op := msgpack.Op(data[11]); op != msgpack.Bin8 {
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
if op := msgpack.Op(data[10]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("CheckCurrentSerial.Oid", op, msgpack.Bin8)
}
if l := data[12]; l != 8 {
if l := data[11]; l != 8 {
return 0, mdecodeLen8Err("CheckCurrentSerial.Oid", l, 8)
}
p.Oid = zodb.Oid(binary.BigEndian.Uint64(data[13:]))
if op := msgpack.Op(data[21]); op != msgpack.Bin8 {
p.Oid = zodb.Oid(binary.BigEndian.Uint64(data[12:]))
if op := msgpack.Op(data[20]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("CheckCurrentSerial.Serial", op, msgpack.Bin8)
}
if l := data[22]; l != 8 {
if l := data[21]; l != 8 {
return 0, mdecodeLen8Err("CheckCurrentSerial.Serial", l, 8)
}
p.Serial = zodb.Tid(binary.BigEndian.Uint64(data[23:]))
p.Serial = zodb.Tid(binary.BigEndian.Uint64(data[22:]))
return 31, nil
overflow:
......@@ -9257,16 +10017,30 @@ func (p *AnswerCheckCurrentSerial) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|1; op != opOk {
return 0, &mstructDecodeError{"AnswerCheckCurrentSerial", op, opOk}
}
if op, opOk := msgpack.Op(data[1]), msgpack.FixArray_4|1; op != opOk {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerCheckCurrentSerial", err)
}
data = tail
}
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|1; op != opOk {
return 0, &mstructDecodeError{"AnswerCheckCurrentSerial.AnswerStoreObject", op, opOk}
}
if op := msgpack.Op(data[2]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerCheckCurrentSerial.AnswerStoreObject", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("AnswerCheckCurrentSerial.AnswerStoreObject.Conflict", op, msgpack.Bin8)
}
if l := data[3]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("AnswerCheckCurrentSerial.AnswerStoreObject.Conflict", l, 8)
}
p.AnswerStoreObject.Conflict = zodb.Tid(binary.BigEndian.Uint64(data[4:]))
p.AnswerStoreObject.Conflict = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
return 12, nil
overflow:
......@@ -9321,20 +10095,27 @@ func (p *NotifyTransactionFinished) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|2; op != opOk {
return 0, &mstructDecodeError{"NotifyTransactionFinished", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("NotifyTransactionFinished", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("NotifyTransactionFinished.TTID", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("NotifyTransactionFinished.TTID", l, 8)
}
p.TTID = zodb.Tid(binary.BigEndian.Uint64(data[3:]))
if op := msgpack.Op(data[11]); op != msgpack.Bin8 {
p.TTID = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
if op := msgpack.Op(data[10]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("NotifyTransactionFinished.MaxTID", op, msgpack.Bin8)
}
if l := data[12]; l != 8 {
if l := data[11]; l != 8 {
return 0, mdecodeLen8Err("NotifyTransactionFinished.MaxTID", l, 8)
}
p.MaxTID = zodb.Tid(binary.BigEndian.Uint64(data[13:]))
p.MaxTID = zodb.Tid(binary.BigEndian.Uint64(data[12:]))
return 21, nil
overflow:
......@@ -9485,14 +10266,21 @@ func (p *Replicate) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|3; op != opOk {
return 0, &mstructDecodeError{"Replicate", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("Replicate", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("Replicate.Tid", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("Replicate.Tid", l, 8)
}
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[3:]))
data = data[11:]
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
data = data[10:]
{
b, tail, err := msgp.ReadBytesZC(data)
if err != nil {
......@@ -9589,7 +10377,13 @@ func (p *ReplicationDone) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|2; op != opOk {
return 0, &mstructDecodeError{"ReplicationDone", op, opOk}
}
data = data[1:]
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("ReplicationDone", err)
}
data = tail
}
{
v, tail, err := msgp.ReadUint32Bytes(data)
if err != nil {
......@@ -9713,7 +10507,13 @@ func (p *FetchTransactions) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|5; op != opOk {
return 0, &mstructDecodeError{"FetchTransactions", op, opOk}
}
data = data[1:]
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("FetchTransactions", err)
}
data = tail
}
{
v, tail, err := msgp.ReadUint32Bytes(data)
if err != nil {
......@@ -9866,22 +10666,29 @@ func (p *AnswerFetchTransactions) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|3; op != opOk {
return 0, &mstructDecodeError{"AnswerFetchTransactions", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerFetchTransactions", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("AnswerFetchTransactions.PackTid", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("AnswerFetchTransactions.PackTid", l, 8)
}
p.PackTid = zodb.Tid(binary.BigEndian.Uint64(data[3:]))
if op := msgpack.Op(data[11]); op != msgpack.Bin8 {
p.PackTid = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
if op := msgpack.Op(data[10]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("AnswerFetchTransactions.NextTid", op, msgpack.Bin8)
}
if l := data[12]; l != 8 {
if l := data[11]; l != 8 {
return 0, mdecodeLen8Err("AnswerFetchTransactions.NextTid", l, 8)
}
p.NextTid = zodb.Tid(binary.BigEndian.Uint64(data[13:]))
p.NextTid = zodb.Tid(binary.BigEndian.Uint64(data[12:]))
{
data = data[21:]
data = data[20:]
l, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerFetchTransactions.TxnDeleteList", err)
......@@ -10066,7 +10873,13 @@ func (p *FetchObjects) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|6; op != opOk {
return 0, &mstructDecodeError{"FetchObjects", op, opOk}
}
data = data[1:]
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("FetchObjects", err)
}
data = tail
}
{
v, tail, err := msgp.ReadUint32Bytes(data)
if err != nil {
......@@ -10310,29 +11123,36 @@ func (p *AnswerFetchObjects) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|4; op != opOk {
return 0, &mstructDecodeError{"AnswerFetchObjects", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerFetchObjects", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("AnswerFetchObjects.PackTid", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("AnswerFetchObjects.PackTid", l, 8)
}
p.PackTid = zodb.Tid(binary.BigEndian.Uint64(data[3:]))
if op := msgpack.Op(data[11]); op != msgpack.Bin8 {
p.PackTid = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
if op := msgpack.Op(data[10]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("AnswerFetchObjects.NextTid", op, msgpack.Bin8)
}
if l := data[12]; l != 8 {
if l := data[11]; l != 8 {
return 0, mdecodeLen8Err("AnswerFetchObjects.NextTid", l, 8)
}
p.NextTid = zodb.Tid(binary.BigEndian.Uint64(data[13:]))
if op := msgpack.Op(data[21]); op != msgpack.Bin8 {
p.NextTid = zodb.Tid(binary.BigEndian.Uint64(data[12:]))
if op := msgpack.Op(data[20]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("AnswerFetchObjects.NextOid", op, msgpack.Bin8)
}
if l := data[22]; l != 8 {
if l := data[21]; l != 8 {
return 0, mdecodeLen8Err("AnswerFetchObjects.NextOid", l, 8)
}
p.NextOid = zodb.Oid(binary.BigEndian.Uint64(data[23:]))
p.NextOid = zodb.Oid(binary.BigEndian.Uint64(data[22:]))
{
data = data[31:]
data = data[30:]
l, tail, err := msgp.ReadMapHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AnswerFetchObjects.ObjDeleteDict", err)
......@@ -10550,14 +11370,21 @@ func (p *AddTransaction) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|7; op != opOk {
return 0, &mstructDecodeError{"AddTransaction", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AddTransaction", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("AddTransaction.Tid", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("AddTransaction.Tid", l, 8)
}
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[3:]))
data = data[11:]
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
data = data[10:]
{
b, tail, err := msgp.ReadBytesZC(data)
if err != nil {
......@@ -10722,21 +11549,28 @@ func (p *AddObject) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|6; op != opOk {
return 0, &mstructDecodeError{"AddObject", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("AddObject", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("AddObject.Oid", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("AddObject.Oid", l, 8)
}
p.Oid = zodb.Oid(binary.BigEndian.Uint64(data[3:]))
if op := msgpack.Op(data[11]); op != msgpack.Bin8 {
p.Oid = zodb.Oid(binary.BigEndian.Uint64(data[2:]))
if op := msgpack.Op(data[10]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("AddObject.Serial", op, msgpack.Bin8)
}
if l := data[12]; l != 8 {
if l := data[11]; l != 8 {
return 0, mdecodeLen8Err("AddObject.Serial", l, 8)
}
p.Serial = zodb.Tid(binary.BigEndian.Uint64(data[13:]))
switch op := msgpack.Op(data[21]); op {
p.Serial = zodb.Tid(binary.BigEndian.Uint64(data[12:]))
switch op := msgpack.Op(data[20]); op {
default:
return 0, mdecodeOpErr("AddObject.Compression", op, msgpack.True, msgpack.False)
case msgpack.True:
......@@ -10744,14 +11578,14 @@ func (p *AddObject) neoMsgDecodeM(data []byte) (int, error) {
case msgpack.False:
p.Compression = false
}
if op := msgpack.Op(data[22]); op != msgpack.Bin8 {
if op := msgpack.Op(data[21]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("AddObject.Checksum", op, msgpack.Bin8)
}
if l := data[23]; l != 20 {
if l := data[22]; l != 20 {
return 0, mdecodeLen8Err("AddObject.Checksum", l, 20)
}
copy(p.Checksum[:], data[24:44])
data = data[44:]
copy(p.Checksum[:], data[23:43])
data = data[43:]
{
b, tail, err := msgp.ReadBytesZC(data)
if err != nil {
......@@ -10821,13 +11655,20 @@ func (p *Truncate) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|1; op != opOk {
return 0, &mstructDecodeError{"Truncate", op, opOk}
}
if op := msgpack.Op(data[1]); op != msgpack.Bin8 {
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("Truncate", err)
}
data = tail
}
if op := msgpack.Op(data[0]); op != msgpack.Bin8 {
return 0, mdecodeOpErr("Truncate.Tid", op, msgpack.Bin8)
}
if l := data[2]; l != 8 {
if l := data[1]; l != 8 {
return 0, mdecodeLen8Err("Truncate.Tid", l, 8)
}
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[3:]))
p.Tid = zodb.Tid(binary.BigEndian.Uint64(data[2:]))
return 11, nil
overflow:
......@@ -10866,6 +11707,13 @@ func (p *FlushLog) neoMsgDecodeM(data []byte) (int, error) {
if op, opOk := msgpack.Op(data[0]), msgpack.FixArray_4|0; op != opOk {
return 0, &mstructDecodeError{"FlushLog", op, opOk}
}
{
_, tail, err := msgp.ReadArrayHeaderBytes(data)
if err != nil {
return 0, mdecodeErr("FlushLog", err)
}
data = tail
}
return 1, nil
overflow:
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7