storage_market_cbor_gen.go

// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT.

package boostly

import (
	"fmt"
	"io"
	"math"
	"sort"

	abi "github.com/filecoin-project/go-state-types/abi"
	cid "github.com/ipfs/go-cid"
	cbg "github.com/whyrusleeping/cbor-gen"
	xerrors "golang.org/x/xerrors"
)

var _ = xerrors.Errorf
var _ = cid.Undef
var _ = math.E
var _ = sort.Sort

func (t *StorageAsk) MarshalCBOR(w io.Writer) error {
	if t == nil {
		_, err := w.Write(cbg.CborNull)
		return err
	}

	cw := cbg.NewCborWriter(w)

	if _, err := cw.Write([]byte{165}); err != nil {
		return err
	}

	// t.Miner (address.Address) (struct)
	if len("Miner") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"Miner\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Miner"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("Miner")); err != nil {
		return err
	}

	if err := t.Miner.MarshalCBOR(cw); err != nil {
		return err
	}

	// t.Price (big.Int) (struct)
	if len("Price") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"Price\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Price"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("Price")); err != nil {
		return err
	}

	if err := t.Price.MarshalCBOR(cw); err != nil {
		return err
	}

	// t.MaxPieceSize (abi.PaddedPieceSize) (uint64)
	if len("MaxPieceSize") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"MaxPieceSize\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("MaxPieceSize"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("MaxPieceSize")); err != nil {
		return err
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.MaxPieceSize)); err != nil {
		return err
	}

	// t.MinPieceSize (abi.PaddedPieceSize) (uint64)
	if len("MinPieceSize") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"MinPieceSize\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("MinPieceSize"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("MinPieceSize")); err != nil {
		return err
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.MinPieceSize)); err != nil {
		return err
	}

	// t.VerifiedPrice (big.Int) (struct)
	if len("VerifiedPrice") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"VerifiedPrice\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("VerifiedPrice"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("VerifiedPrice")); err != nil {
		return err
	}

	if err := t.VerifiedPrice.MarshalCBOR(cw); err != nil {
		return err
	}
	return nil
}

func (t *StorageAsk) UnmarshalCBOR(r io.Reader) (err error) {
	*t = StorageAsk{}

	cr := cbg.NewCborReader(r)

	maj, extra, err := cr.ReadHeader()
	if err != nil {
		return err
	}
	defer func() {
		if err == io.EOF {
			err = io.ErrUnexpectedEOF
		}
	}()

	if maj != cbg.MajMap {
		return fmt.Errorf("cbor input should be of type map")
	}

	if extra > cbg.MaxLength {
		return fmt.Errorf("StorageAsk: map struct too large (%d)", extra)
	}

	var name string
	n := extra

	for i := uint64(0); i < n; i++ {

		{
			sval, err := cbg.ReadString(cr)
			if err != nil {
				return err
			}

			name = string(sval)
		}

		switch name {
		// t.Miner (address.Address) (struct)
		case "Miner":

			{

				if err := t.Miner.UnmarshalCBOR(cr); err != nil {
					return xerrors.Errorf("unmarshaling t.Miner: %w", err)
				}

			}
			// t.Price (big.Int) (struct)
		case "Price":

			{

				if err := t.Price.UnmarshalCBOR(cr); err != nil {
					return xerrors.Errorf("unmarshaling t.Price: %w", err)
				}

			}
			// t.MaxPieceSize (abi.PaddedPieceSize) (uint64)
		case "MaxPieceSize":

			{

				maj, extra, err = cr.ReadHeader()
				if err != nil {
					return err
				}
				if maj != cbg.MajUnsignedInt {
					return fmt.Errorf("wrong type for uint64 field")
				}
				t.MaxPieceSize = abi.PaddedPieceSize(extra)

			}
			// t.MinPieceSize (abi.PaddedPieceSize) (uint64)
		case "MinPieceSize":

			{

				maj, extra, err = cr.ReadHeader()
				if err != nil {
					return err
				}
				if maj != cbg.MajUnsignedInt {
					return fmt.Errorf("wrong type for uint64 field")
				}
				t.MinPieceSize = abi.PaddedPieceSize(extra)

			}
			// t.VerifiedPrice (big.Int) (struct)
		case "VerifiedPrice":

			{

				if err := t.VerifiedPrice.UnmarshalCBOR(cr); err != nil {
					return xerrors.Errorf("unmarshaling t.VerifiedPrice: %w", err)
				}

			}

		default:
			// Field doesn't exist on this type, so ignore it
			cbg.ScanForLinks(r, func(cid.Cid) {})
		}
	}

	return nil
}
func (t *DealProposal) MarshalCBOR(w io.Writer) error {
	if t == nil {
		_, err := w.Write(cbg.CborNull)
		return err
	}

	cw := cbg.NewCborWriter(w)

	if _, err := cw.Write([]byte{167}); err != nil {
		return err
	}

	// t.DealUUID (uuid.UUID) (array)
	if len("DealUUID") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"DealUUID\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("DealUUID"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("DealUUID")); err != nil {
		return err
	}

	if len(t.DealUUID) > cbg.ByteArrayMaxLen {
		return xerrors.Errorf("Byte array in field t.DealUUID was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.DealUUID))); err != nil {
		return err
	}

	if _, err := cw.Write(t.DealUUID[:]); err != nil {
		return err
	}

	// t.Transfer (boostly.Transfer) (struct)
	if len("Transfer") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"Transfer\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Transfer"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("Transfer")); err != nil {
		return err
	}

	if err := t.Transfer.MarshalCBOR(cw); err != nil {
		return err
	}

	// t.IsOffline (bool) (bool)
	if len("IsOffline") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"IsOffline\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("IsOffline"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("IsOffline")); err != nil {
		return err
	}

	if err := cbg.WriteBool(w, t.IsOffline); err != nil {
		return err
	}

	// t.DealDataRoot (cid.Cid) (struct)
	if len("DealDataRoot") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"DealDataRoot\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("DealDataRoot"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("DealDataRoot")); err != nil {
		return err
	}

	if err := cbg.WriteCid(cw, t.DealDataRoot); err != nil {
		return xerrors.Errorf("failed to write cid field t.DealDataRoot: %w", err)
	}

	// t.SkipIPNIAnnounce (bool) (bool)
	if len("SkipIPNIAnnounce") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"SkipIPNIAnnounce\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("SkipIPNIAnnounce"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("SkipIPNIAnnounce")); err != nil {
		return err
	}

	if err := cbg.WriteBool(w, t.SkipIPNIAnnounce); err != nil {
		return err
	}

	// t.ClientDealProposal (market.ClientDealProposal) (struct)
	if len("ClientDealProposal") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"ClientDealProposal\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ClientDealProposal"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("ClientDealProposal")); err != nil {
		return err
	}

	if err := t.ClientDealProposal.MarshalCBOR(cw); err != nil {
		return err
	}

	// t.RemoveUnsealedCopy (bool) (bool)
	if len("RemoveUnsealedCopy") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"RemoveUnsealedCopy\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("RemoveUnsealedCopy"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("RemoveUnsealedCopy")); err != nil {
		return err
	}

	if err := cbg.WriteBool(w, t.RemoveUnsealedCopy); err != nil {
		return err
	}
	return nil
}

func (t *DealProposal) UnmarshalCBOR(r io.Reader) (err error) {
	*t = DealProposal{}

	cr := cbg.NewCborReader(r)

	maj, extra, err := cr.ReadHeader()
	if err != nil {
		return err
	}
	defer func() {
		if err == io.EOF {
			err = io.ErrUnexpectedEOF
		}
	}()

	if maj != cbg.MajMap {
		return fmt.Errorf("cbor input should be of type map")
	}

	if extra > cbg.MaxLength {
		return fmt.Errorf("DealProposal: map struct too large (%d)", extra)
	}

	var name string
	n := extra

	for i := uint64(0); i < n; i++ {

		{
			sval, err := cbg.ReadString(cr)
			if err != nil {
				return err
			}

			name = string(sval)
		}

		switch name {
		// t.DealUUID (uuid.UUID) (array)
		case "DealUUID":

			maj, extra, err = cr.ReadHeader()
			if err != nil {
				return err
			}

			if extra > cbg.ByteArrayMaxLen {
				return fmt.Errorf("t.DealUUID: byte array too large (%d)", extra)
			}
			if maj != cbg.MajByteString {
				return fmt.Errorf("expected byte array")
			}

			if extra != 16 {
				return fmt.Errorf("expected array to have 16 elements")
			}

			t.DealUUID = [16]uint8{}

			if _, err := io.ReadFull(cr, t.DealUUID[:]); err != nil {
				return err
			}
			// t.Transfer (boostly.Transfer) (struct)
		case "Transfer":

			{

				if err := t.Transfer.UnmarshalCBOR(cr); err != nil {
					return xerrors.Errorf("unmarshaling t.Transfer: %w", err)
				}

			}
			// t.IsOffline (bool) (bool)
		case "IsOffline":

			maj, extra, err = cr.ReadHeader()
			if err != nil {
				return err
			}
			if maj != cbg.MajOther {
				return fmt.Errorf("booleans must be major type 7")
			}
			switch extra {
			case 20:
				t.IsOffline = false
			case 21:
				t.IsOffline = true
			default:
				return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
			}
			// t.DealDataRoot (cid.Cid) (struct)
		case "DealDataRoot":

			{

				c, err := cbg.ReadCid(cr)
				if err != nil {
					return xerrors.Errorf("failed to read cid field t.DealDataRoot: %w", err)
				}

				t.DealDataRoot = c

			}
			// t.SkipIPNIAnnounce (bool) (bool)
		case "SkipIPNIAnnounce":

			maj, extra, err = cr.ReadHeader()
			if err != nil {
				return err
			}
			if maj != cbg.MajOther {
				return fmt.Errorf("booleans must be major type 7")
			}
			switch extra {
			case 20:
				t.SkipIPNIAnnounce = false
			case 21:
				t.SkipIPNIAnnounce = true
			default:
				return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
			}
			// t.ClientDealProposal (market.ClientDealProposal) (struct)
		case "ClientDealProposal":

			{

				if err := t.ClientDealProposal.UnmarshalCBOR(cr); err != nil {
					return xerrors.Errorf("unmarshaling t.ClientDealProposal: %w", err)
				}

			}
			// t.RemoveUnsealedCopy (bool) (bool)
		case "RemoveUnsealedCopy":

			maj, extra, err = cr.ReadHeader()
			if err != nil {
				return err
			}
			if maj != cbg.MajOther {
				return fmt.Errorf("booleans must be major type 7")
			}
			switch extra {
			case 20:
				t.RemoveUnsealedCopy = false
			case 21:
				t.RemoveUnsealedCopy = true
			default:
				return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
			}

		default:
			// Field doesn't exist on this type, so ignore it
			cbg.ScanForLinks(r, func(cid.Cid) {})
		}
	}

	return nil
}
func (t *Transfer) MarshalCBOR(w io.Writer) error {
	if t == nil {
		_, err := w.Write(cbg.CborNull)
		return err
	}

	cw := cbg.NewCborWriter(w)

	if _, err := cw.Write([]byte{164}); err != nil {
		return err
	}

	// t.Size (uint64) (uint64)
	if len("Size") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"Size\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Size"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("Size")); err != nil {
		return err
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Size)); err != nil {
		return err
	}

	// t.Type (string) (string)
	if len("Type") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"Type\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Type"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("Type")); err != nil {
		return err
	}

	if len(t.Type) > cbg.MaxLength {
		return xerrors.Errorf("Value in field t.Type was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Type))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string(t.Type)); err != nil {
		return err
	}

	// t.Params ([]uint8) (slice)
	if len("Params") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"Params\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Params"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("Params")); err != nil {
		return err
	}

	if len(t.Params) > cbg.ByteArrayMaxLen {
		return xerrors.Errorf("Byte array in field t.Params was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajByteString, uint64(len(t.Params))); err != nil {
		return err
	}

	if _, err := cw.Write(t.Params[:]); err != nil {
		return err
	}

	// t.ClientID (string) (string)
	if len("ClientID") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"ClientID\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ClientID"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("ClientID")); err != nil {
		return err
	}

	if len(t.ClientID) > cbg.MaxLength {
		return xerrors.Errorf("Value in field t.ClientID was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.ClientID))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string(t.ClientID)); err != nil {
		return err
	}
	return nil
}

func (t *Transfer) UnmarshalCBOR(r io.Reader) (err error) {
	*t = Transfer{}

	cr := cbg.NewCborReader(r)

	maj, extra, err := cr.ReadHeader()
	if err != nil {
		return err
	}
	defer func() {
		if err == io.EOF {
			err = io.ErrUnexpectedEOF
		}
	}()

	if maj != cbg.MajMap {
		return fmt.Errorf("cbor input should be of type map")
	}

	if extra > cbg.MaxLength {
		return fmt.Errorf("Transfer: map struct too large (%d)", extra)
	}

	var name string
	n := extra

	for i := uint64(0); i < n; i++ {

		{
			sval, err := cbg.ReadString(cr)
			if err != nil {
				return err
			}

			name = string(sval)
		}

		switch name {
		// t.Size (uint64) (uint64)
		case "Size":

			{

				maj, extra, err = cr.ReadHeader()
				if err != nil {
					return err
				}
				if maj != cbg.MajUnsignedInt {
					return fmt.Errorf("wrong type for uint64 field")
				}
				t.Size = uint64(extra)

			}
			// t.Type (string) (string)
		case "Type":

			{
				sval, err := cbg.ReadString(cr)
				if err != nil {
					return err
				}

				t.Type = string(sval)
			}
			// t.Params ([]uint8) (slice)
		case "Params":

			maj, extra, err = cr.ReadHeader()
			if err != nil {
				return err
			}

			if extra > cbg.ByteArrayMaxLen {
				return fmt.Errorf("t.Params: byte array too large (%d)", extra)
			}
			if maj != cbg.MajByteString {
				return fmt.Errorf("expected byte array")
			}

			if extra > 0 {
				t.Params = make([]uint8, extra)
			}

			if _, err := io.ReadFull(cr, t.Params[:]); err != nil {
				return err
			}
			// t.ClientID (string) (string)
		case "ClientID":

			{
				sval, err := cbg.ReadString(cr)
				if err != nil {
					return err
				}

				t.ClientID = string(sval)
			}

		default:
			// Field doesn't exist on this type, so ignore it
			cbg.ScanForLinks(r, func(cid.Cid) {})
		}
	}

	return nil
}
func (t *DealProposalResponse) MarshalCBOR(w io.Writer) error {
	if t == nil {
		_, err := w.Write(cbg.CborNull)
		return err
	}

	cw := cbg.NewCborWriter(w)

	if _, err := cw.Write([]byte{162}); err != nil {
		return err
	}

	// t.Message (string) (string)
	if len("Message") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"Message\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Message"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("Message")); err != nil {
		return err
	}

	if len(t.Message) > cbg.MaxLength {
		return xerrors.Errorf("Value in field t.Message was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Message))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string(t.Message)); err != nil {
		return err
	}

	// t.Accepted (bool) (bool)
	if len("Accepted") > cbg.MaxLength {
		return xerrors.Errorf("Value in field \"Accepted\" was too long")
	}

	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("Accepted"))); err != nil {
		return err
	}
	if _, err := io.WriteString(w, string("Accepted")); err != nil {
		return err
	}

	if err := cbg.WriteBool(w, t.Accepted); err != nil {
		return err
	}
	return nil
}

func (t *DealProposalResponse) UnmarshalCBOR(r io.Reader) (err error) {
	*t = DealProposalResponse{}

	cr := cbg.NewCborReader(r)

	maj, extra, err := cr.ReadHeader()
	if err != nil {
		return err
	}
	defer func() {
		if err == io.EOF {
			err = io.ErrUnexpectedEOF
		}
	}()

	if maj != cbg.MajMap {
		return fmt.Errorf("cbor input should be of type map")
	}

	if extra > cbg.MaxLength {
		return fmt.Errorf("DealProposalResponse: map struct too large (%d)", extra)
	}

	var name string
	n := extra

	for i := uint64(0); i < n; i++ {

		{
			sval, err := cbg.ReadString(cr)
			if err != nil {
				return err
			}

			name = string(sval)
		}

		switch name {
		// t.Message (string) (string)
		case "Message":

			{
				sval, err := cbg.ReadString(cr)
				if err != nil {
					return err
				}

				t.Message = string(sval)
			}
			// t.Accepted (bool) (bool)
		case "Accepted":

			maj, extra, err = cr.ReadHeader()
			if err != nil {
				return err
			}
			if maj != cbg.MajOther {
				return fmt.Errorf("booleans must be major type 7")
			}
			switch extra {
			case 20:
				t.Accepted = false
			case 21:
				t.Accepted = true
			default:
				return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
			}

		default:
			// Field doesn't exist on this type, so ignore it
			cbg.ScanForLinks(r, func(cid.Cid) {})
		}
	}

	return nil
}