Gitiles
Code Review Sign In
gerrit.opencord.org / goloxi / 44bdbfc319927fdbd8a09267da232ae09bc39962 / . / of15 / common.go
blob: 83d6b77194e64f459b6781d59943f4e2e4851d55 [file] [log] [blame]
Jonathan Hart44bdbfc2020-04-14 17:45:47 -0700[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 of15
11
12import (
13 "bytes"
14 "encoding/binary"
15 "fmt"
16 "net"
17
18 "github.com/opencord/goloxi"
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 72708:
187 return DecodeOxmIdReg14(_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 2147488514:
261 return DecodeOxmIdIpEcnMasked(_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 112764:
325 return DecodeOxmIdTunMetadata52(_oxmid, decoder)
326 case 101500:
327 return DecodeOxmIdTunMetadata30(_oxmid, decoder)
328 case 97272:
329 return DecodeOxmIdTunMetadata21Masked(_oxmid, decoder)
330 case 2147498754:
331 return DecodeOxmIdIcmpv6TypeMasked(_oxmid, decoder)
332 case 209668:
333 return DecodeOxmIdBsnVfiMasked(_oxmid, decoder)
334 case 2147484424:
335 return DecodeOxmIdInPhyPortMasked(_oxmid, decoder)
336 case 74507:
337 return DecodeOxmIdArpShaMasked(_oxmid, decoder)
338 case 2147500812:
339 return DecodeOxmIdIpv6NdTllMasked(_oxmid, decoder)
340 case 197384:
341 return DecodeOxmIdBsnLagIdMasked(_oxmid, decoder)
342 case 76064:
343 return DecodeOxmIdIpv6DstMasked(_oxmid, decoder)
344 case 102524:
345 return DecodeOxmIdTunMetadata32(_oxmid, decoder)
346 case 98296:
347 return DecodeOxmIdTunMetadata23Masked(_oxmid, decoder)
348 case 4868:
349 return DecodeOxmIdTcpSrcMasked(_oxmid, decoder)
350 case 121632:
351 return DecodeOxmIdTunIpv6SrcMasked(_oxmid, decoder)
352 case 75792:
353 return DecodeOxmIdIpv6Dst(_oxmid, decoder)
354 case 202504:
355 return DecodeOxmIdBsnUdf3Masked(_oxmid, decoder)
356 case 120324:
357 return DecodeOxmIdConnTrackingMark(_oxmid, decoder)
358 case 99320:
359 return DecodeOxmIdTunMetadata25Masked(_oxmid, decoder)
360 case 65800:
361 return DecodeOxmIdReg0Masked(_oxmid, decoder)
362 case 66824:
363 return DecodeOxmIdReg2Masked(_oxmid, decoder)
364 case 2147506180:
365 return DecodeOxmIdPacketType(_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 73480:
399 return DecodeOxmIdReg15Masked(_oxmid, decoder)
400 case 204292:
401 return DecodeOxmIdBsnUdf7(_oxmid, decoder)
402 case 2147489544:
403 return DecodeOxmIdIpv4SrcMasked(_oxmid, decoder)
404 case 107644:
405 return DecodeOxmIdTunMetadata42(_oxmid, decoder)
406 case 103416:
407 return DecodeOxmIdTunMetadata33Masked(_oxmid, decoder)
408 case 2147498248:
409 return DecodeOxmIdIpv6FlabelMasked(_oxmid, decoder)
410 case 203528:
411 return DecodeOxmIdBsnUdf5Masked(_oxmid, decoder)
412 case 89592:
413 return DecodeOxmIdTunMetadata6Masked(_oxmid, decoder)
414 case 104440:
415 return DecodeOxmIdTunMetadata35Masked(_oxmid, decoder)
416 case 2147494660:
417 return DecodeOxmIdArpOpMasked(_oxmid, decoder)
418 case 197636:
419 return DecodeOxmIdBsnVrf(_oxmid, decoder)
420 case 204552:
421 return DecodeOxmIdBsnUdf7Masked(_oxmid, decoder)
422 case 109692:
423 return DecodeOxmIdTunMetadata46(_oxmid, decoder)
424 case 105464:
425 return DecodeOxmIdTunMetadata37Masked(_oxmid, decoder)
426 case 89080:
427 return DecodeOxmIdTunMetadata5Masked(_oxmid, decoder)
428 case 67588:
429 return DecodeOxmIdReg4(_oxmid, decoder)
430 case 7169:
431 return DecodeOxmIdIcmpCode(_oxmid, decoder)
432 case 82946:
433 return DecodeOxmIdTcpFlags(_oxmid, decoder)
434 case 203780:
435 return DecodeOxmIdBsnUdf6(_oxmid, decoder)
436 case 207878:
437 return DecodeOxmIdBsnInnerEthDst(_oxmid, decoder)
438 case 85505:
439 return DecodeOxmIdTunGbpFlags(_oxmid, decoder)
440 case 2147484680:
441 return DecodeOxmIdMetadata(_oxmid, decoder)
442 case 1538:
443 return DecodeOxmIdEthType(_oxmid, decoder)
444 case 8968:
445 return DecodeOxmIdArpTpaMasked(_oxmid, decoder)
446 case 128016:
447 return DecodeOxmIdConnTrackingIpv6Src(_oxmid, decoder)
448 case 110716:
449 return DecodeOxmIdTunMetadata48(_oxmid, decoder)
450 case 127492:
451 return DecodeOxmIdConnTrackingNwDst(_oxmid, decoder)
452 case 78342:
453 return DecodeOxmIdNdTll(_oxmid, decoder)
454 case 111740:
455 return DecodeOxmIdTunMetadata50(_oxmid, decoder)
456 case 107512:
457 return DecodeOxmIdTunMetadata41Masked(_oxmid, decoder)
458 case 207624:
459 return DecodeOxmIdBsnVxlanNetworkIdMasked(_oxmid, decoder)
460 case 121360:
461 return DecodeOxmIdTunIpv6Src(_oxmid, decoder)
462 case 113788:
463 return DecodeOxmIdTunMetadata54(_oxmid, decoder)
464 case 109560:
465 return DecodeOxmIdTunMetadata45Masked(_oxmid, decoder)
466 case 2147501826:
467 return DecodeOxmIdMplsTcMasked(_oxmid, decoder)
468 case 103548:
469 return DecodeOxmIdTunMetadata34(_oxmid, decoder)
470 case 2147484164:
471 return DecodeOxmIdInPhyPort(_oxmid, decoder)
472 case 205316:
473 return DecodeOxmIdBsnVlanXlatePortGroupId(_oxmid, decoder)
474 case 114812:
475 return DecodeOxmIdTunMetadata56(_oxmid, decoder)
476 case 2147487233:
477 return DecodeOxmIdVlanPcp(_oxmid, decoder)
478 case 110584:
479 return DecodeOxmIdTunMetadata47Masked(_oxmid, decoder)
480 case 210696:
481 return DecodeOxmIdBsnIfpClassIdMasked(_oxmid, decoder)
482 case 115836:
483 return DecodeOxmIdTunMetadata58(_oxmid, decoder)
484 case 2147488257:
485 return DecodeOxmIdIpEcn(_oxmid, decoder)
486 case 111608:
487 return DecodeOxmIdTunMetadata49Masked(_oxmid, decoder)
488 case 518:
489 return DecodeOxmIdEthDst(_oxmid, decoder)
490 case 68100:
491 return DecodeOxmIdReg5(_oxmid, decoder)
492 case 116860:
493 return DecodeOxmIdTunMetadata60(_oxmid, decoder)
494 case 4610:
495 return DecodeOxmIdTcpSrc(_oxmid, decoder)
496 case 112632:
497 return DecodeOxmIdTunMetadata51Masked(_oxmid, decoder)
498 case 122384:
499 return DecodeOxmIdXxreg0(_oxmid, decoder)
500 case 2147504898:
501 return DecodeOxmIdPbbUcaMasked(_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 90748:
579 return DecodeOxmIdTunMetadata9(_oxmid, decoder)
580 case 86520:
581 return DecodeOxmIdTunMetadata0Masked(_oxmid, decoder)
582 case 2147487490:
583 return DecodeOxmIdVlanPcpMasked(_oxmid, decoder)
584 case 2147501320:
585 return DecodeOxmIdMplsLabelMasked(_oxmid, decoder)
586 case 197124:
587 return DecodeOxmIdBsnLagId(_oxmid, decoder)
588 case 78849:
589 return DecodeOxmIdIpFrag(_oxmid, decoder)
590 case 2147505928:
591 return DecodeOxmIdActsetOutputMasked(_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 210436:
659 return DecodeOxmIdBsnIfpClassId(_oxmid, decoder)
660 case 82436:
661 return DecodeOxmIdPktMark(_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 2147504641:
671 return DecodeOxmIdPbbUca(_oxmid, decoder)
672 case 123168:
673 return DecodeOxmIdXxreg1Masked(_oxmid, decoder)
674 case 118786:
675 return DecodeOxmIdTunFlags(_oxmid, decoder)
676 case 95736:
677 return DecodeOxmIdTunMetadata18Masked(_oxmid, decoder)
678 case 2308:
679 return DecodeOxmIdVlanTciMasked(_oxmid, decoder)
680 case 2147488002:
681 return DecodeOxmIdIpDscpMasked(_oxmid, decoder)
682 case 100988:
683 return DecodeOxmIdTunMetadata29(_oxmid, decoder)
684 case 119810:
685 return DecodeOxmIdConnTrackingZone(_oxmid, decoder)
686 case 96760:
687 return DecodeOxmIdTunMetadata20Masked(_oxmid, decoder)
688 case 2147486980:
689 return DecodeOxmIdVlanVidMasked(_oxmid, decoder)
690 case 116348:
691 return DecodeOxmIdTunMetadata59(_oxmid, decoder)
692 case 5378:
693 return DecodeOxmIdTcpDstMasked(_oxmid, decoder)
694 case 71944:
695 return DecodeOxmIdReg12Masked(_oxmid, decoder)
696 case 2147483912:
697 return DecodeOxmIdInPortMasked(_oxmid, decoder)
698 case 75552:
699 return DecodeOxmIdIpv6SrcMasked(_oxmid, decoder)
700 case 102012:
701 return DecodeOxmIdTunMetadata31(_oxmid, decoder)
702 case 85762:
703 return DecodeOxmIdTunGbpFlagsMasked(_oxmid, decoder)
704 case 5892:
705 return DecodeOxmIdUdpSrcMasked(_oxmid, decoder)
706 case 97784:
707 return DecodeOxmIdTunMetadata22Masked(_oxmid, decoder)
708 case 66052:
709 return DecodeOxmIdReg1(_oxmid, decoder)
710 case 67336:
711 return DecodeOxmIdReg3Masked(_oxmid, decoder)
712 case 208652:
713 return DecodeOxmIdBsnInnerEthSrcMasked(_oxmid, decoder)
714 case 75280:
715 return DecodeOxmIdIpv6Src(_oxmid, decoder)
716 case 197896:
717 return DecodeOxmIdBsnVrfMasked(_oxmid, decoder)
718 case 122656:
719 return DecodeOxmIdXxreg0Masked(_oxmid, decoder)
720 case 103036:
721 return DecodeOxmIdTunMetadata33(_oxmid, decoder)
722 case 98808:
723 return DecodeOxmIdTunMetadata24Masked(_oxmid, decoder)
724 case 2147505668:
725 return DecodeOxmIdActsetOutput(_oxmid, decoder)
726 case 67848:
727 return DecodeOxmIdReg4Masked(_oxmid, decoder)
728 case 77600:
729 return DecodeOxmIdNdTargetMasked(_oxmid, decoder)
730 case 104060:
731 return DecodeOxmIdTunMetadata35(_oxmid, decoder)
732 case 99832:
733 return DecodeOxmIdTunMetadata26Masked(_oxmid, decoder)
734 case 6404:
735 return DecodeOxmIdUdpDstMasked(_oxmid, decoder)
736 case 77328:
737 return DecodeOxmIdNdTarget(_oxmid, decoder)
738 case 68872:
739 return DecodeOxmIdReg6Masked(_oxmid, decoder)
740 case 105084:
741 return DecodeOxmIdTunMetadata37(_oxmid, decoder)
742 case 100856:
743 return DecodeOxmIdTunMetadata28Masked(_oxmid, decoder)
744 case 206082:
745 return DecodeOxmIdBsnL2CacheHitMasked(_oxmid, decoder)
746 case 203016:
747 return DecodeOxmIdBsnUdf4Masked(_oxmid, decoder)
748 case 69896:
749 return DecodeOxmIdReg8Masked(_oxmid, decoder)
750 case 206720:
751 return DecodeOxmIdBsnInPorts512Masked(_oxmid, decoder)
752 case 106108:
753 return DecodeOxmIdTunMetadata39(_oxmid, decoder)
754 case 101880:
755 return DecodeOxmIdTunMetadata30Masked(_oxmid, decoder)
756 case 8452:
757 return DecodeOxmIdArpSpaMasked(_oxmid, decoder)
758 case 66312:
759 return DecodeOxmIdReg1Masked(_oxmid, decoder)
760 case 201992:
761 return DecodeOxmIdBsnUdf2Masked(_oxmid, decoder)
762 case 107132:
763 return DecodeOxmIdTunMetadata41(_oxmid, decoder)
764 case 102904:
765 return DecodeOxmIdTunMetadata32Masked(_oxmid, decoder)
766 case 2147493124:
767 return DecodeOxmIdSctpDstMasked(_oxmid, decoder)
768 case 67076:
769 return DecodeOxmIdReg3(_oxmid, decoder)
770 case 79624:
771 return DecodeOxmIdIpv6LabelMasked(_oxmid, decoder)
772 case 119300:
773 return DecodeOxmIdConnTrackingState(_oxmid, decoder)
774 case 2147490056:
775 return DecodeOxmIdIpv4DstMasked(_oxmid, decoder)
776 case 2147499808:
777 return DecodeOxmIdIpv6NdTargetMasked(_oxmid, decoder)
778 case 108156:
779 return DecodeOxmIdTunMetadata43(_oxmid, decoder)
780 case 103928:
781 return DecodeOxmIdTunMetadata34Masked(_oxmid, decoder)
782 case 106488:
783 return DecodeOxmIdTunMetadata39Masked(_oxmid, decoder)
784 case 201732:
785 return DecodeOxmIdBsnUdf2(_oxmid, decoder)
786 case 2147499536:
787 return DecodeOxmIdIpv6NdTarget(_oxmid, decoder)
788 case 72968:
789 return DecodeOxmIdReg14Masked(_oxmid, decoder)
790 case 109180:
791 return DecodeOxmIdTunMetadata45(_oxmid, decoder)
792 case 104952:
793 return DecodeOxmIdTunMetadata36Masked(_oxmid, decoder)
794 case 93820:
795 return DecodeOxmIdTunMetadata15(_oxmid, decoder)
796 case 79106:
797 return DecodeOxmIdIpFragMasked(_oxmid, decoder)
798 case 108536:
799 return DecodeOxmIdTunMetadata43Masked(_oxmid, decoder)
800 case 126980:
801 return DecodeOxmIdConnTrackingNwSrc(_oxmid, decoder)
802 default:
803 return _oxmid, nil
804 }
805}
806
807func NewOxmId(_type_len uint32) *OxmId {
808 obj := &OxmId{}
809 obj.TypeLen = _type_len
810 return obj
811}
812func (self *OxmId) GetOXMName() string {
813 return ""
814}
815
816func (self *OxmId) MarshalJSON() ([]byte, error) {
817 if self.TypeLen == 0 {
818 return []byte("\"\""), nil
819 } else {
820 return []byte("\"" + self.GetOXMName() + "\""), nil
821 }
822}
823
824type ActionNxBundleLoadSlave struct {
825 Port Port
826}
827
828type IActionNxBundleLoadSlave interface {
829 goloxi.Serializable
830 GetPort() Port
831}
832
833func (self *ActionNxBundleLoadSlave) GetPort() Port {
834 return self.Port
835}
836
837func (self *ActionNxBundleLoadSlave) SetPort(v Port) {
838 self.Port = v
839}
840
841func (self *ActionNxBundleLoadSlave) Serialize(encoder *goloxi.Encoder) error {
842
843 encoder.PutUint32(uint32(self.Port))
844
845 return nil
846}
847
848func DecodeActionNxBundleLoadSlave(decoder *goloxi.Decoder) (*ActionNxBundleLoadSlave, error) {
849 _actionnxbundleloadslave := &ActionNxBundleLoadSlave{}
850 if decoder.Length() < 4 {
851 return nil, fmt.Errorf("ActionNxBundleLoadSlave packet too short: %d < 4", decoder.Length())
852 }
853 _actionnxbundleloadslave.Port = Port(decoder.ReadUint32())
854 return _actionnxbundleloadslave, nil
855}
856
857func NewActionNxBundleLoadSlave() *ActionNxBundleLoadSlave {
858 obj := &ActionNxBundleLoadSlave{}
859 return obj
860}
861
862type ActionNxController2Property struct {
863 Type NxActionController2PropType
864}
865
866type IActionNxController2Property interface {
867 goloxi.Serializable
868 GetType() NxActionController2PropType
869}
870
871func (self *ActionNxController2Property) GetType() NxActionController2PropType {
872 return self.Type
873}
874
875func (self *ActionNxController2Property) SetType(v NxActionController2PropType) {
876 self.Type = v
877}
878
879func (self *ActionNxController2Property) Serialize(encoder *goloxi.Encoder) error {
880
881 encoder.PutUint16(uint16(self.Type))
882
883 return nil
884}
885
886func DecodeActionNxController2Property(decoder *goloxi.Decoder) (IActionNxController2Property, error) {
887 _actionnxcontroller2property := &ActionNxController2Property{}
888 if decoder.Length() < 2 {
889 return nil, fmt.Errorf("ActionNxController2Property packet too short: %d < 2", decoder.Length())
890 }
891 _actionnxcontroller2property.Type = NxActionController2PropType(decoder.ReadUint16())
892
893 switch _actionnxcontroller2property.Type {
894 case 0:
895 return DecodeActionNxController2PropertyMaxLen(_actionnxcontroller2property, decoder)
896 case 1:
897 return DecodeActionNxController2PropertyControllerId(_actionnxcontroller2property, decoder)
898 case 2:
899 return DecodeActionNxController2PropertyReason(_actionnxcontroller2property, decoder)
900 case 3:
901 return DecodeActionNxController2PropertyUserdata(_actionnxcontroller2property, decoder)
902 case 4:
903 return DecodeActionNxController2PropertyPause(_actionnxcontroller2property, decoder)
904 case 5:
905 return DecodeActionNxController2PropertyMeterId(_actionnxcontroller2property, decoder)
906 default:
907 return nil, fmt.Errorf("Invalid type '%d' for 'ActionNxController2Property'", _actionnxcontroller2property.Type)
908 }
909}
910
911func NewActionNxController2Property(_type NxActionController2PropType) *ActionNxController2Property {
912 obj := &ActionNxController2Property{}
913 obj.Type = _type
914 return obj
915}
916
917type ActionNxController2PropertyControllerId struct {
918 *ActionNxController2Property
919 ControllerId uint16
920}
921
922type IActionNxController2PropertyControllerId interface {
923 IActionNxController2Property
924 GetControllerId() uint16
925}
926
927func (self *ActionNxController2PropertyControllerId) GetControllerId() uint16 {
928 return self.ControllerId
929}
930
931func (self *ActionNxController2PropertyControllerId) SetControllerId(v uint16) {
932 self.ControllerId = v
933}
934
935func (self *ActionNxController2PropertyControllerId) Serialize(encoder *goloxi.Encoder) error {
936 startIndex := len(encoder.Bytes())
937 if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
938 return err
939 }
940
941 encoder.PutUint16(uint16(self.ControllerId))
942 length := len(encoder.Bytes()) - startIndex
943 alignedLength := ((length + 7) / 8 * 8)
944
945 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
946
947 return nil
948}
949
950func DecodeActionNxController2PropertyControllerId(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyControllerId, error) {
951 _actionnxcontroller2propertycontrollerid := &ActionNxController2PropertyControllerId{ActionNxController2Property: parent}
952 if decoder.Length() < 2 {
953 return nil, fmt.Errorf("ActionNxController2PropertyControllerId packet too short: %d < 2", decoder.Length())
954 }
955 defer decoder.SkipAlign()
956
957 _actionnxcontroller2propertycontrollerid.ControllerId = uint16(decoder.ReadUint16())
958 return _actionnxcontroller2propertycontrollerid, nil
959}
960
961func NewActionNxController2PropertyControllerId() *ActionNxController2PropertyControllerId {
962 obj := &ActionNxController2PropertyControllerId{
963 ActionNxController2Property: NewActionNxController2Property(1),
964 }
965 return obj
966}
967
968type ActionNxController2PropertyMaxLen struct {
969 *ActionNxController2Property
970 MaxLen uint16
971}
972
973type IActionNxController2PropertyMaxLen interface {
974 IActionNxController2Property
975 GetMaxLen() uint16
976}
977
978func (self *ActionNxController2PropertyMaxLen) GetMaxLen() uint16 {
979 return self.MaxLen
980}
981
982func (self *ActionNxController2PropertyMaxLen) SetMaxLen(v uint16) {
983 self.MaxLen = v
984}
985
986func (self *ActionNxController2PropertyMaxLen) Serialize(encoder *goloxi.Encoder) error {
987 startIndex := len(encoder.Bytes())
988 if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
989 return err
990 }
991
992 encoder.PutUint16(uint16(self.MaxLen))
993 length := len(encoder.Bytes()) - startIndex
994 alignedLength := ((length + 7) / 8 * 8)
995
996 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
997
998 return nil
999}
1000
1001func DecodeActionNxController2PropertyMaxLen(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyMaxLen, error) {
1002 _actionnxcontroller2propertymaxlen := &ActionNxController2PropertyMaxLen{ActionNxController2Property: parent}
1003 if decoder.Length() < 2 {
1004 return nil, fmt.Errorf("ActionNxController2PropertyMaxLen packet too short: %d < 2", decoder.Length())
1005 }
1006 defer decoder.SkipAlign()
1007
1008 _actionnxcontroller2propertymaxlen.MaxLen = uint16(decoder.ReadUint16())
1009 return _actionnxcontroller2propertymaxlen, nil
1010}
1011
1012func NewActionNxController2PropertyMaxLen() *ActionNxController2PropertyMaxLen {
1013 obj := &ActionNxController2PropertyMaxLen{
1014 ActionNxController2Property: NewActionNxController2Property(0),
1015 }
1016 return obj
1017}
1018
1019type ActionNxController2PropertyMeterId struct {
1020 *ActionNxController2Property
1021 MeterId uint32
1022}
1023
1024type IActionNxController2PropertyMeterId interface {
1025 IActionNxController2Property
1026 GetMeterId() uint32
1027}
1028
1029func (self *ActionNxController2PropertyMeterId) GetMeterId() uint32 {
1030 return self.MeterId
1031}
1032
1033func (self *ActionNxController2PropertyMeterId) SetMeterId(v uint32) {
1034 self.MeterId = v
1035}
1036
1037func (self *ActionNxController2PropertyMeterId) Serialize(encoder *goloxi.Encoder) error {
1038 startIndex := len(encoder.Bytes())
1039 if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
1040 return err
1041 }
1042
1043 encoder.PutUint32(uint32(self.MeterId))
1044 length := len(encoder.Bytes()) - startIndex
1045 alignedLength := ((length + 7) / 8 * 8)
1046
1047 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
1048
1049 return nil
1050}
1051
1052func DecodeActionNxController2PropertyMeterId(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyMeterId, error) {
1053 _actionnxcontroller2propertymeterid := &ActionNxController2PropertyMeterId{ActionNxController2Property: parent}
1054 if decoder.Length() < 4 {
1055 return nil, fmt.Errorf("ActionNxController2PropertyMeterId packet too short: %d < 4", decoder.Length())
1056 }
1057 defer decoder.SkipAlign()
1058
1059 _actionnxcontroller2propertymeterid.MeterId = uint32(decoder.ReadUint32())
1060 return _actionnxcontroller2propertymeterid, nil
1061}
1062
1063func NewActionNxController2PropertyMeterId() *ActionNxController2PropertyMeterId {
1064 obj := &ActionNxController2PropertyMeterId{
1065 ActionNxController2Property: NewActionNxController2Property(5),
1066 }
1067 return obj
1068}
1069
1070type ActionNxController2PropertyPause struct {
1071 *ActionNxController2Property
1072}
1073
1074type IActionNxController2PropertyPause interface {
1075 IActionNxController2Property
1076}
1077
1078func (self *ActionNxController2PropertyPause) Serialize(encoder *goloxi.Encoder) error {
1079 startIndex := len(encoder.Bytes())
1080 if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
1081 return err
1082 }
1083 length := len(encoder.Bytes()) - startIndex
1084 alignedLength := ((length + 7) / 8 * 8)
1085
1086 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
1087
1088 return nil
1089}
1090
1091func DecodeActionNxController2PropertyPause(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyPause, error) {
1092 _actionnxcontroller2propertypause := &ActionNxController2PropertyPause{ActionNxController2Property: parent}
1093 defer decoder.SkipAlign()
1094
1095 return _actionnxcontroller2propertypause, nil
1096}
1097
1098func NewActionNxController2PropertyPause() *ActionNxController2PropertyPause {
1099 obj := &ActionNxController2PropertyPause{
1100 ActionNxController2Property: NewActionNxController2Property(4),
1101 }
1102 return obj
1103}
1104
1105type ActionNxController2PropertyReason struct {
1106 *ActionNxController2Property
1107 Reason PacketInReason
1108}
1109
1110type IActionNxController2PropertyReason interface {
1111 IActionNxController2Property
1112 GetReason() PacketInReason
1113}
1114
1115func (self *ActionNxController2PropertyReason) GetReason() PacketInReason {
1116 return self.Reason
1117}
1118
1119func (self *ActionNxController2PropertyReason) SetReason(v PacketInReason) {
1120 self.Reason = v
1121}
1122
1123func (self *ActionNxController2PropertyReason) Serialize(encoder *goloxi.Encoder) error {
1124 startIndex := len(encoder.Bytes())
1125 if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
1126 return err
1127 }
1128
1129 encoder.PutUint8(uint8(self.Reason))
1130 length := len(encoder.Bytes()) - startIndex
1131 alignedLength := ((length + 7) / 8 * 8)
1132
1133 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
1134
1135 return nil
1136}
1137
1138func DecodeActionNxController2PropertyReason(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyReason, error) {
1139 _actionnxcontroller2propertyreason := &ActionNxController2PropertyReason{ActionNxController2Property: parent}
1140 if decoder.Length() < 1 {
1141 return nil, fmt.Errorf("ActionNxController2PropertyReason packet too short: %d < 1", decoder.Length())
1142 }
1143 defer decoder.SkipAlign()
1144
1145 _actionnxcontroller2propertyreason.Reason = PacketInReason(decoder.ReadByte())
1146 return _actionnxcontroller2propertyreason, nil
1147}
1148
1149func NewActionNxController2PropertyReason() *ActionNxController2PropertyReason {
1150 obj := &ActionNxController2PropertyReason{
1151 ActionNxController2Property: NewActionNxController2Property(2),
1152 }
1153 return obj
1154}
1155
1156type ActionNxController2PropertyUserdata struct {
1157 *ActionNxController2Property
1158 Length uint16
1159 Userdata []byte
1160}
1161
1162type IActionNxController2PropertyUserdata interface {
1163 IActionNxController2Property
1164 GetLength() uint16
1165 GetUserdata() []byte
1166}
1167
1168func (self *ActionNxController2PropertyUserdata) GetLength() uint16 {
1169 return self.Length
1170}
1171
1172func (self *ActionNxController2PropertyUserdata) SetLength(v uint16) {
1173 self.Length = v
1174}
1175
1176func (self *ActionNxController2PropertyUserdata) GetUserdata() []byte {
1177 return self.Userdata
1178}
1179
1180func (self *ActionNxController2PropertyUserdata) SetUserdata(v []byte) {
1181 self.Userdata = v
1182}
1183
1184func (self *ActionNxController2PropertyUserdata) Serialize(encoder *goloxi.Encoder) error {
1185 startIndex := len(encoder.Bytes())
1186 if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
1187 return err
1188 }
1189
1190 encoder.PutUint16(uint16(self.Length))
1191 encoder.Write(self.Userdata)
1192 length := len(encoder.Bytes()) - startIndex
1193 alignedLength := ((length + 7) / 8 * 8)
1194
1195 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1196
1197 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
1198
1199 return nil
1200}
1201
1202func DecodeActionNxController2PropertyUserdata(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyUserdata, error) {
1203 _actionnxcontroller2propertyuserdata := &ActionNxController2PropertyUserdata{ActionNxController2Property: parent}
1204 if decoder.Length() < 2 {
1205 return nil, fmt.Errorf("ActionNxController2PropertyUserdata packet too short: %d < 2", decoder.Length())
1206 }
1207 defer decoder.SkipAlign()
1208
1209 _actionnxcontroller2propertyuserdata.Length = uint16(decoder.ReadUint16())
1210 oldDecoder := decoder
1211 defer func() { decoder = oldDecoder }()
1212 decoder = decoder.SliceDecoder(int(((_actionnxcontroller2propertyuserdata.Length)+7)/8*8), 2+2)
1213 _actionnxcontroller2propertyuserdata.Userdata = decoder.Read(int(decoder.Length()))
1214 return _actionnxcontroller2propertyuserdata, nil
1215}
1216
1217func NewActionNxController2PropertyUserdata() *ActionNxController2PropertyUserdata {
1218 obj := &ActionNxController2PropertyUserdata{
1219 ActionNxController2Property: NewActionNxController2Property(3),
1220 }
1221 return obj
1222}
1223
1224type AsyncConfigProp struct {
1225 Type uint16
1226 Length uint16
1227}
1228
1229type IAsyncConfigProp interface {
1230 goloxi.Serializable
1231 GetType() uint16
1232 GetLength() uint16
1233}
1234
1235func (self *AsyncConfigProp) GetType() uint16 {
1236 return self.Type
1237}
1238
1239func (self *AsyncConfigProp) SetType(v uint16) {
1240 self.Type = v
1241}
1242
1243func (self *AsyncConfigProp) GetLength() uint16 {
1244 return self.Length
1245}
1246
1247func (self *AsyncConfigProp) SetLength(v uint16) {
1248 self.Length = v
1249}
1250
1251func (self *AsyncConfigProp) Serialize(encoder *goloxi.Encoder) error {
1252
1253 encoder.PutUint16(uint16(self.Type))
1254 encoder.PutUint16(uint16(self.Length))
1255
1256 return nil
1257}
1258
1259func DecodeAsyncConfigProp(decoder *goloxi.Decoder) (IAsyncConfigProp, error) {
1260 _asyncconfigprop := &AsyncConfigProp{}
1261 if decoder.Length() < 4 {
1262 return nil, fmt.Errorf("AsyncConfigProp packet too short: %d < 4", decoder.Length())
1263 }
1264 _asyncconfigprop.Type = uint16(decoder.ReadUint16())
1265 _asyncconfigprop.Length = uint16(decoder.ReadUint16())
1266 oldDecoder := decoder
1267 defer func() { decoder = oldDecoder }()
1268 decoder = decoder.SliceDecoder(int(_asyncconfigprop.Length), 2+2)
1269
1270 switch _asyncconfigprop.Type {
1271 case 0:
1272 return DecodeAsyncConfigPropPacketInSlave(_asyncconfigprop, decoder)
1273 case 1:
1274 return DecodeAsyncConfigPropPacketInMaster(_asyncconfigprop, decoder)
1275 case 2:
1276 return DecodeAsyncConfigPropPortStatusSlave(_asyncconfigprop, decoder)
1277 case 3:
1278 return DecodeAsyncConfigPropPortStatusMaster(_asyncconfigprop, decoder)
1279 case 4:
1280 return DecodeAsyncConfigPropFlowRemovedSlave(_asyncconfigprop, decoder)
1281 case 5:
1282 return DecodeAsyncConfigPropFlowRemovedMaster(_asyncconfigprop, decoder)
1283 case 6:
1284 return DecodeAsyncConfigPropRoleStatusSlave(_asyncconfigprop, decoder)
1285 case 7:
1286 return DecodeAsyncConfigPropRoleStatusMaster(_asyncconfigprop, decoder)
1287 case 8:
1288 return DecodeAsyncConfigPropTableStatusSlave(_asyncconfigprop, decoder)
1289 case 9:
1290 return DecodeAsyncConfigPropTableStatusMaster(_asyncconfigprop, decoder)
1291 case 10:
1292 return DecodeAsyncConfigPropRequestforwardSlave(_asyncconfigprop, decoder)
1293 case 11:
1294 return DecodeAsyncConfigPropRequestforwardMaster(_asyncconfigprop, decoder)
1295 case 12:
1296 return DecodeAsyncConfigPropFlowStatsSlave(_asyncconfigprop, decoder)
1297 case 13:
1298 return DecodeAsyncConfigPropFlowStatsMaster(_asyncconfigprop, decoder)
1299 case 14:
1300 return DecodeAsyncConfigPropContStatusSlave(_asyncconfigprop, decoder)
1301 case 15:
1302 return DecodeAsyncConfigPropContStatusMaster(_asyncconfigprop, decoder)
1303 case 65534:
1304 return DecodeAsyncConfigPropExperimenterSlave(_asyncconfigprop, decoder)
1305 case 65535:
1306 return DecodeAsyncConfigPropExperimenterMaster(_asyncconfigprop, decoder)
1307 default:
1308 return nil, fmt.Errorf("Invalid type '%d' for 'AsyncConfigProp'", _asyncconfigprop.Type)
1309 }
1310}
1311
1312func NewAsyncConfigProp(_type uint16) *AsyncConfigProp {
1313 obj := &AsyncConfigProp{}
1314 obj.Type = _type
1315 return obj
1316}
1317
1318type AsyncConfigPropContStatusMaster struct {
1319 *AsyncConfigProp
1320 Mask uint32
1321}
1322
1323type IAsyncConfigPropContStatusMaster interface {
1324 IAsyncConfigProp
1325 GetMask() uint32
1326}
1327
1328func (self *AsyncConfigPropContStatusMaster) GetMask() uint32 {
1329 return self.Mask
1330}
1331
1332func (self *AsyncConfigPropContStatusMaster) SetMask(v uint32) {
1333 self.Mask = v
1334}
1335
1336func (self *AsyncConfigPropContStatusMaster) Serialize(encoder *goloxi.Encoder) error {
1337 startIndex := len(encoder.Bytes())
1338 if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
1339 return err
1340 }
1341
1342 encoder.PutUint32(uint32(self.Mask))
1343 length := len(encoder.Bytes()) - startIndex
1344
1345 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1346
1347 return nil
1348}
1349
1350func DecodeAsyncConfigPropContStatusMaster(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropContStatusMaster, error) {
1351 _asyncconfigpropcontstatusmaster := &AsyncConfigPropContStatusMaster{AsyncConfigProp: parent}
1352 if decoder.Length() < 4 {
1353 return nil, fmt.Errorf("AsyncConfigPropContStatusMaster packet too short: %d < 4", decoder.Length())
1354 }
1355 _asyncconfigpropcontstatusmaster.Mask = uint32(decoder.ReadUint32())
1356 return _asyncconfigpropcontstatusmaster, nil
1357}
1358
1359func NewAsyncConfigPropContStatusMaster() *AsyncConfigPropContStatusMaster {
1360 obj := &AsyncConfigPropContStatusMaster{
1361 AsyncConfigProp: NewAsyncConfigProp(15),
1362 }
1363 return obj
1364}
1365
1366type AsyncConfigPropContStatusSlave struct {
1367 *AsyncConfigProp
1368 Mask uint32
1369}
1370
1371type IAsyncConfigPropContStatusSlave interface {
1372 IAsyncConfigProp
1373 GetMask() uint32
1374}
1375
1376func (self *AsyncConfigPropContStatusSlave) GetMask() uint32 {
1377 return self.Mask
1378}
1379
1380func (self *AsyncConfigPropContStatusSlave) SetMask(v uint32) {
1381 self.Mask = v
1382}
1383
1384func (self *AsyncConfigPropContStatusSlave) Serialize(encoder *goloxi.Encoder) error {
1385 startIndex := len(encoder.Bytes())
1386 if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
1387 return err
1388 }
1389
1390 encoder.PutUint32(uint32(self.Mask))
1391 length := len(encoder.Bytes()) - startIndex
1392
1393 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1394
1395 return nil
1396}
1397
1398func DecodeAsyncConfigPropContStatusSlave(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropContStatusSlave, error) {
1399 _asyncconfigpropcontstatusslave := &AsyncConfigPropContStatusSlave{AsyncConfigProp: parent}
1400 if decoder.Length() < 4 {
1401 return nil, fmt.Errorf("AsyncConfigPropContStatusSlave packet too short: %d < 4", decoder.Length())
1402 }
1403 _asyncconfigpropcontstatusslave.Mask = uint32(decoder.ReadUint32())
1404 return _asyncconfigpropcontstatusslave, nil
1405}
1406
1407func NewAsyncConfigPropContStatusSlave() *AsyncConfigPropContStatusSlave {
1408 obj := &AsyncConfigPropContStatusSlave{
1409 AsyncConfigProp: NewAsyncConfigProp(14),
1410 }
1411 return obj
1412}
1413
1414type AsyncConfigPropExperimenterMaster struct {
1415 *AsyncConfigProp
1416}
1417
1418type IAsyncConfigPropExperimenterMaster interface {
1419 IAsyncConfigProp
1420}
1421
1422func (self *AsyncConfigPropExperimenterMaster) Serialize(encoder *goloxi.Encoder) error {
1423 startIndex := len(encoder.Bytes())
1424 if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
1425 return err
1426 }
1427 length := len(encoder.Bytes()) - startIndex
1428
1429 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1430
1431 return nil
1432}
1433
1434func DecodeAsyncConfigPropExperimenterMaster(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropExperimenterMaster, error) {
1435 _asyncconfigpropexperimentermaster := &AsyncConfigPropExperimenterMaster{AsyncConfigProp: parent}
1436 return _asyncconfigpropexperimentermaster, nil
1437}
1438
1439func NewAsyncConfigPropExperimenterMaster() *AsyncConfigPropExperimenterMaster {
1440 obj := &AsyncConfigPropExperimenterMaster{
1441 AsyncConfigProp: NewAsyncConfigProp(65535),
1442 }
1443 return obj
1444}
1445
1446type AsyncConfigPropExperimenterSlave struct {
1447 *AsyncConfigProp
1448}
1449
1450type IAsyncConfigPropExperimenterSlave interface {
1451 IAsyncConfigProp
1452}
1453
1454func (self *AsyncConfigPropExperimenterSlave) Serialize(encoder *goloxi.Encoder) error {
1455 startIndex := len(encoder.Bytes())
1456 if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
1457 return err
1458 }
1459 length := len(encoder.Bytes()) - startIndex
1460
1461 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1462
1463 return nil
1464}
1465
1466func DecodeAsyncConfigPropExperimenterSlave(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropExperimenterSlave, error) {
1467 _asyncconfigpropexperimenterslave := &AsyncConfigPropExperimenterSlave{AsyncConfigProp: parent}
1468 return _asyncconfigpropexperimenterslave, nil
1469}
1470
1471func NewAsyncConfigPropExperimenterSlave() *AsyncConfigPropExperimenterSlave {
1472 obj := &AsyncConfigPropExperimenterSlave{
1473 AsyncConfigProp: NewAsyncConfigProp(65534),
1474 }
1475 return obj
1476}
1477
1478type AsyncConfigPropFlowRemovedMaster struct {
1479 *AsyncConfigProp
1480 Mask uint32
1481}
1482
1483type IAsyncConfigPropFlowRemovedMaster interface {
1484 IAsyncConfigProp
1485 GetMask() uint32
1486}
1487
1488func (self *AsyncConfigPropFlowRemovedMaster) GetMask() uint32 {
1489 return self.Mask
1490}
1491
1492func (self *AsyncConfigPropFlowRemovedMaster) SetMask(v uint32) {
1493 self.Mask = v
1494}
1495
1496func (self *AsyncConfigPropFlowRemovedMaster) Serialize(encoder *goloxi.Encoder) error {
1497 startIndex := len(encoder.Bytes())
1498 if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
1499 return err
1500 }
1501
1502 encoder.PutUint32(uint32(self.Mask))
1503 length := len(encoder.Bytes()) - startIndex
1504
1505 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1506
1507 return nil
1508}
1509
1510func DecodeAsyncConfigPropFlowRemovedMaster(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropFlowRemovedMaster, error) {
1511 _asyncconfigpropflowremovedmaster := &AsyncConfigPropFlowRemovedMaster{AsyncConfigProp: parent}
1512 if decoder.Length() < 4 {
1513 return nil, fmt.Errorf("AsyncConfigPropFlowRemovedMaster packet too short: %d < 4", decoder.Length())
1514 }
1515 _asyncconfigpropflowremovedmaster.Mask = uint32(decoder.ReadUint32())
1516 return _asyncconfigpropflowremovedmaster, nil
1517}
1518
1519func NewAsyncConfigPropFlowRemovedMaster() *AsyncConfigPropFlowRemovedMaster {
1520 obj := &AsyncConfigPropFlowRemovedMaster{
1521 AsyncConfigProp: NewAsyncConfigProp(5),
1522 }
1523 return obj
1524}
1525
1526type AsyncConfigPropFlowRemovedSlave struct {
1527 *AsyncConfigProp
1528 Mask uint32
1529}
1530
1531type IAsyncConfigPropFlowRemovedSlave interface {
1532 IAsyncConfigProp
1533 GetMask() uint32
1534}
1535
1536func (self *AsyncConfigPropFlowRemovedSlave) GetMask() uint32 {
1537 return self.Mask
1538}
1539
1540func (self *AsyncConfigPropFlowRemovedSlave) SetMask(v uint32) {
1541 self.Mask = v
1542}
1543
1544func (self *AsyncConfigPropFlowRemovedSlave) Serialize(encoder *goloxi.Encoder) error {
1545 startIndex := len(encoder.Bytes())
1546 if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
1547 return err
1548 }
1549
1550 encoder.PutUint32(uint32(self.Mask))
1551 length := len(encoder.Bytes()) - startIndex
1552
1553 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1554
1555 return nil
1556}
1557
1558func DecodeAsyncConfigPropFlowRemovedSlave(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropFlowRemovedSlave, error) {
1559 _asyncconfigpropflowremovedslave := &AsyncConfigPropFlowRemovedSlave{AsyncConfigProp: parent}
1560 if decoder.Length() < 4 {
1561 return nil, fmt.Errorf("AsyncConfigPropFlowRemovedSlave packet too short: %d < 4", decoder.Length())
1562 }
1563 _asyncconfigpropflowremovedslave.Mask = uint32(decoder.ReadUint32())
1564 return _asyncconfigpropflowremovedslave, nil
1565}
1566
1567func NewAsyncConfigPropFlowRemovedSlave() *AsyncConfigPropFlowRemovedSlave {
1568 obj := &AsyncConfigPropFlowRemovedSlave{
1569 AsyncConfigProp: NewAsyncConfigProp(4),
1570 }
1571 return obj
1572}
1573
1574type AsyncConfigPropFlowStatsMaster struct {
1575 *AsyncConfigProp
1576 Mask uint32
1577}
1578
1579type IAsyncConfigPropFlowStatsMaster interface {
1580 IAsyncConfigProp
1581 GetMask() uint32
1582}
1583
1584func (self *AsyncConfigPropFlowStatsMaster) GetMask() uint32 {
1585 return self.Mask
1586}
1587
1588func (self *AsyncConfigPropFlowStatsMaster) SetMask(v uint32) {
1589 self.Mask = v
1590}
1591
1592func (self *AsyncConfigPropFlowStatsMaster) Serialize(encoder *goloxi.Encoder) error {
1593 startIndex := len(encoder.Bytes())
1594 if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
1595 return err
1596 }
1597
1598 encoder.PutUint32(uint32(self.Mask))
1599 length := len(encoder.Bytes()) - startIndex
1600
1601 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1602
1603 return nil
1604}
1605
1606func DecodeAsyncConfigPropFlowStatsMaster(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropFlowStatsMaster, error) {
1607 _asyncconfigpropflowstatsmaster := &AsyncConfigPropFlowStatsMaster{AsyncConfigProp: parent}
1608 if decoder.Length() < 4 {
1609 return nil, fmt.Errorf("AsyncConfigPropFlowStatsMaster packet too short: %d < 4", decoder.Length())
1610 }
1611 _asyncconfigpropflowstatsmaster.Mask = uint32(decoder.ReadUint32())
1612 return _asyncconfigpropflowstatsmaster, nil
1613}
1614
1615func NewAsyncConfigPropFlowStatsMaster() *AsyncConfigPropFlowStatsMaster {
1616 obj := &AsyncConfigPropFlowStatsMaster{
1617 AsyncConfigProp: NewAsyncConfigProp(13),
1618 }
1619 return obj
1620}
1621
1622type AsyncConfigPropFlowStatsSlave struct {
1623 *AsyncConfigProp
1624 Mask uint32
1625}
1626
1627type IAsyncConfigPropFlowStatsSlave interface {
1628 IAsyncConfigProp
1629 GetMask() uint32
1630}
1631
1632func (self *AsyncConfigPropFlowStatsSlave) GetMask() uint32 {
1633 return self.Mask
1634}
1635
1636func (self *AsyncConfigPropFlowStatsSlave) SetMask(v uint32) {
1637 self.Mask = v
1638}
1639
1640func (self *AsyncConfigPropFlowStatsSlave) Serialize(encoder *goloxi.Encoder) error {
1641 startIndex := len(encoder.Bytes())
1642 if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
1643 return err
1644 }
1645
1646 encoder.PutUint32(uint32(self.Mask))
1647 length := len(encoder.Bytes()) - startIndex
1648
1649 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1650
1651 return nil
1652}
1653
1654func DecodeAsyncConfigPropFlowStatsSlave(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropFlowStatsSlave, error) {
1655 _asyncconfigpropflowstatsslave := &AsyncConfigPropFlowStatsSlave{AsyncConfigProp: parent}
1656 if decoder.Length() < 4 {
1657 return nil, fmt.Errorf("AsyncConfigPropFlowStatsSlave packet too short: %d < 4", decoder.Length())
1658 }
1659 _asyncconfigpropflowstatsslave.Mask = uint32(decoder.ReadUint32())
1660 return _asyncconfigpropflowstatsslave, nil
1661}
1662
1663func NewAsyncConfigPropFlowStatsSlave() *AsyncConfigPropFlowStatsSlave {
1664 obj := &AsyncConfigPropFlowStatsSlave{
1665 AsyncConfigProp: NewAsyncConfigProp(12),
1666 }
1667 return obj
1668}
1669
1670type AsyncConfigPropPacketInMaster struct {
1671 *AsyncConfigProp
1672 Mask uint32
1673}
1674
1675type IAsyncConfigPropPacketInMaster interface {
1676 IAsyncConfigProp
1677 GetMask() uint32
1678}
1679
1680func (self *AsyncConfigPropPacketInMaster) GetMask() uint32 {
1681 return self.Mask
1682}
1683
1684func (self *AsyncConfigPropPacketInMaster) SetMask(v uint32) {
1685 self.Mask = v
1686}
1687
1688func (self *AsyncConfigPropPacketInMaster) Serialize(encoder *goloxi.Encoder) error {
1689 startIndex := len(encoder.Bytes())
1690 if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
1691 return err
1692 }
1693
1694 encoder.PutUint32(uint32(self.Mask))
1695 length := len(encoder.Bytes()) - startIndex
1696
1697 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1698
1699 return nil
1700}
1701
1702func DecodeAsyncConfigPropPacketInMaster(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropPacketInMaster, error) {
1703 _asyncconfigproppacketinmaster := &AsyncConfigPropPacketInMaster{AsyncConfigProp: parent}
1704 if decoder.Length() < 4 {
1705 return nil, fmt.Errorf("AsyncConfigPropPacketInMaster packet too short: %d < 4", decoder.Length())
1706 }
1707 _asyncconfigproppacketinmaster.Mask = uint32(decoder.ReadUint32())
1708 return _asyncconfigproppacketinmaster, nil
1709}
1710
1711func NewAsyncConfigPropPacketInMaster() *AsyncConfigPropPacketInMaster {
1712 obj := &AsyncConfigPropPacketInMaster{
1713 AsyncConfigProp: NewAsyncConfigProp(1),
1714 }
1715 return obj
1716}
1717
1718type AsyncConfigPropPacketInSlave struct {
1719 *AsyncConfigProp
1720 Mask uint32
1721}
1722
1723type IAsyncConfigPropPacketInSlave interface {
1724 IAsyncConfigProp
1725 GetMask() uint32
1726}
1727
1728func (self *AsyncConfigPropPacketInSlave) GetMask() uint32 {
1729 return self.Mask
1730}
1731
1732func (self *AsyncConfigPropPacketInSlave) SetMask(v uint32) {
1733 self.Mask = v
1734}
1735
1736func (self *AsyncConfigPropPacketInSlave) Serialize(encoder *goloxi.Encoder) error {
1737 startIndex := len(encoder.Bytes())
1738 if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
1739 return err
1740 }
1741
1742 encoder.PutUint32(uint32(self.Mask))
1743 length := len(encoder.Bytes()) - startIndex
1744
1745 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1746
1747 return nil
1748}
1749
1750func DecodeAsyncConfigPropPacketInSlave(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropPacketInSlave, error) {
1751 _asyncconfigproppacketinslave := &AsyncConfigPropPacketInSlave{AsyncConfigProp: parent}
1752 if decoder.Length() < 4 {
1753 return nil, fmt.Errorf("AsyncConfigPropPacketInSlave packet too short: %d < 4", decoder.Length())
1754 }
1755 _asyncconfigproppacketinslave.Mask = uint32(decoder.ReadUint32())
1756 return _asyncconfigproppacketinslave, nil
1757}
1758
1759func NewAsyncConfigPropPacketInSlave() *AsyncConfigPropPacketInSlave {
1760 obj := &AsyncConfigPropPacketInSlave{
1761 AsyncConfigProp: NewAsyncConfigProp(0),
1762 }
1763 return obj
1764}
1765
1766type AsyncConfigPropPortStatusMaster struct {
1767 *AsyncConfigProp
1768 Mask uint32
1769}
1770
1771type IAsyncConfigPropPortStatusMaster interface {
1772 IAsyncConfigProp
1773 GetMask() uint32
1774}
1775
1776func (self *AsyncConfigPropPortStatusMaster) GetMask() uint32 {
1777 return self.Mask
1778}
1779
1780func (self *AsyncConfigPropPortStatusMaster) SetMask(v uint32) {
1781 self.Mask = v
1782}
1783
1784func (self *AsyncConfigPropPortStatusMaster) Serialize(encoder *goloxi.Encoder) error {
1785 startIndex := len(encoder.Bytes())
1786 if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
1787 return err
1788 }
1789
1790 encoder.PutUint32(uint32(self.Mask))
1791 length := len(encoder.Bytes()) - startIndex
1792
1793 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1794
1795 return nil
1796}
1797
1798func DecodeAsyncConfigPropPortStatusMaster(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropPortStatusMaster, error) {
1799 _asyncconfigpropportstatusmaster := &AsyncConfigPropPortStatusMaster{AsyncConfigProp: parent}
1800 if decoder.Length() < 4 {
1801 return nil, fmt.Errorf("AsyncConfigPropPortStatusMaster packet too short: %d < 4", decoder.Length())
1802 }
1803 _asyncconfigpropportstatusmaster.Mask = uint32(decoder.ReadUint32())
1804 return _asyncconfigpropportstatusmaster, nil
1805}
1806
1807func NewAsyncConfigPropPortStatusMaster() *AsyncConfigPropPortStatusMaster {
1808 obj := &AsyncConfigPropPortStatusMaster{
1809 AsyncConfigProp: NewAsyncConfigProp(3),
1810 }
1811 return obj
1812}
1813
1814type AsyncConfigPropPortStatusSlave struct {
1815 *AsyncConfigProp
1816 Mask uint32
1817}
1818
1819type IAsyncConfigPropPortStatusSlave interface {
1820 IAsyncConfigProp
1821 GetMask() uint32
1822}
1823
1824func (self *AsyncConfigPropPortStatusSlave) GetMask() uint32 {
1825 return self.Mask
1826}
1827
1828func (self *AsyncConfigPropPortStatusSlave) SetMask(v uint32) {
1829 self.Mask = v
1830}
1831
1832func (self *AsyncConfigPropPortStatusSlave) Serialize(encoder *goloxi.Encoder) error {
1833 startIndex := len(encoder.Bytes())
1834 if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
1835 return err
1836 }
1837
1838 encoder.PutUint32(uint32(self.Mask))
1839 length := len(encoder.Bytes()) - startIndex
1840
1841 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1842
1843 return nil
1844}
1845
1846func DecodeAsyncConfigPropPortStatusSlave(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropPortStatusSlave, error) {
1847 _asyncconfigpropportstatusslave := &AsyncConfigPropPortStatusSlave{AsyncConfigProp: parent}
1848 if decoder.Length() < 4 {
1849 return nil, fmt.Errorf("AsyncConfigPropPortStatusSlave packet too short: %d < 4", decoder.Length())
1850 }
1851 _asyncconfigpropportstatusslave.Mask = uint32(decoder.ReadUint32())
1852 return _asyncconfigpropportstatusslave, nil
1853}
1854
1855func NewAsyncConfigPropPortStatusSlave() *AsyncConfigPropPortStatusSlave {
1856 obj := &AsyncConfigPropPortStatusSlave{
1857 AsyncConfigProp: NewAsyncConfigProp(2),
1858 }
1859 return obj
1860}
1861
1862type AsyncConfigPropRequestforwardMaster struct {
1863 *AsyncConfigProp
1864 Mask uint32
1865}
1866
1867type IAsyncConfigPropRequestforwardMaster interface {
1868 IAsyncConfigProp
1869 GetMask() uint32
1870}
1871
1872func (self *AsyncConfigPropRequestforwardMaster) GetMask() uint32 {
1873 return self.Mask
1874}
1875
1876func (self *AsyncConfigPropRequestforwardMaster) SetMask(v uint32) {
1877 self.Mask = v
1878}
1879
1880func (self *AsyncConfigPropRequestforwardMaster) Serialize(encoder *goloxi.Encoder) error {
1881 startIndex := len(encoder.Bytes())
1882 if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
1883 return err
1884 }
1885
1886 encoder.PutUint32(uint32(self.Mask))
1887 length := len(encoder.Bytes()) - startIndex
1888
1889 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1890
1891 return nil
1892}
1893
1894func DecodeAsyncConfigPropRequestforwardMaster(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropRequestforwardMaster, error) {
1895 _asyncconfigproprequestforwardmaster := &AsyncConfigPropRequestforwardMaster{AsyncConfigProp: parent}
1896 if decoder.Length() < 4 {
1897 return nil, fmt.Errorf("AsyncConfigPropRequestforwardMaster packet too short: %d < 4", decoder.Length())
1898 }
1899 _asyncconfigproprequestforwardmaster.Mask = uint32(decoder.ReadUint32())
1900 return _asyncconfigproprequestforwardmaster, nil
1901}
1902
1903func NewAsyncConfigPropRequestforwardMaster() *AsyncConfigPropRequestforwardMaster {
1904 obj := &AsyncConfigPropRequestforwardMaster{
1905 AsyncConfigProp: NewAsyncConfigProp(11),
1906 }
1907 return obj
1908}
1909
1910type AsyncConfigPropRequestforwardSlave struct {
1911 *AsyncConfigProp
1912 Mask uint32
1913}
1914
1915type IAsyncConfigPropRequestforwardSlave interface {
1916 IAsyncConfigProp
1917 GetMask() uint32
1918}
1919
1920func (self *AsyncConfigPropRequestforwardSlave) GetMask() uint32 {
1921 return self.Mask
1922}
1923
1924func (self *AsyncConfigPropRequestforwardSlave) SetMask(v uint32) {
1925 self.Mask = v
1926}
1927
1928func (self *AsyncConfigPropRequestforwardSlave) Serialize(encoder *goloxi.Encoder) error {
1929 startIndex := len(encoder.Bytes())
1930 if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
1931 return err
1932 }
1933
1934 encoder.PutUint32(uint32(self.Mask))
1935 length := len(encoder.Bytes()) - startIndex
1936
1937 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1938
1939 return nil
1940}
1941
1942func DecodeAsyncConfigPropRequestforwardSlave(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropRequestforwardSlave, error) {
1943 _asyncconfigproprequestforwardslave := &AsyncConfigPropRequestforwardSlave{AsyncConfigProp: parent}
1944 if decoder.Length() < 4 {
1945 return nil, fmt.Errorf("AsyncConfigPropRequestforwardSlave packet too short: %d < 4", decoder.Length())
1946 }
1947 _asyncconfigproprequestforwardslave.Mask = uint32(decoder.ReadUint32())
1948 return _asyncconfigproprequestforwardslave, nil
1949}
1950
1951func NewAsyncConfigPropRequestforwardSlave() *AsyncConfigPropRequestforwardSlave {
1952 obj := &AsyncConfigPropRequestforwardSlave{
1953 AsyncConfigProp: NewAsyncConfigProp(10),
1954 }
1955 return obj
1956}
1957
1958type AsyncConfigPropRoleStatusMaster struct {
1959 *AsyncConfigProp
1960 Mask uint32
1961}
1962
1963type IAsyncConfigPropRoleStatusMaster interface {
1964 IAsyncConfigProp
1965 GetMask() uint32
1966}
1967
1968func (self *AsyncConfigPropRoleStatusMaster) GetMask() uint32 {
1969 return self.Mask
1970}
1971
1972func (self *AsyncConfigPropRoleStatusMaster) SetMask(v uint32) {
1973 self.Mask = v
1974}
1975
1976func (self *AsyncConfigPropRoleStatusMaster) Serialize(encoder *goloxi.Encoder) error {
1977 startIndex := len(encoder.Bytes())
1978 if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
1979 return err
1980 }
1981
1982 encoder.PutUint32(uint32(self.Mask))
1983 length := len(encoder.Bytes()) - startIndex
1984
1985 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1986
1987 return nil
1988}
1989
1990func DecodeAsyncConfigPropRoleStatusMaster(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropRoleStatusMaster, error) {
1991 _asyncconfigproprolestatusmaster := &AsyncConfigPropRoleStatusMaster{AsyncConfigProp: parent}
1992 if decoder.Length() < 4 {
1993 return nil, fmt.Errorf("AsyncConfigPropRoleStatusMaster packet too short: %d < 4", decoder.Length())
1994 }
1995 _asyncconfigproprolestatusmaster.Mask = uint32(decoder.ReadUint32())
1996 return _asyncconfigproprolestatusmaster, nil
1997}
1998
1999func NewAsyncConfigPropRoleStatusMaster() *AsyncConfigPropRoleStatusMaster {
2000 obj := &AsyncConfigPropRoleStatusMaster{
2001 AsyncConfigProp: NewAsyncConfigProp(7),
2002 }
2003 return obj
2004}
2005
2006type AsyncConfigPropRoleStatusSlave struct {
2007 *AsyncConfigProp
2008 Mask uint32
2009}
2010
2011type IAsyncConfigPropRoleStatusSlave interface {
2012 IAsyncConfigProp
2013 GetMask() uint32
2014}
2015
2016func (self *AsyncConfigPropRoleStatusSlave) GetMask() uint32 {
2017 return self.Mask
2018}
2019
2020func (self *AsyncConfigPropRoleStatusSlave) SetMask(v uint32) {
2021 self.Mask = v
2022}
2023
2024func (self *AsyncConfigPropRoleStatusSlave) Serialize(encoder *goloxi.Encoder) error {
2025 startIndex := len(encoder.Bytes())
2026 if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
2027 return err
2028 }
2029
2030 encoder.PutUint32(uint32(self.Mask))
2031 length := len(encoder.Bytes()) - startIndex
2032
2033 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
2034
2035 return nil
2036}
2037
2038func DecodeAsyncConfigPropRoleStatusSlave(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropRoleStatusSlave, error) {
2039 _asyncconfigproprolestatusslave := &AsyncConfigPropRoleStatusSlave{AsyncConfigProp: parent}
2040 if decoder.Length() < 4 {
2041 return nil, fmt.Errorf("AsyncConfigPropRoleStatusSlave packet too short: %d < 4", decoder.Length())
2042 }
2043 _asyncconfigproprolestatusslave.Mask = uint32(decoder.ReadUint32())
2044 return _asyncconfigproprolestatusslave, nil
2045}
2046
2047func NewAsyncConfigPropRoleStatusSlave() *AsyncConfigPropRoleStatusSlave {
2048 obj := &AsyncConfigPropRoleStatusSlave{
2049 AsyncConfigProp: NewAsyncConfigProp(6),
2050 }
2051 return obj
2052}
2053
2054type AsyncConfigPropTableStatusMaster struct {
2055 *AsyncConfigProp
2056 Mask uint32
2057}
2058
2059type IAsyncConfigPropTableStatusMaster interface {
2060 IAsyncConfigProp
2061 GetMask() uint32
2062}
2063
2064func (self *AsyncConfigPropTableStatusMaster) GetMask() uint32 {
2065 return self.Mask
2066}
2067
2068func (self *AsyncConfigPropTableStatusMaster) SetMask(v uint32) {
2069 self.Mask = v
2070}
2071
2072func (self *AsyncConfigPropTableStatusMaster) Serialize(encoder *goloxi.Encoder) error {
2073 startIndex := len(encoder.Bytes())
2074 if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
2075 return err
2076 }
2077
2078 encoder.PutUint32(uint32(self.Mask))
2079 length := len(encoder.Bytes()) - startIndex
2080
2081 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
2082
2083 return nil
2084}
2085
2086func DecodeAsyncConfigPropTableStatusMaster(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropTableStatusMaster, error) {
2087 _asyncconfigproptablestatusmaster := &AsyncConfigPropTableStatusMaster{AsyncConfigProp: parent}
2088 if decoder.Length() < 4 {
2089 return nil, fmt.Errorf("AsyncConfigPropTableStatusMaster packet too short: %d < 4", decoder.Length())
2090 }
2091 _asyncconfigproptablestatusmaster.Mask = uint32(decoder.ReadUint32())
2092 return _asyncconfigproptablestatusmaster, nil
2093}
2094
2095func NewAsyncConfigPropTableStatusMaster() *AsyncConfigPropTableStatusMaster {
2096 obj := &AsyncConfigPropTableStatusMaster{
2097 AsyncConfigProp: NewAsyncConfigProp(9),
2098 }
2099 return obj
2100}
2101
2102type AsyncConfigPropTableStatusSlave struct {
2103 *AsyncConfigProp
2104 Mask uint32
2105}
2106
2107type IAsyncConfigPropTableStatusSlave interface {
2108 IAsyncConfigProp
2109 GetMask() uint32
2110}
2111
2112func (self *AsyncConfigPropTableStatusSlave) GetMask() uint32 {
2113 return self.Mask
2114}
2115
2116func (self *AsyncConfigPropTableStatusSlave) SetMask(v uint32) {
2117 self.Mask = v
2118}
2119
2120func (self *AsyncConfigPropTableStatusSlave) Serialize(encoder *goloxi.Encoder) error {
2121 startIndex := len(encoder.Bytes())
2122 if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
2123 return err
2124 }
2125
2126 encoder.PutUint32(uint32(self.Mask))
2127 length := len(encoder.Bytes()) - startIndex
2128
2129 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
2130
2131 return nil
2132}
2133
2134func DecodeAsyncConfigPropTableStatusSlave(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropTableStatusSlave, error) {
2135 _asyncconfigproptablestatusslave := &AsyncConfigPropTableStatusSlave{AsyncConfigProp: parent}
2136 if decoder.Length() < 4 {
2137 return nil, fmt.Errorf("AsyncConfigPropTableStatusSlave packet too short: %d < 4", decoder.Length())
2138 }
2139 _asyncconfigproptablestatusslave.Mask = uint32(decoder.ReadUint32())
2140 return _asyncconfigproptablestatusslave, nil
2141}
2142
2143func NewAsyncConfigPropTableStatusSlave() *AsyncConfigPropTableStatusSlave {
2144 obj := &AsyncConfigPropTableStatusSlave{
2145 AsyncConfigProp: NewAsyncConfigProp(8),
2146 }
2147 return obj
2148}
2149
2150type BsnControllerConnection struct {
2151 State BsnControllerConnectionState
2152 AuxiliaryId uint8
2153 Role ControllerRole
2154 Uri string
2155}
2156
2157type IBsnControllerConnection interface {
2158 goloxi.Serializable
2159 GetState() BsnControllerConnectionState
2160 GetAuxiliaryId() uint8
2161 GetRole() ControllerRole
2162 GetUri() string
2163}
2164
2165func (self *BsnControllerConnection) GetState() BsnControllerConnectionState {
2166 return self.State
2167}
2168
2169func (self *BsnControllerConnection) SetState(v BsnControllerConnectionState) {
2170 self.State = v
2171}
2172
2173func (self *BsnControllerConnection) GetAuxiliaryId() uint8 {
2174 return self.AuxiliaryId
2175}
2176
2177func (self *BsnControllerConnection) SetAuxiliaryId(v uint8) {
2178 self.AuxiliaryId = v
2179}
2180
2181func (self *BsnControllerConnection) GetRole() ControllerRole {
2182 return self.Role
2183}
2184
2185func (self *BsnControllerConnection) SetRole(v ControllerRole) {
2186 self.Role = v
2187}
2188
2189func (self *BsnControllerConnection) GetUri() string {
2190 return self.Uri
2191}
2192
2193func (self *BsnControllerConnection) SetUri(v string) {
2194 self.Uri = v
2195}
2196
2197func (self *BsnControllerConnection) Serialize(encoder *goloxi.Encoder) error {
2198
2199 encoder.PutUint8(uint8(self.State))
2200 encoder.PutUint8(uint8(self.AuxiliaryId))
2201 encoder.Write(bytes.Repeat([]byte{0}, 2))
2202 encoder.PutUint32(uint32(self.Role))
2203 encoder.Write([]byte(self.Uri))
2204
2205 return nil
2206}
2207
2208func DecodeBsnControllerConnection(decoder *goloxi.Decoder) (*BsnControllerConnection, error) {
2209 _bsncontrollerconnection := &BsnControllerConnection{}
2210 if decoder.Length() < 264 {
2211 return nil, fmt.Errorf("BsnControllerConnection packet too short: %d < 264", decoder.Length())
2212 }
2213 _bsncontrollerconnection.State = BsnControllerConnectionState(decoder.ReadByte())
2214 _bsncontrollerconnection.AuxiliaryId = uint8(decoder.ReadByte())
2215 decoder.Skip(2)
2216 _bsncontrollerconnection.Role = ControllerRole(decoder.ReadUint32())
2217 _bsncontrollerconnection.Uri = string(bytes.Trim(decoder.Read(256), "\x00"))
2218 return _bsncontrollerconnection, nil
2219}
2220
2221func NewBsnControllerConnection() *BsnControllerConnection {
2222 obj := &BsnControllerConnection{}
2223 return obj
2224}
2225
2226type BsnDebugCounterDescStatsEntry struct {
2227 CounterId uint64
2228 Name string
2229 Description string
2230}
2231
2232type IBsnDebugCounterDescStatsEntry interface {
2233 goloxi.Serializable
2234 GetCounterId() uint64
2235 GetName() string
2236 GetDescription() string
2237}
2238
2239func (self *BsnDebugCounterDescStatsEntry) GetCounterId() uint64 {
2240 return self.CounterId
2241}
2242
2243func (self *BsnDebugCounterDescStatsEntry) SetCounterId(v uint64) {
2244 self.CounterId = v
2245}
2246
2247func (self *BsnDebugCounterDescStatsEntry) GetName() string {
2248 return self.Name
2249}
2250
2251func (self *BsnDebugCounterDescStatsEntry) SetName(v string) {
2252 self.Name = v
2253}
2254
2255func (self *BsnDebugCounterDescStatsEntry) GetDescription() string {
2256 return self.Description
2257}
2258
2259func (self *BsnDebugCounterDescStatsEntry) SetDescription(v string) {
2260 self.Description = v
2261}
2262
2263func (self *BsnDebugCounterDescStatsEntry) Serialize(encoder *goloxi.Encoder) error {
2264
2265 encoder.PutUint64(uint64(self.CounterId))
2266 encoder.Write([]byte(self.Name))
2267 encoder.Write([]byte(self.Description))
2268
2269 return nil
2270}
2271
2272func DecodeBsnDebugCounterDescStatsEntry(decoder *goloxi.Decoder) (*BsnDebugCounterDescStatsEntry, error) {
2273 _bsndebugcounterdescstatsentry := &BsnDebugCounterDescStatsEntry{}
2274 if decoder.Length() < 328 {
2275 return nil, fmt.Errorf("BsnDebugCounterDescStatsEntry packet too short: %d < 328", decoder.Length())
2276 }
2277 _bsndebugcounterdescstatsentry.CounterId = uint64(decoder.ReadUint64())
2278 _bsndebugcounterdescstatsentry.Name = string(bytes.Trim(decoder.Read(64), "\x00"))
2279 _bsndebugcounterdescstatsentry.Description = string(bytes.Trim(decoder.Read(256), "\x00"))
2280 return _bsndebugcounterdescstatsentry, nil
2281}
2282
2283func NewBsnDebugCounterDescStatsEntry() *BsnDebugCounterDescStatsEntry {
2284 obj := &BsnDebugCounterDescStatsEntry{}
2285 return obj
2286}
2287
2288type BsnDebugCounterStatsEntry struct {
2289 CounterId uint64
2290 Value uint64
2291}
2292
2293type IBsnDebugCounterStatsEntry interface {
2294 goloxi.Serializable
2295 GetCounterId() uint64
2296 GetValue() uint64
2297}
2298
2299func (self *BsnDebugCounterStatsEntry) GetCounterId() uint64 {
2300 return self.CounterId
2301}
2302
2303func (self *BsnDebugCounterStatsEntry) SetCounterId(v uint64) {
2304 self.CounterId = v
2305}
2306
2307func (self *BsnDebugCounterStatsEntry) GetValue() uint64 {
2308 return self.Value
2309}
2310
2311func (self *BsnDebugCounterStatsEntry) SetValue(v uint64) {
2312 self.Value = v
2313}
2314
2315func (self *BsnDebugCounterStatsEntry) Serialize(encoder *goloxi.Encoder) error {
2316
2317 encoder.PutUint64(uint64(self.CounterId))
2318 encoder.PutUint64(uint64(self.Value))
2319
2320 return nil
2321}
2322
2323func DecodeBsnDebugCounterStatsEntry(decoder *goloxi.Decoder) (*BsnDebugCounterStatsEntry, error) {
2324 _bsndebugcounterstatsentry := &BsnDebugCounterStatsEntry{}
2325 if decoder.Length() < 16 {
2326 return nil, fmt.Errorf("BsnDebugCounterStatsEntry packet too short: %d < 16", decoder.Length())
2327 }
2328 _bsndebugcounterstatsentry.CounterId = uint64(decoder.ReadUint64())
2329 _bsndebugcounterstatsentry.Value = uint64(decoder.ReadUint64())
2330 return _bsndebugcounterstatsentry, nil
2331}
2332
2333func NewBsnDebugCounterStatsEntry() *BsnDebugCounterStatsEntry {
2334 obj := &BsnDebugCounterStatsEntry{}
2335 return obj
2336}
2337
2338type BsnFlowChecksumBucketStatsEntry struct {
2339 Checksum uint64
2340}
2341
2342type IBsnFlowChecksumBucketStatsEntry interface {
2343 goloxi.Serializable
2344 GetChecksum() uint64
2345}
2346
2347func (self *BsnFlowChecksumBucketStatsEntry) GetChecksum() uint64 {
2348 return self.Checksum
2349}
2350
2351func (self *BsnFlowChecksumBucketStatsEntry) SetChecksum(v uint64) {
2352 self.Checksum = v
2353}
2354
2355func (self *BsnFlowChecksumBucketStatsEntry) Serialize(encoder *goloxi.Encoder) error {
2356
2357 encoder.PutUint64(uint64(self.Checksum))
2358
2359 return nil
2360}
2361
2362func DecodeBsnFlowChecksumBucketStatsEntry(decoder *goloxi.Decoder) (*BsnFlowChecksumBucketStatsEntry, error) {
2363 _bsnflowchecksumbucketstatsentry := &BsnFlowChecksumBucketStatsEntry{}
2364 if decoder.Length() < 8 {
2365 return nil, fmt.Errorf("BsnFlowChecksumBucketStatsEntry packet too short: %d < 8", decoder.Length())
2366 }
2367 _bsnflowchecksumbucketstatsentry.Checksum = uint64(decoder.ReadUint64())
2368 return _bsnflowchecksumbucketstatsentry, nil
2369}
2370
2371func NewBsnFlowChecksumBucketStatsEntry() *BsnFlowChecksumBucketStatsEntry {
2372 obj := &BsnFlowChecksumBucketStatsEntry{}
2373 return obj
2374}
2375
2376type BsnGenericStatsEntry struct {
2377 Length uint16
2378 Tlvs []IBsnTlv
2379}
2380
2381type IBsnGenericStatsEntry interface {
2382 goloxi.Serializable
2383 GetLength() uint16
2384 GetTlvs() []IBsnTlv
2385}
2386
2387func (self *BsnGenericStatsEntry) GetLength() uint16 {
2388 return self.Length
2389}
2390
2391func (self *BsnGenericStatsEntry) SetLength(v uint16) {
2392 self.Length = v
2393}
2394
2395func (self *BsnGenericStatsEntry) GetTlvs() []IBsnTlv {
2396 return self.Tlvs
2397}
2398
2399func (self *BsnGenericStatsEntry) SetTlvs(v []IBsnTlv) {
2400 self.Tlvs = v
2401}
2402
2403func (self *BsnGenericStatsEntry) Serialize(encoder *goloxi.Encoder) error {
2404 startIndex := len(encoder.Bytes())
2405
2406 encoder.PutUint16(uint16(self.Length))
2407 for _, obj := range self.Tlvs {
2408 if err := obj.Serialize(encoder); err != nil {
2409 return err
2410 }
2411 }
2412 length := len(encoder.Bytes()) - startIndex
2413
2414 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
2415
2416 return nil
2417}
2418
2419func DecodeBsnGenericStatsEntry(decoder *goloxi.Decoder) (*BsnGenericStatsEntry, error) {
2420 _bsngenericstatsentry := &BsnGenericStatsEntry{}
2421 if decoder.Length() < 2 {
2422 return nil, fmt.Errorf("BsnGenericStatsEntry packet too short: %d < 2", decoder.Length())
2423 }
2424 _bsngenericstatsentry.Length = uint16(decoder.ReadUint16())
2425 oldDecoder := decoder
2426 defer func() { decoder = oldDecoder }()
2427 decoder = decoder.SliceDecoder(int(_bsngenericstatsentry.Length), 2+0)
2428
2429 for decoder.Length() >= 4 {
2430 item, err := DecodeBsnTlv(decoder)
2431 if err != nil {
2432 return nil, err
2433 }
2434 if item != nil {
2435 _bsngenericstatsentry.Tlvs = append(_bsngenericstatsentry.Tlvs, item)
2436 }
2437 }
2438 return _bsngenericstatsentry, nil
2439}
2440
2441func NewBsnGenericStatsEntry() *BsnGenericStatsEntry {
2442 obj := &BsnGenericStatsEntry{}
2443 return obj
2444}
2445
2446type BsnGentableBucketStatsEntry struct {
2447 Checksum Checksum128
2448}
2449
2450type IBsnGentableBucketStatsEntry interface {
2451 goloxi.Serializable
2452 GetChecksum() Checksum128
2453}
2454
2455func (self *BsnGentableBucketStatsEntry) GetChecksum() Checksum128 {
2456 return self.Checksum
2457}
2458
2459func (self *BsnGentableBucketStatsEntry) SetChecksum(v Checksum128) {
2460 self.Checksum = v
2461}
2462
2463func (self *BsnGentableBucketStatsEntry) Serialize(encoder *goloxi.Encoder) error {
2464
2465 self.Checksum.Serialize(encoder)
2466
2467 return nil
2468}
2469
2470func DecodeBsnGentableBucketStatsEntry(decoder *goloxi.Decoder) (*BsnGentableBucketStatsEntry, error) {
2471 _bsngentablebucketstatsentry := &BsnGentableBucketStatsEntry{}
2472 if decoder.Length() < 16 {
2473 return nil, fmt.Errorf("BsnGentableBucketStatsEntry packet too short: %d < 16", decoder.Length())
2474 }
2475 _bsngentablebucketstatsentry.Checksum.Decode(decoder)
2476 return _bsngentablebucketstatsentry, nil
2477}
2478
2479func NewBsnGentableBucketStatsEntry() *BsnGentableBucketStatsEntry {
2480 obj := &BsnGentableBucketStatsEntry{}
2481 return obj
2482}
2483
2484type BsnGentableDescStatsEntry struct {
2485 Length uint16
2486 TableId uint16
2487 Name string
2488 BucketsSize uint32
2489 MaxEntries uint32
2490}
2491
2492type IBsnGentableDescStatsEntry interface {
2493 goloxi.Serializable
2494 GetLength() uint16
2495 GetTableId() uint16
2496 GetName() string
2497 GetBucketsSize() uint32
2498 GetMaxEntries() uint32
2499}
2500
2501func (self *BsnGentableDescStatsEntry) GetLength() uint16 {
2502 return self.Length
2503}
2504
2505func (self *BsnGentableDescStatsEntry) SetLength(v uint16) {
2506 self.Length = v
2507}
2508
2509func (self *BsnGentableDescStatsEntry) GetTableId() uint16 {
2510 return self.TableId
2511}
2512
2513func (self *BsnGentableDescStatsEntry) SetTableId(v uint16) {
2514 self.TableId = v
2515}
2516
2517func (self *BsnGentableDescStatsEntry) GetName() string {
2518 return self.Name
2519}
2520
2521func (self *BsnGentableDescStatsEntry) SetName(v string) {
2522 self.Name = v
2523}
2524
2525func (self *BsnGentableDescStatsEntry) GetBucketsSize() uint32 {
2526 return self.BucketsSize
2527}
2528
2529func (self *BsnGentableDescStatsEntry) SetBucketsSize(v uint32) {
2530 self.BucketsSize = v
2531}
2532
2533func (self *BsnGentableDescStatsEntry) GetMaxEntries() uint32 {
2534 return self.MaxEntries
2535}
2536
2537func (self *BsnGentableDescStatsEntry) SetMaxEntries(v uint32) {
2538 self.MaxEntries = v
2539}
2540
2541func (self *BsnGentableDescStatsEntry) Serialize(encoder *goloxi.Encoder) error {
2542 startIndex := len(encoder.Bytes())
2543
2544 encoder.PutUint16(uint16(self.Length))
2545 encoder.PutUint16(uint16(self.TableId))
2546 encoder.Write([]byte(self.Name))
2547 encoder.PutUint32(uint32(self.BucketsSize))
2548 encoder.PutUint32(uint32(self.MaxEntries))
2549 encoder.Write(bytes.Repeat([]byte{0}, 4))
2550 length := len(encoder.Bytes()) - startIndex
2551
2552 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
2553
2554 return nil
2555}
2556
2557func DecodeBsnGentableDescStatsEntry(decoder *goloxi.Decoder) (*BsnGentableDescStatsEntry, error) {
2558 _bsngentabledescstatsentry := &BsnGentableDescStatsEntry{}
2559 if decoder.Length() < 48 {
2560 return nil, fmt.Errorf("BsnGentableDescStatsEntry packet too short: %d < 48", decoder.Length())
2561 }
2562 _bsngentabledescstatsentry.Length = uint16(decoder.ReadUint16())
2563 oldDecoder := decoder
2564 defer func() { decoder = oldDecoder }()
2565 decoder = decoder.SliceDecoder(int(_bsngentabledescstatsentry.Length), 2+0)
2566 _bsngentabledescstatsentry.TableId = uint16(decoder.ReadUint16())
2567 _bsngentabledescstatsentry.Name = string(bytes.Trim(decoder.Read(32), "\x00"))
2568 _bsngentabledescstatsentry.BucketsSize = uint32(decoder.ReadUint32())
2569 _bsngentabledescstatsentry.MaxEntries = uint32(decoder.ReadUint32())
2570 decoder.Skip(4)
2571 return _bsngentabledescstatsentry, nil
2572}
2573
2574func NewBsnGentableDescStatsEntry() *BsnGentableDescStatsEntry {
2575 obj := &BsnGentableDescStatsEntry{}
2576 return obj
2577}
2578
2579type BsnGentableEntryDescStatsEntry struct {
2580 Length uint16
2581 KeyLength uint16
2582 Checksum Checksum128
2583 Key []IBsnTlv
2584 Value []IBsnTlv
2585}
2586
2587type IBsnGentableEntryDescStatsEntry interface {
2588 goloxi.Serializable
2589 GetLength() uint16
2590 GetKeyLength() uint16
2591 GetChecksum() Checksum128
2592 GetKey() []IBsnTlv
2593 GetValue() []IBsnTlv
2594}
2595
2596func (self *BsnGentableEntryDescStatsEntry) GetLength() uint16 {
2597 return self.Length
2598}
2599
2600func (self *BsnGentableEntryDescStatsEntry) SetLength(v uint16) {
2601 self.Length = v
2602}
2603
2604func (self *BsnGentableEntryDescStatsEntry) GetKeyLength() uint16 {
2605 return self.KeyLength
2606}
2607
2608func (self *BsnGentableEntryDescStatsEntry) SetKeyLength(v uint16) {
2609 self.KeyLength = v
2610}
2611
2612func (self *BsnGentableEntryDescStatsEntry) GetChecksum() Checksum128 {
2613 return self.Checksum
2614}
2615
2616func (self *BsnGentableEntryDescStatsEntry) SetChecksum(v Checksum128) {
2617 self.Checksum = v
2618}
2619
2620func (self *BsnGentableEntryDescStatsEntry) GetKey() []IBsnTlv {
2621 return self.Key
2622}
2623
2624func (self *BsnGentableEntryDescStatsEntry) SetKey(v []IBsnTlv) {
2625 self.Key = v
2626}
2627
2628func (self *BsnGentableEntryDescStatsEntry) GetValue() []IBsnTlv {
2629 return self.Value
2630}
2631
2632func (self *BsnGentableEntryDescStatsEntry) SetValue(v []IBsnTlv) {
2633 self.Value = v
2634}
2635
2636func (self *BsnGentableEntryDescStatsEntry) Serialize(encoder *goloxi.Encoder) error {
2637 startIndex := len(encoder.Bytes())
2638
2639 encoder.PutUint16(uint16(self.Length))
2640 encoder.PutUint16(uint16(self.KeyLength))
2641 self.Checksum.Serialize(encoder)
2642 for _, obj := range self.Key {
2643 if err := obj.Serialize(encoder); err != nil {
2644 return err
2645 }
2646 }
2647 for _, obj := range self.Value {
2648 if err := obj.Serialize(encoder); err != nil {
2649 return err
2650 }
2651 }
2652 length := len(encoder.Bytes()) - startIndex
2653
2654 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
2655
2656 return nil
2657}
2658
2659func DecodeBsnGentableEntryDescStatsEntry(decoder *goloxi.Decoder) (*BsnGentableEntryDescStatsEntry, error) {
2660 _bsngentableentrydescstatsentry := &BsnGentableEntryDescStatsEntry{}
2661 if decoder.Length() < 20 {
2662 return nil, fmt.Errorf("BsnGentableEntryDescStatsEntry packet too short: %d < 20", decoder.Length())
2663 }
2664 _bsngentableentrydescstatsentry.Length = uint16(decoder.ReadUint16())
2665 oldDecoder := decoder
2666 defer func() { decoder = oldDecoder }()
2667 decoder = decoder.SliceDecoder(int(_bsngentableentrydescstatsentry.Length), 2+0)
2668 _bsngentableentrydescstatsentry.KeyLength = uint16(decoder.ReadUint16())
2669 _bsngentableentrydescstatsentry.Checksum.Decode(decoder)
2670
2671 end := decoder.Offset() + int(_bsngentableentrydescstatsentry.KeyLength)
2672 for decoder.Offset() < end {
2673 item, err := DecodeBsnTlv(decoder)
2674 if err != nil {
2675 return nil, err
2676 }
2677 if item != nil {
2678 _bsngentableentrydescstatsentry.Key = append(_bsngentableentrydescstatsentry.Key, item)
2679 }
2680 }
2681
2682 for decoder.Length() >= 4 {
2683 item, err := DecodeBsnTlv(decoder)
2684 if err != nil {
2685 return nil, err
2686 }
2687 if item != nil {
2688 _bsngentableentrydescstatsentry.Value = append(_bsngentableentrydescstatsentry.Value, item)
2689 }
2690 }
2691 return _bsngentableentrydescstatsentry, nil
2692}
2693
2694func NewBsnGentableEntryDescStatsEntry() *BsnGentableEntryDescStatsEntry {
2695 obj := &BsnGentableEntryDescStatsEntry{}
2696 return obj
2697}
2698
2699type BsnGentableEntryStatsEntry struct {
2700 Length uint16
2701 KeyLength uint16
2702 Key []IBsnTlv
2703 Stats []IBsnTlv
2704}
2705
2706type IBsnGentableEntryStatsEntry interface {
2707 goloxi.Serializable
2708 GetLength() uint16
2709 GetKeyLength() uint16
2710 GetKey() []IBsnTlv
2711 GetStats() []IBsnTlv
2712}
2713
2714func (self *BsnGentableEntryStatsEntry) GetLength() uint16 {
2715 return self.Length
2716}
2717
2718func (self *BsnGentableEntryStatsEntry) SetLength(v uint16) {
2719 self.Length = v
2720}
2721
2722func (self *BsnGentableEntryStatsEntry) GetKeyLength() uint16 {
2723 return self.KeyLength
2724}
2725
2726func (self *BsnGentableEntryStatsEntry) SetKeyLength(v uint16) {
2727 self.KeyLength = v
2728}
2729
2730func (self *BsnGentableEntryStatsEntry) GetKey() []IBsnTlv {
2731 return self.Key
2732}
2733
2734func (self *BsnGentableEntryStatsEntry) SetKey(v []IBsnTlv) {
2735 self.Key = v
2736}
2737
2738func (self *BsnGentableEntryStatsEntry) GetStats() []IBsnTlv {
2739 return self.Stats
2740}
2741
2742func (self *BsnGentableEntryStatsEntry) SetStats(v []IBsnTlv) {
2743 self.Stats = v
2744}
2745
2746func (self *BsnGentableEntryStatsEntry) Serialize(encoder *goloxi.Encoder) error {
2747 startIndex := len(encoder.Bytes())
2748
2749 encoder.PutUint16(uint16(self.Length))
2750 encoder.PutUint16(uint16(self.KeyLength))
2751 for _, obj := range self.Key {
2752 if err := obj.Serialize(encoder); err != nil {
2753 return err
2754 }
2755 }
2756 for _, obj := range self.Stats {
2757 if err := obj.Serialize(encoder); err != nil {
2758 return err
2759 }
2760 }
2761 length := len(encoder.Bytes()) - startIndex
2762
2763 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
2764
2765 return nil
2766}
2767
2768func DecodeBsnGentableEntryStatsEntry(decoder *goloxi.Decoder) (*BsnGentableEntryStatsEntry, error) {
2769 _bsngentableentrystatsentry := &BsnGentableEntryStatsEntry{}
2770 if decoder.Length() < 4 {
2771 return nil, fmt.Errorf("BsnGentableEntryStatsEntry packet too short: %d < 4", decoder.Length())
2772 }
2773 _bsngentableentrystatsentry.Length = uint16(decoder.ReadUint16())
2774 oldDecoder := decoder
2775 defer func() { decoder = oldDecoder }()
2776 decoder = decoder.SliceDecoder(int(_bsngentableentrystatsentry.Length), 2+0)
2777 _bsngentableentrystatsentry.KeyLength = uint16(decoder.ReadUint16())
2778
2779 end := decoder.Offset() + int(_bsngentableentrystatsentry.KeyLength)
2780 for decoder.Offset() < end {
2781 item, err := DecodeBsnTlv(decoder)
2782 if err != nil {
2783 return nil, err
2784 }
2785 if item != nil {
2786 _bsngentableentrystatsentry.Key = append(_bsngentableentrystatsentry.Key, item)
2787 }
2788 }
2789
2790 for decoder.Length() >= 4 {
2791 item, err := DecodeBsnTlv(decoder)
2792 if err != nil {
2793 return nil, err
2794 }
2795 if item != nil {
2796 _bsngentableentrystatsentry.Stats = append(_bsngentableentrystatsentry.Stats, item)
2797 }
2798 }
2799 return _bsngentableentrystatsentry, nil
2800}
2801
2802func NewBsnGentableEntryStatsEntry() *BsnGentableEntryStatsEntry {
2803 obj := &BsnGentableEntryStatsEntry{}
2804 return obj
2805}
2806
2807type BsnGentableStatsEntry struct {
2808 TableId uint16
2809 EntryCount uint32
2810 Checksum Checksum128
2811}
2812
2813type IBsnGentableStatsEntry interface {
2814 goloxi.Serializable
2815 GetTableId() uint16
2816 GetEntryCount() uint32
2817 GetChecksum() Checksum128
2818}
2819
2820func (self *BsnGentableStatsEntry) GetTableId() uint16 {
2821 return self.TableId
2822}
2823
2824func (self *BsnGentableStatsEntry) SetTableId(v uint16) {
2825 self.TableId = v
2826}
2827
2828func (self *BsnGentableStatsEntry) GetEntryCount() uint32 {
2829 return self.EntryCount
2830}
2831
2832func (self *BsnGentableStatsEntry) SetEntryCount(v uint32) {
2833 self.EntryCount = v
2834}
2835
2836func (self *BsnGentableStatsEntry) GetChecksum() Checksum128 {
2837 return self.Checksum
2838}
2839
2840func (self *BsnGentableStatsEntry) SetChecksum(v Checksum128) {
2841 self.Checksum = v
2842}
2843
2844func (self *BsnGentableStatsEntry) Serialize(encoder *goloxi.Encoder) error {
2845
2846 encoder.PutUint16(uint16(self.TableId))
2847 encoder.Write(bytes.Repeat([]byte{0}, 2))
2848 encoder.PutUint32(uint32(self.EntryCount))
2849 self.Checksum.Serialize(encoder)
2850
2851 return nil
2852}
2853
2854func DecodeBsnGentableStatsEntry(decoder *goloxi.Decoder) (*BsnGentableStatsEntry, error) {
2855 _bsngentablestatsentry := &BsnGentableStatsEntry{}
2856 if decoder.Length() < 24 {
2857 return nil, fmt.Errorf("BsnGentableStatsEntry packet too short: %d < 24", decoder.Length())
2858 }
2859 _bsngentablestatsentry.TableId = uint16(decoder.ReadUint16())
2860 decoder.Skip(2)
2861 _bsngentablestatsentry.EntryCount = uint32(decoder.ReadUint32())
2862 _bsngentablestatsentry.Checksum.Decode(decoder)
2863 return _bsngentablestatsentry, nil
2864}
2865
2866func NewBsnGentableStatsEntry() *BsnGentableStatsEntry {
2867 obj := &BsnGentableStatsEntry{}
2868 return obj
2869}
2870
2871type BsnInterface struct {
2872 HwAddr net.HardwareAddr
2873 Name string
2874 Ipv4Addr net.IP
2875 Ipv4Netmask net.IP
2876}
2877
2878type IBsnInterface interface {
2879 goloxi.Serializable
2880 GetHwAddr() net.HardwareAddr
2881 GetName() string
2882 GetIpv4Addr() net.IP
2883 GetIpv4Netmask() net.IP
2884}
2885
2886func (self *BsnInterface) GetHwAddr() net.HardwareAddr {
2887 return self.HwAddr
2888}
2889
2890func (self *BsnInterface) SetHwAddr(v net.HardwareAddr) {
2891 self.HwAddr = v
2892}
2893
2894func (self *BsnInterface) GetName() string {
2895 return self.Name
2896}
2897
2898func (self *BsnInterface) SetName(v string) {
2899 self.Name = v
2900}
2901
2902func (self *BsnInterface) GetIpv4Addr() net.IP {
2903 return self.Ipv4Addr
2904}
2905
2906func (self *BsnInterface) SetIpv4Addr(v net.IP) {
2907 self.Ipv4Addr = v
2908}
2909
2910func (self *BsnInterface) GetIpv4Netmask() net.IP {
2911 return self.Ipv4Netmask
2912}
2913
2914func (self *BsnInterface) SetIpv4Netmask(v net.IP) {
2915 self.Ipv4Netmask = v
2916}
2917
2918func (self *BsnInterface) Serialize(encoder *goloxi.Encoder) error {
2919
2920 encoder.Write(self.HwAddr)
2921 encoder.Write(bytes.Repeat([]byte{0}, 2))
2922 encoder.Write([]byte(self.Name))
2923 encoder.Write(self.Ipv4Addr.To4())
2924 encoder.Write(self.Ipv4Netmask.To4())
2925
2926 return nil
2927}
2928
2929func DecodeBsnInterface(decoder *goloxi.Decoder) (*BsnInterface, error) {
2930 _bsninterface := &BsnInterface{}
2931 if decoder.Length() < 32 {
2932 return nil, fmt.Errorf("BsnInterface packet too short: %d < 32", decoder.Length())
2933 }
2934 _bsninterface.HwAddr = net.HardwareAddr(decoder.Read(6))
2935 decoder.Skip(2)
2936 _bsninterface.Name = string(bytes.Trim(decoder.Read(16), "\x00"))
2937 _bsninterface.Ipv4Addr = net.IP(decoder.Read(4))
2938 _bsninterface.Ipv4Netmask = net.IP(decoder.Read(4))
2939 return _bsninterface, nil
2940}
2941
2942func NewBsnInterface() *BsnInterface {
2943 obj := &BsnInterface{}
2944 return obj
2945}
2946
2947type BsnLacpStatsEntry struct {
2948 PortNo Port
2949 ActorSysPriority uint16
2950 ActorSysMac net.HardwareAddr
2951 ActorPortPriority uint16
2952 ActorPortNum uint16
2953 ActorKey uint16
2954 ConvergenceStatus uint8
2955 PartnerSysPriority uint16
2956 PartnerSysMac net.HardwareAddr
2957 PartnerPortPriority uint16
2958 PartnerPortNum uint16
2959 PartnerKey uint16
2960}
2961
2962type IBsnLacpStatsEntry interface {
2963 goloxi.Serializable
2964 GetPortNo() Port
2965 GetActorSysPriority() uint16
2966 GetActorSysMac() net.HardwareAddr
2967 GetActorPortPriority() uint16
2968 GetActorPortNum() uint16
2969 GetActorKey() uint16
2970 GetConvergenceStatus() uint8
2971 GetPartnerSysPriority() uint16
2972 GetPartnerSysMac() net.HardwareAddr
2973 GetPartnerPortPriority() uint16
2974 GetPartnerPortNum() uint16
2975 GetPartnerKey() uint16
2976}
2977
2978func (self *BsnLacpStatsEntry) GetPortNo() Port {
2979 return self.PortNo
2980}
2981
2982func (self *BsnLacpStatsEntry) SetPortNo(v Port) {
2983 self.PortNo = v
2984}
2985
2986func (self *BsnLacpStatsEntry) GetActorSysPriority() uint16 {
2987 return self.ActorSysPriority
2988}
2989
2990func (self *BsnLacpStatsEntry) SetActorSysPriority(v uint16) {
2991 self.ActorSysPriority = v
2992}
2993
2994func (self *BsnLacpStatsEntry) GetActorSysMac() net.HardwareAddr {
2995 return self.ActorSysMac
2996}
2997
2998func (self *BsnLacpStatsEntry) SetActorSysMac(v net.HardwareAddr) {
2999 self.ActorSysMac = v
3000}
3001
3002func (self *BsnLacpStatsEntry) GetActorPortPriority() uint16 {
3003 return self.ActorPortPriority
3004}
3005
3006func (self *BsnLacpStatsEntry) SetActorPortPriority(v uint16) {
3007 self.ActorPortPriority = v
3008}
3009
3010func (self *BsnLacpStatsEntry) GetActorPortNum() uint16 {
3011 return self.ActorPortNum
3012}
3013
3014func (self *BsnLacpStatsEntry) SetActorPortNum(v uint16) {
3015 self.ActorPortNum = v
3016}
3017
3018func (self *BsnLacpStatsEntry) GetActorKey() uint16 {
3019 return self.ActorKey
3020}
3021
3022func (self *BsnLacpStatsEntry) SetActorKey(v uint16) {
3023 self.ActorKey = v
3024}
3025
3026func (self *BsnLacpStatsEntry) GetConvergenceStatus() uint8 {
3027 return self.ConvergenceStatus
3028}
3029
3030func (self *BsnLacpStatsEntry) SetConvergenceStatus(v uint8) {
3031 self.ConvergenceStatus = v
3032}
3033
3034func (self *BsnLacpStatsEntry) GetPartnerSysPriority() uint16 {
3035 return self.PartnerSysPriority
3036}
3037
3038func (self *BsnLacpStatsEntry) SetPartnerSysPriority(v uint16) {
3039 self.PartnerSysPriority = v
3040}
3041
3042func (self *BsnLacpStatsEntry) GetPartnerSysMac() net.HardwareAddr {
3043 return self.PartnerSysMac
3044}
3045
3046func (self *BsnLacpStatsEntry) SetPartnerSysMac(v net.HardwareAddr) {
3047 self.PartnerSysMac = v
3048}
3049
3050func (self *BsnLacpStatsEntry) GetPartnerPortPriority() uint16 {
3051 return self.PartnerPortPriority
3052}
3053
3054func (self *BsnLacpStatsEntry) SetPartnerPortPriority(v uint16) {
3055 self.PartnerPortPriority = v
3056}
3057
3058func (self *BsnLacpStatsEntry) GetPartnerPortNum() uint16 {
3059 return self.PartnerPortNum
3060}
3061
3062func (self *BsnLacpStatsEntry) SetPartnerPortNum(v uint16) {
3063 self.PartnerPortNum = v
3064}
3065
3066func (self *BsnLacpStatsEntry) GetPartnerKey() uint16 {
3067 return self.PartnerKey
3068}
3069
3070func (self *BsnLacpStatsEntry) SetPartnerKey(v uint16) {
3071 self.PartnerKey = v
3072}
3073
3074func (self *BsnLacpStatsEntry) Serialize(encoder *goloxi.Encoder) error {
3075
3076 self.PortNo.Serialize(encoder)
3077 encoder.PutUint16(uint16(self.ActorSysPriority))
3078 encoder.Write(self.ActorSysMac)
3079 encoder.PutUint16(uint16(self.ActorPortPriority))
3080 encoder.PutUint16(uint16(self.ActorPortNum))
3081 encoder.PutUint16(uint16(self.ActorKey))
3082 encoder.PutUint8(uint8(self.ConvergenceStatus))
3083 encoder.Write(bytes.Repeat([]byte{0}, 1))
3084 encoder.PutUint16(uint16(self.PartnerSysPriority))
3085 encoder.Write(self.PartnerSysMac)
3086 encoder.PutUint16(uint16(self.PartnerPortPriority))
3087 encoder.PutUint16(uint16(self.PartnerPortNum))
3088 encoder.PutUint16(uint16(self.PartnerKey))
3089 encoder.Write(bytes.Repeat([]byte{0}, 2))
3090
3091 return nil
3092}
3093
3094func DecodeBsnLacpStatsEntry(decoder *goloxi.Decoder) (*BsnLacpStatsEntry, error) {
3095 _bsnlacpstatsentry := &BsnLacpStatsEntry{}
3096 if decoder.Length() < 36 {
3097 return nil, fmt.Errorf("BsnLacpStatsEntry packet too short: %d < 36", decoder.Length())
3098 }
3099 _bsnlacpstatsentry.PortNo.Decode(decoder)
3100 _bsnlacpstatsentry.ActorSysPriority = uint16(decoder.ReadUint16())
3101 _bsnlacpstatsentry.ActorSysMac = net.HardwareAddr(decoder.Read(6))
3102 _bsnlacpstatsentry.ActorPortPriority = uint16(decoder.ReadUint16())
3103 _bsnlacpstatsentry.ActorPortNum = uint16(decoder.ReadUint16())
3104 _bsnlacpstatsentry.ActorKey = uint16(decoder.ReadUint16())
3105 _bsnlacpstatsentry.ConvergenceStatus = uint8(decoder.ReadByte())
3106 decoder.Skip(1)
3107 _bsnlacpstatsentry.PartnerSysPriority = uint16(decoder.ReadUint16())
3108 _bsnlacpstatsentry.PartnerSysMac = net.HardwareAddr(decoder.Read(6))
3109 _bsnlacpstatsentry.PartnerPortPriority = uint16(decoder.ReadUint16())
3110 _bsnlacpstatsentry.PartnerPortNum = uint16(decoder.ReadUint16())
3111 _bsnlacpstatsentry.PartnerKey = uint16(decoder.ReadUint16())
3112 decoder.Skip(2)
3113 return _bsnlacpstatsentry, nil
3114}
3115
3116func NewBsnLacpStatsEntry() *BsnLacpStatsEntry {
3117 obj := &BsnLacpStatsEntry{}
3118 return obj
3119}
3120
3121type BsnPortCounterStatsEntry struct {
3122 Length uint16
3123 PortNo Port
3124 Values []*Uint64
3125}
3126
3127type IBsnPortCounterStatsEntry interface {
3128 goloxi.Serializable
3129 GetLength() uint16
3130 GetPortNo() Port
3131 GetValues() []*Uint64
3132}
3133
3134func (self *BsnPortCounterStatsEntry) GetLength() uint16 {
3135 return self.Length
3136}
3137
3138func (self *BsnPortCounterStatsEntry) SetLength(v uint16) {
3139 self.Length = v
3140}
3141
3142func (self *BsnPortCounterStatsEntry) GetPortNo() Port {
3143 return self.PortNo
3144}
3145
3146func (self *BsnPortCounterStatsEntry) SetPortNo(v Port) {
3147 self.PortNo = v
3148}
3149
3150func (self *BsnPortCounterStatsEntry) GetValues() []*Uint64 {
3151 return self.Values
3152}
3153
3154func (self *BsnPortCounterStatsEntry) SetValues(v []*Uint64) {
3155 self.Values = v
3156}
3157
3158func (self *BsnPortCounterStatsEntry) Serialize(encoder *goloxi.Encoder) error {
3159 startIndex := len(encoder.Bytes())
3160
3161 encoder.PutUint16(uint16(self.Length))
3162 encoder.Write(bytes.Repeat([]byte{0}, 2))
3163 self.PortNo.Serialize(encoder)
3164 for _, obj := range self.Values {
3165 if err := obj.Serialize(encoder); err != nil {
3166 return err
3167 }
3168 }
3169 length := len(encoder.Bytes()) - startIndex
3170
3171 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
3172
3173 return nil
3174}
3175
3176func DecodeBsnPortCounterStatsEntry(decoder *goloxi.Decoder) (*BsnPortCounterStatsEntry, error) {
3177 _bsnportcounterstatsentry := &BsnPortCounterStatsEntry{}
3178 if decoder.Length() < 8 {
3179 return nil, fmt.Errorf("BsnPortCounterStatsEntry packet too short: %d < 8", decoder.Length())
3180 }
3181 _bsnportcounterstatsentry.Length = uint16(decoder.ReadUint16())
3182 oldDecoder := decoder
3183 defer func() { decoder = oldDecoder }()
3184 decoder = decoder.SliceDecoder(int(_bsnportcounterstatsentry.Length), 2+0)
3185 decoder.Skip(2)
3186 _bsnportcounterstatsentry.PortNo.Decode(decoder)
3187
3188 for decoder.Length() >= 8 {
3189 item, err := DecodeUint64(decoder)
3190 if err != nil {
3191 return nil, err
3192 }
3193 if item != nil {
3194 _bsnportcounterstatsentry.Values = append(_bsnportcounterstatsentry.Values, item)
3195 }
3196 }
3197 return _bsnportcounterstatsentry, nil
3198}
3199
3200func NewBsnPortCounterStatsEntry() *BsnPortCounterStatsEntry {
3201 obj := &BsnPortCounterStatsEntry{}
3202 return obj
3203}
3204
3205type BsnSwitchPipelineStatsEntry struct {
3206 Pipeline string
3207}
3208
3209type IBsnSwitchPipelineStatsEntry interface {
3210 goloxi.Serializable
3211 GetPipeline() string
3212}
3213
3214func (self *BsnSwitchPipelineStatsEntry) GetPipeline() string {
3215 return self.Pipeline
3216}
3217
3218func (self *BsnSwitchPipelineStatsEntry) SetPipeline(v string) {
3219 self.Pipeline = v
3220}
3221
3222func (self *BsnSwitchPipelineStatsEntry) Serialize(encoder *goloxi.Encoder) error {
3223
3224 encoder.Write([]byte(self.Pipeline))
3225
3226 return nil
3227}
3228
3229func DecodeBsnSwitchPipelineStatsEntry(decoder *goloxi.Decoder) (*BsnSwitchPipelineStatsEntry, error) {
3230 _bsnswitchpipelinestatsentry := &BsnSwitchPipelineStatsEntry{}
3231 if decoder.Length() < 256 {
3232 return nil, fmt.Errorf("BsnSwitchPipelineStatsEntry packet too short: %d < 256", decoder.Length())
3233 }
3234 _bsnswitchpipelinestatsentry.Pipeline = string(bytes.Trim(decoder.Read(256), "\x00"))
3235 return _bsnswitchpipelinestatsentry, nil
3236}
3237
3238func NewBsnSwitchPipelineStatsEntry() *BsnSwitchPipelineStatsEntry {
3239 obj := &BsnSwitchPipelineStatsEntry{}
3240 return obj
3241}
3242
3243type BsnTableChecksumStatsEntry struct {
3244 TableId uint8
3245 Checksum uint64
3246}
3247
3248type IBsnTableChecksumStatsEntry interface {
3249 goloxi.Serializable
3250 GetTableId() uint8
3251 GetChecksum() uint64
3252}
3253
3254func (self *BsnTableChecksumStatsEntry) GetTableId() uint8 {
3255 return self.TableId
3256}
3257
3258func (self *BsnTableChecksumStatsEntry) SetTableId(v uint8) {
3259 self.TableId = v
3260}
3261
3262func (self *BsnTableChecksumStatsEntry) GetChecksum() uint64 {
3263 return self.Checksum
3264}
3265
3266func (self *BsnTableChecksumStatsEntry) SetChecksum(v uint64) {
3267 self.Checksum = v
3268}
3269
3270func (self *BsnTableChecksumStatsEntry) Serialize(encoder *goloxi.Encoder) error {
3271
3272 encoder.PutUint8(uint8(self.TableId))
3273 encoder.PutUint64(uint64(self.Checksum))
3274
3275 return nil
3276}
3277
3278func DecodeBsnTableChecksumStatsEntry(decoder *goloxi.Decoder) (*BsnTableChecksumStatsEntry, error) {
3279 _bsntablechecksumstatsentry := &BsnTableChecksumStatsEntry{}
3280 if decoder.Length() < 9 {
3281 return nil, fmt.Errorf("BsnTableChecksumStatsEntry packet too short: %d < 9", decoder.Length())
3282 }
3283 _bsntablechecksumstatsentry.TableId = uint8(decoder.ReadByte())
3284 _bsntablechecksumstatsentry.Checksum = uint64(decoder.ReadUint64())
3285 return _bsntablechecksumstatsentry, nil
3286}
3287
3288func NewBsnTableChecksumStatsEntry() *BsnTableChecksumStatsEntry {
3289 obj := &BsnTableChecksumStatsEntry{}
3290 return obj
3291}
3292
3293type BsnTlv struct {
3294 Type uint16
3295 Length uint16
3296}
3297
3298type IBsnTlv interface {
3299 goloxi.Serializable
3300 GetType() uint16
3301 GetLength() uint16
3302}
3303
3304func (self *BsnTlv) GetType() uint16 {
3305 return self.Type
3306}
3307
3308func (self *BsnTlv) SetType(v uint16) {
3309 self.Type = v
3310}
3311
3312func (self *BsnTlv) GetLength() uint16 {
3313 return self.Length
3314}
3315
3316func (self *BsnTlv) SetLength(v uint16) {
3317 self.Length = v
3318}
3319
3320func (self *BsnTlv) Serialize(encoder *goloxi.Encoder) error {
3321
3322 encoder.PutUint16(uint16(self.Type))
3323 encoder.PutUint16(uint16(self.Length))
3324
3325 return nil
3326}
3327
3328func DecodeBsnTlv(decoder *goloxi.Decoder) (IBsnTlv, error) {
3329 _bsntlv := &BsnTlv{}
3330 if decoder.Length() < 4 {
3331 return nil, fmt.Errorf("BsnTlv packet too short: %d < 4", decoder.Length())
3332 }
3333 _bsntlv.Type = uint16(decoder.ReadUint16())
3334 _bsntlv.Length = uint16(decoder.ReadUint16())
3335 oldDecoder := decoder
3336 defer func() { decoder = oldDecoder }()
3337 decoder = decoder.SliceDecoder(int(_bsntlv.Length), 2+2)
3338
3339 switch _bsntlv.Type {
3340 case 0:
3341 return DecodeBsnTlvPort(_bsntlv, decoder)
3342 case 1:
3343 return DecodeBsnTlvMac(_bsntlv, decoder)
3344 case 2:
3345 return DecodeBsnTlvRxPackets(_bsntlv, decoder)
3346 case 3:
3347 return DecodeBsnTlvTxPackets(_bsntlv, decoder)
3348 case 4:
3349 return DecodeBsnTlvIpv4(_bsntlv, decoder)
3350 case 5:
3351 return DecodeBsnTlvIdleTime(_bsntlv, decoder)
3352 case 6:
3353 return DecodeBsnTlvVlanVid(_bsntlv, decoder)
3354 case 7:
3355 return DecodeBsnTlvIdleNotification(_bsntlv, decoder)
3356 case 8:
3357 return DecodeBsnTlvIdleTimeout(_bsntlv, decoder)
3358 case 9:
3359 return DecodeBsnTlvUnicastQueryTimeout(_bsntlv, decoder)
3360 case 10:
3361 return DecodeBsnTlvBroadcastQueryTimeout(_bsntlv, decoder)
3362 case 11:
3363 return DecodeBsnTlvRequestPackets(_bsntlv, decoder)
3364 case 12:
3365 return DecodeBsnTlvReplyPackets(_bsntlv, decoder)
3366 case 13:
3367 return DecodeBsnTlvMissPackets(_bsntlv, decoder)
3368 case 14:
3369 return DecodeBsnTlvCircuitId(_bsntlv, decoder)
3370 case 15:
3371 return DecodeBsnTlvUdfId(_bsntlv, decoder)
3372 case 16:
3373 return DecodeBsnTlvUdfAnchor(_bsntlv, decoder)
3374 case 17:
3375 return DecodeBsnTlvUdfOffset(_bsntlv, decoder)
3376 case 18:
3377 return DecodeBsnTlvUdfLength(_bsntlv, decoder)
3378 case 19:
3379 return DecodeBsnTlvVrf(_bsntlv, decoder)
3380 case 20:
3381 return DecodeBsnTlvQueueId(_bsntlv, decoder)
3382 case 21:
3383 return DecodeBsnTlvQueueWeight(_bsntlv, decoder)
3384 case 22:
3385 return DecodeBsnTlvCrcEnabled(_bsntlv, decoder)
3386 case 23:
3387 return DecodeBsnTlvExternalIp(_bsntlv, decoder)
3388 case 24:
3389 return DecodeBsnTlvExternalMac(_bsntlv, decoder)
3390 case 25:
3391 return DecodeBsnTlvExternalNetmask(_bsntlv, decoder)
3392 case 26:
3393 return DecodeBsnTlvExternalGatewayIp(_bsntlv, decoder)
3394 case 27:
3395 return DecodeBsnTlvInternalMac(_bsntlv, decoder)
3396 case 28:
3397 return DecodeBsnTlvInternalGatewayMac(_bsntlv, decoder)
3398 case 29:
3399 return DecodeBsnTlvExternalGatewayMac(_bsntlv, decoder)
3400 case 30:
3401 return DecodeBsnTlvSamplingRate(_bsntlv, decoder)
3402 case 31:
3403 return DecodeBsnTlvHeaderSize(_bsntlv, decoder)
3404 case 32:
3405 return DecodeBsnTlvEthSrc(_bsntlv, decoder)
3406 case 33:
3407 return DecodeBsnTlvEthDst(_bsntlv, decoder)
3408 case 34:
3409 return DecodeBsnTlvIpv4Src(_bsntlv, decoder)
3410 case 35:
3411 return DecodeBsnTlvIpv4Dst(_bsntlv, decoder)
3412 case 36:
3413 return DecodeBsnTlvUdpSrc(_bsntlv, decoder)
3414 case 37:
3415 return DecodeBsnTlvUdpDst(_bsntlv, decoder)
3416 case 38:
3417 return DecodeBsnTlvSubAgentId(_bsntlv, decoder)
3418 case 39:
3419 return DecodeBsnTlvTxBytes(_bsntlv, decoder)
3420 case 40:
3421 return DecodeBsnTlvActorSystemPriority(_bsntlv, decoder)
3422 case 41:
3423 return DecodeBsnTlvActorSystemMac(_bsntlv, decoder)
3424 case 42:
3425 return DecodeBsnTlvActorPortPriority(_bsntlv, decoder)
3426 case 43:
3427 return DecodeBsnTlvActorPortNum(_bsntlv, decoder)
3428 case 44:
3429 return DecodeBsnTlvActorKey(_bsntlv, decoder)
3430 case 45:
3431 return DecodeBsnTlvConvergenceStatus(_bsntlv, decoder)
3432 case 47:
3433 return DecodeBsnTlvPartnerSystemPriority(_bsntlv, decoder)
3434 case 48:
3435 return DecodeBsnTlvPartnerSystemMac(_bsntlv, decoder)
3436 case 49:
3437 return DecodeBsnTlvPartnerPortPriority(_bsntlv, decoder)
3438 case 50:
3439 return DecodeBsnTlvPartnerPortNum(_bsntlv, decoder)
3440 case 51:
3441 return DecodeBsnTlvPartnerKey(_bsntlv, decoder)
3442 case 52:
3443 return DecodeBsnTlvName(_bsntlv, decoder)
3444 case 53:
3445 return DecodeBsnTlvActorState(_bsntlv, decoder)
3446 case 54:
3447 return DecodeBsnTlvPartnerState(_bsntlv, decoder)
3448 case 55:
3449 return DecodeBsnTlvData(_bsntlv, decoder)
3450 case 56:
3451 return DecodeBsnTlvMacMask(_bsntlv, decoder)
3452 case 57:
3453 return DecodeBsnTlvPriority(_bsntlv, decoder)
3454 case 58:
3455 return DecodeBsnTlvInterval(_bsntlv, decoder)
3456 case 59:
3457 return DecodeBsnTlvReference(_bsntlv, decoder)
3458 case 60:
3459 return DecodeBsnTlvIpv4Netmask(_bsntlv, decoder)
3460 case 61:
3461 return DecodeBsnTlvMplsLabel(_bsntlv, decoder)
3462 case 62:
3463 return DecodeBsnTlvMplsControlWord(_bsntlv, decoder)
3464 case 63:
3465 return DecodeBsnTlvMplsSequenced(_bsntlv, decoder)
3466 case 64:
3467 return DecodeBsnTlvBucket(_bsntlv, decoder)
3468 case 65:
3469 return DecodeBsnTlvTcpSrc(_bsntlv, decoder)
3470 case 66:
3471 return DecodeBsnTlvTcpDst(_bsntlv, decoder)
3472 case 67:
3473 return DecodeBsnTlvIpProto(_bsntlv, decoder)
3474 case 68:
3475 return DecodeBsnTlvIcmpType(_bsntlv, decoder)
3476 case 69:
3477 return DecodeBsnTlvIcmpCode(_bsntlv, decoder)
3478 case 70:
3479 return DecodeBsnTlvIcmpId(_bsntlv, decoder)
3480 case 71:
3481 return DecodeBsnTlvRxBytes(_bsntlv, decoder)
3482 case 72:
3483 return DecodeBsnTlvVlanPcp(_bsntlv, decoder)
3484 case 73:
3485 return DecodeBsnTlvStripVlanOnEgress(_bsntlv, decoder)
3486 case 74:
3487 return DecodeBsnTlvSetLoopbackMode(_bsntlv, decoder)
3488 case 75:
3489 return DecodeBsnTlvStripMplsL2OnIngress(_bsntlv, decoder)
3490 case 76:
3491 return DecodeBsnTlvStripMplsL3OnIngress(_bsntlv, decoder)
3492 case 77:
3493 return DecodeBsnTlvVlanVidMask(_bsntlv, decoder)
3494 case 78:
3495 return DecodeBsnTlvIgmpSnooping(_bsntlv, decoder)
3496 case 79:
3497 return DecodeBsnTlvL2MulticastLookup(_bsntlv, decoder)
3498 case 80:
3499 return DecodeBsnTlvGenerationId(_bsntlv, decoder)
3500 case 81:
3501 return DecodeBsnTlvAnchor(_bsntlv, decoder)
3502 case 82:
3503 return DecodeBsnTlvOffset(_bsntlv, decoder)
3504 case 83:
3505 return DecodeBsnTlvNegate(_bsntlv, decoder)
3506 case 84:
3507 return DecodeBsnTlvIpv6(_bsntlv, decoder)
3508 case 85:
3509 return DecodeBsnTlvDecap(_bsntlv, decoder)
3510 case 86:
3511 return DecodeBsnTlvVni(_bsntlv, decoder)
3512 case 87:
3513 return DecodeBsnTlvMcgTypeVxlan(_bsntlv, decoder)
3514 case 88:
3515 return DecodeBsnTlvPortVxlanMode(_bsntlv, decoder)
3516 case 89:
3517 return DecodeBsnTlvRateUnit(_bsntlv, decoder)
3518 case 90:
3519 return DecodeBsnTlvBroadcastRate(_bsntlv, decoder)
3520 case 91:
3521 return DecodeBsnTlvKnownMulticastRate(_bsntlv, decoder)
3522 case 92:
3523 return DecodeBsnTlvUnknownMulticastRate(_bsntlv, decoder)
3524 case 93:
3525 return DecodeBsnTlvUnicastRate(_bsntlv, decoder)
3526 case 94:
3527 return DecodeBsnTlvNexthopTypeVxlan(_bsntlv, decoder)
3528 case 95:
3529 return DecodeBsnTlvMulticastInterfaceId(_bsntlv, decoder)
3530 case 96:
3531 return DecodeBsnTlvUsePacketState(_bsntlv, decoder)
3532 case 97:
3533 return DecodeBsnTlvStatus(_bsntlv, decoder)
3534 case 98:
3535 return DecodeBsnTlvVlanMacList(_bsntlv, decoder)
3536 case 99:
3537 return DecodeBsnTlvVfi(_bsntlv, decoder)
3538 case 100:
3539 return DecodeBsnTlvHashSeed(_bsntlv, decoder)
3540 case 101:
3541 return DecodeBsnTlvHashType(_bsntlv, decoder)
3542 case 102:
3543 return DecodeBsnTlvHashPacketType(_bsntlv, decoder)
3544 case 103:
3545 return DecodeBsnTlvHashPacketField(_bsntlv, decoder)
3546 case 104:
3547 return DecodeBsnTlvHashGtpHeaderMatch(_bsntlv, decoder)
3548 case 105:
3549 return DecodeBsnTlvHashGtpPortMatch(_bsntlv, decoder)
3550 case 106:
3551 return DecodeBsnTlvUntagged(_bsntlv, decoder)
3552 case 107:
3553 return DecodeBsnTlvVfpClassId(_bsntlv, decoder)
3554 case 108:
3555 return DecodeBsnTlvQosPriority(_bsntlv, decoder)
3556 case 109:
3557 return DecodeBsnTlvParentPort(_bsntlv, decoder)
3558 case 110:
3559 return DecodeBsnTlvLoopbackPort(_bsntlv, decoder)
3560 case 111:
3561 return DecodeBsnTlvVpnKey(_bsntlv, decoder)
3562 case 112:
3563 return DecodeBsnTlvDscp(_bsntlv, decoder)
3564 case 113:
3565 return DecodeBsnTlvTtl(_bsntlv, decoder)
3566 case 114:
3567 return DecodeBsnTlvNextHopMac(_bsntlv, decoder)
3568 case 115:
3569 return DecodeBsnTlvNextHopIpv4(_bsntlv, decoder)
3570 case 116:
3571 return DecodeBsnTlvRateLimit(_bsntlv, decoder)
3572 case 117:
3573 return DecodeBsnTlvVxlanEgressLag(_bsntlv, decoder)
3574 case 118:
3575 return DecodeBsnTlvCpuLag(_bsntlv, decoder)
3576 case 119:
3577 return DecodeBsnTlvUint64List(_bsntlv, decoder)
3578 case 120:
3579 return DecodeBsnTlvDisableSrcMacCheck(_bsntlv, decoder)
3580 case 121:
3581 return DecodeBsnTlvDrop(_bsntlv, decoder)
3582 case 122:
3583 return DecodeBsnTlvIpv6Prefix(_bsntlv, decoder)
3584 case 123:
3585 return DecodeBsnTlvNdpOffload(_bsntlv, decoder)
3586 case 124:
3587 return DecodeBsnTlvNdpStatic(_bsntlv, decoder)
3588 case 125:
3589 return DecodeBsnTlvIcmpv6Chksum(_bsntlv, decoder)
3590 case 126:
3591 return DecodeBsnTlvIpv6Src(_bsntlv, decoder)
3592 case 127:
3593 return DecodeBsnTlvIpv6Dst(_bsntlv, decoder)
3594 case 128:
3595 return DecodeBsnTlvPushVlanOnIngress(_bsntlv, decoder)
3596 case 129:
3597 return DecodeBsnTlvApplyPackets(_bsntlv, decoder)
3598 case 130:
3599 return DecodeBsnTlvApplyBytes(_bsntlv, decoder)
3600 case 131:
3601 return DecodeBsnTlvEthType(_bsntlv, decoder)
3602 case 132:
3603 return DecodeBsnTlvEcn(_bsntlv, decoder)
3604 case 133:
3605 return DecodeBsnTlvTcpFlags(_bsntlv, decoder)
3606 case 134:
3607 return DecodeBsnTlvL3InterfaceClassId(_bsntlv, decoder)
3608 case 135:
3609 return DecodeBsnTlvL3SrcClassId(_bsntlv, decoder)
3610 case 136:
3611 return DecodeBsnTlvL3DstClassId(_bsntlv, decoder)
3612 case 137:
3613 return DecodeBsnTlvEgressOnly(_bsntlv, decoder)
3614 case 138:
3615 return DecodeBsnTlvIngressPortGroupId(_bsntlv, decoder)
3616 case 139:
3617 return DecodeBsnTlvEgressPortGroupId(_bsntlv, decoder)
3618 case 140:
3619 return DecodeBsnTlvDataMask(_bsntlv, decoder)
3620 case 141:
3621 return DecodeBsnTlvPortUsage(_bsntlv, decoder)
3622 case 142:
3623 return DecodeBsnTlvTunnelCapability(_bsntlv, decoder)
3624 case 143:
3625 return DecodeBsnTlvEnhancedHashCapability(_bsntlv, decoder)
3626 case 144:
3627 return DecodeBsnTlvAutoNegotiation(_bsntlv, decoder)
3628 case 145:
3629 return DecodeBsnTlvHashAlgorithm(_bsntlv, decoder)
3630 case 146:
3631 return DecodeBsnTlvLoopbackMode(_bsntlv, decoder)
3632 case 147:
3633 return DecodeBsnTlvNoArpResponse(_bsntlv, decoder)
3634 case 148:
3635 return DecodeBsnTlvNoNsResponse(_bsntlv, decoder)
3636 case 149:
3637 return DecodeBsnTlvForwardErrorCorrection(_bsntlv, decoder)
3638 case 150:
3639 return DecodeBsnTlvOpticsAlwaysEnabled(_bsntlv, decoder)
3640 case 151:
3641 return DecodeBsnTlvForceLinkUp(_bsntlv, decoder)
3642 case 152:
3643 return DecodeBsnTlvRestServer(_bsntlv, decoder)
3644 case 153:
3645 return DecodeBsnTlvUriScheme(_bsntlv, decoder)
3646 case 154:
3647 return DecodeBsnTlvTimestamp(_bsntlv, decoder)
3648 case 155:
3649 return DecodeBsnTlvRecordPackets(_bsntlv, decoder)
3650 case 156:
3651 return DecodeBsnTlvPortSpeedGbps(_bsntlv, decoder)
3652 case 157:
3653 return DecodeBsnTlvOuterSrcMac(_bsntlv, decoder)
3654 case 158:
3655 return DecodeBsnTlvVirtual(_bsntlv, decoder)
3656 case 159:
3657 return DecodeBsnTlvPduaRxInstance(_bsntlv, decoder)
3658 case 160:
3659 return DecodeBsnTlvLagOptions(_bsntlv, decoder)
3660 case 161:
3661 return DecodeBsnTlvRoutingParam(_bsntlv, decoder)
3662 case 162:
3663 return DecodeBsnTlvPushVlanOnEgress(_bsntlv, decoder)
3664 case 163:
3665 return DecodeBsnTlvFlood(_bsntlv, decoder)
3666 case 164:
3667 return DecodeBsnTlvUpgrade(_bsntlv, decoder)
3668 case 165:
3669 return DecodeBsnTlvFabricPortRole(_bsntlv, decoder)
3670 case 166:
3671 return DecodeBsnTlvUserConfigured(_bsntlv, decoder)
3672 case 167:
3673 return DecodeBsnTlvUint32(_bsntlv, decoder)
3674 case 168:
3675 return DecodeBsnTlvL3(_bsntlv, decoder)
3676 case 169:
3677 return DecodeBsnTlvIpTunnelType(_bsntlv, decoder)
3678 case 170:
3679 return DecodeBsnTlvMulticastPacket(_bsntlv, decoder)
3680 case 171:
3681 return DecodeBsnTlvPimDr(_bsntlv, decoder)
3682 case 172:
3683 return DecodeBsnTlvPassive(_bsntlv, decoder)
3684 case 173:
3685 return DecodeBsnTlvIdentifier(_bsntlv, decoder)
3686 case 174:
3687 return DecodeBsnTlvMultiplier(_bsntlv, decoder)
3688 case 175:
3689 return DecodeBsnTlvEncap(_bsntlv, decoder)
3690 case 176:
3691 return DecodeBsnTlvBfdEndpoint(_bsntlv, decoder)
3692 case 177:
3693 return DecodeBsnTlvBfdState(_bsntlv, decoder)
3694 case 178:
3695 return DecodeBsnTlvLrAllEnabled(_bsntlv, decoder)
3696 case 179:
3697 return DecodeBsnTlvPortMode(_bsntlv, decoder)
3698 case 180:
3699 return DecodeBsnTlvUdfCapability(_bsntlv, decoder)
3700 case 181:
3701 return DecodeBsnTlvPimHelloFlood(_bsntlv, decoder)
3702 case 182:
3703 return DecodeBsnTlvFlowClassify(_bsntlv, decoder)
3704 case 183:
3705 return DecodeBsnTlvFlowIdentifier(_bsntlv, decoder)
3706 case 184:
3707 return DecodeBsnTlvFlowClassifier(_bsntlv, decoder)
3708 case 185:
3709 return DecodeBsnTlvDisableXmit(_bsntlv, decoder)
3710 case 186:
3711 return DecodeBsnTlvPreserveVlan(_bsntlv, decoder)
3712 case 187:
3713 return DecodeBsnTlvDropControl(_bsntlv, decoder)
3714 case 188:
3715 return DecodeBsnTlvLossless(_bsntlv, decoder)
3716 case 189:
3717 return DecodeBsnTlvRedundantMgmt(_bsntlv, decoder)
3718 case 190:
3719 return DecodeBsnTlvDnsAnalytics(_bsntlv, decoder)
3720 case 191:
3721 return DecodeBsnTlvSrcMacCml(_bsntlv, decoder)
3722 case 192:
3723 return DecodeBsnTlvActive(_bsntlv, decoder)
3724 case 193:
3725 return DecodeBsnTlvLinkUp(_bsntlv, decoder)
3726 case 194:
3727 return DecodeBsnTlvFailCount(_bsntlv, decoder)
3728 case 195:
3729 return DecodeBsnTlvEgressSamplingRate(_bsntlv, decoder)
3730 default:
3731 return nil, fmt.Errorf("Invalid type '%d' for 'BsnTlv'", _bsntlv.Type)
3732 }
3733}
3734
3735func NewBsnTlv(_type uint16) *BsnTlv {
3736 obj := &BsnTlv{}
3737 obj.Type = _type
3738 return obj
3739}
3740
3741type BsnTlvActive struct {
3742 *BsnTlv
3743}
3744
3745type IBsnTlvActive interface {
3746 IBsnTlv
3747}
3748
3749func (self *BsnTlvActive) Serialize(encoder *goloxi.Encoder) error {
3750 startIndex := len(encoder.Bytes())
3751 if err := self.BsnTlv.Serialize(encoder); err != nil {
3752 return err
3753 }
3754 length := len(encoder.Bytes()) - startIndex
3755
3756 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
3757
3758 return nil
3759}
3760
3761func DecodeBsnTlvActive(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvActive, error) {
3762 _bsntlvactive := &BsnTlvActive{BsnTlv: parent}
3763 return _bsntlvactive, nil
3764}
3765
3766func NewBsnTlvActive() *BsnTlvActive {
3767 obj := &BsnTlvActive{
3768 BsnTlv: NewBsnTlv(192),
3769 }
3770 return obj
3771}
3772
3773type BsnTlvActorKey struct {
3774 *BsnTlv
3775 Value uint16
3776}
3777
3778type IBsnTlvActorKey interface {
3779 IBsnTlv
3780 GetValue() uint16
3781}
3782
3783func (self *BsnTlvActorKey) GetValue() uint16 {
3784 return self.Value
3785}
3786
3787func (self *BsnTlvActorKey) SetValue(v uint16) {
3788 self.Value = v
3789}
3790
3791func (self *BsnTlvActorKey) Serialize(encoder *goloxi.Encoder) error {
3792 startIndex := len(encoder.Bytes())
3793 if err := self.BsnTlv.Serialize(encoder); err != nil {
3794 return err
3795 }
3796
3797 encoder.PutUint16(uint16(self.Value))
3798 length := len(encoder.Bytes()) - startIndex
3799
3800 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
3801
3802 return nil
3803}
3804
3805func DecodeBsnTlvActorKey(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvActorKey, error) {
3806 _bsntlvactorkey := &BsnTlvActorKey{BsnTlv: parent}
3807 if decoder.Length() < 2 {
3808 return nil, fmt.Errorf("BsnTlvActorKey packet too short: %d < 2", decoder.Length())
3809 }
3810 _bsntlvactorkey.Value = uint16(decoder.ReadUint16())
3811 return _bsntlvactorkey, nil
3812}
3813
3814func NewBsnTlvActorKey() *BsnTlvActorKey {
3815 obj := &BsnTlvActorKey{
3816 BsnTlv: NewBsnTlv(44),
3817 }
3818 return obj
3819}
3820
3821type BsnTlvActorPortNum struct {
3822 *BsnTlv
3823 Value uint16
3824}
3825
3826type IBsnTlvActorPortNum interface {
3827 IBsnTlv
3828 GetValue() uint16
3829}
3830
3831func (self *BsnTlvActorPortNum) GetValue() uint16 {
3832 return self.Value
3833}
3834
3835func (self *BsnTlvActorPortNum) SetValue(v uint16) {
3836 self.Value = v
3837}
3838
3839func (self *BsnTlvActorPortNum) Serialize(encoder *goloxi.Encoder) error {
3840 startIndex := len(encoder.Bytes())
3841 if err := self.BsnTlv.Serialize(encoder); err != nil {
3842 return err
3843 }
3844
3845 encoder.PutUint16(uint16(self.Value))
3846 length := len(encoder.Bytes()) - startIndex
3847
3848 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
3849
3850 return nil
3851}
3852
3853func DecodeBsnTlvActorPortNum(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvActorPortNum, error) {
3854 _bsntlvactorportnum := &BsnTlvActorPortNum{BsnTlv: parent}
3855 if decoder.Length() < 2 {
3856 return nil, fmt.Errorf("BsnTlvActorPortNum packet too short: %d < 2", decoder.Length())
3857 }
3858 _bsntlvactorportnum.Value = uint16(decoder.ReadUint16())
3859 return _bsntlvactorportnum, nil
3860}
3861
3862func NewBsnTlvActorPortNum() *BsnTlvActorPortNum {
3863 obj := &BsnTlvActorPortNum{
3864 BsnTlv: NewBsnTlv(43),
3865 }
3866 return obj
3867}
3868
3869type BsnTlvActorPortPriority struct {
3870 *BsnTlv
3871 Value uint16
3872}
3873
3874type IBsnTlvActorPortPriority interface {
3875 IBsnTlv
3876 GetValue() uint16
3877}
3878
3879func (self *BsnTlvActorPortPriority) GetValue() uint16 {
3880 return self.Value
3881}
3882
3883func (self *BsnTlvActorPortPriority) SetValue(v uint16) {
3884 self.Value = v
3885}
3886
3887func (self *BsnTlvActorPortPriority) Serialize(encoder *goloxi.Encoder) error {
3888 startIndex := len(encoder.Bytes())
3889 if err := self.BsnTlv.Serialize(encoder); err != nil {
3890 return err
3891 }
3892
3893 encoder.PutUint16(uint16(self.Value))
3894 length := len(encoder.Bytes()) - startIndex
3895
3896 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
3897
3898 return nil
3899}
3900
3901func DecodeBsnTlvActorPortPriority(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvActorPortPriority, error) {
3902 _bsntlvactorportpriority := &BsnTlvActorPortPriority{BsnTlv: parent}
3903 if decoder.Length() < 2 {
3904 return nil, fmt.Errorf("BsnTlvActorPortPriority packet too short: %d < 2", decoder.Length())
3905 }
3906 _bsntlvactorportpriority.Value = uint16(decoder.ReadUint16())
3907 return _bsntlvactorportpriority, nil
3908}
3909
3910func NewBsnTlvActorPortPriority() *BsnTlvActorPortPriority {
3911 obj := &BsnTlvActorPortPriority{
3912 BsnTlv: NewBsnTlv(42),
3913 }
3914 return obj
3915}
3916
3917type BsnTlvActorState struct {
3918 *BsnTlv
3919 Value BsnLacpState
3920}
3921
3922type IBsnTlvActorState interface {
3923 IBsnTlv
3924 GetValue() BsnLacpState
3925}
3926
3927func (self *BsnTlvActorState) GetValue() BsnLacpState {
3928 return self.Value
3929}
3930
3931func (self *BsnTlvActorState) SetValue(v BsnLacpState) {
3932 self.Value = v
3933}
3934
3935func (self *BsnTlvActorState) Serialize(encoder *goloxi.Encoder) error {
3936 startIndex := len(encoder.Bytes())
3937 if err := self.BsnTlv.Serialize(encoder); err != nil {
3938 return err
3939 }
3940
3941 encoder.PutUint8(uint8(self.Value))
3942 length := len(encoder.Bytes()) - startIndex
3943
3944 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
3945
3946 return nil
3947}
3948
3949func DecodeBsnTlvActorState(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvActorState, error) {
3950 _bsntlvactorstate := &BsnTlvActorState{BsnTlv: parent}
3951 if decoder.Length() < 1 {
3952 return nil, fmt.Errorf("BsnTlvActorState packet too short: %d < 1", decoder.Length())
3953 }
3954 _bsntlvactorstate.Value = BsnLacpState(decoder.ReadByte())
3955 return _bsntlvactorstate, nil
3956}
3957
3958func NewBsnTlvActorState() *BsnTlvActorState {
3959 obj := &BsnTlvActorState{
3960 BsnTlv: NewBsnTlv(53),
3961 }
3962 return obj
3963}
3964
3965type BsnTlvActorSystemMac struct {
3966 *BsnTlv
3967 Value net.HardwareAddr
3968}
3969
3970type IBsnTlvActorSystemMac interface {
3971 IBsnTlv
3972 GetValue() net.HardwareAddr
3973}
3974
3975func (self *BsnTlvActorSystemMac) GetValue() net.HardwareAddr {
3976 return self.Value
3977}
3978
3979func (self *BsnTlvActorSystemMac) SetValue(v net.HardwareAddr) {
3980 self.Value = v
3981}
3982
3983func (self *BsnTlvActorSystemMac) Serialize(encoder *goloxi.Encoder) error {
3984 startIndex := len(encoder.Bytes())
3985 if err := self.BsnTlv.Serialize(encoder); err != nil {
3986 return err
3987 }
3988
3989 encoder.Write(self.Value)
3990 length := len(encoder.Bytes()) - startIndex
3991
3992 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
3993
3994 return nil
3995}
3996
3997func DecodeBsnTlvActorSystemMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvActorSystemMac, error) {
3998 _bsntlvactorsystemmac := &BsnTlvActorSystemMac{BsnTlv: parent}
3999 if decoder.Length() < 6 {
4000 return nil, fmt.Errorf("BsnTlvActorSystemMac packet too short: %d < 6", decoder.Length())
4001 }
4002 _bsntlvactorsystemmac.Value = net.HardwareAddr(decoder.Read(6))
4003 return _bsntlvactorsystemmac, nil
4004}
4005
4006func NewBsnTlvActorSystemMac() *BsnTlvActorSystemMac {
4007 obj := &BsnTlvActorSystemMac{
4008 BsnTlv: NewBsnTlv(41),
4009 }
4010 return obj
4011}
4012
4013type BsnTlvActorSystemPriority struct {
4014 *BsnTlv
4015 Value uint16
4016}
4017
4018type IBsnTlvActorSystemPriority interface {
4019 IBsnTlv
4020 GetValue() uint16
4021}
4022
4023func (self *BsnTlvActorSystemPriority) GetValue() uint16 {
4024 return self.Value
4025}
4026
4027func (self *BsnTlvActorSystemPriority) SetValue(v uint16) {
4028 self.Value = v
4029}
4030
4031func (self *BsnTlvActorSystemPriority) Serialize(encoder *goloxi.Encoder) error {
4032 startIndex := len(encoder.Bytes())
4033 if err := self.BsnTlv.Serialize(encoder); err != nil {
4034 return err
4035 }
4036
4037 encoder.PutUint16(uint16(self.Value))
4038 length := len(encoder.Bytes()) - startIndex
4039
4040 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4041
4042 return nil
4043}
4044
4045func DecodeBsnTlvActorSystemPriority(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvActorSystemPriority, error) {
4046 _bsntlvactorsystempriority := &BsnTlvActorSystemPriority{BsnTlv: parent}
4047 if decoder.Length() < 2 {
4048 return nil, fmt.Errorf("BsnTlvActorSystemPriority packet too short: %d < 2", decoder.Length())
4049 }
4050 _bsntlvactorsystempriority.Value = uint16(decoder.ReadUint16())
4051 return _bsntlvactorsystempriority, nil
4052}
4053
4054func NewBsnTlvActorSystemPriority() *BsnTlvActorSystemPriority {
4055 obj := &BsnTlvActorSystemPriority{
4056 BsnTlv: NewBsnTlv(40),
4057 }
4058 return obj
4059}
4060
4061type BsnTlvAnchor struct {
4062 *BsnTlv
4063 Value BsnAnchor
4064}
4065
4066type IBsnTlvAnchor interface {
4067 IBsnTlv
4068 GetValue() BsnAnchor
4069}
4070
4071func (self *BsnTlvAnchor) GetValue() BsnAnchor {
4072 return self.Value
4073}
4074
4075func (self *BsnTlvAnchor) SetValue(v BsnAnchor) {
4076 self.Value = v
4077}
4078
4079func (self *BsnTlvAnchor) Serialize(encoder *goloxi.Encoder) error {
4080 startIndex := len(encoder.Bytes())
4081 if err := self.BsnTlv.Serialize(encoder); err != nil {
4082 return err
4083 }
4084
4085 encoder.PutUint16(uint16(self.Value))
4086 length := len(encoder.Bytes()) - startIndex
4087
4088 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4089
4090 return nil
4091}
4092
4093func DecodeBsnTlvAnchor(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvAnchor, error) {
4094 _bsntlvanchor := &BsnTlvAnchor{BsnTlv: parent}
4095 if decoder.Length() < 2 {
4096 return nil, fmt.Errorf("BsnTlvAnchor packet too short: %d < 2", decoder.Length())
4097 }
4098 _bsntlvanchor.Value = BsnAnchor(decoder.ReadUint16())
4099 return _bsntlvanchor, nil
4100}
4101
4102func NewBsnTlvAnchor() *BsnTlvAnchor {
4103 obj := &BsnTlvAnchor{
4104 BsnTlv: NewBsnTlv(81),
4105 }
4106 return obj
4107}
4108
4109type BsnTlvApplyBytes struct {
4110 *BsnTlv
4111 Value uint64
4112}
4113
4114type IBsnTlvApplyBytes interface {
4115 IBsnTlv
4116 GetValue() uint64
4117}
4118
4119func (self *BsnTlvApplyBytes) GetValue() uint64 {
4120 return self.Value
4121}
4122
4123func (self *BsnTlvApplyBytes) SetValue(v uint64) {
4124 self.Value = v
4125}
4126
4127func (self *BsnTlvApplyBytes) Serialize(encoder *goloxi.Encoder) error {
4128 startIndex := len(encoder.Bytes())
4129 if err := self.BsnTlv.Serialize(encoder); err != nil {
4130 return err
4131 }
4132
4133 encoder.PutUint64(uint64(self.Value))
4134 length := len(encoder.Bytes()) - startIndex
4135
4136 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4137
4138 return nil
4139}
4140
4141func DecodeBsnTlvApplyBytes(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvApplyBytes, error) {
4142 _bsntlvapplybytes := &BsnTlvApplyBytes{BsnTlv: parent}
4143 if decoder.Length() < 8 {
4144 return nil, fmt.Errorf("BsnTlvApplyBytes packet too short: %d < 8", decoder.Length())
4145 }
4146 _bsntlvapplybytes.Value = uint64(decoder.ReadUint64())
4147 return _bsntlvapplybytes, nil
4148}
4149
4150func NewBsnTlvApplyBytes() *BsnTlvApplyBytes {
4151 obj := &BsnTlvApplyBytes{
4152 BsnTlv: NewBsnTlv(130),
4153 }
4154 return obj
4155}
4156
4157type BsnTlvApplyPackets struct {
4158 *BsnTlv
4159 Value uint64
4160}
4161
4162type IBsnTlvApplyPackets interface {
4163 IBsnTlv
4164 GetValue() uint64
4165}
4166
4167func (self *BsnTlvApplyPackets) GetValue() uint64 {
4168 return self.Value
4169}
4170
4171func (self *BsnTlvApplyPackets) SetValue(v uint64) {
4172 self.Value = v
4173}
4174
4175func (self *BsnTlvApplyPackets) Serialize(encoder *goloxi.Encoder) error {
4176 startIndex := len(encoder.Bytes())
4177 if err := self.BsnTlv.Serialize(encoder); err != nil {
4178 return err
4179 }
4180
4181 encoder.PutUint64(uint64(self.Value))
4182 length := len(encoder.Bytes()) - startIndex
4183
4184 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4185
4186 return nil
4187}
4188
4189func DecodeBsnTlvApplyPackets(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvApplyPackets, error) {
4190 _bsntlvapplypackets := &BsnTlvApplyPackets{BsnTlv: parent}
4191 if decoder.Length() < 8 {
4192 return nil, fmt.Errorf("BsnTlvApplyPackets packet too short: %d < 8", decoder.Length())
4193 }
4194 _bsntlvapplypackets.Value = uint64(decoder.ReadUint64())
4195 return _bsntlvapplypackets, nil
4196}
4197
4198func NewBsnTlvApplyPackets() *BsnTlvApplyPackets {
4199 obj := &BsnTlvApplyPackets{
4200 BsnTlv: NewBsnTlv(129),
4201 }
4202 return obj
4203}
4204
4205type BsnTlvAutoNegotiation struct {
4206 *BsnTlv
4207 Value BsnAutoNegotiationType
4208}
4209
4210type IBsnTlvAutoNegotiation interface {
4211 IBsnTlv
4212 GetValue() BsnAutoNegotiationType
4213}
4214
4215func (self *BsnTlvAutoNegotiation) GetValue() BsnAutoNegotiationType {
4216 return self.Value
4217}
4218
4219func (self *BsnTlvAutoNegotiation) SetValue(v BsnAutoNegotiationType) {
4220 self.Value = v
4221}
4222
4223func (self *BsnTlvAutoNegotiation) Serialize(encoder *goloxi.Encoder) error {
4224 startIndex := len(encoder.Bytes())
4225 if err := self.BsnTlv.Serialize(encoder); err != nil {
4226 return err
4227 }
4228
4229 encoder.PutUint8(uint8(self.Value))
4230 length := len(encoder.Bytes()) - startIndex
4231
4232 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4233
4234 return nil
4235}
4236
4237func DecodeBsnTlvAutoNegotiation(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvAutoNegotiation, error) {
4238 _bsntlvautonegotiation := &BsnTlvAutoNegotiation{BsnTlv: parent}
4239 if decoder.Length() < 1 {
4240 return nil, fmt.Errorf("BsnTlvAutoNegotiation packet too short: %d < 1", decoder.Length())
4241 }
4242 _bsntlvautonegotiation.Value = BsnAutoNegotiationType(decoder.ReadByte())
4243 return _bsntlvautonegotiation, nil
4244}
4245
4246func NewBsnTlvAutoNegotiation() *BsnTlvAutoNegotiation {
4247 obj := &BsnTlvAutoNegotiation{
4248 BsnTlv: NewBsnTlv(144),
4249 }
4250 return obj
4251}
4252
4253type BsnTlvBfdEndpoint struct {
4254 *BsnTlv
4255 Value BsnBfdEndpoint
4256}
4257
4258type IBsnTlvBfdEndpoint interface {
4259 IBsnTlv
4260 GetValue() BsnBfdEndpoint
4261}
4262
4263func (self *BsnTlvBfdEndpoint) GetValue() BsnBfdEndpoint {
4264 return self.Value
4265}
4266
4267func (self *BsnTlvBfdEndpoint) SetValue(v BsnBfdEndpoint) {
4268 self.Value = v
4269}
4270
4271func (self *BsnTlvBfdEndpoint) Serialize(encoder *goloxi.Encoder) error {
4272 startIndex := len(encoder.Bytes())
4273 if err := self.BsnTlv.Serialize(encoder); err != nil {
4274 return err
4275 }
4276
4277 encoder.PutUint8(uint8(self.Value))
4278 length := len(encoder.Bytes()) - startIndex
4279
4280 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4281
4282 return nil
4283}
4284
4285func DecodeBsnTlvBfdEndpoint(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvBfdEndpoint, error) {
4286 _bsntlvbfdendpoint := &BsnTlvBfdEndpoint{BsnTlv: parent}
4287 if decoder.Length() < 1 {
4288 return nil, fmt.Errorf("BsnTlvBfdEndpoint packet too short: %d < 1", decoder.Length())
4289 }
4290 _bsntlvbfdendpoint.Value = BsnBfdEndpoint(decoder.ReadByte())
4291 return _bsntlvbfdendpoint, nil
4292}
4293
4294func NewBsnTlvBfdEndpoint() *BsnTlvBfdEndpoint {
4295 obj := &BsnTlvBfdEndpoint{
4296 BsnTlv: NewBsnTlv(176),
4297 }
4298 return obj
4299}
4300
4301type BsnTlvBfdState struct {
4302 *BsnTlv
4303 Value BsnBfdEndpointState
4304}
4305
4306type IBsnTlvBfdState interface {
4307 IBsnTlv
4308 GetValue() BsnBfdEndpointState
4309}
4310
4311func (self *BsnTlvBfdState) GetValue() BsnBfdEndpointState {
4312 return self.Value
4313}
4314
4315func (self *BsnTlvBfdState) SetValue(v BsnBfdEndpointState) {
4316 self.Value = v
4317}
4318
4319func (self *BsnTlvBfdState) Serialize(encoder *goloxi.Encoder) error {
4320 startIndex := len(encoder.Bytes())
4321 if err := self.BsnTlv.Serialize(encoder); err != nil {
4322 return err
4323 }
4324
4325 encoder.PutUint8(uint8(self.Value))
4326 length := len(encoder.Bytes()) - startIndex
4327
4328 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4329
4330 return nil
4331}
4332
4333func DecodeBsnTlvBfdState(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvBfdState, error) {
4334 _bsntlvbfdstate := &BsnTlvBfdState{BsnTlv: parent}
4335 if decoder.Length() < 1 {
4336 return nil, fmt.Errorf("BsnTlvBfdState packet too short: %d < 1", decoder.Length())
4337 }
4338 _bsntlvbfdstate.Value = BsnBfdEndpointState(decoder.ReadByte())
4339 return _bsntlvbfdstate, nil
4340}
4341
4342func NewBsnTlvBfdState() *BsnTlvBfdState {
4343 obj := &BsnTlvBfdState{
4344 BsnTlv: NewBsnTlv(177),
4345 }
4346 return obj
4347}
4348
4349type BsnTlvBroadcastQueryTimeout struct {
4350 *BsnTlv
4351 Value uint32
4352}
4353
4354type IBsnTlvBroadcastQueryTimeout interface {
4355 IBsnTlv
4356 GetValue() uint32
4357}
4358
4359func (self *BsnTlvBroadcastQueryTimeout) GetValue() uint32 {
4360 return self.Value
4361}
4362
4363func (self *BsnTlvBroadcastQueryTimeout) SetValue(v uint32) {
4364 self.Value = v
4365}
4366
4367func (self *BsnTlvBroadcastQueryTimeout) Serialize(encoder *goloxi.Encoder) error {
4368 startIndex := len(encoder.Bytes())
4369 if err := self.BsnTlv.Serialize(encoder); err != nil {
4370 return err
4371 }
4372
4373 encoder.PutUint32(uint32(self.Value))
4374 length := len(encoder.Bytes()) - startIndex
4375
4376 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4377
4378 return nil
4379}
4380
4381func DecodeBsnTlvBroadcastQueryTimeout(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvBroadcastQueryTimeout, error) {
4382 _bsntlvbroadcastquerytimeout := &BsnTlvBroadcastQueryTimeout{BsnTlv: parent}
4383 if decoder.Length() < 4 {
4384 return nil, fmt.Errorf("BsnTlvBroadcastQueryTimeout packet too short: %d < 4", decoder.Length())
4385 }
4386 _bsntlvbroadcastquerytimeout.Value = uint32(decoder.ReadUint32())
4387 return _bsntlvbroadcastquerytimeout, nil
4388}
4389
4390func NewBsnTlvBroadcastQueryTimeout() *BsnTlvBroadcastQueryTimeout {
4391 obj := &BsnTlvBroadcastQueryTimeout{
4392 BsnTlv: NewBsnTlv(10),
4393 }
4394 return obj
4395}
4396
4397type BsnTlvBroadcastRate struct {
4398 *BsnTlv
4399 Value uint32
4400}
4401
4402type IBsnTlvBroadcastRate interface {
4403 IBsnTlv
4404 GetValue() uint32
4405}
4406
4407func (self *BsnTlvBroadcastRate) GetValue() uint32 {
4408 return self.Value
4409}
4410
4411func (self *BsnTlvBroadcastRate) SetValue(v uint32) {
4412 self.Value = v
4413}
4414
4415func (self *BsnTlvBroadcastRate) Serialize(encoder *goloxi.Encoder) error {
4416 startIndex := len(encoder.Bytes())
4417 if err := self.BsnTlv.Serialize(encoder); err != nil {
4418 return err
4419 }
4420
4421 encoder.PutUint32(uint32(self.Value))
4422 length := len(encoder.Bytes()) - startIndex
4423
4424 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4425
4426 return nil
4427}
4428
4429func DecodeBsnTlvBroadcastRate(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvBroadcastRate, error) {
4430 _bsntlvbroadcastrate := &BsnTlvBroadcastRate{BsnTlv: parent}
4431 if decoder.Length() < 4 {
4432 return nil, fmt.Errorf("BsnTlvBroadcastRate packet too short: %d < 4", decoder.Length())
4433 }
4434 _bsntlvbroadcastrate.Value = uint32(decoder.ReadUint32())
4435 return _bsntlvbroadcastrate, nil
4436}
4437
4438func NewBsnTlvBroadcastRate() *BsnTlvBroadcastRate {
4439 obj := &BsnTlvBroadcastRate{
4440 BsnTlv: NewBsnTlv(90),
4441 }
4442 return obj
4443}
4444
4445type BsnTlvBucket struct {
4446 *BsnTlv
4447 Value []IBsnTlv
4448}
4449
4450type IBsnTlvBucket interface {
4451 IBsnTlv
4452 GetValue() []IBsnTlv
4453}
4454
4455func (self *BsnTlvBucket) GetValue() []IBsnTlv {
4456 return self.Value
4457}
4458
4459func (self *BsnTlvBucket) SetValue(v []IBsnTlv) {
4460 self.Value = v
4461}
4462
4463func (self *BsnTlvBucket) Serialize(encoder *goloxi.Encoder) error {
4464 startIndex := len(encoder.Bytes())
4465 if err := self.BsnTlv.Serialize(encoder); err != nil {
4466 return err
4467 }
4468
4469 for _, obj := range self.Value {
4470 if err := obj.Serialize(encoder); err != nil {
4471 return err
4472 }
4473 }
4474 length := len(encoder.Bytes()) - startIndex
4475
4476 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4477
4478 return nil
4479}
4480
4481func DecodeBsnTlvBucket(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvBucket, error) {
4482 _bsntlvbucket := &BsnTlvBucket{BsnTlv: parent}
4483
4484 for decoder.Length() >= 4 {
4485 item, err := DecodeBsnTlv(decoder)
4486 if err != nil {
4487 return nil, err
4488 }
4489 if item != nil {
4490 _bsntlvbucket.Value = append(_bsntlvbucket.Value, item)
4491 }
4492 }
4493 return _bsntlvbucket, nil
4494}
4495
4496func NewBsnTlvBucket() *BsnTlvBucket {
4497 obj := &BsnTlvBucket{
4498 BsnTlv: NewBsnTlv(64),
4499 }
4500 return obj
4501}
4502
4503type BsnTlvCircuitId struct {
4504 *BsnTlv
4505 Value []byte
4506}
4507
4508type IBsnTlvCircuitId interface {
4509 IBsnTlv
4510 GetValue() []byte
4511}
4512
4513func (self *BsnTlvCircuitId) GetValue() []byte {
4514 return self.Value
4515}
4516
4517func (self *BsnTlvCircuitId) SetValue(v []byte) {
4518 self.Value = v
4519}
4520
4521func (self *BsnTlvCircuitId) Serialize(encoder *goloxi.Encoder) error {
4522 startIndex := len(encoder.Bytes())
4523 if err := self.BsnTlv.Serialize(encoder); err != nil {
4524 return err
4525 }
4526
4527 encoder.Write(self.Value)
4528 length := len(encoder.Bytes()) - startIndex
4529
4530 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4531
4532 return nil
4533}
4534
4535func DecodeBsnTlvCircuitId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvCircuitId, error) {
4536 _bsntlvcircuitid := &BsnTlvCircuitId{BsnTlv: parent}
4537 _bsntlvcircuitid.Value = decoder.Read(int(decoder.Length()))
4538 return _bsntlvcircuitid, nil
4539}
4540
4541func NewBsnTlvCircuitId() *BsnTlvCircuitId {
4542 obj := &BsnTlvCircuitId{
4543 BsnTlv: NewBsnTlv(14),
4544 }
4545 return obj
4546}
4547
4548type BsnTlvConvergenceStatus struct {
4549 *BsnTlv
4550 Value uint8
4551}
4552
4553type IBsnTlvConvergenceStatus interface {
4554 IBsnTlv
4555 GetValue() uint8
4556}
4557
4558func (self *BsnTlvConvergenceStatus) GetValue() uint8 {
4559 return self.Value
4560}
4561
4562func (self *BsnTlvConvergenceStatus) SetValue(v uint8) {
4563 self.Value = v
4564}
4565
4566func (self *BsnTlvConvergenceStatus) Serialize(encoder *goloxi.Encoder) error {
4567 startIndex := len(encoder.Bytes())
4568 if err := self.BsnTlv.Serialize(encoder); err != nil {
4569 return err
4570 }
4571
4572 encoder.PutUint8(uint8(self.Value))
4573 length := len(encoder.Bytes()) - startIndex
4574
4575 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4576
4577 return nil
4578}
4579
4580func DecodeBsnTlvConvergenceStatus(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvConvergenceStatus, error) {
4581 _bsntlvconvergencestatus := &BsnTlvConvergenceStatus{BsnTlv: parent}
4582 if decoder.Length() < 1 {
4583 return nil, fmt.Errorf("BsnTlvConvergenceStatus packet too short: %d < 1", decoder.Length())
4584 }
4585 _bsntlvconvergencestatus.Value = uint8(decoder.ReadByte())
4586 return _bsntlvconvergencestatus, nil
4587}
4588
4589func NewBsnTlvConvergenceStatus() *BsnTlvConvergenceStatus {
4590 obj := &BsnTlvConvergenceStatus{
4591 BsnTlv: NewBsnTlv(45),
4592 }
4593 return obj
4594}
4595
4596type BsnTlvCpuLag struct {
4597 *BsnTlv
4598}
4599
4600type IBsnTlvCpuLag interface {
4601 IBsnTlv
4602}
4603
4604func (self *BsnTlvCpuLag) Serialize(encoder *goloxi.Encoder) error {
4605 startIndex := len(encoder.Bytes())
4606 if err := self.BsnTlv.Serialize(encoder); err != nil {
4607 return err
4608 }
4609 length := len(encoder.Bytes()) - startIndex
4610
4611 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4612
4613 return nil
4614}
4615
4616func DecodeBsnTlvCpuLag(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvCpuLag, error) {
4617 _bsntlvcpulag := &BsnTlvCpuLag{BsnTlv: parent}
4618 return _bsntlvcpulag, nil
4619}
4620
4621func NewBsnTlvCpuLag() *BsnTlvCpuLag {
4622 obj := &BsnTlvCpuLag{
4623 BsnTlv: NewBsnTlv(118),
4624 }
4625 return obj
4626}
4627
4628type BsnTlvCrcEnabled struct {
4629 *BsnTlv
4630 Value uint8
4631}
4632
4633type IBsnTlvCrcEnabled interface {
4634 IBsnTlv
4635 GetValue() uint8
4636}
4637
4638func (self *BsnTlvCrcEnabled) GetValue() uint8 {
4639 return self.Value
4640}
4641
4642func (self *BsnTlvCrcEnabled) SetValue(v uint8) {
4643 self.Value = v
4644}
4645
4646func (self *BsnTlvCrcEnabled) Serialize(encoder *goloxi.Encoder) error {
4647 startIndex := len(encoder.Bytes())
4648 if err := self.BsnTlv.Serialize(encoder); err != nil {
4649 return err
4650 }
4651
4652 encoder.PutUint8(uint8(self.Value))
4653 length := len(encoder.Bytes()) - startIndex
4654
4655 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4656
4657 return nil
4658}
4659
4660func DecodeBsnTlvCrcEnabled(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvCrcEnabled, error) {
4661 _bsntlvcrcenabled := &BsnTlvCrcEnabled{BsnTlv: parent}
4662 if decoder.Length() < 1 {
4663 return nil, fmt.Errorf("BsnTlvCrcEnabled packet too short: %d < 1", decoder.Length())
4664 }
4665 _bsntlvcrcenabled.Value = uint8(decoder.ReadByte())
4666 return _bsntlvcrcenabled, nil
4667}
4668
4669func NewBsnTlvCrcEnabled() *BsnTlvCrcEnabled {
4670 obj := &BsnTlvCrcEnabled{
4671 BsnTlv: NewBsnTlv(22),
4672 }
4673 return obj
4674}
4675
4676type BsnTlvData struct {
4677 *BsnTlv
4678 Value []byte
4679}
4680
4681type IBsnTlvData interface {
4682 IBsnTlv
4683 GetValue() []byte
4684}
4685
4686func (self *BsnTlvData) GetValue() []byte {
4687 return self.Value
4688}
4689
4690func (self *BsnTlvData) SetValue(v []byte) {
4691 self.Value = v
4692}
4693
4694func (self *BsnTlvData) Serialize(encoder *goloxi.Encoder) error {
4695 startIndex := len(encoder.Bytes())
4696 if err := self.BsnTlv.Serialize(encoder); err != nil {
4697 return err
4698 }
4699
4700 encoder.Write(self.Value)
4701 length := len(encoder.Bytes()) - startIndex
4702
4703 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4704
4705 return nil
4706}
4707
4708func DecodeBsnTlvData(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvData, error) {
4709 _bsntlvdata := &BsnTlvData{BsnTlv: parent}
4710 _bsntlvdata.Value = decoder.Read(int(decoder.Length()))
4711 return _bsntlvdata, nil
4712}
4713
4714func NewBsnTlvData() *BsnTlvData {
4715 obj := &BsnTlvData{
4716 BsnTlv: NewBsnTlv(55),
4717 }
4718 return obj
4719}
4720
4721type BsnTlvDataMask struct {
4722 *BsnTlv
4723 Value []byte
4724}
4725
4726type IBsnTlvDataMask interface {
4727 IBsnTlv
4728 GetValue() []byte
4729}
4730
4731func (self *BsnTlvDataMask) GetValue() []byte {
4732 return self.Value
4733}
4734
4735func (self *BsnTlvDataMask) SetValue(v []byte) {
4736 self.Value = v
4737}
4738
4739func (self *BsnTlvDataMask) Serialize(encoder *goloxi.Encoder) error {
4740 startIndex := len(encoder.Bytes())
4741 if err := self.BsnTlv.Serialize(encoder); err != nil {
4742 return err
4743 }
4744
4745 encoder.Write(self.Value)
4746 length := len(encoder.Bytes()) - startIndex
4747
4748 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4749
4750 return nil
4751}
4752
4753func DecodeBsnTlvDataMask(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvDataMask, error) {
4754 _bsntlvdatamask := &BsnTlvDataMask{BsnTlv: parent}
4755 _bsntlvdatamask.Value = decoder.Read(int(decoder.Length()))
4756 return _bsntlvdatamask, nil
4757}
4758
4759func NewBsnTlvDataMask() *BsnTlvDataMask {
4760 obj := &BsnTlvDataMask{
4761 BsnTlv: NewBsnTlv(140),
4762 }
4763 return obj
4764}
4765
4766type BsnTlvDecap struct {
4767 *BsnTlv
4768 Value BsnDecap
4769}
4770
4771type IBsnTlvDecap interface {
4772 IBsnTlv
4773 GetValue() BsnDecap
4774}
4775
4776func (self *BsnTlvDecap) GetValue() BsnDecap {
4777 return self.Value
4778}
4779
4780func (self *BsnTlvDecap) SetValue(v BsnDecap) {
4781 self.Value = v
4782}
4783
4784func (self *BsnTlvDecap) Serialize(encoder *goloxi.Encoder) error {
4785 startIndex := len(encoder.Bytes())
4786 if err := self.BsnTlv.Serialize(encoder); err != nil {
4787 return err
4788 }
4789
4790 encoder.PutUint16(uint16(self.Value))
4791 length := len(encoder.Bytes()) - startIndex
4792
4793 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4794
4795 return nil
4796}
4797
4798func DecodeBsnTlvDecap(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvDecap, error) {
4799 _bsntlvdecap := &BsnTlvDecap{BsnTlv: parent}
4800 if decoder.Length() < 2 {
4801 return nil, fmt.Errorf("BsnTlvDecap packet too short: %d < 2", decoder.Length())
4802 }
4803 _bsntlvdecap.Value = BsnDecap(decoder.ReadUint16())
4804 return _bsntlvdecap, nil
4805}
4806
4807func NewBsnTlvDecap() *BsnTlvDecap {
4808 obj := &BsnTlvDecap{
4809 BsnTlv: NewBsnTlv(85),
4810 }
4811 return obj
4812}
4813
4814type BsnTlvDisableSrcMacCheck struct {
4815 *BsnTlv
4816}
4817
4818type IBsnTlvDisableSrcMacCheck interface {
4819 IBsnTlv
4820}
4821
4822func (self *BsnTlvDisableSrcMacCheck) Serialize(encoder *goloxi.Encoder) error {
4823 startIndex := len(encoder.Bytes())
4824 if err := self.BsnTlv.Serialize(encoder); err != nil {
4825 return err
4826 }
4827 length := len(encoder.Bytes()) - startIndex
4828
4829 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4830
4831 return nil
4832}
4833
4834func DecodeBsnTlvDisableSrcMacCheck(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvDisableSrcMacCheck, error) {
4835 _bsntlvdisablesrcmaccheck := &BsnTlvDisableSrcMacCheck{BsnTlv: parent}
4836 return _bsntlvdisablesrcmaccheck, nil
4837}
4838
4839func NewBsnTlvDisableSrcMacCheck() *BsnTlvDisableSrcMacCheck {
4840 obj := &BsnTlvDisableSrcMacCheck{
4841 BsnTlv: NewBsnTlv(120),
4842 }
4843 return obj
4844}
4845
4846type BsnTlvDisableXmit struct {
4847 *BsnTlv
4848}
4849
4850type IBsnTlvDisableXmit interface {
4851 IBsnTlv
4852}
4853
4854func (self *BsnTlvDisableXmit) Serialize(encoder *goloxi.Encoder) error {
4855 startIndex := len(encoder.Bytes())
4856 if err := self.BsnTlv.Serialize(encoder); err != nil {
4857 return err
4858 }
4859 length := len(encoder.Bytes()) - startIndex
4860
4861 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4862
4863 return nil
4864}
4865
4866func DecodeBsnTlvDisableXmit(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvDisableXmit, error) {
4867 _bsntlvdisablexmit := &BsnTlvDisableXmit{BsnTlv: parent}
4868 return _bsntlvdisablexmit, nil
4869}
4870
4871func NewBsnTlvDisableXmit() *BsnTlvDisableXmit {
4872 obj := &BsnTlvDisableXmit{
4873 BsnTlv: NewBsnTlv(185),
4874 }
4875 return obj
4876}
4877
4878type BsnTlvDnsAnalytics struct {
4879 *BsnTlv
4880}
4881
4882type IBsnTlvDnsAnalytics interface {
4883 IBsnTlv
4884}
4885
4886func (self *BsnTlvDnsAnalytics) Serialize(encoder *goloxi.Encoder) error {
4887 startIndex := len(encoder.Bytes())
4888 if err := self.BsnTlv.Serialize(encoder); err != nil {
4889 return err
4890 }
4891 length := len(encoder.Bytes()) - startIndex
4892
4893 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4894
4895 return nil
4896}
4897
4898func DecodeBsnTlvDnsAnalytics(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvDnsAnalytics, error) {
4899 _bsntlvdnsanalytics := &BsnTlvDnsAnalytics{BsnTlv: parent}
4900 return _bsntlvdnsanalytics, nil
4901}
4902
4903func NewBsnTlvDnsAnalytics() *BsnTlvDnsAnalytics {
4904 obj := &BsnTlvDnsAnalytics{
4905 BsnTlv: NewBsnTlv(190),
4906 }
4907 return obj
4908}
4909
4910type BsnTlvDrop struct {
4911 *BsnTlv
4912}
4913
4914type IBsnTlvDrop interface {
4915 IBsnTlv
4916}
4917
4918func (self *BsnTlvDrop) Serialize(encoder *goloxi.Encoder) error {
4919 startIndex := len(encoder.Bytes())
4920 if err := self.BsnTlv.Serialize(encoder); err != nil {
4921 return err
4922 }
4923 length := len(encoder.Bytes()) - startIndex
4924
4925 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4926
4927 return nil
4928}
4929
4930func DecodeBsnTlvDrop(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvDrop, error) {
4931 _bsntlvdrop := &BsnTlvDrop{BsnTlv: parent}
4932 return _bsntlvdrop, nil
4933}
4934
4935func NewBsnTlvDrop() *BsnTlvDrop {
4936 obj := &BsnTlvDrop{
4937 BsnTlv: NewBsnTlv(121),
4938 }
4939 return obj
4940}
4941
4942type BsnTlvDropControl struct {
4943 *BsnTlv
4944}
4945
4946type IBsnTlvDropControl interface {
4947 IBsnTlv
4948}
4949
4950func (self *BsnTlvDropControl) Serialize(encoder *goloxi.Encoder) error {
4951 startIndex := len(encoder.Bytes())
4952 if err := self.BsnTlv.Serialize(encoder); err != nil {
4953 return err
4954 }
4955 length := len(encoder.Bytes()) - startIndex
4956
4957 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4958
4959 return nil
4960}
4961
4962func DecodeBsnTlvDropControl(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvDropControl, error) {
4963 _bsntlvdropcontrol := &BsnTlvDropControl{BsnTlv: parent}
4964 return _bsntlvdropcontrol, nil
4965}
4966
4967func NewBsnTlvDropControl() *BsnTlvDropControl {
4968 obj := &BsnTlvDropControl{
4969 BsnTlv: NewBsnTlv(187),
4970 }
4971 return obj
4972}
4973
4974type BsnTlvDscp struct {
4975 *BsnTlv
4976 Value uint16
4977}
4978
4979type IBsnTlvDscp interface {
4980 IBsnTlv
4981 GetValue() uint16
4982}
4983
4984func (self *BsnTlvDscp) GetValue() uint16 {
4985 return self.Value
4986}
4987
4988func (self *BsnTlvDscp) SetValue(v uint16) {
4989 self.Value = v
4990}
4991
4992func (self *BsnTlvDscp) Serialize(encoder *goloxi.Encoder) error {
4993 startIndex := len(encoder.Bytes())
4994 if err := self.BsnTlv.Serialize(encoder); err != nil {
4995 return err
4996 }
4997
4998 encoder.PutUint16(uint16(self.Value))
4999 length := len(encoder.Bytes()) - startIndex
5000
5001 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5002
5003 return nil
5004}
5005
5006func DecodeBsnTlvDscp(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvDscp, error) {
5007 _bsntlvdscp := &BsnTlvDscp{BsnTlv: parent}
5008 if decoder.Length() < 2 {
5009 return nil, fmt.Errorf("BsnTlvDscp packet too short: %d < 2", decoder.Length())
5010 }
5011 _bsntlvdscp.Value = uint16(decoder.ReadUint16())
5012 return _bsntlvdscp, nil
5013}
5014
5015func NewBsnTlvDscp() *BsnTlvDscp {
5016 obj := &BsnTlvDscp{
5017 BsnTlv: NewBsnTlv(112),
5018 }
5019 return obj
5020}
5021
5022type BsnTlvEcn struct {
5023 *BsnTlv
5024 Value uint8
5025}
5026
5027type IBsnTlvEcn interface {
5028 IBsnTlv
5029 GetValue() uint8
5030}
5031
5032func (self *BsnTlvEcn) GetValue() uint8 {
5033 return self.Value
5034}
5035
5036func (self *BsnTlvEcn) SetValue(v uint8) {
5037 self.Value = v
5038}
5039
5040func (self *BsnTlvEcn) Serialize(encoder *goloxi.Encoder) error {
5041 startIndex := len(encoder.Bytes())
5042 if err := self.BsnTlv.Serialize(encoder); err != nil {
5043 return err
5044 }
5045
5046 encoder.PutUint8(uint8(self.Value))
5047 length := len(encoder.Bytes()) - startIndex
5048
5049 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5050
5051 return nil
5052}
5053
5054func DecodeBsnTlvEcn(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEcn, error) {
5055 _bsntlvecn := &BsnTlvEcn{BsnTlv: parent}
5056 if decoder.Length() < 1 {
5057 return nil, fmt.Errorf("BsnTlvEcn packet too short: %d < 1", decoder.Length())
5058 }
5059 _bsntlvecn.Value = uint8(decoder.ReadByte())
5060 return _bsntlvecn, nil
5061}
5062
5063func NewBsnTlvEcn() *BsnTlvEcn {
5064 obj := &BsnTlvEcn{
5065 BsnTlv: NewBsnTlv(132),
5066 }
5067 return obj
5068}
5069
5070type BsnTlvEgressOnly struct {
5071 *BsnTlv
5072}
5073
5074type IBsnTlvEgressOnly interface {
5075 IBsnTlv
5076}
5077
5078func (self *BsnTlvEgressOnly) Serialize(encoder *goloxi.Encoder) error {
5079 startIndex := len(encoder.Bytes())
5080 if err := self.BsnTlv.Serialize(encoder); err != nil {
5081 return err
5082 }
5083 length := len(encoder.Bytes()) - startIndex
5084
5085 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5086
5087 return nil
5088}
5089
5090func DecodeBsnTlvEgressOnly(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEgressOnly, error) {
5091 _bsntlvegressonly := &BsnTlvEgressOnly{BsnTlv: parent}
5092 return _bsntlvegressonly, nil
5093}
5094
5095func NewBsnTlvEgressOnly() *BsnTlvEgressOnly {
5096 obj := &BsnTlvEgressOnly{
5097 BsnTlv: NewBsnTlv(137),
5098 }
5099 return obj
5100}
5101
5102type BsnTlvEgressPortGroupId struct {
5103 *BsnTlv
5104 Value uint32
5105}
5106
5107type IBsnTlvEgressPortGroupId interface {
5108 IBsnTlv
5109 GetValue() uint32
5110}
5111
5112func (self *BsnTlvEgressPortGroupId) GetValue() uint32 {
5113 return self.Value
5114}
5115
5116func (self *BsnTlvEgressPortGroupId) SetValue(v uint32) {
5117 self.Value = v
5118}
5119
5120func (self *BsnTlvEgressPortGroupId) Serialize(encoder *goloxi.Encoder) error {
5121 startIndex := len(encoder.Bytes())
5122 if err := self.BsnTlv.Serialize(encoder); err != nil {
5123 return err
5124 }
5125
5126 encoder.PutUint32(uint32(self.Value))
5127 length := len(encoder.Bytes()) - startIndex
5128
5129 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5130
5131 return nil
5132}
5133
5134func DecodeBsnTlvEgressPortGroupId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEgressPortGroupId, error) {
5135 _bsntlvegressportgroupid := &BsnTlvEgressPortGroupId{BsnTlv: parent}
5136 if decoder.Length() < 4 {
5137 return nil, fmt.Errorf("BsnTlvEgressPortGroupId packet too short: %d < 4", decoder.Length())
5138 }
5139 _bsntlvegressportgroupid.Value = uint32(decoder.ReadUint32())
5140 return _bsntlvegressportgroupid, nil
5141}
5142
5143func NewBsnTlvEgressPortGroupId() *BsnTlvEgressPortGroupId {
5144 obj := &BsnTlvEgressPortGroupId{
5145 BsnTlv: NewBsnTlv(139),
5146 }
5147 return obj
5148}
5149
5150type BsnTlvEgressSamplingRate struct {
5151 *BsnTlv
5152 Value uint32
5153}
5154
5155type IBsnTlvEgressSamplingRate interface {
5156 IBsnTlv
5157 GetValue() uint32
5158}
5159
5160func (self *BsnTlvEgressSamplingRate) GetValue() uint32 {
5161 return self.Value
5162}
5163
5164func (self *BsnTlvEgressSamplingRate) SetValue(v uint32) {
5165 self.Value = v
5166}
5167
5168func (self *BsnTlvEgressSamplingRate) Serialize(encoder *goloxi.Encoder) error {
5169 startIndex := len(encoder.Bytes())
5170 if err := self.BsnTlv.Serialize(encoder); err != nil {
5171 return err
5172 }
5173
5174 encoder.PutUint32(uint32(self.Value))
5175 length := len(encoder.Bytes()) - startIndex
5176
5177 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5178
5179 return nil
5180}
5181
5182func DecodeBsnTlvEgressSamplingRate(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEgressSamplingRate, error) {
5183 _bsntlvegresssamplingrate := &BsnTlvEgressSamplingRate{BsnTlv: parent}
5184 if decoder.Length() < 4 {
5185 return nil, fmt.Errorf("BsnTlvEgressSamplingRate packet too short: %d < 4", decoder.Length())
5186 }
5187 _bsntlvegresssamplingrate.Value = uint32(decoder.ReadUint32())
5188 return _bsntlvegresssamplingrate, nil
5189}
5190
5191func NewBsnTlvEgressSamplingRate() *BsnTlvEgressSamplingRate {
5192 obj := &BsnTlvEgressSamplingRate{
5193 BsnTlv: NewBsnTlv(195),
5194 }
5195 return obj
5196}
5197
5198type BsnTlvEncap struct {
5199 *BsnTlv
5200 Value BsnEncap
5201}
5202
5203type IBsnTlvEncap interface {
5204 IBsnTlv
5205 GetValue() BsnEncap
5206}
5207
5208func (self *BsnTlvEncap) GetValue() BsnEncap {
5209 return self.Value
5210}
5211
5212func (self *BsnTlvEncap) SetValue(v BsnEncap) {
5213 self.Value = v
5214}
5215
5216func (self *BsnTlvEncap) Serialize(encoder *goloxi.Encoder) error {
5217 startIndex := len(encoder.Bytes())
5218 if err := self.BsnTlv.Serialize(encoder); err != nil {
5219 return err
5220 }
5221
5222 encoder.PutUint8(uint8(self.Value))
5223 length := len(encoder.Bytes()) - startIndex
5224
5225 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5226
5227 return nil
5228}
5229
5230func DecodeBsnTlvEncap(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEncap, error) {
5231 _bsntlvencap := &BsnTlvEncap{BsnTlv: parent}
5232 if decoder.Length() < 1 {
5233 return nil, fmt.Errorf("BsnTlvEncap packet too short: %d < 1", decoder.Length())
5234 }
5235 _bsntlvencap.Value = BsnEncap(decoder.ReadByte())
5236 return _bsntlvencap, nil
5237}
5238
5239func NewBsnTlvEncap() *BsnTlvEncap {
5240 obj := &BsnTlvEncap{
5241 BsnTlv: NewBsnTlv(175),
5242 }
5243 return obj
5244}
5245
5246type BsnTlvEnhancedHashCapability struct {
5247 *BsnTlv
5248 Value BsnEnhancedHashType
5249}
5250
5251type IBsnTlvEnhancedHashCapability interface {
5252 IBsnTlv
5253 GetValue() BsnEnhancedHashType
5254}
5255
5256func (self *BsnTlvEnhancedHashCapability) GetValue() BsnEnhancedHashType {
5257 return self.Value
5258}
5259
5260func (self *BsnTlvEnhancedHashCapability) SetValue(v BsnEnhancedHashType) {
5261 self.Value = v
5262}
5263
5264func (self *BsnTlvEnhancedHashCapability) Serialize(encoder *goloxi.Encoder) error {
5265 startIndex := len(encoder.Bytes())
5266 if err := self.BsnTlv.Serialize(encoder); err != nil {
5267 return err
5268 }
5269
5270 encoder.PutUint64(uint64(self.Value))
5271 length := len(encoder.Bytes()) - startIndex
5272
5273 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5274
5275 return nil
5276}
5277
5278func DecodeBsnTlvEnhancedHashCapability(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEnhancedHashCapability, error) {
5279 _bsntlvenhancedhashcapability := &BsnTlvEnhancedHashCapability{BsnTlv: parent}
5280 if decoder.Length() < 8 {
5281 return nil, fmt.Errorf("BsnTlvEnhancedHashCapability packet too short: %d < 8", decoder.Length())
5282 }
5283 _bsntlvenhancedhashcapability.Value = BsnEnhancedHashType(decoder.ReadUint64())
5284 return _bsntlvenhancedhashcapability, nil
5285}
5286
5287func NewBsnTlvEnhancedHashCapability() *BsnTlvEnhancedHashCapability {
5288 obj := &BsnTlvEnhancedHashCapability{
5289 BsnTlv: NewBsnTlv(143),
5290 }
5291 return obj
5292}
5293
5294type BsnTlvEthDst struct {
5295 *BsnTlv
5296 Value net.HardwareAddr
5297}
5298
5299type IBsnTlvEthDst interface {
5300 IBsnTlv
5301 GetValue() net.HardwareAddr
5302}
5303
5304func (self *BsnTlvEthDst) GetValue() net.HardwareAddr {
5305 return self.Value
5306}
5307
5308func (self *BsnTlvEthDst) SetValue(v net.HardwareAddr) {
5309 self.Value = v
5310}
5311
5312func (self *BsnTlvEthDst) Serialize(encoder *goloxi.Encoder) error {
5313 startIndex := len(encoder.Bytes())
5314 if err := self.BsnTlv.Serialize(encoder); err != nil {
5315 return err
5316 }
5317
5318 encoder.Write(self.Value)
5319 length := len(encoder.Bytes()) - startIndex
5320
5321 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5322
5323 return nil
5324}
5325
5326func DecodeBsnTlvEthDst(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEthDst, error) {
5327 _bsntlvethdst := &BsnTlvEthDst{BsnTlv: parent}
5328 if decoder.Length() < 6 {
5329 return nil, fmt.Errorf("BsnTlvEthDst packet too short: %d < 6", decoder.Length())
5330 }
5331 _bsntlvethdst.Value = net.HardwareAddr(decoder.Read(6))
5332 return _bsntlvethdst, nil
5333}
5334
5335func NewBsnTlvEthDst() *BsnTlvEthDst {
5336 obj := &BsnTlvEthDst{
5337 BsnTlv: NewBsnTlv(33),
5338 }
5339 return obj
5340}
5341
5342type BsnTlvEthSrc struct {
5343 *BsnTlv
5344 Value net.HardwareAddr
5345}
5346
5347type IBsnTlvEthSrc interface {
5348 IBsnTlv
5349 GetValue() net.HardwareAddr
5350}
5351
5352func (self *BsnTlvEthSrc) GetValue() net.HardwareAddr {
5353 return self.Value
5354}
5355
5356func (self *BsnTlvEthSrc) SetValue(v net.HardwareAddr) {
5357 self.Value = v
5358}
5359
5360func (self *BsnTlvEthSrc) Serialize(encoder *goloxi.Encoder) error {
5361 startIndex := len(encoder.Bytes())
5362 if err := self.BsnTlv.Serialize(encoder); err != nil {
5363 return err
5364 }
5365
5366 encoder.Write(self.Value)
5367 length := len(encoder.Bytes()) - startIndex
5368
5369 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5370
5371 return nil
5372}
5373
5374func DecodeBsnTlvEthSrc(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEthSrc, error) {
5375 _bsntlvethsrc := &BsnTlvEthSrc{BsnTlv: parent}
5376 if decoder.Length() < 6 {
5377 return nil, fmt.Errorf("BsnTlvEthSrc packet too short: %d < 6", decoder.Length())
5378 }
5379 _bsntlvethsrc.Value = net.HardwareAddr(decoder.Read(6))
5380 return _bsntlvethsrc, nil
5381}
5382
5383func NewBsnTlvEthSrc() *BsnTlvEthSrc {
5384 obj := &BsnTlvEthSrc{
5385 BsnTlv: NewBsnTlv(32),
5386 }
5387 return obj
5388}
5389
5390type BsnTlvEthType struct {
5391 *BsnTlv
5392 Value uint16
5393}
5394
5395type IBsnTlvEthType interface {
5396 IBsnTlv
5397 GetValue() uint16
5398}
5399
5400func (self *BsnTlvEthType) GetValue() uint16 {
5401 return self.Value
5402}
5403
5404func (self *BsnTlvEthType) SetValue(v uint16) {
5405 self.Value = v
5406}
5407
5408func (self *BsnTlvEthType) Serialize(encoder *goloxi.Encoder) error {
5409 startIndex := len(encoder.Bytes())
5410 if err := self.BsnTlv.Serialize(encoder); err != nil {
5411 return err
5412 }
5413
5414 encoder.PutUint16(uint16(self.Value))
5415 length := len(encoder.Bytes()) - startIndex
5416
5417 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5418
5419 return nil
5420}
5421
5422func DecodeBsnTlvEthType(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEthType, error) {
5423 _bsntlvethtype := &BsnTlvEthType{BsnTlv: parent}
5424 if decoder.Length() < 2 {
5425 return nil, fmt.Errorf("BsnTlvEthType packet too short: %d < 2", decoder.Length())
5426 }
5427 _bsntlvethtype.Value = uint16(decoder.ReadUint16())
5428 return _bsntlvethtype, nil
5429}
5430
5431func NewBsnTlvEthType() *BsnTlvEthType {
5432 obj := &BsnTlvEthType{
5433 BsnTlv: NewBsnTlv(131),
5434 }
5435 return obj
5436}
5437
5438type BsnTlvExternalGatewayIp struct {
5439 *BsnTlv
5440 Value net.IP
5441}
5442
5443type IBsnTlvExternalGatewayIp interface {
5444 IBsnTlv
5445 GetValue() net.IP
5446}
5447
5448func (self *BsnTlvExternalGatewayIp) GetValue() net.IP {
5449 return self.Value
5450}
5451
5452func (self *BsnTlvExternalGatewayIp) SetValue(v net.IP) {
5453 self.Value = v
5454}
5455
5456func (self *BsnTlvExternalGatewayIp) Serialize(encoder *goloxi.Encoder) error {
5457 startIndex := len(encoder.Bytes())
5458 if err := self.BsnTlv.Serialize(encoder); err != nil {
5459 return err
5460 }
5461
5462 encoder.Write(self.Value.To4())
5463 length := len(encoder.Bytes()) - startIndex
5464
5465 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5466
5467 return nil
5468}
5469
5470func DecodeBsnTlvExternalGatewayIp(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvExternalGatewayIp, error) {
5471 _bsntlvexternalgatewayip := &BsnTlvExternalGatewayIp{BsnTlv: parent}
5472 if decoder.Length() < 4 {
5473 return nil, fmt.Errorf("BsnTlvExternalGatewayIp packet too short: %d < 4", decoder.Length())
5474 }
5475 _bsntlvexternalgatewayip.Value = net.IP(decoder.Read(4))
5476 return _bsntlvexternalgatewayip, nil
5477}
5478
5479func NewBsnTlvExternalGatewayIp() *BsnTlvExternalGatewayIp {
5480 obj := &BsnTlvExternalGatewayIp{
5481 BsnTlv: NewBsnTlv(26),
5482 }
5483 return obj
5484}
5485
5486type BsnTlvExternalGatewayMac struct {
5487 *BsnTlv
5488 Value net.HardwareAddr
5489}
5490
5491type IBsnTlvExternalGatewayMac interface {
5492 IBsnTlv
5493 GetValue() net.HardwareAddr
5494}
5495
5496func (self *BsnTlvExternalGatewayMac) GetValue() net.HardwareAddr {
5497 return self.Value
5498}
5499
5500func (self *BsnTlvExternalGatewayMac) SetValue(v net.HardwareAddr) {
5501 self.Value = v
5502}
5503
5504func (self *BsnTlvExternalGatewayMac) Serialize(encoder *goloxi.Encoder) error {
5505 startIndex := len(encoder.Bytes())
5506 if err := self.BsnTlv.Serialize(encoder); err != nil {
5507 return err
5508 }
5509
5510 encoder.Write(self.Value)
5511 length := len(encoder.Bytes()) - startIndex
5512
5513 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5514
5515 return nil
5516}
5517
5518func DecodeBsnTlvExternalGatewayMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvExternalGatewayMac, error) {
5519 _bsntlvexternalgatewaymac := &BsnTlvExternalGatewayMac{BsnTlv: parent}
5520 if decoder.Length() < 6 {
5521 return nil, fmt.Errorf("BsnTlvExternalGatewayMac packet too short: %d < 6", decoder.Length())
5522 }
5523 _bsntlvexternalgatewaymac.Value = net.HardwareAddr(decoder.Read(6))
5524 return _bsntlvexternalgatewaymac, nil
5525}
5526
5527func NewBsnTlvExternalGatewayMac() *BsnTlvExternalGatewayMac {
5528 obj := &BsnTlvExternalGatewayMac{
5529 BsnTlv: NewBsnTlv(29),
5530 }
5531 return obj
5532}
5533
5534type BsnTlvExternalIp struct {
5535 *BsnTlv
5536 Value net.IP
5537}
5538
5539type IBsnTlvExternalIp interface {
5540 IBsnTlv
5541 GetValue() net.IP
5542}
5543
5544func (self *BsnTlvExternalIp) GetValue() net.IP {
5545 return self.Value
5546}
5547
5548func (self *BsnTlvExternalIp) SetValue(v net.IP) {
5549 self.Value = v
5550}
5551
5552func (self *BsnTlvExternalIp) Serialize(encoder *goloxi.Encoder) error {
5553 startIndex := len(encoder.Bytes())
5554 if err := self.BsnTlv.Serialize(encoder); err != nil {
5555 return err
5556 }
5557
5558 encoder.Write(self.Value.To4())
5559 length := len(encoder.Bytes()) - startIndex
5560
5561 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5562
5563 return nil
5564}
5565
5566func DecodeBsnTlvExternalIp(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvExternalIp, error) {
5567 _bsntlvexternalip := &BsnTlvExternalIp{BsnTlv: parent}
5568 if decoder.Length() < 4 {
5569 return nil, fmt.Errorf("BsnTlvExternalIp packet too short: %d < 4", decoder.Length())
5570 }
5571 _bsntlvexternalip.Value = net.IP(decoder.Read(4))
5572 return _bsntlvexternalip, nil
5573}
5574
5575func NewBsnTlvExternalIp() *BsnTlvExternalIp {
5576 obj := &BsnTlvExternalIp{
5577 BsnTlv: NewBsnTlv(23),
5578 }
5579 return obj
5580}
5581
5582type BsnTlvExternalMac struct {
5583 *BsnTlv
5584 Value net.HardwareAddr
5585}
5586
5587type IBsnTlvExternalMac interface {
5588 IBsnTlv
5589 GetValue() net.HardwareAddr
5590}
5591
5592func (self *BsnTlvExternalMac) GetValue() net.HardwareAddr {
5593 return self.Value
5594}
5595
5596func (self *BsnTlvExternalMac) SetValue(v net.HardwareAddr) {
5597 self.Value = v
5598}
5599
5600func (self *BsnTlvExternalMac) Serialize(encoder *goloxi.Encoder) error {
5601 startIndex := len(encoder.Bytes())
5602 if err := self.BsnTlv.Serialize(encoder); err != nil {
5603 return err
5604 }
5605
5606 encoder.Write(self.Value)
5607 length := len(encoder.Bytes()) - startIndex
5608
5609 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5610
5611 return nil
5612}
5613
5614func DecodeBsnTlvExternalMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvExternalMac, error) {
5615 _bsntlvexternalmac := &BsnTlvExternalMac{BsnTlv: parent}
5616 if decoder.Length() < 6 {
5617 return nil, fmt.Errorf("BsnTlvExternalMac packet too short: %d < 6", decoder.Length())
5618 }
5619 _bsntlvexternalmac.Value = net.HardwareAddr(decoder.Read(6))
5620 return _bsntlvexternalmac, nil
5621}
5622
5623func NewBsnTlvExternalMac() *BsnTlvExternalMac {
5624 obj := &BsnTlvExternalMac{
5625 BsnTlv: NewBsnTlv(24),
5626 }
5627 return obj
5628}
5629
5630type BsnTlvExternalNetmask struct {
5631 *BsnTlv
5632 Value net.IP
5633}
5634
5635type IBsnTlvExternalNetmask interface {
5636 IBsnTlv
5637 GetValue() net.IP
5638}
5639
5640func (self *BsnTlvExternalNetmask) GetValue() net.IP {
5641 return self.Value
5642}
5643
5644func (self *BsnTlvExternalNetmask) SetValue(v net.IP) {
5645 self.Value = v
5646}
5647
5648func (self *BsnTlvExternalNetmask) Serialize(encoder *goloxi.Encoder) error {
5649 startIndex := len(encoder.Bytes())
5650 if err := self.BsnTlv.Serialize(encoder); err != nil {
5651 return err
5652 }
5653
5654 encoder.Write(self.Value.To4())
5655 length := len(encoder.Bytes()) - startIndex
5656
5657 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5658
5659 return nil
5660}
5661
5662func DecodeBsnTlvExternalNetmask(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvExternalNetmask, error) {
5663 _bsntlvexternalnetmask := &BsnTlvExternalNetmask{BsnTlv: parent}
5664 if decoder.Length() < 4 {
5665 return nil, fmt.Errorf("BsnTlvExternalNetmask packet too short: %d < 4", decoder.Length())
5666 }
5667 _bsntlvexternalnetmask.Value = net.IP(decoder.Read(4))
5668 return _bsntlvexternalnetmask, nil
5669}
5670
5671func NewBsnTlvExternalNetmask() *BsnTlvExternalNetmask {
5672 obj := &BsnTlvExternalNetmask{
5673 BsnTlv: NewBsnTlv(25),
5674 }
5675 return obj
5676}
5677
5678type BsnTlvFabricPortRole struct {
5679 *BsnTlv
5680 Value BsnFabricPortRole
5681}
5682
5683type IBsnTlvFabricPortRole interface {
5684 IBsnTlv
5685 GetValue() BsnFabricPortRole
5686}
5687
5688func (self *BsnTlvFabricPortRole) GetValue() BsnFabricPortRole {
5689 return self.Value
5690}
5691
5692func (self *BsnTlvFabricPortRole) SetValue(v BsnFabricPortRole) {
5693 self.Value = v
5694}
5695
5696func (self *BsnTlvFabricPortRole) Serialize(encoder *goloxi.Encoder) error {
5697 startIndex := len(encoder.Bytes())
5698 if err := self.BsnTlv.Serialize(encoder); err != nil {
5699 return err
5700 }
5701
5702 encoder.PutUint16(uint16(self.Value))
5703 length := len(encoder.Bytes()) - startIndex
5704
5705 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5706
5707 return nil
5708}
5709
5710func DecodeBsnTlvFabricPortRole(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvFabricPortRole, error) {
5711 _bsntlvfabricportrole := &BsnTlvFabricPortRole{BsnTlv: parent}
5712 if decoder.Length() < 2 {
5713 return nil, fmt.Errorf("BsnTlvFabricPortRole packet too short: %d < 2", decoder.Length())
5714 }
5715 _bsntlvfabricportrole.Value = BsnFabricPortRole(decoder.ReadUint16())
5716 return _bsntlvfabricportrole, nil
5717}
5718
5719func NewBsnTlvFabricPortRole() *BsnTlvFabricPortRole {
5720 obj := &BsnTlvFabricPortRole{
5721 BsnTlv: NewBsnTlv(165),
5722 }
5723 return obj
5724}
5725
5726type BsnTlvFailCount struct {
5727 *BsnTlv
5728 Value uint64
5729}
5730
5731type IBsnTlvFailCount interface {
5732 IBsnTlv
5733 GetValue() uint64
5734}
5735
5736func (self *BsnTlvFailCount) GetValue() uint64 {
5737 return self.Value
5738}
5739
5740func (self *BsnTlvFailCount) SetValue(v uint64) {
5741 self.Value = v
5742}
5743
5744func (self *BsnTlvFailCount) Serialize(encoder *goloxi.Encoder) error {
5745 startIndex := len(encoder.Bytes())
5746 if err := self.BsnTlv.Serialize(encoder); err != nil {
5747 return err
5748 }
5749
5750 encoder.PutUint64(uint64(self.Value))
5751 length := len(encoder.Bytes()) - startIndex
5752
5753 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5754
5755 return nil
5756}
5757
5758func DecodeBsnTlvFailCount(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvFailCount, error) {
5759 _bsntlvfailcount := &BsnTlvFailCount{BsnTlv: parent}
5760 if decoder.Length() < 8 {
5761 return nil, fmt.Errorf("BsnTlvFailCount packet too short: %d < 8", decoder.Length())
5762 }
5763 _bsntlvfailcount.Value = uint64(decoder.ReadUint64())
5764 return _bsntlvfailcount, nil
5765}
5766
5767func NewBsnTlvFailCount() *BsnTlvFailCount {
5768 obj := &BsnTlvFailCount{
5769 BsnTlv: NewBsnTlv(194),
5770 }
5771 return obj
5772}
5773
5774type BsnTlvFlood struct {
5775 *BsnTlv
5776}
5777
5778type IBsnTlvFlood interface {
5779 IBsnTlv
5780}
5781
5782func (self *BsnTlvFlood) Serialize(encoder *goloxi.Encoder) error {
5783 startIndex := len(encoder.Bytes())
5784 if err := self.BsnTlv.Serialize(encoder); err != nil {
5785 return err
5786 }
5787 length := len(encoder.Bytes()) - startIndex
5788
5789 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5790
5791 return nil
5792}
5793
5794func DecodeBsnTlvFlood(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvFlood, error) {
5795 _bsntlvflood := &BsnTlvFlood{BsnTlv: parent}
5796 return _bsntlvflood, nil
5797}
5798
5799func NewBsnTlvFlood() *BsnTlvFlood {
5800 obj := &BsnTlvFlood{
5801 BsnTlv: NewBsnTlv(163),
5802 }
5803 return obj
5804}
5805
5806type BsnTlvFlowClassifier struct {
5807 *BsnTlv
5808 Value BsnFlowClassifier
5809}
5810
5811type IBsnTlvFlowClassifier interface {
5812 IBsnTlv
5813 GetValue() BsnFlowClassifier
5814}
5815
5816func (self *BsnTlvFlowClassifier) GetValue() BsnFlowClassifier {
5817 return self.Value
5818}
5819
5820func (self *BsnTlvFlowClassifier) SetValue(v BsnFlowClassifier) {
5821 self.Value = v
5822}
5823
5824func (self *BsnTlvFlowClassifier) Serialize(encoder *goloxi.Encoder) error {
5825 startIndex := len(encoder.Bytes())
5826 if err := self.BsnTlv.Serialize(encoder); err != nil {
5827 return err
5828 }
5829
5830 encoder.PutUint16(uint16(self.Value))
5831 length := len(encoder.Bytes()) - startIndex
5832
5833 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5834
5835 return nil
5836}
5837
5838func DecodeBsnTlvFlowClassifier(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvFlowClassifier, error) {
5839 _bsntlvflowclassifier := &BsnTlvFlowClassifier{BsnTlv: parent}
5840 if decoder.Length() < 2 {
5841 return nil, fmt.Errorf("BsnTlvFlowClassifier packet too short: %d < 2", decoder.Length())
5842 }
5843 _bsntlvflowclassifier.Value = BsnFlowClassifier(decoder.ReadUint16())
5844 return _bsntlvflowclassifier, nil
5845}
5846
5847func NewBsnTlvFlowClassifier() *BsnTlvFlowClassifier {
5848 obj := &BsnTlvFlowClassifier{
5849 BsnTlv: NewBsnTlv(184),
5850 }
5851 return obj
5852}
5853
5854type BsnTlvFlowClassify struct {
5855 *BsnTlv
5856}
5857
5858type IBsnTlvFlowClassify interface {
5859 IBsnTlv
5860}
5861
5862func (self *BsnTlvFlowClassify) Serialize(encoder *goloxi.Encoder) error {
5863 startIndex := len(encoder.Bytes())
5864 if err := self.BsnTlv.Serialize(encoder); err != nil {
5865 return err
5866 }
5867 length := len(encoder.Bytes()) - startIndex
5868
5869 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5870
5871 return nil
5872}
5873
5874func DecodeBsnTlvFlowClassify(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvFlowClassify, error) {
5875 _bsntlvflowclassify := &BsnTlvFlowClassify{BsnTlv: parent}
5876 return _bsntlvflowclassify, nil
5877}
5878
5879func NewBsnTlvFlowClassify() *BsnTlvFlowClassify {
5880 obj := &BsnTlvFlowClassify{
5881 BsnTlv: NewBsnTlv(182),
5882 }
5883 return obj
5884}
5885
5886type BsnTlvFlowIdentifier struct {
5887 *BsnTlv
5888 Value uint32
5889}
5890
5891type IBsnTlvFlowIdentifier interface {
5892 IBsnTlv
5893 GetValue() uint32
5894}
5895
5896func (self *BsnTlvFlowIdentifier) GetValue() uint32 {
5897 return self.Value
5898}
5899
5900func (self *BsnTlvFlowIdentifier) SetValue(v uint32) {
5901 self.Value = v
5902}
5903
5904func (self *BsnTlvFlowIdentifier) Serialize(encoder *goloxi.Encoder) error {
5905 startIndex := len(encoder.Bytes())
5906 if err := self.BsnTlv.Serialize(encoder); err != nil {
5907 return err
5908 }
5909
5910 encoder.PutUint32(uint32(self.Value))
5911 length := len(encoder.Bytes()) - startIndex
5912
5913 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5914
5915 return nil
5916}
5917
5918func DecodeBsnTlvFlowIdentifier(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvFlowIdentifier, error) {
5919 _bsntlvflowidentifier := &BsnTlvFlowIdentifier{BsnTlv: parent}
5920 if decoder.Length() < 4 {
5921 return nil, fmt.Errorf("BsnTlvFlowIdentifier packet too short: %d < 4", decoder.Length())
5922 }
5923 _bsntlvflowidentifier.Value = uint32(decoder.ReadUint32())
5924 return _bsntlvflowidentifier, nil
5925}
5926
5927func NewBsnTlvFlowIdentifier() *BsnTlvFlowIdentifier {
5928 obj := &BsnTlvFlowIdentifier{
5929 BsnTlv: NewBsnTlv(183),
5930 }
5931 return obj
5932}
5933
5934type BsnTlvForceLinkUp struct {
5935 *BsnTlv
5936}
5937
5938type IBsnTlvForceLinkUp interface {
5939 IBsnTlv
5940}
5941
5942func (self *BsnTlvForceLinkUp) Serialize(encoder *goloxi.Encoder) error {
5943 startIndex := len(encoder.Bytes())
5944 if err := self.BsnTlv.Serialize(encoder); err != nil {
5945 return err
5946 }
5947 length := len(encoder.Bytes()) - startIndex
5948
5949 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5950
5951 return nil
5952}
5953
5954func DecodeBsnTlvForceLinkUp(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvForceLinkUp, error) {
5955 _bsntlvforcelinkup := &BsnTlvForceLinkUp{BsnTlv: parent}
5956 return _bsntlvforcelinkup, nil
5957}
5958
5959func NewBsnTlvForceLinkUp() *BsnTlvForceLinkUp {
5960 obj := &BsnTlvForceLinkUp{
5961 BsnTlv: NewBsnTlv(151),
5962 }
5963 return obj
5964}
5965
5966type BsnTlvForwardErrorCorrection struct {
5967 *BsnTlv
5968 Value BsnForwardErrorCorrectionType
5969}
5970
5971type IBsnTlvForwardErrorCorrection interface {
5972 IBsnTlv
5973 GetValue() BsnForwardErrorCorrectionType
5974}
5975
5976func (self *BsnTlvForwardErrorCorrection) GetValue() BsnForwardErrorCorrectionType {
5977 return self.Value
5978}
5979
5980func (self *BsnTlvForwardErrorCorrection) SetValue(v BsnForwardErrorCorrectionType) {
5981 self.Value = v
5982}
5983
5984func (self *BsnTlvForwardErrorCorrection) Serialize(encoder *goloxi.Encoder) error {
5985 startIndex := len(encoder.Bytes())
5986 if err := self.BsnTlv.Serialize(encoder); err != nil {
5987 return err
5988 }
5989
5990 encoder.PutUint8(uint8(self.Value))
5991 length := len(encoder.Bytes()) - startIndex
5992
5993 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5994
5995 return nil
5996}
5997
5998func DecodeBsnTlvForwardErrorCorrection(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvForwardErrorCorrection, error) {
5999 _bsntlvforwarderrorcorrection := &BsnTlvForwardErrorCorrection{BsnTlv: parent}
6000 if decoder.Length() < 1 {
6001 return nil, fmt.Errorf("BsnTlvForwardErrorCorrection packet too short: %d < 1", decoder.Length())
6002 }
6003 _bsntlvforwarderrorcorrection.Value = BsnForwardErrorCorrectionType(decoder.ReadByte())
6004 return _bsntlvforwarderrorcorrection, nil
6005}
6006
6007func NewBsnTlvForwardErrorCorrection() *BsnTlvForwardErrorCorrection {
6008 obj := &BsnTlvForwardErrorCorrection{
6009 BsnTlv: NewBsnTlv(149),
6010 }
6011 return obj
6012}
6013
6014type BsnTlvGenerationId struct {
6015 *BsnTlv
6016 Value uint64
6017}
6018
6019type IBsnTlvGenerationId interface {
6020 IBsnTlv
6021 GetValue() uint64
6022}
6023
6024func (self *BsnTlvGenerationId) GetValue() uint64 {
6025 return self.Value
6026}
6027
6028func (self *BsnTlvGenerationId) SetValue(v uint64) {
6029 self.Value = v
6030}
6031
6032func (self *BsnTlvGenerationId) Serialize(encoder *goloxi.Encoder) error {
6033 startIndex := len(encoder.Bytes())
6034 if err := self.BsnTlv.Serialize(encoder); err != nil {
6035 return err
6036 }
6037
6038 encoder.PutUint64(uint64(self.Value))
6039 length := len(encoder.Bytes()) - startIndex
6040
6041 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6042
6043 return nil
6044}
6045
6046func DecodeBsnTlvGenerationId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvGenerationId, error) {
6047 _bsntlvgenerationid := &BsnTlvGenerationId{BsnTlv: parent}
6048 if decoder.Length() < 8 {
6049 return nil, fmt.Errorf("BsnTlvGenerationId packet too short: %d < 8", decoder.Length())
6050 }
6051 _bsntlvgenerationid.Value = uint64(decoder.ReadUint64())
6052 return _bsntlvgenerationid, nil
6053}
6054
6055func NewBsnTlvGenerationId() *BsnTlvGenerationId {
6056 obj := &BsnTlvGenerationId{
6057 BsnTlv: NewBsnTlv(80),
6058 }
6059 return obj
6060}
6061
6062type BsnTlvHashAlgorithm struct {
6063 *BsnTlv
6064 Value BsnHashAlgorithmType
6065}
6066
6067type IBsnTlvHashAlgorithm interface {
6068 IBsnTlv
6069 GetValue() BsnHashAlgorithmType
6070}
6071
6072func (self *BsnTlvHashAlgorithm) GetValue() BsnHashAlgorithmType {
6073 return self.Value
6074}
6075
6076func (self *BsnTlvHashAlgorithm) SetValue(v BsnHashAlgorithmType) {
6077 self.Value = v
6078}
6079
6080func (self *BsnTlvHashAlgorithm) Serialize(encoder *goloxi.Encoder) error {
6081 startIndex := len(encoder.Bytes())
6082 if err := self.BsnTlv.Serialize(encoder); err != nil {
6083 return err
6084 }
6085
6086 encoder.PutUint16(uint16(self.Value))
6087 length := len(encoder.Bytes()) - startIndex
6088
6089 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6090
6091 return nil
6092}
6093
6094func DecodeBsnTlvHashAlgorithm(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHashAlgorithm, error) {
6095 _bsntlvhashalgorithm := &BsnTlvHashAlgorithm{BsnTlv: parent}
6096 if decoder.Length() < 2 {
6097 return nil, fmt.Errorf("BsnTlvHashAlgorithm packet too short: %d < 2", decoder.Length())
6098 }
6099 _bsntlvhashalgorithm.Value = BsnHashAlgorithmType(decoder.ReadUint16())
6100 return _bsntlvhashalgorithm, nil
6101}
6102
6103func NewBsnTlvHashAlgorithm() *BsnTlvHashAlgorithm {
6104 obj := &BsnTlvHashAlgorithm{
6105 BsnTlv: NewBsnTlv(145),
6106 }
6107 return obj
6108}
6109
6110type BsnTlvHashGtpHeaderMatch struct {
6111 *BsnTlv
6112 FirstHeaderByte uint8
6113 FirstHeaderMask uint8
6114}
6115
6116type IBsnTlvHashGtpHeaderMatch interface {
6117 IBsnTlv
6118 GetFirstHeaderByte() uint8
6119 GetFirstHeaderMask() uint8
6120}
6121
6122func (self *BsnTlvHashGtpHeaderMatch) GetFirstHeaderByte() uint8 {
6123 return self.FirstHeaderByte
6124}
6125
6126func (self *BsnTlvHashGtpHeaderMatch) SetFirstHeaderByte(v uint8) {
6127 self.FirstHeaderByte = v
6128}
6129
6130func (self *BsnTlvHashGtpHeaderMatch) GetFirstHeaderMask() uint8 {
6131 return self.FirstHeaderMask
6132}
6133
6134func (self *BsnTlvHashGtpHeaderMatch) SetFirstHeaderMask(v uint8) {
6135 self.FirstHeaderMask = v
6136}
6137
6138func (self *BsnTlvHashGtpHeaderMatch) Serialize(encoder *goloxi.Encoder) error {
6139 startIndex := len(encoder.Bytes())
6140 if err := self.BsnTlv.Serialize(encoder); err != nil {
6141 return err
6142 }
6143
6144 encoder.PutUint8(uint8(self.FirstHeaderByte))
6145 encoder.PutUint8(uint8(self.FirstHeaderMask))
6146 length := len(encoder.Bytes()) - startIndex
6147
6148 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6149
6150 return nil
6151}
6152
6153func DecodeBsnTlvHashGtpHeaderMatch(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHashGtpHeaderMatch, error) {
6154 _bsntlvhashgtpheadermatch := &BsnTlvHashGtpHeaderMatch{BsnTlv: parent}
6155 if decoder.Length() < 2 {
6156 return nil, fmt.Errorf("BsnTlvHashGtpHeaderMatch packet too short: %d < 2", decoder.Length())
6157 }
6158 _bsntlvhashgtpheadermatch.FirstHeaderByte = uint8(decoder.ReadByte())
6159 _bsntlvhashgtpheadermatch.FirstHeaderMask = uint8(decoder.ReadByte())
6160 return _bsntlvhashgtpheadermatch, nil
6161}
6162
6163func NewBsnTlvHashGtpHeaderMatch() *BsnTlvHashGtpHeaderMatch {
6164 obj := &BsnTlvHashGtpHeaderMatch{
6165 BsnTlv: NewBsnTlv(104),
6166 }
6167 return obj
6168}
6169
6170type BsnTlvHashGtpPortMatch struct {
6171 *BsnTlv
6172 Match BsnHashGtpPortMatch
6173 SrcPort uint16
6174 DstPort uint16
6175}
6176
6177type IBsnTlvHashGtpPortMatch interface {
6178 IBsnTlv
6179 GetMatch() BsnHashGtpPortMatch
6180 GetSrcPort() uint16
6181 GetDstPort() uint16
6182}
6183
6184func (self *BsnTlvHashGtpPortMatch) GetMatch() BsnHashGtpPortMatch {
6185 return self.Match
6186}
6187
6188func (self *BsnTlvHashGtpPortMatch) SetMatch(v BsnHashGtpPortMatch) {
6189 self.Match = v
6190}
6191
6192func (self *BsnTlvHashGtpPortMatch) GetSrcPort() uint16 {
6193 return self.SrcPort
6194}
6195
6196func (self *BsnTlvHashGtpPortMatch) SetSrcPort(v uint16) {
6197 self.SrcPort = v
6198}
6199
6200func (self *BsnTlvHashGtpPortMatch) GetDstPort() uint16 {
6201 return self.DstPort
6202}
6203
6204func (self *BsnTlvHashGtpPortMatch) SetDstPort(v uint16) {
6205 self.DstPort = v
6206}
6207
6208func (self *BsnTlvHashGtpPortMatch) Serialize(encoder *goloxi.Encoder) error {
6209 startIndex := len(encoder.Bytes())
6210 if err := self.BsnTlv.Serialize(encoder); err != nil {
6211 return err
6212 }
6213
6214 encoder.PutUint8(uint8(self.Match))
6215 encoder.PutUint16(uint16(self.SrcPort))
6216 encoder.PutUint16(uint16(self.DstPort))
6217 length := len(encoder.Bytes()) - startIndex
6218
6219 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6220
6221 return nil
6222}
6223
6224func DecodeBsnTlvHashGtpPortMatch(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHashGtpPortMatch, error) {
6225 _bsntlvhashgtpportmatch := &BsnTlvHashGtpPortMatch{BsnTlv: parent}
6226 if decoder.Length() < 5 {
6227 return nil, fmt.Errorf("BsnTlvHashGtpPortMatch packet too short: %d < 5", decoder.Length())
6228 }
6229 _bsntlvhashgtpportmatch.Match = BsnHashGtpPortMatch(decoder.ReadByte())
6230 _bsntlvhashgtpportmatch.SrcPort = uint16(decoder.ReadUint16())
6231 _bsntlvhashgtpportmatch.DstPort = uint16(decoder.ReadUint16())
6232 return _bsntlvhashgtpportmatch, nil
6233}
6234
6235func NewBsnTlvHashGtpPortMatch() *BsnTlvHashGtpPortMatch {
6236 obj := &BsnTlvHashGtpPortMatch{
6237 BsnTlv: NewBsnTlv(105),
6238 }
6239 return obj
6240}
6241
6242type BsnTlvHashPacketField struct {
6243 *BsnTlv
6244 Value BsnHashPacketField
6245}
6246
6247type IBsnTlvHashPacketField interface {
6248 IBsnTlv
6249 GetValue() BsnHashPacketField
6250}
6251
6252func (self *BsnTlvHashPacketField) GetValue() BsnHashPacketField {
6253 return self.Value
6254}
6255
6256func (self *BsnTlvHashPacketField) SetValue(v BsnHashPacketField) {
6257 self.Value = v
6258}
6259
6260func (self *BsnTlvHashPacketField) Serialize(encoder *goloxi.Encoder) error {
6261 startIndex := len(encoder.Bytes())
6262 if err := self.BsnTlv.Serialize(encoder); err != nil {
6263 return err
6264 }
6265
6266 encoder.PutUint64(uint64(self.Value))
6267 length := len(encoder.Bytes()) - startIndex
6268
6269 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6270
6271 return nil
6272}
6273
6274func DecodeBsnTlvHashPacketField(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHashPacketField, error) {
6275 _bsntlvhashpacketfield := &BsnTlvHashPacketField{BsnTlv: parent}
6276 if decoder.Length() < 8 {
6277 return nil, fmt.Errorf("BsnTlvHashPacketField packet too short: %d < 8", decoder.Length())
6278 }
6279 _bsntlvhashpacketfield.Value = BsnHashPacketField(decoder.ReadUint64())
6280 return _bsntlvhashpacketfield, nil
6281}
6282
6283func NewBsnTlvHashPacketField() *BsnTlvHashPacketField {
6284 obj := &BsnTlvHashPacketField{
6285 BsnTlv: NewBsnTlv(103),
6286 }
6287 return obj
6288}
6289
6290type BsnTlvHashPacketType struct {
6291 *BsnTlv
6292 Value BsnHashPacketType
6293}
6294
6295type IBsnTlvHashPacketType interface {
6296 IBsnTlv
6297 GetValue() BsnHashPacketType
6298}
6299
6300func (self *BsnTlvHashPacketType) GetValue() BsnHashPacketType {
6301 return self.Value
6302}
6303
6304func (self *BsnTlvHashPacketType) SetValue(v BsnHashPacketType) {
6305 self.Value = v
6306}
6307
6308func (self *BsnTlvHashPacketType) Serialize(encoder *goloxi.Encoder) error {
6309 startIndex := len(encoder.Bytes())
6310 if err := self.BsnTlv.Serialize(encoder); err != nil {
6311 return err
6312 }
6313
6314 encoder.PutUint8(uint8(self.Value))
6315 length := len(encoder.Bytes()) - startIndex
6316
6317 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6318
6319 return nil
6320}
6321
6322func DecodeBsnTlvHashPacketType(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHashPacketType, error) {
6323 _bsntlvhashpackettype := &BsnTlvHashPacketType{BsnTlv: parent}
6324 if decoder.Length() < 1 {
6325 return nil, fmt.Errorf("BsnTlvHashPacketType packet too short: %d < 1", decoder.Length())
6326 }
6327 _bsntlvhashpackettype.Value = BsnHashPacketType(decoder.ReadByte())
6328 return _bsntlvhashpackettype, nil
6329}
6330
6331func NewBsnTlvHashPacketType() *BsnTlvHashPacketType {
6332 obj := &BsnTlvHashPacketType{
6333 BsnTlv: NewBsnTlv(102),
6334 }
6335 return obj
6336}
6337
6338type BsnTlvHashSeed struct {
6339 *BsnTlv
6340 Seed1 uint32
6341 Seed2 uint32
6342}
6343
6344type IBsnTlvHashSeed interface {
6345 IBsnTlv
6346 GetSeed1() uint32
6347 GetSeed2() uint32
6348}
6349
6350func (self *BsnTlvHashSeed) GetSeed1() uint32 {
6351 return self.Seed1
6352}
6353
6354func (self *BsnTlvHashSeed) SetSeed1(v uint32) {
6355 self.Seed1 = v
6356}
6357
6358func (self *BsnTlvHashSeed) GetSeed2() uint32 {
6359 return self.Seed2
6360}
6361
6362func (self *BsnTlvHashSeed) SetSeed2(v uint32) {
6363 self.Seed2 = v
6364}
6365
6366func (self *BsnTlvHashSeed) Serialize(encoder *goloxi.Encoder) error {
6367 startIndex := len(encoder.Bytes())
6368 if err := self.BsnTlv.Serialize(encoder); err != nil {
6369 return err
6370 }
6371
6372 encoder.PutUint32(uint32(self.Seed1))
6373 encoder.PutUint32(uint32(self.Seed2))
6374 length := len(encoder.Bytes()) - startIndex
6375
6376 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6377
6378 return nil
6379}
6380
6381func DecodeBsnTlvHashSeed(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHashSeed, error) {
6382 _bsntlvhashseed := &BsnTlvHashSeed{BsnTlv: parent}
6383 if decoder.Length() < 8 {
6384 return nil, fmt.Errorf("BsnTlvHashSeed packet too short: %d < 8", decoder.Length())
6385 }
6386 _bsntlvhashseed.Seed1 = uint32(decoder.ReadUint32())
6387 _bsntlvhashseed.Seed2 = uint32(decoder.ReadUint32())
6388 return _bsntlvhashseed, nil
6389}
6390
6391func NewBsnTlvHashSeed() *BsnTlvHashSeed {
6392 obj := &BsnTlvHashSeed{
6393 BsnTlv: NewBsnTlv(100),
6394 }
6395 return obj
6396}
6397
6398type BsnTlvHashType struct {
6399 *BsnTlv
6400 Value BsnHashType
6401}
6402
6403type IBsnTlvHashType interface {
6404 IBsnTlv
6405 GetValue() BsnHashType
6406}
6407
6408func (self *BsnTlvHashType) GetValue() BsnHashType {
6409 return self.Value
6410}
6411
6412func (self *BsnTlvHashType) SetValue(v BsnHashType) {
6413 self.Value = v
6414}
6415
6416func (self *BsnTlvHashType) Serialize(encoder *goloxi.Encoder) error {
6417 startIndex := len(encoder.Bytes())
6418 if err := self.BsnTlv.Serialize(encoder); err != nil {
6419 return err
6420 }
6421
6422 encoder.PutUint8(uint8(self.Value))
6423 length := len(encoder.Bytes()) - startIndex
6424
6425 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6426
6427 return nil
6428}
6429
6430func DecodeBsnTlvHashType(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHashType, error) {
6431 _bsntlvhashtype := &BsnTlvHashType{BsnTlv: parent}
6432 if decoder.Length() < 1 {
6433 return nil, fmt.Errorf("BsnTlvHashType packet too short: %d < 1", decoder.Length())
6434 }
6435 _bsntlvhashtype.Value = BsnHashType(decoder.ReadByte())
6436 return _bsntlvhashtype, nil
6437}
6438
6439func NewBsnTlvHashType() *BsnTlvHashType {
6440 obj := &BsnTlvHashType{
6441 BsnTlv: NewBsnTlv(101),
6442 }
6443 return obj
6444}
6445
6446type BsnTlvHeaderSize struct {
6447 *BsnTlv
6448 Value uint32
6449}
6450
6451type IBsnTlvHeaderSize interface {
6452 IBsnTlv
6453 GetValue() uint32
6454}
6455
6456func (self *BsnTlvHeaderSize) GetValue() uint32 {
6457 return self.Value
6458}
6459
6460func (self *BsnTlvHeaderSize) SetValue(v uint32) {
6461 self.Value = v
6462}
6463
6464func (self *BsnTlvHeaderSize) Serialize(encoder *goloxi.Encoder) error {
6465 startIndex := len(encoder.Bytes())
6466 if err := self.BsnTlv.Serialize(encoder); err != nil {
6467 return err
6468 }
6469
6470 encoder.PutUint32(uint32(self.Value))
6471 length := len(encoder.Bytes()) - startIndex
6472
6473 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6474
6475 return nil
6476}
6477
6478func DecodeBsnTlvHeaderSize(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHeaderSize, error) {
6479 _bsntlvheadersize := &BsnTlvHeaderSize{BsnTlv: parent}
6480 if decoder.Length() < 4 {
6481 return nil, fmt.Errorf("BsnTlvHeaderSize packet too short: %d < 4", decoder.Length())
6482 }
6483 _bsntlvheadersize.Value = uint32(decoder.ReadUint32())
6484 return _bsntlvheadersize, nil
6485}
6486
6487func NewBsnTlvHeaderSize() *BsnTlvHeaderSize {
6488 obj := &BsnTlvHeaderSize{
6489 BsnTlv: NewBsnTlv(31),
6490 }
6491 return obj
6492}
6493
6494type BsnTlvIcmpCode struct {
6495 *BsnTlv
6496 Value uint8
6497}
6498
6499type IBsnTlvIcmpCode interface {
6500 IBsnTlv
6501 GetValue() uint8
6502}
6503
6504func (self *BsnTlvIcmpCode) GetValue() uint8 {
6505 return self.Value
6506}
6507
6508func (self *BsnTlvIcmpCode) SetValue(v uint8) {
6509 self.Value = v
6510}
6511
6512func (self *BsnTlvIcmpCode) Serialize(encoder *goloxi.Encoder) error {
6513 startIndex := len(encoder.Bytes())
6514 if err := self.BsnTlv.Serialize(encoder); err != nil {
6515 return err
6516 }
6517
6518 encoder.PutUint8(uint8(self.Value))
6519 length := len(encoder.Bytes()) - startIndex
6520
6521 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6522
6523 return nil
6524}
6525
6526func DecodeBsnTlvIcmpCode(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIcmpCode, error) {
6527 _bsntlvicmpcode := &BsnTlvIcmpCode{BsnTlv: parent}
6528 if decoder.Length() < 1 {
6529 return nil, fmt.Errorf("BsnTlvIcmpCode packet too short: %d < 1", decoder.Length())
6530 }
6531 _bsntlvicmpcode.Value = uint8(decoder.ReadByte())
6532 return _bsntlvicmpcode, nil
6533}
6534
6535func NewBsnTlvIcmpCode() *BsnTlvIcmpCode {
6536 obj := &BsnTlvIcmpCode{
6537 BsnTlv: NewBsnTlv(69),
6538 }
6539 return obj
6540}
6541
6542type BsnTlvIcmpId struct {
6543 *BsnTlv
6544 Value uint16
6545}
6546
6547type IBsnTlvIcmpId interface {
6548 IBsnTlv
6549 GetValue() uint16
6550}
6551
6552func (self *BsnTlvIcmpId) GetValue() uint16 {
6553 return self.Value
6554}
6555
6556func (self *BsnTlvIcmpId) SetValue(v uint16) {
6557 self.Value = v
6558}
6559
6560func (self *BsnTlvIcmpId) Serialize(encoder *goloxi.Encoder) error {
6561 startIndex := len(encoder.Bytes())
6562 if err := self.BsnTlv.Serialize(encoder); err != nil {
6563 return err
6564 }
6565
6566 encoder.PutUint16(uint16(self.Value))
6567 length := len(encoder.Bytes()) - startIndex
6568
6569 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6570
6571 return nil
6572}
6573
6574func DecodeBsnTlvIcmpId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIcmpId, error) {
6575 _bsntlvicmpid := &BsnTlvIcmpId{BsnTlv: parent}
6576 if decoder.Length() < 2 {
6577 return nil, fmt.Errorf("BsnTlvIcmpId packet too short: %d < 2", decoder.Length())
6578 }
6579 _bsntlvicmpid.Value = uint16(decoder.ReadUint16())
6580 return _bsntlvicmpid, nil
6581}
6582
6583func NewBsnTlvIcmpId() *BsnTlvIcmpId {
6584 obj := &BsnTlvIcmpId{
6585 BsnTlv: NewBsnTlv(70),
6586 }
6587 return obj
6588}
6589
6590type BsnTlvIcmpType struct {
6591 *BsnTlv
6592 Value uint8
6593}
6594
6595type IBsnTlvIcmpType interface {
6596 IBsnTlv
6597 GetValue() uint8
6598}
6599
6600func (self *BsnTlvIcmpType) GetValue() uint8 {
6601 return self.Value
6602}
6603
6604func (self *BsnTlvIcmpType) SetValue(v uint8) {
6605 self.Value = v
6606}
6607
6608func (self *BsnTlvIcmpType) Serialize(encoder *goloxi.Encoder) error {
6609 startIndex := len(encoder.Bytes())
6610 if err := self.BsnTlv.Serialize(encoder); err != nil {
6611 return err
6612 }
6613
6614 encoder.PutUint8(uint8(self.Value))
6615 length := len(encoder.Bytes()) - startIndex
6616
6617 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6618
6619 return nil
6620}
6621
6622func DecodeBsnTlvIcmpType(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIcmpType, error) {
6623 _bsntlvicmptype := &BsnTlvIcmpType{BsnTlv: parent}
6624 if decoder.Length() < 1 {
6625 return nil, fmt.Errorf("BsnTlvIcmpType packet too short: %d < 1", decoder.Length())
6626 }
6627 _bsntlvicmptype.Value = uint8(decoder.ReadByte())
6628 return _bsntlvicmptype, nil
6629}
6630
6631func NewBsnTlvIcmpType() *BsnTlvIcmpType {
6632 obj := &BsnTlvIcmpType{
6633 BsnTlv: NewBsnTlv(68),
6634 }
6635 return obj
6636}
6637
6638type BsnTlvIcmpv6Chksum struct {
6639 *BsnTlv
6640 Value uint16
6641}
6642
6643type IBsnTlvIcmpv6Chksum interface {
6644 IBsnTlv
6645 GetValue() uint16
6646}
6647
6648func (self *BsnTlvIcmpv6Chksum) GetValue() uint16 {
6649 return self.Value
6650}
6651
6652func (self *BsnTlvIcmpv6Chksum) SetValue(v uint16) {
6653 self.Value = v
6654}
6655
6656func (self *BsnTlvIcmpv6Chksum) Serialize(encoder *goloxi.Encoder) error {
6657 startIndex := len(encoder.Bytes())
6658 if err := self.BsnTlv.Serialize(encoder); err != nil {
6659 return err
6660 }
6661
6662 encoder.PutUint16(uint16(self.Value))
6663 length := len(encoder.Bytes()) - startIndex
6664
6665 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6666
6667 return nil
6668}
6669
6670func DecodeBsnTlvIcmpv6Chksum(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIcmpv6Chksum, error) {
6671 _bsntlvicmpv6chksum := &BsnTlvIcmpv6Chksum{BsnTlv: parent}
6672 if decoder.Length() < 2 {
6673 return nil, fmt.Errorf("BsnTlvIcmpv6Chksum packet too short: %d < 2", decoder.Length())
6674 }
6675 _bsntlvicmpv6chksum.Value = uint16(decoder.ReadUint16())
6676 return _bsntlvicmpv6chksum, nil
6677}
6678
6679func NewBsnTlvIcmpv6Chksum() *BsnTlvIcmpv6Chksum {
6680 obj := &BsnTlvIcmpv6Chksum{
6681 BsnTlv: NewBsnTlv(125),
6682 }
6683 return obj
6684}
6685
6686type BsnTlvIdentifier struct {
6687 *BsnTlv
6688 Value uint32
6689}
6690
6691type IBsnTlvIdentifier interface {
6692 IBsnTlv
6693 GetValue() uint32
6694}
6695
6696func (self *BsnTlvIdentifier) GetValue() uint32 {
6697 return self.Value
6698}
6699
6700func (self *BsnTlvIdentifier) SetValue(v uint32) {
6701 self.Value = v
6702}
6703
6704func (self *BsnTlvIdentifier) Serialize(encoder *goloxi.Encoder) error {
6705 startIndex := len(encoder.Bytes())
6706 if err := self.BsnTlv.Serialize(encoder); err != nil {
6707 return err
6708 }
6709
6710 encoder.PutUint32(uint32(self.Value))
6711 length := len(encoder.Bytes()) - startIndex
6712
6713 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6714
6715 return nil
6716}
6717
6718func DecodeBsnTlvIdentifier(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIdentifier, error) {
6719 _bsntlvidentifier := &BsnTlvIdentifier{BsnTlv: parent}
6720 if decoder.Length() < 4 {
6721 return nil, fmt.Errorf("BsnTlvIdentifier packet too short: %d < 4", decoder.Length())
6722 }
6723 _bsntlvidentifier.Value = uint32(decoder.ReadUint32())
6724 return _bsntlvidentifier, nil
6725}
6726
6727func NewBsnTlvIdentifier() *BsnTlvIdentifier {
6728 obj := &BsnTlvIdentifier{
6729 BsnTlv: NewBsnTlv(173),
6730 }
6731 return obj
6732}
6733
6734type BsnTlvIdleNotification struct {
6735 *BsnTlv
6736}
6737
6738type IBsnTlvIdleNotification interface {
6739 IBsnTlv
6740}
6741
6742func (self *BsnTlvIdleNotification) Serialize(encoder *goloxi.Encoder) error {
6743 startIndex := len(encoder.Bytes())
6744 if err := self.BsnTlv.Serialize(encoder); err != nil {
6745 return err
6746 }
6747 length := len(encoder.Bytes()) - startIndex
6748
6749 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6750
6751 return nil
6752}
6753
6754func DecodeBsnTlvIdleNotification(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIdleNotification, error) {
6755 _bsntlvidlenotification := &BsnTlvIdleNotification{BsnTlv: parent}
6756 return _bsntlvidlenotification, nil
6757}
6758
6759func NewBsnTlvIdleNotification() *BsnTlvIdleNotification {
6760 obj := &BsnTlvIdleNotification{
6761 BsnTlv: NewBsnTlv(7),
6762 }
6763 return obj
6764}
6765
6766type BsnTlvIdleTime struct {
6767 *BsnTlv
6768 Value uint64
6769}
6770
6771type IBsnTlvIdleTime interface {
6772 IBsnTlv
6773 GetValue() uint64
6774}
6775
6776func (self *BsnTlvIdleTime) GetValue() uint64 {
6777 return self.Value
6778}
6779
6780func (self *BsnTlvIdleTime) SetValue(v uint64) {
6781 self.Value = v
6782}
6783
6784func (self *BsnTlvIdleTime) Serialize(encoder *goloxi.Encoder) error {
6785 startIndex := len(encoder.Bytes())
6786 if err := self.BsnTlv.Serialize(encoder); err != nil {
6787 return err
6788 }
6789
6790 encoder.PutUint64(uint64(self.Value))
6791 length := len(encoder.Bytes()) - startIndex
6792
6793 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6794
6795 return nil
6796}
6797
6798func DecodeBsnTlvIdleTime(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIdleTime, error) {
6799 _bsntlvidletime := &BsnTlvIdleTime{BsnTlv: parent}
6800 if decoder.Length() < 8 {
6801 return nil, fmt.Errorf("BsnTlvIdleTime packet too short: %d < 8", decoder.Length())
6802 }
6803 _bsntlvidletime.Value = uint64(decoder.ReadUint64())
6804 return _bsntlvidletime, nil
6805}
6806
6807func NewBsnTlvIdleTime() *BsnTlvIdleTime {
6808 obj := &BsnTlvIdleTime{
6809 BsnTlv: NewBsnTlv(5),
6810 }
6811 return obj
6812}
6813
6814type BsnTlvIdleTimeout struct {
6815 *BsnTlv
6816 Value uint32
6817}
6818
6819type IBsnTlvIdleTimeout interface {
6820 IBsnTlv
6821 GetValue() uint32
6822}
6823
6824func (self *BsnTlvIdleTimeout) GetValue() uint32 {
6825 return self.Value
6826}
6827
6828func (self *BsnTlvIdleTimeout) SetValue(v uint32) {
6829 self.Value = v
6830}
6831
6832func (self *BsnTlvIdleTimeout) Serialize(encoder *goloxi.Encoder) error {
6833 startIndex := len(encoder.Bytes())
6834 if err := self.BsnTlv.Serialize(encoder); err != nil {
6835 return err
6836 }
6837
6838 encoder.PutUint32(uint32(self.Value))
6839 length := len(encoder.Bytes()) - startIndex
6840
6841 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6842
6843 return nil
6844}
6845
6846func DecodeBsnTlvIdleTimeout(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIdleTimeout, error) {
6847 _bsntlvidletimeout := &BsnTlvIdleTimeout{BsnTlv: parent}
6848 if decoder.Length() < 4 {
6849 return nil, fmt.Errorf("BsnTlvIdleTimeout packet too short: %d < 4", decoder.Length())
6850 }
6851 _bsntlvidletimeout.Value = uint32(decoder.ReadUint32())
6852 return _bsntlvidletimeout, nil
6853}
6854
6855func NewBsnTlvIdleTimeout() *BsnTlvIdleTimeout {
6856 obj := &BsnTlvIdleTimeout{
6857 BsnTlv: NewBsnTlv(8),
6858 }
6859 return obj
6860}
6861
6862type BsnTlvIgmpSnooping struct {
6863 *BsnTlv
6864}
6865
6866type IBsnTlvIgmpSnooping interface {
6867 IBsnTlv
6868}
6869
6870func (self *BsnTlvIgmpSnooping) Serialize(encoder *goloxi.Encoder) error {
6871 startIndex := len(encoder.Bytes())
6872 if err := self.BsnTlv.Serialize(encoder); err != nil {
6873 return err
6874 }
6875 length := len(encoder.Bytes()) - startIndex
6876
6877 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6878
6879 return nil
6880}
6881
6882func DecodeBsnTlvIgmpSnooping(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIgmpSnooping, error) {
6883 _bsntlvigmpsnooping := &BsnTlvIgmpSnooping{BsnTlv: parent}
6884 return _bsntlvigmpsnooping, nil
6885}
6886
6887func NewBsnTlvIgmpSnooping() *BsnTlvIgmpSnooping {
6888 obj := &BsnTlvIgmpSnooping{
6889 BsnTlv: NewBsnTlv(78),
6890 }
6891 return obj
6892}
6893
6894type BsnTlvIngressPortGroupId struct {
6895 *BsnTlv
6896 Value uint32
6897}
6898
6899type IBsnTlvIngressPortGroupId interface {
6900 IBsnTlv
6901 GetValue() uint32
6902}
6903
6904func (self *BsnTlvIngressPortGroupId) GetValue() uint32 {
6905 return self.Value
6906}
6907
6908func (self *BsnTlvIngressPortGroupId) SetValue(v uint32) {
6909 self.Value = v
6910}
6911
6912func (self *BsnTlvIngressPortGroupId) Serialize(encoder *goloxi.Encoder) error {
6913 startIndex := len(encoder.Bytes())
6914 if err := self.BsnTlv.Serialize(encoder); err != nil {
6915 return err
6916 }
6917
6918 encoder.PutUint32(uint32(self.Value))
6919 length := len(encoder.Bytes()) - startIndex
6920
6921 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6922
6923 return nil
6924}
6925
6926func DecodeBsnTlvIngressPortGroupId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIngressPortGroupId, error) {
6927 _bsntlvingressportgroupid := &BsnTlvIngressPortGroupId{BsnTlv: parent}
6928 if decoder.Length() < 4 {
6929 return nil, fmt.Errorf("BsnTlvIngressPortGroupId packet too short: %d < 4", decoder.Length())
6930 }
6931 _bsntlvingressportgroupid.Value = uint32(decoder.ReadUint32())
6932 return _bsntlvingressportgroupid, nil
6933}
6934
6935func NewBsnTlvIngressPortGroupId() *BsnTlvIngressPortGroupId {
6936 obj := &BsnTlvIngressPortGroupId{
6937 BsnTlv: NewBsnTlv(138),
6938 }
6939 return obj
6940}
6941
6942type BsnTlvInternalGatewayMac struct {
6943 *BsnTlv
6944 Value net.HardwareAddr
6945}
6946
6947type IBsnTlvInternalGatewayMac interface {
6948 IBsnTlv
6949 GetValue() net.HardwareAddr
6950}
6951
6952func (self *BsnTlvInternalGatewayMac) GetValue() net.HardwareAddr {
6953 return self.Value
6954}
6955
6956func (self *BsnTlvInternalGatewayMac) SetValue(v net.HardwareAddr) {
6957 self.Value = v
6958}
6959
6960func (self *BsnTlvInternalGatewayMac) Serialize(encoder *goloxi.Encoder) error {
6961 startIndex := len(encoder.Bytes())
6962 if err := self.BsnTlv.Serialize(encoder); err != nil {
6963 return err
6964 }
6965
6966 encoder.Write(self.Value)
6967 length := len(encoder.Bytes()) - startIndex
6968
6969 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6970
6971 return nil
6972}
6973
6974func DecodeBsnTlvInternalGatewayMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvInternalGatewayMac, error) {
6975 _bsntlvinternalgatewaymac := &BsnTlvInternalGatewayMac{BsnTlv: parent}
6976 if decoder.Length() < 6 {
6977 return nil, fmt.Errorf("BsnTlvInternalGatewayMac packet too short: %d < 6", decoder.Length())
6978 }
6979 _bsntlvinternalgatewaymac.Value = net.HardwareAddr(decoder.Read(6))
6980 return _bsntlvinternalgatewaymac, nil
6981}
6982
6983func NewBsnTlvInternalGatewayMac() *BsnTlvInternalGatewayMac {
6984 obj := &BsnTlvInternalGatewayMac{
6985 BsnTlv: NewBsnTlv(28),
6986 }
6987 return obj
6988}
6989
6990type BsnTlvInternalMac struct {
6991 *BsnTlv
6992 Value net.HardwareAddr
6993}
6994
6995type IBsnTlvInternalMac interface {
6996 IBsnTlv
6997 GetValue() net.HardwareAddr
6998}
6999
7000func (self *BsnTlvInternalMac) GetValue() net.HardwareAddr {
7001 return self.Value
7002}
7003
7004func (self *BsnTlvInternalMac) SetValue(v net.HardwareAddr) {
7005 self.Value = v
7006}
7007
7008func (self *BsnTlvInternalMac) Serialize(encoder *goloxi.Encoder) error {
7009 startIndex := len(encoder.Bytes())
7010 if err := self.BsnTlv.Serialize(encoder); err != nil {
7011 return err
7012 }
7013
7014 encoder.Write(self.Value)
7015 length := len(encoder.Bytes()) - startIndex
7016
7017 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7018
7019 return nil
7020}
7021
7022func DecodeBsnTlvInternalMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvInternalMac, error) {
7023 _bsntlvinternalmac := &BsnTlvInternalMac{BsnTlv: parent}
7024 if decoder.Length() < 6 {
7025 return nil, fmt.Errorf("BsnTlvInternalMac packet too short: %d < 6", decoder.Length())
7026 }
7027 _bsntlvinternalmac.Value = net.HardwareAddr(decoder.Read(6))
7028 return _bsntlvinternalmac, nil
7029}
7030
7031func NewBsnTlvInternalMac() *BsnTlvInternalMac {
7032 obj := &BsnTlvInternalMac{
7033 BsnTlv: NewBsnTlv(27),
7034 }
7035 return obj
7036}
7037
7038type BsnTlvInterval struct {
7039 *BsnTlv
7040 Value uint32
7041}
7042
7043type IBsnTlvInterval interface {
7044 IBsnTlv
7045 GetValue() uint32
7046}
7047
7048func (self *BsnTlvInterval) GetValue() uint32 {
7049 return self.Value
7050}
7051
7052func (self *BsnTlvInterval) SetValue(v uint32) {
7053 self.Value = v
7054}
7055
7056func (self *BsnTlvInterval) Serialize(encoder *goloxi.Encoder) error {
7057 startIndex := len(encoder.Bytes())
7058 if err := self.BsnTlv.Serialize(encoder); err != nil {
7059 return err
7060 }
7061
7062 encoder.PutUint32(uint32(self.Value))
7063 length := len(encoder.Bytes()) - startIndex
7064
7065 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7066
7067 return nil
7068}
7069
7070func DecodeBsnTlvInterval(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvInterval, error) {
7071 _bsntlvinterval := &BsnTlvInterval{BsnTlv: parent}
7072 if decoder.Length() < 4 {
7073 return nil, fmt.Errorf("BsnTlvInterval packet too short: %d < 4", decoder.Length())
7074 }
7075 _bsntlvinterval.Value = uint32(decoder.ReadUint32())
7076 return _bsntlvinterval, nil
7077}
7078
7079func NewBsnTlvInterval() *BsnTlvInterval {
7080 obj := &BsnTlvInterval{
7081 BsnTlv: NewBsnTlv(58),
7082 }
7083 return obj
7084}
7085
7086type BsnTlvIpProto struct {
7087 *BsnTlv
7088 Value uint8
7089}
7090
7091type IBsnTlvIpProto interface {
7092 IBsnTlv
7093 GetValue() uint8
7094}
7095
7096func (self *BsnTlvIpProto) GetValue() uint8 {
7097 return self.Value
7098}
7099
7100func (self *BsnTlvIpProto) SetValue(v uint8) {
7101 self.Value = v
7102}
7103
7104func (self *BsnTlvIpProto) Serialize(encoder *goloxi.Encoder) error {
7105 startIndex := len(encoder.Bytes())
7106 if err := self.BsnTlv.Serialize(encoder); err != nil {
7107 return err
7108 }
7109
7110 encoder.PutUint8(uint8(self.Value))
7111 length := len(encoder.Bytes()) - startIndex
7112
7113 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7114
7115 return nil
7116}
7117
7118func DecodeBsnTlvIpProto(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpProto, error) {
7119 _bsntlvipproto := &BsnTlvIpProto{BsnTlv: parent}
7120 if decoder.Length() < 1 {
7121 return nil, fmt.Errorf("BsnTlvIpProto packet too short: %d < 1", decoder.Length())
7122 }
7123 _bsntlvipproto.Value = uint8(decoder.ReadByte())
7124 return _bsntlvipproto, nil
7125}
7126
7127func NewBsnTlvIpProto() *BsnTlvIpProto {
7128 obj := &BsnTlvIpProto{
7129 BsnTlv: NewBsnTlv(67),
7130 }
7131 return obj
7132}
7133
7134type BsnTlvIpTunnelType struct {
7135 *BsnTlv
7136 Value BsnIpTunnelType
7137}
7138
7139type IBsnTlvIpTunnelType interface {
7140 IBsnTlv
7141 GetValue() BsnIpTunnelType
7142}
7143
7144func (self *BsnTlvIpTunnelType) GetValue() BsnIpTunnelType {
7145 return self.Value
7146}
7147
7148func (self *BsnTlvIpTunnelType) SetValue(v BsnIpTunnelType) {
7149 self.Value = v
7150}
7151
7152func (self *BsnTlvIpTunnelType) Serialize(encoder *goloxi.Encoder) error {
7153 startIndex := len(encoder.Bytes())
7154 if err := self.BsnTlv.Serialize(encoder); err != nil {
7155 return err
7156 }
7157
7158 encoder.PutUint16(uint16(self.Value))
7159 length := len(encoder.Bytes()) - startIndex
7160
7161 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7162
7163 return nil
7164}
7165
7166func DecodeBsnTlvIpTunnelType(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpTunnelType, error) {
7167 _bsntlviptunneltype := &BsnTlvIpTunnelType{BsnTlv: parent}
7168 if decoder.Length() < 2 {
7169 return nil, fmt.Errorf("BsnTlvIpTunnelType packet too short: %d < 2", decoder.Length())
7170 }
7171 _bsntlviptunneltype.Value = BsnIpTunnelType(decoder.ReadUint16())
7172 return _bsntlviptunneltype, nil
7173}
7174
7175func NewBsnTlvIpTunnelType() *BsnTlvIpTunnelType {
7176 obj := &BsnTlvIpTunnelType{
7177 BsnTlv: NewBsnTlv(169),
7178 }
7179 return obj
7180}
7181
7182type BsnTlvIpv4 struct {
7183 *BsnTlv
7184 Value net.IP
7185}
7186
7187type IBsnTlvIpv4 interface {
7188 IBsnTlv
7189 GetValue() net.IP
7190}
7191
7192func (self *BsnTlvIpv4) GetValue() net.IP {
7193 return self.Value
7194}
7195
7196func (self *BsnTlvIpv4) SetValue(v net.IP) {
7197 self.Value = v
7198}
7199
7200func (self *BsnTlvIpv4) Serialize(encoder *goloxi.Encoder) error {
7201 startIndex := len(encoder.Bytes())
7202 if err := self.BsnTlv.Serialize(encoder); err != nil {
7203 return err
7204 }
7205
7206 encoder.Write(self.Value.To4())
7207 length := len(encoder.Bytes()) - startIndex
7208
7209 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7210
7211 return nil
7212}
7213
7214func DecodeBsnTlvIpv4(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv4, error) {
7215 _bsntlvipv4 := &BsnTlvIpv4{BsnTlv: parent}
7216 if decoder.Length() < 4 {
7217 return nil, fmt.Errorf("BsnTlvIpv4 packet too short: %d < 4", decoder.Length())
7218 }
7219 _bsntlvipv4.Value = net.IP(decoder.Read(4))
7220 return _bsntlvipv4, nil
7221}
7222
7223func NewBsnTlvIpv4() *BsnTlvIpv4 {
7224 obj := &BsnTlvIpv4{
7225 BsnTlv: NewBsnTlv(4),
7226 }
7227 return obj
7228}
7229
7230type BsnTlvIpv4Dst struct {
7231 *BsnTlv
7232 Value net.IP
7233}
7234
7235type IBsnTlvIpv4Dst interface {
7236 IBsnTlv
7237 GetValue() net.IP
7238}
7239
7240func (self *BsnTlvIpv4Dst) GetValue() net.IP {
7241 return self.Value
7242}
7243
7244func (self *BsnTlvIpv4Dst) SetValue(v net.IP) {
7245 self.Value = v
7246}
7247
7248func (self *BsnTlvIpv4Dst) Serialize(encoder *goloxi.Encoder) error {
7249 startIndex := len(encoder.Bytes())
7250 if err := self.BsnTlv.Serialize(encoder); err != nil {
7251 return err
7252 }
7253
7254 encoder.Write(self.Value.To4())
7255 length := len(encoder.Bytes()) - startIndex
7256
7257 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7258
7259 return nil
7260}
7261
7262func DecodeBsnTlvIpv4Dst(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv4Dst, error) {
7263 _bsntlvipv4dst := &BsnTlvIpv4Dst{BsnTlv: parent}
7264 if decoder.Length() < 4 {
7265 return nil, fmt.Errorf("BsnTlvIpv4Dst packet too short: %d < 4", decoder.Length())
7266 }
7267 _bsntlvipv4dst.Value = net.IP(decoder.Read(4))
7268 return _bsntlvipv4dst, nil
7269}
7270
7271func NewBsnTlvIpv4Dst() *BsnTlvIpv4Dst {
7272 obj := &BsnTlvIpv4Dst{
7273 BsnTlv: NewBsnTlv(35),
7274 }
7275 return obj
7276}
7277
7278type BsnTlvIpv4Netmask struct {
7279 *BsnTlv
7280 Value net.IP
7281}
7282
7283type IBsnTlvIpv4Netmask interface {
7284 IBsnTlv
7285 GetValue() net.IP
7286}
7287
7288func (self *BsnTlvIpv4Netmask) GetValue() net.IP {
7289 return self.Value
7290}
7291
7292func (self *BsnTlvIpv4Netmask) SetValue(v net.IP) {
7293 self.Value = v
7294}
7295
7296func (self *BsnTlvIpv4Netmask) Serialize(encoder *goloxi.Encoder) error {
7297 startIndex := len(encoder.Bytes())
7298 if err := self.BsnTlv.Serialize(encoder); err != nil {
7299 return err
7300 }
7301
7302 encoder.Write(self.Value.To4())
7303 length := len(encoder.Bytes()) - startIndex
7304
7305 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7306
7307 return nil
7308}
7309
7310func DecodeBsnTlvIpv4Netmask(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv4Netmask, error) {
7311 _bsntlvipv4netmask := &BsnTlvIpv4Netmask{BsnTlv: parent}
7312 if decoder.Length() < 4 {
7313 return nil, fmt.Errorf("BsnTlvIpv4Netmask packet too short: %d < 4", decoder.Length())
7314 }
7315 _bsntlvipv4netmask.Value = net.IP(decoder.Read(4))
7316 return _bsntlvipv4netmask, nil
7317}
7318
7319func NewBsnTlvIpv4Netmask() *BsnTlvIpv4Netmask {
7320 obj := &BsnTlvIpv4Netmask{
7321 BsnTlv: NewBsnTlv(60),
7322 }
7323 return obj
7324}
7325
7326type BsnTlvIpv4Src struct {
7327 *BsnTlv
7328 Value net.IP
7329}
7330
7331type IBsnTlvIpv4Src interface {
7332 IBsnTlv
7333 GetValue() net.IP
7334}
7335
7336func (self *BsnTlvIpv4Src) GetValue() net.IP {
7337 return self.Value
7338}
7339
7340func (self *BsnTlvIpv4Src) SetValue(v net.IP) {
7341 self.Value = v
7342}
7343
7344func (self *BsnTlvIpv4Src) Serialize(encoder *goloxi.Encoder) error {
7345 startIndex := len(encoder.Bytes())
7346 if err := self.BsnTlv.Serialize(encoder); err != nil {
7347 return err
7348 }
7349
7350 encoder.Write(self.Value.To4())
7351 length := len(encoder.Bytes()) - startIndex
7352
7353 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7354
7355 return nil
7356}
7357
7358func DecodeBsnTlvIpv4Src(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv4Src, error) {
7359 _bsntlvipv4src := &BsnTlvIpv4Src{BsnTlv: parent}
7360 if decoder.Length() < 4 {
7361 return nil, fmt.Errorf("BsnTlvIpv4Src packet too short: %d < 4", decoder.Length())
7362 }
7363 _bsntlvipv4src.Value = net.IP(decoder.Read(4))
7364 return _bsntlvipv4src, nil
7365}
7366
7367func NewBsnTlvIpv4Src() *BsnTlvIpv4Src {
7368 obj := &BsnTlvIpv4Src{
7369 BsnTlv: NewBsnTlv(34),
7370 }
7371 return obj
7372}
7373
7374type BsnTlvIpv6 struct {
7375 *BsnTlv
7376 Value net.IP
7377}
7378
7379type IBsnTlvIpv6 interface {
7380 IBsnTlv
7381 GetValue() net.IP
7382}
7383
7384func (self *BsnTlvIpv6) GetValue() net.IP {
7385 return self.Value
7386}
7387
7388func (self *BsnTlvIpv6) SetValue(v net.IP) {
7389 self.Value = v
7390}
7391
7392func (self *BsnTlvIpv6) Serialize(encoder *goloxi.Encoder) error {
7393 startIndex := len(encoder.Bytes())
7394 if err := self.BsnTlv.Serialize(encoder); err != nil {
7395 return err
7396 }
7397
7398 encoder.Write(self.Value.To16())
7399 length := len(encoder.Bytes()) - startIndex
7400
7401 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7402
7403 return nil
7404}
7405
7406func DecodeBsnTlvIpv6(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv6, error) {
7407 _bsntlvipv6 := &BsnTlvIpv6{BsnTlv: parent}
7408 if decoder.Length() < 16 {
7409 return nil, fmt.Errorf("BsnTlvIpv6 packet too short: %d < 16", decoder.Length())
7410 }
7411 _bsntlvipv6.Value = net.IP(decoder.Read(16))
7412 return _bsntlvipv6, nil
7413}
7414
7415func NewBsnTlvIpv6() *BsnTlvIpv6 {
7416 obj := &BsnTlvIpv6{
7417 BsnTlv: NewBsnTlv(84),
7418 }
7419 return obj
7420}
7421
7422type BsnTlvIpv6Dst struct {
7423 *BsnTlv
7424 Value net.IP
7425}
7426
7427type IBsnTlvIpv6Dst interface {
7428 IBsnTlv
7429 GetValue() net.IP
7430}
7431
7432func (self *BsnTlvIpv6Dst) GetValue() net.IP {
7433 return self.Value
7434}
7435
7436func (self *BsnTlvIpv6Dst) SetValue(v net.IP) {
7437 self.Value = v
7438}
7439
7440func (self *BsnTlvIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
7441 startIndex := len(encoder.Bytes())
7442 if err := self.BsnTlv.Serialize(encoder); err != nil {
7443 return err
7444 }
7445
7446 encoder.Write(self.Value.To16())
7447 length := len(encoder.Bytes()) - startIndex
7448
7449 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7450
7451 return nil
7452}
7453
7454func DecodeBsnTlvIpv6Dst(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv6Dst, error) {
7455 _bsntlvipv6dst := &BsnTlvIpv6Dst{BsnTlv: parent}
7456 if decoder.Length() < 16 {
7457 return nil, fmt.Errorf("BsnTlvIpv6Dst packet too short: %d < 16", decoder.Length())
7458 }
7459 _bsntlvipv6dst.Value = net.IP(decoder.Read(16))
7460 return _bsntlvipv6dst, nil
7461}
7462
7463func NewBsnTlvIpv6Dst() *BsnTlvIpv6Dst {
7464 obj := &BsnTlvIpv6Dst{
7465 BsnTlv: NewBsnTlv(127),
7466 }
7467 return obj
7468}
7469
7470type BsnTlvIpv6Prefix struct {
7471 *BsnTlv
7472 Value net.IP
7473 PrefixLength uint8
7474}
7475
7476type IBsnTlvIpv6Prefix interface {
7477 IBsnTlv
7478 GetValue() net.IP
7479 GetPrefixLength() uint8
7480}
7481
7482func (self *BsnTlvIpv6Prefix) GetValue() net.IP {
7483 return self.Value
7484}
7485
7486func (self *BsnTlvIpv6Prefix) SetValue(v net.IP) {
7487 self.Value = v
7488}
7489
7490func (self *BsnTlvIpv6Prefix) GetPrefixLength() uint8 {
7491 return self.PrefixLength
7492}
7493
7494func (self *BsnTlvIpv6Prefix) SetPrefixLength(v uint8) {
7495 self.PrefixLength = v
7496}
7497
7498func (self *BsnTlvIpv6Prefix) Serialize(encoder *goloxi.Encoder) error {
7499 startIndex := len(encoder.Bytes())
7500 if err := self.BsnTlv.Serialize(encoder); err != nil {
7501 return err
7502 }
7503
7504 encoder.Write(self.Value.To16())
7505 encoder.PutUint8(uint8(self.PrefixLength))
7506 length := len(encoder.Bytes()) - startIndex
7507
7508 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7509
7510 return nil
7511}
7512
7513func DecodeBsnTlvIpv6Prefix(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv6Prefix, error) {
7514 _bsntlvipv6prefix := &BsnTlvIpv6Prefix{BsnTlv: parent}
7515 if decoder.Length() < 17 {
7516 return nil, fmt.Errorf("BsnTlvIpv6Prefix packet too short: %d < 17", decoder.Length())
7517 }
7518 _bsntlvipv6prefix.Value = net.IP(decoder.Read(16))
7519 _bsntlvipv6prefix.PrefixLength = uint8(decoder.ReadByte())
7520 return _bsntlvipv6prefix, nil
7521}
7522
7523func NewBsnTlvIpv6Prefix() *BsnTlvIpv6Prefix {
7524 obj := &BsnTlvIpv6Prefix{
7525 BsnTlv: NewBsnTlv(122),
7526 }
7527 return obj
7528}
7529
7530type BsnTlvIpv6Src struct {
7531 *BsnTlv
7532 Value net.IP
7533}
7534
7535type IBsnTlvIpv6Src interface {
7536 IBsnTlv
7537 GetValue() net.IP
7538}
7539
7540func (self *BsnTlvIpv6Src) GetValue() net.IP {
7541 return self.Value
7542}
7543
7544func (self *BsnTlvIpv6Src) SetValue(v net.IP) {
7545 self.Value = v
7546}
7547
7548func (self *BsnTlvIpv6Src) Serialize(encoder *goloxi.Encoder) error {
7549 startIndex := len(encoder.Bytes())
7550 if err := self.BsnTlv.Serialize(encoder); err != nil {
7551 return err
7552 }
7553
7554 encoder.Write(self.Value.To16())
7555 length := len(encoder.Bytes()) - startIndex
7556
7557 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7558
7559 return nil
7560}
7561
7562func DecodeBsnTlvIpv6Src(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv6Src, error) {
7563 _bsntlvipv6src := &BsnTlvIpv6Src{BsnTlv: parent}
7564 if decoder.Length() < 16 {
7565 return nil, fmt.Errorf("BsnTlvIpv6Src packet too short: %d < 16", decoder.Length())
7566 }
7567 _bsntlvipv6src.Value = net.IP(decoder.Read(16))
7568 return _bsntlvipv6src, nil
7569}
7570
7571func NewBsnTlvIpv6Src() *BsnTlvIpv6Src {
7572 obj := &BsnTlvIpv6Src{
7573 BsnTlv: NewBsnTlv(126),
7574 }
7575 return obj
7576}
7577
7578type BsnTlvKnownMulticastRate struct {
7579 *BsnTlv
7580 Value uint32
7581}
7582
7583type IBsnTlvKnownMulticastRate interface {
7584 IBsnTlv
7585 GetValue() uint32
7586}
7587
7588func (self *BsnTlvKnownMulticastRate) GetValue() uint32 {
7589 return self.Value
7590}
7591
7592func (self *BsnTlvKnownMulticastRate) SetValue(v uint32) {
7593 self.Value = v
7594}
7595
7596func (self *BsnTlvKnownMulticastRate) Serialize(encoder *goloxi.Encoder) error {
7597 startIndex := len(encoder.Bytes())
7598 if err := self.BsnTlv.Serialize(encoder); err != nil {
7599 return err
7600 }
7601
7602 encoder.PutUint32(uint32(self.Value))
7603 length := len(encoder.Bytes()) - startIndex
7604
7605 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7606
7607 return nil
7608}
7609
7610func DecodeBsnTlvKnownMulticastRate(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvKnownMulticastRate, error) {
7611 _bsntlvknownmulticastrate := &BsnTlvKnownMulticastRate{BsnTlv: parent}
7612 if decoder.Length() < 4 {
7613 return nil, fmt.Errorf("BsnTlvKnownMulticastRate packet too short: %d < 4", decoder.Length())
7614 }
7615 _bsntlvknownmulticastrate.Value = uint32(decoder.ReadUint32())
7616 return _bsntlvknownmulticastrate, nil
7617}
7618
7619func NewBsnTlvKnownMulticastRate() *BsnTlvKnownMulticastRate {
7620 obj := &BsnTlvKnownMulticastRate{
7621 BsnTlv: NewBsnTlv(91),
7622 }
7623 return obj
7624}
7625
7626type BsnTlvL2MulticastLookup struct {
7627 *BsnTlv
7628}
7629
7630type IBsnTlvL2MulticastLookup interface {
7631 IBsnTlv
7632}
7633
7634func (self *BsnTlvL2MulticastLookup) Serialize(encoder *goloxi.Encoder) error {
7635 startIndex := len(encoder.Bytes())
7636 if err := self.BsnTlv.Serialize(encoder); err != nil {
7637 return err
7638 }
7639 length := len(encoder.Bytes()) - startIndex
7640
7641 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7642
7643 return nil
7644}
7645
7646func DecodeBsnTlvL2MulticastLookup(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvL2MulticastLookup, error) {
7647 _bsntlvl2multicastlookup := &BsnTlvL2MulticastLookup{BsnTlv: parent}
7648 return _bsntlvl2multicastlookup, nil
7649}
7650
7651func NewBsnTlvL2MulticastLookup() *BsnTlvL2MulticastLookup {
7652 obj := &BsnTlvL2MulticastLookup{
7653 BsnTlv: NewBsnTlv(79),
7654 }
7655 return obj
7656}
7657
7658type BsnTlvL3 struct {
7659 *BsnTlv
7660}
7661
7662type IBsnTlvL3 interface {
7663 IBsnTlv
7664}
7665
7666func (self *BsnTlvL3) Serialize(encoder *goloxi.Encoder) error {
7667 startIndex := len(encoder.Bytes())
7668 if err := self.BsnTlv.Serialize(encoder); err != nil {
7669 return err
7670 }
7671 length := len(encoder.Bytes()) - startIndex
7672
7673 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7674
7675 return nil
7676}
7677
7678func DecodeBsnTlvL3(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvL3, error) {
7679 _bsntlvl3 := &BsnTlvL3{BsnTlv: parent}
7680 return _bsntlvl3, nil
7681}
7682
7683func NewBsnTlvL3() *BsnTlvL3 {
7684 obj := &BsnTlvL3{
7685 BsnTlv: NewBsnTlv(168),
7686 }
7687 return obj
7688}
7689
7690type BsnTlvL3DstClassId struct {
7691 *BsnTlv
7692 Value uint32
7693}
7694
7695type IBsnTlvL3DstClassId interface {
7696 IBsnTlv
7697 GetValue() uint32
7698}
7699
7700func (self *BsnTlvL3DstClassId) GetValue() uint32 {
7701 return self.Value
7702}
7703
7704func (self *BsnTlvL3DstClassId) SetValue(v uint32) {
7705 self.Value = v
7706}
7707
7708func (self *BsnTlvL3DstClassId) Serialize(encoder *goloxi.Encoder) error {
7709 startIndex := len(encoder.Bytes())
7710 if err := self.BsnTlv.Serialize(encoder); err != nil {
7711 return err
7712 }
7713
7714 encoder.PutUint32(uint32(self.Value))
7715 length := len(encoder.Bytes()) - startIndex
7716
7717 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7718
7719 return nil
7720}
7721
7722func DecodeBsnTlvL3DstClassId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvL3DstClassId, error) {
7723 _bsntlvl3dstclassid := &BsnTlvL3DstClassId{BsnTlv: parent}
7724 if decoder.Length() < 4 {
7725 return nil, fmt.Errorf("BsnTlvL3DstClassId packet too short: %d < 4", decoder.Length())
7726 }
7727 _bsntlvl3dstclassid.Value = uint32(decoder.ReadUint32())
7728 return _bsntlvl3dstclassid, nil
7729}
7730
7731func NewBsnTlvL3DstClassId() *BsnTlvL3DstClassId {
7732 obj := &BsnTlvL3DstClassId{
7733 BsnTlv: NewBsnTlv(136),
7734 }
7735 return obj
7736}
7737
7738type BsnTlvL3InterfaceClassId struct {
7739 *BsnTlv
7740 Value uint32
7741}
7742
7743type IBsnTlvL3InterfaceClassId interface {
7744 IBsnTlv
7745 GetValue() uint32
7746}
7747
7748func (self *BsnTlvL3InterfaceClassId) GetValue() uint32 {
7749 return self.Value
7750}
7751
7752func (self *BsnTlvL3InterfaceClassId) SetValue(v uint32) {
7753 self.Value = v
7754}
7755
7756func (self *BsnTlvL3InterfaceClassId) Serialize(encoder *goloxi.Encoder) error {
7757 startIndex := len(encoder.Bytes())
7758 if err := self.BsnTlv.Serialize(encoder); err != nil {
7759 return err
7760 }
7761
7762 encoder.PutUint32(uint32(self.Value))
7763 length := len(encoder.Bytes()) - startIndex
7764
7765 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7766
7767 return nil
7768}
7769
7770func DecodeBsnTlvL3InterfaceClassId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvL3InterfaceClassId, error) {
7771 _bsntlvl3interfaceclassid := &BsnTlvL3InterfaceClassId{BsnTlv: parent}
7772 if decoder.Length() < 4 {
7773 return nil, fmt.Errorf("BsnTlvL3InterfaceClassId packet too short: %d < 4", decoder.Length())
7774 }
7775 _bsntlvl3interfaceclassid.Value = uint32(decoder.ReadUint32())
7776 return _bsntlvl3interfaceclassid, nil
7777}
7778
7779func NewBsnTlvL3InterfaceClassId() *BsnTlvL3InterfaceClassId {
7780 obj := &BsnTlvL3InterfaceClassId{
7781 BsnTlv: NewBsnTlv(134),
7782 }
7783 return obj
7784}
7785
7786type BsnTlvL3SrcClassId struct {
7787 *BsnTlv
7788 Value uint32
7789}
7790
7791type IBsnTlvL3SrcClassId interface {
7792 IBsnTlv
7793 GetValue() uint32
7794}
7795
7796func (self *BsnTlvL3SrcClassId) GetValue() uint32 {
7797 return self.Value
7798}
7799
7800func (self *BsnTlvL3SrcClassId) SetValue(v uint32) {
7801 self.Value = v
7802}
7803
7804func (self *BsnTlvL3SrcClassId) Serialize(encoder *goloxi.Encoder) error {
7805 startIndex := len(encoder.Bytes())
7806 if err := self.BsnTlv.Serialize(encoder); err != nil {
7807 return err
7808 }
7809
7810 encoder.PutUint32(uint32(self.Value))
7811 length := len(encoder.Bytes()) - startIndex
7812
7813 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7814
7815 return nil
7816}
7817
7818func DecodeBsnTlvL3SrcClassId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvL3SrcClassId, error) {
7819 _bsntlvl3srcclassid := &BsnTlvL3SrcClassId{BsnTlv: parent}
7820 if decoder.Length() < 4 {
7821 return nil, fmt.Errorf("BsnTlvL3SrcClassId packet too short: %d < 4", decoder.Length())
7822 }
7823 _bsntlvl3srcclassid.Value = uint32(decoder.ReadUint32())
7824 return _bsntlvl3srcclassid, nil
7825}
7826
7827func NewBsnTlvL3SrcClassId() *BsnTlvL3SrcClassId {
7828 obj := &BsnTlvL3SrcClassId{
7829 BsnTlv: NewBsnTlv(135),
7830 }
7831 return obj
7832}
7833
7834type BsnTlvLagOptions struct {
7835 *BsnTlv
7836 Flags BsnLagFlag
7837}
7838
7839type IBsnTlvLagOptions interface {
7840 IBsnTlv
7841 GetFlags() BsnLagFlag
7842}
7843
7844func (self *BsnTlvLagOptions) GetFlags() BsnLagFlag {
7845 return self.Flags
7846}
7847
7848func (self *BsnTlvLagOptions) SetFlags(v BsnLagFlag) {
7849 self.Flags = v
7850}
7851
7852func (self *BsnTlvLagOptions) Serialize(encoder *goloxi.Encoder) error {
7853 startIndex := len(encoder.Bytes())
7854 if err := self.BsnTlv.Serialize(encoder); err != nil {
7855 return err
7856 }
7857
7858 encoder.PutUint16(uint16(self.Flags))
7859 length := len(encoder.Bytes()) - startIndex
7860
7861 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7862
7863 return nil
7864}
7865
7866func DecodeBsnTlvLagOptions(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvLagOptions, error) {
7867 _bsntlvlagoptions := &BsnTlvLagOptions{BsnTlv: parent}
7868 if decoder.Length() < 2 {
7869 return nil, fmt.Errorf("BsnTlvLagOptions packet too short: %d < 2", decoder.Length())
7870 }
7871 _bsntlvlagoptions.Flags = BsnLagFlag(decoder.ReadUint16())
7872 return _bsntlvlagoptions, nil
7873}
7874
7875func NewBsnTlvLagOptions() *BsnTlvLagOptions {
7876 obj := &BsnTlvLagOptions{
7877 BsnTlv: NewBsnTlv(160),
7878 }
7879 return obj
7880}
7881
7882type BsnTlvLinkUp struct {
7883 *BsnTlv
7884}
7885
7886type IBsnTlvLinkUp interface {
7887 IBsnTlv
7888}
7889
7890func (self *BsnTlvLinkUp) Serialize(encoder *goloxi.Encoder) error {
7891 startIndex := len(encoder.Bytes())
7892 if err := self.BsnTlv.Serialize(encoder); err != nil {
7893 return err
7894 }
7895 length := len(encoder.Bytes()) - startIndex
7896
7897 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7898
7899 return nil
7900}
7901
7902func DecodeBsnTlvLinkUp(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvLinkUp, error) {
7903 _bsntlvlinkup := &BsnTlvLinkUp{BsnTlv: parent}
7904 return _bsntlvlinkup, nil
7905}
7906
7907func NewBsnTlvLinkUp() *BsnTlvLinkUp {
7908 obj := &BsnTlvLinkUp{
7909 BsnTlv: NewBsnTlv(193),
7910 }
7911 return obj
7912}
7913
7914type BsnTlvLoopbackMode struct {
7915 *BsnTlv
7916 Value BsnLoopbackMode
7917}
7918
7919type IBsnTlvLoopbackMode interface {
7920 IBsnTlv
7921 GetValue() BsnLoopbackMode
7922}
7923
7924func (self *BsnTlvLoopbackMode) GetValue() BsnLoopbackMode {
7925 return self.Value
7926}
7927
7928func (self *BsnTlvLoopbackMode) SetValue(v BsnLoopbackMode) {
7929 self.Value = v
7930}
7931
7932func (self *BsnTlvLoopbackMode) Serialize(encoder *goloxi.Encoder) error {
7933 startIndex := len(encoder.Bytes())
7934 if err := self.BsnTlv.Serialize(encoder); err != nil {
7935 return err
7936 }
7937
7938 encoder.PutUint8(uint8(self.Value))
7939 length := len(encoder.Bytes()) - startIndex
7940
7941 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7942
7943 return nil
7944}
7945
7946func DecodeBsnTlvLoopbackMode(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvLoopbackMode, error) {
7947 _bsntlvloopbackmode := &BsnTlvLoopbackMode{BsnTlv: parent}
7948 if decoder.Length() < 1 {
7949 return nil, fmt.Errorf("BsnTlvLoopbackMode packet too short: %d < 1", decoder.Length())
7950 }
7951 _bsntlvloopbackmode.Value = BsnLoopbackMode(decoder.ReadByte())
7952 return _bsntlvloopbackmode, nil
7953}
7954
7955func NewBsnTlvLoopbackMode() *BsnTlvLoopbackMode {
7956 obj := &BsnTlvLoopbackMode{
7957 BsnTlv: NewBsnTlv(146),
7958 }
7959 return obj
7960}
7961
7962type BsnTlvLoopbackPort struct {
7963 *BsnTlv
7964 Value Port
7965}
7966
7967type IBsnTlvLoopbackPort interface {
7968 IBsnTlv
7969 GetValue() Port
7970}
7971
7972func (self *BsnTlvLoopbackPort) GetValue() Port {
7973 return self.Value
7974}
7975
7976func (self *BsnTlvLoopbackPort) SetValue(v Port) {
7977 self.Value = v
7978}
7979
7980func (self *BsnTlvLoopbackPort) Serialize(encoder *goloxi.Encoder) error {
7981 startIndex := len(encoder.Bytes())
7982 if err := self.BsnTlv.Serialize(encoder); err != nil {
7983 return err
7984 }
7985
7986 self.Value.Serialize(encoder)
7987 length := len(encoder.Bytes()) - startIndex
7988
7989 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7990
7991 return nil
7992}
7993
7994func DecodeBsnTlvLoopbackPort(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvLoopbackPort, error) {
7995 _bsntlvloopbackport := &BsnTlvLoopbackPort{BsnTlv: parent}
7996 if decoder.Length() < 4 {
7997 return nil, fmt.Errorf("BsnTlvLoopbackPort packet too short: %d < 4", decoder.Length())
7998 }
7999 _bsntlvloopbackport.Value.Decode(decoder)
8000 return _bsntlvloopbackport, nil
8001}
8002
8003func NewBsnTlvLoopbackPort() *BsnTlvLoopbackPort {
8004 obj := &BsnTlvLoopbackPort{
8005 BsnTlv: NewBsnTlv(110),
8006 }
8007 return obj
8008}
8009
8010type BsnTlvLossless struct {
8011 *BsnTlv
8012}
8013
8014type IBsnTlvLossless interface {
8015 IBsnTlv
8016}
8017
8018func (self *BsnTlvLossless) Serialize(encoder *goloxi.Encoder) error {
8019 startIndex := len(encoder.Bytes())
8020 if err := self.BsnTlv.Serialize(encoder); err != nil {
8021 return err
8022 }
8023 length := len(encoder.Bytes()) - startIndex
8024
8025 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8026
8027 return nil
8028}
8029
8030func DecodeBsnTlvLossless(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvLossless, error) {
8031 _bsntlvlossless := &BsnTlvLossless{BsnTlv: parent}
8032 return _bsntlvlossless, nil
8033}
8034
8035func NewBsnTlvLossless() *BsnTlvLossless {
8036 obj := &BsnTlvLossless{
8037 BsnTlv: NewBsnTlv(188),
8038 }
8039 return obj
8040}
8041
8042type BsnTlvLrAllEnabled struct {
8043 *BsnTlv
8044}
8045
8046type IBsnTlvLrAllEnabled interface {
8047 IBsnTlv
8048}
8049
8050func (self *BsnTlvLrAllEnabled) Serialize(encoder *goloxi.Encoder) error {
8051 startIndex := len(encoder.Bytes())
8052 if err := self.BsnTlv.Serialize(encoder); err != nil {
8053 return err
8054 }
8055 length := len(encoder.Bytes()) - startIndex
8056
8057 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8058
8059 return nil
8060}
8061
8062func DecodeBsnTlvLrAllEnabled(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvLrAllEnabled, error) {
8063 _bsntlvlrallenabled := &BsnTlvLrAllEnabled{BsnTlv: parent}
8064 return _bsntlvlrallenabled, nil
8065}
8066
8067func NewBsnTlvLrAllEnabled() *BsnTlvLrAllEnabled {
8068 obj := &BsnTlvLrAllEnabled{
8069 BsnTlv: NewBsnTlv(178),
8070 }
8071 return obj
8072}
8073
8074type BsnTlvMac struct {
8075 *BsnTlv
8076 Value net.HardwareAddr
8077}
8078
8079type IBsnTlvMac interface {
8080 IBsnTlv
8081 GetValue() net.HardwareAddr
8082}
8083
8084func (self *BsnTlvMac) GetValue() net.HardwareAddr {
8085 return self.Value
8086}
8087
8088func (self *BsnTlvMac) SetValue(v net.HardwareAddr) {
8089 self.Value = v
8090}
8091
8092func (self *BsnTlvMac) Serialize(encoder *goloxi.Encoder) error {
8093 startIndex := len(encoder.Bytes())
8094 if err := self.BsnTlv.Serialize(encoder); err != nil {
8095 return err
8096 }
8097
8098 encoder.Write(self.Value)
8099 length := len(encoder.Bytes()) - startIndex
8100
8101 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8102
8103 return nil
8104}
8105
8106func DecodeBsnTlvMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMac, error) {
8107 _bsntlvmac := &BsnTlvMac{BsnTlv: parent}
8108 if decoder.Length() < 6 {
8109 return nil, fmt.Errorf("BsnTlvMac packet too short: %d < 6", decoder.Length())
8110 }
8111 _bsntlvmac.Value = net.HardwareAddr(decoder.Read(6))
8112 return _bsntlvmac, nil
8113}
8114
8115func NewBsnTlvMac() *BsnTlvMac {
8116 obj := &BsnTlvMac{
8117 BsnTlv: NewBsnTlv(1),
8118 }
8119 return obj
8120}
8121
8122type BsnTlvMacMask struct {
8123 *BsnTlv
8124 Value net.HardwareAddr
8125}
8126
8127type IBsnTlvMacMask interface {
8128 IBsnTlv
8129 GetValue() net.HardwareAddr
8130}
8131
8132func (self *BsnTlvMacMask) GetValue() net.HardwareAddr {
8133 return self.Value
8134}
8135
8136func (self *BsnTlvMacMask) SetValue(v net.HardwareAddr) {
8137 self.Value = v
8138}
8139
8140func (self *BsnTlvMacMask) Serialize(encoder *goloxi.Encoder) error {
8141 startIndex := len(encoder.Bytes())
8142 if err := self.BsnTlv.Serialize(encoder); err != nil {
8143 return err
8144 }
8145
8146 encoder.Write(self.Value)
8147 length := len(encoder.Bytes()) - startIndex
8148
8149 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8150
8151 return nil
8152}
8153
8154func DecodeBsnTlvMacMask(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMacMask, error) {
8155 _bsntlvmacmask := &BsnTlvMacMask{BsnTlv: parent}
8156 if decoder.Length() < 6 {
8157 return nil, fmt.Errorf("BsnTlvMacMask packet too short: %d < 6", decoder.Length())
8158 }
8159 _bsntlvmacmask.Value = net.HardwareAddr(decoder.Read(6))
8160 return _bsntlvmacmask, nil
8161}
8162
8163func NewBsnTlvMacMask() *BsnTlvMacMask {
8164 obj := &BsnTlvMacMask{
8165 BsnTlv: NewBsnTlv(56),
8166 }
8167 return obj
8168}
8169
8170type BsnTlvMcgTypeVxlan struct {
8171 *BsnTlv
8172}
8173
8174type IBsnTlvMcgTypeVxlan interface {
8175 IBsnTlv
8176}
8177
8178func (self *BsnTlvMcgTypeVxlan) Serialize(encoder *goloxi.Encoder) error {
8179 startIndex := len(encoder.Bytes())
8180 if err := self.BsnTlv.Serialize(encoder); err != nil {
8181 return err
8182 }
8183 length := len(encoder.Bytes()) - startIndex
8184
8185 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8186
8187 return nil
8188}
8189
8190func DecodeBsnTlvMcgTypeVxlan(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMcgTypeVxlan, error) {
8191 _bsntlvmcgtypevxlan := &BsnTlvMcgTypeVxlan{BsnTlv: parent}
8192 return _bsntlvmcgtypevxlan, nil
8193}
8194
8195func NewBsnTlvMcgTypeVxlan() *BsnTlvMcgTypeVxlan {
8196 obj := &BsnTlvMcgTypeVxlan{
8197 BsnTlv: NewBsnTlv(87),
8198 }
8199 return obj
8200}
8201
8202type BsnTlvMissPackets struct {
8203 *BsnTlv
8204 Value uint64
8205}
8206
8207type IBsnTlvMissPackets interface {
8208 IBsnTlv
8209 GetValue() uint64
8210}
8211
8212func (self *BsnTlvMissPackets) GetValue() uint64 {
8213 return self.Value
8214}
8215
8216func (self *BsnTlvMissPackets) SetValue(v uint64) {
8217 self.Value = v
8218}
8219
8220func (self *BsnTlvMissPackets) Serialize(encoder *goloxi.Encoder) error {
8221 startIndex := len(encoder.Bytes())
8222 if err := self.BsnTlv.Serialize(encoder); err != nil {
8223 return err
8224 }
8225
8226 encoder.PutUint64(uint64(self.Value))
8227 length := len(encoder.Bytes()) - startIndex
8228
8229 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8230
8231 return nil
8232}
8233
8234func DecodeBsnTlvMissPackets(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMissPackets, error) {
8235 _bsntlvmisspackets := &BsnTlvMissPackets{BsnTlv: parent}
8236 if decoder.Length() < 8 {
8237 return nil, fmt.Errorf("BsnTlvMissPackets packet too short: %d < 8", decoder.Length())
8238 }
8239 _bsntlvmisspackets.Value = uint64(decoder.ReadUint64())
8240 return _bsntlvmisspackets, nil
8241}
8242
8243func NewBsnTlvMissPackets() *BsnTlvMissPackets {
8244 obj := &BsnTlvMissPackets{
8245 BsnTlv: NewBsnTlv(13),
8246 }
8247 return obj
8248}
8249
8250type BsnTlvMplsControlWord struct {
8251 *BsnTlv
8252 Value uint8
8253}
8254
8255type IBsnTlvMplsControlWord interface {
8256 IBsnTlv
8257 GetValue() uint8
8258}
8259
8260func (self *BsnTlvMplsControlWord) GetValue() uint8 {
8261 return self.Value
8262}
8263
8264func (self *BsnTlvMplsControlWord) SetValue(v uint8) {
8265 self.Value = v
8266}
8267
8268func (self *BsnTlvMplsControlWord) Serialize(encoder *goloxi.Encoder) error {
8269 startIndex := len(encoder.Bytes())
8270 if err := self.BsnTlv.Serialize(encoder); err != nil {
8271 return err
8272 }
8273
8274 encoder.PutUint8(uint8(self.Value))
8275 length := len(encoder.Bytes()) - startIndex
8276
8277 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8278
8279 return nil
8280}
8281
8282func DecodeBsnTlvMplsControlWord(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMplsControlWord, error) {
8283 _bsntlvmplscontrolword := &BsnTlvMplsControlWord{BsnTlv: parent}
8284 if decoder.Length() < 1 {
8285 return nil, fmt.Errorf("BsnTlvMplsControlWord packet too short: %d < 1", decoder.Length())
8286 }
8287 _bsntlvmplscontrolword.Value = uint8(decoder.ReadByte())
8288 return _bsntlvmplscontrolword, nil
8289}
8290
8291func NewBsnTlvMplsControlWord() *BsnTlvMplsControlWord {
8292 obj := &BsnTlvMplsControlWord{
8293 BsnTlv: NewBsnTlv(62),
8294 }
8295 return obj
8296}
8297
8298type BsnTlvMplsLabel struct {
8299 *BsnTlv
8300 Value uint32
8301}
8302
8303type IBsnTlvMplsLabel interface {
8304 IBsnTlv
8305 GetValue() uint32
8306}
8307
8308func (self *BsnTlvMplsLabel) GetValue() uint32 {
8309 return self.Value
8310}
8311
8312func (self *BsnTlvMplsLabel) SetValue(v uint32) {
8313 self.Value = v
8314}
8315
8316func (self *BsnTlvMplsLabel) Serialize(encoder *goloxi.Encoder) error {
8317 startIndex := len(encoder.Bytes())
8318 if err := self.BsnTlv.Serialize(encoder); err != nil {
8319 return err
8320 }
8321
8322 encoder.PutUint32(uint32(self.Value))
8323 length := len(encoder.Bytes()) - startIndex
8324
8325 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8326
8327 return nil
8328}
8329
8330func DecodeBsnTlvMplsLabel(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMplsLabel, error) {
8331 _bsntlvmplslabel := &BsnTlvMplsLabel{BsnTlv: parent}
8332 if decoder.Length() < 4 {
8333 return nil, fmt.Errorf("BsnTlvMplsLabel packet too short: %d < 4", decoder.Length())
8334 }
8335 _bsntlvmplslabel.Value = uint32(decoder.ReadUint32())
8336 return _bsntlvmplslabel, nil
8337}
8338
8339func NewBsnTlvMplsLabel() *BsnTlvMplsLabel {
8340 obj := &BsnTlvMplsLabel{
8341 BsnTlv: NewBsnTlv(61),
8342 }
8343 return obj
8344}
8345
8346type BsnTlvMplsSequenced struct {
8347 *BsnTlv
8348 Value uint8
8349}
8350
8351type IBsnTlvMplsSequenced interface {
8352 IBsnTlv
8353 GetValue() uint8
8354}
8355
8356func (self *BsnTlvMplsSequenced) GetValue() uint8 {
8357 return self.Value
8358}
8359
8360func (self *BsnTlvMplsSequenced) SetValue(v uint8) {
8361 self.Value = v
8362}
8363
8364func (self *BsnTlvMplsSequenced) Serialize(encoder *goloxi.Encoder) error {
8365 startIndex := len(encoder.Bytes())
8366 if err := self.BsnTlv.Serialize(encoder); err != nil {
8367 return err
8368 }
8369
8370 encoder.PutUint8(uint8(self.Value))
8371 length := len(encoder.Bytes()) - startIndex
8372
8373 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8374
8375 return nil
8376}
8377
8378func DecodeBsnTlvMplsSequenced(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMplsSequenced, error) {
8379 _bsntlvmplssequenced := &BsnTlvMplsSequenced{BsnTlv: parent}
8380 if decoder.Length() < 1 {
8381 return nil, fmt.Errorf("BsnTlvMplsSequenced packet too short: %d < 1", decoder.Length())
8382 }
8383 _bsntlvmplssequenced.Value = uint8(decoder.ReadByte())
8384 return _bsntlvmplssequenced, nil
8385}
8386
8387func NewBsnTlvMplsSequenced() *BsnTlvMplsSequenced {
8388 obj := &BsnTlvMplsSequenced{
8389 BsnTlv: NewBsnTlv(63),
8390 }
8391 return obj
8392}
8393
8394type BsnTlvMulticastInterfaceId struct {
8395 *BsnTlv
8396 Value uint32
8397}
8398
8399type IBsnTlvMulticastInterfaceId interface {
8400 IBsnTlv
8401 GetValue() uint32
8402}
8403
8404func (self *BsnTlvMulticastInterfaceId) GetValue() uint32 {
8405 return self.Value
8406}
8407
8408func (self *BsnTlvMulticastInterfaceId) SetValue(v uint32) {
8409 self.Value = v
8410}
8411
8412func (self *BsnTlvMulticastInterfaceId) Serialize(encoder *goloxi.Encoder) error {
8413 startIndex := len(encoder.Bytes())
8414 if err := self.BsnTlv.Serialize(encoder); err != nil {
8415 return err
8416 }
8417
8418 encoder.PutUint32(uint32(self.Value))
8419 length := len(encoder.Bytes()) - startIndex
8420
8421 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8422
8423 return nil
8424}
8425
8426func DecodeBsnTlvMulticastInterfaceId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMulticastInterfaceId, error) {
8427 _bsntlvmulticastinterfaceid := &BsnTlvMulticastInterfaceId{BsnTlv: parent}
8428 if decoder.Length() < 4 {
8429 return nil, fmt.Errorf("BsnTlvMulticastInterfaceId packet too short: %d < 4", decoder.Length())
8430 }
8431 _bsntlvmulticastinterfaceid.Value = uint32(decoder.ReadUint32())
8432 return _bsntlvmulticastinterfaceid, nil
8433}
8434
8435func NewBsnTlvMulticastInterfaceId() *BsnTlvMulticastInterfaceId {
8436 obj := &BsnTlvMulticastInterfaceId{
8437 BsnTlv: NewBsnTlv(95),
8438 }
8439 return obj
8440}
8441
8442type BsnTlvMulticastPacket struct {
8443 *BsnTlv
8444 Value BsnMulticastPacket
8445}
8446
8447type IBsnTlvMulticastPacket interface {
8448 IBsnTlv
8449 GetValue() BsnMulticastPacket
8450}
8451
8452func (self *BsnTlvMulticastPacket) GetValue() BsnMulticastPacket {
8453 return self.Value
8454}
8455
8456func (self *BsnTlvMulticastPacket) SetValue(v BsnMulticastPacket) {
8457 self.Value = v
8458}
8459
8460func (self *BsnTlvMulticastPacket) Serialize(encoder *goloxi.Encoder) error {
8461 startIndex := len(encoder.Bytes())
8462 if err := self.BsnTlv.Serialize(encoder); err != nil {
8463 return err
8464 }
8465
8466 encoder.PutUint16(uint16(self.Value))
8467 length := len(encoder.Bytes()) - startIndex
8468
8469 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8470
8471 return nil
8472}
8473
8474func DecodeBsnTlvMulticastPacket(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMulticastPacket, error) {
8475 _bsntlvmulticastpacket := &BsnTlvMulticastPacket{BsnTlv: parent}
8476 if decoder.Length() < 2 {
8477 return nil, fmt.Errorf("BsnTlvMulticastPacket packet too short: %d < 2", decoder.Length())
8478 }
8479 _bsntlvmulticastpacket.Value = BsnMulticastPacket(decoder.ReadUint16())
8480 return _bsntlvmulticastpacket, nil
8481}
8482
8483func NewBsnTlvMulticastPacket() *BsnTlvMulticastPacket {
8484 obj := &BsnTlvMulticastPacket{
8485 BsnTlv: NewBsnTlv(170),
8486 }
8487 return obj
8488}
8489
8490type BsnTlvMultiplier struct {
8491 *BsnTlv
8492 Value uint32
8493}
8494
8495type IBsnTlvMultiplier interface {
8496 IBsnTlv
8497 GetValue() uint32
8498}
8499
8500func (self *BsnTlvMultiplier) GetValue() uint32 {
8501 return self.Value
8502}
8503
8504func (self *BsnTlvMultiplier) SetValue(v uint32) {
8505 self.Value = v
8506}
8507
8508func (self *BsnTlvMultiplier) Serialize(encoder *goloxi.Encoder) error {
8509 startIndex := len(encoder.Bytes())
8510 if err := self.BsnTlv.Serialize(encoder); err != nil {
8511 return err
8512 }
8513
8514 encoder.PutUint32(uint32(self.Value))
8515 length := len(encoder.Bytes()) - startIndex
8516
8517 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8518
8519 return nil
8520}
8521
8522func DecodeBsnTlvMultiplier(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMultiplier, error) {
8523 _bsntlvmultiplier := &BsnTlvMultiplier{BsnTlv: parent}
8524 if decoder.Length() < 4 {
8525 return nil, fmt.Errorf("BsnTlvMultiplier packet too short: %d < 4", decoder.Length())
8526 }
8527 _bsntlvmultiplier.Value = uint32(decoder.ReadUint32())
8528 return _bsntlvmultiplier, nil
8529}
8530
8531func NewBsnTlvMultiplier() *BsnTlvMultiplier {
8532 obj := &BsnTlvMultiplier{
8533 BsnTlv: NewBsnTlv(174),
8534 }
8535 return obj
8536}
8537
8538type BsnTlvName struct {
8539 *BsnTlv
8540 Value []byte
8541}
8542
8543type IBsnTlvName interface {
8544 IBsnTlv
8545 GetValue() []byte
8546}
8547
8548func (self *BsnTlvName) GetValue() []byte {
8549 return self.Value
8550}
8551
8552func (self *BsnTlvName) SetValue(v []byte) {
8553 self.Value = v
8554}
8555
8556func (self *BsnTlvName) Serialize(encoder *goloxi.Encoder) error {
8557 startIndex := len(encoder.Bytes())
8558 if err := self.BsnTlv.Serialize(encoder); err != nil {
8559 return err
8560 }
8561
8562 encoder.Write(self.Value)
8563 length := len(encoder.Bytes()) - startIndex
8564
8565 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8566
8567 return nil
8568}
8569
8570func DecodeBsnTlvName(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvName, error) {
8571 _bsntlvname := &BsnTlvName{BsnTlv: parent}
8572 _bsntlvname.Value = decoder.Read(int(decoder.Length()))
8573 return _bsntlvname, nil
8574}
8575
8576func NewBsnTlvName() *BsnTlvName {
8577 obj := &BsnTlvName{
8578 BsnTlv: NewBsnTlv(52),
8579 }
8580 return obj
8581}
8582
8583type BsnTlvNdpOffload struct {
8584 *BsnTlv
8585}
8586
8587type IBsnTlvNdpOffload interface {
8588 IBsnTlv
8589}
8590
8591func (self *BsnTlvNdpOffload) Serialize(encoder *goloxi.Encoder) error {
8592 startIndex := len(encoder.Bytes())
8593 if err := self.BsnTlv.Serialize(encoder); err != nil {
8594 return err
8595 }
8596 length := len(encoder.Bytes()) - startIndex
8597
8598 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8599
8600 return nil
8601}
8602
8603func DecodeBsnTlvNdpOffload(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNdpOffload, error) {
8604 _bsntlvndpoffload := &BsnTlvNdpOffload{BsnTlv: parent}
8605 return _bsntlvndpoffload, nil
8606}
8607
8608func NewBsnTlvNdpOffload() *BsnTlvNdpOffload {
8609 obj := &BsnTlvNdpOffload{
8610 BsnTlv: NewBsnTlv(123),
8611 }
8612 return obj
8613}
8614
8615type BsnTlvNdpStatic struct {
8616 *BsnTlv
8617}
8618
8619type IBsnTlvNdpStatic interface {
8620 IBsnTlv
8621}
8622
8623func (self *BsnTlvNdpStatic) Serialize(encoder *goloxi.Encoder) error {
8624 startIndex := len(encoder.Bytes())
8625 if err := self.BsnTlv.Serialize(encoder); err != nil {
8626 return err
8627 }
8628 length := len(encoder.Bytes()) - startIndex
8629
8630 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8631
8632 return nil
8633}
8634
8635func DecodeBsnTlvNdpStatic(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNdpStatic, error) {
8636 _bsntlvndpstatic := &BsnTlvNdpStatic{BsnTlv: parent}
8637 return _bsntlvndpstatic, nil
8638}
8639
8640func NewBsnTlvNdpStatic() *BsnTlvNdpStatic {
8641 obj := &BsnTlvNdpStatic{
8642 BsnTlv: NewBsnTlv(124),
8643 }
8644 return obj
8645}
8646
8647type BsnTlvNegate struct {
8648 *BsnTlv
8649}
8650
8651type IBsnTlvNegate interface {
8652 IBsnTlv
8653}
8654
8655func (self *BsnTlvNegate) Serialize(encoder *goloxi.Encoder) error {
8656 startIndex := len(encoder.Bytes())
8657 if err := self.BsnTlv.Serialize(encoder); err != nil {
8658 return err
8659 }
8660 length := len(encoder.Bytes()) - startIndex
8661
8662 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8663
8664 return nil
8665}
8666
8667func DecodeBsnTlvNegate(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNegate, error) {
8668 _bsntlvnegate := &BsnTlvNegate{BsnTlv: parent}
8669 return _bsntlvnegate, nil
8670}
8671
8672func NewBsnTlvNegate() *BsnTlvNegate {
8673 obj := &BsnTlvNegate{
8674 BsnTlv: NewBsnTlv(83),
8675 }
8676 return obj
8677}
8678
8679type BsnTlvNextHopIpv4 struct {
8680 *BsnTlv
8681 Value net.IP
8682}
8683
8684type IBsnTlvNextHopIpv4 interface {
8685 IBsnTlv
8686 GetValue() net.IP
8687}
8688
8689func (self *BsnTlvNextHopIpv4) GetValue() net.IP {
8690 return self.Value
8691}
8692
8693func (self *BsnTlvNextHopIpv4) SetValue(v net.IP) {
8694 self.Value = v
8695}
8696
8697func (self *BsnTlvNextHopIpv4) Serialize(encoder *goloxi.Encoder) error {
8698 startIndex := len(encoder.Bytes())
8699 if err := self.BsnTlv.Serialize(encoder); err != nil {
8700 return err
8701 }
8702
8703 encoder.Write(self.Value.To4())
8704 length := len(encoder.Bytes()) - startIndex
8705
8706 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8707
8708 return nil
8709}
8710
8711func DecodeBsnTlvNextHopIpv4(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNextHopIpv4, error) {
8712 _bsntlvnexthopipv4 := &BsnTlvNextHopIpv4{BsnTlv: parent}
8713 if decoder.Length() < 4 {
8714 return nil, fmt.Errorf("BsnTlvNextHopIpv4 packet too short: %d < 4", decoder.Length())
8715 }
8716 _bsntlvnexthopipv4.Value = net.IP(decoder.Read(4))
8717 return _bsntlvnexthopipv4, nil
8718}
8719
8720func NewBsnTlvNextHopIpv4() *BsnTlvNextHopIpv4 {
8721 obj := &BsnTlvNextHopIpv4{
8722 BsnTlv: NewBsnTlv(115),
8723 }
8724 return obj
8725}
8726
8727type BsnTlvNextHopMac struct {
8728 *BsnTlv
8729 Value net.HardwareAddr
8730}
8731
8732type IBsnTlvNextHopMac interface {
8733 IBsnTlv
8734 GetValue() net.HardwareAddr
8735}
8736
8737func (self *BsnTlvNextHopMac) GetValue() net.HardwareAddr {
8738 return self.Value
8739}
8740
8741func (self *BsnTlvNextHopMac) SetValue(v net.HardwareAddr) {
8742 self.Value = v
8743}
8744
8745func (self *BsnTlvNextHopMac) Serialize(encoder *goloxi.Encoder) error {
8746 startIndex := len(encoder.Bytes())
8747 if err := self.BsnTlv.Serialize(encoder); err != nil {
8748 return err
8749 }
8750
8751 encoder.Write(self.Value)
8752 length := len(encoder.Bytes()) - startIndex
8753
8754 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8755
8756 return nil
8757}
8758
8759func DecodeBsnTlvNextHopMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNextHopMac, error) {
8760 _bsntlvnexthopmac := &BsnTlvNextHopMac{BsnTlv: parent}
8761 if decoder.Length() < 6 {
8762 return nil, fmt.Errorf("BsnTlvNextHopMac packet too short: %d < 6", decoder.Length())
8763 }
8764 _bsntlvnexthopmac.Value = net.HardwareAddr(decoder.Read(6))
8765 return _bsntlvnexthopmac, nil
8766}
8767
8768func NewBsnTlvNextHopMac() *BsnTlvNextHopMac {
8769 obj := &BsnTlvNextHopMac{
8770 BsnTlv: NewBsnTlv(114),
8771 }
8772 return obj
8773}
8774
8775type BsnTlvNexthopTypeVxlan struct {
8776 *BsnTlv
8777}
8778
8779type IBsnTlvNexthopTypeVxlan interface {
8780 IBsnTlv
8781}
8782
8783func (self *BsnTlvNexthopTypeVxlan) Serialize(encoder *goloxi.Encoder) error {
8784 startIndex := len(encoder.Bytes())
8785 if err := self.BsnTlv.Serialize(encoder); err != nil {
8786 return err
8787 }
8788 length := len(encoder.Bytes()) - startIndex
8789
8790 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8791
8792 return nil
8793}
8794
8795func DecodeBsnTlvNexthopTypeVxlan(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNexthopTypeVxlan, error) {
8796 _bsntlvnexthoptypevxlan := &BsnTlvNexthopTypeVxlan{BsnTlv: parent}
8797 return _bsntlvnexthoptypevxlan, nil
8798}
8799
8800func NewBsnTlvNexthopTypeVxlan() *BsnTlvNexthopTypeVxlan {
8801 obj := &BsnTlvNexthopTypeVxlan{
8802 BsnTlv: NewBsnTlv(94),
8803 }
8804 return obj
8805}
8806
8807type BsnTlvNoArpResponse struct {
8808 *BsnTlv
8809}
8810
8811type IBsnTlvNoArpResponse interface {
8812 IBsnTlv
8813}
8814
8815func (self *BsnTlvNoArpResponse) Serialize(encoder *goloxi.Encoder) error {
8816 startIndex := len(encoder.Bytes())
8817 if err := self.BsnTlv.Serialize(encoder); err != nil {
8818 return err
8819 }
8820 length := len(encoder.Bytes()) - startIndex
8821
8822 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8823
8824 return nil
8825}
8826
8827func DecodeBsnTlvNoArpResponse(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNoArpResponse, error) {
8828 _bsntlvnoarpresponse := &BsnTlvNoArpResponse{BsnTlv: parent}
8829 return _bsntlvnoarpresponse, nil
8830}
8831
8832func NewBsnTlvNoArpResponse() *BsnTlvNoArpResponse {
8833 obj := &BsnTlvNoArpResponse{
8834 BsnTlv: NewBsnTlv(147),
8835 }
8836 return obj
8837}
8838
8839type BsnTlvNoNsResponse struct {
8840 *BsnTlv
8841}
8842
8843type IBsnTlvNoNsResponse interface {
8844 IBsnTlv
8845}
8846
8847func (self *BsnTlvNoNsResponse) Serialize(encoder *goloxi.Encoder) error {
8848 startIndex := len(encoder.Bytes())
8849 if err := self.BsnTlv.Serialize(encoder); err != nil {
8850 return err
8851 }
8852 length := len(encoder.Bytes()) - startIndex
8853
8854 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8855
8856 return nil
8857}
8858
8859func DecodeBsnTlvNoNsResponse(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNoNsResponse, error) {
8860 _bsntlvnonsresponse := &BsnTlvNoNsResponse{BsnTlv: parent}
8861 return _bsntlvnonsresponse, nil
8862}
8863
8864func NewBsnTlvNoNsResponse() *BsnTlvNoNsResponse {
8865 obj := &BsnTlvNoNsResponse{
8866 BsnTlv: NewBsnTlv(148),
8867 }
8868 return obj
8869}
8870
8871type BsnTlvOffset struct {
8872 *BsnTlv
8873 Value uint16
8874}
8875
8876type IBsnTlvOffset interface {
8877 IBsnTlv
8878 GetValue() uint16
8879}
8880
8881func (self *BsnTlvOffset) GetValue() uint16 {
8882 return self.Value
8883}
8884
8885func (self *BsnTlvOffset) SetValue(v uint16) {
8886 self.Value = v
8887}
8888
8889func (self *BsnTlvOffset) Serialize(encoder *goloxi.Encoder) error {
8890 startIndex := len(encoder.Bytes())
8891 if err := self.BsnTlv.Serialize(encoder); err != nil {
8892 return err
8893 }
8894
8895 encoder.PutUint16(uint16(self.Value))
8896 length := len(encoder.Bytes()) - startIndex
8897
8898 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8899
8900 return nil
8901}
8902
8903func DecodeBsnTlvOffset(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvOffset, error) {
8904 _bsntlvoffset := &BsnTlvOffset{BsnTlv: parent}
8905 if decoder.Length() < 2 {
8906 return nil, fmt.Errorf("BsnTlvOffset packet too short: %d < 2", decoder.Length())
8907 }
8908 _bsntlvoffset.Value = uint16(decoder.ReadUint16())
8909 return _bsntlvoffset, nil
8910}
8911
8912func NewBsnTlvOffset() *BsnTlvOffset {
8913 obj := &BsnTlvOffset{
8914 BsnTlv: NewBsnTlv(82),
8915 }
8916 return obj
8917}
8918
8919type BsnTlvOpticsAlwaysEnabled struct {
8920 *BsnTlv
8921}
8922
8923type IBsnTlvOpticsAlwaysEnabled interface {
8924 IBsnTlv
8925}
8926
8927func (self *BsnTlvOpticsAlwaysEnabled) Serialize(encoder *goloxi.Encoder) error {
8928 startIndex := len(encoder.Bytes())
8929 if err := self.BsnTlv.Serialize(encoder); err != nil {
8930 return err
8931 }
8932 length := len(encoder.Bytes()) - startIndex
8933
8934 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8935
8936 return nil
8937}
8938
8939func DecodeBsnTlvOpticsAlwaysEnabled(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvOpticsAlwaysEnabled, error) {
8940 _bsntlvopticsalwaysenabled := &BsnTlvOpticsAlwaysEnabled{BsnTlv: parent}
8941 return _bsntlvopticsalwaysenabled, nil
8942}
8943
8944func NewBsnTlvOpticsAlwaysEnabled() *BsnTlvOpticsAlwaysEnabled {
8945 obj := &BsnTlvOpticsAlwaysEnabled{
8946 BsnTlv: NewBsnTlv(150),
8947 }
8948 return obj
8949}
8950
8951type BsnTlvOuterSrcMac struct {
8952 *BsnTlv
8953 Value net.HardwareAddr
8954}
8955
8956type IBsnTlvOuterSrcMac interface {
8957 IBsnTlv
8958 GetValue() net.HardwareAddr
8959}
8960
8961func (self *BsnTlvOuterSrcMac) GetValue() net.HardwareAddr {
8962 return self.Value
8963}
8964
8965func (self *BsnTlvOuterSrcMac) SetValue(v net.HardwareAddr) {
8966 self.Value = v
8967}
8968
8969func (self *BsnTlvOuterSrcMac) Serialize(encoder *goloxi.Encoder) error {
8970 startIndex := len(encoder.Bytes())
8971 if err := self.BsnTlv.Serialize(encoder); err != nil {
8972 return err
8973 }
8974
8975 encoder.Write(self.Value)
8976 length := len(encoder.Bytes()) - startIndex
8977
8978 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8979
8980 return nil
8981}
8982
8983func DecodeBsnTlvOuterSrcMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvOuterSrcMac, error) {
8984 _bsntlvoutersrcmac := &BsnTlvOuterSrcMac{BsnTlv: parent}
8985 if decoder.Length() < 6 {
8986 return nil, fmt.Errorf("BsnTlvOuterSrcMac packet too short: %d < 6", decoder.Length())
8987 }
8988 _bsntlvoutersrcmac.Value = net.HardwareAddr(decoder.Read(6))
8989 return _bsntlvoutersrcmac, nil
8990}
8991
8992func NewBsnTlvOuterSrcMac() *BsnTlvOuterSrcMac {
8993 obj := &BsnTlvOuterSrcMac{
8994 BsnTlv: NewBsnTlv(157),
8995 }
8996 return obj
8997}
8998
8999type BsnTlvParentPort struct {
9000 *BsnTlv
9001 Value Port
9002}
9003
9004type IBsnTlvParentPort interface {
9005 IBsnTlv
9006 GetValue() Port
9007}
9008
9009func (self *BsnTlvParentPort) GetValue() Port {
9010 return self.Value
9011}
9012
9013func (self *BsnTlvParentPort) SetValue(v Port) {
9014 self.Value = v
9015}
9016
9017func (self *BsnTlvParentPort) Serialize(encoder *goloxi.Encoder) error {
9018 startIndex := len(encoder.Bytes())
9019 if err := self.BsnTlv.Serialize(encoder); err != nil {
9020 return err
9021 }
9022
9023 self.Value.Serialize(encoder)
9024 length := len(encoder.Bytes()) - startIndex
9025
9026 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9027
9028 return nil
9029}
9030
9031func DecodeBsnTlvParentPort(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvParentPort, error) {
9032 _bsntlvparentport := &BsnTlvParentPort{BsnTlv: parent}
9033 if decoder.Length() < 4 {
9034 return nil, fmt.Errorf("BsnTlvParentPort packet too short: %d < 4", decoder.Length())
9035 }
9036 _bsntlvparentport.Value.Decode(decoder)
9037 return _bsntlvparentport, nil
9038}
9039
9040func NewBsnTlvParentPort() *BsnTlvParentPort {
9041 obj := &BsnTlvParentPort{
9042 BsnTlv: NewBsnTlv(109),
9043 }
9044 return obj
9045}
9046
9047type BsnTlvPartnerKey struct {
9048 *BsnTlv
9049 Value uint16
9050}
9051
9052type IBsnTlvPartnerKey interface {
9053 IBsnTlv
9054 GetValue() uint16
9055}
9056
9057func (self *BsnTlvPartnerKey) GetValue() uint16 {
9058 return self.Value
9059}
9060
9061func (self *BsnTlvPartnerKey) SetValue(v uint16) {
9062 self.Value = v
9063}
9064
9065func (self *BsnTlvPartnerKey) Serialize(encoder *goloxi.Encoder) error {
9066 startIndex := len(encoder.Bytes())
9067 if err := self.BsnTlv.Serialize(encoder); err != nil {
9068 return err
9069 }
9070
9071 encoder.PutUint16(uint16(self.Value))
9072 length := len(encoder.Bytes()) - startIndex
9073
9074 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9075
9076 return nil
9077}
9078
9079func DecodeBsnTlvPartnerKey(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPartnerKey, error) {
9080 _bsntlvpartnerkey := &BsnTlvPartnerKey{BsnTlv: parent}
9081 if decoder.Length() < 2 {
9082 return nil, fmt.Errorf("BsnTlvPartnerKey packet too short: %d < 2", decoder.Length())
9083 }
9084 _bsntlvpartnerkey.Value = uint16(decoder.ReadUint16())
9085 return _bsntlvpartnerkey, nil
9086}
9087
9088func NewBsnTlvPartnerKey() *BsnTlvPartnerKey {
9089 obj := &BsnTlvPartnerKey{
9090 BsnTlv: NewBsnTlv(51),
9091 }
9092 return obj
9093}
9094
9095type BsnTlvPartnerPortNum struct {
9096 *BsnTlv
9097 Value uint16
9098}
9099
9100type IBsnTlvPartnerPortNum interface {
9101 IBsnTlv
9102 GetValue() uint16
9103}
9104
9105func (self *BsnTlvPartnerPortNum) GetValue() uint16 {
9106 return self.Value
9107}
9108
9109func (self *BsnTlvPartnerPortNum) SetValue(v uint16) {
9110 self.Value = v
9111}
9112
9113func (self *BsnTlvPartnerPortNum) Serialize(encoder *goloxi.Encoder) error {
9114 startIndex := len(encoder.Bytes())
9115 if err := self.BsnTlv.Serialize(encoder); err != nil {
9116 return err
9117 }
9118
9119 encoder.PutUint16(uint16(self.Value))
9120 length := len(encoder.Bytes()) - startIndex
9121
9122 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9123
9124 return nil
9125}
9126
9127func DecodeBsnTlvPartnerPortNum(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPartnerPortNum, error) {
9128 _bsntlvpartnerportnum := &BsnTlvPartnerPortNum{BsnTlv: parent}
9129 if decoder.Length() < 2 {
9130 return nil, fmt.Errorf("BsnTlvPartnerPortNum packet too short: %d < 2", decoder.Length())
9131 }
9132 _bsntlvpartnerportnum.Value = uint16(decoder.ReadUint16())
9133 return _bsntlvpartnerportnum, nil
9134}
9135
9136func NewBsnTlvPartnerPortNum() *BsnTlvPartnerPortNum {
9137 obj := &BsnTlvPartnerPortNum{
9138 BsnTlv: NewBsnTlv(50),
9139 }
9140 return obj
9141}
9142
9143type BsnTlvPartnerPortPriority struct {
9144 *BsnTlv
9145 Value uint16
9146}
9147
9148type IBsnTlvPartnerPortPriority interface {
9149 IBsnTlv
9150 GetValue() uint16
9151}
9152
9153func (self *BsnTlvPartnerPortPriority) GetValue() uint16 {
9154 return self.Value
9155}
9156
9157func (self *BsnTlvPartnerPortPriority) SetValue(v uint16) {
9158 self.Value = v
9159}
9160
9161func (self *BsnTlvPartnerPortPriority) Serialize(encoder *goloxi.Encoder) error {
9162 startIndex := len(encoder.Bytes())
9163 if err := self.BsnTlv.Serialize(encoder); err != nil {
9164 return err
9165 }
9166
9167 encoder.PutUint16(uint16(self.Value))
9168 length := len(encoder.Bytes()) - startIndex
9169
9170 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9171
9172 return nil
9173}
9174
9175func DecodeBsnTlvPartnerPortPriority(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPartnerPortPriority, error) {
9176 _bsntlvpartnerportpriority := &BsnTlvPartnerPortPriority{BsnTlv: parent}
9177 if decoder.Length() < 2 {
9178 return nil, fmt.Errorf("BsnTlvPartnerPortPriority packet too short: %d < 2", decoder.Length())
9179 }
9180 _bsntlvpartnerportpriority.Value = uint16(decoder.ReadUint16())
9181 return _bsntlvpartnerportpriority, nil
9182}
9183
9184func NewBsnTlvPartnerPortPriority() *BsnTlvPartnerPortPriority {
9185 obj := &BsnTlvPartnerPortPriority{
9186 BsnTlv: NewBsnTlv(49),
9187 }
9188 return obj
9189}
9190
9191type BsnTlvPartnerState struct {
9192 *BsnTlv
9193 Value BsnLacpState
9194}
9195
9196type IBsnTlvPartnerState interface {
9197 IBsnTlv
9198 GetValue() BsnLacpState
9199}
9200
9201func (self *BsnTlvPartnerState) GetValue() BsnLacpState {
9202 return self.Value
9203}
9204
9205func (self *BsnTlvPartnerState) SetValue(v BsnLacpState) {
9206 self.Value = v
9207}
9208
9209func (self *BsnTlvPartnerState) Serialize(encoder *goloxi.Encoder) error {
9210 startIndex := len(encoder.Bytes())
9211 if err := self.BsnTlv.Serialize(encoder); err != nil {
9212 return err
9213 }
9214
9215 encoder.PutUint8(uint8(self.Value))
9216 length := len(encoder.Bytes()) - startIndex
9217
9218 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9219
9220 return nil
9221}
9222
9223func DecodeBsnTlvPartnerState(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPartnerState, error) {
9224 _bsntlvpartnerstate := &BsnTlvPartnerState{BsnTlv: parent}
9225 if decoder.Length() < 1 {
9226 return nil, fmt.Errorf("BsnTlvPartnerState packet too short: %d < 1", decoder.Length())
9227 }
9228 _bsntlvpartnerstate.Value = BsnLacpState(decoder.ReadByte())
9229 return _bsntlvpartnerstate, nil
9230}
9231
9232func NewBsnTlvPartnerState() *BsnTlvPartnerState {
9233 obj := &BsnTlvPartnerState{
9234 BsnTlv: NewBsnTlv(54),
9235 }
9236 return obj
9237}
9238
9239type BsnTlvPartnerSystemMac struct {
9240 *BsnTlv
9241 Value net.HardwareAddr
9242}
9243
9244type IBsnTlvPartnerSystemMac interface {
9245 IBsnTlv
9246 GetValue() net.HardwareAddr
9247}
9248
9249func (self *BsnTlvPartnerSystemMac) GetValue() net.HardwareAddr {
9250 return self.Value
9251}
9252
9253func (self *BsnTlvPartnerSystemMac) SetValue(v net.HardwareAddr) {
9254 self.Value = v
9255}
9256
9257func (self *BsnTlvPartnerSystemMac) Serialize(encoder *goloxi.Encoder) error {
9258 startIndex := len(encoder.Bytes())
9259 if err := self.BsnTlv.Serialize(encoder); err != nil {
9260 return err
9261 }
9262
9263 encoder.Write(self.Value)
9264 length := len(encoder.Bytes()) - startIndex
9265
9266 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9267
9268 return nil
9269}
9270
9271func DecodeBsnTlvPartnerSystemMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPartnerSystemMac, error) {
9272 _bsntlvpartnersystemmac := &BsnTlvPartnerSystemMac{BsnTlv: parent}
9273 if decoder.Length() < 6 {
9274 return nil, fmt.Errorf("BsnTlvPartnerSystemMac packet too short: %d < 6", decoder.Length())
9275 }
9276 _bsntlvpartnersystemmac.Value = net.HardwareAddr(decoder.Read(6))
9277 return _bsntlvpartnersystemmac, nil
9278}
9279
9280func NewBsnTlvPartnerSystemMac() *BsnTlvPartnerSystemMac {
9281 obj := &BsnTlvPartnerSystemMac{
9282 BsnTlv: NewBsnTlv(48),
9283 }
9284 return obj
9285}
9286
9287type BsnTlvPartnerSystemPriority struct {
9288 *BsnTlv
9289 Value uint16
9290}
9291
9292type IBsnTlvPartnerSystemPriority interface {
9293 IBsnTlv
9294 GetValue() uint16
9295}
9296
9297func (self *BsnTlvPartnerSystemPriority) GetValue() uint16 {
9298 return self.Value
9299}
9300
9301func (self *BsnTlvPartnerSystemPriority) SetValue(v uint16) {
9302 self.Value = v
9303}
9304
9305func (self *BsnTlvPartnerSystemPriority) Serialize(encoder *goloxi.Encoder) error {
9306 startIndex := len(encoder.Bytes())
9307 if err := self.BsnTlv.Serialize(encoder); err != nil {
9308 return err
9309 }
9310
9311 encoder.PutUint16(uint16(self.Value))
9312 length := len(encoder.Bytes()) - startIndex
9313
9314 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9315
9316 return nil
9317}
9318
9319func DecodeBsnTlvPartnerSystemPriority(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPartnerSystemPriority, error) {
9320 _bsntlvpartnersystempriority := &BsnTlvPartnerSystemPriority{BsnTlv: parent}
9321 if decoder.Length() < 2 {
9322 return nil, fmt.Errorf("BsnTlvPartnerSystemPriority packet too short: %d < 2", decoder.Length())
9323 }
9324 _bsntlvpartnersystempriority.Value = uint16(decoder.ReadUint16())
9325 return _bsntlvpartnersystempriority, nil
9326}
9327
9328func NewBsnTlvPartnerSystemPriority() *BsnTlvPartnerSystemPriority {
9329 obj := &BsnTlvPartnerSystemPriority{
9330 BsnTlv: NewBsnTlv(47),
9331 }
9332 return obj
9333}
9334
9335type BsnTlvPassive struct {
9336 *BsnTlv
9337}
9338
9339type IBsnTlvPassive interface {
9340 IBsnTlv
9341}
9342
9343func (self *BsnTlvPassive) Serialize(encoder *goloxi.Encoder) error {
9344 startIndex := len(encoder.Bytes())
9345 if err := self.BsnTlv.Serialize(encoder); err != nil {
9346 return err
9347 }
9348 length := len(encoder.Bytes()) - startIndex
9349
9350 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9351
9352 return nil
9353}
9354
9355func DecodeBsnTlvPassive(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPassive, error) {
9356 _bsntlvpassive := &BsnTlvPassive{BsnTlv: parent}
9357 return _bsntlvpassive, nil
9358}
9359
9360func NewBsnTlvPassive() *BsnTlvPassive {
9361 obj := &BsnTlvPassive{
9362 BsnTlv: NewBsnTlv(172),
9363 }
9364 return obj
9365}
9366
9367type BsnTlvPduaRxInstance struct {
9368 *BsnTlv
9369 Value []byte
9370}
9371
9372type IBsnTlvPduaRxInstance interface {
9373 IBsnTlv
9374 GetValue() []byte
9375}
9376
9377func (self *BsnTlvPduaRxInstance) GetValue() []byte {
9378 return self.Value
9379}
9380
9381func (self *BsnTlvPduaRxInstance) SetValue(v []byte) {
9382 self.Value = v
9383}
9384
9385func (self *BsnTlvPduaRxInstance) Serialize(encoder *goloxi.Encoder) error {
9386 startIndex := len(encoder.Bytes())
9387 if err := self.BsnTlv.Serialize(encoder); err != nil {
9388 return err
9389 }
9390
9391 encoder.Write(self.Value)
9392 length := len(encoder.Bytes()) - startIndex
9393
9394 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9395
9396 return nil
9397}
9398
9399func DecodeBsnTlvPduaRxInstance(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPduaRxInstance, error) {
9400 _bsntlvpduarxinstance := &BsnTlvPduaRxInstance{BsnTlv: parent}
9401 _bsntlvpduarxinstance.Value = decoder.Read(int(decoder.Length()))
9402 return _bsntlvpduarxinstance, nil
9403}
9404
9405func NewBsnTlvPduaRxInstance() *BsnTlvPduaRxInstance {
9406 obj := &BsnTlvPduaRxInstance{
9407 BsnTlv: NewBsnTlv(159),
9408 }
9409 return obj
9410}
9411
9412type BsnTlvPimDr struct {
9413 *BsnTlv
9414}
9415
9416type IBsnTlvPimDr interface {
9417 IBsnTlv
9418}
9419
9420func (self *BsnTlvPimDr) Serialize(encoder *goloxi.Encoder) error {
9421 startIndex := len(encoder.Bytes())
9422 if err := self.BsnTlv.Serialize(encoder); err != nil {
9423 return err
9424 }
9425 length := len(encoder.Bytes()) - startIndex
9426
9427 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9428
9429 return nil
9430}
9431
9432func DecodeBsnTlvPimDr(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPimDr, error) {
9433 _bsntlvpimdr := &BsnTlvPimDr{BsnTlv: parent}
9434 return _bsntlvpimdr, nil
9435}
9436
9437func NewBsnTlvPimDr() *BsnTlvPimDr {
9438 obj := &BsnTlvPimDr{
9439 BsnTlv: NewBsnTlv(171),
9440 }
9441 return obj
9442}
9443
9444type BsnTlvPimHelloFlood struct {
9445 *BsnTlv
9446}
9447
9448type IBsnTlvPimHelloFlood interface {
9449 IBsnTlv
9450}
9451
9452func (self *BsnTlvPimHelloFlood) Serialize(encoder *goloxi.Encoder) error {
9453 startIndex := len(encoder.Bytes())
9454 if err := self.BsnTlv.Serialize(encoder); err != nil {
9455 return err
9456 }
9457 length := len(encoder.Bytes()) - startIndex
9458
9459 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9460
9461 return nil
9462}
9463
9464func DecodeBsnTlvPimHelloFlood(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPimHelloFlood, error) {
9465 _bsntlvpimhelloflood := &BsnTlvPimHelloFlood{BsnTlv: parent}
9466 return _bsntlvpimhelloflood, nil
9467}
9468
9469func NewBsnTlvPimHelloFlood() *BsnTlvPimHelloFlood {
9470 obj := &BsnTlvPimHelloFlood{
9471 BsnTlv: NewBsnTlv(181),
9472 }
9473 return obj
9474}
9475
9476type BsnTlvPort struct {
9477 *BsnTlv
9478 Value Port
9479}
9480
9481type IBsnTlvPort interface {
9482 IBsnTlv
9483 GetValue() Port
9484}
9485
9486func (self *BsnTlvPort) GetValue() Port {
9487 return self.Value
9488}
9489
9490func (self *BsnTlvPort) SetValue(v Port) {
9491 self.Value = v
9492}
9493
9494func (self *BsnTlvPort) Serialize(encoder *goloxi.Encoder) error {
9495 startIndex := len(encoder.Bytes())
9496 if err := self.BsnTlv.Serialize(encoder); err != nil {
9497 return err
9498 }
9499
9500 self.Value.Serialize(encoder)
9501 length := len(encoder.Bytes()) - startIndex
9502
9503 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9504
9505 return nil
9506}
9507
9508func DecodeBsnTlvPort(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPort, error) {
9509 _bsntlvport := &BsnTlvPort{BsnTlv: parent}
9510 if decoder.Length() < 4 {
9511 return nil, fmt.Errorf("BsnTlvPort packet too short: %d < 4", decoder.Length())
9512 }
9513 _bsntlvport.Value.Decode(decoder)
9514 return _bsntlvport, nil
9515}
9516
9517func NewBsnTlvPort() *BsnTlvPort {
9518 obj := &BsnTlvPort{
9519 BsnTlv: NewBsnTlv(0),
9520 }
9521 return obj
9522}
9523
9524type BsnTlvPortMode struct {
9525 *BsnTlv
9526 Value BsnPortMode
9527}
9528
9529type IBsnTlvPortMode interface {
9530 IBsnTlv
9531 GetValue() BsnPortMode
9532}
9533
9534func (self *BsnTlvPortMode) GetValue() BsnPortMode {
9535 return self.Value
9536}
9537
9538func (self *BsnTlvPortMode) SetValue(v BsnPortMode) {
9539 self.Value = v
9540}
9541
9542func (self *BsnTlvPortMode) Serialize(encoder *goloxi.Encoder) error {
9543 startIndex := len(encoder.Bytes())
9544 if err := self.BsnTlv.Serialize(encoder); err != nil {
9545 return err
9546 }
9547
9548 encoder.PutUint16(uint16(self.Value))
9549 length := len(encoder.Bytes()) - startIndex
9550
9551 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9552
9553 return nil
9554}
9555
9556func DecodeBsnTlvPortMode(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPortMode, error) {
9557 _bsntlvportmode := &BsnTlvPortMode{BsnTlv: parent}
9558 if decoder.Length() < 2 {
9559 return nil, fmt.Errorf("BsnTlvPortMode packet too short: %d < 2", decoder.Length())
9560 }
9561 _bsntlvportmode.Value = BsnPortMode(decoder.ReadUint16())
9562 return _bsntlvportmode, nil
9563}
9564
9565func NewBsnTlvPortMode() *BsnTlvPortMode {
9566 obj := &BsnTlvPortMode{
9567 BsnTlv: NewBsnTlv(179),
9568 }
9569 return obj
9570}
9571
9572type BsnTlvPortSpeedGbps struct {
9573 *BsnTlv
9574 Value uint32
9575}
9576
9577type IBsnTlvPortSpeedGbps interface {
9578 IBsnTlv
9579 GetValue() uint32
9580}
9581
9582func (self *BsnTlvPortSpeedGbps) GetValue() uint32 {
9583 return self.Value
9584}
9585
9586func (self *BsnTlvPortSpeedGbps) SetValue(v uint32) {
9587 self.Value = v
9588}
9589
9590func (self *BsnTlvPortSpeedGbps) Serialize(encoder *goloxi.Encoder) error {
9591 startIndex := len(encoder.Bytes())
9592 if err := self.BsnTlv.Serialize(encoder); err != nil {
9593 return err
9594 }
9595
9596 encoder.PutUint32(uint32(self.Value))
9597 length := len(encoder.Bytes()) - startIndex
9598
9599 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9600
9601 return nil
9602}
9603
9604func DecodeBsnTlvPortSpeedGbps(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPortSpeedGbps, error) {
9605 _bsntlvportspeedgbps := &BsnTlvPortSpeedGbps{BsnTlv: parent}
9606 if decoder.Length() < 4 {
9607 return nil, fmt.Errorf("BsnTlvPortSpeedGbps packet too short: %d < 4", decoder.Length())
9608 }
9609 _bsntlvportspeedgbps.Value = uint32(decoder.ReadUint32())
9610 return _bsntlvportspeedgbps, nil
9611}
9612
9613func NewBsnTlvPortSpeedGbps() *BsnTlvPortSpeedGbps {
9614 obj := &BsnTlvPortSpeedGbps{
9615 BsnTlv: NewBsnTlv(156),
9616 }
9617 return obj
9618}
9619
9620type BsnTlvPortUsage struct {
9621 *BsnTlv
9622 Value BsnPortUsage
9623}
9624
9625type IBsnTlvPortUsage interface {
9626 IBsnTlv
9627 GetValue() BsnPortUsage
9628}
9629
9630func (self *BsnTlvPortUsage) GetValue() BsnPortUsage {
9631 return self.Value
9632}
9633
9634func (self *BsnTlvPortUsage) SetValue(v BsnPortUsage) {
9635 self.Value = v
9636}
9637
9638func (self *BsnTlvPortUsage) Serialize(encoder *goloxi.Encoder) error {
9639 startIndex := len(encoder.Bytes())
9640 if err := self.BsnTlv.Serialize(encoder); err != nil {
9641 return err
9642 }
9643
9644 encoder.PutUint16(uint16(self.Value))
9645 length := len(encoder.Bytes()) - startIndex
9646
9647 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9648
9649 return nil
9650}
9651
9652func DecodeBsnTlvPortUsage(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPortUsage, error) {
9653 _bsntlvportusage := &BsnTlvPortUsage{BsnTlv: parent}
9654 if decoder.Length() < 2 {
9655 return nil, fmt.Errorf("BsnTlvPortUsage packet too short: %d < 2", decoder.Length())
9656 }
9657 _bsntlvportusage.Value = BsnPortUsage(decoder.ReadUint16())
9658 return _bsntlvportusage, nil
9659}
9660
9661func NewBsnTlvPortUsage() *BsnTlvPortUsage {
9662 obj := &BsnTlvPortUsage{
9663 BsnTlv: NewBsnTlv(141),
9664 }
9665 return obj
9666}
9667
9668type BsnTlvPortVxlanMode struct {
9669 *BsnTlv
9670 Value BsnPortVxlanMode
9671}
9672
9673type IBsnTlvPortVxlanMode interface {
9674 IBsnTlv
9675 GetValue() BsnPortVxlanMode
9676}
9677
9678func (self *BsnTlvPortVxlanMode) GetValue() BsnPortVxlanMode {
9679 return self.Value
9680}
9681
9682func (self *BsnTlvPortVxlanMode) SetValue(v BsnPortVxlanMode) {
9683 self.Value = v
9684}
9685
9686func (self *BsnTlvPortVxlanMode) Serialize(encoder *goloxi.Encoder) error {
9687 startIndex := len(encoder.Bytes())
9688 if err := self.BsnTlv.Serialize(encoder); err != nil {
9689 return err
9690 }
9691
9692 encoder.PutUint8(uint8(self.Value))
9693 length := len(encoder.Bytes()) - startIndex
9694
9695 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9696
9697 return nil
9698}
9699
9700func DecodeBsnTlvPortVxlanMode(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPortVxlanMode, error) {
9701 _bsntlvportvxlanmode := &BsnTlvPortVxlanMode{BsnTlv: parent}
9702 if decoder.Length() < 1 {
9703 return nil, fmt.Errorf("BsnTlvPortVxlanMode packet too short: %d < 1", decoder.Length())
9704 }
9705 _bsntlvportvxlanmode.Value = BsnPortVxlanMode(decoder.ReadByte())
9706 return _bsntlvportvxlanmode, nil
9707}
9708
9709func NewBsnTlvPortVxlanMode() *BsnTlvPortVxlanMode {
9710 obj := &BsnTlvPortVxlanMode{
9711 BsnTlv: NewBsnTlv(88),
9712 }
9713 return obj
9714}
9715
9716type BsnTlvPreserveVlan struct {
9717 *BsnTlv
9718}
9719
9720type IBsnTlvPreserveVlan interface {
9721 IBsnTlv
9722}
9723
9724func (self *BsnTlvPreserveVlan) Serialize(encoder *goloxi.Encoder) error {
9725 startIndex := len(encoder.Bytes())
9726 if err := self.BsnTlv.Serialize(encoder); err != nil {
9727 return err
9728 }
9729 length := len(encoder.Bytes()) - startIndex
9730
9731 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9732
9733 return nil
9734}
9735
9736func DecodeBsnTlvPreserveVlan(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPreserveVlan, error) {
9737 _bsntlvpreservevlan := &BsnTlvPreserveVlan{BsnTlv: parent}
9738 return _bsntlvpreservevlan, nil
9739}
9740
9741func NewBsnTlvPreserveVlan() *BsnTlvPreserveVlan {
9742 obj := &BsnTlvPreserveVlan{
9743 BsnTlv: NewBsnTlv(186),
9744 }
9745 return obj
9746}
9747
9748type BsnTlvPriority struct {
9749 *BsnTlv
9750 Value uint32
9751}
9752
9753type IBsnTlvPriority interface {
9754 IBsnTlv
9755 GetValue() uint32
9756}
9757
9758func (self *BsnTlvPriority) GetValue() uint32 {
9759 return self.Value
9760}
9761
9762func (self *BsnTlvPriority) SetValue(v uint32) {
9763 self.Value = v
9764}
9765
9766func (self *BsnTlvPriority) Serialize(encoder *goloxi.Encoder) error {
9767 startIndex := len(encoder.Bytes())
9768 if err := self.BsnTlv.Serialize(encoder); err != nil {
9769 return err
9770 }
9771
9772 encoder.PutUint32(uint32(self.Value))
9773 length := len(encoder.Bytes()) - startIndex
9774
9775 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9776
9777 return nil
9778}
9779
9780func DecodeBsnTlvPriority(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPriority, error) {
9781 _bsntlvpriority := &BsnTlvPriority{BsnTlv: parent}
9782 if decoder.Length() < 4 {
9783 return nil, fmt.Errorf("BsnTlvPriority packet too short: %d < 4", decoder.Length())
9784 }
9785 _bsntlvpriority.Value = uint32(decoder.ReadUint32())
9786 return _bsntlvpriority, nil
9787}
9788
9789func NewBsnTlvPriority() *BsnTlvPriority {
9790 obj := &BsnTlvPriority{
9791 BsnTlv: NewBsnTlv(57),
9792 }
9793 return obj
9794}
9795
9796type BsnTlvPushVlanOnEgress struct {
9797 *BsnTlv
9798}
9799
9800type IBsnTlvPushVlanOnEgress interface {
9801 IBsnTlv
9802}
9803
9804func (self *BsnTlvPushVlanOnEgress) Serialize(encoder *goloxi.Encoder) error {
9805 startIndex := len(encoder.Bytes())
9806 if err := self.BsnTlv.Serialize(encoder); err != nil {
9807 return err
9808 }
9809 length := len(encoder.Bytes()) - startIndex
9810
9811 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9812
9813 return nil
9814}
9815
9816func DecodeBsnTlvPushVlanOnEgress(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPushVlanOnEgress, error) {
9817 _bsntlvpushvlanonegress := &BsnTlvPushVlanOnEgress{BsnTlv: parent}
9818 return _bsntlvpushvlanonegress, nil
9819}
9820
9821func NewBsnTlvPushVlanOnEgress() *BsnTlvPushVlanOnEgress {
9822 obj := &BsnTlvPushVlanOnEgress{
9823 BsnTlv: NewBsnTlv(162),
9824 }
9825 return obj
9826}
9827
9828type BsnTlvPushVlanOnIngress struct {
9829 *BsnTlv
9830 Flags BsnPushVlan
9831}
9832
9833type IBsnTlvPushVlanOnIngress interface {
9834 IBsnTlv
9835 GetFlags() BsnPushVlan
9836}
9837
9838func (self *BsnTlvPushVlanOnIngress) GetFlags() BsnPushVlan {
9839 return self.Flags
9840}
9841
9842func (self *BsnTlvPushVlanOnIngress) SetFlags(v BsnPushVlan) {
9843 self.Flags = v
9844}
9845
9846func (self *BsnTlvPushVlanOnIngress) Serialize(encoder *goloxi.Encoder) error {
9847 startIndex := len(encoder.Bytes())
9848 if err := self.BsnTlv.Serialize(encoder); err != nil {
9849 return err
9850 }
9851
9852 encoder.PutUint8(uint8(self.Flags))
9853 length := len(encoder.Bytes()) - startIndex
9854
9855 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9856
9857 return nil
9858}
9859
9860func DecodeBsnTlvPushVlanOnIngress(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPushVlanOnIngress, error) {
9861 _bsntlvpushvlanoningress := &BsnTlvPushVlanOnIngress{BsnTlv: parent}
9862 if decoder.Length() < 1 {
9863 return nil, fmt.Errorf("BsnTlvPushVlanOnIngress packet too short: %d < 1", decoder.Length())
9864 }
9865 _bsntlvpushvlanoningress.Flags = BsnPushVlan(decoder.ReadByte())
9866 return _bsntlvpushvlanoningress, nil
9867}
9868
9869func NewBsnTlvPushVlanOnIngress() *BsnTlvPushVlanOnIngress {
9870 obj := &BsnTlvPushVlanOnIngress{
9871 BsnTlv: NewBsnTlv(128),
9872 }
9873 return obj
9874}
9875
9876type BsnTlvQosPriority struct {
9877 *BsnTlv
9878 Value uint32
9879}
9880
9881type IBsnTlvQosPriority interface {
9882 IBsnTlv
9883 GetValue() uint32
9884}
9885
9886func (self *BsnTlvQosPriority) GetValue() uint32 {
9887 return self.Value
9888}
9889
9890func (self *BsnTlvQosPriority) SetValue(v uint32) {
9891 self.Value = v
9892}
9893
9894func (self *BsnTlvQosPriority) Serialize(encoder *goloxi.Encoder) error {
9895 startIndex := len(encoder.Bytes())
9896 if err := self.BsnTlv.Serialize(encoder); err != nil {
9897 return err
9898 }
9899
9900 encoder.PutUint32(uint32(self.Value))
9901 length := len(encoder.Bytes()) - startIndex
9902
9903 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9904
9905 return nil
9906}
9907
9908func DecodeBsnTlvQosPriority(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvQosPriority, error) {
9909 _bsntlvqospriority := &BsnTlvQosPriority{BsnTlv: parent}
9910 if decoder.Length() < 4 {
9911 return nil, fmt.Errorf("BsnTlvQosPriority packet too short: %d < 4", decoder.Length())
9912 }
9913 _bsntlvqospriority.Value = uint32(decoder.ReadUint32())
9914 return _bsntlvqospriority, nil
9915}
9916
9917func NewBsnTlvQosPriority() *BsnTlvQosPriority {
9918 obj := &BsnTlvQosPriority{
9919 BsnTlv: NewBsnTlv(108),
9920 }
9921 return obj
9922}
9923
9924type BsnTlvQueueId struct {
9925 *BsnTlv
9926 Value uint32
9927}
9928
9929type IBsnTlvQueueId interface {
9930 IBsnTlv
9931 GetValue() uint32
9932}
9933
9934func (self *BsnTlvQueueId) GetValue() uint32 {
9935 return self.Value
9936}
9937
9938func (self *BsnTlvQueueId) SetValue(v uint32) {
9939 self.Value = v
9940}
9941
9942func (self *BsnTlvQueueId) Serialize(encoder *goloxi.Encoder) error {
9943 startIndex := len(encoder.Bytes())
9944 if err := self.BsnTlv.Serialize(encoder); err != nil {
9945 return err
9946 }
9947
9948 encoder.PutUint32(uint32(self.Value))
9949 length := len(encoder.Bytes()) - startIndex
9950
9951 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9952
9953 return nil
9954}
9955
9956func DecodeBsnTlvQueueId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvQueueId, error) {
9957 _bsntlvqueueid := &BsnTlvQueueId{BsnTlv: parent}
9958 if decoder.Length() < 4 {
9959 return nil, fmt.Errorf("BsnTlvQueueId packet too short: %d < 4", decoder.Length())
9960 }
9961 _bsntlvqueueid.Value = uint32(decoder.ReadUint32())
9962 return _bsntlvqueueid, nil
9963}
9964
9965func NewBsnTlvQueueId() *BsnTlvQueueId {
9966 obj := &BsnTlvQueueId{
9967 BsnTlv: NewBsnTlv(20),
9968 }
9969 return obj
9970}
9971
9972type BsnTlvQueueWeight struct {
9973 *BsnTlv
9974 Value uint32
9975}
9976
9977type IBsnTlvQueueWeight interface {
9978 IBsnTlv
9979 GetValue() uint32
9980}
9981
9982func (self *BsnTlvQueueWeight) GetValue() uint32 {
9983 return self.Value
9984}
9985
9986func (self *BsnTlvQueueWeight) SetValue(v uint32) {
9987 self.Value = v
9988}
9989
9990func (self *BsnTlvQueueWeight) Serialize(encoder *goloxi.Encoder) error {
9991 startIndex := len(encoder.Bytes())
9992 if err := self.BsnTlv.Serialize(encoder); err != nil {
9993 return err
9994 }
9995
9996 encoder.PutUint32(uint32(self.Value))
9997 length := len(encoder.Bytes()) - startIndex
9998
9999 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10000
10001 return nil
10002}
10003
10004func DecodeBsnTlvQueueWeight(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvQueueWeight, error) {
10005 _bsntlvqueueweight := &BsnTlvQueueWeight{BsnTlv: parent}
10006 if decoder.Length() < 4 {
10007 return nil, fmt.Errorf("BsnTlvQueueWeight packet too short: %d < 4", decoder.Length())
10008 }
10009 _bsntlvqueueweight.Value = uint32(decoder.ReadUint32())
10010 return _bsntlvqueueweight, nil
10011}
10012
10013func NewBsnTlvQueueWeight() *BsnTlvQueueWeight {
10014 obj := &BsnTlvQueueWeight{
10015 BsnTlv: NewBsnTlv(21),
10016 }
10017 return obj
10018}
10019
10020type BsnTlvRateLimit struct {
10021 *BsnTlv
10022 Value uint32
10023}
10024
10025type IBsnTlvRateLimit interface {
10026 IBsnTlv
10027 GetValue() uint32
10028}
10029
10030func (self *BsnTlvRateLimit) GetValue() uint32 {
10031 return self.Value
10032}
10033
10034func (self *BsnTlvRateLimit) SetValue(v uint32) {
10035 self.Value = v
10036}
10037
10038func (self *BsnTlvRateLimit) Serialize(encoder *goloxi.Encoder) error {
10039 startIndex := len(encoder.Bytes())
10040 if err := self.BsnTlv.Serialize(encoder); err != nil {
10041 return err
10042 }
10043
10044 encoder.PutUint32(uint32(self.Value))
10045 length := len(encoder.Bytes()) - startIndex
10046
10047 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10048
10049 return nil
10050}
10051
10052func DecodeBsnTlvRateLimit(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRateLimit, error) {
10053 _bsntlvratelimit := &BsnTlvRateLimit{BsnTlv: parent}
10054 if decoder.Length() < 4 {
10055 return nil, fmt.Errorf("BsnTlvRateLimit packet too short: %d < 4", decoder.Length())
10056 }
10057 _bsntlvratelimit.Value = uint32(decoder.ReadUint32())
10058 return _bsntlvratelimit, nil
10059}
10060
10061func NewBsnTlvRateLimit() *BsnTlvRateLimit {
10062 obj := &BsnTlvRateLimit{
10063 BsnTlv: NewBsnTlv(116),
10064 }
10065 return obj
10066}
10067
10068type BsnTlvRateUnit struct {
10069 *BsnTlv
10070 Value BsnRateUnit
10071}
10072
10073type IBsnTlvRateUnit interface {
10074 IBsnTlv
10075 GetValue() BsnRateUnit
10076}
10077
10078func (self *BsnTlvRateUnit) GetValue() BsnRateUnit {
10079 return self.Value
10080}
10081
10082func (self *BsnTlvRateUnit) SetValue(v BsnRateUnit) {
10083 self.Value = v
10084}
10085
10086func (self *BsnTlvRateUnit) Serialize(encoder *goloxi.Encoder) error {
10087 startIndex := len(encoder.Bytes())
10088 if err := self.BsnTlv.Serialize(encoder); err != nil {
10089 return err
10090 }
10091
10092 encoder.PutUint8(uint8(self.Value))
10093 length := len(encoder.Bytes()) - startIndex
10094
10095 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10096
10097 return nil
10098}
10099
10100func DecodeBsnTlvRateUnit(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRateUnit, error) {
10101 _bsntlvrateunit := &BsnTlvRateUnit{BsnTlv: parent}
10102 if decoder.Length() < 1 {
10103 return nil, fmt.Errorf("BsnTlvRateUnit packet too short: %d < 1", decoder.Length())
10104 }
10105 _bsntlvrateunit.Value = BsnRateUnit(decoder.ReadByte())
10106 return _bsntlvrateunit, nil
10107}
10108
10109func NewBsnTlvRateUnit() *BsnTlvRateUnit {
10110 obj := &BsnTlvRateUnit{
10111 BsnTlv: NewBsnTlv(89),
10112 }
10113 return obj
10114}
10115
10116type BsnTlvRecordPackets struct {
10117 *BsnTlv
10118 Value uint32
10119}
10120
10121type IBsnTlvRecordPackets interface {
10122 IBsnTlv
10123 GetValue() uint32
10124}
10125
10126func (self *BsnTlvRecordPackets) GetValue() uint32 {
10127 return self.Value
10128}
10129
10130func (self *BsnTlvRecordPackets) SetValue(v uint32) {
10131 self.Value = v
10132}
10133
10134func (self *BsnTlvRecordPackets) Serialize(encoder *goloxi.Encoder) error {
10135 startIndex := len(encoder.Bytes())
10136 if err := self.BsnTlv.Serialize(encoder); err != nil {
10137 return err
10138 }
10139
10140 encoder.PutUint32(uint32(self.Value))
10141 length := len(encoder.Bytes()) - startIndex
10142
10143 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10144
10145 return nil
10146}
10147
10148func DecodeBsnTlvRecordPackets(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRecordPackets, error) {
10149 _bsntlvrecordpackets := &BsnTlvRecordPackets{BsnTlv: parent}
10150 if decoder.Length() < 4 {
10151 return nil, fmt.Errorf("BsnTlvRecordPackets packet too short: %d < 4", decoder.Length())
10152 }
10153 _bsntlvrecordpackets.Value = uint32(decoder.ReadUint32())
10154 return _bsntlvrecordpackets, nil
10155}
10156
10157func NewBsnTlvRecordPackets() *BsnTlvRecordPackets {
10158 obj := &BsnTlvRecordPackets{
10159 BsnTlv: NewBsnTlv(155),
10160 }
10161 return obj
10162}
10163
10164type BsnTlvRedundantMgmt struct {
10165 *BsnTlv
10166}
10167
10168type IBsnTlvRedundantMgmt interface {
10169 IBsnTlv
10170}
10171
10172func (self *BsnTlvRedundantMgmt) Serialize(encoder *goloxi.Encoder) error {
10173 startIndex := len(encoder.Bytes())
10174 if err := self.BsnTlv.Serialize(encoder); err != nil {
10175 return err
10176 }
10177 length := len(encoder.Bytes()) - startIndex
10178
10179 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10180
10181 return nil
10182}
10183
10184func DecodeBsnTlvRedundantMgmt(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRedundantMgmt, error) {
10185 _bsntlvredundantmgmt := &BsnTlvRedundantMgmt{BsnTlv: parent}
10186 return _bsntlvredundantmgmt, nil
10187}
10188
10189func NewBsnTlvRedundantMgmt() *BsnTlvRedundantMgmt {
10190 obj := &BsnTlvRedundantMgmt{
10191 BsnTlv: NewBsnTlv(189),
10192 }
10193 return obj
10194}
10195
10196type BsnTlvReference struct {
10197 *BsnTlv
10198 TableId uint16
10199 Key []IBsnTlv
10200}
10201
10202type IBsnTlvReference interface {
10203 IBsnTlv
10204 GetTableId() uint16
10205 GetKey() []IBsnTlv
10206}
10207
10208func (self *BsnTlvReference) GetTableId() uint16 {
10209 return self.TableId
10210}
10211
10212func (self *BsnTlvReference) SetTableId(v uint16) {
10213 self.TableId = v
10214}
10215
10216func (self *BsnTlvReference) GetKey() []IBsnTlv {
10217 return self.Key
10218}
10219
10220func (self *BsnTlvReference) SetKey(v []IBsnTlv) {
10221 self.Key = v
10222}
10223
10224func (self *BsnTlvReference) Serialize(encoder *goloxi.Encoder) error {
10225 startIndex := len(encoder.Bytes())
10226 if err := self.BsnTlv.Serialize(encoder); err != nil {
10227 return err
10228 }
10229
10230 encoder.PutUint16(uint16(self.TableId))
10231 for _, obj := range self.Key {
10232 if err := obj.Serialize(encoder); err != nil {
10233 return err
10234 }
10235 }
10236 length := len(encoder.Bytes()) - startIndex
10237
10238 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10239
10240 return nil
10241}
10242
10243func DecodeBsnTlvReference(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvReference, error) {
10244 _bsntlvreference := &BsnTlvReference{BsnTlv: parent}
10245 if decoder.Length() < 2 {
10246 return nil, fmt.Errorf("BsnTlvReference packet too short: %d < 2", decoder.Length())
10247 }
10248 _bsntlvreference.TableId = uint16(decoder.ReadUint16())
10249
10250 for decoder.Length() >= 4 {
10251 item, err := DecodeBsnTlv(decoder)
10252 if err != nil {
10253 return nil, err
10254 }
10255 if item != nil {
10256 _bsntlvreference.Key = append(_bsntlvreference.Key, item)
10257 }
10258 }
10259 return _bsntlvreference, nil
10260}
10261
10262func NewBsnTlvReference() *BsnTlvReference {
10263 obj := &BsnTlvReference{
10264 BsnTlv: NewBsnTlv(59),
10265 }
10266 return obj
10267}
10268
10269type BsnTlvReplyPackets struct {
10270 *BsnTlv
10271 Value uint64
10272}
10273
10274type IBsnTlvReplyPackets interface {
10275 IBsnTlv
10276 GetValue() uint64
10277}
10278
10279func (self *BsnTlvReplyPackets) GetValue() uint64 {
10280 return self.Value
10281}
10282
10283func (self *BsnTlvReplyPackets) SetValue(v uint64) {
10284 self.Value = v
10285}
10286
10287func (self *BsnTlvReplyPackets) Serialize(encoder *goloxi.Encoder) error {
10288 startIndex := len(encoder.Bytes())
10289 if err := self.BsnTlv.Serialize(encoder); err != nil {
10290 return err
10291 }
10292
10293 encoder.PutUint64(uint64(self.Value))
10294 length := len(encoder.Bytes()) - startIndex
10295
10296 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10297
10298 return nil
10299}
10300
10301func DecodeBsnTlvReplyPackets(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvReplyPackets, error) {
10302 _bsntlvreplypackets := &BsnTlvReplyPackets{BsnTlv: parent}
10303 if decoder.Length() < 8 {
10304 return nil, fmt.Errorf("BsnTlvReplyPackets packet too short: %d < 8", decoder.Length())
10305 }
10306 _bsntlvreplypackets.Value = uint64(decoder.ReadUint64())
10307 return _bsntlvreplypackets, nil
10308}
10309
10310func NewBsnTlvReplyPackets() *BsnTlvReplyPackets {
10311 obj := &BsnTlvReplyPackets{
10312 BsnTlv: NewBsnTlv(12),
10313 }
10314 return obj
10315}
10316
10317type BsnTlvRequestPackets struct {
10318 *BsnTlv
10319 Value uint64
10320}
10321
10322type IBsnTlvRequestPackets interface {
10323 IBsnTlv
10324 GetValue() uint64
10325}
10326
10327func (self *BsnTlvRequestPackets) GetValue() uint64 {
10328 return self.Value
10329}
10330
10331func (self *BsnTlvRequestPackets) SetValue(v uint64) {
10332 self.Value = v
10333}
10334
10335func (self *BsnTlvRequestPackets) Serialize(encoder *goloxi.Encoder) error {
10336 startIndex := len(encoder.Bytes())
10337 if err := self.BsnTlv.Serialize(encoder); err != nil {
10338 return err
10339 }
10340
10341 encoder.PutUint64(uint64(self.Value))
10342 length := len(encoder.Bytes()) - startIndex
10343
10344 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10345
10346 return nil
10347}
10348
10349func DecodeBsnTlvRequestPackets(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRequestPackets, error) {
10350 _bsntlvrequestpackets := &BsnTlvRequestPackets{BsnTlv: parent}
10351 if decoder.Length() < 8 {
10352 return nil, fmt.Errorf("BsnTlvRequestPackets packet too short: %d < 8", decoder.Length())
10353 }
10354 _bsntlvrequestpackets.Value = uint64(decoder.ReadUint64())
10355 return _bsntlvrequestpackets, nil
10356}
10357
10358func NewBsnTlvRequestPackets() *BsnTlvRequestPackets {
10359 obj := &BsnTlvRequestPackets{
10360 BsnTlv: NewBsnTlv(11),
10361 }
10362 return obj
10363}
10364
10365type BsnTlvRestServer struct {
10366 *BsnTlv
10367}
10368
10369type IBsnTlvRestServer interface {
10370 IBsnTlv
10371}
10372
10373func (self *BsnTlvRestServer) Serialize(encoder *goloxi.Encoder) error {
10374 startIndex := len(encoder.Bytes())
10375 if err := self.BsnTlv.Serialize(encoder); err != nil {
10376 return err
10377 }
10378 length := len(encoder.Bytes()) - startIndex
10379
10380 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10381
10382 return nil
10383}
10384
10385func DecodeBsnTlvRestServer(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRestServer, error) {
10386 _bsntlvrestserver := &BsnTlvRestServer{BsnTlv: parent}
10387 return _bsntlvrestserver, nil
10388}
10389
10390func NewBsnTlvRestServer() *BsnTlvRestServer {
10391 obj := &BsnTlvRestServer{
10392 BsnTlv: NewBsnTlv(152),
10393 }
10394 return obj
10395}
10396
10397type BsnTlvRoutingParam struct {
10398 *BsnTlv
10399 Value BsnRoutingParam
10400}
10401
10402type IBsnTlvRoutingParam interface {
10403 IBsnTlv
10404 GetValue() BsnRoutingParam
10405}
10406
10407func (self *BsnTlvRoutingParam) GetValue() BsnRoutingParam {
10408 return self.Value
10409}
10410
10411func (self *BsnTlvRoutingParam) SetValue(v BsnRoutingParam) {
10412 self.Value = v
10413}
10414
10415func (self *BsnTlvRoutingParam) Serialize(encoder *goloxi.Encoder) error {
10416 startIndex := len(encoder.Bytes())
10417 if err := self.BsnTlv.Serialize(encoder); err != nil {
10418 return err
10419 }
10420
10421 encoder.PutUint16(uint16(self.Value))
10422 length := len(encoder.Bytes()) - startIndex
10423
10424 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10425
10426 return nil
10427}
10428
10429func DecodeBsnTlvRoutingParam(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRoutingParam, error) {
10430 _bsntlvroutingparam := &BsnTlvRoutingParam{BsnTlv: parent}
10431 if decoder.Length() < 2 {
10432 return nil, fmt.Errorf("BsnTlvRoutingParam packet too short: %d < 2", decoder.Length())
10433 }
10434 _bsntlvroutingparam.Value = BsnRoutingParam(decoder.ReadUint16())
10435 return _bsntlvroutingparam, nil
10436}
10437
10438func NewBsnTlvRoutingParam() *BsnTlvRoutingParam {
10439 obj := &BsnTlvRoutingParam{
10440 BsnTlv: NewBsnTlv(161),
10441 }
10442 return obj
10443}
10444
10445type BsnTlvRxBytes struct {
10446 *BsnTlv
10447 Value uint64
10448}
10449
10450type IBsnTlvRxBytes interface {
10451 IBsnTlv
10452 GetValue() uint64
10453}
10454
10455func (self *BsnTlvRxBytes) GetValue() uint64 {
10456 return self.Value
10457}
10458
10459func (self *BsnTlvRxBytes) SetValue(v uint64) {
10460 self.Value = v
10461}
10462
10463func (self *BsnTlvRxBytes) Serialize(encoder *goloxi.Encoder) error {
10464 startIndex := len(encoder.Bytes())
10465 if err := self.BsnTlv.Serialize(encoder); err != nil {
10466 return err
10467 }
10468
10469 encoder.PutUint64(uint64(self.Value))
10470 length := len(encoder.Bytes()) - startIndex
10471
10472 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10473
10474 return nil
10475}
10476
10477func DecodeBsnTlvRxBytes(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRxBytes, error) {
10478 _bsntlvrxbytes := &BsnTlvRxBytes{BsnTlv: parent}
10479 if decoder.Length() < 8 {
10480 return nil, fmt.Errorf("BsnTlvRxBytes packet too short: %d < 8", decoder.Length())
10481 }
10482 _bsntlvrxbytes.Value = uint64(decoder.ReadUint64())
10483 return _bsntlvrxbytes, nil
10484}
10485
10486func NewBsnTlvRxBytes() *BsnTlvRxBytes {
10487 obj := &BsnTlvRxBytes{
10488 BsnTlv: NewBsnTlv(71),
10489 }
10490 return obj
10491}
10492
10493type BsnTlvRxPackets struct {
10494 *BsnTlv
10495 Value uint64
10496}
10497
10498type IBsnTlvRxPackets interface {
10499 IBsnTlv
10500 GetValue() uint64
10501}
10502
10503func (self *BsnTlvRxPackets) GetValue() uint64 {
10504 return self.Value
10505}
10506
10507func (self *BsnTlvRxPackets) SetValue(v uint64) {
10508 self.Value = v
10509}
10510
10511func (self *BsnTlvRxPackets) Serialize(encoder *goloxi.Encoder) error {
10512 startIndex := len(encoder.Bytes())
10513 if err := self.BsnTlv.Serialize(encoder); err != nil {
10514 return err
10515 }
10516
10517 encoder.PutUint64(uint64(self.Value))
10518 length := len(encoder.Bytes()) - startIndex
10519
10520 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10521
10522 return nil
10523}
10524
10525func DecodeBsnTlvRxPackets(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRxPackets, error) {
10526 _bsntlvrxpackets := &BsnTlvRxPackets{BsnTlv: parent}
10527 if decoder.Length() < 8 {
10528 return nil, fmt.Errorf("BsnTlvRxPackets packet too short: %d < 8", decoder.Length())
10529 }
10530 _bsntlvrxpackets.Value = uint64(decoder.ReadUint64())
10531 return _bsntlvrxpackets, nil
10532}
10533
10534func NewBsnTlvRxPackets() *BsnTlvRxPackets {
10535 obj := &BsnTlvRxPackets{
10536 BsnTlv: NewBsnTlv(2),
10537 }
10538 return obj
10539}
10540
10541type BsnTlvSamplingRate struct {
10542 *BsnTlv
10543 Value uint32
10544}
10545
10546type IBsnTlvSamplingRate interface {
10547 IBsnTlv
10548 GetValue() uint32
10549}
10550
10551func (self *BsnTlvSamplingRate) GetValue() uint32 {
10552 return self.Value
10553}
10554
10555func (self *BsnTlvSamplingRate) SetValue(v uint32) {
10556 self.Value = v
10557}
10558
10559func (self *BsnTlvSamplingRate) Serialize(encoder *goloxi.Encoder) error {
10560 startIndex := len(encoder.Bytes())
10561 if err := self.BsnTlv.Serialize(encoder); err != nil {
10562 return err
10563 }
10564
10565 encoder.PutUint32(uint32(self.Value))
10566 length := len(encoder.Bytes()) - startIndex
10567
10568 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10569
10570 return nil
10571}
10572
10573func DecodeBsnTlvSamplingRate(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvSamplingRate, error) {
10574 _bsntlvsamplingrate := &BsnTlvSamplingRate{BsnTlv: parent}
10575 if decoder.Length() < 4 {
10576 return nil, fmt.Errorf("BsnTlvSamplingRate packet too short: %d < 4", decoder.Length())
10577 }
10578 _bsntlvsamplingrate.Value = uint32(decoder.ReadUint32())
10579 return _bsntlvsamplingrate, nil
10580}
10581
10582func NewBsnTlvSamplingRate() *BsnTlvSamplingRate {
10583 obj := &BsnTlvSamplingRate{
10584 BsnTlv: NewBsnTlv(30),
10585 }
10586 return obj
10587}
10588
10589type BsnTlvSetLoopbackMode struct {
10590 *BsnTlv
10591}
10592
10593type IBsnTlvSetLoopbackMode interface {
10594 IBsnTlv
10595}
10596
10597func (self *BsnTlvSetLoopbackMode) Serialize(encoder *goloxi.Encoder) error {
10598 startIndex := len(encoder.Bytes())
10599 if err := self.BsnTlv.Serialize(encoder); err != nil {
10600 return err
10601 }
10602 length := len(encoder.Bytes()) - startIndex
10603
10604 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10605
10606 return nil
10607}
10608
10609func DecodeBsnTlvSetLoopbackMode(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvSetLoopbackMode, error) {
10610 _bsntlvsetloopbackmode := &BsnTlvSetLoopbackMode{BsnTlv: parent}
10611 return _bsntlvsetloopbackmode, nil
10612}
10613
10614func NewBsnTlvSetLoopbackMode() *BsnTlvSetLoopbackMode {
10615 obj := &BsnTlvSetLoopbackMode{
10616 BsnTlv: NewBsnTlv(74),
10617 }
10618 return obj
10619}
10620
10621type BsnTlvSrcMacCml struct {
10622 *BsnTlv
10623 Value BsnCml
10624}
10625
10626type IBsnTlvSrcMacCml interface {
10627 IBsnTlv
10628 GetValue() BsnCml
10629}
10630
10631func (self *BsnTlvSrcMacCml) GetValue() BsnCml {
10632 return self.Value
10633}
10634
10635func (self *BsnTlvSrcMacCml) SetValue(v BsnCml) {
10636 self.Value = v
10637}
10638
10639func (self *BsnTlvSrcMacCml) Serialize(encoder *goloxi.Encoder) error {
10640 startIndex := len(encoder.Bytes())
10641 if err := self.BsnTlv.Serialize(encoder); err != nil {
10642 return err
10643 }
10644
10645 encoder.PutUint16(uint16(self.Value))
10646 length := len(encoder.Bytes()) - startIndex
10647
10648 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10649
10650 return nil
10651}
10652
10653func DecodeBsnTlvSrcMacCml(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvSrcMacCml, error) {
10654 _bsntlvsrcmaccml := &BsnTlvSrcMacCml{BsnTlv: parent}
10655 if decoder.Length() < 2 {
10656 return nil, fmt.Errorf("BsnTlvSrcMacCml packet too short: %d < 2", decoder.Length())
10657 }
10658 _bsntlvsrcmaccml.Value = BsnCml(decoder.ReadUint16())
10659 return _bsntlvsrcmaccml, nil
10660}
10661
10662func NewBsnTlvSrcMacCml() *BsnTlvSrcMacCml {
10663 obj := &BsnTlvSrcMacCml{
10664 BsnTlv: NewBsnTlv(191),
10665 }
10666 return obj
10667}
10668
10669type BsnTlvStatus struct {
10670 *BsnTlv
10671 Value BsnStatus
10672}
10673
10674type IBsnTlvStatus interface {
10675 IBsnTlv
10676 GetValue() BsnStatus
10677}
10678
10679func (self *BsnTlvStatus) GetValue() BsnStatus {
10680 return self.Value
10681}
10682
10683func (self *BsnTlvStatus) SetValue(v BsnStatus) {
10684 self.Value = v
10685}
10686
10687func (self *BsnTlvStatus) Serialize(encoder *goloxi.Encoder) error {
10688 startIndex := len(encoder.Bytes())
10689 if err := self.BsnTlv.Serialize(encoder); err != nil {
10690 return err
10691 }
10692
10693 encoder.PutUint8(uint8(self.Value))
10694 length := len(encoder.Bytes()) - startIndex
10695
10696 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10697
10698 return nil
10699}
10700
10701func DecodeBsnTlvStatus(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvStatus, error) {
10702 _bsntlvstatus := &BsnTlvStatus{BsnTlv: parent}
10703 if decoder.Length() < 1 {
10704 return nil, fmt.Errorf("BsnTlvStatus packet too short: %d < 1", decoder.Length())
10705 }
10706 _bsntlvstatus.Value = BsnStatus(decoder.ReadByte())
10707 return _bsntlvstatus, nil
10708}
10709
10710func NewBsnTlvStatus() *BsnTlvStatus {
10711 obj := &BsnTlvStatus{
10712 BsnTlv: NewBsnTlv(97),
10713 }
10714 return obj
10715}
10716
10717type BsnTlvStripMplsL2OnIngress struct {
10718 *BsnTlv
10719}
10720
10721type IBsnTlvStripMplsL2OnIngress interface {
10722 IBsnTlv
10723}
10724
10725func (self *BsnTlvStripMplsL2OnIngress) Serialize(encoder *goloxi.Encoder) error {
10726 startIndex := len(encoder.Bytes())
10727 if err := self.BsnTlv.Serialize(encoder); err != nil {
10728 return err
10729 }
10730 length := len(encoder.Bytes()) - startIndex
10731
10732 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10733
10734 return nil
10735}
10736
10737func DecodeBsnTlvStripMplsL2OnIngress(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvStripMplsL2OnIngress, error) {
10738 _bsntlvstripmplsl2oningress := &BsnTlvStripMplsL2OnIngress{BsnTlv: parent}
10739 return _bsntlvstripmplsl2oningress, nil
10740}
10741
10742func NewBsnTlvStripMplsL2OnIngress() *BsnTlvStripMplsL2OnIngress {
10743 obj := &BsnTlvStripMplsL2OnIngress{
10744 BsnTlv: NewBsnTlv(75),
10745 }
10746 return obj
10747}
10748
10749type BsnTlvStripMplsL3OnIngress struct {
10750 *BsnTlv
10751}
10752
10753type IBsnTlvStripMplsL3OnIngress interface {
10754 IBsnTlv
10755}
10756
10757func (self *BsnTlvStripMplsL3OnIngress) Serialize(encoder *goloxi.Encoder) error {
10758 startIndex := len(encoder.Bytes())
10759 if err := self.BsnTlv.Serialize(encoder); err != nil {
10760 return err
10761 }
10762 length := len(encoder.Bytes()) - startIndex
10763
10764 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10765
10766 return nil
10767}
10768
10769func DecodeBsnTlvStripMplsL3OnIngress(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvStripMplsL3OnIngress, error) {
10770 _bsntlvstripmplsl3oningress := &BsnTlvStripMplsL3OnIngress{BsnTlv: parent}
10771 return _bsntlvstripmplsl3oningress, nil
10772}
10773
10774func NewBsnTlvStripMplsL3OnIngress() *BsnTlvStripMplsL3OnIngress {
10775 obj := &BsnTlvStripMplsL3OnIngress{
10776 BsnTlv: NewBsnTlv(76),
10777 }
10778 return obj
10779}
10780
10781type BsnTlvStripVlanOnEgress struct {
10782 *BsnTlv
10783 Flags BsnStripVlan
10784}
10785
10786type IBsnTlvStripVlanOnEgress interface {
10787 IBsnTlv
10788 GetFlags() BsnStripVlan
10789}
10790
10791func (self *BsnTlvStripVlanOnEgress) GetFlags() BsnStripVlan {
10792 return self.Flags
10793}
10794
10795func (self *BsnTlvStripVlanOnEgress) SetFlags(v BsnStripVlan) {
10796 self.Flags = v
10797}
10798
10799func (self *BsnTlvStripVlanOnEgress) Serialize(encoder *goloxi.Encoder) error {
10800 startIndex := len(encoder.Bytes())
10801 if err := self.BsnTlv.Serialize(encoder); err != nil {
10802 return err
10803 }
10804
10805 encoder.PutUint8(uint8(self.Flags))
10806 length := len(encoder.Bytes()) - startIndex
10807
10808 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10809
10810 return nil
10811}
10812
10813func DecodeBsnTlvStripVlanOnEgress(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvStripVlanOnEgress, error) {
10814 _bsntlvstripvlanonegress := &BsnTlvStripVlanOnEgress{BsnTlv: parent}
10815 if decoder.Length() < 1 {
10816 return nil, fmt.Errorf("BsnTlvStripVlanOnEgress packet too short: %d < 1", decoder.Length())
10817 }
10818 _bsntlvstripvlanonegress.Flags = BsnStripVlan(decoder.ReadByte())
10819 return _bsntlvstripvlanonegress, nil
10820}
10821
10822func NewBsnTlvStripVlanOnEgress() *BsnTlvStripVlanOnEgress {
10823 obj := &BsnTlvStripVlanOnEgress{
10824 BsnTlv: NewBsnTlv(73),
10825 }
10826 return obj
10827}
10828
10829type BsnTlvSubAgentId struct {
10830 *BsnTlv
10831 Value uint32
10832}
10833
10834type IBsnTlvSubAgentId interface {
10835 IBsnTlv
10836 GetValue() uint32
10837}
10838
10839func (self *BsnTlvSubAgentId) GetValue() uint32 {
10840 return self.Value
10841}
10842
10843func (self *BsnTlvSubAgentId) SetValue(v uint32) {
10844 self.Value = v
10845}
10846
10847func (self *BsnTlvSubAgentId) Serialize(encoder *goloxi.Encoder) error {
10848 startIndex := len(encoder.Bytes())
10849 if err := self.BsnTlv.Serialize(encoder); err != nil {
10850 return err
10851 }
10852
10853 encoder.PutUint32(uint32(self.Value))
10854 length := len(encoder.Bytes()) - startIndex
10855
10856 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10857
10858 return nil
10859}
10860
10861func DecodeBsnTlvSubAgentId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvSubAgentId, error) {
10862 _bsntlvsubagentid := &BsnTlvSubAgentId{BsnTlv: parent}
10863 if decoder.Length() < 4 {
10864 return nil, fmt.Errorf("BsnTlvSubAgentId packet too short: %d < 4", decoder.Length())
10865 }
10866 _bsntlvsubagentid.Value = uint32(decoder.ReadUint32())
10867 return _bsntlvsubagentid, nil
10868}
10869
10870func NewBsnTlvSubAgentId() *BsnTlvSubAgentId {
10871 obj := &BsnTlvSubAgentId{
10872 BsnTlv: NewBsnTlv(38),
10873 }
10874 return obj
10875}
10876
10877type BsnTlvTcpDst struct {
10878 *BsnTlv
10879 Value uint16
10880}
10881
10882type IBsnTlvTcpDst interface {
10883 IBsnTlv
10884 GetValue() uint16
10885}
10886
10887func (self *BsnTlvTcpDst) GetValue() uint16 {
10888 return self.Value
10889}
10890
10891func (self *BsnTlvTcpDst) SetValue(v uint16) {
10892 self.Value = v
10893}
10894
10895func (self *BsnTlvTcpDst) Serialize(encoder *goloxi.Encoder) error {
10896 startIndex := len(encoder.Bytes())
10897 if err := self.BsnTlv.Serialize(encoder); err != nil {
10898 return err
10899 }
10900
10901 encoder.PutUint16(uint16(self.Value))
10902 length := len(encoder.Bytes()) - startIndex
10903
10904 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10905
10906 return nil
10907}
10908
10909func DecodeBsnTlvTcpDst(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTcpDst, error) {
10910 _bsntlvtcpdst := &BsnTlvTcpDst{BsnTlv: parent}
10911 if decoder.Length() < 2 {
10912 return nil, fmt.Errorf("BsnTlvTcpDst packet too short: %d < 2", decoder.Length())
10913 }
10914 _bsntlvtcpdst.Value = uint16(decoder.ReadUint16())
10915 return _bsntlvtcpdst, nil
10916}
10917
10918func NewBsnTlvTcpDst() *BsnTlvTcpDst {
10919 obj := &BsnTlvTcpDst{
10920 BsnTlv: NewBsnTlv(66),
10921 }
10922 return obj
10923}
10924
10925type BsnTlvTcpFlags struct {
10926 *BsnTlv
10927 Value uint16
10928}
10929
10930type IBsnTlvTcpFlags interface {
10931 IBsnTlv
10932 GetValue() uint16
10933}
10934
10935func (self *BsnTlvTcpFlags) GetValue() uint16 {
10936 return self.Value
10937}
10938
10939func (self *BsnTlvTcpFlags) SetValue(v uint16) {
10940 self.Value = v
10941}
10942
10943func (self *BsnTlvTcpFlags) Serialize(encoder *goloxi.Encoder) error {
10944 startIndex := len(encoder.Bytes())
10945 if err := self.BsnTlv.Serialize(encoder); err != nil {
10946 return err
10947 }
10948
10949 encoder.PutUint16(uint16(self.Value))
10950 length := len(encoder.Bytes()) - startIndex
10951
10952 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10953
10954 return nil
10955}
10956
10957func DecodeBsnTlvTcpFlags(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTcpFlags, error) {
10958 _bsntlvtcpflags := &BsnTlvTcpFlags{BsnTlv: parent}
10959 if decoder.Length() < 2 {
10960 return nil, fmt.Errorf("BsnTlvTcpFlags packet too short: %d < 2", decoder.Length())
10961 }
10962 _bsntlvtcpflags.Value = uint16(decoder.ReadUint16())
10963 return _bsntlvtcpflags, nil
10964}
10965
10966func NewBsnTlvTcpFlags() *BsnTlvTcpFlags {
10967 obj := &BsnTlvTcpFlags{
10968 BsnTlv: NewBsnTlv(133),
10969 }
10970 return obj
10971}
10972
10973type BsnTlvTcpSrc struct {
10974 *BsnTlv
10975 Value uint16
10976}
10977
10978type IBsnTlvTcpSrc interface {
10979 IBsnTlv
10980 GetValue() uint16
10981}
10982
10983func (self *BsnTlvTcpSrc) GetValue() uint16 {
10984 return self.Value
10985}
10986
10987func (self *BsnTlvTcpSrc) SetValue(v uint16) {
10988 self.Value = v
10989}
10990
10991func (self *BsnTlvTcpSrc) Serialize(encoder *goloxi.Encoder) error {
10992 startIndex := len(encoder.Bytes())
10993 if err := self.BsnTlv.Serialize(encoder); err != nil {
10994 return err
10995 }
10996
10997 encoder.PutUint16(uint16(self.Value))
10998 length := len(encoder.Bytes()) - startIndex
10999
11000 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11001
11002 return nil
11003}
11004
11005func DecodeBsnTlvTcpSrc(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTcpSrc, error) {
11006 _bsntlvtcpsrc := &BsnTlvTcpSrc{BsnTlv: parent}
11007 if decoder.Length() < 2 {
11008 return nil, fmt.Errorf("BsnTlvTcpSrc packet too short: %d < 2", decoder.Length())
11009 }
11010 _bsntlvtcpsrc.Value = uint16(decoder.ReadUint16())
11011 return _bsntlvtcpsrc, nil
11012}
11013
11014func NewBsnTlvTcpSrc() *BsnTlvTcpSrc {
11015 obj := &BsnTlvTcpSrc{
11016 BsnTlv: NewBsnTlv(65),
11017 }
11018 return obj
11019}
11020
11021type BsnTlvTimestamp struct {
11022 *BsnTlv
11023 Value uint64
11024}
11025
11026type IBsnTlvTimestamp interface {
11027 IBsnTlv
11028 GetValue() uint64
11029}
11030
11031func (self *BsnTlvTimestamp) GetValue() uint64 {
11032 return self.Value
11033}
11034
11035func (self *BsnTlvTimestamp) SetValue(v uint64) {
11036 self.Value = v
11037}
11038
11039func (self *BsnTlvTimestamp) Serialize(encoder *goloxi.Encoder) error {
11040 startIndex := len(encoder.Bytes())
11041 if err := self.BsnTlv.Serialize(encoder); err != nil {
11042 return err
11043 }
11044
11045 encoder.PutUint64(uint64(self.Value))
11046 length := len(encoder.Bytes()) - startIndex
11047
11048 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11049
11050 return nil
11051}
11052
11053func DecodeBsnTlvTimestamp(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTimestamp, error) {
11054 _bsntlvtimestamp := &BsnTlvTimestamp{BsnTlv: parent}
11055 if decoder.Length() < 8 {
11056 return nil, fmt.Errorf("BsnTlvTimestamp packet too short: %d < 8", decoder.Length())
11057 }
11058 _bsntlvtimestamp.Value = uint64(decoder.ReadUint64())
11059 return _bsntlvtimestamp, nil
11060}
11061
11062func NewBsnTlvTimestamp() *BsnTlvTimestamp {
11063 obj := &BsnTlvTimestamp{
11064 BsnTlv: NewBsnTlv(154),
11065 }
11066 return obj
11067}
11068
11069type BsnTlvTtl struct {
11070 *BsnTlv
11071 Value uint16
11072}
11073
11074type IBsnTlvTtl interface {
11075 IBsnTlv
11076 GetValue() uint16
11077}
11078
11079func (self *BsnTlvTtl) GetValue() uint16 {
11080 return self.Value
11081}
11082
11083func (self *BsnTlvTtl) SetValue(v uint16) {
11084 self.Value = v
11085}
11086
11087func (self *BsnTlvTtl) Serialize(encoder *goloxi.Encoder) error {
11088 startIndex := len(encoder.Bytes())
11089 if err := self.BsnTlv.Serialize(encoder); err != nil {
11090 return err
11091 }
11092
11093 encoder.PutUint16(uint16(self.Value))
11094 length := len(encoder.Bytes()) - startIndex
11095
11096 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11097
11098 return nil
11099}
11100
11101func DecodeBsnTlvTtl(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTtl, error) {
11102 _bsntlvttl := &BsnTlvTtl{BsnTlv: parent}
11103 if decoder.Length() < 2 {
11104 return nil, fmt.Errorf("BsnTlvTtl packet too short: %d < 2", decoder.Length())
11105 }
11106 _bsntlvttl.Value = uint16(decoder.ReadUint16())
11107 return _bsntlvttl, nil
11108}
11109
11110func NewBsnTlvTtl() *BsnTlvTtl {
11111 obj := &BsnTlvTtl{
11112 BsnTlv: NewBsnTlv(113),
11113 }
11114 return obj
11115}
11116
11117type BsnTlvTunnelCapability struct {
11118 *BsnTlv
11119 Value BsnTunnelType
11120}
11121
11122type IBsnTlvTunnelCapability interface {
11123 IBsnTlv
11124 GetValue() BsnTunnelType
11125}
11126
11127func (self *BsnTlvTunnelCapability) GetValue() BsnTunnelType {
11128 return self.Value
11129}
11130
11131func (self *BsnTlvTunnelCapability) SetValue(v BsnTunnelType) {
11132 self.Value = v
11133}
11134
11135func (self *BsnTlvTunnelCapability) Serialize(encoder *goloxi.Encoder) error {
11136 startIndex := len(encoder.Bytes())
11137 if err := self.BsnTlv.Serialize(encoder); err != nil {
11138 return err
11139 }
11140
11141 encoder.PutUint64(uint64(self.Value))
11142 length := len(encoder.Bytes()) - startIndex
11143
11144 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11145
11146 return nil
11147}
11148
11149func DecodeBsnTlvTunnelCapability(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTunnelCapability, error) {
11150 _bsntlvtunnelcapability := &BsnTlvTunnelCapability{BsnTlv: parent}
11151 if decoder.Length() < 8 {
11152 return nil, fmt.Errorf("BsnTlvTunnelCapability packet too short: %d < 8", decoder.Length())
11153 }
11154 _bsntlvtunnelcapability.Value = BsnTunnelType(decoder.ReadUint64())
11155 return _bsntlvtunnelcapability, nil
11156}
11157
11158func NewBsnTlvTunnelCapability() *BsnTlvTunnelCapability {
11159 obj := &BsnTlvTunnelCapability{
11160 BsnTlv: NewBsnTlv(142),
11161 }
11162 return obj
11163}
11164
11165type BsnTlvTxBytes struct {
11166 *BsnTlv
11167 Value uint64
11168}
11169
11170type IBsnTlvTxBytes interface {
11171 IBsnTlv
11172 GetValue() uint64
11173}
11174
11175func (self *BsnTlvTxBytes) GetValue() uint64 {
11176 return self.Value
11177}
11178
11179func (self *BsnTlvTxBytes) SetValue(v uint64) {
11180 self.Value = v
11181}
11182
11183func (self *BsnTlvTxBytes) Serialize(encoder *goloxi.Encoder) error {
11184 startIndex := len(encoder.Bytes())
11185 if err := self.BsnTlv.Serialize(encoder); err != nil {
11186 return err
11187 }
11188
11189 encoder.PutUint64(uint64(self.Value))
11190 length := len(encoder.Bytes()) - startIndex
11191
11192 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11193
11194 return nil
11195}
11196
11197func DecodeBsnTlvTxBytes(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTxBytes, error) {
11198 _bsntlvtxbytes := &BsnTlvTxBytes{BsnTlv: parent}
11199 if decoder.Length() < 8 {
11200 return nil, fmt.Errorf("BsnTlvTxBytes packet too short: %d < 8", decoder.Length())
11201 }
11202 _bsntlvtxbytes.Value = uint64(decoder.ReadUint64())
11203 return _bsntlvtxbytes, nil
11204}
11205
11206func NewBsnTlvTxBytes() *BsnTlvTxBytes {
11207 obj := &BsnTlvTxBytes{
11208 BsnTlv: NewBsnTlv(39),
11209 }
11210 return obj
11211}
11212
11213type BsnTlvTxPackets struct {
11214 *BsnTlv
11215 Value uint64
11216}
11217
11218type IBsnTlvTxPackets interface {
11219 IBsnTlv
11220 GetValue() uint64
11221}
11222
11223func (self *BsnTlvTxPackets) GetValue() uint64 {
11224 return self.Value
11225}
11226
11227func (self *BsnTlvTxPackets) SetValue(v uint64) {
11228 self.Value = v
11229}
11230
11231func (self *BsnTlvTxPackets) Serialize(encoder *goloxi.Encoder) error {
11232 startIndex := len(encoder.Bytes())
11233 if err := self.BsnTlv.Serialize(encoder); err != nil {
11234 return err
11235 }
11236
11237 encoder.PutUint64(uint64(self.Value))
11238 length := len(encoder.Bytes()) - startIndex
11239
11240 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11241
11242 return nil
11243}
11244
11245func DecodeBsnTlvTxPackets(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTxPackets, error) {
11246 _bsntlvtxpackets := &BsnTlvTxPackets{BsnTlv: parent}
11247 if decoder.Length() < 8 {
11248 return nil, fmt.Errorf("BsnTlvTxPackets packet too short: %d < 8", decoder.Length())
11249 }
11250 _bsntlvtxpackets.Value = uint64(decoder.ReadUint64())
11251 return _bsntlvtxpackets, nil
11252}
11253
11254func NewBsnTlvTxPackets() *BsnTlvTxPackets {
11255 obj := &BsnTlvTxPackets{
11256 BsnTlv: NewBsnTlv(3),
11257 }
11258 return obj
11259}
11260
11261type BsnTlvUdfAnchor struct {
11262 *BsnTlv
11263 Value BsnUdfAnchor
11264}
11265
11266type IBsnTlvUdfAnchor interface {
11267 IBsnTlv
11268 GetValue() BsnUdfAnchor
11269}
11270
11271func (self *BsnTlvUdfAnchor) GetValue() BsnUdfAnchor {
11272 return self.Value
11273}
11274
11275func (self *BsnTlvUdfAnchor) SetValue(v BsnUdfAnchor) {
11276 self.Value = v
11277}
11278
11279func (self *BsnTlvUdfAnchor) Serialize(encoder *goloxi.Encoder) error {
11280 startIndex := len(encoder.Bytes())
11281 if err := self.BsnTlv.Serialize(encoder); err != nil {
11282 return err
11283 }
11284
11285 encoder.PutUint16(uint16(self.Value))
11286 length := len(encoder.Bytes()) - startIndex
11287
11288 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11289
11290 return nil
11291}
11292
11293func DecodeBsnTlvUdfAnchor(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUdfAnchor, error) {
11294 _bsntlvudfanchor := &BsnTlvUdfAnchor{BsnTlv: parent}
11295 if decoder.Length() < 2 {
11296 return nil, fmt.Errorf("BsnTlvUdfAnchor packet too short: %d < 2", decoder.Length())
11297 }
11298 _bsntlvudfanchor.Value = BsnUdfAnchor(decoder.ReadUint16())
11299 return _bsntlvudfanchor, nil
11300}
11301
11302func NewBsnTlvUdfAnchor() *BsnTlvUdfAnchor {
11303 obj := &BsnTlvUdfAnchor{
11304 BsnTlv: NewBsnTlv(16),
11305 }
11306 return obj
11307}
11308
11309type BsnTlvUdfCapability struct {
11310 *BsnTlv
11311 Value BsnUdfMode
11312}
11313
11314type IBsnTlvUdfCapability interface {
11315 IBsnTlv
11316 GetValue() BsnUdfMode
11317}
11318
11319func (self *BsnTlvUdfCapability) GetValue() BsnUdfMode {
11320 return self.Value
11321}
11322
11323func (self *BsnTlvUdfCapability) SetValue(v BsnUdfMode) {
11324 self.Value = v
11325}
11326
11327func (self *BsnTlvUdfCapability) Serialize(encoder *goloxi.Encoder) error {
11328 startIndex := len(encoder.Bytes())
11329 if err := self.BsnTlv.Serialize(encoder); err != nil {
11330 return err
11331 }
11332
11333 encoder.PutUint8(uint8(self.Value))
11334 length := len(encoder.Bytes()) - startIndex
11335
11336 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11337
11338 return nil
11339}
11340
11341func DecodeBsnTlvUdfCapability(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUdfCapability, error) {
11342 _bsntlvudfcapability := &BsnTlvUdfCapability{BsnTlv: parent}
11343 if decoder.Length() < 1 {
11344 return nil, fmt.Errorf("BsnTlvUdfCapability packet too short: %d < 1", decoder.Length())
11345 }
11346 _bsntlvudfcapability.Value = BsnUdfMode(decoder.ReadByte())
11347 return _bsntlvudfcapability, nil
11348}
11349
11350func NewBsnTlvUdfCapability() *BsnTlvUdfCapability {
11351 obj := &BsnTlvUdfCapability{
11352 BsnTlv: NewBsnTlv(180),
11353 }
11354 return obj
11355}
11356
11357type BsnTlvUdfId struct {
11358 *BsnTlv
11359 Value uint16
11360}
11361
11362type IBsnTlvUdfId interface {
11363 IBsnTlv
11364 GetValue() uint16
11365}
11366
11367func (self *BsnTlvUdfId) GetValue() uint16 {
11368 return self.Value
11369}
11370
11371func (self *BsnTlvUdfId) SetValue(v uint16) {
11372 self.Value = v
11373}
11374
11375func (self *BsnTlvUdfId) Serialize(encoder *goloxi.Encoder) error {
11376 startIndex := len(encoder.Bytes())
11377 if err := self.BsnTlv.Serialize(encoder); err != nil {
11378 return err
11379 }
11380
11381 encoder.PutUint16(uint16(self.Value))
11382 length := len(encoder.Bytes()) - startIndex
11383
11384 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11385
11386 return nil
11387}
11388
11389func DecodeBsnTlvUdfId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUdfId, error) {
11390 _bsntlvudfid := &BsnTlvUdfId{BsnTlv: parent}
11391 if decoder.Length() < 2 {
11392 return nil, fmt.Errorf("BsnTlvUdfId packet too short: %d < 2", decoder.Length())
11393 }
11394 _bsntlvudfid.Value = uint16(decoder.ReadUint16())
11395 return _bsntlvudfid, nil
11396}
11397
11398func NewBsnTlvUdfId() *BsnTlvUdfId {
11399 obj := &BsnTlvUdfId{
11400 BsnTlv: NewBsnTlv(15),
11401 }
11402 return obj
11403}
11404
11405type BsnTlvUdfLength struct {
11406 *BsnTlv
11407 Value uint16
11408}
11409
11410type IBsnTlvUdfLength interface {
11411 IBsnTlv
11412 GetValue() uint16
11413}
11414
11415func (self *BsnTlvUdfLength) GetValue() uint16 {
11416 return self.Value
11417}
11418
11419func (self *BsnTlvUdfLength) SetValue(v uint16) {
11420 self.Value = v
11421}
11422
11423func (self *BsnTlvUdfLength) Serialize(encoder *goloxi.Encoder) error {
11424 startIndex := len(encoder.Bytes())
11425 if err := self.BsnTlv.Serialize(encoder); err != nil {
11426 return err
11427 }
11428
11429 encoder.PutUint16(uint16(self.Value))
11430 length := len(encoder.Bytes()) - startIndex
11431
11432 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11433
11434 return nil
11435}
11436
11437func DecodeBsnTlvUdfLength(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUdfLength, error) {
11438 _bsntlvudflength := &BsnTlvUdfLength{BsnTlv: parent}
11439 if decoder.Length() < 2 {
11440 return nil, fmt.Errorf("BsnTlvUdfLength packet too short: %d < 2", decoder.Length())
11441 }
11442 _bsntlvudflength.Value = uint16(decoder.ReadUint16())
11443 return _bsntlvudflength, nil
11444}
11445
11446func NewBsnTlvUdfLength() *BsnTlvUdfLength {
11447 obj := &BsnTlvUdfLength{
11448 BsnTlv: NewBsnTlv(18),
11449 }
11450 return obj
11451}
11452
11453type BsnTlvUdfOffset struct {
11454 *BsnTlv
11455 Value uint16
11456}
11457
11458type IBsnTlvUdfOffset interface {
11459 IBsnTlv
11460 GetValue() uint16
11461}
11462
11463func (self *BsnTlvUdfOffset) GetValue() uint16 {
11464 return self.Value
11465}
11466
11467func (self *BsnTlvUdfOffset) SetValue(v uint16) {
11468 self.Value = v
11469}
11470
11471func (self *BsnTlvUdfOffset) Serialize(encoder *goloxi.Encoder) error {
11472 startIndex := len(encoder.Bytes())
11473 if err := self.BsnTlv.Serialize(encoder); err != nil {
11474 return err
11475 }
11476
11477 encoder.PutUint16(uint16(self.Value))
11478 length := len(encoder.Bytes()) - startIndex
11479
11480 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11481
11482 return nil
11483}
11484
11485func DecodeBsnTlvUdfOffset(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUdfOffset, error) {
11486 _bsntlvudfoffset := &BsnTlvUdfOffset{BsnTlv: parent}
11487 if decoder.Length() < 2 {
11488 return nil, fmt.Errorf("BsnTlvUdfOffset packet too short: %d < 2", decoder.Length())
11489 }
11490 _bsntlvudfoffset.Value = uint16(decoder.ReadUint16())
11491 return _bsntlvudfoffset, nil
11492}
11493
11494func NewBsnTlvUdfOffset() *BsnTlvUdfOffset {
11495 obj := &BsnTlvUdfOffset{
11496 BsnTlv: NewBsnTlv(17),
11497 }
11498 return obj
11499}
11500
11501type BsnTlvUdpDst struct {
11502 *BsnTlv
11503 Value uint16
11504}
11505
11506type IBsnTlvUdpDst interface {
11507 IBsnTlv
11508 GetValue() uint16
11509}
11510
11511func (self *BsnTlvUdpDst) GetValue() uint16 {
11512 return self.Value
11513}
11514
11515func (self *BsnTlvUdpDst) SetValue(v uint16) {
11516 self.Value = v
11517}
11518
11519func (self *BsnTlvUdpDst) Serialize(encoder *goloxi.Encoder) error {
11520 startIndex := len(encoder.Bytes())
11521 if err := self.BsnTlv.Serialize(encoder); err != nil {
11522 return err
11523 }
11524
11525 encoder.PutUint16(uint16(self.Value))
11526 length := len(encoder.Bytes()) - startIndex
11527
11528 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11529
11530 return nil
11531}
11532
11533func DecodeBsnTlvUdpDst(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUdpDst, error) {
11534 _bsntlvudpdst := &BsnTlvUdpDst{BsnTlv: parent}
11535 if decoder.Length() < 2 {
11536 return nil, fmt.Errorf("BsnTlvUdpDst packet too short: %d < 2", decoder.Length())
11537 }
11538 _bsntlvudpdst.Value = uint16(decoder.ReadUint16())
11539 return _bsntlvudpdst, nil
11540}
11541
11542func NewBsnTlvUdpDst() *BsnTlvUdpDst {
11543 obj := &BsnTlvUdpDst{
11544 BsnTlv: NewBsnTlv(37),
11545 }
11546 return obj
11547}
11548
11549type BsnTlvUdpSrc struct {
11550 *BsnTlv
11551 Value uint16
11552}
11553
11554type IBsnTlvUdpSrc interface {
11555 IBsnTlv
11556 GetValue() uint16
11557}
11558
11559func (self *BsnTlvUdpSrc) GetValue() uint16 {
11560 return self.Value
11561}
11562
11563func (self *BsnTlvUdpSrc) SetValue(v uint16) {
11564 self.Value = v
11565}
11566
11567func (self *BsnTlvUdpSrc) Serialize(encoder *goloxi.Encoder) error {
11568 startIndex := len(encoder.Bytes())
11569 if err := self.BsnTlv.Serialize(encoder); err != nil {
11570 return err
11571 }
11572
11573 encoder.PutUint16(uint16(self.Value))
11574 length := len(encoder.Bytes()) - startIndex
11575
11576 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11577
11578 return nil
11579}
11580
11581func DecodeBsnTlvUdpSrc(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUdpSrc, error) {
11582 _bsntlvudpsrc := &BsnTlvUdpSrc{BsnTlv: parent}
11583 if decoder.Length() < 2 {
11584 return nil, fmt.Errorf("BsnTlvUdpSrc packet too short: %d < 2", decoder.Length())
11585 }
11586 _bsntlvudpsrc.Value = uint16(decoder.ReadUint16())
11587 return _bsntlvudpsrc, nil
11588}
11589
11590func NewBsnTlvUdpSrc() *BsnTlvUdpSrc {
11591 obj := &BsnTlvUdpSrc{
11592 BsnTlv: NewBsnTlv(36),
11593 }
11594 return obj
11595}
11596
11597type BsnTlvUint32 struct {
11598 *BsnTlv
11599 Value uint32
11600}
11601
11602type IBsnTlvUint32 interface {
11603 IBsnTlv
11604 GetValue() uint32
11605}
11606
11607func (self *BsnTlvUint32) GetValue() uint32 {
11608 return self.Value
11609}
11610
11611func (self *BsnTlvUint32) SetValue(v uint32) {
11612 self.Value = v
11613}
11614
11615func (self *BsnTlvUint32) Serialize(encoder *goloxi.Encoder) error {
11616 startIndex := len(encoder.Bytes())
11617 if err := self.BsnTlv.Serialize(encoder); err != nil {
11618 return err
11619 }
11620
11621 encoder.PutUint32(uint32(self.Value))
11622 length := len(encoder.Bytes()) - startIndex
11623
11624 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11625
11626 return nil
11627}
11628
11629func DecodeBsnTlvUint32(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUint32, error) {
11630 _bsntlvuint32 := &BsnTlvUint32{BsnTlv: parent}
11631 if decoder.Length() < 4 {
11632 return nil, fmt.Errorf("BsnTlvUint32 packet too short: %d < 4", decoder.Length())
11633 }
11634 _bsntlvuint32.Value = uint32(decoder.ReadUint32())
11635 return _bsntlvuint32, nil
11636}
11637
11638func NewBsnTlvUint32() *BsnTlvUint32 {
11639 obj := &BsnTlvUint32{
11640 BsnTlv: NewBsnTlv(167),
11641 }
11642 return obj
11643}
11644
11645type BsnTlvUint64List struct {
11646 *BsnTlv
11647 Value []*Uint64
11648}
11649
11650type IBsnTlvUint64List interface {
11651 IBsnTlv
11652 GetValue() []*Uint64
11653}
11654
11655func (self *BsnTlvUint64List) GetValue() []*Uint64 {
11656 return self.Value
11657}
11658
11659func (self *BsnTlvUint64List) SetValue(v []*Uint64) {
11660 self.Value = v
11661}
11662
11663func (self *BsnTlvUint64List) Serialize(encoder *goloxi.Encoder) error {
11664 startIndex := len(encoder.Bytes())
11665 if err := self.BsnTlv.Serialize(encoder); err != nil {
11666 return err
11667 }
11668
11669 for _, obj := range self.Value {
11670 if err := obj.Serialize(encoder); err != nil {
11671 return err
11672 }
11673 }
11674 length := len(encoder.Bytes()) - startIndex
11675
11676 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11677
11678 return nil
11679}
11680
11681func DecodeBsnTlvUint64List(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUint64List, error) {
11682 _bsntlvuint64list := &BsnTlvUint64List{BsnTlv: parent}
11683
11684 for decoder.Length() >= 8 {
11685 item, err := DecodeUint64(decoder)
11686 if err != nil {
11687 return nil, err
11688 }
11689 if item != nil {
11690 _bsntlvuint64list.Value = append(_bsntlvuint64list.Value, item)
11691 }
11692 }
11693 return _bsntlvuint64list, nil
11694}
11695
11696func NewBsnTlvUint64List() *BsnTlvUint64List {
11697 obj := &BsnTlvUint64List{
11698 BsnTlv: NewBsnTlv(119),
11699 }
11700 return obj
11701}
11702
11703type BsnTlvUnicastQueryTimeout struct {
11704 *BsnTlv
11705 Value uint32
11706}
11707
11708type IBsnTlvUnicastQueryTimeout interface {
11709 IBsnTlv
11710 GetValue() uint32
11711}
11712
11713func (self *BsnTlvUnicastQueryTimeout) GetValue() uint32 {
11714 return self.Value
11715}
11716
11717func (self *BsnTlvUnicastQueryTimeout) SetValue(v uint32) {
11718 self.Value = v
11719}
11720
11721func (self *BsnTlvUnicastQueryTimeout) Serialize(encoder *goloxi.Encoder) error {
11722 startIndex := len(encoder.Bytes())
11723 if err := self.BsnTlv.Serialize(encoder); err != nil {
11724 return err
11725 }
11726
11727 encoder.PutUint32(uint32(self.Value))
11728 length := len(encoder.Bytes()) - startIndex
11729
11730 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11731
11732 return nil
11733}
11734
11735func DecodeBsnTlvUnicastQueryTimeout(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUnicastQueryTimeout, error) {
11736 _bsntlvunicastquerytimeout := &BsnTlvUnicastQueryTimeout{BsnTlv: parent}
11737 if decoder.Length() < 4 {
11738 return nil, fmt.Errorf("BsnTlvUnicastQueryTimeout packet too short: %d < 4", decoder.Length())
11739 }
11740 _bsntlvunicastquerytimeout.Value = uint32(decoder.ReadUint32())
11741 return _bsntlvunicastquerytimeout, nil
11742}
11743
11744func NewBsnTlvUnicastQueryTimeout() *BsnTlvUnicastQueryTimeout {
11745 obj := &BsnTlvUnicastQueryTimeout{
11746 BsnTlv: NewBsnTlv(9),
11747 }
11748 return obj
11749}
11750
11751type BsnTlvUnicastRate struct {
11752 *BsnTlv
11753 Value uint32
11754}
11755
11756type IBsnTlvUnicastRate interface {
11757 IBsnTlv
11758 GetValue() uint32
11759}
11760
11761func (self *BsnTlvUnicastRate) GetValue() uint32 {
11762 return self.Value
11763}
11764
11765func (self *BsnTlvUnicastRate) SetValue(v uint32) {
11766 self.Value = v
11767}
11768
11769func (self *BsnTlvUnicastRate) Serialize(encoder *goloxi.Encoder) error {
11770 startIndex := len(encoder.Bytes())
11771 if err := self.BsnTlv.Serialize(encoder); err != nil {
11772 return err
11773 }
11774
11775 encoder.PutUint32(uint32(self.Value))
11776 length := len(encoder.Bytes()) - startIndex
11777
11778 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11779
11780 return nil
11781}
11782
11783func DecodeBsnTlvUnicastRate(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUnicastRate, error) {
11784 _bsntlvunicastrate := &BsnTlvUnicastRate{BsnTlv: parent}
11785 if decoder.Length() < 4 {
11786 return nil, fmt.Errorf("BsnTlvUnicastRate packet too short: %d < 4", decoder.Length())
11787 }
11788 _bsntlvunicastrate.Value = uint32(decoder.ReadUint32())
11789 return _bsntlvunicastrate, nil
11790}
11791
11792func NewBsnTlvUnicastRate() *BsnTlvUnicastRate {
11793 obj := &BsnTlvUnicastRate{
11794 BsnTlv: NewBsnTlv(93),
11795 }
11796 return obj
11797}
11798
11799type BsnTlvUnknownMulticastRate struct {
11800 *BsnTlv
11801 Value uint32
11802}
11803
11804type IBsnTlvUnknownMulticastRate interface {
11805 IBsnTlv
11806 GetValue() uint32
11807}
11808
11809func (self *BsnTlvUnknownMulticastRate) GetValue() uint32 {
11810 return self.Value
11811}
11812
11813func (self *BsnTlvUnknownMulticastRate) SetValue(v uint32) {
11814 self.Value = v
11815}
11816
11817func (self *BsnTlvUnknownMulticastRate) Serialize(encoder *goloxi.Encoder) error {
11818 startIndex := len(encoder.Bytes())
11819 if err := self.BsnTlv.Serialize(encoder); err != nil {
11820 return err
11821 }
11822
11823 encoder.PutUint32(uint32(self.Value))
11824 length := len(encoder.Bytes()) - startIndex
11825
11826 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11827
11828 return nil
11829}
11830
11831func DecodeBsnTlvUnknownMulticastRate(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUnknownMulticastRate, error) {
11832 _bsntlvunknownmulticastrate := &BsnTlvUnknownMulticastRate{BsnTlv: parent}
11833 if decoder.Length() < 4 {
11834 return nil, fmt.Errorf("BsnTlvUnknownMulticastRate packet too short: %d < 4", decoder.Length())
11835 }
11836 _bsntlvunknownmulticastrate.Value = uint32(decoder.ReadUint32())
11837 return _bsntlvunknownmulticastrate, nil
11838}
11839
11840func NewBsnTlvUnknownMulticastRate() *BsnTlvUnknownMulticastRate {
11841 obj := &BsnTlvUnknownMulticastRate{
11842 BsnTlv: NewBsnTlv(92),
11843 }
11844 return obj
11845}
11846
11847type BsnTlvUntagged struct {
11848 *BsnTlv
11849}
11850
11851type IBsnTlvUntagged interface {
11852 IBsnTlv
11853}
11854
11855func (self *BsnTlvUntagged) Serialize(encoder *goloxi.Encoder) error {
11856 startIndex := len(encoder.Bytes())
11857 if err := self.BsnTlv.Serialize(encoder); err != nil {
11858 return err
11859 }
11860 length := len(encoder.Bytes()) - startIndex
11861
11862 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11863
11864 return nil
11865}
11866
11867func DecodeBsnTlvUntagged(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUntagged, error) {
11868 _bsntlvuntagged := &BsnTlvUntagged{BsnTlv: parent}
11869 return _bsntlvuntagged, nil
11870}
11871
11872func NewBsnTlvUntagged() *BsnTlvUntagged {
11873 obj := &BsnTlvUntagged{
11874 BsnTlv: NewBsnTlv(106),
11875 }
11876 return obj
11877}
11878
11879type BsnTlvUpgrade struct {
11880 *BsnTlv
11881 Value BsnUpgrade
11882}
11883
11884type IBsnTlvUpgrade interface {
11885 IBsnTlv
11886 GetValue() BsnUpgrade
11887}
11888
11889func (self *BsnTlvUpgrade) GetValue() BsnUpgrade {
11890 return self.Value
11891}
11892
11893func (self *BsnTlvUpgrade) SetValue(v BsnUpgrade) {
11894 self.Value = v
11895}
11896
11897func (self *BsnTlvUpgrade) Serialize(encoder *goloxi.Encoder) error {
11898 startIndex := len(encoder.Bytes())
11899 if err := self.BsnTlv.Serialize(encoder); err != nil {
11900 return err
11901 }
11902
11903 encoder.PutUint16(uint16(self.Value))
11904 length := len(encoder.Bytes()) - startIndex
11905
11906 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11907
11908 return nil
11909}
11910
11911func DecodeBsnTlvUpgrade(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUpgrade, error) {
11912 _bsntlvupgrade := &BsnTlvUpgrade{BsnTlv: parent}
11913 if decoder.Length() < 2 {
11914 return nil, fmt.Errorf("BsnTlvUpgrade packet too short: %d < 2", decoder.Length())
11915 }
11916 _bsntlvupgrade.Value = BsnUpgrade(decoder.ReadUint16())
11917 return _bsntlvupgrade, nil
11918}
11919
11920func NewBsnTlvUpgrade() *BsnTlvUpgrade {
11921 obj := &BsnTlvUpgrade{
11922 BsnTlv: NewBsnTlv(164),
11923 }
11924 return obj
11925}
11926
11927type BsnTlvUriScheme struct {
11928 *BsnTlv
11929 Value []byte
11930}
11931
11932type IBsnTlvUriScheme interface {
11933 IBsnTlv
11934 GetValue() []byte
11935}
11936
11937func (self *BsnTlvUriScheme) GetValue() []byte {
11938 return self.Value
11939}
11940
11941func (self *BsnTlvUriScheme) SetValue(v []byte) {
11942 self.Value = v
11943}
11944
11945func (self *BsnTlvUriScheme) Serialize(encoder *goloxi.Encoder) error {
11946 startIndex := len(encoder.Bytes())
11947 if err := self.BsnTlv.Serialize(encoder); err != nil {
11948 return err
11949 }
11950
11951 encoder.Write(self.Value)
11952 length := len(encoder.Bytes()) - startIndex
11953
11954 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11955
11956 return nil
11957}
11958
11959func DecodeBsnTlvUriScheme(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUriScheme, error) {
11960 _bsntlvurischeme := &BsnTlvUriScheme{BsnTlv: parent}
11961 _bsntlvurischeme.Value = decoder.Read(int(decoder.Length()))
11962 return _bsntlvurischeme, nil
11963}
11964
11965func NewBsnTlvUriScheme() *BsnTlvUriScheme {
11966 obj := &BsnTlvUriScheme{
11967 BsnTlv: NewBsnTlv(153),
11968 }
11969 return obj
11970}
11971
11972type BsnTlvUsePacketState struct {
11973 *BsnTlv
11974 Value uint8
11975}
11976
11977type IBsnTlvUsePacketState interface {
11978 IBsnTlv
11979 GetValue() uint8
11980}
11981
11982func (self *BsnTlvUsePacketState) GetValue() uint8 {
11983 return self.Value
11984}
11985
11986func (self *BsnTlvUsePacketState) SetValue(v uint8) {
11987 self.Value = v
11988}
11989
11990func (self *BsnTlvUsePacketState) Serialize(encoder *goloxi.Encoder) error {
11991 startIndex := len(encoder.Bytes())
11992 if err := self.BsnTlv.Serialize(encoder); err != nil {
11993 return err
11994 }
11995
11996 encoder.PutUint8(uint8(self.Value))
11997 length := len(encoder.Bytes()) - startIndex
11998
11999 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
12000
12001 return nil
12002}
12003
12004func DecodeBsnTlvUsePacketState(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUsePacketState, error) {
12005 _bsntlvusepacketstate := &BsnTlvUsePacketState{BsnTlv: parent}
12006 if decoder.Length() < 1 {
12007 return nil, fmt.Errorf("BsnTlvUsePacketState packet too short: %d < 1", decoder.Length())
12008 }
12009 _bsntlvusepacketstate.Value = uint8(decoder.ReadByte())
12010 return _bsntlvusepacketstate, nil
12011}
12012
12013func NewBsnTlvUsePacketState() *BsnTlvUsePacketState {
12014 obj := &BsnTlvUsePacketState{
12015 BsnTlv: NewBsnTlv(96),
12016 }
12017 return obj
12018}
12019
12020type BsnTlvUserConfigured struct {
12021 *BsnTlv
12022}
12023
12024type IBsnTlvUserConfigured interface {
12025 IBsnTlv
12026}
12027
12028func (self *BsnTlvUserConfigured) Serialize(encoder *goloxi.Encoder) error {
12029 startIndex := len(encoder.Bytes())
12030 if err := self.BsnTlv.Serialize(encoder); err != nil {
12031 return err
12032 }
12033 length := len(encoder.Bytes()) - startIndex
12034
12035 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
12036
12037 return nil
12038}
12039
12040func DecodeBsnTlvUserConfigured(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUserConfigured, error) {
12041 _bsntlvuserconfigured := &BsnTlvUserConfigured{BsnTlv: parent}
12042 return _bsntlvuserconfigured, nil
12043}
12044
12045func NewBsnTlvUserConfigured() *BsnTlvUserConfigured {
12046 obj := &BsnTlvUserConfigured{
12047 BsnTlv: NewBsnTlv(166),
12048 }
12049 return obj
12050}
12051
12052type BsnTlvVfi struct {
12053 *BsnTlv
12054 Value uint16
12055}
12056
12057type IBsnTlvVfi interface {
12058 IBsnTlv
12059 GetValue() uint16
12060}
12061
12062func (self *BsnTlvVfi) GetValue() uint16 {
12063 return self.Value
12064}
12065
12066func (self *BsnTlvVfi) SetValue(v uint16) {
12067 self.Value = v
12068}
12069
12070func (self *BsnTlvVfi) Serialize(encoder *goloxi.Encoder) error {
12071 startIndex := len(encoder.Bytes())
12072 if err := self.BsnTlv.Serialize(encoder); err != nil {
12073 return err
12074 }
12075
12076 encoder.PutUint16(uint16(self.Value))
12077 length := len(encoder.Bytes()) - startIndex
12078
12079 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
12080
12081 return nil
12082}
12083
12084func DecodeBsnTlvVfi(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVfi, error) {
12085 _bsntlvvfi := &BsnTlvVfi{BsnTlv: parent}
12086 if decoder.Length() < 2 {
12087 return nil, fmt.Errorf("BsnTlvVfi packet too short: %d < 2", decoder.Length())
12088 }
12089 _bsntlvvfi.Value = uint16(decoder.ReadUint16())
12090 return _bsntlvvfi, nil
12091}
12092
12093func NewBsnTlvVfi() *BsnTlvVfi {
12094 obj := &BsnTlvVfi{
12095 BsnTlv: NewBsnTlv(99),
12096 }
12097 return obj
12098}
12099
12100type BsnTlvVfpClassId struct {
12101 *BsnTlv
12102 Value uint32
12103}
12104
12105type IBsnTlvVfpClassId interface {
12106 IBsnTlv
12107 GetValue() uint32
12108}
12109
12110func (self *BsnTlvVfpClassId) GetValue() uint32 {
12111 return self.Value
12112}
12113
12114func (self *BsnTlvVfpClassId) SetValue(v uint32) {
12115 self.Value = v
12116}
12117
12118func (self *BsnTlvVfpClassId) Serialize(encoder *goloxi.Encoder) error {
12119 startIndex := len(encoder.Bytes())
12120 if err := self.BsnTlv.Serialize(encoder); err != nil {
12121 return err
12122 }
12123
12124 encoder.PutUint32(uint32(self.Value))
12125 length := len(encoder.Bytes()) - startIndex
12126
12127 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
12128
12129 return nil
12130}
12131
12132func DecodeBsnTlvVfpClassId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVfpClassId, error) {
12133 _bsntlvvfpclassid := &BsnTlvVfpClassId{BsnTlv: parent}
12134 if decoder.Length() < 4 {
12135 return nil, fmt.Errorf("BsnTlvVfpClassId packet too short: %d < 4", decoder.Length())
12136 }
12137 _bsntlvvfpclassid.Value = uint32(decoder.ReadUint32())
12138 return _bsntlvvfpclassid, nil
12139}
12140
12141func NewBsnTlvVfpClassId() *BsnTlvVfpClassId {
12142 obj := &BsnTlvVfpClassId{
12143 BsnTlv: NewBsnTlv(107),
12144 }
12145 return obj
12146}
12147
12148type BsnTlvVirtual struct {
12149 *BsnTlv
12150}
12151
12152type IBsnTlvVirtual interface {
12153 IBsnTlv
12154}
12155
12156func (self *BsnTlvVirtual) Serialize(encoder *goloxi.Encoder) error {
12157 startIndex := len(encoder.Bytes())
12158 if err := self.BsnTlv.Serialize(encoder); err != nil {
12159 return err
12160 }
12161 length := len(encoder.Bytes()) - startIndex
12162
12163 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
12164
12165 return nil
12166}
12167
12168func DecodeBsnTlvVirtual(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVirtual, error) {
12169 _bsntlvvirtual := &BsnTlvVirtual{BsnTlv: parent}
12170 return _bsntlvvirtual, nil
12171}
12172
12173func NewBsnTlvVirtual() *BsnTlvVirtual {
12174 obj := &BsnTlvVirtual{
12175 BsnTlv: NewBsnTlv(158),
12176 }
12177 return obj
12178}
12179
12180type BsnTlvVlanMacList struct {
12181 *BsnTlv
12182 Key []*BsnVlanMac
12183}
12184
12185type IBsnTlvVlanMacList interface {
12186 IBsnTlv
12187 GetKey() []*BsnVlanMac
12188}
12189
12190func (self *BsnTlvVlanMacList) GetKey() []*BsnVlanMac {
12191 return self.Key
12192}
12193
12194func (self *BsnTlvVlanMacList) SetKey(v []*BsnVlanMac) {
12195 self.Key = v
12196}
12197
12198func (self *BsnTlvVlanMacList) Serialize(encoder *goloxi.Encoder) error {
12199 startIndex := len(encoder.Bytes())
12200 if err := self.BsnTlv.Serialize(encoder); err != nil {
12201 return err
12202 }
12203
12204 for _, obj := range self.Key {
12205 if err := obj.Serialize(encoder); err != nil {
12206 return err
12207 }
12208 }
12209 length := len(encoder.Bytes()) - startIndex
12210
12211 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
12212
12213 return nil
12214}
12215
12216func DecodeBsnTlvVlanMacList(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVlanMacList, error) {
12217 _bsntlvvlanmaclist := &BsnTlvVlanMacList{BsnTlv: parent}
12218
12219 for decoder.Length() >= 8 {
12220 item, err := DecodeBsnVlanMac(decoder)
12221 if err != nil {
12222 return nil, err
12223 }
12224 if item != nil {
12225 _bsntlvvlanmaclist.Key = append(_bsntlvvlanmaclist.Key, item)
12226 }
12227 }
12228 return _bsntlvvlanmaclist, nil
12229}
12230
12231func NewBsnTlvVlanMacList() *BsnTlvVlanMacList {
12232 obj := &BsnTlvVlanMacList{
12233 BsnTlv: NewBsnTlv(98),
12234 }
12235 return obj
12236}
12237
12238type BsnTlvVlanPcp struct {
12239 *BsnTlv
12240 Value uint8
12241}
12242
12243type IBsnTlvVlanPcp interface {
12244 IBsnTlv
12245 GetValue() uint8
12246}
12247
12248func (self *BsnTlvVlanPcp) GetValue() uint8 {
12249 return self.Value
12250}
12251
12252func (self *BsnTlvVlanPcp) SetValue(v uint8) {
12253 self.Value = v
12254}
12255
12256func (self *BsnTlvVlanPcp) Serialize(encoder *goloxi.Encoder) error {
12257 startIndex := len(encoder.Bytes())
12258 if err := self.BsnTlv.Serialize(encoder); err != nil {
12259 return err
12260 }
12261
12262 encoder.PutUint8(uint8(self.Value))
12263 length := len(encoder.Bytes()) - startIndex
12264
12265 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
12266
12267 return nil
12268}
12269
12270func DecodeBsnTlvVlanPcp(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVlanPcp, error) {
12271 _bsntlvvlanpcp := &BsnTlvVlanPcp{BsnTlv: parent}
12272 if decoder.Length() < 1 {
12273 return nil, fmt.Errorf("BsnTlvVlanPcp packet too short: %d < 1", decoder.Length())
12274 }
12275 _bsntlvvlanpcp.Value = uint8(decoder.ReadByte())
12276 return _bsntlvvlanpcp, nil
12277}
12278
12279func NewBsnTlvVlanPcp() *BsnTlvVlanPcp {
12280 obj := &BsnTlvVlanPcp{
12281 BsnTlv: NewBsnTlv(72),
12282 }
12283 return obj
12284}
12285
12286type BsnTlvVlanVid struct {
12287 *BsnTlv
12288 Value uint16
12289}
12290
12291type IBsnTlvVlanVid interface {
12292 IBsnTlv
12293 GetValue() uint16
12294}
12295
12296func (self *BsnTlvVlanVid) GetValue() uint16 {
12297 return self.Value
12298}
12299
12300func (self *BsnTlvVlanVid) SetValue(v uint16) {
12301 self.Value = v
12302}
12303
12304func (self *BsnTlvVlanVid) Serialize(encoder *goloxi.Encoder) error {
12305 startIndex := len(encoder.Bytes())
12306 if err := self.BsnTlv.Serialize(encoder); err != nil {
12307 return err
12308 }
12309
12310 encoder.PutUint16(uint16(self.Value))
12311 length := len(encoder.Bytes()) - startIndex
12312
12313 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
12314
12315 return nil
12316}
12317
12318func DecodeBsnTlvVlanVid(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVlanVid, error) {
12319 _bsntlvvlanvid := &BsnTlvVlanVid{BsnTlv: parent}
12320 if decoder.Length() < 2 {
12321 return nil, fmt.Errorf("BsnTlvVlanVid packet too short: %d < 2", decoder.Length())
12322 }
12323 _bsntlvvlanvid.Value = uint16(decoder.ReadUint16())
12324 return _bsntlvvlanvid, nil
12325}
12326
12327func NewBsnTlvVlanVid() *BsnTlvVlanVid {
12328 obj := &BsnTlvVlanVid{
12329 BsnTlv: NewBsnTlv(6),
12330 }
12331 return obj
12332}
12333
12334type BsnTlvVlanVidMask struct {
12335 *BsnTlv
12336 Value uint16
12337}
12338
12339type IBsnTlvVlanVidMask interface {
12340 IBsnTlv
12341 GetValue() uint16
12342}
12343
12344func (self *BsnTlvVlanVidMask) GetValue() uint16 {
12345 return self.Value
12346}
12347
12348func (self *BsnTlvVlanVidMask) SetValue(v uint16) {
12349 self.Value = v
12350}
12351
12352func (self *BsnTlvVlanVidMask) Serialize(encoder *goloxi.Encoder) error {
12353 startIndex := len(encoder.Bytes())
12354 if err := self.BsnTlv.Serialize(encoder); err != nil {
12355 return err
12356 }
12357
12358 encoder.PutUint16(uint16(self.Value))
12359 length := len(encoder.Bytes()) - startIndex
12360
12361 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
12362
12363 return nil
12364}
12365
12366func DecodeBsnTlvVlanVidMask(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVlanVidMask, error) {
12367 _bsntlvvlanvidmask := &BsnTlvVlanVidMask{BsnTlv: parent}
12368 if decoder.Length() < 2 {
12369 return nil, fmt.Errorf("BsnTlvVlanVidMask packet too short: %d < 2", decoder.Length())
12370 }
12371 _bsntlvvlanvidmask.Value = uint16(decoder.ReadUint16())
12372 return _bsntlvvlanvidmask, nil
12373}
12374
12375func NewBsnTlvVlanVidMask() *BsnTlvVlanVidMask {
12376 obj := &BsnTlvVlanVidMask{
12377 BsnTlv: NewBsnTlv(77),
12378 }
12379 return obj
12380}
12381
12382type BsnTlvVni struct {
12383 *BsnTlv
12384 Value uint32
12385}
12386
12387type IBsnTlvVni interface {
12388 IBsnTlv
12389 GetValue() uint32
12390}
12391
12392func (self *BsnTlvVni) GetValue() uint32 {
12393 return self.Value
12394}
12395
12396func (self *BsnTlvVni) SetValue(v uint32) {
12397 self.Value = v
12398}
12399
12400func (self *BsnTlvVni) Serialize(encoder *goloxi.Encoder) error {
12401 startIndex := len(encoder.Bytes())
12402 if err := self.BsnTlv.Serialize(encoder); err != nil {
12403 return err
12404 }
12405
12406 encoder.PutUint32(uint32(self.Value))
12407 length := len(encoder.Bytes()) - startIndex
12408
12409 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
12410
12411 return nil
12412}
12413
12414func DecodeBsnTlvVni(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVni, error) {
12415 _bsntlvvni := &BsnTlvVni{BsnTlv: parent}
12416 if decoder.Length() < 4 {
12417 return nil, fmt.Errorf("BsnTlvVni packet too short: %d < 4", decoder.Length())
12418 }
12419 _bsntlvvni.Value = uint32(decoder.ReadUint32())
12420 return _bsntlvvni, nil
12421}
12422
12423func NewBsnTlvVni() *BsnTlvVni {
12424 obj := &BsnTlvVni{
12425 BsnTlv: NewBsnTlv(86),
12426 }
12427 return obj
12428}
12429
12430type BsnTlvVpnKey struct {
12431 *BsnTlv
12432 Value uint32
12433}
12434
12435type IBsnTlvVpnKey interface {
12436 IBsnTlv
12437 GetValue() uint32
12438}
12439
12440func (self *BsnTlvVpnKey) GetValue() uint32 {
12441 return self.Value
12442}
12443
12444func (self *BsnTlvVpnKey) SetValue(v uint32) {
12445 self.Value = v
12446}
12447
12448func (self *BsnTlvVpnKey) Serialize(encoder *goloxi.Encoder) error {
12449 startIndex := len(encoder.Bytes())
12450 if err := self.BsnTlv.Serialize(encoder); err != nil {
12451 return err
12452 }
12453
12454 encoder.PutUint32(uint32(self.Value))
12455 length := len(encoder.Bytes()) - startIndex
12456
12457 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
12458
12459 return nil
12460}
12461
12462func DecodeBsnTlvVpnKey(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVpnKey, error) {
12463 _bsntlvvpnkey := &BsnTlvVpnKey{BsnTlv: parent}
12464 if decoder.Length() < 4 {
12465 return nil, fmt.Errorf("BsnTlvVpnKey packet too short: %d < 4", decoder.Length())
12466 }
12467 _bsntlvvpnkey.Value = uint32(decoder.ReadUint32())
12468 return _bsntlvvpnkey, nil
12469}
12470
12471func NewBsnTlvVpnKey() *BsnTlvVpnKey {
12472 obj := &BsnTlvVpnKey{
12473 BsnTlv: NewBsnTlv(111),
12474 }
12475 return obj
12476}
12477
12478type BsnTlvVrf struct {
12479 *BsnTlv
12480 Value uint32
12481}
12482
12483type IBsnTlvVrf interface {
12484 IBsnTlv
12485 GetValue() uint32
12486}
12487
12488func (self *BsnTlvVrf) GetValue() uint32 {
12489 return self.Value
12490}
12491
12492func (self *BsnTlvVrf) SetValue(v uint32) {
12493 self.Value = v
12494}
12495
12496func (self *BsnTlvVrf) Serialize(encoder *goloxi.Encoder) error {
12497 startIndex := len(encoder.Bytes())
12498 if err := self.BsnTlv.Serialize(encoder); err != nil {
12499 return err
12500 }
12501
12502 encoder.PutUint32(uint32(self.Value))
12503 length := len(encoder.Bytes()) - startIndex
12504
12505 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
12506
12507 return nil
12508}
12509
12510func DecodeBsnTlvVrf(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVrf, error) {
12511 _bsntlvvrf := &BsnTlvVrf{BsnTlv: parent}
12512 if decoder.Length() < 4 {
12513 return nil, fmt.Errorf("BsnTlvVrf packet too short: %d < 4", decoder.Length())
12514 }
12515 _bsntlvvrf.Value = uint32(decoder.ReadUint32())
12516 return _bsntlvvrf, nil
12517}
12518
12519func NewBsnTlvVrf() *BsnTlvVrf {
12520 obj := &BsnTlvVrf{
12521 BsnTlv: NewBsnTlv(19),
12522 }
12523 return obj
12524}
12525
12526type BsnTlvVxlanEgressLag struct {
12527 *BsnTlv
12528}
12529
12530type IBsnTlvVxlanEgressLag interface {
12531 IBsnTlv
12532}
12533
12534func (self *BsnTlvVxlanEgressLag) Serialize(encoder *goloxi.Encoder) error {
12535 startIndex := len(encoder.Bytes())
12536 if err := self.BsnTlv.Serialize(encoder); err != nil {
12537 return err
12538 }
12539 length := len(encoder.Bytes()) - startIndex
12540
12541 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
12542
12543 return nil
12544}
12545
12546func DecodeBsnTlvVxlanEgressLag(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVxlanEgressLag, error) {
12547 _bsntlvvxlanegresslag := &BsnTlvVxlanEgressLag{BsnTlv: parent}
12548 return _bsntlvvxlanegresslag, nil
12549}
12550
12551func NewBsnTlvVxlanEgressLag() *BsnTlvVxlanEgressLag {
12552 obj := &BsnTlvVxlanEgressLag{
12553 BsnTlv: NewBsnTlv(117),
12554 }
12555 return obj
12556}
12557
12558type BsnVport struct {
12559 Type uint16
12560 Length uint16
12561}
12562
12563type IBsnVport interface {
12564 goloxi.Serializable
12565 GetType() uint16
12566 GetLength() uint16
12567}
12568
12569func (self *BsnVport) GetType() uint16 {
12570 return self.Type
12571}
12572
12573func (self *BsnVport) SetType(v uint16) {
12574 self.Type = v
12575}
12576
12577func (self *BsnVport) GetLength() uint16 {
12578 return self.Length
12579}
12580
12581func (self *BsnVport) SetLength(v uint16) {
12582 self.Length = v
12583}
12584
12585func (self *BsnVport) Serialize(encoder *goloxi.Encoder) error {
12586
12587 encoder.PutUint16(uint16(self.Type))
12588 encoder.PutUint16(uint16(self.Length))
12589
12590 return nil
12591}
12592func (self *BsnVport) Decode(decoder *goloxi.Decoder) error {
12593 if decoder.Length() < 4 {
12594 return fmt.Errorf("BsnVport packet too short: %d < 4", decoder.Length())
12595 }
12596
12597 self.Type = uint16(decoder.ReadUint16())
12598 self.Length = uint16(decoder.ReadUint16())
12599 oldDecoder := decoder
12600 defer func() { decoder = oldDecoder }()
12601 decoder = decoder.SliceDecoder(int(self.Length), 2+2)
12602
12603 return nil
12604}
12605
12606func NewBsnVport(_type uint16) *BsnVport {
12607 obj := &BsnVport{}
12608 obj.Type = _type
12609 return obj
12610}
12611
12612type BsnVlanCounterStatsEntry struct {
12613 Length uint16
12614 VlanVid uint16
12615 Values []*Uint64
12616}
12617
12618type IBsnVlanCounterStatsEntry interface {
12619 goloxi.Serializable
12620 GetLength() uint16
12621 GetVlanVid() uint16
12622 GetValues() []*Uint64
12623}
12624
12625func (self *BsnVlanCounterStatsEntry) GetLength() uint16 {
12626 return self.Length
12627}
12628
12629func (self *BsnVlanCounterStatsEntry) SetLength(v uint16) {
12630 self.Length = v
12631}
12632
12633func (self *BsnVlanCounterStatsEntry) GetVlanVid() uint16 {
12634 return self.VlanVid
12635}
12636
12637func (self *BsnVlanCounterStatsEntry) SetVlanVid(v uint16) {
12638 self.VlanVid = v
12639}
12640
12641func (self *BsnVlanCounterStatsEntry) GetValues() []*Uint64 {
12642 return self.Values
12643}
12644
12645func (self *BsnVlanCounterStatsEntry) SetValues(v []*Uint64) {
12646 self.Values = v
12647}
12648
12649func (self *BsnVlanCounterStatsEntry) Serialize(encoder *goloxi.Encoder) error {
12650 startIndex := len(encoder.Bytes())
12651
12652 encoder.PutUint16(uint16(self.Length))
12653 encoder.PutUint16(uint16(self.VlanVid))
12654 encoder.Write(bytes.Repeat([]byte{0}, 4))
12655 for _, obj := range self.Values {
12656 if err := obj.Serialize(encoder); err != nil {
12657 return err
12658 }
12659 }
12660 length := len(encoder.Bytes()) - startIndex
12661
12662 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
12663
12664 return nil
12665}
12666
12667func DecodeBsnVlanCounterStatsEntry(decoder *goloxi.Decoder) (*BsnVlanCounterStatsEntry, error) {
12668 _bsnvlancounterstatsentry := &BsnVlanCounterStatsEntry{}
12669 if decoder.Length() < 8 {
12670 return nil, fmt.Errorf("BsnVlanCounterStatsEntry packet too short: %d < 8", decoder.Length())
12671 }
12672 _bsnvlancounterstatsentry.Length = uint16(decoder.ReadUint16())
12673 oldDecoder := decoder
12674 defer func() { decoder = oldDecoder }()
12675 decoder = decoder.SliceDecoder(int(_bsnvlancounterstatsentry.Length), 2+0)
12676 _bsnvlancounterstatsentry.VlanVid = uint16(decoder.ReadUint16())
12677 decoder.Skip(4)
12678
12679 for decoder.Length() >= 8 {
12680 item, err := DecodeUint64(decoder)
12681 if err != nil {
12682 return nil, err
12683 }
12684 if item != nil {
12685 _bsnvlancounterstatsentry.Values = append(_bsnvlancounterstatsentry.Values, item)
12686 }
12687 }
12688 return _bsnvlancounterstatsentry, nil
12689}
12690
12691func NewBsnVlanCounterStatsEntry() *BsnVlanCounterStatsEntry {
12692 obj := &BsnVlanCounterStatsEntry{}
12693 return obj
12694}
12695
12696type BsnVlanMac struct {
12697 VlanVid uint16
12698 Mac net.HardwareAddr
12699}
12700
12701type IBsnVlanMac interface {
12702 goloxi.Serializable
12703 GetVlanVid() uint16
12704 GetMac() net.HardwareAddr
12705}
12706
12707func (self *BsnVlanMac) GetVlanVid() uint16 {
12708 return self.VlanVid
12709}
12710
12711func (self *BsnVlanMac) SetVlanVid(v uint16) {
12712 self.VlanVid = v
12713}
12714
12715func (self *BsnVlanMac) GetMac() net.HardwareAddr {
12716 return self.Mac
12717}
12718
12719func (self *BsnVlanMac) SetMac(v net.HardwareAddr) {
12720 self.Mac = v
12721}
12722
12723func (self *BsnVlanMac) Serialize(encoder *goloxi.Encoder) error {
12724
12725 encoder.PutUint16(uint16(self.VlanVid))
12726 encoder.Write(self.Mac)
12727
12728 return nil
12729}
12730
12731func DecodeBsnVlanMac(decoder *goloxi.Decoder) (*BsnVlanMac, error) {
12732 _bsnvlanmac := &BsnVlanMac{}
12733 if decoder.Length() < 8 {
12734 return nil, fmt.Errorf("BsnVlanMac packet too short: %d < 8", decoder.Length())
12735 }
12736 _bsnvlanmac.VlanVid = uint16(decoder.ReadUint16())
12737 _bsnvlanmac.Mac = net.HardwareAddr(decoder.Read(6))
12738 return _bsnvlanmac, nil
12739}
12740
12741func NewBsnVlanMac() *BsnVlanMac {
12742 obj := &BsnVlanMac{}
12743 return obj
12744}
12745
12746type BsnVportL2Gre struct {
12747 *BsnVport
12748 Flags BsnVportL2GreFlags
12749 PortNo Port
12750 LoopbackPortNo Port
12751 LocalMac net.HardwareAddr
12752 NhMac net.HardwareAddr
12753 SrcIp net.IP
12754 DstIp net.IP
12755 Dscp uint8
12756 Ttl uint8
12757 Vpn uint32
12758 RateLimit uint32
12759 IfName string
12760}
12761
12762type IBsnVportL2Gre interface {
12763 IBsnVport
12764 GetFlags() BsnVportL2GreFlags
12765 GetPortNo() Port
12766 GetLoopbackPortNo() Port
12767 GetLocalMac() net.HardwareAddr
12768 GetNhMac() net.HardwareAddr
12769 GetSrcIp() net.IP
12770 GetDstIp() net.IP
12771 GetDscp() uint8
12772 GetTtl() uint8
12773 GetVpn() uint32
12774 GetRateLimit() uint32
12775 GetIfName() string
12776}
12777
12778func (self *BsnVportL2Gre) GetFlags() BsnVportL2GreFlags {
12779 return self.Flags
12780}
12781
12782func (self *BsnVportL2Gre) SetFlags(v BsnVportL2GreFlags) {
12783 self.Flags = v
12784}
12785
12786func (self *BsnVportL2Gre) GetPortNo() Port {
12787 return self.PortNo
12788}
12789
12790func (self *BsnVportL2Gre) SetPortNo(v Port) {
12791 self.PortNo = v
12792}
12793
12794func (self *BsnVportL2Gre) GetLoopbackPortNo() Port {
12795 return self.LoopbackPortNo
12796}
12797
12798func (self *BsnVportL2Gre) SetLoopbackPortNo(v Port) {
12799 self.LoopbackPortNo = v
12800}
12801
12802func (self *BsnVportL2Gre) GetLocalMac() net.HardwareAddr {
12803 return self.LocalMac
12804}
12805
12806func (self *BsnVportL2Gre) SetLocalMac(v net.HardwareAddr) {
12807 self.LocalMac = v
12808}
12809
12810func (self *BsnVportL2Gre) GetNhMac() net.HardwareAddr {
12811 return self.NhMac
12812}
12813
12814func (self *BsnVportL2Gre) SetNhMac(v net.HardwareAddr) {
12815 self.NhMac = v
12816}
12817
12818func (self *BsnVportL2Gre) GetSrcIp() net.IP {
12819 return self.SrcIp
12820}
12821
12822func (self *BsnVportL2Gre) SetSrcIp(v net.IP) {
12823 self.SrcIp = v
12824}
12825
12826func (self *BsnVportL2Gre) GetDstIp() net.IP {
12827 return self.DstIp
12828}
12829
12830func (self *BsnVportL2Gre) SetDstIp(v net.IP) {
12831 self.DstIp = v
12832}
12833
12834func (self *BsnVportL2Gre) GetDscp() uint8 {
12835 return self.Dscp
12836}
12837
12838func (self *BsnVportL2Gre) SetDscp(v uint8) {
12839 self.Dscp = v
12840}
12841
12842func (self *BsnVportL2Gre) GetTtl() uint8 {
12843 return self.Ttl
12844}
12845
12846func (self *BsnVportL2Gre) SetTtl(v uint8) {
12847 self.Ttl = v
12848}
12849
12850func (self *BsnVportL2Gre) GetVpn() uint32 {
12851 return self.Vpn
12852}
12853
12854func (self *BsnVportL2Gre) SetVpn(v uint32) {
12855 self.Vpn = v
12856}
12857
12858func (self *BsnVportL2Gre) GetRateLimit() uint32 {
12859 return self.RateLimit
12860}
12861
12862func (self *BsnVportL2Gre) SetRateLimit(v uint32) {
12863 self.RateLimit = v
12864}
12865
12866func (self *BsnVportL2Gre) GetIfName() string {
12867 return self.IfName
12868}
12869
12870func (self *BsnVportL2Gre) SetIfName(v string) {
12871 self.IfName = v
12872}
12873
12874func (self *BsnVportL2Gre) Serialize(encoder *goloxi.Encoder) error {
12875 startIndex := len(encoder.Bytes())
12876 if err := self.BsnVport.Serialize(encoder); err != nil {
12877 return err
12878 }
12879
12880 encoder.PutUint32(uint32(self.Flags))
12881 self.PortNo.Serialize(encoder)
12882 self.LoopbackPortNo.Serialize(encoder)
12883 encoder.Write(self.LocalMac)
12884 encoder.Write(self.NhMac)
12885 encoder.Write(self.SrcIp.To4())
12886 encoder.Write(self.DstIp.To4())
12887 encoder.PutUint8(uint8(self.Dscp))
12888 encoder.PutUint8(uint8(self.Ttl))
12889 encoder.Write(bytes.Repeat([]byte{0}, 2))
12890 encoder.PutUint32(uint32(self.Vpn))
12891 encoder.PutUint32(uint32(self.RateLimit))
12892 encoder.Write([]byte(self.IfName))
12893 length := len(encoder.Bytes()) - startIndex
12894
12895 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
12896
12897 return nil
12898}
12899
12900func DecodeBsnVportL2Gre(parent *BsnVport, decoder *goloxi.Decoder) (*BsnVportL2Gre, error) {
12901 _bsnvportl2gre := &BsnVportL2Gre{BsnVport: parent}
12902 if decoder.Length() < 60 {
12903 return nil, fmt.Errorf("BsnVportL2Gre packet too short: %d < 60", decoder.Length())
12904 }
12905 _bsnvportl2gre.Flags = BsnVportL2GreFlags(decoder.ReadUint32())
12906 _bsnvportl2gre.PortNo.Decode(decoder)
12907 _bsnvportl2gre.LoopbackPortNo.Decode(decoder)
12908 _bsnvportl2gre.LocalMac = net.HardwareAddr(decoder.Read(6))
12909 _bsnvportl2gre.NhMac = net.HardwareAddr(decoder.Read(6))
12910 _bsnvportl2gre.SrcIp = net.IP(decoder.Read(4))
12911 _bsnvportl2gre.DstIp = net.IP(decoder.Read(4))
12912 _bsnvportl2gre.Dscp = uint8(decoder.ReadByte())
12913 _bsnvportl2gre.Ttl = uint8(decoder.ReadByte())
12914 decoder.Skip(2)
12915 _bsnvportl2gre.Vpn = uint32(decoder.ReadUint32())
12916 _bsnvportl2gre.RateLimit = uint32(decoder.ReadUint32())
12917 _bsnvportl2gre.IfName = string(bytes.Trim(decoder.Read(16), "\x00"))
12918 return _bsnvportl2gre, nil
12919}
12920
12921func NewBsnVportL2Gre() *BsnVportL2Gre {
12922 obj := &BsnVportL2Gre{
12923 BsnVport: NewBsnVport(1),
12924 }
12925 return obj
12926}
12927
12928type BsnVportQInQ struct {
12929 *BsnVport
12930 PortNo uint32
12931 IngressTpid uint16
12932 IngressVlanId uint16
12933 EgressTpid uint16
12934 EgressVlanId uint16
12935 IfName string
12936}
12937
12938type IBsnVportQInQ interface {
12939 IBsnVport
12940 GetPortNo() uint32
12941 GetIngressTpid() uint16
12942 GetIngressVlanId() uint16
12943 GetEgressTpid() uint16
12944 GetEgressVlanId() uint16
12945 GetIfName() string
12946}
12947
12948func (self *BsnVportQInQ) GetPortNo() uint32 {
12949 return self.PortNo
12950}
12951
12952func (self *BsnVportQInQ) SetPortNo(v uint32) {
12953 self.PortNo = v
12954}
12955
12956func (self *BsnVportQInQ) GetIngressTpid() uint16 {
12957 return self.IngressTpid
12958}
12959
12960func (self *BsnVportQInQ) SetIngressTpid(v uint16) {
12961 self.IngressTpid = v
12962}
12963
12964func (self *BsnVportQInQ) GetIngressVlanId() uint16 {
12965 return self.IngressVlanId
12966}
12967
12968func (self *BsnVportQInQ) SetIngressVlanId(v uint16) {
12969 self.IngressVlanId = v
12970}
12971
12972func (self *BsnVportQInQ) GetEgressTpid() uint16 {
12973 return self.EgressTpid
12974}
12975
12976func (self *BsnVportQInQ) SetEgressTpid(v uint16) {
12977 self.EgressTpid = v
12978}
12979
12980func (self *BsnVportQInQ) GetEgressVlanId() uint16 {
12981 return self.EgressVlanId
12982}
12983
12984func (self *BsnVportQInQ) SetEgressVlanId(v uint16) {
12985 self.EgressVlanId = v
12986}
12987
12988func (self *BsnVportQInQ) GetIfName() string {
12989 return self.IfName
12990}
12991
12992func (self *BsnVportQInQ) SetIfName(v string) {
12993 self.IfName = v
12994}
12995
12996func (self *BsnVportQInQ) Serialize(encoder *goloxi.Encoder) error {
12997 startIndex := len(encoder.Bytes())
12998 if err := self.BsnVport.Serialize(encoder); err != nil {
12999 return err
13000 }
13001
13002 encoder.PutUint32(uint32(self.PortNo))
13003 encoder.PutUint16(uint16(self.IngressTpid))
13004 encoder.PutUint16(uint16(self.IngressVlanId))
13005 encoder.PutUint16(uint16(self.EgressTpid))
13006 encoder.PutUint16(uint16(self.EgressVlanId))
13007 encoder.Write([]byte(self.IfName))
13008 length := len(encoder.Bytes()) - startIndex
13009
13010 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
13011
13012 return nil
13013}
13014
13015func DecodeBsnVportQInQ(parent *BsnVport, decoder *goloxi.Decoder) (*BsnVportQInQ, error) {
13016 _bsnvportqinq := &BsnVportQInQ{BsnVport: parent}
13017 if decoder.Length() < 28 {
13018 return nil, fmt.Errorf("BsnVportQInQ packet too short: %d < 28", decoder.Length())
13019 }
13020 _bsnvportqinq.PortNo = uint32(decoder.ReadUint32())
13021 _bsnvportqinq.IngressTpid = uint16(decoder.ReadUint16())
13022 _bsnvportqinq.IngressVlanId = uint16(decoder.ReadUint16())
13023 _bsnvportqinq.EgressTpid = uint16(decoder.ReadUint16())
13024 _bsnvportqinq.EgressVlanId = uint16(decoder.ReadUint16())
13025 _bsnvportqinq.IfName = string(bytes.Trim(decoder.Read(16), "\x00"))
13026 return _bsnvportqinq, nil
13027}
13028
13029func NewBsnVportQInQ() *BsnVportQInQ {
13030 obj := &BsnVportQInQ{
13031 BsnVport: NewBsnVport(0),
13032 }
13033 return obj
13034}
13035
13036type BsnVrfCounterStatsEntry struct {
13037 Length uint16
13038 Vrf uint32
13039 Values []*Uint64
13040}
13041
13042type IBsnVrfCounterStatsEntry interface {
13043 goloxi.Serializable
13044 GetLength() uint16
13045 GetVrf() uint32
13046 GetValues() []*Uint64
13047}
13048
13049func (self *BsnVrfCounterStatsEntry) GetLength() uint16 {
13050 return self.Length
13051}
13052
13053func (self *BsnVrfCounterStatsEntry) SetLength(v uint16) {
13054 self.Length = v
13055}
13056
13057func (self *BsnVrfCounterStatsEntry) GetVrf() uint32 {
13058 return self.Vrf
13059}
13060
13061func (self *BsnVrfCounterStatsEntry) SetVrf(v uint32) {
13062 self.Vrf = v
13063}
13064
13065func (self *BsnVrfCounterStatsEntry) GetValues() []*Uint64 {
13066 return self.Values
13067}
13068
13069func (self *BsnVrfCounterStatsEntry) SetValues(v []*Uint64) {
13070 self.Values = v
13071}
13072
13073func (self *BsnVrfCounterStatsEntry) Serialize(encoder *goloxi.Encoder) error {
13074 startIndex := len(encoder.Bytes())
13075
13076 encoder.PutUint16(uint16(self.Length))
13077 encoder.Write(bytes.Repeat([]byte{0}, 2))
13078 encoder.PutUint32(uint32(self.Vrf))
13079 for _, obj := range self.Values {
13080 if err := obj.Serialize(encoder); err != nil {
13081 return err
13082 }
13083 }
13084 length := len(encoder.Bytes()) - startIndex
13085
13086 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
13087
13088 return nil
13089}
13090
13091func DecodeBsnVrfCounterStatsEntry(decoder *goloxi.Decoder) (*BsnVrfCounterStatsEntry, error) {
13092 _bsnvrfcounterstatsentry := &BsnVrfCounterStatsEntry{}
13093 if decoder.Length() < 8 {
13094 return nil, fmt.Errorf("BsnVrfCounterStatsEntry packet too short: %d < 8", decoder.Length())
13095 }
13096 _bsnvrfcounterstatsentry.Length = uint16(decoder.ReadUint16())
13097 oldDecoder := decoder
13098 defer func() { decoder = oldDecoder }()
13099 decoder = decoder.SliceDecoder(int(_bsnvrfcounterstatsentry.Length), 2+0)
13100 decoder.Skip(2)
13101 _bsnvrfcounterstatsentry.Vrf = uint32(decoder.ReadUint32())
13102
13103 for decoder.Length() >= 8 {
13104 item, err := DecodeUint64(decoder)
13105 if err != nil {
13106 return nil, err
13107 }
13108 if item != nil {
13109 _bsnvrfcounterstatsentry.Values = append(_bsnvrfcounterstatsentry.Values, item)
13110 }
13111 }
13112 return _bsnvrfcounterstatsentry, nil
13113}
13114
13115func NewBsnVrfCounterStatsEntry() *BsnVrfCounterStatsEntry {
13116 obj := &BsnVrfCounterStatsEntry{}
13117 return obj
13118}
13119
13120type Bucket struct {
13121 Len uint16
13122 ActionArrayLen uint16
13123 BucketId GroupBucket
13124 Actions []goloxi.IAction
13125 Properties []IGroupBucketProp
13126}
13127
13128type IBucket interface {
13129 goloxi.Serializable
13130 GetLen() uint16
13131 GetActionArrayLen() uint16
13132 GetBucketId() GroupBucket
13133 GetActions() []goloxi.IAction
13134 GetProperties() []IGroupBucketProp
13135}
13136
13137func (self *Bucket) GetLen() uint16 {
13138 return self.Len
13139}
13140
13141func (self *Bucket) SetLen(v uint16) {
13142 self.Len = v
13143}
13144
13145func (self *Bucket) GetActionArrayLen() uint16 {
13146 return self.ActionArrayLen
13147}
13148
13149func (self *Bucket) SetActionArrayLen(v uint16) {
13150 self.ActionArrayLen = v
13151}
13152
13153func (self *Bucket) GetBucketId() GroupBucket {
13154 return self.BucketId
13155}
13156
13157func (self *Bucket) SetBucketId(v GroupBucket) {
13158 self.BucketId = v
13159}
13160
13161func (self *Bucket) GetActions() []goloxi.IAction {
13162 return self.Actions
13163}
13164
13165func (self *Bucket) SetActions(v []goloxi.IAction) {
13166 self.Actions = v
13167}
13168
13169func (self *Bucket) GetProperties() []IGroupBucketProp {
13170 return self.Properties
13171}
13172
13173func (self *Bucket) SetProperties(v []IGroupBucketProp) {
13174 self.Properties = v
13175}
13176
13177func (self *Bucket) Serialize(encoder *goloxi.Encoder) error {
13178 startIndex := len(encoder.Bytes())
13179
13180 encoder.PutUint16(uint16(self.Len))
13181 encoder.PutUint16(uint16(self.ActionArrayLen))
13182 encoder.PutUint32(uint32(self.BucketId))
13183 for _, obj := range self.Actions {
13184 if err := obj.Serialize(encoder); err != nil {
13185 return err
13186 }
13187 }
13188 for _, obj := range self.Properties {
13189 if err := obj.Serialize(encoder); err != nil {
13190 return err
13191 }
13192 }
13193 length := len(encoder.Bytes()) - startIndex
13194
13195 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
13196
13197 return nil
13198}
13199
13200func DecodeBucket(decoder *goloxi.Decoder) (*Bucket, error) {
13201 _bucket := &Bucket{}
13202 if decoder.Length() < 8 {
13203 return nil, fmt.Errorf("Bucket packet too short: %d < 8", decoder.Length())
13204 }
13205 _bucket.Len = uint16(decoder.ReadUint16())
13206 oldDecoder := decoder
13207 defer func() { decoder = oldDecoder }()
13208 decoder = decoder.SliceDecoder(int(_bucket.Len), 2+0)
13209 _bucket.ActionArrayLen = uint16(decoder.ReadUint16())
13210 _bucket.BucketId = GroupBucket(decoder.ReadUint32())
13211
13212 end := decoder.Offset() + int(_bucket.ActionArrayLen)
13213 for decoder.Offset() < end {
13214 item, err := DecodeAction(decoder)
13215 if err != nil {
13216 return nil, err
13217 }
13218 if item != nil {
13219 _bucket.Actions = append(_bucket.Actions, item)
13220 }
13221 }
13222
13223 for decoder.Length() >= 4 {
13224 item, err := DecodeGroupBucketProp(decoder)
13225 if err != nil {
13226 return nil, err
13227 }
13228 if item != nil {
13229 _bucket.Properties = append(_bucket.Properties, item)
13230 }
13231 }
13232 return _bucket, nil
13233}
13234
13235func NewBucket() *Bucket {
13236 obj := &Bucket{}
13237 return obj
13238}
13239
13240type BucketCounter struct {
13241 PacketCount uint64
13242 ByteCount uint64
13243}
13244
13245type IBucketCounter interface {
13246 goloxi.Serializable
13247 GetPacketCount() uint64
13248 GetByteCount() uint64
13249}
13250
13251func (self *BucketCounter) GetPacketCount() uint64 {
13252 return self.PacketCount
13253}
13254
13255func (self *BucketCounter) SetPacketCount(v uint64) {
13256 self.PacketCount = v
13257}
13258
13259func (self *BucketCounter) GetByteCount() uint64 {
13260 return self.ByteCount
13261}
13262
13263func (self *BucketCounter) SetByteCount(v uint64) {
13264 self.ByteCount = v
13265}
13266
13267func (self *BucketCounter) Serialize(encoder *goloxi.Encoder) error {
13268
13269 encoder.PutUint64(uint64(self.PacketCount))
13270 encoder.PutUint64(uint64(self.ByteCount))
13271
13272 return nil
13273}
13274
13275func DecodeBucketCounter(decoder *goloxi.Decoder) (*BucketCounter, error) {
13276 _bucketcounter := &BucketCounter{}
13277 if decoder.Length() < 16 {
13278 return nil, fmt.Errorf("BucketCounter packet too short: %d < 16", decoder.Length())
13279 }
13280 _bucketcounter.PacketCount = uint64(decoder.ReadUint64())
13281 _bucketcounter.ByteCount = uint64(decoder.ReadUint64())
13282 return _bucketcounter, nil
13283}
13284
13285func NewBucketCounter() *BucketCounter {
13286 obj := &BucketCounter{}
13287 return obj
13288}
13289
13290type BundleFeaturesProp struct {
13291 Type uint16
13292 Length uint16
13293}
13294
13295type IBundleFeaturesProp interface {
13296 goloxi.Serializable
13297 GetType() uint16
13298 GetLength() uint16
13299}
13300
13301func (self *BundleFeaturesProp) GetType() uint16 {
13302 return self.Type
13303}
13304
13305func (self *BundleFeaturesProp) SetType(v uint16) {
13306 self.Type = v
13307}
13308
13309func (self *BundleFeaturesProp) GetLength() uint16 {
13310 return self.Length
13311}
13312
13313func (self *BundleFeaturesProp) SetLength(v uint16) {
13314 self.Length = v
13315}
13316
13317func (self *BundleFeaturesProp) Serialize(encoder *goloxi.Encoder) error {
13318
13319 encoder.PutUint16(uint16(self.Type))
13320 encoder.PutUint16(uint16(self.Length))
13321
13322 return nil
13323}
13324
13325func DecodeBundleFeaturesProp(decoder *goloxi.Decoder) (IBundleFeaturesProp, error) {
13326 _bundlefeaturesprop := &BundleFeaturesProp{}
13327 if decoder.Length() < 4 {
13328 return nil, fmt.Errorf("BundleFeaturesProp packet too short: %d < 4", decoder.Length())
13329 }
13330 _bundlefeaturesprop.Type = uint16(decoder.ReadUint16())
13331 _bundlefeaturesprop.Length = uint16(decoder.ReadUint16())
13332 oldDecoder := decoder
13333 defer func() { decoder = oldDecoder }()
13334 decoder = decoder.SliceDecoder(int(_bundlefeaturesprop.Length), 2+2)
13335
13336 switch _bundlefeaturesprop.Type {
13337 case 1:
13338 return DecodeBundleFeaturesPropTime(_bundlefeaturesprop, decoder)
13339 default:
13340 return nil, fmt.Errorf("Invalid type '%d' for 'BundleFeaturesProp'", _bundlefeaturesprop.Type)
13341 }
13342}
13343
13344func NewBundleFeaturesProp(_type uint16) *BundleFeaturesProp {
13345 obj := &BundleFeaturesProp{}
13346 obj.Type = _type
13347 return obj
13348}
13349
13350type Time struct {
13351 Seconds uint64
13352 Nanoseconds uint32
13353}
13354
13355type ITime interface {
13356 goloxi.Serializable
13357 GetSeconds() uint64
13358 GetNanoseconds() uint32
13359}
13360
13361func (self *Time) GetSeconds() uint64 {
13362 return self.Seconds
13363}
13364
13365func (self *Time) SetSeconds(v uint64) {
13366 self.Seconds = v
13367}
13368
13369func (self *Time) GetNanoseconds() uint32 {
13370 return self.Nanoseconds
13371}
13372
13373func (self *Time) SetNanoseconds(v uint32) {
13374 self.Nanoseconds = v
13375}
13376
13377func (self *Time) Serialize(encoder *goloxi.Encoder) error {
13378
13379 encoder.PutUint64(uint64(self.Seconds))
13380 encoder.PutUint32(uint32(self.Nanoseconds))
13381 encoder.Write(bytes.Repeat([]byte{0}, 4))
13382
13383 return nil
13384}
13385
13386func DecodeTime(decoder *goloxi.Decoder) (*Time, error) {
13387 _time := &Time{}
13388 if decoder.Length() < 16 {
13389 return nil, fmt.Errorf("Time packet too short: %d < 16", decoder.Length())
13390 }
13391 _time.Seconds = uint64(decoder.ReadUint64())
13392 _time.Nanoseconds = uint32(decoder.ReadUint32())
13393 decoder.Skip(4)
13394 return _time, nil
13395}
13396
13397func NewTime() *Time {
13398 obj := &Time{}
13399 return obj
13400}
13401
13402type BundleFeaturesPropTime struct {
13403 *BundleFeaturesProp
13404 SchedAccuracy *Time
13405 SchedMaxFuture *Time
13406 SchedMaxPast *Time
13407 Timestamp *Time
13408}
13409
13410type IBundleFeaturesPropTime interface {
13411 IBundleFeaturesProp
13412 GetSchedAccuracy() *Time
13413 GetSchedMaxFuture() *Time
13414 GetSchedMaxPast() *Time
13415 GetTimestamp() *Time
13416}
13417
13418func (self *BundleFeaturesPropTime) GetSchedAccuracy() *Time {
13419 return self.SchedAccuracy
13420}
13421
13422func (self *BundleFeaturesPropTime) SetSchedAccuracy(v *Time) {
13423 self.SchedAccuracy = v
13424}
13425
13426func (self *BundleFeaturesPropTime) GetSchedMaxFuture() *Time {
13427 return self.SchedMaxFuture
13428}
13429
13430func (self *BundleFeaturesPropTime) SetSchedMaxFuture(v *Time) {
13431 self.SchedMaxFuture = v
13432}
13433
13434func (self *BundleFeaturesPropTime) GetSchedMaxPast() *Time {
13435 return self.SchedMaxPast
13436}
13437
13438func (self *BundleFeaturesPropTime) SetSchedMaxPast(v *Time) {
13439 self.SchedMaxPast = v
13440}
13441
13442func (self *BundleFeaturesPropTime) GetTimestamp() *Time {
13443 return self.Timestamp
13444}
13445
13446func (self *BundleFeaturesPropTime) SetTimestamp(v *Time) {
13447 self.Timestamp = v
13448}
13449
13450func (self *BundleFeaturesPropTime) Serialize(encoder *goloxi.Encoder) error {
13451 startIndex := len(encoder.Bytes())
13452 if err := self.BundleFeaturesProp.Serialize(encoder); err != nil {
13453 return err
13454 }
13455
13456 encoder.Write(bytes.Repeat([]byte{0}, 4))
13457 self.SchedAccuracy.Serialize(encoder)
13458 self.SchedMaxFuture.Serialize(encoder)
13459 self.SchedMaxPast.Serialize(encoder)
13460 self.Timestamp.Serialize(encoder)
13461 length := len(encoder.Bytes()) - startIndex
13462
13463 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
13464
13465 return nil
13466}
13467
13468func DecodeBundleFeaturesPropTime(parent *BundleFeaturesProp, decoder *goloxi.Decoder) (*BundleFeaturesPropTime, error) {
13469 _bundlefeaturesproptime := &BundleFeaturesPropTime{BundleFeaturesProp: parent}
13470 if decoder.Length() < 68 {
13471 return nil, fmt.Errorf("BundleFeaturesPropTime packet too short: %d < 68", decoder.Length())
13472 }
13473 decoder.Skip(4)
13474 if obj, err := DecodeTime(decoder); err != nil {
13475 return nil, err
13476 } else {
13477 _bundlefeaturesproptime.SchedAccuracy = obj
13478 }
13479
13480 if obj, err := DecodeTime(decoder); err != nil {
13481 return nil, err
13482 } else {
13483 _bundlefeaturesproptime.SchedMaxFuture = obj
13484 }
13485
13486 if obj, err := DecodeTime(decoder); err != nil {
13487 return nil, err
13488 } else {
13489 _bundlefeaturesproptime.SchedMaxPast = obj
13490 }
13491
13492 if obj, err := DecodeTime(decoder); err != nil {
13493 return nil, err
13494 } else {
13495 _bundlefeaturesproptime.Timestamp = obj
13496 }
13497
13498 return _bundlefeaturesproptime, nil
13499}
13500
13501func NewBundleFeaturesPropTime() *BundleFeaturesPropTime {
13502 obj := &BundleFeaturesPropTime{
13503 BundleFeaturesProp: NewBundleFeaturesProp(1),
13504 }
13505 return obj
13506}
13507
13508type BundleProp struct {
13509 Type uint16
13510 Length uint16
13511}
13512
13513type IBundleProp interface {
13514 goloxi.Serializable
13515 GetType() uint16
13516 GetLength() uint16
13517}
13518
13519func (self *BundleProp) GetType() uint16 {
13520 return self.Type
13521}
13522
13523func (self *BundleProp) SetType(v uint16) {
13524 self.Type = v
13525}
13526
13527func (self *BundleProp) GetLength() uint16 {
13528 return self.Length
13529}
13530
13531func (self *BundleProp) SetLength(v uint16) {
13532 self.Length = v
13533}
13534
13535func (self *BundleProp) Serialize(encoder *goloxi.Encoder) error {
13536
13537 encoder.PutUint16(uint16(self.Type))
13538 encoder.PutUint16(uint16(self.Length))
13539
13540 return nil
13541}
13542
13543func DecodeBundleProp(decoder *goloxi.Decoder) (IBundleProp, error) {
13544 _bundleprop := &BundleProp{}
13545 if decoder.Length() < 4 {
13546 return nil, fmt.Errorf("BundleProp packet too short: %d < 4", decoder.Length())
13547 }
13548 _bundleprop.Type = uint16(decoder.ReadUint16())
13549 _bundleprop.Length = uint16(decoder.ReadUint16())
13550 oldDecoder := decoder
13551 defer func() { decoder = oldDecoder }()
13552 decoder = decoder.SliceDecoder(int(_bundleprop.Length), 2+2)
13553
13554 switch _bundleprop.Type {
13555 case 1:
13556 return DecodeBundlePropTime(_bundleprop, decoder)
13557 case 65535:
13558 return DecodeBundlePropExperimenter(_bundleprop, decoder)
13559 default:
13560 return nil, fmt.Errorf("Invalid type '%d' for 'BundleProp'", _bundleprop.Type)
13561 }
13562}
13563
13564func NewBundleProp(_type uint16) *BundleProp {
13565 obj := &BundleProp{}
13566 obj.Type = _type
13567 return obj
13568}
13569
13570type BundlePropExperimenter struct {
13571 *BundleProp
13572 Experimenter uint32
13573 ExpType uint32
13574}
13575
13576type IBundlePropExperimenter interface {
13577 IBundleProp
13578 GetExperimenter() uint32
13579 GetExpType() uint32
13580}
13581
13582func (self *BundlePropExperimenter) GetExperimenter() uint32 {
13583 return self.Experimenter
13584}
13585
13586func (self *BundlePropExperimenter) SetExperimenter(v uint32) {
13587 self.Experimenter = v
13588}
13589
13590func (self *BundlePropExperimenter) GetExpType() uint32 {
13591 return self.ExpType
13592}
13593
13594func (self *BundlePropExperimenter) SetExpType(v uint32) {
13595 self.ExpType = v
13596}
13597
13598func (self *BundlePropExperimenter) Serialize(encoder *goloxi.Encoder) error {
13599 if err := self.BundleProp.Serialize(encoder); err != nil {
13600 return err
13601 }
13602
13603 encoder.PutUint32(uint32(self.Experimenter))
13604 encoder.PutUint32(uint32(self.ExpType))
13605
13606 return nil
13607}
13608
13609func DecodeBundlePropExperimenter(parent *BundleProp, decoder *goloxi.Decoder) (IBundlePropExperimenter, error) {
13610 _bundlepropexperimenter := &BundlePropExperimenter{BundleProp: parent}
13611 if decoder.Length() < 8 {
13612 return nil, fmt.Errorf("BundlePropExperimenter packet too short: %d < 8", decoder.Length())
13613 }
13614 _bundlepropexperimenter.Experimenter = uint32(decoder.ReadUint32())
13615 _bundlepropexperimenter.ExpType = uint32(decoder.ReadUint32())
13616 return _bundlepropexperimenter, nil
13617}
13618
13619func NewBundlePropExperimenter(_experimenter uint32) *BundlePropExperimenter {
13620 obj := &BundlePropExperimenter{
13621 BundleProp: NewBundleProp(65535),
13622 }
13623 obj.Experimenter = _experimenter
13624 return obj
13625}
13626
13627type BundlePropTime struct {
13628 *BundleProp
13629 ScheduledTime []*Time
13630}
13631
13632type IBundlePropTime interface {
13633 IBundleProp
13634 GetScheduledTime() []*Time
13635}
13636
13637func (self *BundlePropTime) GetScheduledTime() []*Time {
13638 return self.ScheduledTime
13639}
13640
13641func (self *BundlePropTime) SetScheduledTime(v []*Time) {
13642 self.ScheduledTime = v
13643}
13644
13645func (self *BundlePropTime) Serialize(encoder *goloxi.Encoder) error {
13646 startIndex := len(encoder.Bytes())
13647 if err := self.BundleProp.Serialize(encoder); err != nil {
13648 return err
13649 }
13650
13651 encoder.Write(bytes.Repeat([]byte{0}, 4))
13652 for _, obj := range self.ScheduledTime {
13653 if err := obj.Serialize(encoder); err != nil {
13654 return err
13655 }
13656 }
13657 length := len(encoder.Bytes()) - startIndex
13658
13659 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
13660
13661 return nil
13662}
13663
13664func DecodeBundlePropTime(parent *BundleProp, decoder *goloxi.Decoder) (*BundlePropTime, error) {
13665 _bundleproptime := &BundlePropTime{BundleProp: parent}
13666 if decoder.Length() < 4 {
13667 return nil, fmt.Errorf("BundlePropTime packet too short: %d < 4", decoder.Length())
13668 }
13669 decoder.Skip(4)
13670
13671 for decoder.Length() >= 16 {
13672 item, err := DecodeTime(decoder)
13673 if err != nil {
13674 return nil, err
13675 }
13676 if item != nil {
13677 _bundleproptime.ScheduledTime = append(_bundleproptime.ScheduledTime, item)
13678 }
13679 }
13680 return _bundleproptime, nil
13681}
13682
13683func NewBundlePropTime() *BundlePropTime {
13684 obj := &BundlePropTime{
13685 BundleProp: NewBundleProp(1),
13686 }
13687 return obj
13688}
13689
13690type ControllerStatusEntry struct {
13691 Length uint16
13692 ShortId uint16
13693 Role ControllerRole
13694 Reason ControllerStatusReason
13695 ChannelStatus ControlChannelStatus
13696 Properties []IControllerStatusProp
13697}
13698
13699type IControllerStatusEntry interface {
13700 goloxi.Serializable
13701 GetLength() uint16
13702 GetShortId() uint16
13703 GetRole() ControllerRole
13704 GetReason() ControllerStatusReason
13705 GetChannelStatus() ControlChannelStatus
13706 GetProperties() []IControllerStatusProp
13707}
13708
13709func (self *ControllerStatusEntry) GetLength() uint16 {
13710 return self.Length
13711}
13712
13713func (self *ControllerStatusEntry) SetLength(v uint16) {
13714 self.Length = v
13715}
13716
13717func (self *ControllerStatusEntry) GetShortId() uint16 {
13718 return self.ShortId
13719}
13720
13721func (self *ControllerStatusEntry) SetShortId(v uint16) {
13722 self.ShortId = v
13723}
13724
13725func (self *ControllerStatusEntry) GetRole() ControllerRole {
13726 return self.Role
13727}
13728
13729func (self *ControllerStatusEntry) SetRole(v ControllerRole) {
13730 self.Role = v
13731}
13732
13733func (self *ControllerStatusEntry) GetReason() ControllerStatusReason {
13734 return self.Reason
13735}
13736
13737func (self *ControllerStatusEntry) SetReason(v ControllerStatusReason) {
13738 self.Reason = v
13739}
13740
13741func (self *ControllerStatusEntry) GetChannelStatus() ControlChannelStatus {
13742 return self.ChannelStatus
13743}
13744
13745func (self *ControllerStatusEntry) SetChannelStatus(v ControlChannelStatus) {
13746 self.ChannelStatus = v
13747}
13748
13749func (self *ControllerStatusEntry) GetProperties() []IControllerStatusProp {
13750 return self.Properties
13751}
13752
13753func (self *ControllerStatusEntry) SetProperties(v []IControllerStatusProp) {
13754 self.Properties = v
13755}
13756
13757func (self *ControllerStatusEntry) Serialize(encoder *goloxi.Encoder) error {
13758 startIndex := len(encoder.Bytes())
13759
13760 encoder.PutUint16(uint16(self.Length))
13761 encoder.PutUint16(uint16(self.ShortId))
13762 encoder.PutUint32(uint32(self.Role))
13763 encoder.PutUint8(uint8(self.Reason))
13764 encoder.PutUint8(uint8(self.ChannelStatus))
13765 encoder.Write(bytes.Repeat([]byte{0}, 6))
13766 for _, obj := range self.Properties {
13767 if err := obj.Serialize(encoder); err != nil {
13768 return err
13769 }
13770 }
13771 length := len(encoder.Bytes()) - startIndex
13772
13773 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
13774
13775 return nil
13776}
13777
13778func DecodeControllerStatusEntry(decoder *goloxi.Decoder) (*ControllerStatusEntry, error) {
13779 _controllerstatusentry := &ControllerStatusEntry{}
13780 if decoder.Length() < 16 {
13781 return nil, fmt.Errorf("ControllerStatusEntry packet too short: %d < 16", decoder.Length())
13782 }
13783 _controllerstatusentry.Length = uint16(decoder.ReadUint16())
13784 oldDecoder := decoder
13785 defer func() { decoder = oldDecoder }()
13786 decoder = decoder.SliceDecoder(int(_controllerstatusentry.Length), 2+0)
13787 _controllerstatusentry.ShortId = uint16(decoder.ReadUint16())
13788 _controllerstatusentry.Role = ControllerRole(decoder.ReadUint32())
13789 _controllerstatusentry.Reason = ControllerStatusReason(decoder.ReadByte())
13790 _controllerstatusentry.ChannelStatus = ControlChannelStatus(decoder.ReadByte())
13791 decoder.Skip(6)
13792
13793 for decoder.Length() >= 4 {
13794 item, err := DecodeControllerStatusProp(decoder)
13795 if err != nil {
13796 return nil, err
13797 }
13798 if item != nil {
13799 _controllerstatusentry.Properties = append(_controllerstatusentry.Properties, item)
13800 }
13801 }
13802 return _controllerstatusentry, nil
13803}
13804
13805func NewControllerStatusEntry() *ControllerStatusEntry {
13806 obj := &ControllerStatusEntry{}
13807 return obj
13808}
13809
13810type ControllerStatusProp struct {
13811 Type uint16
13812 Length uint16
13813}
13814
13815type IControllerStatusProp interface {
13816 goloxi.Serializable
13817 GetType() uint16
13818 GetLength() uint16
13819}
13820
13821func (self *ControllerStatusProp) GetType() uint16 {
13822 return self.Type
13823}
13824
13825func (self *ControllerStatusProp) SetType(v uint16) {
13826 self.Type = v
13827}
13828
13829func (self *ControllerStatusProp) GetLength() uint16 {
13830 return self.Length
13831}
13832
13833func (self *ControllerStatusProp) SetLength(v uint16) {
13834 self.Length = v
13835}
13836
13837func (self *ControllerStatusProp) Serialize(encoder *goloxi.Encoder) error {
13838
13839 encoder.PutUint16(uint16(self.Type))
13840 encoder.PutUint16(uint16(self.Length))
13841
13842 return nil
13843}
13844
13845func DecodeControllerStatusProp(decoder *goloxi.Decoder) (IControllerStatusProp, error) {
13846 _controllerstatusprop := &ControllerStatusProp{}
13847 if decoder.Length() < 4 {
13848 return nil, fmt.Errorf("ControllerStatusProp packet too short: %d < 4", decoder.Length())
13849 }
13850 _controllerstatusprop.Type = uint16(decoder.ReadUint16())
13851 _controllerstatusprop.Length = uint16(decoder.ReadUint16())
13852 oldDecoder := decoder
13853 defer func() { decoder = oldDecoder }()
13854 decoder = decoder.SliceDecoder(int(_controllerstatusprop.Length), 2+2)
13855
13856 switch _controllerstatusprop.Type {
13857 case 0:
13858 return DecodeControllerStatusPropUri(_controllerstatusprop, decoder)
13859 case 65535:
13860 return DecodeControllerStatusPropExperimenter(_controllerstatusprop, decoder)
13861 default:
13862 return nil, fmt.Errorf("Invalid type '%d' for 'ControllerStatusProp'", _controllerstatusprop.Type)
13863 }
13864}
13865
13866func NewControllerStatusProp(_type uint16) *ControllerStatusProp {
13867 obj := &ControllerStatusProp{}
13868 obj.Type = _type
13869 return obj
13870}
13871
13872type EdPropHeader struct {
13873 PropClass uint16
13874}
13875
13876type IEdPropHeader interface {
13877 goloxi.Serializable
13878 GetPropClass() uint16
13879}
13880
13881func (self *EdPropHeader) GetPropClass() uint16 {
13882 return self.PropClass
13883}
13884
13885func (self *EdPropHeader) SetPropClass(v uint16) {
13886 self.PropClass = v
13887}
13888
13889func (self *EdPropHeader) Serialize(encoder *goloxi.Encoder) error {
13890
13891 encoder.PutUint16(uint16(self.PropClass))
13892
13893 return nil
13894}
13895
13896func DecodeEdPropHeader(decoder *goloxi.Decoder) (IEdPropHeader, error) {
13897 _edpropheader := &EdPropHeader{}
13898 if decoder.Length() < 2 {
13899 return nil, fmt.Errorf("EdPropHeader packet too short: %d < 2", decoder.Length())
13900 }
13901 _edpropheader.PropClass = uint16(decoder.ReadUint16())
13902
13903 switch _edpropheader.PropClass {
13904 case 4:
13905 return DecodeEdPropNsh(_edpropheader, decoder)
13906 default:
13907 return nil, fmt.Errorf("Invalid type '%d' for 'EdPropHeader'", _edpropheader.PropClass)
13908 }
13909}
13910
13911func NewEdPropHeader(_prop_class uint16) *EdPropHeader {
13912 obj := &EdPropHeader{}
13913 obj.PropClass = _prop_class
13914 return obj
13915}
13916
13917type EdPropNsh struct {
13918 *EdPropHeader
13919 Type uint8
13920 Len uint8
13921}
13922
13923type IEdPropNsh interface {
13924 IEdPropHeader
13925 GetType() uint8
13926 GetLen() uint8
13927}
13928
13929func (self *EdPropNsh) GetType() uint8 {
13930 return self.Type
13931}
13932
13933func (self *EdPropNsh) SetType(v uint8) {
13934 self.Type = v
13935}
13936
13937func (self *EdPropNsh) GetLen() uint8 {
13938 return self.Len
13939}
13940
13941func (self *EdPropNsh) SetLen(v uint8) {
13942 self.Len = v
13943}
13944
13945func (self *EdPropNsh) Serialize(encoder *goloxi.Encoder) error {
13946 if err := self.EdPropHeader.Serialize(encoder); err != nil {
13947 return err
13948 }
13949
13950 encoder.PutUint8(uint8(self.Type))
13951 encoder.PutUint8(uint8(self.Len))
13952
13953 return nil
13954}
13955
13956func DecodeEdPropNsh(parent *EdPropHeader, decoder *goloxi.Decoder) (IEdPropNsh, error) {
13957 _edpropnsh := &EdPropNsh{EdPropHeader: parent}
13958 if decoder.Length() < 2 {
13959 return nil, fmt.Errorf("EdPropNsh packet too short: %d < 2", decoder.Length())
13960 }
13961 defer decoder.SkipAlign()
13962
13963 _edpropnsh.Type = uint8(decoder.ReadByte())
13964 _edpropnsh.Len = uint8(decoder.ReadByte())
13965 oldDecoder := decoder
13966 defer func() { decoder = oldDecoder }()
13967 decoder = decoder.SliceDecoder(int(((_edpropnsh.Len)+7)/8*8), 1+3)
13968
13969 switch _edpropnsh.Type {
13970 case 1:
13971 return DecodeEdPropNshMdType(_edpropnsh, decoder)
13972 case 2:
13973 return DecodeEdPropNshTlv(_edpropnsh, decoder)
13974 default:
13975 return nil, fmt.Errorf("Invalid type '%d' for 'EdPropNsh'", _edpropnsh.Type)
13976 }
13977}
13978
13979func NewEdPropNsh(_type uint8) *EdPropNsh {
13980 obj := &EdPropNsh{
13981 EdPropHeader: NewEdPropHeader(4),
13982 }
13983 obj.Type = _type
13984 return obj
13985}
13986
13987type EdPropNshMdType struct {
13988 *EdPropNsh
13989 MdType uint8
13990}
13991
13992type IEdPropNshMdType interface {
13993 IEdPropNsh
13994 GetMdType() uint8
13995}
13996
13997func (self *EdPropNshMdType) GetMdType() uint8 {
13998 return self.MdType
13999}
14000
14001func (self *EdPropNshMdType) SetMdType(v uint8) {
14002 self.MdType = v
14003}
14004
14005func (self *EdPropNshMdType) Serialize(encoder *goloxi.Encoder) error {
14006 startIndex := len(encoder.Bytes())
14007 if err := self.EdPropNsh.Serialize(encoder); err != nil {
14008 return err
14009 }
14010
14011 encoder.PutUint8(uint8(self.MdType))
14012 encoder.Write(bytes.Repeat([]byte{0}, 3))
14013 length := len(encoder.Bytes()) - startIndex
14014
14015 encoder.Bytes()[startIndex+3] = uint8(length)
14016
14017 return nil
14018}
14019
14020func DecodeEdPropNshMdType(parent *EdPropNsh, decoder *goloxi.Decoder) (*EdPropNshMdType, error) {
14021 _edpropnshmdtype := &EdPropNshMdType{EdPropNsh: parent}
14022 if decoder.Length() < 4 {
14023 return nil, fmt.Errorf("EdPropNshMdType packet too short: %d < 4", decoder.Length())
14024 }
14025 _edpropnshmdtype.MdType = uint8(decoder.ReadByte())
14026 decoder.Skip(3)
14027 return _edpropnshmdtype, nil
14028}
14029
14030func NewEdPropNshMdType() *EdPropNshMdType {
14031 obj := &EdPropNshMdType{
14032 EdPropNsh: NewEdPropNsh(1),
14033 }
14034 return obj
14035}
14036
14037type EdPropNshTlv struct {
14038 *EdPropNsh
14039 TlvClass uint16
14040 TlvType uint8
14041 TlvLen uint8
14042 Value []byte
14043}
14044
14045type IEdPropNshTlv interface {
14046 IEdPropNsh
14047 GetTlvClass() uint16
14048 GetTlvType() uint8
14049 GetTlvLen() uint8
14050 GetValue() []byte
14051}
14052
14053func (self *EdPropNshTlv) GetTlvClass() uint16 {
14054 return self.TlvClass
14055}
14056
14057func (self *EdPropNshTlv) SetTlvClass(v uint16) {
14058 self.TlvClass = v
14059}
14060
14061func (self *EdPropNshTlv) GetTlvType() uint8 {
14062 return self.TlvType
14063}
14064
14065func (self *EdPropNshTlv) SetTlvType(v uint8) {
14066 self.TlvType = v
14067}
14068
14069func (self *EdPropNshTlv) GetTlvLen() uint8 {
14070 return self.TlvLen
14071}
14072
14073func (self *EdPropNshTlv) SetTlvLen(v uint8) {
14074 self.TlvLen = v
14075}
14076
14077func (self *EdPropNshTlv) GetValue() []byte {
14078 return self.Value
14079}
14080
14081func (self *EdPropNshTlv) SetValue(v []byte) {
14082 self.Value = v
14083}
14084
14085func (self *EdPropNshTlv) Serialize(encoder *goloxi.Encoder) error {
14086 startIndex := len(encoder.Bytes())
14087 if err := self.EdPropNsh.Serialize(encoder); err != nil {
14088 return err
14089 }
14090
14091 encoder.PutUint16(uint16(self.TlvClass))
14092 encoder.PutUint8(uint8(self.TlvType))
14093 encoder.PutUint8(uint8(self.TlvLen))
14094 encoder.Write(self.Value)
14095 length := len(encoder.Bytes()) - startIndex
14096
14097 encoder.Bytes()[startIndex+3] = uint8(length)
14098
14099 return nil
14100}
14101
14102func DecodeEdPropNshTlv(parent *EdPropNsh, decoder *goloxi.Decoder) (*EdPropNshTlv, error) {
14103 _edpropnshtlv := &EdPropNshTlv{EdPropNsh: parent}
14104 if decoder.Length() < 4 {
14105 return nil, fmt.Errorf("EdPropNshTlv packet too short: %d < 4", decoder.Length())
14106 }
14107 _edpropnshtlv.TlvClass = uint16(decoder.ReadUint16())
14108 _edpropnshtlv.TlvType = uint8(decoder.ReadByte())
14109 _edpropnshtlv.TlvLen = uint8(decoder.ReadByte())
14110 _edpropnshtlv.Value = decoder.SliceDecoder(int(_edpropnshtlv.TlvLen), 0).Read(int(_edpropnshtlv.TlvLen))
14111 return _edpropnshtlv, nil
14112}
14113
14114func NewEdPropNshTlv() *EdPropNshTlv {
14115 obj := &EdPropNshTlv{
14116 EdPropNsh: NewEdPropNsh(2),
14117 }
14118 return obj
14119}
14120
14121type FlowLightweightStatsEntry struct {
14122 Length uint16
14123 TableId uint8
14124 Reason FlowStatsReason
14125 Priority uint16
14126 Match Match
14127 Stats Stat
14128}
14129
14130type IFlowLightweightStatsEntry interface {
14131 goloxi.Serializable
14132 GetLength() uint16
14133 GetTableId() uint8
14134 GetReason() FlowStatsReason
14135 GetPriority() uint16
14136 GetMatch() Match
14137 GetStats() Stat
14138}
14139
14140func (self *FlowLightweightStatsEntry) GetLength() uint16 {
14141 return self.Length
14142}
14143
14144func (self *FlowLightweightStatsEntry) SetLength(v uint16) {
14145 self.Length = v
14146}
14147
14148func (self *FlowLightweightStatsEntry) GetTableId() uint8 {
14149 return self.TableId
14150}
14151
14152func (self *FlowLightweightStatsEntry) SetTableId(v uint8) {
14153 self.TableId = v
14154}
14155
14156func (self *FlowLightweightStatsEntry) GetReason() FlowStatsReason {
14157 return self.Reason
14158}
14159
14160func (self *FlowLightweightStatsEntry) SetReason(v FlowStatsReason) {
14161 self.Reason = v
14162}
14163
14164func (self *FlowLightweightStatsEntry) GetPriority() uint16 {
14165 return self.Priority
14166}
14167
14168func (self *FlowLightweightStatsEntry) SetPriority(v uint16) {
14169 self.Priority = v
14170}
14171
14172func (self *FlowLightweightStatsEntry) GetMatch() Match {
14173 return self.Match
14174}
14175
14176func (self *FlowLightweightStatsEntry) SetMatch(v Match) {
14177 self.Match = v
14178}
14179
14180func (self *FlowLightweightStatsEntry) GetStats() Stat {
14181 return self.Stats
14182}
14183
14184func (self *FlowLightweightStatsEntry) SetStats(v Stat) {
14185 self.Stats = v
14186}
14187
14188func (self *FlowLightweightStatsEntry) Serialize(encoder *goloxi.Encoder) error {
14189 startIndex := len(encoder.Bytes())
14190
14191 encoder.PutUint16(uint16(self.Length))
14192 encoder.Write(bytes.Repeat([]byte{0}, 2))
14193 encoder.PutUint8(uint8(self.TableId))
14194 encoder.PutUint8(uint8(self.Reason))
14195 encoder.PutUint16(uint16(self.Priority))
14196 if err := self.Match.Serialize(encoder); err != nil {
14197 return err
14198 }
14199
14200 if err := self.Stats.Serialize(encoder); err != nil {
14201 return err
14202 }
14203
14204 length := len(encoder.Bytes()) - startIndex
14205
14206 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
14207
14208 return nil
14209}
14210
14211func DecodeFlowLightweightStatsEntry(decoder *goloxi.Decoder) (*FlowLightweightStatsEntry, error) {
14212 _flowlightweightstatsentry := &FlowLightweightStatsEntry{}
14213 if decoder.Length() < 24 {
14214 return nil, fmt.Errorf("FlowLightweightStatsEntry packet too short: %d < 24", decoder.Length())
14215 }
14216 _flowlightweightstatsentry.Length = uint16(decoder.ReadUint16())
14217 oldDecoder := decoder
14218 defer func() { decoder = oldDecoder }()
14219 decoder = decoder.SliceDecoder(int(_flowlightweightstatsentry.Length), 2+0)
14220 decoder.Skip(2)
14221 _flowlightweightstatsentry.TableId = uint8(decoder.ReadByte())
14222 _flowlightweightstatsentry.Reason = FlowStatsReason(decoder.ReadByte())
14223 _flowlightweightstatsentry.Priority = uint16(decoder.ReadUint16())
14224 if err := _flowlightweightstatsentry.Match.Decode(decoder); err != nil {
14225 return nil, err
14226 }
14227
14228 decoder.SkipAlign()
14229 if err := _flowlightweightstatsentry.Stats.Decode(decoder); err != nil {
14230 return nil, err
14231 }
14232
14233 decoder.SkipAlign()
14234 return _flowlightweightstatsentry, nil
14235}
14236
14237func NewFlowLightweightStatsEntry() *FlowLightweightStatsEntry {
14238 obj := &FlowLightweightStatsEntry{}
14239 return obj
14240}
14241
14242type FlowModSpec struct {
14243 SrcDst uint8
14244 NBits uint8
14245}
14246
14247type IFlowModSpec interface {
14248 goloxi.Serializable
14249 GetSrcDst() uint8
14250 GetNBits() uint8
14251}
14252
14253func (self *FlowModSpec) GetSrcDst() uint8 {
14254 return self.SrcDst
14255}
14256
14257func (self *FlowModSpec) SetSrcDst(v uint8) {
14258 self.SrcDst = v
14259}
14260
14261func (self *FlowModSpec) GetNBits() uint8 {
14262 return self.NBits
14263}
14264
14265func (self *FlowModSpec) SetNBits(v uint8) {
14266 self.NBits = v
14267}
14268
14269func (self *FlowModSpec) Serialize(encoder *goloxi.Encoder) error {
14270
14271 encoder.PutUint8(uint8(self.SrcDst))
14272 encoder.PutUint8(uint8(self.NBits))
14273
14274 return nil
14275}
14276
14277func DecodeFlowModSpec(decoder *goloxi.Decoder) (IFlowModSpec, error) {
14278 _flowmodspec := &FlowModSpec{}
14279 if decoder.Length() < 2 {
14280 return nil, fmt.Errorf("FlowModSpec packet too short: %d < 2", decoder.Length())
14281 }
14282 _flowmodspec.SrcDst = uint8(decoder.ReadByte())
14283 _flowmodspec.NBits = uint8(decoder.ReadByte())
14284 if _flowmodspec.SrcDst == 0 && _flowmodspec.NBits == 0 {
14285 return nil, nil
14286 }
14287
14288 switch _flowmodspec.SrcDst {
14289 case 0:
14290 return DecodeFlowModSpecSrc0Dst0(_flowmodspec, decoder)
14291 case 8:
14292 return DecodeFlowModSpecSrc0Dst1(_flowmodspec, decoder)
14293 case 40:
14294 return DecodeFlowModSpecSrc1Dst1(_flowmodspec, decoder)
14295 case 16:
14296 return DecodeFlowModSpecSrc0Dst2(_flowmodspec, decoder)
14297 case 32:
14298 return DecodeFlowModSpecSrc1Dst0(_flowmodspec, decoder)
14299 default:
14300 return nil, fmt.Errorf("Invalid type '%d' for 'FlowModSpec'", _flowmodspec.SrcDst)
14301 }
14302}
14303
14304func NewFlowModSpec(_src_dst uint8) *FlowModSpec {
14305 obj := &FlowModSpec{}
14306 obj.SrcDst = _src_dst
14307 return obj
14308}
14309
14310type FlowModSpecSrc0Dst0 struct {
14311 *FlowModSpec
14312 Src goloxi.IOxmId
14313 SrcOfs uint16
14314 Dst goloxi.IOxmId
14315 DstOfs uint16
14316}
14317
14318type IFlowModSpecSrc0Dst0 interface {
14319 IFlowModSpec
14320 GetSrc() goloxi.IOxmId
14321 GetSrcOfs() uint16
14322 GetDst() goloxi.IOxmId
14323 GetDstOfs() uint16
14324}
14325
14326func (self *FlowModSpecSrc0Dst0) GetSrc() goloxi.IOxmId {
14327 return self.Src
14328}
14329
14330func (self *FlowModSpecSrc0Dst0) SetSrc(v goloxi.IOxmId) {
14331 self.Src = v
14332}
14333
14334func (self *FlowModSpecSrc0Dst0) GetSrcOfs() uint16 {
14335 return self.SrcOfs
14336}
14337
14338func (self *FlowModSpecSrc0Dst0) SetSrcOfs(v uint16) {
14339 self.SrcOfs = v
14340}
14341
14342func (self *FlowModSpecSrc0Dst0) GetDst() goloxi.IOxmId {
14343 return self.Dst
14344}
14345
14346func (self *FlowModSpecSrc0Dst0) SetDst(v goloxi.IOxmId) {
14347 self.Dst = v
14348}
14349
14350func (self *FlowModSpecSrc0Dst0) GetDstOfs() uint16 {
14351 return self.DstOfs
14352}
14353
14354func (self *FlowModSpecSrc0Dst0) SetDstOfs(v uint16) {
14355 self.DstOfs = v
14356}
14357
14358func (self *FlowModSpecSrc0Dst0) Serialize(encoder *goloxi.Encoder) error {
14359 if err := self.FlowModSpec.Serialize(encoder); err != nil {
14360 return err
14361 }
14362
14363 self.Src.Serialize(encoder)
14364 encoder.PutUint16(uint16(self.SrcOfs))
14365 self.Dst.Serialize(encoder)
14366 encoder.PutUint16(uint16(self.DstOfs))
14367
14368 return nil
14369}
14370
14371func DecodeFlowModSpecSrc0Dst0(parent *FlowModSpec, decoder *goloxi.Decoder) (IFlowModSpecSrc0Dst0, error) {
14372 _flowmodspecsrc0dst0 := &FlowModSpecSrc0Dst0{FlowModSpec: parent}
14373 if decoder.Length() < 12 {
14374 return nil, fmt.Errorf("FlowModSpecSrc0Dst0 packet too short: %d < 12", decoder.Length())
14375 }
14376 if obj, err := DecodeOxmId(decoder); err != nil {
14377 return nil, err
14378 } else {
14379 _flowmodspecsrc0dst0.Src = obj
14380 }
14381
14382 _flowmodspecsrc0dst0.SrcOfs = uint16(decoder.ReadUint16())
14383 if obj, err := DecodeOxmId(decoder); err != nil {
14384 return nil, err
14385 } else {
14386 _flowmodspecsrc0dst0.Dst = obj
14387 }
14388
14389 _flowmodspecsrc0dst0.DstOfs = uint16(decoder.ReadUint16())
14390 return _flowmodspecsrc0dst0, nil
14391}
14392
14393func NewFlowModSpecSrc0Dst0(_n_bits uint8) *FlowModSpecSrc0Dst0 {
14394 obj := &FlowModSpecSrc0Dst0{
14395 FlowModSpec: NewFlowModSpec(0),
14396 }
14397 obj.NBits = _n_bits
14398 return obj
14399}
14400
14401type FlowModSpecSrc0Dst1 struct {
14402 *FlowModSpec
14403 Src goloxi.IOxmId
14404 SrcOfs uint16
14405 Dst goloxi.IOxmId
14406 DstOfs uint16
14407}
14408
14409type IFlowModSpecSrc0Dst1 interface {
14410 IFlowModSpec
14411 GetSrc() goloxi.IOxmId
14412 GetSrcOfs() uint16
14413 GetDst() goloxi.IOxmId
14414 GetDstOfs() uint16
14415}
14416
14417func (self *FlowModSpecSrc0Dst1) GetSrc() goloxi.IOxmId {
14418 return self.Src
14419}
14420
14421func (self *FlowModSpecSrc0Dst1) SetSrc(v goloxi.IOxmId) {
14422 self.Src = v
14423}
14424
14425func (self *FlowModSpecSrc0Dst1) GetSrcOfs() uint16 {
14426 return self.SrcOfs
14427}
14428
14429func (self *FlowModSpecSrc0Dst1) SetSrcOfs(v uint16) {
14430 self.SrcOfs = v
14431}
14432
14433func (self *FlowModSpecSrc0Dst1) GetDst() goloxi.IOxmId {
14434 return self.Dst
14435}
14436
14437func (self *FlowModSpecSrc0Dst1) SetDst(v goloxi.IOxmId) {
14438 self.Dst = v
14439}
14440
14441func (self *FlowModSpecSrc0Dst1) GetDstOfs() uint16 {
14442 return self.DstOfs
14443}
14444
14445func (self *FlowModSpecSrc0Dst1) SetDstOfs(v uint16) {
14446 self.DstOfs = v
14447}
14448
14449func (self *FlowModSpecSrc0Dst1) Serialize(encoder *goloxi.Encoder) error {
14450 if err := self.FlowModSpec.Serialize(encoder); err != nil {
14451 return err
14452 }
14453
14454 self.Src.Serialize(encoder)
14455 encoder.PutUint16(uint16(self.SrcOfs))
14456 self.Dst.Serialize(encoder)
14457 encoder.PutUint16(uint16(self.DstOfs))
14458
14459 return nil
14460}
14461
14462func DecodeFlowModSpecSrc0Dst1(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc0Dst1, error) {
14463 _flowmodspecsrc0dst1 := &FlowModSpecSrc0Dst1{FlowModSpec: parent}
14464 if decoder.Length() < 12 {
14465 return nil, fmt.Errorf("FlowModSpecSrc0Dst1 packet too short: %d < 12", decoder.Length())
14466 }
14467 if obj, err := DecodeOxmId(decoder); err != nil {
14468 return nil, err
14469 } else {
14470 _flowmodspecsrc0dst1.Src = obj
14471 }
14472
14473 _flowmodspecsrc0dst1.SrcOfs = uint16(decoder.ReadUint16())
14474 if obj, err := DecodeOxmId(decoder); err != nil {
14475 return nil, err
14476 } else {
14477 _flowmodspecsrc0dst1.Dst = obj
14478 }
14479
14480 _flowmodspecsrc0dst1.DstOfs = uint16(decoder.ReadUint16())
14481 return _flowmodspecsrc0dst1, nil
14482}
14483
14484func NewFlowModSpecSrc0Dst1() *FlowModSpecSrc0Dst1 {
14485 obj := &FlowModSpecSrc0Dst1{
14486 FlowModSpec: NewFlowModSpec(8),
14487 }
14488 return obj
14489}
14490
14491type FlowModSpecSrc0Dst2 struct {
14492 *FlowModSpec
14493 Src goloxi.IOxmId
14494 SrcOfs uint16
14495}
14496
14497type IFlowModSpecSrc0Dst2 interface {
14498 IFlowModSpec
14499 GetSrc() goloxi.IOxmId
14500 GetSrcOfs() uint16
14501}
14502
14503func (self *FlowModSpecSrc0Dst2) GetSrc() goloxi.IOxmId {
14504 return self.Src
14505}
14506
14507func (self *FlowModSpecSrc0Dst2) SetSrc(v goloxi.IOxmId) {
14508 self.Src = v
14509}
14510
14511func (self *FlowModSpecSrc0Dst2) GetSrcOfs() uint16 {
14512 return self.SrcOfs
14513}
14514
14515func (self *FlowModSpecSrc0Dst2) SetSrcOfs(v uint16) {
14516 self.SrcOfs = v
14517}
14518
14519func (self *FlowModSpecSrc0Dst2) Serialize(encoder *goloxi.Encoder) error {
14520 if err := self.FlowModSpec.Serialize(encoder); err != nil {
14521 return err
14522 }
14523
14524 self.Src.Serialize(encoder)
14525 encoder.PutUint16(uint16(self.SrcOfs))
14526
14527 return nil
14528}
14529
14530func DecodeFlowModSpecSrc0Dst2(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc0Dst2, error) {
14531 _flowmodspecsrc0dst2 := &FlowModSpecSrc0Dst2{FlowModSpec: parent}
14532 if decoder.Length() < 6 {
14533 return nil, fmt.Errorf("FlowModSpecSrc0Dst2 packet too short: %d < 6", decoder.Length())
14534 }
14535 if obj, err := DecodeOxmId(decoder); err != nil {
14536 return nil, err
14537 } else {
14538 _flowmodspecsrc0dst2.Src = obj
14539 }
14540
14541 _flowmodspecsrc0dst2.SrcOfs = uint16(decoder.ReadUint16())
14542 return _flowmodspecsrc0dst2, nil
14543}
14544
14545func NewFlowModSpecSrc0Dst2() *FlowModSpecSrc0Dst2 {
14546 obj := &FlowModSpecSrc0Dst2{
14547 FlowModSpec: NewFlowModSpec(16),
14548 }
14549 return obj
14550}
14551
14552type FlowModSpecSrc1Dst0 struct {
14553 *FlowModSpec
14554 Src []byte
14555 Dst goloxi.IOxmId
14556 DstOfs uint16
14557}
14558
14559type IFlowModSpecSrc1Dst0 interface {
14560 IFlowModSpec
14561 GetSrc() []byte
14562 GetDst() goloxi.IOxmId
14563 GetDstOfs() uint16
14564}
14565
14566func (self *FlowModSpecSrc1Dst0) GetSrc() []byte {
14567 return self.Src
14568}
14569
14570func (self *FlowModSpecSrc1Dst0) SetSrc(v []byte) {
14571 self.Src = v
14572}
14573
14574func (self *FlowModSpecSrc1Dst0) GetDst() goloxi.IOxmId {
14575 return self.Dst
14576}
14577
14578func (self *FlowModSpecSrc1Dst0) SetDst(v goloxi.IOxmId) {
14579 self.Dst = v
14580}
14581
14582func (self *FlowModSpecSrc1Dst0) GetDstOfs() uint16 {
14583 return self.DstOfs
14584}
14585
14586func (self *FlowModSpecSrc1Dst0) SetDstOfs(v uint16) {
14587 self.DstOfs = v
14588}
14589
14590func (self *FlowModSpecSrc1Dst0) Serialize(encoder *goloxi.Encoder) error {
14591 if err := self.FlowModSpec.Serialize(encoder); err != nil {
14592 return err
14593 }
14594
14595 encoder.Write(self.Src)
14596 self.Dst.Serialize(encoder)
14597 encoder.PutUint16(uint16(self.DstOfs))
14598
14599 return nil
14600}
14601
14602func DecodeFlowModSpecSrc1Dst0(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc1Dst0, error) {
14603 _flowmodspecsrc1dst0 := &FlowModSpecSrc1Dst0{FlowModSpec: parent}
14604 if decoder.Length() < 6 {
14605 return nil, fmt.Errorf("FlowModSpecSrc1Dst0 packet too short: %d < 6", decoder.Length())
14606 }
14607 _flowmodspecsrc1dst0.Src = decoder.SliceDecoder(int((_flowmodspecsrc1dst0.NBits+15)/16*2), 0).Read(int(_flowmodspecsrc1dst0.NBits))
14608 if obj, err := DecodeOxmId(decoder); err != nil {
14609 return nil, err
14610 } else {
14611 _flowmodspecsrc1dst0.Dst = obj
14612 }
14613
14614 _flowmodspecsrc1dst0.DstOfs = uint16(decoder.ReadUint16())
14615 return _flowmodspecsrc1dst0, nil
14616}
14617
14618func NewFlowModSpecSrc1Dst0() *FlowModSpecSrc1Dst0 {
14619 obj := &FlowModSpecSrc1Dst0{
14620 FlowModSpec: NewFlowModSpec(32),
14621 }
14622 return obj
14623}
14624
14625type FlowModSpecSrc1Dst1 struct {
14626 *FlowModSpec
14627 Src []byte
14628 Dst goloxi.IOxmId
14629 DstOfs uint16
14630}
14631
14632type IFlowModSpecSrc1Dst1 interface {
14633 IFlowModSpec
14634 GetSrc() []byte
14635 GetDst() goloxi.IOxmId
14636 GetDstOfs() uint16
14637}
14638
14639func (self *FlowModSpecSrc1Dst1) GetSrc() []byte {
14640 return self.Src
14641}
14642
14643func (self *FlowModSpecSrc1Dst1) SetSrc(v []byte) {
14644 self.Src = v
14645}
14646
14647func (self *FlowModSpecSrc1Dst1) GetDst() goloxi.IOxmId {
14648 return self.Dst
14649}
14650
14651func (self *FlowModSpecSrc1Dst1) SetDst(v goloxi.IOxmId) {
14652 self.Dst = v
14653}
14654
14655func (self *FlowModSpecSrc1Dst1) GetDstOfs() uint16 {
14656 return self.DstOfs
14657}
14658
14659func (self *FlowModSpecSrc1Dst1) SetDstOfs(v uint16) {
14660 self.DstOfs = v
14661}
14662
14663func (self *FlowModSpecSrc1Dst1) Serialize(encoder *goloxi.Encoder) error {
14664 if err := self.FlowModSpec.Serialize(encoder); err != nil {
14665 return err
14666 }
14667
14668 encoder.Write(self.Src)
14669 self.Dst.Serialize(encoder)
14670 encoder.PutUint16(uint16(self.DstOfs))
14671
14672 return nil
14673}
14674
14675func DecodeFlowModSpecSrc1Dst1(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc1Dst1, error) {
14676 _flowmodspecsrc1dst1 := &FlowModSpecSrc1Dst1{FlowModSpec: parent}
14677 if decoder.Length() < 6 {
14678 return nil, fmt.Errorf("FlowModSpecSrc1Dst1 packet too short: %d < 6", decoder.Length())
14679 }
14680 _flowmodspecsrc1dst1.Src = decoder.SliceDecoder(int((_flowmodspecsrc1dst1.NBits+15)/16*2), 0).Read(int(_flowmodspecsrc1dst1.NBits))
14681 if obj, err := DecodeOxmId(decoder); err != nil {
14682 return nil, err
14683 } else {
14684 _flowmodspecsrc1dst1.Dst = obj
14685 }
14686
14687 _flowmodspecsrc1dst1.DstOfs = uint16(decoder.ReadUint16())
14688 return _flowmodspecsrc1dst1, nil
14689}
14690
14691func NewFlowModSpecSrc1Dst1() *FlowModSpecSrc1Dst1 {
14692 obj := &FlowModSpecSrc1Dst1{
14693 FlowModSpec: NewFlowModSpec(40),
14694 }
14695 return obj
14696}
14697
14698type FlowMonitorEntry struct {
14699 MonitorId uint32
14700 OutPort uint32
14701 OutGroup uint32
14702 Flags FlowMonitorFlags
14703 TableId uint8
14704 Command FlowMonitorCommand
14705 Match Match
14706}
14707
14708type IFlowMonitorEntry interface {
14709 goloxi.Serializable
14710 GetMonitorId() uint32
14711 GetOutPort() uint32
14712 GetOutGroup() uint32
14713 GetFlags() FlowMonitorFlags
14714 GetTableId() uint8
14715 GetCommand() FlowMonitorCommand
14716 GetMatch() Match
14717}
14718
14719func (self *FlowMonitorEntry) GetMonitorId() uint32 {
14720 return self.MonitorId
14721}
14722
14723func (self *FlowMonitorEntry) SetMonitorId(v uint32) {
14724 self.MonitorId = v
14725}
14726
14727func (self *FlowMonitorEntry) GetOutPort() uint32 {
14728 return self.OutPort
14729}
14730
14731func (self *FlowMonitorEntry) SetOutPort(v uint32) {
14732 self.OutPort = v
14733}
14734
14735func (self *FlowMonitorEntry) GetOutGroup() uint32 {
14736 return self.OutGroup
14737}
14738
14739func (self *FlowMonitorEntry) SetOutGroup(v uint32) {
14740 self.OutGroup = v
14741}
14742
14743func (self *FlowMonitorEntry) GetFlags() FlowMonitorFlags {
14744 return self.Flags
14745}
14746
14747func (self *FlowMonitorEntry) SetFlags(v FlowMonitorFlags) {
14748 self.Flags = v
14749}
14750
14751func (self *FlowMonitorEntry) GetTableId() uint8 {
14752 return self.TableId
14753}
14754
14755func (self *FlowMonitorEntry) SetTableId(v uint8) {
14756 self.TableId = v
14757}
14758
14759func (self *FlowMonitorEntry) GetCommand() FlowMonitorCommand {
14760 return self.Command
14761}
14762
14763func (self *FlowMonitorEntry) SetCommand(v FlowMonitorCommand) {
14764 self.Command = v
14765}
14766
14767func (self *FlowMonitorEntry) GetMatch() Match {
14768 return self.Match
14769}
14770
14771func (self *FlowMonitorEntry) SetMatch(v Match) {
14772 self.Match = v
14773}
14774
14775func (self *FlowMonitorEntry) Serialize(encoder *goloxi.Encoder) error {
14776
14777 encoder.PutUint32(uint32(self.MonitorId))
14778 encoder.PutUint32(uint32(self.OutPort))
14779 encoder.PutUint32(uint32(self.OutGroup))
14780 encoder.PutUint16(uint16(self.Flags))
14781 encoder.PutUint8(uint8(self.TableId))
14782 encoder.PutUint8(uint8(self.Command))
14783 if err := self.Match.Serialize(encoder); err != nil {
14784 return err
14785 }
14786
14787 return nil
14788}
14789
14790func DecodeFlowMonitorEntry(decoder *goloxi.Decoder) (*FlowMonitorEntry, error) {
14791 _flowmonitorentry := &FlowMonitorEntry{}
14792 if decoder.Length() < 24 {
14793 return nil, fmt.Errorf("FlowMonitorEntry packet too short: %d < 24", decoder.Length())
14794 }
14795 _flowmonitorentry.MonitorId = uint32(decoder.ReadUint32())
14796 _flowmonitorentry.OutPort = uint32(decoder.ReadUint32())
14797 _flowmonitorentry.OutGroup = uint32(decoder.ReadUint32())
14798 _flowmonitorentry.Flags = FlowMonitorFlags(decoder.ReadUint16())
14799 _flowmonitorentry.TableId = uint8(decoder.ReadByte())
14800 _flowmonitorentry.Command = FlowMonitorCommand(decoder.ReadByte())
14801 if err := _flowmonitorentry.Match.Decode(decoder); err != nil {
14802 return nil, err
14803 }
14804
14805 decoder.SkipAlign()
14806 return _flowmonitorentry, nil
14807}
14808
14809func NewFlowMonitorEntry() *FlowMonitorEntry {
14810 obj := &FlowMonitorEntry{}
14811 return obj
14812}
14813
14814type FlowMonitorReplyEntry struct {
14815 Length uint16
14816 Event FlowUpdateEvent
14817}
14818
14819type IFlowMonitorReplyEntry interface {
14820 goloxi.Serializable
14821 GetLength() uint16
14822 GetEvent() FlowUpdateEvent
14823}
14824
14825func (self *FlowMonitorReplyEntry) GetLength() uint16 {
14826 return self.Length
14827}
14828
14829func (self *FlowMonitorReplyEntry) SetLength(v uint16) {
14830 self.Length = v
14831}
14832
14833func (self *FlowMonitorReplyEntry) GetEvent() FlowUpdateEvent {
14834 return self.Event
14835}
14836
14837func (self *FlowMonitorReplyEntry) SetEvent(v FlowUpdateEvent) {
14838 self.Event = v
14839}
14840
14841func (self *FlowMonitorReplyEntry) Serialize(encoder *goloxi.Encoder) error {
14842
14843 encoder.PutUint16(uint16(self.Length))
14844 encoder.PutUint16(uint16(self.Event))
14845
14846 return nil
14847}
14848
14849func DecodeFlowMonitorReplyEntry(decoder *goloxi.Decoder) (IFlowMonitorReplyEntry, error) {
14850 _flowmonitorreplyentry := &FlowMonitorReplyEntry{}
14851 if decoder.Length() < 4 {
14852 return nil, fmt.Errorf("FlowMonitorReplyEntry packet too short: %d < 4", decoder.Length())
14853 }
14854 _flowmonitorreplyentry.Length = uint16(decoder.ReadUint16())
14855 oldDecoder := decoder
14856 defer func() { decoder = oldDecoder }()
14857 decoder = decoder.SliceDecoder(int(_flowmonitorreplyentry.Length), 2+0)
14858 _flowmonitorreplyentry.Event = FlowUpdateEvent(decoder.ReadUint16())
14859
14860 switch _flowmonitorreplyentry.Event {
14861 case 0:
14862 return DecodeFlowUpdateFullInitial(_flowmonitorreplyentry, decoder)
14863 case 1:
14864 return DecodeFlowUpdateFullAdded(_flowmonitorreplyentry, decoder)
14865 case 2:
14866 return DecodeFlowUpdateFullRemoved(_flowmonitorreplyentry, decoder)
14867 case 3:
14868 return DecodeFlowUpdateFullModified(_flowmonitorreplyentry, decoder)
14869 default:
14870 return nil, fmt.Errorf("Invalid type '%d' for 'FlowMonitorReplyEntry'", _flowmonitorreplyentry.Event)
14871 }
14872}
14873
14874func NewFlowMonitorReplyEntry(_event FlowUpdateEvent) *FlowMonitorReplyEntry {
14875 obj := &FlowMonitorReplyEntry{}
14876 obj.Event = _event
14877 return obj
14878}
14879
14880type FlowStatsEntry struct {
14881 Length uint16
14882 TableId uint8
14883 Priority uint16
14884 IdleTimeout uint16
14885 HardTimeout uint16
14886 Flags FlowModFlags
14887 Importance uint16
14888 Cookie uint64
14889 Match Match
14890 Stats Stat
14891 Instructions []IInstruction
14892}
14893
14894type IFlowStatsEntry interface {
14895 goloxi.Serializable
14896 GetLength() uint16
14897 GetTableId() uint8
14898 GetPriority() uint16
14899 GetIdleTimeout() uint16
14900 GetHardTimeout() uint16
14901 GetFlags() FlowModFlags
14902 GetImportance() uint16
14903 GetCookie() uint64
14904 GetMatch() Match
14905 GetStats() Stat
14906 GetInstructions() []IInstruction
14907}
14908
14909func (self *FlowStatsEntry) GetLength() uint16 {
14910 return self.Length
14911}
14912
14913func (self *FlowStatsEntry) SetLength(v uint16) {
14914 self.Length = v
14915}
14916
14917func (self *FlowStatsEntry) GetTableId() uint8 {
14918 return self.TableId
14919}
14920
14921func (self *FlowStatsEntry) SetTableId(v uint8) {
14922 self.TableId = v
14923}
14924
14925func (self *FlowStatsEntry) GetPriority() uint16 {
14926 return self.Priority
14927}
14928
14929func (self *FlowStatsEntry) SetPriority(v uint16) {
14930 self.Priority = v
14931}
14932
14933func (self *FlowStatsEntry) GetIdleTimeout() uint16 {
14934 return self.IdleTimeout
14935}
14936
14937func (self *FlowStatsEntry) SetIdleTimeout(v uint16) {
14938 self.IdleTimeout = v
14939}
14940
14941func (self *FlowStatsEntry) GetHardTimeout() uint16 {
14942 return self.HardTimeout
14943}
14944
14945func (self *FlowStatsEntry) SetHardTimeout(v uint16) {
14946 self.HardTimeout = v
14947}
14948
14949func (self *FlowStatsEntry) GetFlags() FlowModFlags {
14950 return self.Flags
14951}
14952
14953func (self *FlowStatsEntry) SetFlags(v FlowModFlags) {
14954 self.Flags = v
14955}
14956
14957func (self *FlowStatsEntry) GetImportance() uint16 {
14958 return self.Importance
14959}
14960
14961func (self *FlowStatsEntry) SetImportance(v uint16) {
14962 self.Importance = v
14963}
14964
14965func (self *FlowStatsEntry) GetCookie() uint64 {
14966 return self.Cookie
14967}
14968
14969func (self *FlowStatsEntry) SetCookie(v uint64) {
14970 self.Cookie = v
14971}
14972
14973func (self *FlowStatsEntry) GetMatch() Match {
14974 return self.Match
14975}
14976
14977func (self *FlowStatsEntry) SetMatch(v Match) {
14978 self.Match = v
14979}
14980
14981func (self *FlowStatsEntry) GetStats() Stat {
14982 return self.Stats
14983}
14984
14985func (self *FlowStatsEntry) SetStats(v Stat) {
14986 self.Stats = v
14987}
14988
14989func (self *FlowStatsEntry) GetInstructions() []IInstruction {
14990 return self.Instructions
14991}
14992
14993func (self *FlowStatsEntry) SetInstructions(v []IInstruction) {
14994 self.Instructions = v
14995}
14996
14997func (self *FlowStatsEntry) Serialize(encoder *goloxi.Encoder) error {
14998 startIndex := len(encoder.Bytes())
14999
15000 encoder.PutUint16(uint16(self.Length))
15001 encoder.Write(bytes.Repeat([]byte{0}, 2))
15002 encoder.PutUint8(uint8(self.TableId))
15003 encoder.Write(bytes.Repeat([]byte{0}, 1))
15004 encoder.PutUint16(uint16(self.Priority))
15005 encoder.PutUint16(uint16(self.IdleTimeout))
15006 encoder.PutUint16(uint16(self.HardTimeout))
15007 encoder.PutUint16(uint16(self.Flags))
15008 encoder.PutUint16(uint16(self.Importance))
15009 encoder.PutUint64(uint64(self.Cookie))
15010 if err := self.Match.Serialize(encoder); err != nil {
15011 return err
15012 }
15013
15014 if err := self.Stats.Serialize(encoder); err != nil {
15015 return err
15016 }
15017
15018 for _, obj := range self.Instructions {
15019 if err := obj.Serialize(encoder); err != nil {
15020 return err
15021 }
15022 }
15023 length := len(encoder.Bytes()) - startIndex
15024
15025 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
15026
15027 return nil
15028}
15029
15030func DecodeFlowStatsEntry(decoder *goloxi.Decoder) (*FlowStatsEntry, error) {
15031 _flowstatsentry := &FlowStatsEntry{}
15032 if decoder.Length() < 40 {
15033 return nil, fmt.Errorf("FlowStatsEntry packet too short: %d < 40", decoder.Length())
15034 }
15035 _flowstatsentry.Length = uint16(decoder.ReadUint16())
15036 oldDecoder := decoder
15037 defer func() { decoder = oldDecoder }()
15038 decoder = decoder.SliceDecoder(int(_flowstatsentry.Length), 2+0)
15039 decoder.Skip(2)
15040 _flowstatsentry.TableId = uint8(decoder.ReadByte())
15041 decoder.Skip(1)
15042 _flowstatsentry.Priority = uint16(decoder.ReadUint16())
15043 _flowstatsentry.IdleTimeout = uint16(decoder.ReadUint16())
15044 _flowstatsentry.HardTimeout = uint16(decoder.ReadUint16())
15045 _flowstatsentry.Flags = FlowModFlags(decoder.ReadUint16())
15046 _flowstatsentry.Importance = uint16(decoder.ReadUint16())
15047 _flowstatsentry.Cookie = uint64(decoder.ReadUint64())
15048 if err := _flowstatsentry.Match.Decode(decoder); err != nil {
15049 return nil, err
15050 }
15051
15052 decoder.SkipAlign()
15053 if err := _flowstatsentry.Stats.Decode(decoder); err != nil {
15054 return nil, err
15055 }
15056
15057 decoder.SkipAlign()
15058
15059 for decoder.Length() >= 4 {
15060 item, err := DecodeInstruction(decoder)
15061 if err != nil {
15062 return nil, err
15063 }
15064 if item != nil {
15065 _flowstatsentry.Instructions = append(_flowstatsentry.Instructions, item)
15066 }
15067 }
15068 return _flowstatsentry, nil
15069}
15070
15071func NewFlowStatsEntry() *FlowStatsEntry {
15072 obj := &FlowStatsEntry{}
15073 return obj
15074}
15075
15076type FlowUpdateFullAdded struct {
15077 *FlowMonitorReplyEntry
15078 TableId uint8
15079 Reason uint8
15080 IdleTimeout uint16
15081 HardTimeout uint16
15082 Priority uint16
15083 Cookie uint64
15084 Match Match
15085 Instructions []IInstruction
15086}
15087
15088type IFlowUpdateFullAdded interface {
15089 IFlowMonitorReplyEntry
15090 GetTableId() uint8
15091 GetReason() uint8
15092 GetIdleTimeout() uint16
15093 GetHardTimeout() uint16
15094 GetPriority() uint16
15095 GetCookie() uint64
15096 GetMatch() Match
15097 GetInstructions() []IInstruction
15098}
15099
15100func (self *FlowUpdateFullAdded) GetTableId() uint8 {
15101 return self.TableId
15102}
15103
15104func (self *FlowUpdateFullAdded) SetTableId(v uint8) {
15105 self.TableId = v
15106}
15107
15108func (self *FlowUpdateFullAdded) GetReason() uint8 {
15109 return self.Reason
15110}
15111
15112func (self *FlowUpdateFullAdded) SetReason(v uint8) {
15113 self.Reason = v
15114}
15115
15116func (self *FlowUpdateFullAdded) GetIdleTimeout() uint16 {
15117 return self.IdleTimeout
15118}
15119
15120func (self *FlowUpdateFullAdded) SetIdleTimeout(v uint16) {
15121 self.IdleTimeout = v
15122}
15123
15124func (self *FlowUpdateFullAdded) GetHardTimeout() uint16 {
15125 return self.HardTimeout
15126}
15127
15128func (self *FlowUpdateFullAdded) SetHardTimeout(v uint16) {
15129 self.HardTimeout = v
15130}
15131
15132func (self *FlowUpdateFullAdded) GetPriority() uint16 {
15133 return self.Priority
15134}
15135
15136func (self *FlowUpdateFullAdded) SetPriority(v uint16) {
15137 self.Priority = v
15138}
15139
15140func (self *FlowUpdateFullAdded) GetCookie() uint64 {
15141 return self.Cookie
15142}
15143
15144func (self *FlowUpdateFullAdded) SetCookie(v uint64) {
15145 self.Cookie = v
15146}
15147
15148func (self *FlowUpdateFullAdded) GetMatch() Match {
15149 return self.Match
15150}
15151
15152func (self *FlowUpdateFullAdded) SetMatch(v Match) {
15153 self.Match = v
15154}
15155
15156func (self *FlowUpdateFullAdded) GetInstructions() []IInstruction {
15157 return self.Instructions
15158}
15159
15160func (self *FlowUpdateFullAdded) SetInstructions(v []IInstruction) {
15161 self.Instructions = v
15162}
15163
15164func (self *FlowUpdateFullAdded) Serialize(encoder *goloxi.Encoder) error {
15165 startIndex := len(encoder.Bytes())
15166 if err := self.FlowMonitorReplyEntry.Serialize(encoder); err != nil {
15167 return err
15168 }
15169
15170 encoder.PutUint8(uint8(self.TableId))
15171 encoder.PutUint8(uint8(self.Reason))
15172 encoder.PutUint16(uint16(self.IdleTimeout))
15173 encoder.PutUint16(uint16(self.HardTimeout))
15174 encoder.PutUint16(uint16(self.Priority))
15175 encoder.Write(bytes.Repeat([]byte{0}, 4))
15176 encoder.PutUint64(uint64(self.Cookie))
15177 if err := self.Match.Serialize(encoder); err != nil {
15178 return err
15179 }
15180
15181 for _, obj := range self.Instructions {
15182 if err := obj.Serialize(encoder); err != nil {
15183 return err
15184 }
15185 }
15186 length := len(encoder.Bytes()) - startIndex
15187
15188 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
15189
15190 return nil
15191}
15192
15193func DecodeFlowUpdateFullAdded(parent *FlowMonitorReplyEntry, decoder *goloxi.Decoder) (*FlowUpdateFullAdded, error) {
15194 _flowupdatefulladded := &FlowUpdateFullAdded{FlowMonitorReplyEntry: parent}
15195 if decoder.Length() < 28 {
15196 return nil, fmt.Errorf("FlowUpdateFullAdded packet too short: %d < 28", decoder.Length())
15197 }
15198 _flowupdatefulladded.TableId = uint8(decoder.ReadByte())
15199 _flowupdatefulladded.Reason = uint8(decoder.ReadByte())
15200 _flowupdatefulladded.IdleTimeout = uint16(decoder.ReadUint16())
15201 _flowupdatefulladded.HardTimeout = uint16(decoder.ReadUint16())
15202 _flowupdatefulladded.Priority = uint16(decoder.ReadUint16())
15203 decoder.Skip(4)
15204 _flowupdatefulladded.Cookie = uint64(decoder.ReadUint64())
15205 if err := _flowupdatefulladded.Match.Decode(decoder); err != nil {
15206 return nil, err
15207 }
15208
15209 decoder.SkipAlign()
15210
15211 for decoder.Length() >= 4 {
15212 item, err := DecodeInstruction(decoder)
15213 if err != nil {
15214 return nil, err
15215 }
15216 if item != nil {
15217 _flowupdatefulladded.Instructions = append(_flowupdatefulladded.Instructions, item)
15218 }
15219 }
15220 return _flowupdatefulladded, nil
15221}
15222
15223func NewFlowUpdateFullAdded() *FlowUpdateFullAdded {
15224 obj := &FlowUpdateFullAdded{
15225 FlowMonitorReplyEntry: NewFlowMonitorReplyEntry(1),
15226 }
15227 return obj
15228}
15229
15230type FlowUpdateFullInitial struct {
15231 *FlowMonitorReplyEntry
15232 TableId uint8
15233 Reason uint8
15234 IdleTimeout uint16
15235 HardTimeout uint16
15236 Priority uint16
15237 Cookie uint64
15238 Match Match
15239 Instructions []IInstruction
15240}
15241
15242type IFlowUpdateFullInitial interface {
15243 IFlowMonitorReplyEntry
15244 GetTableId() uint8
15245 GetReason() uint8
15246 GetIdleTimeout() uint16
15247 GetHardTimeout() uint16
15248 GetPriority() uint16
15249 GetCookie() uint64
15250 GetMatch() Match
15251 GetInstructions() []IInstruction
15252}
15253
15254func (self *FlowUpdateFullInitial) GetTableId() uint8 {
15255 return self.TableId
15256}
15257
15258func (self *FlowUpdateFullInitial) SetTableId(v uint8) {
15259 self.TableId = v
15260}
15261
15262func (self *FlowUpdateFullInitial) GetReason() uint8 {
15263 return self.Reason
15264}
15265
15266func (self *FlowUpdateFullInitial) SetReason(v uint8) {
15267 self.Reason = v
15268}
15269
15270func (self *FlowUpdateFullInitial) GetIdleTimeout() uint16 {
15271 return self.IdleTimeout
15272}
15273
15274func (self *FlowUpdateFullInitial) SetIdleTimeout(v uint16) {
15275 self.IdleTimeout = v
15276}
15277
15278func (self *FlowUpdateFullInitial) GetHardTimeout() uint16 {
15279 return self.HardTimeout
15280}
15281
15282func (self *FlowUpdateFullInitial) SetHardTimeout(v uint16) {
15283 self.HardTimeout = v
15284}
15285
15286func (self *FlowUpdateFullInitial) GetPriority() uint16 {
15287 return self.Priority
15288}
15289
15290func (self *FlowUpdateFullInitial) SetPriority(v uint16) {
15291 self.Priority = v
15292}
15293
15294func (self *FlowUpdateFullInitial) GetCookie() uint64 {
15295 return self.Cookie
15296}
15297
15298func (self *FlowUpdateFullInitial) SetCookie(v uint64) {
15299 self.Cookie = v
15300}
15301
15302func (self *FlowUpdateFullInitial) GetMatch() Match {
15303 return self.Match
15304}
15305
15306func (self *FlowUpdateFullInitial) SetMatch(v Match) {
15307 self.Match = v
15308}
15309
15310func (self *FlowUpdateFullInitial) GetInstructions() []IInstruction {
15311 return self.Instructions
15312}
15313
15314func (self *FlowUpdateFullInitial) SetInstructions(v []IInstruction) {
15315 self.Instructions = v
15316}
15317
15318func (self *FlowUpdateFullInitial) Serialize(encoder *goloxi.Encoder) error {
15319 startIndex := len(encoder.Bytes())
15320 if err := self.FlowMonitorReplyEntry.Serialize(encoder); err != nil {
15321 return err
15322 }
15323
15324 encoder.PutUint8(uint8(self.TableId))
15325 encoder.PutUint8(uint8(self.Reason))
15326 encoder.PutUint16(uint16(self.IdleTimeout))
15327 encoder.PutUint16(uint16(self.HardTimeout))
15328 encoder.PutUint16(uint16(self.Priority))
15329 encoder.Write(bytes.Repeat([]byte{0}, 4))
15330 encoder.PutUint64(uint64(self.Cookie))
15331 if err := self.Match.Serialize(encoder); err != nil {
15332 return err
15333 }
15334
15335 for _, obj := range self.Instructions {
15336 if err := obj.Serialize(encoder); err != nil {
15337 return err
15338 }
15339 }
15340 length := len(encoder.Bytes()) - startIndex
15341
15342 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
15343
15344 return nil
15345}
15346
15347func DecodeFlowUpdateFullInitial(parent *FlowMonitorReplyEntry, decoder *goloxi.Decoder) (*FlowUpdateFullInitial, error) {
15348 _flowupdatefullinitial := &FlowUpdateFullInitial{FlowMonitorReplyEntry: parent}
15349 if decoder.Length() < 28 {
15350 return nil, fmt.Errorf("FlowUpdateFullInitial packet too short: %d < 28", decoder.Length())
15351 }
15352 _flowupdatefullinitial.TableId = uint8(decoder.ReadByte())
15353 _flowupdatefullinitial.Reason = uint8(decoder.ReadByte())
15354 _flowupdatefullinitial.IdleTimeout = uint16(decoder.ReadUint16())
15355 _flowupdatefullinitial.HardTimeout = uint16(decoder.ReadUint16())
15356 _flowupdatefullinitial.Priority = uint16(decoder.ReadUint16())
15357 decoder.Skip(4)
15358 _flowupdatefullinitial.Cookie = uint64(decoder.ReadUint64())
15359 if err := _flowupdatefullinitial.Match.Decode(decoder); err != nil {
15360 return nil, err
15361 }
15362
15363 decoder.SkipAlign()
15364
15365 for decoder.Length() >= 4 {
15366 item, err := DecodeInstruction(decoder)
15367 if err != nil {
15368 return nil, err
15369 }
15370 if item != nil {
15371 _flowupdatefullinitial.Instructions = append(_flowupdatefullinitial.Instructions, item)
15372 }
15373 }
15374 return _flowupdatefullinitial, nil
15375}
15376
15377func NewFlowUpdateFullInitial() *FlowUpdateFullInitial {
15378 obj := &FlowUpdateFullInitial{
15379 FlowMonitorReplyEntry: NewFlowMonitorReplyEntry(0),
15380 }
15381 return obj
15382}
15383
15384type FlowUpdateFullModified struct {
15385 *FlowMonitorReplyEntry
15386 TableId uint8
15387 Reason uint8
15388 IdleTimeout uint16
15389 HardTimeout uint16
15390 Priority uint16
15391 Cookie uint64
15392 Match Match
15393 Instructions []IInstruction
15394}
15395
15396type IFlowUpdateFullModified interface {
15397 IFlowMonitorReplyEntry
15398 GetTableId() uint8
15399 GetReason() uint8
15400 GetIdleTimeout() uint16
15401 GetHardTimeout() uint16
15402 GetPriority() uint16
15403 GetCookie() uint64
15404 GetMatch() Match
15405 GetInstructions() []IInstruction
15406}
15407
15408func (self *FlowUpdateFullModified) GetTableId() uint8 {
15409 return self.TableId
15410}
15411
15412func (self *FlowUpdateFullModified) SetTableId(v uint8) {
15413 self.TableId = v
15414}
15415
15416func (self *FlowUpdateFullModified) GetReason() uint8 {
15417 return self.Reason
15418}
15419
15420func (self *FlowUpdateFullModified) SetReason(v uint8) {
15421 self.Reason = v
15422}
15423
15424func (self *FlowUpdateFullModified) GetIdleTimeout() uint16 {
15425 return self.IdleTimeout
15426}
15427
15428func (self *FlowUpdateFullModified) SetIdleTimeout(v uint16) {
15429 self.IdleTimeout = v
15430}
15431
15432func (self *FlowUpdateFullModified) GetHardTimeout() uint16 {
15433 return self.HardTimeout
15434}
15435
15436func (self *FlowUpdateFullModified) SetHardTimeout(v uint16) {
15437 self.HardTimeout = v
15438}
15439
15440func (self *FlowUpdateFullModified) GetPriority() uint16 {
15441 return self.Priority
15442}
15443
15444func (self *FlowUpdateFullModified) SetPriority(v uint16) {
15445 self.Priority = v
15446}
15447
15448func (self *FlowUpdateFullModified) GetCookie() uint64 {
15449 return self.Cookie
15450}
15451
15452func (self *FlowUpdateFullModified) SetCookie(v uint64) {
15453 self.Cookie = v
15454}
15455
15456func (self *FlowUpdateFullModified) GetMatch() Match {
15457 return self.Match
15458}
15459
15460func (self *FlowUpdateFullModified) SetMatch(v Match) {
15461 self.Match = v
15462}
15463
15464func (self *FlowUpdateFullModified) GetInstructions() []IInstruction {
15465 return self.Instructions
15466}
15467
15468func (self *FlowUpdateFullModified) SetInstructions(v []IInstruction) {
15469 self.Instructions = v
15470}
15471
15472func (self *FlowUpdateFullModified) Serialize(encoder *goloxi.Encoder) error {
15473 startIndex := len(encoder.Bytes())
15474 if err := self.FlowMonitorReplyEntry.Serialize(encoder); err != nil {
15475 return err
15476 }
15477
15478 encoder.PutUint8(uint8(self.TableId))
15479 encoder.PutUint8(uint8(self.Reason))
15480 encoder.PutUint16(uint16(self.IdleTimeout))
15481 encoder.PutUint16(uint16(self.HardTimeout))
15482 encoder.PutUint16(uint16(self.Priority))
15483 encoder.Write(bytes.Repeat([]byte{0}, 4))
15484 encoder.PutUint64(uint64(self.Cookie))
15485 if err := self.Match.Serialize(encoder); err != nil {
15486 return err
15487 }
15488
15489 for _, obj := range self.Instructions {
15490 if err := obj.Serialize(encoder); err != nil {
15491 return err
15492 }
15493 }
15494 length := len(encoder.Bytes()) - startIndex
15495
15496 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
15497
15498 return nil
15499}
15500
15501func DecodeFlowUpdateFullModified(parent *FlowMonitorReplyEntry, decoder *goloxi.Decoder) (*FlowUpdateFullModified, error) {
15502 _flowupdatefullmodified := &FlowUpdateFullModified{FlowMonitorReplyEntry: parent}
15503 if decoder.Length() < 28 {
15504 return nil, fmt.Errorf("FlowUpdateFullModified packet too short: %d < 28", decoder.Length())
15505 }
15506 _flowupdatefullmodified.TableId = uint8(decoder.ReadByte())
15507 _flowupdatefullmodified.Reason = uint8(decoder.ReadByte())
15508 _flowupdatefullmodified.IdleTimeout = uint16(decoder.ReadUint16())
15509 _flowupdatefullmodified.HardTimeout = uint16(decoder.ReadUint16())
15510 _flowupdatefullmodified.Priority = uint16(decoder.ReadUint16())
15511 decoder.Skip(4)
15512 _flowupdatefullmodified.Cookie = uint64(decoder.ReadUint64())
15513 if err := _flowupdatefullmodified.Match.Decode(decoder); err != nil {
15514 return nil, err
15515 }
15516
15517 decoder.SkipAlign()
15518
15519 for decoder.Length() >= 4 {
15520 item, err := DecodeInstruction(decoder)
15521 if err != nil {
15522 return nil, err
15523 }
15524 if item != nil {
15525 _flowupdatefullmodified.Instructions = append(_flowupdatefullmodified.Instructions, item)
15526 }
15527 }
15528 return _flowupdatefullmodified, nil
15529}
15530
15531func NewFlowUpdateFullModified() *FlowUpdateFullModified {
15532 obj := &FlowUpdateFullModified{
15533 FlowMonitorReplyEntry: NewFlowMonitorReplyEntry(3),
15534 }
15535 return obj
15536}
15537
15538type FlowUpdateFullRemoved struct {
15539 *FlowMonitorReplyEntry
15540 TableId uint8
15541 Reason uint8
15542 IdleTimeout uint16
15543 HardTimeout uint16
15544 Priority uint16
15545 Cookie uint64
15546 Match Match
15547 Instructions []IInstruction
15548}
15549
15550type IFlowUpdateFullRemoved interface {
15551 IFlowMonitorReplyEntry
15552 GetTableId() uint8
15553 GetReason() uint8
15554 GetIdleTimeout() uint16
15555 GetHardTimeout() uint16
15556 GetPriority() uint16
15557 GetCookie() uint64
15558 GetMatch() Match
15559 GetInstructions() []IInstruction
15560}
15561
15562func (self *FlowUpdateFullRemoved) GetTableId() uint8 {
15563 return self.TableId
15564}
15565
15566func (self *FlowUpdateFullRemoved) SetTableId(v uint8) {
15567 self.TableId = v
15568}
15569
15570func (self *FlowUpdateFullRemoved) GetReason() uint8 {
15571 return self.Reason
15572}
15573
15574func (self *FlowUpdateFullRemoved) SetReason(v uint8) {
15575 self.Reason = v
15576}
15577
15578func (self *FlowUpdateFullRemoved) GetIdleTimeout() uint16 {
15579 return self.IdleTimeout
15580}
15581
15582func (self *FlowUpdateFullRemoved) SetIdleTimeout(v uint16) {
15583 self.IdleTimeout = v
15584}
15585
15586func (self *FlowUpdateFullRemoved) GetHardTimeout() uint16 {
15587 return self.HardTimeout
15588}
15589
15590func (self *FlowUpdateFullRemoved) SetHardTimeout(v uint16) {
15591 self.HardTimeout = v
15592}
15593
15594func (self *FlowUpdateFullRemoved) GetPriority() uint16 {
15595 return self.Priority
15596}
15597
15598func (self *FlowUpdateFullRemoved) SetPriority(v uint16) {
15599 self.Priority = v
15600}
15601
15602func (self *FlowUpdateFullRemoved) GetCookie() uint64 {
15603 return self.Cookie
15604}
15605
15606func (self *FlowUpdateFullRemoved) SetCookie(v uint64) {
15607 self.Cookie = v
15608}
15609
15610func (self *FlowUpdateFullRemoved) GetMatch() Match {
15611 return self.Match
15612}
15613
15614func (self *FlowUpdateFullRemoved) SetMatch(v Match) {
15615 self.Match = v
15616}
15617
15618func (self *FlowUpdateFullRemoved) GetInstructions() []IInstruction {
15619 return self.Instructions
15620}
15621
15622func (self *FlowUpdateFullRemoved) SetInstructions(v []IInstruction) {
15623 self.Instructions = v
15624}
15625
15626func (self *FlowUpdateFullRemoved) Serialize(encoder *goloxi.Encoder) error {
15627 startIndex := len(encoder.Bytes())
15628 if err := self.FlowMonitorReplyEntry.Serialize(encoder); err != nil {
15629 return err
15630 }
15631
15632 encoder.PutUint8(uint8(self.TableId))
15633 encoder.PutUint8(uint8(self.Reason))
15634 encoder.PutUint16(uint16(self.IdleTimeout))
15635 encoder.PutUint16(uint16(self.HardTimeout))
15636 encoder.PutUint16(uint16(self.Priority))
15637 encoder.Write(bytes.Repeat([]byte{0}, 4))
15638 encoder.PutUint64(uint64(self.Cookie))
15639 if err := self.Match.Serialize(encoder); err != nil {
15640 return err
15641 }
15642
15643 for _, obj := range self.Instructions {
15644 if err := obj.Serialize(encoder); err != nil {
15645 return err
15646 }
15647 }
15648 length := len(encoder.Bytes()) - startIndex
15649
15650 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
15651
15652 return nil
15653}
15654
15655func DecodeFlowUpdateFullRemoved(parent *FlowMonitorReplyEntry, decoder *goloxi.Decoder) (*FlowUpdateFullRemoved, error) {
15656 _flowupdatefullremoved := &FlowUpdateFullRemoved{FlowMonitorReplyEntry: parent}
15657 if decoder.Length() < 28 {
15658 return nil, fmt.Errorf("FlowUpdateFullRemoved packet too short: %d < 28", decoder.Length())
15659 }
15660 _flowupdatefullremoved.TableId = uint8(decoder.ReadByte())
15661 _flowupdatefullremoved.Reason = uint8(decoder.ReadByte())
15662 _flowupdatefullremoved.IdleTimeout = uint16(decoder.ReadUint16())
15663 _flowupdatefullremoved.HardTimeout = uint16(decoder.ReadUint16())
15664 _flowupdatefullremoved.Priority = uint16(decoder.ReadUint16())
15665 decoder.Skip(4)
15666 _flowupdatefullremoved.Cookie = uint64(decoder.ReadUint64())
15667 if err := _flowupdatefullremoved.Match.Decode(decoder); err != nil {
15668 return nil, err
15669 }
15670
15671 decoder.SkipAlign()
15672
15673 for decoder.Length() >= 4 {
15674 item, err := DecodeInstruction(decoder)
15675 if err != nil {
15676 return nil, err
15677 }
15678 if item != nil {
15679 _flowupdatefullremoved.Instructions = append(_flowupdatefullremoved.Instructions, item)
15680 }
15681 }
15682 return _flowupdatefullremoved, nil
15683}
15684
15685func NewFlowUpdateFullRemoved() *FlowUpdateFullRemoved {
15686 obj := &FlowUpdateFullRemoved{
15687 FlowMonitorReplyEntry: NewFlowMonitorReplyEntry(2),
15688 }
15689 return obj
15690}
15691
15692type GroupBucketProp struct {
15693 Type uint16
15694 Length uint16
15695}
15696
15697type IGroupBucketProp interface {
15698 goloxi.Serializable
15699 GetType() uint16
15700 GetLength() uint16
15701}
15702
15703func (self *GroupBucketProp) GetType() uint16 {
15704 return self.Type
15705}
15706
15707func (self *GroupBucketProp) SetType(v uint16) {
15708 self.Type = v
15709}
15710
15711func (self *GroupBucketProp) GetLength() uint16 {
15712 return self.Length
15713}
15714
15715func (self *GroupBucketProp) SetLength(v uint16) {
15716 self.Length = v
15717}
15718
15719func (self *GroupBucketProp) Serialize(encoder *goloxi.Encoder) error {
15720
15721 encoder.PutUint16(uint16(self.Type))
15722 encoder.PutUint16(uint16(self.Length))
15723
15724 return nil
15725}
15726
15727func DecodeGroupBucketProp(decoder *goloxi.Decoder) (IGroupBucketProp, error) {
15728 _groupbucketprop := &GroupBucketProp{}
15729 if decoder.Length() < 4 {
15730 return nil, fmt.Errorf("GroupBucketProp packet too short: %d < 4", decoder.Length())
15731 }
15732 _groupbucketprop.Type = uint16(decoder.ReadUint16())
15733 _groupbucketprop.Length = uint16(decoder.ReadUint16())
15734 oldDecoder := decoder
15735 defer func() { decoder = oldDecoder }()
15736 decoder = decoder.SliceDecoder(int(_groupbucketprop.Length), 2+2)
15737
15738 switch _groupbucketprop.Type {
15739 case 0:
15740 return DecodeGroupBucketPropWeight(_groupbucketprop, decoder)
15741 case 1:
15742 return DecodeGroupBucketPropWatchPort(_groupbucketprop, decoder)
15743 case 2:
15744 return DecodeGroupBucketPropWatchGroup(_groupbucketprop, decoder)
15745 case 3:
15746 return DecodeGroupBucketPropExperimenter(_groupbucketprop, decoder)
15747 default:
15748 return nil, fmt.Errorf("Invalid type '%d' for 'GroupBucketProp'", _groupbucketprop.Type)
15749 }
15750}
15751
15752func NewGroupBucketProp(_type uint16) *GroupBucketProp {
15753 obj := &GroupBucketProp{}
15754 obj.Type = _type
15755 return obj
15756}
15757
15758type GroupBucketPropExperimenter struct {
15759 *GroupBucketProp
15760 Experimenter uint32
15761 ExpType uint32
15762}
15763
15764type IGroupBucketPropExperimenter interface {
15765 IGroupBucketProp
15766 GetExperimenter() uint32
15767 GetExpType() uint32
15768}
15769
15770func (self *GroupBucketPropExperimenter) GetExperimenter() uint32 {
15771 return self.Experimenter
15772}
15773
15774func (self *GroupBucketPropExperimenter) SetExperimenter(v uint32) {
15775 self.Experimenter = v
15776}
15777
15778func (self *GroupBucketPropExperimenter) GetExpType() uint32 {
15779 return self.ExpType
15780}
15781
15782func (self *GroupBucketPropExperimenter) SetExpType(v uint32) {
15783 self.ExpType = v
15784}
15785
15786func (self *GroupBucketPropExperimenter) Serialize(encoder *goloxi.Encoder) error {
15787 if err := self.GroupBucketProp.Serialize(encoder); err != nil {
15788 return err
15789 }
15790
15791 encoder.PutUint32(uint32(self.Experimenter))
15792 encoder.PutUint32(uint32(self.ExpType))
15793
15794 return nil
15795}
15796
15797func DecodeGroupBucketPropExperimenter(parent *GroupBucketProp, decoder *goloxi.Decoder) (IGroupBucketPropExperimenter, error) {
15798 _groupbucketpropexperimenter := &GroupBucketPropExperimenter{GroupBucketProp: parent}
15799 if decoder.Length() < 8 {
15800 return nil, fmt.Errorf("GroupBucketPropExperimenter packet too short: %d < 8", decoder.Length())
15801 }
15802 _groupbucketpropexperimenter.Experimenter = uint32(decoder.ReadUint32())
15803 _groupbucketpropexperimenter.ExpType = uint32(decoder.ReadUint32())
15804 return _groupbucketpropexperimenter, nil
15805}
15806
15807func NewGroupBucketPropExperimenter(_experimenter uint32) *GroupBucketPropExperimenter {
15808 obj := &GroupBucketPropExperimenter{
15809 GroupBucketProp: NewGroupBucketProp(3),
15810 }
15811 obj.Experimenter = _experimenter
15812 return obj
15813}
15814
15815type GroupBucketPropWatchGroup struct {
15816 *GroupBucketProp
15817 Watch uint32
15818}
15819
15820type IGroupBucketPropWatchGroup interface {
15821 IGroupBucketProp
15822 GetWatch() uint32
15823}
15824
15825func (self *GroupBucketPropWatchGroup) GetWatch() uint32 {
15826 return self.Watch
15827}
15828
15829func (self *GroupBucketPropWatchGroup) SetWatch(v uint32) {
15830 self.Watch = v
15831}
15832
15833func (self *GroupBucketPropWatchGroup) Serialize(encoder *goloxi.Encoder) error {
15834 startIndex := len(encoder.Bytes())
15835 if err := self.GroupBucketProp.Serialize(encoder); err != nil {
15836 return err
15837 }
15838
15839 encoder.PutUint32(uint32(self.Watch))
15840 length := len(encoder.Bytes()) - startIndex
15841
15842 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
15843
15844 return nil
15845}
15846
15847func DecodeGroupBucketPropWatchGroup(parent *GroupBucketProp, decoder *goloxi.Decoder) (*GroupBucketPropWatchGroup, error) {
15848 _groupbucketpropwatchgroup := &GroupBucketPropWatchGroup{GroupBucketProp: parent}
15849 if decoder.Length() < 4 {
15850 return nil, fmt.Errorf("GroupBucketPropWatchGroup packet too short: %d < 4", decoder.Length())
15851 }
15852 _groupbucketpropwatchgroup.Watch = uint32(decoder.ReadUint32())
15853 return _groupbucketpropwatchgroup, nil
15854}
15855
15856func NewGroupBucketPropWatchGroup() *GroupBucketPropWatchGroup {
15857 obj := &GroupBucketPropWatchGroup{
15858 GroupBucketProp: NewGroupBucketProp(2),
15859 }
15860 return obj
15861}
15862
15863type GroupBucketPropWatchPort struct {
15864 *GroupBucketProp
15865 Watch uint32
15866}
15867
15868type IGroupBucketPropWatchPort interface {
15869 IGroupBucketProp
15870 GetWatch() uint32
15871}
15872
15873func (self *GroupBucketPropWatchPort) GetWatch() uint32 {
15874 return self.Watch
15875}
15876
15877func (self *GroupBucketPropWatchPort) SetWatch(v uint32) {
15878 self.Watch = v
15879}
15880
15881func (self *GroupBucketPropWatchPort) Serialize(encoder *goloxi.Encoder) error {
15882 startIndex := len(encoder.Bytes())
15883 if err := self.GroupBucketProp.Serialize(encoder); err != nil {
15884 return err
15885 }
15886
15887 encoder.PutUint32(uint32(self.Watch))
15888 length := len(encoder.Bytes()) - startIndex
15889
15890 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
15891
15892 return nil
15893}
15894
15895func DecodeGroupBucketPropWatchPort(parent *GroupBucketProp, decoder *goloxi.Decoder) (*GroupBucketPropWatchPort, error) {
15896 _groupbucketpropwatchport := &GroupBucketPropWatchPort{GroupBucketProp: parent}
15897 if decoder.Length() < 4 {
15898 return nil, fmt.Errorf("GroupBucketPropWatchPort packet too short: %d < 4", decoder.Length())
15899 }
15900 _groupbucketpropwatchport.Watch = uint32(decoder.ReadUint32())
15901 return _groupbucketpropwatchport, nil
15902}
15903
15904func NewGroupBucketPropWatchPort() *GroupBucketPropWatchPort {
15905 obj := &GroupBucketPropWatchPort{
15906 GroupBucketProp: NewGroupBucketProp(1),
15907 }
15908 return obj
15909}
15910
15911type GroupBucketPropWeight struct {
15912 *GroupBucketProp
15913 Weight uint16
15914}
15915
15916type IGroupBucketPropWeight interface {
15917 IGroupBucketProp
15918 GetWeight() uint16
15919}
15920
15921func (self *GroupBucketPropWeight) GetWeight() uint16 {
15922 return self.Weight
15923}
15924
15925func (self *GroupBucketPropWeight) SetWeight(v uint16) {
15926 self.Weight = v
15927}
15928
15929func (self *GroupBucketPropWeight) Serialize(encoder *goloxi.Encoder) error {
15930 startIndex := len(encoder.Bytes())
15931 if err := self.GroupBucketProp.Serialize(encoder); err != nil {
15932 return err
15933 }
15934
15935 encoder.PutUint16(uint16(self.Weight))
15936 encoder.Write(bytes.Repeat([]byte{0}, 2))
15937 length := len(encoder.Bytes()) - startIndex
15938
15939 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
15940
15941 return nil
15942}
15943
15944func DecodeGroupBucketPropWeight(parent *GroupBucketProp, decoder *goloxi.Decoder) (*GroupBucketPropWeight, error) {
15945 _groupbucketpropweight := &GroupBucketPropWeight{GroupBucketProp: parent}
15946 if decoder.Length() < 4 {
15947 return nil, fmt.Errorf("GroupBucketPropWeight packet too short: %d < 4", decoder.Length())
15948 }
15949 _groupbucketpropweight.Weight = uint16(decoder.ReadUint16())
15950 decoder.Skip(2)
15951 return _groupbucketpropweight, nil
15952}
15953
15954func NewGroupBucketPropWeight() *GroupBucketPropWeight {
15955 obj := &GroupBucketPropWeight{
15956 GroupBucketProp: NewGroupBucketProp(0),
15957 }
15958 return obj
15959}
15960
15961type GroupDescStatsEntry struct {
15962 Length uint16
15963 GroupType GroupType
15964 GroupId uint32
15965 BucketArrayLen uint16
15966 Buckets []*Bucket
15967 Properties []IGroupProp
15968}
15969
15970type IGroupDescStatsEntry interface {
15971 goloxi.Serializable
15972 GetLength() uint16
15973 GetGroupType() GroupType
15974 GetGroupId() uint32
15975 GetBucketArrayLen() uint16
15976 GetBuckets() []*Bucket
15977 GetProperties() []IGroupProp
15978}
15979
15980func (self *GroupDescStatsEntry) GetLength() uint16 {
15981 return self.Length
15982}
15983
15984func (self *GroupDescStatsEntry) SetLength(v uint16) {
15985 self.Length = v
15986}
15987
15988func (self *GroupDescStatsEntry) GetGroupType() GroupType {
15989 return self.GroupType
15990}
15991
15992func (self *GroupDescStatsEntry) SetGroupType(v GroupType) {
15993 self.GroupType = v
15994}
15995
15996func (self *GroupDescStatsEntry) GetGroupId() uint32 {
15997 return self.GroupId
15998}
15999
16000func (self *GroupDescStatsEntry) SetGroupId(v uint32) {
16001 self.GroupId = v
16002}
16003
16004func (self *GroupDescStatsEntry) GetBucketArrayLen() uint16 {
16005 return self.BucketArrayLen
16006}
16007
16008func (self *GroupDescStatsEntry) SetBucketArrayLen(v uint16) {
16009 self.BucketArrayLen = v
16010}
16011
16012func (self *GroupDescStatsEntry) GetBuckets() []*Bucket {
16013 return self.Buckets
16014}
16015
16016func (self *GroupDescStatsEntry) SetBuckets(v []*Bucket) {
16017 self.Buckets = v
16018}
16019
16020func (self *GroupDescStatsEntry) GetProperties() []IGroupProp {
16021 return self.Properties
16022}
16023
16024func (self *GroupDescStatsEntry) SetProperties(v []IGroupProp) {
16025 self.Properties = v
16026}
16027
16028func (self *GroupDescStatsEntry) Serialize(encoder *goloxi.Encoder) error {
16029 startIndex := len(encoder.Bytes())
16030
16031 encoder.PutUint16(uint16(self.Length))
16032 encoder.PutUint8(uint8(self.GroupType))
16033 encoder.Write(bytes.Repeat([]byte{0}, 1))
16034 encoder.PutUint32(uint32(self.GroupId))
16035 encoder.PutUint16(uint16(self.BucketArrayLen))
16036 encoder.Write(bytes.Repeat([]byte{0}, 6))
16037 for _, obj := range self.Buckets {
16038 if err := obj.Serialize(encoder); err != nil {
16039 return err
16040 }
16041 }
16042 for _, obj := range self.Properties {
16043 if err := obj.Serialize(encoder); err != nil {
16044 return err
16045 }
16046 }
16047 length := len(encoder.Bytes()) - startIndex
16048
16049 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
16050
16051 return nil
16052}
16053
16054func DecodeGroupDescStatsEntry(decoder *goloxi.Decoder) (*GroupDescStatsEntry, error) {
16055 _groupdescstatsentry := &GroupDescStatsEntry{}
16056 if decoder.Length() < 16 {
16057 return nil, fmt.Errorf("GroupDescStatsEntry packet too short: %d < 16", decoder.Length())
16058 }
16059 _groupdescstatsentry.Length = uint16(decoder.ReadUint16())
16060 oldDecoder := decoder
16061 defer func() { decoder = oldDecoder }()
16062 decoder = decoder.SliceDecoder(int(_groupdescstatsentry.Length), 2+0)
16063 _groupdescstatsentry.GroupType = GroupType(decoder.ReadByte())
16064 decoder.Skip(1)
16065 _groupdescstatsentry.GroupId = uint32(decoder.ReadUint32())
16066 _groupdescstatsentry.BucketArrayLen = uint16(decoder.ReadUint16())
16067 decoder.Skip(6)
16068
16069 end := decoder.Offset() + int(_groupdescstatsentry.BucketArrayLen)
16070 for decoder.Offset() < end {
16071 item, err := DecodeBucket(decoder)
16072 if err != nil {
16073 return nil, err
16074 }
16075 if item != nil {
16076 _groupdescstatsentry.Buckets = append(_groupdescstatsentry.Buckets, item)
16077 }
16078 }
16079
16080 for decoder.Length() >= 4 {
16081 item, err := DecodeGroupProp(decoder)
16082 if err != nil {
16083 return nil, err
16084 }
16085 if item != nil {
16086 _groupdescstatsentry.Properties = append(_groupdescstatsentry.Properties, item)
16087 }
16088 }
16089 return _groupdescstatsentry, nil
16090}
16091
16092func NewGroupDescStatsEntry() *GroupDescStatsEntry {
16093 obj := &GroupDescStatsEntry{}
16094 return obj
16095}
16096
16097type GroupProp struct {
16098 Type uint16
16099 Length uint16
16100}
16101
16102type IGroupProp interface {
16103 goloxi.Serializable
16104 GetType() uint16
16105 GetLength() uint16
16106}
16107
16108func (self *GroupProp) GetType() uint16 {
16109 return self.Type
16110}
16111
16112func (self *GroupProp) SetType(v uint16) {
16113 self.Type = v
16114}
16115
16116func (self *GroupProp) GetLength() uint16 {
16117 return self.Length
16118}
16119
16120func (self *GroupProp) SetLength(v uint16) {
16121 self.Length = v
16122}
16123
16124func (self *GroupProp) Serialize(encoder *goloxi.Encoder) error {
16125
16126 encoder.PutUint16(uint16(self.Type))
16127 encoder.PutUint16(uint16(self.Length))
16128
16129 return nil
16130}
16131
16132func DecodeGroupProp(decoder *goloxi.Decoder) (IGroupProp, error) {
16133 _groupprop := &GroupProp{}
16134 if decoder.Length() < 4 {
16135 return nil, fmt.Errorf("GroupProp packet too short: %d < 4", decoder.Length())
16136 }
16137 _groupprop.Type = uint16(decoder.ReadUint16())
16138 _groupprop.Length = uint16(decoder.ReadUint16())
16139 oldDecoder := decoder
16140 defer func() { decoder = oldDecoder }()
16141 decoder = decoder.SliceDecoder(int(_groupprop.Length), 2+2)
16142 return _groupprop, nil
16143}
16144
16145func NewGroupProp(_type uint16) *GroupProp {
16146 obj := &GroupProp{}
16147 obj.Type = _type
16148 return obj
16149}
16150
16151type GroupPropExperimenter struct {
16152 Type uint16
16153 Length uint16
16154 Experimenter uint32
16155 ExpType uint32
16156}
16157
16158type IGroupPropExperimenter interface {
16159 goloxi.Serializable
16160 GetType() uint16
16161 GetLength() uint16
16162 GetExperimenter() uint32
16163 GetExpType() uint32
16164}
16165
16166func (self *GroupPropExperimenter) GetType() uint16 {
16167 return self.Type
16168}
16169
16170func (self *GroupPropExperimenter) SetType(v uint16) {
16171 self.Type = v
16172}
16173
16174func (self *GroupPropExperimenter) GetLength() uint16 {
16175 return self.Length
16176}
16177
16178func (self *GroupPropExperimenter) SetLength(v uint16) {
16179 self.Length = v
16180}
16181
16182func (self *GroupPropExperimenter) GetExperimenter() uint32 {
16183 return self.Experimenter
16184}
16185
16186func (self *GroupPropExperimenter) SetExperimenter(v uint32) {
16187 self.Experimenter = v
16188}
16189
16190func (self *GroupPropExperimenter) GetExpType() uint32 {
16191 return self.ExpType
16192}
16193
16194func (self *GroupPropExperimenter) SetExpType(v uint32) {
16195 self.ExpType = v
16196}
16197
16198func (self *GroupPropExperimenter) Serialize(encoder *goloxi.Encoder) error {
16199
16200 encoder.PutUint16(uint16(self.Type))
16201 encoder.PutUint16(uint16(self.Length))
16202 encoder.PutUint32(uint32(self.Experimenter))
16203 encoder.PutUint32(uint32(self.ExpType))
16204
16205 return nil
16206}
16207
16208func DecodeGroupPropExperimenter(decoder *goloxi.Decoder) (IGroupPropExperimenter, error) {
16209 _grouppropexperimenter := &GroupPropExperimenter{}
16210 if decoder.Length() < 12 {
16211 return nil, fmt.Errorf("GroupPropExperimenter packet too short: %d < 12", decoder.Length())
16212 }
16213 _grouppropexperimenter.Type = uint16(decoder.ReadUint16())
16214 _grouppropexperimenter.Length = uint16(decoder.ReadUint16())
16215 oldDecoder := decoder
16216 defer func() { decoder = oldDecoder }()
16217 decoder = decoder.SliceDecoder(int(_grouppropexperimenter.Length), 2+2)
16218 _grouppropexperimenter.Experimenter = uint32(decoder.ReadUint32())
16219 _grouppropexperimenter.ExpType = uint32(decoder.ReadUint32())
16220 return _grouppropexperimenter, nil
16221}
16222
16223func NewGroupPropExperimenter(_experimenter uint32) *GroupPropExperimenter {
16224 obj := &GroupPropExperimenter{}
16225 obj.Experimenter = _experimenter
16226 return obj
16227}
16228
16229type GroupStatsEntry struct {
16230 Length uint16
16231 GroupId uint32
16232 RefCount uint32
16233 PacketCount uint64
16234 ByteCount uint64
16235 DurationSec uint32
16236 DurationNsec uint32
16237 BucketStats []*BucketCounter
16238}
16239
16240type IGroupStatsEntry interface {
16241 goloxi.Serializable
16242 GetLength() uint16
16243 GetGroupId() uint32
16244 GetRefCount() uint32
16245 GetPacketCount() uint64
16246 GetByteCount() uint64
16247 GetDurationSec() uint32
16248 GetDurationNsec() uint32
16249 GetBucketStats() []*BucketCounter
16250}
16251
16252func (self *GroupStatsEntry) GetLength() uint16 {
16253 return self.Length
16254}
16255
16256func (self *GroupStatsEntry) SetLength(v uint16) {
16257 self.Length = v
16258}
16259
16260func (self *GroupStatsEntry) GetGroupId() uint32 {
16261 return self.GroupId
16262}
16263
16264func (self *GroupStatsEntry) SetGroupId(v uint32) {
16265 self.GroupId = v
16266}
16267
16268func (self *GroupStatsEntry) GetRefCount() uint32 {
16269 return self.RefCount
16270}
16271
16272func (self *GroupStatsEntry) SetRefCount(v uint32) {
16273 self.RefCount = v
16274}
16275
16276func (self *GroupStatsEntry) GetPacketCount() uint64 {
16277 return self.PacketCount
16278}
16279
16280func (self *GroupStatsEntry) SetPacketCount(v uint64) {
16281 self.PacketCount = v
16282}
16283
16284func (self *GroupStatsEntry) GetByteCount() uint64 {
16285 return self.ByteCount
16286}
16287
16288func (self *GroupStatsEntry) SetByteCount(v uint64) {
16289 self.ByteCount = v
16290}
16291
16292func (self *GroupStatsEntry) GetDurationSec() uint32 {
16293 return self.DurationSec
16294}
16295
16296func (self *GroupStatsEntry) SetDurationSec(v uint32) {
16297 self.DurationSec = v
16298}
16299
16300func (self *GroupStatsEntry) GetDurationNsec() uint32 {
16301 return self.DurationNsec
16302}
16303
16304func (self *GroupStatsEntry) SetDurationNsec(v uint32) {
16305 self.DurationNsec = v
16306}
16307
16308func (self *GroupStatsEntry) GetBucketStats() []*BucketCounter {
16309 return self.BucketStats
16310}
16311
16312func (self *GroupStatsEntry) SetBucketStats(v []*BucketCounter) {
16313 self.BucketStats = v
16314}
16315
16316func (self *GroupStatsEntry) Serialize(encoder *goloxi.Encoder) error {
16317 startIndex := len(encoder.Bytes())
16318
16319 encoder.PutUint16(uint16(self.Length))
16320 encoder.Write(bytes.Repeat([]byte{0}, 2))
16321 encoder.PutUint32(uint32(self.GroupId))
16322 encoder.PutUint32(uint32(self.RefCount))
16323 encoder.Write(bytes.Repeat([]byte{0}, 4))
16324 encoder.PutUint64(uint64(self.PacketCount))
16325 encoder.PutUint64(uint64(self.ByteCount))
16326 encoder.PutUint32(uint32(self.DurationSec))
16327 encoder.PutUint32(uint32(self.DurationNsec))
16328 for _, obj := range self.BucketStats {
16329 if err := obj.Serialize(encoder); err != nil {
16330 return err
16331 }
16332 }
16333 length := len(encoder.Bytes()) - startIndex
16334
16335 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
16336
16337 return nil
16338}
16339
16340func DecodeGroupStatsEntry(decoder *goloxi.Decoder) (*GroupStatsEntry, error) {
16341 _groupstatsentry := &GroupStatsEntry{}
16342 if decoder.Length() < 40 {
16343 return nil, fmt.Errorf("GroupStatsEntry packet too short: %d < 40", decoder.Length())
16344 }
16345 _groupstatsentry.Length = uint16(decoder.ReadUint16())
16346 oldDecoder := decoder
16347 defer func() { decoder = oldDecoder }()
16348 decoder = decoder.SliceDecoder(int(_groupstatsentry.Length), 2+0)
16349 decoder.Skip(2)
16350 _groupstatsentry.GroupId = uint32(decoder.ReadUint32())
16351 _groupstatsentry.RefCount = uint32(decoder.ReadUint32())
16352 decoder.Skip(4)
16353 _groupstatsentry.PacketCount = uint64(decoder.ReadUint64())
16354 _groupstatsentry.ByteCount = uint64(decoder.ReadUint64())
16355 _groupstatsentry.DurationSec = uint32(decoder.ReadUint32())
16356 _groupstatsentry.DurationNsec = uint32(decoder.ReadUint32())
16357
16358 for decoder.Length() >= 16 {
16359 item, err := DecodeBucketCounter(decoder)
16360 if err != nil {
16361 return nil, err
16362 }
16363 if item != nil {
16364 _groupstatsentry.BucketStats = append(_groupstatsentry.BucketStats, item)
16365 }
16366 }
16367 return _groupstatsentry, nil
16368}
16369
16370func NewGroupStatsEntry() *GroupStatsEntry {
16371 obj := &GroupStatsEntry{}
16372 return obj
16373}
16374
16375type HeaderType struct {
16376 Namespace HeaderTypeNamespace
16377 NsType uint16
16378}
16379
16380type IHeaderType interface {
16381 goloxi.Serializable
16382 GetNamespace() HeaderTypeNamespace
16383 GetNsType() uint16
16384}
16385
16386func (self *HeaderType) GetNamespace() HeaderTypeNamespace {
16387 return self.Namespace
16388}
16389
16390func (self *HeaderType) SetNamespace(v HeaderTypeNamespace) {
16391 self.Namespace = v
16392}
16393
16394func (self *HeaderType) GetNsType() uint16 {
16395 return self.NsType
16396}
16397
16398func (self *HeaderType) SetNsType(v uint16) {
16399 self.NsType = v
16400}
16401
16402func (self *HeaderType) Serialize(encoder *goloxi.Encoder) error {
16403
16404 encoder.PutUint16(uint16(self.Namespace))
16405 encoder.PutUint16(uint16(self.NsType))
16406
16407 return nil
16408}
16409
16410func DecodeHeaderType(decoder *goloxi.Decoder) (IHeaderType, error) {
16411 _headertype := &HeaderType{}
16412 if decoder.Length() < 4 {
16413 return nil, fmt.Errorf("HeaderType packet too short: %d < 4", decoder.Length())
16414 }
16415 _headertype.Namespace = HeaderTypeNamespace(decoder.ReadUint16())
16416 _headertype.NsType = uint16(decoder.ReadUint16())
16417 return _headertype, nil
16418}
16419
16420func NewHeaderType(_namespace HeaderTypeNamespace) *HeaderType {
16421 obj := &HeaderType{}
16422 obj.Namespace = _namespace
16423 return obj
16424}
16425
16426type HelloElem struct {
16427 Type uint16
16428 Length uint16
16429}
16430
16431type IHelloElem interface {
16432 goloxi.Serializable
16433 GetType() uint16
16434 GetLength() uint16
16435}
16436
16437func (self *HelloElem) GetType() uint16 {
16438 return self.Type
16439}
16440
16441func (self *HelloElem) SetType(v uint16) {
16442 self.Type = v
16443}
16444
16445func (self *HelloElem) GetLength() uint16 {
16446 return self.Length
16447}
16448
16449func (self *HelloElem) SetLength(v uint16) {
16450 self.Length = v
16451}
16452
16453func (self *HelloElem) Serialize(encoder *goloxi.Encoder) error {
16454
16455 encoder.PutUint16(uint16(self.Type))
16456 encoder.PutUint16(uint16(self.Length))
16457
16458 return nil
16459}
16460
16461func DecodeHelloElem(decoder *goloxi.Decoder) (IHelloElem, error) {
16462 _helloelem := &HelloElem{}
16463 if decoder.Length() < 4 {
16464 return nil, fmt.Errorf("HelloElem packet too short: %d < 4", decoder.Length())
16465 }
16466 _helloelem.Type = uint16(decoder.ReadUint16())
16467 _helloelem.Length = uint16(decoder.ReadUint16())
16468 oldDecoder := decoder
16469 defer func() { decoder = oldDecoder }()
16470 decoder = decoder.SliceDecoder(int(_helloelem.Length), 2+2)
16471
16472 switch _helloelem.Type {
16473 case 1:
16474 return DecodeHelloElemVersionbitmap(_helloelem, decoder)
16475 default:
16476 return nil, fmt.Errorf("Invalid type '%d' for 'HelloElem'", _helloelem.Type)
16477 }
16478}
16479
16480func NewHelloElem(_type uint16) *HelloElem {
16481 obj := &HelloElem{}
16482 obj.Type = _type
16483 return obj
16484}
16485
16486type HelloElemVersionbitmap struct {
16487 *HelloElem
16488 Bitmaps []*Uint32
16489}
16490
16491type IHelloElemVersionbitmap interface {
16492 IHelloElem
16493 GetBitmaps() []*Uint32
16494}
16495
16496func (self *HelloElemVersionbitmap) GetBitmaps() []*Uint32 {
16497 return self.Bitmaps
16498}
16499
16500func (self *HelloElemVersionbitmap) SetBitmaps(v []*Uint32) {
16501 self.Bitmaps = v
16502}
16503
16504func (self *HelloElemVersionbitmap) Serialize(encoder *goloxi.Encoder) error {
16505 startIndex := len(encoder.Bytes())
16506 if err := self.HelloElem.Serialize(encoder); err != nil {
16507 return err
16508 }
16509
16510 for _, obj := range self.Bitmaps {
16511 if err := obj.Serialize(encoder); err != nil {
16512 return err
16513 }
16514 }
16515 length := len(encoder.Bytes()) - startIndex
16516
16517 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
16518
16519 return nil
16520}
16521
16522func DecodeHelloElemVersionbitmap(parent *HelloElem, decoder *goloxi.Decoder) (*HelloElemVersionbitmap, error) {
16523 _helloelemversionbitmap := &HelloElemVersionbitmap{HelloElem: parent}
16524
16525 for decoder.Length() >= 4 {
16526 item, err := DecodeUint32(decoder)
16527 if err != nil {
16528 return nil, err
16529 }
16530 if item != nil {
16531 _helloelemversionbitmap.Bitmaps = append(_helloelemversionbitmap.Bitmaps, item)
16532 }
16533 }
16534 return _helloelemversionbitmap, nil
16535}
16536
16537func NewHelloElemVersionbitmap() *HelloElemVersionbitmap {
16538 obj := &HelloElemVersionbitmap{
16539 HelloElem: NewHelloElem(1),
16540 }
16541 return obj
16542}
16543
16544type InstructionId struct {
16545 Type uint16
16546 Len uint16
16547}
16548
16549type IInstructionId interface {
16550 goloxi.Serializable
16551 GetType() uint16
16552 GetLen() uint16
16553}
16554
16555func (self *InstructionId) GetType() uint16 {
16556 return self.Type
16557}
16558
16559func (self *InstructionId) SetType(v uint16) {
16560 self.Type = v
16561}
16562
16563func (self *InstructionId) GetLen() uint16 {
16564 return self.Len
16565}
16566
16567func (self *InstructionId) SetLen(v uint16) {
16568 self.Len = v
16569}
16570
16571func (self *InstructionId) Serialize(encoder *goloxi.Encoder) error {
16572
16573 encoder.PutUint16(uint16(self.Type))
16574 encoder.PutUint16(uint16(self.Len))
16575
16576 return nil
16577}
16578
16579func DecodeInstructionId(decoder *goloxi.Decoder) (IInstructionId, error) {
16580 _instructionid := &InstructionId{}
16581 if decoder.Length() < 4 {
16582 return nil, fmt.Errorf("InstructionId packet too short: %d < 4", decoder.Length())
16583 }
16584 _instructionid.Type = uint16(decoder.ReadUint16())
16585 _instructionid.Len = uint16(decoder.ReadUint16())
16586 oldDecoder := decoder
16587 defer func() { decoder = oldDecoder }()
16588 decoder = decoder.SliceDecoder(int(_instructionid.Len), 2+2)
16589
16590 switch _instructionid.Type {
16591 case 1:
16592 return DecodeInstructionIdGotoTable(_instructionid, decoder)
16593 case 2:
16594 return DecodeInstructionIdWriteMetadata(_instructionid, decoder)
16595 case 3:
16596 return DecodeInstructionIdWriteActions(_instructionid, decoder)
16597 case 4:
16598 return DecodeInstructionIdApplyActions(_instructionid, decoder)
16599 case 5:
16600 return DecodeInstructionIdClearActions(_instructionid, decoder)
16601 case 7:
16602 return DecodeInstructionIdStatTrigger(_instructionid, decoder)
16603 case 65535:
16604 return DecodeInstructionIdExperimenter(_instructionid, decoder)
16605 default:
16606 return nil, fmt.Errorf("Invalid type '%d' for 'InstructionId'", _instructionid.Type)
16607 }
16608}
16609
16610func NewInstructionId(_type uint16) *InstructionId {
16611 obj := &InstructionId{}
16612 obj.Type = _type
16613 return obj
16614}
16615
16616type InstructionIdApplyActions struct {
16617 *InstructionId
16618}
16619
16620type IInstructionIdApplyActions interface {
16621 IInstructionId
16622}
16623
16624func (self *InstructionIdApplyActions) Serialize(encoder *goloxi.Encoder) error {
16625 startIndex := len(encoder.Bytes())
16626 if err := self.InstructionId.Serialize(encoder); err != nil {
16627 return err
16628 }
16629 length := len(encoder.Bytes()) - startIndex
16630
16631 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
16632
16633 return nil
16634}
16635
16636func DecodeInstructionIdApplyActions(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdApplyActions, error) {
16637 _instructionidapplyactions := &InstructionIdApplyActions{InstructionId: parent}
16638 return _instructionidapplyactions, nil
16639}
16640
16641func NewInstructionIdApplyActions() *InstructionIdApplyActions {
16642 obj := &InstructionIdApplyActions{
16643 InstructionId: NewInstructionId(4),
16644 }
16645 return obj
16646}
16647
16648type InstructionIdExperimenter struct {
16649 *InstructionId
16650 Experimenter uint32
16651}
16652
16653type IInstructionIdExperimenter interface {
16654 IInstructionId
16655 GetExperimenter() uint32
16656}
16657
16658func (self *InstructionIdExperimenter) GetExperimenter() uint32 {
16659 return self.Experimenter
16660}
16661
16662func (self *InstructionIdExperimenter) SetExperimenter(v uint32) {
16663 self.Experimenter = v
16664}
16665
16666func (self *InstructionIdExperimenter) Serialize(encoder *goloxi.Encoder) error {
16667 if err := self.InstructionId.Serialize(encoder); err != nil {
16668 return err
16669 }
16670
16671 encoder.PutUint32(uint32(self.Experimenter))
16672
16673 return nil
16674}
16675
16676func DecodeInstructionIdExperimenter(parent *InstructionId, decoder *goloxi.Decoder) (IInstructionIdExperimenter, error) {
16677 _instructionidexperimenter := &InstructionIdExperimenter{InstructionId: parent}
16678 if decoder.Length() < 4 {
16679 return nil, fmt.Errorf("InstructionIdExperimenter packet too short: %d < 4", decoder.Length())
16680 }
16681 _instructionidexperimenter.Experimenter = uint32(decoder.ReadUint32())
16682
16683 switch _instructionidexperimenter.Experimenter {
16684 case 6035143:
16685 return DecodeInstructionIdBsn(_instructionidexperimenter, decoder)
16686 default:
16687 return nil, fmt.Errorf("Invalid type '%d' for 'InstructionIdExperimenter'", _instructionidexperimenter.Experimenter)
16688 }
16689}
16690
16691func NewInstructionIdExperimenter(_experimenter uint32) *InstructionIdExperimenter {
16692 obj := &InstructionIdExperimenter{
16693 InstructionId: NewInstructionId(65535),
16694 }
16695 obj.Experimenter = _experimenter
16696 return obj
16697}
16698
16699type InstructionIdBsn struct {
16700 *InstructionIdExperimenter
16701 Subtype uint32
16702}
16703
16704type IInstructionIdBsn interface {
16705 IInstructionIdExperimenter
16706 GetSubtype() uint32
16707}
16708
16709func (self *InstructionIdBsn) GetSubtype() uint32 {
16710 return self.Subtype
16711}
16712
16713func (self *InstructionIdBsn) SetSubtype(v uint32) {
16714 self.Subtype = v
16715}
16716
16717func (self *InstructionIdBsn) Serialize(encoder *goloxi.Encoder) error {
16718 if err := self.InstructionIdExperimenter.Serialize(encoder); err != nil {
16719 return err
16720 }
16721
16722 encoder.PutUint32(uint32(self.Subtype))
16723
16724 return nil
16725}
16726
16727func DecodeInstructionIdBsn(parent *InstructionIdExperimenter, decoder *goloxi.Decoder) (IInstructionIdBsn, error) {
16728 _instructionidbsn := &InstructionIdBsn{InstructionIdExperimenter: parent}
16729 if decoder.Length() < 4 {
16730 return nil, fmt.Errorf("InstructionIdBsn packet too short: %d < 4", decoder.Length())
16731 }
16732 _instructionidbsn.Subtype = uint32(decoder.ReadUint32())
16733
16734 switch _instructionidbsn.Subtype {
16735 case 0:
16736 return DecodeInstructionIdBsnDisableSrcMacCheck(_instructionidbsn, decoder)
16737 case 1:
16738 return DecodeInstructionIdBsnArpOffload(_instructionidbsn, decoder)
16739 case 2:
16740 return DecodeInstructionIdBsnDhcpOffload(_instructionidbsn, decoder)
16741 case 4:
16742 return DecodeInstructionIdBsnPermit(_instructionidbsn, decoder)
16743 case 5:
16744 return DecodeInstructionIdBsnDeny(_instructionidbsn, decoder)
16745 case 6:
16746 return DecodeInstructionIdBsnPacketOfDeath(_instructionidbsn, decoder)
16747 case 7:
16748 return DecodeInstructionIdBsnPrioritizePdus(_instructionidbsn, decoder)
16749 case 8:
16750 return DecodeInstructionIdBsnRequireVlanXlate(_instructionidbsn, decoder)
16751 case 9:
16752 return DecodeInstructionIdBsnDisableVlanCounters(_instructionidbsn, decoder)
16753 case 10:
16754 return DecodeInstructionIdBsnSpanDestination(_instructionidbsn, decoder)
16755 case 11:
16756 return DecodeInstructionIdBsnAutoNegotiation(_instructionidbsn, decoder)
16757 case 12:
16758 return DecodeInstructionIdBsnInternalPriority(_instructionidbsn, decoder)
16759 case 13:
16760 return DecodeInstructionIdBsnDisableL3(_instructionidbsn, decoder)
16761 case 14:
16762 return DecodeInstructionIdBsnNdpOffload(_instructionidbsn, decoder)
16763 case 15:
16764 return DecodeInstructionIdBsnHashSelect(_instructionidbsn, decoder)
16765 case 16:
16766 return DecodeInstructionIdBsnDirectedBroadcast(_instructionidbsn, decoder)
16767 default:
16768 return nil, fmt.Errorf("Invalid type '%d' for 'InstructionIdBsn'", _instructionidbsn.Subtype)
16769 }
16770}
16771
16772func NewInstructionIdBsn(_subtype uint32) *InstructionIdBsn {
16773 obj := &InstructionIdBsn{
16774 InstructionIdExperimenter: NewInstructionIdExperimenter(6035143),
16775 }
16776 obj.Subtype = _subtype
16777 return obj
16778}
16779
16780type InstructionIdBsnArpOffload struct {
16781 *InstructionIdBsn
16782}
16783
16784type IInstructionIdBsnArpOffload interface {
16785 IInstructionIdBsn
16786}
16787
16788func (self *InstructionIdBsnArpOffload) Serialize(encoder *goloxi.Encoder) error {
16789 startIndex := len(encoder.Bytes())
16790 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
16791 return err
16792 }
16793 length := len(encoder.Bytes()) - startIndex
16794
16795 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
16796
16797 return nil
16798}
16799
16800func DecodeInstructionIdBsnArpOffload(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnArpOffload, error) {
16801 _instructionidbsnarpoffload := &InstructionIdBsnArpOffload{InstructionIdBsn: parent}
16802 return _instructionidbsnarpoffload, nil
16803}
16804
16805func NewInstructionIdBsnArpOffload() *InstructionIdBsnArpOffload {
16806 obj := &InstructionIdBsnArpOffload{
16807 InstructionIdBsn: NewInstructionIdBsn(1),
16808 }
16809 return obj
16810}
16811
16812type InstructionIdBsnAutoNegotiation struct {
16813 *InstructionIdBsn
16814}
16815
16816type IInstructionIdBsnAutoNegotiation interface {
16817 IInstructionIdBsn
16818}
16819
16820func (self *InstructionIdBsnAutoNegotiation) Serialize(encoder *goloxi.Encoder) error {
16821 startIndex := len(encoder.Bytes())
16822 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
16823 return err
16824 }
16825 length := len(encoder.Bytes()) - startIndex
16826
16827 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
16828
16829 return nil
16830}
16831
16832func DecodeInstructionIdBsnAutoNegotiation(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnAutoNegotiation, error) {
16833 _instructionidbsnautonegotiation := &InstructionIdBsnAutoNegotiation{InstructionIdBsn: parent}
16834 return _instructionidbsnautonegotiation, nil
16835}
16836
16837func NewInstructionIdBsnAutoNegotiation() *InstructionIdBsnAutoNegotiation {
16838 obj := &InstructionIdBsnAutoNegotiation{
16839 InstructionIdBsn: NewInstructionIdBsn(11),
16840 }
16841 return obj
16842}
16843
16844type InstructionIdBsnDeny struct {
16845 *InstructionIdBsn
16846}
16847
16848type IInstructionIdBsnDeny interface {
16849 IInstructionIdBsn
16850}
16851
16852func (self *InstructionIdBsnDeny) Serialize(encoder *goloxi.Encoder) error {
16853 startIndex := len(encoder.Bytes())
16854 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
16855 return err
16856 }
16857 length := len(encoder.Bytes()) - startIndex
16858
16859 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
16860
16861 return nil
16862}
16863
16864func DecodeInstructionIdBsnDeny(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnDeny, error) {
16865 _instructionidbsndeny := &InstructionIdBsnDeny{InstructionIdBsn: parent}
16866 return _instructionidbsndeny, nil
16867}
16868
16869func NewInstructionIdBsnDeny() *InstructionIdBsnDeny {
16870 obj := &InstructionIdBsnDeny{
16871 InstructionIdBsn: NewInstructionIdBsn(5),
16872 }
16873 return obj
16874}
16875
16876type InstructionIdBsnDhcpOffload struct {
16877 *InstructionIdBsn
16878}
16879
16880type IInstructionIdBsnDhcpOffload interface {
16881 IInstructionIdBsn
16882}
16883
16884func (self *InstructionIdBsnDhcpOffload) Serialize(encoder *goloxi.Encoder) error {
16885 startIndex := len(encoder.Bytes())
16886 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
16887 return err
16888 }
16889 length := len(encoder.Bytes()) - startIndex
16890
16891 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
16892
16893 return nil
16894}
16895
16896func DecodeInstructionIdBsnDhcpOffload(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnDhcpOffload, error) {
16897 _instructionidbsndhcpoffload := &InstructionIdBsnDhcpOffload{InstructionIdBsn: parent}
16898 return _instructionidbsndhcpoffload, nil
16899}
16900
16901func NewInstructionIdBsnDhcpOffload() *InstructionIdBsnDhcpOffload {
16902 obj := &InstructionIdBsnDhcpOffload{
16903 InstructionIdBsn: NewInstructionIdBsn(2),
16904 }
16905 return obj
16906}
16907
16908type InstructionIdBsnDirectedBroadcast struct {
16909 *InstructionIdBsn
16910}
16911
16912type IInstructionIdBsnDirectedBroadcast interface {
16913 IInstructionIdBsn
16914}
16915
16916func (self *InstructionIdBsnDirectedBroadcast) Serialize(encoder *goloxi.Encoder) error {
16917 startIndex := len(encoder.Bytes())
16918 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
16919 return err
16920 }
16921 length := len(encoder.Bytes()) - startIndex
16922
16923 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
16924
16925 return nil
16926}
16927
16928func DecodeInstructionIdBsnDirectedBroadcast(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnDirectedBroadcast, error) {
16929 _instructionidbsndirectedbroadcast := &InstructionIdBsnDirectedBroadcast{InstructionIdBsn: parent}
16930 return _instructionidbsndirectedbroadcast, nil
16931}
16932
16933func NewInstructionIdBsnDirectedBroadcast() *InstructionIdBsnDirectedBroadcast {
16934 obj := &InstructionIdBsnDirectedBroadcast{
16935 InstructionIdBsn: NewInstructionIdBsn(16),
16936 }
16937 return obj
16938}
16939
16940type InstructionIdBsnDisableL3 struct {
16941 *InstructionIdBsn
16942}
16943
16944type IInstructionIdBsnDisableL3 interface {
16945 IInstructionIdBsn
16946}
16947
16948func (self *InstructionIdBsnDisableL3) Serialize(encoder *goloxi.Encoder) error {
16949 startIndex := len(encoder.Bytes())
16950 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
16951 return err
16952 }
16953 length := len(encoder.Bytes()) - startIndex
16954
16955 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
16956
16957 return nil
16958}
16959
16960func DecodeInstructionIdBsnDisableL3(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnDisableL3, error) {
16961 _instructionidbsndisablel3 := &InstructionIdBsnDisableL3{InstructionIdBsn: parent}
16962 return _instructionidbsndisablel3, nil
16963}
16964
16965func NewInstructionIdBsnDisableL3() *InstructionIdBsnDisableL3 {
16966 obj := &InstructionIdBsnDisableL3{
16967 InstructionIdBsn: NewInstructionIdBsn(13),
16968 }
16969 return obj
16970}
16971
16972type InstructionIdBsnDisableSrcMacCheck struct {
16973 *InstructionIdBsn
16974}
16975
16976type IInstructionIdBsnDisableSrcMacCheck interface {
16977 IInstructionIdBsn
16978}
16979
16980func (self *InstructionIdBsnDisableSrcMacCheck) Serialize(encoder *goloxi.Encoder) error {
16981 startIndex := len(encoder.Bytes())
16982 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
16983 return err
16984 }
16985 length := len(encoder.Bytes()) - startIndex
16986
16987 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
16988
16989 return nil
16990}
16991
16992func DecodeInstructionIdBsnDisableSrcMacCheck(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnDisableSrcMacCheck, error) {
16993 _instructionidbsndisablesrcmaccheck := &InstructionIdBsnDisableSrcMacCheck{InstructionIdBsn: parent}
16994 return _instructionidbsndisablesrcmaccheck, nil
16995}
16996
16997func NewInstructionIdBsnDisableSrcMacCheck() *InstructionIdBsnDisableSrcMacCheck {
16998 obj := &InstructionIdBsnDisableSrcMacCheck{
16999 InstructionIdBsn: NewInstructionIdBsn(0),
17000 }
17001 return obj
17002}
17003
17004type InstructionIdBsnDisableVlanCounters struct {
17005 *InstructionIdBsn
17006}
17007
17008type IInstructionIdBsnDisableVlanCounters interface {
17009 IInstructionIdBsn
17010}
17011
17012func (self *InstructionIdBsnDisableVlanCounters) Serialize(encoder *goloxi.Encoder) error {
17013 startIndex := len(encoder.Bytes())
17014 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
17015 return err
17016 }
17017 length := len(encoder.Bytes()) - startIndex
17018
17019 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
17020
17021 return nil
17022}
17023
17024func DecodeInstructionIdBsnDisableVlanCounters(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnDisableVlanCounters, error) {
17025 _instructionidbsndisablevlancounters := &InstructionIdBsnDisableVlanCounters{InstructionIdBsn: parent}
17026 return _instructionidbsndisablevlancounters, nil
17027}
17028
17029func NewInstructionIdBsnDisableVlanCounters() *InstructionIdBsnDisableVlanCounters {
17030 obj := &InstructionIdBsnDisableVlanCounters{
17031 InstructionIdBsn: NewInstructionIdBsn(9),
17032 }
17033 return obj
17034}
17035
17036type InstructionIdBsnHashSelect struct {
17037 *InstructionIdBsn
17038}
17039
17040type IInstructionIdBsnHashSelect interface {
17041 IInstructionIdBsn
17042}
17043
17044func (self *InstructionIdBsnHashSelect) Serialize(encoder *goloxi.Encoder) error {
17045 startIndex := len(encoder.Bytes())
17046 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
17047 return err
17048 }
17049 length := len(encoder.Bytes()) - startIndex
17050
17051 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
17052
17053 return nil
17054}
17055
17056func DecodeInstructionIdBsnHashSelect(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnHashSelect, error) {
17057 _instructionidbsnhashselect := &InstructionIdBsnHashSelect{InstructionIdBsn: parent}
17058 return _instructionidbsnhashselect, nil
17059}
17060
17061func NewInstructionIdBsnHashSelect() *InstructionIdBsnHashSelect {
17062 obj := &InstructionIdBsnHashSelect{
17063 InstructionIdBsn: NewInstructionIdBsn(15),
17064 }
17065 return obj
17066}
17067
17068type InstructionIdBsnInternalPriority struct {
17069 *InstructionIdBsn
17070}
17071
17072type IInstructionIdBsnInternalPriority interface {
17073 IInstructionIdBsn
17074}
17075
17076func (self *InstructionIdBsnInternalPriority) Serialize(encoder *goloxi.Encoder) error {
17077 startIndex := len(encoder.Bytes())
17078 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
17079 return err
17080 }
17081 length := len(encoder.Bytes()) - startIndex
17082
17083 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
17084
17085 return nil
17086}
17087
17088func DecodeInstructionIdBsnInternalPriority(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnInternalPriority, error) {
17089 _instructionidbsninternalpriority := &InstructionIdBsnInternalPriority{InstructionIdBsn: parent}
17090 return _instructionidbsninternalpriority, nil
17091}
17092
17093func NewInstructionIdBsnInternalPriority() *InstructionIdBsnInternalPriority {
17094 obj := &InstructionIdBsnInternalPriority{
17095 InstructionIdBsn: NewInstructionIdBsn(12),
17096 }
17097 return obj
17098}
17099
17100type InstructionIdBsnNdpOffload struct {
17101 *InstructionIdBsn
17102}
17103
17104type IInstructionIdBsnNdpOffload interface {
17105 IInstructionIdBsn
17106}
17107
17108func (self *InstructionIdBsnNdpOffload) Serialize(encoder *goloxi.Encoder) error {
17109 startIndex := len(encoder.Bytes())
17110 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
17111 return err
17112 }
17113 length := len(encoder.Bytes()) - startIndex
17114
17115 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
17116
17117 return nil
17118}
17119
17120func DecodeInstructionIdBsnNdpOffload(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnNdpOffload, error) {
17121 _instructionidbsnndpoffload := &InstructionIdBsnNdpOffload{InstructionIdBsn: parent}
17122 return _instructionidbsnndpoffload, nil
17123}
17124
17125func NewInstructionIdBsnNdpOffload() *InstructionIdBsnNdpOffload {
17126 obj := &InstructionIdBsnNdpOffload{
17127 InstructionIdBsn: NewInstructionIdBsn(14),
17128 }
17129 return obj
17130}
17131
17132type InstructionIdBsnPacketOfDeath struct {
17133 *InstructionIdBsn
17134}
17135
17136type IInstructionIdBsnPacketOfDeath interface {
17137 IInstructionIdBsn
17138}
17139
17140func (self *InstructionIdBsnPacketOfDeath) Serialize(encoder *goloxi.Encoder) error {
17141 startIndex := len(encoder.Bytes())
17142 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
17143 return err
17144 }
17145 length := len(encoder.Bytes()) - startIndex
17146
17147 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
17148
17149 return nil
17150}
17151
17152func DecodeInstructionIdBsnPacketOfDeath(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnPacketOfDeath, error) {
17153 _instructionidbsnpacketofdeath := &InstructionIdBsnPacketOfDeath{InstructionIdBsn: parent}
17154 return _instructionidbsnpacketofdeath, nil
17155}
17156
17157func NewInstructionIdBsnPacketOfDeath() *InstructionIdBsnPacketOfDeath {
17158 obj := &InstructionIdBsnPacketOfDeath{
17159 InstructionIdBsn: NewInstructionIdBsn(6),
17160 }
17161 return obj
17162}
17163
17164type InstructionIdBsnPermit struct {
17165 *InstructionIdBsn
17166}
17167
17168type IInstructionIdBsnPermit interface {
17169 IInstructionIdBsn
17170}
17171
17172func (self *InstructionIdBsnPermit) Serialize(encoder *goloxi.Encoder) error {
17173 startIndex := len(encoder.Bytes())
17174 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
17175 return err
17176 }
17177 length := len(encoder.Bytes()) - startIndex
17178
17179 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
17180
17181 return nil
17182}
17183
17184func DecodeInstructionIdBsnPermit(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnPermit, error) {
17185 _instructionidbsnpermit := &InstructionIdBsnPermit{InstructionIdBsn: parent}
17186 return _instructionidbsnpermit, nil
17187}
17188
17189func NewInstructionIdBsnPermit() *InstructionIdBsnPermit {
17190 obj := &InstructionIdBsnPermit{
17191 InstructionIdBsn: NewInstructionIdBsn(4),
17192 }
17193 return obj
17194}
17195
17196type InstructionIdBsnPrioritizePdus struct {
17197 *InstructionIdBsn
17198}
17199
17200type IInstructionIdBsnPrioritizePdus interface {
17201 IInstructionIdBsn
17202}
17203
17204func (self *InstructionIdBsnPrioritizePdus) Serialize(encoder *goloxi.Encoder) error {
17205 startIndex := len(encoder.Bytes())
17206 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
17207 return err
17208 }
17209 length := len(encoder.Bytes()) - startIndex
17210
17211 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
17212
17213 return nil
17214}
17215
17216func DecodeInstructionIdBsnPrioritizePdus(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnPrioritizePdus, error) {
17217 _instructionidbsnprioritizepdus := &InstructionIdBsnPrioritizePdus{InstructionIdBsn: parent}
17218 return _instructionidbsnprioritizepdus, nil
17219}
17220
17221func NewInstructionIdBsnPrioritizePdus() *InstructionIdBsnPrioritizePdus {
17222 obj := &InstructionIdBsnPrioritizePdus{
17223 InstructionIdBsn: NewInstructionIdBsn(7),
17224 }
17225 return obj
17226}
17227
17228type InstructionIdBsnRequireVlanXlate struct {
17229 *InstructionIdBsn
17230}
17231
17232type IInstructionIdBsnRequireVlanXlate interface {
17233 IInstructionIdBsn
17234}
17235
17236func (self *InstructionIdBsnRequireVlanXlate) Serialize(encoder *goloxi.Encoder) error {
17237 startIndex := len(encoder.Bytes())
17238 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
17239 return err
17240 }
17241 length := len(encoder.Bytes()) - startIndex
17242
17243 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
17244
17245 return nil
17246}
17247
17248func DecodeInstructionIdBsnRequireVlanXlate(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnRequireVlanXlate, error) {
17249 _instructionidbsnrequirevlanxlate := &InstructionIdBsnRequireVlanXlate{InstructionIdBsn: parent}
17250 return _instructionidbsnrequirevlanxlate, nil
17251}
17252
17253func NewInstructionIdBsnRequireVlanXlate() *InstructionIdBsnRequireVlanXlate {
17254 obj := &InstructionIdBsnRequireVlanXlate{
17255 InstructionIdBsn: NewInstructionIdBsn(8),
17256 }
17257 return obj
17258}
17259
17260type InstructionIdBsnSpanDestination struct {
17261 *InstructionIdBsn
17262}
17263
17264type IInstructionIdBsnSpanDestination interface {
17265 IInstructionIdBsn
17266}
17267
17268func (self *InstructionIdBsnSpanDestination) Serialize(encoder *goloxi.Encoder) error {
17269 startIndex := len(encoder.Bytes())
17270 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
17271 return err
17272 }
17273 length := len(encoder.Bytes()) - startIndex
17274
17275 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
17276
17277 return nil
17278}
17279
17280func DecodeInstructionIdBsnSpanDestination(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnSpanDestination, error) {
17281 _instructionidbsnspandestination := &InstructionIdBsnSpanDestination{InstructionIdBsn: parent}
17282 return _instructionidbsnspandestination, nil
17283}
17284
17285func NewInstructionIdBsnSpanDestination() *InstructionIdBsnSpanDestination {
17286 obj := &InstructionIdBsnSpanDestination{
17287 InstructionIdBsn: NewInstructionIdBsn(10),
17288 }
17289 return obj
17290}
17291
17292type InstructionIdClearActions struct {
17293 *InstructionId
17294}
17295
17296type IInstructionIdClearActions interface {
17297 IInstructionId
17298}
17299
17300func (self *InstructionIdClearActions) Serialize(encoder *goloxi.Encoder) error {
17301 startIndex := len(encoder.Bytes())
17302 if err := self.InstructionId.Serialize(encoder); err != nil {
17303 return err
17304 }
17305 length := len(encoder.Bytes()) - startIndex
17306
17307 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
17308
17309 return nil
17310}
17311
17312func DecodeInstructionIdClearActions(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdClearActions, error) {
17313 _instructionidclearactions := &InstructionIdClearActions{InstructionId: parent}
17314 return _instructionidclearactions, nil
17315}
17316
17317func NewInstructionIdClearActions() *InstructionIdClearActions {
17318 obj := &InstructionIdClearActions{
17319 InstructionId: NewInstructionId(5),
17320 }
17321 return obj
17322}
17323
17324type InstructionIdGotoTable struct {
17325 *InstructionId
17326}
17327
17328type IInstructionIdGotoTable interface {
17329 IInstructionId
17330}
17331
17332func (self *InstructionIdGotoTable) Serialize(encoder *goloxi.Encoder) error {
17333 startIndex := len(encoder.Bytes())
17334 if err := self.InstructionId.Serialize(encoder); err != nil {
17335 return err
17336 }
17337 length := len(encoder.Bytes()) - startIndex
17338
17339 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
17340
17341 return nil
17342}
17343
17344func DecodeInstructionIdGotoTable(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdGotoTable, error) {
17345 _instructionidgototable := &InstructionIdGotoTable{InstructionId: parent}
17346 return _instructionidgototable, nil
17347}
17348
17349func NewInstructionIdGotoTable() *InstructionIdGotoTable {
17350 obj := &InstructionIdGotoTable{
17351 InstructionId: NewInstructionId(1),
17352 }
17353 return obj
17354}
17355
17356type InstructionIdStatTrigger struct {
17357 *InstructionId
17358}
17359
17360type IInstructionIdStatTrigger interface {
17361 IInstructionId
17362}
17363
17364func (self *InstructionIdStatTrigger) Serialize(encoder *goloxi.Encoder) error {
17365 startIndex := len(encoder.Bytes())
17366 if err := self.InstructionId.Serialize(encoder); err != nil {
17367 return err
17368 }
17369 length := len(encoder.Bytes()) - startIndex
17370
17371 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
17372
17373 return nil
17374}
17375
17376func DecodeInstructionIdStatTrigger(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdStatTrigger, error) {
17377 _instructionidstattrigger := &InstructionIdStatTrigger{InstructionId: parent}
17378 return _instructionidstattrigger, nil
17379}
17380
17381func NewInstructionIdStatTrigger() *InstructionIdStatTrigger {
17382 obj := &InstructionIdStatTrigger{
17383 InstructionId: NewInstructionId(7),
17384 }
17385 return obj
17386}
17387
17388type InstructionIdWriteActions struct {
17389 *InstructionId
17390}
17391
17392type IInstructionIdWriteActions interface {
17393 IInstructionId
17394}
17395
17396func (self *InstructionIdWriteActions) Serialize(encoder *goloxi.Encoder) error {
17397 startIndex := len(encoder.Bytes())
17398 if err := self.InstructionId.Serialize(encoder); err != nil {
17399 return err
17400 }
17401 length := len(encoder.Bytes()) - startIndex
17402
17403 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
17404
17405 return nil
17406}
17407
17408func DecodeInstructionIdWriteActions(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdWriteActions, error) {
17409 _instructionidwriteactions := &InstructionIdWriteActions{InstructionId: parent}
17410 return _instructionidwriteactions, nil
17411}
17412
17413func NewInstructionIdWriteActions() *InstructionIdWriteActions {
17414 obj := &InstructionIdWriteActions{
17415 InstructionId: NewInstructionId(3),
17416 }
17417 return obj
17418}
17419
17420type InstructionIdWriteMetadata struct {
17421 *InstructionId
17422}
17423
17424type IInstructionIdWriteMetadata interface {
17425 IInstructionId
17426}
17427
17428func (self *InstructionIdWriteMetadata) Serialize(encoder *goloxi.Encoder) error {
17429 startIndex := len(encoder.Bytes())
17430 if err := self.InstructionId.Serialize(encoder); err != nil {
17431 return err
17432 }
17433 length := len(encoder.Bytes()) - startIndex
17434
17435 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
17436
17437 return nil
17438}
17439
17440func DecodeInstructionIdWriteMetadata(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdWriteMetadata, error) {
17441 _instructionidwritemetadata := &InstructionIdWriteMetadata{InstructionId: parent}
17442 return _instructionidwritemetadata, nil
17443}
17444
17445func NewInstructionIdWriteMetadata() *InstructionIdWriteMetadata {
17446 obj := &InstructionIdWriteMetadata{
17447 InstructionId: NewInstructionId(2),
17448 }
17449 return obj
17450}
17451
17452type MatchV3 struct {
17453 Type uint16
17454 Length uint16
17455 OxmList []goloxi.IOxm
17456}
17457
17458type IMatchV3 interface {
17459 goloxi.Serializable
17460 GetType() uint16
17461 GetLength() uint16
17462 GetOxmList() []goloxi.IOxm
17463}
17464
17465func (self *MatchV3) GetType() uint16 {
17466 return self.Type
17467}
17468
17469func (self *MatchV3) SetType(v uint16) {
17470 self.Type = v
17471}
17472
17473func (self *MatchV3) GetLength() uint16 {
17474 return self.Length
17475}
17476
17477func (self *MatchV3) SetLength(v uint16) {
17478 self.Length = v
17479}
17480
17481func (self *MatchV3) GetOxmList() []goloxi.IOxm {
17482 return self.OxmList
17483}
17484
17485func (self *MatchV3) SetOxmList(v []goloxi.IOxm) {
17486 self.OxmList = v
17487}
17488
17489func (self *MatchV3) Serialize(encoder *goloxi.Encoder) error {
17490 startIndex := len(encoder.Bytes())
17491
17492 encoder.PutUint16(uint16(self.Type))
17493 encoder.PutUint16(uint16(self.Length))
17494 for _, obj := range self.OxmList {
17495 if err := obj.Serialize(encoder); err != nil {
17496 return err
17497 }
17498 }
17499 length := len(encoder.Bytes()) - startIndex
17500 alignedLength := ((length + 7) / 8 * 8)
17501
17502 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
17503
17504 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
17505
17506 return nil
17507}
17508func (self *MatchV3) Decode(decoder *goloxi.Decoder) error {
17509 if decoder.Length() < 4 {
17510 return fmt.Errorf("MatchV3 packet too short: %d < 4", decoder.Length())
17511 }
17512
17513 defer decoder.SkipAlign()
17514
17515 self.Type = uint16(decoder.ReadUint16())
17516 self.Length = uint16(decoder.ReadUint16())
17517 oldDecoder := decoder
17518 defer func() { decoder = oldDecoder }()
17519 decoder = decoder.SliceDecoder(int(((self.Length)+7)/8*8), 2+2)
17520
17521 for decoder.Length() >= 4 {
17522 item, err := DecodeOxm(decoder)
17523 if err != nil {
17524 return err
17525 }
17526 if item != nil {
17527 self.OxmList = append(self.OxmList, item)
17528 }
17529 }
17530
17531 return nil
17532}
17533
17534func NewMatchV3() *MatchV3 {
17535 obj := &MatchV3{}
17536 return obj
17537}
17538
17539type MeterBand struct {
17540 Type uint16
17541 Len uint16
17542}
17543
17544type IMeterBand interface {
17545 goloxi.Serializable
17546 GetType() uint16
17547 GetLen() uint16
17548}
17549
17550func (self *MeterBand) GetType() uint16 {
17551 return self.Type
17552}
17553
17554func (self *MeterBand) SetType(v uint16) {
17555 self.Type = v
17556}
17557
17558func (self *MeterBand) GetLen() uint16 {
17559 return self.Len
17560}
17561
17562func (self *MeterBand) SetLen(v uint16) {
17563 self.Len = v
17564}
17565
17566func (self *MeterBand) Serialize(encoder *goloxi.Encoder) error {
17567
17568 encoder.PutUint16(uint16(self.Type))
17569 encoder.PutUint16(uint16(self.Len))
17570
17571 return nil
17572}
17573
17574func DecodeMeterBand(decoder *goloxi.Decoder) (IMeterBand, error) {
17575 _meterband := &MeterBand{}
17576 if decoder.Length() < 4 {
17577 return nil, fmt.Errorf("MeterBand packet too short: %d < 4", decoder.Length())
17578 }
17579 _meterband.Type = uint16(decoder.ReadUint16())
17580 _meterband.Len = uint16(decoder.ReadUint16())
17581 oldDecoder := decoder
17582 defer func() { decoder = oldDecoder }()
17583 decoder = decoder.SliceDecoder(int(_meterband.Len), 2+2)
17584
17585 switch _meterband.Type {
17586 case 1:
17587 return DecodeMeterBandDrop(_meterband, decoder)
17588 case 2:
17589 return DecodeMeterBandDscpRemark(_meterband, decoder)
17590 case 65535:
17591 return DecodeMeterBandExperimenter(_meterband, decoder)
17592 default:
17593 return nil, fmt.Errorf("Invalid type '%d' for 'MeterBand'", _meterband.Type)
17594 }
17595}
17596
17597func NewMeterBand(_type uint16) *MeterBand {
17598 obj := &MeterBand{}
17599 obj.Type = _type
17600 return obj
17601}
17602
17603type MeterBandDrop struct {
17604 *MeterBand
17605 Rate uint32
17606 BurstSize uint32
17607}
17608
17609type IMeterBandDrop interface {
17610 IMeterBand
17611 GetRate() uint32
17612 GetBurstSize() uint32
17613}
17614
17615func (self *MeterBandDrop) GetRate() uint32 {
17616 return self.Rate
17617}
17618
17619func (self *MeterBandDrop) SetRate(v uint32) {
17620 self.Rate = v
17621}
17622
17623func (self *MeterBandDrop) GetBurstSize() uint32 {
17624 return self.BurstSize
17625}
17626
17627func (self *MeterBandDrop) SetBurstSize(v uint32) {
17628 self.BurstSize = v
17629}
17630
17631func (self *MeterBandDrop) Serialize(encoder *goloxi.Encoder) error {
17632 startIndex := len(encoder.Bytes())
17633 if err := self.MeterBand.Serialize(encoder); err != nil {
17634 return err
17635 }
17636
17637 encoder.PutUint32(uint32(self.Rate))
17638 encoder.PutUint32(uint32(self.BurstSize))
17639 encoder.Write(bytes.Repeat([]byte{0}, 4))
17640 length := len(encoder.Bytes()) - startIndex
17641
17642 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
17643
17644 return nil
17645}
17646
17647func DecodeMeterBandDrop(parent *MeterBand, decoder *goloxi.Decoder) (*MeterBandDrop, error) {
17648 _meterbanddrop := &MeterBandDrop{MeterBand: parent}
17649 if decoder.Length() < 12 {
17650 return nil, fmt.Errorf("MeterBandDrop packet too short: %d < 12", decoder.Length())
17651 }
17652 _meterbanddrop.Rate = uint32(decoder.ReadUint32())
17653 _meterbanddrop.BurstSize = uint32(decoder.ReadUint32())
17654 decoder.Skip(4)
17655 return _meterbanddrop, nil
17656}
17657
17658func NewMeterBandDrop() *MeterBandDrop {
17659 obj := &MeterBandDrop{
17660 MeterBand: NewMeterBand(1),
17661 }
17662 return obj
17663}
17664
17665type MeterBandDscpRemark struct {
17666 *MeterBand
17667 Rate uint32
17668 BurstSize uint32
17669 PrecLevel uint8
17670}
17671
17672type IMeterBandDscpRemark interface {
17673 IMeterBand
17674 GetRate() uint32
17675 GetBurstSize() uint32
17676 GetPrecLevel() uint8
17677}
17678
17679func (self *MeterBandDscpRemark) GetRate() uint32 {
17680 return self.Rate
17681}
17682
17683func (self *MeterBandDscpRemark) SetRate(v uint32) {
17684 self.Rate = v
17685}
17686
17687func (self *MeterBandDscpRemark) GetBurstSize() uint32 {
17688 return self.BurstSize
17689}
17690
17691func (self *MeterBandDscpRemark) SetBurstSize(v uint32) {
17692 self.BurstSize = v
17693}
17694
17695func (self *MeterBandDscpRemark) GetPrecLevel() uint8 {
17696 return self.PrecLevel
17697}
17698
17699func (self *MeterBandDscpRemark) SetPrecLevel(v uint8) {
17700 self.PrecLevel = v
17701}
17702
17703func (self *MeterBandDscpRemark) Serialize(encoder *goloxi.Encoder) error {
17704 startIndex := len(encoder.Bytes())
17705 if err := self.MeterBand.Serialize(encoder); err != nil {
17706 return err
17707 }
17708
17709 encoder.PutUint32(uint32(self.Rate))
17710 encoder.PutUint32(uint32(self.BurstSize))
17711 encoder.PutUint8(uint8(self.PrecLevel))
17712 encoder.Write(bytes.Repeat([]byte{0}, 3))
17713 length := len(encoder.Bytes()) - startIndex
17714
17715 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
17716
17717 return nil
17718}
17719
17720func DecodeMeterBandDscpRemark(parent *MeterBand, decoder *goloxi.Decoder) (*MeterBandDscpRemark, error) {
17721 _meterbanddscpremark := &MeterBandDscpRemark{MeterBand: parent}
17722 if decoder.Length() < 12 {
17723 return nil, fmt.Errorf("MeterBandDscpRemark packet too short: %d < 12", decoder.Length())
17724 }
17725 _meterbanddscpremark.Rate = uint32(decoder.ReadUint32())
17726 _meterbanddscpremark.BurstSize = uint32(decoder.ReadUint32())
17727 _meterbanddscpremark.PrecLevel = uint8(decoder.ReadByte())
17728 decoder.Skip(3)
17729 return _meterbanddscpremark, nil
17730}
17731
17732func NewMeterBandDscpRemark() *MeterBandDscpRemark {
17733 obj := &MeterBandDscpRemark{
17734 MeterBand: NewMeterBand(2),
17735 }
17736 return obj
17737}
17738
17739type MeterBandExperimenter struct {
17740 *MeterBand
17741 Rate uint32
17742 BurstSize uint32
17743 Experimenter uint32
17744}
17745
17746type IMeterBandExperimenter interface {
17747 IMeterBand
17748 GetRate() uint32
17749 GetBurstSize() uint32
17750 GetExperimenter() uint32
17751}
17752
17753func (self *MeterBandExperimenter) GetRate() uint32 {
17754 return self.Rate
17755}
17756
17757func (self *MeterBandExperimenter) SetRate(v uint32) {
17758 self.Rate = v
17759}
17760
17761func (self *MeterBandExperimenter) GetBurstSize() uint32 {
17762 return self.BurstSize
17763}
17764
17765func (self *MeterBandExperimenter) SetBurstSize(v uint32) {
17766 self.BurstSize = v
17767}
17768
17769func (self *MeterBandExperimenter) GetExperimenter() uint32 {
17770 return self.Experimenter
17771}
17772
17773func (self *MeterBandExperimenter) SetExperimenter(v uint32) {
17774 self.Experimenter = v
17775}
17776
17777func (self *MeterBandExperimenter) Serialize(encoder *goloxi.Encoder) error {
17778 startIndex := len(encoder.Bytes())
17779 if err := self.MeterBand.Serialize(encoder); err != nil {
17780 return err
17781 }
17782
17783 encoder.PutUint32(uint32(self.Rate))
17784 encoder.PutUint32(uint32(self.BurstSize))
17785 encoder.PutUint32(uint32(self.Experimenter))
17786 length := len(encoder.Bytes()) - startIndex
17787
17788 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
17789
17790 return nil
17791}
17792
17793func DecodeMeterBandExperimenter(parent *MeterBand, decoder *goloxi.Decoder) (*MeterBandExperimenter, error) {
17794 _meterbandexperimenter := &MeterBandExperimenter{MeterBand: parent}
17795 if decoder.Length() < 12 {
17796 return nil, fmt.Errorf("MeterBandExperimenter packet too short: %d < 12", decoder.Length())
17797 }
17798 _meterbandexperimenter.Rate = uint32(decoder.ReadUint32())
17799 _meterbandexperimenter.BurstSize = uint32(decoder.ReadUint32())
17800 _meterbandexperimenter.Experimenter = uint32(decoder.ReadUint32())
17801 return _meterbandexperimenter, nil
17802}
17803
17804func NewMeterBandExperimenter() *MeterBandExperimenter {
17805 obj := &MeterBandExperimenter{
17806 MeterBand: NewMeterBand(65535),
17807 }
17808 return obj
17809}
17810
17811type MeterBandStats struct {
17812 PacketBandCount uint64
17813 ByteBandCount uint64
17814}
17815
17816type IMeterBandStats interface {
17817 goloxi.Serializable
17818 GetPacketBandCount() uint64
17819 GetByteBandCount() uint64
17820}
17821
17822func (self *MeterBandStats) GetPacketBandCount() uint64 {
17823 return self.PacketBandCount
17824}
17825
17826func (self *MeterBandStats) SetPacketBandCount(v uint64) {
17827 self.PacketBandCount = v
17828}
17829
17830func (self *MeterBandStats) GetByteBandCount() uint64 {
17831 return self.ByteBandCount
17832}
17833
17834func (self *MeterBandStats) SetByteBandCount(v uint64) {
17835 self.ByteBandCount = v
17836}
17837
17838func (self *MeterBandStats) Serialize(encoder *goloxi.Encoder) error {
17839
17840 encoder.PutUint64(uint64(self.PacketBandCount))
17841 encoder.PutUint64(uint64(self.ByteBandCount))
17842
17843 return nil
17844}
17845
17846func DecodeMeterBandStats(decoder *goloxi.Decoder) (*MeterBandStats, error) {
17847 _meterbandstats := &MeterBandStats{}
17848 if decoder.Length() < 16 {
17849 return nil, fmt.Errorf("MeterBandStats packet too short: %d < 16", decoder.Length())
17850 }
17851 _meterbandstats.PacketBandCount = uint64(decoder.ReadUint64())
17852 _meterbandstats.ByteBandCount = uint64(decoder.ReadUint64())
17853 return _meterbandstats, nil
17854}
17855
17856func NewMeterBandStats() *MeterBandStats {
17857 obj := &MeterBandStats{}
17858 return obj
17859}
17860
17861type MeterConfig struct {
17862 Length uint16
17863 Flags MeterFlags
17864 MeterId uint32
17865 Entries []IMeterBand
17866}
17867
17868type IMeterConfig interface {
17869 goloxi.Serializable
17870 GetLength() uint16
17871 GetFlags() MeterFlags
17872 GetMeterId() uint32
17873 GetEntries() []IMeterBand
17874}
17875
17876func (self *MeterConfig) GetLength() uint16 {
17877 return self.Length
17878}
17879
17880func (self *MeterConfig) SetLength(v uint16) {
17881 self.Length = v
17882}
17883
17884func (self *MeterConfig) GetFlags() MeterFlags {
17885 return self.Flags
17886}
17887
17888func (self *MeterConfig) SetFlags(v MeterFlags) {
17889 self.Flags = v
17890}
17891
17892func (self *MeterConfig) GetMeterId() uint32 {
17893 return self.MeterId
17894}
17895
17896func (self *MeterConfig) SetMeterId(v uint32) {
17897 self.MeterId = v
17898}
17899
17900func (self *MeterConfig) GetEntries() []IMeterBand {
17901 return self.Entries
17902}
17903
17904func (self *MeterConfig) SetEntries(v []IMeterBand) {
17905 self.Entries = v
17906}
17907
17908func (self *MeterConfig) Serialize(encoder *goloxi.Encoder) error {
17909 startIndex := len(encoder.Bytes())
17910
17911 encoder.PutUint16(uint16(self.Length))
17912 encoder.PutUint16(uint16(self.Flags))
17913 encoder.PutUint32(uint32(self.MeterId))
17914 for _, obj := range self.Entries {
17915 if err := obj.Serialize(encoder); err != nil {
17916 return err
17917 }
17918 }
17919 length := len(encoder.Bytes()) - startIndex
17920
17921 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
17922
17923 return nil
17924}
17925
17926func DecodeMeterConfig(decoder *goloxi.Decoder) (*MeterConfig, error) {
17927 _meterconfig := &MeterConfig{}
17928 if decoder.Length() < 8 {
17929 return nil, fmt.Errorf("MeterConfig packet too short: %d < 8", decoder.Length())
17930 }
17931 _meterconfig.Length = uint16(decoder.ReadUint16())
17932 oldDecoder := decoder
17933 defer func() { decoder = oldDecoder }()
17934 decoder = decoder.SliceDecoder(int(_meterconfig.Length), 2+0)
17935 _meterconfig.Flags = MeterFlags(decoder.ReadUint16())
17936 _meterconfig.MeterId = uint32(decoder.ReadUint32())
17937
17938 for decoder.Length() >= 4 {
17939 item, err := DecodeMeterBand(decoder)
17940 if err != nil {
17941 return nil, err
17942 }
17943 if item != nil {
17944 _meterconfig.Entries = append(_meterconfig.Entries, item)
17945 }
17946 }
17947 return _meterconfig, nil
17948}
17949
17950func NewMeterConfig() *MeterConfig {
17951 obj := &MeterConfig{}
17952 return obj
17953}
17954
17955type MeterFeatures struct {
17956 MaxMeter uint32
17957 BandTypes uint32
17958 Capabilities uint32
17959 MaxBands uint8
17960 MaxColor uint8
17961 Features uint32
17962}
17963
17964type IMeterFeatures interface {
17965 goloxi.Serializable
17966 GetMaxMeter() uint32
17967 GetBandTypes() uint32
17968 GetCapabilities() uint32
17969 GetMaxBands() uint8
17970 GetMaxColor() uint8
17971 GetFeatures() uint32
17972}
17973
17974func (self *MeterFeatures) GetMaxMeter() uint32 {
17975 return self.MaxMeter
17976}
17977
17978func (self *MeterFeatures) SetMaxMeter(v uint32) {
17979 self.MaxMeter = v
17980}
17981
17982func (self *MeterFeatures) GetBandTypes() uint32 {
17983 return self.BandTypes
17984}
17985
17986func (self *MeterFeatures) SetBandTypes(v uint32) {
17987 self.BandTypes = v
17988}
17989
17990func (self *MeterFeatures) GetCapabilities() uint32 {
17991 return self.Capabilities
17992}
17993
17994func (self *MeterFeatures) SetCapabilities(v uint32) {
17995 self.Capabilities = v
17996}
17997
17998func (self *MeterFeatures) GetMaxBands() uint8 {
17999 return self.MaxBands
18000}
18001
18002func (self *MeterFeatures) SetMaxBands(v uint8) {
18003 self.MaxBands = v
18004}
18005
18006func (self *MeterFeatures) GetMaxColor() uint8 {
18007 return self.MaxColor
18008}
18009
18010func (self *MeterFeatures) SetMaxColor(v uint8) {
18011 self.MaxColor = v
18012}
18013
18014func (self *MeterFeatures) GetFeatures() uint32 {
18015 return self.Features
18016}
18017
18018func (self *MeterFeatures) SetFeatures(v uint32) {
18019 self.Features = v
18020}
18021
18022func (self *MeterFeatures) Serialize(encoder *goloxi.Encoder) error {
18023
18024 encoder.PutUint32(uint32(self.MaxMeter))
18025 encoder.PutUint32(uint32(self.BandTypes))
18026 encoder.PutUint32(uint32(self.Capabilities))
18027 encoder.PutUint8(uint8(self.MaxBands))
18028 encoder.PutUint8(uint8(self.MaxColor))
18029 encoder.Write(bytes.Repeat([]byte{0}, 2))
18030 encoder.PutUint32(uint32(self.Features))
18031 encoder.Write(bytes.Repeat([]byte{0}, 4))
18032
18033 return nil
18034}
18035func (self *MeterFeatures) Decode(decoder *goloxi.Decoder) error {
18036 if decoder.Length() < 24 {
18037 return fmt.Errorf("MeterFeatures packet too short: %d < 24", decoder.Length())
18038 }
18039
18040 self.MaxMeter = uint32(decoder.ReadUint32())
18041 self.BandTypes = uint32(decoder.ReadUint32())
18042 self.Capabilities = uint32(decoder.ReadUint32())
18043 self.MaxBands = uint8(decoder.ReadByte())
18044 self.MaxColor = uint8(decoder.ReadByte())
18045 decoder.Skip(2)
18046 self.Features = uint32(decoder.ReadUint32())
18047 decoder.Skip(4)
18048
18049 return nil
18050}
18051
18052func NewMeterFeatures() *MeterFeatures {
18053 obj := &MeterFeatures{}
18054 return obj
18055}
18056
18057type MeterStats struct {
18058 MeterId uint32
18059 Len uint16
18060 RefCount uint32
18061 PacketInCount uint64
18062 ByteInCount uint64
18063 DurationSec uint32
18064 DurationNsec uint32
18065 BandStats []*MeterBandStats
18066}
18067
18068type IMeterStats interface {
18069 goloxi.Serializable
18070 GetMeterId() uint32
18071 GetLen() uint16
18072 GetRefCount() uint32
18073 GetPacketInCount() uint64
18074 GetByteInCount() uint64
18075 GetDurationSec() uint32
18076 GetDurationNsec() uint32
18077 GetBandStats() []*MeterBandStats
18078}
18079
18080func (self *MeterStats) GetMeterId() uint32 {
18081 return self.MeterId
18082}
18083
18084func (self *MeterStats) SetMeterId(v uint32) {
18085 self.MeterId = v
18086}
18087
18088func (self *MeterStats) GetLen() uint16 {
18089 return self.Len
18090}
18091
18092func (self *MeterStats) SetLen(v uint16) {
18093 self.Len = v
18094}
18095
18096func (self *MeterStats) GetRefCount() uint32 {
18097 return self.RefCount
18098}
18099
18100func (self *MeterStats) SetRefCount(v uint32) {
18101 self.RefCount = v
18102}
18103
18104func (self *MeterStats) GetPacketInCount() uint64 {
18105 return self.PacketInCount
18106}
18107
18108func (self *MeterStats) SetPacketInCount(v uint64) {
18109 self.PacketInCount = v
18110}
18111
18112func (self *MeterStats) GetByteInCount() uint64 {
18113 return self.ByteInCount
18114}
18115
18116func (self *MeterStats) SetByteInCount(v uint64) {
18117 self.ByteInCount = v
18118}
18119
18120func (self *MeterStats) GetDurationSec() uint32 {
18121 return self.DurationSec
18122}
18123
18124func (self *MeterStats) SetDurationSec(v uint32) {
18125 self.DurationSec = v
18126}
18127
18128func (self *MeterStats) GetDurationNsec() uint32 {
18129 return self.DurationNsec
18130}
18131
18132func (self *MeterStats) SetDurationNsec(v uint32) {
18133 self.DurationNsec = v
18134}
18135
18136func (self *MeterStats) GetBandStats() []*MeterBandStats {
18137 return self.BandStats
18138}
18139
18140func (self *MeterStats) SetBandStats(v []*MeterBandStats) {
18141 self.BandStats = v
18142}
18143
18144func (self *MeterStats) Serialize(encoder *goloxi.Encoder) error {
18145 startIndex := len(encoder.Bytes())
18146
18147 encoder.PutUint32(uint32(self.MeterId))
18148 encoder.PutUint16(uint16(self.Len))
18149 encoder.Write(bytes.Repeat([]byte{0}, 6))
18150 encoder.PutUint32(uint32(self.RefCount))
18151 encoder.PutUint64(uint64(self.PacketInCount))
18152 encoder.PutUint64(uint64(self.ByteInCount))
18153 encoder.PutUint32(uint32(self.DurationSec))
18154 encoder.PutUint32(uint32(self.DurationNsec))
18155 for _, obj := range self.BandStats {
18156 if err := obj.Serialize(encoder); err != nil {
18157 return err
18158 }
18159 }
18160 length := len(encoder.Bytes()) - startIndex
18161
18162 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+4:startIndex+6], uint16(length))
18163
18164 return nil
18165}
18166
18167func DecodeMeterStats(decoder *goloxi.Decoder) (*MeterStats, error) {
18168 _meterstats := &MeterStats{}
18169 if decoder.Length() < 40 {
18170 return nil, fmt.Errorf("MeterStats packet too short: %d < 40", decoder.Length())
18171 }
18172 _meterstats.MeterId = uint32(decoder.ReadUint32())
18173 _meterstats.Len = uint16(decoder.ReadUint16())
18174 oldDecoder := decoder
18175 defer func() { decoder = oldDecoder }()
18176 decoder = decoder.SliceDecoder(int(_meterstats.Len), 2+4)
18177 decoder.Skip(6)
18178 _meterstats.RefCount = uint32(decoder.ReadUint32())
18179 _meterstats.PacketInCount = uint64(decoder.ReadUint64())
18180 _meterstats.ByteInCount = uint64(decoder.ReadUint64())
18181 _meterstats.DurationSec = uint32(decoder.ReadUint32())
18182 _meterstats.DurationNsec = uint32(decoder.ReadUint32())
18183
18184 for decoder.Length() >= 16 {
18185 item, err := DecodeMeterBandStats(decoder)
18186 if err != nil {
18187 return nil, err
18188 }
18189 if item != nil {
18190 _meterstats.BandStats = append(_meterstats.BandStats, item)
18191 }
18192 }
18193 return _meterstats, nil
18194}
18195
18196func NewMeterStats() *MeterStats {
18197 obj := &MeterStats{}
18198 return obj
18199}
18200
18201type NiciraMatch struct {
18202 NxmEntries []goloxi.IOxm
18203}
18204
18205type INiciraMatch interface {
18206 goloxi.Serializable
18207 GetNxmEntries() []goloxi.IOxm
18208}
18209
18210func (self *NiciraMatch) GetNxmEntries() []goloxi.IOxm {
18211 return self.NxmEntries
18212}
18213
18214func (self *NiciraMatch) SetNxmEntries(v []goloxi.IOxm) {
18215 self.NxmEntries = v
18216}
18217
18218func (self *NiciraMatch) Serialize(encoder *goloxi.Encoder) error {
18219 startIndex := len(encoder.Bytes())
18220
18221 for _, obj := range self.NxmEntries {
18222 if err := obj.Serialize(encoder); err != nil {
18223 return err
18224 }
18225 }
18226 length := len(encoder.Bytes()) - startIndex
18227 alignedLength := ((length + 7) / 8 * 8)
18228
18229 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
18230
18231 return nil
18232}
18233func (self *NiciraMatch) Decode(decoder *goloxi.Decoder) error {
18234
18235 defer decoder.SkipAlign()
18236
18237 for decoder.Length() >= 4 {
18238 item, err := DecodeOxm(decoder)
18239 if err != nil {
18240 return err
18241 }
18242 if item != nil {
18243 self.NxmEntries = append(self.NxmEntries, item)
18244 }
18245 }
18246
18247 return nil
18248}
18249
18250func NewNiciraMatch() *NiciraMatch {
18251 obj := &NiciraMatch{}
18252 return obj
18253}
18254
18255type NiciraFlowStats struct {
18256 Length uint16
18257 TableId uint8
18258 DurationSec uint32
18259 DurationNsec uint32
18260 Priority uint16
18261 IdleTimeout uint16
18262 HardTimeout uint16
18263 MatchLen uint16
18264 IdleAge uint16
18265 HardAge uint16
18266 Cookie uint64
18267 PacketCount uint64
18268 ByteCount uint64
18269 Match NiciraMatch
18270 Actions []goloxi.IAction
18271}
18272
18273type INiciraFlowStats interface {
18274 goloxi.Serializable
18275 GetLength() uint16
18276 GetTableId() uint8
18277 GetDurationSec() uint32
18278 GetDurationNsec() uint32
18279 GetPriority() uint16
18280 GetIdleTimeout() uint16
18281 GetHardTimeout() uint16
18282 GetMatchLen() uint16
18283 GetIdleAge() uint16
18284 GetHardAge() uint16
18285 GetCookie() uint64
18286 GetPacketCount() uint64
18287 GetByteCount() uint64
18288 GetMatch() NiciraMatch
18289 GetActions() []goloxi.IAction
18290}
18291
18292func (self *NiciraFlowStats) GetLength() uint16 {
18293 return self.Length
18294}
18295
18296func (self *NiciraFlowStats) SetLength(v uint16) {
18297 self.Length = v
18298}
18299
18300func (self *NiciraFlowStats) GetTableId() uint8 {
18301 return self.TableId
18302}
18303
18304func (self *NiciraFlowStats) SetTableId(v uint8) {
18305 self.TableId = v
18306}
18307
18308func (self *NiciraFlowStats) GetDurationSec() uint32 {
18309 return self.DurationSec
18310}
18311
18312func (self *NiciraFlowStats) SetDurationSec(v uint32) {
18313 self.DurationSec = v
18314}
18315
18316func (self *NiciraFlowStats) GetDurationNsec() uint32 {
18317 return self.DurationNsec
18318}
18319
18320func (self *NiciraFlowStats) SetDurationNsec(v uint32) {
18321 self.DurationNsec = v
18322}
18323
18324func (self *NiciraFlowStats) GetPriority() uint16 {
18325 return self.Priority
18326}
18327
18328func (self *NiciraFlowStats) SetPriority(v uint16) {
18329 self.Priority = v
18330}
18331
18332func (self *NiciraFlowStats) GetIdleTimeout() uint16 {
18333 return self.IdleTimeout
18334}
18335
18336func (self *NiciraFlowStats) SetIdleTimeout(v uint16) {
18337 self.IdleTimeout = v
18338}
18339
18340func (self *NiciraFlowStats) GetHardTimeout() uint16 {
18341 return self.HardTimeout
18342}
18343
18344func (self *NiciraFlowStats) SetHardTimeout(v uint16) {
18345 self.HardTimeout = v
18346}
18347
18348func (self *NiciraFlowStats) GetMatchLen() uint16 {
18349 return self.MatchLen
18350}
18351
18352func (self *NiciraFlowStats) SetMatchLen(v uint16) {
18353 self.MatchLen = v
18354}
18355
18356func (self *NiciraFlowStats) GetIdleAge() uint16 {
18357 return self.IdleAge
18358}
18359
18360func (self *NiciraFlowStats) SetIdleAge(v uint16) {
18361 self.IdleAge = v
18362}
18363
18364func (self *NiciraFlowStats) GetHardAge() uint16 {
18365 return self.HardAge
18366}
18367
18368func (self *NiciraFlowStats) SetHardAge(v uint16) {
18369 self.HardAge = v
18370}
18371
18372func (self *NiciraFlowStats) GetCookie() uint64 {
18373 return self.Cookie
18374}
18375
18376func (self *NiciraFlowStats) SetCookie(v uint64) {
18377 self.Cookie = v
18378}
18379
18380func (self *NiciraFlowStats) GetPacketCount() uint64 {
18381 return self.PacketCount
18382}
18383
18384func (self *NiciraFlowStats) SetPacketCount(v uint64) {
18385 self.PacketCount = v
18386}
18387
18388func (self *NiciraFlowStats) GetByteCount() uint64 {
18389 return self.ByteCount
18390}
18391
18392func (self *NiciraFlowStats) SetByteCount(v uint64) {
18393 self.ByteCount = v
18394}
18395
18396func (self *NiciraFlowStats) GetMatch() NiciraMatch {
18397 return self.Match
18398}
18399
18400func (self *NiciraFlowStats) SetMatch(v NiciraMatch) {
18401 self.Match = v
18402}
18403
18404func (self *NiciraFlowStats) GetActions() []goloxi.IAction {
18405 return self.Actions
18406}
18407
18408func (self *NiciraFlowStats) SetActions(v []goloxi.IAction) {
18409 self.Actions = v
18410}
18411
18412func (self *NiciraFlowStats) Serialize(encoder *goloxi.Encoder) error {
18413 startIndex := len(encoder.Bytes())
18414
18415 encoder.PutUint16(uint16(self.Length))
18416 encoder.PutUint8(uint8(self.TableId))
18417 encoder.Write(bytes.Repeat([]byte{0}, 1))
18418 encoder.PutUint32(uint32(self.DurationSec))
18419 encoder.PutUint32(uint32(self.DurationNsec))
18420 encoder.PutUint16(uint16(self.Priority))
18421 encoder.PutUint16(uint16(self.IdleTimeout))
18422 encoder.PutUint16(uint16(self.HardTimeout))
18423 encoder.PutUint16(uint16(self.MatchLen))
18424 encoder.PutUint16(uint16(self.IdleAge))
18425 encoder.PutUint16(uint16(self.HardAge))
18426 encoder.PutUint64(uint64(self.Cookie))
18427 encoder.PutUint64(uint64(self.PacketCount))
18428 encoder.PutUint64(uint64(self.ByteCount))
18429 if err := self.Match.Serialize(encoder); err != nil {
18430 return err
18431 }
18432
18433 for _, obj := range self.Actions {
18434 if err := obj.Serialize(encoder); err != nil {
18435 return err
18436 }
18437 }
18438 length := len(encoder.Bytes()) - startIndex
18439
18440 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
18441
18442 return nil
18443}
18444
18445func DecodeNiciraFlowStats(decoder *goloxi.Decoder) (*NiciraFlowStats, error) {
18446 _niciraflowstats := &NiciraFlowStats{}
18447 if decoder.Length() < 48 {
18448 return nil, fmt.Errorf("NiciraFlowStats packet too short: %d < 48", decoder.Length())
18449 }
18450 _niciraflowstats.Length = uint16(decoder.ReadUint16())
18451 oldDecoder := decoder
18452 defer func() { decoder = oldDecoder }()
18453 decoder = decoder.SliceDecoder(int(_niciraflowstats.Length), 2+0)
18454 _niciraflowstats.TableId = uint8(decoder.ReadByte())
18455 decoder.Skip(1)
18456 _niciraflowstats.DurationSec = uint32(decoder.ReadUint32())
18457 _niciraflowstats.DurationNsec = uint32(decoder.ReadUint32())
18458 _niciraflowstats.Priority = uint16(decoder.ReadUint16())
18459 _niciraflowstats.IdleTimeout = uint16(decoder.ReadUint16())
18460 _niciraflowstats.HardTimeout = uint16(decoder.ReadUint16())
18461 _niciraflowstats.MatchLen = uint16(decoder.ReadUint16())
18462 _niciraflowstats.IdleAge = uint16(decoder.ReadUint16())
18463 _niciraflowstats.HardAge = uint16(decoder.ReadUint16())
18464 _niciraflowstats.Cookie = uint64(decoder.ReadUint64())
18465 _niciraflowstats.PacketCount = uint64(decoder.ReadUint64())
18466 _niciraflowstats.ByteCount = uint64(decoder.ReadUint64())
18467 if err := _niciraflowstats.Match.Decode(decoder.SliceDecoder(int(_niciraflowstats.MatchLen), 0)); err != nil {
18468 return nil, err
18469 }
18470
18471 decoder.SkipAlign()
18472
18473 for decoder.Length() >= 4 {
18474 item, err := DecodeAction(decoder)
18475 if err != nil {
18476 return nil, err
18477 }
18478 if item != nil {
18479 _niciraflowstats.Actions = append(_niciraflowstats.Actions, item)
18480 }
18481 }
18482 return _niciraflowstats, nil
18483}
18484
18485func NewNiciraFlowStats() *NiciraFlowStats {
18486 obj := &NiciraFlowStats{}
18487 return obj
18488}
18489
18490type NiciraFlowUpdateEvent struct {
18491 Length uint16
18492 Event uint16
18493}
18494
18495type INiciraFlowUpdateEvent interface {
18496 goloxi.Serializable
18497 GetLength() uint16
18498 GetEvent() uint16
18499}
18500
18501func (self *NiciraFlowUpdateEvent) GetLength() uint16 {
18502 return self.Length
18503}
18504
18505func (self *NiciraFlowUpdateEvent) SetLength(v uint16) {
18506 self.Length = v
18507}
18508
18509func (self *NiciraFlowUpdateEvent) GetEvent() uint16 {
18510 return self.Event
18511}
18512
18513func (self *NiciraFlowUpdateEvent) SetEvent(v uint16) {
18514 self.Event = v
18515}
18516
18517func (self *NiciraFlowUpdateEvent) Serialize(encoder *goloxi.Encoder) error {
18518
18519 encoder.PutUint16(uint16(self.Length))
18520 encoder.PutUint16(uint16(self.Event))
18521
18522 return nil
18523}
18524
18525func DecodeNiciraFlowUpdateEvent(decoder *goloxi.Decoder) (INiciraFlowUpdateEvent, error) {
18526 _niciraflowupdateevent := &NiciraFlowUpdateEvent{}
18527 if decoder.Length() < 4 {
18528 return nil, fmt.Errorf("NiciraFlowUpdateEvent packet too short: %d < 4", decoder.Length())
18529 }
18530 _niciraflowupdateevent.Length = uint16(decoder.ReadUint16())
18531 oldDecoder := decoder
18532 defer func() { decoder = oldDecoder }()
18533 decoder = decoder.SliceDecoder(int(_niciraflowupdateevent.Length), 2+0)
18534 _niciraflowupdateevent.Event = uint16(decoder.ReadUint16())
18535
18536 switch _niciraflowupdateevent.Event {
18537 case 0:
18538 return DecodeNiciraFlowUpdateFullAdd(_niciraflowupdateevent, decoder)
18539 case 1:
18540 return DecodeNiciraFlowUpdateFullDeleted(_niciraflowupdateevent, decoder)
18541 case 2:
18542 return DecodeNiciraFlowUpdateFullModified(_niciraflowupdateevent, decoder)
18543 default:
18544 return nil, fmt.Errorf("Invalid type '%d' for 'NiciraFlowUpdateEvent'", _niciraflowupdateevent.Event)
18545 }
18546}
18547
18548func NewNiciraFlowUpdateEvent(_event uint16) *NiciraFlowUpdateEvent {
18549 obj := &NiciraFlowUpdateEvent{}
18550 obj.Event = _event
18551 return obj
18552}
18553
18554type NiciraFlowUpdateFullAdd struct {
18555 *NiciraFlowUpdateEvent
18556 Reason uint16
18557 Priority uint16
18558 IdleTimeout uint16
18559 HardTimeout uint16
18560 MatchLen uint16
18561 TableId uint8
18562 Cookie uint64
18563 Match NiciraMatch
18564 Actions []goloxi.IAction
18565}
18566
18567type INiciraFlowUpdateFullAdd interface {
18568 INiciraFlowUpdateEvent
18569 GetReason() uint16
18570 GetPriority() uint16
18571 GetIdleTimeout() uint16
18572 GetHardTimeout() uint16
18573 GetMatchLen() uint16
18574 GetTableId() uint8
18575 GetCookie() uint64
18576 GetMatch() NiciraMatch
18577 GetActions() []goloxi.IAction
18578}
18579
18580func (self *NiciraFlowUpdateFullAdd) GetReason() uint16 {
18581 return self.Reason
18582}
18583
18584func (self *NiciraFlowUpdateFullAdd) SetReason(v uint16) {
18585 self.Reason = v
18586}
18587
18588func (self *NiciraFlowUpdateFullAdd) GetPriority() uint16 {
18589 return self.Priority
18590}
18591
18592func (self *NiciraFlowUpdateFullAdd) SetPriority(v uint16) {
18593 self.Priority = v
18594}
18595
18596func (self *NiciraFlowUpdateFullAdd) GetIdleTimeout() uint16 {
18597 return self.IdleTimeout
18598}
18599
18600func (self *NiciraFlowUpdateFullAdd) SetIdleTimeout(v uint16) {
18601 self.IdleTimeout = v
18602}
18603
18604func (self *NiciraFlowUpdateFullAdd) GetHardTimeout() uint16 {
18605 return self.HardTimeout
18606}
18607
18608func (self *NiciraFlowUpdateFullAdd) SetHardTimeout(v uint16) {
18609 self.HardTimeout = v
18610}
18611
18612func (self *NiciraFlowUpdateFullAdd) GetMatchLen() uint16 {
18613 return self.MatchLen
18614}
18615
18616func (self *NiciraFlowUpdateFullAdd) SetMatchLen(v uint16) {
18617 self.MatchLen = v
18618}
18619
18620func (self *NiciraFlowUpdateFullAdd) GetTableId() uint8 {
18621 return self.TableId
18622}
18623
18624func (self *NiciraFlowUpdateFullAdd) SetTableId(v uint8) {
18625 self.TableId = v
18626}
18627
18628func (self *NiciraFlowUpdateFullAdd) GetCookie() uint64 {
18629 return self.Cookie
18630}
18631
18632func (self *NiciraFlowUpdateFullAdd) SetCookie(v uint64) {
18633 self.Cookie = v
18634}
18635
18636func (self *NiciraFlowUpdateFullAdd) GetMatch() NiciraMatch {
18637 return self.Match
18638}
18639
18640func (self *NiciraFlowUpdateFullAdd) SetMatch(v NiciraMatch) {
18641 self.Match = v
18642}
18643
18644func (self *NiciraFlowUpdateFullAdd) GetActions() []goloxi.IAction {
18645 return self.Actions
18646}
18647
18648func (self *NiciraFlowUpdateFullAdd) SetActions(v []goloxi.IAction) {
18649 self.Actions = v
18650}
18651
18652func (self *NiciraFlowUpdateFullAdd) Serialize(encoder *goloxi.Encoder) error {
18653 startIndex := len(encoder.Bytes())
18654 if err := self.NiciraFlowUpdateEvent.Serialize(encoder); err != nil {
18655 return err
18656 }
18657
18658 encoder.PutUint16(uint16(self.Reason))
18659 encoder.PutUint16(uint16(self.Priority))
18660 encoder.PutUint16(uint16(self.IdleTimeout))
18661 encoder.PutUint16(uint16(self.HardTimeout))
18662 encoder.PutUint16(uint16(self.MatchLen))
18663 encoder.PutUint8(uint8(self.TableId))
18664 encoder.Write(bytes.Repeat([]byte{0}, 1))
18665 encoder.PutUint64(uint64(self.Cookie))
18666 if err := self.Match.Serialize(encoder); err != nil {
18667 return err
18668 }
18669
18670 for _, obj := range self.Actions {
18671 if err := obj.Serialize(encoder); err != nil {
18672 return err
18673 }
18674 }
18675 length := len(encoder.Bytes()) - startIndex
18676
18677 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
18678
18679 return nil
18680}
18681
18682func DecodeNiciraFlowUpdateFullAdd(parent *NiciraFlowUpdateEvent, decoder *goloxi.Decoder) (*NiciraFlowUpdateFullAdd, error) {
18683 _niciraflowupdatefulladd := &NiciraFlowUpdateFullAdd{NiciraFlowUpdateEvent: parent}
18684 if decoder.Length() < 20 {
18685 return nil, fmt.Errorf("NiciraFlowUpdateFullAdd packet too short: %d < 20", decoder.Length())
18686 }
18687 _niciraflowupdatefulladd.Reason = uint16(decoder.ReadUint16())
18688 _niciraflowupdatefulladd.Priority = uint16(decoder.ReadUint16())
18689 _niciraflowupdatefulladd.IdleTimeout = uint16(decoder.ReadUint16())
18690 _niciraflowupdatefulladd.HardTimeout = uint16(decoder.ReadUint16())
18691 _niciraflowupdatefulladd.MatchLen = uint16(decoder.ReadUint16())
18692 _niciraflowupdatefulladd.TableId = uint8(decoder.ReadByte())
18693 decoder.Skip(1)
18694 _niciraflowupdatefulladd.Cookie = uint64(decoder.ReadUint64())
18695 if err := _niciraflowupdatefulladd.Match.Decode(decoder.SliceDecoder(int(_niciraflowupdatefulladd.MatchLen), 0)); err != nil {
18696 return nil, err
18697 }
18698
18699 decoder.SkipAlign()
18700
18701 for decoder.Length() >= 4 {
18702 item, err := DecodeAction(decoder)
18703 if err != nil {
18704 return nil, err
18705 }
18706 if item != nil {
18707 _niciraflowupdatefulladd.Actions = append(_niciraflowupdatefulladd.Actions, item)
18708 }
18709 }
18710 return _niciraflowupdatefulladd, nil
18711}
18712
18713func NewNiciraFlowUpdateFullAdd() *NiciraFlowUpdateFullAdd {
18714 obj := &NiciraFlowUpdateFullAdd{
18715 NiciraFlowUpdateEvent: NewNiciraFlowUpdateEvent(0),
18716 }
18717 return obj
18718}
18719
18720type NiciraFlowUpdateFullDeleted struct {
18721 *NiciraFlowUpdateEvent
18722 Reason uint16
18723 Priority uint16
18724 IdleTimeout uint16
18725 HardTimeout uint16
18726 MatchLen uint16
18727 TableId uint8
18728 Cookie uint64
18729 Match NiciraMatch
18730 Actions []goloxi.IAction
18731}
18732
18733type INiciraFlowUpdateFullDeleted interface {
18734 INiciraFlowUpdateEvent
18735 GetReason() uint16
18736 GetPriority() uint16
18737 GetIdleTimeout() uint16
18738 GetHardTimeout() uint16
18739 GetMatchLen() uint16
18740 GetTableId() uint8
18741 GetCookie() uint64
18742 GetMatch() NiciraMatch
18743 GetActions() []goloxi.IAction
18744}
18745
18746func (self *NiciraFlowUpdateFullDeleted) GetReason() uint16 {
18747 return self.Reason
18748}
18749
18750func (self *NiciraFlowUpdateFullDeleted) SetReason(v uint16) {
18751 self.Reason = v
18752}
18753
18754func (self *NiciraFlowUpdateFullDeleted) GetPriority() uint16 {
18755 return self.Priority
18756}
18757
18758func (self *NiciraFlowUpdateFullDeleted) SetPriority(v uint16) {
18759 self.Priority = v
18760}
18761
18762func (self *NiciraFlowUpdateFullDeleted) GetIdleTimeout() uint16 {
18763 return self.IdleTimeout
18764}
18765
18766func (self *NiciraFlowUpdateFullDeleted) SetIdleTimeout(v uint16) {
18767 self.IdleTimeout = v
18768}
18769
18770func (self *NiciraFlowUpdateFullDeleted) GetHardTimeout() uint16 {
18771 return self.HardTimeout
18772}
18773
18774func (self *NiciraFlowUpdateFullDeleted) SetHardTimeout(v uint16) {
18775 self.HardTimeout = v
18776}
18777
18778func (self *NiciraFlowUpdateFullDeleted) GetMatchLen() uint16 {
18779 return self.MatchLen
18780}
18781
18782func (self *NiciraFlowUpdateFullDeleted) SetMatchLen(v uint16) {
18783 self.MatchLen = v
18784}
18785
18786func (self *NiciraFlowUpdateFullDeleted) GetTableId() uint8 {
18787 return self.TableId
18788}
18789
18790func (self *NiciraFlowUpdateFullDeleted) SetTableId(v uint8) {
18791 self.TableId = v
18792}
18793
18794func (self *NiciraFlowUpdateFullDeleted) GetCookie() uint64 {
18795 return self.Cookie
18796}
18797
18798func (self *NiciraFlowUpdateFullDeleted) SetCookie(v uint64) {
18799 self.Cookie = v
18800}
18801
18802func (self *NiciraFlowUpdateFullDeleted) GetMatch() NiciraMatch {
18803 return self.Match
18804}
18805
18806func (self *NiciraFlowUpdateFullDeleted) SetMatch(v NiciraMatch) {
18807 self.Match = v
18808}
18809
18810func (self *NiciraFlowUpdateFullDeleted) GetActions() []goloxi.IAction {
18811 return self.Actions
18812}
18813
18814func (self *NiciraFlowUpdateFullDeleted) SetActions(v []goloxi.IAction) {
18815 self.Actions = v
18816}
18817
18818func (self *NiciraFlowUpdateFullDeleted) Serialize(encoder *goloxi.Encoder) error {
18819 startIndex := len(encoder.Bytes())
18820 if err := self.NiciraFlowUpdateEvent.Serialize(encoder); err != nil {
18821 return err
18822 }
18823
18824 encoder.PutUint16(uint16(self.Reason))
18825 encoder.PutUint16(uint16(self.Priority))
18826 encoder.PutUint16(uint16(self.IdleTimeout))
18827 encoder.PutUint16(uint16(self.HardTimeout))
18828 encoder.PutUint16(uint16(self.MatchLen))
18829 encoder.PutUint8(uint8(self.TableId))
18830 encoder.Write(bytes.Repeat([]byte{0}, 1))
18831 encoder.PutUint64(uint64(self.Cookie))
18832 if err := self.Match.Serialize(encoder); err != nil {
18833 return err
18834 }
18835
18836 for _, obj := range self.Actions {
18837 if err := obj.Serialize(encoder); err != nil {
18838 return err
18839 }
18840 }
18841 length := len(encoder.Bytes()) - startIndex
18842
18843 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
18844
18845 return nil
18846}
18847
18848func DecodeNiciraFlowUpdateFullDeleted(parent *NiciraFlowUpdateEvent, decoder *goloxi.Decoder) (*NiciraFlowUpdateFullDeleted, error) {
18849 _niciraflowupdatefulldeleted := &NiciraFlowUpdateFullDeleted{NiciraFlowUpdateEvent: parent}
18850 if decoder.Length() < 20 {
18851 return nil, fmt.Errorf("NiciraFlowUpdateFullDeleted packet too short: %d < 20", decoder.Length())
18852 }
18853 _niciraflowupdatefulldeleted.Reason = uint16(decoder.ReadUint16())
18854 _niciraflowupdatefulldeleted.Priority = uint16(decoder.ReadUint16())
18855 _niciraflowupdatefulldeleted.IdleTimeout = uint16(decoder.ReadUint16())
18856 _niciraflowupdatefulldeleted.HardTimeout = uint16(decoder.ReadUint16())
18857 _niciraflowupdatefulldeleted.MatchLen = uint16(decoder.ReadUint16())
18858 _niciraflowupdatefulldeleted.TableId = uint8(decoder.ReadByte())
18859 decoder.Skip(1)
18860 _niciraflowupdatefulldeleted.Cookie = uint64(decoder.ReadUint64())
18861 if err := _niciraflowupdatefulldeleted.Match.Decode(decoder.SliceDecoder(int(_niciraflowupdatefulldeleted.MatchLen), 0)); err != nil {
18862 return nil, err
18863 }
18864
18865 decoder.SkipAlign()
18866
18867 for decoder.Length() >= 4 {
18868 item, err := DecodeAction(decoder)
18869 if err != nil {
18870 return nil, err
18871 }
18872 if item != nil {
18873 _niciraflowupdatefulldeleted.Actions = append(_niciraflowupdatefulldeleted.Actions, item)
18874 }
18875 }
18876 return _niciraflowupdatefulldeleted, nil
18877}
18878
18879func NewNiciraFlowUpdateFullDeleted() *NiciraFlowUpdateFullDeleted {
18880 obj := &NiciraFlowUpdateFullDeleted{
18881 NiciraFlowUpdateEvent: NewNiciraFlowUpdateEvent(1),
18882 }
18883 return obj
18884}
18885
18886type NiciraFlowUpdateFullModified struct {
18887 *NiciraFlowUpdateEvent
18888 Reason uint16
18889 Priority uint16
18890 IdleTimeout uint16
18891 HardTimeout uint16
18892 MatchLen uint16
18893 TableId uint8
18894 Cookie uint64
18895 Match NiciraMatch
18896 Actions []goloxi.IAction
18897}
18898
18899type INiciraFlowUpdateFullModified interface {
18900 INiciraFlowUpdateEvent
18901 GetReason() uint16
18902 GetPriority() uint16
18903 GetIdleTimeout() uint16
18904 GetHardTimeout() uint16
18905 GetMatchLen() uint16
18906 GetTableId() uint8
18907 GetCookie() uint64
18908 GetMatch() NiciraMatch
18909 GetActions() []goloxi.IAction
18910}
18911
18912func (self *NiciraFlowUpdateFullModified) GetReason() uint16 {
18913 return self.Reason
18914}
18915
18916func (self *NiciraFlowUpdateFullModified) SetReason(v uint16) {
18917 self.Reason = v
18918}
18919
18920func (self *NiciraFlowUpdateFullModified) GetPriority() uint16 {
18921 return self.Priority
18922}
18923
18924func (self *NiciraFlowUpdateFullModified) SetPriority(v uint16) {
18925 self.Priority = v
18926}
18927
18928func (self *NiciraFlowUpdateFullModified) GetIdleTimeout() uint16 {
18929 return self.IdleTimeout
18930}
18931
18932func (self *NiciraFlowUpdateFullModified) SetIdleTimeout(v uint16) {
18933 self.IdleTimeout = v
18934}
18935
18936func (self *NiciraFlowUpdateFullModified) GetHardTimeout() uint16 {
18937 return self.HardTimeout
18938}
18939
18940func (self *NiciraFlowUpdateFullModified) SetHardTimeout(v uint16) {
18941 self.HardTimeout = v
18942}
18943
18944func (self *NiciraFlowUpdateFullModified) GetMatchLen() uint16 {
18945 return self.MatchLen
18946}
18947
18948func (self *NiciraFlowUpdateFullModified) SetMatchLen(v uint16) {
18949 self.MatchLen = v
18950}
18951
18952func (self *NiciraFlowUpdateFullModified) GetTableId() uint8 {
18953 return self.TableId
18954}
18955
18956func (self *NiciraFlowUpdateFullModified) SetTableId(v uint8) {
18957 self.TableId = v
18958}
18959
18960func (self *NiciraFlowUpdateFullModified) GetCookie() uint64 {
18961 return self.Cookie
18962}
18963
18964func (self *NiciraFlowUpdateFullModified) SetCookie(v uint64) {
18965 self.Cookie = v
18966}
18967
18968func (self *NiciraFlowUpdateFullModified) GetMatch() NiciraMatch {
18969 return self.Match
18970}
18971
18972func (self *NiciraFlowUpdateFullModified) SetMatch(v NiciraMatch) {
18973 self.Match = v
18974}
18975
18976func (self *NiciraFlowUpdateFullModified) GetActions() []goloxi.IAction {
18977 return self.Actions
18978}
18979
18980func (self *NiciraFlowUpdateFullModified) SetActions(v []goloxi.IAction) {
18981 self.Actions = v
18982}
18983
18984func (self *NiciraFlowUpdateFullModified) Serialize(encoder *goloxi.Encoder) error {
18985 startIndex := len(encoder.Bytes())
18986 if err := self.NiciraFlowUpdateEvent.Serialize(encoder); err != nil {
18987 return err
18988 }
18989
18990 encoder.PutUint16(uint16(self.Reason))
18991 encoder.PutUint16(uint16(self.Priority))
18992 encoder.PutUint16(uint16(self.IdleTimeout))
18993 encoder.PutUint16(uint16(self.HardTimeout))
18994 encoder.PutUint16(uint16(self.MatchLen))
18995 encoder.PutUint8(uint8(self.TableId))
18996 encoder.Write(bytes.Repeat([]byte{0}, 1))
18997 encoder.PutUint64(uint64(self.Cookie))
18998 if err := self.Match.Serialize(encoder); err != nil {
18999 return err
19000 }
19001
19002 for _, obj := range self.Actions {
19003 if err := obj.Serialize(encoder); err != nil {
19004 return err
19005 }
19006 }
19007 length := len(encoder.Bytes()) - startIndex
19008
19009 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
19010
19011 return nil
19012}
19013
19014func DecodeNiciraFlowUpdateFullModified(parent *NiciraFlowUpdateEvent, decoder *goloxi.Decoder) (*NiciraFlowUpdateFullModified, error) {
19015 _niciraflowupdatefullmodified := &NiciraFlowUpdateFullModified{NiciraFlowUpdateEvent: parent}
19016 if decoder.Length() < 20 {
19017 return nil, fmt.Errorf("NiciraFlowUpdateFullModified packet too short: %d < 20", decoder.Length())
19018 }
19019 _niciraflowupdatefullmodified.Reason = uint16(decoder.ReadUint16())
19020 _niciraflowupdatefullmodified.Priority = uint16(decoder.ReadUint16())
19021 _niciraflowupdatefullmodified.IdleTimeout = uint16(decoder.ReadUint16())
19022 _niciraflowupdatefullmodified.HardTimeout = uint16(decoder.ReadUint16())
19023 _niciraflowupdatefullmodified.MatchLen = uint16(decoder.ReadUint16())
19024 _niciraflowupdatefullmodified.TableId = uint8(decoder.ReadByte())
19025 decoder.Skip(1)
19026 _niciraflowupdatefullmodified.Cookie = uint64(decoder.ReadUint64())
19027 if err := _niciraflowupdatefullmodified.Match.Decode(decoder.SliceDecoder(int(_niciraflowupdatefullmodified.MatchLen), 0)); err != nil {
19028 return nil, err
19029 }
19030
19031 decoder.SkipAlign()
19032
19033 for decoder.Length() >= 4 {
19034 item, err := DecodeAction(decoder)
19035 if err != nil {
19036 return nil, err
19037 }
19038 if item != nil {
19039 _niciraflowupdatefullmodified.Actions = append(_niciraflowupdatefullmodified.Actions, item)
19040 }
19041 }
19042 return _niciraflowupdatefullmodified, nil
19043}
19044
19045func NewNiciraFlowUpdateFullModified() *NiciraFlowUpdateFullModified {
19046 obj := &NiciraFlowUpdateFullModified{
19047 NiciraFlowUpdateEvent: NewNiciraFlowUpdateEvent(2),
19048 }
19049 return obj
19050}
19051
19052type OxmIdArpOp struct {
19053 *OxmId
19054}
19055
19056type IOxmIdArpOp interface {
19057 IOxmId
19058}
19059
19060func (self *OxmIdArpOp) Serialize(encoder *goloxi.Encoder) error {
19061 if err := self.OxmId.Serialize(encoder); err != nil {
19062 return err
19063 }
19064
19065 return nil
19066}
19067
19068func DecodeOxmIdArpOp(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpOp, error) {
19069 _oxmidarpop := &OxmIdArpOp{OxmId: parent}
19070 return _oxmidarpop, nil
19071}
19072
19073func NewOxmIdArpOp() *OxmIdArpOp {
19074 obj := &OxmIdArpOp{
19075 OxmId: NewOxmId(7682),
19076 }
19077 return obj
19078}
19079func (self *OxmIdArpOp) GetOXMName() string {
19080 return "arp_op"
19081}
19082
19083func (self *OxmIdArpOp) MarshalJSON() ([]byte, error) {
19084 if self.TypeLen == 0 {
19085 return []byte("\"\""), nil
19086 } else {
19087 return []byte("\"" + self.GetOXMName() + "\""), nil
19088 }
19089}
19090
19091type OxmIdArpSha struct {
19092 *OxmId
19093}
19094
19095type IOxmIdArpSha interface {
19096 IOxmId
19097}
19098
19099func (self *OxmIdArpSha) Serialize(encoder *goloxi.Encoder) error {
19100 if err := self.OxmId.Serialize(encoder); err != nil {
19101 return err
19102 }
19103
19104 return nil
19105}
19106
19107func DecodeOxmIdArpSha(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpSha, error) {
19108 _oxmidarpsha := &OxmIdArpSha{OxmId: parent}
19109 return _oxmidarpsha, nil
19110}
19111
19112func NewOxmIdArpSha() *OxmIdArpSha {
19113 obj := &OxmIdArpSha{
19114 OxmId: NewOxmId(74246),
19115 }
19116 return obj
19117}
19118func (self *OxmIdArpSha) GetOXMName() string {
19119 return "arp_sha"
19120}
19121
19122func (self *OxmIdArpSha) MarshalJSON() ([]byte, error) {
19123 if self.TypeLen == 0 {
19124 return []byte("\"\""), nil
19125 } else {
19126 return []byte("\"" + self.GetOXMName() + "\""), nil
19127 }
19128}
19129
19130type OxmIdArpShaMasked struct {
19131 *OxmId
19132}
19133
19134type IOxmIdArpShaMasked interface {
19135 IOxmId
19136}
19137
19138func (self *OxmIdArpShaMasked) Serialize(encoder *goloxi.Encoder) error {
19139 if err := self.OxmId.Serialize(encoder); err != nil {
19140 return err
19141 }
19142
19143 return nil
19144}
19145
19146func DecodeOxmIdArpShaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpShaMasked, error) {
19147 _oxmidarpshamasked := &OxmIdArpShaMasked{OxmId: parent}
19148 return _oxmidarpshamasked, nil
19149}
19150
19151func NewOxmIdArpShaMasked() *OxmIdArpShaMasked {
19152 obj := &OxmIdArpShaMasked{
19153 OxmId: NewOxmId(74507),
19154 }
19155 return obj
19156}
19157func (self *OxmIdArpShaMasked) GetOXMName() string {
19158 return "arp_sha_masked"
19159}
19160
19161func (self *OxmIdArpShaMasked) MarshalJSON() ([]byte, error) {
19162 if self.TypeLen == 0 {
19163 return []byte("\"\""), nil
19164 } else {
19165 return []byte("\"" + self.GetOXMName() + "\""), nil
19166 }
19167}
19168
19169type OxmIdArpSpa struct {
19170 *OxmId
19171}
19172
19173type IOxmIdArpSpa interface {
19174 IOxmId
19175}
19176
19177func (self *OxmIdArpSpa) Serialize(encoder *goloxi.Encoder) error {
19178 if err := self.OxmId.Serialize(encoder); err != nil {
19179 return err
19180 }
19181
19182 return nil
19183}
19184
19185func DecodeOxmIdArpSpa(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpSpa, error) {
19186 _oxmidarpspa := &OxmIdArpSpa{OxmId: parent}
19187 return _oxmidarpspa, nil
19188}
19189
19190func NewOxmIdArpSpa() *OxmIdArpSpa {
19191 obj := &OxmIdArpSpa{
19192 OxmId: NewOxmId(8196),
19193 }
19194 return obj
19195}
19196func (self *OxmIdArpSpa) GetOXMName() string {
19197 return "arp_spa"
19198}
19199
19200func (self *OxmIdArpSpa) MarshalJSON() ([]byte, error) {
19201 if self.TypeLen == 0 {
19202 return []byte("\"\""), nil
19203 } else {
19204 return []byte("\"" + self.GetOXMName() + "\""), nil
19205 }
19206}
19207
19208type OxmIdArpSpaMasked struct {
19209 *OxmId
19210}
19211
19212type IOxmIdArpSpaMasked interface {
19213 IOxmId
19214}
19215
19216func (self *OxmIdArpSpaMasked) Serialize(encoder *goloxi.Encoder) error {
19217 if err := self.OxmId.Serialize(encoder); err != nil {
19218 return err
19219 }
19220
19221 return nil
19222}
19223
19224func DecodeOxmIdArpSpaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpSpaMasked, error) {
19225 _oxmidarpspamasked := &OxmIdArpSpaMasked{OxmId: parent}
19226 return _oxmidarpspamasked, nil
19227}
19228
19229func NewOxmIdArpSpaMasked() *OxmIdArpSpaMasked {
19230 obj := &OxmIdArpSpaMasked{
19231 OxmId: NewOxmId(8452),
19232 }
19233 return obj
19234}
19235func (self *OxmIdArpSpaMasked) GetOXMName() string {
19236 return "arp_spa_masked"
19237}
19238
19239func (self *OxmIdArpSpaMasked) MarshalJSON() ([]byte, error) {
19240 if self.TypeLen == 0 {
19241 return []byte("\"\""), nil
19242 } else {
19243 return []byte("\"" + self.GetOXMName() + "\""), nil
19244 }
19245}
19246
19247type OxmIdArpTha struct {
19248 *OxmId
19249}
19250
19251type IOxmIdArpTha interface {
19252 IOxmId
19253}
19254
19255func (self *OxmIdArpTha) Serialize(encoder *goloxi.Encoder) error {
19256 if err := self.OxmId.Serialize(encoder); err != nil {
19257 return err
19258 }
19259
19260 return nil
19261}
19262
19263func DecodeOxmIdArpTha(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpTha, error) {
19264 _oxmidarptha := &OxmIdArpTha{OxmId: parent}
19265 return _oxmidarptha, nil
19266}
19267
19268func NewOxmIdArpTha() *OxmIdArpTha {
19269 obj := &OxmIdArpTha{
19270 OxmId: NewOxmId(74758),
19271 }
19272 return obj
19273}
19274func (self *OxmIdArpTha) GetOXMName() string {
19275 return "arp_tha"
19276}
19277
19278func (self *OxmIdArpTha) MarshalJSON() ([]byte, error) {
19279 if self.TypeLen == 0 {
19280 return []byte("\"\""), nil
19281 } else {
19282 return []byte("\"" + self.GetOXMName() + "\""), nil
19283 }
19284}
19285
19286type OxmIdArpThaMasked struct {
19287 *OxmId
19288}
19289
19290type IOxmIdArpThaMasked interface {
19291 IOxmId
19292}
19293
19294func (self *OxmIdArpThaMasked) Serialize(encoder *goloxi.Encoder) error {
19295 if err := self.OxmId.Serialize(encoder); err != nil {
19296 return err
19297 }
19298
19299 return nil
19300}
19301
19302func DecodeOxmIdArpThaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpThaMasked, error) {
19303 _oxmidarpthamasked := &OxmIdArpThaMasked{OxmId: parent}
19304 return _oxmidarpthamasked, nil
19305}
19306
19307func NewOxmIdArpThaMasked() *OxmIdArpThaMasked {
19308 obj := &OxmIdArpThaMasked{
19309 OxmId: NewOxmId(75019),
19310 }
19311 return obj
19312}
19313func (self *OxmIdArpThaMasked) GetOXMName() string {
19314 return "arp_tha_masked"
19315}
19316
19317func (self *OxmIdArpThaMasked) MarshalJSON() ([]byte, error) {
19318 if self.TypeLen == 0 {
19319 return []byte("\"\""), nil
19320 } else {
19321 return []byte("\"" + self.GetOXMName() + "\""), nil
19322 }
19323}
19324
19325type OxmIdArpTpa struct {
19326 *OxmId
19327}
19328
19329type IOxmIdArpTpa interface {
19330 IOxmId
19331}
19332
19333func (self *OxmIdArpTpa) Serialize(encoder *goloxi.Encoder) error {
19334 if err := self.OxmId.Serialize(encoder); err != nil {
19335 return err
19336 }
19337
19338 return nil
19339}
19340
19341func DecodeOxmIdArpTpa(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpTpa, error) {
19342 _oxmidarptpa := &OxmIdArpTpa{OxmId: parent}
19343 return _oxmidarptpa, nil
19344}
19345
19346func NewOxmIdArpTpa() *OxmIdArpTpa {
19347 obj := &OxmIdArpTpa{
19348 OxmId: NewOxmId(8708),
19349 }
19350 return obj
19351}
19352func (self *OxmIdArpTpa) GetOXMName() string {
19353 return "arp_tpa"
19354}
19355
19356func (self *OxmIdArpTpa) MarshalJSON() ([]byte, error) {
19357 if self.TypeLen == 0 {
19358 return []byte("\"\""), nil
19359 } else {
19360 return []byte("\"" + self.GetOXMName() + "\""), nil
19361 }
19362}
19363
19364type OxmIdArpTpaMasked struct {
19365 *OxmId
19366}
19367
19368type IOxmIdArpTpaMasked interface {
19369 IOxmId
19370}
19371
19372func (self *OxmIdArpTpaMasked) Serialize(encoder *goloxi.Encoder) error {
19373 if err := self.OxmId.Serialize(encoder); err != nil {
19374 return err
19375 }
19376
19377 return nil
19378}
19379
19380func DecodeOxmIdArpTpaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpTpaMasked, error) {
19381 _oxmidarptpamasked := &OxmIdArpTpaMasked{OxmId: parent}
19382 return _oxmidarptpamasked, nil
19383}
19384
19385func NewOxmIdArpTpaMasked() *OxmIdArpTpaMasked {
19386 obj := &OxmIdArpTpaMasked{
19387 OxmId: NewOxmId(8968),
19388 }
19389 return obj
19390}
19391func (self *OxmIdArpTpaMasked) GetOXMName() string {
19392 return "arp_tpa_masked"
19393}
19394
19395func (self *OxmIdArpTpaMasked) MarshalJSON() ([]byte, error) {
19396 if self.TypeLen == 0 {
19397 return []byte("\"\""), nil
19398 } else {
19399 return []byte("\"" + self.GetOXMName() + "\""), nil
19400 }
19401}
19402
19403type OxmIdConjId struct {
19404 *OxmId
19405}
19406
19407type IOxmIdConjId interface {
19408 IOxmId
19409}
19410
19411func (self *OxmIdConjId) Serialize(encoder *goloxi.Encoder) error {
19412 if err := self.OxmId.Serialize(encoder); err != nil {
19413 return err
19414 }
19415
19416 return nil
19417}
19418
19419func DecodeOxmIdConjId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConjId, error) {
19420 _oxmidconjid := &OxmIdConjId{OxmId: parent}
19421 return _oxmidconjid, nil
19422}
19423
19424func NewOxmIdConjId() *OxmIdConjId {
19425 obj := &OxmIdConjId{
19426 OxmId: NewOxmId(84484),
19427 }
19428 return obj
19429}
19430func (self *OxmIdConjId) GetOXMName() string {
19431 return "conj_id"
19432}
19433
19434func (self *OxmIdConjId) MarshalJSON() ([]byte, error) {
19435 if self.TypeLen == 0 {
19436 return []byte("\"\""), nil
19437 } else {
19438 return []byte("\"" + self.GetOXMName() + "\""), nil
19439 }
19440}
19441
19442type OxmIdCtIpv6Dst struct {
19443 *OxmId
19444}
19445
19446type IOxmIdCtIpv6Dst interface {
19447 IOxmId
19448}
19449
19450func (self *OxmIdCtIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
19451 if err := self.OxmId.Serialize(encoder); err != nil {
19452 return err
19453 }
19454
19455 return nil
19456}
19457
19458func DecodeOxmIdCtIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6Dst, error) {
19459 _oxmidctipv6dst := &OxmIdCtIpv6Dst{OxmId: parent}
19460 return _oxmidctipv6dst, nil
19461}
19462
19463func NewOxmIdCtIpv6Dst() *OxmIdCtIpv6Dst {
19464 obj := &OxmIdCtIpv6Dst{
19465 OxmId: NewOxmId(128528),
19466 }
19467 return obj
19468}
19469func (self *OxmIdCtIpv6Dst) GetOXMName() string {
19470 return "ct_ipv6_dst"
19471}
19472
19473func (self *OxmIdCtIpv6Dst) MarshalJSON() ([]byte, error) {
19474 if self.TypeLen == 0 {
19475 return []byte("\"\""), nil
19476 } else {
19477 return []byte("\"" + self.GetOXMName() + "\""), nil
19478 }
19479}
19480
19481type OxmIdCtIpv6DstMasked struct {
19482 *OxmId
19483}
19484
19485type IOxmIdCtIpv6DstMasked interface {
19486 IOxmId
19487}
19488
19489func (self *OxmIdCtIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
19490 if err := self.OxmId.Serialize(encoder); err != nil {
19491 return err
19492 }
19493
19494 return nil
19495}
19496
19497func DecodeOxmIdCtIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6DstMasked, error) {
19498 _oxmidctipv6dstmasked := &OxmIdCtIpv6DstMasked{OxmId: parent}
19499 return _oxmidctipv6dstmasked, nil
19500}
19501
19502func NewOxmIdCtIpv6DstMasked() *OxmIdCtIpv6DstMasked {
19503 obj := &OxmIdCtIpv6DstMasked{
19504 OxmId: NewOxmId(128800),
19505 }
19506 return obj
19507}
19508func (self *OxmIdCtIpv6DstMasked) GetOXMName() string {
19509 return "ct_ipv6_dst_masked"
19510}
19511
19512func (self *OxmIdCtIpv6DstMasked) MarshalJSON() ([]byte, error) {
19513 if self.TypeLen == 0 {
19514 return []byte("\"\""), nil
19515 } else {
19516 return []byte("\"" + self.GetOXMName() + "\""), nil
19517 }
19518}
19519
19520type OxmIdCtIpv6Src struct {
19521 *OxmId
19522}
19523
19524type IOxmIdCtIpv6Src interface {
19525 IOxmId
19526}
19527
19528func (self *OxmIdCtIpv6Src) Serialize(encoder *goloxi.Encoder) error {
19529 if err := self.OxmId.Serialize(encoder); err != nil {
19530 return err
19531 }
19532
19533 return nil
19534}
19535
19536func DecodeOxmIdCtIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6Src, error) {
19537 _oxmidctipv6src := &OxmIdCtIpv6Src{OxmId: parent}
19538 return _oxmidctipv6src, nil
19539}
19540
19541func NewOxmIdCtIpv6Src() *OxmIdCtIpv6Src {
19542 obj := &OxmIdCtIpv6Src{
19543 OxmId: NewOxmId(128016),
19544 }
19545 return obj
19546}
19547func (self *OxmIdCtIpv6Src) GetOXMName() string {
19548 return "ct_ipv6_src"
19549}
19550
19551func (self *OxmIdCtIpv6Src) MarshalJSON() ([]byte, error) {
19552 if self.TypeLen == 0 {
19553 return []byte("\"\""), nil
19554 } else {
19555 return []byte("\"" + self.GetOXMName() + "\""), nil
19556 }
19557}
19558
19559type OxmIdCtIpv6SrcMasked struct {
19560 *OxmId
19561}
19562
19563type IOxmIdCtIpv6SrcMasked interface {
19564 IOxmId
19565}
19566
19567func (self *OxmIdCtIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
19568 if err := self.OxmId.Serialize(encoder); err != nil {
19569 return err
19570 }
19571
19572 return nil
19573}
19574
19575func DecodeOxmIdCtIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6SrcMasked, error) {
19576 _oxmidctipv6srcmasked := &OxmIdCtIpv6SrcMasked{OxmId: parent}
19577 return _oxmidctipv6srcmasked, nil
19578}
19579
19580func NewOxmIdCtIpv6SrcMasked() *OxmIdCtIpv6SrcMasked {
19581 obj := &OxmIdCtIpv6SrcMasked{
19582 OxmId: NewOxmId(128288),
19583 }
19584 return obj
19585}
19586func (self *OxmIdCtIpv6SrcMasked) GetOXMName() string {
19587 return "ct_ipv6_src_masked"
19588}
19589
19590func (self *OxmIdCtIpv6SrcMasked) MarshalJSON() ([]byte, error) {
19591 if self.TypeLen == 0 {
19592 return []byte("\"\""), nil
19593 } else {
19594 return []byte("\"" + self.GetOXMName() + "\""), nil
19595 }
19596}
19597
19598type OxmIdCtLabel struct {
19599 *OxmId
19600}
19601
19602type IOxmIdCtLabel interface {
19603 IOxmId
19604}
19605
19606func (self *OxmIdCtLabel) Serialize(encoder *goloxi.Encoder) error {
19607 if err := self.OxmId.Serialize(encoder); err != nil {
19608 return err
19609 }
19610
19611 return nil
19612}
19613
19614func DecodeOxmIdCtLabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtLabel, error) {
19615 _oxmidctlabel := &OxmIdCtLabel{OxmId: parent}
19616 return _oxmidctlabel, nil
19617}
19618
19619func NewOxmIdCtLabel() *OxmIdCtLabel {
19620 obj := &OxmIdCtLabel{
19621 OxmId: NewOxmId(120848),
19622 }
19623 return obj
19624}
19625func (self *OxmIdCtLabel) GetOXMName() string {
19626 return "ct_label"
19627}
19628
19629func (self *OxmIdCtLabel) MarshalJSON() ([]byte, error) {
19630 if self.TypeLen == 0 {
19631 return []byte("\"\""), nil
19632 } else {
19633 return []byte("\"" + self.GetOXMName() + "\""), nil
19634 }
19635}
19636
19637type OxmIdCtLabelMasked struct {
19638 *OxmId
19639}
19640
19641type IOxmIdCtLabelMasked interface {
19642 IOxmId
19643}
19644
19645func (self *OxmIdCtLabelMasked) Serialize(encoder *goloxi.Encoder) error {
19646 if err := self.OxmId.Serialize(encoder); err != nil {
19647 return err
19648 }
19649
19650 return nil
19651}
19652
19653func DecodeOxmIdCtLabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtLabelMasked, error) {
19654 _oxmidctlabelmasked := &OxmIdCtLabelMasked{OxmId: parent}
19655 return _oxmidctlabelmasked, nil
19656}
19657
19658func NewOxmIdCtLabelMasked() *OxmIdCtLabelMasked {
19659 obj := &OxmIdCtLabelMasked{
19660 OxmId: NewOxmId(121120),
19661 }
19662 return obj
19663}
19664func (self *OxmIdCtLabelMasked) GetOXMName() string {
19665 return "ct_label_masked"
19666}
19667
19668func (self *OxmIdCtLabelMasked) MarshalJSON() ([]byte, error) {
19669 if self.TypeLen == 0 {
19670 return []byte("\"\""), nil
19671 } else {
19672 return []byte("\"" + self.GetOXMName() + "\""), nil
19673 }
19674}
19675
19676type OxmIdCtMark struct {
19677 *OxmId
19678}
19679
19680type IOxmIdCtMark interface {
19681 IOxmId
19682}
19683
19684func (self *OxmIdCtMark) Serialize(encoder *goloxi.Encoder) error {
19685 if err := self.OxmId.Serialize(encoder); err != nil {
19686 return err
19687 }
19688
19689 return nil
19690}
19691
19692func DecodeOxmIdCtMark(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtMark, error) {
19693 _oxmidctmark := &OxmIdCtMark{OxmId: parent}
19694 return _oxmidctmark, nil
19695}
19696
19697func NewOxmIdCtMark() *OxmIdCtMark {
19698 obj := &OxmIdCtMark{
19699 OxmId: NewOxmId(120324),
19700 }
19701 return obj
19702}
19703func (self *OxmIdCtMark) GetOXMName() string {
19704 return "ct_mark"
19705}
19706
19707func (self *OxmIdCtMark) MarshalJSON() ([]byte, error) {
19708 if self.TypeLen == 0 {
19709 return []byte("\"\""), nil
19710 } else {
19711 return []byte("\"" + self.GetOXMName() + "\""), nil
19712 }
19713}
19714
19715type OxmIdCtMarkMasked struct {
19716 *OxmId
19717}
19718
19719type IOxmIdCtMarkMasked interface {
19720 IOxmId
19721}
19722
19723func (self *OxmIdCtMarkMasked) Serialize(encoder *goloxi.Encoder) error {
19724 if err := self.OxmId.Serialize(encoder); err != nil {
19725 return err
19726 }
19727
19728 return nil
19729}
19730
19731func DecodeOxmIdCtMarkMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtMarkMasked, error) {
19732 _oxmidctmarkmasked := &OxmIdCtMarkMasked{OxmId: parent}
19733 return _oxmidctmarkmasked, nil
19734}
19735
19736func NewOxmIdCtMarkMasked() *OxmIdCtMarkMasked {
19737 obj := &OxmIdCtMarkMasked{
19738 OxmId: NewOxmId(120584),
19739 }
19740 return obj
19741}
19742func (self *OxmIdCtMarkMasked) GetOXMName() string {
19743 return "ct_mark_masked"
19744}
19745
19746func (self *OxmIdCtMarkMasked) MarshalJSON() ([]byte, error) {
19747 if self.TypeLen == 0 {
19748 return []byte("\"\""), nil
19749 } else {
19750 return []byte("\"" + self.GetOXMName() + "\""), nil
19751 }
19752}
19753
19754type OxmIdCtNwDst struct {
19755 *OxmId
19756}
19757
19758type IOxmIdCtNwDst interface {
19759 IOxmId
19760}
19761
19762func (self *OxmIdCtNwDst) Serialize(encoder *goloxi.Encoder) error {
19763 if err := self.OxmId.Serialize(encoder); err != nil {
19764 return err
19765 }
19766
19767 return nil
19768}
19769
19770func DecodeOxmIdCtNwDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwDst, error) {
19771 _oxmidctnwdst := &OxmIdCtNwDst{OxmId: parent}
19772 return _oxmidctnwdst, nil
19773}
19774
19775func NewOxmIdCtNwDst() *OxmIdCtNwDst {
19776 obj := &OxmIdCtNwDst{
19777 OxmId: NewOxmId(127492),
19778 }
19779 return obj
19780}
19781func (self *OxmIdCtNwDst) GetOXMName() string {
19782 return "ct_nw_dst"
19783}
19784
19785func (self *OxmIdCtNwDst) MarshalJSON() ([]byte, error) {
19786 if self.TypeLen == 0 {
19787 return []byte("\"\""), nil
19788 } else {
19789 return []byte("\"" + self.GetOXMName() + "\""), nil
19790 }
19791}
19792
19793type OxmIdCtNwDstMasked struct {
19794 *OxmId
19795}
19796
19797type IOxmIdCtNwDstMasked interface {
19798 IOxmId
19799}
19800
19801func (self *OxmIdCtNwDstMasked) Serialize(encoder *goloxi.Encoder) error {
19802 if err := self.OxmId.Serialize(encoder); err != nil {
19803 return err
19804 }
19805
19806 return nil
19807}
19808
19809func DecodeOxmIdCtNwDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwDstMasked, error) {
19810 _oxmidctnwdstmasked := &OxmIdCtNwDstMasked{OxmId: parent}
19811 return _oxmidctnwdstmasked, nil
19812}
19813
19814func NewOxmIdCtNwDstMasked() *OxmIdCtNwDstMasked {
19815 obj := &OxmIdCtNwDstMasked{
19816 OxmId: NewOxmId(127752),
19817 }
19818 return obj
19819}
19820func (self *OxmIdCtNwDstMasked) GetOXMName() string {
19821 return "ct_nw_dst_masked"
19822}
19823
19824func (self *OxmIdCtNwDstMasked) MarshalJSON() ([]byte, error) {
19825 if self.TypeLen == 0 {
19826 return []byte("\"\""), nil
19827 } else {
19828 return []byte("\"" + self.GetOXMName() + "\""), nil
19829 }
19830}
19831
19832type OxmIdCtNwProto struct {
19833 *OxmId
19834}
19835
19836type IOxmIdCtNwProto interface {
19837 IOxmId
19838}
19839
19840func (self *OxmIdCtNwProto) Serialize(encoder *goloxi.Encoder) error {
19841 if err := self.OxmId.Serialize(encoder); err != nil {
19842 return err
19843 }
19844
19845 return nil
19846}
19847
19848func DecodeOxmIdCtNwProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwProto, error) {
19849 _oxmidctnwproto := &OxmIdCtNwProto{OxmId: parent}
19850 return _oxmidctnwproto, nil
19851}
19852
19853func NewOxmIdCtNwProto() *OxmIdCtNwProto {
19854 obj := &OxmIdCtNwProto{
19855 OxmId: NewOxmId(126465),
19856 }
19857 return obj
19858}
19859func (self *OxmIdCtNwProto) GetOXMName() string {
19860 return "ct_nw_proto"
19861}
19862
19863func (self *OxmIdCtNwProto) MarshalJSON() ([]byte, error) {
19864 if self.TypeLen == 0 {
19865 return []byte("\"\""), nil
19866 } else {
19867 return []byte("\"" + self.GetOXMName() + "\""), nil
19868 }
19869}
19870
19871type OxmIdCtNwSrc struct {
19872 *OxmId
19873}
19874
19875type IOxmIdCtNwSrc interface {
19876 IOxmId
19877}
19878
19879func (self *OxmIdCtNwSrc) Serialize(encoder *goloxi.Encoder) error {
19880 if err := self.OxmId.Serialize(encoder); err != nil {
19881 return err
19882 }
19883
19884 return nil
19885}
19886
19887func DecodeOxmIdCtNwSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwSrc, error) {
19888 _oxmidctnwsrc := &OxmIdCtNwSrc{OxmId: parent}
19889 return _oxmidctnwsrc, nil
19890}
19891
19892func NewOxmIdCtNwSrc() *OxmIdCtNwSrc {
19893 obj := &OxmIdCtNwSrc{
19894 OxmId: NewOxmId(126980),
19895 }
19896 return obj
19897}
19898func (self *OxmIdCtNwSrc) GetOXMName() string {
19899 return "ct_nw_src"
19900}
19901
19902func (self *OxmIdCtNwSrc) MarshalJSON() ([]byte, error) {
19903 if self.TypeLen == 0 {
19904 return []byte("\"\""), nil
19905 } else {
19906 return []byte("\"" + self.GetOXMName() + "\""), nil
19907 }
19908}
19909
19910type OxmIdCtNwSrcMasked struct {
19911 *OxmId
19912}
19913
19914type IOxmIdCtNwSrcMasked interface {
19915 IOxmId
19916}
19917
19918func (self *OxmIdCtNwSrcMasked) Serialize(encoder *goloxi.Encoder) error {
19919 if err := self.OxmId.Serialize(encoder); err != nil {
19920 return err
19921 }
19922
19923 return nil
19924}
19925
19926func DecodeOxmIdCtNwSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwSrcMasked, error) {
19927 _oxmidctnwsrcmasked := &OxmIdCtNwSrcMasked{OxmId: parent}
19928 return _oxmidctnwsrcmasked, nil
19929}
19930
19931func NewOxmIdCtNwSrcMasked() *OxmIdCtNwSrcMasked {
19932 obj := &OxmIdCtNwSrcMasked{
19933 OxmId: NewOxmId(127240),
19934 }
19935 return obj
19936}
19937func (self *OxmIdCtNwSrcMasked) GetOXMName() string {
19938 return "ct_nw_src_masked"
19939}
19940
19941func (self *OxmIdCtNwSrcMasked) MarshalJSON() ([]byte, error) {
19942 if self.TypeLen == 0 {
19943 return []byte("\"\""), nil
19944 } else {
19945 return []byte("\"" + self.GetOXMName() + "\""), nil
19946 }
19947}
19948
19949type OxmIdCtState struct {
19950 *OxmId
19951}
19952
19953type IOxmIdCtState interface {
19954 IOxmId
19955}
19956
19957func (self *OxmIdCtState) Serialize(encoder *goloxi.Encoder) error {
19958 if err := self.OxmId.Serialize(encoder); err != nil {
19959 return err
19960 }
19961
19962 return nil
19963}
19964
19965func DecodeOxmIdCtState(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtState, error) {
19966 _oxmidctstate := &OxmIdCtState{OxmId: parent}
19967 return _oxmidctstate, nil
19968}
19969
19970func NewOxmIdCtState() *OxmIdCtState {
19971 obj := &OxmIdCtState{
19972 OxmId: NewOxmId(119300),
19973 }
19974 return obj
19975}
19976func (self *OxmIdCtState) GetOXMName() string {
19977 return "ct_state"
19978}
19979
19980func (self *OxmIdCtState) MarshalJSON() ([]byte, error) {
19981 if self.TypeLen == 0 {
19982 return []byte("\"\""), nil
19983 } else {
19984 return []byte("\"" + self.GetOXMName() + "\""), nil
19985 }
19986}
19987
19988type OxmIdCtStateMasked struct {
19989 *OxmId
19990}
19991
19992type IOxmIdCtStateMasked interface {
19993 IOxmId
19994}
19995
19996func (self *OxmIdCtStateMasked) Serialize(encoder *goloxi.Encoder) error {
19997 if err := self.OxmId.Serialize(encoder); err != nil {
19998 return err
19999 }
20000
20001 return nil
20002}
20003
20004func DecodeOxmIdCtStateMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtStateMasked, error) {
20005 _oxmidctstatemasked := &OxmIdCtStateMasked{OxmId: parent}
20006 return _oxmidctstatemasked, nil
20007}
20008
20009func NewOxmIdCtStateMasked() *OxmIdCtStateMasked {
20010 obj := &OxmIdCtStateMasked{
20011 OxmId: NewOxmId(119560),
20012 }
20013 return obj
20014}
20015func (self *OxmIdCtStateMasked) GetOXMName() string {
20016 return "ct_state_masked"
20017}
20018
20019func (self *OxmIdCtStateMasked) MarshalJSON() ([]byte, error) {
20020 if self.TypeLen == 0 {
20021 return []byte("\"\""), nil
20022 } else {
20023 return []byte("\"" + self.GetOXMName() + "\""), nil
20024 }
20025}
20026
20027type OxmIdCtTpDst struct {
20028 *OxmId
20029}
20030
20031type IOxmIdCtTpDst interface {
20032 IOxmId
20033}
20034
20035func (self *OxmIdCtTpDst) Serialize(encoder *goloxi.Encoder) error {
20036 if err := self.OxmId.Serialize(encoder); err != nil {
20037 return err
20038 }
20039
20040 return nil
20041}
20042
20043func DecodeOxmIdCtTpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpDst, error) {
20044 _oxmidcttpdst := &OxmIdCtTpDst{OxmId: parent}
20045 return _oxmidcttpdst, nil
20046}
20047
20048func NewOxmIdCtTpDst() *OxmIdCtTpDst {
20049 obj := &OxmIdCtTpDst{
20050 OxmId: NewOxmId(129538),
20051 }
20052 return obj
20053}
20054func (self *OxmIdCtTpDst) GetOXMName() string {
20055 return "ct_tp_dst"
20056}
20057
20058func (self *OxmIdCtTpDst) MarshalJSON() ([]byte, error) {
20059 if self.TypeLen == 0 {
20060 return []byte("\"\""), nil
20061 } else {
20062 return []byte("\"" + self.GetOXMName() + "\""), nil
20063 }
20064}
20065
20066type OxmIdCtTpDstMasked struct {
20067 *OxmId
20068}
20069
20070type IOxmIdCtTpDstMasked interface {
20071 IOxmId
20072}
20073
20074func (self *OxmIdCtTpDstMasked) Serialize(encoder *goloxi.Encoder) error {
20075 if err := self.OxmId.Serialize(encoder); err != nil {
20076 return err
20077 }
20078
20079 return nil
20080}
20081
20082func DecodeOxmIdCtTpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpDstMasked, error) {
20083 _oxmidcttpdstmasked := &OxmIdCtTpDstMasked{OxmId: parent}
20084 return _oxmidcttpdstmasked, nil
20085}
20086
20087func NewOxmIdCtTpDstMasked() *OxmIdCtTpDstMasked {
20088 obj := &OxmIdCtTpDstMasked{
20089 OxmId: NewOxmId(129796),
20090 }
20091 return obj
20092}
20093func (self *OxmIdCtTpDstMasked) GetOXMName() string {
20094 return "ct_tp_dst_masked"
20095}
20096
20097func (self *OxmIdCtTpDstMasked) MarshalJSON() ([]byte, error) {
20098 if self.TypeLen == 0 {
20099 return []byte("\"\""), nil
20100 } else {
20101 return []byte("\"" + self.GetOXMName() + "\""), nil
20102 }
20103}
20104
20105type OxmIdCtTpSrc struct {
20106 *OxmId
20107}
20108
20109type IOxmIdCtTpSrc interface {
20110 IOxmId
20111}
20112
20113func (self *OxmIdCtTpSrc) Serialize(encoder *goloxi.Encoder) error {
20114 if err := self.OxmId.Serialize(encoder); err != nil {
20115 return err
20116 }
20117
20118 return nil
20119}
20120
20121func DecodeOxmIdCtTpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpSrc, error) {
20122 _oxmidcttpsrc := &OxmIdCtTpSrc{OxmId: parent}
20123 return _oxmidcttpsrc, nil
20124}
20125
20126func NewOxmIdCtTpSrc() *OxmIdCtTpSrc {
20127 obj := &OxmIdCtTpSrc{
20128 OxmId: NewOxmId(129026),
20129 }
20130 return obj
20131}
20132func (self *OxmIdCtTpSrc) GetOXMName() string {
20133 return "ct_tp_src"
20134}
20135
20136func (self *OxmIdCtTpSrc) MarshalJSON() ([]byte, error) {
20137 if self.TypeLen == 0 {
20138 return []byte("\"\""), nil
20139 } else {
20140 return []byte("\"" + self.GetOXMName() + "\""), nil
20141 }
20142}
20143
20144type OxmIdCtTpSrcMasked struct {
20145 *OxmId
20146}
20147
20148type IOxmIdCtTpSrcMasked interface {
20149 IOxmId
20150}
20151
20152func (self *OxmIdCtTpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
20153 if err := self.OxmId.Serialize(encoder); err != nil {
20154 return err
20155 }
20156
20157 return nil
20158}
20159
20160func DecodeOxmIdCtTpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpSrcMasked, error) {
20161 _oxmidcttpsrcmasked := &OxmIdCtTpSrcMasked{OxmId: parent}
20162 return _oxmidcttpsrcmasked, nil
20163}
20164
20165func NewOxmIdCtTpSrcMasked() *OxmIdCtTpSrcMasked {
20166 obj := &OxmIdCtTpSrcMasked{
20167 OxmId: NewOxmId(129284),
20168 }
20169 return obj
20170}
20171func (self *OxmIdCtTpSrcMasked) GetOXMName() string {
20172 return "ct_tp_src_masked"
20173}
20174
20175func (self *OxmIdCtTpSrcMasked) MarshalJSON() ([]byte, error) {
20176 if self.TypeLen == 0 {
20177 return []byte("\"\""), nil
20178 } else {
20179 return []byte("\"" + self.GetOXMName() + "\""), nil
20180 }
20181}
20182
20183type OxmIdCtZone struct {
20184 *OxmId
20185}
20186
20187type IOxmIdCtZone interface {
20188 IOxmId
20189}
20190
20191func (self *OxmIdCtZone) Serialize(encoder *goloxi.Encoder) error {
20192 if err := self.OxmId.Serialize(encoder); err != nil {
20193 return err
20194 }
20195
20196 return nil
20197}
20198
20199func DecodeOxmIdCtZone(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtZone, error) {
20200 _oxmidctzone := &OxmIdCtZone{OxmId: parent}
20201 return _oxmidctzone, nil
20202}
20203
20204func NewOxmIdCtZone() *OxmIdCtZone {
20205 obj := &OxmIdCtZone{
20206 OxmId: NewOxmId(119810),
20207 }
20208 return obj
20209}
20210func (self *OxmIdCtZone) GetOXMName() string {
20211 return "ct_zone"
20212}
20213
20214func (self *OxmIdCtZone) MarshalJSON() ([]byte, error) {
20215 if self.TypeLen == 0 {
20216 return []byte("\"\""), nil
20217 } else {
20218 return []byte("\"" + self.GetOXMName() + "\""), nil
20219 }
20220}
20221
20222type OxmIdDpHash struct {
20223 *OxmId
20224}
20225
20226type IOxmIdDpHash interface {
20227 IOxmId
20228}
20229
20230func (self *OxmIdDpHash) Serialize(encoder *goloxi.Encoder) error {
20231 if err := self.OxmId.Serialize(encoder); err != nil {
20232 return err
20233 }
20234
20235 return nil
20236}
20237
20238func DecodeOxmIdDpHash(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdDpHash, error) {
20239 _oxmiddphash := &OxmIdDpHash{OxmId: parent}
20240 return _oxmiddphash, nil
20241}
20242
20243func NewOxmIdDpHash() *OxmIdDpHash {
20244 obj := &OxmIdDpHash{
20245 OxmId: NewOxmId(83460),
20246 }
20247 return obj
20248}
20249func (self *OxmIdDpHash) GetOXMName() string {
20250 return "dp_hash"
20251}
20252
20253func (self *OxmIdDpHash) MarshalJSON() ([]byte, error) {
20254 if self.TypeLen == 0 {
20255 return []byte("\"\""), nil
20256 } else {
20257 return []byte("\"" + self.GetOXMName() + "\""), nil
20258 }
20259}
20260
20261type OxmIdDpHashMasked struct {
20262 *OxmId
20263}
20264
20265type IOxmIdDpHashMasked interface {
20266 IOxmId
20267}
20268
20269func (self *OxmIdDpHashMasked) Serialize(encoder *goloxi.Encoder) error {
20270 if err := self.OxmId.Serialize(encoder); err != nil {
20271 return err
20272 }
20273
20274 return nil
20275}
20276
20277func DecodeOxmIdDpHashMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdDpHashMasked, error) {
20278 _oxmiddphashmasked := &OxmIdDpHashMasked{OxmId: parent}
20279 return _oxmiddphashmasked, nil
20280}
20281
20282func NewOxmIdDpHashMasked() *OxmIdDpHashMasked {
20283 obj := &OxmIdDpHashMasked{
20284 OxmId: NewOxmId(83720),
20285 }
20286 return obj
20287}
20288func (self *OxmIdDpHashMasked) GetOXMName() string {
20289 return "dp_hash_masked"
20290}
20291
20292func (self *OxmIdDpHashMasked) MarshalJSON() ([]byte, error) {
20293 if self.TypeLen == 0 {
20294 return []byte("\"\""), nil
20295 } else {
20296 return []byte("\"" + self.GetOXMName() + "\""), nil
20297 }
20298}
20299
20300type OxmIdEthDst struct {
20301 *OxmId
20302}
20303
20304type IOxmIdEthDst interface {
20305 IOxmId
20306}
20307
20308func (self *OxmIdEthDst) Serialize(encoder *goloxi.Encoder) error {
20309 if err := self.OxmId.Serialize(encoder); err != nil {
20310 return err
20311 }
20312
20313 return nil
20314}
20315
20316func DecodeOxmIdEthDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthDst, error) {
20317 _oxmidethdst := &OxmIdEthDst{OxmId: parent}
20318 return _oxmidethdst, nil
20319}
20320
20321func NewOxmIdEthDst() *OxmIdEthDst {
20322 obj := &OxmIdEthDst{
20323 OxmId: NewOxmId(518),
20324 }
20325 return obj
20326}
20327func (self *OxmIdEthDst) GetOXMName() string {
20328 return "eth_dst"
20329}
20330
20331func (self *OxmIdEthDst) MarshalJSON() ([]byte, error) {
20332 if self.TypeLen == 0 {
20333 return []byte("\"\""), nil
20334 } else {
20335 return []byte("\"" + self.GetOXMName() + "\""), nil
20336 }
20337}
20338
20339type OxmIdEthDstMasked struct {
20340 *OxmId
20341}
20342
20343type IOxmIdEthDstMasked interface {
20344 IOxmId
20345}
20346
20347func (self *OxmIdEthDstMasked) Serialize(encoder *goloxi.Encoder) error {
20348 if err := self.OxmId.Serialize(encoder); err != nil {
20349 return err
20350 }
20351
20352 return nil
20353}
20354
20355func DecodeOxmIdEthDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthDstMasked, error) {
20356 _oxmidethdstmasked := &OxmIdEthDstMasked{OxmId: parent}
20357 return _oxmidethdstmasked, nil
20358}
20359
20360func NewOxmIdEthDstMasked() *OxmIdEthDstMasked {
20361 obj := &OxmIdEthDstMasked{
20362 OxmId: NewOxmId(779),
20363 }
20364 return obj
20365}
20366func (self *OxmIdEthDstMasked) GetOXMName() string {
20367 return "eth_dst_masked"
20368}
20369
20370func (self *OxmIdEthDstMasked) MarshalJSON() ([]byte, error) {
20371 if self.TypeLen == 0 {
20372 return []byte("\"\""), nil
20373 } else {
20374 return []byte("\"" + self.GetOXMName() + "\""), nil
20375 }
20376}
20377
20378type OxmIdEthSrc struct {
20379 *OxmId
20380}
20381
20382type IOxmIdEthSrc interface {
20383 IOxmId
20384}
20385
20386func (self *OxmIdEthSrc) Serialize(encoder *goloxi.Encoder) error {
20387 if err := self.OxmId.Serialize(encoder); err != nil {
20388 return err
20389 }
20390
20391 return nil
20392}
20393
20394func DecodeOxmIdEthSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthSrc, error) {
20395 _oxmidethsrc := &OxmIdEthSrc{OxmId: parent}
20396 return _oxmidethsrc, nil
20397}
20398
20399func NewOxmIdEthSrc() *OxmIdEthSrc {
20400 obj := &OxmIdEthSrc{
20401 OxmId: NewOxmId(1030),
20402 }
20403 return obj
20404}
20405func (self *OxmIdEthSrc) GetOXMName() string {
20406 return "eth_src"
20407}
20408
20409func (self *OxmIdEthSrc) MarshalJSON() ([]byte, error) {
20410 if self.TypeLen == 0 {
20411 return []byte("\"\""), nil
20412 } else {
20413 return []byte("\"" + self.GetOXMName() + "\""), nil
20414 }
20415}
20416
20417type OxmIdEthSrcMasked struct {
20418 *OxmId
20419}
20420
20421type IOxmIdEthSrcMasked interface {
20422 IOxmId
20423}
20424
20425func (self *OxmIdEthSrcMasked) Serialize(encoder *goloxi.Encoder) error {
20426 if err := self.OxmId.Serialize(encoder); err != nil {
20427 return err
20428 }
20429
20430 return nil
20431}
20432
20433func DecodeOxmIdEthSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthSrcMasked, error) {
20434 _oxmidethsrcmasked := &OxmIdEthSrcMasked{OxmId: parent}
20435 return _oxmidethsrcmasked, nil
20436}
20437
20438func NewOxmIdEthSrcMasked() *OxmIdEthSrcMasked {
20439 obj := &OxmIdEthSrcMasked{
20440 OxmId: NewOxmId(1286),
20441 }
20442 return obj
20443}
20444func (self *OxmIdEthSrcMasked) GetOXMName() string {
20445 return "eth_src_masked"
20446}
20447
20448func (self *OxmIdEthSrcMasked) MarshalJSON() ([]byte, error) {
20449 if self.TypeLen == 0 {
20450 return []byte("\"\""), nil
20451 } else {
20452 return []byte("\"" + self.GetOXMName() + "\""), nil
20453 }
20454}
20455
20456type OxmIdEthType struct {
20457 *OxmId
20458}
20459
20460type IOxmIdEthType interface {
20461 IOxmId
20462}
20463
20464func (self *OxmIdEthType) Serialize(encoder *goloxi.Encoder) error {
20465 if err := self.OxmId.Serialize(encoder); err != nil {
20466 return err
20467 }
20468
20469 return nil
20470}
20471
20472func DecodeOxmIdEthType(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthType, error) {
20473 _oxmidethtype := &OxmIdEthType{OxmId: parent}
20474 return _oxmidethtype, nil
20475}
20476
20477func NewOxmIdEthType() *OxmIdEthType {
20478 obj := &OxmIdEthType{
20479 OxmId: NewOxmId(1538),
20480 }
20481 return obj
20482}
20483func (self *OxmIdEthType) GetOXMName() string {
20484 return "eth_type"
20485}
20486
20487func (self *OxmIdEthType) MarshalJSON() ([]byte, error) {
20488 if self.TypeLen == 0 {
20489 return []byte("\"\""), nil
20490 } else {
20491 return []byte("\"" + self.GetOXMName() + "\""), nil
20492 }
20493}
20494
20495type OxmIdIcmpCode struct {
20496 *OxmId
20497}
20498
20499type IOxmIdIcmpCode interface {
20500 IOxmId
20501}
20502
20503func (self *OxmIdIcmpCode) Serialize(encoder *goloxi.Encoder) error {
20504 if err := self.OxmId.Serialize(encoder); err != nil {
20505 return err
20506 }
20507
20508 return nil
20509}
20510
20511func DecodeOxmIdIcmpCode(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpCode, error) {
20512 _oxmidicmpcode := &OxmIdIcmpCode{OxmId: parent}
20513 return _oxmidicmpcode, nil
20514}
20515
20516func NewOxmIdIcmpCode() *OxmIdIcmpCode {
20517 obj := &OxmIdIcmpCode{
20518 OxmId: NewOxmId(7169),
20519 }
20520 return obj
20521}
20522func (self *OxmIdIcmpCode) GetOXMName() string {
20523 return "icmp_code"
20524}
20525
20526func (self *OxmIdIcmpCode) MarshalJSON() ([]byte, error) {
20527 if self.TypeLen == 0 {
20528 return []byte("\"\""), nil
20529 } else {
20530 return []byte("\"" + self.GetOXMName() + "\""), nil
20531 }
20532}
20533
20534type OxmIdIcmpType struct {
20535 *OxmId
20536}
20537
20538type IOxmIdIcmpType interface {
20539 IOxmId
20540}
20541
20542func (self *OxmIdIcmpType) Serialize(encoder *goloxi.Encoder) error {
20543 if err := self.OxmId.Serialize(encoder); err != nil {
20544 return err
20545 }
20546
20547 return nil
20548}
20549
20550func DecodeOxmIdIcmpType(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpType, error) {
20551 _oxmidicmptype := &OxmIdIcmpType{OxmId: parent}
20552 return _oxmidicmptype, nil
20553}
20554
20555func NewOxmIdIcmpType() *OxmIdIcmpType {
20556 obj := &OxmIdIcmpType{
20557 OxmId: NewOxmId(6657),
20558 }
20559 return obj
20560}
20561func (self *OxmIdIcmpType) GetOXMName() string {
20562 return "icmp_type"
20563}
20564
20565func (self *OxmIdIcmpType) MarshalJSON() ([]byte, error) {
20566 if self.TypeLen == 0 {
20567 return []byte("\"\""), nil
20568 } else {
20569 return []byte("\"" + self.GetOXMName() + "\""), nil
20570 }
20571}
20572
20573type OxmIdIcmpv6Code struct {
20574 *OxmId
20575}
20576
20577type IOxmIdIcmpv6Code interface {
20578 IOxmId
20579}
20580
20581func (self *OxmIdIcmpv6Code) Serialize(encoder *goloxi.Encoder) error {
20582 if err := self.OxmId.Serialize(encoder); err != nil {
20583 return err
20584 }
20585
20586 return nil
20587}
20588
20589func DecodeOxmIdIcmpv6Code(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6Code, error) {
20590 _oxmidicmpv6code := &OxmIdIcmpv6Code{OxmId: parent}
20591 return _oxmidicmpv6code, nil
20592}
20593
20594func NewOxmIdIcmpv6Code() *OxmIdIcmpv6Code {
20595 obj := &OxmIdIcmpv6Code{
20596 OxmId: NewOxmId(76801),
20597 }
20598 return obj
20599}
20600func (self *OxmIdIcmpv6Code) GetOXMName() string {
20601 return "icmpv6_code"
20602}
20603
20604func (self *OxmIdIcmpv6Code) MarshalJSON() ([]byte, error) {
20605 if self.TypeLen == 0 {
20606 return []byte("\"\""), nil
20607 } else {
20608 return []byte("\"" + self.GetOXMName() + "\""), nil
20609 }
20610}
20611
20612type OxmIdIcmpv6Type struct {
20613 *OxmId
20614}
20615
20616type IOxmIdIcmpv6Type interface {
20617 IOxmId
20618}
20619
20620func (self *OxmIdIcmpv6Type) Serialize(encoder *goloxi.Encoder) error {
20621 if err := self.OxmId.Serialize(encoder); err != nil {
20622 return err
20623 }
20624
20625 return nil
20626}
20627
20628func DecodeOxmIdIcmpv6Type(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6Type, error) {
20629 _oxmidicmpv6type := &OxmIdIcmpv6Type{OxmId: parent}
20630 return _oxmidicmpv6type, nil
20631}
20632
20633func NewOxmIdIcmpv6Type() *OxmIdIcmpv6Type {
20634 obj := &OxmIdIcmpv6Type{
20635 OxmId: NewOxmId(76289),
20636 }
20637 return obj
20638}
20639func (self *OxmIdIcmpv6Type) GetOXMName() string {
20640 return "icmpv6_type"
20641}
20642
20643func (self *OxmIdIcmpv6Type) MarshalJSON() ([]byte, error) {
20644 if self.TypeLen == 0 {
20645 return []byte("\"\""), nil
20646 } else {
20647 return []byte("\"" + self.GetOXMName() + "\""), nil
20648 }
20649}
20650
20651type OxmIdInPort struct {
20652 *OxmId
20653}
20654
20655type IOxmIdInPort interface {
20656 IOxmId
20657}
20658
20659func (self *OxmIdInPort) Serialize(encoder *goloxi.Encoder) error {
20660 if err := self.OxmId.Serialize(encoder); err != nil {
20661 return err
20662 }
20663
20664 return nil
20665}
20666
20667func DecodeOxmIdInPort(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPort, error) {
20668 _oxmidinport := &OxmIdInPort{OxmId: parent}
20669 return _oxmidinport, nil
20670}
20671
20672func NewOxmIdInPort() *OxmIdInPort {
20673 obj := &OxmIdInPort{
20674 OxmId: NewOxmId(2),
20675 }
20676 return obj
20677}
20678func (self *OxmIdInPort) GetOXMName() string {
20679 return "in_port"
20680}
20681
20682func (self *OxmIdInPort) MarshalJSON() ([]byte, error) {
20683 if self.TypeLen == 0 {
20684 return []byte("\"\""), nil
20685 } else {
20686 return []byte("\"" + self.GetOXMName() + "\""), nil
20687 }
20688}
20689
20690type OxmIdIpDst struct {
20691 *OxmId
20692}
20693
20694type IOxmIdIpDst interface {
20695 IOxmId
20696}
20697
20698func (self *OxmIdIpDst) Serialize(encoder *goloxi.Encoder) error {
20699 if err := self.OxmId.Serialize(encoder); err != nil {
20700 return err
20701 }
20702
20703 return nil
20704}
20705
20706func DecodeOxmIdIpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDst, error) {
20707 _oxmidipdst := &OxmIdIpDst{OxmId: parent}
20708 return _oxmidipdst, nil
20709}
20710
20711func NewOxmIdIpDst() *OxmIdIpDst {
20712 obj := &OxmIdIpDst{
20713 OxmId: NewOxmId(4100),
20714 }
20715 return obj
20716}
20717func (self *OxmIdIpDst) GetOXMName() string {
20718 return "ip_dst"
20719}
20720
20721func (self *OxmIdIpDst) MarshalJSON() ([]byte, error) {
20722 if self.TypeLen == 0 {
20723 return []byte("\"\""), nil
20724 } else {
20725 return []byte("\"" + self.GetOXMName() + "\""), nil
20726 }
20727}
20728
20729type OxmIdIpDstMasked struct {
20730 *OxmId
20731}
20732
20733type IOxmIdIpDstMasked interface {
20734 IOxmId
20735}
20736
20737func (self *OxmIdIpDstMasked) Serialize(encoder *goloxi.Encoder) error {
20738 if err := self.OxmId.Serialize(encoder); err != nil {
20739 return err
20740 }
20741
20742 return nil
20743}
20744
20745func DecodeOxmIdIpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDstMasked, error) {
20746 _oxmidipdstmasked := &OxmIdIpDstMasked{OxmId: parent}
20747 return _oxmidipdstmasked, nil
20748}
20749
20750func NewOxmIdIpDstMasked() *OxmIdIpDstMasked {
20751 obj := &OxmIdIpDstMasked{
20752 OxmId: NewOxmId(4360),
20753 }
20754 return obj
20755}
20756func (self *OxmIdIpDstMasked) GetOXMName() string {
20757 return "ip_dst_masked"
20758}
20759
20760func (self *OxmIdIpDstMasked) MarshalJSON() ([]byte, error) {
20761 if self.TypeLen == 0 {
20762 return []byte("\"\""), nil
20763 } else {
20764 return []byte("\"" + self.GetOXMName() + "\""), nil
20765 }
20766}
20767
20768type OxmIdIpFrag struct {
20769 *OxmId
20770}
20771
20772type IOxmIdIpFrag interface {
20773 IOxmId
20774}
20775
20776func (self *OxmIdIpFrag) Serialize(encoder *goloxi.Encoder) error {
20777 if err := self.OxmId.Serialize(encoder); err != nil {
20778 return err
20779 }
20780
20781 return nil
20782}
20783
20784func DecodeOxmIdIpFrag(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpFrag, error) {
20785 _oxmidipfrag := &OxmIdIpFrag{OxmId: parent}
20786 return _oxmidipfrag, nil
20787}
20788
20789func NewOxmIdIpFrag() *OxmIdIpFrag {
20790 obj := &OxmIdIpFrag{
20791 OxmId: NewOxmId(78849),
20792 }
20793 return obj
20794}
20795func (self *OxmIdIpFrag) GetOXMName() string {
20796 return "ip_frag"
20797}
20798
20799func (self *OxmIdIpFrag) MarshalJSON() ([]byte, error) {
20800 if self.TypeLen == 0 {
20801 return []byte("\"\""), nil
20802 } else {
20803 return []byte("\"" + self.GetOXMName() + "\""), nil
20804 }
20805}
20806
20807type OxmIdIpFragMasked struct {
20808 *OxmId
20809}
20810
20811type IOxmIdIpFragMasked interface {
20812 IOxmId
20813}
20814
20815func (self *OxmIdIpFragMasked) Serialize(encoder *goloxi.Encoder) error {
20816 if err := self.OxmId.Serialize(encoder); err != nil {
20817 return err
20818 }
20819
20820 return nil
20821}
20822
20823func DecodeOxmIdIpFragMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpFragMasked, error) {
20824 _oxmidipfragmasked := &OxmIdIpFragMasked{OxmId: parent}
20825 return _oxmidipfragmasked, nil
20826}
20827
20828func NewOxmIdIpFragMasked() *OxmIdIpFragMasked {
20829 obj := &OxmIdIpFragMasked{
20830 OxmId: NewOxmId(79106),
20831 }
20832 return obj
20833}
20834func (self *OxmIdIpFragMasked) GetOXMName() string {
20835 return "ip_frag_masked"
20836}
20837
20838func (self *OxmIdIpFragMasked) MarshalJSON() ([]byte, error) {
20839 if self.TypeLen == 0 {
20840 return []byte("\"\""), nil
20841 } else {
20842 return []byte("\"" + self.GetOXMName() + "\""), nil
20843 }
20844}
20845
20846type OxmIdIpSrc struct {
20847 *OxmId
20848}
20849
20850type IOxmIdIpSrc interface {
20851 IOxmId
20852}
20853
20854func (self *OxmIdIpSrc) Serialize(encoder *goloxi.Encoder) error {
20855 if err := self.OxmId.Serialize(encoder); err != nil {
20856 return err
20857 }
20858
20859 return nil
20860}
20861
20862func DecodeOxmIdIpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpSrc, error) {
20863 _oxmidipsrc := &OxmIdIpSrc{OxmId: parent}
20864 return _oxmidipsrc, nil
20865}
20866
20867func NewOxmIdIpSrc() *OxmIdIpSrc {
20868 obj := &OxmIdIpSrc{
20869 OxmId: NewOxmId(3588),
20870 }
20871 return obj
20872}
20873func (self *OxmIdIpSrc) GetOXMName() string {
20874 return "ip_src"
20875}
20876
20877func (self *OxmIdIpSrc) MarshalJSON() ([]byte, error) {
20878 if self.TypeLen == 0 {
20879 return []byte("\"\""), nil
20880 } else {
20881 return []byte("\"" + self.GetOXMName() + "\""), nil
20882 }
20883}
20884
20885type OxmIdIpSrcMasked struct {
20886 *OxmId
20887}
20888
20889type IOxmIdIpSrcMasked interface {
20890 IOxmId
20891}
20892
20893func (self *OxmIdIpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
20894 if err := self.OxmId.Serialize(encoder); err != nil {
20895 return err
20896 }
20897
20898 return nil
20899}
20900
20901func DecodeOxmIdIpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpSrcMasked, error) {
20902 _oxmidipsrcmasked := &OxmIdIpSrcMasked{OxmId: parent}
20903 return _oxmidipsrcmasked, nil
20904}
20905
20906func NewOxmIdIpSrcMasked() *OxmIdIpSrcMasked {
20907 obj := &OxmIdIpSrcMasked{
20908 OxmId: NewOxmId(3848),
20909 }
20910 return obj
20911}
20912func (self *OxmIdIpSrcMasked) GetOXMName() string {
20913 return "ip_src_masked"
20914}
20915
20916func (self *OxmIdIpSrcMasked) MarshalJSON() ([]byte, error) {
20917 if self.TypeLen == 0 {
20918 return []byte("\"\""), nil
20919 } else {
20920 return []byte("\"" + self.GetOXMName() + "\""), nil
20921 }
20922}
20923
20924type OxmIdIpv6Dst struct {
20925 *OxmId
20926}
20927
20928type IOxmIdIpv6Dst interface {
20929 IOxmId
20930}
20931
20932func (self *OxmIdIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
20933 if err := self.OxmId.Serialize(encoder); err != nil {
20934 return err
20935 }
20936
20937 return nil
20938}
20939
20940func DecodeOxmIdIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Dst, error) {
20941 _oxmidipv6dst := &OxmIdIpv6Dst{OxmId: parent}
20942 return _oxmidipv6dst, nil
20943}
20944
20945func NewOxmIdIpv6Dst() *OxmIdIpv6Dst {
20946 obj := &OxmIdIpv6Dst{
20947 OxmId: NewOxmId(75792),
20948 }
20949 return obj
20950}
20951func (self *OxmIdIpv6Dst) GetOXMName() string {
20952 return "ipv6_dst"
20953}
20954
20955func (self *OxmIdIpv6Dst) MarshalJSON() ([]byte, error) {
20956 if self.TypeLen == 0 {
20957 return []byte("\"\""), nil
20958 } else {
20959 return []byte("\"" + self.GetOXMName() + "\""), nil
20960 }
20961}
20962
20963type OxmIdIpv6DstMasked struct {
20964 *OxmId
20965}
20966
20967type IOxmIdIpv6DstMasked interface {
20968 IOxmId
20969}
20970
20971func (self *OxmIdIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
20972 if err := self.OxmId.Serialize(encoder); err != nil {
20973 return err
20974 }
20975
20976 return nil
20977}
20978
20979func DecodeOxmIdIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6DstMasked, error) {
20980 _oxmidipv6dstmasked := &OxmIdIpv6DstMasked{OxmId: parent}
20981 return _oxmidipv6dstmasked, nil
20982}
20983
20984func NewOxmIdIpv6DstMasked() *OxmIdIpv6DstMasked {
20985 obj := &OxmIdIpv6DstMasked{
20986 OxmId: NewOxmId(76064),
20987 }
20988 return obj
20989}
20990func (self *OxmIdIpv6DstMasked) GetOXMName() string {
20991 return "ipv6_dst_masked"
20992}
20993
20994func (self *OxmIdIpv6DstMasked) MarshalJSON() ([]byte, error) {
20995 if self.TypeLen == 0 {
20996 return []byte("\"\""), nil
20997 } else {
20998 return []byte("\"" + self.GetOXMName() + "\""), nil
20999 }
21000}
21001
21002type OxmIdIpv6Label struct {
21003 *OxmId
21004}
21005
21006type IOxmIdIpv6Label interface {
21007 IOxmId
21008}
21009
21010func (self *OxmIdIpv6Label) Serialize(encoder *goloxi.Encoder) error {
21011 if err := self.OxmId.Serialize(encoder); err != nil {
21012 return err
21013 }
21014
21015 return nil
21016}
21017
21018func DecodeOxmIdIpv6Label(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Label, error) {
21019 _oxmidipv6label := &OxmIdIpv6Label{OxmId: parent}
21020 return _oxmidipv6label, nil
21021}
21022
21023func NewOxmIdIpv6Label() *OxmIdIpv6Label {
21024 obj := &OxmIdIpv6Label{
21025 OxmId: NewOxmId(79364),
21026 }
21027 return obj
21028}
21029func (self *OxmIdIpv6Label) GetOXMName() string {
21030 return "ipv6_label"
21031}
21032
21033func (self *OxmIdIpv6Label) MarshalJSON() ([]byte, error) {
21034 if self.TypeLen == 0 {
21035 return []byte("\"\""), nil
21036 } else {
21037 return []byte("\"" + self.GetOXMName() + "\""), nil
21038 }
21039}
21040
21041type OxmIdIpv6LabelMasked struct {
21042 *OxmId
21043}
21044
21045type IOxmIdIpv6LabelMasked interface {
21046 IOxmId
21047}
21048
21049func (self *OxmIdIpv6LabelMasked) Serialize(encoder *goloxi.Encoder) error {
21050 if err := self.OxmId.Serialize(encoder); err != nil {
21051 return err
21052 }
21053
21054 return nil
21055}
21056
21057func DecodeOxmIdIpv6LabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6LabelMasked, error) {
21058 _oxmidipv6labelmasked := &OxmIdIpv6LabelMasked{OxmId: parent}
21059 return _oxmidipv6labelmasked, nil
21060}
21061
21062func NewOxmIdIpv6LabelMasked() *OxmIdIpv6LabelMasked {
21063 obj := &OxmIdIpv6LabelMasked{
21064 OxmId: NewOxmId(79624),
21065 }
21066 return obj
21067}
21068func (self *OxmIdIpv6LabelMasked) GetOXMName() string {
21069 return "ipv6_label_masked"
21070}
21071
21072func (self *OxmIdIpv6LabelMasked) MarshalJSON() ([]byte, error) {
21073 if self.TypeLen == 0 {
21074 return []byte("\"\""), nil
21075 } else {
21076 return []byte("\"" + self.GetOXMName() + "\""), nil
21077 }
21078}
21079
21080type OxmIdIpv6Src struct {
21081 *OxmId
21082}
21083
21084type IOxmIdIpv6Src interface {
21085 IOxmId
21086}
21087
21088func (self *OxmIdIpv6Src) Serialize(encoder *goloxi.Encoder) error {
21089 if err := self.OxmId.Serialize(encoder); err != nil {
21090 return err
21091 }
21092
21093 return nil
21094}
21095
21096func DecodeOxmIdIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Src, error) {
21097 _oxmidipv6src := &OxmIdIpv6Src{OxmId: parent}
21098 return _oxmidipv6src, nil
21099}
21100
21101func NewOxmIdIpv6Src() *OxmIdIpv6Src {
21102 obj := &OxmIdIpv6Src{
21103 OxmId: NewOxmId(75280),
21104 }
21105 return obj
21106}
21107func (self *OxmIdIpv6Src) GetOXMName() string {
21108 return "ipv6_src"
21109}
21110
21111func (self *OxmIdIpv6Src) MarshalJSON() ([]byte, error) {
21112 if self.TypeLen == 0 {
21113 return []byte("\"\""), nil
21114 } else {
21115 return []byte("\"" + self.GetOXMName() + "\""), nil
21116 }
21117}
21118
21119type OxmIdIpv6SrcMasked struct {
21120 *OxmId
21121}
21122
21123type IOxmIdIpv6SrcMasked interface {
21124 IOxmId
21125}
21126
21127func (self *OxmIdIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
21128 if err := self.OxmId.Serialize(encoder); err != nil {
21129 return err
21130 }
21131
21132 return nil
21133}
21134
21135func DecodeOxmIdIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6SrcMasked, error) {
21136 _oxmidipv6srcmasked := &OxmIdIpv6SrcMasked{OxmId: parent}
21137 return _oxmidipv6srcmasked, nil
21138}
21139
21140func NewOxmIdIpv6SrcMasked() *OxmIdIpv6SrcMasked {
21141 obj := &OxmIdIpv6SrcMasked{
21142 OxmId: NewOxmId(75552),
21143 }
21144 return obj
21145}
21146func (self *OxmIdIpv6SrcMasked) GetOXMName() string {
21147 return "ipv6_src_masked"
21148}
21149
21150func (self *OxmIdIpv6SrcMasked) MarshalJSON() ([]byte, error) {
21151 if self.TypeLen == 0 {
21152 return []byte("\"\""), nil
21153 } else {
21154 return []byte("\"" + self.GetOXMName() + "\""), nil
21155 }
21156}
21157
21158type OxmIdMplsTtl struct {
21159 *OxmId
21160}
21161
21162type IOxmIdMplsTtl interface {
21163 IOxmId
21164}
21165
21166func (self *OxmIdMplsTtl) Serialize(encoder *goloxi.Encoder) error {
21167 if err := self.OxmId.Serialize(encoder); err != nil {
21168 return err
21169 }
21170
21171 return nil
21172}
21173
21174func DecodeOxmIdMplsTtl(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsTtl, error) {
21175 _oxmidmplsttl := &OxmIdMplsTtl{OxmId: parent}
21176 return _oxmidmplsttl, nil
21177}
21178
21179func NewOxmIdMplsTtl() *OxmIdMplsTtl {
21180 obj := &OxmIdMplsTtl{
21181 OxmId: NewOxmId(80897),
21182 }
21183 return obj
21184}
21185func (self *OxmIdMplsTtl) GetOXMName() string {
21186 return "mpls_ttl"
21187}
21188
21189func (self *OxmIdMplsTtl) MarshalJSON() ([]byte, error) {
21190 if self.TypeLen == 0 {
21191 return []byte("\"\""), nil
21192 } else {
21193 return []byte("\"" + self.GetOXMName() + "\""), nil
21194 }
21195}
21196
21197type OxmIdNdSll struct {
21198 *OxmId
21199}
21200
21201type IOxmIdNdSll interface {
21202 IOxmId
21203}
21204
21205func (self *OxmIdNdSll) Serialize(encoder *goloxi.Encoder) error {
21206 if err := self.OxmId.Serialize(encoder); err != nil {
21207 return err
21208 }
21209
21210 return nil
21211}
21212
21213func DecodeOxmIdNdSll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdSll, error) {
21214 _oxmidndsll := &OxmIdNdSll{OxmId: parent}
21215 return _oxmidndsll, nil
21216}
21217
21218func NewOxmIdNdSll() *OxmIdNdSll {
21219 obj := &OxmIdNdSll{
21220 OxmId: NewOxmId(77830),
21221 }
21222 return obj
21223}
21224func (self *OxmIdNdSll) GetOXMName() string {
21225 return "nd_sll"
21226}
21227
21228func (self *OxmIdNdSll) MarshalJSON() ([]byte, error) {
21229 if self.TypeLen == 0 {
21230 return []byte("\"\""), nil
21231 } else {
21232 return []byte("\"" + self.GetOXMName() + "\""), nil
21233 }
21234}
21235
21236type OxmIdNdSllMasked struct {
21237 *OxmId
21238}
21239
21240type IOxmIdNdSllMasked interface {
21241 IOxmId
21242}
21243
21244func (self *OxmIdNdSllMasked) Serialize(encoder *goloxi.Encoder) error {
21245 if err := self.OxmId.Serialize(encoder); err != nil {
21246 return err
21247 }
21248
21249 return nil
21250}
21251
21252func DecodeOxmIdNdSllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdSllMasked, error) {
21253 _oxmidndsllmasked := &OxmIdNdSllMasked{OxmId: parent}
21254 return _oxmidndsllmasked, nil
21255}
21256
21257func NewOxmIdNdSllMasked() *OxmIdNdSllMasked {
21258 obj := &OxmIdNdSllMasked{
21259 OxmId: NewOxmId(78091),
21260 }
21261 return obj
21262}
21263func (self *OxmIdNdSllMasked) GetOXMName() string {
21264 return "nd_sll_masked"
21265}
21266
21267func (self *OxmIdNdSllMasked) MarshalJSON() ([]byte, error) {
21268 if self.TypeLen == 0 {
21269 return []byte("\"\""), nil
21270 } else {
21271 return []byte("\"" + self.GetOXMName() + "\""), nil
21272 }
21273}
21274
21275type OxmIdNdTarget struct {
21276 *OxmId
21277}
21278
21279type IOxmIdNdTarget interface {
21280 IOxmId
21281}
21282
21283func (self *OxmIdNdTarget) Serialize(encoder *goloxi.Encoder) error {
21284 if err := self.OxmId.Serialize(encoder); err != nil {
21285 return err
21286 }
21287
21288 return nil
21289}
21290
21291func DecodeOxmIdNdTarget(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTarget, error) {
21292 _oxmidndtarget := &OxmIdNdTarget{OxmId: parent}
21293 return _oxmidndtarget, nil
21294}
21295
21296func NewOxmIdNdTarget() *OxmIdNdTarget {
21297 obj := &OxmIdNdTarget{
21298 OxmId: NewOxmId(77328),
21299 }
21300 return obj
21301}
21302func (self *OxmIdNdTarget) GetOXMName() string {
21303 return "nd_target"
21304}
21305
21306func (self *OxmIdNdTarget) MarshalJSON() ([]byte, error) {
21307 if self.TypeLen == 0 {
21308 return []byte("\"\""), nil
21309 } else {
21310 return []byte("\"" + self.GetOXMName() + "\""), nil
21311 }
21312}
21313
21314type OxmIdNdTargetMasked struct {
21315 *OxmId
21316}
21317
21318type IOxmIdNdTargetMasked interface {
21319 IOxmId
21320}
21321
21322func (self *OxmIdNdTargetMasked) Serialize(encoder *goloxi.Encoder) error {
21323 if err := self.OxmId.Serialize(encoder); err != nil {
21324 return err
21325 }
21326
21327 return nil
21328}
21329
21330func DecodeOxmIdNdTargetMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTargetMasked, error) {
21331 _oxmidndtargetmasked := &OxmIdNdTargetMasked{OxmId: parent}
21332 return _oxmidndtargetmasked, nil
21333}
21334
21335func NewOxmIdNdTargetMasked() *OxmIdNdTargetMasked {
21336 obj := &OxmIdNdTargetMasked{
21337 OxmId: NewOxmId(77600),
21338 }
21339 return obj
21340}
21341func (self *OxmIdNdTargetMasked) GetOXMName() string {
21342 return "nd_target_masked"
21343}
21344
21345func (self *OxmIdNdTargetMasked) MarshalJSON() ([]byte, error) {
21346 if self.TypeLen == 0 {
21347 return []byte("\"\""), nil
21348 } else {
21349 return []byte("\"" + self.GetOXMName() + "\""), nil
21350 }
21351}
21352
21353type OxmIdNdTll struct {
21354 *OxmId
21355}
21356
21357type IOxmIdNdTll interface {
21358 IOxmId
21359}
21360
21361func (self *OxmIdNdTll) Serialize(encoder *goloxi.Encoder) error {
21362 if err := self.OxmId.Serialize(encoder); err != nil {
21363 return err
21364 }
21365
21366 return nil
21367}
21368
21369func DecodeOxmIdNdTll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTll, error) {
21370 _oxmidndtll := &OxmIdNdTll{OxmId: parent}
21371 return _oxmidndtll, nil
21372}
21373
21374func NewOxmIdNdTll() *OxmIdNdTll {
21375 obj := &OxmIdNdTll{
21376 OxmId: NewOxmId(78342),
21377 }
21378 return obj
21379}
21380func (self *OxmIdNdTll) GetOXMName() string {
21381 return "nd_tll"
21382}
21383
21384func (self *OxmIdNdTll) MarshalJSON() ([]byte, error) {
21385 if self.TypeLen == 0 {
21386 return []byte("\"\""), nil
21387 } else {
21388 return []byte("\"" + self.GetOXMName() + "\""), nil
21389 }
21390}
21391
21392type OxmIdNdTllMasked struct {
21393 *OxmId
21394}
21395
21396type IOxmIdNdTllMasked interface {
21397 IOxmId
21398}
21399
21400func (self *OxmIdNdTllMasked) Serialize(encoder *goloxi.Encoder) error {
21401 if err := self.OxmId.Serialize(encoder); err != nil {
21402 return err
21403 }
21404
21405 return nil
21406}
21407
21408func DecodeOxmIdNdTllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTllMasked, error) {
21409 _oxmidndtllmasked := &OxmIdNdTllMasked{OxmId: parent}
21410 return _oxmidndtllmasked, nil
21411}
21412
21413func NewOxmIdNdTllMasked() *OxmIdNdTllMasked {
21414 obj := &OxmIdNdTllMasked{
21415 OxmId: NewOxmId(78603),
21416 }
21417 return obj
21418}
21419func (self *OxmIdNdTllMasked) GetOXMName() string {
21420 return "nd_tll_masked"
21421}
21422
21423func (self *OxmIdNdTllMasked) MarshalJSON() ([]byte, error) {
21424 if self.TypeLen == 0 {
21425 return []byte("\"\""), nil
21426 } else {
21427 return []byte("\"" + self.GetOXMName() + "\""), nil
21428 }
21429}
21430
21431type OxmIdNwEcn struct {
21432 *OxmId
21433}
21434
21435type IOxmIdNwEcn interface {
21436 IOxmId
21437}
21438
21439func (self *OxmIdNwEcn) Serialize(encoder *goloxi.Encoder) error {
21440 if err := self.OxmId.Serialize(encoder); err != nil {
21441 return err
21442 }
21443
21444 return nil
21445}
21446
21447func DecodeOxmIdNwEcn(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwEcn, error) {
21448 _oxmidnwecn := &OxmIdNwEcn{OxmId: parent}
21449 return _oxmidnwecn, nil
21450}
21451
21452func NewOxmIdNwEcn() *OxmIdNwEcn {
21453 obj := &OxmIdNwEcn{
21454 OxmId: NewOxmId(79873),
21455 }
21456 return obj
21457}
21458func (self *OxmIdNwEcn) GetOXMName() string {
21459 return "nw_ecn"
21460}
21461
21462func (self *OxmIdNwEcn) MarshalJSON() ([]byte, error) {
21463 if self.TypeLen == 0 {
21464 return []byte("\"\""), nil
21465 } else {
21466 return []byte("\"" + self.GetOXMName() + "\""), nil
21467 }
21468}
21469
21470type OxmIdNwProto struct {
21471 *OxmId
21472}
21473
21474type IOxmIdNwProto interface {
21475 IOxmId
21476}
21477
21478func (self *OxmIdNwProto) Serialize(encoder *goloxi.Encoder) error {
21479 if err := self.OxmId.Serialize(encoder); err != nil {
21480 return err
21481 }
21482
21483 return nil
21484}
21485
21486func DecodeOxmIdNwProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwProto, error) {
21487 _oxmidnwproto := &OxmIdNwProto{OxmId: parent}
21488 return _oxmidnwproto, nil
21489}
21490
21491func NewOxmIdNwProto() *OxmIdNwProto {
21492 obj := &OxmIdNwProto{
21493 OxmId: NewOxmId(3073),
21494 }
21495 return obj
21496}
21497func (self *OxmIdNwProto) GetOXMName() string {
21498 return "nw_proto"
21499}
21500
21501func (self *OxmIdNwProto) MarshalJSON() ([]byte, error) {
21502 if self.TypeLen == 0 {
21503 return []byte("\"\""), nil
21504 } else {
21505 return []byte("\"" + self.GetOXMName() + "\""), nil
21506 }
21507}
21508
21509type OxmIdNwTos struct {
21510 *OxmId
21511}
21512
21513type IOxmIdNwTos interface {
21514 IOxmId
21515}
21516
21517func (self *OxmIdNwTos) Serialize(encoder *goloxi.Encoder) error {
21518 if err := self.OxmId.Serialize(encoder); err != nil {
21519 return err
21520 }
21521
21522 return nil
21523}
21524
21525func DecodeOxmIdNwTos(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwTos, error) {
21526 _oxmidnwtos := &OxmIdNwTos{OxmId: parent}
21527 return _oxmidnwtos, nil
21528}
21529
21530func NewOxmIdNwTos() *OxmIdNwTos {
21531 obj := &OxmIdNwTos{
21532 OxmId: NewOxmId(2561),
21533 }
21534 return obj
21535}
21536func (self *OxmIdNwTos) GetOXMName() string {
21537 return "nw_tos"
21538}
21539
21540func (self *OxmIdNwTos) MarshalJSON() ([]byte, error) {
21541 if self.TypeLen == 0 {
21542 return []byte("\"\""), nil
21543 } else {
21544 return []byte("\"" + self.GetOXMName() + "\""), nil
21545 }
21546}
21547
21548type OxmIdNwTtl struct {
21549 *OxmId
21550}
21551
21552type IOxmIdNwTtl interface {
21553 IOxmId
21554}
21555
21556func (self *OxmIdNwTtl) Serialize(encoder *goloxi.Encoder) error {
21557 if err := self.OxmId.Serialize(encoder); err != nil {
21558 return err
21559 }
21560
21561 return nil
21562}
21563
21564func DecodeOxmIdNwTtl(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwTtl, error) {
21565 _oxmidnwttl := &OxmIdNwTtl{OxmId: parent}
21566 return _oxmidnwttl, nil
21567}
21568
21569func NewOxmIdNwTtl() *OxmIdNwTtl {
21570 obj := &OxmIdNwTtl{
21571 OxmId: NewOxmId(80385),
21572 }
21573 return obj
21574}
21575func (self *OxmIdNwTtl) GetOXMName() string {
21576 return "nw_ttl"
21577}
21578
21579func (self *OxmIdNwTtl) MarshalJSON() ([]byte, error) {
21580 if self.TypeLen == 0 {
21581 return []byte("\"\""), nil
21582 } else {
21583 return []byte("\"" + self.GetOXMName() + "\""), nil
21584 }
21585}
21586
21587type OxmIdPktMark struct {
21588 *OxmId
21589}
21590
21591type IOxmIdPktMark interface {
21592 IOxmId
21593}
21594
21595func (self *OxmIdPktMark) Serialize(encoder *goloxi.Encoder) error {
21596 if err := self.OxmId.Serialize(encoder); err != nil {
21597 return err
21598 }
21599
21600 return nil
21601}
21602
21603func DecodeOxmIdPktMark(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdPktMark, error) {
21604 _oxmidpktmark := &OxmIdPktMark{OxmId: parent}
21605 return _oxmidpktmark, nil
21606}
21607
21608func NewOxmIdPktMark() *OxmIdPktMark {
21609 obj := &OxmIdPktMark{
21610 OxmId: NewOxmId(82436),
21611 }
21612 return obj
21613}
21614func (self *OxmIdPktMark) GetOXMName() string {
21615 return "pkt_mark"
21616}
21617
21618func (self *OxmIdPktMark) MarshalJSON() ([]byte, error) {
21619 if self.TypeLen == 0 {
21620 return []byte("\"\""), nil
21621 } else {
21622 return []byte("\"" + self.GetOXMName() + "\""), nil
21623 }
21624}
21625
21626type OxmIdPktMarkMasked struct {
21627 *OxmId
21628}
21629
21630type IOxmIdPktMarkMasked interface {
21631 IOxmId
21632}
21633
21634func (self *OxmIdPktMarkMasked) Serialize(encoder *goloxi.Encoder) error {
21635 if err := self.OxmId.Serialize(encoder); err != nil {
21636 return err
21637 }
21638
21639 return nil
21640}
21641
21642func DecodeOxmIdPktMarkMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdPktMarkMasked, error) {
21643 _oxmidpktmarkmasked := &OxmIdPktMarkMasked{OxmId: parent}
21644 return _oxmidpktmarkmasked, nil
21645}
21646
21647func NewOxmIdPktMarkMasked() *OxmIdPktMarkMasked {
21648 obj := &OxmIdPktMarkMasked{
21649 OxmId: NewOxmId(82696),
21650 }
21651 return obj
21652}
21653func (self *OxmIdPktMarkMasked) GetOXMName() string {
21654 return "pkt_mark_masked"
21655}
21656
21657func (self *OxmIdPktMarkMasked) MarshalJSON() ([]byte, error) {
21658 if self.TypeLen == 0 {
21659 return []byte("\"\""), nil
21660 } else {
21661 return []byte("\"" + self.GetOXMName() + "\""), nil
21662 }
21663}
21664
21665type OxmIdRecircId struct {
21666 *OxmId
21667}
21668
21669type IOxmIdRecircId interface {
21670 IOxmId
21671}
21672
21673func (self *OxmIdRecircId) Serialize(encoder *goloxi.Encoder) error {
21674 if err := self.OxmId.Serialize(encoder); err != nil {
21675 return err
21676 }
21677
21678 return nil
21679}
21680
21681func DecodeOxmIdRecircId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdRecircId, error) {
21682 _oxmidrecircid := &OxmIdRecircId{OxmId: parent}
21683 return _oxmidrecircid, nil
21684}
21685
21686func NewOxmIdRecircId() *OxmIdRecircId {
21687 obj := &OxmIdRecircId{
21688 OxmId: NewOxmId(83972),
21689 }
21690 return obj
21691}
21692func (self *OxmIdRecircId) GetOXMName() string {
21693 return "recirc_id"
21694}
21695
21696func (self *OxmIdRecircId) MarshalJSON() ([]byte, error) {
21697 if self.TypeLen == 0 {
21698 return []byte("\"\""), nil
21699 } else {
21700 return []byte("\"" + self.GetOXMName() + "\""), nil
21701 }
21702}
21703
21704type OxmIdReg0 struct {
21705 *OxmId
21706}
21707
21708type IOxmIdReg0 interface {
21709 IOxmId
21710}
21711
21712func (self *OxmIdReg0) Serialize(encoder *goloxi.Encoder) error {
21713 if err := self.OxmId.Serialize(encoder); err != nil {
21714 return err
21715 }
21716
21717 return nil
21718}
21719
21720func DecodeOxmIdReg0(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg0, error) {
21721 _oxmidreg0 := &OxmIdReg0{OxmId: parent}
21722 return _oxmidreg0, nil
21723}
21724
21725func NewOxmIdReg0() *OxmIdReg0 {
21726 obj := &OxmIdReg0{
21727 OxmId: NewOxmId(65540),
21728 }
21729 return obj
21730}
21731func (self *OxmIdReg0) GetOXMName() string {
21732 return "reg0"
21733}
21734
21735func (self *OxmIdReg0) MarshalJSON() ([]byte, error) {
21736 if self.TypeLen == 0 {
21737 return []byte("\"\""), nil
21738 } else {
21739 return []byte("\"" + self.GetOXMName() + "\""), nil
21740 }
21741}
21742
21743type OxmIdReg0Masked struct {
21744 *OxmId
21745}
21746
21747type IOxmIdReg0Masked interface {
21748 IOxmId
21749}
21750
21751func (self *OxmIdReg0Masked) Serialize(encoder *goloxi.Encoder) error {
21752 if err := self.OxmId.Serialize(encoder); err != nil {
21753 return err
21754 }
21755
21756 return nil
21757}
21758
21759func DecodeOxmIdReg0Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg0Masked, error) {
21760 _oxmidreg0masked := &OxmIdReg0Masked{OxmId: parent}
21761 return _oxmidreg0masked, nil
21762}
21763
21764func NewOxmIdReg0Masked() *OxmIdReg0Masked {
21765 obj := &OxmIdReg0Masked{
21766 OxmId: NewOxmId(65800),
21767 }
21768 return obj
21769}
21770func (self *OxmIdReg0Masked) GetOXMName() string {
21771 return "reg0_masked"
21772}
21773
21774func (self *OxmIdReg0Masked) MarshalJSON() ([]byte, error) {
21775 if self.TypeLen == 0 {
21776 return []byte("\"\""), nil
21777 } else {
21778 return []byte("\"" + self.GetOXMName() + "\""), nil
21779 }
21780}
21781
21782type OxmIdReg1 struct {
21783 *OxmId
21784}
21785
21786type IOxmIdReg1 interface {
21787 IOxmId
21788}
21789
21790func (self *OxmIdReg1) Serialize(encoder *goloxi.Encoder) error {
21791 if err := self.OxmId.Serialize(encoder); err != nil {
21792 return err
21793 }
21794
21795 return nil
21796}
21797
21798func DecodeOxmIdReg1(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg1, error) {
21799 _oxmidreg1 := &OxmIdReg1{OxmId: parent}
21800 return _oxmidreg1, nil
21801}
21802
21803func NewOxmIdReg1() *OxmIdReg1 {
21804 obj := &OxmIdReg1{
21805 OxmId: NewOxmId(66052),
21806 }
21807 return obj
21808}
21809func (self *OxmIdReg1) GetOXMName() string {
21810 return "reg1"
21811}
21812
21813func (self *OxmIdReg1) MarshalJSON() ([]byte, error) {
21814 if self.TypeLen == 0 {
21815 return []byte("\"\""), nil
21816 } else {
21817 return []byte("\"" + self.GetOXMName() + "\""), nil
21818 }
21819}
21820
21821type OxmIdReg10 struct {
21822 *OxmId
21823}
21824
21825type IOxmIdReg10 interface {
21826 IOxmId
21827}
21828
21829func (self *OxmIdReg10) Serialize(encoder *goloxi.Encoder) error {
21830 if err := self.OxmId.Serialize(encoder); err != nil {
21831 return err
21832 }
21833
21834 return nil
21835}
21836
21837func DecodeOxmIdReg10(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg10, error) {
21838 _oxmidreg10 := &OxmIdReg10{OxmId: parent}
21839 return _oxmidreg10, nil
21840}
21841
21842func NewOxmIdReg10() *OxmIdReg10 {
21843 obj := &OxmIdReg10{
21844 OxmId: NewOxmId(70660),
21845 }
21846 return obj
21847}
21848func (self *OxmIdReg10) GetOXMName() string {
21849 return "reg10"
21850}
21851
21852func (self *OxmIdReg10) MarshalJSON() ([]byte, error) {
21853 if self.TypeLen == 0 {
21854 return []byte("\"\""), nil
21855 } else {
21856 return []byte("\"" + self.GetOXMName() + "\""), nil
21857 }
21858}
21859
21860type OxmIdReg10Masked struct {
21861 *OxmId
21862}
21863
21864type IOxmIdReg10Masked interface {
21865 IOxmId
21866}
21867
21868func (self *OxmIdReg10Masked) Serialize(encoder *goloxi.Encoder) error {
21869 if err := self.OxmId.Serialize(encoder); err != nil {
21870 return err
21871 }
21872
21873 return nil
21874}
21875
21876func DecodeOxmIdReg10Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg10Masked, error) {
21877 _oxmidreg10masked := &OxmIdReg10Masked{OxmId: parent}
21878 return _oxmidreg10masked, nil
21879}
21880
21881func NewOxmIdReg10Masked() *OxmIdReg10Masked {
21882 obj := &OxmIdReg10Masked{
21883 OxmId: NewOxmId(70920),
21884 }
21885 return obj
21886}
21887func (self *OxmIdReg10Masked) GetOXMName() string {
21888 return "reg10_masked"
21889}
21890
21891func (self *OxmIdReg10Masked) MarshalJSON() ([]byte, error) {
21892 if self.TypeLen == 0 {
21893 return []byte("\"\""), nil
21894 } else {
21895 return []byte("\"" + self.GetOXMName() + "\""), nil
21896 }
21897}
21898
21899type OxmIdReg11 struct {
21900 *OxmId
21901}
21902
21903type IOxmIdReg11 interface {
21904 IOxmId
21905}
21906
21907func (self *OxmIdReg11) Serialize(encoder *goloxi.Encoder) error {
21908 if err := self.OxmId.Serialize(encoder); err != nil {
21909 return err
21910 }
21911
21912 return nil
21913}
21914
21915func DecodeOxmIdReg11(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg11, error) {
21916 _oxmidreg11 := &OxmIdReg11{OxmId: parent}
21917 return _oxmidreg11, nil
21918}
21919
21920func NewOxmIdReg11() *OxmIdReg11 {
21921 obj := &OxmIdReg11{
21922 OxmId: NewOxmId(71172),
21923 }
21924 return obj
21925}
21926func (self *OxmIdReg11) GetOXMName() string {
21927 return "reg11"
21928}
21929
21930func (self *OxmIdReg11) MarshalJSON() ([]byte, error) {
21931 if self.TypeLen == 0 {
21932 return []byte("\"\""), nil
21933 } else {
21934 return []byte("\"" + self.GetOXMName() + "\""), nil
21935 }
21936}
21937
21938type OxmIdReg11Masked struct {
21939 *OxmId
21940}
21941
21942type IOxmIdReg11Masked interface {
21943 IOxmId
21944}
21945
21946func (self *OxmIdReg11Masked) Serialize(encoder *goloxi.Encoder) error {
21947 if err := self.OxmId.Serialize(encoder); err != nil {
21948 return err
21949 }
21950
21951 return nil
21952}
21953
21954func DecodeOxmIdReg11Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg11Masked, error) {
21955 _oxmidreg11masked := &OxmIdReg11Masked{OxmId: parent}
21956 return _oxmidreg11masked, nil
21957}
21958
21959func NewOxmIdReg11Masked() *OxmIdReg11Masked {
21960 obj := &OxmIdReg11Masked{
21961 OxmId: NewOxmId(71432),
21962 }
21963 return obj
21964}
21965func (self *OxmIdReg11Masked) GetOXMName() string {
21966 return "reg11_masked"
21967}
21968
21969func (self *OxmIdReg11Masked) MarshalJSON() ([]byte, error) {
21970 if self.TypeLen == 0 {
21971 return []byte("\"\""), nil
21972 } else {
21973 return []byte("\"" + self.GetOXMName() + "\""), nil
21974 }
21975}
21976
21977type OxmIdReg12 struct {
21978 *OxmId
21979}
21980
21981type IOxmIdReg12 interface {
21982 IOxmId
21983}
21984
21985func (self *OxmIdReg12) Serialize(encoder *goloxi.Encoder) error {
21986 if err := self.OxmId.Serialize(encoder); err != nil {
21987 return err
21988 }
21989
21990 return nil
21991}
21992
21993func DecodeOxmIdReg12(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg12, error) {
21994 _oxmidreg12 := &OxmIdReg12{OxmId: parent}
21995 return _oxmidreg12, nil
21996}
21997
21998func NewOxmIdReg12() *OxmIdReg12 {
21999 obj := &OxmIdReg12{
22000 OxmId: NewOxmId(71684),
22001 }
22002 return obj
22003}
22004func (self *OxmIdReg12) GetOXMName() string {
22005 return "reg12"
22006}
22007
22008func (self *OxmIdReg12) MarshalJSON() ([]byte, error) {
22009 if self.TypeLen == 0 {
22010 return []byte("\"\""), nil
22011 } else {
22012 return []byte("\"" + self.GetOXMName() + "\""), nil
22013 }
22014}
22015
22016type OxmIdReg12Masked struct {
22017 *OxmId
22018}
22019
22020type IOxmIdReg12Masked interface {
22021 IOxmId
22022}
22023
22024func (self *OxmIdReg12Masked) Serialize(encoder *goloxi.Encoder) error {
22025 if err := self.OxmId.Serialize(encoder); err != nil {
22026 return err
22027 }
22028
22029 return nil
22030}
22031
22032func DecodeOxmIdReg12Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg12Masked, error) {
22033 _oxmidreg12masked := &OxmIdReg12Masked{OxmId: parent}
22034 return _oxmidreg12masked, nil
22035}
22036
22037func NewOxmIdReg12Masked() *OxmIdReg12Masked {
22038 obj := &OxmIdReg12Masked{
22039 OxmId: NewOxmId(71944),
22040 }
22041 return obj
22042}
22043func (self *OxmIdReg12Masked) GetOXMName() string {
22044 return "reg12_masked"
22045}
22046
22047func (self *OxmIdReg12Masked) MarshalJSON() ([]byte, error) {
22048 if self.TypeLen == 0 {
22049 return []byte("\"\""), nil
22050 } else {
22051 return []byte("\"" + self.GetOXMName() + "\""), nil
22052 }
22053}
22054
22055type OxmIdReg13 struct {
22056 *OxmId
22057}
22058
22059type IOxmIdReg13 interface {
22060 IOxmId
22061}
22062
22063func (self *OxmIdReg13) Serialize(encoder *goloxi.Encoder) error {
22064 if err := self.OxmId.Serialize(encoder); err != nil {
22065 return err
22066 }
22067
22068 return nil
22069}
22070
22071func DecodeOxmIdReg13(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg13, error) {
22072 _oxmidreg13 := &OxmIdReg13{OxmId: parent}
22073 return _oxmidreg13, nil
22074}
22075
22076func NewOxmIdReg13() *OxmIdReg13 {
22077 obj := &OxmIdReg13{
22078 OxmId: NewOxmId(72196),
22079 }
22080 return obj
22081}
22082func (self *OxmIdReg13) GetOXMName() string {
22083 return "reg13"
22084}
22085
22086func (self *OxmIdReg13) MarshalJSON() ([]byte, error) {
22087 if self.TypeLen == 0 {
22088 return []byte("\"\""), nil
22089 } else {
22090 return []byte("\"" + self.GetOXMName() + "\""), nil
22091 }
22092}
22093
22094type OxmIdReg13Masked struct {
22095 *OxmId
22096}
22097
22098type IOxmIdReg13Masked interface {
22099 IOxmId
22100}
22101
22102func (self *OxmIdReg13Masked) Serialize(encoder *goloxi.Encoder) error {
22103 if err := self.OxmId.Serialize(encoder); err != nil {
22104 return err
22105 }
22106
22107 return nil
22108}
22109
22110func DecodeOxmIdReg13Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg13Masked, error) {
22111 _oxmidreg13masked := &OxmIdReg13Masked{OxmId: parent}
22112 return _oxmidreg13masked, nil
22113}
22114
22115func NewOxmIdReg13Masked() *OxmIdReg13Masked {
22116 obj := &OxmIdReg13Masked{
22117 OxmId: NewOxmId(72456),
22118 }
22119 return obj
22120}
22121func (self *OxmIdReg13Masked) GetOXMName() string {
22122 return "reg13_masked"
22123}
22124
22125func (self *OxmIdReg13Masked) MarshalJSON() ([]byte, error) {
22126 if self.TypeLen == 0 {
22127 return []byte("\"\""), nil
22128 } else {
22129 return []byte("\"" + self.GetOXMName() + "\""), nil
22130 }
22131}
22132
22133type OxmIdReg14 struct {
22134 *OxmId
22135}
22136
22137type IOxmIdReg14 interface {
22138 IOxmId
22139}
22140
22141func (self *OxmIdReg14) Serialize(encoder *goloxi.Encoder) error {
22142 if err := self.OxmId.Serialize(encoder); err != nil {
22143 return err
22144 }
22145
22146 return nil
22147}
22148
22149func DecodeOxmIdReg14(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg14, error) {
22150 _oxmidreg14 := &OxmIdReg14{OxmId: parent}
22151 return _oxmidreg14, nil
22152}
22153
22154func NewOxmIdReg14() *OxmIdReg14 {
22155 obj := &OxmIdReg14{
22156 OxmId: NewOxmId(72708),
22157 }
22158 return obj
22159}
22160func (self *OxmIdReg14) GetOXMName() string {
22161 return "reg14"
22162}
22163
22164func (self *OxmIdReg14) MarshalJSON() ([]byte, error) {
22165 if self.TypeLen == 0 {
22166 return []byte("\"\""), nil
22167 } else {
22168 return []byte("\"" + self.GetOXMName() + "\""), nil
22169 }
22170}
22171
22172type OxmIdReg14Masked struct {
22173 *OxmId
22174}
22175
22176type IOxmIdReg14Masked interface {
22177 IOxmId
22178}
22179
22180func (self *OxmIdReg14Masked) Serialize(encoder *goloxi.Encoder) error {
22181 if err := self.OxmId.Serialize(encoder); err != nil {
22182 return err
22183 }
22184
22185 return nil
22186}
22187
22188func DecodeOxmIdReg14Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg14Masked, error) {
22189 _oxmidreg14masked := &OxmIdReg14Masked{OxmId: parent}
22190 return _oxmidreg14masked, nil
22191}
22192
22193func NewOxmIdReg14Masked() *OxmIdReg14Masked {
22194 obj := &OxmIdReg14Masked{
22195 OxmId: NewOxmId(72968),
22196 }
22197 return obj
22198}
22199func (self *OxmIdReg14Masked) GetOXMName() string {
22200 return "reg14_masked"
22201}
22202
22203func (self *OxmIdReg14Masked) MarshalJSON() ([]byte, error) {
22204 if self.TypeLen == 0 {
22205 return []byte("\"\""), nil
22206 } else {
22207 return []byte("\"" + self.GetOXMName() + "\""), nil
22208 }
22209}
22210
22211type OxmIdReg15 struct {
22212 *OxmId
22213}
22214
22215type IOxmIdReg15 interface {
22216 IOxmId
22217}
22218
22219func (self *OxmIdReg15) Serialize(encoder *goloxi.Encoder) error {
22220 if err := self.OxmId.Serialize(encoder); err != nil {
22221 return err
22222 }
22223
22224 return nil
22225}
22226
22227func DecodeOxmIdReg15(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg15, error) {
22228 _oxmidreg15 := &OxmIdReg15{OxmId: parent}
22229 return _oxmidreg15, nil
22230}
22231
22232func NewOxmIdReg15() *OxmIdReg15 {
22233 obj := &OxmIdReg15{
22234 OxmId: NewOxmId(73220),
22235 }
22236 return obj
22237}
22238func (self *OxmIdReg15) GetOXMName() string {
22239 return "reg15"
22240}
22241
22242func (self *OxmIdReg15) MarshalJSON() ([]byte, error) {
22243 if self.TypeLen == 0 {
22244 return []byte("\"\""), nil
22245 } else {
22246 return []byte("\"" + self.GetOXMName() + "\""), nil
22247 }
22248}
22249
22250type OxmIdReg15Masked struct {
22251 *OxmId
22252}
22253
22254type IOxmIdReg15Masked interface {
22255 IOxmId
22256}
22257
22258func (self *OxmIdReg15Masked) Serialize(encoder *goloxi.Encoder) error {
22259 if err := self.OxmId.Serialize(encoder); err != nil {
22260 return err
22261 }
22262
22263 return nil
22264}
22265
22266func DecodeOxmIdReg15Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg15Masked, error) {
22267 _oxmidreg15masked := &OxmIdReg15Masked{OxmId: parent}
22268 return _oxmidreg15masked, nil
22269}
22270
22271func NewOxmIdReg15Masked() *OxmIdReg15Masked {
22272 obj := &OxmIdReg15Masked{
22273 OxmId: NewOxmId(73480),
22274 }
22275 return obj
22276}
22277func (self *OxmIdReg15Masked) GetOXMName() string {
22278 return "reg15_masked"
22279}
22280
22281func (self *OxmIdReg15Masked) MarshalJSON() ([]byte, error) {
22282 if self.TypeLen == 0 {
22283 return []byte("\"\""), nil
22284 } else {
22285 return []byte("\"" + self.GetOXMName() + "\""), nil
22286 }
22287}
22288
22289type OxmIdReg1Masked struct {
22290 *OxmId
22291}
22292
22293type IOxmIdReg1Masked interface {
22294 IOxmId
22295}
22296
22297func (self *OxmIdReg1Masked) Serialize(encoder *goloxi.Encoder) error {
22298 if err := self.OxmId.Serialize(encoder); err != nil {
22299 return err
22300 }
22301
22302 return nil
22303}
22304
22305func DecodeOxmIdReg1Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg1Masked, error) {
22306 _oxmidreg1masked := &OxmIdReg1Masked{OxmId: parent}
22307 return _oxmidreg1masked, nil
22308}
22309
22310func NewOxmIdReg1Masked() *OxmIdReg1Masked {
22311 obj := &OxmIdReg1Masked{
22312 OxmId: NewOxmId(66312),
22313 }
22314 return obj
22315}
22316func (self *OxmIdReg1Masked) GetOXMName() string {
22317 return "reg1_masked"
22318}
22319
22320func (self *OxmIdReg1Masked) MarshalJSON() ([]byte, error) {
22321 if self.TypeLen == 0 {
22322 return []byte("\"\""), nil
22323 } else {
22324 return []byte("\"" + self.GetOXMName() + "\""), nil
22325 }
22326}
22327
22328type OxmIdReg2 struct {
22329 *OxmId
22330}
22331
22332type IOxmIdReg2 interface {
22333 IOxmId
22334}
22335
22336func (self *OxmIdReg2) Serialize(encoder *goloxi.Encoder) error {
22337 if err := self.OxmId.Serialize(encoder); err != nil {
22338 return err
22339 }
22340
22341 return nil
22342}
22343
22344func DecodeOxmIdReg2(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg2, error) {
22345 _oxmidreg2 := &OxmIdReg2{OxmId: parent}
22346 return _oxmidreg2, nil
22347}
22348
22349func NewOxmIdReg2() *OxmIdReg2 {
22350 obj := &OxmIdReg2{
22351 OxmId: NewOxmId(66564),
22352 }
22353 return obj
22354}
22355func (self *OxmIdReg2) GetOXMName() string {
22356 return "reg2"
22357}
22358
22359func (self *OxmIdReg2) MarshalJSON() ([]byte, error) {
22360 if self.TypeLen == 0 {
22361 return []byte("\"\""), nil
22362 } else {
22363 return []byte("\"" + self.GetOXMName() + "\""), nil
22364 }
22365}
22366
22367type OxmIdReg2Masked struct {
22368 *OxmId
22369}
22370
22371type IOxmIdReg2Masked interface {
22372 IOxmId
22373}
22374
22375func (self *OxmIdReg2Masked) Serialize(encoder *goloxi.Encoder) error {
22376 if err := self.OxmId.Serialize(encoder); err != nil {
22377 return err
22378 }
22379
22380 return nil
22381}
22382
22383func DecodeOxmIdReg2Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg2Masked, error) {
22384 _oxmidreg2masked := &OxmIdReg2Masked{OxmId: parent}
22385 return _oxmidreg2masked, nil
22386}
22387
22388func NewOxmIdReg2Masked() *OxmIdReg2Masked {
22389 obj := &OxmIdReg2Masked{
22390 OxmId: NewOxmId(66824),
22391 }
22392 return obj
22393}
22394func (self *OxmIdReg2Masked) GetOXMName() string {
22395 return "reg2_masked"
22396}
22397
22398func (self *OxmIdReg2Masked) MarshalJSON() ([]byte, error) {
22399 if self.TypeLen == 0 {
22400 return []byte("\"\""), nil
22401 } else {
22402 return []byte("\"" + self.GetOXMName() + "\""), nil
22403 }
22404}
22405
22406type OxmIdReg3 struct {
22407 *OxmId
22408}
22409
22410type IOxmIdReg3 interface {
22411 IOxmId
22412}
22413
22414func (self *OxmIdReg3) Serialize(encoder *goloxi.Encoder) error {
22415 if err := self.OxmId.Serialize(encoder); err != nil {
22416 return err
22417 }
22418
22419 return nil
22420}
22421
22422func DecodeOxmIdReg3(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg3, error) {
22423 _oxmidreg3 := &OxmIdReg3{OxmId: parent}
22424 return _oxmidreg3, nil
22425}
22426
22427func NewOxmIdReg3() *OxmIdReg3 {
22428 obj := &OxmIdReg3{
22429 OxmId: NewOxmId(67076),
22430 }
22431 return obj
22432}
22433func (self *OxmIdReg3) GetOXMName() string {
22434 return "reg3"
22435}
22436
22437func (self *OxmIdReg3) MarshalJSON() ([]byte, error) {
22438 if self.TypeLen == 0 {
22439 return []byte("\"\""), nil
22440 } else {
22441 return []byte("\"" + self.GetOXMName() + "\""), nil
22442 }
22443}
22444
22445type OxmIdReg3Masked struct {
22446 *OxmId
22447}
22448
22449type IOxmIdReg3Masked interface {
22450 IOxmId
22451}
22452
22453func (self *OxmIdReg3Masked) Serialize(encoder *goloxi.Encoder) error {
22454 if err := self.OxmId.Serialize(encoder); err != nil {
22455 return err
22456 }
22457
22458 return nil
22459}
22460
22461func DecodeOxmIdReg3Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg3Masked, error) {
22462 _oxmidreg3masked := &OxmIdReg3Masked{OxmId: parent}
22463 return _oxmidreg3masked, nil
22464}
22465
22466func NewOxmIdReg3Masked() *OxmIdReg3Masked {
22467 obj := &OxmIdReg3Masked{
22468 OxmId: NewOxmId(67336),
22469 }
22470 return obj
22471}
22472func (self *OxmIdReg3Masked) GetOXMName() string {
22473 return "reg3_masked"
22474}
22475
22476func (self *OxmIdReg3Masked) MarshalJSON() ([]byte, error) {
22477 if self.TypeLen == 0 {
22478 return []byte("\"\""), nil
22479 } else {
22480 return []byte("\"" + self.GetOXMName() + "\""), nil
22481 }
22482}
22483
22484type OxmIdReg4 struct {
22485 *OxmId
22486}
22487
22488type IOxmIdReg4 interface {
22489 IOxmId
22490}
22491
22492func (self *OxmIdReg4) Serialize(encoder *goloxi.Encoder) error {
22493 if err := self.OxmId.Serialize(encoder); err != nil {
22494 return err
22495 }
22496
22497 return nil
22498}
22499
22500func DecodeOxmIdReg4(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg4, error) {
22501 _oxmidreg4 := &OxmIdReg4{OxmId: parent}
22502 return _oxmidreg4, nil
22503}
22504
22505func NewOxmIdReg4() *OxmIdReg4 {
22506 obj := &OxmIdReg4{
22507 OxmId: NewOxmId(67588),
22508 }
22509 return obj
22510}
22511func (self *OxmIdReg4) GetOXMName() string {
22512 return "reg4"
22513}
22514
22515func (self *OxmIdReg4) MarshalJSON() ([]byte, error) {
22516 if self.TypeLen == 0 {
22517 return []byte("\"\""), nil
22518 } else {
22519 return []byte("\"" + self.GetOXMName() + "\""), nil
22520 }
22521}
22522
22523type OxmIdReg4Masked struct {
22524 *OxmId
22525}
22526
22527type IOxmIdReg4Masked interface {
22528 IOxmId
22529}
22530
22531func (self *OxmIdReg4Masked) Serialize(encoder *goloxi.Encoder) error {
22532 if err := self.OxmId.Serialize(encoder); err != nil {
22533 return err
22534 }
22535
22536 return nil
22537}
22538
22539func DecodeOxmIdReg4Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg4Masked, error) {
22540 _oxmidreg4masked := &OxmIdReg4Masked{OxmId: parent}
22541 return _oxmidreg4masked, nil
22542}
22543
22544func NewOxmIdReg4Masked() *OxmIdReg4Masked {
22545 obj := &OxmIdReg4Masked{
22546 OxmId: NewOxmId(67848),
22547 }
22548 return obj
22549}
22550func (self *OxmIdReg4Masked) GetOXMName() string {
22551 return "reg4_masked"
22552}
22553
22554func (self *OxmIdReg4Masked) MarshalJSON() ([]byte, error) {
22555 if self.TypeLen == 0 {
22556 return []byte("\"\""), nil
22557 } else {
22558 return []byte("\"" + self.GetOXMName() + "\""), nil
22559 }
22560}
22561
22562type OxmIdReg5 struct {
22563 *OxmId
22564}
22565
22566type IOxmIdReg5 interface {
22567 IOxmId
22568}
22569
22570func (self *OxmIdReg5) Serialize(encoder *goloxi.Encoder) error {
22571 if err := self.OxmId.Serialize(encoder); err != nil {
22572 return err
22573 }
22574
22575 return nil
22576}
22577
22578func DecodeOxmIdReg5(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg5, error) {
22579 _oxmidreg5 := &OxmIdReg5{OxmId: parent}
22580 return _oxmidreg5, nil
22581}
22582
22583func NewOxmIdReg5() *OxmIdReg5 {
22584 obj := &OxmIdReg5{
22585 OxmId: NewOxmId(68100),
22586 }
22587 return obj
22588}
22589func (self *OxmIdReg5) GetOXMName() string {
22590 return "reg5"
22591}
22592
22593func (self *OxmIdReg5) MarshalJSON() ([]byte, error) {
22594 if self.TypeLen == 0 {
22595 return []byte("\"\""), nil
22596 } else {
22597 return []byte("\"" + self.GetOXMName() + "\""), nil
22598 }
22599}
22600
22601type OxmIdReg5Masked struct {
22602 *OxmId
22603}
22604
22605type IOxmIdReg5Masked interface {
22606 IOxmId
22607}
22608
22609func (self *OxmIdReg5Masked) Serialize(encoder *goloxi.Encoder) error {
22610 if err := self.OxmId.Serialize(encoder); err != nil {
22611 return err
22612 }
22613
22614 return nil
22615}
22616
22617func DecodeOxmIdReg5Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg5Masked, error) {
22618 _oxmidreg5masked := &OxmIdReg5Masked{OxmId: parent}
22619 return _oxmidreg5masked, nil
22620}
22621
22622func NewOxmIdReg5Masked() *OxmIdReg5Masked {
22623 obj := &OxmIdReg5Masked{
22624 OxmId: NewOxmId(68360),
22625 }
22626 return obj
22627}
22628func (self *OxmIdReg5Masked) GetOXMName() string {
22629 return "reg5_masked"
22630}
22631
22632func (self *OxmIdReg5Masked) MarshalJSON() ([]byte, error) {
22633 if self.TypeLen == 0 {
22634 return []byte("\"\""), nil
22635 } else {
22636 return []byte("\"" + self.GetOXMName() + "\""), nil
22637 }
22638}
22639
22640type OxmIdReg6 struct {
22641 *OxmId
22642}
22643
22644type IOxmIdReg6 interface {
22645 IOxmId
22646}
22647
22648func (self *OxmIdReg6) Serialize(encoder *goloxi.Encoder) error {
22649 if err := self.OxmId.Serialize(encoder); err != nil {
22650 return err
22651 }
22652
22653 return nil
22654}
22655
22656func DecodeOxmIdReg6(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg6, error) {
22657 _oxmidreg6 := &OxmIdReg6{OxmId: parent}
22658 return _oxmidreg6, nil
22659}
22660
22661func NewOxmIdReg6() *OxmIdReg6 {
22662 obj := &OxmIdReg6{
22663 OxmId: NewOxmId(68612),
22664 }
22665 return obj
22666}
22667func (self *OxmIdReg6) GetOXMName() string {
22668 return "reg6"
22669}
22670
22671func (self *OxmIdReg6) MarshalJSON() ([]byte, error) {
22672 if self.TypeLen == 0 {
22673 return []byte("\"\""), nil
22674 } else {
22675 return []byte("\"" + self.GetOXMName() + "\""), nil
22676 }
22677}
22678
22679type OxmIdReg6Masked struct {
22680 *OxmId
22681}
22682
22683type IOxmIdReg6Masked interface {
22684 IOxmId
22685}
22686
22687func (self *OxmIdReg6Masked) Serialize(encoder *goloxi.Encoder) error {
22688 if err := self.OxmId.Serialize(encoder); err != nil {
22689 return err
22690 }
22691
22692 return nil
22693}
22694
22695func DecodeOxmIdReg6Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg6Masked, error) {
22696 _oxmidreg6masked := &OxmIdReg6Masked{OxmId: parent}
22697 return _oxmidreg6masked, nil
22698}
22699
22700func NewOxmIdReg6Masked() *OxmIdReg6Masked {
22701 obj := &OxmIdReg6Masked{
22702 OxmId: NewOxmId(68872),
22703 }
22704 return obj
22705}
22706func (self *OxmIdReg6Masked) GetOXMName() string {
22707 return "reg6_masked"
22708}
22709
22710func (self *OxmIdReg6Masked) MarshalJSON() ([]byte, error) {
22711 if self.TypeLen == 0 {
22712 return []byte("\"\""), nil
22713 } else {
22714 return []byte("\"" + self.GetOXMName() + "\""), nil
22715 }
22716}
22717
22718type OxmIdReg7 struct {
22719 *OxmId
22720}
22721
22722type IOxmIdReg7 interface {
22723 IOxmId
22724}
22725
22726func (self *OxmIdReg7) Serialize(encoder *goloxi.Encoder) error {
22727 if err := self.OxmId.Serialize(encoder); err != nil {
22728 return err
22729 }
22730
22731 return nil
22732}
22733
22734func DecodeOxmIdReg7(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg7, error) {
22735 _oxmidreg7 := &OxmIdReg7{OxmId: parent}
22736 return _oxmidreg7, nil
22737}
22738
22739func NewOxmIdReg7() *OxmIdReg7 {
22740 obj := &OxmIdReg7{
22741 OxmId: NewOxmId(69124),
22742 }
22743 return obj
22744}
22745func (self *OxmIdReg7) GetOXMName() string {
22746 return "reg7"
22747}
22748
22749func (self *OxmIdReg7) MarshalJSON() ([]byte, error) {
22750 if self.TypeLen == 0 {
22751 return []byte("\"\""), nil
22752 } else {
22753 return []byte("\"" + self.GetOXMName() + "\""), nil
22754 }
22755}
22756
22757type OxmIdReg7Masked struct {
22758 *OxmId
22759}
22760
22761type IOxmIdReg7Masked interface {
22762 IOxmId
22763}
22764
22765func (self *OxmIdReg7Masked) Serialize(encoder *goloxi.Encoder) error {
22766 if err := self.OxmId.Serialize(encoder); err != nil {
22767 return err
22768 }
22769
22770 return nil
22771}
22772
22773func DecodeOxmIdReg7Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg7Masked, error) {
22774 _oxmidreg7masked := &OxmIdReg7Masked{OxmId: parent}
22775 return _oxmidreg7masked, nil
22776}
22777
22778func NewOxmIdReg7Masked() *OxmIdReg7Masked {
22779 obj := &OxmIdReg7Masked{
22780 OxmId: NewOxmId(69384),
22781 }
22782 return obj
22783}
22784func (self *OxmIdReg7Masked) GetOXMName() string {
22785 return "reg7_masked"
22786}
22787
22788func (self *OxmIdReg7Masked) MarshalJSON() ([]byte, error) {
22789 if self.TypeLen == 0 {
22790 return []byte("\"\""), nil
22791 } else {
22792 return []byte("\"" + self.GetOXMName() + "\""), nil
22793 }
22794}
22795
22796type OxmIdReg8 struct {
22797 *OxmId
22798}
22799
22800type IOxmIdReg8 interface {
22801 IOxmId
22802}
22803
22804func (self *OxmIdReg8) Serialize(encoder *goloxi.Encoder) error {
22805 if err := self.OxmId.Serialize(encoder); err != nil {
22806 return err
22807 }
22808
22809 return nil
22810}
22811
22812func DecodeOxmIdReg8(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg8, error) {
22813 _oxmidreg8 := &OxmIdReg8{OxmId: parent}
22814 return _oxmidreg8, nil
22815}
22816
22817func NewOxmIdReg8() *OxmIdReg8 {
22818 obj := &OxmIdReg8{
22819 OxmId: NewOxmId(69636),
22820 }
22821 return obj
22822}
22823func (self *OxmIdReg8) GetOXMName() string {
22824 return "reg8"
22825}
22826
22827func (self *OxmIdReg8) MarshalJSON() ([]byte, error) {
22828 if self.TypeLen == 0 {
22829 return []byte("\"\""), nil
22830 } else {
22831 return []byte("\"" + self.GetOXMName() + "\""), nil
22832 }
22833}
22834
22835type OxmIdReg8Masked struct {
22836 *OxmId
22837}
22838
22839type IOxmIdReg8Masked interface {
22840 IOxmId
22841}
22842
22843func (self *OxmIdReg8Masked) Serialize(encoder *goloxi.Encoder) error {
22844 if err := self.OxmId.Serialize(encoder); err != nil {
22845 return err
22846 }
22847
22848 return nil
22849}
22850
22851func DecodeOxmIdReg8Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg8Masked, error) {
22852 _oxmidreg8masked := &OxmIdReg8Masked{OxmId: parent}
22853 return _oxmidreg8masked, nil
22854}
22855
22856func NewOxmIdReg8Masked() *OxmIdReg8Masked {
22857 obj := &OxmIdReg8Masked{
22858 OxmId: NewOxmId(69896),
22859 }
22860 return obj
22861}
22862func (self *OxmIdReg8Masked) GetOXMName() string {
22863 return "reg8_masked"
22864}
22865
22866func (self *OxmIdReg8Masked) MarshalJSON() ([]byte, error) {
22867 if self.TypeLen == 0 {
22868 return []byte("\"\""), nil
22869 } else {
22870 return []byte("\"" + self.GetOXMName() + "\""), nil
22871 }
22872}
22873
22874type OxmIdReg9 struct {
22875 *OxmId
22876}
22877
22878type IOxmIdReg9 interface {
22879 IOxmId
22880}
22881
22882func (self *OxmIdReg9) Serialize(encoder *goloxi.Encoder) error {
22883 if err := self.OxmId.Serialize(encoder); err != nil {
22884 return err
22885 }
22886
22887 return nil
22888}
22889
22890func DecodeOxmIdReg9(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg9, error) {
22891 _oxmidreg9 := &OxmIdReg9{OxmId: parent}
22892 return _oxmidreg9, nil
22893}
22894
22895func NewOxmIdReg9() *OxmIdReg9 {
22896 obj := &OxmIdReg9{
22897 OxmId: NewOxmId(70148),
22898 }
22899 return obj
22900}
22901func (self *OxmIdReg9) GetOXMName() string {
22902 return "reg9"
22903}
22904
22905func (self *OxmIdReg9) MarshalJSON() ([]byte, error) {
22906 if self.TypeLen == 0 {
22907 return []byte("\"\""), nil
22908 } else {
22909 return []byte("\"" + self.GetOXMName() + "\""), nil
22910 }
22911}
22912
22913type OxmIdReg9Masked struct {
22914 *OxmId
22915}
22916
22917type IOxmIdReg9Masked interface {
22918 IOxmId
22919}
22920
22921func (self *OxmIdReg9Masked) Serialize(encoder *goloxi.Encoder) error {
22922 if err := self.OxmId.Serialize(encoder); err != nil {
22923 return err
22924 }
22925
22926 return nil
22927}
22928
22929func DecodeOxmIdReg9Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg9Masked, error) {
22930 _oxmidreg9masked := &OxmIdReg9Masked{OxmId: parent}
22931 return _oxmidreg9masked, nil
22932}
22933
22934func NewOxmIdReg9Masked() *OxmIdReg9Masked {
22935 obj := &OxmIdReg9Masked{
22936 OxmId: NewOxmId(70408),
22937 }
22938 return obj
22939}
22940func (self *OxmIdReg9Masked) GetOXMName() string {
22941 return "reg9_masked"
22942}
22943
22944func (self *OxmIdReg9Masked) MarshalJSON() ([]byte, error) {
22945 if self.TypeLen == 0 {
22946 return []byte("\"\""), nil
22947 } else {
22948 return []byte("\"" + self.GetOXMName() + "\""), nil
22949 }
22950}
22951
22952type OxmIdTcpDst struct {
22953 *OxmId
22954}
22955
22956type IOxmIdTcpDst interface {
22957 IOxmId
22958}
22959
22960func (self *OxmIdTcpDst) Serialize(encoder *goloxi.Encoder) error {
22961 if err := self.OxmId.Serialize(encoder); err != nil {
22962 return err
22963 }
22964
22965 return nil
22966}
22967
22968func DecodeOxmIdTcpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpDst, error) {
22969 _oxmidtcpdst := &OxmIdTcpDst{OxmId: parent}
22970 return _oxmidtcpdst, nil
22971}
22972
22973func NewOxmIdTcpDst() *OxmIdTcpDst {
22974 obj := &OxmIdTcpDst{
22975 OxmId: NewOxmId(5122),
22976 }
22977 return obj
22978}
22979func (self *OxmIdTcpDst) GetOXMName() string {
22980 return "tcp_dst"
22981}
22982
22983func (self *OxmIdTcpDst) MarshalJSON() ([]byte, error) {
22984 if self.TypeLen == 0 {
22985 return []byte("\"\""), nil
22986 } else {
22987 return []byte("\"" + self.GetOXMName() + "\""), nil
22988 }
22989}
22990
22991type OxmIdTcpDstMasked struct {
22992 *OxmId
22993}
22994
22995type IOxmIdTcpDstMasked interface {
22996 IOxmId
22997}
22998
22999func (self *OxmIdTcpDstMasked) Serialize(encoder *goloxi.Encoder) error {
23000 if err := self.OxmId.Serialize(encoder); err != nil {
23001 return err
23002 }
23003
23004 return nil
23005}
23006
23007func DecodeOxmIdTcpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpDstMasked, error) {
23008 _oxmidtcpdstmasked := &OxmIdTcpDstMasked{OxmId: parent}
23009 return _oxmidtcpdstmasked, nil
23010}
23011
23012func NewOxmIdTcpDstMasked() *OxmIdTcpDstMasked {
23013 obj := &OxmIdTcpDstMasked{
23014 OxmId: NewOxmId(5378),
23015 }
23016 return obj
23017}
23018func (self *OxmIdTcpDstMasked) GetOXMName() string {
23019 return "tcp_dst_masked"
23020}
23021
23022func (self *OxmIdTcpDstMasked) MarshalJSON() ([]byte, error) {
23023 if self.TypeLen == 0 {
23024 return []byte("\"\""), nil
23025 } else {
23026 return []byte("\"" + self.GetOXMName() + "\""), nil
23027 }
23028}
23029
23030type OxmIdTcpFlags struct {
23031 *OxmId
23032}
23033
23034type IOxmIdTcpFlags interface {
23035 IOxmId
23036}
23037
23038func (self *OxmIdTcpFlags) Serialize(encoder *goloxi.Encoder) error {
23039 if err := self.OxmId.Serialize(encoder); err != nil {
23040 return err
23041 }
23042
23043 return nil
23044}
23045
23046func DecodeOxmIdTcpFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpFlags, error) {
23047 _oxmidtcpflags := &OxmIdTcpFlags{OxmId: parent}
23048 return _oxmidtcpflags, nil
23049}
23050
23051func NewOxmIdTcpFlags() *OxmIdTcpFlags {
23052 obj := &OxmIdTcpFlags{
23053 OxmId: NewOxmId(82946),
23054 }
23055 return obj
23056}
23057func (self *OxmIdTcpFlags) GetOXMName() string {
23058 return "tcp_flags"
23059}
23060
23061func (self *OxmIdTcpFlags) MarshalJSON() ([]byte, error) {
23062 if self.TypeLen == 0 {
23063 return []byte("\"\""), nil
23064 } else {
23065 return []byte("\"" + self.GetOXMName() + "\""), nil
23066 }
23067}
23068
23069type OxmIdTcpFlagsMasked struct {
23070 *OxmId
23071}
23072
23073type IOxmIdTcpFlagsMasked interface {
23074 IOxmId
23075}
23076
23077func (self *OxmIdTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
23078 if err := self.OxmId.Serialize(encoder); err != nil {
23079 return err
23080 }
23081
23082 return nil
23083}
23084
23085func DecodeOxmIdTcpFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpFlagsMasked, error) {
23086 _oxmidtcpflagsmasked := &OxmIdTcpFlagsMasked{OxmId: parent}
23087 return _oxmidtcpflagsmasked, nil
23088}
23089
23090func NewOxmIdTcpFlagsMasked() *OxmIdTcpFlagsMasked {
23091 obj := &OxmIdTcpFlagsMasked{
23092 OxmId: NewOxmId(83204),
23093 }
23094 return obj
23095}
23096func (self *OxmIdTcpFlagsMasked) GetOXMName() string {
23097 return "tcp_flags_masked"
23098}
23099
23100func (self *OxmIdTcpFlagsMasked) MarshalJSON() ([]byte, error) {
23101 if self.TypeLen == 0 {
23102 return []byte("\"\""), nil
23103 } else {
23104 return []byte("\"" + self.GetOXMName() + "\""), nil
23105 }
23106}
23107
23108type OxmIdTcpSrc struct {
23109 *OxmId
23110}
23111
23112type IOxmIdTcpSrc interface {
23113 IOxmId
23114}
23115
23116func (self *OxmIdTcpSrc) Serialize(encoder *goloxi.Encoder) error {
23117 if err := self.OxmId.Serialize(encoder); err != nil {
23118 return err
23119 }
23120
23121 return nil
23122}
23123
23124func DecodeOxmIdTcpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpSrc, error) {
23125 _oxmidtcpsrc := &OxmIdTcpSrc{OxmId: parent}
23126 return _oxmidtcpsrc, nil
23127}
23128
23129func NewOxmIdTcpSrc() *OxmIdTcpSrc {
23130 obj := &OxmIdTcpSrc{
23131 OxmId: NewOxmId(4610),
23132 }
23133 return obj
23134}
23135func (self *OxmIdTcpSrc) GetOXMName() string {
23136 return "tcp_src"
23137}
23138
23139func (self *OxmIdTcpSrc) MarshalJSON() ([]byte, error) {
23140 if self.TypeLen == 0 {
23141 return []byte("\"\""), nil
23142 } else {
23143 return []byte("\"" + self.GetOXMName() + "\""), nil
23144 }
23145}
23146
23147type OxmIdTcpSrcMasked struct {
23148 *OxmId
23149}
23150
23151type IOxmIdTcpSrcMasked interface {
23152 IOxmId
23153}
23154
23155func (self *OxmIdTcpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
23156 if err := self.OxmId.Serialize(encoder); err != nil {
23157 return err
23158 }
23159
23160 return nil
23161}
23162
23163func DecodeOxmIdTcpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpSrcMasked, error) {
23164 _oxmidtcpsrcmasked := &OxmIdTcpSrcMasked{OxmId: parent}
23165 return _oxmidtcpsrcmasked, nil
23166}
23167
23168func NewOxmIdTcpSrcMasked() *OxmIdTcpSrcMasked {
23169 obj := &OxmIdTcpSrcMasked{
23170 OxmId: NewOxmId(4868),
23171 }
23172 return obj
23173}
23174func (self *OxmIdTcpSrcMasked) GetOXMName() string {
23175 return "tcp_src_masked"
23176}
23177
23178func (self *OxmIdTcpSrcMasked) MarshalJSON() ([]byte, error) {
23179 if self.TypeLen == 0 {
23180 return []byte("\"\""), nil
23181 } else {
23182 return []byte("\"" + self.GetOXMName() + "\""), nil
23183 }
23184}
23185
23186type OxmIdTunDst struct {
23187 *OxmId
23188}
23189
23190type IOxmIdTunDst interface {
23191 IOxmId
23192}
23193
23194func (self *OxmIdTunDst) Serialize(encoder *goloxi.Encoder) error {
23195 if err := self.OxmId.Serialize(encoder); err != nil {
23196 return err
23197 }
23198
23199 return nil
23200}
23201
23202func DecodeOxmIdTunDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunDst, error) {
23203 _oxmidtundst := &OxmIdTunDst{OxmId: parent}
23204 return _oxmidtundst, nil
23205}
23206
23207func NewOxmIdTunDst() *OxmIdTunDst {
23208 obj := &OxmIdTunDst{
23209 OxmId: NewOxmId(81924),
23210 }
23211 return obj
23212}
23213func (self *OxmIdTunDst) GetOXMName() string {
23214 return "tun_dst"
23215}
23216
23217func (self *OxmIdTunDst) MarshalJSON() ([]byte, error) {
23218 if self.TypeLen == 0 {
23219 return []byte("\"\""), nil
23220 } else {
23221 return []byte("\"" + self.GetOXMName() + "\""), nil
23222 }
23223}
23224
23225type OxmIdTunDstMasked struct {
23226 *OxmId
23227}
23228
23229type IOxmIdTunDstMasked interface {
23230 IOxmId
23231}
23232
23233func (self *OxmIdTunDstMasked) Serialize(encoder *goloxi.Encoder) error {
23234 if err := self.OxmId.Serialize(encoder); err != nil {
23235 return err
23236 }
23237
23238 return nil
23239}
23240
23241func DecodeOxmIdTunDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunDstMasked, error) {
23242 _oxmidtundstmasked := &OxmIdTunDstMasked{OxmId: parent}
23243 return _oxmidtundstmasked, nil
23244}
23245
23246func NewOxmIdTunDstMasked() *OxmIdTunDstMasked {
23247 obj := &OxmIdTunDstMasked{
23248 OxmId: NewOxmId(82184),
23249 }
23250 return obj
23251}
23252func (self *OxmIdTunDstMasked) GetOXMName() string {
23253 return "tun_dst_masked"
23254}
23255
23256func (self *OxmIdTunDstMasked) MarshalJSON() ([]byte, error) {
23257 if self.TypeLen == 0 {
23258 return []byte("\"\""), nil
23259 } else {
23260 return []byte("\"" + self.GetOXMName() + "\""), nil
23261 }
23262}
23263
23264type OxmIdTunFlags struct {
23265 *OxmId
23266}
23267
23268type IOxmIdTunFlags interface {
23269 IOxmId
23270}
23271
23272func (self *OxmIdTunFlags) Serialize(encoder *goloxi.Encoder) error {
23273 if err := self.OxmId.Serialize(encoder); err != nil {
23274 return err
23275 }
23276
23277 return nil
23278}
23279
23280func DecodeOxmIdTunFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunFlags, error) {
23281 _oxmidtunflags := &OxmIdTunFlags{OxmId: parent}
23282 return _oxmidtunflags, nil
23283}
23284
23285func NewOxmIdTunFlags() *OxmIdTunFlags {
23286 obj := &OxmIdTunFlags{
23287 OxmId: NewOxmId(118786),
23288 }
23289 return obj
23290}
23291func (self *OxmIdTunFlags) GetOXMName() string {
23292 return "tun_flags"
23293}
23294
23295func (self *OxmIdTunFlags) MarshalJSON() ([]byte, error) {
23296 if self.TypeLen == 0 {
23297 return []byte("\"\""), nil
23298 } else {
23299 return []byte("\"" + self.GetOXMName() + "\""), nil
23300 }
23301}
23302
23303type OxmIdTunFlagsMasked struct {
23304 *OxmId
23305}
23306
23307type IOxmIdTunFlagsMasked interface {
23308 IOxmId
23309}
23310
23311func (self *OxmIdTunFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
23312 if err := self.OxmId.Serialize(encoder); err != nil {
23313 return err
23314 }
23315
23316 return nil
23317}
23318
23319func DecodeOxmIdTunFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunFlagsMasked, error) {
23320 _oxmidtunflagsmasked := &OxmIdTunFlagsMasked{OxmId: parent}
23321 return _oxmidtunflagsmasked, nil
23322}
23323
23324func NewOxmIdTunFlagsMasked() *OxmIdTunFlagsMasked {
23325 obj := &OxmIdTunFlagsMasked{
23326 OxmId: NewOxmId(119044),
23327 }
23328 return obj
23329}
23330func (self *OxmIdTunFlagsMasked) GetOXMName() string {
23331 return "tun_flags_masked"
23332}
23333
23334func (self *OxmIdTunFlagsMasked) MarshalJSON() ([]byte, error) {
23335 if self.TypeLen == 0 {
23336 return []byte("\"\""), nil
23337 } else {
23338 return []byte("\"" + self.GetOXMName() + "\""), nil
23339 }
23340}
23341
23342type OxmIdTunGbpFlags struct {
23343 *OxmId
23344}
23345
23346type IOxmIdTunGbpFlags interface {
23347 IOxmId
23348}
23349
23350func (self *OxmIdTunGbpFlags) Serialize(encoder *goloxi.Encoder) error {
23351 if err := self.OxmId.Serialize(encoder); err != nil {
23352 return err
23353 }
23354
23355 return nil
23356}
23357
23358func DecodeOxmIdTunGbpFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpFlags, error) {
23359 _oxmidtungbpflags := &OxmIdTunGbpFlags{OxmId: parent}
23360 return _oxmidtungbpflags, nil
23361}
23362
23363func NewOxmIdTunGbpFlags() *OxmIdTunGbpFlags {
23364 obj := &OxmIdTunGbpFlags{
23365 OxmId: NewOxmId(85505),
23366 }
23367 return obj
23368}
23369func (self *OxmIdTunGbpFlags) GetOXMName() string {
23370 return "tun_gbp_flags"
23371}
23372
23373func (self *OxmIdTunGbpFlags) MarshalJSON() ([]byte, error) {
23374 if self.TypeLen == 0 {
23375 return []byte("\"\""), nil
23376 } else {
23377 return []byte("\"" + self.GetOXMName() + "\""), nil
23378 }
23379}
23380
23381type OxmIdTunGbpFlagsMasked struct {
23382 *OxmId
23383}
23384
23385type IOxmIdTunGbpFlagsMasked interface {
23386 IOxmId
23387}
23388
23389func (self *OxmIdTunGbpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
23390 if err := self.OxmId.Serialize(encoder); err != nil {
23391 return err
23392 }
23393
23394 return nil
23395}
23396
23397func DecodeOxmIdTunGbpFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpFlagsMasked, error) {
23398 _oxmidtungbpflagsmasked := &OxmIdTunGbpFlagsMasked{OxmId: parent}
23399 return _oxmidtungbpflagsmasked, nil
23400}
23401
23402func NewOxmIdTunGbpFlagsMasked() *OxmIdTunGbpFlagsMasked {
23403 obj := &OxmIdTunGbpFlagsMasked{
23404 OxmId: NewOxmId(85762),
23405 }
23406 return obj
23407}
23408func (self *OxmIdTunGbpFlagsMasked) GetOXMName() string {
23409 return "tun_gbp_flags_masked"
23410}
23411
23412func (self *OxmIdTunGbpFlagsMasked) MarshalJSON() ([]byte, error) {
23413 if self.TypeLen == 0 {
23414 return []byte("\"\""), nil
23415 } else {
23416 return []byte("\"" + self.GetOXMName() + "\""), nil
23417 }
23418}
23419
23420type OxmIdTunGbpId struct {
23421 *OxmId
23422}
23423
23424type IOxmIdTunGbpId interface {
23425 IOxmId
23426}
23427
23428func (self *OxmIdTunGbpId) Serialize(encoder *goloxi.Encoder) error {
23429 if err := self.OxmId.Serialize(encoder); err != nil {
23430 return err
23431 }
23432
23433 return nil
23434}
23435
23436func DecodeOxmIdTunGbpId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpId, error) {
23437 _oxmidtungbpid := &OxmIdTunGbpId{OxmId: parent}
23438 return _oxmidtungbpid, nil
23439}
23440
23441func NewOxmIdTunGbpId() *OxmIdTunGbpId {
23442 obj := &OxmIdTunGbpId{
23443 OxmId: NewOxmId(84994),
23444 }
23445 return obj
23446}
23447func (self *OxmIdTunGbpId) GetOXMName() string {
23448 return "tun_gbp_id"
23449}
23450
23451func (self *OxmIdTunGbpId) MarshalJSON() ([]byte, error) {
23452 if self.TypeLen == 0 {
23453 return []byte("\"\""), nil
23454 } else {
23455 return []byte("\"" + self.GetOXMName() + "\""), nil
23456 }
23457}
23458
23459type OxmIdTunGbpIdMasked struct {
23460 *OxmId
23461}
23462
23463type IOxmIdTunGbpIdMasked interface {
23464 IOxmId
23465}
23466
23467func (self *OxmIdTunGbpIdMasked) Serialize(encoder *goloxi.Encoder) error {
23468 if err := self.OxmId.Serialize(encoder); err != nil {
23469 return err
23470 }
23471
23472 return nil
23473}
23474
23475func DecodeOxmIdTunGbpIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpIdMasked, error) {
23476 _oxmidtungbpidmasked := &OxmIdTunGbpIdMasked{OxmId: parent}
23477 return _oxmidtungbpidmasked, nil
23478}
23479
23480func NewOxmIdTunGbpIdMasked() *OxmIdTunGbpIdMasked {
23481 obj := &OxmIdTunGbpIdMasked{
23482 OxmId: NewOxmId(85252),
23483 }
23484 return obj
23485}
23486func (self *OxmIdTunGbpIdMasked) GetOXMName() string {
23487 return "tun_gbp_id_masked"
23488}
23489
23490func (self *OxmIdTunGbpIdMasked) MarshalJSON() ([]byte, error) {
23491 if self.TypeLen == 0 {
23492 return []byte("\"\""), nil
23493 } else {
23494 return []byte("\"" + self.GetOXMName() + "\""), nil
23495 }
23496}
23497
23498type OxmIdTunId struct {
23499 *OxmId
23500}
23501
23502type IOxmIdTunId interface {
23503 IOxmId
23504}
23505
23506func (self *OxmIdTunId) Serialize(encoder *goloxi.Encoder) error {
23507 if err := self.OxmId.Serialize(encoder); err != nil {
23508 return err
23509 }
23510
23511 return nil
23512}
23513
23514func DecodeOxmIdTunId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunId, error) {
23515 _oxmidtunid := &OxmIdTunId{OxmId: parent}
23516 return _oxmidtunid, nil
23517}
23518
23519func NewOxmIdTunId() *OxmIdTunId {
23520 obj := &OxmIdTunId{
23521 OxmId: NewOxmId(73736),
23522 }
23523 return obj
23524}
23525func (self *OxmIdTunId) GetOXMName() string {
23526 return "tun_id"
23527}
23528
23529func (self *OxmIdTunId) MarshalJSON() ([]byte, error) {
23530 if self.TypeLen == 0 {
23531 return []byte("\"\""), nil
23532 } else {
23533 return []byte("\"" + self.GetOXMName() + "\""), nil
23534 }
23535}
23536
23537type OxmIdTunIdMasked struct {
23538 *OxmId
23539}
23540
23541type IOxmIdTunIdMasked interface {
23542 IOxmId
23543}
23544
23545func (self *OxmIdTunIdMasked) Serialize(encoder *goloxi.Encoder) error {
23546 if err := self.OxmId.Serialize(encoder); err != nil {
23547 return err
23548 }
23549
23550 return nil
23551}
23552
23553func DecodeOxmIdTunIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIdMasked, error) {
23554 _oxmidtunidmasked := &OxmIdTunIdMasked{OxmId: parent}
23555 return _oxmidtunidmasked, nil
23556}
23557
23558func NewOxmIdTunIdMasked() *OxmIdTunIdMasked {
23559 obj := &OxmIdTunIdMasked{
23560 OxmId: NewOxmId(74000),
23561 }
23562 return obj
23563}
23564func (self *OxmIdTunIdMasked) GetOXMName() string {
23565 return "tun_id_masked"
23566}
23567
23568func (self *OxmIdTunIdMasked) MarshalJSON() ([]byte, error) {
23569 if self.TypeLen == 0 {
23570 return []byte("\"\""), nil
23571 } else {
23572 return []byte("\"" + self.GetOXMName() + "\""), nil
23573 }
23574}
23575
23576type OxmIdTunIpv6Dst struct {
23577 *OxmId
23578}
23579
23580type IOxmIdTunIpv6Dst interface {
23581 IOxmId
23582}
23583
23584func (self *OxmIdTunIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
23585 if err := self.OxmId.Serialize(encoder); err != nil {
23586 return err
23587 }
23588
23589 return nil
23590}
23591
23592func DecodeOxmIdTunIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6Dst, error) {
23593 _oxmidtunipv6dst := &OxmIdTunIpv6Dst{OxmId: parent}
23594 return _oxmidtunipv6dst, nil
23595}
23596
23597func NewOxmIdTunIpv6Dst() *OxmIdTunIpv6Dst {
23598 obj := &OxmIdTunIpv6Dst{
23599 OxmId: NewOxmId(121872),
23600 }
23601 return obj
23602}
23603func (self *OxmIdTunIpv6Dst) GetOXMName() string {
23604 return "tun_ipv6_dst"
23605}
23606
23607func (self *OxmIdTunIpv6Dst) MarshalJSON() ([]byte, error) {
23608 if self.TypeLen == 0 {
23609 return []byte("\"\""), nil
23610 } else {
23611 return []byte("\"" + self.GetOXMName() + "\""), nil
23612 }
23613}
23614
23615type OxmIdTunIpv6DstMasked struct {
23616 *OxmId
23617}
23618
23619type IOxmIdTunIpv6DstMasked interface {
23620 IOxmId
23621}
23622
23623func (self *OxmIdTunIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
23624 if err := self.OxmId.Serialize(encoder); err != nil {
23625 return err
23626 }
23627
23628 return nil
23629}
23630
23631func DecodeOxmIdTunIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6DstMasked, error) {
23632 _oxmidtunipv6dstmasked := &OxmIdTunIpv6DstMasked{OxmId: parent}
23633 return _oxmidtunipv6dstmasked, nil
23634}
23635
23636func NewOxmIdTunIpv6DstMasked() *OxmIdTunIpv6DstMasked {
23637 obj := &OxmIdTunIpv6DstMasked{
23638 OxmId: NewOxmId(122144),
23639 }
23640 return obj
23641}
23642func (self *OxmIdTunIpv6DstMasked) GetOXMName() string {
23643 return "tun_ipv6_dst_masked"
23644}
23645
23646func (self *OxmIdTunIpv6DstMasked) MarshalJSON() ([]byte, error) {
23647 if self.TypeLen == 0 {
23648 return []byte("\"\""), nil
23649 } else {
23650 return []byte("\"" + self.GetOXMName() + "\""), nil
23651 }
23652}
23653
23654type OxmIdTunIpv6Src struct {
23655 *OxmId
23656}
23657
23658type IOxmIdTunIpv6Src interface {
23659 IOxmId
23660}
23661
23662func (self *OxmIdTunIpv6Src) Serialize(encoder *goloxi.Encoder) error {
23663 if err := self.OxmId.Serialize(encoder); err != nil {
23664 return err
23665 }
23666
23667 return nil
23668}
23669
23670func DecodeOxmIdTunIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6Src, error) {
23671 _oxmidtunipv6src := &OxmIdTunIpv6Src{OxmId: parent}
23672 return _oxmidtunipv6src, nil
23673}
23674
23675func NewOxmIdTunIpv6Src() *OxmIdTunIpv6Src {
23676 obj := &OxmIdTunIpv6Src{
23677 OxmId: NewOxmId(121360),
23678 }
23679 return obj
23680}
23681func (self *OxmIdTunIpv6Src) GetOXMName() string {
23682 return "tun_ipv6_src"
23683}
23684
23685func (self *OxmIdTunIpv6Src) MarshalJSON() ([]byte, error) {
23686 if self.TypeLen == 0 {
23687 return []byte("\"\""), nil
23688 } else {
23689 return []byte("\"" + self.GetOXMName() + "\""), nil
23690 }
23691}
23692
23693type OxmIdTunIpv6SrcMasked struct {
23694 *OxmId
23695}
23696
23697type IOxmIdTunIpv6SrcMasked interface {
23698 IOxmId
23699}
23700
23701func (self *OxmIdTunIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
23702 if err := self.OxmId.Serialize(encoder); err != nil {
23703 return err
23704 }
23705
23706 return nil
23707}
23708
23709func DecodeOxmIdTunIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6SrcMasked, error) {
23710 _oxmidtunipv6srcmasked := &OxmIdTunIpv6SrcMasked{OxmId: parent}
23711 return _oxmidtunipv6srcmasked, nil
23712}
23713
23714func NewOxmIdTunIpv6SrcMasked() *OxmIdTunIpv6SrcMasked {
23715 obj := &OxmIdTunIpv6SrcMasked{
23716 OxmId: NewOxmId(121632),
23717 }
23718 return obj
23719}
23720func (self *OxmIdTunIpv6SrcMasked) GetOXMName() string {
23721 return "tun_ipv6_src_masked"
23722}
23723
23724func (self *OxmIdTunIpv6SrcMasked) MarshalJSON() ([]byte, error) {
23725 if self.TypeLen == 0 {
23726 return []byte("\"\""), nil
23727 } else {
23728 return []byte("\"" + self.GetOXMName() + "\""), nil
23729 }
23730}
23731
23732type OxmIdTunMetadata0 struct {
23733 *OxmId
23734}
23735
23736type IOxmIdTunMetadata0 interface {
23737 IOxmId
23738}
23739
23740func (self *OxmIdTunMetadata0) Serialize(encoder *goloxi.Encoder) error {
23741 if err := self.OxmId.Serialize(encoder); err != nil {
23742 return err
23743 }
23744
23745 return nil
23746}
23747
23748func DecodeOxmIdTunMetadata0(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata0, error) {
23749 _oxmidtunmetadata0 := &OxmIdTunMetadata0{OxmId: parent}
23750 return _oxmidtunmetadata0, nil
23751}
23752
23753func NewOxmIdTunMetadata0() *OxmIdTunMetadata0 {
23754 obj := &OxmIdTunMetadata0{
23755 OxmId: NewOxmId(86140),
23756 }
23757 return obj
23758}
23759func (self *OxmIdTunMetadata0) GetOXMName() string {
23760 return "tun_metadata0"
23761}
23762
23763func (self *OxmIdTunMetadata0) MarshalJSON() ([]byte, error) {
23764 if self.TypeLen == 0 {
23765 return []byte("\"\""), nil
23766 } else {
23767 return []byte("\"" + self.GetOXMName() + "\""), nil
23768 }
23769}
23770
23771type OxmIdTunMetadata0Masked struct {
23772 *OxmId
23773}
23774
23775type IOxmIdTunMetadata0Masked interface {
23776 IOxmId
23777}
23778
23779func (self *OxmIdTunMetadata0Masked) Serialize(encoder *goloxi.Encoder) error {
23780 if err := self.OxmId.Serialize(encoder); err != nil {
23781 return err
23782 }
23783
23784 return nil
23785}
23786
23787func DecodeOxmIdTunMetadata0Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata0Masked, error) {
23788 _oxmidtunmetadata0masked := &OxmIdTunMetadata0Masked{OxmId: parent}
23789 return _oxmidtunmetadata0masked, nil
23790}
23791
23792func NewOxmIdTunMetadata0Masked() *OxmIdTunMetadata0Masked {
23793 obj := &OxmIdTunMetadata0Masked{
23794 OxmId: NewOxmId(86520),
23795 }
23796 return obj
23797}
23798func (self *OxmIdTunMetadata0Masked) GetOXMName() string {
23799 return "tun_metadata0_masked"
23800}
23801
23802func (self *OxmIdTunMetadata0Masked) MarshalJSON() ([]byte, error) {
23803 if self.TypeLen == 0 {
23804 return []byte("\"\""), nil
23805 } else {
23806 return []byte("\"" + self.GetOXMName() + "\""), nil
23807 }
23808}
23809
23810type OxmIdTunMetadata1 struct {
23811 *OxmId
23812}
23813
23814type IOxmIdTunMetadata1 interface {
23815 IOxmId
23816}
23817
23818func (self *OxmIdTunMetadata1) Serialize(encoder *goloxi.Encoder) error {
23819 if err := self.OxmId.Serialize(encoder); err != nil {
23820 return err
23821 }
23822
23823 return nil
23824}
23825
23826func DecodeOxmIdTunMetadata1(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata1, error) {
23827 _oxmidtunmetadata1 := &OxmIdTunMetadata1{OxmId: parent}
23828 return _oxmidtunmetadata1, nil
23829}
23830
23831func NewOxmIdTunMetadata1() *OxmIdTunMetadata1 {
23832 obj := &OxmIdTunMetadata1{
23833 OxmId: NewOxmId(86652),
23834 }
23835 return obj
23836}
23837func (self *OxmIdTunMetadata1) GetOXMName() string {
23838 return "tun_metadata1"
23839}
23840
23841func (self *OxmIdTunMetadata1) MarshalJSON() ([]byte, error) {
23842 if self.TypeLen == 0 {
23843 return []byte("\"\""), nil
23844 } else {
23845 return []byte("\"" + self.GetOXMName() + "\""), nil
23846 }
23847}
23848
23849type OxmIdTunMetadata10 struct {
23850 *OxmId
23851}
23852
23853type IOxmIdTunMetadata10 interface {
23854 IOxmId
23855}
23856
23857func (self *OxmIdTunMetadata10) Serialize(encoder *goloxi.Encoder) error {
23858 if err := self.OxmId.Serialize(encoder); err != nil {
23859 return err
23860 }
23861
23862 return nil
23863}
23864
23865func DecodeOxmIdTunMetadata10(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata10, error) {
23866 _oxmidtunmetadata10 := &OxmIdTunMetadata10{OxmId: parent}
23867 return _oxmidtunmetadata10, nil
23868}
23869
23870func NewOxmIdTunMetadata10() *OxmIdTunMetadata10 {
23871 obj := &OxmIdTunMetadata10{
23872 OxmId: NewOxmId(91260),
23873 }
23874 return obj
23875}
23876func (self *OxmIdTunMetadata10) GetOXMName() string {
23877 return "tun_metadata10"
23878}
23879
23880func (self *OxmIdTunMetadata10) MarshalJSON() ([]byte, error) {
23881 if self.TypeLen == 0 {
23882 return []byte("\"\""), nil
23883 } else {
23884 return []byte("\"" + self.GetOXMName() + "\""), nil
23885 }
23886}
23887
23888type OxmIdTunMetadata10Masked struct {
23889 *OxmId
23890}
23891
23892type IOxmIdTunMetadata10Masked interface {
23893 IOxmId
23894}
23895
23896func (self *OxmIdTunMetadata10Masked) Serialize(encoder *goloxi.Encoder) error {
23897 if err := self.OxmId.Serialize(encoder); err != nil {
23898 return err
23899 }
23900
23901 return nil
23902}
23903
23904func DecodeOxmIdTunMetadata10Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata10Masked, error) {
23905 _oxmidtunmetadata10masked := &OxmIdTunMetadata10Masked{OxmId: parent}
23906 return _oxmidtunmetadata10masked, nil
23907}
23908
23909func NewOxmIdTunMetadata10Masked() *OxmIdTunMetadata10Masked {
23910 obj := &OxmIdTunMetadata10Masked{
23911 OxmId: NewOxmId(91640),
23912 }
23913 return obj
23914}
23915func (self *OxmIdTunMetadata10Masked) GetOXMName() string {
23916 return "tun_metadata10_masked"
23917}
23918
23919func (self *OxmIdTunMetadata10Masked) MarshalJSON() ([]byte, error) {
23920 if self.TypeLen == 0 {
23921 return []byte("\"\""), nil
23922 } else {
23923 return []byte("\"" + self.GetOXMName() + "\""), nil
23924 }
23925}
23926
23927type OxmIdTunMetadata11 struct {
23928 *OxmId
23929}
23930
23931type IOxmIdTunMetadata11 interface {
23932 IOxmId
23933}
23934
23935func (self *OxmIdTunMetadata11) Serialize(encoder *goloxi.Encoder) error {
23936 if err := self.OxmId.Serialize(encoder); err != nil {
23937 return err
23938 }
23939
23940 return nil
23941}
23942
23943func DecodeOxmIdTunMetadata11(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata11, error) {
23944 _oxmidtunmetadata11 := &OxmIdTunMetadata11{OxmId: parent}
23945 return _oxmidtunmetadata11, nil
23946}
23947
23948func NewOxmIdTunMetadata11() *OxmIdTunMetadata11 {
23949 obj := &OxmIdTunMetadata11{
23950 OxmId: NewOxmId(91772),
23951 }
23952 return obj
23953}
23954func (self *OxmIdTunMetadata11) GetOXMName() string {
23955 return "tun_metadata11"
23956}
23957
23958func (self *OxmIdTunMetadata11) MarshalJSON() ([]byte, error) {
23959 if self.TypeLen == 0 {
23960 return []byte("\"\""), nil
23961 } else {
23962 return []byte("\"" + self.GetOXMName() + "\""), nil
23963 }
23964}
23965
23966type OxmIdTunMetadata11Masked struct {
23967 *OxmId
23968}
23969
23970type IOxmIdTunMetadata11Masked interface {
23971 IOxmId
23972}
23973
23974func (self *OxmIdTunMetadata11Masked) Serialize(encoder *goloxi.Encoder) error {
23975 if err := self.OxmId.Serialize(encoder); err != nil {
23976 return err
23977 }
23978
23979 return nil
23980}
23981
23982func DecodeOxmIdTunMetadata11Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata11Masked, error) {
23983 _oxmidtunmetadata11masked := &OxmIdTunMetadata11Masked{OxmId: parent}
23984 return _oxmidtunmetadata11masked, nil
23985}
23986
23987func NewOxmIdTunMetadata11Masked() *OxmIdTunMetadata11Masked {
23988 obj := &OxmIdTunMetadata11Masked{
23989 OxmId: NewOxmId(92152),
23990 }
23991 return obj
23992}
23993func (self *OxmIdTunMetadata11Masked) GetOXMName() string {
23994 return "tun_metadata11_masked"
23995}
23996
23997func (self *OxmIdTunMetadata11Masked) MarshalJSON() ([]byte, error) {
23998 if self.TypeLen == 0 {
23999 return []byte("\"\""), nil
24000 } else {
24001 return []byte("\"" + self.GetOXMName() + "\""), nil
24002 }
24003}
24004
24005type OxmIdTunMetadata12 struct {
24006 *OxmId
24007}
24008
24009type IOxmIdTunMetadata12 interface {
24010 IOxmId
24011}
24012
24013func (self *OxmIdTunMetadata12) Serialize(encoder *goloxi.Encoder) error {
24014 if err := self.OxmId.Serialize(encoder); err != nil {
24015 return err
24016 }
24017
24018 return nil
24019}
24020
24021func DecodeOxmIdTunMetadata12(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata12, error) {
24022 _oxmidtunmetadata12 := &OxmIdTunMetadata12{OxmId: parent}
24023 return _oxmidtunmetadata12, nil
24024}
24025
24026func NewOxmIdTunMetadata12() *OxmIdTunMetadata12 {
24027 obj := &OxmIdTunMetadata12{
24028 OxmId: NewOxmId(92284),
24029 }
24030 return obj
24031}
24032func (self *OxmIdTunMetadata12) GetOXMName() string {
24033 return "tun_metadata12"
24034}
24035
24036func (self *OxmIdTunMetadata12) MarshalJSON() ([]byte, error) {
24037 if self.TypeLen == 0 {
24038 return []byte("\"\""), nil
24039 } else {
24040 return []byte("\"" + self.GetOXMName() + "\""), nil
24041 }
24042}
24043
24044type OxmIdTunMetadata12Masked struct {
24045 *OxmId
24046}
24047
24048type IOxmIdTunMetadata12Masked interface {
24049 IOxmId
24050}
24051
24052func (self *OxmIdTunMetadata12Masked) Serialize(encoder *goloxi.Encoder) error {
24053 if err := self.OxmId.Serialize(encoder); err != nil {
24054 return err
24055 }
24056
24057 return nil
24058}
24059
24060func DecodeOxmIdTunMetadata12Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata12Masked, error) {
24061 _oxmidtunmetadata12masked := &OxmIdTunMetadata12Masked{OxmId: parent}
24062 return _oxmidtunmetadata12masked, nil
24063}
24064
24065func NewOxmIdTunMetadata12Masked() *OxmIdTunMetadata12Masked {
24066 obj := &OxmIdTunMetadata12Masked{
24067 OxmId: NewOxmId(92664),
24068 }
24069 return obj
24070}
24071func (self *OxmIdTunMetadata12Masked) GetOXMName() string {
24072 return "tun_metadata12_masked"
24073}
24074
24075func (self *OxmIdTunMetadata12Masked) MarshalJSON() ([]byte, error) {
24076 if self.TypeLen == 0 {
24077 return []byte("\"\""), nil
24078 } else {
24079 return []byte("\"" + self.GetOXMName() + "\""), nil
24080 }
24081}
24082
24083type OxmIdTunMetadata13 struct {
24084 *OxmId
24085}
24086
24087type IOxmIdTunMetadata13 interface {
24088 IOxmId
24089}
24090
24091func (self *OxmIdTunMetadata13) Serialize(encoder *goloxi.Encoder) error {
24092 if err := self.OxmId.Serialize(encoder); err != nil {
24093 return err
24094 }
24095
24096 return nil
24097}
24098
24099func DecodeOxmIdTunMetadata13(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata13, error) {
24100 _oxmidtunmetadata13 := &OxmIdTunMetadata13{OxmId: parent}
24101 return _oxmidtunmetadata13, nil
24102}
24103
24104func NewOxmIdTunMetadata13() *OxmIdTunMetadata13 {
24105 obj := &OxmIdTunMetadata13{
24106 OxmId: NewOxmId(92796),
24107 }
24108 return obj
24109}
24110func (self *OxmIdTunMetadata13) GetOXMName() string {
24111 return "tun_metadata13"
24112}
24113
24114func (self *OxmIdTunMetadata13) MarshalJSON() ([]byte, error) {
24115 if self.TypeLen == 0 {
24116 return []byte("\"\""), nil
24117 } else {
24118 return []byte("\"" + self.GetOXMName() + "\""), nil
24119 }
24120}
24121
24122type OxmIdTunMetadata13Masked struct {
24123 *OxmId
24124}
24125
24126type IOxmIdTunMetadata13Masked interface {
24127 IOxmId
24128}
24129
24130func (self *OxmIdTunMetadata13Masked) Serialize(encoder *goloxi.Encoder) error {
24131 if err := self.OxmId.Serialize(encoder); err != nil {
24132 return err
24133 }
24134
24135 return nil
24136}
24137
24138func DecodeOxmIdTunMetadata13Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata13Masked, error) {
24139 _oxmidtunmetadata13masked := &OxmIdTunMetadata13Masked{OxmId: parent}
24140 return _oxmidtunmetadata13masked, nil
24141}
24142
24143func NewOxmIdTunMetadata13Masked() *OxmIdTunMetadata13Masked {
24144 obj := &OxmIdTunMetadata13Masked{
24145 OxmId: NewOxmId(93176),
24146 }
24147 return obj
24148}
24149func (self *OxmIdTunMetadata13Masked) GetOXMName() string {
24150 return "tun_metadata13_masked"
24151}
24152
24153func (self *OxmIdTunMetadata13Masked) MarshalJSON() ([]byte, error) {
24154 if self.TypeLen == 0 {
24155 return []byte("\"\""), nil
24156 } else {
24157 return []byte("\"" + self.GetOXMName() + "\""), nil
24158 }
24159}
24160
24161type OxmIdTunMetadata14 struct {
24162 *OxmId
24163}
24164
24165type IOxmIdTunMetadata14 interface {
24166 IOxmId
24167}
24168
24169func (self *OxmIdTunMetadata14) Serialize(encoder *goloxi.Encoder) error {
24170 if err := self.OxmId.Serialize(encoder); err != nil {
24171 return err
24172 }
24173
24174 return nil
24175}
24176
24177func DecodeOxmIdTunMetadata14(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata14, error) {
24178 _oxmidtunmetadata14 := &OxmIdTunMetadata14{OxmId: parent}
24179 return _oxmidtunmetadata14, nil
24180}
24181
24182func NewOxmIdTunMetadata14() *OxmIdTunMetadata14 {
24183 obj := &OxmIdTunMetadata14{
24184 OxmId: NewOxmId(93308),
24185 }
24186 return obj
24187}
24188func (self *OxmIdTunMetadata14) GetOXMName() string {
24189 return "tun_metadata14"
24190}
24191
24192func (self *OxmIdTunMetadata14) MarshalJSON() ([]byte, error) {
24193 if self.TypeLen == 0 {
24194 return []byte("\"\""), nil
24195 } else {
24196 return []byte("\"" + self.GetOXMName() + "\""), nil
24197 }
24198}
24199
24200type OxmIdTunMetadata14Masked struct {
24201 *OxmId
24202}
24203
24204type IOxmIdTunMetadata14Masked interface {
24205 IOxmId
24206}
24207
24208func (self *OxmIdTunMetadata14Masked) Serialize(encoder *goloxi.Encoder) error {
24209 if err := self.OxmId.Serialize(encoder); err != nil {
24210 return err
24211 }
24212
24213 return nil
24214}
24215
24216func DecodeOxmIdTunMetadata14Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata14Masked, error) {
24217 _oxmidtunmetadata14masked := &OxmIdTunMetadata14Masked{OxmId: parent}
24218 return _oxmidtunmetadata14masked, nil
24219}
24220
24221func NewOxmIdTunMetadata14Masked() *OxmIdTunMetadata14Masked {
24222 obj := &OxmIdTunMetadata14Masked{
24223 OxmId: NewOxmId(93688),
24224 }
24225 return obj
24226}
24227func (self *OxmIdTunMetadata14Masked) GetOXMName() string {
24228 return "tun_metadata14_masked"
24229}
24230
24231func (self *OxmIdTunMetadata14Masked) MarshalJSON() ([]byte, error) {
24232 if self.TypeLen == 0 {
24233 return []byte("\"\""), nil
24234 } else {
24235 return []byte("\"" + self.GetOXMName() + "\""), nil
24236 }
24237}
24238
24239type OxmIdTunMetadata15 struct {
24240 *OxmId
24241}
24242
24243type IOxmIdTunMetadata15 interface {
24244 IOxmId
24245}
24246
24247func (self *OxmIdTunMetadata15) Serialize(encoder *goloxi.Encoder) error {
24248 if err := self.OxmId.Serialize(encoder); err != nil {
24249 return err
24250 }
24251
24252 return nil
24253}
24254
24255func DecodeOxmIdTunMetadata15(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata15, error) {
24256 _oxmidtunmetadata15 := &OxmIdTunMetadata15{OxmId: parent}
24257 return _oxmidtunmetadata15, nil
24258}
24259
24260func NewOxmIdTunMetadata15() *OxmIdTunMetadata15 {
24261 obj := &OxmIdTunMetadata15{
24262 OxmId: NewOxmId(93820),
24263 }
24264 return obj
24265}
24266func (self *OxmIdTunMetadata15) GetOXMName() string {
24267 return "tun_metadata15"
24268}
24269
24270func (self *OxmIdTunMetadata15) MarshalJSON() ([]byte, error) {
24271 if self.TypeLen == 0 {
24272 return []byte("\"\""), nil
24273 } else {
24274 return []byte("\"" + self.GetOXMName() + "\""), nil
24275 }
24276}
24277
24278type OxmIdTunMetadata15Masked struct {
24279 *OxmId
24280}
24281
24282type IOxmIdTunMetadata15Masked interface {
24283 IOxmId
24284}
24285
24286func (self *OxmIdTunMetadata15Masked) Serialize(encoder *goloxi.Encoder) error {
24287 if err := self.OxmId.Serialize(encoder); err != nil {
24288 return err
24289 }
24290
24291 return nil
24292}
24293
24294func DecodeOxmIdTunMetadata15Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata15Masked, error) {
24295 _oxmidtunmetadata15masked := &OxmIdTunMetadata15Masked{OxmId: parent}
24296 return _oxmidtunmetadata15masked, nil
24297}
24298
24299func NewOxmIdTunMetadata15Masked() *OxmIdTunMetadata15Masked {
24300 obj := &OxmIdTunMetadata15Masked{
24301 OxmId: NewOxmId(94200),
24302 }
24303 return obj
24304}
24305func (self *OxmIdTunMetadata15Masked) GetOXMName() string {
24306 return "tun_metadata15_masked"
24307}
24308
24309func (self *OxmIdTunMetadata15Masked) MarshalJSON() ([]byte, error) {
24310 if self.TypeLen == 0 {
24311 return []byte("\"\""), nil
24312 } else {
24313 return []byte("\"" + self.GetOXMName() + "\""), nil
24314 }
24315}
24316
24317type OxmIdTunMetadata16 struct {
24318 *OxmId
24319}
24320
24321type IOxmIdTunMetadata16 interface {
24322 IOxmId
24323}
24324
24325func (self *OxmIdTunMetadata16) Serialize(encoder *goloxi.Encoder) error {
24326 if err := self.OxmId.Serialize(encoder); err != nil {
24327 return err
24328 }
24329
24330 return nil
24331}
24332
24333func DecodeOxmIdTunMetadata16(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata16, error) {
24334 _oxmidtunmetadata16 := &OxmIdTunMetadata16{OxmId: parent}
24335 return _oxmidtunmetadata16, nil
24336}
24337
24338func NewOxmIdTunMetadata16() *OxmIdTunMetadata16 {
24339 obj := &OxmIdTunMetadata16{
24340 OxmId: NewOxmId(94332),
24341 }
24342 return obj
24343}
24344func (self *OxmIdTunMetadata16) GetOXMName() string {
24345 return "tun_metadata16"
24346}
24347
24348func (self *OxmIdTunMetadata16) MarshalJSON() ([]byte, error) {
24349 if self.TypeLen == 0 {
24350 return []byte("\"\""), nil
24351 } else {
24352 return []byte("\"" + self.GetOXMName() + "\""), nil
24353 }
24354}
24355
24356type OxmIdTunMetadata16Masked struct {
24357 *OxmId
24358}
24359
24360type IOxmIdTunMetadata16Masked interface {
24361 IOxmId
24362}
24363
24364func (self *OxmIdTunMetadata16Masked) Serialize(encoder *goloxi.Encoder) error {
24365 if err := self.OxmId.Serialize(encoder); err != nil {
24366 return err
24367 }
24368
24369 return nil
24370}
24371
24372func DecodeOxmIdTunMetadata16Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata16Masked, error) {
24373 _oxmidtunmetadata16masked := &OxmIdTunMetadata16Masked{OxmId: parent}
24374 return _oxmidtunmetadata16masked, nil
24375}
24376
24377func NewOxmIdTunMetadata16Masked() *OxmIdTunMetadata16Masked {
24378 obj := &OxmIdTunMetadata16Masked{
24379 OxmId: NewOxmId(94712),
24380 }
24381 return obj
24382}
24383func (self *OxmIdTunMetadata16Masked) GetOXMName() string {
24384 return "tun_metadata16_masked"
24385}
24386
24387func (self *OxmIdTunMetadata16Masked) MarshalJSON() ([]byte, error) {
24388 if self.TypeLen == 0 {
24389 return []byte("\"\""), nil
24390 } else {
24391 return []byte("\"" + self.GetOXMName() + "\""), nil
24392 }
24393}
24394
24395type OxmIdTunMetadata17 struct {
24396 *OxmId
24397}
24398
24399type IOxmIdTunMetadata17 interface {
24400 IOxmId
24401}
24402
24403func (self *OxmIdTunMetadata17) Serialize(encoder *goloxi.Encoder) error {
24404 if err := self.OxmId.Serialize(encoder); err != nil {
24405 return err
24406 }
24407
24408 return nil
24409}
24410
24411func DecodeOxmIdTunMetadata17(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata17, error) {
24412 _oxmidtunmetadata17 := &OxmIdTunMetadata17{OxmId: parent}
24413 return _oxmidtunmetadata17, nil
24414}
24415
24416func NewOxmIdTunMetadata17() *OxmIdTunMetadata17 {
24417 obj := &OxmIdTunMetadata17{
24418 OxmId: NewOxmId(94844),
24419 }
24420 return obj
24421}
24422func (self *OxmIdTunMetadata17) GetOXMName() string {
24423 return "tun_metadata17"
24424}
24425
24426func (self *OxmIdTunMetadata17) MarshalJSON() ([]byte, error) {
24427 if self.TypeLen == 0 {
24428 return []byte("\"\""), nil
24429 } else {
24430 return []byte("\"" + self.GetOXMName() + "\""), nil
24431 }
24432}
24433
24434type OxmIdTunMetadata17Masked struct {
24435 *OxmId
24436}
24437
24438type IOxmIdTunMetadata17Masked interface {
24439 IOxmId
24440}
24441
24442func (self *OxmIdTunMetadata17Masked) Serialize(encoder *goloxi.Encoder) error {
24443 if err := self.OxmId.Serialize(encoder); err != nil {
24444 return err
24445 }
24446
24447 return nil
24448}
24449
24450func DecodeOxmIdTunMetadata17Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata17Masked, error) {
24451 _oxmidtunmetadata17masked := &OxmIdTunMetadata17Masked{OxmId: parent}
24452 return _oxmidtunmetadata17masked, nil
24453}
24454
24455func NewOxmIdTunMetadata17Masked() *OxmIdTunMetadata17Masked {
24456 obj := &OxmIdTunMetadata17Masked{
24457 OxmId: NewOxmId(95224),
24458 }
24459 return obj
24460}
24461func (self *OxmIdTunMetadata17Masked) GetOXMName() string {
24462 return "tun_metadata17_masked"
24463}
24464
24465func (self *OxmIdTunMetadata17Masked) MarshalJSON() ([]byte, error) {
24466 if self.TypeLen == 0 {
24467 return []byte("\"\""), nil
24468 } else {
24469 return []byte("\"" + self.GetOXMName() + "\""), nil
24470 }
24471}
24472
24473type OxmIdTunMetadata18 struct {
24474 *OxmId
24475}
24476
24477type IOxmIdTunMetadata18 interface {
24478 IOxmId
24479}
24480
24481func (self *OxmIdTunMetadata18) Serialize(encoder *goloxi.Encoder) error {
24482 if err := self.OxmId.Serialize(encoder); err != nil {
24483 return err
24484 }
24485
24486 return nil
24487}
24488
24489func DecodeOxmIdTunMetadata18(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata18, error) {
24490 _oxmidtunmetadata18 := &OxmIdTunMetadata18{OxmId: parent}
24491 return _oxmidtunmetadata18, nil
24492}
24493
24494func NewOxmIdTunMetadata18() *OxmIdTunMetadata18 {
24495 obj := &OxmIdTunMetadata18{
24496 OxmId: NewOxmId(95356),
24497 }
24498 return obj
24499}
24500func (self *OxmIdTunMetadata18) GetOXMName() string {
24501 return "tun_metadata18"
24502}
24503
24504func (self *OxmIdTunMetadata18) MarshalJSON() ([]byte, error) {
24505 if self.TypeLen == 0 {
24506 return []byte("\"\""), nil
24507 } else {
24508 return []byte("\"" + self.GetOXMName() + "\""), nil
24509 }
24510}
24511
24512type OxmIdTunMetadata18Masked struct {
24513 *OxmId
24514}
24515
24516type IOxmIdTunMetadata18Masked interface {
24517 IOxmId
24518}
24519
24520func (self *OxmIdTunMetadata18Masked) Serialize(encoder *goloxi.Encoder) error {
24521 if err := self.OxmId.Serialize(encoder); err != nil {
24522 return err
24523 }
24524
24525 return nil
24526}
24527
24528func DecodeOxmIdTunMetadata18Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata18Masked, error) {
24529 _oxmidtunmetadata18masked := &OxmIdTunMetadata18Masked{OxmId: parent}
24530 return _oxmidtunmetadata18masked, nil
24531}
24532
24533func NewOxmIdTunMetadata18Masked() *OxmIdTunMetadata18Masked {
24534 obj := &OxmIdTunMetadata18Masked{
24535 OxmId: NewOxmId(95736),
24536 }
24537 return obj
24538}
24539func (self *OxmIdTunMetadata18Masked) GetOXMName() string {
24540 return "tun_metadata18_masked"
24541}
24542
24543func (self *OxmIdTunMetadata18Masked) MarshalJSON() ([]byte, error) {
24544 if self.TypeLen == 0 {
24545 return []byte("\"\""), nil
24546 } else {
24547 return []byte("\"" + self.GetOXMName() + "\""), nil
24548 }
24549}
24550
24551type OxmIdTunMetadata19 struct {
24552 *OxmId
24553}
24554
24555type IOxmIdTunMetadata19 interface {
24556 IOxmId
24557}
24558
24559func (self *OxmIdTunMetadata19) Serialize(encoder *goloxi.Encoder) error {
24560 if err := self.OxmId.Serialize(encoder); err != nil {
24561 return err
24562 }
24563
24564 return nil
24565}
24566
24567func DecodeOxmIdTunMetadata19(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata19, error) {
24568 _oxmidtunmetadata19 := &OxmIdTunMetadata19{OxmId: parent}
24569 return _oxmidtunmetadata19, nil
24570}
24571
24572func NewOxmIdTunMetadata19() *OxmIdTunMetadata19 {
24573 obj := &OxmIdTunMetadata19{
24574 OxmId: NewOxmId(95868),
24575 }
24576 return obj
24577}
24578func (self *OxmIdTunMetadata19) GetOXMName() string {
24579 return "tun_metadata19"
24580}
24581
24582func (self *OxmIdTunMetadata19) MarshalJSON() ([]byte, error) {
24583 if self.TypeLen == 0 {
24584 return []byte("\"\""), nil
24585 } else {
24586 return []byte("\"" + self.GetOXMName() + "\""), nil
24587 }
24588}
24589
24590type OxmIdTunMetadata19Masked struct {
24591 *OxmId
24592}
24593
24594type IOxmIdTunMetadata19Masked interface {
24595 IOxmId
24596}
24597
24598func (self *OxmIdTunMetadata19Masked) Serialize(encoder *goloxi.Encoder) error {
24599 if err := self.OxmId.Serialize(encoder); err != nil {
24600 return err
24601 }
24602
24603 return nil
24604}
24605
24606func DecodeOxmIdTunMetadata19Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata19Masked, error) {
24607 _oxmidtunmetadata19masked := &OxmIdTunMetadata19Masked{OxmId: parent}
24608 return _oxmidtunmetadata19masked, nil
24609}
24610
24611func NewOxmIdTunMetadata19Masked() *OxmIdTunMetadata19Masked {
24612 obj := &OxmIdTunMetadata19Masked{
24613 OxmId: NewOxmId(96248),
24614 }
24615 return obj
24616}
24617func (self *OxmIdTunMetadata19Masked) GetOXMName() string {
24618 return "tun_metadata19_masked"
24619}
24620
24621func (self *OxmIdTunMetadata19Masked) MarshalJSON() ([]byte, error) {
24622 if self.TypeLen == 0 {
24623 return []byte("\"\""), nil
24624 } else {
24625 return []byte("\"" + self.GetOXMName() + "\""), nil
24626 }
24627}
24628
24629type OxmIdTunMetadata1Masked struct {
24630 *OxmId
24631}
24632
24633type IOxmIdTunMetadata1Masked interface {
24634 IOxmId
24635}
24636
24637func (self *OxmIdTunMetadata1Masked) Serialize(encoder *goloxi.Encoder) error {
24638 if err := self.OxmId.Serialize(encoder); err != nil {
24639 return err
24640 }
24641
24642 return nil
24643}
24644
24645func DecodeOxmIdTunMetadata1Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata1Masked, error) {
24646 _oxmidtunmetadata1masked := &OxmIdTunMetadata1Masked{OxmId: parent}
24647 return _oxmidtunmetadata1masked, nil
24648}
24649
24650func NewOxmIdTunMetadata1Masked() *OxmIdTunMetadata1Masked {
24651 obj := &OxmIdTunMetadata1Masked{
24652 OxmId: NewOxmId(87032),
24653 }
24654 return obj
24655}
24656func (self *OxmIdTunMetadata1Masked) GetOXMName() string {
24657 return "tun_metadata1_masked"
24658}
24659
24660func (self *OxmIdTunMetadata1Masked) MarshalJSON() ([]byte, error) {
24661 if self.TypeLen == 0 {
24662 return []byte("\"\""), nil
24663 } else {
24664 return []byte("\"" + self.GetOXMName() + "\""), nil
24665 }
24666}
24667
24668type OxmIdTunMetadata2 struct {
24669 *OxmId
24670}
24671
24672type IOxmIdTunMetadata2 interface {
24673 IOxmId
24674}
24675
24676func (self *OxmIdTunMetadata2) Serialize(encoder *goloxi.Encoder) error {
24677 if err := self.OxmId.Serialize(encoder); err != nil {
24678 return err
24679 }
24680
24681 return nil
24682}
24683
24684func DecodeOxmIdTunMetadata2(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata2, error) {
24685 _oxmidtunmetadata2 := &OxmIdTunMetadata2{OxmId: parent}
24686 return _oxmidtunmetadata2, nil
24687}
24688
24689func NewOxmIdTunMetadata2() *OxmIdTunMetadata2 {
24690 obj := &OxmIdTunMetadata2{
24691 OxmId: NewOxmId(87164),
24692 }
24693 return obj
24694}
24695func (self *OxmIdTunMetadata2) GetOXMName() string {
24696 return "tun_metadata2"
24697}
24698
24699func (self *OxmIdTunMetadata2) MarshalJSON() ([]byte, error) {
24700 if self.TypeLen == 0 {
24701 return []byte("\"\""), nil
24702 } else {
24703 return []byte("\"" + self.GetOXMName() + "\""), nil
24704 }
24705}
24706
24707type OxmIdTunMetadata20 struct {
24708 *OxmId
24709}
24710
24711type IOxmIdTunMetadata20 interface {
24712 IOxmId
24713}
24714
24715func (self *OxmIdTunMetadata20) Serialize(encoder *goloxi.Encoder) error {
24716 if err := self.OxmId.Serialize(encoder); err != nil {
24717 return err
24718 }
24719
24720 return nil
24721}
24722
24723func DecodeOxmIdTunMetadata20(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata20, error) {
24724 _oxmidtunmetadata20 := &OxmIdTunMetadata20{OxmId: parent}
24725 return _oxmidtunmetadata20, nil
24726}
24727
24728func NewOxmIdTunMetadata20() *OxmIdTunMetadata20 {
24729 obj := &OxmIdTunMetadata20{
24730 OxmId: NewOxmId(96380),
24731 }
24732 return obj
24733}
24734func (self *OxmIdTunMetadata20) GetOXMName() string {
24735 return "tun_metadata20"
24736}
24737
24738func (self *OxmIdTunMetadata20) MarshalJSON() ([]byte, error) {
24739 if self.TypeLen == 0 {
24740 return []byte("\"\""), nil
24741 } else {
24742 return []byte("\"" + self.GetOXMName() + "\""), nil
24743 }
24744}
24745
24746type OxmIdTunMetadata20Masked struct {
24747 *OxmId
24748}
24749
24750type IOxmIdTunMetadata20Masked interface {
24751 IOxmId
24752}
24753
24754func (self *OxmIdTunMetadata20Masked) Serialize(encoder *goloxi.Encoder) error {
24755 if err := self.OxmId.Serialize(encoder); err != nil {
24756 return err
24757 }
24758
24759 return nil
24760}
24761
24762func DecodeOxmIdTunMetadata20Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata20Masked, error) {
24763 _oxmidtunmetadata20masked := &OxmIdTunMetadata20Masked{OxmId: parent}
24764 return _oxmidtunmetadata20masked, nil
24765}
24766
24767func NewOxmIdTunMetadata20Masked() *OxmIdTunMetadata20Masked {
24768 obj := &OxmIdTunMetadata20Masked{
24769 OxmId: NewOxmId(96760),
24770 }
24771 return obj
24772}
24773func (self *OxmIdTunMetadata20Masked) GetOXMName() string {
24774 return "tun_metadata20_masked"
24775}
24776
24777func (self *OxmIdTunMetadata20Masked) MarshalJSON() ([]byte, error) {
24778 if self.TypeLen == 0 {
24779 return []byte("\"\""), nil
24780 } else {
24781 return []byte("\"" + self.GetOXMName() + "\""), nil
24782 }
24783}
24784
24785type OxmIdTunMetadata21 struct {
24786 *OxmId
24787}
24788
24789type IOxmIdTunMetadata21 interface {
24790 IOxmId
24791}
24792
24793func (self *OxmIdTunMetadata21) Serialize(encoder *goloxi.Encoder) error {
24794 if err := self.OxmId.Serialize(encoder); err != nil {
24795 return err
24796 }
24797
24798 return nil
24799}
24800
24801func DecodeOxmIdTunMetadata21(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata21, error) {
24802 _oxmidtunmetadata21 := &OxmIdTunMetadata21{OxmId: parent}
24803 return _oxmidtunmetadata21, nil
24804}
24805
24806func NewOxmIdTunMetadata21() *OxmIdTunMetadata21 {
24807 obj := &OxmIdTunMetadata21{
24808 OxmId: NewOxmId(96892),
24809 }
24810 return obj
24811}
24812func (self *OxmIdTunMetadata21) GetOXMName() string {
24813 return "tun_metadata21"
24814}
24815
24816func (self *OxmIdTunMetadata21) MarshalJSON() ([]byte, error) {
24817 if self.TypeLen == 0 {
24818 return []byte("\"\""), nil
24819 } else {
24820 return []byte("\"" + self.GetOXMName() + "\""), nil
24821 }
24822}
24823
24824type OxmIdTunMetadata21Masked struct {
24825 *OxmId
24826}
24827
24828type IOxmIdTunMetadata21Masked interface {
24829 IOxmId
24830}
24831
24832func (self *OxmIdTunMetadata21Masked) Serialize(encoder *goloxi.Encoder) error {
24833 if err := self.OxmId.Serialize(encoder); err != nil {
24834 return err
24835 }
24836
24837 return nil
24838}
24839
24840func DecodeOxmIdTunMetadata21Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata21Masked, error) {
24841 _oxmidtunmetadata21masked := &OxmIdTunMetadata21Masked{OxmId: parent}
24842 return _oxmidtunmetadata21masked, nil
24843}
24844
24845func NewOxmIdTunMetadata21Masked() *OxmIdTunMetadata21Masked {
24846 obj := &OxmIdTunMetadata21Masked{
24847 OxmId: NewOxmId(97272),
24848 }
24849 return obj
24850}
24851func (self *OxmIdTunMetadata21Masked) GetOXMName() string {
24852 return "tun_metadata21_masked"
24853}
24854
24855func (self *OxmIdTunMetadata21Masked) MarshalJSON() ([]byte, error) {
24856 if self.TypeLen == 0 {
24857 return []byte("\"\""), nil
24858 } else {
24859 return []byte("\"" + self.GetOXMName() + "\""), nil
24860 }
24861}
24862
24863type OxmIdTunMetadata22 struct {
24864 *OxmId
24865}
24866
24867type IOxmIdTunMetadata22 interface {
24868 IOxmId
24869}
24870
24871func (self *OxmIdTunMetadata22) Serialize(encoder *goloxi.Encoder) error {
24872 if err := self.OxmId.Serialize(encoder); err != nil {
24873 return err
24874 }
24875
24876 return nil
24877}
24878
24879func DecodeOxmIdTunMetadata22(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata22, error) {
24880 _oxmidtunmetadata22 := &OxmIdTunMetadata22{OxmId: parent}
24881 return _oxmidtunmetadata22, nil
24882}
24883
24884func NewOxmIdTunMetadata22() *OxmIdTunMetadata22 {
24885 obj := &OxmIdTunMetadata22{
24886 OxmId: NewOxmId(97404),
24887 }
24888 return obj
24889}
24890func (self *OxmIdTunMetadata22) GetOXMName() string {
24891 return "tun_metadata22"
24892}
24893
24894func (self *OxmIdTunMetadata22) MarshalJSON() ([]byte, error) {
24895 if self.TypeLen == 0 {
24896 return []byte("\"\""), nil
24897 } else {
24898 return []byte("\"" + self.GetOXMName() + "\""), nil
24899 }
24900}
24901
24902type OxmIdTunMetadata22Masked struct {
24903 *OxmId
24904}
24905
24906type IOxmIdTunMetadata22Masked interface {
24907 IOxmId
24908}
24909
24910func (self *OxmIdTunMetadata22Masked) Serialize(encoder *goloxi.Encoder) error {
24911 if err := self.OxmId.Serialize(encoder); err != nil {
24912 return err
24913 }
24914
24915 return nil
24916}
24917
24918func DecodeOxmIdTunMetadata22Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata22Masked, error) {
24919 _oxmidtunmetadata22masked := &OxmIdTunMetadata22Masked{OxmId: parent}
24920 return _oxmidtunmetadata22masked, nil
24921}
24922
24923func NewOxmIdTunMetadata22Masked() *OxmIdTunMetadata22Masked {
24924 obj := &OxmIdTunMetadata22Masked{
24925 OxmId: NewOxmId(97784),
24926 }
24927 return obj
24928}
24929func (self *OxmIdTunMetadata22Masked) GetOXMName() string {
24930 return "tun_metadata22_masked"
24931}
24932
24933func (self *OxmIdTunMetadata22Masked) MarshalJSON() ([]byte, error) {
24934 if self.TypeLen == 0 {
24935 return []byte("\"\""), nil
24936 } else {
24937 return []byte("\"" + self.GetOXMName() + "\""), nil
24938 }
24939}
24940
24941type OxmIdTunMetadata23 struct {
24942 *OxmId
24943}
24944
24945type IOxmIdTunMetadata23 interface {
24946 IOxmId
24947}
24948
24949func (self *OxmIdTunMetadata23) Serialize(encoder *goloxi.Encoder) error {
24950 if err := self.OxmId.Serialize(encoder); err != nil {
24951 return err
24952 }
24953
24954 return nil
24955}
24956
24957func DecodeOxmIdTunMetadata23(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata23, error) {
24958 _oxmidtunmetadata23 := &OxmIdTunMetadata23{OxmId: parent}
24959 return _oxmidtunmetadata23, nil
24960}
24961
24962func NewOxmIdTunMetadata23() *OxmIdTunMetadata23 {
24963 obj := &OxmIdTunMetadata23{
24964 OxmId: NewOxmId(97916),
24965 }
24966 return obj
24967}
24968func (self *OxmIdTunMetadata23) GetOXMName() string {
24969 return "tun_metadata23"
24970}
24971
24972func (self *OxmIdTunMetadata23) MarshalJSON() ([]byte, error) {
24973 if self.TypeLen == 0 {
24974 return []byte("\"\""), nil
24975 } else {
24976 return []byte("\"" + self.GetOXMName() + "\""), nil
24977 }
24978}
24979
24980type OxmIdTunMetadata23Masked struct {
24981 *OxmId
24982}
24983
24984type IOxmIdTunMetadata23Masked interface {
24985 IOxmId
24986}
24987
24988func (self *OxmIdTunMetadata23Masked) Serialize(encoder *goloxi.Encoder) error {
24989 if err := self.OxmId.Serialize(encoder); err != nil {
24990 return err
24991 }
24992
24993 return nil
24994}
24995
24996func DecodeOxmIdTunMetadata23Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata23Masked, error) {
24997 _oxmidtunmetadata23masked := &OxmIdTunMetadata23Masked{OxmId: parent}
24998 return _oxmidtunmetadata23masked, nil
24999}
25000
25001func NewOxmIdTunMetadata23Masked() *OxmIdTunMetadata23Masked {
25002 obj := &OxmIdTunMetadata23Masked{
25003 OxmId: NewOxmId(98296),
25004 }
25005 return obj
25006}
25007func (self *OxmIdTunMetadata23Masked) GetOXMName() string {
25008 return "tun_metadata23_masked"
25009}
25010
25011func (self *OxmIdTunMetadata23Masked) MarshalJSON() ([]byte, error) {
25012 if self.TypeLen == 0 {
25013 return []byte("\"\""), nil
25014 } else {
25015 return []byte("\"" + self.GetOXMName() + "\""), nil
25016 }
25017}
25018
25019type OxmIdTunMetadata24 struct {
25020 *OxmId
25021}
25022
25023type IOxmIdTunMetadata24 interface {
25024 IOxmId
25025}
25026
25027func (self *OxmIdTunMetadata24) Serialize(encoder *goloxi.Encoder) error {
25028 if err := self.OxmId.Serialize(encoder); err != nil {
25029 return err
25030 }
25031
25032 return nil
25033}
25034
25035func DecodeOxmIdTunMetadata24(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata24, error) {
25036 _oxmidtunmetadata24 := &OxmIdTunMetadata24{OxmId: parent}
25037 return _oxmidtunmetadata24, nil
25038}
25039
25040func NewOxmIdTunMetadata24() *OxmIdTunMetadata24 {
25041 obj := &OxmIdTunMetadata24{
25042 OxmId: NewOxmId(98428),
25043 }
25044 return obj
25045}
25046func (self *OxmIdTunMetadata24) GetOXMName() string {
25047 return "tun_metadata24"
25048}
25049
25050func (self *OxmIdTunMetadata24) MarshalJSON() ([]byte, error) {
25051 if self.TypeLen == 0 {
25052 return []byte("\"\""), nil
25053 } else {
25054 return []byte("\"" + self.GetOXMName() + "\""), nil
25055 }
25056}
25057
25058type OxmIdTunMetadata24Masked struct {
25059 *OxmId
25060}
25061
25062type IOxmIdTunMetadata24Masked interface {
25063 IOxmId
25064}
25065
25066func (self *OxmIdTunMetadata24Masked) Serialize(encoder *goloxi.Encoder) error {
25067 if err := self.OxmId.Serialize(encoder); err != nil {
25068 return err
25069 }
25070
25071 return nil
25072}
25073
25074func DecodeOxmIdTunMetadata24Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata24Masked, error) {
25075 _oxmidtunmetadata24masked := &OxmIdTunMetadata24Masked{OxmId: parent}
25076 return _oxmidtunmetadata24masked, nil
25077}
25078
25079func NewOxmIdTunMetadata24Masked() *OxmIdTunMetadata24Masked {
25080 obj := &OxmIdTunMetadata24Masked{
25081 OxmId: NewOxmId(98808),
25082 }
25083 return obj
25084}
25085func (self *OxmIdTunMetadata24Masked) GetOXMName() string {
25086 return "tun_metadata24_masked"
25087}
25088
25089func (self *OxmIdTunMetadata24Masked) MarshalJSON() ([]byte, error) {
25090 if self.TypeLen == 0 {
25091 return []byte("\"\""), nil
25092 } else {
25093 return []byte("\"" + self.GetOXMName() + "\""), nil
25094 }
25095}
25096
25097type OxmIdTunMetadata25 struct {
25098 *OxmId
25099}
25100
25101type IOxmIdTunMetadata25 interface {
25102 IOxmId
25103}
25104
25105func (self *OxmIdTunMetadata25) Serialize(encoder *goloxi.Encoder) error {
25106 if err := self.OxmId.Serialize(encoder); err != nil {
25107 return err
25108 }
25109
25110 return nil
25111}
25112
25113func DecodeOxmIdTunMetadata25(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata25, error) {
25114 _oxmidtunmetadata25 := &OxmIdTunMetadata25{OxmId: parent}
25115 return _oxmidtunmetadata25, nil
25116}
25117
25118func NewOxmIdTunMetadata25() *OxmIdTunMetadata25 {
25119 obj := &OxmIdTunMetadata25{
25120 OxmId: NewOxmId(98940),
25121 }
25122 return obj
25123}
25124func (self *OxmIdTunMetadata25) GetOXMName() string {
25125 return "tun_metadata25"
25126}
25127
25128func (self *OxmIdTunMetadata25) MarshalJSON() ([]byte, error) {
25129 if self.TypeLen == 0 {
25130 return []byte("\"\""), nil
25131 } else {
25132 return []byte("\"" + self.GetOXMName() + "\""), nil
25133 }
25134}
25135
25136type OxmIdTunMetadata25Masked struct {
25137 *OxmId
25138}
25139
25140type IOxmIdTunMetadata25Masked interface {
25141 IOxmId
25142}
25143
25144func (self *OxmIdTunMetadata25Masked) Serialize(encoder *goloxi.Encoder) error {
25145 if err := self.OxmId.Serialize(encoder); err != nil {
25146 return err
25147 }
25148
25149 return nil
25150}
25151
25152func DecodeOxmIdTunMetadata25Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata25Masked, error) {
25153 _oxmidtunmetadata25masked := &OxmIdTunMetadata25Masked{OxmId: parent}
25154 return _oxmidtunmetadata25masked, nil
25155}
25156
25157func NewOxmIdTunMetadata25Masked() *OxmIdTunMetadata25Masked {
25158 obj := &OxmIdTunMetadata25Masked{
25159 OxmId: NewOxmId(99320),
25160 }
25161 return obj
25162}
25163func (self *OxmIdTunMetadata25Masked) GetOXMName() string {
25164 return "tun_metadata25_masked"
25165}
25166
25167func (self *OxmIdTunMetadata25Masked) MarshalJSON() ([]byte, error) {
25168 if self.TypeLen == 0 {
25169 return []byte("\"\""), nil
25170 } else {
25171 return []byte("\"" + self.GetOXMName() + "\""), nil
25172 }
25173}
25174
25175type OxmIdTunMetadata26 struct {
25176 *OxmId
25177}
25178
25179type IOxmIdTunMetadata26 interface {
25180 IOxmId
25181}
25182
25183func (self *OxmIdTunMetadata26) Serialize(encoder *goloxi.Encoder) error {
25184 if err := self.OxmId.Serialize(encoder); err != nil {
25185 return err
25186 }
25187
25188 return nil
25189}
25190
25191func DecodeOxmIdTunMetadata26(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata26, error) {
25192 _oxmidtunmetadata26 := &OxmIdTunMetadata26{OxmId: parent}
25193 return _oxmidtunmetadata26, nil
25194}
25195
25196func NewOxmIdTunMetadata26() *OxmIdTunMetadata26 {
25197 obj := &OxmIdTunMetadata26{
25198 OxmId: NewOxmId(99452),
25199 }
25200 return obj
25201}
25202func (self *OxmIdTunMetadata26) GetOXMName() string {
25203 return "tun_metadata26"
25204}
25205
25206func (self *OxmIdTunMetadata26) MarshalJSON() ([]byte, error) {
25207 if self.TypeLen == 0 {
25208 return []byte("\"\""), nil
25209 } else {
25210 return []byte("\"" + self.GetOXMName() + "\""), nil
25211 }
25212}
25213
25214type OxmIdTunMetadata26Masked struct {
25215 *OxmId
25216}
25217
25218type IOxmIdTunMetadata26Masked interface {
25219 IOxmId
25220}
25221
25222func (self *OxmIdTunMetadata26Masked) Serialize(encoder *goloxi.Encoder) error {
25223 if err := self.OxmId.Serialize(encoder); err != nil {
25224 return err
25225 }
25226
25227 return nil
25228}
25229
25230func DecodeOxmIdTunMetadata26Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata26Masked, error) {
25231 _oxmidtunmetadata26masked := &OxmIdTunMetadata26Masked{OxmId: parent}
25232 return _oxmidtunmetadata26masked, nil
25233}
25234
25235func NewOxmIdTunMetadata26Masked() *OxmIdTunMetadata26Masked {
25236 obj := &OxmIdTunMetadata26Masked{
25237 OxmId: NewOxmId(99832),
25238 }
25239 return obj
25240}
25241func (self *OxmIdTunMetadata26Masked) GetOXMName() string {
25242 return "tun_metadata26_masked"
25243}
25244
25245func (self *OxmIdTunMetadata26Masked) MarshalJSON() ([]byte, error) {
25246 if self.TypeLen == 0 {
25247 return []byte("\"\""), nil
25248 } else {
25249 return []byte("\"" + self.GetOXMName() + "\""), nil
25250 }
25251}
25252
25253type OxmIdTunMetadata27 struct {
25254 *OxmId
25255}
25256
25257type IOxmIdTunMetadata27 interface {
25258 IOxmId
25259}
25260
25261func (self *OxmIdTunMetadata27) Serialize(encoder *goloxi.Encoder) error {
25262 if err := self.OxmId.Serialize(encoder); err != nil {
25263 return err
25264 }
25265
25266 return nil
25267}
25268
25269func DecodeOxmIdTunMetadata27(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata27, error) {
25270 _oxmidtunmetadata27 := &OxmIdTunMetadata27{OxmId: parent}
25271 return _oxmidtunmetadata27, nil
25272}
25273
25274func NewOxmIdTunMetadata27() *OxmIdTunMetadata27 {
25275 obj := &OxmIdTunMetadata27{
25276 OxmId: NewOxmId(99964),
25277 }
25278 return obj
25279}
25280func (self *OxmIdTunMetadata27) GetOXMName() string {
25281 return "tun_metadata27"
25282}
25283
25284func (self *OxmIdTunMetadata27) MarshalJSON() ([]byte, error) {
25285 if self.TypeLen == 0 {
25286 return []byte("\"\""), nil
25287 } else {
25288 return []byte("\"" + self.GetOXMName() + "\""), nil
25289 }
25290}
25291
25292type OxmIdTunMetadata27Masked struct {
25293 *OxmId
25294}
25295
25296type IOxmIdTunMetadata27Masked interface {
25297 IOxmId
25298}
25299
25300func (self *OxmIdTunMetadata27Masked) Serialize(encoder *goloxi.Encoder) error {
25301 if err := self.OxmId.Serialize(encoder); err != nil {
25302 return err
25303 }
25304
25305 return nil
25306}
25307
25308func DecodeOxmIdTunMetadata27Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata27Masked, error) {
25309 _oxmidtunmetadata27masked := &OxmIdTunMetadata27Masked{OxmId: parent}
25310 return _oxmidtunmetadata27masked, nil
25311}
25312
25313func NewOxmIdTunMetadata27Masked() *OxmIdTunMetadata27Masked {
25314 obj := &OxmIdTunMetadata27Masked{
25315 OxmId: NewOxmId(100344),
25316 }
25317 return obj
25318}
25319func (self *OxmIdTunMetadata27Masked) GetOXMName() string {
25320 return "tun_metadata27_masked"
25321}
25322
25323func (self *OxmIdTunMetadata27Masked) MarshalJSON() ([]byte, error) {
25324 if self.TypeLen == 0 {
25325 return []byte("\"\""), nil
25326 } else {
25327 return []byte("\"" + self.GetOXMName() + "\""), nil
25328 }
25329}
25330
25331type OxmIdTunMetadata28 struct {
25332 *OxmId
25333}
25334
25335type IOxmIdTunMetadata28 interface {
25336 IOxmId
25337}
25338
25339func (self *OxmIdTunMetadata28) Serialize(encoder *goloxi.Encoder) error {
25340 if err := self.OxmId.Serialize(encoder); err != nil {
25341 return err
25342 }
25343
25344 return nil
25345}
25346
25347func DecodeOxmIdTunMetadata28(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata28, error) {
25348 _oxmidtunmetadata28 := &OxmIdTunMetadata28{OxmId: parent}
25349 return _oxmidtunmetadata28, nil
25350}
25351
25352func NewOxmIdTunMetadata28() *OxmIdTunMetadata28 {
25353 obj := &OxmIdTunMetadata28{
25354 OxmId: NewOxmId(100476),
25355 }
25356 return obj
25357}
25358func (self *OxmIdTunMetadata28) GetOXMName() string {
25359 return "tun_metadata28"
25360}
25361
25362func (self *OxmIdTunMetadata28) MarshalJSON() ([]byte, error) {
25363 if self.TypeLen == 0 {
25364 return []byte("\"\""), nil
25365 } else {
25366 return []byte("\"" + self.GetOXMName() + "\""), nil
25367 }
25368}
25369
25370type OxmIdTunMetadata28Masked struct {
25371 *OxmId
25372}
25373
25374type IOxmIdTunMetadata28Masked interface {
25375 IOxmId
25376}
25377
25378func (self *OxmIdTunMetadata28Masked) Serialize(encoder *goloxi.Encoder) error {
25379 if err := self.OxmId.Serialize(encoder); err != nil {
25380 return err
25381 }
25382
25383 return nil
25384}
25385
25386func DecodeOxmIdTunMetadata28Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata28Masked, error) {
25387 _oxmidtunmetadata28masked := &OxmIdTunMetadata28Masked{OxmId: parent}
25388 return _oxmidtunmetadata28masked, nil
25389}
25390
25391func NewOxmIdTunMetadata28Masked() *OxmIdTunMetadata28Masked {
25392 obj := &OxmIdTunMetadata28Masked{
25393 OxmId: NewOxmId(100856),
25394 }
25395 return obj
25396}
25397func (self *OxmIdTunMetadata28Masked) GetOXMName() string {
25398 return "tun_metadata28_masked"
25399}
25400
25401func (self *OxmIdTunMetadata28Masked) MarshalJSON() ([]byte, error) {
25402 if self.TypeLen == 0 {
25403 return []byte("\"\""), nil
25404 } else {
25405 return []byte("\"" + self.GetOXMName() + "\""), nil
25406 }
25407}
25408
25409type OxmIdTunMetadata29 struct {
25410 *OxmId
25411}
25412
25413type IOxmIdTunMetadata29 interface {
25414 IOxmId
25415}
25416
25417func (self *OxmIdTunMetadata29) Serialize(encoder *goloxi.Encoder) error {
25418 if err := self.OxmId.Serialize(encoder); err != nil {
25419 return err
25420 }
25421
25422 return nil
25423}
25424
25425func DecodeOxmIdTunMetadata29(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata29, error) {
25426 _oxmidtunmetadata29 := &OxmIdTunMetadata29{OxmId: parent}
25427 return _oxmidtunmetadata29, nil
25428}
25429
25430func NewOxmIdTunMetadata29() *OxmIdTunMetadata29 {
25431 obj := &OxmIdTunMetadata29{
25432 OxmId: NewOxmId(100988),
25433 }
25434 return obj
25435}
25436func (self *OxmIdTunMetadata29) GetOXMName() string {
25437 return "tun_metadata29"
25438}
25439
25440func (self *OxmIdTunMetadata29) MarshalJSON() ([]byte, error) {
25441 if self.TypeLen == 0 {
25442 return []byte("\"\""), nil
25443 } else {
25444 return []byte("\"" + self.GetOXMName() + "\""), nil
25445 }
25446}
25447
25448type OxmIdTunMetadata29Masked struct {
25449 *OxmId
25450}
25451
25452type IOxmIdTunMetadata29Masked interface {
25453 IOxmId
25454}
25455
25456func (self *OxmIdTunMetadata29Masked) Serialize(encoder *goloxi.Encoder) error {
25457 if err := self.OxmId.Serialize(encoder); err != nil {
25458 return err
25459 }
25460
25461 return nil
25462}
25463
25464func DecodeOxmIdTunMetadata29Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata29Masked, error) {
25465 _oxmidtunmetadata29masked := &OxmIdTunMetadata29Masked{OxmId: parent}
25466 return _oxmidtunmetadata29masked, nil
25467}
25468
25469func NewOxmIdTunMetadata29Masked() *OxmIdTunMetadata29Masked {
25470 obj := &OxmIdTunMetadata29Masked{
25471 OxmId: NewOxmId(101368),
25472 }
25473 return obj
25474}
25475func (self *OxmIdTunMetadata29Masked) GetOXMName() string {
25476 return "tun_metadata29_masked"
25477}
25478
25479func (self *OxmIdTunMetadata29Masked) MarshalJSON() ([]byte, error) {
25480 if self.TypeLen == 0 {
25481 return []byte("\"\""), nil
25482 } else {
25483 return []byte("\"" + self.GetOXMName() + "\""), nil
25484 }
25485}
25486
25487type OxmIdTunMetadata2Masked struct {
25488 *OxmId
25489}
25490
25491type IOxmIdTunMetadata2Masked interface {
25492 IOxmId
25493}
25494
25495func (self *OxmIdTunMetadata2Masked) Serialize(encoder *goloxi.Encoder) error {
25496 if err := self.OxmId.Serialize(encoder); err != nil {
25497 return err
25498 }
25499
25500 return nil
25501}
25502
25503func DecodeOxmIdTunMetadata2Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata2Masked, error) {
25504 _oxmidtunmetadata2masked := &OxmIdTunMetadata2Masked{OxmId: parent}
25505 return _oxmidtunmetadata2masked, nil
25506}
25507
25508func NewOxmIdTunMetadata2Masked() *OxmIdTunMetadata2Masked {
25509 obj := &OxmIdTunMetadata2Masked{
25510 OxmId: NewOxmId(87544),
25511 }
25512 return obj
25513}
25514func (self *OxmIdTunMetadata2Masked) GetOXMName() string {
25515 return "tun_metadata2_masked"
25516}
25517
25518func (self *OxmIdTunMetadata2Masked) MarshalJSON() ([]byte, error) {
25519 if self.TypeLen == 0 {
25520 return []byte("\"\""), nil
25521 } else {
25522 return []byte("\"" + self.GetOXMName() + "\""), nil
25523 }
25524}
25525
25526type OxmIdTunMetadata3 struct {
25527 *OxmId
25528}
25529
25530type IOxmIdTunMetadata3 interface {
25531 IOxmId
25532}
25533
25534func (self *OxmIdTunMetadata3) Serialize(encoder *goloxi.Encoder) error {
25535 if err := self.OxmId.Serialize(encoder); err != nil {
25536 return err
25537 }
25538
25539 return nil
25540}
25541
25542func DecodeOxmIdTunMetadata3(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata3, error) {
25543 _oxmidtunmetadata3 := &OxmIdTunMetadata3{OxmId: parent}
25544 return _oxmidtunmetadata3, nil
25545}
25546
25547func NewOxmIdTunMetadata3() *OxmIdTunMetadata3 {
25548 obj := &OxmIdTunMetadata3{
25549 OxmId: NewOxmId(87676),
25550 }
25551 return obj
25552}
25553func (self *OxmIdTunMetadata3) GetOXMName() string {
25554 return "tun_metadata3"
25555}
25556
25557func (self *OxmIdTunMetadata3) MarshalJSON() ([]byte, error) {
25558 if self.TypeLen == 0 {
25559 return []byte("\"\""), nil
25560 } else {
25561 return []byte("\"" + self.GetOXMName() + "\""), nil
25562 }
25563}
25564
25565type OxmIdTunMetadata30 struct {
25566 *OxmId
25567}
25568
25569type IOxmIdTunMetadata30 interface {
25570 IOxmId
25571}
25572
25573func (self *OxmIdTunMetadata30) Serialize(encoder *goloxi.Encoder) error {
25574 if err := self.OxmId.Serialize(encoder); err != nil {
25575 return err
25576 }
25577
25578 return nil
25579}
25580
25581func DecodeOxmIdTunMetadata30(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata30, error) {
25582 _oxmidtunmetadata30 := &OxmIdTunMetadata30{OxmId: parent}
25583 return _oxmidtunmetadata30, nil
25584}
25585
25586func NewOxmIdTunMetadata30() *OxmIdTunMetadata30 {
25587 obj := &OxmIdTunMetadata30{
25588 OxmId: NewOxmId(101500),
25589 }
25590 return obj
25591}
25592func (self *OxmIdTunMetadata30) GetOXMName() string {
25593 return "tun_metadata30"
25594}
25595
25596func (self *OxmIdTunMetadata30) MarshalJSON() ([]byte, error) {
25597 if self.TypeLen == 0 {
25598 return []byte("\"\""), nil
25599 } else {
25600 return []byte("\"" + self.GetOXMName() + "\""), nil
25601 }
25602}
25603
25604type OxmIdTunMetadata30Masked struct {
25605 *OxmId
25606}
25607
25608type IOxmIdTunMetadata30Masked interface {
25609 IOxmId
25610}
25611
25612func (self *OxmIdTunMetadata30Masked) Serialize(encoder *goloxi.Encoder) error {
25613 if err := self.OxmId.Serialize(encoder); err != nil {
25614 return err
25615 }
25616
25617 return nil
25618}
25619
25620func DecodeOxmIdTunMetadata30Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata30Masked, error) {
25621 _oxmidtunmetadata30masked := &OxmIdTunMetadata30Masked{OxmId: parent}
25622 return _oxmidtunmetadata30masked, nil
25623}
25624
25625func NewOxmIdTunMetadata30Masked() *OxmIdTunMetadata30Masked {
25626 obj := &OxmIdTunMetadata30Masked{
25627 OxmId: NewOxmId(101880),
25628 }
25629 return obj
25630}
25631func (self *OxmIdTunMetadata30Masked) GetOXMName() string {
25632 return "tun_metadata30_masked"
25633}
25634
25635func (self *OxmIdTunMetadata30Masked) MarshalJSON() ([]byte, error) {
25636 if self.TypeLen == 0 {
25637 return []byte("\"\""), nil
25638 } else {
25639 return []byte("\"" + self.GetOXMName() + "\""), nil
25640 }
25641}
25642
25643type OxmIdTunMetadata31 struct {
25644 *OxmId
25645}
25646
25647type IOxmIdTunMetadata31 interface {
25648 IOxmId
25649}
25650
25651func (self *OxmIdTunMetadata31) Serialize(encoder *goloxi.Encoder) error {
25652 if err := self.OxmId.Serialize(encoder); err != nil {
25653 return err
25654 }
25655
25656 return nil
25657}
25658
25659func DecodeOxmIdTunMetadata31(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata31, error) {
25660 _oxmidtunmetadata31 := &OxmIdTunMetadata31{OxmId: parent}
25661 return _oxmidtunmetadata31, nil
25662}
25663
25664func NewOxmIdTunMetadata31() *OxmIdTunMetadata31 {
25665 obj := &OxmIdTunMetadata31{
25666 OxmId: NewOxmId(102012),
25667 }
25668 return obj
25669}
25670func (self *OxmIdTunMetadata31) GetOXMName() string {
25671 return "tun_metadata31"
25672}
25673
25674func (self *OxmIdTunMetadata31) MarshalJSON() ([]byte, error) {
25675 if self.TypeLen == 0 {
25676 return []byte("\"\""), nil
25677 } else {
25678 return []byte("\"" + self.GetOXMName() + "\""), nil
25679 }
25680}
25681
25682type OxmIdTunMetadata31Masked struct {
25683 *OxmId
25684}
25685
25686type IOxmIdTunMetadata31Masked interface {
25687 IOxmId
25688}
25689
25690func (self *OxmIdTunMetadata31Masked) Serialize(encoder *goloxi.Encoder) error {
25691 if err := self.OxmId.Serialize(encoder); err != nil {
25692 return err
25693 }
25694
25695 return nil
25696}
25697
25698func DecodeOxmIdTunMetadata31Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata31Masked, error) {
25699 _oxmidtunmetadata31masked := &OxmIdTunMetadata31Masked{OxmId: parent}
25700 return _oxmidtunmetadata31masked, nil
25701}
25702
25703func NewOxmIdTunMetadata31Masked() *OxmIdTunMetadata31Masked {
25704 obj := &OxmIdTunMetadata31Masked{
25705 OxmId: NewOxmId(102392),
25706 }
25707 return obj
25708}
25709func (self *OxmIdTunMetadata31Masked) GetOXMName() string {
25710 return "tun_metadata31_masked"
25711}
25712
25713func (self *OxmIdTunMetadata31Masked) MarshalJSON() ([]byte, error) {
25714 if self.TypeLen == 0 {
25715 return []byte("\"\""), nil
25716 } else {
25717 return []byte("\"" + self.GetOXMName() + "\""), nil
25718 }
25719}
25720
25721type OxmIdTunMetadata32 struct {
25722 *OxmId
25723}
25724
25725type IOxmIdTunMetadata32 interface {
25726 IOxmId
25727}
25728
25729func (self *OxmIdTunMetadata32) Serialize(encoder *goloxi.Encoder) error {
25730 if err := self.OxmId.Serialize(encoder); err != nil {
25731 return err
25732 }
25733
25734 return nil
25735}
25736
25737func DecodeOxmIdTunMetadata32(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata32, error) {
25738 _oxmidtunmetadata32 := &OxmIdTunMetadata32{OxmId: parent}
25739 return _oxmidtunmetadata32, nil
25740}
25741
25742func NewOxmIdTunMetadata32() *OxmIdTunMetadata32 {
25743 obj := &OxmIdTunMetadata32{
25744 OxmId: NewOxmId(102524),
25745 }
25746 return obj
25747}
25748func (self *OxmIdTunMetadata32) GetOXMName() string {
25749 return "tun_metadata32"
25750}
25751
25752func (self *OxmIdTunMetadata32) MarshalJSON() ([]byte, error) {
25753 if self.TypeLen == 0 {
25754 return []byte("\"\""), nil
25755 } else {
25756 return []byte("\"" + self.GetOXMName() + "\""), nil
25757 }
25758}
25759
25760type OxmIdTunMetadata32Masked struct {
25761 *OxmId
25762}
25763
25764type IOxmIdTunMetadata32Masked interface {
25765 IOxmId
25766}
25767
25768func (self *OxmIdTunMetadata32Masked) Serialize(encoder *goloxi.Encoder) error {
25769 if err := self.OxmId.Serialize(encoder); err != nil {
25770 return err
25771 }
25772
25773 return nil
25774}
25775
25776func DecodeOxmIdTunMetadata32Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata32Masked, error) {
25777 _oxmidtunmetadata32masked := &OxmIdTunMetadata32Masked{OxmId: parent}
25778 return _oxmidtunmetadata32masked, nil
25779}
25780
25781func NewOxmIdTunMetadata32Masked() *OxmIdTunMetadata32Masked {
25782 obj := &OxmIdTunMetadata32Masked{
25783 OxmId: NewOxmId(102904),
25784 }
25785 return obj
25786}
25787func (self *OxmIdTunMetadata32Masked) GetOXMName() string {
25788 return "tun_metadata32_masked"
25789}
25790
25791func (self *OxmIdTunMetadata32Masked) MarshalJSON() ([]byte, error) {
25792 if self.TypeLen == 0 {
25793 return []byte("\"\""), nil
25794 } else {
25795 return []byte("\"" + self.GetOXMName() + "\""), nil
25796 }
25797}
25798
25799type OxmIdTunMetadata33 struct {
25800 *OxmId
25801}
25802
25803type IOxmIdTunMetadata33 interface {
25804 IOxmId
25805}
25806
25807func (self *OxmIdTunMetadata33) Serialize(encoder *goloxi.Encoder) error {
25808 if err := self.OxmId.Serialize(encoder); err != nil {
25809 return err
25810 }
25811
25812 return nil
25813}
25814
25815func DecodeOxmIdTunMetadata33(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata33, error) {
25816 _oxmidtunmetadata33 := &OxmIdTunMetadata33{OxmId: parent}
25817 return _oxmidtunmetadata33, nil
25818}
25819
25820func NewOxmIdTunMetadata33() *OxmIdTunMetadata33 {
25821 obj := &OxmIdTunMetadata33{
25822 OxmId: NewOxmId(103036),
25823 }
25824 return obj
25825}
25826func (self *OxmIdTunMetadata33) GetOXMName() string {
25827 return "tun_metadata33"
25828}
25829
25830func (self *OxmIdTunMetadata33) MarshalJSON() ([]byte, error) {
25831 if self.TypeLen == 0 {
25832 return []byte("\"\""), nil
25833 } else {
25834 return []byte("\"" + self.GetOXMName() + "\""), nil
25835 }
25836}
25837
25838type OxmIdTunMetadata33Masked struct {
25839 *OxmId
25840}
25841
25842type IOxmIdTunMetadata33Masked interface {
25843 IOxmId
25844}
25845
25846func (self *OxmIdTunMetadata33Masked) Serialize(encoder *goloxi.Encoder) error {
25847 if err := self.OxmId.Serialize(encoder); err != nil {
25848 return err
25849 }
25850
25851 return nil
25852}
25853
25854func DecodeOxmIdTunMetadata33Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata33Masked, error) {
25855 _oxmidtunmetadata33masked := &OxmIdTunMetadata33Masked{OxmId: parent}
25856 return _oxmidtunmetadata33masked, nil
25857}
25858
25859func NewOxmIdTunMetadata33Masked() *OxmIdTunMetadata33Masked {
25860 obj := &OxmIdTunMetadata33Masked{
25861 OxmId: NewOxmId(103416),
25862 }
25863 return obj
25864}
25865func (self *OxmIdTunMetadata33Masked) GetOXMName() string {
25866 return "tun_metadata33_masked"
25867}
25868
25869func (self *OxmIdTunMetadata33Masked) MarshalJSON() ([]byte, error) {
25870 if self.TypeLen == 0 {
25871 return []byte("\"\""), nil
25872 } else {
25873 return []byte("\"" + self.GetOXMName() + "\""), nil
25874 }
25875}
25876
25877type OxmIdTunMetadata34 struct {
25878 *OxmId
25879}
25880
25881type IOxmIdTunMetadata34 interface {
25882 IOxmId
25883}
25884
25885func (self *OxmIdTunMetadata34) Serialize(encoder *goloxi.Encoder) error {
25886 if err := self.OxmId.Serialize(encoder); err != nil {
25887 return err
25888 }
25889
25890 return nil
25891}
25892
25893func DecodeOxmIdTunMetadata34(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata34, error) {
25894 _oxmidtunmetadata34 := &OxmIdTunMetadata34{OxmId: parent}
25895 return _oxmidtunmetadata34, nil
25896}
25897
25898func NewOxmIdTunMetadata34() *OxmIdTunMetadata34 {
25899 obj := &OxmIdTunMetadata34{
25900 OxmId: NewOxmId(103548),
25901 }
25902 return obj
25903}
25904func (self *OxmIdTunMetadata34) GetOXMName() string {
25905 return "tun_metadata34"
25906}
25907
25908func (self *OxmIdTunMetadata34) MarshalJSON() ([]byte, error) {
25909 if self.TypeLen == 0 {
25910 return []byte("\"\""), nil
25911 } else {
25912 return []byte("\"" + self.GetOXMName() + "\""), nil
25913 }
25914}
25915
25916type OxmIdTunMetadata34Masked struct {
25917 *OxmId
25918}
25919
25920type IOxmIdTunMetadata34Masked interface {
25921 IOxmId
25922}
25923
25924func (self *OxmIdTunMetadata34Masked) Serialize(encoder *goloxi.Encoder) error {
25925 if err := self.OxmId.Serialize(encoder); err != nil {
25926 return err
25927 }
25928
25929 return nil
25930}
25931
25932func DecodeOxmIdTunMetadata34Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata34Masked, error) {
25933 _oxmidtunmetadata34masked := &OxmIdTunMetadata34Masked{OxmId: parent}
25934 return _oxmidtunmetadata34masked, nil
25935}
25936
25937func NewOxmIdTunMetadata34Masked() *OxmIdTunMetadata34Masked {
25938 obj := &OxmIdTunMetadata34Masked{
25939 OxmId: NewOxmId(103928),
25940 }
25941 return obj
25942}
25943func (self *OxmIdTunMetadata34Masked) GetOXMName() string {
25944 return "tun_metadata34_masked"
25945}
25946
25947func (self *OxmIdTunMetadata34Masked) MarshalJSON() ([]byte, error) {
25948 if self.TypeLen == 0 {
25949 return []byte("\"\""), nil
25950 } else {
25951 return []byte("\"" + self.GetOXMName() + "\""), nil
25952 }
25953}
25954
25955type OxmIdTunMetadata35 struct {
25956 *OxmId
25957}
25958
25959type IOxmIdTunMetadata35 interface {
25960 IOxmId
25961}
25962
25963func (self *OxmIdTunMetadata35) Serialize(encoder *goloxi.Encoder) error {
25964 if err := self.OxmId.Serialize(encoder); err != nil {
25965 return err
25966 }
25967
25968 return nil
25969}
25970
25971func DecodeOxmIdTunMetadata35(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata35, error) {
25972 _oxmidtunmetadata35 := &OxmIdTunMetadata35{OxmId: parent}
25973 return _oxmidtunmetadata35, nil
25974}
25975
25976func NewOxmIdTunMetadata35() *OxmIdTunMetadata35 {
25977 obj := &OxmIdTunMetadata35{
25978 OxmId: NewOxmId(104060),
25979 }
25980 return obj
25981}
25982func (self *OxmIdTunMetadata35) GetOXMName() string {
25983 return "tun_metadata35"
25984}
25985
25986func (self *OxmIdTunMetadata35) MarshalJSON() ([]byte, error) {
25987 if self.TypeLen == 0 {
25988 return []byte("\"\""), nil
25989 } else {
25990 return []byte("\"" + self.GetOXMName() + "\""), nil
25991 }
25992}
25993
25994type OxmIdTunMetadata35Masked struct {
25995 *OxmId
25996}
25997
25998type IOxmIdTunMetadata35Masked interface {
25999 IOxmId
26000}
26001
26002func (self *OxmIdTunMetadata35Masked) Serialize(encoder *goloxi.Encoder) error {
26003 if err := self.OxmId.Serialize(encoder); err != nil {
26004 return err
26005 }
26006
26007 return nil
26008}
26009
26010func DecodeOxmIdTunMetadata35Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata35Masked, error) {
26011 _oxmidtunmetadata35masked := &OxmIdTunMetadata35Masked{OxmId: parent}
26012 return _oxmidtunmetadata35masked, nil
26013}
26014
26015func NewOxmIdTunMetadata35Masked() *OxmIdTunMetadata35Masked {
26016 obj := &OxmIdTunMetadata35Masked{
26017 OxmId: NewOxmId(104440),
26018 }
26019 return obj
26020}
26021func (self *OxmIdTunMetadata35Masked) GetOXMName() string {
26022 return "tun_metadata35_masked"
26023}
26024
26025func (self *OxmIdTunMetadata35Masked) MarshalJSON() ([]byte, error) {
26026 if self.TypeLen == 0 {
26027 return []byte("\"\""), nil
26028 } else {
26029 return []byte("\"" + self.GetOXMName() + "\""), nil
26030 }
26031}
26032
26033type OxmIdTunMetadata36 struct {
26034 *OxmId
26035}
26036
26037type IOxmIdTunMetadata36 interface {
26038 IOxmId
26039}
26040
26041func (self *OxmIdTunMetadata36) Serialize(encoder *goloxi.Encoder) error {
26042 if err := self.OxmId.Serialize(encoder); err != nil {
26043 return err
26044 }
26045
26046 return nil
26047}
26048
26049func DecodeOxmIdTunMetadata36(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata36, error) {
26050 _oxmidtunmetadata36 := &OxmIdTunMetadata36{OxmId: parent}
26051 return _oxmidtunmetadata36, nil
26052}
26053
26054func NewOxmIdTunMetadata36() *OxmIdTunMetadata36 {
26055 obj := &OxmIdTunMetadata36{
26056 OxmId: NewOxmId(104572),
26057 }
26058 return obj
26059}
26060func (self *OxmIdTunMetadata36) GetOXMName() string {
26061 return "tun_metadata36"
26062}
26063
26064func (self *OxmIdTunMetadata36) MarshalJSON() ([]byte, error) {
26065 if self.TypeLen == 0 {
26066 return []byte("\"\""), nil
26067 } else {
26068 return []byte("\"" + self.GetOXMName() + "\""), nil
26069 }
26070}
26071
26072type OxmIdTunMetadata36Masked struct {
26073 *OxmId
26074}
26075
26076type IOxmIdTunMetadata36Masked interface {
26077 IOxmId
26078}
26079
26080func (self *OxmIdTunMetadata36Masked) Serialize(encoder *goloxi.Encoder) error {
26081 if err := self.OxmId.Serialize(encoder); err != nil {
26082 return err
26083 }
26084
26085 return nil
26086}
26087
26088func DecodeOxmIdTunMetadata36Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata36Masked, error) {
26089 _oxmidtunmetadata36masked := &OxmIdTunMetadata36Masked{OxmId: parent}
26090 return _oxmidtunmetadata36masked, nil
26091}
26092
26093func NewOxmIdTunMetadata36Masked() *OxmIdTunMetadata36Masked {
26094 obj := &OxmIdTunMetadata36Masked{
26095 OxmId: NewOxmId(104952),
26096 }
26097 return obj
26098}
26099func (self *OxmIdTunMetadata36Masked) GetOXMName() string {
26100 return "tun_metadata36_masked"
26101}
26102
26103func (self *OxmIdTunMetadata36Masked) MarshalJSON() ([]byte, error) {
26104 if self.TypeLen == 0 {
26105 return []byte("\"\""), nil
26106 } else {
26107 return []byte("\"" + self.GetOXMName() + "\""), nil
26108 }
26109}
26110
26111type OxmIdTunMetadata37 struct {
26112 *OxmId
26113}
26114
26115type IOxmIdTunMetadata37 interface {
26116 IOxmId
26117}
26118
26119func (self *OxmIdTunMetadata37) Serialize(encoder *goloxi.Encoder) error {
26120 if err := self.OxmId.Serialize(encoder); err != nil {
26121 return err
26122 }
26123
26124 return nil
26125}
26126
26127func DecodeOxmIdTunMetadata37(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata37, error) {
26128 _oxmidtunmetadata37 := &OxmIdTunMetadata37{OxmId: parent}
26129 return _oxmidtunmetadata37, nil
26130}
26131
26132func NewOxmIdTunMetadata37() *OxmIdTunMetadata37 {
26133 obj := &OxmIdTunMetadata37{
26134 OxmId: NewOxmId(105084),
26135 }
26136 return obj
26137}
26138func (self *OxmIdTunMetadata37) GetOXMName() string {
26139 return "tun_metadata37"
26140}
26141
26142func (self *OxmIdTunMetadata37) MarshalJSON() ([]byte, error) {
26143 if self.TypeLen == 0 {
26144 return []byte("\"\""), nil
26145 } else {
26146 return []byte("\"" + self.GetOXMName() + "\""), nil
26147 }
26148}
26149
26150type OxmIdTunMetadata37Masked struct {
26151 *OxmId
26152}
26153
26154type IOxmIdTunMetadata37Masked interface {
26155 IOxmId
26156}
26157
26158func (self *OxmIdTunMetadata37Masked) Serialize(encoder *goloxi.Encoder) error {
26159 if err := self.OxmId.Serialize(encoder); err != nil {
26160 return err
26161 }
26162
26163 return nil
26164}
26165
26166func DecodeOxmIdTunMetadata37Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata37Masked, error) {
26167 _oxmidtunmetadata37masked := &OxmIdTunMetadata37Masked{OxmId: parent}
26168 return _oxmidtunmetadata37masked, nil
26169}
26170
26171func NewOxmIdTunMetadata37Masked() *OxmIdTunMetadata37Masked {
26172 obj := &OxmIdTunMetadata37Masked{
26173 OxmId: NewOxmId(105464),
26174 }
26175 return obj
26176}
26177func (self *OxmIdTunMetadata37Masked) GetOXMName() string {
26178 return "tun_metadata37_masked"
26179}
26180
26181func (self *OxmIdTunMetadata37Masked) MarshalJSON() ([]byte, error) {
26182 if self.TypeLen == 0 {
26183 return []byte("\"\""), nil
26184 } else {
26185 return []byte("\"" + self.GetOXMName() + "\""), nil
26186 }
26187}
26188
26189type OxmIdTunMetadata38 struct {
26190 *OxmId
26191}
26192
26193type IOxmIdTunMetadata38 interface {
26194 IOxmId
26195}
26196
26197func (self *OxmIdTunMetadata38) Serialize(encoder *goloxi.Encoder) error {
26198 if err := self.OxmId.Serialize(encoder); err != nil {
26199 return err
26200 }
26201
26202 return nil
26203}
26204
26205func DecodeOxmIdTunMetadata38(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata38, error) {
26206 _oxmidtunmetadata38 := &OxmIdTunMetadata38{OxmId: parent}
26207 return _oxmidtunmetadata38, nil
26208}
26209
26210func NewOxmIdTunMetadata38() *OxmIdTunMetadata38 {
26211 obj := &OxmIdTunMetadata38{
26212 OxmId: NewOxmId(105596),
26213 }
26214 return obj
26215}
26216func (self *OxmIdTunMetadata38) GetOXMName() string {
26217 return "tun_metadata38"
26218}
26219
26220func (self *OxmIdTunMetadata38) MarshalJSON() ([]byte, error) {
26221 if self.TypeLen == 0 {
26222 return []byte("\"\""), nil
26223 } else {
26224 return []byte("\"" + self.GetOXMName() + "\""), nil
26225 }
26226}
26227
26228type OxmIdTunMetadata38Masked struct {
26229 *OxmId
26230}
26231
26232type IOxmIdTunMetadata38Masked interface {
26233 IOxmId
26234}
26235
26236func (self *OxmIdTunMetadata38Masked) Serialize(encoder *goloxi.Encoder) error {
26237 if err := self.OxmId.Serialize(encoder); err != nil {
26238 return err
26239 }
26240
26241 return nil
26242}
26243
26244func DecodeOxmIdTunMetadata38Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata38Masked, error) {
26245 _oxmidtunmetadata38masked := &OxmIdTunMetadata38Masked{OxmId: parent}
26246 return _oxmidtunmetadata38masked, nil
26247}
26248
26249func NewOxmIdTunMetadata38Masked() *OxmIdTunMetadata38Masked {
26250 obj := &OxmIdTunMetadata38Masked{
26251 OxmId: NewOxmId(105976),
26252 }
26253 return obj
26254}
26255func (self *OxmIdTunMetadata38Masked) GetOXMName() string {
26256 return "tun_metadata38_masked"
26257}
26258
26259func (self *OxmIdTunMetadata38Masked) MarshalJSON() ([]byte, error) {
26260 if self.TypeLen == 0 {
26261 return []byte("\"\""), nil
26262 } else {
26263 return []byte("\"" + self.GetOXMName() + "\""), nil
26264 }
26265}
26266
26267type OxmIdTunMetadata39 struct {
26268 *OxmId
26269}
26270
26271type IOxmIdTunMetadata39 interface {
26272 IOxmId
26273}
26274
26275func (self *OxmIdTunMetadata39) Serialize(encoder *goloxi.Encoder) error {
26276 if err := self.OxmId.Serialize(encoder); err != nil {
26277 return err
26278 }
26279
26280 return nil
26281}
26282
26283func DecodeOxmIdTunMetadata39(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata39, error) {
26284 _oxmidtunmetadata39 := &OxmIdTunMetadata39{OxmId: parent}
26285 return _oxmidtunmetadata39, nil
26286}
26287
26288func NewOxmIdTunMetadata39() *OxmIdTunMetadata39 {
26289 obj := &OxmIdTunMetadata39{
26290 OxmId: NewOxmId(106108),
26291 }
26292 return obj
26293}
26294func (self *OxmIdTunMetadata39) GetOXMName() string {
26295 return "tun_metadata39"
26296}
26297
26298func (self *OxmIdTunMetadata39) MarshalJSON() ([]byte, error) {
26299 if self.TypeLen == 0 {
26300 return []byte("\"\""), nil
26301 } else {
26302 return []byte("\"" + self.GetOXMName() + "\""), nil
26303 }
26304}
26305
26306type OxmIdTunMetadata39Masked struct {
26307 *OxmId
26308}
26309
26310type IOxmIdTunMetadata39Masked interface {
26311 IOxmId
26312}
26313
26314func (self *OxmIdTunMetadata39Masked) Serialize(encoder *goloxi.Encoder) error {
26315 if err := self.OxmId.Serialize(encoder); err != nil {
26316 return err
26317 }
26318
26319 return nil
26320}
26321
26322func DecodeOxmIdTunMetadata39Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata39Masked, error) {
26323 _oxmidtunmetadata39masked := &OxmIdTunMetadata39Masked{OxmId: parent}
26324 return _oxmidtunmetadata39masked, nil
26325}
26326
26327func NewOxmIdTunMetadata39Masked() *OxmIdTunMetadata39Masked {
26328 obj := &OxmIdTunMetadata39Masked{
26329 OxmId: NewOxmId(106488),
26330 }
26331 return obj
26332}
26333func (self *OxmIdTunMetadata39Masked) GetOXMName() string {
26334 return "tun_metadata39_masked"
26335}
26336
26337func (self *OxmIdTunMetadata39Masked) MarshalJSON() ([]byte, error) {
26338 if self.TypeLen == 0 {
26339 return []byte("\"\""), nil
26340 } else {
26341 return []byte("\"" + self.GetOXMName() + "\""), nil
26342 }
26343}
26344
26345type OxmIdTunMetadata3Masked struct {
26346 *OxmId
26347}
26348
26349type IOxmIdTunMetadata3Masked interface {
26350 IOxmId
26351}
26352
26353func (self *OxmIdTunMetadata3Masked) Serialize(encoder *goloxi.Encoder) error {
26354 if err := self.OxmId.Serialize(encoder); err != nil {
26355 return err
26356 }
26357
26358 return nil
26359}
26360
26361func DecodeOxmIdTunMetadata3Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata3Masked, error) {
26362 _oxmidtunmetadata3masked := &OxmIdTunMetadata3Masked{OxmId: parent}
26363 return _oxmidtunmetadata3masked, nil
26364}
26365
26366func NewOxmIdTunMetadata3Masked() *OxmIdTunMetadata3Masked {
26367 obj := &OxmIdTunMetadata3Masked{
26368 OxmId: NewOxmId(88056),
26369 }
26370 return obj
26371}
26372func (self *OxmIdTunMetadata3Masked) GetOXMName() string {
26373 return "tun_metadata3_masked"
26374}
26375
26376func (self *OxmIdTunMetadata3Masked) MarshalJSON() ([]byte, error) {
26377 if self.TypeLen == 0 {
26378 return []byte("\"\""), nil
26379 } else {
26380 return []byte("\"" + self.GetOXMName() + "\""), nil
26381 }
26382}
26383
26384type OxmIdTunMetadata4 struct {
26385 *OxmId
26386}
26387
26388type IOxmIdTunMetadata4 interface {
26389 IOxmId
26390}
26391
26392func (self *OxmIdTunMetadata4) Serialize(encoder *goloxi.Encoder) error {
26393 if err := self.OxmId.Serialize(encoder); err != nil {
26394 return err
26395 }
26396
26397 return nil
26398}
26399
26400func DecodeOxmIdTunMetadata4(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata4, error) {
26401 _oxmidtunmetadata4 := &OxmIdTunMetadata4{OxmId: parent}
26402 return _oxmidtunmetadata4, nil
26403}
26404
26405func NewOxmIdTunMetadata4() *OxmIdTunMetadata4 {
26406 obj := &OxmIdTunMetadata4{
26407 OxmId: NewOxmId(88188),
26408 }
26409 return obj
26410}
26411func (self *OxmIdTunMetadata4) GetOXMName() string {
26412 return "tun_metadata4"
26413}
26414
26415func (self *OxmIdTunMetadata4) MarshalJSON() ([]byte, error) {
26416 if self.TypeLen == 0 {
26417 return []byte("\"\""), nil
26418 } else {
26419 return []byte("\"" + self.GetOXMName() + "\""), nil
26420 }
26421}
26422
26423type OxmIdTunMetadata40 struct {
26424 *OxmId
26425}
26426
26427type IOxmIdTunMetadata40 interface {
26428 IOxmId
26429}
26430
26431func (self *OxmIdTunMetadata40) Serialize(encoder *goloxi.Encoder) error {
26432 if err := self.OxmId.Serialize(encoder); err != nil {
26433 return err
26434 }
26435
26436 return nil
26437}
26438
26439func DecodeOxmIdTunMetadata40(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata40, error) {
26440 _oxmidtunmetadata40 := &OxmIdTunMetadata40{OxmId: parent}
26441 return _oxmidtunmetadata40, nil
26442}
26443
26444func NewOxmIdTunMetadata40() *OxmIdTunMetadata40 {
26445 obj := &OxmIdTunMetadata40{
26446 OxmId: NewOxmId(106620),
26447 }
26448 return obj
26449}
26450func (self *OxmIdTunMetadata40) GetOXMName() string {
26451 return "tun_metadata40"
26452}
26453
26454func (self *OxmIdTunMetadata40) MarshalJSON() ([]byte, error) {
26455 if self.TypeLen == 0 {
26456 return []byte("\"\""), nil
26457 } else {
26458 return []byte("\"" + self.GetOXMName() + "\""), nil
26459 }
26460}
26461
26462type OxmIdTunMetadata40Masked struct {
26463 *OxmId
26464}
26465
26466type IOxmIdTunMetadata40Masked interface {
26467 IOxmId
26468}
26469
26470func (self *OxmIdTunMetadata40Masked) Serialize(encoder *goloxi.Encoder) error {
26471 if err := self.OxmId.Serialize(encoder); err != nil {
26472 return err
26473 }
26474
26475 return nil
26476}
26477
26478func DecodeOxmIdTunMetadata40Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata40Masked, error) {
26479 _oxmidtunmetadata40masked := &OxmIdTunMetadata40Masked{OxmId: parent}
26480 return _oxmidtunmetadata40masked, nil
26481}
26482
26483func NewOxmIdTunMetadata40Masked() *OxmIdTunMetadata40Masked {
26484 obj := &OxmIdTunMetadata40Masked{
26485 OxmId: NewOxmId(107000),
26486 }
26487 return obj
26488}
26489func (self *OxmIdTunMetadata40Masked) GetOXMName() string {
26490 return "tun_metadata40_masked"
26491}
26492
26493func (self *OxmIdTunMetadata40Masked) MarshalJSON() ([]byte, error) {
26494 if self.TypeLen == 0 {
26495 return []byte("\"\""), nil
26496 } else {
26497 return []byte("\"" + self.GetOXMName() + "\""), nil
26498 }
26499}
26500
26501type OxmIdTunMetadata41 struct {
26502 *OxmId
26503}
26504
26505type IOxmIdTunMetadata41 interface {
26506 IOxmId
26507}
26508
26509func (self *OxmIdTunMetadata41) Serialize(encoder *goloxi.Encoder) error {
26510 if err := self.OxmId.Serialize(encoder); err != nil {
26511 return err
26512 }
26513
26514 return nil
26515}
26516
26517func DecodeOxmIdTunMetadata41(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata41, error) {
26518 _oxmidtunmetadata41 := &OxmIdTunMetadata41{OxmId: parent}
26519 return _oxmidtunmetadata41, nil
26520}
26521
26522func NewOxmIdTunMetadata41() *OxmIdTunMetadata41 {
26523 obj := &OxmIdTunMetadata41{
26524 OxmId: NewOxmId(107132),
26525 }
26526 return obj
26527}
26528func (self *OxmIdTunMetadata41) GetOXMName() string {
26529 return "tun_metadata41"
26530}
26531
26532func (self *OxmIdTunMetadata41) MarshalJSON() ([]byte, error) {
26533 if self.TypeLen == 0 {
26534 return []byte("\"\""), nil
26535 } else {
26536 return []byte("\"" + self.GetOXMName() + "\""), nil
26537 }
26538}
26539
26540type OxmIdTunMetadata41Masked struct {
26541 *OxmId
26542}
26543
26544type IOxmIdTunMetadata41Masked interface {
26545 IOxmId
26546}
26547
26548func (self *OxmIdTunMetadata41Masked) Serialize(encoder *goloxi.Encoder) error {
26549 if err := self.OxmId.Serialize(encoder); err != nil {
26550 return err
26551 }
26552
26553 return nil
26554}
26555
26556func DecodeOxmIdTunMetadata41Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata41Masked, error) {
26557 _oxmidtunmetadata41masked := &OxmIdTunMetadata41Masked{OxmId: parent}
26558 return _oxmidtunmetadata41masked, nil
26559}
26560
26561func NewOxmIdTunMetadata41Masked() *OxmIdTunMetadata41Masked {
26562 obj := &OxmIdTunMetadata41Masked{
26563 OxmId: NewOxmId(107512),
26564 }
26565 return obj
26566}
26567func (self *OxmIdTunMetadata41Masked) GetOXMName() string {
26568 return "tun_metadata41_masked"
26569}
26570
26571func (self *OxmIdTunMetadata41Masked) MarshalJSON() ([]byte, error) {
26572 if self.TypeLen == 0 {
26573 return []byte("\"\""), nil
26574 } else {
26575 return []byte("\"" + self.GetOXMName() + "\""), nil
26576 }
26577}
26578
26579type OxmIdTunMetadata42 struct {
26580 *OxmId
26581}
26582
26583type IOxmIdTunMetadata42 interface {
26584 IOxmId
26585}
26586
26587func (self *OxmIdTunMetadata42) Serialize(encoder *goloxi.Encoder) error {
26588 if err := self.OxmId.Serialize(encoder); err != nil {
26589 return err
26590 }
26591
26592 return nil
26593}
26594
26595func DecodeOxmIdTunMetadata42(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata42, error) {
26596 _oxmidtunmetadata42 := &OxmIdTunMetadata42{OxmId: parent}
26597 return _oxmidtunmetadata42, nil
26598}
26599
26600func NewOxmIdTunMetadata42() *OxmIdTunMetadata42 {
26601 obj := &OxmIdTunMetadata42{
26602 OxmId: NewOxmId(107644),
26603 }
26604 return obj
26605}
26606func (self *OxmIdTunMetadata42) GetOXMName() string {
26607 return "tun_metadata42"
26608}
26609
26610func (self *OxmIdTunMetadata42) MarshalJSON() ([]byte, error) {
26611 if self.TypeLen == 0 {
26612 return []byte("\"\""), nil
26613 } else {
26614 return []byte("\"" + self.GetOXMName() + "\""), nil
26615 }
26616}
26617
26618type OxmIdTunMetadata42Masked struct {
26619 *OxmId
26620}
26621
26622type IOxmIdTunMetadata42Masked interface {
26623 IOxmId
26624}
26625
26626func (self *OxmIdTunMetadata42Masked) Serialize(encoder *goloxi.Encoder) error {
26627 if err := self.OxmId.Serialize(encoder); err != nil {
26628 return err
26629 }
26630
26631 return nil
26632}
26633
26634func DecodeOxmIdTunMetadata42Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata42Masked, error) {
26635 _oxmidtunmetadata42masked := &OxmIdTunMetadata42Masked{OxmId: parent}
26636 return _oxmidtunmetadata42masked, nil
26637}
26638
26639func NewOxmIdTunMetadata42Masked() *OxmIdTunMetadata42Masked {
26640 obj := &OxmIdTunMetadata42Masked{
26641 OxmId: NewOxmId(108024),
26642 }
26643 return obj
26644}
26645func (self *OxmIdTunMetadata42Masked) GetOXMName() string {
26646 return "tun_metadata42_masked"
26647}
26648
26649func (self *OxmIdTunMetadata42Masked) MarshalJSON() ([]byte, error) {
26650 if self.TypeLen == 0 {
26651 return []byte("\"\""), nil
26652 } else {
26653 return []byte("\"" + self.GetOXMName() + "\""), nil
26654 }
26655}
26656
26657type OxmIdTunMetadata43 struct {
26658 *OxmId
26659}
26660
26661type IOxmIdTunMetadata43 interface {
26662 IOxmId
26663}
26664
26665func (self *OxmIdTunMetadata43) Serialize(encoder *goloxi.Encoder) error {
26666 if err := self.OxmId.Serialize(encoder); err != nil {
26667 return err
26668 }
26669
26670 return nil
26671}
26672
26673func DecodeOxmIdTunMetadata43(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata43, error) {
26674 _oxmidtunmetadata43 := &OxmIdTunMetadata43{OxmId: parent}
26675 return _oxmidtunmetadata43, nil
26676}
26677
26678func NewOxmIdTunMetadata43() *OxmIdTunMetadata43 {
26679 obj := &OxmIdTunMetadata43{
26680 OxmId: NewOxmId(108156),
26681 }
26682 return obj
26683}
26684func (self *OxmIdTunMetadata43) GetOXMName() string {
26685 return "tun_metadata43"
26686}
26687
26688func (self *OxmIdTunMetadata43) MarshalJSON() ([]byte, error) {
26689 if self.TypeLen == 0 {
26690 return []byte("\"\""), nil
26691 } else {
26692 return []byte("\"" + self.GetOXMName() + "\""), nil
26693 }
26694}
26695
26696type OxmIdTunMetadata43Masked struct {
26697 *OxmId
26698}
26699
26700type IOxmIdTunMetadata43Masked interface {
26701 IOxmId
26702}
26703
26704func (self *OxmIdTunMetadata43Masked) Serialize(encoder *goloxi.Encoder) error {
26705 if err := self.OxmId.Serialize(encoder); err != nil {
26706 return err
26707 }
26708
26709 return nil
26710}
26711
26712func DecodeOxmIdTunMetadata43Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata43Masked, error) {
26713 _oxmidtunmetadata43masked := &OxmIdTunMetadata43Masked{OxmId: parent}
26714 return _oxmidtunmetadata43masked, nil
26715}
26716
26717func NewOxmIdTunMetadata43Masked() *OxmIdTunMetadata43Masked {
26718 obj := &OxmIdTunMetadata43Masked{
26719 OxmId: NewOxmId(108536),
26720 }
26721 return obj
26722}
26723func (self *OxmIdTunMetadata43Masked) GetOXMName() string {
26724 return "tun_metadata43_masked"
26725}
26726
26727func (self *OxmIdTunMetadata43Masked) MarshalJSON() ([]byte, error) {
26728 if self.TypeLen == 0 {
26729 return []byte("\"\""), nil
26730 } else {
26731 return []byte("\"" + self.GetOXMName() + "\""), nil
26732 }
26733}
26734
26735type OxmIdTunMetadata44 struct {
26736 *OxmId
26737}
26738
26739type IOxmIdTunMetadata44 interface {
26740 IOxmId
26741}
26742
26743func (self *OxmIdTunMetadata44) Serialize(encoder *goloxi.Encoder) error {
26744 if err := self.OxmId.Serialize(encoder); err != nil {
26745 return err
26746 }
26747
26748 return nil
26749}
26750
26751func DecodeOxmIdTunMetadata44(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata44, error) {
26752 _oxmidtunmetadata44 := &OxmIdTunMetadata44{OxmId: parent}
26753 return _oxmidtunmetadata44, nil
26754}
26755
26756func NewOxmIdTunMetadata44() *OxmIdTunMetadata44 {
26757 obj := &OxmIdTunMetadata44{
26758 OxmId: NewOxmId(108668),
26759 }
26760 return obj
26761}
26762func (self *OxmIdTunMetadata44) GetOXMName() string {
26763 return "tun_metadata44"
26764}
26765
26766func (self *OxmIdTunMetadata44) MarshalJSON() ([]byte, error) {
26767 if self.TypeLen == 0 {
26768 return []byte("\"\""), nil
26769 } else {
26770 return []byte("\"" + self.GetOXMName() + "\""), nil
26771 }
26772}
26773
26774type OxmIdTunMetadata44Masked struct {
26775 *OxmId
26776}
26777
26778type IOxmIdTunMetadata44Masked interface {
26779 IOxmId
26780}
26781
26782func (self *OxmIdTunMetadata44Masked) Serialize(encoder *goloxi.Encoder) error {
26783 if err := self.OxmId.Serialize(encoder); err != nil {
26784 return err
26785 }
26786
26787 return nil
26788}
26789
26790func DecodeOxmIdTunMetadata44Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata44Masked, error) {
26791 _oxmidtunmetadata44masked := &OxmIdTunMetadata44Masked{OxmId: parent}
26792 return _oxmidtunmetadata44masked, nil
26793}
26794
26795func NewOxmIdTunMetadata44Masked() *OxmIdTunMetadata44Masked {
26796 obj := &OxmIdTunMetadata44Masked{
26797 OxmId: NewOxmId(109048),
26798 }
26799 return obj
26800}
26801func (self *OxmIdTunMetadata44Masked) GetOXMName() string {
26802 return "tun_metadata44_masked"
26803}
26804
26805func (self *OxmIdTunMetadata44Masked) MarshalJSON() ([]byte, error) {
26806 if self.TypeLen == 0 {
26807 return []byte("\"\""), nil
26808 } else {
26809 return []byte("\"" + self.GetOXMName() + "\""), nil
26810 }
26811}
26812
26813type OxmIdTunMetadata45 struct {
26814 *OxmId
26815}
26816
26817type IOxmIdTunMetadata45 interface {
26818 IOxmId
26819}
26820
26821func (self *OxmIdTunMetadata45) Serialize(encoder *goloxi.Encoder) error {
26822 if err := self.OxmId.Serialize(encoder); err != nil {
26823 return err
26824 }
26825
26826 return nil
26827}
26828
26829func DecodeOxmIdTunMetadata45(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata45, error) {
26830 _oxmidtunmetadata45 := &OxmIdTunMetadata45{OxmId: parent}
26831 return _oxmidtunmetadata45, nil
26832}
26833
26834func NewOxmIdTunMetadata45() *OxmIdTunMetadata45 {
26835 obj := &OxmIdTunMetadata45{
26836 OxmId: NewOxmId(109180),
26837 }
26838 return obj
26839}
26840func (self *OxmIdTunMetadata45) GetOXMName() string {
26841 return "tun_metadata45"
26842}
26843
26844func (self *OxmIdTunMetadata45) MarshalJSON() ([]byte, error) {
26845 if self.TypeLen == 0 {
26846 return []byte("\"\""), nil
26847 } else {
26848 return []byte("\"" + self.GetOXMName() + "\""), nil
26849 }
26850}
26851
26852type OxmIdTunMetadata45Masked struct {
26853 *OxmId
26854}
26855
26856type IOxmIdTunMetadata45Masked interface {
26857 IOxmId
26858}
26859
26860func (self *OxmIdTunMetadata45Masked) Serialize(encoder *goloxi.Encoder) error {
26861 if err := self.OxmId.Serialize(encoder); err != nil {
26862 return err
26863 }
26864
26865 return nil
26866}
26867
26868func DecodeOxmIdTunMetadata45Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata45Masked, error) {
26869 _oxmidtunmetadata45masked := &OxmIdTunMetadata45Masked{OxmId: parent}
26870 return _oxmidtunmetadata45masked, nil
26871}
26872
26873func NewOxmIdTunMetadata45Masked() *OxmIdTunMetadata45Masked {
26874 obj := &OxmIdTunMetadata45Masked{
26875 OxmId: NewOxmId(109560),
26876 }
26877 return obj
26878}
26879func (self *OxmIdTunMetadata45Masked) GetOXMName() string {
26880 return "tun_metadata45_masked"
26881}
26882
26883func (self *OxmIdTunMetadata45Masked) MarshalJSON() ([]byte, error) {
26884 if self.TypeLen == 0 {
26885 return []byte("\"\""), nil
26886 } else {
26887 return []byte("\"" + self.GetOXMName() + "\""), nil
26888 }
26889}
26890
26891type OxmIdTunMetadata46 struct {
26892 *OxmId
26893}
26894
26895type IOxmIdTunMetadata46 interface {
26896 IOxmId
26897}
26898
26899func (self *OxmIdTunMetadata46) Serialize(encoder *goloxi.Encoder) error {
26900 if err := self.OxmId.Serialize(encoder); err != nil {
26901 return err
26902 }
26903
26904 return nil
26905}
26906
26907func DecodeOxmIdTunMetadata46(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata46, error) {
26908 _oxmidtunmetadata46 := &OxmIdTunMetadata46{OxmId: parent}
26909 return _oxmidtunmetadata46, nil
26910}
26911
26912func NewOxmIdTunMetadata46() *OxmIdTunMetadata46 {
26913 obj := &OxmIdTunMetadata46{
26914 OxmId: NewOxmId(109692),
26915 }
26916 return obj
26917}
26918func (self *OxmIdTunMetadata46) GetOXMName() string {
26919 return "tun_metadata46"
26920}
26921
26922func (self *OxmIdTunMetadata46) MarshalJSON() ([]byte, error) {
26923 if self.TypeLen == 0 {
26924 return []byte("\"\""), nil
26925 } else {
26926 return []byte("\"" + self.GetOXMName() + "\""), nil
26927 }
26928}
26929
26930type OxmIdTunMetadata46Masked struct {
26931 *OxmId
26932}
26933
26934type IOxmIdTunMetadata46Masked interface {
26935 IOxmId
26936}
26937
26938func (self *OxmIdTunMetadata46Masked) Serialize(encoder *goloxi.Encoder) error {
26939 if err := self.OxmId.Serialize(encoder); err != nil {
26940 return err
26941 }
26942
26943 return nil
26944}
26945
26946func DecodeOxmIdTunMetadata46Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata46Masked, error) {
26947 _oxmidtunmetadata46masked := &OxmIdTunMetadata46Masked{OxmId: parent}
26948 return _oxmidtunmetadata46masked, nil
26949}
26950
26951func NewOxmIdTunMetadata46Masked() *OxmIdTunMetadata46Masked {
26952 obj := &OxmIdTunMetadata46Masked{
26953 OxmId: NewOxmId(110072),
26954 }
26955 return obj
26956}
26957func (self *OxmIdTunMetadata46Masked) GetOXMName() string {
26958 return "tun_metadata46_masked"
26959}
26960
26961func (self *OxmIdTunMetadata46Masked) MarshalJSON() ([]byte, error) {
26962 if self.TypeLen == 0 {
26963 return []byte("\"\""), nil
26964 } else {
26965 return []byte("\"" + self.GetOXMName() + "\""), nil
26966 }
26967}
26968
26969type OxmIdTunMetadata47 struct {
26970 *OxmId
26971}
26972
26973type IOxmIdTunMetadata47 interface {
26974 IOxmId
26975}
26976
26977func (self *OxmIdTunMetadata47) Serialize(encoder *goloxi.Encoder) error {
26978 if err := self.OxmId.Serialize(encoder); err != nil {
26979 return err
26980 }
26981
26982 return nil
26983}
26984
26985func DecodeOxmIdTunMetadata47(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata47, error) {
26986 _oxmidtunmetadata47 := &OxmIdTunMetadata47{OxmId: parent}
26987 return _oxmidtunmetadata47, nil
26988}
26989
26990func NewOxmIdTunMetadata47() *OxmIdTunMetadata47 {
26991 obj := &OxmIdTunMetadata47{
26992 OxmId: NewOxmId(110204),
26993 }
26994 return obj
26995}
26996func (self *OxmIdTunMetadata47) GetOXMName() string {
26997 return "tun_metadata47"
26998}
26999
27000func (self *OxmIdTunMetadata47) MarshalJSON() ([]byte, error) {
27001 if self.TypeLen == 0 {
27002 return []byte("\"\""), nil
27003 } else {
27004 return []byte("\"" + self.GetOXMName() + "\""), nil
27005 }
27006}
27007
27008type OxmIdTunMetadata47Masked struct {
27009 *OxmId
27010}
27011
27012type IOxmIdTunMetadata47Masked interface {
27013 IOxmId
27014}
27015
27016func (self *OxmIdTunMetadata47Masked) Serialize(encoder *goloxi.Encoder) error {
27017 if err := self.OxmId.Serialize(encoder); err != nil {
27018 return err
27019 }
27020
27021 return nil
27022}
27023
27024func DecodeOxmIdTunMetadata47Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata47Masked, error) {
27025 _oxmidtunmetadata47masked := &OxmIdTunMetadata47Masked{OxmId: parent}
27026 return _oxmidtunmetadata47masked, nil
27027}
27028
27029func NewOxmIdTunMetadata47Masked() *OxmIdTunMetadata47Masked {
27030 obj := &OxmIdTunMetadata47Masked{
27031 OxmId: NewOxmId(110584),
27032 }
27033 return obj
27034}
27035func (self *OxmIdTunMetadata47Masked) GetOXMName() string {
27036 return "tun_metadata47_masked"
27037}
27038
27039func (self *OxmIdTunMetadata47Masked) MarshalJSON() ([]byte, error) {
27040 if self.TypeLen == 0 {
27041 return []byte("\"\""), nil
27042 } else {
27043 return []byte("\"" + self.GetOXMName() + "\""), nil
27044 }
27045}
27046
27047type OxmIdTunMetadata48 struct {
27048 *OxmId
27049}
27050
27051type IOxmIdTunMetadata48 interface {
27052 IOxmId
27053}
27054
27055func (self *OxmIdTunMetadata48) Serialize(encoder *goloxi.Encoder) error {
27056 if err := self.OxmId.Serialize(encoder); err != nil {
27057 return err
27058 }
27059
27060 return nil
27061}
27062
27063func DecodeOxmIdTunMetadata48(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata48, error) {
27064 _oxmidtunmetadata48 := &OxmIdTunMetadata48{OxmId: parent}
27065 return _oxmidtunmetadata48, nil
27066}
27067
27068func NewOxmIdTunMetadata48() *OxmIdTunMetadata48 {
27069 obj := &OxmIdTunMetadata48{
27070 OxmId: NewOxmId(110716),
27071 }
27072 return obj
27073}
27074func (self *OxmIdTunMetadata48) GetOXMName() string {
27075 return "tun_metadata48"
27076}
27077
27078func (self *OxmIdTunMetadata48) MarshalJSON() ([]byte, error) {
27079 if self.TypeLen == 0 {
27080 return []byte("\"\""), nil
27081 } else {
27082 return []byte("\"" + self.GetOXMName() + "\""), nil
27083 }
27084}
27085
27086type OxmIdTunMetadata48Masked struct {
27087 *OxmId
27088}
27089
27090type IOxmIdTunMetadata48Masked interface {
27091 IOxmId
27092}
27093
27094func (self *OxmIdTunMetadata48Masked) Serialize(encoder *goloxi.Encoder) error {
27095 if err := self.OxmId.Serialize(encoder); err != nil {
27096 return err
27097 }
27098
27099 return nil
27100}
27101
27102func DecodeOxmIdTunMetadata48Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata48Masked, error) {
27103 _oxmidtunmetadata48masked := &OxmIdTunMetadata48Masked{OxmId: parent}
27104 return _oxmidtunmetadata48masked, nil
27105}
27106
27107func NewOxmIdTunMetadata48Masked() *OxmIdTunMetadata48Masked {
27108 obj := &OxmIdTunMetadata48Masked{
27109 OxmId: NewOxmId(111096),
27110 }
27111 return obj
27112}
27113func (self *OxmIdTunMetadata48Masked) GetOXMName() string {
27114 return "tun_metadata48_masked"
27115}
27116
27117func (self *OxmIdTunMetadata48Masked) MarshalJSON() ([]byte, error) {
27118 if self.TypeLen == 0 {
27119 return []byte("\"\""), nil
27120 } else {
27121 return []byte("\"" + self.GetOXMName() + "\""), nil
27122 }
27123}
27124
27125type OxmIdTunMetadata49 struct {
27126 *OxmId
27127}
27128
27129type IOxmIdTunMetadata49 interface {
27130 IOxmId
27131}
27132
27133func (self *OxmIdTunMetadata49) Serialize(encoder *goloxi.Encoder) error {
27134 if err := self.OxmId.Serialize(encoder); err != nil {
27135 return err
27136 }
27137
27138 return nil
27139}
27140
27141func DecodeOxmIdTunMetadata49(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata49, error) {
27142 _oxmidtunmetadata49 := &OxmIdTunMetadata49{OxmId: parent}
27143 return _oxmidtunmetadata49, nil
27144}
27145
27146func NewOxmIdTunMetadata49() *OxmIdTunMetadata49 {
27147 obj := &OxmIdTunMetadata49{
27148 OxmId: NewOxmId(111228),
27149 }
27150 return obj
27151}
27152func (self *OxmIdTunMetadata49) GetOXMName() string {
27153 return "tun_metadata49"
27154}
27155
27156func (self *OxmIdTunMetadata49) MarshalJSON() ([]byte, error) {
27157 if self.TypeLen == 0 {
27158 return []byte("\"\""), nil
27159 } else {
27160 return []byte("\"" + self.GetOXMName() + "\""), nil
27161 }
27162}
27163
27164type OxmIdTunMetadata49Masked struct {
27165 *OxmId
27166}
27167
27168type IOxmIdTunMetadata49Masked interface {
27169 IOxmId
27170}
27171
27172func (self *OxmIdTunMetadata49Masked) Serialize(encoder *goloxi.Encoder) error {
27173 if err := self.OxmId.Serialize(encoder); err != nil {
27174 return err
27175 }
27176
27177 return nil
27178}
27179
27180func DecodeOxmIdTunMetadata49Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata49Masked, error) {
27181 _oxmidtunmetadata49masked := &OxmIdTunMetadata49Masked{OxmId: parent}
27182 return _oxmidtunmetadata49masked, nil
27183}
27184
27185func NewOxmIdTunMetadata49Masked() *OxmIdTunMetadata49Masked {
27186 obj := &OxmIdTunMetadata49Masked{
27187 OxmId: NewOxmId(111608),
27188 }
27189 return obj
27190}
27191func (self *OxmIdTunMetadata49Masked) GetOXMName() string {
27192 return "tun_metadata49_masked"
27193}
27194
27195func (self *OxmIdTunMetadata49Masked) MarshalJSON() ([]byte, error) {
27196 if self.TypeLen == 0 {
27197 return []byte("\"\""), nil
27198 } else {
27199 return []byte("\"" + self.GetOXMName() + "\""), nil
27200 }
27201}
27202
27203type OxmIdTunMetadata4Masked struct {
27204 *OxmId
27205}
27206
27207type IOxmIdTunMetadata4Masked interface {
27208 IOxmId
27209}
27210
27211func (self *OxmIdTunMetadata4Masked) Serialize(encoder *goloxi.Encoder) error {
27212 if err := self.OxmId.Serialize(encoder); err != nil {
27213 return err
27214 }
27215
27216 return nil
27217}
27218
27219func DecodeOxmIdTunMetadata4Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata4Masked, error) {
27220 _oxmidtunmetadata4masked := &OxmIdTunMetadata4Masked{OxmId: parent}
27221 return _oxmidtunmetadata4masked, nil
27222}
27223
27224func NewOxmIdTunMetadata4Masked() *OxmIdTunMetadata4Masked {
27225 obj := &OxmIdTunMetadata4Masked{
27226 OxmId: NewOxmId(88568),
27227 }
27228 return obj
27229}
27230func (self *OxmIdTunMetadata4Masked) GetOXMName() string {
27231 return "tun_metadata4_masked"
27232}
27233
27234func (self *OxmIdTunMetadata4Masked) MarshalJSON() ([]byte, error) {
27235 if self.TypeLen == 0 {
27236 return []byte("\"\""), nil
27237 } else {
27238 return []byte("\"" + self.GetOXMName() + "\""), nil
27239 }
27240}
27241
27242type OxmIdTunMetadata5 struct {
27243 *OxmId
27244}
27245
27246type IOxmIdTunMetadata5 interface {
27247 IOxmId
27248}
27249
27250func (self *OxmIdTunMetadata5) Serialize(encoder *goloxi.Encoder) error {
27251 if err := self.OxmId.Serialize(encoder); err != nil {
27252 return err
27253 }
27254
27255 return nil
27256}
27257
27258func DecodeOxmIdTunMetadata5(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata5, error) {
27259 _oxmidtunmetadata5 := &OxmIdTunMetadata5{OxmId: parent}
27260 return _oxmidtunmetadata5, nil
27261}
27262
27263func NewOxmIdTunMetadata5() *OxmIdTunMetadata5 {
27264 obj := &OxmIdTunMetadata5{
27265 OxmId: NewOxmId(88700),
27266 }
27267 return obj
27268}
27269func (self *OxmIdTunMetadata5) GetOXMName() string {
27270 return "tun_metadata5"
27271}
27272
27273func (self *OxmIdTunMetadata5) MarshalJSON() ([]byte, error) {
27274 if self.TypeLen == 0 {
27275 return []byte("\"\""), nil
27276 } else {
27277 return []byte("\"" + self.GetOXMName() + "\""), nil
27278 }
27279}
27280
27281type OxmIdTunMetadata50 struct {
27282 *OxmId
27283}
27284
27285type IOxmIdTunMetadata50 interface {
27286 IOxmId
27287}
27288
27289func (self *OxmIdTunMetadata50) Serialize(encoder *goloxi.Encoder) error {
27290 if err := self.OxmId.Serialize(encoder); err != nil {
27291 return err
27292 }
27293
27294 return nil
27295}
27296
27297func DecodeOxmIdTunMetadata50(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata50, error) {
27298 _oxmidtunmetadata50 := &OxmIdTunMetadata50{OxmId: parent}
27299 return _oxmidtunmetadata50, nil
27300}
27301
27302func NewOxmIdTunMetadata50() *OxmIdTunMetadata50 {
27303 obj := &OxmIdTunMetadata50{
27304 OxmId: NewOxmId(111740),
27305 }
27306 return obj
27307}
27308func (self *OxmIdTunMetadata50) GetOXMName() string {
27309 return "tun_metadata50"
27310}
27311
27312func (self *OxmIdTunMetadata50) MarshalJSON() ([]byte, error) {
27313 if self.TypeLen == 0 {
27314 return []byte("\"\""), nil
27315 } else {
27316 return []byte("\"" + self.GetOXMName() + "\""), nil
27317 }
27318}
27319
27320type OxmIdTunMetadata50Masked struct {
27321 *OxmId
27322}
27323
27324type IOxmIdTunMetadata50Masked interface {
27325 IOxmId
27326}
27327
27328func (self *OxmIdTunMetadata50Masked) Serialize(encoder *goloxi.Encoder) error {
27329 if err := self.OxmId.Serialize(encoder); err != nil {
27330 return err
27331 }
27332
27333 return nil
27334}
27335
27336func DecodeOxmIdTunMetadata50Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata50Masked, error) {
27337 _oxmidtunmetadata50masked := &OxmIdTunMetadata50Masked{OxmId: parent}
27338 return _oxmidtunmetadata50masked, nil
27339}
27340
27341func NewOxmIdTunMetadata50Masked() *OxmIdTunMetadata50Masked {
27342 obj := &OxmIdTunMetadata50Masked{
27343 OxmId: NewOxmId(112120),
27344 }
27345 return obj
27346}
27347func (self *OxmIdTunMetadata50Masked) GetOXMName() string {
27348 return "tun_metadata50_masked"
27349}
27350
27351func (self *OxmIdTunMetadata50Masked) MarshalJSON() ([]byte, error) {
27352 if self.TypeLen == 0 {
27353 return []byte("\"\""), nil
27354 } else {
27355 return []byte("\"" + self.GetOXMName() + "\""), nil
27356 }
27357}
27358
27359type OxmIdTunMetadata51 struct {
27360 *OxmId
27361}
27362
27363type IOxmIdTunMetadata51 interface {
27364 IOxmId
27365}
27366
27367func (self *OxmIdTunMetadata51) Serialize(encoder *goloxi.Encoder) error {
27368 if err := self.OxmId.Serialize(encoder); err != nil {
27369 return err
27370 }
27371
27372 return nil
27373}
27374
27375func DecodeOxmIdTunMetadata51(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata51, error) {
27376 _oxmidtunmetadata51 := &OxmIdTunMetadata51{OxmId: parent}
27377 return _oxmidtunmetadata51, nil
27378}
27379
27380func NewOxmIdTunMetadata51() *OxmIdTunMetadata51 {
27381 obj := &OxmIdTunMetadata51{
27382 OxmId: NewOxmId(112252),
27383 }
27384 return obj
27385}
27386func (self *OxmIdTunMetadata51) GetOXMName() string {
27387 return "tun_metadata51"
27388}
27389
27390func (self *OxmIdTunMetadata51) MarshalJSON() ([]byte, error) {
27391 if self.TypeLen == 0 {
27392 return []byte("\"\""), nil
27393 } else {
27394 return []byte("\"" + self.GetOXMName() + "\""), nil
27395 }
27396}
27397
27398type OxmIdTunMetadata51Masked struct {
27399 *OxmId
27400}
27401
27402type IOxmIdTunMetadata51Masked interface {
27403 IOxmId
27404}
27405
27406func (self *OxmIdTunMetadata51Masked) Serialize(encoder *goloxi.Encoder) error {
27407 if err := self.OxmId.Serialize(encoder); err != nil {
27408 return err
27409 }
27410
27411 return nil
27412}
27413
27414func DecodeOxmIdTunMetadata51Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata51Masked, error) {
27415 _oxmidtunmetadata51masked := &OxmIdTunMetadata51Masked{OxmId: parent}
27416 return _oxmidtunmetadata51masked, nil
27417}
27418
27419func NewOxmIdTunMetadata51Masked() *OxmIdTunMetadata51Masked {
27420 obj := &OxmIdTunMetadata51Masked{
27421 OxmId: NewOxmId(112632),
27422 }
27423 return obj
27424}
27425func (self *OxmIdTunMetadata51Masked) GetOXMName() string {
27426 return "tun_metadata51_masked"
27427}
27428
27429func (self *OxmIdTunMetadata51Masked) MarshalJSON() ([]byte, error) {
27430 if self.TypeLen == 0 {
27431 return []byte("\"\""), nil
27432 } else {
27433 return []byte("\"" + self.GetOXMName() + "\""), nil
27434 }
27435}
27436
27437type OxmIdTunMetadata52 struct {
27438 *OxmId
27439}
27440
27441type IOxmIdTunMetadata52 interface {
27442 IOxmId
27443}
27444
27445func (self *OxmIdTunMetadata52) Serialize(encoder *goloxi.Encoder) error {
27446 if err := self.OxmId.Serialize(encoder); err != nil {
27447 return err
27448 }
27449
27450 return nil
27451}
27452
27453func DecodeOxmIdTunMetadata52(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata52, error) {
27454 _oxmidtunmetadata52 := &OxmIdTunMetadata52{OxmId: parent}
27455 return _oxmidtunmetadata52, nil
27456}
27457
27458func NewOxmIdTunMetadata52() *OxmIdTunMetadata52 {
27459 obj := &OxmIdTunMetadata52{
27460 OxmId: NewOxmId(112764),
27461 }
27462 return obj
27463}
27464func (self *OxmIdTunMetadata52) GetOXMName() string {
27465 return "tun_metadata52"
27466}
27467
27468func (self *OxmIdTunMetadata52) MarshalJSON() ([]byte, error) {
27469 if self.TypeLen == 0 {
27470 return []byte("\"\""), nil
27471 } else {
27472 return []byte("\"" + self.GetOXMName() + "\""), nil
27473 }
27474}
27475
27476type OxmIdTunMetadata52Masked struct {
27477 *OxmId
27478}
27479
27480type IOxmIdTunMetadata52Masked interface {
27481 IOxmId
27482}
27483
27484func (self *OxmIdTunMetadata52Masked) Serialize(encoder *goloxi.Encoder) error {
27485 if err := self.OxmId.Serialize(encoder); err != nil {
27486 return err
27487 }
27488
27489 return nil
27490}
27491
27492func DecodeOxmIdTunMetadata52Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata52Masked, error) {
27493 _oxmidtunmetadata52masked := &OxmIdTunMetadata52Masked{OxmId: parent}
27494 return _oxmidtunmetadata52masked, nil
27495}
27496
27497func NewOxmIdTunMetadata52Masked() *OxmIdTunMetadata52Masked {
27498 obj := &OxmIdTunMetadata52Masked{
27499 OxmId: NewOxmId(113144),
27500 }
27501 return obj
27502}
27503func (self *OxmIdTunMetadata52Masked) GetOXMName() string {
27504 return "tun_metadata52_masked"
27505}
27506
27507func (self *OxmIdTunMetadata52Masked) MarshalJSON() ([]byte, error) {
27508 if self.TypeLen == 0 {
27509 return []byte("\"\""), nil
27510 } else {
27511 return []byte("\"" + self.GetOXMName() + "\""), nil
27512 }
27513}
27514
27515type OxmIdTunMetadata53 struct {
27516 *OxmId
27517}
27518
27519type IOxmIdTunMetadata53 interface {
27520 IOxmId
27521}
27522
27523func (self *OxmIdTunMetadata53) Serialize(encoder *goloxi.Encoder) error {
27524 if err := self.OxmId.Serialize(encoder); err != nil {
27525 return err
27526 }
27527
27528 return nil
27529}
27530
27531func DecodeOxmIdTunMetadata53(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata53, error) {
27532 _oxmidtunmetadata53 := &OxmIdTunMetadata53{OxmId: parent}
27533 return _oxmidtunmetadata53, nil
27534}
27535
27536func NewOxmIdTunMetadata53() *OxmIdTunMetadata53 {
27537 obj := &OxmIdTunMetadata53{
27538 OxmId: NewOxmId(113276),
27539 }
27540 return obj
27541}
27542func (self *OxmIdTunMetadata53) GetOXMName() string {
27543 return "tun_metadata53"
27544}
27545
27546func (self *OxmIdTunMetadata53) MarshalJSON() ([]byte, error) {
27547 if self.TypeLen == 0 {
27548 return []byte("\"\""), nil
27549 } else {
27550 return []byte("\"" + self.GetOXMName() + "\""), nil
27551 }
27552}
27553
27554type OxmIdTunMetadata53Masked struct {
27555 *OxmId
27556}
27557
27558type IOxmIdTunMetadata53Masked interface {
27559 IOxmId
27560}
27561
27562func (self *OxmIdTunMetadata53Masked) Serialize(encoder *goloxi.Encoder) error {
27563 if err := self.OxmId.Serialize(encoder); err != nil {
27564 return err
27565 }
27566
27567 return nil
27568}
27569
27570func DecodeOxmIdTunMetadata53Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata53Masked, error) {
27571 _oxmidtunmetadata53masked := &OxmIdTunMetadata53Masked{OxmId: parent}
27572 return _oxmidtunmetadata53masked, nil
27573}
27574
27575func NewOxmIdTunMetadata53Masked() *OxmIdTunMetadata53Masked {
27576 obj := &OxmIdTunMetadata53Masked{
27577 OxmId: NewOxmId(113656),
27578 }
27579 return obj
27580}
27581func (self *OxmIdTunMetadata53Masked) GetOXMName() string {
27582 return "tun_metadata53_masked"
27583}
27584
27585func (self *OxmIdTunMetadata53Masked) MarshalJSON() ([]byte, error) {
27586 if self.TypeLen == 0 {
27587 return []byte("\"\""), nil
27588 } else {
27589 return []byte("\"" + self.GetOXMName() + "\""), nil
27590 }
27591}
27592
27593type OxmIdTunMetadata54 struct {
27594 *OxmId
27595}
27596
27597type IOxmIdTunMetadata54 interface {
27598 IOxmId
27599}
27600
27601func (self *OxmIdTunMetadata54) Serialize(encoder *goloxi.Encoder) error {
27602 if err := self.OxmId.Serialize(encoder); err != nil {
27603 return err
27604 }
27605
27606 return nil
27607}
27608
27609func DecodeOxmIdTunMetadata54(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata54, error) {
27610 _oxmidtunmetadata54 := &OxmIdTunMetadata54{OxmId: parent}
27611 return _oxmidtunmetadata54, nil
27612}
27613
27614func NewOxmIdTunMetadata54() *OxmIdTunMetadata54 {
27615 obj := &OxmIdTunMetadata54{
27616 OxmId: NewOxmId(113788),
27617 }
27618 return obj
27619}
27620func (self *OxmIdTunMetadata54) GetOXMName() string {
27621 return "tun_metadata54"
27622}
27623
27624func (self *OxmIdTunMetadata54) MarshalJSON() ([]byte, error) {
27625 if self.TypeLen == 0 {
27626 return []byte("\"\""), nil
27627 } else {
27628 return []byte("\"" + self.GetOXMName() + "\""), nil
27629 }
27630}
27631
27632type OxmIdTunMetadata54Masked struct {
27633 *OxmId
27634}
27635
27636type IOxmIdTunMetadata54Masked interface {
27637 IOxmId
27638}
27639
27640func (self *OxmIdTunMetadata54Masked) Serialize(encoder *goloxi.Encoder) error {
27641 if err := self.OxmId.Serialize(encoder); err != nil {
27642 return err
27643 }
27644
27645 return nil
27646}
27647
27648func DecodeOxmIdTunMetadata54Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata54Masked, error) {
27649 _oxmidtunmetadata54masked := &OxmIdTunMetadata54Masked{OxmId: parent}
27650 return _oxmidtunmetadata54masked, nil
27651}
27652
27653func NewOxmIdTunMetadata54Masked() *OxmIdTunMetadata54Masked {
27654 obj := &OxmIdTunMetadata54Masked{
27655 OxmId: NewOxmId(114168),
27656 }
27657 return obj
27658}
27659func (self *OxmIdTunMetadata54Masked) GetOXMName() string {
27660 return "tun_metadata54_masked"
27661}
27662
27663func (self *OxmIdTunMetadata54Masked) MarshalJSON() ([]byte, error) {
27664 if self.TypeLen == 0 {
27665 return []byte("\"\""), nil
27666 } else {
27667 return []byte("\"" + self.GetOXMName() + "\""), nil
27668 }
27669}
27670
27671type OxmIdTunMetadata55 struct {
27672 *OxmId
27673}
27674
27675type IOxmIdTunMetadata55 interface {
27676 IOxmId
27677}
27678
27679func (self *OxmIdTunMetadata55) Serialize(encoder *goloxi.Encoder) error {
27680 if err := self.OxmId.Serialize(encoder); err != nil {
27681 return err
27682 }
27683
27684 return nil
27685}
27686
27687func DecodeOxmIdTunMetadata55(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata55, error) {
27688 _oxmidtunmetadata55 := &OxmIdTunMetadata55{OxmId: parent}
27689 return _oxmidtunmetadata55, nil
27690}
27691
27692func NewOxmIdTunMetadata55() *OxmIdTunMetadata55 {
27693 obj := &OxmIdTunMetadata55{
27694 OxmId: NewOxmId(114300),
27695 }
27696 return obj
27697}
27698func (self *OxmIdTunMetadata55) GetOXMName() string {
27699 return "tun_metadata55"
27700}
27701
27702func (self *OxmIdTunMetadata55) MarshalJSON() ([]byte, error) {
27703 if self.TypeLen == 0 {
27704 return []byte("\"\""), nil
27705 } else {
27706 return []byte("\"" + self.GetOXMName() + "\""), nil
27707 }
27708}
27709
27710type OxmIdTunMetadata55Masked struct {
27711 *OxmId
27712}
27713
27714type IOxmIdTunMetadata55Masked interface {
27715 IOxmId
27716}
27717
27718func (self *OxmIdTunMetadata55Masked) Serialize(encoder *goloxi.Encoder) error {
27719 if err := self.OxmId.Serialize(encoder); err != nil {
27720 return err
27721 }
27722
27723 return nil
27724}
27725
27726func DecodeOxmIdTunMetadata55Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata55Masked, error) {
27727 _oxmidtunmetadata55masked := &OxmIdTunMetadata55Masked{OxmId: parent}
27728 return _oxmidtunmetadata55masked, nil
27729}
27730
27731func NewOxmIdTunMetadata55Masked() *OxmIdTunMetadata55Masked {
27732 obj := &OxmIdTunMetadata55Masked{
27733 OxmId: NewOxmId(114680),
27734 }
27735 return obj
27736}
27737func (self *OxmIdTunMetadata55Masked) GetOXMName() string {
27738 return "tun_metadata55_masked"
27739}
27740
27741func (self *OxmIdTunMetadata55Masked) MarshalJSON() ([]byte, error) {
27742 if self.TypeLen == 0 {
27743 return []byte("\"\""), nil
27744 } else {
27745 return []byte("\"" + self.GetOXMName() + "\""), nil
27746 }
27747}
27748
27749type OxmIdTunMetadata56 struct {
27750 *OxmId
27751}
27752
27753type IOxmIdTunMetadata56 interface {
27754 IOxmId
27755}
27756
27757func (self *OxmIdTunMetadata56) Serialize(encoder *goloxi.Encoder) error {
27758 if err := self.OxmId.Serialize(encoder); err != nil {
27759 return err
27760 }
27761
27762 return nil
27763}
27764
27765func DecodeOxmIdTunMetadata56(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata56, error) {
27766 _oxmidtunmetadata56 := &OxmIdTunMetadata56{OxmId: parent}
27767 return _oxmidtunmetadata56, nil
27768}
27769
27770func NewOxmIdTunMetadata56() *OxmIdTunMetadata56 {
27771 obj := &OxmIdTunMetadata56{
27772 OxmId: NewOxmId(114812),
27773 }
27774 return obj
27775}
27776func (self *OxmIdTunMetadata56) GetOXMName() string {
27777 return "tun_metadata56"
27778}
27779
27780func (self *OxmIdTunMetadata56) MarshalJSON() ([]byte, error) {
27781 if self.TypeLen == 0 {
27782 return []byte("\"\""), nil
27783 } else {
27784 return []byte("\"" + self.GetOXMName() + "\""), nil
27785 }
27786}
27787
27788type OxmIdTunMetadata56Masked struct {
27789 *OxmId
27790}
27791
27792type IOxmIdTunMetadata56Masked interface {
27793 IOxmId
27794}
27795
27796func (self *OxmIdTunMetadata56Masked) Serialize(encoder *goloxi.Encoder) error {
27797 if err := self.OxmId.Serialize(encoder); err != nil {
27798 return err
27799 }
27800
27801 return nil
27802}
27803
27804func DecodeOxmIdTunMetadata56Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata56Masked, error) {
27805 _oxmidtunmetadata56masked := &OxmIdTunMetadata56Masked{OxmId: parent}
27806 return _oxmidtunmetadata56masked, nil
27807}
27808
27809func NewOxmIdTunMetadata56Masked() *OxmIdTunMetadata56Masked {
27810 obj := &OxmIdTunMetadata56Masked{
27811 OxmId: NewOxmId(115192),
27812 }
27813 return obj
27814}
27815func (self *OxmIdTunMetadata56Masked) GetOXMName() string {
27816 return "tun_metadata56_masked"
27817}
27818
27819func (self *OxmIdTunMetadata56Masked) MarshalJSON() ([]byte, error) {
27820 if self.TypeLen == 0 {
27821 return []byte("\"\""), nil
27822 } else {
27823 return []byte("\"" + self.GetOXMName() + "\""), nil
27824 }
27825}
27826
27827type OxmIdTunMetadata57 struct {
27828 *OxmId
27829}
27830
27831type IOxmIdTunMetadata57 interface {
27832 IOxmId
27833}
27834
27835func (self *OxmIdTunMetadata57) Serialize(encoder *goloxi.Encoder) error {
27836 if err := self.OxmId.Serialize(encoder); err != nil {
27837 return err
27838 }
27839
27840 return nil
27841}
27842
27843func DecodeOxmIdTunMetadata57(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata57, error) {
27844 _oxmidtunmetadata57 := &OxmIdTunMetadata57{OxmId: parent}
27845 return _oxmidtunmetadata57, nil
27846}
27847
27848func NewOxmIdTunMetadata57() *OxmIdTunMetadata57 {
27849 obj := &OxmIdTunMetadata57{
27850 OxmId: NewOxmId(115324),
27851 }
27852 return obj
27853}
27854func (self *OxmIdTunMetadata57) GetOXMName() string {
27855 return "tun_metadata57"
27856}
27857
27858func (self *OxmIdTunMetadata57) MarshalJSON() ([]byte, error) {
27859 if self.TypeLen == 0 {
27860 return []byte("\"\""), nil
27861 } else {
27862 return []byte("\"" + self.GetOXMName() + "\""), nil
27863 }
27864}
27865
27866type OxmIdTunMetadata57Masked struct {
27867 *OxmId
27868}
27869
27870type IOxmIdTunMetadata57Masked interface {
27871 IOxmId
27872}
27873
27874func (self *OxmIdTunMetadata57Masked) Serialize(encoder *goloxi.Encoder) error {
27875 if err := self.OxmId.Serialize(encoder); err != nil {
27876 return err
27877 }
27878
27879 return nil
27880}
27881
27882func DecodeOxmIdTunMetadata57Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata57Masked, error) {
27883 _oxmidtunmetadata57masked := &OxmIdTunMetadata57Masked{OxmId: parent}
27884 return _oxmidtunmetadata57masked, nil
27885}
27886
27887func NewOxmIdTunMetadata57Masked() *OxmIdTunMetadata57Masked {
27888 obj := &OxmIdTunMetadata57Masked{
27889 OxmId: NewOxmId(115704),
27890 }
27891 return obj
27892}
27893func (self *OxmIdTunMetadata57Masked) GetOXMName() string {
27894 return "tun_metadata57_masked"
27895}
27896
27897func (self *OxmIdTunMetadata57Masked) MarshalJSON() ([]byte, error) {
27898 if self.TypeLen == 0 {
27899 return []byte("\"\""), nil
27900 } else {
27901 return []byte("\"" + self.GetOXMName() + "\""), nil
27902 }
27903}
27904
27905type OxmIdTunMetadata58 struct {
27906 *OxmId
27907}
27908
27909type IOxmIdTunMetadata58 interface {
27910 IOxmId
27911}
27912
27913func (self *OxmIdTunMetadata58) Serialize(encoder *goloxi.Encoder) error {
27914 if err := self.OxmId.Serialize(encoder); err != nil {
27915 return err
27916 }
27917
27918 return nil
27919}
27920
27921func DecodeOxmIdTunMetadata58(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata58, error) {
27922 _oxmidtunmetadata58 := &OxmIdTunMetadata58{OxmId: parent}
27923 return _oxmidtunmetadata58, nil
27924}
27925
27926func NewOxmIdTunMetadata58() *OxmIdTunMetadata58 {
27927 obj := &OxmIdTunMetadata58{
27928 OxmId: NewOxmId(115836),
27929 }
27930 return obj
27931}
27932func (self *OxmIdTunMetadata58) GetOXMName() string {
27933 return "tun_metadata58"
27934}
27935
27936func (self *OxmIdTunMetadata58) MarshalJSON() ([]byte, error) {
27937 if self.TypeLen == 0 {
27938 return []byte("\"\""), nil
27939 } else {
27940 return []byte("\"" + self.GetOXMName() + "\""), nil
27941 }
27942}
27943
27944type OxmIdTunMetadata58Masked struct {
27945 *OxmId
27946}
27947
27948type IOxmIdTunMetadata58Masked interface {
27949 IOxmId
27950}
27951
27952func (self *OxmIdTunMetadata58Masked) Serialize(encoder *goloxi.Encoder) error {
27953 if err := self.OxmId.Serialize(encoder); err != nil {
27954 return err
27955 }
27956
27957 return nil
27958}
27959
27960func DecodeOxmIdTunMetadata58Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata58Masked, error) {
27961 _oxmidtunmetadata58masked := &OxmIdTunMetadata58Masked{OxmId: parent}
27962 return _oxmidtunmetadata58masked, nil
27963}
27964
27965func NewOxmIdTunMetadata58Masked() *OxmIdTunMetadata58Masked {
27966 obj := &OxmIdTunMetadata58Masked{
27967 OxmId: NewOxmId(116216),
27968 }
27969 return obj
27970}
27971func (self *OxmIdTunMetadata58Masked) GetOXMName() string {
27972 return "tun_metadata58_masked"
27973}
27974
27975func (self *OxmIdTunMetadata58Masked) MarshalJSON() ([]byte, error) {
27976 if self.TypeLen == 0 {
27977 return []byte("\"\""), nil
27978 } else {
27979 return []byte("\"" + self.GetOXMName() + "\""), nil
27980 }
27981}
27982
27983type OxmIdTunMetadata59 struct {
27984 *OxmId
27985}
27986
27987type IOxmIdTunMetadata59 interface {
27988 IOxmId
27989}
27990
27991func (self *OxmIdTunMetadata59) Serialize(encoder *goloxi.Encoder) error {
27992 if err := self.OxmId.Serialize(encoder); err != nil {
27993 return err
27994 }
27995
27996 return nil
27997}
27998
27999func DecodeOxmIdTunMetadata59(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata59, error) {
28000 _oxmidtunmetadata59 := &OxmIdTunMetadata59{OxmId: parent}
28001 return _oxmidtunmetadata59, nil
28002}
28003
28004func NewOxmIdTunMetadata59() *OxmIdTunMetadata59 {
28005 obj := &OxmIdTunMetadata59{
28006 OxmId: NewOxmId(116348),
28007 }
28008 return obj
28009}
28010func (self *OxmIdTunMetadata59) GetOXMName() string {
28011 return "tun_metadata59"
28012}
28013
28014func (self *OxmIdTunMetadata59) MarshalJSON() ([]byte, error) {
28015 if self.TypeLen == 0 {
28016 return []byte("\"\""), nil
28017 } else {
28018 return []byte("\"" + self.GetOXMName() + "\""), nil
28019 }
28020}
28021
28022type OxmIdTunMetadata59Masked struct {
28023 *OxmId
28024}
28025
28026type IOxmIdTunMetadata59Masked interface {
28027 IOxmId
28028}
28029
28030func (self *OxmIdTunMetadata59Masked) Serialize(encoder *goloxi.Encoder) error {
28031 if err := self.OxmId.Serialize(encoder); err != nil {
28032 return err
28033 }
28034
28035 return nil
28036}
28037
28038func DecodeOxmIdTunMetadata59Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata59Masked, error) {
28039 _oxmidtunmetadata59masked := &OxmIdTunMetadata59Masked{OxmId: parent}
28040 return _oxmidtunmetadata59masked, nil
28041}
28042
28043func NewOxmIdTunMetadata59Masked() *OxmIdTunMetadata59Masked {
28044 obj := &OxmIdTunMetadata59Masked{
28045 OxmId: NewOxmId(116728),
28046 }
28047 return obj
28048}
28049func (self *OxmIdTunMetadata59Masked) GetOXMName() string {
28050 return "tun_metadata59_masked"
28051}
28052
28053func (self *OxmIdTunMetadata59Masked) MarshalJSON() ([]byte, error) {
28054 if self.TypeLen == 0 {
28055 return []byte("\"\""), nil
28056 } else {
28057 return []byte("\"" + self.GetOXMName() + "\""), nil
28058 }
28059}
28060
28061type OxmIdTunMetadata5Masked struct {
28062 *OxmId
28063}
28064
28065type IOxmIdTunMetadata5Masked interface {
28066 IOxmId
28067}
28068
28069func (self *OxmIdTunMetadata5Masked) Serialize(encoder *goloxi.Encoder) error {
28070 if err := self.OxmId.Serialize(encoder); err != nil {
28071 return err
28072 }
28073
28074 return nil
28075}
28076
28077func DecodeOxmIdTunMetadata5Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata5Masked, error) {
28078 _oxmidtunmetadata5masked := &OxmIdTunMetadata5Masked{OxmId: parent}
28079 return _oxmidtunmetadata5masked, nil
28080}
28081
28082func NewOxmIdTunMetadata5Masked() *OxmIdTunMetadata5Masked {
28083 obj := &OxmIdTunMetadata5Masked{
28084 OxmId: NewOxmId(89080),
28085 }
28086 return obj
28087}
28088func (self *OxmIdTunMetadata5Masked) GetOXMName() string {
28089 return "tun_metadata5_masked"
28090}
28091
28092func (self *OxmIdTunMetadata5Masked) MarshalJSON() ([]byte, error) {
28093 if self.TypeLen == 0 {
28094 return []byte("\"\""), nil
28095 } else {
28096 return []byte("\"" + self.GetOXMName() + "\""), nil
28097 }
28098}
28099
28100type OxmIdTunMetadata6 struct {
28101 *OxmId
28102}
28103
28104type IOxmIdTunMetadata6 interface {
28105 IOxmId
28106}
28107
28108func (self *OxmIdTunMetadata6) Serialize(encoder *goloxi.Encoder) error {
28109 if err := self.OxmId.Serialize(encoder); err != nil {
28110 return err
28111 }
28112
28113 return nil
28114}
28115
28116func DecodeOxmIdTunMetadata6(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata6, error) {
28117 _oxmidtunmetadata6 := &OxmIdTunMetadata6{OxmId: parent}
28118 return _oxmidtunmetadata6, nil
28119}
28120
28121func NewOxmIdTunMetadata6() *OxmIdTunMetadata6 {
28122 obj := &OxmIdTunMetadata6{
28123 OxmId: NewOxmId(89212),
28124 }
28125 return obj
28126}
28127func (self *OxmIdTunMetadata6) GetOXMName() string {
28128 return "tun_metadata6"
28129}
28130
28131func (self *OxmIdTunMetadata6) MarshalJSON() ([]byte, error) {
28132 if self.TypeLen == 0 {
28133 return []byte("\"\""), nil
28134 } else {
28135 return []byte("\"" + self.GetOXMName() + "\""), nil
28136 }
28137}
28138
28139type OxmIdTunMetadata60 struct {
28140 *OxmId
28141}
28142
28143type IOxmIdTunMetadata60 interface {
28144 IOxmId
28145}
28146
28147func (self *OxmIdTunMetadata60) Serialize(encoder *goloxi.Encoder) error {
28148 if err := self.OxmId.Serialize(encoder); err != nil {
28149 return err
28150 }
28151
28152 return nil
28153}
28154
28155func DecodeOxmIdTunMetadata60(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata60, error) {
28156 _oxmidtunmetadata60 := &OxmIdTunMetadata60{OxmId: parent}
28157 return _oxmidtunmetadata60, nil
28158}
28159
28160func NewOxmIdTunMetadata60() *OxmIdTunMetadata60 {
28161 obj := &OxmIdTunMetadata60{
28162 OxmId: NewOxmId(116860),
28163 }
28164 return obj
28165}
28166func (self *OxmIdTunMetadata60) GetOXMName() string {
28167 return "tun_metadata60"
28168}
28169
28170func (self *OxmIdTunMetadata60) MarshalJSON() ([]byte, error) {
28171 if self.TypeLen == 0 {
28172 return []byte("\"\""), nil
28173 } else {
28174 return []byte("\"" + self.GetOXMName() + "\""), nil
28175 }
28176}
28177
28178type OxmIdTunMetadata60Masked struct {
28179 *OxmId
28180}
28181
28182type IOxmIdTunMetadata60Masked interface {
28183 IOxmId
28184}
28185
28186func (self *OxmIdTunMetadata60Masked) Serialize(encoder *goloxi.Encoder) error {
28187 if err := self.OxmId.Serialize(encoder); err != nil {
28188 return err
28189 }
28190
28191 return nil
28192}
28193
28194func DecodeOxmIdTunMetadata60Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata60Masked, error) {
28195 _oxmidtunmetadata60masked := &OxmIdTunMetadata60Masked{OxmId: parent}
28196 return _oxmidtunmetadata60masked, nil
28197}
28198
28199func NewOxmIdTunMetadata60Masked() *OxmIdTunMetadata60Masked {
28200 obj := &OxmIdTunMetadata60Masked{
28201 OxmId: NewOxmId(117240),
28202 }
28203 return obj
28204}
28205func (self *OxmIdTunMetadata60Masked) GetOXMName() string {
28206 return "tun_metadata60_masked"
28207}
28208
28209func (self *OxmIdTunMetadata60Masked) MarshalJSON() ([]byte, error) {
28210 if self.TypeLen == 0 {
28211 return []byte("\"\""), nil
28212 } else {
28213 return []byte("\"" + self.GetOXMName() + "\""), nil
28214 }
28215}
28216
28217type OxmIdTunMetadata61 struct {
28218 *OxmId
28219}
28220
28221type IOxmIdTunMetadata61 interface {
28222 IOxmId
28223}
28224
28225func (self *OxmIdTunMetadata61) Serialize(encoder *goloxi.Encoder) error {
28226 if err := self.OxmId.Serialize(encoder); err != nil {
28227 return err
28228 }
28229
28230 return nil
28231}
28232
28233func DecodeOxmIdTunMetadata61(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata61, error) {
28234 _oxmidtunmetadata61 := &OxmIdTunMetadata61{OxmId: parent}
28235 return _oxmidtunmetadata61, nil
28236}
28237
28238func NewOxmIdTunMetadata61() *OxmIdTunMetadata61 {
28239 obj := &OxmIdTunMetadata61{
28240 OxmId: NewOxmId(117372),
28241 }
28242 return obj
28243}
28244func (self *OxmIdTunMetadata61) GetOXMName() string {
28245 return "tun_metadata61"
28246}
28247
28248func (self *OxmIdTunMetadata61) MarshalJSON() ([]byte, error) {
28249 if self.TypeLen == 0 {
28250 return []byte("\"\""), nil
28251 } else {
28252 return []byte("\"" + self.GetOXMName() + "\""), nil
28253 }
28254}
28255
28256type OxmIdTunMetadata61Masked struct {
28257 *OxmId
28258}
28259
28260type IOxmIdTunMetadata61Masked interface {
28261 IOxmId
28262}
28263
28264func (self *OxmIdTunMetadata61Masked) Serialize(encoder *goloxi.Encoder) error {
28265 if err := self.OxmId.Serialize(encoder); err != nil {
28266 return err
28267 }
28268
28269 return nil
28270}
28271
28272func DecodeOxmIdTunMetadata61Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata61Masked, error) {
28273 _oxmidtunmetadata61masked := &OxmIdTunMetadata61Masked{OxmId: parent}
28274 return _oxmidtunmetadata61masked, nil
28275}
28276
28277func NewOxmIdTunMetadata61Masked() *OxmIdTunMetadata61Masked {
28278 obj := &OxmIdTunMetadata61Masked{
28279 OxmId: NewOxmId(117752),
28280 }
28281 return obj
28282}
28283func (self *OxmIdTunMetadata61Masked) GetOXMName() string {
28284 return "tun_metadata61_masked"
28285}
28286
28287func (self *OxmIdTunMetadata61Masked) MarshalJSON() ([]byte, error) {
28288 if self.TypeLen == 0 {
28289 return []byte("\"\""), nil
28290 } else {
28291 return []byte("\"" + self.GetOXMName() + "\""), nil
28292 }
28293}
28294
28295type OxmIdTunMetadata62 struct {
28296 *OxmId
28297}
28298
28299type IOxmIdTunMetadata62 interface {
28300 IOxmId
28301}
28302
28303func (self *OxmIdTunMetadata62) Serialize(encoder *goloxi.Encoder) error {
28304 if err := self.OxmId.Serialize(encoder); err != nil {
28305 return err
28306 }
28307
28308 return nil
28309}
28310
28311func DecodeOxmIdTunMetadata62(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata62, error) {
28312 _oxmidtunmetadata62 := &OxmIdTunMetadata62{OxmId: parent}
28313 return _oxmidtunmetadata62, nil
28314}
28315
28316func NewOxmIdTunMetadata62() *OxmIdTunMetadata62 {
28317 obj := &OxmIdTunMetadata62{
28318 OxmId: NewOxmId(117884),
28319 }
28320 return obj
28321}
28322func (self *OxmIdTunMetadata62) GetOXMName() string {
28323 return "tun_metadata62"
28324}
28325
28326func (self *OxmIdTunMetadata62) MarshalJSON() ([]byte, error) {
28327 if self.TypeLen == 0 {
28328 return []byte("\"\""), nil
28329 } else {
28330 return []byte("\"" + self.GetOXMName() + "\""), nil
28331 }
28332}
28333
28334type OxmIdTunMetadata62Masked struct {
28335 *OxmId
28336}
28337
28338type IOxmIdTunMetadata62Masked interface {
28339 IOxmId
28340}
28341
28342func (self *OxmIdTunMetadata62Masked) Serialize(encoder *goloxi.Encoder) error {
28343 if err := self.OxmId.Serialize(encoder); err != nil {
28344 return err
28345 }
28346
28347 return nil
28348}
28349
28350func DecodeOxmIdTunMetadata62Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata62Masked, error) {
28351 _oxmidtunmetadata62masked := &OxmIdTunMetadata62Masked{OxmId: parent}
28352 return _oxmidtunmetadata62masked, nil
28353}
28354
28355func NewOxmIdTunMetadata62Masked() *OxmIdTunMetadata62Masked {
28356 obj := &OxmIdTunMetadata62Masked{
28357 OxmId: NewOxmId(118264),
28358 }
28359 return obj
28360}
28361func (self *OxmIdTunMetadata62Masked) GetOXMName() string {
28362 return "tun_metadata62_masked"
28363}
28364
28365func (self *OxmIdTunMetadata62Masked) MarshalJSON() ([]byte, error) {
28366 if self.TypeLen == 0 {
28367 return []byte("\"\""), nil
28368 } else {
28369 return []byte("\"" + self.GetOXMName() + "\""), nil
28370 }
28371}
28372
28373type OxmIdTunMetadata63 struct {
28374 *OxmId
28375}
28376
28377type IOxmIdTunMetadata63 interface {
28378 IOxmId
28379}
28380
28381func (self *OxmIdTunMetadata63) Serialize(encoder *goloxi.Encoder) error {
28382 if err := self.OxmId.Serialize(encoder); err != nil {
28383 return err
28384 }
28385
28386 return nil
28387}
28388
28389func DecodeOxmIdTunMetadata63(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata63, error) {
28390 _oxmidtunmetadata63 := &OxmIdTunMetadata63{OxmId: parent}
28391 return _oxmidtunmetadata63, nil
28392}
28393
28394func NewOxmIdTunMetadata63() *OxmIdTunMetadata63 {
28395 obj := &OxmIdTunMetadata63{
28396 OxmId: NewOxmId(118396),
28397 }
28398 return obj
28399}
28400func (self *OxmIdTunMetadata63) GetOXMName() string {
28401 return "tun_metadata63"
28402}
28403
28404func (self *OxmIdTunMetadata63) MarshalJSON() ([]byte, error) {
28405 if self.TypeLen == 0 {
28406 return []byte("\"\""), nil
28407 } else {
28408 return []byte("\"" + self.GetOXMName() + "\""), nil
28409 }
28410}
28411
28412type OxmIdTunMetadata63Masked struct {
28413 *OxmId
28414}
28415
28416type IOxmIdTunMetadata63Masked interface {
28417 IOxmId
28418}
28419
28420func (self *OxmIdTunMetadata63Masked) Serialize(encoder *goloxi.Encoder) error {
28421 if err := self.OxmId.Serialize(encoder); err != nil {
28422 return err
28423 }
28424
28425 return nil
28426}
28427
28428func DecodeOxmIdTunMetadata63Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata63Masked, error) {
28429 _oxmidtunmetadata63masked := &OxmIdTunMetadata63Masked{OxmId: parent}
28430 return _oxmidtunmetadata63masked, nil
28431}
28432
28433func NewOxmIdTunMetadata63Masked() *OxmIdTunMetadata63Masked {
28434 obj := &OxmIdTunMetadata63Masked{
28435 OxmId: NewOxmId(118776),
28436 }
28437 return obj
28438}
28439func (self *OxmIdTunMetadata63Masked) GetOXMName() string {
28440 return "tun_metadata63_masked"
28441}
28442
28443func (self *OxmIdTunMetadata63Masked) MarshalJSON() ([]byte, error) {
28444 if self.TypeLen == 0 {
28445 return []byte("\"\""), nil
28446 } else {
28447 return []byte("\"" + self.GetOXMName() + "\""), nil
28448 }
28449}
28450
28451type OxmIdTunMetadata6Masked struct {
28452 *OxmId
28453}
28454
28455type IOxmIdTunMetadata6Masked interface {
28456 IOxmId
28457}
28458
28459func (self *OxmIdTunMetadata6Masked) Serialize(encoder *goloxi.Encoder) error {
28460 if err := self.OxmId.Serialize(encoder); err != nil {
28461 return err
28462 }
28463
28464 return nil
28465}
28466
28467func DecodeOxmIdTunMetadata6Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata6Masked, error) {
28468 _oxmidtunmetadata6masked := &OxmIdTunMetadata6Masked{OxmId: parent}
28469 return _oxmidtunmetadata6masked, nil
28470}
28471
28472func NewOxmIdTunMetadata6Masked() *OxmIdTunMetadata6Masked {
28473 obj := &OxmIdTunMetadata6Masked{
28474 OxmId: NewOxmId(89592),
28475 }
28476 return obj
28477}
28478func (self *OxmIdTunMetadata6Masked) GetOXMName() string {
28479 return "tun_metadata6_masked"
28480}
28481
28482func (self *OxmIdTunMetadata6Masked) MarshalJSON() ([]byte, error) {
28483 if self.TypeLen == 0 {
28484 return []byte("\"\""), nil
28485 } else {
28486 return []byte("\"" + self.GetOXMName() + "\""), nil
28487 }
28488}
28489
28490type OxmIdTunMetadata7 struct {
28491 *OxmId
28492}
28493
28494type IOxmIdTunMetadata7 interface {
28495 IOxmId
28496}
28497
28498func (self *OxmIdTunMetadata7) Serialize(encoder *goloxi.Encoder) error {
28499 if err := self.OxmId.Serialize(encoder); err != nil {
28500 return err
28501 }
28502
28503 return nil
28504}
28505
28506func DecodeOxmIdTunMetadata7(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata7, error) {
28507 _oxmidtunmetadata7 := &OxmIdTunMetadata7{OxmId: parent}
28508 return _oxmidtunmetadata7, nil
28509}
28510
28511func NewOxmIdTunMetadata7() *OxmIdTunMetadata7 {
28512 obj := &OxmIdTunMetadata7{
28513 OxmId: NewOxmId(89724),
28514 }
28515 return obj
28516}
28517func (self *OxmIdTunMetadata7) GetOXMName() string {
28518 return "tun_metadata7"
28519}
28520
28521func (self *OxmIdTunMetadata7) MarshalJSON() ([]byte, error) {
28522 if self.TypeLen == 0 {
28523 return []byte("\"\""), nil
28524 } else {
28525 return []byte("\"" + self.GetOXMName() + "\""), nil
28526 }
28527}
28528
28529type OxmIdTunMetadata7Masked struct {
28530 *OxmId
28531}
28532
28533type IOxmIdTunMetadata7Masked interface {
28534 IOxmId
28535}
28536
28537func (self *OxmIdTunMetadata7Masked) Serialize(encoder *goloxi.Encoder) error {
28538 if err := self.OxmId.Serialize(encoder); err != nil {
28539 return err
28540 }
28541
28542 return nil
28543}
28544
28545func DecodeOxmIdTunMetadata7Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata7Masked, error) {
28546 _oxmidtunmetadata7masked := &OxmIdTunMetadata7Masked{OxmId: parent}
28547 return _oxmidtunmetadata7masked, nil
28548}
28549
28550func NewOxmIdTunMetadata7Masked() *OxmIdTunMetadata7Masked {
28551 obj := &OxmIdTunMetadata7Masked{
28552 OxmId: NewOxmId(90104),
28553 }
28554 return obj
28555}
28556func (self *OxmIdTunMetadata7Masked) GetOXMName() string {
28557 return "tun_metadata7_masked"
28558}
28559
28560func (self *OxmIdTunMetadata7Masked) MarshalJSON() ([]byte, error) {
28561 if self.TypeLen == 0 {
28562 return []byte("\"\""), nil
28563 } else {
28564 return []byte("\"" + self.GetOXMName() + "\""), nil
28565 }
28566}
28567
28568type OxmIdTunMetadata8 struct {
28569 *OxmId
28570}
28571
28572type IOxmIdTunMetadata8 interface {
28573 IOxmId
28574}
28575
28576func (self *OxmIdTunMetadata8) Serialize(encoder *goloxi.Encoder) error {
28577 if err := self.OxmId.Serialize(encoder); err != nil {
28578 return err
28579 }
28580
28581 return nil
28582}
28583
28584func DecodeOxmIdTunMetadata8(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata8, error) {
28585 _oxmidtunmetadata8 := &OxmIdTunMetadata8{OxmId: parent}
28586 return _oxmidtunmetadata8, nil
28587}
28588
28589func NewOxmIdTunMetadata8() *OxmIdTunMetadata8 {
28590 obj := &OxmIdTunMetadata8{
28591 OxmId: NewOxmId(90236),
28592 }
28593 return obj
28594}
28595func (self *OxmIdTunMetadata8) GetOXMName() string {
28596 return "tun_metadata8"
28597}
28598
28599func (self *OxmIdTunMetadata8) MarshalJSON() ([]byte, error) {
28600 if self.TypeLen == 0 {
28601 return []byte("\"\""), nil
28602 } else {
28603 return []byte("\"" + self.GetOXMName() + "\""), nil
28604 }
28605}
28606
28607type OxmIdTunMetadata8Masked struct {
28608 *OxmId
28609}
28610
28611type IOxmIdTunMetadata8Masked interface {
28612 IOxmId
28613}
28614
28615func (self *OxmIdTunMetadata8Masked) Serialize(encoder *goloxi.Encoder) error {
28616 if err := self.OxmId.Serialize(encoder); err != nil {
28617 return err
28618 }
28619
28620 return nil
28621}
28622
28623func DecodeOxmIdTunMetadata8Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata8Masked, error) {
28624 _oxmidtunmetadata8masked := &OxmIdTunMetadata8Masked{OxmId: parent}
28625 return _oxmidtunmetadata8masked, nil
28626}
28627
28628func NewOxmIdTunMetadata8Masked() *OxmIdTunMetadata8Masked {
28629 obj := &OxmIdTunMetadata8Masked{
28630 OxmId: NewOxmId(90616),
28631 }
28632 return obj
28633}
28634func (self *OxmIdTunMetadata8Masked) GetOXMName() string {
28635 return "tun_metadata8_masked"
28636}
28637
28638func (self *OxmIdTunMetadata8Masked) MarshalJSON() ([]byte, error) {
28639 if self.TypeLen == 0 {
28640 return []byte("\"\""), nil
28641 } else {
28642 return []byte("\"" + self.GetOXMName() + "\""), nil
28643 }
28644}
28645
28646type OxmIdTunMetadata9 struct {
28647 *OxmId
28648}
28649
28650type IOxmIdTunMetadata9 interface {
28651 IOxmId
28652}
28653
28654func (self *OxmIdTunMetadata9) Serialize(encoder *goloxi.Encoder) error {
28655 if err := self.OxmId.Serialize(encoder); err != nil {
28656 return err
28657 }
28658
28659 return nil
28660}
28661
28662func DecodeOxmIdTunMetadata9(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata9, error) {
28663 _oxmidtunmetadata9 := &OxmIdTunMetadata9{OxmId: parent}
28664 return _oxmidtunmetadata9, nil
28665}
28666
28667func NewOxmIdTunMetadata9() *OxmIdTunMetadata9 {
28668 obj := &OxmIdTunMetadata9{
28669 OxmId: NewOxmId(90748),
28670 }
28671 return obj
28672}
28673func (self *OxmIdTunMetadata9) GetOXMName() string {
28674 return "tun_metadata9"
28675}
28676
28677func (self *OxmIdTunMetadata9) MarshalJSON() ([]byte, error) {
28678 if self.TypeLen == 0 {
28679 return []byte("\"\""), nil
28680 } else {
28681 return []byte("\"" + self.GetOXMName() + "\""), nil
28682 }
28683}
28684
28685type OxmIdTunMetadata9Masked struct {
28686 *OxmId
28687}
28688
28689type IOxmIdTunMetadata9Masked interface {
28690 IOxmId
28691}
28692
28693func (self *OxmIdTunMetadata9Masked) Serialize(encoder *goloxi.Encoder) error {
28694 if err := self.OxmId.Serialize(encoder); err != nil {
28695 return err
28696 }
28697
28698 return nil
28699}
28700
28701func DecodeOxmIdTunMetadata9Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata9Masked, error) {
28702 _oxmidtunmetadata9masked := &OxmIdTunMetadata9Masked{OxmId: parent}
28703 return _oxmidtunmetadata9masked, nil
28704}
28705
28706func NewOxmIdTunMetadata9Masked() *OxmIdTunMetadata9Masked {
28707 obj := &OxmIdTunMetadata9Masked{
28708 OxmId: NewOxmId(91128),
28709 }
28710 return obj
28711}
28712func (self *OxmIdTunMetadata9Masked) GetOXMName() string {
28713 return "tun_metadata9_masked"
28714}
28715
28716func (self *OxmIdTunMetadata9Masked) MarshalJSON() ([]byte, error) {
28717 if self.TypeLen == 0 {
28718 return []byte("\"\""), nil
28719 } else {
28720 return []byte("\"" + self.GetOXMName() + "\""), nil
28721 }
28722}
28723
28724type OxmIdTunSrc struct {
28725 *OxmId
28726}
28727
28728type IOxmIdTunSrc interface {
28729 IOxmId
28730}
28731
28732func (self *OxmIdTunSrc) Serialize(encoder *goloxi.Encoder) error {
28733 if err := self.OxmId.Serialize(encoder); err != nil {
28734 return err
28735 }
28736
28737 return nil
28738}
28739
28740func DecodeOxmIdTunSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunSrc, error) {
28741 _oxmidtunsrc := &OxmIdTunSrc{OxmId: parent}
28742 return _oxmidtunsrc, nil
28743}
28744
28745func NewOxmIdTunSrc() *OxmIdTunSrc {
28746 obj := &OxmIdTunSrc{
28747 OxmId: NewOxmId(81412),
28748 }
28749 return obj
28750}
28751func (self *OxmIdTunSrc) GetOXMName() string {
28752 return "tun_src"
28753}
28754
28755func (self *OxmIdTunSrc) MarshalJSON() ([]byte, error) {
28756 if self.TypeLen == 0 {
28757 return []byte("\"\""), nil
28758 } else {
28759 return []byte("\"" + self.GetOXMName() + "\""), nil
28760 }
28761}
28762
28763type OxmIdTunSrcMasked struct {
28764 *OxmId
28765}
28766
28767type IOxmIdTunSrcMasked interface {
28768 IOxmId
28769}
28770
28771func (self *OxmIdTunSrcMasked) Serialize(encoder *goloxi.Encoder) error {
28772 if err := self.OxmId.Serialize(encoder); err != nil {
28773 return err
28774 }
28775
28776 return nil
28777}
28778
28779func DecodeOxmIdTunSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunSrcMasked, error) {
28780 _oxmidtunsrcmasked := &OxmIdTunSrcMasked{OxmId: parent}
28781 return _oxmidtunsrcmasked, nil
28782}
28783
28784func NewOxmIdTunSrcMasked() *OxmIdTunSrcMasked {
28785 obj := &OxmIdTunSrcMasked{
28786 OxmId: NewOxmId(81672),
28787 }
28788 return obj
28789}
28790func (self *OxmIdTunSrcMasked) GetOXMName() string {
28791 return "tun_src_masked"
28792}
28793
28794func (self *OxmIdTunSrcMasked) MarshalJSON() ([]byte, error) {
28795 if self.TypeLen == 0 {
28796 return []byte("\"\""), nil
28797 } else {
28798 return []byte("\"" + self.GetOXMName() + "\""), nil
28799 }
28800}
28801
28802type OxmIdUdpDst struct {
28803 *OxmId
28804}
28805
28806type IOxmIdUdpDst interface {
28807 IOxmId
28808}
28809
28810func (self *OxmIdUdpDst) Serialize(encoder *goloxi.Encoder) error {
28811 if err := self.OxmId.Serialize(encoder); err != nil {
28812 return err
28813 }
28814
28815 return nil
28816}
28817
28818func DecodeOxmIdUdpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpDst, error) {
28819 _oxmidudpdst := &OxmIdUdpDst{OxmId: parent}
28820 return _oxmidudpdst, nil
28821}
28822
28823func NewOxmIdUdpDst() *OxmIdUdpDst {
28824 obj := &OxmIdUdpDst{
28825 OxmId: NewOxmId(6146),
28826 }
28827 return obj
28828}
28829func (self *OxmIdUdpDst) GetOXMName() string {
28830 return "udp_dst"
28831}
28832
28833func (self *OxmIdUdpDst) MarshalJSON() ([]byte, error) {
28834 if self.TypeLen == 0 {
28835 return []byte("\"\""), nil
28836 } else {
28837 return []byte("\"" + self.GetOXMName() + "\""), nil
28838 }
28839}
28840
28841type OxmIdUdpDstMasked struct {
28842 *OxmId
28843}
28844
28845type IOxmIdUdpDstMasked interface {
28846 IOxmId
28847}
28848
28849func (self *OxmIdUdpDstMasked) Serialize(encoder *goloxi.Encoder) error {
28850 if err := self.OxmId.Serialize(encoder); err != nil {
28851 return err
28852 }
28853
28854 return nil
28855}
28856
28857func DecodeOxmIdUdpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpDstMasked, error) {
28858 _oxmidudpdstmasked := &OxmIdUdpDstMasked{OxmId: parent}
28859 return _oxmidudpdstmasked, nil
28860}
28861
28862func NewOxmIdUdpDstMasked() *OxmIdUdpDstMasked {
28863 obj := &OxmIdUdpDstMasked{
28864 OxmId: NewOxmId(6404),
28865 }
28866 return obj
28867}
28868func (self *OxmIdUdpDstMasked) GetOXMName() string {
28869 return "udp_dst_masked"
28870}
28871
28872func (self *OxmIdUdpDstMasked) MarshalJSON() ([]byte, error) {
28873 if self.TypeLen == 0 {
28874 return []byte("\"\""), nil
28875 } else {
28876 return []byte("\"" + self.GetOXMName() + "\""), nil
28877 }
28878}
28879
28880type OxmIdUdpSrc struct {
28881 *OxmId
28882}
28883
28884type IOxmIdUdpSrc interface {
28885 IOxmId
28886}
28887
28888func (self *OxmIdUdpSrc) Serialize(encoder *goloxi.Encoder) error {
28889 if err := self.OxmId.Serialize(encoder); err != nil {
28890 return err
28891 }
28892
28893 return nil
28894}
28895
28896func DecodeOxmIdUdpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpSrc, error) {
28897 _oxmidudpsrc := &OxmIdUdpSrc{OxmId: parent}
28898 return _oxmidudpsrc, nil
28899}
28900
28901func NewOxmIdUdpSrc() *OxmIdUdpSrc {
28902 obj := &OxmIdUdpSrc{
28903 OxmId: NewOxmId(5634),
28904 }
28905 return obj
28906}
28907func (self *OxmIdUdpSrc) GetOXMName() string {
28908 return "udp_src"
28909}
28910
28911func (self *OxmIdUdpSrc) MarshalJSON() ([]byte, error) {
28912 if self.TypeLen == 0 {
28913 return []byte("\"\""), nil
28914 } else {
28915 return []byte("\"" + self.GetOXMName() + "\""), nil
28916 }
28917}
28918
28919type OxmIdUdpSrcMasked struct {
28920 *OxmId
28921}
28922
28923type IOxmIdUdpSrcMasked interface {
28924 IOxmId
28925}
28926
28927func (self *OxmIdUdpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
28928 if err := self.OxmId.Serialize(encoder); err != nil {
28929 return err
28930 }
28931
28932 return nil
28933}
28934
28935func DecodeOxmIdUdpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpSrcMasked, error) {
28936 _oxmidudpsrcmasked := &OxmIdUdpSrcMasked{OxmId: parent}
28937 return _oxmidudpsrcmasked, nil
28938}
28939
28940func NewOxmIdUdpSrcMasked() *OxmIdUdpSrcMasked {
28941 obj := &OxmIdUdpSrcMasked{
28942 OxmId: NewOxmId(5892),
28943 }
28944 return obj
28945}
28946func (self *OxmIdUdpSrcMasked) GetOXMName() string {
28947 return "udp_src_masked"
28948}
28949
28950func (self *OxmIdUdpSrcMasked) MarshalJSON() ([]byte, error) {
28951 if self.TypeLen == 0 {
28952 return []byte("\"\""), nil
28953 } else {
28954 return []byte("\"" + self.GetOXMName() + "\""), nil
28955 }
28956}
28957
28958type OxmIdVlanTci struct {
28959 *OxmId
28960}
28961
28962type IOxmIdVlanTci interface {
28963 IOxmId
28964}
28965
28966func (self *OxmIdVlanTci) Serialize(encoder *goloxi.Encoder) error {
28967 if err := self.OxmId.Serialize(encoder); err != nil {
28968 return err
28969 }
28970
28971 return nil
28972}
28973
28974func DecodeOxmIdVlanTci(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanTci, error) {
28975 _oxmidvlantci := &OxmIdVlanTci{OxmId: parent}
28976 return _oxmidvlantci, nil
28977}
28978
28979func NewOxmIdVlanTci() *OxmIdVlanTci {
28980 obj := &OxmIdVlanTci{
28981 OxmId: NewOxmId(2050),
28982 }
28983 return obj
28984}
28985func (self *OxmIdVlanTci) GetOXMName() string {
28986 return "vlan_tci"
28987}
28988
28989func (self *OxmIdVlanTci) MarshalJSON() ([]byte, error) {
28990 if self.TypeLen == 0 {
28991 return []byte("\"\""), nil
28992 } else {
28993 return []byte("\"" + self.GetOXMName() + "\""), nil
28994 }
28995}
28996
28997type OxmIdVlanTciMasked struct {
28998 *OxmId
28999}
29000
29001type IOxmIdVlanTciMasked interface {
29002 IOxmId
29003}
29004
29005func (self *OxmIdVlanTciMasked) Serialize(encoder *goloxi.Encoder) error {
29006 if err := self.OxmId.Serialize(encoder); err != nil {
29007 return err
29008 }
29009
29010 return nil
29011}
29012
29013func DecodeOxmIdVlanTciMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanTciMasked, error) {
29014 _oxmidvlantcimasked := &OxmIdVlanTciMasked{OxmId: parent}
29015 return _oxmidvlantcimasked, nil
29016}
29017
29018func NewOxmIdVlanTciMasked() *OxmIdVlanTciMasked {
29019 obj := &OxmIdVlanTciMasked{
29020 OxmId: NewOxmId(2308),
29021 }
29022 return obj
29023}
29024func (self *OxmIdVlanTciMasked) GetOXMName() string {
29025 return "vlan_tci_masked"
29026}
29027
29028func (self *OxmIdVlanTciMasked) MarshalJSON() ([]byte, error) {
29029 if self.TypeLen == 0 {
29030 return []byte("\"\""), nil
29031 } else {
29032 return []byte("\"" + self.GetOXMName() + "\""), nil
29033 }
29034}
29035
29036type OxmIdXxreg0 struct {
29037 *OxmId
29038}
29039
29040type IOxmIdXxreg0 interface {
29041 IOxmId
29042}
29043
29044func (self *OxmIdXxreg0) Serialize(encoder *goloxi.Encoder) error {
29045 if err := self.OxmId.Serialize(encoder); err != nil {
29046 return err
29047 }
29048
29049 return nil
29050}
29051
29052func DecodeOxmIdXxreg0(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg0, error) {
29053 _oxmidxxreg0 := &OxmIdXxreg0{OxmId: parent}
29054 return _oxmidxxreg0, nil
29055}
29056
29057func NewOxmIdXxreg0() *OxmIdXxreg0 {
29058 obj := &OxmIdXxreg0{
29059 OxmId: NewOxmId(122384),
29060 }
29061 return obj
29062}
29063func (self *OxmIdXxreg0) GetOXMName() string {
29064 return "xxreg0"
29065}
29066
29067func (self *OxmIdXxreg0) MarshalJSON() ([]byte, error) {
29068 if self.TypeLen == 0 {
29069 return []byte("\"\""), nil
29070 } else {
29071 return []byte("\"" + self.GetOXMName() + "\""), nil
29072 }
29073}
29074
29075type OxmIdXxreg0Masked struct {
29076 *OxmId
29077}
29078
29079type IOxmIdXxreg0Masked interface {
29080 IOxmId
29081}
29082
29083func (self *OxmIdXxreg0Masked) Serialize(encoder *goloxi.Encoder) error {
29084 if err := self.OxmId.Serialize(encoder); err != nil {
29085 return err
29086 }
29087
29088 return nil
29089}
29090
29091func DecodeOxmIdXxreg0Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg0Masked, error) {
29092 _oxmidxxreg0masked := &OxmIdXxreg0Masked{OxmId: parent}
29093 return _oxmidxxreg0masked, nil
29094}
29095
29096func NewOxmIdXxreg0Masked() *OxmIdXxreg0Masked {
29097 obj := &OxmIdXxreg0Masked{
29098 OxmId: NewOxmId(122656),
29099 }
29100 return obj
29101}
29102func (self *OxmIdXxreg0Masked) GetOXMName() string {
29103 return "xxreg0_masked"
29104}
29105
29106func (self *OxmIdXxreg0Masked) MarshalJSON() ([]byte, error) {
29107 if self.TypeLen == 0 {
29108 return []byte("\"\""), nil
29109 } else {
29110 return []byte("\"" + self.GetOXMName() + "\""), nil
29111 }
29112}
29113
29114type OxmIdXxreg1 struct {
29115 *OxmId
29116}
29117
29118type IOxmIdXxreg1 interface {
29119 IOxmId
29120}
29121
29122func (self *OxmIdXxreg1) Serialize(encoder *goloxi.Encoder) error {
29123 if err := self.OxmId.Serialize(encoder); err != nil {
29124 return err
29125 }
29126
29127 return nil
29128}
29129
29130func DecodeOxmIdXxreg1(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg1, error) {
29131 _oxmidxxreg1 := &OxmIdXxreg1{OxmId: parent}
29132 return _oxmidxxreg1, nil
29133}
29134
29135func NewOxmIdXxreg1() *OxmIdXxreg1 {
29136 obj := &OxmIdXxreg1{
29137 OxmId: NewOxmId(122896),
29138 }
29139 return obj
29140}
29141func (self *OxmIdXxreg1) GetOXMName() string {
29142 return "xxreg1"
29143}
29144
29145func (self *OxmIdXxreg1) MarshalJSON() ([]byte, error) {
29146 if self.TypeLen == 0 {
29147 return []byte("\"\""), nil
29148 } else {
29149 return []byte("\"" + self.GetOXMName() + "\""), nil
29150 }
29151}
29152
29153type OxmIdXxreg1Masked struct {
29154 *OxmId
29155}
29156
29157type IOxmIdXxreg1Masked interface {
29158 IOxmId
29159}
29160
29161func (self *OxmIdXxreg1Masked) Serialize(encoder *goloxi.Encoder) error {
29162 if err := self.OxmId.Serialize(encoder); err != nil {
29163 return err
29164 }
29165
29166 return nil
29167}
29168
29169func DecodeOxmIdXxreg1Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg1Masked, error) {
29170 _oxmidxxreg1masked := &OxmIdXxreg1Masked{OxmId: parent}
29171 return _oxmidxxreg1masked, nil
29172}
29173
29174func NewOxmIdXxreg1Masked() *OxmIdXxreg1Masked {
29175 obj := &OxmIdXxreg1Masked{
29176 OxmId: NewOxmId(123168),
29177 }
29178 return obj
29179}
29180func (self *OxmIdXxreg1Masked) GetOXMName() string {
29181 return "xxreg1_masked"
29182}
29183
29184func (self *OxmIdXxreg1Masked) MarshalJSON() ([]byte, error) {
29185 if self.TypeLen == 0 {
29186 return []byte("\"\""), nil
29187 } else {
29188 return []byte("\"" + self.GetOXMName() + "\""), nil
29189 }
29190}
29191
29192type OxmIdXxreg2 struct {
29193 *OxmId
29194}
29195
29196type IOxmIdXxreg2 interface {
29197 IOxmId
29198}
29199
29200func (self *OxmIdXxreg2) Serialize(encoder *goloxi.Encoder) error {
29201 if err := self.OxmId.Serialize(encoder); err != nil {
29202 return err
29203 }
29204
29205 return nil
29206}
29207
29208func DecodeOxmIdXxreg2(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg2, error) {
29209 _oxmidxxreg2 := &OxmIdXxreg2{OxmId: parent}
29210 return _oxmidxxreg2, nil
29211}
29212
29213func NewOxmIdXxreg2() *OxmIdXxreg2 {
29214 obj := &OxmIdXxreg2{
29215 OxmId: NewOxmId(123408),
29216 }
29217 return obj
29218}
29219func (self *OxmIdXxreg2) GetOXMName() string {
29220 return "xxreg2"
29221}
29222
29223func (self *OxmIdXxreg2) MarshalJSON() ([]byte, error) {
29224 if self.TypeLen == 0 {
29225 return []byte("\"\""), nil
29226 } else {
29227 return []byte("\"" + self.GetOXMName() + "\""), nil
29228 }
29229}
29230
29231type OxmIdXxreg2Masked struct {
29232 *OxmId
29233}
29234
29235type IOxmIdXxreg2Masked interface {
29236 IOxmId
29237}
29238
29239func (self *OxmIdXxreg2Masked) Serialize(encoder *goloxi.Encoder) error {
29240 if err := self.OxmId.Serialize(encoder); err != nil {
29241 return err
29242 }
29243
29244 return nil
29245}
29246
29247func DecodeOxmIdXxreg2Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg2Masked, error) {
29248 _oxmidxxreg2masked := &OxmIdXxreg2Masked{OxmId: parent}
29249 return _oxmidxxreg2masked, nil
29250}
29251
29252func NewOxmIdXxreg2Masked() *OxmIdXxreg2Masked {
29253 obj := &OxmIdXxreg2Masked{
29254 OxmId: NewOxmId(123680),
29255 }
29256 return obj
29257}
29258func (self *OxmIdXxreg2Masked) GetOXMName() string {
29259 return "xxreg2_masked"
29260}
29261
29262func (self *OxmIdXxreg2Masked) MarshalJSON() ([]byte, error) {
29263 if self.TypeLen == 0 {
29264 return []byte("\"\""), nil
29265 } else {
29266 return []byte("\"" + self.GetOXMName() + "\""), nil
29267 }
29268}
29269
29270type OxmIdXxreg3 struct {
29271 *OxmId
29272}
29273
29274type IOxmIdXxreg3 interface {
29275 IOxmId
29276}
29277
29278func (self *OxmIdXxreg3) Serialize(encoder *goloxi.Encoder) error {
29279 if err := self.OxmId.Serialize(encoder); err != nil {
29280 return err
29281 }
29282
29283 return nil
29284}
29285
29286func DecodeOxmIdXxreg3(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg3, error) {
29287 _oxmidxxreg3 := &OxmIdXxreg3{OxmId: parent}
29288 return _oxmidxxreg3, nil
29289}
29290
29291func NewOxmIdXxreg3() *OxmIdXxreg3 {
29292 obj := &OxmIdXxreg3{
29293 OxmId: NewOxmId(123920),
29294 }
29295 return obj
29296}
29297func (self *OxmIdXxreg3) GetOXMName() string {
29298 return "xxreg3"
29299}
29300
29301func (self *OxmIdXxreg3) MarshalJSON() ([]byte, error) {
29302 if self.TypeLen == 0 {
29303 return []byte("\"\""), nil
29304 } else {
29305 return []byte("\"" + self.GetOXMName() + "\""), nil
29306 }
29307}
29308
29309type OxmIdXxreg3Masked struct {
29310 *OxmId
29311}
29312
29313type IOxmIdXxreg3Masked interface {
29314 IOxmId
29315}
29316
29317func (self *OxmIdXxreg3Masked) Serialize(encoder *goloxi.Encoder) error {
29318 if err := self.OxmId.Serialize(encoder); err != nil {
29319 return err
29320 }
29321
29322 return nil
29323}
29324
29325func DecodeOxmIdXxreg3Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg3Masked, error) {
29326 _oxmidxxreg3masked := &OxmIdXxreg3Masked{OxmId: parent}
29327 return _oxmidxxreg3masked, nil
29328}
29329
29330func NewOxmIdXxreg3Masked() *OxmIdXxreg3Masked {
29331 obj := &OxmIdXxreg3Masked{
29332 OxmId: NewOxmId(124192),
29333 }
29334 return obj
29335}
29336func (self *OxmIdXxreg3Masked) GetOXMName() string {
29337 return "xxreg3_masked"
29338}
29339
29340func (self *OxmIdXxreg3Masked) MarshalJSON() ([]byte, error) {
29341 if self.TypeLen == 0 {
29342 return []byte("\"\""), nil
29343 } else {
29344 return []byte("\"" + self.GetOXMName() + "\""), nil
29345 }
29346}
29347
29348type OxmIdActsetOutput struct {
29349 *OxmId
29350}
29351
29352type IOxmIdActsetOutput interface {
29353 IOxmId
29354}
29355
29356func (self *OxmIdActsetOutput) Serialize(encoder *goloxi.Encoder) error {
29357 if err := self.OxmId.Serialize(encoder); err != nil {
29358 return err
29359 }
29360
29361 return nil
29362}
29363
29364func DecodeOxmIdActsetOutput(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdActsetOutput, error) {
29365 _oxmidactsetoutput := &OxmIdActsetOutput{OxmId: parent}
29366 return _oxmidactsetoutput, nil
29367}
29368
29369func NewOxmIdActsetOutput() *OxmIdActsetOutput {
29370 obj := &OxmIdActsetOutput{
29371 OxmId: NewOxmId(2147505668),
29372 }
29373 return obj
29374}
29375func (self *OxmIdActsetOutput) GetOXMName() string {
29376 return "actset_output"
29377}
29378
29379func (self *OxmIdActsetOutput) MarshalJSON() ([]byte, error) {
29380 if self.TypeLen == 0 {
29381 return []byte("\"\""), nil
29382 } else {
29383 return []byte("\"" + self.GetOXMName() + "\""), nil
29384 }
29385}
29386
29387type OxmIdActsetOutputMasked struct {
29388 *OxmId
29389}
29390
29391type IOxmIdActsetOutputMasked interface {
29392 IOxmId
29393}
29394
29395func (self *OxmIdActsetOutputMasked) Serialize(encoder *goloxi.Encoder) error {
29396 if err := self.OxmId.Serialize(encoder); err != nil {
29397 return err
29398 }
29399
29400 return nil
29401}
29402
29403func DecodeOxmIdActsetOutputMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdActsetOutputMasked, error) {
29404 _oxmidactsetoutputmasked := &OxmIdActsetOutputMasked{OxmId: parent}
29405 return _oxmidactsetoutputmasked, nil
29406}
29407
29408func NewOxmIdActsetOutputMasked() *OxmIdActsetOutputMasked {
29409 obj := &OxmIdActsetOutputMasked{
29410 OxmId: NewOxmId(2147505928),
29411 }
29412 return obj
29413}
29414func (self *OxmIdActsetOutputMasked) GetOXMName() string {
29415 return "actset_output_masked"
29416}
29417
29418func (self *OxmIdActsetOutputMasked) MarshalJSON() ([]byte, error) {
29419 if self.TypeLen == 0 {
29420 return []byte("\"\""), nil
29421 } else {
29422 return []byte("\"" + self.GetOXMName() + "\""), nil
29423 }
29424}
29425
29426type OxmIdArpOpMasked struct {
29427 *OxmId
29428}
29429
29430type IOxmIdArpOpMasked interface {
29431 IOxmId
29432}
29433
29434func (self *OxmIdArpOpMasked) Serialize(encoder *goloxi.Encoder) error {
29435 if err := self.OxmId.Serialize(encoder); err != nil {
29436 return err
29437 }
29438
29439 return nil
29440}
29441
29442func DecodeOxmIdArpOpMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpOpMasked, error) {
29443 _oxmidarpopmasked := &OxmIdArpOpMasked{OxmId: parent}
29444 return _oxmidarpopmasked, nil
29445}
29446
29447func NewOxmIdArpOpMasked() *OxmIdArpOpMasked {
29448 obj := &OxmIdArpOpMasked{
29449 OxmId: NewOxmId(2147494660),
29450 }
29451 return obj
29452}
29453func (self *OxmIdArpOpMasked) GetOXMName() string {
29454 return "arp_op_masked"
29455}
29456
29457func (self *OxmIdArpOpMasked) MarshalJSON() ([]byte, error) {
29458 if self.TypeLen == 0 {
29459 return []byte("\"\""), nil
29460 } else {
29461 return []byte("\"" + self.GetOXMName() + "\""), nil
29462 }
29463}
29464
29465type OxmIdBsnEgrPortGroupId struct {
29466 *OxmId
29467}
29468
29469type IOxmIdBsnEgrPortGroupId interface {
29470 IOxmId
29471}
29472
29473func (self *OxmIdBsnEgrPortGroupId) Serialize(encoder *goloxi.Encoder) error {
29474 if err := self.OxmId.Serialize(encoder); err != nil {
29475 return err
29476 }
29477
29478 return nil
29479}
29480
29481func DecodeOxmIdBsnEgrPortGroupId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnEgrPortGroupId, error) {
29482 _oxmidbsnegrportgroupid := &OxmIdBsnEgrPortGroupId{OxmId: parent}
29483 return _oxmidbsnegrportgroupid, nil
29484}
29485
29486func NewOxmIdBsnEgrPortGroupId() *OxmIdBsnEgrPortGroupId {
29487 obj := &OxmIdBsnEgrPortGroupId{
29488 OxmId: NewOxmId(200196),
29489 }
29490 return obj
29491}
29492func (self *OxmIdBsnEgrPortGroupId) GetOXMName() string {
29493 return "bsn_egr_port_group_id"
29494}
29495
29496func (self *OxmIdBsnEgrPortGroupId) MarshalJSON() ([]byte, error) {
29497 if self.TypeLen == 0 {
29498 return []byte("\"\""), nil
29499 } else {
29500 return []byte("\"" + self.GetOXMName() + "\""), nil
29501 }
29502}
29503
29504type OxmIdBsnEgrPortGroupIdMasked struct {
29505 *OxmId
29506}
29507
29508type IOxmIdBsnEgrPortGroupIdMasked interface {
29509 IOxmId
29510}
29511
29512func (self *OxmIdBsnEgrPortGroupIdMasked) Serialize(encoder *goloxi.Encoder) error {
29513 if err := self.OxmId.Serialize(encoder); err != nil {
29514 return err
29515 }
29516
29517 return nil
29518}
29519
29520func DecodeOxmIdBsnEgrPortGroupIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnEgrPortGroupIdMasked, error) {
29521 _oxmidbsnegrportgroupidmasked := &OxmIdBsnEgrPortGroupIdMasked{OxmId: parent}
29522 return _oxmidbsnegrportgroupidmasked, nil
29523}
29524
29525func NewOxmIdBsnEgrPortGroupIdMasked() *OxmIdBsnEgrPortGroupIdMasked {
29526 obj := &OxmIdBsnEgrPortGroupIdMasked{
29527 OxmId: NewOxmId(200456),
29528 }
29529 return obj
29530}
29531func (self *OxmIdBsnEgrPortGroupIdMasked) GetOXMName() string {
29532 return "bsn_egr_port_group_id_masked"
29533}
29534
29535func (self *OxmIdBsnEgrPortGroupIdMasked) MarshalJSON() ([]byte, error) {
29536 if self.TypeLen == 0 {
29537 return []byte("\"\""), nil
29538 } else {
29539 return []byte("\"" + self.GetOXMName() + "\""), nil
29540 }
29541}
29542
29543type OxmIdBsnIfpClassId struct {
29544 *OxmId
29545}
29546
29547type IOxmIdBsnIfpClassId interface {
29548 IOxmId
29549}
29550
29551func (self *OxmIdBsnIfpClassId) Serialize(encoder *goloxi.Encoder) error {
29552 if err := self.OxmId.Serialize(encoder); err != nil {
29553 return err
29554 }
29555
29556 return nil
29557}
29558
29559func DecodeOxmIdBsnIfpClassId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnIfpClassId, error) {
29560 _oxmidbsnifpclassid := &OxmIdBsnIfpClassId{OxmId: parent}
29561 return _oxmidbsnifpclassid, nil
29562}
29563
29564func NewOxmIdBsnIfpClassId() *OxmIdBsnIfpClassId {
29565 obj := &OxmIdBsnIfpClassId{
29566 OxmId: NewOxmId(210436),
29567 }
29568 return obj
29569}
29570func (self *OxmIdBsnIfpClassId) GetOXMName() string {
29571 return "bsn_ifp_class_id"
29572}
29573
29574func (self *OxmIdBsnIfpClassId) MarshalJSON() ([]byte, error) {
29575 if self.TypeLen == 0 {
29576 return []byte("\"\""), nil
29577 } else {
29578 return []byte("\"" + self.GetOXMName() + "\""), nil
29579 }
29580}
29581
29582type OxmIdBsnIfpClassIdMasked struct {
29583 *OxmId
29584}
29585
29586type IOxmIdBsnIfpClassIdMasked interface {
29587 IOxmId
29588}
29589
29590func (self *OxmIdBsnIfpClassIdMasked) Serialize(encoder *goloxi.Encoder) error {
29591 if err := self.OxmId.Serialize(encoder); err != nil {
29592 return err
29593 }
29594
29595 return nil
29596}
29597
29598func DecodeOxmIdBsnIfpClassIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnIfpClassIdMasked, error) {
29599 _oxmidbsnifpclassidmasked := &OxmIdBsnIfpClassIdMasked{OxmId: parent}
29600 return _oxmidbsnifpclassidmasked, nil
29601}
29602
29603func NewOxmIdBsnIfpClassIdMasked() *OxmIdBsnIfpClassIdMasked {
29604 obj := &OxmIdBsnIfpClassIdMasked{
29605 OxmId: NewOxmId(210696),
29606 }
29607 return obj
29608}
29609func (self *OxmIdBsnIfpClassIdMasked) GetOXMName() string {
29610 return "bsn_ifp_class_id_masked"
29611}
29612
29613func (self *OxmIdBsnIfpClassIdMasked) MarshalJSON() ([]byte, error) {
29614 if self.TypeLen == 0 {
29615 return []byte("\"\""), nil
29616 } else {
29617 return []byte("\"" + self.GetOXMName() + "\""), nil
29618 }
29619}
29620
29621type OxmIdBsnInPorts128 struct {
29622 *OxmId
29623}
29624
29625type IOxmIdBsnInPorts128 interface {
29626 IOxmId
29627}
29628
29629func (self *OxmIdBsnInPorts128) Serialize(encoder *goloxi.Encoder) error {
29630 if err := self.OxmId.Serialize(encoder); err != nil {
29631 return err
29632 }
29633
29634 return nil
29635}
29636
29637func DecodeOxmIdBsnInPorts128(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInPorts128, error) {
29638 _oxmidbsninports128 := &OxmIdBsnInPorts128{OxmId: parent}
29639 return _oxmidbsninports128, nil
29640}
29641
29642func NewOxmIdBsnInPorts128() *OxmIdBsnInPorts128 {
29643 obj := &OxmIdBsnInPorts128{
29644 OxmId: NewOxmId(196624),
29645 }
29646 return obj
29647}
29648func (self *OxmIdBsnInPorts128) GetOXMName() string {
29649 return "bsn_in_ports_128"
29650}
29651
29652func (self *OxmIdBsnInPorts128) MarshalJSON() ([]byte, error) {
29653 if self.TypeLen == 0 {
29654 return []byte("\"\""), nil
29655 } else {
29656 return []byte("\"" + self.GetOXMName() + "\""), nil
29657 }
29658}
29659
29660type OxmIdBsnInPorts128Masked struct {
29661 *OxmId
29662}
29663
29664type IOxmIdBsnInPorts128Masked interface {
29665 IOxmId
29666}
29667
29668func (self *OxmIdBsnInPorts128Masked) Serialize(encoder *goloxi.Encoder) error {
29669 if err := self.OxmId.Serialize(encoder); err != nil {
29670 return err
29671 }
29672
29673 return nil
29674}
29675
29676func DecodeOxmIdBsnInPorts128Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInPorts128Masked, error) {
29677 _oxmidbsninports128masked := &OxmIdBsnInPorts128Masked{OxmId: parent}
29678 return _oxmidbsninports128masked, nil
29679}
29680
29681func NewOxmIdBsnInPorts128Masked() *OxmIdBsnInPorts128Masked {
29682 obj := &OxmIdBsnInPorts128Masked{
29683 OxmId: NewOxmId(196896),
29684 }
29685 return obj
29686}
29687func (self *OxmIdBsnInPorts128Masked) GetOXMName() string {
29688 return "bsn_in_ports_128_masked"
29689}
29690
29691func (self *OxmIdBsnInPorts128Masked) MarshalJSON() ([]byte, error) {
29692 if self.TypeLen == 0 {
29693 return []byte("\"\""), nil
29694 } else {
29695 return []byte("\"" + self.GetOXMName() + "\""), nil
29696 }
29697}
29698
29699type OxmIdBsnInPorts512 struct {
29700 *OxmId
29701}
29702
29703type IOxmIdBsnInPorts512 interface {
29704 IOxmId
29705}
29706
29707func (self *OxmIdBsnInPorts512) Serialize(encoder *goloxi.Encoder) error {
29708 if err := self.OxmId.Serialize(encoder); err != nil {
29709 return err
29710 }
29711
29712 return nil
29713}
29714
29715func DecodeOxmIdBsnInPorts512(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInPorts512, error) {
29716 _oxmidbsninports512 := &OxmIdBsnInPorts512{OxmId: parent}
29717 return _oxmidbsninports512, nil
29718}
29719
29720func NewOxmIdBsnInPorts512() *OxmIdBsnInPorts512 {
29721 obj := &OxmIdBsnInPorts512{
29722 OxmId: NewOxmId(206400),
29723 }
29724 return obj
29725}
29726func (self *OxmIdBsnInPorts512) GetOXMName() string {
29727 return "bsn_in_ports_512"
29728}
29729
29730func (self *OxmIdBsnInPorts512) MarshalJSON() ([]byte, error) {
29731 if self.TypeLen == 0 {
29732 return []byte("\"\""), nil
29733 } else {
29734 return []byte("\"" + self.GetOXMName() + "\""), nil
29735 }
29736}
29737
29738type OxmIdBsnInPorts512Masked struct {
29739 *OxmId
29740}
29741
29742type IOxmIdBsnInPorts512Masked interface {
29743 IOxmId
29744}
29745
29746func (self *OxmIdBsnInPorts512Masked) Serialize(encoder *goloxi.Encoder) error {
29747 if err := self.OxmId.Serialize(encoder); err != nil {
29748 return err
29749 }
29750
29751 return nil
29752}
29753
29754func DecodeOxmIdBsnInPorts512Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInPorts512Masked, error) {
29755 _oxmidbsninports512masked := &OxmIdBsnInPorts512Masked{OxmId: parent}
29756 return _oxmidbsninports512masked, nil
29757}
29758
29759func NewOxmIdBsnInPorts512Masked() *OxmIdBsnInPorts512Masked {
29760 obj := &OxmIdBsnInPorts512Masked{
29761 OxmId: NewOxmId(206720),
29762 }
29763 return obj
29764}
29765func (self *OxmIdBsnInPorts512Masked) GetOXMName() string {
29766 return "bsn_in_ports_512_masked"
29767}
29768
29769func (self *OxmIdBsnInPorts512Masked) MarshalJSON() ([]byte, error) {
29770 if self.TypeLen == 0 {
29771 return []byte("\"\""), nil
29772 } else {
29773 return []byte("\"" + self.GetOXMName() + "\""), nil
29774 }
29775}
29776
29777type OxmIdBsnIngressPortGroupId struct {
29778 *OxmId
29779}
29780
29781type IOxmIdBsnIngressPortGroupId interface {
29782 IOxmId
29783}
29784
29785func (self *OxmIdBsnIngressPortGroupId) Serialize(encoder *goloxi.Encoder) error {
29786 if err := self.OxmId.Serialize(encoder); err != nil {
29787 return err
29788 }
29789
29790 return nil
29791}
29792
29793func DecodeOxmIdBsnIngressPortGroupId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnIngressPortGroupId, error) {
29794 _oxmidbsningressportgroupid := &OxmIdBsnIngressPortGroupId{OxmId: parent}
29795 return _oxmidbsningressportgroupid, nil
29796}
29797
29798func NewOxmIdBsnIngressPortGroupId() *OxmIdBsnIngressPortGroupId {
29799 obj := &OxmIdBsnIngressPortGroupId{
29800 OxmId: NewOxmId(206852),
29801 }
29802 return obj
29803}
29804func (self *OxmIdBsnIngressPortGroupId) GetOXMName() string {
29805 return "bsn_ingress_port_group_id"
29806}
29807
29808func (self *OxmIdBsnIngressPortGroupId) MarshalJSON() ([]byte, error) {
29809 if self.TypeLen == 0 {
29810 return []byte("\"\""), nil
29811 } else {
29812 return []byte("\"" + self.GetOXMName() + "\""), nil
29813 }
29814}
29815
29816type OxmIdBsnIngressPortGroupIdMasked struct {
29817 *OxmId
29818}
29819
29820type IOxmIdBsnIngressPortGroupIdMasked interface {
29821 IOxmId
29822}
29823
29824func (self *OxmIdBsnIngressPortGroupIdMasked) Serialize(encoder *goloxi.Encoder) error {
29825 if err := self.OxmId.Serialize(encoder); err != nil {
29826 return err
29827 }
29828
29829 return nil
29830}
29831
29832func DecodeOxmIdBsnIngressPortGroupIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnIngressPortGroupIdMasked, error) {
29833 _oxmidbsningressportgroupidmasked := &OxmIdBsnIngressPortGroupIdMasked{OxmId: parent}
29834 return _oxmidbsningressportgroupidmasked, nil
29835}
29836
29837func NewOxmIdBsnIngressPortGroupIdMasked() *OxmIdBsnIngressPortGroupIdMasked {
29838 obj := &OxmIdBsnIngressPortGroupIdMasked{
29839 OxmId: NewOxmId(207112),
29840 }
29841 return obj
29842}
29843func (self *OxmIdBsnIngressPortGroupIdMasked) GetOXMName() string {
29844 return "bsn_ingress_port_group_id_masked"
29845}
29846
29847func (self *OxmIdBsnIngressPortGroupIdMasked) MarshalJSON() ([]byte, error) {
29848 if self.TypeLen == 0 {
29849 return []byte("\"\""), nil
29850 } else {
29851 return []byte("\"" + self.GetOXMName() + "\""), nil
29852 }
29853}
29854
29855type OxmIdBsnInnerEthDst struct {
29856 *OxmId
29857}
29858
29859type IOxmIdBsnInnerEthDst interface {
29860 IOxmId
29861}
29862
29863func (self *OxmIdBsnInnerEthDst) Serialize(encoder *goloxi.Encoder) error {
29864 if err := self.OxmId.Serialize(encoder); err != nil {
29865 return err
29866 }
29867
29868 return nil
29869}
29870
29871func DecodeOxmIdBsnInnerEthDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInnerEthDst, error) {
29872 _oxmidbsninnerethdst := &OxmIdBsnInnerEthDst{OxmId: parent}
29873 return _oxmidbsninnerethdst, nil
29874}
29875
29876func NewOxmIdBsnInnerEthDst() *OxmIdBsnInnerEthDst {
29877 obj := &OxmIdBsnInnerEthDst{
29878 OxmId: NewOxmId(207878),
29879 }
29880 return obj
29881}
29882func (self *OxmIdBsnInnerEthDst) GetOXMName() string {
29883 return "bsn_inner_eth_dst"
29884}
29885
29886func (self *OxmIdBsnInnerEthDst) MarshalJSON() ([]byte, error) {
29887 if self.TypeLen == 0 {
29888 return []byte("\"\""), nil
29889 } else {
29890 return []byte("\"" + self.GetOXMName() + "\""), nil
29891 }
29892}
29893
29894type OxmIdBsnInnerEthDstMasked struct {
29895 *OxmId
29896}
29897
29898type IOxmIdBsnInnerEthDstMasked interface {
29899 IOxmId
29900}
29901
29902func (self *OxmIdBsnInnerEthDstMasked) Serialize(encoder *goloxi.Encoder) error {
29903 if err := self.OxmId.Serialize(encoder); err != nil {
29904 return err
29905 }
29906
29907 return nil
29908}
29909
29910func DecodeOxmIdBsnInnerEthDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInnerEthDstMasked, error) {
29911 _oxmidbsninnerethdstmasked := &OxmIdBsnInnerEthDstMasked{OxmId: parent}
29912 return _oxmidbsninnerethdstmasked, nil
29913}
29914
29915func NewOxmIdBsnInnerEthDstMasked() *OxmIdBsnInnerEthDstMasked {
29916 obj := &OxmIdBsnInnerEthDstMasked{
29917 OxmId: NewOxmId(208140),
29918 }
29919 return obj
29920}
29921func (self *OxmIdBsnInnerEthDstMasked) GetOXMName() string {
29922 return "bsn_inner_eth_dst_masked"
29923}
29924
29925func (self *OxmIdBsnInnerEthDstMasked) MarshalJSON() ([]byte, error) {
29926 if self.TypeLen == 0 {
29927 return []byte("\"\""), nil
29928 } else {
29929 return []byte("\"" + self.GetOXMName() + "\""), nil
29930 }
29931}
29932
29933type OxmIdBsnInnerEthSrc struct {
29934 *OxmId
29935}
29936
29937type IOxmIdBsnInnerEthSrc interface {
29938 IOxmId
29939}
29940
29941func (self *OxmIdBsnInnerEthSrc) Serialize(encoder *goloxi.Encoder) error {
29942 if err := self.OxmId.Serialize(encoder); err != nil {
29943 return err
29944 }
29945
29946 return nil
29947}
29948
29949func DecodeOxmIdBsnInnerEthSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInnerEthSrc, error) {
29950 _oxmidbsninnerethsrc := &OxmIdBsnInnerEthSrc{OxmId: parent}
29951 return _oxmidbsninnerethsrc, nil
29952}
29953
29954func NewOxmIdBsnInnerEthSrc() *OxmIdBsnInnerEthSrc {
29955 obj := &OxmIdBsnInnerEthSrc{
29956 OxmId: NewOxmId(208390),
29957 }
29958 return obj
29959}
29960func (self *OxmIdBsnInnerEthSrc) GetOXMName() string {
29961 return "bsn_inner_eth_src"
29962}
29963
29964func (self *OxmIdBsnInnerEthSrc) MarshalJSON() ([]byte, error) {
29965 if self.TypeLen == 0 {
29966 return []byte("\"\""), nil
29967 } else {
29968 return []byte("\"" + self.GetOXMName() + "\""), nil
29969 }
29970}
29971
29972type OxmIdBsnInnerEthSrcMasked struct {
29973 *OxmId
29974}
29975
29976type IOxmIdBsnInnerEthSrcMasked interface {
29977 IOxmId
29978}
29979
29980func (self *OxmIdBsnInnerEthSrcMasked) Serialize(encoder *goloxi.Encoder) error {
29981 if err := self.OxmId.Serialize(encoder); err != nil {
29982 return err
29983 }
29984
29985 return nil
29986}
29987
29988func DecodeOxmIdBsnInnerEthSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInnerEthSrcMasked, error) {
29989 _oxmidbsninnerethsrcmasked := &OxmIdBsnInnerEthSrcMasked{OxmId: parent}
29990 return _oxmidbsninnerethsrcmasked, nil
29991}
29992
29993func NewOxmIdBsnInnerEthSrcMasked() *OxmIdBsnInnerEthSrcMasked {
29994 obj := &OxmIdBsnInnerEthSrcMasked{
29995 OxmId: NewOxmId(208652),
29996 }
29997 return obj
29998}
29999func (self *OxmIdBsnInnerEthSrcMasked) GetOXMName() string {
30000 return "bsn_inner_eth_src_masked"
30001}
30002
30003func (self *OxmIdBsnInnerEthSrcMasked) MarshalJSON() ([]byte, error) {
30004 if self.TypeLen == 0 {
30005 return []byte("\"\""), nil
30006 } else {
30007 return []byte("\"" + self.GetOXMName() + "\""), nil
30008 }
30009}
30010
30011type OxmIdBsnInnerVlanVid struct {
30012 *OxmId
30013}
30014
30015type IOxmIdBsnInnerVlanVid interface {
30016 IOxmId
30017}
30018
30019func (self *OxmIdBsnInnerVlanVid) Serialize(encoder *goloxi.Encoder) error {
30020 if err := self.OxmId.Serialize(encoder); err != nil {
30021 return err
30022 }
30023
30024 return nil
30025}
30026
30027func DecodeOxmIdBsnInnerVlanVid(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInnerVlanVid, error) {
30028 _oxmidbsninnervlanvid := &OxmIdBsnInnerVlanVid{OxmId: parent}
30029 return _oxmidbsninnervlanvid, nil
30030}
30031
30032func NewOxmIdBsnInnerVlanVid() *OxmIdBsnInnerVlanVid {
30033 obj := &OxmIdBsnInnerVlanVid{
30034 OxmId: NewOxmId(208898),
30035 }
30036 return obj
30037}
30038func (self *OxmIdBsnInnerVlanVid) GetOXMName() string {
30039 return "bsn_inner_vlan_vid"
30040}
30041
30042func (self *OxmIdBsnInnerVlanVid) MarshalJSON() ([]byte, error) {
30043 if self.TypeLen == 0 {
30044 return []byte("\"\""), nil
30045 } else {
30046 return []byte("\"" + self.GetOXMName() + "\""), nil
30047 }
30048}
30049
30050type OxmIdBsnInnerVlanVidMasked struct {
30051 *OxmId
30052}
30053
30054type IOxmIdBsnInnerVlanVidMasked interface {
30055 IOxmId
30056}
30057
30058func (self *OxmIdBsnInnerVlanVidMasked) Serialize(encoder *goloxi.Encoder) error {
30059 if err := self.OxmId.Serialize(encoder); err != nil {
30060 return err
30061 }
30062
30063 return nil
30064}
30065
30066func DecodeOxmIdBsnInnerVlanVidMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInnerVlanVidMasked, error) {
30067 _oxmidbsninnervlanvidmasked := &OxmIdBsnInnerVlanVidMasked{OxmId: parent}
30068 return _oxmidbsninnervlanvidmasked, nil
30069}
30070
30071func NewOxmIdBsnInnerVlanVidMasked() *OxmIdBsnInnerVlanVidMasked {
30072 obj := &OxmIdBsnInnerVlanVidMasked{
30073 OxmId: NewOxmId(209156),
30074 }
30075 return obj
30076}
30077func (self *OxmIdBsnInnerVlanVidMasked) GetOXMName() string {
30078 return "bsn_inner_vlan_vid_masked"
30079}
30080
30081func (self *OxmIdBsnInnerVlanVidMasked) MarshalJSON() ([]byte, error) {
30082 if self.TypeLen == 0 {
30083 return []byte("\"\""), nil
30084 } else {
30085 return []byte("\"" + self.GetOXMName() + "\""), nil
30086 }
30087}
30088
30089type OxmIdBsnIpFragmentation struct {
30090 *OxmId
30091}
30092
30093type IOxmIdBsnIpFragmentation interface {
30094 IOxmId
30095}
30096
30097func (self *OxmIdBsnIpFragmentation) Serialize(encoder *goloxi.Encoder) error {
30098 if err := self.OxmId.Serialize(encoder); err != nil {
30099 return err
30100 }
30101
30102 return nil
30103}
30104
30105func DecodeOxmIdBsnIpFragmentation(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnIpFragmentation, error) {
30106 _oxmidbsnipfragmentation := &OxmIdBsnIpFragmentation{OxmId: parent}
30107 return _oxmidbsnipfragmentation, nil
30108}
30109
30110func NewOxmIdBsnIpFragmentation() *OxmIdBsnIpFragmentation {
30111 obj := &OxmIdBsnIpFragmentation{
30112 OxmId: NewOxmId(209921),
30113 }
30114 return obj
30115}
30116func (self *OxmIdBsnIpFragmentation) GetOXMName() string {
30117 return "bsn_ip_fragmentation"
30118}
30119
30120func (self *OxmIdBsnIpFragmentation) MarshalJSON() ([]byte, error) {
30121 if self.TypeLen == 0 {
30122 return []byte("\"\""), nil
30123 } else {
30124 return []byte("\"" + self.GetOXMName() + "\""), nil
30125 }
30126}
30127
30128type OxmIdBsnIpFragmentationMasked struct {
30129 *OxmId
30130}
30131
30132type IOxmIdBsnIpFragmentationMasked interface {
30133 IOxmId
30134}
30135
30136func (self *OxmIdBsnIpFragmentationMasked) Serialize(encoder *goloxi.Encoder) error {
30137 if err := self.OxmId.Serialize(encoder); err != nil {
30138 return err
30139 }
30140
30141 return nil
30142}
30143
30144func DecodeOxmIdBsnIpFragmentationMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnIpFragmentationMasked, error) {
30145 _oxmidbsnipfragmentationmasked := &OxmIdBsnIpFragmentationMasked{OxmId: parent}
30146 return _oxmidbsnipfragmentationmasked, nil
30147}
30148
30149func NewOxmIdBsnIpFragmentationMasked() *OxmIdBsnIpFragmentationMasked {
30150 obj := &OxmIdBsnIpFragmentationMasked{
30151 OxmId: NewOxmId(210178),
30152 }
30153 return obj
30154}
30155func (self *OxmIdBsnIpFragmentationMasked) GetOXMName() string {
30156 return "bsn_ip_fragmentation_masked"
30157}
30158
30159func (self *OxmIdBsnIpFragmentationMasked) MarshalJSON() ([]byte, error) {
30160 if self.TypeLen == 0 {
30161 return []byte("\"\""), nil
30162 } else {
30163 return []byte("\"" + self.GetOXMName() + "\""), nil
30164 }
30165}
30166
30167type OxmIdBsnL2CacheHit struct {
30168 *OxmId
30169}
30170
30171type IOxmIdBsnL2CacheHit interface {
30172 IOxmId
30173}
30174
30175func (self *OxmIdBsnL2CacheHit) Serialize(encoder *goloxi.Encoder) error {
30176 if err := self.OxmId.Serialize(encoder); err != nil {
30177 return err
30178 }
30179
30180 return nil
30181}
30182
30183func DecodeOxmIdBsnL2CacheHit(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL2CacheHit, error) {
30184 _oxmidbsnl2cachehit := &OxmIdBsnL2CacheHit{OxmId: parent}
30185 return _oxmidbsnl2cachehit, nil
30186}
30187
30188func NewOxmIdBsnL2CacheHit() *OxmIdBsnL2CacheHit {
30189 obj := &OxmIdBsnL2CacheHit{
30190 OxmId: NewOxmId(205825),
30191 }
30192 return obj
30193}
30194func (self *OxmIdBsnL2CacheHit) GetOXMName() string {
30195 return "bsn_l2_cache_hit"
30196}
30197
30198func (self *OxmIdBsnL2CacheHit) MarshalJSON() ([]byte, error) {
30199 if self.TypeLen == 0 {
30200 return []byte("\"\""), nil
30201 } else {
30202 return []byte("\"" + self.GetOXMName() + "\""), nil
30203 }
30204}
30205
30206type OxmIdBsnL2CacheHitMasked struct {
30207 *OxmId
30208}
30209
30210type IOxmIdBsnL2CacheHitMasked interface {
30211 IOxmId
30212}
30213
30214func (self *OxmIdBsnL2CacheHitMasked) Serialize(encoder *goloxi.Encoder) error {
30215 if err := self.OxmId.Serialize(encoder); err != nil {
30216 return err
30217 }
30218
30219 return nil
30220}
30221
30222func DecodeOxmIdBsnL2CacheHitMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL2CacheHitMasked, error) {
30223 _oxmidbsnl2cachehitmasked := &OxmIdBsnL2CacheHitMasked{OxmId: parent}
30224 return _oxmidbsnl2cachehitmasked, nil
30225}
30226
30227func NewOxmIdBsnL2CacheHitMasked() *OxmIdBsnL2CacheHitMasked {
30228 obj := &OxmIdBsnL2CacheHitMasked{
30229 OxmId: NewOxmId(206082),
30230 }
30231 return obj
30232}
30233func (self *OxmIdBsnL2CacheHitMasked) GetOXMName() string {
30234 return "bsn_l2_cache_hit_masked"
30235}
30236
30237func (self *OxmIdBsnL2CacheHitMasked) MarshalJSON() ([]byte, error) {
30238 if self.TypeLen == 0 {
30239 return []byte("\"\""), nil
30240 } else {
30241 return []byte("\"" + self.GetOXMName() + "\""), nil
30242 }
30243}
30244
30245type OxmIdBsnL3InterfaceClassId struct {
30246 *OxmId
30247}
30248
30249type IOxmIdBsnL3InterfaceClassId interface {
30250 IOxmId
30251}
30252
30253func (self *OxmIdBsnL3InterfaceClassId) Serialize(encoder *goloxi.Encoder) error {
30254 if err := self.OxmId.Serialize(encoder); err != nil {
30255 return err
30256 }
30257
30258 return nil
30259}
30260
30261func DecodeOxmIdBsnL3InterfaceClassId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL3InterfaceClassId, error) {
30262 _oxmidbsnl3interfaceclassid := &OxmIdBsnL3InterfaceClassId{OxmId: parent}
30263 return _oxmidbsnl3interfaceclassid, nil
30264}
30265
30266func NewOxmIdBsnL3InterfaceClassId() *OxmIdBsnL3InterfaceClassId {
30267 obj := &OxmIdBsnL3InterfaceClassId{
30268 OxmId: NewOxmId(198660),
30269 }
30270 return obj
30271}
30272func (self *OxmIdBsnL3InterfaceClassId) GetOXMName() string {
30273 return "bsn_l3_interface_class_id"
30274}
30275
30276func (self *OxmIdBsnL3InterfaceClassId) MarshalJSON() ([]byte, error) {
30277 if self.TypeLen == 0 {
30278 return []byte("\"\""), nil
30279 } else {
30280 return []byte("\"" + self.GetOXMName() + "\""), nil
30281 }
30282}
30283
30284type OxmIdBsnL3InterfaceClassIdMasked struct {
30285 *OxmId
30286}
30287
30288type IOxmIdBsnL3InterfaceClassIdMasked interface {
30289 IOxmId
30290}
30291
30292func (self *OxmIdBsnL3InterfaceClassIdMasked) Serialize(encoder *goloxi.Encoder) error {
30293 if err := self.OxmId.Serialize(encoder); err != nil {
30294 return err
30295 }
30296
30297 return nil
30298}
30299
30300func DecodeOxmIdBsnL3InterfaceClassIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL3InterfaceClassIdMasked, error) {
30301 _oxmidbsnl3interfaceclassidmasked := &OxmIdBsnL3InterfaceClassIdMasked{OxmId: parent}
30302 return _oxmidbsnl3interfaceclassidmasked, nil
30303}
30304
30305func NewOxmIdBsnL3InterfaceClassIdMasked() *OxmIdBsnL3InterfaceClassIdMasked {
30306 obj := &OxmIdBsnL3InterfaceClassIdMasked{
30307 OxmId: NewOxmId(198920),
30308 }
30309 return obj
30310}
30311func (self *OxmIdBsnL3InterfaceClassIdMasked) GetOXMName() string {
30312 return "bsn_l3_interface_class_id_masked"
30313}
30314
30315func (self *OxmIdBsnL3InterfaceClassIdMasked) MarshalJSON() ([]byte, error) {
30316 if self.TypeLen == 0 {
30317 return []byte("\"\""), nil
30318 } else {
30319 return []byte("\"" + self.GetOXMName() + "\""), nil
30320 }
30321}
30322
30323type OxmIdBsnL3SrcClassId struct {
30324 *OxmId
30325}
30326
30327type IOxmIdBsnL3SrcClassId interface {
30328 IOxmId
30329}
30330
30331func (self *OxmIdBsnL3SrcClassId) Serialize(encoder *goloxi.Encoder) error {
30332 if err := self.OxmId.Serialize(encoder); err != nil {
30333 return err
30334 }
30335
30336 return nil
30337}
30338
30339func DecodeOxmIdBsnL3SrcClassId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL3SrcClassId, error) {
30340 _oxmidbsnl3srcclassid := &OxmIdBsnL3SrcClassId{OxmId: parent}
30341 return _oxmidbsnl3srcclassid, nil
30342}
30343
30344func NewOxmIdBsnL3SrcClassId() *OxmIdBsnL3SrcClassId {
30345 obj := &OxmIdBsnL3SrcClassId{
30346 OxmId: NewOxmId(199172),
30347 }
30348 return obj
30349}
30350func (self *OxmIdBsnL3SrcClassId) GetOXMName() string {
30351 return "bsn_l3_src_class_id"
30352}
30353
30354func (self *OxmIdBsnL3SrcClassId) MarshalJSON() ([]byte, error) {
30355 if self.TypeLen == 0 {
30356 return []byte("\"\""), nil
30357 } else {
30358 return []byte("\"" + self.GetOXMName() + "\""), nil
30359 }
30360}
30361
30362type OxmIdBsnL3SrcClassIdMasked struct {
30363 *OxmId
30364}
30365
30366type IOxmIdBsnL3SrcClassIdMasked interface {
30367 IOxmId
30368}
30369
30370func (self *OxmIdBsnL3SrcClassIdMasked) Serialize(encoder *goloxi.Encoder) error {
30371 if err := self.OxmId.Serialize(encoder); err != nil {
30372 return err
30373 }
30374
30375 return nil
30376}
30377
30378func DecodeOxmIdBsnL3SrcClassIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL3SrcClassIdMasked, error) {
30379 _oxmidbsnl3srcclassidmasked := &OxmIdBsnL3SrcClassIdMasked{OxmId: parent}
30380 return _oxmidbsnl3srcclassidmasked, nil
30381}
30382
30383func NewOxmIdBsnL3SrcClassIdMasked() *OxmIdBsnL3SrcClassIdMasked {
30384 obj := &OxmIdBsnL3SrcClassIdMasked{
30385 OxmId: NewOxmId(199432),
30386 }
30387 return obj
30388}
30389func (self *OxmIdBsnL3SrcClassIdMasked) GetOXMName() string {
30390 return "bsn_l3_src_class_id_masked"
30391}
30392
30393func (self *OxmIdBsnL3SrcClassIdMasked) MarshalJSON() ([]byte, error) {
30394 if self.TypeLen == 0 {
30395 return []byte("\"\""), nil
30396 } else {
30397 return []byte("\"" + self.GetOXMName() + "\""), nil
30398 }
30399}
30400
30401type OxmIdBsnLagId struct {
30402 *OxmId
30403}
30404
30405type IOxmIdBsnLagId interface {
30406 IOxmId
30407}
30408
30409func (self *OxmIdBsnLagId) Serialize(encoder *goloxi.Encoder) error {
30410 if err := self.OxmId.Serialize(encoder); err != nil {
30411 return err
30412 }
30413
30414 return nil
30415}
30416
30417func DecodeOxmIdBsnLagId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnLagId, error) {
30418 _oxmidbsnlagid := &OxmIdBsnLagId{OxmId: parent}
30419 return _oxmidbsnlagid, nil
30420}
30421
30422func NewOxmIdBsnLagId() *OxmIdBsnLagId {
30423 obj := &OxmIdBsnLagId{
30424 OxmId: NewOxmId(197124),
30425 }
30426 return obj
30427}
30428func (self *OxmIdBsnLagId) GetOXMName() string {
30429 return "bsn_lag_id"
30430}
30431
30432func (self *OxmIdBsnLagId) MarshalJSON() ([]byte, error) {
30433 if self.TypeLen == 0 {
30434 return []byte("\"\""), nil
30435 } else {
30436 return []byte("\"" + self.GetOXMName() + "\""), nil
30437 }
30438}
30439
30440type OxmIdBsnLagIdMasked struct {
30441 *OxmId
30442}
30443
30444type IOxmIdBsnLagIdMasked interface {
30445 IOxmId
30446}
30447
30448func (self *OxmIdBsnLagIdMasked) Serialize(encoder *goloxi.Encoder) error {
30449 if err := self.OxmId.Serialize(encoder); err != nil {
30450 return err
30451 }
30452
30453 return nil
30454}
30455
30456func DecodeOxmIdBsnLagIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnLagIdMasked, error) {
30457 _oxmidbsnlagidmasked := &OxmIdBsnLagIdMasked{OxmId: parent}
30458 return _oxmidbsnlagidmasked, nil
30459}
30460
30461func NewOxmIdBsnLagIdMasked() *OxmIdBsnLagIdMasked {
30462 obj := &OxmIdBsnLagIdMasked{
30463 OxmId: NewOxmId(197384),
30464 }
30465 return obj
30466}
30467func (self *OxmIdBsnLagIdMasked) GetOXMName() string {
30468 return "bsn_lag_id_masked"
30469}
30470
30471func (self *OxmIdBsnLagIdMasked) MarshalJSON() ([]byte, error) {
30472 if self.TypeLen == 0 {
30473 return []byte("\"\""), nil
30474 } else {
30475 return []byte("\"" + self.GetOXMName() + "\""), nil
30476 }
30477}
30478
30479type OxmIdBsnTcpFlags struct {
30480 *OxmId
30481}
30482
30483type IOxmIdBsnTcpFlags interface {
30484 IOxmId
30485}
30486
30487func (self *OxmIdBsnTcpFlags) Serialize(encoder *goloxi.Encoder) error {
30488 if err := self.OxmId.Serialize(encoder); err != nil {
30489 return err
30490 }
30491
30492 return nil
30493}
30494
30495func DecodeOxmIdBsnTcpFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnTcpFlags, error) {
30496 _oxmidbsntcpflags := &OxmIdBsnTcpFlags{OxmId: parent}
30497 return _oxmidbsntcpflags, nil
30498}
30499
30500func NewOxmIdBsnTcpFlags() *OxmIdBsnTcpFlags {
30501 obj := &OxmIdBsnTcpFlags{
30502 OxmId: NewOxmId(204802),
30503 }
30504 return obj
30505}
30506func (self *OxmIdBsnTcpFlags) GetOXMName() string {
30507 return "bsn_tcp_flags"
30508}
30509
30510func (self *OxmIdBsnTcpFlags) MarshalJSON() ([]byte, error) {
30511 if self.TypeLen == 0 {
30512 return []byte("\"\""), nil
30513 } else {
30514 return []byte("\"" + self.GetOXMName() + "\""), nil
30515 }
30516}
30517
30518type OxmIdBsnTcpFlagsMasked struct {
30519 *OxmId
30520}
30521
30522type IOxmIdBsnTcpFlagsMasked interface {
30523 IOxmId
30524}
30525
30526func (self *OxmIdBsnTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
30527 if err := self.OxmId.Serialize(encoder); err != nil {
30528 return err
30529 }
30530
30531 return nil
30532}
30533
30534func DecodeOxmIdBsnTcpFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnTcpFlagsMasked, error) {
30535 _oxmidbsntcpflagsmasked := &OxmIdBsnTcpFlagsMasked{OxmId: parent}
30536 return _oxmidbsntcpflagsmasked, nil
30537}
30538
30539func NewOxmIdBsnTcpFlagsMasked() *OxmIdBsnTcpFlagsMasked {
30540 obj := &OxmIdBsnTcpFlagsMasked{
30541 OxmId: NewOxmId(205060),
30542 }
30543 return obj
30544}
30545func (self *OxmIdBsnTcpFlagsMasked) GetOXMName() string {
30546 return "bsn_tcp_flags_masked"
30547}
30548
30549func (self *OxmIdBsnTcpFlagsMasked) MarshalJSON() ([]byte, error) {
30550 if self.TypeLen == 0 {
30551 return []byte("\"\""), nil
30552 } else {
30553 return []byte("\"" + self.GetOXMName() + "\""), nil
30554 }
30555}
30556
30557type OxmIdBsnUdf0 struct {
30558 *OxmId
30559}
30560
30561type IOxmIdBsnUdf0 interface {
30562 IOxmId
30563}
30564
30565func (self *OxmIdBsnUdf0) Serialize(encoder *goloxi.Encoder) error {
30566 if err := self.OxmId.Serialize(encoder); err != nil {
30567 return err
30568 }
30569
30570 return nil
30571}
30572
30573func DecodeOxmIdBsnUdf0(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf0, error) {
30574 _oxmidbsnudf0 := &OxmIdBsnUdf0{OxmId: parent}
30575 return _oxmidbsnudf0, nil
30576}
30577
30578func NewOxmIdBsnUdf0() *OxmIdBsnUdf0 {
30579 obj := &OxmIdBsnUdf0{
30580 OxmId: NewOxmId(200708),
30581 }
30582 return obj
30583}
30584func (self *OxmIdBsnUdf0) GetOXMName() string {
30585 return "bsn_udf0"
30586}
30587
30588func (self *OxmIdBsnUdf0) MarshalJSON() ([]byte, error) {
30589 if self.TypeLen == 0 {
30590 return []byte("\"\""), nil
30591 } else {
30592 return []byte("\"" + self.GetOXMName() + "\""), nil
30593 }
30594}
30595
30596type OxmIdBsnUdf0Masked struct {
30597 *OxmId
30598}
30599
30600type IOxmIdBsnUdf0Masked interface {
30601 IOxmId
30602}
30603
30604func (self *OxmIdBsnUdf0Masked) Serialize(encoder *goloxi.Encoder) error {
30605 if err := self.OxmId.Serialize(encoder); err != nil {
30606 return err
30607 }
30608
30609 return nil
30610}
30611
30612func DecodeOxmIdBsnUdf0Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf0Masked, error) {
30613 _oxmidbsnudf0masked := &OxmIdBsnUdf0Masked{OxmId: parent}
30614 return _oxmidbsnudf0masked, nil
30615}
30616
30617func NewOxmIdBsnUdf0Masked() *OxmIdBsnUdf0Masked {
30618 obj := &OxmIdBsnUdf0Masked{
30619 OxmId: NewOxmId(200968),
30620 }
30621 return obj
30622}
30623func (self *OxmIdBsnUdf0Masked) GetOXMName() string {
30624 return "bsn_udf0_masked"
30625}
30626
30627func (self *OxmIdBsnUdf0Masked) MarshalJSON() ([]byte, error) {
30628 if self.TypeLen == 0 {
30629 return []byte("\"\""), nil
30630 } else {
30631 return []byte("\"" + self.GetOXMName() + "\""), nil
30632 }
30633}
30634
30635type OxmIdBsnUdf1 struct {
30636 *OxmId
30637}
30638
30639type IOxmIdBsnUdf1 interface {
30640 IOxmId
30641}
30642
30643func (self *OxmIdBsnUdf1) Serialize(encoder *goloxi.Encoder) error {
30644 if err := self.OxmId.Serialize(encoder); err != nil {
30645 return err
30646 }
30647
30648 return nil
30649}
30650
30651func DecodeOxmIdBsnUdf1(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf1, error) {
30652 _oxmidbsnudf1 := &OxmIdBsnUdf1{OxmId: parent}
30653 return _oxmidbsnudf1, nil
30654}
30655
30656func NewOxmIdBsnUdf1() *OxmIdBsnUdf1 {
30657 obj := &OxmIdBsnUdf1{
30658 OxmId: NewOxmId(201220),
30659 }
30660 return obj
30661}
30662func (self *OxmIdBsnUdf1) GetOXMName() string {
30663 return "bsn_udf1"
30664}
30665
30666func (self *OxmIdBsnUdf1) MarshalJSON() ([]byte, error) {
30667 if self.TypeLen == 0 {
30668 return []byte("\"\""), nil
30669 } else {
30670 return []byte("\"" + self.GetOXMName() + "\""), nil
30671 }
30672}
30673
30674type OxmIdBsnUdf1Masked struct {
30675 *OxmId
30676}
30677
30678type IOxmIdBsnUdf1Masked interface {
30679 IOxmId
30680}
30681
30682func (self *OxmIdBsnUdf1Masked) Serialize(encoder *goloxi.Encoder) error {
30683 if err := self.OxmId.Serialize(encoder); err != nil {
30684 return err
30685 }
30686
30687 return nil
30688}
30689
30690func DecodeOxmIdBsnUdf1Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf1Masked, error) {
30691 _oxmidbsnudf1masked := &OxmIdBsnUdf1Masked{OxmId: parent}
30692 return _oxmidbsnudf1masked, nil
30693}
30694
30695func NewOxmIdBsnUdf1Masked() *OxmIdBsnUdf1Masked {
30696 obj := &OxmIdBsnUdf1Masked{
30697 OxmId: NewOxmId(201480),
30698 }
30699 return obj
30700}
30701func (self *OxmIdBsnUdf1Masked) GetOXMName() string {
30702 return "bsn_udf1_masked"
30703}
30704
30705func (self *OxmIdBsnUdf1Masked) MarshalJSON() ([]byte, error) {
30706 if self.TypeLen == 0 {
30707 return []byte("\"\""), nil
30708 } else {
30709 return []byte("\"" + self.GetOXMName() + "\""), nil
30710 }
30711}
30712
30713type OxmIdBsnUdf2 struct {
30714 *OxmId
30715}
30716
30717type IOxmIdBsnUdf2 interface {
30718 IOxmId
30719}
30720
30721func (self *OxmIdBsnUdf2) Serialize(encoder *goloxi.Encoder) error {
30722 if err := self.OxmId.Serialize(encoder); err != nil {
30723 return err
30724 }
30725
30726 return nil
30727}
30728
30729func DecodeOxmIdBsnUdf2(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf2, error) {
30730 _oxmidbsnudf2 := &OxmIdBsnUdf2{OxmId: parent}
30731 return _oxmidbsnudf2, nil
30732}
30733
30734func NewOxmIdBsnUdf2() *OxmIdBsnUdf2 {
30735 obj := &OxmIdBsnUdf2{
30736 OxmId: NewOxmId(201732),
30737 }
30738 return obj
30739}
30740func (self *OxmIdBsnUdf2) GetOXMName() string {
30741 return "bsn_udf2"
30742}
30743
30744func (self *OxmIdBsnUdf2) MarshalJSON() ([]byte, error) {
30745 if self.TypeLen == 0 {
30746 return []byte("\"\""), nil
30747 } else {
30748 return []byte("\"" + self.GetOXMName() + "\""), nil
30749 }
30750}
30751
30752type OxmIdBsnUdf2Masked struct {
30753 *OxmId
30754}
30755
30756type IOxmIdBsnUdf2Masked interface {
30757 IOxmId
30758}
30759
30760func (self *OxmIdBsnUdf2Masked) Serialize(encoder *goloxi.Encoder) error {
30761 if err := self.OxmId.Serialize(encoder); err != nil {
30762 return err
30763 }
30764
30765 return nil
30766}
30767
30768func DecodeOxmIdBsnUdf2Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf2Masked, error) {
30769 _oxmidbsnudf2masked := &OxmIdBsnUdf2Masked{OxmId: parent}
30770 return _oxmidbsnudf2masked, nil
30771}
30772
30773func NewOxmIdBsnUdf2Masked() *OxmIdBsnUdf2Masked {
30774 obj := &OxmIdBsnUdf2Masked{
30775 OxmId: NewOxmId(201992),
30776 }
30777 return obj
30778}
30779func (self *OxmIdBsnUdf2Masked) GetOXMName() string {
30780 return "bsn_udf2_masked"
30781}
30782
30783func (self *OxmIdBsnUdf2Masked) MarshalJSON() ([]byte, error) {
30784 if self.TypeLen == 0 {
30785 return []byte("\"\""), nil
30786 } else {
30787 return []byte("\"" + self.GetOXMName() + "\""), nil
30788 }
30789}
30790
30791type OxmIdBsnUdf3 struct {
30792 *OxmId
30793}
30794
30795type IOxmIdBsnUdf3 interface {
30796 IOxmId
30797}
30798
30799func (self *OxmIdBsnUdf3) Serialize(encoder *goloxi.Encoder) error {
30800 if err := self.OxmId.Serialize(encoder); err != nil {
30801 return err
30802 }
30803
30804 return nil
30805}
30806
30807func DecodeOxmIdBsnUdf3(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf3, error) {
30808 _oxmidbsnudf3 := &OxmIdBsnUdf3{OxmId: parent}
30809 return _oxmidbsnudf3, nil
30810}
30811
30812func NewOxmIdBsnUdf3() *OxmIdBsnUdf3 {
30813 obj := &OxmIdBsnUdf3{
30814 OxmId: NewOxmId(202244),
30815 }
30816 return obj
30817}
30818func (self *OxmIdBsnUdf3) GetOXMName() string {
30819 return "bsn_udf3"
30820}
30821
30822func (self *OxmIdBsnUdf3) MarshalJSON() ([]byte, error) {
30823 if self.TypeLen == 0 {
30824 return []byte("\"\""), nil
30825 } else {
30826 return []byte("\"" + self.GetOXMName() + "\""), nil
30827 }
30828}
30829
30830type OxmIdBsnUdf3Masked struct {
30831 *OxmId
30832}
30833
30834type IOxmIdBsnUdf3Masked interface {
30835 IOxmId
30836}
30837
30838func (self *OxmIdBsnUdf3Masked) Serialize(encoder *goloxi.Encoder) error {
30839 if err := self.OxmId.Serialize(encoder); err != nil {
30840 return err
30841 }
30842
30843 return nil
30844}
30845
30846func DecodeOxmIdBsnUdf3Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf3Masked, error) {
30847 _oxmidbsnudf3masked := &OxmIdBsnUdf3Masked{OxmId: parent}
30848 return _oxmidbsnudf3masked, nil
30849}
30850
30851func NewOxmIdBsnUdf3Masked() *OxmIdBsnUdf3Masked {
30852 obj := &OxmIdBsnUdf3Masked{
30853 OxmId: NewOxmId(202504),
30854 }
30855 return obj
30856}
30857func (self *OxmIdBsnUdf3Masked) GetOXMName() string {
30858 return "bsn_udf3_masked"
30859}
30860
30861func (self *OxmIdBsnUdf3Masked) MarshalJSON() ([]byte, error) {
30862 if self.TypeLen == 0 {
30863 return []byte("\"\""), nil
30864 } else {
30865 return []byte("\"" + self.GetOXMName() + "\""), nil
30866 }
30867}
30868
30869type OxmIdBsnUdf4 struct {
30870 *OxmId
30871}
30872
30873type IOxmIdBsnUdf4 interface {
30874 IOxmId
30875}
30876
30877func (self *OxmIdBsnUdf4) Serialize(encoder *goloxi.Encoder) error {
30878 if err := self.OxmId.Serialize(encoder); err != nil {
30879 return err
30880 }
30881
30882 return nil
30883}
30884
30885func DecodeOxmIdBsnUdf4(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf4, error) {
30886 _oxmidbsnudf4 := &OxmIdBsnUdf4{OxmId: parent}
30887 return _oxmidbsnudf4, nil
30888}
30889
30890func NewOxmIdBsnUdf4() *OxmIdBsnUdf4 {
30891 obj := &OxmIdBsnUdf4{
30892 OxmId: NewOxmId(202756),
30893 }
30894 return obj
30895}
30896func (self *OxmIdBsnUdf4) GetOXMName() string {
30897 return "bsn_udf4"
30898}
30899
30900func (self *OxmIdBsnUdf4) MarshalJSON() ([]byte, error) {
30901 if self.TypeLen == 0 {
30902 return []byte("\"\""), nil
30903 } else {
30904 return []byte("\"" + self.GetOXMName() + "\""), nil
30905 }
30906}
30907
30908type OxmIdBsnUdf4Masked struct {
30909 *OxmId
30910}
30911
30912type IOxmIdBsnUdf4Masked interface {
30913 IOxmId
30914}
30915
30916func (self *OxmIdBsnUdf4Masked) Serialize(encoder *goloxi.Encoder) error {
30917 if err := self.OxmId.Serialize(encoder); err != nil {
30918 return err
30919 }
30920
30921 return nil
30922}
30923
30924func DecodeOxmIdBsnUdf4Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf4Masked, error) {
30925 _oxmidbsnudf4masked := &OxmIdBsnUdf4Masked{OxmId: parent}
30926 return _oxmidbsnudf4masked, nil
30927}
30928
30929func NewOxmIdBsnUdf4Masked() *OxmIdBsnUdf4Masked {
30930 obj := &OxmIdBsnUdf4Masked{
30931 OxmId: NewOxmId(203016),
30932 }
30933 return obj
30934}
30935func (self *OxmIdBsnUdf4Masked) GetOXMName() string {
30936 return "bsn_udf4_masked"
30937}
30938
30939func (self *OxmIdBsnUdf4Masked) MarshalJSON() ([]byte, error) {
30940 if self.TypeLen == 0 {
30941 return []byte("\"\""), nil
30942 } else {
30943 return []byte("\"" + self.GetOXMName() + "\""), nil
30944 }
30945}
30946
30947type OxmIdBsnUdf5 struct {
30948 *OxmId
30949}
30950
30951type IOxmIdBsnUdf5 interface {
30952 IOxmId
30953}
30954
30955func (self *OxmIdBsnUdf5) Serialize(encoder *goloxi.Encoder) error {
30956 if err := self.OxmId.Serialize(encoder); err != nil {
30957 return err
30958 }
30959
30960 return nil
30961}
30962
30963func DecodeOxmIdBsnUdf5(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf5, error) {
30964 _oxmidbsnudf5 := &OxmIdBsnUdf5{OxmId: parent}
30965 return _oxmidbsnudf5, nil
30966}
30967
30968func NewOxmIdBsnUdf5() *OxmIdBsnUdf5 {
30969 obj := &OxmIdBsnUdf5{
30970 OxmId: NewOxmId(203268),
30971 }
30972 return obj
30973}
30974func (self *OxmIdBsnUdf5) GetOXMName() string {
30975 return "bsn_udf5"
30976}
30977
30978func (self *OxmIdBsnUdf5) MarshalJSON() ([]byte, error) {
30979 if self.TypeLen == 0 {
30980 return []byte("\"\""), nil
30981 } else {
30982 return []byte("\"" + self.GetOXMName() + "\""), nil
30983 }
30984}
30985
30986type OxmIdBsnUdf5Masked struct {
30987 *OxmId
30988}
30989
30990type IOxmIdBsnUdf5Masked interface {
30991 IOxmId
30992}
30993
30994func (self *OxmIdBsnUdf5Masked) Serialize(encoder *goloxi.Encoder) error {
30995 if err := self.OxmId.Serialize(encoder); err != nil {
30996 return err
30997 }
30998
30999 return nil
31000}
31001
31002func DecodeOxmIdBsnUdf5Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf5Masked, error) {
31003 _oxmidbsnudf5masked := &OxmIdBsnUdf5Masked{OxmId: parent}
31004 return _oxmidbsnudf5masked, nil
31005}
31006
31007func NewOxmIdBsnUdf5Masked() *OxmIdBsnUdf5Masked {
31008 obj := &OxmIdBsnUdf5Masked{
31009 OxmId: NewOxmId(203528),
31010 }
31011 return obj
31012}
31013func (self *OxmIdBsnUdf5Masked) GetOXMName() string {
31014 return "bsn_udf5_masked"
31015}
31016
31017func (self *OxmIdBsnUdf5Masked) MarshalJSON() ([]byte, error) {
31018 if self.TypeLen == 0 {
31019 return []byte("\"\""), nil
31020 } else {
31021 return []byte("\"" + self.GetOXMName() + "\""), nil
31022 }
31023}
31024
31025type OxmIdBsnUdf6 struct {
31026 *OxmId
31027}
31028
31029type IOxmIdBsnUdf6 interface {
31030 IOxmId
31031}
31032
31033func (self *OxmIdBsnUdf6) Serialize(encoder *goloxi.Encoder) error {
31034 if err := self.OxmId.Serialize(encoder); err != nil {
31035 return err
31036 }
31037
31038 return nil
31039}
31040
31041func DecodeOxmIdBsnUdf6(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf6, error) {
31042 _oxmidbsnudf6 := &OxmIdBsnUdf6{OxmId: parent}
31043 return _oxmidbsnudf6, nil
31044}
31045
31046func NewOxmIdBsnUdf6() *OxmIdBsnUdf6 {
31047 obj := &OxmIdBsnUdf6{
31048 OxmId: NewOxmId(203780),
31049 }
31050 return obj
31051}
31052func (self *OxmIdBsnUdf6) GetOXMName() string {
31053 return "bsn_udf6"
31054}
31055
31056func (self *OxmIdBsnUdf6) MarshalJSON() ([]byte, error) {
31057 if self.TypeLen == 0 {
31058 return []byte("\"\""), nil
31059 } else {
31060 return []byte("\"" + self.GetOXMName() + "\""), nil
31061 }
31062}
31063
31064type OxmIdBsnUdf6Masked struct {
31065 *OxmId
31066}
31067
31068type IOxmIdBsnUdf6Masked interface {
31069 IOxmId
31070}
31071
31072func (self *OxmIdBsnUdf6Masked) Serialize(encoder *goloxi.Encoder) error {
31073 if err := self.OxmId.Serialize(encoder); err != nil {
31074 return err
31075 }
31076
31077 return nil
31078}
31079
31080func DecodeOxmIdBsnUdf6Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf6Masked, error) {
31081 _oxmidbsnudf6masked := &OxmIdBsnUdf6Masked{OxmId: parent}
31082 return _oxmidbsnudf6masked, nil
31083}
31084
31085func NewOxmIdBsnUdf6Masked() *OxmIdBsnUdf6Masked {
31086 obj := &OxmIdBsnUdf6Masked{
31087 OxmId: NewOxmId(204040),
31088 }
31089 return obj
31090}
31091func (self *OxmIdBsnUdf6Masked) GetOXMName() string {
31092 return "bsn_udf6_masked"
31093}
31094
31095func (self *OxmIdBsnUdf6Masked) MarshalJSON() ([]byte, error) {
31096 if self.TypeLen == 0 {
31097 return []byte("\"\""), nil
31098 } else {
31099 return []byte("\"" + self.GetOXMName() + "\""), nil
31100 }
31101}
31102
31103type OxmIdBsnUdf7 struct {
31104 *OxmId
31105}
31106
31107type IOxmIdBsnUdf7 interface {
31108 IOxmId
31109}
31110
31111func (self *OxmIdBsnUdf7) Serialize(encoder *goloxi.Encoder) error {
31112 if err := self.OxmId.Serialize(encoder); err != nil {
31113 return err
31114 }
31115
31116 return nil
31117}
31118
31119func DecodeOxmIdBsnUdf7(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf7, error) {
31120 _oxmidbsnudf7 := &OxmIdBsnUdf7{OxmId: parent}
31121 return _oxmidbsnudf7, nil
31122}
31123
31124func NewOxmIdBsnUdf7() *OxmIdBsnUdf7 {
31125 obj := &OxmIdBsnUdf7{
31126 OxmId: NewOxmId(204292),
31127 }
31128 return obj
31129}
31130func (self *OxmIdBsnUdf7) GetOXMName() string {
31131 return "bsn_udf7"
31132}
31133
31134func (self *OxmIdBsnUdf7) MarshalJSON() ([]byte, error) {
31135 if self.TypeLen == 0 {
31136 return []byte("\"\""), nil
31137 } else {
31138 return []byte("\"" + self.GetOXMName() + "\""), nil
31139 }
31140}
31141
31142type OxmIdBsnUdf7Masked struct {
31143 *OxmId
31144}
31145
31146type IOxmIdBsnUdf7Masked interface {
31147 IOxmId
31148}
31149
31150func (self *OxmIdBsnUdf7Masked) Serialize(encoder *goloxi.Encoder) error {
31151 if err := self.OxmId.Serialize(encoder); err != nil {
31152 return err
31153 }
31154
31155 return nil
31156}
31157
31158func DecodeOxmIdBsnUdf7Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf7Masked, error) {
31159 _oxmidbsnudf7masked := &OxmIdBsnUdf7Masked{OxmId: parent}
31160 return _oxmidbsnudf7masked, nil
31161}
31162
31163func NewOxmIdBsnUdf7Masked() *OxmIdBsnUdf7Masked {
31164 obj := &OxmIdBsnUdf7Masked{
31165 OxmId: NewOxmId(204552),
31166 }
31167 return obj
31168}
31169func (self *OxmIdBsnUdf7Masked) GetOXMName() string {
31170 return "bsn_udf7_masked"
31171}
31172
31173func (self *OxmIdBsnUdf7Masked) MarshalJSON() ([]byte, error) {
31174 if self.TypeLen == 0 {
31175 return []byte("\"\""), nil
31176 } else {
31177 return []byte("\"" + self.GetOXMName() + "\""), nil
31178 }
31179}
31180
31181type OxmIdBsnVfi struct {
31182 *OxmId
31183}
31184
31185type IOxmIdBsnVfi interface {
31186 IOxmId
31187}
31188
31189func (self *OxmIdBsnVfi) Serialize(encoder *goloxi.Encoder) error {
31190 if err := self.OxmId.Serialize(encoder); err != nil {
31191 return err
31192 }
31193
31194 return nil
31195}
31196
31197func DecodeOxmIdBsnVfi(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVfi, error) {
31198 _oxmidbsnvfi := &OxmIdBsnVfi{OxmId: parent}
31199 return _oxmidbsnvfi, nil
31200}
31201
31202func NewOxmIdBsnVfi() *OxmIdBsnVfi {
31203 obj := &OxmIdBsnVfi{
31204 OxmId: NewOxmId(209410),
31205 }
31206 return obj
31207}
31208func (self *OxmIdBsnVfi) GetOXMName() string {
31209 return "bsn_vfi"
31210}
31211
31212func (self *OxmIdBsnVfi) MarshalJSON() ([]byte, error) {
31213 if self.TypeLen == 0 {
31214 return []byte("\"\""), nil
31215 } else {
31216 return []byte("\"" + self.GetOXMName() + "\""), nil
31217 }
31218}
31219
31220type OxmIdBsnVfiMasked struct {
31221 *OxmId
31222}
31223
31224type IOxmIdBsnVfiMasked interface {
31225 IOxmId
31226}
31227
31228func (self *OxmIdBsnVfiMasked) Serialize(encoder *goloxi.Encoder) error {
31229 if err := self.OxmId.Serialize(encoder); err != nil {
31230 return err
31231 }
31232
31233 return nil
31234}
31235
31236func DecodeOxmIdBsnVfiMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVfiMasked, error) {
31237 _oxmidbsnvfimasked := &OxmIdBsnVfiMasked{OxmId: parent}
31238 return _oxmidbsnvfimasked, nil
31239}
31240
31241func NewOxmIdBsnVfiMasked() *OxmIdBsnVfiMasked {
31242 obj := &OxmIdBsnVfiMasked{
31243 OxmId: NewOxmId(209668),
31244 }
31245 return obj
31246}
31247func (self *OxmIdBsnVfiMasked) GetOXMName() string {
31248 return "bsn_vfi_masked"
31249}
31250
31251func (self *OxmIdBsnVfiMasked) MarshalJSON() ([]byte, error) {
31252 if self.TypeLen == 0 {
31253 return []byte("\"\""), nil
31254 } else {
31255 return []byte("\"" + self.GetOXMName() + "\""), nil
31256 }
31257}
31258
31259type OxmIdBsnVlanXlatePortGroupId struct {
31260 *OxmId
31261}
31262
31263type IOxmIdBsnVlanXlatePortGroupId interface {
31264 IOxmId
31265}
31266
31267func (self *OxmIdBsnVlanXlatePortGroupId) Serialize(encoder *goloxi.Encoder) error {
31268 if err := self.OxmId.Serialize(encoder); err != nil {
31269 return err
31270 }
31271
31272 return nil
31273}
31274
31275func DecodeOxmIdBsnVlanXlatePortGroupId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVlanXlatePortGroupId, error) {
31276 _oxmidbsnvlanxlateportgroupid := &OxmIdBsnVlanXlatePortGroupId{OxmId: parent}
31277 return _oxmidbsnvlanxlateportgroupid, nil
31278}
31279
31280func NewOxmIdBsnVlanXlatePortGroupId() *OxmIdBsnVlanXlatePortGroupId {
31281 obj := &OxmIdBsnVlanXlatePortGroupId{
31282 OxmId: NewOxmId(205316),
31283 }
31284 return obj
31285}
31286func (self *OxmIdBsnVlanXlatePortGroupId) GetOXMName() string {
31287 return "bsn_vlan_xlate_port_group_id"
31288}
31289
31290func (self *OxmIdBsnVlanXlatePortGroupId) MarshalJSON() ([]byte, error) {
31291 if self.TypeLen == 0 {
31292 return []byte("\"\""), nil
31293 } else {
31294 return []byte("\"" + self.GetOXMName() + "\""), nil
31295 }
31296}
31297
31298type OxmIdBsnVlanXlatePortGroupIdMasked struct {
31299 *OxmId
31300}
31301
31302type IOxmIdBsnVlanXlatePortGroupIdMasked interface {
31303 IOxmId
31304}
31305
31306func (self *OxmIdBsnVlanXlatePortGroupIdMasked) Serialize(encoder *goloxi.Encoder) error {
31307 if err := self.OxmId.Serialize(encoder); err != nil {
31308 return err
31309 }
31310
31311 return nil
31312}
31313
31314func DecodeOxmIdBsnVlanXlatePortGroupIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVlanXlatePortGroupIdMasked, error) {
31315 _oxmidbsnvlanxlateportgroupidmasked := &OxmIdBsnVlanXlatePortGroupIdMasked{OxmId: parent}
31316 return _oxmidbsnvlanxlateportgroupidmasked, nil
31317}
31318
31319func NewOxmIdBsnVlanXlatePortGroupIdMasked() *OxmIdBsnVlanXlatePortGroupIdMasked {
31320 obj := &OxmIdBsnVlanXlatePortGroupIdMasked{
31321 OxmId: NewOxmId(205576),
31322 }
31323 return obj
31324}
31325func (self *OxmIdBsnVlanXlatePortGroupIdMasked) GetOXMName() string {
31326 return "bsn_vlan_xlate_port_group_id_masked"
31327}
31328
31329func (self *OxmIdBsnVlanXlatePortGroupIdMasked) MarshalJSON() ([]byte, error) {
31330 if self.TypeLen == 0 {
31331 return []byte("\"\""), nil
31332 } else {
31333 return []byte("\"" + self.GetOXMName() + "\""), nil
31334 }
31335}
31336
31337type OxmIdBsnVrf struct {
31338 *OxmId
31339}
31340
31341type IOxmIdBsnVrf interface {
31342 IOxmId
31343}
31344
31345func (self *OxmIdBsnVrf) Serialize(encoder *goloxi.Encoder) error {
31346 if err := self.OxmId.Serialize(encoder); err != nil {
31347 return err
31348 }
31349
31350 return nil
31351}
31352
31353func DecodeOxmIdBsnVrf(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVrf, error) {
31354 _oxmidbsnvrf := &OxmIdBsnVrf{OxmId: parent}
31355 return _oxmidbsnvrf, nil
31356}
31357
31358func NewOxmIdBsnVrf() *OxmIdBsnVrf {
31359 obj := &OxmIdBsnVrf{
31360 OxmId: NewOxmId(197636),
31361 }
31362 return obj
31363}
31364func (self *OxmIdBsnVrf) GetOXMName() string {
31365 return "bsn_vrf"
31366}
31367
31368func (self *OxmIdBsnVrf) MarshalJSON() ([]byte, error) {
31369 if self.TypeLen == 0 {
31370 return []byte("\"\""), nil
31371 } else {
31372 return []byte("\"" + self.GetOXMName() + "\""), nil
31373 }
31374}
31375
31376type OxmIdBsnVrfMasked struct {
31377 *OxmId
31378}
31379
31380type IOxmIdBsnVrfMasked interface {
31381 IOxmId
31382}
31383
31384func (self *OxmIdBsnVrfMasked) Serialize(encoder *goloxi.Encoder) error {
31385 if err := self.OxmId.Serialize(encoder); err != nil {
31386 return err
31387 }
31388
31389 return nil
31390}
31391
31392func DecodeOxmIdBsnVrfMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVrfMasked, error) {
31393 _oxmidbsnvrfmasked := &OxmIdBsnVrfMasked{OxmId: parent}
31394 return _oxmidbsnvrfmasked, nil
31395}
31396
31397func NewOxmIdBsnVrfMasked() *OxmIdBsnVrfMasked {
31398 obj := &OxmIdBsnVrfMasked{
31399 OxmId: NewOxmId(197896),
31400 }
31401 return obj
31402}
31403func (self *OxmIdBsnVrfMasked) GetOXMName() string {
31404 return "bsn_vrf_masked"
31405}
31406
31407func (self *OxmIdBsnVrfMasked) MarshalJSON() ([]byte, error) {
31408 if self.TypeLen == 0 {
31409 return []byte("\"\""), nil
31410 } else {
31411 return []byte("\"" + self.GetOXMName() + "\""), nil
31412 }
31413}
31414
31415type OxmIdBsnVxlanNetworkId struct {
31416 *OxmId
31417}
31418
31419type IOxmIdBsnVxlanNetworkId interface {
31420 IOxmId
31421}
31422
31423func (self *OxmIdBsnVxlanNetworkId) Serialize(encoder *goloxi.Encoder) error {
31424 if err := self.OxmId.Serialize(encoder); err != nil {
31425 return err
31426 }
31427
31428 return nil
31429}
31430
31431func DecodeOxmIdBsnVxlanNetworkId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVxlanNetworkId, error) {
31432 _oxmidbsnvxlannetworkid := &OxmIdBsnVxlanNetworkId{OxmId: parent}
31433 return _oxmidbsnvxlannetworkid, nil
31434}
31435
31436func NewOxmIdBsnVxlanNetworkId() *OxmIdBsnVxlanNetworkId {
31437 obj := &OxmIdBsnVxlanNetworkId{
31438 OxmId: NewOxmId(207364),
31439 }
31440 return obj
31441}
31442func (self *OxmIdBsnVxlanNetworkId) GetOXMName() string {
31443 return "bsn_vxlan_network_id"
31444}
31445
31446func (self *OxmIdBsnVxlanNetworkId) MarshalJSON() ([]byte, error) {
31447 if self.TypeLen == 0 {
31448 return []byte("\"\""), nil
31449 } else {
31450 return []byte("\"" + self.GetOXMName() + "\""), nil
31451 }
31452}
31453
31454type OxmIdBsnVxlanNetworkIdMasked struct {
31455 *OxmId
31456}
31457
31458type IOxmIdBsnVxlanNetworkIdMasked interface {
31459 IOxmId
31460}
31461
31462func (self *OxmIdBsnVxlanNetworkIdMasked) Serialize(encoder *goloxi.Encoder) error {
31463 if err := self.OxmId.Serialize(encoder); err != nil {
31464 return err
31465 }
31466
31467 return nil
31468}
31469
31470func DecodeOxmIdBsnVxlanNetworkIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVxlanNetworkIdMasked, error) {
31471 _oxmidbsnvxlannetworkidmasked := &OxmIdBsnVxlanNetworkIdMasked{OxmId: parent}
31472 return _oxmidbsnvxlannetworkidmasked, nil
31473}
31474
31475func NewOxmIdBsnVxlanNetworkIdMasked() *OxmIdBsnVxlanNetworkIdMasked {
31476 obj := &OxmIdBsnVxlanNetworkIdMasked{
31477 OxmId: NewOxmId(207624),
31478 }
31479 return obj
31480}
31481func (self *OxmIdBsnVxlanNetworkIdMasked) GetOXMName() string {
31482 return "bsn_vxlan_network_id_masked"
31483}
31484
31485func (self *OxmIdBsnVxlanNetworkIdMasked) MarshalJSON() ([]byte, error) {
31486 if self.TypeLen == 0 {
31487 return []byte("\"\""), nil
31488 } else {
31489 return []byte("\"" + self.GetOXMName() + "\""), nil
31490 }
31491}
31492
31493type OxmIdConnTrackingIpv6Dst struct {
31494 *OxmId
31495}
31496
31497type IOxmIdConnTrackingIpv6Dst interface {
31498 IOxmId
31499}
31500
31501func (self *OxmIdConnTrackingIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
31502 if err := self.OxmId.Serialize(encoder); err != nil {
31503 return err
31504 }
31505
31506 return nil
31507}
31508
31509func DecodeOxmIdConnTrackingIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6Dst, error) {
31510 _oxmidconntrackingipv6dst := &OxmIdConnTrackingIpv6Dst{OxmId: parent}
31511 return _oxmidconntrackingipv6dst, nil
31512}
31513
31514func NewOxmIdConnTrackingIpv6Dst() *OxmIdConnTrackingIpv6Dst {
31515 obj := &OxmIdConnTrackingIpv6Dst{
31516 OxmId: NewOxmId(128528),
31517 }
31518 return obj
31519}
31520func (self *OxmIdConnTrackingIpv6Dst) GetOXMName() string {
31521 return "conn_tracking_ipv6_dst"
31522}
31523
31524func (self *OxmIdConnTrackingIpv6Dst) MarshalJSON() ([]byte, error) {
31525 if self.TypeLen == 0 {
31526 return []byte("\"\""), nil
31527 } else {
31528 return []byte("\"" + self.GetOXMName() + "\""), nil
31529 }
31530}
31531
31532type OxmIdConnTrackingIpv6DstMasked struct {
31533 *OxmId
31534}
31535
31536type IOxmIdConnTrackingIpv6DstMasked interface {
31537 IOxmId
31538}
31539
31540func (self *OxmIdConnTrackingIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
31541 if err := self.OxmId.Serialize(encoder); err != nil {
31542 return err
31543 }
31544
31545 return nil
31546}
31547
31548func DecodeOxmIdConnTrackingIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6DstMasked, error) {
31549 _oxmidconntrackingipv6dstmasked := &OxmIdConnTrackingIpv6DstMasked{OxmId: parent}
31550 return _oxmidconntrackingipv6dstmasked, nil
31551}
31552
31553func NewOxmIdConnTrackingIpv6DstMasked() *OxmIdConnTrackingIpv6DstMasked {
31554 obj := &OxmIdConnTrackingIpv6DstMasked{
31555 OxmId: NewOxmId(128800),
31556 }
31557 return obj
31558}
31559func (self *OxmIdConnTrackingIpv6DstMasked) GetOXMName() string {
31560 return "conn_tracking_ipv6_dst_masked"
31561}
31562
31563func (self *OxmIdConnTrackingIpv6DstMasked) MarshalJSON() ([]byte, error) {
31564 if self.TypeLen == 0 {
31565 return []byte("\"\""), nil
31566 } else {
31567 return []byte("\"" + self.GetOXMName() + "\""), nil
31568 }
31569}
31570
31571type OxmIdConnTrackingIpv6Src struct {
31572 *OxmId
31573}
31574
31575type IOxmIdConnTrackingIpv6Src interface {
31576 IOxmId
31577}
31578
31579func (self *OxmIdConnTrackingIpv6Src) Serialize(encoder *goloxi.Encoder) error {
31580 if err := self.OxmId.Serialize(encoder); err != nil {
31581 return err
31582 }
31583
31584 return nil
31585}
31586
31587func DecodeOxmIdConnTrackingIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6Src, error) {
31588 _oxmidconntrackingipv6src := &OxmIdConnTrackingIpv6Src{OxmId: parent}
31589 return _oxmidconntrackingipv6src, nil
31590}
31591
31592func NewOxmIdConnTrackingIpv6Src() *OxmIdConnTrackingIpv6Src {
31593 obj := &OxmIdConnTrackingIpv6Src{
31594 OxmId: NewOxmId(128016),
31595 }
31596 return obj
31597}
31598func (self *OxmIdConnTrackingIpv6Src) GetOXMName() string {
31599 return "conn_tracking_ipv6_src"
31600}
31601
31602func (self *OxmIdConnTrackingIpv6Src) MarshalJSON() ([]byte, error) {
31603 if self.TypeLen == 0 {
31604 return []byte("\"\""), nil
31605 } else {
31606 return []byte("\"" + self.GetOXMName() + "\""), nil
31607 }
31608}
31609
31610type OxmIdConnTrackingIpv6SrcMasked struct {
31611 *OxmId
31612}
31613
31614type IOxmIdConnTrackingIpv6SrcMasked interface {
31615 IOxmId
31616}
31617
31618func (self *OxmIdConnTrackingIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
31619 if err := self.OxmId.Serialize(encoder); err != nil {
31620 return err
31621 }
31622
31623 return nil
31624}
31625
31626func DecodeOxmIdConnTrackingIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6SrcMasked, error) {
31627 _oxmidconntrackingipv6srcmasked := &OxmIdConnTrackingIpv6SrcMasked{OxmId: parent}
31628 return _oxmidconntrackingipv6srcmasked, nil
31629}
31630
31631func NewOxmIdConnTrackingIpv6SrcMasked() *OxmIdConnTrackingIpv6SrcMasked {
31632 obj := &OxmIdConnTrackingIpv6SrcMasked{
31633 OxmId: NewOxmId(128288),
31634 }
31635 return obj
31636}
31637func (self *OxmIdConnTrackingIpv6SrcMasked) GetOXMName() string {
31638 return "conn_tracking_ipv6_src_masked"
31639}
31640
31641func (self *OxmIdConnTrackingIpv6SrcMasked) MarshalJSON() ([]byte, error) {
31642 if self.TypeLen == 0 {
31643 return []byte("\"\""), nil
31644 } else {
31645 return []byte("\"" + self.GetOXMName() + "\""), nil
31646 }
31647}
31648
31649type OxmIdConnTrackingLabel struct {
31650 *OxmId
31651}
31652
31653type IOxmIdConnTrackingLabel interface {
31654 IOxmId
31655}
31656
31657func (self *OxmIdConnTrackingLabel) Serialize(encoder *goloxi.Encoder) error {
31658 if err := self.OxmId.Serialize(encoder); err != nil {
31659 return err
31660 }
31661
31662 return nil
31663}
31664
31665func DecodeOxmIdConnTrackingLabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingLabel, error) {
31666 _oxmidconntrackinglabel := &OxmIdConnTrackingLabel{OxmId: parent}
31667 return _oxmidconntrackinglabel, nil
31668}
31669
31670func NewOxmIdConnTrackingLabel() *OxmIdConnTrackingLabel {
31671 obj := &OxmIdConnTrackingLabel{
31672 OxmId: NewOxmId(120848),
31673 }
31674 return obj
31675}
31676func (self *OxmIdConnTrackingLabel) GetOXMName() string {
31677 return "conn_tracking_label"
31678}
31679
31680func (self *OxmIdConnTrackingLabel) MarshalJSON() ([]byte, error) {
31681 if self.TypeLen == 0 {
31682 return []byte("\"\""), nil
31683 } else {
31684 return []byte("\"" + self.GetOXMName() + "\""), nil
31685 }
31686}
31687
31688type OxmIdConnTrackingLabelMasked struct {
31689 *OxmId
31690}
31691
31692type IOxmIdConnTrackingLabelMasked interface {
31693 IOxmId
31694}
31695
31696func (self *OxmIdConnTrackingLabelMasked) Serialize(encoder *goloxi.Encoder) error {
31697 if err := self.OxmId.Serialize(encoder); err != nil {
31698 return err
31699 }
31700
31701 return nil
31702}
31703
31704func DecodeOxmIdConnTrackingLabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingLabelMasked, error) {
31705 _oxmidconntrackinglabelmasked := &OxmIdConnTrackingLabelMasked{OxmId: parent}
31706 return _oxmidconntrackinglabelmasked, nil
31707}
31708
31709func NewOxmIdConnTrackingLabelMasked() *OxmIdConnTrackingLabelMasked {
31710 obj := &OxmIdConnTrackingLabelMasked{
31711 OxmId: NewOxmId(121120),
31712 }
31713 return obj
31714}
31715func (self *OxmIdConnTrackingLabelMasked) GetOXMName() string {
31716 return "conn_tracking_label_masked"
31717}
31718
31719func (self *OxmIdConnTrackingLabelMasked) MarshalJSON() ([]byte, error) {
31720 if self.TypeLen == 0 {
31721 return []byte("\"\""), nil
31722 } else {
31723 return []byte("\"" + self.GetOXMName() + "\""), nil
31724 }
31725}
31726
31727type OxmIdConnTrackingMark struct {
31728 *OxmId
31729}
31730
31731type IOxmIdConnTrackingMark interface {
31732 IOxmId
31733}
31734
31735func (self *OxmIdConnTrackingMark) Serialize(encoder *goloxi.Encoder) error {
31736 if err := self.OxmId.Serialize(encoder); err != nil {
31737 return err
31738 }
31739
31740 return nil
31741}
31742
31743func DecodeOxmIdConnTrackingMark(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingMark, error) {
31744 _oxmidconntrackingmark := &OxmIdConnTrackingMark{OxmId: parent}
31745 return _oxmidconntrackingmark, nil
31746}
31747
31748func NewOxmIdConnTrackingMark() *OxmIdConnTrackingMark {
31749 obj := &OxmIdConnTrackingMark{
31750 OxmId: NewOxmId(120324),
31751 }
31752 return obj
31753}
31754func (self *OxmIdConnTrackingMark) GetOXMName() string {
31755 return "conn_tracking_mark"
31756}
31757
31758func (self *OxmIdConnTrackingMark) MarshalJSON() ([]byte, error) {
31759 if self.TypeLen == 0 {
31760 return []byte("\"\""), nil
31761 } else {
31762 return []byte("\"" + self.GetOXMName() + "\""), nil
31763 }
31764}
31765
31766type OxmIdConnTrackingMarkMasked struct {
31767 *OxmId
31768}
31769
31770type IOxmIdConnTrackingMarkMasked interface {
31771 IOxmId
31772}
31773
31774func (self *OxmIdConnTrackingMarkMasked) Serialize(encoder *goloxi.Encoder) error {
31775 if err := self.OxmId.Serialize(encoder); err != nil {
31776 return err
31777 }
31778
31779 return nil
31780}
31781
31782func DecodeOxmIdConnTrackingMarkMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingMarkMasked, error) {
31783 _oxmidconntrackingmarkmasked := &OxmIdConnTrackingMarkMasked{OxmId: parent}
31784 return _oxmidconntrackingmarkmasked, nil
31785}
31786
31787func NewOxmIdConnTrackingMarkMasked() *OxmIdConnTrackingMarkMasked {
31788 obj := &OxmIdConnTrackingMarkMasked{
31789 OxmId: NewOxmId(120584),
31790 }
31791 return obj
31792}
31793func (self *OxmIdConnTrackingMarkMasked) GetOXMName() string {
31794 return "conn_tracking_mark_masked"
31795}
31796
31797func (self *OxmIdConnTrackingMarkMasked) MarshalJSON() ([]byte, error) {
31798 if self.TypeLen == 0 {
31799 return []byte("\"\""), nil
31800 } else {
31801 return []byte("\"" + self.GetOXMName() + "\""), nil
31802 }
31803}
31804
31805type OxmIdConnTrackingNwDst struct {
31806 *OxmId
31807}
31808
31809type IOxmIdConnTrackingNwDst interface {
31810 IOxmId
31811}
31812
31813func (self *OxmIdConnTrackingNwDst) Serialize(encoder *goloxi.Encoder) error {
31814 if err := self.OxmId.Serialize(encoder); err != nil {
31815 return err
31816 }
31817
31818 return nil
31819}
31820
31821func DecodeOxmIdConnTrackingNwDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwDst, error) {
31822 _oxmidconntrackingnwdst := &OxmIdConnTrackingNwDst{OxmId: parent}
31823 return _oxmidconntrackingnwdst, nil
31824}
31825
31826func NewOxmIdConnTrackingNwDst() *OxmIdConnTrackingNwDst {
31827 obj := &OxmIdConnTrackingNwDst{
31828 OxmId: NewOxmId(127492),
31829 }
31830 return obj
31831}
31832func (self *OxmIdConnTrackingNwDst) GetOXMName() string {
31833 return "conn_tracking_nw_dst"
31834}
31835
31836func (self *OxmIdConnTrackingNwDst) MarshalJSON() ([]byte, error) {
31837 if self.TypeLen == 0 {
31838 return []byte("\"\""), nil
31839 } else {
31840 return []byte("\"" + self.GetOXMName() + "\""), nil
31841 }
31842}
31843
31844type OxmIdConnTrackingNwDstMasked struct {
31845 *OxmId
31846}
31847
31848type IOxmIdConnTrackingNwDstMasked interface {
31849 IOxmId
31850}
31851
31852func (self *OxmIdConnTrackingNwDstMasked) Serialize(encoder *goloxi.Encoder) error {
31853 if err := self.OxmId.Serialize(encoder); err != nil {
31854 return err
31855 }
31856
31857 return nil
31858}
31859
31860func DecodeOxmIdConnTrackingNwDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwDstMasked, error) {
31861 _oxmidconntrackingnwdstmasked := &OxmIdConnTrackingNwDstMasked{OxmId: parent}
31862 return _oxmidconntrackingnwdstmasked, nil
31863}
31864
31865func NewOxmIdConnTrackingNwDstMasked() *OxmIdConnTrackingNwDstMasked {
31866 obj := &OxmIdConnTrackingNwDstMasked{
31867 OxmId: NewOxmId(127752),
31868 }
31869 return obj
31870}
31871func (self *OxmIdConnTrackingNwDstMasked) GetOXMName() string {
31872 return "conn_tracking_nw_dst_masked"
31873}
31874
31875func (self *OxmIdConnTrackingNwDstMasked) MarshalJSON() ([]byte, error) {
31876 if self.TypeLen == 0 {
31877 return []byte("\"\""), nil
31878 } else {
31879 return []byte("\"" + self.GetOXMName() + "\""), nil
31880 }
31881}
31882
31883type OxmIdConnTrackingNwProto struct {
31884 *OxmId
31885}
31886
31887type IOxmIdConnTrackingNwProto interface {
31888 IOxmId
31889}
31890
31891func (self *OxmIdConnTrackingNwProto) Serialize(encoder *goloxi.Encoder) error {
31892 if err := self.OxmId.Serialize(encoder); err != nil {
31893 return err
31894 }
31895
31896 return nil
31897}
31898
31899func DecodeOxmIdConnTrackingNwProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwProto, error) {
31900 _oxmidconntrackingnwproto := &OxmIdConnTrackingNwProto{OxmId: parent}
31901 return _oxmidconntrackingnwproto, nil
31902}
31903
31904func NewOxmIdConnTrackingNwProto() *OxmIdConnTrackingNwProto {
31905 obj := &OxmIdConnTrackingNwProto{
31906 OxmId: NewOxmId(126465),
31907 }
31908 return obj
31909}
31910func (self *OxmIdConnTrackingNwProto) GetOXMName() string {
31911 return "conn_tracking_nw_proto"
31912}
31913
31914func (self *OxmIdConnTrackingNwProto) MarshalJSON() ([]byte, error) {
31915 if self.TypeLen == 0 {
31916 return []byte("\"\""), nil
31917 } else {
31918 return []byte("\"" + self.GetOXMName() + "\""), nil
31919 }
31920}
31921
31922type OxmIdConnTrackingNwProtoMasked struct {
31923 *OxmId
31924}
31925
31926type IOxmIdConnTrackingNwProtoMasked interface {
31927 IOxmId
31928}
31929
31930func (self *OxmIdConnTrackingNwProtoMasked) Serialize(encoder *goloxi.Encoder) error {
31931 if err := self.OxmId.Serialize(encoder); err != nil {
31932 return err
31933 }
31934
31935 return nil
31936}
31937
31938func DecodeOxmIdConnTrackingNwProtoMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwProtoMasked, error) {
31939 _oxmidconntrackingnwprotomasked := &OxmIdConnTrackingNwProtoMasked{OxmId: parent}
31940 return _oxmidconntrackingnwprotomasked, nil
31941}
31942
31943func NewOxmIdConnTrackingNwProtoMasked() *OxmIdConnTrackingNwProtoMasked {
31944 obj := &OxmIdConnTrackingNwProtoMasked{
31945 OxmId: NewOxmId(126722),
31946 }
31947 return obj
31948}
31949func (self *OxmIdConnTrackingNwProtoMasked) GetOXMName() string {
31950 return "conn_tracking_nw_proto_masked"
31951}
31952
31953func (self *OxmIdConnTrackingNwProtoMasked) MarshalJSON() ([]byte, error) {
31954 if self.TypeLen == 0 {
31955 return []byte("\"\""), nil
31956 } else {
31957 return []byte("\"" + self.GetOXMName() + "\""), nil
31958 }
31959}
31960
31961type OxmIdConnTrackingNwSrc struct {
31962 *OxmId
31963}
31964
31965type IOxmIdConnTrackingNwSrc interface {
31966 IOxmId
31967}
31968
31969func (self *OxmIdConnTrackingNwSrc) Serialize(encoder *goloxi.Encoder) error {
31970 if err := self.OxmId.Serialize(encoder); err != nil {
31971 return err
31972 }
31973
31974 return nil
31975}
31976
31977func DecodeOxmIdConnTrackingNwSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwSrc, error) {
31978 _oxmidconntrackingnwsrc := &OxmIdConnTrackingNwSrc{OxmId: parent}
31979 return _oxmidconntrackingnwsrc, nil
31980}
31981
31982func NewOxmIdConnTrackingNwSrc() *OxmIdConnTrackingNwSrc {
31983 obj := &OxmIdConnTrackingNwSrc{
31984 OxmId: NewOxmId(126980),
31985 }
31986 return obj
31987}
31988func (self *OxmIdConnTrackingNwSrc) GetOXMName() string {
31989 return "conn_tracking_nw_src"
31990}
31991
31992func (self *OxmIdConnTrackingNwSrc) MarshalJSON() ([]byte, error) {
31993 if self.TypeLen == 0 {
31994 return []byte("\"\""), nil
31995 } else {
31996 return []byte("\"" + self.GetOXMName() + "\""), nil
31997 }
31998}
31999
32000type OxmIdConnTrackingNwSrcMasked struct {
32001 *OxmId
32002}
32003
32004type IOxmIdConnTrackingNwSrcMasked interface {
32005 IOxmId
32006}
32007
32008func (self *OxmIdConnTrackingNwSrcMasked) Serialize(encoder *goloxi.Encoder) error {
32009 if err := self.OxmId.Serialize(encoder); err != nil {
32010 return err
32011 }
32012
32013 return nil
32014}
32015
32016func DecodeOxmIdConnTrackingNwSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwSrcMasked, error) {
32017 _oxmidconntrackingnwsrcmasked := &OxmIdConnTrackingNwSrcMasked{OxmId: parent}
32018 return _oxmidconntrackingnwsrcmasked, nil
32019}
32020
32021func NewOxmIdConnTrackingNwSrcMasked() *OxmIdConnTrackingNwSrcMasked {
32022 obj := &OxmIdConnTrackingNwSrcMasked{
32023 OxmId: NewOxmId(127240),
32024 }
32025 return obj
32026}
32027func (self *OxmIdConnTrackingNwSrcMasked) GetOXMName() string {
32028 return "conn_tracking_nw_src_masked"
32029}
32030
32031func (self *OxmIdConnTrackingNwSrcMasked) MarshalJSON() ([]byte, error) {
32032 if self.TypeLen == 0 {
32033 return []byte("\"\""), nil
32034 } else {
32035 return []byte("\"" + self.GetOXMName() + "\""), nil
32036 }
32037}
32038
32039type OxmIdConnTrackingState struct {
32040 *OxmId
32041}
32042
32043type IOxmIdConnTrackingState interface {
32044 IOxmId
32045}
32046
32047func (self *OxmIdConnTrackingState) Serialize(encoder *goloxi.Encoder) error {
32048 if err := self.OxmId.Serialize(encoder); err != nil {
32049 return err
32050 }
32051
32052 return nil
32053}
32054
32055func DecodeOxmIdConnTrackingState(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingState, error) {
32056 _oxmidconntrackingstate := &OxmIdConnTrackingState{OxmId: parent}
32057 return _oxmidconntrackingstate, nil
32058}
32059
32060func NewOxmIdConnTrackingState() *OxmIdConnTrackingState {
32061 obj := &OxmIdConnTrackingState{
32062 OxmId: NewOxmId(119300),
32063 }
32064 return obj
32065}
32066func (self *OxmIdConnTrackingState) GetOXMName() string {
32067 return "conn_tracking_state"
32068}
32069
32070func (self *OxmIdConnTrackingState) MarshalJSON() ([]byte, error) {
32071 if self.TypeLen == 0 {
32072 return []byte("\"\""), nil
32073 } else {
32074 return []byte("\"" + self.GetOXMName() + "\""), nil
32075 }
32076}
32077
32078type OxmIdConnTrackingStateMasked struct {
32079 *OxmId
32080}
32081
32082type IOxmIdConnTrackingStateMasked interface {
32083 IOxmId
32084}
32085
32086func (self *OxmIdConnTrackingStateMasked) Serialize(encoder *goloxi.Encoder) error {
32087 if err := self.OxmId.Serialize(encoder); err != nil {
32088 return err
32089 }
32090
32091 return nil
32092}
32093
32094func DecodeOxmIdConnTrackingStateMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingStateMasked, error) {
32095 _oxmidconntrackingstatemasked := &OxmIdConnTrackingStateMasked{OxmId: parent}
32096 return _oxmidconntrackingstatemasked, nil
32097}
32098
32099func NewOxmIdConnTrackingStateMasked() *OxmIdConnTrackingStateMasked {
32100 obj := &OxmIdConnTrackingStateMasked{
32101 OxmId: NewOxmId(119560),
32102 }
32103 return obj
32104}
32105func (self *OxmIdConnTrackingStateMasked) GetOXMName() string {
32106 return "conn_tracking_state_masked"
32107}
32108
32109func (self *OxmIdConnTrackingStateMasked) MarshalJSON() ([]byte, error) {
32110 if self.TypeLen == 0 {
32111 return []byte("\"\""), nil
32112 } else {
32113 return []byte("\"" + self.GetOXMName() + "\""), nil
32114 }
32115}
32116
32117type OxmIdConnTrackingTpDst struct {
32118 *OxmId
32119}
32120
32121type IOxmIdConnTrackingTpDst interface {
32122 IOxmId
32123}
32124
32125func (self *OxmIdConnTrackingTpDst) Serialize(encoder *goloxi.Encoder) error {
32126 if err := self.OxmId.Serialize(encoder); err != nil {
32127 return err
32128 }
32129
32130 return nil
32131}
32132
32133func DecodeOxmIdConnTrackingTpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpDst, error) {
32134 _oxmidconntrackingtpdst := &OxmIdConnTrackingTpDst{OxmId: parent}
32135 return _oxmidconntrackingtpdst, nil
32136}
32137
32138func NewOxmIdConnTrackingTpDst() *OxmIdConnTrackingTpDst {
32139 obj := &OxmIdConnTrackingTpDst{
32140 OxmId: NewOxmId(129538),
32141 }
32142 return obj
32143}
32144func (self *OxmIdConnTrackingTpDst) GetOXMName() string {
32145 return "conn_tracking_tp_dst"
32146}
32147
32148func (self *OxmIdConnTrackingTpDst) MarshalJSON() ([]byte, error) {
32149 if self.TypeLen == 0 {
32150 return []byte("\"\""), nil
32151 } else {
32152 return []byte("\"" + self.GetOXMName() + "\""), nil
32153 }
32154}
32155
32156type OxmIdConnTrackingTpDstMasked struct {
32157 *OxmId
32158}
32159
32160type IOxmIdConnTrackingTpDstMasked interface {
32161 IOxmId
32162}
32163
32164func (self *OxmIdConnTrackingTpDstMasked) Serialize(encoder *goloxi.Encoder) error {
32165 if err := self.OxmId.Serialize(encoder); err != nil {
32166 return err
32167 }
32168
32169 return nil
32170}
32171
32172func DecodeOxmIdConnTrackingTpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpDstMasked, error) {
32173 _oxmidconntrackingtpdstmasked := &OxmIdConnTrackingTpDstMasked{OxmId: parent}
32174 return _oxmidconntrackingtpdstmasked, nil
32175}
32176
32177func NewOxmIdConnTrackingTpDstMasked() *OxmIdConnTrackingTpDstMasked {
32178 obj := &OxmIdConnTrackingTpDstMasked{
32179 OxmId: NewOxmId(129796),
32180 }
32181 return obj
32182}
32183func (self *OxmIdConnTrackingTpDstMasked) GetOXMName() string {
32184 return "conn_tracking_tp_dst_masked"
32185}
32186
32187func (self *OxmIdConnTrackingTpDstMasked) MarshalJSON() ([]byte, error) {
32188 if self.TypeLen == 0 {
32189 return []byte("\"\""), nil
32190 } else {
32191 return []byte("\"" + self.GetOXMName() + "\""), nil
32192 }
32193}
32194
32195type OxmIdConnTrackingTpSrc struct {
32196 *OxmId
32197}
32198
32199type IOxmIdConnTrackingTpSrc interface {
32200 IOxmId
32201}
32202
32203func (self *OxmIdConnTrackingTpSrc) Serialize(encoder *goloxi.Encoder) error {
32204 if err := self.OxmId.Serialize(encoder); err != nil {
32205 return err
32206 }
32207
32208 return nil
32209}
32210
32211func DecodeOxmIdConnTrackingTpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpSrc, error) {
32212 _oxmidconntrackingtpsrc := &OxmIdConnTrackingTpSrc{OxmId: parent}
32213 return _oxmidconntrackingtpsrc, nil
32214}
32215
32216func NewOxmIdConnTrackingTpSrc() *OxmIdConnTrackingTpSrc {
32217 obj := &OxmIdConnTrackingTpSrc{
32218 OxmId: NewOxmId(129026),
32219 }
32220 return obj
32221}
32222func (self *OxmIdConnTrackingTpSrc) GetOXMName() string {
32223 return "conn_tracking_tp_src"
32224}
32225
32226func (self *OxmIdConnTrackingTpSrc) MarshalJSON() ([]byte, error) {
32227 if self.TypeLen == 0 {
32228 return []byte("\"\""), nil
32229 } else {
32230 return []byte("\"" + self.GetOXMName() + "\""), nil
32231 }
32232}
32233
32234type OxmIdConnTrackingTpSrcMasked struct {
32235 *OxmId
32236}
32237
32238type IOxmIdConnTrackingTpSrcMasked interface {
32239 IOxmId
32240}
32241
32242func (self *OxmIdConnTrackingTpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
32243 if err := self.OxmId.Serialize(encoder); err != nil {
32244 return err
32245 }
32246
32247 return nil
32248}
32249
32250func DecodeOxmIdConnTrackingTpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpSrcMasked, error) {
32251 _oxmidconntrackingtpsrcmasked := &OxmIdConnTrackingTpSrcMasked{OxmId: parent}
32252 return _oxmidconntrackingtpsrcmasked, nil
32253}
32254
32255func NewOxmIdConnTrackingTpSrcMasked() *OxmIdConnTrackingTpSrcMasked {
32256 obj := &OxmIdConnTrackingTpSrcMasked{
32257 OxmId: NewOxmId(129284),
32258 }
32259 return obj
32260}
32261func (self *OxmIdConnTrackingTpSrcMasked) GetOXMName() string {
32262 return "conn_tracking_tp_src_masked"
32263}
32264
32265func (self *OxmIdConnTrackingTpSrcMasked) MarshalJSON() ([]byte, error) {
32266 if self.TypeLen == 0 {
32267 return []byte("\"\""), nil
32268 } else {
32269 return []byte("\"" + self.GetOXMName() + "\""), nil
32270 }
32271}
32272
32273type OxmIdConnTrackingZone struct {
32274 *OxmId
32275}
32276
32277type IOxmIdConnTrackingZone interface {
32278 IOxmId
32279}
32280
32281func (self *OxmIdConnTrackingZone) Serialize(encoder *goloxi.Encoder) error {
32282 if err := self.OxmId.Serialize(encoder); err != nil {
32283 return err
32284 }
32285
32286 return nil
32287}
32288
32289func DecodeOxmIdConnTrackingZone(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingZone, error) {
32290 _oxmidconntrackingzone := &OxmIdConnTrackingZone{OxmId: parent}
32291 return _oxmidconntrackingzone, nil
32292}
32293
32294func NewOxmIdConnTrackingZone() *OxmIdConnTrackingZone {
32295 obj := &OxmIdConnTrackingZone{
32296 OxmId: NewOxmId(119810),
32297 }
32298 return obj
32299}
32300func (self *OxmIdConnTrackingZone) GetOXMName() string {
32301 return "conn_tracking_zone"
32302}
32303
32304func (self *OxmIdConnTrackingZone) MarshalJSON() ([]byte, error) {
32305 if self.TypeLen == 0 {
32306 return []byte("\"\""), nil
32307 } else {
32308 return []byte("\"" + self.GetOXMName() + "\""), nil
32309 }
32310}
32311
32312type OxmIdConnTrackingZoneMasked struct {
32313 *OxmId
32314}
32315
32316type IOxmIdConnTrackingZoneMasked interface {
32317 IOxmId
32318}
32319
32320func (self *OxmIdConnTrackingZoneMasked) Serialize(encoder *goloxi.Encoder) error {
32321 if err := self.OxmId.Serialize(encoder); err != nil {
32322 return err
32323 }
32324
32325 return nil
32326}
32327
32328func DecodeOxmIdConnTrackingZoneMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingZoneMasked, error) {
32329 _oxmidconntrackingzonemasked := &OxmIdConnTrackingZoneMasked{OxmId: parent}
32330 return _oxmidconntrackingzonemasked, nil
32331}
32332
32333func NewOxmIdConnTrackingZoneMasked() *OxmIdConnTrackingZoneMasked {
32334 obj := &OxmIdConnTrackingZoneMasked{
32335 OxmId: NewOxmId(120068),
32336 }
32337 return obj
32338}
32339func (self *OxmIdConnTrackingZoneMasked) GetOXMName() string {
32340 return "conn_tracking_zone_masked"
32341}
32342
32343func (self *OxmIdConnTrackingZoneMasked) MarshalJSON() ([]byte, error) {
32344 if self.TypeLen == 0 {
32345 return []byte("\"\""), nil
32346 } else {
32347 return []byte("\"" + self.GetOXMName() + "\""), nil
32348 }
32349}
32350
32351type OxmIdEthTypeMasked struct {
32352 *OxmId
32353}
32354
32355type IOxmIdEthTypeMasked interface {
32356 IOxmId
32357}
32358
32359func (self *OxmIdEthTypeMasked) Serialize(encoder *goloxi.Encoder) error {
32360 if err := self.OxmId.Serialize(encoder); err != nil {
32361 return err
32362 }
32363
32364 return nil
32365}
32366
32367func DecodeOxmIdEthTypeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthTypeMasked, error) {
32368 _oxmidethtypemasked := &OxmIdEthTypeMasked{OxmId: parent}
32369 return _oxmidethtypemasked, nil
32370}
32371
32372func NewOxmIdEthTypeMasked() *OxmIdEthTypeMasked {
32373 obj := &OxmIdEthTypeMasked{
32374 OxmId: NewOxmId(2147486468),
32375 }
32376 return obj
32377}
32378func (self *OxmIdEthTypeMasked) GetOXMName() string {
32379 return "eth_type_masked"
32380}
32381
32382func (self *OxmIdEthTypeMasked) MarshalJSON() ([]byte, error) {
32383 if self.TypeLen == 0 {
32384 return []byte("\"\""), nil
32385 } else {
32386 return []byte("\"" + self.GetOXMName() + "\""), nil
32387 }
32388}
32389
32390type OxmIdIcmpv4Code struct {
32391 *OxmId
32392}
32393
32394type IOxmIdIcmpv4Code interface {
32395 IOxmId
32396}
32397
32398func (self *OxmIdIcmpv4Code) Serialize(encoder *goloxi.Encoder) error {
32399 if err := self.OxmId.Serialize(encoder); err != nil {
32400 return err
32401 }
32402
32403 return nil
32404}
32405
32406func DecodeOxmIdIcmpv4Code(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4Code, error) {
32407 _oxmidicmpv4code := &OxmIdIcmpv4Code{OxmId: parent}
32408 return _oxmidicmpv4code, nil
32409}
32410
32411func NewOxmIdIcmpv4Code() *OxmIdIcmpv4Code {
32412 obj := &OxmIdIcmpv4Code{
32413 OxmId: NewOxmId(2147493889),
32414 }
32415 return obj
32416}
32417func (self *OxmIdIcmpv4Code) GetOXMName() string {
32418 return "icmpv4_code"
32419}
32420
32421func (self *OxmIdIcmpv4Code) MarshalJSON() ([]byte, error) {
32422 if self.TypeLen == 0 {
32423 return []byte("\"\""), nil
32424 } else {
32425 return []byte("\"" + self.GetOXMName() + "\""), nil
32426 }
32427}
32428
32429type OxmIdIcmpv4CodeMasked struct {
32430 *OxmId
32431}
32432
32433type IOxmIdIcmpv4CodeMasked interface {
32434 IOxmId
32435}
32436
32437func (self *OxmIdIcmpv4CodeMasked) Serialize(encoder *goloxi.Encoder) error {
32438 if err := self.OxmId.Serialize(encoder); err != nil {
32439 return err
32440 }
32441
32442 return nil
32443}
32444
32445func DecodeOxmIdIcmpv4CodeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4CodeMasked, error) {
32446 _oxmidicmpv4codemasked := &OxmIdIcmpv4CodeMasked{OxmId: parent}
32447 return _oxmidicmpv4codemasked, nil
32448}
32449
32450func NewOxmIdIcmpv4CodeMasked() *OxmIdIcmpv4CodeMasked {
32451 obj := &OxmIdIcmpv4CodeMasked{
32452 OxmId: NewOxmId(2147494146),
32453 }
32454 return obj
32455}
32456func (self *OxmIdIcmpv4CodeMasked) GetOXMName() string {
32457 return "icmpv4_code_masked"
32458}
32459
32460func (self *OxmIdIcmpv4CodeMasked) MarshalJSON() ([]byte, error) {
32461 if self.TypeLen == 0 {
32462 return []byte("\"\""), nil
32463 } else {
32464 return []byte("\"" + self.GetOXMName() + "\""), nil
32465 }
32466}
32467
32468type OxmIdIcmpv4Type struct {
32469 *OxmId
32470}
32471
32472type IOxmIdIcmpv4Type interface {
32473 IOxmId
32474}
32475
32476func (self *OxmIdIcmpv4Type) Serialize(encoder *goloxi.Encoder) error {
32477 if err := self.OxmId.Serialize(encoder); err != nil {
32478 return err
32479 }
32480
32481 return nil
32482}
32483
32484func DecodeOxmIdIcmpv4Type(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4Type, error) {
32485 _oxmidicmpv4type := &OxmIdIcmpv4Type{OxmId: parent}
32486 return _oxmidicmpv4type, nil
32487}
32488
32489func NewOxmIdIcmpv4Type() *OxmIdIcmpv4Type {
32490 obj := &OxmIdIcmpv4Type{
32491 OxmId: NewOxmId(2147493377),
32492 }
32493 return obj
32494}
32495func (self *OxmIdIcmpv4Type) GetOXMName() string {
32496 return "icmpv4_type"
32497}
32498
32499func (self *OxmIdIcmpv4Type) MarshalJSON() ([]byte, error) {
32500 if self.TypeLen == 0 {
32501 return []byte("\"\""), nil
32502 } else {
32503 return []byte("\"" + self.GetOXMName() + "\""), nil
32504 }
32505}
32506
32507type OxmIdIcmpv4TypeMasked struct {
32508 *OxmId
32509}
32510
32511type IOxmIdIcmpv4TypeMasked interface {
32512 IOxmId
32513}
32514
32515func (self *OxmIdIcmpv4TypeMasked) Serialize(encoder *goloxi.Encoder) error {
32516 if err := self.OxmId.Serialize(encoder); err != nil {
32517 return err
32518 }
32519
32520 return nil
32521}
32522
32523func DecodeOxmIdIcmpv4TypeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4TypeMasked, error) {
32524 _oxmidicmpv4typemasked := &OxmIdIcmpv4TypeMasked{OxmId: parent}
32525 return _oxmidicmpv4typemasked, nil
32526}
32527
32528func NewOxmIdIcmpv4TypeMasked() *OxmIdIcmpv4TypeMasked {
32529 obj := &OxmIdIcmpv4TypeMasked{
32530 OxmId: NewOxmId(2147493634),
32531 }
32532 return obj
32533}
32534func (self *OxmIdIcmpv4TypeMasked) GetOXMName() string {
32535 return "icmpv4_type_masked"
32536}
32537
32538func (self *OxmIdIcmpv4TypeMasked) MarshalJSON() ([]byte, error) {
32539 if self.TypeLen == 0 {
32540 return []byte("\"\""), nil
32541 } else {
32542 return []byte("\"" + self.GetOXMName() + "\""), nil
32543 }
32544}
32545
32546type OxmIdIcmpv6CodeMasked struct {
32547 *OxmId
32548}
32549
32550type IOxmIdIcmpv6CodeMasked interface {
32551 IOxmId
32552}
32553
32554func (self *OxmIdIcmpv6CodeMasked) Serialize(encoder *goloxi.Encoder) error {
32555 if err := self.OxmId.Serialize(encoder); err != nil {
32556 return err
32557 }
32558
32559 return nil
32560}
32561
32562func DecodeOxmIdIcmpv6CodeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6CodeMasked, error) {
32563 _oxmidicmpv6codemasked := &OxmIdIcmpv6CodeMasked{OxmId: parent}
32564 return _oxmidicmpv6codemasked, nil
32565}
32566
32567func NewOxmIdIcmpv6CodeMasked() *OxmIdIcmpv6CodeMasked {
32568 obj := &OxmIdIcmpv6CodeMasked{
32569 OxmId: NewOxmId(2147499266),
32570 }
32571 return obj
32572}
32573func (self *OxmIdIcmpv6CodeMasked) GetOXMName() string {
32574 return "icmpv6_code_masked"
32575}
32576
32577func (self *OxmIdIcmpv6CodeMasked) MarshalJSON() ([]byte, error) {
32578 if self.TypeLen == 0 {
32579 return []byte("\"\""), nil
32580 } else {
32581 return []byte("\"" + self.GetOXMName() + "\""), nil
32582 }
32583}
32584
32585type OxmIdIcmpv6TypeMasked struct {
32586 *OxmId
32587}
32588
32589type IOxmIdIcmpv6TypeMasked interface {
32590 IOxmId
32591}
32592
32593func (self *OxmIdIcmpv6TypeMasked) Serialize(encoder *goloxi.Encoder) error {
32594 if err := self.OxmId.Serialize(encoder); err != nil {
32595 return err
32596 }
32597
32598 return nil
32599}
32600
32601func DecodeOxmIdIcmpv6TypeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6TypeMasked, error) {
32602 _oxmidicmpv6typemasked := &OxmIdIcmpv6TypeMasked{OxmId: parent}
32603 return _oxmidicmpv6typemasked, nil
32604}
32605
32606func NewOxmIdIcmpv6TypeMasked() *OxmIdIcmpv6TypeMasked {
32607 obj := &OxmIdIcmpv6TypeMasked{
32608 OxmId: NewOxmId(2147498754),
32609 }
32610 return obj
32611}
32612func (self *OxmIdIcmpv6TypeMasked) GetOXMName() string {
32613 return "icmpv6_type_masked"
32614}
32615
32616func (self *OxmIdIcmpv6TypeMasked) MarshalJSON() ([]byte, error) {
32617 if self.TypeLen == 0 {
32618 return []byte("\"\""), nil
32619 } else {
32620 return []byte("\"" + self.GetOXMName() + "\""), nil
32621 }
32622}
32623
32624type OxmIdInPhyPort struct {
32625 *OxmId
32626}
32627
32628type IOxmIdInPhyPort interface {
32629 IOxmId
32630}
32631
32632func (self *OxmIdInPhyPort) Serialize(encoder *goloxi.Encoder) error {
32633 if err := self.OxmId.Serialize(encoder); err != nil {
32634 return err
32635 }
32636
32637 return nil
32638}
32639
32640func DecodeOxmIdInPhyPort(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPhyPort, error) {
32641 _oxmidinphyport := &OxmIdInPhyPort{OxmId: parent}
32642 return _oxmidinphyport, nil
32643}
32644
32645func NewOxmIdInPhyPort() *OxmIdInPhyPort {
32646 obj := &OxmIdInPhyPort{
32647 OxmId: NewOxmId(2147484164),
32648 }
32649 return obj
32650}
32651func (self *OxmIdInPhyPort) GetOXMName() string {
32652 return "in_phy_port"
32653}
32654
32655func (self *OxmIdInPhyPort) MarshalJSON() ([]byte, error) {
32656 if self.TypeLen == 0 {
32657 return []byte("\"\""), nil
32658 } else {
32659 return []byte("\"" + self.GetOXMName() + "\""), nil
32660 }
32661}
32662
32663type OxmIdInPhyPortMasked struct {
32664 *OxmId
32665}
32666
32667type IOxmIdInPhyPortMasked interface {
32668 IOxmId
32669}
32670
32671func (self *OxmIdInPhyPortMasked) Serialize(encoder *goloxi.Encoder) error {
32672 if err := self.OxmId.Serialize(encoder); err != nil {
32673 return err
32674 }
32675
32676 return nil
32677}
32678
32679func DecodeOxmIdInPhyPortMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPhyPortMasked, error) {
32680 _oxmidinphyportmasked := &OxmIdInPhyPortMasked{OxmId: parent}
32681 return _oxmidinphyportmasked, nil
32682}
32683
32684func NewOxmIdInPhyPortMasked() *OxmIdInPhyPortMasked {
32685 obj := &OxmIdInPhyPortMasked{
32686 OxmId: NewOxmId(2147484424),
32687 }
32688 return obj
32689}
32690func (self *OxmIdInPhyPortMasked) GetOXMName() string {
32691 return "in_phy_port_masked"
32692}
32693
32694func (self *OxmIdInPhyPortMasked) MarshalJSON() ([]byte, error) {
32695 if self.TypeLen == 0 {
32696 return []byte("\"\""), nil
32697 } else {
32698 return []byte("\"" + self.GetOXMName() + "\""), nil
32699 }
32700}
32701
32702type OxmIdInPortMasked struct {
32703 *OxmId
32704}
32705
32706type IOxmIdInPortMasked interface {
32707 IOxmId
32708}
32709
32710func (self *OxmIdInPortMasked) Serialize(encoder *goloxi.Encoder) error {
32711 if err := self.OxmId.Serialize(encoder); err != nil {
32712 return err
32713 }
32714
32715 return nil
32716}
32717
32718func DecodeOxmIdInPortMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPortMasked, error) {
32719 _oxmidinportmasked := &OxmIdInPortMasked{OxmId: parent}
32720 return _oxmidinportmasked, nil
32721}
32722
32723func NewOxmIdInPortMasked() *OxmIdInPortMasked {
32724 obj := &OxmIdInPortMasked{
32725 OxmId: NewOxmId(2147483912),
32726 }
32727 return obj
32728}
32729func (self *OxmIdInPortMasked) GetOXMName() string {
32730 return "in_port_masked"
32731}
32732
32733func (self *OxmIdInPortMasked) MarshalJSON() ([]byte, error) {
32734 if self.TypeLen == 0 {
32735 return []byte("\"\""), nil
32736 } else {
32737 return []byte("\"" + self.GetOXMName() + "\""), nil
32738 }
32739}
32740
32741type OxmIdIpDscp struct {
32742 *OxmId
32743}
32744
32745type IOxmIdIpDscp interface {
32746 IOxmId
32747}
32748
32749func (self *OxmIdIpDscp) Serialize(encoder *goloxi.Encoder) error {
32750 if err := self.OxmId.Serialize(encoder); err != nil {
32751 return err
32752 }
32753
32754 return nil
32755}
32756
32757func DecodeOxmIdIpDscp(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDscp, error) {
32758 _oxmidipdscp := &OxmIdIpDscp{OxmId: parent}
32759 return _oxmidipdscp, nil
32760}
32761
32762func NewOxmIdIpDscp() *OxmIdIpDscp {
32763 obj := &OxmIdIpDscp{
32764 OxmId: NewOxmId(2147487745),
32765 }
32766 return obj
32767}
32768func (self *OxmIdIpDscp) GetOXMName() string {
32769 return "ip_dscp"
32770}
32771
32772func (self *OxmIdIpDscp) MarshalJSON() ([]byte, error) {
32773 if self.TypeLen == 0 {
32774 return []byte("\"\""), nil
32775 } else {
32776 return []byte("\"" + self.GetOXMName() + "\""), nil
32777 }
32778}
32779
32780type OxmIdIpDscpMasked struct {
32781 *OxmId
32782}
32783
32784type IOxmIdIpDscpMasked interface {
32785 IOxmId
32786}
32787
32788func (self *OxmIdIpDscpMasked) Serialize(encoder *goloxi.Encoder) error {
32789 if err := self.OxmId.Serialize(encoder); err != nil {
32790 return err
32791 }
32792
32793 return nil
32794}
32795
32796func DecodeOxmIdIpDscpMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDscpMasked, error) {
32797 _oxmidipdscpmasked := &OxmIdIpDscpMasked{OxmId: parent}
32798 return _oxmidipdscpmasked, nil
32799}
32800
32801func NewOxmIdIpDscpMasked() *OxmIdIpDscpMasked {
32802 obj := &OxmIdIpDscpMasked{
32803 OxmId: NewOxmId(2147488002),
32804 }
32805 return obj
32806}
32807func (self *OxmIdIpDscpMasked) GetOXMName() string {
32808 return "ip_dscp_masked"
32809}
32810
32811func (self *OxmIdIpDscpMasked) MarshalJSON() ([]byte, error) {
32812 if self.TypeLen == 0 {
32813 return []byte("\"\""), nil
32814 } else {
32815 return []byte("\"" + self.GetOXMName() + "\""), nil
32816 }
32817}
32818
32819type OxmIdIpEcn struct {
32820 *OxmId
32821}
32822
32823type IOxmIdIpEcn interface {
32824 IOxmId
32825}
32826
32827func (self *OxmIdIpEcn) Serialize(encoder *goloxi.Encoder) error {
32828 if err := self.OxmId.Serialize(encoder); err != nil {
32829 return err
32830 }
32831
32832 return nil
32833}
32834
32835func DecodeOxmIdIpEcn(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpEcn, error) {
32836 _oxmidipecn := &OxmIdIpEcn{OxmId: parent}
32837 return _oxmidipecn, nil
32838}
32839
32840func NewOxmIdIpEcn() *OxmIdIpEcn {
32841 obj := &OxmIdIpEcn{
32842 OxmId: NewOxmId(2147488257),
32843 }
32844 return obj
32845}
32846func (self *OxmIdIpEcn) GetOXMName() string {
32847 return "ip_ecn"
32848}
32849
32850func (self *OxmIdIpEcn) MarshalJSON() ([]byte, error) {
32851 if self.TypeLen == 0 {
32852 return []byte("\"\""), nil
32853 } else {
32854 return []byte("\"" + self.GetOXMName() + "\""), nil
32855 }
32856}
32857
32858type OxmIdIpEcnMasked struct {
32859 *OxmId
32860}
32861
32862type IOxmIdIpEcnMasked interface {
32863 IOxmId
32864}
32865
32866func (self *OxmIdIpEcnMasked) Serialize(encoder *goloxi.Encoder) error {
32867 if err := self.OxmId.Serialize(encoder); err != nil {
32868 return err
32869 }
32870
32871 return nil
32872}
32873
32874func DecodeOxmIdIpEcnMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpEcnMasked, error) {
32875 _oxmidipecnmasked := &OxmIdIpEcnMasked{OxmId: parent}
32876 return _oxmidipecnmasked, nil
32877}
32878
32879func NewOxmIdIpEcnMasked() *OxmIdIpEcnMasked {
32880 obj := &OxmIdIpEcnMasked{
32881 OxmId: NewOxmId(2147488514),
32882 }
32883 return obj
32884}
32885func (self *OxmIdIpEcnMasked) GetOXMName() string {
32886 return "ip_ecn_masked"
32887}
32888
32889func (self *OxmIdIpEcnMasked) MarshalJSON() ([]byte, error) {
32890 if self.TypeLen == 0 {
32891 return []byte("\"\""), nil
32892 } else {
32893 return []byte("\"" + self.GetOXMName() + "\""), nil
32894 }
32895}
32896
32897type OxmIdIpProto struct {
32898 *OxmId
32899}
32900
32901type IOxmIdIpProto interface {
32902 IOxmId
32903}
32904
32905func (self *OxmIdIpProto) Serialize(encoder *goloxi.Encoder) error {
32906 if err := self.OxmId.Serialize(encoder); err != nil {
32907 return err
32908 }
32909
32910 return nil
32911}
32912
32913func DecodeOxmIdIpProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpProto, error) {
32914 _oxmidipproto := &OxmIdIpProto{OxmId: parent}
32915 return _oxmidipproto, nil
32916}
32917
32918func NewOxmIdIpProto() *OxmIdIpProto {
32919 obj := &OxmIdIpProto{
32920 OxmId: NewOxmId(2147488769),
32921 }
32922 return obj
32923}
32924func (self *OxmIdIpProto) GetOXMName() string {
32925 return "ip_proto"
32926}
32927
32928func (self *OxmIdIpProto) MarshalJSON() ([]byte, error) {
32929 if self.TypeLen == 0 {
32930 return []byte("\"\""), nil
32931 } else {
32932 return []byte("\"" + self.GetOXMName() + "\""), nil
32933 }
32934}
32935
32936type OxmIdIpProtoMasked struct {
32937 *OxmId
32938}
32939
32940type IOxmIdIpProtoMasked interface {
32941 IOxmId
32942}
32943
32944func (self *OxmIdIpProtoMasked) Serialize(encoder *goloxi.Encoder) error {
32945 if err := self.OxmId.Serialize(encoder); err != nil {
32946 return err
32947 }
32948
32949 return nil
32950}
32951
32952func DecodeOxmIdIpProtoMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpProtoMasked, error) {
32953 _oxmidipprotomasked := &OxmIdIpProtoMasked{OxmId: parent}
32954 return _oxmidipprotomasked, nil
32955}
32956
32957func NewOxmIdIpProtoMasked() *OxmIdIpProtoMasked {
32958 obj := &OxmIdIpProtoMasked{
32959 OxmId: NewOxmId(2147489026),
32960 }
32961 return obj
32962}
32963func (self *OxmIdIpProtoMasked) GetOXMName() string {
32964 return "ip_proto_masked"
32965}
32966
32967func (self *OxmIdIpProtoMasked) MarshalJSON() ([]byte, error) {
32968 if self.TypeLen == 0 {
32969 return []byte("\"\""), nil
32970 } else {
32971 return []byte("\"" + self.GetOXMName() + "\""), nil
32972 }
32973}
32974
32975type OxmIdIpv4Dst struct {
32976 *OxmId
32977}
32978
32979type IOxmIdIpv4Dst interface {
32980 IOxmId
32981}
32982
32983func (self *OxmIdIpv4Dst) Serialize(encoder *goloxi.Encoder) error {
32984 if err := self.OxmId.Serialize(encoder); err != nil {
32985 return err
32986 }
32987
32988 return nil
32989}
32990
32991func DecodeOxmIdIpv4Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4Dst, error) {
32992 _oxmidipv4dst := &OxmIdIpv4Dst{OxmId: parent}
32993 return _oxmidipv4dst, nil
32994}
32995
32996func NewOxmIdIpv4Dst() *OxmIdIpv4Dst {
32997 obj := &OxmIdIpv4Dst{
32998 OxmId: NewOxmId(2147489796),
32999 }
33000 return obj
33001}
33002func (self *OxmIdIpv4Dst) GetOXMName() string {
33003 return "ipv4_dst"
33004}
33005
33006func (self *OxmIdIpv4Dst) MarshalJSON() ([]byte, error) {
33007 if self.TypeLen == 0 {
33008 return []byte("\"\""), nil
33009 } else {
33010 return []byte("\"" + self.GetOXMName() + "\""), nil
33011 }
33012}
33013
33014type OxmIdIpv4DstMasked struct {
33015 *OxmId
33016}
33017
33018type IOxmIdIpv4DstMasked interface {
33019 IOxmId
33020}
33021
33022func (self *OxmIdIpv4DstMasked) Serialize(encoder *goloxi.Encoder) error {
33023 if err := self.OxmId.Serialize(encoder); err != nil {
33024 return err
33025 }
33026
33027 return nil
33028}
33029
33030func DecodeOxmIdIpv4DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4DstMasked, error) {
33031 _oxmidipv4dstmasked := &OxmIdIpv4DstMasked{OxmId: parent}
33032 return _oxmidipv4dstmasked, nil
33033}
33034
33035func NewOxmIdIpv4DstMasked() *OxmIdIpv4DstMasked {
33036 obj := &OxmIdIpv4DstMasked{
33037 OxmId: NewOxmId(2147490056),
33038 }
33039 return obj
33040}
33041func (self *OxmIdIpv4DstMasked) GetOXMName() string {
33042 return "ipv4_dst_masked"
33043}
33044
33045func (self *OxmIdIpv4DstMasked) MarshalJSON() ([]byte, error) {
33046 if self.TypeLen == 0 {
33047 return []byte("\"\""), nil
33048 } else {
33049 return []byte("\"" + self.GetOXMName() + "\""), nil
33050 }
33051}
33052
33053type OxmIdIpv4Src struct {
33054 *OxmId
33055}
33056
33057type IOxmIdIpv4Src interface {
33058 IOxmId
33059}
33060
33061func (self *OxmIdIpv4Src) Serialize(encoder *goloxi.Encoder) error {
33062 if err := self.OxmId.Serialize(encoder); err != nil {
33063 return err
33064 }
33065
33066 return nil
33067}
33068
33069func DecodeOxmIdIpv4Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4Src, error) {
33070 _oxmidipv4src := &OxmIdIpv4Src{OxmId: parent}
33071 return _oxmidipv4src, nil
33072}
33073
33074func NewOxmIdIpv4Src() *OxmIdIpv4Src {
33075 obj := &OxmIdIpv4Src{
33076 OxmId: NewOxmId(2147489284),
33077 }
33078 return obj
33079}
33080func (self *OxmIdIpv4Src) GetOXMName() string {
33081 return "ipv4_src"
33082}
33083
33084func (self *OxmIdIpv4Src) MarshalJSON() ([]byte, error) {
33085 if self.TypeLen == 0 {
33086 return []byte("\"\""), nil
33087 } else {
33088 return []byte("\"" + self.GetOXMName() + "\""), nil
33089 }
33090}
33091
33092type OxmIdIpv4SrcMasked struct {
33093 *OxmId
33094}
33095
33096type IOxmIdIpv4SrcMasked interface {
33097 IOxmId
33098}
33099
33100func (self *OxmIdIpv4SrcMasked) Serialize(encoder *goloxi.Encoder) error {
33101 if err := self.OxmId.Serialize(encoder); err != nil {
33102 return err
33103 }
33104
33105 return nil
33106}
33107
33108func DecodeOxmIdIpv4SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4SrcMasked, error) {
33109 _oxmidipv4srcmasked := &OxmIdIpv4SrcMasked{OxmId: parent}
33110 return _oxmidipv4srcmasked, nil
33111}
33112
33113func NewOxmIdIpv4SrcMasked() *OxmIdIpv4SrcMasked {
33114 obj := &OxmIdIpv4SrcMasked{
33115 OxmId: NewOxmId(2147489544),
33116 }
33117 return obj
33118}
33119func (self *OxmIdIpv4SrcMasked) GetOXMName() string {
33120 return "ipv4_src_masked"
33121}
33122
33123func (self *OxmIdIpv4SrcMasked) MarshalJSON() ([]byte, error) {
33124 if self.TypeLen == 0 {
33125 return []byte("\"\""), nil
33126 } else {
33127 return []byte("\"" + self.GetOXMName() + "\""), nil
33128 }
33129}
33130
33131type OxmIdIpv6Exthdr struct {
33132 *OxmId
33133}
33134
33135type IOxmIdIpv6Exthdr interface {
33136 IOxmId
33137}
33138
33139func (self *OxmIdIpv6Exthdr) Serialize(encoder *goloxi.Encoder) error {
33140 if err := self.OxmId.Serialize(encoder); err != nil {
33141 return err
33142 }
33143
33144 return nil
33145}
33146
33147func DecodeOxmIdIpv6Exthdr(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Exthdr, error) {
33148 _oxmidipv6exthdr := &OxmIdIpv6Exthdr{OxmId: parent}
33149 return _oxmidipv6exthdr, nil
33150}
33151
33152func NewOxmIdIpv6Exthdr() *OxmIdIpv6Exthdr {
33153 obj := &OxmIdIpv6Exthdr{
33154 OxmId: NewOxmId(2147503618),
33155 }
33156 return obj
33157}
33158func (self *OxmIdIpv6Exthdr) GetOXMName() string {
33159 return "ipv6_exthdr"
33160}
33161
33162func (self *OxmIdIpv6Exthdr) MarshalJSON() ([]byte, error) {
33163 if self.TypeLen == 0 {
33164 return []byte("\"\""), nil
33165 } else {
33166 return []byte("\"" + self.GetOXMName() + "\""), nil
33167 }
33168}
33169
33170type OxmIdIpv6ExthdrMasked struct {
33171 *OxmId
33172}
33173
33174type IOxmIdIpv6ExthdrMasked interface {
33175 IOxmId
33176}
33177
33178func (self *OxmIdIpv6ExthdrMasked) Serialize(encoder *goloxi.Encoder) error {
33179 if err := self.OxmId.Serialize(encoder); err != nil {
33180 return err
33181 }
33182
33183 return nil
33184}
33185
33186func DecodeOxmIdIpv6ExthdrMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6ExthdrMasked, error) {
33187 _oxmidipv6exthdrmasked := &OxmIdIpv6ExthdrMasked{OxmId: parent}
33188 return _oxmidipv6exthdrmasked, nil
33189}
33190
33191func NewOxmIdIpv6ExthdrMasked() *OxmIdIpv6ExthdrMasked {
33192 obj := &OxmIdIpv6ExthdrMasked{
33193 OxmId: NewOxmId(2147503876),
33194 }
33195 return obj
33196}
33197func (self *OxmIdIpv6ExthdrMasked) GetOXMName() string {
33198 return "ipv6_exthdr_masked"
33199}
33200
33201func (self *OxmIdIpv6ExthdrMasked) MarshalJSON() ([]byte, error) {
33202 if self.TypeLen == 0 {
33203 return []byte("\"\""), nil
33204 } else {
33205 return []byte("\"" + self.GetOXMName() + "\""), nil
33206 }
33207}
33208
33209type OxmIdIpv6Flabel struct {
33210 *OxmId
33211}
33212
33213type IOxmIdIpv6Flabel interface {
33214 IOxmId
33215}
33216
33217func (self *OxmIdIpv6Flabel) Serialize(encoder *goloxi.Encoder) error {
33218 if err := self.OxmId.Serialize(encoder); err != nil {
33219 return err
33220 }
33221
33222 return nil
33223}
33224
33225func DecodeOxmIdIpv6Flabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Flabel, error) {
33226 _oxmidipv6flabel := &OxmIdIpv6Flabel{OxmId: parent}
33227 return _oxmidipv6flabel, nil
33228}
33229
33230func NewOxmIdIpv6Flabel() *OxmIdIpv6Flabel {
33231 obj := &OxmIdIpv6Flabel{
33232 OxmId: NewOxmId(2147497988),
33233 }
33234 return obj
33235}
33236func (self *OxmIdIpv6Flabel) GetOXMName() string {
33237 return "ipv6_flabel"
33238}
33239
33240func (self *OxmIdIpv6Flabel) MarshalJSON() ([]byte, error) {
33241 if self.TypeLen == 0 {
33242 return []byte("\"\""), nil
33243 } else {
33244 return []byte("\"" + self.GetOXMName() + "\""), nil
33245 }
33246}
33247
33248type OxmIdIpv6FlabelMasked struct {
33249 *OxmId
33250}
33251
33252type IOxmIdIpv6FlabelMasked interface {
33253 IOxmId
33254}
33255
33256func (self *OxmIdIpv6FlabelMasked) Serialize(encoder *goloxi.Encoder) error {
33257 if err := self.OxmId.Serialize(encoder); err != nil {
33258 return err
33259 }
33260
33261 return nil
33262}
33263
33264func DecodeOxmIdIpv6FlabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6FlabelMasked, error) {
33265 _oxmidipv6flabelmasked := &OxmIdIpv6FlabelMasked{OxmId: parent}
33266 return _oxmidipv6flabelmasked, nil
33267}
33268
33269func NewOxmIdIpv6FlabelMasked() *OxmIdIpv6FlabelMasked {
33270 obj := &OxmIdIpv6FlabelMasked{
33271 OxmId: NewOxmId(2147498248),
33272 }
33273 return obj
33274}
33275func (self *OxmIdIpv6FlabelMasked) GetOXMName() string {
33276 return "ipv6_flabel_masked"
33277}
33278
33279func (self *OxmIdIpv6FlabelMasked) MarshalJSON() ([]byte, error) {
33280 if self.TypeLen == 0 {
33281 return []byte("\"\""), nil
33282 } else {
33283 return []byte("\"" + self.GetOXMName() + "\""), nil
33284 }
33285}
33286
33287type OxmIdIpv6NdSll struct {
33288 *OxmId
33289}
33290
33291type IOxmIdIpv6NdSll interface {
33292 IOxmId
33293}
33294
33295func (self *OxmIdIpv6NdSll) Serialize(encoder *goloxi.Encoder) error {
33296 if err := self.OxmId.Serialize(encoder); err != nil {
33297 return err
33298 }
33299
33300 return nil
33301}
33302
33303func DecodeOxmIdIpv6NdSll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdSll, error) {
33304 _oxmidipv6ndsll := &OxmIdIpv6NdSll{OxmId: parent}
33305 return _oxmidipv6ndsll, nil
33306}
33307
33308func NewOxmIdIpv6NdSll() *OxmIdIpv6NdSll {
33309 obj := &OxmIdIpv6NdSll{
33310 OxmId: NewOxmId(2147500038),
33311 }
33312 return obj
33313}
33314func (self *OxmIdIpv6NdSll) GetOXMName() string {
33315 return "ipv6_nd_sll"
33316}
33317
33318func (self *OxmIdIpv6NdSll) MarshalJSON() ([]byte, error) {
33319 if self.TypeLen == 0 {
33320 return []byte("\"\""), nil
33321 } else {
33322 return []byte("\"" + self.GetOXMName() + "\""), nil
33323 }
33324}
33325
33326type OxmIdIpv6NdSllMasked struct {
33327 *OxmId
33328}
33329
33330type IOxmIdIpv6NdSllMasked interface {
33331 IOxmId
33332}
33333
33334func (self *OxmIdIpv6NdSllMasked) Serialize(encoder *goloxi.Encoder) error {
33335 if err := self.OxmId.Serialize(encoder); err != nil {
33336 return err
33337 }
33338
33339 return nil
33340}
33341
33342func DecodeOxmIdIpv6NdSllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdSllMasked, error) {
33343 _oxmidipv6ndsllmasked := &OxmIdIpv6NdSllMasked{OxmId: parent}
33344 return _oxmidipv6ndsllmasked, nil
33345}
33346
33347func NewOxmIdIpv6NdSllMasked() *OxmIdIpv6NdSllMasked {
33348 obj := &OxmIdIpv6NdSllMasked{
33349 OxmId: NewOxmId(2147500300),
33350 }
33351 return obj
33352}
33353func (self *OxmIdIpv6NdSllMasked) GetOXMName() string {
33354 return "ipv6_nd_sll_masked"
33355}
33356
33357func (self *OxmIdIpv6NdSllMasked) MarshalJSON() ([]byte, error) {
33358 if self.TypeLen == 0 {
33359 return []byte("\"\""), nil
33360 } else {
33361 return []byte("\"" + self.GetOXMName() + "\""), nil
33362 }
33363}
33364
33365type OxmIdIpv6NdTarget struct {
33366 *OxmId
33367}
33368
33369type IOxmIdIpv6NdTarget interface {
33370 IOxmId
33371}
33372
33373func (self *OxmIdIpv6NdTarget) Serialize(encoder *goloxi.Encoder) error {
33374 if err := self.OxmId.Serialize(encoder); err != nil {
33375 return err
33376 }
33377
33378 return nil
33379}
33380
33381func DecodeOxmIdIpv6NdTarget(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTarget, error) {
33382 _oxmidipv6ndtarget := &OxmIdIpv6NdTarget{OxmId: parent}
33383 return _oxmidipv6ndtarget, nil
33384}
33385
33386func NewOxmIdIpv6NdTarget() *OxmIdIpv6NdTarget {
33387 obj := &OxmIdIpv6NdTarget{
33388 OxmId: NewOxmId(2147499536),
33389 }
33390 return obj
33391}
33392func (self *OxmIdIpv6NdTarget) GetOXMName() string {
33393 return "ipv6_nd_target"
33394}
33395
33396func (self *OxmIdIpv6NdTarget) MarshalJSON() ([]byte, error) {
33397 if self.TypeLen == 0 {
33398 return []byte("\"\""), nil
33399 } else {
33400 return []byte("\"" + self.GetOXMName() + "\""), nil
33401 }
33402}
33403
33404type OxmIdIpv6NdTargetMasked struct {
33405 *OxmId
33406}
33407
33408type IOxmIdIpv6NdTargetMasked interface {
33409 IOxmId
33410}
33411
33412func (self *OxmIdIpv6NdTargetMasked) Serialize(encoder *goloxi.Encoder) error {
33413 if err := self.OxmId.Serialize(encoder); err != nil {
33414 return err
33415 }
33416
33417 return nil
33418}
33419
33420func DecodeOxmIdIpv6NdTargetMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTargetMasked, error) {
33421 _oxmidipv6ndtargetmasked := &OxmIdIpv6NdTargetMasked{OxmId: parent}
33422 return _oxmidipv6ndtargetmasked, nil
33423}
33424
33425func NewOxmIdIpv6NdTargetMasked() *OxmIdIpv6NdTargetMasked {
33426 obj := &OxmIdIpv6NdTargetMasked{
33427 OxmId: NewOxmId(2147499808),
33428 }
33429 return obj
33430}
33431func (self *OxmIdIpv6NdTargetMasked) GetOXMName() string {
33432 return "ipv6_nd_target_masked"
33433}
33434
33435func (self *OxmIdIpv6NdTargetMasked) MarshalJSON() ([]byte, error) {
33436 if self.TypeLen == 0 {
33437 return []byte("\"\""), nil
33438 } else {
33439 return []byte("\"" + self.GetOXMName() + "\""), nil
33440 }
33441}
33442
33443type OxmIdIpv6NdTll struct {
33444 *OxmId
33445}
33446
33447type IOxmIdIpv6NdTll interface {
33448 IOxmId
33449}
33450
33451func (self *OxmIdIpv6NdTll) Serialize(encoder *goloxi.Encoder) error {
33452 if err := self.OxmId.Serialize(encoder); err != nil {
33453 return err
33454 }
33455
33456 return nil
33457}
33458
33459func DecodeOxmIdIpv6NdTll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTll, error) {
33460 _oxmidipv6ndtll := &OxmIdIpv6NdTll{OxmId: parent}
33461 return _oxmidipv6ndtll, nil
33462}
33463
33464func NewOxmIdIpv6NdTll() *OxmIdIpv6NdTll {
33465 obj := &OxmIdIpv6NdTll{
33466 OxmId: NewOxmId(2147500550),
33467 }
33468 return obj
33469}
33470func (self *OxmIdIpv6NdTll) GetOXMName() string {
33471 return "ipv6_nd_tll"
33472}
33473
33474func (self *OxmIdIpv6NdTll) MarshalJSON() ([]byte, error) {
33475 if self.TypeLen == 0 {
33476 return []byte("\"\""), nil
33477 } else {
33478 return []byte("\"" + self.GetOXMName() + "\""), nil
33479 }
33480}
33481
33482type OxmIdIpv6NdTllMasked struct {
33483 *OxmId
33484}
33485
33486type IOxmIdIpv6NdTllMasked interface {
33487 IOxmId
33488}
33489
33490func (self *OxmIdIpv6NdTllMasked) Serialize(encoder *goloxi.Encoder) error {
33491 if err := self.OxmId.Serialize(encoder); err != nil {
33492 return err
33493 }
33494
33495 return nil
33496}
33497
33498func DecodeOxmIdIpv6NdTllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTllMasked, error) {
33499 _oxmidipv6ndtllmasked := &OxmIdIpv6NdTllMasked{OxmId: parent}
33500 return _oxmidipv6ndtllmasked, nil
33501}
33502
33503func NewOxmIdIpv6NdTllMasked() *OxmIdIpv6NdTllMasked {
33504 obj := &OxmIdIpv6NdTllMasked{
33505 OxmId: NewOxmId(2147500812),
33506 }
33507 return obj
33508}
33509func (self *OxmIdIpv6NdTllMasked) GetOXMName() string {
33510 return "ipv6_nd_tll_masked"
33511}
33512
33513func (self *OxmIdIpv6NdTllMasked) MarshalJSON() ([]byte, error) {
33514 if self.TypeLen == 0 {
33515 return []byte("\"\""), nil
33516 } else {
33517 return []byte("\"" + self.GetOXMName() + "\""), nil
33518 }
33519}
33520
33521type OxmIdMetadata struct {
33522 *OxmId
33523}
33524
33525type IOxmIdMetadata interface {
33526 IOxmId
33527}
33528
33529func (self *OxmIdMetadata) Serialize(encoder *goloxi.Encoder) error {
33530 if err := self.OxmId.Serialize(encoder); err != nil {
33531 return err
33532 }
33533
33534 return nil
33535}
33536
33537func DecodeOxmIdMetadata(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMetadata, error) {
33538 _oxmidmetadata := &OxmIdMetadata{OxmId: parent}
33539 return _oxmidmetadata, nil
33540}
33541
33542func NewOxmIdMetadata() *OxmIdMetadata {
33543 obj := &OxmIdMetadata{
33544 OxmId: NewOxmId(2147484680),
33545 }
33546 return obj
33547}
33548func (self *OxmIdMetadata) GetOXMName() string {
33549 return "metadata"
33550}
33551
33552func (self *OxmIdMetadata) MarshalJSON() ([]byte, error) {
33553 if self.TypeLen == 0 {
33554 return []byte("\"\""), nil
33555 } else {
33556 return []byte("\"" + self.GetOXMName() + "\""), nil
33557 }
33558}
33559
33560type OxmIdMetadataMasked struct {
33561 *OxmId
33562}
33563
33564type IOxmIdMetadataMasked interface {
33565 IOxmId
33566}
33567
33568func (self *OxmIdMetadataMasked) Serialize(encoder *goloxi.Encoder) error {
33569 if err := self.OxmId.Serialize(encoder); err != nil {
33570 return err
33571 }
33572
33573 return nil
33574}
33575
33576func DecodeOxmIdMetadataMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMetadataMasked, error) {
33577 _oxmidmetadatamasked := &OxmIdMetadataMasked{OxmId: parent}
33578 return _oxmidmetadatamasked, nil
33579}
33580
33581func NewOxmIdMetadataMasked() *OxmIdMetadataMasked {
33582 obj := &OxmIdMetadataMasked{
33583 OxmId: NewOxmId(2147484944),
33584 }
33585 return obj
33586}
33587func (self *OxmIdMetadataMasked) GetOXMName() string {
33588 return "metadata_masked"
33589}
33590
33591func (self *OxmIdMetadataMasked) MarshalJSON() ([]byte, error) {
33592 if self.TypeLen == 0 {
33593 return []byte("\"\""), nil
33594 } else {
33595 return []byte("\"" + self.GetOXMName() + "\""), nil
33596 }
33597}
33598
33599type OxmIdMplsBos struct {
33600 *OxmId
33601}
33602
33603type IOxmIdMplsBos interface {
33604 IOxmId
33605}
33606
33607func (self *OxmIdMplsBos) Serialize(encoder *goloxi.Encoder) error {
33608 if err := self.OxmId.Serialize(encoder); err != nil {
33609 return err
33610 }
33611
33612 return nil
33613}
33614
33615func DecodeOxmIdMplsBos(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsBos, error) {
33616 _oxmidmplsbos := &OxmIdMplsBos{OxmId: parent}
33617 return _oxmidmplsbos, nil
33618}
33619
33620func NewOxmIdMplsBos() *OxmIdMplsBos {
33621 obj := &OxmIdMplsBos{
33622 OxmId: NewOxmId(2147502081),
33623 }
33624 return obj
33625}
33626func (self *OxmIdMplsBos) GetOXMName() string {
33627 return "mpls_bos"
33628}
33629
33630func (self *OxmIdMplsBos) MarshalJSON() ([]byte, error) {
33631 if self.TypeLen == 0 {
33632 return []byte("\"\""), nil
33633 } else {
33634 return []byte("\"" + self.GetOXMName() + "\""), nil
33635 }
33636}
33637
33638type OxmIdMplsBosMasked struct {
33639 *OxmId
33640}
33641
33642type IOxmIdMplsBosMasked interface {
33643 IOxmId
33644}
33645
33646func (self *OxmIdMplsBosMasked) Serialize(encoder *goloxi.Encoder) error {
33647 if err := self.OxmId.Serialize(encoder); err != nil {
33648 return err
33649 }
33650
33651 return nil
33652}
33653
33654func DecodeOxmIdMplsBosMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsBosMasked, error) {
33655 _oxmidmplsbosmasked := &OxmIdMplsBosMasked{OxmId: parent}
33656 return _oxmidmplsbosmasked, nil
33657}
33658
33659func NewOxmIdMplsBosMasked() *OxmIdMplsBosMasked {
33660 obj := &OxmIdMplsBosMasked{
33661 OxmId: NewOxmId(2147502338),
33662 }
33663 return obj
33664}
33665func (self *OxmIdMplsBosMasked) GetOXMName() string {
33666 return "mpls_bos_masked"
33667}
33668
33669func (self *OxmIdMplsBosMasked) MarshalJSON() ([]byte, error) {
33670 if self.TypeLen == 0 {
33671 return []byte("\"\""), nil
33672 } else {
33673 return []byte("\"" + self.GetOXMName() + "\""), nil
33674 }
33675}
33676
33677type OxmIdMplsLabel struct {
33678 *OxmId
33679}
33680
33681type IOxmIdMplsLabel interface {
33682 IOxmId
33683}
33684
33685func (self *OxmIdMplsLabel) Serialize(encoder *goloxi.Encoder) error {
33686 if err := self.OxmId.Serialize(encoder); err != nil {
33687 return err
33688 }
33689
33690 return nil
33691}
33692
33693func DecodeOxmIdMplsLabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsLabel, error) {
33694 _oxmidmplslabel := &OxmIdMplsLabel{OxmId: parent}
33695 return _oxmidmplslabel, nil
33696}
33697
33698func NewOxmIdMplsLabel() *OxmIdMplsLabel {
33699 obj := &OxmIdMplsLabel{
33700 OxmId: NewOxmId(2147501060),
33701 }
33702 return obj
33703}
33704func (self *OxmIdMplsLabel) GetOXMName() string {
33705 return "mpls_label"
33706}
33707
33708func (self *OxmIdMplsLabel) MarshalJSON() ([]byte, error) {
33709 if self.TypeLen == 0 {
33710 return []byte("\"\""), nil
33711 } else {
33712 return []byte("\"" + self.GetOXMName() + "\""), nil
33713 }
33714}
33715
33716type OxmIdMplsLabelMasked struct {
33717 *OxmId
33718}
33719
33720type IOxmIdMplsLabelMasked interface {
33721 IOxmId
33722}
33723
33724func (self *OxmIdMplsLabelMasked) Serialize(encoder *goloxi.Encoder) error {
33725 if err := self.OxmId.Serialize(encoder); err != nil {
33726 return err
33727 }
33728
33729 return nil
33730}
33731
33732func DecodeOxmIdMplsLabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsLabelMasked, error) {
33733 _oxmidmplslabelmasked := &OxmIdMplsLabelMasked{OxmId: parent}
33734 return _oxmidmplslabelmasked, nil
33735}
33736
33737func NewOxmIdMplsLabelMasked() *OxmIdMplsLabelMasked {
33738 obj := &OxmIdMplsLabelMasked{
33739 OxmId: NewOxmId(2147501320),
33740 }
33741 return obj
33742}
33743func (self *OxmIdMplsLabelMasked) GetOXMName() string {
33744 return "mpls_label_masked"
33745}
33746
33747func (self *OxmIdMplsLabelMasked) MarshalJSON() ([]byte, error) {
33748 if self.TypeLen == 0 {
33749 return []byte("\"\""), nil
33750 } else {
33751 return []byte("\"" + self.GetOXMName() + "\""), nil
33752 }
33753}
33754
33755type OxmIdMplsTc struct {
33756 *OxmId
33757}
33758
33759type IOxmIdMplsTc interface {
33760 IOxmId
33761}
33762
33763func (self *OxmIdMplsTc) Serialize(encoder *goloxi.Encoder) error {
33764 if err := self.OxmId.Serialize(encoder); err != nil {
33765 return err
33766 }
33767
33768 return nil
33769}
33770
33771func DecodeOxmIdMplsTc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsTc, error) {
33772 _oxmidmplstc := &OxmIdMplsTc{OxmId: parent}
33773 return _oxmidmplstc, nil
33774}
33775
33776func NewOxmIdMplsTc() *OxmIdMplsTc {
33777 obj := &OxmIdMplsTc{
33778 OxmId: NewOxmId(2147501569),
33779 }
33780 return obj
33781}
33782func (self *OxmIdMplsTc) GetOXMName() string {
33783 return "mpls_tc"
33784}
33785
33786func (self *OxmIdMplsTc) MarshalJSON() ([]byte, error) {
33787 if self.TypeLen == 0 {
33788 return []byte("\"\""), nil
33789 } else {
33790 return []byte("\"" + self.GetOXMName() + "\""), nil
33791 }
33792}
33793
33794type OxmIdMplsTcMasked struct {
33795 *OxmId
33796}
33797
33798type IOxmIdMplsTcMasked interface {
33799 IOxmId
33800}
33801
33802func (self *OxmIdMplsTcMasked) Serialize(encoder *goloxi.Encoder) error {
33803 if err := self.OxmId.Serialize(encoder); err != nil {
33804 return err
33805 }
33806
33807 return nil
33808}
33809
33810func DecodeOxmIdMplsTcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsTcMasked, error) {
33811 _oxmidmplstcmasked := &OxmIdMplsTcMasked{OxmId: parent}
33812 return _oxmidmplstcmasked, nil
33813}
33814
33815func NewOxmIdMplsTcMasked() *OxmIdMplsTcMasked {
33816 obj := &OxmIdMplsTcMasked{
33817 OxmId: NewOxmId(2147501826),
33818 }
33819 return obj
33820}
33821func (self *OxmIdMplsTcMasked) GetOXMName() string {
33822 return "mpls_tc_masked"
33823}
33824
33825func (self *OxmIdMplsTcMasked) MarshalJSON() ([]byte, error) {
33826 if self.TypeLen == 0 {
33827 return []byte("\"\""), nil
33828 } else {
33829 return []byte("\"" + self.GetOXMName() + "\""), nil
33830 }
33831}
33832
33833type OxmIdOvsTcpFlags struct {
33834 *OxmId
33835 ExperimenterId uint32
33836}
33837
33838type IOxmIdOvsTcpFlags interface {
33839 IOxmId
33840 GetExperimenterId() uint32
33841}
33842
33843func (self *OxmIdOvsTcpFlags) GetExperimenterId() uint32 {
33844 return self.ExperimenterId
33845}
33846
33847func (self *OxmIdOvsTcpFlags) SetExperimenterId(v uint32) {
33848 self.ExperimenterId = v
33849}
33850
33851func (self *OxmIdOvsTcpFlags) Serialize(encoder *goloxi.Encoder) error {
33852 if err := self.OxmId.Serialize(encoder); err != nil {
33853 return err
33854 }
33855
33856 encoder.PutUint32(uint32(self.ExperimenterId))
33857
33858 return nil
33859}
33860
33861func DecodeOxmIdOvsTcpFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdOvsTcpFlags, error) {
33862 _oxmidovstcpflags := &OxmIdOvsTcpFlags{OxmId: parent}
33863 if decoder.Length() < 4 {
33864 return nil, fmt.Errorf("OxmIdOvsTcpFlags packet too short: %d < 4", decoder.Length())
33865 }
33866 _oxmidovstcpflags.ExperimenterId = uint32(decoder.ReadUint32())
33867 return _oxmidovstcpflags, nil
33868}
33869
33870func NewOxmIdOvsTcpFlags() *OxmIdOvsTcpFlags {
33871 obj := &OxmIdOvsTcpFlags{
33872 OxmId: NewOxmId(4294923270),
33873 }
33874 return obj
33875}
33876func (self *OxmIdOvsTcpFlags) GetOXMName() string {
33877 return "ovs_tcp_flags"
33878}
33879
33880func (self *OxmIdOvsTcpFlags) MarshalJSON() ([]byte, error) {
33881 if self.TypeLen == 0 {
33882 return []byte("\"\""), nil
33883 } else {
33884 return []byte("\"" + self.GetOXMName() + "\""), nil
33885 }
33886}
33887
33888type OxmIdOvsTcpFlagsMasked struct {
33889 *OxmId
33890 ExperimenterId uint32
33891}
33892
33893type IOxmIdOvsTcpFlagsMasked interface {
33894 IOxmId
33895 GetExperimenterId() uint32
33896}
33897
33898func (self *OxmIdOvsTcpFlagsMasked) GetExperimenterId() uint32 {
33899 return self.ExperimenterId
33900}
33901
33902func (self *OxmIdOvsTcpFlagsMasked) SetExperimenterId(v uint32) {
33903 self.ExperimenterId = v
33904}
33905
33906func (self *OxmIdOvsTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
33907 if err := self.OxmId.Serialize(encoder); err != nil {
33908 return err
33909 }
33910
33911 encoder.PutUint32(uint32(self.ExperimenterId))
33912
33913 return nil
33914}
33915
33916func DecodeOxmIdOvsTcpFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdOvsTcpFlagsMasked, error) {
33917 _oxmidovstcpflagsmasked := &OxmIdOvsTcpFlagsMasked{OxmId: parent}
33918 if decoder.Length() < 4 {
33919 return nil, fmt.Errorf("OxmIdOvsTcpFlagsMasked packet too short: %d < 4", decoder.Length())
33920 }
33921 _oxmidovstcpflagsmasked.ExperimenterId = uint32(decoder.ReadUint32())
33922 return _oxmidovstcpflagsmasked, nil
33923}
33924
33925func NewOxmIdOvsTcpFlagsMasked() *OxmIdOvsTcpFlagsMasked {
33926 obj := &OxmIdOvsTcpFlagsMasked{
33927 OxmId: NewOxmId(4294923528),
33928 }
33929 return obj
33930}
33931func (self *OxmIdOvsTcpFlagsMasked) GetOXMName() string {
33932 return "ovs_tcp_flags_masked"
33933}
33934
33935func (self *OxmIdOvsTcpFlagsMasked) MarshalJSON() ([]byte, error) {
33936 if self.TypeLen == 0 {
33937 return []byte("\"\""), nil
33938 } else {
33939 return []byte("\"" + self.GetOXMName() + "\""), nil
33940 }
33941}
33942
33943type OxmIdPacketType struct {
33944 *OxmId
33945}
33946
33947type IOxmIdPacketType interface {
33948 IOxmId
33949}
33950
33951func (self *OxmIdPacketType) Serialize(encoder *goloxi.Encoder) error {
33952 if err := self.OxmId.Serialize(encoder); err != nil {
33953 return err
33954 }
33955
33956 return nil
33957}
33958
33959func DecodeOxmIdPacketType(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdPacketType, error) {
33960 _oxmidpackettype := &OxmIdPacketType{OxmId: parent}
33961 return _oxmidpackettype, nil
33962}
33963
33964func NewOxmIdPacketType() *OxmIdPacketType {
33965 obj := &OxmIdPacketType{
33966 OxmId: NewOxmId(2147506180),
33967 }
33968 return obj
33969}
33970func (self *OxmIdPacketType) GetOXMName() string {
33971 return "packet_type"
33972}
33973
33974func (self *OxmIdPacketType) MarshalJSON() ([]byte, error) {
33975 if self.TypeLen == 0 {
33976 return []byte("\"\""), nil
33977 } else {
33978 return []byte("\"" + self.GetOXMName() + "\""), nil
33979 }
33980}
33981
33982type OxmIdPbbUca struct {
33983 *OxmId
33984}
33985
33986type IOxmIdPbbUca interface {
33987 IOxmId
33988}
33989
33990func (self *OxmIdPbbUca) Serialize(encoder *goloxi.Encoder) error {
33991 if err := self.OxmId.Serialize(encoder); err != nil {
33992 return err
33993 }
33994
33995 return nil
33996}
33997
33998func DecodeOxmIdPbbUca(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdPbbUca, error) {
33999 _oxmidpbbuca := &OxmIdPbbUca{OxmId: parent}
34000 return _oxmidpbbuca, nil
34001}
34002
34003func NewOxmIdPbbUca() *OxmIdPbbUca {
34004 obj := &OxmIdPbbUca{
34005 OxmId: NewOxmId(2147504641),
34006 }
34007 return obj
34008}
34009func (self *OxmIdPbbUca) GetOXMName() string {
34010 return "pbb_uca"
34011}
34012
34013func (self *OxmIdPbbUca) MarshalJSON() ([]byte, error) {
34014 if self.TypeLen == 0 {
34015 return []byte("\"\""), nil
34016 } else {
34017 return []byte("\"" + self.GetOXMName() + "\""), nil
34018 }
34019}
34020
34021type OxmIdPbbUcaMasked struct {
34022 *OxmId
34023}
34024
34025type IOxmIdPbbUcaMasked interface {
34026 IOxmId
34027}
34028
34029func (self *OxmIdPbbUcaMasked) Serialize(encoder *goloxi.Encoder) error {
34030 if err := self.OxmId.Serialize(encoder); err != nil {
34031 return err
34032 }
34033
34034 return nil
34035}
34036
34037func DecodeOxmIdPbbUcaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdPbbUcaMasked, error) {
34038 _oxmidpbbucamasked := &OxmIdPbbUcaMasked{OxmId: parent}
34039 return _oxmidpbbucamasked, nil
34040}
34041
34042func NewOxmIdPbbUcaMasked() *OxmIdPbbUcaMasked {
34043 obj := &OxmIdPbbUcaMasked{
34044 OxmId: NewOxmId(2147504898),
34045 }
34046 return obj
34047}
34048func (self *OxmIdPbbUcaMasked) GetOXMName() string {
34049 return "pbb_uca_masked"
34050}
34051
34052func (self *OxmIdPbbUcaMasked) MarshalJSON() ([]byte, error) {
34053 if self.TypeLen == 0 {
34054 return []byte("\"\""), nil
34055 } else {
34056 return []byte("\"" + self.GetOXMName() + "\""), nil
34057 }
34058}
34059
34060type OxmIdSctpDst struct {
34061 *OxmId
34062}
34063
34064type IOxmIdSctpDst interface {
34065 IOxmId
34066}
34067
34068func (self *OxmIdSctpDst) Serialize(encoder *goloxi.Encoder) error {
34069 if err := self.OxmId.Serialize(encoder); err != nil {
34070 return err
34071 }
34072
34073 return nil
34074}
34075
34076func DecodeOxmIdSctpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpDst, error) {
34077 _oxmidsctpdst := &OxmIdSctpDst{OxmId: parent}
34078 return _oxmidsctpdst, nil
34079}
34080
34081func NewOxmIdSctpDst() *OxmIdSctpDst {
34082 obj := &OxmIdSctpDst{
34083 OxmId: NewOxmId(2147492866),
34084 }
34085 return obj
34086}
34087func (self *OxmIdSctpDst) GetOXMName() string {
34088 return "sctp_dst"
34089}
34090
34091func (self *OxmIdSctpDst) MarshalJSON() ([]byte, error) {
34092 if self.TypeLen == 0 {
34093 return []byte("\"\""), nil
34094 } else {
34095 return []byte("\"" + self.GetOXMName() + "\""), nil
34096 }
34097}
34098
34099type OxmIdSctpDstMasked struct {
34100 *OxmId
34101}
34102
34103type IOxmIdSctpDstMasked interface {
34104 IOxmId
34105}
34106
34107func (self *OxmIdSctpDstMasked) Serialize(encoder *goloxi.Encoder) error {
34108 if err := self.OxmId.Serialize(encoder); err != nil {
34109 return err
34110 }
34111
34112 return nil
34113}
34114
34115func DecodeOxmIdSctpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpDstMasked, error) {
34116 _oxmidsctpdstmasked := &OxmIdSctpDstMasked{OxmId: parent}
34117 return _oxmidsctpdstmasked, nil
34118}
34119
34120func NewOxmIdSctpDstMasked() *OxmIdSctpDstMasked {
34121 obj := &OxmIdSctpDstMasked{
34122 OxmId: NewOxmId(2147493124),
34123 }
34124 return obj
34125}
34126func (self *OxmIdSctpDstMasked) GetOXMName() string {
34127 return "sctp_dst_masked"
34128}
34129
34130func (self *OxmIdSctpDstMasked) MarshalJSON() ([]byte, error) {
34131 if self.TypeLen == 0 {
34132 return []byte("\"\""), nil
34133 } else {
34134 return []byte("\"" + self.GetOXMName() + "\""), nil
34135 }
34136}
34137
34138type OxmIdSctpSrc struct {
34139 *OxmId
34140}
34141
34142type IOxmIdSctpSrc interface {
34143 IOxmId
34144}
34145
34146func (self *OxmIdSctpSrc) Serialize(encoder *goloxi.Encoder) error {
34147 if err := self.OxmId.Serialize(encoder); err != nil {
34148 return err
34149 }
34150
34151 return nil
34152}
34153
34154func DecodeOxmIdSctpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpSrc, error) {
34155 _oxmidsctpsrc := &OxmIdSctpSrc{OxmId: parent}
34156 return _oxmidsctpsrc, nil
34157}
34158
34159func NewOxmIdSctpSrc() *OxmIdSctpSrc {
34160 obj := &OxmIdSctpSrc{
34161 OxmId: NewOxmId(2147492354),
34162 }
34163 return obj
34164}
34165func (self *OxmIdSctpSrc) GetOXMName() string {
34166 return "sctp_src"
34167}
34168
34169func (self *OxmIdSctpSrc) MarshalJSON() ([]byte, error) {
34170 if self.TypeLen == 0 {
34171 return []byte("\"\""), nil
34172 } else {
34173 return []byte("\"" + self.GetOXMName() + "\""), nil
34174 }
34175}
34176
34177type OxmIdSctpSrcMasked struct {
34178 *OxmId
34179}
34180
34181type IOxmIdSctpSrcMasked interface {
34182 IOxmId
34183}
34184
34185func (self *OxmIdSctpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
34186 if err := self.OxmId.Serialize(encoder); err != nil {
34187 return err
34188 }
34189
34190 return nil
34191}
34192
34193func DecodeOxmIdSctpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpSrcMasked, error) {
34194 _oxmidsctpsrcmasked := &OxmIdSctpSrcMasked{OxmId: parent}
34195 return _oxmidsctpsrcmasked, nil
34196}
34197
34198func NewOxmIdSctpSrcMasked() *OxmIdSctpSrcMasked {
34199 obj := &OxmIdSctpSrcMasked{
34200 OxmId: NewOxmId(2147492612),
34201 }
34202 return obj
34203}
34204func (self *OxmIdSctpSrcMasked) GetOXMName() string {
34205 return "sctp_src_masked"
34206}
34207
34208func (self *OxmIdSctpSrcMasked) MarshalJSON() ([]byte, error) {
34209 if self.TypeLen == 0 {
34210 return []byte("\"\""), nil
34211 } else {
34212 return []byte("\"" + self.GetOXMName() + "\""), nil
34213 }
34214}
34215
34216type OxmIdTunnelId struct {
34217 *OxmId
34218}
34219
34220type IOxmIdTunnelId interface {
34221 IOxmId
34222}
34223
34224func (self *OxmIdTunnelId) Serialize(encoder *goloxi.Encoder) error {
34225 if err := self.OxmId.Serialize(encoder); err != nil {
34226 return err
34227 }
34228
34229 return nil
34230}
34231
34232func DecodeOxmIdTunnelId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelId, error) {
34233 _oxmidtunnelid := &OxmIdTunnelId{OxmId: parent}
34234 return _oxmidtunnelid, nil
34235}
34236
34237func NewOxmIdTunnelId() *OxmIdTunnelId {
34238 obj := &OxmIdTunnelId{
34239 OxmId: NewOxmId(2147503112),
34240 }
34241 return obj
34242}
34243func (self *OxmIdTunnelId) GetOXMName() string {
34244 return "tunnel_id"
34245}
34246
34247func (self *OxmIdTunnelId) MarshalJSON() ([]byte, error) {
34248 if self.TypeLen == 0 {
34249 return []byte("\"\""), nil
34250 } else {
34251 return []byte("\"" + self.GetOXMName() + "\""), nil
34252 }
34253}
34254
34255type OxmIdTunnelIdMasked struct {
34256 *OxmId
34257}
34258
34259type IOxmIdTunnelIdMasked interface {
34260 IOxmId
34261}
34262
34263func (self *OxmIdTunnelIdMasked) Serialize(encoder *goloxi.Encoder) error {
34264 if err := self.OxmId.Serialize(encoder); err != nil {
34265 return err
34266 }
34267
34268 return nil
34269}
34270
34271func DecodeOxmIdTunnelIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelIdMasked, error) {
34272 _oxmidtunnelidmasked := &OxmIdTunnelIdMasked{OxmId: parent}
34273 return _oxmidtunnelidmasked, nil
34274}
34275
34276func NewOxmIdTunnelIdMasked() *OxmIdTunnelIdMasked {
34277 obj := &OxmIdTunnelIdMasked{
34278 OxmId: NewOxmId(2147503376),
34279 }
34280 return obj
34281}
34282func (self *OxmIdTunnelIdMasked) GetOXMName() string {
34283 return "tunnel_id_masked"
34284}
34285
34286func (self *OxmIdTunnelIdMasked) MarshalJSON() ([]byte, error) {
34287 if self.TypeLen == 0 {
34288 return []byte("\"\""), nil
34289 } else {
34290 return []byte("\"" + self.GetOXMName() + "\""), nil
34291 }
34292}
34293
34294type OxmIdTunnelIpv4Dst struct {
34295 *OxmId
34296}
34297
34298type IOxmIdTunnelIpv4Dst interface {
34299 IOxmId
34300}
34301
34302func (self *OxmIdTunnelIpv4Dst) Serialize(encoder *goloxi.Encoder) error {
34303 if err := self.OxmId.Serialize(encoder); err != nil {
34304 return err
34305 }
34306
34307 return nil
34308}
34309
34310func DecodeOxmIdTunnelIpv4Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelIpv4Dst, error) {
34311 _oxmidtunnelipv4dst := &OxmIdTunnelIpv4Dst{OxmId: parent}
34312 return _oxmidtunnelipv4dst, nil
34313}
34314
34315func NewOxmIdTunnelIpv4Dst() *OxmIdTunnelIpv4Dst {
34316 obj := &OxmIdTunnelIpv4Dst{
34317 OxmId: NewOxmId(81924),
34318 }
34319 return obj
34320}
34321func (self *OxmIdTunnelIpv4Dst) GetOXMName() string {
34322 return "tunnel_ipv4_dst"
34323}
34324
34325func (self *OxmIdTunnelIpv4Dst) MarshalJSON() ([]byte, error) {
34326 if self.TypeLen == 0 {
34327 return []byte("\"\""), nil
34328 } else {
34329 return []byte("\"" + self.GetOXMName() + "\""), nil
34330 }
34331}
34332
34333type OxmIdTunnelIpv4DstMasked struct {
34334 *OxmId
34335}
34336
34337type IOxmIdTunnelIpv4DstMasked interface {
34338 IOxmId
34339}
34340
34341func (self *OxmIdTunnelIpv4DstMasked) Serialize(encoder *goloxi.Encoder) error {
34342 if err := self.OxmId.Serialize(encoder); err != nil {
34343 return err
34344 }
34345
34346 return nil
34347}
34348
34349func DecodeOxmIdTunnelIpv4DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelIpv4DstMasked, error) {
34350 _oxmidtunnelipv4dstmasked := &OxmIdTunnelIpv4DstMasked{OxmId: parent}
34351 return _oxmidtunnelipv4dstmasked, nil
34352}
34353
34354func NewOxmIdTunnelIpv4DstMasked() *OxmIdTunnelIpv4DstMasked {
34355 obj := &OxmIdTunnelIpv4DstMasked{
34356 OxmId: NewOxmId(82184),
34357 }
34358 return obj
34359}
34360func (self *OxmIdTunnelIpv4DstMasked) GetOXMName() string {
34361 return "tunnel_ipv4_dst_masked"
34362}
34363
34364func (self *OxmIdTunnelIpv4DstMasked) MarshalJSON() ([]byte, error) {
34365 if self.TypeLen == 0 {
34366 return []byte("\"\""), nil
34367 } else {
34368 return []byte("\"" + self.GetOXMName() + "\""), nil
34369 }
34370}
34371
34372type OxmIdTunnelIpv4Src struct {
34373 *OxmId
34374}
34375
34376type IOxmIdTunnelIpv4Src interface {
34377 IOxmId
34378}
34379
34380func (self *OxmIdTunnelIpv4Src) Serialize(encoder *goloxi.Encoder) error {
34381 if err := self.OxmId.Serialize(encoder); err != nil {
34382 return err
34383 }
34384
34385 return nil
34386}
34387
34388func DecodeOxmIdTunnelIpv4Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelIpv4Src, error) {
34389 _oxmidtunnelipv4src := &OxmIdTunnelIpv4Src{OxmId: parent}
34390 return _oxmidtunnelipv4src, nil
34391}
34392
34393func NewOxmIdTunnelIpv4Src() *OxmIdTunnelIpv4Src {
34394 obj := &OxmIdTunnelIpv4Src{
34395 OxmId: NewOxmId(81412),
34396 }
34397 return obj
34398}
34399func (self *OxmIdTunnelIpv4Src) GetOXMName() string {
34400 return "tunnel_ipv4_src"
34401}
34402
34403func (self *OxmIdTunnelIpv4Src) MarshalJSON() ([]byte, error) {
34404 if self.TypeLen == 0 {
34405 return []byte("\"\""), nil
34406 } else {
34407 return []byte("\"" + self.GetOXMName() + "\""), nil
34408 }
34409}
34410
34411type OxmIdTunnelIpv4SrcMasked struct {
34412 *OxmId
34413}
34414
34415type IOxmIdTunnelIpv4SrcMasked interface {
34416 IOxmId
34417}
34418
34419func (self *OxmIdTunnelIpv4SrcMasked) Serialize(encoder *goloxi.Encoder) error {
34420 if err := self.OxmId.Serialize(encoder); err != nil {
34421 return err
34422 }
34423
34424 return nil
34425}
34426
34427func DecodeOxmIdTunnelIpv4SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelIpv4SrcMasked, error) {
34428 _oxmidtunnelipv4srcmasked := &OxmIdTunnelIpv4SrcMasked{OxmId: parent}
34429 return _oxmidtunnelipv4srcmasked, nil
34430}
34431
34432func NewOxmIdTunnelIpv4SrcMasked() *OxmIdTunnelIpv4SrcMasked {
34433 obj := &OxmIdTunnelIpv4SrcMasked{
34434 OxmId: NewOxmId(81672),
34435 }
34436 return obj
34437}
34438func (self *OxmIdTunnelIpv4SrcMasked) GetOXMName() string {
34439 return "tunnel_ipv4_src_masked"
34440}
34441
34442func (self *OxmIdTunnelIpv4SrcMasked) MarshalJSON() ([]byte, error) {
34443 if self.TypeLen == 0 {
34444 return []byte("\"\""), nil
34445 } else {
34446 return []byte("\"" + self.GetOXMName() + "\""), nil
34447 }
34448}
34449
34450type OxmIdVlanPcp struct {
34451 *OxmId
34452}
34453
34454type IOxmIdVlanPcp interface {
34455 IOxmId
34456}
34457
34458func (self *OxmIdVlanPcp) Serialize(encoder *goloxi.Encoder) error {
34459 if err := self.OxmId.Serialize(encoder); err != nil {
34460 return err
34461 }
34462
34463 return nil
34464}
34465
34466func DecodeOxmIdVlanPcp(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanPcp, error) {
34467 _oxmidvlanpcp := &OxmIdVlanPcp{OxmId: parent}
34468 return _oxmidvlanpcp, nil
34469}
34470
34471func NewOxmIdVlanPcp() *OxmIdVlanPcp {
34472 obj := &OxmIdVlanPcp{
34473 OxmId: NewOxmId(2147487233),
34474 }
34475 return obj
34476}
34477func (self *OxmIdVlanPcp) GetOXMName() string {
34478 return "vlan_pcp"
34479}
34480
34481func (self *OxmIdVlanPcp) MarshalJSON() ([]byte, error) {
34482 if self.TypeLen == 0 {
34483 return []byte("\"\""), nil
34484 } else {
34485 return []byte("\"" + self.GetOXMName() + "\""), nil
34486 }
34487}
34488
34489type OxmIdVlanPcpMasked struct {
34490 *OxmId
34491}
34492
34493type IOxmIdVlanPcpMasked interface {
34494 IOxmId
34495}
34496
34497func (self *OxmIdVlanPcpMasked) Serialize(encoder *goloxi.Encoder) error {
34498 if err := self.OxmId.Serialize(encoder); err != nil {
34499 return err
34500 }
34501
34502 return nil
34503}
34504
34505func DecodeOxmIdVlanPcpMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanPcpMasked, error) {
34506 _oxmidvlanpcpmasked := &OxmIdVlanPcpMasked{OxmId: parent}
34507 return _oxmidvlanpcpmasked, nil
34508}
34509
34510func NewOxmIdVlanPcpMasked() *OxmIdVlanPcpMasked {
34511 obj := &OxmIdVlanPcpMasked{
34512 OxmId: NewOxmId(2147487490),
34513 }
34514 return obj
34515}
34516func (self *OxmIdVlanPcpMasked) GetOXMName() string {
34517 return "vlan_pcp_masked"
34518}
34519
34520func (self *OxmIdVlanPcpMasked) MarshalJSON() ([]byte, error) {
34521 if self.TypeLen == 0 {
34522 return []byte("\"\""), nil
34523 } else {
34524 return []byte("\"" + self.GetOXMName() + "\""), nil
34525 }
34526}
34527
34528type OxmIdVlanVid struct {
34529 *OxmId
34530}
34531
34532type IOxmIdVlanVid interface {
34533 IOxmId
34534}
34535
34536func (self *OxmIdVlanVid) Serialize(encoder *goloxi.Encoder) error {
34537 if err := self.OxmId.Serialize(encoder); err != nil {
34538 return err
34539 }
34540
34541 return nil
34542}
34543
34544func DecodeOxmIdVlanVid(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanVid, error) {
34545 _oxmidvlanvid := &OxmIdVlanVid{OxmId: parent}
34546 return _oxmidvlanvid, nil
34547}
34548
34549func NewOxmIdVlanVid() *OxmIdVlanVid {
34550 obj := &OxmIdVlanVid{
34551 OxmId: NewOxmId(2147486722),
34552 }
34553 return obj
34554}
34555func (self *OxmIdVlanVid) GetOXMName() string {
34556 return "vlan_vid"
34557}
34558
34559func (self *OxmIdVlanVid) MarshalJSON() ([]byte, error) {
34560 if self.TypeLen == 0 {
34561 return []byte("\"\""), nil
34562 } else {
34563 return []byte("\"" + self.GetOXMName() + "\""), nil
34564 }
34565}
34566
34567type OxmIdVlanVidMasked struct {
34568 *OxmId
34569}
34570
34571type IOxmIdVlanVidMasked interface {
34572 IOxmId
34573}
34574
34575func (self *OxmIdVlanVidMasked) Serialize(encoder *goloxi.Encoder) error {
34576 if err := self.OxmId.Serialize(encoder); err != nil {
34577 return err
34578 }
34579
34580 return nil
34581}
34582
34583func DecodeOxmIdVlanVidMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanVidMasked, error) {
34584 _oxmidvlanvidmasked := &OxmIdVlanVidMasked{OxmId: parent}
34585 return _oxmidvlanvidmasked, nil
34586}
34587
34588func NewOxmIdVlanVidMasked() *OxmIdVlanVidMasked {
34589 obj := &OxmIdVlanVidMasked{
34590 OxmId: NewOxmId(2147486980),
34591 }
34592 return obj
34593}
34594func (self *OxmIdVlanVidMasked) GetOXMName() string {
34595 return "vlan_vid_masked"
34596}
34597
34598func (self *OxmIdVlanVidMasked) MarshalJSON() ([]byte, error) {
34599 if self.TypeLen == 0 {
34600 return []byte("\"\""), nil
34601 } else {
34602 return []byte("\"" + self.GetOXMName() + "\""), nil
34603 }
34604}
34605
34606type PacketQueue struct {
34607 QueueId uint32
34608 Port Port
34609 Len uint16
34610 Properties []IQueueProp
34611}
34612
34613type IPacketQueue interface {
34614 goloxi.Serializable
34615 GetQueueId() uint32
34616 GetPort() Port
34617 GetLen() uint16
34618 GetProperties() []IQueueProp
34619}
34620
34621func (self *PacketQueue) GetQueueId() uint32 {
34622 return self.QueueId
34623}
34624
34625func (self *PacketQueue) SetQueueId(v uint32) {
34626 self.QueueId = v
34627}
34628
34629func (self *PacketQueue) GetPort() Port {
34630 return self.Port
34631}
34632
34633func (self *PacketQueue) SetPort(v Port) {
34634 self.Port = v
34635}
34636
34637func (self *PacketQueue) GetLen() uint16 {
34638 return self.Len
34639}
34640
34641func (self *PacketQueue) SetLen(v uint16) {
34642 self.Len = v
34643}
34644
34645func (self *PacketQueue) GetProperties() []IQueueProp {
34646 return self.Properties
34647}
34648
34649func (self *PacketQueue) SetProperties(v []IQueueProp) {
34650 self.Properties = v
34651}
34652
34653func (self *PacketQueue) Serialize(encoder *goloxi.Encoder) error {
34654 startIndex := len(encoder.Bytes())
34655
34656 encoder.PutUint32(uint32(self.QueueId))
34657 self.Port.Serialize(encoder)
34658 encoder.PutUint16(uint16(self.Len))
34659 encoder.Write(bytes.Repeat([]byte{0}, 6))
34660 for _, obj := range self.Properties {
34661 if err := obj.Serialize(encoder); err != nil {
34662 return err
34663 }
34664 }
34665 length := len(encoder.Bytes()) - startIndex
34666
34667 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+8:startIndex+10], uint16(length))
34668
34669 return nil
34670}
34671
34672func DecodePacketQueue(decoder *goloxi.Decoder) (*PacketQueue, error) {
34673 _packetqueue := &PacketQueue{}
34674 if decoder.Length() < 16 {
34675 return nil, fmt.Errorf("PacketQueue packet too short: %d < 16", decoder.Length())
34676 }
34677 _packetqueue.QueueId = uint32(decoder.ReadUint32())
34678 _packetqueue.Port.Decode(decoder)
34679 _packetqueue.Len = uint16(decoder.ReadUint16())
34680 oldDecoder := decoder
34681 defer func() { decoder = oldDecoder }()
34682 decoder = decoder.SliceDecoder(int(_packetqueue.Len), 2+8)
34683 decoder.Skip(6)
34684
34685 for decoder.Length() >= 8 {
34686 item, err := DecodeQueueProp(decoder)
34687 if err != nil {
34688 return nil, err
34689 }
34690 if item != nil {
34691 _packetqueue.Properties = append(_packetqueue.Properties, item)
34692 }
34693 }
34694 return _packetqueue, nil
34695}
34696
34697func NewPacketQueue() *PacketQueue {
34698 obj := &PacketQueue{}
34699 return obj
34700}
34701
34702type PortDesc struct {
34703 PortNo Port
34704 Length uint16
34705 HwAddr net.HardwareAddr
34706 Name string
34707 Config PortConfig
34708 State PortState
34709 Properties []IPortDescProp
34710}
34711
34712type IPortDesc interface {
34713 goloxi.Serializable
34714 GetPortNo() Port
34715 GetLength() uint16
34716 GetHwAddr() net.HardwareAddr
34717 GetName() string
34718 GetConfig() PortConfig
34719 GetState() PortState
34720 GetProperties() []IPortDescProp
34721}
34722
34723func (self *PortDesc) GetPortNo() Port {
34724 return self.PortNo
34725}
34726
34727func (self *PortDesc) SetPortNo(v Port) {
34728 self.PortNo = v
34729}
34730
34731func (self *PortDesc) GetLength() uint16 {
34732 return self.Length
34733}
34734
34735func (self *PortDesc) SetLength(v uint16) {
34736 self.Length = v
34737}
34738
34739func (self *PortDesc) GetHwAddr() net.HardwareAddr {
34740 return self.HwAddr
34741}
34742
34743func (self *PortDesc) SetHwAddr(v net.HardwareAddr) {
34744 self.HwAddr = v
34745}
34746
34747func (self *PortDesc) GetName() string {
34748 return self.Name
34749}
34750
34751func (self *PortDesc) SetName(v string) {
34752 self.Name = v
34753}
34754
34755func (self *PortDesc) GetConfig() PortConfig {
34756 return self.Config
34757}
34758
34759func (self *PortDesc) SetConfig(v PortConfig) {
34760 self.Config = v
34761}
34762
34763func (self *PortDesc) GetState() PortState {
34764 return self.State
34765}
34766
34767func (self *PortDesc) SetState(v PortState) {
34768 self.State = v
34769}
34770
34771func (self *PortDesc) GetProperties() []IPortDescProp {
34772 return self.Properties
34773}
34774
34775func (self *PortDesc) SetProperties(v []IPortDescProp) {
34776 self.Properties = v
34777}
34778
34779func (self *PortDesc) Serialize(encoder *goloxi.Encoder) error {
34780 startIndex := len(encoder.Bytes())
34781
34782 self.PortNo.Serialize(encoder)
34783 encoder.PutUint16(uint16(self.Length))
34784 encoder.Write(bytes.Repeat([]byte{0}, 2))
34785 encoder.Write(self.HwAddr)
34786 encoder.Write(bytes.Repeat([]byte{0}, 2))
34787 encoder.Write([]byte(self.Name))
34788 encoder.PutUint32(uint32(self.Config))
34789 encoder.PutUint32(uint32(self.State))
34790 for _, obj := range self.Properties {
34791 if err := obj.Serialize(encoder); err != nil {
34792 return err
34793 }
34794 }
34795 length := len(encoder.Bytes()) - startIndex
34796
34797 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+4:startIndex+6], uint16(length))
34798
34799 return nil
34800}
34801func (self *PortDesc) Decode(decoder *goloxi.Decoder) error {
34802 if decoder.Length() < 40 {
34803 return fmt.Errorf("PortDesc packet too short: %d < 40", decoder.Length())
34804 }
34805
34806 self.PortNo.Decode(decoder)
34807 self.Length = uint16(decoder.ReadUint16())
34808 oldDecoder := decoder
34809 defer func() { decoder = oldDecoder }()
34810 decoder = decoder.SliceDecoder(int(self.Length), 2+4)
34811 decoder.Skip(2)
34812 self.HwAddr = net.HardwareAddr(decoder.Read(6))
34813 decoder.Skip(2)
34814 self.Name = string(bytes.Trim(decoder.Read(16), "\x00"))
34815 self.Config = PortConfig(decoder.ReadUint32())
34816 self.State = PortState(decoder.ReadUint32())
34817
34818 for decoder.Length() >= 4 {
34819 item, err := DecodePortDescProp(decoder)
34820 if err != nil {
34821 return err
34822 }
34823 if item != nil {
34824 self.Properties = append(self.Properties, item)
34825 }
34826 }
34827
34828 return nil
34829}
34830
34831func NewPortDesc() *PortDesc {
34832 obj := &PortDesc{}
34833 return obj
34834}
34835
34836type PortDescProp struct {
34837 Type uint16
34838 Length uint16
34839}
34840
34841type IPortDescProp interface {
34842 goloxi.Serializable
34843 GetType() uint16
34844 GetLength() uint16
34845}
34846
34847func (self *PortDescProp) GetType() uint16 {
34848 return self.Type
34849}
34850
34851func (self *PortDescProp) SetType(v uint16) {
34852 self.Type = v
34853}
34854
34855func (self *PortDescProp) GetLength() uint16 {
34856 return self.Length
34857}
34858
34859func (self *PortDescProp) SetLength(v uint16) {
34860 self.Length = v
34861}
34862
34863func (self *PortDescProp) Serialize(encoder *goloxi.Encoder) error {
34864
34865 encoder.PutUint16(uint16(self.Type))
34866 encoder.PutUint16(uint16(self.Length))
34867
34868 return nil
34869}
34870
34871func DecodePortDescProp(decoder *goloxi.Decoder) (IPortDescProp, error) {
34872 _portdescprop := &PortDescProp{}
34873 if decoder.Length() < 4 {
34874 return nil, fmt.Errorf("PortDescProp packet too short: %d < 4", decoder.Length())
34875 }
34876 _portdescprop.Type = uint16(decoder.ReadUint16())
34877 _portdescprop.Length = uint16(decoder.ReadUint16())
34878 oldDecoder := decoder
34879 defer func() { decoder = oldDecoder }()
34880 decoder = decoder.SliceDecoder(int(_portdescprop.Length), 2+2)
34881
34882 switch _portdescprop.Type {
34883 case 0:
34884 return DecodePortDescPropEthernet(_portdescprop, decoder)
34885 case 1:
34886 return DecodePortDescPropOptical(_portdescprop, decoder)
34887 case 65535:
34888 return DecodePortDescPropExperimenter(_portdescprop, decoder)
34889 default:
34890 return nil, fmt.Errorf("Invalid type '%d' for 'PortDescProp'", _portdescprop.Type)
34891 }
34892}
34893
34894func NewPortDescProp(_type uint16) *PortDescProp {
34895 obj := &PortDescProp{}
34896 obj.Type = _type
34897 return obj
34898}
34899
34900type PortDescPropExperimenter struct {
34901 *PortDescProp
34902 Experimenter uint32
34903 ExpType uint32
34904}
34905
34906type IPortDescPropExperimenter interface {
34907 IPortDescProp
34908 GetExperimenter() uint32
34909 GetExpType() uint32
34910}
34911
34912func (self *PortDescPropExperimenter) GetExperimenter() uint32 {
34913 return self.Experimenter
34914}
34915
34916func (self *PortDescPropExperimenter) SetExperimenter(v uint32) {
34917 self.Experimenter = v
34918}
34919
34920func (self *PortDescPropExperimenter) GetExpType() uint32 {
34921 return self.ExpType
34922}
34923
34924func (self *PortDescPropExperimenter) SetExpType(v uint32) {
34925 self.ExpType = v
34926}
34927
34928func (self *PortDescPropExperimenter) Serialize(encoder *goloxi.Encoder) error {
34929 if err := self.PortDescProp.Serialize(encoder); err != nil {
34930 return err
34931 }
34932
34933 encoder.PutUint32(uint32(self.Experimenter))
34934 encoder.PutUint32(uint32(self.ExpType))
34935
34936 return nil
34937}
34938
34939func DecodePortDescPropExperimenter(parent *PortDescProp, decoder *goloxi.Decoder) (IPortDescPropExperimenter, error) {
34940 _portdescpropexperimenter := &PortDescPropExperimenter{PortDescProp: parent}
34941 if decoder.Length() < 8 {
34942 return nil, fmt.Errorf("PortDescPropExperimenter packet too short: %d < 8", decoder.Length())
34943 }
34944 _portdescpropexperimenter.Experimenter = uint32(decoder.ReadUint32())
34945 _portdescpropexperimenter.ExpType = uint32(decoder.ReadUint32())
34946
34947 switch _portdescpropexperimenter.Experimenter {
34948 case 6035143:
34949 return DecodePortDescPropBsn(_portdescpropexperimenter, decoder)
34950 default:
34951 return nil, fmt.Errorf("Invalid type '%d' for 'PortDescPropExperimenter'", _portdescpropexperimenter.Experimenter)
34952 }
34953}
34954
34955func NewPortDescPropExperimenter(_experimenter uint32) *PortDescPropExperimenter {
34956 obj := &PortDescPropExperimenter{
34957 PortDescProp: NewPortDescProp(65535),
34958 }
34959 obj.Experimenter = _experimenter
34960 return obj
34961}
34962
34963type PortDescPropBsn struct {
34964 *PortDescPropExperimenter
34965}
34966
34967type IPortDescPropBsn interface {
34968 IPortDescPropExperimenter
34969}
34970
34971func (self *PortDescPropBsn) Serialize(encoder *goloxi.Encoder) error {
34972 if err := self.PortDescPropExperimenter.Serialize(encoder); err != nil {
34973 return err
34974 }
34975
34976 return nil
34977}
34978
34979func DecodePortDescPropBsn(parent *PortDescPropExperimenter, decoder *goloxi.Decoder) (IPortDescPropBsn, error) {
34980 _portdescpropbsn := &PortDescPropBsn{PortDescPropExperimenter: parent}
34981
34982 switch _portdescpropbsn.ExpType {
34983 case 0:
34984 return DecodePortDescPropBsnUplink(_portdescpropbsn, decoder)
34985 case 1:
34986 return DecodePortDescPropBsnGenerationId(_portdescpropbsn, decoder)
34987 case 2:
34988 return DecodePortDescPropBsnForwardErrorCorrection(_portdescpropbsn, decoder)
34989 case 3:
34990 return DecodePortDescPropBsnBreakout(_portdescpropbsn, decoder)
34991 case 4:
34992 return DecodePortDescPropBsnSpeedCapabilities(_portdescpropbsn, decoder)
34993 case 5:
34994 return DecodePortDescPropBsnMiscCapabilities(_portdescpropbsn, decoder)
34995 case 6:
34996 return DecodePortDescPropBsnSffJson(_portdescpropbsn, decoder)
34997 case 7:
34998 return DecodePortDescPropBsnDriverInfoJson(_portdescpropbsn, decoder)
34999 case 8:
35000 return DecodePortDescPropBsnExtendedCapabilities(_portdescpropbsn, decoder)
35001 default:
35002 return nil, fmt.Errorf("Invalid type '%d' for 'PortDescPropBsn'", _portdescpropbsn.ExpType)
35003 }
35004}
35005
35006func NewPortDescPropBsn(_exp_type uint32) *PortDescPropBsn {
35007 obj := &PortDescPropBsn{
35008 PortDescPropExperimenter: NewPortDescPropExperimenter(6035143),
35009 }
35010 obj.ExpType = _exp_type
35011 return obj
35012}
35013
35014type PortDescPropBsnBreakout struct {
35015 *PortDescPropBsn
35016 SubInterfaceCount uint16
35017 SubInterfaceSpeedGbps uint16
35018}
35019
35020type IPortDescPropBsnBreakout interface {
35021 IPortDescPropBsn
35022 GetSubInterfaceCount() uint16
35023 GetSubInterfaceSpeedGbps() uint16
35024}
35025
35026func (self *PortDescPropBsnBreakout) GetSubInterfaceCount() uint16 {
35027 return self.SubInterfaceCount
35028}
35029
35030func (self *PortDescPropBsnBreakout) SetSubInterfaceCount(v uint16) {
35031 self.SubInterfaceCount = v
35032}
35033
35034func (self *PortDescPropBsnBreakout) GetSubInterfaceSpeedGbps() uint16 {
35035 return self.SubInterfaceSpeedGbps
35036}
35037
35038func (self *PortDescPropBsnBreakout) SetSubInterfaceSpeedGbps(v uint16) {
35039 self.SubInterfaceSpeedGbps = v
35040}
35041
35042func (self *PortDescPropBsnBreakout) Serialize(encoder *goloxi.Encoder) error {
35043 startIndex := len(encoder.Bytes())
35044 if err := self.PortDescPropBsn.Serialize(encoder); err != nil {
35045 return err
35046 }
35047
35048 encoder.PutUint16(uint16(self.SubInterfaceCount))
35049 encoder.PutUint16(uint16(self.SubInterfaceSpeedGbps))
35050 length := len(encoder.Bytes()) - startIndex
35051
35052 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
35053
35054 return nil
35055}
35056
35057func DecodePortDescPropBsnBreakout(parent *PortDescPropBsn, decoder *goloxi.Decoder) (*PortDescPropBsnBreakout, error) {
35058 _portdescpropbsnbreakout := &PortDescPropBsnBreakout{PortDescPropBsn: parent}
35059 if decoder.Length() < 4 {
35060 return nil, fmt.Errorf("PortDescPropBsnBreakout packet too short: %d < 4", decoder.Length())
35061 }
35062 _portdescpropbsnbreakout.SubInterfaceCount = uint16(decoder.ReadUint16())
35063 _portdescpropbsnbreakout.SubInterfaceSpeedGbps = uint16(decoder.ReadUint16())
35064 return _portdescpropbsnbreakout, nil
35065}
35066
35067func NewPortDescPropBsnBreakout() *PortDescPropBsnBreakout {
35068 obj := &PortDescPropBsnBreakout{
35069 PortDescPropBsn: NewPortDescPropBsn(3),
35070 }
35071 return obj
35072}
35073
35074type PortDescPropBsnDriverInfoJson struct {
35075 *PortDescPropBsn
35076 DriverInfoJson []byte
35077}
35078
35079type IPortDescPropBsnDriverInfoJson interface {
35080 IPortDescPropBsn
35081 GetDriverInfoJson() []byte
35082}
35083
35084func (self *PortDescPropBsnDriverInfoJson) GetDriverInfoJson() []byte {
35085 return self.DriverInfoJson
35086}
35087
35088func (self *PortDescPropBsnDriverInfoJson) SetDriverInfoJson(v []byte) {
35089 self.DriverInfoJson = v
35090}
35091
35092func (self *PortDescPropBsnDriverInfoJson) Serialize(encoder *goloxi.Encoder) error {
35093 startIndex := len(encoder.Bytes())
35094 if err := self.PortDescPropBsn.Serialize(encoder); err != nil {
35095 return err
35096 }
35097
35098 encoder.Write(self.DriverInfoJson)
35099 length := len(encoder.Bytes()) - startIndex
35100
35101 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
35102
35103 return nil
35104}
35105
35106func DecodePortDescPropBsnDriverInfoJson(parent *PortDescPropBsn, decoder *goloxi.Decoder) (*PortDescPropBsnDriverInfoJson, error) {
35107 _portdescpropbsndriverinfojson := &PortDescPropBsnDriverInfoJson{PortDescPropBsn: parent}
35108 _portdescpropbsndriverinfojson.DriverInfoJson = decoder.Read(int(decoder.Length()))
35109 return _portdescpropbsndriverinfojson, nil
35110}
35111
35112func NewPortDescPropBsnDriverInfoJson() *PortDescPropBsnDriverInfoJson {
35113 obj := &PortDescPropBsnDriverInfoJson{
35114 PortDescPropBsn: NewPortDescPropBsn(7),
35115 }
35116 return obj
35117}
35118
35119type PortDescPropBsnExtendedCapabilities struct {
35120 *PortDescPropBsn
35121 Configurability uint64
35122 Conflict uint64
35123 Reserved1 uint64
35124 Reserved2 uint64
35125}
35126
35127type IPortDescPropBsnExtendedCapabilities interface {
35128 IPortDescPropBsn
35129 GetConfigurability() uint64
35130 GetConflict() uint64
35131 GetReserved1() uint64
35132 GetReserved2() uint64
35133}
35134
35135func (self *PortDescPropBsnExtendedCapabilities) GetConfigurability() uint64 {
35136 return self.Configurability
35137}
35138
35139func (self *PortDescPropBsnExtendedCapabilities) SetConfigurability(v uint64) {
35140 self.Configurability = v
35141}
35142
35143func (self *PortDescPropBsnExtendedCapabilities) GetConflict() uint64 {
35144 return self.Conflict
35145}
35146
35147func (self *PortDescPropBsnExtendedCapabilities) SetConflict(v uint64) {
35148 self.Conflict = v
35149}
35150
35151func (self *PortDescPropBsnExtendedCapabilities) GetReserved1() uint64 {
35152 return self.Reserved1
35153}
35154
35155func (self *PortDescPropBsnExtendedCapabilities) SetReserved1(v uint64) {
35156 self.Reserved1 = v
35157}
35158
35159func (self *PortDescPropBsnExtendedCapabilities) GetReserved2() uint64 {
35160 return self.Reserved2
35161}
35162
35163func (self *PortDescPropBsnExtendedCapabilities) SetReserved2(v uint64) {
35164 self.Reserved2 = v
35165}
35166
35167func (self *PortDescPropBsnExtendedCapabilities) Serialize(encoder *goloxi.Encoder) error {
35168 startIndex := len(encoder.Bytes())
35169 if err := self.PortDescPropBsn.Serialize(encoder); err != nil {
35170 return err
35171 }
35172
35173 encoder.PutUint64(uint64(self.Configurability))
35174 encoder.PutUint64(uint64(self.Conflict))
35175 encoder.PutUint64(uint64(self.Reserved1))
35176 encoder.PutUint64(uint64(self.Reserved2))
35177 length := len(encoder.Bytes()) - startIndex
35178
35179 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
35180
35181 return nil
35182}
35183
35184func DecodePortDescPropBsnExtendedCapabilities(parent *PortDescPropBsn, decoder *goloxi.Decoder) (*PortDescPropBsnExtendedCapabilities, error) {
35185 _portdescpropbsnextendedcapabilities := &PortDescPropBsnExtendedCapabilities{PortDescPropBsn: parent}
35186 if decoder.Length() < 32 {
35187 return nil, fmt.Errorf("PortDescPropBsnExtendedCapabilities packet too short: %d < 32", decoder.Length())
35188 }
35189 _portdescpropbsnextendedcapabilities.Configurability = uint64(decoder.ReadUint64())
35190 _portdescpropbsnextendedcapabilities.Conflict = uint64(decoder.ReadUint64())
35191 _portdescpropbsnextendedcapabilities.Reserved1 = uint64(decoder.ReadUint64())
35192 _portdescpropbsnextendedcapabilities.Reserved2 = uint64(decoder.ReadUint64())
35193 return _portdescpropbsnextendedcapabilities, nil
35194}
35195
35196func NewPortDescPropBsnExtendedCapabilities() *PortDescPropBsnExtendedCapabilities {
35197 obj := &PortDescPropBsnExtendedCapabilities{
35198 PortDescPropBsn: NewPortDescPropBsn(8),
35199 }
35200 return obj
35201}
35202
35203type PortDescPropBsnForwardErrorCorrection struct {
35204 *PortDescPropBsn
35205 Configured BsnFecConfigState
35206 Enabled uint32
35207}
35208
35209type IPortDescPropBsnForwardErrorCorrection interface {
35210 IPortDescPropBsn
35211 GetConfigured() BsnFecConfigState
35212 GetEnabled() uint32
35213}
35214
35215func (self *PortDescPropBsnForwardErrorCorrection) GetConfigured() BsnFecConfigState {
35216 return self.Configured
35217}
35218
35219func (self *PortDescPropBsnForwardErrorCorrection) SetConfigured(v BsnFecConfigState) {
35220 self.Configured = v
35221}
35222
35223func (self *PortDescPropBsnForwardErrorCorrection) GetEnabled() uint32 {
35224 return self.Enabled
35225}
35226
35227func (self *PortDescPropBsnForwardErrorCorrection) SetEnabled(v uint32) {
35228 self.Enabled = v
35229}
35230
35231func (self *PortDescPropBsnForwardErrorCorrection) Serialize(encoder *goloxi.Encoder) error {
35232 startIndex := len(encoder.Bytes())
35233 if err := self.PortDescPropBsn.Serialize(encoder); err != nil {
35234 return err
35235 }
35236
35237 encoder.PutUint32(uint32(self.Configured))
35238 encoder.PutUint32(uint32(self.Enabled))
35239 length := len(encoder.Bytes()) - startIndex
35240
35241 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
35242
35243 return nil
35244}
35245
35246func DecodePortDescPropBsnForwardErrorCorrection(parent *PortDescPropBsn, decoder *goloxi.Decoder) (*PortDescPropBsnForwardErrorCorrection, error) {
35247 _portdescpropbsnforwarderrorcorrection := &PortDescPropBsnForwardErrorCorrection{PortDescPropBsn: parent}
35248 if decoder.Length() < 8 {
35249 return nil, fmt.Errorf("PortDescPropBsnForwardErrorCorrection packet too short: %d < 8", decoder.Length())
35250 }
35251 _portdescpropbsnforwarderrorcorrection.Configured = BsnFecConfigState(decoder.ReadUint32())
35252 _portdescpropbsnforwarderrorcorrection.Enabled = uint32(decoder.ReadUint32())
35253 return _portdescpropbsnforwarderrorcorrection, nil
35254}
35255
35256func NewPortDescPropBsnForwardErrorCorrection() *PortDescPropBsnForwardErrorCorrection {
35257 obj := &PortDescPropBsnForwardErrorCorrection{
35258 PortDescPropBsn: NewPortDescPropBsn(2),
35259 }
35260 return obj
35261}
35262
35263type PortDescPropBsnGenerationId struct {
35264 *PortDescPropBsn
35265 GenerationId uint64
35266}
35267
35268type IPortDescPropBsnGenerationId interface {
35269 IPortDescPropBsn
35270 GetGenerationId() uint64
35271}
35272
35273func (self *PortDescPropBsnGenerationId) GetGenerationId() uint64 {
35274 return self.GenerationId
35275}
35276
35277func (self *PortDescPropBsnGenerationId) SetGenerationId(v uint64) {
35278 self.GenerationId = v
35279}
35280
35281func (self *PortDescPropBsnGenerationId) Serialize(encoder *goloxi.Encoder) error {
35282 startIndex := len(encoder.Bytes())
35283 if err := self.PortDescPropBsn.Serialize(encoder); err != nil {
35284 return err
35285 }
35286
35287 encoder.PutUint64(uint64(self.GenerationId))
35288 length := len(encoder.Bytes()) - startIndex
35289
35290 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
35291
35292 return nil
35293}
35294
35295func DecodePortDescPropBsnGenerationId(parent *PortDescPropBsn, decoder *goloxi.Decoder) (*PortDescPropBsnGenerationId, error) {
35296 _portdescpropbsngenerationid := &PortDescPropBsnGenerationId{PortDescPropBsn: parent}
35297 if decoder.Length() < 8 {
35298 return nil, fmt.Errorf("PortDescPropBsnGenerationId packet too short: %d < 8", decoder.Length())
35299 }
35300 _portdescpropbsngenerationid.GenerationId = uint64(decoder.ReadUint64())
35301 return _portdescpropbsngenerationid, nil
35302}
35303
35304func NewPortDescPropBsnGenerationId() *PortDescPropBsnGenerationId {
35305 obj := &PortDescPropBsnGenerationId{
35306 PortDescPropBsn: NewPortDescPropBsn(1),
35307 }
35308 return obj
35309}
35310
35311type PortDescPropBsnMiscCapabilities struct {
35312 *PortDescPropBsn
35313 Current uint64
35314 Available uint64
35315 Supported uint64
35316}
35317
35318type IPortDescPropBsnMiscCapabilities interface {
35319 IPortDescPropBsn
35320 GetCurrent() uint64
35321 GetAvailable() uint64
35322 GetSupported() uint64
35323}
35324
35325func (self *PortDescPropBsnMiscCapabilities) GetCurrent() uint64 {
35326 return self.Current
35327}
35328
35329func (self *PortDescPropBsnMiscCapabilities) SetCurrent(v uint64) {
35330 self.Current = v
35331}
35332
35333func (self *PortDescPropBsnMiscCapabilities) GetAvailable() uint64 {
35334 return self.Available
35335}
35336
35337func (self *PortDescPropBsnMiscCapabilities) SetAvailable(v uint64) {
35338 self.Available = v
35339}
35340
35341func (self *PortDescPropBsnMiscCapabilities) GetSupported() uint64 {
35342 return self.Supported
35343}
35344
35345func (self *PortDescPropBsnMiscCapabilities) SetSupported(v uint64) {
35346 self.Supported = v
35347}
35348
35349func (self *PortDescPropBsnMiscCapabilities) Serialize(encoder *goloxi.Encoder) error {
35350 startIndex := len(encoder.Bytes())
35351 if err := self.PortDescPropBsn.Serialize(encoder); err != nil {
35352 return err
35353 }
35354
35355 encoder.PutUint64(uint64(self.Current))
35356 encoder.PutUint64(uint64(self.Available))
35357 encoder.PutUint64(uint64(self.Supported))
35358 length := len(encoder.Bytes()) - startIndex
35359
35360 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
35361
35362 return nil
35363}
35364
35365func DecodePortDescPropBsnMiscCapabilities(parent *PortDescPropBsn, decoder *goloxi.Decoder) (*PortDescPropBsnMiscCapabilities, error) {
35366 _portdescpropbsnmisccapabilities := &PortDescPropBsnMiscCapabilities{PortDescPropBsn: parent}
35367 if decoder.Length() < 24 {
35368 return nil, fmt.Errorf("PortDescPropBsnMiscCapabilities packet too short: %d < 24", decoder.Length())
35369 }
35370 _portdescpropbsnmisccapabilities.Current = uint64(decoder.ReadUint64())
35371 _portdescpropbsnmisccapabilities.Available = uint64(decoder.ReadUint64())
35372 _portdescpropbsnmisccapabilities.Supported = uint64(decoder.ReadUint64())
35373 return _portdescpropbsnmisccapabilities, nil
35374}
35375
35376func NewPortDescPropBsnMiscCapabilities() *PortDescPropBsnMiscCapabilities {
35377 obj := &PortDescPropBsnMiscCapabilities{
35378 PortDescPropBsn: NewPortDescPropBsn(5),
35379 }
35380 return obj
35381}
35382
35383type PortDescPropBsnSffJson struct {
35384 *PortDescPropBsn
35385 DataJson []byte
35386}
35387
35388type IPortDescPropBsnSffJson interface {
35389 IPortDescPropBsn
35390 GetDataJson() []byte
35391}
35392
35393func (self *PortDescPropBsnSffJson) GetDataJson() []byte {
35394 return self.DataJson
35395}
35396
35397func (self *PortDescPropBsnSffJson) SetDataJson(v []byte) {
35398 self.DataJson = v
35399}
35400
35401func (self *PortDescPropBsnSffJson) Serialize(encoder *goloxi.Encoder) error {
35402 startIndex := len(encoder.Bytes())
35403 if err := self.PortDescPropBsn.Serialize(encoder); err != nil {
35404 return err
35405 }
35406
35407 encoder.Write(self.DataJson)
35408 length := len(encoder.Bytes()) - startIndex
35409
35410 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
35411
35412 return nil
35413}
35414
35415func DecodePortDescPropBsnSffJson(parent *PortDescPropBsn, decoder *goloxi.Decoder) (*PortDescPropBsnSffJson, error) {
35416 _portdescpropbsnsffjson := &PortDescPropBsnSffJson{PortDescPropBsn: parent}
35417 _portdescpropbsnsffjson.DataJson = decoder.Read(int(decoder.Length()))
35418 return _portdescpropbsnsffjson, nil
35419}
35420
35421func NewPortDescPropBsnSffJson() *PortDescPropBsnSffJson {
35422 obj := &PortDescPropBsnSffJson{
35423 PortDescPropBsn: NewPortDescPropBsn(6),
35424 }
35425 return obj
35426}
35427
35428type PortDescPropBsnSpeedCapabilities struct {
35429 *PortDescPropBsn
35430 Current uint64
35431 Available uint64
35432 Supported uint64
35433}
35434
35435type IPortDescPropBsnSpeedCapabilities interface {
35436 IPortDescPropBsn
35437 GetCurrent() uint64
35438 GetAvailable() uint64
35439 GetSupported() uint64
35440}
35441
35442func (self *PortDescPropBsnSpeedCapabilities) GetCurrent() uint64 {
35443 return self.Current
35444}
35445
35446func (self *PortDescPropBsnSpeedCapabilities) SetCurrent(v uint64) {
35447 self.Current = v
35448}
35449
35450func (self *PortDescPropBsnSpeedCapabilities) GetAvailable() uint64 {
35451 return self.Available
35452}
35453
35454func (self *PortDescPropBsnSpeedCapabilities) SetAvailable(v uint64) {
35455 self.Available = v
35456}
35457
35458func (self *PortDescPropBsnSpeedCapabilities) GetSupported() uint64 {
35459 return self.Supported
35460}
35461
35462func (self *PortDescPropBsnSpeedCapabilities) SetSupported(v uint64) {
35463 self.Supported = v
35464}
35465
35466func (self *PortDescPropBsnSpeedCapabilities) Serialize(encoder *goloxi.Encoder) error {
35467 startIndex := len(encoder.Bytes())
35468 if err := self.PortDescPropBsn.Serialize(encoder); err != nil {
35469 return err
35470 }
35471
35472 encoder.PutUint64(uint64(self.Current))
35473 encoder.PutUint64(uint64(self.Available))
35474 encoder.PutUint64(uint64(self.Supported))
35475 length := len(encoder.Bytes()) - startIndex
35476
35477 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
35478
35479 return nil
35480}
35481
35482func DecodePortDescPropBsnSpeedCapabilities(parent *PortDescPropBsn, decoder *goloxi.Decoder) (*PortDescPropBsnSpeedCapabilities, error) {
35483 _portdescpropbsnspeedcapabilities := &PortDescPropBsnSpeedCapabilities{PortDescPropBsn: parent}
35484 if decoder.Length() < 24 {
35485 return nil, fmt.Errorf("PortDescPropBsnSpeedCapabilities packet too short: %d < 24", decoder.Length())
35486 }
35487 _portdescpropbsnspeedcapabilities.Current = uint64(decoder.ReadUint64())
35488 _portdescpropbsnspeedcapabilities.Available = uint64(decoder.ReadUint64())
35489 _portdescpropbsnspeedcapabilities.Supported = uint64(decoder.ReadUint64())
35490 return _portdescpropbsnspeedcapabilities, nil
35491}
35492
35493func NewPortDescPropBsnSpeedCapabilities() *PortDescPropBsnSpeedCapabilities {
35494 obj := &PortDescPropBsnSpeedCapabilities{
35495 PortDescPropBsn: NewPortDescPropBsn(4),
35496 }
35497 return obj
35498}
35499
35500type PortDescPropBsnUplink struct {
35501 *PortDescPropBsn
35502}
35503
35504type IPortDescPropBsnUplink interface {
35505 IPortDescPropBsn
35506}
35507
35508func (self *PortDescPropBsnUplink) Serialize(encoder *goloxi.Encoder) error {
35509 startIndex := len(encoder.Bytes())
35510 if err := self.PortDescPropBsn.Serialize(encoder); err != nil {
35511 return err
35512 }
35513 length := len(encoder.Bytes()) - startIndex
35514
35515 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
35516
35517 return nil
35518}
35519
35520func DecodePortDescPropBsnUplink(parent *PortDescPropBsn, decoder *goloxi.Decoder) (*PortDescPropBsnUplink, error) {
35521 _portdescpropbsnuplink := &PortDescPropBsnUplink{PortDescPropBsn: parent}
35522 return _portdescpropbsnuplink, nil
35523}
35524
35525func NewPortDescPropBsnUplink() *PortDescPropBsnUplink {
35526 obj := &PortDescPropBsnUplink{
35527 PortDescPropBsn: NewPortDescPropBsn(0),
35528 }
35529 return obj
35530}
35531
35532type PortDescPropEgress struct {
35533 Type uint16
35534 Length uint16
35535 OxmIds []byte
35536}
35537
35538type IPortDescPropEgress interface {
35539 goloxi.Serializable
35540 GetType() uint16
35541 GetLength() uint16
35542 GetOxmIds() []byte
35543}
35544
35545func (self *PortDescPropEgress) GetType() uint16 {
35546 return self.Type
35547}
35548
35549func (self *PortDescPropEgress) SetType(v uint16) {
35550 self.Type = v
35551}
35552
35553func (self *PortDescPropEgress) GetLength() uint16 {
35554 return self.Length
35555}
35556
35557func (self *PortDescPropEgress) SetLength(v uint16) {
35558 self.Length = v
35559}
35560
35561func (self *PortDescPropEgress) GetOxmIds() []byte {
35562 return self.OxmIds
35563}
35564
35565func (self *PortDescPropEgress) SetOxmIds(v []byte) {
35566 self.OxmIds = v
35567}
35568
35569func (self *PortDescPropEgress) Serialize(encoder *goloxi.Encoder) error {
35570 startIndex := len(encoder.Bytes())
35571
35572 encoder.PutUint16(uint16(self.Type))
35573 encoder.PutUint16(uint16(self.Length))
35574 encoder.Write(self.OxmIds)
35575 length := len(encoder.Bytes()) - startIndex
35576
35577 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
35578
35579 return nil
35580}
35581
35582func DecodePortDescPropEgress(decoder *goloxi.Decoder) (*PortDescPropEgress, error) {
35583 _portdescpropegress := &PortDescPropEgress{}
35584 if decoder.Length() < 4 {
35585 return nil, fmt.Errorf("PortDescPropEgress packet too short: %d < 4", decoder.Length())
35586 }
35587 _portdescpropegress.Type = uint16(decoder.ReadUint16())
35588 _portdescpropegress.Length = uint16(decoder.ReadUint16())
35589 oldDecoder := decoder
35590 defer func() { decoder = oldDecoder }()
35591 decoder = decoder.SliceDecoder(int(_portdescpropegress.Length), 2+2)
35592 _portdescpropegress.OxmIds = decoder.Read(int(decoder.Length()))
35593 return _portdescpropegress, nil
35594}
35595
35596func NewPortDescPropEgress() *PortDescPropEgress {
35597 obj := &PortDescPropEgress{}
35598 return obj
35599}
35600
35601type PortDescPropEthernet struct {
35602 *PortDescProp
35603 Curr uint32
35604 Advertised uint32
35605 Supported uint32
35606 Peer uint32
35607 CurrSpeed uint32
35608 MaxSpeed uint32
35609}
35610
35611type IPortDescPropEthernet interface {
35612 IPortDescProp
35613 GetCurr() uint32
35614 GetAdvertised() uint32
35615 GetSupported() uint32
35616 GetPeer() uint32
35617 GetCurrSpeed() uint32
35618 GetMaxSpeed() uint32
35619}
35620
35621func (self *PortDescPropEthernet) GetCurr() uint32 {
35622 return self.Curr
35623}
35624
35625func (self *PortDescPropEthernet) SetCurr(v uint32) {
35626 self.Curr = v
35627}
35628
35629func (self *PortDescPropEthernet) GetAdvertised() uint32 {
35630 return self.Advertised
35631}
35632
35633func (self *PortDescPropEthernet) SetAdvertised(v uint32) {
35634 self.Advertised = v
35635}
35636
35637func (self *PortDescPropEthernet) GetSupported() uint32 {
35638 return self.Supported
35639}
35640
35641func (self *PortDescPropEthernet) SetSupported(v uint32) {
35642 self.Supported = v
35643}
35644
35645func (self *PortDescPropEthernet) GetPeer() uint32 {
35646 return self.Peer
35647}
35648
35649func (self *PortDescPropEthernet) SetPeer(v uint32) {
35650 self.Peer = v
35651}
35652
35653func (self *PortDescPropEthernet) GetCurrSpeed() uint32 {
35654 return self.CurrSpeed
35655}
35656
35657func (self *PortDescPropEthernet) SetCurrSpeed(v uint32) {
35658 self.CurrSpeed = v
35659}
35660
35661func (self *PortDescPropEthernet) GetMaxSpeed() uint32 {
35662 return self.MaxSpeed
35663}
35664
35665func (self *PortDescPropEthernet) SetMaxSpeed(v uint32) {
35666 self.MaxSpeed = v
35667}
35668
35669func (self *PortDescPropEthernet) Serialize(encoder *goloxi.Encoder) error {
35670 startIndex := len(encoder.Bytes())
35671 if err := self.PortDescProp.Serialize(encoder); err != nil {
35672 return err
35673 }
35674
35675 encoder.Write(bytes.Repeat([]byte{0}, 4))
35676 encoder.PutUint32(uint32(self.Curr))
35677 encoder.PutUint32(uint32(self.Advertised))
35678 encoder.PutUint32(uint32(self.Supported))
35679 encoder.PutUint32(uint32(self.Peer))
35680 encoder.PutUint32(uint32(self.CurrSpeed))
35681 encoder.PutUint32(uint32(self.MaxSpeed))
35682 length := len(encoder.Bytes()) - startIndex
35683
35684 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
35685
35686 return nil
35687}
35688
35689func DecodePortDescPropEthernet(parent *PortDescProp, decoder *goloxi.Decoder) (*PortDescPropEthernet, error) {
35690 _portdescpropethernet := &PortDescPropEthernet{PortDescProp: parent}
35691 if decoder.Length() < 28 {
35692 return nil, fmt.Errorf("PortDescPropEthernet packet too short: %d < 28", decoder.Length())
35693 }
35694 decoder.Skip(4)
35695 _portdescpropethernet.Curr = uint32(decoder.ReadUint32())
35696 _portdescpropethernet.Advertised = uint32(decoder.ReadUint32())
35697 _portdescpropethernet.Supported = uint32(decoder.ReadUint32())
35698 _portdescpropethernet.Peer = uint32(decoder.ReadUint32())
35699 _portdescpropethernet.CurrSpeed = uint32(decoder.ReadUint32())
35700 _portdescpropethernet.MaxSpeed = uint32(decoder.ReadUint32())
35701 return _portdescpropethernet, nil
35702}
35703
35704func NewPortDescPropEthernet() *PortDescPropEthernet {
35705 obj := &PortDescPropEthernet{
35706 PortDescProp: NewPortDescProp(0),
35707 }
35708 return obj
35709}
35710
35711type PortDescPropIngress struct {
35712 Type uint16
35713 Length uint16
35714 OxmIds []byte
35715}
35716
35717type IPortDescPropIngress interface {
35718 goloxi.Serializable
35719 GetType() uint16
35720 GetLength() uint16
35721 GetOxmIds() []byte
35722}
35723
35724func (self *PortDescPropIngress) GetType() uint16 {
35725 return self.Type
35726}
35727
35728func (self *PortDescPropIngress) SetType(v uint16) {
35729 self.Type = v
35730}
35731
35732func (self *PortDescPropIngress) GetLength() uint16 {
35733 return self.Length
35734}
35735
35736func (self *PortDescPropIngress) SetLength(v uint16) {
35737 self.Length = v
35738}
35739
35740func (self *PortDescPropIngress) GetOxmIds() []byte {
35741 return self.OxmIds
35742}
35743
35744func (self *PortDescPropIngress) SetOxmIds(v []byte) {
35745 self.OxmIds = v
35746}
35747
35748func (self *PortDescPropIngress) Serialize(encoder *goloxi.Encoder) error {
35749 startIndex := len(encoder.Bytes())
35750
35751 encoder.PutUint16(uint16(self.Type))
35752 encoder.PutUint16(uint16(self.Length))
35753 encoder.Write(self.OxmIds)
35754 length := len(encoder.Bytes()) - startIndex
35755
35756 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
35757
35758 return nil
35759}
35760
35761func DecodePortDescPropIngress(decoder *goloxi.Decoder) (*PortDescPropIngress, error) {
35762 _portdescpropingress := &PortDescPropIngress{}
35763 if decoder.Length() < 4 {
35764 return nil, fmt.Errorf("PortDescPropIngress packet too short: %d < 4", decoder.Length())
35765 }
35766 _portdescpropingress.Type = uint16(decoder.ReadUint16())
35767 _portdescpropingress.Length = uint16(decoder.ReadUint16())
35768 oldDecoder := decoder
35769 defer func() { decoder = oldDecoder }()
35770 decoder = decoder.SliceDecoder(int(_portdescpropingress.Length), 2+2)
35771 _portdescpropingress.OxmIds = decoder.Read(int(decoder.Length()))
35772 return _portdescpropingress, nil
35773}
35774
35775func NewPortDescPropIngress() *PortDescPropIngress {
35776 obj := &PortDescPropIngress{}
35777 return obj
35778}
35779
35780type PortDescPropOptical struct {
35781 *PortDescProp
35782 Supported uint32
35783 TxMinFreqLmda uint32
35784 TxMaxFreqLmda uint32
35785 TxGridFreqLmda uint32
35786 RxMinFreqLmda uint32
35787 RxMaxFreqLmda uint32
35788 RxGridFreqLmda uint32
35789 TxPwrMin uint32
35790 TxPwrMax uint32
35791}
35792
35793type IPortDescPropOptical interface {
35794 IPortDescProp
35795 GetSupported() uint32
35796 GetTxMinFreqLmda() uint32
35797 GetTxMaxFreqLmda() uint32
35798 GetTxGridFreqLmda() uint32
35799 GetRxMinFreqLmda() uint32
35800 GetRxMaxFreqLmda() uint32
35801 GetRxGridFreqLmda() uint32
35802 GetTxPwrMin() uint32
35803 GetTxPwrMax() uint32
35804}
35805
35806func (self *PortDescPropOptical) GetSupported() uint32 {
35807 return self.Supported
35808}
35809
35810func (self *PortDescPropOptical) SetSupported(v uint32) {
35811 self.Supported = v
35812}
35813
35814func (self *PortDescPropOptical) GetTxMinFreqLmda() uint32 {
35815 return self.TxMinFreqLmda
35816}
35817
35818func (self *PortDescPropOptical) SetTxMinFreqLmda(v uint32) {
35819 self.TxMinFreqLmda = v
35820}
35821
35822func (self *PortDescPropOptical) GetTxMaxFreqLmda() uint32 {
35823 return self.TxMaxFreqLmda
35824}
35825
35826func (self *PortDescPropOptical) SetTxMaxFreqLmda(v uint32) {
35827 self.TxMaxFreqLmda = v
35828}
35829
35830func (self *PortDescPropOptical) GetTxGridFreqLmda() uint32 {
35831 return self.TxGridFreqLmda
35832}
35833
35834func (self *PortDescPropOptical) SetTxGridFreqLmda(v uint32) {
35835 self.TxGridFreqLmda = v
35836}
35837
35838func (self *PortDescPropOptical) GetRxMinFreqLmda() uint32 {
35839 return self.RxMinFreqLmda
35840}
35841
35842func (self *PortDescPropOptical) SetRxMinFreqLmda(v uint32) {
35843 self.RxMinFreqLmda = v
35844}
35845
35846func (self *PortDescPropOptical) GetRxMaxFreqLmda() uint32 {
35847 return self.RxMaxFreqLmda
35848}
35849
35850func (self *PortDescPropOptical) SetRxMaxFreqLmda(v uint32) {
35851 self.RxMaxFreqLmda = v
35852}
35853
35854func (self *PortDescPropOptical) GetRxGridFreqLmda() uint32 {
35855 return self.RxGridFreqLmda
35856}
35857
35858func (self *PortDescPropOptical) SetRxGridFreqLmda(v uint32) {
35859 self.RxGridFreqLmda = v
35860}
35861
35862func (self *PortDescPropOptical) GetTxPwrMin() uint32 {
35863 return self.TxPwrMin
35864}
35865
35866func (self *PortDescPropOptical) SetTxPwrMin(v uint32) {
35867 self.TxPwrMin = v
35868}
35869
35870func (self *PortDescPropOptical) GetTxPwrMax() uint32 {
35871 return self.TxPwrMax
35872}
35873
35874func (self *PortDescPropOptical) SetTxPwrMax(v uint32) {
35875 self.TxPwrMax = v
35876}
35877
35878func (self *PortDescPropOptical) Serialize(encoder *goloxi.Encoder) error {
35879 startIndex := len(encoder.Bytes())
35880 if err := self.PortDescProp.Serialize(encoder); err != nil {
35881 return err
35882 }
35883
35884 encoder.Write(bytes.Repeat([]byte{0}, 4))
35885 encoder.PutUint32(uint32(self.Supported))
35886 encoder.PutUint32(uint32(self.TxMinFreqLmda))
35887 encoder.PutUint32(uint32(self.TxMaxFreqLmda))
35888 encoder.PutUint32(uint32(self.TxGridFreqLmda))
35889 encoder.PutUint32(uint32(self.RxMinFreqLmda))
35890 encoder.PutUint32(uint32(self.RxMaxFreqLmda))
35891 encoder.PutUint32(uint32(self.RxGridFreqLmda))
35892 encoder.PutUint32(uint32(self.TxPwrMin))
35893 encoder.PutUint32(uint32(self.TxPwrMax))
35894 length := len(encoder.Bytes()) - startIndex
35895
35896 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
35897
35898 return nil
35899}
35900
35901func DecodePortDescPropOptical(parent *PortDescProp, decoder *goloxi.Decoder) (*PortDescPropOptical, error) {
35902 _portdescpropoptical := &PortDescPropOptical{PortDescProp: parent}
35903 if decoder.Length() < 40 {
35904 return nil, fmt.Errorf("PortDescPropOptical packet too short: %d < 40", decoder.Length())
35905 }
35906 decoder.Skip(4)
35907 _portdescpropoptical.Supported = uint32(decoder.ReadUint32())
35908 _portdescpropoptical.TxMinFreqLmda = uint32(decoder.ReadUint32())
35909 _portdescpropoptical.TxMaxFreqLmda = uint32(decoder.ReadUint32())
35910 _portdescpropoptical.TxGridFreqLmda = uint32(decoder.ReadUint32())
35911 _portdescpropoptical.RxMinFreqLmda = uint32(decoder.ReadUint32())
35912 _portdescpropoptical.RxMaxFreqLmda = uint32(decoder.ReadUint32())
35913 _portdescpropoptical.RxGridFreqLmda = uint32(decoder.ReadUint32())
35914 _portdescpropoptical.TxPwrMin = uint32(decoder.ReadUint32())
35915 _portdescpropoptical.TxPwrMax = uint32(decoder.ReadUint32())
35916 return _portdescpropoptical, nil
35917}
35918
35919func NewPortDescPropOptical() *PortDescPropOptical {
35920 obj := &PortDescPropOptical{
35921 PortDescProp: NewPortDescProp(1),
35922 }
35923 return obj
35924}
35925
35926type PortModProp struct {
35927 Type uint16
35928 Length uint16
35929}
35930
35931type IPortModProp interface {
35932 goloxi.Serializable
35933 GetType() uint16
35934 GetLength() uint16
35935}
35936
35937func (self *PortModProp) GetType() uint16 {
35938 return self.Type
35939}
35940
35941func (self *PortModProp) SetType(v uint16) {
35942 self.Type = v
35943}
35944
35945func (self *PortModProp) GetLength() uint16 {
35946 return self.Length
35947}
35948
35949func (self *PortModProp) SetLength(v uint16) {
35950 self.Length = v
35951}
35952
35953func (self *PortModProp) Serialize(encoder *goloxi.Encoder) error {
35954
35955 encoder.PutUint16(uint16(self.Type))
35956 encoder.PutUint16(uint16(self.Length))
35957
35958 return nil
35959}
35960
35961func DecodePortModProp(decoder *goloxi.Decoder) (IPortModProp, error) {
35962 _portmodprop := &PortModProp{}
35963 if decoder.Length() < 4 {
35964 return nil, fmt.Errorf("PortModProp packet too short: %d < 4", decoder.Length())
35965 }
35966 _portmodprop.Type = uint16(decoder.ReadUint16())
35967 _portmodprop.Length = uint16(decoder.ReadUint16())
35968 oldDecoder := decoder
35969 defer func() { decoder = oldDecoder }()
35970 decoder = decoder.SliceDecoder(int(_portmodprop.Length), 2+2)
35971
35972 switch _portmodprop.Type {
35973 case 0:
35974 return DecodePortModPropEthernet(_portmodprop, decoder)
35975 case 1:
35976 return DecodePortModPropOptical(_portmodprop, decoder)
35977 case 65535:
35978 return DecodePortModPropExperimenter(_portmodprop, decoder)
35979 default:
35980 return nil, fmt.Errorf("Invalid type '%d' for 'PortModProp'", _portmodprop.Type)
35981 }
35982}
35983
35984func NewPortModProp(_type uint16) *PortModProp {
35985 obj := &PortModProp{}
35986 obj.Type = _type
35987 return obj
35988}
35989
35990type PortModPropEthernet struct {
35991 *PortModProp
35992 Advertise PortFeatures
35993}
35994
35995type IPortModPropEthernet interface {
35996 IPortModProp
35997 GetAdvertise() PortFeatures
35998}
35999
36000func (self *PortModPropEthernet) GetAdvertise() PortFeatures {
36001 return self.Advertise
36002}
36003
36004func (self *PortModPropEthernet) SetAdvertise(v PortFeatures) {
36005 self.Advertise = v
36006}
36007
36008func (self *PortModPropEthernet) Serialize(encoder *goloxi.Encoder) error {
36009 startIndex := len(encoder.Bytes())
36010 if err := self.PortModProp.Serialize(encoder); err != nil {
36011 return err
36012 }
36013
36014 encoder.PutUint32(uint32(self.Advertise))
36015 length := len(encoder.Bytes()) - startIndex
36016
36017 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
36018
36019 return nil
36020}
36021
36022func DecodePortModPropEthernet(parent *PortModProp, decoder *goloxi.Decoder) (*PortModPropEthernet, error) {
36023 _portmodpropethernet := &PortModPropEthernet{PortModProp: parent}
36024 if decoder.Length() < 4 {
36025 return nil, fmt.Errorf("PortModPropEthernet packet too short: %d < 4", decoder.Length())
36026 }
36027 _portmodpropethernet.Advertise = PortFeatures(decoder.ReadUint32())
36028 return _portmodpropethernet, nil
36029}
36030
36031func NewPortModPropEthernet() *PortModPropEthernet {
36032 obj := &PortModPropEthernet{
36033 PortModProp: NewPortModProp(0),
36034 }
36035 return obj
36036}
36037
36038type PortModPropExperimenter struct {
36039 *PortModProp
36040 Experimenter uint32
36041 ExpType uint32
36042}
36043
36044type IPortModPropExperimenter interface {
36045 IPortModProp
36046 GetExperimenter() uint32
36047 GetExpType() uint32
36048}
36049
36050func (self *PortModPropExperimenter) GetExperimenter() uint32 {
36051 return self.Experimenter
36052}
36053
36054func (self *PortModPropExperimenter) SetExperimenter(v uint32) {
36055 self.Experimenter = v
36056}
36057
36058func (self *PortModPropExperimenter) GetExpType() uint32 {
36059 return self.ExpType
36060}
36061
36062func (self *PortModPropExperimenter) SetExpType(v uint32) {
36063 self.ExpType = v
36064}
36065
36066func (self *PortModPropExperimenter) Serialize(encoder *goloxi.Encoder) error {
36067 if err := self.PortModProp.Serialize(encoder); err != nil {
36068 return err
36069 }
36070
36071 encoder.PutUint32(uint32(self.Experimenter))
36072 encoder.PutUint32(uint32(self.ExpType))
36073
36074 return nil
36075}
36076
36077func DecodePortModPropExperimenter(parent *PortModProp, decoder *goloxi.Decoder) (IPortModPropExperimenter, error) {
36078 _portmodpropexperimenter := &PortModPropExperimenter{PortModProp: parent}
36079 if decoder.Length() < 8 {
36080 return nil, fmt.Errorf("PortModPropExperimenter packet too short: %d < 8", decoder.Length())
36081 }
36082 _portmodpropexperimenter.Experimenter = uint32(decoder.ReadUint32())
36083 _portmodpropexperimenter.ExpType = uint32(decoder.ReadUint32())
36084 return _portmodpropexperimenter, nil
36085}
36086
36087func NewPortModPropExperimenter(_experimenter uint32) *PortModPropExperimenter {
36088 obj := &PortModPropExperimenter{
36089 PortModProp: NewPortModProp(65535),
36090 }
36091 obj.Experimenter = _experimenter
36092 return obj
36093}
36094
36095type PortModPropOptical struct {
36096 *PortModProp
36097 Configure uint32
36098 FreqLdma uint32
36099 FlOffset uint32
36100 GridSpan uint32
36101 TxPwr uint32
36102}
36103
36104type IPortModPropOptical interface {
36105 IPortModProp
36106 GetConfigure() uint32
36107 GetFreqLdma() uint32
36108 GetFlOffset() uint32
36109 GetGridSpan() uint32
36110 GetTxPwr() uint32
36111}
36112
36113func (self *PortModPropOptical) GetConfigure() uint32 {
36114 return self.Configure
36115}
36116
36117func (self *PortModPropOptical) SetConfigure(v uint32) {
36118 self.Configure = v
36119}
36120
36121func (self *PortModPropOptical) GetFreqLdma() uint32 {
36122 return self.FreqLdma
36123}
36124
36125func (self *PortModPropOptical) SetFreqLdma(v uint32) {
36126 self.FreqLdma = v
36127}
36128
36129func (self *PortModPropOptical) GetFlOffset() uint32 {
36130 return self.FlOffset
36131}
36132
36133func (self *PortModPropOptical) SetFlOffset(v uint32) {
36134 self.FlOffset = v
36135}
36136
36137func (self *PortModPropOptical) GetGridSpan() uint32 {
36138 return self.GridSpan
36139}
36140
36141func (self *PortModPropOptical) SetGridSpan(v uint32) {
36142 self.GridSpan = v
36143}
36144
36145func (self *PortModPropOptical) GetTxPwr() uint32 {
36146 return self.TxPwr
36147}
36148
36149func (self *PortModPropOptical) SetTxPwr(v uint32) {
36150 self.TxPwr = v
36151}
36152
36153func (self *PortModPropOptical) Serialize(encoder *goloxi.Encoder) error {
36154 startIndex := len(encoder.Bytes())
36155 if err := self.PortModProp.Serialize(encoder); err != nil {
36156 return err
36157 }
36158
36159 encoder.PutUint32(uint32(self.Configure))
36160 encoder.PutUint32(uint32(self.FreqLdma))
36161 encoder.PutUint32(uint32(self.FlOffset))
36162 encoder.PutUint32(uint32(self.GridSpan))
36163 encoder.PutUint32(uint32(self.TxPwr))
36164 length := len(encoder.Bytes()) - startIndex
36165
36166 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
36167
36168 return nil
36169}
36170
36171func DecodePortModPropOptical(parent *PortModProp, decoder *goloxi.Decoder) (*PortModPropOptical, error) {
36172 _portmodpropoptical := &PortModPropOptical{PortModProp: parent}
36173 if decoder.Length() < 20 {
36174 return nil, fmt.Errorf("PortModPropOptical packet too short: %d < 20", decoder.Length())
36175 }
36176 _portmodpropoptical.Configure = uint32(decoder.ReadUint32())
36177 _portmodpropoptical.FreqLdma = uint32(decoder.ReadUint32())
36178 _portmodpropoptical.FlOffset = uint32(decoder.ReadUint32())
36179 _portmodpropoptical.GridSpan = uint32(decoder.ReadUint32())
36180 _portmodpropoptical.TxPwr = uint32(decoder.ReadUint32())
36181 return _portmodpropoptical, nil
36182}
36183
36184func NewPortModPropOptical() *PortModPropOptical {
36185 obj := &PortModPropOptical{
36186 PortModProp: NewPortModProp(1),
36187 }
36188 return obj
36189}
36190
36191type PortStatsEntry struct {
36192 Length uint16
36193 PortNo Port
36194 DurationSec uint32
36195 DurationNsec uint32
36196 RxPackets uint64
36197 TxPackets uint64
36198 RxBytes uint64
36199 TxBytes uint64
36200 RxDropped uint64
36201 TxDropped uint64
36202 RxErrors uint64
36203 TxErrors uint64
36204 Properties []IPortStatsProp
36205}
36206
36207type IPortStatsEntry interface {
36208 goloxi.Serializable
36209 GetLength() uint16
36210 GetPortNo() Port
36211 GetDurationSec() uint32
36212 GetDurationNsec() uint32
36213 GetRxPackets() uint64
36214 GetTxPackets() uint64
36215 GetRxBytes() uint64
36216 GetTxBytes() uint64
36217 GetRxDropped() uint64
36218 GetTxDropped() uint64
36219 GetRxErrors() uint64
36220 GetTxErrors() uint64
36221 GetProperties() []IPortStatsProp
36222}
36223
36224func (self *PortStatsEntry) GetLength() uint16 {
36225 return self.Length
36226}
36227
36228func (self *PortStatsEntry) SetLength(v uint16) {
36229 self.Length = v
36230}
36231
36232func (self *PortStatsEntry) GetPortNo() Port {
36233 return self.PortNo
36234}
36235
36236func (self *PortStatsEntry) SetPortNo(v Port) {
36237 self.PortNo = v
36238}
36239
36240func (self *PortStatsEntry) GetDurationSec() uint32 {
36241 return self.DurationSec
36242}
36243
36244func (self *PortStatsEntry) SetDurationSec(v uint32) {
36245 self.DurationSec = v
36246}
36247
36248func (self *PortStatsEntry) GetDurationNsec() uint32 {
36249 return self.DurationNsec
36250}
36251
36252func (self *PortStatsEntry) SetDurationNsec(v uint32) {
36253 self.DurationNsec = v
36254}
36255
36256func (self *PortStatsEntry) GetRxPackets() uint64 {
36257 return self.RxPackets
36258}
36259
36260func (self *PortStatsEntry) SetRxPackets(v uint64) {
36261 self.RxPackets = v
36262}
36263
36264func (self *PortStatsEntry) GetTxPackets() uint64 {
36265 return self.TxPackets
36266}
36267
36268func (self *PortStatsEntry) SetTxPackets(v uint64) {
36269 self.TxPackets = v
36270}
36271
36272func (self *PortStatsEntry) GetRxBytes() uint64 {
36273 return self.RxBytes
36274}
36275
36276func (self *PortStatsEntry) SetRxBytes(v uint64) {
36277 self.RxBytes = v
36278}
36279
36280func (self *PortStatsEntry) GetTxBytes() uint64 {
36281 return self.TxBytes
36282}
36283
36284func (self *PortStatsEntry) SetTxBytes(v uint64) {
36285 self.TxBytes = v
36286}
36287
36288func (self *PortStatsEntry) GetRxDropped() uint64 {
36289 return self.RxDropped
36290}
36291
36292func (self *PortStatsEntry) SetRxDropped(v uint64) {
36293 self.RxDropped = v
36294}
36295
36296func (self *PortStatsEntry) GetTxDropped() uint64 {
36297 return self.TxDropped
36298}
36299
36300func (self *PortStatsEntry) SetTxDropped(v uint64) {
36301 self.TxDropped = v
36302}
36303
36304func (self *PortStatsEntry) GetRxErrors() uint64 {
36305 return self.RxErrors
36306}
36307
36308func (self *PortStatsEntry) SetRxErrors(v uint64) {
36309 self.RxErrors = v
36310}
36311
36312func (self *PortStatsEntry) GetTxErrors() uint64 {
36313 return self.TxErrors
36314}
36315
36316func (self *PortStatsEntry) SetTxErrors(v uint64) {
36317 self.TxErrors = v
36318}
36319
36320func (self *PortStatsEntry) GetProperties() []IPortStatsProp {
36321 return self.Properties
36322}
36323
36324func (self *PortStatsEntry) SetProperties(v []IPortStatsProp) {
36325 self.Properties = v
36326}
36327
36328func (self *PortStatsEntry) Serialize(encoder *goloxi.Encoder) error {
36329 startIndex := len(encoder.Bytes())
36330
36331 encoder.PutUint16(uint16(self.Length))
36332 encoder.Write(bytes.Repeat([]byte{0}, 2))
36333 self.PortNo.Serialize(encoder)
36334 encoder.PutUint32(uint32(self.DurationSec))
36335 encoder.PutUint32(uint32(self.DurationNsec))
36336 encoder.PutUint64(uint64(self.RxPackets))
36337 encoder.PutUint64(uint64(self.TxPackets))
36338 encoder.PutUint64(uint64(self.RxBytes))
36339 encoder.PutUint64(uint64(self.TxBytes))
36340 encoder.PutUint64(uint64(self.RxDropped))
36341 encoder.PutUint64(uint64(self.TxDropped))
36342 encoder.PutUint64(uint64(self.RxErrors))
36343 encoder.PutUint64(uint64(self.TxErrors))
36344 for _, obj := range self.Properties {
36345 if err := obj.Serialize(encoder); err != nil {
36346 return err
36347 }
36348 }
36349 length := len(encoder.Bytes()) - startIndex
36350
36351 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
36352
36353 return nil
36354}
36355
36356func DecodePortStatsEntry(decoder *goloxi.Decoder) (*PortStatsEntry, error) {
36357 _portstatsentry := &PortStatsEntry{}
36358 if decoder.Length() < 80 {
36359 return nil, fmt.Errorf("PortStatsEntry packet too short: %d < 80", decoder.Length())
36360 }
36361 _portstatsentry.Length = uint16(decoder.ReadUint16())
36362 oldDecoder := decoder
36363 defer func() { decoder = oldDecoder }()
36364 decoder = decoder.SliceDecoder(int(_portstatsentry.Length), 2+0)
36365 decoder.Skip(2)
36366 _portstatsentry.PortNo.Decode(decoder)
36367 _portstatsentry.DurationSec = uint32(decoder.ReadUint32())
36368 _portstatsentry.DurationNsec = uint32(decoder.ReadUint32())
36369 _portstatsentry.RxPackets = uint64(decoder.ReadUint64())
36370 _portstatsentry.TxPackets = uint64(decoder.ReadUint64())
36371 _portstatsentry.RxBytes = uint64(decoder.ReadUint64())
36372 _portstatsentry.TxBytes = uint64(decoder.ReadUint64())
36373 _portstatsentry.RxDropped = uint64(decoder.ReadUint64())
36374 _portstatsentry.TxDropped = uint64(decoder.ReadUint64())
36375 _portstatsentry.RxErrors = uint64(decoder.ReadUint64())
36376 _portstatsentry.TxErrors = uint64(decoder.ReadUint64())
36377
36378 for decoder.Length() >= 4 {
36379 item, err := DecodePortStatsProp(decoder)
36380 if err != nil {
36381 return nil, err
36382 }
36383 if item != nil {
36384 _portstatsentry.Properties = append(_portstatsentry.Properties, item)
36385 }
36386 }
36387 return _portstatsentry, nil
36388}
36389
36390func NewPortStatsEntry() *PortStatsEntry {
36391 obj := &PortStatsEntry{}
36392 return obj
36393}
36394
36395type PortStatsProp struct {
36396 Type uint16
36397 Length uint16
36398}
36399
36400type IPortStatsProp interface {
36401 goloxi.Serializable
36402 GetType() uint16
36403 GetLength() uint16
36404}
36405
36406func (self *PortStatsProp) GetType() uint16 {
36407 return self.Type
36408}
36409
36410func (self *PortStatsProp) SetType(v uint16) {
36411 self.Type = v
36412}
36413
36414func (self *PortStatsProp) GetLength() uint16 {
36415 return self.Length
36416}
36417
36418func (self *PortStatsProp) SetLength(v uint16) {
36419 self.Length = v
36420}
36421
36422func (self *PortStatsProp) Serialize(encoder *goloxi.Encoder) error {
36423
36424 encoder.PutUint16(uint16(self.Type))
36425 encoder.PutUint16(uint16(self.Length))
36426
36427 return nil
36428}
36429
36430func DecodePortStatsProp(decoder *goloxi.Decoder) (IPortStatsProp, error) {
36431 _portstatsprop := &PortStatsProp{}
36432 if decoder.Length() < 4 {
36433 return nil, fmt.Errorf("PortStatsProp packet too short: %d < 4", decoder.Length())
36434 }
36435 _portstatsprop.Type = uint16(decoder.ReadUint16())
36436 _portstatsprop.Length = uint16(decoder.ReadUint16())
36437 oldDecoder := decoder
36438 defer func() { decoder = oldDecoder }()
36439 decoder = decoder.SliceDecoder(int(_portstatsprop.Length), 2+2)
36440
36441 switch _portstatsprop.Type {
36442 case 0:
36443 return DecodePortStatsPropEthernet(_portstatsprop, decoder)
36444 case 1:
36445 return DecodePortStatsPropOptical(_portstatsprop, decoder)
36446 case 65535:
36447 return DecodePortStatsPropExperimenter(_portstatsprop, decoder)
36448 default:
36449 return nil, fmt.Errorf("Invalid type '%d' for 'PortStatsProp'", _portstatsprop.Type)
36450 }
36451}
36452
36453func NewPortStatsProp(_type uint16) *PortStatsProp {
36454 obj := &PortStatsProp{}
36455 obj.Type = _type
36456 return obj
36457}
36458
36459type PortStatsPropEthernet struct {
36460 *PortStatsProp
36461 RxFrameErr uint64
36462 RxOverErr uint64
36463 RxCrcErr uint64
36464 Collisions uint64
36465}
36466
36467type IPortStatsPropEthernet interface {
36468 IPortStatsProp
36469 GetRxFrameErr() uint64
36470 GetRxOverErr() uint64
36471 GetRxCrcErr() uint64
36472 GetCollisions() uint64
36473}
36474
36475func (self *PortStatsPropEthernet) GetRxFrameErr() uint64 {
36476 return self.RxFrameErr
36477}
36478
36479func (self *PortStatsPropEthernet) SetRxFrameErr(v uint64) {
36480 self.RxFrameErr = v
36481}
36482
36483func (self *PortStatsPropEthernet) GetRxOverErr() uint64 {
36484 return self.RxOverErr
36485}
36486
36487func (self *PortStatsPropEthernet) SetRxOverErr(v uint64) {
36488 self.RxOverErr = v
36489}
36490
36491func (self *PortStatsPropEthernet) GetRxCrcErr() uint64 {
36492 return self.RxCrcErr
36493}
36494
36495func (self *PortStatsPropEthernet) SetRxCrcErr(v uint64) {
36496 self.RxCrcErr = v
36497}
36498
36499func (self *PortStatsPropEthernet) GetCollisions() uint64 {
36500 return self.Collisions
36501}
36502
36503func (self *PortStatsPropEthernet) SetCollisions(v uint64) {
36504 self.Collisions = v
36505}
36506
36507func (self *PortStatsPropEthernet) Serialize(encoder *goloxi.Encoder) error {
36508 startIndex := len(encoder.Bytes())
36509 if err := self.PortStatsProp.Serialize(encoder); err != nil {
36510 return err
36511 }
36512
36513 encoder.Write(bytes.Repeat([]byte{0}, 4))
36514 encoder.PutUint64(uint64(self.RxFrameErr))
36515 encoder.PutUint64(uint64(self.RxOverErr))
36516 encoder.PutUint64(uint64(self.RxCrcErr))
36517 encoder.PutUint64(uint64(self.Collisions))
36518 length := len(encoder.Bytes()) - startIndex
36519
36520 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
36521
36522 return nil
36523}
36524
36525func DecodePortStatsPropEthernet(parent *PortStatsProp, decoder *goloxi.Decoder) (*PortStatsPropEthernet, error) {
36526 _portstatspropethernet := &PortStatsPropEthernet{PortStatsProp: parent}
36527 if decoder.Length() < 36 {
36528 return nil, fmt.Errorf("PortStatsPropEthernet packet too short: %d < 36", decoder.Length())
36529 }
36530 decoder.Skip(4)
36531 _portstatspropethernet.RxFrameErr = uint64(decoder.ReadUint64())
36532 _portstatspropethernet.RxOverErr = uint64(decoder.ReadUint64())
36533 _portstatspropethernet.RxCrcErr = uint64(decoder.ReadUint64())
36534 _portstatspropethernet.Collisions = uint64(decoder.ReadUint64())
36535 return _portstatspropethernet, nil
36536}
36537
36538func NewPortStatsPropEthernet() *PortStatsPropEthernet {
36539 obj := &PortStatsPropEthernet{
36540 PortStatsProp: NewPortStatsProp(0),
36541 }
36542 return obj
36543}
36544
36545type PortStatsPropExperimenter struct {
36546 *PortStatsProp
36547 Experimenter uint32
36548 ExpType uint32
36549}
36550
36551type IPortStatsPropExperimenter interface {
36552 IPortStatsProp
36553 GetExperimenter() uint32
36554 GetExpType() uint32
36555}
36556
36557func (self *PortStatsPropExperimenter) GetExperimenter() uint32 {
36558 return self.Experimenter
36559}
36560
36561func (self *PortStatsPropExperimenter) SetExperimenter(v uint32) {
36562 self.Experimenter = v
36563}
36564
36565func (self *PortStatsPropExperimenter) GetExpType() uint32 {
36566 return self.ExpType
36567}
36568
36569func (self *PortStatsPropExperimenter) SetExpType(v uint32) {
36570 self.ExpType = v
36571}
36572
36573func (self *PortStatsPropExperimenter) Serialize(encoder *goloxi.Encoder) error {
36574 if err := self.PortStatsProp.Serialize(encoder); err != nil {
36575 return err
36576 }
36577
36578 encoder.PutUint32(uint32(self.Experimenter))
36579 encoder.PutUint32(uint32(self.ExpType))
36580
36581 return nil
36582}
36583
36584func DecodePortStatsPropExperimenter(parent *PortStatsProp, decoder *goloxi.Decoder) (IPortStatsPropExperimenter, error) {
36585 _portstatspropexperimenter := &PortStatsPropExperimenter{PortStatsProp: parent}
36586 if decoder.Length() < 8 {
36587 return nil, fmt.Errorf("PortStatsPropExperimenter packet too short: %d < 8", decoder.Length())
36588 }
36589 _portstatspropexperimenter.Experimenter = uint32(decoder.ReadUint32())
36590 _portstatspropexperimenter.ExpType = uint32(decoder.ReadUint32())
36591
36592 switch _portstatspropexperimenter.Experimenter {
36593 case 43521:
36594 return DecodePortStatsPropExperimenterIntel(_portstatspropexperimenter, decoder)
36595 default:
36596 return nil, fmt.Errorf("Invalid type '%d' for 'PortStatsPropExperimenter'", _portstatspropexperimenter.Experimenter)
36597 }
36598}
36599
36600func NewPortStatsPropExperimenter(_experimenter uint32) *PortStatsPropExperimenter {
36601 obj := &PortStatsPropExperimenter{
36602 PortStatsProp: NewPortStatsProp(65535),
36603 }
36604 obj.Experimenter = _experimenter
36605 return obj
36606}
36607
36608type PortStatsPropExperimenterIntel struct {
36609 *PortStatsPropExperimenter
36610 Rx1To64Packets uint64
36611 Rx65To127Packets uint64
36612 Rx128To255Packets uint64
36613 Rx256To511Packets uint64
36614 Rx512To1023Packets uint64
36615 Rx1024To1522Packets uint64
36616 Rx1523ToMaxPackets uint64
36617 Tx1To64Packets uint64
36618 Tx65To127Packets uint64
36619 Tx128To255Packets uint64
36620 Tx256To511Packets uint64
36621 Tx512To1023Packets uint64
36622 Tx1024To1522Packets uint64
36623 Tx1523ToMaxPackets uint64
36624 TxMulticastPackets uint64
36625 RxBroadcastPackets uint64
36626 TxBroadcastPackets uint64
36627 RxUndersizedErrors uint64
36628 RxOversizeErrors uint64
36629 RxFragmentedErrors uint64
36630 RxJabberErrors uint64
36631}
36632
36633type IPortStatsPropExperimenterIntel interface {
36634 IPortStatsPropExperimenter
36635 GetRx1To64Packets() uint64
36636 GetRx65To127Packets() uint64
36637 GetRx128To255Packets() uint64
36638 GetRx256To511Packets() uint64
36639 GetRx512To1023Packets() uint64
36640 GetRx1024To1522Packets() uint64
36641 GetRx1523ToMaxPackets() uint64
36642 GetTx1To64Packets() uint64
36643 GetTx65To127Packets() uint64
36644 GetTx128To255Packets() uint64
36645 GetTx256To511Packets() uint64
36646 GetTx512To1023Packets() uint64
36647 GetTx1024To1522Packets() uint64
36648 GetTx1523ToMaxPackets() uint64
36649 GetTxMulticastPackets() uint64
36650 GetRxBroadcastPackets() uint64
36651 GetTxBroadcastPackets() uint64
36652 GetRxUndersizedErrors() uint64
36653 GetRxOversizeErrors() uint64
36654 GetRxFragmentedErrors() uint64
36655 GetRxJabberErrors() uint64
36656}
36657
36658func (self *PortStatsPropExperimenterIntel) GetRx1To64Packets() uint64 {
36659 return self.Rx1To64Packets
36660}
36661
36662func (self *PortStatsPropExperimenterIntel) SetRx1To64Packets(v uint64) {
36663 self.Rx1To64Packets = v
36664}
36665
36666func (self *PortStatsPropExperimenterIntel) GetRx65To127Packets() uint64 {
36667 return self.Rx65To127Packets
36668}
36669
36670func (self *PortStatsPropExperimenterIntel) SetRx65To127Packets(v uint64) {
36671 self.Rx65To127Packets = v
36672}
36673
36674func (self *PortStatsPropExperimenterIntel) GetRx128To255Packets() uint64 {
36675 return self.Rx128To255Packets
36676}
36677
36678func (self *PortStatsPropExperimenterIntel) SetRx128To255Packets(v uint64) {
36679 self.Rx128To255Packets = v
36680}
36681
36682func (self *PortStatsPropExperimenterIntel) GetRx256To511Packets() uint64 {
36683 return self.Rx256To511Packets
36684}
36685
36686func (self *PortStatsPropExperimenterIntel) SetRx256To511Packets(v uint64) {
36687 self.Rx256To511Packets = v
36688}
36689
36690func (self *PortStatsPropExperimenterIntel) GetRx512To1023Packets() uint64 {
36691 return self.Rx512To1023Packets
36692}
36693
36694func (self *PortStatsPropExperimenterIntel) SetRx512To1023Packets(v uint64) {
36695 self.Rx512To1023Packets = v
36696}
36697
36698func (self *PortStatsPropExperimenterIntel) GetRx1024To1522Packets() uint64 {
36699 return self.Rx1024To1522Packets
36700}
36701
36702func (self *PortStatsPropExperimenterIntel) SetRx1024To1522Packets(v uint64) {
36703 self.Rx1024To1522Packets = v
36704}
36705
36706func (self *PortStatsPropExperimenterIntel) GetRx1523ToMaxPackets() uint64 {
36707 return self.Rx1523ToMaxPackets
36708}
36709
36710func (self *PortStatsPropExperimenterIntel) SetRx1523ToMaxPackets(v uint64) {
36711 self.Rx1523ToMaxPackets = v
36712}
36713
36714func (self *PortStatsPropExperimenterIntel) GetTx1To64Packets() uint64 {
36715 return self.Tx1To64Packets
36716}
36717
36718func (self *PortStatsPropExperimenterIntel) SetTx1To64Packets(v uint64) {
36719 self.Tx1To64Packets = v
36720}
36721
36722func (self *PortStatsPropExperimenterIntel) GetTx65To127Packets() uint64 {
36723 return self.Tx65To127Packets
36724}
36725
36726func (self *PortStatsPropExperimenterIntel) SetTx65To127Packets(v uint64) {
36727 self.Tx65To127Packets = v
36728}
36729
36730func (self *PortStatsPropExperimenterIntel) GetTx128To255Packets() uint64 {
36731 return self.Tx128To255Packets
36732}
36733
36734func (self *PortStatsPropExperimenterIntel) SetTx128To255Packets(v uint64) {
36735 self.Tx128To255Packets = v
36736}
36737
36738func (self *PortStatsPropExperimenterIntel) GetTx256To511Packets() uint64 {
36739 return self.Tx256To511Packets
36740}
36741
36742func (self *PortStatsPropExperimenterIntel) SetTx256To511Packets(v uint64) {
36743 self.Tx256To511Packets = v
36744}
36745
36746func (self *PortStatsPropExperimenterIntel) GetTx512To1023Packets() uint64 {
36747 return self.Tx512To1023Packets
36748}
36749
36750func (self *PortStatsPropExperimenterIntel) SetTx512To1023Packets(v uint64) {
36751 self.Tx512To1023Packets = v
36752}
36753
36754func (self *PortStatsPropExperimenterIntel) GetTx1024To1522Packets() uint64 {
36755 return self.Tx1024To1522Packets
36756}
36757
36758func (self *PortStatsPropExperimenterIntel) SetTx1024To1522Packets(v uint64) {
36759 self.Tx1024To1522Packets = v
36760}
36761
36762func (self *PortStatsPropExperimenterIntel) GetTx1523ToMaxPackets() uint64 {
36763 return self.Tx1523ToMaxPackets
36764}
36765
36766func (self *PortStatsPropExperimenterIntel) SetTx1523ToMaxPackets(v uint64) {
36767 self.Tx1523ToMaxPackets = v
36768}
36769
36770func (self *PortStatsPropExperimenterIntel) GetTxMulticastPackets() uint64 {
36771 return self.TxMulticastPackets
36772}
36773
36774func (self *PortStatsPropExperimenterIntel) SetTxMulticastPackets(v uint64) {
36775 self.TxMulticastPackets = v
36776}
36777
36778func (self *PortStatsPropExperimenterIntel) GetRxBroadcastPackets() uint64 {
36779 return self.RxBroadcastPackets
36780}
36781
36782func (self *PortStatsPropExperimenterIntel) SetRxBroadcastPackets(v uint64) {
36783 self.RxBroadcastPackets = v
36784}
36785
36786func (self *PortStatsPropExperimenterIntel) GetTxBroadcastPackets() uint64 {
36787 return self.TxBroadcastPackets
36788}
36789
36790func (self *PortStatsPropExperimenterIntel) SetTxBroadcastPackets(v uint64) {
36791 self.TxBroadcastPackets = v
36792}
36793
36794func (self *PortStatsPropExperimenterIntel) GetRxUndersizedErrors() uint64 {
36795 return self.RxUndersizedErrors
36796}
36797
36798func (self *PortStatsPropExperimenterIntel) SetRxUndersizedErrors(v uint64) {
36799 self.RxUndersizedErrors = v
36800}
36801
36802func (self *PortStatsPropExperimenterIntel) GetRxOversizeErrors() uint64 {
36803 return self.RxOversizeErrors
36804}
36805
36806func (self *PortStatsPropExperimenterIntel) SetRxOversizeErrors(v uint64) {
36807 self.RxOversizeErrors = v
36808}
36809
36810func (self *PortStatsPropExperimenterIntel) GetRxFragmentedErrors() uint64 {
36811 return self.RxFragmentedErrors
36812}
36813
36814func (self *PortStatsPropExperimenterIntel) SetRxFragmentedErrors(v uint64) {
36815 self.RxFragmentedErrors = v
36816}
36817
36818func (self *PortStatsPropExperimenterIntel) GetRxJabberErrors() uint64 {
36819 return self.RxJabberErrors
36820}
36821
36822func (self *PortStatsPropExperimenterIntel) SetRxJabberErrors(v uint64) {
36823 self.RxJabberErrors = v
36824}
36825
36826func (self *PortStatsPropExperimenterIntel) Serialize(encoder *goloxi.Encoder) error {
36827 startIndex := len(encoder.Bytes())
36828 if err := self.PortStatsPropExperimenter.Serialize(encoder); err != nil {
36829 return err
36830 }
36831
36832 encoder.Write(bytes.Repeat([]byte{0}, 4))
36833 encoder.PutUint64(uint64(self.Rx1To64Packets))
36834 encoder.PutUint64(uint64(self.Rx65To127Packets))
36835 encoder.PutUint64(uint64(self.Rx128To255Packets))
36836 encoder.PutUint64(uint64(self.Rx256To511Packets))
36837 encoder.PutUint64(uint64(self.Rx512To1023Packets))
36838 encoder.PutUint64(uint64(self.Rx1024To1522Packets))
36839 encoder.PutUint64(uint64(self.Rx1523ToMaxPackets))
36840 encoder.PutUint64(uint64(self.Tx1To64Packets))
36841 encoder.PutUint64(uint64(self.Tx65To127Packets))
36842 encoder.PutUint64(uint64(self.Tx128To255Packets))
36843 encoder.PutUint64(uint64(self.Tx256To511Packets))
36844 encoder.PutUint64(uint64(self.Tx512To1023Packets))
36845 encoder.PutUint64(uint64(self.Tx1024To1522Packets))
36846 encoder.PutUint64(uint64(self.Tx1523ToMaxPackets))
36847 encoder.PutUint64(uint64(self.TxMulticastPackets))
36848 encoder.PutUint64(uint64(self.RxBroadcastPackets))
36849 encoder.PutUint64(uint64(self.TxBroadcastPackets))
36850 encoder.PutUint64(uint64(self.RxUndersizedErrors))
36851 encoder.PutUint64(uint64(self.RxOversizeErrors))
36852 encoder.PutUint64(uint64(self.RxFragmentedErrors))
36853 encoder.PutUint64(uint64(self.RxJabberErrors))
36854 length := len(encoder.Bytes()) - startIndex
36855
36856 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
36857
36858 return nil
36859}
36860
36861func DecodePortStatsPropExperimenterIntel(parent *PortStatsPropExperimenter, decoder *goloxi.Decoder) (*PortStatsPropExperimenterIntel, error) {
36862 _portstatspropexperimenterintel := &PortStatsPropExperimenterIntel{PortStatsPropExperimenter: parent}
36863 if decoder.Length() < 172 {
36864 return nil, fmt.Errorf("PortStatsPropExperimenterIntel packet too short: %d < 172", decoder.Length())
36865 }
36866 decoder.Skip(4)
36867 _portstatspropexperimenterintel.Rx1To64Packets = uint64(decoder.ReadUint64())
36868 _portstatspropexperimenterintel.Rx65To127Packets = uint64(decoder.ReadUint64())
36869 _portstatspropexperimenterintel.Rx128To255Packets = uint64(decoder.ReadUint64())
36870 _portstatspropexperimenterintel.Rx256To511Packets = uint64(decoder.ReadUint64())
36871 _portstatspropexperimenterintel.Rx512To1023Packets = uint64(decoder.ReadUint64())
36872 _portstatspropexperimenterintel.Rx1024To1522Packets = uint64(decoder.ReadUint64())
36873 _portstatspropexperimenterintel.Rx1523ToMaxPackets = uint64(decoder.ReadUint64())
36874 _portstatspropexperimenterintel.Tx1To64Packets = uint64(decoder.ReadUint64())
36875 _portstatspropexperimenterintel.Tx65To127Packets = uint64(decoder.ReadUint64())
36876 _portstatspropexperimenterintel.Tx128To255Packets = uint64(decoder.ReadUint64())
36877 _portstatspropexperimenterintel.Tx256To511Packets = uint64(decoder.ReadUint64())
36878 _portstatspropexperimenterintel.Tx512To1023Packets = uint64(decoder.ReadUint64())
36879 _portstatspropexperimenterintel.Tx1024To1522Packets = uint64(decoder.ReadUint64())
36880 _portstatspropexperimenterintel.Tx1523ToMaxPackets = uint64(decoder.ReadUint64())
36881 _portstatspropexperimenterintel.TxMulticastPackets = uint64(decoder.ReadUint64())
36882 _portstatspropexperimenterintel.RxBroadcastPackets = uint64(decoder.ReadUint64())
36883 _portstatspropexperimenterintel.TxBroadcastPackets = uint64(decoder.ReadUint64())
36884 _portstatspropexperimenterintel.RxUndersizedErrors = uint64(decoder.ReadUint64())
36885 _portstatspropexperimenterintel.RxOversizeErrors = uint64(decoder.ReadUint64())
36886 _portstatspropexperimenterintel.RxFragmentedErrors = uint64(decoder.ReadUint64())
36887 _portstatspropexperimenterintel.RxJabberErrors = uint64(decoder.ReadUint64())
36888 return _portstatspropexperimenterintel, nil
36889}
36890
36891func NewPortStatsPropExperimenterIntel() *PortStatsPropExperimenterIntel {
36892 obj := &PortStatsPropExperimenterIntel{
36893 PortStatsPropExperimenter: NewPortStatsPropExperimenter(43521),
36894 }
36895 return obj
36896}
36897
36898type PortStatsPropOptical struct {
36899 *PortStatsProp
36900 Flags uint32
36901 TxFreqLmda uint32
36902 TxOffset uint32
36903 TxGridSpan uint32
36904 RxFreqLmda uint32
36905 RxOffset uint32
36906 RxGridSpan uint32
36907 TxPwr uint16
36908 RxPwr uint16
36909 BiasCurrent uint16
36910 Temperature uint16
36911}
36912
36913type IPortStatsPropOptical interface {
36914 IPortStatsProp
36915 GetFlags() uint32
36916 GetTxFreqLmda() uint32
36917 GetTxOffset() uint32
36918 GetTxGridSpan() uint32
36919 GetRxFreqLmda() uint32
36920 GetRxOffset() uint32
36921 GetRxGridSpan() uint32
36922 GetTxPwr() uint16
36923 GetRxPwr() uint16
36924 GetBiasCurrent() uint16
36925 GetTemperature() uint16
36926}
36927
36928func (self *PortStatsPropOptical) GetFlags() uint32 {
36929 return self.Flags
36930}
36931
36932func (self *PortStatsPropOptical) SetFlags(v uint32) {
36933 self.Flags = v
36934}
36935
36936func (self *PortStatsPropOptical) GetTxFreqLmda() uint32 {
36937 return self.TxFreqLmda
36938}
36939
36940func (self *PortStatsPropOptical) SetTxFreqLmda(v uint32) {
36941 self.TxFreqLmda = v
36942}
36943
36944func (self *PortStatsPropOptical) GetTxOffset() uint32 {
36945 return self.TxOffset
36946}
36947
36948func (self *PortStatsPropOptical) SetTxOffset(v uint32) {
36949 self.TxOffset = v
36950}
36951
36952func (self *PortStatsPropOptical) GetTxGridSpan() uint32 {
36953 return self.TxGridSpan
36954}
36955
36956func (self *PortStatsPropOptical) SetTxGridSpan(v uint32) {
36957 self.TxGridSpan = v
36958}
36959
36960func (self *PortStatsPropOptical) GetRxFreqLmda() uint32 {
36961 return self.RxFreqLmda
36962}
36963
36964func (self *PortStatsPropOptical) SetRxFreqLmda(v uint32) {
36965 self.RxFreqLmda = v
36966}
36967
36968func (self *PortStatsPropOptical) GetRxOffset() uint32 {
36969 return self.RxOffset
36970}
36971
36972func (self *PortStatsPropOptical) SetRxOffset(v uint32) {
36973 self.RxOffset = v
36974}
36975
36976func (self *PortStatsPropOptical) GetRxGridSpan() uint32 {
36977 return self.RxGridSpan
36978}
36979
36980func (self *PortStatsPropOptical) SetRxGridSpan(v uint32) {
36981 self.RxGridSpan = v
36982}
36983
36984func (self *PortStatsPropOptical) GetTxPwr() uint16 {
36985 return self.TxPwr
36986}
36987
36988func (self *PortStatsPropOptical) SetTxPwr(v uint16) {
36989 self.TxPwr = v
36990}
36991
36992func (self *PortStatsPropOptical) GetRxPwr() uint16 {
36993 return self.RxPwr
36994}
36995
36996func (self *PortStatsPropOptical) SetRxPwr(v uint16) {
36997 self.RxPwr = v
36998}
36999
37000func (self *PortStatsPropOptical) GetBiasCurrent() uint16 {
37001 return self.BiasCurrent
37002}
37003
37004func (self *PortStatsPropOptical) SetBiasCurrent(v uint16) {
37005 self.BiasCurrent = v
37006}
37007
37008func (self *PortStatsPropOptical) GetTemperature() uint16 {
37009 return self.Temperature
37010}
37011
37012func (self *PortStatsPropOptical) SetTemperature(v uint16) {
37013 self.Temperature = v
37014}
37015
37016func (self *PortStatsPropOptical) Serialize(encoder *goloxi.Encoder) error {
37017 startIndex := len(encoder.Bytes())
37018 if err := self.PortStatsProp.Serialize(encoder); err != nil {
37019 return err
37020 }
37021
37022 encoder.Write(bytes.Repeat([]byte{0}, 4))
37023 encoder.PutUint32(uint32(self.Flags))
37024 encoder.PutUint32(uint32(self.TxFreqLmda))
37025 encoder.PutUint32(uint32(self.TxOffset))
37026 encoder.PutUint32(uint32(self.TxGridSpan))
37027 encoder.PutUint32(uint32(self.RxFreqLmda))
37028 encoder.PutUint32(uint32(self.RxOffset))
37029 encoder.PutUint32(uint32(self.RxGridSpan))
37030 encoder.PutUint16(uint16(self.TxPwr))
37031 encoder.PutUint16(uint16(self.RxPwr))
37032 encoder.PutUint16(uint16(self.BiasCurrent))
37033 encoder.PutUint16(uint16(self.Temperature))
37034 length := len(encoder.Bytes()) - startIndex
37035
37036 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
37037
37038 return nil
37039}
37040
37041func DecodePortStatsPropOptical(parent *PortStatsProp, decoder *goloxi.Decoder) (*PortStatsPropOptical, error) {
37042 _portstatspropoptical := &PortStatsPropOptical{PortStatsProp: parent}
37043 if decoder.Length() < 40 {
37044 return nil, fmt.Errorf("PortStatsPropOptical packet too short: %d < 40", decoder.Length())
37045 }
37046 decoder.Skip(4)
37047 _portstatspropoptical.Flags = uint32(decoder.ReadUint32())
37048 _portstatspropoptical.TxFreqLmda = uint32(decoder.ReadUint32())
37049 _portstatspropoptical.TxOffset = uint32(decoder.ReadUint32())
37050 _portstatspropoptical.TxGridSpan = uint32(decoder.ReadUint32())
37051 _portstatspropoptical.RxFreqLmda = uint32(decoder.ReadUint32())
37052 _portstatspropoptical.RxOffset = uint32(decoder.ReadUint32())
37053 _portstatspropoptical.RxGridSpan = uint32(decoder.ReadUint32())
37054 _portstatspropoptical.TxPwr = uint16(decoder.ReadUint16())
37055 _portstatspropoptical.RxPwr = uint16(decoder.ReadUint16())
37056 _portstatspropoptical.BiasCurrent = uint16(decoder.ReadUint16())
37057 _portstatspropoptical.Temperature = uint16(decoder.ReadUint16())
37058 return _portstatspropoptical, nil
37059}
37060
37061func NewPortStatsPropOptical() *PortStatsPropOptical {
37062 obj := &PortStatsPropOptical{
37063 PortStatsProp: NewPortStatsProp(1),
37064 }
37065 return obj
37066}
37067
37068type QueueDesc struct {
37069 PortNo uint32
37070 QueueId uint32
37071 Length uint16
37072 Properties []IQueueDescProp
37073}
37074
37075type IQueueDesc interface {
37076 goloxi.Serializable
37077 GetPortNo() uint32
37078 GetQueueId() uint32
37079 GetLength() uint16
37080 GetProperties() []IQueueDescProp
37081}
37082
37083func (self *QueueDesc) GetPortNo() uint32 {
37084 return self.PortNo
37085}
37086
37087func (self *QueueDesc) SetPortNo(v uint32) {
37088 self.PortNo = v
37089}
37090
37091func (self *QueueDesc) GetQueueId() uint32 {
37092 return self.QueueId
37093}
37094
37095func (self *QueueDesc) SetQueueId(v uint32) {
37096 self.QueueId = v
37097}
37098
37099func (self *QueueDesc) GetLength() uint16 {
37100 return self.Length
37101}
37102
37103func (self *QueueDesc) SetLength(v uint16) {
37104 self.Length = v
37105}
37106
37107func (self *QueueDesc) GetProperties() []IQueueDescProp {
37108 return self.Properties
37109}
37110
37111func (self *QueueDesc) SetProperties(v []IQueueDescProp) {
37112 self.Properties = v
37113}
37114
37115func (self *QueueDesc) Serialize(encoder *goloxi.Encoder) error {
37116 startIndex := len(encoder.Bytes())
37117
37118 encoder.PutUint32(uint32(self.PortNo))
37119 encoder.PutUint32(uint32(self.QueueId))
37120 encoder.PutUint16(uint16(self.Length))
37121 encoder.Write(bytes.Repeat([]byte{0}, 6))
37122 for _, obj := range self.Properties {
37123 if err := obj.Serialize(encoder); err != nil {
37124 return err
37125 }
37126 }
37127 length := len(encoder.Bytes()) - startIndex
37128
37129 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+8:startIndex+10], uint16(length))
37130
37131 return nil
37132}
37133
37134func DecodeQueueDesc(decoder *goloxi.Decoder) (*QueueDesc, error) {
37135 _queuedesc := &QueueDesc{}
37136 if decoder.Length() < 16 {
37137 return nil, fmt.Errorf("QueueDesc packet too short: %d < 16", decoder.Length())
37138 }
37139 _queuedesc.PortNo = uint32(decoder.ReadUint32())
37140 _queuedesc.QueueId = uint32(decoder.ReadUint32())
37141 _queuedesc.Length = uint16(decoder.ReadUint16())
37142 oldDecoder := decoder
37143 defer func() { decoder = oldDecoder }()
37144 decoder = decoder.SliceDecoder(int(_queuedesc.Length), 2+8)
37145 decoder.Skip(6)
37146
37147 for decoder.Length() >= 4 {
37148 item, err := DecodeQueueDescProp(decoder)
37149 if err != nil {
37150 return nil, err
37151 }
37152 if item != nil {
37153 _queuedesc.Properties = append(_queuedesc.Properties, item)
37154 }
37155 }
37156 return _queuedesc, nil
37157}
37158
37159func NewQueueDesc() *QueueDesc {
37160 obj := &QueueDesc{}
37161 return obj
37162}
37163
37164type QueueDescProp struct {
37165 Type uint16
37166 Length uint16
37167}
37168
37169type IQueueDescProp interface {
37170 goloxi.Serializable
37171 GetType() uint16
37172 GetLength() uint16
37173}
37174
37175func (self *QueueDescProp) GetType() uint16 {
37176 return self.Type
37177}
37178
37179func (self *QueueDescProp) SetType(v uint16) {
37180 self.Type = v
37181}
37182
37183func (self *QueueDescProp) GetLength() uint16 {
37184 return self.Length
37185}
37186
37187func (self *QueueDescProp) SetLength(v uint16) {
37188 self.Length = v
37189}
37190
37191func (self *QueueDescProp) Serialize(encoder *goloxi.Encoder) error {
37192
37193 encoder.PutUint16(uint16(self.Type))
37194 encoder.PutUint16(uint16(self.Length))
37195
37196 return nil
37197}
37198
37199func DecodeQueueDescProp(decoder *goloxi.Decoder) (IQueueDescProp, error) {
37200 _queuedescprop := &QueueDescProp{}
37201 if decoder.Length() < 4 {
37202 return nil, fmt.Errorf("QueueDescProp packet too short: %d < 4", decoder.Length())
37203 }
37204 _queuedescprop.Type = uint16(decoder.ReadUint16())
37205 _queuedescprop.Length = uint16(decoder.ReadUint16())
37206 oldDecoder := decoder
37207 defer func() { decoder = oldDecoder }()
37208 decoder = decoder.SliceDecoder(int(_queuedescprop.Length), 2+2)
37209
37210 switch _queuedescprop.Type {
37211 case 1:
37212 return DecodeQueueDescPropMinRate(_queuedescprop, decoder)
37213 case 2:
37214 return DecodeQueueDescPropMaxRate(_queuedescprop, decoder)
37215 case 65535:
37216 return DecodeQueueDescPropExperimenter(_queuedescprop, decoder)
37217 default:
37218 return nil, fmt.Errorf("Invalid type '%d' for 'QueueDescProp'", _queuedescprop.Type)
37219 }
37220}
37221
37222func NewQueueDescProp(_type uint16) *QueueDescProp {
37223 obj := &QueueDescProp{}
37224 obj.Type = _type
37225 return obj
37226}
37227
37228type QueueDescPropExperimenter struct {
37229 *QueueDescProp
37230 Experimenter uint32
37231 ExpType uint32
37232}
37233
37234type IQueueDescPropExperimenter interface {
37235 IQueueDescProp
37236 GetExperimenter() uint32
37237 GetExpType() uint32
37238}
37239
37240func (self *QueueDescPropExperimenter) GetExperimenter() uint32 {
37241 return self.Experimenter
37242}
37243
37244func (self *QueueDescPropExperimenter) SetExperimenter(v uint32) {
37245 self.Experimenter = v
37246}
37247
37248func (self *QueueDescPropExperimenter) GetExpType() uint32 {
37249 return self.ExpType
37250}
37251
37252func (self *QueueDescPropExperimenter) SetExpType(v uint32) {
37253 self.ExpType = v
37254}
37255
37256func (self *QueueDescPropExperimenter) Serialize(encoder *goloxi.Encoder) error {
37257 if err := self.QueueDescProp.Serialize(encoder); err != nil {
37258 return err
37259 }
37260
37261 encoder.PutUint32(uint32(self.Experimenter))
37262 encoder.PutUint32(uint32(self.ExpType))
37263
37264 return nil
37265}
37266
37267func DecodeQueueDescPropExperimenter(parent *QueueDescProp, decoder *goloxi.Decoder) (IQueueDescPropExperimenter, error) {
37268 _queuedescpropexperimenter := &QueueDescPropExperimenter{QueueDescProp: parent}
37269 if decoder.Length() < 8 {
37270 return nil, fmt.Errorf("QueueDescPropExperimenter packet too short: %d < 8", decoder.Length())
37271 }
37272 _queuedescpropexperimenter.Experimenter = uint32(decoder.ReadUint32())
37273 _queuedescpropexperimenter.ExpType = uint32(decoder.ReadUint32())
37274
37275 switch _queuedescpropexperimenter.Experimenter {
37276 case 6035143:
37277 return DecodeQueueDescPropBsn(_queuedescpropexperimenter, decoder)
37278 default:
37279 return nil, fmt.Errorf("Invalid type '%d' for 'QueueDescPropExperimenter'", _queuedescpropexperimenter.Experimenter)
37280 }
37281}
37282
37283func NewQueueDescPropExperimenter(_experimenter uint32) *QueueDescPropExperimenter {
37284 obj := &QueueDescPropExperimenter{
37285 QueueDescProp: NewQueueDescProp(65535),
37286 }
37287 obj.Experimenter = _experimenter
37288 return obj
37289}
37290
37291type QueueDescPropBsn struct {
37292 *QueueDescPropExperimenter
37293}
37294
37295type IQueueDescPropBsn interface {
37296 IQueueDescPropExperimenter
37297}
37298
37299func (self *QueueDescPropBsn) Serialize(encoder *goloxi.Encoder) error {
37300 if err := self.QueueDescPropExperimenter.Serialize(encoder); err != nil {
37301 return err
37302 }
37303
37304 return nil
37305}
37306
37307func DecodeQueueDescPropBsn(parent *QueueDescPropExperimenter, decoder *goloxi.Decoder) (IQueueDescPropBsn, error) {
37308 _queuedescpropbsn := &QueueDescPropBsn{QueueDescPropExperimenter: parent}
37309
37310 switch _queuedescpropbsn.ExpType {
37311 case 0:
37312 return DecodeQueueDescPropBsnQueueName(_queuedescpropbsn, decoder)
37313 default:
37314 return nil, fmt.Errorf("Invalid type '%d' for 'QueueDescPropBsn'", _queuedescpropbsn.ExpType)
37315 }
37316}
37317
37318func NewQueueDescPropBsn(_exp_type uint32) *QueueDescPropBsn {
37319 obj := &QueueDescPropBsn{
37320 QueueDescPropExperimenter: NewQueueDescPropExperimenter(6035143),
37321 }
37322 obj.ExpType = _exp_type
37323 return obj
37324}
37325
37326type QueueDescPropBsnQueueName struct {
37327 *QueueDescPropBsn
37328 Name []byte
37329}
37330
37331type IQueueDescPropBsnQueueName interface {
37332 IQueueDescPropBsn
37333 GetName() []byte
37334}
37335
37336func (self *QueueDescPropBsnQueueName) GetName() []byte {
37337 return self.Name
37338}
37339
37340func (self *QueueDescPropBsnQueueName) SetName(v []byte) {
37341 self.Name = v
37342}
37343
37344func (self *QueueDescPropBsnQueueName) Serialize(encoder *goloxi.Encoder) error {
37345 startIndex := len(encoder.Bytes())
37346 if err := self.QueueDescPropBsn.Serialize(encoder); err != nil {
37347 return err
37348 }
37349
37350 encoder.Write(self.Name)
37351 length := len(encoder.Bytes()) - startIndex
37352
37353 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
37354
37355 return nil
37356}
37357
37358func DecodeQueueDescPropBsnQueueName(parent *QueueDescPropBsn, decoder *goloxi.Decoder) (*QueueDescPropBsnQueueName, error) {
37359 _queuedescpropbsnqueuename := &QueueDescPropBsnQueueName{QueueDescPropBsn: parent}
37360 _queuedescpropbsnqueuename.Name = decoder.Read(int(decoder.Length()))
37361 return _queuedescpropbsnqueuename, nil
37362}
37363
37364func NewQueueDescPropBsnQueueName() *QueueDescPropBsnQueueName {
37365 obj := &QueueDescPropBsnQueueName{
37366 QueueDescPropBsn: NewQueueDescPropBsn(0),
37367 }
37368 return obj
37369}
37370
37371type QueueDescPropMaxRate struct {
37372 *QueueDescProp
37373 Rate uint16
37374}
37375
37376type IQueueDescPropMaxRate interface {
37377 IQueueDescProp
37378 GetRate() uint16
37379}
37380
37381func (self *QueueDescPropMaxRate) GetRate() uint16 {
37382 return self.Rate
37383}
37384
37385func (self *QueueDescPropMaxRate) SetRate(v uint16) {
37386 self.Rate = v
37387}
37388
37389func (self *QueueDescPropMaxRate) Serialize(encoder *goloxi.Encoder) error {
37390 startIndex := len(encoder.Bytes())
37391 if err := self.QueueDescProp.Serialize(encoder); err != nil {
37392 return err
37393 }
37394
37395 encoder.PutUint16(uint16(self.Rate))
37396 encoder.Write(bytes.Repeat([]byte{0}, 2))
37397 length := len(encoder.Bytes()) - startIndex
37398
37399 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
37400
37401 return nil
37402}
37403
37404func DecodeQueueDescPropMaxRate(parent *QueueDescProp, decoder *goloxi.Decoder) (*QueueDescPropMaxRate, error) {
37405 _queuedescpropmaxrate := &QueueDescPropMaxRate{QueueDescProp: parent}
37406 if decoder.Length() < 4 {
37407 return nil, fmt.Errorf("QueueDescPropMaxRate packet too short: %d < 4", decoder.Length())
37408 }
37409 _queuedescpropmaxrate.Rate = uint16(decoder.ReadUint16())
37410 decoder.Skip(2)
37411 return _queuedescpropmaxrate, nil
37412}
37413
37414func NewQueueDescPropMaxRate() *QueueDescPropMaxRate {
37415 obj := &QueueDescPropMaxRate{
37416 QueueDescProp: NewQueueDescProp(2),
37417 }
37418 return obj
37419}
37420
37421type QueueDescPropMinRate struct {
37422 *QueueDescProp
37423 Rate uint16
37424}
37425
37426type IQueueDescPropMinRate interface {
37427 IQueueDescProp
37428 GetRate() uint16
37429}
37430
37431func (self *QueueDescPropMinRate) GetRate() uint16 {
37432 return self.Rate
37433}
37434
37435func (self *QueueDescPropMinRate) SetRate(v uint16) {
37436 self.Rate = v
37437}
37438
37439func (self *QueueDescPropMinRate) Serialize(encoder *goloxi.Encoder) error {
37440 startIndex := len(encoder.Bytes())
37441 if err := self.QueueDescProp.Serialize(encoder); err != nil {
37442 return err
37443 }
37444
37445 encoder.PutUint16(uint16(self.Rate))
37446 encoder.Write(bytes.Repeat([]byte{0}, 2))
37447 length := len(encoder.Bytes()) - startIndex
37448
37449 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
37450
37451 return nil
37452}
37453
37454func DecodeQueueDescPropMinRate(parent *QueueDescProp, decoder *goloxi.Decoder) (*QueueDescPropMinRate, error) {
37455 _queuedescpropminrate := &QueueDescPropMinRate{QueueDescProp: parent}
37456 if decoder.Length() < 4 {
37457 return nil, fmt.Errorf("QueueDescPropMinRate packet too short: %d < 4", decoder.Length())
37458 }
37459 _queuedescpropminrate.Rate = uint16(decoder.ReadUint16())
37460 decoder.Skip(2)
37461 return _queuedescpropminrate, nil
37462}
37463
37464func NewQueueDescPropMinRate() *QueueDescPropMinRate {
37465 obj := &QueueDescPropMinRate{
37466 QueueDescProp: NewQueueDescProp(1),
37467 }
37468 return obj
37469}
37470
37471type QueueProp struct {
37472 Type uint16
37473 Len uint16
37474}
37475
37476type IQueueProp interface {
37477 goloxi.Serializable
37478 GetType() uint16
37479 GetLen() uint16
37480}
37481
37482func (self *QueueProp) GetType() uint16 {
37483 return self.Type
37484}
37485
37486func (self *QueueProp) SetType(v uint16) {
37487 self.Type = v
37488}
37489
37490func (self *QueueProp) GetLen() uint16 {
37491 return self.Len
37492}
37493
37494func (self *QueueProp) SetLen(v uint16) {
37495 self.Len = v
37496}
37497
37498func (self *QueueProp) Serialize(encoder *goloxi.Encoder) error {
37499
37500 encoder.PutUint16(uint16(self.Type))
37501 encoder.PutUint16(uint16(self.Len))
37502
37503 return nil
37504}
37505
37506func DecodeQueueProp(decoder *goloxi.Decoder) (IQueueProp, error) {
37507 _queueprop := &QueueProp{}
37508 if decoder.Length() < 4 {
37509 return nil, fmt.Errorf("QueueProp packet too short: %d < 4", decoder.Length())
37510 }
37511 _queueprop.Type = uint16(decoder.ReadUint16())
37512 _queueprop.Len = uint16(decoder.ReadUint16())
37513 oldDecoder := decoder
37514 defer func() { decoder = oldDecoder }()
37515 decoder = decoder.SliceDecoder(int(_queueprop.Len), 2+2)
37516
37517 switch _queueprop.Type {
37518 case 1:
37519 return DecodeQueuePropMinRate(_queueprop, decoder)
37520 case 2:
37521 return DecodeQueuePropMaxRate(_queueprop, decoder)
37522 case 65535:
37523 return DecodeQueuePropExperimenter(_queueprop, decoder)
37524 default:
37525 return nil, fmt.Errorf("Invalid type '%d' for 'QueueProp'", _queueprop.Type)
37526 }
37527}
37528
37529func NewQueueProp(_type uint16) *QueueProp {
37530 obj := &QueueProp{}
37531 obj.Type = _type
37532 return obj
37533}
37534
37535type QueuePropExperimenter struct {
37536 *QueueProp
37537 Experimenter uint32
37538}
37539
37540type IQueuePropExperimenter interface {
37541 IQueueProp
37542 GetExperimenter() uint32
37543}
37544
37545func (self *QueuePropExperimenter) GetExperimenter() uint32 {
37546 return self.Experimenter
37547}
37548
37549func (self *QueuePropExperimenter) SetExperimenter(v uint32) {
37550 self.Experimenter = v
37551}
37552
37553func (self *QueuePropExperimenter) Serialize(encoder *goloxi.Encoder) error {
37554 if err := self.QueueProp.Serialize(encoder); err != nil {
37555 return err
37556 }
37557
37558 encoder.Write(bytes.Repeat([]byte{0}, 4))
37559 encoder.PutUint32(uint32(self.Experimenter))
37560 encoder.Write(bytes.Repeat([]byte{0}, 4))
37561
37562 return nil
37563}
37564
37565func DecodeQueuePropExperimenter(parent *QueueProp, decoder *goloxi.Decoder) (IQueuePropExperimenter, error) {
37566 _queuepropexperimenter := &QueuePropExperimenter{QueueProp: parent}
37567 if decoder.Length() < 4 {
37568 return nil, fmt.Errorf("QueuePropExperimenter packet too short: %d < 4", decoder.Length())
37569 }
37570 decoder.Skip(4)
37571 _queuepropexperimenter.Experimenter = uint32(decoder.ReadUint32())
37572 decoder.Skip(4)
37573 return _queuepropexperimenter, nil
37574}
37575
37576func NewQueuePropExperimenter(_experimenter uint32) *QueuePropExperimenter {
37577 obj := &QueuePropExperimenter{
37578 QueueProp: NewQueueProp(65535),
37579 }
37580 obj.Experimenter = _experimenter
37581 return obj
37582}
37583
37584type QueuePropMaxRate struct {
37585 *QueueProp
37586 Rate uint16
37587}
37588
37589type IQueuePropMaxRate interface {
37590 IQueueProp
37591 GetRate() uint16
37592}
37593
37594func (self *QueuePropMaxRate) GetRate() uint16 {
37595 return self.Rate
37596}
37597
37598func (self *QueuePropMaxRate) SetRate(v uint16) {
37599 self.Rate = v
37600}
37601
37602func (self *QueuePropMaxRate) Serialize(encoder *goloxi.Encoder) error {
37603 startIndex := len(encoder.Bytes())
37604 if err := self.QueueProp.Serialize(encoder); err != nil {
37605 return err
37606 }
37607
37608 encoder.Write(bytes.Repeat([]byte{0}, 4))
37609 encoder.PutUint16(uint16(self.Rate))
37610 encoder.Write(bytes.Repeat([]byte{0}, 6))
37611 length := len(encoder.Bytes()) - startIndex
37612
37613 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
37614
37615 return nil
37616}
37617
37618func DecodeQueuePropMaxRate(parent *QueueProp, decoder *goloxi.Decoder) (*QueuePropMaxRate, error) {
37619 _queuepropmaxrate := &QueuePropMaxRate{QueueProp: parent}
37620 if decoder.Length() < 12 {
37621 return nil, fmt.Errorf("QueuePropMaxRate packet too short: %d < 12", decoder.Length())
37622 }
37623 decoder.Skip(4)
37624 _queuepropmaxrate.Rate = uint16(decoder.ReadUint16())
37625 decoder.Skip(6)
37626 return _queuepropmaxrate, nil
37627}
37628
37629func NewQueuePropMaxRate() *QueuePropMaxRate {
37630 obj := &QueuePropMaxRate{
37631 QueueProp: NewQueueProp(2),
37632 }
37633 return obj
37634}
37635
37636type QueuePropMinRate struct {
37637 *QueueProp
37638 Rate uint16
37639}
37640
37641type IQueuePropMinRate interface {
37642 IQueueProp
37643 GetRate() uint16
37644}
37645
37646func (self *QueuePropMinRate) GetRate() uint16 {
37647 return self.Rate
37648}
37649
37650func (self *QueuePropMinRate) SetRate(v uint16) {
37651 self.Rate = v
37652}
37653
37654func (self *QueuePropMinRate) Serialize(encoder *goloxi.Encoder) error {
37655 startIndex := len(encoder.Bytes())
37656 if err := self.QueueProp.Serialize(encoder); err != nil {
37657 return err
37658 }
37659
37660 encoder.Write(bytes.Repeat([]byte{0}, 4))
37661 encoder.PutUint16(uint16(self.Rate))
37662 encoder.Write(bytes.Repeat([]byte{0}, 6))
37663 length := len(encoder.Bytes()) - startIndex
37664
37665 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
37666
37667 return nil
37668}
37669
37670func DecodeQueuePropMinRate(parent *QueueProp, decoder *goloxi.Decoder) (*QueuePropMinRate, error) {
37671 _queuepropminrate := &QueuePropMinRate{QueueProp: parent}
37672 if decoder.Length() < 12 {
37673 return nil, fmt.Errorf("QueuePropMinRate packet too short: %d < 12", decoder.Length())
37674 }
37675 decoder.Skip(4)
37676 _queuepropminrate.Rate = uint16(decoder.ReadUint16())
37677 decoder.Skip(6)
37678 return _queuepropminrate, nil
37679}
37680
37681func NewQueuePropMinRate() *QueuePropMinRate {
37682 obj := &QueuePropMinRate{
37683 QueueProp: NewQueueProp(1),
37684 }
37685 return obj
37686}
37687
37688type QueueStatsEntry struct {
37689 Length uint16
37690 PortNo Port
37691 QueueId uint32
37692 TxBytes uint64
37693 TxPackets uint64
37694 TxErrors uint64
37695 DurationSec uint32
37696 DurationNsec uint32
37697 Properties []IQueueStatsProp
37698}
37699
37700type IQueueStatsEntry interface {
37701 goloxi.Serializable
37702 GetLength() uint16
37703 GetPortNo() Port
37704 GetQueueId() uint32
37705 GetTxBytes() uint64
37706 GetTxPackets() uint64
37707 GetTxErrors() uint64
37708 GetDurationSec() uint32
37709 GetDurationNsec() uint32
37710 GetProperties() []IQueueStatsProp
37711}
37712
37713func (self *QueueStatsEntry) GetLength() uint16 {
37714 return self.Length
37715}
37716
37717func (self *QueueStatsEntry) SetLength(v uint16) {
37718 self.Length = v
37719}
37720
37721func (self *QueueStatsEntry) GetPortNo() Port {
37722 return self.PortNo
37723}
37724
37725func (self *QueueStatsEntry) SetPortNo(v Port) {
37726 self.PortNo = v
37727}
37728
37729func (self *QueueStatsEntry) GetQueueId() uint32 {
37730 return self.QueueId
37731}
37732
37733func (self *QueueStatsEntry) SetQueueId(v uint32) {
37734 self.QueueId = v
37735}
37736
37737func (self *QueueStatsEntry) GetTxBytes() uint64 {
37738 return self.TxBytes
37739}
37740
37741func (self *QueueStatsEntry) SetTxBytes(v uint64) {
37742 self.TxBytes = v
37743}
37744
37745func (self *QueueStatsEntry) GetTxPackets() uint64 {
37746 return self.TxPackets
37747}
37748
37749func (self *QueueStatsEntry) SetTxPackets(v uint64) {
37750 self.TxPackets = v
37751}
37752
37753func (self *QueueStatsEntry) GetTxErrors() uint64 {
37754 return self.TxErrors
37755}
37756
37757func (self *QueueStatsEntry) SetTxErrors(v uint64) {
37758 self.TxErrors = v
37759}
37760
37761func (self *QueueStatsEntry) GetDurationSec() uint32 {
37762 return self.DurationSec
37763}
37764
37765func (self *QueueStatsEntry) SetDurationSec(v uint32) {
37766 self.DurationSec = v
37767}
37768
37769func (self *QueueStatsEntry) GetDurationNsec() uint32 {
37770 return self.DurationNsec
37771}
37772
37773func (self *QueueStatsEntry) SetDurationNsec(v uint32) {
37774 self.DurationNsec = v
37775}
37776
37777func (self *QueueStatsEntry) GetProperties() []IQueueStatsProp {
37778 return self.Properties
37779}
37780
37781func (self *QueueStatsEntry) SetProperties(v []IQueueStatsProp) {
37782 self.Properties = v
37783}
37784
37785func (self *QueueStatsEntry) Serialize(encoder *goloxi.Encoder) error {
37786 startIndex := len(encoder.Bytes())
37787
37788 encoder.PutUint16(uint16(self.Length))
37789 encoder.Write(bytes.Repeat([]byte{0}, 6))
37790 self.PortNo.Serialize(encoder)
37791 encoder.PutUint32(uint32(self.QueueId))
37792 encoder.PutUint64(uint64(self.TxBytes))
37793 encoder.PutUint64(uint64(self.TxPackets))
37794 encoder.PutUint64(uint64(self.TxErrors))
37795 encoder.PutUint32(uint32(self.DurationSec))
37796 encoder.PutUint32(uint32(self.DurationNsec))
37797 for _, obj := range self.Properties {
37798 if err := obj.Serialize(encoder); err != nil {
37799 return err
37800 }
37801 }
37802 length := len(encoder.Bytes()) - startIndex
37803
37804 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
37805
37806 return nil
37807}
37808
37809func DecodeQueueStatsEntry(decoder *goloxi.Decoder) (*QueueStatsEntry, error) {
37810 _queuestatsentry := &QueueStatsEntry{}
37811 if decoder.Length() < 48 {
37812 return nil, fmt.Errorf("QueueStatsEntry packet too short: %d < 48", decoder.Length())
37813 }
37814 _queuestatsentry.Length = uint16(decoder.ReadUint16())
37815 oldDecoder := decoder
37816 defer func() { decoder = oldDecoder }()
37817 decoder = decoder.SliceDecoder(int(_queuestatsentry.Length), 2+0)
37818 decoder.Skip(6)
37819 _queuestatsentry.PortNo.Decode(decoder)
37820 _queuestatsentry.QueueId = uint32(decoder.ReadUint32())
37821 _queuestatsentry.TxBytes = uint64(decoder.ReadUint64())
37822 _queuestatsentry.TxPackets = uint64(decoder.ReadUint64())
37823 _queuestatsentry.TxErrors = uint64(decoder.ReadUint64())
37824 _queuestatsentry.DurationSec = uint32(decoder.ReadUint32())
37825 _queuestatsentry.DurationNsec = uint32(decoder.ReadUint32())
37826
37827 for decoder.Length() >= 4 {
37828 item, err := DecodeQueueStatsProp(decoder)
37829 if err != nil {
37830 return nil, err
37831 }
37832 if item != nil {
37833 _queuestatsentry.Properties = append(_queuestatsentry.Properties, item)
37834 }
37835 }
37836 return _queuestatsentry, nil
37837}
37838
37839func NewQueueStatsEntry() *QueueStatsEntry {
37840 obj := &QueueStatsEntry{}
37841 return obj
37842}
37843
37844type QueueStatsProp struct {
37845 Type uint16
37846 Length uint16
37847}
37848
37849type IQueueStatsProp interface {
37850 goloxi.Serializable
37851 GetType() uint16
37852 GetLength() uint16
37853}
37854
37855func (self *QueueStatsProp) GetType() uint16 {
37856 return self.Type
37857}
37858
37859func (self *QueueStatsProp) SetType(v uint16) {
37860 self.Type = v
37861}
37862
37863func (self *QueueStatsProp) GetLength() uint16 {
37864 return self.Length
37865}
37866
37867func (self *QueueStatsProp) SetLength(v uint16) {
37868 self.Length = v
37869}
37870
37871func (self *QueueStatsProp) Serialize(encoder *goloxi.Encoder) error {
37872
37873 encoder.PutUint16(uint16(self.Type))
37874 encoder.PutUint16(uint16(self.Length))
37875
37876 return nil
37877}
37878
37879func DecodeQueueStatsProp(decoder *goloxi.Decoder) (IQueueStatsProp, error) {
37880 _queuestatsprop := &QueueStatsProp{}
37881 if decoder.Length() < 4 {
37882 return nil, fmt.Errorf("QueueStatsProp packet too short: %d < 4", decoder.Length())
37883 }
37884 _queuestatsprop.Type = uint16(decoder.ReadUint16())
37885 _queuestatsprop.Length = uint16(decoder.ReadUint16())
37886 oldDecoder := decoder
37887 defer func() { decoder = oldDecoder }()
37888 decoder = decoder.SliceDecoder(int(_queuestatsprop.Length), 2+2)
37889
37890 switch _queuestatsprop.Type {
37891 case 65535:
37892 return DecodeQueueStatsPropExperimenter(_queuestatsprop, decoder)
37893 default:
37894 return nil, fmt.Errorf("Invalid type '%d' for 'QueueStatsProp'", _queuestatsprop.Type)
37895 }
37896}
37897
37898func NewQueueStatsProp(_type uint16) *QueueStatsProp {
37899 obj := &QueueStatsProp{}
37900 obj.Type = _type
37901 return obj
37902}
37903
37904type QueueStatsPropExperimenter struct {
37905 *QueueStatsProp
37906 Experimenter uint32
37907 ExpType uint32
37908}
37909
37910type IQueueStatsPropExperimenter interface {
37911 IQueueStatsProp
37912 GetExperimenter() uint32
37913 GetExpType() uint32
37914}
37915
37916func (self *QueueStatsPropExperimenter) GetExperimenter() uint32 {
37917 return self.Experimenter
37918}
37919
37920func (self *QueueStatsPropExperimenter) SetExperimenter(v uint32) {
37921 self.Experimenter = v
37922}
37923
37924func (self *QueueStatsPropExperimenter) GetExpType() uint32 {
37925 return self.ExpType
37926}
37927
37928func (self *QueueStatsPropExperimenter) SetExpType(v uint32) {
37929 self.ExpType = v
37930}
37931
37932func (self *QueueStatsPropExperimenter) Serialize(encoder *goloxi.Encoder) error {
37933 if err := self.QueueStatsProp.Serialize(encoder); err != nil {
37934 return err
37935 }
37936
37937 encoder.PutUint32(uint32(self.Experimenter))
37938 encoder.PutUint32(uint32(self.ExpType))
37939
37940 return nil
37941}
37942
37943func DecodeQueueStatsPropExperimenter(parent *QueueStatsProp, decoder *goloxi.Decoder) (IQueueStatsPropExperimenter, error) {
37944 _queuestatspropexperimenter := &QueueStatsPropExperimenter{QueueStatsProp: parent}
37945 if decoder.Length() < 8 {
37946 return nil, fmt.Errorf("QueueStatsPropExperimenter packet too short: %d < 8", decoder.Length())
37947 }
37948 _queuestatspropexperimenter.Experimenter = uint32(decoder.ReadUint32())
37949 _queuestatspropexperimenter.ExpType = uint32(decoder.ReadUint32())
37950
37951 switch _queuestatspropexperimenter.Experimenter {
37952 case 6035143:
37953 return DecodeQueueStatsPropBsn(_queuestatspropexperimenter, decoder)
37954 default:
37955 return nil, fmt.Errorf("Invalid type '%d' for 'QueueStatsPropExperimenter'", _queuestatspropexperimenter.Experimenter)
37956 }
37957}
37958
37959func NewQueueStatsPropExperimenter(_experimenter uint32) *QueueStatsPropExperimenter {
37960 obj := &QueueStatsPropExperimenter{
37961 QueueStatsProp: NewQueueStatsProp(65535),
37962 }
37963 obj.Experimenter = _experimenter
37964 return obj
37965}
37966
37967type QueueStatsPropBsn struct {
37968 *QueueStatsPropExperimenter
37969 ExperimenterData []byte
37970}
37971
37972type IQueueStatsPropBsn interface {
37973 IQueueStatsPropExperimenter
37974 GetExperimenterData() []byte
37975}
37976
37977func (self *QueueStatsPropBsn) GetExperimenterData() []byte {
37978 return self.ExperimenterData
37979}
37980
37981func (self *QueueStatsPropBsn) SetExperimenterData(v []byte) {
37982 self.ExperimenterData = v
37983}
37984
37985func (self *QueueStatsPropBsn) Serialize(encoder *goloxi.Encoder) error {
37986 startIndex := len(encoder.Bytes())
37987 if err := self.QueueStatsPropExperimenter.Serialize(encoder); err != nil {
37988 return err
37989 }
37990
37991 encoder.Write(self.ExperimenterData)
37992 length := len(encoder.Bytes()) - startIndex
37993
37994 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
37995
37996 return nil
37997}
37998
37999func DecodeQueueStatsPropBsn(parent *QueueStatsPropExperimenter, decoder *goloxi.Decoder) (*QueueStatsPropBsn, error) {
38000 _queuestatspropbsn := &QueueStatsPropBsn{QueueStatsPropExperimenter: parent}
38001 _queuestatspropbsn.ExperimenterData = decoder.Read(int(decoder.Length()))
38002 return _queuestatspropbsn, nil
38003}
38004
38005func NewQueueStatsPropBsn() *QueueStatsPropBsn {
38006 obj := &QueueStatsPropBsn{
38007 QueueStatsPropExperimenter: NewQueueStatsPropExperimenter(6035143),
38008 }
38009 return obj
38010}
38011
38012type RoleProp struct {
38013 Type uint16
38014 Length uint16
38015}
38016
38017type IRoleProp interface {
38018 goloxi.Serializable
38019 GetType() uint16
38020 GetLength() uint16
38021}
38022
38023func (self *RoleProp) GetType() uint16 {
38024 return self.Type
38025}
38026
38027func (self *RoleProp) SetType(v uint16) {
38028 self.Type = v
38029}
38030
38031func (self *RoleProp) GetLength() uint16 {
38032 return self.Length
38033}
38034
38035func (self *RoleProp) SetLength(v uint16) {
38036 self.Length = v
38037}
38038
38039func (self *RoleProp) Serialize(encoder *goloxi.Encoder) error {
38040
38041 encoder.PutUint16(uint16(self.Type))
38042 encoder.PutUint16(uint16(self.Length))
38043
38044 return nil
38045}
38046
38047func DecodeRoleProp(decoder *goloxi.Decoder) (IRoleProp, error) {
38048 _roleprop := &RoleProp{}
38049 if decoder.Length() < 4 {
38050 return nil, fmt.Errorf("RoleProp packet too short: %d < 4", decoder.Length())
38051 }
38052 _roleprop.Type = uint16(decoder.ReadUint16())
38053 _roleprop.Length = uint16(decoder.ReadUint16())
38054 oldDecoder := decoder
38055 defer func() { decoder = oldDecoder }()
38056 decoder = decoder.SliceDecoder(int(_roleprop.Length), 2+2)
38057
38058 switch _roleprop.Type {
38059 case 65535:
38060 return DecodeRolePropExperimenter(_roleprop, decoder)
38061 default:
38062 return nil, fmt.Errorf("Invalid type '%d' for 'RoleProp'", _roleprop.Type)
38063 }
38064}
38065
38066func NewRoleProp(_type uint16) *RoleProp {
38067 obj := &RoleProp{}
38068 obj.Type = _type
38069 return obj
38070}
38071
38072type RolePropExperimenter struct {
38073 *RoleProp
38074 Experimenter uint32
38075 ExpType uint32
38076}
38077
38078type IRolePropExperimenter interface {
38079 IRoleProp
38080 GetExperimenter() uint32
38081 GetExpType() uint32
38082}
38083
38084func (self *RolePropExperimenter) GetExperimenter() uint32 {
38085 return self.Experimenter
38086}
38087
38088func (self *RolePropExperimenter) SetExperimenter(v uint32) {
38089 self.Experimenter = v
38090}
38091
38092func (self *RolePropExperimenter) GetExpType() uint32 {
38093 return self.ExpType
38094}
38095
38096func (self *RolePropExperimenter) SetExpType(v uint32) {
38097 self.ExpType = v
38098}
38099
38100func (self *RolePropExperimenter) Serialize(encoder *goloxi.Encoder) error {
38101 if err := self.RoleProp.Serialize(encoder); err != nil {
38102 return err
38103 }
38104
38105 encoder.PutUint32(uint32(self.Experimenter))
38106 encoder.PutUint32(uint32(self.ExpType))
38107
38108 return nil
38109}
38110
38111func DecodeRolePropExperimenter(parent *RoleProp, decoder *goloxi.Decoder) (IRolePropExperimenter, error) {
38112 _rolepropexperimenter := &RolePropExperimenter{RoleProp: parent}
38113 if decoder.Length() < 8 {
38114 return nil, fmt.Errorf("RolePropExperimenter packet too short: %d < 8", decoder.Length())
38115 }
38116 _rolepropexperimenter.Experimenter = uint32(decoder.ReadUint32())
38117 _rolepropexperimenter.ExpType = uint32(decoder.ReadUint32())
38118
38119 switch _rolepropexperimenter.Experimenter {
38120 case 6035143:
38121 return DecodeRolePropBsn(_rolepropexperimenter, decoder)
38122 default:
38123 return nil, fmt.Errorf("Invalid type '%d' for 'RolePropExperimenter'", _rolepropexperimenter.Experimenter)
38124 }
38125}
38126
38127func NewRolePropExperimenter(_experimenter uint32) *RolePropExperimenter {
38128 obj := &RolePropExperimenter{
38129 RoleProp: NewRoleProp(65535),
38130 }
38131 obj.Experimenter = _experimenter
38132 return obj
38133}
38134
38135type RolePropBsn struct {
38136 *RolePropExperimenter
38137 ExperimenterData []byte
38138}
38139
38140type IRolePropBsn interface {
38141 IRolePropExperimenter
38142 GetExperimenterData() []byte
38143}
38144
38145func (self *RolePropBsn) GetExperimenterData() []byte {
38146 return self.ExperimenterData
38147}
38148
38149func (self *RolePropBsn) SetExperimenterData(v []byte) {
38150 self.ExperimenterData = v
38151}
38152
38153func (self *RolePropBsn) Serialize(encoder *goloxi.Encoder) error {
38154 startIndex := len(encoder.Bytes())
38155 if err := self.RolePropExperimenter.Serialize(encoder); err != nil {
38156 return err
38157 }
38158
38159 encoder.Write(self.ExperimenterData)
38160 length := len(encoder.Bytes()) - startIndex
38161
38162 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
38163
38164 return nil
38165}
38166
38167func DecodeRolePropBsn(parent *RolePropExperimenter, decoder *goloxi.Decoder) (*RolePropBsn, error) {
38168 _rolepropbsn := &RolePropBsn{RolePropExperimenter: parent}
38169 _rolepropbsn.ExperimenterData = decoder.Read(int(decoder.Length()))
38170 return _rolepropbsn, nil
38171}
38172
38173func NewRolePropBsn() *RolePropBsn {
38174 obj := &RolePropBsn{
38175 RolePropExperimenter: NewRolePropExperimenter(6035143),
38176 }
38177 return obj
38178}
38179
38180type StatV6 struct {
38181 Length uint16
38182 OxsFields []IOxs
38183}
38184
38185type IStatV6 interface {
38186 goloxi.Serializable
38187 GetLength() uint16
38188 GetOxsFields() []IOxs
38189}
38190
38191func (self *StatV6) GetLength() uint16 {
38192 return self.Length
38193}
38194
38195func (self *StatV6) SetLength(v uint16) {
38196 self.Length = v
38197}
38198
38199func (self *StatV6) GetOxsFields() []IOxs {
38200 return self.OxsFields
38201}
38202
38203func (self *StatV6) SetOxsFields(v []IOxs) {
38204 self.OxsFields = v
38205}
38206
38207func (self *StatV6) Serialize(encoder *goloxi.Encoder) error {
38208 startIndex := len(encoder.Bytes())
38209
38210 encoder.Write(bytes.Repeat([]byte{0}, 2))
38211 encoder.PutUint16(uint16(self.Length))
38212 for _, obj := range self.OxsFields {
38213 if err := obj.Serialize(encoder); err != nil {
38214 return err
38215 }
38216 }
38217 length := len(encoder.Bytes()) - startIndex
38218 alignedLength := ((length + 7) / 8 * 8)
38219
38220 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
38221
38222 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
38223
38224 return nil
38225}
38226func (self *StatV6) Decode(decoder *goloxi.Decoder) error {
38227 if decoder.Length() < 4 {
38228 return fmt.Errorf("StatV6 packet too short: %d < 4", decoder.Length())
38229 }
38230
38231 defer decoder.SkipAlign()
38232
38233 decoder.Skip(2)
38234 self.Length = uint16(decoder.ReadUint16())
38235 oldDecoder := decoder
38236 defer func() { decoder = oldDecoder }()
38237 decoder = decoder.SliceDecoder(int(((self.Length)+7)/8*8), 2+2)
38238
38239 for decoder.Length() >= 4 {
38240 item, err := DecodeOxs(decoder)
38241 if err != nil {
38242 return err
38243 }
38244 if item != nil {
38245 self.OxsFields = append(self.OxsFields, item)
38246 }
38247 }
38248
38249 return nil
38250}
38251
38252func NewStatV6() *StatV6 {
38253 obj := &StatV6{}
38254 return obj
38255}
38256
38257type TableDesc struct {
38258 Length uint16
38259 TableId uint8
38260 Config TableConfig
38261 Properties []ITableModProp
38262}
38263
38264type ITableDesc interface {
38265 goloxi.Serializable
38266 GetLength() uint16
38267 GetTableId() uint8
38268 GetConfig() TableConfig
38269 GetProperties() []ITableModProp
38270}
38271
38272func (self *TableDesc) GetLength() uint16 {
38273 return self.Length
38274}
38275
38276func (self *TableDesc) SetLength(v uint16) {
38277 self.Length = v
38278}
38279
38280func (self *TableDesc) GetTableId() uint8 {
38281 return self.TableId
38282}
38283
38284func (self *TableDesc) SetTableId(v uint8) {
38285 self.TableId = v
38286}
38287
38288func (self *TableDesc) GetConfig() TableConfig {
38289 return self.Config
38290}
38291
38292func (self *TableDesc) SetConfig(v TableConfig) {
38293 self.Config = v
38294}
38295
38296func (self *TableDesc) GetProperties() []ITableModProp {
38297 return self.Properties
38298}
38299
38300func (self *TableDesc) SetProperties(v []ITableModProp) {
38301 self.Properties = v
38302}
38303
38304func (self *TableDesc) Serialize(encoder *goloxi.Encoder) error {
38305 startIndex := len(encoder.Bytes())
38306
38307 encoder.PutUint16(uint16(self.Length))
38308 encoder.PutUint8(uint8(self.TableId))
38309 encoder.Write(bytes.Repeat([]byte{0}, 1))
38310 encoder.PutUint32(uint32(self.Config))
38311 for _, obj := range self.Properties {
38312 if err := obj.Serialize(encoder); err != nil {
38313 return err
38314 }
38315 }
38316 length := len(encoder.Bytes()) - startIndex
38317
38318 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
38319
38320 return nil
38321}
38322func (self *TableDesc) Decode(decoder *goloxi.Decoder) error {
38323 if decoder.Length() < 8 {
38324 return fmt.Errorf("TableDesc packet too short: %d < 8", decoder.Length())
38325 }
38326
38327 self.Length = uint16(decoder.ReadUint16())
38328 oldDecoder := decoder
38329 defer func() { decoder = oldDecoder }()
38330 decoder = decoder.SliceDecoder(int(self.Length), 2+0)
38331 self.TableId = uint8(decoder.ReadByte())
38332 decoder.Skip(1)
38333 self.Config = TableConfig(decoder.ReadUint32())
38334
38335 for decoder.Length() >= 4 {
38336 item, err := DecodeTableModProp(decoder)
38337 if err != nil {
38338 return err
38339 }
38340 if item != nil {
38341 self.Properties = append(self.Properties, item)
38342 }
38343 }
38344
38345 return nil
38346}
38347
38348func NewTableDesc() *TableDesc {
38349 obj := &TableDesc{}
38350 return obj
38351}
38352
38353type TableFeatureProp struct {
38354 Type uint16
38355 Length uint16
38356}
38357
38358type ITableFeatureProp interface {
38359 goloxi.Serializable
38360 GetType() uint16
38361 GetLength() uint16
38362}
38363
38364func (self *TableFeatureProp) GetType() uint16 {
38365 return self.Type
38366}
38367
38368func (self *TableFeatureProp) SetType(v uint16) {
38369 self.Type = v
38370}
38371
38372func (self *TableFeatureProp) GetLength() uint16 {
38373 return self.Length
38374}
38375
38376func (self *TableFeatureProp) SetLength(v uint16) {
38377 self.Length = v
38378}
38379
38380func (self *TableFeatureProp) Serialize(encoder *goloxi.Encoder) error {
38381
38382 encoder.PutUint16(uint16(self.Type))
38383 encoder.PutUint16(uint16(self.Length))
38384
38385 return nil
38386}
38387
38388func DecodeTableFeatureProp(decoder *goloxi.Decoder) (ITableFeatureProp, error) {
38389 _tablefeatureprop := &TableFeatureProp{}
38390 if decoder.Length() < 4 {
38391 return nil, fmt.Errorf("TableFeatureProp packet too short: %d < 4", decoder.Length())
38392 }
38393 _tablefeatureprop.Type = uint16(decoder.ReadUint16())
38394 _tablefeatureprop.Length = uint16(decoder.ReadUint16())
38395 oldDecoder := decoder
38396 defer func() { decoder = oldDecoder }()
38397 decoder = decoder.SliceDecoder(int(_tablefeatureprop.Length), 2+2)
38398
38399 switch _tablefeatureprop.Type {
38400 case 0:
38401 return DecodeTableFeaturePropInstructions(_tablefeatureprop, decoder)
38402 case 1:
38403 return DecodeTableFeaturePropInstructionsMiss(_tablefeatureprop, decoder)
38404 case 2:
38405 return DecodeTableFeaturePropNextTables(_tablefeatureprop, decoder)
38406 case 3:
38407 return DecodeTableFeaturePropNextTablesMiss(_tablefeatureprop, decoder)
38408 case 4:
38409 return DecodeTableFeaturePropWriteActions(_tablefeatureprop, decoder)
38410 case 5:
38411 return DecodeTableFeaturePropWriteActionsMiss(_tablefeatureprop, decoder)
38412 case 6:
38413 return DecodeTableFeaturePropApplyActions(_tablefeatureprop, decoder)
38414 case 7:
38415 return DecodeTableFeaturePropApplyActionsMiss(_tablefeatureprop, decoder)
38416 case 8:
38417 return DecodeTableFeaturePropMatch(_tablefeatureprop, decoder)
38418 case 10:
38419 return DecodeTableFeaturePropWildcards(_tablefeatureprop, decoder)
38420 case 12:
38421 return DecodeTableFeaturePropWriteSetfield(_tablefeatureprop, decoder)
38422 case 13:
38423 return DecodeTableFeaturePropWriteSetfieldMiss(_tablefeatureprop, decoder)
38424 case 14:
38425 return DecodeTableFeaturePropApplySetfield(_tablefeatureprop, decoder)
38426 case 15:
38427 return DecodeTableFeaturePropApplySetfieldMiss(_tablefeatureprop, decoder)
38428 case 16:
38429 return DecodeTableFeaturePropTableSyncFrom(_tablefeatureprop, decoder)
38430 case 18:
38431 return DecodeTableFeaturePropWriteCopyfield(_tablefeatureprop, decoder)
38432 case 19:
38433 return DecodeTableFeaturePropWriteCopyfieldMiss(_tablefeatureprop, decoder)
38434 case 20:
38435 return DecodeTableFeaturePropApplyCopyfield(_tablefeatureprop, decoder)
38436 case 21:
38437 return DecodeTableFeaturePropApplyCopyfieldMiss(_tablefeatureprop, decoder)
38438 case 65534:
38439 return DecodeTableFeaturePropExperimenter(_tablefeatureprop, decoder)
38440 case 65535:
38441 return DecodeTableFeaturePropExperimenterMiss(_tablefeatureprop, decoder)
38442 default:
38443 return nil, fmt.Errorf("Invalid type '%d' for 'TableFeatureProp'", _tablefeatureprop.Type)
38444 }
38445}
38446
38447func NewTableFeatureProp(_type uint16) *TableFeatureProp {
38448 obj := &TableFeatureProp{}
38449 obj.Type = _type
38450 return obj
38451}
38452
38453type TableFeaturePropApplyActions struct {
38454 *TableFeatureProp
38455 ActionIds []IActionId
38456}
38457
38458type ITableFeaturePropApplyActions interface {
38459 ITableFeatureProp
38460 GetActionIds() []IActionId
38461}
38462
38463func (self *TableFeaturePropApplyActions) GetActionIds() []IActionId {
38464 return self.ActionIds
38465}
38466
38467func (self *TableFeaturePropApplyActions) SetActionIds(v []IActionId) {
38468 self.ActionIds = v
38469}
38470
38471func (self *TableFeaturePropApplyActions) Serialize(encoder *goloxi.Encoder) error {
38472 startIndex := len(encoder.Bytes())
38473 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
38474 return err
38475 }
38476
38477 for _, obj := range self.ActionIds {
38478 if err := obj.Serialize(encoder); err != nil {
38479 return err
38480 }
38481 }
38482 length := len(encoder.Bytes()) - startIndex
38483
38484 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
38485
38486 return nil
38487}
38488
38489func DecodeTableFeaturePropApplyActions(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropApplyActions, error) {
38490 _tablefeaturepropapplyactions := &TableFeaturePropApplyActions{TableFeatureProp: parent}
38491
38492 for decoder.Length() >= 4 {
38493 item, err := DecodeActionId(decoder)
38494 if err != nil {
38495 return nil, err
38496 }
38497 if item != nil {
38498 _tablefeaturepropapplyactions.ActionIds = append(_tablefeaturepropapplyactions.ActionIds, item)
38499 }
38500 }
38501 return _tablefeaturepropapplyactions, nil
38502}
38503
38504func NewTableFeaturePropApplyActions() *TableFeaturePropApplyActions {
38505 obj := &TableFeaturePropApplyActions{
38506 TableFeatureProp: NewTableFeatureProp(6),
38507 }
38508 return obj
38509}
38510
38511type TableFeaturePropApplyActionsMiss struct {
38512 *TableFeatureProp
38513 ActionIds []IActionId
38514}
38515
38516type ITableFeaturePropApplyActionsMiss interface {
38517 ITableFeatureProp
38518 GetActionIds() []IActionId
38519}
38520
38521func (self *TableFeaturePropApplyActionsMiss) GetActionIds() []IActionId {
38522 return self.ActionIds
38523}
38524
38525func (self *TableFeaturePropApplyActionsMiss) SetActionIds(v []IActionId) {
38526 self.ActionIds = v
38527}
38528
38529func (self *TableFeaturePropApplyActionsMiss) Serialize(encoder *goloxi.Encoder) error {
38530 startIndex := len(encoder.Bytes())
38531 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
38532 return err
38533 }
38534
38535 for _, obj := range self.ActionIds {
38536 if err := obj.Serialize(encoder); err != nil {
38537 return err
38538 }
38539 }
38540 length := len(encoder.Bytes()) - startIndex
38541
38542 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
38543
38544 return nil
38545}
38546
38547func DecodeTableFeaturePropApplyActionsMiss(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropApplyActionsMiss, error) {
38548 _tablefeaturepropapplyactionsmiss := &TableFeaturePropApplyActionsMiss{TableFeatureProp: parent}
38549
38550 for decoder.Length() >= 4 {
38551 item, err := DecodeActionId(decoder)
38552 if err != nil {
38553 return nil, err
38554 }
38555 if item != nil {
38556 _tablefeaturepropapplyactionsmiss.ActionIds = append(_tablefeaturepropapplyactionsmiss.ActionIds, item)
38557 }
38558 }
38559 return _tablefeaturepropapplyactionsmiss, nil
38560}
38561
38562func NewTableFeaturePropApplyActionsMiss() *TableFeaturePropApplyActionsMiss {
38563 obj := &TableFeaturePropApplyActionsMiss{
38564 TableFeatureProp: NewTableFeatureProp(7),
38565 }
38566 return obj
38567}
38568
38569type TableFeaturePropApplyCopyfield struct {
38570 *TableFeatureProp
38571 OxmIds []*Uint32
38572}
38573
38574type ITableFeaturePropApplyCopyfield interface {
38575 ITableFeatureProp
38576 GetOxmIds() []*Uint32
38577}
38578
38579func (self *TableFeaturePropApplyCopyfield) GetOxmIds() []*Uint32 {
38580 return self.OxmIds
38581}
38582
38583func (self *TableFeaturePropApplyCopyfield) SetOxmIds(v []*Uint32) {
38584 self.OxmIds = v
38585}
38586
38587func (self *TableFeaturePropApplyCopyfield) Serialize(encoder *goloxi.Encoder) error {
38588 startIndex := len(encoder.Bytes())
38589 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
38590 return err
38591 }
38592
38593 for _, obj := range self.OxmIds {
38594 if err := obj.Serialize(encoder); err != nil {
38595 return err
38596 }
38597 }
38598 length := len(encoder.Bytes()) - startIndex
38599
38600 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
38601
38602 return nil
38603}
38604
38605func DecodeTableFeaturePropApplyCopyfield(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropApplyCopyfield, error) {
38606 _tablefeaturepropapplycopyfield := &TableFeaturePropApplyCopyfield{TableFeatureProp: parent}
38607
38608 for decoder.Length() >= 4 {
38609 item, err := DecodeUint32(decoder)
38610 if err != nil {
38611 return nil, err
38612 }
38613 if item != nil {
38614 _tablefeaturepropapplycopyfield.OxmIds = append(_tablefeaturepropapplycopyfield.OxmIds, item)
38615 }
38616 }
38617 return _tablefeaturepropapplycopyfield, nil
38618}
38619
38620func NewTableFeaturePropApplyCopyfield() *TableFeaturePropApplyCopyfield {
38621 obj := &TableFeaturePropApplyCopyfield{
38622 TableFeatureProp: NewTableFeatureProp(20),
38623 }
38624 return obj
38625}
38626
38627type TableFeaturePropApplyCopyfieldMiss struct {
38628 *TableFeatureProp
38629 OxmIds []*Uint32
38630}
38631
38632type ITableFeaturePropApplyCopyfieldMiss interface {
38633 ITableFeatureProp
38634 GetOxmIds() []*Uint32
38635}
38636
38637func (self *TableFeaturePropApplyCopyfieldMiss) GetOxmIds() []*Uint32 {
38638 return self.OxmIds
38639}
38640
38641func (self *TableFeaturePropApplyCopyfieldMiss) SetOxmIds(v []*Uint32) {
38642 self.OxmIds = v
38643}
38644
38645func (self *TableFeaturePropApplyCopyfieldMiss) Serialize(encoder *goloxi.Encoder) error {
38646 startIndex := len(encoder.Bytes())
38647 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
38648 return err
38649 }
38650
38651 for _, obj := range self.OxmIds {
38652 if err := obj.Serialize(encoder); err != nil {
38653 return err
38654 }
38655 }
38656 length := len(encoder.Bytes()) - startIndex
38657
38658 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
38659
38660 return nil
38661}
38662
38663func DecodeTableFeaturePropApplyCopyfieldMiss(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropApplyCopyfieldMiss, error) {
38664 _tablefeaturepropapplycopyfieldmiss := &TableFeaturePropApplyCopyfieldMiss{TableFeatureProp: parent}
38665
38666 for decoder.Length() >= 4 {
38667 item, err := DecodeUint32(decoder)
38668 if err != nil {
38669 return nil, err
38670 }
38671 if item != nil {
38672 _tablefeaturepropapplycopyfieldmiss.OxmIds = append(_tablefeaturepropapplycopyfieldmiss.OxmIds, item)
38673 }
38674 }
38675 return _tablefeaturepropapplycopyfieldmiss, nil
38676}
38677
38678func NewTableFeaturePropApplyCopyfieldMiss() *TableFeaturePropApplyCopyfieldMiss {
38679 obj := &TableFeaturePropApplyCopyfieldMiss{
38680 TableFeatureProp: NewTableFeatureProp(21),
38681 }
38682 return obj
38683}
38684
38685type TableFeaturePropApplySetfield struct {
38686 *TableFeatureProp
38687 OxmIds []*Uint32
38688}
38689
38690type ITableFeaturePropApplySetfield interface {
38691 ITableFeatureProp
38692 GetOxmIds() []*Uint32
38693}
38694
38695func (self *TableFeaturePropApplySetfield) GetOxmIds() []*Uint32 {
38696 return self.OxmIds
38697}
38698
38699func (self *TableFeaturePropApplySetfield) SetOxmIds(v []*Uint32) {
38700 self.OxmIds = v
38701}
38702
38703func (self *TableFeaturePropApplySetfield) Serialize(encoder *goloxi.Encoder) error {
38704 startIndex := len(encoder.Bytes())
38705 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
38706 return err
38707 }
38708
38709 for _, obj := range self.OxmIds {
38710 if err := obj.Serialize(encoder); err != nil {
38711 return err
38712 }
38713 }
38714 length := len(encoder.Bytes()) - startIndex
38715
38716 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
38717
38718 return nil
38719}
38720
38721func DecodeTableFeaturePropApplySetfield(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropApplySetfield, error) {
38722 _tablefeaturepropapplysetfield := &TableFeaturePropApplySetfield{TableFeatureProp: parent}
38723
38724 for decoder.Length() >= 4 {
38725 item, err := DecodeUint32(decoder)
38726 if err != nil {
38727 return nil, err
38728 }
38729 if item != nil {
38730 _tablefeaturepropapplysetfield.OxmIds = append(_tablefeaturepropapplysetfield.OxmIds, item)
38731 }
38732 }
38733 return _tablefeaturepropapplysetfield, nil
38734}
38735
38736func NewTableFeaturePropApplySetfield() *TableFeaturePropApplySetfield {
38737 obj := &TableFeaturePropApplySetfield{
38738 TableFeatureProp: NewTableFeatureProp(14),
38739 }
38740 return obj
38741}
38742
38743type TableFeaturePropApplySetfieldMiss struct {
38744 *TableFeatureProp
38745 OxmIds []*Uint32
38746}
38747
38748type ITableFeaturePropApplySetfieldMiss interface {
38749 ITableFeatureProp
38750 GetOxmIds() []*Uint32
38751}
38752
38753func (self *TableFeaturePropApplySetfieldMiss) GetOxmIds() []*Uint32 {
38754 return self.OxmIds
38755}
38756
38757func (self *TableFeaturePropApplySetfieldMiss) SetOxmIds(v []*Uint32) {
38758 self.OxmIds = v
38759}
38760
38761func (self *TableFeaturePropApplySetfieldMiss) Serialize(encoder *goloxi.Encoder) error {
38762 startIndex := len(encoder.Bytes())
38763 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
38764 return err
38765 }
38766
38767 for _, obj := range self.OxmIds {
38768 if err := obj.Serialize(encoder); err != nil {
38769 return err
38770 }
38771 }
38772 length := len(encoder.Bytes()) - startIndex
38773
38774 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
38775
38776 return nil
38777}
38778
38779func DecodeTableFeaturePropApplySetfieldMiss(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropApplySetfieldMiss, error) {
38780 _tablefeaturepropapplysetfieldmiss := &TableFeaturePropApplySetfieldMiss{TableFeatureProp: parent}
38781
38782 for decoder.Length() >= 4 {
38783 item, err := DecodeUint32(decoder)
38784 if err != nil {
38785 return nil, err
38786 }
38787 if item != nil {
38788 _tablefeaturepropapplysetfieldmiss.OxmIds = append(_tablefeaturepropapplysetfieldmiss.OxmIds, item)
38789 }
38790 }
38791 return _tablefeaturepropapplysetfieldmiss, nil
38792}
38793
38794func NewTableFeaturePropApplySetfieldMiss() *TableFeaturePropApplySetfieldMiss {
38795 obj := &TableFeaturePropApplySetfieldMiss{
38796 TableFeatureProp: NewTableFeatureProp(15),
38797 }
38798 return obj
38799}
38800
38801type TableFeaturePropExperimenter struct {
38802 *TableFeatureProp
38803 Experimenter uint32
38804 Subtype uint32
38805}
38806
38807type ITableFeaturePropExperimenter interface {
38808 ITableFeatureProp
38809 GetExperimenter() uint32
38810 GetSubtype() uint32
38811}
38812
38813func (self *TableFeaturePropExperimenter) GetExperimenter() uint32 {
38814 return self.Experimenter
38815}
38816
38817func (self *TableFeaturePropExperimenter) SetExperimenter(v uint32) {
38818 self.Experimenter = v
38819}
38820
38821func (self *TableFeaturePropExperimenter) GetSubtype() uint32 {
38822 return self.Subtype
38823}
38824
38825func (self *TableFeaturePropExperimenter) SetSubtype(v uint32) {
38826 self.Subtype = v
38827}
38828
38829func (self *TableFeaturePropExperimenter) Serialize(encoder *goloxi.Encoder) error {
38830 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
38831 return err
38832 }
38833
38834 encoder.PutUint32(uint32(self.Experimenter))
38835 encoder.PutUint32(uint32(self.Subtype))
38836
38837 return nil
38838}
38839
38840func DecodeTableFeaturePropExperimenter(parent *TableFeatureProp, decoder *goloxi.Decoder) (ITableFeaturePropExperimenter, error) {
38841 _tablefeaturepropexperimenter := &TableFeaturePropExperimenter{TableFeatureProp: parent}
38842 if decoder.Length() < 8 {
38843 return nil, fmt.Errorf("TableFeaturePropExperimenter packet too short: %d < 8", decoder.Length())
38844 }
38845 _tablefeaturepropexperimenter.Experimenter = uint32(decoder.ReadUint32())
38846 _tablefeaturepropexperimenter.Subtype = uint32(decoder.ReadUint32())
38847 return _tablefeaturepropexperimenter, nil
38848}
38849
38850func NewTableFeaturePropExperimenter(_experimenter uint32) *TableFeaturePropExperimenter {
38851 obj := &TableFeaturePropExperimenter{
38852 TableFeatureProp: NewTableFeatureProp(65534),
38853 }
38854 obj.Experimenter = _experimenter
38855 return obj
38856}
38857
38858type TableFeaturePropExperimenterMiss struct {
38859 *TableFeatureProp
38860 Experimenter uint32
38861 Subtype uint32
38862}
38863
38864type ITableFeaturePropExperimenterMiss interface {
38865 ITableFeatureProp
38866 GetExperimenter() uint32
38867 GetSubtype() uint32
38868}
38869
38870func (self *TableFeaturePropExperimenterMiss) GetExperimenter() uint32 {
38871 return self.Experimenter
38872}
38873
38874func (self *TableFeaturePropExperimenterMiss) SetExperimenter(v uint32) {
38875 self.Experimenter = v
38876}
38877
38878func (self *TableFeaturePropExperimenterMiss) GetSubtype() uint32 {
38879 return self.Subtype
38880}
38881
38882func (self *TableFeaturePropExperimenterMiss) SetSubtype(v uint32) {
38883 self.Subtype = v
38884}
38885
38886func (self *TableFeaturePropExperimenterMiss) Serialize(encoder *goloxi.Encoder) error {
38887 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
38888 return err
38889 }
38890
38891 encoder.PutUint32(uint32(self.Experimenter))
38892 encoder.PutUint32(uint32(self.Subtype))
38893
38894 return nil
38895}
38896
38897func DecodeTableFeaturePropExperimenterMiss(parent *TableFeatureProp, decoder *goloxi.Decoder) (ITableFeaturePropExperimenterMiss, error) {
38898 _tablefeaturepropexperimentermiss := &TableFeaturePropExperimenterMiss{TableFeatureProp: parent}
38899 if decoder.Length() < 8 {
38900 return nil, fmt.Errorf("TableFeaturePropExperimenterMiss packet too short: %d < 8", decoder.Length())
38901 }
38902 _tablefeaturepropexperimentermiss.Experimenter = uint32(decoder.ReadUint32())
38903 _tablefeaturepropexperimentermiss.Subtype = uint32(decoder.ReadUint32())
38904 return _tablefeaturepropexperimentermiss, nil
38905}
38906
38907func NewTableFeaturePropExperimenterMiss(_experimenter uint32) *TableFeaturePropExperimenterMiss {
38908 obj := &TableFeaturePropExperimenterMiss{
38909 TableFeatureProp: NewTableFeatureProp(65535),
38910 }
38911 obj.Experimenter = _experimenter
38912 return obj
38913}
38914
38915type TableFeaturePropInstructions struct {
38916 *TableFeatureProp
38917 InstructionIds []IInstructionId
38918}
38919
38920type ITableFeaturePropInstructions interface {
38921 ITableFeatureProp
38922 GetInstructionIds() []IInstructionId
38923}
38924
38925func (self *TableFeaturePropInstructions) GetInstructionIds() []IInstructionId {
38926 return self.InstructionIds
38927}
38928
38929func (self *TableFeaturePropInstructions) SetInstructionIds(v []IInstructionId) {
38930 self.InstructionIds = v
38931}
38932
38933func (self *TableFeaturePropInstructions) Serialize(encoder *goloxi.Encoder) error {
38934 startIndex := len(encoder.Bytes())
38935 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
38936 return err
38937 }
38938
38939 for _, obj := range self.InstructionIds {
38940 if err := obj.Serialize(encoder); err != nil {
38941 return err
38942 }
38943 }
38944 length := len(encoder.Bytes()) - startIndex
38945
38946 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
38947
38948 return nil
38949}
38950
38951func DecodeTableFeaturePropInstructions(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropInstructions, error) {
38952 _tablefeaturepropinstructions := &TableFeaturePropInstructions{TableFeatureProp: parent}
38953
38954 for decoder.Length() >= 4 {
38955 item, err := DecodeInstructionId(decoder)
38956 if err != nil {
38957 return nil, err
38958 }
38959 if item != nil {
38960 _tablefeaturepropinstructions.InstructionIds = append(_tablefeaturepropinstructions.InstructionIds, item)
38961 }
38962 }
38963 return _tablefeaturepropinstructions, nil
38964}
38965
38966func NewTableFeaturePropInstructions() *TableFeaturePropInstructions {
38967 obj := &TableFeaturePropInstructions{
38968 TableFeatureProp: NewTableFeatureProp(0),
38969 }
38970 return obj
38971}
38972
38973type TableFeaturePropInstructionsMiss struct {
38974 *TableFeatureProp
38975 InstructionIds []IInstructionId
38976}
38977
38978type ITableFeaturePropInstructionsMiss interface {
38979 ITableFeatureProp
38980 GetInstructionIds() []IInstructionId
38981}
38982
38983func (self *TableFeaturePropInstructionsMiss) GetInstructionIds() []IInstructionId {
38984 return self.InstructionIds
38985}
38986
38987func (self *TableFeaturePropInstructionsMiss) SetInstructionIds(v []IInstructionId) {
38988 self.InstructionIds = v
38989}
38990
38991func (self *TableFeaturePropInstructionsMiss) Serialize(encoder *goloxi.Encoder) error {
38992 startIndex := len(encoder.Bytes())
38993 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
38994 return err
38995 }
38996
38997 for _, obj := range self.InstructionIds {
38998 if err := obj.Serialize(encoder); err != nil {
38999 return err
39000 }
39001 }
39002 length := len(encoder.Bytes()) - startIndex
39003
39004 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
39005
39006 return nil
39007}
39008
39009func DecodeTableFeaturePropInstructionsMiss(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropInstructionsMiss, error) {
39010 _tablefeaturepropinstructionsmiss := &TableFeaturePropInstructionsMiss{TableFeatureProp: parent}
39011
39012 for decoder.Length() >= 4 {
39013 item, err := DecodeInstructionId(decoder)
39014 if err != nil {
39015 return nil, err
39016 }
39017 if item != nil {
39018 _tablefeaturepropinstructionsmiss.InstructionIds = append(_tablefeaturepropinstructionsmiss.InstructionIds, item)
39019 }
39020 }
39021 return _tablefeaturepropinstructionsmiss, nil
39022}
39023
39024func NewTableFeaturePropInstructionsMiss() *TableFeaturePropInstructionsMiss {
39025 obj := &TableFeaturePropInstructionsMiss{
39026 TableFeatureProp: NewTableFeatureProp(1),
39027 }
39028 return obj
39029}
39030
39031type TableFeaturePropMatch struct {
39032 *TableFeatureProp
39033 OxmIds []*Uint32
39034}
39035
39036type ITableFeaturePropMatch interface {
39037 ITableFeatureProp
39038 GetOxmIds() []*Uint32
39039}
39040
39041func (self *TableFeaturePropMatch) GetOxmIds() []*Uint32 {
39042 return self.OxmIds
39043}
39044
39045func (self *TableFeaturePropMatch) SetOxmIds(v []*Uint32) {
39046 self.OxmIds = v
39047}
39048
39049func (self *TableFeaturePropMatch) Serialize(encoder *goloxi.Encoder) error {
39050 startIndex := len(encoder.Bytes())
39051 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
39052 return err
39053 }
39054
39055 for _, obj := range self.OxmIds {
39056 if err := obj.Serialize(encoder); err != nil {
39057 return err
39058 }
39059 }
39060 length := len(encoder.Bytes()) - startIndex
39061
39062 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
39063
39064 return nil
39065}
39066
39067func DecodeTableFeaturePropMatch(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropMatch, error) {
39068 _tablefeaturepropmatch := &TableFeaturePropMatch{TableFeatureProp: parent}
39069
39070 for decoder.Length() >= 4 {
39071 item, err := DecodeUint32(decoder)
39072 if err != nil {
39073 return nil, err
39074 }
39075 if item != nil {
39076 _tablefeaturepropmatch.OxmIds = append(_tablefeaturepropmatch.OxmIds, item)
39077 }
39078 }
39079 return _tablefeaturepropmatch, nil
39080}
39081
39082func NewTableFeaturePropMatch() *TableFeaturePropMatch {
39083 obj := &TableFeaturePropMatch{
39084 TableFeatureProp: NewTableFeatureProp(8),
39085 }
39086 return obj
39087}
39088
39089type TableFeaturePropNextTables struct {
39090 *TableFeatureProp
39091 NextTableIds []*Uint8
39092}
39093
39094type ITableFeaturePropNextTables interface {
39095 ITableFeatureProp
39096 GetNextTableIds() []*Uint8
39097}
39098
39099func (self *TableFeaturePropNextTables) GetNextTableIds() []*Uint8 {
39100 return self.NextTableIds
39101}
39102
39103func (self *TableFeaturePropNextTables) SetNextTableIds(v []*Uint8) {
39104 self.NextTableIds = v
39105}
39106
39107func (self *TableFeaturePropNextTables) Serialize(encoder *goloxi.Encoder) error {
39108 startIndex := len(encoder.Bytes())
39109 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
39110 return err
39111 }
39112
39113 for _, obj := range self.NextTableIds {
39114 if err := obj.Serialize(encoder); err != nil {
39115 return err
39116 }
39117 }
39118 length := len(encoder.Bytes()) - startIndex
39119
39120 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
39121
39122 return nil
39123}
39124
39125func DecodeTableFeaturePropNextTables(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropNextTables, error) {
39126 _tablefeaturepropnexttables := &TableFeaturePropNextTables{TableFeatureProp: parent}
39127
39128 for decoder.Length() >= 1 {
39129 item, err := DecodeUint8(decoder)
39130 if err != nil {
39131 return nil, err
39132 }
39133 if item != nil {
39134 _tablefeaturepropnexttables.NextTableIds = append(_tablefeaturepropnexttables.NextTableIds, item)
39135 }
39136 }
39137 return _tablefeaturepropnexttables, nil
39138}
39139
39140func NewTableFeaturePropNextTables() *TableFeaturePropNextTables {
39141 obj := &TableFeaturePropNextTables{
39142 TableFeatureProp: NewTableFeatureProp(2),
39143 }
39144 return obj
39145}
39146
39147type TableFeaturePropNextTablesMiss struct {
39148 *TableFeatureProp
39149 NextTableIds []*Uint8
39150}
39151
39152type ITableFeaturePropNextTablesMiss interface {
39153 ITableFeatureProp
39154 GetNextTableIds() []*Uint8
39155}
39156
39157func (self *TableFeaturePropNextTablesMiss) GetNextTableIds() []*Uint8 {
39158 return self.NextTableIds
39159}
39160
39161func (self *TableFeaturePropNextTablesMiss) SetNextTableIds(v []*Uint8) {
39162 self.NextTableIds = v
39163}
39164
39165func (self *TableFeaturePropNextTablesMiss) Serialize(encoder *goloxi.Encoder) error {
39166 startIndex := len(encoder.Bytes())
39167 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
39168 return err
39169 }
39170
39171 for _, obj := range self.NextTableIds {
39172 if err := obj.Serialize(encoder); err != nil {
39173 return err
39174 }
39175 }
39176 length := len(encoder.Bytes()) - startIndex
39177
39178 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
39179
39180 return nil
39181}
39182
39183func DecodeTableFeaturePropNextTablesMiss(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropNextTablesMiss, error) {
39184 _tablefeaturepropnexttablesmiss := &TableFeaturePropNextTablesMiss{TableFeatureProp: parent}
39185
39186 for decoder.Length() >= 1 {
39187 item, err := DecodeUint8(decoder)
39188 if err != nil {
39189 return nil, err
39190 }
39191 if item != nil {
39192 _tablefeaturepropnexttablesmiss.NextTableIds = append(_tablefeaturepropnexttablesmiss.NextTableIds, item)
39193 }
39194 }
39195 return _tablefeaturepropnexttablesmiss, nil
39196}
39197
39198func NewTableFeaturePropNextTablesMiss() *TableFeaturePropNextTablesMiss {
39199 obj := &TableFeaturePropNextTablesMiss{
39200 TableFeatureProp: NewTableFeatureProp(3),
39201 }
39202 return obj
39203}
39204
39205type TableFeaturePropOxmValues struct {
39206 Type uint16
39207 Length uint16
39208 OxmValues []byte
39209}
39210
39211type ITableFeaturePropOxmValues interface {
39212 goloxi.Serializable
39213 GetType() uint16
39214 GetLength() uint16
39215 GetOxmValues() []byte
39216}
39217
39218func (self *TableFeaturePropOxmValues) GetType() uint16 {
39219 return self.Type
39220}
39221
39222func (self *TableFeaturePropOxmValues) SetType(v uint16) {
39223 self.Type = v
39224}
39225
39226func (self *TableFeaturePropOxmValues) GetLength() uint16 {
39227 return self.Length
39228}
39229
39230func (self *TableFeaturePropOxmValues) SetLength(v uint16) {
39231 self.Length = v
39232}
39233
39234func (self *TableFeaturePropOxmValues) GetOxmValues() []byte {
39235 return self.OxmValues
39236}
39237
39238func (self *TableFeaturePropOxmValues) SetOxmValues(v []byte) {
39239 self.OxmValues = v
39240}
39241
39242func (self *TableFeaturePropOxmValues) Serialize(encoder *goloxi.Encoder) error {
39243 startIndex := len(encoder.Bytes())
39244
39245 encoder.PutUint16(uint16(self.Type))
39246 encoder.PutUint16(uint16(self.Length))
39247 encoder.Write(self.OxmValues)
39248 length := len(encoder.Bytes()) - startIndex
39249
39250 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
39251
39252 return nil
39253}
39254
39255func DecodeTableFeaturePropOxmValues(decoder *goloxi.Decoder) (*TableFeaturePropOxmValues, error) {
39256 _tablefeaturepropoxmvalues := &TableFeaturePropOxmValues{}
39257 if decoder.Length() < 4 {
39258 return nil, fmt.Errorf("TableFeaturePropOxmValues packet too short: %d < 4", decoder.Length())
39259 }
39260 _tablefeaturepropoxmvalues.Type = uint16(decoder.ReadUint16())
39261 _tablefeaturepropoxmvalues.Length = uint16(decoder.ReadUint16())
39262 oldDecoder := decoder
39263 defer func() { decoder = oldDecoder }()
39264 decoder = decoder.SliceDecoder(int(_tablefeaturepropoxmvalues.Length), 2+2)
39265 _tablefeaturepropoxmvalues.OxmValues = decoder.Read(int(decoder.Length()))
39266 return _tablefeaturepropoxmvalues, nil
39267}
39268
39269func NewTableFeaturePropOxmValues() *TableFeaturePropOxmValues {
39270 obj := &TableFeaturePropOxmValues{}
39271 return obj
39272}
39273
39274type TableFeaturePropTableSyncFrom struct {
39275 *TableFeatureProp
39276 TableIds []*Uint8
39277}
39278
39279type ITableFeaturePropTableSyncFrom interface {
39280 ITableFeatureProp
39281 GetTableIds() []*Uint8
39282}
39283
39284func (self *TableFeaturePropTableSyncFrom) GetTableIds() []*Uint8 {
39285 return self.TableIds
39286}
39287
39288func (self *TableFeaturePropTableSyncFrom) SetTableIds(v []*Uint8) {
39289 self.TableIds = v
39290}
39291
39292func (self *TableFeaturePropTableSyncFrom) Serialize(encoder *goloxi.Encoder) error {
39293 startIndex := len(encoder.Bytes())
39294 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
39295 return err
39296 }
39297
39298 for _, obj := range self.TableIds {
39299 if err := obj.Serialize(encoder); err != nil {
39300 return err
39301 }
39302 }
39303 length := len(encoder.Bytes()) - startIndex
39304
39305 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
39306
39307 return nil
39308}
39309
39310func DecodeTableFeaturePropTableSyncFrom(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropTableSyncFrom, error) {
39311 _tablefeatureproptablesyncfrom := &TableFeaturePropTableSyncFrom{TableFeatureProp: parent}
39312
39313 for decoder.Length() >= 1 {
39314 item, err := DecodeUint8(decoder)
39315 if err != nil {
39316 return nil, err
39317 }
39318 if item != nil {
39319 _tablefeatureproptablesyncfrom.TableIds = append(_tablefeatureproptablesyncfrom.TableIds, item)
39320 }
39321 }
39322 return _tablefeatureproptablesyncfrom, nil
39323}
39324
39325func NewTableFeaturePropTableSyncFrom() *TableFeaturePropTableSyncFrom {
39326 obj := &TableFeaturePropTableSyncFrom{
39327 TableFeatureProp: NewTableFeatureProp(16),
39328 }
39329 return obj
39330}
39331
39332type TableFeaturePropWildcards struct {
39333 *TableFeatureProp
39334 OxmIds []*Uint32
39335}
39336
39337type ITableFeaturePropWildcards interface {
39338 ITableFeatureProp
39339 GetOxmIds() []*Uint32
39340}
39341
39342func (self *TableFeaturePropWildcards) GetOxmIds() []*Uint32 {
39343 return self.OxmIds
39344}
39345
39346func (self *TableFeaturePropWildcards) SetOxmIds(v []*Uint32) {
39347 self.OxmIds = v
39348}
39349
39350func (self *TableFeaturePropWildcards) Serialize(encoder *goloxi.Encoder) error {
39351 startIndex := len(encoder.Bytes())
39352 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
39353 return err
39354 }
39355
39356 for _, obj := range self.OxmIds {
39357 if err := obj.Serialize(encoder); err != nil {
39358 return err
39359 }
39360 }
39361 length := len(encoder.Bytes()) - startIndex
39362
39363 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
39364
39365 return nil
39366}
39367
39368func DecodeTableFeaturePropWildcards(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropWildcards, error) {
39369 _tablefeaturepropwildcards := &TableFeaturePropWildcards{TableFeatureProp: parent}
39370
39371 for decoder.Length() >= 4 {
39372 item, err := DecodeUint32(decoder)
39373 if err != nil {
39374 return nil, err
39375 }
39376 if item != nil {
39377 _tablefeaturepropwildcards.OxmIds = append(_tablefeaturepropwildcards.OxmIds, item)
39378 }
39379 }
39380 return _tablefeaturepropwildcards, nil
39381}
39382
39383func NewTableFeaturePropWildcards() *TableFeaturePropWildcards {
39384 obj := &TableFeaturePropWildcards{
39385 TableFeatureProp: NewTableFeatureProp(10),
39386 }
39387 return obj
39388}
39389
39390type TableFeaturePropWriteActions struct {
39391 *TableFeatureProp
39392 ActionIds []IActionId
39393}
39394
39395type ITableFeaturePropWriteActions interface {
39396 ITableFeatureProp
39397 GetActionIds() []IActionId
39398}
39399
39400func (self *TableFeaturePropWriteActions) GetActionIds() []IActionId {
39401 return self.ActionIds
39402}
39403
39404func (self *TableFeaturePropWriteActions) SetActionIds(v []IActionId) {
39405 self.ActionIds = v
39406}
39407
39408func (self *TableFeaturePropWriteActions) Serialize(encoder *goloxi.Encoder) error {
39409 startIndex := len(encoder.Bytes())
39410 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
39411 return err
39412 }
39413
39414 for _, obj := range self.ActionIds {
39415 if err := obj.Serialize(encoder); err != nil {
39416 return err
39417 }
39418 }
39419 length := len(encoder.Bytes()) - startIndex
39420
39421 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
39422
39423 return nil
39424}
39425
39426func DecodeTableFeaturePropWriteActions(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropWriteActions, error) {
39427 _tablefeaturepropwriteactions := &TableFeaturePropWriteActions{TableFeatureProp: parent}
39428
39429 for decoder.Length() >= 4 {
39430 item, err := DecodeActionId(decoder)
39431 if err != nil {
39432 return nil, err
39433 }
39434 if item != nil {
39435 _tablefeaturepropwriteactions.ActionIds = append(_tablefeaturepropwriteactions.ActionIds, item)
39436 }
39437 }
39438 return _tablefeaturepropwriteactions, nil
39439}
39440
39441func NewTableFeaturePropWriteActions() *TableFeaturePropWriteActions {
39442 obj := &TableFeaturePropWriteActions{
39443 TableFeatureProp: NewTableFeatureProp(4),
39444 }
39445 return obj
39446}
39447
39448type TableFeaturePropWriteActionsMiss struct {
39449 *TableFeatureProp
39450 ActionIds []IActionId
39451}
39452
39453type ITableFeaturePropWriteActionsMiss interface {
39454 ITableFeatureProp
39455 GetActionIds() []IActionId
39456}
39457
39458func (self *TableFeaturePropWriteActionsMiss) GetActionIds() []IActionId {
39459 return self.ActionIds
39460}
39461
39462func (self *TableFeaturePropWriteActionsMiss) SetActionIds(v []IActionId) {
39463 self.ActionIds = v
39464}
39465
39466func (self *TableFeaturePropWriteActionsMiss) Serialize(encoder *goloxi.Encoder) error {
39467 startIndex := len(encoder.Bytes())
39468 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
39469 return err
39470 }
39471
39472 for _, obj := range self.ActionIds {
39473 if err := obj.Serialize(encoder); err != nil {
39474 return err
39475 }
39476 }
39477 length := len(encoder.Bytes()) - startIndex
39478
39479 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
39480
39481 return nil
39482}
39483
39484func DecodeTableFeaturePropWriteActionsMiss(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropWriteActionsMiss, error) {
39485 _tablefeaturepropwriteactionsmiss := &TableFeaturePropWriteActionsMiss{TableFeatureProp: parent}
39486
39487 for decoder.Length() >= 4 {
39488 item, err := DecodeActionId(decoder)
39489 if err != nil {
39490 return nil, err
39491 }
39492 if item != nil {
39493 _tablefeaturepropwriteactionsmiss.ActionIds = append(_tablefeaturepropwriteactionsmiss.ActionIds, item)
39494 }
39495 }
39496 return _tablefeaturepropwriteactionsmiss, nil
39497}
39498
39499func NewTableFeaturePropWriteActionsMiss() *TableFeaturePropWriteActionsMiss {
39500 obj := &TableFeaturePropWriteActionsMiss{
39501 TableFeatureProp: NewTableFeatureProp(5),
39502 }
39503 return obj
39504}
39505
39506type TableFeaturePropWriteCopyfield struct {
39507 *TableFeatureProp
39508 OxmIds []*Uint32
39509}
39510
39511type ITableFeaturePropWriteCopyfield interface {
39512 ITableFeatureProp
39513 GetOxmIds() []*Uint32
39514}
39515
39516func (self *TableFeaturePropWriteCopyfield) GetOxmIds() []*Uint32 {
39517 return self.OxmIds
39518}
39519
39520func (self *TableFeaturePropWriteCopyfield) SetOxmIds(v []*Uint32) {
39521 self.OxmIds = v
39522}
39523
39524func (self *TableFeaturePropWriteCopyfield) Serialize(encoder *goloxi.Encoder) error {
39525 startIndex := len(encoder.Bytes())
39526 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
39527 return err
39528 }
39529
39530 for _, obj := range self.OxmIds {
39531 if err := obj.Serialize(encoder); err != nil {
39532 return err
39533 }
39534 }
39535 length := len(encoder.Bytes()) - startIndex
39536
39537 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
39538
39539 return nil
39540}
39541
39542func DecodeTableFeaturePropWriteCopyfield(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropWriteCopyfield, error) {
39543 _tablefeaturepropwritecopyfield := &TableFeaturePropWriteCopyfield{TableFeatureProp: parent}
39544
39545 for decoder.Length() >= 4 {
39546 item, err := DecodeUint32(decoder)
39547 if err != nil {
39548 return nil, err
39549 }
39550 if item != nil {
39551 _tablefeaturepropwritecopyfield.OxmIds = append(_tablefeaturepropwritecopyfield.OxmIds, item)
39552 }
39553 }
39554 return _tablefeaturepropwritecopyfield, nil
39555}
39556
39557func NewTableFeaturePropWriteCopyfield() *TableFeaturePropWriteCopyfield {
39558 obj := &TableFeaturePropWriteCopyfield{
39559 TableFeatureProp: NewTableFeatureProp(18),
39560 }
39561 return obj
39562}
39563
39564type TableFeaturePropWriteCopyfieldMiss struct {
39565 *TableFeatureProp
39566 OxmIds []*Uint32
39567}
39568
39569type ITableFeaturePropWriteCopyfieldMiss interface {
39570 ITableFeatureProp
39571 GetOxmIds() []*Uint32
39572}
39573
39574func (self *TableFeaturePropWriteCopyfieldMiss) GetOxmIds() []*Uint32 {
39575 return self.OxmIds
39576}
39577
39578func (self *TableFeaturePropWriteCopyfieldMiss) SetOxmIds(v []*Uint32) {
39579 self.OxmIds = v
39580}
39581
39582func (self *TableFeaturePropWriteCopyfieldMiss) Serialize(encoder *goloxi.Encoder) error {
39583 startIndex := len(encoder.Bytes())
39584 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
39585 return err
39586 }
39587
39588 for _, obj := range self.OxmIds {
39589 if err := obj.Serialize(encoder); err != nil {
39590 return err
39591 }
39592 }
39593 length := len(encoder.Bytes()) - startIndex
39594
39595 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
39596
39597 return nil
39598}
39599
39600func DecodeTableFeaturePropWriteCopyfieldMiss(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropWriteCopyfieldMiss, error) {
39601 _tablefeaturepropwritecopyfieldmiss := &TableFeaturePropWriteCopyfieldMiss{TableFeatureProp: parent}
39602
39603 for decoder.Length() >= 4 {
39604 item, err := DecodeUint32(decoder)
39605 if err != nil {
39606 return nil, err
39607 }
39608 if item != nil {
39609 _tablefeaturepropwritecopyfieldmiss.OxmIds = append(_tablefeaturepropwritecopyfieldmiss.OxmIds, item)
39610 }
39611 }
39612 return _tablefeaturepropwritecopyfieldmiss, nil
39613}
39614
39615func NewTableFeaturePropWriteCopyfieldMiss() *TableFeaturePropWriteCopyfieldMiss {
39616 obj := &TableFeaturePropWriteCopyfieldMiss{
39617 TableFeatureProp: NewTableFeatureProp(19),
39618 }
39619 return obj
39620}
39621
39622type TableFeaturePropWriteSetfield struct {
39623 *TableFeatureProp
39624 OxmIds []*Uint32
39625}
39626
39627type ITableFeaturePropWriteSetfield interface {
39628 ITableFeatureProp
39629 GetOxmIds() []*Uint32
39630}
39631
39632func (self *TableFeaturePropWriteSetfield) GetOxmIds() []*Uint32 {
39633 return self.OxmIds
39634}
39635
39636func (self *TableFeaturePropWriteSetfield) SetOxmIds(v []*Uint32) {
39637 self.OxmIds = v
39638}
39639
39640func (self *TableFeaturePropWriteSetfield) Serialize(encoder *goloxi.Encoder) error {
39641 startIndex := len(encoder.Bytes())
39642 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
39643 return err
39644 }
39645
39646 for _, obj := range self.OxmIds {
39647 if err := obj.Serialize(encoder); err != nil {
39648 return err
39649 }
39650 }
39651 length := len(encoder.Bytes()) - startIndex
39652
39653 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
39654
39655 return nil
39656}
39657
39658func DecodeTableFeaturePropWriteSetfield(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropWriteSetfield, error) {
39659 _tablefeaturepropwritesetfield := &TableFeaturePropWriteSetfield{TableFeatureProp: parent}
39660
39661 for decoder.Length() >= 4 {
39662 item, err := DecodeUint32(decoder)
39663 if err != nil {
39664 return nil, err
39665 }
39666 if item != nil {
39667 _tablefeaturepropwritesetfield.OxmIds = append(_tablefeaturepropwritesetfield.OxmIds, item)
39668 }
39669 }
39670 return _tablefeaturepropwritesetfield, nil
39671}
39672
39673func NewTableFeaturePropWriteSetfield() *TableFeaturePropWriteSetfield {
39674 obj := &TableFeaturePropWriteSetfield{
39675 TableFeatureProp: NewTableFeatureProp(12),
39676 }
39677 return obj
39678}
39679
39680type TableFeaturePropWriteSetfieldMiss struct {
39681 *TableFeatureProp
39682 OxmIds []*Uint32
39683}
39684
39685type ITableFeaturePropWriteSetfieldMiss interface {
39686 ITableFeatureProp
39687 GetOxmIds() []*Uint32
39688}
39689
39690func (self *TableFeaturePropWriteSetfieldMiss) GetOxmIds() []*Uint32 {
39691 return self.OxmIds
39692}
39693
39694func (self *TableFeaturePropWriteSetfieldMiss) SetOxmIds(v []*Uint32) {
39695 self.OxmIds = v
39696}
39697
39698func (self *TableFeaturePropWriteSetfieldMiss) Serialize(encoder *goloxi.Encoder) error {
39699 startIndex := len(encoder.Bytes())
39700 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
39701 return err
39702 }
39703
39704 for _, obj := range self.OxmIds {
39705 if err := obj.Serialize(encoder); err != nil {
39706 return err
39707 }
39708 }
39709 length := len(encoder.Bytes()) - startIndex
39710
39711 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
39712
39713 return nil
39714}
39715
39716func DecodeTableFeaturePropWriteSetfieldMiss(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropWriteSetfieldMiss, error) {
39717 _tablefeaturepropwritesetfieldmiss := &TableFeaturePropWriteSetfieldMiss{TableFeatureProp: parent}
39718
39719 for decoder.Length() >= 4 {
39720 item, err := DecodeUint32(decoder)
39721 if err != nil {
39722 return nil, err
39723 }
39724 if item != nil {
39725 _tablefeaturepropwritesetfieldmiss.OxmIds = append(_tablefeaturepropwritesetfieldmiss.OxmIds, item)
39726 }
39727 }
39728 return _tablefeaturepropwritesetfieldmiss, nil
39729}
39730
39731func NewTableFeaturePropWriteSetfieldMiss() *TableFeaturePropWriteSetfieldMiss {
39732 obj := &TableFeaturePropWriteSetfieldMiss{
39733 TableFeatureProp: NewTableFeatureProp(13),
39734 }
39735 return obj
39736}
39737
39738type TableFeatures struct {
39739 Length uint16
39740 TableId uint8
39741 Command TableFeaturesCommand
39742 Features TableFeatureFlag
39743 Name string
39744 MetadataMatch uint64
39745 MetadataWrite uint64
39746 Capabilities TableConfig
39747 MaxEntries uint32
39748 Properties []ITableFeatureProp
39749}
39750
39751type ITableFeatures interface {
39752 goloxi.Serializable
39753 GetLength() uint16
39754 GetTableId() uint8
39755 GetCommand() TableFeaturesCommand
39756 GetFeatures() TableFeatureFlag
39757 GetName() string
39758 GetMetadataMatch() uint64
39759 GetMetadataWrite() uint64
39760 GetCapabilities() TableConfig
39761 GetMaxEntries() uint32
39762 GetProperties() []ITableFeatureProp
39763}
39764
39765func (self *TableFeatures) GetLength() uint16 {
39766 return self.Length
39767}
39768
39769func (self *TableFeatures) SetLength(v uint16) {
39770 self.Length = v
39771}
39772
39773func (self *TableFeatures) GetTableId() uint8 {
39774 return self.TableId
39775}
39776
39777func (self *TableFeatures) SetTableId(v uint8) {
39778 self.TableId = v
39779}
39780
39781func (self *TableFeatures) GetCommand() TableFeaturesCommand {
39782 return self.Command
39783}
39784
39785func (self *TableFeatures) SetCommand(v TableFeaturesCommand) {
39786 self.Command = v
39787}
39788
39789func (self *TableFeatures) GetFeatures() TableFeatureFlag {
39790 return self.Features
39791}
39792
39793func (self *TableFeatures) SetFeatures(v TableFeatureFlag) {
39794 self.Features = v
39795}
39796
39797func (self *TableFeatures) GetName() string {
39798 return self.Name
39799}
39800
39801func (self *TableFeatures) SetName(v string) {
39802 self.Name = v
39803}
39804
39805func (self *TableFeatures) GetMetadataMatch() uint64 {
39806 return self.MetadataMatch
39807}
39808
39809func (self *TableFeatures) SetMetadataMatch(v uint64) {
39810 self.MetadataMatch = v
39811}
39812
39813func (self *TableFeatures) GetMetadataWrite() uint64 {
39814 return self.MetadataWrite
39815}
39816
39817func (self *TableFeatures) SetMetadataWrite(v uint64) {
39818 self.MetadataWrite = v
39819}
39820
39821func (self *TableFeatures) GetCapabilities() TableConfig {
39822 return self.Capabilities
39823}
39824
39825func (self *TableFeatures) SetCapabilities(v TableConfig) {
39826 self.Capabilities = v
39827}
39828
39829func (self *TableFeatures) GetMaxEntries() uint32 {
39830 return self.MaxEntries
39831}
39832
39833func (self *TableFeatures) SetMaxEntries(v uint32) {
39834 self.MaxEntries = v
39835}
39836
39837func (self *TableFeatures) GetProperties() []ITableFeatureProp {
39838 return self.Properties
39839}
39840
39841func (self *TableFeatures) SetProperties(v []ITableFeatureProp) {
39842 self.Properties = v
39843}
39844
39845func (self *TableFeatures) Serialize(encoder *goloxi.Encoder) error {
39846 startIndex := len(encoder.Bytes())
39847
39848 encoder.PutUint16(uint16(self.Length))
39849 encoder.PutUint8(uint8(self.TableId))
39850 encoder.PutUint8(uint8(self.Command))
39851 encoder.PutUint32(uint32(self.Features))
39852 encoder.Write([]byte(self.Name))
39853 encoder.PutUint64(uint64(self.MetadataMatch))
39854 encoder.PutUint64(uint64(self.MetadataWrite))
39855 encoder.PutUint32(uint32(self.Capabilities))
39856 encoder.PutUint32(uint32(self.MaxEntries))
39857 for _, obj := range self.Properties {
39858 if err := obj.Serialize(encoder); err != nil {
39859 return err
39860 }
39861 }
39862 length := len(encoder.Bytes()) - startIndex
39863
39864 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
39865
39866 return nil
39867}
39868
39869func DecodeTableFeatures(decoder *goloxi.Decoder) (*TableFeatures, error) {
39870 _tablefeatures := &TableFeatures{}
39871 if decoder.Length() < 64 {
39872 return nil, fmt.Errorf("TableFeatures packet too short: %d < 64", decoder.Length())
39873 }
39874 _tablefeatures.Length = uint16(decoder.ReadUint16())
39875 oldDecoder := decoder
39876 defer func() { decoder = oldDecoder }()
39877 decoder = decoder.SliceDecoder(int(_tablefeatures.Length), 2+0)
39878 _tablefeatures.TableId = uint8(decoder.ReadByte())
39879 _tablefeatures.Command = TableFeaturesCommand(decoder.ReadByte())
39880 _tablefeatures.Features = TableFeatureFlag(decoder.ReadUint32())
39881 _tablefeatures.Name = string(bytes.Trim(decoder.Read(32), "\x00"))
39882 _tablefeatures.MetadataMatch = uint64(decoder.ReadUint64())
39883 _tablefeatures.MetadataWrite = uint64(decoder.ReadUint64())
39884 _tablefeatures.Capabilities = TableConfig(decoder.ReadUint32())
39885 _tablefeatures.MaxEntries = uint32(decoder.ReadUint32())
39886
39887 for decoder.Length() >= 4 {
39888 item, err := DecodeTableFeatureProp(decoder)
39889 if err != nil {
39890 return nil, err
39891 }
39892 if item != nil {
39893 _tablefeatures.Properties = append(_tablefeatures.Properties, item)
39894 }
39895 }
39896 return _tablefeatures, nil
39897}
39898
39899func NewTableFeatures() *TableFeatures {
39900 obj := &TableFeatures{}
39901 return obj
39902}
39903
39904type TableModProp struct {
39905 Type uint16
39906 Length uint16
39907}
39908
39909type ITableModProp interface {
39910 goloxi.Serializable
39911 GetType() uint16
39912 GetLength() uint16
39913}
39914
39915func (self *TableModProp) GetType() uint16 {
39916 return self.Type
39917}
39918
39919func (self *TableModProp) SetType(v uint16) {
39920 self.Type = v
39921}
39922
39923func (self *TableModProp) GetLength() uint16 {
39924 return self.Length
39925}
39926
39927func (self *TableModProp) SetLength(v uint16) {
39928 self.Length = v
39929}
39930
39931func (self *TableModProp) Serialize(encoder *goloxi.Encoder) error {
39932
39933 encoder.PutUint16(uint16(self.Type))
39934 encoder.PutUint16(uint16(self.Length))
39935
39936 return nil
39937}
39938
39939func DecodeTableModProp(decoder *goloxi.Decoder) (ITableModProp, error) {
39940 _tablemodprop := &TableModProp{}
39941 if decoder.Length() < 4 {
39942 return nil, fmt.Errorf("TableModProp packet too short: %d < 4", decoder.Length())
39943 }
39944 _tablemodprop.Type = uint16(decoder.ReadUint16())
39945 _tablemodprop.Length = uint16(decoder.ReadUint16())
39946 oldDecoder := decoder
39947 defer func() { decoder = oldDecoder }()
39948 decoder = decoder.SliceDecoder(int(_tablemodprop.Length), 2+2)
39949
39950 switch _tablemodprop.Type {
39951 case 2:
39952 return DecodeTableModPropEviction(_tablemodprop, decoder)
39953 case 3:
39954 return DecodeTableModPropVacancy(_tablemodprop, decoder)
39955 case 65535:
39956 return DecodeTableModPropExperimenter(_tablemodprop, decoder)
39957 default:
39958 return nil, fmt.Errorf("Invalid type '%d' for 'TableModProp'", _tablemodprop.Type)
39959 }
39960}
39961
39962func NewTableModProp(_type uint16) *TableModProp {
39963 obj := &TableModProp{}
39964 obj.Type = _type
39965 return obj
39966}
39967
39968type TableModPropEviction struct {
39969 *TableModProp
39970 Flags TableModPropEvictionFlag
39971}
39972
39973type ITableModPropEviction interface {
39974 ITableModProp
39975 GetFlags() TableModPropEvictionFlag
39976}
39977
39978func (self *TableModPropEviction) GetFlags() TableModPropEvictionFlag {
39979 return self.Flags
39980}
39981
39982func (self *TableModPropEviction) SetFlags(v TableModPropEvictionFlag) {
39983 self.Flags = v
39984}
39985
39986func (self *TableModPropEviction) Serialize(encoder *goloxi.Encoder) error {
39987 startIndex := len(encoder.Bytes())
39988 if err := self.TableModProp.Serialize(encoder); err != nil {
39989 return err
39990 }
39991
39992 encoder.PutUint32(uint32(self.Flags))
39993 length := len(encoder.Bytes()) - startIndex
39994
39995 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
39996
39997 return nil
39998}
39999
40000func DecodeTableModPropEviction(parent *TableModProp, decoder *goloxi.Decoder) (*TableModPropEviction, error) {
40001 _tablemodpropeviction := &TableModPropEviction{TableModProp: parent}
40002 if decoder.Length() < 4 {
40003 return nil, fmt.Errorf("TableModPropEviction packet too short: %d < 4", decoder.Length())
40004 }
40005 _tablemodpropeviction.Flags = TableModPropEvictionFlag(decoder.ReadUint32())
40006 return _tablemodpropeviction, nil
40007}
40008
40009func NewTableModPropEviction() *TableModPropEviction {
40010 obj := &TableModPropEviction{
40011 TableModProp: NewTableModProp(2),
40012 }
40013 return obj
40014}
40015
40016type TableModPropExperimenter struct {
40017 *TableModProp
40018 Experimenter uint32
40019 ExpType uint32
40020}
40021
40022type ITableModPropExperimenter interface {
40023 ITableModProp
40024 GetExperimenter() uint32
40025 GetExpType() uint32
40026}
40027
40028func (self *TableModPropExperimenter) GetExperimenter() uint32 {
40029 return self.Experimenter
40030}
40031
40032func (self *TableModPropExperimenter) SetExperimenter(v uint32) {
40033 self.Experimenter = v
40034}
40035
40036func (self *TableModPropExperimenter) GetExpType() uint32 {
40037 return self.ExpType
40038}
40039
40040func (self *TableModPropExperimenter) SetExpType(v uint32) {
40041 self.ExpType = v
40042}
40043
40044func (self *TableModPropExperimenter) Serialize(encoder *goloxi.Encoder) error {
40045 if err := self.TableModProp.Serialize(encoder); err != nil {
40046 return err
40047 }
40048
40049 encoder.PutUint32(uint32(self.Experimenter))
40050 encoder.PutUint32(uint32(self.ExpType))
40051
40052 return nil
40053}
40054
40055func DecodeTableModPropExperimenter(parent *TableModProp, decoder *goloxi.Decoder) (ITableModPropExperimenter, error) {
40056 _tablemodpropexperimenter := &TableModPropExperimenter{TableModProp: parent}
40057 if decoder.Length() < 8 {
40058 return nil, fmt.Errorf("TableModPropExperimenter packet too short: %d < 8", decoder.Length())
40059 }
40060 _tablemodpropexperimenter.Experimenter = uint32(decoder.ReadUint32())
40061 _tablemodpropexperimenter.ExpType = uint32(decoder.ReadUint32())
40062 return _tablemodpropexperimenter, nil
40063}
40064
40065func NewTableModPropExperimenter(_experimenter uint32) *TableModPropExperimenter {
40066 obj := &TableModPropExperimenter{
40067 TableModProp: NewTableModProp(65535),
40068 }
40069 obj.Experimenter = _experimenter
40070 return obj
40071}
40072
40073type TableModPropVacancy struct {
40074 *TableModProp
40075 VacancyDown uint8
40076 VacancyUp uint8
40077 Vacancy uint8
40078}
40079
40080type ITableModPropVacancy interface {
40081 ITableModProp
40082 GetVacancyDown() uint8
40083 GetVacancyUp() uint8
40084 GetVacancy() uint8
40085}
40086
40087func (self *TableModPropVacancy) GetVacancyDown() uint8 {
40088 return self.VacancyDown
40089}
40090
40091func (self *TableModPropVacancy) SetVacancyDown(v uint8) {
40092 self.VacancyDown = v
40093}
40094
40095func (self *TableModPropVacancy) GetVacancyUp() uint8 {
40096 return self.VacancyUp
40097}
40098
40099func (self *TableModPropVacancy) SetVacancyUp(v uint8) {
40100 self.VacancyUp = v
40101}
40102
40103func (self *TableModPropVacancy) GetVacancy() uint8 {
40104 return self.Vacancy
40105}
40106
40107func (self *TableModPropVacancy) SetVacancy(v uint8) {
40108 self.Vacancy = v
40109}
40110
40111func (self *TableModPropVacancy) Serialize(encoder *goloxi.Encoder) error {
40112 startIndex := len(encoder.Bytes())
40113 if err := self.TableModProp.Serialize(encoder); err != nil {
40114 return err
40115 }
40116
40117 encoder.PutUint8(uint8(self.VacancyDown))
40118 encoder.PutUint8(uint8(self.VacancyUp))
40119 encoder.PutUint8(uint8(self.Vacancy))
40120 encoder.Write(bytes.Repeat([]byte{0}, 1))
40121 length := len(encoder.Bytes()) - startIndex
40122
40123 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
40124
40125 return nil
40126}
40127
40128func DecodeTableModPropVacancy(parent *TableModProp, decoder *goloxi.Decoder) (*TableModPropVacancy, error) {
40129 _tablemodpropvacancy := &TableModPropVacancy{TableModProp: parent}
40130 if decoder.Length() < 4 {
40131 return nil, fmt.Errorf("TableModPropVacancy packet too short: %d < 4", decoder.Length())
40132 }
40133 _tablemodpropvacancy.VacancyDown = uint8(decoder.ReadByte())
40134 _tablemodpropvacancy.VacancyUp = uint8(decoder.ReadByte())
40135 _tablemodpropvacancy.Vacancy = uint8(decoder.ReadByte())
40136 decoder.Skip(1)
40137 return _tablemodpropvacancy, nil
40138}
40139
40140func NewTableModPropVacancy() *TableModPropVacancy {
40141 obj := &TableModPropVacancy{
40142 TableModProp: NewTableModProp(3),
40143 }
40144 return obj
40145}
40146
40147type TableStatsEntry struct {
40148 TableId uint8
40149 ActiveCount uint32
40150 LookupCount uint64
40151 MatchedCount uint64
40152}
40153
40154type ITableStatsEntry interface {
40155 goloxi.Serializable
40156 GetTableId() uint8
40157 GetActiveCount() uint32
40158 GetLookupCount() uint64
40159 GetMatchedCount() uint64
40160}
40161
40162func (self *TableStatsEntry) GetTableId() uint8 {
40163 return self.TableId
40164}
40165
40166func (self *TableStatsEntry) SetTableId(v uint8) {
40167 self.TableId = v
40168}
40169
40170func (self *TableStatsEntry) GetActiveCount() uint32 {
40171 return self.ActiveCount
40172}
40173
40174func (self *TableStatsEntry) SetActiveCount(v uint32) {
40175 self.ActiveCount = v
40176}
40177
40178func (self *TableStatsEntry) GetLookupCount() uint64 {
40179 return self.LookupCount
40180}
40181
40182func (self *TableStatsEntry) SetLookupCount(v uint64) {
40183 self.LookupCount = v
40184}
40185
40186func (self *TableStatsEntry) GetMatchedCount() uint64 {
40187 return self.MatchedCount
40188}
40189
40190func (self *TableStatsEntry) SetMatchedCount(v uint64) {
40191 self.MatchedCount = v
40192}
40193
40194func (self *TableStatsEntry) Serialize(encoder *goloxi.Encoder) error {
40195
40196 encoder.PutUint8(uint8(self.TableId))
40197 encoder.Write(bytes.Repeat([]byte{0}, 3))
40198 encoder.PutUint32(uint32(self.ActiveCount))
40199 encoder.PutUint64(uint64(self.LookupCount))
40200 encoder.PutUint64(uint64(self.MatchedCount))
40201
40202 return nil
40203}
40204
40205func DecodeTableStatsEntry(decoder *goloxi.Decoder) (*TableStatsEntry, error) {
40206 _tablestatsentry := &TableStatsEntry{}
40207 if decoder.Length() < 24 {
40208 return nil, fmt.Errorf("TableStatsEntry packet too short: %d < 24", decoder.Length())
40209 }
40210 _tablestatsentry.TableId = uint8(decoder.ReadByte())
40211 decoder.Skip(3)
40212 _tablestatsentry.ActiveCount = uint32(decoder.ReadUint32())
40213 _tablestatsentry.LookupCount = uint64(decoder.ReadUint64())
40214 _tablestatsentry.MatchedCount = uint64(decoder.ReadUint64())
40215 return _tablestatsentry, nil
40216}
40217
40218func NewTableStatsEntry() *TableStatsEntry {
40219 obj := &TableStatsEntry{}
40220 return obj
40221}
40222
40223type Uint32 struct {
40224 Value uint32
40225}
40226
40227type IUint32 interface {
40228 goloxi.Serializable
40229 GetValue() uint32
40230}
40231
40232func (self *Uint32) GetValue() uint32 {
40233 return self.Value
40234}
40235
40236func (self *Uint32) SetValue(v uint32) {
40237 self.Value = v
40238}
40239
40240func (self *Uint32) Serialize(encoder *goloxi.Encoder) error {
40241
40242 encoder.PutUint32(uint32(self.Value))
40243
40244 return nil
40245}
40246
40247func DecodeUint32(decoder *goloxi.Decoder) (*Uint32, error) {
40248 _uint32 := &Uint32{}
40249 if decoder.Length() < 4 {
40250 return nil, fmt.Errorf("Uint32 packet too short: %d < 4", decoder.Length())
40251 }
40252 _uint32.Value = uint32(decoder.ReadUint32())
40253 return _uint32, nil
40254}
40255
40256func NewUint32() *Uint32 {
40257 obj := &Uint32{}
40258 return obj
40259}
40260
40261type Uint64 struct {
40262 Value uint64
40263}
40264
40265type IUint64 interface {
40266 goloxi.Serializable
40267 GetValue() uint64
40268}
40269
40270func (self *Uint64) GetValue() uint64 {
40271 return self.Value
40272}
40273
40274func (self *Uint64) SetValue(v uint64) {
40275 self.Value = v
40276}
40277
40278func (self *Uint64) Serialize(encoder *goloxi.Encoder) error {
40279
40280 encoder.PutUint64(uint64(self.Value))
40281
40282 return nil
40283}
40284
40285func DecodeUint64(decoder *goloxi.Decoder) (*Uint64, error) {
40286 _uint64 := &Uint64{}
40287 if decoder.Length() < 8 {
40288 return nil, fmt.Errorf("Uint64 packet too short: %d < 8", decoder.Length())
40289 }
40290 _uint64.Value = uint64(decoder.ReadUint64())
40291 return _uint64, nil
40292}
40293
40294func NewUint64() *Uint64 {
40295 obj := &Uint64{}
40296 return obj
40297}
40298
40299type Uint8 struct {
40300 Value uint8
40301}
40302
40303type IUint8 interface {
40304 goloxi.Serializable
40305 GetValue() uint8
40306}
40307
40308func (self *Uint8) GetValue() uint8 {
40309 return self.Value
40310}
40311
40312func (self *Uint8) SetValue(v uint8) {
40313 self.Value = v
40314}
40315
40316func (self *Uint8) Serialize(encoder *goloxi.Encoder) error {
40317
40318 encoder.PutUint8(uint8(self.Value))
40319
40320 return nil
40321}
40322
40323func DecodeUint8(decoder *goloxi.Decoder) (*Uint8, error) {
40324 _uint8 := &Uint8{}
40325 if decoder.Length() < 1 {
40326 return nil, fmt.Errorf("Uint8 packet too short: %d < 1", decoder.Length())
40327 }
40328 _uint8.Value = uint8(decoder.ReadByte())
40329 return _uint8, nil
40330}
40331
40332func NewUint8() *Uint8 {
40333 obj := &Uint8{}
40334 return obj
40335}
40336
40337type ActionCopyField struct {
40338 Type uint16
40339 Len uint16
40340 NBits uint16
40341 SrcOffset uint16
40342 DstOffset uint16
40343 OxmIds []goloxi.IOxm
40344}
40345
40346type IActionCopyField interface {
40347 goloxi.Serializable
40348 GetType() uint16
40349 GetLen() uint16
40350 GetNBits() uint16
40351 GetSrcOffset() uint16
40352 GetDstOffset() uint16
40353 GetOxmIds() []goloxi.IOxm
40354}
40355
40356func (self *ActionCopyField) GetType() uint16 {
40357 return self.Type
40358}
40359
40360func (self *ActionCopyField) SetType(v uint16) {
40361 self.Type = v
40362}
40363
40364func (self *ActionCopyField) GetLen() uint16 {
40365 return self.Len
40366}
40367
40368func (self *ActionCopyField) SetLen(v uint16) {
40369 self.Len = v
40370}
40371
40372func (self *ActionCopyField) GetNBits() uint16 {
40373 return self.NBits
40374}
40375
40376func (self *ActionCopyField) SetNBits(v uint16) {
40377 self.NBits = v
40378}
40379
40380func (self *ActionCopyField) GetSrcOffset() uint16 {
40381 return self.SrcOffset
40382}
40383
40384func (self *ActionCopyField) SetSrcOffset(v uint16) {
40385 self.SrcOffset = v
40386}
40387
40388func (self *ActionCopyField) GetDstOffset() uint16 {
40389 return self.DstOffset
40390}
40391
40392func (self *ActionCopyField) SetDstOffset(v uint16) {
40393 self.DstOffset = v
40394}
40395
40396func (self *ActionCopyField) GetOxmIds() []goloxi.IOxm {
40397 return self.OxmIds
40398}
40399
40400func (self *ActionCopyField) SetOxmIds(v []goloxi.IOxm) {
40401 self.OxmIds = v
40402}
40403
40404func (self *ActionCopyField) Serialize(encoder *goloxi.Encoder) error {
40405 startIndex := len(encoder.Bytes())
40406
40407 encoder.PutUint16(uint16(self.Type))
40408 encoder.PutUint16(uint16(self.Len))
40409 encoder.PutUint16(uint16(self.NBits))
40410 encoder.PutUint16(uint16(self.SrcOffset))
40411 encoder.PutUint16(uint16(self.DstOffset))
40412 encoder.Write(bytes.Repeat([]byte{0}, 2))
40413 for _, obj := range self.OxmIds {
40414 if err := obj.Serialize(encoder); err != nil {
40415 return err
40416 }
40417 }
40418 length := len(encoder.Bytes()) - startIndex
40419
40420 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
40421
40422 return nil
40423}
40424
40425func DecodeActionCopyField(decoder *goloxi.Decoder) (*ActionCopyField, error) {
40426 _actioncopyfield := &ActionCopyField{}
40427 if decoder.Length() < 12 {
40428 return nil, fmt.Errorf("ActionCopyField packet too short: %d < 12", decoder.Length())
40429 }
40430 _actioncopyfield.Type = uint16(decoder.ReadUint16())
40431 _actioncopyfield.Len = uint16(decoder.ReadUint16())
40432 oldDecoder := decoder
40433 defer func() { decoder = oldDecoder }()
40434 decoder = decoder.SliceDecoder(int(_actioncopyfield.Len), 2+2)
40435 _actioncopyfield.NBits = uint16(decoder.ReadUint16())
40436 _actioncopyfield.SrcOffset = uint16(decoder.ReadUint16())
40437 _actioncopyfield.DstOffset = uint16(decoder.ReadUint16())
40438 decoder.Skip(2)
40439
40440 for decoder.Length() >= 4 {
40441 item, err := DecodeOxm(decoder)
40442 if err != nil {
40443 return nil, err
40444 }
40445 if item != nil {
40446 _actioncopyfield.OxmIds = append(_actioncopyfield.OxmIds, item)
40447 }
40448 }
40449 return _actioncopyfield, nil
40450}
40451
40452func NewActionCopyField() *ActionCopyField {
40453 obj := &ActionCopyField{}
40454 return obj
40455}
40456
40457type ControllerStatusPropExperimenter struct {
40458 *ControllerStatusProp
40459 Experimenter uint32
40460 ExpType uint32
40461}
40462
40463type IControllerStatusPropExperimenter interface {
40464 IControllerStatusProp
40465 GetExperimenter() uint32
40466 GetExpType() uint32
40467}
40468
40469func (self *ControllerStatusPropExperimenter) GetExperimenter() uint32 {
40470 return self.Experimenter
40471}
40472
40473func (self *ControllerStatusPropExperimenter) SetExperimenter(v uint32) {
40474 self.Experimenter = v
40475}
40476
40477func (self *ControllerStatusPropExperimenter) GetExpType() uint32 {
40478 return self.ExpType
40479}
40480
40481func (self *ControllerStatusPropExperimenter) SetExpType(v uint32) {
40482 self.ExpType = v
40483}
40484
40485func (self *ControllerStatusPropExperimenter) Serialize(encoder *goloxi.Encoder) error {
40486 if err := self.ControllerStatusProp.Serialize(encoder); err != nil {
40487 return err
40488 }
40489
40490 encoder.PutUint32(uint32(self.Experimenter))
40491 encoder.PutUint32(uint32(self.ExpType))
40492
40493 return nil
40494}
40495
40496func DecodeControllerStatusPropExperimenter(parent *ControllerStatusProp, decoder *goloxi.Decoder) (IControllerStatusPropExperimenter, error) {
40497 _controllerstatuspropexperimenter := &ControllerStatusPropExperimenter{ControllerStatusProp: parent}
40498 if decoder.Length() < 8 {
40499 return nil, fmt.Errorf("ControllerStatusPropExperimenter packet too short: %d < 8", decoder.Length())
40500 }
40501 _controllerstatuspropexperimenter.Experimenter = uint32(decoder.ReadUint32())
40502 _controllerstatuspropexperimenter.ExpType = uint32(decoder.ReadUint32())
40503 return _controllerstatuspropexperimenter, nil
40504}
40505
40506func NewControllerStatusPropExperimenter(_experimenter uint32) *ControllerStatusPropExperimenter {
40507 obj := &ControllerStatusPropExperimenter{
40508 ControllerStatusProp: NewControllerStatusProp(65535),
40509 }
40510 obj.Experimenter = _experimenter
40511 return obj
40512}
40513
40514type ControllerStatusPropUri struct {
40515 *ControllerStatusProp
40516 Uri *ControllerURI
40517}
40518
40519type IControllerStatusPropUri interface {
40520 IControllerStatusProp
40521 GetUri() *ControllerURI
40522}
40523
40524func (self *ControllerStatusPropUri) GetUri() *ControllerURI {
40525 return self.Uri
40526}
40527
40528func (self *ControllerStatusPropUri) SetUri(v *ControllerURI) {
40529 self.Uri = v
40530}
40531
40532func (self *ControllerStatusPropUri) Serialize(encoder *goloxi.Encoder) error {
40533 startIndex := len(encoder.Bytes())
40534 if err := self.ControllerStatusProp.Serialize(encoder); err != nil {
40535 return err
40536 }
40537
40538 self.Uri.Serialize(encoder)
40539 length := len(encoder.Bytes()) - startIndex
40540
40541 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
40542
40543 return nil
40544}
40545
40546func DecodeControllerStatusPropUri(parent *ControllerStatusProp, decoder *goloxi.Decoder) (*ControllerStatusPropUri, error) {
40547 _controllerstatuspropuri := &ControllerStatusPropUri{ControllerStatusProp: parent}
40548 if decoder.Length() < 32 {
40549 return nil, fmt.Errorf("ControllerStatusPropUri packet too short: %d < 32", decoder.Length())
40550 }
40551 _controllerstatuspropuri.Uri.Decode(decoder)
40552 return _controllerstatuspropuri, nil
40553}
40554
40555func NewControllerStatusPropUri() *ControllerStatusPropUri {
40556 obj := &ControllerStatusPropUri{
40557 ControllerStatusProp: NewControllerStatusProp(0),
40558 }
40559 return obj
40560}
40561
40562type PortDescPropRecirculate struct {
40563 Type uint16
40564 Length uint16
40565 PortNos []byte
40566}
40567
40568type IPortDescPropRecirculate interface {
40569 goloxi.Serializable
40570 GetType() uint16
40571 GetLength() uint16
40572 GetPortNos() []byte
40573}
40574
40575func (self *PortDescPropRecirculate) GetType() uint16 {
40576 return self.Type
40577}
40578
40579func (self *PortDescPropRecirculate) SetType(v uint16) {
40580 self.Type = v
40581}
40582
40583func (self *PortDescPropRecirculate) GetLength() uint16 {
40584 return self.Length
40585}
40586
40587func (self *PortDescPropRecirculate) SetLength(v uint16) {
40588 self.Length = v
40589}
40590
40591func (self *PortDescPropRecirculate) GetPortNos() []byte {
40592 return self.PortNos
40593}
40594
40595func (self *PortDescPropRecirculate) SetPortNos(v []byte) {
40596 self.PortNos = v
40597}
40598
40599func (self *PortDescPropRecirculate) Serialize(encoder *goloxi.Encoder) error {
40600 startIndex := len(encoder.Bytes())
40601
40602 encoder.PutUint16(uint16(self.Type))
40603 encoder.PutUint16(uint16(self.Length))
40604 encoder.Write(self.PortNos)
40605 length := len(encoder.Bytes()) - startIndex
40606
40607 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
40608
40609 return nil
40610}
40611
40612func DecodePortDescPropRecirculate(decoder *goloxi.Decoder) (*PortDescPropRecirculate, error) {
40613 _portdescproprecirculate := &PortDescPropRecirculate{}
40614 if decoder.Length() < 4 {
40615 return nil, fmt.Errorf("PortDescPropRecirculate packet too short: %d < 4", decoder.Length())
40616 }
40617 _portdescproprecirculate.Type = uint16(decoder.ReadUint16())
40618 _portdescproprecirculate.Length = uint16(decoder.ReadUint16())
40619 oldDecoder := decoder
40620 defer func() { decoder = oldDecoder }()
40621 decoder = decoder.SliceDecoder(int(_portdescproprecirculate.Length), 2+2)
40622 _portdescproprecirculate.PortNos = decoder.Read(int(decoder.Length()))
40623 return _portdescproprecirculate, nil
40624}
40625
40626func NewPortDescPropRecirculate() *PortDescPropRecirculate {
40627 obj := &PortDescPropRecirculate{}
40628 return obj
40629}