Gitiles
Code Review Sign In
gerrit.opencord.org / ofagent-go / 828908c5461d5896692bd2aaca36fa28624e3a8c / . / vendor / github.com / opencord / goloxi / of13 / common.go
blob: d21219d154c4d5e987c769d7dcbddbb456218a5a [file] [log] [blame]
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]1/*
2 * Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
3 * Copyright (c) 2011, 2012 Open Networking Foundation
4 * Copyright 2013, Big Switch Networks, Inc. This library was generated by the LoxiGen Compiler.
5 * Copyright 2018, Red Hat, Inc.
6 */
7// Automatically generated by LOXI from template module.go
8// Do not modify
9
10package of13
11
12import (
13 "bytes"
14 "encoding/binary"
15 "fmt"
16 "net"
17
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]18 "github.com/opencord/goloxi"
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]19)
20
21type OxmId struct {
22 TypeLen uint32
23}
24
25type IOxmId interface {
26 goloxi.Serializable
27 GetTypeLen() uint32
28 GetOXMName() string
29}
30
31func (self *OxmId) GetTypeLen() uint32 {
32 return self.TypeLen
33}
34
35func (self *OxmId) SetTypeLen(v uint32) {
36 self.TypeLen = v
37}
38
39func (self *OxmId) Serialize(encoder *goloxi.Encoder) error {
40
41 encoder.PutUint32(uint32(self.TypeLen))
42
43 return nil
44}
45
46func DecodeOxmId(decoder *goloxi.Decoder) (IOxmId, error) {
47 _oxmid := &OxmId{}
48 if decoder.Length() < 4 {
49 return nil, fmt.Errorf("OxmId packet too short: %d < 4", decoder.Length())
50 }
51 _oxmid.TypeLen = uint32(decoder.ReadUint32())
52
53 switch _oxmid.TypeLen {
54 case 110204:
55 return DecodeOxmIdTunMetadata47(_oxmid, decoder)
56 case 129026:
57 return DecodeOxmIdConnTrackingTpSrc(_oxmid, decoder)
58 case 2147489796:
59 return DecodeOxmIdIpv4Dst(_oxmid, decoder)
60 case 77830:
61 return DecodeOxmIdNdSll(_oxmid, decoder)
62 case 80897:
63 return DecodeOxmIdMplsTtl(_oxmid, decoder)
64 case 73736:
65 return DecodeOxmIdTunId(_oxmid, decoder)
66 case 2:
67 return DecodeOxmIdInPort(_oxmid, decoder)
68 case 120848:
69 return DecodeOxmIdConnTrackingLabel(_oxmid, decoder)
70 case 65540:
71 return DecodeOxmIdReg0(_oxmid, decoder)
72 case 111228:
73 return DecodeOxmIdTunMetadata49(_oxmid, decoder)
74 case 74758:
75 return DecodeOxmIdArpTha(_oxmid, decoder)
76 case 2147499266:
77 return DecodeOxmIdIcmpv6CodeMasked(_oxmid, decoder)
78 case 2147503112:
79 return DecodeOxmIdTunnelId(_oxmid, decoder)
80 case 112252:
81 return DecodeOxmIdTunMetadata51(_oxmid, decoder)
82 case 108024:
83 return DecodeOxmIdTunMetadata42Masked(_oxmid, decoder)
84 case 113276:
85 return DecodeOxmIdTunMetadata53(_oxmid, decoder)
86 case 109048:
87 return DecodeOxmIdTunMetadata44Masked(_oxmid, decoder)
88 case 94332:
89 return DecodeOxmIdTunMetadata16(_oxmid, decoder)
90 case 114300:
91 return DecodeOxmIdTunMetadata55(_oxmid, decoder)
92 case 2050:
93 return DecodeOxmIdVlanTci(_oxmid, decoder)
94 case 3073:
95 return DecodeOxmIdNwProto(_oxmid, decoder)
96 case 110072:
97 return DecodeOxmIdTunMetadata46Masked(_oxmid, decoder)
98 case 2147502338:
99 return DecodeOxmIdMplsBosMasked(_oxmid, decoder)
100 case 66564:
101 return DecodeOxmIdReg2(_oxmid, decoder)
102 case 115324:
103 return DecodeOxmIdTunMetadata57(_oxmid, decoder)
104 case 2147486722:
105 return DecodeOxmIdVlanVid(_oxmid, decoder)
106 case 2147487745:
107 return DecodeOxmIdIpDscp(_oxmid, decoder)
108 case 111096:
109 return DecodeOxmIdTunMetadata48Masked(_oxmid, decoder)
110 case 83204:
111 return DecodeOxmIdTcpFlagsMasked(_oxmid, decoder)
112 case 3588:
113 return DecodeOxmIdIpSrc(_oxmid, decoder)
114 case 198660:
115 return DecodeOxmIdBsnL3InterfaceClassId(_oxmid, decoder)
116 case 2147488769:
117 return DecodeOxmIdIpProto(_oxmid, decoder)
118 case 112120:
119 return DecodeOxmIdTunMetadata50Masked(_oxmid, decoder)
120 case 121872:
121 return DecodeOxmIdTunIpv6Dst(_oxmid, decoder)
122 case 199172:
123 return DecodeOxmIdBsnL3SrcClassId(_oxmid, decoder)
124 case 1030:
125 return DecodeOxmIdEthSrc(_oxmid, decoder)
126 case 68612:
127 return DecodeOxmIdReg6(_oxmid, decoder)
128 case 117372:
129 return DecodeOxmIdTunMetadata61(_oxmid, decoder)
130 case 5122:
131 return DecodeOxmIdTcpDst(_oxmid, decoder)
132 case 113144:
133 return DecodeOxmIdTunMetadata52Masked(_oxmid, decoder)
134 case 122896:
135 return DecodeOxmIdXxreg1(_oxmid, decoder)
136 case 209156:
137 return DecodeOxmIdBsnInnerVlanVidMasked(_oxmid, decoder)
138 case 124192:
139 return DecodeOxmIdXxreg3Masked(_oxmid, decoder)
140 case 81672:
141 return DecodeOxmIdTunnelIpv4SrcMasked(_oxmid, decoder)
142 case 4100:
143 return DecodeOxmIdIpDst(_oxmid, decoder)
144 case 118396:
145 return DecodeOxmIdTunMetadata63(_oxmid, decoder)
146 case 2147494146:
147 return DecodeOxmIdIcmpv4CodeMasked(_oxmid, decoder)
148 case 129284:
149 return DecodeOxmIdConnTrackingTpSrcMasked(_oxmid, decoder)
150 case 114168:
151 return DecodeOxmIdTunMetadata54Masked(_oxmid, decoder)
152 case 123920:
153 return DecodeOxmIdXxreg3(_oxmid, decoder)
154 case 200968:
155 return DecodeOxmIdBsnUdf0Masked(_oxmid, decoder)
156 case 78091:
157 return DecodeOxmIdNdSllMasked(_oxmid, decoder)
158 case 2147500300:
159 return DecodeOxmIdIpv6NdSllMasked(_oxmid, decoder)
160 case 74000:
161 return DecodeOxmIdTunIdMasked(_oxmid, decoder)
162 case 86140:
163 return DecodeOxmIdTunMetadata0(_oxmid, decoder)
164 case 70660:
165 return DecodeOxmIdReg10(_oxmid, decoder)
166 case 121120:
167 return DecodeOxmIdConnTrackingLabelMasked(_oxmid, decoder)
168 case 107000:
169 return DecodeOxmIdTunMetadata40Masked(_oxmid, decoder)
170 case 3848:
171 return DecodeOxmIdIpSrcMasked(_oxmid, decoder)
172 case 87164:
173 return DecodeOxmIdTunMetadata2(_oxmid, decoder)
174 case 202756:
175 return DecodeOxmIdBsnUdf4(_oxmid, decoder)
176 case 204802:
177 return DecodeOxmIdBsnTcpFlags(_oxmid, decoder)
178 case 205825:
179 return DecodeOxmIdBsnL2CacheHit(_oxmid, decoder)
180 case 116216:
181 return DecodeOxmIdTunMetadata58Masked(_oxmid, decoder)
182 case 199432:
183 return DecodeOxmIdBsnL3SrcClassIdMasked(_oxmid, decoder)
184 case 88188:
185 return DecodeOxmIdTunMetadata4(_oxmid, decoder)
186 case 203780:
187 return DecodeOxmIdBsnUdf6(_oxmid, decoder)
188 case 2147492866:
189 return DecodeOxmIdSctpDst(_oxmid, decoder)
190 case 2147493889:
191 return DecodeOxmIdIcmpv4Code(_oxmid, decoder)
192 case 117240:
193 return DecodeOxmIdTunMetadata60Masked(_oxmid, decoder)
194 case 200196:
195 return DecodeOxmIdBsnEgrPortGroupId(_oxmid, decoder)
196 case 128288:
197 return DecodeOxmIdConnTrackingIpv6SrcMasked(_oxmid, decoder)
198 case 89212:
199 return DecodeOxmIdTunMetadata6(_oxmid, decoder)
200 case 8196:
201 return DecodeOxmIdArpSpa(_oxmid, decoder)
202 case 76801:
203 return DecodeOxmIdIcmpv6Code(_oxmid, decoder)
204 case 118264:
205 return DecodeOxmIdTunMetadata62Masked(_oxmid, decoder)
206 case 70148:
207 return DecodeOxmIdReg9(_oxmid, decoder)
208 case 119560:
209 return DecodeOxmIdConnTrackingStateMasked(_oxmid, decoder)
210 case 90236:
211 return DecodeOxmIdTunMetadata8(_oxmid, decoder)
212 case 119044:
213 return DecodeOxmIdTunFlagsMasked(_oxmid, decoder)
214 case 82696:
215 return DecodeOxmIdPktMarkMasked(_oxmid, decoder)
216 case 4294923528:
217 return DecodeOxmIdOvsTcpFlagsMasked(_oxmid, decoder)
218 case 120584:
219 return DecodeOxmIdConnTrackingMarkMasked(_oxmid, decoder)
220 case 91260:
221 return DecodeOxmIdTunMetadata10(_oxmid, decoder)
222 case 87032:
223 return DecodeOxmIdTunMetadata1Masked(_oxmid, decoder)
224 case 126722:
225 return DecodeOxmIdConnTrackingNwProtoMasked(_oxmid, decoder)
226 case 206852:
227 return DecodeOxmIdBsnIngressPortGroupId(_oxmid, decoder)
228 case 208898:
229 return DecodeOxmIdBsnInnerVlanVid(_oxmid, decoder)
230 case 209921:
231 return DecodeOxmIdBsnIpFragmentation(_oxmid, decoder)
232 case 196896:
233 return DecodeOxmIdBsnInPorts128Masked(_oxmid, decoder)
234 case 92284:
235 return DecodeOxmIdTunMetadata12(_oxmid, decoder)
236 case 88056:
237 return DecodeOxmIdTunMetadata3Masked(_oxmid, decoder)
238 case 79873:
239 return DecodeOxmIdNwEcn(_oxmid, decoder)
240 case 196624:
241 return DecodeOxmIdBsnInPorts128(_oxmid, decoder)
242 case 200456:
243 return DecodeOxmIdBsnEgrPortGroupIdMasked(_oxmid, decoder)
244 case 2147489284:
245 return DecodeOxmIdIpv4Src(_oxmid, decoder)
246 case 93308:
247 return DecodeOxmIdTunMetadata14(_oxmid, decoder)
248 case 115192:
249 return DecodeOxmIdTunMetadata56Masked(_oxmid, decoder)
250 case 2561:
251 return DecodeOxmIdNwTos(_oxmid, decoder)
252 case 129538:
253 return DecodeOxmIdConnTrackingTpDst(_oxmid, decoder)
254 case 2147500550:
255 return DecodeOxmIdIpv6NdTll(_oxmid, decoder)
256 case 84484:
257 return DecodeOxmIdConjId(_oxmid, decoder)
258 case 74246:
259 return DecodeOxmIdArpSha(_oxmid, decoder)
260 case 85762:
261 return DecodeOxmIdTunGbpFlagsMasked(_oxmid, decoder)
262 case 123408:
263 return DecodeOxmIdXxreg2(_oxmid, decoder)
264 case 90104:
265 return DecodeOxmIdTunMetadata7Masked(_oxmid, decoder)
266 case 2147486468:
267 return DecodeOxmIdEthTypeMasked(_oxmid, decoder)
268 case 70408:
269 return DecodeOxmIdReg9Masked(_oxmid, decoder)
270 case 91128:
271 return DecodeOxmIdTunMetadata9Masked(_oxmid, decoder)
272 case 83720:
273 return DecodeOxmIdDpHashMasked(_oxmid, decoder)
274 case 2147497988:
275 return DecodeOxmIdIpv6Flabel(_oxmid, decoder)
276 case 78603:
277 return DecodeOxmIdNdTllMasked(_oxmid, decoder)
278 case 2147503376:
279 return DecodeOxmIdTunnelIdMasked(_oxmid, decoder)
280 case 96380:
281 return DecodeOxmIdTunMetadata20(_oxmid, decoder)
282 case 92152:
283 return DecodeOxmIdTunMetadata11Masked(_oxmid, decoder)
284 case 129796:
285 return DecodeOxmIdConnTrackingTpDstMasked(_oxmid, decoder)
286 case 2147502081:
287 return DecodeOxmIdMplsBos(_oxmid, decoder)
288 case 97404:
289 return DecodeOxmIdTunMetadata22(_oxmid, decoder)
290 case 93176:
291 return DecodeOxmIdTunMetadata13Masked(_oxmid, decoder)
292 case 94844:
293 return DecodeOxmIdTunMetadata17(_oxmid, decoder)
294 case 81924:
295 return DecodeOxmIdTunnelIpv4Dst(_oxmid, decoder)
296 case 127752:
297 return DecodeOxmIdConnTrackingNwDstMasked(_oxmid, decoder)
298 case 98428:
299 return DecodeOxmIdTunMetadata24(_oxmid, decoder)
300 case 94200:
301 return DecodeOxmIdTunMetadata15Masked(_oxmid, decoder)
302 case 2147501060:
303 return DecodeOxmIdMplsLabel(_oxmid, decoder)
304 case 84994:
305 return DecodeOxmIdTunGbpId(_oxmid, decoder)
306 case 71432:
307 return DecodeOxmIdReg11Masked(_oxmid, decoder)
308 case 99452:
309 return DecodeOxmIdTunMetadata26(_oxmid, decoder)
310 case 95224:
311 return DecodeOxmIdTunMetadata17Masked(_oxmid, decoder)
312 case 2147500038:
313 return DecodeOxmIdIpv6NdSll(_oxmid, decoder)
314 case 83972:
315 return DecodeOxmIdRecircId(_oxmid, decoder)
316 case 128800:
317 return DecodeOxmIdConnTrackingIpv6DstMasked(_oxmid, decoder)
318 case 72196:
319 return DecodeOxmIdReg13(_oxmid, decoder)
320 case 100476:
321 return DecodeOxmIdTunMetadata28(_oxmid, decoder)
322 case 96248:
323 return DecodeOxmIdTunMetadata19Masked(_oxmid, decoder)
324 case 2147488514:
325 return DecodeOxmIdIpEcnMasked(_oxmid, decoder)
326 case 112764:
327 return DecodeOxmIdTunMetadata52(_oxmid, decoder)
328 case 101500:
329 return DecodeOxmIdTunMetadata30(_oxmid, decoder)
330 case 97272:
331 return DecodeOxmIdTunMetadata21Masked(_oxmid, decoder)
332 case 2147498754:
333 return DecodeOxmIdIcmpv6TypeMasked(_oxmid, decoder)
334 case 209668:
335 return DecodeOxmIdBsnVfiMasked(_oxmid, decoder)
336 case 2147484424:
337 return DecodeOxmIdInPhyPortMasked(_oxmid, decoder)
338 case 74507:
339 return DecodeOxmIdArpShaMasked(_oxmid, decoder)
340 case 2147500812:
341 return DecodeOxmIdIpv6NdTllMasked(_oxmid, decoder)
342 case 197384:
343 return DecodeOxmIdBsnLagIdMasked(_oxmid, decoder)
344 case 76064:
345 return DecodeOxmIdIpv6DstMasked(_oxmid, decoder)
346 case 102524:
347 return DecodeOxmIdTunMetadata32(_oxmid, decoder)
348 case 98296:
349 return DecodeOxmIdTunMetadata23Masked(_oxmid, decoder)
350 case 4868:
351 return DecodeOxmIdTcpSrcMasked(_oxmid, decoder)
352 case 121632:
353 return DecodeOxmIdTunIpv6SrcMasked(_oxmid, decoder)
354 case 75792:
355 return DecodeOxmIdIpv6Dst(_oxmid, decoder)
356 case 202504:
357 return DecodeOxmIdBsnUdf3Masked(_oxmid, decoder)
358 case 120324:
359 return DecodeOxmIdConnTrackingMark(_oxmid, decoder)
360 case 99320:
361 return DecodeOxmIdTunMetadata25Masked(_oxmid, decoder)
362 case 65800:
363 return DecodeOxmIdReg0Masked(_oxmid, decoder)
364 case 66824:
365 return DecodeOxmIdReg2Masked(_oxmid, decoder)
366 case 72456:
367 return DecodeOxmIdReg13Masked(_oxmid, decoder)
368 case 68360:
369 return DecodeOxmIdReg5Masked(_oxmid, decoder)
370 case 104572:
371 return DecodeOxmIdTunMetadata36(_oxmid, decoder)
372 case 95356:
373 return DecodeOxmIdTunMetadata18(_oxmid, decoder)
374 case 100344:
375 return DecodeOxmIdTunMetadata27Masked(_oxmid, decoder)
376 case 4294923270:
377 return DecodeOxmIdOvsTcpFlags(_oxmid, decoder)
378 case 779:
379 return DecodeOxmIdEthDstMasked(_oxmid, decoder)
380 case 69384:
381 return DecodeOxmIdReg7Masked(_oxmid, decoder)
382 case 105596:
383 return DecodeOxmIdTunMetadata38(_oxmid, decoder)
384 case 101368:
385 return DecodeOxmIdTunMetadata29Masked(_oxmid, decoder)
386 case 2147493634:
387 return DecodeOxmIdIcmpv4TypeMasked(_oxmid, decoder)
388 case 108668:
389 return DecodeOxmIdTunMetadata44(_oxmid, decoder)
390 case 201480:
391 return DecodeOxmIdBsnUdf1Masked(_oxmid, decoder)
392 case 106620:
393 return DecodeOxmIdTunMetadata40(_oxmid, decoder)
394 case 102392:
395 return DecodeOxmIdTunMetadata31Masked(_oxmid, decoder)
396 case 2147492612:
397 return DecodeOxmIdSctpSrcMasked(_oxmid, decoder)
398 case 72708:
399 return DecodeOxmIdReg14(_oxmid, decoder)
400 case 73480:
401 return DecodeOxmIdReg15Masked(_oxmid, decoder)
402 case 204292:
403 return DecodeOxmIdBsnUdf7(_oxmid, decoder)
404 case 2147489544:
405 return DecodeOxmIdIpv4SrcMasked(_oxmid, decoder)
406 case 107644:
407 return DecodeOxmIdTunMetadata42(_oxmid, decoder)
408 case 103416:
409 return DecodeOxmIdTunMetadata33Masked(_oxmid, decoder)
410 case 2147498248:
411 return DecodeOxmIdIpv6FlabelMasked(_oxmid, decoder)
412 case 203528:
413 return DecodeOxmIdBsnUdf5Masked(_oxmid, decoder)
414 case 89592:
415 return DecodeOxmIdTunMetadata6Masked(_oxmid, decoder)
416 case 104440:
417 return DecodeOxmIdTunMetadata35Masked(_oxmid, decoder)
418 case 2147494660:
419 return DecodeOxmIdArpOpMasked(_oxmid, decoder)
420 case 197636:
421 return DecodeOxmIdBsnVrf(_oxmid, decoder)
422 case 204552:
423 return DecodeOxmIdBsnUdf7Masked(_oxmid, decoder)
424 case 109692:
425 return DecodeOxmIdTunMetadata46(_oxmid, decoder)
426 case 105464:
427 return DecodeOxmIdTunMetadata37Masked(_oxmid, decoder)
428 case 89080:
429 return DecodeOxmIdTunMetadata5Masked(_oxmid, decoder)
430 case 67588:
431 return DecodeOxmIdReg4(_oxmid, decoder)
432 case 7169:
433 return DecodeOxmIdIcmpCode(_oxmid, decoder)
434 case 82946:
435 return DecodeOxmIdTcpFlags(_oxmid, decoder)
436 case 199684:
437 return DecodeOxmIdBsnL3DstClassId(_oxmid, decoder)
438 case 207878:
439 return DecodeOxmIdBsnInnerEthDst(_oxmid, decoder)
440 case 198145:
441 return DecodeOxmIdBsnGlobalVrfAllowed(_oxmid, decoder)
442 case 2147484680:
443 return DecodeOxmIdMetadata(_oxmid, decoder)
444 case 1538:
445 return DecodeOxmIdEthType(_oxmid, decoder)
446 case 8968:
447 return DecodeOxmIdArpTpaMasked(_oxmid, decoder)
448 case 128016:
449 return DecodeOxmIdConnTrackingIpv6Src(_oxmid, decoder)
450 case 110716:
451 return DecodeOxmIdTunMetadata48(_oxmid, decoder)
452 case 127492:
453 return DecodeOxmIdConnTrackingNwDst(_oxmid, decoder)
454 case 78342:
455 return DecodeOxmIdNdTll(_oxmid, decoder)
456 case 111740:
457 return DecodeOxmIdTunMetadata50(_oxmid, decoder)
458 case 107512:
459 return DecodeOxmIdTunMetadata41Masked(_oxmid, decoder)
460 case 207624:
461 return DecodeOxmIdBsnVxlanNetworkIdMasked(_oxmid, decoder)
462 case 121360:
463 return DecodeOxmIdTunIpv6Src(_oxmid, decoder)
464 case 113788:
465 return DecodeOxmIdTunMetadata54(_oxmid, decoder)
466 case 109560:
467 return DecodeOxmIdTunMetadata45Masked(_oxmid, decoder)
468 case 2147501826:
469 return DecodeOxmIdMplsTcMasked(_oxmid, decoder)
470 case 103548:
471 return DecodeOxmIdTunMetadata34(_oxmid, decoder)
472 case 2147484164:
473 return DecodeOxmIdInPhyPort(_oxmid, decoder)
474 case 205316:
475 return DecodeOxmIdBsnVlanXlatePortGroupId(_oxmid, decoder)
476 case 114812:
477 return DecodeOxmIdTunMetadata56(_oxmid, decoder)
478 case 2147487233:
479 return DecodeOxmIdVlanPcp(_oxmid, decoder)
480 case 110584:
481 return DecodeOxmIdTunMetadata47Masked(_oxmid, decoder)
482 case 79624:
483 return DecodeOxmIdIpv6LabelMasked(_oxmid, decoder)
484 case 115836:
485 return DecodeOxmIdTunMetadata58(_oxmid, decoder)
486 case 2147488257:
487 return DecodeOxmIdIpEcn(_oxmid, decoder)
488 case 111608:
489 return DecodeOxmIdTunMetadata49Masked(_oxmid, decoder)
490 case 518:
491 return DecodeOxmIdEthDst(_oxmid, decoder)
492 case 68100:
493 return DecodeOxmIdReg5(_oxmid, decoder)
494 case 116860:
495 return DecodeOxmIdTunMetadata60(_oxmid, decoder)
496 case 4610:
497 return DecodeOxmIdTcpSrc(_oxmid, decoder)
498 case 112632:
499 return DecodeOxmIdTunMetadata51Masked(_oxmid, decoder)
500 case 122384:
501 return DecodeOxmIdXxreg0(_oxmid, decoder)
502 case 123680:
503 return DecodeOxmIdXxreg2Masked(_oxmid, decoder)
504 case 69124:
505 return DecodeOxmIdReg7(_oxmid, decoder)
506 case 117884:
507 return DecodeOxmIdTunMetadata62(_oxmid, decoder)
508 case 5634:
509 return DecodeOxmIdUdpSrc(_oxmid, decoder)
510 case 6657:
511 return DecodeOxmIdIcmpType(_oxmid, decoder)
512 case 113656:
513 return DecodeOxmIdTunMetadata53Masked(_oxmid, decoder)
514 case 2147503876:
515 return DecodeOxmIdIpv6ExthdrMasked(_oxmid, decoder)
516 case 198920:
517 return DecodeOxmIdBsnL3InterfaceClassIdMasked(_oxmid, decoder)
518 case 2147489026:
519 return DecodeOxmIdIpProtoMasked(_oxmid, decoder)
520 case 120068:
521 return DecodeOxmIdConnTrackingZoneMasked(_oxmid, decoder)
522 case 1286:
523 return DecodeOxmIdEthSrcMasked(_oxmid, decoder)
524 case 204040:
525 return DecodeOxmIdBsnUdf6Masked(_oxmid, decoder)
526 case 75019:
527 return DecodeOxmIdArpThaMasked(_oxmid, decoder)
528 case 208140:
529 return DecodeOxmIdBsnInnerEthDstMasked(_oxmid, decoder)
530 case 201220:
531 return DecodeOxmIdBsnUdf1(_oxmid, decoder)
532 case 205576:
533 return DecodeOxmIdBsnVlanXlatePortGroupIdMasked(_oxmid, decoder)
534 case 2147484944:
535 return DecodeOxmIdMetadataMasked(_oxmid, decoder)
536 case 6146:
537 return DecodeOxmIdUdpDst(_oxmid, decoder)
538 case 114680:
539 return DecodeOxmIdTunMetadata55Masked(_oxmid, decoder)
540 case 122144:
541 return DecodeOxmIdTunIpv6DstMasked(_oxmid, decoder)
542 case 86652:
543 return DecodeOxmIdTunMetadata1(_oxmid, decoder)
544 case 202244:
545 return DecodeOxmIdBsnUdf3(_oxmid, decoder)
546 case 115704:
547 return DecodeOxmIdTunMetadata57Masked(_oxmid, decoder)
548 case 69636:
549 return DecodeOxmIdReg8(_oxmid, decoder)
550 case 87676:
551 return DecodeOxmIdTunMetadata3(_oxmid, decoder)
552 case 82184:
553 return DecodeOxmIdTunnelIpv4DstMasked(_oxmid, decoder)
554 case 203268:
555 return DecodeOxmIdBsnUdf5(_oxmid, decoder)
556 case 2147492354:
557 return DecodeOxmIdSctpSrc(_oxmid, decoder)
558 case 2147493377:
559 return DecodeOxmIdIcmpv4Type(_oxmid, decoder)
560 case 116728:
561 return DecodeOxmIdTunMetadata59Masked(_oxmid, decoder)
562 case 88700:
563 return DecodeOxmIdTunMetadata5(_oxmid, decoder)
564 case 73220:
565 return DecodeOxmIdReg15(_oxmid, decoder)
566 case 76289:
567 return DecodeOxmIdIcmpv6Type(_oxmid, decoder)
568 case 117752:
569 return DecodeOxmIdTunMetadata61Masked(_oxmid, decoder)
570 case 4360:
571 return DecodeOxmIdIpDstMasked(_oxmid, decoder)
572 case 89724:
573 return DecodeOxmIdTunMetadata7(_oxmid, decoder)
574 case 8708:
575 return DecodeOxmIdArpTpa(_oxmid, decoder)
576 case 118776:
577 return DecodeOxmIdTunMetadata63Masked(_oxmid, decoder)
578 case 199944:
579 return DecodeOxmIdBsnL3DstClassIdMasked(_oxmid, decoder)
580 case 90748:
581 return DecodeOxmIdTunMetadata9(_oxmid, decoder)
582 case 86520:
583 return DecodeOxmIdTunMetadata0Masked(_oxmid, decoder)
584 case 2147487490:
585 return DecodeOxmIdVlanPcpMasked(_oxmid, decoder)
586 case 2147501320:
587 return DecodeOxmIdMplsLabelMasked(_oxmid, decoder)
588 case 197124:
589 return DecodeOxmIdBsnLagId(_oxmid, decoder)
590 case 78849:
591 return DecodeOxmIdIpFrag(_oxmid, decoder)
592 case 200708:
593 return DecodeOxmIdBsnUdf0(_oxmid, decoder)
594 case 91772:
595 return DecodeOxmIdTunMetadata11(_oxmid, decoder)
596 case 87544:
597 return DecodeOxmIdTunMetadata2Masked(_oxmid, decoder)
598 case 207364:
599 return DecodeOxmIdBsnVxlanNetworkId(_oxmid, decoder)
600 case 209410:
601 return DecodeOxmIdBsnVfi(_oxmid, decoder)
602 case 92796:
603 return DecodeOxmIdTunMetadata13(_oxmid, decoder)
604 case 88568:
605 return DecodeOxmIdTunMetadata4Masked(_oxmid, decoder)
606 case 80385:
607 return DecodeOxmIdNwTtl(_oxmid, decoder)
608 case 105976:
609 return DecodeOxmIdTunMetadata38Masked(_oxmid, decoder)
610 case 126465:
611 return DecodeOxmIdConnTrackingNwProto(_oxmid, decoder)
612 case 7682:
613 return DecodeOxmIdArpOp(_oxmid, decoder)
614 case 71172:
615 return DecodeOxmIdReg11(_oxmid, decoder)
616 case 208390:
617 return DecodeOxmIdBsnInnerEthSrc(_oxmid, decoder)
618 case 210178:
619 return DecodeOxmIdBsnIpFragmentationMasked(_oxmid, decoder)
620 case 128528:
621 return DecodeOxmIdConnTrackingIpv6Dst(_oxmid, decoder)
622 case 85252:
623 return DecodeOxmIdTunGbpIdMasked(_oxmid, decoder)
624 case 90616:
625 return DecodeOxmIdTunMetadata8Masked(_oxmid, decoder)
626 case 79364:
627 return DecodeOxmIdIpv6Label(_oxmid, decoder)
628 case 207112:
629 return DecodeOxmIdBsnIngressPortGroupIdMasked(_oxmid, decoder)
630 case 206400:
631 return DecodeOxmIdBsnInPorts512(_oxmid, decoder)
632 case 95868:
633 return DecodeOxmIdTunMetadata19(_oxmid, decoder)
634 case 91640:
635 return DecodeOxmIdTunMetadata10Masked(_oxmid, decoder)
636 case 2147501569:
637 return DecodeOxmIdMplsTc(_oxmid, decoder)
638 case 70920:
639 return DecodeOxmIdReg10Masked(_oxmid, decoder)
640 case 96892:
641 return DecodeOxmIdTunMetadata21(_oxmid, decoder)
642 case 92664:
643 return DecodeOxmIdTunMetadata12Masked(_oxmid, decoder)
644 case 205060:
645 return DecodeOxmIdBsnTcpFlagsMasked(_oxmid, decoder)
646 case 81412:
647 return DecodeOxmIdTunnelIpv4Src(_oxmid, decoder)
648 case 99964:
649 return DecodeOxmIdTunMetadata27(_oxmid, decoder)
650 case 71684:
651 return DecodeOxmIdReg12(_oxmid, decoder)
652 case 127240:
653 return DecodeOxmIdConnTrackingNwSrcMasked(_oxmid, decoder)
654 case 97916:
655 return DecodeOxmIdTunMetadata23(_oxmid, decoder)
656 case 93688:
657 return DecodeOxmIdTunMetadata14Masked(_oxmid, decoder)
658 case 82436:
659 return DecodeOxmIdPktMark(_oxmid, decoder)
660 case 85505:
661 return DecodeOxmIdTunGbpFlags(_oxmid, decoder)
662 case 98940:
663 return DecodeOxmIdTunMetadata25(_oxmid, decoder)
664 case 94712:
665 return DecodeOxmIdTunMetadata16Masked(_oxmid, decoder)
666 case 83460:
667 return DecodeOxmIdDpHash(_oxmid, decoder)
668 case 2147503618:
669 return DecodeOxmIdIpv6Exthdr(_oxmid, decoder)
670 case 123168:
671 return DecodeOxmIdXxreg1Masked(_oxmid, decoder)
672 case 118786:
673 return DecodeOxmIdTunFlags(_oxmid, decoder)
674 case 95736:
675 return DecodeOxmIdTunMetadata18Masked(_oxmid, decoder)
676 case 2308:
677 return DecodeOxmIdVlanTciMasked(_oxmid, decoder)
678 case 2147488002:
679 return DecodeOxmIdIpDscpMasked(_oxmid, decoder)
680 case 100988:
681 return DecodeOxmIdTunMetadata29(_oxmid, decoder)
682 case 119810:
683 return DecodeOxmIdConnTrackingZone(_oxmid, decoder)
684 case 96760:
685 return DecodeOxmIdTunMetadata20Masked(_oxmid, decoder)
686 case 2147486980:
687 return DecodeOxmIdVlanVidMasked(_oxmid, decoder)
688 case 116348:
689 return DecodeOxmIdTunMetadata59(_oxmid, decoder)
690 case 5378:
691 return DecodeOxmIdTcpDstMasked(_oxmid, decoder)
692 case 71944:
693 return DecodeOxmIdReg12Masked(_oxmid, decoder)
694 case 2147483912:
695 return DecodeOxmIdInPortMasked(_oxmid, decoder)
696 case 75552:
697 return DecodeOxmIdIpv6SrcMasked(_oxmid, decoder)
698 case 102012:
699 return DecodeOxmIdTunMetadata31(_oxmid, decoder)
700 case 198402:
701 return DecodeOxmIdBsnGlobalVrfAllowedMasked(_oxmid, decoder)
702 case 5892:
703 return DecodeOxmIdUdpSrcMasked(_oxmid, decoder)
704 case 97784:
705 return DecodeOxmIdTunMetadata22Masked(_oxmid, decoder)
706 case 66052:
707 return DecodeOxmIdReg1(_oxmid, decoder)
708 case 67336:
709 return DecodeOxmIdReg3Masked(_oxmid, decoder)
710 case 208652:
711 return DecodeOxmIdBsnInnerEthSrcMasked(_oxmid, decoder)
712 case 75280:
713 return DecodeOxmIdIpv6Src(_oxmid, decoder)
714 case 197896:
715 return DecodeOxmIdBsnVrfMasked(_oxmid, decoder)
716 case 122656:
717 return DecodeOxmIdXxreg0Masked(_oxmid, decoder)
718 case 103036:
719 return DecodeOxmIdTunMetadata33(_oxmid, decoder)
720 case 98808:
721 return DecodeOxmIdTunMetadata24Masked(_oxmid, decoder)
722 case 67848:
723 return DecodeOxmIdReg4Masked(_oxmid, decoder)
724 case 77600:
725 return DecodeOxmIdNdTargetMasked(_oxmid, decoder)
726 case 104060:
727 return DecodeOxmIdTunMetadata35(_oxmid, decoder)
728 case 99832:
729 return DecodeOxmIdTunMetadata26Masked(_oxmid, decoder)
730 case 6404:
731 return DecodeOxmIdUdpDstMasked(_oxmid, decoder)
732 case 77328:
733 return DecodeOxmIdNdTarget(_oxmid, decoder)
734 case 68872:
735 return DecodeOxmIdReg6Masked(_oxmid, decoder)
736 case 105084:
737 return DecodeOxmIdTunMetadata37(_oxmid, decoder)
738 case 100856:
739 return DecodeOxmIdTunMetadata28Masked(_oxmid, decoder)
740 case 206082:
741 return DecodeOxmIdBsnL2CacheHitMasked(_oxmid, decoder)
742 case 203016:
743 return DecodeOxmIdBsnUdf4Masked(_oxmid, decoder)
744 case 69896:
745 return DecodeOxmIdReg8Masked(_oxmid, decoder)
746 case 206720:
747 return DecodeOxmIdBsnInPorts512Masked(_oxmid, decoder)
748 case 106108:
749 return DecodeOxmIdTunMetadata39(_oxmid, decoder)
750 case 101880:
751 return DecodeOxmIdTunMetadata30Masked(_oxmid, decoder)
752 case 8452:
753 return DecodeOxmIdArpSpaMasked(_oxmid, decoder)
754 case 66312:
755 return DecodeOxmIdReg1Masked(_oxmid, decoder)
756 case 201992:
757 return DecodeOxmIdBsnUdf2Masked(_oxmid, decoder)
758 case 107132:
759 return DecodeOxmIdTunMetadata41(_oxmid, decoder)
760 case 102904:
761 return DecodeOxmIdTunMetadata32Masked(_oxmid, decoder)
762 case 2147493124:
763 return DecodeOxmIdSctpDstMasked(_oxmid, decoder)
764 case 67076:
765 return DecodeOxmIdReg3(_oxmid, decoder)
766 case 119300:
767 return DecodeOxmIdConnTrackingState(_oxmid, decoder)
768 case 2147490056:
769 return DecodeOxmIdIpv4DstMasked(_oxmid, decoder)
770 case 2147499808:
771 return DecodeOxmIdIpv6NdTargetMasked(_oxmid, decoder)
772 case 108156:
773 return DecodeOxmIdTunMetadata43(_oxmid, decoder)
774 case 103928:
775 return DecodeOxmIdTunMetadata34Masked(_oxmid, decoder)
776 case 106488:
777 return DecodeOxmIdTunMetadata39Masked(_oxmid, decoder)
778 case 201732:
779 return DecodeOxmIdBsnUdf2(_oxmid, decoder)
780 case 2147499536:
781 return DecodeOxmIdIpv6NdTarget(_oxmid, decoder)
782 case 72968:
783 return DecodeOxmIdReg14Masked(_oxmid, decoder)
784 case 109180:
785 return DecodeOxmIdTunMetadata45(_oxmid, decoder)
786 case 104952:
787 return DecodeOxmIdTunMetadata36Masked(_oxmid, decoder)
788 case 93820:
789 return DecodeOxmIdTunMetadata15(_oxmid, decoder)
790 case 79106:
791 return DecodeOxmIdIpFragMasked(_oxmid, decoder)
792 case 108536:
793 return DecodeOxmIdTunMetadata43Masked(_oxmid, decoder)
794 case 126980:
795 return DecodeOxmIdConnTrackingNwSrc(_oxmid, decoder)
796 default:
797 return _oxmid, nil
798 }
799}
800
801func NewOxmId(_type_len uint32) *OxmId {
802 obj := &OxmId{}
803 obj.TypeLen = _type_len
804 return obj
805}
806func (self *OxmId) GetOXMName() string {
807 return ""
808}
809
810func (self *OxmId) MarshalJSON() ([]byte, error) {
811 if self.TypeLen == 0 {
812 return []byte("\"\""), nil
813 } else {
814 return []byte("\"" + self.GetOXMName() + "\""), nil
815 }
816}
817
818type ActionNxBundleLoadSlave struct {
819 Port Port
820}
821
822type IActionNxBundleLoadSlave interface {
823 goloxi.Serializable
824 GetPort() Port
825}
826
827func (self *ActionNxBundleLoadSlave) GetPort() Port {
828 return self.Port
829}
830
831func (self *ActionNxBundleLoadSlave) SetPort(v Port) {
832 self.Port = v
833}
834
835func (self *ActionNxBundleLoadSlave) Serialize(encoder *goloxi.Encoder) error {
836
837 encoder.PutUint32(uint32(self.Port))
838
839 return nil
840}
841
842func DecodeActionNxBundleLoadSlave(decoder *goloxi.Decoder) (*ActionNxBundleLoadSlave, error) {
843 _actionnxbundleloadslave := &ActionNxBundleLoadSlave{}
844 if decoder.Length() < 4 {
845 return nil, fmt.Errorf("ActionNxBundleLoadSlave packet too short: %d < 4", decoder.Length())
846 }
847 _actionnxbundleloadslave.Port = Port(decoder.ReadUint32())
848 return _actionnxbundleloadslave, nil
849}
850
851func NewActionNxBundleLoadSlave() *ActionNxBundleLoadSlave {
852 obj := &ActionNxBundleLoadSlave{}
853 return obj
854}
855
856type ActionNxController2Property struct {
857 Type NxActionController2PropType
858}
859
860type IActionNxController2Property interface {
861 goloxi.Serializable
862 GetType() NxActionController2PropType
863}
864
865func (self *ActionNxController2Property) GetType() NxActionController2PropType {
866 return self.Type
867}
868
869func (self *ActionNxController2Property) SetType(v NxActionController2PropType) {
870 self.Type = v
871}
872
873func (self *ActionNxController2Property) Serialize(encoder *goloxi.Encoder) error {
874
875 encoder.PutUint16(uint16(self.Type))
876
877 return nil
878}
879
880func DecodeActionNxController2Property(decoder *goloxi.Decoder) (IActionNxController2Property, error) {
881 _actionnxcontroller2property := &ActionNxController2Property{}
882 if decoder.Length() < 2 {
883 return nil, fmt.Errorf("ActionNxController2Property packet too short: %d < 2", decoder.Length())
884 }
885 _actionnxcontroller2property.Type = NxActionController2PropType(decoder.ReadUint16())
886
887 switch _actionnxcontroller2property.Type {
888 case 0:
889 return DecodeActionNxController2PropertyMaxLen(_actionnxcontroller2property, decoder)
890 case 1:
891 return DecodeActionNxController2PropertyControllerId(_actionnxcontroller2property, decoder)
892 case 2:
893 return DecodeActionNxController2PropertyReason(_actionnxcontroller2property, decoder)
894 case 3:
895 return DecodeActionNxController2PropertyUserdata(_actionnxcontroller2property, decoder)
896 case 4:
897 return DecodeActionNxController2PropertyPause(_actionnxcontroller2property, decoder)
898 case 5:
899 return DecodeActionNxController2PropertyMeterId(_actionnxcontroller2property, decoder)
900 default:
901 return nil, fmt.Errorf("Invalid type '%d' for 'ActionNxController2Property'", _actionnxcontroller2property.Type)
902 }
903}
904
905func NewActionNxController2Property(_type NxActionController2PropType) *ActionNxController2Property {
906 obj := &ActionNxController2Property{}
907 obj.Type = _type
908 return obj
909}
910
911type ActionNxController2PropertyControllerId struct {
912 *ActionNxController2Property
913 ControllerId uint16
914}
915
916type IActionNxController2PropertyControllerId interface {
917 IActionNxController2Property
918 GetControllerId() uint16
919}
920
921func (self *ActionNxController2PropertyControllerId) GetControllerId() uint16 {
922 return self.ControllerId
923}
924
925func (self *ActionNxController2PropertyControllerId) SetControllerId(v uint16) {
926 self.ControllerId = v
927}
928
929func (self *ActionNxController2PropertyControllerId) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]930 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]931 if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
932 return err
933 }
934
935 encoder.PutUint16(uint16(self.ControllerId))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]936 length := len(encoder.Bytes()) - startIndex
937 alignedLength := ((length + 7) / 8 * 8)
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]938
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]939 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]940
941 return nil
942}
943
944func DecodeActionNxController2PropertyControllerId(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyControllerId, error) {
945 _actionnxcontroller2propertycontrollerid := &ActionNxController2PropertyControllerId{ActionNxController2Property: parent}
946 if decoder.Length() < 2 {
947 return nil, fmt.Errorf("ActionNxController2PropertyControllerId packet too short: %d < 2", decoder.Length())
948 }
949 defer decoder.SkipAlign()
950
951 _actionnxcontroller2propertycontrollerid.ControllerId = uint16(decoder.ReadUint16())
952 return _actionnxcontroller2propertycontrollerid, nil
953}
954
955func NewActionNxController2PropertyControllerId() *ActionNxController2PropertyControllerId {
956 obj := &ActionNxController2PropertyControllerId{
957 ActionNxController2Property: NewActionNxController2Property(1),
958 }
959 return obj
960}
961
962type ActionNxController2PropertyMaxLen struct {
963 *ActionNxController2Property
964 MaxLen uint16
965}
966
967type IActionNxController2PropertyMaxLen interface {
968 IActionNxController2Property
969 GetMaxLen() uint16
970}
971
972func (self *ActionNxController2PropertyMaxLen) GetMaxLen() uint16 {
973 return self.MaxLen
974}
975
976func (self *ActionNxController2PropertyMaxLen) SetMaxLen(v uint16) {
977 self.MaxLen = v
978}
979
980func (self *ActionNxController2PropertyMaxLen) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]981 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]982 if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
983 return err
984 }
985
986 encoder.PutUint16(uint16(self.MaxLen))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]987 length := len(encoder.Bytes()) - startIndex
988 alignedLength := ((length + 7) / 8 * 8)
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]989
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]990 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]991
992 return nil
993}
994
995func DecodeActionNxController2PropertyMaxLen(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyMaxLen, error) {
996 _actionnxcontroller2propertymaxlen := &ActionNxController2PropertyMaxLen{ActionNxController2Property: parent}
997 if decoder.Length() < 2 {
998 return nil, fmt.Errorf("ActionNxController2PropertyMaxLen packet too short: %d < 2", decoder.Length())
999 }
1000 defer decoder.SkipAlign()
1001
1002 _actionnxcontroller2propertymaxlen.MaxLen = uint16(decoder.ReadUint16())
1003 return _actionnxcontroller2propertymaxlen, nil
1004}
1005
1006func NewActionNxController2PropertyMaxLen() *ActionNxController2PropertyMaxLen {
1007 obj := &ActionNxController2PropertyMaxLen{
1008 ActionNxController2Property: NewActionNxController2Property(0),
1009 }
1010 return obj
1011}
1012
1013type ActionNxController2PropertyMeterId struct {
1014 *ActionNxController2Property
1015 MeterId uint32
1016}
1017
1018type IActionNxController2PropertyMeterId interface {
1019 IActionNxController2Property
1020 GetMeterId() uint32
1021}
1022
1023func (self *ActionNxController2PropertyMeterId) GetMeterId() uint32 {
1024 return self.MeterId
1025}
1026
1027func (self *ActionNxController2PropertyMeterId) SetMeterId(v uint32) {
1028 self.MeterId = v
1029}
1030
1031func (self *ActionNxController2PropertyMeterId) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]1032 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]1033 if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
1034 return err
1035 }
1036
1037 encoder.PutUint32(uint32(self.MeterId))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]1038 length := len(encoder.Bytes()) - startIndex
1039 alignedLength := ((length + 7) / 8 * 8)
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]1040
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]1041 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]1042
1043 return nil
1044}
1045
1046func DecodeActionNxController2PropertyMeterId(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyMeterId, error) {
1047 _actionnxcontroller2propertymeterid := &ActionNxController2PropertyMeterId{ActionNxController2Property: parent}
1048 if decoder.Length() < 4 {
1049 return nil, fmt.Errorf("ActionNxController2PropertyMeterId packet too short: %d < 4", decoder.Length())
1050 }
1051 defer decoder.SkipAlign()
1052
1053 _actionnxcontroller2propertymeterid.MeterId = uint32(decoder.ReadUint32())
1054 return _actionnxcontroller2propertymeterid, nil
1055}
1056
1057func NewActionNxController2PropertyMeterId() *ActionNxController2PropertyMeterId {
1058 obj := &ActionNxController2PropertyMeterId{
1059 ActionNxController2Property: NewActionNxController2Property(5),
1060 }
1061 return obj
1062}
1063
1064type ActionNxController2PropertyPause struct {
1065 *ActionNxController2Property
1066}
1067
1068type IActionNxController2PropertyPause interface {
1069 IActionNxController2Property
1070}
1071
1072func (self *ActionNxController2PropertyPause) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]1073 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]1074 if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
1075 return err
1076 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]1077 length := len(encoder.Bytes()) - startIndex
1078 alignedLength := ((length + 7) / 8 * 8)
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]1079
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]1080 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]1081
1082 return nil
1083}
1084
1085func DecodeActionNxController2PropertyPause(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyPause, error) {
1086 _actionnxcontroller2propertypause := &ActionNxController2PropertyPause{ActionNxController2Property: parent}
1087 defer decoder.SkipAlign()
1088
1089 return _actionnxcontroller2propertypause, nil
1090}
1091
1092func NewActionNxController2PropertyPause() *ActionNxController2PropertyPause {
1093 obj := &ActionNxController2PropertyPause{
1094 ActionNxController2Property: NewActionNxController2Property(4),
1095 }
1096 return obj
1097}
1098
1099type ActionNxController2PropertyReason struct {
1100 *ActionNxController2Property
1101 Reason PacketInReason
1102}
1103
1104type IActionNxController2PropertyReason interface {
1105 IActionNxController2Property
1106 GetReason() PacketInReason
1107}
1108
1109func (self *ActionNxController2PropertyReason) GetReason() PacketInReason {
1110 return self.Reason
1111}
1112
1113func (self *ActionNxController2PropertyReason) SetReason(v PacketInReason) {
1114 self.Reason = v
1115}
1116
1117func (self *ActionNxController2PropertyReason) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]1118 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]1119 if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
1120 return err
1121 }
1122
1123 encoder.PutUint8(uint8(self.Reason))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]1124 length := len(encoder.Bytes()) - startIndex
1125 alignedLength := ((length + 7) / 8 * 8)
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]1126
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]1127 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]1128
1129 return nil
1130}
1131
1132func DecodeActionNxController2PropertyReason(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyReason, error) {
1133 _actionnxcontroller2propertyreason := &ActionNxController2PropertyReason{ActionNxController2Property: parent}
1134 if decoder.Length() < 1 {
1135 return nil, fmt.Errorf("ActionNxController2PropertyReason packet too short: %d < 1", decoder.Length())
1136 }
1137 defer decoder.SkipAlign()
1138
1139 _actionnxcontroller2propertyreason.Reason = PacketInReason(decoder.ReadByte())
1140 return _actionnxcontroller2propertyreason, nil
1141}
1142
1143func NewActionNxController2PropertyReason() *ActionNxController2PropertyReason {
1144 obj := &ActionNxController2PropertyReason{
1145 ActionNxController2Property: NewActionNxController2Property(2),
1146 }
1147 return obj
1148}
1149
1150type ActionNxController2PropertyUserdata struct {
1151 *ActionNxController2Property
1152 Length uint16
1153 Userdata []byte
1154}
1155
1156type IActionNxController2PropertyUserdata interface {
1157 IActionNxController2Property
1158 GetLength() uint16
1159 GetUserdata() []byte
1160}
1161
1162func (self *ActionNxController2PropertyUserdata) GetLength() uint16 {
1163 return self.Length
1164}
1165
1166func (self *ActionNxController2PropertyUserdata) SetLength(v uint16) {
1167 self.Length = v
1168}
1169
1170func (self *ActionNxController2PropertyUserdata) GetUserdata() []byte {
1171 return self.Userdata
1172}
1173
1174func (self *ActionNxController2PropertyUserdata) SetUserdata(v []byte) {
1175 self.Userdata = v
1176}
1177
1178func (self *ActionNxController2PropertyUserdata) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]1179 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]1180 if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
1181 return err
1182 }
1183
1184 encoder.PutUint16(uint16(self.Length))
1185 encoder.Write(self.Userdata)
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]1186 length := len(encoder.Bytes()) - startIndex
1187 alignedLength := ((length + 7) / 8 * 8)
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]1188
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]1189 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]1190
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]1191 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]1192
1193 return nil
1194}
1195
1196func DecodeActionNxController2PropertyUserdata(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyUserdata, error) {
1197 _actionnxcontroller2propertyuserdata := &ActionNxController2PropertyUserdata{ActionNxController2Property: parent}
1198 if decoder.Length() < 2 {
1199 return nil, fmt.Errorf("ActionNxController2PropertyUserdata packet too short: %d < 2", decoder.Length())
1200 }
1201 defer decoder.SkipAlign()
1202
1203 _actionnxcontroller2propertyuserdata.Length = uint16(decoder.ReadUint16())
1204 oldDecoder := decoder
1205 defer func() { decoder = oldDecoder }()
1206 decoder = decoder.SliceDecoder(int(((_actionnxcontroller2propertyuserdata.Length)+7)/8*8), 2+2)
1207 _actionnxcontroller2propertyuserdata.Userdata = decoder.Read(int(decoder.Length()))
1208 return _actionnxcontroller2propertyuserdata, nil
1209}
1210
1211func NewActionNxController2PropertyUserdata() *ActionNxController2PropertyUserdata {
1212 obj := &ActionNxController2PropertyUserdata{
1213 ActionNxController2Property: NewActionNxController2Property(3),
1214 }
1215 return obj
1216}
1217
1218type BsnControllerConnection struct {
1219 State BsnControllerConnectionState
1220 AuxiliaryId uint8
1221 Role ControllerRole
1222 Uri string
1223}
1224
1225type IBsnControllerConnection interface {
1226 goloxi.Serializable
1227 GetState() BsnControllerConnectionState
1228 GetAuxiliaryId() uint8
1229 GetRole() ControllerRole
1230 GetUri() string
1231}
1232
1233func (self *BsnControllerConnection) GetState() BsnControllerConnectionState {
1234 return self.State
1235}
1236
1237func (self *BsnControllerConnection) SetState(v BsnControllerConnectionState) {
1238 self.State = v
1239}
1240
1241func (self *BsnControllerConnection) GetAuxiliaryId() uint8 {
1242 return self.AuxiliaryId
1243}
1244
1245func (self *BsnControllerConnection) SetAuxiliaryId(v uint8) {
1246 self.AuxiliaryId = v
1247}
1248
1249func (self *BsnControllerConnection) GetRole() ControllerRole {
1250 return self.Role
1251}
1252
1253func (self *BsnControllerConnection) SetRole(v ControllerRole) {
1254 self.Role = v
1255}
1256
1257func (self *BsnControllerConnection) GetUri() string {
1258 return self.Uri
1259}
1260
1261func (self *BsnControllerConnection) SetUri(v string) {
1262 self.Uri = v
1263}
1264
1265func (self *BsnControllerConnection) Serialize(encoder *goloxi.Encoder) error {
1266
1267 encoder.PutUint8(uint8(self.State))
1268 encoder.PutUint8(uint8(self.AuxiliaryId))
1269 encoder.Write(bytes.Repeat([]byte{0}, 2))
1270 encoder.PutUint32(uint32(self.Role))
1271 encoder.Write([]byte(self.Uri))
1272
1273 return nil
1274}
1275
1276func DecodeBsnControllerConnection(decoder *goloxi.Decoder) (*BsnControllerConnection, error) {
1277 _bsncontrollerconnection := &BsnControllerConnection{}
1278 if decoder.Length() < 264 {
1279 return nil, fmt.Errorf("BsnControllerConnection packet too short: %d < 264", decoder.Length())
1280 }
1281 _bsncontrollerconnection.State = BsnControllerConnectionState(decoder.ReadByte())
1282 _bsncontrollerconnection.AuxiliaryId = uint8(decoder.ReadByte())
1283 decoder.Skip(2)
1284 _bsncontrollerconnection.Role = ControllerRole(decoder.ReadUint32())
1285 _bsncontrollerconnection.Uri = string(bytes.Trim(decoder.Read(256), "\x00"))
1286 return _bsncontrollerconnection, nil
1287}
1288
1289func NewBsnControllerConnection() *BsnControllerConnection {
1290 obj := &BsnControllerConnection{}
1291 return obj
1292}
1293
1294type BsnDebugCounterDescStatsEntry struct {
1295 CounterId uint64
1296 Name string
1297 Description string
1298}
1299
1300type IBsnDebugCounterDescStatsEntry interface {
1301 goloxi.Serializable
1302 GetCounterId() uint64
1303 GetName() string
1304 GetDescription() string
1305}
1306
1307func (self *BsnDebugCounterDescStatsEntry) GetCounterId() uint64 {
1308 return self.CounterId
1309}
1310
1311func (self *BsnDebugCounterDescStatsEntry) SetCounterId(v uint64) {
1312 self.CounterId = v
1313}
1314
1315func (self *BsnDebugCounterDescStatsEntry) GetName() string {
1316 return self.Name
1317}
1318
1319func (self *BsnDebugCounterDescStatsEntry) SetName(v string) {
1320 self.Name = v
1321}
1322
1323func (self *BsnDebugCounterDescStatsEntry) GetDescription() string {
1324 return self.Description
1325}
1326
1327func (self *BsnDebugCounterDescStatsEntry) SetDescription(v string) {
1328 self.Description = v
1329}
1330
1331func (self *BsnDebugCounterDescStatsEntry) Serialize(encoder *goloxi.Encoder) error {
1332
1333 encoder.PutUint64(uint64(self.CounterId))
1334 encoder.Write([]byte(self.Name))
1335 encoder.Write([]byte(self.Description))
1336
1337 return nil
1338}
1339
1340func DecodeBsnDebugCounterDescStatsEntry(decoder *goloxi.Decoder) (*BsnDebugCounterDescStatsEntry, error) {
1341 _bsndebugcounterdescstatsentry := &BsnDebugCounterDescStatsEntry{}
1342 if decoder.Length() < 328 {
1343 return nil, fmt.Errorf("BsnDebugCounterDescStatsEntry packet too short: %d < 328", decoder.Length())
1344 }
1345 _bsndebugcounterdescstatsentry.CounterId = uint64(decoder.ReadUint64())
1346 _bsndebugcounterdescstatsentry.Name = string(bytes.Trim(decoder.Read(64), "\x00"))
1347 _bsndebugcounterdescstatsentry.Description = string(bytes.Trim(decoder.Read(256), "\x00"))
1348 return _bsndebugcounterdescstatsentry, nil
1349}
1350
1351func NewBsnDebugCounterDescStatsEntry() *BsnDebugCounterDescStatsEntry {
1352 obj := &BsnDebugCounterDescStatsEntry{}
1353 return obj
1354}
1355
1356type BsnDebugCounterStatsEntry struct {
1357 CounterId uint64
1358 Value uint64
1359}
1360
1361type IBsnDebugCounterStatsEntry interface {
1362 goloxi.Serializable
1363 GetCounterId() uint64
1364 GetValue() uint64
1365}
1366
1367func (self *BsnDebugCounterStatsEntry) GetCounterId() uint64 {
1368 return self.CounterId
1369}
1370
1371func (self *BsnDebugCounterStatsEntry) SetCounterId(v uint64) {
1372 self.CounterId = v
1373}
1374
1375func (self *BsnDebugCounterStatsEntry) GetValue() uint64 {
1376 return self.Value
1377}
1378
1379func (self *BsnDebugCounterStatsEntry) SetValue(v uint64) {
1380 self.Value = v
1381}
1382
1383func (self *BsnDebugCounterStatsEntry) Serialize(encoder *goloxi.Encoder) error {
1384
1385 encoder.PutUint64(uint64(self.CounterId))
1386 encoder.PutUint64(uint64(self.Value))
1387
1388 return nil
1389}
1390
1391func DecodeBsnDebugCounterStatsEntry(decoder *goloxi.Decoder) (*BsnDebugCounterStatsEntry, error) {
1392 _bsndebugcounterstatsentry := &BsnDebugCounterStatsEntry{}
1393 if decoder.Length() < 16 {
1394 return nil, fmt.Errorf("BsnDebugCounterStatsEntry packet too short: %d < 16", decoder.Length())
1395 }
1396 _bsndebugcounterstatsentry.CounterId = uint64(decoder.ReadUint64())
1397 _bsndebugcounterstatsentry.Value = uint64(decoder.ReadUint64())
1398 return _bsndebugcounterstatsentry, nil
1399}
1400
1401func NewBsnDebugCounterStatsEntry() *BsnDebugCounterStatsEntry {
1402 obj := &BsnDebugCounterStatsEntry{}
1403 return obj
1404}
1405
1406type BsnFlowChecksumBucketStatsEntry struct {
1407 Checksum uint64
1408}
1409
1410type IBsnFlowChecksumBucketStatsEntry interface {
1411 goloxi.Serializable
1412 GetChecksum() uint64
1413}
1414
1415func (self *BsnFlowChecksumBucketStatsEntry) GetChecksum() uint64 {
1416 return self.Checksum
1417}
1418
1419func (self *BsnFlowChecksumBucketStatsEntry) SetChecksum(v uint64) {
1420 self.Checksum = v
1421}
1422
1423func (self *BsnFlowChecksumBucketStatsEntry) Serialize(encoder *goloxi.Encoder) error {
1424
1425 encoder.PutUint64(uint64(self.Checksum))
1426
1427 return nil
1428}
1429
1430func DecodeBsnFlowChecksumBucketStatsEntry(decoder *goloxi.Decoder) (*BsnFlowChecksumBucketStatsEntry, error) {
1431 _bsnflowchecksumbucketstatsentry := &BsnFlowChecksumBucketStatsEntry{}
1432 if decoder.Length() < 8 {
1433 return nil, fmt.Errorf("BsnFlowChecksumBucketStatsEntry packet too short: %d < 8", decoder.Length())
1434 }
1435 _bsnflowchecksumbucketstatsentry.Checksum = uint64(decoder.ReadUint64())
1436 return _bsnflowchecksumbucketstatsentry, nil
1437}
1438
1439func NewBsnFlowChecksumBucketStatsEntry() *BsnFlowChecksumBucketStatsEntry {
1440 obj := &BsnFlowChecksumBucketStatsEntry{}
1441 return obj
1442}
1443
1444type BsnGenericStatsEntry struct {
1445 Length uint16
1446 Tlvs []IBsnTlv
1447}
1448
1449type IBsnGenericStatsEntry interface {
1450 goloxi.Serializable
1451 GetLength() uint16
1452 GetTlvs() []IBsnTlv
1453}
1454
1455func (self *BsnGenericStatsEntry) GetLength() uint16 {
1456 return self.Length
1457}
1458
1459func (self *BsnGenericStatsEntry) SetLength(v uint16) {
1460 self.Length = v
1461}
1462
1463func (self *BsnGenericStatsEntry) GetTlvs() []IBsnTlv {
1464 return self.Tlvs
1465}
1466
1467func (self *BsnGenericStatsEntry) SetTlvs(v []IBsnTlv) {
1468 self.Tlvs = v
1469}
1470
1471func (self *BsnGenericStatsEntry) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]1472 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]1473
1474 encoder.PutUint16(uint16(self.Length))
1475 for _, obj := range self.Tlvs {
1476 if err := obj.Serialize(encoder); err != nil {
1477 return err
1478 }
1479 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]1480 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]1481
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]1482 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]1483
1484 return nil
1485}
1486
1487func DecodeBsnGenericStatsEntry(decoder *goloxi.Decoder) (*BsnGenericStatsEntry, error) {
1488 _bsngenericstatsentry := &BsnGenericStatsEntry{}
1489 if decoder.Length() < 2 {
1490 return nil, fmt.Errorf("BsnGenericStatsEntry packet too short: %d < 2", decoder.Length())
1491 }
1492 _bsngenericstatsentry.Length = uint16(decoder.ReadUint16())
1493 oldDecoder := decoder
1494 defer func() { decoder = oldDecoder }()
1495 decoder = decoder.SliceDecoder(int(_bsngenericstatsentry.Length), 2+0)
1496
1497 for decoder.Length() >= 4 {
1498 item, err := DecodeBsnTlv(decoder)
1499 if err != nil {
1500 return nil, err
1501 }
1502 if item != nil {
1503 _bsngenericstatsentry.Tlvs = append(_bsngenericstatsentry.Tlvs, item)
1504 }
1505 }
1506 return _bsngenericstatsentry, nil
1507}
1508
1509func NewBsnGenericStatsEntry() *BsnGenericStatsEntry {
1510 obj := &BsnGenericStatsEntry{}
1511 return obj
1512}
1513
1514type BsnGentableBucketStatsEntry struct {
1515 Checksum Checksum128
1516}
1517
1518type IBsnGentableBucketStatsEntry interface {
1519 goloxi.Serializable
1520 GetChecksum() Checksum128
1521}
1522
1523func (self *BsnGentableBucketStatsEntry) GetChecksum() Checksum128 {
1524 return self.Checksum
1525}
1526
1527func (self *BsnGentableBucketStatsEntry) SetChecksum(v Checksum128) {
1528 self.Checksum = v
1529}
1530
1531func (self *BsnGentableBucketStatsEntry) Serialize(encoder *goloxi.Encoder) error {
1532
1533 self.Checksum.Serialize(encoder)
1534
1535 return nil
1536}
1537
1538func DecodeBsnGentableBucketStatsEntry(decoder *goloxi.Decoder) (*BsnGentableBucketStatsEntry, error) {
1539 _bsngentablebucketstatsentry := &BsnGentableBucketStatsEntry{}
1540 if decoder.Length() < 16 {
1541 return nil, fmt.Errorf("BsnGentableBucketStatsEntry packet too short: %d < 16", decoder.Length())
1542 }
1543 _bsngentablebucketstatsentry.Checksum.Decode(decoder)
1544 return _bsngentablebucketstatsentry, nil
1545}
1546
1547func NewBsnGentableBucketStatsEntry() *BsnGentableBucketStatsEntry {
1548 obj := &BsnGentableBucketStatsEntry{}
1549 return obj
1550}
1551
1552type BsnGentableDescStatsEntry struct {
1553 Length uint16
1554 TableId uint16
1555 Name string
1556 BucketsSize uint32
1557 MaxEntries uint32
1558}
1559
1560type IBsnGentableDescStatsEntry interface {
1561 goloxi.Serializable
1562 GetLength() uint16
1563 GetTableId() uint16
1564 GetName() string
1565 GetBucketsSize() uint32
1566 GetMaxEntries() uint32
1567}
1568
1569func (self *BsnGentableDescStatsEntry) GetLength() uint16 {
1570 return self.Length
1571}
1572
1573func (self *BsnGentableDescStatsEntry) SetLength(v uint16) {
1574 self.Length = v
1575}
1576
1577func (self *BsnGentableDescStatsEntry) GetTableId() uint16 {
1578 return self.TableId
1579}
1580
1581func (self *BsnGentableDescStatsEntry) SetTableId(v uint16) {
1582 self.TableId = v
1583}
1584
1585func (self *BsnGentableDescStatsEntry) GetName() string {
1586 return self.Name
1587}
1588
1589func (self *BsnGentableDescStatsEntry) SetName(v string) {
1590 self.Name = v
1591}
1592
1593func (self *BsnGentableDescStatsEntry) GetBucketsSize() uint32 {
1594 return self.BucketsSize
1595}
1596
1597func (self *BsnGentableDescStatsEntry) SetBucketsSize(v uint32) {
1598 self.BucketsSize = v
1599}
1600
1601func (self *BsnGentableDescStatsEntry) GetMaxEntries() uint32 {
1602 return self.MaxEntries
1603}
1604
1605func (self *BsnGentableDescStatsEntry) SetMaxEntries(v uint32) {
1606 self.MaxEntries = v
1607}
1608
1609func (self *BsnGentableDescStatsEntry) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]1610 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]1611
1612 encoder.PutUint16(uint16(self.Length))
1613 encoder.PutUint16(uint16(self.TableId))
1614 encoder.Write([]byte(self.Name))
1615 encoder.PutUint32(uint32(self.BucketsSize))
1616 encoder.PutUint32(uint32(self.MaxEntries))
1617 encoder.Write(bytes.Repeat([]byte{0}, 4))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]1618 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]1619
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]1620 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]1621
1622 return nil
1623}
1624
1625func DecodeBsnGentableDescStatsEntry(decoder *goloxi.Decoder) (*BsnGentableDescStatsEntry, error) {
1626 _bsngentabledescstatsentry := &BsnGentableDescStatsEntry{}
1627 if decoder.Length() < 48 {
1628 return nil, fmt.Errorf("BsnGentableDescStatsEntry packet too short: %d < 48", decoder.Length())
1629 }
1630 _bsngentabledescstatsentry.Length = uint16(decoder.ReadUint16())
1631 oldDecoder := decoder
1632 defer func() { decoder = oldDecoder }()
1633 decoder = decoder.SliceDecoder(int(_bsngentabledescstatsentry.Length), 2+0)
1634 _bsngentabledescstatsentry.TableId = uint16(decoder.ReadUint16())
1635 _bsngentabledescstatsentry.Name = string(bytes.Trim(decoder.Read(32), "\x00"))
1636 _bsngentabledescstatsentry.BucketsSize = uint32(decoder.ReadUint32())
1637 _bsngentabledescstatsentry.MaxEntries = uint32(decoder.ReadUint32())
1638 decoder.Skip(4)
1639 return _bsngentabledescstatsentry, nil
1640}
1641
1642func NewBsnGentableDescStatsEntry() *BsnGentableDescStatsEntry {
1643 obj := &BsnGentableDescStatsEntry{}
1644 return obj
1645}
1646
1647type BsnGentableEntryDescStatsEntry struct {
1648 Length uint16
1649 KeyLength uint16
1650 Checksum Checksum128
1651 Key []IBsnTlv
1652 Value []IBsnTlv
1653}
1654
1655type IBsnGentableEntryDescStatsEntry interface {
1656 goloxi.Serializable
1657 GetLength() uint16
1658 GetKeyLength() uint16
1659 GetChecksum() Checksum128
1660 GetKey() []IBsnTlv
1661 GetValue() []IBsnTlv
1662}
1663
1664func (self *BsnGentableEntryDescStatsEntry) GetLength() uint16 {
1665 return self.Length
1666}
1667
1668func (self *BsnGentableEntryDescStatsEntry) SetLength(v uint16) {
1669 self.Length = v
1670}
1671
1672func (self *BsnGentableEntryDescStatsEntry) GetKeyLength() uint16 {
1673 return self.KeyLength
1674}
1675
1676func (self *BsnGentableEntryDescStatsEntry) SetKeyLength(v uint16) {
1677 self.KeyLength = v
1678}
1679
1680func (self *BsnGentableEntryDescStatsEntry) GetChecksum() Checksum128 {
1681 return self.Checksum
1682}
1683
1684func (self *BsnGentableEntryDescStatsEntry) SetChecksum(v Checksum128) {
1685 self.Checksum = v
1686}
1687
1688func (self *BsnGentableEntryDescStatsEntry) GetKey() []IBsnTlv {
1689 return self.Key
1690}
1691
1692func (self *BsnGentableEntryDescStatsEntry) SetKey(v []IBsnTlv) {
1693 self.Key = v
1694}
1695
1696func (self *BsnGentableEntryDescStatsEntry) GetValue() []IBsnTlv {
1697 return self.Value
1698}
1699
1700func (self *BsnGentableEntryDescStatsEntry) SetValue(v []IBsnTlv) {
1701 self.Value = v
1702}
1703
1704func (self *BsnGentableEntryDescStatsEntry) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]1705 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]1706
1707 encoder.PutUint16(uint16(self.Length))
1708 encoder.PutUint16(uint16(self.KeyLength))
1709 self.Checksum.Serialize(encoder)
1710 for _, obj := range self.Key {
1711 if err := obj.Serialize(encoder); err != nil {
1712 return err
1713 }
1714 }
1715 for _, obj := range self.Value {
1716 if err := obj.Serialize(encoder); err != nil {
1717 return err
1718 }
1719 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]1720 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]1721
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]1722 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]1723
1724 return nil
1725}
1726
1727func DecodeBsnGentableEntryDescStatsEntry(decoder *goloxi.Decoder) (*BsnGentableEntryDescStatsEntry, error) {
1728 _bsngentableentrydescstatsentry := &BsnGentableEntryDescStatsEntry{}
1729 if decoder.Length() < 20 {
1730 return nil, fmt.Errorf("BsnGentableEntryDescStatsEntry packet too short: %d < 20", decoder.Length())
1731 }
1732 _bsngentableentrydescstatsentry.Length = uint16(decoder.ReadUint16())
1733 oldDecoder := decoder
1734 defer func() { decoder = oldDecoder }()
1735 decoder = decoder.SliceDecoder(int(_bsngentableentrydescstatsentry.Length), 2+0)
1736 _bsngentableentrydescstatsentry.KeyLength = uint16(decoder.ReadUint16())
1737 _bsngentableentrydescstatsentry.Checksum.Decode(decoder)
1738
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]1739 end := decoder.Offset() + int(_bsngentableentrydescstatsentry.KeyLength)
1740 for decoder.Offset() < end {
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]1741 item, err := DecodeBsnTlv(decoder)
1742 if err != nil {
1743 return nil, err
1744 }
1745 if item != nil {
1746 _bsngentableentrydescstatsentry.Key = append(_bsngentableentrydescstatsentry.Key, item)
1747 }
1748 }
1749
1750 for decoder.Length() >= 4 {
1751 item, err := DecodeBsnTlv(decoder)
1752 if err != nil {
1753 return nil, err
1754 }
1755 if item != nil {
1756 _bsngentableentrydescstatsentry.Value = append(_bsngentableentrydescstatsentry.Value, item)
1757 }
1758 }
1759 return _bsngentableentrydescstatsentry, nil
1760}
1761
1762func NewBsnGentableEntryDescStatsEntry() *BsnGentableEntryDescStatsEntry {
1763 obj := &BsnGentableEntryDescStatsEntry{}
1764 return obj
1765}
1766
1767type BsnGentableEntryStatsEntry struct {
1768 Length uint16
1769 KeyLength uint16
1770 Key []IBsnTlv
1771 Stats []IBsnTlv
1772}
1773
1774type IBsnGentableEntryStatsEntry interface {
1775 goloxi.Serializable
1776 GetLength() uint16
1777 GetKeyLength() uint16
1778 GetKey() []IBsnTlv
1779 GetStats() []IBsnTlv
1780}
1781
1782func (self *BsnGentableEntryStatsEntry) GetLength() uint16 {
1783 return self.Length
1784}
1785
1786func (self *BsnGentableEntryStatsEntry) SetLength(v uint16) {
1787 self.Length = v
1788}
1789
1790func (self *BsnGentableEntryStatsEntry) GetKeyLength() uint16 {
1791 return self.KeyLength
1792}
1793
1794func (self *BsnGentableEntryStatsEntry) SetKeyLength(v uint16) {
1795 self.KeyLength = v
1796}
1797
1798func (self *BsnGentableEntryStatsEntry) GetKey() []IBsnTlv {
1799 return self.Key
1800}
1801
1802func (self *BsnGentableEntryStatsEntry) SetKey(v []IBsnTlv) {
1803 self.Key = v
1804}
1805
1806func (self *BsnGentableEntryStatsEntry) GetStats() []IBsnTlv {
1807 return self.Stats
1808}
1809
1810func (self *BsnGentableEntryStatsEntry) SetStats(v []IBsnTlv) {
1811 self.Stats = v
1812}
1813
1814func (self *BsnGentableEntryStatsEntry) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]1815 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]1816
1817 encoder.PutUint16(uint16(self.Length))
1818 encoder.PutUint16(uint16(self.KeyLength))
1819 for _, obj := range self.Key {
1820 if err := obj.Serialize(encoder); err != nil {
1821 return err
1822 }
1823 }
1824 for _, obj := range self.Stats {
1825 if err := obj.Serialize(encoder); err != nil {
1826 return err
1827 }
1828 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]1829 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]1830
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]1831 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]1832
1833 return nil
1834}
1835
1836func DecodeBsnGentableEntryStatsEntry(decoder *goloxi.Decoder) (*BsnGentableEntryStatsEntry, error) {
1837 _bsngentableentrystatsentry := &BsnGentableEntryStatsEntry{}
1838 if decoder.Length() < 4 {
1839 return nil, fmt.Errorf("BsnGentableEntryStatsEntry packet too short: %d < 4", decoder.Length())
1840 }
1841 _bsngentableentrystatsentry.Length = uint16(decoder.ReadUint16())
1842 oldDecoder := decoder
1843 defer func() { decoder = oldDecoder }()
1844 decoder = decoder.SliceDecoder(int(_bsngentableentrystatsentry.Length), 2+0)
1845 _bsngentableentrystatsentry.KeyLength = uint16(decoder.ReadUint16())
1846
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]1847 end := decoder.Offset() + int(_bsngentableentrystatsentry.KeyLength)
1848 for decoder.Offset() < end {
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]1849 item, err := DecodeBsnTlv(decoder)
1850 if err != nil {
1851 return nil, err
1852 }
1853 if item != nil {
1854 _bsngentableentrystatsentry.Key = append(_bsngentableentrystatsentry.Key, item)
1855 }
1856 }
1857
1858 for decoder.Length() >= 4 {
1859 item, err := DecodeBsnTlv(decoder)
1860 if err != nil {
1861 return nil, err
1862 }
1863 if item != nil {
1864 _bsngentableentrystatsentry.Stats = append(_bsngentableentrystatsentry.Stats, item)
1865 }
1866 }
1867 return _bsngentableentrystatsentry, nil
1868}
1869
1870func NewBsnGentableEntryStatsEntry() *BsnGentableEntryStatsEntry {
1871 obj := &BsnGentableEntryStatsEntry{}
1872 return obj
1873}
1874
1875type BsnGentableStatsEntry struct {
1876 TableId uint16
1877 EntryCount uint32
1878 Checksum Checksum128
1879}
1880
1881type IBsnGentableStatsEntry interface {
1882 goloxi.Serializable
1883 GetTableId() uint16
1884 GetEntryCount() uint32
1885 GetChecksum() Checksum128
1886}
1887
1888func (self *BsnGentableStatsEntry) GetTableId() uint16 {
1889 return self.TableId
1890}
1891
1892func (self *BsnGentableStatsEntry) SetTableId(v uint16) {
1893 self.TableId = v
1894}
1895
1896func (self *BsnGentableStatsEntry) GetEntryCount() uint32 {
1897 return self.EntryCount
1898}
1899
1900func (self *BsnGentableStatsEntry) SetEntryCount(v uint32) {
1901 self.EntryCount = v
1902}
1903
1904func (self *BsnGentableStatsEntry) GetChecksum() Checksum128 {
1905 return self.Checksum
1906}
1907
1908func (self *BsnGentableStatsEntry) SetChecksum(v Checksum128) {
1909 self.Checksum = v
1910}
1911
1912func (self *BsnGentableStatsEntry) Serialize(encoder *goloxi.Encoder) error {
1913
1914 encoder.PutUint16(uint16(self.TableId))
1915 encoder.Write(bytes.Repeat([]byte{0}, 2))
1916 encoder.PutUint32(uint32(self.EntryCount))
1917 self.Checksum.Serialize(encoder)
1918
1919 return nil
1920}
1921
1922func DecodeBsnGentableStatsEntry(decoder *goloxi.Decoder) (*BsnGentableStatsEntry, error) {
1923 _bsngentablestatsentry := &BsnGentableStatsEntry{}
1924 if decoder.Length() < 24 {
1925 return nil, fmt.Errorf("BsnGentableStatsEntry packet too short: %d < 24", decoder.Length())
1926 }
1927 _bsngentablestatsentry.TableId = uint16(decoder.ReadUint16())
1928 decoder.Skip(2)
1929 _bsngentablestatsentry.EntryCount = uint32(decoder.ReadUint32())
1930 _bsngentablestatsentry.Checksum.Decode(decoder)
1931 return _bsngentablestatsentry, nil
1932}
1933
1934func NewBsnGentableStatsEntry() *BsnGentableStatsEntry {
1935 obj := &BsnGentableStatsEntry{}
1936 return obj
1937}
1938
1939type BsnInterface struct {
1940 HwAddr net.HardwareAddr
1941 Name string
1942 Ipv4Addr net.IP
1943 Ipv4Netmask net.IP
1944}
1945
1946type IBsnInterface interface {
1947 goloxi.Serializable
1948 GetHwAddr() net.HardwareAddr
1949 GetName() string
1950 GetIpv4Addr() net.IP
1951 GetIpv4Netmask() net.IP
1952}
1953
1954func (self *BsnInterface) GetHwAddr() net.HardwareAddr {
1955 return self.HwAddr
1956}
1957
1958func (self *BsnInterface) SetHwAddr(v net.HardwareAddr) {
1959 self.HwAddr = v
1960}
1961
1962func (self *BsnInterface) GetName() string {
1963 return self.Name
1964}
1965
1966func (self *BsnInterface) SetName(v string) {
1967 self.Name = v
1968}
1969
1970func (self *BsnInterface) GetIpv4Addr() net.IP {
1971 return self.Ipv4Addr
1972}
1973
1974func (self *BsnInterface) SetIpv4Addr(v net.IP) {
1975 self.Ipv4Addr = v
1976}
1977
1978func (self *BsnInterface) GetIpv4Netmask() net.IP {
1979 return self.Ipv4Netmask
1980}
1981
1982func (self *BsnInterface) SetIpv4Netmask(v net.IP) {
1983 self.Ipv4Netmask = v
1984}
1985
1986func (self *BsnInterface) Serialize(encoder *goloxi.Encoder) error {
1987
1988 encoder.Write(self.HwAddr)
1989 encoder.Write(bytes.Repeat([]byte{0}, 2))
1990 encoder.Write([]byte(self.Name))
1991 encoder.Write(self.Ipv4Addr.To4())
1992 encoder.Write(self.Ipv4Netmask.To4())
1993
1994 return nil
1995}
1996
1997func DecodeBsnInterface(decoder *goloxi.Decoder) (*BsnInterface, error) {
1998 _bsninterface := &BsnInterface{}
1999 if decoder.Length() < 32 {
2000 return nil, fmt.Errorf("BsnInterface packet too short: %d < 32", decoder.Length())
2001 }
2002 _bsninterface.HwAddr = net.HardwareAddr(decoder.Read(6))
2003 decoder.Skip(2)
2004 _bsninterface.Name = string(bytes.Trim(decoder.Read(16), "\x00"))
2005 _bsninterface.Ipv4Addr = net.IP(decoder.Read(4))
2006 _bsninterface.Ipv4Netmask = net.IP(decoder.Read(4))
2007 return _bsninterface, nil
2008}
2009
2010func NewBsnInterface() *BsnInterface {
2011 obj := &BsnInterface{}
2012 return obj
2013}
2014
2015type BsnLacpStatsEntry struct {
2016 PortNo Port
2017 ActorSysPriority uint16
2018 ActorSysMac net.HardwareAddr
2019 ActorPortPriority uint16
2020 ActorPortNum uint16
2021 ActorKey uint16
2022 ConvergenceStatus uint8
2023 PartnerSysPriority uint16
2024 PartnerSysMac net.HardwareAddr
2025 PartnerPortPriority uint16
2026 PartnerPortNum uint16
2027 PartnerKey uint16
2028}
2029
2030type IBsnLacpStatsEntry interface {
2031 goloxi.Serializable
2032 GetPortNo() Port
2033 GetActorSysPriority() uint16
2034 GetActorSysMac() net.HardwareAddr
2035 GetActorPortPriority() uint16
2036 GetActorPortNum() uint16
2037 GetActorKey() uint16
2038 GetConvergenceStatus() uint8
2039 GetPartnerSysPriority() uint16
2040 GetPartnerSysMac() net.HardwareAddr
2041 GetPartnerPortPriority() uint16
2042 GetPartnerPortNum() uint16
2043 GetPartnerKey() uint16
2044}
2045
2046func (self *BsnLacpStatsEntry) GetPortNo() Port {
2047 return self.PortNo
2048}
2049
2050func (self *BsnLacpStatsEntry) SetPortNo(v Port) {
2051 self.PortNo = v
2052}
2053
2054func (self *BsnLacpStatsEntry) GetActorSysPriority() uint16 {
2055 return self.ActorSysPriority
2056}
2057
2058func (self *BsnLacpStatsEntry) SetActorSysPriority(v uint16) {
2059 self.ActorSysPriority = v
2060}
2061
2062func (self *BsnLacpStatsEntry) GetActorSysMac() net.HardwareAddr {
2063 return self.ActorSysMac
2064}
2065
2066func (self *BsnLacpStatsEntry) SetActorSysMac(v net.HardwareAddr) {
2067 self.ActorSysMac = v
2068}
2069
2070func (self *BsnLacpStatsEntry) GetActorPortPriority() uint16 {
2071 return self.ActorPortPriority
2072}
2073
2074func (self *BsnLacpStatsEntry) SetActorPortPriority(v uint16) {
2075 self.ActorPortPriority = v
2076}
2077
2078func (self *BsnLacpStatsEntry) GetActorPortNum() uint16 {
2079 return self.ActorPortNum
2080}
2081
2082func (self *BsnLacpStatsEntry) SetActorPortNum(v uint16) {
2083 self.ActorPortNum = v
2084}
2085
2086func (self *BsnLacpStatsEntry) GetActorKey() uint16 {
2087 return self.ActorKey
2088}
2089
2090func (self *BsnLacpStatsEntry) SetActorKey(v uint16) {
2091 self.ActorKey = v
2092}
2093
2094func (self *BsnLacpStatsEntry) GetConvergenceStatus() uint8 {
2095 return self.ConvergenceStatus
2096}
2097
2098func (self *BsnLacpStatsEntry) SetConvergenceStatus(v uint8) {
2099 self.ConvergenceStatus = v
2100}
2101
2102func (self *BsnLacpStatsEntry) GetPartnerSysPriority() uint16 {
2103 return self.PartnerSysPriority
2104}
2105
2106func (self *BsnLacpStatsEntry) SetPartnerSysPriority(v uint16) {
2107 self.PartnerSysPriority = v
2108}
2109
2110func (self *BsnLacpStatsEntry) GetPartnerSysMac() net.HardwareAddr {
2111 return self.PartnerSysMac
2112}
2113
2114func (self *BsnLacpStatsEntry) SetPartnerSysMac(v net.HardwareAddr) {
2115 self.PartnerSysMac = v
2116}
2117
2118func (self *BsnLacpStatsEntry) GetPartnerPortPriority() uint16 {
2119 return self.PartnerPortPriority
2120}
2121
2122func (self *BsnLacpStatsEntry) SetPartnerPortPriority(v uint16) {
2123 self.PartnerPortPriority = v
2124}
2125
2126func (self *BsnLacpStatsEntry) GetPartnerPortNum() uint16 {
2127 return self.PartnerPortNum
2128}
2129
2130func (self *BsnLacpStatsEntry) SetPartnerPortNum(v uint16) {
2131 self.PartnerPortNum = v
2132}
2133
2134func (self *BsnLacpStatsEntry) GetPartnerKey() uint16 {
2135 return self.PartnerKey
2136}
2137
2138func (self *BsnLacpStatsEntry) SetPartnerKey(v uint16) {
2139 self.PartnerKey = v
2140}
2141
2142func (self *BsnLacpStatsEntry) Serialize(encoder *goloxi.Encoder) error {
2143
2144 self.PortNo.Serialize(encoder)
2145 encoder.PutUint16(uint16(self.ActorSysPriority))
2146 encoder.Write(self.ActorSysMac)
2147 encoder.PutUint16(uint16(self.ActorPortPriority))
2148 encoder.PutUint16(uint16(self.ActorPortNum))
2149 encoder.PutUint16(uint16(self.ActorKey))
2150 encoder.PutUint8(uint8(self.ConvergenceStatus))
2151 encoder.Write(bytes.Repeat([]byte{0}, 1))
2152 encoder.PutUint16(uint16(self.PartnerSysPriority))
2153 encoder.Write(self.PartnerSysMac)
2154 encoder.PutUint16(uint16(self.PartnerPortPriority))
2155 encoder.PutUint16(uint16(self.PartnerPortNum))
2156 encoder.PutUint16(uint16(self.PartnerKey))
2157 encoder.Write(bytes.Repeat([]byte{0}, 2))
2158
2159 return nil
2160}
2161
2162func DecodeBsnLacpStatsEntry(decoder *goloxi.Decoder) (*BsnLacpStatsEntry, error) {
2163 _bsnlacpstatsentry := &BsnLacpStatsEntry{}
2164 if decoder.Length() < 36 {
2165 return nil, fmt.Errorf("BsnLacpStatsEntry packet too short: %d < 36", decoder.Length())
2166 }
2167 _bsnlacpstatsentry.PortNo.Decode(decoder)
2168 _bsnlacpstatsentry.ActorSysPriority = uint16(decoder.ReadUint16())
2169 _bsnlacpstatsentry.ActorSysMac = net.HardwareAddr(decoder.Read(6))
2170 _bsnlacpstatsentry.ActorPortPriority = uint16(decoder.ReadUint16())
2171 _bsnlacpstatsentry.ActorPortNum = uint16(decoder.ReadUint16())
2172 _bsnlacpstatsentry.ActorKey = uint16(decoder.ReadUint16())
2173 _bsnlacpstatsentry.ConvergenceStatus = uint8(decoder.ReadByte())
2174 decoder.Skip(1)
2175 _bsnlacpstatsentry.PartnerSysPriority = uint16(decoder.ReadUint16())
2176 _bsnlacpstatsentry.PartnerSysMac = net.HardwareAddr(decoder.Read(6))
2177 _bsnlacpstatsentry.PartnerPortPriority = uint16(decoder.ReadUint16())
2178 _bsnlacpstatsentry.PartnerPortNum = uint16(decoder.ReadUint16())
2179 _bsnlacpstatsentry.PartnerKey = uint16(decoder.ReadUint16())
2180 decoder.Skip(2)
2181 return _bsnlacpstatsentry, nil
2182}
2183
2184func NewBsnLacpStatsEntry() *BsnLacpStatsEntry {
2185 obj := &BsnLacpStatsEntry{}
2186 return obj
2187}
2188
2189type BsnPortCounterStatsEntry struct {
2190 Length uint16
2191 PortNo Port
2192 Values []*Uint64
2193}
2194
2195type IBsnPortCounterStatsEntry interface {
2196 goloxi.Serializable
2197 GetLength() uint16
2198 GetPortNo() Port
2199 GetValues() []*Uint64
2200}
2201
2202func (self *BsnPortCounterStatsEntry) GetLength() uint16 {
2203 return self.Length
2204}
2205
2206func (self *BsnPortCounterStatsEntry) SetLength(v uint16) {
2207 self.Length = v
2208}
2209
2210func (self *BsnPortCounterStatsEntry) GetPortNo() Port {
2211 return self.PortNo
2212}
2213
2214func (self *BsnPortCounterStatsEntry) SetPortNo(v Port) {
2215 self.PortNo = v
2216}
2217
2218func (self *BsnPortCounterStatsEntry) GetValues() []*Uint64 {
2219 return self.Values
2220}
2221
2222func (self *BsnPortCounterStatsEntry) SetValues(v []*Uint64) {
2223 self.Values = v
2224}
2225
2226func (self *BsnPortCounterStatsEntry) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]2227 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]2228
2229 encoder.PutUint16(uint16(self.Length))
2230 encoder.Write(bytes.Repeat([]byte{0}, 2))
2231 self.PortNo.Serialize(encoder)
2232 for _, obj := range self.Values {
2233 if err := obj.Serialize(encoder); err != nil {
2234 return err
2235 }
2236 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]2237 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]2238
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]2239 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]2240
2241 return nil
2242}
2243
2244func DecodeBsnPortCounterStatsEntry(decoder *goloxi.Decoder) (*BsnPortCounterStatsEntry, error) {
2245 _bsnportcounterstatsentry := &BsnPortCounterStatsEntry{}
2246 if decoder.Length() < 8 {
2247 return nil, fmt.Errorf("BsnPortCounterStatsEntry packet too short: %d < 8", decoder.Length())
2248 }
2249 _bsnportcounterstatsentry.Length = uint16(decoder.ReadUint16())
2250 oldDecoder := decoder
2251 defer func() { decoder = oldDecoder }()
2252 decoder = decoder.SliceDecoder(int(_bsnportcounterstatsentry.Length), 2+0)
2253 decoder.Skip(2)
2254 _bsnportcounterstatsentry.PortNo.Decode(decoder)
2255
2256 for decoder.Length() >= 8 {
2257 item, err := DecodeUint64(decoder)
2258 if err != nil {
2259 return nil, err
2260 }
2261 if item != nil {
2262 _bsnportcounterstatsentry.Values = append(_bsnportcounterstatsentry.Values, item)
2263 }
2264 }
2265 return _bsnportcounterstatsentry, nil
2266}
2267
2268func NewBsnPortCounterStatsEntry() *BsnPortCounterStatsEntry {
2269 obj := &BsnPortCounterStatsEntry{}
2270 return obj
2271}
2272
2273type BsnSwitchPipelineStatsEntry struct {
2274 Pipeline string
2275}
2276
2277type IBsnSwitchPipelineStatsEntry interface {
2278 goloxi.Serializable
2279 GetPipeline() string
2280}
2281
2282func (self *BsnSwitchPipelineStatsEntry) GetPipeline() string {
2283 return self.Pipeline
2284}
2285
2286func (self *BsnSwitchPipelineStatsEntry) SetPipeline(v string) {
2287 self.Pipeline = v
2288}
2289
2290func (self *BsnSwitchPipelineStatsEntry) Serialize(encoder *goloxi.Encoder) error {
2291
2292 encoder.Write([]byte(self.Pipeline))
2293
2294 return nil
2295}
2296
2297func DecodeBsnSwitchPipelineStatsEntry(decoder *goloxi.Decoder) (*BsnSwitchPipelineStatsEntry, error) {
2298 _bsnswitchpipelinestatsentry := &BsnSwitchPipelineStatsEntry{}
2299 if decoder.Length() < 256 {
2300 return nil, fmt.Errorf("BsnSwitchPipelineStatsEntry packet too short: %d < 256", decoder.Length())
2301 }
2302 _bsnswitchpipelinestatsentry.Pipeline = string(bytes.Trim(decoder.Read(256), "\x00"))
2303 return _bsnswitchpipelinestatsentry, nil
2304}
2305
2306func NewBsnSwitchPipelineStatsEntry() *BsnSwitchPipelineStatsEntry {
2307 obj := &BsnSwitchPipelineStatsEntry{}
2308 return obj
2309}
2310
2311type BsnTableChecksumStatsEntry struct {
2312 TableId uint8
2313 Checksum uint64
2314}
2315
2316type IBsnTableChecksumStatsEntry interface {
2317 goloxi.Serializable
2318 GetTableId() uint8
2319 GetChecksum() uint64
2320}
2321
2322func (self *BsnTableChecksumStatsEntry) GetTableId() uint8 {
2323 return self.TableId
2324}
2325
2326func (self *BsnTableChecksumStatsEntry) SetTableId(v uint8) {
2327 self.TableId = v
2328}
2329
2330func (self *BsnTableChecksumStatsEntry) GetChecksum() uint64 {
2331 return self.Checksum
2332}
2333
2334func (self *BsnTableChecksumStatsEntry) SetChecksum(v uint64) {
2335 self.Checksum = v
2336}
2337
2338func (self *BsnTableChecksumStatsEntry) Serialize(encoder *goloxi.Encoder) error {
2339
2340 encoder.PutUint8(uint8(self.TableId))
2341 encoder.PutUint64(uint64(self.Checksum))
2342
2343 return nil
2344}
2345
2346func DecodeBsnTableChecksumStatsEntry(decoder *goloxi.Decoder) (*BsnTableChecksumStatsEntry, error) {
2347 _bsntablechecksumstatsentry := &BsnTableChecksumStatsEntry{}
2348 if decoder.Length() < 9 {
2349 return nil, fmt.Errorf("BsnTableChecksumStatsEntry packet too short: %d < 9", decoder.Length())
2350 }
2351 _bsntablechecksumstatsentry.TableId = uint8(decoder.ReadByte())
2352 _bsntablechecksumstatsentry.Checksum = uint64(decoder.ReadUint64())
2353 return _bsntablechecksumstatsentry, nil
2354}
2355
2356func NewBsnTableChecksumStatsEntry() *BsnTableChecksumStatsEntry {
2357 obj := &BsnTableChecksumStatsEntry{}
2358 return obj
2359}
2360
2361type BsnTlv struct {
2362 Type uint16
2363 Length uint16
2364}
2365
2366type IBsnTlv interface {
2367 goloxi.Serializable
2368 GetType() uint16
2369 GetLength() uint16
2370}
2371
2372func (self *BsnTlv) GetType() uint16 {
2373 return self.Type
2374}
2375
2376func (self *BsnTlv) SetType(v uint16) {
2377 self.Type = v
2378}
2379
2380func (self *BsnTlv) GetLength() uint16 {
2381 return self.Length
2382}
2383
2384func (self *BsnTlv) SetLength(v uint16) {
2385 self.Length = v
2386}
2387
2388func (self *BsnTlv) Serialize(encoder *goloxi.Encoder) error {
2389
2390 encoder.PutUint16(uint16(self.Type))
2391 encoder.PutUint16(uint16(self.Length))
2392
2393 return nil
2394}
2395
2396func DecodeBsnTlv(decoder *goloxi.Decoder) (IBsnTlv, error) {
2397 _bsntlv := &BsnTlv{}
2398 if decoder.Length() < 4 {
2399 return nil, fmt.Errorf("BsnTlv packet too short: %d < 4", decoder.Length())
2400 }
2401 _bsntlv.Type = uint16(decoder.ReadUint16())
2402 _bsntlv.Length = uint16(decoder.ReadUint16())
2403 oldDecoder := decoder
2404 defer func() { decoder = oldDecoder }()
2405 decoder = decoder.SliceDecoder(int(_bsntlv.Length), 2+2)
2406
2407 switch _bsntlv.Type {
2408 case 0:
2409 return DecodeBsnTlvPort(_bsntlv, decoder)
2410 case 1:
2411 return DecodeBsnTlvMac(_bsntlv, decoder)
2412 case 2:
2413 return DecodeBsnTlvRxPackets(_bsntlv, decoder)
2414 case 3:
2415 return DecodeBsnTlvTxPackets(_bsntlv, decoder)
2416 case 4:
2417 return DecodeBsnTlvIpv4(_bsntlv, decoder)
2418 case 5:
2419 return DecodeBsnTlvIdleTime(_bsntlv, decoder)
2420 case 6:
2421 return DecodeBsnTlvVlanVid(_bsntlv, decoder)
2422 case 7:
2423 return DecodeBsnTlvIdleNotification(_bsntlv, decoder)
2424 case 8:
2425 return DecodeBsnTlvIdleTimeout(_bsntlv, decoder)
2426 case 9:
2427 return DecodeBsnTlvUnicastQueryTimeout(_bsntlv, decoder)
2428 case 10:
2429 return DecodeBsnTlvBroadcastQueryTimeout(_bsntlv, decoder)
2430 case 11:
2431 return DecodeBsnTlvRequestPackets(_bsntlv, decoder)
2432 case 12:
2433 return DecodeBsnTlvReplyPackets(_bsntlv, decoder)
2434 case 13:
2435 return DecodeBsnTlvMissPackets(_bsntlv, decoder)
2436 case 14:
2437 return DecodeBsnTlvCircuitId(_bsntlv, decoder)
2438 case 15:
2439 return DecodeBsnTlvUdfId(_bsntlv, decoder)
2440 case 16:
2441 return DecodeBsnTlvUdfAnchor(_bsntlv, decoder)
2442 case 17:
2443 return DecodeBsnTlvUdfOffset(_bsntlv, decoder)
2444 case 18:
2445 return DecodeBsnTlvUdfLength(_bsntlv, decoder)
2446 case 19:
2447 return DecodeBsnTlvVrf(_bsntlv, decoder)
2448 case 20:
2449 return DecodeBsnTlvQueueId(_bsntlv, decoder)
2450 case 21:
2451 return DecodeBsnTlvQueueWeight(_bsntlv, decoder)
2452 case 22:
2453 return DecodeBsnTlvCrcEnabled(_bsntlv, decoder)
2454 case 23:
2455 return DecodeBsnTlvExternalIp(_bsntlv, decoder)
2456 case 24:
2457 return DecodeBsnTlvExternalMac(_bsntlv, decoder)
2458 case 25:
2459 return DecodeBsnTlvExternalNetmask(_bsntlv, decoder)
2460 case 26:
2461 return DecodeBsnTlvExternalGatewayIp(_bsntlv, decoder)
2462 case 27:
2463 return DecodeBsnTlvInternalMac(_bsntlv, decoder)
2464 case 28:
2465 return DecodeBsnTlvInternalGatewayMac(_bsntlv, decoder)
2466 case 29:
2467 return DecodeBsnTlvExternalGatewayMac(_bsntlv, decoder)
2468 case 30:
2469 return DecodeBsnTlvSamplingRate(_bsntlv, decoder)
2470 case 31:
2471 return DecodeBsnTlvHeaderSize(_bsntlv, decoder)
2472 case 32:
2473 return DecodeBsnTlvEthSrc(_bsntlv, decoder)
2474 case 33:
2475 return DecodeBsnTlvEthDst(_bsntlv, decoder)
2476 case 34:
2477 return DecodeBsnTlvIpv4Src(_bsntlv, decoder)
2478 case 35:
2479 return DecodeBsnTlvIpv4Dst(_bsntlv, decoder)
2480 case 36:
2481 return DecodeBsnTlvUdpSrc(_bsntlv, decoder)
2482 case 37:
2483 return DecodeBsnTlvUdpDst(_bsntlv, decoder)
2484 case 38:
2485 return DecodeBsnTlvSubAgentId(_bsntlv, decoder)
2486 case 39:
2487 return DecodeBsnTlvTxBytes(_bsntlv, decoder)
2488 case 40:
2489 return DecodeBsnTlvActorSystemPriority(_bsntlv, decoder)
2490 case 41:
2491 return DecodeBsnTlvActorSystemMac(_bsntlv, decoder)
2492 case 42:
2493 return DecodeBsnTlvActorPortPriority(_bsntlv, decoder)
2494 case 43:
2495 return DecodeBsnTlvActorPortNum(_bsntlv, decoder)
2496 case 44:
2497 return DecodeBsnTlvActorKey(_bsntlv, decoder)
2498 case 45:
2499 return DecodeBsnTlvConvergenceStatus(_bsntlv, decoder)
2500 case 47:
2501 return DecodeBsnTlvPartnerSystemPriority(_bsntlv, decoder)
2502 case 48:
2503 return DecodeBsnTlvPartnerSystemMac(_bsntlv, decoder)
2504 case 49:
2505 return DecodeBsnTlvPartnerPortPriority(_bsntlv, decoder)
2506 case 50:
2507 return DecodeBsnTlvPartnerPortNum(_bsntlv, decoder)
2508 case 51:
2509 return DecodeBsnTlvPartnerKey(_bsntlv, decoder)
2510 case 52:
2511 return DecodeBsnTlvName(_bsntlv, decoder)
2512 case 53:
2513 return DecodeBsnTlvActorState(_bsntlv, decoder)
2514 case 54:
2515 return DecodeBsnTlvPartnerState(_bsntlv, decoder)
2516 case 55:
2517 return DecodeBsnTlvData(_bsntlv, decoder)
2518 case 56:
2519 return DecodeBsnTlvMacMask(_bsntlv, decoder)
2520 case 57:
2521 return DecodeBsnTlvPriority(_bsntlv, decoder)
2522 case 58:
2523 return DecodeBsnTlvInterval(_bsntlv, decoder)
2524 case 59:
2525 return DecodeBsnTlvReference(_bsntlv, decoder)
2526 case 60:
2527 return DecodeBsnTlvIpv4Netmask(_bsntlv, decoder)
2528 case 61:
2529 return DecodeBsnTlvMplsLabel(_bsntlv, decoder)
2530 case 62:
2531 return DecodeBsnTlvMplsControlWord(_bsntlv, decoder)
2532 case 63:
2533 return DecodeBsnTlvMplsSequenced(_bsntlv, decoder)
2534 case 64:
2535 return DecodeBsnTlvBucket(_bsntlv, decoder)
2536 case 65:
2537 return DecodeBsnTlvTcpSrc(_bsntlv, decoder)
2538 case 66:
2539 return DecodeBsnTlvTcpDst(_bsntlv, decoder)
2540 case 67:
2541 return DecodeBsnTlvIpProto(_bsntlv, decoder)
2542 case 68:
2543 return DecodeBsnTlvIcmpType(_bsntlv, decoder)
2544 case 69:
2545 return DecodeBsnTlvIcmpCode(_bsntlv, decoder)
2546 case 70:
2547 return DecodeBsnTlvIcmpId(_bsntlv, decoder)
2548 case 71:
2549 return DecodeBsnTlvRxBytes(_bsntlv, decoder)
2550 case 72:
2551 return DecodeBsnTlvVlanPcp(_bsntlv, decoder)
2552 case 73:
2553 return DecodeBsnTlvStripVlanOnEgress(_bsntlv, decoder)
2554 case 74:
2555 return DecodeBsnTlvSetLoopbackMode(_bsntlv, decoder)
2556 case 75:
2557 return DecodeBsnTlvStripMplsL2OnIngress(_bsntlv, decoder)
2558 case 76:
2559 return DecodeBsnTlvStripMplsL3OnIngress(_bsntlv, decoder)
2560 case 77:
2561 return DecodeBsnTlvVlanVidMask(_bsntlv, decoder)
2562 case 78:
2563 return DecodeBsnTlvIgmpSnooping(_bsntlv, decoder)
2564 case 79:
2565 return DecodeBsnTlvL2MulticastLookup(_bsntlv, decoder)
2566 case 80:
2567 return DecodeBsnTlvGenerationId(_bsntlv, decoder)
2568 case 81:
2569 return DecodeBsnTlvAnchor(_bsntlv, decoder)
2570 case 82:
2571 return DecodeBsnTlvOffset(_bsntlv, decoder)
2572 case 83:
2573 return DecodeBsnTlvNegate(_bsntlv, decoder)
2574 case 84:
2575 return DecodeBsnTlvIpv6(_bsntlv, decoder)
2576 case 85:
2577 return DecodeBsnTlvDecap(_bsntlv, decoder)
2578 case 86:
2579 return DecodeBsnTlvVni(_bsntlv, decoder)
2580 case 87:
2581 return DecodeBsnTlvMcgTypeVxlan(_bsntlv, decoder)
2582 case 88:
2583 return DecodeBsnTlvPortVxlanMode(_bsntlv, decoder)
2584 case 89:
2585 return DecodeBsnTlvRateUnit(_bsntlv, decoder)
2586 case 90:
2587 return DecodeBsnTlvBroadcastRate(_bsntlv, decoder)
2588 case 91:
2589 return DecodeBsnTlvKnownMulticastRate(_bsntlv, decoder)
2590 case 92:
2591 return DecodeBsnTlvUnknownMulticastRate(_bsntlv, decoder)
2592 case 93:
2593 return DecodeBsnTlvUnicastRate(_bsntlv, decoder)
2594 case 94:
2595 return DecodeBsnTlvNexthopTypeVxlan(_bsntlv, decoder)
2596 case 95:
2597 return DecodeBsnTlvMulticastInterfaceId(_bsntlv, decoder)
2598 case 96:
2599 return DecodeBsnTlvUsePacketState(_bsntlv, decoder)
2600 case 97:
2601 return DecodeBsnTlvStatus(_bsntlv, decoder)
2602 case 98:
2603 return DecodeBsnTlvVlanMacList(_bsntlv, decoder)
2604 case 99:
2605 return DecodeBsnTlvVfi(_bsntlv, decoder)
2606 case 100:
2607 return DecodeBsnTlvHashSeed(_bsntlv, decoder)
2608 case 101:
2609 return DecodeBsnTlvHashType(_bsntlv, decoder)
2610 case 102:
2611 return DecodeBsnTlvHashPacketType(_bsntlv, decoder)
2612 case 103:
2613 return DecodeBsnTlvHashPacketField(_bsntlv, decoder)
2614 case 104:
2615 return DecodeBsnTlvHashGtpHeaderMatch(_bsntlv, decoder)
2616 case 105:
2617 return DecodeBsnTlvHashGtpPortMatch(_bsntlv, decoder)
2618 case 106:
2619 return DecodeBsnTlvUntagged(_bsntlv, decoder)
2620 case 107:
2621 return DecodeBsnTlvVfpClassId(_bsntlv, decoder)
2622 case 108:
2623 return DecodeBsnTlvQosPriority(_bsntlv, decoder)
2624 case 109:
2625 return DecodeBsnTlvParentPort(_bsntlv, decoder)
2626 case 110:
2627 return DecodeBsnTlvLoopbackPort(_bsntlv, decoder)
2628 case 111:
2629 return DecodeBsnTlvVpnKey(_bsntlv, decoder)
2630 case 112:
2631 return DecodeBsnTlvDscp(_bsntlv, decoder)
2632 case 113:
2633 return DecodeBsnTlvTtl(_bsntlv, decoder)
2634 case 114:
2635 return DecodeBsnTlvNextHopMac(_bsntlv, decoder)
2636 case 115:
2637 return DecodeBsnTlvNextHopIpv4(_bsntlv, decoder)
2638 case 116:
2639 return DecodeBsnTlvRateLimit(_bsntlv, decoder)
2640 case 117:
2641 return DecodeBsnTlvVxlanEgressLag(_bsntlv, decoder)
2642 case 118:
2643 return DecodeBsnTlvCpuLag(_bsntlv, decoder)
2644 case 119:
2645 return DecodeBsnTlvUint64List(_bsntlv, decoder)
2646 case 120:
2647 return DecodeBsnTlvDisableSrcMacCheck(_bsntlv, decoder)
2648 case 121:
2649 return DecodeBsnTlvDrop(_bsntlv, decoder)
2650 case 122:
2651 return DecodeBsnTlvIpv6Prefix(_bsntlv, decoder)
2652 case 123:
2653 return DecodeBsnTlvNdpOffload(_bsntlv, decoder)
2654 case 124:
2655 return DecodeBsnTlvNdpStatic(_bsntlv, decoder)
2656 case 125:
2657 return DecodeBsnTlvIcmpv6Chksum(_bsntlv, decoder)
2658 case 126:
2659 return DecodeBsnTlvIpv6Src(_bsntlv, decoder)
2660 case 127:
2661 return DecodeBsnTlvIpv6Dst(_bsntlv, decoder)
2662 case 128:
2663 return DecodeBsnTlvPushVlanOnIngress(_bsntlv, decoder)
2664 case 129:
2665 return DecodeBsnTlvApplyPackets(_bsntlv, decoder)
2666 case 130:
2667 return DecodeBsnTlvApplyBytes(_bsntlv, decoder)
2668 case 131:
2669 return DecodeBsnTlvEthType(_bsntlv, decoder)
2670 case 132:
2671 return DecodeBsnTlvEcn(_bsntlv, decoder)
2672 case 133:
2673 return DecodeBsnTlvTcpFlags(_bsntlv, decoder)
2674 case 134:
2675 return DecodeBsnTlvL3InterfaceClassId(_bsntlv, decoder)
2676 case 135:
2677 return DecodeBsnTlvL3SrcClassId(_bsntlv, decoder)
2678 case 136:
2679 return DecodeBsnTlvL3DstClassId(_bsntlv, decoder)
2680 case 137:
2681 return DecodeBsnTlvEgressOnly(_bsntlv, decoder)
2682 case 138:
2683 return DecodeBsnTlvIngressPortGroupId(_bsntlv, decoder)
2684 case 139:
2685 return DecodeBsnTlvEgressPortGroupId(_bsntlv, decoder)
2686 case 140:
2687 return DecodeBsnTlvDataMask(_bsntlv, decoder)
2688 case 141:
2689 return DecodeBsnTlvPortUsage(_bsntlv, decoder)
2690 case 142:
2691 return DecodeBsnTlvTunnelCapability(_bsntlv, decoder)
2692 case 143:
2693 return DecodeBsnTlvEnhancedHashCapability(_bsntlv, decoder)
2694 case 144:
2695 return DecodeBsnTlvAutoNegotiation(_bsntlv, decoder)
2696 case 145:
2697 return DecodeBsnTlvHashAlgorithm(_bsntlv, decoder)
2698 case 146:
2699 return DecodeBsnTlvLoopbackMode(_bsntlv, decoder)
2700 case 147:
2701 return DecodeBsnTlvNoArpResponse(_bsntlv, decoder)
2702 case 148:
2703 return DecodeBsnTlvNoNsResponse(_bsntlv, decoder)
2704 case 149:
2705 return DecodeBsnTlvForwardErrorCorrection(_bsntlv, decoder)
2706 case 150:
2707 return DecodeBsnTlvOpticsAlwaysEnabled(_bsntlv, decoder)
2708 case 151:
2709 return DecodeBsnTlvForceLinkUp(_bsntlv, decoder)
2710 case 152:
2711 return DecodeBsnTlvRestServer(_bsntlv, decoder)
2712 case 153:
2713 return DecodeBsnTlvUriScheme(_bsntlv, decoder)
2714 case 154:
2715 return DecodeBsnTlvTimestamp(_bsntlv, decoder)
2716 case 155:
2717 return DecodeBsnTlvRecordPackets(_bsntlv, decoder)
2718 case 156:
2719 return DecodeBsnTlvPortSpeedGbps(_bsntlv, decoder)
2720 case 157:
2721 return DecodeBsnTlvOuterSrcMac(_bsntlv, decoder)
2722 case 158:
2723 return DecodeBsnTlvVirtual(_bsntlv, decoder)
2724 case 159:
2725 return DecodeBsnTlvPduaRxInstance(_bsntlv, decoder)
2726 case 160:
2727 return DecodeBsnTlvLagOptions(_bsntlv, decoder)
2728 case 161:
2729 return DecodeBsnTlvRoutingParam(_bsntlv, decoder)
2730 case 162:
2731 return DecodeBsnTlvPushVlanOnEgress(_bsntlv, decoder)
2732 case 163:
2733 return DecodeBsnTlvFlood(_bsntlv, decoder)
2734 case 164:
2735 return DecodeBsnTlvUpgrade(_bsntlv, decoder)
2736 case 165:
2737 return DecodeBsnTlvFabricPortRole(_bsntlv, decoder)
2738 case 166:
2739 return DecodeBsnTlvUserConfigured(_bsntlv, decoder)
2740 case 167:
2741 return DecodeBsnTlvUint32(_bsntlv, decoder)
2742 case 168:
2743 return DecodeBsnTlvL3(_bsntlv, decoder)
2744 case 169:
2745 return DecodeBsnTlvIpTunnelType(_bsntlv, decoder)
2746 case 170:
2747 return DecodeBsnTlvMulticastPacket(_bsntlv, decoder)
2748 case 171:
2749 return DecodeBsnTlvPimDr(_bsntlv, decoder)
2750 case 172:
2751 return DecodeBsnTlvPassive(_bsntlv, decoder)
2752 case 173:
2753 return DecodeBsnTlvIdentifier(_bsntlv, decoder)
2754 case 174:
2755 return DecodeBsnTlvMultiplier(_bsntlv, decoder)
2756 case 175:
2757 return DecodeBsnTlvEncap(_bsntlv, decoder)
2758 case 176:
2759 return DecodeBsnTlvBfdEndpoint(_bsntlv, decoder)
2760 case 177:
2761 return DecodeBsnTlvBfdState(_bsntlv, decoder)
2762 case 178:
2763 return DecodeBsnTlvLrAllEnabled(_bsntlv, decoder)
2764 case 179:
2765 return DecodeBsnTlvPortMode(_bsntlv, decoder)
2766 case 180:
2767 return DecodeBsnTlvUdfCapability(_bsntlv, decoder)
2768 case 181:
2769 return DecodeBsnTlvPimHelloFlood(_bsntlv, decoder)
2770 case 182:
2771 return DecodeBsnTlvFlowClassify(_bsntlv, decoder)
2772 case 183:
2773 return DecodeBsnTlvFlowIdentifier(_bsntlv, decoder)
2774 case 184:
2775 return DecodeBsnTlvFlowClassifier(_bsntlv, decoder)
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]2776 case 185:
2777 return DecodeBsnTlvDisableXmit(_bsntlv, decoder)
2778 case 186:
2779 return DecodeBsnTlvPreserveVlan(_bsntlv, decoder)
2780 case 187:
2781 return DecodeBsnTlvDropControl(_bsntlv, decoder)
2782 case 188:
2783 return DecodeBsnTlvLossless(_bsntlv, decoder)
2784 case 189:
2785 return DecodeBsnTlvRedundantMgmt(_bsntlv, decoder)
2786 case 190:
2787 return DecodeBsnTlvDnsAnalytics(_bsntlv, decoder)
2788 case 191:
2789 return DecodeBsnTlvSrcMacCml(_bsntlv, decoder)
2790 case 192:
2791 return DecodeBsnTlvActive(_bsntlv, decoder)
2792 case 193:
2793 return DecodeBsnTlvLinkUp(_bsntlv, decoder)
2794 case 194:
2795 return DecodeBsnTlvFailCount(_bsntlv, decoder)
2796 case 195:
2797 return DecodeBsnTlvEgressSamplingRate(_bsntlv, decoder)
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]2798 default:
2799 return nil, fmt.Errorf("Invalid type '%d' for 'BsnTlv'", _bsntlv.Type)
2800 }
2801}
2802
2803func NewBsnTlv(_type uint16) *BsnTlv {
2804 obj := &BsnTlv{}
2805 obj.Type = _type
2806 return obj
2807}
2808
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]2809type BsnTlvActive struct {
2810 *BsnTlv
2811}
2812
2813type IBsnTlvActive interface {
2814 IBsnTlv
2815}
2816
2817func (self *BsnTlvActive) Serialize(encoder *goloxi.Encoder) error {
2818 startIndex := len(encoder.Bytes())
2819 if err := self.BsnTlv.Serialize(encoder); err != nil {
2820 return err
2821 }
2822 length := len(encoder.Bytes()) - startIndex
2823
2824 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
2825
2826 return nil
2827}
2828
2829func DecodeBsnTlvActive(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvActive, error) {
2830 _bsntlvactive := &BsnTlvActive{BsnTlv: parent}
2831 return _bsntlvactive, nil
2832}
2833
2834func NewBsnTlvActive() *BsnTlvActive {
2835 obj := &BsnTlvActive{
2836 BsnTlv: NewBsnTlv(192),
2837 }
2838 return obj
2839}
2840
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]2841type BsnTlvActorKey struct {
2842 *BsnTlv
2843 Value uint16
2844}
2845
2846type IBsnTlvActorKey interface {
2847 IBsnTlv
2848 GetValue() uint16
2849}
2850
2851func (self *BsnTlvActorKey) GetValue() uint16 {
2852 return self.Value
2853}
2854
2855func (self *BsnTlvActorKey) SetValue(v uint16) {
2856 self.Value = v
2857}
2858
2859func (self *BsnTlvActorKey) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]2860 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]2861 if err := self.BsnTlv.Serialize(encoder); err != nil {
2862 return err
2863 }
2864
2865 encoder.PutUint16(uint16(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]2866 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]2867
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]2868 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]2869
2870 return nil
2871}
2872
2873func DecodeBsnTlvActorKey(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvActorKey, error) {
2874 _bsntlvactorkey := &BsnTlvActorKey{BsnTlv: parent}
2875 if decoder.Length() < 2 {
2876 return nil, fmt.Errorf("BsnTlvActorKey packet too short: %d < 2", decoder.Length())
2877 }
2878 _bsntlvactorkey.Value = uint16(decoder.ReadUint16())
2879 return _bsntlvactorkey, nil
2880}
2881
2882func NewBsnTlvActorKey() *BsnTlvActorKey {
2883 obj := &BsnTlvActorKey{
2884 BsnTlv: NewBsnTlv(44),
2885 }
2886 return obj
2887}
2888
2889type BsnTlvActorPortNum struct {
2890 *BsnTlv
2891 Value uint16
2892}
2893
2894type IBsnTlvActorPortNum interface {
2895 IBsnTlv
2896 GetValue() uint16
2897}
2898
2899func (self *BsnTlvActorPortNum) GetValue() uint16 {
2900 return self.Value
2901}
2902
2903func (self *BsnTlvActorPortNum) SetValue(v uint16) {
2904 self.Value = v
2905}
2906
2907func (self *BsnTlvActorPortNum) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]2908 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]2909 if err := self.BsnTlv.Serialize(encoder); err != nil {
2910 return err
2911 }
2912
2913 encoder.PutUint16(uint16(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]2914 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]2915
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]2916 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]2917
2918 return nil
2919}
2920
2921func DecodeBsnTlvActorPortNum(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvActorPortNum, error) {
2922 _bsntlvactorportnum := &BsnTlvActorPortNum{BsnTlv: parent}
2923 if decoder.Length() < 2 {
2924 return nil, fmt.Errorf("BsnTlvActorPortNum packet too short: %d < 2", decoder.Length())
2925 }
2926 _bsntlvactorportnum.Value = uint16(decoder.ReadUint16())
2927 return _bsntlvactorportnum, nil
2928}
2929
2930func NewBsnTlvActorPortNum() *BsnTlvActorPortNum {
2931 obj := &BsnTlvActorPortNum{
2932 BsnTlv: NewBsnTlv(43),
2933 }
2934 return obj
2935}
2936
2937type BsnTlvActorPortPriority struct {
2938 *BsnTlv
2939 Value uint16
2940}
2941
2942type IBsnTlvActorPortPriority interface {
2943 IBsnTlv
2944 GetValue() uint16
2945}
2946
2947func (self *BsnTlvActorPortPriority) GetValue() uint16 {
2948 return self.Value
2949}
2950
2951func (self *BsnTlvActorPortPriority) SetValue(v uint16) {
2952 self.Value = v
2953}
2954
2955func (self *BsnTlvActorPortPriority) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]2956 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]2957 if err := self.BsnTlv.Serialize(encoder); err != nil {
2958 return err
2959 }
2960
2961 encoder.PutUint16(uint16(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]2962 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]2963
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]2964 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]2965
2966 return nil
2967}
2968
2969func DecodeBsnTlvActorPortPriority(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvActorPortPriority, error) {
2970 _bsntlvactorportpriority := &BsnTlvActorPortPriority{BsnTlv: parent}
2971 if decoder.Length() < 2 {
2972 return nil, fmt.Errorf("BsnTlvActorPortPriority packet too short: %d < 2", decoder.Length())
2973 }
2974 _bsntlvactorportpriority.Value = uint16(decoder.ReadUint16())
2975 return _bsntlvactorportpriority, nil
2976}
2977
2978func NewBsnTlvActorPortPriority() *BsnTlvActorPortPriority {
2979 obj := &BsnTlvActorPortPriority{
2980 BsnTlv: NewBsnTlv(42),
2981 }
2982 return obj
2983}
2984
2985type BsnTlvActorState struct {
2986 *BsnTlv
2987 Value BsnLacpState
2988}
2989
2990type IBsnTlvActorState interface {
2991 IBsnTlv
2992 GetValue() BsnLacpState
2993}
2994
2995func (self *BsnTlvActorState) GetValue() BsnLacpState {
2996 return self.Value
2997}
2998
2999func (self *BsnTlvActorState) SetValue(v BsnLacpState) {
3000 self.Value = v
3001}
3002
3003func (self *BsnTlvActorState) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3004 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3005 if err := self.BsnTlv.Serialize(encoder); err != nil {
3006 return err
3007 }
3008
3009 encoder.PutUint8(uint8(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3010 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3011
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3012 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3013
3014 return nil
3015}
3016
3017func DecodeBsnTlvActorState(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvActorState, error) {
3018 _bsntlvactorstate := &BsnTlvActorState{BsnTlv: parent}
3019 if decoder.Length() < 1 {
3020 return nil, fmt.Errorf("BsnTlvActorState packet too short: %d < 1", decoder.Length())
3021 }
3022 _bsntlvactorstate.Value = BsnLacpState(decoder.ReadByte())
3023 return _bsntlvactorstate, nil
3024}
3025
3026func NewBsnTlvActorState() *BsnTlvActorState {
3027 obj := &BsnTlvActorState{
3028 BsnTlv: NewBsnTlv(53),
3029 }
3030 return obj
3031}
3032
3033type BsnTlvActorSystemMac struct {
3034 *BsnTlv
3035 Value net.HardwareAddr
3036}
3037
3038type IBsnTlvActorSystemMac interface {
3039 IBsnTlv
3040 GetValue() net.HardwareAddr
3041}
3042
3043func (self *BsnTlvActorSystemMac) GetValue() net.HardwareAddr {
3044 return self.Value
3045}
3046
3047func (self *BsnTlvActorSystemMac) SetValue(v net.HardwareAddr) {
3048 self.Value = v
3049}
3050
3051func (self *BsnTlvActorSystemMac) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3052 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3053 if err := self.BsnTlv.Serialize(encoder); err != nil {
3054 return err
3055 }
3056
3057 encoder.Write(self.Value)
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3058 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3059
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3060 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3061
3062 return nil
3063}
3064
3065func DecodeBsnTlvActorSystemMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvActorSystemMac, error) {
3066 _bsntlvactorsystemmac := &BsnTlvActorSystemMac{BsnTlv: parent}
3067 if decoder.Length() < 6 {
3068 return nil, fmt.Errorf("BsnTlvActorSystemMac packet too short: %d < 6", decoder.Length())
3069 }
3070 _bsntlvactorsystemmac.Value = net.HardwareAddr(decoder.Read(6))
3071 return _bsntlvactorsystemmac, nil
3072}
3073
3074func NewBsnTlvActorSystemMac() *BsnTlvActorSystemMac {
3075 obj := &BsnTlvActorSystemMac{
3076 BsnTlv: NewBsnTlv(41),
3077 }
3078 return obj
3079}
3080
3081type BsnTlvActorSystemPriority struct {
3082 *BsnTlv
3083 Value uint16
3084}
3085
3086type IBsnTlvActorSystemPriority interface {
3087 IBsnTlv
3088 GetValue() uint16
3089}
3090
3091func (self *BsnTlvActorSystemPriority) GetValue() uint16 {
3092 return self.Value
3093}
3094
3095func (self *BsnTlvActorSystemPriority) SetValue(v uint16) {
3096 self.Value = v
3097}
3098
3099func (self *BsnTlvActorSystemPriority) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3100 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3101 if err := self.BsnTlv.Serialize(encoder); err != nil {
3102 return err
3103 }
3104
3105 encoder.PutUint16(uint16(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3106 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3107
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3108 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3109
3110 return nil
3111}
3112
3113func DecodeBsnTlvActorSystemPriority(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvActorSystemPriority, error) {
3114 _bsntlvactorsystempriority := &BsnTlvActorSystemPriority{BsnTlv: parent}
3115 if decoder.Length() < 2 {
3116 return nil, fmt.Errorf("BsnTlvActorSystemPriority packet too short: %d < 2", decoder.Length())
3117 }
3118 _bsntlvactorsystempriority.Value = uint16(decoder.ReadUint16())
3119 return _bsntlvactorsystempriority, nil
3120}
3121
3122func NewBsnTlvActorSystemPriority() *BsnTlvActorSystemPriority {
3123 obj := &BsnTlvActorSystemPriority{
3124 BsnTlv: NewBsnTlv(40),
3125 }
3126 return obj
3127}
3128
3129type BsnTlvAnchor struct {
3130 *BsnTlv
3131 Value BsnAnchor
3132}
3133
3134type IBsnTlvAnchor interface {
3135 IBsnTlv
3136 GetValue() BsnAnchor
3137}
3138
3139func (self *BsnTlvAnchor) GetValue() BsnAnchor {
3140 return self.Value
3141}
3142
3143func (self *BsnTlvAnchor) SetValue(v BsnAnchor) {
3144 self.Value = v
3145}
3146
3147func (self *BsnTlvAnchor) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3148 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3149 if err := self.BsnTlv.Serialize(encoder); err != nil {
3150 return err
3151 }
3152
3153 encoder.PutUint16(uint16(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3154 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3155
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3156 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3157
3158 return nil
3159}
3160
3161func DecodeBsnTlvAnchor(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvAnchor, error) {
3162 _bsntlvanchor := &BsnTlvAnchor{BsnTlv: parent}
3163 if decoder.Length() < 2 {
3164 return nil, fmt.Errorf("BsnTlvAnchor packet too short: %d < 2", decoder.Length())
3165 }
3166 _bsntlvanchor.Value = BsnAnchor(decoder.ReadUint16())
3167 return _bsntlvanchor, nil
3168}
3169
3170func NewBsnTlvAnchor() *BsnTlvAnchor {
3171 obj := &BsnTlvAnchor{
3172 BsnTlv: NewBsnTlv(81),
3173 }
3174 return obj
3175}
3176
3177type BsnTlvApplyBytes struct {
3178 *BsnTlv
3179 Value uint64
3180}
3181
3182type IBsnTlvApplyBytes interface {
3183 IBsnTlv
3184 GetValue() uint64
3185}
3186
3187func (self *BsnTlvApplyBytes) GetValue() uint64 {
3188 return self.Value
3189}
3190
3191func (self *BsnTlvApplyBytes) SetValue(v uint64) {
3192 self.Value = v
3193}
3194
3195func (self *BsnTlvApplyBytes) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3196 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3197 if err := self.BsnTlv.Serialize(encoder); err != nil {
3198 return err
3199 }
3200
3201 encoder.PutUint64(uint64(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3202 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3203
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3204 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3205
3206 return nil
3207}
3208
3209func DecodeBsnTlvApplyBytes(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvApplyBytes, error) {
3210 _bsntlvapplybytes := &BsnTlvApplyBytes{BsnTlv: parent}
3211 if decoder.Length() < 8 {
3212 return nil, fmt.Errorf("BsnTlvApplyBytes packet too short: %d < 8", decoder.Length())
3213 }
3214 _bsntlvapplybytes.Value = uint64(decoder.ReadUint64())
3215 return _bsntlvapplybytes, nil
3216}
3217
3218func NewBsnTlvApplyBytes() *BsnTlvApplyBytes {
3219 obj := &BsnTlvApplyBytes{
3220 BsnTlv: NewBsnTlv(130),
3221 }
3222 return obj
3223}
3224
3225type BsnTlvApplyPackets struct {
3226 *BsnTlv
3227 Value uint64
3228}
3229
3230type IBsnTlvApplyPackets interface {
3231 IBsnTlv
3232 GetValue() uint64
3233}
3234
3235func (self *BsnTlvApplyPackets) GetValue() uint64 {
3236 return self.Value
3237}
3238
3239func (self *BsnTlvApplyPackets) SetValue(v uint64) {
3240 self.Value = v
3241}
3242
3243func (self *BsnTlvApplyPackets) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3244 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3245 if err := self.BsnTlv.Serialize(encoder); err != nil {
3246 return err
3247 }
3248
3249 encoder.PutUint64(uint64(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3250 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3251
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3252 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3253
3254 return nil
3255}
3256
3257func DecodeBsnTlvApplyPackets(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvApplyPackets, error) {
3258 _bsntlvapplypackets := &BsnTlvApplyPackets{BsnTlv: parent}
3259 if decoder.Length() < 8 {
3260 return nil, fmt.Errorf("BsnTlvApplyPackets packet too short: %d < 8", decoder.Length())
3261 }
3262 _bsntlvapplypackets.Value = uint64(decoder.ReadUint64())
3263 return _bsntlvapplypackets, nil
3264}
3265
3266func NewBsnTlvApplyPackets() *BsnTlvApplyPackets {
3267 obj := &BsnTlvApplyPackets{
3268 BsnTlv: NewBsnTlv(129),
3269 }
3270 return obj
3271}
3272
3273type BsnTlvAutoNegotiation struct {
3274 *BsnTlv
3275 Value BsnAutoNegotiationType
3276}
3277
3278type IBsnTlvAutoNegotiation interface {
3279 IBsnTlv
3280 GetValue() BsnAutoNegotiationType
3281}
3282
3283func (self *BsnTlvAutoNegotiation) GetValue() BsnAutoNegotiationType {
3284 return self.Value
3285}
3286
3287func (self *BsnTlvAutoNegotiation) SetValue(v BsnAutoNegotiationType) {
3288 self.Value = v
3289}
3290
3291func (self *BsnTlvAutoNegotiation) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3292 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3293 if err := self.BsnTlv.Serialize(encoder); err != nil {
3294 return err
3295 }
3296
3297 encoder.PutUint8(uint8(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3298 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3299
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3300 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3301
3302 return nil
3303}
3304
3305func DecodeBsnTlvAutoNegotiation(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvAutoNegotiation, error) {
3306 _bsntlvautonegotiation := &BsnTlvAutoNegotiation{BsnTlv: parent}
3307 if decoder.Length() < 1 {
3308 return nil, fmt.Errorf("BsnTlvAutoNegotiation packet too short: %d < 1", decoder.Length())
3309 }
3310 _bsntlvautonegotiation.Value = BsnAutoNegotiationType(decoder.ReadByte())
3311 return _bsntlvautonegotiation, nil
3312}
3313
3314func NewBsnTlvAutoNegotiation() *BsnTlvAutoNegotiation {
3315 obj := &BsnTlvAutoNegotiation{
3316 BsnTlv: NewBsnTlv(144),
3317 }
3318 return obj
3319}
3320
3321type BsnTlvBfdEndpoint struct {
3322 *BsnTlv
3323 Value BsnBfdEndpoint
3324}
3325
3326type IBsnTlvBfdEndpoint interface {
3327 IBsnTlv
3328 GetValue() BsnBfdEndpoint
3329}
3330
3331func (self *BsnTlvBfdEndpoint) GetValue() BsnBfdEndpoint {
3332 return self.Value
3333}
3334
3335func (self *BsnTlvBfdEndpoint) SetValue(v BsnBfdEndpoint) {
3336 self.Value = v
3337}
3338
3339func (self *BsnTlvBfdEndpoint) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3340 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3341 if err := self.BsnTlv.Serialize(encoder); err != nil {
3342 return err
3343 }
3344
3345 encoder.PutUint8(uint8(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3346 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3347
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3348 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3349
3350 return nil
3351}
3352
3353func DecodeBsnTlvBfdEndpoint(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvBfdEndpoint, error) {
3354 _bsntlvbfdendpoint := &BsnTlvBfdEndpoint{BsnTlv: parent}
3355 if decoder.Length() < 1 {
3356 return nil, fmt.Errorf("BsnTlvBfdEndpoint packet too short: %d < 1", decoder.Length())
3357 }
3358 _bsntlvbfdendpoint.Value = BsnBfdEndpoint(decoder.ReadByte())
3359 return _bsntlvbfdendpoint, nil
3360}
3361
3362func NewBsnTlvBfdEndpoint() *BsnTlvBfdEndpoint {
3363 obj := &BsnTlvBfdEndpoint{
3364 BsnTlv: NewBsnTlv(176),
3365 }
3366 return obj
3367}
3368
3369type BsnTlvBfdState struct {
3370 *BsnTlv
3371 Value BsnBfdEndpointState
3372}
3373
3374type IBsnTlvBfdState interface {
3375 IBsnTlv
3376 GetValue() BsnBfdEndpointState
3377}
3378
3379func (self *BsnTlvBfdState) GetValue() BsnBfdEndpointState {
3380 return self.Value
3381}
3382
3383func (self *BsnTlvBfdState) SetValue(v BsnBfdEndpointState) {
3384 self.Value = v
3385}
3386
3387func (self *BsnTlvBfdState) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3388 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3389 if err := self.BsnTlv.Serialize(encoder); err != nil {
3390 return err
3391 }
3392
3393 encoder.PutUint8(uint8(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3394 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3395
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3396 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3397
3398 return nil
3399}
3400
3401func DecodeBsnTlvBfdState(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvBfdState, error) {
3402 _bsntlvbfdstate := &BsnTlvBfdState{BsnTlv: parent}
3403 if decoder.Length() < 1 {
3404 return nil, fmt.Errorf("BsnTlvBfdState packet too short: %d < 1", decoder.Length())
3405 }
3406 _bsntlvbfdstate.Value = BsnBfdEndpointState(decoder.ReadByte())
3407 return _bsntlvbfdstate, nil
3408}
3409
3410func NewBsnTlvBfdState() *BsnTlvBfdState {
3411 obj := &BsnTlvBfdState{
3412 BsnTlv: NewBsnTlv(177),
3413 }
3414 return obj
3415}
3416
3417type BsnTlvBroadcastQueryTimeout struct {
3418 *BsnTlv
3419 Value uint32
3420}
3421
3422type IBsnTlvBroadcastQueryTimeout interface {
3423 IBsnTlv
3424 GetValue() uint32
3425}
3426
3427func (self *BsnTlvBroadcastQueryTimeout) GetValue() uint32 {
3428 return self.Value
3429}
3430
3431func (self *BsnTlvBroadcastQueryTimeout) SetValue(v uint32) {
3432 self.Value = v
3433}
3434
3435func (self *BsnTlvBroadcastQueryTimeout) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3436 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3437 if err := self.BsnTlv.Serialize(encoder); err != nil {
3438 return err
3439 }
3440
3441 encoder.PutUint32(uint32(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3442 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3443
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3444 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3445
3446 return nil
3447}
3448
3449func DecodeBsnTlvBroadcastQueryTimeout(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvBroadcastQueryTimeout, error) {
3450 _bsntlvbroadcastquerytimeout := &BsnTlvBroadcastQueryTimeout{BsnTlv: parent}
3451 if decoder.Length() < 4 {
3452 return nil, fmt.Errorf("BsnTlvBroadcastQueryTimeout packet too short: %d < 4", decoder.Length())
3453 }
3454 _bsntlvbroadcastquerytimeout.Value = uint32(decoder.ReadUint32())
3455 return _bsntlvbroadcastquerytimeout, nil
3456}
3457
3458func NewBsnTlvBroadcastQueryTimeout() *BsnTlvBroadcastQueryTimeout {
3459 obj := &BsnTlvBroadcastQueryTimeout{
3460 BsnTlv: NewBsnTlv(10),
3461 }
3462 return obj
3463}
3464
3465type BsnTlvBroadcastRate struct {
3466 *BsnTlv
3467 Value uint32
3468}
3469
3470type IBsnTlvBroadcastRate interface {
3471 IBsnTlv
3472 GetValue() uint32
3473}
3474
3475func (self *BsnTlvBroadcastRate) GetValue() uint32 {
3476 return self.Value
3477}
3478
3479func (self *BsnTlvBroadcastRate) SetValue(v uint32) {
3480 self.Value = v
3481}
3482
3483func (self *BsnTlvBroadcastRate) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3484 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3485 if err := self.BsnTlv.Serialize(encoder); err != nil {
3486 return err
3487 }
3488
3489 encoder.PutUint32(uint32(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3490 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3491
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3492 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3493
3494 return nil
3495}
3496
3497func DecodeBsnTlvBroadcastRate(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvBroadcastRate, error) {
3498 _bsntlvbroadcastrate := &BsnTlvBroadcastRate{BsnTlv: parent}
3499 if decoder.Length() < 4 {
3500 return nil, fmt.Errorf("BsnTlvBroadcastRate packet too short: %d < 4", decoder.Length())
3501 }
3502 _bsntlvbroadcastrate.Value = uint32(decoder.ReadUint32())
3503 return _bsntlvbroadcastrate, nil
3504}
3505
3506func NewBsnTlvBroadcastRate() *BsnTlvBroadcastRate {
3507 obj := &BsnTlvBroadcastRate{
3508 BsnTlv: NewBsnTlv(90),
3509 }
3510 return obj
3511}
3512
3513type BsnTlvBucket struct {
3514 *BsnTlv
3515 Value []IBsnTlv
3516}
3517
3518type IBsnTlvBucket interface {
3519 IBsnTlv
3520 GetValue() []IBsnTlv
3521}
3522
3523func (self *BsnTlvBucket) GetValue() []IBsnTlv {
3524 return self.Value
3525}
3526
3527func (self *BsnTlvBucket) SetValue(v []IBsnTlv) {
3528 self.Value = v
3529}
3530
3531func (self *BsnTlvBucket) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3532 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3533 if err := self.BsnTlv.Serialize(encoder); err != nil {
3534 return err
3535 }
3536
3537 for _, obj := range self.Value {
3538 if err := obj.Serialize(encoder); err != nil {
3539 return err
3540 }
3541 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3542 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3543
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3544 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3545
3546 return nil
3547}
3548
3549func DecodeBsnTlvBucket(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvBucket, error) {
3550 _bsntlvbucket := &BsnTlvBucket{BsnTlv: parent}
3551
3552 for decoder.Length() >= 4 {
3553 item, err := DecodeBsnTlv(decoder)
3554 if err != nil {
3555 return nil, err
3556 }
3557 if item != nil {
3558 _bsntlvbucket.Value = append(_bsntlvbucket.Value, item)
3559 }
3560 }
3561 return _bsntlvbucket, nil
3562}
3563
3564func NewBsnTlvBucket() *BsnTlvBucket {
3565 obj := &BsnTlvBucket{
3566 BsnTlv: NewBsnTlv(64),
3567 }
3568 return obj
3569}
3570
3571type BsnTlvCircuitId struct {
3572 *BsnTlv
3573 Value []byte
3574}
3575
3576type IBsnTlvCircuitId interface {
3577 IBsnTlv
3578 GetValue() []byte
3579}
3580
3581func (self *BsnTlvCircuitId) GetValue() []byte {
3582 return self.Value
3583}
3584
3585func (self *BsnTlvCircuitId) SetValue(v []byte) {
3586 self.Value = v
3587}
3588
3589func (self *BsnTlvCircuitId) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3590 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3591 if err := self.BsnTlv.Serialize(encoder); err != nil {
3592 return err
3593 }
3594
3595 encoder.Write(self.Value)
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3596 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3597
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3598 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3599
3600 return nil
3601}
3602
3603func DecodeBsnTlvCircuitId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvCircuitId, error) {
3604 _bsntlvcircuitid := &BsnTlvCircuitId{BsnTlv: parent}
3605 _bsntlvcircuitid.Value = decoder.Read(int(decoder.Length()))
3606 return _bsntlvcircuitid, nil
3607}
3608
3609func NewBsnTlvCircuitId() *BsnTlvCircuitId {
3610 obj := &BsnTlvCircuitId{
3611 BsnTlv: NewBsnTlv(14),
3612 }
3613 return obj
3614}
3615
3616type BsnTlvConvergenceStatus struct {
3617 *BsnTlv
3618 Value uint8
3619}
3620
3621type IBsnTlvConvergenceStatus interface {
3622 IBsnTlv
3623 GetValue() uint8
3624}
3625
3626func (self *BsnTlvConvergenceStatus) GetValue() uint8 {
3627 return self.Value
3628}
3629
3630func (self *BsnTlvConvergenceStatus) SetValue(v uint8) {
3631 self.Value = v
3632}
3633
3634func (self *BsnTlvConvergenceStatus) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3635 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3636 if err := self.BsnTlv.Serialize(encoder); err != nil {
3637 return err
3638 }
3639
3640 encoder.PutUint8(uint8(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3641 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3642
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3643 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3644
3645 return nil
3646}
3647
3648func DecodeBsnTlvConvergenceStatus(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvConvergenceStatus, error) {
3649 _bsntlvconvergencestatus := &BsnTlvConvergenceStatus{BsnTlv: parent}
3650 if decoder.Length() < 1 {
3651 return nil, fmt.Errorf("BsnTlvConvergenceStatus packet too short: %d < 1", decoder.Length())
3652 }
3653 _bsntlvconvergencestatus.Value = uint8(decoder.ReadByte())
3654 return _bsntlvconvergencestatus, nil
3655}
3656
3657func NewBsnTlvConvergenceStatus() *BsnTlvConvergenceStatus {
3658 obj := &BsnTlvConvergenceStatus{
3659 BsnTlv: NewBsnTlv(45),
3660 }
3661 return obj
3662}
3663
3664type BsnTlvCpuLag struct {
3665 *BsnTlv
3666}
3667
3668type IBsnTlvCpuLag interface {
3669 IBsnTlv
3670}
3671
3672func (self *BsnTlvCpuLag) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3673 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3674 if err := self.BsnTlv.Serialize(encoder); err != nil {
3675 return err
3676 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3677 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3678
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3679 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3680
3681 return nil
3682}
3683
3684func DecodeBsnTlvCpuLag(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvCpuLag, error) {
3685 _bsntlvcpulag := &BsnTlvCpuLag{BsnTlv: parent}
3686 return _bsntlvcpulag, nil
3687}
3688
3689func NewBsnTlvCpuLag() *BsnTlvCpuLag {
3690 obj := &BsnTlvCpuLag{
3691 BsnTlv: NewBsnTlv(118),
3692 }
3693 return obj
3694}
3695
3696type BsnTlvCrcEnabled struct {
3697 *BsnTlv
3698 Value uint8
3699}
3700
3701type IBsnTlvCrcEnabled interface {
3702 IBsnTlv
3703 GetValue() uint8
3704}
3705
3706func (self *BsnTlvCrcEnabled) GetValue() uint8 {
3707 return self.Value
3708}
3709
3710func (self *BsnTlvCrcEnabled) SetValue(v uint8) {
3711 self.Value = v
3712}
3713
3714func (self *BsnTlvCrcEnabled) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3715 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3716 if err := self.BsnTlv.Serialize(encoder); err != nil {
3717 return err
3718 }
3719
3720 encoder.PutUint8(uint8(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3721 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3722
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3723 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3724
3725 return nil
3726}
3727
3728func DecodeBsnTlvCrcEnabled(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvCrcEnabled, error) {
3729 _bsntlvcrcenabled := &BsnTlvCrcEnabled{BsnTlv: parent}
3730 if decoder.Length() < 1 {
3731 return nil, fmt.Errorf("BsnTlvCrcEnabled packet too short: %d < 1", decoder.Length())
3732 }
3733 _bsntlvcrcenabled.Value = uint8(decoder.ReadByte())
3734 return _bsntlvcrcenabled, nil
3735}
3736
3737func NewBsnTlvCrcEnabled() *BsnTlvCrcEnabled {
3738 obj := &BsnTlvCrcEnabled{
3739 BsnTlv: NewBsnTlv(22),
3740 }
3741 return obj
3742}
3743
3744type BsnTlvData struct {
3745 *BsnTlv
3746 Value []byte
3747}
3748
3749type IBsnTlvData interface {
3750 IBsnTlv
3751 GetValue() []byte
3752}
3753
3754func (self *BsnTlvData) GetValue() []byte {
3755 return self.Value
3756}
3757
3758func (self *BsnTlvData) SetValue(v []byte) {
3759 self.Value = v
3760}
3761
3762func (self *BsnTlvData) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3763 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3764 if err := self.BsnTlv.Serialize(encoder); err != nil {
3765 return err
3766 }
3767
3768 encoder.Write(self.Value)
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3769 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3770
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3771 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3772
3773 return nil
3774}
3775
3776func DecodeBsnTlvData(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvData, error) {
3777 _bsntlvdata := &BsnTlvData{BsnTlv: parent}
3778 _bsntlvdata.Value = decoder.Read(int(decoder.Length()))
3779 return _bsntlvdata, nil
3780}
3781
3782func NewBsnTlvData() *BsnTlvData {
3783 obj := &BsnTlvData{
3784 BsnTlv: NewBsnTlv(55),
3785 }
3786 return obj
3787}
3788
3789type BsnTlvDataMask struct {
3790 *BsnTlv
3791 Value []byte
3792}
3793
3794type IBsnTlvDataMask interface {
3795 IBsnTlv
3796 GetValue() []byte
3797}
3798
3799func (self *BsnTlvDataMask) GetValue() []byte {
3800 return self.Value
3801}
3802
3803func (self *BsnTlvDataMask) SetValue(v []byte) {
3804 self.Value = v
3805}
3806
3807func (self *BsnTlvDataMask) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3808 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3809 if err := self.BsnTlv.Serialize(encoder); err != nil {
3810 return err
3811 }
3812
3813 encoder.Write(self.Value)
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3814 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3815
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3816 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3817
3818 return nil
3819}
3820
3821func DecodeBsnTlvDataMask(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvDataMask, error) {
3822 _bsntlvdatamask := &BsnTlvDataMask{BsnTlv: parent}
3823 _bsntlvdatamask.Value = decoder.Read(int(decoder.Length()))
3824 return _bsntlvdatamask, nil
3825}
3826
3827func NewBsnTlvDataMask() *BsnTlvDataMask {
3828 obj := &BsnTlvDataMask{
3829 BsnTlv: NewBsnTlv(140),
3830 }
3831 return obj
3832}
3833
3834type BsnTlvDecap struct {
3835 *BsnTlv
3836 Value BsnDecap
3837}
3838
3839type IBsnTlvDecap interface {
3840 IBsnTlv
3841 GetValue() BsnDecap
3842}
3843
3844func (self *BsnTlvDecap) GetValue() BsnDecap {
3845 return self.Value
3846}
3847
3848func (self *BsnTlvDecap) SetValue(v BsnDecap) {
3849 self.Value = v
3850}
3851
3852func (self *BsnTlvDecap) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3853 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3854 if err := self.BsnTlv.Serialize(encoder); err != nil {
3855 return err
3856 }
3857
3858 encoder.PutUint16(uint16(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3859 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3860
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3861 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3862
3863 return nil
3864}
3865
3866func DecodeBsnTlvDecap(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvDecap, error) {
3867 _bsntlvdecap := &BsnTlvDecap{BsnTlv: parent}
3868 if decoder.Length() < 2 {
3869 return nil, fmt.Errorf("BsnTlvDecap packet too short: %d < 2", decoder.Length())
3870 }
3871 _bsntlvdecap.Value = BsnDecap(decoder.ReadUint16())
3872 return _bsntlvdecap, nil
3873}
3874
3875func NewBsnTlvDecap() *BsnTlvDecap {
3876 obj := &BsnTlvDecap{
3877 BsnTlv: NewBsnTlv(85),
3878 }
3879 return obj
3880}
3881
3882type BsnTlvDisableSrcMacCheck struct {
3883 *BsnTlv
3884}
3885
3886type IBsnTlvDisableSrcMacCheck interface {
3887 IBsnTlv
3888}
3889
3890func (self *BsnTlvDisableSrcMacCheck) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3891 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3892 if err := self.BsnTlv.Serialize(encoder); err != nil {
3893 return err
3894 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3895 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3896
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3897 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3898
3899 return nil
3900}
3901
3902func DecodeBsnTlvDisableSrcMacCheck(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvDisableSrcMacCheck, error) {
3903 _bsntlvdisablesrcmaccheck := &BsnTlvDisableSrcMacCheck{BsnTlv: parent}
3904 return _bsntlvdisablesrcmaccheck, nil
3905}
3906
3907func NewBsnTlvDisableSrcMacCheck() *BsnTlvDisableSrcMacCheck {
3908 obj := &BsnTlvDisableSrcMacCheck{
3909 BsnTlv: NewBsnTlv(120),
3910 }
3911 return obj
3912}
3913
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3914type BsnTlvDisableXmit struct {
3915 *BsnTlv
3916}
3917
3918type IBsnTlvDisableXmit interface {
3919 IBsnTlv
3920}
3921
3922func (self *BsnTlvDisableXmit) Serialize(encoder *goloxi.Encoder) error {
3923 startIndex := len(encoder.Bytes())
3924 if err := self.BsnTlv.Serialize(encoder); err != nil {
3925 return err
3926 }
3927 length := len(encoder.Bytes()) - startIndex
3928
3929 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
3930
3931 return nil
3932}
3933
3934func DecodeBsnTlvDisableXmit(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvDisableXmit, error) {
3935 _bsntlvdisablexmit := &BsnTlvDisableXmit{BsnTlv: parent}
3936 return _bsntlvdisablexmit, nil
3937}
3938
3939func NewBsnTlvDisableXmit() *BsnTlvDisableXmit {
3940 obj := &BsnTlvDisableXmit{
3941 BsnTlv: NewBsnTlv(185),
3942 }
3943 return obj
3944}
3945
3946type BsnTlvDnsAnalytics struct {
3947 *BsnTlv
3948}
3949
3950type IBsnTlvDnsAnalytics interface {
3951 IBsnTlv
3952}
3953
3954func (self *BsnTlvDnsAnalytics) Serialize(encoder *goloxi.Encoder) error {
3955 startIndex := len(encoder.Bytes())
3956 if err := self.BsnTlv.Serialize(encoder); err != nil {
3957 return err
3958 }
3959 length := len(encoder.Bytes()) - startIndex
3960
3961 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
3962
3963 return nil
3964}
3965
3966func DecodeBsnTlvDnsAnalytics(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvDnsAnalytics, error) {
3967 _bsntlvdnsanalytics := &BsnTlvDnsAnalytics{BsnTlv: parent}
3968 return _bsntlvdnsanalytics, nil
3969}
3970
3971func NewBsnTlvDnsAnalytics() *BsnTlvDnsAnalytics {
3972 obj := &BsnTlvDnsAnalytics{
3973 BsnTlv: NewBsnTlv(190),
3974 }
3975 return obj
3976}
3977
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3978type BsnTlvDrop struct {
3979 *BsnTlv
3980}
3981
3982type IBsnTlvDrop interface {
3983 IBsnTlv
3984}
3985
3986func (self *BsnTlvDrop) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3987 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3988 if err := self.BsnTlv.Serialize(encoder); err != nil {
3989 return err
3990 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3991 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3992
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]3993 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]3994
3995 return nil
3996}
3997
3998func DecodeBsnTlvDrop(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvDrop, error) {
3999 _bsntlvdrop := &BsnTlvDrop{BsnTlv: parent}
4000 return _bsntlvdrop, nil
4001}
4002
4003func NewBsnTlvDrop() *BsnTlvDrop {
4004 obj := &BsnTlvDrop{
4005 BsnTlv: NewBsnTlv(121),
4006 }
4007 return obj
4008}
4009
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4010type BsnTlvDropControl struct {
4011 *BsnTlv
4012}
4013
4014type IBsnTlvDropControl interface {
4015 IBsnTlv
4016}
4017
4018func (self *BsnTlvDropControl) Serialize(encoder *goloxi.Encoder) error {
4019 startIndex := len(encoder.Bytes())
4020 if err := self.BsnTlv.Serialize(encoder); err != nil {
4021 return err
4022 }
4023 length := len(encoder.Bytes()) - startIndex
4024
4025 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4026
4027 return nil
4028}
4029
4030func DecodeBsnTlvDropControl(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvDropControl, error) {
4031 _bsntlvdropcontrol := &BsnTlvDropControl{BsnTlv: parent}
4032 return _bsntlvdropcontrol, nil
4033}
4034
4035func NewBsnTlvDropControl() *BsnTlvDropControl {
4036 obj := &BsnTlvDropControl{
4037 BsnTlv: NewBsnTlv(187),
4038 }
4039 return obj
4040}
4041
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4042type BsnTlvDscp struct {
4043 *BsnTlv
4044 Value uint16
4045}
4046
4047type IBsnTlvDscp interface {
4048 IBsnTlv
4049 GetValue() uint16
4050}
4051
4052func (self *BsnTlvDscp) GetValue() uint16 {
4053 return self.Value
4054}
4055
4056func (self *BsnTlvDscp) SetValue(v uint16) {
4057 self.Value = v
4058}
4059
4060func (self *BsnTlvDscp) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4061 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4062 if err := self.BsnTlv.Serialize(encoder); err != nil {
4063 return err
4064 }
4065
4066 encoder.PutUint16(uint16(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4067 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4068
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4069 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4070
4071 return nil
4072}
4073
4074func DecodeBsnTlvDscp(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvDscp, error) {
4075 _bsntlvdscp := &BsnTlvDscp{BsnTlv: parent}
4076 if decoder.Length() < 2 {
4077 return nil, fmt.Errorf("BsnTlvDscp packet too short: %d < 2", decoder.Length())
4078 }
4079 _bsntlvdscp.Value = uint16(decoder.ReadUint16())
4080 return _bsntlvdscp, nil
4081}
4082
4083func NewBsnTlvDscp() *BsnTlvDscp {
4084 obj := &BsnTlvDscp{
4085 BsnTlv: NewBsnTlv(112),
4086 }
4087 return obj
4088}
4089
4090type BsnTlvEcn struct {
4091 *BsnTlv
4092 Value uint8
4093}
4094
4095type IBsnTlvEcn interface {
4096 IBsnTlv
4097 GetValue() uint8
4098}
4099
4100func (self *BsnTlvEcn) GetValue() uint8 {
4101 return self.Value
4102}
4103
4104func (self *BsnTlvEcn) SetValue(v uint8) {
4105 self.Value = v
4106}
4107
4108func (self *BsnTlvEcn) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4109 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4110 if err := self.BsnTlv.Serialize(encoder); err != nil {
4111 return err
4112 }
4113
4114 encoder.PutUint8(uint8(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4115 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4116
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4117 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4118
4119 return nil
4120}
4121
4122func DecodeBsnTlvEcn(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEcn, error) {
4123 _bsntlvecn := &BsnTlvEcn{BsnTlv: parent}
4124 if decoder.Length() < 1 {
4125 return nil, fmt.Errorf("BsnTlvEcn packet too short: %d < 1", decoder.Length())
4126 }
4127 _bsntlvecn.Value = uint8(decoder.ReadByte())
4128 return _bsntlvecn, nil
4129}
4130
4131func NewBsnTlvEcn() *BsnTlvEcn {
4132 obj := &BsnTlvEcn{
4133 BsnTlv: NewBsnTlv(132),
4134 }
4135 return obj
4136}
4137
4138type BsnTlvEgressOnly struct {
4139 *BsnTlv
4140}
4141
4142type IBsnTlvEgressOnly interface {
4143 IBsnTlv
4144}
4145
4146func (self *BsnTlvEgressOnly) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4147 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4148 if err := self.BsnTlv.Serialize(encoder); err != nil {
4149 return err
4150 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4151 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4152
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4153 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4154
4155 return nil
4156}
4157
4158func DecodeBsnTlvEgressOnly(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEgressOnly, error) {
4159 _bsntlvegressonly := &BsnTlvEgressOnly{BsnTlv: parent}
4160 return _bsntlvegressonly, nil
4161}
4162
4163func NewBsnTlvEgressOnly() *BsnTlvEgressOnly {
4164 obj := &BsnTlvEgressOnly{
4165 BsnTlv: NewBsnTlv(137),
4166 }
4167 return obj
4168}
4169
4170type BsnTlvEgressPortGroupId struct {
4171 *BsnTlv
4172 Value uint32
4173}
4174
4175type IBsnTlvEgressPortGroupId interface {
4176 IBsnTlv
4177 GetValue() uint32
4178}
4179
4180func (self *BsnTlvEgressPortGroupId) GetValue() uint32 {
4181 return self.Value
4182}
4183
4184func (self *BsnTlvEgressPortGroupId) SetValue(v uint32) {
4185 self.Value = v
4186}
4187
4188func (self *BsnTlvEgressPortGroupId) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4189 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4190 if err := self.BsnTlv.Serialize(encoder); err != nil {
4191 return err
4192 }
4193
4194 encoder.PutUint32(uint32(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4195 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4196
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4197 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4198
4199 return nil
4200}
4201
4202func DecodeBsnTlvEgressPortGroupId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEgressPortGroupId, error) {
4203 _bsntlvegressportgroupid := &BsnTlvEgressPortGroupId{BsnTlv: parent}
4204 if decoder.Length() < 4 {
4205 return nil, fmt.Errorf("BsnTlvEgressPortGroupId packet too short: %d < 4", decoder.Length())
4206 }
4207 _bsntlvegressportgroupid.Value = uint32(decoder.ReadUint32())
4208 return _bsntlvegressportgroupid, nil
4209}
4210
4211func NewBsnTlvEgressPortGroupId() *BsnTlvEgressPortGroupId {
4212 obj := &BsnTlvEgressPortGroupId{
4213 BsnTlv: NewBsnTlv(139),
4214 }
4215 return obj
4216}
4217
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4218type BsnTlvEgressSamplingRate struct {
4219 *BsnTlv
4220 Value uint32
4221}
4222
4223type IBsnTlvEgressSamplingRate interface {
4224 IBsnTlv
4225 GetValue() uint32
4226}
4227
4228func (self *BsnTlvEgressSamplingRate) GetValue() uint32 {
4229 return self.Value
4230}
4231
4232func (self *BsnTlvEgressSamplingRate) SetValue(v uint32) {
4233 self.Value = v
4234}
4235
4236func (self *BsnTlvEgressSamplingRate) Serialize(encoder *goloxi.Encoder) error {
4237 startIndex := len(encoder.Bytes())
4238 if err := self.BsnTlv.Serialize(encoder); err != nil {
4239 return err
4240 }
4241
4242 encoder.PutUint32(uint32(self.Value))
4243 length := len(encoder.Bytes()) - startIndex
4244
4245 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4246
4247 return nil
4248}
4249
4250func DecodeBsnTlvEgressSamplingRate(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEgressSamplingRate, error) {
4251 _bsntlvegresssamplingrate := &BsnTlvEgressSamplingRate{BsnTlv: parent}
4252 if decoder.Length() < 4 {
4253 return nil, fmt.Errorf("BsnTlvEgressSamplingRate packet too short: %d < 4", decoder.Length())
4254 }
4255 _bsntlvegresssamplingrate.Value = uint32(decoder.ReadUint32())
4256 return _bsntlvegresssamplingrate, nil
4257}
4258
4259func NewBsnTlvEgressSamplingRate() *BsnTlvEgressSamplingRate {
4260 obj := &BsnTlvEgressSamplingRate{
4261 BsnTlv: NewBsnTlv(195),
4262 }
4263 return obj
4264}
4265
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4266type BsnTlvEncap struct {
4267 *BsnTlv
4268 Value BsnEncap
4269}
4270
4271type IBsnTlvEncap interface {
4272 IBsnTlv
4273 GetValue() BsnEncap
4274}
4275
4276func (self *BsnTlvEncap) GetValue() BsnEncap {
4277 return self.Value
4278}
4279
4280func (self *BsnTlvEncap) SetValue(v BsnEncap) {
4281 self.Value = v
4282}
4283
4284func (self *BsnTlvEncap) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4285 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4286 if err := self.BsnTlv.Serialize(encoder); err != nil {
4287 return err
4288 }
4289
4290 encoder.PutUint8(uint8(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4291 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4292
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4293 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4294
4295 return nil
4296}
4297
4298func DecodeBsnTlvEncap(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEncap, error) {
4299 _bsntlvencap := &BsnTlvEncap{BsnTlv: parent}
4300 if decoder.Length() < 1 {
4301 return nil, fmt.Errorf("BsnTlvEncap packet too short: %d < 1", decoder.Length())
4302 }
4303 _bsntlvencap.Value = BsnEncap(decoder.ReadByte())
4304 return _bsntlvencap, nil
4305}
4306
4307func NewBsnTlvEncap() *BsnTlvEncap {
4308 obj := &BsnTlvEncap{
4309 BsnTlv: NewBsnTlv(175),
4310 }
4311 return obj
4312}
4313
4314type BsnTlvEnhancedHashCapability struct {
4315 *BsnTlv
4316 Value BsnEnhancedHashType
4317}
4318
4319type IBsnTlvEnhancedHashCapability interface {
4320 IBsnTlv
4321 GetValue() BsnEnhancedHashType
4322}
4323
4324func (self *BsnTlvEnhancedHashCapability) GetValue() BsnEnhancedHashType {
4325 return self.Value
4326}
4327
4328func (self *BsnTlvEnhancedHashCapability) SetValue(v BsnEnhancedHashType) {
4329 self.Value = v
4330}
4331
4332func (self *BsnTlvEnhancedHashCapability) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4333 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4334 if err := self.BsnTlv.Serialize(encoder); err != nil {
4335 return err
4336 }
4337
4338 encoder.PutUint64(uint64(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4339 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4340
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4341 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4342
4343 return nil
4344}
4345
4346func DecodeBsnTlvEnhancedHashCapability(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEnhancedHashCapability, error) {
4347 _bsntlvenhancedhashcapability := &BsnTlvEnhancedHashCapability{BsnTlv: parent}
4348 if decoder.Length() < 8 {
4349 return nil, fmt.Errorf("BsnTlvEnhancedHashCapability packet too short: %d < 8", decoder.Length())
4350 }
4351 _bsntlvenhancedhashcapability.Value = BsnEnhancedHashType(decoder.ReadUint64())
4352 return _bsntlvenhancedhashcapability, nil
4353}
4354
4355func NewBsnTlvEnhancedHashCapability() *BsnTlvEnhancedHashCapability {
4356 obj := &BsnTlvEnhancedHashCapability{
4357 BsnTlv: NewBsnTlv(143),
4358 }
4359 return obj
4360}
4361
4362type BsnTlvEthDst struct {
4363 *BsnTlv
4364 Value net.HardwareAddr
4365}
4366
4367type IBsnTlvEthDst interface {
4368 IBsnTlv
4369 GetValue() net.HardwareAddr
4370}
4371
4372func (self *BsnTlvEthDst) GetValue() net.HardwareAddr {
4373 return self.Value
4374}
4375
4376func (self *BsnTlvEthDst) SetValue(v net.HardwareAddr) {
4377 self.Value = v
4378}
4379
4380func (self *BsnTlvEthDst) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4381 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4382 if err := self.BsnTlv.Serialize(encoder); err != nil {
4383 return err
4384 }
4385
4386 encoder.Write(self.Value)
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4387 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4388
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4389 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4390
4391 return nil
4392}
4393
4394func DecodeBsnTlvEthDst(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEthDst, error) {
4395 _bsntlvethdst := &BsnTlvEthDst{BsnTlv: parent}
4396 if decoder.Length() < 6 {
4397 return nil, fmt.Errorf("BsnTlvEthDst packet too short: %d < 6", decoder.Length())
4398 }
4399 _bsntlvethdst.Value = net.HardwareAddr(decoder.Read(6))
4400 return _bsntlvethdst, nil
4401}
4402
4403func NewBsnTlvEthDst() *BsnTlvEthDst {
4404 obj := &BsnTlvEthDst{
4405 BsnTlv: NewBsnTlv(33),
4406 }
4407 return obj
4408}
4409
4410type BsnTlvEthSrc struct {
4411 *BsnTlv
4412 Value net.HardwareAddr
4413}
4414
4415type IBsnTlvEthSrc interface {
4416 IBsnTlv
4417 GetValue() net.HardwareAddr
4418}
4419
4420func (self *BsnTlvEthSrc) GetValue() net.HardwareAddr {
4421 return self.Value
4422}
4423
4424func (self *BsnTlvEthSrc) SetValue(v net.HardwareAddr) {
4425 self.Value = v
4426}
4427
4428func (self *BsnTlvEthSrc) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4429 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4430 if err := self.BsnTlv.Serialize(encoder); err != nil {
4431 return err
4432 }
4433
4434 encoder.Write(self.Value)
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4435 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4436
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4437 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4438
4439 return nil
4440}
4441
4442func DecodeBsnTlvEthSrc(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEthSrc, error) {
4443 _bsntlvethsrc := &BsnTlvEthSrc{BsnTlv: parent}
4444 if decoder.Length() < 6 {
4445 return nil, fmt.Errorf("BsnTlvEthSrc packet too short: %d < 6", decoder.Length())
4446 }
4447 _bsntlvethsrc.Value = net.HardwareAddr(decoder.Read(6))
4448 return _bsntlvethsrc, nil
4449}
4450
4451func NewBsnTlvEthSrc() *BsnTlvEthSrc {
4452 obj := &BsnTlvEthSrc{
4453 BsnTlv: NewBsnTlv(32),
4454 }
4455 return obj
4456}
4457
4458type BsnTlvEthType struct {
4459 *BsnTlv
4460 Value uint16
4461}
4462
4463type IBsnTlvEthType interface {
4464 IBsnTlv
4465 GetValue() uint16
4466}
4467
4468func (self *BsnTlvEthType) GetValue() uint16 {
4469 return self.Value
4470}
4471
4472func (self *BsnTlvEthType) SetValue(v uint16) {
4473 self.Value = v
4474}
4475
4476func (self *BsnTlvEthType) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4477 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4478 if err := self.BsnTlv.Serialize(encoder); err != nil {
4479 return err
4480 }
4481
4482 encoder.PutUint16(uint16(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4483 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4484
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4485 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4486
4487 return nil
4488}
4489
4490func DecodeBsnTlvEthType(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEthType, error) {
4491 _bsntlvethtype := &BsnTlvEthType{BsnTlv: parent}
4492 if decoder.Length() < 2 {
4493 return nil, fmt.Errorf("BsnTlvEthType packet too short: %d < 2", decoder.Length())
4494 }
4495 _bsntlvethtype.Value = uint16(decoder.ReadUint16())
4496 return _bsntlvethtype, nil
4497}
4498
4499func NewBsnTlvEthType() *BsnTlvEthType {
4500 obj := &BsnTlvEthType{
4501 BsnTlv: NewBsnTlv(131),
4502 }
4503 return obj
4504}
4505
4506type BsnTlvExternalGatewayIp struct {
4507 *BsnTlv
4508 Value net.IP
4509}
4510
4511type IBsnTlvExternalGatewayIp interface {
4512 IBsnTlv
4513 GetValue() net.IP
4514}
4515
4516func (self *BsnTlvExternalGatewayIp) GetValue() net.IP {
4517 return self.Value
4518}
4519
4520func (self *BsnTlvExternalGatewayIp) SetValue(v net.IP) {
4521 self.Value = v
4522}
4523
4524func (self *BsnTlvExternalGatewayIp) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4525 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4526 if err := self.BsnTlv.Serialize(encoder); err != nil {
4527 return err
4528 }
4529
4530 encoder.Write(self.Value.To4())
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4531 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4532
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4533 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4534
4535 return nil
4536}
4537
4538func DecodeBsnTlvExternalGatewayIp(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvExternalGatewayIp, error) {
4539 _bsntlvexternalgatewayip := &BsnTlvExternalGatewayIp{BsnTlv: parent}
4540 if decoder.Length() < 4 {
4541 return nil, fmt.Errorf("BsnTlvExternalGatewayIp packet too short: %d < 4", decoder.Length())
4542 }
4543 _bsntlvexternalgatewayip.Value = net.IP(decoder.Read(4))
4544 return _bsntlvexternalgatewayip, nil
4545}
4546
4547func NewBsnTlvExternalGatewayIp() *BsnTlvExternalGatewayIp {
4548 obj := &BsnTlvExternalGatewayIp{
4549 BsnTlv: NewBsnTlv(26),
4550 }
4551 return obj
4552}
4553
4554type BsnTlvExternalGatewayMac struct {
4555 *BsnTlv
4556 Value net.HardwareAddr
4557}
4558
4559type IBsnTlvExternalGatewayMac interface {
4560 IBsnTlv
4561 GetValue() net.HardwareAddr
4562}
4563
4564func (self *BsnTlvExternalGatewayMac) GetValue() net.HardwareAddr {
4565 return self.Value
4566}
4567
4568func (self *BsnTlvExternalGatewayMac) SetValue(v net.HardwareAddr) {
4569 self.Value = v
4570}
4571
4572func (self *BsnTlvExternalGatewayMac) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4573 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4574 if err := self.BsnTlv.Serialize(encoder); err != nil {
4575 return err
4576 }
4577
4578 encoder.Write(self.Value)
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4579 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4580
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4581 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4582
4583 return nil
4584}
4585
4586func DecodeBsnTlvExternalGatewayMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvExternalGatewayMac, error) {
4587 _bsntlvexternalgatewaymac := &BsnTlvExternalGatewayMac{BsnTlv: parent}
4588 if decoder.Length() < 6 {
4589 return nil, fmt.Errorf("BsnTlvExternalGatewayMac packet too short: %d < 6", decoder.Length())
4590 }
4591 _bsntlvexternalgatewaymac.Value = net.HardwareAddr(decoder.Read(6))
4592 return _bsntlvexternalgatewaymac, nil
4593}
4594
4595func NewBsnTlvExternalGatewayMac() *BsnTlvExternalGatewayMac {
4596 obj := &BsnTlvExternalGatewayMac{
4597 BsnTlv: NewBsnTlv(29),
4598 }
4599 return obj
4600}
4601
4602type BsnTlvExternalIp struct {
4603 *BsnTlv
4604 Value net.IP
4605}
4606
4607type IBsnTlvExternalIp interface {
4608 IBsnTlv
4609 GetValue() net.IP
4610}
4611
4612func (self *BsnTlvExternalIp) GetValue() net.IP {
4613 return self.Value
4614}
4615
4616func (self *BsnTlvExternalIp) SetValue(v net.IP) {
4617 self.Value = v
4618}
4619
4620func (self *BsnTlvExternalIp) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4621 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4622 if err := self.BsnTlv.Serialize(encoder); err != nil {
4623 return err
4624 }
4625
4626 encoder.Write(self.Value.To4())
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4627 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4628
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4629 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4630
4631 return nil
4632}
4633
4634func DecodeBsnTlvExternalIp(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvExternalIp, error) {
4635 _bsntlvexternalip := &BsnTlvExternalIp{BsnTlv: parent}
4636 if decoder.Length() < 4 {
4637 return nil, fmt.Errorf("BsnTlvExternalIp packet too short: %d < 4", decoder.Length())
4638 }
4639 _bsntlvexternalip.Value = net.IP(decoder.Read(4))
4640 return _bsntlvexternalip, nil
4641}
4642
4643func NewBsnTlvExternalIp() *BsnTlvExternalIp {
4644 obj := &BsnTlvExternalIp{
4645 BsnTlv: NewBsnTlv(23),
4646 }
4647 return obj
4648}
4649
4650type BsnTlvExternalMac struct {
4651 *BsnTlv
4652 Value net.HardwareAddr
4653}
4654
4655type IBsnTlvExternalMac interface {
4656 IBsnTlv
4657 GetValue() net.HardwareAddr
4658}
4659
4660func (self *BsnTlvExternalMac) GetValue() net.HardwareAddr {
4661 return self.Value
4662}
4663
4664func (self *BsnTlvExternalMac) SetValue(v net.HardwareAddr) {
4665 self.Value = v
4666}
4667
4668func (self *BsnTlvExternalMac) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4669 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4670 if err := self.BsnTlv.Serialize(encoder); err != nil {
4671 return err
4672 }
4673
4674 encoder.Write(self.Value)
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4675 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4676
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4677 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4678
4679 return nil
4680}
4681
4682func DecodeBsnTlvExternalMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvExternalMac, error) {
4683 _bsntlvexternalmac := &BsnTlvExternalMac{BsnTlv: parent}
4684 if decoder.Length() < 6 {
4685 return nil, fmt.Errorf("BsnTlvExternalMac packet too short: %d < 6", decoder.Length())
4686 }
4687 _bsntlvexternalmac.Value = net.HardwareAddr(decoder.Read(6))
4688 return _bsntlvexternalmac, nil
4689}
4690
4691func NewBsnTlvExternalMac() *BsnTlvExternalMac {
4692 obj := &BsnTlvExternalMac{
4693 BsnTlv: NewBsnTlv(24),
4694 }
4695 return obj
4696}
4697
4698type BsnTlvExternalNetmask struct {
4699 *BsnTlv
4700 Value net.IP
4701}
4702
4703type IBsnTlvExternalNetmask interface {
4704 IBsnTlv
4705 GetValue() net.IP
4706}
4707
4708func (self *BsnTlvExternalNetmask) GetValue() net.IP {
4709 return self.Value
4710}
4711
4712func (self *BsnTlvExternalNetmask) SetValue(v net.IP) {
4713 self.Value = v
4714}
4715
4716func (self *BsnTlvExternalNetmask) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4717 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4718 if err := self.BsnTlv.Serialize(encoder); err != nil {
4719 return err
4720 }
4721
4722 encoder.Write(self.Value.To4())
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4723 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4724
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4725 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4726
4727 return nil
4728}
4729
4730func DecodeBsnTlvExternalNetmask(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvExternalNetmask, error) {
4731 _bsntlvexternalnetmask := &BsnTlvExternalNetmask{BsnTlv: parent}
4732 if decoder.Length() < 4 {
4733 return nil, fmt.Errorf("BsnTlvExternalNetmask packet too short: %d < 4", decoder.Length())
4734 }
4735 _bsntlvexternalnetmask.Value = net.IP(decoder.Read(4))
4736 return _bsntlvexternalnetmask, nil
4737}
4738
4739func NewBsnTlvExternalNetmask() *BsnTlvExternalNetmask {
4740 obj := &BsnTlvExternalNetmask{
4741 BsnTlv: NewBsnTlv(25),
4742 }
4743 return obj
4744}
4745
4746type BsnTlvFabricPortRole struct {
4747 *BsnTlv
4748 Value BsnFabricPortRole
4749}
4750
4751type IBsnTlvFabricPortRole interface {
4752 IBsnTlv
4753 GetValue() BsnFabricPortRole
4754}
4755
4756func (self *BsnTlvFabricPortRole) GetValue() BsnFabricPortRole {
4757 return self.Value
4758}
4759
4760func (self *BsnTlvFabricPortRole) SetValue(v BsnFabricPortRole) {
4761 self.Value = v
4762}
4763
4764func (self *BsnTlvFabricPortRole) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4765 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4766 if err := self.BsnTlv.Serialize(encoder); err != nil {
4767 return err
4768 }
4769
4770 encoder.PutUint16(uint16(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4771 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4772
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4773 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4774
4775 return nil
4776}
4777
4778func DecodeBsnTlvFabricPortRole(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvFabricPortRole, error) {
4779 _bsntlvfabricportrole := &BsnTlvFabricPortRole{BsnTlv: parent}
4780 if decoder.Length() < 2 {
4781 return nil, fmt.Errorf("BsnTlvFabricPortRole packet too short: %d < 2", decoder.Length())
4782 }
4783 _bsntlvfabricportrole.Value = BsnFabricPortRole(decoder.ReadUint16())
4784 return _bsntlvfabricportrole, nil
4785}
4786
4787func NewBsnTlvFabricPortRole() *BsnTlvFabricPortRole {
4788 obj := &BsnTlvFabricPortRole{
4789 BsnTlv: NewBsnTlv(165),
4790 }
4791 return obj
4792}
4793
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4794type BsnTlvFailCount struct {
4795 *BsnTlv
4796 Value uint64
4797}
4798
4799type IBsnTlvFailCount interface {
4800 IBsnTlv
4801 GetValue() uint64
4802}
4803
4804func (self *BsnTlvFailCount) GetValue() uint64 {
4805 return self.Value
4806}
4807
4808func (self *BsnTlvFailCount) SetValue(v uint64) {
4809 self.Value = v
4810}
4811
4812func (self *BsnTlvFailCount) Serialize(encoder *goloxi.Encoder) error {
4813 startIndex := len(encoder.Bytes())
4814 if err := self.BsnTlv.Serialize(encoder); err != nil {
4815 return err
4816 }
4817
4818 encoder.PutUint64(uint64(self.Value))
4819 length := len(encoder.Bytes()) - startIndex
4820
4821 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4822
4823 return nil
4824}
4825
4826func DecodeBsnTlvFailCount(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvFailCount, error) {
4827 _bsntlvfailcount := &BsnTlvFailCount{BsnTlv: parent}
4828 if decoder.Length() < 8 {
4829 return nil, fmt.Errorf("BsnTlvFailCount packet too short: %d < 8", decoder.Length())
4830 }
4831 _bsntlvfailcount.Value = uint64(decoder.ReadUint64())
4832 return _bsntlvfailcount, nil
4833}
4834
4835func NewBsnTlvFailCount() *BsnTlvFailCount {
4836 obj := &BsnTlvFailCount{
4837 BsnTlv: NewBsnTlv(194),
4838 }
4839 return obj
4840}
4841
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4842type BsnTlvFlood struct {
4843 *BsnTlv
4844}
4845
4846type IBsnTlvFlood interface {
4847 IBsnTlv
4848}
4849
4850func (self *BsnTlvFlood) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4851 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4852 if err := self.BsnTlv.Serialize(encoder); err != nil {
4853 return err
4854 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4855 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4856
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4857 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4858
4859 return nil
4860}
4861
4862func DecodeBsnTlvFlood(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvFlood, error) {
4863 _bsntlvflood := &BsnTlvFlood{BsnTlv: parent}
4864 return _bsntlvflood, nil
4865}
4866
4867func NewBsnTlvFlood() *BsnTlvFlood {
4868 obj := &BsnTlvFlood{
4869 BsnTlv: NewBsnTlv(163),
4870 }
4871 return obj
4872}
4873
4874type BsnTlvFlowClassifier struct {
4875 *BsnTlv
4876 Value BsnFlowClassifier
4877}
4878
4879type IBsnTlvFlowClassifier interface {
4880 IBsnTlv
4881 GetValue() BsnFlowClassifier
4882}
4883
4884func (self *BsnTlvFlowClassifier) GetValue() BsnFlowClassifier {
4885 return self.Value
4886}
4887
4888func (self *BsnTlvFlowClassifier) SetValue(v BsnFlowClassifier) {
4889 self.Value = v
4890}
4891
4892func (self *BsnTlvFlowClassifier) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4893 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4894 if err := self.BsnTlv.Serialize(encoder); err != nil {
4895 return err
4896 }
4897
4898 encoder.PutUint16(uint16(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4899 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4900
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4901 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4902
4903 return nil
4904}
4905
4906func DecodeBsnTlvFlowClassifier(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvFlowClassifier, error) {
4907 _bsntlvflowclassifier := &BsnTlvFlowClassifier{BsnTlv: parent}
4908 if decoder.Length() < 2 {
4909 return nil, fmt.Errorf("BsnTlvFlowClassifier packet too short: %d < 2", decoder.Length())
4910 }
4911 _bsntlvflowclassifier.Value = BsnFlowClassifier(decoder.ReadUint16())
4912 return _bsntlvflowclassifier, nil
4913}
4914
4915func NewBsnTlvFlowClassifier() *BsnTlvFlowClassifier {
4916 obj := &BsnTlvFlowClassifier{
4917 BsnTlv: NewBsnTlv(184),
4918 }
4919 return obj
4920}
4921
4922type BsnTlvFlowClassify struct {
4923 *BsnTlv
4924}
4925
4926type IBsnTlvFlowClassify interface {
4927 IBsnTlv
4928}
4929
4930func (self *BsnTlvFlowClassify) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4931 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4932 if err := self.BsnTlv.Serialize(encoder); err != nil {
4933 return err
4934 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4935 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4936
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4937 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4938
4939 return nil
4940}
4941
4942func DecodeBsnTlvFlowClassify(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvFlowClassify, error) {
4943 _bsntlvflowclassify := &BsnTlvFlowClassify{BsnTlv: parent}
4944 return _bsntlvflowclassify, nil
4945}
4946
4947func NewBsnTlvFlowClassify() *BsnTlvFlowClassify {
4948 obj := &BsnTlvFlowClassify{
4949 BsnTlv: NewBsnTlv(182),
4950 }
4951 return obj
4952}
4953
4954type BsnTlvFlowIdentifier struct {
4955 *BsnTlv
4956 Value uint32
4957}
4958
4959type IBsnTlvFlowIdentifier interface {
4960 IBsnTlv
4961 GetValue() uint32
4962}
4963
4964func (self *BsnTlvFlowIdentifier) GetValue() uint32 {
4965 return self.Value
4966}
4967
4968func (self *BsnTlvFlowIdentifier) SetValue(v uint32) {
4969 self.Value = v
4970}
4971
4972func (self *BsnTlvFlowIdentifier) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4973 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4974 if err := self.BsnTlv.Serialize(encoder); err != nil {
4975 return err
4976 }
4977
4978 encoder.PutUint32(uint32(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4979 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4980
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]4981 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]4982
4983 return nil
4984}
4985
4986func DecodeBsnTlvFlowIdentifier(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvFlowIdentifier, error) {
4987 _bsntlvflowidentifier := &BsnTlvFlowIdentifier{BsnTlv: parent}
4988 if decoder.Length() < 4 {
4989 return nil, fmt.Errorf("BsnTlvFlowIdentifier packet too short: %d < 4", decoder.Length())
4990 }
4991 _bsntlvflowidentifier.Value = uint32(decoder.ReadUint32())
4992 return _bsntlvflowidentifier, nil
4993}
4994
4995func NewBsnTlvFlowIdentifier() *BsnTlvFlowIdentifier {
4996 obj := &BsnTlvFlowIdentifier{
4997 BsnTlv: NewBsnTlv(183),
4998 }
4999 return obj
5000}
5001
5002type BsnTlvForceLinkUp struct {
5003 *BsnTlv
5004}
5005
5006type IBsnTlvForceLinkUp interface {
5007 IBsnTlv
5008}
5009
5010func (self *BsnTlvForceLinkUp) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5011 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5012 if err := self.BsnTlv.Serialize(encoder); err != nil {
5013 return err
5014 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5015 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5016
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5017 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5018
5019 return nil
5020}
5021
5022func DecodeBsnTlvForceLinkUp(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvForceLinkUp, error) {
5023 _bsntlvforcelinkup := &BsnTlvForceLinkUp{BsnTlv: parent}
5024 return _bsntlvforcelinkup, nil
5025}
5026
5027func NewBsnTlvForceLinkUp() *BsnTlvForceLinkUp {
5028 obj := &BsnTlvForceLinkUp{
5029 BsnTlv: NewBsnTlv(151),
5030 }
5031 return obj
5032}
5033
5034type BsnTlvForwardErrorCorrection struct {
5035 *BsnTlv
5036 Value BsnForwardErrorCorrectionType
5037}
5038
5039type IBsnTlvForwardErrorCorrection interface {
5040 IBsnTlv
5041 GetValue() BsnForwardErrorCorrectionType
5042}
5043
5044func (self *BsnTlvForwardErrorCorrection) GetValue() BsnForwardErrorCorrectionType {
5045 return self.Value
5046}
5047
5048func (self *BsnTlvForwardErrorCorrection) SetValue(v BsnForwardErrorCorrectionType) {
5049 self.Value = v
5050}
5051
5052func (self *BsnTlvForwardErrorCorrection) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5053 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5054 if err := self.BsnTlv.Serialize(encoder); err != nil {
5055 return err
5056 }
5057
5058 encoder.PutUint8(uint8(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5059 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5060
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5061 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5062
5063 return nil
5064}
5065
5066func DecodeBsnTlvForwardErrorCorrection(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvForwardErrorCorrection, error) {
5067 _bsntlvforwarderrorcorrection := &BsnTlvForwardErrorCorrection{BsnTlv: parent}
5068 if decoder.Length() < 1 {
5069 return nil, fmt.Errorf("BsnTlvForwardErrorCorrection packet too short: %d < 1", decoder.Length())
5070 }
5071 _bsntlvforwarderrorcorrection.Value = BsnForwardErrorCorrectionType(decoder.ReadByte())
5072 return _bsntlvforwarderrorcorrection, nil
5073}
5074
5075func NewBsnTlvForwardErrorCorrection() *BsnTlvForwardErrorCorrection {
5076 obj := &BsnTlvForwardErrorCorrection{
5077 BsnTlv: NewBsnTlv(149),
5078 }
5079 return obj
5080}
5081
5082type BsnTlvGenerationId struct {
5083 *BsnTlv
5084 Value uint64
5085}
5086
5087type IBsnTlvGenerationId interface {
5088 IBsnTlv
5089 GetValue() uint64
5090}
5091
5092func (self *BsnTlvGenerationId) GetValue() uint64 {
5093 return self.Value
5094}
5095
5096func (self *BsnTlvGenerationId) SetValue(v uint64) {
5097 self.Value = v
5098}
5099
5100func (self *BsnTlvGenerationId) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5101 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5102 if err := self.BsnTlv.Serialize(encoder); err != nil {
5103 return err
5104 }
5105
5106 encoder.PutUint64(uint64(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5107 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5108
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5109 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5110
5111 return nil
5112}
5113
5114func DecodeBsnTlvGenerationId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvGenerationId, error) {
5115 _bsntlvgenerationid := &BsnTlvGenerationId{BsnTlv: parent}
5116 if decoder.Length() < 8 {
5117 return nil, fmt.Errorf("BsnTlvGenerationId packet too short: %d < 8", decoder.Length())
5118 }
5119 _bsntlvgenerationid.Value = uint64(decoder.ReadUint64())
5120 return _bsntlvgenerationid, nil
5121}
5122
5123func NewBsnTlvGenerationId() *BsnTlvGenerationId {
5124 obj := &BsnTlvGenerationId{
5125 BsnTlv: NewBsnTlv(80),
5126 }
5127 return obj
5128}
5129
5130type BsnTlvHashAlgorithm struct {
5131 *BsnTlv
5132 Value BsnHashAlgorithmType
5133}
5134
5135type IBsnTlvHashAlgorithm interface {
5136 IBsnTlv
5137 GetValue() BsnHashAlgorithmType
5138}
5139
5140func (self *BsnTlvHashAlgorithm) GetValue() BsnHashAlgorithmType {
5141 return self.Value
5142}
5143
5144func (self *BsnTlvHashAlgorithm) SetValue(v BsnHashAlgorithmType) {
5145 self.Value = v
5146}
5147
5148func (self *BsnTlvHashAlgorithm) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5149 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5150 if err := self.BsnTlv.Serialize(encoder); err != nil {
5151 return err
5152 }
5153
5154 encoder.PutUint16(uint16(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5155 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5156
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5157 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5158
5159 return nil
5160}
5161
5162func DecodeBsnTlvHashAlgorithm(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHashAlgorithm, error) {
5163 _bsntlvhashalgorithm := &BsnTlvHashAlgorithm{BsnTlv: parent}
5164 if decoder.Length() < 2 {
5165 return nil, fmt.Errorf("BsnTlvHashAlgorithm packet too short: %d < 2", decoder.Length())
5166 }
5167 _bsntlvhashalgorithm.Value = BsnHashAlgorithmType(decoder.ReadUint16())
5168 return _bsntlvhashalgorithm, nil
5169}
5170
5171func NewBsnTlvHashAlgorithm() *BsnTlvHashAlgorithm {
5172 obj := &BsnTlvHashAlgorithm{
5173 BsnTlv: NewBsnTlv(145),
5174 }
5175 return obj
5176}
5177
5178type BsnTlvHashGtpHeaderMatch struct {
5179 *BsnTlv
5180 FirstHeaderByte uint8
5181 FirstHeaderMask uint8
5182}
5183
5184type IBsnTlvHashGtpHeaderMatch interface {
5185 IBsnTlv
5186 GetFirstHeaderByte() uint8
5187 GetFirstHeaderMask() uint8
5188}
5189
5190func (self *BsnTlvHashGtpHeaderMatch) GetFirstHeaderByte() uint8 {
5191 return self.FirstHeaderByte
5192}
5193
5194func (self *BsnTlvHashGtpHeaderMatch) SetFirstHeaderByte(v uint8) {
5195 self.FirstHeaderByte = v
5196}
5197
5198func (self *BsnTlvHashGtpHeaderMatch) GetFirstHeaderMask() uint8 {
5199 return self.FirstHeaderMask
5200}
5201
5202func (self *BsnTlvHashGtpHeaderMatch) SetFirstHeaderMask(v uint8) {
5203 self.FirstHeaderMask = v
5204}
5205
5206func (self *BsnTlvHashGtpHeaderMatch) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5207 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5208 if err := self.BsnTlv.Serialize(encoder); err != nil {
5209 return err
5210 }
5211
5212 encoder.PutUint8(uint8(self.FirstHeaderByte))
5213 encoder.PutUint8(uint8(self.FirstHeaderMask))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5214 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5215
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5216 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5217
5218 return nil
5219}
5220
5221func DecodeBsnTlvHashGtpHeaderMatch(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHashGtpHeaderMatch, error) {
5222 _bsntlvhashgtpheadermatch := &BsnTlvHashGtpHeaderMatch{BsnTlv: parent}
5223 if decoder.Length() < 2 {
5224 return nil, fmt.Errorf("BsnTlvHashGtpHeaderMatch packet too short: %d < 2", decoder.Length())
5225 }
5226 _bsntlvhashgtpheadermatch.FirstHeaderByte = uint8(decoder.ReadByte())
5227 _bsntlvhashgtpheadermatch.FirstHeaderMask = uint8(decoder.ReadByte())
5228 return _bsntlvhashgtpheadermatch, nil
5229}
5230
5231func NewBsnTlvHashGtpHeaderMatch() *BsnTlvHashGtpHeaderMatch {
5232 obj := &BsnTlvHashGtpHeaderMatch{
5233 BsnTlv: NewBsnTlv(104),
5234 }
5235 return obj
5236}
5237
5238type BsnTlvHashGtpPortMatch struct {
5239 *BsnTlv
5240 Match BsnHashGtpPortMatch
5241 SrcPort uint16
5242 DstPort uint16
5243}
5244
5245type IBsnTlvHashGtpPortMatch interface {
5246 IBsnTlv
5247 GetMatch() BsnHashGtpPortMatch
5248 GetSrcPort() uint16
5249 GetDstPort() uint16
5250}
5251
5252func (self *BsnTlvHashGtpPortMatch) GetMatch() BsnHashGtpPortMatch {
5253 return self.Match
5254}
5255
5256func (self *BsnTlvHashGtpPortMatch) SetMatch(v BsnHashGtpPortMatch) {
5257 self.Match = v
5258}
5259
5260func (self *BsnTlvHashGtpPortMatch) GetSrcPort() uint16 {
5261 return self.SrcPort
5262}
5263
5264func (self *BsnTlvHashGtpPortMatch) SetSrcPort(v uint16) {
5265 self.SrcPort = v
5266}
5267
5268func (self *BsnTlvHashGtpPortMatch) GetDstPort() uint16 {
5269 return self.DstPort
5270}
5271
5272func (self *BsnTlvHashGtpPortMatch) SetDstPort(v uint16) {
5273 self.DstPort = v
5274}
5275
5276func (self *BsnTlvHashGtpPortMatch) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5277 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5278 if err := self.BsnTlv.Serialize(encoder); err != nil {
5279 return err
5280 }
5281
5282 encoder.PutUint8(uint8(self.Match))
5283 encoder.PutUint16(uint16(self.SrcPort))
5284 encoder.PutUint16(uint16(self.DstPort))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5285 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5286
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5287 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5288
5289 return nil
5290}
5291
5292func DecodeBsnTlvHashGtpPortMatch(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHashGtpPortMatch, error) {
5293 _bsntlvhashgtpportmatch := &BsnTlvHashGtpPortMatch{BsnTlv: parent}
5294 if decoder.Length() < 5 {
5295 return nil, fmt.Errorf("BsnTlvHashGtpPortMatch packet too short: %d < 5", decoder.Length())
5296 }
5297 _bsntlvhashgtpportmatch.Match = BsnHashGtpPortMatch(decoder.ReadByte())
5298 _bsntlvhashgtpportmatch.SrcPort = uint16(decoder.ReadUint16())
5299 _bsntlvhashgtpportmatch.DstPort = uint16(decoder.ReadUint16())
5300 return _bsntlvhashgtpportmatch, nil
5301}
5302
5303func NewBsnTlvHashGtpPortMatch() *BsnTlvHashGtpPortMatch {
5304 obj := &BsnTlvHashGtpPortMatch{
5305 BsnTlv: NewBsnTlv(105),
5306 }
5307 return obj
5308}
5309
5310type BsnTlvHashPacketField struct {
5311 *BsnTlv
5312 Value BsnHashPacketField
5313}
5314
5315type IBsnTlvHashPacketField interface {
5316 IBsnTlv
5317 GetValue() BsnHashPacketField
5318}
5319
5320func (self *BsnTlvHashPacketField) GetValue() BsnHashPacketField {
5321 return self.Value
5322}
5323
5324func (self *BsnTlvHashPacketField) SetValue(v BsnHashPacketField) {
5325 self.Value = v
5326}
5327
5328func (self *BsnTlvHashPacketField) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5329 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5330 if err := self.BsnTlv.Serialize(encoder); err != nil {
5331 return err
5332 }
5333
5334 encoder.PutUint64(uint64(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5335 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5336
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5337 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5338
5339 return nil
5340}
5341
5342func DecodeBsnTlvHashPacketField(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHashPacketField, error) {
5343 _bsntlvhashpacketfield := &BsnTlvHashPacketField{BsnTlv: parent}
5344 if decoder.Length() < 8 {
5345 return nil, fmt.Errorf("BsnTlvHashPacketField packet too short: %d < 8", decoder.Length())
5346 }
5347 _bsntlvhashpacketfield.Value = BsnHashPacketField(decoder.ReadUint64())
5348 return _bsntlvhashpacketfield, nil
5349}
5350
5351func NewBsnTlvHashPacketField() *BsnTlvHashPacketField {
5352 obj := &BsnTlvHashPacketField{
5353 BsnTlv: NewBsnTlv(103),
5354 }
5355 return obj
5356}
5357
5358type BsnTlvHashPacketType struct {
5359 *BsnTlv
5360 Value BsnHashPacketType
5361}
5362
5363type IBsnTlvHashPacketType interface {
5364 IBsnTlv
5365 GetValue() BsnHashPacketType
5366}
5367
5368func (self *BsnTlvHashPacketType) GetValue() BsnHashPacketType {
5369 return self.Value
5370}
5371
5372func (self *BsnTlvHashPacketType) SetValue(v BsnHashPacketType) {
5373 self.Value = v
5374}
5375
5376func (self *BsnTlvHashPacketType) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5377 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5378 if err := self.BsnTlv.Serialize(encoder); err != nil {
5379 return err
5380 }
5381
5382 encoder.PutUint8(uint8(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5383 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5384
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5385 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5386
5387 return nil
5388}
5389
5390func DecodeBsnTlvHashPacketType(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHashPacketType, error) {
5391 _bsntlvhashpackettype := &BsnTlvHashPacketType{BsnTlv: parent}
5392 if decoder.Length() < 1 {
5393 return nil, fmt.Errorf("BsnTlvHashPacketType packet too short: %d < 1", decoder.Length())
5394 }
5395 _bsntlvhashpackettype.Value = BsnHashPacketType(decoder.ReadByte())
5396 return _bsntlvhashpackettype, nil
5397}
5398
5399func NewBsnTlvHashPacketType() *BsnTlvHashPacketType {
5400 obj := &BsnTlvHashPacketType{
5401 BsnTlv: NewBsnTlv(102),
5402 }
5403 return obj
5404}
5405
5406type BsnTlvHashSeed struct {
5407 *BsnTlv
5408 Seed1 uint32
5409 Seed2 uint32
5410}
5411
5412type IBsnTlvHashSeed interface {
5413 IBsnTlv
5414 GetSeed1() uint32
5415 GetSeed2() uint32
5416}
5417
5418func (self *BsnTlvHashSeed) GetSeed1() uint32 {
5419 return self.Seed1
5420}
5421
5422func (self *BsnTlvHashSeed) SetSeed1(v uint32) {
5423 self.Seed1 = v
5424}
5425
5426func (self *BsnTlvHashSeed) GetSeed2() uint32 {
5427 return self.Seed2
5428}
5429
5430func (self *BsnTlvHashSeed) SetSeed2(v uint32) {
5431 self.Seed2 = v
5432}
5433
5434func (self *BsnTlvHashSeed) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5435 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5436 if err := self.BsnTlv.Serialize(encoder); err != nil {
5437 return err
5438 }
5439
5440 encoder.PutUint32(uint32(self.Seed1))
5441 encoder.PutUint32(uint32(self.Seed2))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5442 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5443
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5444 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5445
5446 return nil
5447}
5448
5449func DecodeBsnTlvHashSeed(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHashSeed, error) {
5450 _bsntlvhashseed := &BsnTlvHashSeed{BsnTlv: parent}
5451 if decoder.Length() < 8 {
5452 return nil, fmt.Errorf("BsnTlvHashSeed packet too short: %d < 8", decoder.Length())
5453 }
5454 _bsntlvhashseed.Seed1 = uint32(decoder.ReadUint32())
5455 _bsntlvhashseed.Seed2 = uint32(decoder.ReadUint32())
5456 return _bsntlvhashseed, nil
5457}
5458
5459func NewBsnTlvHashSeed() *BsnTlvHashSeed {
5460 obj := &BsnTlvHashSeed{
5461 BsnTlv: NewBsnTlv(100),
5462 }
5463 return obj
5464}
5465
5466type BsnTlvHashType struct {
5467 *BsnTlv
5468 Value BsnHashType
5469}
5470
5471type IBsnTlvHashType interface {
5472 IBsnTlv
5473 GetValue() BsnHashType
5474}
5475
5476func (self *BsnTlvHashType) GetValue() BsnHashType {
5477 return self.Value
5478}
5479
5480func (self *BsnTlvHashType) SetValue(v BsnHashType) {
5481 self.Value = v
5482}
5483
5484func (self *BsnTlvHashType) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5485 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5486 if err := self.BsnTlv.Serialize(encoder); err != nil {
5487 return err
5488 }
5489
5490 encoder.PutUint8(uint8(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5491 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5492
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5493 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5494
5495 return nil
5496}
5497
5498func DecodeBsnTlvHashType(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHashType, error) {
5499 _bsntlvhashtype := &BsnTlvHashType{BsnTlv: parent}
5500 if decoder.Length() < 1 {
5501 return nil, fmt.Errorf("BsnTlvHashType packet too short: %d < 1", decoder.Length())
5502 }
5503 _bsntlvhashtype.Value = BsnHashType(decoder.ReadByte())
5504 return _bsntlvhashtype, nil
5505}
5506
5507func NewBsnTlvHashType() *BsnTlvHashType {
5508 obj := &BsnTlvHashType{
5509 BsnTlv: NewBsnTlv(101),
5510 }
5511 return obj
5512}
5513
5514type BsnTlvHeaderSize struct {
5515 *BsnTlv
5516 Value uint32
5517}
5518
5519type IBsnTlvHeaderSize interface {
5520 IBsnTlv
5521 GetValue() uint32
5522}
5523
5524func (self *BsnTlvHeaderSize) GetValue() uint32 {
5525 return self.Value
5526}
5527
5528func (self *BsnTlvHeaderSize) SetValue(v uint32) {
5529 self.Value = v
5530}
5531
5532func (self *BsnTlvHeaderSize) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5533 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5534 if err := self.BsnTlv.Serialize(encoder); err != nil {
5535 return err
5536 }
5537
5538 encoder.PutUint32(uint32(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5539 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5540
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5541 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5542
5543 return nil
5544}
5545
5546func DecodeBsnTlvHeaderSize(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHeaderSize, error) {
5547 _bsntlvheadersize := &BsnTlvHeaderSize{BsnTlv: parent}
5548 if decoder.Length() < 4 {
5549 return nil, fmt.Errorf("BsnTlvHeaderSize packet too short: %d < 4", decoder.Length())
5550 }
5551 _bsntlvheadersize.Value = uint32(decoder.ReadUint32())
5552 return _bsntlvheadersize, nil
5553}
5554
5555func NewBsnTlvHeaderSize() *BsnTlvHeaderSize {
5556 obj := &BsnTlvHeaderSize{
5557 BsnTlv: NewBsnTlv(31),
5558 }
5559 return obj
5560}
5561
5562type BsnTlvIcmpCode struct {
5563 *BsnTlv
5564 Value uint8
5565}
5566
5567type IBsnTlvIcmpCode interface {
5568 IBsnTlv
5569 GetValue() uint8
5570}
5571
5572func (self *BsnTlvIcmpCode) GetValue() uint8 {
5573 return self.Value
5574}
5575
5576func (self *BsnTlvIcmpCode) SetValue(v uint8) {
5577 self.Value = v
5578}
5579
5580func (self *BsnTlvIcmpCode) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5581 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5582 if err := self.BsnTlv.Serialize(encoder); err != nil {
5583 return err
5584 }
5585
5586 encoder.PutUint8(uint8(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5587 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5588
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5589 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5590
5591 return nil
5592}
5593
5594func DecodeBsnTlvIcmpCode(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIcmpCode, error) {
5595 _bsntlvicmpcode := &BsnTlvIcmpCode{BsnTlv: parent}
5596 if decoder.Length() < 1 {
5597 return nil, fmt.Errorf("BsnTlvIcmpCode packet too short: %d < 1", decoder.Length())
5598 }
5599 _bsntlvicmpcode.Value = uint8(decoder.ReadByte())
5600 return _bsntlvicmpcode, nil
5601}
5602
5603func NewBsnTlvIcmpCode() *BsnTlvIcmpCode {
5604 obj := &BsnTlvIcmpCode{
5605 BsnTlv: NewBsnTlv(69),
5606 }
5607 return obj
5608}
5609
5610type BsnTlvIcmpId struct {
5611 *BsnTlv
5612 Value uint16
5613}
5614
5615type IBsnTlvIcmpId interface {
5616 IBsnTlv
5617 GetValue() uint16
5618}
5619
5620func (self *BsnTlvIcmpId) GetValue() uint16 {
5621 return self.Value
5622}
5623
5624func (self *BsnTlvIcmpId) SetValue(v uint16) {
5625 self.Value = v
5626}
5627
5628func (self *BsnTlvIcmpId) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5629 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5630 if err := self.BsnTlv.Serialize(encoder); err != nil {
5631 return err
5632 }
5633
5634 encoder.PutUint16(uint16(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5635 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5636
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5637 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5638
5639 return nil
5640}
5641
5642func DecodeBsnTlvIcmpId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIcmpId, error) {
5643 _bsntlvicmpid := &BsnTlvIcmpId{BsnTlv: parent}
5644 if decoder.Length() < 2 {
5645 return nil, fmt.Errorf("BsnTlvIcmpId packet too short: %d < 2", decoder.Length())
5646 }
5647 _bsntlvicmpid.Value = uint16(decoder.ReadUint16())
5648 return _bsntlvicmpid, nil
5649}
5650
5651func NewBsnTlvIcmpId() *BsnTlvIcmpId {
5652 obj := &BsnTlvIcmpId{
5653 BsnTlv: NewBsnTlv(70),
5654 }
5655 return obj
5656}
5657
5658type BsnTlvIcmpType struct {
5659 *BsnTlv
5660 Value uint8
5661}
5662
5663type IBsnTlvIcmpType interface {
5664 IBsnTlv
5665 GetValue() uint8
5666}
5667
5668func (self *BsnTlvIcmpType) GetValue() uint8 {
5669 return self.Value
5670}
5671
5672func (self *BsnTlvIcmpType) SetValue(v uint8) {
5673 self.Value = v
5674}
5675
5676func (self *BsnTlvIcmpType) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5677 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5678 if err := self.BsnTlv.Serialize(encoder); err != nil {
5679 return err
5680 }
5681
5682 encoder.PutUint8(uint8(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5683 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5684
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5685 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5686
5687 return nil
5688}
5689
5690func DecodeBsnTlvIcmpType(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIcmpType, error) {
5691 _bsntlvicmptype := &BsnTlvIcmpType{BsnTlv: parent}
5692 if decoder.Length() < 1 {
5693 return nil, fmt.Errorf("BsnTlvIcmpType packet too short: %d < 1", decoder.Length())
5694 }
5695 _bsntlvicmptype.Value = uint8(decoder.ReadByte())
5696 return _bsntlvicmptype, nil
5697}
5698
5699func NewBsnTlvIcmpType() *BsnTlvIcmpType {
5700 obj := &BsnTlvIcmpType{
5701 BsnTlv: NewBsnTlv(68),
5702 }
5703 return obj
5704}
5705
5706type BsnTlvIcmpv6Chksum struct {
5707 *BsnTlv
5708 Value uint16
5709}
5710
5711type IBsnTlvIcmpv6Chksum interface {
5712 IBsnTlv
5713 GetValue() uint16
5714}
5715
5716func (self *BsnTlvIcmpv6Chksum) GetValue() uint16 {
5717 return self.Value
5718}
5719
5720func (self *BsnTlvIcmpv6Chksum) SetValue(v uint16) {
5721 self.Value = v
5722}
5723
5724func (self *BsnTlvIcmpv6Chksum) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5725 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5726 if err := self.BsnTlv.Serialize(encoder); err != nil {
5727 return err
5728 }
5729
5730 encoder.PutUint16(uint16(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5731 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5732
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5733 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5734
5735 return nil
5736}
5737
5738func DecodeBsnTlvIcmpv6Chksum(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIcmpv6Chksum, error) {
5739 _bsntlvicmpv6chksum := &BsnTlvIcmpv6Chksum{BsnTlv: parent}
5740 if decoder.Length() < 2 {
5741 return nil, fmt.Errorf("BsnTlvIcmpv6Chksum packet too short: %d < 2", decoder.Length())
5742 }
5743 _bsntlvicmpv6chksum.Value = uint16(decoder.ReadUint16())
5744 return _bsntlvicmpv6chksum, nil
5745}
5746
5747func NewBsnTlvIcmpv6Chksum() *BsnTlvIcmpv6Chksum {
5748 obj := &BsnTlvIcmpv6Chksum{
5749 BsnTlv: NewBsnTlv(125),
5750 }
5751 return obj
5752}
5753
5754type BsnTlvIdentifier struct {
5755 *BsnTlv
5756 Value uint32
5757}
5758
5759type IBsnTlvIdentifier interface {
5760 IBsnTlv
5761 GetValue() uint32
5762}
5763
5764func (self *BsnTlvIdentifier) GetValue() uint32 {
5765 return self.Value
5766}
5767
5768func (self *BsnTlvIdentifier) SetValue(v uint32) {
5769 self.Value = v
5770}
5771
5772func (self *BsnTlvIdentifier) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5773 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5774 if err := self.BsnTlv.Serialize(encoder); err != nil {
5775 return err
5776 }
5777
5778 encoder.PutUint32(uint32(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5779 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5780
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5781 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5782
5783 return nil
5784}
5785
5786func DecodeBsnTlvIdentifier(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIdentifier, error) {
5787 _bsntlvidentifier := &BsnTlvIdentifier{BsnTlv: parent}
5788 if decoder.Length() < 4 {
5789 return nil, fmt.Errorf("BsnTlvIdentifier packet too short: %d < 4", decoder.Length())
5790 }
5791 _bsntlvidentifier.Value = uint32(decoder.ReadUint32())
5792 return _bsntlvidentifier, nil
5793}
5794
5795func NewBsnTlvIdentifier() *BsnTlvIdentifier {
5796 obj := &BsnTlvIdentifier{
5797 BsnTlv: NewBsnTlv(173),
5798 }
5799 return obj
5800}
5801
5802type BsnTlvIdleNotification struct {
5803 *BsnTlv
5804}
5805
5806type IBsnTlvIdleNotification interface {
5807 IBsnTlv
5808}
5809
5810func (self *BsnTlvIdleNotification) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5811 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5812 if err := self.BsnTlv.Serialize(encoder); err != nil {
5813 return err
5814 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5815 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5816
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5817 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5818
5819 return nil
5820}
5821
5822func DecodeBsnTlvIdleNotification(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIdleNotification, error) {
5823 _bsntlvidlenotification := &BsnTlvIdleNotification{BsnTlv: parent}
5824 return _bsntlvidlenotification, nil
5825}
5826
5827func NewBsnTlvIdleNotification() *BsnTlvIdleNotification {
5828 obj := &BsnTlvIdleNotification{
5829 BsnTlv: NewBsnTlv(7),
5830 }
5831 return obj
5832}
5833
5834type BsnTlvIdleTime struct {
5835 *BsnTlv
5836 Value uint64
5837}
5838
5839type IBsnTlvIdleTime interface {
5840 IBsnTlv
5841 GetValue() uint64
5842}
5843
5844func (self *BsnTlvIdleTime) GetValue() uint64 {
5845 return self.Value
5846}
5847
5848func (self *BsnTlvIdleTime) SetValue(v uint64) {
5849 self.Value = v
5850}
5851
5852func (self *BsnTlvIdleTime) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5853 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5854 if err := self.BsnTlv.Serialize(encoder); err != nil {
5855 return err
5856 }
5857
5858 encoder.PutUint64(uint64(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5859 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5860
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5861 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5862
5863 return nil
5864}
5865
5866func DecodeBsnTlvIdleTime(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIdleTime, error) {
5867 _bsntlvidletime := &BsnTlvIdleTime{BsnTlv: parent}
5868 if decoder.Length() < 8 {
5869 return nil, fmt.Errorf("BsnTlvIdleTime packet too short: %d < 8", decoder.Length())
5870 }
5871 _bsntlvidletime.Value = uint64(decoder.ReadUint64())
5872 return _bsntlvidletime, nil
5873}
5874
5875func NewBsnTlvIdleTime() *BsnTlvIdleTime {
5876 obj := &BsnTlvIdleTime{
5877 BsnTlv: NewBsnTlv(5),
5878 }
5879 return obj
5880}
5881
5882type BsnTlvIdleTimeout struct {
5883 *BsnTlv
5884 Value uint32
5885}
5886
5887type IBsnTlvIdleTimeout interface {
5888 IBsnTlv
5889 GetValue() uint32
5890}
5891
5892func (self *BsnTlvIdleTimeout) GetValue() uint32 {
5893 return self.Value
5894}
5895
5896func (self *BsnTlvIdleTimeout) SetValue(v uint32) {
5897 self.Value = v
5898}
5899
5900func (self *BsnTlvIdleTimeout) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5901 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5902 if err := self.BsnTlv.Serialize(encoder); err != nil {
5903 return err
5904 }
5905
5906 encoder.PutUint32(uint32(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5907 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5908
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5909 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5910
5911 return nil
5912}
5913
5914func DecodeBsnTlvIdleTimeout(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIdleTimeout, error) {
5915 _bsntlvidletimeout := &BsnTlvIdleTimeout{BsnTlv: parent}
5916 if decoder.Length() < 4 {
5917 return nil, fmt.Errorf("BsnTlvIdleTimeout packet too short: %d < 4", decoder.Length())
5918 }
5919 _bsntlvidletimeout.Value = uint32(decoder.ReadUint32())
5920 return _bsntlvidletimeout, nil
5921}
5922
5923func NewBsnTlvIdleTimeout() *BsnTlvIdleTimeout {
5924 obj := &BsnTlvIdleTimeout{
5925 BsnTlv: NewBsnTlv(8),
5926 }
5927 return obj
5928}
5929
5930type BsnTlvIgmpSnooping struct {
5931 *BsnTlv
5932}
5933
5934type IBsnTlvIgmpSnooping interface {
5935 IBsnTlv
5936}
5937
5938func (self *BsnTlvIgmpSnooping) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5939 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5940 if err := self.BsnTlv.Serialize(encoder); err != nil {
5941 return err
5942 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5943 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5944
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5945 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5946
5947 return nil
5948}
5949
5950func DecodeBsnTlvIgmpSnooping(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIgmpSnooping, error) {
5951 _bsntlvigmpsnooping := &BsnTlvIgmpSnooping{BsnTlv: parent}
5952 return _bsntlvigmpsnooping, nil
5953}
5954
5955func NewBsnTlvIgmpSnooping() *BsnTlvIgmpSnooping {
5956 obj := &BsnTlvIgmpSnooping{
5957 BsnTlv: NewBsnTlv(78),
5958 }
5959 return obj
5960}
5961
5962type BsnTlvIngressPortGroupId struct {
5963 *BsnTlv
5964 Value uint32
5965}
5966
5967type IBsnTlvIngressPortGroupId interface {
5968 IBsnTlv
5969 GetValue() uint32
5970}
5971
5972func (self *BsnTlvIngressPortGroupId) GetValue() uint32 {
5973 return self.Value
5974}
5975
5976func (self *BsnTlvIngressPortGroupId) SetValue(v uint32) {
5977 self.Value = v
5978}
5979
5980func (self *BsnTlvIngressPortGroupId) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5981 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5982 if err := self.BsnTlv.Serialize(encoder); err != nil {
5983 return err
5984 }
5985
5986 encoder.PutUint32(uint32(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5987 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5988
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]5989 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]5990
5991 return nil
5992}
5993
5994func DecodeBsnTlvIngressPortGroupId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIngressPortGroupId, error) {
5995 _bsntlvingressportgroupid := &BsnTlvIngressPortGroupId{BsnTlv: parent}
5996 if decoder.Length() < 4 {
5997 return nil, fmt.Errorf("BsnTlvIngressPortGroupId packet too short: %d < 4", decoder.Length())
5998 }
5999 _bsntlvingressportgroupid.Value = uint32(decoder.ReadUint32())
6000 return _bsntlvingressportgroupid, nil
6001}
6002
6003func NewBsnTlvIngressPortGroupId() *BsnTlvIngressPortGroupId {
6004 obj := &BsnTlvIngressPortGroupId{
6005 BsnTlv: NewBsnTlv(138),
6006 }
6007 return obj
6008}
6009
6010type BsnTlvInternalGatewayMac struct {
6011 *BsnTlv
6012 Value net.HardwareAddr
6013}
6014
6015type IBsnTlvInternalGatewayMac interface {
6016 IBsnTlv
6017 GetValue() net.HardwareAddr
6018}
6019
6020func (self *BsnTlvInternalGatewayMac) GetValue() net.HardwareAddr {
6021 return self.Value
6022}
6023
6024func (self *BsnTlvInternalGatewayMac) SetValue(v net.HardwareAddr) {
6025 self.Value = v
6026}
6027
6028func (self *BsnTlvInternalGatewayMac) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6029 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6030 if err := self.BsnTlv.Serialize(encoder); err != nil {
6031 return err
6032 }
6033
6034 encoder.Write(self.Value)
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6035 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6036
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6037 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6038
6039 return nil
6040}
6041
6042func DecodeBsnTlvInternalGatewayMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvInternalGatewayMac, error) {
6043 _bsntlvinternalgatewaymac := &BsnTlvInternalGatewayMac{BsnTlv: parent}
6044 if decoder.Length() < 6 {
6045 return nil, fmt.Errorf("BsnTlvInternalGatewayMac packet too short: %d < 6", decoder.Length())
6046 }
6047 _bsntlvinternalgatewaymac.Value = net.HardwareAddr(decoder.Read(6))
6048 return _bsntlvinternalgatewaymac, nil
6049}
6050
6051func NewBsnTlvInternalGatewayMac() *BsnTlvInternalGatewayMac {
6052 obj := &BsnTlvInternalGatewayMac{
6053 BsnTlv: NewBsnTlv(28),
6054 }
6055 return obj
6056}
6057
6058type BsnTlvInternalMac struct {
6059 *BsnTlv
6060 Value net.HardwareAddr
6061}
6062
6063type IBsnTlvInternalMac interface {
6064 IBsnTlv
6065 GetValue() net.HardwareAddr
6066}
6067
6068func (self *BsnTlvInternalMac) GetValue() net.HardwareAddr {
6069 return self.Value
6070}
6071
6072func (self *BsnTlvInternalMac) SetValue(v net.HardwareAddr) {
6073 self.Value = v
6074}
6075
6076func (self *BsnTlvInternalMac) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6077 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6078 if err := self.BsnTlv.Serialize(encoder); err != nil {
6079 return err
6080 }
6081
6082 encoder.Write(self.Value)
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6083 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6084
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6085 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6086
6087 return nil
6088}
6089
6090func DecodeBsnTlvInternalMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvInternalMac, error) {
6091 _bsntlvinternalmac := &BsnTlvInternalMac{BsnTlv: parent}
6092 if decoder.Length() < 6 {
6093 return nil, fmt.Errorf("BsnTlvInternalMac packet too short: %d < 6", decoder.Length())
6094 }
6095 _bsntlvinternalmac.Value = net.HardwareAddr(decoder.Read(6))
6096 return _bsntlvinternalmac, nil
6097}
6098
6099func NewBsnTlvInternalMac() *BsnTlvInternalMac {
6100 obj := &BsnTlvInternalMac{
6101 BsnTlv: NewBsnTlv(27),
6102 }
6103 return obj
6104}
6105
6106type BsnTlvInterval struct {
6107 *BsnTlv
6108 Value uint32
6109}
6110
6111type IBsnTlvInterval interface {
6112 IBsnTlv
6113 GetValue() uint32
6114}
6115
6116func (self *BsnTlvInterval) GetValue() uint32 {
6117 return self.Value
6118}
6119
6120func (self *BsnTlvInterval) SetValue(v uint32) {
6121 self.Value = v
6122}
6123
6124func (self *BsnTlvInterval) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6125 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6126 if err := self.BsnTlv.Serialize(encoder); err != nil {
6127 return err
6128 }
6129
6130 encoder.PutUint32(uint32(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6131 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6132
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6133 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6134
6135 return nil
6136}
6137
6138func DecodeBsnTlvInterval(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvInterval, error) {
6139 _bsntlvinterval := &BsnTlvInterval{BsnTlv: parent}
6140 if decoder.Length() < 4 {
6141 return nil, fmt.Errorf("BsnTlvInterval packet too short: %d < 4", decoder.Length())
6142 }
6143 _bsntlvinterval.Value = uint32(decoder.ReadUint32())
6144 return _bsntlvinterval, nil
6145}
6146
6147func NewBsnTlvInterval() *BsnTlvInterval {
6148 obj := &BsnTlvInterval{
6149 BsnTlv: NewBsnTlv(58),
6150 }
6151 return obj
6152}
6153
6154type BsnTlvIpProto struct {
6155 *BsnTlv
6156 Value uint8
6157}
6158
6159type IBsnTlvIpProto interface {
6160 IBsnTlv
6161 GetValue() uint8
6162}
6163
6164func (self *BsnTlvIpProto) GetValue() uint8 {
6165 return self.Value
6166}
6167
6168func (self *BsnTlvIpProto) SetValue(v uint8) {
6169 self.Value = v
6170}
6171
6172func (self *BsnTlvIpProto) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6173 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6174 if err := self.BsnTlv.Serialize(encoder); err != nil {
6175 return err
6176 }
6177
6178 encoder.PutUint8(uint8(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6179 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6180
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6181 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6182
6183 return nil
6184}
6185
6186func DecodeBsnTlvIpProto(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpProto, error) {
6187 _bsntlvipproto := &BsnTlvIpProto{BsnTlv: parent}
6188 if decoder.Length() < 1 {
6189 return nil, fmt.Errorf("BsnTlvIpProto packet too short: %d < 1", decoder.Length())
6190 }
6191 _bsntlvipproto.Value = uint8(decoder.ReadByte())
6192 return _bsntlvipproto, nil
6193}
6194
6195func NewBsnTlvIpProto() *BsnTlvIpProto {
6196 obj := &BsnTlvIpProto{
6197 BsnTlv: NewBsnTlv(67),
6198 }
6199 return obj
6200}
6201
6202type BsnTlvIpTunnelType struct {
6203 *BsnTlv
6204 Value BsnIpTunnelType
6205}
6206
6207type IBsnTlvIpTunnelType interface {
6208 IBsnTlv
6209 GetValue() BsnIpTunnelType
6210}
6211
6212func (self *BsnTlvIpTunnelType) GetValue() BsnIpTunnelType {
6213 return self.Value
6214}
6215
6216func (self *BsnTlvIpTunnelType) SetValue(v BsnIpTunnelType) {
6217 self.Value = v
6218}
6219
6220func (self *BsnTlvIpTunnelType) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6221 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6222 if err := self.BsnTlv.Serialize(encoder); err != nil {
6223 return err
6224 }
6225
6226 encoder.PutUint16(uint16(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6227 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6228
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6229 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6230
6231 return nil
6232}
6233
6234func DecodeBsnTlvIpTunnelType(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpTunnelType, error) {
6235 _bsntlviptunneltype := &BsnTlvIpTunnelType{BsnTlv: parent}
6236 if decoder.Length() < 2 {
6237 return nil, fmt.Errorf("BsnTlvIpTunnelType packet too short: %d < 2", decoder.Length())
6238 }
6239 _bsntlviptunneltype.Value = BsnIpTunnelType(decoder.ReadUint16())
6240 return _bsntlviptunneltype, nil
6241}
6242
6243func NewBsnTlvIpTunnelType() *BsnTlvIpTunnelType {
6244 obj := &BsnTlvIpTunnelType{
6245 BsnTlv: NewBsnTlv(169),
6246 }
6247 return obj
6248}
6249
6250type BsnTlvIpv4 struct {
6251 *BsnTlv
6252 Value net.IP
6253}
6254
6255type IBsnTlvIpv4 interface {
6256 IBsnTlv
6257 GetValue() net.IP
6258}
6259
6260func (self *BsnTlvIpv4) GetValue() net.IP {
6261 return self.Value
6262}
6263
6264func (self *BsnTlvIpv4) SetValue(v net.IP) {
6265 self.Value = v
6266}
6267
6268func (self *BsnTlvIpv4) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6269 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6270 if err := self.BsnTlv.Serialize(encoder); err != nil {
6271 return err
6272 }
6273
6274 encoder.Write(self.Value.To4())
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6275 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6276
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6277 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6278
6279 return nil
6280}
6281
6282func DecodeBsnTlvIpv4(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv4, error) {
6283 _bsntlvipv4 := &BsnTlvIpv4{BsnTlv: parent}
6284 if decoder.Length() < 4 {
6285 return nil, fmt.Errorf("BsnTlvIpv4 packet too short: %d < 4", decoder.Length())
6286 }
6287 _bsntlvipv4.Value = net.IP(decoder.Read(4))
6288 return _bsntlvipv4, nil
6289}
6290
6291func NewBsnTlvIpv4() *BsnTlvIpv4 {
6292 obj := &BsnTlvIpv4{
6293 BsnTlv: NewBsnTlv(4),
6294 }
6295 return obj
6296}
6297
6298type BsnTlvIpv4Dst struct {
6299 *BsnTlv
6300 Value net.IP
6301}
6302
6303type IBsnTlvIpv4Dst interface {
6304 IBsnTlv
6305 GetValue() net.IP
6306}
6307
6308func (self *BsnTlvIpv4Dst) GetValue() net.IP {
6309 return self.Value
6310}
6311
6312func (self *BsnTlvIpv4Dst) SetValue(v net.IP) {
6313 self.Value = v
6314}
6315
6316func (self *BsnTlvIpv4Dst) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6317 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6318 if err := self.BsnTlv.Serialize(encoder); err != nil {
6319 return err
6320 }
6321
6322 encoder.Write(self.Value.To4())
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6323 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6324
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6325 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6326
6327 return nil
6328}
6329
6330func DecodeBsnTlvIpv4Dst(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv4Dst, error) {
6331 _bsntlvipv4dst := &BsnTlvIpv4Dst{BsnTlv: parent}
6332 if decoder.Length() < 4 {
6333 return nil, fmt.Errorf("BsnTlvIpv4Dst packet too short: %d < 4", decoder.Length())
6334 }
6335 _bsntlvipv4dst.Value = net.IP(decoder.Read(4))
6336 return _bsntlvipv4dst, nil
6337}
6338
6339func NewBsnTlvIpv4Dst() *BsnTlvIpv4Dst {
6340 obj := &BsnTlvIpv4Dst{
6341 BsnTlv: NewBsnTlv(35),
6342 }
6343 return obj
6344}
6345
6346type BsnTlvIpv4Netmask struct {
6347 *BsnTlv
6348 Value net.IP
6349}
6350
6351type IBsnTlvIpv4Netmask interface {
6352 IBsnTlv
6353 GetValue() net.IP
6354}
6355
6356func (self *BsnTlvIpv4Netmask) GetValue() net.IP {
6357 return self.Value
6358}
6359
6360func (self *BsnTlvIpv4Netmask) SetValue(v net.IP) {
6361 self.Value = v
6362}
6363
6364func (self *BsnTlvIpv4Netmask) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6365 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6366 if err := self.BsnTlv.Serialize(encoder); err != nil {
6367 return err
6368 }
6369
6370 encoder.Write(self.Value.To4())
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6371 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6372
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6373 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6374
6375 return nil
6376}
6377
6378func DecodeBsnTlvIpv4Netmask(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv4Netmask, error) {
6379 _bsntlvipv4netmask := &BsnTlvIpv4Netmask{BsnTlv: parent}
6380 if decoder.Length() < 4 {
6381 return nil, fmt.Errorf("BsnTlvIpv4Netmask packet too short: %d < 4", decoder.Length())
6382 }
6383 _bsntlvipv4netmask.Value = net.IP(decoder.Read(4))
6384 return _bsntlvipv4netmask, nil
6385}
6386
6387func NewBsnTlvIpv4Netmask() *BsnTlvIpv4Netmask {
6388 obj := &BsnTlvIpv4Netmask{
6389 BsnTlv: NewBsnTlv(60),
6390 }
6391 return obj
6392}
6393
6394type BsnTlvIpv4Src struct {
6395 *BsnTlv
6396 Value net.IP
6397}
6398
6399type IBsnTlvIpv4Src interface {
6400 IBsnTlv
6401 GetValue() net.IP
6402}
6403
6404func (self *BsnTlvIpv4Src) GetValue() net.IP {
6405 return self.Value
6406}
6407
6408func (self *BsnTlvIpv4Src) SetValue(v net.IP) {
6409 self.Value = v
6410}
6411
6412func (self *BsnTlvIpv4Src) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6413 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6414 if err := self.BsnTlv.Serialize(encoder); err != nil {
6415 return err
6416 }
6417
6418 encoder.Write(self.Value.To4())
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6419 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6420
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6421 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6422
6423 return nil
6424}
6425
6426func DecodeBsnTlvIpv4Src(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv4Src, error) {
6427 _bsntlvipv4src := &BsnTlvIpv4Src{BsnTlv: parent}
6428 if decoder.Length() < 4 {
6429 return nil, fmt.Errorf("BsnTlvIpv4Src packet too short: %d < 4", decoder.Length())
6430 }
6431 _bsntlvipv4src.Value = net.IP(decoder.Read(4))
6432 return _bsntlvipv4src, nil
6433}
6434
6435func NewBsnTlvIpv4Src() *BsnTlvIpv4Src {
6436 obj := &BsnTlvIpv4Src{
6437 BsnTlv: NewBsnTlv(34),
6438 }
6439 return obj
6440}
6441
6442type BsnTlvIpv6 struct {
6443 *BsnTlv
6444 Value net.IP
6445}
6446
6447type IBsnTlvIpv6 interface {
6448 IBsnTlv
6449 GetValue() net.IP
6450}
6451
6452func (self *BsnTlvIpv6) GetValue() net.IP {
6453 return self.Value
6454}
6455
6456func (self *BsnTlvIpv6) SetValue(v net.IP) {
6457 self.Value = v
6458}
6459
6460func (self *BsnTlvIpv6) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6461 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6462 if err := self.BsnTlv.Serialize(encoder); err != nil {
6463 return err
6464 }
6465
6466 encoder.Write(self.Value.To16())
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6467 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6468
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6469 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6470
6471 return nil
6472}
6473
6474func DecodeBsnTlvIpv6(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv6, error) {
6475 _bsntlvipv6 := &BsnTlvIpv6{BsnTlv: parent}
6476 if decoder.Length() < 16 {
6477 return nil, fmt.Errorf("BsnTlvIpv6 packet too short: %d < 16", decoder.Length())
6478 }
6479 _bsntlvipv6.Value = net.IP(decoder.Read(16))
6480 return _bsntlvipv6, nil
6481}
6482
6483func NewBsnTlvIpv6() *BsnTlvIpv6 {
6484 obj := &BsnTlvIpv6{
6485 BsnTlv: NewBsnTlv(84),
6486 }
6487 return obj
6488}
6489
6490type BsnTlvIpv6Dst struct {
6491 *BsnTlv
6492 Value net.IP
6493}
6494
6495type IBsnTlvIpv6Dst interface {
6496 IBsnTlv
6497 GetValue() net.IP
6498}
6499
6500func (self *BsnTlvIpv6Dst) GetValue() net.IP {
6501 return self.Value
6502}
6503
6504func (self *BsnTlvIpv6Dst) SetValue(v net.IP) {
6505 self.Value = v
6506}
6507
6508func (self *BsnTlvIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6509 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6510 if err := self.BsnTlv.Serialize(encoder); err != nil {
6511 return err
6512 }
6513
6514 encoder.Write(self.Value.To16())
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6515 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6516
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6517 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6518
6519 return nil
6520}
6521
6522func DecodeBsnTlvIpv6Dst(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv6Dst, error) {
6523 _bsntlvipv6dst := &BsnTlvIpv6Dst{BsnTlv: parent}
6524 if decoder.Length() < 16 {
6525 return nil, fmt.Errorf("BsnTlvIpv6Dst packet too short: %d < 16", decoder.Length())
6526 }
6527 _bsntlvipv6dst.Value = net.IP(decoder.Read(16))
6528 return _bsntlvipv6dst, nil
6529}
6530
6531func NewBsnTlvIpv6Dst() *BsnTlvIpv6Dst {
6532 obj := &BsnTlvIpv6Dst{
6533 BsnTlv: NewBsnTlv(127),
6534 }
6535 return obj
6536}
6537
6538type BsnTlvIpv6Prefix struct {
6539 *BsnTlv
6540 Value net.IP
6541 PrefixLength uint8
6542}
6543
6544type IBsnTlvIpv6Prefix interface {
6545 IBsnTlv
6546 GetValue() net.IP
6547 GetPrefixLength() uint8
6548}
6549
6550func (self *BsnTlvIpv6Prefix) GetValue() net.IP {
6551 return self.Value
6552}
6553
6554func (self *BsnTlvIpv6Prefix) SetValue(v net.IP) {
6555 self.Value = v
6556}
6557
6558func (self *BsnTlvIpv6Prefix) GetPrefixLength() uint8 {
6559 return self.PrefixLength
6560}
6561
6562func (self *BsnTlvIpv6Prefix) SetPrefixLength(v uint8) {
6563 self.PrefixLength = v
6564}
6565
6566func (self *BsnTlvIpv6Prefix) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6567 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6568 if err := self.BsnTlv.Serialize(encoder); err != nil {
6569 return err
6570 }
6571
6572 encoder.Write(self.Value.To16())
6573 encoder.PutUint8(uint8(self.PrefixLength))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6574 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6575
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6576 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6577
6578 return nil
6579}
6580
6581func DecodeBsnTlvIpv6Prefix(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv6Prefix, error) {
6582 _bsntlvipv6prefix := &BsnTlvIpv6Prefix{BsnTlv: parent}
6583 if decoder.Length() < 17 {
6584 return nil, fmt.Errorf("BsnTlvIpv6Prefix packet too short: %d < 17", decoder.Length())
6585 }
6586 _bsntlvipv6prefix.Value = net.IP(decoder.Read(16))
6587 _bsntlvipv6prefix.PrefixLength = uint8(decoder.ReadByte())
6588 return _bsntlvipv6prefix, nil
6589}
6590
6591func NewBsnTlvIpv6Prefix() *BsnTlvIpv6Prefix {
6592 obj := &BsnTlvIpv6Prefix{
6593 BsnTlv: NewBsnTlv(122),
6594 }
6595 return obj
6596}
6597
6598type BsnTlvIpv6Src struct {
6599 *BsnTlv
6600 Value net.IP
6601}
6602
6603type IBsnTlvIpv6Src interface {
6604 IBsnTlv
6605 GetValue() net.IP
6606}
6607
6608func (self *BsnTlvIpv6Src) GetValue() net.IP {
6609 return self.Value
6610}
6611
6612func (self *BsnTlvIpv6Src) SetValue(v net.IP) {
6613 self.Value = v
6614}
6615
6616func (self *BsnTlvIpv6Src) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6617 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6618 if err := self.BsnTlv.Serialize(encoder); err != nil {
6619 return err
6620 }
6621
6622 encoder.Write(self.Value.To16())
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6623 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6624
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6625 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6626
6627 return nil
6628}
6629
6630func DecodeBsnTlvIpv6Src(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv6Src, error) {
6631 _bsntlvipv6src := &BsnTlvIpv6Src{BsnTlv: parent}
6632 if decoder.Length() < 16 {
6633 return nil, fmt.Errorf("BsnTlvIpv6Src packet too short: %d < 16", decoder.Length())
6634 }
6635 _bsntlvipv6src.Value = net.IP(decoder.Read(16))
6636 return _bsntlvipv6src, nil
6637}
6638
6639func NewBsnTlvIpv6Src() *BsnTlvIpv6Src {
6640 obj := &BsnTlvIpv6Src{
6641 BsnTlv: NewBsnTlv(126),
6642 }
6643 return obj
6644}
6645
6646type BsnTlvKnownMulticastRate struct {
6647 *BsnTlv
6648 Value uint32
6649}
6650
6651type IBsnTlvKnownMulticastRate interface {
6652 IBsnTlv
6653 GetValue() uint32
6654}
6655
6656func (self *BsnTlvKnownMulticastRate) GetValue() uint32 {
6657 return self.Value
6658}
6659
6660func (self *BsnTlvKnownMulticastRate) SetValue(v uint32) {
6661 self.Value = v
6662}
6663
6664func (self *BsnTlvKnownMulticastRate) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6665 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6666 if err := self.BsnTlv.Serialize(encoder); err != nil {
6667 return err
6668 }
6669
6670 encoder.PutUint32(uint32(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6671 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6672
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6673 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6674
6675 return nil
6676}
6677
6678func DecodeBsnTlvKnownMulticastRate(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvKnownMulticastRate, error) {
6679 _bsntlvknownmulticastrate := &BsnTlvKnownMulticastRate{BsnTlv: parent}
6680 if decoder.Length() < 4 {
6681 return nil, fmt.Errorf("BsnTlvKnownMulticastRate packet too short: %d < 4", decoder.Length())
6682 }
6683 _bsntlvknownmulticastrate.Value = uint32(decoder.ReadUint32())
6684 return _bsntlvknownmulticastrate, nil
6685}
6686
6687func NewBsnTlvKnownMulticastRate() *BsnTlvKnownMulticastRate {
6688 obj := &BsnTlvKnownMulticastRate{
6689 BsnTlv: NewBsnTlv(91),
6690 }
6691 return obj
6692}
6693
6694type BsnTlvL2MulticastLookup struct {
6695 *BsnTlv
6696}
6697
6698type IBsnTlvL2MulticastLookup interface {
6699 IBsnTlv
6700}
6701
6702func (self *BsnTlvL2MulticastLookup) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6703 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6704 if err := self.BsnTlv.Serialize(encoder); err != nil {
6705 return err
6706 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6707 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6708
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6709 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6710
6711 return nil
6712}
6713
6714func DecodeBsnTlvL2MulticastLookup(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvL2MulticastLookup, error) {
6715 _bsntlvl2multicastlookup := &BsnTlvL2MulticastLookup{BsnTlv: parent}
6716 return _bsntlvl2multicastlookup, nil
6717}
6718
6719func NewBsnTlvL2MulticastLookup() *BsnTlvL2MulticastLookup {
6720 obj := &BsnTlvL2MulticastLookup{
6721 BsnTlv: NewBsnTlv(79),
6722 }
6723 return obj
6724}
6725
6726type BsnTlvL3 struct {
6727 *BsnTlv
6728}
6729
6730type IBsnTlvL3 interface {
6731 IBsnTlv
6732}
6733
6734func (self *BsnTlvL3) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6735 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6736 if err := self.BsnTlv.Serialize(encoder); err != nil {
6737 return err
6738 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6739 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6740
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6741 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6742
6743 return nil
6744}
6745
6746func DecodeBsnTlvL3(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvL3, error) {
6747 _bsntlvl3 := &BsnTlvL3{BsnTlv: parent}
6748 return _bsntlvl3, nil
6749}
6750
6751func NewBsnTlvL3() *BsnTlvL3 {
6752 obj := &BsnTlvL3{
6753 BsnTlv: NewBsnTlv(168),
6754 }
6755 return obj
6756}
6757
6758type BsnTlvL3DstClassId struct {
6759 *BsnTlv
6760 Value uint32
6761}
6762
6763type IBsnTlvL3DstClassId interface {
6764 IBsnTlv
6765 GetValue() uint32
6766}
6767
6768func (self *BsnTlvL3DstClassId) GetValue() uint32 {
6769 return self.Value
6770}
6771
6772func (self *BsnTlvL3DstClassId) SetValue(v uint32) {
6773 self.Value = v
6774}
6775
6776func (self *BsnTlvL3DstClassId) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6777 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6778 if err := self.BsnTlv.Serialize(encoder); err != nil {
6779 return err
6780 }
6781
6782 encoder.PutUint32(uint32(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6783 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6784
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6785 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6786
6787 return nil
6788}
6789
6790func DecodeBsnTlvL3DstClassId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvL3DstClassId, error) {
6791 _bsntlvl3dstclassid := &BsnTlvL3DstClassId{BsnTlv: parent}
6792 if decoder.Length() < 4 {
6793 return nil, fmt.Errorf("BsnTlvL3DstClassId packet too short: %d < 4", decoder.Length())
6794 }
6795 _bsntlvl3dstclassid.Value = uint32(decoder.ReadUint32())
6796 return _bsntlvl3dstclassid, nil
6797}
6798
6799func NewBsnTlvL3DstClassId() *BsnTlvL3DstClassId {
6800 obj := &BsnTlvL3DstClassId{
6801 BsnTlv: NewBsnTlv(136),
6802 }
6803 return obj
6804}
6805
6806type BsnTlvL3InterfaceClassId struct {
6807 *BsnTlv
6808 Value uint32
6809}
6810
6811type IBsnTlvL3InterfaceClassId interface {
6812 IBsnTlv
6813 GetValue() uint32
6814}
6815
6816func (self *BsnTlvL3InterfaceClassId) GetValue() uint32 {
6817 return self.Value
6818}
6819
6820func (self *BsnTlvL3InterfaceClassId) SetValue(v uint32) {
6821 self.Value = v
6822}
6823
6824func (self *BsnTlvL3InterfaceClassId) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6825 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6826 if err := self.BsnTlv.Serialize(encoder); err != nil {
6827 return err
6828 }
6829
6830 encoder.PutUint32(uint32(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6831 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6832
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6833 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6834
6835 return nil
6836}
6837
6838func DecodeBsnTlvL3InterfaceClassId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvL3InterfaceClassId, error) {
6839 _bsntlvl3interfaceclassid := &BsnTlvL3InterfaceClassId{BsnTlv: parent}
6840 if decoder.Length() < 4 {
6841 return nil, fmt.Errorf("BsnTlvL3InterfaceClassId packet too short: %d < 4", decoder.Length())
6842 }
6843 _bsntlvl3interfaceclassid.Value = uint32(decoder.ReadUint32())
6844 return _bsntlvl3interfaceclassid, nil
6845}
6846
6847func NewBsnTlvL3InterfaceClassId() *BsnTlvL3InterfaceClassId {
6848 obj := &BsnTlvL3InterfaceClassId{
6849 BsnTlv: NewBsnTlv(134),
6850 }
6851 return obj
6852}
6853
6854type BsnTlvL3SrcClassId struct {
6855 *BsnTlv
6856 Value uint32
6857}
6858
6859type IBsnTlvL3SrcClassId interface {
6860 IBsnTlv
6861 GetValue() uint32
6862}
6863
6864func (self *BsnTlvL3SrcClassId) GetValue() uint32 {
6865 return self.Value
6866}
6867
6868func (self *BsnTlvL3SrcClassId) SetValue(v uint32) {
6869 self.Value = v
6870}
6871
6872func (self *BsnTlvL3SrcClassId) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6873 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6874 if err := self.BsnTlv.Serialize(encoder); err != nil {
6875 return err
6876 }
6877
6878 encoder.PutUint32(uint32(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6879 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6880
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6881 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6882
6883 return nil
6884}
6885
6886func DecodeBsnTlvL3SrcClassId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvL3SrcClassId, error) {
6887 _bsntlvl3srcclassid := &BsnTlvL3SrcClassId{BsnTlv: parent}
6888 if decoder.Length() < 4 {
6889 return nil, fmt.Errorf("BsnTlvL3SrcClassId packet too short: %d < 4", decoder.Length())
6890 }
6891 _bsntlvl3srcclassid.Value = uint32(decoder.ReadUint32())
6892 return _bsntlvl3srcclassid, nil
6893}
6894
6895func NewBsnTlvL3SrcClassId() *BsnTlvL3SrcClassId {
6896 obj := &BsnTlvL3SrcClassId{
6897 BsnTlv: NewBsnTlv(135),
6898 }
6899 return obj
6900}
6901
6902type BsnTlvLagOptions struct {
6903 *BsnTlv
6904 Flags BsnLagFlag
6905}
6906
6907type IBsnTlvLagOptions interface {
6908 IBsnTlv
6909 GetFlags() BsnLagFlag
6910}
6911
6912func (self *BsnTlvLagOptions) GetFlags() BsnLagFlag {
6913 return self.Flags
6914}
6915
6916func (self *BsnTlvLagOptions) SetFlags(v BsnLagFlag) {
6917 self.Flags = v
6918}
6919
6920func (self *BsnTlvLagOptions) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6921 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6922 if err := self.BsnTlv.Serialize(encoder); err != nil {
6923 return err
6924 }
6925
6926 encoder.PutUint16(uint16(self.Flags))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6927 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6928
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6929 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6930
6931 return nil
6932}
6933
6934func DecodeBsnTlvLagOptions(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvLagOptions, error) {
6935 _bsntlvlagoptions := &BsnTlvLagOptions{BsnTlv: parent}
6936 if decoder.Length() < 2 {
6937 return nil, fmt.Errorf("BsnTlvLagOptions packet too short: %d < 2", decoder.Length())
6938 }
6939 _bsntlvlagoptions.Flags = BsnLagFlag(decoder.ReadUint16())
6940 return _bsntlvlagoptions, nil
6941}
6942
6943func NewBsnTlvLagOptions() *BsnTlvLagOptions {
6944 obj := &BsnTlvLagOptions{
6945 BsnTlv: NewBsnTlv(160),
6946 }
6947 return obj
6948}
6949
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]6950type BsnTlvLinkUp struct {
6951 *BsnTlv
6952}
6953
6954type IBsnTlvLinkUp interface {
6955 IBsnTlv
6956}
6957
6958func (self *BsnTlvLinkUp) Serialize(encoder *goloxi.Encoder) error {
6959 startIndex := len(encoder.Bytes())
6960 if err := self.BsnTlv.Serialize(encoder); err != nil {
6961 return err
6962 }
6963 length := len(encoder.Bytes()) - startIndex
6964
6965 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6966
6967 return nil
6968}
6969
6970func DecodeBsnTlvLinkUp(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvLinkUp, error) {
6971 _bsntlvlinkup := &BsnTlvLinkUp{BsnTlv: parent}
6972 return _bsntlvlinkup, nil
6973}
6974
6975func NewBsnTlvLinkUp() *BsnTlvLinkUp {
6976 obj := &BsnTlvLinkUp{
6977 BsnTlv: NewBsnTlv(193),
6978 }
6979 return obj
6980}
6981
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]6982type BsnTlvLoopbackMode struct {
6983 *BsnTlv
6984 Value BsnLoopbackMode
6985}
6986
6987type IBsnTlvLoopbackMode interface {
6988 IBsnTlv
6989 GetValue() BsnLoopbackMode
6990}
6991
6992func (self *BsnTlvLoopbackMode) GetValue() BsnLoopbackMode {
6993 return self.Value
6994}
6995
6996func (self *BsnTlvLoopbackMode) SetValue(v BsnLoopbackMode) {
6997 self.Value = v
6998}
6999
7000func (self *BsnTlvLoopbackMode) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7001 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7002 if err := self.BsnTlv.Serialize(encoder); err != nil {
7003 return err
7004 }
7005
7006 encoder.PutUint8(uint8(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7007 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7008
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7009 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7010
7011 return nil
7012}
7013
7014func DecodeBsnTlvLoopbackMode(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvLoopbackMode, error) {
7015 _bsntlvloopbackmode := &BsnTlvLoopbackMode{BsnTlv: parent}
7016 if decoder.Length() < 1 {
7017 return nil, fmt.Errorf("BsnTlvLoopbackMode packet too short: %d < 1", decoder.Length())
7018 }
7019 _bsntlvloopbackmode.Value = BsnLoopbackMode(decoder.ReadByte())
7020 return _bsntlvloopbackmode, nil
7021}
7022
7023func NewBsnTlvLoopbackMode() *BsnTlvLoopbackMode {
7024 obj := &BsnTlvLoopbackMode{
7025 BsnTlv: NewBsnTlv(146),
7026 }
7027 return obj
7028}
7029
7030type BsnTlvLoopbackPort struct {
7031 *BsnTlv
7032 Value Port
7033}
7034
7035type IBsnTlvLoopbackPort interface {
7036 IBsnTlv
7037 GetValue() Port
7038}
7039
7040func (self *BsnTlvLoopbackPort) GetValue() Port {
7041 return self.Value
7042}
7043
7044func (self *BsnTlvLoopbackPort) SetValue(v Port) {
7045 self.Value = v
7046}
7047
7048func (self *BsnTlvLoopbackPort) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7049 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7050 if err := self.BsnTlv.Serialize(encoder); err != nil {
7051 return err
7052 }
7053
7054 self.Value.Serialize(encoder)
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7055 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7056
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7057 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7058
7059 return nil
7060}
7061
7062func DecodeBsnTlvLoopbackPort(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvLoopbackPort, error) {
7063 _bsntlvloopbackport := &BsnTlvLoopbackPort{BsnTlv: parent}
7064 if decoder.Length() < 4 {
7065 return nil, fmt.Errorf("BsnTlvLoopbackPort packet too short: %d < 4", decoder.Length())
7066 }
7067 _bsntlvloopbackport.Value.Decode(decoder)
7068 return _bsntlvloopbackport, nil
7069}
7070
7071func NewBsnTlvLoopbackPort() *BsnTlvLoopbackPort {
7072 obj := &BsnTlvLoopbackPort{
7073 BsnTlv: NewBsnTlv(110),
7074 }
7075 return obj
7076}
7077
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7078type BsnTlvLossless struct {
7079 *BsnTlv
7080}
7081
7082type IBsnTlvLossless interface {
7083 IBsnTlv
7084}
7085
7086func (self *BsnTlvLossless) Serialize(encoder *goloxi.Encoder) error {
7087 startIndex := len(encoder.Bytes())
7088 if err := self.BsnTlv.Serialize(encoder); err != nil {
7089 return err
7090 }
7091 length := len(encoder.Bytes()) - startIndex
7092
7093 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7094
7095 return nil
7096}
7097
7098func DecodeBsnTlvLossless(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvLossless, error) {
7099 _bsntlvlossless := &BsnTlvLossless{BsnTlv: parent}
7100 return _bsntlvlossless, nil
7101}
7102
7103func NewBsnTlvLossless() *BsnTlvLossless {
7104 obj := &BsnTlvLossless{
7105 BsnTlv: NewBsnTlv(188),
7106 }
7107 return obj
7108}
7109
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7110type BsnTlvLrAllEnabled struct {
7111 *BsnTlv
7112}
7113
7114type IBsnTlvLrAllEnabled interface {
7115 IBsnTlv
7116}
7117
7118func (self *BsnTlvLrAllEnabled) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7119 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7120 if err := self.BsnTlv.Serialize(encoder); err != nil {
7121 return err
7122 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7123 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7124
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7125 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7126
7127 return nil
7128}
7129
7130func DecodeBsnTlvLrAllEnabled(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvLrAllEnabled, error) {
7131 _bsntlvlrallenabled := &BsnTlvLrAllEnabled{BsnTlv: parent}
7132 return _bsntlvlrallenabled, nil
7133}
7134
7135func NewBsnTlvLrAllEnabled() *BsnTlvLrAllEnabled {
7136 obj := &BsnTlvLrAllEnabled{
7137 BsnTlv: NewBsnTlv(178),
7138 }
7139 return obj
7140}
7141
7142type BsnTlvMac struct {
7143 *BsnTlv
7144 Value net.HardwareAddr
7145}
7146
7147type IBsnTlvMac interface {
7148 IBsnTlv
7149 GetValue() net.HardwareAddr
7150}
7151
7152func (self *BsnTlvMac) GetValue() net.HardwareAddr {
7153 return self.Value
7154}
7155
7156func (self *BsnTlvMac) SetValue(v net.HardwareAddr) {
7157 self.Value = v
7158}
7159
7160func (self *BsnTlvMac) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7161 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7162 if err := self.BsnTlv.Serialize(encoder); err != nil {
7163 return err
7164 }
7165
7166 encoder.Write(self.Value)
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7167 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7168
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7169 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7170
7171 return nil
7172}
7173
7174func DecodeBsnTlvMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMac, error) {
7175 _bsntlvmac := &BsnTlvMac{BsnTlv: parent}
7176 if decoder.Length() < 6 {
7177 return nil, fmt.Errorf("BsnTlvMac packet too short: %d < 6", decoder.Length())
7178 }
7179 _bsntlvmac.Value = net.HardwareAddr(decoder.Read(6))
7180 return _bsntlvmac, nil
7181}
7182
7183func NewBsnTlvMac() *BsnTlvMac {
7184 obj := &BsnTlvMac{
7185 BsnTlv: NewBsnTlv(1),
7186 }
7187 return obj
7188}
7189
7190type BsnTlvMacMask struct {
7191 *BsnTlv
7192 Value net.HardwareAddr
7193}
7194
7195type IBsnTlvMacMask interface {
7196 IBsnTlv
7197 GetValue() net.HardwareAddr
7198}
7199
7200func (self *BsnTlvMacMask) GetValue() net.HardwareAddr {
7201 return self.Value
7202}
7203
7204func (self *BsnTlvMacMask) SetValue(v net.HardwareAddr) {
7205 self.Value = v
7206}
7207
7208func (self *BsnTlvMacMask) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7209 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7210 if err := self.BsnTlv.Serialize(encoder); err != nil {
7211 return err
7212 }
7213
7214 encoder.Write(self.Value)
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7215 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7216
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7217 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7218
7219 return nil
7220}
7221
7222func DecodeBsnTlvMacMask(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMacMask, error) {
7223 _bsntlvmacmask := &BsnTlvMacMask{BsnTlv: parent}
7224 if decoder.Length() < 6 {
7225 return nil, fmt.Errorf("BsnTlvMacMask packet too short: %d < 6", decoder.Length())
7226 }
7227 _bsntlvmacmask.Value = net.HardwareAddr(decoder.Read(6))
7228 return _bsntlvmacmask, nil
7229}
7230
7231func NewBsnTlvMacMask() *BsnTlvMacMask {
7232 obj := &BsnTlvMacMask{
7233 BsnTlv: NewBsnTlv(56),
7234 }
7235 return obj
7236}
7237
7238type BsnTlvMcgTypeVxlan struct {
7239 *BsnTlv
7240}
7241
7242type IBsnTlvMcgTypeVxlan interface {
7243 IBsnTlv
7244}
7245
7246func (self *BsnTlvMcgTypeVxlan) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7247 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7248 if err := self.BsnTlv.Serialize(encoder); err != nil {
7249 return err
7250 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7251 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7252
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7253 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7254
7255 return nil
7256}
7257
7258func DecodeBsnTlvMcgTypeVxlan(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMcgTypeVxlan, error) {
7259 _bsntlvmcgtypevxlan := &BsnTlvMcgTypeVxlan{BsnTlv: parent}
7260 return _bsntlvmcgtypevxlan, nil
7261}
7262
7263func NewBsnTlvMcgTypeVxlan() *BsnTlvMcgTypeVxlan {
7264 obj := &BsnTlvMcgTypeVxlan{
7265 BsnTlv: NewBsnTlv(87),
7266 }
7267 return obj
7268}
7269
7270type BsnTlvMissPackets struct {
7271 *BsnTlv
7272 Value uint64
7273}
7274
7275type IBsnTlvMissPackets interface {
7276 IBsnTlv
7277 GetValue() uint64
7278}
7279
7280func (self *BsnTlvMissPackets) GetValue() uint64 {
7281 return self.Value
7282}
7283
7284func (self *BsnTlvMissPackets) SetValue(v uint64) {
7285 self.Value = v
7286}
7287
7288func (self *BsnTlvMissPackets) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7289 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7290 if err := self.BsnTlv.Serialize(encoder); err != nil {
7291 return err
7292 }
7293
7294 encoder.PutUint64(uint64(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7295 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7296
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7297 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7298
7299 return nil
7300}
7301
7302func DecodeBsnTlvMissPackets(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMissPackets, error) {
7303 _bsntlvmisspackets := &BsnTlvMissPackets{BsnTlv: parent}
7304 if decoder.Length() < 8 {
7305 return nil, fmt.Errorf("BsnTlvMissPackets packet too short: %d < 8", decoder.Length())
7306 }
7307 _bsntlvmisspackets.Value = uint64(decoder.ReadUint64())
7308 return _bsntlvmisspackets, nil
7309}
7310
7311func NewBsnTlvMissPackets() *BsnTlvMissPackets {
7312 obj := &BsnTlvMissPackets{
7313 BsnTlv: NewBsnTlv(13),
7314 }
7315 return obj
7316}
7317
7318type BsnTlvMplsControlWord struct {
7319 *BsnTlv
7320 Value uint8
7321}
7322
7323type IBsnTlvMplsControlWord interface {
7324 IBsnTlv
7325 GetValue() uint8
7326}
7327
7328func (self *BsnTlvMplsControlWord) GetValue() uint8 {
7329 return self.Value
7330}
7331
7332func (self *BsnTlvMplsControlWord) SetValue(v uint8) {
7333 self.Value = v
7334}
7335
7336func (self *BsnTlvMplsControlWord) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7337 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7338 if err := self.BsnTlv.Serialize(encoder); err != nil {
7339 return err
7340 }
7341
7342 encoder.PutUint8(uint8(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7343 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7344
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7345 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7346
7347 return nil
7348}
7349
7350func DecodeBsnTlvMplsControlWord(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMplsControlWord, error) {
7351 _bsntlvmplscontrolword := &BsnTlvMplsControlWord{BsnTlv: parent}
7352 if decoder.Length() < 1 {
7353 return nil, fmt.Errorf("BsnTlvMplsControlWord packet too short: %d < 1", decoder.Length())
7354 }
7355 _bsntlvmplscontrolword.Value = uint8(decoder.ReadByte())
7356 return _bsntlvmplscontrolword, nil
7357}
7358
7359func NewBsnTlvMplsControlWord() *BsnTlvMplsControlWord {
7360 obj := &BsnTlvMplsControlWord{
7361 BsnTlv: NewBsnTlv(62),
7362 }
7363 return obj
7364}
7365
7366type BsnTlvMplsLabel struct {
7367 *BsnTlv
7368 Value uint32
7369}
7370
7371type IBsnTlvMplsLabel interface {
7372 IBsnTlv
7373 GetValue() uint32
7374}
7375
7376func (self *BsnTlvMplsLabel) GetValue() uint32 {
7377 return self.Value
7378}
7379
7380func (self *BsnTlvMplsLabel) SetValue(v uint32) {
7381 self.Value = v
7382}
7383
7384func (self *BsnTlvMplsLabel) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7385 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7386 if err := self.BsnTlv.Serialize(encoder); err != nil {
7387 return err
7388 }
7389
7390 encoder.PutUint32(uint32(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7391 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7392
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7393 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7394
7395 return nil
7396}
7397
7398func DecodeBsnTlvMplsLabel(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMplsLabel, error) {
7399 _bsntlvmplslabel := &BsnTlvMplsLabel{BsnTlv: parent}
7400 if decoder.Length() < 4 {
7401 return nil, fmt.Errorf("BsnTlvMplsLabel packet too short: %d < 4", decoder.Length())
7402 }
7403 _bsntlvmplslabel.Value = uint32(decoder.ReadUint32())
7404 return _bsntlvmplslabel, nil
7405}
7406
7407func NewBsnTlvMplsLabel() *BsnTlvMplsLabel {
7408 obj := &BsnTlvMplsLabel{
7409 BsnTlv: NewBsnTlv(61),
7410 }
7411 return obj
7412}
7413
7414type BsnTlvMplsSequenced struct {
7415 *BsnTlv
7416 Value uint8
7417}
7418
7419type IBsnTlvMplsSequenced interface {
7420 IBsnTlv
7421 GetValue() uint8
7422}
7423
7424func (self *BsnTlvMplsSequenced) GetValue() uint8 {
7425 return self.Value
7426}
7427
7428func (self *BsnTlvMplsSequenced) SetValue(v uint8) {
7429 self.Value = v
7430}
7431
7432func (self *BsnTlvMplsSequenced) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7433 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7434 if err := self.BsnTlv.Serialize(encoder); err != nil {
7435 return err
7436 }
7437
7438 encoder.PutUint8(uint8(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7439 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7440
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7441 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7442
7443 return nil
7444}
7445
7446func DecodeBsnTlvMplsSequenced(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMplsSequenced, error) {
7447 _bsntlvmplssequenced := &BsnTlvMplsSequenced{BsnTlv: parent}
7448 if decoder.Length() < 1 {
7449 return nil, fmt.Errorf("BsnTlvMplsSequenced packet too short: %d < 1", decoder.Length())
7450 }
7451 _bsntlvmplssequenced.Value = uint8(decoder.ReadByte())
7452 return _bsntlvmplssequenced, nil
7453}
7454
7455func NewBsnTlvMplsSequenced() *BsnTlvMplsSequenced {
7456 obj := &BsnTlvMplsSequenced{
7457 BsnTlv: NewBsnTlv(63),
7458 }
7459 return obj
7460}
7461
7462type BsnTlvMulticastInterfaceId struct {
7463 *BsnTlv
7464 Value uint32
7465}
7466
7467type IBsnTlvMulticastInterfaceId interface {
7468 IBsnTlv
7469 GetValue() uint32
7470}
7471
7472func (self *BsnTlvMulticastInterfaceId) GetValue() uint32 {
7473 return self.Value
7474}
7475
7476func (self *BsnTlvMulticastInterfaceId) SetValue(v uint32) {
7477 self.Value = v
7478}
7479
7480func (self *BsnTlvMulticastInterfaceId) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7481 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7482 if err := self.BsnTlv.Serialize(encoder); err != nil {
7483 return err
7484 }
7485
7486 encoder.PutUint32(uint32(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7487 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7488
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7489 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7490
7491 return nil
7492}
7493
7494func DecodeBsnTlvMulticastInterfaceId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMulticastInterfaceId, error) {
7495 _bsntlvmulticastinterfaceid := &BsnTlvMulticastInterfaceId{BsnTlv: parent}
7496 if decoder.Length() < 4 {
7497 return nil, fmt.Errorf("BsnTlvMulticastInterfaceId packet too short: %d < 4", decoder.Length())
7498 }
7499 _bsntlvmulticastinterfaceid.Value = uint32(decoder.ReadUint32())
7500 return _bsntlvmulticastinterfaceid, nil
7501}
7502
7503func NewBsnTlvMulticastInterfaceId() *BsnTlvMulticastInterfaceId {
7504 obj := &BsnTlvMulticastInterfaceId{
7505 BsnTlv: NewBsnTlv(95),
7506 }
7507 return obj
7508}
7509
7510type BsnTlvMulticastPacket struct {
7511 *BsnTlv
7512 Value BsnMulticastPacket
7513}
7514
7515type IBsnTlvMulticastPacket interface {
7516 IBsnTlv
7517 GetValue() BsnMulticastPacket
7518}
7519
7520func (self *BsnTlvMulticastPacket) GetValue() BsnMulticastPacket {
7521 return self.Value
7522}
7523
7524func (self *BsnTlvMulticastPacket) SetValue(v BsnMulticastPacket) {
7525 self.Value = v
7526}
7527
7528func (self *BsnTlvMulticastPacket) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7529 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7530 if err := self.BsnTlv.Serialize(encoder); err != nil {
7531 return err
7532 }
7533
7534 encoder.PutUint16(uint16(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7535 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7536
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7537 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7538
7539 return nil
7540}
7541
7542func DecodeBsnTlvMulticastPacket(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMulticastPacket, error) {
7543 _bsntlvmulticastpacket := &BsnTlvMulticastPacket{BsnTlv: parent}
7544 if decoder.Length() < 2 {
7545 return nil, fmt.Errorf("BsnTlvMulticastPacket packet too short: %d < 2", decoder.Length())
7546 }
7547 _bsntlvmulticastpacket.Value = BsnMulticastPacket(decoder.ReadUint16())
7548 return _bsntlvmulticastpacket, nil
7549}
7550
7551func NewBsnTlvMulticastPacket() *BsnTlvMulticastPacket {
7552 obj := &BsnTlvMulticastPacket{
7553 BsnTlv: NewBsnTlv(170),
7554 }
7555 return obj
7556}
7557
7558type BsnTlvMultiplier struct {
7559 *BsnTlv
7560 Value uint32
7561}
7562
7563type IBsnTlvMultiplier interface {
7564 IBsnTlv
7565 GetValue() uint32
7566}
7567
7568func (self *BsnTlvMultiplier) GetValue() uint32 {
7569 return self.Value
7570}
7571
7572func (self *BsnTlvMultiplier) SetValue(v uint32) {
7573 self.Value = v
7574}
7575
7576func (self *BsnTlvMultiplier) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7577 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7578 if err := self.BsnTlv.Serialize(encoder); err != nil {
7579 return err
7580 }
7581
7582 encoder.PutUint32(uint32(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7583 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7584
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7585 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7586
7587 return nil
7588}
7589
7590func DecodeBsnTlvMultiplier(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMultiplier, error) {
7591 _bsntlvmultiplier := &BsnTlvMultiplier{BsnTlv: parent}
7592 if decoder.Length() < 4 {
7593 return nil, fmt.Errorf("BsnTlvMultiplier packet too short: %d < 4", decoder.Length())
7594 }
7595 _bsntlvmultiplier.Value = uint32(decoder.ReadUint32())
7596 return _bsntlvmultiplier, nil
7597}
7598
7599func NewBsnTlvMultiplier() *BsnTlvMultiplier {
7600 obj := &BsnTlvMultiplier{
7601 BsnTlv: NewBsnTlv(174),
7602 }
7603 return obj
7604}
7605
7606type BsnTlvName struct {
7607 *BsnTlv
7608 Value []byte
7609}
7610
7611type IBsnTlvName interface {
7612 IBsnTlv
7613 GetValue() []byte
7614}
7615
7616func (self *BsnTlvName) GetValue() []byte {
7617 return self.Value
7618}
7619
7620func (self *BsnTlvName) SetValue(v []byte) {
7621 self.Value = v
7622}
7623
7624func (self *BsnTlvName) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7625 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7626 if err := self.BsnTlv.Serialize(encoder); err != nil {
7627 return err
7628 }
7629
7630 encoder.Write(self.Value)
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7631 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7632
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7633 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7634
7635 return nil
7636}
7637
7638func DecodeBsnTlvName(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvName, error) {
7639 _bsntlvname := &BsnTlvName{BsnTlv: parent}
7640 _bsntlvname.Value = decoder.Read(int(decoder.Length()))
7641 return _bsntlvname, nil
7642}
7643
7644func NewBsnTlvName() *BsnTlvName {
7645 obj := &BsnTlvName{
7646 BsnTlv: NewBsnTlv(52),
7647 }
7648 return obj
7649}
7650
7651type BsnTlvNdpOffload struct {
7652 *BsnTlv
7653}
7654
7655type IBsnTlvNdpOffload interface {
7656 IBsnTlv
7657}
7658
7659func (self *BsnTlvNdpOffload) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7660 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7661 if err := self.BsnTlv.Serialize(encoder); err != nil {
7662 return err
7663 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7664 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7665
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7666 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7667
7668 return nil
7669}
7670
7671func DecodeBsnTlvNdpOffload(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNdpOffload, error) {
7672 _bsntlvndpoffload := &BsnTlvNdpOffload{BsnTlv: parent}
7673 return _bsntlvndpoffload, nil
7674}
7675
7676func NewBsnTlvNdpOffload() *BsnTlvNdpOffload {
7677 obj := &BsnTlvNdpOffload{
7678 BsnTlv: NewBsnTlv(123),
7679 }
7680 return obj
7681}
7682
7683type BsnTlvNdpStatic struct {
7684 *BsnTlv
7685}
7686
7687type IBsnTlvNdpStatic interface {
7688 IBsnTlv
7689}
7690
7691func (self *BsnTlvNdpStatic) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7692 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7693 if err := self.BsnTlv.Serialize(encoder); err != nil {
7694 return err
7695 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7696 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7697
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7698 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7699
7700 return nil
7701}
7702
7703func DecodeBsnTlvNdpStatic(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNdpStatic, error) {
7704 _bsntlvndpstatic := &BsnTlvNdpStatic{BsnTlv: parent}
7705 return _bsntlvndpstatic, nil
7706}
7707
7708func NewBsnTlvNdpStatic() *BsnTlvNdpStatic {
7709 obj := &BsnTlvNdpStatic{
7710 BsnTlv: NewBsnTlv(124),
7711 }
7712 return obj
7713}
7714
7715type BsnTlvNegate struct {
7716 *BsnTlv
7717}
7718
7719type IBsnTlvNegate interface {
7720 IBsnTlv
7721}
7722
7723func (self *BsnTlvNegate) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7724 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7725 if err := self.BsnTlv.Serialize(encoder); err != nil {
7726 return err
7727 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7728 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7729
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7730 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7731
7732 return nil
7733}
7734
7735func DecodeBsnTlvNegate(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNegate, error) {
7736 _bsntlvnegate := &BsnTlvNegate{BsnTlv: parent}
7737 return _bsntlvnegate, nil
7738}
7739
7740func NewBsnTlvNegate() *BsnTlvNegate {
7741 obj := &BsnTlvNegate{
7742 BsnTlv: NewBsnTlv(83),
7743 }
7744 return obj
7745}
7746
7747type BsnTlvNextHopIpv4 struct {
7748 *BsnTlv
7749 Value net.IP
7750}
7751
7752type IBsnTlvNextHopIpv4 interface {
7753 IBsnTlv
7754 GetValue() net.IP
7755}
7756
7757func (self *BsnTlvNextHopIpv4) GetValue() net.IP {
7758 return self.Value
7759}
7760
7761func (self *BsnTlvNextHopIpv4) SetValue(v net.IP) {
7762 self.Value = v
7763}
7764
7765func (self *BsnTlvNextHopIpv4) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7766 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7767 if err := self.BsnTlv.Serialize(encoder); err != nil {
7768 return err
7769 }
7770
7771 encoder.Write(self.Value.To4())
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7772 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7773
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7774 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7775
7776 return nil
7777}
7778
7779func DecodeBsnTlvNextHopIpv4(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNextHopIpv4, error) {
7780 _bsntlvnexthopipv4 := &BsnTlvNextHopIpv4{BsnTlv: parent}
7781 if decoder.Length() < 4 {
7782 return nil, fmt.Errorf("BsnTlvNextHopIpv4 packet too short: %d < 4", decoder.Length())
7783 }
7784 _bsntlvnexthopipv4.Value = net.IP(decoder.Read(4))
7785 return _bsntlvnexthopipv4, nil
7786}
7787
7788func NewBsnTlvNextHopIpv4() *BsnTlvNextHopIpv4 {
7789 obj := &BsnTlvNextHopIpv4{
7790 BsnTlv: NewBsnTlv(115),
7791 }
7792 return obj
7793}
7794
7795type BsnTlvNextHopMac struct {
7796 *BsnTlv
7797 Value net.HardwareAddr
7798}
7799
7800type IBsnTlvNextHopMac interface {
7801 IBsnTlv
7802 GetValue() net.HardwareAddr
7803}
7804
7805func (self *BsnTlvNextHopMac) GetValue() net.HardwareAddr {
7806 return self.Value
7807}
7808
7809func (self *BsnTlvNextHopMac) SetValue(v net.HardwareAddr) {
7810 self.Value = v
7811}
7812
7813func (self *BsnTlvNextHopMac) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7814 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7815 if err := self.BsnTlv.Serialize(encoder); err != nil {
7816 return err
7817 }
7818
7819 encoder.Write(self.Value)
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7820 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7821
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7822 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7823
7824 return nil
7825}
7826
7827func DecodeBsnTlvNextHopMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNextHopMac, error) {
7828 _bsntlvnexthopmac := &BsnTlvNextHopMac{BsnTlv: parent}
7829 if decoder.Length() < 6 {
7830 return nil, fmt.Errorf("BsnTlvNextHopMac packet too short: %d < 6", decoder.Length())
7831 }
7832 _bsntlvnexthopmac.Value = net.HardwareAddr(decoder.Read(6))
7833 return _bsntlvnexthopmac, nil
7834}
7835
7836func NewBsnTlvNextHopMac() *BsnTlvNextHopMac {
7837 obj := &BsnTlvNextHopMac{
7838 BsnTlv: NewBsnTlv(114),
7839 }
7840 return obj
7841}
7842
7843type BsnTlvNexthopTypeVxlan struct {
7844 *BsnTlv
7845}
7846
7847type IBsnTlvNexthopTypeVxlan interface {
7848 IBsnTlv
7849}
7850
7851func (self *BsnTlvNexthopTypeVxlan) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7852 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7853 if err := self.BsnTlv.Serialize(encoder); err != nil {
7854 return err
7855 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7856 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7857
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7858 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7859
7860 return nil
7861}
7862
7863func DecodeBsnTlvNexthopTypeVxlan(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNexthopTypeVxlan, error) {
7864 _bsntlvnexthoptypevxlan := &BsnTlvNexthopTypeVxlan{BsnTlv: parent}
7865 return _bsntlvnexthoptypevxlan, nil
7866}
7867
7868func NewBsnTlvNexthopTypeVxlan() *BsnTlvNexthopTypeVxlan {
7869 obj := &BsnTlvNexthopTypeVxlan{
7870 BsnTlv: NewBsnTlv(94),
7871 }
7872 return obj
7873}
7874
7875type BsnTlvNoArpResponse struct {
7876 *BsnTlv
7877}
7878
7879type IBsnTlvNoArpResponse interface {
7880 IBsnTlv
7881}
7882
7883func (self *BsnTlvNoArpResponse) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7884 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7885 if err := self.BsnTlv.Serialize(encoder); err != nil {
7886 return err
7887 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7888 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7889
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7890 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7891
7892 return nil
7893}
7894
7895func DecodeBsnTlvNoArpResponse(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNoArpResponse, error) {
7896 _bsntlvnoarpresponse := &BsnTlvNoArpResponse{BsnTlv: parent}
7897 return _bsntlvnoarpresponse, nil
7898}
7899
7900func NewBsnTlvNoArpResponse() *BsnTlvNoArpResponse {
7901 obj := &BsnTlvNoArpResponse{
7902 BsnTlv: NewBsnTlv(147),
7903 }
7904 return obj
7905}
7906
7907type BsnTlvNoNsResponse struct {
7908 *BsnTlv
7909}
7910
7911type IBsnTlvNoNsResponse interface {
7912 IBsnTlv
7913}
7914
7915func (self *BsnTlvNoNsResponse) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7916 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7917 if err := self.BsnTlv.Serialize(encoder); err != nil {
7918 return err
7919 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7920 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7921
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7922 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7923
7924 return nil
7925}
7926
7927func DecodeBsnTlvNoNsResponse(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNoNsResponse, error) {
7928 _bsntlvnonsresponse := &BsnTlvNoNsResponse{BsnTlv: parent}
7929 return _bsntlvnonsresponse, nil
7930}
7931
7932func NewBsnTlvNoNsResponse() *BsnTlvNoNsResponse {
7933 obj := &BsnTlvNoNsResponse{
7934 BsnTlv: NewBsnTlv(148),
7935 }
7936 return obj
7937}
7938
7939type BsnTlvOffset struct {
7940 *BsnTlv
7941 Value uint16
7942}
7943
7944type IBsnTlvOffset interface {
7945 IBsnTlv
7946 GetValue() uint16
7947}
7948
7949func (self *BsnTlvOffset) GetValue() uint16 {
7950 return self.Value
7951}
7952
7953func (self *BsnTlvOffset) SetValue(v uint16) {
7954 self.Value = v
7955}
7956
7957func (self *BsnTlvOffset) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7958 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7959 if err := self.BsnTlv.Serialize(encoder); err != nil {
7960 return err
7961 }
7962
7963 encoder.PutUint16(uint16(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7964 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7965
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7966 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7967
7968 return nil
7969}
7970
7971func DecodeBsnTlvOffset(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvOffset, error) {
7972 _bsntlvoffset := &BsnTlvOffset{BsnTlv: parent}
7973 if decoder.Length() < 2 {
7974 return nil, fmt.Errorf("BsnTlvOffset packet too short: %d < 2", decoder.Length())
7975 }
7976 _bsntlvoffset.Value = uint16(decoder.ReadUint16())
7977 return _bsntlvoffset, nil
7978}
7979
7980func NewBsnTlvOffset() *BsnTlvOffset {
7981 obj := &BsnTlvOffset{
7982 BsnTlv: NewBsnTlv(82),
7983 }
7984 return obj
7985}
7986
7987type BsnTlvOpticsAlwaysEnabled struct {
7988 *BsnTlv
7989}
7990
7991type IBsnTlvOpticsAlwaysEnabled interface {
7992 IBsnTlv
7993}
7994
7995func (self *BsnTlvOpticsAlwaysEnabled) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]7996 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]7997 if err := self.BsnTlv.Serialize(encoder); err != nil {
7998 return err
7999 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8000 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8001
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8002 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8003
8004 return nil
8005}
8006
8007func DecodeBsnTlvOpticsAlwaysEnabled(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvOpticsAlwaysEnabled, error) {
8008 _bsntlvopticsalwaysenabled := &BsnTlvOpticsAlwaysEnabled{BsnTlv: parent}
8009 return _bsntlvopticsalwaysenabled, nil
8010}
8011
8012func NewBsnTlvOpticsAlwaysEnabled() *BsnTlvOpticsAlwaysEnabled {
8013 obj := &BsnTlvOpticsAlwaysEnabled{
8014 BsnTlv: NewBsnTlv(150),
8015 }
8016 return obj
8017}
8018
8019type BsnTlvOuterSrcMac struct {
8020 *BsnTlv
8021 Value net.HardwareAddr
8022}
8023
8024type IBsnTlvOuterSrcMac interface {
8025 IBsnTlv
8026 GetValue() net.HardwareAddr
8027}
8028
8029func (self *BsnTlvOuterSrcMac) GetValue() net.HardwareAddr {
8030 return self.Value
8031}
8032
8033func (self *BsnTlvOuterSrcMac) SetValue(v net.HardwareAddr) {
8034 self.Value = v
8035}
8036
8037func (self *BsnTlvOuterSrcMac) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8038 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8039 if err := self.BsnTlv.Serialize(encoder); err != nil {
8040 return err
8041 }
8042
8043 encoder.Write(self.Value)
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8044 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8045
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8046 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8047
8048 return nil
8049}
8050
8051func DecodeBsnTlvOuterSrcMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvOuterSrcMac, error) {
8052 _bsntlvoutersrcmac := &BsnTlvOuterSrcMac{BsnTlv: parent}
8053 if decoder.Length() < 6 {
8054 return nil, fmt.Errorf("BsnTlvOuterSrcMac packet too short: %d < 6", decoder.Length())
8055 }
8056 _bsntlvoutersrcmac.Value = net.HardwareAddr(decoder.Read(6))
8057 return _bsntlvoutersrcmac, nil
8058}
8059
8060func NewBsnTlvOuterSrcMac() *BsnTlvOuterSrcMac {
8061 obj := &BsnTlvOuterSrcMac{
8062 BsnTlv: NewBsnTlv(157),
8063 }
8064 return obj
8065}
8066
8067type BsnTlvParentPort struct {
8068 *BsnTlv
8069 Value Port
8070}
8071
8072type IBsnTlvParentPort interface {
8073 IBsnTlv
8074 GetValue() Port
8075}
8076
8077func (self *BsnTlvParentPort) GetValue() Port {
8078 return self.Value
8079}
8080
8081func (self *BsnTlvParentPort) SetValue(v Port) {
8082 self.Value = v
8083}
8084
8085func (self *BsnTlvParentPort) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8086 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8087 if err := self.BsnTlv.Serialize(encoder); err != nil {
8088 return err
8089 }
8090
8091 self.Value.Serialize(encoder)
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8092 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8093
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8094 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8095
8096 return nil
8097}
8098
8099func DecodeBsnTlvParentPort(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvParentPort, error) {
8100 _bsntlvparentport := &BsnTlvParentPort{BsnTlv: parent}
8101 if decoder.Length() < 4 {
8102 return nil, fmt.Errorf("BsnTlvParentPort packet too short: %d < 4", decoder.Length())
8103 }
8104 _bsntlvparentport.Value.Decode(decoder)
8105 return _bsntlvparentport, nil
8106}
8107
8108func NewBsnTlvParentPort() *BsnTlvParentPort {
8109 obj := &BsnTlvParentPort{
8110 BsnTlv: NewBsnTlv(109),
8111 }
8112 return obj
8113}
8114
8115type BsnTlvPartnerKey struct {
8116 *BsnTlv
8117 Value uint16
8118}
8119
8120type IBsnTlvPartnerKey interface {
8121 IBsnTlv
8122 GetValue() uint16
8123}
8124
8125func (self *BsnTlvPartnerKey) GetValue() uint16 {
8126 return self.Value
8127}
8128
8129func (self *BsnTlvPartnerKey) SetValue(v uint16) {
8130 self.Value = v
8131}
8132
8133func (self *BsnTlvPartnerKey) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8134 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8135 if err := self.BsnTlv.Serialize(encoder); err != nil {
8136 return err
8137 }
8138
8139 encoder.PutUint16(uint16(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8140 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8141
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8142 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8143
8144 return nil
8145}
8146
8147func DecodeBsnTlvPartnerKey(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPartnerKey, error) {
8148 _bsntlvpartnerkey := &BsnTlvPartnerKey{BsnTlv: parent}
8149 if decoder.Length() < 2 {
8150 return nil, fmt.Errorf("BsnTlvPartnerKey packet too short: %d < 2", decoder.Length())
8151 }
8152 _bsntlvpartnerkey.Value = uint16(decoder.ReadUint16())
8153 return _bsntlvpartnerkey, nil
8154}
8155
8156func NewBsnTlvPartnerKey() *BsnTlvPartnerKey {
8157 obj := &BsnTlvPartnerKey{
8158 BsnTlv: NewBsnTlv(51),
8159 }
8160 return obj
8161}
8162
8163type BsnTlvPartnerPortNum struct {
8164 *BsnTlv
8165 Value uint16
8166}
8167
8168type IBsnTlvPartnerPortNum interface {
8169 IBsnTlv
8170 GetValue() uint16
8171}
8172
8173func (self *BsnTlvPartnerPortNum) GetValue() uint16 {
8174 return self.Value
8175}
8176
8177func (self *BsnTlvPartnerPortNum) SetValue(v uint16) {
8178 self.Value = v
8179}
8180
8181func (self *BsnTlvPartnerPortNum) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8182 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8183 if err := self.BsnTlv.Serialize(encoder); err != nil {
8184 return err
8185 }
8186
8187 encoder.PutUint16(uint16(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8188 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8189
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8190 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8191
8192 return nil
8193}
8194
8195func DecodeBsnTlvPartnerPortNum(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPartnerPortNum, error) {
8196 _bsntlvpartnerportnum := &BsnTlvPartnerPortNum{BsnTlv: parent}
8197 if decoder.Length() < 2 {
8198 return nil, fmt.Errorf("BsnTlvPartnerPortNum packet too short: %d < 2", decoder.Length())
8199 }
8200 _bsntlvpartnerportnum.Value = uint16(decoder.ReadUint16())
8201 return _bsntlvpartnerportnum, nil
8202}
8203
8204func NewBsnTlvPartnerPortNum() *BsnTlvPartnerPortNum {
8205 obj := &BsnTlvPartnerPortNum{
8206 BsnTlv: NewBsnTlv(50),
8207 }
8208 return obj
8209}
8210
8211type BsnTlvPartnerPortPriority struct {
8212 *BsnTlv
8213 Value uint16
8214}
8215
8216type IBsnTlvPartnerPortPriority interface {
8217 IBsnTlv
8218 GetValue() uint16
8219}
8220
8221func (self *BsnTlvPartnerPortPriority) GetValue() uint16 {
8222 return self.Value
8223}
8224
8225func (self *BsnTlvPartnerPortPriority) SetValue(v uint16) {
8226 self.Value = v
8227}
8228
8229func (self *BsnTlvPartnerPortPriority) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8230 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8231 if err := self.BsnTlv.Serialize(encoder); err != nil {
8232 return err
8233 }
8234
8235 encoder.PutUint16(uint16(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8236 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8237
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8238 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8239
8240 return nil
8241}
8242
8243func DecodeBsnTlvPartnerPortPriority(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPartnerPortPriority, error) {
8244 _bsntlvpartnerportpriority := &BsnTlvPartnerPortPriority{BsnTlv: parent}
8245 if decoder.Length() < 2 {
8246 return nil, fmt.Errorf("BsnTlvPartnerPortPriority packet too short: %d < 2", decoder.Length())
8247 }
8248 _bsntlvpartnerportpriority.Value = uint16(decoder.ReadUint16())
8249 return _bsntlvpartnerportpriority, nil
8250}
8251
8252func NewBsnTlvPartnerPortPriority() *BsnTlvPartnerPortPriority {
8253 obj := &BsnTlvPartnerPortPriority{
8254 BsnTlv: NewBsnTlv(49),
8255 }
8256 return obj
8257}
8258
8259type BsnTlvPartnerState struct {
8260 *BsnTlv
8261 Value BsnLacpState
8262}
8263
8264type IBsnTlvPartnerState interface {
8265 IBsnTlv
8266 GetValue() BsnLacpState
8267}
8268
8269func (self *BsnTlvPartnerState) GetValue() BsnLacpState {
8270 return self.Value
8271}
8272
8273func (self *BsnTlvPartnerState) SetValue(v BsnLacpState) {
8274 self.Value = v
8275}
8276
8277func (self *BsnTlvPartnerState) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8278 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8279 if err := self.BsnTlv.Serialize(encoder); err != nil {
8280 return err
8281 }
8282
8283 encoder.PutUint8(uint8(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8284 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8285
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8286 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8287
8288 return nil
8289}
8290
8291func DecodeBsnTlvPartnerState(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPartnerState, error) {
8292 _bsntlvpartnerstate := &BsnTlvPartnerState{BsnTlv: parent}
8293 if decoder.Length() < 1 {
8294 return nil, fmt.Errorf("BsnTlvPartnerState packet too short: %d < 1", decoder.Length())
8295 }
8296 _bsntlvpartnerstate.Value = BsnLacpState(decoder.ReadByte())
8297 return _bsntlvpartnerstate, nil
8298}
8299
8300func NewBsnTlvPartnerState() *BsnTlvPartnerState {
8301 obj := &BsnTlvPartnerState{
8302 BsnTlv: NewBsnTlv(54),
8303 }
8304 return obj
8305}
8306
8307type BsnTlvPartnerSystemMac struct {
8308 *BsnTlv
8309 Value net.HardwareAddr
8310}
8311
8312type IBsnTlvPartnerSystemMac interface {
8313 IBsnTlv
8314 GetValue() net.HardwareAddr
8315}
8316
8317func (self *BsnTlvPartnerSystemMac) GetValue() net.HardwareAddr {
8318 return self.Value
8319}
8320
8321func (self *BsnTlvPartnerSystemMac) SetValue(v net.HardwareAddr) {
8322 self.Value = v
8323}
8324
8325func (self *BsnTlvPartnerSystemMac) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8326 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8327 if err := self.BsnTlv.Serialize(encoder); err != nil {
8328 return err
8329 }
8330
8331 encoder.Write(self.Value)
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8332 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8333
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8334 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8335
8336 return nil
8337}
8338
8339func DecodeBsnTlvPartnerSystemMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPartnerSystemMac, error) {
8340 _bsntlvpartnersystemmac := &BsnTlvPartnerSystemMac{BsnTlv: parent}
8341 if decoder.Length() < 6 {
8342 return nil, fmt.Errorf("BsnTlvPartnerSystemMac packet too short: %d < 6", decoder.Length())
8343 }
8344 _bsntlvpartnersystemmac.Value = net.HardwareAddr(decoder.Read(6))
8345 return _bsntlvpartnersystemmac, nil
8346}
8347
8348func NewBsnTlvPartnerSystemMac() *BsnTlvPartnerSystemMac {
8349 obj := &BsnTlvPartnerSystemMac{
8350 BsnTlv: NewBsnTlv(48),
8351 }
8352 return obj
8353}
8354
8355type BsnTlvPartnerSystemPriority struct {
8356 *BsnTlv
8357 Value uint16
8358}
8359
8360type IBsnTlvPartnerSystemPriority interface {
8361 IBsnTlv
8362 GetValue() uint16
8363}
8364
8365func (self *BsnTlvPartnerSystemPriority) GetValue() uint16 {
8366 return self.Value
8367}
8368
8369func (self *BsnTlvPartnerSystemPriority) SetValue(v uint16) {
8370 self.Value = v
8371}
8372
8373func (self *BsnTlvPartnerSystemPriority) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8374 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8375 if err := self.BsnTlv.Serialize(encoder); err != nil {
8376 return err
8377 }
8378
8379 encoder.PutUint16(uint16(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8380 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8381
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8382 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8383
8384 return nil
8385}
8386
8387func DecodeBsnTlvPartnerSystemPriority(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPartnerSystemPriority, error) {
8388 _bsntlvpartnersystempriority := &BsnTlvPartnerSystemPriority{BsnTlv: parent}
8389 if decoder.Length() < 2 {
8390 return nil, fmt.Errorf("BsnTlvPartnerSystemPriority packet too short: %d < 2", decoder.Length())
8391 }
8392 _bsntlvpartnersystempriority.Value = uint16(decoder.ReadUint16())
8393 return _bsntlvpartnersystempriority, nil
8394}
8395
8396func NewBsnTlvPartnerSystemPriority() *BsnTlvPartnerSystemPriority {
8397 obj := &BsnTlvPartnerSystemPriority{
8398 BsnTlv: NewBsnTlv(47),
8399 }
8400 return obj
8401}
8402
8403type BsnTlvPassive struct {
8404 *BsnTlv
8405}
8406
8407type IBsnTlvPassive interface {
8408 IBsnTlv
8409}
8410
8411func (self *BsnTlvPassive) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8412 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8413 if err := self.BsnTlv.Serialize(encoder); err != nil {
8414 return err
8415 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8416 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8417
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8418 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8419
8420 return nil
8421}
8422
8423func DecodeBsnTlvPassive(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPassive, error) {
8424 _bsntlvpassive := &BsnTlvPassive{BsnTlv: parent}
8425 return _bsntlvpassive, nil
8426}
8427
8428func NewBsnTlvPassive() *BsnTlvPassive {
8429 obj := &BsnTlvPassive{
8430 BsnTlv: NewBsnTlv(172),
8431 }
8432 return obj
8433}
8434
8435type BsnTlvPduaRxInstance struct {
8436 *BsnTlv
8437 Value []byte
8438}
8439
8440type IBsnTlvPduaRxInstance interface {
8441 IBsnTlv
8442 GetValue() []byte
8443}
8444
8445func (self *BsnTlvPduaRxInstance) GetValue() []byte {
8446 return self.Value
8447}
8448
8449func (self *BsnTlvPduaRxInstance) SetValue(v []byte) {
8450 self.Value = v
8451}
8452
8453func (self *BsnTlvPduaRxInstance) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8454 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8455 if err := self.BsnTlv.Serialize(encoder); err != nil {
8456 return err
8457 }
8458
8459 encoder.Write(self.Value)
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8460 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8461
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8462 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8463
8464 return nil
8465}
8466
8467func DecodeBsnTlvPduaRxInstance(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPduaRxInstance, error) {
8468 _bsntlvpduarxinstance := &BsnTlvPduaRxInstance{BsnTlv: parent}
8469 _bsntlvpduarxinstance.Value = decoder.Read(int(decoder.Length()))
8470 return _bsntlvpduarxinstance, nil
8471}
8472
8473func NewBsnTlvPduaRxInstance() *BsnTlvPduaRxInstance {
8474 obj := &BsnTlvPduaRxInstance{
8475 BsnTlv: NewBsnTlv(159),
8476 }
8477 return obj
8478}
8479
8480type BsnTlvPimDr struct {
8481 *BsnTlv
8482}
8483
8484type IBsnTlvPimDr interface {
8485 IBsnTlv
8486}
8487
8488func (self *BsnTlvPimDr) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8489 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8490 if err := self.BsnTlv.Serialize(encoder); err != nil {
8491 return err
8492 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8493 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8494
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8495 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8496
8497 return nil
8498}
8499
8500func DecodeBsnTlvPimDr(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPimDr, error) {
8501 _bsntlvpimdr := &BsnTlvPimDr{BsnTlv: parent}
8502 return _bsntlvpimdr, nil
8503}
8504
8505func NewBsnTlvPimDr() *BsnTlvPimDr {
8506 obj := &BsnTlvPimDr{
8507 BsnTlv: NewBsnTlv(171),
8508 }
8509 return obj
8510}
8511
8512type BsnTlvPimHelloFlood struct {
8513 *BsnTlv
8514}
8515
8516type IBsnTlvPimHelloFlood interface {
8517 IBsnTlv
8518}
8519
8520func (self *BsnTlvPimHelloFlood) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8521 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8522 if err := self.BsnTlv.Serialize(encoder); err != nil {
8523 return err
8524 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8525 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8526
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8527 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8528
8529 return nil
8530}
8531
8532func DecodeBsnTlvPimHelloFlood(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPimHelloFlood, error) {
8533 _bsntlvpimhelloflood := &BsnTlvPimHelloFlood{BsnTlv: parent}
8534 return _bsntlvpimhelloflood, nil
8535}
8536
8537func NewBsnTlvPimHelloFlood() *BsnTlvPimHelloFlood {
8538 obj := &BsnTlvPimHelloFlood{
8539 BsnTlv: NewBsnTlv(181),
8540 }
8541 return obj
8542}
8543
8544type BsnTlvPort struct {
8545 *BsnTlv
8546 Value Port
8547}
8548
8549type IBsnTlvPort interface {
8550 IBsnTlv
8551 GetValue() Port
8552}
8553
8554func (self *BsnTlvPort) GetValue() Port {
8555 return self.Value
8556}
8557
8558func (self *BsnTlvPort) SetValue(v Port) {
8559 self.Value = v
8560}
8561
8562func (self *BsnTlvPort) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8563 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8564 if err := self.BsnTlv.Serialize(encoder); err != nil {
8565 return err
8566 }
8567
8568 self.Value.Serialize(encoder)
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8569 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8570
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8571 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8572
8573 return nil
8574}
8575
8576func DecodeBsnTlvPort(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPort, error) {
8577 _bsntlvport := &BsnTlvPort{BsnTlv: parent}
8578 if decoder.Length() < 4 {
8579 return nil, fmt.Errorf("BsnTlvPort packet too short: %d < 4", decoder.Length())
8580 }
8581 _bsntlvport.Value.Decode(decoder)
8582 return _bsntlvport, nil
8583}
8584
8585func NewBsnTlvPort() *BsnTlvPort {
8586 obj := &BsnTlvPort{
8587 BsnTlv: NewBsnTlv(0),
8588 }
8589 return obj
8590}
8591
8592type BsnTlvPortMode struct {
8593 *BsnTlv
8594 Value BsnPortMode
8595}
8596
8597type IBsnTlvPortMode interface {
8598 IBsnTlv
8599 GetValue() BsnPortMode
8600}
8601
8602func (self *BsnTlvPortMode) GetValue() BsnPortMode {
8603 return self.Value
8604}
8605
8606func (self *BsnTlvPortMode) SetValue(v BsnPortMode) {
8607 self.Value = v
8608}
8609
8610func (self *BsnTlvPortMode) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8611 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8612 if err := self.BsnTlv.Serialize(encoder); err != nil {
8613 return err
8614 }
8615
8616 encoder.PutUint16(uint16(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8617 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8618
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8619 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8620
8621 return nil
8622}
8623
8624func DecodeBsnTlvPortMode(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPortMode, error) {
8625 _bsntlvportmode := &BsnTlvPortMode{BsnTlv: parent}
8626 if decoder.Length() < 2 {
8627 return nil, fmt.Errorf("BsnTlvPortMode packet too short: %d < 2", decoder.Length())
8628 }
8629 _bsntlvportmode.Value = BsnPortMode(decoder.ReadUint16())
8630 return _bsntlvportmode, nil
8631}
8632
8633func NewBsnTlvPortMode() *BsnTlvPortMode {
8634 obj := &BsnTlvPortMode{
8635 BsnTlv: NewBsnTlv(179),
8636 }
8637 return obj
8638}
8639
8640type BsnTlvPortSpeedGbps struct {
8641 *BsnTlv
8642 Value uint32
8643}
8644
8645type IBsnTlvPortSpeedGbps interface {
8646 IBsnTlv
8647 GetValue() uint32
8648}
8649
8650func (self *BsnTlvPortSpeedGbps) GetValue() uint32 {
8651 return self.Value
8652}
8653
8654func (self *BsnTlvPortSpeedGbps) SetValue(v uint32) {
8655 self.Value = v
8656}
8657
8658func (self *BsnTlvPortSpeedGbps) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8659 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8660 if err := self.BsnTlv.Serialize(encoder); err != nil {
8661 return err
8662 }
8663
8664 encoder.PutUint32(uint32(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8665 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8666
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8667 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8668
8669 return nil
8670}
8671
8672func DecodeBsnTlvPortSpeedGbps(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPortSpeedGbps, error) {
8673 _bsntlvportspeedgbps := &BsnTlvPortSpeedGbps{BsnTlv: parent}
8674 if decoder.Length() < 4 {
8675 return nil, fmt.Errorf("BsnTlvPortSpeedGbps packet too short: %d < 4", decoder.Length())
8676 }
8677 _bsntlvportspeedgbps.Value = uint32(decoder.ReadUint32())
8678 return _bsntlvportspeedgbps, nil
8679}
8680
8681func NewBsnTlvPortSpeedGbps() *BsnTlvPortSpeedGbps {
8682 obj := &BsnTlvPortSpeedGbps{
8683 BsnTlv: NewBsnTlv(156),
8684 }
8685 return obj
8686}
8687
8688type BsnTlvPortUsage struct {
8689 *BsnTlv
8690 Value BsnPortUsage
8691}
8692
8693type IBsnTlvPortUsage interface {
8694 IBsnTlv
8695 GetValue() BsnPortUsage
8696}
8697
8698func (self *BsnTlvPortUsage) GetValue() BsnPortUsage {
8699 return self.Value
8700}
8701
8702func (self *BsnTlvPortUsage) SetValue(v BsnPortUsage) {
8703 self.Value = v
8704}
8705
8706func (self *BsnTlvPortUsage) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8707 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8708 if err := self.BsnTlv.Serialize(encoder); err != nil {
8709 return err
8710 }
8711
8712 encoder.PutUint16(uint16(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8713 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8714
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8715 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8716
8717 return nil
8718}
8719
8720func DecodeBsnTlvPortUsage(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPortUsage, error) {
8721 _bsntlvportusage := &BsnTlvPortUsage{BsnTlv: parent}
8722 if decoder.Length() < 2 {
8723 return nil, fmt.Errorf("BsnTlvPortUsage packet too short: %d < 2", decoder.Length())
8724 }
8725 _bsntlvportusage.Value = BsnPortUsage(decoder.ReadUint16())
8726 return _bsntlvportusage, nil
8727}
8728
8729func NewBsnTlvPortUsage() *BsnTlvPortUsage {
8730 obj := &BsnTlvPortUsage{
8731 BsnTlv: NewBsnTlv(141),
8732 }
8733 return obj
8734}
8735
8736type BsnTlvPortVxlanMode struct {
8737 *BsnTlv
8738 Value BsnPortVxlanMode
8739}
8740
8741type IBsnTlvPortVxlanMode interface {
8742 IBsnTlv
8743 GetValue() BsnPortVxlanMode
8744}
8745
8746func (self *BsnTlvPortVxlanMode) GetValue() BsnPortVxlanMode {
8747 return self.Value
8748}
8749
8750func (self *BsnTlvPortVxlanMode) SetValue(v BsnPortVxlanMode) {
8751 self.Value = v
8752}
8753
8754func (self *BsnTlvPortVxlanMode) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8755 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8756 if err := self.BsnTlv.Serialize(encoder); err != nil {
8757 return err
8758 }
8759
8760 encoder.PutUint8(uint8(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8761 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8762
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8763 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8764
8765 return nil
8766}
8767
8768func DecodeBsnTlvPortVxlanMode(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPortVxlanMode, error) {
8769 _bsntlvportvxlanmode := &BsnTlvPortVxlanMode{BsnTlv: parent}
8770 if decoder.Length() < 1 {
8771 return nil, fmt.Errorf("BsnTlvPortVxlanMode packet too short: %d < 1", decoder.Length())
8772 }
8773 _bsntlvportvxlanmode.Value = BsnPortVxlanMode(decoder.ReadByte())
8774 return _bsntlvportvxlanmode, nil
8775}
8776
8777func NewBsnTlvPortVxlanMode() *BsnTlvPortVxlanMode {
8778 obj := &BsnTlvPortVxlanMode{
8779 BsnTlv: NewBsnTlv(88),
8780 }
8781 return obj
8782}
8783
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8784type BsnTlvPreserveVlan struct {
8785 *BsnTlv
8786}
8787
8788type IBsnTlvPreserveVlan interface {
8789 IBsnTlv
8790}
8791
8792func (self *BsnTlvPreserveVlan) Serialize(encoder *goloxi.Encoder) error {
8793 startIndex := len(encoder.Bytes())
8794 if err := self.BsnTlv.Serialize(encoder); err != nil {
8795 return err
8796 }
8797 length := len(encoder.Bytes()) - startIndex
8798
8799 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8800
8801 return nil
8802}
8803
8804func DecodeBsnTlvPreserveVlan(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPreserveVlan, error) {
8805 _bsntlvpreservevlan := &BsnTlvPreserveVlan{BsnTlv: parent}
8806 return _bsntlvpreservevlan, nil
8807}
8808
8809func NewBsnTlvPreserveVlan() *BsnTlvPreserveVlan {
8810 obj := &BsnTlvPreserveVlan{
8811 BsnTlv: NewBsnTlv(186),
8812 }
8813 return obj
8814}
8815
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8816type BsnTlvPriority struct {
8817 *BsnTlv
8818 Value uint32
8819}
8820
8821type IBsnTlvPriority interface {
8822 IBsnTlv
8823 GetValue() uint32
8824}
8825
8826func (self *BsnTlvPriority) GetValue() uint32 {
8827 return self.Value
8828}
8829
8830func (self *BsnTlvPriority) SetValue(v uint32) {
8831 self.Value = v
8832}
8833
8834func (self *BsnTlvPriority) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8835 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8836 if err := self.BsnTlv.Serialize(encoder); err != nil {
8837 return err
8838 }
8839
8840 encoder.PutUint32(uint32(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8841 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8842
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8843 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8844
8845 return nil
8846}
8847
8848func DecodeBsnTlvPriority(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPriority, error) {
8849 _bsntlvpriority := &BsnTlvPriority{BsnTlv: parent}
8850 if decoder.Length() < 4 {
8851 return nil, fmt.Errorf("BsnTlvPriority packet too short: %d < 4", decoder.Length())
8852 }
8853 _bsntlvpriority.Value = uint32(decoder.ReadUint32())
8854 return _bsntlvpriority, nil
8855}
8856
8857func NewBsnTlvPriority() *BsnTlvPriority {
8858 obj := &BsnTlvPriority{
8859 BsnTlv: NewBsnTlv(57),
8860 }
8861 return obj
8862}
8863
8864type BsnTlvPushVlanOnEgress struct {
8865 *BsnTlv
8866}
8867
8868type IBsnTlvPushVlanOnEgress interface {
8869 IBsnTlv
8870}
8871
8872func (self *BsnTlvPushVlanOnEgress) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8873 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8874 if err := self.BsnTlv.Serialize(encoder); err != nil {
8875 return err
8876 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8877 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8878
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8879 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8880
8881 return nil
8882}
8883
8884func DecodeBsnTlvPushVlanOnEgress(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPushVlanOnEgress, error) {
8885 _bsntlvpushvlanonegress := &BsnTlvPushVlanOnEgress{BsnTlv: parent}
8886 return _bsntlvpushvlanonegress, nil
8887}
8888
8889func NewBsnTlvPushVlanOnEgress() *BsnTlvPushVlanOnEgress {
8890 obj := &BsnTlvPushVlanOnEgress{
8891 BsnTlv: NewBsnTlv(162),
8892 }
8893 return obj
8894}
8895
8896type BsnTlvPushVlanOnIngress struct {
8897 *BsnTlv
8898 Flags BsnPushVlan
8899}
8900
8901type IBsnTlvPushVlanOnIngress interface {
8902 IBsnTlv
8903 GetFlags() BsnPushVlan
8904}
8905
8906func (self *BsnTlvPushVlanOnIngress) GetFlags() BsnPushVlan {
8907 return self.Flags
8908}
8909
8910func (self *BsnTlvPushVlanOnIngress) SetFlags(v BsnPushVlan) {
8911 self.Flags = v
8912}
8913
8914func (self *BsnTlvPushVlanOnIngress) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8915 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8916 if err := self.BsnTlv.Serialize(encoder); err != nil {
8917 return err
8918 }
8919
8920 encoder.PutUint8(uint8(self.Flags))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8921 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8922
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8923 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8924
8925 return nil
8926}
8927
8928func DecodeBsnTlvPushVlanOnIngress(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPushVlanOnIngress, error) {
8929 _bsntlvpushvlanoningress := &BsnTlvPushVlanOnIngress{BsnTlv: parent}
8930 if decoder.Length() < 1 {
8931 return nil, fmt.Errorf("BsnTlvPushVlanOnIngress packet too short: %d < 1", decoder.Length())
8932 }
8933 _bsntlvpushvlanoningress.Flags = BsnPushVlan(decoder.ReadByte())
8934 return _bsntlvpushvlanoningress, nil
8935}
8936
8937func NewBsnTlvPushVlanOnIngress() *BsnTlvPushVlanOnIngress {
8938 obj := &BsnTlvPushVlanOnIngress{
8939 BsnTlv: NewBsnTlv(128),
8940 }
8941 return obj
8942}
8943
8944type BsnTlvQosPriority struct {
8945 *BsnTlv
8946 Value uint32
8947}
8948
8949type IBsnTlvQosPriority interface {
8950 IBsnTlv
8951 GetValue() uint32
8952}
8953
8954func (self *BsnTlvQosPriority) GetValue() uint32 {
8955 return self.Value
8956}
8957
8958func (self *BsnTlvQosPriority) SetValue(v uint32) {
8959 self.Value = v
8960}
8961
8962func (self *BsnTlvQosPriority) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8963 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8964 if err := self.BsnTlv.Serialize(encoder); err != nil {
8965 return err
8966 }
8967
8968 encoder.PutUint32(uint32(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8969 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8970
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]8971 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]8972
8973 return nil
8974}
8975
8976func DecodeBsnTlvQosPriority(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvQosPriority, error) {
8977 _bsntlvqospriority := &BsnTlvQosPriority{BsnTlv: parent}
8978 if decoder.Length() < 4 {
8979 return nil, fmt.Errorf("BsnTlvQosPriority packet too short: %d < 4", decoder.Length())
8980 }
8981 _bsntlvqospriority.Value = uint32(decoder.ReadUint32())
8982 return _bsntlvqospriority, nil
8983}
8984
8985func NewBsnTlvQosPriority() *BsnTlvQosPriority {
8986 obj := &BsnTlvQosPriority{
8987 BsnTlv: NewBsnTlv(108),
8988 }
8989 return obj
8990}
8991
8992type BsnTlvQueueId struct {
8993 *BsnTlv
8994 Value uint32
8995}
8996
8997type IBsnTlvQueueId interface {
8998 IBsnTlv
8999 GetValue() uint32
9000}
9001
9002func (self *BsnTlvQueueId) GetValue() uint32 {
9003 return self.Value
9004}
9005
9006func (self *BsnTlvQueueId) SetValue(v uint32) {
9007 self.Value = v
9008}
9009
9010func (self *BsnTlvQueueId) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9011 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9012 if err := self.BsnTlv.Serialize(encoder); err != nil {
9013 return err
9014 }
9015
9016 encoder.PutUint32(uint32(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9017 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9018
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9019 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9020
9021 return nil
9022}
9023
9024func DecodeBsnTlvQueueId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvQueueId, error) {
9025 _bsntlvqueueid := &BsnTlvQueueId{BsnTlv: parent}
9026 if decoder.Length() < 4 {
9027 return nil, fmt.Errorf("BsnTlvQueueId packet too short: %d < 4", decoder.Length())
9028 }
9029 _bsntlvqueueid.Value = uint32(decoder.ReadUint32())
9030 return _bsntlvqueueid, nil
9031}
9032
9033func NewBsnTlvQueueId() *BsnTlvQueueId {
9034 obj := &BsnTlvQueueId{
9035 BsnTlv: NewBsnTlv(20),
9036 }
9037 return obj
9038}
9039
9040type BsnTlvQueueWeight struct {
9041 *BsnTlv
9042 Value uint32
9043}
9044
9045type IBsnTlvQueueWeight interface {
9046 IBsnTlv
9047 GetValue() uint32
9048}
9049
9050func (self *BsnTlvQueueWeight) GetValue() uint32 {
9051 return self.Value
9052}
9053
9054func (self *BsnTlvQueueWeight) SetValue(v uint32) {
9055 self.Value = v
9056}
9057
9058func (self *BsnTlvQueueWeight) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9059 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9060 if err := self.BsnTlv.Serialize(encoder); err != nil {
9061 return err
9062 }
9063
9064 encoder.PutUint32(uint32(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9065 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9066
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9067 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9068
9069 return nil
9070}
9071
9072func DecodeBsnTlvQueueWeight(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvQueueWeight, error) {
9073 _bsntlvqueueweight := &BsnTlvQueueWeight{BsnTlv: parent}
9074 if decoder.Length() < 4 {
9075 return nil, fmt.Errorf("BsnTlvQueueWeight packet too short: %d < 4", decoder.Length())
9076 }
9077 _bsntlvqueueweight.Value = uint32(decoder.ReadUint32())
9078 return _bsntlvqueueweight, nil
9079}
9080
9081func NewBsnTlvQueueWeight() *BsnTlvQueueWeight {
9082 obj := &BsnTlvQueueWeight{
9083 BsnTlv: NewBsnTlv(21),
9084 }
9085 return obj
9086}
9087
9088type BsnTlvRateLimit struct {
9089 *BsnTlv
9090 Value uint32
9091}
9092
9093type IBsnTlvRateLimit interface {
9094 IBsnTlv
9095 GetValue() uint32
9096}
9097
9098func (self *BsnTlvRateLimit) GetValue() uint32 {
9099 return self.Value
9100}
9101
9102func (self *BsnTlvRateLimit) SetValue(v uint32) {
9103 self.Value = v
9104}
9105
9106func (self *BsnTlvRateLimit) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9107 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9108 if err := self.BsnTlv.Serialize(encoder); err != nil {
9109 return err
9110 }
9111
9112 encoder.PutUint32(uint32(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9113 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9114
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9115 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9116
9117 return nil
9118}
9119
9120func DecodeBsnTlvRateLimit(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRateLimit, error) {
9121 _bsntlvratelimit := &BsnTlvRateLimit{BsnTlv: parent}
9122 if decoder.Length() < 4 {
9123 return nil, fmt.Errorf("BsnTlvRateLimit packet too short: %d < 4", decoder.Length())
9124 }
9125 _bsntlvratelimit.Value = uint32(decoder.ReadUint32())
9126 return _bsntlvratelimit, nil
9127}
9128
9129func NewBsnTlvRateLimit() *BsnTlvRateLimit {
9130 obj := &BsnTlvRateLimit{
9131 BsnTlv: NewBsnTlv(116),
9132 }
9133 return obj
9134}
9135
9136type BsnTlvRateUnit struct {
9137 *BsnTlv
9138 Value BsnRateUnit
9139}
9140
9141type IBsnTlvRateUnit interface {
9142 IBsnTlv
9143 GetValue() BsnRateUnit
9144}
9145
9146func (self *BsnTlvRateUnit) GetValue() BsnRateUnit {
9147 return self.Value
9148}
9149
9150func (self *BsnTlvRateUnit) SetValue(v BsnRateUnit) {
9151 self.Value = v
9152}
9153
9154func (self *BsnTlvRateUnit) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9155 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9156 if err := self.BsnTlv.Serialize(encoder); err != nil {
9157 return err
9158 }
9159
9160 encoder.PutUint8(uint8(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9161 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9162
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9163 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9164
9165 return nil
9166}
9167
9168func DecodeBsnTlvRateUnit(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRateUnit, error) {
9169 _bsntlvrateunit := &BsnTlvRateUnit{BsnTlv: parent}
9170 if decoder.Length() < 1 {
9171 return nil, fmt.Errorf("BsnTlvRateUnit packet too short: %d < 1", decoder.Length())
9172 }
9173 _bsntlvrateunit.Value = BsnRateUnit(decoder.ReadByte())
9174 return _bsntlvrateunit, nil
9175}
9176
9177func NewBsnTlvRateUnit() *BsnTlvRateUnit {
9178 obj := &BsnTlvRateUnit{
9179 BsnTlv: NewBsnTlv(89),
9180 }
9181 return obj
9182}
9183
9184type BsnTlvRecordPackets struct {
9185 *BsnTlv
9186 Value uint32
9187}
9188
9189type IBsnTlvRecordPackets interface {
9190 IBsnTlv
9191 GetValue() uint32
9192}
9193
9194func (self *BsnTlvRecordPackets) GetValue() uint32 {
9195 return self.Value
9196}
9197
9198func (self *BsnTlvRecordPackets) SetValue(v uint32) {
9199 self.Value = v
9200}
9201
9202func (self *BsnTlvRecordPackets) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9203 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9204 if err := self.BsnTlv.Serialize(encoder); err != nil {
9205 return err
9206 }
9207
9208 encoder.PutUint32(uint32(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9209 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9210
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9211 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9212
9213 return nil
9214}
9215
9216func DecodeBsnTlvRecordPackets(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRecordPackets, error) {
9217 _bsntlvrecordpackets := &BsnTlvRecordPackets{BsnTlv: parent}
9218 if decoder.Length() < 4 {
9219 return nil, fmt.Errorf("BsnTlvRecordPackets packet too short: %d < 4", decoder.Length())
9220 }
9221 _bsntlvrecordpackets.Value = uint32(decoder.ReadUint32())
9222 return _bsntlvrecordpackets, nil
9223}
9224
9225func NewBsnTlvRecordPackets() *BsnTlvRecordPackets {
9226 obj := &BsnTlvRecordPackets{
9227 BsnTlv: NewBsnTlv(155),
9228 }
9229 return obj
9230}
9231
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9232type BsnTlvRedundantMgmt struct {
9233 *BsnTlv
9234}
9235
9236type IBsnTlvRedundantMgmt interface {
9237 IBsnTlv
9238}
9239
9240func (self *BsnTlvRedundantMgmt) Serialize(encoder *goloxi.Encoder) error {
9241 startIndex := len(encoder.Bytes())
9242 if err := self.BsnTlv.Serialize(encoder); err != nil {
9243 return err
9244 }
9245 length := len(encoder.Bytes()) - startIndex
9246
9247 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9248
9249 return nil
9250}
9251
9252func DecodeBsnTlvRedundantMgmt(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRedundantMgmt, error) {
9253 _bsntlvredundantmgmt := &BsnTlvRedundantMgmt{BsnTlv: parent}
9254 return _bsntlvredundantmgmt, nil
9255}
9256
9257func NewBsnTlvRedundantMgmt() *BsnTlvRedundantMgmt {
9258 obj := &BsnTlvRedundantMgmt{
9259 BsnTlv: NewBsnTlv(189),
9260 }
9261 return obj
9262}
9263
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9264type BsnTlvReference struct {
9265 *BsnTlv
9266 TableId uint16
9267 Key []IBsnTlv
9268}
9269
9270type IBsnTlvReference interface {
9271 IBsnTlv
9272 GetTableId() uint16
9273 GetKey() []IBsnTlv
9274}
9275
9276func (self *BsnTlvReference) GetTableId() uint16 {
9277 return self.TableId
9278}
9279
9280func (self *BsnTlvReference) SetTableId(v uint16) {
9281 self.TableId = v
9282}
9283
9284func (self *BsnTlvReference) GetKey() []IBsnTlv {
9285 return self.Key
9286}
9287
9288func (self *BsnTlvReference) SetKey(v []IBsnTlv) {
9289 self.Key = v
9290}
9291
9292func (self *BsnTlvReference) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9293 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9294 if err := self.BsnTlv.Serialize(encoder); err != nil {
9295 return err
9296 }
9297
9298 encoder.PutUint16(uint16(self.TableId))
9299 for _, obj := range self.Key {
9300 if err := obj.Serialize(encoder); err != nil {
9301 return err
9302 }
9303 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9304 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9305
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9306 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9307
9308 return nil
9309}
9310
9311func DecodeBsnTlvReference(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvReference, error) {
9312 _bsntlvreference := &BsnTlvReference{BsnTlv: parent}
9313 if decoder.Length() < 2 {
9314 return nil, fmt.Errorf("BsnTlvReference packet too short: %d < 2", decoder.Length())
9315 }
9316 _bsntlvreference.TableId = uint16(decoder.ReadUint16())
9317
9318 for decoder.Length() >= 4 {
9319 item, err := DecodeBsnTlv(decoder)
9320 if err != nil {
9321 return nil, err
9322 }
9323 if item != nil {
9324 _bsntlvreference.Key = append(_bsntlvreference.Key, item)
9325 }
9326 }
9327 return _bsntlvreference, nil
9328}
9329
9330func NewBsnTlvReference() *BsnTlvReference {
9331 obj := &BsnTlvReference{
9332 BsnTlv: NewBsnTlv(59),
9333 }
9334 return obj
9335}
9336
9337type BsnTlvReplyPackets struct {
9338 *BsnTlv
9339 Value uint64
9340}
9341
9342type IBsnTlvReplyPackets interface {
9343 IBsnTlv
9344 GetValue() uint64
9345}
9346
9347func (self *BsnTlvReplyPackets) GetValue() uint64 {
9348 return self.Value
9349}
9350
9351func (self *BsnTlvReplyPackets) SetValue(v uint64) {
9352 self.Value = v
9353}
9354
9355func (self *BsnTlvReplyPackets) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9356 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9357 if err := self.BsnTlv.Serialize(encoder); err != nil {
9358 return err
9359 }
9360
9361 encoder.PutUint64(uint64(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9362 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9363
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9364 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9365
9366 return nil
9367}
9368
9369func DecodeBsnTlvReplyPackets(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvReplyPackets, error) {
9370 _bsntlvreplypackets := &BsnTlvReplyPackets{BsnTlv: parent}
9371 if decoder.Length() < 8 {
9372 return nil, fmt.Errorf("BsnTlvReplyPackets packet too short: %d < 8", decoder.Length())
9373 }
9374 _bsntlvreplypackets.Value = uint64(decoder.ReadUint64())
9375 return _bsntlvreplypackets, nil
9376}
9377
9378func NewBsnTlvReplyPackets() *BsnTlvReplyPackets {
9379 obj := &BsnTlvReplyPackets{
9380 BsnTlv: NewBsnTlv(12),
9381 }
9382 return obj
9383}
9384
9385type BsnTlvRequestPackets struct {
9386 *BsnTlv
9387 Value uint64
9388}
9389
9390type IBsnTlvRequestPackets interface {
9391 IBsnTlv
9392 GetValue() uint64
9393}
9394
9395func (self *BsnTlvRequestPackets) GetValue() uint64 {
9396 return self.Value
9397}
9398
9399func (self *BsnTlvRequestPackets) SetValue(v uint64) {
9400 self.Value = v
9401}
9402
9403func (self *BsnTlvRequestPackets) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9404 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9405 if err := self.BsnTlv.Serialize(encoder); err != nil {
9406 return err
9407 }
9408
9409 encoder.PutUint64(uint64(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9410 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9411
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9412 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9413
9414 return nil
9415}
9416
9417func DecodeBsnTlvRequestPackets(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRequestPackets, error) {
9418 _bsntlvrequestpackets := &BsnTlvRequestPackets{BsnTlv: parent}
9419 if decoder.Length() < 8 {
9420 return nil, fmt.Errorf("BsnTlvRequestPackets packet too short: %d < 8", decoder.Length())
9421 }
9422 _bsntlvrequestpackets.Value = uint64(decoder.ReadUint64())
9423 return _bsntlvrequestpackets, nil
9424}
9425
9426func NewBsnTlvRequestPackets() *BsnTlvRequestPackets {
9427 obj := &BsnTlvRequestPackets{
9428 BsnTlv: NewBsnTlv(11),
9429 }
9430 return obj
9431}
9432
9433type BsnTlvRestServer struct {
9434 *BsnTlv
9435}
9436
9437type IBsnTlvRestServer interface {
9438 IBsnTlv
9439}
9440
9441func (self *BsnTlvRestServer) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9442 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9443 if err := self.BsnTlv.Serialize(encoder); err != nil {
9444 return err
9445 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9446 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9447
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9448 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9449
9450 return nil
9451}
9452
9453func DecodeBsnTlvRestServer(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRestServer, error) {
9454 _bsntlvrestserver := &BsnTlvRestServer{BsnTlv: parent}
9455 return _bsntlvrestserver, nil
9456}
9457
9458func NewBsnTlvRestServer() *BsnTlvRestServer {
9459 obj := &BsnTlvRestServer{
9460 BsnTlv: NewBsnTlv(152),
9461 }
9462 return obj
9463}
9464
9465type BsnTlvRoutingParam struct {
9466 *BsnTlv
9467 Value BsnRoutingParam
9468}
9469
9470type IBsnTlvRoutingParam interface {
9471 IBsnTlv
9472 GetValue() BsnRoutingParam
9473}
9474
9475func (self *BsnTlvRoutingParam) GetValue() BsnRoutingParam {
9476 return self.Value
9477}
9478
9479func (self *BsnTlvRoutingParam) SetValue(v BsnRoutingParam) {
9480 self.Value = v
9481}
9482
9483func (self *BsnTlvRoutingParam) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9484 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9485 if err := self.BsnTlv.Serialize(encoder); err != nil {
9486 return err
9487 }
9488
9489 encoder.PutUint16(uint16(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9490 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9491
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9492 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9493
9494 return nil
9495}
9496
9497func DecodeBsnTlvRoutingParam(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRoutingParam, error) {
9498 _bsntlvroutingparam := &BsnTlvRoutingParam{BsnTlv: parent}
9499 if decoder.Length() < 2 {
9500 return nil, fmt.Errorf("BsnTlvRoutingParam packet too short: %d < 2", decoder.Length())
9501 }
9502 _bsntlvroutingparam.Value = BsnRoutingParam(decoder.ReadUint16())
9503 return _bsntlvroutingparam, nil
9504}
9505
9506func NewBsnTlvRoutingParam() *BsnTlvRoutingParam {
9507 obj := &BsnTlvRoutingParam{
9508 BsnTlv: NewBsnTlv(161),
9509 }
9510 return obj
9511}
9512
9513type BsnTlvRxBytes struct {
9514 *BsnTlv
9515 Value uint64
9516}
9517
9518type IBsnTlvRxBytes interface {
9519 IBsnTlv
9520 GetValue() uint64
9521}
9522
9523func (self *BsnTlvRxBytes) GetValue() uint64 {
9524 return self.Value
9525}
9526
9527func (self *BsnTlvRxBytes) SetValue(v uint64) {
9528 self.Value = v
9529}
9530
9531func (self *BsnTlvRxBytes) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9532 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9533 if err := self.BsnTlv.Serialize(encoder); err != nil {
9534 return err
9535 }
9536
9537 encoder.PutUint64(uint64(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9538 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9539
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9540 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9541
9542 return nil
9543}
9544
9545func DecodeBsnTlvRxBytes(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRxBytes, error) {
9546 _bsntlvrxbytes := &BsnTlvRxBytes{BsnTlv: parent}
9547 if decoder.Length() < 8 {
9548 return nil, fmt.Errorf("BsnTlvRxBytes packet too short: %d < 8", decoder.Length())
9549 }
9550 _bsntlvrxbytes.Value = uint64(decoder.ReadUint64())
9551 return _bsntlvrxbytes, nil
9552}
9553
9554func NewBsnTlvRxBytes() *BsnTlvRxBytes {
9555 obj := &BsnTlvRxBytes{
9556 BsnTlv: NewBsnTlv(71),
9557 }
9558 return obj
9559}
9560
9561type BsnTlvRxPackets struct {
9562 *BsnTlv
9563 Value uint64
9564}
9565
9566type IBsnTlvRxPackets interface {
9567 IBsnTlv
9568 GetValue() uint64
9569}
9570
9571func (self *BsnTlvRxPackets) GetValue() uint64 {
9572 return self.Value
9573}
9574
9575func (self *BsnTlvRxPackets) SetValue(v uint64) {
9576 self.Value = v
9577}
9578
9579func (self *BsnTlvRxPackets) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9580 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9581 if err := self.BsnTlv.Serialize(encoder); err != nil {
9582 return err
9583 }
9584
9585 encoder.PutUint64(uint64(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9586 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9587
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9588 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9589
9590 return nil
9591}
9592
9593func DecodeBsnTlvRxPackets(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRxPackets, error) {
9594 _bsntlvrxpackets := &BsnTlvRxPackets{BsnTlv: parent}
9595 if decoder.Length() < 8 {
9596 return nil, fmt.Errorf("BsnTlvRxPackets packet too short: %d < 8", decoder.Length())
9597 }
9598 _bsntlvrxpackets.Value = uint64(decoder.ReadUint64())
9599 return _bsntlvrxpackets, nil
9600}
9601
9602func NewBsnTlvRxPackets() *BsnTlvRxPackets {
9603 obj := &BsnTlvRxPackets{
9604 BsnTlv: NewBsnTlv(2),
9605 }
9606 return obj
9607}
9608
9609type BsnTlvSamplingRate struct {
9610 *BsnTlv
9611 Value uint32
9612}
9613
9614type IBsnTlvSamplingRate interface {
9615 IBsnTlv
9616 GetValue() uint32
9617}
9618
9619func (self *BsnTlvSamplingRate) GetValue() uint32 {
9620 return self.Value
9621}
9622
9623func (self *BsnTlvSamplingRate) SetValue(v uint32) {
9624 self.Value = v
9625}
9626
9627func (self *BsnTlvSamplingRate) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9628 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9629 if err := self.BsnTlv.Serialize(encoder); err != nil {
9630 return err
9631 }
9632
9633 encoder.PutUint32(uint32(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9634 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9635
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9636 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9637
9638 return nil
9639}
9640
9641func DecodeBsnTlvSamplingRate(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvSamplingRate, error) {
9642 _bsntlvsamplingrate := &BsnTlvSamplingRate{BsnTlv: parent}
9643 if decoder.Length() < 4 {
9644 return nil, fmt.Errorf("BsnTlvSamplingRate packet too short: %d < 4", decoder.Length())
9645 }
9646 _bsntlvsamplingrate.Value = uint32(decoder.ReadUint32())
9647 return _bsntlvsamplingrate, nil
9648}
9649
9650func NewBsnTlvSamplingRate() *BsnTlvSamplingRate {
9651 obj := &BsnTlvSamplingRate{
9652 BsnTlv: NewBsnTlv(30),
9653 }
9654 return obj
9655}
9656
9657type BsnTlvSetLoopbackMode struct {
9658 *BsnTlv
9659}
9660
9661type IBsnTlvSetLoopbackMode interface {
9662 IBsnTlv
9663}
9664
9665func (self *BsnTlvSetLoopbackMode) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9666 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9667 if err := self.BsnTlv.Serialize(encoder); err != nil {
9668 return err
9669 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9670 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9671
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9672 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9673
9674 return nil
9675}
9676
9677func DecodeBsnTlvSetLoopbackMode(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvSetLoopbackMode, error) {
9678 _bsntlvsetloopbackmode := &BsnTlvSetLoopbackMode{BsnTlv: parent}
9679 return _bsntlvsetloopbackmode, nil
9680}
9681
9682func NewBsnTlvSetLoopbackMode() *BsnTlvSetLoopbackMode {
9683 obj := &BsnTlvSetLoopbackMode{
9684 BsnTlv: NewBsnTlv(74),
9685 }
9686 return obj
9687}
9688
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9689type BsnTlvSrcMacCml struct {
9690 *BsnTlv
9691 Value BsnCml
9692}
9693
9694type IBsnTlvSrcMacCml interface {
9695 IBsnTlv
9696 GetValue() BsnCml
9697}
9698
9699func (self *BsnTlvSrcMacCml) GetValue() BsnCml {
9700 return self.Value
9701}
9702
9703func (self *BsnTlvSrcMacCml) SetValue(v BsnCml) {
9704 self.Value = v
9705}
9706
9707func (self *BsnTlvSrcMacCml) Serialize(encoder *goloxi.Encoder) error {
9708 startIndex := len(encoder.Bytes())
9709 if err := self.BsnTlv.Serialize(encoder); err != nil {
9710 return err
9711 }
9712
9713 encoder.PutUint16(uint16(self.Value))
9714 length := len(encoder.Bytes()) - startIndex
9715
9716 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9717
9718 return nil
9719}
9720
9721func DecodeBsnTlvSrcMacCml(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvSrcMacCml, error) {
9722 _bsntlvsrcmaccml := &BsnTlvSrcMacCml{BsnTlv: parent}
9723 if decoder.Length() < 2 {
9724 return nil, fmt.Errorf("BsnTlvSrcMacCml packet too short: %d < 2", decoder.Length())
9725 }
9726 _bsntlvsrcmaccml.Value = BsnCml(decoder.ReadUint16())
9727 return _bsntlvsrcmaccml, nil
9728}
9729
9730func NewBsnTlvSrcMacCml() *BsnTlvSrcMacCml {
9731 obj := &BsnTlvSrcMacCml{
9732 BsnTlv: NewBsnTlv(191),
9733 }
9734 return obj
9735}
9736
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9737type BsnTlvStatus struct {
9738 *BsnTlv
9739 Value BsnStatus
9740}
9741
9742type IBsnTlvStatus interface {
9743 IBsnTlv
9744 GetValue() BsnStatus
9745}
9746
9747func (self *BsnTlvStatus) GetValue() BsnStatus {
9748 return self.Value
9749}
9750
9751func (self *BsnTlvStatus) SetValue(v BsnStatus) {
9752 self.Value = v
9753}
9754
9755func (self *BsnTlvStatus) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9756 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9757 if err := self.BsnTlv.Serialize(encoder); err != nil {
9758 return err
9759 }
9760
9761 encoder.PutUint8(uint8(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9762 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9763
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9764 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9765
9766 return nil
9767}
9768
9769func DecodeBsnTlvStatus(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvStatus, error) {
9770 _bsntlvstatus := &BsnTlvStatus{BsnTlv: parent}
9771 if decoder.Length() < 1 {
9772 return nil, fmt.Errorf("BsnTlvStatus packet too short: %d < 1", decoder.Length())
9773 }
9774 _bsntlvstatus.Value = BsnStatus(decoder.ReadByte())
9775 return _bsntlvstatus, nil
9776}
9777
9778func NewBsnTlvStatus() *BsnTlvStatus {
9779 obj := &BsnTlvStatus{
9780 BsnTlv: NewBsnTlv(97),
9781 }
9782 return obj
9783}
9784
9785type BsnTlvStripMplsL2OnIngress struct {
9786 *BsnTlv
9787}
9788
9789type IBsnTlvStripMplsL2OnIngress interface {
9790 IBsnTlv
9791}
9792
9793func (self *BsnTlvStripMplsL2OnIngress) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9794 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9795 if err := self.BsnTlv.Serialize(encoder); err != nil {
9796 return err
9797 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9798 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9799
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9800 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9801
9802 return nil
9803}
9804
9805func DecodeBsnTlvStripMplsL2OnIngress(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvStripMplsL2OnIngress, error) {
9806 _bsntlvstripmplsl2oningress := &BsnTlvStripMplsL2OnIngress{BsnTlv: parent}
9807 return _bsntlvstripmplsl2oningress, nil
9808}
9809
9810func NewBsnTlvStripMplsL2OnIngress() *BsnTlvStripMplsL2OnIngress {
9811 obj := &BsnTlvStripMplsL2OnIngress{
9812 BsnTlv: NewBsnTlv(75),
9813 }
9814 return obj
9815}
9816
9817type BsnTlvStripMplsL3OnIngress struct {
9818 *BsnTlv
9819}
9820
9821type IBsnTlvStripMplsL3OnIngress interface {
9822 IBsnTlv
9823}
9824
9825func (self *BsnTlvStripMplsL3OnIngress) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9826 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9827 if err := self.BsnTlv.Serialize(encoder); err != nil {
9828 return err
9829 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9830 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9831
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9832 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9833
9834 return nil
9835}
9836
9837func DecodeBsnTlvStripMplsL3OnIngress(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvStripMplsL3OnIngress, error) {
9838 _bsntlvstripmplsl3oningress := &BsnTlvStripMplsL3OnIngress{BsnTlv: parent}
9839 return _bsntlvstripmplsl3oningress, nil
9840}
9841
9842func NewBsnTlvStripMplsL3OnIngress() *BsnTlvStripMplsL3OnIngress {
9843 obj := &BsnTlvStripMplsL3OnIngress{
9844 BsnTlv: NewBsnTlv(76),
9845 }
9846 return obj
9847}
9848
9849type BsnTlvStripVlanOnEgress struct {
9850 *BsnTlv
9851 Flags BsnStripVlan
9852}
9853
9854type IBsnTlvStripVlanOnEgress interface {
9855 IBsnTlv
9856 GetFlags() BsnStripVlan
9857}
9858
9859func (self *BsnTlvStripVlanOnEgress) GetFlags() BsnStripVlan {
9860 return self.Flags
9861}
9862
9863func (self *BsnTlvStripVlanOnEgress) SetFlags(v BsnStripVlan) {
9864 self.Flags = v
9865}
9866
9867func (self *BsnTlvStripVlanOnEgress) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9868 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9869 if err := self.BsnTlv.Serialize(encoder); err != nil {
9870 return err
9871 }
9872
9873 encoder.PutUint8(uint8(self.Flags))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9874 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9875
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9876 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9877
9878 return nil
9879}
9880
9881func DecodeBsnTlvStripVlanOnEgress(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvStripVlanOnEgress, error) {
9882 _bsntlvstripvlanonegress := &BsnTlvStripVlanOnEgress{BsnTlv: parent}
9883 if decoder.Length() < 1 {
9884 return nil, fmt.Errorf("BsnTlvStripVlanOnEgress packet too short: %d < 1", decoder.Length())
9885 }
9886 _bsntlvstripvlanonegress.Flags = BsnStripVlan(decoder.ReadByte())
9887 return _bsntlvstripvlanonegress, nil
9888}
9889
9890func NewBsnTlvStripVlanOnEgress() *BsnTlvStripVlanOnEgress {
9891 obj := &BsnTlvStripVlanOnEgress{
9892 BsnTlv: NewBsnTlv(73),
9893 }
9894 return obj
9895}
9896
9897type BsnTlvSubAgentId struct {
9898 *BsnTlv
9899 Value uint32
9900}
9901
9902type IBsnTlvSubAgentId interface {
9903 IBsnTlv
9904 GetValue() uint32
9905}
9906
9907func (self *BsnTlvSubAgentId) GetValue() uint32 {
9908 return self.Value
9909}
9910
9911func (self *BsnTlvSubAgentId) SetValue(v uint32) {
9912 self.Value = v
9913}
9914
9915func (self *BsnTlvSubAgentId) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9916 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9917 if err := self.BsnTlv.Serialize(encoder); err != nil {
9918 return err
9919 }
9920
9921 encoder.PutUint32(uint32(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9922 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9923
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9924 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9925
9926 return nil
9927}
9928
9929func DecodeBsnTlvSubAgentId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvSubAgentId, error) {
9930 _bsntlvsubagentid := &BsnTlvSubAgentId{BsnTlv: parent}
9931 if decoder.Length() < 4 {
9932 return nil, fmt.Errorf("BsnTlvSubAgentId packet too short: %d < 4", decoder.Length())
9933 }
9934 _bsntlvsubagentid.Value = uint32(decoder.ReadUint32())
9935 return _bsntlvsubagentid, nil
9936}
9937
9938func NewBsnTlvSubAgentId() *BsnTlvSubAgentId {
9939 obj := &BsnTlvSubAgentId{
9940 BsnTlv: NewBsnTlv(38),
9941 }
9942 return obj
9943}
9944
9945type BsnTlvTcpDst struct {
9946 *BsnTlv
9947 Value uint16
9948}
9949
9950type IBsnTlvTcpDst interface {
9951 IBsnTlv
9952 GetValue() uint16
9953}
9954
9955func (self *BsnTlvTcpDst) GetValue() uint16 {
9956 return self.Value
9957}
9958
9959func (self *BsnTlvTcpDst) SetValue(v uint16) {
9960 self.Value = v
9961}
9962
9963func (self *BsnTlvTcpDst) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9964 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9965 if err := self.BsnTlv.Serialize(encoder); err != nil {
9966 return err
9967 }
9968
9969 encoder.PutUint16(uint16(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9970 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9971
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]9972 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]9973
9974 return nil
9975}
9976
9977func DecodeBsnTlvTcpDst(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTcpDst, error) {
9978 _bsntlvtcpdst := &BsnTlvTcpDst{BsnTlv: parent}
9979 if decoder.Length() < 2 {
9980 return nil, fmt.Errorf("BsnTlvTcpDst packet too short: %d < 2", decoder.Length())
9981 }
9982 _bsntlvtcpdst.Value = uint16(decoder.ReadUint16())
9983 return _bsntlvtcpdst, nil
9984}
9985
9986func NewBsnTlvTcpDst() *BsnTlvTcpDst {
9987 obj := &BsnTlvTcpDst{
9988 BsnTlv: NewBsnTlv(66),
9989 }
9990 return obj
9991}
9992
9993type BsnTlvTcpFlags struct {
9994 *BsnTlv
9995 Value uint16
9996}
9997
9998type IBsnTlvTcpFlags interface {
9999 IBsnTlv
10000 GetValue() uint16
10001}
10002
10003func (self *BsnTlvTcpFlags) GetValue() uint16 {
10004 return self.Value
10005}
10006
10007func (self *BsnTlvTcpFlags) SetValue(v uint16) {
10008 self.Value = v
10009}
10010
10011func (self *BsnTlvTcpFlags) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10012 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10013 if err := self.BsnTlv.Serialize(encoder); err != nil {
10014 return err
10015 }
10016
10017 encoder.PutUint16(uint16(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10018 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10019
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10020 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10021
10022 return nil
10023}
10024
10025func DecodeBsnTlvTcpFlags(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTcpFlags, error) {
10026 _bsntlvtcpflags := &BsnTlvTcpFlags{BsnTlv: parent}
10027 if decoder.Length() < 2 {
10028 return nil, fmt.Errorf("BsnTlvTcpFlags packet too short: %d < 2", decoder.Length())
10029 }
10030 _bsntlvtcpflags.Value = uint16(decoder.ReadUint16())
10031 return _bsntlvtcpflags, nil
10032}
10033
10034func NewBsnTlvTcpFlags() *BsnTlvTcpFlags {
10035 obj := &BsnTlvTcpFlags{
10036 BsnTlv: NewBsnTlv(133),
10037 }
10038 return obj
10039}
10040
10041type BsnTlvTcpSrc struct {
10042 *BsnTlv
10043 Value uint16
10044}
10045
10046type IBsnTlvTcpSrc interface {
10047 IBsnTlv
10048 GetValue() uint16
10049}
10050
10051func (self *BsnTlvTcpSrc) GetValue() uint16 {
10052 return self.Value
10053}
10054
10055func (self *BsnTlvTcpSrc) SetValue(v uint16) {
10056 self.Value = v
10057}
10058
10059func (self *BsnTlvTcpSrc) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10060 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10061 if err := self.BsnTlv.Serialize(encoder); err != nil {
10062 return err
10063 }
10064
10065 encoder.PutUint16(uint16(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10066 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10067
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10068 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10069
10070 return nil
10071}
10072
10073func DecodeBsnTlvTcpSrc(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTcpSrc, error) {
10074 _bsntlvtcpsrc := &BsnTlvTcpSrc{BsnTlv: parent}
10075 if decoder.Length() < 2 {
10076 return nil, fmt.Errorf("BsnTlvTcpSrc packet too short: %d < 2", decoder.Length())
10077 }
10078 _bsntlvtcpsrc.Value = uint16(decoder.ReadUint16())
10079 return _bsntlvtcpsrc, nil
10080}
10081
10082func NewBsnTlvTcpSrc() *BsnTlvTcpSrc {
10083 obj := &BsnTlvTcpSrc{
10084 BsnTlv: NewBsnTlv(65),
10085 }
10086 return obj
10087}
10088
10089type BsnTlvTimestamp struct {
10090 *BsnTlv
10091 Value uint64
10092}
10093
10094type IBsnTlvTimestamp interface {
10095 IBsnTlv
10096 GetValue() uint64
10097}
10098
10099func (self *BsnTlvTimestamp) GetValue() uint64 {
10100 return self.Value
10101}
10102
10103func (self *BsnTlvTimestamp) SetValue(v uint64) {
10104 self.Value = v
10105}
10106
10107func (self *BsnTlvTimestamp) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10108 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10109 if err := self.BsnTlv.Serialize(encoder); err != nil {
10110 return err
10111 }
10112
10113 encoder.PutUint64(uint64(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10114 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10115
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10116 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10117
10118 return nil
10119}
10120
10121func DecodeBsnTlvTimestamp(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTimestamp, error) {
10122 _bsntlvtimestamp := &BsnTlvTimestamp{BsnTlv: parent}
10123 if decoder.Length() < 8 {
10124 return nil, fmt.Errorf("BsnTlvTimestamp packet too short: %d < 8", decoder.Length())
10125 }
10126 _bsntlvtimestamp.Value = uint64(decoder.ReadUint64())
10127 return _bsntlvtimestamp, nil
10128}
10129
10130func NewBsnTlvTimestamp() *BsnTlvTimestamp {
10131 obj := &BsnTlvTimestamp{
10132 BsnTlv: NewBsnTlv(154),
10133 }
10134 return obj
10135}
10136
10137type BsnTlvTtl struct {
10138 *BsnTlv
10139 Value uint16
10140}
10141
10142type IBsnTlvTtl interface {
10143 IBsnTlv
10144 GetValue() uint16
10145}
10146
10147func (self *BsnTlvTtl) GetValue() uint16 {
10148 return self.Value
10149}
10150
10151func (self *BsnTlvTtl) SetValue(v uint16) {
10152 self.Value = v
10153}
10154
10155func (self *BsnTlvTtl) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10156 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10157 if err := self.BsnTlv.Serialize(encoder); err != nil {
10158 return err
10159 }
10160
10161 encoder.PutUint16(uint16(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10162 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10163
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10164 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10165
10166 return nil
10167}
10168
10169func DecodeBsnTlvTtl(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTtl, error) {
10170 _bsntlvttl := &BsnTlvTtl{BsnTlv: parent}
10171 if decoder.Length() < 2 {
10172 return nil, fmt.Errorf("BsnTlvTtl packet too short: %d < 2", decoder.Length())
10173 }
10174 _bsntlvttl.Value = uint16(decoder.ReadUint16())
10175 return _bsntlvttl, nil
10176}
10177
10178func NewBsnTlvTtl() *BsnTlvTtl {
10179 obj := &BsnTlvTtl{
10180 BsnTlv: NewBsnTlv(113),
10181 }
10182 return obj
10183}
10184
10185type BsnTlvTunnelCapability struct {
10186 *BsnTlv
10187 Value BsnTunnelType
10188}
10189
10190type IBsnTlvTunnelCapability interface {
10191 IBsnTlv
10192 GetValue() BsnTunnelType
10193}
10194
10195func (self *BsnTlvTunnelCapability) GetValue() BsnTunnelType {
10196 return self.Value
10197}
10198
10199func (self *BsnTlvTunnelCapability) SetValue(v BsnTunnelType) {
10200 self.Value = v
10201}
10202
10203func (self *BsnTlvTunnelCapability) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10204 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10205 if err := self.BsnTlv.Serialize(encoder); err != nil {
10206 return err
10207 }
10208
10209 encoder.PutUint64(uint64(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10210 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10211
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10212 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10213
10214 return nil
10215}
10216
10217func DecodeBsnTlvTunnelCapability(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTunnelCapability, error) {
10218 _bsntlvtunnelcapability := &BsnTlvTunnelCapability{BsnTlv: parent}
10219 if decoder.Length() < 8 {
10220 return nil, fmt.Errorf("BsnTlvTunnelCapability packet too short: %d < 8", decoder.Length())
10221 }
10222 _bsntlvtunnelcapability.Value = BsnTunnelType(decoder.ReadUint64())
10223 return _bsntlvtunnelcapability, nil
10224}
10225
10226func NewBsnTlvTunnelCapability() *BsnTlvTunnelCapability {
10227 obj := &BsnTlvTunnelCapability{
10228 BsnTlv: NewBsnTlv(142),
10229 }
10230 return obj
10231}
10232
10233type BsnTlvTxBytes struct {
10234 *BsnTlv
10235 Value uint64
10236}
10237
10238type IBsnTlvTxBytes interface {
10239 IBsnTlv
10240 GetValue() uint64
10241}
10242
10243func (self *BsnTlvTxBytes) GetValue() uint64 {
10244 return self.Value
10245}
10246
10247func (self *BsnTlvTxBytes) SetValue(v uint64) {
10248 self.Value = v
10249}
10250
10251func (self *BsnTlvTxBytes) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10252 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10253 if err := self.BsnTlv.Serialize(encoder); err != nil {
10254 return err
10255 }
10256
10257 encoder.PutUint64(uint64(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10258 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10259
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10260 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10261
10262 return nil
10263}
10264
10265func DecodeBsnTlvTxBytes(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTxBytes, error) {
10266 _bsntlvtxbytes := &BsnTlvTxBytes{BsnTlv: parent}
10267 if decoder.Length() < 8 {
10268 return nil, fmt.Errorf("BsnTlvTxBytes packet too short: %d < 8", decoder.Length())
10269 }
10270 _bsntlvtxbytes.Value = uint64(decoder.ReadUint64())
10271 return _bsntlvtxbytes, nil
10272}
10273
10274func NewBsnTlvTxBytes() *BsnTlvTxBytes {
10275 obj := &BsnTlvTxBytes{
10276 BsnTlv: NewBsnTlv(39),
10277 }
10278 return obj
10279}
10280
10281type BsnTlvTxPackets struct {
10282 *BsnTlv
10283 Value uint64
10284}
10285
10286type IBsnTlvTxPackets interface {
10287 IBsnTlv
10288 GetValue() uint64
10289}
10290
10291func (self *BsnTlvTxPackets) GetValue() uint64 {
10292 return self.Value
10293}
10294
10295func (self *BsnTlvTxPackets) SetValue(v uint64) {
10296 self.Value = v
10297}
10298
10299func (self *BsnTlvTxPackets) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10300 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10301 if err := self.BsnTlv.Serialize(encoder); err != nil {
10302 return err
10303 }
10304
10305 encoder.PutUint64(uint64(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10306 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10307
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10308 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10309
10310 return nil
10311}
10312
10313func DecodeBsnTlvTxPackets(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTxPackets, error) {
10314 _bsntlvtxpackets := &BsnTlvTxPackets{BsnTlv: parent}
10315 if decoder.Length() < 8 {
10316 return nil, fmt.Errorf("BsnTlvTxPackets packet too short: %d < 8", decoder.Length())
10317 }
10318 _bsntlvtxpackets.Value = uint64(decoder.ReadUint64())
10319 return _bsntlvtxpackets, nil
10320}
10321
10322func NewBsnTlvTxPackets() *BsnTlvTxPackets {
10323 obj := &BsnTlvTxPackets{
10324 BsnTlv: NewBsnTlv(3),
10325 }
10326 return obj
10327}
10328
10329type BsnTlvUdfAnchor struct {
10330 *BsnTlv
10331 Value BsnUdfAnchor
10332}
10333
10334type IBsnTlvUdfAnchor interface {
10335 IBsnTlv
10336 GetValue() BsnUdfAnchor
10337}
10338
10339func (self *BsnTlvUdfAnchor) GetValue() BsnUdfAnchor {
10340 return self.Value
10341}
10342
10343func (self *BsnTlvUdfAnchor) SetValue(v BsnUdfAnchor) {
10344 self.Value = v
10345}
10346
10347func (self *BsnTlvUdfAnchor) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10348 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10349 if err := self.BsnTlv.Serialize(encoder); err != nil {
10350 return err
10351 }
10352
10353 encoder.PutUint16(uint16(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10354 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10355
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10356 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10357
10358 return nil
10359}
10360
10361func DecodeBsnTlvUdfAnchor(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUdfAnchor, error) {
10362 _bsntlvudfanchor := &BsnTlvUdfAnchor{BsnTlv: parent}
10363 if decoder.Length() < 2 {
10364 return nil, fmt.Errorf("BsnTlvUdfAnchor packet too short: %d < 2", decoder.Length())
10365 }
10366 _bsntlvudfanchor.Value = BsnUdfAnchor(decoder.ReadUint16())
10367 return _bsntlvudfanchor, nil
10368}
10369
10370func NewBsnTlvUdfAnchor() *BsnTlvUdfAnchor {
10371 obj := &BsnTlvUdfAnchor{
10372 BsnTlv: NewBsnTlv(16),
10373 }
10374 return obj
10375}
10376
10377type BsnTlvUdfCapability struct {
10378 *BsnTlv
10379 Value BsnUdfMode
10380}
10381
10382type IBsnTlvUdfCapability interface {
10383 IBsnTlv
10384 GetValue() BsnUdfMode
10385}
10386
10387func (self *BsnTlvUdfCapability) GetValue() BsnUdfMode {
10388 return self.Value
10389}
10390
10391func (self *BsnTlvUdfCapability) SetValue(v BsnUdfMode) {
10392 self.Value = v
10393}
10394
10395func (self *BsnTlvUdfCapability) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10396 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10397 if err := self.BsnTlv.Serialize(encoder); err != nil {
10398 return err
10399 }
10400
10401 encoder.PutUint8(uint8(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10402 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10403
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10404 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10405
10406 return nil
10407}
10408
10409func DecodeBsnTlvUdfCapability(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUdfCapability, error) {
10410 _bsntlvudfcapability := &BsnTlvUdfCapability{BsnTlv: parent}
10411 if decoder.Length() < 1 {
10412 return nil, fmt.Errorf("BsnTlvUdfCapability packet too short: %d < 1", decoder.Length())
10413 }
10414 _bsntlvudfcapability.Value = BsnUdfMode(decoder.ReadByte())
10415 return _bsntlvudfcapability, nil
10416}
10417
10418func NewBsnTlvUdfCapability() *BsnTlvUdfCapability {
10419 obj := &BsnTlvUdfCapability{
10420 BsnTlv: NewBsnTlv(180),
10421 }
10422 return obj
10423}
10424
10425type BsnTlvUdfId struct {
10426 *BsnTlv
10427 Value uint16
10428}
10429
10430type IBsnTlvUdfId interface {
10431 IBsnTlv
10432 GetValue() uint16
10433}
10434
10435func (self *BsnTlvUdfId) GetValue() uint16 {
10436 return self.Value
10437}
10438
10439func (self *BsnTlvUdfId) SetValue(v uint16) {
10440 self.Value = v
10441}
10442
10443func (self *BsnTlvUdfId) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10444 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10445 if err := self.BsnTlv.Serialize(encoder); err != nil {
10446 return err
10447 }
10448
10449 encoder.PutUint16(uint16(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10450 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10451
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10452 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10453
10454 return nil
10455}
10456
10457func DecodeBsnTlvUdfId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUdfId, error) {
10458 _bsntlvudfid := &BsnTlvUdfId{BsnTlv: parent}
10459 if decoder.Length() < 2 {
10460 return nil, fmt.Errorf("BsnTlvUdfId packet too short: %d < 2", decoder.Length())
10461 }
10462 _bsntlvudfid.Value = uint16(decoder.ReadUint16())
10463 return _bsntlvudfid, nil
10464}
10465
10466func NewBsnTlvUdfId() *BsnTlvUdfId {
10467 obj := &BsnTlvUdfId{
10468 BsnTlv: NewBsnTlv(15),
10469 }
10470 return obj
10471}
10472
10473type BsnTlvUdfLength struct {
10474 *BsnTlv
10475 Value uint16
10476}
10477
10478type IBsnTlvUdfLength interface {
10479 IBsnTlv
10480 GetValue() uint16
10481}
10482
10483func (self *BsnTlvUdfLength) GetValue() uint16 {
10484 return self.Value
10485}
10486
10487func (self *BsnTlvUdfLength) SetValue(v uint16) {
10488 self.Value = v
10489}
10490
10491func (self *BsnTlvUdfLength) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10492 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10493 if err := self.BsnTlv.Serialize(encoder); err != nil {
10494 return err
10495 }
10496
10497 encoder.PutUint16(uint16(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10498 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10499
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10500 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10501
10502 return nil
10503}
10504
10505func DecodeBsnTlvUdfLength(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUdfLength, error) {
10506 _bsntlvudflength := &BsnTlvUdfLength{BsnTlv: parent}
10507 if decoder.Length() < 2 {
10508 return nil, fmt.Errorf("BsnTlvUdfLength packet too short: %d < 2", decoder.Length())
10509 }
10510 _bsntlvudflength.Value = uint16(decoder.ReadUint16())
10511 return _bsntlvudflength, nil
10512}
10513
10514func NewBsnTlvUdfLength() *BsnTlvUdfLength {
10515 obj := &BsnTlvUdfLength{
10516 BsnTlv: NewBsnTlv(18),
10517 }
10518 return obj
10519}
10520
10521type BsnTlvUdfOffset struct {
10522 *BsnTlv
10523 Value uint16
10524}
10525
10526type IBsnTlvUdfOffset interface {
10527 IBsnTlv
10528 GetValue() uint16
10529}
10530
10531func (self *BsnTlvUdfOffset) GetValue() uint16 {
10532 return self.Value
10533}
10534
10535func (self *BsnTlvUdfOffset) SetValue(v uint16) {
10536 self.Value = v
10537}
10538
10539func (self *BsnTlvUdfOffset) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10540 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10541 if err := self.BsnTlv.Serialize(encoder); err != nil {
10542 return err
10543 }
10544
10545 encoder.PutUint16(uint16(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10546 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10547
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10548 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10549
10550 return nil
10551}
10552
10553func DecodeBsnTlvUdfOffset(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUdfOffset, error) {
10554 _bsntlvudfoffset := &BsnTlvUdfOffset{BsnTlv: parent}
10555 if decoder.Length() < 2 {
10556 return nil, fmt.Errorf("BsnTlvUdfOffset packet too short: %d < 2", decoder.Length())
10557 }
10558 _bsntlvudfoffset.Value = uint16(decoder.ReadUint16())
10559 return _bsntlvudfoffset, nil
10560}
10561
10562func NewBsnTlvUdfOffset() *BsnTlvUdfOffset {
10563 obj := &BsnTlvUdfOffset{
10564 BsnTlv: NewBsnTlv(17),
10565 }
10566 return obj
10567}
10568
10569type BsnTlvUdpDst struct {
10570 *BsnTlv
10571 Value uint16
10572}
10573
10574type IBsnTlvUdpDst interface {
10575 IBsnTlv
10576 GetValue() uint16
10577}
10578
10579func (self *BsnTlvUdpDst) GetValue() uint16 {
10580 return self.Value
10581}
10582
10583func (self *BsnTlvUdpDst) SetValue(v uint16) {
10584 self.Value = v
10585}
10586
10587func (self *BsnTlvUdpDst) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10588 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10589 if err := self.BsnTlv.Serialize(encoder); err != nil {
10590 return err
10591 }
10592
10593 encoder.PutUint16(uint16(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10594 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10595
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10596 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10597
10598 return nil
10599}
10600
10601func DecodeBsnTlvUdpDst(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUdpDst, error) {
10602 _bsntlvudpdst := &BsnTlvUdpDst{BsnTlv: parent}
10603 if decoder.Length() < 2 {
10604 return nil, fmt.Errorf("BsnTlvUdpDst packet too short: %d < 2", decoder.Length())
10605 }
10606 _bsntlvudpdst.Value = uint16(decoder.ReadUint16())
10607 return _bsntlvudpdst, nil
10608}
10609
10610func NewBsnTlvUdpDst() *BsnTlvUdpDst {
10611 obj := &BsnTlvUdpDst{
10612 BsnTlv: NewBsnTlv(37),
10613 }
10614 return obj
10615}
10616
10617type BsnTlvUdpSrc struct {
10618 *BsnTlv
10619 Value uint16
10620}
10621
10622type IBsnTlvUdpSrc interface {
10623 IBsnTlv
10624 GetValue() uint16
10625}
10626
10627func (self *BsnTlvUdpSrc) GetValue() uint16 {
10628 return self.Value
10629}
10630
10631func (self *BsnTlvUdpSrc) SetValue(v uint16) {
10632 self.Value = v
10633}
10634
10635func (self *BsnTlvUdpSrc) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10636 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10637 if err := self.BsnTlv.Serialize(encoder); err != nil {
10638 return err
10639 }
10640
10641 encoder.PutUint16(uint16(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10642 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10643
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10644 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10645
10646 return nil
10647}
10648
10649func DecodeBsnTlvUdpSrc(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUdpSrc, error) {
10650 _bsntlvudpsrc := &BsnTlvUdpSrc{BsnTlv: parent}
10651 if decoder.Length() < 2 {
10652 return nil, fmt.Errorf("BsnTlvUdpSrc packet too short: %d < 2", decoder.Length())
10653 }
10654 _bsntlvudpsrc.Value = uint16(decoder.ReadUint16())
10655 return _bsntlvudpsrc, nil
10656}
10657
10658func NewBsnTlvUdpSrc() *BsnTlvUdpSrc {
10659 obj := &BsnTlvUdpSrc{
10660 BsnTlv: NewBsnTlv(36),
10661 }
10662 return obj
10663}
10664
10665type BsnTlvUint32 struct {
10666 *BsnTlv
10667 Value uint32
10668}
10669
10670type IBsnTlvUint32 interface {
10671 IBsnTlv
10672 GetValue() uint32
10673}
10674
10675func (self *BsnTlvUint32) GetValue() uint32 {
10676 return self.Value
10677}
10678
10679func (self *BsnTlvUint32) SetValue(v uint32) {
10680 self.Value = v
10681}
10682
10683func (self *BsnTlvUint32) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10684 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10685 if err := self.BsnTlv.Serialize(encoder); err != nil {
10686 return err
10687 }
10688
10689 encoder.PutUint32(uint32(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10690 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10691
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10692 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10693
10694 return nil
10695}
10696
10697func DecodeBsnTlvUint32(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUint32, error) {
10698 _bsntlvuint32 := &BsnTlvUint32{BsnTlv: parent}
10699 if decoder.Length() < 4 {
10700 return nil, fmt.Errorf("BsnTlvUint32 packet too short: %d < 4", decoder.Length())
10701 }
10702 _bsntlvuint32.Value = uint32(decoder.ReadUint32())
10703 return _bsntlvuint32, nil
10704}
10705
10706func NewBsnTlvUint32() *BsnTlvUint32 {
10707 obj := &BsnTlvUint32{
10708 BsnTlv: NewBsnTlv(167),
10709 }
10710 return obj
10711}
10712
10713type BsnTlvUint64List struct {
10714 *BsnTlv
10715 Value []*Uint64
10716}
10717
10718type IBsnTlvUint64List interface {
10719 IBsnTlv
10720 GetValue() []*Uint64
10721}
10722
10723func (self *BsnTlvUint64List) GetValue() []*Uint64 {
10724 return self.Value
10725}
10726
10727func (self *BsnTlvUint64List) SetValue(v []*Uint64) {
10728 self.Value = v
10729}
10730
10731func (self *BsnTlvUint64List) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10732 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10733 if err := self.BsnTlv.Serialize(encoder); err != nil {
10734 return err
10735 }
10736
10737 for _, obj := range self.Value {
10738 if err := obj.Serialize(encoder); err != nil {
10739 return err
10740 }
10741 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10742 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10743
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10744 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10745
10746 return nil
10747}
10748
10749func DecodeBsnTlvUint64List(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUint64List, error) {
10750 _bsntlvuint64list := &BsnTlvUint64List{BsnTlv: parent}
10751
10752 for decoder.Length() >= 8 {
10753 item, err := DecodeUint64(decoder)
10754 if err != nil {
10755 return nil, err
10756 }
10757 if item != nil {
10758 _bsntlvuint64list.Value = append(_bsntlvuint64list.Value, item)
10759 }
10760 }
10761 return _bsntlvuint64list, nil
10762}
10763
10764func NewBsnTlvUint64List() *BsnTlvUint64List {
10765 obj := &BsnTlvUint64List{
10766 BsnTlv: NewBsnTlv(119),
10767 }
10768 return obj
10769}
10770
10771type BsnTlvUnicastQueryTimeout struct {
10772 *BsnTlv
10773 Value uint32
10774}
10775
10776type IBsnTlvUnicastQueryTimeout interface {
10777 IBsnTlv
10778 GetValue() uint32
10779}
10780
10781func (self *BsnTlvUnicastQueryTimeout) GetValue() uint32 {
10782 return self.Value
10783}
10784
10785func (self *BsnTlvUnicastQueryTimeout) SetValue(v uint32) {
10786 self.Value = v
10787}
10788
10789func (self *BsnTlvUnicastQueryTimeout) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10790 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10791 if err := self.BsnTlv.Serialize(encoder); err != nil {
10792 return err
10793 }
10794
10795 encoder.PutUint32(uint32(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10796 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10797
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10798 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10799
10800 return nil
10801}
10802
10803func DecodeBsnTlvUnicastQueryTimeout(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUnicastQueryTimeout, error) {
10804 _bsntlvunicastquerytimeout := &BsnTlvUnicastQueryTimeout{BsnTlv: parent}
10805 if decoder.Length() < 4 {
10806 return nil, fmt.Errorf("BsnTlvUnicastQueryTimeout packet too short: %d < 4", decoder.Length())
10807 }
10808 _bsntlvunicastquerytimeout.Value = uint32(decoder.ReadUint32())
10809 return _bsntlvunicastquerytimeout, nil
10810}
10811
10812func NewBsnTlvUnicastQueryTimeout() *BsnTlvUnicastQueryTimeout {
10813 obj := &BsnTlvUnicastQueryTimeout{
10814 BsnTlv: NewBsnTlv(9),
10815 }
10816 return obj
10817}
10818
10819type BsnTlvUnicastRate struct {
10820 *BsnTlv
10821 Value uint32
10822}
10823
10824type IBsnTlvUnicastRate interface {
10825 IBsnTlv
10826 GetValue() uint32
10827}
10828
10829func (self *BsnTlvUnicastRate) GetValue() uint32 {
10830 return self.Value
10831}
10832
10833func (self *BsnTlvUnicastRate) SetValue(v uint32) {
10834 self.Value = v
10835}
10836
10837func (self *BsnTlvUnicastRate) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10838 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10839 if err := self.BsnTlv.Serialize(encoder); err != nil {
10840 return err
10841 }
10842
10843 encoder.PutUint32(uint32(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10844 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10845
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10846 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10847
10848 return nil
10849}
10850
10851func DecodeBsnTlvUnicastRate(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUnicastRate, error) {
10852 _bsntlvunicastrate := &BsnTlvUnicastRate{BsnTlv: parent}
10853 if decoder.Length() < 4 {
10854 return nil, fmt.Errorf("BsnTlvUnicastRate packet too short: %d < 4", decoder.Length())
10855 }
10856 _bsntlvunicastrate.Value = uint32(decoder.ReadUint32())
10857 return _bsntlvunicastrate, nil
10858}
10859
10860func NewBsnTlvUnicastRate() *BsnTlvUnicastRate {
10861 obj := &BsnTlvUnicastRate{
10862 BsnTlv: NewBsnTlv(93),
10863 }
10864 return obj
10865}
10866
10867type BsnTlvUnknownMulticastRate struct {
10868 *BsnTlv
10869 Value uint32
10870}
10871
10872type IBsnTlvUnknownMulticastRate interface {
10873 IBsnTlv
10874 GetValue() uint32
10875}
10876
10877func (self *BsnTlvUnknownMulticastRate) GetValue() uint32 {
10878 return self.Value
10879}
10880
10881func (self *BsnTlvUnknownMulticastRate) SetValue(v uint32) {
10882 self.Value = v
10883}
10884
10885func (self *BsnTlvUnknownMulticastRate) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10886 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10887 if err := self.BsnTlv.Serialize(encoder); err != nil {
10888 return err
10889 }
10890
10891 encoder.PutUint32(uint32(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10892 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10893
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10894 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10895
10896 return nil
10897}
10898
10899func DecodeBsnTlvUnknownMulticastRate(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUnknownMulticastRate, error) {
10900 _bsntlvunknownmulticastrate := &BsnTlvUnknownMulticastRate{BsnTlv: parent}
10901 if decoder.Length() < 4 {
10902 return nil, fmt.Errorf("BsnTlvUnknownMulticastRate packet too short: %d < 4", decoder.Length())
10903 }
10904 _bsntlvunknownmulticastrate.Value = uint32(decoder.ReadUint32())
10905 return _bsntlvunknownmulticastrate, nil
10906}
10907
10908func NewBsnTlvUnknownMulticastRate() *BsnTlvUnknownMulticastRate {
10909 obj := &BsnTlvUnknownMulticastRate{
10910 BsnTlv: NewBsnTlv(92),
10911 }
10912 return obj
10913}
10914
10915type BsnTlvUntagged struct {
10916 *BsnTlv
10917}
10918
10919type IBsnTlvUntagged interface {
10920 IBsnTlv
10921}
10922
10923func (self *BsnTlvUntagged) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10924 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10925 if err := self.BsnTlv.Serialize(encoder); err != nil {
10926 return err
10927 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10928 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10929
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10930 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10931
10932 return nil
10933}
10934
10935func DecodeBsnTlvUntagged(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUntagged, error) {
10936 _bsntlvuntagged := &BsnTlvUntagged{BsnTlv: parent}
10937 return _bsntlvuntagged, nil
10938}
10939
10940func NewBsnTlvUntagged() *BsnTlvUntagged {
10941 obj := &BsnTlvUntagged{
10942 BsnTlv: NewBsnTlv(106),
10943 }
10944 return obj
10945}
10946
10947type BsnTlvUpgrade struct {
10948 *BsnTlv
10949 Value BsnUpgrade
10950}
10951
10952type IBsnTlvUpgrade interface {
10953 IBsnTlv
10954 GetValue() BsnUpgrade
10955}
10956
10957func (self *BsnTlvUpgrade) GetValue() BsnUpgrade {
10958 return self.Value
10959}
10960
10961func (self *BsnTlvUpgrade) SetValue(v BsnUpgrade) {
10962 self.Value = v
10963}
10964
10965func (self *BsnTlvUpgrade) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10966 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10967 if err := self.BsnTlv.Serialize(encoder); err != nil {
10968 return err
10969 }
10970
10971 encoder.PutUint16(uint16(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10972 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10973
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]10974 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]10975
10976 return nil
10977}
10978
10979func DecodeBsnTlvUpgrade(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUpgrade, error) {
10980 _bsntlvupgrade := &BsnTlvUpgrade{BsnTlv: parent}
10981 if decoder.Length() < 2 {
10982 return nil, fmt.Errorf("BsnTlvUpgrade packet too short: %d < 2", decoder.Length())
10983 }
10984 _bsntlvupgrade.Value = BsnUpgrade(decoder.ReadUint16())
10985 return _bsntlvupgrade, nil
10986}
10987
10988func NewBsnTlvUpgrade() *BsnTlvUpgrade {
10989 obj := &BsnTlvUpgrade{
10990 BsnTlv: NewBsnTlv(164),
10991 }
10992 return obj
10993}
10994
10995type BsnTlvUriScheme struct {
10996 *BsnTlv
10997 Value []byte
10998}
10999
11000type IBsnTlvUriScheme interface {
11001 IBsnTlv
11002 GetValue() []byte
11003}
11004
11005func (self *BsnTlvUriScheme) GetValue() []byte {
11006 return self.Value
11007}
11008
11009func (self *BsnTlvUriScheme) SetValue(v []byte) {
11010 self.Value = v
11011}
11012
11013func (self *BsnTlvUriScheme) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11014 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11015 if err := self.BsnTlv.Serialize(encoder); err != nil {
11016 return err
11017 }
11018
11019 encoder.Write(self.Value)
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11020 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11021
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11022 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11023
11024 return nil
11025}
11026
11027func DecodeBsnTlvUriScheme(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUriScheme, error) {
11028 _bsntlvurischeme := &BsnTlvUriScheme{BsnTlv: parent}
11029 _bsntlvurischeme.Value = decoder.Read(int(decoder.Length()))
11030 return _bsntlvurischeme, nil
11031}
11032
11033func NewBsnTlvUriScheme() *BsnTlvUriScheme {
11034 obj := &BsnTlvUriScheme{
11035 BsnTlv: NewBsnTlv(153),
11036 }
11037 return obj
11038}
11039
11040type BsnTlvUsePacketState struct {
11041 *BsnTlv
11042 Value uint8
11043}
11044
11045type IBsnTlvUsePacketState interface {
11046 IBsnTlv
11047 GetValue() uint8
11048}
11049
11050func (self *BsnTlvUsePacketState) GetValue() uint8 {
11051 return self.Value
11052}
11053
11054func (self *BsnTlvUsePacketState) SetValue(v uint8) {
11055 self.Value = v
11056}
11057
11058func (self *BsnTlvUsePacketState) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11059 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11060 if err := self.BsnTlv.Serialize(encoder); err != nil {
11061 return err
11062 }
11063
11064 encoder.PutUint8(uint8(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11065 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11066
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11067 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11068
11069 return nil
11070}
11071
11072func DecodeBsnTlvUsePacketState(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUsePacketState, error) {
11073 _bsntlvusepacketstate := &BsnTlvUsePacketState{BsnTlv: parent}
11074 if decoder.Length() < 1 {
11075 return nil, fmt.Errorf("BsnTlvUsePacketState packet too short: %d < 1", decoder.Length())
11076 }
11077 _bsntlvusepacketstate.Value = uint8(decoder.ReadByte())
11078 return _bsntlvusepacketstate, nil
11079}
11080
11081func NewBsnTlvUsePacketState() *BsnTlvUsePacketState {
11082 obj := &BsnTlvUsePacketState{
11083 BsnTlv: NewBsnTlv(96),
11084 }
11085 return obj
11086}
11087
11088type BsnTlvUserConfigured struct {
11089 *BsnTlv
11090}
11091
11092type IBsnTlvUserConfigured interface {
11093 IBsnTlv
11094}
11095
11096func (self *BsnTlvUserConfigured) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11097 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11098 if err := self.BsnTlv.Serialize(encoder); err != nil {
11099 return err
11100 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11101 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11102
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11103 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11104
11105 return nil
11106}
11107
11108func DecodeBsnTlvUserConfigured(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUserConfigured, error) {
11109 _bsntlvuserconfigured := &BsnTlvUserConfigured{BsnTlv: parent}
11110 return _bsntlvuserconfigured, nil
11111}
11112
11113func NewBsnTlvUserConfigured() *BsnTlvUserConfigured {
11114 obj := &BsnTlvUserConfigured{
11115 BsnTlv: NewBsnTlv(166),
11116 }
11117 return obj
11118}
11119
11120type BsnTlvVfi struct {
11121 *BsnTlv
11122 Value uint16
11123}
11124
11125type IBsnTlvVfi interface {
11126 IBsnTlv
11127 GetValue() uint16
11128}
11129
11130func (self *BsnTlvVfi) GetValue() uint16 {
11131 return self.Value
11132}
11133
11134func (self *BsnTlvVfi) SetValue(v uint16) {
11135 self.Value = v
11136}
11137
11138func (self *BsnTlvVfi) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11139 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11140 if err := self.BsnTlv.Serialize(encoder); err != nil {
11141 return err
11142 }
11143
11144 encoder.PutUint16(uint16(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11145 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11146
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11147 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11148
11149 return nil
11150}
11151
11152func DecodeBsnTlvVfi(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVfi, error) {
11153 _bsntlvvfi := &BsnTlvVfi{BsnTlv: parent}
11154 if decoder.Length() < 2 {
11155 return nil, fmt.Errorf("BsnTlvVfi packet too short: %d < 2", decoder.Length())
11156 }
11157 _bsntlvvfi.Value = uint16(decoder.ReadUint16())
11158 return _bsntlvvfi, nil
11159}
11160
11161func NewBsnTlvVfi() *BsnTlvVfi {
11162 obj := &BsnTlvVfi{
11163 BsnTlv: NewBsnTlv(99),
11164 }
11165 return obj
11166}
11167
11168type BsnTlvVfpClassId struct {
11169 *BsnTlv
11170 Value uint32
11171}
11172
11173type IBsnTlvVfpClassId interface {
11174 IBsnTlv
11175 GetValue() uint32
11176}
11177
11178func (self *BsnTlvVfpClassId) GetValue() uint32 {
11179 return self.Value
11180}
11181
11182func (self *BsnTlvVfpClassId) SetValue(v uint32) {
11183 self.Value = v
11184}
11185
11186func (self *BsnTlvVfpClassId) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11187 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11188 if err := self.BsnTlv.Serialize(encoder); err != nil {
11189 return err
11190 }
11191
11192 encoder.PutUint32(uint32(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11193 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11194
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11195 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11196
11197 return nil
11198}
11199
11200func DecodeBsnTlvVfpClassId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVfpClassId, error) {
11201 _bsntlvvfpclassid := &BsnTlvVfpClassId{BsnTlv: parent}
11202 if decoder.Length() < 4 {
11203 return nil, fmt.Errorf("BsnTlvVfpClassId packet too short: %d < 4", decoder.Length())
11204 }
11205 _bsntlvvfpclassid.Value = uint32(decoder.ReadUint32())
11206 return _bsntlvvfpclassid, nil
11207}
11208
11209func NewBsnTlvVfpClassId() *BsnTlvVfpClassId {
11210 obj := &BsnTlvVfpClassId{
11211 BsnTlv: NewBsnTlv(107),
11212 }
11213 return obj
11214}
11215
11216type BsnTlvVirtual struct {
11217 *BsnTlv
11218}
11219
11220type IBsnTlvVirtual interface {
11221 IBsnTlv
11222}
11223
11224func (self *BsnTlvVirtual) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11225 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11226 if err := self.BsnTlv.Serialize(encoder); err != nil {
11227 return err
11228 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11229 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11230
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11231 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11232
11233 return nil
11234}
11235
11236func DecodeBsnTlvVirtual(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVirtual, error) {
11237 _bsntlvvirtual := &BsnTlvVirtual{BsnTlv: parent}
11238 return _bsntlvvirtual, nil
11239}
11240
11241func NewBsnTlvVirtual() *BsnTlvVirtual {
11242 obj := &BsnTlvVirtual{
11243 BsnTlv: NewBsnTlv(158),
11244 }
11245 return obj
11246}
11247
11248type BsnTlvVlanMacList struct {
11249 *BsnTlv
11250 Key []*BsnVlanMac
11251}
11252
11253type IBsnTlvVlanMacList interface {
11254 IBsnTlv
11255 GetKey() []*BsnVlanMac
11256}
11257
11258func (self *BsnTlvVlanMacList) GetKey() []*BsnVlanMac {
11259 return self.Key
11260}
11261
11262func (self *BsnTlvVlanMacList) SetKey(v []*BsnVlanMac) {
11263 self.Key = v
11264}
11265
11266func (self *BsnTlvVlanMacList) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11267 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11268 if err := self.BsnTlv.Serialize(encoder); err != nil {
11269 return err
11270 }
11271
11272 for _, obj := range self.Key {
11273 if err := obj.Serialize(encoder); err != nil {
11274 return err
11275 }
11276 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11277 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11278
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11279 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11280
11281 return nil
11282}
11283
11284func DecodeBsnTlvVlanMacList(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVlanMacList, error) {
11285 _bsntlvvlanmaclist := &BsnTlvVlanMacList{BsnTlv: parent}
11286
11287 for decoder.Length() >= 8 {
11288 item, err := DecodeBsnVlanMac(decoder)
11289 if err != nil {
11290 return nil, err
11291 }
11292 if item != nil {
11293 _bsntlvvlanmaclist.Key = append(_bsntlvvlanmaclist.Key, item)
11294 }
11295 }
11296 return _bsntlvvlanmaclist, nil
11297}
11298
11299func NewBsnTlvVlanMacList() *BsnTlvVlanMacList {
11300 obj := &BsnTlvVlanMacList{
11301 BsnTlv: NewBsnTlv(98),
11302 }
11303 return obj
11304}
11305
11306type BsnTlvVlanPcp struct {
11307 *BsnTlv
11308 Value uint8
11309}
11310
11311type IBsnTlvVlanPcp interface {
11312 IBsnTlv
11313 GetValue() uint8
11314}
11315
11316func (self *BsnTlvVlanPcp) GetValue() uint8 {
11317 return self.Value
11318}
11319
11320func (self *BsnTlvVlanPcp) SetValue(v uint8) {
11321 self.Value = v
11322}
11323
11324func (self *BsnTlvVlanPcp) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11325 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11326 if err := self.BsnTlv.Serialize(encoder); err != nil {
11327 return err
11328 }
11329
11330 encoder.PutUint8(uint8(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11331 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11332
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11333 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11334
11335 return nil
11336}
11337
11338func DecodeBsnTlvVlanPcp(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVlanPcp, error) {
11339 _bsntlvvlanpcp := &BsnTlvVlanPcp{BsnTlv: parent}
11340 if decoder.Length() < 1 {
11341 return nil, fmt.Errorf("BsnTlvVlanPcp packet too short: %d < 1", decoder.Length())
11342 }
11343 _bsntlvvlanpcp.Value = uint8(decoder.ReadByte())
11344 return _bsntlvvlanpcp, nil
11345}
11346
11347func NewBsnTlvVlanPcp() *BsnTlvVlanPcp {
11348 obj := &BsnTlvVlanPcp{
11349 BsnTlv: NewBsnTlv(72),
11350 }
11351 return obj
11352}
11353
11354type BsnTlvVlanVid struct {
11355 *BsnTlv
11356 Value uint16
11357}
11358
11359type IBsnTlvVlanVid interface {
11360 IBsnTlv
11361 GetValue() uint16
11362}
11363
11364func (self *BsnTlvVlanVid) GetValue() uint16 {
11365 return self.Value
11366}
11367
11368func (self *BsnTlvVlanVid) SetValue(v uint16) {
11369 self.Value = v
11370}
11371
11372func (self *BsnTlvVlanVid) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11373 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11374 if err := self.BsnTlv.Serialize(encoder); err != nil {
11375 return err
11376 }
11377
11378 encoder.PutUint16(uint16(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11379 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11380
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11381 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11382
11383 return nil
11384}
11385
11386func DecodeBsnTlvVlanVid(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVlanVid, error) {
11387 _bsntlvvlanvid := &BsnTlvVlanVid{BsnTlv: parent}
11388 if decoder.Length() < 2 {
11389 return nil, fmt.Errorf("BsnTlvVlanVid packet too short: %d < 2", decoder.Length())
11390 }
11391 _bsntlvvlanvid.Value = uint16(decoder.ReadUint16())
11392 return _bsntlvvlanvid, nil
11393}
11394
11395func NewBsnTlvVlanVid() *BsnTlvVlanVid {
11396 obj := &BsnTlvVlanVid{
11397 BsnTlv: NewBsnTlv(6),
11398 }
11399 return obj
11400}
11401
11402type BsnTlvVlanVidMask struct {
11403 *BsnTlv
11404 Value uint16
11405}
11406
11407type IBsnTlvVlanVidMask interface {
11408 IBsnTlv
11409 GetValue() uint16
11410}
11411
11412func (self *BsnTlvVlanVidMask) GetValue() uint16 {
11413 return self.Value
11414}
11415
11416func (self *BsnTlvVlanVidMask) SetValue(v uint16) {
11417 self.Value = v
11418}
11419
11420func (self *BsnTlvVlanVidMask) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11421 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11422 if err := self.BsnTlv.Serialize(encoder); err != nil {
11423 return err
11424 }
11425
11426 encoder.PutUint16(uint16(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11427 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11428
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11429 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11430
11431 return nil
11432}
11433
11434func DecodeBsnTlvVlanVidMask(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVlanVidMask, error) {
11435 _bsntlvvlanvidmask := &BsnTlvVlanVidMask{BsnTlv: parent}
11436 if decoder.Length() < 2 {
11437 return nil, fmt.Errorf("BsnTlvVlanVidMask packet too short: %d < 2", decoder.Length())
11438 }
11439 _bsntlvvlanvidmask.Value = uint16(decoder.ReadUint16())
11440 return _bsntlvvlanvidmask, nil
11441}
11442
11443func NewBsnTlvVlanVidMask() *BsnTlvVlanVidMask {
11444 obj := &BsnTlvVlanVidMask{
11445 BsnTlv: NewBsnTlv(77),
11446 }
11447 return obj
11448}
11449
11450type BsnTlvVni struct {
11451 *BsnTlv
11452 Value uint32
11453}
11454
11455type IBsnTlvVni interface {
11456 IBsnTlv
11457 GetValue() uint32
11458}
11459
11460func (self *BsnTlvVni) GetValue() uint32 {
11461 return self.Value
11462}
11463
11464func (self *BsnTlvVni) SetValue(v uint32) {
11465 self.Value = v
11466}
11467
11468func (self *BsnTlvVni) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11469 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11470 if err := self.BsnTlv.Serialize(encoder); err != nil {
11471 return err
11472 }
11473
11474 encoder.PutUint32(uint32(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11475 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11476
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11477 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11478
11479 return nil
11480}
11481
11482func DecodeBsnTlvVni(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVni, error) {
11483 _bsntlvvni := &BsnTlvVni{BsnTlv: parent}
11484 if decoder.Length() < 4 {
11485 return nil, fmt.Errorf("BsnTlvVni packet too short: %d < 4", decoder.Length())
11486 }
11487 _bsntlvvni.Value = uint32(decoder.ReadUint32())
11488 return _bsntlvvni, nil
11489}
11490
11491func NewBsnTlvVni() *BsnTlvVni {
11492 obj := &BsnTlvVni{
11493 BsnTlv: NewBsnTlv(86),
11494 }
11495 return obj
11496}
11497
11498type BsnTlvVpnKey struct {
11499 *BsnTlv
11500 Value uint32
11501}
11502
11503type IBsnTlvVpnKey interface {
11504 IBsnTlv
11505 GetValue() uint32
11506}
11507
11508func (self *BsnTlvVpnKey) GetValue() uint32 {
11509 return self.Value
11510}
11511
11512func (self *BsnTlvVpnKey) SetValue(v uint32) {
11513 self.Value = v
11514}
11515
11516func (self *BsnTlvVpnKey) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11517 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11518 if err := self.BsnTlv.Serialize(encoder); err != nil {
11519 return err
11520 }
11521
11522 encoder.PutUint32(uint32(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11523 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11524
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11525 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11526
11527 return nil
11528}
11529
11530func DecodeBsnTlvVpnKey(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVpnKey, error) {
11531 _bsntlvvpnkey := &BsnTlvVpnKey{BsnTlv: parent}
11532 if decoder.Length() < 4 {
11533 return nil, fmt.Errorf("BsnTlvVpnKey packet too short: %d < 4", decoder.Length())
11534 }
11535 _bsntlvvpnkey.Value = uint32(decoder.ReadUint32())
11536 return _bsntlvvpnkey, nil
11537}
11538
11539func NewBsnTlvVpnKey() *BsnTlvVpnKey {
11540 obj := &BsnTlvVpnKey{
11541 BsnTlv: NewBsnTlv(111),
11542 }
11543 return obj
11544}
11545
11546type BsnTlvVrf struct {
11547 *BsnTlv
11548 Value uint32
11549}
11550
11551type IBsnTlvVrf interface {
11552 IBsnTlv
11553 GetValue() uint32
11554}
11555
11556func (self *BsnTlvVrf) GetValue() uint32 {
11557 return self.Value
11558}
11559
11560func (self *BsnTlvVrf) SetValue(v uint32) {
11561 self.Value = v
11562}
11563
11564func (self *BsnTlvVrf) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11565 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11566 if err := self.BsnTlv.Serialize(encoder); err != nil {
11567 return err
11568 }
11569
11570 encoder.PutUint32(uint32(self.Value))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11571 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11572
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11573 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11574
11575 return nil
11576}
11577
11578func DecodeBsnTlvVrf(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVrf, error) {
11579 _bsntlvvrf := &BsnTlvVrf{BsnTlv: parent}
11580 if decoder.Length() < 4 {
11581 return nil, fmt.Errorf("BsnTlvVrf packet too short: %d < 4", decoder.Length())
11582 }
11583 _bsntlvvrf.Value = uint32(decoder.ReadUint32())
11584 return _bsntlvvrf, nil
11585}
11586
11587func NewBsnTlvVrf() *BsnTlvVrf {
11588 obj := &BsnTlvVrf{
11589 BsnTlv: NewBsnTlv(19),
11590 }
11591 return obj
11592}
11593
11594type BsnTlvVxlanEgressLag struct {
11595 *BsnTlv
11596}
11597
11598type IBsnTlvVxlanEgressLag interface {
11599 IBsnTlv
11600}
11601
11602func (self *BsnTlvVxlanEgressLag) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11603 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11604 if err := self.BsnTlv.Serialize(encoder); err != nil {
11605 return err
11606 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11607 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11608
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11609 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11610
11611 return nil
11612}
11613
11614func DecodeBsnTlvVxlanEgressLag(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVxlanEgressLag, error) {
11615 _bsntlvvxlanegresslag := &BsnTlvVxlanEgressLag{BsnTlv: parent}
11616 return _bsntlvvxlanegresslag, nil
11617}
11618
11619func NewBsnTlvVxlanEgressLag() *BsnTlvVxlanEgressLag {
11620 obj := &BsnTlvVxlanEgressLag{
11621 BsnTlv: NewBsnTlv(117),
11622 }
11623 return obj
11624}
11625
11626type BsnVport struct {
11627 Type uint16
11628 Length uint16
11629}
11630
11631type IBsnVport interface {
11632 goloxi.Serializable
11633 GetType() uint16
11634 GetLength() uint16
11635}
11636
11637func (self *BsnVport) GetType() uint16 {
11638 return self.Type
11639}
11640
11641func (self *BsnVport) SetType(v uint16) {
11642 self.Type = v
11643}
11644
11645func (self *BsnVport) GetLength() uint16 {
11646 return self.Length
11647}
11648
11649func (self *BsnVport) SetLength(v uint16) {
11650 self.Length = v
11651}
11652
11653func (self *BsnVport) Serialize(encoder *goloxi.Encoder) error {
11654
11655 encoder.PutUint16(uint16(self.Type))
11656 encoder.PutUint16(uint16(self.Length))
11657
11658 return nil
11659}
11660func (self *BsnVport) Decode(decoder *goloxi.Decoder) error {
11661 if decoder.Length() < 4 {
11662 return fmt.Errorf("BsnVport packet too short: %d < 4", decoder.Length())
11663 }
11664
11665 self.Type = uint16(decoder.ReadUint16())
11666 self.Length = uint16(decoder.ReadUint16())
11667 oldDecoder := decoder
11668 defer func() { decoder = oldDecoder }()
11669 decoder = decoder.SliceDecoder(int(self.Length), 2+2)
11670
11671 return nil
11672}
11673
11674func NewBsnVport(_type uint16) *BsnVport {
11675 obj := &BsnVport{}
11676 obj.Type = _type
11677 return obj
11678}
11679
11680type BsnVlanCounterStatsEntry struct {
11681 Length uint16
11682 VlanVid uint16
11683 Values []*Uint64
11684}
11685
11686type IBsnVlanCounterStatsEntry interface {
11687 goloxi.Serializable
11688 GetLength() uint16
11689 GetVlanVid() uint16
11690 GetValues() []*Uint64
11691}
11692
11693func (self *BsnVlanCounterStatsEntry) GetLength() uint16 {
11694 return self.Length
11695}
11696
11697func (self *BsnVlanCounterStatsEntry) SetLength(v uint16) {
11698 self.Length = v
11699}
11700
11701func (self *BsnVlanCounterStatsEntry) GetVlanVid() uint16 {
11702 return self.VlanVid
11703}
11704
11705func (self *BsnVlanCounterStatsEntry) SetVlanVid(v uint16) {
11706 self.VlanVid = v
11707}
11708
11709func (self *BsnVlanCounterStatsEntry) GetValues() []*Uint64 {
11710 return self.Values
11711}
11712
11713func (self *BsnVlanCounterStatsEntry) SetValues(v []*Uint64) {
11714 self.Values = v
11715}
11716
11717func (self *BsnVlanCounterStatsEntry) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11718 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11719
11720 encoder.PutUint16(uint16(self.Length))
11721 encoder.PutUint16(uint16(self.VlanVid))
11722 encoder.Write(bytes.Repeat([]byte{0}, 4))
11723 for _, obj := range self.Values {
11724 if err := obj.Serialize(encoder); err != nil {
11725 return err
11726 }
11727 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11728 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11729
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11730 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11731
11732 return nil
11733}
11734
11735func DecodeBsnVlanCounterStatsEntry(decoder *goloxi.Decoder) (*BsnVlanCounterStatsEntry, error) {
11736 _bsnvlancounterstatsentry := &BsnVlanCounterStatsEntry{}
11737 if decoder.Length() < 8 {
11738 return nil, fmt.Errorf("BsnVlanCounterStatsEntry packet too short: %d < 8", decoder.Length())
11739 }
11740 _bsnvlancounterstatsentry.Length = uint16(decoder.ReadUint16())
11741 oldDecoder := decoder
11742 defer func() { decoder = oldDecoder }()
11743 decoder = decoder.SliceDecoder(int(_bsnvlancounterstatsentry.Length), 2+0)
11744 _bsnvlancounterstatsentry.VlanVid = uint16(decoder.ReadUint16())
11745 decoder.Skip(4)
11746
11747 for decoder.Length() >= 8 {
11748 item, err := DecodeUint64(decoder)
11749 if err != nil {
11750 return nil, err
11751 }
11752 if item != nil {
11753 _bsnvlancounterstatsentry.Values = append(_bsnvlancounterstatsentry.Values, item)
11754 }
11755 }
11756 return _bsnvlancounterstatsentry, nil
11757}
11758
11759func NewBsnVlanCounterStatsEntry() *BsnVlanCounterStatsEntry {
11760 obj := &BsnVlanCounterStatsEntry{}
11761 return obj
11762}
11763
11764type BsnVlanMac struct {
11765 VlanVid uint16
11766 Mac net.HardwareAddr
11767}
11768
11769type IBsnVlanMac interface {
11770 goloxi.Serializable
11771 GetVlanVid() uint16
11772 GetMac() net.HardwareAddr
11773}
11774
11775func (self *BsnVlanMac) GetVlanVid() uint16 {
11776 return self.VlanVid
11777}
11778
11779func (self *BsnVlanMac) SetVlanVid(v uint16) {
11780 self.VlanVid = v
11781}
11782
11783func (self *BsnVlanMac) GetMac() net.HardwareAddr {
11784 return self.Mac
11785}
11786
11787func (self *BsnVlanMac) SetMac(v net.HardwareAddr) {
11788 self.Mac = v
11789}
11790
11791func (self *BsnVlanMac) Serialize(encoder *goloxi.Encoder) error {
11792
11793 encoder.PutUint16(uint16(self.VlanVid))
11794 encoder.Write(self.Mac)
11795
11796 return nil
11797}
11798
11799func DecodeBsnVlanMac(decoder *goloxi.Decoder) (*BsnVlanMac, error) {
11800 _bsnvlanmac := &BsnVlanMac{}
11801 if decoder.Length() < 8 {
11802 return nil, fmt.Errorf("BsnVlanMac packet too short: %d < 8", decoder.Length())
11803 }
11804 _bsnvlanmac.VlanVid = uint16(decoder.ReadUint16())
11805 _bsnvlanmac.Mac = net.HardwareAddr(decoder.Read(6))
11806 return _bsnvlanmac, nil
11807}
11808
11809func NewBsnVlanMac() *BsnVlanMac {
11810 obj := &BsnVlanMac{}
11811 return obj
11812}
11813
11814type BsnVportL2Gre struct {
11815 *BsnVport
11816 Flags BsnVportL2GreFlags
11817 PortNo Port
11818 LoopbackPortNo Port
11819 LocalMac net.HardwareAddr
11820 NhMac net.HardwareAddr
11821 SrcIp net.IP
11822 DstIp net.IP
11823 Dscp uint8
11824 Ttl uint8
11825 Vpn uint32
11826 RateLimit uint32
11827 IfName string
11828}
11829
11830type IBsnVportL2Gre interface {
11831 IBsnVport
11832 GetFlags() BsnVportL2GreFlags
11833 GetPortNo() Port
11834 GetLoopbackPortNo() Port
11835 GetLocalMac() net.HardwareAddr
11836 GetNhMac() net.HardwareAddr
11837 GetSrcIp() net.IP
11838 GetDstIp() net.IP
11839 GetDscp() uint8
11840 GetTtl() uint8
11841 GetVpn() uint32
11842 GetRateLimit() uint32
11843 GetIfName() string
11844}
11845
11846func (self *BsnVportL2Gre) GetFlags() BsnVportL2GreFlags {
11847 return self.Flags
11848}
11849
11850func (self *BsnVportL2Gre) SetFlags(v BsnVportL2GreFlags) {
11851 self.Flags = v
11852}
11853
11854func (self *BsnVportL2Gre) GetPortNo() Port {
11855 return self.PortNo
11856}
11857
11858func (self *BsnVportL2Gre) SetPortNo(v Port) {
11859 self.PortNo = v
11860}
11861
11862func (self *BsnVportL2Gre) GetLoopbackPortNo() Port {
11863 return self.LoopbackPortNo
11864}
11865
11866func (self *BsnVportL2Gre) SetLoopbackPortNo(v Port) {
11867 self.LoopbackPortNo = v
11868}
11869
11870func (self *BsnVportL2Gre) GetLocalMac() net.HardwareAddr {
11871 return self.LocalMac
11872}
11873
11874func (self *BsnVportL2Gre) SetLocalMac(v net.HardwareAddr) {
11875 self.LocalMac = v
11876}
11877
11878func (self *BsnVportL2Gre) GetNhMac() net.HardwareAddr {
11879 return self.NhMac
11880}
11881
11882func (self *BsnVportL2Gre) SetNhMac(v net.HardwareAddr) {
11883 self.NhMac = v
11884}
11885
11886func (self *BsnVportL2Gre) GetSrcIp() net.IP {
11887 return self.SrcIp
11888}
11889
11890func (self *BsnVportL2Gre) SetSrcIp(v net.IP) {
11891 self.SrcIp = v
11892}
11893
11894func (self *BsnVportL2Gre) GetDstIp() net.IP {
11895 return self.DstIp
11896}
11897
11898func (self *BsnVportL2Gre) SetDstIp(v net.IP) {
11899 self.DstIp = v
11900}
11901
11902func (self *BsnVportL2Gre) GetDscp() uint8 {
11903 return self.Dscp
11904}
11905
11906func (self *BsnVportL2Gre) SetDscp(v uint8) {
11907 self.Dscp = v
11908}
11909
11910func (self *BsnVportL2Gre) GetTtl() uint8 {
11911 return self.Ttl
11912}
11913
11914func (self *BsnVportL2Gre) SetTtl(v uint8) {
11915 self.Ttl = v
11916}
11917
11918func (self *BsnVportL2Gre) GetVpn() uint32 {
11919 return self.Vpn
11920}
11921
11922func (self *BsnVportL2Gre) SetVpn(v uint32) {
11923 self.Vpn = v
11924}
11925
11926func (self *BsnVportL2Gre) GetRateLimit() uint32 {
11927 return self.RateLimit
11928}
11929
11930func (self *BsnVportL2Gre) SetRateLimit(v uint32) {
11931 self.RateLimit = v
11932}
11933
11934func (self *BsnVportL2Gre) GetIfName() string {
11935 return self.IfName
11936}
11937
11938func (self *BsnVportL2Gre) SetIfName(v string) {
11939 self.IfName = v
11940}
11941
11942func (self *BsnVportL2Gre) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11943 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11944 if err := self.BsnVport.Serialize(encoder); err != nil {
11945 return err
11946 }
11947
11948 encoder.PutUint32(uint32(self.Flags))
11949 self.PortNo.Serialize(encoder)
11950 self.LoopbackPortNo.Serialize(encoder)
11951 encoder.Write(self.LocalMac)
11952 encoder.Write(self.NhMac)
11953 encoder.Write(self.SrcIp.To4())
11954 encoder.Write(self.DstIp.To4())
11955 encoder.PutUint8(uint8(self.Dscp))
11956 encoder.PutUint8(uint8(self.Ttl))
11957 encoder.Write(bytes.Repeat([]byte{0}, 2))
11958 encoder.PutUint32(uint32(self.Vpn))
11959 encoder.PutUint32(uint32(self.RateLimit))
11960 encoder.Write([]byte(self.IfName))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11961 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11962
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]11963 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]11964
11965 return nil
11966}
11967
11968func DecodeBsnVportL2Gre(parent *BsnVport, decoder *goloxi.Decoder) (*BsnVportL2Gre, error) {
11969 _bsnvportl2gre := &BsnVportL2Gre{BsnVport: parent}
11970 if decoder.Length() < 60 {
11971 return nil, fmt.Errorf("BsnVportL2Gre packet too short: %d < 60", decoder.Length())
11972 }
11973 _bsnvportl2gre.Flags = BsnVportL2GreFlags(decoder.ReadUint32())
11974 _bsnvportl2gre.PortNo.Decode(decoder)
11975 _bsnvportl2gre.LoopbackPortNo.Decode(decoder)
11976 _bsnvportl2gre.LocalMac = net.HardwareAddr(decoder.Read(6))
11977 _bsnvportl2gre.NhMac = net.HardwareAddr(decoder.Read(6))
11978 _bsnvportl2gre.SrcIp = net.IP(decoder.Read(4))
11979 _bsnvportl2gre.DstIp = net.IP(decoder.Read(4))
11980 _bsnvportl2gre.Dscp = uint8(decoder.ReadByte())
11981 _bsnvportl2gre.Ttl = uint8(decoder.ReadByte())
11982 decoder.Skip(2)
11983 _bsnvportl2gre.Vpn = uint32(decoder.ReadUint32())
11984 _bsnvportl2gre.RateLimit = uint32(decoder.ReadUint32())
11985 _bsnvportl2gre.IfName = string(bytes.Trim(decoder.Read(16), "\x00"))
11986 return _bsnvportl2gre, nil
11987}
11988
11989func NewBsnVportL2Gre() *BsnVportL2Gre {
11990 obj := &BsnVportL2Gre{
11991 BsnVport: NewBsnVport(1),
11992 }
11993 return obj
11994}
11995
11996type BsnVportQInQ struct {
11997 *BsnVport
11998 PortNo uint32
11999 IngressTpid uint16
12000 IngressVlanId uint16
12001 EgressTpid uint16
12002 EgressVlanId uint16
12003 IfName string
12004}
12005
12006type IBsnVportQInQ interface {
12007 IBsnVport
12008 GetPortNo() uint32
12009 GetIngressTpid() uint16
12010 GetIngressVlanId() uint16
12011 GetEgressTpid() uint16
12012 GetEgressVlanId() uint16
12013 GetIfName() string
12014}
12015
12016func (self *BsnVportQInQ) GetPortNo() uint32 {
12017 return self.PortNo
12018}
12019
12020func (self *BsnVportQInQ) SetPortNo(v uint32) {
12021 self.PortNo = v
12022}
12023
12024func (self *BsnVportQInQ) GetIngressTpid() uint16 {
12025 return self.IngressTpid
12026}
12027
12028func (self *BsnVportQInQ) SetIngressTpid(v uint16) {
12029 self.IngressTpid = v
12030}
12031
12032func (self *BsnVportQInQ) GetIngressVlanId() uint16 {
12033 return self.IngressVlanId
12034}
12035
12036func (self *BsnVportQInQ) SetIngressVlanId(v uint16) {
12037 self.IngressVlanId = v
12038}
12039
12040func (self *BsnVportQInQ) GetEgressTpid() uint16 {
12041 return self.EgressTpid
12042}
12043
12044func (self *BsnVportQInQ) SetEgressTpid(v uint16) {
12045 self.EgressTpid = v
12046}
12047
12048func (self *BsnVportQInQ) GetEgressVlanId() uint16 {
12049 return self.EgressVlanId
12050}
12051
12052func (self *BsnVportQInQ) SetEgressVlanId(v uint16) {
12053 self.EgressVlanId = v
12054}
12055
12056func (self *BsnVportQInQ) GetIfName() string {
12057 return self.IfName
12058}
12059
12060func (self *BsnVportQInQ) SetIfName(v string) {
12061 self.IfName = v
12062}
12063
12064func (self *BsnVportQInQ) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]12065 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]12066 if err := self.BsnVport.Serialize(encoder); err != nil {
12067 return err
12068 }
12069
12070 encoder.PutUint32(uint32(self.PortNo))
12071 encoder.PutUint16(uint16(self.IngressTpid))
12072 encoder.PutUint16(uint16(self.IngressVlanId))
12073 encoder.PutUint16(uint16(self.EgressTpid))
12074 encoder.PutUint16(uint16(self.EgressVlanId))
12075 encoder.Write([]byte(self.IfName))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]12076 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]12077
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]12078 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]12079
12080 return nil
12081}
12082
12083func DecodeBsnVportQInQ(parent *BsnVport, decoder *goloxi.Decoder) (*BsnVportQInQ, error) {
12084 _bsnvportqinq := &BsnVportQInQ{BsnVport: parent}
12085 if decoder.Length() < 28 {
12086 return nil, fmt.Errorf("BsnVportQInQ packet too short: %d < 28", decoder.Length())
12087 }
12088 _bsnvportqinq.PortNo = uint32(decoder.ReadUint32())
12089 _bsnvportqinq.IngressTpid = uint16(decoder.ReadUint16())
12090 _bsnvportqinq.IngressVlanId = uint16(decoder.ReadUint16())
12091 _bsnvportqinq.EgressTpid = uint16(decoder.ReadUint16())
12092 _bsnvportqinq.EgressVlanId = uint16(decoder.ReadUint16())
12093 _bsnvportqinq.IfName = string(bytes.Trim(decoder.Read(16), "\x00"))
12094 return _bsnvportqinq, nil
12095}
12096
12097func NewBsnVportQInQ() *BsnVportQInQ {
12098 obj := &BsnVportQInQ{
12099 BsnVport: NewBsnVport(0),
12100 }
12101 return obj
12102}
12103
12104type BsnVrfCounterStatsEntry struct {
12105 Length uint16
12106 Vrf uint32
12107 Values []*Uint64
12108}
12109
12110type IBsnVrfCounterStatsEntry interface {
12111 goloxi.Serializable
12112 GetLength() uint16
12113 GetVrf() uint32
12114 GetValues() []*Uint64
12115}
12116
12117func (self *BsnVrfCounterStatsEntry) GetLength() uint16 {
12118 return self.Length
12119}
12120
12121func (self *BsnVrfCounterStatsEntry) SetLength(v uint16) {
12122 self.Length = v
12123}
12124
12125func (self *BsnVrfCounterStatsEntry) GetVrf() uint32 {
12126 return self.Vrf
12127}
12128
12129func (self *BsnVrfCounterStatsEntry) SetVrf(v uint32) {
12130 self.Vrf = v
12131}
12132
12133func (self *BsnVrfCounterStatsEntry) GetValues() []*Uint64 {
12134 return self.Values
12135}
12136
12137func (self *BsnVrfCounterStatsEntry) SetValues(v []*Uint64) {
12138 self.Values = v
12139}
12140
12141func (self *BsnVrfCounterStatsEntry) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]12142 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]12143
12144 encoder.PutUint16(uint16(self.Length))
12145 encoder.Write(bytes.Repeat([]byte{0}, 2))
12146 encoder.PutUint32(uint32(self.Vrf))
12147 for _, obj := range self.Values {
12148 if err := obj.Serialize(encoder); err != nil {
12149 return err
12150 }
12151 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]12152 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]12153
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]12154 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]12155
12156 return nil
12157}
12158
12159func DecodeBsnVrfCounterStatsEntry(decoder *goloxi.Decoder) (*BsnVrfCounterStatsEntry, error) {
12160 _bsnvrfcounterstatsentry := &BsnVrfCounterStatsEntry{}
12161 if decoder.Length() < 8 {
12162 return nil, fmt.Errorf("BsnVrfCounterStatsEntry packet too short: %d < 8", decoder.Length())
12163 }
12164 _bsnvrfcounterstatsentry.Length = uint16(decoder.ReadUint16())
12165 oldDecoder := decoder
12166 defer func() { decoder = oldDecoder }()
12167 decoder = decoder.SliceDecoder(int(_bsnvrfcounterstatsentry.Length), 2+0)
12168 decoder.Skip(2)
12169 _bsnvrfcounterstatsentry.Vrf = uint32(decoder.ReadUint32())
12170
12171 for decoder.Length() >= 8 {
12172 item, err := DecodeUint64(decoder)
12173 if err != nil {
12174 return nil, err
12175 }
12176 if item != nil {
12177 _bsnvrfcounterstatsentry.Values = append(_bsnvrfcounterstatsentry.Values, item)
12178 }
12179 }
12180 return _bsnvrfcounterstatsentry, nil
12181}
12182
12183func NewBsnVrfCounterStatsEntry() *BsnVrfCounterStatsEntry {
12184 obj := &BsnVrfCounterStatsEntry{}
12185 return obj
12186}
12187
12188type Bucket struct {
12189 Len uint16
12190 Weight uint16
12191 WatchPort Port
12192 WatchGroup uint32
12193 Actions []goloxi.IAction
12194}
12195
12196type IBucket interface {
12197 goloxi.Serializable
12198 GetLen() uint16
12199 GetWeight() uint16
12200 GetWatchPort() Port
12201 GetWatchGroup() uint32
12202 GetActions() []goloxi.IAction
12203}
12204
12205func (self *Bucket) GetLen() uint16 {
12206 return self.Len
12207}
12208
12209func (self *Bucket) SetLen(v uint16) {
12210 self.Len = v
12211}
12212
12213func (self *Bucket) GetWeight() uint16 {
12214 return self.Weight
12215}
12216
12217func (self *Bucket) SetWeight(v uint16) {
12218 self.Weight = v
12219}
12220
12221func (self *Bucket) GetWatchPort() Port {
12222 return self.WatchPort
12223}
12224
12225func (self *Bucket) SetWatchPort(v Port) {
12226 self.WatchPort = v
12227}
12228
12229func (self *Bucket) GetWatchGroup() uint32 {
12230 return self.WatchGroup
12231}
12232
12233func (self *Bucket) SetWatchGroup(v uint32) {
12234 self.WatchGroup = v
12235}
12236
12237func (self *Bucket) GetActions() []goloxi.IAction {
12238 return self.Actions
12239}
12240
12241func (self *Bucket) SetActions(v []goloxi.IAction) {
12242 self.Actions = v
12243}
12244
12245func (self *Bucket) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]12246 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]12247
12248 encoder.PutUint16(uint16(self.Len))
12249 encoder.PutUint16(uint16(self.Weight))
12250 self.WatchPort.Serialize(encoder)
12251 encoder.PutUint32(uint32(self.WatchGroup))
12252 encoder.Write(bytes.Repeat([]byte{0}, 4))
12253 for _, obj := range self.Actions {
12254 if err := obj.Serialize(encoder); err != nil {
12255 return err
12256 }
12257 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]12258 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]12259
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]12260 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]12261
12262 return nil
12263}
12264
12265func DecodeBucket(decoder *goloxi.Decoder) (*Bucket, error) {
12266 _bucket := &Bucket{}
12267 if decoder.Length() < 16 {
12268 return nil, fmt.Errorf("Bucket packet too short: %d < 16", decoder.Length())
12269 }
12270 _bucket.Len = uint16(decoder.ReadUint16())
12271 oldDecoder := decoder
12272 defer func() { decoder = oldDecoder }()
12273 decoder = decoder.SliceDecoder(int(_bucket.Len), 2+0)
12274 _bucket.Weight = uint16(decoder.ReadUint16())
12275 _bucket.WatchPort.Decode(decoder)
12276 _bucket.WatchGroup = uint32(decoder.ReadUint32())
12277 decoder.Skip(4)
12278
12279 for decoder.Length() >= 8 {
12280 item, err := DecodeAction(decoder)
12281 if err != nil {
12282 return nil, err
12283 }
12284 if item != nil {
12285 _bucket.Actions = append(_bucket.Actions, item)
12286 }
12287 }
12288 return _bucket, nil
12289}
12290
12291func NewBucket() *Bucket {
12292 obj := &Bucket{}
12293 return obj
12294}
12295
12296type BucketCounter struct {
12297 PacketCount uint64
12298 ByteCount uint64
12299}
12300
12301type IBucketCounter interface {
12302 goloxi.Serializable
12303 GetPacketCount() uint64
12304 GetByteCount() uint64
12305}
12306
12307func (self *BucketCounter) GetPacketCount() uint64 {
12308 return self.PacketCount
12309}
12310
12311func (self *BucketCounter) SetPacketCount(v uint64) {
12312 self.PacketCount = v
12313}
12314
12315func (self *BucketCounter) GetByteCount() uint64 {
12316 return self.ByteCount
12317}
12318
12319func (self *BucketCounter) SetByteCount(v uint64) {
12320 self.ByteCount = v
12321}
12322
12323func (self *BucketCounter) Serialize(encoder *goloxi.Encoder) error {
12324
12325 encoder.PutUint64(uint64(self.PacketCount))
12326 encoder.PutUint64(uint64(self.ByteCount))
12327
12328 return nil
12329}
12330
12331func DecodeBucketCounter(decoder *goloxi.Decoder) (*BucketCounter, error) {
12332 _bucketcounter := &BucketCounter{}
12333 if decoder.Length() < 16 {
12334 return nil, fmt.Errorf("BucketCounter packet too short: %d < 16", decoder.Length())
12335 }
12336 _bucketcounter.PacketCount = uint64(decoder.ReadUint64())
12337 _bucketcounter.ByteCount = uint64(decoder.ReadUint64())
12338 return _bucketcounter, nil
12339}
12340
12341func NewBucketCounter() *BucketCounter {
12342 obj := &BucketCounter{}
12343 return obj
12344}
12345
12346type EdPropHeader struct {
12347 PropClass uint16
12348}
12349
12350type IEdPropHeader interface {
12351 goloxi.Serializable
12352 GetPropClass() uint16
12353}
12354
12355func (self *EdPropHeader) GetPropClass() uint16 {
12356 return self.PropClass
12357}
12358
12359func (self *EdPropHeader) SetPropClass(v uint16) {
12360 self.PropClass = v
12361}
12362
12363func (self *EdPropHeader) Serialize(encoder *goloxi.Encoder) error {
12364
12365 encoder.PutUint16(uint16(self.PropClass))
12366
12367 return nil
12368}
12369
12370func DecodeEdPropHeader(decoder *goloxi.Decoder) (IEdPropHeader, error) {
12371 _edpropheader := &EdPropHeader{}
12372 if decoder.Length() < 2 {
12373 return nil, fmt.Errorf("EdPropHeader packet too short: %d < 2", decoder.Length())
12374 }
12375 _edpropheader.PropClass = uint16(decoder.ReadUint16())
12376
12377 switch _edpropheader.PropClass {
12378 case 4:
12379 return DecodeEdPropNsh(_edpropheader, decoder)
12380 default:
12381 return nil, fmt.Errorf("Invalid type '%d' for 'EdPropHeader'", _edpropheader.PropClass)
12382 }
12383}
12384
12385func NewEdPropHeader(_prop_class uint16) *EdPropHeader {
12386 obj := &EdPropHeader{}
12387 obj.PropClass = _prop_class
12388 return obj
12389}
12390
12391type EdPropNsh struct {
12392 *EdPropHeader
12393 Type uint8
12394 Len uint8
12395}
12396
12397type IEdPropNsh interface {
12398 IEdPropHeader
12399 GetType() uint8
12400 GetLen() uint8
12401}
12402
12403func (self *EdPropNsh) GetType() uint8 {
12404 return self.Type
12405}
12406
12407func (self *EdPropNsh) SetType(v uint8) {
12408 self.Type = v
12409}
12410
12411func (self *EdPropNsh) GetLen() uint8 {
12412 return self.Len
12413}
12414
12415func (self *EdPropNsh) SetLen(v uint8) {
12416 self.Len = v
12417}
12418
12419func (self *EdPropNsh) Serialize(encoder *goloxi.Encoder) error {
12420 if err := self.EdPropHeader.Serialize(encoder); err != nil {
12421 return err
12422 }
12423
12424 encoder.PutUint8(uint8(self.Type))
12425 encoder.PutUint8(uint8(self.Len))
12426
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]12427 return nil
12428}
12429
12430func DecodeEdPropNsh(parent *EdPropHeader, decoder *goloxi.Decoder) (IEdPropNsh, error) {
12431 _edpropnsh := &EdPropNsh{EdPropHeader: parent}
12432 if decoder.Length() < 2 {
12433 return nil, fmt.Errorf("EdPropNsh packet too short: %d < 2", decoder.Length())
12434 }
12435 defer decoder.SkipAlign()
12436
12437 _edpropnsh.Type = uint8(decoder.ReadByte())
12438 _edpropnsh.Len = uint8(decoder.ReadByte())
12439 oldDecoder := decoder
12440 defer func() { decoder = oldDecoder }()
12441 decoder = decoder.SliceDecoder(int(((_edpropnsh.Len)+7)/8*8), 1+3)
12442
12443 switch _edpropnsh.Type {
12444 case 1:
12445 return DecodeEdPropNshMdType(_edpropnsh, decoder)
12446 case 2:
12447 return DecodeEdPropNshTlv(_edpropnsh, decoder)
12448 default:
12449 return nil, fmt.Errorf("Invalid type '%d' for 'EdPropNsh'", _edpropnsh.Type)
12450 }
12451}
12452
12453func NewEdPropNsh(_type uint8) *EdPropNsh {
12454 obj := &EdPropNsh{
12455 EdPropHeader: NewEdPropHeader(4),
12456 }
12457 obj.Type = _type
12458 return obj
12459}
12460
12461type EdPropNshMdType struct {
12462 *EdPropNsh
12463 MdType uint8
12464}
12465
12466type IEdPropNshMdType interface {
12467 IEdPropNsh
12468 GetMdType() uint8
12469}
12470
12471func (self *EdPropNshMdType) GetMdType() uint8 {
12472 return self.MdType
12473}
12474
12475func (self *EdPropNshMdType) SetMdType(v uint8) {
12476 self.MdType = v
12477}
12478
12479func (self *EdPropNshMdType) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]12480 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]12481 if err := self.EdPropNsh.Serialize(encoder); err != nil {
12482 return err
12483 }
12484
12485 encoder.PutUint8(uint8(self.MdType))
12486 encoder.Write(bytes.Repeat([]byte{0}, 3))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]12487 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]12488
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]12489 encoder.Bytes()[startIndex+3] = uint8(length)
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]12490
12491 return nil
12492}
12493
12494func DecodeEdPropNshMdType(parent *EdPropNsh, decoder *goloxi.Decoder) (*EdPropNshMdType, error) {
12495 _edpropnshmdtype := &EdPropNshMdType{EdPropNsh: parent}
12496 if decoder.Length() < 4 {
12497 return nil, fmt.Errorf("EdPropNshMdType packet too short: %d < 4", decoder.Length())
12498 }
12499 _edpropnshmdtype.MdType = uint8(decoder.ReadByte())
12500 decoder.Skip(3)
12501 return _edpropnshmdtype, nil
12502}
12503
12504func NewEdPropNshMdType() *EdPropNshMdType {
12505 obj := &EdPropNshMdType{
12506 EdPropNsh: NewEdPropNsh(1),
12507 }
12508 return obj
12509}
12510
12511type EdPropNshTlv struct {
12512 *EdPropNsh
12513 TlvClass uint16
12514 TlvType uint8
12515 TlvLen uint8
12516 Value []byte
12517}
12518
12519type IEdPropNshTlv interface {
12520 IEdPropNsh
12521 GetTlvClass() uint16
12522 GetTlvType() uint8
12523 GetTlvLen() uint8
12524 GetValue() []byte
12525}
12526
12527func (self *EdPropNshTlv) GetTlvClass() uint16 {
12528 return self.TlvClass
12529}
12530
12531func (self *EdPropNshTlv) SetTlvClass(v uint16) {
12532 self.TlvClass = v
12533}
12534
12535func (self *EdPropNshTlv) GetTlvType() uint8 {
12536 return self.TlvType
12537}
12538
12539func (self *EdPropNshTlv) SetTlvType(v uint8) {
12540 self.TlvType = v
12541}
12542
12543func (self *EdPropNshTlv) GetTlvLen() uint8 {
12544 return self.TlvLen
12545}
12546
12547func (self *EdPropNshTlv) SetTlvLen(v uint8) {
12548 self.TlvLen = v
12549}
12550
12551func (self *EdPropNshTlv) GetValue() []byte {
12552 return self.Value
12553}
12554
12555func (self *EdPropNshTlv) SetValue(v []byte) {
12556 self.Value = v
12557}
12558
12559func (self *EdPropNshTlv) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]12560 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]12561 if err := self.EdPropNsh.Serialize(encoder); err != nil {
12562 return err
12563 }
12564
12565 encoder.PutUint16(uint16(self.TlvClass))
12566 encoder.PutUint8(uint8(self.TlvType))
12567 encoder.PutUint8(uint8(self.TlvLen))
12568 encoder.Write(self.Value)
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]12569 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]12570
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]12571 encoder.Bytes()[startIndex+3] = uint8(length)
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]12572
12573 return nil
12574}
12575
12576func DecodeEdPropNshTlv(parent *EdPropNsh, decoder *goloxi.Decoder) (*EdPropNshTlv, error) {
12577 _edpropnshtlv := &EdPropNshTlv{EdPropNsh: parent}
12578 if decoder.Length() < 4 {
12579 return nil, fmt.Errorf("EdPropNshTlv packet too short: %d < 4", decoder.Length())
12580 }
12581 _edpropnshtlv.TlvClass = uint16(decoder.ReadUint16())
12582 _edpropnshtlv.TlvType = uint8(decoder.ReadByte())
12583 _edpropnshtlv.TlvLen = uint8(decoder.ReadByte())
12584 _edpropnshtlv.Value = decoder.SliceDecoder(int(_edpropnshtlv.TlvLen), 0).Read(int(_edpropnshtlv.TlvLen))
12585 return _edpropnshtlv, nil
12586}
12587
12588func NewEdPropNshTlv() *EdPropNshTlv {
12589 obj := &EdPropNshTlv{
12590 EdPropNsh: NewEdPropNsh(2),
12591 }
12592 return obj
12593}
12594
12595type FlowModSpec struct {
12596 SrcDst uint8
12597 NBits uint8
12598}
12599
12600type IFlowModSpec interface {
12601 goloxi.Serializable
12602 GetSrcDst() uint8
12603 GetNBits() uint8
12604}
12605
12606func (self *FlowModSpec) GetSrcDst() uint8 {
12607 return self.SrcDst
12608}
12609
12610func (self *FlowModSpec) SetSrcDst(v uint8) {
12611 self.SrcDst = v
12612}
12613
12614func (self *FlowModSpec) GetNBits() uint8 {
12615 return self.NBits
12616}
12617
12618func (self *FlowModSpec) SetNBits(v uint8) {
12619 self.NBits = v
12620}
12621
12622func (self *FlowModSpec) Serialize(encoder *goloxi.Encoder) error {
12623
12624 encoder.PutUint8(uint8(self.SrcDst))
12625 encoder.PutUint8(uint8(self.NBits))
12626
12627 return nil
12628}
12629
12630func DecodeFlowModSpec(decoder *goloxi.Decoder) (IFlowModSpec, error) {
12631 _flowmodspec := &FlowModSpec{}
12632 if decoder.Length() < 2 {
12633 return nil, fmt.Errorf("FlowModSpec packet too short: %d < 2", decoder.Length())
12634 }
12635 _flowmodspec.SrcDst = uint8(decoder.ReadByte())
12636 _flowmodspec.NBits = uint8(decoder.ReadByte())
12637 if _flowmodspec.SrcDst == 0 && _flowmodspec.NBits == 0 {
12638 return nil, nil
12639 }
12640
12641 switch _flowmodspec.SrcDst {
12642 case 0:
12643 return DecodeFlowModSpecSrc0Dst0(_flowmodspec, decoder)
12644 case 8:
12645 return DecodeFlowModSpecSrc0Dst1(_flowmodspec, decoder)
12646 case 40:
12647 return DecodeFlowModSpecSrc1Dst1(_flowmodspec, decoder)
12648 case 16:
12649 return DecodeFlowModSpecSrc0Dst2(_flowmodspec, decoder)
12650 case 32:
12651 return DecodeFlowModSpecSrc1Dst0(_flowmodspec, decoder)
12652 default:
12653 return nil, fmt.Errorf("Invalid type '%d' for 'FlowModSpec'", _flowmodspec.SrcDst)
12654 }
12655}
12656
12657func NewFlowModSpec(_src_dst uint8) *FlowModSpec {
12658 obj := &FlowModSpec{}
12659 obj.SrcDst = _src_dst
12660 return obj
12661}
12662
12663type FlowModSpecSrc0Dst0 struct {
12664 *FlowModSpec
12665 Src goloxi.IOxmId
12666 SrcOfs uint16
12667 Dst goloxi.IOxmId
12668 DstOfs uint16
12669}
12670
12671type IFlowModSpecSrc0Dst0 interface {
12672 IFlowModSpec
12673 GetSrc() goloxi.IOxmId
12674 GetSrcOfs() uint16
12675 GetDst() goloxi.IOxmId
12676 GetDstOfs() uint16
12677}
12678
12679func (self *FlowModSpecSrc0Dst0) GetSrc() goloxi.IOxmId {
12680 return self.Src
12681}
12682
12683func (self *FlowModSpecSrc0Dst0) SetSrc(v goloxi.IOxmId) {
12684 self.Src = v
12685}
12686
12687func (self *FlowModSpecSrc0Dst0) GetSrcOfs() uint16 {
12688 return self.SrcOfs
12689}
12690
12691func (self *FlowModSpecSrc0Dst0) SetSrcOfs(v uint16) {
12692 self.SrcOfs = v
12693}
12694
12695func (self *FlowModSpecSrc0Dst0) GetDst() goloxi.IOxmId {
12696 return self.Dst
12697}
12698
12699func (self *FlowModSpecSrc0Dst0) SetDst(v goloxi.IOxmId) {
12700 self.Dst = v
12701}
12702
12703func (self *FlowModSpecSrc0Dst0) GetDstOfs() uint16 {
12704 return self.DstOfs
12705}
12706
12707func (self *FlowModSpecSrc0Dst0) SetDstOfs(v uint16) {
12708 self.DstOfs = v
12709}
12710
12711func (self *FlowModSpecSrc0Dst0) Serialize(encoder *goloxi.Encoder) error {
12712 if err := self.FlowModSpec.Serialize(encoder); err != nil {
12713 return err
12714 }
12715
12716 self.Src.Serialize(encoder)
12717 encoder.PutUint16(uint16(self.SrcOfs))
12718 self.Dst.Serialize(encoder)
12719 encoder.PutUint16(uint16(self.DstOfs))
12720
12721 return nil
12722}
12723
12724func DecodeFlowModSpecSrc0Dst0(parent *FlowModSpec, decoder *goloxi.Decoder) (IFlowModSpecSrc0Dst0, error) {
12725 _flowmodspecsrc0dst0 := &FlowModSpecSrc0Dst0{FlowModSpec: parent}
12726 if decoder.Length() < 12 {
12727 return nil, fmt.Errorf("FlowModSpecSrc0Dst0 packet too short: %d < 12", decoder.Length())
12728 }
12729 if obj, err := DecodeOxmId(decoder); err != nil {
12730 return nil, err
12731 } else {
12732 _flowmodspecsrc0dst0.Src = obj
12733 }
12734
12735 _flowmodspecsrc0dst0.SrcOfs = uint16(decoder.ReadUint16())
12736 if obj, err := DecodeOxmId(decoder); err != nil {
12737 return nil, err
12738 } else {
12739 _flowmodspecsrc0dst0.Dst = obj
12740 }
12741
12742 _flowmodspecsrc0dst0.DstOfs = uint16(decoder.ReadUint16())
12743 return _flowmodspecsrc0dst0, nil
12744}
12745
12746func NewFlowModSpecSrc0Dst0(_n_bits uint8) *FlowModSpecSrc0Dst0 {
12747 obj := &FlowModSpecSrc0Dst0{
12748 FlowModSpec: NewFlowModSpec(0),
12749 }
12750 obj.NBits = _n_bits
12751 return obj
12752}
12753
12754type FlowModSpecSrc0Dst1 struct {
12755 *FlowModSpec
12756 Src goloxi.IOxmId
12757 SrcOfs uint16
12758 Dst goloxi.IOxmId
12759 DstOfs uint16
12760}
12761
12762type IFlowModSpecSrc0Dst1 interface {
12763 IFlowModSpec
12764 GetSrc() goloxi.IOxmId
12765 GetSrcOfs() uint16
12766 GetDst() goloxi.IOxmId
12767 GetDstOfs() uint16
12768}
12769
12770func (self *FlowModSpecSrc0Dst1) GetSrc() goloxi.IOxmId {
12771 return self.Src
12772}
12773
12774func (self *FlowModSpecSrc0Dst1) SetSrc(v goloxi.IOxmId) {
12775 self.Src = v
12776}
12777
12778func (self *FlowModSpecSrc0Dst1) GetSrcOfs() uint16 {
12779 return self.SrcOfs
12780}
12781
12782func (self *FlowModSpecSrc0Dst1) SetSrcOfs(v uint16) {
12783 self.SrcOfs = v
12784}
12785
12786func (self *FlowModSpecSrc0Dst1) GetDst() goloxi.IOxmId {
12787 return self.Dst
12788}
12789
12790func (self *FlowModSpecSrc0Dst1) SetDst(v goloxi.IOxmId) {
12791 self.Dst = v
12792}
12793
12794func (self *FlowModSpecSrc0Dst1) GetDstOfs() uint16 {
12795 return self.DstOfs
12796}
12797
12798func (self *FlowModSpecSrc0Dst1) SetDstOfs(v uint16) {
12799 self.DstOfs = v
12800}
12801
12802func (self *FlowModSpecSrc0Dst1) Serialize(encoder *goloxi.Encoder) error {
12803 if err := self.FlowModSpec.Serialize(encoder); err != nil {
12804 return err
12805 }
12806
12807 self.Src.Serialize(encoder)
12808 encoder.PutUint16(uint16(self.SrcOfs))
12809 self.Dst.Serialize(encoder)
12810 encoder.PutUint16(uint16(self.DstOfs))
12811
12812 return nil
12813}
12814
12815func DecodeFlowModSpecSrc0Dst1(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc0Dst1, error) {
12816 _flowmodspecsrc0dst1 := &FlowModSpecSrc0Dst1{FlowModSpec: parent}
12817 if decoder.Length() < 12 {
12818 return nil, fmt.Errorf("FlowModSpecSrc0Dst1 packet too short: %d < 12", decoder.Length())
12819 }
12820 if obj, err := DecodeOxmId(decoder); err != nil {
12821 return nil, err
12822 } else {
12823 _flowmodspecsrc0dst1.Src = obj
12824 }
12825
12826 _flowmodspecsrc0dst1.SrcOfs = uint16(decoder.ReadUint16())
12827 if obj, err := DecodeOxmId(decoder); err != nil {
12828 return nil, err
12829 } else {
12830 _flowmodspecsrc0dst1.Dst = obj
12831 }
12832
12833 _flowmodspecsrc0dst1.DstOfs = uint16(decoder.ReadUint16())
12834 return _flowmodspecsrc0dst1, nil
12835}
12836
12837func NewFlowModSpecSrc0Dst1() *FlowModSpecSrc0Dst1 {
12838 obj := &FlowModSpecSrc0Dst1{
12839 FlowModSpec: NewFlowModSpec(8),
12840 }
12841 return obj
12842}
12843
12844type FlowModSpecSrc0Dst2 struct {
12845 *FlowModSpec
12846 Src goloxi.IOxmId
12847 SrcOfs uint16
12848}
12849
12850type IFlowModSpecSrc0Dst2 interface {
12851 IFlowModSpec
12852 GetSrc() goloxi.IOxmId
12853 GetSrcOfs() uint16
12854}
12855
12856func (self *FlowModSpecSrc0Dst2) GetSrc() goloxi.IOxmId {
12857 return self.Src
12858}
12859
12860func (self *FlowModSpecSrc0Dst2) SetSrc(v goloxi.IOxmId) {
12861 self.Src = v
12862}
12863
12864func (self *FlowModSpecSrc0Dst2) GetSrcOfs() uint16 {
12865 return self.SrcOfs
12866}
12867
12868func (self *FlowModSpecSrc0Dst2) SetSrcOfs(v uint16) {
12869 self.SrcOfs = v
12870}
12871
12872func (self *FlowModSpecSrc0Dst2) Serialize(encoder *goloxi.Encoder) error {
12873 if err := self.FlowModSpec.Serialize(encoder); err != nil {
12874 return err
12875 }
12876
12877 self.Src.Serialize(encoder)
12878 encoder.PutUint16(uint16(self.SrcOfs))
12879
12880 return nil
12881}
12882
12883func DecodeFlowModSpecSrc0Dst2(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc0Dst2, error) {
12884 _flowmodspecsrc0dst2 := &FlowModSpecSrc0Dst2{FlowModSpec: parent}
12885 if decoder.Length() < 6 {
12886 return nil, fmt.Errorf("FlowModSpecSrc0Dst2 packet too short: %d < 6", decoder.Length())
12887 }
12888 if obj, err := DecodeOxmId(decoder); err != nil {
12889 return nil, err
12890 } else {
12891 _flowmodspecsrc0dst2.Src = obj
12892 }
12893
12894 _flowmodspecsrc0dst2.SrcOfs = uint16(decoder.ReadUint16())
12895 return _flowmodspecsrc0dst2, nil
12896}
12897
12898func NewFlowModSpecSrc0Dst2() *FlowModSpecSrc0Dst2 {
12899 obj := &FlowModSpecSrc0Dst2{
12900 FlowModSpec: NewFlowModSpec(16),
12901 }
12902 return obj
12903}
12904
12905type FlowModSpecSrc1Dst0 struct {
12906 *FlowModSpec
12907 Src []byte
12908 Dst goloxi.IOxmId
12909 DstOfs uint16
12910}
12911
12912type IFlowModSpecSrc1Dst0 interface {
12913 IFlowModSpec
12914 GetSrc() []byte
12915 GetDst() goloxi.IOxmId
12916 GetDstOfs() uint16
12917}
12918
12919func (self *FlowModSpecSrc1Dst0) GetSrc() []byte {
12920 return self.Src
12921}
12922
12923func (self *FlowModSpecSrc1Dst0) SetSrc(v []byte) {
12924 self.Src = v
12925}
12926
12927func (self *FlowModSpecSrc1Dst0) GetDst() goloxi.IOxmId {
12928 return self.Dst
12929}
12930
12931func (self *FlowModSpecSrc1Dst0) SetDst(v goloxi.IOxmId) {
12932 self.Dst = v
12933}
12934
12935func (self *FlowModSpecSrc1Dst0) GetDstOfs() uint16 {
12936 return self.DstOfs
12937}
12938
12939func (self *FlowModSpecSrc1Dst0) SetDstOfs(v uint16) {
12940 self.DstOfs = v
12941}
12942
12943func (self *FlowModSpecSrc1Dst0) Serialize(encoder *goloxi.Encoder) error {
12944 if err := self.FlowModSpec.Serialize(encoder); err != nil {
12945 return err
12946 }
12947
12948 encoder.Write(self.Src)
12949 self.Dst.Serialize(encoder)
12950 encoder.PutUint16(uint16(self.DstOfs))
12951
12952 return nil
12953}
12954
12955func DecodeFlowModSpecSrc1Dst0(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc1Dst0, error) {
12956 _flowmodspecsrc1dst0 := &FlowModSpecSrc1Dst0{FlowModSpec: parent}
12957 if decoder.Length() < 6 {
12958 return nil, fmt.Errorf("FlowModSpecSrc1Dst0 packet too short: %d < 6", decoder.Length())
12959 }
12960 _flowmodspecsrc1dst0.Src = decoder.SliceDecoder(int((_flowmodspecsrc1dst0.NBits+15)/16*2), 0).Read(int(_flowmodspecsrc1dst0.NBits))
12961 if obj, err := DecodeOxmId(decoder); err != nil {
12962 return nil, err
12963 } else {
12964 _flowmodspecsrc1dst0.Dst = obj
12965 }
12966
12967 _flowmodspecsrc1dst0.DstOfs = uint16(decoder.ReadUint16())
12968 return _flowmodspecsrc1dst0, nil
12969}
12970
12971func NewFlowModSpecSrc1Dst0() *FlowModSpecSrc1Dst0 {
12972 obj := &FlowModSpecSrc1Dst0{
12973 FlowModSpec: NewFlowModSpec(32),
12974 }
12975 return obj
12976}
12977
12978type FlowModSpecSrc1Dst1 struct {
12979 *FlowModSpec
12980 Src []byte
12981 Dst goloxi.IOxmId
12982 DstOfs uint16
12983}
12984
12985type IFlowModSpecSrc1Dst1 interface {
12986 IFlowModSpec
12987 GetSrc() []byte
12988 GetDst() goloxi.IOxmId
12989 GetDstOfs() uint16
12990}
12991
12992func (self *FlowModSpecSrc1Dst1) GetSrc() []byte {
12993 return self.Src
12994}
12995
12996func (self *FlowModSpecSrc1Dst1) SetSrc(v []byte) {
12997 self.Src = v
12998}
12999
13000func (self *FlowModSpecSrc1Dst1) GetDst() goloxi.IOxmId {
13001 return self.Dst
13002}
13003
13004func (self *FlowModSpecSrc1Dst1) SetDst(v goloxi.IOxmId) {
13005 self.Dst = v
13006}
13007
13008func (self *FlowModSpecSrc1Dst1) GetDstOfs() uint16 {
13009 return self.DstOfs
13010}
13011
13012func (self *FlowModSpecSrc1Dst1) SetDstOfs(v uint16) {
13013 self.DstOfs = v
13014}
13015
13016func (self *FlowModSpecSrc1Dst1) Serialize(encoder *goloxi.Encoder) error {
13017 if err := self.FlowModSpec.Serialize(encoder); err != nil {
13018 return err
13019 }
13020
13021 encoder.Write(self.Src)
13022 self.Dst.Serialize(encoder)
13023 encoder.PutUint16(uint16(self.DstOfs))
13024
13025 return nil
13026}
13027
13028func DecodeFlowModSpecSrc1Dst1(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc1Dst1, error) {
13029 _flowmodspecsrc1dst1 := &FlowModSpecSrc1Dst1{FlowModSpec: parent}
13030 if decoder.Length() < 6 {
13031 return nil, fmt.Errorf("FlowModSpecSrc1Dst1 packet too short: %d < 6", decoder.Length())
13032 }
13033 _flowmodspecsrc1dst1.Src = decoder.SliceDecoder(int((_flowmodspecsrc1dst1.NBits+15)/16*2), 0).Read(int(_flowmodspecsrc1dst1.NBits))
13034 if obj, err := DecodeOxmId(decoder); err != nil {
13035 return nil, err
13036 } else {
13037 _flowmodspecsrc1dst1.Dst = obj
13038 }
13039
13040 _flowmodspecsrc1dst1.DstOfs = uint16(decoder.ReadUint16())
13041 return _flowmodspecsrc1dst1, nil
13042}
13043
13044func NewFlowModSpecSrc1Dst1() *FlowModSpecSrc1Dst1 {
13045 obj := &FlowModSpecSrc1Dst1{
13046 FlowModSpec: NewFlowModSpec(40),
13047 }
13048 return obj
13049}
13050
13051type FlowStatsEntry struct {
13052 Length uint16
13053 TableId uint8
13054 DurationSec uint32
13055 DurationNsec uint32
13056 Priority uint16
13057 IdleTimeout uint16
13058 HardTimeout uint16
13059 Flags FlowModFlags
13060 Cookie uint64
13061 PacketCount uint64
13062 ByteCount uint64
13063 Match Match
13064 Instructions []IInstruction
13065}
13066
13067type IFlowStatsEntry interface {
13068 goloxi.Serializable
13069 GetLength() uint16
13070 GetTableId() uint8
13071 GetDurationSec() uint32
13072 GetDurationNsec() uint32
13073 GetPriority() uint16
13074 GetIdleTimeout() uint16
13075 GetHardTimeout() uint16
13076 GetFlags() FlowModFlags
13077 GetCookie() uint64
13078 GetPacketCount() uint64
13079 GetByteCount() uint64
13080 GetMatch() Match
13081 GetInstructions() []IInstruction
13082}
13083
13084func (self *FlowStatsEntry) GetLength() uint16 {
13085 return self.Length
13086}
13087
13088func (self *FlowStatsEntry) SetLength(v uint16) {
13089 self.Length = v
13090}
13091
13092func (self *FlowStatsEntry) GetTableId() uint8 {
13093 return self.TableId
13094}
13095
13096func (self *FlowStatsEntry) SetTableId(v uint8) {
13097 self.TableId = v
13098}
13099
13100func (self *FlowStatsEntry) GetDurationSec() uint32 {
13101 return self.DurationSec
13102}
13103
13104func (self *FlowStatsEntry) SetDurationSec(v uint32) {
13105 self.DurationSec = v
13106}
13107
13108func (self *FlowStatsEntry) GetDurationNsec() uint32 {
13109 return self.DurationNsec
13110}
13111
13112func (self *FlowStatsEntry) SetDurationNsec(v uint32) {
13113 self.DurationNsec = v
13114}
13115
13116func (self *FlowStatsEntry) GetPriority() uint16 {
13117 return self.Priority
13118}
13119
13120func (self *FlowStatsEntry) SetPriority(v uint16) {
13121 self.Priority = v
13122}
13123
13124func (self *FlowStatsEntry) GetIdleTimeout() uint16 {
13125 return self.IdleTimeout
13126}
13127
13128func (self *FlowStatsEntry) SetIdleTimeout(v uint16) {
13129 self.IdleTimeout = v
13130}
13131
13132func (self *FlowStatsEntry) GetHardTimeout() uint16 {
13133 return self.HardTimeout
13134}
13135
13136func (self *FlowStatsEntry) SetHardTimeout(v uint16) {
13137 self.HardTimeout = v
13138}
13139
13140func (self *FlowStatsEntry) GetFlags() FlowModFlags {
13141 return self.Flags
13142}
13143
13144func (self *FlowStatsEntry) SetFlags(v FlowModFlags) {
13145 self.Flags = v
13146}
13147
13148func (self *FlowStatsEntry) GetCookie() uint64 {
13149 return self.Cookie
13150}
13151
13152func (self *FlowStatsEntry) SetCookie(v uint64) {
13153 self.Cookie = v
13154}
13155
13156func (self *FlowStatsEntry) GetPacketCount() uint64 {
13157 return self.PacketCount
13158}
13159
13160func (self *FlowStatsEntry) SetPacketCount(v uint64) {
13161 self.PacketCount = v
13162}
13163
13164func (self *FlowStatsEntry) GetByteCount() uint64 {
13165 return self.ByteCount
13166}
13167
13168func (self *FlowStatsEntry) SetByteCount(v uint64) {
13169 self.ByteCount = v
13170}
13171
13172func (self *FlowStatsEntry) GetMatch() Match {
13173 return self.Match
13174}
13175
13176func (self *FlowStatsEntry) SetMatch(v Match) {
13177 self.Match = v
13178}
13179
13180func (self *FlowStatsEntry) GetInstructions() []IInstruction {
13181 return self.Instructions
13182}
13183
13184func (self *FlowStatsEntry) SetInstructions(v []IInstruction) {
13185 self.Instructions = v
13186}
13187
13188func (self *FlowStatsEntry) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]13189 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]13190
13191 encoder.PutUint16(uint16(self.Length))
13192 encoder.PutUint8(uint8(self.TableId))
13193 encoder.Write(bytes.Repeat([]byte{0}, 1))
13194 encoder.PutUint32(uint32(self.DurationSec))
13195 encoder.PutUint32(uint32(self.DurationNsec))
13196 encoder.PutUint16(uint16(self.Priority))
13197 encoder.PutUint16(uint16(self.IdleTimeout))
13198 encoder.PutUint16(uint16(self.HardTimeout))
13199 encoder.PutUint16(uint16(self.Flags))
13200 encoder.Write(bytes.Repeat([]byte{0}, 4))
13201 encoder.PutUint64(uint64(self.Cookie))
13202 encoder.PutUint64(uint64(self.PacketCount))
13203 encoder.PutUint64(uint64(self.ByteCount))
13204 if err := self.Match.Serialize(encoder); err != nil {
13205 return err
13206 }
13207
13208 for _, obj := range self.Instructions {
13209 if err := obj.Serialize(encoder); err != nil {
13210 return err
13211 }
13212 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]13213 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]13214
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]13215 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]13216
13217 return nil
13218}
13219
13220func DecodeFlowStatsEntry(decoder *goloxi.Decoder) (*FlowStatsEntry, error) {
13221 _flowstatsentry := &FlowStatsEntry{}
13222 if decoder.Length() < 56 {
13223 return nil, fmt.Errorf("FlowStatsEntry packet too short: %d < 56", decoder.Length())
13224 }
13225 _flowstatsentry.Length = uint16(decoder.ReadUint16())
13226 oldDecoder := decoder
13227 defer func() { decoder = oldDecoder }()
13228 decoder = decoder.SliceDecoder(int(_flowstatsentry.Length), 2+0)
13229 _flowstatsentry.TableId = uint8(decoder.ReadByte())
13230 decoder.Skip(1)
13231 _flowstatsentry.DurationSec = uint32(decoder.ReadUint32())
13232 _flowstatsentry.DurationNsec = uint32(decoder.ReadUint32())
13233 _flowstatsentry.Priority = uint16(decoder.ReadUint16())
13234 _flowstatsentry.IdleTimeout = uint16(decoder.ReadUint16())
13235 _flowstatsentry.HardTimeout = uint16(decoder.ReadUint16())
13236 _flowstatsentry.Flags = FlowModFlags(decoder.ReadUint16())
13237 decoder.Skip(4)
13238 _flowstatsentry.Cookie = uint64(decoder.ReadUint64())
13239 _flowstatsentry.PacketCount = uint64(decoder.ReadUint64())
13240 _flowstatsentry.ByteCount = uint64(decoder.ReadUint64())
13241 if err := _flowstatsentry.Match.Decode(decoder); err != nil {
13242 return nil, err
13243 }
13244
13245 decoder.SkipAlign()
13246
13247 for decoder.Length() >= 4 {
13248 item, err := DecodeInstruction(decoder)
13249 if err != nil {
13250 return nil, err
13251 }
13252 if item != nil {
13253 _flowstatsentry.Instructions = append(_flowstatsentry.Instructions, item)
13254 }
13255 }
13256 return _flowstatsentry, nil
13257}
13258
13259func NewFlowStatsEntry() *FlowStatsEntry {
13260 obj := &FlowStatsEntry{}
13261 return obj
13262}
13263
13264type GroupDescStatsEntry struct {
13265 Length uint16
13266 GroupType GroupType
13267 GroupId uint32
13268 Buckets []*Bucket
13269}
13270
13271type IGroupDescStatsEntry interface {
13272 goloxi.Serializable
13273 GetLength() uint16
13274 GetGroupType() GroupType
13275 GetGroupId() uint32
13276 GetBuckets() []*Bucket
13277}
13278
13279func (self *GroupDescStatsEntry) GetLength() uint16 {
13280 return self.Length
13281}
13282
13283func (self *GroupDescStatsEntry) SetLength(v uint16) {
13284 self.Length = v
13285}
13286
13287func (self *GroupDescStatsEntry) GetGroupType() GroupType {
13288 return self.GroupType
13289}
13290
13291func (self *GroupDescStatsEntry) SetGroupType(v GroupType) {
13292 self.GroupType = v
13293}
13294
13295func (self *GroupDescStatsEntry) GetGroupId() uint32 {
13296 return self.GroupId
13297}
13298
13299func (self *GroupDescStatsEntry) SetGroupId(v uint32) {
13300 self.GroupId = v
13301}
13302
13303func (self *GroupDescStatsEntry) GetBuckets() []*Bucket {
13304 return self.Buckets
13305}
13306
13307func (self *GroupDescStatsEntry) SetBuckets(v []*Bucket) {
13308 self.Buckets = v
13309}
13310
13311func (self *GroupDescStatsEntry) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]13312 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]13313
13314 encoder.PutUint16(uint16(self.Length))
13315 encoder.PutUint8(uint8(self.GroupType))
13316 encoder.Write(bytes.Repeat([]byte{0}, 1))
13317 encoder.PutUint32(uint32(self.GroupId))
13318 for _, obj := range self.Buckets {
13319 if err := obj.Serialize(encoder); err != nil {
13320 return err
13321 }
13322 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]13323 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]13324
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]13325 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]13326
13327 return nil
13328}
13329
13330func DecodeGroupDescStatsEntry(decoder *goloxi.Decoder) (*GroupDescStatsEntry, error) {
13331 _groupdescstatsentry := &GroupDescStatsEntry{}
13332 if decoder.Length() < 8 {
13333 return nil, fmt.Errorf("GroupDescStatsEntry packet too short: %d < 8", decoder.Length())
13334 }
13335 _groupdescstatsentry.Length = uint16(decoder.ReadUint16())
13336 oldDecoder := decoder
13337 defer func() { decoder = oldDecoder }()
13338 decoder = decoder.SliceDecoder(int(_groupdescstatsentry.Length), 2+0)
13339 _groupdescstatsentry.GroupType = GroupType(decoder.ReadByte())
13340 decoder.Skip(1)
13341 _groupdescstatsentry.GroupId = uint32(decoder.ReadUint32())
13342
13343 for decoder.Length() >= 16 {
13344 item, err := DecodeBucket(decoder)
13345 if err != nil {
13346 return nil, err
13347 }
13348 if item != nil {
13349 _groupdescstatsentry.Buckets = append(_groupdescstatsentry.Buckets, item)
13350 }
13351 }
13352 return _groupdescstatsentry, nil
13353}
13354
13355func NewGroupDescStatsEntry() *GroupDescStatsEntry {
13356 obj := &GroupDescStatsEntry{}
13357 return obj
13358}
13359
13360type GroupStatsEntry struct {
13361 Length uint16
13362 GroupId uint32
13363 RefCount uint32
13364 PacketCount uint64
13365 ByteCount uint64
13366 DurationSec uint32
13367 DurationNsec uint32
13368 BucketStats []*BucketCounter
13369}
13370
13371type IGroupStatsEntry interface {
13372 goloxi.Serializable
13373 GetLength() uint16
13374 GetGroupId() uint32
13375 GetRefCount() uint32
13376 GetPacketCount() uint64
13377 GetByteCount() uint64
13378 GetDurationSec() uint32
13379 GetDurationNsec() uint32
13380 GetBucketStats() []*BucketCounter
13381}
13382
13383func (self *GroupStatsEntry) GetLength() uint16 {
13384 return self.Length
13385}
13386
13387func (self *GroupStatsEntry) SetLength(v uint16) {
13388 self.Length = v
13389}
13390
13391func (self *GroupStatsEntry) GetGroupId() uint32 {
13392 return self.GroupId
13393}
13394
13395func (self *GroupStatsEntry) SetGroupId(v uint32) {
13396 self.GroupId = v
13397}
13398
13399func (self *GroupStatsEntry) GetRefCount() uint32 {
13400 return self.RefCount
13401}
13402
13403func (self *GroupStatsEntry) SetRefCount(v uint32) {
13404 self.RefCount = v
13405}
13406
13407func (self *GroupStatsEntry) GetPacketCount() uint64 {
13408 return self.PacketCount
13409}
13410
13411func (self *GroupStatsEntry) SetPacketCount(v uint64) {
13412 self.PacketCount = v
13413}
13414
13415func (self *GroupStatsEntry) GetByteCount() uint64 {
13416 return self.ByteCount
13417}
13418
13419func (self *GroupStatsEntry) SetByteCount(v uint64) {
13420 self.ByteCount = v
13421}
13422
13423func (self *GroupStatsEntry) GetDurationSec() uint32 {
13424 return self.DurationSec
13425}
13426
13427func (self *GroupStatsEntry) SetDurationSec(v uint32) {
13428 self.DurationSec = v
13429}
13430
13431func (self *GroupStatsEntry) GetDurationNsec() uint32 {
13432 return self.DurationNsec
13433}
13434
13435func (self *GroupStatsEntry) SetDurationNsec(v uint32) {
13436 self.DurationNsec = v
13437}
13438
13439func (self *GroupStatsEntry) GetBucketStats() []*BucketCounter {
13440 return self.BucketStats
13441}
13442
13443func (self *GroupStatsEntry) SetBucketStats(v []*BucketCounter) {
13444 self.BucketStats = v
13445}
13446
13447func (self *GroupStatsEntry) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]13448 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]13449
13450 encoder.PutUint16(uint16(self.Length))
13451 encoder.Write(bytes.Repeat([]byte{0}, 2))
13452 encoder.PutUint32(uint32(self.GroupId))
13453 encoder.PutUint32(uint32(self.RefCount))
13454 encoder.Write(bytes.Repeat([]byte{0}, 4))
13455 encoder.PutUint64(uint64(self.PacketCount))
13456 encoder.PutUint64(uint64(self.ByteCount))
13457 encoder.PutUint32(uint32(self.DurationSec))
13458 encoder.PutUint32(uint32(self.DurationNsec))
13459 for _, obj := range self.BucketStats {
13460 if err := obj.Serialize(encoder); err != nil {
13461 return err
13462 }
13463 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]13464 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]13465
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]13466 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]13467
13468 return nil
13469}
13470
13471func DecodeGroupStatsEntry(decoder *goloxi.Decoder) (*GroupStatsEntry, error) {
13472 _groupstatsentry := &GroupStatsEntry{}
13473 if decoder.Length() < 40 {
13474 return nil, fmt.Errorf("GroupStatsEntry packet too short: %d < 40", decoder.Length())
13475 }
13476 _groupstatsentry.Length = uint16(decoder.ReadUint16())
13477 oldDecoder := decoder
13478 defer func() { decoder = oldDecoder }()
13479 decoder = decoder.SliceDecoder(int(_groupstatsentry.Length), 2+0)
13480 decoder.Skip(2)
13481 _groupstatsentry.GroupId = uint32(decoder.ReadUint32())
13482 _groupstatsentry.RefCount = uint32(decoder.ReadUint32())
13483 decoder.Skip(4)
13484 _groupstatsentry.PacketCount = uint64(decoder.ReadUint64())
13485 _groupstatsentry.ByteCount = uint64(decoder.ReadUint64())
13486 _groupstatsentry.DurationSec = uint32(decoder.ReadUint32())
13487 _groupstatsentry.DurationNsec = uint32(decoder.ReadUint32())
13488
13489 for decoder.Length() >= 16 {
13490 item, err := DecodeBucketCounter(decoder)
13491 if err != nil {
13492 return nil, err
13493 }
13494 if item != nil {
13495 _groupstatsentry.BucketStats = append(_groupstatsentry.BucketStats, item)
13496 }
13497 }
13498 return _groupstatsentry, nil
13499}
13500
13501func NewGroupStatsEntry() *GroupStatsEntry {
13502 obj := &GroupStatsEntry{}
13503 return obj
13504}
13505
13506type HelloElem struct {
13507 Type uint16
13508 Length uint16
13509}
13510
13511type IHelloElem interface {
13512 goloxi.Serializable
13513 GetType() uint16
13514 GetLength() uint16
13515}
13516
13517func (self *HelloElem) GetType() uint16 {
13518 return self.Type
13519}
13520
13521func (self *HelloElem) SetType(v uint16) {
13522 self.Type = v
13523}
13524
13525func (self *HelloElem) GetLength() uint16 {
13526 return self.Length
13527}
13528
13529func (self *HelloElem) SetLength(v uint16) {
13530 self.Length = v
13531}
13532
13533func (self *HelloElem) Serialize(encoder *goloxi.Encoder) error {
13534
13535 encoder.PutUint16(uint16(self.Type))
13536 encoder.PutUint16(uint16(self.Length))
13537
13538 return nil
13539}
13540
13541func DecodeHelloElem(decoder *goloxi.Decoder) (IHelloElem, error) {
13542 _helloelem := &HelloElem{}
13543 if decoder.Length() < 4 {
13544 return nil, fmt.Errorf("HelloElem packet too short: %d < 4", decoder.Length())
13545 }
13546 _helloelem.Type = uint16(decoder.ReadUint16())
13547 _helloelem.Length = uint16(decoder.ReadUint16())
13548 oldDecoder := decoder
13549 defer func() { decoder = oldDecoder }()
13550 decoder = decoder.SliceDecoder(int(_helloelem.Length), 2+2)
13551
13552 switch _helloelem.Type {
13553 case 1:
13554 return DecodeHelloElemVersionbitmap(_helloelem, decoder)
13555 default:
13556 return nil, fmt.Errorf("Invalid type '%d' for 'HelloElem'", _helloelem.Type)
13557 }
13558}
13559
13560func NewHelloElem(_type uint16) *HelloElem {
13561 obj := &HelloElem{}
13562 obj.Type = _type
13563 return obj
13564}
13565
13566type HelloElemVersionbitmap struct {
13567 *HelloElem
13568 Bitmaps []*Uint32
13569}
13570
13571type IHelloElemVersionbitmap interface {
13572 IHelloElem
13573 GetBitmaps() []*Uint32
13574}
13575
13576func (self *HelloElemVersionbitmap) GetBitmaps() []*Uint32 {
13577 return self.Bitmaps
13578}
13579
13580func (self *HelloElemVersionbitmap) SetBitmaps(v []*Uint32) {
13581 self.Bitmaps = v
13582}
13583
13584func (self *HelloElemVersionbitmap) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]13585 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]13586 if err := self.HelloElem.Serialize(encoder); err != nil {
13587 return err
13588 }
13589
13590 for _, obj := range self.Bitmaps {
13591 if err := obj.Serialize(encoder); err != nil {
13592 return err
13593 }
13594 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]13595 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]13596
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]13597 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]13598
13599 return nil
13600}
13601
13602func DecodeHelloElemVersionbitmap(parent *HelloElem, decoder *goloxi.Decoder) (*HelloElemVersionbitmap, error) {
13603 _helloelemversionbitmap := &HelloElemVersionbitmap{HelloElem: parent}
13604
13605 for decoder.Length() >= 4 {
13606 item, err := DecodeUint32(decoder)
13607 if err != nil {
13608 return nil, err
13609 }
13610 if item != nil {
13611 _helloelemversionbitmap.Bitmaps = append(_helloelemversionbitmap.Bitmaps, item)
13612 }
13613 }
13614 return _helloelemversionbitmap, nil
13615}
13616
13617func NewHelloElemVersionbitmap() *HelloElemVersionbitmap {
13618 obj := &HelloElemVersionbitmap{
13619 HelloElem: NewHelloElem(1),
13620 }
13621 return obj
13622}
13623
13624type InstructionId struct {
13625 Type uint16
13626 Len uint16
13627}
13628
13629type IInstructionId interface {
13630 goloxi.Serializable
13631 GetType() uint16
13632 GetLen() uint16
13633}
13634
13635func (self *InstructionId) GetType() uint16 {
13636 return self.Type
13637}
13638
13639func (self *InstructionId) SetType(v uint16) {
13640 self.Type = v
13641}
13642
13643func (self *InstructionId) GetLen() uint16 {
13644 return self.Len
13645}
13646
13647func (self *InstructionId) SetLen(v uint16) {
13648 self.Len = v
13649}
13650
13651func (self *InstructionId) Serialize(encoder *goloxi.Encoder) error {
13652
13653 encoder.PutUint16(uint16(self.Type))
13654 encoder.PutUint16(uint16(self.Len))
13655
13656 return nil
13657}
13658
13659func DecodeInstructionId(decoder *goloxi.Decoder) (IInstructionId, error) {
13660 _instructionid := &InstructionId{}
13661 if decoder.Length() < 4 {
13662 return nil, fmt.Errorf("InstructionId packet too short: %d < 4", decoder.Length())
13663 }
13664 _instructionid.Type = uint16(decoder.ReadUint16())
13665 _instructionid.Len = uint16(decoder.ReadUint16())
13666 oldDecoder := decoder
13667 defer func() { decoder = oldDecoder }()
13668 decoder = decoder.SliceDecoder(int(_instructionid.Len), 2+2)
13669
13670 switch _instructionid.Type {
13671 case 1:
13672 return DecodeInstructionIdGotoTable(_instructionid, decoder)
13673 case 2:
13674 return DecodeInstructionIdWriteMetadata(_instructionid, decoder)
13675 case 3:
13676 return DecodeInstructionIdWriteActions(_instructionid, decoder)
13677 case 4:
13678 return DecodeInstructionIdApplyActions(_instructionid, decoder)
13679 case 5:
13680 return DecodeInstructionIdClearActions(_instructionid, decoder)
13681 case 6:
13682 return DecodeInstructionIdMeter(_instructionid, decoder)
13683 case 65535:
13684 return DecodeInstructionIdExperimenter(_instructionid, decoder)
13685 default:
13686 return nil, fmt.Errorf("Invalid type '%d' for 'InstructionId'", _instructionid.Type)
13687 }
13688}
13689
13690func NewInstructionId(_type uint16) *InstructionId {
13691 obj := &InstructionId{}
13692 obj.Type = _type
13693 return obj
13694}
13695
13696type InstructionIdApplyActions struct {
13697 *InstructionId
13698}
13699
13700type IInstructionIdApplyActions interface {
13701 IInstructionId
13702}
13703
13704func (self *InstructionIdApplyActions) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]13705 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]13706 if err := self.InstructionId.Serialize(encoder); err != nil {
13707 return err
13708 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]13709 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]13710
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]13711 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]13712
13713 return nil
13714}
13715
13716func DecodeInstructionIdApplyActions(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdApplyActions, error) {
13717 _instructionidapplyactions := &InstructionIdApplyActions{InstructionId: parent}
13718 return _instructionidapplyactions, nil
13719}
13720
13721func NewInstructionIdApplyActions() *InstructionIdApplyActions {
13722 obj := &InstructionIdApplyActions{
13723 InstructionId: NewInstructionId(4),
13724 }
13725 return obj
13726}
13727
13728type InstructionIdExperimenter struct {
13729 *InstructionId
13730 Experimenter uint32
13731}
13732
13733type IInstructionIdExperimenter interface {
13734 IInstructionId
13735 GetExperimenter() uint32
13736}
13737
13738func (self *InstructionIdExperimenter) GetExperimenter() uint32 {
13739 return self.Experimenter
13740}
13741
13742func (self *InstructionIdExperimenter) SetExperimenter(v uint32) {
13743 self.Experimenter = v
13744}
13745
13746func (self *InstructionIdExperimenter) Serialize(encoder *goloxi.Encoder) error {
13747 if err := self.InstructionId.Serialize(encoder); err != nil {
13748 return err
13749 }
13750
13751 encoder.PutUint32(uint32(self.Experimenter))
13752
13753 return nil
13754}
13755
13756func DecodeInstructionIdExperimenter(parent *InstructionId, decoder *goloxi.Decoder) (IInstructionIdExperimenter, error) {
13757 _instructionidexperimenter := &InstructionIdExperimenter{InstructionId: parent}
13758 if decoder.Length() < 4 {
13759 return nil, fmt.Errorf("InstructionIdExperimenter packet too short: %d < 4", decoder.Length())
13760 }
13761 _instructionidexperimenter.Experimenter = uint32(decoder.ReadUint32())
13762
13763 switch _instructionidexperimenter.Experimenter {
13764 case 6035143:
13765 return DecodeInstructionIdBsn(_instructionidexperimenter, decoder)
13766 default:
13767 return nil, fmt.Errorf("Invalid type '%d' for 'InstructionIdExperimenter'", _instructionidexperimenter.Experimenter)
13768 }
13769}
13770
13771func NewInstructionIdExperimenter(_experimenter uint32) *InstructionIdExperimenter {
13772 obj := &InstructionIdExperimenter{
13773 InstructionId: NewInstructionId(65535),
13774 }
13775 obj.Experimenter = _experimenter
13776 return obj
13777}
13778
13779type InstructionIdBsn struct {
13780 *InstructionIdExperimenter
13781 Subtype uint32
13782}
13783
13784type IInstructionIdBsn interface {
13785 IInstructionIdExperimenter
13786 GetSubtype() uint32
13787}
13788
13789func (self *InstructionIdBsn) GetSubtype() uint32 {
13790 return self.Subtype
13791}
13792
13793func (self *InstructionIdBsn) SetSubtype(v uint32) {
13794 self.Subtype = v
13795}
13796
13797func (self *InstructionIdBsn) Serialize(encoder *goloxi.Encoder) error {
13798 if err := self.InstructionIdExperimenter.Serialize(encoder); err != nil {
13799 return err
13800 }
13801
13802 encoder.PutUint32(uint32(self.Subtype))
13803
13804 return nil
13805}
13806
13807func DecodeInstructionIdBsn(parent *InstructionIdExperimenter, decoder *goloxi.Decoder) (IInstructionIdBsn, error) {
13808 _instructionidbsn := &InstructionIdBsn{InstructionIdExperimenter: parent}
13809 if decoder.Length() < 4 {
13810 return nil, fmt.Errorf("InstructionIdBsn packet too short: %d < 4", decoder.Length())
13811 }
13812 _instructionidbsn.Subtype = uint32(decoder.ReadUint32())
13813
13814 switch _instructionidbsn.Subtype {
13815 case 0:
13816 return DecodeInstructionIdBsnDisableSrcMacCheck(_instructionidbsn, decoder)
13817 case 1:
13818 return DecodeInstructionIdBsnArpOffload(_instructionidbsn, decoder)
13819 case 2:
13820 return DecodeInstructionIdBsnDhcpOffload(_instructionidbsn, decoder)
13821 case 3:
13822 return DecodeInstructionIdBsnDisableSplitHorizonCheck(_instructionidbsn, decoder)
13823 case 4:
13824 return DecodeInstructionIdBsnPermit(_instructionidbsn, decoder)
13825 case 5:
13826 return DecodeInstructionIdBsnDeny(_instructionidbsn, decoder)
13827 case 6:
13828 return DecodeInstructionIdBsnPacketOfDeath(_instructionidbsn, decoder)
13829 case 7:
13830 return DecodeInstructionIdBsnPrioritizePdus(_instructionidbsn, decoder)
13831 case 8:
13832 return DecodeInstructionIdBsnRequireVlanXlate(_instructionidbsn, decoder)
13833 case 9:
13834 return DecodeInstructionIdBsnDisableVlanCounters(_instructionidbsn, decoder)
13835 case 10:
13836 return DecodeInstructionIdBsnSpanDestination(_instructionidbsn, decoder)
13837 case 11:
13838 return DecodeInstructionIdBsnAutoNegotiation(_instructionidbsn, decoder)
13839 case 12:
13840 return DecodeInstructionIdBsnInternalPriority(_instructionidbsn, decoder)
13841 case 13:
13842 return DecodeInstructionIdBsnDisableL3(_instructionidbsn, decoder)
13843 case 14:
13844 return DecodeInstructionIdBsnNdpOffload(_instructionidbsn, decoder)
13845 case 15:
13846 return DecodeInstructionIdBsnHashSelect(_instructionidbsn, decoder)
13847 case 16:
13848 return DecodeInstructionIdBsnDirectedBroadcast(_instructionidbsn, decoder)
13849 default:
13850 return nil, fmt.Errorf("Invalid type '%d' for 'InstructionIdBsn'", _instructionidbsn.Subtype)
13851 }
13852}
13853
13854func NewInstructionIdBsn(_subtype uint32) *InstructionIdBsn {
13855 obj := &InstructionIdBsn{
13856 InstructionIdExperimenter: NewInstructionIdExperimenter(6035143),
13857 }
13858 obj.Subtype = _subtype
13859 return obj
13860}
13861
13862type InstructionIdBsnArpOffload struct {
13863 *InstructionIdBsn
13864}
13865
13866type IInstructionIdBsnArpOffload interface {
13867 IInstructionIdBsn
13868}
13869
13870func (self *InstructionIdBsnArpOffload) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]13871 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]13872 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
13873 return err
13874 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]13875 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]13876
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]13877 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]13878
13879 return nil
13880}
13881
13882func DecodeInstructionIdBsnArpOffload(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnArpOffload, error) {
13883 _instructionidbsnarpoffload := &InstructionIdBsnArpOffload{InstructionIdBsn: parent}
13884 return _instructionidbsnarpoffload, nil
13885}
13886
13887func NewInstructionIdBsnArpOffload() *InstructionIdBsnArpOffload {
13888 obj := &InstructionIdBsnArpOffload{
13889 InstructionIdBsn: NewInstructionIdBsn(1),
13890 }
13891 return obj
13892}
13893
13894type InstructionIdBsnAutoNegotiation struct {
13895 *InstructionIdBsn
13896}
13897
13898type IInstructionIdBsnAutoNegotiation interface {
13899 IInstructionIdBsn
13900}
13901
13902func (self *InstructionIdBsnAutoNegotiation) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]13903 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]13904 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
13905 return err
13906 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]13907 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]13908
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]13909 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]13910
13911 return nil
13912}
13913
13914func DecodeInstructionIdBsnAutoNegotiation(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnAutoNegotiation, error) {
13915 _instructionidbsnautonegotiation := &InstructionIdBsnAutoNegotiation{InstructionIdBsn: parent}
13916 return _instructionidbsnautonegotiation, nil
13917}
13918
13919func NewInstructionIdBsnAutoNegotiation() *InstructionIdBsnAutoNegotiation {
13920 obj := &InstructionIdBsnAutoNegotiation{
13921 InstructionIdBsn: NewInstructionIdBsn(11),
13922 }
13923 return obj
13924}
13925
13926type InstructionIdBsnDeny struct {
13927 *InstructionIdBsn
13928}
13929
13930type IInstructionIdBsnDeny interface {
13931 IInstructionIdBsn
13932}
13933
13934func (self *InstructionIdBsnDeny) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]13935 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]13936 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
13937 return err
13938 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]13939 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]13940
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]13941 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]13942
13943 return nil
13944}
13945
13946func DecodeInstructionIdBsnDeny(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnDeny, error) {
13947 _instructionidbsndeny := &InstructionIdBsnDeny{InstructionIdBsn: parent}
13948 return _instructionidbsndeny, nil
13949}
13950
13951func NewInstructionIdBsnDeny() *InstructionIdBsnDeny {
13952 obj := &InstructionIdBsnDeny{
13953 InstructionIdBsn: NewInstructionIdBsn(5),
13954 }
13955 return obj
13956}
13957
13958type InstructionIdBsnDhcpOffload struct {
13959 *InstructionIdBsn
13960}
13961
13962type IInstructionIdBsnDhcpOffload interface {
13963 IInstructionIdBsn
13964}
13965
13966func (self *InstructionIdBsnDhcpOffload) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]13967 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]13968 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
13969 return err
13970 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]13971 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]13972
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]13973 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]13974
13975 return nil
13976}
13977
13978func DecodeInstructionIdBsnDhcpOffload(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnDhcpOffload, error) {
13979 _instructionidbsndhcpoffload := &InstructionIdBsnDhcpOffload{InstructionIdBsn: parent}
13980 return _instructionidbsndhcpoffload, nil
13981}
13982
13983func NewInstructionIdBsnDhcpOffload() *InstructionIdBsnDhcpOffload {
13984 obj := &InstructionIdBsnDhcpOffload{
13985 InstructionIdBsn: NewInstructionIdBsn(2),
13986 }
13987 return obj
13988}
13989
13990type InstructionIdBsnDirectedBroadcast struct {
13991 *InstructionIdBsn
13992}
13993
13994type IInstructionIdBsnDirectedBroadcast interface {
13995 IInstructionIdBsn
13996}
13997
13998func (self *InstructionIdBsnDirectedBroadcast) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]13999 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14000 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
14001 return err
14002 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14003 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14004
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14005 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14006
14007 return nil
14008}
14009
14010func DecodeInstructionIdBsnDirectedBroadcast(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnDirectedBroadcast, error) {
14011 _instructionidbsndirectedbroadcast := &InstructionIdBsnDirectedBroadcast{InstructionIdBsn: parent}
14012 return _instructionidbsndirectedbroadcast, nil
14013}
14014
14015func NewInstructionIdBsnDirectedBroadcast() *InstructionIdBsnDirectedBroadcast {
14016 obj := &InstructionIdBsnDirectedBroadcast{
14017 InstructionIdBsn: NewInstructionIdBsn(16),
14018 }
14019 return obj
14020}
14021
14022type InstructionIdBsnDisableL3 struct {
14023 *InstructionIdBsn
14024}
14025
14026type IInstructionIdBsnDisableL3 interface {
14027 IInstructionIdBsn
14028}
14029
14030func (self *InstructionIdBsnDisableL3) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14031 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14032 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
14033 return err
14034 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14035 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14036
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14037 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14038
14039 return nil
14040}
14041
14042func DecodeInstructionIdBsnDisableL3(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnDisableL3, error) {
14043 _instructionidbsndisablel3 := &InstructionIdBsnDisableL3{InstructionIdBsn: parent}
14044 return _instructionidbsndisablel3, nil
14045}
14046
14047func NewInstructionIdBsnDisableL3() *InstructionIdBsnDisableL3 {
14048 obj := &InstructionIdBsnDisableL3{
14049 InstructionIdBsn: NewInstructionIdBsn(13),
14050 }
14051 return obj
14052}
14053
14054type InstructionIdBsnDisableSplitHorizonCheck struct {
14055 *InstructionIdBsn
14056}
14057
14058type IInstructionIdBsnDisableSplitHorizonCheck interface {
14059 IInstructionIdBsn
14060}
14061
14062func (self *InstructionIdBsnDisableSplitHorizonCheck) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14063 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14064 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
14065 return err
14066 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14067 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14068
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14069 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14070
14071 return nil
14072}
14073
14074func DecodeInstructionIdBsnDisableSplitHorizonCheck(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnDisableSplitHorizonCheck, error) {
14075 _instructionidbsndisablesplithorizoncheck := &InstructionIdBsnDisableSplitHorizonCheck{InstructionIdBsn: parent}
14076 return _instructionidbsndisablesplithorizoncheck, nil
14077}
14078
14079func NewInstructionIdBsnDisableSplitHorizonCheck() *InstructionIdBsnDisableSplitHorizonCheck {
14080 obj := &InstructionIdBsnDisableSplitHorizonCheck{
14081 InstructionIdBsn: NewInstructionIdBsn(3),
14082 }
14083 return obj
14084}
14085
14086type InstructionIdBsnDisableSrcMacCheck struct {
14087 *InstructionIdBsn
14088}
14089
14090type IInstructionIdBsnDisableSrcMacCheck interface {
14091 IInstructionIdBsn
14092}
14093
14094func (self *InstructionIdBsnDisableSrcMacCheck) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14095 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14096 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
14097 return err
14098 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14099 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14100
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14101 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14102
14103 return nil
14104}
14105
14106func DecodeInstructionIdBsnDisableSrcMacCheck(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnDisableSrcMacCheck, error) {
14107 _instructionidbsndisablesrcmaccheck := &InstructionIdBsnDisableSrcMacCheck{InstructionIdBsn: parent}
14108 return _instructionidbsndisablesrcmaccheck, nil
14109}
14110
14111func NewInstructionIdBsnDisableSrcMacCheck() *InstructionIdBsnDisableSrcMacCheck {
14112 obj := &InstructionIdBsnDisableSrcMacCheck{
14113 InstructionIdBsn: NewInstructionIdBsn(0),
14114 }
14115 return obj
14116}
14117
14118type InstructionIdBsnDisableVlanCounters struct {
14119 *InstructionIdBsn
14120}
14121
14122type IInstructionIdBsnDisableVlanCounters interface {
14123 IInstructionIdBsn
14124}
14125
14126func (self *InstructionIdBsnDisableVlanCounters) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14127 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14128 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
14129 return err
14130 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14131 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14132
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14133 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14134
14135 return nil
14136}
14137
14138func DecodeInstructionIdBsnDisableVlanCounters(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnDisableVlanCounters, error) {
14139 _instructionidbsndisablevlancounters := &InstructionIdBsnDisableVlanCounters{InstructionIdBsn: parent}
14140 return _instructionidbsndisablevlancounters, nil
14141}
14142
14143func NewInstructionIdBsnDisableVlanCounters() *InstructionIdBsnDisableVlanCounters {
14144 obj := &InstructionIdBsnDisableVlanCounters{
14145 InstructionIdBsn: NewInstructionIdBsn(9),
14146 }
14147 return obj
14148}
14149
14150type InstructionIdBsnHashSelect struct {
14151 *InstructionIdBsn
14152}
14153
14154type IInstructionIdBsnHashSelect interface {
14155 IInstructionIdBsn
14156}
14157
14158func (self *InstructionIdBsnHashSelect) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14159 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14160 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
14161 return err
14162 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14163 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14164
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14165 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14166
14167 return nil
14168}
14169
14170func DecodeInstructionIdBsnHashSelect(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnHashSelect, error) {
14171 _instructionidbsnhashselect := &InstructionIdBsnHashSelect{InstructionIdBsn: parent}
14172 return _instructionidbsnhashselect, nil
14173}
14174
14175func NewInstructionIdBsnHashSelect() *InstructionIdBsnHashSelect {
14176 obj := &InstructionIdBsnHashSelect{
14177 InstructionIdBsn: NewInstructionIdBsn(15),
14178 }
14179 return obj
14180}
14181
14182type InstructionIdBsnInternalPriority struct {
14183 *InstructionIdBsn
14184}
14185
14186type IInstructionIdBsnInternalPriority interface {
14187 IInstructionIdBsn
14188}
14189
14190func (self *InstructionIdBsnInternalPriority) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14191 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14192 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
14193 return err
14194 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14195 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14196
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14197 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14198
14199 return nil
14200}
14201
14202func DecodeInstructionIdBsnInternalPriority(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnInternalPriority, error) {
14203 _instructionidbsninternalpriority := &InstructionIdBsnInternalPriority{InstructionIdBsn: parent}
14204 return _instructionidbsninternalpriority, nil
14205}
14206
14207func NewInstructionIdBsnInternalPriority() *InstructionIdBsnInternalPriority {
14208 obj := &InstructionIdBsnInternalPriority{
14209 InstructionIdBsn: NewInstructionIdBsn(12),
14210 }
14211 return obj
14212}
14213
14214type InstructionIdBsnNdpOffload struct {
14215 *InstructionIdBsn
14216}
14217
14218type IInstructionIdBsnNdpOffload interface {
14219 IInstructionIdBsn
14220}
14221
14222func (self *InstructionIdBsnNdpOffload) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14223 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14224 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
14225 return err
14226 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14227 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14228
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14229 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14230
14231 return nil
14232}
14233
14234func DecodeInstructionIdBsnNdpOffload(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnNdpOffload, error) {
14235 _instructionidbsnndpoffload := &InstructionIdBsnNdpOffload{InstructionIdBsn: parent}
14236 return _instructionidbsnndpoffload, nil
14237}
14238
14239func NewInstructionIdBsnNdpOffload() *InstructionIdBsnNdpOffload {
14240 obj := &InstructionIdBsnNdpOffload{
14241 InstructionIdBsn: NewInstructionIdBsn(14),
14242 }
14243 return obj
14244}
14245
14246type InstructionIdBsnPacketOfDeath struct {
14247 *InstructionIdBsn
14248}
14249
14250type IInstructionIdBsnPacketOfDeath interface {
14251 IInstructionIdBsn
14252}
14253
14254func (self *InstructionIdBsnPacketOfDeath) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14255 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14256 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
14257 return err
14258 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14259 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14260
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14261 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14262
14263 return nil
14264}
14265
14266func DecodeInstructionIdBsnPacketOfDeath(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnPacketOfDeath, error) {
14267 _instructionidbsnpacketofdeath := &InstructionIdBsnPacketOfDeath{InstructionIdBsn: parent}
14268 return _instructionidbsnpacketofdeath, nil
14269}
14270
14271func NewInstructionIdBsnPacketOfDeath() *InstructionIdBsnPacketOfDeath {
14272 obj := &InstructionIdBsnPacketOfDeath{
14273 InstructionIdBsn: NewInstructionIdBsn(6),
14274 }
14275 return obj
14276}
14277
14278type InstructionIdBsnPermit struct {
14279 *InstructionIdBsn
14280}
14281
14282type IInstructionIdBsnPermit interface {
14283 IInstructionIdBsn
14284}
14285
14286func (self *InstructionIdBsnPermit) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14287 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14288 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
14289 return err
14290 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14291 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14292
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14293 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14294
14295 return nil
14296}
14297
14298func DecodeInstructionIdBsnPermit(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnPermit, error) {
14299 _instructionidbsnpermit := &InstructionIdBsnPermit{InstructionIdBsn: parent}
14300 return _instructionidbsnpermit, nil
14301}
14302
14303func NewInstructionIdBsnPermit() *InstructionIdBsnPermit {
14304 obj := &InstructionIdBsnPermit{
14305 InstructionIdBsn: NewInstructionIdBsn(4),
14306 }
14307 return obj
14308}
14309
14310type InstructionIdBsnPrioritizePdus struct {
14311 *InstructionIdBsn
14312}
14313
14314type IInstructionIdBsnPrioritizePdus interface {
14315 IInstructionIdBsn
14316}
14317
14318func (self *InstructionIdBsnPrioritizePdus) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14319 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14320 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
14321 return err
14322 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14323 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14324
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14325 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14326
14327 return nil
14328}
14329
14330func DecodeInstructionIdBsnPrioritizePdus(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnPrioritizePdus, error) {
14331 _instructionidbsnprioritizepdus := &InstructionIdBsnPrioritizePdus{InstructionIdBsn: parent}
14332 return _instructionidbsnprioritizepdus, nil
14333}
14334
14335func NewInstructionIdBsnPrioritizePdus() *InstructionIdBsnPrioritizePdus {
14336 obj := &InstructionIdBsnPrioritizePdus{
14337 InstructionIdBsn: NewInstructionIdBsn(7),
14338 }
14339 return obj
14340}
14341
14342type InstructionIdBsnRequireVlanXlate struct {
14343 *InstructionIdBsn
14344}
14345
14346type IInstructionIdBsnRequireVlanXlate interface {
14347 IInstructionIdBsn
14348}
14349
14350func (self *InstructionIdBsnRequireVlanXlate) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14351 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14352 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
14353 return err
14354 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14355 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14356
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14357 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14358
14359 return nil
14360}
14361
14362func DecodeInstructionIdBsnRequireVlanXlate(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnRequireVlanXlate, error) {
14363 _instructionidbsnrequirevlanxlate := &InstructionIdBsnRequireVlanXlate{InstructionIdBsn: parent}
14364 return _instructionidbsnrequirevlanxlate, nil
14365}
14366
14367func NewInstructionIdBsnRequireVlanXlate() *InstructionIdBsnRequireVlanXlate {
14368 obj := &InstructionIdBsnRequireVlanXlate{
14369 InstructionIdBsn: NewInstructionIdBsn(8),
14370 }
14371 return obj
14372}
14373
14374type InstructionIdBsnSpanDestination struct {
14375 *InstructionIdBsn
14376}
14377
14378type IInstructionIdBsnSpanDestination interface {
14379 IInstructionIdBsn
14380}
14381
14382func (self *InstructionIdBsnSpanDestination) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14383 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14384 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
14385 return err
14386 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14387 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14388
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14389 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14390
14391 return nil
14392}
14393
14394func DecodeInstructionIdBsnSpanDestination(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnSpanDestination, error) {
14395 _instructionidbsnspandestination := &InstructionIdBsnSpanDestination{InstructionIdBsn: parent}
14396 return _instructionidbsnspandestination, nil
14397}
14398
14399func NewInstructionIdBsnSpanDestination() *InstructionIdBsnSpanDestination {
14400 obj := &InstructionIdBsnSpanDestination{
14401 InstructionIdBsn: NewInstructionIdBsn(10),
14402 }
14403 return obj
14404}
14405
14406type InstructionIdClearActions struct {
14407 *InstructionId
14408}
14409
14410type IInstructionIdClearActions interface {
14411 IInstructionId
14412}
14413
14414func (self *InstructionIdClearActions) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14415 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14416 if err := self.InstructionId.Serialize(encoder); err != nil {
14417 return err
14418 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14419 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14420
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14421 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14422
14423 return nil
14424}
14425
14426func DecodeInstructionIdClearActions(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdClearActions, error) {
14427 _instructionidclearactions := &InstructionIdClearActions{InstructionId: parent}
14428 return _instructionidclearactions, nil
14429}
14430
14431func NewInstructionIdClearActions() *InstructionIdClearActions {
14432 obj := &InstructionIdClearActions{
14433 InstructionId: NewInstructionId(5),
14434 }
14435 return obj
14436}
14437
14438type InstructionIdGotoTable struct {
14439 *InstructionId
14440}
14441
14442type IInstructionIdGotoTable interface {
14443 IInstructionId
14444}
14445
14446func (self *InstructionIdGotoTable) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14447 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14448 if err := self.InstructionId.Serialize(encoder); err != nil {
14449 return err
14450 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14451 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14452
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14453 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14454
14455 return nil
14456}
14457
14458func DecodeInstructionIdGotoTable(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdGotoTable, error) {
14459 _instructionidgototable := &InstructionIdGotoTable{InstructionId: parent}
14460 return _instructionidgototable, nil
14461}
14462
14463func NewInstructionIdGotoTable() *InstructionIdGotoTable {
14464 obj := &InstructionIdGotoTable{
14465 InstructionId: NewInstructionId(1),
14466 }
14467 return obj
14468}
14469
14470type InstructionIdMeter struct {
14471 *InstructionId
14472}
14473
14474type IInstructionIdMeter interface {
14475 IInstructionId
14476}
14477
14478func (self *InstructionIdMeter) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14479 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14480 if err := self.InstructionId.Serialize(encoder); err != nil {
14481 return err
14482 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14483 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14484
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14485 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14486
14487 return nil
14488}
14489
14490func DecodeInstructionIdMeter(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdMeter, error) {
14491 _instructionidmeter := &InstructionIdMeter{InstructionId: parent}
14492 return _instructionidmeter, nil
14493}
14494
14495func NewInstructionIdMeter() *InstructionIdMeter {
14496 obj := &InstructionIdMeter{
14497 InstructionId: NewInstructionId(6),
14498 }
14499 return obj
14500}
14501
14502type InstructionIdWriteActions struct {
14503 *InstructionId
14504}
14505
14506type IInstructionIdWriteActions interface {
14507 IInstructionId
14508}
14509
14510func (self *InstructionIdWriteActions) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14511 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14512 if err := self.InstructionId.Serialize(encoder); err != nil {
14513 return err
14514 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14515 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14516
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14517 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14518
14519 return nil
14520}
14521
14522func DecodeInstructionIdWriteActions(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdWriteActions, error) {
14523 _instructionidwriteactions := &InstructionIdWriteActions{InstructionId: parent}
14524 return _instructionidwriteactions, nil
14525}
14526
14527func NewInstructionIdWriteActions() *InstructionIdWriteActions {
14528 obj := &InstructionIdWriteActions{
14529 InstructionId: NewInstructionId(3),
14530 }
14531 return obj
14532}
14533
14534type InstructionIdWriteMetadata struct {
14535 *InstructionId
14536}
14537
14538type IInstructionIdWriteMetadata interface {
14539 IInstructionId
14540}
14541
14542func (self *InstructionIdWriteMetadata) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14543 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14544 if err := self.InstructionId.Serialize(encoder); err != nil {
14545 return err
14546 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14547 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14548
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14549 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14550
14551 return nil
14552}
14553
14554func DecodeInstructionIdWriteMetadata(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdWriteMetadata, error) {
14555 _instructionidwritemetadata := &InstructionIdWriteMetadata{InstructionId: parent}
14556 return _instructionidwritemetadata, nil
14557}
14558
14559func NewInstructionIdWriteMetadata() *InstructionIdWriteMetadata {
14560 obj := &InstructionIdWriteMetadata{
14561 InstructionId: NewInstructionId(2),
14562 }
14563 return obj
14564}
14565
14566type MatchV3 struct {
14567 Type uint16
14568 Length uint16
14569 OxmList []goloxi.IOxm
14570}
14571
14572type IMatchV3 interface {
14573 goloxi.Serializable
14574 GetType() uint16
14575 GetLength() uint16
14576 GetOxmList() []goloxi.IOxm
14577}
14578
14579func (self *MatchV3) GetType() uint16 {
14580 return self.Type
14581}
14582
14583func (self *MatchV3) SetType(v uint16) {
14584 self.Type = v
14585}
14586
14587func (self *MatchV3) GetLength() uint16 {
14588 return self.Length
14589}
14590
14591func (self *MatchV3) SetLength(v uint16) {
14592 self.Length = v
14593}
14594
14595func (self *MatchV3) GetOxmList() []goloxi.IOxm {
14596 return self.OxmList
14597}
14598
14599func (self *MatchV3) SetOxmList(v []goloxi.IOxm) {
14600 self.OxmList = v
14601}
14602
14603func (self *MatchV3) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14604 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14605
14606 encoder.PutUint16(uint16(self.Type))
14607 encoder.PutUint16(uint16(self.Length))
14608 for _, obj := range self.OxmList {
14609 if err := obj.Serialize(encoder); err != nil {
14610 return err
14611 }
14612 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14613 length := len(encoder.Bytes()) - startIndex
14614 alignedLength := ((length + 7) / 8 * 8)
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14615
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14616 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14617
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14618 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14619
14620 return nil
14621}
14622func (self *MatchV3) Decode(decoder *goloxi.Decoder) error {
14623 if decoder.Length() < 4 {
14624 return fmt.Errorf("MatchV3 packet too short: %d < 4", decoder.Length())
14625 }
14626
14627 defer decoder.SkipAlign()
14628
14629 self.Type = uint16(decoder.ReadUint16())
14630 self.Length = uint16(decoder.ReadUint16())
14631 oldDecoder := decoder
14632 defer func() { decoder = oldDecoder }()
14633 decoder = decoder.SliceDecoder(int(((self.Length)+7)/8*8), 2+2)
14634
14635 for decoder.Length() >= 4 {
14636 item, err := DecodeOxm(decoder)
14637 if err != nil {
14638 return err
14639 }
14640 if item != nil {
14641 self.OxmList = append(self.OxmList, item)
14642 }
14643 }
14644
14645 return nil
14646}
14647
14648func NewMatchV3() *MatchV3 {
14649 obj := &MatchV3{}
14650 return obj
14651}
14652
14653type MeterBand struct {
14654 Type uint16
14655 Len uint16
14656}
14657
14658type IMeterBand interface {
14659 goloxi.Serializable
14660 GetType() uint16
14661 GetLen() uint16
14662}
14663
14664func (self *MeterBand) GetType() uint16 {
14665 return self.Type
14666}
14667
14668func (self *MeterBand) SetType(v uint16) {
14669 self.Type = v
14670}
14671
14672func (self *MeterBand) GetLen() uint16 {
14673 return self.Len
14674}
14675
14676func (self *MeterBand) SetLen(v uint16) {
14677 self.Len = v
14678}
14679
14680func (self *MeterBand) Serialize(encoder *goloxi.Encoder) error {
14681
14682 encoder.PutUint16(uint16(self.Type))
14683 encoder.PutUint16(uint16(self.Len))
14684
14685 return nil
14686}
14687
14688func DecodeMeterBand(decoder *goloxi.Decoder) (IMeterBand, error) {
14689 _meterband := &MeterBand{}
14690 if decoder.Length() < 4 {
14691 return nil, fmt.Errorf("MeterBand packet too short: %d < 4", decoder.Length())
14692 }
14693 _meterband.Type = uint16(decoder.ReadUint16())
14694 _meterband.Len = uint16(decoder.ReadUint16())
14695 oldDecoder := decoder
14696 defer func() { decoder = oldDecoder }()
14697 decoder = decoder.SliceDecoder(int(_meterband.Len), 2+2)
14698
14699 switch _meterband.Type {
14700 case 1:
14701 return DecodeMeterBandDrop(_meterband, decoder)
14702 case 2:
14703 return DecodeMeterBandDscpRemark(_meterband, decoder)
14704 case 65535:
14705 return DecodeMeterBandExperimenter(_meterband, decoder)
14706 default:
14707 return nil, fmt.Errorf("Invalid type '%d' for 'MeterBand'", _meterband.Type)
14708 }
14709}
14710
14711func NewMeterBand(_type uint16) *MeterBand {
14712 obj := &MeterBand{}
14713 obj.Type = _type
14714 return obj
14715}
14716
14717type MeterBandDrop struct {
14718 *MeterBand
14719 Rate uint32
14720 BurstSize uint32
14721}
14722
14723type IMeterBandDrop interface {
14724 IMeterBand
14725 GetRate() uint32
14726 GetBurstSize() uint32
14727}
14728
14729func (self *MeterBandDrop) GetRate() uint32 {
14730 return self.Rate
14731}
14732
14733func (self *MeterBandDrop) SetRate(v uint32) {
14734 self.Rate = v
14735}
14736
14737func (self *MeterBandDrop) GetBurstSize() uint32 {
14738 return self.BurstSize
14739}
14740
14741func (self *MeterBandDrop) SetBurstSize(v uint32) {
14742 self.BurstSize = v
14743}
14744
14745func (self *MeterBandDrop) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14746 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14747 if err := self.MeterBand.Serialize(encoder); err != nil {
14748 return err
14749 }
14750
14751 encoder.PutUint32(uint32(self.Rate))
14752 encoder.PutUint32(uint32(self.BurstSize))
14753 encoder.Write(bytes.Repeat([]byte{0}, 4))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14754 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14755
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14756 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14757
14758 return nil
14759}
14760
14761func DecodeMeterBandDrop(parent *MeterBand, decoder *goloxi.Decoder) (*MeterBandDrop, error) {
14762 _meterbanddrop := &MeterBandDrop{MeterBand: parent}
14763 if decoder.Length() < 12 {
14764 return nil, fmt.Errorf("MeterBandDrop packet too short: %d < 12", decoder.Length())
14765 }
14766 _meterbanddrop.Rate = uint32(decoder.ReadUint32())
14767 _meterbanddrop.BurstSize = uint32(decoder.ReadUint32())
14768 decoder.Skip(4)
14769 return _meterbanddrop, nil
14770}
14771
14772func NewMeterBandDrop() *MeterBandDrop {
14773 obj := &MeterBandDrop{
14774 MeterBand: NewMeterBand(1),
14775 }
14776 return obj
14777}
14778
14779type MeterBandDscpRemark struct {
14780 *MeterBand
14781 Rate uint32
14782 BurstSize uint32
14783 PrecLevel uint8
14784}
14785
14786type IMeterBandDscpRemark interface {
14787 IMeterBand
14788 GetRate() uint32
14789 GetBurstSize() uint32
14790 GetPrecLevel() uint8
14791}
14792
14793func (self *MeterBandDscpRemark) GetRate() uint32 {
14794 return self.Rate
14795}
14796
14797func (self *MeterBandDscpRemark) SetRate(v uint32) {
14798 self.Rate = v
14799}
14800
14801func (self *MeterBandDscpRemark) GetBurstSize() uint32 {
14802 return self.BurstSize
14803}
14804
14805func (self *MeterBandDscpRemark) SetBurstSize(v uint32) {
14806 self.BurstSize = v
14807}
14808
14809func (self *MeterBandDscpRemark) GetPrecLevel() uint8 {
14810 return self.PrecLevel
14811}
14812
14813func (self *MeterBandDscpRemark) SetPrecLevel(v uint8) {
14814 self.PrecLevel = v
14815}
14816
14817func (self *MeterBandDscpRemark) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14818 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14819 if err := self.MeterBand.Serialize(encoder); err != nil {
14820 return err
14821 }
14822
14823 encoder.PutUint32(uint32(self.Rate))
14824 encoder.PutUint32(uint32(self.BurstSize))
14825 encoder.PutUint8(uint8(self.PrecLevel))
14826 encoder.Write(bytes.Repeat([]byte{0}, 3))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14827 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14828
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14829 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14830
14831 return nil
14832}
14833
14834func DecodeMeterBandDscpRemark(parent *MeterBand, decoder *goloxi.Decoder) (*MeterBandDscpRemark, error) {
14835 _meterbanddscpremark := &MeterBandDscpRemark{MeterBand: parent}
14836 if decoder.Length() < 12 {
14837 return nil, fmt.Errorf("MeterBandDscpRemark packet too short: %d < 12", decoder.Length())
14838 }
14839 _meterbanddscpremark.Rate = uint32(decoder.ReadUint32())
14840 _meterbanddscpremark.BurstSize = uint32(decoder.ReadUint32())
14841 _meterbanddscpremark.PrecLevel = uint8(decoder.ReadByte())
14842 decoder.Skip(3)
14843 return _meterbanddscpremark, nil
14844}
14845
14846func NewMeterBandDscpRemark() *MeterBandDscpRemark {
14847 obj := &MeterBandDscpRemark{
14848 MeterBand: NewMeterBand(2),
14849 }
14850 return obj
14851}
14852
14853type MeterBandExperimenter struct {
14854 *MeterBand
14855 Rate uint32
14856 BurstSize uint32
14857 Experimenter uint32
14858}
14859
14860type IMeterBandExperimenter interface {
14861 IMeterBand
14862 GetRate() uint32
14863 GetBurstSize() uint32
14864 GetExperimenter() uint32
14865}
14866
14867func (self *MeterBandExperimenter) GetRate() uint32 {
14868 return self.Rate
14869}
14870
14871func (self *MeterBandExperimenter) SetRate(v uint32) {
14872 self.Rate = v
14873}
14874
14875func (self *MeterBandExperimenter) GetBurstSize() uint32 {
14876 return self.BurstSize
14877}
14878
14879func (self *MeterBandExperimenter) SetBurstSize(v uint32) {
14880 self.BurstSize = v
14881}
14882
14883func (self *MeterBandExperimenter) GetExperimenter() uint32 {
14884 return self.Experimenter
14885}
14886
14887func (self *MeterBandExperimenter) SetExperimenter(v uint32) {
14888 self.Experimenter = v
14889}
14890
14891func (self *MeterBandExperimenter) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14892 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14893 if err := self.MeterBand.Serialize(encoder); err != nil {
14894 return err
14895 }
14896
14897 encoder.PutUint32(uint32(self.Rate))
14898 encoder.PutUint32(uint32(self.BurstSize))
14899 encoder.PutUint32(uint32(self.Experimenter))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14900 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14901
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]14902 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]14903
14904 return nil
14905}
14906
14907func DecodeMeterBandExperimenter(parent *MeterBand, decoder *goloxi.Decoder) (*MeterBandExperimenter, error) {
14908 _meterbandexperimenter := &MeterBandExperimenter{MeterBand: parent}
14909 if decoder.Length() < 12 {
14910 return nil, fmt.Errorf("MeterBandExperimenter packet too short: %d < 12", decoder.Length())
14911 }
14912 _meterbandexperimenter.Rate = uint32(decoder.ReadUint32())
14913 _meterbandexperimenter.BurstSize = uint32(decoder.ReadUint32())
14914 _meterbandexperimenter.Experimenter = uint32(decoder.ReadUint32())
14915 return _meterbandexperimenter, nil
14916}
14917
14918func NewMeterBandExperimenter() *MeterBandExperimenter {
14919 obj := &MeterBandExperimenter{
14920 MeterBand: NewMeterBand(65535),
14921 }
14922 return obj
14923}
14924
14925type MeterBandStats struct {
14926 PacketBandCount uint64
14927 ByteBandCount uint64
14928}
14929
14930type IMeterBandStats interface {
14931 goloxi.Serializable
14932 GetPacketBandCount() uint64
14933 GetByteBandCount() uint64
14934}
14935
14936func (self *MeterBandStats) GetPacketBandCount() uint64 {
14937 return self.PacketBandCount
14938}
14939
14940func (self *MeterBandStats) SetPacketBandCount(v uint64) {
14941 self.PacketBandCount = v
14942}
14943
14944func (self *MeterBandStats) GetByteBandCount() uint64 {
14945 return self.ByteBandCount
14946}
14947
14948func (self *MeterBandStats) SetByteBandCount(v uint64) {
14949 self.ByteBandCount = v
14950}
14951
14952func (self *MeterBandStats) Serialize(encoder *goloxi.Encoder) error {
14953
14954 encoder.PutUint64(uint64(self.PacketBandCount))
14955 encoder.PutUint64(uint64(self.ByteBandCount))
14956
14957 return nil
14958}
14959
14960func DecodeMeterBandStats(decoder *goloxi.Decoder) (*MeterBandStats, error) {
14961 _meterbandstats := &MeterBandStats{}
14962 if decoder.Length() < 16 {
14963 return nil, fmt.Errorf("MeterBandStats packet too short: %d < 16", decoder.Length())
14964 }
14965 _meterbandstats.PacketBandCount = uint64(decoder.ReadUint64())
14966 _meterbandstats.ByteBandCount = uint64(decoder.ReadUint64())
14967 return _meterbandstats, nil
14968}
14969
14970func NewMeterBandStats() *MeterBandStats {
14971 obj := &MeterBandStats{}
14972 return obj
14973}
14974
14975type MeterConfig struct {
14976 Length uint16
14977 Flags MeterFlags
14978 MeterId uint32
14979 Entries []IMeterBand
14980}
14981
14982type IMeterConfig interface {
14983 goloxi.Serializable
14984 GetLength() uint16
14985 GetFlags() MeterFlags
14986 GetMeterId() uint32
14987 GetEntries() []IMeterBand
14988}
14989
14990func (self *MeterConfig) GetLength() uint16 {
14991 return self.Length
14992}
14993
14994func (self *MeterConfig) SetLength(v uint16) {
14995 self.Length = v
14996}
14997
14998func (self *MeterConfig) GetFlags() MeterFlags {
14999 return self.Flags
15000}
15001
15002func (self *MeterConfig) SetFlags(v MeterFlags) {
15003 self.Flags = v
15004}
15005
15006func (self *MeterConfig) GetMeterId() uint32 {
15007 return self.MeterId
15008}
15009
15010func (self *MeterConfig) SetMeterId(v uint32) {
15011 self.MeterId = v
15012}
15013
15014func (self *MeterConfig) GetEntries() []IMeterBand {
15015 return self.Entries
15016}
15017
15018func (self *MeterConfig) SetEntries(v []IMeterBand) {
15019 self.Entries = v
15020}
15021
15022func (self *MeterConfig) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]15023 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]15024
15025 encoder.PutUint16(uint16(self.Length))
15026 encoder.PutUint16(uint16(self.Flags))
15027 encoder.PutUint32(uint32(self.MeterId))
15028 for _, obj := range self.Entries {
15029 if err := obj.Serialize(encoder); err != nil {
15030 return err
15031 }
15032 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]15033 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]15034
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]15035 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]15036
15037 return nil
15038}
15039
15040func DecodeMeterConfig(decoder *goloxi.Decoder) (*MeterConfig, error) {
15041 _meterconfig := &MeterConfig{}
15042 if decoder.Length() < 8 {
15043 return nil, fmt.Errorf("MeterConfig packet too short: %d < 8", decoder.Length())
15044 }
15045 _meterconfig.Length = uint16(decoder.ReadUint16())
15046 oldDecoder := decoder
15047 defer func() { decoder = oldDecoder }()
15048 decoder = decoder.SliceDecoder(int(_meterconfig.Length), 2+0)
15049 _meterconfig.Flags = MeterFlags(decoder.ReadUint16())
15050 _meterconfig.MeterId = uint32(decoder.ReadUint32())
15051
15052 for decoder.Length() >= 4 {
15053 item, err := DecodeMeterBand(decoder)
15054 if err != nil {
15055 return nil, err
15056 }
15057 if item != nil {
15058 _meterconfig.Entries = append(_meterconfig.Entries, item)
15059 }
15060 }
15061 return _meterconfig, nil
15062}
15063
15064func NewMeterConfig() *MeterConfig {
15065 obj := &MeterConfig{}
15066 return obj
15067}
15068
15069type MeterFeatures struct {
15070 MaxMeter uint32
15071 BandTypes uint32
15072 Capabilities uint32
15073 MaxBands uint8
15074 MaxColor uint8
15075}
15076
15077type IMeterFeatures interface {
15078 goloxi.Serializable
15079 GetMaxMeter() uint32
15080 GetBandTypes() uint32
15081 GetCapabilities() uint32
15082 GetMaxBands() uint8
15083 GetMaxColor() uint8
15084}
15085
15086func (self *MeterFeatures) GetMaxMeter() uint32 {
15087 return self.MaxMeter
15088}
15089
15090func (self *MeterFeatures) SetMaxMeter(v uint32) {
15091 self.MaxMeter = v
15092}
15093
15094func (self *MeterFeatures) GetBandTypes() uint32 {
15095 return self.BandTypes
15096}
15097
15098func (self *MeterFeatures) SetBandTypes(v uint32) {
15099 self.BandTypes = v
15100}
15101
15102func (self *MeterFeatures) GetCapabilities() uint32 {
15103 return self.Capabilities
15104}
15105
15106func (self *MeterFeatures) SetCapabilities(v uint32) {
15107 self.Capabilities = v
15108}
15109
15110func (self *MeterFeatures) GetMaxBands() uint8 {
15111 return self.MaxBands
15112}
15113
15114func (self *MeterFeatures) SetMaxBands(v uint8) {
15115 self.MaxBands = v
15116}
15117
15118func (self *MeterFeatures) GetMaxColor() uint8 {
15119 return self.MaxColor
15120}
15121
15122func (self *MeterFeatures) SetMaxColor(v uint8) {
15123 self.MaxColor = v
15124}
15125
15126func (self *MeterFeatures) Serialize(encoder *goloxi.Encoder) error {
15127
15128 encoder.PutUint32(uint32(self.MaxMeter))
15129 encoder.PutUint32(uint32(self.BandTypes))
15130 encoder.PutUint32(uint32(self.Capabilities))
15131 encoder.PutUint8(uint8(self.MaxBands))
15132 encoder.PutUint8(uint8(self.MaxColor))
15133 encoder.Write(bytes.Repeat([]byte{0}, 2))
15134
15135 return nil
15136}
15137func (self *MeterFeatures) Decode(decoder *goloxi.Decoder) error {
15138 if decoder.Length() < 16 {
15139 return fmt.Errorf("MeterFeatures packet too short: %d < 16", decoder.Length())
15140 }
15141
15142 self.MaxMeter = uint32(decoder.ReadUint32())
15143 self.BandTypes = uint32(decoder.ReadUint32())
15144 self.Capabilities = uint32(decoder.ReadUint32())
15145 self.MaxBands = uint8(decoder.ReadByte())
15146 self.MaxColor = uint8(decoder.ReadByte())
15147 decoder.Skip(2)
15148
15149 return nil
15150}
15151
15152func NewMeterFeatures() *MeterFeatures {
15153 obj := &MeterFeatures{}
15154 return obj
15155}
15156
15157type MeterStats struct {
15158 MeterId uint32
15159 Len uint16
15160 FlowCount uint32
15161 PacketInCount uint64
15162 ByteInCount uint64
15163 DurationSec uint32
15164 DurationNsec uint32
15165 BandStats []*MeterBandStats
15166}
15167
15168type IMeterStats interface {
15169 goloxi.Serializable
15170 GetMeterId() uint32
15171 GetLen() uint16
15172 GetFlowCount() uint32
15173 GetPacketInCount() uint64
15174 GetByteInCount() uint64
15175 GetDurationSec() uint32
15176 GetDurationNsec() uint32
15177 GetBandStats() []*MeterBandStats
15178}
15179
15180func (self *MeterStats) GetMeterId() uint32 {
15181 return self.MeterId
15182}
15183
15184func (self *MeterStats) SetMeterId(v uint32) {
15185 self.MeterId = v
15186}
15187
15188func (self *MeterStats) GetLen() uint16 {
15189 return self.Len
15190}
15191
15192func (self *MeterStats) SetLen(v uint16) {
15193 self.Len = v
15194}
15195
15196func (self *MeterStats) GetFlowCount() uint32 {
15197 return self.FlowCount
15198}
15199
15200func (self *MeterStats) SetFlowCount(v uint32) {
15201 self.FlowCount = v
15202}
15203
15204func (self *MeterStats) GetPacketInCount() uint64 {
15205 return self.PacketInCount
15206}
15207
15208func (self *MeterStats) SetPacketInCount(v uint64) {
15209 self.PacketInCount = v
15210}
15211
15212func (self *MeterStats) GetByteInCount() uint64 {
15213 return self.ByteInCount
15214}
15215
15216func (self *MeterStats) SetByteInCount(v uint64) {
15217 self.ByteInCount = v
15218}
15219
15220func (self *MeterStats) GetDurationSec() uint32 {
15221 return self.DurationSec
15222}
15223
15224func (self *MeterStats) SetDurationSec(v uint32) {
15225 self.DurationSec = v
15226}
15227
15228func (self *MeterStats) GetDurationNsec() uint32 {
15229 return self.DurationNsec
15230}
15231
15232func (self *MeterStats) SetDurationNsec(v uint32) {
15233 self.DurationNsec = v
15234}
15235
15236func (self *MeterStats) GetBandStats() []*MeterBandStats {
15237 return self.BandStats
15238}
15239
15240func (self *MeterStats) SetBandStats(v []*MeterBandStats) {
15241 self.BandStats = v
15242}
15243
15244func (self *MeterStats) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]15245 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]15246
15247 encoder.PutUint32(uint32(self.MeterId))
15248 encoder.PutUint16(uint16(self.Len))
15249 encoder.Write(bytes.Repeat([]byte{0}, 6))
15250 encoder.PutUint32(uint32(self.FlowCount))
15251 encoder.PutUint64(uint64(self.PacketInCount))
15252 encoder.PutUint64(uint64(self.ByteInCount))
15253 encoder.PutUint32(uint32(self.DurationSec))
15254 encoder.PutUint32(uint32(self.DurationNsec))
15255 for _, obj := range self.BandStats {
15256 if err := obj.Serialize(encoder); err != nil {
15257 return err
15258 }
15259 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]15260 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]15261
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]15262 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+4:startIndex+6], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]15263
15264 return nil
15265}
15266
15267func DecodeMeterStats(decoder *goloxi.Decoder) (*MeterStats, error) {
15268 _meterstats := &MeterStats{}
15269 if decoder.Length() < 40 {
15270 return nil, fmt.Errorf("MeterStats packet too short: %d < 40", decoder.Length())
15271 }
15272 _meterstats.MeterId = uint32(decoder.ReadUint32())
15273 _meterstats.Len = uint16(decoder.ReadUint16())
15274 oldDecoder := decoder
15275 defer func() { decoder = oldDecoder }()
15276 decoder = decoder.SliceDecoder(int(_meterstats.Len), 2+4)
15277 decoder.Skip(6)
15278 _meterstats.FlowCount = uint32(decoder.ReadUint32())
15279 _meterstats.PacketInCount = uint64(decoder.ReadUint64())
15280 _meterstats.ByteInCount = uint64(decoder.ReadUint64())
15281 _meterstats.DurationSec = uint32(decoder.ReadUint32())
15282 _meterstats.DurationNsec = uint32(decoder.ReadUint32())
15283
15284 for decoder.Length() >= 16 {
15285 item, err := DecodeMeterBandStats(decoder)
15286 if err != nil {
15287 return nil, err
15288 }
15289 if item != nil {
15290 _meterstats.BandStats = append(_meterstats.BandStats, item)
15291 }
15292 }
15293 return _meterstats, nil
15294}
15295
15296func NewMeterStats() *MeterStats {
15297 obj := &MeterStats{}
15298 return obj
15299}
15300
15301type NiciraMatch struct {
15302 NxmEntries []goloxi.IOxm
15303}
15304
15305type INiciraMatch interface {
15306 goloxi.Serializable
15307 GetNxmEntries() []goloxi.IOxm
15308}
15309
15310func (self *NiciraMatch) GetNxmEntries() []goloxi.IOxm {
15311 return self.NxmEntries
15312}
15313
15314func (self *NiciraMatch) SetNxmEntries(v []goloxi.IOxm) {
15315 self.NxmEntries = v
15316}
15317
15318func (self *NiciraMatch) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]15319 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]15320
15321 for _, obj := range self.NxmEntries {
15322 if err := obj.Serialize(encoder); err != nil {
15323 return err
15324 }
15325 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]15326 length := len(encoder.Bytes()) - startIndex
15327 alignedLength := ((length + 7) / 8 * 8)
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]15328
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]15329 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]15330
15331 return nil
15332}
15333func (self *NiciraMatch) Decode(decoder *goloxi.Decoder) error {
15334
15335 defer decoder.SkipAlign()
15336
15337 for decoder.Length() >= 4 {
15338 item, err := DecodeOxm(decoder)
15339 if err != nil {
15340 return err
15341 }
15342 if item != nil {
15343 self.NxmEntries = append(self.NxmEntries, item)
15344 }
15345 }
15346
15347 return nil
15348}
15349
15350func NewNiciraMatch() *NiciraMatch {
15351 obj := &NiciraMatch{}
15352 return obj
15353}
15354
15355type NiciraFlowStats struct {
15356 Length uint16
15357 TableId uint8
15358 DurationSec uint32
15359 DurationNsec uint32
15360 Priority uint16
15361 IdleTimeout uint16
15362 HardTimeout uint16
15363 MatchLen uint16
15364 IdleAge uint16
15365 HardAge uint16
15366 Cookie uint64
15367 PacketCount uint64
15368 ByteCount uint64
15369 Match NiciraMatch
15370 Actions []goloxi.IAction
15371}
15372
15373type INiciraFlowStats interface {
15374 goloxi.Serializable
15375 GetLength() uint16
15376 GetTableId() uint8
15377 GetDurationSec() uint32
15378 GetDurationNsec() uint32
15379 GetPriority() uint16
15380 GetIdleTimeout() uint16
15381 GetHardTimeout() uint16
15382 GetMatchLen() uint16
15383 GetIdleAge() uint16
15384 GetHardAge() uint16
15385 GetCookie() uint64
15386 GetPacketCount() uint64
15387 GetByteCount() uint64
15388 GetMatch() NiciraMatch
15389 GetActions() []goloxi.IAction
15390}
15391
15392func (self *NiciraFlowStats) GetLength() uint16 {
15393 return self.Length
15394}
15395
15396func (self *NiciraFlowStats) SetLength(v uint16) {
15397 self.Length = v
15398}
15399
15400func (self *NiciraFlowStats) GetTableId() uint8 {
15401 return self.TableId
15402}
15403
15404func (self *NiciraFlowStats) SetTableId(v uint8) {
15405 self.TableId = v
15406}
15407
15408func (self *NiciraFlowStats) GetDurationSec() uint32 {
15409 return self.DurationSec
15410}
15411
15412func (self *NiciraFlowStats) SetDurationSec(v uint32) {
15413 self.DurationSec = v
15414}
15415
15416func (self *NiciraFlowStats) GetDurationNsec() uint32 {
15417 return self.DurationNsec
15418}
15419
15420func (self *NiciraFlowStats) SetDurationNsec(v uint32) {
15421 self.DurationNsec = v
15422}
15423
15424func (self *NiciraFlowStats) GetPriority() uint16 {
15425 return self.Priority
15426}
15427
15428func (self *NiciraFlowStats) SetPriority(v uint16) {
15429 self.Priority = v
15430}
15431
15432func (self *NiciraFlowStats) GetIdleTimeout() uint16 {
15433 return self.IdleTimeout
15434}
15435
15436func (self *NiciraFlowStats) SetIdleTimeout(v uint16) {
15437 self.IdleTimeout = v
15438}
15439
15440func (self *NiciraFlowStats) GetHardTimeout() uint16 {
15441 return self.HardTimeout
15442}
15443
15444func (self *NiciraFlowStats) SetHardTimeout(v uint16) {
15445 self.HardTimeout = v
15446}
15447
15448func (self *NiciraFlowStats) GetMatchLen() uint16 {
15449 return self.MatchLen
15450}
15451
15452func (self *NiciraFlowStats) SetMatchLen(v uint16) {
15453 self.MatchLen = v
15454}
15455
15456func (self *NiciraFlowStats) GetIdleAge() uint16 {
15457 return self.IdleAge
15458}
15459
15460func (self *NiciraFlowStats) SetIdleAge(v uint16) {
15461 self.IdleAge = v
15462}
15463
15464func (self *NiciraFlowStats) GetHardAge() uint16 {
15465 return self.HardAge
15466}
15467
15468func (self *NiciraFlowStats) SetHardAge(v uint16) {
15469 self.HardAge = v
15470}
15471
15472func (self *NiciraFlowStats) GetCookie() uint64 {
15473 return self.Cookie
15474}
15475
15476func (self *NiciraFlowStats) SetCookie(v uint64) {
15477 self.Cookie = v
15478}
15479
15480func (self *NiciraFlowStats) GetPacketCount() uint64 {
15481 return self.PacketCount
15482}
15483
15484func (self *NiciraFlowStats) SetPacketCount(v uint64) {
15485 self.PacketCount = v
15486}
15487
15488func (self *NiciraFlowStats) GetByteCount() uint64 {
15489 return self.ByteCount
15490}
15491
15492func (self *NiciraFlowStats) SetByteCount(v uint64) {
15493 self.ByteCount = v
15494}
15495
15496func (self *NiciraFlowStats) GetMatch() NiciraMatch {
15497 return self.Match
15498}
15499
15500func (self *NiciraFlowStats) SetMatch(v NiciraMatch) {
15501 self.Match = v
15502}
15503
15504func (self *NiciraFlowStats) GetActions() []goloxi.IAction {
15505 return self.Actions
15506}
15507
15508func (self *NiciraFlowStats) SetActions(v []goloxi.IAction) {
15509 self.Actions = v
15510}
15511
15512func (self *NiciraFlowStats) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]15513 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]15514
15515 encoder.PutUint16(uint16(self.Length))
15516 encoder.PutUint8(uint8(self.TableId))
15517 encoder.Write(bytes.Repeat([]byte{0}, 1))
15518 encoder.PutUint32(uint32(self.DurationSec))
15519 encoder.PutUint32(uint32(self.DurationNsec))
15520 encoder.PutUint16(uint16(self.Priority))
15521 encoder.PutUint16(uint16(self.IdleTimeout))
15522 encoder.PutUint16(uint16(self.HardTimeout))
15523 encoder.PutUint16(uint16(self.MatchLen))
15524 encoder.PutUint16(uint16(self.IdleAge))
15525 encoder.PutUint16(uint16(self.HardAge))
15526 encoder.PutUint64(uint64(self.Cookie))
15527 encoder.PutUint64(uint64(self.PacketCount))
15528 encoder.PutUint64(uint64(self.ByteCount))
15529 if err := self.Match.Serialize(encoder); err != nil {
15530 return err
15531 }
15532
15533 for _, obj := range self.Actions {
15534 if err := obj.Serialize(encoder); err != nil {
15535 return err
15536 }
15537 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]15538 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]15539
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]15540 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]15541
15542 return nil
15543}
15544
15545func DecodeNiciraFlowStats(decoder *goloxi.Decoder) (*NiciraFlowStats, error) {
15546 _niciraflowstats := &NiciraFlowStats{}
15547 if decoder.Length() < 48 {
15548 return nil, fmt.Errorf("NiciraFlowStats packet too short: %d < 48", decoder.Length())
15549 }
15550 _niciraflowstats.Length = uint16(decoder.ReadUint16())
15551 oldDecoder := decoder
15552 defer func() { decoder = oldDecoder }()
15553 decoder = decoder.SliceDecoder(int(_niciraflowstats.Length), 2+0)
15554 _niciraflowstats.TableId = uint8(decoder.ReadByte())
15555 decoder.Skip(1)
15556 _niciraflowstats.DurationSec = uint32(decoder.ReadUint32())
15557 _niciraflowstats.DurationNsec = uint32(decoder.ReadUint32())
15558 _niciraflowstats.Priority = uint16(decoder.ReadUint16())
15559 _niciraflowstats.IdleTimeout = uint16(decoder.ReadUint16())
15560 _niciraflowstats.HardTimeout = uint16(decoder.ReadUint16())
15561 _niciraflowstats.MatchLen = uint16(decoder.ReadUint16())
15562 _niciraflowstats.IdleAge = uint16(decoder.ReadUint16())
15563 _niciraflowstats.HardAge = uint16(decoder.ReadUint16())
15564 _niciraflowstats.Cookie = uint64(decoder.ReadUint64())
15565 _niciraflowstats.PacketCount = uint64(decoder.ReadUint64())
15566 _niciraflowstats.ByteCount = uint64(decoder.ReadUint64())
15567 if err := _niciraflowstats.Match.Decode(decoder.SliceDecoder(int(_niciraflowstats.MatchLen), 0)); err != nil {
15568 return nil, err
15569 }
15570
15571 decoder.SkipAlign()
15572
15573 for decoder.Length() >= 8 {
15574 item, err := DecodeAction(decoder)
15575 if err != nil {
15576 return nil, err
15577 }
15578 if item != nil {
15579 _niciraflowstats.Actions = append(_niciraflowstats.Actions, item)
15580 }
15581 }
15582 return _niciraflowstats, nil
15583}
15584
15585func NewNiciraFlowStats() *NiciraFlowStats {
15586 obj := &NiciraFlowStats{}
15587 return obj
15588}
15589
15590type NiciraFlowUpdateEvent struct {
15591 Length uint16
15592 Event uint16
15593}
15594
15595type INiciraFlowUpdateEvent interface {
15596 goloxi.Serializable
15597 GetLength() uint16
15598 GetEvent() uint16
15599}
15600
15601func (self *NiciraFlowUpdateEvent) GetLength() uint16 {
15602 return self.Length
15603}
15604
15605func (self *NiciraFlowUpdateEvent) SetLength(v uint16) {
15606 self.Length = v
15607}
15608
15609func (self *NiciraFlowUpdateEvent) GetEvent() uint16 {
15610 return self.Event
15611}
15612
15613func (self *NiciraFlowUpdateEvent) SetEvent(v uint16) {
15614 self.Event = v
15615}
15616
15617func (self *NiciraFlowUpdateEvent) Serialize(encoder *goloxi.Encoder) error {
15618
15619 encoder.PutUint16(uint16(self.Length))
15620 encoder.PutUint16(uint16(self.Event))
15621
15622 return nil
15623}
15624
15625func DecodeNiciraFlowUpdateEvent(decoder *goloxi.Decoder) (INiciraFlowUpdateEvent, error) {
15626 _niciraflowupdateevent := &NiciraFlowUpdateEvent{}
15627 if decoder.Length() < 4 {
15628 return nil, fmt.Errorf("NiciraFlowUpdateEvent packet too short: %d < 4", decoder.Length())
15629 }
15630 _niciraflowupdateevent.Length = uint16(decoder.ReadUint16())
15631 oldDecoder := decoder
15632 defer func() { decoder = oldDecoder }()
15633 decoder = decoder.SliceDecoder(int(_niciraflowupdateevent.Length), 2+0)
15634 _niciraflowupdateevent.Event = uint16(decoder.ReadUint16())
15635
15636 switch _niciraflowupdateevent.Event {
15637 case 0:
15638 return DecodeNiciraFlowUpdateFullAdd(_niciraflowupdateevent, decoder)
15639 case 1:
15640 return DecodeNiciraFlowUpdateFullDeleted(_niciraflowupdateevent, decoder)
15641 case 2:
15642 return DecodeNiciraFlowUpdateFullModified(_niciraflowupdateevent, decoder)
15643 default:
15644 return nil, fmt.Errorf("Invalid type '%d' for 'NiciraFlowUpdateEvent'", _niciraflowupdateevent.Event)
15645 }
15646}
15647
15648func NewNiciraFlowUpdateEvent(_event uint16) *NiciraFlowUpdateEvent {
15649 obj := &NiciraFlowUpdateEvent{}
15650 obj.Event = _event
15651 return obj
15652}
15653
15654type NiciraFlowUpdateFullAdd struct {
15655 *NiciraFlowUpdateEvent
15656 Reason uint16
15657 Priority uint16
15658 IdleTimeout uint16
15659 HardTimeout uint16
15660 MatchLen uint16
15661 TableId uint8
15662 Cookie uint64
15663 Match NiciraMatch
15664 Actions []goloxi.IAction
15665}
15666
15667type INiciraFlowUpdateFullAdd interface {
15668 INiciraFlowUpdateEvent
15669 GetReason() uint16
15670 GetPriority() uint16
15671 GetIdleTimeout() uint16
15672 GetHardTimeout() uint16
15673 GetMatchLen() uint16
15674 GetTableId() uint8
15675 GetCookie() uint64
15676 GetMatch() NiciraMatch
15677 GetActions() []goloxi.IAction
15678}
15679
15680func (self *NiciraFlowUpdateFullAdd) GetReason() uint16 {
15681 return self.Reason
15682}
15683
15684func (self *NiciraFlowUpdateFullAdd) SetReason(v uint16) {
15685 self.Reason = v
15686}
15687
15688func (self *NiciraFlowUpdateFullAdd) GetPriority() uint16 {
15689 return self.Priority
15690}
15691
15692func (self *NiciraFlowUpdateFullAdd) SetPriority(v uint16) {
15693 self.Priority = v
15694}
15695
15696func (self *NiciraFlowUpdateFullAdd) GetIdleTimeout() uint16 {
15697 return self.IdleTimeout
15698}
15699
15700func (self *NiciraFlowUpdateFullAdd) SetIdleTimeout(v uint16) {
15701 self.IdleTimeout = v
15702}
15703
15704func (self *NiciraFlowUpdateFullAdd) GetHardTimeout() uint16 {
15705 return self.HardTimeout
15706}
15707
15708func (self *NiciraFlowUpdateFullAdd) SetHardTimeout(v uint16) {
15709 self.HardTimeout = v
15710}
15711
15712func (self *NiciraFlowUpdateFullAdd) GetMatchLen() uint16 {
15713 return self.MatchLen
15714}
15715
15716func (self *NiciraFlowUpdateFullAdd) SetMatchLen(v uint16) {
15717 self.MatchLen = v
15718}
15719
15720func (self *NiciraFlowUpdateFullAdd) GetTableId() uint8 {
15721 return self.TableId
15722}
15723
15724func (self *NiciraFlowUpdateFullAdd) SetTableId(v uint8) {
15725 self.TableId = v
15726}
15727
15728func (self *NiciraFlowUpdateFullAdd) GetCookie() uint64 {
15729 return self.Cookie
15730}
15731
15732func (self *NiciraFlowUpdateFullAdd) SetCookie(v uint64) {
15733 self.Cookie = v
15734}
15735
15736func (self *NiciraFlowUpdateFullAdd) GetMatch() NiciraMatch {
15737 return self.Match
15738}
15739
15740func (self *NiciraFlowUpdateFullAdd) SetMatch(v NiciraMatch) {
15741 self.Match = v
15742}
15743
15744func (self *NiciraFlowUpdateFullAdd) GetActions() []goloxi.IAction {
15745 return self.Actions
15746}
15747
15748func (self *NiciraFlowUpdateFullAdd) SetActions(v []goloxi.IAction) {
15749 self.Actions = v
15750}
15751
15752func (self *NiciraFlowUpdateFullAdd) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]15753 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]15754 if err := self.NiciraFlowUpdateEvent.Serialize(encoder); err != nil {
15755 return err
15756 }
15757
15758 encoder.PutUint16(uint16(self.Reason))
15759 encoder.PutUint16(uint16(self.Priority))
15760 encoder.PutUint16(uint16(self.IdleTimeout))
15761 encoder.PutUint16(uint16(self.HardTimeout))
15762 encoder.PutUint16(uint16(self.MatchLen))
15763 encoder.PutUint8(uint8(self.TableId))
15764 encoder.Write(bytes.Repeat([]byte{0}, 1))
15765 encoder.PutUint64(uint64(self.Cookie))
15766 if err := self.Match.Serialize(encoder); err != nil {
15767 return err
15768 }
15769
15770 for _, obj := range self.Actions {
15771 if err := obj.Serialize(encoder); err != nil {
15772 return err
15773 }
15774 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]15775 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]15776
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]15777 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]15778
15779 return nil
15780}
15781
15782func DecodeNiciraFlowUpdateFullAdd(parent *NiciraFlowUpdateEvent, decoder *goloxi.Decoder) (*NiciraFlowUpdateFullAdd, error) {
15783 _niciraflowupdatefulladd := &NiciraFlowUpdateFullAdd{NiciraFlowUpdateEvent: parent}
15784 if decoder.Length() < 20 {
15785 return nil, fmt.Errorf("NiciraFlowUpdateFullAdd packet too short: %d < 20", decoder.Length())
15786 }
15787 _niciraflowupdatefulladd.Reason = uint16(decoder.ReadUint16())
15788 _niciraflowupdatefulladd.Priority = uint16(decoder.ReadUint16())
15789 _niciraflowupdatefulladd.IdleTimeout = uint16(decoder.ReadUint16())
15790 _niciraflowupdatefulladd.HardTimeout = uint16(decoder.ReadUint16())
15791 _niciraflowupdatefulladd.MatchLen = uint16(decoder.ReadUint16())
15792 _niciraflowupdatefulladd.TableId = uint8(decoder.ReadByte())
15793 decoder.Skip(1)
15794 _niciraflowupdatefulladd.Cookie = uint64(decoder.ReadUint64())
15795 if err := _niciraflowupdatefulladd.Match.Decode(decoder.SliceDecoder(int(_niciraflowupdatefulladd.MatchLen), 0)); err != nil {
15796 return nil, err
15797 }
15798
15799 decoder.SkipAlign()
15800
15801 for decoder.Length() >= 8 {
15802 item, err := DecodeAction(decoder)
15803 if err != nil {
15804 return nil, err
15805 }
15806 if item != nil {
15807 _niciraflowupdatefulladd.Actions = append(_niciraflowupdatefulladd.Actions, item)
15808 }
15809 }
15810 return _niciraflowupdatefulladd, nil
15811}
15812
15813func NewNiciraFlowUpdateFullAdd() *NiciraFlowUpdateFullAdd {
15814 obj := &NiciraFlowUpdateFullAdd{
15815 NiciraFlowUpdateEvent: NewNiciraFlowUpdateEvent(0),
15816 }
15817 return obj
15818}
15819
15820type NiciraFlowUpdateFullDeleted struct {
15821 *NiciraFlowUpdateEvent
15822 Reason uint16
15823 Priority uint16
15824 IdleTimeout uint16
15825 HardTimeout uint16
15826 MatchLen uint16
15827 TableId uint8
15828 Cookie uint64
15829 Match NiciraMatch
15830 Actions []goloxi.IAction
15831}
15832
15833type INiciraFlowUpdateFullDeleted interface {
15834 INiciraFlowUpdateEvent
15835 GetReason() uint16
15836 GetPriority() uint16
15837 GetIdleTimeout() uint16
15838 GetHardTimeout() uint16
15839 GetMatchLen() uint16
15840 GetTableId() uint8
15841 GetCookie() uint64
15842 GetMatch() NiciraMatch
15843 GetActions() []goloxi.IAction
15844}
15845
15846func (self *NiciraFlowUpdateFullDeleted) GetReason() uint16 {
15847 return self.Reason
15848}
15849
15850func (self *NiciraFlowUpdateFullDeleted) SetReason(v uint16) {
15851 self.Reason = v
15852}
15853
15854func (self *NiciraFlowUpdateFullDeleted) GetPriority() uint16 {
15855 return self.Priority
15856}
15857
15858func (self *NiciraFlowUpdateFullDeleted) SetPriority(v uint16) {
15859 self.Priority = v
15860}
15861
15862func (self *NiciraFlowUpdateFullDeleted) GetIdleTimeout() uint16 {
15863 return self.IdleTimeout
15864}
15865
15866func (self *NiciraFlowUpdateFullDeleted) SetIdleTimeout(v uint16) {
15867 self.IdleTimeout = v
15868}
15869
15870func (self *NiciraFlowUpdateFullDeleted) GetHardTimeout() uint16 {
15871 return self.HardTimeout
15872}
15873
15874func (self *NiciraFlowUpdateFullDeleted) SetHardTimeout(v uint16) {
15875 self.HardTimeout = v
15876}
15877
15878func (self *NiciraFlowUpdateFullDeleted) GetMatchLen() uint16 {
15879 return self.MatchLen
15880}
15881
15882func (self *NiciraFlowUpdateFullDeleted) SetMatchLen(v uint16) {
15883 self.MatchLen = v
15884}
15885
15886func (self *NiciraFlowUpdateFullDeleted) GetTableId() uint8 {
15887 return self.TableId
15888}
15889
15890func (self *NiciraFlowUpdateFullDeleted) SetTableId(v uint8) {
15891 self.TableId = v
15892}
15893
15894func (self *NiciraFlowUpdateFullDeleted) GetCookie() uint64 {
15895 return self.Cookie
15896}
15897
15898func (self *NiciraFlowUpdateFullDeleted) SetCookie(v uint64) {
15899 self.Cookie = v
15900}
15901
15902func (self *NiciraFlowUpdateFullDeleted) GetMatch() NiciraMatch {
15903 return self.Match
15904}
15905
15906func (self *NiciraFlowUpdateFullDeleted) SetMatch(v NiciraMatch) {
15907 self.Match = v
15908}
15909
15910func (self *NiciraFlowUpdateFullDeleted) GetActions() []goloxi.IAction {
15911 return self.Actions
15912}
15913
15914func (self *NiciraFlowUpdateFullDeleted) SetActions(v []goloxi.IAction) {
15915 self.Actions = v
15916}
15917
15918func (self *NiciraFlowUpdateFullDeleted) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]15919 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]15920 if err := self.NiciraFlowUpdateEvent.Serialize(encoder); err != nil {
15921 return err
15922 }
15923
15924 encoder.PutUint16(uint16(self.Reason))
15925 encoder.PutUint16(uint16(self.Priority))
15926 encoder.PutUint16(uint16(self.IdleTimeout))
15927 encoder.PutUint16(uint16(self.HardTimeout))
15928 encoder.PutUint16(uint16(self.MatchLen))
15929 encoder.PutUint8(uint8(self.TableId))
15930 encoder.Write(bytes.Repeat([]byte{0}, 1))
15931 encoder.PutUint64(uint64(self.Cookie))
15932 if err := self.Match.Serialize(encoder); err != nil {
15933 return err
15934 }
15935
15936 for _, obj := range self.Actions {
15937 if err := obj.Serialize(encoder); err != nil {
15938 return err
15939 }
15940 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]15941 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]15942
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]15943 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]15944
15945 return nil
15946}
15947
15948func DecodeNiciraFlowUpdateFullDeleted(parent *NiciraFlowUpdateEvent, decoder *goloxi.Decoder) (*NiciraFlowUpdateFullDeleted, error) {
15949 _niciraflowupdatefulldeleted := &NiciraFlowUpdateFullDeleted{NiciraFlowUpdateEvent: parent}
15950 if decoder.Length() < 20 {
15951 return nil, fmt.Errorf("NiciraFlowUpdateFullDeleted packet too short: %d < 20", decoder.Length())
15952 }
15953 _niciraflowupdatefulldeleted.Reason = uint16(decoder.ReadUint16())
15954 _niciraflowupdatefulldeleted.Priority = uint16(decoder.ReadUint16())
15955 _niciraflowupdatefulldeleted.IdleTimeout = uint16(decoder.ReadUint16())
15956 _niciraflowupdatefulldeleted.HardTimeout = uint16(decoder.ReadUint16())
15957 _niciraflowupdatefulldeleted.MatchLen = uint16(decoder.ReadUint16())
15958 _niciraflowupdatefulldeleted.TableId = uint8(decoder.ReadByte())
15959 decoder.Skip(1)
15960 _niciraflowupdatefulldeleted.Cookie = uint64(decoder.ReadUint64())
15961 if err := _niciraflowupdatefulldeleted.Match.Decode(decoder.SliceDecoder(int(_niciraflowupdatefulldeleted.MatchLen), 0)); err != nil {
15962 return nil, err
15963 }
15964
15965 decoder.SkipAlign()
15966
15967 for decoder.Length() >= 8 {
15968 item, err := DecodeAction(decoder)
15969 if err != nil {
15970 return nil, err
15971 }
15972 if item != nil {
15973 _niciraflowupdatefulldeleted.Actions = append(_niciraflowupdatefulldeleted.Actions, item)
15974 }
15975 }
15976 return _niciraflowupdatefulldeleted, nil
15977}
15978
15979func NewNiciraFlowUpdateFullDeleted() *NiciraFlowUpdateFullDeleted {
15980 obj := &NiciraFlowUpdateFullDeleted{
15981 NiciraFlowUpdateEvent: NewNiciraFlowUpdateEvent(1),
15982 }
15983 return obj
15984}
15985
15986type NiciraFlowUpdateFullModified struct {
15987 *NiciraFlowUpdateEvent
15988 Reason uint16
15989 Priority uint16
15990 IdleTimeout uint16
15991 HardTimeout uint16
15992 MatchLen uint16
15993 TableId uint8
15994 Cookie uint64
15995 Match NiciraMatch
15996 Actions []goloxi.IAction
15997}
15998
15999type INiciraFlowUpdateFullModified interface {
16000 INiciraFlowUpdateEvent
16001 GetReason() uint16
16002 GetPriority() uint16
16003 GetIdleTimeout() uint16
16004 GetHardTimeout() uint16
16005 GetMatchLen() uint16
16006 GetTableId() uint8
16007 GetCookie() uint64
16008 GetMatch() NiciraMatch
16009 GetActions() []goloxi.IAction
16010}
16011
16012func (self *NiciraFlowUpdateFullModified) GetReason() uint16 {
16013 return self.Reason
16014}
16015
16016func (self *NiciraFlowUpdateFullModified) SetReason(v uint16) {
16017 self.Reason = v
16018}
16019
16020func (self *NiciraFlowUpdateFullModified) GetPriority() uint16 {
16021 return self.Priority
16022}
16023
16024func (self *NiciraFlowUpdateFullModified) SetPriority(v uint16) {
16025 self.Priority = v
16026}
16027
16028func (self *NiciraFlowUpdateFullModified) GetIdleTimeout() uint16 {
16029 return self.IdleTimeout
16030}
16031
16032func (self *NiciraFlowUpdateFullModified) SetIdleTimeout(v uint16) {
16033 self.IdleTimeout = v
16034}
16035
16036func (self *NiciraFlowUpdateFullModified) GetHardTimeout() uint16 {
16037 return self.HardTimeout
16038}
16039
16040func (self *NiciraFlowUpdateFullModified) SetHardTimeout(v uint16) {
16041 self.HardTimeout = v
16042}
16043
16044func (self *NiciraFlowUpdateFullModified) GetMatchLen() uint16 {
16045 return self.MatchLen
16046}
16047
16048func (self *NiciraFlowUpdateFullModified) SetMatchLen(v uint16) {
16049 self.MatchLen = v
16050}
16051
16052func (self *NiciraFlowUpdateFullModified) GetTableId() uint8 {
16053 return self.TableId
16054}
16055
16056func (self *NiciraFlowUpdateFullModified) SetTableId(v uint8) {
16057 self.TableId = v
16058}
16059
16060func (self *NiciraFlowUpdateFullModified) GetCookie() uint64 {
16061 return self.Cookie
16062}
16063
16064func (self *NiciraFlowUpdateFullModified) SetCookie(v uint64) {
16065 self.Cookie = v
16066}
16067
16068func (self *NiciraFlowUpdateFullModified) GetMatch() NiciraMatch {
16069 return self.Match
16070}
16071
16072func (self *NiciraFlowUpdateFullModified) SetMatch(v NiciraMatch) {
16073 self.Match = v
16074}
16075
16076func (self *NiciraFlowUpdateFullModified) GetActions() []goloxi.IAction {
16077 return self.Actions
16078}
16079
16080func (self *NiciraFlowUpdateFullModified) SetActions(v []goloxi.IAction) {
16081 self.Actions = v
16082}
16083
16084func (self *NiciraFlowUpdateFullModified) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]16085 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]16086 if err := self.NiciraFlowUpdateEvent.Serialize(encoder); err != nil {
16087 return err
16088 }
16089
16090 encoder.PutUint16(uint16(self.Reason))
16091 encoder.PutUint16(uint16(self.Priority))
16092 encoder.PutUint16(uint16(self.IdleTimeout))
16093 encoder.PutUint16(uint16(self.HardTimeout))
16094 encoder.PutUint16(uint16(self.MatchLen))
16095 encoder.PutUint8(uint8(self.TableId))
16096 encoder.Write(bytes.Repeat([]byte{0}, 1))
16097 encoder.PutUint64(uint64(self.Cookie))
16098 if err := self.Match.Serialize(encoder); err != nil {
16099 return err
16100 }
16101
16102 for _, obj := range self.Actions {
16103 if err := obj.Serialize(encoder); err != nil {
16104 return err
16105 }
16106 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]16107 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]16108
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]16109 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]16110
16111 return nil
16112}
16113
16114func DecodeNiciraFlowUpdateFullModified(parent *NiciraFlowUpdateEvent, decoder *goloxi.Decoder) (*NiciraFlowUpdateFullModified, error) {
16115 _niciraflowupdatefullmodified := &NiciraFlowUpdateFullModified{NiciraFlowUpdateEvent: parent}
16116 if decoder.Length() < 20 {
16117 return nil, fmt.Errorf("NiciraFlowUpdateFullModified packet too short: %d < 20", decoder.Length())
16118 }
16119 _niciraflowupdatefullmodified.Reason = uint16(decoder.ReadUint16())
16120 _niciraflowupdatefullmodified.Priority = uint16(decoder.ReadUint16())
16121 _niciraflowupdatefullmodified.IdleTimeout = uint16(decoder.ReadUint16())
16122 _niciraflowupdatefullmodified.HardTimeout = uint16(decoder.ReadUint16())
16123 _niciraflowupdatefullmodified.MatchLen = uint16(decoder.ReadUint16())
16124 _niciraflowupdatefullmodified.TableId = uint8(decoder.ReadByte())
16125 decoder.Skip(1)
16126 _niciraflowupdatefullmodified.Cookie = uint64(decoder.ReadUint64())
16127 if err := _niciraflowupdatefullmodified.Match.Decode(decoder.SliceDecoder(int(_niciraflowupdatefullmodified.MatchLen), 0)); err != nil {
16128 return nil, err
16129 }
16130
16131 decoder.SkipAlign()
16132
16133 for decoder.Length() >= 8 {
16134 item, err := DecodeAction(decoder)
16135 if err != nil {
16136 return nil, err
16137 }
16138 if item != nil {
16139 _niciraflowupdatefullmodified.Actions = append(_niciraflowupdatefullmodified.Actions, item)
16140 }
16141 }
16142 return _niciraflowupdatefullmodified, nil
16143}
16144
16145func NewNiciraFlowUpdateFullModified() *NiciraFlowUpdateFullModified {
16146 obj := &NiciraFlowUpdateFullModified{
16147 NiciraFlowUpdateEvent: NewNiciraFlowUpdateEvent(2),
16148 }
16149 return obj
16150}
16151
16152type OxmIdArpOp struct {
16153 *OxmId
16154}
16155
16156type IOxmIdArpOp interface {
16157 IOxmId
16158}
16159
16160func (self *OxmIdArpOp) Serialize(encoder *goloxi.Encoder) error {
16161 if err := self.OxmId.Serialize(encoder); err != nil {
16162 return err
16163 }
16164
16165 return nil
16166}
16167
16168func DecodeOxmIdArpOp(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpOp, error) {
16169 _oxmidarpop := &OxmIdArpOp{OxmId: parent}
16170 return _oxmidarpop, nil
16171}
16172
16173func NewOxmIdArpOp() *OxmIdArpOp {
16174 obj := &OxmIdArpOp{
16175 OxmId: NewOxmId(7682),
16176 }
16177 return obj
16178}
16179func (self *OxmIdArpOp) GetOXMName() string {
16180 return "arp_op"
16181}
16182
16183func (self *OxmIdArpOp) MarshalJSON() ([]byte, error) {
16184 if self.TypeLen == 0 {
16185 return []byte("\"\""), nil
16186 } else {
16187 return []byte("\"" + self.GetOXMName() + "\""), nil
16188 }
16189}
16190
16191type OxmIdArpSha struct {
16192 *OxmId
16193}
16194
16195type IOxmIdArpSha interface {
16196 IOxmId
16197}
16198
16199func (self *OxmIdArpSha) Serialize(encoder *goloxi.Encoder) error {
16200 if err := self.OxmId.Serialize(encoder); err != nil {
16201 return err
16202 }
16203
16204 return nil
16205}
16206
16207func DecodeOxmIdArpSha(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpSha, error) {
16208 _oxmidarpsha := &OxmIdArpSha{OxmId: parent}
16209 return _oxmidarpsha, nil
16210}
16211
16212func NewOxmIdArpSha() *OxmIdArpSha {
16213 obj := &OxmIdArpSha{
16214 OxmId: NewOxmId(74246),
16215 }
16216 return obj
16217}
16218func (self *OxmIdArpSha) GetOXMName() string {
16219 return "arp_sha"
16220}
16221
16222func (self *OxmIdArpSha) MarshalJSON() ([]byte, error) {
16223 if self.TypeLen == 0 {
16224 return []byte("\"\""), nil
16225 } else {
16226 return []byte("\"" + self.GetOXMName() + "\""), nil
16227 }
16228}
16229
16230type OxmIdArpShaMasked struct {
16231 *OxmId
16232}
16233
16234type IOxmIdArpShaMasked interface {
16235 IOxmId
16236}
16237
16238func (self *OxmIdArpShaMasked) Serialize(encoder *goloxi.Encoder) error {
16239 if err := self.OxmId.Serialize(encoder); err != nil {
16240 return err
16241 }
16242
16243 return nil
16244}
16245
16246func DecodeOxmIdArpShaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpShaMasked, error) {
16247 _oxmidarpshamasked := &OxmIdArpShaMasked{OxmId: parent}
16248 return _oxmidarpshamasked, nil
16249}
16250
16251func NewOxmIdArpShaMasked() *OxmIdArpShaMasked {
16252 obj := &OxmIdArpShaMasked{
16253 OxmId: NewOxmId(74507),
16254 }
16255 return obj
16256}
16257func (self *OxmIdArpShaMasked) GetOXMName() string {
16258 return "arp_sha_masked"
16259}
16260
16261func (self *OxmIdArpShaMasked) MarshalJSON() ([]byte, error) {
16262 if self.TypeLen == 0 {
16263 return []byte("\"\""), nil
16264 } else {
16265 return []byte("\"" + self.GetOXMName() + "\""), nil
16266 }
16267}
16268
16269type OxmIdArpSpa struct {
16270 *OxmId
16271}
16272
16273type IOxmIdArpSpa interface {
16274 IOxmId
16275}
16276
16277func (self *OxmIdArpSpa) Serialize(encoder *goloxi.Encoder) error {
16278 if err := self.OxmId.Serialize(encoder); err != nil {
16279 return err
16280 }
16281
16282 return nil
16283}
16284
16285func DecodeOxmIdArpSpa(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpSpa, error) {
16286 _oxmidarpspa := &OxmIdArpSpa{OxmId: parent}
16287 return _oxmidarpspa, nil
16288}
16289
16290func NewOxmIdArpSpa() *OxmIdArpSpa {
16291 obj := &OxmIdArpSpa{
16292 OxmId: NewOxmId(8196),
16293 }
16294 return obj
16295}
16296func (self *OxmIdArpSpa) GetOXMName() string {
16297 return "arp_spa"
16298}
16299
16300func (self *OxmIdArpSpa) MarshalJSON() ([]byte, error) {
16301 if self.TypeLen == 0 {
16302 return []byte("\"\""), nil
16303 } else {
16304 return []byte("\"" + self.GetOXMName() + "\""), nil
16305 }
16306}
16307
16308type OxmIdArpSpaMasked struct {
16309 *OxmId
16310}
16311
16312type IOxmIdArpSpaMasked interface {
16313 IOxmId
16314}
16315
16316func (self *OxmIdArpSpaMasked) Serialize(encoder *goloxi.Encoder) error {
16317 if err := self.OxmId.Serialize(encoder); err != nil {
16318 return err
16319 }
16320
16321 return nil
16322}
16323
16324func DecodeOxmIdArpSpaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpSpaMasked, error) {
16325 _oxmidarpspamasked := &OxmIdArpSpaMasked{OxmId: parent}
16326 return _oxmidarpspamasked, nil
16327}
16328
16329func NewOxmIdArpSpaMasked() *OxmIdArpSpaMasked {
16330 obj := &OxmIdArpSpaMasked{
16331 OxmId: NewOxmId(8452),
16332 }
16333 return obj
16334}
16335func (self *OxmIdArpSpaMasked) GetOXMName() string {
16336 return "arp_spa_masked"
16337}
16338
16339func (self *OxmIdArpSpaMasked) MarshalJSON() ([]byte, error) {
16340 if self.TypeLen == 0 {
16341 return []byte("\"\""), nil
16342 } else {
16343 return []byte("\"" + self.GetOXMName() + "\""), nil
16344 }
16345}
16346
16347type OxmIdArpTha struct {
16348 *OxmId
16349}
16350
16351type IOxmIdArpTha interface {
16352 IOxmId
16353}
16354
16355func (self *OxmIdArpTha) Serialize(encoder *goloxi.Encoder) error {
16356 if err := self.OxmId.Serialize(encoder); err != nil {
16357 return err
16358 }
16359
16360 return nil
16361}
16362
16363func DecodeOxmIdArpTha(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpTha, error) {
16364 _oxmidarptha := &OxmIdArpTha{OxmId: parent}
16365 return _oxmidarptha, nil
16366}
16367
16368func NewOxmIdArpTha() *OxmIdArpTha {
16369 obj := &OxmIdArpTha{
16370 OxmId: NewOxmId(74758),
16371 }
16372 return obj
16373}
16374func (self *OxmIdArpTha) GetOXMName() string {
16375 return "arp_tha"
16376}
16377
16378func (self *OxmIdArpTha) MarshalJSON() ([]byte, error) {
16379 if self.TypeLen == 0 {
16380 return []byte("\"\""), nil
16381 } else {
16382 return []byte("\"" + self.GetOXMName() + "\""), nil
16383 }
16384}
16385
16386type OxmIdArpThaMasked struct {
16387 *OxmId
16388}
16389
16390type IOxmIdArpThaMasked interface {
16391 IOxmId
16392}
16393
16394func (self *OxmIdArpThaMasked) Serialize(encoder *goloxi.Encoder) error {
16395 if err := self.OxmId.Serialize(encoder); err != nil {
16396 return err
16397 }
16398
16399 return nil
16400}
16401
16402func DecodeOxmIdArpThaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpThaMasked, error) {
16403 _oxmidarpthamasked := &OxmIdArpThaMasked{OxmId: parent}
16404 return _oxmidarpthamasked, nil
16405}
16406
16407func NewOxmIdArpThaMasked() *OxmIdArpThaMasked {
16408 obj := &OxmIdArpThaMasked{
16409 OxmId: NewOxmId(75019),
16410 }
16411 return obj
16412}
16413func (self *OxmIdArpThaMasked) GetOXMName() string {
16414 return "arp_tha_masked"
16415}
16416
16417func (self *OxmIdArpThaMasked) MarshalJSON() ([]byte, error) {
16418 if self.TypeLen == 0 {
16419 return []byte("\"\""), nil
16420 } else {
16421 return []byte("\"" + self.GetOXMName() + "\""), nil
16422 }
16423}
16424
16425type OxmIdArpTpa struct {
16426 *OxmId
16427}
16428
16429type IOxmIdArpTpa interface {
16430 IOxmId
16431}
16432
16433func (self *OxmIdArpTpa) Serialize(encoder *goloxi.Encoder) error {
16434 if err := self.OxmId.Serialize(encoder); err != nil {
16435 return err
16436 }
16437
16438 return nil
16439}
16440
16441func DecodeOxmIdArpTpa(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpTpa, error) {
16442 _oxmidarptpa := &OxmIdArpTpa{OxmId: parent}
16443 return _oxmidarptpa, nil
16444}
16445
16446func NewOxmIdArpTpa() *OxmIdArpTpa {
16447 obj := &OxmIdArpTpa{
16448 OxmId: NewOxmId(8708),
16449 }
16450 return obj
16451}
16452func (self *OxmIdArpTpa) GetOXMName() string {
16453 return "arp_tpa"
16454}
16455
16456func (self *OxmIdArpTpa) MarshalJSON() ([]byte, error) {
16457 if self.TypeLen == 0 {
16458 return []byte("\"\""), nil
16459 } else {
16460 return []byte("\"" + self.GetOXMName() + "\""), nil
16461 }
16462}
16463
16464type OxmIdArpTpaMasked struct {
16465 *OxmId
16466}
16467
16468type IOxmIdArpTpaMasked interface {
16469 IOxmId
16470}
16471
16472func (self *OxmIdArpTpaMasked) Serialize(encoder *goloxi.Encoder) error {
16473 if err := self.OxmId.Serialize(encoder); err != nil {
16474 return err
16475 }
16476
16477 return nil
16478}
16479
16480func DecodeOxmIdArpTpaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpTpaMasked, error) {
16481 _oxmidarptpamasked := &OxmIdArpTpaMasked{OxmId: parent}
16482 return _oxmidarptpamasked, nil
16483}
16484
16485func NewOxmIdArpTpaMasked() *OxmIdArpTpaMasked {
16486 obj := &OxmIdArpTpaMasked{
16487 OxmId: NewOxmId(8968),
16488 }
16489 return obj
16490}
16491func (self *OxmIdArpTpaMasked) GetOXMName() string {
16492 return "arp_tpa_masked"
16493}
16494
16495func (self *OxmIdArpTpaMasked) MarshalJSON() ([]byte, error) {
16496 if self.TypeLen == 0 {
16497 return []byte("\"\""), nil
16498 } else {
16499 return []byte("\"" + self.GetOXMName() + "\""), nil
16500 }
16501}
16502
16503type OxmIdConjId struct {
16504 *OxmId
16505}
16506
16507type IOxmIdConjId interface {
16508 IOxmId
16509}
16510
16511func (self *OxmIdConjId) Serialize(encoder *goloxi.Encoder) error {
16512 if err := self.OxmId.Serialize(encoder); err != nil {
16513 return err
16514 }
16515
16516 return nil
16517}
16518
16519func DecodeOxmIdConjId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConjId, error) {
16520 _oxmidconjid := &OxmIdConjId{OxmId: parent}
16521 return _oxmidconjid, nil
16522}
16523
16524func NewOxmIdConjId() *OxmIdConjId {
16525 obj := &OxmIdConjId{
16526 OxmId: NewOxmId(84484),
16527 }
16528 return obj
16529}
16530func (self *OxmIdConjId) GetOXMName() string {
16531 return "conj_id"
16532}
16533
16534func (self *OxmIdConjId) MarshalJSON() ([]byte, error) {
16535 if self.TypeLen == 0 {
16536 return []byte("\"\""), nil
16537 } else {
16538 return []byte("\"" + self.GetOXMName() + "\""), nil
16539 }
16540}
16541
16542type OxmIdCtIpv6Dst struct {
16543 *OxmId
16544}
16545
16546type IOxmIdCtIpv6Dst interface {
16547 IOxmId
16548}
16549
16550func (self *OxmIdCtIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
16551 if err := self.OxmId.Serialize(encoder); err != nil {
16552 return err
16553 }
16554
16555 return nil
16556}
16557
16558func DecodeOxmIdCtIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6Dst, error) {
16559 _oxmidctipv6dst := &OxmIdCtIpv6Dst{OxmId: parent}
16560 return _oxmidctipv6dst, nil
16561}
16562
16563func NewOxmIdCtIpv6Dst() *OxmIdCtIpv6Dst {
16564 obj := &OxmIdCtIpv6Dst{
16565 OxmId: NewOxmId(128528),
16566 }
16567 return obj
16568}
16569func (self *OxmIdCtIpv6Dst) GetOXMName() string {
16570 return "ct_ipv6_dst"
16571}
16572
16573func (self *OxmIdCtIpv6Dst) MarshalJSON() ([]byte, error) {
16574 if self.TypeLen == 0 {
16575 return []byte("\"\""), nil
16576 } else {
16577 return []byte("\"" + self.GetOXMName() + "\""), nil
16578 }
16579}
16580
16581type OxmIdCtIpv6DstMasked struct {
16582 *OxmId
16583}
16584
16585type IOxmIdCtIpv6DstMasked interface {
16586 IOxmId
16587}
16588
16589func (self *OxmIdCtIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
16590 if err := self.OxmId.Serialize(encoder); err != nil {
16591 return err
16592 }
16593
16594 return nil
16595}
16596
16597func DecodeOxmIdCtIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6DstMasked, error) {
16598 _oxmidctipv6dstmasked := &OxmIdCtIpv6DstMasked{OxmId: parent}
16599 return _oxmidctipv6dstmasked, nil
16600}
16601
16602func NewOxmIdCtIpv6DstMasked() *OxmIdCtIpv6DstMasked {
16603 obj := &OxmIdCtIpv6DstMasked{
16604 OxmId: NewOxmId(128800),
16605 }
16606 return obj
16607}
16608func (self *OxmIdCtIpv6DstMasked) GetOXMName() string {
16609 return "ct_ipv6_dst_masked"
16610}
16611
16612func (self *OxmIdCtIpv6DstMasked) MarshalJSON() ([]byte, error) {
16613 if self.TypeLen == 0 {
16614 return []byte("\"\""), nil
16615 } else {
16616 return []byte("\"" + self.GetOXMName() + "\""), nil
16617 }
16618}
16619
16620type OxmIdCtIpv6Src struct {
16621 *OxmId
16622}
16623
16624type IOxmIdCtIpv6Src interface {
16625 IOxmId
16626}
16627
16628func (self *OxmIdCtIpv6Src) Serialize(encoder *goloxi.Encoder) error {
16629 if err := self.OxmId.Serialize(encoder); err != nil {
16630 return err
16631 }
16632
16633 return nil
16634}
16635
16636func DecodeOxmIdCtIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6Src, error) {
16637 _oxmidctipv6src := &OxmIdCtIpv6Src{OxmId: parent}
16638 return _oxmidctipv6src, nil
16639}
16640
16641func NewOxmIdCtIpv6Src() *OxmIdCtIpv6Src {
16642 obj := &OxmIdCtIpv6Src{
16643 OxmId: NewOxmId(128016),
16644 }
16645 return obj
16646}
16647func (self *OxmIdCtIpv6Src) GetOXMName() string {
16648 return "ct_ipv6_src"
16649}
16650
16651func (self *OxmIdCtIpv6Src) MarshalJSON() ([]byte, error) {
16652 if self.TypeLen == 0 {
16653 return []byte("\"\""), nil
16654 } else {
16655 return []byte("\"" + self.GetOXMName() + "\""), nil
16656 }
16657}
16658
16659type OxmIdCtIpv6SrcMasked struct {
16660 *OxmId
16661}
16662
16663type IOxmIdCtIpv6SrcMasked interface {
16664 IOxmId
16665}
16666
16667func (self *OxmIdCtIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
16668 if err := self.OxmId.Serialize(encoder); err != nil {
16669 return err
16670 }
16671
16672 return nil
16673}
16674
16675func DecodeOxmIdCtIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6SrcMasked, error) {
16676 _oxmidctipv6srcmasked := &OxmIdCtIpv6SrcMasked{OxmId: parent}
16677 return _oxmidctipv6srcmasked, nil
16678}
16679
16680func NewOxmIdCtIpv6SrcMasked() *OxmIdCtIpv6SrcMasked {
16681 obj := &OxmIdCtIpv6SrcMasked{
16682 OxmId: NewOxmId(128288),
16683 }
16684 return obj
16685}
16686func (self *OxmIdCtIpv6SrcMasked) GetOXMName() string {
16687 return "ct_ipv6_src_masked"
16688}
16689
16690func (self *OxmIdCtIpv6SrcMasked) MarshalJSON() ([]byte, error) {
16691 if self.TypeLen == 0 {
16692 return []byte("\"\""), nil
16693 } else {
16694 return []byte("\"" + self.GetOXMName() + "\""), nil
16695 }
16696}
16697
16698type OxmIdCtLabel struct {
16699 *OxmId
16700}
16701
16702type IOxmIdCtLabel interface {
16703 IOxmId
16704}
16705
16706func (self *OxmIdCtLabel) Serialize(encoder *goloxi.Encoder) error {
16707 if err := self.OxmId.Serialize(encoder); err != nil {
16708 return err
16709 }
16710
16711 return nil
16712}
16713
16714func DecodeOxmIdCtLabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtLabel, error) {
16715 _oxmidctlabel := &OxmIdCtLabel{OxmId: parent}
16716 return _oxmidctlabel, nil
16717}
16718
16719func NewOxmIdCtLabel() *OxmIdCtLabel {
16720 obj := &OxmIdCtLabel{
16721 OxmId: NewOxmId(120848),
16722 }
16723 return obj
16724}
16725func (self *OxmIdCtLabel) GetOXMName() string {
16726 return "ct_label"
16727}
16728
16729func (self *OxmIdCtLabel) MarshalJSON() ([]byte, error) {
16730 if self.TypeLen == 0 {
16731 return []byte("\"\""), nil
16732 } else {
16733 return []byte("\"" + self.GetOXMName() + "\""), nil
16734 }
16735}
16736
16737type OxmIdCtLabelMasked struct {
16738 *OxmId
16739}
16740
16741type IOxmIdCtLabelMasked interface {
16742 IOxmId
16743}
16744
16745func (self *OxmIdCtLabelMasked) Serialize(encoder *goloxi.Encoder) error {
16746 if err := self.OxmId.Serialize(encoder); err != nil {
16747 return err
16748 }
16749
16750 return nil
16751}
16752
16753func DecodeOxmIdCtLabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtLabelMasked, error) {
16754 _oxmidctlabelmasked := &OxmIdCtLabelMasked{OxmId: parent}
16755 return _oxmidctlabelmasked, nil
16756}
16757
16758func NewOxmIdCtLabelMasked() *OxmIdCtLabelMasked {
16759 obj := &OxmIdCtLabelMasked{
16760 OxmId: NewOxmId(121120),
16761 }
16762 return obj
16763}
16764func (self *OxmIdCtLabelMasked) GetOXMName() string {
16765 return "ct_label_masked"
16766}
16767
16768func (self *OxmIdCtLabelMasked) MarshalJSON() ([]byte, error) {
16769 if self.TypeLen == 0 {
16770 return []byte("\"\""), nil
16771 } else {
16772 return []byte("\"" + self.GetOXMName() + "\""), nil
16773 }
16774}
16775
16776type OxmIdCtMark struct {
16777 *OxmId
16778}
16779
16780type IOxmIdCtMark interface {
16781 IOxmId
16782}
16783
16784func (self *OxmIdCtMark) Serialize(encoder *goloxi.Encoder) error {
16785 if err := self.OxmId.Serialize(encoder); err != nil {
16786 return err
16787 }
16788
16789 return nil
16790}
16791
16792func DecodeOxmIdCtMark(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtMark, error) {
16793 _oxmidctmark := &OxmIdCtMark{OxmId: parent}
16794 return _oxmidctmark, nil
16795}
16796
16797func NewOxmIdCtMark() *OxmIdCtMark {
16798 obj := &OxmIdCtMark{
16799 OxmId: NewOxmId(120324),
16800 }
16801 return obj
16802}
16803func (self *OxmIdCtMark) GetOXMName() string {
16804 return "ct_mark"
16805}
16806
16807func (self *OxmIdCtMark) MarshalJSON() ([]byte, error) {
16808 if self.TypeLen == 0 {
16809 return []byte("\"\""), nil
16810 } else {
16811 return []byte("\"" + self.GetOXMName() + "\""), nil
16812 }
16813}
16814
16815type OxmIdCtMarkMasked struct {
16816 *OxmId
16817}
16818
16819type IOxmIdCtMarkMasked interface {
16820 IOxmId
16821}
16822
16823func (self *OxmIdCtMarkMasked) Serialize(encoder *goloxi.Encoder) error {
16824 if err := self.OxmId.Serialize(encoder); err != nil {
16825 return err
16826 }
16827
16828 return nil
16829}
16830
16831func DecodeOxmIdCtMarkMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtMarkMasked, error) {
16832 _oxmidctmarkmasked := &OxmIdCtMarkMasked{OxmId: parent}
16833 return _oxmidctmarkmasked, nil
16834}
16835
16836func NewOxmIdCtMarkMasked() *OxmIdCtMarkMasked {
16837 obj := &OxmIdCtMarkMasked{
16838 OxmId: NewOxmId(120584),
16839 }
16840 return obj
16841}
16842func (self *OxmIdCtMarkMasked) GetOXMName() string {
16843 return "ct_mark_masked"
16844}
16845
16846func (self *OxmIdCtMarkMasked) MarshalJSON() ([]byte, error) {
16847 if self.TypeLen == 0 {
16848 return []byte("\"\""), nil
16849 } else {
16850 return []byte("\"" + self.GetOXMName() + "\""), nil
16851 }
16852}
16853
16854type OxmIdCtNwDst struct {
16855 *OxmId
16856}
16857
16858type IOxmIdCtNwDst interface {
16859 IOxmId
16860}
16861
16862func (self *OxmIdCtNwDst) Serialize(encoder *goloxi.Encoder) error {
16863 if err := self.OxmId.Serialize(encoder); err != nil {
16864 return err
16865 }
16866
16867 return nil
16868}
16869
16870func DecodeOxmIdCtNwDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwDst, error) {
16871 _oxmidctnwdst := &OxmIdCtNwDst{OxmId: parent}
16872 return _oxmidctnwdst, nil
16873}
16874
16875func NewOxmIdCtNwDst() *OxmIdCtNwDst {
16876 obj := &OxmIdCtNwDst{
16877 OxmId: NewOxmId(127492),
16878 }
16879 return obj
16880}
16881func (self *OxmIdCtNwDst) GetOXMName() string {
16882 return "ct_nw_dst"
16883}
16884
16885func (self *OxmIdCtNwDst) MarshalJSON() ([]byte, error) {
16886 if self.TypeLen == 0 {
16887 return []byte("\"\""), nil
16888 } else {
16889 return []byte("\"" + self.GetOXMName() + "\""), nil
16890 }
16891}
16892
16893type OxmIdCtNwDstMasked struct {
16894 *OxmId
16895}
16896
16897type IOxmIdCtNwDstMasked interface {
16898 IOxmId
16899}
16900
16901func (self *OxmIdCtNwDstMasked) Serialize(encoder *goloxi.Encoder) error {
16902 if err := self.OxmId.Serialize(encoder); err != nil {
16903 return err
16904 }
16905
16906 return nil
16907}
16908
16909func DecodeOxmIdCtNwDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwDstMasked, error) {
16910 _oxmidctnwdstmasked := &OxmIdCtNwDstMasked{OxmId: parent}
16911 return _oxmidctnwdstmasked, nil
16912}
16913
16914func NewOxmIdCtNwDstMasked() *OxmIdCtNwDstMasked {
16915 obj := &OxmIdCtNwDstMasked{
16916 OxmId: NewOxmId(127752),
16917 }
16918 return obj
16919}
16920func (self *OxmIdCtNwDstMasked) GetOXMName() string {
16921 return "ct_nw_dst_masked"
16922}
16923
16924func (self *OxmIdCtNwDstMasked) MarshalJSON() ([]byte, error) {
16925 if self.TypeLen == 0 {
16926 return []byte("\"\""), nil
16927 } else {
16928 return []byte("\"" + self.GetOXMName() + "\""), nil
16929 }
16930}
16931
16932type OxmIdCtNwProto struct {
16933 *OxmId
16934}
16935
16936type IOxmIdCtNwProto interface {
16937 IOxmId
16938}
16939
16940func (self *OxmIdCtNwProto) Serialize(encoder *goloxi.Encoder) error {
16941 if err := self.OxmId.Serialize(encoder); err != nil {
16942 return err
16943 }
16944
16945 return nil
16946}
16947
16948func DecodeOxmIdCtNwProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwProto, error) {
16949 _oxmidctnwproto := &OxmIdCtNwProto{OxmId: parent}
16950 return _oxmidctnwproto, nil
16951}
16952
16953func NewOxmIdCtNwProto() *OxmIdCtNwProto {
16954 obj := &OxmIdCtNwProto{
16955 OxmId: NewOxmId(126465),
16956 }
16957 return obj
16958}
16959func (self *OxmIdCtNwProto) GetOXMName() string {
16960 return "ct_nw_proto"
16961}
16962
16963func (self *OxmIdCtNwProto) MarshalJSON() ([]byte, error) {
16964 if self.TypeLen == 0 {
16965 return []byte("\"\""), nil
16966 } else {
16967 return []byte("\"" + self.GetOXMName() + "\""), nil
16968 }
16969}
16970
16971type OxmIdCtNwSrc struct {
16972 *OxmId
16973}
16974
16975type IOxmIdCtNwSrc interface {
16976 IOxmId
16977}
16978
16979func (self *OxmIdCtNwSrc) Serialize(encoder *goloxi.Encoder) error {
16980 if err := self.OxmId.Serialize(encoder); err != nil {
16981 return err
16982 }
16983
16984 return nil
16985}
16986
16987func DecodeOxmIdCtNwSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwSrc, error) {
16988 _oxmidctnwsrc := &OxmIdCtNwSrc{OxmId: parent}
16989 return _oxmidctnwsrc, nil
16990}
16991
16992func NewOxmIdCtNwSrc() *OxmIdCtNwSrc {
16993 obj := &OxmIdCtNwSrc{
16994 OxmId: NewOxmId(126980),
16995 }
16996 return obj
16997}
16998func (self *OxmIdCtNwSrc) GetOXMName() string {
16999 return "ct_nw_src"
17000}
17001
17002func (self *OxmIdCtNwSrc) MarshalJSON() ([]byte, error) {
17003 if self.TypeLen == 0 {
17004 return []byte("\"\""), nil
17005 } else {
17006 return []byte("\"" + self.GetOXMName() + "\""), nil
17007 }
17008}
17009
17010type OxmIdCtNwSrcMasked struct {
17011 *OxmId
17012}
17013
17014type IOxmIdCtNwSrcMasked interface {
17015 IOxmId
17016}
17017
17018func (self *OxmIdCtNwSrcMasked) Serialize(encoder *goloxi.Encoder) error {
17019 if err := self.OxmId.Serialize(encoder); err != nil {
17020 return err
17021 }
17022
17023 return nil
17024}
17025
17026func DecodeOxmIdCtNwSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwSrcMasked, error) {
17027 _oxmidctnwsrcmasked := &OxmIdCtNwSrcMasked{OxmId: parent}
17028 return _oxmidctnwsrcmasked, nil
17029}
17030
17031func NewOxmIdCtNwSrcMasked() *OxmIdCtNwSrcMasked {
17032 obj := &OxmIdCtNwSrcMasked{
17033 OxmId: NewOxmId(127240),
17034 }
17035 return obj
17036}
17037func (self *OxmIdCtNwSrcMasked) GetOXMName() string {
17038 return "ct_nw_src_masked"
17039}
17040
17041func (self *OxmIdCtNwSrcMasked) MarshalJSON() ([]byte, error) {
17042 if self.TypeLen == 0 {
17043 return []byte("\"\""), nil
17044 } else {
17045 return []byte("\"" + self.GetOXMName() + "\""), nil
17046 }
17047}
17048
17049type OxmIdCtState struct {
17050 *OxmId
17051}
17052
17053type IOxmIdCtState interface {
17054 IOxmId
17055}
17056
17057func (self *OxmIdCtState) Serialize(encoder *goloxi.Encoder) error {
17058 if err := self.OxmId.Serialize(encoder); err != nil {
17059 return err
17060 }
17061
17062 return nil
17063}
17064
17065func DecodeOxmIdCtState(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtState, error) {
17066 _oxmidctstate := &OxmIdCtState{OxmId: parent}
17067 return _oxmidctstate, nil
17068}
17069
17070func NewOxmIdCtState() *OxmIdCtState {
17071 obj := &OxmIdCtState{
17072 OxmId: NewOxmId(119300),
17073 }
17074 return obj
17075}
17076func (self *OxmIdCtState) GetOXMName() string {
17077 return "ct_state"
17078}
17079
17080func (self *OxmIdCtState) MarshalJSON() ([]byte, error) {
17081 if self.TypeLen == 0 {
17082 return []byte("\"\""), nil
17083 } else {
17084 return []byte("\"" + self.GetOXMName() + "\""), nil
17085 }
17086}
17087
17088type OxmIdCtStateMasked struct {
17089 *OxmId
17090}
17091
17092type IOxmIdCtStateMasked interface {
17093 IOxmId
17094}
17095
17096func (self *OxmIdCtStateMasked) Serialize(encoder *goloxi.Encoder) error {
17097 if err := self.OxmId.Serialize(encoder); err != nil {
17098 return err
17099 }
17100
17101 return nil
17102}
17103
17104func DecodeOxmIdCtStateMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtStateMasked, error) {
17105 _oxmidctstatemasked := &OxmIdCtStateMasked{OxmId: parent}
17106 return _oxmidctstatemasked, nil
17107}
17108
17109func NewOxmIdCtStateMasked() *OxmIdCtStateMasked {
17110 obj := &OxmIdCtStateMasked{
17111 OxmId: NewOxmId(119560),
17112 }
17113 return obj
17114}
17115func (self *OxmIdCtStateMasked) GetOXMName() string {
17116 return "ct_state_masked"
17117}
17118
17119func (self *OxmIdCtStateMasked) MarshalJSON() ([]byte, error) {
17120 if self.TypeLen == 0 {
17121 return []byte("\"\""), nil
17122 } else {
17123 return []byte("\"" + self.GetOXMName() + "\""), nil
17124 }
17125}
17126
17127type OxmIdCtTpDst struct {
17128 *OxmId
17129}
17130
17131type IOxmIdCtTpDst interface {
17132 IOxmId
17133}
17134
17135func (self *OxmIdCtTpDst) Serialize(encoder *goloxi.Encoder) error {
17136 if err := self.OxmId.Serialize(encoder); err != nil {
17137 return err
17138 }
17139
17140 return nil
17141}
17142
17143func DecodeOxmIdCtTpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpDst, error) {
17144 _oxmidcttpdst := &OxmIdCtTpDst{OxmId: parent}
17145 return _oxmidcttpdst, nil
17146}
17147
17148func NewOxmIdCtTpDst() *OxmIdCtTpDst {
17149 obj := &OxmIdCtTpDst{
17150 OxmId: NewOxmId(129538),
17151 }
17152 return obj
17153}
17154func (self *OxmIdCtTpDst) GetOXMName() string {
17155 return "ct_tp_dst"
17156}
17157
17158func (self *OxmIdCtTpDst) MarshalJSON() ([]byte, error) {
17159 if self.TypeLen == 0 {
17160 return []byte("\"\""), nil
17161 } else {
17162 return []byte("\"" + self.GetOXMName() + "\""), nil
17163 }
17164}
17165
17166type OxmIdCtTpDstMasked struct {
17167 *OxmId
17168}
17169
17170type IOxmIdCtTpDstMasked interface {
17171 IOxmId
17172}
17173
17174func (self *OxmIdCtTpDstMasked) Serialize(encoder *goloxi.Encoder) error {
17175 if err := self.OxmId.Serialize(encoder); err != nil {
17176 return err
17177 }
17178
17179 return nil
17180}
17181
17182func DecodeOxmIdCtTpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpDstMasked, error) {
17183 _oxmidcttpdstmasked := &OxmIdCtTpDstMasked{OxmId: parent}
17184 return _oxmidcttpdstmasked, nil
17185}
17186
17187func NewOxmIdCtTpDstMasked() *OxmIdCtTpDstMasked {
17188 obj := &OxmIdCtTpDstMasked{
17189 OxmId: NewOxmId(129796),
17190 }
17191 return obj
17192}
17193func (self *OxmIdCtTpDstMasked) GetOXMName() string {
17194 return "ct_tp_dst_masked"
17195}
17196
17197func (self *OxmIdCtTpDstMasked) MarshalJSON() ([]byte, error) {
17198 if self.TypeLen == 0 {
17199 return []byte("\"\""), nil
17200 } else {
17201 return []byte("\"" + self.GetOXMName() + "\""), nil
17202 }
17203}
17204
17205type OxmIdCtTpSrc struct {
17206 *OxmId
17207}
17208
17209type IOxmIdCtTpSrc interface {
17210 IOxmId
17211}
17212
17213func (self *OxmIdCtTpSrc) Serialize(encoder *goloxi.Encoder) error {
17214 if err := self.OxmId.Serialize(encoder); err != nil {
17215 return err
17216 }
17217
17218 return nil
17219}
17220
17221func DecodeOxmIdCtTpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpSrc, error) {
17222 _oxmidcttpsrc := &OxmIdCtTpSrc{OxmId: parent}
17223 return _oxmidcttpsrc, nil
17224}
17225
17226func NewOxmIdCtTpSrc() *OxmIdCtTpSrc {
17227 obj := &OxmIdCtTpSrc{
17228 OxmId: NewOxmId(129026),
17229 }
17230 return obj
17231}
17232func (self *OxmIdCtTpSrc) GetOXMName() string {
17233 return "ct_tp_src"
17234}
17235
17236func (self *OxmIdCtTpSrc) MarshalJSON() ([]byte, error) {
17237 if self.TypeLen == 0 {
17238 return []byte("\"\""), nil
17239 } else {
17240 return []byte("\"" + self.GetOXMName() + "\""), nil
17241 }
17242}
17243
17244type OxmIdCtTpSrcMasked struct {
17245 *OxmId
17246}
17247
17248type IOxmIdCtTpSrcMasked interface {
17249 IOxmId
17250}
17251
17252func (self *OxmIdCtTpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
17253 if err := self.OxmId.Serialize(encoder); err != nil {
17254 return err
17255 }
17256
17257 return nil
17258}
17259
17260func DecodeOxmIdCtTpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpSrcMasked, error) {
17261 _oxmidcttpsrcmasked := &OxmIdCtTpSrcMasked{OxmId: parent}
17262 return _oxmidcttpsrcmasked, nil
17263}
17264
17265func NewOxmIdCtTpSrcMasked() *OxmIdCtTpSrcMasked {
17266 obj := &OxmIdCtTpSrcMasked{
17267 OxmId: NewOxmId(129284),
17268 }
17269 return obj
17270}
17271func (self *OxmIdCtTpSrcMasked) GetOXMName() string {
17272 return "ct_tp_src_masked"
17273}
17274
17275func (self *OxmIdCtTpSrcMasked) MarshalJSON() ([]byte, error) {
17276 if self.TypeLen == 0 {
17277 return []byte("\"\""), nil
17278 } else {
17279 return []byte("\"" + self.GetOXMName() + "\""), nil
17280 }
17281}
17282
17283type OxmIdCtZone struct {
17284 *OxmId
17285}
17286
17287type IOxmIdCtZone interface {
17288 IOxmId
17289}
17290
17291func (self *OxmIdCtZone) Serialize(encoder *goloxi.Encoder) error {
17292 if err := self.OxmId.Serialize(encoder); err != nil {
17293 return err
17294 }
17295
17296 return nil
17297}
17298
17299func DecodeOxmIdCtZone(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtZone, error) {
17300 _oxmidctzone := &OxmIdCtZone{OxmId: parent}
17301 return _oxmidctzone, nil
17302}
17303
17304func NewOxmIdCtZone() *OxmIdCtZone {
17305 obj := &OxmIdCtZone{
17306 OxmId: NewOxmId(119810),
17307 }
17308 return obj
17309}
17310func (self *OxmIdCtZone) GetOXMName() string {
17311 return "ct_zone"
17312}
17313
17314func (self *OxmIdCtZone) MarshalJSON() ([]byte, error) {
17315 if self.TypeLen == 0 {
17316 return []byte("\"\""), nil
17317 } else {
17318 return []byte("\"" + self.GetOXMName() + "\""), nil
17319 }
17320}
17321
17322type OxmIdDpHash struct {
17323 *OxmId
17324}
17325
17326type IOxmIdDpHash interface {
17327 IOxmId
17328}
17329
17330func (self *OxmIdDpHash) Serialize(encoder *goloxi.Encoder) error {
17331 if err := self.OxmId.Serialize(encoder); err != nil {
17332 return err
17333 }
17334
17335 return nil
17336}
17337
17338func DecodeOxmIdDpHash(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdDpHash, error) {
17339 _oxmiddphash := &OxmIdDpHash{OxmId: parent}
17340 return _oxmiddphash, nil
17341}
17342
17343func NewOxmIdDpHash() *OxmIdDpHash {
17344 obj := &OxmIdDpHash{
17345 OxmId: NewOxmId(83460),
17346 }
17347 return obj
17348}
17349func (self *OxmIdDpHash) GetOXMName() string {
17350 return "dp_hash"
17351}
17352
17353func (self *OxmIdDpHash) MarshalJSON() ([]byte, error) {
17354 if self.TypeLen == 0 {
17355 return []byte("\"\""), nil
17356 } else {
17357 return []byte("\"" + self.GetOXMName() + "\""), nil
17358 }
17359}
17360
17361type OxmIdDpHashMasked struct {
17362 *OxmId
17363}
17364
17365type IOxmIdDpHashMasked interface {
17366 IOxmId
17367}
17368
17369func (self *OxmIdDpHashMasked) Serialize(encoder *goloxi.Encoder) error {
17370 if err := self.OxmId.Serialize(encoder); err != nil {
17371 return err
17372 }
17373
17374 return nil
17375}
17376
17377func DecodeOxmIdDpHashMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdDpHashMasked, error) {
17378 _oxmiddphashmasked := &OxmIdDpHashMasked{OxmId: parent}
17379 return _oxmiddphashmasked, nil
17380}
17381
17382func NewOxmIdDpHashMasked() *OxmIdDpHashMasked {
17383 obj := &OxmIdDpHashMasked{
17384 OxmId: NewOxmId(83720),
17385 }
17386 return obj
17387}
17388func (self *OxmIdDpHashMasked) GetOXMName() string {
17389 return "dp_hash_masked"
17390}
17391
17392func (self *OxmIdDpHashMasked) MarshalJSON() ([]byte, error) {
17393 if self.TypeLen == 0 {
17394 return []byte("\"\""), nil
17395 } else {
17396 return []byte("\"" + self.GetOXMName() + "\""), nil
17397 }
17398}
17399
17400type OxmIdEthDst struct {
17401 *OxmId
17402}
17403
17404type IOxmIdEthDst interface {
17405 IOxmId
17406}
17407
17408func (self *OxmIdEthDst) Serialize(encoder *goloxi.Encoder) error {
17409 if err := self.OxmId.Serialize(encoder); err != nil {
17410 return err
17411 }
17412
17413 return nil
17414}
17415
17416func DecodeOxmIdEthDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthDst, error) {
17417 _oxmidethdst := &OxmIdEthDst{OxmId: parent}
17418 return _oxmidethdst, nil
17419}
17420
17421func NewOxmIdEthDst() *OxmIdEthDst {
17422 obj := &OxmIdEthDst{
17423 OxmId: NewOxmId(518),
17424 }
17425 return obj
17426}
17427func (self *OxmIdEthDst) GetOXMName() string {
17428 return "eth_dst"
17429}
17430
17431func (self *OxmIdEthDst) MarshalJSON() ([]byte, error) {
17432 if self.TypeLen == 0 {
17433 return []byte("\"\""), nil
17434 } else {
17435 return []byte("\"" + self.GetOXMName() + "\""), nil
17436 }
17437}
17438
17439type OxmIdEthDstMasked struct {
17440 *OxmId
17441}
17442
17443type IOxmIdEthDstMasked interface {
17444 IOxmId
17445}
17446
17447func (self *OxmIdEthDstMasked) Serialize(encoder *goloxi.Encoder) error {
17448 if err := self.OxmId.Serialize(encoder); err != nil {
17449 return err
17450 }
17451
17452 return nil
17453}
17454
17455func DecodeOxmIdEthDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthDstMasked, error) {
17456 _oxmidethdstmasked := &OxmIdEthDstMasked{OxmId: parent}
17457 return _oxmidethdstmasked, nil
17458}
17459
17460func NewOxmIdEthDstMasked() *OxmIdEthDstMasked {
17461 obj := &OxmIdEthDstMasked{
17462 OxmId: NewOxmId(779),
17463 }
17464 return obj
17465}
17466func (self *OxmIdEthDstMasked) GetOXMName() string {
17467 return "eth_dst_masked"
17468}
17469
17470func (self *OxmIdEthDstMasked) MarshalJSON() ([]byte, error) {
17471 if self.TypeLen == 0 {
17472 return []byte("\"\""), nil
17473 } else {
17474 return []byte("\"" + self.GetOXMName() + "\""), nil
17475 }
17476}
17477
17478type OxmIdEthSrc struct {
17479 *OxmId
17480}
17481
17482type IOxmIdEthSrc interface {
17483 IOxmId
17484}
17485
17486func (self *OxmIdEthSrc) Serialize(encoder *goloxi.Encoder) error {
17487 if err := self.OxmId.Serialize(encoder); err != nil {
17488 return err
17489 }
17490
17491 return nil
17492}
17493
17494func DecodeOxmIdEthSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthSrc, error) {
17495 _oxmidethsrc := &OxmIdEthSrc{OxmId: parent}
17496 return _oxmidethsrc, nil
17497}
17498
17499func NewOxmIdEthSrc() *OxmIdEthSrc {
17500 obj := &OxmIdEthSrc{
17501 OxmId: NewOxmId(1030),
17502 }
17503 return obj
17504}
17505func (self *OxmIdEthSrc) GetOXMName() string {
17506 return "eth_src"
17507}
17508
17509func (self *OxmIdEthSrc) MarshalJSON() ([]byte, error) {
17510 if self.TypeLen == 0 {
17511 return []byte("\"\""), nil
17512 } else {
17513 return []byte("\"" + self.GetOXMName() + "\""), nil
17514 }
17515}
17516
17517type OxmIdEthSrcMasked struct {
17518 *OxmId
17519}
17520
17521type IOxmIdEthSrcMasked interface {
17522 IOxmId
17523}
17524
17525func (self *OxmIdEthSrcMasked) Serialize(encoder *goloxi.Encoder) error {
17526 if err := self.OxmId.Serialize(encoder); err != nil {
17527 return err
17528 }
17529
17530 return nil
17531}
17532
17533func DecodeOxmIdEthSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthSrcMasked, error) {
17534 _oxmidethsrcmasked := &OxmIdEthSrcMasked{OxmId: parent}
17535 return _oxmidethsrcmasked, nil
17536}
17537
17538func NewOxmIdEthSrcMasked() *OxmIdEthSrcMasked {
17539 obj := &OxmIdEthSrcMasked{
17540 OxmId: NewOxmId(1286),
17541 }
17542 return obj
17543}
17544func (self *OxmIdEthSrcMasked) GetOXMName() string {
17545 return "eth_src_masked"
17546}
17547
17548func (self *OxmIdEthSrcMasked) MarshalJSON() ([]byte, error) {
17549 if self.TypeLen == 0 {
17550 return []byte("\"\""), nil
17551 } else {
17552 return []byte("\"" + self.GetOXMName() + "\""), nil
17553 }
17554}
17555
17556type OxmIdEthType struct {
17557 *OxmId
17558}
17559
17560type IOxmIdEthType interface {
17561 IOxmId
17562}
17563
17564func (self *OxmIdEthType) Serialize(encoder *goloxi.Encoder) error {
17565 if err := self.OxmId.Serialize(encoder); err != nil {
17566 return err
17567 }
17568
17569 return nil
17570}
17571
17572func DecodeOxmIdEthType(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthType, error) {
17573 _oxmidethtype := &OxmIdEthType{OxmId: parent}
17574 return _oxmidethtype, nil
17575}
17576
17577func NewOxmIdEthType() *OxmIdEthType {
17578 obj := &OxmIdEthType{
17579 OxmId: NewOxmId(1538),
17580 }
17581 return obj
17582}
17583func (self *OxmIdEthType) GetOXMName() string {
17584 return "eth_type"
17585}
17586
17587func (self *OxmIdEthType) MarshalJSON() ([]byte, error) {
17588 if self.TypeLen == 0 {
17589 return []byte("\"\""), nil
17590 } else {
17591 return []byte("\"" + self.GetOXMName() + "\""), nil
17592 }
17593}
17594
17595type OxmIdIcmpCode struct {
17596 *OxmId
17597}
17598
17599type IOxmIdIcmpCode interface {
17600 IOxmId
17601}
17602
17603func (self *OxmIdIcmpCode) Serialize(encoder *goloxi.Encoder) error {
17604 if err := self.OxmId.Serialize(encoder); err != nil {
17605 return err
17606 }
17607
17608 return nil
17609}
17610
17611func DecodeOxmIdIcmpCode(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpCode, error) {
17612 _oxmidicmpcode := &OxmIdIcmpCode{OxmId: parent}
17613 return _oxmidicmpcode, nil
17614}
17615
17616func NewOxmIdIcmpCode() *OxmIdIcmpCode {
17617 obj := &OxmIdIcmpCode{
17618 OxmId: NewOxmId(7169),
17619 }
17620 return obj
17621}
17622func (self *OxmIdIcmpCode) GetOXMName() string {
17623 return "icmp_code"
17624}
17625
17626func (self *OxmIdIcmpCode) MarshalJSON() ([]byte, error) {
17627 if self.TypeLen == 0 {
17628 return []byte("\"\""), nil
17629 } else {
17630 return []byte("\"" + self.GetOXMName() + "\""), nil
17631 }
17632}
17633
17634type OxmIdIcmpType struct {
17635 *OxmId
17636}
17637
17638type IOxmIdIcmpType interface {
17639 IOxmId
17640}
17641
17642func (self *OxmIdIcmpType) Serialize(encoder *goloxi.Encoder) error {
17643 if err := self.OxmId.Serialize(encoder); err != nil {
17644 return err
17645 }
17646
17647 return nil
17648}
17649
17650func DecodeOxmIdIcmpType(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpType, error) {
17651 _oxmidicmptype := &OxmIdIcmpType{OxmId: parent}
17652 return _oxmidicmptype, nil
17653}
17654
17655func NewOxmIdIcmpType() *OxmIdIcmpType {
17656 obj := &OxmIdIcmpType{
17657 OxmId: NewOxmId(6657),
17658 }
17659 return obj
17660}
17661func (self *OxmIdIcmpType) GetOXMName() string {
17662 return "icmp_type"
17663}
17664
17665func (self *OxmIdIcmpType) MarshalJSON() ([]byte, error) {
17666 if self.TypeLen == 0 {
17667 return []byte("\"\""), nil
17668 } else {
17669 return []byte("\"" + self.GetOXMName() + "\""), nil
17670 }
17671}
17672
17673type OxmIdIcmpv6Code struct {
17674 *OxmId
17675}
17676
17677type IOxmIdIcmpv6Code interface {
17678 IOxmId
17679}
17680
17681func (self *OxmIdIcmpv6Code) Serialize(encoder *goloxi.Encoder) error {
17682 if err := self.OxmId.Serialize(encoder); err != nil {
17683 return err
17684 }
17685
17686 return nil
17687}
17688
17689func DecodeOxmIdIcmpv6Code(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6Code, error) {
17690 _oxmidicmpv6code := &OxmIdIcmpv6Code{OxmId: parent}
17691 return _oxmidicmpv6code, nil
17692}
17693
17694func NewOxmIdIcmpv6Code() *OxmIdIcmpv6Code {
17695 obj := &OxmIdIcmpv6Code{
17696 OxmId: NewOxmId(76801),
17697 }
17698 return obj
17699}
17700func (self *OxmIdIcmpv6Code) GetOXMName() string {
17701 return "icmpv6_code"
17702}
17703
17704func (self *OxmIdIcmpv6Code) MarshalJSON() ([]byte, error) {
17705 if self.TypeLen == 0 {
17706 return []byte("\"\""), nil
17707 } else {
17708 return []byte("\"" + self.GetOXMName() + "\""), nil
17709 }
17710}
17711
17712type OxmIdIcmpv6Type struct {
17713 *OxmId
17714}
17715
17716type IOxmIdIcmpv6Type interface {
17717 IOxmId
17718}
17719
17720func (self *OxmIdIcmpv6Type) Serialize(encoder *goloxi.Encoder) error {
17721 if err := self.OxmId.Serialize(encoder); err != nil {
17722 return err
17723 }
17724
17725 return nil
17726}
17727
17728func DecodeOxmIdIcmpv6Type(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6Type, error) {
17729 _oxmidicmpv6type := &OxmIdIcmpv6Type{OxmId: parent}
17730 return _oxmidicmpv6type, nil
17731}
17732
17733func NewOxmIdIcmpv6Type() *OxmIdIcmpv6Type {
17734 obj := &OxmIdIcmpv6Type{
17735 OxmId: NewOxmId(76289),
17736 }
17737 return obj
17738}
17739func (self *OxmIdIcmpv6Type) GetOXMName() string {
17740 return "icmpv6_type"
17741}
17742
17743func (self *OxmIdIcmpv6Type) MarshalJSON() ([]byte, error) {
17744 if self.TypeLen == 0 {
17745 return []byte("\"\""), nil
17746 } else {
17747 return []byte("\"" + self.GetOXMName() + "\""), nil
17748 }
17749}
17750
17751type OxmIdInPort struct {
17752 *OxmId
17753}
17754
17755type IOxmIdInPort interface {
17756 IOxmId
17757}
17758
17759func (self *OxmIdInPort) Serialize(encoder *goloxi.Encoder) error {
17760 if err := self.OxmId.Serialize(encoder); err != nil {
17761 return err
17762 }
17763
17764 return nil
17765}
17766
17767func DecodeOxmIdInPort(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPort, error) {
17768 _oxmidinport := &OxmIdInPort{OxmId: parent}
17769 return _oxmidinport, nil
17770}
17771
17772func NewOxmIdInPort() *OxmIdInPort {
17773 obj := &OxmIdInPort{
17774 OxmId: NewOxmId(2),
17775 }
17776 return obj
17777}
17778func (self *OxmIdInPort) GetOXMName() string {
17779 return "in_port"
17780}
17781
17782func (self *OxmIdInPort) MarshalJSON() ([]byte, error) {
17783 if self.TypeLen == 0 {
17784 return []byte("\"\""), nil
17785 } else {
17786 return []byte("\"" + self.GetOXMName() + "\""), nil
17787 }
17788}
17789
17790type OxmIdIpDst struct {
17791 *OxmId
17792}
17793
17794type IOxmIdIpDst interface {
17795 IOxmId
17796}
17797
17798func (self *OxmIdIpDst) Serialize(encoder *goloxi.Encoder) error {
17799 if err := self.OxmId.Serialize(encoder); err != nil {
17800 return err
17801 }
17802
17803 return nil
17804}
17805
17806func DecodeOxmIdIpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDst, error) {
17807 _oxmidipdst := &OxmIdIpDst{OxmId: parent}
17808 return _oxmidipdst, nil
17809}
17810
17811func NewOxmIdIpDst() *OxmIdIpDst {
17812 obj := &OxmIdIpDst{
17813 OxmId: NewOxmId(4100),
17814 }
17815 return obj
17816}
17817func (self *OxmIdIpDst) GetOXMName() string {
17818 return "ip_dst"
17819}
17820
17821func (self *OxmIdIpDst) MarshalJSON() ([]byte, error) {
17822 if self.TypeLen == 0 {
17823 return []byte("\"\""), nil
17824 } else {
17825 return []byte("\"" + self.GetOXMName() + "\""), nil
17826 }
17827}
17828
17829type OxmIdIpDstMasked struct {
17830 *OxmId
17831}
17832
17833type IOxmIdIpDstMasked interface {
17834 IOxmId
17835}
17836
17837func (self *OxmIdIpDstMasked) Serialize(encoder *goloxi.Encoder) error {
17838 if err := self.OxmId.Serialize(encoder); err != nil {
17839 return err
17840 }
17841
17842 return nil
17843}
17844
17845func DecodeOxmIdIpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDstMasked, error) {
17846 _oxmidipdstmasked := &OxmIdIpDstMasked{OxmId: parent}
17847 return _oxmidipdstmasked, nil
17848}
17849
17850func NewOxmIdIpDstMasked() *OxmIdIpDstMasked {
17851 obj := &OxmIdIpDstMasked{
17852 OxmId: NewOxmId(4360),
17853 }
17854 return obj
17855}
17856func (self *OxmIdIpDstMasked) GetOXMName() string {
17857 return "ip_dst_masked"
17858}
17859
17860func (self *OxmIdIpDstMasked) MarshalJSON() ([]byte, error) {
17861 if self.TypeLen == 0 {
17862 return []byte("\"\""), nil
17863 } else {
17864 return []byte("\"" + self.GetOXMName() + "\""), nil
17865 }
17866}
17867
17868type OxmIdIpFrag struct {
17869 *OxmId
17870}
17871
17872type IOxmIdIpFrag interface {
17873 IOxmId
17874}
17875
17876func (self *OxmIdIpFrag) Serialize(encoder *goloxi.Encoder) error {
17877 if err := self.OxmId.Serialize(encoder); err != nil {
17878 return err
17879 }
17880
17881 return nil
17882}
17883
17884func DecodeOxmIdIpFrag(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpFrag, error) {
17885 _oxmidipfrag := &OxmIdIpFrag{OxmId: parent}
17886 return _oxmidipfrag, nil
17887}
17888
17889func NewOxmIdIpFrag() *OxmIdIpFrag {
17890 obj := &OxmIdIpFrag{
17891 OxmId: NewOxmId(78849),
17892 }
17893 return obj
17894}
17895func (self *OxmIdIpFrag) GetOXMName() string {
17896 return "ip_frag"
17897}
17898
17899func (self *OxmIdIpFrag) MarshalJSON() ([]byte, error) {
17900 if self.TypeLen == 0 {
17901 return []byte("\"\""), nil
17902 } else {
17903 return []byte("\"" + self.GetOXMName() + "\""), nil
17904 }
17905}
17906
17907type OxmIdIpFragMasked struct {
17908 *OxmId
17909}
17910
17911type IOxmIdIpFragMasked interface {
17912 IOxmId
17913}
17914
17915func (self *OxmIdIpFragMasked) Serialize(encoder *goloxi.Encoder) error {
17916 if err := self.OxmId.Serialize(encoder); err != nil {
17917 return err
17918 }
17919
17920 return nil
17921}
17922
17923func DecodeOxmIdIpFragMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpFragMasked, error) {
17924 _oxmidipfragmasked := &OxmIdIpFragMasked{OxmId: parent}
17925 return _oxmidipfragmasked, nil
17926}
17927
17928func NewOxmIdIpFragMasked() *OxmIdIpFragMasked {
17929 obj := &OxmIdIpFragMasked{
17930 OxmId: NewOxmId(79106),
17931 }
17932 return obj
17933}
17934func (self *OxmIdIpFragMasked) GetOXMName() string {
17935 return "ip_frag_masked"
17936}
17937
17938func (self *OxmIdIpFragMasked) MarshalJSON() ([]byte, error) {
17939 if self.TypeLen == 0 {
17940 return []byte("\"\""), nil
17941 } else {
17942 return []byte("\"" + self.GetOXMName() + "\""), nil
17943 }
17944}
17945
17946type OxmIdIpSrc struct {
17947 *OxmId
17948}
17949
17950type IOxmIdIpSrc interface {
17951 IOxmId
17952}
17953
17954func (self *OxmIdIpSrc) Serialize(encoder *goloxi.Encoder) error {
17955 if err := self.OxmId.Serialize(encoder); err != nil {
17956 return err
17957 }
17958
17959 return nil
17960}
17961
17962func DecodeOxmIdIpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpSrc, error) {
17963 _oxmidipsrc := &OxmIdIpSrc{OxmId: parent}
17964 return _oxmidipsrc, nil
17965}
17966
17967func NewOxmIdIpSrc() *OxmIdIpSrc {
17968 obj := &OxmIdIpSrc{
17969 OxmId: NewOxmId(3588),
17970 }
17971 return obj
17972}
17973func (self *OxmIdIpSrc) GetOXMName() string {
17974 return "ip_src"
17975}
17976
17977func (self *OxmIdIpSrc) MarshalJSON() ([]byte, error) {
17978 if self.TypeLen == 0 {
17979 return []byte("\"\""), nil
17980 } else {
17981 return []byte("\"" + self.GetOXMName() + "\""), nil
17982 }
17983}
17984
17985type OxmIdIpSrcMasked struct {
17986 *OxmId
17987}
17988
17989type IOxmIdIpSrcMasked interface {
17990 IOxmId
17991}
17992
17993func (self *OxmIdIpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
17994 if err := self.OxmId.Serialize(encoder); err != nil {
17995 return err
17996 }
17997
17998 return nil
17999}
18000
18001func DecodeOxmIdIpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpSrcMasked, error) {
18002 _oxmidipsrcmasked := &OxmIdIpSrcMasked{OxmId: parent}
18003 return _oxmidipsrcmasked, nil
18004}
18005
18006func NewOxmIdIpSrcMasked() *OxmIdIpSrcMasked {
18007 obj := &OxmIdIpSrcMasked{
18008 OxmId: NewOxmId(3848),
18009 }
18010 return obj
18011}
18012func (self *OxmIdIpSrcMasked) GetOXMName() string {
18013 return "ip_src_masked"
18014}
18015
18016func (self *OxmIdIpSrcMasked) MarshalJSON() ([]byte, error) {
18017 if self.TypeLen == 0 {
18018 return []byte("\"\""), nil
18019 } else {
18020 return []byte("\"" + self.GetOXMName() + "\""), nil
18021 }
18022}
18023
18024type OxmIdIpv6Dst struct {
18025 *OxmId
18026}
18027
18028type IOxmIdIpv6Dst interface {
18029 IOxmId
18030}
18031
18032func (self *OxmIdIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
18033 if err := self.OxmId.Serialize(encoder); err != nil {
18034 return err
18035 }
18036
18037 return nil
18038}
18039
18040func DecodeOxmIdIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Dst, error) {
18041 _oxmidipv6dst := &OxmIdIpv6Dst{OxmId: parent}
18042 return _oxmidipv6dst, nil
18043}
18044
18045func NewOxmIdIpv6Dst() *OxmIdIpv6Dst {
18046 obj := &OxmIdIpv6Dst{
18047 OxmId: NewOxmId(75792),
18048 }
18049 return obj
18050}
18051func (self *OxmIdIpv6Dst) GetOXMName() string {
18052 return "ipv6_dst"
18053}
18054
18055func (self *OxmIdIpv6Dst) MarshalJSON() ([]byte, error) {
18056 if self.TypeLen == 0 {
18057 return []byte("\"\""), nil
18058 } else {
18059 return []byte("\"" + self.GetOXMName() + "\""), nil
18060 }
18061}
18062
18063type OxmIdIpv6DstMasked struct {
18064 *OxmId
18065}
18066
18067type IOxmIdIpv6DstMasked interface {
18068 IOxmId
18069}
18070
18071func (self *OxmIdIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
18072 if err := self.OxmId.Serialize(encoder); err != nil {
18073 return err
18074 }
18075
18076 return nil
18077}
18078
18079func DecodeOxmIdIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6DstMasked, error) {
18080 _oxmidipv6dstmasked := &OxmIdIpv6DstMasked{OxmId: parent}
18081 return _oxmidipv6dstmasked, nil
18082}
18083
18084func NewOxmIdIpv6DstMasked() *OxmIdIpv6DstMasked {
18085 obj := &OxmIdIpv6DstMasked{
18086 OxmId: NewOxmId(76064),
18087 }
18088 return obj
18089}
18090func (self *OxmIdIpv6DstMasked) GetOXMName() string {
18091 return "ipv6_dst_masked"
18092}
18093
18094func (self *OxmIdIpv6DstMasked) MarshalJSON() ([]byte, error) {
18095 if self.TypeLen == 0 {
18096 return []byte("\"\""), nil
18097 } else {
18098 return []byte("\"" + self.GetOXMName() + "\""), nil
18099 }
18100}
18101
18102type OxmIdIpv6Label struct {
18103 *OxmId
18104}
18105
18106type IOxmIdIpv6Label interface {
18107 IOxmId
18108}
18109
18110func (self *OxmIdIpv6Label) Serialize(encoder *goloxi.Encoder) error {
18111 if err := self.OxmId.Serialize(encoder); err != nil {
18112 return err
18113 }
18114
18115 return nil
18116}
18117
18118func DecodeOxmIdIpv6Label(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Label, error) {
18119 _oxmidipv6label := &OxmIdIpv6Label{OxmId: parent}
18120 return _oxmidipv6label, nil
18121}
18122
18123func NewOxmIdIpv6Label() *OxmIdIpv6Label {
18124 obj := &OxmIdIpv6Label{
18125 OxmId: NewOxmId(79364),
18126 }
18127 return obj
18128}
18129func (self *OxmIdIpv6Label) GetOXMName() string {
18130 return "ipv6_label"
18131}
18132
18133func (self *OxmIdIpv6Label) MarshalJSON() ([]byte, error) {
18134 if self.TypeLen == 0 {
18135 return []byte("\"\""), nil
18136 } else {
18137 return []byte("\"" + self.GetOXMName() + "\""), nil
18138 }
18139}
18140
18141type OxmIdIpv6LabelMasked struct {
18142 *OxmId
18143}
18144
18145type IOxmIdIpv6LabelMasked interface {
18146 IOxmId
18147}
18148
18149func (self *OxmIdIpv6LabelMasked) Serialize(encoder *goloxi.Encoder) error {
18150 if err := self.OxmId.Serialize(encoder); err != nil {
18151 return err
18152 }
18153
18154 return nil
18155}
18156
18157func DecodeOxmIdIpv6LabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6LabelMasked, error) {
18158 _oxmidipv6labelmasked := &OxmIdIpv6LabelMasked{OxmId: parent}
18159 return _oxmidipv6labelmasked, nil
18160}
18161
18162func NewOxmIdIpv6LabelMasked() *OxmIdIpv6LabelMasked {
18163 obj := &OxmIdIpv6LabelMasked{
18164 OxmId: NewOxmId(79624),
18165 }
18166 return obj
18167}
18168func (self *OxmIdIpv6LabelMasked) GetOXMName() string {
18169 return "ipv6_label_masked"
18170}
18171
18172func (self *OxmIdIpv6LabelMasked) MarshalJSON() ([]byte, error) {
18173 if self.TypeLen == 0 {
18174 return []byte("\"\""), nil
18175 } else {
18176 return []byte("\"" + self.GetOXMName() + "\""), nil
18177 }
18178}
18179
18180type OxmIdIpv6Src struct {
18181 *OxmId
18182}
18183
18184type IOxmIdIpv6Src interface {
18185 IOxmId
18186}
18187
18188func (self *OxmIdIpv6Src) Serialize(encoder *goloxi.Encoder) error {
18189 if err := self.OxmId.Serialize(encoder); err != nil {
18190 return err
18191 }
18192
18193 return nil
18194}
18195
18196func DecodeOxmIdIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Src, error) {
18197 _oxmidipv6src := &OxmIdIpv6Src{OxmId: parent}
18198 return _oxmidipv6src, nil
18199}
18200
18201func NewOxmIdIpv6Src() *OxmIdIpv6Src {
18202 obj := &OxmIdIpv6Src{
18203 OxmId: NewOxmId(75280),
18204 }
18205 return obj
18206}
18207func (self *OxmIdIpv6Src) GetOXMName() string {
18208 return "ipv6_src"
18209}
18210
18211func (self *OxmIdIpv6Src) MarshalJSON() ([]byte, error) {
18212 if self.TypeLen == 0 {
18213 return []byte("\"\""), nil
18214 } else {
18215 return []byte("\"" + self.GetOXMName() + "\""), nil
18216 }
18217}
18218
18219type OxmIdIpv6SrcMasked struct {
18220 *OxmId
18221}
18222
18223type IOxmIdIpv6SrcMasked interface {
18224 IOxmId
18225}
18226
18227func (self *OxmIdIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
18228 if err := self.OxmId.Serialize(encoder); err != nil {
18229 return err
18230 }
18231
18232 return nil
18233}
18234
18235func DecodeOxmIdIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6SrcMasked, error) {
18236 _oxmidipv6srcmasked := &OxmIdIpv6SrcMasked{OxmId: parent}
18237 return _oxmidipv6srcmasked, nil
18238}
18239
18240func NewOxmIdIpv6SrcMasked() *OxmIdIpv6SrcMasked {
18241 obj := &OxmIdIpv6SrcMasked{
18242 OxmId: NewOxmId(75552),
18243 }
18244 return obj
18245}
18246func (self *OxmIdIpv6SrcMasked) GetOXMName() string {
18247 return "ipv6_src_masked"
18248}
18249
18250func (self *OxmIdIpv6SrcMasked) MarshalJSON() ([]byte, error) {
18251 if self.TypeLen == 0 {
18252 return []byte("\"\""), nil
18253 } else {
18254 return []byte("\"" + self.GetOXMName() + "\""), nil
18255 }
18256}
18257
18258type OxmIdMplsTtl struct {
18259 *OxmId
18260}
18261
18262type IOxmIdMplsTtl interface {
18263 IOxmId
18264}
18265
18266func (self *OxmIdMplsTtl) Serialize(encoder *goloxi.Encoder) error {
18267 if err := self.OxmId.Serialize(encoder); err != nil {
18268 return err
18269 }
18270
18271 return nil
18272}
18273
18274func DecodeOxmIdMplsTtl(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsTtl, error) {
18275 _oxmidmplsttl := &OxmIdMplsTtl{OxmId: parent}
18276 return _oxmidmplsttl, nil
18277}
18278
18279func NewOxmIdMplsTtl() *OxmIdMplsTtl {
18280 obj := &OxmIdMplsTtl{
18281 OxmId: NewOxmId(80897),
18282 }
18283 return obj
18284}
18285func (self *OxmIdMplsTtl) GetOXMName() string {
18286 return "mpls_ttl"
18287}
18288
18289func (self *OxmIdMplsTtl) MarshalJSON() ([]byte, error) {
18290 if self.TypeLen == 0 {
18291 return []byte("\"\""), nil
18292 } else {
18293 return []byte("\"" + self.GetOXMName() + "\""), nil
18294 }
18295}
18296
18297type OxmIdNdSll struct {
18298 *OxmId
18299}
18300
18301type IOxmIdNdSll interface {
18302 IOxmId
18303}
18304
18305func (self *OxmIdNdSll) Serialize(encoder *goloxi.Encoder) error {
18306 if err := self.OxmId.Serialize(encoder); err != nil {
18307 return err
18308 }
18309
18310 return nil
18311}
18312
18313func DecodeOxmIdNdSll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdSll, error) {
18314 _oxmidndsll := &OxmIdNdSll{OxmId: parent}
18315 return _oxmidndsll, nil
18316}
18317
18318func NewOxmIdNdSll() *OxmIdNdSll {
18319 obj := &OxmIdNdSll{
18320 OxmId: NewOxmId(77830),
18321 }
18322 return obj
18323}
18324func (self *OxmIdNdSll) GetOXMName() string {
18325 return "nd_sll"
18326}
18327
18328func (self *OxmIdNdSll) MarshalJSON() ([]byte, error) {
18329 if self.TypeLen == 0 {
18330 return []byte("\"\""), nil
18331 } else {
18332 return []byte("\"" + self.GetOXMName() + "\""), nil
18333 }
18334}
18335
18336type OxmIdNdSllMasked struct {
18337 *OxmId
18338}
18339
18340type IOxmIdNdSllMasked interface {
18341 IOxmId
18342}
18343
18344func (self *OxmIdNdSllMasked) Serialize(encoder *goloxi.Encoder) error {
18345 if err := self.OxmId.Serialize(encoder); err != nil {
18346 return err
18347 }
18348
18349 return nil
18350}
18351
18352func DecodeOxmIdNdSllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdSllMasked, error) {
18353 _oxmidndsllmasked := &OxmIdNdSllMasked{OxmId: parent}
18354 return _oxmidndsllmasked, nil
18355}
18356
18357func NewOxmIdNdSllMasked() *OxmIdNdSllMasked {
18358 obj := &OxmIdNdSllMasked{
18359 OxmId: NewOxmId(78091),
18360 }
18361 return obj
18362}
18363func (self *OxmIdNdSllMasked) GetOXMName() string {
18364 return "nd_sll_masked"
18365}
18366
18367func (self *OxmIdNdSllMasked) MarshalJSON() ([]byte, error) {
18368 if self.TypeLen == 0 {
18369 return []byte("\"\""), nil
18370 } else {
18371 return []byte("\"" + self.GetOXMName() + "\""), nil
18372 }
18373}
18374
18375type OxmIdNdTarget struct {
18376 *OxmId
18377}
18378
18379type IOxmIdNdTarget interface {
18380 IOxmId
18381}
18382
18383func (self *OxmIdNdTarget) Serialize(encoder *goloxi.Encoder) error {
18384 if err := self.OxmId.Serialize(encoder); err != nil {
18385 return err
18386 }
18387
18388 return nil
18389}
18390
18391func DecodeOxmIdNdTarget(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTarget, error) {
18392 _oxmidndtarget := &OxmIdNdTarget{OxmId: parent}
18393 return _oxmidndtarget, nil
18394}
18395
18396func NewOxmIdNdTarget() *OxmIdNdTarget {
18397 obj := &OxmIdNdTarget{
18398 OxmId: NewOxmId(77328),
18399 }
18400 return obj
18401}
18402func (self *OxmIdNdTarget) GetOXMName() string {
18403 return "nd_target"
18404}
18405
18406func (self *OxmIdNdTarget) MarshalJSON() ([]byte, error) {
18407 if self.TypeLen == 0 {
18408 return []byte("\"\""), nil
18409 } else {
18410 return []byte("\"" + self.GetOXMName() + "\""), nil
18411 }
18412}
18413
18414type OxmIdNdTargetMasked struct {
18415 *OxmId
18416}
18417
18418type IOxmIdNdTargetMasked interface {
18419 IOxmId
18420}
18421
18422func (self *OxmIdNdTargetMasked) Serialize(encoder *goloxi.Encoder) error {
18423 if err := self.OxmId.Serialize(encoder); err != nil {
18424 return err
18425 }
18426
18427 return nil
18428}
18429
18430func DecodeOxmIdNdTargetMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTargetMasked, error) {
18431 _oxmidndtargetmasked := &OxmIdNdTargetMasked{OxmId: parent}
18432 return _oxmidndtargetmasked, nil
18433}
18434
18435func NewOxmIdNdTargetMasked() *OxmIdNdTargetMasked {
18436 obj := &OxmIdNdTargetMasked{
18437 OxmId: NewOxmId(77600),
18438 }
18439 return obj
18440}
18441func (self *OxmIdNdTargetMasked) GetOXMName() string {
18442 return "nd_target_masked"
18443}
18444
18445func (self *OxmIdNdTargetMasked) MarshalJSON() ([]byte, error) {
18446 if self.TypeLen == 0 {
18447 return []byte("\"\""), nil
18448 } else {
18449 return []byte("\"" + self.GetOXMName() + "\""), nil
18450 }
18451}
18452
18453type OxmIdNdTll struct {
18454 *OxmId
18455}
18456
18457type IOxmIdNdTll interface {
18458 IOxmId
18459}
18460
18461func (self *OxmIdNdTll) Serialize(encoder *goloxi.Encoder) error {
18462 if err := self.OxmId.Serialize(encoder); err != nil {
18463 return err
18464 }
18465
18466 return nil
18467}
18468
18469func DecodeOxmIdNdTll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTll, error) {
18470 _oxmidndtll := &OxmIdNdTll{OxmId: parent}
18471 return _oxmidndtll, nil
18472}
18473
18474func NewOxmIdNdTll() *OxmIdNdTll {
18475 obj := &OxmIdNdTll{
18476 OxmId: NewOxmId(78342),
18477 }
18478 return obj
18479}
18480func (self *OxmIdNdTll) GetOXMName() string {
18481 return "nd_tll"
18482}
18483
18484func (self *OxmIdNdTll) MarshalJSON() ([]byte, error) {
18485 if self.TypeLen == 0 {
18486 return []byte("\"\""), nil
18487 } else {
18488 return []byte("\"" + self.GetOXMName() + "\""), nil
18489 }
18490}
18491
18492type OxmIdNdTllMasked struct {
18493 *OxmId
18494}
18495
18496type IOxmIdNdTllMasked interface {
18497 IOxmId
18498}
18499
18500func (self *OxmIdNdTllMasked) Serialize(encoder *goloxi.Encoder) error {
18501 if err := self.OxmId.Serialize(encoder); err != nil {
18502 return err
18503 }
18504
18505 return nil
18506}
18507
18508func DecodeOxmIdNdTllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTllMasked, error) {
18509 _oxmidndtllmasked := &OxmIdNdTllMasked{OxmId: parent}
18510 return _oxmidndtllmasked, nil
18511}
18512
18513func NewOxmIdNdTllMasked() *OxmIdNdTllMasked {
18514 obj := &OxmIdNdTllMasked{
18515 OxmId: NewOxmId(78603),
18516 }
18517 return obj
18518}
18519func (self *OxmIdNdTllMasked) GetOXMName() string {
18520 return "nd_tll_masked"
18521}
18522
18523func (self *OxmIdNdTllMasked) MarshalJSON() ([]byte, error) {
18524 if self.TypeLen == 0 {
18525 return []byte("\"\""), nil
18526 } else {
18527 return []byte("\"" + self.GetOXMName() + "\""), nil
18528 }
18529}
18530
18531type OxmIdNwEcn struct {
18532 *OxmId
18533}
18534
18535type IOxmIdNwEcn interface {
18536 IOxmId
18537}
18538
18539func (self *OxmIdNwEcn) Serialize(encoder *goloxi.Encoder) error {
18540 if err := self.OxmId.Serialize(encoder); err != nil {
18541 return err
18542 }
18543
18544 return nil
18545}
18546
18547func DecodeOxmIdNwEcn(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwEcn, error) {
18548 _oxmidnwecn := &OxmIdNwEcn{OxmId: parent}
18549 return _oxmidnwecn, nil
18550}
18551
18552func NewOxmIdNwEcn() *OxmIdNwEcn {
18553 obj := &OxmIdNwEcn{
18554 OxmId: NewOxmId(79873),
18555 }
18556 return obj
18557}
18558func (self *OxmIdNwEcn) GetOXMName() string {
18559 return "nw_ecn"
18560}
18561
18562func (self *OxmIdNwEcn) MarshalJSON() ([]byte, error) {
18563 if self.TypeLen == 0 {
18564 return []byte("\"\""), nil
18565 } else {
18566 return []byte("\"" + self.GetOXMName() + "\""), nil
18567 }
18568}
18569
18570type OxmIdNwProto struct {
18571 *OxmId
18572}
18573
18574type IOxmIdNwProto interface {
18575 IOxmId
18576}
18577
18578func (self *OxmIdNwProto) Serialize(encoder *goloxi.Encoder) error {
18579 if err := self.OxmId.Serialize(encoder); err != nil {
18580 return err
18581 }
18582
18583 return nil
18584}
18585
18586func DecodeOxmIdNwProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwProto, error) {
18587 _oxmidnwproto := &OxmIdNwProto{OxmId: parent}
18588 return _oxmidnwproto, nil
18589}
18590
18591func NewOxmIdNwProto() *OxmIdNwProto {
18592 obj := &OxmIdNwProto{
18593 OxmId: NewOxmId(3073),
18594 }
18595 return obj
18596}
18597func (self *OxmIdNwProto) GetOXMName() string {
18598 return "nw_proto"
18599}
18600
18601func (self *OxmIdNwProto) MarshalJSON() ([]byte, error) {
18602 if self.TypeLen == 0 {
18603 return []byte("\"\""), nil
18604 } else {
18605 return []byte("\"" + self.GetOXMName() + "\""), nil
18606 }
18607}
18608
18609type OxmIdNwTos struct {
18610 *OxmId
18611}
18612
18613type IOxmIdNwTos interface {
18614 IOxmId
18615}
18616
18617func (self *OxmIdNwTos) Serialize(encoder *goloxi.Encoder) error {
18618 if err := self.OxmId.Serialize(encoder); err != nil {
18619 return err
18620 }
18621
18622 return nil
18623}
18624
18625func DecodeOxmIdNwTos(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwTos, error) {
18626 _oxmidnwtos := &OxmIdNwTos{OxmId: parent}
18627 return _oxmidnwtos, nil
18628}
18629
18630func NewOxmIdNwTos() *OxmIdNwTos {
18631 obj := &OxmIdNwTos{
18632 OxmId: NewOxmId(2561),
18633 }
18634 return obj
18635}
18636func (self *OxmIdNwTos) GetOXMName() string {
18637 return "nw_tos"
18638}
18639
18640func (self *OxmIdNwTos) MarshalJSON() ([]byte, error) {
18641 if self.TypeLen == 0 {
18642 return []byte("\"\""), nil
18643 } else {
18644 return []byte("\"" + self.GetOXMName() + "\""), nil
18645 }
18646}
18647
18648type OxmIdNwTtl struct {
18649 *OxmId
18650}
18651
18652type IOxmIdNwTtl interface {
18653 IOxmId
18654}
18655
18656func (self *OxmIdNwTtl) Serialize(encoder *goloxi.Encoder) error {
18657 if err := self.OxmId.Serialize(encoder); err != nil {
18658 return err
18659 }
18660
18661 return nil
18662}
18663
18664func DecodeOxmIdNwTtl(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwTtl, error) {
18665 _oxmidnwttl := &OxmIdNwTtl{OxmId: parent}
18666 return _oxmidnwttl, nil
18667}
18668
18669func NewOxmIdNwTtl() *OxmIdNwTtl {
18670 obj := &OxmIdNwTtl{
18671 OxmId: NewOxmId(80385),
18672 }
18673 return obj
18674}
18675func (self *OxmIdNwTtl) GetOXMName() string {
18676 return "nw_ttl"
18677}
18678
18679func (self *OxmIdNwTtl) MarshalJSON() ([]byte, error) {
18680 if self.TypeLen == 0 {
18681 return []byte("\"\""), nil
18682 } else {
18683 return []byte("\"" + self.GetOXMName() + "\""), nil
18684 }
18685}
18686
18687type OxmIdPktMark struct {
18688 *OxmId
18689}
18690
18691type IOxmIdPktMark interface {
18692 IOxmId
18693}
18694
18695func (self *OxmIdPktMark) Serialize(encoder *goloxi.Encoder) error {
18696 if err := self.OxmId.Serialize(encoder); err != nil {
18697 return err
18698 }
18699
18700 return nil
18701}
18702
18703func DecodeOxmIdPktMark(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdPktMark, error) {
18704 _oxmidpktmark := &OxmIdPktMark{OxmId: parent}
18705 return _oxmidpktmark, nil
18706}
18707
18708func NewOxmIdPktMark() *OxmIdPktMark {
18709 obj := &OxmIdPktMark{
18710 OxmId: NewOxmId(82436),
18711 }
18712 return obj
18713}
18714func (self *OxmIdPktMark) GetOXMName() string {
18715 return "pkt_mark"
18716}
18717
18718func (self *OxmIdPktMark) MarshalJSON() ([]byte, error) {
18719 if self.TypeLen == 0 {
18720 return []byte("\"\""), nil
18721 } else {
18722 return []byte("\"" + self.GetOXMName() + "\""), nil
18723 }
18724}
18725
18726type OxmIdPktMarkMasked struct {
18727 *OxmId
18728}
18729
18730type IOxmIdPktMarkMasked interface {
18731 IOxmId
18732}
18733
18734func (self *OxmIdPktMarkMasked) Serialize(encoder *goloxi.Encoder) error {
18735 if err := self.OxmId.Serialize(encoder); err != nil {
18736 return err
18737 }
18738
18739 return nil
18740}
18741
18742func DecodeOxmIdPktMarkMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdPktMarkMasked, error) {
18743 _oxmidpktmarkmasked := &OxmIdPktMarkMasked{OxmId: parent}
18744 return _oxmidpktmarkmasked, nil
18745}
18746
18747func NewOxmIdPktMarkMasked() *OxmIdPktMarkMasked {
18748 obj := &OxmIdPktMarkMasked{
18749 OxmId: NewOxmId(82696),
18750 }
18751 return obj
18752}
18753func (self *OxmIdPktMarkMasked) GetOXMName() string {
18754 return "pkt_mark_masked"
18755}
18756
18757func (self *OxmIdPktMarkMasked) MarshalJSON() ([]byte, error) {
18758 if self.TypeLen == 0 {
18759 return []byte("\"\""), nil
18760 } else {
18761 return []byte("\"" + self.GetOXMName() + "\""), nil
18762 }
18763}
18764
18765type OxmIdRecircId struct {
18766 *OxmId
18767}
18768
18769type IOxmIdRecircId interface {
18770 IOxmId
18771}
18772
18773func (self *OxmIdRecircId) Serialize(encoder *goloxi.Encoder) error {
18774 if err := self.OxmId.Serialize(encoder); err != nil {
18775 return err
18776 }
18777
18778 return nil
18779}
18780
18781func DecodeOxmIdRecircId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdRecircId, error) {
18782 _oxmidrecircid := &OxmIdRecircId{OxmId: parent}
18783 return _oxmidrecircid, nil
18784}
18785
18786func NewOxmIdRecircId() *OxmIdRecircId {
18787 obj := &OxmIdRecircId{
18788 OxmId: NewOxmId(83972),
18789 }
18790 return obj
18791}
18792func (self *OxmIdRecircId) GetOXMName() string {
18793 return "recirc_id"
18794}
18795
18796func (self *OxmIdRecircId) MarshalJSON() ([]byte, error) {
18797 if self.TypeLen == 0 {
18798 return []byte("\"\""), nil
18799 } else {
18800 return []byte("\"" + self.GetOXMName() + "\""), nil
18801 }
18802}
18803
18804type OxmIdReg0 struct {
18805 *OxmId
18806}
18807
18808type IOxmIdReg0 interface {
18809 IOxmId
18810}
18811
18812func (self *OxmIdReg0) Serialize(encoder *goloxi.Encoder) error {
18813 if err := self.OxmId.Serialize(encoder); err != nil {
18814 return err
18815 }
18816
18817 return nil
18818}
18819
18820func DecodeOxmIdReg0(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg0, error) {
18821 _oxmidreg0 := &OxmIdReg0{OxmId: parent}
18822 return _oxmidreg0, nil
18823}
18824
18825func NewOxmIdReg0() *OxmIdReg0 {
18826 obj := &OxmIdReg0{
18827 OxmId: NewOxmId(65540),
18828 }
18829 return obj
18830}
18831func (self *OxmIdReg0) GetOXMName() string {
18832 return "reg0"
18833}
18834
18835func (self *OxmIdReg0) MarshalJSON() ([]byte, error) {
18836 if self.TypeLen == 0 {
18837 return []byte("\"\""), nil
18838 } else {
18839 return []byte("\"" + self.GetOXMName() + "\""), nil
18840 }
18841}
18842
18843type OxmIdReg0Masked struct {
18844 *OxmId
18845}
18846
18847type IOxmIdReg0Masked interface {
18848 IOxmId
18849}
18850
18851func (self *OxmIdReg0Masked) Serialize(encoder *goloxi.Encoder) error {
18852 if err := self.OxmId.Serialize(encoder); err != nil {
18853 return err
18854 }
18855
18856 return nil
18857}
18858
18859func DecodeOxmIdReg0Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg0Masked, error) {
18860 _oxmidreg0masked := &OxmIdReg0Masked{OxmId: parent}
18861 return _oxmidreg0masked, nil
18862}
18863
18864func NewOxmIdReg0Masked() *OxmIdReg0Masked {
18865 obj := &OxmIdReg0Masked{
18866 OxmId: NewOxmId(65800),
18867 }
18868 return obj
18869}
18870func (self *OxmIdReg0Masked) GetOXMName() string {
18871 return "reg0_masked"
18872}
18873
18874func (self *OxmIdReg0Masked) MarshalJSON() ([]byte, error) {
18875 if self.TypeLen == 0 {
18876 return []byte("\"\""), nil
18877 } else {
18878 return []byte("\"" + self.GetOXMName() + "\""), nil
18879 }
18880}
18881
18882type OxmIdReg1 struct {
18883 *OxmId
18884}
18885
18886type IOxmIdReg1 interface {
18887 IOxmId
18888}
18889
18890func (self *OxmIdReg1) Serialize(encoder *goloxi.Encoder) error {
18891 if err := self.OxmId.Serialize(encoder); err != nil {
18892 return err
18893 }
18894
18895 return nil
18896}
18897
18898func DecodeOxmIdReg1(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg1, error) {
18899 _oxmidreg1 := &OxmIdReg1{OxmId: parent}
18900 return _oxmidreg1, nil
18901}
18902
18903func NewOxmIdReg1() *OxmIdReg1 {
18904 obj := &OxmIdReg1{
18905 OxmId: NewOxmId(66052),
18906 }
18907 return obj
18908}
18909func (self *OxmIdReg1) GetOXMName() string {
18910 return "reg1"
18911}
18912
18913func (self *OxmIdReg1) MarshalJSON() ([]byte, error) {
18914 if self.TypeLen == 0 {
18915 return []byte("\"\""), nil
18916 } else {
18917 return []byte("\"" + self.GetOXMName() + "\""), nil
18918 }
18919}
18920
18921type OxmIdReg10 struct {
18922 *OxmId
18923}
18924
18925type IOxmIdReg10 interface {
18926 IOxmId
18927}
18928
18929func (self *OxmIdReg10) Serialize(encoder *goloxi.Encoder) error {
18930 if err := self.OxmId.Serialize(encoder); err != nil {
18931 return err
18932 }
18933
18934 return nil
18935}
18936
18937func DecodeOxmIdReg10(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg10, error) {
18938 _oxmidreg10 := &OxmIdReg10{OxmId: parent}
18939 return _oxmidreg10, nil
18940}
18941
18942func NewOxmIdReg10() *OxmIdReg10 {
18943 obj := &OxmIdReg10{
18944 OxmId: NewOxmId(70660),
18945 }
18946 return obj
18947}
18948func (self *OxmIdReg10) GetOXMName() string {
18949 return "reg10"
18950}
18951
18952func (self *OxmIdReg10) MarshalJSON() ([]byte, error) {
18953 if self.TypeLen == 0 {
18954 return []byte("\"\""), nil
18955 } else {
18956 return []byte("\"" + self.GetOXMName() + "\""), nil
18957 }
18958}
18959
18960type OxmIdReg10Masked struct {
18961 *OxmId
18962}
18963
18964type IOxmIdReg10Masked interface {
18965 IOxmId
18966}
18967
18968func (self *OxmIdReg10Masked) Serialize(encoder *goloxi.Encoder) error {
18969 if err := self.OxmId.Serialize(encoder); err != nil {
18970 return err
18971 }
18972
18973 return nil
18974}
18975
18976func DecodeOxmIdReg10Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg10Masked, error) {
18977 _oxmidreg10masked := &OxmIdReg10Masked{OxmId: parent}
18978 return _oxmidreg10masked, nil
18979}
18980
18981func NewOxmIdReg10Masked() *OxmIdReg10Masked {
18982 obj := &OxmIdReg10Masked{
18983 OxmId: NewOxmId(70920),
18984 }
18985 return obj
18986}
18987func (self *OxmIdReg10Masked) GetOXMName() string {
18988 return "reg10_masked"
18989}
18990
18991func (self *OxmIdReg10Masked) MarshalJSON() ([]byte, error) {
18992 if self.TypeLen == 0 {
18993 return []byte("\"\""), nil
18994 } else {
18995 return []byte("\"" + self.GetOXMName() + "\""), nil
18996 }
18997}
18998
18999type OxmIdReg11 struct {
19000 *OxmId
19001}
19002
19003type IOxmIdReg11 interface {
19004 IOxmId
19005}
19006
19007func (self *OxmIdReg11) Serialize(encoder *goloxi.Encoder) error {
19008 if err := self.OxmId.Serialize(encoder); err != nil {
19009 return err
19010 }
19011
19012 return nil
19013}
19014
19015func DecodeOxmIdReg11(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg11, error) {
19016 _oxmidreg11 := &OxmIdReg11{OxmId: parent}
19017 return _oxmidreg11, nil
19018}
19019
19020func NewOxmIdReg11() *OxmIdReg11 {
19021 obj := &OxmIdReg11{
19022 OxmId: NewOxmId(71172),
19023 }
19024 return obj
19025}
19026func (self *OxmIdReg11) GetOXMName() string {
19027 return "reg11"
19028}
19029
19030func (self *OxmIdReg11) MarshalJSON() ([]byte, error) {
19031 if self.TypeLen == 0 {
19032 return []byte("\"\""), nil
19033 } else {
19034 return []byte("\"" + self.GetOXMName() + "\""), nil
19035 }
19036}
19037
19038type OxmIdReg11Masked struct {
19039 *OxmId
19040}
19041
19042type IOxmIdReg11Masked interface {
19043 IOxmId
19044}
19045
19046func (self *OxmIdReg11Masked) Serialize(encoder *goloxi.Encoder) error {
19047 if err := self.OxmId.Serialize(encoder); err != nil {
19048 return err
19049 }
19050
19051 return nil
19052}
19053
19054func DecodeOxmIdReg11Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg11Masked, error) {
19055 _oxmidreg11masked := &OxmIdReg11Masked{OxmId: parent}
19056 return _oxmidreg11masked, nil
19057}
19058
19059func NewOxmIdReg11Masked() *OxmIdReg11Masked {
19060 obj := &OxmIdReg11Masked{
19061 OxmId: NewOxmId(71432),
19062 }
19063 return obj
19064}
19065func (self *OxmIdReg11Masked) GetOXMName() string {
19066 return "reg11_masked"
19067}
19068
19069func (self *OxmIdReg11Masked) MarshalJSON() ([]byte, error) {
19070 if self.TypeLen == 0 {
19071 return []byte("\"\""), nil
19072 } else {
19073 return []byte("\"" + self.GetOXMName() + "\""), nil
19074 }
19075}
19076
19077type OxmIdReg12 struct {
19078 *OxmId
19079}
19080
19081type IOxmIdReg12 interface {
19082 IOxmId
19083}
19084
19085func (self *OxmIdReg12) Serialize(encoder *goloxi.Encoder) error {
19086 if err := self.OxmId.Serialize(encoder); err != nil {
19087 return err
19088 }
19089
19090 return nil
19091}
19092
19093func DecodeOxmIdReg12(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg12, error) {
19094 _oxmidreg12 := &OxmIdReg12{OxmId: parent}
19095 return _oxmidreg12, nil
19096}
19097
19098func NewOxmIdReg12() *OxmIdReg12 {
19099 obj := &OxmIdReg12{
19100 OxmId: NewOxmId(71684),
19101 }
19102 return obj
19103}
19104func (self *OxmIdReg12) GetOXMName() string {
19105 return "reg12"
19106}
19107
19108func (self *OxmIdReg12) MarshalJSON() ([]byte, error) {
19109 if self.TypeLen == 0 {
19110 return []byte("\"\""), nil
19111 } else {
19112 return []byte("\"" + self.GetOXMName() + "\""), nil
19113 }
19114}
19115
19116type OxmIdReg12Masked struct {
19117 *OxmId
19118}
19119
19120type IOxmIdReg12Masked interface {
19121 IOxmId
19122}
19123
19124func (self *OxmIdReg12Masked) Serialize(encoder *goloxi.Encoder) error {
19125 if err := self.OxmId.Serialize(encoder); err != nil {
19126 return err
19127 }
19128
19129 return nil
19130}
19131
19132func DecodeOxmIdReg12Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg12Masked, error) {
19133 _oxmidreg12masked := &OxmIdReg12Masked{OxmId: parent}
19134 return _oxmidreg12masked, nil
19135}
19136
19137func NewOxmIdReg12Masked() *OxmIdReg12Masked {
19138 obj := &OxmIdReg12Masked{
19139 OxmId: NewOxmId(71944),
19140 }
19141 return obj
19142}
19143func (self *OxmIdReg12Masked) GetOXMName() string {
19144 return "reg12_masked"
19145}
19146
19147func (self *OxmIdReg12Masked) MarshalJSON() ([]byte, error) {
19148 if self.TypeLen == 0 {
19149 return []byte("\"\""), nil
19150 } else {
19151 return []byte("\"" + self.GetOXMName() + "\""), nil
19152 }
19153}
19154
19155type OxmIdReg13 struct {
19156 *OxmId
19157}
19158
19159type IOxmIdReg13 interface {
19160 IOxmId
19161}
19162
19163func (self *OxmIdReg13) Serialize(encoder *goloxi.Encoder) error {
19164 if err := self.OxmId.Serialize(encoder); err != nil {
19165 return err
19166 }
19167
19168 return nil
19169}
19170
19171func DecodeOxmIdReg13(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg13, error) {
19172 _oxmidreg13 := &OxmIdReg13{OxmId: parent}
19173 return _oxmidreg13, nil
19174}
19175
19176func NewOxmIdReg13() *OxmIdReg13 {
19177 obj := &OxmIdReg13{
19178 OxmId: NewOxmId(72196),
19179 }
19180 return obj
19181}
19182func (self *OxmIdReg13) GetOXMName() string {
19183 return "reg13"
19184}
19185
19186func (self *OxmIdReg13) MarshalJSON() ([]byte, error) {
19187 if self.TypeLen == 0 {
19188 return []byte("\"\""), nil
19189 } else {
19190 return []byte("\"" + self.GetOXMName() + "\""), nil
19191 }
19192}
19193
19194type OxmIdReg13Masked struct {
19195 *OxmId
19196}
19197
19198type IOxmIdReg13Masked interface {
19199 IOxmId
19200}
19201
19202func (self *OxmIdReg13Masked) Serialize(encoder *goloxi.Encoder) error {
19203 if err := self.OxmId.Serialize(encoder); err != nil {
19204 return err
19205 }
19206
19207 return nil
19208}
19209
19210func DecodeOxmIdReg13Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg13Masked, error) {
19211 _oxmidreg13masked := &OxmIdReg13Masked{OxmId: parent}
19212 return _oxmidreg13masked, nil
19213}
19214
19215func NewOxmIdReg13Masked() *OxmIdReg13Masked {
19216 obj := &OxmIdReg13Masked{
19217 OxmId: NewOxmId(72456),
19218 }
19219 return obj
19220}
19221func (self *OxmIdReg13Masked) GetOXMName() string {
19222 return "reg13_masked"
19223}
19224
19225func (self *OxmIdReg13Masked) MarshalJSON() ([]byte, error) {
19226 if self.TypeLen == 0 {
19227 return []byte("\"\""), nil
19228 } else {
19229 return []byte("\"" + self.GetOXMName() + "\""), nil
19230 }
19231}
19232
19233type OxmIdReg14 struct {
19234 *OxmId
19235}
19236
19237type IOxmIdReg14 interface {
19238 IOxmId
19239}
19240
19241func (self *OxmIdReg14) Serialize(encoder *goloxi.Encoder) error {
19242 if err := self.OxmId.Serialize(encoder); err != nil {
19243 return err
19244 }
19245
19246 return nil
19247}
19248
19249func DecodeOxmIdReg14(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg14, error) {
19250 _oxmidreg14 := &OxmIdReg14{OxmId: parent}
19251 return _oxmidreg14, nil
19252}
19253
19254func NewOxmIdReg14() *OxmIdReg14 {
19255 obj := &OxmIdReg14{
19256 OxmId: NewOxmId(72708),
19257 }
19258 return obj
19259}
19260func (self *OxmIdReg14) GetOXMName() string {
19261 return "reg14"
19262}
19263
19264func (self *OxmIdReg14) MarshalJSON() ([]byte, error) {
19265 if self.TypeLen == 0 {
19266 return []byte("\"\""), nil
19267 } else {
19268 return []byte("\"" + self.GetOXMName() + "\""), nil
19269 }
19270}
19271
19272type OxmIdReg14Masked struct {
19273 *OxmId
19274}
19275
19276type IOxmIdReg14Masked interface {
19277 IOxmId
19278}
19279
19280func (self *OxmIdReg14Masked) Serialize(encoder *goloxi.Encoder) error {
19281 if err := self.OxmId.Serialize(encoder); err != nil {
19282 return err
19283 }
19284
19285 return nil
19286}
19287
19288func DecodeOxmIdReg14Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg14Masked, error) {
19289 _oxmidreg14masked := &OxmIdReg14Masked{OxmId: parent}
19290 return _oxmidreg14masked, nil
19291}
19292
19293func NewOxmIdReg14Masked() *OxmIdReg14Masked {
19294 obj := &OxmIdReg14Masked{
19295 OxmId: NewOxmId(72968),
19296 }
19297 return obj
19298}
19299func (self *OxmIdReg14Masked) GetOXMName() string {
19300 return "reg14_masked"
19301}
19302
19303func (self *OxmIdReg14Masked) MarshalJSON() ([]byte, error) {
19304 if self.TypeLen == 0 {
19305 return []byte("\"\""), nil
19306 } else {
19307 return []byte("\"" + self.GetOXMName() + "\""), nil
19308 }
19309}
19310
19311type OxmIdReg15 struct {
19312 *OxmId
19313}
19314
19315type IOxmIdReg15 interface {
19316 IOxmId
19317}
19318
19319func (self *OxmIdReg15) Serialize(encoder *goloxi.Encoder) error {
19320 if err := self.OxmId.Serialize(encoder); err != nil {
19321 return err
19322 }
19323
19324 return nil
19325}
19326
19327func DecodeOxmIdReg15(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg15, error) {
19328 _oxmidreg15 := &OxmIdReg15{OxmId: parent}
19329 return _oxmidreg15, nil
19330}
19331
19332func NewOxmIdReg15() *OxmIdReg15 {
19333 obj := &OxmIdReg15{
19334 OxmId: NewOxmId(73220),
19335 }
19336 return obj
19337}
19338func (self *OxmIdReg15) GetOXMName() string {
19339 return "reg15"
19340}
19341
19342func (self *OxmIdReg15) MarshalJSON() ([]byte, error) {
19343 if self.TypeLen == 0 {
19344 return []byte("\"\""), nil
19345 } else {
19346 return []byte("\"" + self.GetOXMName() + "\""), nil
19347 }
19348}
19349
19350type OxmIdReg15Masked struct {
19351 *OxmId
19352}
19353
19354type IOxmIdReg15Masked interface {
19355 IOxmId
19356}
19357
19358func (self *OxmIdReg15Masked) Serialize(encoder *goloxi.Encoder) error {
19359 if err := self.OxmId.Serialize(encoder); err != nil {
19360 return err
19361 }
19362
19363 return nil
19364}
19365
19366func DecodeOxmIdReg15Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg15Masked, error) {
19367 _oxmidreg15masked := &OxmIdReg15Masked{OxmId: parent}
19368 return _oxmidreg15masked, nil
19369}
19370
19371func NewOxmIdReg15Masked() *OxmIdReg15Masked {
19372 obj := &OxmIdReg15Masked{
19373 OxmId: NewOxmId(73480),
19374 }
19375 return obj
19376}
19377func (self *OxmIdReg15Masked) GetOXMName() string {
19378 return "reg15_masked"
19379}
19380
19381func (self *OxmIdReg15Masked) MarshalJSON() ([]byte, error) {
19382 if self.TypeLen == 0 {
19383 return []byte("\"\""), nil
19384 } else {
19385 return []byte("\"" + self.GetOXMName() + "\""), nil
19386 }
19387}
19388
19389type OxmIdReg1Masked struct {
19390 *OxmId
19391}
19392
19393type IOxmIdReg1Masked interface {
19394 IOxmId
19395}
19396
19397func (self *OxmIdReg1Masked) Serialize(encoder *goloxi.Encoder) error {
19398 if err := self.OxmId.Serialize(encoder); err != nil {
19399 return err
19400 }
19401
19402 return nil
19403}
19404
19405func DecodeOxmIdReg1Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg1Masked, error) {
19406 _oxmidreg1masked := &OxmIdReg1Masked{OxmId: parent}
19407 return _oxmidreg1masked, nil
19408}
19409
19410func NewOxmIdReg1Masked() *OxmIdReg1Masked {
19411 obj := &OxmIdReg1Masked{
19412 OxmId: NewOxmId(66312),
19413 }
19414 return obj
19415}
19416func (self *OxmIdReg1Masked) GetOXMName() string {
19417 return "reg1_masked"
19418}
19419
19420func (self *OxmIdReg1Masked) MarshalJSON() ([]byte, error) {
19421 if self.TypeLen == 0 {
19422 return []byte("\"\""), nil
19423 } else {
19424 return []byte("\"" + self.GetOXMName() + "\""), nil
19425 }
19426}
19427
19428type OxmIdReg2 struct {
19429 *OxmId
19430}
19431
19432type IOxmIdReg2 interface {
19433 IOxmId
19434}
19435
19436func (self *OxmIdReg2) Serialize(encoder *goloxi.Encoder) error {
19437 if err := self.OxmId.Serialize(encoder); err != nil {
19438 return err
19439 }
19440
19441 return nil
19442}
19443
19444func DecodeOxmIdReg2(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg2, error) {
19445 _oxmidreg2 := &OxmIdReg2{OxmId: parent}
19446 return _oxmidreg2, nil
19447}
19448
19449func NewOxmIdReg2() *OxmIdReg2 {
19450 obj := &OxmIdReg2{
19451 OxmId: NewOxmId(66564),
19452 }
19453 return obj
19454}
19455func (self *OxmIdReg2) GetOXMName() string {
19456 return "reg2"
19457}
19458
19459func (self *OxmIdReg2) MarshalJSON() ([]byte, error) {
19460 if self.TypeLen == 0 {
19461 return []byte("\"\""), nil
19462 } else {
19463 return []byte("\"" + self.GetOXMName() + "\""), nil
19464 }
19465}
19466
19467type OxmIdReg2Masked struct {
19468 *OxmId
19469}
19470
19471type IOxmIdReg2Masked interface {
19472 IOxmId
19473}
19474
19475func (self *OxmIdReg2Masked) Serialize(encoder *goloxi.Encoder) error {
19476 if err := self.OxmId.Serialize(encoder); err != nil {
19477 return err
19478 }
19479
19480 return nil
19481}
19482
19483func DecodeOxmIdReg2Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg2Masked, error) {
19484 _oxmidreg2masked := &OxmIdReg2Masked{OxmId: parent}
19485 return _oxmidreg2masked, nil
19486}
19487
19488func NewOxmIdReg2Masked() *OxmIdReg2Masked {
19489 obj := &OxmIdReg2Masked{
19490 OxmId: NewOxmId(66824),
19491 }
19492 return obj
19493}
19494func (self *OxmIdReg2Masked) GetOXMName() string {
19495 return "reg2_masked"
19496}
19497
19498func (self *OxmIdReg2Masked) MarshalJSON() ([]byte, error) {
19499 if self.TypeLen == 0 {
19500 return []byte("\"\""), nil
19501 } else {
19502 return []byte("\"" + self.GetOXMName() + "\""), nil
19503 }
19504}
19505
19506type OxmIdReg3 struct {
19507 *OxmId
19508}
19509
19510type IOxmIdReg3 interface {
19511 IOxmId
19512}
19513
19514func (self *OxmIdReg3) Serialize(encoder *goloxi.Encoder) error {
19515 if err := self.OxmId.Serialize(encoder); err != nil {
19516 return err
19517 }
19518
19519 return nil
19520}
19521
19522func DecodeOxmIdReg3(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg3, error) {
19523 _oxmidreg3 := &OxmIdReg3{OxmId: parent}
19524 return _oxmidreg3, nil
19525}
19526
19527func NewOxmIdReg3() *OxmIdReg3 {
19528 obj := &OxmIdReg3{
19529 OxmId: NewOxmId(67076),
19530 }
19531 return obj
19532}
19533func (self *OxmIdReg3) GetOXMName() string {
19534 return "reg3"
19535}
19536
19537func (self *OxmIdReg3) MarshalJSON() ([]byte, error) {
19538 if self.TypeLen == 0 {
19539 return []byte("\"\""), nil
19540 } else {
19541 return []byte("\"" + self.GetOXMName() + "\""), nil
19542 }
19543}
19544
19545type OxmIdReg3Masked struct {
19546 *OxmId
19547}
19548
19549type IOxmIdReg3Masked interface {
19550 IOxmId
19551}
19552
19553func (self *OxmIdReg3Masked) Serialize(encoder *goloxi.Encoder) error {
19554 if err := self.OxmId.Serialize(encoder); err != nil {
19555 return err
19556 }
19557
19558 return nil
19559}
19560
19561func DecodeOxmIdReg3Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg3Masked, error) {
19562 _oxmidreg3masked := &OxmIdReg3Masked{OxmId: parent}
19563 return _oxmidreg3masked, nil
19564}
19565
19566func NewOxmIdReg3Masked() *OxmIdReg3Masked {
19567 obj := &OxmIdReg3Masked{
19568 OxmId: NewOxmId(67336),
19569 }
19570 return obj
19571}
19572func (self *OxmIdReg3Masked) GetOXMName() string {
19573 return "reg3_masked"
19574}
19575
19576func (self *OxmIdReg3Masked) MarshalJSON() ([]byte, error) {
19577 if self.TypeLen == 0 {
19578 return []byte("\"\""), nil
19579 } else {
19580 return []byte("\"" + self.GetOXMName() + "\""), nil
19581 }
19582}
19583
19584type OxmIdReg4 struct {
19585 *OxmId
19586}
19587
19588type IOxmIdReg4 interface {
19589 IOxmId
19590}
19591
19592func (self *OxmIdReg4) Serialize(encoder *goloxi.Encoder) error {
19593 if err := self.OxmId.Serialize(encoder); err != nil {
19594 return err
19595 }
19596
19597 return nil
19598}
19599
19600func DecodeOxmIdReg4(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg4, error) {
19601 _oxmidreg4 := &OxmIdReg4{OxmId: parent}
19602 return _oxmidreg4, nil
19603}
19604
19605func NewOxmIdReg4() *OxmIdReg4 {
19606 obj := &OxmIdReg4{
19607 OxmId: NewOxmId(67588),
19608 }
19609 return obj
19610}
19611func (self *OxmIdReg4) GetOXMName() string {
19612 return "reg4"
19613}
19614
19615func (self *OxmIdReg4) MarshalJSON() ([]byte, error) {
19616 if self.TypeLen == 0 {
19617 return []byte("\"\""), nil
19618 } else {
19619 return []byte("\"" + self.GetOXMName() + "\""), nil
19620 }
19621}
19622
19623type OxmIdReg4Masked struct {
19624 *OxmId
19625}
19626
19627type IOxmIdReg4Masked interface {
19628 IOxmId
19629}
19630
19631func (self *OxmIdReg4Masked) Serialize(encoder *goloxi.Encoder) error {
19632 if err := self.OxmId.Serialize(encoder); err != nil {
19633 return err
19634 }
19635
19636 return nil
19637}
19638
19639func DecodeOxmIdReg4Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg4Masked, error) {
19640 _oxmidreg4masked := &OxmIdReg4Masked{OxmId: parent}
19641 return _oxmidreg4masked, nil
19642}
19643
19644func NewOxmIdReg4Masked() *OxmIdReg4Masked {
19645 obj := &OxmIdReg4Masked{
19646 OxmId: NewOxmId(67848),
19647 }
19648 return obj
19649}
19650func (self *OxmIdReg4Masked) GetOXMName() string {
19651 return "reg4_masked"
19652}
19653
19654func (self *OxmIdReg4Masked) MarshalJSON() ([]byte, error) {
19655 if self.TypeLen == 0 {
19656 return []byte("\"\""), nil
19657 } else {
19658 return []byte("\"" + self.GetOXMName() + "\""), nil
19659 }
19660}
19661
19662type OxmIdReg5 struct {
19663 *OxmId
19664}
19665
19666type IOxmIdReg5 interface {
19667 IOxmId
19668}
19669
19670func (self *OxmIdReg5) Serialize(encoder *goloxi.Encoder) error {
19671 if err := self.OxmId.Serialize(encoder); err != nil {
19672 return err
19673 }
19674
19675 return nil
19676}
19677
19678func DecodeOxmIdReg5(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg5, error) {
19679 _oxmidreg5 := &OxmIdReg5{OxmId: parent}
19680 return _oxmidreg5, nil
19681}
19682
19683func NewOxmIdReg5() *OxmIdReg5 {
19684 obj := &OxmIdReg5{
19685 OxmId: NewOxmId(68100),
19686 }
19687 return obj
19688}
19689func (self *OxmIdReg5) GetOXMName() string {
19690 return "reg5"
19691}
19692
19693func (self *OxmIdReg5) MarshalJSON() ([]byte, error) {
19694 if self.TypeLen == 0 {
19695 return []byte("\"\""), nil
19696 } else {
19697 return []byte("\"" + self.GetOXMName() + "\""), nil
19698 }
19699}
19700
19701type OxmIdReg5Masked struct {
19702 *OxmId
19703}
19704
19705type IOxmIdReg5Masked interface {
19706 IOxmId
19707}
19708
19709func (self *OxmIdReg5Masked) Serialize(encoder *goloxi.Encoder) error {
19710 if err := self.OxmId.Serialize(encoder); err != nil {
19711 return err
19712 }
19713
19714 return nil
19715}
19716
19717func DecodeOxmIdReg5Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg5Masked, error) {
19718 _oxmidreg5masked := &OxmIdReg5Masked{OxmId: parent}
19719 return _oxmidreg5masked, nil
19720}
19721
19722func NewOxmIdReg5Masked() *OxmIdReg5Masked {
19723 obj := &OxmIdReg5Masked{
19724 OxmId: NewOxmId(68360),
19725 }
19726 return obj
19727}
19728func (self *OxmIdReg5Masked) GetOXMName() string {
19729 return "reg5_masked"
19730}
19731
19732func (self *OxmIdReg5Masked) MarshalJSON() ([]byte, error) {
19733 if self.TypeLen == 0 {
19734 return []byte("\"\""), nil
19735 } else {
19736 return []byte("\"" + self.GetOXMName() + "\""), nil
19737 }
19738}
19739
19740type OxmIdReg6 struct {
19741 *OxmId
19742}
19743
19744type IOxmIdReg6 interface {
19745 IOxmId
19746}
19747
19748func (self *OxmIdReg6) Serialize(encoder *goloxi.Encoder) error {
19749 if err := self.OxmId.Serialize(encoder); err != nil {
19750 return err
19751 }
19752
19753 return nil
19754}
19755
19756func DecodeOxmIdReg6(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg6, error) {
19757 _oxmidreg6 := &OxmIdReg6{OxmId: parent}
19758 return _oxmidreg6, nil
19759}
19760
19761func NewOxmIdReg6() *OxmIdReg6 {
19762 obj := &OxmIdReg6{
19763 OxmId: NewOxmId(68612),
19764 }
19765 return obj
19766}
19767func (self *OxmIdReg6) GetOXMName() string {
19768 return "reg6"
19769}
19770
19771func (self *OxmIdReg6) MarshalJSON() ([]byte, error) {
19772 if self.TypeLen == 0 {
19773 return []byte("\"\""), nil
19774 } else {
19775 return []byte("\"" + self.GetOXMName() + "\""), nil
19776 }
19777}
19778
19779type OxmIdReg6Masked struct {
19780 *OxmId
19781}
19782
19783type IOxmIdReg6Masked interface {
19784 IOxmId
19785}
19786
19787func (self *OxmIdReg6Masked) Serialize(encoder *goloxi.Encoder) error {
19788 if err := self.OxmId.Serialize(encoder); err != nil {
19789 return err
19790 }
19791
19792 return nil
19793}
19794
19795func DecodeOxmIdReg6Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg6Masked, error) {
19796 _oxmidreg6masked := &OxmIdReg6Masked{OxmId: parent}
19797 return _oxmidreg6masked, nil
19798}
19799
19800func NewOxmIdReg6Masked() *OxmIdReg6Masked {
19801 obj := &OxmIdReg6Masked{
19802 OxmId: NewOxmId(68872),
19803 }
19804 return obj
19805}
19806func (self *OxmIdReg6Masked) GetOXMName() string {
19807 return "reg6_masked"
19808}
19809
19810func (self *OxmIdReg6Masked) MarshalJSON() ([]byte, error) {
19811 if self.TypeLen == 0 {
19812 return []byte("\"\""), nil
19813 } else {
19814 return []byte("\"" + self.GetOXMName() + "\""), nil
19815 }
19816}
19817
19818type OxmIdReg7 struct {
19819 *OxmId
19820}
19821
19822type IOxmIdReg7 interface {
19823 IOxmId
19824}
19825
19826func (self *OxmIdReg7) Serialize(encoder *goloxi.Encoder) error {
19827 if err := self.OxmId.Serialize(encoder); err != nil {
19828 return err
19829 }
19830
19831 return nil
19832}
19833
19834func DecodeOxmIdReg7(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg7, error) {
19835 _oxmidreg7 := &OxmIdReg7{OxmId: parent}
19836 return _oxmidreg7, nil
19837}
19838
19839func NewOxmIdReg7() *OxmIdReg7 {
19840 obj := &OxmIdReg7{
19841 OxmId: NewOxmId(69124),
19842 }
19843 return obj
19844}
19845func (self *OxmIdReg7) GetOXMName() string {
19846 return "reg7"
19847}
19848
19849func (self *OxmIdReg7) MarshalJSON() ([]byte, error) {
19850 if self.TypeLen == 0 {
19851 return []byte("\"\""), nil
19852 } else {
19853 return []byte("\"" + self.GetOXMName() + "\""), nil
19854 }
19855}
19856
19857type OxmIdReg7Masked struct {
19858 *OxmId
19859}
19860
19861type IOxmIdReg7Masked interface {
19862 IOxmId
19863}
19864
19865func (self *OxmIdReg7Masked) Serialize(encoder *goloxi.Encoder) error {
19866 if err := self.OxmId.Serialize(encoder); err != nil {
19867 return err
19868 }
19869
19870 return nil
19871}
19872
19873func DecodeOxmIdReg7Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg7Masked, error) {
19874 _oxmidreg7masked := &OxmIdReg7Masked{OxmId: parent}
19875 return _oxmidreg7masked, nil
19876}
19877
19878func NewOxmIdReg7Masked() *OxmIdReg7Masked {
19879 obj := &OxmIdReg7Masked{
19880 OxmId: NewOxmId(69384),
19881 }
19882 return obj
19883}
19884func (self *OxmIdReg7Masked) GetOXMName() string {
19885 return "reg7_masked"
19886}
19887
19888func (self *OxmIdReg7Masked) MarshalJSON() ([]byte, error) {
19889 if self.TypeLen == 0 {
19890 return []byte("\"\""), nil
19891 } else {
19892 return []byte("\"" + self.GetOXMName() + "\""), nil
19893 }
19894}
19895
19896type OxmIdReg8 struct {
19897 *OxmId
19898}
19899
19900type IOxmIdReg8 interface {
19901 IOxmId
19902}
19903
19904func (self *OxmIdReg8) Serialize(encoder *goloxi.Encoder) error {
19905 if err := self.OxmId.Serialize(encoder); err != nil {
19906 return err
19907 }
19908
19909 return nil
19910}
19911
19912func DecodeOxmIdReg8(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg8, error) {
19913 _oxmidreg8 := &OxmIdReg8{OxmId: parent}
19914 return _oxmidreg8, nil
19915}
19916
19917func NewOxmIdReg8() *OxmIdReg8 {
19918 obj := &OxmIdReg8{
19919 OxmId: NewOxmId(69636),
19920 }
19921 return obj
19922}
19923func (self *OxmIdReg8) GetOXMName() string {
19924 return "reg8"
19925}
19926
19927func (self *OxmIdReg8) MarshalJSON() ([]byte, error) {
19928 if self.TypeLen == 0 {
19929 return []byte("\"\""), nil
19930 } else {
19931 return []byte("\"" + self.GetOXMName() + "\""), nil
19932 }
19933}
19934
19935type OxmIdReg8Masked struct {
19936 *OxmId
19937}
19938
19939type IOxmIdReg8Masked interface {
19940 IOxmId
19941}
19942
19943func (self *OxmIdReg8Masked) Serialize(encoder *goloxi.Encoder) error {
19944 if err := self.OxmId.Serialize(encoder); err != nil {
19945 return err
19946 }
19947
19948 return nil
19949}
19950
19951func DecodeOxmIdReg8Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg8Masked, error) {
19952 _oxmidreg8masked := &OxmIdReg8Masked{OxmId: parent}
19953 return _oxmidreg8masked, nil
19954}
19955
19956func NewOxmIdReg8Masked() *OxmIdReg8Masked {
19957 obj := &OxmIdReg8Masked{
19958 OxmId: NewOxmId(69896),
19959 }
19960 return obj
19961}
19962func (self *OxmIdReg8Masked) GetOXMName() string {
19963 return "reg8_masked"
19964}
19965
19966func (self *OxmIdReg8Masked) MarshalJSON() ([]byte, error) {
19967 if self.TypeLen == 0 {
19968 return []byte("\"\""), nil
19969 } else {
19970 return []byte("\"" + self.GetOXMName() + "\""), nil
19971 }
19972}
19973
19974type OxmIdReg9 struct {
19975 *OxmId
19976}
19977
19978type IOxmIdReg9 interface {
19979 IOxmId
19980}
19981
19982func (self *OxmIdReg9) Serialize(encoder *goloxi.Encoder) error {
19983 if err := self.OxmId.Serialize(encoder); err != nil {
19984 return err
19985 }
19986
19987 return nil
19988}
19989
19990func DecodeOxmIdReg9(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg9, error) {
19991 _oxmidreg9 := &OxmIdReg9{OxmId: parent}
19992 return _oxmidreg9, nil
19993}
19994
19995func NewOxmIdReg9() *OxmIdReg9 {
19996 obj := &OxmIdReg9{
19997 OxmId: NewOxmId(70148),
19998 }
19999 return obj
20000}
20001func (self *OxmIdReg9) GetOXMName() string {
20002 return "reg9"
20003}
20004
20005func (self *OxmIdReg9) MarshalJSON() ([]byte, error) {
20006 if self.TypeLen == 0 {
20007 return []byte("\"\""), nil
20008 } else {
20009 return []byte("\"" + self.GetOXMName() + "\""), nil
20010 }
20011}
20012
20013type OxmIdReg9Masked struct {
20014 *OxmId
20015}
20016
20017type IOxmIdReg9Masked interface {
20018 IOxmId
20019}
20020
20021func (self *OxmIdReg9Masked) Serialize(encoder *goloxi.Encoder) error {
20022 if err := self.OxmId.Serialize(encoder); err != nil {
20023 return err
20024 }
20025
20026 return nil
20027}
20028
20029func DecodeOxmIdReg9Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg9Masked, error) {
20030 _oxmidreg9masked := &OxmIdReg9Masked{OxmId: parent}
20031 return _oxmidreg9masked, nil
20032}
20033
20034func NewOxmIdReg9Masked() *OxmIdReg9Masked {
20035 obj := &OxmIdReg9Masked{
20036 OxmId: NewOxmId(70408),
20037 }
20038 return obj
20039}
20040func (self *OxmIdReg9Masked) GetOXMName() string {
20041 return "reg9_masked"
20042}
20043
20044func (self *OxmIdReg9Masked) MarshalJSON() ([]byte, error) {
20045 if self.TypeLen == 0 {
20046 return []byte("\"\""), nil
20047 } else {
20048 return []byte("\"" + self.GetOXMName() + "\""), nil
20049 }
20050}
20051
20052type OxmIdTcpDst struct {
20053 *OxmId
20054}
20055
20056type IOxmIdTcpDst interface {
20057 IOxmId
20058}
20059
20060func (self *OxmIdTcpDst) Serialize(encoder *goloxi.Encoder) error {
20061 if err := self.OxmId.Serialize(encoder); err != nil {
20062 return err
20063 }
20064
20065 return nil
20066}
20067
20068func DecodeOxmIdTcpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpDst, error) {
20069 _oxmidtcpdst := &OxmIdTcpDst{OxmId: parent}
20070 return _oxmidtcpdst, nil
20071}
20072
20073func NewOxmIdTcpDst() *OxmIdTcpDst {
20074 obj := &OxmIdTcpDst{
20075 OxmId: NewOxmId(5122),
20076 }
20077 return obj
20078}
20079func (self *OxmIdTcpDst) GetOXMName() string {
20080 return "tcp_dst"
20081}
20082
20083func (self *OxmIdTcpDst) MarshalJSON() ([]byte, error) {
20084 if self.TypeLen == 0 {
20085 return []byte("\"\""), nil
20086 } else {
20087 return []byte("\"" + self.GetOXMName() + "\""), nil
20088 }
20089}
20090
20091type OxmIdTcpDstMasked struct {
20092 *OxmId
20093}
20094
20095type IOxmIdTcpDstMasked interface {
20096 IOxmId
20097}
20098
20099func (self *OxmIdTcpDstMasked) Serialize(encoder *goloxi.Encoder) error {
20100 if err := self.OxmId.Serialize(encoder); err != nil {
20101 return err
20102 }
20103
20104 return nil
20105}
20106
20107func DecodeOxmIdTcpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpDstMasked, error) {
20108 _oxmidtcpdstmasked := &OxmIdTcpDstMasked{OxmId: parent}
20109 return _oxmidtcpdstmasked, nil
20110}
20111
20112func NewOxmIdTcpDstMasked() *OxmIdTcpDstMasked {
20113 obj := &OxmIdTcpDstMasked{
20114 OxmId: NewOxmId(5378),
20115 }
20116 return obj
20117}
20118func (self *OxmIdTcpDstMasked) GetOXMName() string {
20119 return "tcp_dst_masked"
20120}
20121
20122func (self *OxmIdTcpDstMasked) MarshalJSON() ([]byte, error) {
20123 if self.TypeLen == 0 {
20124 return []byte("\"\""), nil
20125 } else {
20126 return []byte("\"" + self.GetOXMName() + "\""), nil
20127 }
20128}
20129
20130type OxmIdTcpFlags struct {
20131 *OxmId
20132}
20133
20134type IOxmIdTcpFlags interface {
20135 IOxmId
20136}
20137
20138func (self *OxmIdTcpFlags) Serialize(encoder *goloxi.Encoder) error {
20139 if err := self.OxmId.Serialize(encoder); err != nil {
20140 return err
20141 }
20142
20143 return nil
20144}
20145
20146func DecodeOxmIdTcpFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpFlags, error) {
20147 _oxmidtcpflags := &OxmIdTcpFlags{OxmId: parent}
20148 return _oxmidtcpflags, nil
20149}
20150
20151func NewOxmIdTcpFlags() *OxmIdTcpFlags {
20152 obj := &OxmIdTcpFlags{
20153 OxmId: NewOxmId(82946),
20154 }
20155 return obj
20156}
20157func (self *OxmIdTcpFlags) GetOXMName() string {
20158 return "tcp_flags"
20159}
20160
20161func (self *OxmIdTcpFlags) MarshalJSON() ([]byte, error) {
20162 if self.TypeLen == 0 {
20163 return []byte("\"\""), nil
20164 } else {
20165 return []byte("\"" + self.GetOXMName() + "\""), nil
20166 }
20167}
20168
20169type OxmIdTcpFlagsMasked struct {
20170 *OxmId
20171}
20172
20173type IOxmIdTcpFlagsMasked interface {
20174 IOxmId
20175}
20176
20177func (self *OxmIdTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
20178 if err := self.OxmId.Serialize(encoder); err != nil {
20179 return err
20180 }
20181
20182 return nil
20183}
20184
20185func DecodeOxmIdTcpFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpFlagsMasked, error) {
20186 _oxmidtcpflagsmasked := &OxmIdTcpFlagsMasked{OxmId: parent}
20187 return _oxmidtcpflagsmasked, nil
20188}
20189
20190func NewOxmIdTcpFlagsMasked() *OxmIdTcpFlagsMasked {
20191 obj := &OxmIdTcpFlagsMasked{
20192 OxmId: NewOxmId(83204),
20193 }
20194 return obj
20195}
20196func (self *OxmIdTcpFlagsMasked) GetOXMName() string {
20197 return "tcp_flags_masked"
20198}
20199
20200func (self *OxmIdTcpFlagsMasked) MarshalJSON() ([]byte, error) {
20201 if self.TypeLen == 0 {
20202 return []byte("\"\""), nil
20203 } else {
20204 return []byte("\"" + self.GetOXMName() + "\""), nil
20205 }
20206}
20207
20208type OxmIdTcpSrc struct {
20209 *OxmId
20210}
20211
20212type IOxmIdTcpSrc interface {
20213 IOxmId
20214}
20215
20216func (self *OxmIdTcpSrc) Serialize(encoder *goloxi.Encoder) error {
20217 if err := self.OxmId.Serialize(encoder); err != nil {
20218 return err
20219 }
20220
20221 return nil
20222}
20223
20224func DecodeOxmIdTcpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpSrc, error) {
20225 _oxmidtcpsrc := &OxmIdTcpSrc{OxmId: parent}
20226 return _oxmidtcpsrc, nil
20227}
20228
20229func NewOxmIdTcpSrc() *OxmIdTcpSrc {
20230 obj := &OxmIdTcpSrc{
20231 OxmId: NewOxmId(4610),
20232 }
20233 return obj
20234}
20235func (self *OxmIdTcpSrc) GetOXMName() string {
20236 return "tcp_src"
20237}
20238
20239func (self *OxmIdTcpSrc) MarshalJSON() ([]byte, error) {
20240 if self.TypeLen == 0 {
20241 return []byte("\"\""), nil
20242 } else {
20243 return []byte("\"" + self.GetOXMName() + "\""), nil
20244 }
20245}
20246
20247type OxmIdTcpSrcMasked struct {
20248 *OxmId
20249}
20250
20251type IOxmIdTcpSrcMasked interface {
20252 IOxmId
20253}
20254
20255func (self *OxmIdTcpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
20256 if err := self.OxmId.Serialize(encoder); err != nil {
20257 return err
20258 }
20259
20260 return nil
20261}
20262
20263func DecodeOxmIdTcpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpSrcMasked, error) {
20264 _oxmidtcpsrcmasked := &OxmIdTcpSrcMasked{OxmId: parent}
20265 return _oxmidtcpsrcmasked, nil
20266}
20267
20268func NewOxmIdTcpSrcMasked() *OxmIdTcpSrcMasked {
20269 obj := &OxmIdTcpSrcMasked{
20270 OxmId: NewOxmId(4868),
20271 }
20272 return obj
20273}
20274func (self *OxmIdTcpSrcMasked) GetOXMName() string {
20275 return "tcp_src_masked"
20276}
20277
20278func (self *OxmIdTcpSrcMasked) MarshalJSON() ([]byte, error) {
20279 if self.TypeLen == 0 {
20280 return []byte("\"\""), nil
20281 } else {
20282 return []byte("\"" + self.GetOXMName() + "\""), nil
20283 }
20284}
20285
20286type OxmIdTunDst struct {
20287 *OxmId
20288}
20289
20290type IOxmIdTunDst interface {
20291 IOxmId
20292}
20293
20294func (self *OxmIdTunDst) Serialize(encoder *goloxi.Encoder) error {
20295 if err := self.OxmId.Serialize(encoder); err != nil {
20296 return err
20297 }
20298
20299 return nil
20300}
20301
20302func DecodeOxmIdTunDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunDst, error) {
20303 _oxmidtundst := &OxmIdTunDst{OxmId: parent}
20304 return _oxmidtundst, nil
20305}
20306
20307func NewOxmIdTunDst() *OxmIdTunDst {
20308 obj := &OxmIdTunDst{
20309 OxmId: NewOxmId(81924),
20310 }
20311 return obj
20312}
20313func (self *OxmIdTunDst) GetOXMName() string {
20314 return "tun_dst"
20315}
20316
20317func (self *OxmIdTunDst) MarshalJSON() ([]byte, error) {
20318 if self.TypeLen == 0 {
20319 return []byte("\"\""), nil
20320 } else {
20321 return []byte("\"" + self.GetOXMName() + "\""), nil
20322 }
20323}
20324
20325type OxmIdTunDstMasked struct {
20326 *OxmId
20327}
20328
20329type IOxmIdTunDstMasked interface {
20330 IOxmId
20331}
20332
20333func (self *OxmIdTunDstMasked) Serialize(encoder *goloxi.Encoder) error {
20334 if err := self.OxmId.Serialize(encoder); err != nil {
20335 return err
20336 }
20337
20338 return nil
20339}
20340
20341func DecodeOxmIdTunDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunDstMasked, error) {
20342 _oxmidtundstmasked := &OxmIdTunDstMasked{OxmId: parent}
20343 return _oxmidtundstmasked, nil
20344}
20345
20346func NewOxmIdTunDstMasked() *OxmIdTunDstMasked {
20347 obj := &OxmIdTunDstMasked{
20348 OxmId: NewOxmId(82184),
20349 }
20350 return obj
20351}
20352func (self *OxmIdTunDstMasked) GetOXMName() string {
20353 return "tun_dst_masked"
20354}
20355
20356func (self *OxmIdTunDstMasked) MarshalJSON() ([]byte, error) {
20357 if self.TypeLen == 0 {
20358 return []byte("\"\""), nil
20359 } else {
20360 return []byte("\"" + self.GetOXMName() + "\""), nil
20361 }
20362}
20363
20364type OxmIdTunFlags struct {
20365 *OxmId
20366}
20367
20368type IOxmIdTunFlags interface {
20369 IOxmId
20370}
20371
20372func (self *OxmIdTunFlags) Serialize(encoder *goloxi.Encoder) error {
20373 if err := self.OxmId.Serialize(encoder); err != nil {
20374 return err
20375 }
20376
20377 return nil
20378}
20379
20380func DecodeOxmIdTunFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunFlags, error) {
20381 _oxmidtunflags := &OxmIdTunFlags{OxmId: parent}
20382 return _oxmidtunflags, nil
20383}
20384
20385func NewOxmIdTunFlags() *OxmIdTunFlags {
20386 obj := &OxmIdTunFlags{
20387 OxmId: NewOxmId(118786),
20388 }
20389 return obj
20390}
20391func (self *OxmIdTunFlags) GetOXMName() string {
20392 return "tun_flags"
20393}
20394
20395func (self *OxmIdTunFlags) MarshalJSON() ([]byte, error) {
20396 if self.TypeLen == 0 {
20397 return []byte("\"\""), nil
20398 } else {
20399 return []byte("\"" + self.GetOXMName() + "\""), nil
20400 }
20401}
20402
20403type OxmIdTunFlagsMasked struct {
20404 *OxmId
20405}
20406
20407type IOxmIdTunFlagsMasked interface {
20408 IOxmId
20409}
20410
20411func (self *OxmIdTunFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
20412 if err := self.OxmId.Serialize(encoder); err != nil {
20413 return err
20414 }
20415
20416 return nil
20417}
20418
20419func DecodeOxmIdTunFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunFlagsMasked, error) {
20420 _oxmidtunflagsmasked := &OxmIdTunFlagsMasked{OxmId: parent}
20421 return _oxmidtunflagsmasked, nil
20422}
20423
20424func NewOxmIdTunFlagsMasked() *OxmIdTunFlagsMasked {
20425 obj := &OxmIdTunFlagsMasked{
20426 OxmId: NewOxmId(119044),
20427 }
20428 return obj
20429}
20430func (self *OxmIdTunFlagsMasked) GetOXMName() string {
20431 return "tun_flags_masked"
20432}
20433
20434func (self *OxmIdTunFlagsMasked) MarshalJSON() ([]byte, error) {
20435 if self.TypeLen == 0 {
20436 return []byte("\"\""), nil
20437 } else {
20438 return []byte("\"" + self.GetOXMName() + "\""), nil
20439 }
20440}
20441
20442type OxmIdTunGbpFlags struct {
20443 *OxmId
20444}
20445
20446type IOxmIdTunGbpFlags interface {
20447 IOxmId
20448}
20449
20450func (self *OxmIdTunGbpFlags) Serialize(encoder *goloxi.Encoder) error {
20451 if err := self.OxmId.Serialize(encoder); err != nil {
20452 return err
20453 }
20454
20455 return nil
20456}
20457
20458func DecodeOxmIdTunGbpFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpFlags, error) {
20459 _oxmidtungbpflags := &OxmIdTunGbpFlags{OxmId: parent}
20460 return _oxmidtungbpflags, nil
20461}
20462
20463func NewOxmIdTunGbpFlags() *OxmIdTunGbpFlags {
20464 obj := &OxmIdTunGbpFlags{
20465 OxmId: NewOxmId(85505),
20466 }
20467 return obj
20468}
20469func (self *OxmIdTunGbpFlags) GetOXMName() string {
20470 return "tun_gbp_flags"
20471}
20472
20473func (self *OxmIdTunGbpFlags) MarshalJSON() ([]byte, error) {
20474 if self.TypeLen == 0 {
20475 return []byte("\"\""), nil
20476 } else {
20477 return []byte("\"" + self.GetOXMName() + "\""), nil
20478 }
20479}
20480
20481type OxmIdTunGbpFlagsMasked struct {
20482 *OxmId
20483}
20484
20485type IOxmIdTunGbpFlagsMasked interface {
20486 IOxmId
20487}
20488
20489func (self *OxmIdTunGbpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
20490 if err := self.OxmId.Serialize(encoder); err != nil {
20491 return err
20492 }
20493
20494 return nil
20495}
20496
20497func DecodeOxmIdTunGbpFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpFlagsMasked, error) {
20498 _oxmidtungbpflagsmasked := &OxmIdTunGbpFlagsMasked{OxmId: parent}
20499 return _oxmidtungbpflagsmasked, nil
20500}
20501
20502func NewOxmIdTunGbpFlagsMasked() *OxmIdTunGbpFlagsMasked {
20503 obj := &OxmIdTunGbpFlagsMasked{
20504 OxmId: NewOxmId(85762),
20505 }
20506 return obj
20507}
20508func (self *OxmIdTunGbpFlagsMasked) GetOXMName() string {
20509 return "tun_gbp_flags_masked"
20510}
20511
20512func (self *OxmIdTunGbpFlagsMasked) MarshalJSON() ([]byte, error) {
20513 if self.TypeLen == 0 {
20514 return []byte("\"\""), nil
20515 } else {
20516 return []byte("\"" + self.GetOXMName() + "\""), nil
20517 }
20518}
20519
20520type OxmIdTunGbpId struct {
20521 *OxmId
20522}
20523
20524type IOxmIdTunGbpId interface {
20525 IOxmId
20526}
20527
20528func (self *OxmIdTunGbpId) Serialize(encoder *goloxi.Encoder) error {
20529 if err := self.OxmId.Serialize(encoder); err != nil {
20530 return err
20531 }
20532
20533 return nil
20534}
20535
20536func DecodeOxmIdTunGbpId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpId, error) {
20537 _oxmidtungbpid := &OxmIdTunGbpId{OxmId: parent}
20538 return _oxmidtungbpid, nil
20539}
20540
20541func NewOxmIdTunGbpId() *OxmIdTunGbpId {
20542 obj := &OxmIdTunGbpId{
20543 OxmId: NewOxmId(84994),
20544 }
20545 return obj
20546}
20547func (self *OxmIdTunGbpId) GetOXMName() string {
20548 return "tun_gbp_id"
20549}
20550
20551func (self *OxmIdTunGbpId) MarshalJSON() ([]byte, error) {
20552 if self.TypeLen == 0 {
20553 return []byte("\"\""), nil
20554 } else {
20555 return []byte("\"" + self.GetOXMName() + "\""), nil
20556 }
20557}
20558
20559type OxmIdTunGbpIdMasked struct {
20560 *OxmId
20561}
20562
20563type IOxmIdTunGbpIdMasked interface {
20564 IOxmId
20565}
20566
20567func (self *OxmIdTunGbpIdMasked) Serialize(encoder *goloxi.Encoder) error {
20568 if err := self.OxmId.Serialize(encoder); err != nil {
20569 return err
20570 }
20571
20572 return nil
20573}
20574
20575func DecodeOxmIdTunGbpIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpIdMasked, error) {
20576 _oxmidtungbpidmasked := &OxmIdTunGbpIdMasked{OxmId: parent}
20577 return _oxmidtungbpidmasked, nil
20578}
20579
20580func NewOxmIdTunGbpIdMasked() *OxmIdTunGbpIdMasked {
20581 obj := &OxmIdTunGbpIdMasked{
20582 OxmId: NewOxmId(85252),
20583 }
20584 return obj
20585}
20586func (self *OxmIdTunGbpIdMasked) GetOXMName() string {
20587 return "tun_gbp_id_masked"
20588}
20589
20590func (self *OxmIdTunGbpIdMasked) MarshalJSON() ([]byte, error) {
20591 if self.TypeLen == 0 {
20592 return []byte("\"\""), nil
20593 } else {
20594 return []byte("\"" + self.GetOXMName() + "\""), nil
20595 }
20596}
20597
20598type OxmIdTunId struct {
20599 *OxmId
20600}
20601
20602type IOxmIdTunId interface {
20603 IOxmId
20604}
20605
20606func (self *OxmIdTunId) Serialize(encoder *goloxi.Encoder) error {
20607 if err := self.OxmId.Serialize(encoder); err != nil {
20608 return err
20609 }
20610
20611 return nil
20612}
20613
20614func DecodeOxmIdTunId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunId, error) {
20615 _oxmidtunid := &OxmIdTunId{OxmId: parent}
20616 return _oxmidtunid, nil
20617}
20618
20619func NewOxmIdTunId() *OxmIdTunId {
20620 obj := &OxmIdTunId{
20621 OxmId: NewOxmId(73736),
20622 }
20623 return obj
20624}
20625func (self *OxmIdTunId) GetOXMName() string {
20626 return "tun_id"
20627}
20628
20629func (self *OxmIdTunId) MarshalJSON() ([]byte, error) {
20630 if self.TypeLen == 0 {
20631 return []byte("\"\""), nil
20632 } else {
20633 return []byte("\"" + self.GetOXMName() + "\""), nil
20634 }
20635}
20636
20637type OxmIdTunIdMasked struct {
20638 *OxmId
20639}
20640
20641type IOxmIdTunIdMasked interface {
20642 IOxmId
20643}
20644
20645func (self *OxmIdTunIdMasked) Serialize(encoder *goloxi.Encoder) error {
20646 if err := self.OxmId.Serialize(encoder); err != nil {
20647 return err
20648 }
20649
20650 return nil
20651}
20652
20653func DecodeOxmIdTunIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIdMasked, error) {
20654 _oxmidtunidmasked := &OxmIdTunIdMasked{OxmId: parent}
20655 return _oxmidtunidmasked, nil
20656}
20657
20658func NewOxmIdTunIdMasked() *OxmIdTunIdMasked {
20659 obj := &OxmIdTunIdMasked{
20660 OxmId: NewOxmId(74000),
20661 }
20662 return obj
20663}
20664func (self *OxmIdTunIdMasked) GetOXMName() string {
20665 return "tun_id_masked"
20666}
20667
20668func (self *OxmIdTunIdMasked) MarshalJSON() ([]byte, error) {
20669 if self.TypeLen == 0 {
20670 return []byte("\"\""), nil
20671 } else {
20672 return []byte("\"" + self.GetOXMName() + "\""), nil
20673 }
20674}
20675
20676type OxmIdTunIpv6Dst struct {
20677 *OxmId
20678}
20679
20680type IOxmIdTunIpv6Dst interface {
20681 IOxmId
20682}
20683
20684func (self *OxmIdTunIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
20685 if err := self.OxmId.Serialize(encoder); err != nil {
20686 return err
20687 }
20688
20689 return nil
20690}
20691
20692func DecodeOxmIdTunIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6Dst, error) {
20693 _oxmidtunipv6dst := &OxmIdTunIpv6Dst{OxmId: parent}
20694 return _oxmidtunipv6dst, nil
20695}
20696
20697func NewOxmIdTunIpv6Dst() *OxmIdTunIpv6Dst {
20698 obj := &OxmIdTunIpv6Dst{
20699 OxmId: NewOxmId(121872),
20700 }
20701 return obj
20702}
20703func (self *OxmIdTunIpv6Dst) GetOXMName() string {
20704 return "tun_ipv6_dst"
20705}
20706
20707func (self *OxmIdTunIpv6Dst) MarshalJSON() ([]byte, error) {
20708 if self.TypeLen == 0 {
20709 return []byte("\"\""), nil
20710 } else {
20711 return []byte("\"" + self.GetOXMName() + "\""), nil
20712 }
20713}
20714
20715type OxmIdTunIpv6DstMasked struct {
20716 *OxmId
20717}
20718
20719type IOxmIdTunIpv6DstMasked interface {
20720 IOxmId
20721}
20722
20723func (self *OxmIdTunIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
20724 if err := self.OxmId.Serialize(encoder); err != nil {
20725 return err
20726 }
20727
20728 return nil
20729}
20730
20731func DecodeOxmIdTunIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6DstMasked, error) {
20732 _oxmidtunipv6dstmasked := &OxmIdTunIpv6DstMasked{OxmId: parent}
20733 return _oxmidtunipv6dstmasked, nil
20734}
20735
20736func NewOxmIdTunIpv6DstMasked() *OxmIdTunIpv6DstMasked {
20737 obj := &OxmIdTunIpv6DstMasked{
20738 OxmId: NewOxmId(122144),
20739 }
20740 return obj
20741}
20742func (self *OxmIdTunIpv6DstMasked) GetOXMName() string {
20743 return "tun_ipv6_dst_masked"
20744}
20745
20746func (self *OxmIdTunIpv6DstMasked) MarshalJSON() ([]byte, error) {
20747 if self.TypeLen == 0 {
20748 return []byte("\"\""), nil
20749 } else {
20750 return []byte("\"" + self.GetOXMName() + "\""), nil
20751 }
20752}
20753
20754type OxmIdTunIpv6Src struct {
20755 *OxmId
20756}
20757
20758type IOxmIdTunIpv6Src interface {
20759 IOxmId
20760}
20761
20762func (self *OxmIdTunIpv6Src) Serialize(encoder *goloxi.Encoder) error {
20763 if err := self.OxmId.Serialize(encoder); err != nil {
20764 return err
20765 }
20766
20767 return nil
20768}
20769
20770func DecodeOxmIdTunIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6Src, error) {
20771 _oxmidtunipv6src := &OxmIdTunIpv6Src{OxmId: parent}
20772 return _oxmidtunipv6src, nil
20773}
20774
20775func NewOxmIdTunIpv6Src() *OxmIdTunIpv6Src {
20776 obj := &OxmIdTunIpv6Src{
20777 OxmId: NewOxmId(121360),
20778 }
20779 return obj
20780}
20781func (self *OxmIdTunIpv6Src) GetOXMName() string {
20782 return "tun_ipv6_src"
20783}
20784
20785func (self *OxmIdTunIpv6Src) MarshalJSON() ([]byte, error) {
20786 if self.TypeLen == 0 {
20787 return []byte("\"\""), nil
20788 } else {
20789 return []byte("\"" + self.GetOXMName() + "\""), nil
20790 }
20791}
20792
20793type OxmIdTunIpv6SrcMasked struct {
20794 *OxmId
20795}
20796
20797type IOxmIdTunIpv6SrcMasked interface {
20798 IOxmId
20799}
20800
20801func (self *OxmIdTunIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
20802 if err := self.OxmId.Serialize(encoder); err != nil {
20803 return err
20804 }
20805
20806 return nil
20807}
20808
20809func DecodeOxmIdTunIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6SrcMasked, error) {
20810 _oxmidtunipv6srcmasked := &OxmIdTunIpv6SrcMasked{OxmId: parent}
20811 return _oxmidtunipv6srcmasked, nil
20812}
20813
20814func NewOxmIdTunIpv6SrcMasked() *OxmIdTunIpv6SrcMasked {
20815 obj := &OxmIdTunIpv6SrcMasked{
20816 OxmId: NewOxmId(121632),
20817 }
20818 return obj
20819}
20820func (self *OxmIdTunIpv6SrcMasked) GetOXMName() string {
20821 return "tun_ipv6_src_masked"
20822}
20823
20824func (self *OxmIdTunIpv6SrcMasked) MarshalJSON() ([]byte, error) {
20825 if self.TypeLen == 0 {
20826 return []byte("\"\""), nil
20827 } else {
20828 return []byte("\"" + self.GetOXMName() + "\""), nil
20829 }
20830}
20831
20832type OxmIdTunMetadata0 struct {
20833 *OxmId
20834}
20835
20836type IOxmIdTunMetadata0 interface {
20837 IOxmId
20838}
20839
20840func (self *OxmIdTunMetadata0) Serialize(encoder *goloxi.Encoder) error {
20841 if err := self.OxmId.Serialize(encoder); err != nil {
20842 return err
20843 }
20844
20845 return nil
20846}
20847
20848func DecodeOxmIdTunMetadata0(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata0, error) {
20849 _oxmidtunmetadata0 := &OxmIdTunMetadata0{OxmId: parent}
20850 return _oxmidtunmetadata0, nil
20851}
20852
20853func NewOxmIdTunMetadata0() *OxmIdTunMetadata0 {
20854 obj := &OxmIdTunMetadata0{
20855 OxmId: NewOxmId(86140),
20856 }
20857 return obj
20858}
20859func (self *OxmIdTunMetadata0) GetOXMName() string {
20860 return "tun_metadata0"
20861}
20862
20863func (self *OxmIdTunMetadata0) MarshalJSON() ([]byte, error) {
20864 if self.TypeLen == 0 {
20865 return []byte("\"\""), nil
20866 } else {
20867 return []byte("\"" + self.GetOXMName() + "\""), nil
20868 }
20869}
20870
20871type OxmIdTunMetadata0Masked struct {
20872 *OxmId
20873}
20874
20875type IOxmIdTunMetadata0Masked interface {
20876 IOxmId
20877}
20878
20879func (self *OxmIdTunMetadata0Masked) Serialize(encoder *goloxi.Encoder) error {
20880 if err := self.OxmId.Serialize(encoder); err != nil {
20881 return err
20882 }
20883
20884 return nil
20885}
20886
20887func DecodeOxmIdTunMetadata0Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata0Masked, error) {
20888 _oxmidtunmetadata0masked := &OxmIdTunMetadata0Masked{OxmId: parent}
20889 return _oxmidtunmetadata0masked, nil
20890}
20891
20892func NewOxmIdTunMetadata0Masked() *OxmIdTunMetadata0Masked {
20893 obj := &OxmIdTunMetadata0Masked{
20894 OxmId: NewOxmId(86520),
20895 }
20896 return obj
20897}
20898func (self *OxmIdTunMetadata0Masked) GetOXMName() string {
20899 return "tun_metadata0_masked"
20900}
20901
20902func (self *OxmIdTunMetadata0Masked) MarshalJSON() ([]byte, error) {
20903 if self.TypeLen == 0 {
20904 return []byte("\"\""), nil
20905 } else {
20906 return []byte("\"" + self.GetOXMName() + "\""), nil
20907 }
20908}
20909
20910type OxmIdTunMetadata1 struct {
20911 *OxmId
20912}
20913
20914type IOxmIdTunMetadata1 interface {
20915 IOxmId
20916}
20917
20918func (self *OxmIdTunMetadata1) Serialize(encoder *goloxi.Encoder) error {
20919 if err := self.OxmId.Serialize(encoder); err != nil {
20920 return err
20921 }
20922
20923 return nil
20924}
20925
20926func DecodeOxmIdTunMetadata1(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata1, error) {
20927 _oxmidtunmetadata1 := &OxmIdTunMetadata1{OxmId: parent}
20928 return _oxmidtunmetadata1, nil
20929}
20930
20931func NewOxmIdTunMetadata1() *OxmIdTunMetadata1 {
20932 obj := &OxmIdTunMetadata1{
20933 OxmId: NewOxmId(86652),
20934 }
20935 return obj
20936}
20937func (self *OxmIdTunMetadata1) GetOXMName() string {
20938 return "tun_metadata1"
20939}
20940
20941func (self *OxmIdTunMetadata1) MarshalJSON() ([]byte, error) {
20942 if self.TypeLen == 0 {
20943 return []byte("\"\""), nil
20944 } else {
20945 return []byte("\"" + self.GetOXMName() + "\""), nil
20946 }
20947}
20948
20949type OxmIdTunMetadata10 struct {
20950 *OxmId
20951}
20952
20953type IOxmIdTunMetadata10 interface {
20954 IOxmId
20955}
20956
20957func (self *OxmIdTunMetadata10) Serialize(encoder *goloxi.Encoder) error {
20958 if err := self.OxmId.Serialize(encoder); err != nil {
20959 return err
20960 }
20961
20962 return nil
20963}
20964
20965func DecodeOxmIdTunMetadata10(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata10, error) {
20966 _oxmidtunmetadata10 := &OxmIdTunMetadata10{OxmId: parent}
20967 return _oxmidtunmetadata10, nil
20968}
20969
20970func NewOxmIdTunMetadata10() *OxmIdTunMetadata10 {
20971 obj := &OxmIdTunMetadata10{
20972 OxmId: NewOxmId(91260),
20973 }
20974 return obj
20975}
20976func (self *OxmIdTunMetadata10) GetOXMName() string {
20977 return "tun_metadata10"
20978}
20979
20980func (self *OxmIdTunMetadata10) MarshalJSON() ([]byte, error) {
20981 if self.TypeLen == 0 {
20982 return []byte("\"\""), nil
20983 } else {
20984 return []byte("\"" + self.GetOXMName() + "\""), nil
20985 }
20986}
20987
20988type OxmIdTunMetadata10Masked struct {
20989 *OxmId
20990}
20991
20992type IOxmIdTunMetadata10Masked interface {
20993 IOxmId
20994}
20995
20996func (self *OxmIdTunMetadata10Masked) Serialize(encoder *goloxi.Encoder) error {
20997 if err := self.OxmId.Serialize(encoder); err != nil {
20998 return err
20999 }
21000
21001 return nil
21002}
21003
21004func DecodeOxmIdTunMetadata10Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata10Masked, error) {
21005 _oxmidtunmetadata10masked := &OxmIdTunMetadata10Masked{OxmId: parent}
21006 return _oxmidtunmetadata10masked, nil
21007}
21008
21009func NewOxmIdTunMetadata10Masked() *OxmIdTunMetadata10Masked {
21010 obj := &OxmIdTunMetadata10Masked{
21011 OxmId: NewOxmId(91640),
21012 }
21013 return obj
21014}
21015func (self *OxmIdTunMetadata10Masked) GetOXMName() string {
21016 return "tun_metadata10_masked"
21017}
21018
21019func (self *OxmIdTunMetadata10Masked) MarshalJSON() ([]byte, error) {
21020 if self.TypeLen == 0 {
21021 return []byte("\"\""), nil
21022 } else {
21023 return []byte("\"" + self.GetOXMName() + "\""), nil
21024 }
21025}
21026
21027type OxmIdTunMetadata11 struct {
21028 *OxmId
21029}
21030
21031type IOxmIdTunMetadata11 interface {
21032 IOxmId
21033}
21034
21035func (self *OxmIdTunMetadata11) Serialize(encoder *goloxi.Encoder) error {
21036 if err := self.OxmId.Serialize(encoder); err != nil {
21037 return err
21038 }
21039
21040 return nil
21041}
21042
21043func DecodeOxmIdTunMetadata11(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata11, error) {
21044 _oxmidtunmetadata11 := &OxmIdTunMetadata11{OxmId: parent}
21045 return _oxmidtunmetadata11, nil
21046}
21047
21048func NewOxmIdTunMetadata11() *OxmIdTunMetadata11 {
21049 obj := &OxmIdTunMetadata11{
21050 OxmId: NewOxmId(91772),
21051 }
21052 return obj
21053}
21054func (self *OxmIdTunMetadata11) GetOXMName() string {
21055 return "tun_metadata11"
21056}
21057
21058func (self *OxmIdTunMetadata11) MarshalJSON() ([]byte, error) {
21059 if self.TypeLen == 0 {
21060 return []byte("\"\""), nil
21061 } else {
21062 return []byte("\"" + self.GetOXMName() + "\""), nil
21063 }
21064}
21065
21066type OxmIdTunMetadata11Masked struct {
21067 *OxmId
21068}
21069
21070type IOxmIdTunMetadata11Masked interface {
21071 IOxmId
21072}
21073
21074func (self *OxmIdTunMetadata11Masked) Serialize(encoder *goloxi.Encoder) error {
21075 if err := self.OxmId.Serialize(encoder); err != nil {
21076 return err
21077 }
21078
21079 return nil
21080}
21081
21082func DecodeOxmIdTunMetadata11Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata11Masked, error) {
21083 _oxmidtunmetadata11masked := &OxmIdTunMetadata11Masked{OxmId: parent}
21084 return _oxmidtunmetadata11masked, nil
21085}
21086
21087func NewOxmIdTunMetadata11Masked() *OxmIdTunMetadata11Masked {
21088 obj := &OxmIdTunMetadata11Masked{
21089 OxmId: NewOxmId(92152),
21090 }
21091 return obj
21092}
21093func (self *OxmIdTunMetadata11Masked) GetOXMName() string {
21094 return "tun_metadata11_masked"
21095}
21096
21097func (self *OxmIdTunMetadata11Masked) MarshalJSON() ([]byte, error) {
21098 if self.TypeLen == 0 {
21099 return []byte("\"\""), nil
21100 } else {
21101 return []byte("\"" + self.GetOXMName() + "\""), nil
21102 }
21103}
21104
21105type OxmIdTunMetadata12 struct {
21106 *OxmId
21107}
21108
21109type IOxmIdTunMetadata12 interface {
21110 IOxmId
21111}
21112
21113func (self *OxmIdTunMetadata12) Serialize(encoder *goloxi.Encoder) error {
21114 if err := self.OxmId.Serialize(encoder); err != nil {
21115 return err
21116 }
21117
21118 return nil
21119}
21120
21121func DecodeOxmIdTunMetadata12(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata12, error) {
21122 _oxmidtunmetadata12 := &OxmIdTunMetadata12{OxmId: parent}
21123 return _oxmidtunmetadata12, nil
21124}
21125
21126func NewOxmIdTunMetadata12() *OxmIdTunMetadata12 {
21127 obj := &OxmIdTunMetadata12{
21128 OxmId: NewOxmId(92284),
21129 }
21130 return obj
21131}
21132func (self *OxmIdTunMetadata12) GetOXMName() string {
21133 return "tun_metadata12"
21134}
21135
21136func (self *OxmIdTunMetadata12) MarshalJSON() ([]byte, error) {
21137 if self.TypeLen == 0 {
21138 return []byte("\"\""), nil
21139 } else {
21140 return []byte("\"" + self.GetOXMName() + "\""), nil
21141 }
21142}
21143
21144type OxmIdTunMetadata12Masked struct {
21145 *OxmId
21146}
21147
21148type IOxmIdTunMetadata12Masked interface {
21149 IOxmId
21150}
21151
21152func (self *OxmIdTunMetadata12Masked) Serialize(encoder *goloxi.Encoder) error {
21153 if err := self.OxmId.Serialize(encoder); err != nil {
21154 return err
21155 }
21156
21157 return nil
21158}
21159
21160func DecodeOxmIdTunMetadata12Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata12Masked, error) {
21161 _oxmidtunmetadata12masked := &OxmIdTunMetadata12Masked{OxmId: parent}
21162 return _oxmidtunmetadata12masked, nil
21163}
21164
21165func NewOxmIdTunMetadata12Masked() *OxmIdTunMetadata12Masked {
21166 obj := &OxmIdTunMetadata12Masked{
21167 OxmId: NewOxmId(92664),
21168 }
21169 return obj
21170}
21171func (self *OxmIdTunMetadata12Masked) GetOXMName() string {
21172 return "tun_metadata12_masked"
21173}
21174
21175func (self *OxmIdTunMetadata12Masked) MarshalJSON() ([]byte, error) {
21176 if self.TypeLen == 0 {
21177 return []byte("\"\""), nil
21178 } else {
21179 return []byte("\"" + self.GetOXMName() + "\""), nil
21180 }
21181}
21182
21183type OxmIdTunMetadata13 struct {
21184 *OxmId
21185}
21186
21187type IOxmIdTunMetadata13 interface {
21188 IOxmId
21189}
21190
21191func (self *OxmIdTunMetadata13) Serialize(encoder *goloxi.Encoder) error {
21192 if err := self.OxmId.Serialize(encoder); err != nil {
21193 return err
21194 }
21195
21196 return nil
21197}
21198
21199func DecodeOxmIdTunMetadata13(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata13, error) {
21200 _oxmidtunmetadata13 := &OxmIdTunMetadata13{OxmId: parent}
21201 return _oxmidtunmetadata13, nil
21202}
21203
21204func NewOxmIdTunMetadata13() *OxmIdTunMetadata13 {
21205 obj := &OxmIdTunMetadata13{
21206 OxmId: NewOxmId(92796),
21207 }
21208 return obj
21209}
21210func (self *OxmIdTunMetadata13) GetOXMName() string {
21211 return "tun_metadata13"
21212}
21213
21214func (self *OxmIdTunMetadata13) MarshalJSON() ([]byte, error) {
21215 if self.TypeLen == 0 {
21216 return []byte("\"\""), nil
21217 } else {
21218 return []byte("\"" + self.GetOXMName() + "\""), nil
21219 }
21220}
21221
21222type OxmIdTunMetadata13Masked struct {
21223 *OxmId
21224}
21225
21226type IOxmIdTunMetadata13Masked interface {
21227 IOxmId
21228}
21229
21230func (self *OxmIdTunMetadata13Masked) Serialize(encoder *goloxi.Encoder) error {
21231 if err := self.OxmId.Serialize(encoder); err != nil {
21232 return err
21233 }
21234
21235 return nil
21236}
21237
21238func DecodeOxmIdTunMetadata13Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata13Masked, error) {
21239 _oxmidtunmetadata13masked := &OxmIdTunMetadata13Masked{OxmId: parent}
21240 return _oxmidtunmetadata13masked, nil
21241}
21242
21243func NewOxmIdTunMetadata13Masked() *OxmIdTunMetadata13Masked {
21244 obj := &OxmIdTunMetadata13Masked{
21245 OxmId: NewOxmId(93176),
21246 }
21247 return obj
21248}
21249func (self *OxmIdTunMetadata13Masked) GetOXMName() string {
21250 return "tun_metadata13_masked"
21251}
21252
21253func (self *OxmIdTunMetadata13Masked) MarshalJSON() ([]byte, error) {
21254 if self.TypeLen == 0 {
21255 return []byte("\"\""), nil
21256 } else {
21257 return []byte("\"" + self.GetOXMName() + "\""), nil
21258 }
21259}
21260
21261type OxmIdTunMetadata14 struct {
21262 *OxmId
21263}
21264
21265type IOxmIdTunMetadata14 interface {
21266 IOxmId
21267}
21268
21269func (self *OxmIdTunMetadata14) Serialize(encoder *goloxi.Encoder) error {
21270 if err := self.OxmId.Serialize(encoder); err != nil {
21271 return err
21272 }
21273
21274 return nil
21275}
21276
21277func DecodeOxmIdTunMetadata14(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata14, error) {
21278 _oxmidtunmetadata14 := &OxmIdTunMetadata14{OxmId: parent}
21279 return _oxmidtunmetadata14, nil
21280}
21281
21282func NewOxmIdTunMetadata14() *OxmIdTunMetadata14 {
21283 obj := &OxmIdTunMetadata14{
21284 OxmId: NewOxmId(93308),
21285 }
21286 return obj
21287}
21288func (self *OxmIdTunMetadata14) GetOXMName() string {
21289 return "tun_metadata14"
21290}
21291
21292func (self *OxmIdTunMetadata14) MarshalJSON() ([]byte, error) {
21293 if self.TypeLen == 0 {
21294 return []byte("\"\""), nil
21295 } else {
21296 return []byte("\"" + self.GetOXMName() + "\""), nil
21297 }
21298}
21299
21300type OxmIdTunMetadata14Masked struct {
21301 *OxmId
21302}
21303
21304type IOxmIdTunMetadata14Masked interface {
21305 IOxmId
21306}
21307
21308func (self *OxmIdTunMetadata14Masked) Serialize(encoder *goloxi.Encoder) error {
21309 if err := self.OxmId.Serialize(encoder); err != nil {
21310 return err
21311 }
21312
21313 return nil
21314}
21315
21316func DecodeOxmIdTunMetadata14Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata14Masked, error) {
21317 _oxmidtunmetadata14masked := &OxmIdTunMetadata14Masked{OxmId: parent}
21318 return _oxmidtunmetadata14masked, nil
21319}
21320
21321func NewOxmIdTunMetadata14Masked() *OxmIdTunMetadata14Masked {
21322 obj := &OxmIdTunMetadata14Masked{
21323 OxmId: NewOxmId(93688),
21324 }
21325 return obj
21326}
21327func (self *OxmIdTunMetadata14Masked) GetOXMName() string {
21328 return "tun_metadata14_masked"
21329}
21330
21331func (self *OxmIdTunMetadata14Masked) MarshalJSON() ([]byte, error) {
21332 if self.TypeLen == 0 {
21333 return []byte("\"\""), nil
21334 } else {
21335 return []byte("\"" + self.GetOXMName() + "\""), nil
21336 }
21337}
21338
21339type OxmIdTunMetadata15 struct {
21340 *OxmId
21341}
21342
21343type IOxmIdTunMetadata15 interface {
21344 IOxmId
21345}
21346
21347func (self *OxmIdTunMetadata15) Serialize(encoder *goloxi.Encoder) error {
21348 if err := self.OxmId.Serialize(encoder); err != nil {
21349 return err
21350 }
21351
21352 return nil
21353}
21354
21355func DecodeOxmIdTunMetadata15(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata15, error) {
21356 _oxmidtunmetadata15 := &OxmIdTunMetadata15{OxmId: parent}
21357 return _oxmidtunmetadata15, nil
21358}
21359
21360func NewOxmIdTunMetadata15() *OxmIdTunMetadata15 {
21361 obj := &OxmIdTunMetadata15{
21362 OxmId: NewOxmId(93820),
21363 }
21364 return obj
21365}
21366func (self *OxmIdTunMetadata15) GetOXMName() string {
21367 return "tun_metadata15"
21368}
21369
21370func (self *OxmIdTunMetadata15) MarshalJSON() ([]byte, error) {
21371 if self.TypeLen == 0 {
21372 return []byte("\"\""), nil
21373 } else {
21374 return []byte("\"" + self.GetOXMName() + "\""), nil
21375 }
21376}
21377
21378type OxmIdTunMetadata15Masked struct {
21379 *OxmId
21380}
21381
21382type IOxmIdTunMetadata15Masked interface {
21383 IOxmId
21384}
21385
21386func (self *OxmIdTunMetadata15Masked) Serialize(encoder *goloxi.Encoder) error {
21387 if err := self.OxmId.Serialize(encoder); err != nil {
21388 return err
21389 }
21390
21391 return nil
21392}
21393
21394func DecodeOxmIdTunMetadata15Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata15Masked, error) {
21395 _oxmidtunmetadata15masked := &OxmIdTunMetadata15Masked{OxmId: parent}
21396 return _oxmidtunmetadata15masked, nil
21397}
21398
21399func NewOxmIdTunMetadata15Masked() *OxmIdTunMetadata15Masked {
21400 obj := &OxmIdTunMetadata15Masked{
21401 OxmId: NewOxmId(94200),
21402 }
21403 return obj
21404}
21405func (self *OxmIdTunMetadata15Masked) GetOXMName() string {
21406 return "tun_metadata15_masked"
21407}
21408
21409func (self *OxmIdTunMetadata15Masked) MarshalJSON() ([]byte, error) {
21410 if self.TypeLen == 0 {
21411 return []byte("\"\""), nil
21412 } else {
21413 return []byte("\"" + self.GetOXMName() + "\""), nil
21414 }
21415}
21416
21417type OxmIdTunMetadata16 struct {
21418 *OxmId
21419}
21420
21421type IOxmIdTunMetadata16 interface {
21422 IOxmId
21423}
21424
21425func (self *OxmIdTunMetadata16) Serialize(encoder *goloxi.Encoder) error {
21426 if err := self.OxmId.Serialize(encoder); err != nil {
21427 return err
21428 }
21429
21430 return nil
21431}
21432
21433func DecodeOxmIdTunMetadata16(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata16, error) {
21434 _oxmidtunmetadata16 := &OxmIdTunMetadata16{OxmId: parent}
21435 return _oxmidtunmetadata16, nil
21436}
21437
21438func NewOxmIdTunMetadata16() *OxmIdTunMetadata16 {
21439 obj := &OxmIdTunMetadata16{
21440 OxmId: NewOxmId(94332),
21441 }
21442 return obj
21443}
21444func (self *OxmIdTunMetadata16) GetOXMName() string {
21445 return "tun_metadata16"
21446}
21447
21448func (self *OxmIdTunMetadata16) MarshalJSON() ([]byte, error) {
21449 if self.TypeLen == 0 {
21450 return []byte("\"\""), nil
21451 } else {
21452 return []byte("\"" + self.GetOXMName() + "\""), nil
21453 }
21454}
21455
21456type OxmIdTunMetadata16Masked struct {
21457 *OxmId
21458}
21459
21460type IOxmIdTunMetadata16Masked interface {
21461 IOxmId
21462}
21463
21464func (self *OxmIdTunMetadata16Masked) Serialize(encoder *goloxi.Encoder) error {
21465 if err := self.OxmId.Serialize(encoder); err != nil {
21466 return err
21467 }
21468
21469 return nil
21470}
21471
21472func DecodeOxmIdTunMetadata16Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata16Masked, error) {
21473 _oxmidtunmetadata16masked := &OxmIdTunMetadata16Masked{OxmId: parent}
21474 return _oxmidtunmetadata16masked, nil
21475}
21476
21477func NewOxmIdTunMetadata16Masked() *OxmIdTunMetadata16Masked {
21478 obj := &OxmIdTunMetadata16Masked{
21479 OxmId: NewOxmId(94712),
21480 }
21481 return obj
21482}
21483func (self *OxmIdTunMetadata16Masked) GetOXMName() string {
21484 return "tun_metadata16_masked"
21485}
21486
21487func (self *OxmIdTunMetadata16Masked) MarshalJSON() ([]byte, error) {
21488 if self.TypeLen == 0 {
21489 return []byte("\"\""), nil
21490 } else {
21491 return []byte("\"" + self.GetOXMName() + "\""), nil
21492 }
21493}
21494
21495type OxmIdTunMetadata17 struct {
21496 *OxmId
21497}
21498
21499type IOxmIdTunMetadata17 interface {
21500 IOxmId
21501}
21502
21503func (self *OxmIdTunMetadata17) Serialize(encoder *goloxi.Encoder) error {
21504 if err := self.OxmId.Serialize(encoder); err != nil {
21505 return err
21506 }
21507
21508 return nil
21509}
21510
21511func DecodeOxmIdTunMetadata17(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata17, error) {
21512 _oxmidtunmetadata17 := &OxmIdTunMetadata17{OxmId: parent}
21513 return _oxmidtunmetadata17, nil
21514}
21515
21516func NewOxmIdTunMetadata17() *OxmIdTunMetadata17 {
21517 obj := &OxmIdTunMetadata17{
21518 OxmId: NewOxmId(94844),
21519 }
21520 return obj
21521}
21522func (self *OxmIdTunMetadata17) GetOXMName() string {
21523 return "tun_metadata17"
21524}
21525
21526func (self *OxmIdTunMetadata17) MarshalJSON() ([]byte, error) {
21527 if self.TypeLen == 0 {
21528 return []byte("\"\""), nil
21529 } else {
21530 return []byte("\"" + self.GetOXMName() + "\""), nil
21531 }
21532}
21533
21534type OxmIdTunMetadata17Masked struct {
21535 *OxmId
21536}
21537
21538type IOxmIdTunMetadata17Masked interface {
21539 IOxmId
21540}
21541
21542func (self *OxmIdTunMetadata17Masked) Serialize(encoder *goloxi.Encoder) error {
21543 if err := self.OxmId.Serialize(encoder); err != nil {
21544 return err
21545 }
21546
21547 return nil
21548}
21549
21550func DecodeOxmIdTunMetadata17Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata17Masked, error) {
21551 _oxmidtunmetadata17masked := &OxmIdTunMetadata17Masked{OxmId: parent}
21552 return _oxmidtunmetadata17masked, nil
21553}
21554
21555func NewOxmIdTunMetadata17Masked() *OxmIdTunMetadata17Masked {
21556 obj := &OxmIdTunMetadata17Masked{
21557 OxmId: NewOxmId(95224),
21558 }
21559 return obj
21560}
21561func (self *OxmIdTunMetadata17Masked) GetOXMName() string {
21562 return "tun_metadata17_masked"
21563}
21564
21565func (self *OxmIdTunMetadata17Masked) MarshalJSON() ([]byte, error) {
21566 if self.TypeLen == 0 {
21567 return []byte("\"\""), nil
21568 } else {
21569 return []byte("\"" + self.GetOXMName() + "\""), nil
21570 }
21571}
21572
21573type OxmIdTunMetadata18 struct {
21574 *OxmId
21575}
21576
21577type IOxmIdTunMetadata18 interface {
21578 IOxmId
21579}
21580
21581func (self *OxmIdTunMetadata18) Serialize(encoder *goloxi.Encoder) error {
21582 if err := self.OxmId.Serialize(encoder); err != nil {
21583 return err
21584 }
21585
21586 return nil
21587}
21588
21589func DecodeOxmIdTunMetadata18(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata18, error) {
21590 _oxmidtunmetadata18 := &OxmIdTunMetadata18{OxmId: parent}
21591 return _oxmidtunmetadata18, nil
21592}
21593
21594func NewOxmIdTunMetadata18() *OxmIdTunMetadata18 {
21595 obj := &OxmIdTunMetadata18{
21596 OxmId: NewOxmId(95356),
21597 }
21598 return obj
21599}
21600func (self *OxmIdTunMetadata18) GetOXMName() string {
21601 return "tun_metadata18"
21602}
21603
21604func (self *OxmIdTunMetadata18) MarshalJSON() ([]byte, error) {
21605 if self.TypeLen == 0 {
21606 return []byte("\"\""), nil
21607 } else {
21608 return []byte("\"" + self.GetOXMName() + "\""), nil
21609 }
21610}
21611
21612type OxmIdTunMetadata18Masked struct {
21613 *OxmId
21614}
21615
21616type IOxmIdTunMetadata18Masked interface {
21617 IOxmId
21618}
21619
21620func (self *OxmIdTunMetadata18Masked) Serialize(encoder *goloxi.Encoder) error {
21621 if err := self.OxmId.Serialize(encoder); err != nil {
21622 return err
21623 }
21624
21625 return nil
21626}
21627
21628func DecodeOxmIdTunMetadata18Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata18Masked, error) {
21629 _oxmidtunmetadata18masked := &OxmIdTunMetadata18Masked{OxmId: parent}
21630 return _oxmidtunmetadata18masked, nil
21631}
21632
21633func NewOxmIdTunMetadata18Masked() *OxmIdTunMetadata18Masked {
21634 obj := &OxmIdTunMetadata18Masked{
21635 OxmId: NewOxmId(95736),
21636 }
21637 return obj
21638}
21639func (self *OxmIdTunMetadata18Masked) GetOXMName() string {
21640 return "tun_metadata18_masked"
21641}
21642
21643func (self *OxmIdTunMetadata18Masked) MarshalJSON() ([]byte, error) {
21644 if self.TypeLen == 0 {
21645 return []byte("\"\""), nil
21646 } else {
21647 return []byte("\"" + self.GetOXMName() + "\""), nil
21648 }
21649}
21650
21651type OxmIdTunMetadata19 struct {
21652 *OxmId
21653}
21654
21655type IOxmIdTunMetadata19 interface {
21656 IOxmId
21657}
21658
21659func (self *OxmIdTunMetadata19) Serialize(encoder *goloxi.Encoder) error {
21660 if err := self.OxmId.Serialize(encoder); err != nil {
21661 return err
21662 }
21663
21664 return nil
21665}
21666
21667func DecodeOxmIdTunMetadata19(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata19, error) {
21668 _oxmidtunmetadata19 := &OxmIdTunMetadata19{OxmId: parent}
21669 return _oxmidtunmetadata19, nil
21670}
21671
21672func NewOxmIdTunMetadata19() *OxmIdTunMetadata19 {
21673 obj := &OxmIdTunMetadata19{
21674 OxmId: NewOxmId(95868),
21675 }
21676 return obj
21677}
21678func (self *OxmIdTunMetadata19) GetOXMName() string {
21679 return "tun_metadata19"
21680}
21681
21682func (self *OxmIdTunMetadata19) MarshalJSON() ([]byte, error) {
21683 if self.TypeLen == 0 {
21684 return []byte("\"\""), nil
21685 } else {
21686 return []byte("\"" + self.GetOXMName() + "\""), nil
21687 }
21688}
21689
21690type OxmIdTunMetadata19Masked struct {
21691 *OxmId
21692}
21693
21694type IOxmIdTunMetadata19Masked interface {
21695 IOxmId
21696}
21697
21698func (self *OxmIdTunMetadata19Masked) Serialize(encoder *goloxi.Encoder) error {
21699 if err := self.OxmId.Serialize(encoder); err != nil {
21700 return err
21701 }
21702
21703 return nil
21704}
21705
21706func DecodeOxmIdTunMetadata19Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata19Masked, error) {
21707 _oxmidtunmetadata19masked := &OxmIdTunMetadata19Masked{OxmId: parent}
21708 return _oxmidtunmetadata19masked, nil
21709}
21710
21711func NewOxmIdTunMetadata19Masked() *OxmIdTunMetadata19Masked {
21712 obj := &OxmIdTunMetadata19Masked{
21713 OxmId: NewOxmId(96248),
21714 }
21715 return obj
21716}
21717func (self *OxmIdTunMetadata19Masked) GetOXMName() string {
21718 return "tun_metadata19_masked"
21719}
21720
21721func (self *OxmIdTunMetadata19Masked) MarshalJSON() ([]byte, error) {
21722 if self.TypeLen == 0 {
21723 return []byte("\"\""), nil
21724 } else {
21725 return []byte("\"" + self.GetOXMName() + "\""), nil
21726 }
21727}
21728
21729type OxmIdTunMetadata1Masked struct {
21730 *OxmId
21731}
21732
21733type IOxmIdTunMetadata1Masked interface {
21734 IOxmId
21735}
21736
21737func (self *OxmIdTunMetadata1Masked) Serialize(encoder *goloxi.Encoder) error {
21738 if err := self.OxmId.Serialize(encoder); err != nil {
21739 return err
21740 }
21741
21742 return nil
21743}
21744
21745func DecodeOxmIdTunMetadata1Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata1Masked, error) {
21746 _oxmidtunmetadata1masked := &OxmIdTunMetadata1Masked{OxmId: parent}
21747 return _oxmidtunmetadata1masked, nil
21748}
21749
21750func NewOxmIdTunMetadata1Masked() *OxmIdTunMetadata1Masked {
21751 obj := &OxmIdTunMetadata1Masked{
21752 OxmId: NewOxmId(87032),
21753 }
21754 return obj
21755}
21756func (self *OxmIdTunMetadata1Masked) GetOXMName() string {
21757 return "tun_metadata1_masked"
21758}
21759
21760func (self *OxmIdTunMetadata1Masked) MarshalJSON() ([]byte, error) {
21761 if self.TypeLen == 0 {
21762 return []byte("\"\""), nil
21763 } else {
21764 return []byte("\"" + self.GetOXMName() + "\""), nil
21765 }
21766}
21767
21768type OxmIdTunMetadata2 struct {
21769 *OxmId
21770}
21771
21772type IOxmIdTunMetadata2 interface {
21773 IOxmId
21774}
21775
21776func (self *OxmIdTunMetadata2) Serialize(encoder *goloxi.Encoder) error {
21777 if err := self.OxmId.Serialize(encoder); err != nil {
21778 return err
21779 }
21780
21781 return nil
21782}
21783
21784func DecodeOxmIdTunMetadata2(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata2, error) {
21785 _oxmidtunmetadata2 := &OxmIdTunMetadata2{OxmId: parent}
21786 return _oxmidtunmetadata2, nil
21787}
21788
21789func NewOxmIdTunMetadata2() *OxmIdTunMetadata2 {
21790 obj := &OxmIdTunMetadata2{
21791 OxmId: NewOxmId(87164),
21792 }
21793 return obj
21794}
21795func (self *OxmIdTunMetadata2) GetOXMName() string {
21796 return "tun_metadata2"
21797}
21798
21799func (self *OxmIdTunMetadata2) MarshalJSON() ([]byte, error) {
21800 if self.TypeLen == 0 {
21801 return []byte("\"\""), nil
21802 } else {
21803 return []byte("\"" + self.GetOXMName() + "\""), nil
21804 }
21805}
21806
21807type OxmIdTunMetadata20 struct {
21808 *OxmId
21809}
21810
21811type IOxmIdTunMetadata20 interface {
21812 IOxmId
21813}
21814
21815func (self *OxmIdTunMetadata20) Serialize(encoder *goloxi.Encoder) error {
21816 if err := self.OxmId.Serialize(encoder); err != nil {
21817 return err
21818 }
21819
21820 return nil
21821}
21822
21823func DecodeOxmIdTunMetadata20(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata20, error) {
21824 _oxmidtunmetadata20 := &OxmIdTunMetadata20{OxmId: parent}
21825 return _oxmidtunmetadata20, nil
21826}
21827
21828func NewOxmIdTunMetadata20() *OxmIdTunMetadata20 {
21829 obj := &OxmIdTunMetadata20{
21830 OxmId: NewOxmId(96380),
21831 }
21832 return obj
21833}
21834func (self *OxmIdTunMetadata20) GetOXMName() string {
21835 return "tun_metadata20"
21836}
21837
21838func (self *OxmIdTunMetadata20) MarshalJSON() ([]byte, error) {
21839 if self.TypeLen == 0 {
21840 return []byte("\"\""), nil
21841 } else {
21842 return []byte("\"" + self.GetOXMName() + "\""), nil
21843 }
21844}
21845
21846type OxmIdTunMetadata20Masked struct {
21847 *OxmId
21848}
21849
21850type IOxmIdTunMetadata20Masked interface {
21851 IOxmId
21852}
21853
21854func (self *OxmIdTunMetadata20Masked) Serialize(encoder *goloxi.Encoder) error {
21855 if err := self.OxmId.Serialize(encoder); err != nil {
21856 return err
21857 }
21858
21859 return nil
21860}
21861
21862func DecodeOxmIdTunMetadata20Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata20Masked, error) {
21863 _oxmidtunmetadata20masked := &OxmIdTunMetadata20Masked{OxmId: parent}
21864 return _oxmidtunmetadata20masked, nil
21865}
21866
21867func NewOxmIdTunMetadata20Masked() *OxmIdTunMetadata20Masked {
21868 obj := &OxmIdTunMetadata20Masked{
21869 OxmId: NewOxmId(96760),
21870 }
21871 return obj
21872}
21873func (self *OxmIdTunMetadata20Masked) GetOXMName() string {
21874 return "tun_metadata20_masked"
21875}
21876
21877func (self *OxmIdTunMetadata20Masked) MarshalJSON() ([]byte, error) {
21878 if self.TypeLen == 0 {
21879 return []byte("\"\""), nil
21880 } else {
21881 return []byte("\"" + self.GetOXMName() + "\""), nil
21882 }
21883}
21884
21885type OxmIdTunMetadata21 struct {
21886 *OxmId
21887}
21888
21889type IOxmIdTunMetadata21 interface {
21890 IOxmId
21891}
21892
21893func (self *OxmIdTunMetadata21) Serialize(encoder *goloxi.Encoder) error {
21894 if err := self.OxmId.Serialize(encoder); err != nil {
21895 return err
21896 }
21897
21898 return nil
21899}
21900
21901func DecodeOxmIdTunMetadata21(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata21, error) {
21902 _oxmidtunmetadata21 := &OxmIdTunMetadata21{OxmId: parent}
21903 return _oxmidtunmetadata21, nil
21904}
21905
21906func NewOxmIdTunMetadata21() *OxmIdTunMetadata21 {
21907 obj := &OxmIdTunMetadata21{
21908 OxmId: NewOxmId(96892),
21909 }
21910 return obj
21911}
21912func (self *OxmIdTunMetadata21) GetOXMName() string {
21913 return "tun_metadata21"
21914}
21915
21916func (self *OxmIdTunMetadata21) MarshalJSON() ([]byte, error) {
21917 if self.TypeLen == 0 {
21918 return []byte("\"\""), nil
21919 } else {
21920 return []byte("\"" + self.GetOXMName() + "\""), nil
21921 }
21922}
21923
21924type OxmIdTunMetadata21Masked struct {
21925 *OxmId
21926}
21927
21928type IOxmIdTunMetadata21Masked interface {
21929 IOxmId
21930}
21931
21932func (self *OxmIdTunMetadata21Masked) Serialize(encoder *goloxi.Encoder) error {
21933 if err := self.OxmId.Serialize(encoder); err != nil {
21934 return err
21935 }
21936
21937 return nil
21938}
21939
21940func DecodeOxmIdTunMetadata21Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata21Masked, error) {
21941 _oxmidtunmetadata21masked := &OxmIdTunMetadata21Masked{OxmId: parent}
21942 return _oxmidtunmetadata21masked, nil
21943}
21944
21945func NewOxmIdTunMetadata21Masked() *OxmIdTunMetadata21Masked {
21946 obj := &OxmIdTunMetadata21Masked{
21947 OxmId: NewOxmId(97272),
21948 }
21949 return obj
21950}
21951func (self *OxmIdTunMetadata21Masked) GetOXMName() string {
21952 return "tun_metadata21_masked"
21953}
21954
21955func (self *OxmIdTunMetadata21Masked) MarshalJSON() ([]byte, error) {
21956 if self.TypeLen == 0 {
21957 return []byte("\"\""), nil
21958 } else {
21959 return []byte("\"" + self.GetOXMName() + "\""), nil
21960 }
21961}
21962
21963type OxmIdTunMetadata22 struct {
21964 *OxmId
21965}
21966
21967type IOxmIdTunMetadata22 interface {
21968 IOxmId
21969}
21970
21971func (self *OxmIdTunMetadata22) Serialize(encoder *goloxi.Encoder) error {
21972 if err := self.OxmId.Serialize(encoder); err != nil {
21973 return err
21974 }
21975
21976 return nil
21977}
21978
21979func DecodeOxmIdTunMetadata22(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata22, error) {
21980 _oxmidtunmetadata22 := &OxmIdTunMetadata22{OxmId: parent}
21981 return _oxmidtunmetadata22, nil
21982}
21983
21984func NewOxmIdTunMetadata22() *OxmIdTunMetadata22 {
21985 obj := &OxmIdTunMetadata22{
21986 OxmId: NewOxmId(97404),
21987 }
21988 return obj
21989}
21990func (self *OxmIdTunMetadata22) GetOXMName() string {
21991 return "tun_metadata22"
21992}
21993
21994func (self *OxmIdTunMetadata22) MarshalJSON() ([]byte, error) {
21995 if self.TypeLen == 0 {
21996 return []byte("\"\""), nil
21997 } else {
21998 return []byte("\"" + self.GetOXMName() + "\""), nil
21999 }
22000}
22001
22002type OxmIdTunMetadata22Masked struct {
22003 *OxmId
22004}
22005
22006type IOxmIdTunMetadata22Masked interface {
22007 IOxmId
22008}
22009
22010func (self *OxmIdTunMetadata22Masked) Serialize(encoder *goloxi.Encoder) error {
22011 if err := self.OxmId.Serialize(encoder); err != nil {
22012 return err
22013 }
22014
22015 return nil
22016}
22017
22018func DecodeOxmIdTunMetadata22Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata22Masked, error) {
22019 _oxmidtunmetadata22masked := &OxmIdTunMetadata22Masked{OxmId: parent}
22020 return _oxmidtunmetadata22masked, nil
22021}
22022
22023func NewOxmIdTunMetadata22Masked() *OxmIdTunMetadata22Masked {
22024 obj := &OxmIdTunMetadata22Masked{
22025 OxmId: NewOxmId(97784),
22026 }
22027 return obj
22028}
22029func (self *OxmIdTunMetadata22Masked) GetOXMName() string {
22030 return "tun_metadata22_masked"
22031}
22032
22033func (self *OxmIdTunMetadata22Masked) MarshalJSON() ([]byte, error) {
22034 if self.TypeLen == 0 {
22035 return []byte("\"\""), nil
22036 } else {
22037 return []byte("\"" + self.GetOXMName() + "\""), nil
22038 }
22039}
22040
22041type OxmIdTunMetadata23 struct {
22042 *OxmId
22043}
22044
22045type IOxmIdTunMetadata23 interface {
22046 IOxmId
22047}
22048
22049func (self *OxmIdTunMetadata23) Serialize(encoder *goloxi.Encoder) error {
22050 if err := self.OxmId.Serialize(encoder); err != nil {
22051 return err
22052 }
22053
22054 return nil
22055}
22056
22057func DecodeOxmIdTunMetadata23(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata23, error) {
22058 _oxmidtunmetadata23 := &OxmIdTunMetadata23{OxmId: parent}
22059 return _oxmidtunmetadata23, nil
22060}
22061
22062func NewOxmIdTunMetadata23() *OxmIdTunMetadata23 {
22063 obj := &OxmIdTunMetadata23{
22064 OxmId: NewOxmId(97916),
22065 }
22066 return obj
22067}
22068func (self *OxmIdTunMetadata23) GetOXMName() string {
22069 return "tun_metadata23"
22070}
22071
22072func (self *OxmIdTunMetadata23) MarshalJSON() ([]byte, error) {
22073 if self.TypeLen == 0 {
22074 return []byte("\"\""), nil
22075 } else {
22076 return []byte("\"" + self.GetOXMName() + "\""), nil
22077 }
22078}
22079
22080type OxmIdTunMetadata23Masked struct {
22081 *OxmId
22082}
22083
22084type IOxmIdTunMetadata23Masked interface {
22085 IOxmId
22086}
22087
22088func (self *OxmIdTunMetadata23Masked) Serialize(encoder *goloxi.Encoder) error {
22089 if err := self.OxmId.Serialize(encoder); err != nil {
22090 return err
22091 }
22092
22093 return nil
22094}
22095
22096func DecodeOxmIdTunMetadata23Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata23Masked, error) {
22097 _oxmidtunmetadata23masked := &OxmIdTunMetadata23Masked{OxmId: parent}
22098 return _oxmidtunmetadata23masked, nil
22099}
22100
22101func NewOxmIdTunMetadata23Masked() *OxmIdTunMetadata23Masked {
22102 obj := &OxmIdTunMetadata23Masked{
22103 OxmId: NewOxmId(98296),
22104 }
22105 return obj
22106}
22107func (self *OxmIdTunMetadata23Masked) GetOXMName() string {
22108 return "tun_metadata23_masked"
22109}
22110
22111func (self *OxmIdTunMetadata23Masked) MarshalJSON() ([]byte, error) {
22112 if self.TypeLen == 0 {
22113 return []byte("\"\""), nil
22114 } else {
22115 return []byte("\"" + self.GetOXMName() + "\""), nil
22116 }
22117}
22118
22119type OxmIdTunMetadata24 struct {
22120 *OxmId
22121}
22122
22123type IOxmIdTunMetadata24 interface {
22124 IOxmId
22125}
22126
22127func (self *OxmIdTunMetadata24) Serialize(encoder *goloxi.Encoder) error {
22128 if err := self.OxmId.Serialize(encoder); err != nil {
22129 return err
22130 }
22131
22132 return nil
22133}
22134
22135func DecodeOxmIdTunMetadata24(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata24, error) {
22136 _oxmidtunmetadata24 := &OxmIdTunMetadata24{OxmId: parent}
22137 return _oxmidtunmetadata24, nil
22138}
22139
22140func NewOxmIdTunMetadata24() *OxmIdTunMetadata24 {
22141 obj := &OxmIdTunMetadata24{
22142 OxmId: NewOxmId(98428),
22143 }
22144 return obj
22145}
22146func (self *OxmIdTunMetadata24) GetOXMName() string {
22147 return "tun_metadata24"
22148}
22149
22150func (self *OxmIdTunMetadata24) MarshalJSON() ([]byte, error) {
22151 if self.TypeLen == 0 {
22152 return []byte("\"\""), nil
22153 } else {
22154 return []byte("\"" + self.GetOXMName() + "\""), nil
22155 }
22156}
22157
22158type OxmIdTunMetadata24Masked struct {
22159 *OxmId
22160}
22161
22162type IOxmIdTunMetadata24Masked interface {
22163 IOxmId
22164}
22165
22166func (self *OxmIdTunMetadata24Masked) Serialize(encoder *goloxi.Encoder) error {
22167 if err := self.OxmId.Serialize(encoder); err != nil {
22168 return err
22169 }
22170
22171 return nil
22172}
22173
22174func DecodeOxmIdTunMetadata24Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata24Masked, error) {
22175 _oxmidtunmetadata24masked := &OxmIdTunMetadata24Masked{OxmId: parent}
22176 return _oxmidtunmetadata24masked, nil
22177}
22178
22179func NewOxmIdTunMetadata24Masked() *OxmIdTunMetadata24Masked {
22180 obj := &OxmIdTunMetadata24Masked{
22181 OxmId: NewOxmId(98808),
22182 }
22183 return obj
22184}
22185func (self *OxmIdTunMetadata24Masked) GetOXMName() string {
22186 return "tun_metadata24_masked"
22187}
22188
22189func (self *OxmIdTunMetadata24Masked) MarshalJSON() ([]byte, error) {
22190 if self.TypeLen == 0 {
22191 return []byte("\"\""), nil
22192 } else {
22193 return []byte("\"" + self.GetOXMName() + "\""), nil
22194 }
22195}
22196
22197type OxmIdTunMetadata25 struct {
22198 *OxmId
22199}
22200
22201type IOxmIdTunMetadata25 interface {
22202 IOxmId
22203}
22204
22205func (self *OxmIdTunMetadata25) Serialize(encoder *goloxi.Encoder) error {
22206 if err := self.OxmId.Serialize(encoder); err != nil {
22207 return err
22208 }
22209
22210 return nil
22211}
22212
22213func DecodeOxmIdTunMetadata25(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata25, error) {
22214 _oxmidtunmetadata25 := &OxmIdTunMetadata25{OxmId: parent}
22215 return _oxmidtunmetadata25, nil
22216}
22217
22218func NewOxmIdTunMetadata25() *OxmIdTunMetadata25 {
22219 obj := &OxmIdTunMetadata25{
22220 OxmId: NewOxmId(98940),
22221 }
22222 return obj
22223}
22224func (self *OxmIdTunMetadata25) GetOXMName() string {
22225 return "tun_metadata25"
22226}
22227
22228func (self *OxmIdTunMetadata25) MarshalJSON() ([]byte, error) {
22229 if self.TypeLen == 0 {
22230 return []byte("\"\""), nil
22231 } else {
22232 return []byte("\"" + self.GetOXMName() + "\""), nil
22233 }
22234}
22235
22236type OxmIdTunMetadata25Masked struct {
22237 *OxmId
22238}
22239
22240type IOxmIdTunMetadata25Masked interface {
22241 IOxmId
22242}
22243
22244func (self *OxmIdTunMetadata25Masked) Serialize(encoder *goloxi.Encoder) error {
22245 if err := self.OxmId.Serialize(encoder); err != nil {
22246 return err
22247 }
22248
22249 return nil
22250}
22251
22252func DecodeOxmIdTunMetadata25Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata25Masked, error) {
22253 _oxmidtunmetadata25masked := &OxmIdTunMetadata25Masked{OxmId: parent}
22254 return _oxmidtunmetadata25masked, nil
22255}
22256
22257func NewOxmIdTunMetadata25Masked() *OxmIdTunMetadata25Masked {
22258 obj := &OxmIdTunMetadata25Masked{
22259 OxmId: NewOxmId(99320),
22260 }
22261 return obj
22262}
22263func (self *OxmIdTunMetadata25Masked) GetOXMName() string {
22264 return "tun_metadata25_masked"
22265}
22266
22267func (self *OxmIdTunMetadata25Masked) MarshalJSON() ([]byte, error) {
22268 if self.TypeLen == 0 {
22269 return []byte("\"\""), nil
22270 } else {
22271 return []byte("\"" + self.GetOXMName() + "\""), nil
22272 }
22273}
22274
22275type OxmIdTunMetadata26 struct {
22276 *OxmId
22277}
22278
22279type IOxmIdTunMetadata26 interface {
22280 IOxmId
22281}
22282
22283func (self *OxmIdTunMetadata26) Serialize(encoder *goloxi.Encoder) error {
22284 if err := self.OxmId.Serialize(encoder); err != nil {
22285 return err
22286 }
22287
22288 return nil
22289}
22290
22291func DecodeOxmIdTunMetadata26(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata26, error) {
22292 _oxmidtunmetadata26 := &OxmIdTunMetadata26{OxmId: parent}
22293 return _oxmidtunmetadata26, nil
22294}
22295
22296func NewOxmIdTunMetadata26() *OxmIdTunMetadata26 {
22297 obj := &OxmIdTunMetadata26{
22298 OxmId: NewOxmId(99452),
22299 }
22300 return obj
22301}
22302func (self *OxmIdTunMetadata26) GetOXMName() string {
22303 return "tun_metadata26"
22304}
22305
22306func (self *OxmIdTunMetadata26) MarshalJSON() ([]byte, error) {
22307 if self.TypeLen == 0 {
22308 return []byte("\"\""), nil
22309 } else {
22310 return []byte("\"" + self.GetOXMName() + "\""), nil
22311 }
22312}
22313
22314type OxmIdTunMetadata26Masked struct {
22315 *OxmId
22316}
22317
22318type IOxmIdTunMetadata26Masked interface {
22319 IOxmId
22320}
22321
22322func (self *OxmIdTunMetadata26Masked) Serialize(encoder *goloxi.Encoder) error {
22323 if err := self.OxmId.Serialize(encoder); err != nil {
22324 return err
22325 }
22326
22327 return nil
22328}
22329
22330func DecodeOxmIdTunMetadata26Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata26Masked, error) {
22331 _oxmidtunmetadata26masked := &OxmIdTunMetadata26Masked{OxmId: parent}
22332 return _oxmidtunmetadata26masked, nil
22333}
22334
22335func NewOxmIdTunMetadata26Masked() *OxmIdTunMetadata26Masked {
22336 obj := &OxmIdTunMetadata26Masked{
22337 OxmId: NewOxmId(99832),
22338 }
22339 return obj
22340}
22341func (self *OxmIdTunMetadata26Masked) GetOXMName() string {
22342 return "tun_metadata26_masked"
22343}
22344
22345func (self *OxmIdTunMetadata26Masked) MarshalJSON() ([]byte, error) {
22346 if self.TypeLen == 0 {
22347 return []byte("\"\""), nil
22348 } else {
22349 return []byte("\"" + self.GetOXMName() + "\""), nil
22350 }
22351}
22352
22353type OxmIdTunMetadata27 struct {
22354 *OxmId
22355}
22356
22357type IOxmIdTunMetadata27 interface {
22358 IOxmId
22359}
22360
22361func (self *OxmIdTunMetadata27) Serialize(encoder *goloxi.Encoder) error {
22362 if err := self.OxmId.Serialize(encoder); err != nil {
22363 return err
22364 }
22365
22366 return nil
22367}
22368
22369func DecodeOxmIdTunMetadata27(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata27, error) {
22370 _oxmidtunmetadata27 := &OxmIdTunMetadata27{OxmId: parent}
22371 return _oxmidtunmetadata27, nil
22372}
22373
22374func NewOxmIdTunMetadata27() *OxmIdTunMetadata27 {
22375 obj := &OxmIdTunMetadata27{
22376 OxmId: NewOxmId(99964),
22377 }
22378 return obj
22379}
22380func (self *OxmIdTunMetadata27) GetOXMName() string {
22381 return "tun_metadata27"
22382}
22383
22384func (self *OxmIdTunMetadata27) MarshalJSON() ([]byte, error) {
22385 if self.TypeLen == 0 {
22386 return []byte("\"\""), nil
22387 } else {
22388 return []byte("\"" + self.GetOXMName() + "\""), nil
22389 }
22390}
22391
22392type OxmIdTunMetadata27Masked struct {
22393 *OxmId
22394}
22395
22396type IOxmIdTunMetadata27Masked interface {
22397 IOxmId
22398}
22399
22400func (self *OxmIdTunMetadata27Masked) Serialize(encoder *goloxi.Encoder) error {
22401 if err := self.OxmId.Serialize(encoder); err != nil {
22402 return err
22403 }
22404
22405 return nil
22406}
22407
22408func DecodeOxmIdTunMetadata27Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata27Masked, error) {
22409 _oxmidtunmetadata27masked := &OxmIdTunMetadata27Masked{OxmId: parent}
22410 return _oxmidtunmetadata27masked, nil
22411}
22412
22413func NewOxmIdTunMetadata27Masked() *OxmIdTunMetadata27Masked {
22414 obj := &OxmIdTunMetadata27Masked{
22415 OxmId: NewOxmId(100344),
22416 }
22417 return obj
22418}
22419func (self *OxmIdTunMetadata27Masked) GetOXMName() string {
22420 return "tun_metadata27_masked"
22421}
22422
22423func (self *OxmIdTunMetadata27Masked) MarshalJSON() ([]byte, error) {
22424 if self.TypeLen == 0 {
22425 return []byte("\"\""), nil
22426 } else {
22427 return []byte("\"" + self.GetOXMName() + "\""), nil
22428 }
22429}
22430
22431type OxmIdTunMetadata28 struct {
22432 *OxmId
22433}
22434
22435type IOxmIdTunMetadata28 interface {
22436 IOxmId
22437}
22438
22439func (self *OxmIdTunMetadata28) Serialize(encoder *goloxi.Encoder) error {
22440 if err := self.OxmId.Serialize(encoder); err != nil {
22441 return err
22442 }
22443
22444 return nil
22445}
22446
22447func DecodeOxmIdTunMetadata28(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata28, error) {
22448 _oxmidtunmetadata28 := &OxmIdTunMetadata28{OxmId: parent}
22449 return _oxmidtunmetadata28, nil
22450}
22451
22452func NewOxmIdTunMetadata28() *OxmIdTunMetadata28 {
22453 obj := &OxmIdTunMetadata28{
22454 OxmId: NewOxmId(100476),
22455 }
22456 return obj
22457}
22458func (self *OxmIdTunMetadata28) GetOXMName() string {
22459 return "tun_metadata28"
22460}
22461
22462func (self *OxmIdTunMetadata28) MarshalJSON() ([]byte, error) {
22463 if self.TypeLen == 0 {
22464 return []byte("\"\""), nil
22465 } else {
22466 return []byte("\"" + self.GetOXMName() + "\""), nil
22467 }
22468}
22469
22470type OxmIdTunMetadata28Masked struct {
22471 *OxmId
22472}
22473
22474type IOxmIdTunMetadata28Masked interface {
22475 IOxmId
22476}
22477
22478func (self *OxmIdTunMetadata28Masked) Serialize(encoder *goloxi.Encoder) error {
22479 if err := self.OxmId.Serialize(encoder); err != nil {
22480 return err
22481 }
22482
22483 return nil
22484}
22485
22486func DecodeOxmIdTunMetadata28Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata28Masked, error) {
22487 _oxmidtunmetadata28masked := &OxmIdTunMetadata28Masked{OxmId: parent}
22488 return _oxmidtunmetadata28masked, nil
22489}
22490
22491func NewOxmIdTunMetadata28Masked() *OxmIdTunMetadata28Masked {
22492 obj := &OxmIdTunMetadata28Masked{
22493 OxmId: NewOxmId(100856),
22494 }
22495 return obj
22496}
22497func (self *OxmIdTunMetadata28Masked) GetOXMName() string {
22498 return "tun_metadata28_masked"
22499}
22500
22501func (self *OxmIdTunMetadata28Masked) MarshalJSON() ([]byte, error) {
22502 if self.TypeLen == 0 {
22503 return []byte("\"\""), nil
22504 } else {
22505 return []byte("\"" + self.GetOXMName() + "\""), nil
22506 }
22507}
22508
22509type OxmIdTunMetadata29 struct {
22510 *OxmId
22511}
22512
22513type IOxmIdTunMetadata29 interface {
22514 IOxmId
22515}
22516
22517func (self *OxmIdTunMetadata29) Serialize(encoder *goloxi.Encoder) error {
22518 if err := self.OxmId.Serialize(encoder); err != nil {
22519 return err
22520 }
22521
22522 return nil
22523}
22524
22525func DecodeOxmIdTunMetadata29(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata29, error) {
22526 _oxmidtunmetadata29 := &OxmIdTunMetadata29{OxmId: parent}
22527 return _oxmidtunmetadata29, nil
22528}
22529
22530func NewOxmIdTunMetadata29() *OxmIdTunMetadata29 {
22531 obj := &OxmIdTunMetadata29{
22532 OxmId: NewOxmId(100988),
22533 }
22534 return obj
22535}
22536func (self *OxmIdTunMetadata29) GetOXMName() string {
22537 return "tun_metadata29"
22538}
22539
22540func (self *OxmIdTunMetadata29) MarshalJSON() ([]byte, error) {
22541 if self.TypeLen == 0 {
22542 return []byte("\"\""), nil
22543 } else {
22544 return []byte("\"" + self.GetOXMName() + "\""), nil
22545 }
22546}
22547
22548type OxmIdTunMetadata29Masked struct {
22549 *OxmId
22550}
22551
22552type IOxmIdTunMetadata29Masked interface {
22553 IOxmId
22554}
22555
22556func (self *OxmIdTunMetadata29Masked) Serialize(encoder *goloxi.Encoder) error {
22557 if err := self.OxmId.Serialize(encoder); err != nil {
22558 return err
22559 }
22560
22561 return nil
22562}
22563
22564func DecodeOxmIdTunMetadata29Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata29Masked, error) {
22565 _oxmidtunmetadata29masked := &OxmIdTunMetadata29Masked{OxmId: parent}
22566 return _oxmidtunmetadata29masked, nil
22567}
22568
22569func NewOxmIdTunMetadata29Masked() *OxmIdTunMetadata29Masked {
22570 obj := &OxmIdTunMetadata29Masked{
22571 OxmId: NewOxmId(101368),
22572 }
22573 return obj
22574}
22575func (self *OxmIdTunMetadata29Masked) GetOXMName() string {
22576 return "tun_metadata29_masked"
22577}
22578
22579func (self *OxmIdTunMetadata29Masked) MarshalJSON() ([]byte, error) {
22580 if self.TypeLen == 0 {
22581 return []byte("\"\""), nil
22582 } else {
22583 return []byte("\"" + self.GetOXMName() + "\""), nil
22584 }
22585}
22586
22587type OxmIdTunMetadata2Masked struct {
22588 *OxmId
22589}
22590
22591type IOxmIdTunMetadata2Masked interface {
22592 IOxmId
22593}
22594
22595func (self *OxmIdTunMetadata2Masked) Serialize(encoder *goloxi.Encoder) error {
22596 if err := self.OxmId.Serialize(encoder); err != nil {
22597 return err
22598 }
22599
22600 return nil
22601}
22602
22603func DecodeOxmIdTunMetadata2Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata2Masked, error) {
22604 _oxmidtunmetadata2masked := &OxmIdTunMetadata2Masked{OxmId: parent}
22605 return _oxmidtunmetadata2masked, nil
22606}
22607
22608func NewOxmIdTunMetadata2Masked() *OxmIdTunMetadata2Masked {
22609 obj := &OxmIdTunMetadata2Masked{
22610 OxmId: NewOxmId(87544),
22611 }
22612 return obj
22613}
22614func (self *OxmIdTunMetadata2Masked) GetOXMName() string {
22615 return "tun_metadata2_masked"
22616}
22617
22618func (self *OxmIdTunMetadata2Masked) MarshalJSON() ([]byte, error) {
22619 if self.TypeLen == 0 {
22620 return []byte("\"\""), nil
22621 } else {
22622 return []byte("\"" + self.GetOXMName() + "\""), nil
22623 }
22624}
22625
22626type OxmIdTunMetadata3 struct {
22627 *OxmId
22628}
22629
22630type IOxmIdTunMetadata3 interface {
22631 IOxmId
22632}
22633
22634func (self *OxmIdTunMetadata3) Serialize(encoder *goloxi.Encoder) error {
22635 if err := self.OxmId.Serialize(encoder); err != nil {
22636 return err
22637 }
22638
22639 return nil
22640}
22641
22642func DecodeOxmIdTunMetadata3(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata3, error) {
22643 _oxmidtunmetadata3 := &OxmIdTunMetadata3{OxmId: parent}
22644 return _oxmidtunmetadata3, nil
22645}
22646
22647func NewOxmIdTunMetadata3() *OxmIdTunMetadata3 {
22648 obj := &OxmIdTunMetadata3{
22649 OxmId: NewOxmId(87676),
22650 }
22651 return obj
22652}
22653func (self *OxmIdTunMetadata3) GetOXMName() string {
22654 return "tun_metadata3"
22655}
22656
22657func (self *OxmIdTunMetadata3) MarshalJSON() ([]byte, error) {
22658 if self.TypeLen == 0 {
22659 return []byte("\"\""), nil
22660 } else {
22661 return []byte("\"" + self.GetOXMName() + "\""), nil
22662 }
22663}
22664
22665type OxmIdTunMetadata30 struct {
22666 *OxmId
22667}
22668
22669type IOxmIdTunMetadata30 interface {
22670 IOxmId
22671}
22672
22673func (self *OxmIdTunMetadata30) Serialize(encoder *goloxi.Encoder) error {
22674 if err := self.OxmId.Serialize(encoder); err != nil {
22675 return err
22676 }
22677
22678 return nil
22679}
22680
22681func DecodeOxmIdTunMetadata30(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata30, error) {
22682 _oxmidtunmetadata30 := &OxmIdTunMetadata30{OxmId: parent}
22683 return _oxmidtunmetadata30, nil
22684}
22685
22686func NewOxmIdTunMetadata30() *OxmIdTunMetadata30 {
22687 obj := &OxmIdTunMetadata30{
22688 OxmId: NewOxmId(101500),
22689 }
22690 return obj
22691}
22692func (self *OxmIdTunMetadata30) GetOXMName() string {
22693 return "tun_metadata30"
22694}
22695
22696func (self *OxmIdTunMetadata30) MarshalJSON() ([]byte, error) {
22697 if self.TypeLen == 0 {
22698 return []byte("\"\""), nil
22699 } else {
22700 return []byte("\"" + self.GetOXMName() + "\""), nil
22701 }
22702}
22703
22704type OxmIdTunMetadata30Masked struct {
22705 *OxmId
22706}
22707
22708type IOxmIdTunMetadata30Masked interface {
22709 IOxmId
22710}
22711
22712func (self *OxmIdTunMetadata30Masked) Serialize(encoder *goloxi.Encoder) error {
22713 if err := self.OxmId.Serialize(encoder); err != nil {
22714 return err
22715 }
22716
22717 return nil
22718}
22719
22720func DecodeOxmIdTunMetadata30Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata30Masked, error) {
22721 _oxmidtunmetadata30masked := &OxmIdTunMetadata30Masked{OxmId: parent}
22722 return _oxmidtunmetadata30masked, nil
22723}
22724
22725func NewOxmIdTunMetadata30Masked() *OxmIdTunMetadata30Masked {
22726 obj := &OxmIdTunMetadata30Masked{
22727 OxmId: NewOxmId(101880),
22728 }
22729 return obj
22730}
22731func (self *OxmIdTunMetadata30Masked) GetOXMName() string {
22732 return "tun_metadata30_masked"
22733}
22734
22735func (self *OxmIdTunMetadata30Masked) MarshalJSON() ([]byte, error) {
22736 if self.TypeLen == 0 {
22737 return []byte("\"\""), nil
22738 } else {
22739 return []byte("\"" + self.GetOXMName() + "\""), nil
22740 }
22741}
22742
22743type OxmIdTunMetadata31 struct {
22744 *OxmId
22745}
22746
22747type IOxmIdTunMetadata31 interface {
22748 IOxmId
22749}
22750
22751func (self *OxmIdTunMetadata31) Serialize(encoder *goloxi.Encoder) error {
22752 if err := self.OxmId.Serialize(encoder); err != nil {
22753 return err
22754 }
22755
22756 return nil
22757}
22758
22759func DecodeOxmIdTunMetadata31(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata31, error) {
22760 _oxmidtunmetadata31 := &OxmIdTunMetadata31{OxmId: parent}
22761 return _oxmidtunmetadata31, nil
22762}
22763
22764func NewOxmIdTunMetadata31() *OxmIdTunMetadata31 {
22765 obj := &OxmIdTunMetadata31{
22766 OxmId: NewOxmId(102012),
22767 }
22768 return obj
22769}
22770func (self *OxmIdTunMetadata31) GetOXMName() string {
22771 return "tun_metadata31"
22772}
22773
22774func (self *OxmIdTunMetadata31) MarshalJSON() ([]byte, error) {
22775 if self.TypeLen == 0 {
22776 return []byte("\"\""), nil
22777 } else {
22778 return []byte("\"" + self.GetOXMName() + "\""), nil
22779 }
22780}
22781
22782type OxmIdTunMetadata31Masked struct {
22783 *OxmId
22784}
22785
22786type IOxmIdTunMetadata31Masked interface {
22787 IOxmId
22788}
22789
22790func (self *OxmIdTunMetadata31Masked) Serialize(encoder *goloxi.Encoder) error {
22791 if err := self.OxmId.Serialize(encoder); err != nil {
22792 return err
22793 }
22794
22795 return nil
22796}
22797
22798func DecodeOxmIdTunMetadata31Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata31Masked, error) {
22799 _oxmidtunmetadata31masked := &OxmIdTunMetadata31Masked{OxmId: parent}
22800 return _oxmidtunmetadata31masked, nil
22801}
22802
22803func NewOxmIdTunMetadata31Masked() *OxmIdTunMetadata31Masked {
22804 obj := &OxmIdTunMetadata31Masked{
22805 OxmId: NewOxmId(102392),
22806 }
22807 return obj
22808}
22809func (self *OxmIdTunMetadata31Masked) GetOXMName() string {
22810 return "tun_metadata31_masked"
22811}
22812
22813func (self *OxmIdTunMetadata31Masked) MarshalJSON() ([]byte, error) {
22814 if self.TypeLen == 0 {
22815 return []byte("\"\""), nil
22816 } else {
22817 return []byte("\"" + self.GetOXMName() + "\""), nil
22818 }
22819}
22820
22821type OxmIdTunMetadata32 struct {
22822 *OxmId
22823}
22824
22825type IOxmIdTunMetadata32 interface {
22826 IOxmId
22827}
22828
22829func (self *OxmIdTunMetadata32) Serialize(encoder *goloxi.Encoder) error {
22830 if err := self.OxmId.Serialize(encoder); err != nil {
22831 return err
22832 }
22833
22834 return nil
22835}
22836
22837func DecodeOxmIdTunMetadata32(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata32, error) {
22838 _oxmidtunmetadata32 := &OxmIdTunMetadata32{OxmId: parent}
22839 return _oxmidtunmetadata32, nil
22840}
22841
22842func NewOxmIdTunMetadata32() *OxmIdTunMetadata32 {
22843 obj := &OxmIdTunMetadata32{
22844 OxmId: NewOxmId(102524),
22845 }
22846 return obj
22847}
22848func (self *OxmIdTunMetadata32) GetOXMName() string {
22849 return "tun_metadata32"
22850}
22851
22852func (self *OxmIdTunMetadata32) MarshalJSON() ([]byte, error) {
22853 if self.TypeLen == 0 {
22854 return []byte("\"\""), nil
22855 } else {
22856 return []byte("\"" + self.GetOXMName() + "\""), nil
22857 }
22858}
22859
22860type OxmIdTunMetadata32Masked struct {
22861 *OxmId
22862}
22863
22864type IOxmIdTunMetadata32Masked interface {
22865 IOxmId
22866}
22867
22868func (self *OxmIdTunMetadata32Masked) Serialize(encoder *goloxi.Encoder) error {
22869 if err := self.OxmId.Serialize(encoder); err != nil {
22870 return err
22871 }
22872
22873 return nil
22874}
22875
22876func DecodeOxmIdTunMetadata32Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata32Masked, error) {
22877 _oxmidtunmetadata32masked := &OxmIdTunMetadata32Masked{OxmId: parent}
22878 return _oxmidtunmetadata32masked, nil
22879}
22880
22881func NewOxmIdTunMetadata32Masked() *OxmIdTunMetadata32Masked {
22882 obj := &OxmIdTunMetadata32Masked{
22883 OxmId: NewOxmId(102904),
22884 }
22885 return obj
22886}
22887func (self *OxmIdTunMetadata32Masked) GetOXMName() string {
22888 return "tun_metadata32_masked"
22889}
22890
22891func (self *OxmIdTunMetadata32Masked) MarshalJSON() ([]byte, error) {
22892 if self.TypeLen == 0 {
22893 return []byte("\"\""), nil
22894 } else {
22895 return []byte("\"" + self.GetOXMName() + "\""), nil
22896 }
22897}
22898
22899type OxmIdTunMetadata33 struct {
22900 *OxmId
22901}
22902
22903type IOxmIdTunMetadata33 interface {
22904 IOxmId
22905}
22906
22907func (self *OxmIdTunMetadata33) Serialize(encoder *goloxi.Encoder) error {
22908 if err := self.OxmId.Serialize(encoder); err != nil {
22909 return err
22910 }
22911
22912 return nil
22913}
22914
22915func DecodeOxmIdTunMetadata33(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata33, error) {
22916 _oxmidtunmetadata33 := &OxmIdTunMetadata33{OxmId: parent}
22917 return _oxmidtunmetadata33, nil
22918}
22919
22920func NewOxmIdTunMetadata33() *OxmIdTunMetadata33 {
22921 obj := &OxmIdTunMetadata33{
22922 OxmId: NewOxmId(103036),
22923 }
22924 return obj
22925}
22926func (self *OxmIdTunMetadata33) GetOXMName() string {
22927 return "tun_metadata33"
22928}
22929
22930func (self *OxmIdTunMetadata33) MarshalJSON() ([]byte, error) {
22931 if self.TypeLen == 0 {
22932 return []byte("\"\""), nil
22933 } else {
22934 return []byte("\"" + self.GetOXMName() + "\""), nil
22935 }
22936}
22937
22938type OxmIdTunMetadata33Masked struct {
22939 *OxmId
22940}
22941
22942type IOxmIdTunMetadata33Masked interface {
22943 IOxmId
22944}
22945
22946func (self *OxmIdTunMetadata33Masked) Serialize(encoder *goloxi.Encoder) error {
22947 if err := self.OxmId.Serialize(encoder); err != nil {
22948 return err
22949 }
22950
22951 return nil
22952}
22953
22954func DecodeOxmIdTunMetadata33Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata33Masked, error) {
22955 _oxmidtunmetadata33masked := &OxmIdTunMetadata33Masked{OxmId: parent}
22956 return _oxmidtunmetadata33masked, nil
22957}
22958
22959func NewOxmIdTunMetadata33Masked() *OxmIdTunMetadata33Masked {
22960 obj := &OxmIdTunMetadata33Masked{
22961 OxmId: NewOxmId(103416),
22962 }
22963 return obj
22964}
22965func (self *OxmIdTunMetadata33Masked) GetOXMName() string {
22966 return "tun_metadata33_masked"
22967}
22968
22969func (self *OxmIdTunMetadata33Masked) MarshalJSON() ([]byte, error) {
22970 if self.TypeLen == 0 {
22971 return []byte("\"\""), nil
22972 } else {
22973 return []byte("\"" + self.GetOXMName() + "\""), nil
22974 }
22975}
22976
22977type OxmIdTunMetadata34 struct {
22978 *OxmId
22979}
22980
22981type IOxmIdTunMetadata34 interface {
22982 IOxmId
22983}
22984
22985func (self *OxmIdTunMetadata34) Serialize(encoder *goloxi.Encoder) error {
22986 if err := self.OxmId.Serialize(encoder); err != nil {
22987 return err
22988 }
22989
22990 return nil
22991}
22992
22993func DecodeOxmIdTunMetadata34(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata34, error) {
22994 _oxmidtunmetadata34 := &OxmIdTunMetadata34{OxmId: parent}
22995 return _oxmidtunmetadata34, nil
22996}
22997
22998func NewOxmIdTunMetadata34() *OxmIdTunMetadata34 {
22999 obj := &OxmIdTunMetadata34{
23000 OxmId: NewOxmId(103548),
23001 }
23002 return obj
23003}
23004func (self *OxmIdTunMetadata34) GetOXMName() string {
23005 return "tun_metadata34"
23006}
23007
23008func (self *OxmIdTunMetadata34) MarshalJSON() ([]byte, error) {
23009 if self.TypeLen == 0 {
23010 return []byte("\"\""), nil
23011 } else {
23012 return []byte("\"" + self.GetOXMName() + "\""), nil
23013 }
23014}
23015
23016type OxmIdTunMetadata34Masked struct {
23017 *OxmId
23018}
23019
23020type IOxmIdTunMetadata34Masked interface {
23021 IOxmId
23022}
23023
23024func (self *OxmIdTunMetadata34Masked) Serialize(encoder *goloxi.Encoder) error {
23025 if err := self.OxmId.Serialize(encoder); err != nil {
23026 return err
23027 }
23028
23029 return nil
23030}
23031
23032func DecodeOxmIdTunMetadata34Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata34Masked, error) {
23033 _oxmidtunmetadata34masked := &OxmIdTunMetadata34Masked{OxmId: parent}
23034 return _oxmidtunmetadata34masked, nil
23035}
23036
23037func NewOxmIdTunMetadata34Masked() *OxmIdTunMetadata34Masked {
23038 obj := &OxmIdTunMetadata34Masked{
23039 OxmId: NewOxmId(103928),
23040 }
23041 return obj
23042}
23043func (self *OxmIdTunMetadata34Masked) GetOXMName() string {
23044 return "tun_metadata34_masked"
23045}
23046
23047func (self *OxmIdTunMetadata34Masked) MarshalJSON() ([]byte, error) {
23048 if self.TypeLen == 0 {
23049 return []byte("\"\""), nil
23050 } else {
23051 return []byte("\"" + self.GetOXMName() + "\""), nil
23052 }
23053}
23054
23055type OxmIdTunMetadata35 struct {
23056 *OxmId
23057}
23058
23059type IOxmIdTunMetadata35 interface {
23060 IOxmId
23061}
23062
23063func (self *OxmIdTunMetadata35) Serialize(encoder *goloxi.Encoder) error {
23064 if err := self.OxmId.Serialize(encoder); err != nil {
23065 return err
23066 }
23067
23068 return nil
23069}
23070
23071func DecodeOxmIdTunMetadata35(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata35, error) {
23072 _oxmidtunmetadata35 := &OxmIdTunMetadata35{OxmId: parent}
23073 return _oxmidtunmetadata35, nil
23074}
23075
23076func NewOxmIdTunMetadata35() *OxmIdTunMetadata35 {
23077 obj := &OxmIdTunMetadata35{
23078 OxmId: NewOxmId(104060),
23079 }
23080 return obj
23081}
23082func (self *OxmIdTunMetadata35) GetOXMName() string {
23083 return "tun_metadata35"
23084}
23085
23086func (self *OxmIdTunMetadata35) MarshalJSON() ([]byte, error) {
23087 if self.TypeLen == 0 {
23088 return []byte("\"\""), nil
23089 } else {
23090 return []byte("\"" + self.GetOXMName() + "\""), nil
23091 }
23092}
23093
23094type OxmIdTunMetadata35Masked struct {
23095 *OxmId
23096}
23097
23098type IOxmIdTunMetadata35Masked interface {
23099 IOxmId
23100}
23101
23102func (self *OxmIdTunMetadata35Masked) Serialize(encoder *goloxi.Encoder) error {
23103 if err := self.OxmId.Serialize(encoder); err != nil {
23104 return err
23105 }
23106
23107 return nil
23108}
23109
23110func DecodeOxmIdTunMetadata35Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata35Masked, error) {
23111 _oxmidtunmetadata35masked := &OxmIdTunMetadata35Masked{OxmId: parent}
23112 return _oxmidtunmetadata35masked, nil
23113}
23114
23115func NewOxmIdTunMetadata35Masked() *OxmIdTunMetadata35Masked {
23116 obj := &OxmIdTunMetadata35Masked{
23117 OxmId: NewOxmId(104440),
23118 }
23119 return obj
23120}
23121func (self *OxmIdTunMetadata35Masked) GetOXMName() string {
23122 return "tun_metadata35_masked"
23123}
23124
23125func (self *OxmIdTunMetadata35Masked) MarshalJSON() ([]byte, error) {
23126 if self.TypeLen == 0 {
23127 return []byte("\"\""), nil
23128 } else {
23129 return []byte("\"" + self.GetOXMName() + "\""), nil
23130 }
23131}
23132
23133type OxmIdTunMetadata36 struct {
23134 *OxmId
23135}
23136
23137type IOxmIdTunMetadata36 interface {
23138 IOxmId
23139}
23140
23141func (self *OxmIdTunMetadata36) Serialize(encoder *goloxi.Encoder) error {
23142 if err := self.OxmId.Serialize(encoder); err != nil {
23143 return err
23144 }
23145
23146 return nil
23147}
23148
23149func DecodeOxmIdTunMetadata36(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata36, error) {
23150 _oxmidtunmetadata36 := &OxmIdTunMetadata36{OxmId: parent}
23151 return _oxmidtunmetadata36, nil
23152}
23153
23154func NewOxmIdTunMetadata36() *OxmIdTunMetadata36 {
23155 obj := &OxmIdTunMetadata36{
23156 OxmId: NewOxmId(104572),
23157 }
23158 return obj
23159}
23160func (self *OxmIdTunMetadata36) GetOXMName() string {
23161 return "tun_metadata36"
23162}
23163
23164func (self *OxmIdTunMetadata36) MarshalJSON() ([]byte, error) {
23165 if self.TypeLen == 0 {
23166 return []byte("\"\""), nil
23167 } else {
23168 return []byte("\"" + self.GetOXMName() + "\""), nil
23169 }
23170}
23171
23172type OxmIdTunMetadata36Masked struct {
23173 *OxmId
23174}
23175
23176type IOxmIdTunMetadata36Masked interface {
23177 IOxmId
23178}
23179
23180func (self *OxmIdTunMetadata36Masked) Serialize(encoder *goloxi.Encoder) error {
23181 if err := self.OxmId.Serialize(encoder); err != nil {
23182 return err
23183 }
23184
23185 return nil
23186}
23187
23188func DecodeOxmIdTunMetadata36Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata36Masked, error) {
23189 _oxmidtunmetadata36masked := &OxmIdTunMetadata36Masked{OxmId: parent}
23190 return _oxmidtunmetadata36masked, nil
23191}
23192
23193func NewOxmIdTunMetadata36Masked() *OxmIdTunMetadata36Masked {
23194 obj := &OxmIdTunMetadata36Masked{
23195 OxmId: NewOxmId(104952),
23196 }
23197 return obj
23198}
23199func (self *OxmIdTunMetadata36Masked) GetOXMName() string {
23200 return "tun_metadata36_masked"
23201}
23202
23203func (self *OxmIdTunMetadata36Masked) MarshalJSON() ([]byte, error) {
23204 if self.TypeLen == 0 {
23205 return []byte("\"\""), nil
23206 } else {
23207 return []byte("\"" + self.GetOXMName() + "\""), nil
23208 }
23209}
23210
23211type OxmIdTunMetadata37 struct {
23212 *OxmId
23213}
23214
23215type IOxmIdTunMetadata37 interface {
23216 IOxmId
23217}
23218
23219func (self *OxmIdTunMetadata37) Serialize(encoder *goloxi.Encoder) error {
23220 if err := self.OxmId.Serialize(encoder); err != nil {
23221 return err
23222 }
23223
23224 return nil
23225}
23226
23227func DecodeOxmIdTunMetadata37(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata37, error) {
23228 _oxmidtunmetadata37 := &OxmIdTunMetadata37{OxmId: parent}
23229 return _oxmidtunmetadata37, nil
23230}
23231
23232func NewOxmIdTunMetadata37() *OxmIdTunMetadata37 {
23233 obj := &OxmIdTunMetadata37{
23234 OxmId: NewOxmId(105084),
23235 }
23236 return obj
23237}
23238func (self *OxmIdTunMetadata37) GetOXMName() string {
23239 return "tun_metadata37"
23240}
23241
23242func (self *OxmIdTunMetadata37) MarshalJSON() ([]byte, error) {
23243 if self.TypeLen == 0 {
23244 return []byte("\"\""), nil
23245 } else {
23246 return []byte("\"" + self.GetOXMName() + "\""), nil
23247 }
23248}
23249
23250type OxmIdTunMetadata37Masked struct {
23251 *OxmId
23252}
23253
23254type IOxmIdTunMetadata37Masked interface {
23255 IOxmId
23256}
23257
23258func (self *OxmIdTunMetadata37Masked) Serialize(encoder *goloxi.Encoder) error {
23259 if err := self.OxmId.Serialize(encoder); err != nil {
23260 return err
23261 }
23262
23263 return nil
23264}
23265
23266func DecodeOxmIdTunMetadata37Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata37Masked, error) {
23267 _oxmidtunmetadata37masked := &OxmIdTunMetadata37Masked{OxmId: parent}
23268 return _oxmidtunmetadata37masked, nil
23269}
23270
23271func NewOxmIdTunMetadata37Masked() *OxmIdTunMetadata37Masked {
23272 obj := &OxmIdTunMetadata37Masked{
23273 OxmId: NewOxmId(105464),
23274 }
23275 return obj
23276}
23277func (self *OxmIdTunMetadata37Masked) GetOXMName() string {
23278 return "tun_metadata37_masked"
23279}
23280
23281func (self *OxmIdTunMetadata37Masked) MarshalJSON() ([]byte, error) {
23282 if self.TypeLen == 0 {
23283 return []byte("\"\""), nil
23284 } else {
23285 return []byte("\"" + self.GetOXMName() + "\""), nil
23286 }
23287}
23288
23289type OxmIdTunMetadata38 struct {
23290 *OxmId
23291}
23292
23293type IOxmIdTunMetadata38 interface {
23294 IOxmId
23295}
23296
23297func (self *OxmIdTunMetadata38) Serialize(encoder *goloxi.Encoder) error {
23298 if err := self.OxmId.Serialize(encoder); err != nil {
23299 return err
23300 }
23301
23302 return nil
23303}
23304
23305func DecodeOxmIdTunMetadata38(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata38, error) {
23306 _oxmidtunmetadata38 := &OxmIdTunMetadata38{OxmId: parent}
23307 return _oxmidtunmetadata38, nil
23308}
23309
23310func NewOxmIdTunMetadata38() *OxmIdTunMetadata38 {
23311 obj := &OxmIdTunMetadata38{
23312 OxmId: NewOxmId(105596),
23313 }
23314 return obj
23315}
23316func (self *OxmIdTunMetadata38) GetOXMName() string {
23317 return "tun_metadata38"
23318}
23319
23320func (self *OxmIdTunMetadata38) MarshalJSON() ([]byte, error) {
23321 if self.TypeLen == 0 {
23322 return []byte("\"\""), nil
23323 } else {
23324 return []byte("\"" + self.GetOXMName() + "\""), nil
23325 }
23326}
23327
23328type OxmIdTunMetadata38Masked struct {
23329 *OxmId
23330}
23331
23332type IOxmIdTunMetadata38Masked interface {
23333 IOxmId
23334}
23335
23336func (self *OxmIdTunMetadata38Masked) Serialize(encoder *goloxi.Encoder) error {
23337 if err := self.OxmId.Serialize(encoder); err != nil {
23338 return err
23339 }
23340
23341 return nil
23342}
23343
23344func DecodeOxmIdTunMetadata38Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata38Masked, error) {
23345 _oxmidtunmetadata38masked := &OxmIdTunMetadata38Masked{OxmId: parent}
23346 return _oxmidtunmetadata38masked, nil
23347}
23348
23349func NewOxmIdTunMetadata38Masked() *OxmIdTunMetadata38Masked {
23350 obj := &OxmIdTunMetadata38Masked{
23351 OxmId: NewOxmId(105976),
23352 }
23353 return obj
23354}
23355func (self *OxmIdTunMetadata38Masked) GetOXMName() string {
23356 return "tun_metadata38_masked"
23357}
23358
23359func (self *OxmIdTunMetadata38Masked) MarshalJSON() ([]byte, error) {
23360 if self.TypeLen == 0 {
23361 return []byte("\"\""), nil
23362 } else {
23363 return []byte("\"" + self.GetOXMName() + "\""), nil
23364 }
23365}
23366
23367type OxmIdTunMetadata39 struct {
23368 *OxmId
23369}
23370
23371type IOxmIdTunMetadata39 interface {
23372 IOxmId
23373}
23374
23375func (self *OxmIdTunMetadata39) Serialize(encoder *goloxi.Encoder) error {
23376 if err := self.OxmId.Serialize(encoder); err != nil {
23377 return err
23378 }
23379
23380 return nil
23381}
23382
23383func DecodeOxmIdTunMetadata39(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata39, error) {
23384 _oxmidtunmetadata39 := &OxmIdTunMetadata39{OxmId: parent}
23385 return _oxmidtunmetadata39, nil
23386}
23387
23388func NewOxmIdTunMetadata39() *OxmIdTunMetadata39 {
23389 obj := &OxmIdTunMetadata39{
23390 OxmId: NewOxmId(106108),
23391 }
23392 return obj
23393}
23394func (self *OxmIdTunMetadata39) GetOXMName() string {
23395 return "tun_metadata39"
23396}
23397
23398func (self *OxmIdTunMetadata39) MarshalJSON() ([]byte, error) {
23399 if self.TypeLen == 0 {
23400 return []byte("\"\""), nil
23401 } else {
23402 return []byte("\"" + self.GetOXMName() + "\""), nil
23403 }
23404}
23405
23406type OxmIdTunMetadata39Masked struct {
23407 *OxmId
23408}
23409
23410type IOxmIdTunMetadata39Masked interface {
23411 IOxmId
23412}
23413
23414func (self *OxmIdTunMetadata39Masked) Serialize(encoder *goloxi.Encoder) error {
23415 if err := self.OxmId.Serialize(encoder); err != nil {
23416 return err
23417 }
23418
23419 return nil
23420}
23421
23422func DecodeOxmIdTunMetadata39Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata39Masked, error) {
23423 _oxmidtunmetadata39masked := &OxmIdTunMetadata39Masked{OxmId: parent}
23424 return _oxmidtunmetadata39masked, nil
23425}
23426
23427func NewOxmIdTunMetadata39Masked() *OxmIdTunMetadata39Masked {
23428 obj := &OxmIdTunMetadata39Masked{
23429 OxmId: NewOxmId(106488),
23430 }
23431 return obj
23432}
23433func (self *OxmIdTunMetadata39Masked) GetOXMName() string {
23434 return "tun_metadata39_masked"
23435}
23436
23437func (self *OxmIdTunMetadata39Masked) MarshalJSON() ([]byte, error) {
23438 if self.TypeLen == 0 {
23439 return []byte("\"\""), nil
23440 } else {
23441 return []byte("\"" + self.GetOXMName() + "\""), nil
23442 }
23443}
23444
23445type OxmIdTunMetadata3Masked struct {
23446 *OxmId
23447}
23448
23449type IOxmIdTunMetadata3Masked interface {
23450 IOxmId
23451}
23452
23453func (self *OxmIdTunMetadata3Masked) Serialize(encoder *goloxi.Encoder) error {
23454 if err := self.OxmId.Serialize(encoder); err != nil {
23455 return err
23456 }
23457
23458 return nil
23459}
23460
23461func DecodeOxmIdTunMetadata3Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata3Masked, error) {
23462 _oxmidtunmetadata3masked := &OxmIdTunMetadata3Masked{OxmId: parent}
23463 return _oxmidtunmetadata3masked, nil
23464}
23465
23466func NewOxmIdTunMetadata3Masked() *OxmIdTunMetadata3Masked {
23467 obj := &OxmIdTunMetadata3Masked{
23468 OxmId: NewOxmId(88056),
23469 }
23470 return obj
23471}
23472func (self *OxmIdTunMetadata3Masked) GetOXMName() string {
23473 return "tun_metadata3_masked"
23474}
23475
23476func (self *OxmIdTunMetadata3Masked) MarshalJSON() ([]byte, error) {
23477 if self.TypeLen == 0 {
23478 return []byte("\"\""), nil
23479 } else {
23480 return []byte("\"" + self.GetOXMName() + "\""), nil
23481 }
23482}
23483
23484type OxmIdTunMetadata4 struct {
23485 *OxmId
23486}
23487
23488type IOxmIdTunMetadata4 interface {
23489 IOxmId
23490}
23491
23492func (self *OxmIdTunMetadata4) Serialize(encoder *goloxi.Encoder) error {
23493 if err := self.OxmId.Serialize(encoder); err != nil {
23494 return err
23495 }
23496
23497 return nil
23498}
23499
23500func DecodeOxmIdTunMetadata4(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata4, error) {
23501 _oxmidtunmetadata4 := &OxmIdTunMetadata4{OxmId: parent}
23502 return _oxmidtunmetadata4, nil
23503}
23504
23505func NewOxmIdTunMetadata4() *OxmIdTunMetadata4 {
23506 obj := &OxmIdTunMetadata4{
23507 OxmId: NewOxmId(88188),
23508 }
23509 return obj
23510}
23511func (self *OxmIdTunMetadata4) GetOXMName() string {
23512 return "tun_metadata4"
23513}
23514
23515func (self *OxmIdTunMetadata4) MarshalJSON() ([]byte, error) {
23516 if self.TypeLen == 0 {
23517 return []byte("\"\""), nil
23518 } else {
23519 return []byte("\"" + self.GetOXMName() + "\""), nil
23520 }
23521}
23522
23523type OxmIdTunMetadata40 struct {
23524 *OxmId
23525}
23526
23527type IOxmIdTunMetadata40 interface {
23528 IOxmId
23529}
23530
23531func (self *OxmIdTunMetadata40) Serialize(encoder *goloxi.Encoder) error {
23532 if err := self.OxmId.Serialize(encoder); err != nil {
23533 return err
23534 }
23535
23536 return nil
23537}
23538
23539func DecodeOxmIdTunMetadata40(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata40, error) {
23540 _oxmidtunmetadata40 := &OxmIdTunMetadata40{OxmId: parent}
23541 return _oxmidtunmetadata40, nil
23542}
23543
23544func NewOxmIdTunMetadata40() *OxmIdTunMetadata40 {
23545 obj := &OxmIdTunMetadata40{
23546 OxmId: NewOxmId(106620),
23547 }
23548 return obj
23549}
23550func (self *OxmIdTunMetadata40) GetOXMName() string {
23551 return "tun_metadata40"
23552}
23553
23554func (self *OxmIdTunMetadata40) MarshalJSON() ([]byte, error) {
23555 if self.TypeLen == 0 {
23556 return []byte("\"\""), nil
23557 } else {
23558 return []byte("\"" + self.GetOXMName() + "\""), nil
23559 }
23560}
23561
23562type OxmIdTunMetadata40Masked struct {
23563 *OxmId
23564}
23565
23566type IOxmIdTunMetadata40Masked interface {
23567 IOxmId
23568}
23569
23570func (self *OxmIdTunMetadata40Masked) Serialize(encoder *goloxi.Encoder) error {
23571 if err := self.OxmId.Serialize(encoder); err != nil {
23572 return err
23573 }
23574
23575 return nil
23576}
23577
23578func DecodeOxmIdTunMetadata40Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata40Masked, error) {
23579 _oxmidtunmetadata40masked := &OxmIdTunMetadata40Masked{OxmId: parent}
23580 return _oxmidtunmetadata40masked, nil
23581}
23582
23583func NewOxmIdTunMetadata40Masked() *OxmIdTunMetadata40Masked {
23584 obj := &OxmIdTunMetadata40Masked{
23585 OxmId: NewOxmId(107000),
23586 }
23587 return obj
23588}
23589func (self *OxmIdTunMetadata40Masked) GetOXMName() string {
23590 return "tun_metadata40_masked"
23591}
23592
23593func (self *OxmIdTunMetadata40Masked) MarshalJSON() ([]byte, error) {
23594 if self.TypeLen == 0 {
23595 return []byte("\"\""), nil
23596 } else {
23597 return []byte("\"" + self.GetOXMName() + "\""), nil
23598 }
23599}
23600
23601type OxmIdTunMetadata41 struct {
23602 *OxmId
23603}
23604
23605type IOxmIdTunMetadata41 interface {
23606 IOxmId
23607}
23608
23609func (self *OxmIdTunMetadata41) Serialize(encoder *goloxi.Encoder) error {
23610 if err := self.OxmId.Serialize(encoder); err != nil {
23611 return err
23612 }
23613
23614 return nil
23615}
23616
23617func DecodeOxmIdTunMetadata41(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata41, error) {
23618 _oxmidtunmetadata41 := &OxmIdTunMetadata41{OxmId: parent}
23619 return _oxmidtunmetadata41, nil
23620}
23621
23622func NewOxmIdTunMetadata41() *OxmIdTunMetadata41 {
23623 obj := &OxmIdTunMetadata41{
23624 OxmId: NewOxmId(107132),
23625 }
23626 return obj
23627}
23628func (self *OxmIdTunMetadata41) GetOXMName() string {
23629 return "tun_metadata41"
23630}
23631
23632func (self *OxmIdTunMetadata41) MarshalJSON() ([]byte, error) {
23633 if self.TypeLen == 0 {
23634 return []byte("\"\""), nil
23635 } else {
23636 return []byte("\"" + self.GetOXMName() + "\""), nil
23637 }
23638}
23639
23640type OxmIdTunMetadata41Masked struct {
23641 *OxmId
23642}
23643
23644type IOxmIdTunMetadata41Masked interface {
23645 IOxmId
23646}
23647
23648func (self *OxmIdTunMetadata41Masked) Serialize(encoder *goloxi.Encoder) error {
23649 if err := self.OxmId.Serialize(encoder); err != nil {
23650 return err
23651 }
23652
23653 return nil
23654}
23655
23656func DecodeOxmIdTunMetadata41Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata41Masked, error) {
23657 _oxmidtunmetadata41masked := &OxmIdTunMetadata41Masked{OxmId: parent}
23658 return _oxmidtunmetadata41masked, nil
23659}
23660
23661func NewOxmIdTunMetadata41Masked() *OxmIdTunMetadata41Masked {
23662 obj := &OxmIdTunMetadata41Masked{
23663 OxmId: NewOxmId(107512),
23664 }
23665 return obj
23666}
23667func (self *OxmIdTunMetadata41Masked) GetOXMName() string {
23668 return "tun_metadata41_masked"
23669}
23670
23671func (self *OxmIdTunMetadata41Masked) MarshalJSON() ([]byte, error) {
23672 if self.TypeLen == 0 {
23673 return []byte("\"\""), nil
23674 } else {
23675 return []byte("\"" + self.GetOXMName() + "\""), nil
23676 }
23677}
23678
23679type OxmIdTunMetadata42 struct {
23680 *OxmId
23681}
23682
23683type IOxmIdTunMetadata42 interface {
23684 IOxmId
23685}
23686
23687func (self *OxmIdTunMetadata42) Serialize(encoder *goloxi.Encoder) error {
23688 if err := self.OxmId.Serialize(encoder); err != nil {
23689 return err
23690 }
23691
23692 return nil
23693}
23694
23695func DecodeOxmIdTunMetadata42(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata42, error) {
23696 _oxmidtunmetadata42 := &OxmIdTunMetadata42{OxmId: parent}
23697 return _oxmidtunmetadata42, nil
23698}
23699
23700func NewOxmIdTunMetadata42() *OxmIdTunMetadata42 {
23701 obj := &OxmIdTunMetadata42{
23702 OxmId: NewOxmId(107644),
23703 }
23704 return obj
23705}
23706func (self *OxmIdTunMetadata42) GetOXMName() string {
23707 return "tun_metadata42"
23708}
23709
23710func (self *OxmIdTunMetadata42) MarshalJSON() ([]byte, error) {
23711 if self.TypeLen == 0 {
23712 return []byte("\"\""), nil
23713 } else {
23714 return []byte("\"" + self.GetOXMName() + "\""), nil
23715 }
23716}
23717
23718type OxmIdTunMetadata42Masked struct {
23719 *OxmId
23720}
23721
23722type IOxmIdTunMetadata42Masked interface {
23723 IOxmId
23724}
23725
23726func (self *OxmIdTunMetadata42Masked) Serialize(encoder *goloxi.Encoder) error {
23727 if err := self.OxmId.Serialize(encoder); err != nil {
23728 return err
23729 }
23730
23731 return nil
23732}
23733
23734func DecodeOxmIdTunMetadata42Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata42Masked, error) {
23735 _oxmidtunmetadata42masked := &OxmIdTunMetadata42Masked{OxmId: parent}
23736 return _oxmidtunmetadata42masked, nil
23737}
23738
23739func NewOxmIdTunMetadata42Masked() *OxmIdTunMetadata42Masked {
23740 obj := &OxmIdTunMetadata42Masked{
23741 OxmId: NewOxmId(108024),
23742 }
23743 return obj
23744}
23745func (self *OxmIdTunMetadata42Masked) GetOXMName() string {
23746 return "tun_metadata42_masked"
23747}
23748
23749func (self *OxmIdTunMetadata42Masked) MarshalJSON() ([]byte, error) {
23750 if self.TypeLen == 0 {
23751 return []byte("\"\""), nil
23752 } else {
23753 return []byte("\"" + self.GetOXMName() + "\""), nil
23754 }
23755}
23756
23757type OxmIdTunMetadata43 struct {
23758 *OxmId
23759}
23760
23761type IOxmIdTunMetadata43 interface {
23762 IOxmId
23763}
23764
23765func (self *OxmIdTunMetadata43) Serialize(encoder *goloxi.Encoder) error {
23766 if err := self.OxmId.Serialize(encoder); err != nil {
23767 return err
23768 }
23769
23770 return nil
23771}
23772
23773func DecodeOxmIdTunMetadata43(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata43, error) {
23774 _oxmidtunmetadata43 := &OxmIdTunMetadata43{OxmId: parent}
23775 return _oxmidtunmetadata43, nil
23776}
23777
23778func NewOxmIdTunMetadata43() *OxmIdTunMetadata43 {
23779 obj := &OxmIdTunMetadata43{
23780 OxmId: NewOxmId(108156),
23781 }
23782 return obj
23783}
23784func (self *OxmIdTunMetadata43) GetOXMName() string {
23785 return "tun_metadata43"
23786}
23787
23788func (self *OxmIdTunMetadata43) MarshalJSON() ([]byte, error) {
23789 if self.TypeLen == 0 {
23790 return []byte("\"\""), nil
23791 } else {
23792 return []byte("\"" + self.GetOXMName() + "\""), nil
23793 }
23794}
23795
23796type OxmIdTunMetadata43Masked struct {
23797 *OxmId
23798}
23799
23800type IOxmIdTunMetadata43Masked interface {
23801 IOxmId
23802}
23803
23804func (self *OxmIdTunMetadata43Masked) Serialize(encoder *goloxi.Encoder) error {
23805 if err := self.OxmId.Serialize(encoder); err != nil {
23806 return err
23807 }
23808
23809 return nil
23810}
23811
23812func DecodeOxmIdTunMetadata43Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata43Masked, error) {
23813 _oxmidtunmetadata43masked := &OxmIdTunMetadata43Masked{OxmId: parent}
23814 return _oxmidtunmetadata43masked, nil
23815}
23816
23817func NewOxmIdTunMetadata43Masked() *OxmIdTunMetadata43Masked {
23818 obj := &OxmIdTunMetadata43Masked{
23819 OxmId: NewOxmId(108536),
23820 }
23821 return obj
23822}
23823func (self *OxmIdTunMetadata43Masked) GetOXMName() string {
23824 return "tun_metadata43_masked"
23825}
23826
23827func (self *OxmIdTunMetadata43Masked) MarshalJSON() ([]byte, error) {
23828 if self.TypeLen == 0 {
23829 return []byte("\"\""), nil
23830 } else {
23831 return []byte("\"" + self.GetOXMName() + "\""), nil
23832 }
23833}
23834
23835type OxmIdTunMetadata44 struct {
23836 *OxmId
23837}
23838
23839type IOxmIdTunMetadata44 interface {
23840 IOxmId
23841}
23842
23843func (self *OxmIdTunMetadata44) Serialize(encoder *goloxi.Encoder) error {
23844 if err := self.OxmId.Serialize(encoder); err != nil {
23845 return err
23846 }
23847
23848 return nil
23849}
23850
23851func DecodeOxmIdTunMetadata44(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata44, error) {
23852 _oxmidtunmetadata44 := &OxmIdTunMetadata44{OxmId: parent}
23853 return _oxmidtunmetadata44, nil
23854}
23855
23856func NewOxmIdTunMetadata44() *OxmIdTunMetadata44 {
23857 obj := &OxmIdTunMetadata44{
23858 OxmId: NewOxmId(108668),
23859 }
23860 return obj
23861}
23862func (self *OxmIdTunMetadata44) GetOXMName() string {
23863 return "tun_metadata44"
23864}
23865
23866func (self *OxmIdTunMetadata44) MarshalJSON() ([]byte, error) {
23867 if self.TypeLen == 0 {
23868 return []byte("\"\""), nil
23869 } else {
23870 return []byte("\"" + self.GetOXMName() + "\""), nil
23871 }
23872}
23873
23874type OxmIdTunMetadata44Masked struct {
23875 *OxmId
23876}
23877
23878type IOxmIdTunMetadata44Masked interface {
23879 IOxmId
23880}
23881
23882func (self *OxmIdTunMetadata44Masked) Serialize(encoder *goloxi.Encoder) error {
23883 if err := self.OxmId.Serialize(encoder); err != nil {
23884 return err
23885 }
23886
23887 return nil
23888}
23889
23890func DecodeOxmIdTunMetadata44Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata44Masked, error) {
23891 _oxmidtunmetadata44masked := &OxmIdTunMetadata44Masked{OxmId: parent}
23892 return _oxmidtunmetadata44masked, nil
23893}
23894
23895func NewOxmIdTunMetadata44Masked() *OxmIdTunMetadata44Masked {
23896 obj := &OxmIdTunMetadata44Masked{
23897 OxmId: NewOxmId(109048),
23898 }
23899 return obj
23900}
23901func (self *OxmIdTunMetadata44Masked) GetOXMName() string {
23902 return "tun_metadata44_masked"
23903}
23904
23905func (self *OxmIdTunMetadata44Masked) MarshalJSON() ([]byte, error) {
23906 if self.TypeLen == 0 {
23907 return []byte("\"\""), nil
23908 } else {
23909 return []byte("\"" + self.GetOXMName() + "\""), nil
23910 }
23911}
23912
23913type OxmIdTunMetadata45 struct {
23914 *OxmId
23915}
23916
23917type IOxmIdTunMetadata45 interface {
23918 IOxmId
23919}
23920
23921func (self *OxmIdTunMetadata45) Serialize(encoder *goloxi.Encoder) error {
23922 if err := self.OxmId.Serialize(encoder); err != nil {
23923 return err
23924 }
23925
23926 return nil
23927}
23928
23929func DecodeOxmIdTunMetadata45(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata45, error) {
23930 _oxmidtunmetadata45 := &OxmIdTunMetadata45{OxmId: parent}
23931 return _oxmidtunmetadata45, nil
23932}
23933
23934func NewOxmIdTunMetadata45() *OxmIdTunMetadata45 {
23935 obj := &OxmIdTunMetadata45{
23936 OxmId: NewOxmId(109180),
23937 }
23938 return obj
23939}
23940func (self *OxmIdTunMetadata45) GetOXMName() string {
23941 return "tun_metadata45"
23942}
23943
23944func (self *OxmIdTunMetadata45) MarshalJSON() ([]byte, error) {
23945 if self.TypeLen == 0 {
23946 return []byte("\"\""), nil
23947 } else {
23948 return []byte("\"" + self.GetOXMName() + "\""), nil
23949 }
23950}
23951
23952type OxmIdTunMetadata45Masked struct {
23953 *OxmId
23954}
23955
23956type IOxmIdTunMetadata45Masked interface {
23957 IOxmId
23958}
23959
23960func (self *OxmIdTunMetadata45Masked) Serialize(encoder *goloxi.Encoder) error {
23961 if err := self.OxmId.Serialize(encoder); err != nil {
23962 return err
23963 }
23964
23965 return nil
23966}
23967
23968func DecodeOxmIdTunMetadata45Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata45Masked, error) {
23969 _oxmidtunmetadata45masked := &OxmIdTunMetadata45Masked{OxmId: parent}
23970 return _oxmidtunmetadata45masked, nil
23971}
23972
23973func NewOxmIdTunMetadata45Masked() *OxmIdTunMetadata45Masked {
23974 obj := &OxmIdTunMetadata45Masked{
23975 OxmId: NewOxmId(109560),
23976 }
23977 return obj
23978}
23979func (self *OxmIdTunMetadata45Masked) GetOXMName() string {
23980 return "tun_metadata45_masked"
23981}
23982
23983func (self *OxmIdTunMetadata45Masked) MarshalJSON() ([]byte, error) {
23984 if self.TypeLen == 0 {
23985 return []byte("\"\""), nil
23986 } else {
23987 return []byte("\"" + self.GetOXMName() + "\""), nil
23988 }
23989}
23990
23991type OxmIdTunMetadata46 struct {
23992 *OxmId
23993}
23994
23995type IOxmIdTunMetadata46 interface {
23996 IOxmId
23997}
23998
23999func (self *OxmIdTunMetadata46) Serialize(encoder *goloxi.Encoder) error {
24000 if err := self.OxmId.Serialize(encoder); err != nil {
24001 return err
24002 }
24003
24004 return nil
24005}
24006
24007func DecodeOxmIdTunMetadata46(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata46, error) {
24008 _oxmidtunmetadata46 := &OxmIdTunMetadata46{OxmId: parent}
24009 return _oxmidtunmetadata46, nil
24010}
24011
24012func NewOxmIdTunMetadata46() *OxmIdTunMetadata46 {
24013 obj := &OxmIdTunMetadata46{
24014 OxmId: NewOxmId(109692),
24015 }
24016 return obj
24017}
24018func (self *OxmIdTunMetadata46) GetOXMName() string {
24019 return "tun_metadata46"
24020}
24021
24022func (self *OxmIdTunMetadata46) MarshalJSON() ([]byte, error) {
24023 if self.TypeLen == 0 {
24024 return []byte("\"\""), nil
24025 } else {
24026 return []byte("\"" + self.GetOXMName() + "\""), nil
24027 }
24028}
24029
24030type OxmIdTunMetadata46Masked struct {
24031 *OxmId
24032}
24033
24034type IOxmIdTunMetadata46Masked interface {
24035 IOxmId
24036}
24037
24038func (self *OxmIdTunMetadata46Masked) Serialize(encoder *goloxi.Encoder) error {
24039 if err := self.OxmId.Serialize(encoder); err != nil {
24040 return err
24041 }
24042
24043 return nil
24044}
24045
24046func DecodeOxmIdTunMetadata46Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata46Masked, error) {
24047 _oxmidtunmetadata46masked := &OxmIdTunMetadata46Masked{OxmId: parent}
24048 return _oxmidtunmetadata46masked, nil
24049}
24050
24051func NewOxmIdTunMetadata46Masked() *OxmIdTunMetadata46Masked {
24052 obj := &OxmIdTunMetadata46Masked{
24053 OxmId: NewOxmId(110072),
24054 }
24055 return obj
24056}
24057func (self *OxmIdTunMetadata46Masked) GetOXMName() string {
24058 return "tun_metadata46_masked"
24059}
24060
24061func (self *OxmIdTunMetadata46Masked) MarshalJSON() ([]byte, error) {
24062 if self.TypeLen == 0 {
24063 return []byte("\"\""), nil
24064 } else {
24065 return []byte("\"" + self.GetOXMName() + "\""), nil
24066 }
24067}
24068
24069type OxmIdTunMetadata47 struct {
24070 *OxmId
24071}
24072
24073type IOxmIdTunMetadata47 interface {
24074 IOxmId
24075}
24076
24077func (self *OxmIdTunMetadata47) Serialize(encoder *goloxi.Encoder) error {
24078 if err := self.OxmId.Serialize(encoder); err != nil {
24079 return err
24080 }
24081
24082 return nil
24083}
24084
24085func DecodeOxmIdTunMetadata47(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata47, error) {
24086 _oxmidtunmetadata47 := &OxmIdTunMetadata47{OxmId: parent}
24087 return _oxmidtunmetadata47, nil
24088}
24089
24090func NewOxmIdTunMetadata47() *OxmIdTunMetadata47 {
24091 obj := &OxmIdTunMetadata47{
24092 OxmId: NewOxmId(110204),
24093 }
24094 return obj
24095}
24096func (self *OxmIdTunMetadata47) GetOXMName() string {
24097 return "tun_metadata47"
24098}
24099
24100func (self *OxmIdTunMetadata47) MarshalJSON() ([]byte, error) {
24101 if self.TypeLen == 0 {
24102 return []byte("\"\""), nil
24103 } else {
24104 return []byte("\"" + self.GetOXMName() + "\""), nil
24105 }
24106}
24107
24108type OxmIdTunMetadata47Masked struct {
24109 *OxmId
24110}
24111
24112type IOxmIdTunMetadata47Masked interface {
24113 IOxmId
24114}
24115
24116func (self *OxmIdTunMetadata47Masked) Serialize(encoder *goloxi.Encoder) error {
24117 if err := self.OxmId.Serialize(encoder); err != nil {
24118 return err
24119 }
24120
24121 return nil
24122}
24123
24124func DecodeOxmIdTunMetadata47Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata47Masked, error) {
24125 _oxmidtunmetadata47masked := &OxmIdTunMetadata47Masked{OxmId: parent}
24126 return _oxmidtunmetadata47masked, nil
24127}
24128
24129func NewOxmIdTunMetadata47Masked() *OxmIdTunMetadata47Masked {
24130 obj := &OxmIdTunMetadata47Masked{
24131 OxmId: NewOxmId(110584),
24132 }
24133 return obj
24134}
24135func (self *OxmIdTunMetadata47Masked) GetOXMName() string {
24136 return "tun_metadata47_masked"
24137}
24138
24139func (self *OxmIdTunMetadata47Masked) MarshalJSON() ([]byte, error) {
24140 if self.TypeLen == 0 {
24141 return []byte("\"\""), nil
24142 } else {
24143 return []byte("\"" + self.GetOXMName() + "\""), nil
24144 }
24145}
24146
24147type OxmIdTunMetadata48 struct {
24148 *OxmId
24149}
24150
24151type IOxmIdTunMetadata48 interface {
24152 IOxmId
24153}
24154
24155func (self *OxmIdTunMetadata48) Serialize(encoder *goloxi.Encoder) error {
24156 if err := self.OxmId.Serialize(encoder); err != nil {
24157 return err
24158 }
24159
24160 return nil
24161}
24162
24163func DecodeOxmIdTunMetadata48(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata48, error) {
24164 _oxmidtunmetadata48 := &OxmIdTunMetadata48{OxmId: parent}
24165 return _oxmidtunmetadata48, nil
24166}
24167
24168func NewOxmIdTunMetadata48() *OxmIdTunMetadata48 {
24169 obj := &OxmIdTunMetadata48{
24170 OxmId: NewOxmId(110716),
24171 }
24172 return obj
24173}
24174func (self *OxmIdTunMetadata48) GetOXMName() string {
24175 return "tun_metadata48"
24176}
24177
24178func (self *OxmIdTunMetadata48) MarshalJSON() ([]byte, error) {
24179 if self.TypeLen == 0 {
24180 return []byte("\"\""), nil
24181 } else {
24182 return []byte("\"" + self.GetOXMName() + "\""), nil
24183 }
24184}
24185
24186type OxmIdTunMetadata48Masked struct {
24187 *OxmId
24188}
24189
24190type IOxmIdTunMetadata48Masked interface {
24191 IOxmId
24192}
24193
24194func (self *OxmIdTunMetadata48Masked) Serialize(encoder *goloxi.Encoder) error {
24195 if err := self.OxmId.Serialize(encoder); err != nil {
24196 return err
24197 }
24198
24199 return nil
24200}
24201
24202func DecodeOxmIdTunMetadata48Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata48Masked, error) {
24203 _oxmidtunmetadata48masked := &OxmIdTunMetadata48Masked{OxmId: parent}
24204 return _oxmidtunmetadata48masked, nil
24205}
24206
24207func NewOxmIdTunMetadata48Masked() *OxmIdTunMetadata48Masked {
24208 obj := &OxmIdTunMetadata48Masked{
24209 OxmId: NewOxmId(111096),
24210 }
24211 return obj
24212}
24213func (self *OxmIdTunMetadata48Masked) GetOXMName() string {
24214 return "tun_metadata48_masked"
24215}
24216
24217func (self *OxmIdTunMetadata48Masked) MarshalJSON() ([]byte, error) {
24218 if self.TypeLen == 0 {
24219 return []byte("\"\""), nil
24220 } else {
24221 return []byte("\"" + self.GetOXMName() + "\""), nil
24222 }
24223}
24224
24225type OxmIdTunMetadata49 struct {
24226 *OxmId
24227}
24228
24229type IOxmIdTunMetadata49 interface {
24230 IOxmId
24231}
24232
24233func (self *OxmIdTunMetadata49) Serialize(encoder *goloxi.Encoder) error {
24234 if err := self.OxmId.Serialize(encoder); err != nil {
24235 return err
24236 }
24237
24238 return nil
24239}
24240
24241func DecodeOxmIdTunMetadata49(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata49, error) {
24242 _oxmidtunmetadata49 := &OxmIdTunMetadata49{OxmId: parent}
24243 return _oxmidtunmetadata49, nil
24244}
24245
24246func NewOxmIdTunMetadata49() *OxmIdTunMetadata49 {
24247 obj := &OxmIdTunMetadata49{
24248 OxmId: NewOxmId(111228),
24249 }
24250 return obj
24251}
24252func (self *OxmIdTunMetadata49) GetOXMName() string {
24253 return "tun_metadata49"
24254}
24255
24256func (self *OxmIdTunMetadata49) MarshalJSON() ([]byte, error) {
24257 if self.TypeLen == 0 {
24258 return []byte("\"\""), nil
24259 } else {
24260 return []byte("\"" + self.GetOXMName() + "\""), nil
24261 }
24262}
24263
24264type OxmIdTunMetadata49Masked struct {
24265 *OxmId
24266}
24267
24268type IOxmIdTunMetadata49Masked interface {
24269 IOxmId
24270}
24271
24272func (self *OxmIdTunMetadata49Masked) Serialize(encoder *goloxi.Encoder) error {
24273 if err := self.OxmId.Serialize(encoder); err != nil {
24274 return err
24275 }
24276
24277 return nil
24278}
24279
24280func DecodeOxmIdTunMetadata49Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata49Masked, error) {
24281 _oxmidtunmetadata49masked := &OxmIdTunMetadata49Masked{OxmId: parent}
24282 return _oxmidtunmetadata49masked, nil
24283}
24284
24285func NewOxmIdTunMetadata49Masked() *OxmIdTunMetadata49Masked {
24286 obj := &OxmIdTunMetadata49Masked{
24287 OxmId: NewOxmId(111608),
24288 }
24289 return obj
24290}
24291func (self *OxmIdTunMetadata49Masked) GetOXMName() string {
24292 return "tun_metadata49_masked"
24293}
24294
24295func (self *OxmIdTunMetadata49Masked) MarshalJSON() ([]byte, error) {
24296 if self.TypeLen == 0 {
24297 return []byte("\"\""), nil
24298 } else {
24299 return []byte("\"" + self.GetOXMName() + "\""), nil
24300 }
24301}
24302
24303type OxmIdTunMetadata4Masked struct {
24304 *OxmId
24305}
24306
24307type IOxmIdTunMetadata4Masked interface {
24308 IOxmId
24309}
24310
24311func (self *OxmIdTunMetadata4Masked) Serialize(encoder *goloxi.Encoder) error {
24312 if err := self.OxmId.Serialize(encoder); err != nil {
24313 return err
24314 }
24315
24316 return nil
24317}
24318
24319func DecodeOxmIdTunMetadata4Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata4Masked, error) {
24320 _oxmidtunmetadata4masked := &OxmIdTunMetadata4Masked{OxmId: parent}
24321 return _oxmidtunmetadata4masked, nil
24322}
24323
24324func NewOxmIdTunMetadata4Masked() *OxmIdTunMetadata4Masked {
24325 obj := &OxmIdTunMetadata4Masked{
24326 OxmId: NewOxmId(88568),
24327 }
24328 return obj
24329}
24330func (self *OxmIdTunMetadata4Masked) GetOXMName() string {
24331 return "tun_metadata4_masked"
24332}
24333
24334func (self *OxmIdTunMetadata4Masked) MarshalJSON() ([]byte, error) {
24335 if self.TypeLen == 0 {
24336 return []byte("\"\""), nil
24337 } else {
24338 return []byte("\"" + self.GetOXMName() + "\""), nil
24339 }
24340}
24341
24342type OxmIdTunMetadata5 struct {
24343 *OxmId
24344}
24345
24346type IOxmIdTunMetadata5 interface {
24347 IOxmId
24348}
24349
24350func (self *OxmIdTunMetadata5) Serialize(encoder *goloxi.Encoder) error {
24351 if err := self.OxmId.Serialize(encoder); err != nil {
24352 return err
24353 }
24354
24355 return nil
24356}
24357
24358func DecodeOxmIdTunMetadata5(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata5, error) {
24359 _oxmidtunmetadata5 := &OxmIdTunMetadata5{OxmId: parent}
24360 return _oxmidtunmetadata5, nil
24361}
24362
24363func NewOxmIdTunMetadata5() *OxmIdTunMetadata5 {
24364 obj := &OxmIdTunMetadata5{
24365 OxmId: NewOxmId(88700),
24366 }
24367 return obj
24368}
24369func (self *OxmIdTunMetadata5) GetOXMName() string {
24370 return "tun_metadata5"
24371}
24372
24373func (self *OxmIdTunMetadata5) MarshalJSON() ([]byte, error) {
24374 if self.TypeLen == 0 {
24375 return []byte("\"\""), nil
24376 } else {
24377 return []byte("\"" + self.GetOXMName() + "\""), nil
24378 }
24379}
24380
24381type OxmIdTunMetadata50 struct {
24382 *OxmId
24383}
24384
24385type IOxmIdTunMetadata50 interface {
24386 IOxmId
24387}
24388
24389func (self *OxmIdTunMetadata50) Serialize(encoder *goloxi.Encoder) error {
24390 if err := self.OxmId.Serialize(encoder); err != nil {
24391 return err
24392 }
24393
24394 return nil
24395}
24396
24397func DecodeOxmIdTunMetadata50(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata50, error) {
24398 _oxmidtunmetadata50 := &OxmIdTunMetadata50{OxmId: parent}
24399 return _oxmidtunmetadata50, nil
24400}
24401
24402func NewOxmIdTunMetadata50() *OxmIdTunMetadata50 {
24403 obj := &OxmIdTunMetadata50{
24404 OxmId: NewOxmId(111740),
24405 }
24406 return obj
24407}
24408func (self *OxmIdTunMetadata50) GetOXMName() string {
24409 return "tun_metadata50"
24410}
24411
24412func (self *OxmIdTunMetadata50) MarshalJSON() ([]byte, error) {
24413 if self.TypeLen == 0 {
24414 return []byte("\"\""), nil
24415 } else {
24416 return []byte("\"" + self.GetOXMName() + "\""), nil
24417 }
24418}
24419
24420type OxmIdTunMetadata50Masked struct {
24421 *OxmId
24422}
24423
24424type IOxmIdTunMetadata50Masked interface {
24425 IOxmId
24426}
24427
24428func (self *OxmIdTunMetadata50Masked) Serialize(encoder *goloxi.Encoder) error {
24429 if err := self.OxmId.Serialize(encoder); err != nil {
24430 return err
24431 }
24432
24433 return nil
24434}
24435
24436func DecodeOxmIdTunMetadata50Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata50Masked, error) {
24437 _oxmidtunmetadata50masked := &OxmIdTunMetadata50Masked{OxmId: parent}
24438 return _oxmidtunmetadata50masked, nil
24439}
24440
24441func NewOxmIdTunMetadata50Masked() *OxmIdTunMetadata50Masked {
24442 obj := &OxmIdTunMetadata50Masked{
24443 OxmId: NewOxmId(112120),
24444 }
24445 return obj
24446}
24447func (self *OxmIdTunMetadata50Masked) GetOXMName() string {
24448 return "tun_metadata50_masked"
24449}
24450
24451func (self *OxmIdTunMetadata50Masked) MarshalJSON() ([]byte, error) {
24452 if self.TypeLen == 0 {
24453 return []byte("\"\""), nil
24454 } else {
24455 return []byte("\"" + self.GetOXMName() + "\""), nil
24456 }
24457}
24458
24459type OxmIdTunMetadata51 struct {
24460 *OxmId
24461}
24462
24463type IOxmIdTunMetadata51 interface {
24464 IOxmId
24465}
24466
24467func (self *OxmIdTunMetadata51) Serialize(encoder *goloxi.Encoder) error {
24468 if err := self.OxmId.Serialize(encoder); err != nil {
24469 return err
24470 }
24471
24472 return nil
24473}
24474
24475func DecodeOxmIdTunMetadata51(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata51, error) {
24476 _oxmidtunmetadata51 := &OxmIdTunMetadata51{OxmId: parent}
24477 return _oxmidtunmetadata51, nil
24478}
24479
24480func NewOxmIdTunMetadata51() *OxmIdTunMetadata51 {
24481 obj := &OxmIdTunMetadata51{
24482 OxmId: NewOxmId(112252),
24483 }
24484 return obj
24485}
24486func (self *OxmIdTunMetadata51) GetOXMName() string {
24487 return "tun_metadata51"
24488}
24489
24490func (self *OxmIdTunMetadata51) MarshalJSON() ([]byte, error) {
24491 if self.TypeLen == 0 {
24492 return []byte("\"\""), nil
24493 } else {
24494 return []byte("\"" + self.GetOXMName() + "\""), nil
24495 }
24496}
24497
24498type OxmIdTunMetadata51Masked struct {
24499 *OxmId
24500}
24501
24502type IOxmIdTunMetadata51Masked interface {
24503 IOxmId
24504}
24505
24506func (self *OxmIdTunMetadata51Masked) Serialize(encoder *goloxi.Encoder) error {
24507 if err := self.OxmId.Serialize(encoder); err != nil {
24508 return err
24509 }
24510
24511 return nil
24512}
24513
24514func DecodeOxmIdTunMetadata51Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata51Masked, error) {
24515 _oxmidtunmetadata51masked := &OxmIdTunMetadata51Masked{OxmId: parent}
24516 return _oxmidtunmetadata51masked, nil
24517}
24518
24519func NewOxmIdTunMetadata51Masked() *OxmIdTunMetadata51Masked {
24520 obj := &OxmIdTunMetadata51Masked{
24521 OxmId: NewOxmId(112632),
24522 }
24523 return obj
24524}
24525func (self *OxmIdTunMetadata51Masked) GetOXMName() string {
24526 return "tun_metadata51_masked"
24527}
24528
24529func (self *OxmIdTunMetadata51Masked) MarshalJSON() ([]byte, error) {
24530 if self.TypeLen == 0 {
24531 return []byte("\"\""), nil
24532 } else {
24533 return []byte("\"" + self.GetOXMName() + "\""), nil
24534 }
24535}
24536
24537type OxmIdTunMetadata52 struct {
24538 *OxmId
24539}
24540
24541type IOxmIdTunMetadata52 interface {
24542 IOxmId
24543}
24544
24545func (self *OxmIdTunMetadata52) Serialize(encoder *goloxi.Encoder) error {
24546 if err := self.OxmId.Serialize(encoder); err != nil {
24547 return err
24548 }
24549
24550 return nil
24551}
24552
24553func DecodeOxmIdTunMetadata52(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata52, error) {
24554 _oxmidtunmetadata52 := &OxmIdTunMetadata52{OxmId: parent}
24555 return _oxmidtunmetadata52, nil
24556}
24557
24558func NewOxmIdTunMetadata52() *OxmIdTunMetadata52 {
24559 obj := &OxmIdTunMetadata52{
24560 OxmId: NewOxmId(112764),
24561 }
24562 return obj
24563}
24564func (self *OxmIdTunMetadata52) GetOXMName() string {
24565 return "tun_metadata52"
24566}
24567
24568func (self *OxmIdTunMetadata52) MarshalJSON() ([]byte, error) {
24569 if self.TypeLen == 0 {
24570 return []byte("\"\""), nil
24571 } else {
24572 return []byte("\"" + self.GetOXMName() + "\""), nil
24573 }
24574}
24575
24576type OxmIdTunMetadata52Masked struct {
24577 *OxmId
24578}
24579
24580type IOxmIdTunMetadata52Masked interface {
24581 IOxmId
24582}
24583
24584func (self *OxmIdTunMetadata52Masked) Serialize(encoder *goloxi.Encoder) error {
24585 if err := self.OxmId.Serialize(encoder); err != nil {
24586 return err
24587 }
24588
24589 return nil
24590}
24591
24592func DecodeOxmIdTunMetadata52Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata52Masked, error) {
24593 _oxmidtunmetadata52masked := &OxmIdTunMetadata52Masked{OxmId: parent}
24594 return _oxmidtunmetadata52masked, nil
24595}
24596
24597func NewOxmIdTunMetadata52Masked() *OxmIdTunMetadata52Masked {
24598 obj := &OxmIdTunMetadata52Masked{
24599 OxmId: NewOxmId(113144),
24600 }
24601 return obj
24602}
24603func (self *OxmIdTunMetadata52Masked) GetOXMName() string {
24604 return "tun_metadata52_masked"
24605}
24606
24607func (self *OxmIdTunMetadata52Masked) MarshalJSON() ([]byte, error) {
24608 if self.TypeLen == 0 {
24609 return []byte("\"\""), nil
24610 } else {
24611 return []byte("\"" + self.GetOXMName() + "\""), nil
24612 }
24613}
24614
24615type OxmIdTunMetadata53 struct {
24616 *OxmId
24617}
24618
24619type IOxmIdTunMetadata53 interface {
24620 IOxmId
24621}
24622
24623func (self *OxmIdTunMetadata53) Serialize(encoder *goloxi.Encoder) error {
24624 if err := self.OxmId.Serialize(encoder); err != nil {
24625 return err
24626 }
24627
24628 return nil
24629}
24630
24631func DecodeOxmIdTunMetadata53(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata53, error) {
24632 _oxmidtunmetadata53 := &OxmIdTunMetadata53{OxmId: parent}
24633 return _oxmidtunmetadata53, nil
24634}
24635
24636func NewOxmIdTunMetadata53() *OxmIdTunMetadata53 {
24637 obj := &OxmIdTunMetadata53{
24638 OxmId: NewOxmId(113276),
24639 }
24640 return obj
24641}
24642func (self *OxmIdTunMetadata53) GetOXMName() string {
24643 return "tun_metadata53"
24644}
24645
24646func (self *OxmIdTunMetadata53) MarshalJSON() ([]byte, error) {
24647 if self.TypeLen == 0 {
24648 return []byte("\"\""), nil
24649 } else {
24650 return []byte("\"" + self.GetOXMName() + "\""), nil
24651 }
24652}
24653
24654type OxmIdTunMetadata53Masked struct {
24655 *OxmId
24656}
24657
24658type IOxmIdTunMetadata53Masked interface {
24659 IOxmId
24660}
24661
24662func (self *OxmIdTunMetadata53Masked) Serialize(encoder *goloxi.Encoder) error {
24663 if err := self.OxmId.Serialize(encoder); err != nil {
24664 return err
24665 }
24666
24667 return nil
24668}
24669
24670func DecodeOxmIdTunMetadata53Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata53Masked, error) {
24671 _oxmidtunmetadata53masked := &OxmIdTunMetadata53Masked{OxmId: parent}
24672 return _oxmidtunmetadata53masked, nil
24673}
24674
24675func NewOxmIdTunMetadata53Masked() *OxmIdTunMetadata53Masked {
24676 obj := &OxmIdTunMetadata53Masked{
24677 OxmId: NewOxmId(113656),
24678 }
24679 return obj
24680}
24681func (self *OxmIdTunMetadata53Masked) GetOXMName() string {
24682 return "tun_metadata53_masked"
24683}
24684
24685func (self *OxmIdTunMetadata53Masked) MarshalJSON() ([]byte, error) {
24686 if self.TypeLen == 0 {
24687 return []byte("\"\""), nil
24688 } else {
24689 return []byte("\"" + self.GetOXMName() + "\""), nil
24690 }
24691}
24692
24693type OxmIdTunMetadata54 struct {
24694 *OxmId
24695}
24696
24697type IOxmIdTunMetadata54 interface {
24698 IOxmId
24699}
24700
24701func (self *OxmIdTunMetadata54) Serialize(encoder *goloxi.Encoder) error {
24702 if err := self.OxmId.Serialize(encoder); err != nil {
24703 return err
24704 }
24705
24706 return nil
24707}
24708
24709func DecodeOxmIdTunMetadata54(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata54, error) {
24710 _oxmidtunmetadata54 := &OxmIdTunMetadata54{OxmId: parent}
24711 return _oxmidtunmetadata54, nil
24712}
24713
24714func NewOxmIdTunMetadata54() *OxmIdTunMetadata54 {
24715 obj := &OxmIdTunMetadata54{
24716 OxmId: NewOxmId(113788),
24717 }
24718 return obj
24719}
24720func (self *OxmIdTunMetadata54) GetOXMName() string {
24721 return "tun_metadata54"
24722}
24723
24724func (self *OxmIdTunMetadata54) MarshalJSON() ([]byte, error) {
24725 if self.TypeLen == 0 {
24726 return []byte("\"\""), nil
24727 } else {
24728 return []byte("\"" + self.GetOXMName() + "\""), nil
24729 }
24730}
24731
24732type OxmIdTunMetadata54Masked struct {
24733 *OxmId
24734}
24735
24736type IOxmIdTunMetadata54Masked interface {
24737 IOxmId
24738}
24739
24740func (self *OxmIdTunMetadata54Masked) Serialize(encoder *goloxi.Encoder) error {
24741 if err := self.OxmId.Serialize(encoder); err != nil {
24742 return err
24743 }
24744
24745 return nil
24746}
24747
24748func DecodeOxmIdTunMetadata54Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata54Masked, error) {
24749 _oxmidtunmetadata54masked := &OxmIdTunMetadata54Masked{OxmId: parent}
24750 return _oxmidtunmetadata54masked, nil
24751}
24752
24753func NewOxmIdTunMetadata54Masked() *OxmIdTunMetadata54Masked {
24754 obj := &OxmIdTunMetadata54Masked{
24755 OxmId: NewOxmId(114168),
24756 }
24757 return obj
24758}
24759func (self *OxmIdTunMetadata54Masked) GetOXMName() string {
24760 return "tun_metadata54_masked"
24761}
24762
24763func (self *OxmIdTunMetadata54Masked) MarshalJSON() ([]byte, error) {
24764 if self.TypeLen == 0 {
24765 return []byte("\"\""), nil
24766 } else {
24767 return []byte("\"" + self.GetOXMName() + "\""), nil
24768 }
24769}
24770
24771type OxmIdTunMetadata55 struct {
24772 *OxmId
24773}
24774
24775type IOxmIdTunMetadata55 interface {
24776 IOxmId
24777}
24778
24779func (self *OxmIdTunMetadata55) Serialize(encoder *goloxi.Encoder) error {
24780 if err := self.OxmId.Serialize(encoder); err != nil {
24781 return err
24782 }
24783
24784 return nil
24785}
24786
24787func DecodeOxmIdTunMetadata55(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata55, error) {
24788 _oxmidtunmetadata55 := &OxmIdTunMetadata55{OxmId: parent}
24789 return _oxmidtunmetadata55, nil
24790}
24791
24792func NewOxmIdTunMetadata55() *OxmIdTunMetadata55 {
24793 obj := &OxmIdTunMetadata55{
24794 OxmId: NewOxmId(114300),
24795 }
24796 return obj
24797}
24798func (self *OxmIdTunMetadata55) GetOXMName() string {
24799 return "tun_metadata55"
24800}
24801
24802func (self *OxmIdTunMetadata55) MarshalJSON() ([]byte, error) {
24803 if self.TypeLen == 0 {
24804 return []byte("\"\""), nil
24805 } else {
24806 return []byte("\"" + self.GetOXMName() + "\""), nil
24807 }
24808}
24809
24810type OxmIdTunMetadata55Masked struct {
24811 *OxmId
24812}
24813
24814type IOxmIdTunMetadata55Masked interface {
24815 IOxmId
24816}
24817
24818func (self *OxmIdTunMetadata55Masked) Serialize(encoder *goloxi.Encoder) error {
24819 if err := self.OxmId.Serialize(encoder); err != nil {
24820 return err
24821 }
24822
24823 return nil
24824}
24825
24826func DecodeOxmIdTunMetadata55Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata55Masked, error) {
24827 _oxmidtunmetadata55masked := &OxmIdTunMetadata55Masked{OxmId: parent}
24828 return _oxmidtunmetadata55masked, nil
24829}
24830
24831func NewOxmIdTunMetadata55Masked() *OxmIdTunMetadata55Masked {
24832 obj := &OxmIdTunMetadata55Masked{
24833 OxmId: NewOxmId(114680),
24834 }
24835 return obj
24836}
24837func (self *OxmIdTunMetadata55Masked) GetOXMName() string {
24838 return "tun_metadata55_masked"
24839}
24840
24841func (self *OxmIdTunMetadata55Masked) MarshalJSON() ([]byte, error) {
24842 if self.TypeLen == 0 {
24843 return []byte("\"\""), nil
24844 } else {
24845 return []byte("\"" + self.GetOXMName() + "\""), nil
24846 }
24847}
24848
24849type OxmIdTunMetadata56 struct {
24850 *OxmId
24851}
24852
24853type IOxmIdTunMetadata56 interface {
24854 IOxmId
24855}
24856
24857func (self *OxmIdTunMetadata56) Serialize(encoder *goloxi.Encoder) error {
24858 if err := self.OxmId.Serialize(encoder); err != nil {
24859 return err
24860 }
24861
24862 return nil
24863}
24864
24865func DecodeOxmIdTunMetadata56(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata56, error) {
24866 _oxmidtunmetadata56 := &OxmIdTunMetadata56{OxmId: parent}
24867 return _oxmidtunmetadata56, nil
24868}
24869
24870func NewOxmIdTunMetadata56() *OxmIdTunMetadata56 {
24871 obj := &OxmIdTunMetadata56{
24872 OxmId: NewOxmId(114812),
24873 }
24874 return obj
24875}
24876func (self *OxmIdTunMetadata56) GetOXMName() string {
24877 return "tun_metadata56"
24878}
24879
24880func (self *OxmIdTunMetadata56) MarshalJSON() ([]byte, error) {
24881 if self.TypeLen == 0 {
24882 return []byte("\"\""), nil
24883 } else {
24884 return []byte("\"" + self.GetOXMName() + "\""), nil
24885 }
24886}
24887
24888type OxmIdTunMetadata56Masked struct {
24889 *OxmId
24890}
24891
24892type IOxmIdTunMetadata56Masked interface {
24893 IOxmId
24894}
24895
24896func (self *OxmIdTunMetadata56Masked) Serialize(encoder *goloxi.Encoder) error {
24897 if err := self.OxmId.Serialize(encoder); err != nil {
24898 return err
24899 }
24900
24901 return nil
24902}
24903
24904func DecodeOxmIdTunMetadata56Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata56Masked, error) {
24905 _oxmidtunmetadata56masked := &OxmIdTunMetadata56Masked{OxmId: parent}
24906 return _oxmidtunmetadata56masked, nil
24907}
24908
24909func NewOxmIdTunMetadata56Masked() *OxmIdTunMetadata56Masked {
24910 obj := &OxmIdTunMetadata56Masked{
24911 OxmId: NewOxmId(115192),
24912 }
24913 return obj
24914}
24915func (self *OxmIdTunMetadata56Masked) GetOXMName() string {
24916 return "tun_metadata56_masked"
24917}
24918
24919func (self *OxmIdTunMetadata56Masked) MarshalJSON() ([]byte, error) {
24920 if self.TypeLen == 0 {
24921 return []byte("\"\""), nil
24922 } else {
24923 return []byte("\"" + self.GetOXMName() + "\""), nil
24924 }
24925}
24926
24927type OxmIdTunMetadata57 struct {
24928 *OxmId
24929}
24930
24931type IOxmIdTunMetadata57 interface {
24932 IOxmId
24933}
24934
24935func (self *OxmIdTunMetadata57) Serialize(encoder *goloxi.Encoder) error {
24936 if err := self.OxmId.Serialize(encoder); err != nil {
24937 return err
24938 }
24939
24940 return nil
24941}
24942
24943func DecodeOxmIdTunMetadata57(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata57, error) {
24944 _oxmidtunmetadata57 := &OxmIdTunMetadata57{OxmId: parent}
24945 return _oxmidtunmetadata57, nil
24946}
24947
24948func NewOxmIdTunMetadata57() *OxmIdTunMetadata57 {
24949 obj := &OxmIdTunMetadata57{
24950 OxmId: NewOxmId(115324),
24951 }
24952 return obj
24953}
24954func (self *OxmIdTunMetadata57) GetOXMName() string {
24955 return "tun_metadata57"
24956}
24957
24958func (self *OxmIdTunMetadata57) MarshalJSON() ([]byte, error) {
24959 if self.TypeLen == 0 {
24960 return []byte("\"\""), nil
24961 } else {
24962 return []byte("\"" + self.GetOXMName() + "\""), nil
24963 }
24964}
24965
24966type OxmIdTunMetadata57Masked struct {
24967 *OxmId
24968}
24969
24970type IOxmIdTunMetadata57Masked interface {
24971 IOxmId
24972}
24973
24974func (self *OxmIdTunMetadata57Masked) Serialize(encoder *goloxi.Encoder) error {
24975 if err := self.OxmId.Serialize(encoder); err != nil {
24976 return err
24977 }
24978
24979 return nil
24980}
24981
24982func DecodeOxmIdTunMetadata57Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata57Masked, error) {
24983 _oxmidtunmetadata57masked := &OxmIdTunMetadata57Masked{OxmId: parent}
24984 return _oxmidtunmetadata57masked, nil
24985}
24986
24987func NewOxmIdTunMetadata57Masked() *OxmIdTunMetadata57Masked {
24988 obj := &OxmIdTunMetadata57Masked{
24989 OxmId: NewOxmId(115704),
24990 }
24991 return obj
24992}
24993func (self *OxmIdTunMetadata57Masked) GetOXMName() string {
24994 return "tun_metadata57_masked"
24995}
24996
24997func (self *OxmIdTunMetadata57Masked) MarshalJSON() ([]byte, error) {
24998 if self.TypeLen == 0 {
24999 return []byte("\"\""), nil
25000 } else {
25001 return []byte("\"" + self.GetOXMName() + "\""), nil
25002 }
25003}
25004
25005type OxmIdTunMetadata58 struct {
25006 *OxmId
25007}
25008
25009type IOxmIdTunMetadata58 interface {
25010 IOxmId
25011}
25012
25013func (self *OxmIdTunMetadata58) Serialize(encoder *goloxi.Encoder) error {
25014 if err := self.OxmId.Serialize(encoder); err != nil {
25015 return err
25016 }
25017
25018 return nil
25019}
25020
25021func DecodeOxmIdTunMetadata58(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata58, error) {
25022 _oxmidtunmetadata58 := &OxmIdTunMetadata58{OxmId: parent}
25023 return _oxmidtunmetadata58, nil
25024}
25025
25026func NewOxmIdTunMetadata58() *OxmIdTunMetadata58 {
25027 obj := &OxmIdTunMetadata58{
25028 OxmId: NewOxmId(115836),
25029 }
25030 return obj
25031}
25032func (self *OxmIdTunMetadata58) GetOXMName() string {
25033 return "tun_metadata58"
25034}
25035
25036func (self *OxmIdTunMetadata58) MarshalJSON() ([]byte, error) {
25037 if self.TypeLen == 0 {
25038 return []byte("\"\""), nil
25039 } else {
25040 return []byte("\"" + self.GetOXMName() + "\""), nil
25041 }
25042}
25043
25044type OxmIdTunMetadata58Masked struct {
25045 *OxmId
25046}
25047
25048type IOxmIdTunMetadata58Masked interface {
25049 IOxmId
25050}
25051
25052func (self *OxmIdTunMetadata58Masked) Serialize(encoder *goloxi.Encoder) error {
25053 if err := self.OxmId.Serialize(encoder); err != nil {
25054 return err
25055 }
25056
25057 return nil
25058}
25059
25060func DecodeOxmIdTunMetadata58Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata58Masked, error) {
25061 _oxmidtunmetadata58masked := &OxmIdTunMetadata58Masked{OxmId: parent}
25062 return _oxmidtunmetadata58masked, nil
25063}
25064
25065func NewOxmIdTunMetadata58Masked() *OxmIdTunMetadata58Masked {
25066 obj := &OxmIdTunMetadata58Masked{
25067 OxmId: NewOxmId(116216),
25068 }
25069 return obj
25070}
25071func (self *OxmIdTunMetadata58Masked) GetOXMName() string {
25072 return "tun_metadata58_masked"
25073}
25074
25075func (self *OxmIdTunMetadata58Masked) MarshalJSON() ([]byte, error) {
25076 if self.TypeLen == 0 {
25077 return []byte("\"\""), nil
25078 } else {
25079 return []byte("\"" + self.GetOXMName() + "\""), nil
25080 }
25081}
25082
25083type OxmIdTunMetadata59 struct {
25084 *OxmId
25085}
25086
25087type IOxmIdTunMetadata59 interface {
25088 IOxmId
25089}
25090
25091func (self *OxmIdTunMetadata59) Serialize(encoder *goloxi.Encoder) error {
25092 if err := self.OxmId.Serialize(encoder); err != nil {
25093 return err
25094 }
25095
25096 return nil
25097}
25098
25099func DecodeOxmIdTunMetadata59(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata59, error) {
25100 _oxmidtunmetadata59 := &OxmIdTunMetadata59{OxmId: parent}
25101 return _oxmidtunmetadata59, nil
25102}
25103
25104func NewOxmIdTunMetadata59() *OxmIdTunMetadata59 {
25105 obj := &OxmIdTunMetadata59{
25106 OxmId: NewOxmId(116348),
25107 }
25108 return obj
25109}
25110func (self *OxmIdTunMetadata59) GetOXMName() string {
25111 return "tun_metadata59"
25112}
25113
25114func (self *OxmIdTunMetadata59) MarshalJSON() ([]byte, error) {
25115 if self.TypeLen == 0 {
25116 return []byte("\"\""), nil
25117 } else {
25118 return []byte("\"" + self.GetOXMName() + "\""), nil
25119 }
25120}
25121
25122type OxmIdTunMetadata59Masked struct {
25123 *OxmId
25124}
25125
25126type IOxmIdTunMetadata59Masked interface {
25127 IOxmId
25128}
25129
25130func (self *OxmIdTunMetadata59Masked) Serialize(encoder *goloxi.Encoder) error {
25131 if err := self.OxmId.Serialize(encoder); err != nil {
25132 return err
25133 }
25134
25135 return nil
25136}
25137
25138func DecodeOxmIdTunMetadata59Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata59Masked, error) {
25139 _oxmidtunmetadata59masked := &OxmIdTunMetadata59Masked{OxmId: parent}
25140 return _oxmidtunmetadata59masked, nil
25141}
25142
25143func NewOxmIdTunMetadata59Masked() *OxmIdTunMetadata59Masked {
25144 obj := &OxmIdTunMetadata59Masked{
25145 OxmId: NewOxmId(116728),
25146 }
25147 return obj
25148}
25149func (self *OxmIdTunMetadata59Masked) GetOXMName() string {
25150 return "tun_metadata59_masked"
25151}
25152
25153func (self *OxmIdTunMetadata59Masked) MarshalJSON() ([]byte, error) {
25154 if self.TypeLen == 0 {
25155 return []byte("\"\""), nil
25156 } else {
25157 return []byte("\"" + self.GetOXMName() + "\""), nil
25158 }
25159}
25160
25161type OxmIdTunMetadata5Masked struct {
25162 *OxmId
25163}
25164
25165type IOxmIdTunMetadata5Masked interface {
25166 IOxmId
25167}
25168
25169func (self *OxmIdTunMetadata5Masked) Serialize(encoder *goloxi.Encoder) error {
25170 if err := self.OxmId.Serialize(encoder); err != nil {
25171 return err
25172 }
25173
25174 return nil
25175}
25176
25177func DecodeOxmIdTunMetadata5Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata5Masked, error) {
25178 _oxmidtunmetadata5masked := &OxmIdTunMetadata5Masked{OxmId: parent}
25179 return _oxmidtunmetadata5masked, nil
25180}
25181
25182func NewOxmIdTunMetadata5Masked() *OxmIdTunMetadata5Masked {
25183 obj := &OxmIdTunMetadata5Masked{
25184 OxmId: NewOxmId(89080),
25185 }
25186 return obj
25187}
25188func (self *OxmIdTunMetadata5Masked) GetOXMName() string {
25189 return "tun_metadata5_masked"
25190}
25191
25192func (self *OxmIdTunMetadata5Masked) MarshalJSON() ([]byte, error) {
25193 if self.TypeLen == 0 {
25194 return []byte("\"\""), nil
25195 } else {
25196 return []byte("\"" + self.GetOXMName() + "\""), nil
25197 }
25198}
25199
25200type OxmIdTunMetadata6 struct {
25201 *OxmId
25202}
25203
25204type IOxmIdTunMetadata6 interface {
25205 IOxmId
25206}
25207
25208func (self *OxmIdTunMetadata6) Serialize(encoder *goloxi.Encoder) error {
25209 if err := self.OxmId.Serialize(encoder); err != nil {
25210 return err
25211 }
25212
25213 return nil
25214}
25215
25216func DecodeOxmIdTunMetadata6(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata6, error) {
25217 _oxmidtunmetadata6 := &OxmIdTunMetadata6{OxmId: parent}
25218 return _oxmidtunmetadata6, nil
25219}
25220
25221func NewOxmIdTunMetadata6() *OxmIdTunMetadata6 {
25222 obj := &OxmIdTunMetadata6{
25223 OxmId: NewOxmId(89212),
25224 }
25225 return obj
25226}
25227func (self *OxmIdTunMetadata6) GetOXMName() string {
25228 return "tun_metadata6"
25229}
25230
25231func (self *OxmIdTunMetadata6) MarshalJSON() ([]byte, error) {
25232 if self.TypeLen == 0 {
25233 return []byte("\"\""), nil
25234 } else {
25235 return []byte("\"" + self.GetOXMName() + "\""), nil
25236 }
25237}
25238
25239type OxmIdTunMetadata60 struct {
25240 *OxmId
25241}
25242
25243type IOxmIdTunMetadata60 interface {
25244 IOxmId
25245}
25246
25247func (self *OxmIdTunMetadata60) Serialize(encoder *goloxi.Encoder) error {
25248 if err := self.OxmId.Serialize(encoder); err != nil {
25249 return err
25250 }
25251
25252 return nil
25253}
25254
25255func DecodeOxmIdTunMetadata60(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata60, error) {
25256 _oxmidtunmetadata60 := &OxmIdTunMetadata60{OxmId: parent}
25257 return _oxmidtunmetadata60, nil
25258}
25259
25260func NewOxmIdTunMetadata60() *OxmIdTunMetadata60 {
25261 obj := &OxmIdTunMetadata60{
25262 OxmId: NewOxmId(116860),
25263 }
25264 return obj
25265}
25266func (self *OxmIdTunMetadata60) GetOXMName() string {
25267 return "tun_metadata60"
25268}
25269
25270func (self *OxmIdTunMetadata60) MarshalJSON() ([]byte, error) {
25271 if self.TypeLen == 0 {
25272 return []byte("\"\""), nil
25273 } else {
25274 return []byte("\"" + self.GetOXMName() + "\""), nil
25275 }
25276}
25277
25278type OxmIdTunMetadata60Masked struct {
25279 *OxmId
25280}
25281
25282type IOxmIdTunMetadata60Masked interface {
25283 IOxmId
25284}
25285
25286func (self *OxmIdTunMetadata60Masked) Serialize(encoder *goloxi.Encoder) error {
25287 if err := self.OxmId.Serialize(encoder); err != nil {
25288 return err
25289 }
25290
25291 return nil
25292}
25293
25294func DecodeOxmIdTunMetadata60Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata60Masked, error) {
25295 _oxmidtunmetadata60masked := &OxmIdTunMetadata60Masked{OxmId: parent}
25296 return _oxmidtunmetadata60masked, nil
25297}
25298
25299func NewOxmIdTunMetadata60Masked() *OxmIdTunMetadata60Masked {
25300 obj := &OxmIdTunMetadata60Masked{
25301 OxmId: NewOxmId(117240),
25302 }
25303 return obj
25304}
25305func (self *OxmIdTunMetadata60Masked) GetOXMName() string {
25306 return "tun_metadata60_masked"
25307}
25308
25309func (self *OxmIdTunMetadata60Masked) MarshalJSON() ([]byte, error) {
25310 if self.TypeLen == 0 {
25311 return []byte("\"\""), nil
25312 } else {
25313 return []byte("\"" + self.GetOXMName() + "\""), nil
25314 }
25315}
25316
25317type OxmIdTunMetadata61 struct {
25318 *OxmId
25319}
25320
25321type IOxmIdTunMetadata61 interface {
25322 IOxmId
25323}
25324
25325func (self *OxmIdTunMetadata61) Serialize(encoder *goloxi.Encoder) error {
25326 if err := self.OxmId.Serialize(encoder); err != nil {
25327 return err
25328 }
25329
25330 return nil
25331}
25332
25333func DecodeOxmIdTunMetadata61(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata61, error) {
25334 _oxmidtunmetadata61 := &OxmIdTunMetadata61{OxmId: parent}
25335 return _oxmidtunmetadata61, nil
25336}
25337
25338func NewOxmIdTunMetadata61() *OxmIdTunMetadata61 {
25339 obj := &OxmIdTunMetadata61{
25340 OxmId: NewOxmId(117372),
25341 }
25342 return obj
25343}
25344func (self *OxmIdTunMetadata61) GetOXMName() string {
25345 return "tun_metadata61"
25346}
25347
25348func (self *OxmIdTunMetadata61) MarshalJSON() ([]byte, error) {
25349 if self.TypeLen == 0 {
25350 return []byte("\"\""), nil
25351 } else {
25352 return []byte("\"" + self.GetOXMName() + "\""), nil
25353 }
25354}
25355
25356type OxmIdTunMetadata61Masked struct {
25357 *OxmId
25358}
25359
25360type IOxmIdTunMetadata61Masked interface {
25361 IOxmId
25362}
25363
25364func (self *OxmIdTunMetadata61Masked) Serialize(encoder *goloxi.Encoder) error {
25365 if err := self.OxmId.Serialize(encoder); err != nil {
25366 return err
25367 }
25368
25369 return nil
25370}
25371
25372func DecodeOxmIdTunMetadata61Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata61Masked, error) {
25373 _oxmidtunmetadata61masked := &OxmIdTunMetadata61Masked{OxmId: parent}
25374 return _oxmidtunmetadata61masked, nil
25375}
25376
25377func NewOxmIdTunMetadata61Masked() *OxmIdTunMetadata61Masked {
25378 obj := &OxmIdTunMetadata61Masked{
25379 OxmId: NewOxmId(117752),
25380 }
25381 return obj
25382}
25383func (self *OxmIdTunMetadata61Masked) GetOXMName() string {
25384 return "tun_metadata61_masked"
25385}
25386
25387func (self *OxmIdTunMetadata61Masked) MarshalJSON() ([]byte, error) {
25388 if self.TypeLen == 0 {
25389 return []byte("\"\""), nil
25390 } else {
25391 return []byte("\"" + self.GetOXMName() + "\""), nil
25392 }
25393}
25394
25395type OxmIdTunMetadata62 struct {
25396 *OxmId
25397}
25398
25399type IOxmIdTunMetadata62 interface {
25400 IOxmId
25401}
25402
25403func (self *OxmIdTunMetadata62) Serialize(encoder *goloxi.Encoder) error {
25404 if err := self.OxmId.Serialize(encoder); err != nil {
25405 return err
25406 }
25407
25408 return nil
25409}
25410
25411func DecodeOxmIdTunMetadata62(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata62, error) {
25412 _oxmidtunmetadata62 := &OxmIdTunMetadata62{OxmId: parent}
25413 return _oxmidtunmetadata62, nil
25414}
25415
25416func NewOxmIdTunMetadata62() *OxmIdTunMetadata62 {
25417 obj := &OxmIdTunMetadata62{
25418 OxmId: NewOxmId(117884),
25419 }
25420 return obj
25421}
25422func (self *OxmIdTunMetadata62) GetOXMName() string {
25423 return "tun_metadata62"
25424}
25425
25426func (self *OxmIdTunMetadata62) MarshalJSON() ([]byte, error) {
25427 if self.TypeLen == 0 {
25428 return []byte("\"\""), nil
25429 } else {
25430 return []byte("\"" + self.GetOXMName() + "\""), nil
25431 }
25432}
25433
25434type OxmIdTunMetadata62Masked struct {
25435 *OxmId
25436}
25437
25438type IOxmIdTunMetadata62Masked interface {
25439 IOxmId
25440}
25441
25442func (self *OxmIdTunMetadata62Masked) Serialize(encoder *goloxi.Encoder) error {
25443 if err := self.OxmId.Serialize(encoder); err != nil {
25444 return err
25445 }
25446
25447 return nil
25448}
25449
25450func DecodeOxmIdTunMetadata62Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata62Masked, error) {
25451 _oxmidtunmetadata62masked := &OxmIdTunMetadata62Masked{OxmId: parent}
25452 return _oxmidtunmetadata62masked, nil
25453}
25454
25455func NewOxmIdTunMetadata62Masked() *OxmIdTunMetadata62Masked {
25456 obj := &OxmIdTunMetadata62Masked{
25457 OxmId: NewOxmId(118264),
25458 }
25459 return obj
25460}
25461func (self *OxmIdTunMetadata62Masked) GetOXMName() string {
25462 return "tun_metadata62_masked"
25463}
25464
25465func (self *OxmIdTunMetadata62Masked) MarshalJSON() ([]byte, error) {
25466 if self.TypeLen == 0 {
25467 return []byte("\"\""), nil
25468 } else {
25469 return []byte("\"" + self.GetOXMName() + "\""), nil
25470 }
25471}
25472
25473type OxmIdTunMetadata63 struct {
25474 *OxmId
25475}
25476
25477type IOxmIdTunMetadata63 interface {
25478 IOxmId
25479}
25480
25481func (self *OxmIdTunMetadata63) Serialize(encoder *goloxi.Encoder) error {
25482 if err := self.OxmId.Serialize(encoder); err != nil {
25483 return err
25484 }
25485
25486 return nil
25487}
25488
25489func DecodeOxmIdTunMetadata63(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata63, error) {
25490 _oxmidtunmetadata63 := &OxmIdTunMetadata63{OxmId: parent}
25491 return _oxmidtunmetadata63, nil
25492}
25493
25494func NewOxmIdTunMetadata63() *OxmIdTunMetadata63 {
25495 obj := &OxmIdTunMetadata63{
25496 OxmId: NewOxmId(118396),
25497 }
25498 return obj
25499}
25500func (self *OxmIdTunMetadata63) GetOXMName() string {
25501 return "tun_metadata63"
25502}
25503
25504func (self *OxmIdTunMetadata63) MarshalJSON() ([]byte, error) {
25505 if self.TypeLen == 0 {
25506 return []byte("\"\""), nil
25507 } else {
25508 return []byte("\"" + self.GetOXMName() + "\""), nil
25509 }
25510}
25511
25512type OxmIdTunMetadata63Masked struct {
25513 *OxmId
25514}
25515
25516type IOxmIdTunMetadata63Masked interface {
25517 IOxmId
25518}
25519
25520func (self *OxmIdTunMetadata63Masked) Serialize(encoder *goloxi.Encoder) error {
25521 if err := self.OxmId.Serialize(encoder); err != nil {
25522 return err
25523 }
25524
25525 return nil
25526}
25527
25528func DecodeOxmIdTunMetadata63Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata63Masked, error) {
25529 _oxmidtunmetadata63masked := &OxmIdTunMetadata63Masked{OxmId: parent}
25530 return _oxmidtunmetadata63masked, nil
25531}
25532
25533func NewOxmIdTunMetadata63Masked() *OxmIdTunMetadata63Masked {
25534 obj := &OxmIdTunMetadata63Masked{
25535 OxmId: NewOxmId(118776),
25536 }
25537 return obj
25538}
25539func (self *OxmIdTunMetadata63Masked) GetOXMName() string {
25540 return "tun_metadata63_masked"
25541}
25542
25543func (self *OxmIdTunMetadata63Masked) MarshalJSON() ([]byte, error) {
25544 if self.TypeLen == 0 {
25545 return []byte("\"\""), nil
25546 } else {
25547 return []byte("\"" + self.GetOXMName() + "\""), nil
25548 }
25549}
25550
25551type OxmIdTunMetadata6Masked struct {
25552 *OxmId
25553}
25554
25555type IOxmIdTunMetadata6Masked interface {
25556 IOxmId
25557}
25558
25559func (self *OxmIdTunMetadata6Masked) Serialize(encoder *goloxi.Encoder) error {
25560 if err := self.OxmId.Serialize(encoder); err != nil {
25561 return err
25562 }
25563
25564 return nil
25565}
25566
25567func DecodeOxmIdTunMetadata6Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata6Masked, error) {
25568 _oxmidtunmetadata6masked := &OxmIdTunMetadata6Masked{OxmId: parent}
25569 return _oxmidtunmetadata6masked, nil
25570}
25571
25572func NewOxmIdTunMetadata6Masked() *OxmIdTunMetadata6Masked {
25573 obj := &OxmIdTunMetadata6Masked{
25574 OxmId: NewOxmId(89592),
25575 }
25576 return obj
25577}
25578func (self *OxmIdTunMetadata6Masked) GetOXMName() string {
25579 return "tun_metadata6_masked"
25580}
25581
25582func (self *OxmIdTunMetadata6Masked) MarshalJSON() ([]byte, error) {
25583 if self.TypeLen == 0 {
25584 return []byte("\"\""), nil
25585 } else {
25586 return []byte("\"" + self.GetOXMName() + "\""), nil
25587 }
25588}
25589
25590type OxmIdTunMetadata7 struct {
25591 *OxmId
25592}
25593
25594type IOxmIdTunMetadata7 interface {
25595 IOxmId
25596}
25597
25598func (self *OxmIdTunMetadata7) Serialize(encoder *goloxi.Encoder) error {
25599 if err := self.OxmId.Serialize(encoder); err != nil {
25600 return err
25601 }
25602
25603 return nil
25604}
25605
25606func DecodeOxmIdTunMetadata7(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata7, error) {
25607 _oxmidtunmetadata7 := &OxmIdTunMetadata7{OxmId: parent}
25608 return _oxmidtunmetadata7, nil
25609}
25610
25611func NewOxmIdTunMetadata7() *OxmIdTunMetadata7 {
25612 obj := &OxmIdTunMetadata7{
25613 OxmId: NewOxmId(89724),
25614 }
25615 return obj
25616}
25617func (self *OxmIdTunMetadata7) GetOXMName() string {
25618 return "tun_metadata7"
25619}
25620
25621func (self *OxmIdTunMetadata7) MarshalJSON() ([]byte, error) {
25622 if self.TypeLen == 0 {
25623 return []byte("\"\""), nil
25624 } else {
25625 return []byte("\"" + self.GetOXMName() + "\""), nil
25626 }
25627}
25628
25629type OxmIdTunMetadata7Masked struct {
25630 *OxmId
25631}
25632
25633type IOxmIdTunMetadata7Masked interface {
25634 IOxmId
25635}
25636
25637func (self *OxmIdTunMetadata7Masked) Serialize(encoder *goloxi.Encoder) error {
25638 if err := self.OxmId.Serialize(encoder); err != nil {
25639 return err
25640 }
25641
25642 return nil
25643}
25644
25645func DecodeOxmIdTunMetadata7Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata7Masked, error) {
25646 _oxmidtunmetadata7masked := &OxmIdTunMetadata7Masked{OxmId: parent}
25647 return _oxmidtunmetadata7masked, nil
25648}
25649
25650func NewOxmIdTunMetadata7Masked() *OxmIdTunMetadata7Masked {
25651 obj := &OxmIdTunMetadata7Masked{
25652 OxmId: NewOxmId(90104),
25653 }
25654 return obj
25655}
25656func (self *OxmIdTunMetadata7Masked) GetOXMName() string {
25657 return "tun_metadata7_masked"
25658}
25659
25660func (self *OxmIdTunMetadata7Masked) MarshalJSON() ([]byte, error) {
25661 if self.TypeLen == 0 {
25662 return []byte("\"\""), nil
25663 } else {
25664 return []byte("\"" + self.GetOXMName() + "\""), nil
25665 }
25666}
25667
25668type OxmIdTunMetadata8 struct {
25669 *OxmId
25670}
25671
25672type IOxmIdTunMetadata8 interface {
25673 IOxmId
25674}
25675
25676func (self *OxmIdTunMetadata8) Serialize(encoder *goloxi.Encoder) error {
25677 if err := self.OxmId.Serialize(encoder); err != nil {
25678 return err
25679 }
25680
25681 return nil
25682}
25683
25684func DecodeOxmIdTunMetadata8(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata8, error) {
25685 _oxmidtunmetadata8 := &OxmIdTunMetadata8{OxmId: parent}
25686 return _oxmidtunmetadata8, nil
25687}
25688
25689func NewOxmIdTunMetadata8() *OxmIdTunMetadata8 {
25690 obj := &OxmIdTunMetadata8{
25691 OxmId: NewOxmId(90236),
25692 }
25693 return obj
25694}
25695func (self *OxmIdTunMetadata8) GetOXMName() string {
25696 return "tun_metadata8"
25697}
25698
25699func (self *OxmIdTunMetadata8) MarshalJSON() ([]byte, error) {
25700 if self.TypeLen == 0 {
25701 return []byte("\"\""), nil
25702 } else {
25703 return []byte("\"" + self.GetOXMName() + "\""), nil
25704 }
25705}
25706
25707type OxmIdTunMetadata8Masked struct {
25708 *OxmId
25709}
25710
25711type IOxmIdTunMetadata8Masked interface {
25712 IOxmId
25713}
25714
25715func (self *OxmIdTunMetadata8Masked) Serialize(encoder *goloxi.Encoder) error {
25716 if err := self.OxmId.Serialize(encoder); err != nil {
25717 return err
25718 }
25719
25720 return nil
25721}
25722
25723func DecodeOxmIdTunMetadata8Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata8Masked, error) {
25724 _oxmidtunmetadata8masked := &OxmIdTunMetadata8Masked{OxmId: parent}
25725 return _oxmidtunmetadata8masked, nil
25726}
25727
25728func NewOxmIdTunMetadata8Masked() *OxmIdTunMetadata8Masked {
25729 obj := &OxmIdTunMetadata8Masked{
25730 OxmId: NewOxmId(90616),
25731 }
25732 return obj
25733}
25734func (self *OxmIdTunMetadata8Masked) GetOXMName() string {
25735 return "tun_metadata8_masked"
25736}
25737
25738func (self *OxmIdTunMetadata8Masked) MarshalJSON() ([]byte, error) {
25739 if self.TypeLen == 0 {
25740 return []byte("\"\""), nil
25741 } else {
25742 return []byte("\"" + self.GetOXMName() + "\""), nil
25743 }
25744}
25745
25746type OxmIdTunMetadata9 struct {
25747 *OxmId
25748}
25749
25750type IOxmIdTunMetadata9 interface {
25751 IOxmId
25752}
25753
25754func (self *OxmIdTunMetadata9) Serialize(encoder *goloxi.Encoder) error {
25755 if err := self.OxmId.Serialize(encoder); err != nil {
25756 return err
25757 }
25758
25759 return nil
25760}
25761
25762func DecodeOxmIdTunMetadata9(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata9, error) {
25763 _oxmidtunmetadata9 := &OxmIdTunMetadata9{OxmId: parent}
25764 return _oxmidtunmetadata9, nil
25765}
25766
25767func NewOxmIdTunMetadata9() *OxmIdTunMetadata9 {
25768 obj := &OxmIdTunMetadata9{
25769 OxmId: NewOxmId(90748),
25770 }
25771 return obj
25772}
25773func (self *OxmIdTunMetadata9) GetOXMName() string {
25774 return "tun_metadata9"
25775}
25776
25777func (self *OxmIdTunMetadata9) MarshalJSON() ([]byte, error) {
25778 if self.TypeLen == 0 {
25779 return []byte("\"\""), nil
25780 } else {
25781 return []byte("\"" + self.GetOXMName() + "\""), nil
25782 }
25783}
25784
25785type OxmIdTunMetadata9Masked struct {
25786 *OxmId
25787}
25788
25789type IOxmIdTunMetadata9Masked interface {
25790 IOxmId
25791}
25792
25793func (self *OxmIdTunMetadata9Masked) Serialize(encoder *goloxi.Encoder) error {
25794 if err := self.OxmId.Serialize(encoder); err != nil {
25795 return err
25796 }
25797
25798 return nil
25799}
25800
25801func DecodeOxmIdTunMetadata9Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata9Masked, error) {
25802 _oxmidtunmetadata9masked := &OxmIdTunMetadata9Masked{OxmId: parent}
25803 return _oxmidtunmetadata9masked, nil
25804}
25805
25806func NewOxmIdTunMetadata9Masked() *OxmIdTunMetadata9Masked {
25807 obj := &OxmIdTunMetadata9Masked{
25808 OxmId: NewOxmId(91128),
25809 }
25810 return obj
25811}
25812func (self *OxmIdTunMetadata9Masked) GetOXMName() string {
25813 return "tun_metadata9_masked"
25814}
25815
25816func (self *OxmIdTunMetadata9Masked) MarshalJSON() ([]byte, error) {
25817 if self.TypeLen == 0 {
25818 return []byte("\"\""), nil
25819 } else {
25820 return []byte("\"" + self.GetOXMName() + "\""), nil
25821 }
25822}
25823
25824type OxmIdTunSrc struct {
25825 *OxmId
25826}
25827
25828type IOxmIdTunSrc interface {
25829 IOxmId
25830}
25831
25832func (self *OxmIdTunSrc) Serialize(encoder *goloxi.Encoder) error {
25833 if err := self.OxmId.Serialize(encoder); err != nil {
25834 return err
25835 }
25836
25837 return nil
25838}
25839
25840func DecodeOxmIdTunSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunSrc, error) {
25841 _oxmidtunsrc := &OxmIdTunSrc{OxmId: parent}
25842 return _oxmidtunsrc, nil
25843}
25844
25845func NewOxmIdTunSrc() *OxmIdTunSrc {
25846 obj := &OxmIdTunSrc{
25847 OxmId: NewOxmId(81412),
25848 }
25849 return obj
25850}
25851func (self *OxmIdTunSrc) GetOXMName() string {
25852 return "tun_src"
25853}
25854
25855func (self *OxmIdTunSrc) MarshalJSON() ([]byte, error) {
25856 if self.TypeLen == 0 {
25857 return []byte("\"\""), nil
25858 } else {
25859 return []byte("\"" + self.GetOXMName() + "\""), nil
25860 }
25861}
25862
25863type OxmIdTunSrcMasked struct {
25864 *OxmId
25865}
25866
25867type IOxmIdTunSrcMasked interface {
25868 IOxmId
25869}
25870
25871func (self *OxmIdTunSrcMasked) Serialize(encoder *goloxi.Encoder) error {
25872 if err := self.OxmId.Serialize(encoder); err != nil {
25873 return err
25874 }
25875
25876 return nil
25877}
25878
25879func DecodeOxmIdTunSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunSrcMasked, error) {
25880 _oxmidtunsrcmasked := &OxmIdTunSrcMasked{OxmId: parent}
25881 return _oxmidtunsrcmasked, nil
25882}
25883
25884func NewOxmIdTunSrcMasked() *OxmIdTunSrcMasked {
25885 obj := &OxmIdTunSrcMasked{
25886 OxmId: NewOxmId(81672),
25887 }
25888 return obj
25889}
25890func (self *OxmIdTunSrcMasked) GetOXMName() string {
25891 return "tun_src_masked"
25892}
25893
25894func (self *OxmIdTunSrcMasked) MarshalJSON() ([]byte, error) {
25895 if self.TypeLen == 0 {
25896 return []byte("\"\""), nil
25897 } else {
25898 return []byte("\"" + self.GetOXMName() + "\""), nil
25899 }
25900}
25901
25902type OxmIdUdpDst struct {
25903 *OxmId
25904}
25905
25906type IOxmIdUdpDst interface {
25907 IOxmId
25908}
25909
25910func (self *OxmIdUdpDst) Serialize(encoder *goloxi.Encoder) error {
25911 if err := self.OxmId.Serialize(encoder); err != nil {
25912 return err
25913 }
25914
25915 return nil
25916}
25917
25918func DecodeOxmIdUdpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpDst, error) {
25919 _oxmidudpdst := &OxmIdUdpDst{OxmId: parent}
25920 return _oxmidudpdst, nil
25921}
25922
25923func NewOxmIdUdpDst() *OxmIdUdpDst {
25924 obj := &OxmIdUdpDst{
25925 OxmId: NewOxmId(6146),
25926 }
25927 return obj
25928}
25929func (self *OxmIdUdpDst) GetOXMName() string {
25930 return "udp_dst"
25931}
25932
25933func (self *OxmIdUdpDst) MarshalJSON() ([]byte, error) {
25934 if self.TypeLen == 0 {
25935 return []byte("\"\""), nil
25936 } else {
25937 return []byte("\"" + self.GetOXMName() + "\""), nil
25938 }
25939}
25940
25941type OxmIdUdpDstMasked struct {
25942 *OxmId
25943}
25944
25945type IOxmIdUdpDstMasked interface {
25946 IOxmId
25947}
25948
25949func (self *OxmIdUdpDstMasked) Serialize(encoder *goloxi.Encoder) error {
25950 if err := self.OxmId.Serialize(encoder); err != nil {
25951 return err
25952 }
25953
25954 return nil
25955}
25956
25957func DecodeOxmIdUdpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpDstMasked, error) {
25958 _oxmidudpdstmasked := &OxmIdUdpDstMasked{OxmId: parent}
25959 return _oxmidudpdstmasked, nil
25960}
25961
25962func NewOxmIdUdpDstMasked() *OxmIdUdpDstMasked {
25963 obj := &OxmIdUdpDstMasked{
25964 OxmId: NewOxmId(6404),
25965 }
25966 return obj
25967}
25968func (self *OxmIdUdpDstMasked) GetOXMName() string {
25969 return "udp_dst_masked"
25970}
25971
25972func (self *OxmIdUdpDstMasked) MarshalJSON() ([]byte, error) {
25973 if self.TypeLen == 0 {
25974 return []byte("\"\""), nil
25975 } else {
25976 return []byte("\"" + self.GetOXMName() + "\""), nil
25977 }
25978}
25979
25980type OxmIdUdpSrc struct {
25981 *OxmId
25982}
25983
25984type IOxmIdUdpSrc interface {
25985 IOxmId
25986}
25987
25988func (self *OxmIdUdpSrc) Serialize(encoder *goloxi.Encoder) error {
25989 if err := self.OxmId.Serialize(encoder); err != nil {
25990 return err
25991 }
25992
25993 return nil
25994}
25995
25996func DecodeOxmIdUdpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpSrc, error) {
25997 _oxmidudpsrc := &OxmIdUdpSrc{OxmId: parent}
25998 return _oxmidudpsrc, nil
25999}
26000
26001func NewOxmIdUdpSrc() *OxmIdUdpSrc {
26002 obj := &OxmIdUdpSrc{
26003 OxmId: NewOxmId(5634),
26004 }
26005 return obj
26006}
26007func (self *OxmIdUdpSrc) GetOXMName() string {
26008 return "udp_src"
26009}
26010
26011func (self *OxmIdUdpSrc) MarshalJSON() ([]byte, error) {
26012 if self.TypeLen == 0 {
26013 return []byte("\"\""), nil
26014 } else {
26015 return []byte("\"" + self.GetOXMName() + "\""), nil
26016 }
26017}
26018
26019type OxmIdUdpSrcMasked struct {
26020 *OxmId
26021}
26022
26023type IOxmIdUdpSrcMasked interface {
26024 IOxmId
26025}
26026
26027func (self *OxmIdUdpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
26028 if err := self.OxmId.Serialize(encoder); err != nil {
26029 return err
26030 }
26031
26032 return nil
26033}
26034
26035func DecodeOxmIdUdpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpSrcMasked, error) {
26036 _oxmidudpsrcmasked := &OxmIdUdpSrcMasked{OxmId: parent}
26037 return _oxmidudpsrcmasked, nil
26038}
26039
26040func NewOxmIdUdpSrcMasked() *OxmIdUdpSrcMasked {
26041 obj := &OxmIdUdpSrcMasked{
26042 OxmId: NewOxmId(5892),
26043 }
26044 return obj
26045}
26046func (self *OxmIdUdpSrcMasked) GetOXMName() string {
26047 return "udp_src_masked"
26048}
26049
26050func (self *OxmIdUdpSrcMasked) MarshalJSON() ([]byte, error) {
26051 if self.TypeLen == 0 {
26052 return []byte("\"\""), nil
26053 } else {
26054 return []byte("\"" + self.GetOXMName() + "\""), nil
26055 }
26056}
26057
26058type OxmIdVlanTci struct {
26059 *OxmId
26060}
26061
26062type IOxmIdVlanTci interface {
26063 IOxmId
26064}
26065
26066func (self *OxmIdVlanTci) Serialize(encoder *goloxi.Encoder) error {
26067 if err := self.OxmId.Serialize(encoder); err != nil {
26068 return err
26069 }
26070
26071 return nil
26072}
26073
26074func DecodeOxmIdVlanTci(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanTci, error) {
26075 _oxmidvlantci := &OxmIdVlanTci{OxmId: parent}
26076 return _oxmidvlantci, nil
26077}
26078
26079func NewOxmIdVlanTci() *OxmIdVlanTci {
26080 obj := &OxmIdVlanTci{
26081 OxmId: NewOxmId(2050),
26082 }
26083 return obj
26084}
26085func (self *OxmIdVlanTci) GetOXMName() string {
26086 return "vlan_tci"
26087}
26088
26089func (self *OxmIdVlanTci) MarshalJSON() ([]byte, error) {
26090 if self.TypeLen == 0 {
26091 return []byte("\"\""), nil
26092 } else {
26093 return []byte("\"" + self.GetOXMName() + "\""), nil
26094 }
26095}
26096
26097type OxmIdVlanTciMasked struct {
26098 *OxmId
26099}
26100
26101type IOxmIdVlanTciMasked interface {
26102 IOxmId
26103}
26104
26105func (self *OxmIdVlanTciMasked) Serialize(encoder *goloxi.Encoder) error {
26106 if err := self.OxmId.Serialize(encoder); err != nil {
26107 return err
26108 }
26109
26110 return nil
26111}
26112
26113func DecodeOxmIdVlanTciMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanTciMasked, error) {
26114 _oxmidvlantcimasked := &OxmIdVlanTciMasked{OxmId: parent}
26115 return _oxmidvlantcimasked, nil
26116}
26117
26118func NewOxmIdVlanTciMasked() *OxmIdVlanTciMasked {
26119 obj := &OxmIdVlanTciMasked{
26120 OxmId: NewOxmId(2308),
26121 }
26122 return obj
26123}
26124func (self *OxmIdVlanTciMasked) GetOXMName() string {
26125 return "vlan_tci_masked"
26126}
26127
26128func (self *OxmIdVlanTciMasked) MarshalJSON() ([]byte, error) {
26129 if self.TypeLen == 0 {
26130 return []byte("\"\""), nil
26131 } else {
26132 return []byte("\"" + self.GetOXMName() + "\""), nil
26133 }
26134}
26135
26136type OxmIdXxreg0 struct {
26137 *OxmId
26138}
26139
26140type IOxmIdXxreg0 interface {
26141 IOxmId
26142}
26143
26144func (self *OxmIdXxreg0) Serialize(encoder *goloxi.Encoder) error {
26145 if err := self.OxmId.Serialize(encoder); err != nil {
26146 return err
26147 }
26148
26149 return nil
26150}
26151
26152func DecodeOxmIdXxreg0(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg0, error) {
26153 _oxmidxxreg0 := &OxmIdXxreg0{OxmId: parent}
26154 return _oxmidxxreg0, nil
26155}
26156
26157func NewOxmIdXxreg0() *OxmIdXxreg0 {
26158 obj := &OxmIdXxreg0{
26159 OxmId: NewOxmId(122384),
26160 }
26161 return obj
26162}
26163func (self *OxmIdXxreg0) GetOXMName() string {
26164 return "xxreg0"
26165}
26166
26167func (self *OxmIdXxreg0) MarshalJSON() ([]byte, error) {
26168 if self.TypeLen == 0 {
26169 return []byte("\"\""), nil
26170 } else {
26171 return []byte("\"" + self.GetOXMName() + "\""), nil
26172 }
26173}
26174
26175type OxmIdXxreg0Masked struct {
26176 *OxmId
26177}
26178
26179type IOxmIdXxreg0Masked interface {
26180 IOxmId
26181}
26182
26183func (self *OxmIdXxreg0Masked) Serialize(encoder *goloxi.Encoder) error {
26184 if err := self.OxmId.Serialize(encoder); err != nil {
26185 return err
26186 }
26187
26188 return nil
26189}
26190
26191func DecodeOxmIdXxreg0Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg0Masked, error) {
26192 _oxmidxxreg0masked := &OxmIdXxreg0Masked{OxmId: parent}
26193 return _oxmidxxreg0masked, nil
26194}
26195
26196func NewOxmIdXxreg0Masked() *OxmIdXxreg0Masked {
26197 obj := &OxmIdXxreg0Masked{
26198 OxmId: NewOxmId(122656),
26199 }
26200 return obj
26201}
26202func (self *OxmIdXxreg0Masked) GetOXMName() string {
26203 return "xxreg0_masked"
26204}
26205
26206func (self *OxmIdXxreg0Masked) MarshalJSON() ([]byte, error) {
26207 if self.TypeLen == 0 {
26208 return []byte("\"\""), nil
26209 } else {
26210 return []byte("\"" + self.GetOXMName() + "\""), nil
26211 }
26212}
26213
26214type OxmIdXxreg1 struct {
26215 *OxmId
26216}
26217
26218type IOxmIdXxreg1 interface {
26219 IOxmId
26220}
26221
26222func (self *OxmIdXxreg1) Serialize(encoder *goloxi.Encoder) error {
26223 if err := self.OxmId.Serialize(encoder); err != nil {
26224 return err
26225 }
26226
26227 return nil
26228}
26229
26230func DecodeOxmIdXxreg1(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg1, error) {
26231 _oxmidxxreg1 := &OxmIdXxreg1{OxmId: parent}
26232 return _oxmidxxreg1, nil
26233}
26234
26235func NewOxmIdXxreg1() *OxmIdXxreg1 {
26236 obj := &OxmIdXxreg1{
26237 OxmId: NewOxmId(122896),
26238 }
26239 return obj
26240}
26241func (self *OxmIdXxreg1) GetOXMName() string {
26242 return "xxreg1"
26243}
26244
26245func (self *OxmIdXxreg1) MarshalJSON() ([]byte, error) {
26246 if self.TypeLen == 0 {
26247 return []byte("\"\""), nil
26248 } else {
26249 return []byte("\"" + self.GetOXMName() + "\""), nil
26250 }
26251}
26252
26253type OxmIdXxreg1Masked struct {
26254 *OxmId
26255}
26256
26257type IOxmIdXxreg1Masked interface {
26258 IOxmId
26259}
26260
26261func (self *OxmIdXxreg1Masked) Serialize(encoder *goloxi.Encoder) error {
26262 if err := self.OxmId.Serialize(encoder); err != nil {
26263 return err
26264 }
26265
26266 return nil
26267}
26268
26269func DecodeOxmIdXxreg1Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg1Masked, error) {
26270 _oxmidxxreg1masked := &OxmIdXxreg1Masked{OxmId: parent}
26271 return _oxmidxxreg1masked, nil
26272}
26273
26274func NewOxmIdXxreg1Masked() *OxmIdXxreg1Masked {
26275 obj := &OxmIdXxreg1Masked{
26276 OxmId: NewOxmId(123168),
26277 }
26278 return obj
26279}
26280func (self *OxmIdXxreg1Masked) GetOXMName() string {
26281 return "xxreg1_masked"
26282}
26283
26284func (self *OxmIdXxreg1Masked) MarshalJSON() ([]byte, error) {
26285 if self.TypeLen == 0 {
26286 return []byte("\"\""), nil
26287 } else {
26288 return []byte("\"" + self.GetOXMName() + "\""), nil
26289 }
26290}
26291
26292type OxmIdXxreg2 struct {
26293 *OxmId
26294}
26295
26296type IOxmIdXxreg2 interface {
26297 IOxmId
26298}
26299
26300func (self *OxmIdXxreg2) Serialize(encoder *goloxi.Encoder) error {
26301 if err := self.OxmId.Serialize(encoder); err != nil {
26302 return err
26303 }
26304
26305 return nil
26306}
26307
26308func DecodeOxmIdXxreg2(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg2, error) {
26309 _oxmidxxreg2 := &OxmIdXxreg2{OxmId: parent}
26310 return _oxmidxxreg2, nil
26311}
26312
26313func NewOxmIdXxreg2() *OxmIdXxreg2 {
26314 obj := &OxmIdXxreg2{
26315 OxmId: NewOxmId(123408),
26316 }
26317 return obj
26318}
26319func (self *OxmIdXxreg2) GetOXMName() string {
26320 return "xxreg2"
26321}
26322
26323func (self *OxmIdXxreg2) MarshalJSON() ([]byte, error) {
26324 if self.TypeLen == 0 {
26325 return []byte("\"\""), nil
26326 } else {
26327 return []byte("\"" + self.GetOXMName() + "\""), nil
26328 }
26329}
26330
26331type OxmIdXxreg2Masked struct {
26332 *OxmId
26333}
26334
26335type IOxmIdXxreg2Masked interface {
26336 IOxmId
26337}
26338
26339func (self *OxmIdXxreg2Masked) Serialize(encoder *goloxi.Encoder) error {
26340 if err := self.OxmId.Serialize(encoder); err != nil {
26341 return err
26342 }
26343
26344 return nil
26345}
26346
26347func DecodeOxmIdXxreg2Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg2Masked, error) {
26348 _oxmidxxreg2masked := &OxmIdXxreg2Masked{OxmId: parent}
26349 return _oxmidxxreg2masked, nil
26350}
26351
26352func NewOxmIdXxreg2Masked() *OxmIdXxreg2Masked {
26353 obj := &OxmIdXxreg2Masked{
26354 OxmId: NewOxmId(123680),
26355 }
26356 return obj
26357}
26358func (self *OxmIdXxreg2Masked) GetOXMName() string {
26359 return "xxreg2_masked"
26360}
26361
26362func (self *OxmIdXxreg2Masked) MarshalJSON() ([]byte, error) {
26363 if self.TypeLen == 0 {
26364 return []byte("\"\""), nil
26365 } else {
26366 return []byte("\"" + self.GetOXMName() + "\""), nil
26367 }
26368}
26369
26370type OxmIdXxreg3 struct {
26371 *OxmId
26372}
26373
26374type IOxmIdXxreg3 interface {
26375 IOxmId
26376}
26377
26378func (self *OxmIdXxreg3) Serialize(encoder *goloxi.Encoder) error {
26379 if err := self.OxmId.Serialize(encoder); err != nil {
26380 return err
26381 }
26382
26383 return nil
26384}
26385
26386func DecodeOxmIdXxreg3(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg3, error) {
26387 _oxmidxxreg3 := &OxmIdXxreg3{OxmId: parent}
26388 return _oxmidxxreg3, nil
26389}
26390
26391func NewOxmIdXxreg3() *OxmIdXxreg3 {
26392 obj := &OxmIdXxreg3{
26393 OxmId: NewOxmId(123920),
26394 }
26395 return obj
26396}
26397func (self *OxmIdXxreg3) GetOXMName() string {
26398 return "xxreg3"
26399}
26400
26401func (self *OxmIdXxreg3) MarshalJSON() ([]byte, error) {
26402 if self.TypeLen == 0 {
26403 return []byte("\"\""), nil
26404 } else {
26405 return []byte("\"" + self.GetOXMName() + "\""), nil
26406 }
26407}
26408
26409type OxmIdXxreg3Masked struct {
26410 *OxmId
26411}
26412
26413type IOxmIdXxreg3Masked interface {
26414 IOxmId
26415}
26416
26417func (self *OxmIdXxreg3Masked) Serialize(encoder *goloxi.Encoder) error {
26418 if err := self.OxmId.Serialize(encoder); err != nil {
26419 return err
26420 }
26421
26422 return nil
26423}
26424
26425func DecodeOxmIdXxreg3Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg3Masked, error) {
26426 _oxmidxxreg3masked := &OxmIdXxreg3Masked{OxmId: parent}
26427 return _oxmidxxreg3masked, nil
26428}
26429
26430func NewOxmIdXxreg3Masked() *OxmIdXxreg3Masked {
26431 obj := &OxmIdXxreg3Masked{
26432 OxmId: NewOxmId(124192),
26433 }
26434 return obj
26435}
26436func (self *OxmIdXxreg3Masked) GetOXMName() string {
26437 return "xxreg3_masked"
26438}
26439
26440func (self *OxmIdXxreg3Masked) MarshalJSON() ([]byte, error) {
26441 if self.TypeLen == 0 {
26442 return []byte("\"\""), nil
26443 } else {
26444 return []byte("\"" + self.GetOXMName() + "\""), nil
26445 }
26446}
26447
26448type OxmIdArpOpMasked struct {
26449 *OxmId
26450}
26451
26452type IOxmIdArpOpMasked interface {
26453 IOxmId
26454}
26455
26456func (self *OxmIdArpOpMasked) Serialize(encoder *goloxi.Encoder) error {
26457 if err := self.OxmId.Serialize(encoder); err != nil {
26458 return err
26459 }
26460
26461 return nil
26462}
26463
26464func DecodeOxmIdArpOpMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpOpMasked, error) {
26465 _oxmidarpopmasked := &OxmIdArpOpMasked{OxmId: parent}
26466 return _oxmidarpopmasked, nil
26467}
26468
26469func NewOxmIdArpOpMasked() *OxmIdArpOpMasked {
26470 obj := &OxmIdArpOpMasked{
26471 OxmId: NewOxmId(2147494660),
26472 }
26473 return obj
26474}
26475func (self *OxmIdArpOpMasked) GetOXMName() string {
26476 return "arp_op_masked"
26477}
26478
26479func (self *OxmIdArpOpMasked) MarshalJSON() ([]byte, error) {
26480 if self.TypeLen == 0 {
26481 return []byte("\"\""), nil
26482 } else {
26483 return []byte("\"" + self.GetOXMName() + "\""), nil
26484 }
26485}
26486
26487type OxmIdBsnEgrPortGroupId struct {
26488 *OxmId
26489}
26490
26491type IOxmIdBsnEgrPortGroupId interface {
26492 IOxmId
26493}
26494
26495func (self *OxmIdBsnEgrPortGroupId) Serialize(encoder *goloxi.Encoder) error {
26496 if err := self.OxmId.Serialize(encoder); err != nil {
26497 return err
26498 }
26499
26500 return nil
26501}
26502
26503func DecodeOxmIdBsnEgrPortGroupId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnEgrPortGroupId, error) {
26504 _oxmidbsnegrportgroupid := &OxmIdBsnEgrPortGroupId{OxmId: parent}
26505 return _oxmidbsnegrportgroupid, nil
26506}
26507
26508func NewOxmIdBsnEgrPortGroupId() *OxmIdBsnEgrPortGroupId {
26509 obj := &OxmIdBsnEgrPortGroupId{
26510 OxmId: NewOxmId(200196),
26511 }
26512 return obj
26513}
26514func (self *OxmIdBsnEgrPortGroupId) GetOXMName() string {
26515 return "bsn_egr_port_group_id"
26516}
26517
26518func (self *OxmIdBsnEgrPortGroupId) MarshalJSON() ([]byte, error) {
26519 if self.TypeLen == 0 {
26520 return []byte("\"\""), nil
26521 } else {
26522 return []byte("\"" + self.GetOXMName() + "\""), nil
26523 }
26524}
26525
26526type OxmIdBsnEgrPortGroupIdMasked struct {
26527 *OxmId
26528}
26529
26530type IOxmIdBsnEgrPortGroupIdMasked interface {
26531 IOxmId
26532}
26533
26534func (self *OxmIdBsnEgrPortGroupIdMasked) Serialize(encoder *goloxi.Encoder) error {
26535 if err := self.OxmId.Serialize(encoder); err != nil {
26536 return err
26537 }
26538
26539 return nil
26540}
26541
26542func DecodeOxmIdBsnEgrPortGroupIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnEgrPortGroupIdMasked, error) {
26543 _oxmidbsnegrportgroupidmasked := &OxmIdBsnEgrPortGroupIdMasked{OxmId: parent}
26544 return _oxmidbsnegrportgroupidmasked, nil
26545}
26546
26547func NewOxmIdBsnEgrPortGroupIdMasked() *OxmIdBsnEgrPortGroupIdMasked {
26548 obj := &OxmIdBsnEgrPortGroupIdMasked{
26549 OxmId: NewOxmId(200456),
26550 }
26551 return obj
26552}
26553func (self *OxmIdBsnEgrPortGroupIdMasked) GetOXMName() string {
26554 return "bsn_egr_port_group_id_masked"
26555}
26556
26557func (self *OxmIdBsnEgrPortGroupIdMasked) MarshalJSON() ([]byte, error) {
26558 if self.TypeLen == 0 {
26559 return []byte("\"\""), nil
26560 } else {
26561 return []byte("\"" + self.GetOXMName() + "\""), nil
26562 }
26563}
26564
26565type OxmIdBsnGlobalVrfAllowed struct {
26566 *OxmId
26567}
26568
26569type IOxmIdBsnGlobalVrfAllowed interface {
26570 IOxmId
26571}
26572
26573func (self *OxmIdBsnGlobalVrfAllowed) Serialize(encoder *goloxi.Encoder) error {
26574 if err := self.OxmId.Serialize(encoder); err != nil {
26575 return err
26576 }
26577
26578 return nil
26579}
26580
26581func DecodeOxmIdBsnGlobalVrfAllowed(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnGlobalVrfAllowed, error) {
26582 _oxmidbsnglobalvrfallowed := &OxmIdBsnGlobalVrfAllowed{OxmId: parent}
26583 return _oxmidbsnglobalvrfallowed, nil
26584}
26585
26586func NewOxmIdBsnGlobalVrfAllowed() *OxmIdBsnGlobalVrfAllowed {
26587 obj := &OxmIdBsnGlobalVrfAllowed{
26588 OxmId: NewOxmId(198145),
26589 }
26590 return obj
26591}
26592func (self *OxmIdBsnGlobalVrfAllowed) GetOXMName() string {
26593 return "bsn_global_vrf_allowed"
26594}
26595
26596func (self *OxmIdBsnGlobalVrfAllowed) MarshalJSON() ([]byte, error) {
26597 if self.TypeLen == 0 {
26598 return []byte("\"\""), nil
26599 } else {
26600 return []byte("\"" + self.GetOXMName() + "\""), nil
26601 }
26602}
26603
26604type OxmIdBsnGlobalVrfAllowedMasked struct {
26605 *OxmId
26606}
26607
26608type IOxmIdBsnGlobalVrfAllowedMasked interface {
26609 IOxmId
26610}
26611
26612func (self *OxmIdBsnGlobalVrfAllowedMasked) Serialize(encoder *goloxi.Encoder) error {
26613 if err := self.OxmId.Serialize(encoder); err != nil {
26614 return err
26615 }
26616
26617 return nil
26618}
26619
26620func DecodeOxmIdBsnGlobalVrfAllowedMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnGlobalVrfAllowedMasked, error) {
26621 _oxmidbsnglobalvrfallowedmasked := &OxmIdBsnGlobalVrfAllowedMasked{OxmId: parent}
26622 return _oxmidbsnglobalvrfallowedmasked, nil
26623}
26624
26625func NewOxmIdBsnGlobalVrfAllowedMasked() *OxmIdBsnGlobalVrfAllowedMasked {
26626 obj := &OxmIdBsnGlobalVrfAllowedMasked{
26627 OxmId: NewOxmId(198402),
26628 }
26629 return obj
26630}
26631func (self *OxmIdBsnGlobalVrfAllowedMasked) GetOXMName() string {
26632 return "bsn_global_vrf_allowed_masked"
26633}
26634
26635func (self *OxmIdBsnGlobalVrfAllowedMasked) MarshalJSON() ([]byte, error) {
26636 if self.TypeLen == 0 {
26637 return []byte("\"\""), nil
26638 } else {
26639 return []byte("\"" + self.GetOXMName() + "\""), nil
26640 }
26641}
26642
26643type OxmIdBsnInPorts128 struct {
26644 *OxmId
26645}
26646
26647type IOxmIdBsnInPorts128 interface {
26648 IOxmId
26649}
26650
26651func (self *OxmIdBsnInPorts128) Serialize(encoder *goloxi.Encoder) error {
26652 if err := self.OxmId.Serialize(encoder); err != nil {
26653 return err
26654 }
26655
26656 return nil
26657}
26658
26659func DecodeOxmIdBsnInPorts128(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInPorts128, error) {
26660 _oxmidbsninports128 := &OxmIdBsnInPorts128{OxmId: parent}
26661 return _oxmidbsninports128, nil
26662}
26663
26664func NewOxmIdBsnInPorts128() *OxmIdBsnInPorts128 {
26665 obj := &OxmIdBsnInPorts128{
26666 OxmId: NewOxmId(196624),
26667 }
26668 return obj
26669}
26670func (self *OxmIdBsnInPorts128) GetOXMName() string {
26671 return "bsn_in_ports_128"
26672}
26673
26674func (self *OxmIdBsnInPorts128) MarshalJSON() ([]byte, error) {
26675 if self.TypeLen == 0 {
26676 return []byte("\"\""), nil
26677 } else {
26678 return []byte("\"" + self.GetOXMName() + "\""), nil
26679 }
26680}
26681
26682type OxmIdBsnInPorts128Masked struct {
26683 *OxmId
26684}
26685
26686type IOxmIdBsnInPorts128Masked interface {
26687 IOxmId
26688}
26689
26690func (self *OxmIdBsnInPorts128Masked) Serialize(encoder *goloxi.Encoder) error {
26691 if err := self.OxmId.Serialize(encoder); err != nil {
26692 return err
26693 }
26694
26695 return nil
26696}
26697
26698func DecodeOxmIdBsnInPorts128Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInPorts128Masked, error) {
26699 _oxmidbsninports128masked := &OxmIdBsnInPorts128Masked{OxmId: parent}
26700 return _oxmidbsninports128masked, nil
26701}
26702
26703func NewOxmIdBsnInPorts128Masked() *OxmIdBsnInPorts128Masked {
26704 obj := &OxmIdBsnInPorts128Masked{
26705 OxmId: NewOxmId(196896),
26706 }
26707 return obj
26708}
26709func (self *OxmIdBsnInPorts128Masked) GetOXMName() string {
26710 return "bsn_in_ports_128_masked"
26711}
26712
26713func (self *OxmIdBsnInPorts128Masked) MarshalJSON() ([]byte, error) {
26714 if self.TypeLen == 0 {
26715 return []byte("\"\""), nil
26716 } else {
26717 return []byte("\"" + self.GetOXMName() + "\""), nil
26718 }
26719}
26720
26721type OxmIdBsnInPorts512 struct {
26722 *OxmId
26723}
26724
26725type IOxmIdBsnInPorts512 interface {
26726 IOxmId
26727}
26728
26729func (self *OxmIdBsnInPorts512) Serialize(encoder *goloxi.Encoder) error {
26730 if err := self.OxmId.Serialize(encoder); err != nil {
26731 return err
26732 }
26733
26734 return nil
26735}
26736
26737func DecodeOxmIdBsnInPorts512(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInPorts512, error) {
26738 _oxmidbsninports512 := &OxmIdBsnInPorts512{OxmId: parent}
26739 return _oxmidbsninports512, nil
26740}
26741
26742func NewOxmIdBsnInPorts512() *OxmIdBsnInPorts512 {
26743 obj := &OxmIdBsnInPorts512{
26744 OxmId: NewOxmId(206400),
26745 }
26746 return obj
26747}
26748func (self *OxmIdBsnInPorts512) GetOXMName() string {
26749 return "bsn_in_ports_512"
26750}
26751
26752func (self *OxmIdBsnInPorts512) MarshalJSON() ([]byte, error) {
26753 if self.TypeLen == 0 {
26754 return []byte("\"\""), nil
26755 } else {
26756 return []byte("\"" + self.GetOXMName() + "\""), nil
26757 }
26758}
26759
26760type OxmIdBsnInPorts512Masked struct {
26761 *OxmId
26762}
26763
26764type IOxmIdBsnInPorts512Masked interface {
26765 IOxmId
26766}
26767
26768func (self *OxmIdBsnInPorts512Masked) Serialize(encoder *goloxi.Encoder) error {
26769 if err := self.OxmId.Serialize(encoder); err != nil {
26770 return err
26771 }
26772
26773 return nil
26774}
26775
26776func DecodeOxmIdBsnInPorts512Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInPorts512Masked, error) {
26777 _oxmidbsninports512masked := &OxmIdBsnInPorts512Masked{OxmId: parent}
26778 return _oxmidbsninports512masked, nil
26779}
26780
26781func NewOxmIdBsnInPorts512Masked() *OxmIdBsnInPorts512Masked {
26782 obj := &OxmIdBsnInPorts512Masked{
26783 OxmId: NewOxmId(206720),
26784 }
26785 return obj
26786}
26787func (self *OxmIdBsnInPorts512Masked) GetOXMName() string {
26788 return "bsn_in_ports_512_masked"
26789}
26790
26791func (self *OxmIdBsnInPorts512Masked) MarshalJSON() ([]byte, error) {
26792 if self.TypeLen == 0 {
26793 return []byte("\"\""), nil
26794 } else {
26795 return []byte("\"" + self.GetOXMName() + "\""), nil
26796 }
26797}
26798
26799type OxmIdBsnIngressPortGroupId struct {
26800 *OxmId
26801}
26802
26803type IOxmIdBsnIngressPortGroupId interface {
26804 IOxmId
26805}
26806
26807func (self *OxmIdBsnIngressPortGroupId) Serialize(encoder *goloxi.Encoder) error {
26808 if err := self.OxmId.Serialize(encoder); err != nil {
26809 return err
26810 }
26811
26812 return nil
26813}
26814
26815func DecodeOxmIdBsnIngressPortGroupId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnIngressPortGroupId, error) {
26816 _oxmidbsningressportgroupid := &OxmIdBsnIngressPortGroupId{OxmId: parent}
26817 return _oxmidbsningressportgroupid, nil
26818}
26819
26820func NewOxmIdBsnIngressPortGroupId() *OxmIdBsnIngressPortGroupId {
26821 obj := &OxmIdBsnIngressPortGroupId{
26822 OxmId: NewOxmId(206852),
26823 }
26824 return obj
26825}
26826func (self *OxmIdBsnIngressPortGroupId) GetOXMName() string {
26827 return "bsn_ingress_port_group_id"
26828}
26829
26830func (self *OxmIdBsnIngressPortGroupId) MarshalJSON() ([]byte, error) {
26831 if self.TypeLen == 0 {
26832 return []byte("\"\""), nil
26833 } else {
26834 return []byte("\"" + self.GetOXMName() + "\""), nil
26835 }
26836}
26837
26838type OxmIdBsnIngressPortGroupIdMasked struct {
26839 *OxmId
26840}
26841
26842type IOxmIdBsnIngressPortGroupIdMasked interface {
26843 IOxmId
26844}
26845
26846func (self *OxmIdBsnIngressPortGroupIdMasked) Serialize(encoder *goloxi.Encoder) error {
26847 if err := self.OxmId.Serialize(encoder); err != nil {
26848 return err
26849 }
26850
26851 return nil
26852}
26853
26854func DecodeOxmIdBsnIngressPortGroupIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnIngressPortGroupIdMasked, error) {
26855 _oxmidbsningressportgroupidmasked := &OxmIdBsnIngressPortGroupIdMasked{OxmId: parent}
26856 return _oxmidbsningressportgroupidmasked, nil
26857}
26858
26859func NewOxmIdBsnIngressPortGroupIdMasked() *OxmIdBsnIngressPortGroupIdMasked {
26860 obj := &OxmIdBsnIngressPortGroupIdMasked{
26861 OxmId: NewOxmId(207112),
26862 }
26863 return obj
26864}
26865func (self *OxmIdBsnIngressPortGroupIdMasked) GetOXMName() string {
26866 return "bsn_ingress_port_group_id_masked"
26867}
26868
26869func (self *OxmIdBsnIngressPortGroupIdMasked) MarshalJSON() ([]byte, error) {
26870 if self.TypeLen == 0 {
26871 return []byte("\"\""), nil
26872 } else {
26873 return []byte("\"" + self.GetOXMName() + "\""), nil
26874 }
26875}
26876
26877type OxmIdBsnInnerEthDst struct {
26878 *OxmId
26879}
26880
26881type IOxmIdBsnInnerEthDst interface {
26882 IOxmId
26883}
26884
26885func (self *OxmIdBsnInnerEthDst) Serialize(encoder *goloxi.Encoder) error {
26886 if err := self.OxmId.Serialize(encoder); err != nil {
26887 return err
26888 }
26889
26890 return nil
26891}
26892
26893func DecodeOxmIdBsnInnerEthDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInnerEthDst, error) {
26894 _oxmidbsninnerethdst := &OxmIdBsnInnerEthDst{OxmId: parent}
26895 return _oxmidbsninnerethdst, nil
26896}
26897
26898func NewOxmIdBsnInnerEthDst() *OxmIdBsnInnerEthDst {
26899 obj := &OxmIdBsnInnerEthDst{
26900 OxmId: NewOxmId(207878),
26901 }
26902 return obj
26903}
26904func (self *OxmIdBsnInnerEthDst) GetOXMName() string {
26905 return "bsn_inner_eth_dst"
26906}
26907
26908func (self *OxmIdBsnInnerEthDst) MarshalJSON() ([]byte, error) {
26909 if self.TypeLen == 0 {
26910 return []byte("\"\""), nil
26911 } else {
26912 return []byte("\"" + self.GetOXMName() + "\""), nil
26913 }
26914}
26915
26916type OxmIdBsnInnerEthDstMasked struct {
26917 *OxmId
26918}
26919
26920type IOxmIdBsnInnerEthDstMasked interface {
26921 IOxmId
26922}
26923
26924func (self *OxmIdBsnInnerEthDstMasked) Serialize(encoder *goloxi.Encoder) error {
26925 if err := self.OxmId.Serialize(encoder); err != nil {
26926 return err
26927 }
26928
26929 return nil
26930}
26931
26932func DecodeOxmIdBsnInnerEthDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInnerEthDstMasked, error) {
26933 _oxmidbsninnerethdstmasked := &OxmIdBsnInnerEthDstMasked{OxmId: parent}
26934 return _oxmidbsninnerethdstmasked, nil
26935}
26936
26937func NewOxmIdBsnInnerEthDstMasked() *OxmIdBsnInnerEthDstMasked {
26938 obj := &OxmIdBsnInnerEthDstMasked{
26939 OxmId: NewOxmId(208140),
26940 }
26941 return obj
26942}
26943func (self *OxmIdBsnInnerEthDstMasked) GetOXMName() string {
26944 return "bsn_inner_eth_dst_masked"
26945}
26946
26947func (self *OxmIdBsnInnerEthDstMasked) MarshalJSON() ([]byte, error) {
26948 if self.TypeLen == 0 {
26949 return []byte("\"\""), nil
26950 } else {
26951 return []byte("\"" + self.GetOXMName() + "\""), nil
26952 }
26953}
26954
26955type OxmIdBsnInnerEthSrc struct {
26956 *OxmId
26957}
26958
26959type IOxmIdBsnInnerEthSrc interface {
26960 IOxmId
26961}
26962
26963func (self *OxmIdBsnInnerEthSrc) Serialize(encoder *goloxi.Encoder) error {
26964 if err := self.OxmId.Serialize(encoder); err != nil {
26965 return err
26966 }
26967
26968 return nil
26969}
26970
26971func DecodeOxmIdBsnInnerEthSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInnerEthSrc, error) {
26972 _oxmidbsninnerethsrc := &OxmIdBsnInnerEthSrc{OxmId: parent}
26973 return _oxmidbsninnerethsrc, nil
26974}
26975
26976func NewOxmIdBsnInnerEthSrc() *OxmIdBsnInnerEthSrc {
26977 obj := &OxmIdBsnInnerEthSrc{
26978 OxmId: NewOxmId(208390),
26979 }
26980 return obj
26981}
26982func (self *OxmIdBsnInnerEthSrc) GetOXMName() string {
26983 return "bsn_inner_eth_src"
26984}
26985
26986func (self *OxmIdBsnInnerEthSrc) MarshalJSON() ([]byte, error) {
26987 if self.TypeLen == 0 {
26988 return []byte("\"\""), nil
26989 } else {
26990 return []byte("\"" + self.GetOXMName() + "\""), nil
26991 }
26992}
26993
26994type OxmIdBsnInnerEthSrcMasked struct {
26995 *OxmId
26996}
26997
26998type IOxmIdBsnInnerEthSrcMasked interface {
26999 IOxmId
27000}
27001
27002func (self *OxmIdBsnInnerEthSrcMasked) Serialize(encoder *goloxi.Encoder) error {
27003 if err := self.OxmId.Serialize(encoder); err != nil {
27004 return err
27005 }
27006
27007 return nil
27008}
27009
27010func DecodeOxmIdBsnInnerEthSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInnerEthSrcMasked, error) {
27011 _oxmidbsninnerethsrcmasked := &OxmIdBsnInnerEthSrcMasked{OxmId: parent}
27012 return _oxmidbsninnerethsrcmasked, nil
27013}
27014
27015func NewOxmIdBsnInnerEthSrcMasked() *OxmIdBsnInnerEthSrcMasked {
27016 obj := &OxmIdBsnInnerEthSrcMasked{
27017 OxmId: NewOxmId(208652),
27018 }
27019 return obj
27020}
27021func (self *OxmIdBsnInnerEthSrcMasked) GetOXMName() string {
27022 return "bsn_inner_eth_src_masked"
27023}
27024
27025func (self *OxmIdBsnInnerEthSrcMasked) MarshalJSON() ([]byte, error) {
27026 if self.TypeLen == 0 {
27027 return []byte("\"\""), nil
27028 } else {
27029 return []byte("\"" + self.GetOXMName() + "\""), nil
27030 }
27031}
27032
27033type OxmIdBsnInnerVlanVid struct {
27034 *OxmId
27035}
27036
27037type IOxmIdBsnInnerVlanVid interface {
27038 IOxmId
27039}
27040
27041func (self *OxmIdBsnInnerVlanVid) Serialize(encoder *goloxi.Encoder) error {
27042 if err := self.OxmId.Serialize(encoder); err != nil {
27043 return err
27044 }
27045
27046 return nil
27047}
27048
27049func DecodeOxmIdBsnInnerVlanVid(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInnerVlanVid, error) {
27050 _oxmidbsninnervlanvid := &OxmIdBsnInnerVlanVid{OxmId: parent}
27051 return _oxmidbsninnervlanvid, nil
27052}
27053
27054func NewOxmIdBsnInnerVlanVid() *OxmIdBsnInnerVlanVid {
27055 obj := &OxmIdBsnInnerVlanVid{
27056 OxmId: NewOxmId(208898),
27057 }
27058 return obj
27059}
27060func (self *OxmIdBsnInnerVlanVid) GetOXMName() string {
27061 return "bsn_inner_vlan_vid"
27062}
27063
27064func (self *OxmIdBsnInnerVlanVid) MarshalJSON() ([]byte, error) {
27065 if self.TypeLen == 0 {
27066 return []byte("\"\""), nil
27067 } else {
27068 return []byte("\"" + self.GetOXMName() + "\""), nil
27069 }
27070}
27071
27072type OxmIdBsnInnerVlanVidMasked struct {
27073 *OxmId
27074}
27075
27076type IOxmIdBsnInnerVlanVidMasked interface {
27077 IOxmId
27078}
27079
27080func (self *OxmIdBsnInnerVlanVidMasked) Serialize(encoder *goloxi.Encoder) error {
27081 if err := self.OxmId.Serialize(encoder); err != nil {
27082 return err
27083 }
27084
27085 return nil
27086}
27087
27088func DecodeOxmIdBsnInnerVlanVidMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInnerVlanVidMasked, error) {
27089 _oxmidbsninnervlanvidmasked := &OxmIdBsnInnerVlanVidMasked{OxmId: parent}
27090 return _oxmidbsninnervlanvidmasked, nil
27091}
27092
27093func NewOxmIdBsnInnerVlanVidMasked() *OxmIdBsnInnerVlanVidMasked {
27094 obj := &OxmIdBsnInnerVlanVidMasked{
27095 OxmId: NewOxmId(209156),
27096 }
27097 return obj
27098}
27099func (self *OxmIdBsnInnerVlanVidMasked) GetOXMName() string {
27100 return "bsn_inner_vlan_vid_masked"
27101}
27102
27103func (self *OxmIdBsnInnerVlanVidMasked) MarshalJSON() ([]byte, error) {
27104 if self.TypeLen == 0 {
27105 return []byte("\"\""), nil
27106 } else {
27107 return []byte("\"" + self.GetOXMName() + "\""), nil
27108 }
27109}
27110
27111type OxmIdBsnIpFragmentation struct {
27112 *OxmId
27113}
27114
27115type IOxmIdBsnIpFragmentation interface {
27116 IOxmId
27117}
27118
27119func (self *OxmIdBsnIpFragmentation) Serialize(encoder *goloxi.Encoder) error {
27120 if err := self.OxmId.Serialize(encoder); err != nil {
27121 return err
27122 }
27123
27124 return nil
27125}
27126
27127func DecodeOxmIdBsnIpFragmentation(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnIpFragmentation, error) {
27128 _oxmidbsnipfragmentation := &OxmIdBsnIpFragmentation{OxmId: parent}
27129 return _oxmidbsnipfragmentation, nil
27130}
27131
27132func NewOxmIdBsnIpFragmentation() *OxmIdBsnIpFragmentation {
27133 obj := &OxmIdBsnIpFragmentation{
27134 OxmId: NewOxmId(209921),
27135 }
27136 return obj
27137}
27138func (self *OxmIdBsnIpFragmentation) GetOXMName() string {
27139 return "bsn_ip_fragmentation"
27140}
27141
27142func (self *OxmIdBsnIpFragmentation) MarshalJSON() ([]byte, error) {
27143 if self.TypeLen == 0 {
27144 return []byte("\"\""), nil
27145 } else {
27146 return []byte("\"" + self.GetOXMName() + "\""), nil
27147 }
27148}
27149
27150type OxmIdBsnIpFragmentationMasked struct {
27151 *OxmId
27152}
27153
27154type IOxmIdBsnIpFragmentationMasked interface {
27155 IOxmId
27156}
27157
27158func (self *OxmIdBsnIpFragmentationMasked) Serialize(encoder *goloxi.Encoder) error {
27159 if err := self.OxmId.Serialize(encoder); err != nil {
27160 return err
27161 }
27162
27163 return nil
27164}
27165
27166func DecodeOxmIdBsnIpFragmentationMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnIpFragmentationMasked, error) {
27167 _oxmidbsnipfragmentationmasked := &OxmIdBsnIpFragmentationMasked{OxmId: parent}
27168 return _oxmidbsnipfragmentationmasked, nil
27169}
27170
27171func NewOxmIdBsnIpFragmentationMasked() *OxmIdBsnIpFragmentationMasked {
27172 obj := &OxmIdBsnIpFragmentationMasked{
27173 OxmId: NewOxmId(210178),
27174 }
27175 return obj
27176}
27177func (self *OxmIdBsnIpFragmentationMasked) GetOXMName() string {
27178 return "bsn_ip_fragmentation_masked"
27179}
27180
27181func (self *OxmIdBsnIpFragmentationMasked) MarshalJSON() ([]byte, error) {
27182 if self.TypeLen == 0 {
27183 return []byte("\"\""), nil
27184 } else {
27185 return []byte("\"" + self.GetOXMName() + "\""), nil
27186 }
27187}
27188
27189type OxmIdBsnL2CacheHit struct {
27190 *OxmId
27191}
27192
27193type IOxmIdBsnL2CacheHit interface {
27194 IOxmId
27195}
27196
27197func (self *OxmIdBsnL2CacheHit) Serialize(encoder *goloxi.Encoder) error {
27198 if err := self.OxmId.Serialize(encoder); err != nil {
27199 return err
27200 }
27201
27202 return nil
27203}
27204
27205func DecodeOxmIdBsnL2CacheHit(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL2CacheHit, error) {
27206 _oxmidbsnl2cachehit := &OxmIdBsnL2CacheHit{OxmId: parent}
27207 return _oxmidbsnl2cachehit, nil
27208}
27209
27210func NewOxmIdBsnL2CacheHit() *OxmIdBsnL2CacheHit {
27211 obj := &OxmIdBsnL2CacheHit{
27212 OxmId: NewOxmId(205825),
27213 }
27214 return obj
27215}
27216func (self *OxmIdBsnL2CacheHit) GetOXMName() string {
27217 return "bsn_l2_cache_hit"
27218}
27219
27220func (self *OxmIdBsnL2CacheHit) MarshalJSON() ([]byte, error) {
27221 if self.TypeLen == 0 {
27222 return []byte("\"\""), nil
27223 } else {
27224 return []byte("\"" + self.GetOXMName() + "\""), nil
27225 }
27226}
27227
27228type OxmIdBsnL2CacheHitMasked struct {
27229 *OxmId
27230}
27231
27232type IOxmIdBsnL2CacheHitMasked interface {
27233 IOxmId
27234}
27235
27236func (self *OxmIdBsnL2CacheHitMasked) Serialize(encoder *goloxi.Encoder) error {
27237 if err := self.OxmId.Serialize(encoder); err != nil {
27238 return err
27239 }
27240
27241 return nil
27242}
27243
27244func DecodeOxmIdBsnL2CacheHitMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL2CacheHitMasked, error) {
27245 _oxmidbsnl2cachehitmasked := &OxmIdBsnL2CacheHitMasked{OxmId: parent}
27246 return _oxmidbsnl2cachehitmasked, nil
27247}
27248
27249func NewOxmIdBsnL2CacheHitMasked() *OxmIdBsnL2CacheHitMasked {
27250 obj := &OxmIdBsnL2CacheHitMasked{
27251 OxmId: NewOxmId(206082),
27252 }
27253 return obj
27254}
27255func (self *OxmIdBsnL2CacheHitMasked) GetOXMName() string {
27256 return "bsn_l2_cache_hit_masked"
27257}
27258
27259func (self *OxmIdBsnL2CacheHitMasked) MarshalJSON() ([]byte, error) {
27260 if self.TypeLen == 0 {
27261 return []byte("\"\""), nil
27262 } else {
27263 return []byte("\"" + self.GetOXMName() + "\""), nil
27264 }
27265}
27266
27267type OxmIdBsnL3DstClassId struct {
27268 *OxmId
27269}
27270
27271type IOxmIdBsnL3DstClassId interface {
27272 IOxmId
27273}
27274
27275func (self *OxmIdBsnL3DstClassId) Serialize(encoder *goloxi.Encoder) error {
27276 if err := self.OxmId.Serialize(encoder); err != nil {
27277 return err
27278 }
27279
27280 return nil
27281}
27282
27283func DecodeOxmIdBsnL3DstClassId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL3DstClassId, error) {
27284 _oxmidbsnl3dstclassid := &OxmIdBsnL3DstClassId{OxmId: parent}
27285 return _oxmidbsnl3dstclassid, nil
27286}
27287
27288func NewOxmIdBsnL3DstClassId() *OxmIdBsnL3DstClassId {
27289 obj := &OxmIdBsnL3DstClassId{
27290 OxmId: NewOxmId(199684),
27291 }
27292 return obj
27293}
27294func (self *OxmIdBsnL3DstClassId) GetOXMName() string {
27295 return "bsn_l3_dst_class_id"
27296}
27297
27298func (self *OxmIdBsnL3DstClassId) MarshalJSON() ([]byte, error) {
27299 if self.TypeLen == 0 {
27300 return []byte("\"\""), nil
27301 } else {
27302 return []byte("\"" + self.GetOXMName() + "\""), nil
27303 }
27304}
27305
27306type OxmIdBsnL3DstClassIdMasked struct {
27307 *OxmId
27308}
27309
27310type IOxmIdBsnL3DstClassIdMasked interface {
27311 IOxmId
27312}
27313
27314func (self *OxmIdBsnL3DstClassIdMasked) Serialize(encoder *goloxi.Encoder) error {
27315 if err := self.OxmId.Serialize(encoder); err != nil {
27316 return err
27317 }
27318
27319 return nil
27320}
27321
27322func DecodeOxmIdBsnL3DstClassIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL3DstClassIdMasked, error) {
27323 _oxmidbsnl3dstclassidmasked := &OxmIdBsnL3DstClassIdMasked{OxmId: parent}
27324 return _oxmidbsnl3dstclassidmasked, nil
27325}
27326
27327func NewOxmIdBsnL3DstClassIdMasked() *OxmIdBsnL3DstClassIdMasked {
27328 obj := &OxmIdBsnL3DstClassIdMasked{
27329 OxmId: NewOxmId(199944),
27330 }
27331 return obj
27332}
27333func (self *OxmIdBsnL3DstClassIdMasked) GetOXMName() string {
27334 return "bsn_l3_dst_class_id_masked"
27335}
27336
27337func (self *OxmIdBsnL3DstClassIdMasked) MarshalJSON() ([]byte, error) {
27338 if self.TypeLen == 0 {
27339 return []byte("\"\""), nil
27340 } else {
27341 return []byte("\"" + self.GetOXMName() + "\""), nil
27342 }
27343}
27344
27345type OxmIdBsnL3InterfaceClassId struct {
27346 *OxmId
27347}
27348
27349type IOxmIdBsnL3InterfaceClassId interface {
27350 IOxmId
27351}
27352
27353func (self *OxmIdBsnL3InterfaceClassId) Serialize(encoder *goloxi.Encoder) error {
27354 if err := self.OxmId.Serialize(encoder); err != nil {
27355 return err
27356 }
27357
27358 return nil
27359}
27360
27361func DecodeOxmIdBsnL3InterfaceClassId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL3InterfaceClassId, error) {
27362 _oxmidbsnl3interfaceclassid := &OxmIdBsnL3InterfaceClassId{OxmId: parent}
27363 return _oxmidbsnl3interfaceclassid, nil
27364}
27365
27366func NewOxmIdBsnL3InterfaceClassId() *OxmIdBsnL3InterfaceClassId {
27367 obj := &OxmIdBsnL3InterfaceClassId{
27368 OxmId: NewOxmId(198660),
27369 }
27370 return obj
27371}
27372func (self *OxmIdBsnL3InterfaceClassId) GetOXMName() string {
27373 return "bsn_l3_interface_class_id"
27374}
27375
27376func (self *OxmIdBsnL3InterfaceClassId) MarshalJSON() ([]byte, error) {
27377 if self.TypeLen == 0 {
27378 return []byte("\"\""), nil
27379 } else {
27380 return []byte("\"" + self.GetOXMName() + "\""), nil
27381 }
27382}
27383
27384type OxmIdBsnL3InterfaceClassIdMasked struct {
27385 *OxmId
27386}
27387
27388type IOxmIdBsnL3InterfaceClassIdMasked interface {
27389 IOxmId
27390}
27391
27392func (self *OxmIdBsnL3InterfaceClassIdMasked) Serialize(encoder *goloxi.Encoder) error {
27393 if err := self.OxmId.Serialize(encoder); err != nil {
27394 return err
27395 }
27396
27397 return nil
27398}
27399
27400func DecodeOxmIdBsnL3InterfaceClassIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL3InterfaceClassIdMasked, error) {
27401 _oxmidbsnl3interfaceclassidmasked := &OxmIdBsnL3InterfaceClassIdMasked{OxmId: parent}
27402 return _oxmidbsnl3interfaceclassidmasked, nil
27403}
27404
27405func NewOxmIdBsnL3InterfaceClassIdMasked() *OxmIdBsnL3InterfaceClassIdMasked {
27406 obj := &OxmIdBsnL3InterfaceClassIdMasked{
27407 OxmId: NewOxmId(198920),
27408 }
27409 return obj
27410}
27411func (self *OxmIdBsnL3InterfaceClassIdMasked) GetOXMName() string {
27412 return "bsn_l3_interface_class_id_masked"
27413}
27414
27415func (self *OxmIdBsnL3InterfaceClassIdMasked) MarshalJSON() ([]byte, error) {
27416 if self.TypeLen == 0 {
27417 return []byte("\"\""), nil
27418 } else {
27419 return []byte("\"" + self.GetOXMName() + "\""), nil
27420 }
27421}
27422
27423type OxmIdBsnL3SrcClassId struct {
27424 *OxmId
27425}
27426
27427type IOxmIdBsnL3SrcClassId interface {
27428 IOxmId
27429}
27430
27431func (self *OxmIdBsnL3SrcClassId) Serialize(encoder *goloxi.Encoder) error {
27432 if err := self.OxmId.Serialize(encoder); err != nil {
27433 return err
27434 }
27435
27436 return nil
27437}
27438
27439func DecodeOxmIdBsnL3SrcClassId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL3SrcClassId, error) {
27440 _oxmidbsnl3srcclassid := &OxmIdBsnL3SrcClassId{OxmId: parent}
27441 return _oxmidbsnl3srcclassid, nil
27442}
27443
27444func NewOxmIdBsnL3SrcClassId() *OxmIdBsnL3SrcClassId {
27445 obj := &OxmIdBsnL3SrcClassId{
27446 OxmId: NewOxmId(199172),
27447 }
27448 return obj
27449}
27450func (self *OxmIdBsnL3SrcClassId) GetOXMName() string {
27451 return "bsn_l3_src_class_id"
27452}
27453
27454func (self *OxmIdBsnL3SrcClassId) MarshalJSON() ([]byte, error) {
27455 if self.TypeLen == 0 {
27456 return []byte("\"\""), nil
27457 } else {
27458 return []byte("\"" + self.GetOXMName() + "\""), nil
27459 }
27460}
27461
27462type OxmIdBsnL3SrcClassIdMasked struct {
27463 *OxmId
27464}
27465
27466type IOxmIdBsnL3SrcClassIdMasked interface {
27467 IOxmId
27468}
27469
27470func (self *OxmIdBsnL3SrcClassIdMasked) Serialize(encoder *goloxi.Encoder) error {
27471 if err := self.OxmId.Serialize(encoder); err != nil {
27472 return err
27473 }
27474
27475 return nil
27476}
27477
27478func DecodeOxmIdBsnL3SrcClassIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL3SrcClassIdMasked, error) {
27479 _oxmidbsnl3srcclassidmasked := &OxmIdBsnL3SrcClassIdMasked{OxmId: parent}
27480 return _oxmidbsnl3srcclassidmasked, nil
27481}
27482
27483func NewOxmIdBsnL3SrcClassIdMasked() *OxmIdBsnL3SrcClassIdMasked {
27484 obj := &OxmIdBsnL3SrcClassIdMasked{
27485 OxmId: NewOxmId(199432),
27486 }
27487 return obj
27488}
27489func (self *OxmIdBsnL3SrcClassIdMasked) GetOXMName() string {
27490 return "bsn_l3_src_class_id_masked"
27491}
27492
27493func (self *OxmIdBsnL3SrcClassIdMasked) MarshalJSON() ([]byte, error) {
27494 if self.TypeLen == 0 {
27495 return []byte("\"\""), nil
27496 } else {
27497 return []byte("\"" + self.GetOXMName() + "\""), nil
27498 }
27499}
27500
27501type OxmIdBsnLagId struct {
27502 *OxmId
27503}
27504
27505type IOxmIdBsnLagId interface {
27506 IOxmId
27507}
27508
27509func (self *OxmIdBsnLagId) Serialize(encoder *goloxi.Encoder) error {
27510 if err := self.OxmId.Serialize(encoder); err != nil {
27511 return err
27512 }
27513
27514 return nil
27515}
27516
27517func DecodeOxmIdBsnLagId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnLagId, error) {
27518 _oxmidbsnlagid := &OxmIdBsnLagId{OxmId: parent}
27519 return _oxmidbsnlagid, nil
27520}
27521
27522func NewOxmIdBsnLagId() *OxmIdBsnLagId {
27523 obj := &OxmIdBsnLagId{
27524 OxmId: NewOxmId(197124),
27525 }
27526 return obj
27527}
27528func (self *OxmIdBsnLagId) GetOXMName() string {
27529 return "bsn_lag_id"
27530}
27531
27532func (self *OxmIdBsnLagId) MarshalJSON() ([]byte, error) {
27533 if self.TypeLen == 0 {
27534 return []byte("\"\""), nil
27535 } else {
27536 return []byte("\"" + self.GetOXMName() + "\""), nil
27537 }
27538}
27539
27540type OxmIdBsnLagIdMasked struct {
27541 *OxmId
27542}
27543
27544type IOxmIdBsnLagIdMasked interface {
27545 IOxmId
27546}
27547
27548func (self *OxmIdBsnLagIdMasked) Serialize(encoder *goloxi.Encoder) error {
27549 if err := self.OxmId.Serialize(encoder); err != nil {
27550 return err
27551 }
27552
27553 return nil
27554}
27555
27556func DecodeOxmIdBsnLagIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnLagIdMasked, error) {
27557 _oxmidbsnlagidmasked := &OxmIdBsnLagIdMasked{OxmId: parent}
27558 return _oxmidbsnlagidmasked, nil
27559}
27560
27561func NewOxmIdBsnLagIdMasked() *OxmIdBsnLagIdMasked {
27562 obj := &OxmIdBsnLagIdMasked{
27563 OxmId: NewOxmId(197384),
27564 }
27565 return obj
27566}
27567func (self *OxmIdBsnLagIdMasked) GetOXMName() string {
27568 return "bsn_lag_id_masked"
27569}
27570
27571func (self *OxmIdBsnLagIdMasked) MarshalJSON() ([]byte, error) {
27572 if self.TypeLen == 0 {
27573 return []byte("\"\""), nil
27574 } else {
27575 return []byte("\"" + self.GetOXMName() + "\""), nil
27576 }
27577}
27578
27579type OxmIdBsnTcpFlags struct {
27580 *OxmId
27581}
27582
27583type IOxmIdBsnTcpFlags interface {
27584 IOxmId
27585}
27586
27587func (self *OxmIdBsnTcpFlags) Serialize(encoder *goloxi.Encoder) error {
27588 if err := self.OxmId.Serialize(encoder); err != nil {
27589 return err
27590 }
27591
27592 return nil
27593}
27594
27595func DecodeOxmIdBsnTcpFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnTcpFlags, error) {
27596 _oxmidbsntcpflags := &OxmIdBsnTcpFlags{OxmId: parent}
27597 return _oxmidbsntcpflags, nil
27598}
27599
27600func NewOxmIdBsnTcpFlags() *OxmIdBsnTcpFlags {
27601 obj := &OxmIdBsnTcpFlags{
27602 OxmId: NewOxmId(204802),
27603 }
27604 return obj
27605}
27606func (self *OxmIdBsnTcpFlags) GetOXMName() string {
27607 return "bsn_tcp_flags"
27608}
27609
27610func (self *OxmIdBsnTcpFlags) MarshalJSON() ([]byte, error) {
27611 if self.TypeLen == 0 {
27612 return []byte("\"\""), nil
27613 } else {
27614 return []byte("\"" + self.GetOXMName() + "\""), nil
27615 }
27616}
27617
27618type OxmIdBsnTcpFlagsMasked struct {
27619 *OxmId
27620}
27621
27622type IOxmIdBsnTcpFlagsMasked interface {
27623 IOxmId
27624}
27625
27626func (self *OxmIdBsnTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
27627 if err := self.OxmId.Serialize(encoder); err != nil {
27628 return err
27629 }
27630
27631 return nil
27632}
27633
27634func DecodeOxmIdBsnTcpFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnTcpFlagsMasked, error) {
27635 _oxmidbsntcpflagsmasked := &OxmIdBsnTcpFlagsMasked{OxmId: parent}
27636 return _oxmidbsntcpflagsmasked, nil
27637}
27638
27639func NewOxmIdBsnTcpFlagsMasked() *OxmIdBsnTcpFlagsMasked {
27640 obj := &OxmIdBsnTcpFlagsMasked{
27641 OxmId: NewOxmId(205060),
27642 }
27643 return obj
27644}
27645func (self *OxmIdBsnTcpFlagsMasked) GetOXMName() string {
27646 return "bsn_tcp_flags_masked"
27647}
27648
27649func (self *OxmIdBsnTcpFlagsMasked) MarshalJSON() ([]byte, error) {
27650 if self.TypeLen == 0 {
27651 return []byte("\"\""), nil
27652 } else {
27653 return []byte("\"" + self.GetOXMName() + "\""), nil
27654 }
27655}
27656
27657type OxmIdBsnUdf0 struct {
27658 *OxmId
27659}
27660
27661type IOxmIdBsnUdf0 interface {
27662 IOxmId
27663}
27664
27665func (self *OxmIdBsnUdf0) Serialize(encoder *goloxi.Encoder) error {
27666 if err := self.OxmId.Serialize(encoder); err != nil {
27667 return err
27668 }
27669
27670 return nil
27671}
27672
27673func DecodeOxmIdBsnUdf0(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf0, error) {
27674 _oxmidbsnudf0 := &OxmIdBsnUdf0{OxmId: parent}
27675 return _oxmidbsnudf0, nil
27676}
27677
27678func NewOxmIdBsnUdf0() *OxmIdBsnUdf0 {
27679 obj := &OxmIdBsnUdf0{
27680 OxmId: NewOxmId(200708),
27681 }
27682 return obj
27683}
27684func (self *OxmIdBsnUdf0) GetOXMName() string {
27685 return "bsn_udf0"
27686}
27687
27688func (self *OxmIdBsnUdf0) MarshalJSON() ([]byte, error) {
27689 if self.TypeLen == 0 {
27690 return []byte("\"\""), nil
27691 } else {
27692 return []byte("\"" + self.GetOXMName() + "\""), nil
27693 }
27694}
27695
27696type OxmIdBsnUdf0Masked struct {
27697 *OxmId
27698}
27699
27700type IOxmIdBsnUdf0Masked interface {
27701 IOxmId
27702}
27703
27704func (self *OxmIdBsnUdf0Masked) Serialize(encoder *goloxi.Encoder) error {
27705 if err := self.OxmId.Serialize(encoder); err != nil {
27706 return err
27707 }
27708
27709 return nil
27710}
27711
27712func DecodeOxmIdBsnUdf0Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf0Masked, error) {
27713 _oxmidbsnudf0masked := &OxmIdBsnUdf0Masked{OxmId: parent}
27714 return _oxmidbsnudf0masked, nil
27715}
27716
27717func NewOxmIdBsnUdf0Masked() *OxmIdBsnUdf0Masked {
27718 obj := &OxmIdBsnUdf0Masked{
27719 OxmId: NewOxmId(200968),
27720 }
27721 return obj
27722}
27723func (self *OxmIdBsnUdf0Masked) GetOXMName() string {
27724 return "bsn_udf0_masked"
27725}
27726
27727func (self *OxmIdBsnUdf0Masked) MarshalJSON() ([]byte, error) {
27728 if self.TypeLen == 0 {
27729 return []byte("\"\""), nil
27730 } else {
27731 return []byte("\"" + self.GetOXMName() + "\""), nil
27732 }
27733}
27734
27735type OxmIdBsnUdf1 struct {
27736 *OxmId
27737}
27738
27739type IOxmIdBsnUdf1 interface {
27740 IOxmId
27741}
27742
27743func (self *OxmIdBsnUdf1) Serialize(encoder *goloxi.Encoder) error {
27744 if err := self.OxmId.Serialize(encoder); err != nil {
27745 return err
27746 }
27747
27748 return nil
27749}
27750
27751func DecodeOxmIdBsnUdf1(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf1, error) {
27752 _oxmidbsnudf1 := &OxmIdBsnUdf1{OxmId: parent}
27753 return _oxmidbsnudf1, nil
27754}
27755
27756func NewOxmIdBsnUdf1() *OxmIdBsnUdf1 {
27757 obj := &OxmIdBsnUdf1{
27758 OxmId: NewOxmId(201220),
27759 }
27760 return obj
27761}
27762func (self *OxmIdBsnUdf1) GetOXMName() string {
27763 return "bsn_udf1"
27764}
27765
27766func (self *OxmIdBsnUdf1) MarshalJSON() ([]byte, error) {
27767 if self.TypeLen == 0 {
27768 return []byte("\"\""), nil
27769 } else {
27770 return []byte("\"" + self.GetOXMName() + "\""), nil
27771 }
27772}
27773
27774type OxmIdBsnUdf1Masked struct {
27775 *OxmId
27776}
27777
27778type IOxmIdBsnUdf1Masked interface {
27779 IOxmId
27780}
27781
27782func (self *OxmIdBsnUdf1Masked) Serialize(encoder *goloxi.Encoder) error {
27783 if err := self.OxmId.Serialize(encoder); err != nil {
27784 return err
27785 }
27786
27787 return nil
27788}
27789
27790func DecodeOxmIdBsnUdf1Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf1Masked, error) {
27791 _oxmidbsnudf1masked := &OxmIdBsnUdf1Masked{OxmId: parent}
27792 return _oxmidbsnudf1masked, nil
27793}
27794
27795func NewOxmIdBsnUdf1Masked() *OxmIdBsnUdf1Masked {
27796 obj := &OxmIdBsnUdf1Masked{
27797 OxmId: NewOxmId(201480),
27798 }
27799 return obj
27800}
27801func (self *OxmIdBsnUdf1Masked) GetOXMName() string {
27802 return "bsn_udf1_masked"
27803}
27804
27805func (self *OxmIdBsnUdf1Masked) MarshalJSON() ([]byte, error) {
27806 if self.TypeLen == 0 {
27807 return []byte("\"\""), nil
27808 } else {
27809 return []byte("\"" + self.GetOXMName() + "\""), nil
27810 }
27811}
27812
27813type OxmIdBsnUdf2 struct {
27814 *OxmId
27815}
27816
27817type IOxmIdBsnUdf2 interface {
27818 IOxmId
27819}
27820
27821func (self *OxmIdBsnUdf2) Serialize(encoder *goloxi.Encoder) error {
27822 if err := self.OxmId.Serialize(encoder); err != nil {
27823 return err
27824 }
27825
27826 return nil
27827}
27828
27829func DecodeOxmIdBsnUdf2(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf2, error) {
27830 _oxmidbsnudf2 := &OxmIdBsnUdf2{OxmId: parent}
27831 return _oxmidbsnudf2, nil
27832}
27833
27834func NewOxmIdBsnUdf2() *OxmIdBsnUdf2 {
27835 obj := &OxmIdBsnUdf2{
27836 OxmId: NewOxmId(201732),
27837 }
27838 return obj
27839}
27840func (self *OxmIdBsnUdf2) GetOXMName() string {
27841 return "bsn_udf2"
27842}
27843
27844func (self *OxmIdBsnUdf2) MarshalJSON() ([]byte, error) {
27845 if self.TypeLen == 0 {
27846 return []byte("\"\""), nil
27847 } else {
27848 return []byte("\"" + self.GetOXMName() + "\""), nil
27849 }
27850}
27851
27852type OxmIdBsnUdf2Masked struct {
27853 *OxmId
27854}
27855
27856type IOxmIdBsnUdf2Masked interface {
27857 IOxmId
27858}
27859
27860func (self *OxmIdBsnUdf2Masked) Serialize(encoder *goloxi.Encoder) error {
27861 if err := self.OxmId.Serialize(encoder); err != nil {
27862 return err
27863 }
27864
27865 return nil
27866}
27867
27868func DecodeOxmIdBsnUdf2Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf2Masked, error) {
27869 _oxmidbsnudf2masked := &OxmIdBsnUdf2Masked{OxmId: parent}
27870 return _oxmidbsnudf2masked, nil
27871}
27872
27873func NewOxmIdBsnUdf2Masked() *OxmIdBsnUdf2Masked {
27874 obj := &OxmIdBsnUdf2Masked{
27875 OxmId: NewOxmId(201992),
27876 }
27877 return obj
27878}
27879func (self *OxmIdBsnUdf2Masked) GetOXMName() string {
27880 return "bsn_udf2_masked"
27881}
27882
27883func (self *OxmIdBsnUdf2Masked) MarshalJSON() ([]byte, error) {
27884 if self.TypeLen == 0 {
27885 return []byte("\"\""), nil
27886 } else {
27887 return []byte("\"" + self.GetOXMName() + "\""), nil
27888 }
27889}
27890
27891type OxmIdBsnUdf3 struct {
27892 *OxmId
27893}
27894
27895type IOxmIdBsnUdf3 interface {
27896 IOxmId
27897}
27898
27899func (self *OxmIdBsnUdf3) Serialize(encoder *goloxi.Encoder) error {
27900 if err := self.OxmId.Serialize(encoder); err != nil {
27901 return err
27902 }
27903
27904 return nil
27905}
27906
27907func DecodeOxmIdBsnUdf3(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf3, error) {
27908 _oxmidbsnudf3 := &OxmIdBsnUdf3{OxmId: parent}
27909 return _oxmidbsnudf3, nil
27910}
27911
27912func NewOxmIdBsnUdf3() *OxmIdBsnUdf3 {
27913 obj := &OxmIdBsnUdf3{
27914 OxmId: NewOxmId(202244),
27915 }
27916 return obj
27917}
27918func (self *OxmIdBsnUdf3) GetOXMName() string {
27919 return "bsn_udf3"
27920}
27921
27922func (self *OxmIdBsnUdf3) MarshalJSON() ([]byte, error) {
27923 if self.TypeLen == 0 {
27924 return []byte("\"\""), nil
27925 } else {
27926 return []byte("\"" + self.GetOXMName() + "\""), nil
27927 }
27928}
27929
27930type OxmIdBsnUdf3Masked struct {
27931 *OxmId
27932}
27933
27934type IOxmIdBsnUdf3Masked interface {
27935 IOxmId
27936}
27937
27938func (self *OxmIdBsnUdf3Masked) Serialize(encoder *goloxi.Encoder) error {
27939 if err := self.OxmId.Serialize(encoder); err != nil {
27940 return err
27941 }
27942
27943 return nil
27944}
27945
27946func DecodeOxmIdBsnUdf3Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf3Masked, error) {
27947 _oxmidbsnudf3masked := &OxmIdBsnUdf3Masked{OxmId: parent}
27948 return _oxmidbsnudf3masked, nil
27949}
27950
27951func NewOxmIdBsnUdf3Masked() *OxmIdBsnUdf3Masked {
27952 obj := &OxmIdBsnUdf3Masked{
27953 OxmId: NewOxmId(202504),
27954 }
27955 return obj
27956}
27957func (self *OxmIdBsnUdf3Masked) GetOXMName() string {
27958 return "bsn_udf3_masked"
27959}
27960
27961func (self *OxmIdBsnUdf3Masked) MarshalJSON() ([]byte, error) {
27962 if self.TypeLen == 0 {
27963 return []byte("\"\""), nil
27964 } else {
27965 return []byte("\"" + self.GetOXMName() + "\""), nil
27966 }
27967}
27968
27969type OxmIdBsnUdf4 struct {
27970 *OxmId
27971}
27972
27973type IOxmIdBsnUdf4 interface {
27974 IOxmId
27975}
27976
27977func (self *OxmIdBsnUdf4) Serialize(encoder *goloxi.Encoder) error {
27978 if err := self.OxmId.Serialize(encoder); err != nil {
27979 return err
27980 }
27981
27982 return nil
27983}
27984
27985func DecodeOxmIdBsnUdf4(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf4, error) {
27986 _oxmidbsnudf4 := &OxmIdBsnUdf4{OxmId: parent}
27987 return _oxmidbsnudf4, nil
27988}
27989
27990func NewOxmIdBsnUdf4() *OxmIdBsnUdf4 {
27991 obj := &OxmIdBsnUdf4{
27992 OxmId: NewOxmId(202756),
27993 }
27994 return obj
27995}
27996func (self *OxmIdBsnUdf4) GetOXMName() string {
27997 return "bsn_udf4"
27998}
27999
28000func (self *OxmIdBsnUdf4) MarshalJSON() ([]byte, error) {
28001 if self.TypeLen == 0 {
28002 return []byte("\"\""), nil
28003 } else {
28004 return []byte("\"" + self.GetOXMName() + "\""), nil
28005 }
28006}
28007
28008type OxmIdBsnUdf4Masked struct {
28009 *OxmId
28010}
28011
28012type IOxmIdBsnUdf4Masked interface {
28013 IOxmId
28014}
28015
28016func (self *OxmIdBsnUdf4Masked) Serialize(encoder *goloxi.Encoder) error {
28017 if err := self.OxmId.Serialize(encoder); err != nil {
28018 return err
28019 }
28020
28021 return nil
28022}
28023
28024func DecodeOxmIdBsnUdf4Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf4Masked, error) {
28025 _oxmidbsnudf4masked := &OxmIdBsnUdf4Masked{OxmId: parent}
28026 return _oxmidbsnudf4masked, nil
28027}
28028
28029func NewOxmIdBsnUdf4Masked() *OxmIdBsnUdf4Masked {
28030 obj := &OxmIdBsnUdf4Masked{
28031 OxmId: NewOxmId(203016),
28032 }
28033 return obj
28034}
28035func (self *OxmIdBsnUdf4Masked) GetOXMName() string {
28036 return "bsn_udf4_masked"
28037}
28038
28039func (self *OxmIdBsnUdf4Masked) MarshalJSON() ([]byte, error) {
28040 if self.TypeLen == 0 {
28041 return []byte("\"\""), nil
28042 } else {
28043 return []byte("\"" + self.GetOXMName() + "\""), nil
28044 }
28045}
28046
28047type OxmIdBsnUdf5 struct {
28048 *OxmId
28049}
28050
28051type IOxmIdBsnUdf5 interface {
28052 IOxmId
28053}
28054
28055func (self *OxmIdBsnUdf5) Serialize(encoder *goloxi.Encoder) error {
28056 if err := self.OxmId.Serialize(encoder); err != nil {
28057 return err
28058 }
28059
28060 return nil
28061}
28062
28063func DecodeOxmIdBsnUdf5(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf5, error) {
28064 _oxmidbsnudf5 := &OxmIdBsnUdf5{OxmId: parent}
28065 return _oxmidbsnudf5, nil
28066}
28067
28068func NewOxmIdBsnUdf5() *OxmIdBsnUdf5 {
28069 obj := &OxmIdBsnUdf5{
28070 OxmId: NewOxmId(203268),
28071 }
28072 return obj
28073}
28074func (self *OxmIdBsnUdf5) GetOXMName() string {
28075 return "bsn_udf5"
28076}
28077
28078func (self *OxmIdBsnUdf5) MarshalJSON() ([]byte, error) {
28079 if self.TypeLen == 0 {
28080 return []byte("\"\""), nil
28081 } else {
28082 return []byte("\"" + self.GetOXMName() + "\""), nil
28083 }
28084}
28085
28086type OxmIdBsnUdf5Masked struct {
28087 *OxmId
28088}
28089
28090type IOxmIdBsnUdf5Masked interface {
28091 IOxmId
28092}
28093
28094func (self *OxmIdBsnUdf5Masked) Serialize(encoder *goloxi.Encoder) error {
28095 if err := self.OxmId.Serialize(encoder); err != nil {
28096 return err
28097 }
28098
28099 return nil
28100}
28101
28102func DecodeOxmIdBsnUdf5Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf5Masked, error) {
28103 _oxmidbsnudf5masked := &OxmIdBsnUdf5Masked{OxmId: parent}
28104 return _oxmidbsnudf5masked, nil
28105}
28106
28107func NewOxmIdBsnUdf5Masked() *OxmIdBsnUdf5Masked {
28108 obj := &OxmIdBsnUdf5Masked{
28109 OxmId: NewOxmId(203528),
28110 }
28111 return obj
28112}
28113func (self *OxmIdBsnUdf5Masked) GetOXMName() string {
28114 return "bsn_udf5_masked"
28115}
28116
28117func (self *OxmIdBsnUdf5Masked) MarshalJSON() ([]byte, error) {
28118 if self.TypeLen == 0 {
28119 return []byte("\"\""), nil
28120 } else {
28121 return []byte("\"" + self.GetOXMName() + "\""), nil
28122 }
28123}
28124
28125type OxmIdBsnUdf6 struct {
28126 *OxmId
28127}
28128
28129type IOxmIdBsnUdf6 interface {
28130 IOxmId
28131}
28132
28133func (self *OxmIdBsnUdf6) Serialize(encoder *goloxi.Encoder) error {
28134 if err := self.OxmId.Serialize(encoder); err != nil {
28135 return err
28136 }
28137
28138 return nil
28139}
28140
28141func DecodeOxmIdBsnUdf6(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf6, error) {
28142 _oxmidbsnudf6 := &OxmIdBsnUdf6{OxmId: parent}
28143 return _oxmidbsnudf6, nil
28144}
28145
28146func NewOxmIdBsnUdf6() *OxmIdBsnUdf6 {
28147 obj := &OxmIdBsnUdf6{
28148 OxmId: NewOxmId(203780),
28149 }
28150 return obj
28151}
28152func (self *OxmIdBsnUdf6) GetOXMName() string {
28153 return "bsn_udf6"
28154}
28155
28156func (self *OxmIdBsnUdf6) MarshalJSON() ([]byte, error) {
28157 if self.TypeLen == 0 {
28158 return []byte("\"\""), nil
28159 } else {
28160 return []byte("\"" + self.GetOXMName() + "\""), nil
28161 }
28162}
28163
28164type OxmIdBsnUdf6Masked struct {
28165 *OxmId
28166}
28167
28168type IOxmIdBsnUdf6Masked interface {
28169 IOxmId
28170}
28171
28172func (self *OxmIdBsnUdf6Masked) Serialize(encoder *goloxi.Encoder) error {
28173 if err := self.OxmId.Serialize(encoder); err != nil {
28174 return err
28175 }
28176
28177 return nil
28178}
28179
28180func DecodeOxmIdBsnUdf6Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf6Masked, error) {
28181 _oxmidbsnudf6masked := &OxmIdBsnUdf6Masked{OxmId: parent}
28182 return _oxmidbsnudf6masked, nil
28183}
28184
28185func NewOxmIdBsnUdf6Masked() *OxmIdBsnUdf6Masked {
28186 obj := &OxmIdBsnUdf6Masked{
28187 OxmId: NewOxmId(204040),
28188 }
28189 return obj
28190}
28191func (self *OxmIdBsnUdf6Masked) GetOXMName() string {
28192 return "bsn_udf6_masked"
28193}
28194
28195func (self *OxmIdBsnUdf6Masked) MarshalJSON() ([]byte, error) {
28196 if self.TypeLen == 0 {
28197 return []byte("\"\""), nil
28198 } else {
28199 return []byte("\"" + self.GetOXMName() + "\""), nil
28200 }
28201}
28202
28203type OxmIdBsnUdf7 struct {
28204 *OxmId
28205}
28206
28207type IOxmIdBsnUdf7 interface {
28208 IOxmId
28209}
28210
28211func (self *OxmIdBsnUdf7) Serialize(encoder *goloxi.Encoder) error {
28212 if err := self.OxmId.Serialize(encoder); err != nil {
28213 return err
28214 }
28215
28216 return nil
28217}
28218
28219func DecodeOxmIdBsnUdf7(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf7, error) {
28220 _oxmidbsnudf7 := &OxmIdBsnUdf7{OxmId: parent}
28221 return _oxmidbsnudf7, nil
28222}
28223
28224func NewOxmIdBsnUdf7() *OxmIdBsnUdf7 {
28225 obj := &OxmIdBsnUdf7{
28226 OxmId: NewOxmId(204292),
28227 }
28228 return obj
28229}
28230func (self *OxmIdBsnUdf7) GetOXMName() string {
28231 return "bsn_udf7"
28232}
28233
28234func (self *OxmIdBsnUdf7) MarshalJSON() ([]byte, error) {
28235 if self.TypeLen == 0 {
28236 return []byte("\"\""), nil
28237 } else {
28238 return []byte("\"" + self.GetOXMName() + "\""), nil
28239 }
28240}
28241
28242type OxmIdBsnUdf7Masked struct {
28243 *OxmId
28244}
28245
28246type IOxmIdBsnUdf7Masked interface {
28247 IOxmId
28248}
28249
28250func (self *OxmIdBsnUdf7Masked) Serialize(encoder *goloxi.Encoder) error {
28251 if err := self.OxmId.Serialize(encoder); err != nil {
28252 return err
28253 }
28254
28255 return nil
28256}
28257
28258func DecodeOxmIdBsnUdf7Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf7Masked, error) {
28259 _oxmidbsnudf7masked := &OxmIdBsnUdf7Masked{OxmId: parent}
28260 return _oxmidbsnudf7masked, nil
28261}
28262
28263func NewOxmIdBsnUdf7Masked() *OxmIdBsnUdf7Masked {
28264 obj := &OxmIdBsnUdf7Masked{
28265 OxmId: NewOxmId(204552),
28266 }
28267 return obj
28268}
28269func (self *OxmIdBsnUdf7Masked) GetOXMName() string {
28270 return "bsn_udf7_masked"
28271}
28272
28273func (self *OxmIdBsnUdf7Masked) MarshalJSON() ([]byte, error) {
28274 if self.TypeLen == 0 {
28275 return []byte("\"\""), nil
28276 } else {
28277 return []byte("\"" + self.GetOXMName() + "\""), nil
28278 }
28279}
28280
28281type OxmIdBsnVfi struct {
28282 *OxmId
28283}
28284
28285type IOxmIdBsnVfi interface {
28286 IOxmId
28287}
28288
28289func (self *OxmIdBsnVfi) Serialize(encoder *goloxi.Encoder) error {
28290 if err := self.OxmId.Serialize(encoder); err != nil {
28291 return err
28292 }
28293
28294 return nil
28295}
28296
28297func DecodeOxmIdBsnVfi(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVfi, error) {
28298 _oxmidbsnvfi := &OxmIdBsnVfi{OxmId: parent}
28299 return _oxmidbsnvfi, nil
28300}
28301
28302func NewOxmIdBsnVfi() *OxmIdBsnVfi {
28303 obj := &OxmIdBsnVfi{
28304 OxmId: NewOxmId(209410),
28305 }
28306 return obj
28307}
28308func (self *OxmIdBsnVfi) GetOXMName() string {
28309 return "bsn_vfi"
28310}
28311
28312func (self *OxmIdBsnVfi) MarshalJSON() ([]byte, error) {
28313 if self.TypeLen == 0 {
28314 return []byte("\"\""), nil
28315 } else {
28316 return []byte("\"" + self.GetOXMName() + "\""), nil
28317 }
28318}
28319
28320type OxmIdBsnVfiMasked struct {
28321 *OxmId
28322}
28323
28324type IOxmIdBsnVfiMasked interface {
28325 IOxmId
28326}
28327
28328func (self *OxmIdBsnVfiMasked) Serialize(encoder *goloxi.Encoder) error {
28329 if err := self.OxmId.Serialize(encoder); err != nil {
28330 return err
28331 }
28332
28333 return nil
28334}
28335
28336func DecodeOxmIdBsnVfiMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVfiMasked, error) {
28337 _oxmidbsnvfimasked := &OxmIdBsnVfiMasked{OxmId: parent}
28338 return _oxmidbsnvfimasked, nil
28339}
28340
28341func NewOxmIdBsnVfiMasked() *OxmIdBsnVfiMasked {
28342 obj := &OxmIdBsnVfiMasked{
28343 OxmId: NewOxmId(209668),
28344 }
28345 return obj
28346}
28347func (self *OxmIdBsnVfiMasked) GetOXMName() string {
28348 return "bsn_vfi_masked"
28349}
28350
28351func (self *OxmIdBsnVfiMasked) MarshalJSON() ([]byte, error) {
28352 if self.TypeLen == 0 {
28353 return []byte("\"\""), nil
28354 } else {
28355 return []byte("\"" + self.GetOXMName() + "\""), nil
28356 }
28357}
28358
28359type OxmIdBsnVlanXlatePortGroupId struct {
28360 *OxmId
28361}
28362
28363type IOxmIdBsnVlanXlatePortGroupId interface {
28364 IOxmId
28365}
28366
28367func (self *OxmIdBsnVlanXlatePortGroupId) Serialize(encoder *goloxi.Encoder) error {
28368 if err := self.OxmId.Serialize(encoder); err != nil {
28369 return err
28370 }
28371
28372 return nil
28373}
28374
28375func DecodeOxmIdBsnVlanXlatePortGroupId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVlanXlatePortGroupId, error) {
28376 _oxmidbsnvlanxlateportgroupid := &OxmIdBsnVlanXlatePortGroupId{OxmId: parent}
28377 return _oxmidbsnvlanxlateportgroupid, nil
28378}
28379
28380func NewOxmIdBsnVlanXlatePortGroupId() *OxmIdBsnVlanXlatePortGroupId {
28381 obj := &OxmIdBsnVlanXlatePortGroupId{
28382 OxmId: NewOxmId(205316),
28383 }
28384 return obj
28385}
28386func (self *OxmIdBsnVlanXlatePortGroupId) GetOXMName() string {
28387 return "bsn_vlan_xlate_port_group_id"
28388}
28389
28390func (self *OxmIdBsnVlanXlatePortGroupId) MarshalJSON() ([]byte, error) {
28391 if self.TypeLen == 0 {
28392 return []byte("\"\""), nil
28393 } else {
28394 return []byte("\"" + self.GetOXMName() + "\""), nil
28395 }
28396}
28397
28398type OxmIdBsnVlanXlatePortGroupIdMasked struct {
28399 *OxmId
28400}
28401
28402type IOxmIdBsnVlanXlatePortGroupIdMasked interface {
28403 IOxmId
28404}
28405
28406func (self *OxmIdBsnVlanXlatePortGroupIdMasked) Serialize(encoder *goloxi.Encoder) error {
28407 if err := self.OxmId.Serialize(encoder); err != nil {
28408 return err
28409 }
28410
28411 return nil
28412}
28413
28414func DecodeOxmIdBsnVlanXlatePortGroupIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVlanXlatePortGroupIdMasked, error) {
28415 _oxmidbsnvlanxlateportgroupidmasked := &OxmIdBsnVlanXlatePortGroupIdMasked{OxmId: parent}
28416 return _oxmidbsnvlanxlateportgroupidmasked, nil
28417}
28418
28419func NewOxmIdBsnVlanXlatePortGroupIdMasked() *OxmIdBsnVlanXlatePortGroupIdMasked {
28420 obj := &OxmIdBsnVlanXlatePortGroupIdMasked{
28421 OxmId: NewOxmId(205576),
28422 }
28423 return obj
28424}
28425func (self *OxmIdBsnVlanXlatePortGroupIdMasked) GetOXMName() string {
28426 return "bsn_vlan_xlate_port_group_id_masked"
28427}
28428
28429func (self *OxmIdBsnVlanXlatePortGroupIdMasked) MarshalJSON() ([]byte, error) {
28430 if self.TypeLen == 0 {
28431 return []byte("\"\""), nil
28432 } else {
28433 return []byte("\"" + self.GetOXMName() + "\""), nil
28434 }
28435}
28436
28437type OxmIdBsnVrf struct {
28438 *OxmId
28439}
28440
28441type IOxmIdBsnVrf interface {
28442 IOxmId
28443}
28444
28445func (self *OxmIdBsnVrf) Serialize(encoder *goloxi.Encoder) error {
28446 if err := self.OxmId.Serialize(encoder); err != nil {
28447 return err
28448 }
28449
28450 return nil
28451}
28452
28453func DecodeOxmIdBsnVrf(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVrf, error) {
28454 _oxmidbsnvrf := &OxmIdBsnVrf{OxmId: parent}
28455 return _oxmidbsnvrf, nil
28456}
28457
28458func NewOxmIdBsnVrf() *OxmIdBsnVrf {
28459 obj := &OxmIdBsnVrf{
28460 OxmId: NewOxmId(197636),
28461 }
28462 return obj
28463}
28464func (self *OxmIdBsnVrf) GetOXMName() string {
28465 return "bsn_vrf"
28466}
28467
28468func (self *OxmIdBsnVrf) MarshalJSON() ([]byte, error) {
28469 if self.TypeLen == 0 {
28470 return []byte("\"\""), nil
28471 } else {
28472 return []byte("\"" + self.GetOXMName() + "\""), nil
28473 }
28474}
28475
28476type OxmIdBsnVrfMasked struct {
28477 *OxmId
28478}
28479
28480type IOxmIdBsnVrfMasked interface {
28481 IOxmId
28482}
28483
28484func (self *OxmIdBsnVrfMasked) Serialize(encoder *goloxi.Encoder) error {
28485 if err := self.OxmId.Serialize(encoder); err != nil {
28486 return err
28487 }
28488
28489 return nil
28490}
28491
28492func DecodeOxmIdBsnVrfMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVrfMasked, error) {
28493 _oxmidbsnvrfmasked := &OxmIdBsnVrfMasked{OxmId: parent}
28494 return _oxmidbsnvrfmasked, nil
28495}
28496
28497func NewOxmIdBsnVrfMasked() *OxmIdBsnVrfMasked {
28498 obj := &OxmIdBsnVrfMasked{
28499 OxmId: NewOxmId(197896),
28500 }
28501 return obj
28502}
28503func (self *OxmIdBsnVrfMasked) GetOXMName() string {
28504 return "bsn_vrf_masked"
28505}
28506
28507func (self *OxmIdBsnVrfMasked) MarshalJSON() ([]byte, error) {
28508 if self.TypeLen == 0 {
28509 return []byte("\"\""), nil
28510 } else {
28511 return []byte("\"" + self.GetOXMName() + "\""), nil
28512 }
28513}
28514
28515type OxmIdBsnVxlanNetworkId struct {
28516 *OxmId
28517}
28518
28519type IOxmIdBsnVxlanNetworkId interface {
28520 IOxmId
28521}
28522
28523func (self *OxmIdBsnVxlanNetworkId) Serialize(encoder *goloxi.Encoder) error {
28524 if err := self.OxmId.Serialize(encoder); err != nil {
28525 return err
28526 }
28527
28528 return nil
28529}
28530
28531func DecodeOxmIdBsnVxlanNetworkId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVxlanNetworkId, error) {
28532 _oxmidbsnvxlannetworkid := &OxmIdBsnVxlanNetworkId{OxmId: parent}
28533 return _oxmidbsnvxlannetworkid, nil
28534}
28535
28536func NewOxmIdBsnVxlanNetworkId() *OxmIdBsnVxlanNetworkId {
28537 obj := &OxmIdBsnVxlanNetworkId{
28538 OxmId: NewOxmId(207364),
28539 }
28540 return obj
28541}
28542func (self *OxmIdBsnVxlanNetworkId) GetOXMName() string {
28543 return "bsn_vxlan_network_id"
28544}
28545
28546func (self *OxmIdBsnVxlanNetworkId) MarshalJSON() ([]byte, error) {
28547 if self.TypeLen == 0 {
28548 return []byte("\"\""), nil
28549 } else {
28550 return []byte("\"" + self.GetOXMName() + "\""), nil
28551 }
28552}
28553
28554type OxmIdBsnVxlanNetworkIdMasked struct {
28555 *OxmId
28556}
28557
28558type IOxmIdBsnVxlanNetworkIdMasked interface {
28559 IOxmId
28560}
28561
28562func (self *OxmIdBsnVxlanNetworkIdMasked) Serialize(encoder *goloxi.Encoder) error {
28563 if err := self.OxmId.Serialize(encoder); err != nil {
28564 return err
28565 }
28566
28567 return nil
28568}
28569
28570func DecodeOxmIdBsnVxlanNetworkIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVxlanNetworkIdMasked, error) {
28571 _oxmidbsnvxlannetworkidmasked := &OxmIdBsnVxlanNetworkIdMasked{OxmId: parent}
28572 return _oxmidbsnvxlannetworkidmasked, nil
28573}
28574
28575func NewOxmIdBsnVxlanNetworkIdMasked() *OxmIdBsnVxlanNetworkIdMasked {
28576 obj := &OxmIdBsnVxlanNetworkIdMasked{
28577 OxmId: NewOxmId(207624),
28578 }
28579 return obj
28580}
28581func (self *OxmIdBsnVxlanNetworkIdMasked) GetOXMName() string {
28582 return "bsn_vxlan_network_id_masked"
28583}
28584
28585func (self *OxmIdBsnVxlanNetworkIdMasked) MarshalJSON() ([]byte, error) {
28586 if self.TypeLen == 0 {
28587 return []byte("\"\""), nil
28588 } else {
28589 return []byte("\"" + self.GetOXMName() + "\""), nil
28590 }
28591}
28592
28593type OxmIdConnTrackingIpv6Dst struct {
28594 *OxmId
28595}
28596
28597type IOxmIdConnTrackingIpv6Dst interface {
28598 IOxmId
28599}
28600
28601func (self *OxmIdConnTrackingIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
28602 if err := self.OxmId.Serialize(encoder); err != nil {
28603 return err
28604 }
28605
28606 return nil
28607}
28608
28609func DecodeOxmIdConnTrackingIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6Dst, error) {
28610 _oxmidconntrackingipv6dst := &OxmIdConnTrackingIpv6Dst{OxmId: parent}
28611 return _oxmidconntrackingipv6dst, nil
28612}
28613
28614func NewOxmIdConnTrackingIpv6Dst() *OxmIdConnTrackingIpv6Dst {
28615 obj := &OxmIdConnTrackingIpv6Dst{
28616 OxmId: NewOxmId(128528),
28617 }
28618 return obj
28619}
28620func (self *OxmIdConnTrackingIpv6Dst) GetOXMName() string {
28621 return "conn_tracking_ipv6_dst"
28622}
28623
28624func (self *OxmIdConnTrackingIpv6Dst) MarshalJSON() ([]byte, error) {
28625 if self.TypeLen == 0 {
28626 return []byte("\"\""), nil
28627 } else {
28628 return []byte("\"" + self.GetOXMName() + "\""), nil
28629 }
28630}
28631
28632type OxmIdConnTrackingIpv6DstMasked struct {
28633 *OxmId
28634}
28635
28636type IOxmIdConnTrackingIpv6DstMasked interface {
28637 IOxmId
28638}
28639
28640func (self *OxmIdConnTrackingIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
28641 if err := self.OxmId.Serialize(encoder); err != nil {
28642 return err
28643 }
28644
28645 return nil
28646}
28647
28648func DecodeOxmIdConnTrackingIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6DstMasked, error) {
28649 _oxmidconntrackingipv6dstmasked := &OxmIdConnTrackingIpv6DstMasked{OxmId: parent}
28650 return _oxmidconntrackingipv6dstmasked, nil
28651}
28652
28653func NewOxmIdConnTrackingIpv6DstMasked() *OxmIdConnTrackingIpv6DstMasked {
28654 obj := &OxmIdConnTrackingIpv6DstMasked{
28655 OxmId: NewOxmId(128800),
28656 }
28657 return obj
28658}
28659func (self *OxmIdConnTrackingIpv6DstMasked) GetOXMName() string {
28660 return "conn_tracking_ipv6_dst_masked"
28661}
28662
28663func (self *OxmIdConnTrackingIpv6DstMasked) MarshalJSON() ([]byte, error) {
28664 if self.TypeLen == 0 {
28665 return []byte("\"\""), nil
28666 } else {
28667 return []byte("\"" + self.GetOXMName() + "\""), nil
28668 }
28669}
28670
28671type OxmIdConnTrackingIpv6Src struct {
28672 *OxmId
28673}
28674
28675type IOxmIdConnTrackingIpv6Src interface {
28676 IOxmId
28677}
28678
28679func (self *OxmIdConnTrackingIpv6Src) Serialize(encoder *goloxi.Encoder) error {
28680 if err := self.OxmId.Serialize(encoder); err != nil {
28681 return err
28682 }
28683
28684 return nil
28685}
28686
28687func DecodeOxmIdConnTrackingIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6Src, error) {
28688 _oxmidconntrackingipv6src := &OxmIdConnTrackingIpv6Src{OxmId: parent}
28689 return _oxmidconntrackingipv6src, nil
28690}
28691
28692func NewOxmIdConnTrackingIpv6Src() *OxmIdConnTrackingIpv6Src {
28693 obj := &OxmIdConnTrackingIpv6Src{
28694 OxmId: NewOxmId(128016),
28695 }
28696 return obj
28697}
28698func (self *OxmIdConnTrackingIpv6Src) GetOXMName() string {
28699 return "conn_tracking_ipv6_src"
28700}
28701
28702func (self *OxmIdConnTrackingIpv6Src) MarshalJSON() ([]byte, error) {
28703 if self.TypeLen == 0 {
28704 return []byte("\"\""), nil
28705 } else {
28706 return []byte("\"" + self.GetOXMName() + "\""), nil
28707 }
28708}
28709
28710type OxmIdConnTrackingIpv6SrcMasked struct {
28711 *OxmId
28712}
28713
28714type IOxmIdConnTrackingIpv6SrcMasked interface {
28715 IOxmId
28716}
28717
28718func (self *OxmIdConnTrackingIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
28719 if err := self.OxmId.Serialize(encoder); err != nil {
28720 return err
28721 }
28722
28723 return nil
28724}
28725
28726func DecodeOxmIdConnTrackingIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6SrcMasked, error) {
28727 _oxmidconntrackingipv6srcmasked := &OxmIdConnTrackingIpv6SrcMasked{OxmId: parent}
28728 return _oxmidconntrackingipv6srcmasked, nil
28729}
28730
28731func NewOxmIdConnTrackingIpv6SrcMasked() *OxmIdConnTrackingIpv6SrcMasked {
28732 obj := &OxmIdConnTrackingIpv6SrcMasked{
28733 OxmId: NewOxmId(128288),
28734 }
28735 return obj
28736}
28737func (self *OxmIdConnTrackingIpv6SrcMasked) GetOXMName() string {
28738 return "conn_tracking_ipv6_src_masked"
28739}
28740
28741func (self *OxmIdConnTrackingIpv6SrcMasked) MarshalJSON() ([]byte, error) {
28742 if self.TypeLen == 0 {
28743 return []byte("\"\""), nil
28744 } else {
28745 return []byte("\"" + self.GetOXMName() + "\""), nil
28746 }
28747}
28748
28749type OxmIdConnTrackingLabel struct {
28750 *OxmId
28751}
28752
28753type IOxmIdConnTrackingLabel interface {
28754 IOxmId
28755}
28756
28757func (self *OxmIdConnTrackingLabel) Serialize(encoder *goloxi.Encoder) error {
28758 if err := self.OxmId.Serialize(encoder); err != nil {
28759 return err
28760 }
28761
28762 return nil
28763}
28764
28765func DecodeOxmIdConnTrackingLabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingLabel, error) {
28766 _oxmidconntrackinglabel := &OxmIdConnTrackingLabel{OxmId: parent}
28767 return _oxmidconntrackinglabel, nil
28768}
28769
28770func NewOxmIdConnTrackingLabel() *OxmIdConnTrackingLabel {
28771 obj := &OxmIdConnTrackingLabel{
28772 OxmId: NewOxmId(120848),
28773 }
28774 return obj
28775}
28776func (self *OxmIdConnTrackingLabel) GetOXMName() string {
28777 return "conn_tracking_label"
28778}
28779
28780func (self *OxmIdConnTrackingLabel) MarshalJSON() ([]byte, error) {
28781 if self.TypeLen == 0 {
28782 return []byte("\"\""), nil
28783 } else {
28784 return []byte("\"" + self.GetOXMName() + "\""), nil
28785 }
28786}
28787
28788type OxmIdConnTrackingLabelMasked struct {
28789 *OxmId
28790}
28791
28792type IOxmIdConnTrackingLabelMasked interface {
28793 IOxmId
28794}
28795
28796func (self *OxmIdConnTrackingLabelMasked) Serialize(encoder *goloxi.Encoder) error {
28797 if err := self.OxmId.Serialize(encoder); err != nil {
28798 return err
28799 }
28800
28801 return nil
28802}
28803
28804func DecodeOxmIdConnTrackingLabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingLabelMasked, error) {
28805 _oxmidconntrackinglabelmasked := &OxmIdConnTrackingLabelMasked{OxmId: parent}
28806 return _oxmidconntrackinglabelmasked, nil
28807}
28808
28809func NewOxmIdConnTrackingLabelMasked() *OxmIdConnTrackingLabelMasked {
28810 obj := &OxmIdConnTrackingLabelMasked{
28811 OxmId: NewOxmId(121120),
28812 }
28813 return obj
28814}
28815func (self *OxmIdConnTrackingLabelMasked) GetOXMName() string {
28816 return "conn_tracking_label_masked"
28817}
28818
28819func (self *OxmIdConnTrackingLabelMasked) MarshalJSON() ([]byte, error) {
28820 if self.TypeLen == 0 {
28821 return []byte("\"\""), nil
28822 } else {
28823 return []byte("\"" + self.GetOXMName() + "\""), nil
28824 }
28825}
28826
28827type OxmIdConnTrackingMark struct {
28828 *OxmId
28829}
28830
28831type IOxmIdConnTrackingMark interface {
28832 IOxmId
28833}
28834
28835func (self *OxmIdConnTrackingMark) Serialize(encoder *goloxi.Encoder) error {
28836 if err := self.OxmId.Serialize(encoder); err != nil {
28837 return err
28838 }
28839
28840 return nil
28841}
28842
28843func DecodeOxmIdConnTrackingMark(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingMark, error) {
28844 _oxmidconntrackingmark := &OxmIdConnTrackingMark{OxmId: parent}
28845 return _oxmidconntrackingmark, nil
28846}
28847
28848func NewOxmIdConnTrackingMark() *OxmIdConnTrackingMark {
28849 obj := &OxmIdConnTrackingMark{
28850 OxmId: NewOxmId(120324),
28851 }
28852 return obj
28853}
28854func (self *OxmIdConnTrackingMark) GetOXMName() string {
28855 return "conn_tracking_mark"
28856}
28857
28858func (self *OxmIdConnTrackingMark) MarshalJSON() ([]byte, error) {
28859 if self.TypeLen == 0 {
28860 return []byte("\"\""), nil
28861 } else {
28862 return []byte("\"" + self.GetOXMName() + "\""), nil
28863 }
28864}
28865
28866type OxmIdConnTrackingMarkMasked struct {
28867 *OxmId
28868}
28869
28870type IOxmIdConnTrackingMarkMasked interface {
28871 IOxmId
28872}
28873
28874func (self *OxmIdConnTrackingMarkMasked) Serialize(encoder *goloxi.Encoder) error {
28875 if err := self.OxmId.Serialize(encoder); err != nil {
28876 return err
28877 }
28878
28879 return nil
28880}
28881
28882func DecodeOxmIdConnTrackingMarkMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingMarkMasked, error) {
28883 _oxmidconntrackingmarkmasked := &OxmIdConnTrackingMarkMasked{OxmId: parent}
28884 return _oxmidconntrackingmarkmasked, nil
28885}
28886
28887func NewOxmIdConnTrackingMarkMasked() *OxmIdConnTrackingMarkMasked {
28888 obj := &OxmIdConnTrackingMarkMasked{
28889 OxmId: NewOxmId(120584),
28890 }
28891 return obj
28892}
28893func (self *OxmIdConnTrackingMarkMasked) GetOXMName() string {
28894 return "conn_tracking_mark_masked"
28895}
28896
28897func (self *OxmIdConnTrackingMarkMasked) MarshalJSON() ([]byte, error) {
28898 if self.TypeLen == 0 {
28899 return []byte("\"\""), nil
28900 } else {
28901 return []byte("\"" + self.GetOXMName() + "\""), nil
28902 }
28903}
28904
28905type OxmIdConnTrackingNwDst struct {
28906 *OxmId
28907}
28908
28909type IOxmIdConnTrackingNwDst interface {
28910 IOxmId
28911}
28912
28913func (self *OxmIdConnTrackingNwDst) Serialize(encoder *goloxi.Encoder) error {
28914 if err := self.OxmId.Serialize(encoder); err != nil {
28915 return err
28916 }
28917
28918 return nil
28919}
28920
28921func DecodeOxmIdConnTrackingNwDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwDst, error) {
28922 _oxmidconntrackingnwdst := &OxmIdConnTrackingNwDst{OxmId: parent}
28923 return _oxmidconntrackingnwdst, nil
28924}
28925
28926func NewOxmIdConnTrackingNwDst() *OxmIdConnTrackingNwDst {
28927 obj := &OxmIdConnTrackingNwDst{
28928 OxmId: NewOxmId(127492),
28929 }
28930 return obj
28931}
28932func (self *OxmIdConnTrackingNwDst) GetOXMName() string {
28933 return "conn_tracking_nw_dst"
28934}
28935
28936func (self *OxmIdConnTrackingNwDst) MarshalJSON() ([]byte, error) {
28937 if self.TypeLen == 0 {
28938 return []byte("\"\""), nil
28939 } else {
28940 return []byte("\"" + self.GetOXMName() + "\""), nil
28941 }
28942}
28943
28944type OxmIdConnTrackingNwDstMasked struct {
28945 *OxmId
28946}
28947
28948type IOxmIdConnTrackingNwDstMasked interface {
28949 IOxmId
28950}
28951
28952func (self *OxmIdConnTrackingNwDstMasked) Serialize(encoder *goloxi.Encoder) error {
28953 if err := self.OxmId.Serialize(encoder); err != nil {
28954 return err
28955 }
28956
28957 return nil
28958}
28959
28960func DecodeOxmIdConnTrackingNwDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwDstMasked, error) {
28961 _oxmidconntrackingnwdstmasked := &OxmIdConnTrackingNwDstMasked{OxmId: parent}
28962 return _oxmidconntrackingnwdstmasked, nil
28963}
28964
28965func NewOxmIdConnTrackingNwDstMasked() *OxmIdConnTrackingNwDstMasked {
28966 obj := &OxmIdConnTrackingNwDstMasked{
28967 OxmId: NewOxmId(127752),
28968 }
28969 return obj
28970}
28971func (self *OxmIdConnTrackingNwDstMasked) GetOXMName() string {
28972 return "conn_tracking_nw_dst_masked"
28973}
28974
28975func (self *OxmIdConnTrackingNwDstMasked) MarshalJSON() ([]byte, error) {
28976 if self.TypeLen == 0 {
28977 return []byte("\"\""), nil
28978 } else {
28979 return []byte("\"" + self.GetOXMName() + "\""), nil
28980 }
28981}
28982
28983type OxmIdConnTrackingNwProto struct {
28984 *OxmId
28985}
28986
28987type IOxmIdConnTrackingNwProto interface {
28988 IOxmId
28989}
28990
28991func (self *OxmIdConnTrackingNwProto) Serialize(encoder *goloxi.Encoder) error {
28992 if err := self.OxmId.Serialize(encoder); err != nil {
28993 return err
28994 }
28995
28996 return nil
28997}
28998
28999func DecodeOxmIdConnTrackingNwProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwProto, error) {
29000 _oxmidconntrackingnwproto := &OxmIdConnTrackingNwProto{OxmId: parent}
29001 return _oxmidconntrackingnwproto, nil
29002}
29003
29004func NewOxmIdConnTrackingNwProto() *OxmIdConnTrackingNwProto {
29005 obj := &OxmIdConnTrackingNwProto{
29006 OxmId: NewOxmId(126465),
29007 }
29008 return obj
29009}
29010func (self *OxmIdConnTrackingNwProto) GetOXMName() string {
29011 return "conn_tracking_nw_proto"
29012}
29013
29014func (self *OxmIdConnTrackingNwProto) MarshalJSON() ([]byte, error) {
29015 if self.TypeLen == 0 {
29016 return []byte("\"\""), nil
29017 } else {
29018 return []byte("\"" + self.GetOXMName() + "\""), nil
29019 }
29020}
29021
29022type OxmIdConnTrackingNwProtoMasked struct {
29023 *OxmId
29024}
29025
29026type IOxmIdConnTrackingNwProtoMasked interface {
29027 IOxmId
29028}
29029
29030func (self *OxmIdConnTrackingNwProtoMasked) Serialize(encoder *goloxi.Encoder) error {
29031 if err := self.OxmId.Serialize(encoder); err != nil {
29032 return err
29033 }
29034
29035 return nil
29036}
29037
29038func DecodeOxmIdConnTrackingNwProtoMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwProtoMasked, error) {
29039 _oxmidconntrackingnwprotomasked := &OxmIdConnTrackingNwProtoMasked{OxmId: parent}
29040 return _oxmidconntrackingnwprotomasked, nil
29041}
29042
29043func NewOxmIdConnTrackingNwProtoMasked() *OxmIdConnTrackingNwProtoMasked {
29044 obj := &OxmIdConnTrackingNwProtoMasked{
29045 OxmId: NewOxmId(126722),
29046 }
29047 return obj
29048}
29049func (self *OxmIdConnTrackingNwProtoMasked) GetOXMName() string {
29050 return "conn_tracking_nw_proto_masked"
29051}
29052
29053func (self *OxmIdConnTrackingNwProtoMasked) MarshalJSON() ([]byte, error) {
29054 if self.TypeLen == 0 {
29055 return []byte("\"\""), nil
29056 } else {
29057 return []byte("\"" + self.GetOXMName() + "\""), nil
29058 }
29059}
29060
29061type OxmIdConnTrackingNwSrc struct {
29062 *OxmId
29063}
29064
29065type IOxmIdConnTrackingNwSrc interface {
29066 IOxmId
29067}
29068
29069func (self *OxmIdConnTrackingNwSrc) Serialize(encoder *goloxi.Encoder) error {
29070 if err := self.OxmId.Serialize(encoder); err != nil {
29071 return err
29072 }
29073
29074 return nil
29075}
29076
29077func DecodeOxmIdConnTrackingNwSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwSrc, error) {
29078 _oxmidconntrackingnwsrc := &OxmIdConnTrackingNwSrc{OxmId: parent}
29079 return _oxmidconntrackingnwsrc, nil
29080}
29081
29082func NewOxmIdConnTrackingNwSrc() *OxmIdConnTrackingNwSrc {
29083 obj := &OxmIdConnTrackingNwSrc{
29084 OxmId: NewOxmId(126980),
29085 }
29086 return obj
29087}
29088func (self *OxmIdConnTrackingNwSrc) GetOXMName() string {
29089 return "conn_tracking_nw_src"
29090}
29091
29092func (self *OxmIdConnTrackingNwSrc) MarshalJSON() ([]byte, error) {
29093 if self.TypeLen == 0 {
29094 return []byte("\"\""), nil
29095 } else {
29096 return []byte("\"" + self.GetOXMName() + "\""), nil
29097 }
29098}
29099
29100type OxmIdConnTrackingNwSrcMasked struct {
29101 *OxmId
29102}
29103
29104type IOxmIdConnTrackingNwSrcMasked interface {
29105 IOxmId
29106}
29107
29108func (self *OxmIdConnTrackingNwSrcMasked) Serialize(encoder *goloxi.Encoder) error {
29109 if err := self.OxmId.Serialize(encoder); err != nil {
29110 return err
29111 }
29112
29113 return nil
29114}
29115
29116func DecodeOxmIdConnTrackingNwSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwSrcMasked, error) {
29117 _oxmidconntrackingnwsrcmasked := &OxmIdConnTrackingNwSrcMasked{OxmId: parent}
29118 return _oxmidconntrackingnwsrcmasked, nil
29119}
29120
29121func NewOxmIdConnTrackingNwSrcMasked() *OxmIdConnTrackingNwSrcMasked {
29122 obj := &OxmIdConnTrackingNwSrcMasked{
29123 OxmId: NewOxmId(127240),
29124 }
29125 return obj
29126}
29127func (self *OxmIdConnTrackingNwSrcMasked) GetOXMName() string {
29128 return "conn_tracking_nw_src_masked"
29129}
29130
29131func (self *OxmIdConnTrackingNwSrcMasked) MarshalJSON() ([]byte, error) {
29132 if self.TypeLen == 0 {
29133 return []byte("\"\""), nil
29134 } else {
29135 return []byte("\"" + self.GetOXMName() + "\""), nil
29136 }
29137}
29138
29139type OxmIdConnTrackingState struct {
29140 *OxmId
29141}
29142
29143type IOxmIdConnTrackingState interface {
29144 IOxmId
29145}
29146
29147func (self *OxmIdConnTrackingState) Serialize(encoder *goloxi.Encoder) error {
29148 if err := self.OxmId.Serialize(encoder); err != nil {
29149 return err
29150 }
29151
29152 return nil
29153}
29154
29155func DecodeOxmIdConnTrackingState(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingState, error) {
29156 _oxmidconntrackingstate := &OxmIdConnTrackingState{OxmId: parent}
29157 return _oxmidconntrackingstate, nil
29158}
29159
29160func NewOxmIdConnTrackingState() *OxmIdConnTrackingState {
29161 obj := &OxmIdConnTrackingState{
29162 OxmId: NewOxmId(119300),
29163 }
29164 return obj
29165}
29166func (self *OxmIdConnTrackingState) GetOXMName() string {
29167 return "conn_tracking_state"
29168}
29169
29170func (self *OxmIdConnTrackingState) MarshalJSON() ([]byte, error) {
29171 if self.TypeLen == 0 {
29172 return []byte("\"\""), nil
29173 } else {
29174 return []byte("\"" + self.GetOXMName() + "\""), nil
29175 }
29176}
29177
29178type OxmIdConnTrackingStateMasked struct {
29179 *OxmId
29180}
29181
29182type IOxmIdConnTrackingStateMasked interface {
29183 IOxmId
29184}
29185
29186func (self *OxmIdConnTrackingStateMasked) Serialize(encoder *goloxi.Encoder) error {
29187 if err := self.OxmId.Serialize(encoder); err != nil {
29188 return err
29189 }
29190
29191 return nil
29192}
29193
29194func DecodeOxmIdConnTrackingStateMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingStateMasked, error) {
29195 _oxmidconntrackingstatemasked := &OxmIdConnTrackingStateMasked{OxmId: parent}
29196 return _oxmidconntrackingstatemasked, nil
29197}
29198
29199func NewOxmIdConnTrackingStateMasked() *OxmIdConnTrackingStateMasked {
29200 obj := &OxmIdConnTrackingStateMasked{
29201 OxmId: NewOxmId(119560),
29202 }
29203 return obj
29204}
29205func (self *OxmIdConnTrackingStateMasked) GetOXMName() string {
29206 return "conn_tracking_state_masked"
29207}
29208
29209func (self *OxmIdConnTrackingStateMasked) MarshalJSON() ([]byte, error) {
29210 if self.TypeLen == 0 {
29211 return []byte("\"\""), nil
29212 } else {
29213 return []byte("\"" + self.GetOXMName() + "\""), nil
29214 }
29215}
29216
29217type OxmIdConnTrackingTpDst struct {
29218 *OxmId
29219}
29220
29221type IOxmIdConnTrackingTpDst interface {
29222 IOxmId
29223}
29224
29225func (self *OxmIdConnTrackingTpDst) Serialize(encoder *goloxi.Encoder) error {
29226 if err := self.OxmId.Serialize(encoder); err != nil {
29227 return err
29228 }
29229
29230 return nil
29231}
29232
29233func DecodeOxmIdConnTrackingTpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpDst, error) {
29234 _oxmidconntrackingtpdst := &OxmIdConnTrackingTpDst{OxmId: parent}
29235 return _oxmidconntrackingtpdst, nil
29236}
29237
29238func NewOxmIdConnTrackingTpDst() *OxmIdConnTrackingTpDst {
29239 obj := &OxmIdConnTrackingTpDst{
29240 OxmId: NewOxmId(129538),
29241 }
29242 return obj
29243}
29244func (self *OxmIdConnTrackingTpDst) GetOXMName() string {
29245 return "conn_tracking_tp_dst"
29246}
29247
29248func (self *OxmIdConnTrackingTpDst) MarshalJSON() ([]byte, error) {
29249 if self.TypeLen == 0 {
29250 return []byte("\"\""), nil
29251 } else {
29252 return []byte("\"" + self.GetOXMName() + "\""), nil
29253 }
29254}
29255
29256type OxmIdConnTrackingTpDstMasked struct {
29257 *OxmId
29258}
29259
29260type IOxmIdConnTrackingTpDstMasked interface {
29261 IOxmId
29262}
29263
29264func (self *OxmIdConnTrackingTpDstMasked) Serialize(encoder *goloxi.Encoder) error {
29265 if err := self.OxmId.Serialize(encoder); err != nil {
29266 return err
29267 }
29268
29269 return nil
29270}
29271
29272func DecodeOxmIdConnTrackingTpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpDstMasked, error) {
29273 _oxmidconntrackingtpdstmasked := &OxmIdConnTrackingTpDstMasked{OxmId: parent}
29274 return _oxmidconntrackingtpdstmasked, nil
29275}
29276
29277func NewOxmIdConnTrackingTpDstMasked() *OxmIdConnTrackingTpDstMasked {
29278 obj := &OxmIdConnTrackingTpDstMasked{
29279 OxmId: NewOxmId(129796),
29280 }
29281 return obj
29282}
29283func (self *OxmIdConnTrackingTpDstMasked) GetOXMName() string {
29284 return "conn_tracking_tp_dst_masked"
29285}
29286
29287func (self *OxmIdConnTrackingTpDstMasked) MarshalJSON() ([]byte, error) {
29288 if self.TypeLen == 0 {
29289 return []byte("\"\""), nil
29290 } else {
29291 return []byte("\"" + self.GetOXMName() + "\""), nil
29292 }
29293}
29294
29295type OxmIdConnTrackingTpSrc struct {
29296 *OxmId
29297}
29298
29299type IOxmIdConnTrackingTpSrc interface {
29300 IOxmId
29301}
29302
29303func (self *OxmIdConnTrackingTpSrc) Serialize(encoder *goloxi.Encoder) error {
29304 if err := self.OxmId.Serialize(encoder); err != nil {
29305 return err
29306 }
29307
29308 return nil
29309}
29310
29311func DecodeOxmIdConnTrackingTpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpSrc, error) {
29312 _oxmidconntrackingtpsrc := &OxmIdConnTrackingTpSrc{OxmId: parent}
29313 return _oxmidconntrackingtpsrc, nil
29314}
29315
29316func NewOxmIdConnTrackingTpSrc() *OxmIdConnTrackingTpSrc {
29317 obj := &OxmIdConnTrackingTpSrc{
29318 OxmId: NewOxmId(129026),
29319 }
29320 return obj
29321}
29322func (self *OxmIdConnTrackingTpSrc) GetOXMName() string {
29323 return "conn_tracking_tp_src"
29324}
29325
29326func (self *OxmIdConnTrackingTpSrc) MarshalJSON() ([]byte, error) {
29327 if self.TypeLen == 0 {
29328 return []byte("\"\""), nil
29329 } else {
29330 return []byte("\"" + self.GetOXMName() + "\""), nil
29331 }
29332}
29333
29334type OxmIdConnTrackingTpSrcMasked struct {
29335 *OxmId
29336}
29337
29338type IOxmIdConnTrackingTpSrcMasked interface {
29339 IOxmId
29340}
29341
29342func (self *OxmIdConnTrackingTpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
29343 if err := self.OxmId.Serialize(encoder); err != nil {
29344 return err
29345 }
29346
29347 return nil
29348}
29349
29350func DecodeOxmIdConnTrackingTpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpSrcMasked, error) {
29351 _oxmidconntrackingtpsrcmasked := &OxmIdConnTrackingTpSrcMasked{OxmId: parent}
29352 return _oxmidconntrackingtpsrcmasked, nil
29353}
29354
29355func NewOxmIdConnTrackingTpSrcMasked() *OxmIdConnTrackingTpSrcMasked {
29356 obj := &OxmIdConnTrackingTpSrcMasked{
29357 OxmId: NewOxmId(129284),
29358 }
29359 return obj
29360}
29361func (self *OxmIdConnTrackingTpSrcMasked) GetOXMName() string {
29362 return "conn_tracking_tp_src_masked"
29363}
29364
29365func (self *OxmIdConnTrackingTpSrcMasked) MarshalJSON() ([]byte, error) {
29366 if self.TypeLen == 0 {
29367 return []byte("\"\""), nil
29368 } else {
29369 return []byte("\"" + self.GetOXMName() + "\""), nil
29370 }
29371}
29372
29373type OxmIdConnTrackingZone struct {
29374 *OxmId
29375}
29376
29377type IOxmIdConnTrackingZone interface {
29378 IOxmId
29379}
29380
29381func (self *OxmIdConnTrackingZone) Serialize(encoder *goloxi.Encoder) error {
29382 if err := self.OxmId.Serialize(encoder); err != nil {
29383 return err
29384 }
29385
29386 return nil
29387}
29388
29389func DecodeOxmIdConnTrackingZone(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingZone, error) {
29390 _oxmidconntrackingzone := &OxmIdConnTrackingZone{OxmId: parent}
29391 return _oxmidconntrackingzone, nil
29392}
29393
29394func NewOxmIdConnTrackingZone() *OxmIdConnTrackingZone {
29395 obj := &OxmIdConnTrackingZone{
29396 OxmId: NewOxmId(119810),
29397 }
29398 return obj
29399}
29400func (self *OxmIdConnTrackingZone) GetOXMName() string {
29401 return "conn_tracking_zone"
29402}
29403
29404func (self *OxmIdConnTrackingZone) MarshalJSON() ([]byte, error) {
29405 if self.TypeLen == 0 {
29406 return []byte("\"\""), nil
29407 } else {
29408 return []byte("\"" + self.GetOXMName() + "\""), nil
29409 }
29410}
29411
29412type OxmIdConnTrackingZoneMasked struct {
29413 *OxmId
29414}
29415
29416type IOxmIdConnTrackingZoneMasked interface {
29417 IOxmId
29418}
29419
29420func (self *OxmIdConnTrackingZoneMasked) Serialize(encoder *goloxi.Encoder) error {
29421 if err := self.OxmId.Serialize(encoder); err != nil {
29422 return err
29423 }
29424
29425 return nil
29426}
29427
29428func DecodeOxmIdConnTrackingZoneMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingZoneMasked, error) {
29429 _oxmidconntrackingzonemasked := &OxmIdConnTrackingZoneMasked{OxmId: parent}
29430 return _oxmidconntrackingzonemasked, nil
29431}
29432
29433func NewOxmIdConnTrackingZoneMasked() *OxmIdConnTrackingZoneMasked {
29434 obj := &OxmIdConnTrackingZoneMasked{
29435 OxmId: NewOxmId(120068),
29436 }
29437 return obj
29438}
29439func (self *OxmIdConnTrackingZoneMasked) GetOXMName() string {
29440 return "conn_tracking_zone_masked"
29441}
29442
29443func (self *OxmIdConnTrackingZoneMasked) MarshalJSON() ([]byte, error) {
29444 if self.TypeLen == 0 {
29445 return []byte("\"\""), nil
29446 } else {
29447 return []byte("\"" + self.GetOXMName() + "\""), nil
29448 }
29449}
29450
29451type OxmIdEthTypeMasked struct {
29452 *OxmId
29453}
29454
29455type IOxmIdEthTypeMasked interface {
29456 IOxmId
29457}
29458
29459func (self *OxmIdEthTypeMasked) Serialize(encoder *goloxi.Encoder) error {
29460 if err := self.OxmId.Serialize(encoder); err != nil {
29461 return err
29462 }
29463
29464 return nil
29465}
29466
29467func DecodeOxmIdEthTypeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthTypeMasked, error) {
29468 _oxmidethtypemasked := &OxmIdEthTypeMasked{OxmId: parent}
29469 return _oxmidethtypemasked, nil
29470}
29471
29472func NewOxmIdEthTypeMasked() *OxmIdEthTypeMasked {
29473 obj := &OxmIdEthTypeMasked{
29474 OxmId: NewOxmId(2147486468),
29475 }
29476 return obj
29477}
29478func (self *OxmIdEthTypeMasked) GetOXMName() string {
29479 return "eth_type_masked"
29480}
29481
29482func (self *OxmIdEthTypeMasked) MarshalJSON() ([]byte, error) {
29483 if self.TypeLen == 0 {
29484 return []byte("\"\""), nil
29485 } else {
29486 return []byte("\"" + self.GetOXMName() + "\""), nil
29487 }
29488}
29489
29490type OxmIdIcmpv4Code struct {
29491 *OxmId
29492}
29493
29494type IOxmIdIcmpv4Code interface {
29495 IOxmId
29496}
29497
29498func (self *OxmIdIcmpv4Code) Serialize(encoder *goloxi.Encoder) error {
29499 if err := self.OxmId.Serialize(encoder); err != nil {
29500 return err
29501 }
29502
29503 return nil
29504}
29505
29506func DecodeOxmIdIcmpv4Code(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4Code, error) {
29507 _oxmidicmpv4code := &OxmIdIcmpv4Code{OxmId: parent}
29508 return _oxmidicmpv4code, nil
29509}
29510
29511func NewOxmIdIcmpv4Code() *OxmIdIcmpv4Code {
29512 obj := &OxmIdIcmpv4Code{
29513 OxmId: NewOxmId(2147493889),
29514 }
29515 return obj
29516}
29517func (self *OxmIdIcmpv4Code) GetOXMName() string {
29518 return "icmpv4_code"
29519}
29520
29521func (self *OxmIdIcmpv4Code) MarshalJSON() ([]byte, error) {
29522 if self.TypeLen == 0 {
29523 return []byte("\"\""), nil
29524 } else {
29525 return []byte("\"" + self.GetOXMName() + "\""), nil
29526 }
29527}
29528
29529type OxmIdIcmpv4CodeMasked struct {
29530 *OxmId
29531}
29532
29533type IOxmIdIcmpv4CodeMasked interface {
29534 IOxmId
29535}
29536
29537func (self *OxmIdIcmpv4CodeMasked) Serialize(encoder *goloxi.Encoder) error {
29538 if err := self.OxmId.Serialize(encoder); err != nil {
29539 return err
29540 }
29541
29542 return nil
29543}
29544
29545func DecodeOxmIdIcmpv4CodeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4CodeMasked, error) {
29546 _oxmidicmpv4codemasked := &OxmIdIcmpv4CodeMasked{OxmId: parent}
29547 return _oxmidicmpv4codemasked, nil
29548}
29549
29550func NewOxmIdIcmpv4CodeMasked() *OxmIdIcmpv4CodeMasked {
29551 obj := &OxmIdIcmpv4CodeMasked{
29552 OxmId: NewOxmId(2147494146),
29553 }
29554 return obj
29555}
29556func (self *OxmIdIcmpv4CodeMasked) GetOXMName() string {
29557 return "icmpv4_code_masked"
29558}
29559
29560func (self *OxmIdIcmpv4CodeMasked) MarshalJSON() ([]byte, error) {
29561 if self.TypeLen == 0 {
29562 return []byte("\"\""), nil
29563 } else {
29564 return []byte("\"" + self.GetOXMName() + "\""), nil
29565 }
29566}
29567
29568type OxmIdIcmpv4Type struct {
29569 *OxmId
29570}
29571
29572type IOxmIdIcmpv4Type interface {
29573 IOxmId
29574}
29575
29576func (self *OxmIdIcmpv4Type) Serialize(encoder *goloxi.Encoder) error {
29577 if err := self.OxmId.Serialize(encoder); err != nil {
29578 return err
29579 }
29580
29581 return nil
29582}
29583
29584func DecodeOxmIdIcmpv4Type(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4Type, error) {
29585 _oxmidicmpv4type := &OxmIdIcmpv4Type{OxmId: parent}
29586 return _oxmidicmpv4type, nil
29587}
29588
29589func NewOxmIdIcmpv4Type() *OxmIdIcmpv4Type {
29590 obj := &OxmIdIcmpv4Type{
29591 OxmId: NewOxmId(2147493377),
29592 }
29593 return obj
29594}
29595func (self *OxmIdIcmpv4Type) GetOXMName() string {
29596 return "icmpv4_type"
29597}
29598
29599func (self *OxmIdIcmpv4Type) MarshalJSON() ([]byte, error) {
29600 if self.TypeLen == 0 {
29601 return []byte("\"\""), nil
29602 } else {
29603 return []byte("\"" + self.GetOXMName() + "\""), nil
29604 }
29605}
29606
29607type OxmIdIcmpv4TypeMasked struct {
29608 *OxmId
29609}
29610
29611type IOxmIdIcmpv4TypeMasked interface {
29612 IOxmId
29613}
29614
29615func (self *OxmIdIcmpv4TypeMasked) Serialize(encoder *goloxi.Encoder) error {
29616 if err := self.OxmId.Serialize(encoder); err != nil {
29617 return err
29618 }
29619
29620 return nil
29621}
29622
29623func DecodeOxmIdIcmpv4TypeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4TypeMasked, error) {
29624 _oxmidicmpv4typemasked := &OxmIdIcmpv4TypeMasked{OxmId: parent}
29625 return _oxmidicmpv4typemasked, nil
29626}
29627
29628func NewOxmIdIcmpv4TypeMasked() *OxmIdIcmpv4TypeMasked {
29629 obj := &OxmIdIcmpv4TypeMasked{
29630 OxmId: NewOxmId(2147493634),
29631 }
29632 return obj
29633}
29634func (self *OxmIdIcmpv4TypeMasked) GetOXMName() string {
29635 return "icmpv4_type_masked"
29636}
29637
29638func (self *OxmIdIcmpv4TypeMasked) MarshalJSON() ([]byte, error) {
29639 if self.TypeLen == 0 {
29640 return []byte("\"\""), nil
29641 } else {
29642 return []byte("\"" + self.GetOXMName() + "\""), nil
29643 }
29644}
29645
29646type OxmIdIcmpv6CodeMasked struct {
29647 *OxmId
29648}
29649
29650type IOxmIdIcmpv6CodeMasked interface {
29651 IOxmId
29652}
29653
29654func (self *OxmIdIcmpv6CodeMasked) Serialize(encoder *goloxi.Encoder) error {
29655 if err := self.OxmId.Serialize(encoder); err != nil {
29656 return err
29657 }
29658
29659 return nil
29660}
29661
29662func DecodeOxmIdIcmpv6CodeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6CodeMasked, error) {
29663 _oxmidicmpv6codemasked := &OxmIdIcmpv6CodeMasked{OxmId: parent}
29664 return _oxmidicmpv6codemasked, nil
29665}
29666
29667func NewOxmIdIcmpv6CodeMasked() *OxmIdIcmpv6CodeMasked {
29668 obj := &OxmIdIcmpv6CodeMasked{
29669 OxmId: NewOxmId(2147499266),
29670 }
29671 return obj
29672}
29673func (self *OxmIdIcmpv6CodeMasked) GetOXMName() string {
29674 return "icmpv6_code_masked"
29675}
29676
29677func (self *OxmIdIcmpv6CodeMasked) MarshalJSON() ([]byte, error) {
29678 if self.TypeLen == 0 {
29679 return []byte("\"\""), nil
29680 } else {
29681 return []byte("\"" + self.GetOXMName() + "\""), nil
29682 }
29683}
29684
29685type OxmIdIcmpv6TypeMasked struct {
29686 *OxmId
29687}
29688
29689type IOxmIdIcmpv6TypeMasked interface {
29690 IOxmId
29691}
29692
29693func (self *OxmIdIcmpv6TypeMasked) Serialize(encoder *goloxi.Encoder) error {
29694 if err := self.OxmId.Serialize(encoder); err != nil {
29695 return err
29696 }
29697
29698 return nil
29699}
29700
29701func DecodeOxmIdIcmpv6TypeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6TypeMasked, error) {
29702 _oxmidicmpv6typemasked := &OxmIdIcmpv6TypeMasked{OxmId: parent}
29703 return _oxmidicmpv6typemasked, nil
29704}
29705
29706func NewOxmIdIcmpv6TypeMasked() *OxmIdIcmpv6TypeMasked {
29707 obj := &OxmIdIcmpv6TypeMasked{
29708 OxmId: NewOxmId(2147498754),
29709 }
29710 return obj
29711}
29712func (self *OxmIdIcmpv6TypeMasked) GetOXMName() string {
29713 return "icmpv6_type_masked"
29714}
29715
29716func (self *OxmIdIcmpv6TypeMasked) MarshalJSON() ([]byte, error) {
29717 if self.TypeLen == 0 {
29718 return []byte("\"\""), nil
29719 } else {
29720 return []byte("\"" + self.GetOXMName() + "\""), nil
29721 }
29722}
29723
29724type OxmIdInPhyPort struct {
29725 *OxmId
29726}
29727
29728type IOxmIdInPhyPort interface {
29729 IOxmId
29730}
29731
29732func (self *OxmIdInPhyPort) Serialize(encoder *goloxi.Encoder) error {
29733 if err := self.OxmId.Serialize(encoder); err != nil {
29734 return err
29735 }
29736
29737 return nil
29738}
29739
29740func DecodeOxmIdInPhyPort(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPhyPort, error) {
29741 _oxmidinphyport := &OxmIdInPhyPort{OxmId: parent}
29742 return _oxmidinphyport, nil
29743}
29744
29745func NewOxmIdInPhyPort() *OxmIdInPhyPort {
29746 obj := &OxmIdInPhyPort{
29747 OxmId: NewOxmId(2147484164),
29748 }
29749 return obj
29750}
29751func (self *OxmIdInPhyPort) GetOXMName() string {
29752 return "in_phy_port"
29753}
29754
29755func (self *OxmIdInPhyPort) MarshalJSON() ([]byte, error) {
29756 if self.TypeLen == 0 {
29757 return []byte("\"\""), nil
29758 } else {
29759 return []byte("\"" + self.GetOXMName() + "\""), nil
29760 }
29761}
29762
29763type OxmIdInPhyPortMasked struct {
29764 *OxmId
29765}
29766
29767type IOxmIdInPhyPortMasked interface {
29768 IOxmId
29769}
29770
29771func (self *OxmIdInPhyPortMasked) Serialize(encoder *goloxi.Encoder) error {
29772 if err := self.OxmId.Serialize(encoder); err != nil {
29773 return err
29774 }
29775
29776 return nil
29777}
29778
29779func DecodeOxmIdInPhyPortMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPhyPortMasked, error) {
29780 _oxmidinphyportmasked := &OxmIdInPhyPortMasked{OxmId: parent}
29781 return _oxmidinphyportmasked, nil
29782}
29783
29784func NewOxmIdInPhyPortMasked() *OxmIdInPhyPortMasked {
29785 obj := &OxmIdInPhyPortMasked{
29786 OxmId: NewOxmId(2147484424),
29787 }
29788 return obj
29789}
29790func (self *OxmIdInPhyPortMasked) GetOXMName() string {
29791 return "in_phy_port_masked"
29792}
29793
29794func (self *OxmIdInPhyPortMasked) MarshalJSON() ([]byte, error) {
29795 if self.TypeLen == 0 {
29796 return []byte("\"\""), nil
29797 } else {
29798 return []byte("\"" + self.GetOXMName() + "\""), nil
29799 }
29800}
29801
29802type OxmIdInPortMasked struct {
29803 *OxmId
29804}
29805
29806type IOxmIdInPortMasked interface {
29807 IOxmId
29808}
29809
29810func (self *OxmIdInPortMasked) Serialize(encoder *goloxi.Encoder) error {
29811 if err := self.OxmId.Serialize(encoder); err != nil {
29812 return err
29813 }
29814
29815 return nil
29816}
29817
29818func DecodeOxmIdInPortMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPortMasked, error) {
29819 _oxmidinportmasked := &OxmIdInPortMasked{OxmId: parent}
29820 return _oxmidinportmasked, nil
29821}
29822
29823func NewOxmIdInPortMasked() *OxmIdInPortMasked {
29824 obj := &OxmIdInPortMasked{
29825 OxmId: NewOxmId(2147483912),
29826 }
29827 return obj
29828}
29829func (self *OxmIdInPortMasked) GetOXMName() string {
29830 return "in_port_masked"
29831}
29832
29833func (self *OxmIdInPortMasked) MarshalJSON() ([]byte, error) {
29834 if self.TypeLen == 0 {
29835 return []byte("\"\""), nil
29836 } else {
29837 return []byte("\"" + self.GetOXMName() + "\""), nil
29838 }
29839}
29840
29841type OxmIdIpDscp struct {
29842 *OxmId
29843}
29844
29845type IOxmIdIpDscp interface {
29846 IOxmId
29847}
29848
29849func (self *OxmIdIpDscp) Serialize(encoder *goloxi.Encoder) error {
29850 if err := self.OxmId.Serialize(encoder); err != nil {
29851 return err
29852 }
29853
29854 return nil
29855}
29856
29857func DecodeOxmIdIpDscp(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDscp, error) {
29858 _oxmidipdscp := &OxmIdIpDscp{OxmId: parent}
29859 return _oxmidipdscp, nil
29860}
29861
29862func NewOxmIdIpDscp() *OxmIdIpDscp {
29863 obj := &OxmIdIpDscp{
29864 OxmId: NewOxmId(2147487745),
29865 }
29866 return obj
29867}
29868func (self *OxmIdIpDscp) GetOXMName() string {
29869 return "ip_dscp"
29870}
29871
29872func (self *OxmIdIpDscp) MarshalJSON() ([]byte, error) {
29873 if self.TypeLen == 0 {
29874 return []byte("\"\""), nil
29875 } else {
29876 return []byte("\"" + self.GetOXMName() + "\""), nil
29877 }
29878}
29879
29880type OxmIdIpDscpMasked struct {
29881 *OxmId
29882}
29883
29884type IOxmIdIpDscpMasked interface {
29885 IOxmId
29886}
29887
29888func (self *OxmIdIpDscpMasked) Serialize(encoder *goloxi.Encoder) error {
29889 if err := self.OxmId.Serialize(encoder); err != nil {
29890 return err
29891 }
29892
29893 return nil
29894}
29895
29896func DecodeOxmIdIpDscpMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDscpMasked, error) {
29897 _oxmidipdscpmasked := &OxmIdIpDscpMasked{OxmId: parent}
29898 return _oxmidipdscpmasked, nil
29899}
29900
29901func NewOxmIdIpDscpMasked() *OxmIdIpDscpMasked {
29902 obj := &OxmIdIpDscpMasked{
29903 OxmId: NewOxmId(2147488002),
29904 }
29905 return obj
29906}
29907func (self *OxmIdIpDscpMasked) GetOXMName() string {
29908 return "ip_dscp_masked"
29909}
29910
29911func (self *OxmIdIpDscpMasked) MarshalJSON() ([]byte, error) {
29912 if self.TypeLen == 0 {
29913 return []byte("\"\""), nil
29914 } else {
29915 return []byte("\"" + self.GetOXMName() + "\""), nil
29916 }
29917}
29918
29919type OxmIdIpEcn struct {
29920 *OxmId
29921}
29922
29923type IOxmIdIpEcn interface {
29924 IOxmId
29925}
29926
29927func (self *OxmIdIpEcn) Serialize(encoder *goloxi.Encoder) error {
29928 if err := self.OxmId.Serialize(encoder); err != nil {
29929 return err
29930 }
29931
29932 return nil
29933}
29934
29935func DecodeOxmIdIpEcn(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpEcn, error) {
29936 _oxmidipecn := &OxmIdIpEcn{OxmId: parent}
29937 return _oxmidipecn, nil
29938}
29939
29940func NewOxmIdIpEcn() *OxmIdIpEcn {
29941 obj := &OxmIdIpEcn{
29942 OxmId: NewOxmId(2147488257),
29943 }
29944 return obj
29945}
29946func (self *OxmIdIpEcn) GetOXMName() string {
29947 return "ip_ecn"
29948}
29949
29950func (self *OxmIdIpEcn) MarshalJSON() ([]byte, error) {
29951 if self.TypeLen == 0 {
29952 return []byte("\"\""), nil
29953 } else {
29954 return []byte("\"" + self.GetOXMName() + "\""), nil
29955 }
29956}
29957
29958type OxmIdIpEcnMasked struct {
29959 *OxmId
29960}
29961
29962type IOxmIdIpEcnMasked interface {
29963 IOxmId
29964}
29965
29966func (self *OxmIdIpEcnMasked) Serialize(encoder *goloxi.Encoder) error {
29967 if err := self.OxmId.Serialize(encoder); err != nil {
29968 return err
29969 }
29970
29971 return nil
29972}
29973
29974func DecodeOxmIdIpEcnMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpEcnMasked, error) {
29975 _oxmidipecnmasked := &OxmIdIpEcnMasked{OxmId: parent}
29976 return _oxmidipecnmasked, nil
29977}
29978
29979func NewOxmIdIpEcnMasked() *OxmIdIpEcnMasked {
29980 obj := &OxmIdIpEcnMasked{
29981 OxmId: NewOxmId(2147488514),
29982 }
29983 return obj
29984}
29985func (self *OxmIdIpEcnMasked) GetOXMName() string {
29986 return "ip_ecn_masked"
29987}
29988
29989func (self *OxmIdIpEcnMasked) MarshalJSON() ([]byte, error) {
29990 if self.TypeLen == 0 {
29991 return []byte("\"\""), nil
29992 } else {
29993 return []byte("\"" + self.GetOXMName() + "\""), nil
29994 }
29995}
29996
29997type OxmIdIpProto struct {
29998 *OxmId
29999}
30000
30001type IOxmIdIpProto interface {
30002 IOxmId
30003}
30004
30005func (self *OxmIdIpProto) Serialize(encoder *goloxi.Encoder) error {
30006 if err := self.OxmId.Serialize(encoder); err != nil {
30007 return err
30008 }
30009
30010 return nil
30011}
30012
30013func DecodeOxmIdIpProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpProto, error) {
30014 _oxmidipproto := &OxmIdIpProto{OxmId: parent}
30015 return _oxmidipproto, nil
30016}
30017
30018func NewOxmIdIpProto() *OxmIdIpProto {
30019 obj := &OxmIdIpProto{
30020 OxmId: NewOxmId(2147488769),
30021 }
30022 return obj
30023}
30024func (self *OxmIdIpProto) GetOXMName() string {
30025 return "ip_proto"
30026}
30027
30028func (self *OxmIdIpProto) MarshalJSON() ([]byte, error) {
30029 if self.TypeLen == 0 {
30030 return []byte("\"\""), nil
30031 } else {
30032 return []byte("\"" + self.GetOXMName() + "\""), nil
30033 }
30034}
30035
30036type OxmIdIpProtoMasked struct {
30037 *OxmId
30038}
30039
30040type IOxmIdIpProtoMasked interface {
30041 IOxmId
30042}
30043
30044func (self *OxmIdIpProtoMasked) Serialize(encoder *goloxi.Encoder) error {
30045 if err := self.OxmId.Serialize(encoder); err != nil {
30046 return err
30047 }
30048
30049 return nil
30050}
30051
30052func DecodeOxmIdIpProtoMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpProtoMasked, error) {
30053 _oxmidipprotomasked := &OxmIdIpProtoMasked{OxmId: parent}
30054 return _oxmidipprotomasked, nil
30055}
30056
30057func NewOxmIdIpProtoMasked() *OxmIdIpProtoMasked {
30058 obj := &OxmIdIpProtoMasked{
30059 OxmId: NewOxmId(2147489026),
30060 }
30061 return obj
30062}
30063func (self *OxmIdIpProtoMasked) GetOXMName() string {
30064 return "ip_proto_masked"
30065}
30066
30067func (self *OxmIdIpProtoMasked) MarshalJSON() ([]byte, error) {
30068 if self.TypeLen == 0 {
30069 return []byte("\"\""), nil
30070 } else {
30071 return []byte("\"" + self.GetOXMName() + "\""), nil
30072 }
30073}
30074
30075type OxmIdIpv4Dst struct {
30076 *OxmId
30077}
30078
30079type IOxmIdIpv4Dst interface {
30080 IOxmId
30081}
30082
30083func (self *OxmIdIpv4Dst) Serialize(encoder *goloxi.Encoder) error {
30084 if err := self.OxmId.Serialize(encoder); err != nil {
30085 return err
30086 }
30087
30088 return nil
30089}
30090
30091func DecodeOxmIdIpv4Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4Dst, error) {
30092 _oxmidipv4dst := &OxmIdIpv4Dst{OxmId: parent}
30093 return _oxmidipv4dst, nil
30094}
30095
30096func NewOxmIdIpv4Dst() *OxmIdIpv4Dst {
30097 obj := &OxmIdIpv4Dst{
30098 OxmId: NewOxmId(2147489796),
30099 }
30100 return obj
30101}
30102func (self *OxmIdIpv4Dst) GetOXMName() string {
30103 return "ipv4_dst"
30104}
30105
30106func (self *OxmIdIpv4Dst) MarshalJSON() ([]byte, error) {
30107 if self.TypeLen == 0 {
30108 return []byte("\"\""), nil
30109 } else {
30110 return []byte("\"" + self.GetOXMName() + "\""), nil
30111 }
30112}
30113
30114type OxmIdIpv4DstMasked struct {
30115 *OxmId
30116}
30117
30118type IOxmIdIpv4DstMasked interface {
30119 IOxmId
30120}
30121
30122func (self *OxmIdIpv4DstMasked) Serialize(encoder *goloxi.Encoder) error {
30123 if err := self.OxmId.Serialize(encoder); err != nil {
30124 return err
30125 }
30126
30127 return nil
30128}
30129
30130func DecodeOxmIdIpv4DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4DstMasked, error) {
30131 _oxmidipv4dstmasked := &OxmIdIpv4DstMasked{OxmId: parent}
30132 return _oxmidipv4dstmasked, nil
30133}
30134
30135func NewOxmIdIpv4DstMasked() *OxmIdIpv4DstMasked {
30136 obj := &OxmIdIpv4DstMasked{
30137 OxmId: NewOxmId(2147490056),
30138 }
30139 return obj
30140}
30141func (self *OxmIdIpv4DstMasked) GetOXMName() string {
30142 return "ipv4_dst_masked"
30143}
30144
30145func (self *OxmIdIpv4DstMasked) MarshalJSON() ([]byte, error) {
30146 if self.TypeLen == 0 {
30147 return []byte("\"\""), nil
30148 } else {
30149 return []byte("\"" + self.GetOXMName() + "\""), nil
30150 }
30151}
30152
30153type OxmIdIpv4Src struct {
30154 *OxmId
30155}
30156
30157type IOxmIdIpv4Src interface {
30158 IOxmId
30159}
30160
30161func (self *OxmIdIpv4Src) Serialize(encoder *goloxi.Encoder) error {
30162 if err := self.OxmId.Serialize(encoder); err != nil {
30163 return err
30164 }
30165
30166 return nil
30167}
30168
30169func DecodeOxmIdIpv4Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4Src, error) {
30170 _oxmidipv4src := &OxmIdIpv4Src{OxmId: parent}
30171 return _oxmidipv4src, nil
30172}
30173
30174func NewOxmIdIpv4Src() *OxmIdIpv4Src {
30175 obj := &OxmIdIpv4Src{
30176 OxmId: NewOxmId(2147489284),
30177 }
30178 return obj
30179}
30180func (self *OxmIdIpv4Src) GetOXMName() string {
30181 return "ipv4_src"
30182}
30183
30184func (self *OxmIdIpv4Src) MarshalJSON() ([]byte, error) {
30185 if self.TypeLen == 0 {
30186 return []byte("\"\""), nil
30187 } else {
30188 return []byte("\"" + self.GetOXMName() + "\""), nil
30189 }
30190}
30191
30192type OxmIdIpv4SrcMasked struct {
30193 *OxmId
30194}
30195
30196type IOxmIdIpv4SrcMasked interface {
30197 IOxmId
30198}
30199
30200func (self *OxmIdIpv4SrcMasked) Serialize(encoder *goloxi.Encoder) error {
30201 if err := self.OxmId.Serialize(encoder); err != nil {
30202 return err
30203 }
30204
30205 return nil
30206}
30207
30208func DecodeOxmIdIpv4SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4SrcMasked, error) {
30209 _oxmidipv4srcmasked := &OxmIdIpv4SrcMasked{OxmId: parent}
30210 return _oxmidipv4srcmasked, nil
30211}
30212
30213func NewOxmIdIpv4SrcMasked() *OxmIdIpv4SrcMasked {
30214 obj := &OxmIdIpv4SrcMasked{
30215 OxmId: NewOxmId(2147489544),
30216 }
30217 return obj
30218}
30219func (self *OxmIdIpv4SrcMasked) GetOXMName() string {
30220 return "ipv4_src_masked"
30221}
30222
30223func (self *OxmIdIpv4SrcMasked) MarshalJSON() ([]byte, error) {
30224 if self.TypeLen == 0 {
30225 return []byte("\"\""), nil
30226 } else {
30227 return []byte("\"" + self.GetOXMName() + "\""), nil
30228 }
30229}
30230
30231type OxmIdIpv6Exthdr struct {
30232 *OxmId
30233}
30234
30235type IOxmIdIpv6Exthdr interface {
30236 IOxmId
30237}
30238
30239func (self *OxmIdIpv6Exthdr) Serialize(encoder *goloxi.Encoder) error {
30240 if err := self.OxmId.Serialize(encoder); err != nil {
30241 return err
30242 }
30243
30244 return nil
30245}
30246
30247func DecodeOxmIdIpv6Exthdr(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Exthdr, error) {
30248 _oxmidipv6exthdr := &OxmIdIpv6Exthdr{OxmId: parent}
30249 return _oxmidipv6exthdr, nil
30250}
30251
30252func NewOxmIdIpv6Exthdr() *OxmIdIpv6Exthdr {
30253 obj := &OxmIdIpv6Exthdr{
30254 OxmId: NewOxmId(2147503618),
30255 }
30256 return obj
30257}
30258func (self *OxmIdIpv6Exthdr) GetOXMName() string {
30259 return "ipv6_exthdr"
30260}
30261
30262func (self *OxmIdIpv6Exthdr) MarshalJSON() ([]byte, error) {
30263 if self.TypeLen == 0 {
30264 return []byte("\"\""), nil
30265 } else {
30266 return []byte("\"" + self.GetOXMName() + "\""), nil
30267 }
30268}
30269
30270type OxmIdIpv6ExthdrMasked struct {
30271 *OxmId
30272}
30273
30274type IOxmIdIpv6ExthdrMasked interface {
30275 IOxmId
30276}
30277
30278func (self *OxmIdIpv6ExthdrMasked) Serialize(encoder *goloxi.Encoder) error {
30279 if err := self.OxmId.Serialize(encoder); err != nil {
30280 return err
30281 }
30282
30283 return nil
30284}
30285
30286func DecodeOxmIdIpv6ExthdrMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6ExthdrMasked, error) {
30287 _oxmidipv6exthdrmasked := &OxmIdIpv6ExthdrMasked{OxmId: parent}
30288 return _oxmidipv6exthdrmasked, nil
30289}
30290
30291func NewOxmIdIpv6ExthdrMasked() *OxmIdIpv6ExthdrMasked {
30292 obj := &OxmIdIpv6ExthdrMasked{
30293 OxmId: NewOxmId(2147503876),
30294 }
30295 return obj
30296}
30297func (self *OxmIdIpv6ExthdrMasked) GetOXMName() string {
30298 return "ipv6_exthdr_masked"
30299}
30300
30301func (self *OxmIdIpv6ExthdrMasked) MarshalJSON() ([]byte, error) {
30302 if self.TypeLen == 0 {
30303 return []byte("\"\""), nil
30304 } else {
30305 return []byte("\"" + self.GetOXMName() + "\""), nil
30306 }
30307}
30308
30309type OxmIdIpv6Flabel struct {
30310 *OxmId
30311}
30312
30313type IOxmIdIpv6Flabel interface {
30314 IOxmId
30315}
30316
30317func (self *OxmIdIpv6Flabel) Serialize(encoder *goloxi.Encoder) error {
30318 if err := self.OxmId.Serialize(encoder); err != nil {
30319 return err
30320 }
30321
30322 return nil
30323}
30324
30325func DecodeOxmIdIpv6Flabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Flabel, error) {
30326 _oxmidipv6flabel := &OxmIdIpv6Flabel{OxmId: parent}
30327 return _oxmidipv6flabel, nil
30328}
30329
30330func NewOxmIdIpv6Flabel() *OxmIdIpv6Flabel {
30331 obj := &OxmIdIpv6Flabel{
30332 OxmId: NewOxmId(2147497988),
30333 }
30334 return obj
30335}
30336func (self *OxmIdIpv6Flabel) GetOXMName() string {
30337 return "ipv6_flabel"
30338}
30339
30340func (self *OxmIdIpv6Flabel) MarshalJSON() ([]byte, error) {
30341 if self.TypeLen == 0 {
30342 return []byte("\"\""), nil
30343 } else {
30344 return []byte("\"" + self.GetOXMName() + "\""), nil
30345 }
30346}
30347
30348type OxmIdIpv6FlabelMasked struct {
30349 *OxmId
30350}
30351
30352type IOxmIdIpv6FlabelMasked interface {
30353 IOxmId
30354}
30355
30356func (self *OxmIdIpv6FlabelMasked) Serialize(encoder *goloxi.Encoder) error {
30357 if err := self.OxmId.Serialize(encoder); err != nil {
30358 return err
30359 }
30360
30361 return nil
30362}
30363
30364func DecodeOxmIdIpv6FlabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6FlabelMasked, error) {
30365 _oxmidipv6flabelmasked := &OxmIdIpv6FlabelMasked{OxmId: parent}
30366 return _oxmidipv6flabelmasked, nil
30367}
30368
30369func NewOxmIdIpv6FlabelMasked() *OxmIdIpv6FlabelMasked {
30370 obj := &OxmIdIpv6FlabelMasked{
30371 OxmId: NewOxmId(2147498248),
30372 }
30373 return obj
30374}
30375func (self *OxmIdIpv6FlabelMasked) GetOXMName() string {
30376 return "ipv6_flabel_masked"
30377}
30378
30379func (self *OxmIdIpv6FlabelMasked) MarshalJSON() ([]byte, error) {
30380 if self.TypeLen == 0 {
30381 return []byte("\"\""), nil
30382 } else {
30383 return []byte("\"" + self.GetOXMName() + "\""), nil
30384 }
30385}
30386
30387type OxmIdIpv6NdSll struct {
30388 *OxmId
30389}
30390
30391type IOxmIdIpv6NdSll interface {
30392 IOxmId
30393}
30394
30395func (self *OxmIdIpv6NdSll) Serialize(encoder *goloxi.Encoder) error {
30396 if err := self.OxmId.Serialize(encoder); err != nil {
30397 return err
30398 }
30399
30400 return nil
30401}
30402
30403func DecodeOxmIdIpv6NdSll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdSll, error) {
30404 _oxmidipv6ndsll := &OxmIdIpv6NdSll{OxmId: parent}
30405 return _oxmidipv6ndsll, nil
30406}
30407
30408func NewOxmIdIpv6NdSll() *OxmIdIpv6NdSll {
30409 obj := &OxmIdIpv6NdSll{
30410 OxmId: NewOxmId(2147500038),
30411 }
30412 return obj
30413}
30414func (self *OxmIdIpv6NdSll) GetOXMName() string {
30415 return "ipv6_nd_sll"
30416}
30417
30418func (self *OxmIdIpv6NdSll) MarshalJSON() ([]byte, error) {
30419 if self.TypeLen == 0 {
30420 return []byte("\"\""), nil
30421 } else {
30422 return []byte("\"" + self.GetOXMName() + "\""), nil
30423 }
30424}
30425
30426type OxmIdIpv6NdSllMasked struct {
30427 *OxmId
30428}
30429
30430type IOxmIdIpv6NdSllMasked interface {
30431 IOxmId
30432}
30433
30434func (self *OxmIdIpv6NdSllMasked) Serialize(encoder *goloxi.Encoder) error {
30435 if err := self.OxmId.Serialize(encoder); err != nil {
30436 return err
30437 }
30438
30439 return nil
30440}
30441
30442func DecodeOxmIdIpv6NdSllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdSllMasked, error) {
30443 _oxmidipv6ndsllmasked := &OxmIdIpv6NdSllMasked{OxmId: parent}
30444 return _oxmidipv6ndsllmasked, nil
30445}
30446
30447func NewOxmIdIpv6NdSllMasked() *OxmIdIpv6NdSllMasked {
30448 obj := &OxmIdIpv6NdSllMasked{
30449 OxmId: NewOxmId(2147500300),
30450 }
30451 return obj
30452}
30453func (self *OxmIdIpv6NdSllMasked) GetOXMName() string {
30454 return "ipv6_nd_sll_masked"
30455}
30456
30457func (self *OxmIdIpv6NdSllMasked) MarshalJSON() ([]byte, error) {
30458 if self.TypeLen == 0 {
30459 return []byte("\"\""), nil
30460 } else {
30461 return []byte("\"" + self.GetOXMName() + "\""), nil
30462 }
30463}
30464
30465type OxmIdIpv6NdTarget struct {
30466 *OxmId
30467}
30468
30469type IOxmIdIpv6NdTarget interface {
30470 IOxmId
30471}
30472
30473func (self *OxmIdIpv6NdTarget) Serialize(encoder *goloxi.Encoder) error {
30474 if err := self.OxmId.Serialize(encoder); err != nil {
30475 return err
30476 }
30477
30478 return nil
30479}
30480
30481func DecodeOxmIdIpv6NdTarget(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTarget, error) {
30482 _oxmidipv6ndtarget := &OxmIdIpv6NdTarget{OxmId: parent}
30483 return _oxmidipv6ndtarget, nil
30484}
30485
30486func NewOxmIdIpv6NdTarget() *OxmIdIpv6NdTarget {
30487 obj := &OxmIdIpv6NdTarget{
30488 OxmId: NewOxmId(2147499536),
30489 }
30490 return obj
30491}
30492func (self *OxmIdIpv6NdTarget) GetOXMName() string {
30493 return "ipv6_nd_target"
30494}
30495
30496func (self *OxmIdIpv6NdTarget) MarshalJSON() ([]byte, error) {
30497 if self.TypeLen == 0 {
30498 return []byte("\"\""), nil
30499 } else {
30500 return []byte("\"" + self.GetOXMName() + "\""), nil
30501 }
30502}
30503
30504type OxmIdIpv6NdTargetMasked struct {
30505 *OxmId
30506}
30507
30508type IOxmIdIpv6NdTargetMasked interface {
30509 IOxmId
30510}
30511
30512func (self *OxmIdIpv6NdTargetMasked) Serialize(encoder *goloxi.Encoder) error {
30513 if err := self.OxmId.Serialize(encoder); err != nil {
30514 return err
30515 }
30516
30517 return nil
30518}
30519
30520func DecodeOxmIdIpv6NdTargetMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTargetMasked, error) {
30521 _oxmidipv6ndtargetmasked := &OxmIdIpv6NdTargetMasked{OxmId: parent}
30522 return _oxmidipv6ndtargetmasked, nil
30523}
30524
30525func NewOxmIdIpv6NdTargetMasked() *OxmIdIpv6NdTargetMasked {
30526 obj := &OxmIdIpv6NdTargetMasked{
30527 OxmId: NewOxmId(2147499808),
30528 }
30529 return obj
30530}
30531func (self *OxmIdIpv6NdTargetMasked) GetOXMName() string {
30532 return "ipv6_nd_target_masked"
30533}
30534
30535func (self *OxmIdIpv6NdTargetMasked) MarshalJSON() ([]byte, error) {
30536 if self.TypeLen == 0 {
30537 return []byte("\"\""), nil
30538 } else {
30539 return []byte("\"" + self.GetOXMName() + "\""), nil
30540 }
30541}
30542
30543type OxmIdIpv6NdTll struct {
30544 *OxmId
30545}
30546
30547type IOxmIdIpv6NdTll interface {
30548 IOxmId
30549}
30550
30551func (self *OxmIdIpv6NdTll) Serialize(encoder *goloxi.Encoder) error {
30552 if err := self.OxmId.Serialize(encoder); err != nil {
30553 return err
30554 }
30555
30556 return nil
30557}
30558
30559func DecodeOxmIdIpv6NdTll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTll, error) {
30560 _oxmidipv6ndtll := &OxmIdIpv6NdTll{OxmId: parent}
30561 return _oxmidipv6ndtll, nil
30562}
30563
30564func NewOxmIdIpv6NdTll() *OxmIdIpv6NdTll {
30565 obj := &OxmIdIpv6NdTll{
30566 OxmId: NewOxmId(2147500550),
30567 }
30568 return obj
30569}
30570func (self *OxmIdIpv6NdTll) GetOXMName() string {
30571 return "ipv6_nd_tll"
30572}
30573
30574func (self *OxmIdIpv6NdTll) MarshalJSON() ([]byte, error) {
30575 if self.TypeLen == 0 {
30576 return []byte("\"\""), nil
30577 } else {
30578 return []byte("\"" + self.GetOXMName() + "\""), nil
30579 }
30580}
30581
30582type OxmIdIpv6NdTllMasked struct {
30583 *OxmId
30584}
30585
30586type IOxmIdIpv6NdTllMasked interface {
30587 IOxmId
30588}
30589
30590func (self *OxmIdIpv6NdTllMasked) Serialize(encoder *goloxi.Encoder) error {
30591 if err := self.OxmId.Serialize(encoder); err != nil {
30592 return err
30593 }
30594
30595 return nil
30596}
30597
30598func DecodeOxmIdIpv6NdTllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTllMasked, error) {
30599 _oxmidipv6ndtllmasked := &OxmIdIpv6NdTllMasked{OxmId: parent}
30600 return _oxmidipv6ndtllmasked, nil
30601}
30602
30603func NewOxmIdIpv6NdTllMasked() *OxmIdIpv6NdTllMasked {
30604 obj := &OxmIdIpv6NdTllMasked{
30605 OxmId: NewOxmId(2147500812),
30606 }
30607 return obj
30608}
30609func (self *OxmIdIpv6NdTllMasked) GetOXMName() string {
30610 return "ipv6_nd_tll_masked"
30611}
30612
30613func (self *OxmIdIpv6NdTllMasked) MarshalJSON() ([]byte, error) {
30614 if self.TypeLen == 0 {
30615 return []byte("\"\""), nil
30616 } else {
30617 return []byte("\"" + self.GetOXMName() + "\""), nil
30618 }
30619}
30620
30621type OxmIdMetadata struct {
30622 *OxmId
30623}
30624
30625type IOxmIdMetadata interface {
30626 IOxmId
30627}
30628
30629func (self *OxmIdMetadata) Serialize(encoder *goloxi.Encoder) error {
30630 if err := self.OxmId.Serialize(encoder); err != nil {
30631 return err
30632 }
30633
30634 return nil
30635}
30636
30637func DecodeOxmIdMetadata(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMetadata, error) {
30638 _oxmidmetadata := &OxmIdMetadata{OxmId: parent}
30639 return _oxmidmetadata, nil
30640}
30641
30642func NewOxmIdMetadata() *OxmIdMetadata {
30643 obj := &OxmIdMetadata{
30644 OxmId: NewOxmId(2147484680),
30645 }
30646 return obj
30647}
30648func (self *OxmIdMetadata) GetOXMName() string {
30649 return "metadata"
30650}
30651
30652func (self *OxmIdMetadata) MarshalJSON() ([]byte, error) {
30653 if self.TypeLen == 0 {
30654 return []byte("\"\""), nil
30655 } else {
30656 return []byte("\"" + self.GetOXMName() + "\""), nil
30657 }
30658}
30659
30660type OxmIdMetadataMasked struct {
30661 *OxmId
30662}
30663
30664type IOxmIdMetadataMasked interface {
30665 IOxmId
30666}
30667
30668func (self *OxmIdMetadataMasked) Serialize(encoder *goloxi.Encoder) error {
30669 if err := self.OxmId.Serialize(encoder); err != nil {
30670 return err
30671 }
30672
30673 return nil
30674}
30675
30676func DecodeOxmIdMetadataMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMetadataMasked, error) {
30677 _oxmidmetadatamasked := &OxmIdMetadataMasked{OxmId: parent}
30678 return _oxmidmetadatamasked, nil
30679}
30680
30681func NewOxmIdMetadataMasked() *OxmIdMetadataMasked {
30682 obj := &OxmIdMetadataMasked{
30683 OxmId: NewOxmId(2147484944),
30684 }
30685 return obj
30686}
30687func (self *OxmIdMetadataMasked) GetOXMName() string {
30688 return "metadata_masked"
30689}
30690
30691func (self *OxmIdMetadataMasked) MarshalJSON() ([]byte, error) {
30692 if self.TypeLen == 0 {
30693 return []byte("\"\""), nil
30694 } else {
30695 return []byte("\"" + self.GetOXMName() + "\""), nil
30696 }
30697}
30698
30699type OxmIdMplsBos struct {
30700 *OxmId
30701}
30702
30703type IOxmIdMplsBos interface {
30704 IOxmId
30705}
30706
30707func (self *OxmIdMplsBos) Serialize(encoder *goloxi.Encoder) error {
30708 if err := self.OxmId.Serialize(encoder); err != nil {
30709 return err
30710 }
30711
30712 return nil
30713}
30714
30715func DecodeOxmIdMplsBos(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsBos, error) {
30716 _oxmidmplsbos := &OxmIdMplsBos{OxmId: parent}
30717 return _oxmidmplsbos, nil
30718}
30719
30720func NewOxmIdMplsBos() *OxmIdMplsBos {
30721 obj := &OxmIdMplsBos{
30722 OxmId: NewOxmId(2147502081),
30723 }
30724 return obj
30725}
30726func (self *OxmIdMplsBos) GetOXMName() string {
30727 return "mpls_bos"
30728}
30729
30730func (self *OxmIdMplsBos) MarshalJSON() ([]byte, error) {
30731 if self.TypeLen == 0 {
30732 return []byte("\"\""), nil
30733 } else {
30734 return []byte("\"" + self.GetOXMName() + "\""), nil
30735 }
30736}
30737
30738type OxmIdMplsBosMasked struct {
30739 *OxmId
30740}
30741
30742type IOxmIdMplsBosMasked interface {
30743 IOxmId
30744}
30745
30746func (self *OxmIdMplsBosMasked) Serialize(encoder *goloxi.Encoder) error {
30747 if err := self.OxmId.Serialize(encoder); err != nil {
30748 return err
30749 }
30750
30751 return nil
30752}
30753
30754func DecodeOxmIdMplsBosMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsBosMasked, error) {
30755 _oxmidmplsbosmasked := &OxmIdMplsBosMasked{OxmId: parent}
30756 return _oxmidmplsbosmasked, nil
30757}
30758
30759func NewOxmIdMplsBosMasked() *OxmIdMplsBosMasked {
30760 obj := &OxmIdMplsBosMasked{
30761 OxmId: NewOxmId(2147502338),
30762 }
30763 return obj
30764}
30765func (self *OxmIdMplsBosMasked) GetOXMName() string {
30766 return "mpls_bos_masked"
30767}
30768
30769func (self *OxmIdMplsBosMasked) MarshalJSON() ([]byte, error) {
30770 if self.TypeLen == 0 {
30771 return []byte("\"\""), nil
30772 } else {
30773 return []byte("\"" + self.GetOXMName() + "\""), nil
30774 }
30775}
30776
30777type OxmIdMplsLabel struct {
30778 *OxmId
30779}
30780
30781type IOxmIdMplsLabel interface {
30782 IOxmId
30783}
30784
30785func (self *OxmIdMplsLabel) Serialize(encoder *goloxi.Encoder) error {
30786 if err := self.OxmId.Serialize(encoder); err != nil {
30787 return err
30788 }
30789
30790 return nil
30791}
30792
30793func DecodeOxmIdMplsLabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsLabel, error) {
30794 _oxmidmplslabel := &OxmIdMplsLabel{OxmId: parent}
30795 return _oxmidmplslabel, nil
30796}
30797
30798func NewOxmIdMplsLabel() *OxmIdMplsLabel {
30799 obj := &OxmIdMplsLabel{
30800 OxmId: NewOxmId(2147501060),
30801 }
30802 return obj
30803}
30804func (self *OxmIdMplsLabel) GetOXMName() string {
30805 return "mpls_label"
30806}
30807
30808func (self *OxmIdMplsLabel) MarshalJSON() ([]byte, error) {
30809 if self.TypeLen == 0 {
30810 return []byte("\"\""), nil
30811 } else {
30812 return []byte("\"" + self.GetOXMName() + "\""), nil
30813 }
30814}
30815
30816type OxmIdMplsLabelMasked struct {
30817 *OxmId
30818}
30819
30820type IOxmIdMplsLabelMasked interface {
30821 IOxmId
30822}
30823
30824func (self *OxmIdMplsLabelMasked) Serialize(encoder *goloxi.Encoder) error {
30825 if err := self.OxmId.Serialize(encoder); err != nil {
30826 return err
30827 }
30828
30829 return nil
30830}
30831
30832func DecodeOxmIdMplsLabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsLabelMasked, error) {
30833 _oxmidmplslabelmasked := &OxmIdMplsLabelMasked{OxmId: parent}
30834 return _oxmidmplslabelmasked, nil
30835}
30836
30837func NewOxmIdMplsLabelMasked() *OxmIdMplsLabelMasked {
30838 obj := &OxmIdMplsLabelMasked{
30839 OxmId: NewOxmId(2147501320),
30840 }
30841 return obj
30842}
30843func (self *OxmIdMplsLabelMasked) GetOXMName() string {
30844 return "mpls_label_masked"
30845}
30846
30847func (self *OxmIdMplsLabelMasked) MarshalJSON() ([]byte, error) {
30848 if self.TypeLen == 0 {
30849 return []byte("\"\""), nil
30850 } else {
30851 return []byte("\"" + self.GetOXMName() + "\""), nil
30852 }
30853}
30854
30855type OxmIdMplsTc struct {
30856 *OxmId
30857}
30858
30859type IOxmIdMplsTc interface {
30860 IOxmId
30861}
30862
30863func (self *OxmIdMplsTc) Serialize(encoder *goloxi.Encoder) error {
30864 if err := self.OxmId.Serialize(encoder); err != nil {
30865 return err
30866 }
30867
30868 return nil
30869}
30870
30871func DecodeOxmIdMplsTc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsTc, error) {
30872 _oxmidmplstc := &OxmIdMplsTc{OxmId: parent}
30873 return _oxmidmplstc, nil
30874}
30875
30876func NewOxmIdMplsTc() *OxmIdMplsTc {
30877 obj := &OxmIdMplsTc{
30878 OxmId: NewOxmId(2147501569),
30879 }
30880 return obj
30881}
30882func (self *OxmIdMplsTc) GetOXMName() string {
30883 return "mpls_tc"
30884}
30885
30886func (self *OxmIdMplsTc) MarshalJSON() ([]byte, error) {
30887 if self.TypeLen == 0 {
30888 return []byte("\"\""), nil
30889 } else {
30890 return []byte("\"" + self.GetOXMName() + "\""), nil
30891 }
30892}
30893
30894type OxmIdMplsTcMasked struct {
30895 *OxmId
30896}
30897
30898type IOxmIdMplsTcMasked interface {
30899 IOxmId
30900}
30901
30902func (self *OxmIdMplsTcMasked) Serialize(encoder *goloxi.Encoder) error {
30903 if err := self.OxmId.Serialize(encoder); err != nil {
30904 return err
30905 }
30906
30907 return nil
30908}
30909
30910func DecodeOxmIdMplsTcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsTcMasked, error) {
30911 _oxmidmplstcmasked := &OxmIdMplsTcMasked{OxmId: parent}
30912 return _oxmidmplstcmasked, nil
30913}
30914
30915func NewOxmIdMplsTcMasked() *OxmIdMplsTcMasked {
30916 obj := &OxmIdMplsTcMasked{
30917 OxmId: NewOxmId(2147501826),
30918 }
30919 return obj
30920}
30921func (self *OxmIdMplsTcMasked) GetOXMName() string {
30922 return "mpls_tc_masked"
30923}
30924
30925func (self *OxmIdMplsTcMasked) MarshalJSON() ([]byte, error) {
30926 if self.TypeLen == 0 {
30927 return []byte("\"\""), nil
30928 } else {
30929 return []byte("\"" + self.GetOXMName() + "\""), nil
30930 }
30931}
30932
30933type OxmIdOvsTcpFlags struct {
30934 *OxmId
30935 ExperimenterId uint32
30936}
30937
30938type IOxmIdOvsTcpFlags interface {
30939 IOxmId
30940 GetExperimenterId() uint32
30941}
30942
30943func (self *OxmIdOvsTcpFlags) GetExperimenterId() uint32 {
30944 return self.ExperimenterId
30945}
30946
30947func (self *OxmIdOvsTcpFlags) SetExperimenterId(v uint32) {
30948 self.ExperimenterId = v
30949}
30950
30951func (self *OxmIdOvsTcpFlags) Serialize(encoder *goloxi.Encoder) error {
30952 if err := self.OxmId.Serialize(encoder); err != nil {
30953 return err
30954 }
30955
30956 encoder.PutUint32(uint32(self.ExperimenterId))
30957
30958 return nil
30959}
30960
30961func DecodeOxmIdOvsTcpFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdOvsTcpFlags, error) {
30962 _oxmidovstcpflags := &OxmIdOvsTcpFlags{OxmId: parent}
30963 if decoder.Length() < 4 {
30964 return nil, fmt.Errorf("OxmIdOvsTcpFlags packet too short: %d < 4", decoder.Length())
30965 }
30966 _oxmidovstcpflags.ExperimenterId = uint32(decoder.ReadUint32())
30967 return _oxmidovstcpflags, nil
30968}
30969
30970func NewOxmIdOvsTcpFlags() *OxmIdOvsTcpFlags {
30971 obj := &OxmIdOvsTcpFlags{
30972 OxmId: NewOxmId(4294923270),
30973 }
30974 return obj
30975}
30976func (self *OxmIdOvsTcpFlags) GetOXMName() string {
30977 return "ovs_tcp_flags"
30978}
30979
30980func (self *OxmIdOvsTcpFlags) MarshalJSON() ([]byte, error) {
30981 if self.TypeLen == 0 {
30982 return []byte("\"\""), nil
30983 } else {
30984 return []byte("\"" + self.GetOXMName() + "\""), nil
30985 }
30986}
30987
30988type OxmIdOvsTcpFlagsMasked struct {
30989 *OxmId
30990 ExperimenterId uint32
30991}
30992
30993type IOxmIdOvsTcpFlagsMasked interface {
30994 IOxmId
30995 GetExperimenterId() uint32
30996}
30997
30998func (self *OxmIdOvsTcpFlagsMasked) GetExperimenterId() uint32 {
30999 return self.ExperimenterId
31000}
31001
31002func (self *OxmIdOvsTcpFlagsMasked) SetExperimenterId(v uint32) {
31003 self.ExperimenterId = v
31004}
31005
31006func (self *OxmIdOvsTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
31007 if err := self.OxmId.Serialize(encoder); err != nil {
31008 return err
31009 }
31010
31011 encoder.PutUint32(uint32(self.ExperimenterId))
31012
31013 return nil
31014}
31015
31016func DecodeOxmIdOvsTcpFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdOvsTcpFlagsMasked, error) {
31017 _oxmidovstcpflagsmasked := &OxmIdOvsTcpFlagsMasked{OxmId: parent}
31018 if decoder.Length() < 4 {
31019 return nil, fmt.Errorf("OxmIdOvsTcpFlagsMasked packet too short: %d < 4", decoder.Length())
31020 }
31021 _oxmidovstcpflagsmasked.ExperimenterId = uint32(decoder.ReadUint32())
31022 return _oxmidovstcpflagsmasked, nil
31023}
31024
31025func NewOxmIdOvsTcpFlagsMasked() *OxmIdOvsTcpFlagsMasked {
31026 obj := &OxmIdOvsTcpFlagsMasked{
31027 OxmId: NewOxmId(4294923528),
31028 }
31029 return obj
31030}
31031func (self *OxmIdOvsTcpFlagsMasked) GetOXMName() string {
31032 return "ovs_tcp_flags_masked"
31033}
31034
31035func (self *OxmIdOvsTcpFlagsMasked) MarshalJSON() ([]byte, error) {
31036 if self.TypeLen == 0 {
31037 return []byte("\"\""), nil
31038 } else {
31039 return []byte("\"" + self.GetOXMName() + "\""), nil
31040 }
31041}
31042
31043type OxmIdSctpDst struct {
31044 *OxmId
31045}
31046
31047type IOxmIdSctpDst interface {
31048 IOxmId
31049}
31050
31051func (self *OxmIdSctpDst) Serialize(encoder *goloxi.Encoder) error {
31052 if err := self.OxmId.Serialize(encoder); err != nil {
31053 return err
31054 }
31055
31056 return nil
31057}
31058
31059func DecodeOxmIdSctpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpDst, error) {
31060 _oxmidsctpdst := &OxmIdSctpDst{OxmId: parent}
31061 return _oxmidsctpdst, nil
31062}
31063
31064func NewOxmIdSctpDst() *OxmIdSctpDst {
31065 obj := &OxmIdSctpDst{
31066 OxmId: NewOxmId(2147492866),
31067 }
31068 return obj
31069}
31070func (self *OxmIdSctpDst) GetOXMName() string {
31071 return "sctp_dst"
31072}
31073
31074func (self *OxmIdSctpDst) MarshalJSON() ([]byte, error) {
31075 if self.TypeLen == 0 {
31076 return []byte("\"\""), nil
31077 } else {
31078 return []byte("\"" + self.GetOXMName() + "\""), nil
31079 }
31080}
31081
31082type OxmIdSctpDstMasked struct {
31083 *OxmId
31084}
31085
31086type IOxmIdSctpDstMasked interface {
31087 IOxmId
31088}
31089
31090func (self *OxmIdSctpDstMasked) Serialize(encoder *goloxi.Encoder) error {
31091 if err := self.OxmId.Serialize(encoder); err != nil {
31092 return err
31093 }
31094
31095 return nil
31096}
31097
31098func DecodeOxmIdSctpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpDstMasked, error) {
31099 _oxmidsctpdstmasked := &OxmIdSctpDstMasked{OxmId: parent}
31100 return _oxmidsctpdstmasked, nil
31101}
31102
31103func NewOxmIdSctpDstMasked() *OxmIdSctpDstMasked {
31104 obj := &OxmIdSctpDstMasked{
31105 OxmId: NewOxmId(2147493124),
31106 }
31107 return obj
31108}
31109func (self *OxmIdSctpDstMasked) GetOXMName() string {
31110 return "sctp_dst_masked"
31111}
31112
31113func (self *OxmIdSctpDstMasked) MarshalJSON() ([]byte, error) {
31114 if self.TypeLen == 0 {
31115 return []byte("\"\""), nil
31116 } else {
31117 return []byte("\"" + self.GetOXMName() + "\""), nil
31118 }
31119}
31120
31121type OxmIdSctpSrc struct {
31122 *OxmId
31123}
31124
31125type IOxmIdSctpSrc interface {
31126 IOxmId
31127}
31128
31129func (self *OxmIdSctpSrc) Serialize(encoder *goloxi.Encoder) error {
31130 if err := self.OxmId.Serialize(encoder); err != nil {
31131 return err
31132 }
31133
31134 return nil
31135}
31136
31137func DecodeOxmIdSctpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpSrc, error) {
31138 _oxmidsctpsrc := &OxmIdSctpSrc{OxmId: parent}
31139 return _oxmidsctpsrc, nil
31140}
31141
31142func NewOxmIdSctpSrc() *OxmIdSctpSrc {
31143 obj := &OxmIdSctpSrc{
31144 OxmId: NewOxmId(2147492354),
31145 }
31146 return obj
31147}
31148func (self *OxmIdSctpSrc) GetOXMName() string {
31149 return "sctp_src"
31150}
31151
31152func (self *OxmIdSctpSrc) MarshalJSON() ([]byte, error) {
31153 if self.TypeLen == 0 {
31154 return []byte("\"\""), nil
31155 } else {
31156 return []byte("\"" + self.GetOXMName() + "\""), nil
31157 }
31158}
31159
31160type OxmIdSctpSrcMasked struct {
31161 *OxmId
31162}
31163
31164type IOxmIdSctpSrcMasked interface {
31165 IOxmId
31166}
31167
31168func (self *OxmIdSctpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
31169 if err := self.OxmId.Serialize(encoder); err != nil {
31170 return err
31171 }
31172
31173 return nil
31174}
31175
31176func DecodeOxmIdSctpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpSrcMasked, error) {
31177 _oxmidsctpsrcmasked := &OxmIdSctpSrcMasked{OxmId: parent}
31178 return _oxmidsctpsrcmasked, nil
31179}
31180
31181func NewOxmIdSctpSrcMasked() *OxmIdSctpSrcMasked {
31182 obj := &OxmIdSctpSrcMasked{
31183 OxmId: NewOxmId(2147492612),
31184 }
31185 return obj
31186}
31187func (self *OxmIdSctpSrcMasked) GetOXMName() string {
31188 return "sctp_src_masked"
31189}
31190
31191func (self *OxmIdSctpSrcMasked) MarshalJSON() ([]byte, error) {
31192 if self.TypeLen == 0 {
31193 return []byte("\"\""), nil
31194 } else {
31195 return []byte("\"" + self.GetOXMName() + "\""), nil
31196 }
31197}
31198
31199type OxmIdTunnelId struct {
31200 *OxmId
31201}
31202
31203type IOxmIdTunnelId interface {
31204 IOxmId
31205}
31206
31207func (self *OxmIdTunnelId) Serialize(encoder *goloxi.Encoder) error {
31208 if err := self.OxmId.Serialize(encoder); err != nil {
31209 return err
31210 }
31211
31212 return nil
31213}
31214
31215func DecodeOxmIdTunnelId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelId, error) {
31216 _oxmidtunnelid := &OxmIdTunnelId{OxmId: parent}
31217 return _oxmidtunnelid, nil
31218}
31219
31220func NewOxmIdTunnelId() *OxmIdTunnelId {
31221 obj := &OxmIdTunnelId{
31222 OxmId: NewOxmId(2147503112),
31223 }
31224 return obj
31225}
31226func (self *OxmIdTunnelId) GetOXMName() string {
31227 return "tunnel_id"
31228}
31229
31230func (self *OxmIdTunnelId) MarshalJSON() ([]byte, error) {
31231 if self.TypeLen == 0 {
31232 return []byte("\"\""), nil
31233 } else {
31234 return []byte("\"" + self.GetOXMName() + "\""), nil
31235 }
31236}
31237
31238type OxmIdTunnelIdMasked struct {
31239 *OxmId
31240}
31241
31242type IOxmIdTunnelIdMasked interface {
31243 IOxmId
31244}
31245
31246func (self *OxmIdTunnelIdMasked) Serialize(encoder *goloxi.Encoder) error {
31247 if err := self.OxmId.Serialize(encoder); err != nil {
31248 return err
31249 }
31250
31251 return nil
31252}
31253
31254func DecodeOxmIdTunnelIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelIdMasked, error) {
31255 _oxmidtunnelidmasked := &OxmIdTunnelIdMasked{OxmId: parent}
31256 return _oxmidtunnelidmasked, nil
31257}
31258
31259func NewOxmIdTunnelIdMasked() *OxmIdTunnelIdMasked {
31260 obj := &OxmIdTunnelIdMasked{
31261 OxmId: NewOxmId(2147503376),
31262 }
31263 return obj
31264}
31265func (self *OxmIdTunnelIdMasked) GetOXMName() string {
31266 return "tunnel_id_masked"
31267}
31268
31269func (self *OxmIdTunnelIdMasked) MarshalJSON() ([]byte, error) {
31270 if self.TypeLen == 0 {
31271 return []byte("\"\""), nil
31272 } else {
31273 return []byte("\"" + self.GetOXMName() + "\""), nil
31274 }
31275}
31276
31277type OxmIdTunnelIpv4Dst struct {
31278 *OxmId
31279}
31280
31281type IOxmIdTunnelIpv4Dst interface {
31282 IOxmId
31283}
31284
31285func (self *OxmIdTunnelIpv4Dst) Serialize(encoder *goloxi.Encoder) error {
31286 if err := self.OxmId.Serialize(encoder); err != nil {
31287 return err
31288 }
31289
31290 return nil
31291}
31292
31293func DecodeOxmIdTunnelIpv4Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelIpv4Dst, error) {
31294 _oxmidtunnelipv4dst := &OxmIdTunnelIpv4Dst{OxmId: parent}
31295 return _oxmidtunnelipv4dst, nil
31296}
31297
31298func NewOxmIdTunnelIpv4Dst() *OxmIdTunnelIpv4Dst {
31299 obj := &OxmIdTunnelIpv4Dst{
31300 OxmId: NewOxmId(81924),
31301 }
31302 return obj
31303}
31304func (self *OxmIdTunnelIpv4Dst) GetOXMName() string {
31305 return "tunnel_ipv4_dst"
31306}
31307
31308func (self *OxmIdTunnelIpv4Dst) MarshalJSON() ([]byte, error) {
31309 if self.TypeLen == 0 {
31310 return []byte("\"\""), nil
31311 } else {
31312 return []byte("\"" + self.GetOXMName() + "\""), nil
31313 }
31314}
31315
31316type OxmIdTunnelIpv4DstMasked struct {
31317 *OxmId
31318}
31319
31320type IOxmIdTunnelIpv4DstMasked interface {
31321 IOxmId
31322}
31323
31324func (self *OxmIdTunnelIpv4DstMasked) Serialize(encoder *goloxi.Encoder) error {
31325 if err := self.OxmId.Serialize(encoder); err != nil {
31326 return err
31327 }
31328
31329 return nil
31330}
31331
31332func DecodeOxmIdTunnelIpv4DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelIpv4DstMasked, error) {
31333 _oxmidtunnelipv4dstmasked := &OxmIdTunnelIpv4DstMasked{OxmId: parent}
31334 return _oxmidtunnelipv4dstmasked, nil
31335}
31336
31337func NewOxmIdTunnelIpv4DstMasked() *OxmIdTunnelIpv4DstMasked {
31338 obj := &OxmIdTunnelIpv4DstMasked{
31339 OxmId: NewOxmId(82184),
31340 }
31341 return obj
31342}
31343func (self *OxmIdTunnelIpv4DstMasked) GetOXMName() string {
31344 return "tunnel_ipv4_dst_masked"
31345}
31346
31347func (self *OxmIdTunnelIpv4DstMasked) MarshalJSON() ([]byte, error) {
31348 if self.TypeLen == 0 {
31349 return []byte("\"\""), nil
31350 } else {
31351 return []byte("\"" + self.GetOXMName() + "\""), nil
31352 }
31353}
31354
31355type OxmIdTunnelIpv4Src struct {
31356 *OxmId
31357}
31358
31359type IOxmIdTunnelIpv4Src interface {
31360 IOxmId
31361}
31362
31363func (self *OxmIdTunnelIpv4Src) Serialize(encoder *goloxi.Encoder) error {
31364 if err := self.OxmId.Serialize(encoder); err != nil {
31365 return err
31366 }
31367
31368 return nil
31369}
31370
31371func DecodeOxmIdTunnelIpv4Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelIpv4Src, error) {
31372 _oxmidtunnelipv4src := &OxmIdTunnelIpv4Src{OxmId: parent}
31373 return _oxmidtunnelipv4src, nil
31374}
31375
31376func NewOxmIdTunnelIpv4Src() *OxmIdTunnelIpv4Src {
31377 obj := &OxmIdTunnelIpv4Src{
31378 OxmId: NewOxmId(81412),
31379 }
31380 return obj
31381}
31382func (self *OxmIdTunnelIpv4Src) GetOXMName() string {
31383 return "tunnel_ipv4_src"
31384}
31385
31386func (self *OxmIdTunnelIpv4Src) MarshalJSON() ([]byte, error) {
31387 if self.TypeLen == 0 {
31388 return []byte("\"\""), nil
31389 } else {
31390 return []byte("\"" + self.GetOXMName() + "\""), nil
31391 }
31392}
31393
31394type OxmIdTunnelIpv4SrcMasked struct {
31395 *OxmId
31396}
31397
31398type IOxmIdTunnelIpv4SrcMasked interface {
31399 IOxmId
31400}
31401
31402func (self *OxmIdTunnelIpv4SrcMasked) Serialize(encoder *goloxi.Encoder) error {
31403 if err := self.OxmId.Serialize(encoder); err != nil {
31404 return err
31405 }
31406
31407 return nil
31408}
31409
31410func DecodeOxmIdTunnelIpv4SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelIpv4SrcMasked, error) {
31411 _oxmidtunnelipv4srcmasked := &OxmIdTunnelIpv4SrcMasked{OxmId: parent}
31412 return _oxmidtunnelipv4srcmasked, nil
31413}
31414
31415func NewOxmIdTunnelIpv4SrcMasked() *OxmIdTunnelIpv4SrcMasked {
31416 obj := &OxmIdTunnelIpv4SrcMasked{
31417 OxmId: NewOxmId(81672),
31418 }
31419 return obj
31420}
31421func (self *OxmIdTunnelIpv4SrcMasked) GetOXMName() string {
31422 return "tunnel_ipv4_src_masked"
31423}
31424
31425func (self *OxmIdTunnelIpv4SrcMasked) MarshalJSON() ([]byte, error) {
31426 if self.TypeLen == 0 {
31427 return []byte("\"\""), nil
31428 } else {
31429 return []byte("\"" + self.GetOXMName() + "\""), nil
31430 }
31431}
31432
31433type OxmIdVlanPcp struct {
31434 *OxmId
31435}
31436
31437type IOxmIdVlanPcp interface {
31438 IOxmId
31439}
31440
31441func (self *OxmIdVlanPcp) Serialize(encoder *goloxi.Encoder) error {
31442 if err := self.OxmId.Serialize(encoder); err != nil {
31443 return err
31444 }
31445
31446 return nil
31447}
31448
31449func DecodeOxmIdVlanPcp(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanPcp, error) {
31450 _oxmidvlanpcp := &OxmIdVlanPcp{OxmId: parent}
31451 return _oxmidvlanpcp, nil
31452}
31453
31454func NewOxmIdVlanPcp() *OxmIdVlanPcp {
31455 obj := &OxmIdVlanPcp{
31456 OxmId: NewOxmId(2147487233),
31457 }
31458 return obj
31459}
31460func (self *OxmIdVlanPcp) GetOXMName() string {
31461 return "vlan_pcp"
31462}
31463
31464func (self *OxmIdVlanPcp) MarshalJSON() ([]byte, error) {
31465 if self.TypeLen == 0 {
31466 return []byte("\"\""), nil
31467 } else {
31468 return []byte("\"" + self.GetOXMName() + "\""), nil
31469 }
31470}
31471
31472type OxmIdVlanPcpMasked struct {
31473 *OxmId
31474}
31475
31476type IOxmIdVlanPcpMasked interface {
31477 IOxmId
31478}
31479
31480func (self *OxmIdVlanPcpMasked) Serialize(encoder *goloxi.Encoder) error {
31481 if err := self.OxmId.Serialize(encoder); err != nil {
31482 return err
31483 }
31484
31485 return nil
31486}
31487
31488func DecodeOxmIdVlanPcpMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanPcpMasked, error) {
31489 _oxmidvlanpcpmasked := &OxmIdVlanPcpMasked{OxmId: parent}
31490 return _oxmidvlanpcpmasked, nil
31491}
31492
31493func NewOxmIdVlanPcpMasked() *OxmIdVlanPcpMasked {
31494 obj := &OxmIdVlanPcpMasked{
31495 OxmId: NewOxmId(2147487490),
31496 }
31497 return obj
31498}
31499func (self *OxmIdVlanPcpMasked) GetOXMName() string {
31500 return "vlan_pcp_masked"
31501}
31502
31503func (self *OxmIdVlanPcpMasked) MarshalJSON() ([]byte, error) {
31504 if self.TypeLen == 0 {
31505 return []byte("\"\""), nil
31506 } else {
31507 return []byte("\"" + self.GetOXMName() + "\""), nil
31508 }
31509}
31510
31511type OxmIdVlanVid struct {
31512 *OxmId
31513}
31514
31515type IOxmIdVlanVid interface {
31516 IOxmId
31517}
31518
31519func (self *OxmIdVlanVid) Serialize(encoder *goloxi.Encoder) error {
31520 if err := self.OxmId.Serialize(encoder); err != nil {
31521 return err
31522 }
31523
31524 return nil
31525}
31526
31527func DecodeOxmIdVlanVid(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanVid, error) {
31528 _oxmidvlanvid := &OxmIdVlanVid{OxmId: parent}
31529 return _oxmidvlanvid, nil
31530}
31531
31532func NewOxmIdVlanVid() *OxmIdVlanVid {
31533 obj := &OxmIdVlanVid{
31534 OxmId: NewOxmId(2147486722),
31535 }
31536 return obj
31537}
31538func (self *OxmIdVlanVid) GetOXMName() string {
31539 return "vlan_vid"
31540}
31541
31542func (self *OxmIdVlanVid) MarshalJSON() ([]byte, error) {
31543 if self.TypeLen == 0 {
31544 return []byte("\"\""), nil
31545 } else {
31546 return []byte("\"" + self.GetOXMName() + "\""), nil
31547 }
31548}
31549
31550type OxmIdVlanVidMasked struct {
31551 *OxmId
31552}
31553
31554type IOxmIdVlanVidMasked interface {
31555 IOxmId
31556}
31557
31558func (self *OxmIdVlanVidMasked) Serialize(encoder *goloxi.Encoder) error {
31559 if err := self.OxmId.Serialize(encoder); err != nil {
31560 return err
31561 }
31562
31563 return nil
31564}
31565
31566func DecodeOxmIdVlanVidMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanVidMasked, error) {
31567 _oxmidvlanvidmasked := &OxmIdVlanVidMasked{OxmId: parent}
31568 return _oxmidvlanvidmasked, nil
31569}
31570
31571func NewOxmIdVlanVidMasked() *OxmIdVlanVidMasked {
31572 obj := &OxmIdVlanVidMasked{
31573 OxmId: NewOxmId(2147486980),
31574 }
31575 return obj
31576}
31577func (self *OxmIdVlanVidMasked) GetOXMName() string {
31578 return "vlan_vid_masked"
31579}
31580
31581func (self *OxmIdVlanVidMasked) MarshalJSON() ([]byte, error) {
31582 if self.TypeLen == 0 {
31583 return []byte("\"\""), nil
31584 } else {
31585 return []byte("\"" + self.GetOXMName() + "\""), nil
31586 }
31587}
31588
31589type PacketQueue struct {
31590 QueueId uint32
31591 Port Port
31592 Len uint16
31593 Properties []IQueueProp
31594}
31595
31596type IPacketQueue interface {
31597 goloxi.Serializable
31598 GetQueueId() uint32
31599 GetPort() Port
31600 GetLen() uint16
31601 GetProperties() []IQueueProp
31602}
31603
31604func (self *PacketQueue) GetQueueId() uint32 {
31605 return self.QueueId
31606}
31607
31608func (self *PacketQueue) SetQueueId(v uint32) {
31609 self.QueueId = v
31610}
31611
31612func (self *PacketQueue) GetPort() Port {
31613 return self.Port
31614}
31615
31616func (self *PacketQueue) SetPort(v Port) {
31617 self.Port = v
31618}
31619
31620func (self *PacketQueue) GetLen() uint16 {
31621 return self.Len
31622}
31623
31624func (self *PacketQueue) SetLen(v uint16) {
31625 self.Len = v
31626}
31627
31628func (self *PacketQueue) GetProperties() []IQueueProp {
31629 return self.Properties
31630}
31631
31632func (self *PacketQueue) SetProperties(v []IQueueProp) {
31633 self.Properties = v
31634}
31635
31636func (self *PacketQueue) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]31637 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]31638
31639 encoder.PutUint32(uint32(self.QueueId))
31640 self.Port.Serialize(encoder)
31641 encoder.PutUint16(uint16(self.Len))
31642 encoder.Write(bytes.Repeat([]byte{0}, 6))
31643 for _, obj := range self.Properties {
31644 if err := obj.Serialize(encoder); err != nil {
31645 return err
31646 }
31647 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]31648 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]31649
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]31650 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+8:startIndex+10], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]31651
31652 return nil
31653}
31654
31655func DecodePacketQueue(decoder *goloxi.Decoder) (*PacketQueue, error) {
31656 _packetqueue := &PacketQueue{}
31657 if decoder.Length() < 16 {
31658 return nil, fmt.Errorf("PacketQueue packet too short: %d < 16", decoder.Length())
31659 }
31660 _packetqueue.QueueId = uint32(decoder.ReadUint32())
31661 _packetqueue.Port.Decode(decoder)
31662 _packetqueue.Len = uint16(decoder.ReadUint16())
31663 oldDecoder := decoder
31664 defer func() { decoder = oldDecoder }()
31665 decoder = decoder.SliceDecoder(int(_packetqueue.Len), 2+8)
31666 decoder.Skip(6)
31667
31668 for decoder.Length() >= 8 {
31669 item, err := DecodeQueueProp(decoder)
31670 if err != nil {
31671 return nil, err
31672 }
31673 if item != nil {
31674 _packetqueue.Properties = append(_packetqueue.Properties, item)
31675 }
31676 }
31677 return _packetqueue, nil
31678}
31679
31680func NewPacketQueue() *PacketQueue {
31681 obj := &PacketQueue{}
31682 return obj
31683}
31684
31685type PortDesc struct {
31686 PortNo Port
31687 HwAddr net.HardwareAddr
31688 Name string
31689 Config PortConfig
31690 State PortState
31691 Curr PortFeatures
31692 Advertised PortFeatures
31693 Supported PortFeatures
31694 Peer PortFeatures
31695 CurrSpeed uint32
31696 MaxSpeed uint32
31697}
31698
31699type IPortDesc interface {
31700 goloxi.Serializable
31701 GetPortNo() Port
31702 GetHwAddr() net.HardwareAddr
31703 GetName() string
31704 GetConfig() PortConfig
31705 GetState() PortState
31706 GetCurr() PortFeatures
31707 GetAdvertised() PortFeatures
31708 GetSupported() PortFeatures
31709 GetPeer() PortFeatures
31710 GetCurrSpeed() uint32
31711 GetMaxSpeed() uint32
31712}
31713
31714func (self *PortDesc) GetPortNo() Port {
31715 return self.PortNo
31716}
31717
31718func (self *PortDesc) SetPortNo(v Port) {
31719 self.PortNo = v
31720}
31721
31722func (self *PortDesc) GetHwAddr() net.HardwareAddr {
31723 return self.HwAddr
31724}
31725
31726func (self *PortDesc) SetHwAddr(v net.HardwareAddr) {
31727 self.HwAddr = v
31728}
31729
31730func (self *PortDesc) GetName() string {
31731 return self.Name
31732}
31733
31734func (self *PortDesc) SetName(v string) {
31735 self.Name = v
31736}
31737
31738func (self *PortDesc) GetConfig() PortConfig {
31739 return self.Config
31740}
31741
31742func (self *PortDesc) SetConfig(v PortConfig) {
31743 self.Config = v
31744}
31745
31746func (self *PortDesc) GetState() PortState {
31747 return self.State
31748}
31749
31750func (self *PortDesc) SetState(v PortState) {
31751 self.State = v
31752}
31753
31754func (self *PortDesc) GetCurr() PortFeatures {
31755 return self.Curr
31756}
31757
31758func (self *PortDesc) SetCurr(v PortFeatures) {
31759 self.Curr = v
31760}
31761
31762func (self *PortDesc) GetAdvertised() PortFeatures {
31763 return self.Advertised
31764}
31765
31766func (self *PortDesc) SetAdvertised(v PortFeatures) {
31767 self.Advertised = v
31768}
31769
31770func (self *PortDesc) GetSupported() PortFeatures {
31771 return self.Supported
31772}
31773
31774func (self *PortDesc) SetSupported(v PortFeatures) {
31775 self.Supported = v
31776}
31777
31778func (self *PortDesc) GetPeer() PortFeatures {
31779 return self.Peer
31780}
31781
31782func (self *PortDesc) SetPeer(v PortFeatures) {
31783 self.Peer = v
31784}
31785
31786func (self *PortDesc) GetCurrSpeed() uint32 {
31787 return self.CurrSpeed
31788}
31789
31790func (self *PortDesc) SetCurrSpeed(v uint32) {
31791 self.CurrSpeed = v
31792}
31793
31794func (self *PortDesc) GetMaxSpeed() uint32 {
31795 return self.MaxSpeed
31796}
31797
31798func (self *PortDesc) SetMaxSpeed(v uint32) {
31799 self.MaxSpeed = v
31800}
31801
31802func (self *PortDesc) Serialize(encoder *goloxi.Encoder) error {
31803
31804 self.PortNo.Serialize(encoder)
31805 encoder.Write(bytes.Repeat([]byte{0}, 4))
31806 encoder.Write(self.HwAddr)
31807 encoder.Write(bytes.Repeat([]byte{0}, 2))
31808 encoder.Write([]byte(self.Name))
31809 encoder.PutUint32(uint32(self.Config))
31810 encoder.PutUint32(uint32(self.State))
31811 encoder.PutUint32(uint32(self.Curr))
31812 encoder.PutUint32(uint32(self.Advertised))
31813 encoder.PutUint32(uint32(self.Supported))
31814 encoder.PutUint32(uint32(self.Peer))
31815 encoder.PutUint32(uint32(self.CurrSpeed))
31816 encoder.PutUint32(uint32(self.MaxSpeed))
31817
31818 return nil
31819}
31820func (self *PortDesc) Decode(decoder *goloxi.Decoder) error {
31821 if decoder.Length() < 64 {
31822 return fmt.Errorf("PortDesc packet too short: %d < 64", decoder.Length())
31823 }
31824
31825 self.PortNo.Decode(decoder)
31826 decoder.Skip(4)
31827 self.HwAddr = net.HardwareAddr(decoder.Read(6))
31828 decoder.Skip(2)
31829 self.Name = string(bytes.Trim(decoder.Read(16), "\x00"))
31830 self.Config = PortConfig(decoder.ReadUint32())
31831 self.State = PortState(decoder.ReadUint32())
31832 self.Curr = PortFeatures(decoder.ReadUint32())
31833 self.Advertised = PortFeatures(decoder.ReadUint32())
31834 self.Supported = PortFeatures(decoder.ReadUint32())
31835 self.Peer = PortFeatures(decoder.ReadUint32())
31836 self.CurrSpeed = uint32(decoder.ReadUint32())
31837 self.MaxSpeed = uint32(decoder.ReadUint32())
31838
31839 return nil
31840}
31841
31842func NewPortDesc() *PortDesc {
31843 obj := &PortDesc{}
31844 return obj
31845}
31846
31847type PortStatsEntry struct {
31848 PortNo Port
31849 RxPackets uint64
31850 TxPackets uint64
31851 RxBytes uint64
31852 TxBytes uint64
31853 RxDropped uint64
31854 TxDropped uint64
31855 RxErrors uint64
31856 TxErrors uint64
31857 RxFrameErr uint64
31858 RxOverErr uint64
31859 RxCrcErr uint64
31860 Collisions uint64
31861 DurationSec uint32
31862 DurationNsec uint32
31863}
31864
31865type IPortStatsEntry interface {
31866 goloxi.Serializable
31867 GetPortNo() Port
31868 GetRxPackets() uint64
31869 GetTxPackets() uint64
31870 GetRxBytes() uint64
31871 GetTxBytes() uint64
31872 GetRxDropped() uint64
31873 GetTxDropped() uint64
31874 GetRxErrors() uint64
31875 GetTxErrors() uint64
31876 GetRxFrameErr() uint64
31877 GetRxOverErr() uint64
31878 GetRxCrcErr() uint64
31879 GetCollisions() uint64
31880 GetDurationSec() uint32
31881 GetDurationNsec() uint32
31882}
31883
31884func (self *PortStatsEntry) GetPortNo() Port {
31885 return self.PortNo
31886}
31887
31888func (self *PortStatsEntry) SetPortNo(v Port) {
31889 self.PortNo = v
31890}
31891
31892func (self *PortStatsEntry) GetRxPackets() uint64 {
31893 return self.RxPackets
31894}
31895
31896func (self *PortStatsEntry) SetRxPackets(v uint64) {
31897 self.RxPackets = v
31898}
31899
31900func (self *PortStatsEntry) GetTxPackets() uint64 {
31901 return self.TxPackets
31902}
31903
31904func (self *PortStatsEntry) SetTxPackets(v uint64) {
31905 self.TxPackets = v
31906}
31907
31908func (self *PortStatsEntry) GetRxBytes() uint64 {
31909 return self.RxBytes
31910}
31911
31912func (self *PortStatsEntry) SetRxBytes(v uint64) {
31913 self.RxBytes = v
31914}
31915
31916func (self *PortStatsEntry) GetTxBytes() uint64 {
31917 return self.TxBytes
31918}
31919
31920func (self *PortStatsEntry) SetTxBytes(v uint64) {
31921 self.TxBytes = v
31922}
31923
31924func (self *PortStatsEntry) GetRxDropped() uint64 {
31925 return self.RxDropped
31926}
31927
31928func (self *PortStatsEntry) SetRxDropped(v uint64) {
31929 self.RxDropped = v
31930}
31931
31932func (self *PortStatsEntry) GetTxDropped() uint64 {
31933 return self.TxDropped
31934}
31935
31936func (self *PortStatsEntry) SetTxDropped(v uint64) {
31937 self.TxDropped = v
31938}
31939
31940func (self *PortStatsEntry) GetRxErrors() uint64 {
31941 return self.RxErrors
31942}
31943
31944func (self *PortStatsEntry) SetRxErrors(v uint64) {
31945 self.RxErrors = v
31946}
31947
31948func (self *PortStatsEntry) GetTxErrors() uint64 {
31949 return self.TxErrors
31950}
31951
31952func (self *PortStatsEntry) SetTxErrors(v uint64) {
31953 self.TxErrors = v
31954}
31955
31956func (self *PortStatsEntry) GetRxFrameErr() uint64 {
31957 return self.RxFrameErr
31958}
31959
31960func (self *PortStatsEntry) SetRxFrameErr(v uint64) {
31961 self.RxFrameErr = v
31962}
31963
31964func (self *PortStatsEntry) GetRxOverErr() uint64 {
31965 return self.RxOverErr
31966}
31967
31968func (self *PortStatsEntry) SetRxOverErr(v uint64) {
31969 self.RxOverErr = v
31970}
31971
31972func (self *PortStatsEntry) GetRxCrcErr() uint64 {
31973 return self.RxCrcErr
31974}
31975
31976func (self *PortStatsEntry) SetRxCrcErr(v uint64) {
31977 self.RxCrcErr = v
31978}
31979
31980func (self *PortStatsEntry) GetCollisions() uint64 {
31981 return self.Collisions
31982}
31983
31984func (self *PortStatsEntry) SetCollisions(v uint64) {
31985 self.Collisions = v
31986}
31987
31988func (self *PortStatsEntry) GetDurationSec() uint32 {
31989 return self.DurationSec
31990}
31991
31992func (self *PortStatsEntry) SetDurationSec(v uint32) {
31993 self.DurationSec = v
31994}
31995
31996func (self *PortStatsEntry) GetDurationNsec() uint32 {
31997 return self.DurationNsec
31998}
31999
32000func (self *PortStatsEntry) SetDurationNsec(v uint32) {
32001 self.DurationNsec = v
32002}
32003
32004func (self *PortStatsEntry) Serialize(encoder *goloxi.Encoder) error {
32005
32006 self.PortNo.Serialize(encoder)
32007 encoder.Write(bytes.Repeat([]byte{0}, 4))
32008 encoder.PutUint64(uint64(self.RxPackets))
32009 encoder.PutUint64(uint64(self.TxPackets))
32010 encoder.PutUint64(uint64(self.RxBytes))
32011 encoder.PutUint64(uint64(self.TxBytes))
32012 encoder.PutUint64(uint64(self.RxDropped))
32013 encoder.PutUint64(uint64(self.TxDropped))
32014 encoder.PutUint64(uint64(self.RxErrors))
32015 encoder.PutUint64(uint64(self.TxErrors))
32016 encoder.PutUint64(uint64(self.RxFrameErr))
32017 encoder.PutUint64(uint64(self.RxOverErr))
32018 encoder.PutUint64(uint64(self.RxCrcErr))
32019 encoder.PutUint64(uint64(self.Collisions))
32020 encoder.PutUint32(uint32(self.DurationSec))
32021 encoder.PutUint32(uint32(self.DurationNsec))
32022
32023 return nil
32024}
32025
32026func DecodePortStatsEntry(decoder *goloxi.Decoder) (*PortStatsEntry, error) {
32027 _portstatsentry := &PortStatsEntry{}
32028 if decoder.Length() < 112 {
32029 return nil, fmt.Errorf("PortStatsEntry packet too short: %d < 112", decoder.Length())
32030 }
32031 _portstatsentry.PortNo.Decode(decoder)
32032 decoder.Skip(4)
32033 _portstatsentry.RxPackets = uint64(decoder.ReadUint64())
32034 _portstatsentry.TxPackets = uint64(decoder.ReadUint64())
32035 _portstatsentry.RxBytes = uint64(decoder.ReadUint64())
32036 _portstatsentry.TxBytes = uint64(decoder.ReadUint64())
32037 _portstatsentry.RxDropped = uint64(decoder.ReadUint64())
32038 _portstatsentry.TxDropped = uint64(decoder.ReadUint64())
32039 _portstatsentry.RxErrors = uint64(decoder.ReadUint64())
32040 _portstatsentry.TxErrors = uint64(decoder.ReadUint64())
32041 _portstatsentry.RxFrameErr = uint64(decoder.ReadUint64())
32042 _portstatsentry.RxOverErr = uint64(decoder.ReadUint64())
32043 _portstatsentry.RxCrcErr = uint64(decoder.ReadUint64())
32044 _portstatsentry.Collisions = uint64(decoder.ReadUint64())
32045 _portstatsentry.DurationSec = uint32(decoder.ReadUint32())
32046 _portstatsentry.DurationNsec = uint32(decoder.ReadUint32())
32047 return _portstatsentry, nil
32048}
32049
32050func NewPortStatsEntry() *PortStatsEntry {
32051 obj := &PortStatsEntry{}
32052 return obj
32053}
32054
32055type QueueProp struct {
32056 Type uint16
32057 Len uint16
32058}
32059
32060type IQueueProp interface {
32061 goloxi.Serializable
32062 GetType() uint16
32063 GetLen() uint16
32064}
32065
32066func (self *QueueProp) GetType() uint16 {
32067 return self.Type
32068}
32069
32070func (self *QueueProp) SetType(v uint16) {
32071 self.Type = v
32072}
32073
32074func (self *QueueProp) GetLen() uint16 {
32075 return self.Len
32076}
32077
32078func (self *QueueProp) SetLen(v uint16) {
32079 self.Len = v
32080}
32081
32082func (self *QueueProp) Serialize(encoder *goloxi.Encoder) error {
32083
32084 encoder.PutUint16(uint16(self.Type))
32085 encoder.PutUint16(uint16(self.Len))
32086
32087 return nil
32088}
32089
32090func DecodeQueueProp(decoder *goloxi.Decoder) (IQueueProp, error) {
32091 _queueprop := &QueueProp{}
32092 if decoder.Length() < 4 {
32093 return nil, fmt.Errorf("QueueProp packet too short: %d < 4", decoder.Length())
32094 }
32095 _queueprop.Type = uint16(decoder.ReadUint16())
32096 _queueprop.Len = uint16(decoder.ReadUint16())
32097 oldDecoder := decoder
32098 defer func() { decoder = oldDecoder }()
32099 decoder = decoder.SliceDecoder(int(_queueprop.Len), 2+2)
32100
32101 switch _queueprop.Type {
32102 case 1:
32103 return DecodeQueuePropMinRate(_queueprop, decoder)
32104 case 2:
32105 return DecodeQueuePropMaxRate(_queueprop, decoder)
32106 case 65535:
32107 return DecodeQueuePropExperimenter(_queueprop, decoder)
32108 default:
32109 return nil, fmt.Errorf("Invalid type '%d' for 'QueueProp'", _queueprop.Type)
32110 }
32111}
32112
32113func NewQueueProp(_type uint16) *QueueProp {
32114 obj := &QueueProp{}
32115 obj.Type = _type
32116 return obj
32117}
32118
32119type QueuePropExperimenter struct {
32120 *QueueProp
32121 Experimenter uint32
32122}
32123
32124type IQueuePropExperimenter interface {
32125 IQueueProp
32126 GetExperimenter() uint32
32127}
32128
32129func (self *QueuePropExperimenter) GetExperimenter() uint32 {
32130 return self.Experimenter
32131}
32132
32133func (self *QueuePropExperimenter) SetExperimenter(v uint32) {
32134 self.Experimenter = v
32135}
32136
32137func (self *QueuePropExperimenter) Serialize(encoder *goloxi.Encoder) error {
32138 if err := self.QueueProp.Serialize(encoder); err != nil {
32139 return err
32140 }
32141
32142 encoder.Write(bytes.Repeat([]byte{0}, 4))
32143 encoder.PutUint32(uint32(self.Experimenter))
32144 encoder.Write(bytes.Repeat([]byte{0}, 4))
32145
32146 return nil
32147}
32148
32149func DecodeQueuePropExperimenter(parent *QueueProp, decoder *goloxi.Decoder) (IQueuePropExperimenter, error) {
32150 _queuepropexperimenter := &QueuePropExperimenter{QueueProp: parent}
32151 if decoder.Length() < 4 {
32152 return nil, fmt.Errorf("QueuePropExperimenter packet too short: %d < 4", decoder.Length())
32153 }
32154 decoder.Skip(4)
32155 _queuepropexperimenter.Experimenter = uint32(decoder.ReadUint32())
32156 decoder.Skip(4)
32157 return _queuepropexperimenter, nil
32158}
32159
32160func NewQueuePropExperimenter(_experimenter uint32) *QueuePropExperimenter {
32161 obj := &QueuePropExperimenter{
32162 QueueProp: NewQueueProp(65535),
32163 }
32164 obj.Experimenter = _experimenter
32165 return obj
32166}
32167
32168type QueuePropMaxRate struct {
32169 *QueueProp
32170 Rate uint16
32171}
32172
32173type IQueuePropMaxRate interface {
32174 IQueueProp
32175 GetRate() uint16
32176}
32177
32178func (self *QueuePropMaxRate) GetRate() uint16 {
32179 return self.Rate
32180}
32181
32182func (self *QueuePropMaxRate) SetRate(v uint16) {
32183 self.Rate = v
32184}
32185
32186func (self *QueuePropMaxRate) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]32187 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]32188 if err := self.QueueProp.Serialize(encoder); err != nil {
32189 return err
32190 }
32191
32192 encoder.Write(bytes.Repeat([]byte{0}, 4))
32193 encoder.PutUint16(uint16(self.Rate))
32194 encoder.Write(bytes.Repeat([]byte{0}, 6))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]32195 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]32196
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]32197 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]32198
32199 return nil
32200}
32201
32202func DecodeQueuePropMaxRate(parent *QueueProp, decoder *goloxi.Decoder) (*QueuePropMaxRate, error) {
32203 _queuepropmaxrate := &QueuePropMaxRate{QueueProp: parent}
32204 if decoder.Length() < 12 {
32205 return nil, fmt.Errorf("QueuePropMaxRate packet too short: %d < 12", decoder.Length())
32206 }
32207 decoder.Skip(4)
32208 _queuepropmaxrate.Rate = uint16(decoder.ReadUint16())
32209 decoder.Skip(6)
32210 return _queuepropmaxrate, nil
32211}
32212
32213func NewQueuePropMaxRate() *QueuePropMaxRate {
32214 obj := &QueuePropMaxRate{
32215 QueueProp: NewQueueProp(2),
32216 }
32217 return obj
32218}
32219
32220type QueuePropMinRate struct {
32221 *QueueProp
32222 Rate uint16
32223}
32224
32225type IQueuePropMinRate interface {
32226 IQueueProp
32227 GetRate() uint16
32228}
32229
32230func (self *QueuePropMinRate) GetRate() uint16 {
32231 return self.Rate
32232}
32233
32234func (self *QueuePropMinRate) SetRate(v uint16) {
32235 self.Rate = v
32236}
32237
32238func (self *QueuePropMinRate) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]32239 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]32240 if err := self.QueueProp.Serialize(encoder); err != nil {
32241 return err
32242 }
32243
32244 encoder.Write(bytes.Repeat([]byte{0}, 4))
32245 encoder.PutUint16(uint16(self.Rate))
32246 encoder.Write(bytes.Repeat([]byte{0}, 6))
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]32247 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]32248
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]32249 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]32250
32251 return nil
32252}
32253
32254func DecodeQueuePropMinRate(parent *QueueProp, decoder *goloxi.Decoder) (*QueuePropMinRate, error) {
32255 _queuepropminrate := &QueuePropMinRate{QueueProp: parent}
32256 if decoder.Length() < 12 {
32257 return nil, fmt.Errorf("QueuePropMinRate packet too short: %d < 12", decoder.Length())
32258 }
32259 decoder.Skip(4)
32260 _queuepropminrate.Rate = uint16(decoder.ReadUint16())
32261 decoder.Skip(6)
32262 return _queuepropminrate, nil
32263}
32264
32265func NewQueuePropMinRate() *QueuePropMinRate {
32266 obj := &QueuePropMinRate{
32267 QueueProp: NewQueueProp(1),
32268 }
32269 return obj
32270}
32271
32272type QueueStatsEntry struct {
32273 PortNo Port
32274 QueueId uint32
32275 TxBytes uint64
32276 TxPackets uint64
32277 TxErrors uint64
32278 DurationSec uint32
32279 DurationNsec uint32
32280}
32281
32282type IQueueStatsEntry interface {
32283 goloxi.Serializable
32284 GetPortNo() Port
32285 GetQueueId() uint32
32286 GetTxBytes() uint64
32287 GetTxPackets() uint64
32288 GetTxErrors() uint64
32289 GetDurationSec() uint32
32290 GetDurationNsec() uint32
32291}
32292
32293func (self *QueueStatsEntry) GetPortNo() Port {
32294 return self.PortNo
32295}
32296
32297func (self *QueueStatsEntry) SetPortNo(v Port) {
32298 self.PortNo = v
32299}
32300
32301func (self *QueueStatsEntry) GetQueueId() uint32 {
32302 return self.QueueId
32303}
32304
32305func (self *QueueStatsEntry) SetQueueId(v uint32) {
32306 self.QueueId = v
32307}
32308
32309func (self *QueueStatsEntry) GetTxBytes() uint64 {
32310 return self.TxBytes
32311}
32312
32313func (self *QueueStatsEntry) SetTxBytes(v uint64) {
32314 self.TxBytes = v
32315}
32316
32317func (self *QueueStatsEntry) GetTxPackets() uint64 {
32318 return self.TxPackets
32319}
32320
32321func (self *QueueStatsEntry) SetTxPackets(v uint64) {
32322 self.TxPackets = v
32323}
32324
32325func (self *QueueStatsEntry) GetTxErrors() uint64 {
32326 return self.TxErrors
32327}
32328
32329func (self *QueueStatsEntry) SetTxErrors(v uint64) {
32330 self.TxErrors = v
32331}
32332
32333func (self *QueueStatsEntry) GetDurationSec() uint32 {
32334 return self.DurationSec
32335}
32336
32337func (self *QueueStatsEntry) SetDurationSec(v uint32) {
32338 self.DurationSec = v
32339}
32340
32341func (self *QueueStatsEntry) GetDurationNsec() uint32 {
32342 return self.DurationNsec
32343}
32344
32345func (self *QueueStatsEntry) SetDurationNsec(v uint32) {
32346 self.DurationNsec = v
32347}
32348
32349func (self *QueueStatsEntry) Serialize(encoder *goloxi.Encoder) error {
32350
32351 self.PortNo.Serialize(encoder)
32352 encoder.PutUint32(uint32(self.QueueId))
32353 encoder.PutUint64(uint64(self.TxBytes))
32354 encoder.PutUint64(uint64(self.TxPackets))
32355 encoder.PutUint64(uint64(self.TxErrors))
32356 encoder.PutUint32(uint32(self.DurationSec))
32357 encoder.PutUint32(uint32(self.DurationNsec))
32358
32359 return nil
32360}
32361
32362func DecodeQueueStatsEntry(decoder *goloxi.Decoder) (*QueueStatsEntry, error) {
32363 _queuestatsentry := &QueueStatsEntry{}
32364 if decoder.Length() < 40 {
32365 return nil, fmt.Errorf("QueueStatsEntry packet too short: %d < 40", decoder.Length())
32366 }
32367 _queuestatsentry.PortNo.Decode(decoder)
32368 _queuestatsentry.QueueId = uint32(decoder.ReadUint32())
32369 _queuestatsentry.TxBytes = uint64(decoder.ReadUint64())
32370 _queuestatsentry.TxPackets = uint64(decoder.ReadUint64())
32371 _queuestatsentry.TxErrors = uint64(decoder.ReadUint64())
32372 _queuestatsentry.DurationSec = uint32(decoder.ReadUint32())
32373 _queuestatsentry.DurationNsec = uint32(decoder.ReadUint32())
32374 return _queuestatsentry, nil
32375}
32376
32377func NewQueueStatsEntry() *QueueStatsEntry {
32378 obj := &QueueStatsEntry{}
32379 return obj
32380}
32381
32382type TableFeatureProp struct {
32383 Type uint16
32384 Length uint16
32385}
32386
32387type ITableFeatureProp interface {
32388 goloxi.Serializable
32389 GetType() uint16
32390 GetLength() uint16
32391}
32392
32393func (self *TableFeatureProp) GetType() uint16 {
32394 return self.Type
32395}
32396
32397func (self *TableFeatureProp) SetType(v uint16) {
32398 self.Type = v
32399}
32400
32401func (self *TableFeatureProp) GetLength() uint16 {
32402 return self.Length
32403}
32404
32405func (self *TableFeatureProp) SetLength(v uint16) {
32406 self.Length = v
32407}
32408
32409func (self *TableFeatureProp) Serialize(encoder *goloxi.Encoder) error {
32410
32411 encoder.PutUint16(uint16(self.Type))
32412 encoder.PutUint16(uint16(self.Length))
32413
32414 return nil
32415}
32416
32417func DecodeTableFeatureProp(decoder *goloxi.Decoder) (ITableFeatureProp, error) {
32418 _tablefeatureprop := &TableFeatureProp{}
32419 if decoder.Length() < 4 {
32420 return nil, fmt.Errorf("TableFeatureProp packet too short: %d < 4", decoder.Length())
32421 }
32422 _tablefeatureprop.Type = uint16(decoder.ReadUint16())
32423 _tablefeatureprop.Length = uint16(decoder.ReadUint16())
32424 oldDecoder := decoder
32425 defer func() { decoder = oldDecoder }()
32426 decoder = decoder.SliceDecoder(int(_tablefeatureprop.Length), 2+2)
32427
32428 switch _tablefeatureprop.Type {
32429 case 0:
32430 return DecodeTableFeaturePropInstructions(_tablefeatureprop, decoder)
32431 case 1:
32432 return DecodeTableFeaturePropInstructionsMiss(_tablefeatureprop, decoder)
32433 case 2:
32434 return DecodeTableFeaturePropNextTables(_tablefeatureprop, decoder)
32435 case 3:
32436 return DecodeTableFeaturePropNextTablesMiss(_tablefeatureprop, decoder)
32437 case 4:
32438 return DecodeTableFeaturePropWriteActions(_tablefeatureprop, decoder)
32439 case 5:
32440 return DecodeTableFeaturePropWriteActionsMiss(_tablefeatureprop, decoder)
32441 case 6:
32442 return DecodeTableFeaturePropApplyActions(_tablefeatureprop, decoder)
32443 case 7:
32444 return DecodeTableFeaturePropApplyActionsMiss(_tablefeatureprop, decoder)
32445 case 8:
32446 return DecodeTableFeaturePropMatch(_tablefeatureprop, decoder)
32447 case 10:
32448 return DecodeTableFeaturePropWildcards(_tablefeatureprop, decoder)
32449 case 12:
32450 return DecodeTableFeaturePropWriteSetfield(_tablefeatureprop, decoder)
32451 case 13:
32452 return DecodeTableFeaturePropWriteSetfieldMiss(_tablefeatureprop, decoder)
32453 case 14:
32454 return DecodeTableFeaturePropApplySetfield(_tablefeatureprop, decoder)
32455 case 15:
32456 return DecodeTableFeaturePropApplySetfieldMiss(_tablefeatureprop, decoder)
32457 case 65534:
32458 return DecodeTableFeaturePropExperimenter(_tablefeatureprop, decoder)
32459 case 65535:
32460 return DecodeTableFeaturePropExperimenterMiss(_tablefeatureprop, decoder)
32461 default:
32462 return nil, fmt.Errorf("Invalid type '%d' for 'TableFeatureProp'", _tablefeatureprop.Type)
32463 }
32464}
32465
32466func NewTableFeatureProp(_type uint16) *TableFeatureProp {
32467 obj := &TableFeatureProp{}
32468 obj.Type = _type
32469 return obj
32470}
32471
32472type TableFeaturePropApplyActions struct {
32473 *TableFeatureProp
32474 ActionIds []IActionId
32475}
32476
32477type ITableFeaturePropApplyActions interface {
32478 ITableFeatureProp
32479 GetActionIds() []IActionId
32480}
32481
32482func (self *TableFeaturePropApplyActions) GetActionIds() []IActionId {
32483 return self.ActionIds
32484}
32485
32486func (self *TableFeaturePropApplyActions) SetActionIds(v []IActionId) {
32487 self.ActionIds = v
32488}
32489
32490func (self *TableFeaturePropApplyActions) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]32491 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]32492 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
32493 return err
32494 }
32495
32496 for _, obj := range self.ActionIds {
32497 if err := obj.Serialize(encoder); err != nil {
32498 return err
32499 }
32500 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]32501 length := len(encoder.Bytes()) - startIndex
32502 alignedLength := ((length + 7) / 8 * 8)
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]32503
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]32504 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]32505
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]32506 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]32507
32508 return nil
32509}
32510
32511func DecodeTableFeaturePropApplyActions(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropApplyActions, error) {
32512 _tablefeaturepropapplyactions := &TableFeaturePropApplyActions{TableFeatureProp: parent}
32513 defer decoder.SkipAlign()
32514
32515 for decoder.Length() >= 4 {
32516 item, err := DecodeActionId(decoder)
32517 if err != nil {
32518 return nil, err
32519 }
32520 if item != nil {
32521 _tablefeaturepropapplyactions.ActionIds = append(_tablefeaturepropapplyactions.ActionIds, item)
32522 }
32523 }
32524 return _tablefeaturepropapplyactions, nil
32525}
32526
32527func NewTableFeaturePropApplyActions() *TableFeaturePropApplyActions {
32528 obj := &TableFeaturePropApplyActions{
32529 TableFeatureProp: NewTableFeatureProp(6),
32530 }
32531 return obj
32532}
32533
32534type TableFeaturePropApplyActionsMiss struct {
32535 *TableFeatureProp
32536 ActionIds []IActionId
32537}
32538
32539type ITableFeaturePropApplyActionsMiss interface {
32540 ITableFeatureProp
32541 GetActionIds() []IActionId
32542}
32543
32544func (self *TableFeaturePropApplyActionsMiss) GetActionIds() []IActionId {
32545 return self.ActionIds
32546}
32547
32548func (self *TableFeaturePropApplyActionsMiss) SetActionIds(v []IActionId) {
32549 self.ActionIds = v
32550}
32551
32552func (self *TableFeaturePropApplyActionsMiss) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]32553 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]32554 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
32555 return err
32556 }
32557
32558 for _, obj := range self.ActionIds {
32559 if err := obj.Serialize(encoder); err != nil {
32560 return err
32561 }
32562 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]32563 length := len(encoder.Bytes()) - startIndex
32564 alignedLength := ((length + 7) / 8 * 8)
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]32565
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]32566 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]32567
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]32568 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]32569
32570 return nil
32571}
32572
32573func DecodeTableFeaturePropApplyActionsMiss(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropApplyActionsMiss, error) {
32574 _tablefeaturepropapplyactionsmiss := &TableFeaturePropApplyActionsMiss{TableFeatureProp: parent}
32575 defer decoder.SkipAlign()
32576
32577 for decoder.Length() >= 4 {
32578 item, err := DecodeActionId(decoder)
32579 if err != nil {
32580 return nil, err
32581 }
32582 if item != nil {
32583 _tablefeaturepropapplyactionsmiss.ActionIds = append(_tablefeaturepropapplyactionsmiss.ActionIds, item)
32584 }
32585 }
32586 return _tablefeaturepropapplyactionsmiss, nil
32587}
32588
32589func NewTableFeaturePropApplyActionsMiss() *TableFeaturePropApplyActionsMiss {
32590 obj := &TableFeaturePropApplyActionsMiss{
32591 TableFeatureProp: NewTableFeatureProp(7),
32592 }
32593 return obj
32594}
32595
32596type TableFeaturePropApplySetfield struct {
32597 *TableFeatureProp
32598 OxmIds []*Uint32
32599}
32600
32601type ITableFeaturePropApplySetfield interface {
32602 ITableFeatureProp
32603 GetOxmIds() []*Uint32
32604}
32605
32606func (self *TableFeaturePropApplySetfield) GetOxmIds() []*Uint32 {
32607 return self.OxmIds
32608}
32609
32610func (self *TableFeaturePropApplySetfield) SetOxmIds(v []*Uint32) {
32611 self.OxmIds = v
32612}
32613
32614func (self *TableFeaturePropApplySetfield) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]32615 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]32616 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
32617 return err
32618 }
32619
32620 for _, obj := range self.OxmIds {
32621 if err := obj.Serialize(encoder); err != nil {
32622 return err
32623 }
32624 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]32625 length := len(encoder.Bytes()) - startIndex
32626 alignedLength := ((length + 7) / 8 * 8)
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]32627
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]32628 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]32629
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]32630 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]32631
32632 return nil
32633}
32634
32635func DecodeTableFeaturePropApplySetfield(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropApplySetfield, error) {
32636 _tablefeaturepropapplysetfield := &TableFeaturePropApplySetfield{TableFeatureProp: parent}
32637 defer decoder.SkipAlign()
32638
32639 for decoder.Length() >= 4 {
32640 item, err := DecodeUint32(decoder)
32641 if err != nil {
32642 return nil, err
32643 }
32644 if item != nil {
32645 _tablefeaturepropapplysetfield.OxmIds = append(_tablefeaturepropapplysetfield.OxmIds, item)
32646 }
32647 }
32648 return _tablefeaturepropapplysetfield, nil
32649}
32650
32651func NewTableFeaturePropApplySetfield() *TableFeaturePropApplySetfield {
32652 obj := &TableFeaturePropApplySetfield{
32653 TableFeatureProp: NewTableFeatureProp(14),
32654 }
32655 return obj
32656}
32657
32658type TableFeaturePropApplySetfieldMiss struct {
32659 *TableFeatureProp
32660 OxmIds []*Uint32
32661}
32662
32663type ITableFeaturePropApplySetfieldMiss interface {
32664 ITableFeatureProp
32665 GetOxmIds() []*Uint32
32666}
32667
32668func (self *TableFeaturePropApplySetfieldMiss) GetOxmIds() []*Uint32 {
32669 return self.OxmIds
32670}
32671
32672func (self *TableFeaturePropApplySetfieldMiss) SetOxmIds(v []*Uint32) {
32673 self.OxmIds = v
32674}
32675
32676func (self *TableFeaturePropApplySetfieldMiss) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]32677 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]32678 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
32679 return err
32680 }
32681
32682 for _, obj := range self.OxmIds {
32683 if err := obj.Serialize(encoder); err != nil {
32684 return err
32685 }
32686 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]32687 length := len(encoder.Bytes()) - startIndex
32688 alignedLength := ((length + 7) / 8 * 8)
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]32689
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]32690 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]32691
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]32692 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]32693
32694 return nil
32695}
32696
32697func DecodeTableFeaturePropApplySetfieldMiss(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropApplySetfieldMiss, error) {
32698 _tablefeaturepropapplysetfieldmiss := &TableFeaturePropApplySetfieldMiss{TableFeatureProp: parent}
32699 defer decoder.SkipAlign()
32700
32701 for decoder.Length() >= 4 {
32702 item, err := DecodeUint32(decoder)
32703 if err != nil {
32704 return nil, err
32705 }
32706 if item != nil {
32707 _tablefeaturepropapplysetfieldmiss.OxmIds = append(_tablefeaturepropapplysetfieldmiss.OxmIds, item)
32708 }
32709 }
32710 return _tablefeaturepropapplysetfieldmiss, nil
32711}
32712
32713func NewTableFeaturePropApplySetfieldMiss() *TableFeaturePropApplySetfieldMiss {
32714 obj := &TableFeaturePropApplySetfieldMiss{
32715 TableFeatureProp: NewTableFeatureProp(15),
32716 }
32717 return obj
32718}
32719
32720type TableFeaturePropExperimenter struct {
32721 *TableFeatureProp
32722 Experimenter uint32
32723 Subtype uint32
32724}
32725
32726type ITableFeaturePropExperimenter interface {
32727 ITableFeatureProp
32728 GetExperimenter() uint32
32729 GetSubtype() uint32
32730}
32731
32732func (self *TableFeaturePropExperimenter) GetExperimenter() uint32 {
32733 return self.Experimenter
32734}
32735
32736func (self *TableFeaturePropExperimenter) SetExperimenter(v uint32) {
32737 self.Experimenter = v
32738}
32739
32740func (self *TableFeaturePropExperimenter) GetSubtype() uint32 {
32741 return self.Subtype
32742}
32743
32744func (self *TableFeaturePropExperimenter) SetSubtype(v uint32) {
32745 self.Subtype = v
32746}
32747
32748func (self *TableFeaturePropExperimenter) Serialize(encoder *goloxi.Encoder) error {
32749 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
32750 return err
32751 }
32752
32753 encoder.PutUint32(uint32(self.Experimenter))
32754 encoder.PutUint32(uint32(self.Subtype))
32755
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]32756 return nil
32757}
32758
32759func DecodeTableFeaturePropExperimenter(parent *TableFeatureProp, decoder *goloxi.Decoder) (ITableFeaturePropExperimenter, error) {
32760 _tablefeaturepropexperimenter := &TableFeaturePropExperimenter{TableFeatureProp: parent}
32761 if decoder.Length() < 8 {
32762 return nil, fmt.Errorf("TableFeaturePropExperimenter packet too short: %d < 8", decoder.Length())
32763 }
32764 defer decoder.SkipAlign()
32765
32766 _tablefeaturepropexperimenter.Experimenter = uint32(decoder.ReadUint32())
32767 _tablefeaturepropexperimenter.Subtype = uint32(decoder.ReadUint32())
32768 return _tablefeaturepropexperimenter, nil
32769}
32770
32771func NewTableFeaturePropExperimenter(_experimenter uint32) *TableFeaturePropExperimenter {
32772 obj := &TableFeaturePropExperimenter{
32773 TableFeatureProp: NewTableFeatureProp(65534),
32774 }
32775 obj.Experimenter = _experimenter
32776 return obj
32777}
32778
32779type TableFeaturePropExperimenterMiss struct {
32780 *TableFeatureProp
32781 Experimenter uint32
32782 Subtype uint32
32783}
32784
32785type ITableFeaturePropExperimenterMiss interface {
32786 ITableFeatureProp
32787 GetExperimenter() uint32
32788 GetSubtype() uint32
32789}
32790
32791func (self *TableFeaturePropExperimenterMiss) GetExperimenter() uint32 {
32792 return self.Experimenter
32793}
32794
32795func (self *TableFeaturePropExperimenterMiss) SetExperimenter(v uint32) {
32796 self.Experimenter = v
32797}
32798
32799func (self *TableFeaturePropExperimenterMiss) GetSubtype() uint32 {
32800 return self.Subtype
32801}
32802
32803func (self *TableFeaturePropExperimenterMiss) SetSubtype(v uint32) {
32804 self.Subtype = v
32805}
32806
32807func (self *TableFeaturePropExperimenterMiss) Serialize(encoder *goloxi.Encoder) error {
32808 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
32809 return err
32810 }
32811
32812 encoder.PutUint32(uint32(self.Experimenter))
32813 encoder.PutUint32(uint32(self.Subtype))
32814
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]32815 return nil
32816}
32817
32818func DecodeTableFeaturePropExperimenterMiss(parent *TableFeatureProp, decoder *goloxi.Decoder) (ITableFeaturePropExperimenterMiss, error) {
32819 _tablefeaturepropexperimentermiss := &TableFeaturePropExperimenterMiss{TableFeatureProp: parent}
32820 if decoder.Length() < 8 {
32821 return nil, fmt.Errorf("TableFeaturePropExperimenterMiss packet too short: %d < 8", decoder.Length())
32822 }
32823 defer decoder.SkipAlign()
32824
32825 _tablefeaturepropexperimentermiss.Experimenter = uint32(decoder.ReadUint32())
32826 _tablefeaturepropexperimentermiss.Subtype = uint32(decoder.ReadUint32())
32827 return _tablefeaturepropexperimentermiss, nil
32828}
32829
32830func NewTableFeaturePropExperimenterMiss(_experimenter uint32) *TableFeaturePropExperimenterMiss {
32831 obj := &TableFeaturePropExperimenterMiss{
32832 TableFeatureProp: NewTableFeatureProp(65535),
32833 }
32834 obj.Experimenter = _experimenter
32835 return obj
32836}
32837
32838type TableFeaturePropInstructions struct {
32839 *TableFeatureProp
32840 InstructionIds []IInstructionId
32841}
32842
32843type ITableFeaturePropInstructions interface {
32844 ITableFeatureProp
32845 GetInstructionIds() []IInstructionId
32846}
32847
32848func (self *TableFeaturePropInstructions) GetInstructionIds() []IInstructionId {
32849 return self.InstructionIds
32850}
32851
32852func (self *TableFeaturePropInstructions) SetInstructionIds(v []IInstructionId) {
32853 self.InstructionIds = v
32854}
32855
32856func (self *TableFeaturePropInstructions) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]32857 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]32858 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
32859 return err
32860 }
32861
32862 for _, obj := range self.InstructionIds {
32863 if err := obj.Serialize(encoder); err != nil {
32864 return err
32865 }
32866 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]32867 length := len(encoder.Bytes()) - startIndex
32868 alignedLength := ((length + 7) / 8 * 8)
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]32869
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]32870 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]32871
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]32872 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]32873
32874 return nil
32875}
32876
32877func DecodeTableFeaturePropInstructions(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropInstructions, error) {
32878 _tablefeaturepropinstructions := &TableFeaturePropInstructions{TableFeatureProp: parent}
32879 defer decoder.SkipAlign()
32880
32881 for decoder.Length() >= 4 {
32882 item, err := DecodeInstructionId(decoder)
32883 if err != nil {
32884 return nil, err
32885 }
32886 if item != nil {
32887 _tablefeaturepropinstructions.InstructionIds = append(_tablefeaturepropinstructions.InstructionIds, item)
32888 }
32889 }
32890 return _tablefeaturepropinstructions, nil
32891}
32892
32893func NewTableFeaturePropInstructions() *TableFeaturePropInstructions {
32894 obj := &TableFeaturePropInstructions{
32895 TableFeatureProp: NewTableFeatureProp(0),
32896 }
32897 return obj
32898}
32899
32900type TableFeaturePropInstructionsMiss struct {
32901 *TableFeatureProp
32902 InstructionIds []IInstructionId
32903}
32904
32905type ITableFeaturePropInstructionsMiss interface {
32906 ITableFeatureProp
32907 GetInstructionIds() []IInstructionId
32908}
32909
32910func (self *TableFeaturePropInstructionsMiss) GetInstructionIds() []IInstructionId {
32911 return self.InstructionIds
32912}
32913
32914func (self *TableFeaturePropInstructionsMiss) SetInstructionIds(v []IInstructionId) {
32915 self.InstructionIds = v
32916}
32917
32918func (self *TableFeaturePropInstructionsMiss) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]32919 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]32920 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
32921 return err
32922 }
32923
32924 for _, obj := range self.InstructionIds {
32925 if err := obj.Serialize(encoder); err != nil {
32926 return err
32927 }
32928 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]32929 length := len(encoder.Bytes()) - startIndex
32930 alignedLength := ((length + 7) / 8 * 8)
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]32931
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]32932 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]32933
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]32934 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]32935
32936 return nil
32937}
32938
32939func DecodeTableFeaturePropInstructionsMiss(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropInstructionsMiss, error) {
32940 _tablefeaturepropinstructionsmiss := &TableFeaturePropInstructionsMiss{TableFeatureProp: parent}
32941 defer decoder.SkipAlign()
32942
32943 for decoder.Length() >= 4 {
32944 item, err := DecodeInstructionId(decoder)
32945 if err != nil {
32946 return nil, err
32947 }
32948 if item != nil {
32949 _tablefeaturepropinstructionsmiss.InstructionIds = append(_tablefeaturepropinstructionsmiss.InstructionIds, item)
32950 }
32951 }
32952 return _tablefeaturepropinstructionsmiss, nil
32953}
32954
32955func NewTableFeaturePropInstructionsMiss() *TableFeaturePropInstructionsMiss {
32956 obj := &TableFeaturePropInstructionsMiss{
32957 TableFeatureProp: NewTableFeatureProp(1),
32958 }
32959 return obj
32960}
32961
32962type TableFeaturePropMatch struct {
32963 *TableFeatureProp
32964 OxmIds []*Uint32
32965}
32966
32967type ITableFeaturePropMatch interface {
32968 ITableFeatureProp
32969 GetOxmIds() []*Uint32
32970}
32971
32972func (self *TableFeaturePropMatch) GetOxmIds() []*Uint32 {
32973 return self.OxmIds
32974}
32975
32976func (self *TableFeaturePropMatch) SetOxmIds(v []*Uint32) {
32977 self.OxmIds = v
32978}
32979
32980func (self *TableFeaturePropMatch) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]32981 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]32982 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
32983 return err
32984 }
32985
32986 for _, obj := range self.OxmIds {
32987 if err := obj.Serialize(encoder); err != nil {
32988 return err
32989 }
32990 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]32991 length := len(encoder.Bytes()) - startIndex
32992 alignedLength := ((length + 7) / 8 * 8)
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]32993
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]32994 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]32995
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]32996 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]32997
32998 return nil
32999}
33000
33001func DecodeTableFeaturePropMatch(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropMatch, error) {
33002 _tablefeaturepropmatch := &TableFeaturePropMatch{TableFeatureProp: parent}
33003 defer decoder.SkipAlign()
33004
33005 for decoder.Length() >= 4 {
33006 item, err := DecodeUint32(decoder)
33007 if err != nil {
33008 return nil, err
33009 }
33010 if item != nil {
33011 _tablefeaturepropmatch.OxmIds = append(_tablefeaturepropmatch.OxmIds, item)
33012 }
33013 }
33014 return _tablefeaturepropmatch, nil
33015}
33016
33017func NewTableFeaturePropMatch() *TableFeaturePropMatch {
33018 obj := &TableFeaturePropMatch{
33019 TableFeatureProp: NewTableFeatureProp(8),
33020 }
33021 return obj
33022}
33023
33024type TableFeaturePropNextTables struct {
33025 *TableFeatureProp
33026 NextTableIds []*Uint8
33027}
33028
33029type ITableFeaturePropNextTables interface {
33030 ITableFeatureProp
33031 GetNextTableIds() []*Uint8
33032}
33033
33034func (self *TableFeaturePropNextTables) GetNextTableIds() []*Uint8 {
33035 return self.NextTableIds
33036}
33037
33038func (self *TableFeaturePropNextTables) SetNextTableIds(v []*Uint8) {
33039 self.NextTableIds = v
33040}
33041
33042func (self *TableFeaturePropNextTables) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]33043 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]33044 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
33045 return err
33046 }
33047
33048 for _, obj := range self.NextTableIds {
33049 if err := obj.Serialize(encoder); err != nil {
33050 return err
33051 }
33052 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]33053 length := len(encoder.Bytes()) - startIndex
33054 alignedLength := ((length + 7) / 8 * 8)
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]33055
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]33056 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]33057
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]33058 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]33059
33060 return nil
33061}
33062
33063func DecodeTableFeaturePropNextTables(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropNextTables, error) {
33064 _tablefeaturepropnexttables := &TableFeaturePropNextTables{TableFeatureProp: parent}
33065 defer decoder.SkipAlign()
33066
33067 for decoder.Length() >= 1 {
33068 item, err := DecodeUint8(decoder)
33069 if err != nil {
33070 return nil, err
33071 }
33072 if item != nil {
33073 _tablefeaturepropnexttables.NextTableIds = append(_tablefeaturepropnexttables.NextTableIds, item)
33074 }
33075 }
33076 return _tablefeaturepropnexttables, nil
33077}
33078
33079func NewTableFeaturePropNextTables() *TableFeaturePropNextTables {
33080 obj := &TableFeaturePropNextTables{
33081 TableFeatureProp: NewTableFeatureProp(2),
33082 }
33083 return obj
33084}
33085
33086type TableFeaturePropNextTablesMiss struct {
33087 *TableFeatureProp
33088 NextTableIds []*Uint8
33089}
33090
33091type ITableFeaturePropNextTablesMiss interface {
33092 ITableFeatureProp
33093 GetNextTableIds() []*Uint8
33094}
33095
33096func (self *TableFeaturePropNextTablesMiss) GetNextTableIds() []*Uint8 {
33097 return self.NextTableIds
33098}
33099
33100func (self *TableFeaturePropNextTablesMiss) SetNextTableIds(v []*Uint8) {
33101 self.NextTableIds = v
33102}
33103
33104func (self *TableFeaturePropNextTablesMiss) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]33105 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]33106 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
33107 return err
33108 }
33109
33110 for _, obj := range self.NextTableIds {
33111 if err := obj.Serialize(encoder); err != nil {
33112 return err
33113 }
33114 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]33115 length := len(encoder.Bytes()) - startIndex
33116 alignedLength := ((length + 7) / 8 * 8)
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]33117
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]33118 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]33119
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]33120 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]33121
33122 return nil
33123}
33124
33125func DecodeTableFeaturePropNextTablesMiss(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropNextTablesMiss, error) {
33126 _tablefeaturepropnexttablesmiss := &TableFeaturePropNextTablesMiss{TableFeatureProp: parent}
33127 defer decoder.SkipAlign()
33128
33129 for decoder.Length() >= 1 {
33130 item, err := DecodeUint8(decoder)
33131 if err != nil {
33132 return nil, err
33133 }
33134 if item != nil {
33135 _tablefeaturepropnexttablesmiss.NextTableIds = append(_tablefeaturepropnexttablesmiss.NextTableIds, item)
33136 }
33137 }
33138 return _tablefeaturepropnexttablesmiss, nil
33139}
33140
33141func NewTableFeaturePropNextTablesMiss() *TableFeaturePropNextTablesMiss {
33142 obj := &TableFeaturePropNextTablesMiss{
33143 TableFeatureProp: NewTableFeatureProp(3),
33144 }
33145 return obj
33146}
33147
33148type TableFeaturePropWildcards struct {
33149 *TableFeatureProp
33150 OxmIds []*Uint32
33151}
33152
33153type ITableFeaturePropWildcards interface {
33154 ITableFeatureProp
33155 GetOxmIds() []*Uint32
33156}
33157
33158func (self *TableFeaturePropWildcards) GetOxmIds() []*Uint32 {
33159 return self.OxmIds
33160}
33161
33162func (self *TableFeaturePropWildcards) SetOxmIds(v []*Uint32) {
33163 self.OxmIds = v
33164}
33165
33166func (self *TableFeaturePropWildcards) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]33167 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]33168 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
33169 return err
33170 }
33171
33172 for _, obj := range self.OxmIds {
33173 if err := obj.Serialize(encoder); err != nil {
33174 return err
33175 }
33176 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]33177 length := len(encoder.Bytes()) - startIndex
33178 alignedLength := ((length + 7) / 8 * 8)
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]33179
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]33180 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]33181
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]33182 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]33183
33184 return nil
33185}
33186
33187func DecodeTableFeaturePropWildcards(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropWildcards, error) {
33188 _tablefeaturepropwildcards := &TableFeaturePropWildcards{TableFeatureProp: parent}
33189 defer decoder.SkipAlign()
33190
33191 for decoder.Length() >= 4 {
33192 item, err := DecodeUint32(decoder)
33193 if err != nil {
33194 return nil, err
33195 }
33196 if item != nil {
33197 _tablefeaturepropwildcards.OxmIds = append(_tablefeaturepropwildcards.OxmIds, item)
33198 }
33199 }
33200 return _tablefeaturepropwildcards, nil
33201}
33202
33203func NewTableFeaturePropWildcards() *TableFeaturePropWildcards {
33204 obj := &TableFeaturePropWildcards{
33205 TableFeatureProp: NewTableFeatureProp(10),
33206 }
33207 return obj
33208}
33209
33210type TableFeaturePropWriteActions struct {
33211 *TableFeatureProp
33212 ActionIds []IActionId
33213}
33214
33215type ITableFeaturePropWriteActions interface {
33216 ITableFeatureProp
33217 GetActionIds() []IActionId
33218}
33219
33220func (self *TableFeaturePropWriteActions) GetActionIds() []IActionId {
33221 return self.ActionIds
33222}
33223
33224func (self *TableFeaturePropWriteActions) SetActionIds(v []IActionId) {
33225 self.ActionIds = v
33226}
33227
33228func (self *TableFeaturePropWriteActions) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]33229 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]33230 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
33231 return err
33232 }
33233
33234 for _, obj := range self.ActionIds {
33235 if err := obj.Serialize(encoder); err != nil {
33236 return err
33237 }
33238 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]33239 length := len(encoder.Bytes()) - startIndex
33240 alignedLength := ((length + 7) / 8 * 8)
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]33241
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]33242 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]33243
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]33244 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]33245
33246 return nil
33247}
33248
33249func DecodeTableFeaturePropWriteActions(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropWriteActions, error) {
33250 _tablefeaturepropwriteactions := &TableFeaturePropWriteActions{TableFeatureProp: parent}
33251 defer decoder.SkipAlign()
33252
33253 for decoder.Length() >= 4 {
33254 item, err := DecodeActionId(decoder)
33255 if err != nil {
33256 return nil, err
33257 }
33258 if item != nil {
33259 _tablefeaturepropwriteactions.ActionIds = append(_tablefeaturepropwriteactions.ActionIds, item)
33260 }
33261 }
33262 return _tablefeaturepropwriteactions, nil
33263}
33264
33265func NewTableFeaturePropWriteActions() *TableFeaturePropWriteActions {
33266 obj := &TableFeaturePropWriteActions{
33267 TableFeatureProp: NewTableFeatureProp(4),
33268 }
33269 return obj
33270}
33271
33272type TableFeaturePropWriteActionsMiss struct {
33273 *TableFeatureProp
33274 ActionIds []IActionId
33275}
33276
33277type ITableFeaturePropWriteActionsMiss interface {
33278 ITableFeatureProp
33279 GetActionIds() []IActionId
33280}
33281
33282func (self *TableFeaturePropWriteActionsMiss) GetActionIds() []IActionId {
33283 return self.ActionIds
33284}
33285
33286func (self *TableFeaturePropWriteActionsMiss) SetActionIds(v []IActionId) {
33287 self.ActionIds = v
33288}
33289
33290func (self *TableFeaturePropWriteActionsMiss) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]33291 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]33292 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
33293 return err
33294 }
33295
33296 for _, obj := range self.ActionIds {
33297 if err := obj.Serialize(encoder); err != nil {
33298 return err
33299 }
33300 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]33301 length := len(encoder.Bytes()) - startIndex
33302 alignedLength := ((length + 7) / 8 * 8)
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]33303
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]33304 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]33305
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]33306 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]33307
33308 return nil
33309}
33310
33311func DecodeTableFeaturePropWriteActionsMiss(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropWriteActionsMiss, error) {
33312 _tablefeaturepropwriteactionsmiss := &TableFeaturePropWriteActionsMiss{TableFeatureProp: parent}
33313 defer decoder.SkipAlign()
33314
33315 for decoder.Length() >= 4 {
33316 item, err := DecodeActionId(decoder)
33317 if err != nil {
33318 return nil, err
33319 }
33320 if item != nil {
33321 _tablefeaturepropwriteactionsmiss.ActionIds = append(_tablefeaturepropwriteactionsmiss.ActionIds, item)
33322 }
33323 }
33324 return _tablefeaturepropwriteactionsmiss, nil
33325}
33326
33327func NewTableFeaturePropWriteActionsMiss() *TableFeaturePropWriteActionsMiss {
33328 obj := &TableFeaturePropWriteActionsMiss{
33329 TableFeatureProp: NewTableFeatureProp(5),
33330 }
33331 return obj
33332}
33333
33334type TableFeaturePropWriteSetfield struct {
33335 *TableFeatureProp
33336 OxmIds []*Uint32
33337}
33338
33339type ITableFeaturePropWriteSetfield interface {
33340 ITableFeatureProp
33341 GetOxmIds() []*Uint32
33342}
33343
33344func (self *TableFeaturePropWriteSetfield) GetOxmIds() []*Uint32 {
33345 return self.OxmIds
33346}
33347
33348func (self *TableFeaturePropWriteSetfield) SetOxmIds(v []*Uint32) {
33349 self.OxmIds = v
33350}
33351
33352func (self *TableFeaturePropWriteSetfield) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]33353 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]33354 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
33355 return err
33356 }
33357
33358 for _, obj := range self.OxmIds {
33359 if err := obj.Serialize(encoder); err != nil {
33360 return err
33361 }
33362 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]33363 length := len(encoder.Bytes()) - startIndex
33364 alignedLength := ((length + 7) / 8 * 8)
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]33365
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]33366 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]33367
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]33368 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]33369
33370 return nil
33371}
33372
33373func DecodeTableFeaturePropWriteSetfield(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropWriteSetfield, error) {
33374 _tablefeaturepropwritesetfield := &TableFeaturePropWriteSetfield{TableFeatureProp: parent}
33375 defer decoder.SkipAlign()
33376
33377 for decoder.Length() >= 4 {
33378 item, err := DecodeUint32(decoder)
33379 if err != nil {
33380 return nil, err
33381 }
33382 if item != nil {
33383 _tablefeaturepropwritesetfield.OxmIds = append(_tablefeaturepropwritesetfield.OxmIds, item)
33384 }
33385 }
33386 return _tablefeaturepropwritesetfield, nil
33387}
33388
33389func NewTableFeaturePropWriteSetfield() *TableFeaturePropWriteSetfield {
33390 obj := &TableFeaturePropWriteSetfield{
33391 TableFeatureProp: NewTableFeatureProp(12),
33392 }
33393 return obj
33394}
33395
33396type TableFeaturePropWriteSetfieldMiss struct {
33397 *TableFeatureProp
33398 OxmIds []*Uint32
33399}
33400
33401type ITableFeaturePropWriteSetfieldMiss interface {
33402 ITableFeatureProp
33403 GetOxmIds() []*Uint32
33404}
33405
33406func (self *TableFeaturePropWriteSetfieldMiss) GetOxmIds() []*Uint32 {
33407 return self.OxmIds
33408}
33409
33410func (self *TableFeaturePropWriteSetfieldMiss) SetOxmIds(v []*Uint32) {
33411 self.OxmIds = v
33412}
33413
33414func (self *TableFeaturePropWriteSetfieldMiss) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]33415 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]33416 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
33417 return err
33418 }
33419
33420 for _, obj := range self.OxmIds {
33421 if err := obj.Serialize(encoder); err != nil {
33422 return err
33423 }
33424 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]33425 length := len(encoder.Bytes()) - startIndex
33426 alignedLength := ((length + 7) / 8 * 8)
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]33427
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]33428 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]33429
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]33430 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]33431
33432 return nil
33433}
33434
33435func DecodeTableFeaturePropWriteSetfieldMiss(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropWriteSetfieldMiss, error) {
33436 _tablefeaturepropwritesetfieldmiss := &TableFeaturePropWriteSetfieldMiss{TableFeatureProp: parent}
33437 defer decoder.SkipAlign()
33438
33439 for decoder.Length() >= 4 {
33440 item, err := DecodeUint32(decoder)
33441 if err != nil {
33442 return nil, err
33443 }
33444 if item != nil {
33445 _tablefeaturepropwritesetfieldmiss.OxmIds = append(_tablefeaturepropwritesetfieldmiss.OxmIds, item)
33446 }
33447 }
33448 return _tablefeaturepropwritesetfieldmiss, nil
33449}
33450
33451func NewTableFeaturePropWriteSetfieldMiss() *TableFeaturePropWriteSetfieldMiss {
33452 obj := &TableFeaturePropWriteSetfieldMiss{
33453 TableFeatureProp: NewTableFeatureProp(13),
33454 }
33455 return obj
33456}
33457
33458type TableFeatures struct {
33459 Length uint16
33460 TableId uint8
33461 Name string
33462 MetadataMatch uint64
33463 MetadataWrite uint64
33464 Config uint32
33465 MaxEntries uint32
33466 Properties []ITableFeatureProp
33467}
33468
33469type ITableFeatures interface {
33470 goloxi.Serializable
33471 GetLength() uint16
33472 GetTableId() uint8
33473 GetName() string
33474 GetMetadataMatch() uint64
33475 GetMetadataWrite() uint64
33476 GetConfig() uint32
33477 GetMaxEntries() uint32
33478 GetProperties() []ITableFeatureProp
33479}
33480
33481func (self *TableFeatures) GetLength() uint16 {
33482 return self.Length
33483}
33484
33485func (self *TableFeatures) SetLength(v uint16) {
33486 self.Length = v
33487}
33488
33489func (self *TableFeatures) GetTableId() uint8 {
33490 return self.TableId
33491}
33492
33493func (self *TableFeatures) SetTableId(v uint8) {
33494 self.TableId = v
33495}
33496
33497func (self *TableFeatures) GetName() string {
33498 return self.Name
33499}
33500
33501func (self *TableFeatures) SetName(v string) {
33502 self.Name = v
33503}
33504
33505func (self *TableFeatures) GetMetadataMatch() uint64 {
33506 return self.MetadataMatch
33507}
33508
33509func (self *TableFeatures) SetMetadataMatch(v uint64) {
33510 self.MetadataMatch = v
33511}
33512
33513func (self *TableFeatures) GetMetadataWrite() uint64 {
33514 return self.MetadataWrite
33515}
33516
33517func (self *TableFeatures) SetMetadataWrite(v uint64) {
33518 self.MetadataWrite = v
33519}
33520
33521func (self *TableFeatures) GetConfig() uint32 {
33522 return self.Config
33523}
33524
33525func (self *TableFeatures) SetConfig(v uint32) {
33526 self.Config = v
33527}
33528
33529func (self *TableFeatures) GetMaxEntries() uint32 {
33530 return self.MaxEntries
33531}
33532
33533func (self *TableFeatures) SetMaxEntries(v uint32) {
33534 self.MaxEntries = v
33535}
33536
33537func (self *TableFeatures) GetProperties() []ITableFeatureProp {
33538 return self.Properties
33539}
33540
33541func (self *TableFeatures) SetProperties(v []ITableFeatureProp) {
33542 self.Properties = v
33543}
33544
33545func (self *TableFeatures) Serialize(encoder *goloxi.Encoder) error {
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]33546 startIndex := len(encoder.Bytes())
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]33547
33548 encoder.PutUint16(uint16(self.Length))
33549 encoder.PutUint8(uint8(self.TableId))
33550 encoder.Write(bytes.Repeat([]byte{0}, 5))
33551 encoder.Write([]byte(self.Name))
33552 encoder.PutUint64(uint64(self.MetadataMatch))
33553 encoder.PutUint64(uint64(self.MetadataWrite))
33554 encoder.PutUint32(uint32(self.Config))
33555 encoder.PutUint32(uint32(self.MaxEntries))
33556 for _, obj := range self.Properties {
33557 if err := obj.Serialize(encoder); err != nil {
33558 return err
33559 }
33560 }
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]33561 length := len(encoder.Bytes()) - startIndex
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]33562
Jonathan Hart828908c2020-04-15 14:23:45 -0700[diff] [blame^]33563 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame]33564
33565 return nil
33566}
33567
33568func DecodeTableFeatures(decoder *goloxi.Decoder) (*TableFeatures, error) {
33569 _tablefeatures := &TableFeatures{}
33570 if decoder.Length() < 64 {
33571 return nil, fmt.Errorf("TableFeatures packet too short: %d < 64", decoder.Length())
33572 }
33573 _tablefeatures.Length = uint16(decoder.ReadUint16())
33574 oldDecoder := decoder
33575 defer func() { decoder = oldDecoder }()
33576 decoder = decoder.SliceDecoder(int(_tablefeatures.Length), 2+0)
33577 _tablefeatures.TableId = uint8(decoder.ReadByte())
33578 decoder.Skip(5)
33579 _tablefeatures.Name = string(bytes.Trim(decoder.Read(32), "\x00"))
33580 _tablefeatures.MetadataMatch = uint64(decoder.ReadUint64())
33581 _tablefeatures.MetadataWrite = uint64(decoder.ReadUint64())
33582 _tablefeatures.Config = uint32(decoder.ReadUint32())
33583 _tablefeatures.MaxEntries = uint32(decoder.ReadUint32())
33584
33585 for decoder.Length() >= 4 {
33586 item, err := DecodeTableFeatureProp(decoder)
33587 if err != nil {
33588 return nil, err
33589 }
33590 if item != nil {
33591 _tablefeatures.Properties = append(_tablefeatures.Properties, item)
33592 }
33593 }
33594 return _tablefeatures, nil
33595}
33596
33597func NewTableFeatures() *TableFeatures {
33598 obj := &TableFeatures{}
33599 return obj
33600}
33601
33602type TableStatsEntry struct {
33603 TableId uint8
33604 ActiveCount uint32
33605 LookupCount uint64
33606 MatchedCount uint64
33607}
33608
33609type ITableStatsEntry interface {
33610 goloxi.Serializable
33611 GetTableId() uint8
33612 GetActiveCount() uint32
33613 GetLookupCount() uint64
33614 GetMatchedCount() uint64
33615}
33616
33617func (self *TableStatsEntry) GetTableId() uint8 {
33618 return self.TableId
33619}
33620
33621func (self *TableStatsEntry) SetTableId(v uint8) {
33622 self.TableId = v
33623}
33624
33625func (self *TableStatsEntry) GetActiveCount() uint32 {
33626 return self.ActiveCount
33627}
33628
33629func (self *TableStatsEntry) SetActiveCount(v uint32) {
33630 self.ActiveCount = v
33631}
33632
33633func (self *TableStatsEntry) GetLookupCount() uint64 {
33634 return self.LookupCount
33635}
33636
33637func (self *TableStatsEntry) SetLookupCount(v uint64) {
33638 self.LookupCount = v
33639}
33640
33641func (self *TableStatsEntry) GetMatchedCount() uint64 {
33642 return self.MatchedCount
33643}
33644
33645func (self *TableStatsEntry) SetMatchedCount(v uint64) {
33646 self.MatchedCount = v
33647}
33648
33649func (self *TableStatsEntry) Serialize(encoder *goloxi.Encoder) error {
33650
33651 encoder.PutUint8(uint8(self.TableId))
33652 encoder.Write(bytes.Repeat([]byte{0}, 3))
33653 encoder.PutUint32(uint32(self.ActiveCount))
33654 encoder.PutUint64(uint64(self.LookupCount))
33655 encoder.PutUint64(uint64(self.MatchedCount))
33656
33657 return nil
33658}
33659
33660func DecodeTableStatsEntry(decoder *goloxi.Decoder) (*TableStatsEntry, error) {
33661 _tablestatsentry := &TableStatsEntry{}
33662 if decoder.Length() < 24 {
33663 return nil, fmt.Errorf("TableStatsEntry packet too short: %d < 24", decoder.Length())
33664 }
33665 _tablestatsentry.TableId = uint8(decoder.ReadByte())
33666 decoder.Skip(3)
33667 _tablestatsentry.ActiveCount = uint32(decoder.ReadUint32())
33668 _tablestatsentry.LookupCount = uint64(decoder.ReadUint64())
33669 _tablestatsentry.MatchedCount = uint64(decoder.ReadUint64())
33670 return _tablestatsentry, nil
33671}
33672
33673func NewTableStatsEntry() *TableStatsEntry {
33674 obj := &TableStatsEntry{}
33675 return obj
33676}
33677
33678type Uint32 struct {
33679 Value uint32
33680}
33681
33682type IUint32 interface {
33683 goloxi.Serializable
33684 GetValue() uint32
33685}
33686
33687func (self *Uint32) GetValue() uint32 {
33688 return self.Value
33689}
33690
33691func (self *Uint32) SetValue(v uint32) {
33692 self.Value = v
33693}
33694
33695func (self *Uint32) Serialize(encoder *goloxi.Encoder) error {
33696
33697 encoder.PutUint32(uint32(self.Value))
33698
33699 return nil
33700}
33701
33702func DecodeUint32(decoder *goloxi.Decoder) (*Uint32, error) {
33703 _uint32 := &Uint32{}
33704 if decoder.Length() < 4 {
33705 return nil, fmt.Errorf("Uint32 packet too short: %d < 4", decoder.Length())
33706 }
33707 _uint32.Value = uint32(decoder.ReadUint32())
33708 return _uint32, nil
33709}
33710
33711func NewUint32() *Uint32 {
33712 obj := &Uint32{}
33713 return obj
33714}
33715
33716type Uint64 struct {
33717 Value uint64
33718}
33719
33720type IUint64 interface {
33721 goloxi.Serializable
33722 GetValue() uint64
33723}
33724
33725func (self *Uint64) GetValue() uint64 {
33726 return self.Value
33727}
33728
33729func (self *Uint64) SetValue(v uint64) {
33730 self.Value = v
33731}
33732
33733func (self *Uint64) Serialize(encoder *goloxi.Encoder) error {
33734
33735 encoder.PutUint64(uint64(self.Value))
33736
33737 return nil
33738}
33739
33740func DecodeUint64(decoder *goloxi.Decoder) (*Uint64, error) {
33741 _uint64 := &Uint64{}
33742 if decoder.Length() < 8 {
33743 return nil, fmt.Errorf("Uint64 packet too short: %d < 8", decoder.Length())
33744 }
33745 _uint64.Value = uint64(decoder.ReadUint64())
33746 return _uint64, nil
33747}
33748
33749func NewUint64() *Uint64 {
33750 obj := &Uint64{}
33751 return obj
33752}
33753
33754type Uint8 struct {
33755 Value uint8
33756}
33757
33758type IUint8 interface {
33759 goloxi.Serializable
33760 GetValue() uint8
33761}
33762
33763func (self *Uint8) GetValue() uint8 {
33764 return self.Value
33765}
33766
33767func (self *Uint8) SetValue(v uint8) {
33768 self.Value = v
33769}
33770
33771func (self *Uint8) Serialize(encoder *goloxi.Encoder) error {
33772
33773 encoder.PutUint8(uint8(self.Value))
33774
33775 return nil
33776}
33777
33778func DecodeUint8(decoder *goloxi.Decoder) (*Uint8, error) {
33779 _uint8 := &Uint8{}
33780 if decoder.Length() < 1 {
33781 return nil, fmt.Errorf("Uint8 packet too short: %d < 1", decoder.Length())
33782 }
33783 _uint8.Value = uint8(decoder.ReadByte())
33784 return _uint8, nil
33785}
33786
33787func NewUint8() *Uint8 {
33788 obj := &Uint8{}
33789 return obj
33790}