Broadcast.pb.go 51 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087
  1. // Code generated by protoc-gen-gogo. DO NOT EDIT.
  2. // source: v0/Broadcast.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 BroadcastSendNoticeMsgReq struct {
  19. // 场景常数 1: 全局 2: 一级分区 3: 二级分区 4: 房间
  20. SceneKey string `protobuf:"bytes,1,opt,name=scene_key,json=sceneKey,proto3" json:"scene_key"`
  21. // 场景值(一级分区号, 二级分区号, 房间号; 当scene_key = 1时此值被忽略)
  22. SceneValue string `protobuf:"bytes,2,opt,name=scene_value,json=sceneValue,proto3" json:"scene_value"`
  23. //
  24. Msg *BroadcastSendNoticeMsgReq_MSG `protobuf:"bytes,3,opt,name=msg" json:"msg"`
  25. }
  26. func (m *BroadcastSendNoticeMsgReq) Reset() { *m = BroadcastSendNoticeMsgReq{} }
  27. func (m *BroadcastSendNoticeMsgReq) String() string { return proto.CompactTextString(m) }
  28. func (*BroadcastSendNoticeMsgReq) ProtoMessage() {}
  29. func (*BroadcastSendNoticeMsgReq) Descriptor() ([]byte, []int) {
  30. return fileDescriptor_Broadcast_32ece6a4f6b2cbe4, []int{0}
  31. }
  32. func (m *BroadcastSendNoticeMsgReq) XXX_Unmarshal(b []byte) error {
  33. return m.Unmarshal(b)
  34. }
  35. func (m *BroadcastSendNoticeMsgReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  36. if deterministic {
  37. return xxx_messageInfo_BroadcastSendNoticeMsgReq.Marshal(b, m, deterministic)
  38. } else {
  39. b = b[:cap(b)]
  40. n, err := m.MarshalTo(b)
  41. if err != nil {
  42. return nil, err
  43. }
  44. return b[:n], nil
  45. }
  46. }
  47. func (dst *BroadcastSendNoticeMsgReq) XXX_Merge(src proto.Message) {
  48. xxx_messageInfo_BroadcastSendNoticeMsgReq.Merge(dst, src)
  49. }
  50. func (m *BroadcastSendNoticeMsgReq) XXX_Size() int {
  51. return m.Size()
  52. }
  53. func (m *BroadcastSendNoticeMsgReq) XXX_DiscardUnknown() {
  54. xxx_messageInfo_BroadcastSendNoticeMsgReq.DiscardUnknown(m)
  55. }
  56. var xxx_messageInfo_BroadcastSendNoticeMsgReq proto.InternalMessageInfo
  57. func (m *BroadcastSendNoticeMsgReq) GetSceneKey() string {
  58. if m != nil {
  59. return m.SceneKey
  60. }
  61. return ""
  62. }
  63. func (m *BroadcastSendNoticeMsgReq) GetSceneValue() string {
  64. if m != nil {
  65. return m.SceneValue
  66. }
  67. return ""
  68. }
  69. func (m *BroadcastSendNoticeMsgReq) GetMsg() *BroadcastSendNoticeMsgReq_MSG {
  70. if m != nil {
  71. return m.Msg
  72. }
  73. return nil
  74. }
  75. type BroadcastSendNoticeMsgReq_FullData struct {
  76. // 头图
  77. HeadIcon string `protobuf:"bytes,1,opt,name=head_icon,json=headIcon,proto3" json:"head_icon"`
  78. // 尾图
  79. TailIcon string `protobuf:"bytes,2,opt,name=tail_icon,json=tailIcon,proto3" json:"tail_icon"`
  80. // 序列帧格式头图
  81. HeadIconFa string `protobuf:"bytes,3,opt,name=head_icon_fa,json=headIconFa,proto3" json:"head_icon_fa"`
  82. // 序列帧格式尾图
  83. TailIconFa string `protobuf:"bytes,4,opt,name=tail_icon_fa,json=tailIconFa,proto3" json:"tail_icon_fa"`
  84. // 背景颜色
  85. Background string `protobuf:"bytes,5,opt,name=background,proto3" json:"background"`
  86. // 普通文字颜色
  87. Color string `protobuf:"bytes,6,opt,name=color,proto3" json:"color"`
  88. // 高亮文字颜色
  89. Highlight string `protobuf:"bytes,7,opt,name=highlight,proto3" json:"highlight"`
  90. // 持续时间
  91. Time int64 `protobuf:"varint,8,opt,name=time,proto3" json:"time"`
  92. }
  93. func (m *BroadcastSendNoticeMsgReq_FullData) Reset() { *m = BroadcastSendNoticeMsgReq_FullData{} }
  94. func (m *BroadcastSendNoticeMsgReq_FullData) String() string { return proto.CompactTextString(m) }
  95. func (*BroadcastSendNoticeMsgReq_FullData) ProtoMessage() {}
  96. func (*BroadcastSendNoticeMsgReq_FullData) Descriptor() ([]byte, []int) {
  97. return fileDescriptor_Broadcast_32ece6a4f6b2cbe4, []int{0, 0}
  98. }
  99. func (m *BroadcastSendNoticeMsgReq_FullData) XXX_Unmarshal(b []byte) error {
  100. return m.Unmarshal(b)
  101. }
  102. func (m *BroadcastSendNoticeMsgReq_FullData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  103. if deterministic {
  104. return xxx_messageInfo_BroadcastSendNoticeMsgReq_FullData.Marshal(b, m, deterministic)
  105. } else {
  106. b = b[:cap(b)]
  107. n, err := m.MarshalTo(b)
  108. if err != nil {
  109. return nil, err
  110. }
  111. return b[:n], nil
  112. }
  113. }
  114. func (dst *BroadcastSendNoticeMsgReq_FullData) XXX_Merge(src proto.Message) {
  115. xxx_messageInfo_BroadcastSendNoticeMsgReq_FullData.Merge(dst, src)
  116. }
  117. func (m *BroadcastSendNoticeMsgReq_FullData) XXX_Size() int {
  118. return m.Size()
  119. }
  120. func (m *BroadcastSendNoticeMsgReq_FullData) XXX_DiscardUnknown() {
  121. xxx_messageInfo_BroadcastSendNoticeMsgReq_FullData.DiscardUnknown(m)
  122. }
  123. var xxx_messageInfo_BroadcastSendNoticeMsgReq_FullData proto.InternalMessageInfo
  124. func (m *BroadcastSendNoticeMsgReq_FullData) GetHeadIcon() string {
  125. if m != nil {
  126. return m.HeadIcon
  127. }
  128. return ""
  129. }
  130. func (m *BroadcastSendNoticeMsgReq_FullData) GetTailIcon() string {
  131. if m != nil {
  132. return m.TailIcon
  133. }
  134. return ""
  135. }
  136. func (m *BroadcastSendNoticeMsgReq_FullData) GetHeadIconFa() string {
  137. if m != nil {
  138. return m.HeadIconFa
  139. }
  140. return ""
  141. }
  142. func (m *BroadcastSendNoticeMsgReq_FullData) GetTailIconFa() string {
  143. if m != nil {
  144. return m.TailIconFa
  145. }
  146. return ""
  147. }
  148. func (m *BroadcastSendNoticeMsgReq_FullData) GetBackground() string {
  149. if m != nil {
  150. return m.Background
  151. }
  152. return ""
  153. }
  154. func (m *BroadcastSendNoticeMsgReq_FullData) GetColor() string {
  155. if m != nil {
  156. return m.Color
  157. }
  158. return ""
  159. }
  160. func (m *BroadcastSendNoticeMsgReq_FullData) GetHighlight() string {
  161. if m != nil {
  162. return m.Highlight
  163. }
  164. return ""
  165. }
  166. func (m *BroadcastSendNoticeMsgReq_FullData) GetTime() int64 {
  167. if m != nil {
  168. return m.Time
  169. }
  170. return 0
  171. }
  172. type BroadcastSendNoticeMsgReq_HalfData struct {
  173. // 头图
  174. HeadIcon string `protobuf:"bytes,1,opt,name=head_icon,json=headIcon,proto3" json:"head_icon"`
  175. // 尾图
  176. TailIcon string `protobuf:"bytes,2,opt,name=tail_icon,json=tailIcon,proto3" json:"tail_icon"`
  177. // 背景颜色
  178. Background string `protobuf:"bytes,3,opt,name=background,proto3" json:"background"`
  179. // 普通文字颜色
  180. Color string `protobuf:"bytes,4,opt,name=color,proto3" json:"color"`
  181. // 高亮文字颜色
  182. Highlight string `protobuf:"bytes,5,opt,name=highlight,proto3" json:"highlight"`
  183. // 持续时间
  184. Time int64 `protobuf:"varint,6,opt,name=time,proto3" json:"time"`
  185. }
  186. func (m *BroadcastSendNoticeMsgReq_HalfData) Reset() { *m = BroadcastSendNoticeMsgReq_HalfData{} }
  187. func (m *BroadcastSendNoticeMsgReq_HalfData) String() string { return proto.CompactTextString(m) }
  188. func (*BroadcastSendNoticeMsgReq_HalfData) ProtoMessage() {}
  189. func (*BroadcastSendNoticeMsgReq_HalfData) Descriptor() ([]byte, []int) {
  190. return fileDescriptor_Broadcast_32ece6a4f6b2cbe4, []int{0, 1}
  191. }
  192. func (m *BroadcastSendNoticeMsgReq_HalfData) XXX_Unmarshal(b []byte) error {
  193. return m.Unmarshal(b)
  194. }
  195. func (m *BroadcastSendNoticeMsgReq_HalfData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  196. if deterministic {
  197. return xxx_messageInfo_BroadcastSendNoticeMsgReq_HalfData.Marshal(b, m, deterministic)
  198. } else {
  199. b = b[:cap(b)]
  200. n, err := m.MarshalTo(b)
  201. if err != nil {
  202. return nil, err
  203. }
  204. return b[:n], nil
  205. }
  206. }
  207. func (dst *BroadcastSendNoticeMsgReq_HalfData) XXX_Merge(src proto.Message) {
  208. xxx_messageInfo_BroadcastSendNoticeMsgReq_HalfData.Merge(dst, src)
  209. }
  210. func (m *BroadcastSendNoticeMsgReq_HalfData) XXX_Size() int {
  211. return m.Size()
  212. }
  213. func (m *BroadcastSendNoticeMsgReq_HalfData) XXX_DiscardUnknown() {
  214. xxx_messageInfo_BroadcastSendNoticeMsgReq_HalfData.DiscardUnknown(m)
  215. }
  216. var xxx_messageInfo_BroadcastSendNoticeMsgReq_HalfData proto.InternalMessageInfo
  217. func (m *BroadcastSendNoticeMsgReq_HalfData) GetHeadIcon() string {
  218. if m != nil {
  219. return m.HeadIcon
  220. }
  221. return ""
  222. }
  223. func (m *BroadcastSendNoticeMsgReq_HalfData) GetTailIcon() string {
  224. if m != nil {
  225. return m.TailIcon
  226. }
  227. return ""
  228. }
  229. func (m *BroadcastSendNoticeMsgReq_HalfData) GetBackground() string {
  230. if m != nil {
  231. return m.Background
  232. }
  233. return ""
  234. }
  235. func (m *BroadcastSendNoticeMsgReq_HalfData) GetColor() string {
  236. if m != nil {
  237. return m.Color
  238. }
  239. return ""
  240. }
  241. func (m *BroadcastSendNoticeMsgReq_HalfData) GetHighlight() string {
  242. if m != nil {
  243. return m.Highlight
  244. }
  245. return ""
  246. }
  247. func (m *BroadcastSendNoticeMsgReq_HalfData) GetTime() int64 {
  248. if m != nil {
  249. return m.Time
  250. }
  251. return 0
  252. }
  253. type BroadcastSendNoticeMsgReq_MSG struct {
  254. //
  255. Roomid int64 `protobuf:"varint,1,opt,name=roomid,proto3" json:"roomid"`
  256. //
  257. MsgCommon string `protobuf:"bytes,2,opt,name=msg_common,json=msgCommon,proto3" json:"msg_common"`
  258. //
  259. MsgSelf string `protobuf:"bytes,3,opt,name=msg_self,json=msgSelf,proto3" json:"msg_self"`
  260. //
  261. LinkUrl string `protobuf:"bytes,4,opt,name=link_url,json=linkUrl,proto3" json:"link_url"`
  262. // 1-系统公告;2-小电视/摩天大楼抽奖公告; 3-总督抽奖公告;4-总督进场; 5-小电视/摩天大楼抽奖中奖公告; 6-高能公告
  263. MsgType int64 `protobuf:"varint,5,opt,name=msg_type,json=msgType,proto3" json:"msg_type"`
  264. //
  265. Full *BroadcastSendNoticeMsgReq_FullData `protobuf:"bytes,6,opt,name=full" json:"full"`
  266. //
  267. Half *BroadcastSendNoticeMsgReq_HalfData `protobuf:"bytes,7,opt,name=half" json:"half"`
  268. }
  269. func (m *BroadcastSendNoticeMsgReq_MSG) Reset() { *m = BroadcastSendNoticeMsgReq_MSG{} }
  270. func (m *BroadcastSendNoticeMsgReq_MSG) String() string { return proto.CompactTextString(m) }
  271. func (*BroadcastSendNoticeMsgReq_MSG) ProtoMessage() {}
  272. func (*BroadcastSendNoticeMsgReq_MSG) Descriptor() ([]byte, []int) {
  273. return fileDescriptor_Broadcast_32ece6a4f6b2cbe4, []int{0, 2}
  274. }
  275. func (m *BroadcastSendNoticeMsgReq_MSG) XXX_Unmarshal(b []byte) error {
  276. return m.Unmarshal(b)
  277. }
  278. func (m *BroadcastSendNoticeMsgReq_MSG) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  279. if deterministic {
  280. return xxx_messageInfo_BroadcastSendNoticeMsgReq_MSG.Marshal(b, m, deterministic)
  281. } else {
  282. b = b[:cap(b)]
  283. n, err := m.MarshalTo(b)
  284. if err != nil {
  285. return nil, err
  286. }
  287. return b[:n], nil
  288. }
  289. }
  290. func (dst *BroadcastSendNoticeMsgReq_MSG) XXX_Merge(src proto.Message) {
  291. xxx_messageInfo_BroadcastSendNoticeMsgReq_MSG.Merge(dst, src)
  292. }
  293. func (m *BroadcastSendNoticeMsgReq_MSG) XXX_Size() int {
  294. return m.Size()
  295. }
  296. func (m *BroadcastSendNoticeMsgReq_MSG) XXX_DiscardUnknown() {
  297. xxx_messageInfo_BroadcastSendNoticeMsgReq_MSG.DiscardUnknown(m)
  298. }
  299. var xxx_messageInfo_BroadcastSendNoticeMsgReq_MSG proto.InternalMessageInfo
  300. func (m *BroadcastSendNoticeMsgReq_MSG) GetRoomid() int64 {
  301. if m != nil {
  302. return m.Roomid
  303. }
  304. return 0
  305. }
  306. func (m *BroadcastSendNoticeMsgReq_MSG) GetMsgCommon() string {
  307. if m != nil {
  308. return m.MsgCommon
  309. }
  310. return ""
  311. }
  312. func (m *BroadcastSendNoticeMsgReq_MSG) GetMsgSelf() string {
  313. if m != nil {
  314. return m.MsgSelf
  315. }
  316. return ""
  317. }
  318. func (m *BroadcastSendNoticeMsgReq_MSG) GetLinkUrl() string {
  319. if m != nil {
  320. return m.LinkUrl
  321. }
  322. return ""
  323. }
  324. func (m *BroadcastSendNoticeMsgReq_MSG) GetMsgType() int64 {
  325. if m != nil {
  326. return m.MsgType
  327. }
  328. return 0
  329. }
  330. func (m *BroadcastSendNoticeMsgReq_MSG) GetFull() *BroadcastSendNoticeMsgReq_FullData {
  331. if m != nil {
  332. return m.Full
  333. }
  334. return nil
  335. }
  336. func (m *BroadcastSendNoticeMsgReq_MSG) GetHalf() *BroadcastSendNoticeMsgReq_HalfData {
  337. if m != nil {
  338. return m.Half
  339. }
  340. return nil
  341. }
  342. type BroadcastSendNoticeMsgResp struct {
  343. //
  344. Code int64 `protobuf:"varint,1,opt,name=code,proto3" json:"code"`
  345. //
  346. Msg string `protobuf:"bytes,2,opt,name=msg,proto3" json:"msg"`
  347. //
  348. Data []int64 `protobuf:"varint,3,rep,packed,name=data" json:"data"`
  349. }
  350. func (m *BroadcastSendNoticeMsgResp) Reset() { *m = BroadcastSendNoticeMsgResp{} }
  351. func (m *BroadcastSendNoticeMsgResp) String() string { return proto.CompactTextString(m) }
  352. func (*BroadcastSendNoticeMsgResp) ProtoMessage() {}
  353. func (*BroadcastSendNoticeMsgResp) Descriptor() ([]byte, []int) {
  354. return fileDescriptor_Broadcast_32ece6a4f6b2cbe4, []int{1}
  355. }
  356. func (m *BroadcastSendNoticeMsgResp) XXX_Unmarshal(b []byte) error {
  357. return m.Unmarshal(b)
  358. }
  359. func (m *BroadcastSendNoticeMsgResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  360. if deterministic {
  361. return xxx_messageInfo_BroadcastSendNoticeMsgResp.Marshal(b, m, deterministic)
  362. } else {
  363. b = b[:cap(b)]
  364. n, err := m.MarshalTo(b)
  365. if err != nil {
  366. return nil, err
  367. }
  368. return b[:n], nil
  369. }
  370. }
  371. func (dst *BroadcastSendNoticeMsgResp) XXX_Merge(src proto.Message) {
  372. xxx_messageInfo_BroadcastSendNoticeMsgResp.Merge(dst, src)
  373. }
  374. func (m *BroadcastSendNoticeMsgResp) XXX_Size() int {
  375. return m.Size()
  376. }
  377. func (m *BroadcastSendNoticeMsgResp) XXX_DiscardUnknown() {
  378. xxx_messageInfo_BroadcastSendNoticeMsgResp.DiscardUnknown(m)
  379. }
  380. var xxx_messageInfo_BroadcastSendNoticeMsgResp proto.InternalMessageInfo
  381. func (m *BroadcastSendNoticeMsgResp) GetCode() int64 {
  382. if m != nil {
  383. return m.Code
  384. }
  385. return 0
  386. }
  387. func (m *BroadcastSendNoticeMsgResp) GetMsg() string {
  388. if m != nil {
  389. return m.Msg
  390. }
  391. return ""
  392. }
  393. func (m *BroadcastSendNoticeMsgResp) GetData() []int64 {
  394. if m != nil {
  395. return m.Data
  396. }
  397. return nil
  398. }
  399. func init() {
  400. proto.RegisterType((*BroadcastSendNoticeMsgReq)(nil), "rc.v0.BroadcastSendNoticeMsgReq")
  401. proto.RegisterType((*BroadcastSendNoticeMsgReq_FullData)(nil), "rc.v0.BroadcastSendNoticeMsgReq.FullData")
  402. proto.RegisterType((*BroadcastSendNoticeMsgReq_HalfData)(nil), "rc.v0.BroadcastSendNoticeMsgReq.HalfData")
  403. proto.RegisterType((*BroadcastSendNoticeMsgReq_MSG)(nil), "rc.v0.BroadcastSendNoticeMsgReq.MSG")
  404. proto.RegisterType((*BroadcastSendNoticeMsgResp)(nil), "rc.v0.BroadcastSendNoticeMsgResp")
  405. }
  406. func (m *BroadcastSendNoticeMsgReq) Marshal() (dAtA []byte, err error) {
  407. size := m.Size()
  408. dAtA = make([]byte, size)
  409. n, err := m.MarshalTo(dAtA)
  410. if err != nil {
  411. return nil, err
  412. }
  413. return dAtA[:n], nil
  414. }
  415. func (m *BroadcastSendNoticeMsgReq) MarshalTo(dAtA []byte) (int, error) {
  416. var i int
  417. _ = i
  418. var l int
  419. _ = l
  420. if len(m.SceneKey) > 0 {
  421. dAtA[i] = 0xa
  422. i++
  423. i = encodeVarintBroadcast(dAtA, i, uint64(len(m.SceneKey)))
  424. i += copy(dAtA[i:], m.SceneKey)
  425. }
  426. if len(m.SceneValue) > 0 {
  427. dAtA[i] = 0x12
  428. i++
  429. i = encodeVarintBroadcast(dAtA, i, uint64(len(m.SceneValue)))
  430. i += copy(dAtA[i:], m.SceneValue)
  431. }
  432. if m.Msg != nil {
  433. dAtA[i] = 0x1a
  434. i++
  435. i = encodeVarintBroadcast(dAtA, i, uint64(m.Msg.Size()))
  436. n1, err := m.Msg.MarshalTo(dAtA[i:])
  437. if err != nil {
  438. return 0, err
  439. }
  440. i += n1
  441. }
  442. return i, nil
  443. }
  444. func (m *BroadcastSendNoticeMsgReq_FullData) Marshal() (dAtA []byte, err error) {
  445. size := m.Size()
  446. dAtA = make([]byte, size)
  447. n, err := m.MarshalTo(dAtA)
  448. if err != nil {
  449. return nil, err
  450. }
  451. return dAtA[:n], nil
  452. }
  453. func (m *BroadcastSendNoticeMsgReq_FullData) MarshalTo(dAtA []byte) (int, error) {
  454. var i int
  455. _ = i
  456. var l int
  457. _ = l
  458. if len(m.HeadIcon) > 0 {
  459. dAtA[i] = 0xa
  460. i++
  461. i = encodeVarintBroadcast(dAtA, i, uint64(len(m.HeadIcon)))
  462. i += copy(dAtA[i:], m.HeadIcon)
  463. }
  464. if len(m.TailIcon) > 0 {
  465. dAtA[i] = 0x12
  466. i++
  467. i = encodeVarintBroadcast(dAtA, i, uint64(len(m.TailIcon)))
  468. i += copy(dAtA[i:], m.TailIcon)
  469. }
  470. if len(m.HeadIconFa) > 0 {
  471. dAtA[i] = 0x1a
  472. i++
  473. i = encodeVarintBroadcast(dAtA, i, uint64(len(m.HeadIconFa)))
  474. i += copy(dAtA[i:], m.HeadIconFa)
  475. }
  476. if len(m.TailIconFa) > 0 {
  477. dAtA[i] = 0x22
  478. i++
  479. i = encodeVarintBroadcast(dAtA, i, uint64(len(m.TailIconFa)))
  480. i += copy(dAtA[i:], m.TailIconFa)
  481. }
  482. if len(m.Background) > 0 {
  483. dAtA[i] = 0x2a
  484. i++
  485. i = encodeVarintBroadcast(dAtA, i, uint64(len(m.Background)))
  486. i += copy(dAtA[i:], m.Background)
  487. }
  488. if len(m.Color) > 0 {
  489. dAtA[i] = 0x32
  490. i++
  491. i = encodeVarintBroadcast(dAtA, i, uint64(len(m.Color)))
  492. i += copy(dAtA[i:], m.Color)
  493. }
  494. if len(m.Highlight) > 0 {
  495. dAtA[i] = 0x3a
  496. i++
  497. i = encodeVarintBroadcast(dAtA, i, uint64(len(m.Highlight)))
  498. i += copy(dAtA[i:], m.Highlight)
  499. }
  500. if m.Time != 0 {
  501. dAtA[i] = 0x40
  502. i++
  503. i = encodeVarintBroadcast(dAtA, i, uint64(m.Time))
  504. }
  505. return i, nil
  506. }
  507. func (m *BroadcastSendNoticeMsgReq_HalfData) Marshal() (dAtA []byte, err error) {
  508. size := m.Size()
  509. dAtA = make([]byte, size)
  510. n, err := m.MarshalTo(dAtA)
  511. if err != nil {
  512. return nil, err
  513. }
  514. return dAtA[:n], nil
  515. }
  516. func (m *BroadcastSendNoticeMsgReq_HalfData) MarshalTo(dAtA []byte) (int, error) {
  517. var i int
  518. _ = i
  519. var l int
  520. _ = l
  521. if len(m.HeadIcon) > 0 {
  522. dAtA[i] = 0xa
  523. i++
  524. i = encodeVarintBroadcast(dAtA, i, uint64(len(m.HeadIcon)))
  525. i += copy(dAtA[i:], m.HeadIcon)
  526. }
  527. if len(m.TailIcon) > 0 {
  528. dAtA[i] = 0x12
  529. i++
  530. i = encodeVarintBroadcast(dAtA, i, uint64(len(m.TailIcon)))
  531. i += copy(dAtA[i:], m.TailIcon)
  532. }
  533. if len(m.Background) > 0 {
  534. dAtA[i] = 0x1a
  535. i++
  536. i = encodeVarintBroadcast(dAtA, i, uint64(len(m.Background)))
  537. i += copy(dAtA[i:], m.Background)
  538. }
  539. if len(m.Color) > 0 {
  540. dAtA[i] = 0x22
  541. i++
  542. i = encodeVarintBroadcast(dAtA, i, uint64(len(m.Color)))
  543. i += copy(dAtA[i:], m.Color)
  544. }
  545. if len(m.Highlight) > 0 {
  546. dAtA[i] = 0x2a
  547. i++
  548. i = encodeVarintBroadcast(dAtA, i, uint64(len(m.Highlight)))
  549. i += copy(dAtA[i:], m.Highlight)
  550. }
  551. if m.Time != 0 {
  552. dAtA[i] = 0x30
  553. i++
  554. i = encodeVarintBroadcast(dAtA, i, uint64(m.Time))
  555. }
  556. return i, nil
  557. }
  558. func (m *BroadcastSendNoticeMsgReq_MSG) Marshal() (dAtA []byte, err error) {
  559. size := m.Size()
  560. dAtA = make([]byte, size)
  561. n, err := m.MarshalTo(dAtA)
  562. if err != nil {
  563. return nil, err
  564. }
  565. return dAtA[:n], nil
  566. }
  567. func (m *BroadcastSendNoticeMsgReq_MSG) MarshalTo(dAtA []byte) (int, error) {
  568. var i int
  569. _ = i
  570. var l int
  571. _ = l
  572. if m.Roomid != 0 {
  573. dAtA[i] = 0x8
  574. i++
  575. i = encodeVarintBroadcast(dAtA, i, uint64(m.Roomid))
  576. }
  577. if len(m.MsgCommon) > 0 {
  578. dAtA[i] = 0x12
  579. i++
  580. i = encodeVarintBroadcast(dAtA, i, uint64(len(m.MsgCommon)))
  581. i += copy(dAtA[i:], m.MsgCommon)
  582. }
  583. if len(m.MsgSelf) > 0 {
  584. dAtA[i] = 0x1a
  585. i++
  586. i = encodeVarintBroadcast(dAtA, i, uint64(len(m.MsgSelf)))
  587. i += copy(dAtA[i:], m.MsgSelf)
  588. }
  589. if len(m.LinkUrl) > 0 {
  590. dAtA[i] = 0x22
  591. i++
  592. i = encodeVarintBroadcast(dAtA, i, uint64(len(m.LinkUrl)))
  593. i += copy(dAtA[i:], m.LinkUrl)
  594. }
  595. if m.MsgType != 0 {
  596. dAtA[i] = 0x28
  597. i++
  598. i = encodeVarintBroadcast(dAtA, i, uint64(m.MsgType))
  599. }
  600. if m.Full != nil {
  601. dAtA[i] = 0x32
  602. i++
  603. i = encodeVarintBroadcast(dAtA, i, uint64(m.Full.Size()))
  604. n2, err := m.Full.MarshalTo(dAtA[i:])
  605. if err != nil {
  606. return 0, err
  607. }
  608. i += n2
  609. }
  610. if m.Half != nil {
  611. dAtA[i] = 0x3a
  612. i++
  613. i = encodeVarintBroadcast(dAtA, i, uint64(m.Half.Size()))
  614. n3, err := m.Half.MarshalTo(dAtA[i:])
  615. if err != nil {
  616. return 0, err
  617. }
  618. i += n3
  619. }
  620. return i, nil
  621. }
  622. func (m *BroadcastSendNoticeMsgResp) Marshal() (dAtA []byte, err error) {
  623. size := m.Size()
  624. dAtA = make([]byte, size)
  625. n, err := m.MarshalTo(dAtA)
  626. if err != nil {
  627. return nil, err
  628. }
  629. return dAtA[:n], nil
  630. }
  631. func (m *BroadcastSendNoticeMsgResp) MarshalTo(dAtA []byte) (int, error) {
  632. var i int
  633. _ = i
  634. var l int
  635. _ = l
  636. if m.Code != 0 {
  637. dAtA[i] = 0x8
  638. i++
  639. i = encodeVarintBroadcast(dAtA, i, uint64(m.Code))
  640. }
  641. if len(m.Msg) > 0 {
  642. dAtA[i] = 0x12
  643. i++
  644. i = encodeVarintBroadcast(dAtA, i, uint64(len(m.Msg)))
  645. i += copy(dAtA[i:], m.Msg)
  646. }
  647. if len(m.Data) > 0 {
  648. dAtA5 := make([]byte, len(m.Data)*10)
  649. var j4 int
  650. for _, num1 := range m.Data {
  651. num := uint64(num1)
  652. for num >= 1<<7 {
  653. dAtA5[j4] = uint8(uint64(num)&0x7f | 0x80)
  654. num >>= 7
  655. j4++
  656. }
  657. dAtA5[j4] = uint8(num)
  658. j4++
  659. }
  660. dAtA[i] = 0x1a
  661. i++
  662. i = encodeVarintBroadcast(dAtA, i, uint64(j4))
  663. i += copy(dAtA[i:], dAtA5[:j4])
  664. }
  665. return i, nil
  666. }
  667. func encodeVarintBroadcast(dAtA []byte, offset int, v uint64) int {
  668. for v >= 1<<7 {
  669. dAtA[offset] = uint8(v&0x7f | 0x80)
  670. v >>= 7
  671. offset++
  672. }
  673. dAtA[offset] = uint8(v)
  674. return offset + 1
  675. }
  676. func (m *BroadcastSendNoticeMsgReq) Size() (n int) {
  677. if m == nil {
  678. return 0
  679. }
  680. var l int
  681. _ = l
  682. l = len(m.SceneKey)
  683. if l > 0 {
  684. n += 1 + l + sovBroadcast(uint64(l))
  685. }
  686. l = len(m.SceneValue)
  687. if l > 0 {
  688. n += 1 + l + sovBroadcast(uint64(l))
  689. }
  690. if m.Msg != nil {
  691. l = m.Msg.Size()
  692. n += 1 + l + sovBroadcast(uint64(l))
  693. }
  694. return n
  695. }
  696. func (m *BroadcastSendNoticeMsgReq_FullData) Size() (n int) {
  697. if m == nil {
  698. return 0
  699. }
  700. var l int
  701. _ = l
  702. l = len(m.HeadIcon)
  703. if l > 0 {
  704. n += 1 + l + sovBroadcast(uint64(l))
  705. }
  706. l = len(m.TailIcon)
  707. if l > 0 {
  708. n += 1 + l + sovBroadcast(uint64(l))
  709. }
  710. l = len(m.HeadIconFa)
  711. if l > 0 {
  712. n += 1 + l + sovBroadcast(uint64(l))
  713. }
  714. l = len(m.TailIconFa)
  715. if l > 0 {
  716. n += 1 + l + sovBroadcast(uint64(l))
  717. }
  718. l = len(m.Background)
  719. if l > 0 {
  720. n += 1 + l + sovBroadcast(uint64(l))
  721. }
  722. l = len(m.Color)
  723. if l > 0 {
  724. n += 1 + l + sovBroadcast(uint64(l))
  725. }
  726. l = len(m.Highlight)
  727. if l > 0 {
  728. n += 1 + l + sovBroadcast(uint64(l))
  729. }
  730. if m.Time != 0 {
  731. n += 1 + sovBroadcast(uint64(m.Time))
  732. }
  733. return n
  734. }
  735. func (m *BroadcastSendNoticeMsgReq_HalfData) Size() (n int) {
  736. if m == nil {
  737. return 0
  738. }
  739. var l int
  740. _ = l
  741. l = len(m.HeadIcon)
  742. if l > 0 {
  743. n += 1 + l + sovBroadcast(uint64(l))
  744. }
  745. l = len(m.TailIcon)
  746. if l > 0 {
  747. n += 1 + l + sovBroadcast(uint64(l))
  748. }
  749. l = len(m.Background)
  750. if l > 0 {
  751. n += 1 + l + sovBroadcast(uint64(l))
  752. }
  753. l = len(m.Color)
  754. if l > 0 {
  755. n += 1 + l + sovBroadcast(uint64(l))
  756. }
  757. l = len(m.Highlight)
  758. if l > 0 {
  759. n += 1 + l + sovBroadcast(uint64(l))
  760. }
  761. if m.Time != 0 {
  762. n += 1 + sovBroadcast(uint64(m.Time))
  763. }
  764. return n
  765. }
  766. func (m *BroadcastSendNoticeMsgReq_MSG) Size() (n int) {
  767. if m == nil {
  768. return 0
  769. }
  770. var l int
  771. _ = l
  772. if m.Roomid != 0 {
  773. n += 1 + sovBroadcast(uint64(m.Roomid))
  774. }
  775. l = len(m.MsgCommon)
  776. if l > 0 {
  777. n += 1 + l + sovBroadcast(uint64(l))
  778. }
  779. l = len(m.MsgSelf)
  780. if l > 0 {
  781. n += 1 + l + sovBroadcast(uint64(l))
  782. }
  783. l = len(m.LinkUrl)
  784. if l > 0 {
  785. n += 1 + l + sovBroadcast(uint64(l))
  786. }
  787. if m.MsgType != 0 {
  788. n += 1 + sovBroadcast(uint64(m.MsgType))
  789. }
  790. if m.Full != nil {
  791. l = m.Full.Size()
  792. n += 1 + l + sovBroadcast(uint64(l))
  793. }
  794. if m.Half != nil {
  795. l = m.Half.Size()
  796. n += 1 + l + sovBroadcast(uint64(l))
  797. }
  798. return n
  799. }
  800. func (m *BroadcastSendNoticeMsgResp) Size() (n int) {
  801. if m == nil {
  802. return 0
  803. }
  804. var l int
  805. _ = l
  806. if m.Code != 0 {
  807. n += 1 + sovBroadcast(uint64(m.Code))
  808. }
  809. l = len(m.Msg)
  810. if l > 0 {
  811. n += 1 + l + sovBroadcast(uint64(l))
  812. }
  813. if len(m.Data) > 0 {
  814. l = 0
  815. for _, e := range m.Data {
  816. l += sovBroadcast(uint64(e))
  817. }
  818. n += 1 + sovBroadcast(uint64(l)) + l
  819. }
  820. return n
  821. }
  822. func sovBroadcast(x uint64) (n int) {
  823. for {
  824. n++
  825. x >>= 7
  826. if x == 0 {
  827. break
  828. }
  829. }
  830. return n
  831. }
  832. func sozBroadcast(x uint64) (n int) {
  833. return sovBroadcast(uint64((x << 1) ^ uint64((int64(x) >> 63))))
  834. }
  835. func (m *BroadcastSendNoticeMsgReq) Unmarshal(dAtA []byte) error {
  836. l := len(dAtA)
  837. iNdEx := 0
  838. for iNdEx < l {
  839. preIndex := iNdEx
  840. var wire uint64
  841. for shift := uint(0); ; shift += 7 {
  842. if shift >= 64 {
  843. return ErrIntOverflowBroadcast
  844. }
  845. if iNdEx >= l {
  846. return io.ErrUnexpectedEOF
  847. }
  848. b := dAtA[iNdEx]
  849. iNdEx++
  850. wire |= (uint64(b) & 0x7F) << shift
  851. if b < 0x80 {
  852. break
  853. }
  854. }
  855. fieldNum := int32(wire >> 3)
  856. wireType := int(wire & 0x7)
  857. if wireType == 4 {
  858. return fmt.Errorf("proto: BroadcastSendNoticeMsgReq: wiretype end group for non-group")
  859. }
  860. if fieldNum <= 0 {
  861. return fmt.Errorf("proto: BroadcastSendNoticeMsgReq: illegal tag %d (wire type %d)", fieldNum, wire)
  862. }
  863. switch fieldNum {
  864. case 1:
  865. if wireType != 2 {
  866. return fmt.Errorf("proto: wrong wireType = %d for field SceneKey", wireType)
  867. }
  868. var stringLen uint64
  869. for shift := uint(0); ; shift += 7 {
  870. if shift >= 64 {
  871. return ErrIntOverflowBroadcast
  872. }
  873. if iNdEx >= l {
  874. return io.ErrUnexpectedEOF
  875. }
  876. b := dAtA[iNdEx]
  877. iNdEx++
  878. stringLen |= (uint64(b) & 0x7F) << shift
  879. if b < 0x80 {
  880. break
  881. }
  882. }
  883. intStringLen := int(stringLen)
  884. if intStringLen < 0 {
  885. return ErrInvalidLengthBroadcast
  886. }
  887. postIndex := iNdEx + intStringLen
  888. if postIndex > l {
  889. return io.ErrUnexpectedEOF
  890. }
  891. m.SceneKey = string(dAtA[iNdEx:postIndex])
  892. iNdEx = postIndex
  893. case 2:
  894. if wireType != 2 {
  895. return fmt.Errorf("proto: wrong wireType = %d for field SceneValue", wireType)
  896. }
  897. var stringLen uint64
  898. for shift := uint(0); ; shift += 7 {
  899. if shift >= 64 {
  900. return ErrIntOverflowBroadcast
  901. }
  902. if iNdEx >= l {
  903. return io.ErrUnexpectedEOF
  904. }
  905. b := dAtA[iNdEx]
  906. iNdEx++
  907. stringLen |= (uint64(b) & 0x7F) << shift
  908. if b < 0x80 {
  909. break
  910. }
  911. }
  912. intStringLen := int(stringLen)
  913. if intStringLen < 0 {
  914. return ErrInvalidLengthBroadcast
  915. }
  916. postIndex := iNdEx + intStringLen
  917. if postIndex > l {
  918. return io.ErrUnexpectedEOF
  919. }
  920. m.SceneValue = string(dAtA[iNdEx:postIndex])
  921. iNdEx = postIndex
  922. case 3:
  923. if wireType != 2 {
  924. return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
  925. }
  926. var msglen int
  927. for shift := uint(0); ; shift += 7 {
  928. if shift >= 64 {
  929. return ErrIntOverflowBroadcast
  930. }
  931. if iNdEx >= l {
  932. return io.ErrUnexpectedEOF
  933. }
  934. b := dAtA[iNdEx]
  935. iNdEx++
  936. msglen |= (int(b) & 0x7F) << shift
  937. if b < 0x80 {
  938. break
  939. }
  940. }
  941. if msglen < 0 {
  942. return ErrInvalidLengthBroadcast
  943. }
  944. postIndex := iNdEx + msglen
  945. if postIndex > l {
  946. return io.ErrUnexpectedEOF
  947. }
  948. if m.Msg == nil {
  949. m.Msg = &BroadcastSendNoticeMsgReq_MSG{}
  950. }
  951. if err := m.Msg.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  952. return err
  953. }
  954. iNdEx = postIndex
  955. default:
  956. iNdEx = preIndex
  957. skippy, err := skipBroadcast(dAtA[iNdEx:])
  958. if err != nil {
  959. return err
  960. }
  961. if skippy < 0 {
  962. return ErrInvalidLengthBroadcast
  963. }
  964. if (iNdEx + skippy) > l {
  965. return io.ErrUnexpectedEOF
  966. }
  967. iNdEx += skippy
  968. }
  969. }
  970. if iNdEx > l {
  971. return io.ErrUnexpectedEOF
  972. }
  973. return nil
  974. }
  975. func (m *BroadcastSendNoticeMsgReq_FullData) Unmarshal(dAtA []byte) error {
  976. l := len(dAtA)
  977. iNdEx := 0
  978. for iNdEx < l {
  979. preIndex := iNdEx
  980. var wire uint64
  981. for shift := uint(0); ; shift += 7 {
  982. if shift >= 64 {
  983. return ErrIntOverflowBroadcast
  984. }
  985. if iNdEx >= l {
  986. return io.ErrUnexpectedEOF
  987. }
  988. b := dAtA[iNdEx]
  989. iNdEx++
  990. wire |= (uint64(b) & 0x7F) << shift
  991. if b < 0x80 {
  992. break
  993. }
  994. }
  995. fieldNum := int32(wire >> 3)
  996. wireType := int(wire & 0x7)
  997. if wireType == 4 {
  998. return fmt.Errorf("proto: FullData: wiretype end group for non-group")
  999. }
  1000. if fieldNum <= 0 {
  1001. return fmt.Errorf("proto: FullData: illegal tag %d (wire type %d)", fieldNum, wire)
  1002. }
  1003. switch fieldNum {
  1004. case 1:
  1005. if wireType != 2 {
  1006. return fmt.Errorf("proto: wrong wireType = %d for field HeadIcon", wireType)
  1007. }
  1008. var stringLen uint64
  1009. for shift := uint(0); ; shift += 7 {
  1010. if shift >= 64 {
  1011. return ErrIntOverflowBroadcast
  1012. }
  1013. if iNdEx >= l {
  1014. return io.ErrUnexpectedEOF
  1015. }
  1016. b := dAtA[iNdEx]
  1017. iNdEx++
  1018. stringLen |= (uint64(b) & 0x7F) << shift
  1019. if b < 0x80 {
  1020. break
  1021. }
  1022. }
  1023. intStringLen := int(stringLen)
  1024. if intStringLen < 0 {
  1025. return ErrInvalidLengthBroadcast
  1026. }
  1027. postIndex := iNdEx + intStringLen
  1028. if postIndex > l {
  1029. return io.ErrUnexpectedEOF
  1030. }
  1031. m.HeadIcon = string(dAtA[iNdEx:postIndex])
  1032. iNdEx = postIndex
  1033. case 2:
  1034. if wireType != 2 {
  1035. return fmt.Errorf("proto: wrong wireType = %d for field TailIcon", wireType)
  1036. }
  1037. var stringLen uint64
  1038. for shift := uint(0); ; shift += 7 {
  1039. if shift >= 64 {
  1040. return ErrIntOverflowBroadcast
  1041. }
  1042. if iNdEx >= l {
  1043. return io.ErrUnexpectedEOF
  1044. }
  1045. b := dAtA[iNdEx]
  1046. iNdEx++
  1047. stringLen |= (uint64(b) & 0x7F) << shift
  1048. if b < 0x80 {
  1049. break
  1050. }
  1051. }
  1052. intStringLen := int(stringLen)
  1053. if intStringLen < 0 {
  1054. return ErrInvalidLengthBroadcast
  1055. }
  1056. postIndex := iNdEx + intStringLen
  1057. if postIndex > l {
  1058. return io.ErrUnexpectedEOF
  1059. }
  1060. m.TailIcon = string(dAtA[iNdEx:postIndex])
  1061. iNdEx = postIndex
  1062. case 3:
  1063. if wireType != 2 {
  1064. return fmt.Errorf("proto: wrong wireType = %d for field HeadIconFa", wireType)
  1065. }
  1066. var stringLen uint64
  1067. for shift := uint(0); ; shift += 7 {
  1068. if shift >= 64 {
  1069. return ErrIntOverflowBroadcast
  1070. }
  1071. if iNdEx >= l {
  1072. return io.ErrUnexpectedEOF
  1073. }
  1074. b := dAtA[iNdEx]
  1075. iNdEx++
  1076. stringLen |= (uint64(b) & 0x7F) << shift
  1077. if b < 0x80 {
  1078. break
  1079. }
  1080. }
  1081. intStringLen := int(stringLen)
  1082. if intStringLen < 0 {
  1083. return ErrInvalidLengthBroadcast
  1084. }
  1085. postIndex := iNdEx + intStringLen
  1086. if postIndex > l {
  1087. return io.ErrUnexpectedEOF
  1088. }
  1089. m.HeadIconFa = string(dAtA[iNdEx:postIndex])
  1090. iNdEx = postIndex
  1091. case 4:
  1092. if wireType != 2 {
  1093. return fmt.Errorf("proto: wrong wireType = %d for field TailIconFa", wireType)
  1094. }
  1095. var stringLen uint64
  1096. for shift := uint(0); ; shift += 7 {
  1097. if shift >= 64 {
  1098. return ErrIntOverflowBroadcast
  1099. }
  1100. if iNdEx >= l {
  1101. return io.ErrUnexpectedEOF
  1102. }
  1103. b := dAtA[iNdEx]
  1104. iNdEx++
  1105. stringLen |= (uint64(b) & 0x7F) << shift
  1106. if b < 0x80 {
  1107. break
  1108. }
  1109. }
  1110. intStringLen := int(stringLen)
  1111. if intStringLen < 0 {
  1112. return ErrInvalidLengthBroadcast
  1113. }
  1114. postIndex := iNdEx + intStringLen
  1115. if postIndex > l {
  1116. return io.ErrUnexpectedEOF
  1117. }
  1118. m.TailIconFa = string(dAtA[iNdEx:postIndex])
  1119. iNdEx = postIndex
  1120. case 5:
  1121. if wireType != 2 {
  1122. return fmt.Errorf("proto: wrong wireType = %d for field Background", wireType)
  1123. }
  1124. var stringLen uint64
  1125. for shift := uint(0); ; shift += 7 {
  1126. if shift >= 64 {
  1127. return ErrIntOverflowBroadcast
  1128. }
  1129. if iNdEx >= l {
  1130. return io.ErrUnexpectedEOF
  1131. }
  1132. b := dAtA[iNdEx]
  1133. iNdEx++
  1134. stringLen |= (uint64(b) & 0x7F) << shift
  1135. if b < 0x80 {
  1136. break
  1137. }
  1138. }
  1139. intStringLen := int(stringLen)
  1140. if intStringLen < 0 {
  1141. return ErrInvalidLengthBroadcast
  1142. }
  1143. postIndex := iNdEx + intStringLen
  1144. if postIndex > l {
  1145. return io.ErrUnexpectedEOF
  1146. }
  1147. m.Background = string(dAtA[iNdEx:postIndex])
  1148. iNdEx = postIndex
  1149. case 6:
  1150. if wireType != 2 {
  1151. return fmt.Errorf("proto: wrong wireType = %d for field Color", wireType)
  1152. }
  1153. var stringLen uint64
  1154. for shift := uint(0); ; shift += 7 {
  1155. if shift >= 64 {
  1156. return ErrIntOverflowBroadcast
  1157. }
  1158. if iNdEx >= l {
  1159. return io.ErrUnexpectedEOF
  1160. }
  1161. b := dAtA[iNdEx]
  1162. iNdEx++
  1163. stringLen |= (uint64(b) & 0x7F) << shift
  1164. if b < 0x80 {
  1165. break
  1166. }
  1167. }
  1168. intStringLen := int(stringLen)
  1169. if intStringLen < 0 {
  1170. return ErrInvalidLengthBroadcast
  1171. }
  1172. postIndex := iNdEx + intStringLen
  1173. if postIndex > l {
  1174. return io.ErrUnexpectedEOF
  1175. }
  1176. m.Color = string(dAtA[iNdEx:postIndex])
  1177. iNdEx = postIndex
  1178. case 7:
  1179. if wireType != 2 {
  1180. return fmt.Errorf("proto: wrong wireType = %d for field Highlight", wireType)
  1181. }
  1182. var stringLen uint64
  1183. for shift := uint(0); ; shift += 7 {
  1184. if shift >= 64 {
  1185. return ErrIntOverflowBroadcast
  1186. }
  1187. if iNdEx >= l {
  1188. return io.ErrUnexpectedEOF
  1189. }
  1190. b := dAtA[iNdEx]
  1191. iNdEx++
  1192. stringLen |= (uint64(b) & 0x7F) << shift
  1193. if b < 0x80 {
  1194. break
  1195. }
  1196. }
  1197. intStringLen := int(stringLen)
  1198. if intStringLen < 0 {
  1199. return ErrInvalidLengthBroadcast
  1200. }
  1201. postIndex := iNdEx + intStringLen
  1202. if postIndex > l {
  1203. return io.ErrUnexpectedEOF
  1204. }
  1205. m.Highlight = string(dAtA[iNdEx:postIndex])
  1206. iNdEx = postIndex
  1207. case 8:
  1208. if wireType != 0 {
  1209. return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType)
  1210. }
  1211. m.Time = 0
  1212. for shift := uint(0); ; shift += 7 {
  1213. if shift >= 64 {
  1214. return ErrIntOverflowBroadcast
  1215. }
  1216. if iNdEx >= l {
  1217. return io.ErrUnexpectedEOF
  1218. }
  1219. b := dAtA[iNdEx]
  1220. iNdEx++
  1221. m.Time |= (int64(b) & 0x7F) << shift
  1222. if b < 0x80 {
  1223. break
  1224. }
  1225. }
  1226. default:
  1227. iNdEx = preIndex
  1228. skippy, err := skipBroadcast(dAtA[iNdEx:])
  1229. if err != nil {
  1230. return err
  1231. }
  1232. if skippy < 0 {
  1233. return ErrInvalidLengthBroadcast
  1234. }
  1235. if (iNdEx + skippy) > l {
  1236. return io.ErrUnexpectedEOF
  1237. }
  1238. iNdEx += skippy
  1239. }
  1240. }
  1241. if iNdEx > l {
  1242. return io.ErrUnexpectedEOF
  1243. }
  1244. return nil
  1245. }
  1246. func (m *BroadcastSendNoticeMsgReq_HalfData) Unmarshal(dAtA []byte) error {
  1247. l := len(dAtA)
  1248. iNdEx := 0
  1249. for iNdEx < l {
  1250. preIndex := iNdEx
  1251. var wire uint64
  1252. for shift := uint(0); ; shift += 7 {
  1253. if shift >= 64 {
  1254. return ErrIntOverflowBroadcast
  1255. }
  1256. if iNdEx >= l {
  1257. return io.ErrUnexpectedEOF
  1258. }
  1259. b := dAtA[iNdEx]
  1260. iNdEx++
  1261. wire |= (uint64(b) & 0x7F) << shift
  1262. if b < 0x80 {
  1263. break
  1264. }
  1265. }
  1266. fieldNum := int32(wire >> 3)
  1267. wireType := int(wire & 0x7)
  1268. if wireType == 4 {
  1269. return fmt.Errorf("proto: HalfData: wiretype end group for non-group")
  1270. }
  1271. if fieldNum <= 0 {
  1272. return fmt.Errorf("proto: HalfData: illegal tag %d (wire type %d)", fieldNum, wire)
  1273. }
  1274. switch fieldNum {
  1275. case 1:
  1276. if wireType != 2 {
  1277. return fmt.Errorf("proto: wrong wireType = %d for field HeadIcon", wireType)
  1278. }
  1279. var stringLen uint64
  1280. for shift := uint(0); ; shift += 7 {
  1281. if shift >= 64 {
  1282. return ErrIntOverflowBroadcast
  1283. }
  1284. if iNdEx >= l {
  1285. return io.ErrUnexpectedEOF
  1286. }
  1287. b := dAtA[iNdEx]
  1288. iNdEx++
  1289. stringLen |= (uint64(b) & 0x7F) << shift
  1290. if b < 0x80 {
  1291. break
  1292. }
  1293. }
  1294. intStringLen := int(stringLen)
  1295. if intStringLen < 0 {
  1296. return ErrInvalidLengthBroadcast
  1297. }
  1298. postIndex := iNdEx + intStringLen
  1299. if postIndex > l {
  1300. return io.ErrUnexpectedEOF
  1301. }
  1302. m.HeadIcon = string(dAtA[iNdEx:postIndex])
  1303. iNdEx = postIndex
  1304. case 2:
  1305. if wireType != 2 {
  1306. return fmt.Errorf("proto: wrong wireType = %d for field TailIcon", wireType)
  1307. }
  1308. var stringLen uint64
  1309. for shift := uint(0); ; shift += 7 {
  1310. if shift >= 64 {
  1311. return ErrIntOverflowBroadcast
  1312. }
  1313. if iNdEx >= l {
  1314. return io.ErrUnexpectedEOF
  1315. }
  1316. b := dAtA[iNdEx]
  1317. iNdEx++
  1318. stringLen |= (uint64(b) & 0x7F) << shift
  1319. if b < 0x80 {
  1320. break
  1321. }
  1322. }
  1323. intStringLen := int(stringLen)
  1324. if intStringLen < 0 {
  1325. return ErrInvalidLengthBroadcast
  1326. }
  1327. postIndex := iNdEx + intStringLen
  1328. if postIndex > l {
  1329. return io.ErrUnexpectedEOF
  1330. }
  1331. m.TailIcon = string(dAtA[iNdEx:postIndex])
  1332. iNdEx = postIndex
  1333. case 3:
  1334. if wireType != 2 {
  1335. return fmt.Errorf("proto: wrong wireType = %d for field Background", wireType)
  1336. }
  1337. var stringLen uint64
  1338. for shift := uint(0); ; shift += 7 {
  1339. if shift >= 64 {
  1340. return ErrIntOverflowBroadcast
  1341. }
  1342. if iNdEx >= l {
  1343. return io.ErrUnexpectedEOF
  1344. }
  1345. b := dAtA[iNdEx]
  1346. iNdEx++
  1347. stringLen |= (uint64(b) & 0x7F) << shift
  1348. if b < 0x80 {
  1349. break
  1350. }
  1351. }
  1352. intStringLen := int(stringLen)
  1353. if intStringLen < 0 {
  1354. return ErrInvalidLengthBroadcast
  1355. }
  1356. postIndex := iNdEx + intStringLen
  1357. if postIndex > l {
  1358. return io.ErrUnexpectedEOF
  1359. }
  1360. m.Background = string(dAtA[iNdEx:postIndex])
  1361. iNdEx = postIndex
  1362. case 4:
  1363. if wireType != 2 {
  1364. return fmt.Errorf("proto: wrong wireType = %d for field Color", wireType)
  1365. }
  1366. var stringLen uint64
  1367. for shift := uint(0); ; shift += 7 {
  1368. if shift >= 64 {
  1369. return ErrIntOverflowBroadcast
  1370. }
  1371. if iNdEx >= l {
  1372. return io.ErrUnexpectedEOF
  1373. }
  1374. b := dAtA[iNdEx]
  1375. iNdEx++
  1376. stringLen |= (uint64(b) & 0x7F) << shift
  1377. if b < 0x80 {
  1378. break
  1379. }
  1380. }
  1381. intStringLen := int(stringLen)
  1382. if intStringLen < 0 {
  1383. return ErrInvalidLengthBroadcast
  1384. }
  1385. postIndex := iNdEx + intStringLen
  1386. if postIndex > l {
  1387. return io.ErrUnexpectedEOF
  1388. }
  1389. m.Color = string(dAtA[iNdEx:postIndex])
  1390. iNdEx = postIndex
  1391. case 5:
  1392. if wireType != 2 {
  1393. return fmt.Errorf("proto: wrong wireType = %d for field Highlight", wireType)
  1394. }
  1395. var stringLen uint64
  1396. for shift := uint(0); ; shift += 7 {
  1397. if shift >= 64 {
  1398. return ErrIntOverflowBroadcast
  1399. }
  1400. if iNdEx >= l {
  1401. return io.ErrUnexpectedEOF
  1402. }
  1403. b := dAtA[iNdEx]
  1404. iNdEx++
  1405. stringLen |= (uint64(b) & 0x7F) << shift
  1406. if b < 0x80 {
  1407. break
  1408. }
  1409. }
  1410. intStringLen := int(stringLen)
  1411. if intStringLen < 0 {
  1412. return ErrInvalidLengthBroadcast
  1413. }
  1414. postIndex := iNdEx + intStringLen
  1415. if postIndex > l {
  1416. return io.ErrUnexpectedEOF
  1417. }
  1418. m.Highlight = string(dAtA[iNdEx:postIndex])
  1419. iNdEx = postIndex
  1420. case 6:
  1421. if wireType != 0 {
  1422. return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType)
  1423. }
  1424. m.Time = 0
  1425. for shift := uint(0); ; shift += 7 {
  1426. if shift >= 64 {
  1427. return ErrIntOverflowBroadcast
  1428. }
  1429. if iNdEx >= l {
  1430. return io.ErrUnexpectedEOF
  1431. }
  1432. b := dAtA[iNdEx]
  1433. iNdEx++
  1434. m.Time |= (int64(b) & 0x7F) << shift
  1435. if b < 0x80 {
  1436. break
  1437. }
  1438. }
  1439. default:
  1440. iNdEx = preIndex
  1441. skippy, err := skipBroadcast(dAtA[iNdEx:])
  1442. if err != nil {
  1443. return err
  1444. }
  1445. if skippy < 0 {
  1446. return ErrInvalidLengthBroadcast
  1447. }
  1448. if (iNdEx + skippy) > l {
  1449. return io.ErrUnexpectedEOF
  1450. }
  1451. iNdEx += skippy
  1452. }
  1453. }
  1454. if iNdEx > l {
  1455. return io.ErrUnexpectedEOF
  1456. }
  1457. return nil
  1458. }
  1459. func (m *BroadcastSendNoticeMsgReq_MSG) Unmarshal(dAtA []byte) error {
  1460. l := len(dAtA)
  1461. iNdEx := 0
  1462. for iNdEx < l {
  1463. preIndex := iNdEx
  1464. var wire uint64
  1465. for shift := uint(0); ; shift += 7 {
  1466. if shift >= 64 {
  1467. return ErrIntOverflowBroadcast
  1468. }
  1469. if iNdEx >= l {
  1470. return io.ErrUnexpectedEOF
  1471. }
  1472. b := dAtA[iNdEx]
  1473. iNdEx++
  1474. wire |= (uint64(b) & 0x7F) << shift
  1475. if b < 0x80 {
  1476. break
  1477. }
  1478. }
  1479. fieldNum := int32(wire >> 3)
  1480. wireType := int(wire & 0x7)
  1481. if wireType == 4 {
  1482. return fmt.Errorf("proto: MSG: wiretype end group for non-group")
  1483. }
  1484. if fieldNum <= 0 {
  1485. return fmt.Errorf("proto: MSG: illegal tag %d (wire type %d)", fieldNum, wire)
  1486. }
  1487. switch fieldNum {
  1488. case 1:
  1489. if wireType != 0 {
  1490. return fmt.Errorf("proto: wrong wireType = %d for field Roomid", wireType)
  1491. }
  1492. m.Roomid = 0
  1493. for shift := uint(0); ; shift += 7 {
  1494. if shift >= 64 {
  1495. return ErrIntOverflowBroadcast
  1496. }
  1497. if iNdEx >= l {
  1498. return io.ErrUnexpectedEOF
  1499. }
  1500. b := dAtA[iNdEx]
  1501. iNdEx++
  1502. m.Roomid |= (int64(b) & 0x7F) << shift
  1503. if b < 0x80 {
  1504. break
  1505. }
  1506. }
  1507. case 2:
  1508. if wireType != 2 {
  1509. return fmt.Errorf("proto: wrong wireType = %d for field MsgCommon", wireType)
  1510. }
  1511. var stringLen uint64
  1512. for shift := uint(0); ; shift += 7 {
  1513. if shift >= 64 {
  1514. return ErrIntOverflowBroadcast
  1515. }
  1516. if iNdEx >= l {
  1517. return io.ErrUnexpectedEOF
  1518. }
  1519. b := dAtA[iNdEx]
  1520. iNdEx++
  1521. stringLen |= (uint64(b) & 0x7F) << shift
  1522. if b < 0x80 {
  1523. break
  1524. }
  1525. }
  1526. intStringLen := int(stringLen)
  1527. if intStringLen < 0 {
  1528. return ErrInvalidLengthBroadcast
  1529. }
  1530. postIndex := iNdEx + intStringLen
  1531. if postIndex > l {
  1532. return io.ErrUnexpectedEOF
  1533. }
  1534. m.MsgCommon = string(dAtA[iNdEx:postIndex])
  1535. iNdEx = postIndex
  1536. case 3:
  1537. if wireType != 2 {
  1538. return fmt.Errorf("proto: wrong wireType = %d for field MsgSelf", wireType)
  1539. }
  1540. var stringLen uint64
  1541. for shift := uint(0); ; shift += 7 {
  1542. if shift >= 64 {
  1543. return ErrIntOverflowBroadcast
  1544. }
  1545. if iNdEx >= l {
  1546. return io.ErrUnexpectedEOF
  1547. }
  1548. b := dAtA[iNdEx]
  1549. iNdEx++
  1550. stringLen |= (uint64(b) & 0x7F) << shift
  1551. if b < 0x80 {
  1552. break
  1553. }
  1554. }
  1555. intStringLen := int(stringLen)
  1556. if intStringLen < 0 {
  1557. return ErrInvalidLengthBroadcast
  1558. }
  1559. postIndex := iNdEx + intStringLen
  1560. if postIndex > l {
  1561. return io.ErrUnexpectedEOF
  1562. }
  1563. m.MsgSelf = string(dAtA[iNdEx:postIndex])
  1564. iNdEx = postIndex
  1565. case 4:
  1566. if wireType != 2 {
  1567. return fmt.Errorf("proto: wrong wireType = %d for field LinkUrl", wireType)
  1568. }
  1569. var stringLen uint64
  1570. for shift := uint(0); ; shift += 7 {
  1571. if shift >= 64 {
  1572. return ErrIntOverflowBroadcast
  1573. }
  1574. if iNdEx >= l {
  1575. return io.ErrUnexpectedEOF
  1576. }
  1577. b := dAtA[iNdEx]
  1578. iNdEx++
  1579. stringLen |= (uint64(b) & 0x7F) << shift
  1580. if b < 0x80 {
  1581. break
  1582. }
  1583. }
  1584. intStringLen := int(stringLen)
  1585. if intStringLen < 0 {
  1586. return ErrInvalidLengthBroadcast
  1587. }
  1588. postIndex := iNdEx + intStringLen
  1589. if postIndex > l {
  1590. return io.ErrUnexpectedEOF
  1591. }
  1592. m.LinkUrl = string(dAtA[iNdEx:postIndex])
  1593. iNdEx = postIndex
  1594. case 5:
  1595. if wireType != 0 {
  1596. return fmt.Errorf("proto: wrong wireType = %d for field MsgType", wireType)
  1597. }
  1598. m.MsgType = 0
  1599. for shift := uint(0); ; shift += 7 {
  1600. if shift >= 64 {
  1601. return ErrIntOverflowBroadcast
  1602. }
  1603. if iNdEx >= l {
  1604. return io.ErrUnexpectedEOF
  1605. }
  1606. b := dAtA[iNdEx]
  1607. iNdEx++
  1608. m.MsgType |= (int64(b) & 0x7F) << shift
  1609. if b < 0x80 {
  1610. break
  1611. }
  1612. }
  1613. case 6:
  1614. if wireType != 2 {
  1615. return fmt.Errorf("proto: wrong wireType = %d for field Full", wireType)
  1616. }
  1617. var msglen int
  1618. for shift := uint(0); ; shift += 7 {
  1619. if shift >= 64 {
  1620. return ErrIntOverflowBroadcast
  1621. }
  1622. if iNdEx >= l {
  1623. return io.ErrUnexpectedEOF
  1624. }
  1625. b := dAtA[iNdEx]
  1626. iNdEx++
  1627. msglen |= (int(b) & 0x7F) << shift
  1628. if b < 0x80 {
  1629. break
  1630. }
  1631. }
  1632. if msglen < 0 {
  1633. return ErrInvalidLengthBroadcast
  1634. }
  1635. postIndex := iNdEx + msglen
  1636. if postIndex > l {
  1637. return io.ErrUnexpectedEOF
  1638. }
  1639. if m.Full == nil {
  1640. m.Full = &BroadcastSendNoticeMsgReq_FullData{}
  1641. }
  1642. if err := m.Full.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1643. return err
  1644. }
  1645. iNdEx = postIndex
  1646. case 7:
  1647. if wireType != 2 {
  1648. return fmt.Errorf("proto: wrong wireType = %d for field Half", wireType)
  1649. }
  1650. var msglen int
  1651. for shift := uint(0); ; shift += 7 {
  1652. if shift >= 64 {
  1653. return ErrIntOverflowBroadcast
  1654. }
  1655. if iNdEx >= l {
  1656. return io.ErrUnexpectedEOF
  1657. }
  1658. b := dAtA[iNdEx]
  1659. iNdEx++
  1660. msglen |= (int(b) & 0x7F) << shift
  1661. if b < 0x80 {
  1662. break
  1663. }
  1664. }
  1665. if msglen < 0 {
  1666. return ErrInvalidLengthBroadcast
  1667. }
  1668. postIndex := iNdEx + msglen
  1669. if postIndex > l {
  1670. return io.ErrUnexpectedEOF
  1671. }
  1672. if m.Half == nil {
  1673. m.Half = &BroadcastSendNoticeMsgReq_HalfData{}
  1674. }
  1675. if err := m.Half.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
  1676. return err
  1677. }
  1678. iNdEx = postIndex
  1679. default:
  1680. iNdEx = preIndex
  1681. skippy, err := skipBroadcast(dAtA[iNdEx:])
  1682. if err != nil {
  1683. return err
  1684. }
  1685. if skippy < 0 {
  1686. return ErrInvalidLengthBroadcast
  1687. }
  1688. if (iNdEx + skippy) > l {
  1689. return io.ErrUnexpectedEOF
  1690. }
  1691. iNdEx += skippy
  1692. }
  1693. }
  1694. if iNdEx > l {
  1695. return io.ErrUnexpectedEOF
  1696. }
  1697. return nil
  1698. }
  1699. func (m *BroadcastSendNoticeMsgResp) Unmarshal(dAtA []byte) error {
  1700. l := len(dAtA)
  1701. iNdEx := 0
  1702. for iNdEx < l {
  1703. preIndex := iNdEx
  1704. var wire uint64
  1705. for shift := uint(0); ; shift += 7 {
  1706. if shift >= 64 {
  1707. return ErrIntOverflowBroadcast
  1708. }
  1709. if iNdEx >= l {
  1710. return io.ErrUnexpectedEOF
  1711. }
  1712. b := dAtA[iNdEx]
  1713. iNdEx++
  1714. wire |= (uint64(b) & 0x7F) << shift
  1715. if b < 0x80 {
  1716. break
  1717. }
  1718. }
  1719. fieldNum := int32(wire >> 3)
  1720. wireType := int(wire & 0x7)
  1721. if wireType == 4 {
  1722. return fmt.Errorf("proto: BroadcastSendNoticeMsgResp: wiretype end group for non-group")
  1723. }
  1724. if fieldNum <= 0 {
  1725. return fmt.Errorf("proto: BroadcastSendNoticeMsgResp: illegal tag %d (wire type %d)", fieldNum, wire)
  1726. }
  1727. switch fieldNum {
  1728. case 1:
  1729. if wireType != 0 {
  1730. return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
  1731. }
  1732. m.Code = 0
  1733. for shift := uint(0); ; shift += 7 {
  1734. if shift >= 64 {
  1735. return ErrIntOverflowBroadcast
  1736. }
  1737. if iNdEx >= l {
  1738. return io.ErrUnexpectedEOF
  1739. }
  1740. b := dAtA[iNdEx]
  1741. iNdEx++
  1742. m.Code |= (int64(b) & 0x7F) << shift
  1743. if b < 0x80 {
  1744. break
  1745. }
  1746. }
  1747. case 2:
  1748. if wireType != 2 {
  1749. return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
  1750. }
  1751. var stringLen uint64
  1752. for shift := uint(0); ; shift += 7 {
  1753. if shift >= 64 {
  1754. return ErrIntOverflowBroadcast
  1755. }
  1756. if iNdEx >= l {
  1757. return io.ErrUnexpectedEOF
  1758. }
  1759. b := dAtA[iNdEx]
  1760. iNdEx++
  1761. stringLen |= (uint64(b) & 0x7F) << shift
  1762. if b < 0x80 {
  1763. break
  1764. }
  1765. }
  1766. intStringLen := int(stringLen)
  1767. if intStringLen < 0 {
  1768. return ErrInvalidLengthBroadcast
  1769. }
  1770. postIndex := iNdEx + intStringLen
  1771. if postIndex > l {
  1772. return io.ErrUnexpectedEOF
  1773. }
  1774. m.Msg = string(dAtA[iNdEx:postIndex])
  1775. iNdEx = postIndex
  1776. case 3:
  1777. if wireType == 0 {
  1778. var v int64
  1779. for shift := uint(0); ; shift += 7 {
  1780. if shift >= 64 {
  1781. return ErrIntOverflowBroadcast
  1782. }
  1783. if iNdEx >= l {
  1784. return io.ErrUnexpectedEOF
  1785. }
  1786. b := dAtA[iNdEx]
  1787. iNdEx++
  1788. v |= (int64(b) & 0x7F) << shift
  1789. if b < 0x80 {
  1790. break
  1791. }
  1792. }
  1793. m.Data = append(m.Data, v)
  1794. } else if wireType == 2 {
  1795. var packedLen int
  1796. for shift := uint(0); ; shift += 7 {
  1797. if shift >= 64 {
  1798. return ErrIntOverflowBroadcast
  1799. }
  1800. if iNdEx >= l {
  1801. return io.ErrUnexpectedEOF
  1802. }
  1803. b := dAtA[iNdEx]
  1804. iNdEx++
  1805. packedLen |= (int(b) & 0x7F) << shift
  1806. if b < 0x80 {
  1807. break
  1808. }
  1809. }
  1810. if packedLen < 0 {
  1811. return ErrInvalidLengthBroadcast
  1812. }
  1813. postIndex := iNdEx + packedLen
  1814. if postIndex > l {
  1815. return io.ErrUnexpectedEOF
  1816. }
  1817. var elementCount int
  1818. var count int
  1819. for _, integer := range dAtA {
  1820. if integer < 128 {
  1821. count++
  1822. }
  1823. }
  1824. elementCount = count
  1825. if elementCount != 0 && len(m.Data) == 0 {
  1826. m.Data = make([]int64, 0, elementCount)
  1827. }
  1828. for iNdEx < postIndex {
  1829. var v int64
  1830. for shift := uint(0); ; shift += 7 {
  1831. if shift >= 64 {
  1832. return ErrIntOverflowBroadcast
  1833. }
  1834. if iNdEx >= l {
  1835. return io.ErrUnexpectedEOF
  1836. }
  1837. b := dAtA[iNdEx]
  1838. iNdEx++
  1839. v |= (int64(b) & 0x7F) << shift
  1840. if b < 0x80 {
  1841. break
  1842. }
  1843. }
  1844. m.Data = append(m.Data, v)
  1845. }
  1846. } else {
  1847. return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
  1848. }
  1849. default:
  1850. iNdEx = preIndex
  1851. skippy, err := skipBroadcast(dAtA[iNdEx:])
  1852. if err != nil {
  1853. return err
  1854. }
  1855. if skippy < 0 {
  1856. return ErrInvalidLengthBroadcast
  1857. }
  1858. if (iNdEx + skippy) > l {
  1859. return io.ErrUnexpectedEOF
  1860. }
  1861. iNdEx += skippy
  1862. }
  1863. }
  1864. if iNdEx > l {
  1865. return io.ErrUnexpectedEOF
  1866. }
  1867. return nil
  1868. }
  1869. func skipBroadcast(dAtA []byte) (n int, err error) {
  1870. l := len(dAtA)
  1871. iNdEx := 0
  1872. for iNdEx < l {
  1873. var wire uint64
  1874. for shift := uint(0); ; shift += 7 {
  1875. if shift >= 64 {
  1876. return 0, ErrIntOverflowBroadcast
  1877. }
  1878. if iNdEx >= l {
  1879. return 0, io.ErrUnexpectedEOF
  1880. }
  1881. b := dAtA[iNdEx]
  1882. iNdEx++
  1883. wire |= (uint64(b) & 0x7F) << shift
  1884. if b < 0x80 {
  1885. break
  1886. }
  1887. }
  1888. wireType := int(wire & 0x7)
  1889. switch wireType {
  1890. case 0:
  1891. for shift := uint(0); ; shift += 7 {
  1892. if shift >= 64 {
  1893. return 0, ErrIntOverflowBroadcast
  1894. }
  1895. if iNdEx >= l {
  1896. return 0, io.ErrUnexpectedEOF
  1897. }
  1898. iNdEx++
  1899. if dAtA[iNdEx-1] < 0x80 {
  1900. break
  1901. }
  1902. }
  1903. return iNdEx, nil
  1904. case 1:
  1905. iNdEx += 8
  1906. return iNdEx, nil
  1907. case 2:
  1908. var length int
  1909. for shift := uint(0); ; shift += 7 {
  1910. if shift >= 64 {
  1911. return 0, ErrIntOverflowBroadcast
  1912. }
  1913. if iNdEx >= l {
  1914. return 0, io.ErrUnexpectedEOF
  1915. }
  1916. b := dAtA[iNdEx]
  1917. iNdEx++
  1918. length |= (int(b) & 0x7F) << shift
  1919. if b < 0x80 {
  1920. break
  1921. }
  1922. }
  1923. iNdEx += length
  1924. if length < 0 {
  1925. return 0, ErrInvalidLengthBroadcast
  1926. }
  1927. return iNdEx, nil
  1928. case 3:
  1929. for {
  1930. var innerWire uint64
  1931. var start int = iNdEx
  1932. for shift := uint(0); ; shift += 7 {
  1933. if shift >= 64 {
  1934. return 0, ErrIntOverflowBroadcast
  1935. }
  1936. if iNdEx >= l {
  1937. return 0, io.ErrUnexpectedEOF
  1938. }
  1939. b := dAtA[iNdEx]
  1940. iNdEx++
  1941. innerWire |= (uint64(b) & 0x7F) << shift
  1942. if b < 0x80 {
  1943. break
  1944. }
  1945. }
  1946. innerWireType := int(innerWire & 0x7)
  1947. if innerWireType == 4 {
  1948. break
  1949. }
  1950. next, err := skipBroadcast(dAtA[start:])
  1951. if err != nil {
  1952. return 0, err
  1953. }
  1954. iNdEx = start + next
  1955. }
  1956. return iNdEx, nil
  1957. case 4:
  1958. return iNdEx, nil
  1959. case 5:
  1960. iNdEx += 4
  1961. return iNdEx, nil
  1962. default:
  1963. return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
  1964. }
  1965. }
  1966. panic("unreachable")
  1967. }
  1968. var (
  1969. ErrInvalidLengthBroadcast = fmt.Errorf("proto: negative length found during unmarshaling")
  1970. ErrIntOverflowBroadcast = fmt.Errorf("proto: integer overflow")
  1971. )
  1972. func init() { proto.RegisterFile("v0/Broadcast.proto", fileDescriptor_Broadcast_32ece6a4f6b2cbe4) }
  1973. var fileDescriptor_Broadcast_32ece6a4f6b2cbe4 = []byte{
  1974. // 654 bytes of a gzipped FileDescriptorProto
  1975. 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x54, 0xcd, 0x6e, 0xd3, 0x4a,
  1976. 0x14, 0xae, 0xe3, 0xfc, 0xd8, 0xd3, 0xde, 0xdb, 0xab, 0x59, 0xb9, 0x51, 0x15, 0xe7, 0x56, 0x48,
  1977. 0x14, 0x50, 0xdd, 0x28, 0x3c, 0x00, 0x92, 0x41, 0x2d, 0x08, 0x95, 0xc5, 0x04, 0xba, 0x60, 0x63,
  1978. 0x4d, 0xec, 0xb1, 0x63, 0x75, 0xec, 0x09, 0xfe, 0x89, 0x94, 0x77, 0x60, 0xc1, 0x63, 0xb1, 0xec,
  1979. 0x92, 0x95, 0x85, 0x5a, 0xc1, 0xc2, 0x0f, 0x81, 0xd0, 0x1c, 0xc7, 0x4e, 0x2a, 0x51, 0x35, 0x1b,
  1980. 0x36, 0xc7, 0xe7, 0x7c, 0x3e, 0xdf, 0x37, 0x73, 0x3e, 0x7b, 0x06, 0xe1, 0xc5, 0xe8, 0xd4, 0x4e,
  1981. 0x04, 0xf5, 0x5c, 0x9a, 0x66, 0xd6, 0x3c, 0x11, 0x99, 0xc0, 0x9d, 0xc4, 0xb5, 0x16, 0xa3, 0xfe,
  1982. 0x49, 0x10, 0x66, 0xb3, 0x7c, 0x6a, 0xb9, 0x22, 0x3a, 0x0d, 0x44, 0x20, 0x4e, 0xe1, 0xed, 0x34,
  1983. 0xf7, 0xa1, 0x82, 0x02, 0xb2, 0x8a, 0x75, 0xf4, 0x59, 0x47, 0x07, 0x8d, 0xd2, 0x84, 0xc5, 0xde,
  1984. 0x3b, 0x91, 0x85, 0x2e, 0xbb, 0x48, 0x03, 0xc2, 0x3e, 0xe1, 0xa7, 0x48, 0x4f, 0x5d, 0x16, 0x33,
  1985. 0xe7, 0x8a, 0x2d, 0x0d, 0x65, 0xa8, 0x1c, 0xeb, 0xf6, 0x3f, 0x65, 0x61, 0xae, 0x41, 0xa2, 0x41,
  1986. 0xfa, 0x96, 0x2d, 0xf1, 0x08, 0xed, 0x56, 0xf0, 0x82, 0xf2, 0x9c, 0x19, 0x2d, 0xe8, 0xde, 0x2f,
  1987. 0x0b, 0x73, 0x13, 0x26, 0x08, 0x8a, 0x4b, 0x99, 0xe3, 0x17, 0x48, 0x8d, 0xd2, 0xc0, 0x50, 0x87,
  1988. 0xca, 0xf1, 0xee, 0xf8, 0x91, 0x05, 0xfb, 0xb7, 0xee, 0xdd, 0x8c, 0x75, 0x31, 0x39, 0xb7, 0x7b,
  1989. 0x65, 0x61, 0x4a, 0x12, 0x91, 0xa1, 0xff, 0xb3, 0x85, 0xb4, 0xb3, 0x9c, 0xf3, 0x57, 0x34, 0xa3,
  1990. 0x72, 0xaf, 0x33, 0x46, 0x3d, 0x27, 0x74, 0x45, 0xbc, 0xb9, 0xd7, 0x06, 0x24, 0x9a, 0x4c, 0xdf,
  1991. 0xb8, 0x22, 0x96, 0xbd, 0x19, 0x0d, 0x79, 0xd5, 0xdb, 0x5a, 0xf7, 0x36, 0x20, 0xd1, 0x64, 0x0a,
  1992. 0xbd, 0x63, 0xb4, 0xd7, 0x48, 0x38, 0x3e, 0x85, 0xed, 0xea, 0xf6, 0x7f, 0x65, 0x61, 0xde, 0xc1,
  1993. 0x09, 0xaa, 0xd5, 0xcf, 0xa8, 0xe4, 0x34, 0x52, 0x92, 0xd3, 0x5e, 0x73, 0x36, 0x71, 0x82, 0xea,
  1994. 0x55, 0xce, 0x28, 0xb6, 0x10, 0x9a, 0x52, 0xf7, 0x2a, 0x48, 0x44, 0x1e, 0x7b, 0x46, 0x07, 0x18,
  1995. 0xff, 0x96, 0x85, 0xb9, 0x81, 0x92, 0x8d, 0x1c, 0x9b, 0xa8, 0xe3, 0x0a, 0x2e, 0x12, 0xa3, 0x0b,
  1996. 0xad, 0x7a, 0x59, 0x98, 0x15, 0x40, 0xaa, 0x07, 0x7e, 0x86, 0xf4, 0x59, 0x18, 0xcc, 0x78, 0x18,
  1997. 0xcc, 0x32, 0xa3, 0xb7, 0x61, 0x48, 0x0d, 0x92, 0x75, 0x8a, 0x0f, 0x51, 0x3b, 0x0b, 0x23, 0x66,
  1998. 0x68, 0x43, 0xe5, 0x58, 0xb5, 0xb5, 0xb2, 0x30, 0xa1, 0x26, 0x10, 0xfb, 0xbf, 0x14, 0xa4, 0xbd,
  1999. 0xa6, 0xdc, 0xff, 0xab, 0x46, 0xdf, 0x35, 0x40, 0xdd, 0xde, 0x80, 0xf6, 0x36, 0x06, 0x74, 0xb6,
  2000. 0x34, 0xa0, 0xfb, 0x47, 0x03, 0x7e, 0xb4, 0x90, 0x7a, 0x31, 0x39, 0xc7, 0x47, 0xa8, 0x9b, 0x08,
  2001. 0x11, 0x85, 0x1e, 0x0c, 0xae, 0xda, 0xa8, 0x2c, 0xcc, 0x15, 0x42, 0x56, 0x4f, 0x7c, 0x82, 0x50,
  2002. 0x94, 0x06, 0x8e, 0x2b, 0xa2, 0xa8, 0x19, 0x1a, 0xe6, 0x58, 0xa3, 0x44, 0x8f, 0xd2, 0xe0, 0x25,
  2003. 0xa4, 0xf8, 0x31, 0xd2, 0xe4, 0x8b, 0x94, 0x71, 0x7f, 0x35, 0xf4, 0x5e, 0x59, 0x98, 0x0d, 0x46,
  2004. 0x7a, 0x51, 0x1a, 0x4c, 0x18, 0xf7, 0x65, 0x23, 0x0f, 0xe3, 0x2b, 0x27, 0x4f, 0xf8, 0x6a, 0x64,
  2005. 0x68, 0xac, 0x31, 0xd2, 0x93, 0xd9, 0x87, 0x84, 0xd7, 0x8a, 0xd9, 0x72, 0xce, 0x60, 0x6c, 0x75,
  2006. 0xad, 0x28, 0x31, 0x50, 0x7c, 0xbf, 0x9c, 0x33, 0x7c, 0x8e, 0xda, 0x7e, 0xce, 0x39, 0xcc, 0xbc,
  2007. 0x3b, 0x7e, 0xf2, 0xe0, 0x09, 0xac, 0xcf, 0x5a, 0x65, 0x8f, 0xa4, 0x12, 0x88, 0x52, 0x68, 0x46,
  2008. 0xb9, 0x0f, 0x7f, 0xd9, 0x36, 0x42, 0xf5, 0xbf, 0x54, 0x09, 0x49, 0x2a, 0x81, 0x78, 0x94, 0xa2,
  2009. 0xfe, 0x7d, 0xac, 0x74, 0x2e, 0xbf, 0x91, 0x2b, 0x3c, 0xb6, 0xf2, 0x1e, 0xb8, 0xb2, 0x26, 0x10,
  2010. 0xf1, 0x41, 0x75, 0x9d, 0x54, 0x86, 0xdf, 0xb9, 0x28, 0x24, 0xd1, 0xa3, 0x99, 0x3c, 0xbb, 0x6a,
  2011. 0x4d, 0x94, 0x35, 0x81, 0x38, 0x76, 0x91, 0xde, 0x2c, 0x8a, 0x2f, 0xd1, 0x7e, 0xca, 0x62, 0xcf,
  2012. 0x89, 0x61, 0x65, 0x47, 0xb2, 0x87, 0x0f, 0xcd, 0xd3, 0xff, 0xff, 0x81, 0x8e, 0x74, 0x6e, 0x1f,
  2013. 0x7e, 0xbd, 0x19, 0x28, 0xd7, 0x37, 0x03, 0xe5, 0xfb, 0xcd, 0x40, 0xf9, 0x72, 0x3b, 0xd8, 0xb9,
  2014. 0xbe, 0x1d, 0xec, 0x7c, 0xbb, 0x1d, 0xec, 0x7c, 0x6c, 0x2d, 0x46, 0xd3, 0x2e, 0xdc, 0xc6, 0xcf,
  2015. 0x7f, 0x07, 0x00, 0x00, 0xff, 0xff, 0xa3, 0x4a, 0x6f, 0x45, 0xd9, 0x05, 0x00, 0x00,
  2016. }