Message.pb.go 27 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140
  1. // Code generated by protoc-gen-gogo. DO NOT EDIT.
  2. // source: v0/Message.proto
  3. package v0
  4. import proto "github.com/gogo/protobuf/proto"
  5. import fmt "fmt"
  6. import math "math"
  7. import _ "github.com/gogo/protobuf/gogoproto"
  8. import io "io"
  9. // Reference imports to suppress errors if they are not otherwise used.
  10. var _ = proto.Marshal
  11. var _ = fmt.Errorf
  12. var _ = math.Inf
  13. // This is a compile-time assertion to ensure that this generated file
  14. // is compatible with the proto package it is being compiled against.
  15. // A compilation error at this line likely means your copy of the
  16. // proto package needs to be updated.
  17. const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
  18. type MessageLiveNotifyReq struct {
  19. }
  20. func (m *MessageLiveNotifyReq) Reset() { *m = MessageLiveNotifyReq{} }
  21. func (m *MessageLiveNotifyReq) String() string { return proto.CompactTextString(m) }
  22. func (*MessageLiveNotifyReq) ProtoMessage() {}
  23. func (*MessageLiveNotifyReq) Descriptor() ([]byte, []int) {
  24. return fileDescriptor_Message_1e41299cf86f2f2e, []int{0}
  25. }
  26. func (m *MessageLiveNotifyReq) XXX_Unmarshal(b []byte) error {
  27. return m.Unmarshal(b)
  28. }
  29. func (m *MessageLiveNotifyReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  30. if deterministic {
  31. return xxx_messageInfo_MessageLiveNotifyReq.Marshal(b, m, deterministic)
  32. } else {
  33. b = b[:cap(b)]
  34. n, err := m.MarshalTo(b)
  35. if err != nil {
  36. return nil, err
  37. }
  38. return b[:n], nil
  39. }
  40. }
  41. func (dst *MessageLiveNotifyReq) XXX_Merge(src proto.Message) {
  42. xxx_messageInfo_MessageLiveNotifyReq.Merge(dst, src)
  43. }
  44. func (m *MessageLiveNotifyReq) XXX_Size() int {
  45. return m.Size()
  46. }
  47. func (m *MessageLiveNotifyReq) XXX_DiscardUnknown() {
  48. xxx_messageInfo_MessageLiveNotifyReq.DiscardUnknown(m)
  49. }
  50. var xxx_messageInfo_MessageLiveNotifyReq proto.InternalMessageInfo
  51. type MessageLiveNotifyResp struct {
  52. // code
  53. Code int64 `protobuf:"varint,1,opt,name=code,proto3" json:"code"`
  54. // msg
  55. Msg string `protobuf:"bytes,2,opt,name=msg,proto3" json:"msg"`
  56. //
  57. Data *MessageLiveNotifyResp_Data `protobuf:"bytes,3,opt,name=data" json:"data"`
  58. }
  59. func (m *MessageLiveNotifyResp) Reset() { *m = MessageLiveNotifyResp{} }
  60. func (m *MessageLiveNotifyResp) String() string { return proto.CompactTextString(m) }
  61. func (*MessageLiveNotifyResp) ProtoMessage() {}
  62. func (*MessageLiveNotifyResp) Descriptor() ([]byte, []int) {
  63. return fileDescriptor_Message_1e41299cf86f2f2e, []int{1}
  64. }
  65. func (m *MessageLiveNotifyResp) XXX_Unmarshal(b []byte) error {
  66. return m.Unmarshal(b)
  67. }
  68. func (m *MessageLiveNotifyResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  69. if deterministic {
  70. return xxx_messageInfo_MessageLiveNotifyResp.Marshal(b, m, deterministic)
  71. } else {
  72. b = b[:cap(b)]
  73. n, err := m.MarshalTo(b)
  74. if err != nil {
  75. return nil, err
  76. }
  77. return b[:n], nil
  78. }
  79. }
  80. func (dst *MessageLiveNotifyResp) XXX_Merge(src proto.Message) {
  81. xxx_messageInfo_MessageLiveNotifyResp.Merge(dst, src)
  82. }
  83. func (m *MessageLiveNotifyResp) XXX_Size() int {
  84. return m.Size()
  85. }
  86. func (m *MessageLiveNotifyResp) XXX_DiscardUnknown() {
  87. xxx_messageInfo_MessageLiveNotifyResp.DiscardUnknown(m)
  88. }
  89. var xxx_messageInfo_MessageLiveNotifyResp proto.InternalMessageInfo
  90. func (m *MessageLiveNotifyResp) GetCode() int64 {
  91. if m != nil {
  92. return m.Code
  93. }
  94. return 0
  95. }
  96. func (m *MessageLiveNotifyResp) GetMsg() string {
  97. if m != nil {
  98. return m.Msg
  99. }
  100. return ""
  101. }
  102. func (m *MessageLiveNotifyResp) GetData() *MessageLiveNotifyResp_Data {
  103. if m != nil {
  104. return m.Data
  105. }
  106. return nil
  107. }
  108. type MessageLiveNotifyResp_Data struct {
  109. }
  110. func (m *MessageLiveNotifyResp_Data) Reset() { *m = MessageLiveNotifyResp_Data{} }
  111. func (m *MessageLiveNotifyResp_Data) String() string { return proto.CompactTextString(m) }
  112. func (*MessageLiveNotifyResp_Data) ProtoMessage() {}
  113. func (*MessageLiveNotifyResp_Data) Descriptor() ([]byte, []int) {
  114. return fileDescriptor_Message_1e41299cf86f2f2e, []int{1, 0}
  115. }
  116. func (m *MessageLiveNotifyResp_Data) XXX_Unmarshal(b []byte) error {
  117. return m.Unmarshal(b)
  118. }
  119. func (m *MessageLiveNotifyResp_Data) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  120. if deterministic {
  121. return xxx_messageInfo_MessageLiveNotifyResp_Data.Marshal(b, m, deterministic)
  122. } else {
  123. b = b[:cap(b)]
  124. n, err := m.MarshalTo(b)
  125. if err != nil {
  126. return nil, err
  127. }
  128. return b[:n], nil
  129. }
  130. }
  131. func (dst *MessageLiveNotifyResp_Data) XXX_Merge(src proto.Message) {
  132. xxx_messageInfo_MessageLiveNotifyResp_Data.Merge(dst, src)
  133. }
  134. func (m *MessageLiveNotifyResp_Data) XXX_Size() int {
  135. return m.Size()
  136. }
  137. func (m *MessageLiveNotifyResp_Data) XXX_DiscardUnknown() {
  138. xxx_messageInfo_MessageLiveNotifyResp_Data.DiscardUnknown(m)
  139. }
  140. var xxx_messageInfo_MessageLiveNotifyResp_Data proto.InternalMessageInfo
  141. type MessageAreaNotifyReq struct {
  142. }
  143. func (m *MessageAreaNotifyReq) Reset() { *m = MessageAreaNotifyReq{} }
  144. func (m *MessageAreaNotifyReq) String() string { return proto.CompactTextString(m) }
  145. func (*MessageAreaNotifyReq) ProtoMessage() {}
  146. func (*MessageAreaNotifyReq) Descriptor() ([]byte, []int) {
  147. return fileDescriptor_Message_1e41299cf86f2f2e, []int{2}
  148. }
  149. func (m *MessageAreaNotifyReq) XXX_Unmarshal(b []byte) error {
  150. return m.Unmarshal(b)
  151. }
  152. func (m *MessageAreaNotifyReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  153. if deterministic {
  154. return xxx_messageInfo_MessageAreaNotifyReq.Marshal(b, m, deterministic)
  155. } else {
  156. b = b[:cap(b)]
  157. n, err := m.MarshalTo(b)
  158. if err != nil {
  159. return nil, err
  160. }
  161. return b[:n], nil
  162. }
  163. }
  164. func (dst *MessageAreaNotifyReq) XXX_Merge(src proto.Message) {
  165. xxx_messageInfo_MessageAreaNotifyReq.Merge(dst, src)
  166. }
  167. func (m *MessageAreaNotifyReq) XXX_Size() int {
  168. return m.Size()
  169. }
  170. func (m *MessageAreaNotifyReq) XXX_DiscardUnknown() {
  171. xxx_messageInfo_MessageAreaNotifyReq.DiscardUnknown(m)
  172. }
  173. var xxx_messageInfo_MessageAreaNotifyReq proto.InternalMessageInfo
  174. type MessageAreaNotifyResp struct {
  175. // code
  176. Code int64 `protobuf:"varint,1,opt,name=code,proto3" json:"code"`
  177. // msg
  178. Msg string `protobuf:"bytes,2,opt,name=msg,proto3" json:"msg"`
  179. //
  180. Data *MessageAreaNotifyResp_Data `protobuf:"bytes,3,opt,name=data" json:"data"`
  181. }
  182. func (m *MessageAreaNotifyResp) Reset() { *m = MessageAreaNotifyResp{} }
  183. func (m *MessageAreaNotifyResp) String() string { return proto.CompactTextString(m) }
  184. func (*MessageAreaNotifyResp) ProtoMessage() {}
  185. func (*MessageAreaNotifyResp) Descriptor() ([]byte, []int) {
  186. return fileDescriptor_Message_1e41299cf86f2f2e, []int{3}
  187. }
  188. func (m *MessageAreaNotifyResp) XXX_Unmarshal(b []byte) error {
  189. return m.Unmarshal(b)
  190. }
  191. func (m *MessageAreaNotifyResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  192. if deterministic {
  193. return xxx_messageInfo_MessageAreaNotifyResp.Marshal(b, m, deterministic)
  194. } else {
  195. b = b[:cap(b)]
  196. n, err := m.MarshalTo(b)
  197. if err != nil {
  198. return nil, err
  199. }
  200. return b[:n], nil
  201. }
  202. }
  203. func (dst *MessageAreaNotifyResp) XXX_Merge(src proto.Message) {
  204. xxx_messageInfo_MessageAreaNotifyResp.Merge(dst, src)
  205. }
  206. func (m *MessageAreaNotifyResp) XXX_Size() int {
  207. return m.Size()
  208. }
  209. func (m *MessageAreaNotifyResp) XXX_DiscardUnknown() {
  210. xxx_messageInfo_MessageAreaNotifyResp.DiscardUnknown(m)
  211. }
  212. var xxx_messageInfo_MessageAreaNotifyResp proto.InternalMessageInfo
  213. func (m *MessageAreaNotifyResp) GetCode() int64 {
  214. if m != nil {
  215. return m.Code
  216. }
  217. return 0
  218. }
  219. func (m *MessageAreaNotifyResp) GetMsg() string {
  220. if m != nil {
  221. return m.Msg
  222. }
  223. return ""
  224. }
  225. func (m *MessageAreaNotifyResp) GetData() *MessageAreaNotifyResp_Data {
  226. if m != nil {
  227. return m.Data
  228. }
  229. return nil
  230. }
  231. type MessageAreaNotifyResp_Data struct {
  232. }
  233. func (m *MessageAreaNotifyResp_Data) Reset() { *m = MessageAreaNotifyResp_Data{} }
  234. func (m *MessageAreaNotifyResp_Data) String() string { return proto.CompactTextString(m) }
  235. func (*MessageAreaNotifyResp_Data) ProtoMessage() {}
  236. func (*MessageAreaNotifyResp_Data) Descriptor() ([]byte, []int) {
  237. return fileDescriptor_Message_1e41299cf86f2f2e, []int{3, 0}
  238. }
  239. func (m *MessageAreaNotifyResp_Data) XXX_Unmarshal(b []byte) error {
  240. return m.Unmarshal(b)
  241. }
  242. func (m *MessageAreaNotifyResp_Data) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  243. if deterministic {
  244. return xxx_messageInfo_MessageAreaNotifyResp_Data.Marshal(b, m, deterministic)
  245. } else {
  246. b = b[:cap(b)]
  247. n, err := m.MarshalTo(b)
  248. if err != nil {
  249. return nil, err
  250. }
  251. return b[:n], nil
  252. }
  253. }
  254. func (dst *MessageAreaNotifyResp_Data) XXX_Merge(src proto.Message) {
  255. xxx_messageInfo_MessageAreaNotifyResp_Data.Merge(dst, src)
  256. }
  257. func (m *MessageAreaNotifyResp_Data) XXX_Size() int {
  258. return m.Size()
  259. }
  260. func (m *MessageAreaNotifyResp_Data) XXX_DiscardUnknown() {
  261. xxx_messageInfo_MessageAreaNotifyResp_Data.DiscardUnknown(m)
  262. }
  263. var xxx_messageInfo_MessageAreaNotifyResp_Data proto.InternalMessageInfo
  264. func init() {
  265. proto.RegisterType((*MessageLiveNotifyReq)(nil), "live_data.v0.MessageLiveNotifyReq")
  266. proto.RegisterType((*MessageLiveNotifyResp)(nil), "live_data.v0.MessageLiveNotifyResp")
  267. proto.RegisterType((*MessageLiveNotifyResp_Data)(nil), "live_data.v0.MessageLiveNotifyResp.Data")
  268. proto.RegisterType((*MessageAreaNotifyReq)(nil), "live_data.v0.MessageAreaNotifyReq")
  269. proto.RegisterType((*MessageAreaNotifyResp)(nil), "live_data.v0.MessageAreaNotifyResp")
  270. proto.RegisterType((*MessageAreaNotifyResp_Data)(nil), "live_data.v0.MessageAreaNotifyResp.Data")
  271. }
  272. func (m *MessageLiveNotifyReq) Marshal() (dAtA []byte, err error) {
  273. size := m.Size()
  274. dAtA = make([]byte, size)
  275. n, err := m.MarshalTo(dAtA)
  276. if err != nil {
  277. return nil, err
  278. }
  279. return dAtA[:n], nil
  280. }
  281. func (m *MessageLiveNotifyReq) MarshalTo(dAtA []byte) (int, error) {
  282. var i int
  283. _ = i
  284. var l int
  285. _ = l
  286. return i, nil
  287. }
  288. func (m *MessageLiveNotifyResp) Marshal() (dAtA []byte, err error) {
  289. size := m.Size()
  290. dAtA = make([]byte, size)
  291. n, err := m.MarshalTo(dAtA)
  292. if err != nil {
  293. return nil, err
  294. }
  295. return dAtA[:n], nil
  296. }
  297. func (m *MessageLiveNotifyResp) MarshalTo(dAtA []byte) (int, error) {
  298. var i int
  299. _ = i
  300. var l int
  301. _ = l
  302. if m.Code != 0 {
  303. dAtA[i] = 0x8
  304. i++
  305. i = encodeVarintMessage(dAtA, i, uint64(m.Code))
  306. }
  307. if len(m.Msg) > 0 {
  308. dAtA[i] = 0x12
  309. i++
  310. i = encodeVarintMessage(dAtA, i, uint64(len(m.Msg)))
  311. i += copy(dAtA[i:], m.Msg)
  312. }
  313. if m.Data != nil {
  314. dAtA[i] = 0x1a
  315. i++
  316. i = encodeVarintMessage(dAtA, i, uint64(m.Data.Size()))
  317. n1, err := m.Data.MarshalTo(dAtA[i:])
  318. if err != nil {
  319. return 0, err
  320. }
  321. i += n1
  322. }
  323. return i, nil
  324. }
  325. func (m *MessageLiveNotifyResp_Data) Marshal() (dAtA []byte, err error) {
  326. size := m.Size()
  327. dAtA = make([]byte, size)
  328. n, err := m.MarshalTo(dAtA)
  329. if err != nil {
  330. return nil, err
  331. }
  332. return dAtA[:n], nil
  333. }
  334. func (m *MessageLiveNotifyResp_Data) MarshalTo(dAtA []byte) (int, error) {
  335. var i int
  336. _ = i
  337. var l int
  338. _ = l
  339. return i, nil
  340. }
  341. func (m *MessageAreaNotifyReq) Marshal() (dAtA []byte, err error) {
  342. size := m.Size()
  343. dAtA = make([]byte, size)
  344. n, err := m.MarshalTo(dAtA)
  345. if err != nil {
  346. return nil, err
  347. }
  348. return dAtA[:n], nil
  349. }
  350. func (m *MessageAreaNotifyReq) MarshalTo(dAtA []byte) (int, error) {
  351. var i int
  352. _ = i
  353. var l int
  354. _ = l
  355. return i, nil
  356. }
  357. func (m *MessageAreaNotifyResp) Marshal() (dAtA []byte, err error) {
  358. size := m.Size()
  359. dAtA = make([]byte, size)
  360. n, err := m.MarshalTo(dAtA)
  361. if err != nil {
  362. return nil, err
  363. }
  364. return dAtA[:n], nil
  365. }
  366. func (m *MessageAreaNotifyResp) MarshalTo(dAtA []byte) (int, error) {
  367. var i int
  368. _ = i
  369. var l int
  370. _ = l
  371. if m.Code != 0 {
  372. dAtA[i] = 0x8
  373. i++
  374. i = encodeVarintMessage(dAtA, i, uint64(m.Code))
  375. }
  376. if len(m.Msg) > 0 {
  377. dAtA[i] = 0x12
  378. i++
  379. i = encodeVarintMessage(dAtA, i, uint64(len(m.Msg)))
  380. i += copy(dAtA[i:], m.Msg)
  381. }
  382. if m.Data != nil {
  383. dAtA[i] = 0x1a
  384. i++
  385. i = encodeVarintMessage(dAtA, i, uint64(m.Data.Size()))
  386. n2, err := m.Data.MarshalTo(dAtA[i:])
  387. if err != nil {
  388. return 0, err
  389. }
  390. i += n2
  391. }
  392. return i, nil
  393. }
  394. func (m *MessageAreaNotifyResp_Data) Marshal() (dAtA []byte, err error) {
  395. size := m.Size()
  396. dAtA = make([]byte, size)
  397. n, err := m.MarshalTo(dAtA)
  398. if err != nil {
  399. return nil, err
  400. }
  401. return dAtA[:n], nil
  402. }
  403. func (m *MessageAreaNotifyResp_Data) MarshalTo(dAtA []byte) (int, error) {
  404. var i int
  405. _ = i
  406. var l int
  407. _ = l
  408. return i, nil
  409. }
  410. func encodeVarintMessage(dAtA []byte, offset int, v uint64) int {
  411. for v >= 1<<7 {
  412. dAtA[offset] = uint8(v&0x7f | 0x80)
  413. v >>= 7
  414. offset++
  415. }
  416. dAtA[offset] = uint8(v)
  417. return offset + 1
  418. }
  419. func (m *MessageLiveNotifyReq) Size() (n int) {
  420. if m == nil {
  421. return 0
  422. }
  423. var l int
  424. _ = l
  425. return n
  426. }
  427. func (m *MessageLiveNotifyResp) Size() (n int) {
  428. if m == nil {
  429. return 0
  430. }
  431. var l int
  432. _ = l
  433. if m.Code != 0 {
  434. n += 1 + sovMessage(uint64(m.Code))
  435. }
  436. l = len(m.Msg)
  437. if l > 0 {
  438. n += 1 + l + sovMessage(uint64(l))
  439. }
  440. if m.Data != nil {
  441. l = m.Data.Size()
  442. n += 1 + l + sovMessage(uint64(l))
  443. }
  444. return n
  445. }
  446. func (m *MessageLiveNotifyResp_Data) Size() (n int) {
  447. if m == nil {
  448. return 0
  449. }
  450. var l int
  451. _ = l
  452. return n
  453. }
  454. func (m *MessageAreaNotifyReq) Size() (n int) {
  455. if m == nil {
  456. return 0
  457. }
  458. var l int
  459. _ = l
  460. return n
  461. }
  462. func (m *MessageAreaNotifyResp) Size() (n int) {
  463. if m == nil {
  464. return 0
  465. }
  466. var l int
  467. _ = l
  468. if m.Code != 0 {
  469. n += 1 + sovMessage(uint64(m.Code))
  470. }
  471. l = len(m.Msg)
  472. if l > 0 {
  473. n += 1 + l + sovMessage(uint64(l))
  474. }
  475. if m.Data != nil {
  476. l = m.Data.Size()
  477. n += 1 + l + sovMessage(uint64(l))
  478. }
  479. return n
  480. }
  481. func (m *MessageAreaNotifyResp_Data) Size() (n int) {
  482. if m == nil {
  483. return 0
  484. }
  485. var l int
  486. _ = l
  487. return n
  488. }
  489. func sovMessage(x uint64) (n int) {
  490. for {
  491. n++
  492. x >>= 7
  493. if x == 0 {
  494. break
  495. }
  496. }
  497. return n
  498. }
  499. func sozMessage(x uint64) (n int) {
  500. return sovMessage(uint64((x << 1) ^ uint64((int64(x) >> 63))))
  501. }
  502. func (m *MessageLiveNotifyReq) Unmarshal(dAtA []byte) error {
  503. l := len(dAtA)
  504. iNdEx := 0
  505. for iNdEx < l {
  506. preIndex := iNdEx
  507. var wire uint64
  508. for shift := uint(0); ; shift += 7 {
  509. if shift >= 64 {
  510. return ErrIntOverflowMessage
  511. }
  512. if iNdEx >= l {
  513. return io.ErrUnexpectedEOF
  514. }
  515. b := dAtA[iNdEx]
  516. iNdEx++
  517. wire |= (uint64(b) & 0x7F) << shift
  518. if b < 0x80 {
  519. break
  520. }
  521. }
  522. fieldNum := int32(wire >> 3)
  523. wireType := int(wire & 0x7)
  524. if wireType == 4 {
  525. return fmt.Errorf("proto: MessageLiveNotifyReq: wiretype end group for non-group")
  526. }
  527. if fieldNum <= 0 {
  528. return fmt.Errorf("proto: MessageLiveNotifyReq: illegal tag %d (wire type %d)", fieldNum, wire)
  529. }
  530. switch fieldNum {
  531. default:
  532. iNdEx = preIndex
  533. skippy, err := skipMessage(dAtA[iNdEx:])
  534. if err != nil {
  535. return err
  536. }
  537. if skippy < 0 {
  538. return ErrInvalidLengthMessage
  539. }
  540. if (iNdEx + skippy) > l {
  541. return io.ErrUnexpectedEOF
  542. }
  543. iNdEx += skippy
  544. }
  545. }
  546. if iNdEx > l {
  547. return io.ErrUnexpectedEOF
  548. }
  549. return nil
  550. }
  551. func (m *MessageLiveNotifyResp) Unmarshal(dAtA []byte) error {
  552. l := len(dAtA)
  553. iNdEx := 0
  554. for iNdEx < l {
  555. preIndex := iNdEx
  556. var wire uint64
  557. for shift := uint(0); ; shift += 7 {
  558. if shift >= 64 {
  559. return ErrIntOverflowMessage
  560. }
  561. if iNdEx >= l {
  562. return io.ErrUnexpectedEOF
  563. }
  564. b := dAtA[iNdEx]
  565. iNdEx++
  566. wire |= (uint64(b) & 0x7F) << shift
  567. if b < 0x80 {
  568. break
  569. }
  570. }
  571. fieldNum := int32(wire >> 3)
  572. wireType := int(wire & 0x7)
  573. if wireType == 4 {
  574. return fmt.Errorf("proto: MessageLiveNotifyResp: wiretype end group for non-group")
  575. }
  576. if fieldNum <= 0 {
  577. return fmt.Errorf("proto: MessageLiveNotifyResp: illegal tag %d (wire type %d)", fieldNum, wire)
  578. }
  579. switch fieldNum {
  580. case 1:
  581. if wireType != 0 {
  582. return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
  583. }
  584. m.Code = 0
  585. for shift := uint(0); ; shift += 7 {
  586. if shift >= 64 {
  587. return ErrIntOverflowMessage
  588. }
  589. if iNdEx >= l {
  590. return io.ErrUnexpectedEOF
  591. }
  592. b := dAtA[iNdEx]
  593. iNdEx++
  594. m.Code |= (int64(b) & 0x7F) << shift
  595. if b < 0x80 {
  596. break
  597. }
  598. }
  599. case 2:
  600. if wireType != 2 {
  601. return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
  602. }
  603. var stringLen uint64
  604. for shift := uint(0); ; shift += 7 {
  605. if shift >= 64 {
  606. return ErrIntOverflowMessage
  607. }
  608. if iNdEx >= l {
  609. return io.ErrUnexpectedEOF
  610. }
  611. b := dAtA[iNdEx]
  612. iNdEx++
  613. stringLen |= (uint64(b) & 0x7F) << shift
  614. if b < 0x80 {
  615. break
  616. }
  617. }
  618. intStringLen := int(stringLen)
  619. if intStringLen < 0 {
  620. return ErrInvalidLengthMessage
  621. }
  622. postIndex := iNdEx + intStringLen
  623. if postIndex > l {
  624. return io.ErrUnexpectedEOF
  625. }
  626. m.Msg = string(dAtA[iNdEx:postIndex])
  627. iNdEx = postIndex
  628. case 3:
  629. if wireType != 2 {
  630. return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
  631. }
  632. var msglen int
  633. for shift := uint(0); ; shift += 7 {
  634. if shift >= 64 {
  635. return ErrIntOverflowMessage
  636. }
  637. if iNdEx >= l {
  638. return io.ErrUnexpectedEOF
  639. }
  640. b := dAtA[iNdEx]
  641. iNdEx++
  642. msglen |= (int(b) & 0x7F) << shift
  643. if b < 0x80 {
  644. break
  645. }
  646. }
  647. if msglen < 0 {
  648. return ErrInvalidLengthMessage
  649. }
  650. postIndex := iNdEx + msglen
  651. if postIndex > l {
  652. return io.ErrUnexpectedEOF
  653. }
  654. if m.Data == nil {
  655. m.Data = &MessageLiveNotifyResp_Data{}
  656. }
  657. if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  658. return err
  659. }
  660. iNdEx = postIndex
  661. default:
  662. iNdEx = preIndex
  663. skippy, err := skipMessage(dAtA[iNdEx:])
  664. if err != nil {
  665. return err
  666. }
  667. if skippy < 0 {
  668. return ErrInvalidLengthMessage
  669. }
  670. if (iNdEx + skippy) > l {
  671. return io.ErrUnexpectedEOF
  672. }
  673. iNdEx += skippy
  674. }
  675. }
  676. if iNdEx > l {
  677. return io.ErrUnexpectedEOF
  678. }
  679. return nil
  680. }
  681. func (m *MessageLiveNotifyResp_Data) Unmarshal(dAtA []byte) error {
  682. l := len(dAtA)
  683. iNdEx := 0
  684. for iNdEx < l {
  685. preIndex := iNdEx
  686. var wire uint64
  687. for shift := uint(0); ; shift += 7 {
  688. if shift >= 64 {
  689. return ErrIntOverflowMessage
  690. }
  691. if iNdEx >= l {
  692. return io.ErrUnexpectedEOF
  693. }
  694. b := dAtA[iNdEx]
  695. iNdEx++
  696. wire |= (uint64(b) & 0x7F) << shift
  697. if b < 0x80 {
  698. break
  699. }
  700. }
  701. fieldNum := int32(wire >> 3)
  702. wireType := int(wire & 0x7)
  703. if wireType == 4 {
  704. return fmt.Errorf("proto: Data: wiretype end group for non-group")
  705. }
  706. if fieldNum <= 0 {
  707. return fmt.Errorf("proto: Data: illegal tag %d (wire type %d)", fieldNum, wire)
  708. }
  709. switch fieldNum {
  710. default:
  711. iNdEx = preIndex
  712. skippy, err := skipMessage(dAtA[iNdEx:])
  713. if err != nil {
  714. return err
  715. }
  716. if skippy < 0 {
  717. return ErrInvalidLengthMessage
  718. }
  719. if (iNdEx + skippy) > l {
  720. return io.ErrUnexpectedEOF
  721. }
  722. iNdEx += skippy
  723. }
  724. }
  725. if iNdEx > l {
  726. return io.ErrUnexpectedEOF
  727. }
  728. return nil
  729. }
  730. func (m *MessageAreaNotifyReq) Unmarshal(dAtA []byte) error {
  731. l := len(dAtA)
  732. iNdEx := 0
  733. for iNdEx < l {
  734. preIndex := iNdEx
  735. var wire uint64
  736. for shift := uint(0); ; shift += 7 {
  737. if shift >= 64 {
  738. return ErrIntOverflowMessage
  739. }
  740. if iNdEx >= l {
  741. return io.ErrUnexpectedEOF
  742. }
  743. b := dAtA[iNdEx]
  744. iNdEx++
  745. wire |= (uint64(b) & 0x7F) << shift
  746. if b < 0x80 {
  747. break
  748. }
  749. }
  750. fieldNum := int32(wire >> 3)
  751. wireType := int(wire & 0x7)
  752. if wireType == 4 {
  753. return fmt.Errorf("proto: MessageAreaNotifyReq: wiretype end group for non-group")
  754. }
  755. if fieldNum <= 0 {
  756. return fmt.Errorf("proto: MessageAreaNotifyReq: illegal tag %d (wire type %d)", fieldNum, wire)
  757. }
  758. switch fieldNum {
  759. default:
  760. iNdEx = preIndex
  761. skippy, err := skipMessage(dAtA[iNdEx:])
  762. if err != nil {
  763. return err
  764. }
  765. if skippy < 0 {
  766. return ErrInvalidLengthMessage
  767. }
  768. if (iNdEx + skippy) > l {
  769. return io.ErrUnexpectedEOF
  770. }
  771. iNdEx += skippy
  772. }
  773. }
  774. if iNdEx > l {
  775. return io.ErrUnexpectedEOF
  776. }
  777. return nil
  778. }
  779. func (m *MessageAreaNotifyResp) Unmarshal(dAtA []byte) error {
  780. l := len(dAtA)
  781. iNdEx := 0
  782. for iNdEx < l {
  783. preIndex := iNdEx
  784. var wire uint64
  785. for shift := uint(0); ; shift += 7 {
  786. if shift >= 64 {
  787. return ErrIntOverflowMessage
  788. }
  789. if iNdEx >= l {
  790. return io.ErrUnexpectedEOF
  791. }
  792. b := dAtA[iNdEx]
  793. iNdEx++
  794. wire |= (uint64(b) & 0x7F) << shift
  795. if b < 0x80 {
  796. break
  797. }
  798. }
  799. fieldNum := int32(wire >> 3)
  800. wireType := int(wire & 0x7)
  801. if wireType == 4 {
  802. return fmt.Errorf("proto: MessageAreaNotifyResp: wiretype end group for non-group")
  803. }
  804. if fieldNum <= 0 {
  805. return fmt.Errorf("proto: MessageAreaNotifyResp: illegal tag %d (wire type %d)", fieldNum, wire)
  806. }
  807. switch fieldNum {
  808. case 1:
  809. if wireType != 0 {
  810. return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
  811. }
  812. m.Code = 0
  813. for shift := uint(0); ; shift += 7 {
  814. if shift >= 64 {
  815. return ErrIntOverflowMessage
  816. }
  817. if iNdEx >= l {
  818. return io.ErrUnexpectedEOF
  819. }
  820. b := dAtA[iNdEx]
  821. iNdEx++
  822. m.Code |= (int64(b) & 0x7F) << shift
  823. if b < 0x80 {
  824. break
  825. }
  826. }
  827. case 2:
  828. if wireType != 2 {
  829. return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
  830. }
  831. var stringLen uint64
  832. for shift := uint(0); ; shift += 7 {
  833. if shift >= 64 {
  834. return ErrIntOverflowMessage
  835. }
  836. if iNdEx >= l {
  837. return io.ErrUnexpectedEOF
  838. }
  839. b := dAtA[iNdEx]
  840. iNdEx++
  841. stringLen |= (uint64(b) & 0x7F) << shift
  842. if b < 0x80 {
  843. break
  844. }
  845. }
  846. intStringLen := int(stringLen)
  847. if intStringLen < 0 {
  848. return ErrInvalidLengthMessage
  849. }
  850. postIndex := iNdEx + intStringLen
  851. if postIndex > l {
  852. return io.ErrUnexpectedEOF
  853. }
  854. m.Msg = string(dAtA[iNdEx:postIndex])
  855. iNdEx = postIndex
  856. case 3:
  857. if wireType != 2 {
  858. return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
  859. }
  860. var msglen int
  861. for shift := uint(0); ; shift += 7 {
  862. if shift >= 64 {
  863. return ErrIntOverflowMessage
  864. }
  865. if iNdEx >= l {
  866. return io.ErrUnexpectedEOF
  867. }
  868. b := dAtA[iNdEx]
  869. iNdEx++
  870. msglen |= (int(b) & 0x7F) << shift
  871. if b < 0x80 {
  872. break
  873. }
  874. }
  875. if msglen < 0 {
  876. return ErrInvalidLengthMessage
  877. }
  878. postIndex := iNdEx + msglen
  879. if postIndex > l {
  880. return io.ErrUnexpectedEOF
  881. }
  882. if m.Data == nil {
  883. m.Data = &MessageAreaNotifyResp_Data{}
  884. }
  885. if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  886. return err
  887. }
  888. iNdEx = postIndex
  889. default:
  890. iNdEx = preIndex
  891. skippy, err := skipMessage(dAtA[iNdEx:])
  892. if err != nil {
  893. return err
  894. }
  895. if skippy < 0 {
  896. return ErrInvalidLengthMessage
  897. }
  898. if (iNdEx + skippy) > l {
  899. return io.ErrUnexpectedEOF
  900. }
  901. iNdEx += skippy
  902. }
  903. }
  904. if iNdEx > l {
  905. return io.ErrUnexpectedEOF
  906. }
  907. return nil
  908. }
  909. func (m *MessageAreaNotifyResp_Data) Unmarshal(dAtA []byte) error {
  910. l := len(dAtA)
  911. iNdEx := 0
  912. for iNdEx < l {
  913. preIndex := iNdEx
  914. var wire uint64
  915. for shift := uint(0); ; shift += 7 {
  916. if shift >= 64 {
  917. return ErrIntOverflowMessage
  918. }
  919. if iNdEx >= l {
  920. return io.ErrUnexpectedEOF
  921. }
  922. b := dAtA[iNdEx]
  923. iNdEx++
  924. wire |= (uint64(b) & 0x7F) << shift
  925. if b < 0x80 {
  926. break
  927. }
  928. }
  929. fieldNum := int32(wire >> 3)
  930. wireType := int(wire & 0x7)
  931. if wireType == 4 {
  932. return fmt.Errorf("proto: Data: wiretype end group for non-group")
  933. }
  934. if fieldNum <= 0 {
  935. return fmt.Errorf("proto: Data: illegal tag %d (wire type %d)", fieldNum, wire)
  936. }
  937. switch fieldNum {
  938. default:
  939. iNdEx = preIndex
  940. skippy, err := skipMessage(dAtA[iNdEx:])
  941. if err != nil {
  942. return err
  943. }
  944. if skippy < 0 {
  945. return ErrInvalidLengthMessage
  946. }
  947. if (iNdEx + skippy) > l {
  948. return io.ErrUnexpectedEOF
  949. }
  950. iNdEx += skippy
  951. }
  952. }
  953. if iNdEx > l {
  954. return io.ErrUnexpectedEOF
  955. }
  956. return nil
  957. }
  958. func skipMessage(dAtA []byte) (n int, err error) {
  959. l := len(dAtA)
  960. iNdEx := 0
  961. for iNdEx < l {
  962. var wire uint64
  963. for shift := uint(0); ; shift += 7 {
  964. if shift >= 64 {
  965. return 0, ErrIntOverflowMessage
  966. }
  967. if iNdEx >= l {
  968. return 0, io.ErrUnexpectedEOF
  969. }
  970. b := dAtA[iNdEx]
  971. iNdEx++
  972. wire |= (uint64(b) & 0x7F) << shift
  973. if b < 0x80 {
  974. break
  975. }
  976. }
  977. wireType := int(wire & 0x7)
  978. switch wireType {
  979. case 0:
  980. for shift := uint(0); ; shift += 7 {
  981. if shift >= 64 {
  982. return 0, ErrIntOverflowMessage
  983. }
  984. if iNdEx >= l {
  985. return 0, io.ErrUnexpectedEOF
  986. }
  987. iNdEx++
  988. if dAtA[iNdEx-1] < 0x80 {
  989. break
  990. }
  991. }
  992. return iNdEx, nil
  993. case 1:
  994. iNdEx += 8
  995. return iNdEx, nil
  996. case 2:
  997. var length int
  998. for shift := uint(0); ; shift += 7 {
  999. if shift >= 64 {
  1000. return 0, ErrIntOverflowMessage
  1001. }
  1002. if iNdEx >= l {
  1003. return 0, io.ErrUnexpectedEOF
  1004. }
  1005. b := dAtA[iNdEx]
  1006. iNdEx++
  1007. length |= (int(b) & 0x7F) << shift
  1008. if b < 0x80 {
  1009. break
  1010. }
  1011. }
  1012. iNdEx += length
  1013. if length < 0 {
  1014. return 0, ErrInvalidLengthMessage
  1015. }
  1016. return iNdEx, nil
  1017. case 3:
  1018. for {
  1019. var innerWire uint64
  1020. var start int = iNdEx
  1021. for shift := uint(0); ; shift += 7 {
  1022. if shift >= 64 {
  1023. return 0, ErrIntOverflowMessage
  1024. }
  1025. if iNdEx >= l {
  1026. return 0, io.ErrUnexpectedEOF
  1027. }
  1028. b := dAtA[iNdEx]
  1029. iNdEx++
  1030. innerWire |= (uint64(b) & 0x7F) << shift
  1031. if b < 0x80 {
  1032. break
  1033. }
  1034. }
  1035. innerWireType := int(innerWire & 0x7)
  1036. if innerWireType == 4 {
  1037. break
  1038. }
  1039. next, err := skipMessage(dAtA[start:])
  1040. if err != nil {
  1041. return 0, err
  1042. }
  1043. iNdEx = start + next
  1044. }
  1045. return iNdEx, nil
  1046. case 4:
  1047. return iNdEx, nil
  1048. case 5:
  1049. iNdEx += 4
  1050. return iNdEx, nil
  1051. default:
  1052. return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
  1053. }
  1054. }
  1055. panic("unreachable")
  1056. }
  1057. var (
  1058. ErrInvalidLengthMessage = fmt.Errorf("proto: negative length found during unmarshaling")
  1059. ErrIntOverflowMessage = fmt.Errorf("proto: integer overflow")
  1060. )
  1061. func init() { proto.RegisterFile("v0/Message.proto", fileDescriptor_Message_1e41299cf86f2f2e) }
  1062. var fileDescriptor_Message_1e41299cf86f2f2e = []byte{
  1063. // 295 bytes of a gzipped FileDescriptorProto
  1064. 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0x28, 0x33, 0xd0, 0xf7,
  1065. 0x4d, 0x2d, 0x2e, 0x4e, 0x4c, 0x4f, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0xc9, 0xc9,
  1066. 0x2c, 0x4b, 0x8d, 0x4f, 0x49, 0x2c, 0x49, 0xd4, 0x2b, 0x33, 0x90, 0xd2, 0x4d, 0xcf, 0x2c, 0xc9,
  1067. 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xcf, 0x4f, 0xcf, 0xd7, 0x07, 0x2b, 0x4a, 0x2a,
  1068. 0x4d, 0x03, 0xf3, 0xc0, 0x1c, 0x30, 0x0b, 0xa2, 0x59, 0x49, 0x8c, 0x4b, 0x04, 0x6a, 0x9a, 0x4f,
  1069. 0x66, 0x59, 0xaa, 0x5f, 0x7e, 0x49, 0x66, 0x5a, 0x65, 0x50, 0x6a, 0xa1, 0xd2, 0x02, 0x46, 0x2e,
  1070. 0x51, 0x2c, 0x12, 0xc5, 0x05, 0x42, 0x32, 0x5c, 0x2c, 0xc9, 0xf9, 0x29, 0xa9, 0x12, 0x8c, 0x0a,
  1071. 0x8c, 0x1a, 0xcc, 0x4e, 0x1c, 0xaf, 0xee, 0xc9, 0x83, 0xf9, 0x41, 0x60, 0x52, 0x48, 0x92, 0x8b,
  1072. 0x39, 0xb7, 0x38, 0x5d, 0x82, 0x49, 0x81, 0x51, 0x83, 0xd3, 0x89, 0xfd, 0xd5, 0x3d, 0x79, 0x10,
  1073. 0x37, 0x08, 0x44, 0x08, 0xb9, 0x71, 0xb1, 0x80, 0x1c, 0x29, 0xc1, 0xac, 0xc0, 0xa8, 0xc1, 0x6d,
  1074. 0xa4, 0xa1, 0x87, 0xec, 0x6c, 0x3d, 0xac, 0x76, 0xe9, 0xb9, 0x24, 0x96, 0x24, 0x42, 0xac, 0x00,
  1075. 0xa9, 0x0b, 0x02, 0x93, 0x52, 0x6c, 0x5c, 0x2c, 0x20, 0x71, 0x24, 0xa7, 0x3b, 0x16, 0xa5, 0x26,
  1076. 0x62, 0x75, 0x3a, 0xb2, 0x04, 0xad, 0x9d, 0x8e, 0x6a, 0x17, 0x5e, 0xa7, 0x1b, 0x6d, 0x67, 0xe4,
  1077. 0x62, 0x87, 0x6a, 0x13, 0x0a, 0xe5, 0xe2, 0xca, 0x81, 0xfb, 0x5a, 0x48, 0x89, 0x60, 0xb0, 0x14,
  1078. 0x4a, 0x29, 0x13, 0x11, 0x74, 0x20, 0x63, 0x13, 0xe1, 0x2e, 0xc2, 0x61, 0x2c, 0x4a, 0xb8, 0xe1,
  1079. 0x30, 0x16, 0xd5, 0x5b, 0x4e, 0x32, 0x27, 0x1e, 0xc9, 0x31, 0x5e, 0x78, 0x24, 0xc7, 0xf8, 0xe0,
  1080. 0x91, 0x1c, 0xe3, 0x84, 0xc7, 0x72, 0x0c, 0x17, 0x1e, 0xcb, 0x31, 0xdc, 0x78, 0x2c, 0xc7, 0x10,
  1081. 0xc5, 0x54, 0x66, 0x90, 0xc4, 0x06, 0x4e, 0x54, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x34,
  1082. 0xdf, 0xe6, 0xc2, 0xa5, 0x02, 0x00, 0x00,
  1083. }