storj.io/minio@v0.0.0-20230509071714-0cbc90f649b1/cmd/metacache-bucket_gen.go (about)

     1  package cmd
     2  
     3  // Code generated by github.com/tinylib/msgp DO NOT EDIT.
     4  
     5  import (
     6  	"github.com/tinylib/msgp/msgp"
     7  )
     8  
     9  // DecodeMsg implements msgp.Decodable
    10  func (z *bucketMetacache) DecodeMsg(dc *msgp.Reader) (err error) {
    11  	var field []byte
    12  	_ = field
    13  	var zb0001 uint32
    14  	zb0001, err = dc.ReadMapHeader()
    15  	if err != nil {
    16  		err = msgp.WrapError(err)
    17  		return
    18  	}
    19  	for zb0001 > 0 {
    20  		zb0001--
    21  		field, err = dc.ReadMapKeyPtr()
    22  		if err != nil {
    23  			err = msgp.WrapError(err)
    24  			return
    25  		}
    26  		switch msgp.UnsafeString(field) {
    27  		case "bucket":
    28  			z.bucket, err = dc.ReadString()
    29  			if err != nil {
    30  				err = msgp.WrapError(err, "bucket")
    31  				return
    32  			}
    33  		case "caches":
    34  			var zb0002 uint32
    35  			zb0002, err = dc.ReadMapHeader()
    36  			if err != nil {
    37  				err = msgp.WrapError(err, "caches")
    38  				return
    39  			}
    40  			if z.caches == nil {
    41  				z.caches = make(map[string]metacache, zb0002)
    42  			} else if len(z.caches) > 0 {
    43  				for key := range z.caches {
    44  					delete(z.caches, key)
    45  				}
    46  			}
    47  			for zb0002 > 0 {
    48  				zb0002--
    49  				var za0001 string
    50  				var za0002 metacache
    51  				za0001, err = dc.ReadString()
    52  				if err != nil {
    53  					err = msgp.WrapError(err, "caches")
    54  					return
    55  				}
    56  				err = za0002.DecodeMsg(dc)
    57  				if err != nil {
    58  					err = msgp.WrapError(err, "caches", za0001)
    59  					return
    60  				}
    61  				z.caches[za0001] = za0002
    62  			}
    63  		default:
    64  			err = dc.Skip()
    65  			if err != nil {
    66  				err = msgp.WrapError(err)
    67  				return
    68  			}
    69  		}
    70  	}
    71  	return
    72  }
    73  
    74  // EncodeMsg implements msgp.Encodable
    75  func (z *bucketMetacache) EncodeMsg(en *msgp.Writer) (err error) {
    76  	// map header, size 2
    77  	// write "bucket"
    78  	err = en.Append(0x82, 0xa6, 0x62, 0x75, 0x63, 0x6b, 0x65, 0x74)
    79  	if err != nil {
    80  		return
    81  	}
    82  	err = en.WriteString(z.bucket)
    83  	if err != nil {
    84  		err = msgp.WrapError(err, "bucket")
    85  		return
    86  	}
    87  	// write "caches"
    88  	err = en.Append(0xa6, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73)
    89  	if err != nil {
    90  		return
    91  	}
    92  	err = en.WriteMapHeader(uint32(len(z.caches)))
    93  	if err != nil {
    94  		err = msgp.WrapError(err, "caches")
    95  		return
    96  	}
    97  	for za0001, za0002 := range z.caches {
    98  		err = en.WriteString(za0001)
    99  		if err != nil {
   100  			err = msgp.WrapError(err, "caches")
   101  			return
   102  		}
   103  		err = za0002.EncodeMsg(en)
   104  		if err != nil {
   105  			err = msgp.WrapError(err, "caches", za0001)
   106  			return
   107  		}
   108  	}
   109  	return
   110  }
   111  
   112  // MarshalMsg implements msgp.Marshaler
   113  func (z *bucketMetacache) MarshalMsg(b []byte) (o []byte, err error) {
   114  	o = msgp.Require(b, z.Msgsize())
   115  	// map header, size 2
   116  	// string "bucket"
   117  	o = append(o, 0x82, 0xa6, 0x62, 0x75, 0x63, 0x6b, 0x65, 0x74)
   118  	o = msgp.AppendString(o, z.bucket)
   119  	// string "caches"
   120  	o = append(o, 0xa6, 0x63, 0x61, 0x63, 0x68, 0x65, 0x73)
   121  	o = msgp.AppendMapHeader(o, uint32(len(z.caches)))
   122  	for za0001, za0002 := range z.caches {
   123  		o = msgp.AppendString(o, za0001)
   124  		o, err = za0002.MarshalMsg(o)
   125  		if err != nil {
   126  			err = msgp.WrapError(err, "caches", za0001)
   127  			return
   128  		}
   129  	}
   130  	return
   131  }
   132  
   133  // UnmarshalMsg implements msgp.Unmarshaler
   134  func (z *bucketMetacache) UnmarshalMsg(bts []byte) (o []byte, err error) {
   135  	var field []byte
   136  	_ = field
   137  	var zb0001 uint32
   138  	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
   139  	if err != nil {
   140  		err = msgp.WrapError(err)
   141  		return
   142  	}
   143  	for zb0001 > 0 {
   144  		zb0001--
   145  		field, bts, err = msgp.ReadMapKeyZC(bts)
   146  		if err != nil {
   147  			err = msgp.WrapError(err)
   148  			return
   149  		}
   150  		switch msgp.UnsafeString(field) {
   151  		case "bucket":
   152  			z.bucket, bts, err = msgp.ReadStringBytes(bts)
   153  			if err != nil {
   154  				err = msgp.WrapError(err, "bucket")
   155  				return
   156  			}
   157  		case "caches":
   158  			var zb0002 uint32
   159  			zb0002, bts, err = msgp.ReadMapHeaderBytes(bts)
   160  			if err != nil {
   161  				err = msgp.WrapError(err, "caches")
   162  				return
   163  			}
   164  			if z.caches == nil {
   165  				z.caches = make(map[string]metacache, zb0002)
   166  			} else if len(z.caches) > 0 {
   167  				for key := range z.caches {
   168  					delete(z.caches, key)
   169  				}
   170  			}
   171  			for zb0002 > 0 {
   172  				var za0001 string
   173  				var za0002 metacache
   174  				zb0002--
   175  				za0001, bts, err = msgp.ReadStringBytes(bts)
   176  				if err != nil {
   177  					err = msgp.WrapError(err, "caches")
   178  					return
   179  				}
   180  				bts, err = za0002.UnmarshalMsg(bts)
   181  				if err != nil {
   182  					err = msgp.WrapError(err, "caches", za0001)
   183  					return
   184  				}
   185  				z.caches[za0001] = za0002
   186  			}
   187  		default:
   188  			bts, err = msgp.Skip(bts)
   189  			if err != nil {
   190  				err = msgp.WrapError(err)
   191  				return
   192  			}
   193  		}
   194  	}
   195  	o = bts
   196  	return
   197  }
   198  
   199  // Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
   200  func (z *bucketMetacache) Msgsize() (s int) {
   201  	s = 1 + 7 + msgp.StringPrefixSize + len(z.bucket) + 7 + msgp.MapHeaderSize
   202  	if z.caches != nil {
   203  		for za0001, za0002 := range z.caches {
   204  			_ = za0002
   205  			s += msgp.StringPrefixSize + len(za0001) + za0002.Msgsize()
   206  		}
   207  	}
   208  	return
   209  }