github.com/vipernet-xyz/tm@v0.34.24/proto/tendermint/store/types.pb.go (about) 1 // Code generated by protoc-gen-gogo. DO NOT EDIT. 2 // source: tendermint/store/types.proto 3 4 package store 5 6 import ( 7 fmt "fmt" 8 proto "github.com/gogo/protobuf/proto" 9 io "io" 10 math "math" 11 math_bits "math/bits" 12 ) 13 14 // Reference imports to suppress errors if they are not otherwise used. 15 var _ = proto.Marshal 16 var _ = fmt.Errorf 17 var _ = math.Inf 18 19 // This is a compile-time assertion to ensure that this generated file 20 // is compatible with the proto package it is being compiled against. 21 // A compilation error at this line likely means your copy of the 22 // proto package needs to be updated. 23 const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package 24 25 type BlockStoreState struct { 26 Base int64 `protobuf:"varint,1,opt,name=base,proto3" json:"base,omitempty"` 27 Height int64 `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"` 28 } 29 30 func (m *BlockStoreState) Reset() { *m = BlockStoreState{} } 31 func (m *BlockStoreState) String() string { return proto.CompactTextString(m) } 32 func (*BlockStoreState) ProtoMessage() {} 33 func (*BlockStoreState) Descriptor() ([]byte, []int) { 34 return fileDescriptor_ff9e53a0a74267f7, []int{0} 35 } 36 func (m *BlockStoreState) XXX_Unmarshal(b []byte) error { 37 return m.Unmarshal(b) 38 } 39 func (m *BlockStoreState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 40 if deterministic { 41 return xxx_messageInfo_BlockStoreState.Marshal(b, m, deterministic) 42 } else { 43 b = b[:cap(b)] 44 n, err := m.MarshalToSizedBuffer(b) 45 if err != nil { 46 return nil, err 47 } 48 return b[:n], nil 49 } 50 } 51 func (m *BlockStoreState) XXX_Merge(src proto.Message) { 52 xxx_messageInfo_BlockStoreState.Merge(m, src) 53 } 54 func (m *BlockStoreState) XXX_Size() int { 55 return m.Size() 56 } 57 func (m *BlockStoreState) XXX_DiscardUnknown() { 58 xxx_messageInfo_BlockStoreState.DiscardUnknown(m) 59 } 60 61 var xxx_messageInfo_BlockStoreState proto.InternalMessageInfo 62 63 func (m *BlockStoreState) GetBase() int64 { 64 if m != nil { 65 return m.Base 66 } 67 return 0 68 } 69 70 func (m *BlockStoreState) GetHeight() int64 { 71 if m != nil { 72 return m.Height 73 } 74 return 0 75 } 76 77 func init() { 78 proto.RegisterType((*BlockStoreState)(nil), "tendermint.store.BlockStoreState") 79 } 80 81 func init() { proto.RegisterFile("tendermint/store/types.proto", fileDescriptor_ff9e53a0a74267f7) } 82 83 var fileDescriptor_ff9e53a0a74267f7 = []byte{ 84 // 165 bytes of a gzipped FileDescriptorProto 85 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x29, 0x49, 0xcd, 0x4b, 86 0x49, 0x2d, 0xca, 0xcd, 0xcc, 0x2b, 0xd1, 0x2f, 0x2e, 0xc9, 0x2f, 0x4a, 0xd5, 0x2f, 0xa9, 0x2c, 87 0x48, 0x2d, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x40, 0xc8, 0xea, 0x81, 0x65, 0x95, 88 0x6c, 0xb9, 0xf8, 0x9d, 0x72, 0xf2, 0x93, 0xb3, 0x83, 0x41, 0xbc, 0xe0, 0x92, 0xc4, 0x92, 0x54, 89 0x21, 0x21, 0x2e, 0x96, 0xa4, 0xc4, 0xe2, 0x54, 0x09, 0x46, 0x05, 0x46, 0x0d, 0xe6, 0x20, 0x30, 90 0x5b, 0x48, 0x8c, 0x8b, 0x2d, 0x23, 0x35, 0x33, 0x3d, 0xa3, 0x44, 0x82, 0x09, 0x2c, 0x0a, 0xe5, 91 0x39, 0x05, 0x9e, 0x78, 0x24, 0xc7, 0x78, 0xe1, 0x91, 0x1c, 0xe3, 0x83, 0x47, 0x72, 0x8c, 0x13, 92 0x1e, 0xcb, 0x31, 0x5c, 0x78, 0x2c, 0xc7, 0x70, 0xe3, 0xb1, 0x1c, 0x43, 0x94, 0x79, 0x7a, 0x66, 93 0x49, 0x46, 0x69, 0x92, 0x5e, 0x72, 0x7e, 0xae, 0x3e, 0x92, 0x9b, 0x90, 0x98, 0x60, 0x27, 0xe9, 94 0xa3, 0xbb, 0x37, 0x89, 0x0d, 0x2c, 0x6e, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0xef, 0xa6, 0x30, 95 0x63, 0xca, 0x00, 0x00, 0x00, 96 } 97 98 func (m *BlockStoreState) Marshal() (dAtA []byte, err error) { 99 size := m.Size() 100 dAtA = make([]byte, size) 101 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 102 if err != nil { 103 return nil, err 104 } 105 return dAtA[:n], nil 106 } 107 108 func (m *BlockStoreState) MarshalTo(dAtA []byte) (int, error) { 109 size := m.Size() 110 return m.MarshalToSizedBuffer(dAtA[:size]) 111 } 112 113 func (m *BlockStoreState) MarshalToSizedBuffer(dAtA []byte) (int, error) { 114 i := len(dAtA) 115 _ = i 116 var l int 117 _ = l 118 if m.Height != 0 { 119 i = encodeVarintTypes(dAtA, i, uint64(m.Height)) 120 i-- 121 dAtA[i] = 0x10 122 } 123 if m.Base != 0 { 124 i = encodeVarintTypes(dAtA, i, uint64(m.Base)) 125 i-- 126 dAtA[i] = 0x8 127 } 128 return len(dAtA) - i, nil 129 } 130 131 func encodeVarintTypes(dAtA []byte, offset int, v uint64) int { 132 offset -= sovTypes(v) 133 base := offset 134 for v >= 1<<7 { 135 dAtA[offset] = uint8(v&0x7f | 0x80) 136 v >>= 7 137 offset++ 138 } 139 dAtA[offset] = uint8(v) 140 return base 141 } 142 func (m *BlockStoreState) Size() (n int) { 143 if m == nil { 144 return 0 145 } 146 var l int 147 _ = l 148 if m.Base != 0 { 149 n += 1 + sovTypes(uint64(m.Base)) 150 } 151 if m.Height != 0 { 152 n += 1 + sovTypes(uint64(m.Height)) 153 } 154 return n 155 } 156 157 func sovTypes(x uint64) (n int) { 158 return (math_bits.Len64(x|1) + 6) / 7 159 } 160 func sozTypes(x uint64) (n int) { 161 return sovTypes(uint64((x << 1) ^ uint64((int64(x) >> 63)))) 162 } 163 func (m *BlockStoreState) Unmarshal(dAtA []byte) error { 164 l := len(dAtA) 165 iNdEx := 0 166 for iNdEx < l { 167 preIndex := iNdEx 168 var wire uint64 169 for shift := uint(0); ; shift += 7 { 170 if shift >= 64 { 171 return ErrIntOverflowTypes 172 } 173 if iNdEx >= l { 174 return io.ErrUnexpectedEOF 175 } 176 b := dAtA[iNdEx] 177 iNdEx++ 178 wire |= uint64(b&0x7F) << shift 179 if b < 0x80 { 180 break 181 } 182 } 183 fieldNum := int32(wire >> 3) 184 wireType := int(wire & 0x7) 185 if wireType == 4 { 186 return fmt.Errorf("proto: BlockStoreState: wiretype end group for non-group") 187 } 188 if fieldNum <= 0 { 189 return fmt.Errorf("proto: BlockStoreState: illegal tag %d (wire type %d)", fieldNum, wire) 190 } 191 switch fieldNum { 192 case 1: 193 if wireType != 0 { 194 return fmt.Errorf("proto: wrong wireType = %d for field Base", wireType) 195 } 196 m.Base = 0 197 for shift := uint(0); ; shift += 7 { 198 if shift >= 64 { 199 return ErrIntOverflowTypes 200 } 201 if iNdEx >= l { 202 return io.ErrUnexpectedEOF 203 } 204 b := dAtA[iNdEx] 205 iNdEx++ 206 m.Base |= int64(b&0x7F) << shift 207 if b < 0x80 { 208 break 209 } 210 } 211 case 2: 212 if wireType != 0 { 213 return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) 214 } 215 m.Height = 0 216 for shift := uint(0); ; shift += 7 { 217 if shift >= 64 { 218 return ErrIntOverflowTypes 219 } 220 if iNdEx >= l { 221 return io.ErrUnexpectedEOF 222 } 223 b := dAtA[iNdEx] 224 iNdEx++ 225 m.Height |= int64(b&0x7F) << shift 226 if b < 0x80 { 227 break 228 } 229 } 230 default: 231 iNdEx = preIndex 232 skippy, err := skipTypes(dAtA[iNdEx:]) 233 if err != nil { 234 return err 235 } 236 if (skippy < 0) || (iNdEx+skippy) < 0 { 237 return ErrInvalidLengthTypes 238 } 239 if (iNdEx + skippy) > l { 240 return io.ErrUnexpectedEOF 241 } 242 iNdEx += skippy 243 } 244 } 245 246 if iNdEx > l { 247 return io.ErrUnexpectedEOF 248 } 249 return nil 250 } 251 func skipTypes(dAtA []byte) (n int, err error) { 252 l := len(dAtA) 253 iNdEx := 0 254 depth := 0 255 for iNdEx < l { 256 var wire uint64 257 for shift := uint(0); ; shift += 7 { 258 if shift >= 64 { 259 return 0, ErrIntOverflowTypes 260 } 261 if iNdEx >= l { 262 return 0, io.ErrUnexpectedEOF 263 } 264 b := dAtA[iNdEx] 265 iNdEx++ 266 wire |= (uint64(b) & 0x7F) << shift 267 if b < 0x80 { 268 break 269 } 270 } 271 wireType := int(wire & 0x7) 272 switch wireType { 273 case 0: 274 for shift := uint(0); ; shift += 7 { 275 if shift >= 64 { 276 return 0, ErrIntOverflowTypes 277 } 278 if iNdEx >= l { 279 return 0, io.ErrUnexpectedEOF 280 } 281 iNdEx++ 282 if dAtA[iNdEx-1] < 0x80 { 283 break 284 } 285 } 286 case 1: 287 iNdEx += 8 288 case 2: 289 var length int 290 for shift := uint(0); ; shift += 7 { 291 if shift >= 64 { 292 return 0, ErrIntOverflowTypes 293 } 294 if iNdEx >= l { 295 return 0, io.ErrUnexpectedEOF 296 } 297 b := dAtA[iNdEx] 298 iNdEx++ 299 length |= (int(b) & 0x7F) << shift 300 if b < 0x80 { 301 break 302 } 303 } 304 if length < 0 { 305 return 0, ErrInvalidLengthTypes 306 } 307 iNdEx += length 308 case 3: 309 depth++ 310 case 4: 311 if depth == 0 { 312 return 0, ErrUnexpectedEndOfGroupTypes 313 } 314 depth-- 315 case 5: 316 iNdEx += 4 317 default: 318 return 0, fmt.Errorf("proto: illegal wireType %d", wireType) 319 } 320 if iNdEx < 0 { 321 return 0, ErrInvalidLengthTypes 322 } 323 if depth == 0 { 324 return iNdEx, nil 325 } 326 } 327 return 0, io.ErrUnexpectedEOF 328 } 329 330 var ( 331 ErrInvalidLengthTypes = fmt.Errorf("proto: negative length found during unmarshaling") 332 ErrIntOverflowTypes = fmt.Errorf("proto: integer overflow") 333 ErrUnexpectedEndOfGroupTypes = fmt.Errorf("proto: unexpected end of group") 334 )