msgp_gen.go

package node

// Code generated by github.com/algorand/msgp DO NOT EDIT.

import (
	"github.com/algorand/msgp/msgp"
)

// The following msgp objects are implemented in this file:
// netPrioResponse
//        |-----> (*) MarshalMsg
//        |-----> (*) CanMarshalMsg
//        |-----> (*) UnmarshalMsg
//        |-----> (*) CanUnmarshalMsg
//        |-----> (*) Msgsize
//        |-----> (*) MsgIsZero
//
// netPrioResponseSigned
//           |-----> (*) MarshalMsg
//           |-----> (*) CanMarshalMsg
//           |-----> (*) UnmarshalMsg
//           |-----> (*) CanUnmarshalMsg
//           |-----> (*) Msgsize
//           |-----> (*) MsgIsZero
//

// MarshalMsg implements msgp.Marshaler
func (z *netPrioResponse) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// omitempty: check for empty values
	zb0001Len := uint32(1)
	var zb0001Mask uint8 /* 2 bits */
	if (*z).Nonce == "" {
		zb0001Len--
		zb0001Mask |= 0x1
	}
	// variable map header, size zb0001Len
	o = append(o, 0x80|uint8(zb0001Len))
	if zb0001Len != 0 {
		if (zb0001Mask & 0x1) == 0 { // if not empty
			// string "Nonce"
			o = append(o, 0xa5, 0x4e, 0x6f, 0x6e, 0x63, 0x65)
			o = msgp.AppendString(o, (*z).Nonce)
		}
	}
	return
}

func (_ *netPrioResponse) CanMarshalMsg(z interface{}) bool {
	_, ok := (z).(*netPrioResponse)
	return ok
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *netPrioResponse) 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).Nonce, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "Nonce")
				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) = netPrioResponse{}
		}
		for zb0001 > 0 {
			zb0001--
			field, bts, err = msgp.ReadMapKeyZC(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
			switch string(field) {
			case "Nonce":
				(*z).Nonce, bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Nonce")
					return
				}
			default:
				err = msgp.ErrNoField(string(field))
				if err != nil {
					err = msgp.WrapError(err)
					return
				}
			}
		}
	}
	o = bts
	return
}

func (_ *netPrioResponse) CanUnmarshalMsg(z interface{}) bool {
	_, ok := (z).(*netPrioResponse)
	return ok
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *netPrioResponse) Msgsize() (s int) {
	s = 1 + 6 + msgp.StringPrefixSize + len((*z).Nonce)
	return
}

// MsgIsZero returns whether this is a zero value
func (z *netPrioResponse) MsgIsZero() bool {
	return ((*z).Nonce == "")
}

// MarshalMsg implements msgp.Marshaler
func (z *netPrioResponseSigned) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// omitempty: check for empty values
	zb0001Len := uint32(4)
	var zb0001Mask uint8 /* 5 bits */
	if (*z).Response.Nonce == "" {
		zb0001Len--
		zb0001Mask |= 0x1
	}
	if (*z).Round.MsgIsZero() {
		zb0001Len--
		zb0001Mask |= 0x2
	}
	if (*z).Sender.MsgIsZero() {
		zb0001Len--
		zb0001Mask |= 0x4
	}
	if (*z).Sig.MsgIsZero() {
		zb0001Len--
		zb0001Mask |= 0x8
	}
	// variable map header, size zb0001Len
	o = append(o, 0x80|uint8(zb0001Len))
	if zb0001Len != 0 {
		if (zb0001Mask & 0x1) == 0 { // if not empty
			// string "Response"
			o = append(o, 0xa8, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65)
			// omitempty: check for empty values
			zb0002Len := uint32(1)
			var zb0002Mask uint8 /* 2 bits */
			if (*z).Response.Nonce == "" {
				zb0002Len--
				zb0002Mask |= 0x1
			}
			// variable map header, size zb0002Len
			o = append(o, 0x80|uint8(zb0002Len))
			if (zb0002Mask & 0x1) == 0 { // if not empty
				// string "Nonce"
				o = append(o, 0xa5, 0x4e, 0x6f, 0x6e, 0x63, 0x65)
				o = msgp.AppendString(o, (*z).Response.Nonce)
			}
		}
		if (zb0001Mask & 0x2) == 0 { // if not empty
			// string "Round"
			o = append(o, 0xa5, 0x52, 0x6f, 0x75, 0x6e, 0x64)
			o, err = (*z).Round.MarshalMsg(o)
			if err != nil {
				err = msgp.WrapError(err, "Round")
				return
			}
		}
		if (zb0001Mask & 0x4) == 0 { // if not empty
			// string "Sender"
			o = append(o, 0xa6, 0x53, 0x65, 0x6e, 0x64, 0x65, 0x72)
			o, err = (*z).Sender.MarshalMsg(o)
			if err != nil {
				err = msgp.WrapError(err, "Sender")
				return
			}
		}
		if (zb0001Mask & 0x8) == 0 { // if not empty
			// string "Sig"
			o = append(o, 0xa3, 0x53, 0x69, 0x67)
			o, err = (*z).Sig.MarshalMsg(o)
			if err != nil {
				err = msgp.WrapError(err, "Sig")
				return
			}
		}
	}
	return
}

func (_ *netPrioResponseSigned) CanMarshalMsg(z interface{}) bool {
	_, ok := (z).(*netPrioResponseSigned)
	return ok
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *netPrioResponseSigned) 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--
			var zb0003 int
			var zb0004 bool
			zb0003, zb0004, bts, err = msgp.ReadMapHeaderBytes(bts)
			if _, ok := err.(msgp.TypeError); ok {
				zb0003, zb0004, bts, err = msgp.ReadArrayHeaderBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "struct-from-array", "Response")
					return
				}
				if zb0003 > 0 {
					zb0003--
					(*z).Response.Nonce, bts, err = msgp.ReadStringBytes(bts)
					if err != nil {
						err = msgp.WrapError(err, "struct-from-array", "Response", "struct-from-array", "Nonce")
						return
					}
				}
				if zb0003 > 0 {
					err = msgp.ErrTooManyArrayFields(zb0003)
					if err != nil {
						err = msgp.WrapError(err, "struct-from-array", "Response", "struct-from-array")
						return
					}
				}
			} else {
				if err != nil {
					err = msgp.WrapError(err, "struct-from-array", "Response")
					return
				}
				if zb0004 {
					(*z).Response = netPrioResponse{}
				}
				for zb0003 > 0 {
					zb0003--
					field, bts, err = msgp.ReadMapKeyZC(bts)
					if err != nil {
						err = msgp.WrapError(err, "struct-from-array", "Response")
						return
					}
					switch string(field) {
					case "Nonce":
						(*z).Response.Nonce, bts, err = msgp.ReadStringBytes(bts)
						if err != nil {
							err = msgp.WrapError(err, "struct-from-array", "Response", "Nonce")
							return
						}
					default:
						err = msgp.ErrNoField(string(field))
						if err != nil {
							err = msgp.WrapError(err, "struct-from-array", "Response")
							return
						}
					}
				}
			}
		}
		if zb0001 > 0 {
			zb0001--
			bts, err = (*z).Round.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "Round")
				return
			}
		}
		if zb0001 > 0 {
			zb0001--
			bts, err = (*z).Sender.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "Sender")
				return
			}
		}
		if zb0001 > 0 {
			zb0001--
			bts, err = (*z).Sig.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "Sig")
				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) = netPrioResponseSigned{}
		}
		for zb0001 > 0 {
			zb0001--
			field, bts, err = msgp.ReadMapKeyZC(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
			switch string(field) {
			case "Response":
				var zb0005 int
				var zb0006 bool
				zb0005, zb0006, bts, err = msgp.ReadMapHeaderBytes(bts)
				if _, ok := err.(msgp.TypeError); ok {
					zb0005, zb0006, bts, err = msgp.ReadArrayHeaderBytes(bts)
					if err != nil {
						err = msgp.WrapError(err, "Response")
						return
					}
					if zb0005 > 0 {
						zb0005--
						(*z).Response.Nonce, bts, err = msgp.ReadStringBytes(bts)
						if err != nil {
							err = msgp.WrapError(err, "Response", "struct-from-array", "Nonce")
							return
						}
					}
					if zb0005 > 0 {
						err = msgp.ErrTooManyArrayFields(zb0005)
						if err != nil {
							err = msgp.WrapError(err, "Response", "struct-from-array")
							return
						}
					}
				} else {
					if err != nil {
						err = msgp.WrapError(err, "Response")
						return
					}
					if zb0006 {
						(*z).Response = netPrioResponse{}
					}
					for zb0005 > 0 {
						zb0005--
						field, bts, err = msgp.ReadMapKeyZC(bts)
						if err != nil {
							err = msgp.WrapError(err, "Response")
							return
						}
						switch string(field) {
						case "Nonce":
							(*z).Response.Nonce, bts, err = msgp.ReadStringBytes(bts)
							if err != nil {
								err = msgp.WrapError(err, "Response", "Nonce")
								return
							}
						default:
							err = msgp.ErrNoField(string(field))
							if err != nil {
								err = msgp.WrapError(err, "Response")
								return
							}
						}
					}
				}
			case "Round":
				bts, err = (*z).Round.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "Round")
					return
				}
			case "Sender":
				bts, err = (*z).Sender.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "Sender")
					return
				}
			case "Sig":
				bts, err = (*z).Sig.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "Sig")
					return
				}
			default:
				err = msgp.ErrNoField(string(field))
				if err != nil {
					err = msgp.WrapError(err)
					return
				}
			}
		}
	}
	o = bts
	return
}

func (_ *netPrioResponseSigned) CanUnmarshalMsg(z interface{}) bool {
	_, ok := (z).(*netPrioResponseSigned)
	return ok
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *netPrioResponseSigned) Msgsize() (s int) {
	s = 1 + 9 + 1 + 6 + msgp.StringPrefixSize + len((*z).Response.Nonce) + 6 + (*z).Round.Msgsize() + 7 + (*z).Sender.Msgsize() + 4 + (*z).Sig.Msgsize()
	return
}

// MsgIsZero returns whether this is a zero value
func (z *netPrioResponseSigned) MsgIsZero() bool {
	return ((*z).Response.Nonce == "") && ((*z).Round.MsgIsZero()) && ((*z).Sender.MsgIsZero()) && ((*z).Sig.MsgIsZero())
}