You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

771 lines
18 KiB

  1. // Code generated by protoc-gen-gogo. DO NOT EDIT.
  2. // source: libs/common/types.proto
  3. //nolint
  4. package common
  5. import proto "github.com/gogo/protobuf/proto"
  6. import golang_proto "github.com/golang/protobuf/proto"
  7. import fmt "fmt"
  8. import math "math"
  9. import _ "github.com/gogo/protobuf/gogoproto"
  10. import bytes "bytes"
  11. import io "io"
  12. // Reference imports to suppress errors if they are not otherwise used.
  13. var _ = proto.Marshal
  14. var _ = golang_proto.Marshal
  15. var _ = fmt.Errorf
  16. var _ = math.Inf
  17. // This is a compile-time assertion to ensure that this generated file
  18. // is compatible with the proto package it is being compiled against.
  19. // A compilation error at this line likely means your copy of the
  20. // proto package needs to be updated.
  21. const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
  22. // Define these here for compatibility but use tmlibs/common.KVPair.
  23. type KVPair struct {
  24. Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
  25. Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
  26. XXX_NoUnkeyedLiteral struct{} `json:"-"`
  27. XXX_unrecognized []byte `json:"-"`
  28. XXX_sizecache int32 `json:"-"`
  29. }
  30. func (m *KVPair) Reset() { *m = KVPair{} }
  31. func (m *KVPair) String() string { return proto.CompactTextString(m) }
  32. func (*KVPair) ProtoMessage() {}
  33. func (*KVPair) Descriptor() ([]byte, []int) {
  34. return fileDescriptor_types_611b4364a8604338, []int{0}
  35. }
  36. func (m *KVPair) XXX_Unmarshal(b []byte) error {
  37. return m.Unmarshal(b)
  38. }
  39. func (m *KVPair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  40. if deterministic {
  41. return xxx_messageInfo_KVPair.Marshal(b, m, deterministic)
  42. } else {
  43. b = b[:cap(b)]
  44. n, err := m.MarshalTo(b)
  45. if err != nil {
  46. return nil, err
  47. }
  48. return b[:n], nil
  49. }
  50. }
  51. func (dst *KVPair) XXX_Merge(src proto.Message) {
  52. xxx_messageInfo_KVPair.Merge(dst, src)
  53. }
  54. func (m *KVPair) XXX_Size() int {
  55. return m.Size()
  56. }
  57. func (m *KVPair) XXX_DiscardUnknown() {
  58. xxx_messageInfo_KVPair.DiscardUnknown(m)
  59. }
  60. var xxx_messageInfo_KVPair proto.InternalMessageInfo
  61. func (m *KVPair) GetKey() []byte {
  62. if m != nil {
  63. return m.Key
  64. }
  65. return nil
  66. }
  67. func (m *KVPair) GetValue() []byte {
  68. if m != nil {
  69. return m.Value
  70. }
  71. return nil
  72. }
  73. // Define these here for compatibility but use tmlibs/common.KI64Pair.
  74. type KI64Pair struct {
  75. Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
  76. Value int64 `protobuf:"varint,2,opt,name=value,proto3" json:"value,omitempty"`
  77. XXX_NoUnkeyedLiteral struct{} `json:"-"`
  78. XXX_unrecognized []byte `json:"-"`
  79. XXX_sizecache int32 `json:"-"`
  80. }
  81. func (m *KI64Pair) Reset() { *m = KI64Pair{} }
  82. func (m *KI64Pair) String() string { return proto.CompactTextString(m) }
  83. func (*KI64Pair) ProtoMessage() {}
  84. func (*KI64Pair) Descriptor() ([]byte, []int) {
  85. return fileDescriptor_types_611b4364a8604338, []int{1}
  86. }
  87. func (m *KI64Pair) XXX_Unmarshal(b []byte) error {
  88. return m.Unmarshal(b)
  89. }
  90. func (m *KI64Pair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  91. if deterministic {
  92. return xxx_messageInfo_KI64Pair.Marshal(b, m, deterministic)
  93. } else {
  94. b = b[:cap(b)]
  95. n, err := m.MarshalTo(b)
  96. if err != nil {
  97. return nil, err
  98. }
  99. return b[:n], nil
  100. }
  101. }
  102. func (dst *KI64Pair) XXX_Merge(src proto.Message) {
  103. xxx_messageInfo_KI64Pair.Merge(dst, src)
  104. }
  105. func (m *KI64Pair) XXX_Size() int {
  106. return m.Size()
  107. }
  108. func (m *KI64Pair) XXX_DiscardUnknown() {
  109. xxx_messageInfo_KI64Pair.DiscardUnknown(m)
  110. }
  111. var xxx_messageInfo_KI64Pair proto.InternalMessageInfo
  112. func (m *KI64Pair) GetKey() []byte {
  113. if m != nil {
  114. return m.Key
  115. }
  116. return nil
  117. }
  118. func (m *KI64Pair) GetValue() int64 {
  119. if m != nil {
  120. return m.Value
  121. }
  122. return 0
  123. }
  124. func init() {
  125. proto.RegisterType((*KVPair)(nil), "common.KVPair")
  126. golang_proto.RegisterType((*KVPair)(nil), "common.KVPair")
  127. proto.RegisterType((*KI64Pair)(nil), "common.KI64Pair")
  128. golang_proto.RegisterType((*KI64Pair)(nil), "common.KI64Pair")
  129. }
  130. func (this *KVPair) Equal(that interface{}) bool {
  131. if that == nil {
  132. return this == nil
  133. }
  134. that1, ok := that.(*KVPair)
  135. if !ok {
  136. that2, ok := that.(KVPair)
  137. if ok {
  138. that1 = &that2
  139. } else {
  140. return false
  141. }
  142. }
  143. if that1 == nil {
  144. return this == nil
  145. } else if this == nil {
  146. return false
  147. }
  148. if !bytes.Equal(this.Key, that1.Key) {
  149. return false
  150. }
  151. if !bytes.Equal(this.Value, that1.Value) {
  152. return false
  153. }
  154. if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
  155. return false
  156. }
  157. return true
  158. }
  159. func (this *KI64Pair) Equal(that interface{}) bool {
  160. if that == nil {
  161. return this == nil
  162. }
  163. that1, ok := that.(*KI64Pair)
  164. if !ok {
  165. that2, ok := that.(KI64Pair)
  166. if ok {
  167. that1 = &that2
  168. } else {
  169. return false
  170. }
  171. }
  172. if that1 == nil {
  173. return this == nil
  174. } else if this == nil {
  175. return false
  176. }
  177. if !bytes.Equal(this.Key, that1.Key) {
  178. return false
  179. }
  180. if this.Value != that1.Value {
  181. return false
  182. }
  183. if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
  184. return false
  185. }
  186. return true
  187. }
  188. func (m *KVPair) Marshal() (dAtA []byte, err error) {
  189. size := m.Size()
  190. dAtA = make([]byte, size)
  191. n, err := m.MarshalTo(dAtA)
  192. if err != nil {
  193. return nil, err
  194. }
  195. return dAtA[:n], nil
  196. }
  197. func (m *KVPair) MarshalTo(dAtA []byte) (int, error) {
  198. var i int
  199. _ = i
  200. var l int
  201. _ = l
  202. if len(m.Key) > 0 {
  203. dAtA[i] = 0xa
  204. i++
  205. i = encodeVarintTypes(dAtA, i, uint64(len(m.Key)))
  206. i += copy(dAtA[i:], m.Key)
  207. }
  208. if len(m.Value) > 0 {
  209. dAtA[i] = 0x12
  210. i++
  211. i = encodeVarintTypes(dAtA, i, uint64(len(m.Value)))
  212. i += copy(dAtA[i:], m.Value)
  213. }
  214. if m.XXX_unrecognized != nil {
  215. i += copy(dAtA[i:], m.XXX_unrecognized)
  216. }
  217. return i, nil
  218. }
  219. func (m *KI64Pair) Marshal() (dAtA []byte, err error) {
  220. size := m.Size()
  221. dAtA = make([]byte, size)
  222. n, err := m.MarshalTo(dAtA)
  223. if err != nil {
  224. return nil, err
  225. }
  226. return dAtA[:n], nil
  227. }
  228. func (m *KI64Pair) MarshalTo(dAtA []byte) (int, error) {
  229. var i int
  230. _ = i
  231. var l int
  232. _ = l
  233. if len(m.Key) > 0 {
  234. dAtA[i] = 0xa
  235. i++
  236. i = encodeVarintTypes(dAtA, i, uint64(len(m.Key)))
  237. i += copy(dAtA[i:], m.Key)
  238. }
  239. if m.Value != 0 {
  240. dAtA[i] = 0x10
  241. i++
  242. i = encodeVarintTypes(dAtA, i, uint64(m.Value))
  243. }
  244. if m.XXX_unrecognized != nil {
  245. i += copy(dAtA[i:], m.XXX_unrecognized)
  246. }
  247. return i, nil
  248. }
  249. func encodeVarintTypes(dAtA []byte, offset int, v uint64) int {
  250. for v >= 1<<7 {
  251. dAtA[offset] = uint8(v&0x7f | 0x80)
  252. v >>= 7
  253. offset++
  254. }
  255. dAtA[offset] = uint8(v)
  256. return offset + 1
  257. }
  258. func NewPopulatedKVPair(r randyTypes, easy bool) *KVPair {
  259. this := &KVPair{}
  260. v1 := r.Intn(100)
  261. this.Key = make([]byte, v1)
  262. for i := 0; i < v1; i++ {
  263. this.Key[i] = byte(r.Intn(256))
  264. }
  265. v2 := r.Intn(100)
  266. this.Value = make([]byte, v2)
  267. for i := 0; i < v2; i++ {
  268. this.Value[i] = byte(r.Intn(256))
  269. }
  270. if !easy && r.Intn(10) != 0 {
  271. this.XXX_unrecognized = randUnrecognizedTypes(r, 3)
  272. }
  273. return this
  274. }
  275. func NewPopulatedKI64Pair(r randyTypes, easy bool) *KI64Pair {
  276. this := &KI64Pair{}
  277. v3 := r.Intn(100)
  278. this.Key = make([]byte, v3)
  279. for i := 0; i < v3; i++ {
  280. this.Key[i] = byte(r.Intn(256))
  281. }
  282. this.Value = int64(r.Int63())
  283. if r.Intn(2) == 0 {
  284. this.Value *= -1
  285. }
  286. if !easy && r.Intn(10) != 0 {
  287. this.XXX_unrecognized = randUnrecognizedTypes(r, 3)
  288. }
  289. return this
  290. }
  291. type randyTypes interface {
  292. Float32() float32
  293. Float64() float64
  294. Int63() int64
  295. Int31() int32
  296. Uint32() uint32
  297. Intn(n int) int
  298. }
  299. func randUTF8RuneTypes(r randyTypes) rune {
  300. ru := r.Intn(62)
  301. if ru < 10 {
  302. return rune(ru + 48)
  303. } else if ru < 36 {
  304. return rune(ru + 55)
  305. }
  306. return rune(ru + 61)
  307. }
  308. func randStringTypes(r randyTypes) string {
  309. v4 := r.Intn(100)
  310. tmps := make([]rune, v4)
  311. for i := 0; i < v4; i++ {
  312. tmps[i] = randUTF8RuneTypes(r)
  313. }
  314. return string(tmps)
  315. }
  316. func randUnrecognizedTypes(r randyTypes, maxFieldNumber int) (dAtA []byte) {
  317. l := r.Intn(5)
  318. for i := 0; i < l; i++ {
  319. wire := r.Intn(4)
  320. if wire == 3 {
  321. wire = 5
  322. }
  323. fieldNumber := maxFieldNumber + r.Intn(100)
  324. dAtA = randFieldTypes(dAtA, r, fieldNumber, wire)
  325. }
  326. return dAtA
  327. }
  328. func randFieldTypes(dAtA []byte, r randyTypes, fieldNumber int, wire int) []byte {
  329. key := uint32(fieldNumber)<<3 | uint32(wire)
  330. switch wire {
  331. case 0:
  332. dAtA = encodeVarintPopulateTypes(dAtA, uint64(key))
  333. v5 := r.Int63()
  334. if r.Intn(2) == 0 {
  335. v5 *= -1
  336. }
  337. dAtA = encodeVarintPopulateTypes(dAtA, uint64(v5))
  338. case 1:
  339. dAtA = encodeVarintPopulateTypes(dAtA, uint64(key))
  340. dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
  341. case 2:
  342. dAtA = encodeVarintPopulateTypes(dAtA, uint64(key))
  343. ll := r.Intn(100)
  344. dAtA = encodeVarintPopulateTypes(dAtA, uint64(ll))
  345. for j := 0; j < ll; j++ {
  346. dAtA = append(dAtA, byte(r.Intn(256)))
  347. }
  348. default:
  349. dAtA = encodeVarintPopulateTypes(dAtA, uint64(key))
  350. dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
  351. }
  352. return dAtA
  353. }
  354. func encodeVarintPopulateTypes(dAtA []byte, v uint64) []byte {
  355. for v >= 1<<7 {
  356. dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
  357. v >>= 7
  358. }
  359. dAtA = append(dAtA, uint8(v))
  360. return dAtA
  361. }
  362. func (m *KVPair) Size() (n int) {
  363. var l int
  364. _ = l
  365. l = len(m.Key)
  366. if l > 0 {
  367. n += 1 + l + sovTypes(uint64(l))
  368. }
  369. l = len(m.Value)
  370. if l > 0 {
  371. n += 1 + l + sovTypes(uint64(l))
  372. }
  373. if m.XXX_unrecognized != nil {
  374. n += len(m.XXX_unrecognized)
  375. }
  376. return n
  377. }
  378. func (m *KI64Pair) Size() (n int) {
  379. var l int
  380. _ = l
  381. l = len(m.Key)
  382. if l > 0 {
  383. n += 1 + l + sovTypes(uint64(l))
  384. }
  385. if m.Value != 0 {
  386. n += 1 + sovTypes(uint64(m.Value))
  387. }
  388. if m.XXX_unrecognized != nil {
  389. n += len(m.XXX_unrecognized)
  390. }
  391. return n
  392. }
  393. func sovTypes(x uint64) (n int) {
  394. for {
  395. n++
  396. x >>= 7
  397. if x == 0 {
  398. break
  399. }
  400. }
  401. return n
  402. }
  403. func sozTypes(x uint64) (n int) {
  404. return sovTypes(uint64((x << 1) ^ uint64((int64(x) >> 63))))
  405. }
  406. func (m *KVPair) Unmarshal(dAtA []byte) error {
  407. l := len(dAtA)
  408. iNdEx := 0
  409. for iNdEx < l {
  410. preIndex := iNdEx
  411. var wire uint64
  412. for shift := uint(0); ; shift += 7 {
  413. if shift >= 64 {
  414. return ErrIntOverflowTypes
  415. }
  416. if iNdEx >= l {
  417. return io.ErrUnexpectedEOF
  418. }
  419. b := dAtA[iNdEx]
  420. iNdEx++
  421. wire |= (uint64(b) & 0x7F) << shift
  422. if b < 0x80 {
  423. break
  424. }
  425. }
  426. fieldNum := int32(wire >> 3)
  427. wireType := int(wire & 0x7)
  428. if wireType == 4 {
  429. return fmt.Errorf("proto: KVPair: wiretype end group for non-group")
  430. }
  431. if fieldNum <= 0 {
  432. return fmt.Errorf("proto: KVPair: illegal tag %d (wire type %d)", fieldNum, wire)
  433. }
  434. switch fieldNum {
  435. case 1:
  436. if wireType != 2 {
  437. return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
  438. }
  439. var byteLen int
  440. for shift := uint(0); ; shift += 7 {
  441. if shift >= 64 {
  442. return ErrIntOverflowTypes
  443. }
  444. if iNdEx >= l {
  445. return io.ErrUnexpectedEOF
  446. }
  447. b := dAtA[iNdEx]
  448. iNdEx++
  449. byteLen |= (int(b) & 0x7F) << shift
  450. if b < 0x80 {
  451. break
  452. }
  453. }
  454. if byteLen < 0 {
  455. return ErrInvalidLengthTypes
  456. }
  457. postIndex := iNdEx + byteLen
  458. if postIndex > l {
  459. return io.ErrUnexpectedEOF
  460. }
  461. m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
  462. if m.Key == nil {
  463. m.Key = []byte{}
  464. }
  465. iNdEx = postIndex
  466. case 2:
  467. if wireType != 2 {
  468. return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
  469. }
  470. var byteLen int
  471. for shift := uint(0); ; shift += 7 {
  472. if shift >= 64 {
  473. return ErrIntOverflowTypes
  474. }
  475. if iNdEx >= l {
  476. return io.ErrUnexpectedEOF
  477. }
  478. b := dAtA[iNdEx]
  479. iNdEx++
  480. byteLen |= (int(b) & 0x7F) << shift
  481. if b < 0x80 {
  482. break
  483. }
  484. }
  485. if byteLen < 0 {
  486. return ErrInvalidLengthTypes
  487. }
  488. postIndex := iNdEx + byteLen
  489. if postIndex > l {
  490. return io.ErrUnexpectedEOF
  491. }
  492. m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...)
  493. if m.Value == nil {
  494. m.Value = []byte{}
  495. }
  496. iNdEx = postIndex
  497. default:
  498. iNdEx = preIndex
  499. skippy, err := skipTypes(dAtA[iNdEx:])
  500. if err != nil {
  501. return err
  502. }
  503. if skippy < 0 {
  504. return ErrInvalidLengthTypes
  505. }
  506. if (iNdEx + skippy) > l {
  507. return io.ErrUnexpectedEOF
  508. }
  509. m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  510. iNdEx += skippy
  511. }
  512. }
  513. if iNdEx > l {
  514. return io.ErrUnexpectedEOF
  515. }
  516. return nil
  517. }
  518. func (m *KI64Pair) Unmarshal(dAtA []byte) error {
  519. l := len(dAtA)
  520. iNdEx := 0
  521. for iNdEx < l {
  522. preIndex := iNdEx
  523. var wire uint64
  524. for shift := uint(0); ; shift += 7 {
  525. if shift >= 64 {
  526. return ErrIntOverflowTypes
  527. }
  528. if iNdEx >= l {
  529. return io.ErrUnexpectedEOF
  530. }
  531. b := dAtA[iNdEx]
  532. iNdEx++
  533. wire |= (uint64(b) & 0x7F) << shift
  534. if b < 0x80 {
  535. break
  536. }
  537. }
  538. fieldNum := int32(wire >> 3)
  539. wireType := int(wire & 0x7)
  540. if wireType == 4 {
  541. return fmt.Errorf("proto: KI64Pair: wiretype end group for non-group")
  542. }
  543. if fieldNum <= 0 {
  544. return fmt.Errorf("proto: KI64Pair: illegal tag %d (wire type %d)", fieldNum, wire)
  545. }
  546. switch fieldNum {
  547. case 1:
  548. if wireType != 2 {
  549. return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
  550. }
  551. var byteLen int
  552. for shift := uint(0); ; shift += 7 {
  553. if shift >= 64 {
  554. return ErrIntOverflowTypes
  555. }
  556. if iNdEx >= l {
  557. return io.ErrUnexpectedEOF
  558. }
  559. b := dAtA[iNdEx]
  560. iNdEx++
  561. byteLen |= (int(b) & 0x7F) << shift
  562. if b < 0x80 {
  563. break
  564. }
  565. }
  566. if byteLen < 0 {
  567. return ErrInvalidLengthTypes
  568. }
  569. postIndex := iNdEx + byteLen
  570. if postIndex > l {
  571. return io.ErrUnexpectedEOF
  572. }
  573. m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
  574. if m.Key == nil {
  575. m.Key = []byte{}
  576. }
  577. iNdEx = postIndex
  578. case 2:
  579. if wireType != 0 {
  580. return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
  581. }
  582. m.Value = 0
  583. for shift := uint(0); ; shift += 7 {
  584. if shift >= 64 {
  585. return ErrIntOverflowTypes
  586. }
  587. if iNdEx >= l {
  588. return io.ErrUnexpectedEOF
  589. }
  590. b := dAtA[iNdEx]
  591. iNdEx++
  592. m.Value |= (int64(b) & 0x7F) << shift
  593. if b < 0x80 {
  594. break
  595. }
  596. }
  597. default:
  598. iNdEx = preIndex
  599. skippy, err := skipTypes(dAtA[iNdEx:])
  600. if err != nil {
  601. return err
  602. }
  603. if skippy < 0 {
  604. return ErrInvalidLengthTypes
  605. }
  606. if (iNdEx + skippy) > l {
  607. return io.ErrUnexpectedEOF
  608. }
  609. m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  610. iNdEx += skippy
  611. }
  612. }
  613. if iNdEx > l {
  614. return io.ErrUnexpectedEOF
  615. }
  616. return nil
  617. }
  618. func skipTypes(dAtA []byte) (n int, err error) {
  619. l := len(dAtA)
  620. iNdEx := 0
  621. for iNdEx < l {
  622. var wire uint64
  623. for shift := uint(0); ; shift += 7 {
  624. if shift >= 64 {
  625. return 0, ErrIntOverflowTypes
  626. }
  627. if iNdEx >= l {
  628. return 0, io.ErrUnexpectedEOF
  629. }
  630. b := dAtA[iNdEx]
  631. iNdEx++
  632. wire |= (uint64(b) & 0x7F) << shift
  633. if b < 0x80 {
  634. break
  635. }
  636. }
  637. wireType := int(wire & 0x7)
  638. switch wireType {
  639. case 0:
  640. for shift := uint(0); ; shift += 7 {
  641. if shift >= 64 {
  642. return 0, ErrIntOverflowTypes
  643. }
  644. if iNdEx >= l {
  645. return 0, io.ErrUnexpectedEOF
  646. }
  647. iNdEx++
  648. if dAtA[iNdEx-1] < 0x80 {
  649. break
  650. }
  651. }
  652. return iNdEx, nil
  653. case 1:
  654. iNdEx += 8
  655. return iNdEx, nil
  656. case 2:
  657. var length int
  658. for shift := uint(0); ; shift += 7 {
  659. if shift >= 64 {
  660. return 0, ErrIntOverflowTypes
  661. }
  662. if iNdEx >= l {
  663. return 0, io.ErrUnexpectedEOF
  664. }
  665. b := dAtA[iNdEx]
  666. iNdEx++
  667. length |= (int(b) & 0x7F) << shift
  668. if b < 0x80 {
  669. break
  670. }
  671. }
  672. iNdEx += length
  673. if length < 0 {
  674. return 0, ErrInvalidLengthTypes
  675. }
  676. return iNdEx, nil
  677. case 3:
  678. for {
  679. var innerWire uint64
  680. var start int = iNdEx
  681. for shift := uint(0); ; shift += 7 {
  682. if shift >= 64 {
  683. return 0, ErrIntOverflowTypes
  684. }
  685. if iNdEx >= l {
  686. return 0, io.ErrUnexpectedEOF
  687. }
  688. b := dAtA[iNdEx]
  689. iNdEx++
  690. innerWire |= (uint64(b) & 0x7F) << shift
  691. if b < 0x80 {
  692. break
  693. }
  694. }
  695. innerWireType := int(innerWire & 0x7)
  696. if innerWireType == 4 {
  697. break
  698. }
  699. next, err := skipTypes(dAtA[start:])
  700. if err != nil {
  701. return 0, err
  702. }
  703. iNdEx = start + next
  704. }
  705. return iNdEx, nil
  706. case 4:
  707. return iNdEx, nil
  708. case 5:
  709. iNdEx += 4
  710. return iNdEx, nil
  711. default:
  712. return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
  713. }
  714. }
  715. panic("unreachable")
  716. }
  717. var (
  718. ErrInvalidLengthTypes = fmt.Errorf("proto: negative length found during unmarshaling")
  719. ErrIntOverflowTypes = fmt.Errorf("proto: integer overflow")
  720. )
  721. func init() { proto.RegisterFile("libs/common/types.proto", fileDescriptor_types_611b4364a8604338) }
  722. func init() {
  723. golang_proto.RegisterFile("libs/common/types.proto", fileDescriptor_types_611b4364a8604338)
  724. }
  725. var fileDescriptor_types_611b4364a8604338 = []byte{
  726. // 174 bytes of a gzipped FileDescriptorProto
  727. 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0xcf, 0xc9, 0x4c, 0x2a,
  728. 0xd6, 0x4f, 0xce, 0xcf, 0xcd, 0xcd, 0xcf, 0xd3, 0x2f, 0xa9, 0x2c, 0x48, 0x2d, 0xd6, 0x2b, 0x28,
  729. 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x83, 0x88, 0x49, 0xe9, 0xa6, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9,
  730. 0x25, 0xe7, 0xe7, 0xea, 0xa7, 0xe7, 0xa7, 0xe7, 0xeb, 0x83, 0xa5, 0x93, 0x4a, 0xd3, 0xc0, 0x3c,
  731. 0x30, 0x07, 0xcc, 0x82, 0x68, 0x53, 0x32, 0xe0, 0x62, 0xf3, 0x0e, 0x0b, 0x48, 0xcc, 0x2c, 0x12,
  732. 0x12, 0xe0, 0x62, 0xce, 0x4e, 0xad, 0x94, 0x60, 0x54, 0x60, 0xd4, 0xe0, 0x09, 0x02, 0x31, 0x85,
  733. 0x44, 0xb8, 0x58, 0xcb, 0x12, 0x73, 0x4a, 0x53, 0x25, 0x98, 0xc0, 0x62, 0x10, 0x8e, 0x92, 0x11,
  734. 0x17, 0x87, 0xb7, 0xa7, 0x99, 0x09, 0x31, 0x7a, 0x98, 0xa1, 0x7a, 0x9c, 0x64, 0x7e, 0x3c, 0x94,
  735. 0x63, 0x5c, 0xf1, 0x48, 0x8e, 0x71, 0xc7, 0x23, 0x39, 0xc6, 0x13, 0x8f, 0xe4, 0x18, 0x2f, 0x3c,
  736. 0x92, 0x63, 0x7c, 0xf0, 0x48, 0x8e, 0xf1, 0xc0, 0x63, 0x39, 0xc6, 0x24, 0x36, 0xb0, 0x53, 0x8c,
  737. 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0xb1, 0x39, 0xe1, 0xef, 0xdc, 0x00, 0x00, 0x00,
  738. }