summaryrefslogtreecommitdiff
path: root/data/basics/msgp_gen.go
diff options
context:
space:
mode:
Diffstat (limited to 'data/basics/msgp_gen.go')
-rw-r--r--data/basics/msgp_gen.go735
1 files changed, 0 insertions, 735 deletions
diff --git a/data/basics/msgp_gen.go b/data/basics/msgp_gen.go
index 6127920e8..8e61362d6 100644
--- a/data/basics/msgp_gen.go
+++ b/data/basics/msgp_gen.go
@@ -107,22 +107,6 @@ import (
// |-----> Msgsize
// |-----> MsgIsZero
//
-// EvalDelta
-// |-----> (*) MarshalMsg
-// |-----> (*) CanMarshalMsg
-// |-----> (*) UnmarshalMsg
-// |-----> (*) CanUnmarshalMsg
-// |-----> (*) Msgsize
-// |-----> (*) MsgIsZero
-//
-// LogItem
-// |-----> (*) MarshalMsg
-// |-----> (*) CanMarshalMsg
-// |-----> (*) UnmarshalMsg
-// |-----> (*) CanUnmarshalMsg
-// |-----> (*) Msgsize
-// |-----> (*) MsgIsZero
-//
// Round
// |-----> MarshalMsg
// |-----> CanMarshalMsg
@@ -4134,725 +4118,6 @@ func (z DeltaAction) MsgIsZero() bool {
}
// MarshalMsg implements msgp.Marshaler
-func (z *EvalDelta) MarshalMsg(b []byte) (o []byte) {
- o = msgp.Require(b, z.Msgsize())
- // omitempty: check for empty values
- zb0008Len := uint32(3)
- var zb0008Mask uint8 /* 4 bits */
- if len((*z).GlobalDelta) == 0 {
- zb0008Len--
- zb0008Mask |= 0x2
- }
- if len((*z).LocalDeltas) == 0 {
- zb0008Len--
- zb0008Mask |= 0x4
- }
- if len((*z).Logs) == 0 {
- zb0008Len--
- zb0008Mask |= 0x8
- }
- // variable map header, size zb0008Len
- o = append(o, 0x80|uint8(zb0008Len))
- if zb0008Len != 0 {
- if (zb0008Mask & 0x2) == 0 { // if not empty
- // string "gd"
- o = append(o, 0xa2, 0x67, 0x64)
- if (*z).GlobalDelta == nil {
- o = msgp.AppendNil(o)
- } else {
- o = msgp.AppendMapHeader(o, uint32(len((*z).GlobalDelta)))
- }
- zb0001_keys := make([]string, 0, len((*z).GlobalDelta))
- for zb0001 := range (*z).GlobalDelta {
- zb0001_keys = append(zb0001_keys, zb0001)
- }
- sort.Sort(SortString(zb0001_keys))
- for _, zb0001 := range zb0001_keys {
- zb0002 := (*z).GlobalDelta[zb0001]
- _ = zb0002
- o = msgp.AppendString(o, zb0001)
- o = zb0002.MarshalMsg(o)
- }
- }
- if (zb0008Mask & 0x4) == 0 { // if not empty
- // string "ld"
- o = append(o, 0xa2, 0x6c, 0x64)
- if (*z).LocalDeltas == nil {
- o = msgp.AppendNil(o)
- } else {
- o = msgp.AppendMapHeader(o, uint32(len((*z).LocalDeltas)))
- }
- zb0003_keys := make([]uint64, 0, len((*z).LocalDeltas))
- for zb0003 := range (*z).LocalDeltas {
- zb0003_keys = append(zb0003_keys, zb0003)
- }
- sort.Sort(SortUint64(zb0003_keys))
- for _, zb0003 := range zb0003_keys {
- zb0004 := (*z).LocalDeltas[zb0003]
- _ = zb0004
- o = msgp.AppendUint64(o, zb0003)
- if zb0004 == nil {
- o = msgp.AppendNil(o)
- } else {
- o = msgp.AppendMapHeader(o, uint32(len(zb0004)))
- }
- zb0005_keys := make([]string, 0, len(zb0004))
- for zb0005 := range zb0004 {
- zb0005_keys = append(zb0005_keys, zb0005)
- }
- sort.Sort(SortString(zb0005_keys))
- for _, zb0005 := range zb0005_keys {
- zb0006 := zb0004[zb0005]
- _ = zb0006
- o = msgp.AppendString(o, zb0005)
- o = zb0006.MarshalMsg(o)
- }
- }
- }
- if (zb0008Mask & 0x8) == 0 { // if not empty
- // string "lg"
- o = append(o, 0xa2, 0x6c, 0x67)
- if (*z).Logs == nil {
- o = msgp.AppendNil(o)
- } else {
- o = msgp.AppendArrayHeader(o, uint32(len((*z).Logs)))
- }
- for zb0007 := range (*z).Logs {
- // omitempty: check for empty values
- zb0009Len := uint32(2)
- var zb0009Mask uint8 /* 3 bits */
- if (*z).Logs[zb0007].ID == 0 {
- zb0009Len--
- zb0009Mask |= 0x2
- }
- if (*z).Logs[zb0007].Message == "" {
- zb0009Len--
- zb0009Mask |= 0x4
- }
- // variable map header, size zb0009Len
- o = append(o, 0x80|uint8(zb0009Len))
- if (zb0009Mask & 0x2) == 0 { // if not empty
- // string "i"
- o = append(o, 0xa1, 0x69)
- o = msgp.AppendUint64(o, (*z).Logs[zb0007].ID)
- }
- if (zb0009Mask & 0x4) == 0 { // if not empty
- // string "m"
- o = append(o, 0xa1, 0x6d)
- o = msgp.AppendString(o, (*z).Logs[zb0007].Message)
- }
- }
- }
- }
- return
-}
-
-func (_ *EvalDelta) CanMarshalMsg(z interface{}) bool {
- _, ok := (z).(*EvalDelta)
- return ok
-}
-
-// UnmarshalMsg implements msgp.Unmarshaler
-func (z *EvalDelta) UnmarshalMsg(bts []byte) (o []byte, err error) {
- var field []byte
- _ = field
- var zb0008 int
- var zb0009 bool
- zb0008, zb0009, bts, err = msgp.ReadMapHeaderBytes(bts)
- if _, ok := err.(msgp.TypeError); ok {
- zb0008, zb0009, bts, err = msgp.ReadArrayHeaderBytes(bts)
- if err != nil {
- err = msgp.WrapError(err)
- return
- }
- if zb0008 > 0 {
- zb0008--
- var zb0010 int
- var zb0011 bool
- zb0010, zb0011, bts, err = msgp.ReadMapHeaderBytes(bts)
- if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "GlobalDelta")
- return
- }
- if zb0010 > config.MaxStateDeltaKeys {
- err = msgp.ErrOverflow(uint64(zb0010), uint64(config.MaxStateDeltaKeys))
- err = msgp.WrapError(err, "struct-from-array", "GlobalDelta")
- return
- }
- if zb0011 {
- (*z).GlobalDelta = nil
- } else if (*z).GlobalDelta == nil {
- (*z).GlobalDelta = make(StateDelta, zb0010)
- }
- for zb0010 > 0 {
- var zb0001 string
- var zb0002 ValueDelta
- zb0010--
- zb0001, bts, err = msgp.ReadStringBytes(bts)
- if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "GlobalDelta")
- return
- }
- bts, err = zb0002.UnmarshalMsg(bts)
- if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "GlobalDelta", zb0001)
- return
- }
- (*z).GlobalDelta[zb0001] = zb0002
- }
- }
- if zb0008 > 0 {
- zb0008--
- var zb0012 int
- var zb0013 bool
- zb0012, zb0013, bts, err = msgp.ReadMapHeaderBytes(bts)
- if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "LocalDeltas")
- return
- }
- if zb0012 > config.MaxEvalDeltaAccounts {
- err = msgp.ErrOverflow(uint64(zb0012), uint64(config.MaxEvalDeltaAccounts))
- err = msgp.WrapError(err, "struct-from-array", "LocalDeltas")
- return
- }
- if zb0013 {
- (*z).LocalDeltas = nil
- } else if (*z).LocalDeltas == nil {
- (*z).LocalDeltas = make(map[uint64]StateDelta, zb0012)
- }
- for zb0012 > 0 {
- var zb0003 uint64
- var zb0004 StateDelta
- zb0012--
- zb0003, bts, err = msgp.ReadUint64Bytes(bts)
- if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "LocalDeltas")
- return
- }
- var zb0014 int
- var zb0015 bool
- zb0014, zb0015, bts, err = msgp.ReadMapHeaderBytes(bts)
- if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "LocalDeltas", zb0003)
- return
- }
- if zb0014 > config.MaxStateDeltaKeys {
- err = msgp.ErrOverflow(uint64(zb0014), uint64(config.MaxStateDeltaKeys))
- err = msgp.WrapError(err, "struct-from-array", "LocalDeltas", zb0003)
- return
- }
- if zb0015 {
- zb0004 = nil
- } else if zb0004 == nil {
- zb0004 = make(StateDelta, zb0014)
- }
- for zb0014 > 0 {
- var zb0005 string
- var zb0006 ValueDelta
- zb0014--
- zb0005, bts, err = msgp.ReadStringBytes(bts)
- if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "LocalDeltas", zb0003)
- return
- }
- bts, err = zb0006.UnmarshalMsg(bts)
- if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "LocalDeltas", zb0003, zb0005)
- return
- }
- zb0004[zb0005] = zb0006
- }
- (*z).LocalDeltas[zb0003] = zb0004
- }
- }
- if zb0008 > 0 {
- zb0008--
- var zb0016 int
- var zb0017 bool
- zb0016, zb0017, bts, err = msgp.ReadArrayHeaderBytes(bts)
- if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Logs")
- return
- }
- if zb0016 > config.MaxLogCalls {
- err = msgp.ErrOverflow(uint64(zb0016), uint64(config.MaxLogCalls))
- err = msgp.WrapError(err, "struct-from-array", "Logs")
- return
- }
- if zb0017 {
- (*z).Logs = nil
- } else if (*z).Logs != nil && cap((*z).Logs) >= zb0016 {
- (*z).Logs = ((*z).Logs)[:zb0016]
- } else {
- (*z).Logs = make([]LogItem, zb0016)
- }
- for zb0007 := range (*z).Logs {
- var zb0018 int
- var zb0019 bool
- zb0018, zb0019, bts, err = msgp.ReadMapHeaderBytes(bts)
- if _, ok := err.(msgp.TypeError); ok {
- zb0018, zb0019, bts, err = msgp.ReadArrayHeaderBytes(bts)
- if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Logs", zb0007)
- return
- }
- if zb0018 > 0 {
- zb0018--
- (*z).Logs[zb0007].ID, bts, err = msgp.ReadUint64Bytes(bts)
- if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Logs", zb0007, "struct-from-array", "ID")
- return
- }
- }
- if zb0018 > 0 {
- zb0018--
- (*z).Logs[zb0007].Message, bts, err = msgp.ReadStringBytes(bts)
- if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Logs", zb0007, "struct-from-array", "Message")
- return
- }
- }
- if zb0018 > 0 {
- err = msgp.ErrTooManyArrayFields(zb0018)
- if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Logs", zb0007, "struct-from-array")
- return
- }
- }
- } else {
- if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Logs", zb0007)
- return
- }
- if zb0019 {
- (*z).Logs[zb0007] = LogItem{}
- }
- for zb0018 > 0 {
- zb0018--
- field, bts, err = msgp.ReadMapKeyZC(bts)
- if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Logs", zb0007)
- return
- }
- switch string(field) {
- case "i":
- (*z).Logs[zb0007].ID, bts, err = msgp.ReadUint64Bytes(bts)
- if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Logs", zb0007, "ID")
- return
- }
- case "m":
- (*z).Logs[zb0007].Message, bts, err = msgp.ReadStringBytes(bts)
- if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Logs", zb0007, "Message")
- return
- }
- default:
- err = msgp.ErrNoField(string(field))
- if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Logs", zb0007)
- return
- }
- }
- }
- }
- }
- }
- if zb0008 > 0 {
- err = msgp.ErrTooManyArrayFields(zb0008)
- if err != nil {
- err = msgp.WrapError(err, "struct-from-array")
- return
- }
- }
- } else {
- if err != nil {
- err = msgp.WrapError(err)
- return
- }
- if zb0009 {
- (*z) = EvalDelta{}
- }
- for zb0008 > 0 {
- zb0008--
- field, bts, err = msgp.ReadMapKeyZC(bts)
- if err != nil {
- err = msgp.WrapError(err)
- return
- }
- switch string(field) {
- case "gd":
- var zb0020 int
- var zb0021 bool
- zb0020, zb0021, bts, err = msgp.ReadMapHeaderBytes(bts)
- if err != nil {
- err = msgp.WrapError(err, "GlobalDelta")
- return
- }
- if zb0020 > config.MaxStateDeltaKeys {
- err = msgp.ErrOverflow(uint64(zb0020), uint64(config.MaxStateDeltaKeys))
- err = msgp.WrapError(err, "GlobalDelta")
- return
- }
- if zb0021 {
- (*z).GlobalDelta = nil
- } else if (*z).GlobalDelta == nil {
- (*z).GlobalDelta = make(StateDelta, zb0020)
- }
- for zb0020 > 0 {
- var zb0001 string
- var zb0002 ValueDelta
- zb0020--
- zb0001, bts, err = msgp.ReadStringBytes(bts)
- if err != nil {
- err = msgp.WrapError(err, "GlobalDelta")
- return
- }
- bts, err = zb0002.UnmarshalMsg(bts)
- if err != nil {
- err = msgp.WrapError(err, "GlobalDelta", zb0001)
- return
- }
- (*z).GlobalDelta[zb0001] = zb0002
- }
- case "ld":
- var zb0022 int
- var zb0023 bool
- zb0022, zb0023, bts, err = msgp.ReadMapHeaderBytes(bts)
- if err != nil {
- err = msgp.WrapError(err, "LocalDeltas")
- return
- }
- if zb0022 > config.MaxEvalDeltaAccounts {
- err = msgp.ErrOverflow(uint64(zb0022), uint64(config.MaxEvalDeltaAccounts))
- err = msgp.WrapError(err, "LocalDeltas")
- return
- }
- if zb0023 {
- (*z).LocalDeltas = nil
- } else if (*z).LocalDeltas == nil {
- (*z).LocalDeltas = make(map[uint64]StateDelta, zb0022)
- }
- for zb0022 > 0 {
- var zb0003 uint64
- var zb0004 StateDelta
- zb0022--
- zb0003, bts, err = msgp.ReadUint64Bytes(bts)
- if err != nil {
- err = msgp.WrapError(err, "LocalDeltas")
- return
- }
- var zb0024 int
- var zb0025 bool
- zb0024, zb0025, bts, err = msgp.ReadMapHeaderBytes(bts)
- if err != nil {
- err = msgp.WrapError(err, "LocalDeltas", zb0003)
- return
- }
- if zb0024 > config.MaxStateDeltaKeys {
- err = msgp.ErrOverflow(uint64(zb0024), uint64(config.MaxStateDeltaKeys))
- err = msgp.WrapError(err, "LocalDeltas", zb0003)
- return
- }
- if zb0025 {
- zb0004 = nil
- } else if zb0004 == nil {
- zb0004 = make(StateDelta, zb0024)
- }
- for zb0024 > 0 {
- var zb0005 string
- var zb0006 ValueDelta
- zb0024--
- zb0005, bts, err = msgp.ReadStringBytes(bts)
- if err != nil {
- err = msgp.WrapError(err, "LocalDeltas", zb0003)
- return
- }
- bts, err = zb0006.UnmarshalMsg(bts)
- if err != nil {
- err = msgp.WrapError(err, "LocalDeltas", zb0003, zb0005)
- return
- }
- zb0004[zb0005] = zb0006
- }
- (*z).LocalDeltas[zb0003] = zb0004
- }
- case "lg":
- var zb0026 int
- var zb0027 bool
- zb0026, zb0027, bts, err = msgp.ReadArrayHeaderBytes(bts)
- if err != nil {
- err = msgp.WrapError(err, "Logs")
- return
- }
- if zb0026 > config.MaxLogCalls {
- err = msgp.ErrOverflow(uint64(zb0026), uint64(config.MaxLogCalls))
- err = msgp.WrapError(err, "Logs")
- return
- }
- if zb0027 {
- (*z).Logs = nil
- } else if (*z).Logs != nil && cap((*z).Logs) >= zb0026 {
- (*z).Logs = ((*z).Logs)[:zb0026]
- } else {
- (*z).Logs = make([]LogItem, zb0026)
- }
- for zb0007 := range (*z).Logs {
- var zb0028 int
- var zb0029 bool
- zb0028, zb0029, bts, err = msgp.ReadMapHeaderBytes(bts)
- if _, ok := err.(msgp.TypeError); ok {
- zb0028, zb0029, bts, err = msgp.ReadArrayHeaderBytes(bts)
- if err != nil {
- err = msgp.WrapError(err, "Logs", zb0007)
- return
- }
- if zb0028 > 0 {
- zb0028--
- (*z).Logs[zb0007].ID, bts, err = msgp.ReadUint64Bytes(bts)
- if err != nil {
- err = msgp.WrapError(err, "Logs", zb0007, "struct-from-array", "ID")
- return
- }
- }
- if zb0028 > 0 {
- zb0028--
- (*z).Logs[zb0007].Message, bts, err = msgp.ReadStringBytes(bts)
- if err != nil {
- err = msgp.WrapError(err, "Logs", zb0007, "struct-from-array", "Message")
- return
- }
- }
- if zb0028 > 0 {
- err = msgp.ErrTooManyArrayFields(zb0028)
- if err != nil {
- err = msgp.WrapError(err, "Logs", zb0007, "struct-from-array")
- return
- }
- }
- } else {
- if err != nil {
- err = msgp.WrapError(err, "Logs", zb0007)
- return
- }
- if zb0029 {
- (*z).Logs[zb0007] = LogItem{}
- }
- for zb0028 > 0 {
- zb0028--
- field, bts, err = msgp.ReadMapKeyZC(bts)
- if err != nil {
- err = msgp.WrapError(err, "Logs", zb0007)
- return
- }
- switch string(field) {
- case "i":
- (*z).Logs[zb0007].ID, bts, err = msgp.ReadUint64Bytes(bts)
- if err != nil {
- err = msgp.WrapError(err, "Logs", zb0007, "ID")
- return
- }
- case "m":
- (*z).Logs[zb0007].Message, bts, err = msgp.ReadStringBytes(bts)
- if err != nil {
- err = msgp.WrapError(err, "Logs", zb0007, "Message")
- return
- }
- default:
- err = msgp.ErrNoField(string(field))
- if err != nil {
- err = msgp.WrapError(err, "Logs", zb0007)
- return
- }
- }
- }
- }
- }
- default:
- err = msgp.ErrNoField(string(field))
- if err != nil {
- err = msgp.WrapError(err)
- return
- }
- }
- }
- }
- o = bts
- return
-}
-
-func (_ *EvalDelta) CanUnmarshalMsg(z interface{}) bool {
- _, ok := (z).(*EvalDelta)
- return ok
-}
-
-// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
-func (z *EvalDelta) Msgsize() (s int) {
- s = 1 + 3 + msgp.MapHeaderSize
- if (*z).GlobalDelta != nil {
- for zb0001, zb0002 := range (*z).GlobalDelta {
- _ = zb0001
- _ = zb0002
- s += 0 + msgp.StringPrefixSize + len(zb0001) + zb0002.Msgsize()
- }
- }
- s += 3 + msgp.MapHeaderSize
- if (*z).LocalDeltas != nil {
- for zb0003, zb0004 := range (*z).LocalDeltas {
- _ = zb0003
- _ = zb0004
- s += 0 + msgp.Uint64Size + msgp.MapHeaderSize
- if zb0004 != nil {
- for zb0005, zb0006 := range zb0004 {
- _ = zb0005
- _ = zb0006
- s += 0 + msgp.StringPrefixSize + len(zb0005) + zb0006.Msgsize()
- }
- }
- }
- }
- s += 3 + msgp.ArrayHeaderSize
- for zb0007 := range (*z).Logs {
- s += 1 + 2 + msgp.Uint64Size + 2 + msgp.StringPrefixSize + len((*z).Logs[zb0007].Message)
- }
- return
-}
-
-// MsgIsZero returns whether this is a zero value
-func (z *EvalDelta) MsgIsZero() bool {
- return (len((*z).GlobalDelta) == 0) && (len((*z).LocalDeltas) == 0) && (len((*z).Logs) == 0)
-}
-
-// MarshalMsg implements msgp.Marshaler
-func (z *LogItem) MarshalMsg(b []byte) (o []byte) {
- o = msgp.Require(b, z.Msgsize())
- // omitempty: check for empty values
- zb0001Len := uint32(2)
- var zb0001Mask uint8 /* 3 bits */
- if (*z).ID == 0 {
- zb0001Len--
- zb0001Mask |= 0x2
- }
- if (*z).Message == "" {
- zb0001Len--
- zb0001Mask |= 0x4
- }
- // variable map header, size zb0001Len
- o = append(o, 0x80|uint8(zb0001Len))
- if zb0001Len != 0 {
- if (zb0001Mask & 0x2) == 0 { // if not empty
- // string "i"
- o = append(o, 0xa1, 0x69)
- o = msgp.AppendUint64(o, (*z).ID)
- }
- if (zb0001Mask & 0x4) == 0 { // if not empty
- // string "m"
- o = append(o, 0xa1, 0x6d)
- o = msgp.AppendString(o, (*z).Message)
- }
- }
- return
-}
-
-func (_ *LogItem) CanMarshalMsg(z interface{}) bool {
- _, ok := (z).(*LogItem)
- return ok
-}
-
-// UnmarshalMsg implements msgp.Unmarshaler
-func (z *LogItem) UnmarshalMsg(bts []byte) (o []byte, err error) {
- var field []byte
- _ = field
- var zb0001 int
- var zb0002 bool
- zb0001, zb0002, bts, err = msgp.ReadMapHeaderBytes(bts)
- if _, ok := err.(msgp.TypeError); ok {
- zb0001, zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
- if err != nil {
- err = msgp.WrapError(err)
- return
- }
- if zb0001 > 0 {
- zb0001--
- (*z).ID, bts, err = msgp.ReadUint64Bytes(bts)
- if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "ID")
- return
- }
- }
- if zb0001 > 0 {
- zb0001--
- (*z).Message, bts, err = msgp.ReadStringBytes(bts)
- if err != nil {
- err = msgp.WrapError(err, "struct-from-array", "Message")
- return
- }
- }
- if zb0001 > 0 {
- err = msgp.ErrTooManyArrayFields(zb0001)
- if err != nil {
- err = msgp.WrapError(err, "struct-from-array")
- return
- }
- }
- } else {
- if err != nil {
- err = msgp.WrapError(err)
- return
- }
- if zb0002 {
- (*z) = LogItem{}
- }
- for zb0001 > 0 {
- zb0001--
- field, bts, err = msgp.ReadMapKeyZC(bts)
- if err != nil {
- err = msgp.WrapError(err)
- return
- }
- switch string(field) {
- case "i":
- (*z).ID, bts, err = msgp.ReadUint64Bytes(bts)
- if err != nil {
- err = msgp.WrapError(err, "ID")
- return
- }
- case "m":
- (*z).Message, bts, err = msgp.ReadStringBytes(bts)
- if err != nil {
- err = msgp.WrapError(err, "Message")
- return
- }
- default:
- err = msgp.ErrNoField(string(field))
- if err != nil {
- err = msgp.WrapError(err)
- return
- }
- }
- }
- }
- o = bts
- return
-}
-
-func (_ *LogItem) CanUnmarshalMsg(z interface{}) bool {
- _, ok := (z).(*LogItem)
- return ok
-}
-
-// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
-func (z *LogItem) Msgsize() (s int) {
- s = 1 + 2 + msgp.Uint64Size + 2 + msgp.StringPrefixSize + len((*z).Message)
- return
-}
-
-// MsgIsZero returns whether this is a zero value
-func (z *LogItem) MsgIsZero() bool {
- return ((*z).ID == 0) && ((*z).Message == "")
-}
-
-// MarshalMsg implements msgp.Marshaler
func (z Round) MarshalMsg(b []byte) (o []byte) {
o = msgp.Require(b, z.Msgsize())
o = msgp.AppendUint64(o, uint64(z))
generated by cgit v1.2.3 (git 2.44.0) at 2024-05-03 10:39:54 +0000