Gitiles
Code Review Sign In
gerrit.opencord.org / ofagent-go / 98fd88136b83e8f6b95820580bcb7dee33ee5245 / . / vendor / github.com / skydive-project / goloxi / of13 / common.go
blob: 3ac2db77b9d40bffe9e28fdb2b5d5fb59b1817c4 [file] [log] [blame]
Don Newton98fd8812019-09-23 15:15:02 -0400[diff] [blame^]1/*
2 * Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
3 * Copyright (c) 2011, 2012 Open Networking Foundation
4 * Copyright 2013, Big Switch Networks, Inc. This library was generated by the LoxiGen Compiler.
5 * Copyright 2018, Red Hat, Inc.
6 */
7// Automatically generated by LOXI from template module.go
8// Do not modify
9
10package of13
11
12import (
13 "bytes"
14 "encoding/binary"
15 "fmt"
16 "net"
17
18 "github.com/skydive-project/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 203780:
187 return DecodeOxmIdBsnUdf6(_oxmid, decoder)
188 case 2147492866:
189 return DecodeOxmIdSctpDst(_oxmid, decoder)
190 case 2147493889:
191 return DecodeOxmIdIcmpv4Code(_oxmid, decoder)
192 case 117240:
193 return DecodeOxmIdTunMetadata60Masked(_oxmid, decoder)
194 case 200196:
195 return DecodeOxmIdBsnEgrPortGroupId(_oxmid, decoder)
196 case 128288:
197 return DecodeOxmIdConnTrackingIpv6SrcMasked(_oxmid, decoder)
198 case 89212:
199 return DecodeOxmIdTunMetadata6(_oxmid, decoder)
200 case 8196:
201 return DecodeOxmIdArpSpa(_oxmid, decoder)
202 case 76801:
203 return DecodeOxmIdIcmpv6Code(_oxmid, decoder)
204 case 118264:
205 return DecodeOxmIdTunMetadata62Masked(_oxmid, decoder)
206 case 70148:
207 return DecodeOxmIdReg9(_oxmid, decoder)
208 case 119560:
209 return DecodeOxmIdConnTrackingStateMasked(_oxmid, decoder)
210 case 90236:
211 return DecodeOxmIdTunMetadata8(_oxmid, decoder)
212 case 119044:
213 return DecodeOxmIdTunFlagsMasked(_oxmid, decoder)
214 case 82696:
215 return DecodeOxmIdPktMarkMasked(_oxmid, decoder)
216 case 4294923528:
217 return DecodeOxmIdOvsTcpFlagsMasked(_oxmid, decoder)
218 case 120584:
219 return DecodeOxmIdConnTrackingMarkMasked(_oxmid, decoder)
220 case 91260:
221 return DecodeOxmIdTunMetadata10(_oxmid, decoder)
222 case 87032:
223 return DecodeOxmIdTunMetadata1Masked(_oxmid, decoder)
224 case 126722:
225 return DecodeOxmIdConnTrackingNwProtoMasked(_oxmid, decoder)
226 case 206852:
227 return DecodeOxmIdBsnIngressPortGroupId(_oxmid, decoder)
228 case 208898:
229 return DecodeOxmIdBsnInnerVlanVid(_oxmid, decoder)
230 case 209921:
231 return DecodeOxmIdBsnIpFragmentation(_oxmid, decoder)
232 case 196896:
233 return DecodeOxmIdBsnInPorts128Masked(_oxmid, decoder)
234 case 92284:
235 return DecodeOxmIdTunMetadata12(_oxmid, decoder)
236 case 88056:
237 return DecodeOxmIdTunMetadata3Masked(_oxmid, decoder)
238 case 79873:
239 return DecodeOxmIdNwEcn(_oxmid, decoder)
240 case 196624:
241 return DecodeOxmIdBsnInPorts128(_oxmid, decoder)
242 case 200456:
243 return DecodeOxmIdBsnEgrPortGroupIdMasked(_oxmid, decoder)
244 case 2147489284:
245 return DecodeOxmIdIpv4Src(_oxmid, decoder)
246 case 93308:
247 return DecodeOxmIdTunMetadata14(_oxmid, decoder)
248 case 115192:
249 return DecodeOxmIdTunMetadata56Masked(_oxmid, decoder)
250 case 2561:
251 return DecodeOxmIdNwTos(_oxmid, decoder)
252 case 129538:
253 return DecodeOxmIdConnTrackingTpDst(_oxmid, decoder)
254 case 2147500550:
255 return DecodeOxmIdIpv6NdTll(_oxmid, decoder)
256 case 84484:
257 return DecodeOxmIdConjId(_oxmid, decoder)
258 case 74246:
259 return DecodeOxmIdArpSha(_oxmid, decoder)
260 case 85762:
261 return DecodeOxmIdTunGbpFlagsMasked(_oxmid, decoder)
262 case 123408:
263 return DecodeOxmIdXxreg2(_oxmid, decoder)
264 case 90104:
265 return DecodeOxmIdTunMetadata7Masked(_oxmid, decoder)
266 case 2147486468:
267 return DecodeOxmIdEthTypeMasked(_oxmid, decoder)
268 case 70408:
269 return DecodeOxmIdReg9Masked(_oxmid, decoder)
270 case 91128:
271 return DecodeOxmIdTunMetadata9Masked(_oxmid, decoder)
272 case 83720:
273 return DecodeOxmIdDpHashMasked(_oxmid, decoder)
274 case 2147497988:
275 return DecodeOxmIdIpv6Flabel(_oxmid, decoder)
276 case 78603:
277 return DecodeOxmIdNdTllMasked(_oxmid, decoder)
278 case 2147503376:
279 return DecodeOxmIdTunnelIdMasked(_oxmid, decoder)
280 case 96380:
281 return DecodeOxmIdTunMetadata20(_oxmid, decoder)
282 case 92152:
283 return DecodeOxmIdTunMetadata11Masked(_oxmid, decoder)
284 case 129796:
285 return DecodeOxmIdConnTrackingTpDstMasked(_oxmid, decoder)
286 case 2147502081:
287 return DecodeOxmIdMplsBos(_oxmid, decoder)
288 case 97404:
289 return DecodeOxmIdTunMetadata22(_oxmid, decoder)
290 case 93176:
291 return DecodeOxmIdTunMetadata13Masked(_oxmid, decoder)
292 case 94844:
293 return DecodeOxmIdTunMetadata17(_oxmid, decoder)
294 case 81924:
295 return DecodeOxmIdTunnelIpv4Dst(_oxmid, decoder)
296 case 127752:
297 return DecodeOxmIdConnTrackingNwDstMasked(_oxmid, decoder)
298 case 98428:
299 return DecodeOxmIdTunMetadata24(_oxmid, decoder)
300 case 94200:
301 return DecodeOxmIdTunMetadata15Masked(_oxmid, decoder)
302 case 2147501060:
303 return DecodeOxmIdMplsLabel(_oxmid, decoder)
304 case 84994:
305 return DecodeOxmIdTunGbpId(_oxmid, decoder)
306 case 71432:
307 return DecodeOxmIdReg11Masked(_oxmid, decoder)
308 case 99452:
309 return DecodeOxmIdTunMetadata26(_oxmid, decoder)
310 case 95224:
311 return DecodeOxmIdTunMetadata17Masked(_oxmid, decoder)
312 case 2147500038:
313 return DecodeOxmIdIpv6NdSll(_oxmid, decoder)
314 case 83972:
315 return DecodeOxmIdRecircId(_oxmid, decoder)
316 case 128800:
317 return DecodeOxmIdConnTrackingIpv6DstMasked(_oxmid, decoder)
318 case 72196:
319 return DecodeOxmIdReg13(_oxmid, decoder)
320 case 100476:
321 return DecodeOxmIdTunMetadata28(_oxmid, decoder)
322 case 96248:
323 return DecodeOxmIdTunMetadata19Masked(_oxmid, decoder)
324 case 2147488514:
325 return DecodeOxmIdIpEcnMasked(_oxmid, decoder)
326 case 112764:
327 return DecodeOxmIdTunMetadata52(_oxmid, decoder)
328 case 101500:
329 return DecodeOxmIdTunMetadata30(_oxmid, decoder)
330 case 97272:
331 return DecodeOxmIdTunMetadata21Masked(_oxmid, decoder)
332 case 2147498754:
333 return DecodeOxmIdIcmpv6TypeMasked(_oxmid, decoder)
334 case 209668:
335 return DecodeOxmIdBsnVfiMasked(_oxmid, decoder)
336 case 2147484424:
337 return DecodeOxmIdInPhyPortMasked(_oxmid, decoder)
338 case 74507:
339 return DecodeOxmIdArpShaMasked(_oxmid, decoder)
340 case 2147500812:
341 return DecodeOxmIdIpv6NdTllMasked(_oxmid, decoder)
342 case 197384:
343 return DecodeOxmIdBsnLagIdMasked(_oxmid, decoder)
344 case 76064:
345 return DecodeOxmIdIpv6DstMasked(_oxmid, decoder)
346 case 102524:
347 return DecodeOxmIdTunMetadata32(_oxmid, decoder)
348 case 98296:
349 return DecodeOxmIdTunMetadata23Masked(_oxmid, decoder)
350 case 4868:
351 return DecodeOxmIdTcpSrcMasked(_oxmid, decoder)
352 case 121632:
353 return DecodeOxmIdTunIpv6SrcMasked(_oxmid, decoder)
354 case 75792:
355 return DecodeOxmIdIpv6Dst(_oxmid, decoder)
356 case 202504:
357 return DecodeOxmIdBsnUdf3Masked(_oxmid, decoder)
358 case 120324:
359 return DecodeOxmIdConnTrackingMark(_oxmid, decoder)
360 case 99320:
361 return DecodeOxmIdTunMetadata25Masked(_oxmid, decoder)
362 case 65800:
363 return DecodeOxmIdReg0Masked(_oxmid, decoder)
364 case 66824:
365 return DecodeOxmIdReg2Masked(_oxmid, decoder)
366 case 72456:
367 return DecodeOxmIdReg13Masked(_oxmid, decoder)
368 case 68360:
369 return DecodeOxmIdReg5Masked(_oxmid, decoder)
370 case 104572:
371 return DecodeOxmIdTunMetadata36(_oxmid, decoder)
372 case 95356:
373 return DecodeOxmIdTunMetadata18(_oxmid, decoder)
374 case 100344:
375 return DecodeOxmIdTunMetadata27Masked(_oxmid, decoder)
376 case 4294923270:
377 return DecodeOxmIdOvsTcpFlags(_oxmid, decoder)
378 case 779:
379 return DecodeOxmIdEthDstMasked(_oxmid, decoder)
380 case 69384:
381 return DecodeOxmIdReg7Masked(_oxmid, decoder)
382 case 105596:
383 return DecodeOxmIdTunMetadata38(_oxmid, decoder)
384 case 101368:
385 return DecodeOxmIdTunMetadata29Masked(_oxmid, decoder)
386 case 2147493634:
387 return DecodeOxmIdIcmpv4TypeMasked(_oxmid, decoder)
388 case 108668:
389 return DecodeOxmIdTunMetadata44(_oxmid, decoder)
390 case 201480:
391 return DecodeOxmIdBsnUdf1Masked(_oxmid, decoder)
392 case 106620:
393 return DecodeOxmIdTunMetadata40(_oxmid, decoder)
394 case 102392:
395 return DecodeOxmIdTunMetadata31Masked(_oxmid, decoder)
396 case 2147492612:
397 return DecodeOxmIdSctpSrcMasked(_oxmid, decoder)
398 case 72708:
399 return DecodeOxmIdReg14(_oxmid, decoder)
400 case 73480:
401 return DecodeOxmIdReg15Masked(_oxmid, decoder)
402 case 204292:
403 return DecodeOxmIdBsnUdf7(_oxmid, decoder)
404 case 2147489544:
405 return DecodeOxmIdIpv4SrcMasked(_oxmid, decoder)
406 case 107644:
407 return DecodeOxmIdTunMetadata42(_oxmid, decoder)
408 case 103416:
409 return DecodeOxmIdTunMetadata33Masked(_oxmid, decoder)
410 case 2147498248:
411 return DecodeOxmIdIpv6FlabelMasked(_oxmid, decoder)
412 case 203528:
413 return DecodeOxmIdBsnUdf5Masked(_oxmid, decoder)
414 case 89592:
415 return DecodeOxmIdTunMetadata6Masked(_oxmid, decoder)
416 case 104440:
417 return DecodeOxmIdTunMetadata35Masked(_oxmid, decoder)
418 case 2147494660:
419 return DecodeOxmIdArpOpMasked(_oxmid, decoder)
420 case 197636:
421 return DecodeOxmIdBsnVrf(_oxmid, decoder)
422 case 204552:
423 return DecodeOxmIdBsnUdf7Masked(_oxmid, decoder)
424 case 109692:
425 return DecodeOxmIdTunMetadata46(_oxmid, decoder)
426 case 105464:
427 return DecodeOxmIdTunMetadata37Masked(_oxmid, decoder)
428 case 89080:
429 return DecodeOxmIdTunMetadata5Masked(_oxmid, decoder)
430 case 67588:
431 return DecodeOxmIdReg4(_oxmid, decoder)
432 case 7169:
433 return DecodeOxmIdIcmpCode(_oxmid, decoder)
434 case 82946:
435 return DecodeOxmIdTcpFlags(_oxmid, decoder)
436 case 199684:
437 return DecodeOxmIdBsnL3DstClassId(_oxmid, decoder)
438 case 207878:
439 return DecodeOxmIdBsnInnerEthDst(_oxmid, decoder)
440 case 198145:
441 return DecodeOxmIdBsnGlobalVrfAllowed(_oxmid, decoder)
442 case 2147484680:
443 return DecodeOxmIdMetadata(_oxmid, decoder)
444 case 1538:
445 return DecodeOxmIdEthType(_oxmid, decoder)
446 case 8968:
447 return DecodeOxmIdArpTpaMasked(_oxmid, decoder)
448 case 128016:
449 return DecodeOxmIdConnTrackingIpv6Src(_oxmid, decoder)
450 case 110716:
451 return DecodeOxmIdTunMetadata48(_oxmid, decoder)
452 case 127492:
453 return DecodeOxmIdConnTrackingNwDst(_oxmid, decoder)
454 case 78342:
455 return DecodeOxmIdNdTll(_oxmid, decoder)
456 case 111740:
457 return DecodeOxmIdTunMetadata50(_oxmid, decoder)
458 case 107512:
459 return DecodeOxmIdTunMetadata41Masked(_oxmid, decoder)
460 case 207624:
461 return DecodeOxmIdBsnVxlanNetworkIdMasked(_oxmid, decoder)
462 case 121360:
463 return DecodeOxmIdTunIpv6Src(_oxmid, decoder)
464 case 113788:
465 return DecodeOxmIdTunMetadata54(_oxmid, decoder)
466 case 109560:
467 return DecodeOxmIdTunMetadata45Masked(_oxmid, decoder)
468 case 2147501826:
469 return DecodeOxmIdMplsTcMasked(_oxmid, decoder)
470 case 103548:
471 return DecodeOxmIdTunMetadata34(_oxmid, decoder)
472 case 2147484164:
473 return DecodeOxmIdInPhyPort(_oxmid, decoder)
474 case 205316:
475 return DecodeOxmIdBsnVlanXlatePortGroupId(_oxmid, decoder)
476 case 114812:
477 return DecodeOxmIdTunMetadata56(_oxmid, decoder)
478 case 2147487233:
479 return DecodeOxmIdVlanPcp(_oxmid, decoder)
480 case 110584:
481 return DecodeOxmIdTunMetadata47Masked(_oxmid, decoder)
482 case 79624:
483 return DecodeOxmIdIpv6LabelMasked(_oxmid, decoder)
484 case 115836:
485 return DecodeOxmIdTunMetadata58(_oxmid, decoder)
486 case 2147488257:
487 return DecodeOxmIdIpEcn(_oxmid, decoder)
488 case 111608:
489 return DecodeOxmIdTunMetadata49Masked(_oxmid, decoder)
490 case 518:
491 return DecodeOxmIdEthDst(_oxmid, decoder)
492 case 68100:
493 return DecodeOxmIdReg5(_oxmid, decoder)
494 case 116860:
495 return DecodeOxmIdTunMetadata60(_oxmid, decoder)
496 case 4610:
497 return DecodeOxmIdTcpSrc(_oxmid, decoder)
498 case 112632:
499 return DecodeOxmIdTunMetadata51Masked(_oxmid, decoder)
500 case 122384:
501 return DecodeOxmIdXxreg0(_oxmid, decoder)
502 case 123680:
503 return DecodeOxmIdXxreg2Masked(_oxmid, decoder)
504 case 69124:
505 return DecodeOxmIdReg7(_oxmid, decoder)
506 case 117884:
507 return DecodeOxmIdTunMetadata62(_oxmid, decoder)
508 case 5634:
509 return DecodeOxmIdUdpSrc(_oxmid, decoder)
510 case 6657:
511 return DecodeOxmIdIcmpType(_oxmid, decoder)
512 case 113656:
513 return DecodeOxmIdTunMetadata53Masked(_oxmid, decoder)
514 case 2147503876:
515 return DecodeOxmIdIpv6ExthdrMasked(_oxmid, decoder)
516 case 198920:
517 return DecodeOxmIdBsnL3InterfaceClassIdMasked(_oxmid, decoder)
518 case 2147489026:
519 return DecodeOxmIdIpProtoMasked(_oxmid, decoder)
520 case 120068:
521 return DecodeOxmIdConnTrackingZoneMasked(_oxmid, decoder)
522 case 1286:
523 return DecodeOxmIdEthSrcMasked(_oxmid, decoder)
524 case 204040:
525 return DecodeOxmIdBsnUdf6Masked(_oxmid, decoder)
526 case 75019:
527 return DecodeOxmIdArpThaMasked(_oxmid, decoder)
528 case 208140:
529 return DecodeOxmIdBsnInnerEthDstMasked(_oxmid, decoder)
530 case 201220:
531 return DecodeOxmIdBsnUdf1(_oxmid, decoder)
532 case 205576:
533 return DecodeOxmIdBsnVlanXlatePortGroupIdMasked(_oxmid, decoder)
534 case 2147484944:
535 return DecodeOxmIdMetadataMasked(_oxmid, decoder)
536 case 6146:
537 return DecodeOxmIdUdpDst(_oxmid, decoder)
538 case 114680:
539 return DecodeOxmIdTunMetadata55Masked(_oxmid, decoder)
540 case 122144:
541 return DecodeOxmIdTunIpv6DstMasked(_oxmid, decoder)
542 case 86652:
543 return DecodeOxmIdTunMetadata1(_oxmid, decoder)
544 case 202244:
545 return DecodeOxmIdBsnUdf3(_oxmid, decoder)
546 case 115704:
547 return DecodeOxmIdTunMetadata57Masked(_oxmid, decoder)
548 case 69636:
549 return DecodeOxmIdReg8(_oxmid, decoder)
550 case 87676:
551 return DecodeOxmIdTunMetadata3(_oxmid, decoder)
552 case 82184:
553 return DecodeOxmIdTunnelIpv4DstMasked(_oxmid, decoder)
554 case 203268:
555 return DecodeOxmIdBsnUdf5(_oxmid, decoder)
556 case 2147492354:
557 return DecodeOxmIdSctpSrc(_oxmid, decoder)
558 case 2147493377:
559 return DecodeOxmIdIcmpv4Type(_oxmid, decoder)
560 case 116728:
561 return DecodeOxmIdTunMetadata59Masked(_oxmid, decoder)
562 case 88700:
563 return DecodeOxmIdTunMetadata5(_oxmid, decoder)
564 case 73220:
565 return DecodeOxmIdReg15(_oxmid, decoder)
566 case 76289:
567 return DecodeOxmIdIcmpv6Type(_oxmid, decoder)
568 case 117752:
569 return DecodeOxmIdTunMetadata61Masked(_oxmid, decoder)
570 case 4360:
571 return DecodeOxmIdIpDstMasked(_oxmid, decoder)
572 case 89724:
573 return DecodeOxmIdTunMetadata7(_oxmid, decoder)
574 case 8708:
575 return DecodeOxmIdArpTpa(_oxmid, decoder)
576 case 118776:
577 return DecodeOxmIdTunMetadata63Masked(_oxmid, decoder)
578 case 199944:
579 return DecodeOxmIdBsnL3DstClassIdMasked(_oxmid, decoder)
580 case 90748:
581 return DecodeOxmIdTunMetadata9(_oxmid, decoder)
582 case 86520:
583 return DecodeOxmIdTunMetadata0Masked(_oxmid, decoder)
584 case 2147487490:
585 return DecodeOxmIdVlanPcpMasked(_oxmid, decoder)
586 case 2147501320:
587 return DecodeOxmIdMplsLabelMasked(_oxmid, decoder)
588 case 197124:
589 return DecodeOxmIdBsnLagId(_oxmid, decoder)
590 case 78849:
591 return DecodeOxmIdIpFrag(_oxmid, decoder)
592 case 200708:
593 return DecodeOxmIdBsnUdf0(_oxmid, decoder)
594 case 91772:
595 return DecodeOxmIdTunMetadata11(_oxmid, decoder)
596 case 87544:
597 return DecodeOxmIdTunMetadata2Masked(_oxmid, decoder)
598 case 207364:
599 return DecodeOxmIdBsnVxlanNetworkId(_oxmid, decoder)
600 case 209410:
601 return DecodeOxmIdBsnVfi(_oxmid, decoder)
602 case 92796:
603 return DecodeOxmIdTunMetadata13(_oxmid, decoder)
604 case 88568:
605 return DecodeOxmIdTunMetadata4Masked(_oxmid, decoder)
606 case 80385:
607 return DecodeOxmIdNwTtl(_oxmid, decoder)
608 case 105976:
609 return DecodeOxmIdTunMetadata38Masked(_oxmid, decoder)
610 case 126465:
611 return DecodeOxmIdConnTrackingNwProto(_oxmid, decoder)
612 case 7682:
613 return DecodeOxmIdArpOp(_oxmid, decoder)
614 case 71172:
615 return DecodeOxmIdReg11(_oxmid, decoder)
616 case 208390:
617 return DecodeOxmIdBsnInnerEthSrc(_oxmid, decoder)
618 case 210178:
619 return DecodeOxmIdBsnIpFragmentationMasked(_oxmid, decoder)
620 case 128528:
621 return DecodeOxmIdConnTrackingIpv6Dst(_oxmid, decoder)
622 case 85252:
623 return DecodeOxmIdTunGbpIdMasked(_oxmid, decoder)
624 case 90616:
625 return DecodeOxmIdTunMetadata8Masked(_oxmid, decoder)
626 case 79364:
627 return DecodeOxmIdIpv6Label(_oxmid, decoder)
628 case 207112:
629 return DecodeOxmIdBsnIngressPortGroupIdMasked(_oxmid, decoder)
630 case 206400:
631 return DecodeOxmIdBsnInPorts512(_oxmid, decoder)
632 case 95868:
633 return DecodeOxmIdTunMetadata19(_oxmid, decoder)
634 case 91640:
635 return DecodeOxmIdTunMetadata10Masked(_oxmid, decoder)
636 case 2147501569:
637 return DecodeOxmIdMplsTc(_oxmid, decoder)
638 case 70920:
639 return DecodeOxmIdReg10Masked(_oxmid, decoder)
640 case 96892:
641 return DecodeOxmIdTunMetadata21(_oxmid, decoder)
642 case 92664:
643 return DecodeOxmIdTunMetadata12Masked(_oxmid, decoder)
644 case 205060:
645 return DecodeOxmIdBsnTcpFlagsMasked(_oxmid, decoder)
646 case 81412:
647 return DecodeOxmIdTunnelIpv4Src(_oxmid, decoder)
648 case 99964:
649 return DecodeOxmIdTunMetadata27(_oxmid, decoder)
650 case 71684:
651 return DecodeOxmIdReg12(_oxmid, decoder)
652 case 127240:
653 return DecodeOxmIdConnTrackingNwSrcMasked(_oxmid, decoder)
654 case 97916:
655 return DecodeOxmIdTunMetadata23(_oxmid, decoder)
656 case 93688:
657 return DecodeOxmIdTunMetadata14Masked(_oxmid, decoder)
658 case 82436:
659 return DecodeOxmIdPktMark(_oxmid, decoder)
660 case 85505:
661 return DecodeOxmIdTunGbpFlags(_oxmid, decoder)
662 case 98940:
663 return DecodeOxmIdTunMetadata25(_oxmid, decoder)
664 case 94712:
665 return DecodeOxmIdTunMetadata16Masked(_oxmid, decoder)
666 case 83460:
667 return DecodeOxmIdDpHash(_oxmid, decoder)
668 case 2147503618:
669 return DecodeOxmIdIpv6Exthdr(_oxmid, decoder)
670 case 123168:
671 return DecodeOxmIdXxreg1Masked(_oxmid, decoder)
672 case 118786:
673 return DecodeOxmIdTunFlags(_oxmid, decoder)
674 case 95736:
675 return DecodeOxmIdTunMetadata18Masked(_oxmid, decoder)
676 case 2308:
677 return DecodeOxmIdVlanTciMasked(_oxmid, decoder)
678 case 2147488002:
679 return DecodeOxmIdIpDscpMasked(_oxmid, decoder)
680 case 100988:
681 return DecodeOxmIdTunMetadata29(_oxmid, decoder)
682 case 119810:
683 return DecodeOxmIdConnTrackingZone(_oxmid, decoder)
684 case 96760:
685 return DecodeOxmIdTunMetadata20Masked(_oxmid, decoder)
686 case 2147486980:
687 return DecodeOxmIdVlanVidMasked(_oxmid, decoder)
688 case 116348:
689 return DecodeOxmIdTunMetadata59(_oxmid, decoder)
690 case 5378:
691 return DecodeOxmIdTcpDstMasked(_oxmid, decoder)
692 case 71944:
693 return DecodeOxmIdReg12Masked(_oxmid, decoder)
694 case 2147483912:
695 return DecodeOxmIdInPortMasked(_oxmid, decoder)
696 case 75552:
697 return DecodeOxmIdIpv6SrcMasked(_oxmid, decoder)
698 case 102012:
699 return DecodeOxmIdTunMetadata31(_oxmid, decoder)
700 case 198402:
701 return DecodeOxmIdBsnGlobalVrfAllowedMasked(_oxmid, decoder)
702 case 5892:
703 return DecodeOxmIdUdpSrcMasked(_oxmid, decoder)
704 case 97784:
705 return DecodeOxmIdTunMetadata22Masked(_oxmid, decoder)
706 case 66052:
707 return DecodeOxmIdReg1(_oxmid, decoder)
708 case 67336:
709 return DecodeOxmIdReg3Masked(_oxmid, decoder)
710 case 208652:
711 return DecodeOxmIdBsnInnerEthSrcMasked(_oxmid, decoder)
712 case 75280:
713 return DecodeOxmIdIpv6Src(_oxmid, decoder)
714 case 197896:
715 return DecodeOxmIdBsnVrfMasked(_oxmid, decoder)
716 case 122656:
717 return DecodeOxmIdXxreg0Masked(_oxmid, decoder)
718 case 103036:
719 return DecodeOxmIdTunMetadata33(_oxmid, decoder)
720 case 98808:
721 return DecodeOxmIdTunMetadata24Masked(_oxmid, decoder)
722 case 67848:
723 return DecodeOxmIdReg4Masked(_oxmid, decoder)
724 case 77600:
725 return DecodeOxmIdNdTargetMasked(_oxmid, decoder)
726 case 104060:
727 return DecodeOxmIdTunMetadata35(_oxmid, decoder)
728 case 99832:
729 return DecodeOxmIdTunMetadata26Masked(_oxmid, decoder)
730 case 6404:
731 return DecodeOxmIdUdpDstMasked(_oxmid, decoder)
732 case 77328:
733 return DecodeOxmIdNdTarget(_oxmid, decoder)
734 case 68872:
735 return DecodeOxmIdReg6Masked(_oxmid, decoder)
736 case 105084:
737 return DecodeOxmIdTunMetadata37(_oxmid, decoder)
738 case 100856:
739 return DecodeOxmIdTunMetadata28Masked(_oxmid, decoder)
740 case 206082:
741 return DecodeOxmIdBsnL2CacheHitMasked(_oxmid, decoder)
742 case 203016:
743 return DecodeOxmIdBsnUdf4Masked(_oxmid, decoder)
744 case 69896:
745 return DecodeOxmIdReg8Masked(_oxmid, decoder)
746 case 206720:
747 return DecodeOxmIdBsnInPorts512Masked(_oxmid, decoder)
748 case 106108:
749 return DecodeOxmIdTunMetadata39(_oxmid, decoder)
750 case 101880:
751 return DecodeOxmIdTunMetadata30Masked(_oxmid, decoder)
752 case 8452:
753 return DecodeOxmIdArpSpaMasked(_oxmid, decoder)
754 case 66312:
755 return DecodeOxmIdReg1Masked(_oxmid, decoder)
756 case 201992:
757 return DecodeOxmIdBsnUdf2Masked(_oxmid, decoder)
758 case 107132:
759 return DecodeOxmIdTunMetadata41(_oxmid, decoder)
760 case 102904:
761 return DecodeOxmIdTunMetadata32Masked(_oxmid, decoder)
762 case 2147493124:
763 return DecodeOxmIdSctpDstMasked(_oxmid, decoder)
764 case 67076:
765 return DecodeOxmIdReg3(_oxmid, decoder)
766 case 119300:
767 return DecodeOxmIdConnTrackingState(_oxmid, decoder)
768 case 2147490056:
769 return DecodeOxmIdIpv4DstMasked(_oxmid, decoder)
770 case 2147499808:
771 return DecodeOxmIdIpv6NdTargetMasked(_oxmid, decoder)
772 case 108156:
773 return DecodeOxmIdTunMetadata43(_oxmid, decoder)
774 case 103928:
775 return DecodeOxmIdTunMetadata34Masked(_oxmid, decoder)
776 case 106488:
777 return DecodeOxmIdTunMetadata39Masked(_oxmid, decoder)
778 case 201732:
779 return DecodeOxmIdBsnUdf2(_oxmid, decoder)
780 case 2147499536:
781 return DecodeOxmIdIpv6NdTarget(_oxmid, decoder)
782 case 72968:
783 return DecodeOxmIdReg14Masked(_oxmid, decoder)
784 case 109180:
785 return DecodeOxmIdTunMetadata45(_oxmid, decoder)
786 case 104952:
787 return DecodeOxmIdTunMetadata36Masked(_oxmid, decoder)
788 case 93820:
789 return DecodeOxmIdTunMetadata15(_oxmid, decoder)
790 case 79106:
791 return DecodeOxmIdIpFragMasked(_oxmid, decoder)
792 case 108536:
793 return DecodeOxmIdTunMetadata43Masked(_oxmid, decoder)
794 case 126980:
795 return DecodeOxmIdConnTrackingNwSrc(_oxmid, decoder)
796 default:
797 return _oxmid, nil
798 }
799}
800
801func NewOxmId(_type_len uint32) *OxmId {
802 obj := &OxmId{}
803 obj.TypeLen = _type_len
804 return obj
805}
806func (self *OxmId) GetOXMName() string {
807 return ""
808}
809
810func (self *OxmId) MarshalJSON() ([]byte, error) {
811 if self.TypeLen == 0 {
812 return []byte("\"\""), nil
813 } else {
814 return []byte("\"" + self.GetOXMName() + "\""), nil
815 }
816}
817
818type ActionNxBundleLoadSlave struct {
819 Port Port
820}
821
822type IActionNxBundleLoadSlave interface {
823 goloxi.Serializable
824 GetPort() Port
825}
826
827func (self *ActionNxBundleLoadSlave) GetPort() Port {
828 return self.Port
829}
830
831func (self *ActionNxBundleLoadSlave) SetPort(v Port) {
832 self.Port = v
833}
834
835func (self *ActionNxBundleLoadSlave) Serialize(encoder *goloxi.Encoder) error {
836
837 encoder.PutUint32(uint32(self.Port))
838
839 return nil
840}
841
842func DecodeActionNxBundleLoadSlave(decoder *goloxi.Decoder) (*ActionNxBundleLoadSlave, error) {
843 _actionnxbundleloadslave := &ActionNxBundleLoadSlave{}
844 if decoder.Length() < 4 {
845 return nil, fmt.Errorf("ActionNxBundleLoadSlave packet too short: %d < 4", decoder.Length())
846 }
847 _actionnxbundleloadslave.Port = Port(decoder.ReadUint32())
848 return _actionnxbundleloadslave, nil
849}
850
851func NewActionNxBundleLoadSlave() *ActionNxBundleLoadSlave {
852 obj := &ActionNxBundleLoadSlave{}
853 return obj
854}
855
856type ActionNxController2Property struct {
857 Type NxActionController2PropType
858}
859
860type IActionNxController2Property interface {
861 goloxi.Serializable
862 GetType() NxActionController2PropType
863}
864
865func (self *ActionNxController2Property) GetType() NxActionController2PropType {
866 return self.Type
867}
868
869func (self *ActionNxController2Property) SetType(v NxActionController2PropType) {
870 self.Type = v
871}
872
873func (self *ActionNxController2Property) Serialize(encoder *goloxi.Encoder) error {
874
875 encoder.PutUint16(uint16(self.Type))
876
877 return nil
878}
879
880func DecodeActionNxController2Property(decoder *goloxi.Decoder) (IActionNxController2Property, error) {
881 _actionnxcontroller2property := &ActionNxController2Property{}
882 if decoder.Length() < 2 {
883 return nil, fmt.Errorf("ActionNxController2Property packet too short: %d < 2", decoder.Length())
884 }
885 _actionnxcontroller2property.Type = NxActionController2PropType(decoder.ReadUint16())
886
887 switch _actionnxcontroller2property.Type {
888 case 0:
889 return DecodeActionNxController2PropertyMaxLen(_actionnxcontroller2property, decoder)
890 case 1:
891 return DecodeActionNxController2PropertyControllerId(_actionnxcontroller2property, decoder)
892 case 2:
893 return DecodeActionNxController2PropertyReason(_actionnxcontroller2property, decoder)
894 case 3:
895 return DecodeActionNxController2PropertyUserdata(_actionnxcontroller2property, decoder)
896 case 4:
897 return DecodeActionNxController2PropertyPause(_actionnxcontroller2property, decoder)
898 case 5:
899 return DecodeActionNxController2PropertyMeterId(_actionnxcontroller2property, decoder)
900 default:
901 return nil, fmt.Errorf("Invalid type '%d' for 'ActionNxController2Property'", _actionnxcontroller2property.Type)
902 }
903}
904
905func NewActionNxController2Property(_type NxActionController2PropType) *ActionNxController2Property {
906 obj := &ActionNxController2Property{}
907 obj.Type = _type
908 return obj
909}
910
911type ActionNxController2PropertyControllerId struct {
912 *ActionNxController2Property
913 ControllerId uint16
914}
915
916type IActionNxController2PropertyControllerId interface {
917 IActionNxController2Property
918 GetControllerId() uint16
919}
920
921func (self *ActionNxController2PropertyControllerId) GetControllerId() uint16 {
922 return self.ControllerId
923}
924
925func (self *ActionNxController2PropertyControllerId) SetControllerId(v uint16) {
926 self.ControllerId = v
927}
928
929func (self *ActionNxController2PropertyControllerId) Serialize(encoder *goloxi.Encoder) error {
930 if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
931 return err
932 }
933
934 encoder.PutUint16(uint16(self.ControllerId))
935
936 encoder.SkipAlign()
937
938 return nil
939}
940
941func DecodeActionNxController2PropertyControllerId(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyControllerId, error) {
942 _actionnxcontroller2propertycontrollerid := &ActionNxController2PropertyControllerId{ActionNxController2Property: parent}
943 if decoder.Length() < 2 {
944 return nil, fmt.Errorf("ActionNxController2PropertyControllerId packet too short: %d < 2", decoder.Length())
945 }
946 defer decoder.SkipAlign()
947
948 _actionnxcontroller2propertycontrollerid.ControllerId = uint16(decoder.ReadUint16())
949 return _actionnxcontroller2propertycontrollerid, nil
950}
951
952func NewActionNxController2PropertyControllerId() *ActionNxController2PropertyControllerId {
953 obj := &ActionNxController2PropertyControllerId{
954 ActionNxController2Property: NewActionNxController2Property(1),
955 }
956 return obj
957}
958
959type ActionNxController2PropertyMaxLen struct {
960 *ActionNxController2Property
961 MaxLen uint16
962}
963
964type IActionNxController2PropertyMaxLen interface {
965 IActionNxController2Property
966 GetMaxLen() uint16
967}
968
969func (self *ActionNxController2PropertyMaxLen) GetMaxLen() uint16 {
970 return self.MaxLen
971}
972
973func (self *ActionNxController2PropertyMaxLen) SetMaxLen(v uint16) {
974 self.MaxLen = v
975}
976
977func (self *ActionNxController2PropertyMaxLen) Serialize(encoder *goloxi.Encoder) error {
978 if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
979 return err
980 }
981
982 encoder.PutUint16(uint16(self.MaxLen))
983
984 encoder.SkipAlign()
985
986 return nil
987}
988
989func DecodeActionNxController2PropertyMaxLen(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyMaxLen, error) {
990 _actionnxcontroller2propertymaxlen := &ActionNxController2PropertyMaxLen{ActionNxController2Property: parent}
991 if decoder.Length() < 2 {
992 return nil, fmt.Errorf("ActionNxController2PropertyMaxLen packet too short: %d < 2", decoder.Length())
993 }
994 defer decoder.SkipAlign()
995
996 _actionnxcontroller2propertymaxlen.MaxLen = uint16(decoder.ReadUint16())
997 return _actionnxcontroller2propertymaxlen, nil
998}
999
1000func NewActionNxController2PropertyMaxLen() *ActionNxController2PropertyMaxLen {
1001 obj := &ActionNxController2PropertyMaxLen{
1002 ActionNxController2Property: NewActionNxController2Property(0),
1003 }
1004 return obj
1005}
1006
1007type ActionNxController2PropertyMeterId struct {
1008 *ActionNxController2Property
1009 MeterId uint32
1010}
1011
1012type IActionNxController2PropertyMeterId interface {
1013 IActionNxController2Property
1014 GetMeterId() uint32
1015}
1016
1017func (self *ActionNxController2PropertyMeterId) GetMeterId() uint32 {
1018 return self.MeterId
1019}
1020
1021func (self *ActionNxController2PropertyMeterId) SetMeterId(v uint32) {
1022 self.MeterId = v
1023}
1024
1025func (self *ActionNxController2PropertyMeterId) Serialize(encoder *goloxi.Encoder) error {
1026 if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
1027 return err
1028 }
1029
1030 encoder.PutUint32(uint32(self.MeterId))
1031
1032 encoder.SkipAlign()
1033
1034 return nil
1035}
1036
1037func DecodeActionNxController2PropertyMeterId(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyMeterId, error) {
1038 _actionnxcontroller2propertymeterid := &ActionNxController2PropertyMeterId{ActionNxController2Property: parent}
1039 if decoder.Length() < 4 {
1040 return nil, fmt.Errorf("ActionNxController2PropertyMeterId packet too short: %d < 4", decoder.Length())
1041 }
1042 defer decoder.SkipAlign()
1043
1044 _actionnxcontroller2propertymeterid.MeterId = uint32(decoder.ReadUint32())
1045 return _actionnxcontroller2propertymeterid, nil
1046}
1047
1048func NewActionNxController2PropertyMeterId() *ActionNxController2PropertyMeterId {
1049 obj := &ActionNxController2PropertyMeterId{
1050 ActionNxController2Property: NewActionNxController2Property(5),
1051 }
1052 return obj
1053}
1054
1055type ActionNxController2PropertyPause struct {
1056 *ActionNxController2Property
1057}
1058
1059type IActionNxController2PropertyPause interface {
1060 IActionNxController2Property
1061}
1062
1063func (self *ActionNxController2PropertyPause) Serialize(encoder *goloxi.Encoder) error {
1064 if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
1065 return err
1066 }
1067
1068 encoder.SkipAlign()
1069
1070 return nil
1071}
1072
1073func DecodeActionNxController2PropertyPause(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyPause, error) {
1074 _actionnxcontroller2propertypause := &ActionNxController2PropertyPause{ActionNxController2Property: parent}
1075 defer decoder.SkipAlign()
1076
1077 return _actionnxcontroller2propertypause, nil
1078}
1079
1080func NewActionNxController2PropertyPause() *ActionNxController2PropertyPause {
1081 obj := &ActionNxController2PropertyPause{
1082 ActionNxController2Property: NewActionNxController2Property(4),
1083 }
1084 return obj
1085}
1086
1087type ActionNxController2PropertyReason struct {
1088 *ActionNxController2Property
1089 Reason PacketInReason
1090}
1091
1092type IActionNxController2PropertyReason interface {
1093 IActionNxController2Property
1094 GetReason() PacketInReason
1095}
1096
1097func (self *ActionNxController2PropertyReason) GetReason() PacketInReason {
1098 return self.Reason
1099}
1100
1101func (self *ActionNxController2PropertyReason) SetReason(v PacketInReason) {
1102 self.Reason = v
1103}
1104
1105func (self *ActionNxController2PropertyReason) Serialize(encoder *goloxi.Encoder) error {
1106 if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
1107 return err
1108 }
1109
1110 encoder.PutUint8(uint8(self.Reason))
1111
1112 encoder.SkipAlign()
1113
1114 return nil
1115}
1116
1117func DecodeActionNxController2PropertyReason(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyReason, error) {
1118 _actionnxcontroller2propertyreason := &ActionNxController2PropertyReason{ActionNxController2Property: parent}
1119 if decoder.Length() < 1 {
1120 return nil, fmt.Errorf("ActionNxController2PropertyReason packet too short: %d < 1", decoder.Length())
1121 }
1122 defer decoder.SkipAlign()
1123
1124 _actionnxcontroller2propertyreason.Reason = PacketInReason(decoder.ReadByte())
1125 return _actionnxcontroller2propertyreason, nil
1126}
1127
1128func NewActionNxController2PropertyReason() *ActionNxController2PropertyReason {
1129 obj := &ActionNxController2PropertyReason{
1130 ActionNxController2Property: NewActionNxController2Property(2),
1131 }
1132 return obj
1133}
1134
1135type ActionNxController2PropertyUserdata struct {
1136 *ActionNxController2Property
1137 Length uint16
1138 Userdata []byte
1139}
1140
1141type IActionNxController2PropertyUserdata interface {
1142 IActionNxController2Property
1143 GetLength() uint16
1144 GetUserdata() []byte
1145}
1146
1147func (self *ActionNxController2PropertyUserdata) GetLength() uint16 {
1148 return self.Length
1149}
1150
1151func (self *ActionNxController2PropertyUserdata) SetLength(v uint16) {
1152 self.Length = v
1153}
1154
1155func (self *ActionNxController2PropertyUserdata) GetUserdata() []byte {
1156 return self.Userdata
1157}
1158
1159func (self *ActionNxController2PropertyUserdata) SetUserdata(v []byte) {
1160 self.Userdata = v
1161}
1162
1163func (self *ActionNxController2PropertyUserdata) Serialize(encoder *goloxi.Encoder) error {
1164 if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
1165 return err
1166 }
1167
1168 encoder.PutUint16(uint16(self.Length))
1169 encoder.Write(self.Userdata)
1170
1171 encoder.SkipAlign()
1172
1173 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
1174
1175 return nil
1176}
1177
1178func DecodeActionNxController2PropertyUserdata(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyUserdata, error) {
1179 _actionnxcontroller2propertyuserdata := &ActionNxController2PropertyUserdata{ActionNxController2Property: parent}
1180 if decoder.Length() < 2 {
1181 return nil, fmt.Errorf("ActionNxController2PropertyUserdata packet too short: %d < 2", decoder.Length())
1182 }
1183 defer decoder.SkipAlign()
1184
1185 _actionnxcontroller2propertyuserdata.Length = uint16(decoder.ReadUint16())
1186 oldDecoder := decoder
1187 defer func() { decoder = oldDecoder }()
1188 decoder = decoder.SliceDecoder(int(((_actionnxcontroller2propertyuserdata.Length)+7)/8*8), 2+2)
1189 _actionnxcontroller2propertyuserdata.Userdata = decoder.Read(int(decoder.Length()))
1190 return _actionnxcontroller2propertyuserdata, nil
1191}
1192
1193func NewActionNxController2PropertyUserdata() *ActionNxController2PropertyUserdata {
1194 obj := &ActionNxController2PropertyUserdata{
1195 ActionNxController2Property: NewActionNxController2Property(3),
1196 }
1197 return obj
1198}
1199
1200type BsnControllerConnection struct {
1201 State BsnControllerConnectionState
1202 AuxiliaryId uint8
1203 Role ControllerRole
1204 Uri string
1205}
1206
1207type IBsnControllerConnection interface {
1208 goloxi.Serializable
1209 GetState() BsnControllerConnectionState
1210 GetAuxiliaryId() uint8
1211 GetRole() ControllerRole
1212 GetUri() string
1213}
1214
1215func (self *BsnControllerConnection) GetState() BsnControllerConnectionState {
1216 return self.State
1217}
1218
1219func (self *BsnControllerConnection) SetState(v BsnControllerConnectionState) {
1220 self.State = v
1221}
1222
1223func (self *BsnControllerConnection) GetAuxiliaryId() uint8 {
1224 return self.AuxiliaryId
1225}
1226
1227func (self *BsnControllerConnection) SetAuxiliaryId(v uint8) {
1228 self.AuxiliaryId = v
1229}
1230
1231func (self *BsnControllerConnection) GetRole() ControllerRole {
1232 return self.Role
1233}
1234
1235func (self *BsnControllerConnection) SetRole(v ControllerRole) {
1236 self.Role = v
1237}
1238
1239func (self *BsnControllerConnection) GetUri() string {
1240 return self.Uri
1241}
1242
1243func (self *BsnControllerConnection) SetUri(v string) {
1244 self.Uri = v
1245}
1246
1247func (self *BsnControllerConnection) Serialize(encoder *goloxi.Encoder) error {
1248
1249 encoder.PutUint8(uint8(self.State))
1250 encoder.PutUint8(uint8(self.AuxiliaryId))
1251 encoder.Write(bytes.Repeat([]byte{0}, 2))
1252 encoder.PutUint32(uint32(self.Role))
1253 encoder.Write([]byte(self.Uri))
1254
1255 return nil
1256}
1257
1258func DecodeBsnControllerConnection(decoder *goloxi.Decoder) (*BsnControllerConnection, error) {
1259 _bsncontrollerconnection := &BsnControllerConnection{}
1260 if decoder.Length() < 264 {
1261 return nil, fmt.Errorf("BsnControllerConnection packet too short: %d < 264", decoder.Length())
1262 }
1263 _bsncontrollerconnection.State = BsnControllerConnectionState(decoder.ReadByte())
1264 _bsncontrollerconnection.AuxiliaryId = uint8(decoder.ReadByte())
1265 decoder.Skip(2)
1266 _bsncontrollerconnection.Role = ControllerRole(decoder.ReadUint32())
1267 _bsncontrollerconnection.Uri = string(bytes.Trim(decoder.Read(256), "\x00"))
1268 return _bsncontrollerconnection, nil
1269}
1270
1271func NewBsnControllerConnection() *BsnControllerConnection {
1272 obj := &BsnControllerConnection{}
1273 return obj
1274}
1275
1276type BsnDebugCounterDescStatsEntry struct {
1277 CounterId uint64
1278 Name string
1279 Description string
1280}
1281
1282type IBsnDebugCounterDescStatsEntry interface {
1283 goloxi.Serializable
1284 GetCounterId() uint64
1285 GetName() string
1286 GetDescription() string
1287}
1288
1289func (self *BsnDebugCounterDescStatsEntry) GetCounterId() uint64 {
1290 return self.CounterId
1291}
1292
1293func (self *BsnDebugCounterDescStatsEntry) SetCounterId(v uint64) {
1294 self.CounterId = v
1295}
1296
1297func (self *BsnDebugCounterDescStatsEntry) GetName() string {
1298 return self.Name
1299}
1300
1301func (self *BsnDebugCounterDescStatsEntry) SetName(v string) {
1302 self.Name = v
1303}
1304
1305func (self *BsnDebugCounterDescStatsEntry) GetDescription() string {
1306 return self.Description
1307}
1308
1309func (self *BsnDebugCounterDescStatsEntry) SetDescription(v string) {
1310 self.Description = v
1311}
1312
1313func (self *BsnDebugCounterDescStatsEntry) Serialize(encoder *goloxi.Encoder) error {
1314
1315 encoder.PutUint64(uint64(self.CounterId))
1316 encoder.Write([]byte(self.Name))
1317 encoder.Write([]byte(self.Description))
1318
1319 return nil
1320}
1321
1322func DecodeBsnDebugCounterDescStatsEntry(decoder *goloxi.Decoder) (*BsnDebugCounterDescStatsEntry, error) {
1323 _bsndebugcounterdescstatsentry := &BsnDebugCounterDescStatsEntry{}
1324 if decoder.Length() < 328 {
1325 return nil, fmt.Errorf("BsnDebugCounterDescStatsEntry packet too short: %d < 328", decoder.Length())
1326 }
1327 _bsndebugcounterdescstatsentry.CounterId = uint64(decoder.ReadUint64())
1328 _bsndebugcounterdescstatsentry.Name = string(bytes.Trim(decoder.Read(64), "\x00"))
1329 _bsndebugcounterdescstatsentry.Description = string(bytes.Trim(decoder.Read(256), "\x00"))
1330 return _bsndebugcounterdescstatsentry, nil
1331}
1332
1333func NewBsnDebugCounterDescStatsEntry() *BsnDebugCounterDescStatsEntry {
1334 obj := &BsnDebugCounterDescStatsEntry{}
1335 return obj
1336}
1337
1338type BsnDebugCounterStatsEntry struct {
1339 CounterId uint64
1340 Value uint64
1341}
1342
1343type IBsnDebugCounterStatsEntry interface {
1344 goloxi.Serializable
1345 GetCounterId() uint64
1346 GetValue() uint64
1347}
1348
1349func (self *BsnDebugCounterStatsEntry) GetCounterId() uint64 {
1350 return self.CounterId
1351}
1352
1353func (self *BsnDebugCounterStatsEntry) SetCounterId(v uint64) {
1354 self.CounterId = v
1355}
1356
1357func (self *BsnDebugCounterStatsEntry) GetValue() uint64 {
1358 return self.Value
1359}
1360
1361func (self *BsnDebugCounterStatsEntry) SetValue(v uint64) {
1362 self.Value = v
1363}
1364
1365func (self *BsnDebugCounterStatsEntry) Serialize(encoder *goloxi.Encoder) error {
1366
1367 encoder.PutUint64(uint64(self.CounterId))
1368 encoder.PutUint64(uint64(self.Value))
1369
1370 return nil
1371}
1372
1373func DecodeBsnDebugCounterStatsEntry(decoder *goloxi.Decoder) (*BsnDebugCounterStatsEntry, error) {
1374 _bsndebugcounterstatsentry := &BsnDebugCounterStatsEntry{}
1375 if decoder.Length() < 16 {
1376 return nil, fmt.Errorf("BsnDebugCounterStatsEntry packet too short: %d < 16", decoder.Length())
1377 }
1378 _bsndebugcounterstatsentry.CounterId = uint64(decoder.ReadUint64())
1379 _bsndebugcounterstatsentry.Value = uint64(decoder.ReadUint64())
1380 return _bsndebugcounterstatsentry, nil
1381}
1382
1383func NewBsnDebugCounterStatsEntry() *BsnDebugCounterStatsEntry {
1384 obj := &BsnDebugCounterStatsEntry{}
1385 return obj
1386}
1387
1388type BsnFlowChecksumBucketStatsEntry struct {
1389 Checksum uint64
1390}
1391
1392type IBsnFlowChecksumBucketStatsEntry interface {
1393 goloxi.Serializable
1394 GetChecksum() uint64
1395}
1396
1397func (self *BsnFlowChecksumBucketStatsEntry) GetChecksum() uint64 {
1398 return self.Checksum
1399}
1400
1401func (self *BsnFlowChecksumBucketStatsEntry) SetChecksum(v uint64) {
1402 self.Checksum = v
1403}
1404
1405func (self *BsnFlowChecksumBucketStatsEntry) Serialize(encoder *goloxi.Encoder) error {
1406
1407 encoder.PutUint64(uint64(self.Checksum))
1408
1409 return nil
1410}
1411
1412func DecodeBsnFlowChecksumBucketStatsEntry(decoder *goloxi.Decoder) (*BsnFlowChecksumBucketStatsEntry, error) {
1413 _bsnflowchecksumbucketstatsentry := &BsnFlowChecksumBucketStatsEntry{}
1414 if decoder.Length() < 8 {
1415 return nil, fmt.Errorf("BsnFlowChecksumBucketStatsEntry packet too short: %d < 8", decoder.Length())
1416 }
1417 _bsnflowchecksumbucketstatsentry.Checksum = uint64(decoder.ReadUint64())
1418 return _bsnflowchecksumbucketstatsentry, nil
1419}
1420
1421func NewBsnFlowChecksumBucketStatsEntry() *BsnFlowChecksumBucketStatsEntry {
1422 obj := &BsnFlowChecksumBucketStatsEntry{}
1423 return obj
1424}
1425
1426type BsnGenericStatsEntry struct {
1427 Length uint16
1428 Tlvs []IBsnTlv
1429}
1430
1431type IBsnGenericStatsEntry interface {
1432 goloxi.Serializable
1433 GetLength() uint16
1434 GetTlvs() []IBsnTlv
1435}
1436
1437func (self *BsnGenericStatsEntry) GetLength() uint16 {
1438 return self.Length
1439}
1440
1441func (self *BsnGenericStatsEntry) SetLength(v uint16) {
1442 self.Length = v
1443}
1444
1445func (self *BsnGenericStatsEntry) GetTlvs() []IBsnTlv {
1446 return self.Tlvs
1447}
1448
1449func (self *BsnGenericStatsEntry) SetTlvs(v []IBsnTlv) {
1450 self.Tlvs = v
1451}
1452
1453func (self *BsnGenericStatsEntry) Serialize(encoder *goloxi.Encoder) error {
1454
1455 encoder.PutUint16(uint16(self.Length))
1456 for _, obj := range self.Tlvs {
1457 if err := obj.Serialize(encoder); err != nil {
1458 return err
1459 }
1460 }
1461
1462 binary.BigEndian.PutUint16(encoder.Bytes()[0:2], uint16(len(encoder.Bytes())))
1463
1464 return nil
1465}
1466
1467func DecodeBsnGenericStatsEntry(decoder *goloxi.Decoder) (*BsnGenericStatsEntry, error) {
1468 _bsngenericstatsentry := &BsnGenericStatsEntry{}
1469 if decoder.Length() < 2 {
1470 return nil, fmt.Errorf("BsnGenericStatsEntry packet too short: %d < 2", decoder.Length())
1471 }
1472 _bsngenericstatsentry.Length = uint16(decoder.ReadUint16())
1473 oldDecoder := decoder
1474 defer func() { decoder = oldDecoder }()
1475 decoder = decoder.SliceDecoder(int(_bsngenericstatsentry.Length), 2+0)
1476
1477 for decoder.Length() >= 4 {
1478 item, err := DecodeBsnTlv(decoder)
1479 if err != nil {
1480 return nil, err
1481 }
1482 if item != nil {
1483 _bsngenericstatsentry.Tlvs = append(_bsngenericstatsentry.Tlvs, item)
1484 }
1485 }
1486 return _bsngenericstatsentry, nil
1487}
1488
1489func NewBsnGenericStatsEntry() *BsnGenericStatsEntry {
1490 obj := &BsnGenericStatsEntry{}
1491 return obj
1492}
1493
1494type BsnGentableBucketStatsEntry struct {
1495 Checksum Checksum128
1496}
1497
1498type IBsnGentableBucketStatsEntry interface {
1499 goloxi.Serializable
1500 GetChecksum() Checksum128
1501}
1502
1503func (self *BsnGentableBucketStatsEntry) GetChecksum() Checksum128 {
1504 return self.Checksum
1505}
1506
1507func (self *BsnGentableBucketStatsEntry) SetChecksum(v Checksum128) {
1508 self.Checksum = v
1509}
1510
1511func (self *BsnGentableBucketStatsEntry) Serialize(encoder *goloxi.Encoder) error {
1512
1513 self.Checksum.Serialize(encoder)
1514
1515 return nil
1516}
1517
1518func DecodeBsnGentableBucketStatsEntry(decoder *goloxi.Decoder) (*BsnGentableBucketStatsEntry, error) {
1519 _bsngentablebucketstatsentry := &BsnGentableBucketStatsEntry{}
1520 if decoder.Length() < 16 {
1521 return nil, fmt.Errorf("BsnGentableBucketStatsEntry packet too short: %d < 16", decoder.Length())
1522 }
1523 _bsngentablebucketstatsentry.Checksum.Decode(decoder)
1524 return _bsngentablebucketstatsentry, nil
1525}
1526
1527func NewBsnGentableBucketStatsEntry() *BsnGentableBucketStatsEntry {
1528 obj := &BsnGentableBucketStatsEntry{}
1529 return obj
1530}
1531
1532type BsnGentableDescStatsEntry struct {
1533 Length uint16
1534 TableId uint16
1535 Name string
1536 BucketsSize uint32
1537 MaxEntries uint32
1538}
1539
1540type IBsnGentableDescStatsEntry interface {
1541 goloxi.Serializable
1542 GetLength() uint16
1543 GetTableId() uint16
1544 GetName() string
1545 GetBucketsSize() uint32
1546 GetMaxEntries() uint32
1547}
1548
1549func (self *BsnGentableDescStatsEntry) GetLength() uint16 {
1550 return self.Length
1551}
1552
1553func (self *BsnGentableDescStatsEntry) SetLength(v uint16) {
1554 self.Length = v
1555}
1556
1557func (self *BsnGentableDescStatsEntry) GetTableId() uint16 {
1558 return self.TableId
1559}
1560
1561func (self *BsnGentableDescStatsEntry) SetTableId(v uint16) {
1562 self.TableId = v
1563}
1564
1565func (self *BsnGentableDescStatsEntry) GetName() string {
1566 return self.Name
1567}
1568
1569func (self *BsnGentableDescStatsEntry) SetName(v string) {
1570 self.Name = v
1571}
1572
1573func (self *BsnGentableDescStatsEntry) GetBucketsSize() uint32 {
1574 return self.BucketsSize
1575}
1576
1577func (self *BsnGentableDescStatsEntry) SetBucketsSize(v uint32) {
1578 self.BucketsSize = v
1579}
1580
1581func (self *BsnGentableDescStatsEntry) GetMaxEntries() uint32 {
1582 return self.MaxEntries
1583}
1584
1585func (self *BsnGentableDescStatsEntry) SetMaxEntries(v uint32) {
1586 self.MaxEntries = v
1587}
1588
1589func (self *BsnGentableDescStatsEntry) Serialize(encoder *goloxi.Encoder) error {
1590
1591 encoder.PutUint16(uint16(self.Length))
1592 encoder.PutUint16(uint16(self.TableId))
1593 encoder.Write([]byte(self.Name))
1594 encoder.PutUint32(uint32(self.BucketsSize))
1595 encoder.PutUint32(uint32(self.MaxEntries))
1596 encoder.Write(bytes.Repeat([]byte{0}, 4))
1597
1598 binary.BigEndian.PutUint16(encoder.Bytes()[0:2], uint16(len(encoder.Bytes())))
1599
1600 return nil
1601}
1602
1603func DecodeBsnGentableDescStatsEntry(decoder *goloxi.Decoder) (*BsnGentableDescStatsEntry, error) {
1604 _bsngentabledescstatsentry := &BsnGentableDescStatsEntry{}
1605 if decoder.Length() < 48 {
1606 return nil, fmt.Errorf("BsnGentableDescStatsEntry packet too short: %d < 48", decoder.Length())
1607 }
1608 _bsngentabledescstatsentry.Length = uint16(decoder.ReadUint16())
1609 oldDecoder := decoder
1610 defer func() { decoder = oldDecoder }()
1611 decoder = decoder.SliceDecoder(int(_bsngentabledescstatsentry.Length), 2+0)
1612 _bsngentabledescstatsentry.TableId = uint16(decoder.ReadUint16())
1613 _bsngentabledescstatsentry.Name = string(bytes.Trim(decoder.Read(32), "\x00"))
1614 _bsngentabledescstatsentry.BucketsSize = uint32(decoder.ReadUint32())
1615 _bsngentabledescstatsentry.MaxEntries = uint32(decoder.ReadUint32())
1616 decoder.Skip(4)
1617 return _bsngentabledescstatsentry, nil
1618}
1619
1620func NewBsnGentableDescStatsEntry() *BsnGentableDescStatsEntry {
1621 obj := &BsnGentableDescStatsEntry{}
1622 return obj
1623}
1624
1625type BsnGentableEntryDescStatsEntry struct {
1626 Length uint16
1627 KeyLength uint16
1628 Checksum Checksum128
1629 Key []IBsnTlv
1630 Value []IBsnTlv
1631}
1632
1633type IBsnGentableEntryDescStatsEntry interface {
1634 goloxi.Serializable
1635 GetLength() uint16
1636 GetKeyLength() uint16
1637 GetChecksum() Checksum128
1638 GetKey() []IBsnTlv
1639 GetValue() []IBsnTlv
1640}
1641
1642func (self *BsnGentableEntryDescStatsEntry) GetLength() uint16 {
1643 return self.Length
1644}
1645
1646func (self *BsnGentableEntryDescStatsEntry) SetLength(v uint16) {
1647 self.Length = v
1648}
1649
1650func (self *BsnGentableEntryDescStatsEntry) GetKeyLength() uint16 {
1651 return self.KeyLength
1652}
1653
1654func (self *BsnGentableEntryDescStatsEntry) SetKeyLength(v uint16) {
1655 self.KeyLength = v
1656}
1657
1658func (self *BsnGentableEntryDescStatsEntry) GetChecksum() Checksum128 {
1659 return self.Checksum
1660}
1661
1662func (self *BsnGentableEntryDescStatsEntry) SetChecksum(v Checksum128) {
1663 self.Checksum = v
1664}
1665
1666func (self *BsnGentableEntryDescStatsEntry) GetKey() []IBsnTlv {
1667 return self.Key
1668}
1669
1670func (self *BsnGentableEntryDescStatsEntry) SetKey(v []IBsnTlv) {
1671 self.Key = v
1672}
1673
1674func (self *BsnGentableEntryDescStatsEntry) GetValue() []IBsnTlv {
1675 return self.Value
1676}
1677
1678func (self *BsnGentableEntryDescStatsEntry) SetValue(v []IBsnTlv) {
1679 self.Value = v
1680}
1681
1682func (self *BsnGentableEntryDescStatsEntry) Serialize(encoder *goloxi.Encoder) error {
1683
1684 encoder.PutUint16(uint16(self.Length))
1685 encoder.PutUint16(uint16(self.KeyLength))
1686 self.Checksum.Serialize(encoder)
1687 for _, obj := range self.Key {
1688 if err := obj.Serialize(encoder); err != nil {
1689 return err
1690 }
1691 }
1692 for _, obj := range self.Value {
1693 if err := obj.Serialize(encoder); err != nil {
1694 return err
1695 }
1696 }
1697
1698 binary.BigEndian.PutUint16(encoder.Bytes()[0:2], uint16(len(encoder.Bytes())))
1699
1700 return nil
1701}
1702
1703func DecodeBsnGentableEntryDescStatsEntry(decoder *goloxi.Decoder) (*BsnGentableEntryDescStatsEntry, error) {
1704 _bsngentableentrydescstatsentry := &BsnGentableEntryDescStatsEntry{}
1705 if decoder.Length() < 20 {
1706 return nil, fmt.Errorf("BsnGentableEntryDescStatsEntry packet too short: %d < 20", decoder.Length())
1707 }
1708 _bsngentableentrydescstatsentry.Length = uint16(decoder.ReadUint16())
1709 oldDecoder := decoder
1710 defer func() { decoder = oldDecoder }()
1711 decoder = decoder.SliceDecoder(int(_bsngentableentrydescstatsentry.Length), 2+0)
1712 _bsngentableentrydescstatsentry.KeyLength = uint16(decoder.ReadUint16())
1713 _bsngentableentrydescstatsentry.Checksum.Decode(decoder)
1714
1715 for i := 0; i < int(_bsngentableentrydescstatsentry.KeyLength); i++ {
1716 item, err := DecodeBsnTlv(decoder)
1717 if err != nil {
1718 return nil, err
1719 }
1720 if item != nil {
1721 _bsngentableentrydescstatsentry.Key = append(_bsngentableentrydescstatsentry.Key, item)
1722 }
1723 }
1724
1725 for decoder.Length() >= 4 {
1726 item, err := DecodeBsnTlv(decoder)
1727 if err != nil {
1728 return nil, err
1729 }
1730 if item != nil {
1731 _bsngentableentrydescstatsentry.Value = append(_bsngentableentrydescstatsentry.Value, item)
1732 }
1733 }
1734 return _bsngentableentrydescstatsentry, nil
1735}
1736
1737func NewBsnGentableEntryDescStatsEntry() *BsnGentableEntryDescStatsEntry {
1738 obj := &BsnGentableEntryDescStatsEntry{}
1739 return obj
1740}
1741
1742type BsnGentableEntryStatsEntry struct {
1743 Length uint16
1744 KeyLength uint16
1745 Key []IBsnTlv
1746 Stats []IBsnTlv
1747}
1748
1749type IBsnGentableEntryStatsEntry interface {
1750 goloxi.Serializable
1751 GetLength() uint16
1752 GetKeyLength() uint16
1753 GetKey() []IBsnTlv
1754 GetStats() []IBsnTlv
1755}
1756
1757func (self *BsnGentableEntryStatsEntry) GetLength() uint16 {
1758 return self.Length
1759}
1760
1761func (self *BsnGentableEntryStatsEntry) SetLength(v uint16) {
1762 self.Length = v
1763}
1764
1765func (self *BsnGentableEntryStatsEntry) GetKeyLength() uint16 {
1766 return self.KeyLength
1767}
1768
1769func (self *BsnGentableEntryStatsEntry) SetKeyLength(v uint16) {
1770 self.KeyLength = v
1771}
1772
1773func (self *BsnGentableEntryStatsEntry) GetKey() []IBsnTlv {
1774 return self.Key
1775}
1776
1777func (self *BsnGentableEntryStatsEntry) SetKey(v []IBsnTlv) {
1778 self.Key = v
1779}
1780
1781func (self *BsnGentableEntryStatsEntry) GetStats() []IBsnTlv {
1782 return self.Stats
1783}
1784
1785func (self *BsnGentableEntryStatsEntry) SetStats(v []IBsnTlv) {
1786 self.Stats = v
1787}
1788
1789func (self *BsnGentableEntryStatsEntry) Serialize(encoder *goloxi.Encoder) error {
1790
1791 encoder.PutUint16(uint16(self.Length))
1792 encoder.PutUint16(uint16(self.KeyLength))
1793 for _, obj := range self.Key {
1794 if err := obj.Serialize(encoder); err != nil {
1795 return err
1796 }
1797 }
1798 for _, obj := range self.Stats {
1799 if err := obj.Serialize(encoder); err != nil {
1800 return err
1801 }
1802 }
1803
1804 binary.BigEndian.PutUint16(encoder.Bytes()[0:2], uint16(len(encoder.Bytes())))
1805
1806 return nil
1807}
1808
1809func DecodeBsnGentableEntryStatsEntry(decoder *goloxi.Decoder) (*BsnGentableEntryStatsEntry, error) {
1810 _bsngentableentrystatsentry := &BsnGentableEntryStatsEntry{}
1811 if decoder.Length() < 4 {
1812 return nil, fmt.Errorf("BsnGentableEntryStatsEntry packet too short: %d < 4", decoder.Length())
1813 }
1814 _bsngentableentrystatsentry.Length = uint16(decoder.ReadUint16())
1815 oldDecoder := decoder
1816 defer func() { decoder = oldDecoder }()
1817 decoder = decoder.SliceDecoder(int(_bsngentableentrystatsentry.Length), 2+0)
1818 _bsngentableentrystatsentry.KeyLength = uint16(decoder.ReadUint16())
1819
1820 for i := 0; i < int(_bsngentableentrystatsentry.KeyLength); i++ {
1821 item, err := DecodeBsnTlv(decoder)
1822 if err != nil {
1823 return nil, err
1824 }
1825 if item != nil {
1826 _bsngentableentrystatsentry.Key = append(_bsngentableentrystatsentry.Key, item)
1827 }
1828 }
1829
1830 for decoder.Length() >= 4 {
1831 item, err := DecodeBsnTlv(decoder)
1832 if err != nil {
1833 return nil, err
1834 }
1835 if item != nil {
1836 _bsngentableentrystatsentry.Stats = append(_bsngentableentrystatsentry.Stats, item)
1837 }
1838 }
1839 return _bsngentableentrystatsentry, nil
1840}
1841
1842func NewBsnGentableEntryStatsEntry() *BsnGentableEntryStatsEntry {
1843 obj := &BsnGentableEntryStatsEntry{}
1844 return obj
1845}
1846
1847type BsnGentableStatsEntry struct {
1848 TableId uint16
1849 EntryCount uint32
1850 Checksum Checksum128
1851}
1852
1853type IBsnGentableStatsEntry interface {
1854 goloxi.Serializable
1855 GetTableId() uint16
1856 GetEntryCount() uint32
1857 GetChecksum() Checksum128
1858}
1859
1860func (self *BsnGentableStatsEntry) GetTableId() uint16 {
1861 return self.TableId
1862}
1863
1864func (self *BsnGentableStatsEntry) SetTableId(v uint16) {
1865 self.TableId = v
1866}
1867
1868func (self *BsnGentableStatsEntry) GetEntryCount() uint32 {
1869 return self.EntryCount
1870}
1871
1872func (self *BsnGentableStatsEntry) SetEntryCount(v uint32) {
1873 self.EntryCount = v
1874}
1875
1876func (self *BsnGentableStatsEntry) GetChecksum() Checksum128 {
1877 return self.Checksum
1878}
1879
1880func (self *BsnGentableStatsEntry) SetChecksum(v Checksum128) {
1881 self.Checksum = v
1882}
1883
1884func (self *BsnGentableStatsEntry) Serialize(encoder *goloxi.Encoder) error {
1885
1886 encoder.PutUint16(uint16(self.TableId))
1887 encoder.Write(bytes.Repeat([]byte{0}, 2))
1888 encoder.PutUint32(uint32(self.EntryCount))
1889 self.Checksum.Serialize(encoder)
1890
1891 return nil
1892}
1893
1894func DecodeBsnGentableStatsEntry(decoder *goloxi.Decoder) (*BsnGentableStatsEntry, error) {
1895 _bsngentablestatsentry := &BsnGentableStatsEntry{}
1896 if decoder.Length() < 24 {
1897 return nil, fmt.Errorf("BsnGentableStatsEntry packet too short: %d < 24", decoder.Length())
1898 }
1899 _bsngentablestatsentry.TableId = uint16(decoder.ReadUint16())
1900 decoder.Skip(2)
1901 _bsngentablestatsentry.EntryCount = uint32(decoder.ReadUint32())
1902 _bsngentablestatsentry.Checksum.Decode(decoder)
1903 return _bsngentablestatsentry, nil
1904}
1905
1906func NewBsnGentableStatsEntry() *BsnGentableStatsEntry {
1907 obj := &BsnGentableStatsEntry{}
1908 return obj
1909}
1910
1911type BsnInterface struct {
1912 HwAddr net.HardwareAddr
1913 Name string
1914 Ipv4Addr net.IP
1915 Ipv4Netmask net.IP
1916}
1917
1918type IBsnInterface interface {
1919 goloxi.Serializable
1920 GetHwAddr() net.HardwareAddr
1921 GetName() string
1922 GetIpv4Addr() net.IP
1923 GetIpv4Netmask() net.IP
1924}
1925
1926func (self *BsnInterface) GetHwAddr() net.HardwareAddr {
1927 return self.HwAddr
1928}
1929
1930func (self *BsnInterface) SetHwAddr(v net.HardwareAddr) {
1931 self.HwAddr = v
1932}
1933
1934func (self *BsnInterface) GetName() string {
1935 return self.Name
1936}
1937
1938func (self *BsnInterface) SetName(v string) {
1939 self.Name = v
1940}
1941
1942func (self *BsnInterface) GetIpv4Addr() net.IP {
1943 return self.Ipv4Addr
1944}
1945
1946func (self *BsnInterface) SetIpv4Addr(v net.IP) {
1947 self.Ipv4Addr = v
1948}
1949
1950func (self *BsnInterface) GetIpv4Netmask() net.IP {
1951 return self.Ipv4Netmask
1952}
1953
1954func (self *BsnInterface) SetIpv4Netmask(v net.IP) {
1955 self.Ipv4Netmask = v
1956}
1957
1958func (self *BsnInterface) Serialize(encoder *goloxi.Encoder) error {
1959
1960 encoder.Write(self.HwAddr)
1961 encoder.Write(bytes.Repeat([]byte{0}, 2))
1962 encoder.Write([]byte(self.Name))
1963 encoder.Write(self.Ipv4Addr.To4())
1964 encoder.Write(self.Ipv4Netmask.To4())
1965
1966 return nil
1967}
1968
1969func DecodeBsnInterface(decoder *goloxi.Decoder) (*BsnInterface, error) {
1970 _bsninterface := &BsnInterface{}
1971 if decoder.Length() < 32 {
1972 return nil, fmt.Errorf("BsnInterface packet too short: %d < 32", decoder.Length())
1973 }
1974 _bsninterface.HwAddr = net.HardwareAddr(decoder.Read(6))
1975 decoder.Skip(2)
1976 _bsninterface.Name = string(bytes.Trim(decoder.Read(16), "\x00"))
1977 _bsninterface.Ipv4Addr = net.IP(decoder.Read(4))
1978 _bsninterface.Ipv4Netmask = net.IP(decoder.Read(4))
1979 return _bsninterface, nil
1980}
1981
1982func NewBsnInterface() *BsnInterface {
1983 obj := &BsnInterface{}
1984 return obj
1985}
1986
1987type BsnLacpStatsEntry struct {
1988 PortNo Port
1989 ActorSysPriority uint16
1990 ActorSysMac net.HardwareAddr
1991 ActorPortPriority uint16
1992 ActorPortNum uint16
1993 ActorKey uint16
1994 ConvergenceStatus uint8
1995 PartnerSysPriority uint16
1996 PartnerSysMac net.HardwareAddr
1997 PartnerPortPriority uint16
1998 PartnerPortNum uint16
1999 PartnerKey uint16
2000}
2001
2002type IBsnLacpStatsEntry interface {
2003 goloxi.Serializable
2004 GetPortNo() Port
2005 GetActorSysPriority() uint16
2006 GetActorSysMac() net.HardwareAddr
2007 GetActorPortPriority() uint16
2008 GetActorPortNum() uint16
2009 GetActorKey() uint16
2010 GetConvergenceStatus() uint8
2011 GetPartnerSysPriority() uint16
2012 GetPartnerSysMac() net.HardwareAddr
2013 GetPartnerPortPriority() uint16
2014 GetPartnerPortNum() uint16
2015 GetPartnerKey() uint16
2016}
2017
2018func (self *BsnLacpStatsEntry) GetPortNo() Port {
2019 return self.PortNo
2020}
2021
2022func (self *BsnLacpStatsEntry) SetPortNo(v Port) {
2023 self.PortNo = v
2024}
2025
2026func (self *BsnLacpStatsEntry) GetActorSysPriority() uint16 {
2027 return self.ActorSysPriority
2028}
2029
2030func (self *BsnLacpStatsEntry) SetActorSysPriority(v uint16) {
2031 self.ActorSysPriority = v
2032}
2033
2034func (self *BsnLacpStatsEntry) GetActorSysMac() net.HardwareAddr {
2035 return self.ActorSysMac
2036}
2037
2038func (self *BsnLacpStatsEntry) SetActorSysMac(v net.HardwareAddr) {
2039 self.ActorSysMac = v
2040}
2041
2042func (self *BsnLacpStatsEntry) GetActorPortPriority() uint16 {
2043 return self.ActorPortPriority
2044}
2045
2046func (self *BsnLacpStatsEntry) SetActorPortPriority(v uint16) {
2047 self.ActorPortPriority = v
2048}
2049
2050func (self *BsnLacpStatsEntry) GetActorPortNum() uint16 {
2051 return self.ActorPortNum
2052}
2053
2054func (self *BsnLacpStatsEntry) SetActorPortNum(v uint16) {
2055 self.ActorPortNum = v
2056}
2057
2058func (self *BsnLacpStatsEntry) GetActorKey() uint16 {
2059 return self.ActorKey
2060}
2061
2062func (self *BsnLacpStatsEntry) SetActorKey(v uint16) {
2063 self.ActorKey = v
2064}
2065
2066func (self *BsnLacpStatsEntry) GetConvergenceStatus() uint8 {
2067 return self.ConvergenceStatus
2068}
2069
2070func (self *BsnLacpStatsEntry) SetConvergenceStatus(v uint8) {
2071 self.ConvergenceStatus = v
2072}
2073
2074func (self *BsnLacpStatsEntry) GetPartnerSysPriority() uint16 {
2075 return self.PartnerSysPriority
2076}
2077
2078func (self *BsnLacpStatsEntry) SetPartnerSysPriority(v uint16) {
2079 self.PartnerSysPriority = v
2080}
2081
2082func (self *BsnLacpStatsEntry) GetPartnerSysMac() net.HardwareAddr {
2083 return self.PartnerSysMac
2084}
2085
2086func (self *BsnLacpStatsEntry) SetPartnerSysMac(v net.HardwareAddr) {
2087 self.PartnerSysMac = v
2088}
2089
2090func (self *BsnLacpStatsEntry) GetPartnerPortPriority() uint16 {
2091 return self.PartnerPortPriority
2092}
2093
2094func (self *BsnLacpStatsEntry) SetPartnerPortPriority(v uint16) {
2095 self.PartnerPortPriority = v
2096}
2097
2098func (self *BsnLacpStatsEntry) GetPartnerPortNum() uint16 {
2099 return self.PartnerPortNum
2100}
2101
2102func (self *BsnLacpStatsEntry) SetPartnerPortNum(v uint16) {
2103 self.PartnerPortNum = v
2104}
2105
2106func (self *BsnLacpStatsEntry) GetPartnerKey() uint16 {
2107 return self.PartnerKey
2108}
2109
2110func (self *BsnLacpStatsEntry) SetPartnerKey(v uint16) {
2111 self.PartnerKey = v
2112}
2113
2114func (self *BsnLacpStatsEntry) Serialize(encoder *goloxi.Encoder) error {
2115
2116 self.PortNo.Serialize(encoder)
2117 encoder.PutUint16(uint16(self.ActorSysPriority))
2118 encoder.Write(self.ActorSysMac)
2119 encoder.PutUint16(uint16(self.ActorPortPriority))
2120 encoder.PutUint16(uint16(self.ActorPortNum))
2121 encoder.PutUint16(uint16(self.ActorKey))
2122 encoder.PutUint8(uint8(self.ConvergenceStatus))
2123 encoder.Write(bytes.Repeat([]byte{0}, 1))
2124 encoder.PutUint16(uint16(self.PartnerSysPriority))
2125 encoder.Write(self.PartnerSysMac)
2126 encoder.PutUint16(uint16(self.PartnerPortPriority))
2127 encoder.PutUint16(uint16(self.PartnerPortNum))
2128 encoder.PutUint16(uint16(self.PartnerKey))
2129 encoder.Write(bytes.Repeat([]byte{0}, 2))
2130
2131 return nil
2132}
2133
2134func DecodeBsnLacpStatsEntry(decoder *goloxi.Decoder) (*BsnLacpStatsEntry, error) {
2135 _bsnlacpstatsentry := &BsnLacpStatsEntry{}
2136 if decoder.Length() < 36 {
2137 return nil, fmt.Errorf("BsnLacpStatsEntry packet too short: %d < 36", decoder.Length())
2138 }
2139 _bsnlacpstatsentry.PortNo.Decode(decoder)
2140 _bsnlacpstatsentry.ActorSysPriority = uint16(decoder.ReadUint16())
2141 _bsnlacpstatsentry.ActorSysMac = net.HardwareAddr(decoder.Read(6))
2142 _bsnlacpstatsentry.ActorPortPriority = uint16(decoder.ReadUint16())
2143 _bsnlacpstatsentry.ActorPortNum = uint16(decoder.ReadUint16())
2144 _bsnlacpstatsentry.ActorKey = uint16(decoder.ReadUint16())
2145 _bsnlacpstatsentry.ConvergenceStatus = uint8(decoder.ReadByte())
2146 decoder.Skip(1)
2147 _bsnlacpstatsentry.PartnerSysPriority = uint16(decoder.ReadUint16())
2148 _bsnlacpstatsentry.PartnerSysMac = net.HardwareAddr(decoder.Read(6))
2149 _bsnlacpstatsentry.PartnerPortPriority = uint16(decoder.ReadUint16())
2150 _bsnlacpstatsentry.PartnerPortNum = uint16(decoder.ReadUint16())
2151 _bsnlacpstatsentry.PartnerKey = uint16(decoder.ReadUint16())
2152 decoder.Skip(2)
2153 return _bsnlacpstatsentry, nil
2154}
2155
2156func NewBsnLacpStatsEntry() *BsnLacpStatsEntry {
2157 obj := &BsnLacpStatsEntry{}
2158 return obj
2159}
2160
2161type BsnPortCounterStatsEntry struct {
2162 Length uint16
2163 PortNo Port
2164 Values []*Uint64
2165}
2166
2167type IBsnPortCounterStatsEntry interface {
2168 goloxi.Serializable
2169 GetLength() uint16
2170 GetPortNo() Port
2171 GetValues() []*Uint64
2172}
2173
2174func (self *BsnPortCounterStatsEntry) GetLength() uint16 {
2175 return self.Length
2176}
2177
2178func (self *BsnPortCounterStatsEntry) SetLength(v uint16) {
2179 self.Length = v
2180}
2181
2182func (self *BsnPortCounterStatsEntry) GetPortNo() Port {
2183 return self.PortNo
2184}
2185
2186func (self *BsnPortCounterStatsEntry) SetPortNo(v Port) {
2187 self.PortNo = v
2188}
2189
2190func (self *BsnPortCounterStatsEntry) GetValues() []*Uint64 {
2191 return self.Values
2192}
2193
2194func (self *BsnPortCounterStatsEntry) SetValues(v []*Uint64) {
2195 self.Values = v
2196}
2197
2198func (self *BsnPortCounterStatsEntry) Serialize(encoder *goloxi.Encoder) error {
2199
2200 encoder.PutUint16(uint16(self.Length))
2201 encoder.Write(bytes.Repeat([]byte{0}, 2))
2202 self.PortNo.Serialize(encoder)
2203 for _, obj := range self.Values {
2204 if err := obj.Serialize(encoder); err != nil {
2205 return err
2206 }
2207 }
2208
2209 binary.BigEndian.PutUint16(encoder.Bytes()[0:2], uint16(len(encoder.Bytes())))
2210
2211 return nil
2212}
2213
2214func DecodeBsnPortCounterStatsEntry(decoder *goloxi.Decoder) (*BsnPortCounterStatsEntry, error) {
2215 _bsnportcounterstatsentry := &BsnPortCounterStatsEntry{}
2216 if decoder.Length() < 8 {
2217 return nil, fmt.Errorf("BsnPortCounterStatsEntry packet too short: %d < 8", decoder.Length())
2218 }
2219 _bsnportcounterstatsentry.Length = uint16(decoder.ReadUint16())
2220 oldDecoder := decoder
2221 defer func() { decoder = oldDecoder }()
2222 decoder = decoder.SliceDecoder(int(_bsnportcounterstatsentry.Length), 2+0)
2223 decoder.Skip(2)
2224 _bsnportcounterstatsentry.PortNo.Decode(decoder)
2225
2226 for decoder.Length() >= 8 {
2227 item, err := DecodeUint64(decoder)
2228 if err != nil {
2229 return nil, err
2230 }
2231 if item != nil {
2232 _bsnportcounterstatsentry.Values = append(_bsnportcounterstatsentry.Values, item)
2233 }
2234 }
2235 return _bsnportcounterstatsentry, nil
2236}
2237
2238func NewBsnPortCounterStatsEntry() *BsnPortCounterStatsEntry {
2239 obj := &BsnPortCounterStatsEntry{}
2240 return obj
2241}
2242
2243type BsnSwitchPipelineStatsEntry struct {
2244 Pipeline string
2245}
2246
2247type IBsnSwitchPipelineStatsEntry interface {
2248 goloxi.Serializable
2249 GetPipeline() string
2250}
2251
2252func (self *BsnSwitchPipelineStatsEntry) GetPipeline() string {
2253 return self.Pipeline
2254}
2255
2256func (self *BsnSwitchPipelineStatsEntry) SetPipeline(v string) {
2257 self.Pipeline = v
2258}
2259
2260func (self *BsnSwitchPipelineStatsEntry) Serialize(encoder *goloxi.Encoder) error {
2261
2262 encoder.Write([]byte(self.Pipeline))
2263
2264 return nil
2265}
2266
2267func DecodeBsnSwitchPipelineStatsEntry(decoder *goloxi.Decoder) (*BsnSwitchPipelineStatsEntry, error) {
2268 _bsnswitchpipelinestatsentry := &BsnSwitchPipelineStatsEntry{}
2269 if decoder.Length() < 256 {
2270 return nil, fmt.Errorf("BsnSwitchPipelineStatsEntry packet too short: %d < 256", decoder.Length())
2271 }
2272 _bsnswitchpipelinestatsentry.Pipeline = string(bytes.Trim(decoder.Read(256), "\x00"))
2273 return _bsnswitchpipelinestatsentry, nil
2274}
2275
2276func NewBsnSwitchPipelineStatsEntry() *BsnSwitchPipelineStatsEntry {
2277 obj := &BsnSwitchPipelineStatsEntry{}
2278 return obj
2279}
2280
2281type BsnTableChecksumStatsEntry struct {
2282 TableId uint8
2283 Checksum uint64
2284}
2285
2286type IBsnTableChecksumStatsEntry interface {
2287 goloxi.Serializable
2288 GetTableId() uint8
2289 GetChecksum() uint64
2290}
2291
2292func (self *BsnTableChecksumStatsEntry) GetTableId() uint8 {
2293 return self.TableId
2294}
2295
2296func (self *BsnTableChecksumStatsEntry) SetTableId(v uint8) {
2297 self.TableId = v
2298}
2299
2300func (self *BsnTableChecksumStatsEntry) GetChecksum() uint64 {
2301 return self.Checksum
2302}
2303
2304func (self *BsnTableChecksumStatsEntry) SetChecksum(v uint64) {
2305 self.Checksum = v
2306}
2307
2308func (self *BsnTableChecksumStatsEntry) Serialize(encoder *goloxi.Encoder) error {
2309
2310 encoder.PutUint8(uint8(self.TableId))
2311 encoder.PutUint64(uint64(self.Checksum))
2312
2313 return nil
2314}
2315
2316func DecodeBsnTableChecksumStatsEntry(decoder *goloxi.Decoder) (*BsnTableChecksumStatsEntry, error) {
2317 _bsntablechecksumstatsentry := &BsnTableChecksumStatsEntry{}
2318 if decoder.Length() < 9 {
2319 return nil, fmt.Errorf("BsnTableChecksumStatsEntry packet too short: %d < 9", decoder.Length())
2320 }
2321 _bsntablechecksumstatsentry.TableId = uint8(decoder.ReadByte())
2322 _bsntablechecksumstatsentry.Checksum = uint64(decoder.ReadUint64())
2323 return _bsntablechecksumstatsentry, nil
2324}
2325
2326func NewBsnTableChecksumStatsEntry() *BsnTableChecksumStatsEntry {
2327 obj := &BsnTableChecksumStatsEntry{}
2328 return obj
2329}
2330
2331type BsnTlv struct {
2332 Type uint16
2333 Length uint16
2334}
2335
2336type IBsnTlv interface {
2337 goloxi.Serializable
2338 GetType() uint16
2339 GetLength() uint16
2340}
2341
2342func (self *BsnTlv) GetType() uint16 {
2343 return self.Type
2344}
2345
2346func (self *BsnTlv) SetType(v uint16) {
2347 self.Type = v
2348}
2349
2350func (self *BsnTlv) GetLength() uint16 {
2351 return self.Length
2352}
2353
2354func (self *BsnTlv) SetLength(v uint16) {
2355 self.Length = v
2356}
2357
2358func (self *BsnTlv) Serialize(encoder *goloxi.Encoder) error {
2359
2360 encoder.PutUint16(uint16(self.Type))
2361 encoder.PutUint16(uint16(self.Length))
2362
2363 return nil
2364}
2365
2366func DecodeBsnTlv(decoder *goloxi.Decoder) (IBsnTlv, error) {
2367 _bsntlv := &BsnTlv{}
2368 if decoder.Length() < 4 {
2369 return nil, fmt.Errorf("BsnTlv packet too short: %d < 4", decoder.Length())
2370 }
2371 _bsntlv.Type = uint16(decoder.ReadUint16())
2372 _bsntlv.Length = uint16(decoder.ReadUint16())
2373 oldDecoder := decoder
2374 defer func() { decoder = oldDecoder }()
2375 decoder = decoder.SliceDecoder(int(_bsntlv.Length), 2+2)
2376
2377 switch _bsntlv.Type {
2378 case 0:
2379 return DecodeBsnTlvPort(_bsntlv, decoder)
2380 case 1:
2381 return DecodeBsnTlvMac(_bsntlv, decoder)
2382 case 2:
2383 return DecodeBsnTlvRxPackets(_bsntlv, decoder)
2384 case 3:
2385 return DecodeBsnTlvTxPackets(_bsntlv, decoder)
2386 case 4:
2387 return DecodeBsnTlvIpv4(_bsntlv, decoder)
2388 case 5:
2389 return DecodeBsnTlvIdleTime(_bsntlv, decoder)
2390 case 6:
2391 return DecodeBsnTlvVlanVid(_bsntlv, decoder)
2392 case 7:
2393 return DecodeBsnTlvIdleNotification(_bsntlv, decoder)
2394 case 8:
2395 return DecodeBsnTlvIdleTimeout(_bsntlv, decoder)
2396 case 9:
2397 return DecodeBsnTlvUnicastQueryTimeout(_bsntlv, decoder)
2398 case 10:
2399 return DecodeBsnTlvBroadcastQueryTimeout(_bsntlv, decoder)
2400 case 11:
2401 return DecodeBsnTlvRequestPackets(_bsntlv, decoder)
2402 case 12:
2403 return DecodeBsnTlvReplyPackets(_bsntlv, decoder)
2404 case 13:
2405 return DecodeBsnTlvMissPackets(_bsntlv, decoder)
2406 case 14:
2407 return DecodeBsnTlvCircuitId(_bsntlv, decoder)
2408 case 15:
2409 return DecodeBsnTlvUdfId(_bsntlv, decoder)
2410 case 16:
2411 return DecodeBsnTlvUdfAnchor(_bsntlv, decoder)
2412 case 17:
2413 return DecodeBsnTlvUdfOffset(_bsntlv, decoder)
2414 case 18:
2415 return DecodeBsnTlvUdfLength(_bsntlv, decoder)
2416 case 19:
2417 return DecodeBsnTlvVrf(_bsntlv, decoder)
2418 case 20:
2419 return DecodeBsnTlvQueueId(_bsntlv, decoder)
2420 case 21:
2421 return DecodeBsnTlvQueueWeight(_bsntlv, decoder)
2422 case 22:
2423 return DecodeBsnTlvCrcEnabled(_bsntlv, decoder)
2424 case 23:
2425 return DecodeBsnTlvExternalIp(_bsntlv, decoder)
2426 case 24:
2427 return DecodeBsnTlvExternalMac(_bsntlv, decoder)
2428 case 25:
2429 return DecodeBsnTlvExternalNetmask(_bsntlv, decoder)
2430 case 26:
2431 return DecodeBsnTlvExternalGatewayIp(_bsntlv, decoder)
2432 case 27:
2433 return DecodeBsnTlvInternalMac(_bsntlv, decoder)
2434 case 28:
2435 return DecodeBsnTlvInternalGatewayMac(_bsntlv, decoder)
2436 case 29:
2437 return DecodeBsnTlvExternalGatewayMac(_bsntlv, decoder)
2438 case 30:
2439 return DecodeBsnTlvSamplingRate(_bsntlv, decoder)
2440 case 31:
2441 return DecodeBsnTlvHeaderSize(_bsntlv, decoder)
2442 case 32:
2443 return DecodeBsnTlvEthSrc(_bsntlv, decoder)
2444 case 33:
2445 return DecodeBsnTlvEthDst(_bsntlv, decoder)
2446 case 34:
2447 return DecodeBsnTlvIpv4Src(_bsntlv, decoder)
2448 case 35:
2449 return DecodeBsnTlvIpv4Dst(_bsntlv, decoder)
2450 case 36:
2451 return DecodeBsnTlvUdpSrc(_bsntlv, decoder)
2452 case 37:
2453 return DecodeBsnTlvUdpDst(_bsntlv, decoder)
2454 case 38:
2455 return DecodeBsnTlvSubAgentId(_bsntlv, decoder)
2456 case 39:
2457 return DecodeBsnTlvTxBytes(_bsntlv, decoder)
2458 case 40:
2459 return DecodeBsnTlvActorSystemPriority(_bsntlv, decoder)
2460 case 41:
2461 return DecodeBsnTlvActorSystemMac(_bsntlv, decoder)
2462 case 42:
2463 return DecodeBsnTlvActorPortPriority(_bsntlv, decoder)
2464 case 43:
2465 return DecodeBsnTlvActorPortNum(_bsntlv, decoder)
2466 case 44:
2467 return DecodeBsnTlvActorKey(_bsntlv, decoder)
2468 case 45:
2469 return DecodeBsnTlvConvergenceStatus(_bsntlv, decoder)
2470 case 47:
2471 return DecodeBsnTlvPartnerSystemPriority(_bsntlv, decoder)
2472 case 48:
2473 return DecodeBsnTlvPartnerSystemMac(_bsntlv, decoder)
2474 case 49:
2475 return DecodeBsnTlvPartnerPortPriority(_bsntlv, decoder)
2476 case 50:
2477 return DecodeBsnTlvPartnerPortNum(_bsntlv, decoder)
2478 case 51:
2479 return DecodeBsnTlvPartnerKey(_bsntlv, decoder)
2480 case 52:
2481 return DecodeBsnTlvName(_bsntlv, decoder)
2482 case 53:
2483 return DecodeBsnTlvActorState(_bsntlv, decoder)
2484 case 54:
2485 return DecodeBsnTlvPartnerState(_bsntlv, decoder)
2486 case 55:
2487 return DecodeBsnTlvData(_bsntlv, decoder)
2488 case 56:
2489 return DecodeBsnTlvMacMask(_bsntlv, decoder)
2490 case 57:
2491 return DecodeBsnTlvPriority(_bsntlv, decoder)
2492 case 58:
2493 return DecodeBsnTlvInterval(_bsntlv, decoder)
2494 case 59:
2495 return DecodeBsnTlvReference(_bsntlv, decoder)
2496 case 60:
2497 return DecodeBsnTlvIpv4Netmask(_bsntlv, decoder)
2498 case 61:
2499 return DecodeBsnTlvMplsLabel(_bsntlv, decoder)
2500 case 62:
2501 return DecodeBsnTlvMplsControlWord(_bsntlv, decoder)
2502 case 63:
2503 return DecodeBsnTlvMplsSequenced(_bsntlv, decoder)
2504 case 64:
2505 return DecodeBsnTlvBucket(_bsntlv, decoder)
2506 case 65:
2507 return DecodeBsnTlvTcpSrc(_bsntlv, decoder)
2508 case 66:
2509 return DecodeBsnTlvTcpDst(_bsntlv, decoder)
2510 case 67:
2511 return DecodeBsnTlvIpProto(_bsntlv, decoder)
2512 case 68:
2513 return DecodeBsnTlvIcmpType(_bsntlv, decoder)
2514 case 69:
2515 return DecodeBsnTlvIcmpCode(_bsntlv, decoder)
2516 case 70:
2517 return DecodeBsnTlvIcmpId(_bsntlv, decoder)
2518 case 71:
2519 return DecodeBsnTlvRxBytes(_bsntlv, decoder)
2520 case 72:
2521 return DecodeBsnTlvVlanPcp(_bsntlv, decoder)
2522 case 73:
2523 return DecodeBsnTlvStripVlanOnEgress(_bsntlv, decoder)
2524 case 74:
2525 return DecodeBsnTlvSetLoopbackMode(_bsntlv, decoder)
2526 case 75:
2527 return DecodeBsnTlvStripMplsL2OnIngress(_bsntlv, decoder)
2528 case 76:
2529 return DecodeBsnTlvStripMplsL3OnIngress(_bsntlv, decoder)
2530 case 77:
2531 return DecodeBsnTlvVlanVidMask(_bsntlv, decoder)
2532 case 78:
2533 return DecodeBsnTlvIgmpSnooping(_bsntlv, decoder)
2534 case 79:
2535 return DecodeBsnTlvL2MulticastLookup(_bsntlv, decoder)
2536 case 80:
2537 return DecodeBsnTlvGenerationId(_bsntlv, decoder)
2538 case 81:
2539 return DecodeBsnTlvAnchor(_bsntlv, decoder)
2540 case 82:
2541 return DecodeBsnTlvOffset(_bsntlv, decoder)
2542 case 83:
2543 return DecodeBsnTlvNegate(_bsntlv, decoder)
2544 case 84:
2545 return DecodeBsnTlvIpv6(_bsntlv, decoder)
2546 case 85:
2547 return DecodeBsnTlvDecap(_bsntlv, decoder)
2548 case 86:
2549 return DecodeBsnTlvVni(_bsntlv, decoder)
2550 case 87:
2551 return DecodeBsnTlvMcgTypeVxlan(_bsntlv, decoder)
2552 case 88:
2553 return DecodeBsnTlvPortVxlanMode(_bsntlv, decoder)
2554 case 89:
2555 return DecodeBsnTlvRateUnit(_bsntlv, decoder)
2556 case 90:
2557 return DecodeBsnTlvBroadcastRate(_bsntlv, decoder)
2558 case 91:
2559 return DecodeBsnTlvKnownMulticastRate(_bsntlv, decoder)
2560 case 92:
2561 return DecodeBsnTlvUnknownMulticastRate(_bsntlv, decoder)
2562 case 93:
2563 return DecodeBsnTlvUnicastRate(_bsntlv, decoder)
2564 case 94:
2565 return DecodeBsnTlvNexthopTypeVxlan(_bsntlv, decoder)
2566 case 95:
2567 return DecodeBsnTlvMulticastInterfaceId(_bsntlv, decoder)
2568 case 96:
2569 return DecodeBsnTlvUsePacketState(_bsntlv, decoder)
2570 case 97:
2571 return DecodeBsnTlvStatus(_bsntlv, decoder)
2572 case 98:
2573 return DecodeBsnTlvVlanMacList(_bsntlv, decoder)
2574 case 99:
2575 return DecodeBsnTlvVfi(_bsntlv, decoder)
2576 case 100:
2577 return DecodeBsnTlvHashSeed(_bsntlv, decoder)
2578 case 101:
2579 return DecodeBsnTlvHashType(_bsntlv, decoder)
2580 case 102:
2581 return DecodeBsnTlvHashPacketType(_bsntlv, decoder)
2582 case 103:
2583 return DecodeBsnTlvHashPacketField(_bsntlv, decoder)
2584 case 104:
2585 return DecodeBsnTlvHashGtpHeaderMatch(_bsntlv, decoder)
2586 case 105:
2587 return DecodeBsnTlvHashGtpPortMatch(_bsntlv, decoder)
2588 case 106:
2589 return DecodeBsnTlvUntagged(_bsntlv, decoder)
2590 case 107:
2591 return DecodeBsnTlvVfpClassId(_bsntlv, decoder)
2592 case 108:
2593 return DecodeBsnTlvQosPriority(_bsntlv, decoder)
2594 case 109:
2595 return DecodeBsnTlvParentPort(_bsntlv, decoder)
2596 case 110:
2597 return DecodeBsnTlvLoopbackPort(_bsntlv, decoder)
2598 case 111:
2599 return DecodeBsnTlvVpnKey(_bsntlv, decoder)
2600 case 112:
2601 return DecodeBsnTlvDscp(_bsntlv, decoder)
2602 case 113:
2603 return DecodeBsnTlvTtl(_bsntlv, decoder)
2604 case 114:
2605 return DecodeBsnTlvNextHopMac(_bsntlv, decoder)
2606 case 115:
2607 return DecodeBsnTlvNextHopIpv4(_bsntlv, decoder)
2608 case 116:
2609 return DecodeBsnTlvRateLimit(_bsntlv, decoder)
2610 case 117:
2611 return DecodeBsnTlvVxlanEgressLag(_bsntlv, decoder)
2612 case 118:
2613 return DecodeBsnTlvCpuLag(_bsntlv, decoder)
2614 case 119:
2615 return DecodeBsnTlvUint64List(_bsntlv, decoder)
2616 case 120:
2617 return DecodeBsnTlvDisableSrcMacCheck(_bsntlv, decoder)
2618 case 121:
2619 return DecodeBsnTlvDrop(_bsntlv, decoder)
2620 case 122:
2621 return DecodeBsnTlvIpv6Prefix(_bsntlv, decoder)
2622 case 123:
2623 return DecodeBsnTlvNdpOffload(_bsntlv, decoder)
2624 case 124:
2625 return DecodeBsnTlvNdpStatic(_bsntlv, decoder)
2626 case 125:
2627 return DecodeBsnTlvIcmpv6Chksum(_bsntlv, decoder)
2628 case 126:
2629 return DecodeBsnTlvIpv6Src(_bsntlv, decoder)
2630 case 127:
2631 return DecodeBsnTlvIpv6Dst(_bsntlv, decoder)
2632 case 128:
2633 return DecodeBsnTlvPushVlanOnIngress(_bsntlv, decoder)
2634 case 129:
2635 return DecodeBsnTlvApplyPackets(_bsntlv, decoder)
2636 case 130:
2637 return DecodeBsnTlvApplyBytes(_bsntlv, decoder)
2638 case 131:
2639 return DecodeBsnTlvEthType(_bsntlv, decoder)
2640 case 132:
2641 return DecodeBsnTlvEcn(_bsntlv, decoder)
2642 case 133:
2643 return DecodeBsnTlvTcpFlags(_bsntlv, decoder)
2644 case 134:
2645 return DecodeBsnTlvL3InterfaceClassId(_bsntlv, decoder)
2646 case 135:
2647 return DecodeBsnTlvL3SrcClassId(_bsntlv, decoder)
2648 case 136:
2649 return DecodeBsnTlvL3DstClassId(_bsntlv, decoder)
2650 case 137:
2651 return DecodeBsnTlvEgressOnly(_bsntlv, decoder)
2652 case 138:
2653 return DecodeBsnTlvIngressPortGroupId(_bsntlv, decoder)
2654 case 139:
2655 return DecodeBsnTlvEgressPortGroupId(_bsntlv, decoder)
2656 case 140:
2657 return DecodeBsnTlvDataMask(_bsntlv, decoder)
2658 case 141:
2659 return DecodeBsnTlvPortUsage(_bsntlv, decoder)
2660 case 142:
2661 return DecodeBsnTlvTunnelCapability(_bsntlv, decoder)
2662 case 143:
2663 return DecodeBsnTlvEnhancedHashCapability(_bsntlv, decoder)
2664 case 144:
2665 return DecodeBsnTlvAutoNegotiation(_bsntlv, decoder)
2666 case 145:
2667 return DecodeBsnTlvHashAlgorithm(_bsntlv, decoder)
2668 case 146:
2669 return DecodeBsnTlvLoopbackMode(_bsntlv, decoder)
2670 case 147:
2671 return DecodeBsnTlvNoArpResponse(_bsntlv, decoder)
2672 case 148:
2673 return DecodeBsnTlvNoNsResponse(_bsntlv, decoder)
2674 case 149:
2675 return DecodeBsnTlvForwardErrorCorrection(_bsntlv, decoder)
2676 case 150:
2677 return DecodeBsnTlvOpticsAlwaysEnabled(_bsntlv, decoder)
2678 case 151:
2679 return DecodeBsnTlvForceLinkUp(_bsntlv, decoder)
2680 case 152:
2681 return DecodeBsnTlvRestServer(_bsntlv, decoder)
2682 case 153:
2683 return DecodeBsnTlvUriScheme(_bsntlv, decoder)
2684 case 154:
2685 return DecodeBsnTlvTimestamp(_bsntlv, decoder)
2686 case 155:
2687 return DecodeBsnTlvRecordPackets(_bsntlv, decoder)
2688 case 156:
2689 return DecodeBsnTlvPortSpeedGbps(_bsntlv, decoder)
2690 case 157:
2691 return DecodeBsnTlvOuterSrcMac(_bsntlv, decoder)
2692 case 158:
2693 return DecodeBsnTlvVirtual(_bsntlv, decoder)
2694 case 159:
2695 return DecodeBsnTlvPduaRxInstance(_bsntlv, decoder)
2696 case 160:
2697 return DecodeBsnTlvLagOptions(_bsntlv, decoder)
2698 case 161:
2699 return DecodeBsnTlvRoutingParam(_bsntlv, decoder)
2700 case 162:
2701 return DecodeBsnTlvPushVlanOnEgress(_bsntlv, decoder)
2702 case 163:
2703 return DecodeBsnTlvFlood(_bsntlv, decoder)
2704 case 164:
2705 return DecodeBsnTlvUpgrade(_bsntlv, decoder)
2706 case 165:
2707 return DecodeBsnTlvFabricPortRole(_bsntlv, decoder)
2708 case 166:
2709 return DecodeBsnTlvUserConfigured(_bsntlv, decoder)
2710 case 167:
2711 return DecodeBsnTlvUint32(_bsntlv, decoder)
2712 case 168:
2713 return DecodeBsnTlvL3(_bsntlv, decoder)
2714 case 169:
2715 return DecodeBsnTlvIpTunnelType(_bsntlv, decoder)
2716 case 170:
2717 return DecodeBsnTlvMulticastPacket(_bsntlv, decoder)
2718 case 171:
2719 return DecodeBsnTlvPimDr(_bsntlv, decoder)
2720 case 172:
2721 return DecodeBsnTlvPassive(_bsntlv, decoder)
2722 case 173:
2723 return DecodeBsnTlvIdentifier(_bsntlv, decoder)
2724 case 174:
2725 return DecodeBsnTlvMultiplier(_bsntlv, decoder)
2726 case 175:
2727 return DecodeBsnTlvEncap(_bsntlv, decoder)
2728 case 176:
2729 return DecodeBsnTlvBfdEndpoint(_bsntlv, decoder)
2730 case 177:
2731 return DecodeBsnTlvBfdState(_bsntlv, decoder)
2732 case 178:
2733 return DecodeBsnTlvLrAllEnabled(_bsntlv, decoder)
2734 case 179:
2735 return DecodeBsnTlvPortMode(_bsntlv, decoder)
2736 case 180:
2737 return DecodeBsnTlvUdfCapability(_bsntlv, decoder)
2738 case 181:
2739 return DecodeBsnTlvPimHelloFlood(_bsntlv, decoder)
2740 case 182:
2741 return DecodeBsnTlvFlowClassify(_bsntlv, decoder)
2742 case 183:
2743 return DecodeBsnTlvFlowIdentifier(_bsntlv, decoder)
2744 case 184:
2745 return DecodeBsnTlvFlowClassifier(_bsntlv, decoder)
2746 default:
2747 return nil, fmt.Errorf("Invalid type '%d' for 'BsnTlv'", _bsntlv.Type)
2748 }
2749}
2750
2751func NewBsnTlv(_type uint16) *BsnTlv {
2752 obj := &BsnTlv{}
2753 obj.Type = _type
2754 return obj
2755}
2756
2757type BsnTlvActorKey struct {
2758 *BsnTlv
2759 Value uint16
2760}
2761
2762type IBsnTlvActorKey interface {
2763 IBsnTlv
2764 GetValue() uint16
2765}
2766
2767func (self *BsnTlvActorKey) GetValue() uint16 {
2768 return self.Value
2769}
2770
2771func (self *BsnTlvActorKey) SetValue(v uint16) {
2772 self.Value = v
2773}
2774
2775func (self *BsnTlvActorKey) Serialize(encoder *goloxi.Encoder) error {
2776 if err := self.BsnTlv.Serialize(encoder); err != nil {
2777 return err
2778 }
2779
2780 encoder.PutUint16(uint16(self.Value))
2781
2782 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
2783
2784 return nil
2785}
2786
2787func DecodeBsnTlvActorKey(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvActorKey, error) {
2788 _bsntlvactorkey := &BsnTlvActorKey{BsnTlv: parent}
2789 if decoder.Length() < 2 {
2790 return nil, fmt.Errorf("BsnTlvActorKey packet too short: %d < 2", decoder.Length())
2791 }
2792 _bsntlvactorkey.Value = uint16(decoder.ReadUint16())
2793 return _bsntlvactorkey, nil
2794}
2795
2796func NewBsnTlvActorKey() *BsnTlvActorKey {
2797 obj := &BsnTlvActorKey{
2798 BsnTlv: NewBsnTlv(44),
2799 }
2800 return obj
2801}
2802
2803type BsnTlvActorPortNum struct {
2804 *BsnTlv
2805 Value uint16
2806}
2807
2808type IBsnTlvActorPortNum interface {
2809 IBsnTlv
2810 GetValue() uint16
2811}
2812
2813func (self *BsnTlvActorPortNum) GetValue() uint16 {
2814 return self.Value
2815}
2816
2817func (self *BsnTlvActorPortNum) SetValue(v uint16) {
2818 self.Value = v
2819}
2820
2821func (self *BsnTlvActorPortNum) Serialize(encoder *goloxi.Encoder) error {
2822 if err := self.BsnTlv.Serialize(encoder); err != nil {
2823 return err
2824 }
2825
2826 encoder.PutUint16(uint16(self.Value))
2827
2828 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
2829
2830 return nil
2831}
2832
2833func DecodeBsnTlvActorPortNum(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvActorPortNum, error) {
2834 _bsntlvactorportnum := &BsnTlvActorPortNum{BsnTlv: parent}
2835 if decoder.Length() < 2 {
2836 return nil, fmt.Errorf("BsnTlvActorPortNum packet too short: %d < 2", decoder.Length())
2837 }
2838 _bsntlvactorportnum.Value = uint16(decoder.ReadUint16())
2839 return _bsntlvactorportnum, nil
2840}
2841
2842func NewBsnTlvActorPortNum() *BsnTlvActorPortNum {
2843 obj := &BsnTlvActorPortNum{
2844 BsnTlv: NewBsnTlv(43),
2845 }
2846 return obj
2847}
2848
2849type BsnTlvActorPortPriority struct {
2850 *BsnTlv
2851 Value uint16
2852}
2853
2854type IBsnTlvActorPortPriority interface {
2855 IBsnTlv
2856 GetValue() uint16
2857}
2858
2859func (self *BsnTlvActorPortPriority) GetValue() uint16 {
2860 return self.Value
2861}
2862
2863func (self *BsnTlvActorPortPriority) SetValue(v uint16) {
2864 self.Value = v
2865}
2866
2867func (self *BsnTlvActorPortPriority) Serialize(encoder *goloxi.Encoder) error {
2868 if err := self.BsnTlv.Serialize(encoder); err != nil {
2869 return err
2870 }
2871
2872 encoder.PutUint16(uint16(self.Value))
2873
2874 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
2875
2876 return nil
2877}
2878
2879func DecodeBsnTlvActorPortPriority(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvActorPortPriority, error) {
2880 _bsntlvactorportpriority := &BsnTlvActorPortPriority{BsnTlv: parent}
2881 if decoder.Length() < 2 {
2882 return nil, fmt.Errorf("BsnTlvActorPortPriority packet too short: %d < 2", decoder.Length())
2883 }
2884 _bsntlvactorportpriority.Value = uint16(decoder.ReadUint16())
2885 return _bsntlvactorportpriority, nil
2886}
2887
2888func NewBsnTlvActorPortPriority() *BsnTlvActorPortPriority {
2889 obj := &BsnTlvActorPortPriority{
2890 BsnTlv: NewBsnTlv(42),
2891 }
2892 return obj
2893}
2894
2895type BsnTlvActorState struct {
2896 *BsnTlv
2897 Value BsnLacpState
2898}
2899
2900type IBsnTlvActorState interface {
2901 IBsnTlv
2902 GetValue() BsnLacpState
2903}
2904
2905func (self *BsnTlvActorState) GetValue() BsnLacpState {
2906 return self.Value
2907}
2908
2909func (self *BsnTlvActorState) SetValue(v BsnLacpState) {
2910 self.Value = v
2911}
2912
2913func (self *BsnTlvActorState) Serialize(encoder *goloxi.Encoder) error {
2914 if err := self.BsnTlv.Serialize(encoder); err != nil {
2915 return err
2916 }
2917
2918 encoder.PutUint8(uint8(self.Value))
2919
2920 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
2921
2922 return nil
2923}
2924
2925func DecodeBsnTlvActorState(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvActorState, error) {
2926 _bsntlvactorstate := &BsnTlvActorState{BsnTlv: parent}
2927 if decoder.Length() < 1 {
2928 return nil, fmt.Errorf("BsnTlvActorState packet too short: %d < 1", decoder.Length())
2929 }
2930 _bsntlvactorstate.Value = BsnLacpState(decoder.ReadByte())
2931 return _bsntlvactorstate, nil
2932}
2933
2934func NewBsnTlvActorState() *BsnTlvActorState {
2935 obj := &BsnTlvActorState{
2936 BsnTlv: NewBsnTlv(53),
2937 }
2938 return obj
2939}
2940
2941type BsnTlvActorSystemMac struct {
2942 *BsnTlv
2943 Value net.HardwareAddr
2944}
2945
2946type IBsnTlvActorSystemMac interface {
2947 IBsnTlv
2948 GetValue() net.HardwareAddr
2949}
2950
2951func (self *BsnTlvActorSystemMac) GetValue() net.HardwareAddr {
2952 return self.Value
2953}
2954
2955func (self *BsnTlvActorSystemMac) SetValue(v net.HardwareAddr) {
2956 self.Value = v
2957}
2958
2959func (self *BsnTlvActorSystemMac) Serialize(encoder *goloxi.Encoder) error {
2960 if err := self.BsnTlv.Serialize(encoder); err != nil {
2961 return err
2962 }
2963
2964 encoder.Write(self.Value)
2965
2966 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
2967
2968 return nil
2969}
2970
2971func DecodeBsnTlvActorSystemMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvActorSystemMac, error) {
2972 _bsntlvactorsystemmac := &BsnTlvActorSystemMac{BsnTlv: parent}
2973 if decoder.Length() < 6 {
2974 return nil, fmt.Errorf("BsnTlvActorSystemMac packet too short: %d < 6", decoder.Length())
2975 }
2976 _bsntlvactorsystemmac.Value = net.HardwareAddr(decoder.Read(6))
2977 return _bsntlvactorsystemmac, nil
2978}
2979
2980func NewBsnTlvActorSystemMac() *BsnTlvActorSystemMac {
2981 obj := &BsnTlvActorSystemMac{
2982 BsnTlv: NewBsnTlv(41),
2983 }
2984 return obj
2985}
2986
2987type BsnTlvActorSystemPriority struct {
2988 *BsnTlv
2989 Value uint16
2990}
2991
2992type IBsnTlvActorSystemPriority interface {
2993 IBsnTlv
2994 GetValue() uint16
2995}
2996
2997func (self *BsnTlvActorSystemPriority) GetValue() uint16 {
2998 return self.Value
2999}
3000
3001func (self *BsnTlvActorSystemPriority) SetValue(v uint16) {
3002 self.Value = v
3003}
3004
3005func (self *BsnTlvActorSystemPriority) Serialize(encoder *goloxi.Encoder) error {
3006 if err := self.BsnTlv.Serialize(encoder); err != nil {
3007 return err
3008 }
3009
3010 encoder.PutUint16(uint16(self.Value))
3011
3012 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
3013
3014 return nil
3015}
3016
3017func DecodeBsnTlvActorSystemPriority(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvActorSystemPriority, error) {
3018 _bsntlvactorsystempriority := &BsnTlvActorSystemPriority{BsnTlv: parent}
3019 if decoder.Length() < 2 {
3020 return nil, fmt.Errorf("BsnTlvActorSystemPriority packet too short: %d < 2", decoder.Length())
3021 }
3022 _bsntlvactorsystempriority.Value = uint16(decoder.ReadUint16())
3023 return _bsntlvactorsystempriority, nil
3024}
3025
3026func NewBsnTlvActorSystemPriority() *BsnTlvActorSystemPriority {
3027 obj := &BsnTlvActorSystemPriority{
3028 BsnTlv: NewBsnTlv(40),
3029 }
3030 return obj
3031}
3032
3033type BsnTlvAnchor struct {
3034 *BsnTlv
3035 Value BsnAnchor
3036}
3037
3038type IBsnTlvAnchor interface {
3039 IBsnTlv
3040 GetValue() BsnAnchor
3041}
3042
3043func (self *BsnTlvAnchor) GetValue() BsnAnchor {
3044 return self.Value
3045}
3046
3047func (self *BsnTlvAnchor) SetValue(v BsnAnchor) {
3048 self.Value = v
3049}
3050
3051func (self *BsnTlvAnchor) Serialize(encoder *goloxi.Encoder) error {
3052 if err := self.BsnTlv.Serialize(encoder); err != nil {
3053 return err
3054 }
3055
3056 encoder.PutUint16(uint16(self.Value))
3057
3058 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
3059
3060 return nil
3061}
3062
3063func DecodeBsnTlvAnchor(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvAnchor, error) {
3064 _bsntlvanchor := &BsnTlvAnchor{BsnTlv: parent}
3065 if decoder.Length() < 2 {
3066 return nil, fmt.Errorf("BsnTlvAnchor packet too short: %d < 2", decoder.Length())
3067 }
3068 _bsntlvanchor.Value = BsnAnchor(decoder.ReadUint16())
3069 return _bsntlvanchor, nil
3070}
3071
3072func NewBsnTlvAnchor() *BsnTlvAnchor {
3073 obj := &BsnTlvAnchor{
3074 BsnTlv: NewBsnTlv(81),
3075 }
3076 return obj
3077}
3078
3079type BsnTlvApplyBytes struct {
3080 *BsnTlv
3081 Value uint64
3082}
3083
3084type IBsnTlvApplyBytes interface {
3085 IBsnTlv
3086 GetValue() uint64
3087}
3088
3089func (self *BsnTlvApplyBytes) GetValue() uint64 {
3090 return self.Value
3091}
3092
3093func (self *BsnTlvApplyBytes) SetValue(v uint64) {
3094 self.Value = v
3095}
3096
3097func (self *BsnTlvApplyBytes) Serialize(encoder *goloxi.Encoder) error {
3098 if err := self.BsnTlv.Serialize(encoder); err != nil {
3099 return err
3100 }
3101
3102 encoder.PutUint64(uint64(self.Value))
3103
3104 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
3105
3106 return nil
3107}
3108
3109func DecodeBsnTlvApplyBytes(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvApplyBytes, error) {
3110 _bsntlvapplybytes := &BsnTlvApplyBytes{BsnTlv: parent}
3111 if decoder.Length() < 8 {
3112 return nil, fmt.Errorf("BsnTlvApplyBytes packet too short: %d < 8", decoder.Length())
3113 }
3114 _bsntlvapplybytes.Value = uint64(decoder.ReadUint64())
3115 return _bsntlvapplybytes, nil
3116}
3117
3118func NewBsnTlvApplyBytes() *BsnTlvApplyBytes {
3119 obj := &BsnTlvApplyBytes{
3120 BsnTlv: NewBsnTlv(130),
3121 }
3122 return obj
3123}
3124
3125type BsnTlvApplyPackets struct {
3126 *BsnTlv
3127 Value uint64
3128}
3129
3130type IBsnTlvApplyPackets interface {
3131 IBsnTlv
3132 GetValue() uint64
3133}
3134
3135func (self *BsnTlvApplyPackets) GetValue() uint64 {
3136 return self.Value
3137}
3138
3139func (self *BsnTlvApplyPackets) SetValue(v uint64) {
3140 self.Value = v
3141}
3142
3143func (self *BsnTlvApplyPackets) Serialize(encoder *goloxi.Encoder) error {
3144 if err := self.BsnTlv.Serialize(encoder); err != nil {
3145 return err
3146 }
3147
3148 encoder.PutUint64(uint64(self.Value))
3149
3150 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
3151
3152 return nil
3153}
3154
3155func DecodeBsnTlvApplyPackets(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvApplyPackets, error) {
3156 _bsntlvapplypackets := &BsnTlvApplyPackets{BsnTlv: parent}
3157 if decoder.Length() < 8 {
3158 return nil, fmt.Errorf("BsnTlvApplyPackets packet too short: %d < 8", decoder.Length())
3159 }
3160 _bsntlvapplypackets.Value = uint64(decoder.ReadUint64())
3161 return _bsntlvapplypackets, nil
3162}
3163
3164func NewBsnTlvApplyPackets() *BsnTlvApplyPackets {
3165 obj := &BsnTlvApplyPackets{
3166 BsnTlv: NewBsnTlv(129),
3167 }
3168 return obj
3169}
3170
3171type BsnTlvAutoNegotiation struct {
3172 *BsnTlv
3173 Value BsnAutoNegotiationType
3174}
3175
3176type IBsnTlvAutoNegotiation interface {
3177 IBsnTlv
3178 GetValue() BsnAutoNegotiationType
3179}
3180
3181func (self *BsnTlvAutoNegotiation) GetValue() BsnAutoNegotiationType {
3182 return self.Value
3183}
3184
3185func (self *BsnTlvAutoNegotiation) SetValue(v BsnAutoNegotiationType) {
3186 self.Value = v
3187}
3188
3189func (self *BsnTlvAutoNegotiation) Serialize(encoder *goloxi.Encoder) error {
3190 if err := self.BsnTlv.Serialize(encoder); err != nil {
3191 return err
3192 }
3193
3194 encoder.PutUint8(uint8(self.Value))
3195
3196 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
3197
3198 return nil
3199}
3200
3201func DecodeBsnTlvAutoNegotiation(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvAutoNegotiation, error) {
3202 _bsntlvautonegotiation := &BsnTlvAutoNegotiation{BsnTlv: parent}
3203 if decoder.Length() < 1 {
3204 return nil, fmt.Errorf("BsnTlvAutoNegotiation packet too short: %d < 1", decoder.Length())
3205 }
3206 _bsntlvautonegotiation.Value = BsnAutoNegotiationType(decoder.ReadByte())
3207 return _bsntlvautonegotiation, nil
3208}
3209
3210func NewBsnTlvAutoNegotiation() *BsnTlvAutoNegotiation {
3211 obj := &BsnTlvAutoNegotiation{
3212 BsnTlv: NewBsnTlv(144),
3213 }
3214 return obj
3215}
3216
3217type BsnTlvBfdEndpoint struct {
3218 *BsnTlv
3219 Value BsnBfdEndpoint
3220}
3221
3222type IBsnTlvBfdEndpoint interface {
3223 IBsnTlv
3224 GetValue() BsnBfdEndpoint
3225}
3226
3227func (self *BsnTlvBfdEndpoint) GetValue() BsnBfdEndpoint {
3228 return self.Value
3229}
3230
3231func (self *BsnTlvBfdEndpoint) SetValue(v BsnBfdEndpoint) {
3232 self.Value = v
3233}
3234
3235func (self *BsnTlvBfdEndpoint) Serialize(encoder *goloxi.Encoder) error {
3236 if err := self.BsnTlv.Serialize(encoder); err != nil {
3237 return err
3238 }
3239
3240 encoder.PutUint8(uint8(self.Value))
3241
3242 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
3243
3244 return nil
3245}
3246
3247func DecodeBsnTlvBfdEndpoint(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvBfdEndpoint, error) {
3248 _bsntlvbfdendpoint := &BsnTlvBfdEndpoint{BsnTlv: parent}
3249 if decoder.Length() < 1 {
3250 return nil, fmt.Errorf("BsnTlvBfdEndpoint packet too short: %d < 1", decoder.Length())
3251 }
3252 _bsntlvbfdendpoint.Value = BsnBfdEndpoint(decoder.ReadByte())
3253 return _bsntlvbfdendpoint, nil
3254}
3255
3256func NewBsnTlvBfdEndpoint() *BsnTlvBfdEndpoint {
3257 obj := &BsnTlvBfdEndpoint{
3258 BsnTlv: NewBsnTlv(176),
3259 }
3260 return obj
3261}
3262
3263type BsnTlvBfdState struct {
3264 *BsnTlv
3265 Value BsnBfdEndpointState
3266}
3267
3268type IBsnTlvBfdState interface {
3269 IBsnTlv
3270 GetValue() BsnBfdEndpointState
3271}
3272
3273func (self *BsnTlvBfdState) GetValue() BsnBfdEndpointState {
3274 return self.Value
3275}
3276
3277func (self *BsnTlvBfdState) SetValue(v BsnBfdEndpointState) {
3278 self.Value = v
3279}
3280
3281func (self *BsnTlvBfdState) Serialize(encoder *goloxi.Encoder) error {
3282 if err := self.BsnTlv.Serialize(encoder); err != nil {
3283 return err
3284 }
3285
3286 encoder.PutUint8(uint8(self.Value))
3287
3288 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
3289
3290 return nil
3291}
3292
3293func DecodeBsnTlvBfdState(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvBfdState, error) {
3294 _bsntlvbfdstate := &BsnTlvBfdState{BsnTlv: parent}
3295 if decoder.Length() < 1 {
3296 return nil, fmt.Errorf("BsnTlvBfdState packet too short: %d < 1", decoder.Length())
3297 }
3298 _bsntlvbfdstate.Value = BsnBfdEndpointState(decoder.ReadByte())
3299 return _bsntlvbfdstate, nil
3300}
3301
3302func NewBsnTlvBfdState() *BsnTlvBfdState {
3303 obj := &BsnTlvBfdState{
3304 BsnTlv: NewBsnTlv(177),
3305 }
3306 return obj
3307}
3308
3309type BsnTlvBroadcastQueryTimeout struct {
3310 *BsnTlv
3311 Value uint32
3312}
3313
3314type IBsnTlvBroadcastQueryTimeout interface {
3315 IBsnTlv
3316 GetValue() uint32
3317}
3318
3319func (self *BsnTlvBroadcastQueryTimeout) GetValue() uint32 {
3320 return self.Value
3321}
3322
3323func (self *BsnTlvBroadcastQueryTimeout) SetValue(v uint32) {
3324 self.Value = v
3325}
3326
3327func (self *BsnTlvBroadcastQueryTimeout) Serialize(encoder *goloxi.Encoder) error {
3328 if err := self.BsnTlv.Serialize(encoder); err != nil {
3329 return err
3330 }
3331
3332 encoder.PutUint32(uint32(self.Value))
3333
3334 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
3335
3336 return nil
3337}
3338
3339func DecodeBsnTlvBroadcastQueryTimeout(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvBroadcastQueryTimeout, error) {
3340 _bsntlvbroadcastquerytimeout := &BsnTlvBroadcastQueryTimeout{BsnTlv: parent}
3341 if decoder.Length() < 4 {
3342 return nil, fmt.Errorf("BsnTlvBroadcastQueryTimeout packet too short: %d < 4", decoder.Length())
3343 }
3344 _bsntlvbroadcastquerytimeout.Value = uint32(decoder.ReadUint32())
3345 return _bsntlvbroadcastquerytimeout, nil
3346}
3347
3348func NewBsnTlvBroadcastQueryTimeout() *BsnTlvBroadcastQueryTimeout {
3349 obj := &BsnTlvBroadcastQueryTimeout{
3350 BsnTlv: NewBsnTlv(10),
3351 }
3352 return obj
3353}
3354
3355type BsnTlvBroadcastRate struct {
3356 *BsnTlv
3357 Value uint32
3358}
3359
3360type IBsnTlvBroadcastRate interface {
3361 IBsnTlv
3362 GetValue() uint32
3363}
3364
3365func (self *BsnTlvBroadcastRate) GetValue() uint32 {
3366 return self.Value
3367}
3368
3369func (self *BsnTlvBroadcastRate) SetValue(v uint32) {
3370 self.Value = v
3371}
3372
3373func (self *BsnTlvBroadcastRate) Serialize(encoder *goloxi.Encoder) error {
3374 if err := self.BsnTlv.Serialize(encoder); err != nil {
3375 return err
3376 }
3377
3378 encoder.PutUint32(uint32(self.Value))
3379
3380 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
3381
3382 return nil
3383}
3384
3385func DecodeBsnTlvBroadcastRate(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvBroadcastRate, error) {
3386 _bsntlvbroadcastrate := &BsnTlvBroadcastRate{BsnTlv: parent}
3387 if decoder.Length() < 4 {
3388 return nil, fmt.Errorf("BsnTlvBroadcastRate packet too short: %d < 4", decoder.Length())
3389 }
3390 _bsntlvbroadcastrate.Value = uint32(decoder.ReadUint32())
3391 return _bsntlvbroadcastrate, nil
3392}
3393
3394func NewBsnTlvBroadcastRate() *BsnTlvBroadcastRate {
3395 obj := &BsnTlvBroadcastRate{
3396 BsnTlv: NewBsnTlv(90),
3397 }
3398 return obj
3399}
3400
3401type BsnTlvBucket struct {
3402 *BsnTlv
3403 Value []IBsnTlv
3404}
3405
3406type IBsnTlvBucket interface {
3407 IBsnTlv
3408 GetValue() []IBsnTlv
3409}
3410
3411func (self *BsnTlvBucket) GetValue() []IBsnTlv {
3412 return self.Value
3413}
3414
3415func (self *BsnTlvBucket) SetValue(v []IBsnTlv) {
3416 self.Value = v
3417}
3418
3419func (self *BsnTlvBucket) Serialize(encoder *goloxi.Encoder) error {
3420 if err := self.BsnTlv.Serialize(encoder); err != nil {
3421 return err
3422 }
3423
3424 for _, obj := range self.Value {
3425 if err := obj.Serialize(encoder); err != nil {
3426 return err
3427 }
3428 }
3429
3430 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
3431
3432 return nil
3433}
3434
3435func DecodeBsnTlvBucket(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvBucket, error) {
3436 _bsntlvbucket := &BsnTlvBucket{BsnTlv: parent}
3437
3438 for decoder.Length() >= 4 {
3439 item, err := DecodeBsnTlv(decoder)
3440 if err != nil {
3441 return nil, err
3442 }
3443 if item != nil {
3444 _bsntlvbucket.Value = append(_bsntlvbucket.Value, item)
3445 }
3446 }
3447 return _bsntlvbucket, nil
3448}
3449
3450func NewBsnTlvBucket() *BsnTlvBucket {
3451 obj := &BsnTlvBucket{
3452 BsnTlv: NewBsnTlv(64),
3453 }
3454 return obj
3455}
3456
3457type BsnTlvCircuitId struct {
3458 *BsnTlv
3459 Value []byte
3460}
3461
3462type IBsnTlvCircuitId interface {
3463 IBsnTlv
3464 GetValue() []byte
3465}
3466
3467func (self *BsnTlvCircuitId) GetValue() []byte {
3468 return self.Value
3469}
3470
3471func (self *BsnTlvCircuitId) SetValue(v []byte) {
3472 self.Value = v
3473}
3474
3475func (self *BsnTlvCircuitId) Serialize(encoder *goloxi.Encoder) error {
3476 if err := self.BsnTlv.Serialize(encoder); err != nil {
3477 return err
3478 }
3479
3480 encoder.Write(self.Value)
3481
3482 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
3483
3484 return nil
3485}
3486
3487func DecodeBsnTlvCircuitId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvCircuitId, error) {
3488 _bsntlvcircuitid := &BsnTlvCircuitId{BsnTlv: parent}
3489 _bsntlvcircuitid.Value = decoder.Read(int(decoder.Length()))
3490 return _bsntlvcircuitid, nil
3491}
3492
3493func NewBsnTlvCircuitId() *BsnTlvCircuitId {
3494 obj := &BsnTlvCircuitId{
3495 BsnTlv: NewBsnTlv(14),
3496 }
3497 return obj
3498}
3499
3500type BsnTlvConvergenceStatus struct {
3501 *BsnTlv
3502 Value uint8
3503}
3504
3505type IBsnTlvConvergenceStatus interface {
3506 IBsnTlv
3507 GetValue() uint8
3508}
3509
3510func (self *BsnTlvConvergenceStatus) GetValue() uint8 {
3511 return self.Value
3512}
3513
3514func (self *BsnTlvConvergenceStatus) SetValue(v uint8) {
3515 self.Value = v
3516}
3517
3518func (self *BsnTlvConvergenceStatus) Serialize(encoder *goloxi.Encoder) error {
3519 if err := self.BsnTlv.Serialize(encoder); err != nil {
3520 return err
3521 }
3522
3523 encoder.PutUint8(uint8(self.Value))
3524
3525 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
3526
3527 return nil
3528}
3529
3530func DecodeBsnTlvConvergenceStatus(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvConvergenceStatus, error) {
3531 _bsntlvconvergencestatus := &BsnTlvConvergenceStatus{BsnTlv: parent}
3532 if decoder.Length() < 1 {
3533 return nil, fmt.Errorf("BsnTlvConvergenceStatus packet too short: %d < 1", decoder.Length())
3534 }
3535 _bsntlvconvergencestatus.Value = uint8(decoder.ReadByte())
3536 return _bsntlvconvergencestatus, nil
3537}
3538
3539func NewBsnTlvConvergenceStatus() *BsnTlvConvergenceStatus {
3540 obj := &BsnTlvConvergenceStatus{
3541 BsnTlv: NewBsnTlv(45),
3542 }
3543 return obj
3544}
3545
3546type BsnTlvCpuLag struct {
3547 *BsnTlv
3548}
3549
3550type IBsnTlvCpuLag interface {
3551 IBsnTlv
3552}
3553
3554func (self *BsnTlvCpuLag) Serialize(encoder *goloxi.Encoder) error {
3555 if err := self.BsnTlv.Serialize(encoder); err != nil {
3556 return err
3557 }
3558
3559 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
3560
3561 return nil
3562}
3563
3564func DecodeBsnTlvCpuLag(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvCpuLag, error) {
3565 _bsntlvcpulag := &BsnTlvCpuLag{BsnTlv: parent}
3566 return _bsntlvcpulag, nil
3567}
3568
3569func NewBsnTlvCpuLag() *BsnTlvCpuLag {
3570 obj := &BsnTlvCpuLag{
3571 BsnTlv: NewBsnTlv(118),
3572 }
3573 return obj
3574}
3575
3576type BsnTlvCrcEnabled struct {
3577 *BsnTlv
3578 Value uint8
3579}
3580
3581type IBsnTlvCrcEnabled interface {
3582 IBsnTlv
3583 GetValue() uint8
3584}
3585
3586func (self *BsnTlvCrcEnabled) GetValue() uint8 {
3587 return self.Value
3588}
3589
3590func (self *BsnTlvCrcEnabled) SetValue(v uint8) {
3591 self.Value = v
3592}
3593
3594func (self *BsnTlvCrcEnabled) Serialize(encoder *goloxi.Encoder) error {
3595 if err := self.BsnTlv.Serialize(encoder); err != nil {
3596 return err
3597 }
3598
3599 encoder.PutUint8(uint8(self.Value))
3600
3601 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
3602
3603 return nil
3604}
3605
3606func DecodeBsnTlvCrcEnabled(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvCrcEnabled, error) {
3607 _bsntlvcrcenabled := &BsnTlvCrcEnabled{BsnTlv: parent}
3608 if decoder.Length() < 1 {
3609 return nil, fmt.Errorf("BsnTlvCrcEnabled packet too short: %d < 1", decoder.Length())
3610 }
3611 _bsntlvcrcenabled.Value = uint8(decoder.ReadByte())
3612 return _bsntlvcrcenabled, nil
3613}
3614
3615func NewBsnTlvCrcEnabled() *BsnTlvCrcEnabled {
3616 obj := &BsnTlvCrcEnabled{
3617 BsnTlv: NewBsnTlv(22),
3618 }
3619 return obj
3620}
3621
3622type BsnTlvData struct {
3623 *BsnTlv
3624 Value []byte
3625}
3626
3627type IBsnTlvData interface {
3628 IBsnTlv
3629 GetValue() []byte
3630}
3631
3632func (self *BsnTlvData) GetValue() []byte {
3633 return self.Value
3634}
3635
3636func (self *BsnTlvData) SetValue(v []byte) {
3637 self.Value = v
3638}
3639
3640func (self *BsnTlvData) Serialize(encoder *goloxi.Encoder) error {
3641 if err := self.BsnTlv.Serialize(encoder); err != nil {
3642 return err
3643 }
3644
3645 encoder.Write(self.Value)
3646
3647 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
3648
3649 return nil
3650}
3651
3652func DecodeBsnTlvData(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvData, error) {
3653 _bsntlvdata := &BsnTlvData{BsnTlv: parent}
3654 _bsntlvdata.Value = decoder.Read(int(decoder.Length()))
3655 return _bsntlvdata, nil
3656}
3657
3658func NewBsnTlvData() *BsnTlvData {
3659 obj := &BsnTlvData{
3660 BsnTlv: NewBsnTlv(55),
3661 }
3662 return obj
3663}
3664
3665type BsnTlvDataMask struct {
3666 *BsnTlv
3667 Value []byte
3668}
3669
3670type IBsnTlvDataMask interface {
3671 IBsnTlv
3672 GetValue() []byte
3673}
3674
3675func (self *BsnTlvDataMask) GetValue() []byte {
3676 return self.Value
3677}
3678
3679func (self *BsnTlvDataMask) SetValue(v []byte) {
3680 self.Value = v
3681}
3682
3683func (self *BsnTlvDataMask) Serialize(encoder *goloxi.Encoder) error {
3684 if err := self.BsnTlv.Serialize(encoder); err != nil {
3685 return err
3686 }
3687
3688 encoder.Write(self.Value)
3689
3690 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
3691
3692 return nil
3693}
3694
3695func DecodeBsnTlvDataMask(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvDataMask, error) {
3696 _bsntlvdatamask := &BsnTlvDataMask{BsnTlv: parent}
3697 _bsntlvdatamask.Value = decoder.Read(int(decoder.Length()))
3698 return _bsntlvdatamask, nil
3699}
3700
3701func NewBsnTlvDataMask() *BsnTlvDataMask {
3702 obj := &BsnTlvDataMask{
3703 BsnTlv: NewBsnTlv(140),
3704 }
3705 return obj
3706}
3707
3708type BsnTlvDecap struct {
3709 *BsnTlv
3710 Value BsnDecap
3711}
3712
3713type IBsnTlvDecap interface {
3714 IBsnTlv
3715 GetValue() BsnDecap
3716}
3717
3718func (self *BsnTlvDecap) GetValue() BsnDecap {
3719 return self.Value
3720}
3721
3722func (self *BsnTlvDecap) SetValue(v BsnDecap) {
3723 self.Value = v
3724}
3725
3726func (self *BsnTlvDecap) Serialize(encoder *goloxi.Encoder) error {
3727 if err := self.BsnTlv.Serialize(encoder); err != nil {
3728 return err
3729 }
3730
3731 encoder.PutUint16(uint16(self.Value))
3732
3733 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
3734
3735 return nil
3736}
3737
3738func DecodeBsnTlvDecap(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvDecap, error) {
3739 _bsntlvdecap := &BsnTlvDecap{BsnTlv: parent}
3740 if decoder.Length() < 2 {
3741 return nil, fmt.Errorf("BsnTlvDecap packet too short: %d < 2", decoder.Length())
3742 }
3743 _bsntlvdecap.Value = BsnDecap(decoder.ReadUint16())
3744 return _bsntlvdecap, nil
3745}
3746
3747func NewBsnTlvDecap() *BsnTlvDecap {
3748 obj := &BsnTlvDecap{
3749 BsnTlv: NewBsnTlv(85),
3750 }
3751 return obj
3752}
3753
3754type BsnTlvDisableSrcMacCheck struct {
3755 *BsnTlv
3756}
3757
3758type IBsnTlvDisableSrcMacCheck interface {
3759 IBsnTlv
3760}
3761
3762func (self *BsnTlvDisableSrcMacCheck) Serialize(encoder *goloxi.Encoder) error {
3763 if err := self.BsnTlv.Serialize(encoder); err != nil {
3764 return err
3765 }
3766
3767 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
3768
3769 return nil
3770}
3771
3772func DecodeBsnTlvDisableSrcMacCheck(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvDisableSrcMacCheck, error) {
3773 _bsntlvdisablesrcmaccheck := &BsnTlvDisableSrcMacCheck{BsnTlv: parent}
3774 return _bsntlvdisablesrcmaccheck, nil
3775}
3776
3777func NewBsnTlvDisableSrcMacCheck() *BsnTlvDisableSrcMacCheck {
3778 obj := &BsnTlvDisableSrcMacCheck{
3779 BsnTlv: NewBsnTlv(120),
3780 }
3781 return obj
3782}
3783
3784type BsnTlvDrop struct {
3785 *BsnTlv
3786}
3787
3788type IBsnTlvDrop interface {
3789 IBsnTlv
3790}
3791
3792func (self *BsnTlvDrop) Serialize(encoder *goloxi.Encoder) error {
3793 if err := self.BsnTlv.Serialize(encoder); err != nil {
3794 return err
3795 }
3796
3797 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
3798
3799 return nil
3800}
3801
3802func DecodeBsnTlvDrop(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvDrop, error) {
3803 _bsntlvdrop := &BsnTlvDrop{BsnTlv: parent}
3804 return _bsntlvdrop, nil
3805}
3806
3807func NewBsnTlvDrop() *BsnTlvDrop {
3808 obj := &BsnTlvDrop{
3809 BsnTlv: NewBsnTlv(121),
3810 }
3811 return obj
3812}
3813
3814type BsnTlvDscp struct {
3815 *BsnTlv
3816 Value uint16
3817}
3818
3819type IBsnTlvDscp interface {
3820 IBsnTlv
3821 GetValue() uint16
3822}
3823
3824func (self *BsnTlvDscp) GetValue() uint16 {
3825 return self.Value
3826}
3827
3828func (self *BsnTlvDscp) SetValue(v uint16) {
3829 self.Value = v
3830}
3831
3832func (self *BsnTlvDscp) Serialize(encoder *goloxi.Encoder) error {
3833 if err := self.BsnTlv.Serialize(encoder); err != nil {
3834 return err
3835 }
3836
3837 encoder.PutUint16(uint16(self.Value))
3838
3839 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
3840
3841 return nil
3842}
3843
3844func DecodeBsnTlvDscp(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvDscp, error) {
3845 _bsntlvdscp := &BsnTlvDscp{BsnTlv: parent}
3846 if decoder.Length() < 2 {
3847 return nil, fmt.Errorf("BsnTlvDscp packet too short: %d < 2", decoder.Length())
3848 }
3849 _bsntlvdscp.Value = uint16(decoder.ReadUint16())
3850 return _bsntlvdscp, nil
3851}
3852
3853func NewBsnTlvDscp() *BsnTlvDscp {
3854 obj := &BsnTlvDscp{
3855 BsnTlv: NewBsnTlv(112),
3856 }
3857 return obj
3858}
3859
3860type BsnTlvEcn struct {
3861 *BsnTlv
3862 Value uint8
3863}
3864
3865type IBsnTlvEcn interface {
3866 IBsnTlv
3867 GetValue() uint8
3868}
3869
3870func (self *BsnTlvEcn) GetValue() uint8 {
3871 return self.Value
3872}
3873
3874func (self *BsnTlvEcn) SetValue(v uint8) {
3875 self.Value = v
3876}
3877
3878func (self *BsnTlvEcn) Serialize(encoder *goloxi.Encoder) error {
3879 if err := self.BsnTlv.Serialize(encoder); err != nil {
3880 return err
3881 }
3882
3883 encoder.PutUint8(uint8(self.Value))
3884
3885 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
3886
3887 return nil
3888}
3889
3890func DecodeBsnTlvEcn(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEcn, error) {
3891 _bsntlvecn := &BsnTlvEcn{BsnTlv: parent}
3892 if decoder.Length() < 1 {
3893 return nil, fmt.Errorf("BsnTlvEcn packet too short: %d < 1", decoder.Length())
3894 }
3895 _bsntlvecn.Value = uint8(decoder.ReadByte())
3896 return _bsntlvecn, nil
3897}
3898
3899func NewBsnTlvEcn() *BsnTlvEcn {
3900 obj := &BsnTlvEcn{
3901 BsnTlv: NewBsnTlv(132),
3902 }
3903 return obj
3904}
3905
3906type BsnTlvEgressOnly struct {
3907 *BsnTlv
3908}
3909
3910type IBsnTlvEgressOnly interface {
3911 IBsnTlv
3912}
3913
3914func (self *BsnTlvEgressOnly) Serialize(encoder *goloxi.Encoder) error {
3915 if err := self.BsnTlv.Serialize(encoder); err != nil {
3916 return err
3917 }
3918
3919 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
3920
3921 return nil
3922}
3923
3924func DecodeBsnTlvEgressOnly(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEgressOnly, error) {
3925 _bsntlvegressonly := &BsnTlvEgressOnly{BsnTlv: parent}
3926 return _bsntlvegressonly, nil
3927}
3928
3929func NewBsnTlvEgressOnly() *BsnTlvEgressOnly {
3930 obj := &BsnTlvEgressOnly{
3931 BsnTlv: NewBsnTlv(137),
3932 }
3933 return obj
3934}
3935
3936type BsnTlvEgressPortGroupId struct {
3937 *BsnTlv
3938 Value uint32
3939}
3940
3941type IBsnTlvEgressPortGroupId interface {
3942 IBsnTlv
3943 GetValue() uint32
3944}
3945
3946func (self *BsnTlvEgressPortGroupId) GetValue() uint32 {
3947 return self.Value
3948}
3949
3950func (self *BsnTlvEgressPortGroupId) SetValue(v uint32) {
3951 self.Value = v
3952}
3953
3954func (self *BsnTlvEgressPortGroupId) Serialize(encoder *goloxi.Encoder) error {
3955 if err := self.BsnTlv.Serialize(encoder); err != nil {
3956 return err
3957 }
3958
3959 encoder.PutUint32(uint32(self.Value))
3960
3961 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
3962
3963 return nil
3964}
3965
3966func DecodeBsnTlvEgressPortGroupId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEgressPortGroupId, error) {
3967 _bsntlvegressportgroupid := &BsnTlvEgressPortGroupId{BsnTlv: parent}
3968 if decoder.Length() < 4 {
3969 return nil, fmt.Errorf("BsnTlvEgressPortGroupId packet too short: %d < 4", decoder.Length())
3970 }
3971 _bsntlvegressportgroupid.Value = uint32(decoder.ReadUint32())
3972 return _bsntlvegressportgroupid, nil
3973}
3974
3975func NewBsnTlvEgressPortGroupId() *BsnTlvEgressPortGroupId {
3976 obj := &BsnTlvEgressPortGroupId{
3977 BsnTlv: NewBsnTlv(139),
3978 }
3979 return obj
3980}
3981
3982type BsnTlvEncap struct {
3983 *BsnTlv
3984 Value BsnEncap
3985}
3986
3987type IBsnTlvEncap interface {
3988 IBsnTlv
3989 GetValue() BsnEncap
3990}
3991
3992func (self *BsnTlvEncap) GetValue() BsnEncap {
3993 return self.Value
3994}
3995
3996func (self *BsnTlvEncap) SetValue(v BsnEncap) {
3997 self.Value = v
3998}
3999
4000func (self *BsnTlvEncap) Serialize(encoder *goloxi.Encoder) error {
4001 if err := self.BsnTlv.Serialize(encoder); err != nil {
4002 return err
4003 }
4004
4005 encoder.PutUint8(uint8(self.Value))
4006
4007 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
4008
4009 return nil
4010}
4011
4012func DecodeBsnTlvEncap(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEncap, error) {
4013 _bsntlvencap := &BsnTlvEncap{BsnTlv: parent}
4014 if decoder.Length() < 1 {
4015 return nil, fmt.Errorf("BsnTlvEncap packet too short: %d < 1", decoder.Length())
4016 }
4017 _bsntlvencap.Value = BsnEncap(decoder.ReadByte())
4018 return _bsntlvencap, nil
4019}
4020
4021func NewBsnTlvEncap() *BsnTlvEncap {
4022 obj := &BsnTlvEncap{
4023 BsnTlv: NewBsnTlv(175),
4024 }
4025 return obj
4026}
4027
4028type BsnTlvEnhancedHashCapability struct {
4029 *BsnTlv
4030 Value BsnEnhancedHashType
4031}
4032
4033type IBsnTlvEnhancedHashCapability interface {
4034 IBsnTlv
4035 GetValue() BsnEnhancedHashType
4036}
4037
4038func (self *BsnTlvEnhancedHashCapability) GetValue() BsnEnhancedHashType {
4039 return self.Value
4040}
4041
4042func (self *BsnTlvEnhancedHashCapability) SetValue(v BsnEnhancedHashType) {
4043 self.Value = v
4044}
4045
4046func (self *BsnTlvEnhancedHashCapability) Serialize(encoder *goloxi.Encoder) error {
4047 if err := self.BsnTlv.Serialize(encoder); err != nil {
4048 return err
4049 }
4050
4051 encoder.PutUint64(uint64(self.Value))
4052
4053 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
4054
4055 return nil
4056}
4057
4058func DecodeBsnTlvEnhancedHashCapability(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEnhancedHashCapability, error) {
4059 _bsntlvenhancedhashcapability := &BsnTlvEnhancedHashCapability{BsnTlv: parent}
4060 if decoder.Length() < 8 {
4061 return nil, fmt.Errorf("BsnTlvEnhancedHashCapability packet too short: %d < 8", decoder.Length())
4062 }
4063 _bsntlvenhancedhashcapability.Value = BsnEnhancedHashType(decoder.ReadUint64())
4064 return _bsntlvenhancedhashcapability, nil
4065}
4066
4067func NewBsnTlvEnhancedHashCapability() *BsnTlvEnhancedHashCapability {
4068 obj := &BsnTlvEnhancedHashCapability{
4069 BsnTlv: NewBsnTlv(143),
4070 }
4071 return obj
4072}
4073
4074type BsnTlvEthDst struct {
4075 *BsnTlv
4076 Value net.HardwareAddr
4077}
4078
4079type IBsnTlvEthDst interface {
4080 IBsnTlv
4081 GetValue() net.HardwareAddr
4082}
4083
4084func (self *BsnTlvEthDst) GetValue() net.HardwareAddr {
4085 return self.Value
4086}
4087
4088func (self *BsnTlvEthDst) SetValue(v net.HardwareAddr) {
4089 self.Value = v
4090}
4091
4092func (self *BsnTlvEthDst) Serialize(encoder *goloxi.Encoder) error {
4093 if err := self.BsnTlv.Serialize(encoder); err != nil {
4094 return err
4095 }
4096
4097 encoder.Write(self.Value)
4098
4099 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
4100
4101 return nil
4102}
4103
4104func DecodeBsnTlvEthDst(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEthDst, error) {
4105 _bsntlvethdst := &BsnTlvEthDst{BsnTlv: parent}
4106 if decoder.Length() < 6 {
4107 return nil, fmt.Errorf("BsnTlvEthDst packet too short: %d < 6", decoder.Length())
4108 }
4109 _bsntlvethdst.Value = net.HardwareAddr(decoder.Read(6))
4110 return _bsntlvethdst, nil
4111}
4112
4113func NewBsnTlvEthDst() *BsnTlvEthDst {
4114 obj := &BsnTlvEthDst{
4115 BsnTlv: NewBsnTlv(33),
4116 }
4117 return obj
4118}
4119
4120type BsnTlvEthSrc struct {
4121 *BsnTlv
4122 Value net.HardwareAddr
4123}
4124
4125type IBsnTlvEthSrc interface {
4126 IBsnTlv
4127 GetValue() net.HardwareAddr
4128}
4129
4130func (self *BsnTlvEthSrc) GetValue() net.HardwareAddr {
4131 return self.Value
4132}
4133
4134func (self *BsnTlvEthSrc) SetValue(v net.HardwareAddr) {
4135 self.Value = v
4136}
4137
4138func (self *BsnTlvEthSrc) Serialize(encoder *goloxi.Encoder) error {
4139 if err := self.BsnTlv.Serialize(encoder); err != nil {
4140 return err
4141 }
4142
4143 encoder.Write(self.Value)
4144
4145 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
4146
4147 return nil
4148}
4149
4150func DecodeBsnTlvEthSrc(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEthSrc, error) {
4151 _bsntlvethsrc := &BsnTlvEthSrc{BsnTlv: parent}
4152 if decoder.Length() < 6 {
4153 return nil, fmt.Errorf("BsnTlvEthSrc packet too short: %d < 6", decoder.Length())
4154 }
4155 _bsntlvethsrc.Value = net.HardwareAddr(decoder.Read(6))
4156 return _bsntlvethsrc, nil
4157}
4158
4159func NewBsnTlvEthSrc() *BsnTlvEthSrc {
4160 obj := &BsnTlvEthSrc{
4161 BsnTlv: NewBsnTlv(32),
4162 }
4163 return obj
4164}
4165
4166type BsnTlvEthType struct {
4167 *BsnTlv
4168 Value uint16
4169}
4170
4171type IBsnTlvEthType interface {
4172 IBsnTlv
4173 GetValue() uint16
4174}
4175
4176func (self *BsnTlvEthType) GetValue() uint16 {
4177 return self.Value
4178}
4179
4180func (self *BsnTlvEthType) SetValue(v uint16) {
4181 self.Value = v
4182}
4183
4184func (self *BsnTlvEthType) Serialize(encoder *goloxi.Encoder) error {
4185 if err := self.BsnTlv.Serialize(encoder); err != nil {
4186 return err
4187 }
4188
4189 encoder.PutUint16(uint16(self.Value))
4190
4191 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
4192
4193 return nil
4194}
4195
4196func DecodeBsnTlvEthType(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEthType, error) {
4197 _bsntlvethtype := &BsnTlvEthType{BsnTlv: parent}
4198 if decoder.Length() < 2 {
4199 return nil, fmt.Errorf("BsnTlvEthType packet too short: %d < 2", decoder.Length())
4200 }
4201 _bsntlvethtype.Value = uint16(decoder.ReadUint16())
4202 return _bsntlvethtype, nil
4203}
4204
4205func NewBsnTlvEthType() *BsnTlvEthType {
4206 obj := &BsnTlvEthType{
4207 BsnTlv: NewBsnTlv(131),
4208 }
4209 return obj
4210}
4211
4212type BsnTlvExternalGatewayIp struct {
4213 *BsnTlv
4214 Value net.IP
4215}
4216
4217type IBsnTlvExternalGatewayIp interface {
4218 IBsnTlv
4219 GetValue() net.IP
4220}
4221
4222func (self *BsnTlvExternalGatewayIp) GetValue() net.IP {
4223 return self.Value
4224}
4225
4226func (self *BsnTlvExternalGatewayIp) SetValue(v net.IP) {
4227 self.Value = v
4228}
4229
4230func (self *BsnTlvExternalGatewayIp) Serialize(encoder *goloxi.Encoder) error {
4231 if err := self.BsnTlv.Serialize(encoder); err != nil {
4232 return err
4233 }
4234
4235 encoder.Write(self.Value.To4())
4236
4237 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
4238
4239 return nil
4240}
4241
4242func DecodeBsnTlvExternalGatewayIp(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvExternalGatewayIp, error) {
4243 _bsntlvexternalgatewayip := &BsnTlvExternalGatewayIp{BsnTlv: parent}
4244 if decoder.Length() < 4 {
4245 return nil, fmt.Errorf("BsnTlvExternalGatewayIp packet too short: %d < 4", decoder.Length())
4246 }
4247 _bsntlvexternalgatewayip.Value = net.IP(decoder.Read(4))
4248 return _bsntlvexternalgatewayip, nil
4249}
4250
4251func NewBsnTlvExternalGatewayIp() *BsnTlvExternalGatewayIp {
4252 obj := &BsnTlvExternalGatewayIp{
4253 BsnTlv: NewBsnTlv(26),
4254 }
4255 return obj
4256}
4257
4258type BsnTlvExternalGatewayMac struct {
4259 *BsnTlv
4260 Value net.HardwareAddr
4261}
4262
4263type IBsnTlvExternalGatewayMac interface {
4264 IBsnTlv
4265 GetValue() net.HardwareAddr
4266}
4267
4268func (self *BsnTlvExternalGatewayMac) GetValue() net.HardwareAddr {
4269 return self.Value
4270}
4271
4272func (self *BsnTlvExternalGatewayMac) SetValue(v net.HardwareAddr) {
4273 self.Value = v
4274}
4275
4276func (self *BsnTlvExternalGatewayMac) Serialize(encoder *goloxi.Encoder) error {
4277 if err := self.BsnTlv.Serialize(encoder); err != nil {
4278 return err
4279 }
4280
4281 encoder.Write(self.Value)
4282
4283 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
4284
4285 return nil
4286}
4287
4288func DecodeBsnTlvExternalGatewayMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvExternalGatewayMac, error) {
4289 _bsntlvexternalgatewaymac := &BsnTlvExternalGatewayMac{BsnTlv: parent}
4290 if decoder.Length() < 6 {
4291 return nil, fmt.Errorf("BsnTlvExternalGatewayMac packet too short: %d < 6", decoder.Length())
4292 }
4293 _bsntlvexternalgatewaymac.Value = net.HardwareAddr(decoder.Read(6))
4294 return _bsntlvexternalgatewaymac, nil
4295}
4296
4297func NewBsnTlvExternalGatewayMac() *BsnTlvExternalGatewayMac {
4298 obj := &BsnTlvExternalGatewayMac{
4299 BsnTlv: NewBsnTlv(29),
4300 }
4301 return obj
4302}
4303
4304type BsnTlvExternalIp struct {
4305 *BsnTlv
4306 Value net.IP
4307}
4308
4309type IBsnTlvExternalIp interface {
4310 IBsnTlv
4311 GetValue() net.IP
4312}
4313
4314func (self *BsnTlvExternalIp) GetValue() net.IP {
4315 return self.Value
4316}
4317
4318func (self *BsnTlvExternalIp) SetValue(v net.IP) {
4319 self.Value = v
4320}
4321
4322func (self *BsnTlvExternalIp) Serialize(encoder *goloxi.Encoder) error {
4323 if err := self.BsnTlv.Serialize(encoder); err != nil {
4324 return err
4325 }
4326
4327 encoder.Write(self.Value.To4())
4328
4329 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
4330
4331 return nil
4332}
4333
4334func DecodeBsnTlvExternalIp(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvExternalIp, error) {
4335 _bsntlvexternalip := &BsnTlvExternalIp{BsnTlv: parent}
4336 if decoder.Length() < 4 {
4337 return nil, fmt.Errorf("BsnTlvExternalIp packet too short: %d < 4", decoder.Length())
4338 }
4339 _bsntlvexternalip.Value = net.IP(decoder.Read(4))
4340 return _bsntlvexternalip, nil
4341}
4342
4343func NewBsnTlvExternalIp() *BsnTlvExternalIp {
4344 obj := &BsnTlvExternalIp{
4345 BsnTlv: NewBsnTlv(23),
4346 }
4347 return obj
4348}
4349
4350type BsnTlvExternalMac struct {
4351 *BsnTlv
4352 Value net.HardwareAddr
4353}
4354
4355type IBsnTlvExternalMac interface {
4356 IBsnTlv
4357 GetValue() net.HardwareAddr
4358}
4359
4360func (self *BsnTlvExternalMac) GetValue() net.HardwareAddr {
4361 return self.Value
4362}
4363
4364func (self *BsnTlvExternalMac) SetValue(v net.HardwareAddr) {
4365 self.Value = v
4366}
4367
4368func (self *BsnTlvExternalMac) Serialize(encoder *goloxi.Encoder) error {
4369 if err := self.BsnTlv.Serialize(encoder); err != nil {
4370 return err
4371 }
4372
4373 encoder.Write(self.Value)
4374
4375 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
4376
4377 return nil
4378}
4379
4380func DecodeBsnTlvExternalMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvExternalMac, error) {
4381 _bsntlvexternalmac := &BsnTlvExternalMac{BsnTlv: parent}
4382 if decoder.Length() < 6 {
4383 return nil, fmt.Errorf("BsnTlvExternalMac packet too short: %d < 6", decoder.Length())
4384 }
4385 _bsntlvexternalmac.Value = net.HardwareAddr(decoder.Read(6))
4386 return _bsntlvexternalmac, nil
4387}
4388
4389func NewBsnTlvExternalMac() *BsnTlvExternalMac {
4390 obj := &BsnTlvExternalMac{
4391 BsnTlv: NewBsnTlv(24),
4392 }
4393 return obj
4394}
4395
4396type BsnTlvExternalNetmask struct {
4397 *BsnTlv
4398 Value net.IP
4399}
4400
4401type IBsnTlvExternalNetmask interface {
4402 IBsnTlv
4403 GetValue() net.IP
4404}
4405
4406func (self *BsnTlvExternalNetmask) GetValue() net.IP {
4407 return self.Value
4408}
4409
4410func (self *BsnTlvExternalNetmask) SetValue(v net.IP) {
4411 self.Value = v
4412}
4413
4414func (self *BsnTlvExternalNetmask) Serialize(encoder *goloxi.Encoder) error {
4415 if err := self.BsnTlv.Serialize(encoder); err != nil {
4416 return err
4417 }
4418
4419 encoder.Write(self.Value.To4())
4420
4421 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
4422
4423 return nil
4424}
4425
4426func DecodeBsnTlvExternalNetmask(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvExternalNetmask, error) {
4427 _bsntlvexternalnetmask := &BsnTlvExternalNetmask{BsnTlv: parent}
4428 if decoder.Length() < 4 {
4429 return nil, fmt.Errorf("BsnTlvExternalNetmask packet too short: %d < 4", decoder.Length())
4430 }
4431 _bsntlvexternalnetmask.Value = net.IP(decoder.Read(4))
4432 return _bsntlvexternalnetmask, nil
4433}
4434
4435func NewBsnTlvExternalNetmask() *BsnTlvExternalNetmask {
4436 obj := &BsnTlvExternalNetmask{
4437 BsnTlv: NewBsnTlv(25),
4438 }
4439 return obj
4440}
4441
4442type BsnTlvFabricPortRole struct {
4443 *BsnTlv
4444 Value BsnFabricPortRole
4445}
4446
4447type IBsnTlvFabricPortRole interface {
4448 IBsnTlv
4449 GetValue() BsnFabricPortRole
4450}
4451
4452func (self *BsnTlvFabricPortRole) GetValue() BsnFabricPortRole {
4453 return self.Value
4454}
4455
4456func (self *BsnTlvFabricPortRole) SetValue(v BsnFabricPortRole) {
4457 self.Value = v
4458}
4459
4460func (self *BsnTlvFabricPortRole) Serialize(encoder *goloxi.Encoder) error {
4461 if err := self.BsnTlv.Serialize(encoder); err != nil {
4462 return err
4463 }
4464
4465 encoder.PutUint16(uint16(self.Value))
4466
4467 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
4468
4469 return nil
4470}
4471
4472func DecodeBsnTlvFabricPortRole(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvFabricPortRole, error) {
4473 _bsntlvfabricportrole := &BsnTlvFabricPortRole{BsnTlv: parent}
4474 if decoder.Length() < 2 {
4475 return nil, fmt.Errorf("BsnTlvFabricPortRole packet too short: %d < 2", decoder.Length())
4476 }
4477 _bsntlvfabricportrole.Value = BsnFabricPortRole(decoder.ReadUint16())
4478 return _bsntlvfabricportrole, nil
4479}
4480
4481func NewBsnTlvFabricPortRole() *BsnTlvFabricPortRole {
4482 obj := &BsnTlvFabricPortRole{
4483 BsnTlv: NewBsnTlv(165),
4484 }
4485 return obj
4486}
4487
4488type BsnTlvFlood struct {
4489 *BsnTlv
4490}
4491
4492type IBsnTlvFlood interface {
4493 IBsnTlv
4494}
4495
4496func (self *BsnTlvFlood) Serialize(encoder *goloxi.Encoder) error {
4497 if err := self.BsnTlv.Serialize(encoder); err != nil {
4498 return err
4499 }
4500
4501 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
4502
4503 return nil
4504}
4505
4506func DecodeBsnTlvFlood(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvFlood, error) {
4507 _bsntlvflood := &BsnTlvFlood{BsnTlv: parent}
4508 return _bsntlvflood, nil
4509}
4510
4511func NewBsnTlvFlood() *BsnTlvFlood {
4512 obj := &BsnTlvFlood{
4513 BsnTlv: NewBsnTlv(163),
4514 }
4515 return obj
4516}
4517
4518type BsnTlvFlowClassifier struct {
4519 *BsnTlv
4520 Value BsnFlowClassifier
4521}
4522
4523type IBsnTlvFlowClassifier interface {
4524 IBsnTlv
4525 GetValue() BsnFlowClassifier
4526}
4527
4528func (self *BsnTlvFlowClassifier) GetValue() BsnFlowClassifier {
4529 return self.Value
4530}
4531
4532func (self *BsnTlvFlowClassifier) SetValue(v BsnFlowClassifier) {
4533 self.Value = v
4534}
4535
4536func (self *BsnTlvFlowClassifier) Serialize(encoder *goloxi.Encoder) error {
4537 if err := self.BsnTlv.Serialize(encoder); err != nil {
4538 return err
4539 }
4540
4541 encoder.PutUint16(uint16(self.Value))
4542
4543 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
4544
4545 return nil
4546}
4547
4548func DecodeBsnTlvFlowClassifier(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvFlowClassifier, error) {
4549 _bsntlvflowclassifier := &BsnTlvFlowClassifier{BsnTlv: parent}
4550 if decoder.Length() < 2 {
4551 return nil, fmt.Errorf("BsnTlvFlowClassifier packet too short: %d < 2", decoder.Length())
4552 }
4553 _bsntlvflowclassifier.Value = BsnFlowClassifier(decoder.ReadUint16())
4554 return _bsntlvflowclassifier, nil
4555}
4556
4557func NewBsnTlvFlowClassifier() *BsnTlvFlowClassifier {
4558 obj := &BsnTlvFlowClassifier{
4559 BsnTlv: NewBsnTlv(184),
4560 }
4561 return obj
4562}
4563
4564type BsnTlvFlowClassify struct {
4565 *BsnTlv
4566}
4567
4568type IBsnTlvFlowClassify interface {
4569 IBsnTlv
4570}
4571
4572func (self *BsnTlvFlowClassify) Serialize(encoder *goloxi.Encoder) error {
4573 if err := self.BsnTlv.Serialize(encoder); err != nil {
4574 return err
4575 }
4576
4577 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
4578
4579 return nil
4580}
4581
4582func DecodeBsnTlvFlowClassify(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvFlowClassify, error) {
4583 _bsntlvflowclassify := &BsnTlvFlowClassify{BsnTlv: parent}
4584 return _bsntlvflowclassify, nil
4585}
4586
4587func NewBsnTlvFlowClassify() *BsnTlvFlowClassify {
4588 obj := &BsnTlvFlowClassify{
4589 BsnTlv: NewBsnTlv(182),
4590 }
4591 return obj
4592}
4593
4594type BsnTlvFlowIdentifier struct {
4595 *BsnTlv
4596 Value uint32
4597}
4598
4599type IBsnTlvFlowIdentifier interface {
4600 IBsnTlv
4601 GetValue() uint32
4602}
4603
4604func (self *BsnTlvFlowIdentifier) GetValue() uint32 {
4605 return self.Value
4606}
4607
4608func (self *BsnTlvFlowIdentifier) SetValue(v uint32) {
4609 self.Value = v
4610}
4611
4612func (self *BsnTlvFlowIdentifier) Serialize(encoder *goloxi.Encoder) error {
4613 if err := self.BsnTlv.Serialize(encoder); err != nil {
4614 return err
4615 }
4616
4617 encoder.PutUint32(uint32(self.Value))
4618
4619 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
4620
4621 return nil
4622}
4623
4624func DecodeBsnTlvFlowIdentifier(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvFlowIdentifier, error) {
4625 _bsntlvflowidentifier := &BsnTlvFlowIdentifier{BsnTlv: parent}
4626 if decoder.Length() < 4 {
4627 return nil, fmt.Errorf("BsnTlvFlowIdentifier packet too short: %d < 4", decoder.Length())
4628 }
4629 _bsntlvflowidentifier.Value = uint32(decoder.ReadUint32())
4630 return _bsntlvflowidentifier, nil
4631}
4632
4633func NewBsnTlvFlowIdentifier() *BsnTlvFlowIdentifier {
4634 obj := &BsnTlvFlowIdentifier{
4635 BsnTlv: NewBsnTlv(183),
4636 }
4637 return obj
4638}
4639
4640type BsnTlvForceLinkUp struct {
4641 *BsnTlv
4642}
4643
4644type IBsnTlvForceLinkUp interface {
4645 IBsnTlv
4646}
4647
4648func (self *BsnTlvForceLinkUp) Serialize(encoder *goloxi.Encoder) error {
4649 if err := self.BsnTlv.Serialize(encoder); err != nil {
4650 return err
4651 }
4652
4653 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
4654
4655 return nil
4656}
4657
4658func DecodeBsnTlvForceLinkUp(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvForceLinkUp, error) {
4659 _bsntlvforcelinkup := &BsnTlvForceLinkUp{BsnTlv: parent}
4660 return _bsntlvforcelinkup, nil
4661}
4662
4663func NewBsnTlvForceLinkUp() *BsnTlvForceLinkUp {
4664 obj := &BsnTlvForceLinkUp{
4665 BsnTlv: NewBsnTlv(151),
4666 }
4667 return obj
4668}
4669
4670type BsnTlvForwardErrorCorrection struct {
4671 *BsnTlv
4672 Value BsnForwardErrorCorrectionType
4673}
4674
4675type IBsnTlvForwardErrorCorrection interface {
4676 IBsnTlv
4677 GetValue() BsnForwardErrorCorrectionType
4678}
4679
4680func (self *BsnTlvForwardErrorCorrection) GetValue() BsnForwardErrorCorrectionType {
4681 return self.Value
4682}
4683
4684func (self *BsnTlvForwardErrorCorrection) SetValue(v BsnForwardErrorCorrectionType) {
4685 self.Value = v
4686}
4687
4688func (self *BsnTlvForwardErrorCorrection) Serialize(encoder *goloxi.Encoder) error {
4689 if err := self.BsnTlv.Serialize(encoder); err != nil {
4690 return err
4691 }
4692
4693 encoder.PutUint8(uint8(self.Value))
4694
4695 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
4696
4697 return nil
4698}
4699
4700func DecodeBsnTlvForwardErrorCorrection(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvForwardErrorCorrection, error) {
4701 _bsntlvforwarderrorcorrection := &BsnTlvForwardErrorCorrection{BsnTlv: parent}
4702 if decoder.Length() < 1 {
4703 return nil, fmt.Errorf("BsnTlvForwardErrorCorrection packet too short: %d < 1", decoder.Length())
4704 }
4705 _bsntlvforwarderrorcorrection.Value = BsnForwardErrorCorrectionType(decoder.ReadByte())
4706 return _bsntlvforwarderrorcorrection, nil
4707}
4708
4709func NewBsnTlvForwardErrorCorrection() *BsnTlvForwardErrorCorrection {
4710 obj := &BsnTlvForwardErrorCorrection{
4711 BsnTlv: NewBsnTlv(149),
4712 }
4713 return obj
4714}
4715
4716type BsnTlvGenerationId struct {
4717 *BsnTlv
4718 Value uint64
4719}
4720
4721type IBsnTlvGenerationId interface {
4722 IBsnTlv
4723 GetValue() uint64
4724}
4725
4726func (self *BsnTlvGenerationId) GetValue() uint64 {
4727 return self.Value
4728}
4729
4730func (self *BsnTlvGenerationId) SetValue(v uint64) {
4731 self.Value = v
4732}
4733
4734func (self *BsnTlvGenerationId) Serialize(encoder *goloxi.Encoder) error {
4735 if err := self.BsnTlv.Serialize(encoder); err != nil {
4736 return err
4737 }
4738
4739 encoder.PutUint64(uint64(self.Value))
4740
4741 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
4742
4743 return nil
4744}
4745
4746func DecodeBsnTlvGenerationId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvGenerationId, error) {
4747 _bsntlvgenerationid := &BsnTlvGenerationId{BsnTlv: parent}
4748 if decoder.Length() < 8 {
4749 return nil, fmt.Errorf("BsnTlvGenerationId packet too short: %d < 8", decoder.Length())
4750 }
4751 _bsntlvgenerationid.Value = uint64(decoder.ReadUint64())
4752 return _bsntlvgenerationid, nil
4753}
4754
4755func NewBsnTlvGenerationId() *BsnTlvGenerationId {
4756 obj := &BsnTlvGenerationId{
4757 BsnTlv: NewBsnTlv(80),
4758 }
4759 return obj
4760}
4761
4762type BsnTlvHashAlgorithm struct {
4763 *BsnTlv
4764 Value BsnHashAlgorithmType
4765}
4766
4767type IBsnTlvHashAlgorithm interface {
4768 IBsnTlv
4769 GetValue() BsnHashAlgorithmType
4770}
4771
4772func (self *BsnTlvHashAlgorithm) GetValue() BsnHashAlgorithmType {
4773 return self.Value
4774}
4775
4776func (self *BsnTlvHashAlgorithm) SetValue(v BsnHashAlgorithmType) {
4777 self.Value = v
4778}
4779
4780func (self *BsnTlvHashAlgorithm) Serialize(encoder *goloxi.Encoder) error {
4781 if err := self.BsnTlv.Serialize(encoder); err != nil {
4782 return err
4783 }
4784
4785 encoder.PutUint16(uint16(self.Value))
4786
4787 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
4788
4789 return nil
4790}
4791
4792func DecodeBsnTlvHashAlgorithm(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHashAlgorithm, error) {
4793 _bsntlvhashalgorithm := &BsnTlvHashAlgorithm{BsnTlv: parent}
4794 if decoder.Length() < 2 {
4795 return nil, fmt.Errorf("BsnTlvHashAlgorithm packet too short: %d < 2", decoder.Length())
4796 }
4797 _bsntlvhashalgorithm.Value = BsnHashAlgorithmType(decoder.ReadUint16())
4798 return _bsntlvhashalgorithm, nil
4799}
4800
4801func NewBsnTlvHashAlgorithm() *BsnTlvHashAlgorithm {
4802 obj := &BsnTlvHashAlgorithm{
4803 BsnTlv: NewBsnTlv(145),
4804 }
4805 return obj
4806}
4807
4808type BsnTlvHashGtpHeaderMatch struct {
4809 *BsnTlv
4810 FirstHeaderByte uint8
4811 FirstHeaderMask uint8
4812}
4813
4814type IBsnTlvHashGtpHeaderMatch interface {
4815 IBsnTlv
4816 GetFirstHeaderByte() uint8
4817 GetFirstHeaderMask() uint8
4818}
4819
4820func (self *BsnTlvHashGtpHeaderMatch) GetFirstHeaderByte() uint8 {
4821 return self.FirstHeaderByte
4822}
4823
4824func (self *BsnTlvHashGtpHeaderMatch) SetFirstHeaderByte(v uint8) {
4825 self.FirstHeaderByte = v
4826}
4827
4828func (self *BsnTlvHashGtpHeaderMatch) GetFirstHeaderMask() uint8 {
4829 return self.FirstHeaderMask
4830}
4831
4832func (self *BsnTlvHashGtpHeaderMatch) SetFirstHeaderMask(v uint8) {
4833 self.FirstHeaderMask = v
4834}
4835
4836func (self *BsnTlvHashGtpHeaderMatch) Serialize(encoder *goloxi.Encoder) error {
4837 if err := self.BsnTlv.Serialize(encoder); err != nil {
4838 return err
4839 }
4840
4841 encoder.PutUint8(uint8(self.FirstHeaderByte))
4842 encoder.PutUint8(uint8(self.FirstHeaderMask))
4843
4844 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
4845
4846 return nil
4847}
4848
4849func DecodeBsnTlvHashGtpHeaderMatch(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHashGtpHeaderMatch, error) {
4850 _bsntlvhashgtpheadermatch := &BsnTlvHashGtpHeaderMatch{BsnTlv: parent}
4851 if decoder.Length() < 2 {
4852 return nil, fmt.Errorf("BsnTlvHashGtpHeaderMatch packet too short: %d < 2", decoder.Length())
4853 }
4854 _bsntlvhashgtpheadermatch.FirstHeaderByte = uint8(decoder.ReadByte())
4855 _bsntlvhashgtpheadermatch.FirstHeaderMask = uint8(decoder.ReadByte())
4856 return _bsntlvhashgtpheadermatch, nil
4857}
4858
4859func NewBsnTlvHashGtpHeaderMatch() *BsnTlvHashGtpHeaderMatch {
4860 obj := &BsnTlvHashGtpHeaderMatch{
4861 BsnTlv: NewBsnTlv(104),
4862 }
4863 return obj
4864}
4865
4866type BsnTlvHashGtpPortMatch struct {
4867 *BsnTlv
4868 Match BsnHashGtpPortMatch
4869 SrcPort uint16
4870 DstPort uint16
4871}
4872
4873type IBsnTlvHashGtpPortMatch interface {
4874 IBsnTlv
4875 GetMatch() BsnHashGtpPortMatch
4876 GetSrcPort() uint16
4877 GetDstPort() uint16
4878}
4879
4880func (self *BsnTlvHashGtpPortMatch) GetMatch() BsnHashGtpPortMatch {
4881 return self.Match
4882}
4883
4884func (self *BsnTlvHashGtpPortMatch) SetMatch(v BsnHashGtpPortMatch) {
4885 self.Match = v
4886}
4887
4888func (self *BsnTlvHashGtpPortMatch) GetSrcPort() uint16 {
4889 return self.SrcPort
4890}
4891
4892func (self *BsnTlvHashGtpPortMatch) SetSrcPort(v uint16) {
4893 self.SrcPort = v
4894}
4895
4896func (self *BsnTlvHashGtpPortMatch) GetDstPort() uint16 {
4897 return self.DstPort
4898}
4899
4900func (self *BsnTlvHashGtpPortMatch) SetDstPort(v uint16) {
4901 self.DstPort = v
4902}
4903
4904func (self *BsnTlvHashGtpPortMatch) Serialize(encoder *goloxi.Encoder) error {
4905 if err := self.BsnTlv.Serialize(encoder); err != nil {
4906 return err
4907 }
4908
4909 encoder.PutUint8(uint8(self.Match))
4910 encoder.PutUint16(uint16(self.SrcPort))
4911 encoder.PutUint16(uint16(self.DstPort))
4912
4913 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
4914
4915 return nil
4916}
4917
4918func DecodeBsnTlvHashGtpPortMatch(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHashGtpPortMatch, error) {
4919 _bsntlvhashgtpportmatch := &BsnTlvHashGtpPortMatch{BsnTlv: parent}
4920 if decoder.Length() < 5 {
4921 return nil, fmt.Errorf("BsnTlvHashGtpPortMatch packet too short: %d < 5", decoder.Length())
4922 }
4923 _bsntlvhashgtpportmatch.Match = BsnHashGtpPortMatch(decoder.ReadByte())
4924 _bsntlvhashgtpportmatch.SrcPort = uint16(decoder.ReadUint16())
4925 _bsntlvhashgtpportmatch.DstPort = uint16(decoder.ReadUint16())
4926 return _bsntlvhashgtpportmatch, nil
4927}
4928
4929func NewBsnTlvHashGtpPortMatch() *BsnTlvHashGtpPortMatch {
4930 obj := &BsnTlvHashGtpPortMatch{
4931 BsnTlv: NewBsnTlv(105),
4932 }
4933 return obj
4934}
4935
4936type BsnTlvHashPacketField struct {
4937 *BsnTlv
4938 Value BsnHashPacketField
4939}
4940
4941type IBsnTlvHashPacketField interface {
4942 IBsnTlv
4943 GetValue() BsnHashPacketField
4944}
4945
4946func (self *BsnTlvHashPacketField) GetValue() BsnHashPacketField {
4947 return self.Value
4948}
4949
4950func (self *BsnTlvHashPacketField) SetValue(v BsnHashPacketField) {
4951 self.Value = v
4952}
4953
4954func (self *BsnTlvHashPacketField) Serialize(encoder *goloxi.Encoder) error {
4955 if err := self.BsnTlv.Serialize(encoder); err != nil {
4956 return err
4957 }
4958
4959 encoder.PutUint64(uint64(self.Value))
4960
4961 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
4962
4963 return nil
4964}
4965
4966func DecodeBsnTlvHashPacketField(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHashPacketField, error) {
4967 _bsntlvhashpacketfield := &BsnTlvHashPacketField{BsnTlv: parent}
4968 if decoder.Length() < 8 {
4969 return nil, fmt.Errorf("BsnTlvHashPacketField packet too short: %d < 8", decoder.Length())
4970 }
4971 _bsntlvhashpacketfield.Value = BsnHashPacketField(decoder.ReadUint64())
4972 return _bsntlvhashpacketfield, nil
4973}
4974
4975func NewBsnTlvHashPacketField() *BsnTlvHashPacketField {
4976 obj := &BsnTlvHashPacketField{
4977 BsnTlv: NewBsnTlv(103),
4978 }
4979 return obj
4980}
4981
4982type BsnTlvHashPacketType struct {
4983 *BsnTlv
4984 Value BsnHashPacketType
4985}
4986
4987type IBsnTlvHashPacketType interface {
4988 IBsnTlv
4989 GetValue() BsnHashPacketType
4990}
4991
4992func (self *BsnTlvHashPacketType) GetValue() BsnHashPacketType {
4993 return self.Value
4994}
4995
4996func (self *BsnTlvHashPacketType) SetValue(v BsnHashPacketType) {
4997 self.Value = v
4998}
4999
5000func (self *BsnTlvHashPacketType) Serialize(encoder *goloxi.Encoder) error {
5001 if err := self.BsnTlv.Serialize(encoder); err != nil {
5002 return err
5003 }
5004
5005 encoder.PutUint8(uint8(self.Value))
5006
5007 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
5008
5009 return nil
5010}
5011
5012func DecodeBsnTlvHashPacketType(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHashPacketType, error) {
5013 _bsntlvhashpackettype := &BsnTlvHashPacketType{BsnTlv: parent}
5014 if decoder.Length() < 1 {
5015 return nil, fmt.Errorf("BsnTlvHashPacketType packet too short: %d < 1", decoder.Length())
5016 }
5017 _bsntlvhashpackettype.Value = BsnHashPacketType(decoder.ReadByte())
5018 return _bsntlvhashpackettype, nil
5019}
5020
5021func NewBsnTlvHashPacketType() *BsnTlvHashPacketType {
5022 obj := &BsnTlvHashPacketType{
5023 BsnTlv: NewBsnTlv(102),
5024 }
5025 return obj
5026}
5027
5028type BsnTlvHashSeed struct {
5029 *BsnTlv
5030 Seed1 uint32
5031 Seed2 uint32
5032}
5033
5034type IBsnTlvHashSeed interface {
5035 IBsnTlv
5036 GetSeed1() uint32
5037 GetSeed2() uint32
5038}
5039
5040func (self *BsnTlvHashSeed) GetSeed1() uint32 {
5041 return self.Seed1
5042}
5043
5044func (self *BsnTlvHashSeed) SetSeed1(v uint32) {
5045 self.Seed1 = v
5046}
5047
5048func (self *BsnTlvHashSeed) GetSeed2() uint32 {
5049 return self.Seed2
5050}
5051
5052func (self *BsnTlvHashSeed) SetSeed2(v uint32) {
5053 self.Seed2 = v
5054}
5055
5056func (self *BsnTlvHashSeed) Serialize(encoder *goloxi.Encoder) error {
5057 if err := self.BsnTlv.Serialize(encoder); err != nil {
5058 return err
5059 }
5060
5061 encoder.PutUint32(uint32(self.Seed1))
5062 encoder.PutUint32(uint32(self.Seed2))
5063
5064 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
5065
5066 return nil
5067}
5068
5069func DecodeBsnTlvHashSeed(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHashSeed, error) {
5070 _bsntlvhashseed := &BsnTlvHashSeed{BsnTlv: parent}
5071 if decoder.Length() < 8 {
5072 return nil, fmt.Errorf("BsnTlvHashSeed packet too short: %d < 8", decoder.Length())
5073 }
5074 _bsntlvhashseed.Seed1 = uint32(decoder.ReadUint32())
5075 _bsntlvhashseed.Seed2 = uint32(decoder.ReadUint32())
5076 return _bsntlvhashseed, nil
5077}
5078
5079func NewBsnTlvHashSeed() *BsnTlvHashSeed {
5080 obj := &BsnTlvHashSeed{
5081 BsnTlv: NewBsnTlv(100),
5082 }
5083 return obj
5084}
5085
5086type BsnTlvHashType struct {
5087 *BsnTlv
5088 Value BsnHashType
5089}
5090
5091type IBsnTlvHashType interface {
5092 IBsnTlv
5093 GetValue() BsnHashType
5094}
5095
5096func (self *BsnTlvHashType) GetValue() BsnHashType {
5097 return self.Value
5098}
5099
5100func (self *BsnTlvHashType) SetValue(v BsnHashType) {
5101 self.Value = v
5102}
5103
5104func (self *BsnTlvHashType) Serialize(encoder *goloxi.Encoder) error {
5105 if err := self.BsnTlv.Serialize(encoder); err != nil {
5106 return err
5107 }
5108
5109 encoder.PutUint8(uint8(self.Value))
5110
5111 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
5112
5113 return nil
5114}
5115
5116func DecodeBsnTlvHashType(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHashType, error) {
5117 _bsntlvhashtype := &BsnTlvHashType{BsnTlv: parent}
5118 if decoder.Length() < 1 {
5119 return nil, fmt.Errorf("BsnTlvHashType packet too short: %d < 1", decoder.Length())
5120 }
5121 _bsntlvhashtype.Value = BsnHashType(decoder.ReadByte())
5122 return _bsntlvhashtype, nil
5123}
5124
5125func NewBsnTlvHashType() *BsnTlvHashType {
5126 obj := &BsnTlvHashType{
5127 BsnTlv: NewBsnTlv(101),
5128 }
5129 return obj
5130}
5131
5132type BsnTlvHeaderSize struct {
5133 *BsnTlv
5134 Value uint32
5135}
5136
5137type IBsnTlvHeaderSize interface {
5138 IBsnTlv
5139 GetValue() uint32
5140}
5141
5142func (self *BsnTlvHeaderSize) GetValue() uint32 {
5143 return self.Value
5144}
5145
5146func (self *BsnTlvHeaderSize) SetValue(v uint32) {
5147 self.Value = v
5148}
5149
5150func (self *BsnTlvHeaderSize) Serialize(encoder *goloxi.Encoder) error {
5151 if err := self.BsnTlv.Serialize(encoder); err != nil {
5152 return err
5153 }
5154
5155 encoder.PutUint32(uint32(self.Value))
5156
5157 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
5158
5159 return nil
5160}
5161
5162func DecodeBsnTlvHeaderSize(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHeaderSize, error) {
5163 _bsntlvheadersize := &BsnTlvHeaderSize{BsnTlv: parent}
5164 if decoder.Length() < 4 {
5165 return nil, fmt.Errorf("BsnTlvHeaderSize packet too short: %d < 4", decoder.Length())
5166 }
5167 _bsntlvheadersize.Value = uint32(decoder.ReadUint32())
5168 return _bsntlvheadersize, nil
5169}
5170
5171func NewBsnTlvHeaderSize() *BsnTlvHeaderSize {
5172 obj := &BsnTlvHeaderSize{
5173 BsnTlv: NewBsnTlv(31),
5174 }
5175 return obj
5176}
5177
5178type BsnTlvIcmpCode struct {
5179 *BsnTlv
5180 Value uint8
5181}
5182
5183type IBsnTlvIcmpCode interface {
5184 IBsnTlv
5185 GetValue() uint8
5186}
5187
5188func (self *BsnTlvIcmpCode) GetValue() uint8 {
5189 return self.Value
5190}
5191
5192func (self *BsnTlvIcmpCode) SetValue(v uint8) {
5193 self.Value = v
5194}
5195
5196func (self *BsnTlvIcmpCode) Serialize(encoder *goloxi.Encoder) error {
5197 if err := self.BsnTlv.Serialize(encoder); err != nil {
5198 return err
5199 }
5200
5201 encoder.PutUint8(uint8(self.Value))
5202
5203 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
5204
5205 return nil
5206}
5207
5208func DecodeBsnTlvIcmpCode(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIcmpCode, error) {
5209 _bsntlvicmpcode := &BsnTlvIcmpCode{BsnTlv: parent}
5210 if decoder.Length() < 1 {
5211 return nil, fmt.Errorf("BsnTlvIcmpCode packet too short: %d < 1", decoder.Length())
5212 }
5213 _bsntlvicmpcode.Value = uint8(decoder.ReadByte())
5214 return _bsntlvicmpcode, nil
5215}
5216
5217func NewBsnTlvIcmpCode() *BsnTlvIcmpCode {
5218 obj := &BsnTlvIcmpCode{
5219 BsnTlv: NewBsnTlv(69),
5220 }
5221 return obj
5222}
5223
5224type BsnTlvIcmpId struct {
5225 *BsnTlv
5226 Value uint16
5227}
5228
5229type IBsnTlvIcmpId interface {
5230 IBsnTlv
5231 GetValue() uint16
5232}
5233
5234func (self *BsnTlvIcmpId) GetValue() uint16 {
5235 return self.Value
5236}
5237
5238func (self *BsnTlvIcmpId) SetValue(v uint16) {
5239 self.Value = v
5240}
5241
5242func (self *BsnTlvIcmpId) Serialize(encoder *goloxi.Encoder) error {
5243 if err := self.BsnTlv.Serialize(encoder); err != nil {
5244 return err
5245 }
5246
5247 encoder.PutUint16(uint16(self.Value))
5248
5249 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
5250
5251 return nil
5252}
5253
5254func DecodeBsnTlvIcmpId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIcmpId, error) {
5255 _bsntlvicmpid := &BsnTlvIcmpId{BsnTlv: parent}
5256 if decoder.Length() < 2 {
5257 return nil, fmt.Errorf("BsnTlvIcmpId packet too short: %d < 2", decoder.Length())
5258 }
5259 _bsntlvicmpid.Value = uint16(decoder.ReadUint16())
5260 return _bsntlvicmpid, nil
5261}
5262
5263func NewBsnTlvIcmpId() *BsnTlvIcmpId {
5264 obj := &BsnTlvIcmpId{
5265 BsnTlv: NewBsnTlv(70),
5266 }
5267 return obj
5268}
5269
5270type BsnTlvIcmpType struct {
5271 *BsnTlv
5272 Value uint8
5273}
5274
5275type IBsnTlvIcmpType interface {
5276 IBsnTlv
5277 GetValue() uint8
5278}
5279
5280func (self *BsnTlvIcmpType) GetValue() uint8 {
5281 return self.Value
5282}
5283
5284func (self *BsnTlvIcmpType) SetValue(v uint8) {
5285 self.Value = v
5286}
5287
5288func (self *BsnTlvIcmpType) Serialize(encoder *goloxi.Encoder) error {
5289 if err := self.BsnTlv.Serialize(encoder); err != nil {
5290 return err
5291 }
5292
5293 encoder.PutUint8(uint8(self.Value))
5294
5295 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
5296
5297 return nil
5298}
5299
5300func DecodeBsnTlvIcmpType(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIcmpType, error) {
5301 _bsntlvicmptype := &BsnTlvIcmpType{BsnTlv: parent}
5302 if decoder.Length() < 1 {
5303 return nil, fmt.Errorf("BsnTlvIcmpType packet too short: %d < 1", decoder.Length())
5304 }
5305 _bsntlvicmptype.Value = uint8(decoder.ReadByte())
5306 return _bsntlvicmptype, nil
5307}
5308
5309func NewBsnTlvIcmpType() *BsnTlvIcmpType {
5310 obj := &BsnTlvIcmpType{
5311 BsnTlv: NewBsnTlv(68),
5312 }
5313 return obj
5314}
5315
5316type BsnTlvIcmpv6Chksum struct {
5317 *BsnTlv
5318 Value uint16
5319}
5320
5321type IBsnTlvIcmpv6Chksum interface {
5322 IBsnTlv
5323 GetValue() uint16
5324}
5325
5326func (self *BsnTlvIcmpv6Chksum) GetValue() uint16 {
5327 return self.Value
5328}
5329
5330func (self *BsnTlvIcmpv6Chksum) SetValue(v uint16) {
5331 self.Value = v
5332}
5333
5334func (self *BsnTlvIcmpv6Chksum) Serialize(encoder *goloxi.Encoder) error {
5335 if err := self.BsnTlv.Serialize(encoder); err != nil {
5336 return err
5337 }
5338
5339 encoder.PutUint16(uint16(self.Value))
5340
5341 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
5342
5343 return nil
5344}
5345
5346func DecodeBsnTlvIcmpv6Chksum(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIcmpv6Chksum, error) {
5347 _bsntlvicmpv6chksum := &BsnTlvIcmpv6Chksum{BsnTlv: parent}
5348 if decoder.Length() < 2 {
5349 return nil, fmt.Errorf("BsnTlvIcmpv6Chksum packet too short: %d < 2", decoder.Length())
5350 }
5351 _bsntlvicmpv6chksum.Value = uint16(decoder.ReadUint16())
5352 return _bsntlvicmpv6chksum, nil
5353}
5354
5355func NewBsnTlvIcmpv6Chksum() *BsnTlvIcmpv6Chksum {
5356 obj := &BsnTlvIcmpv6Chksum{
5357 BsnTlv: NewBsnTlv(125),
5358 }
5359 return obj
5360}
5361
5362type BsnTlvIdentifier struct {
5363 *BsnTlv
5364 Value uint32
5365}
5366
5367type IBsnTlvIdentifier interface {
5368 IBsnTlv
5369 GetValue() uint32
5370}
5371
5372func (self *BsnTlvIdentifier) GetValue() uint32 {
5373 return self.Value
5374}
5375
5376func (self *BsnTlvIdentifier) SetValue(v uint32) {
5377 self.Value = v
5378}
5379
5380func (self *BsnTlvIdentifier) Serialize(encoder *goloxi.Encoder) error {
5381 if err := self.BsnTlv.Serialize(encoder); err != nil {
5382 return err
5383 }
5384
5385 encoder.PutUint32(uint32(self.Value))
5386
5387 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
5388
5389 return nil
5390}
5391
5392func DecodeBsnTlvIdentifier(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIdentifier, error) {
5393 _bsntlvidentifier := &BsnTlvIdentifier{BsnTlv: parent}
5394 if decoder.Length() < 4 {
5395 return nil, fmt.Errorf("BsnTlvIdentifier packet too short: %d < 4", decoder.Length())
5396 }
5397 _bsntlvidentifier.Value = uint32(decoder.ReadUint32())
5398 return _bsntlvidentifier, nil
5399}
5400
5401func NewBsnTlvIdentifier() *BsnTlvIdentifier {
5402 obj := &BsnTlvIdentifier{
5403 BsnTlv: NewBsnTlv(173),
5404 }
5405 return obj
5406}
5407
5408type BsnTlvIdleNotification struct {
5409 *BsnTlv
5410}
5411
5412type IBsnTlvIdleNotification interface {
5413 IBsnTlv
5414}
5415
5416func (self *BsnTlvIdleNotification) Serialize(encoder *goloxi.Encoder) error {
5417 if err := self.BsnTlv.Serialize(encoder); err != nil {
5418 return err
5419 }
5420
5421 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
5422
5423 return nil
5424}
5425
5426func DecodeBsnTlvIdleNotification(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIdleNotification, error) {
5427 _bsntlvidlenotification := &BsnTlvIdleNotification{BsnTlv: parent}
5428 return _bsntlvidlenotification, nil
5429}
5430
5431func NewBsnTlvIdleNotification() *BsnTlvIdleNotification {
5432 obj := &BsnTlvIdleNotification{
5433 BsnTlv: NewBsnTlv(7),
5434 }
5435 return obj
5436}
5437
5438type BsnTlvIdleTime struct {
5439 *BsnTlv
5440 Value uint64
5441}
5442
5443type IBsnTlvIdleTime interface {
5444 IBsnTlv
5445 GetValue() uint64
5446}
5447
5448func (self *BsnTlvIdleTime) GetValue() uint64 {
5449 return self.Value
5450}
5451
5452func (self *BsnTlvIdleTime) SetValue(v uint64) {
5453 self.Value = v
5454}
5455
5456func (self *BsnTlvIdleTime) Serialize(encoder *goloxi.Encoder) error {
5457 if err := self.BsnTlv.Serialize(encoder); err != nil {
5458 return err
5459 }
5460
5461 encoder.PutUint64(uint64(self.Value))
5462
5463 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
5464
5465 return nil
5466}
5467
5468func DecodeBsnTlvIdleTime(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIdleTime, error) {
5469 _bsntlvidletime := &BsnTlvIdleTime{BsnTlv: parent}
5470 if decoder.Length() < 8 {
5471 return nil, fmt.Errorf("BsnTlvIdleTime packet too short: %d < 8", decoder.Length())
5472 }
5473 _bsntlvidletime.Value = uint64(decoder.ReadUint64())
5474 return _bsntlvidletime, nil
5475}
5476
5477func NewBsnTlvIdleTime() *BsnTlvIdleTime {
5478 obj := &BsnTlvIdleTime{
5479 BsnTlv: NewBsnTlv(5),
5480 }
5481 return obj
5482}
5483
5484type BsnTlvIdleTimeout struct {
5485 *BsnTlv
5486 Value uint32
5487}
5488
5489type IBsnTlvIdleTimeout interface {
5490 IBsnTlv
5491 GetValue() uint32
5492}
5493
5494func (self *BsnTlvIdleTimeout) GetValue() uint32 {
5495 return self.Value
5496}
5497
5498func (self *BsnTlvIdleTimeout) SetValue(v uint32) {
5499 self.Value = v
5500}
5501
5502func (self *BsnTlvIdleTimeout) Serialize(encoder *goloxi.Encoder) error {
5503 if err := self.BsnTlv.Serialize(encoder); err != nil {
5504 return err
5505 }
5506
5507 encoder.PutUint32(uint32(self.Value))
5508
5509 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
5510
5511 return nil
5512}
5513
5514func DecodeBsnTlvIdleTimeout(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIdleTimeout, error) {
5515 _bsntlvidletimeout := &BsnTlvIdleTimeout{BsnTlv: parent}
5516 if decoder.Length() < 4 {
5517 return nil, fmt.Errorf("BsnTlvIdleTimeout packet too short: %d < 4", decoder.Length())
5518 }
5519 _bsntlvidletimeout.Value = uint32(decoder.ReadUint32())
5520 return _bsntlvidletimeout, nil
5521}
5522
5523func NewBsnTlvIdleTimeout() *BsnTlvIdleTimeout {
5524 obj := &BsnTlvIdleTimeout{
5525 BsnTlv: NewBsnTlv(8),
5526 }
5527 return obj
5528}
5529
5530type BsnTlvIgmpSnooping struct {
5531 *BsnTlv
5532}
5533
5534type IBsnTlvIgmpSnooping interface {
5535 IBsnTlv
5536}
5537
5538func (self *BsnTlvIgmpSnooping) Serialize(encoder *goloxi.Encoder) error {
5539 if err := self.BsnTlv.Serialize(encoder); err != nil {
5540 return err
5541 }
5542
5543 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
5544
5545 return nil
5546}
5547
5548func DecodeBsnTlvIgmpSnooping(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIgmpSnooping, error) {
5549 _bsntlvigmpsnooping := &BsnTlvIgmpSnooping{BsnTlv: parent}
5550 return _bsntlvigmpsnooping, nil
5551}
5552
5553func NewBsnTlvIgmpSnooping() *BsnTlvIgmpSnooping {
5554 obj := &BsnTlvIgmpSnooping{
5555 BsnTlv: NewBsnTlv(78),
5556 }
5557 return obj
5558}
5559
5560type BsnTlvIngressPortGroupId struct {
5561 *BsnTlv
5562 Value uint32
5563}
5564
5565type IBsnTlvIngressPortGroupId interface {
5566 IBsnTlv
5567 GetValue() uint32
5568}
5569
5570func (self *BsnTlvIngressPortGroupId) GetValue() uint32 {
5571 return self.Value
5572}
5573
5574func (self *BsnTlvIngressPortGroupId) SetValue(v uint32) {
5575 self.Value = v
5576}
5577
5578func (self *BsnTlvIngressPortGroupId) Serialize(encoder *goloxi.Encoder) error {
5579 if err := self.BsnTlv.Serialize(encoder); err != nil {
5580 return err
5581 }
5582
5583 encoder.PutUint32(uint32(self.Value))
5584
5585 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
5586
5587 return nil
5588}
5589
5590func DecodeBsnTlvIngressPortGroupId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIngressPortGroupId, error) {
5591 _bsntlvingressportgroupid := &BsnTlvIngressPortGroupId{BsnTlv: parent}
5592 if decoder.Length() < 4 {
5593 return nil, fmt.Errorf("BsnTlvIngressPortGroupId packet too short: %d < 4", decoder.Length())
5594 }
5595 _bsntlvingressportgroupid.Value = uint32(decoder.ReadUint32())
5596 return _bsntlvingressportgroupid, nil
5597}
5598
5599func NewBsnTlvIngressPortGroupId() *BsnTlvIngressPortGroupId {
5600 obj := &BsnTlvIngressPortGroupId{
5601 BsnTlv: NewBsnTlv(138),
5602 }
5603 return obj
5604}
5605
5606type BsnTlvInternalGatewayMac struct {
5607 *BsnTlv
5608 Value net.HardwareAddr
5609}
5610
5611type IBsnTlvInternalGatewayMac interface {
5612 IBsnTlv
5613 GetValue() net.HardwareAddr
5614}
5615
5616func (self *BsnTlvInternalGatewayMac) GetValue() net.HardwareAddr {
5617 return self.Value
5618}
5619
5620func (self *BsnTlvInternalGatewayMac) SetValue(v net.HardwareAddr) {
5621 self.Value = v
5622}
5623
5624func (self *BsnTlvInternalGatewayMac) Serialize(encoder *goloxi.Encoder) error {
5625 if err := self.BsnTlv.Serialize(encoder); err != nil {
5626 return err
5627 }
5628
5629 encoder.Write(self.Value)
5630
5631 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
5632
5633 return nil
5634}
5635
5636func DecodeBsnTlvInternalGatewayMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvInternalGatewayMac, error) {
5637 _bsntlvinternalgatewaymac := &BsnTlvInternalGatewayMac{BsnTlv: parent}
5638 if decoder.Length() < 6 {
5639 return nil, fmt.Errorf("BsnTlvInternalGatewayMac packet too short: %d < 6", decoder.Length())
5640 }
5641 _bsntlvinternalgatewaymac.Value = net.HardwareAddr(decoder.Read(6))
5642 return _bsntlvinternalgatewaymac, nil
5643}
5644
5645func NewBsnTlvInternalGatewayMac() *BsnTlvInternalGatewayMac {
5646 obj := &BsnTlvInternalGatewayMac{
5647 BsnTlv: NewBsnTlv(28),
5648 }
5649 return obj
5650}
5651
5652type BsnTlvInternalMac struct {
5653 *BsnTlv
5654 Value net.HardwareAddr
5655}
5656
5657type IBsnTlvInternalMac interface {
5658 IBsnTlv
5659 GetValue() net.HardwareAddr
5660}
5661
5662func (self *BsnTlvInternalMac) GetValue() net.HardwareAddr {
5663 return self.Value
5664}
5665
5666func (self *BsnTlvInternalMac) SetValue(v net.HardwareAddr) {
5667 self.Value = v
5668}
5669
5670func (self *BsnTlvInternalMac) Serialize(encoder *goloxi.Encoder) error {
5671 if err := self.BsnTlv.Serialize(encoder); err != nil {
5672 return err
5673 }
5674
5675 encoder.Write(self.Value)
5676
5677 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
5678
5679 return nil
5680}
5681
5682func DecodeBsnTlvInternalMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvInternalMac, error) {
5683 _bsntlvinternalmac := &BsnTlvInternalMac{BsnTlv: parent}
5684 if decoder.Length() < 6 {
5685 return nil, fmt.Errorf("BsnTlvInternalMac packet too short: %d < 6", decoder.Length())
5686 }
5687 _bsntlvinternalmac.Value = net.HardwareAddr(decoder.Read(6))
5688 return _bsntlvinternalmac, nil
5689}
5690
5691func NewBsnTlvInternalMac() *BsnTlvInternalMac {
5692 obj := &BsnTlvInternalMac{
5693 BsnTlv: NewBsnTlv(27),
5694 }
5695 return obj
5696}
5697
5698type BsnTlvInterval struct {
5699 *BsnTlv
5700 Value uint32
5701}
5702
5703type IBsnTlvInterval interface {
5704 IBsnTlv
5705 GetValue() uint32
5706}
5707
5708func (self *BsnTlvInterval) GetValue() uint32 {
5709 return self.Value
5710}
5711
5712func (self *BsnTlvInterval) SetValue(v uint32) {
5713 self.Value = v
5714}
5715
5716func (self *BsnTlvInterval) Serialize(encoder *goloxi.Encoder) error {
5717 if err := self.BsnTlv.Serialize(encoder); err != nil {
5718 return err
5719 }
5720
5721 encoder.PutUint32(uint32(self.Value))
5722
5723 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
5724
5725 return nil
5726}
5727
5728func DecodeBsnTlvInterval(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvInterval, error) {
5729 _bsntlvinterval := &BsnTlvInterval{BsnTlv: parent}
5730 if decoder.Length() < 4 {
5731 return nil, fmt.Errorf("BsnTlvInterval packet too short: %d < 4", decoder.Length())
5732 }
5733 _bsntlvinterval.Value = uint32(decoder.ReadUint32())
5734 return _bsntlvinterval, nil
5735}
5736
5737func NewBsnTlvInterval() *BsnTlvInterval {
5738 obj := &BsnTlvInterval{
5739 BsnTlv: NewBsnTlv(58),
5740 }
5741 return obj
5742}
5743
5744type BsnTlvIpProto struct {
5745 *BsnTlv
5746 Value uint8
5747}
5748
5749type IBsnTlvIpProto interface {
5750 IBsnTlv
5751 GetValue() uint8
5752}
5753
5754func (self *BsnTlvIpProto) GetValue() uint8 {
5755 return self.Value
5756}
5757
5758func (self *BsnTlvIpProto) SetValue(v uint8) {
5759 self.Value = v
5760}
5761
5762func (self *BsnTlvIpProto) Serialize(encoder *goloxi.Encoder) error {
5763 if err := self.BsnTlv.Serialize(encoder); err != nil {
5764 return err
5765 }
5766
5767 encoder.PutUint8(uint8(self.Value))
5768
5769 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
5770
5771 return nil
5772}
5773
5774func DecodeBsnTlvIpProto(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpProto, error) {
5775 _bsntlvipproto := &BsnTlvIpProto{BsnTlv: parent}
5776 if decoder.Length() < 1 {
5777 return nil, fmt.Errorf("BsnTlvIpProto packet too short: %d < 1", decoder.Length())
5778 }
5779 _bsntlvipproto.Value = uint8(decoder.ReadByte())
5780 return _bsntlvipproto, nil
5781}
5782
5783func NewBsnTlvIpProto() *BsnTlvIpProto {
5784 obj := &BsnTlvIpProto{
5785 BsnTlv: NewBsnTlv(67),
5786 }
5787 return obj
5788}
5789
5790type BsnTlvIpTunnelType struct {
5791 *BsnTlv
5792 Value BsnIpTunnelType
5793}
5794
5795type IBsnTlvIpTunnelType interface {
5796 IBsnTlv
5797 GetValue() BsnIpTunnelType
5798}
5799
5800func (self *BsnTlvIpTunnelType) GetValue() BsnIpTunnelType {
5801 return self.Value
5802}
5803
5804func (self *BsnTlvIpTunnelType) SetValue(v BsnIpTunnelType) {
5805 self.Value = v
5806}
5807
5808func (self *BsnTlvIpTunnelType) Serialize(encoder *goloxi.Encoder) error {
5809 if err := self.BsnTlv.Serialize(encoder); err != nil {
5810 return err
5811 }
5812
5813 encoder.PutUint16(uint16(self.Value))
5814
5815 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
5816
5817 return nil
5818}
5819
5820func DecodeBsnTlvIpTunnelType(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpTunnelType, error) {
5821 _bsntlviptunneltype := &BsnTlvIpTunnelType{BsnTlv: parent}
5822 if decoder.Length() < 2 {
5823 return nil, fmt.Errorf("BsnTlvIpTunnelType packet too short: %d < 2", decoder.Length())
5824 }
5825 _bsntlviptunneltype.Value = BsnIpTunnelType(decoder.ReadUint16())
5826 return _bsntlviptunneltype, nil
5827}
5828
5829func NewBsnTlvIpTunnelType() *BsnTlvIpTunnelType {
5830 obj := &BsnTlvIpTunnelType{
5831 BsnTlv: NewBsnTlv(169),
5832 }
5833 return obj
5834}
5835
5836type BsnTlvIpv4 struct {
5837 *BsnTlv
5838 Value net.IP
5839}
5840
5841type IBsnTlvIpv4 interface {
5842 IBsnTlv
5843 GetValue() net.IP
5844}
5845
5846func (self *BsnTlvIpv4) GetValue() net.IP {
5847 return self.Value
5848}
5849
5850func (self *BsnTlvIpv4) SetValue(v net.IP) {
5851 self.Value = v
5852}
5853
5854func (self *BsnTlvIpv4) Serialize(encoder *goloxi.Encoder) error {
5855 if err := self.BsnTlv.Serialize(encoder); err != nil {
5856 return err
5857 }
5858
5859 encoder.Write(self.Value.To4())
5860
5861 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
5862
5863 return nil
5864}
5865
5866func DecodeBsnTlvIpv4(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv4, error) {
5867 _bsntlvipv4 := &BsnTlvIpv4{BsnTlv: parent}
5868 if decoder.Length() < 4 {
5869 return nil, fmt.Errorf("BsnTlvIpv4 packet too short: %d < 4", decoder.Length())
5870 }
5871 _bsntlvipv4.Value = net.IP(decoder.Read(4))
5872 return _bsntlvipv4, nil
5873}
5874
5875func NewBsnTlvIpv4() *BsnTlvIpv4 {
5876 obj := &BsnTlvIpv4{
5877 BsnTlv: NewBsnTlv(4),
5878 }
5879 return obj
5880}
5881
5882type BsnTlvIpv4Dst struct {
5883 *BsnTlv
5884 Value net.IP
5885}
5886
5887type IBsnTlvIpv4Dst interface {
5888 IBsnTlv
5889 GetValue() net.IP
5890}
5891
5892func (self *BsnTlvIpv4Dst) GetValue() net.IP {
5893 return self.Value
5894}
5895
5896func (self *BsnTlvIpv4Dst) SetValue(v net.IP) {
5897 self.Value = v
5898}
5899
5900func (self *BsnTlvIpv4Dst) Serialize(encoder *goloxi.Encoder) error {
5901 if err := self.BsnTlv.Serialize(encoder); err != nil {
5902 return err
5903 }
5904
5905 encoder.Write(self.Value.To4())
5906
5907 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
5908
5909 return nil
5910}
5911
5912func DecodeBsnTlvIpv4Dst(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv4Dst, error) {
5913 _bsntlvipv4dst := &BsnTlvIpv4Dst{BsnTlv: parent}
5914 if decoder.Length() < 4 {
5915 return nil, fmt.Errorf("BsnTlvIpv4Dst packet too short: %d < 4", decoder.Length())
5916 }
5917 _bsntlvipv4dst.Value = net.IP(decoder.Read(4))
5918 return _bsntlvipv4dst, nil
5919}
5920
5921func NewBsnTlvIpv4Dst() *BsnTlvIpv4Dst {
5922 obj := &BsnTlvIpv4Dst{
5923 BsnTlv: NewBsnTlv(35),
5924 }
5925 return obj
5926}
5927
5928type BsnTlvIpv4Netmask struct {
5929 *BsnTlv
5930 Value net.IP
5931}
5932
5933type IBsnTlvIpv4Netmask interface {
5934 IBsnTlv
5935 GetValue() net.IP
5936}
5937
5938func (self *BsnTlvIpv4Netmask) GetValue() net.IP {
5939 return self.Value
5940}
5941
5942func (self *BsnTlvIpv4Netmask) SetValue(v net.IP) {
5943 self.Value = v
5944}
5945
5946func (self *BsnTlvIpv4Netmask) Serialize(encoder *goloxi.Encoder) error {
5947 if err := self.BsnTlv.Serialize(encoder); err != nil {
5948 return err
5949 }
5950
5951 encoder.Write(self.Value.To4())
5952
5953 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
5954
5955 return nil
5956}
5957
5958func DecodeBsnTlvIpv4Netmask(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv4Netmask, error) {
5959 _bsntlvipv4netmask := &BsnTlvIpv4Netmask{BsnTlv: parent}
5960 if decoder.Length() < 4 {
5961 return nil, fmt.Errorf("BsnTlvIpv4Netmask packet too short: %d < 4", decoder.Length())
5962 }
5963 _bsntlvipv4netmask.Value = net.IP(decoder.Read(4))
5964 return _bsntlvipv4netmask, nil
5965}
5966
5967func NewBsnTlvIpv4Netmask() *BsnTlvIpv4Netmask {
5968 obj := &BsnTlvIpv4Netmask{
5969 BsnTlv: NewBsnTlv(60),
5970 }
5971 return obj
5972}
5973
5974type BsnTlvIpv4Src struct {
5975 *BsnTlv
5976 Value net.IP
5977}
5978
5979type IBsnTlvIpv4Src interface {
5980 IBsnTlv
5981 GetValue() net.IP
5982}
5983
5984func (self *BsnTlvIpv4Src) GetValue() net.IP {
5985 return self.Value
5986}
5987
5988func (self *BsnTlvIpv4Src) SetValue(v net.IP) {
5989 self.Value = v
5990}
5991
5992func (self *BsnTlvIpv4Src) Serialize(encoder *goloxi.Encoder) error {
5993 if err := self.BsnTlv.Serialize(encoder); err != nil {
5994 return err
5995 }
5996
5997 encoder.Write(self.Value.To4())
5998
5999 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
6000
6001 return nil
6002}
6003
6004func DecodeBsnTlvIpv4Src(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv4Src, error) {
6005 _bsntlvipv4src := &BsnTlvIpv4Src{BsnTlv: parent}
6006 if decoder.Length() < 4 {
6007 return nil, fmt.Errorf("BsnTlvIpv4Src packet too short: %d < 4", decoder.Length())
6008 }
6009 _bsntlvipv4src.Value = net.IP(decoder.Read(4))
6010 return _bsntlvipv4src, nil
6011}
6012
6013func NewBsnTlvIpv4Src() *BsnTlvIpv4Src {
6014 obj := &BsnTlvIpv4Src{
6015 BsnTlv: NewBsnTlv(34),
6016 }
6017 return obj
6018}
6019
6020type BsnTlvIpv6 struct {
6021 *BsnTlv
6022 Value net.IP
6023}
6024
6025type IBsnTlvIpv6 interface {
6026 IBsnTlv
6027 GetValue() net.IP
6028}
6029
6030func (self *BsnTlvIpv6) GetValue() net.IP {
6031 return self.Value
6032}
6033
6034func (self *BsnTlvIpv6) SetValue(v net.IP) {
6035 self.Value = v
6036}
6037
6038func (self *BsnTlvIpv6) Serialize(encoder *goloxi.Encoder) error {
6039 if err := self.BsnTlv.Serialize(encoder); err != nil {
6040 return err
6041 }
6042
6043 encoder.Write(self.Value.To16())
6044
6045 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
6046
6047 return nil
6048}
6049
6050func DecodeBsnTlvIpv6(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv6, error) {
6051 _bsntlvipv6 := &BsnTlvIpv6{BsnTlv: parent}
6052 if decoder.Length() < 16 {
6053 return nil, fmt.Errorf("BsnTlvIpv6 packet too short: %d < 16", decoder.Length())
6054 }
6055 _bsntlvipv6.Value = net.IP(decoder.Read(16))
6056 return _bsntlvipv6, nil
6057}
6058
6059func NewBsnTlvIpv6() *BsnTlvIpv6 {
6060 obj := &BsnTlvIpv6{
6061 BsnTlv: NewBsnTlv(84),
6062 }
6063 return obj
6064}
6065
6066type BsnTlvIpv6Dst struct {
6067 *BsnTlv
6068 Value net.IP
6069}
6070
6071type IBsnTlvIpv6Dst interface {
6072 IBsnTlv
6073 GetValue() net.IP
6074}
6075
6076func (self *BsnTlvIpv6Dst) GetValue() net.IP {
6077 return self.Value
6078}
6079
6080func (self *BsnTlvIpv6Dst) SetValue(v net.IP) {
6081 self.Value = v
6082}
6083
6084func (self *BsnTlvIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
6085 if err := self.BsnTlv.Serialize(encoder); err != nil {
6086 return err
6087 }
6088
6089 encoder.Write(self.Value.To16())
6090
6091 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
6092
6093 return nil
6094}
6095
6096func DecodeBsnTlvIpv6Dst(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv6Dst, error) {
6097 _bsntlvipv6dst := &BsnTlvIpv6Dst{BsnTlv: parent}
6098 if decoder.Length() < 16 {
6099 return nil, fmt.Errorf("BsnTlvIpv6Dst packet too short: %d < 16", decoder.Length())
6100 }
6101 _bsntlvipv6dst.Value = net.IP(decoder.Read(16))
6102 return _bsntlvipv6dst, nil
6103}
6104
6105func NewBsnTlvIpv6Dst() *BsnTlvIpv6Dst {
6106 obj := &BsnTlvIpv6Dst{
6107 BsnTlv: NewBsnTlv(127),
6108 }
6109 return obj
6110}
6111
6112type BsnTlvIpv6Prefix struct {
6113 *BsnTlv
6114 Value net.IP
6115 PrefixLength uint8
6116}
6117
6118type IBsnTlvIpv6Prefix interface {
6119 IBsnTlv
6120 GetValue() net.IP
6121 GetPrefixLength() uint8
6122}
6123
6124func (self *BsnTlvIpv6Prefix) GetValue() net.IP {
6125 return self.Value
6126}
6127
6128func (self *BsnTlvIpv6Prefix) SetValue(v net.IP) {
6129 self.Value = v
6130}
6131
6132func (self *BsnTlvIpv6Prefix) GetPrefixLength() uint8 {
6133 return self.PrefixLength
6134}
6135
6136func (self *BsnTlvIpv6Prefix) SetPrefixLength(v uint8) {
6137 self.PrefixLength = v
6138}
6139
6140func (self *BsnTlvIpv6Prefix) Serialize(encoder *goloxi.Encoder) error {
6141 if err := self.BsnTlv.Serialize(encoder); err != nil {
6142 return err
6143 }
6144
6145 encoder.Write(self.Value.To16())
6146 encoder.PutUint8(uint8(self.PrefixLength))
6147
6148 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
6149
6150 return nil
6151}
6152
6153func DecodeBsnTlvIpv6Prefix(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv6Prefix, error) {
6154 _bsntlvipv6prefix := &BsnTlvIpv6Prefix{BsnTlv: parent}
6155 if decoder.Length() < 17 {
6156 return nil, fmt.Errorf("BsnTlvIpv6Prefix packet too short: %d < 17", decoder.Length())
6157 }
6158 _bsntlvipv6prefix.Value = net.IP(decoder.Read(16))
6159 _bsntlvipv6prefix.PrefixLength = uint8(decoder.ReadByte())
6160 return _bsntlvipv6prefix, nil
6161}
6162
6163func NewBsnTlvIpv6Prefix() *BsnTlvIpv6Prefix {
6164 obj := &BsnTlvIpv6Prefix{
6165 BsnTlv: NewBsnTlv(122),
6166 }
6167 return obj
6168}
6169
6170type BsnTlvIpv6Src struct {
6171 *BsnTlv
6172 Value net.IP
6173}
6174
6175type IBsnTlvIpv6Src interface {
6176 IBsnTlv
6177 GetValue() net.IP
6178}
6179
6180func (self *BsnTlvIpv6Src) GetValue() net.IP {
6181 return self.Value
6182}
6183
6184func (self *BsnTlvIpv6Src) SetValue(v net.IP) {
6185 self.Value = v
6186}
6187
6188func (self *BsnTlvIpv6Src) Serialize(encoder *goloxi.Encoder) error {
6189 if err := self.BsnTlv.Serialize(encoder); err != nil {
6190 return err
6191 }
6192
6193 encoder.Write(self.Value.To16())
6194
6195 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
6196
6197 return nil
6198}
6199
6200func DecodeBsnTlvIpv6Src(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv6Src, error) {
6201 _bsntlvipv6src := &BsnTlvIpv6Src{BsnTlv: parent}
6202 if decoder.Length() < 16 {
6203 return nil, fmt.Errorf("BsnTlvIpv6Src packet too short: %d < 16", decoder.Length())
6204 }
6205 _bsntlvipv6src.Value = net.IP(decoder.Read(16))
6206 return _bsntlvipv6src, nil
6207}
6208
6209func NewBsnTlvIpv6Src() *BsnTlvIpv6Src {
6210 obj := &BsnTlvIpv6Src{
6211 BsnTlv: NewBsnTlv(126),
6212 }
6213 return obj
6214}
6215
6216type BsnTlvKnownMulticastRate struct {
6217 *BsnTlv
6218 Value uint32
6219}
6220
6221type IBsnTlvKnownMulticastRate interface {
6222 IBsnTlv
6223 GetValue() uint32
6224}
6225
6226func (self *BsnTlvKnownMulticastRate) GetValue() uint32 {
6227 return self.Value
6228}
6229
6230func (self *BsnTlvKnownMulticastRate) SetValue(v uint32) {
6231 self.Value = v
6232}
6233
6234func (self *BsnTlvKnownMulticastRate) Serialize(encoder *goloxi.Encoder) error {
6235 if err := self.BsnTlv.Serialize(encoder); err != nil {
6236 return err
6237 }
6238
6239 encoder.PutUint32(uint32(self.Value))
6240
6241 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
6242
6243 return nil
6244}
6245
6246func DecodeBsnTlvKnownMulticastRate(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvKnownMulticastRate, error) {
6247 _bsntlvknownmulticastrate := &BsnTlvKnownMulticastRate{BsnTlv: parent}
6248 if decoder.Length() < 4 {
6249 return nil, fmt.Errorf("BsnTlvKnownMulticastRate packet too short: %d < 4", decoder.Length())
6250 }
6251 _bsntlvknownmulticastrate.Value = uint32(decoder.ReadUint32())
6252 return _bsntlvknownmulticastrate, nil
6253}
6254
6255func NewBsnTlvKnownMulticastRate() *BsnTlvKnownMulticastRate {
6256 obj := &BsnTlvKnownMulticastRate{
6257 BsnTlv: NewBsnTlv(91),
6258 }
6259 return obj
6260}
6261
6262type BsnTlvL2MulticastLookup struct {
6263 *BsnTlv
6264}
6265
6266type IBsnTlvL2MulticastLookup interface {
6267 IBsnTlv
6268}
6269
6270func (self *BsnTlvL2MulticastLookup) Serialize(encoder *goloxi.Encoder) error {
6271 if err := self.BsnTlv.Serialize(encoder); err != nil {
6272 return err
6273 }
6274
6275 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
6276
6277 return nil
6278}
6279
6280func DecodeBsnTlvL2MulticastLookup(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvL2MulticastLookup, error) {
6281 _bsntlvl2multicastlookup := &BsnTlvL2MulticastLookup{BsnTlv: parent}
6282 return _bsntlvl2multicastlookup, nil
6283}
6284
6285func NewBsnTlvL2MulticastLookup() *BsnTlvL2MulticastLookup {
6286 obj := &BsnTlvL2MulticastLookup{
6287 BsnTlv: NewBsnTlv(79),
6288 }
6289 return obj
6290}
6291
6292type BsnTlvL3 struct {
6293 *BsnTlv
6294}
6295
6296type IBsnTlvL3 interface {
6297 IBsnTlv
6298}
6299
6300func (self *BsnTlvL3) Serialize(encoder *goloxi.Encoder) error {
6301 if err := self.BsnTlv.Serialize(encoder); err != nil {
6302 return err
6303 }
6304
6305 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
6306
6307 return nil
6308}
6309
6310func DecodeBsnTlvL3(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvL3, error) {
6311 _bsntlvl3 := &BsnTlvL3{BsnTlv: parent}
6312 return _bsntlvl3, nil
6313}
6314
6315func NewBsnTlvL3() *BsnTlvL3 {
6316 obj := &BsnTlvL3{
6317 BsnTlv: NewBsnTlv(168),
6318 }
6319 return obj
6320}
6321
6322type BsnTlvL3DstClassId struct {
6323 *BsnTlv
6324 Value uint32
6325}
6326
6327type IBsnTlvL3DstClassId interface {
6328 IBsnTlv
6329 GetValue() uint32
6330}
6331
6332func (self *BsnTlvL3DstClassId) GetValue() uint32 {
6333 return self.Value
6334}
6335
6336func (self *BsnTlvL3DstClassId) SetValue(v uint32) {
6337 self.Value = v
6338}
6339
6340func (self *BsnTlvL3DstClassId) Serialize(encoder *goloxi.Encoder) error {
6341 if err := self.BsnTlv.Serialize(encoder); err != nil {
6342 return err
6343 }
6344
6345 encoder.PutUint32(uint32(self.Value))
6346
6347 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
6348
6349 return nil
6350}
6351
6352func DecodeBsnTlvL3DstClassId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvL3DstClassId, error) {
6353 _bsntlvl3dstclassid := &BsnTlvL3DstClassId{BsnTlv: parent}
6354 if decoder.Length() < 4 {
6355 return nil, fmt.Errorf("BsnTlvL3DstClassId packet too short: %d < 4", decoder.Length())
6356 }
6357 _bsntlvl3dstclassid.Value = uint32(decoder.ReadUint32())
6358 return _bsntlvl3dstclassid, nil
6359}
6360
6361func NewBsnTlvL3DstClassId() *BsnTlvL3DstClassId {
6362 obj := &BsnTlvL3DstClassId{
6363 BsnTlv: NewBsnTlv(136),
6364 }
6365 return obj
6366}
6367
6368type BsnTlvL3InterfaceClassId struct {
6369 *BsnTlv
6370 Value uint32
6371}
6372
6373type IBsnTlvL3InterfaceClassId interface {
6374 IBsnTlv
6375 GetValue() uint32
6376}
6377
6378func (self *BsnTlvL3InterfaceClassId) GetValue() uint32 {
6379 return self.Value
6380}
6381
6382func (self *BsnTlvL3InterfaceClassId) SetValue(v uint32) {
6383 self.Value = v
6384}
6385
6386func (self *BsnTlvL3InterfaceClassId) Serialize(encoder *goloxi.Encoder) error {
6387 if err := self.BsnTlv.Serialize(encoder); err != nil {
6388 return err
6389 }
6390
6391 encoder.PutUint32(uint32(self.Value))
6392
6393 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
6394
6395 return nil
6396}
6397
6398func DecodeBsnTlvL3InterfaceClassId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvL3InterfaceClassId, error) {
6399 _bsntlvl3interfaceclassid := &BsnTlvL3InterfaceClassId{BsnTlv: parent}
6400 if decoder.Length() < 4 {
6401 return nil, fmt.Errorf("BsnTlvL3InterfaceClassId packet too short: %d < 4", decoder.Length())
6402 }
6403 _bsntlvl3interfaceclassid.Value = uint32(decoder.ReadUint32())
6404 return _bsntlvl3interfaceclassid, nil
6405}
6406
6407func NewBsnTlvL3InterfaceClassId() *BsnTlvL3InterfaceClassId {
6408 obj := &BsnTlvL3InterfaceClassId{
6409 BsnTlv: NewBsnTlv(134),
6410 }
6411 return obj
6412}
6413
6414type BsnTlvL3SrcClassId struct {
6415 *BsnTlv
6416 Value uint32
6417}
6418
6419type IBsnTlvL3SrcClassId interface {
6420 IBsnTlv
6421 GetValue() uint32
6422}
6423
6424func (self *BsnTlvL3SrcClassId) GetValue() uint32 {
6425 return self.Value
6426}
6427
6428func (self *BsnTlvL3SrcClassId) SetValue(v uint32) {
6429 self.Value = v
6430}
6431
6432func (self *BsnTlvL3SrcClassId) Serialize(encoder *goloxi.Encoder) error {
6433 if err := self.BsnTlv.Serialize(encoder); err != nil {
6434 return err
6435 }
6436
6437 encoder.PutUint32(uint32(self.Value))
6438
6439 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
6440
6441 return nil
6442}
6443
6444func DecodeBsnTlvL3SrcClassId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvL3SrcClassId, error) {
6445 _bsntlvl3srcclassid := &BsnTlvL3SrcClassId{BsnTlv: parent}
6446 if decoder.Length() < 4 {
6447 return nil, fmt.Errorf("BsnTlvL3SrcClassId packet too short: %d < 4", decoder.Length())
6448 }
6449 _bsntlvl3srcclassid.Value = uint32(decoder.ReadUint32())
6450 return _bsntlvl3srcclassid, nil
6451}
6452
6453func NewBsnTlvL3SrcClassId() *BsnTlvL3SrcClassId {
6454 obj := &BsnTlvL3SrcClassId{
6455 BsnTlv: NewBsnTlv(135),
6456 }
6457 return obj
6458}
6459
6460type BsnTlvLagOptions struct {
6461 *BsnTlv
6462 Flags BsnLagFlag
6463}
6464
6465type IBsnTlvLagOptions interface {
6466 IBsnTlv
6467 GetFlags() BsnLagFlag
6468}
6469
6470func (self *BsnTlvLagOptions) GetFlags() BsnLagFlag {
6471 return self.Flags
6472}
6473
6474func (self *BsnTlvLagOptions) SetFlags(v BsnLagFlag) {
6475 self.Flags = v
6476}
6477
6478func (self *BsnTlvLagOptions) Serialize(encoder *goloxi.Encoder) error {
6479 if err := self.BsnTlv.Serialize(encoder); err != nil {
6480 return err
6481 }
6482
6483 encoder.PutUint16(uint16(self.Flags))
6484
6485 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
6486
6487 return nil
6488}
6489
6490func DecodeBsnTlvLagOptions(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvLagOptions, error) {
6491 _bsntlvlagoptions := &BsnTlvLagOptions{BsnTlv: parent}
6492 if decoder.Length() < 2 {
6493 return nil, fmt.Errorf("BsnTlvLagOptions packet too short: %d < 2", decoder.Length())
6494 }
6495 _bsntlvlagoptions.Flags = BsnLagFlag(decoder.ReadUint16())
6496 return _bsntlvlagoptions, nil
6497}
6498
6499func NewBsnTlvLagOptions() *BsnTlvLagOptions {
6500 obj := &BsnTlvLagOptions{
6501 BsnTlv: NewBsnTlv(160),
6502 }
6503 return obj
6504}
6505
6506type BsnTlvLoopbackMode struct {
6507 *BsnTlv
6508 Value BsnLoopbackMode
6509}
6510
6511type IBsnTlvLoopbackMode interface {
6512 IBsnTlv
6513 GetValue() BsnLoopbackMode
6514}
6515
6516func (self *BsnTlvLoopbackMode) GetValue() BsnLoopbackMode {
6517 return self.Value
6518}
6519
6520func (self *BsnTlvLoopbackMode) SetValue(v BsnLoopbackMode) {
6521 self.Value = v
6522}
6523
6524func (self *BsnTlvLoopbackMode) Serialize(encoder *goloxi.Encoder) error {
6525 if err := self.BsnTlv.Serialize(encoder); err != nil {
6526 return err
6527 }
6528
6529 encoder.PutUint8(uint8(self.Value))
6530
6531 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
6532
6533 return nil
6534}
6535
6536func DecodeBsnTlvLoopbackMode(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvLoopbackMode, error) {
6537 _bsntlvloopbackmode := &BsnTlvLoopbackMode{BsnTlv: parent}
6538 if decoder.Length() < 1 {
6539 return nil, fmt.Errorf("BsnTlvLoopbackMode packet too short: %d < 1", decoder.Length())
6540 }
6541 _bsntlvloopbackmode.Value = BsnLoopbackMode(decoder.ReadByte())
6542 return _bsntlvloopbackmode, nil
6543}
6544
6545func NewBsnTlvLoopbackMode() *BsnTlvLoopbackMode {
6546 obj := &BsnTlvLoopbackMode{
6547 BsnTlv: NewBsnTlv(146),
6548 }
6549 return obj
6550}
6551
6552type BsnTlvLoopbackPort struct {
6553 *BsnTlv
6554 Value Port
6555}
6556
6557type IBsnTlvLoopbackPort interface {
6558 IBsnTlv
6559 GetValue() Port
6560}
6561
6562func (self *BsnTlvLoopbackPort) GetValue() Port {
6563 return self.Value
6564}
6565
6566func (self *BsnTlvLoopbackPort) SetValue(v Port) {
6567 self.Value = v
6568}
6569
6570func (self *BsnTlvLoopbackPort) Serialize(encoder *goloxi.Encoder) error {
6571 if err := self.BsnTlv.Serialize(encoder); err != nil {
6572 return err
6573 }
6574
6575 self.Value.Serialize(encoder)
6576
6577 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
6578
6579 return nil
6580}
6581
6582func DecodeBsnTlvLoopbackPort(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvLoopbackPort, error) {
6583 _bsntlvloopbackport := &BsnTlvLoopbackPort{BsnTlv: parent}
6584 if decoder.Length() < 4 {
6585 return nil, fmt.Errorf("BsnTlvLoopbackPort packet too short: %d < 4", decoder.Length())
6586 }
6587 _bsntlvloopbackport.Value.Decode(decoder)
6588 return _bsntlvloopbackport, nil
6589}
6590
6591func NewBsnTlvLoopbackPort() *BsnTlvLoopbackPort {
6592 obj := &BsnTlvLoopbackPort{
6593 BsnTlv: NewBsnTlv(110),
6594 }
6595 return obj
6596}
6597
6598type BsnTlvLrAllEnabled struct {
6599 *BsnTlv
6600}
6601
6602type IBsnTlvLrAllEnabled interface {
6603 IBsnTlv
6604}
6605
6606func (self *BsnTlvLrAllEnabled) Serialize(encoder *goloxi.Encoder) error {
6607 if err := self.BsnTlv.Serialize(encoder); err != nil {
6608 return err
6609 }
6610
6611 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
6612
6613 return nil
6614}
6615
6616func DecodeBsnTlvLrAllEnabled(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvLrAllEnabled, error) {
6617 _bsntlvlrallenabled := &BsnTlvLrAllEnabled{BsnTlv: parent}
6618 return _bsntlvlrallenabled, nil
6619}
6620
6621func NewBsnTlvLrAllEnabled() *BsnTlvLrAllEnabled {
6622 obj := &BsnTlvLrAllEnabled{
6623 BsnTlv: NewBsnTlv(178),
6624 }
6625 return obj
6626}
6627
6628type BsnTlvMac struct {
6629 *BsnTlv
6630 Value net.HardwareAddr
6631}
6632
6633type IBsnTlvMac interface {
6634 IBsnTlv
6635 GetValue() net.HardwareAddr
6636}
6637
6638func (self *BsnTlvMac) GetValue() net.HardwareAddr {
6639 return self.Value
6640}
6641
6642func (self *BsnTlvMac) SetValue(v net.HardwareAddr) {
6643 self.Value = v
6644}
6645
6646func (self *BsnTlvMac) Serialize(encoder *goloxi.Encoder) error {
6647 if err := self.BsnTlv.Serialize(encoder); err != nil {
6648 return err
6649 }
6650
6651 encoder.Write(self.Value)
6652
6653 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
6654
6655 return nil
6656}
6657
6658func DecodeBsnTlvMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMac, error) {
6659 _bsntlvmac := &BsnTlvMac{BsnTlv: parent}
6660 if decoder.Length() < 6 {
6661 return nil, fmt.Errorf("BsnTlvMac packet too short: %d < 6", decoder.Length())
6662 }
6663 _bsntlvmac.Value = net.HardwareAddr(decoder.Read(6))
6664 return _bsntlvmac, nil
6665}
6666
6667func NewBsnTlvMac() *BsnTlvMac {
6668 obj := &BsnTlvMac{
6669 BsnTlv: NewBsnTlv(1),
6670 }
6671 return obj
6672}
6673
6674type BsnTlvMacMask struct {
6675 *BsnTlv
6676 Value net.HardwareAddr
6677}
6678
6679type IBsnTlvMacMask interface {
6680 IBsnTlv
6681 GetValue() net.HardwareAddr
6682}
6683
6684func (self *BsnTlvMacMask) GetValue() net.HardwareAddr {
6685 return self.Value
6686}
6687
6688func (self *BsnTlvMacMask) SetValue(v net.HardwareAddr) {
6689 self.Value = v
6690}
6691
6692func (self *BsnTlvMacMask) Serialize(encoder *goloxi.Encoder) error {
6693 if err := self.BsnTlv.Serialize(encoder); err != nil {
6694 return err
6695 }
6696
6697 encoder.Write(self.Value)
6698
6699 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
6700
6701 return nil
6702}
6703
6704func DecodeBsnTlvMacMask(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMacMask, error) {
6705 _bsntlvmacmask := &BsnTlvMacMask{BsnTlv: parent}
6706 if decoder.Length() < 6 {
6707 return nil, fmt.Errorf("BsnTlvMacMask packet too short: %d < 6", decoder.Length())
6708 }
6709 _bsntlvmacmask.Value = net.HardwareAddr(decoder.Read(6))
6710 return _bsntlvmacmask, nil
6711}
6712
6713func NewBsnTlvMacMask() *BsnTlvMacMask {
6714 obj := &BsnTlvMacMask{
6715 BsnTlv: NewBsnTlv(56),
6716 }
6717 return obj
6718}
6719
6720type BsnTlvMcgTypeVxlan struct {
6721 *BsnTlv
6722}
6723
6724type IBsnTlvMcgTypeVxlan interface {
6725 IBsnTlv
6726}
6727
6728func (self *BsnTlvMcgTypeVxlan) Serialize(encoder *goloxi.Encoder) error {
6729 if err := self.BsnTlv.Serialize(encoder); err != nil {
6730 return err
6731 }
6732
6733 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
6734
6735 return nil
6736}
6737
6738func DecodeBsnTlvMcgTypeVxlan(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMcgTypeVxlan, error) {
6739 _bsntlvmcgtypevxlan := &BsnTlvMcgTypeVxlan{BsnTlv: parent}
6740 return _bsntlvmcgtypevxlan, nil
6741}
6742
6743func NewBsnTlvMcgTypeVxlan() *BsnTlvMcgTypeVxlan {
6744 obj := &BsnTlvMcgTypeVxlan{
6745 BsnTlv: NewBsnTlv(87),
6746 }
6747 return obj
6748}
6749
6750type BsnTlvMissPackets struct {
6751 *BsnTlv
6752 Value uint64
6753}
6754
6755type IBsnTlvMissPackets interface {
6756 IBsnTlv
6757 GetValue() uint64
6758}
6759
6760func (self *BsnTlvMissPackets) GetValue() uint64 {
6761 return self.Value
6762}
6763
6764func (self *BsnTlvMissPackets) SetValue(v uint64) {
6765 self.Value = v
6766}
6767
6768func (self *BsnTlvMissPackets) Serialize(encoder *goloxi.Encoder) error {
6769 if err := self.BsnTlv.Serialize(encoder); err != nil {
6770 return err
6771 }
6772
6773 encoder.PutUint64(uint64(self.Value))
6774
6775 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
6776
6777 return nil
6778}
6779
6780func DecodeBsnTlvMissPackets(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMissPackets, error) {
6781 _bsntlvmisspackets := &BsnTlvMissPackets{BsnTlv: parent}
6782 if decoder.Length() < 8 {
6783 return nil, fmt.Errorf("BsnTlvMissPackets packet too short: %d < 8", decoder.Length())
6784 }
6785 _bsntlvmisspackets.Value = uint64(decoder.ReadUint64())
6786 return _bsntlvmisspackets, nil
6787}
6788
6789func NewBsnTlvMissPackets() *BsnTlvMissPackets {
6790 obj := &BsnTlvMissPackets{
6791 BsnTlv: NewBsnTlv(13),
6792 }
6793 return obj
6794}
6795
6796type BsnTlvMplsControlWord struct {
6797 *BsnTlv
6798 Value uint8
6799}
6800
6801type IBsnTlvMplsControlWord interface {
6802 IBsnTlv
6803 GetValue() uint8
6804}
6805
6806func (self *BsnTlvMplsControlWord) GetValue() uint8 {
6807 return self.Value
6808}
6809
6810func (self *BsnTlvMplsControlWord) SetValue(v uint8) {
6811 self.Value = v
6812}
6813
6814func (self *BsnTlvMplsControlWord) Serialize(encoder *goloxi.Encoder) error {
6815 if err := self.BsnTlv.Serialize(encoder); err != nil {
6816 return err
6817 }
6818
6819 encoder.PutUint8(uint8(self.Value))
6820
6821 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
6822
6823 return nil
6824}
6825
6826func DecodeBsnTlvMplsControlWord(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMplsControlWord, error) {
6827 _bsntlvmplscontrolword := &BsnTlvMplsControlWord{BsnTlv: parent}
6828 if decoder.Length() < 1 {
6829 return nil, fmt.Errorf("BsnTlvMplsControlWord packet too short: %d < 1", decoder.Length())
6830 }
6831 _bsntlvmplscontrolword.Value = uint8(decoder.ReadByte())
6832 return _bsntlvmplscontrolword, nil
6833}
6834
6835func NewBsnTlvMplsControlWord() *BsnTlvMplsControlWord {
6836 obj := &BsnTlvMplsControlWord{
6837 BsnTlv: NewBsnTlv(62),
6838 }
6839 return obj
6840}
6841
6842type BsnTlvMplsLabel struct {
6843 *BsnTlv
6844 Value uint32
6845}
6846
6847type IBsnTlvMplsLabel interface {
6848 IBsnTlv
6849 GetValue() uint32
6850}
6851
6852func (self *BsnTlvMplsLabel) GetValue() uint32 {
6853 return self.Value
6854}
6855
6856func (self *BsnTlvMplsLabel) SetValue(v uint32) {
6857 self.Value = v
6858}
6859
6860func (self *BsnTlvMplsLabel) Serialize(encoder *goloxi.Encoder) error {
6861 if err := self.BsnTlv.Serialize(encoder); err != nil {
6862 return err
6863 }
6864
6865 encoder.PutUint32(uint32(self.Value))
6866
6867 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
6868
6869 return nil
6870}
6871
6872func DecodeBsnTlvMplsLabel(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMplsLabel, error) {
6873 _bsntlvmplslabel := &BsnTlvMplsLabel{BsnTlv: parent}
6874 if decoder.Length() < 4 {
6875 return nil, fmt.Errorf("BsnTlvMplsLabel packet too short: %d < 4", decoder.Length())
6876 }
6877 _bsntlvmplslabel.Value = uint32(decoder.ReadUint32())
6878 return _bsntlvmplslabel, nil
6879}
6880
6881func NewBsnTlvMplsLabel() *BsnTlvMplsLabel {
6882 obj := &BsnTlvMplsLabel{
6883 BsnTlv: NewBsnTlv(61),
6884 }
6885 return obj
6886}
6887
6888type BsnTlvMplsSequenced struct {
6889 *BsnTlv
6890 Value uint8
6891}
6892
6893type IBsnTlvMplsSequenced interface {
6894 IBsnTlv
6895 GetValue() uint8
6896}
6897
6898func (self *BsnTlvMplsSequenced) GetValue() uint8 {
6899 return self.Value
6900}
6901
6902func (self *BsnTlvMplsSequenced) SetValue(v uint8) {
6903 self.Value = v
6904}
6905
6906func (self *BsnTlvMplsSequenced) Serialize(encoder *goloxi.Encoder) error {
6907 if err := self.BsnTlv.Serialize(encoder); err != nil {
6908 return err
6909 }
6910
6911 encoder.PutUint8(uint8(self.Value))
6912
6913 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
6914
6915 return nil
6916}
6917
6918func DecodeBsnTlvMplsSequenced(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMplsSequenced, error) {
6919 _bsntlvmplssequenced := &BsnTlvMplsSequenced{BsnTlv: parent}
6920 if decoder.Length() < 1 {
6921 return nil, fmt.Errorf("BsnTlvMplsSequenced packet too short: %d < 1", decoder.Length())
6922 }
6923 _bsntlvmplssequenced.Value = uint8(decoder.ReadByte())
6924 return _bsntlvmplssequenced, nil
6925}
6926
6927func NewBsnTlvMplsSequenced() *BsnTlvMplsSequenced {
6928 obj := &BsnTlvMplsSequenced{
6929 BsnTlv: NewBsnTlv(63),
6930 }
6931 return obj
6932}
6933
6934type BsnTlvMulticastInterfaceId struct {
6935 *BsnTlv
6936 Value uint32
6937}
6938
6939type IBsnTlvMulticastInterfaceId interface {
6940 IBsnTlv
6941 GetValue() uint32
6942}
6943
6944func (self *BsnTlvMulticastInterfaceId) GetValue() uint32 {
6945 return self.Value
6946}
6947
6948func (self *BsnTlvMulticastInterfaceId) SetValue(v uint32) {
6949 self.Value = v
6950}
6951
6952func (self *BsnTlvMulticastInterfaceId) Serialize(encoder *goloxi.Encoder) error {
6953 if err := self.BsnTlv.Serialize(encoder); err != nil {
6954 return err
6955 }
6956
6957 encoder.PutUint32(uint32(self.Value))
6958
6959 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
6960
6961 return nil
6962}
6963
6964func DecodeBsnTlvMulticastInterfaceId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMulticastInterfaceId, error) {
6965 _bsntlvmulticastinterfaceid := &BsnTlvMulticastInterfaceId{BsnTlv: parent}
6966 if decoder.Length() < 4 {
6967 return nil, fmt.Errorf("BsnTlvMulticastInterfaceId packet too short: %d < 4", decoder.Length())
6968 }
6969 _bsntlvmulticastinterfaceid.Value = uint32(decoder.ReadUint32())
6970 return _bsntlvmulticastinterfaceid, nil
6971}
6972
6973func NewBsnTlvMulticastInterfaceId() *BsnTlvMulticastInterfaceId {
6974 obj := &BsnTlvMulticastInterfaceId{
6975 BsnTlv: NewBsnTlv(95),
6976 }
6977 return obj
6978}
6979
6980type BsnTlvMulticastPacket struct {
6981 *BsnTlv
6982 Value BsnMulticastPacket
6983}
6984
6985type IBsnTlvMulticastPacket interface {
6986 IBsnTlv
6987 GetValue() BsnMulticastPacket
6988}
6989
6990func (self *BsnTlvMulticastPacket) GetValue() BsnMulticastPacket {
6991 return self.Value
6992}
6993
6994func (self *BsnTlvMulticastPacket) SetValue(v BsnMulticastPacket) {
6995 self.Value = v
6996}
6997
6998func (self *BsnTlvMulticastPacket) Serialize(encoder *goloxi.Encoder) error {
6999 if err := self.BsnTlv.Serialize(encoder); err != nil {
7000 return err
7001 }
7002
7003 encoder.PutUint16(uint16(self.Value))
7004
7005 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
7006
7007 return nil
7008}
7009
7010func DecodeBsnTlvMulticastPacket(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMulticastPacket, error) {
7011 _bsntlvmulticastpacket := &BsnTlvMulticastPacket{BsnTlv: parent}
7012 if decoder.Length() < 2 {
7013 return nil, fmt.Errorf("BsnTlvMulticastPacket packet too short: %d < 2", decoder.Length())
7014 }
7015 _bsntlvmulticastpacket.Value = BsnMulticastPacket(decoder.ReadUint16())
7016 return _bsntlvmulticastpacket, nil
7017}
7018
7019func NewBsnTlvMulticastPacket() *BsnTlvMulticastPacket {
7020 obj := &BsnTlvMulticastPacket{
7021 BsnTlv: NewBsnTlv(170),
7022 }
7023 return obj
7024}
7025
7026type BsnTlvMultiplier struct {
7027 *BsnTlv
7028 Value uint32
7029}
7030
7031type IBsnTlvMultiplier interface {
7032 IBsnTlv
7033 GetValue() uint32
7034}
7035
7036func (self *BsnTlvMultiplier) GetValue() uint32 {
7037 return self.Value
7038}
7039
7040func (self *BsnTlvMultiplier) SetValue(v uint32) {
7041 self.Value = v
7042}
7043
7044func (self *BsnTlvMultiplier) Serialize(encoder *goloxi.Encoder) error {
7045 if err := self.BsnTlv.Serialize(encoder); err != nil {
7046 return err
7047 }
7048
7049 encoder.PutUint32(uint32(self.Value))
7050
7051 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
7052
7053 return nil
7054}
7055
7056func DecodeBsnTlvMultiplier(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMultiplier, error) {
7057 _bsntlvmultiplier := &BsnTlvMultiplier{BsnTlv: parent}
7058 if decoder.Length() < 4 {
7059 return nil, fmt.Errorf("BsnTlvMultiplier packet too short: %d < 4", decoder.Length())
7060 }
7061 _bsntlvmultiplier.Value = uint32(decoder.ReadUint32())
7062 return _bsntlvmultiplier, nil
7063}
7064
7065func NewBsnTlvMultiplier() *BsnTlvMultiplier {
7066 obj := &BsnTlvMultiplier{
7067 BsnTlv: NewBsnTlv(174),
7068 }
7069 return obj
7070}
7071
7072type BsnTlvName struct {
7073 *BsnTlv
7074 Value []byte
7075}
7076
7077type IBsnTlvName interface {
7078 IBsnTlv
7079 GetValue() []byte
7080}
7081
7082func (self *BsnTlvName) GetValue() []byte {
7083 return self.Value
7084}
7085
7086func (self *BsnTlvName) SetValue(v []byte) {
7087 self.Value = v
7088}
7089
7090func (self *BsnTlvName) Serialize(encoder *goloxi.Encoder) error {
7091 if err := self.BsnTlv.Serialize(encoder); err != nil {
7092 return err
7093 }
7094
7095 encoder.Write(self.Value)
7096
7097 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
7098
7099 return nil
7100}
7101
7102func DecodeBsnTlvName(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvName, error) {
7103 _bsntlvname := &BsnTlvName{BsnTlv: parent}
7104 _bsntlvname.Value = decoder.Read(int(decoder.Length()))
7105 return _bsntlvname, nil
7106}
7107
7108func NewBsnTlvName() *BsnTlvName {
7109 obj := &BsnTlvName{
7110 BsnTlv: NewBsnTlv(52),
7111 }
7112 return obj
7113}
7114
7115type BsnTlvNdpOffload struct {
7116 *BsnTlv
7117}
7118
7119type IBsnTlvNdpOffload interface {
7120 IBsnTlv
7121}
7122
7123func (self *BsnTlvNdpOffload) Serialize(encoder *goloxi.Encoder) error {
7124 if err := self.BsnTlv.Serialize(encoder); err != nil {
7125 return err
7126 }
7127
7128 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
7129
7130 return nil
7131}
7132
7133func DecodeBsnTlvNdpOffload(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNdpOffload, error) {
7134 _bsntlvndpoffload := &BsnTlvNdpOffload{BsnTlv: parent}
7135 return _bsntlvndpoffload, nil
7136}
7137
7138func NewBsnTlvNdpOffload() *BsnTlvNdpOffload {
7139 obj := &BsnTlvNdpOffload{
7140 BsnTlv: NewBsnTlv(123),
7141 }
7142 return obj
7143}
7144
7145type BsnTlvNdpStatic struct {
7146 *BsnTlv
7147}
7148
7149type IBsnTlvNdpStatic interface {
7150 IBsnTlv
7151}
7152
7153func (self *BsnTlvNdpStatic) Serialize(encoder *goloxi.Encoder) error {
7154 if err := self.BsnTlv.Serialize(encoder); err != nil {
7155 return err
7156 }
7157
7158 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
7159
7160 return nil
7161}
7162
7163func DecodeBsnTlvNdpStatic(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNdpStatic, error) {
7164 _bsntlvndpstatic := &BsnTlvNdpStatic{BsnTlv: parent}
7165 return _bsntlvndpstatic, nil
7166}
7167
7168func NewBsnTlvNdpStatic() *BsnTlvNdpStatic {
7169 obj := &BsnTlvNdpStatic{
7170 BsnTlv: NewBsnTlv(124),
7171 }
7172 return obj
7173}
7174
7175type BsnTlvNegate struct {
7176 *BsnTlv
7177}
7178
7179type IBsnTlvNegate interface {
7180 IBsnTlv
7181}
7182
7183func (self *BsnTlvNegate) Serialize(encoder *goloxi.Encoder) error {
7184 if err := self.BsnTlv.Serialize(encoder); err != nil {
7185 return err
7186 }
7187
7188 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
7189
7190 return nil
7191}
7192
7193func DecodeBsnTlvNegate(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNegate, error) {
7194 _bsntlvnegate := &BsnTlvNegate{BsnTlv: parent}
7195 return _bsntlvnegate, nil
7196}
7197
7198func NewBsnTlvNegate() *BsnTlvNegate {
7199 obj := &BsnTlvNegate{
7200 BsnTlv: NewBsnTlv(83),
7201 }
7202 return obj
7203}
7204
7205type BsnTlvNextHopIpv4 struct {
7206 *BsnTlv
7207 Value net.IP
7208}
7209
7210type IBsnTlvNextHopIpv4 interface {
7211 IBsnTlv
7212 GetValue() net.IP
7213}
7214
7215func (self *BsnTlvNextHopIpv4) GetValue() net.IP {
7216 return self.Value
7217}
7218
7219func (self *BsnTlvNextHopIpv4) SetValue(v net.IP) {
7220 self.Value = v
7221}
7222
7223func (self *BsnTlvNextHopIpv4) Serialize(encoder *goloxi.Encoder) error {
7224 if err := self.BsnTlv.Serialize(encoder); err != nil {
7225 return err
7226 }
7227
7228 encoder.Write(self.Value.To4())
7229
7230 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
7231
7232 return nil
7233}
7234
7235func DecodeBsnTlvNextHopIpv4(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNextHopIpv4, error) {
7236 _bsntlvnexthopipv4 := &BsnTlvNextHopIpv4{BsnTlv: parent}
7237 if decoder.Length() < 4 {
7238 return nil, fmt.Errorf("BsnTlvNextHopIpv4 packet too short: %d < 4", decoder.Length())
7239 }
7240 _bsntlvnexthopipv4.Value = net.IP(decoder.Read(4))
7241 return _bsntlvnexthopipv4, nil
7242}
7243
7244func NewBsnTlvNextHopIpv4() *BsnTlvNextHopIpv4 {
7245 obj := &BsnTlvNextHopIpv4{
7246 BsnTlv: NewBsnTlv(115),
7247 }
7248 return obj
7249}
7250
7251type BsnTlvNextHopMac struct {
7252 *BsnTlv
7253 Value net.HardwareAddr
7254}
7255
7256type IBsnTlvNextHopMac interface {
7257 IBsnTlv
7258 GetValue() net.HardwareAddr
7259}
7260
7261func (self *BsnTlvNextHopMac) GetValue() net.HardwareAddr {
7262 return self.Value
7263}
7264
7265func (self *BsnTlvNextHopMac) SetValue(v net.HardwareAddr) {
7266 self.Value = v
7267}
7268
7269func (self *BsnTlvNextHopMac) Serialize(encoder *goloxi.Encoder) error {
7270 if err := self.BsnTlv.Serialize(encoder); err != nil {
7271 return err
7272 }
7273
7274 encoder.Write(self.Value)
7275
7276 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
7277
7278 return nil
7279}
7280
7281func DecodeBsnTlvNextHopMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNextHopMac, error) {
7282 _bsntlvnexthopmac := &BsnTlvNextHopMac{BsnTlv: parent}
7283 if decoder.Length() < 6 {
7284 return nil, fmt.Errorf("BsnTlvNextHopMac packet too short: %d < 6", decoder.Length())
7285 }
7286 _bsntlvnexthopmac.Value = net.HardwareAddr(decoder.Read(6))
7287 return _bsntlvnexthopmac, nil
7288}
7289
7290func NewBsnTlvNextHopMac() *BsnTlvNextHopMac {
7291 obj := &BsnTlvNextHopMac{
7292 BsnTlv: NewBsnTlv(114),
7293 }
7294 return obj
7295}
7296
7297type BsnTlvNexthopTypeVxlan struct {
7298 *BsnTlv
7299}
7300
7301type IBsnTlvNexthopTypeVxlan interface {
7302 IBsnTlv
7303}
7304
7305func (self *BsnTlvNexthopTypeVxlan) Serialize(encoder *goloxi.Encoder) error {
7306 if err := self.BsnTlv.Serialize(encoder); err != nil {
7307 return err
7308 }
7309
7310 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
7311
7312 return nil
7313}
7314
7315func DecodeBsnTlvNexthopTypeVxlan(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNexthopTypeVxlan, error) {
7316 _bsntlvnexthoptypevxlan := &BsnTlvNexthopTypeVxlan{BsnTlv: parent}
7317 return _bsntlvnexthoptypevxlan, nil
7318}
7319
7320func NewBsnTlvNexthopTypeVxlan() *BsnTlvNexthopTypeVxlan {
7321 obj := &BsnTlvNexthopTypeVxlan{
7322 BsnTlv: NewBsnTlv(94),
7323 }
7324 return obj
7325}
7326
7327type BsnTlvNoArpResponse struct {
7328 *BsnTlv
7329}
7330
7331type IBsnTlvNoArpResponse interface {
7332 IBsnTlv
7333}
7334
7335func (self *BsnTlvNoArpResponse) Serialize(encoder *goloxi.Encoder) error {
7336 if err := self.BsnTlv.Serialize(encoder); err != nil {
7337 return err
7338 }
7339
7340 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
7341
7342 return nil
7343}
7344
7345func DecodeBsnTlvNoArpResponse(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNoArpResponse, error) {
7346 _bsntlvnoarpresponse := &BsnTlvNoArpResponse{BsnTlv: parent}
7347 return _bsntlvnoarpresponse, nil
7348}
7349
7350func NewBsnTlvNoArpResponse() *BsnTlvNoArpResponse {
7351 obj := &BsnTlvNoArpResponse{
7352 BsnTlv: NewBsnTlv(147),
7353 }
7354 return obj
7355}
7356
7357type BsnTlvNoNsResponse struct {
7358 *BsnTlv
7359}
7360
7361type IBsnTlvNoNsResponse interface {
7362 IBsnTlv
7363}
7364
7365func (self *BsnTlvNoNsResponse) Serialize(encoder *goloxi.Encoder) error {
7366 if err := self.BsnTlv.Serialize(encoder); err != nil {
7367 return err
7368 }
7369
7370 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
7371
7372 return nil
7373}
7374
7375func DecodeBsnTlvNoNsResponse(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNoNsResponse, error) {
7376 _bsntlvnonsresponse := &BsnTlvNoNsResponse{BsnTlv: parent}
7377 return _bsntlvnonsresponse, nil
7378}
7379
7380func NewBsnTlvNoNsResponse() *BsnTlvNoNsResponse {
7381 obj := &BsnTlvNoNsResponse{
7382 BsnTlv: NewBsnTlv(148),
7383 }
7384 return obj
7385}
7386
7387type BsnTlvOffset struct {
7388 *BsnTlv
7389 Value uint16
7390}
7391
7392type IBsnTlvOffset interface {
7393 IBsnTlv
7394 GetValue() uint16
7395}
7396
7397func (self *BsnTlvOffset) GetValue() uint16 {
7398 return self.Value
7399}
7400
7401func (self *BsnTlvOffset) SetValue(v uint16) {
7402 self.Value = v
7403}
7404
7405func (self *BsnTlvOffset) Serialize(encoder *goloxi.Encoder) error {
7406 if err := self.BsnTlv.Serialize(encoder); err != nil {
7407 return err
7408 }
7409
7410 encoder.PutUint16(uint16(self.Value))
7411
7412 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
7413
7414 return nil
7415}
7416
7417func DecodeBsnTlvOffset(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvOffset, error) {
7418 _bsntlvoffset := &BsnTlvOffset{BsnTlv: parent}
7419 if decoder.Length() < 2 {
7420 return nil, fmt.Errorf("BsnTlvOffset packet too short: %d < 2", decoder.Length())
7421 }
7422 _bsntlvoffset.Value = uint16(decoder.ReadUint16())
7423 return _bsntlvoffset, nil
7424}
7425
7426func NewBsnTlvOffset() *BsnTlvOffset {
7427 obj := &BsnTlvOffset{
7428 BsnTlv: NewBsnTlv(82),
7429 }
7430 return obj
7431}
7432
7433type BsnTlvOpticsAlwaysEnabled struct {
7434 *BsnTlv
7435}
7436
7437type IBsnTlvOpticsAlwaysEnabled interface {
7438 IBsnTlv
7439}
7440
7441func (self *BsnTlvOpticsAlwaysEnabled) Serialize(encoder *goloxi.Encoder) error {
7442 if err := self.BsnTlv.Serialize(encoder); err != nil {
7443 return err
7444 }
7445
7446 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
7447
7448 return nil
7449}
7450
7451func DecodeBsnTlvOpticsAlwaysEnabled(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvOpticsAlwaysEnabled, error) {
7452 _bsntlvopticsalwaysenabled := &BsnTlvOpticsAlwaysEnabled{BsnTlv: parent}
7453 return _bsntlvopticsalwaysenabled, nil
7454}
7455
7456func NewBsnTlvOpticsAlwaysEnabled() *BsnTlvOpticsAlwaysEnabled {
7457 obj := &BsnTlvOpticsAlwaysEnabled{
7458 BsnTlv: NewBsnTlv(150),
7459 }
7460 return obj
7461}
7462
7463type BsnTlvOuterSrcMac struct {
7464 *BsnTlv
7465 Value net.HardwareAddr
7466}
7467
7468type IBsnTlvOuterSrcMac interface {
7469 IBsnTlv
7470 GetValue() net.HardwareAddr
7471}
7472
7473func (self *BsnTlvOuterSrcMac) GetValue() net.HardwareAddr {
7474 return self.Value
7475}
7476
7477func (self *BsnTlvOuterSrcMac) SetValue(v net.HardwareAddr) {
7478 self.Value = v
7479}
7480
7481func (self *BsnTlvOuterSrcMac) Serialize(encoder *goloxi.Encoder) error {
7482 if err := self.BsnTlv.Serialize(encoder); err != nil {
7483 return err
7484 }
7485
7486 encoder.Write(self.Value)
7487
7488 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
7489
7490 return nil
7491}
7492
7493func DecodeBsnTlvOuterSrcMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvOuterSrcMac, error) {
7494 _bsntlvoutersrcmac := &BsnTlvOuterSrcMac{BsnTlv: parent}
7495 if decoder.Length() < 6 {
7496 return nil, fmt.Errorf("BsnTlvOuterSrcMac packet too short: %d < 6", decoder.Length())
7497 }
7498 _bsntlvoutersrcmac.Value = net.HardwareAddr(decoder.Read(6))
7499 return _bsntlvoutersrcmac, nil
7500}
7501
7502func NewBsnTlvOuterSrcMac() *BsnTlvOuterSrcMac {
7503 obj := &BsnTlvOuterSrcMac{
7504 BsnTlv: NewBsnTlv(157),
7505 }
7506 return obj
7507}
7508
7509type BsnTlvParentPort struct {
7510 *BsnTlv
7511 Value Port
7512}
7513
7514type IBsnTlvParentPort interface {
7515 IBsnTlv
7516 GetValue() Port
7517}
7518
7519func (self *BsnTlvParentPort) GetValue() Port {
7520 return self.Value
7521}
7522
7523func (self *BsnTlvParentPort) SetValue(v Port) {
7524 self.Value = v
7525}
7526
7527func (self *BsnTlvParentPort) Serialize(encoder *goloxi.Encoder) error {
7528 if err := self.BsnTlv.Serialize(encoder); err != nil {
7529 return err
7530 }
7531
7532 self.Value.Serialize(encoder)
7533
7534 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
7535
7536 return nil
7537}
7538
7539func DecodeBsnTlvParentPort(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvParentPort, error) {
7540 _bsntlvparentport := &BsnTlvParentPort{BsnTlv: parent}
7541 if decoder.Length() < 4 {
7542 return nil, fmt.Errorf("BsnTlvParentPort packet too short: %d < 4", decoder.Length())
7543 }
7544 _bsntlvparentport.Value.Decode(decoder)
7545 return _bsntlvparentport, nil
7546}
7547
7548func NewBsnTlvParentPort() *BsnTlvParentPort {
7549 obj := &BsnTlvParentPort{
7550 BsnTlv: NewBsnTlv(109),
7551 }
7552 return obj
7553}
7554
7555type BsnTlvPartnerKey struct {
7556 *BsnTlv
7557 Value uint16
7558}
7559
7560type IBsnTlvPartnerKey interface {
7561 IBsnTlv
7562 GetValue() uint16
7563}
7564
7565func (self *BsnTlvPartnerKey) GetValue() uint16 {
7566 return self.Value
7567}
7568
7569func (self *BsnTlvPartnerKey) SetValue(v uint16) {
7570 self.Value = v
7571}
7572
7573func (self *BsnTlvPartnerKey) Serialize(encoder *goloxi.Encoder) error {
7574 if err := self.BsnTlv.Serialize(encoder); err != nil {
7575 return err
7576 }
7577
7578 encoder.PutUint16(uint16(self.Value))
7579
7580 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
7581
7582 return nil
7583}
7584
7585func DecodeBsnTlvPartnerKey(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPartnerKey, error) {
7586 _bsntlvpartnerkey := &BsnTlvPartnerKey{BsnTlv: parent}
7587 if decoder.Length() < 2 {
7588 return nil, fmt.Errorf("BsnTlvPartnerKey packet too short: %d < 2", decoder.Length())
7589 }
7590 _bsntlvpartnerkey.Value = uint16(decoder.ReadUint16())
7591 return _bsntlvpartnerkey, nil
7592}
7593
7594func NewBsnTlvPartnerKey() *BsnTlvPartnerKey {
7595 obj := &BsnTlvPartnerKey{
7596 BsnTlv: NewBsnTlv(51),
7597 }
7598 return obj
7599}
7600
7601type BsnTlvPartnerPortNum struct {
7602 *BsnTlv
7603 Value uint16
7604}
7605
7606type IBsnTlvPartnerPortNum interface {
7607 IBsnTlv
7608 GetValue() uint16
7609}
7610
7611func (self *BsnTlvPartnerPortNum) GetValue() uint16 {
7612 return self.Value
7613}
7614
7615func (self *BsnTlvPartnerPortNum) SetValue(v uint16) {
7616 self.Value = v
7617}
7618
7619func (self *BsnTlvPartnerPortNum) Serialize(encoder *goloxi.Encoder) error {
7620 if err := self.BsnTlv.Serialize(encoder); err != nil {
7621 return err
7622 }
7623
7624 encoder.PutUint16(uint16(self.Value))
7625
7626 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
7627
7628 return nil
7629}
7630
7631func DecodeBsnTlvPartnerPortNum(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPartnerPortNum, error) {
7632 _bsntlvpartnerportnum := &BsnTlvPartnerPortNum{BsnTlv: parent}
7633 if decoder.Length() < 2 {
7634 return nil, fmt.Errorf("BsnTlvPartnerPortNum packet too short: %d < 2", decoder.Length())
7635 }
7636 _bsntlvpartnerportnum.Value = uint16(decoder.ReadUint16())
7637 return _bsntlvpartnerportnum, nil
7638}
7639
7640func NewBsnTlvPartnerPortNum() *BsnTlvPartnerPortNum {
7641 obj := &BsnTlvPartnerPortNum{
7642 BsnTlv: NewBsnTlv(50),
7643 }
7644 return obj
7645}
7646
7647type BsnTlvPartnerPortPriority struct {
7648 *BsnTlv
7649 Value uint16
7650}
7651
7652type IBsnTlvPartnerPortPriority interface {
7653 IBsnTlv
7654 GetValue() uint16
7655}
7656
7657func (self *BsnTlvPartnerPortPriority) GetValue() uint16 {
7658 return self.Value
7659}
7660
7661func (self *BsnTlvPartnerPortPriority) SetValue(v uint16) {
7662 self.Value = v
7663}
7664
7665func (self *BsnTlvPartnerPortPriority) Serialize(encoder *goloxi.Encoder) error {
7666 if err := self.BsnTlv.Serialize(encoder); err != nil {
7667 return err
7668 }
7669
7670 encoder.PutUint16(uint16(self.Value))
7671
7672 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
7673
7674 return nil
7675}
7676
7677func DecodeBsnTlvPartnerPortPriority(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPartnerPortPriority, error) {
7678 _bsntlvpartnerportpriority := &BsnTlvPartnerPortPriority{BsnTlv: parent}
7679 if decoder.Length() < 2 {
7680 return nil, fmt.Errorf("BsnTlvPartnerPortPriority packet too short: %d < 2", decoder.Length())
7681 }
7682 _bsntlvpartnerportpriority.Value = uint16(decoder.ReadUint16())
7683 return _bsntlvpartnerportpriority, nil
7684}
7685
7686func NewBsnTlvPartnerPortPriority() *BsnTlvPartnerPortPriority {
7687 obj := &BsnTlvPartnerPortPriority{
7688 BsnTlv: NewBsnTlv(49),
7689 }
7690 return obj
7691}
7692
7693type BsnTlvPartnerState struct {
7694 *BsnTlv
7695 Value BsnLacpState
7696}
7697
7698type IBsnTlvPartnerState interface {
7699 IBsnTlv
7700 GetValue() BsnLacpState
7701}
7702
7703func (self *BsnTlvPartnerState) GetValue() BsnLacpState {
7704 return self.Value
7705}
7706
7707func (self *BsnTlvPartnerState) SetValue(v BsnLacpState) {
7708 self.Value = v
7709}
7710
7711func (self *BsnTlvPartnerState) Serialize(encoder *goloxi.Encoder) error {
7712 if err := self.BsnTlv.Serialize(encoder); err != nil {
7713 return err
7714 }
7715
7716 encoder.PutUint8(uint8(self.Value))
7717
7718 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
7719
7720 return nil
7721}
7722
7723func DecodeBsnTlvPartnerState(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPartnerState, error) {
7724 _bsntlvpartnerstate := &BsnTlvPartnerState{BsnTlv: parent}
7725 if decoder.Length() < 1 {
7726 return nil, fmt.Errorf("BsnTlvPartnerState packet too short: %d < 1", decoder.Length())
7727 }
7728 _bsntlvpartnerstate.Value = BsnLacpState(decoder.ReadByte())
7729 return _bsntlvpartnerstate, nil
7730}
7731
7732func NewBsnTlvPartnerState() *BsnTlvPartnerState {
7733 obj := &BsnTlvPartnerState{
7734 BsnTlv: NewBsnTlv(54),
7735 }
7736 return obj
7737}
7738
7739type BsnTlvPartnerSystemMac struct {
7740 *BsnTlv
7741 Value net.HardwareAddr
7742}
7743
7744type IBsnTlvPartnerSystemMac interface {
7745 IBsnTlv
7746 GetValue() net.HardwareAddr
7747}
7748
7749func (self *BsnTlvPartnerSystemMac) GetValue() net.HardwareAddr {
7750 return self.Value
7751}
7752
7753func (self *BsnTlvPartnerSystemMac) SetValue(v net.HardwareAddr) {
7754 self.Value = v
7755}
7756
7757func (self *BsnTlvPartnerSystemMac) Serialize(encoder *goloxi.Encoder) error {
7758 if err := self.BsnTlv.Serialize(encoder); err != nil {
7759 return err
7760 }
7761
7762 encoder.Write(self.Value)
7763
7764 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
7765
7766 return nil
7767}
7768
7769func DecodeBsnTlvPartnerSystemMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPartnerSystemMac, error) {
7770 _bsntlvpartnersystemmac := &BsnTlvPartnerSystemMac{BsnTlv: parent}
7771 if decoder.Length() < 6 {
7772 return nil, fmt.Errorf("BsnTlvPartnerSystemMac packet too short: %d < 6", decoder.Length())
7773 }
7774 _bsntlvpartnersystemmac.Value = net.HardwareAddr(decoder.Read(6))
7775 return _bsntlvpartnersystemmac, nil
7776}
7777
7778func NewBsnTlvPartnerSystemMac() *BsnTlvPartnerSystemMac {
7779 obj := &BsnTlvPartnerSystemMac{
7780 BsnTlv: NewBsnTlv(48),
7781 }
7782 return obj
7783}
7784
7785type BsnTlvPartnerSystemPriority struct {
7786 *BsnTlv
7787 Value uint16
7788}
7789
7790type IBsnTlvPartnerSystemPriority interface {
7791 IBsnTlv
7792 GetValue() uint16
7793}
7794
7795func (self *BsnTlvPartnerSystemPriority) GetValue() uint16 {
7796 return self.Value
7797}
7798
7799func (self *BsnTlvPartnerSystemPriority) SetValue(v uint16) {
7800 self.Value = v
7801}
7802
7803func (self *BsnTlvPartnerSystemPriority) Serialize(encoder *goloxi.Encoder) error {
7804 if err := self.BsnTlv.Serialize(encoder); err != nil {
7805 return err
7806 }
7807
7808 encoder.PutUint16(uint16(self.Value))
7809
7810 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
7811
7812 return nil
7813}
7814
7815func DecodeBsnTlvPartnerSystemPriority(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPartnerSystemPriority, error) {
7816 _bsntlvpartnersystempriority := &BsnTlvPartnerSystemPriority{BsnTlv: parent}
7817 if decoder.Length() < 2 {
7818 return nil, fmt.Errorf("BsnTlvPartnerSystemPriority packet too short: %d < 2", decoder.Length())
7819 }
7820 _bsntlvpartnersystempriority.Value = uint16(decoder.ReadUint16())
7821 return _bsntlvpartnersystempriority, nil
7822}
7823
7824func NewBsnTlvPartnerSystemPriority() *BsnTlvPartnerSystemPriority {
7825 obj := &BsnTlvPartnerSystemPriority{
7826 BsnTlv: NewBsnTlv(47),
7827 }
7828 return obj
7829}
7830
7831type BsnTlvPassive struct {
7832 *BsnTlv
7833}
7834
7835type IBsnTlvPassive interface {
7836 IBsnTlv
7837}
7838
7839func (self *BsnTlvPassive) Serialize(encoder *goloxi.Encoder) error {
7840 if err := self.BsnTlv.Serialize(encoder); err != nil {
7841 return err
7842 }
7843
7844 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
7845
7846 return nil
7847}
7848
7849func DecodeBsnTlvPassive(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPassive, error) {
7850 _bsntlvpassive := &BsnTlvPassive{BsnTlv: parent}
7851 return _bsntlvpassive, nil
7852}
7853
7854func NewBsnTlvPassive() *BsnTlvPassive {
7855 obj := &BsnTlvPassive{
7856 BsnTlv: NewBsnTlv(172),
7857 }
7858 return obj
7859}
7860
7861type BsnTlvPduaRxInstance struct {
7862 *BsnTlv
7863 Value []byte
7864}
7865
7866type IBsnTlvPduaRxInstance interface {
7867 IBsnTlv
7868 GetValue() []byte
7869}
7870
7871func (self *BsnTlvPduaRxInstance) GetValue() []byte {
7872 return self.Value
7873}
7874
7875func (self *BsnTlvPduaRxInstance) SetValue(v []byte) {
7876 self.Value = v
7877}
7878
7879func (self *BsnTlvPduaRxInstance) Serialize(encoder *goloxi.Encoder) error {
7880 if err := self.BsnTlv.Serialize(encoder); err != nil {
7881 return err
7882 }
7883
7884 encoder.Write(self.Value)
7885
7886 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
7887
7888 return nil
7889}
7890
7891func DecodeBsnTlvPduaRxInstance(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPduaRxInstance, error) {
7892 _bsntlvpduarxinstance := &BsnTlvPduaRxInstance{BsnTlv: parent}
7893 _bsntlvpduarxinstance.Value = decoder.Read(int(decoder.Length()))
7894 return _bsntlvpduarxinstance, nil
7895}
7896
7897func NewBsnTlvPduaRxInstance() *BsnTlvPduaRxInstance {
7898 obj := &BsnTlvPduaRxInstance{
7899 BsnTlv: NewBsnTlv(159),
7900 }
7901 return obj
7902}
7903
7904type BsnTlvPimDr struct {
7905 *BsnTlv
7906}
7907
7908type IBsnTlvPimDr interface {
7909 IBsnTlv
7910}
7911
7912func (self *BsnTlvPimDr) Serialize(encoder *goloxi.Encoder) error {
7913 if err := self.BsnTlv.Serialize(encoder); err != nil {
7914 return err
7915 }
7916
7917 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
7918
7919 return nil
7920}
7921
7922func DecodeBsnTlvPimDr(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPimDr, error) {
7923 _bsntlvpimdr := &BsnTlvPimDr{BsnTlv: parent}
7924 return _bsntlvpimdr, nil
7925}
7926
7927func NewBsnTlvPimDr() *BsnTlvPimDr {
7928 obj := &BsnTlvPimDr{
7929 BsnTlv: NewBsnTlv(171),
7930 }
7931 return obj
7932}
7933
7934type BsnTlvPimHelloFlood struct {
7935 *BsnTlv
7936}
7937
7938type IBsnTlvPimHelloFlood interface {
7939 IBsnTlv
7940}
7941
7942func (self *BsnTlvPimHelloFlood) Serialize(encoder *goloxi.Encoder) error {
7943 if err := self.BsnTlv.Serialize(encoder); err != nil {
7944 return err
7945 }
7946
7947 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
7948
7949 return nil
7950}
7951
7952func DecodeBsnTlvPimHelloFlood(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPimHelloFlood, error) {
7953 _bsntlvpimhelloflood := &BsnTlvPimHelloFlood{BsnTlv: parent}
7954 return _bsntlvpimhelloflood, nil
7955}
7956
7957func NewBsnTlvPimHelloFlood() *BsnTlvPimHelloFlood {
7958 obj := &BsnTlvPimHelloFlood{
7959 BsnTlv: NewBsnTlv(181),
7960 }
7961 return obj
7962}
7963
7964type BsnTlvPort struct {
7965 *BsnTlv
7966 Value Port
7967}
7968
7969type IBsnTlvPort interface {
7970 IBsnTlv
7971 GetValue() Port
7972}
7973
7974func (self *BsnTlvPort) GetValue() Port {
7975 return self.Value
7976}
7977
7978func (self *BsnTlvPort) SetValue(v Port) {
7979 self.Value = v
7980}
7981
7982func (self *BsnTlvPort) Serialize(encoder *goloxi.Encoder) error {
7983 if err := self.BsnTlv.Serialize(encoder); err != nil {
7984 return err
7985 }
7986
7987 self.Value.Serialize(encoder)
7988
7989 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
7990
7991 return nil
7992}
7993
7994func DecodeBsnTlvPort(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPort, error) {
7995 _bsntlvport := &BsnTlvPort{BsnTlv: parent}
7996 if decoder.Length() < 4 {
7997 return nil, fmt.Errorf("BsnTlvPort packet too short: %d < 4", decoder.Length())
7998 }
7999 _bsntlvport.Value.Decode(decoder)
8000 return _bsntlvport, nil
8001}
8002
8003func NewBsnTlvPort() *BsnTlvPort {
8004 obj := &BsnTlvPort{
8005 BsnTlv: NewBsnTlv(0),
8006 }
8007 return obj
8008}
8009
8010type BsnTlvPortMode struct {
8011 *BsnTlv
8012 Value BsnPortMode
8013}
8014
8015type IBsnTlvPortMode interface {
8016 IBsnTlv
8017 GetValue() BsnPortMode
8018}
8019
8020func (self *BsnTlvPortMode) GetValue() BsnPortMode {
8021 return self.Value
8022}
8023
8024func (self *BsnTlvPortMode) SetValue(v BsnPortMode) {
8025 self.Value = v
8026}
8027
8028func (self *BsnTlvPortMode) Serialize(encoder *goloxi.Encoder) error {
8029 if err := self.BsnTlv.Serialize(encoder); err != nil {
8030 return err
8031 }
8032
8033 encoder.PutUint16(uint16(self.Value))
8034
8035 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
8036
8037 return nil
8038}
8039
8040func DecodeBsnTlvPortMode(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPortMode, error) {
8041 _bsntlvportmode := &BsnTlvPortMode{BsnTlv: parent}
8042 if decoder.Length() < 2 {
8043 return nil, fmt.Errorf("BsnTlvPortMode packet too short: %d < 2", decoder.Length())
8044 }
8045 _bsntlvportmode.Value = BsnPortMode(decoder.ReadUint16())
8046 return _bsntlvportmode, nil
8047}
8048
8049func NewBsnTlvPortMode() *BsnTlvPortMode {
8050 obj := &BsnTlvPortMode{
8051 BsnTlv: NewBsnTlv(179),
8052 }
8053 return obj
8054}
8055
8056type BsnTlvPortSpeedGbps struct {
8057 *BsnTlv
8058 Value uint32
8059}
8060
8061type IBsnTlvPortSpeedGbps interface {
8062 IBsnTlv
8063 GetValue() uint32
8064}
8065
8066func (self *BsnTlvPortSpeedGbps) GetValue() uint32 {
8067 return self.Value
8068}
8069
8070func (self *BsnTlvPortSpeedGbps) SetValue(v uint32) {
8071 self.Value = v
8072}
8073
8074func (self *BsnTlvPortSpeedGbps) Serialize(encoder *goloxi.Encoder) error {
8075 if err := self.BsnTlv.Serialize(encoder); err != nil {
8076 return err
8077 }
8078
8079 encoder.PutUint32(uint32(self.Value))
8080
8081 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
8082
8083 return nil
8084}
8085
8086func DecodeBsnTlvPortSpeedGbps(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPortSpeedGbps, error) {
8087 _bsntlvportspeedgbps := &BsnTlvPortSpeedGbps{BsnTlv: parent}
8088 if decoder.Length() < 4 {
8089 return nil, fmt.Errorf("BsnTlvPortSpeedGbps packet too short: %d < 4", decoder.Length())
8090 }
8091 _bsntlvportspeedgbps.Value = uint32(decoder.ReadUint32())
8092 return _bsntlvportspeedgbps, nil
8093}
8094
8095func NewBsnTlvPortSpeedGbps() *BsnTlvPortSpeedGbps {
8096 obj := &BsnTlvPortSpeedGbps{
8097 BsnTlv: NewBsnTlv(156),
8098 }
8099 return obj
8100}
8101
8102type BsnTlvPortUsage struct {
8103 *BsnTlv
8104 Value BsnPortUsage
8105}
8106
8107type IBsnTlvPortUsage interface {
8108 IBsnTlv
8109 GetValue() BsnPortUsage
8110}
8111
8112func (self *BsnTlvPortUsage) GetValue() BsnPortUsage {
8113 return self.Value
8114}
8115
8116func (self *BsnTlvPortUsage) SetValue(v BsnPortUsage) {
8117 self.Value = v
8118}
8119
8120func (self *BsnTlvPortUsage) Serialize(encoder *goloxi.Encoder) error {
8121 if err := self.BsnTlv.Serialize(encoder); err != nil {
8122 return err
8123 }
8124
8125 encoder.PutUint16(uint16(self.Value))
8126
8127 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
8128
8129 return nil
8130}
8131
8132func DecodeBsnTlvPortUsage(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPortUsage, error) {
8133 _bsntlvportusage := &BsnTlvPortUsage{BsnTlv: parent}
8134 if decoder.Length() < 2 {
8135 return nil, fmt.Errorf("BsnTlvPortUsage packet too short: %d < 2", decoder.Length())
8136 }
8137 _bsntlvportusage.Value = BsnPortUsage(decoder.ReadUint16())
8138 return _bsntlvportusage, nil
8139}
8140
8141func NewBsnTlvPortUsage() *BsnTlvPortUsage {
8142 obj := &BsnTlvPortUsage{
8143 BsnTlv: NewBsnTlv(141),
8144 }
8145 return obj
8146}
8147
8148type BsnTlvPortVxlanMode struct {
8149 *BsnTlv
8150 Value BsnPortVxlanMode
8151}
8152
8153type IBsnTlvPortVxlanMode interface {
8154 IBsnTlv
8155 GetValue() BsnPortVxlanMode
8156}
8157
8158func (self *BsnTlvPortVxlanMode) GetValue() BsnPortVxlanMode {
8159 return self.Value
8160}
8161
8162func (self *BsnTlvPortVxlanMode) SetValue(v BsnPortVxlanMode) {
8163 self.Value = v
8164}
8165
8166func (self *BsnTlvPortVxlanMode) Serialize(encoder *goloxi.Encoder) error {
8167 if err := self.BsnTlv.Serialize(encoder); err != nil {
8168 return err
8169 }
8170
8171 encoder.PutUint8(uint8(self.Value))
8172
8173 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
8174
8175 return nil
8176}
8177
8178func DecodeBsnTlvPortVxlanMode(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPortVxlanMode, error) {
8179 _bsntlvportvxlanmode := &BsnTlvPortVxlanMode{BsnTlv: parent}
8180 if decoder.Length() < 1 {
8181 return nil, fmt.Errorf("BsnTlvPortVxlanMode packet too short: %d < 1", decoder.Length())
8182 }
8183 _bsntlvportvxlanmode.Value = BsnPortVxlanMode(decoder.ReadByte())
8184 return _bsntlvportvxlanmode, nil
8185}
8186
8187func NewBsnTlvPortVxlanMode() *BsnTlvPortVxlanMode {
8188 obj := &BsnTlvPortVxlanMode{
8189 BsnTlv: NewBsnTlv(88),
8190 }
8191 return obj
8192}
8193
8194type BsnTlvPriority struct {
8195 *BsnTlv
8196 Value uint32
8197}
8198
8199type IBsnTlvPriority interface {
8200 IBsnTlv
8201 GetValue() uint32
8202}
8203
8204func (self *BsnTlvPriority) GetValue() uint32 {
8205 return self.Value
8206}
8207
8208func (self *BsnTlvPriority) SetValue(v uint32) {
8209 self.Value = v
8210}
8211
8212func (self *BsnTlvPriority) Serialize(encoder *goloxi.Encoder) error {
8213 if err := self.BsnTlv.Serialize(encoder); err != nil {
8214 return err
8215 }
8216
8217 encoder.PutUint32(uint32(self.Value))
8218
8219 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
8220
8221 return nil
8222}
8223
8224func DecodeBsnTlvPriority(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPriority, error) {
8225 _bsntlvpriority := &BsnTlvPriority{BsnTlv: parent}
8226 if decoder.Length() < 4 {
8227 return nil, fmt.Errorf("BsnTlvPriority packet too short: %d < 4", decoder.Length())
8228 }
8229 _bsntlvpriority.Value = uint32(decoder.ReadUint32())
8230 return _bsntlvpriority, nil
8231}
8232
8233func NewBsnTlvPriority() *BsnTlvPriority {
8234 obj := &BsnTlvPriority{
8235 BsnTlv: NewBsnTlv(57),
8236 }
8237 return obj
8238}
8239
8240type BsnTlvPushVlanOnEgress struct {
8241 *BsnTlv
8242}
8243
8244type IBsnTlvPushVlanOnEgress interface {
8245 IBsnTlv
8246}
8247
8248func (self *BsnTlvPushVlanOnEgress) Serialize(encoder *goloxi.Encoder) error {
8249 if err := self.BsnTlv.Serialize(encoder); err != nil {
8250 return err
8251 }
8252
8253 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
8254
8255 return nil
8256}
8257
8258func DecodeBsnTlvPushVlanOnEgress(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPushVlanOnEgress, error) {
8259 _bsntlvpushvlanonegress := &BsnTlvPushVlanOnEgress{BsnTlv: parent}
8260 return _bsntlvpushvlanonegress, nil
8261}
8262
8263func NewBsnTlvPushVlanOnEgress() *BsnTlvPushVlanOnEgress {
8264 obj := &BsnTlvPushVlanOnEgress{
8265 BsnTlv: NewBsnTlv(162),
8266 }
8267 return obj
8268}
8269
8270type BsnTlvPushVlanOnIngress struct {
8271 *BsnTlv
8272 Flags BsnPushVlan
8273}
8274
8275type IBsnTlvPushVlanOnIngress interface {
8276 IBsnTlv
8277 GetFlags() BsnPushVlan
8278}
8279
8280func (self *BsnTlvPushVlanOnIngress) GetFlags() BsnPushVlan {
8281 return self.Flags
8282}
8283
8284func (self *BsnTlvPushVlanOnIngress) SetFlags(v BsnPushVlan) {
8285 self.Flags = v
8286}
8287
8288func (self *BsnTlvPushVlanOnIngress) Serialize(encoder *goloxi.Encoder) error {
8289 if err := self.BsnTlv.Serialize(encoder); err != nil {
8290 return err
8291 }
8292
8293 encoder.PutUint8(uint8(self.Flags))
8294
8295 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
8296
8297 return nil
8298}
8299
8300func DecodeBsnTlvPushVlanOnIngress(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPushVlanOnIngress, error) {
8301 _bsntlvpushvlanoningress := &BsnTlvPushVlanOnIngress{BsnTlv: parent}
8302 if decoder.Length() < 1 {
8303 return nil, fmt.Errorf("BsnTlvPushVlanOnIngress packet too short: %d < 1", decoder.Length())
8304 }
8305 _bsntlvpushvlanoningress.Flags = BsnPushVlan(decoder.ReadByte())
8306 return _bsntlvpushvlanoningress, nil
8307}
8308
8309func NewBsnTlvPushVlanOnIngress() *BsnTlvPushVlanOnIngress {
8310 obj := &BsnTlvPushVlanOnIngress{
8311 BsnTlv: NewBsnTlv(128),
8312 }
8313 return obj
8314}
8315
8316type BsnTlvQosPriority struct {
8317 *BsnTlv
8318 Value uint32
8319}
8320
8321type IBsnTlvQosPriority interface {
8322 IBsnTlv
8323 GetValue() uint32
8324}
8325
8326func (self *BsnTlvQosPriority) GetValue() uint32 {
8327 return self.Value
8328}
8329
8330func (self *BsnTlvQosPriority) SetValue(v uint32) {
8331 self.Value = v
8332}
8333
8334func (self *BsnTlvQosPriority) Serialize(encoder *goloxi.Encoder) error {
8335 if err := self.BsnTlv.Serialize(encoder); err != nil {
8336 return err
8337 }
8338
8339 encoder.PutUint32(uint32(self.Value))
8340
8341 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
8342
8343 return nil
8344}
8345
8346func DecodeBsnTlvQosPriority(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvQosPriority, error) {
8347 _bsntlvqospriority := &BsnTlvQosPriority{BsnTlv: parent}
8348 if decoder.Length() < 4 {
8349 return nil, fmt.Errorf("BsnTlvQosPriority packet too short: %d < 4", decoder.Length())
8350 }
8351 _bsntlvqospriority.Value = uint32(decoder.ReadUint32())
8352 return _bsntlvqospriority, nil
8353}
8354
8355func NewBsnTlvQosPriority() *BsnTlvQosPriority {
8356 obj := &BsnTlvQosPriority{
8357 BsnTlv: NewBsnTlv(108),
8358 }
8359 return obj
8360}
8361
8362type BsnTlvQueueId struct {
8363 *BsnTlv
8364 Value uint32
8365}
8366
8367type IBsnTlvQueueId interface {
8368 IBsnTlv
8369 GetValue() uint32
8370}
8371
8372func (self *BsnTlvQueueId) GetValue() uint32 {
8373 return self.Value
8374}
8375
8376func (self *BsnTlvQueueId) SetValue(v uint32) {
8377 self.Value = v
8378}
8379
8380func (self *BsnTlvQueueId) Serialize(encoder *goloxi.Encoder) error {
8381 if err := self.BsnTlv.Serialize(encoder); err != nil {
8382 return err
8383 }
8384
8385 encoder.PutUint32(uint32(self.Value))
8386
8387 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
8388
8389 return nil
8390}
8391
8392func DecodeBsnTlvQueueId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvQueueId, error) {
8393 _bsntlvqueueid := &BsnTlvQueueId{BsnTlv: parent}
8394 if decoder.Length() < 4 {
8395 return nil, fmt.Errorf("BsnTlvQueueId packet too short: %d < 4", decoder.Length())
8396 }
8397 _bsntlvqueueid.Value = uint32(decoder.ReadUint32())
8398 return _bsntlvqueueid, nil
8399}
8400
8401func NewBsnTlvQueueId() *BsnTlvQueueId {
8402 obj := &BsnTlvQueueId{
8403 BsnTlv: NewBsnTlv(20),
8404 }
8405 return obj
8406}
8407
8408type BsnTlvQueueWeight struct {
8409 *BsnTlv
8410 Value uint32
8411}
8412
8413type IBsnTlvQueueWeight interface {
8414 IBsnTlv
8415 GetValue() uint32
8416}
8417
8418func (self *BsnTlvQueueWeight) GetValue() uint32 {
8419 return self.Value
8420}
8421
8422func (self *BsnTlvQueueWeight) SetValue(v uint32) {
8423 self.Value = v
8424}
8425
8426func (self *BsnTlvQueueWeight) Serialize(encoder *goloxi.Encoder) error {
8427 if err := self.BsnTlv.Serialize(encoder); err != nil {
8428 return err
8429 }
8430
8431 encoder.PutUint32(uint32(self.Value))
8432
8433 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
8434
8435 return nil
8436}
8437
8438func DecodeBsnTlvQueueWeight(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvQueueWeight, error) {
8439 _bsntlvqueueweight := &BsnTlvQueueWeight{BsnTlv: parent}
8440 if decoder.Length() < 4 {
8441 return nil, fmt.Errorf("BsnTlvQueueWeight packet too short: %d < 4", decoder.Length())
8442 }
8443 _bsntlvqueueweight.Value = uint32(decoder.ReadUint32())
8444 return _bsntlvqueueweight, nil
8445}
8446
8447func NewBsnTlvQueueWeight() *BsnTlvQueueWeight {
8448 obj := &BsnTlvQueueWeight{
8449 BsnTlv: NewBsnTlv(21),
8450 }
8451 return obj
8452}
8453
8454type BsnTlvRateLimit struct {
8455 *BsnTlv
8456 Value uint32
8457}
8458
8459type IBsnTlvRateLimit interface {
8460 IBsnTlv
8461 GetValue() uint32
8462}
8463
8464func (self *BsnTlvRateLimit) GetValue() uint32 {
8465 return self.Value
8466}
8467
8468func (self *BsnTlvRateLimit) SetValue(v uint32) {
8469 self.Value = v
8470}
8471
8472func (self *BsnTlvRateLimit) Serialize(encoder *goloxi.Encoder) error {
8473 if err := self.BsnTlv.Serialize(encoder); err != nil {
8474 return err
8475 }
8476
8477 encoder.PutUint32(uint32(self.Value))
8478
8479 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
8480
8481 return nil
8482}
8483
8484func DecodeBsnTlvRateLimit(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRateLimit, error) {
8485 _bsntlvratelimit := &BsnTlvRateLimit{BsnTlv: parent}
8486 if decoder.Length() < 4 {
8487 return nil, fmt.Errorf("BsnTlvRateLimit packet too short: %d < 4", decoder.Length())
8488 }
8489 _bsntlvratelimit.Value = uint32(decoder.ReadUint32())
8490 return _bsntlvratelimit, nil
8491}
8492
8493func NewBsnTlvRateLimit() *BsnTlvRateLimit {
8494 obj := &BsnTlvRateLimit{
8495 BsnTlv: NewBsnTlv(116),
8496 }
8497 return obj
8498}
8499
8500type BsnTlvRateUnit struct {
8501 *BsnTlv
8502 Value BsnRateUnit
8503}
8504
8505type IBsnTlvRateUnit interface {
8506 IBsnTlv
8507 GetValue() BsnRateUnit
8508}
8509
8510func (self *BsnTlvRateUnit) GetValue() BsnRateUnit {
8511 return self.Value
8512}
8513
8514func (self *BsnTlvRateUnit) SetValue(v BsnRateUnit) {
8515 self.Value = v
8516}
8517
8518func (self *BsnTlvRateUnit) Serialize(encoder *goloxi.Encoder) error {
8519 if err := self.BsnTlv.Serialize(encoder); err != nil {
8520 return err
8521 }
8522
8523 encoder.PutUint8(uint8(self.Value))
8524
8525 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
8526
8527 return nil
8528}
8529
8530func DecodeBsnTlvRateUnit(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRateUnit, error) {
8531 _bsntlvrateunit := &BsnTlvRateUnit{BsnTlv: parent}
8532 if decoder.Length() < 1 {
8533 return nil, fmt.Errorf("BsnTlvRateUnit packet too short: %d < 1", decoder.Length())
8534 }
8535 _bsntlvrateunit.Value = BsnRateUnit(decoder.ReadByte())
8536 return _bsntlvrateunit, nil
8537}
8538
8539func NewBsnTlvRateUnit() *BsnTlvRateUnit {
8540 obj := &BsnTlvRateUnit{
8541 BsnTlv: NewBsnTlv(89),
8542 }
8543 return obj
8544}
8545
8546type BsnTlvRecordPackets struct {
8547 *BsnTlv
8548 Value uint32
8549}
8550
8551type IBsnTlvRecordPackets interface {
8552 IBsnTlv
8553 GetValue() uint32
8554}
8555
8556func (self *BsnTlvRecordPackets) GetValue() uint32 {
8557 return self.Value
8558}
8559
8560func (self *BsnTlvRecordPackets) SetValue(v uint32) {
8561 self.Value = v
8562}
8563
8564func (self *BsnTlvRecordPackets) Serialize(encoder *goloxi.Encoder) error {
8565 if err := self.BsnTlv.Serialize(encoder); err != nil {
8566 return err
8567 }
8568
8569 encoder.PutUint32(uint32(self.Value))
8570
8571 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
8572
8573 return nil
8574}
8575
8576func DecodeBsnTlvRecordPackets(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRecordPackets, error) {
8577 _bsntlvrecordpackets := &BsnTlvRecordPackets{BsnTlv: parent}
8578 if decoder.Length() < 4 {
8579 return nil, fmt.Errorf("BsnTlvRecordPackets packet too short: %d < 4", decoder.Length())
8580 }
8581 _bsntlvrecordpackets.Value = uint32(decoder.ReadUint32())
8582 return _bsntlvrecordpackets, nil
8583}
8584
8585func NewBsnTlvRecordPackets() *BsnTlvRecordPackets {
8586 obj := &BsnTlvRecordPackets{
8587 BsnTlv: NewBsnTlv(155),
8588 }
8589 return obj
8590}
8591
8592type BsnTlvReference struct {
8593 *BsnTlv
8594 TableId uint16
8595 Key []IBsnTlv
8596}
8597
8598type IBsnTlvReference interface {
8599 IBsnTlv
8600 GetTableId() uint16
8601 GetKey() []IBsnTlv
8602}
8603
8604func (self *BsnTlvReference) GetTableId() uint16 {
8605 return self.TableId
8606}
8607
8608func (self *BsnTlvReference) SetTableId(v uint16) {
8609 self.TableId = v
8610}
8611
8612func (self *BsnTlvReference) GetKey() []IBsnTlv {
8613 return self.Key
8614}
8615
8616func (self *BsnTlvReference) SetKey(v []IBsnTlv) {
8617 self.Key = v
8618}
8619
8620func (self *BsnTlvReference) Serialize(encoder *goloxi.Encoder) error {
8621 if err := self.BsnTlv.Serialize(encoder); err != nil {
8622 return err
8623 }
8624
8625 encoder.PutUint16(uint16(self.TableId))
8626 for _, obj := range self.Key {
8627 if err := obj.Serialize(encoder); err != nil {
8628 return err
8629 }
8630 }
8631
8632 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
8633
8634 return nil
8635}
8636
8637func DecodeBsnTlvReference(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvReference, error) {
8638 _bsntlvreference := &BsnTlvReference{BsnTlv: parent}
8639 if decoder.Length() < 2 {
8640 return nil, fmt.Errorf("BsnTlvReference packet too short: %d < 2", decoder.Length())
8641 }
8642 _bsntlvreference.TableId = uint16(decoder.ReadUint16())
8643
8644 for decoder.Length() >= 4 {
8645 item, err := DecodeBsnTlv(decoder)
8646 if err != nil {
8647 return nil, err
8648 }
8649 if item != nil {
8650 _bsntlvreference.Key = append(_bsntlvreference.Key, item)
8651 }
8652 }
8653 return _bsntlvreference, nil
8654}
8655
8656func NewBsnTlvReference() *BsnTlvReference {
8657 obj := &BsnTlvReference{
8658 BsnTlv: NewBsnTlv(59),
8659 }
8660 return obj
8661}
8662
8663type BsnTlvReplyPackets struct {
8664 *BsnTlv
8665 Value uint64
8666}
8667
8668type IBsnTlvReplyPackets interface {
8669 IBsnTlv
8670 GetValue() uint64
8671}
8672
8673func (self *BsnTlvReplyPackets) GetValue() uint64 {
8674 return self.Value
8675}
8676
8677func (self *BsnTlvReplyPackets) SetValue(v uint64) {
8678 self.Value = v
8679}
8680
8681func (self *BsnTlvReplyPackets) Serialize(encoder *goloxi.Encoder) error {
8682 if err := self.BsnTlv.Serialize(encoder); err != nil {
8683 return err
8684 }
8685
8686 encoder.PutUint64(uint64(self.Value))
8687
8688 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
8689
8690 return nil
8691}
8692
8693func DecodeBsnTlvReplyPackets(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvReplyPackets, error) {
8694 _bsntlvreplypackets := &BsnTlvReplyPackets{BsnTlv: parent}
8695 if decoder.Length() < 8 {
8696 return nil, fmt.Errorf("BsnTlvReplyPackets packet too short: %d < 8", decoder.Length())
8697 }
8698 _bsntlvreplypackets.Value = uint64(decoder.ReadUint64())
8699 return _bsntlvreplypackets, nil
8700}
8701
8702func NewBsnTlvReplyPackets() *BsnTlvReplyPackets {
8703 obj := &BsnTlvReplyPackets{
8704 BsnTlv: NewBsnTlv(12),
8705 }
8706 return obj
8707}
8708
8709type BsnTlvRequestPackets struct {
8710 *BsnTlv
8711 Value uint64
8712}
8713
8714type IBsnTlvRequestPackets interface {
8715 IBsnTlv
8716 GetValue() uint64
8717}
8718
8719func (self *BsnTlvRequestPackets) GetValue() uint64 {
8720 return self.Value
8721}
8722
8723func (self *BsnTlvRequestPackets) SetValue(v uint64) {
8724 self.Value = v
8725}
8726
8727func (self *BsnTlvRequestPackets) Serialize(encoder *goloxi.Encoder) error {
8728 if err := self.BsnTlv.Serialize(encoder); err != nil {
8729 return err
8730 }
8731
8732 encoder.PutUint64(uint64(self.Value))
8733
8734 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
8735
8736 return nil
8737}
8738
8739func DecodeBsnTlvRequestPackets(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRequestPackets, error) {
8740 _bsntlvrequestpackets := &BsnTlvRequestPackets{BsnTlv: parent}
8741 if decoder.Length() < 8 {
8742 return nil, fmt.Errorf("BsnTlvRequestPackets packet too short: %d < 8", decoder.Length())
8743 }
8744 _bsntlvrequestpackets.Value = uint64(decoder.ReadUint64())
8745 return _bsntlvrequestpackets, nil
8746}
8747
8748func NewBsnTlvRequestPackets() *BsnTlvRequestPackets {
8749 obj := &BsnTlvRequestPackets{
8750 BsnTlv: NewBsnTlv(11),
8751 }
8752 return obj
8753}
8754
8755type BsnTlvRestServer struct {
8756 *BsnTlv
8757}
8758
8759type IBsnTlvRestServer interface {
8760 IBsnTlv
8761}
8762
8763func (self *BsnTlvRestServer) Serialize(encoder *goloxi.Encoder) error {
8764 if err := self.BsnTlv.Serialize(encoder); err != nil {
8765 return err
8766 }
8767
8768 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
8769
8770 return nil
8771}
8772
8773func DecodeBsnTlvRestServer(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRestServer, error) {
8774 _bsntlvrestserver := &BsnTlvRestServer{BsnTlv: parent}
8775 return _bsntlvrestserver, nil
8776}
8777
8778func NewBsnTlvRestServer() *BsnTlvRestServer {
8779 obj := &BsnTlvRestServer{
8780 BsnTlv: NewBsnTlv(152),
8781 }
8782 return obj
8783}
8784
8785type BsnTlvRoutingParam struct {
8786 *BsnTlv
8787 Value BsnRoutingParam
8788}
8789
8790type IBsnTlvRoutingParam interface {
8791 IBsnTlv
8792 GetValue() BsnRoutingParam
8793}
8794
8795func (self *BsnTlvRoutingParam) GetValue() BsnRoutingParam {
8796 return self.Value
8797}
8798
8799func (self *BsnTlvRoutingParam) SetValue(v BsnRoutingParam) {
8800 self.Value = v
8801}
8802
8803func (self *BsnTlvRoutingParam) Serialize(encoder *goloxi.Encoder) error {
8804 if err := self.BsnTlv.Serialize(encoder); err != nil {
8805 return err
8806 }
8807
8808 encoder.PutUint16(uint16(self.Value))
8809
8810 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
8811
8812 return nil
8813}
8814
8815func DecodeBsnTlvRoutingParam(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRoutingParam, error) {
8816 _bsntlvroutingparam := &BsnTlvRoutingParam{BsnTlv: parent}
8817 if decoder.Length() < 2 {
8818 return nil, fmt.Errorf("BsnTlvRoutingParam packet too short: %d < 2", decoder.Length())
8819 }
8820 _bsntlvroutingparam.Value = BsnRoutingParam(decoder.ReadUint16())
8821 return _bsntlvroutingparam, nil
8822}
8823
8824func NewBsnTlvRoutingParam() *BsnTlvRoutingParam {
8825 obj := &BsnTlvRoutingParam{
8826 BsnTlv: NewBsnTlv(161),
8827 }
8828 return obj
8829}
8830
8831type BsnTlvRxBytes struct {
8832 *BsnTlv
8833 Value uint64
8834}
8835
8836type IBsnTlvRxBytes interface {
8837 IBsnTlv
8838 GetValue() uint64
8839}
8840
8841func (self *BsnTlvRxBytes) GetValue() uint64 {
8842 return self.Value
8843}
8844
8845func (self *BsnTlvRxBytes) SetValue(v uint64) {
8846 self.Value = v
8847}
8848
8849func (self *BsnTlvRxBytes) Serialize(encoder *goloxi.Encoder) error {
8850 if err := self.BsnTlv.Serialize(encoder); err != nil {
8851 return err
8852 }
8853
8854 encoder.PutUint64(uint64(self.Value))
8855
8856 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
8857
8858 return nil
8859}
8860
8861func DecodeBsnTlvRxBytes(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRxBytes, error) {
8862 _bsntlvrxbytes := &BsnTlvRxBytes{BsnTlv: parent}
8863 if decoder.Length() < 8 {
8864 return nil, fmt.Errorf("BsnTlvRxBytes packet too short: %d < 8", decoder.Length())
8865 }
8866 _bsntlvrxbytes.Value = uint64(decoder.ReadUint64())
8867 return _bsntlvrxbytes, nil
8868}
8869
8870func NewBsnTlvRxBytes() *BsnTlvRxBytes {
8871 obj := &BsnTlvRxBytes{
8872 BsnTlv: NewBsnTlv(71),
8873 }
8874 return obj
8875}
8876
8877type BsnTlvRxPackets struct {
8878 *BsnTlv
8879 Value uint64
8880}
8881
8882type IBsnTlvRxPackets interface {
8883 IBsnTlv
8884 GetValue() uint64
8885}
8886
8887func (self *BsnTlvRxPackets) GetValue() uint64 {
8888 return self.Value
8889}
8890
8891func (self *BsnTlvRxPackets) SetValue(v uint64) {
8892 self.Value = v
8893}
8894
8895func (self *BsnTlvRxPackets) Serialize(encoder *goloxi.Encoder) error {
8896 if err := self.BsnTlv.Serialize(encoder); err != nil {
8897 return err
8898 }
8899
8900 encoder.PutUint64(uint64(self.Value))
8901
8902 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
8903
8904 return nil
8905}
8906
8907func DecodeBsnTlvRxPackets(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRxPackets, error) {
8908 _bsntlvrxpackets := &BsnTlvRxPackets{BsnTlv: parent}
8909 if decoder.Length() < 8 {
8910 return nil, fmt.Errorf("BsnTlvRxPackets packet too short: %d < 8", decoder.Length())
8911 }
8912 _bsntlvrxpackets.Value = uint64(decoder.ReadUint64())
8913 return _bsntlvrxpackets, nil
8914}
8915
8916func NewBsnTlvRxPackets() *BsnTlvRxPackets {
8917 obj := &BsnTlvRxPackets{
8918 BsnTlv: NewBsnTlv(2),
8919 }
8920 return obj
8921}
8922
8923type BsnTlvSamplingRate struct {
8924 *BsnTlv
8925 Value uint32
8926}
8927
8928type IBsnTlvSamplingRate interface {
8929 IBsnTlv
8930 GetValue() uint32
8931}
8932
8933func (self *BsnTlvSamplingRate) GetValue() uint32 {
8934 return self.Value
8935}
8936
8937func (self *BsnTlvSamplingRate) SetValue(v uint32) {
8938 self.Value = v
8939}
8940
8941func (self *BsnTlvSamplingRate) Serialize(encoder *goloxi.Encoder) error {
8942 if err := self.BsnTlv.Serialize(encoder); err != nil {
8943 return err
8944 }
8945
8946 encoder.PutUint32(uint32(self.Value))
8947
8948 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
8949
8950 return nil
8951}
8952
8953func DecodeBsnTlvSamplingRate(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvSamplingRate, error) {
8954 _bsntlvsamplingrate := &BsnTlvSamplingRate{BsnTlv: parent}
8955 if decoder.Length() < 4 {
8956 return nil, fmt.Errorf("BsnTlvSamplingRate packet too short: %d < 4", decoder.Length())
8957 }
8958 _bsntlvsamplingrate.Value = uint32(decoder.ReadUint32())
8959 return _bsntlvsamplingrate, nil
8960}
8961
8962func NewBsnTlvSamplingRate() *BsnTlvSamplingRate {
8963 obj := &BsnTlvSamplingRate{
8964 BsnTlv: NewBsnTlv(30),
8965 }
8966 return obj
8967}
8968
8969type BsnTlvSetLoopbackMode struct {
8970 *BsnTlv
8971}
8972
8973type IBsnTlvSetLoopbackMode interface {
8974 IBsnTlv
8975}
8976
8977func (self *BsnTlvSetLoopbackMode) Serialize(encoder *goloxi.Encoder) error {
8978 if err := self.BsnTlv.Serialize(encoder); err != nil {
8979 return err
8980 }
8981
8982 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
8983
8984 return nil
8985}
8986
8987func DecodeBsnTlvSetLoopbackMode(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvSetLoopbackMode, error) {
8988 _bsntlvsetloopbackmode := &BsnTlvSetLoopbackMode{BsnTlv: parent}
8989 return _bsntlvsetloopbackmode, nil
8990}
8991
8992func NewBsnTlvSetLoopbackMode() *BsnTlvSetLoopbackMode {
8993 obj := &BsnTlvSetLoopbackMode{
8994 BsnTlv: NewBsnTlv(74),
8995 }
8996 return obj
8997}
8998
8999type BsnTlvStatus struct {
9000 *BsnTlv
9001 Value BsnStatus
9002}
9003
9004type IBsnTlvStatus interface {
9005 IBsnTlv
9006 GetValue() BsnStatus
9007}
9008
9009func (self *BsnTlvStatus) GetValue() BsnStatus {
9010 return self.Value
9011}
9012
9013func (self *BsnTlvStatus) SetValue(v BsnStatus) {
9014 self.Value = v
9015}
9016
9017func (self *BsnTlvStatus) Serialize(encoder *goloxi.Encoder) error {
9018 if err := self.BsnTlv.Serialize(encoder); err != nil {
9019 return err
9020 }
9021
9022 encoder.PutUint8(uint8(self.Value))
9023
9024 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
9025
9026 return nil
9027}
9028
9029func DecodeBsnTlvStatus(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvStatus, error) {
9030 _bsntlvstatus := &BsnTlvStatus{BsnTlv: parent}
9031 if decoder.Length() < 1 {
9032 return nil, fmt.Errorf("BsnTlvStatus packet too short: %d < 1", decoder.Length())
9033 }
9034 _bsntlvstatus.Value = BsnStatus(decoder.ReadByte())
9035 return _bsntlvstatus, nil
9036}
9037
9038func NewBsnTlvStatus() *BsnTlvStatus {
9039 obj := &BsnTlvStatus{
9040 BsnTlv: NewBsnTlv(97),
9041 }
9042 return obj
9043}
9044
9045type BsnTlvStripMplsL2OnIngress struct {
9046 *BsnTlv
9047}
9048
9049type IBsnTlvStripMplsL2OnIngress interface {
9050 IBsnTlv
9051}
9052
9053func (self *BsnTlvStripMplsL2OnIngress) Serialize(encoder *goloxi.Encoder) error {
9054 if err := self.BsnTlv.Serialize(encoder); err != nil {
9055 return err
9056 }
9057
9058 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
9059
9060 return nil
9061}
9062
9063func DecodeBsnTlvStripMplsL2OnIngress(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvStripMplsL2OnIngress, error) {
9064 _bsntlvstripmplsl2oningress := &BsnTlvStripMplsL2OnIngress{BsnTlv: parent}
9065 return _bsntlvstripmplsl2oningress, nil
9066}
9067
9068func NewBsnTlvStripMplsL2OnIngress() *BsnTlvStripMplsL2OnIngress {
9069 obj := &BsnTlvStripMplsL2OnIngress{
9070 BsnTlv: NewBsnTlv(75),
9071 }
9072 return obj
9073}
9074
9075type BsnTlvStripMplsL3OnIngress struct {
9076 *BsnTlv
9077}
9078
9079type IBsnTlvStripMplsL3OnIngress interface {
9080 IBsnTlv
9081}
9082
9083func (self *BsnTlvStripMplsL3OnIngress) Serialize(encoder *goloxi.Encoder) error {
9084 if err := self.BsnTlv.Serialize(encoder); err != nil {
9085 return err
9086 }
9087
9088 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
9089
9090 return nil
9091}
9092
9093func DecodeBsnTlvStripMplsL3OnIngress(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvStripMplsL3OnIngress, error) {
9094 _bsntlvstripmplsl3oningress := &BsnTlvStripMplsL3OnIngress{BsnTlv: parent}
9095 return _bsntlvstripmplsl3oningress, nil
9096}
9097
9098func NewBsnTlvStripMplsL3OnIngress() *BsnTlvStripMplsL3OnIngress {
9099 obj := &BsnTlvStripMplsL3OnIngress{
9100 BsnTlv: NewBsnTlv(76),
9101 }
9102 return obj
9103}
9104
9105type BsnTlvStripVlanOnEgress struct {
9106 *BsnTlv
9107 Flags BsnStripVlan
9108}
9109
9110type IBsnTlvStripVlanOnEgress interface {
9111 IBsnTlv
9112 GetFlags() BsnStripVlan
9113}
9114
9115func (self *BsnTlvStripVlanOnEgress) GetFlags() BsnStripVlan {
9116 return self.Flags
9117}
9118
9119func (self *BsnTlvStripVlanOnEgress) SetFlags(v BsnStripVlan) {
9120 self.Flags = v
9121}
9122
9123func (self *BsnTlvStripVlanOnEgress) Serialize(encoder *goloxi.Encoder) error {
9124 if err := self.BsnTlv.Serialize(encoder); err != nil {
9125 return err
9126 }
9127
9128 encoder.PutUint8(uint8(self.Flags))
9129
9130 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
9131
9132 return nil
9133}
9134
9135func DecodeBsnTlvStripVlanOnEgress(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvStripVlanOnEgress, error) {
9136 _bsntlvstripvlanonegress := &BsnTlvStripVlanOnEgress{BsnTlv: parent}
9137 if decoder.Length() < 1 {
9138 return nil, fmt.Errorf("BsnTlvStripVlanOnEgress packet too short: %d < 1", decoder.Length())
9139 }
9140 _bsntlvstripvlanonegress.Flags = BsnStripVlan(decoder.ReadByte())
9141 return _bsntlvstripvlanonegress, nil
9142}
9143
9144func NewBsnTlvStripVlanOnEgress() *BsnTlvStripVlanOnEgress {
9145 obj := &BsnTlvStripVlanOnEgress{
9146 BsnTlv: NewBsnTlv(73),
9147 }
9148 return obj
9149}
9150
9151type BsnTlvSubAgentId struct {
9152 *BsnTlv
9153 Value uint32
9154}
9155
9156type IBsnTlvSubAgentId interface {
9157 IBsnTlv
9158 GetValue() uint32
9159}
9160
9161func (self *BsnTlvSubAgentId) GetValue() uint32 {
9162 return self.Value
9163}
9164
9165func (self *BsnTlvSubAgentId) SetValue(v uint32) {
9166 self.Value = v
9167}
9168
9169func (self *BsnTlvSubAgentId) Serialize(encoder *goloxi.Encoder) error {
9170 if err := self.BsnTlv.Serialize(encoder); err != nil {
9171 return err
9172 }
9173
9174 encoder.PutUint32(uint32(self.Value))
9175
9176 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
9177
9178 return nil
9179}
9180
9181func DecodeBsnTlvSubAgentId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvSubAgentId, error) {
9182 _bsntlvsubagentid := &BsnTlvSubAgentId{BsnTlv: parent}
9183 if decoder.Length() < 4 {
9184 return nil, fmt.Errorf("BsnTlvSubAgentId packet too short: %d < 4", decoder.Length())
9185 }
9186 _bsntlvsubagentid.Value = uint32(decoder.ReadUint32())
9187 return _bsntlvsubagentid, nil
9188}
9189
9190func NewBsnTlvSubAgentId() *BsnTlvSubAgentId {
9191 obj := &BsnTlvSubAgentId{
9192 BsnTlv: NewBsnTlv(38),
9193 }
9194 return obj
9195}
9196
9197type BsnTlvTcpDst struct {
9198 *BsnTlv
9199 Value uint16
9200}
9201
9202type IBsnTlvTcpDst interface {
9203 IBsnTlv
9204 GetValue() uint16
9205}
9206
9207func (self *BsnTlvTcpDst) GetValue() uint16 {
9208 return self.Value
9209}
9210
9211func (self *BsnTlvTcpDst) SetValue(v uint16) {
9212 self.Value = v
9213}
9214
9215func (self *BsnTlvTcpDst) Serialize(encoder *goloxi.Encoder) error {
9216 if err := self.BsnTlv.Serialize(encoder); err != nil {
9217 return err
9218 }
9219
9220 encoder.PutUint16(uint16(self.Value))
9221
9222 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
9223
9224 return nil
9225}
9226
9227func DecodeBsnTlvTcpDst(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTcpDst, error) {
9228 _bsntlvtcpdst := &BsnTlvTcpDst{BsnTlv: parent}
9229 if decoder.Length() < 2 {
9230 return nil, fmt.Errorf("BsnTlvTcpDst packet too short: %d < 2", decoder.Length())
9231 }
9232 _bsntlvtcpdst.Value = uint16(decoder.ReadUint16())
9233 return _bsntlvtcpdst, nil
9234}
9235
9236func NewBsnTlvTcpDst() *BsnTlvTcpDst {
9237 obj := &BsnTlvTcpDst{
9238 BsnTlv: NewBsnTlv(66),
9239 }
9240 return obj
9241}
9242
9243type BsnTlvTcpFlags struct {
9244 *BsnTlv
9245 Value uint16
9246}
9247
9248type IBsnTlvTcpFlags interface {
9249 IBsnTlv
9250 GetValue() uint16
9251}
9252
9253func (self *BsnTlvTcpFlags) GetValue() uint16 {
9254 return self.Value
9255}
9256
9257func (self *BsnTlvTcpFlags) SetValue(v uint16) {
9258 self.Value = v
9259}
9260
9261func (self *BsnTlvTcpFlags) Serialize(encoder *goloxi.Encoder) error {
9262 if err := self.BsnTlv.Serialize(encoder); err != nil {
9263 return err
9264 }
9265
9266 encoder.PutUint16(uint16(self.Value))
9267
9268 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
9269
9270 return nil
9271}
9272
9273func DecodeBsnTlvTcpFlags(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTcpFlags, error) {
9274 _bsntlvtcpflags := &BsnTlvTcpFlags{BsnTlv: parent}
9275 if decoder.Length() < 2 {
9276 return nil, fmt.Errorf("BsnTlvTcpFlags packet too short: %d < 2", decoder.Length())
9277 }
9278 _bsntlvtcpflags.Value = uint16(decoder.ReadUint16())
9279 return _bsntlvtcpflags, nil
9280}
9281
9282func NewBsnTlvTcpFlags() *BsnTlvTcpFlags {
9283 obj := &BsnTlvTcpFlags{
9284 BsnTlv: NewBsnTlv(133),
9285 }
9286 return obj
9287}
9288
9289type BsnTlvTcpSrc struct {
9290 *BsnTlv
9291 Value uint16
9292}
9293
9294type IBsnTlvTcpSrc interface {
9295 IBsnTlv
9296 GetValue() uint16
9297}
9298
9299func (self *BsnTlvTcpSrc) GetValue() uint16 {
9300 return self.Value
9301}
9302
9303func (self *BsnTlvTcpSrc) SetValue(v uint16) {
9304 self.Value = v
9305}
9306
9307func (self *BsnTlvTcpSrc) Serialize(encoder *goloxi.Encoder) error {
9308 if err := self.BsnTlv.Serialize(encoder); err != nil {
9309 return err
9310 }
9311
9312 encoder.PutUint16(uint16(self.Value))
9313
9314 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
9315
9316 return nil
9317}
9318
9319func DecodeBsnTlvTcpSrc(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTcpSrc, error) {
9320 _bsntlvtcpsrc := &BsnTlvTcpSrc{BsnTlv: parent}
9321 if decoder.Length() < 2 {
9322 return nil, fmt.Errorf("BsnTlvTcpSrc packet too short: %d < 2", decoder.Length())
9323 }
9324 _bsntlvtcpsrc.Value = uint16(decoder.ReadUint16())
9325 return _bsntlvtcpsrc, nil
9326}
9327
9328func NewBsnTlvTcpSrc() *BsnTlvTcpSrc {
9329 obj := &BsnTlvTcpSrc{
9330 BsnTlv: NewBsnTlv(65),
9331 }
9332 return obj
9333}
9334
9335type BsnTlvTimestamp struct {
9336 *BsnTlv
9337 Value uint64
9338}
9339
9340type IBsnTlvTimestamp interface {
9341 IBsnTlv
9342 GetValue() uint64
9343}
9344
9345func (self *BsnTlvTimestamp) GetValue() uint64 {
9346 return self.Value
9347}
9348
9349func (self *BsnTlvTimestamp) SetValue(v uint64) {
9350 self.Value = v
9351}
9352
9353func (self *BsnTlvTimestamp) Serialize(encoder *goloxi.Encoder) error {
9354 if err := self.BsnTlv.Serialize(encoder); err != nil {
9355 return err
9356 }
9357
9358 encoder.PutUint64(uint64(self.Value))
9359
9360 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
9361
9362 return nil
9363}
9364
9365func DecodeBsnTlvTimestamp(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTimestamp, error) {
9366 _bsntlvtimestamp := &BsnTlvTimestamp{BsnTlv: parent}
9367 if decoder.Length() < 8 {
9368 return nil, fmt.Errorf("BsnTlvTimestamp packet too short: %d < 8", decoder.Length())
9369 }
9370 _bsntlvtimestamp.Value = uint64(decoder.ReadUint64())
9371 return _bsntlvtimestamp, nil
9372}
9373
9374func NewBsnTlvTimestamp() *BsnTlvTimestamp {
9375 obj := &BsnTlvTimestamp{
9376 BsnTlv: NewBsnTlv(154),
9377 }
9378 return obj
9379}
9380
9381type BsnTlvTtl struct {
9382 *BsnTlv
9383 Value uint16
9384}
9385
9386type IBsnTlvTtl interface {
9387 IBsnTlv
9388 GetValue() uint16
9389}
9390
9391func (self *BsnTlvTtl) GetValue() uint16 {
9392 return self.Value
9393}
9394
9395func (self *BsnTlvTtl) SetValue(v uint16) {
9396 self.Value = v
9397}
9398
9399func (self *BsnTlvTtl) Serialize(encoder *goloxi.Encoder) error {
9400 if err := self.BsnTlv.Serialize(encoder); err != nil {
9401 return err
9402 }
9403
9404 encoder.PutUint16(uint16(self.Value))
9405
9406 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
9407
9408 return nil
9409}
9410
9411func DecodeBsnTlvTtl(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTtl, error) {
9412 _bsntlvttl := &BsnTlvTtl{BsnTlv: parent}
9413 if decoder.Length() < 2 {
9414 return nil, fmt.Errorf("BsnTlvTtl packet too short: %d < 2", decoder.Length())
9415 }
9416 _bsntlvttl.Value = uint16(decoder.ReadUint16())
9417 return _bsntlvttl, nil
9418}
9419
9420func NewBsnTlvTtl() *BsnTlvTtl {
9421 obj := &BsnTlvTtl{
9422 BsnTlv: NewBsnTlv(113),
9423 }
9424 return obj
9425}
9426
9427type BsnTlvTunnelCapability struct {
9428 *BsnTlv
9429 Value BsnTunnelType
9430}
9431
9432type IBsnTlvTunnelCapability interface {
9433 IBsnTlv
9434 GetValue() BsnTunnelType
9435}
9436
9437func (self *BsnTlvTunnelCapability) GetValue() BsnTunnelType {
9438 return self.Value
9439}
9440
9441func (self *BsnTlvTunnelCapability) SetValue(v BsnTunnelType) {
9442 self.Value = v
9443}
9444
9445func (self *BsnTlvTunnelCapability) Serialize(encoder *goloxi.Encoder) error {
9446 if err := self.BsnTlv.Serialize(encoder); err != nil {
9447 return err
9448 }
9449
9450 encoder.PutUint64(uint64(self.Value))
9451
9452 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
9453
9454 return nil
9455}
9456
9457func DecodeBsnTlvTunnelCapability(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTunnelCapability, error) {
9458 _bsntlvtunnelcapability := &BsnTlvTunnelCapability{BsnTlv: parent}
9459 if decoder.Length() < 8 {
9460 return nil, fmt.Errorf("BsnTlvTunnelCapability packet too short: %d < 8", decoder.Length())
9461 }
9462 _bsntlvtunnelcapability.Value = BsnTunnelType(decoder.ReadUint64())
9463 return _bsntlvtunnelcapability, nil
9464}
9465
9466func NewBsnTlvTunnelCapability() *BsnTlvTunnelCapability {
9467 obj := &BsnTlvTunnelCapability{
9468 BsnTlv: NewBsnTlv(142),
9469 }
9470 return obj
9471}
9472
9473type BsnTlvTxBytes struct {
9474 *BsnTlv
9475 Value uint64
9476}
9477
9478type IBsnTlvTxBytes interface {
9479 IBsnTlv
9480 GetValue() uint64
9481}
9482
9483func (self *BsnTlvTxBytes) GetValue() uint64 {
9484 return self.Value
9485}
9486
9487func (self *BsnTlvTxBytes) SetValue(v uint64) {
9488 self.Value = v
9489}
9490
9491func (self *BsnTlvTxBytes) Serialize(encoder *goloxi.Encoder) error {
9492 if err := self.BsnTlv.Serialize(encoder); err != nil {
9493 return err
9494 }
9495
9496 encoder.PutUint64(uint64(self.Value))
9497
9498 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
9499
9500 return nil
9501}
9502
9503func DecodeBsnTlvTxBytes(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTxBytes, error) {
9504 _bsntlvtxbytes := &BsnTlvTxBytes{BsnTlv: parent}
9505 if decoder.Length() < 8 {
9506 return nil, fmt.Errorf("BsnTlvTxBytes packet too short: %d < 8", decoder.Length())
9507 }
9508 _bsntlvtxbytes.Value = uint64(decoder.ReadUint64())
9509 return _bsntlvtxbytes, nil
9510}
9511
9512func NewBsnTlvTxBytes() *BsnTlvTxBytes {
9513 obj := &BsnTlvTxBytes{
9514 BsnTlv: NewBsnTlv(39),
9515 }
9516 return obj
9517}
9518
9519type BsnTlvTxPackets struct {
9520 *BsnTlv
9521 Value uint64
9522}
9523
9524type IBsnTlvTxPackets interface {
9525 IBsnTlv
9526 GetValue() uint64
9527}
9528
9529func (self *BsnTlvTxPackets) GetValue() uint64 {
9530 return self.Value
9531}
9532
9533func (self *BsnTlvTxPackets) SetValue(v uint64) {
9534 self.Value = v
9535}
9536
9537func (self *BsnTlvTxPackets) Serialize(encoder *goloxi.Encoder) error {
9538 if err := self.BsnTlv.Serialize(encoder); err != nil {
9539 return err
9540 }
9541
9542 encoder.PutUint64(uint64(self.Value))
9543
9544 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
9545
9546 return nil
9547}
9548
9549func DecodeBsnTlvTxPackets(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTxPackets, error) {
9550 _bsntlvtxpackets := &BsnTlvTxPackets{BsnTlv: parent}
9551 if decoder.Length() < 8 {
9552 return nil, fmt.Errorf("BsnTlvTxPackets packet too short: %d < 8", decoder.Length())
9553 }
9554 _bsntlvtxpackets.Value = uint64(decoder.ReadUint64())
9555 return _bsntlvtxpackets, nil
9556}
9557
9558func NewBsnTlvTxPackets() *BsnTlvTxPackets {
9559 obj := &BsnTlvTxPackets{
9560 BsnTlv: NewBsnTlv(3),
9561 }
9562 return obj
9563}
9564
9565type BsnTlvUdfAnchor struct {
9566 *BsnTlv
9567 Value BsnUdfAnchor
9568}
9569
9570type IBsnTlvUdfAnchor interface {
9571 IBsnTlv
9572 GetValue() BsnUdfAnchor
9573}
9574
9575func (self *BsnTlvUdfAnchor) GetValue() BsnUdfAnchor {
9576 return self.Value
9577}
9578
9579func (self *BsnTlvUdfAnchor) SetValue(v BsnUdfAnchor) {
9580 self.Value = v
9581}
9582
9583func (self *BsnTlvUdfAnchor) Serialize(encoder *goloxi.Encoder) error {
9584 if err := self.BsnTlv.Serialize(encoder); err != nil {
9585 return err
9586 }
9587
9588 encoder.PutUint16(uint16(self.Value))
9589
9590 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
9591
9592 return nil
9593}
9594
9595func DecodeBsnTlvUdfAnchor(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUdfAnchor, error) {
9596 _bsntlvudfanchor := &BsnTlvUdfAnchor{BsnTlv: parent}
9597 if decoder.Length() < 2 {
9598 return nil, fmt.Errorf("BsnTlvUdfAnchor packet too short: %d < 2", decoder.Length())
9599 }
9600 _bsntlvudfanchor.Value = BsnUdfAnchor(decoder.ReadUint16())
9601 return _bsntlvudfanchor, nil
9602}
9603
9604func NewBsnTlvUdfAnchor() *BsnTlvUdfAnchor {
9605 obj := &BsnTlvUdfAnchor{
9606 BsnTlv: NewBsnTlv(16),
9607 }
9608 return obj
9609}
9610
9611type BsnTlvUdfCapability struct {
9612 *BsnTlv
9613 Value BsnUdfMode
9614}
9615
9616type IBsnTlvUdfCapability interface {
9617 IBsnTlv
9618 GetValue() BsnUdfMode
9619}
9620
9621func (self *BsnTlvUdfCapability) GetValue() BsnUdfMode {
9622 return self.Value
9623}
9624
9625func (self *BsnTlvUdfCapability) SetValue(v BsnUdfMode) {
9626 self.Value = v
9627}
9628
9629func (self *BsnTlvUdfCapability) Serialize(encoder *goloxi.Encoder) error {
9630 if err := self.BsnTlv.Serialize(encoder); err != nil {
9631 return err
9632 }
9633
9634 encoder.PutUint8(uint8(self.Value))
9635
9636 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
9637
9638 return nil
9639}
9640
9641func DecodeBsnTlvUdfCapability(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUdfCapability, error) {
9642 _bsntlvudfcapability := &BsnTlvUdfCapability{BsnTlv: parent}
9643 if decoder.Length() < 1 {
9644 return nil, fmt.Errorf("BsnTlvUdfCapability packet too short: %d < 1", decoder.Length())
9645 }
9646 _bsntlvudfcapability.Value = BsnUdfMode(decoder.ReadByte())
9647 return _bsntlvudfcapability, nil
9648}
9649
9650func NewBsnTlvUdfCapability() *BsnTlvUdfCapability {
9651 obj := &BsnTlvUdfCapability{
9652 BsnTlv: NewBsnTlv(180),
9653 }
9654 return obj
9655}
9656
9657type BsnTlvUdfId struct {
9658 *BsnTlv
9659 Value uint16
9660}
9661
9662type IBsnTlvUdfId interface {
9663 IBsnTlv
9664 GetValue() uint16
9665}
9666
9667func (self *BsnTlvUdfId) GetValue() uint16 {
9668 return self.Value
9669}
9670
9671func (self *BsnTlvUdfId) SetValue(v uint16) {
9672 self.Value = v
9673}
9674
9675func (self *BsnTlvUdfId) Serialize(encoder *goloxi.Encoder) error {
9676 if err := self.BsnTlv.Serialize(encoder); err != nil {
9677 return err
9678 }
9679
9680 encoder.PutUint16(uint16(self.Value))
9681
9682 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
9683
9684 return nil
9685}
9686
9687func DecodeBsnTlvUdfId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUdfId, error) {
9688 _bsntlvudfid := &BsnTlvUdfId{BsnTlv: parent}
9689 if decoder.Length() < 2 {
9690 return nil, fmt.Errorf("BsnTlvUdfId packet too short: %d < 2", decoder.Length())
9691 }
9692 _bsntlvudfid.Value = uint16(decoder.ReadUint16())
9693 return _bsntlvudfid, nil
9694}
9695
9696func NewBsnTlvUdfId() *BsnTlvUdfId {
9697 obj := &BsnTlvUdfId{
9698 BsnTlv: NewBsnTlv(15),
9699 }
9700 return obj
9701}
9702
9703type BsnTlvUdfLength struct {
9704 *BsnTlv
9705 Value uint16
9706}
9707
9708type IBsnTlvUdfLength interface {
9709 IBsnTlv
9710 GetValue() uint16
9711}
9712
9713func (self *BsnTlvUdfLength) GetValue() uint16 {
9714 return self.Value
9715}
9716
9717func (self *BsnTlvUdfLength) SetValue(v uint16) {
9718 self.Value = v
9719}
9720
9721func (self *BsnTlvUdfLength) Serialize(encoder *goloxi.Encoder) error {
9722 if err := self.BsnTlv.Serialize(encoder); err != nil {
9723 return err
9724 }
9725
9726 encoder.PutUint16(uint16(self.Value))
9727
9728 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
9729
9730 return nil
9731}
9732
9733func DecodeBsnTlvUdfLength(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUdfLength, error) {
9734 _bsntlvudflength := &BsnTlvUdfLength{BsnTlv: parent}
9735 if decoder.Length() < 2 {
9736 return nil, fmt.Errorf("BsnTlvUdfLength packet too short: %d < 2", decoder.Length())
9737 }
9738 _bsntlvudflength.Value = uint16(decoder.ReadUint16())
9739 return _bsntlvudflength, nil
9740}
9741
9742func NewBsnTlvUdfLength() *BsnTlvUdfLength {
9743 obj := &BsnTlvUdfLength{
9744 BsnTlv: NewBsnTlv(18),
9745 }
9746 return obj
9747}
9748
9749type BsnTlvUdfOffset struct {
9750 *BsnTlv
9751 Value uint16
9752}
9753
9754type IBsnTlvUdfOffset interface {
9755 IBsnTlv
9756 GetValue() uint16
9757}
9758
9759func (self *BsnTlvUdfOffset) GetValue() uint16 {
9760 return self.Value
9761}
9762
9763func (self *BsnTlvUdfOffset) SetValue(v uint16) {
9764 self.Value = v
9765}
9766
9767func (self *BsnTlvUdfOffset) Serialize(encoder *goloxi.Encoder) error {
9768 if err := self.BsnTlv.Serialize(encoder); err != nil {
9769 return err
9770 }
9771
9772 encoder.PutUint16(uint16(self.Value))
9773
9774 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
9775
9776 return nil
9777}
9778
9779func DecodeBsnTlvUdfOffset(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUdfOffset, error) {
9780 _bsntlvudfoffset := &BsnTlvUdfOffset{BsnTlv: parent}
9781 if decoder.Length() < 2 {
9782 return nil, fmt.Errorf("BsnTlvUdfOffset packet too short: %d < 2", decoder.Length())
9783 }
9784 _bsntlvudfoffset.Value = uint16(decoder.ReadUint16())
9785 return _bsntlvudfoffset, nil
9786}
9787
9788func NewBsnTlvUdfOffset() *BsnTlvUdfOffset {
9789 obj := &BsnTlvUdfOffset{
9790 BsnTlv: NewBsnTlv(17),
9791 }
9792 return obj
9793}
9794
9795type BsnTlvUdpDst struct {
9796 *BsnTlv
9797 Value uint16
9798}
9799
9800type IBsnTlvUdpDst interface {
9801 IBsnTlv
9802 GetValue() uint16
9803}
9804
9805func (self *BsnTlvUdpDst) GetValue() uint16 {
9806 return self.Value
9807}
9808
9809func (self *BsnTlvUdpDst) SetValue(v uint16) {
9810 self.Value = v
9811}
9812
9813func (self *BsnTlvUdpDst) Serialize(encoder *goloxi.Encoder) error {
9814 if err := self.BsnTlv.Serialize(encoder); err != nil {
9815 return err
9816 }
9817
9818 encoder.PutUint16(uint16(self.Value))
9819
9820 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
9821
9822 return nil
9823}
9824
9825func DecodeBsnTlvUdpDst(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUdpDst, error) {
9826 _bsntlvudpdst := &BsnTlvUdpDst{BsnTlv: parent}
9827 if decoder.Length() < 2 {
9828 return nil, fmt.Errorf("BsnTlvUdpDst packet too short: %d < 2", decoder.Length())
9829 }
9830 _bsntlvudpdst.Value = uint16(decoder.ReadUint16())
9831 return _bsntlvudpdst, nil
9832}
9833
9834func NewBsnTlvUdpDst() *BsnTlvUdpDst {
9835 obj := &BsnTlvUdpDst{
9836 BsnTlv: NewBsnTlv(37),
9837 }
9838 return obj
9839}
9840
9841type BsnTlvUdpSrc struct {
9842 *BsnTlv
9843 Value uint16
9844}
9845
9846type IBsnTlvUdpSrc interface {
9847 IBsnTlv
9848 GetValue() uint16
9849}
9850
9851func (self *BsnTlvUdpSrc) GetValue() uint16 {
9852 return self.Value
9853}
9854
9855func (self *BsnTlvUdpSrc) SetValue(v uint16) {
9856 self.Value = v
9857}
9858
9859func (self *BsnTlvUdpSrc) Serialize(encoder *goloxi.Encoder) error {
9860 if err := self.BsnTlv.Serialize(encoder); err != nil {
9861 return err
9862 }
9863
9864 encoder.PutUint16(uint16(self.Value))
9865
9866 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
9867
9868 return nil
9869}
9870
9871func DecodeBsnTlvUdpSrc(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUdpSrc, error) {
9872 _bsntlvudpsrc := &BsnTlvUdpSrc{BsnTlv: parent}
9873 if decoder.Length() < 2 {
9874 return nil, fmt.Errorf("BsnTlvUdpSrc packet too short: %d < 2", decoder.Length())
9875 }
9876 _bsntlvudpsrc.Value = uint16(decoder.ReadUint16())
9877 return _bsntlvudpsrc, nil
9878}
9879
9880func NewBsnTlvUdpSrc() *BsnTlvUdpSrc {
9881 obj := &BsnTlvUdpSrc{
9882 BsnTlv: NewBsnTlv(36),
9883 }
9884 return obj
9885}
9886
9887type BsnTlvUint32 struct {
9888 *BsnTlv
9889 Value uint32
9890}
9891
9892type IBsnTlvUint32 interface {
9893 IBsnTlv
9894 GetValue() uint32
9895}
9896
9897func (self *BsnTlvUint32) GetValue() uint32 {
9898 return self.Value
9899}
9900
9901func (self *BsnTlvUint32) SetValue(v uint32) {
9902 self.Value = v
9903}
9904
9905func (self *BsnTlvUint32) Serialize(encoder *goloxi.Encoder) error {
9906 if err := self.BsnTlv.Serialize(encoder); err != nil {
9907 return err
9908 }
9909
9910 encoder.PutUint32(uint32(self.Value))
9911
9912 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
9913
9914 return nil
9915}
9916
9917func DecodeBsnTlvUint32(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUint32, error) {
9918 _bsntlvuint32 := &BsnTlvUint32{BsnTlv: parent}
9919 if decoder.Length() < 4 {
9920 return nil, fmt.Errorf("BsnTlvUint32 packet too short: %d < 4", decoder.Length())
9921 }
9922 _bsntlvuint32.Value = uint32(decoder.ReadUint32())
9923 return _bsntlvuint32, nil
9924}
9925
9926func NewBsnTlvUint32() *BsnTlvUint32 {
9927 obj := &BsnTlvUint32{
9928 BsnTlv: NewBsnTlv(167),
9929 }
9930 return obj
9931}
9932
9933type BsnTlvUint64List struct {
9934 *BsnTlv
9935 Value []*Uint64
9936}
9937
9938type IBsnTlvUint64List interface {
9939 IBsnTlv
9940 GetValue() []*Uint64
9941}
9942
9943func (self *BsnTlvUint64List) GetValue() []*Uint64 {
9944 return self.Value
9945}
9946
9947func (self *BsnTlvUint64List) SetValue(v []*Uint64) {
9948 self.Value = v
9949}
9950
9951func (self *BsnTlvUint64List) Serialize(encoder *goloxi.Encoder) error {
9952 if err := self.BsnTlv.Serialize(encoder); err != nil {
9953 return err
9954 }
9955
9956 for _, obj := range self.Value {
9957 if err := obj.Serialize(encoder); err != nil {
9958 return err
9959 }
9960 }
9961
9962 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
9963
9964 return nil
9965}
9966
9967func DecodeBsnTlvUint64List(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUint64List, error) {
9968 _bsntlvuint64list := &BsnTlvUint64List{BsnTlv: parent}
9969
9970 for decoder.Length() >= 8 {
9971 item, err := DecodeUint64(decoder)
9972 if err != nil {
9973 return nil, err
9974 }
9975 if item != nil {
9976 _bsntlvuint64list.Value = append(_bsntlvuint64list.Value, item)
9977 }
9978 }
9979 return _bsntlvuint64list, nil
9980}
9981
9982func NewBsnTlvUint64List() *BsnTlvUint64List {
9983 obj := &BsnTlvUint64List{
9984 BsnTlv: NewBsnTlv(119),
9985 }
9986 return obj
9987}
9988
9989type BsnTlvUnicastQueryTimeout struct {
9990 *BsnTlv
9991 Value uint32
9992}
9993
9994type IBsnTlvUnicastQueryTimeout interface {
9995 IBsnTlv
9996 GetValue() uint32
9997}
9998
9999func (self *BsnTlvUnicastQueryTimeout) GetValue() uint32 {
10000 return self.Value
10001}
10002
10003func (self *BsnTlvUnicastQueryTimeout) SetValue(v uint32) {
10004 self.Value = v
10005}
10006
10007func (self *BsnTlvUnicastQueryTimeout) Serialize(encoder *goloxi.Encoder) error {
10008 if err := self.BsnTlv.Serialize(encoder); err != nil {
10009 return err
10010 }
10011
10012 encoder.PutUint32(uint32(self.Value))
10013
10014 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
10015
10016 return nil
10017}
10018
10019func DecodeBsnTlvUnicastQueryTimeout(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUnicastQueryTimeout, error) {
10020 _bsntlvunicastquerytimeout := &BsnTlvUnicastQueryTimeout{BsnTlv: parent}
10021 if decoder.Length() < 4 {
10022 return nil, fmt.Errorf("BsnTlvUnicastQueryTimeout packet too short: %d < 4", decoder.Length())
10023 }
10024 _bsntlvunicastquerytimeout.Value = uint32(decoder.ReadUint32())
10025 return _bsntlvunicastquerytimeout, nil
10026}
10027
10028func NewBsnTlvUnicastQueryTimeout() *BsnTlvUnicastQueryTimeout {
10029 obj := &BsnTlvUnicastQueryTimeout{
10030 BsnTlv: NewBsnTlv(9),
10031 }
10032 return obj
10033}
10034
10035type BsnTlvUnicastRate struct {
10036 *BsnTlv
10037 Value uint32
10038}
10039
10040type IBsnTlvUnicastRate interface {
10041 IBsnTlv
10042 GetValue() uint32
10043}
10044
10045func (self *BsnTlvUnicastRate) GetValue() uint32 {
10046 return self.Value
10047}
10048
10049func (self *BsnTlvUnicastRate) SetValue(v uint32) {
10050 self.Value = v
10051}
10052
10053func (self *BsnTlvUnicastRate) Serialize(encoder *goloxi.Encoder) error {
10054 if err := self.BsnTlv.Serialize(encoder); err != nil {
10055 return err
10056 }
10057
10058 encoder.PutUint32(uint32(self.Value))
10059
10060 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
10061
10062 return nil
10063}
10064
10065func DecodeBsnTlvUnicastRate(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUnicastRate, error) {
10066 _bsntlvunicastrate := &BsnTlvUnicastRate{BsnTlv: parent}
10067 if decoder.Length() < 4 {
10068 return nil, fmt.Errorf("BsnTlvUnicastRate packet too short: %d < 4", decoder.Length())
10069 }
10070 _bsntlvunicastrate.Value = uint32(decoder.ReadUint32())
10071 return _bsntlvunicastrate, nil
10072}
10073
10074func NewBsnTlvUnicastRate() *BsnTlvUnicastRate {
10075 obj := &BsnTlvUnicastRate{
10076 BsnTlv: NewBsnTlv(93),
10077 }
10078 return obj
10079}
10080
10081type BsnTlvUnknownMulticastRate struct {
10082 *BsnTlv
10083 Value uint32
10084}
10085
10086type IBsnTlvUnknownMulticastRate interface {
10087 IBsnTlv
10088 GetValue() uint32
10089}
10090
10091func (self *BsnTlvUnknownMulticastRate) GetValue() uint32 {
10092 return self.Value
10093}
10094
10095func (self *BsnTlvUnknownMulticastRate) SetValue(v uint32) {
10096 self.Value = v
10097}
10098
10099func (self *BsnTlvUnknownMulticastRate) Serialize(encoder *goloxi.Encoder) error {
10100 if err := self.BsnTlv.Serialize(encoder); err != nil {
10101 return err
10102 }
10103
10104 encoder.PutUint32(uint32(self.Value))
10105
10106 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
10107
10108 return nil
10109}
10110
10111func DecodeBsnTlvUnknownMulticastRate(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUnknownMulticastRate, error) {
10112 _bsntlvunknownmulticastrate := &BsnTlvUnknownMulticastRate{BsnTlv: parent}
10113 if decoder.Length() < 4 {
10114 return nil, fmt.Errorf("BsnTlvUnknownMulticastRate packet too short: %d < 4", decoder.Length())
10115 }
10116 _bsntlvunknownmulticastrate.Value = uint32(decoder.ReadUint32())
10117 return _bsntlvunknownmulticastrate, nil
10118}
10119
10120func NewBsnTlvUnknownMulticastRate() *BsnTlvUnknownMulticastRate {
10121 obj := &BsnTlvUnknownMulticastRate{
10122 BsnTlv: NewBsnTlv(92),
10123 }
10124 return obj
10125}
10126
10127type BsnTlvUntagged struct {
10128 *BsnTlv
10129}
10130
10131type IBsnTlvUntagged interface {
10132 IBsnTlv
10133}
10134
10135func (self *BsnTlvUntagged) Serialize(encoder *goloxi.Encoder) error {
10136 if err := self.BsnTlv.Serialize(encoder); err != nil {
10137 return err
10138 }
10139
10140 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
10141
10142 return nil
10143}
10144
10145func DecodeBsnTlvUntagged(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUntagged, error) {
10146 _bsntlvuntagged := &BsnTlvUntagged{BsnTlv: parent}
10147 return _bsntlvuntagged, nil
10148}
10149
10150func NewBsnTlvUntagged() *BsnTlvUntagged {
10151 obj := &BsnTlvUntagged{
10152 BsnTlv: NewBsnTlv(106),
10153 }
10154 return obj
10155}
10156
10157type BsnTlvUpgrade struct {
10158 *BsnTlv
10159 Value BsnUpgrade
10160}
10161
10162type IBsnTlvUpgrade interface {
10163 IBsnTlv
10164 GetValue() BsnUpgrade
10165}
10166
10167func (self *BsnTlvUpgrade) GetValue() BsnUpgrade {
10168 return self.Value
10169}
10170
10171func (self *BsnTlvUpgrade) SetValue(v BsnUpgrade) {
10172 self.Value = v
10173}
10174
10175func (self *BsnTlvUpgrade) Serialize(encoder *goloxi.Encoder) error {
10176 if err := self.BsnTlv.Serialize(encoder); err != nil {
10177 return err
10178 }
10179
10180 encoder.PutUint16(uint16(self.Value))
10181
10182 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
10183
10184 return nil
10185}
10186
10187func DecodeBsnTlvUpgrade(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUpgrade, error) {
10188 _bsntlvupgrade := &BsnTlvUpgrade{BsnTlv: parent}
10189 if decoder.Length() < 2 {
10190 return nil, fmt.Errorf("BsnTlvUpgrade packet too short: %d < 2", decoder.Length())
10191 }
10192 _bsntlvupgrade.Value = BsnUpgrade(decoder.ReadUint16())
10193 return _bsntlvupgrade, nil
10194}
10195
10196func NewBsnTlvUpgrade() *BsnTlvUpgrade {
10197 obj := &BsnTlvUpgrade{
10198 BsnTlv: NewBsnTlv(164),
10199 }
10200 return obj
10201}
10202
10203type BsnTlvUriScheme struct {
10204 *BsnTlv
10205 Value []byte
10206}
10207
10208type IBsnTlvUriScheme interface {
10209 IBsnTlv
10210 GetValue() []byte
10211}
10212
10213func (self *BsnTlvUriScheme) GetValue() []byte {
10214 return self.Value
10215}
10216
10217func (self *BsnTlvUriScheme) SetValue(v []byte) {
10218 self.Value = v
10219}
10220
10221func (self *BsnTlvUriScheme) Serialize(encoder *goloxi.Encoder) error {
10222 if err := self.BsnTlv.Serialize(encoder); err != nil {
10223 return err
10224 }
10225
10226 encoder.Write(self.Value)
10227
10228 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
10229
10230 return nil
10231}
10232
10233func DecodeBsnTlvUriScheme(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUriScheme, error) {
10234 _bsntlvurischeme := &BsnTlvUriScheme{BsnTlv: parent}
10235 _bsntlvurischeme.Value = decoder.Read(int(decoder.Length()))
10236 return _bsntlvurischeme, nil
10237}
10238
10239func NewBsnTlvUriScheme() *BsnTlvUriScheme {
10240 obj := &BsnTlvUriScheme{
10241 BsnTlv: NewBsnTlv(153),
10242 }
10243 return obj
10244}
10245
10246type BsnTlvUsePacketState struct {
10247 *BsnTlv
10248 Value uint8
10249}
10250
10251type IBsnTlvUsePacketState interface {
10252 IBsnTlv
10253 GetValue() uint8
10254}
10255
10256func (self *BsnTlvUsePacketState) GetValue() uint8 {
10257 return self.Value
10258}
10259
10260func (self *BsnTlvUsePacketState) SetValue(v uint8) {
10261 self.Value = v
10262}
10263
10264func (self *BsnTlvUsePacketState) Serialize(encoder *goloxi.Encoder) error {
10265 if err := self.BsnTlv.Serialize(encoder); err != nil {
10266 return err
10267 }
10268
10269 encoder.PutUint8(uint8(self.Value))
10270
10271 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
10272
10273 return nil
10274}
10275
10276func DecodeBsnTlvUsePacketState(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUsePacketState, error) {
10277 _bsntlvusepacketstate := &BsnTlvUsePacketState{BsnTlv: parent}
10278 if decoder.Length() < 1 {
10279 return nil, fmt.Errorf("BsnTlvUsePacketState packet too short: %d < 1", decoder.Length())
10280 }
10281 _bsntlvusepacketstate.Value = uint8(decoder.ReadByte())
10282 return _bsntlvusepacketstate, nil
10283}
10284
10285func NewBsnTlvUsePacketState() *BsnTlvUsePacketState {
10286 obj := &BsnTlvUsePacketState{
10287 BsnTlv: NewBsnTlv(96),
10288 }
10289 return obj
10290}
10291
10292type BsnTlvUserConfigured struct {
10293 *BsnTlv
10294}
10295
10296type IBsnTlvUserConfigured interface {
10297 IBsnTlv
10298}
10299
10300func (self *BsnTlvUserConfigured) Serialize(encoder *goloxi.Encoder) error {
10301 if err := self.BsnTlv.Serialize(encoder); err != nil {
10302 return err
10303 }
10304
10305 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
10306
10307 return nil
10308}
10309
10310func DecodeBsnTlvUserConfigured(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUserConfigured, error) {
10311 _bsntlvuserconfigured := &BsnTlvUserConfigured{BsnTlv: parent}
10312 return _bsntlvuserconfigured, nil
10313}
10314
10315func NewBsnTlvUserConfigured() *BsnTlvUserConfigured {
10316 obj := &BsnTlvUserConfigured{
10317 BsnTlv: NewBsnTlv(166),
10318 }
10319 return obj
10320}
10321
10322type BsnTlvVfi struct {
10323 *BsnTlv
10324 Value uint16
10325}
10326
10327type IBsnTlvVfi interface {
10328 IBsnTlv
10329 GetValue() uint16
10330}
10331
10332func (self *BsnTlvVfi) GetValue() uint16 {
10333 return self.Value
10334}
10335
10336func (self *BsnTlvVfi) SetValue(v uint16) {
10337 self.Value = v
10338}
10339
10340func (self *BsnTlvVfi) Serialize(encoder *goloxi.Encoder) error {
10341 if err := self.BsnTlv.Serialize(encoder); err != nil {
10342 return err
10343 }
10344
10345 encoder.PutUint16(uint16(self.Value))
10346
10347 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
10348
10349 return nil
10350}
10351
10352func DecodeBsnTlvVfi(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVfi, error) {
10353 _bsntlvvfi := &BsnTlvVfi{BsnTlv: parent}
10354 if decoder.Length() < 2 {
10355 return nil, fmt.Errorf("BsnTlvVfi packet too short: %d < 2", decoder.Length())
10356 }
10357 _bsntlvvfi.Value = uint16(decoder.ReadUint16())
10358 return _bsntlvvfi, nil
10359}
10360
10361func NewBsnTlvVfi() *BsnTlvVfi {
10362 obj := &BsnTlvVfi{
10363 BsnTlv: NewBsnTlv(99),
10364 }
10365 return obj
10366}
10367
10368type BsnTlvVfpClassId struct {
10369 *BsnTlv
10370 Value uint32
10371}
10372
10373type IBsnTlvVfpClassId interface {
10374 IBsnTlv
10375 GetValue() uint32
10376}
10377
10378func (self *BsnTlvVfpClassId) GetValue() uint32 {
10379 return self.Value
10380}
10381
10382func (self *BsnTlvVfpClassId) SetValue(v uint32) {
10383 self.Value = v
10384}
10385
10386func (self *BsnTlvVfpClassId) Serialize(encoder *goloxi.Encoder) error {
10387 if err := self.BsnTlv.Serialize(encoder); err != nil {
10388 return err
10389 }
10390
10391 encoder.PutUint32(uint32(self.Value))
10392
10393 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
10394
10395 return nil
10396}
10397
10398func DecodeBsnTlvVfpClassId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVfpClassId, error) {
10399 _bsntlvvfpclassid := &BsnTlvVfpClassId{BsnTlv: parent}
10400 if decoder.Length() < 4 {
10401 return nil, fmt.Errorf("BsnTlvVfpClassId packet too short: %d < 4", decoder.Length())
10402 }
10403 _bsntlvvfpclassid.Value = uint32(decoder.ReadUint32())
10404 return _bsntlvvfpclassid, nil
10405}
10406
10407func NewBsnTlvVfpClassId() *BsnTlvVfpClassId {
10408 obj := &BsnTlvVfpClassId{
10409 BsnTlv: NewBsnTlv(107),
10410 }
10411 return obj
10412}
10413
10414type BsnTlvVirtual struct {
10415 *BsnTlv
10416}
10417
10418type IBsnTlvVirtual interface {
10419 IBsnTlv
10420}
10421
10422func (self *BsnTlvVirtual) Serialize(encoder *goloxi.Encoder) error {
10423 if err := self.BsnTlv.Serialize(encoder); err != nil {
10424 return err
10425 }
10426
10427 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
10428
10429 return nil
10430}
10431
10432func DecodeBsnTlvVirtual(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVirtual, error) {
10433 _bsntlvvirtual := &BsnTlvVirtual{BsnTlv: parent}
10434 return _bsntlvvirtual, nil
10435}
10436
10437func NewBsnTlvVirtual() *BsnTlvVirtual {
10438 obj := &BsnTlvVirtual{
10439 BsnTlv: NewBsnTlv(158),
10440 }
10441 return obj
10442}
10443
10444type BsnTlvVlanMacList struct {
10445 *BsnTlv
10446 Key []*BsnVlanMac
10447}
10448
10449type IBsnTlvVlanMacList interface {
10450 IBsnTlv
10451 GetKey() []*BsnVlanMac
10452}
10453
10454func (self *BsnTlvVlanMacList) GetKey() []*BsnVlanMac {
10455 return self.Key
10456}
10457
10458func (self *BsnTlvVlanMacList) SetKey(v []*BsnVlanMac) {
10459 self.Key = v
10460}
10461
10462func (self *BsnTlvVlanMacList) Serialize(encoder *goloxi.Encoder) error {
10463 if err := self.BsnTlv.Serialize(encoder); err != nil {
10464 return err
10465 }
10466
10467 for _, obj := range self.Key {
10468 if err := obj.Serialize(encoder); err != nil {
10469 return err
10470 }
10471 }
10472
10473 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
10474
10475 return nil
10476}
10477
10478func DecodeBsnTlvVlanMacList(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVlanMacList, error) {
10479 _bsntlvvlanmaclist := &BsnTlvVlanMacList{BsnTlv: parent}
10480
10481 for decoder.Length() >= 8 {
10482 item, err := DecodeBsnVlanMac(decoder)
10483 if err != nil {
10484 return nil, err
10485 }
10486 if item != nil {
10487 _bsntlvvlanmaclist.Key = append(_bsntlvvlanmaclist.Key, item)
10488 }
10489 }
10490 return _bsntlvvlanmaclist, nil
10491}
10492
10493func NewBsnTlvVlanMacList() *BsnTlvVlanMacList {
10494 obj := &BsnTlvVlanMacList{
10495 BsnTlv: NewBsnTlv(98),
10496 }
10497 return obj
10498}
10499
10500type BsnTlvVlanPcp struct {
10501 *BsnTlv
10502 Value uint8
10503}
10504
10505type IBsnTlvVlanPcp interface {
10506 IBsnTlv
10507 GetValue() uint8
10508}
10509
10510func (self *BsnTlvVlanPcp) GetValue() uint8 {
10511 return self.Value
10512}
10513
10514func (self *BsnTlvVlanPcp) SetValue(v uint8) {
10515 self.Value = v
10516}
10517
10518func (self *BsnTlvVlanPcp) Serialize(encoder *goloxi.Encoder) error {
10519 if err := self.BsnTlv.Serialize(encoder); err != nil {
10520 return err
10521 }
10522
10523 encoder.PutUint8(uint8(self.Value))
10524
10525 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
10526
10527 return nil
10528}
10529
10530func DecodeBsnTlvVlanPcp(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVlanPcp, error) {
10531 _bsntlvvlanpcp := &BsnTlvVlanPcp{BsnTlv: parent}
10532 if decoder.Length() < 1 {
10533 return nil, fmt.Errorf("BsnTlvVlanPcp packet too short: %d < 1", decoder.Length())
10534 }
10535 _bsntlvvlanpcp.Value = uint8(decoder.ReadByte())
10536 return _bsntlvvlanpcp, nil
10537}
10538
10539func NewBsnTlvVlanPcp() *BsnTlvVlanPcp {
10540 obj := &BsnTlvVlanPcp{
10541 BsnTlv: NewBsnTlv(72),
10542 }
10543 return obj
10544}
10545
10546type BsnTlvVlanVid struct {
10547 *BsnTlv
10548 Value uint16
10549}
10550
10551type IBsnTlvVlanVid interface {
10552 IBsnTlv
10553 GetValue() uint16
10554}
10555
10556func (self *BsnTlvVlanVid) GetValue() uint16 {
10557 return self.Value
10558}
10559
10560func (self *BsnTlvVlanVid) SetValue(v uint16) {
10561 self.Value = v
10562}
10563
10564func (self *BsnTlvVlanVid) Serialize(encoder *goloxi.Encoder) error {
10565 if err := self.BsnTlv.Serialize(encoder); err != nil {
10566 return err
10567 }
10568
10569 encoder.PutUint16(uint16(self.Value))
10570
10571 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
10572
10573 return nil
10574}
10575
10576func DecodeBsnTlvVlanVid(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVlanVid, error) {
10577 _bsntlvvlanvid := &BsnTlvVlanVid{BsnTlv: parent}
10578 if decoder.Length() < 2 {
10579 return nil, fmt.Errorf("BsnTlvVlanVid packet too short: %d < 2", decoder.Length())
10580 }
10581 _bsntlvvlanvid.Value = uint16(decoder.ReadUint16())
10582 return _bsntlvvlanvid, nil
10583}
10584
10585func NewBsnTlvVlanVid() *BsnTlvVlanVid {
10586 obj := &BsnTlvVlanVid{
10587 BsnTlv: NewBsnTlv(6),
10588 }
10589 return obj
10590}
10591
10592type BsnTlvVlanVidMask struct {
10593 *BsnTlv
10594 Value uint16
10595}
10596
10597type IBsnTlvVlanVidMask interface {
10598 IBsnTlv
10599 GetValue() uint16
10600}
10601
10602func (self *BsnTlvVlanVidMask) GetValue() uint16 {
10603 return self.Value
10604}
10605
10606func (self *BsnTlvVlanVidMask) SetValue(v uint16) {
10607 self.Value = v
10608}
10609
10610func (self *BsnTlvVlanVidMask) Serialize(encoder *goloxi.Encoder) error {
10611 if err := self.BsnTlv.Serialize(encoder); err != nil {
10612 return err
10613 }
10614
10615 encoder.PutUint16(uint16(self.Value))
10616
10617 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
10618
10619 return nil
10620}
10621
10622func DecodeBsnTlvVlanVidMask(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVlanVidMask, error) {
10623 _bsntlvvlanvidmask := &BsnTlvVlanVidMask{BsnTlv: parent}
10624 if decoder.Length() < 2 {
10625 return nil, fmt.Errorf("BsnTlvVlanVidMask packet too short: %d < 2", decoder.Length())
10626 }
10627 _bsntlvvlanvidmask.Value = uint16(decoder.ReadUint16())
10628 return _bsntlvvlanvidmask, nil
10629}
10630
10631func NewBsnTlvVlanVidMask() *BsnTlvVlanVidMask {
10632 obj := &BsnTlvVlanVidMask{
10633 BsnTlv: NewBsnTlv(77),
10634 }
10635 return obj
10636}
10637
10638type BsnTlvVni struct {
10639 *BsnTlv
10640 Value uint32
10641}
10642
10643type IBsnTlvVni interface {
10644 IBsnTlv
10645 GetValue() uint32
10646}
10647
10648func (self *BsnTlvVni) GetValue() uint32 {
10649 return self.Value
10650}
10651
10652func (self *BsnTlvVni) SetValue(v uint32) {
10653 self.Value = v
10654}
10655
10656func (self *BsnTlvVni) Serialize(encoder *goloxi.Encoder) error {
10657 if err := self.BsnTlv.Serialize(encoder); err != nil {
10658 return err
10659 }
10660
10661 encoder.PutUint32(uint32(self.Value))
10662
10663 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
10664
10665 return nil
10666}
10667
10668func DecodeBsnTlvVni(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVni, error) {
10669 _bsntlvvni := &BsnTlvVni{BsnTlv: parent}
10670 if decoder.Length() < 4 {
10671 return nil, fmt.Errorf("BsnTlvVni packet too short: %d < 4", decoder.Length())
10672 }
10673 _bsntlvvni.Value = uint32(decoder.ReadUint32())
10674 return _bsntlvvni, nil
10675}
10676
10677func NewBsnTlvVni() *BsnTlvVni {
10678 obj := &BsnTlvVni{
10679 BsnTlv: NewBsnTlv(86),
10680 }
10681 return obj
10682}
10683
10684type BsnTlvVpnKey struct {
10685 *BsnTlv
10686 Value uint32
10687}
10688
10689type IBsnTlvVpnKey interface {
10690 IBsnTlv
10691 GetValue() uint32
10692}
10693
10694func (self *BsnTlvVpnKey) GetValue() uint32 {
10695 return self.Value
10696}
10697
10698func (self *BsnTlvVpnKey) SetValue(v uint32) {
10699 self.Value = v
10700}
10701
10702func (self *BsnTlvVpnKey) Serialize(encoder *goloxi.Encoder) error {
10703 if err := self.BsnTlv.Serialize(encoder); err != nil {
10704 return err
10705 }
10706
10707 encoder.PutUint32(uint32(self.Value))
10708
10709 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
10710
10711 return nil
10712}
10713
10714func DecodeBsnTlvVpnKey(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVpnKey, error) {
10715 _bsntlvvpnkey := &BsnTlvVpnKey{BsnTlv: parent}
10716 if decoder.Length() < 4 {
10717 return nil, fmt.Errorf("BsnTlvVpnKey packet too short: %d < 4", decoder.Length())
10718 }
10719 _bsntlvvpnkey.Value = uint32(decoder.ReadUint32())
10720 return _bsntlvvpnkey, nil
10721}
10722
10723func NewBsnTlvVpnKey() *BsnTlvVpnKey {
10724 obj := &BsnTlvVpnKey{
10725 BsnTlv: NewBsnTlv(111),
10726 }
10727 return obj
10728}
10729
10730type BsnTlvVrf struct {
10731 *BsnTlv
10732 Value uint32
10733}
10734
10735type IBsnTlvVrf interface {
10736 IBsnTlv
10737 GetValue() uint32
10738}
10739
10740func (self *BsnTlvVrf) GetValue() uint32 {
10741 return self.Value
10742}
10743
10744func (self *BsnTlvVrf) SetValue(v uint32) {
10745 self.Value = v
10746}
10747
10748func (self *BsnTlvVrf) Serialize(encoder *goloxi.Encoder) error {
10749 if err := self.BsnTlv.Serialize(encoder); err != nil {
10750 return err
10751 }
10752
10753 encoder.PutUint32(uint32(self.Value))
10754
10755 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
10756
10757 return nil
10758}
10759
10760func DecodeBsnTlvVrf(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVrf, error) {
10761 _bsntlvvrf := &BsnTlvVrf{BsnTlv: parent}
10762 if decoder.Length() < 4 {
10763 return nil, fmt.Errorf("BsnTlvVrf packet too short: %d < 4", decoder.Length())
10764 }
10765 _bsntlvvrf.Value = uint32(decoder.ReadUint32())
10766 return _bsntlvvrf, nil
10767}
10768
10769func NewBsnTlvVrf() *BsnTlvVrf {
10770 obj := &BsnTlvVrf{
10771 BsnTlv: NewBsnTlv(19),
10772 }
10773 return obj
10774}
10775
10776type BsnTlvVxlanEgressLag struct {
10777 *BsnTlv
10778}
10779
10780type IBsnTlvVxlanEgressLag interface {
10781 IBsnTlv
10782}
10783
10784func (self *BsnTlvVxlanEgressLag) Serialize(encoder *goloxi.Encoder) error {
10785 if err := self.BsnTlv.Serialize(encoder); err != nil {
10786 return err
10787 }
10788
10789 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
10790
10791 return nil
10792}
10793
10794func DecodeBsnTlvVxlanEgressLag(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVxlanEgressLag, error) {
10795 _bsntlvvxlanegresslag := &BsnTlvVxlanEgressLag{BsnTlv: parent}
10796 return _bsntlvvxlanegresslag, nil
10797}
10798
10799func NewBsnTlvVxlanEgressLag() *BsnTlvVxlanEgressLag {
10800 obj := &BsnTlvVxlanEgressLag{
10801 BsnTlv: NewBsnTlv(117),
10802 }
10803 return obj
10804}
10805
10806type BsnVport struct {
10807 Type uint16
10808 Length uint16
10809}
10810
10811type IBsnVport interface {
10812 goloxi.Serializable
10813 GetType() uint16
10814 GetLength() uint16
10815}
10816
10817func (self *BsnVport) GetType() uint16 {
10818 return self.Type
10819}
10820
10821func (self *BsnVport) SetType(v uint16) {
10822 self.Type = v
10823}
10824
10825func (self *BsnVport) GetLength() uint16 {
10826 return self.Length
10827}
10828
10829func (self *BsnVport) SetLength(v uint16) {
10830 self.Length = v
10831}
10832
10833func (self *BsnVport) Serialize(encoder *goloxi.Encoder) error {
10834
10835 encoder.PutUint16(uint16(self.Type))
10836 encoder.PutUint16(uint16(self.Length))
10837
10838 return nil
10839}
10840func (self *BsnVport) Decode(decoder *goloxi.Decoder) error {
10841 if decoder.Length() < 4 {
10842 return fmt.Errorf("BsnVport packet too short: %d < 4", decoder.Length())
10843 }
10844
10845 self.Type = uint16(decoder.ReadUint16())
10846 self.Length = uint16(decoder.ReadUint16())
10847 oldDecoder := decoder
10848 defer func() { decoder = oldDecoder }()
10849 decoder = decoder.SliceDecoder(int(self.Length), 2+2)
10850
10851 return nil
10852}
10853
10854func NewBsnVport(_type uint16) *BsnVport {
10855 obj := &BsnVport{}
10856 obj.Type = _type
10857 return obj
10858}
10859
10860type BsnVlanCounterStatsEntry struct {
10861 Length uint16
10862 VlanVid uint16
10863 Values []*Uint64
10864}
10865
10866type IBsnVlanCounterStatsEntry interface {
10867 goloxi.Serializable
10868 GetLength() uint16
10869 GetVlanVid() uint16
10870 GetValues() []*Uint64
10871}
10872
10873func (self *BsnVlanCounterStatsEntry) GetLength() uint16 {
10874 return self.Length
10875}
10876
10877func (self *BsnVlanCounterStatsEntry) SetLength(v uint16) {
10878 self.Length = v
10879}
10880
10881func (self *BsnVlanCounterStatsEntry) GetVlanVid() uint16 {
10882 return self.VlanVid
10883}
10884
10885func (self *BsnVlanCounterStatsEntry) SetVlanVid(v uint16) {
10886 self.VlanVid = v
10887}
10888
10889func (self *BsnVlanCounterStatsEntry) GetValues() []*Uint64 {
10890 return self.Values
10891}
10892
10893func (self *BsnVlanCounterStatsEntry) SetValues(v []*Uint64) {
10894 self.Values = v
10895}
10896
10897func (self *BsnVlanCounterStatsEntry) Serialize(encoder *goloxi.Encoder) error {
10898
10899 encoder.PutUint16(uint16(self.Length))
10900 encoder.PutUint16(uint16(self.VlanVid))
10901 encoder.Write(bytes.Repeat([]byte{0}, 4))
10902 for _, obj := range self.Values {
10903 if err := obj.Serialize(encoder); err != nil {
10904 return err
10905 }
10906 }
10907
10908 binary.BigEndian.PutUint16(encoder.Bytes()[0:2], uint16(len(encoder.Bytes())))
10909
10910 return nil
10911}
10912
10913func DecodeBsnVlanCounterStatsEntry(decoder *goloxi.Decoder) (*BsnVlanCounterStatsEntry, error) {
10914 _bsnvlancounterstatsentry := &BsnVlanCounterStatsEntry{}
10915 if decoder.Length() < 8 {
10916 return nil, fmt.Errorf("BsnVlanCounterStatsEntry packet too short: %d < 8", decoder.Length())
10917 }
10918 _bsnvlancounterstatsentry.Length = uint16(decoder.ReadUint16())
10919 oldDecoder := decoder
10920 defer func() { decoder = oldDecoder }()
10921 decoder = decoder.SliceDecoder(int(_bsnvlancounterstatsentry.Length), 2+0)
10922 _bsnvlancounterstatsentry.VlanVid = uint16(decoder.ReadUint16())
10923 decoder.Skip(4)
10924
10925 for decoder.Length() >= 8 {
10926 item, err := DecodeUint64(decoder)
10927 if err != nil {
10928 return nil, err
10929 }
10930 if item != nil {
10931 _bsnvlancounterstatsentry.Values = append(_bsnvlancounterstatsentry.Values, item)
10932 }
10933 }
10934 return _bsnvlancounterstatsentry, nil
10935}
10936
10937func NewBsnVlanCounterStatsEntry() *BsnVlanCounterStatsEntry {
10938 obj := &BsnVlanCounterStatsEntry{}
10939 return obj
10940}
10941
10942type BsnVlanMac struct {
10943 VlanVid uint16
10944 Mac net.HardwareAddr
10945}
10946
10947type IBsnVlanMac interface {
10948 goloxi.Serializable
10949 GetVlanVid() uint16
10950 GetMac() net.HardwareAddr
10951}
10952
10953func (self *BsnVlanMac) GetVlanVid() uint16 {
10954 return self.VlanVid
10955}
10956
10957func (self *BsnVlanMac) SetVlanVid(v uint16) {
10958 self.VlanVid = v
10959}
10960
10961func (self *BsnVlanMac) GetMac() net.HardwareAddr {
10962 return self.Mac
10963}
10964
10965func (self *BsnVlanMac) SetMac(v net.HardwareAddr) {
10966 self.Mac = v
10967}
10968
10969func (self *BsnVlanMac) Serialize(encoder *goloxi.Encoder) error {
10970
10971 encoder.PutUint16(uint16(self.VlanVid))
10972 encoder.Write(self.Mac)
10973
10974 return nil
10975}
10976
10977func DecodeBsnVlanMac(decoder *goloxi.Decoder) (*BsnVlanMac, error) {
10978 _bsnvlanmac := &BsnVlanMac{}
10979 if decoder.Length() < 8 {
10980 return nil, fmt.Errorf("BsnVlanMac packet too short: %d < 8", decoder.Length())
10981 }
10982 _bsnvlanmac.VlanVid = uint16(decoder.ReadUint16())
10983 _bsnvlanmac.Mac = net.HardwareAddr(decoder.Read(6))
10984 return _bsnvlanmac, nil
10985}
10986
10987func NewBsnVlanMac() *BsnVlanMac {
10988 obj := &BsnVlanMac{}
10989 return obj
10990}
10991
10992type BsnVportL2Gre struct {
10993 *BsnVport
10994 Flags BsnVportL2GreFlags
10995 PortNo Port
10996 LoopbackPortNo Port
10997 LocalMac net.HardwareAddr
10998 NhMac net.HardwareAddr
10999 SrcIp net.IP
11000 DstIp net.IP
11001 Dscp uint8
11002 Ttl uint8
11003 Vpn uint32
11004 RateLimit uint32
11005 IfName string
11006}
11007
11008type IBsnVportL2Gre interface {
11009 IBsnVport
11010 GetFlags() BsnVportL2GreFlags
11011 GetPortNo() Port
11012 GetLoopbackPortNo() Port
11013 GetLocalMac() net.HardwareAddr
11014 GetNhMac() net.HardwareAddr
11015 GetSrcIp() net.IP
11016 GetDstIp() net.IP
11017 GetDscp() uint8
11018 GetTtl() uint8
11019 GetVpn() uint32
11020 GetRateLimit() uint32
11021 GetIfName() string
11022}
11023
11024func (self *BsnVportL2Gre) GetFlags() BsnVportL2GreFlags {
11025 return self.Flags
11026}
11027
11028func (self *BsnVportL2Gre) SetFlags(v BsnVportL2GreFlags) {
11029 self.Flags = v
11030}
11031
11032func (self *BsnVportL2Gre) GetPortNo() Port {
11033 return self.PortNo
11034}
11035
11036func (self *BsnVportL2Gre) SetPortNo(v Port) {
11037 self.PortNo = v
11038}
11039
11040func (self *BsnVportL2Gre) GetLoopbackPortNo() Port {
11041 return self.LoopbackPortNo
11042}
11043
11044func (self *BsnVportL2Gre) SetLoopbackPortNo(v Port) {
11045 self.LoopbackPortNo = v
11046}
11047
11048func (self *BsnVportL2Gre) GetLocalMac() net.HardwareAddr {
11049 return self.LocalMac
11050}
11051
11052func (self *BsnVportL2Gre) SetLocalMac(v net.HardwareAddr) {
11053 self.LocalMac = v
11054}
11055
11056func (self *BsnVportL2Gre) GetNhMac() net.HardwareAddr {
11057 return self.NhMac
11058}
11059
11060func (self *BsnVportL2Gre) SetNhMac(v net.HardwareAddr) {
11061 self.NhMac = v
11062}
11063
11064func (self *BsnVportL2Gre) GetSrcIp() net.IP {
11065 return self.SrcIp
11066}
11067
11068func (self *BsnVportL2Gre) SetSrcIp(v net.IP) {
11069 self.SrcIp = v
11070}
11071
11072func (self *BsnVportL2Gre) GetDstIp() net.IP {
11073 return self.DstIp
11074}
11075
11076func (self *BsnVportL2Gre) SetDstIp(v net.IP) {
11077 self.DstIp = v
11078}
11079
11080func (self *BsnVportL2Gre) GetDscp() uint8 {
11081 return self.Dscp
11082}
11083
11084func (self *BsnVportL2Gre) SetDscp(v uint8) {
11085 self.Dscp = v
11086}
11087
11088func (self *BsnVportL2Gre) GetTtl() uint8 {
11089 return self.Ttl
11090}
11091
11092func (self *BsnVportL2Gre) SetTtl(v uint8) {
11093 self.Ttl = v
11094}
11095
11096func (self *BsnVportL2Gre) GetVpn() uint32 {
11097 return self.Vpn
11098}
11099
11100func (self *BsnVportL2Gre) SetVpn(v uint32) {
11101 self.Vpn = v
11102}
11103
11104func (self *BsnVportL2Gre) GetRateLimit() uint32 {
11105 return self.RateLimit
11106}
11107
11108func (self *BsnVportL2Gre) SetRateLimit(v uint32) {
11109 self.RateLimit = v
11110}
11111
11112func (self *BsnVportL2Gre) GetIfName() string {
11113 return self.IfName
11114}
11115
11116func (self *BsnVportL2Gre) SetIfName(v string) {
11117 self.IfName = v
11118}
11119
11120func (self *BsnVportL2Gre) Serialize(encoder *goloxi.Encoder) error {
11121 if err := self.BsnVport.Serialize(encoder); err != nil {
11122 return err
11123 }
11124
11125 encoder.PutUint32(uint32(self.Flags))
11126 self.PortNo.Serialize(encoder)
11127 self.LoopbackPortNo.Serialize(encoder)
11128 encoder.Write(self.LocalMac)
11129 encoder.Write(self.NhMac)
11130 encoder.Write(self.SrcIp.To4())
11131 encoder.Write(self.DstIp.To4())
11132 encoder.PutUint8(uint8(self.Dscp))
11133 encoder.PutUint8(uint8(self.Ttl))
11134 encoder.Write(bytes.Repeat([]byte{0}, 2))
11135 encoder.PutUint32(uint32(self.Vpn))
11136 encoder.PutUint32(uint32(self.RateLimit))
11137 encoder.Write([]byte(self.IfName))
11138
11139 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
11140
11141 return nil
11142}
11143
11144func DecodeBsnVportL2Gre(parent *BsnVport, decoder *goloxi.Decoder) (*BsnVportL2Gre, error) {
11145 _bsnvportl2gre := &BsnVportL2Gre{BsnVport: parent}
11146 if decoder.Length() < 60 {
11147 return nil, fmt.Errorf("BsnVportL2Gre packet too short: %d < 60", decoder.Length())
11148 }
11149 _bsnvportl2gre.Flags = BsnVportL2GreFlags(decoder.ReadUint32())
11150 _bsnvportl2gre.PortNo.Decode(decoder)
11151 _bsnvportl2gre.LoopbackPortNo.Decode(decoder)
11152 _bsnvportl2gre.LocalMac = net.HardwareAddr(decoder.Read(6))
11153 _bsnvportl2gre.NhMac = net.HardwareAddr(decoder.Read(6))
11154 _bsnvportl2gre.SrcIp = net.IP(decoder.Read(4))
11155 _bsnvportl2gre.DstIp = net.IP(decoder.Read(4))
11156 _bsnvportl2gre.Dscp = uint8(decoder.ReadByte())
11157 _bsnvportl2gre.Ttl = uint8(decoder.ReadByte())
11158 decoder.Skip(2)
11159 _bsnvportl2gre.Vpn = uint32(decoder.ReadUint32())
11160 _bsnvportl2gre.RateLimit = uint32(decoder.ReadUint32())
11161 _bsnvportl2gre.IfName = string(bytes.Trim(decoder.Read(16), "\x00"))
11162 return _bsnvportl2gre, nil
11163}
11164
11165func NewBsnVportL2Gre() *BsnVportL2Gre {
11166 obj := &BsnVportL2Gre{
11167 BsnVport: NewBsnVport(1),
11168 }
11169 return obj
11170}
11171
11172type BsnVportQInQ struct {
11173 *BsnVport
11174 PortNo uint32
11175 IngressTpid uint16
11176 IngressVlanId uint16
11177 EgressTpid uint16
11178 EgressVlanId uint16
11179 IfName string
11180}
11181
11182type IBsnVportQInQ interface {
11183 IBsnVport
11184 GetPortNo() uint32
11185 GetIngressTpid() uint16
11186 GetIngressVlanId() uint16
11187 GetEgressTpid() uint16
11188 GetEgressVlanId() uint16
11189 GetIfName() string
11190}
11191
11192func (self *BsnVportQInQ) GetPortNo() uint32 {
11193 return self.PortNo
11194}
11195
11196func (self *BsnVportQInQ) SetPortNo(v uint32) {
11197 self.PortNo = v
11198}
11199
11200func (self *BsnVportQInQ) GetIngressTpid() uint16 {
11201 return self.IngressTpid
11202}
11203
11204func (self *BsnVportQInQ) SetIngressTpid(v uint16) {
11205 self.IngressTpid = v
11206}
11207
11208func (self *BsnVportQInQ) GetIngressVlanId() uint16 {
11209 return self.IngressVlanId
11210}
11211
11212func (self *BsnVportQInQ) SetIngressVlanId(v uint16) {
11213 self.IngressVlanId = v
11214}
11215
11216func (self *BsnVportQInQ) GetEgressTpid() uint16 {
11217 return self.EgressTpid
11218}
11219
11220func (self *BsnVportQInQ) SetEgressTpid(v uint16) {
11221 self.EgressTpid = v
11222}
11223
11224func (self *BsnVportQInQ) GetEgressVlanId() uint16 {
11225 return self.EgressVlanId
11226}
11227
11228func (self *BsnVportQInQ) SetEgressVlanId(v uint16) {
11229 self.EgressVlanId = v
11230}
11231
11232func (self *BsnVportQInQ) GetIfName() string {
11233 return self.IfName
11234}
11235
11236func (self *BsnVportQInQ) SetIfName(v string) {
11237 self.IfName = v
11238}
11239
11240func (self *BsnVportQInQ) Serialize(encoder *goloxi.Encoder) error {
11241 if err := self.BsnVport.Serialize(encoder); err != nil {
11242 return err
11243 }
11244
11245 encoder.PutUint32(uint32(self.PortNo))
11246 encoder.PutUint16(uint16(self.IngressTpid))
11247 encoder.PutUint16(uint16(self.IngressVlanId))
11248 encoder.PutUint16(uint16(self.EgressTpid))
11249 encoder.PutUint16(uint16(self.EgressVlanId))
11250 encoder.Write([]byte(self.IfName))
11251
11252 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
11253
11254 return nil
11255}
11256
11257func DecodeBsnVportQInQ(parent *BsnVport, decoder *goloxi.Decoder) (*BsnVportQInQ, error) {
11258 _bsnvportqinq := &BsnVportQInQ{BsnVport: parent}
11259 if decoder.Length() < 28 {
11260 return nil, fmt.Errorf("BsnVportQInQ packet too short: %d < 28", decoder.Length())
11261 }
11262 _bsnvportqinq.PortNo = uint32(decoder.ReadUint32())
11263 _bsnvportqinq.IngressTpid = uint16(decoder.ReadUint16())
11264 _bsnvportqinq.IngressVlanId = uint16(decoder.ReadUint16())
11265 _bsnvportqinq.EgressTpid = uint16(decoder.ReadUint16())
11266 _bsnvportqinq.EgressVlanId = uint16(decoder.ReadUint16())
11267 _bsnvportqinq.IfName = string(bytes.Trim(decoder.Read(16), "\x00"))
11268 return _bsnvportqinq, nil
11269}
11270
11271func NewBsnVportQInQ() *BsnVportQInQ {
11272 obj := &BsnVportQInQ{
11273 BsnVport: NewBsnVport(0),
11274 }
11275 return obj
11276}
11277
11278type BsnVrfCounterStatsEntry struct {
11279 Length uint16
11280 Vrf uint32
11281 Values []*Uint64
11282}
11283
11284type IBsnVrfCounterStatsEntry interface {
11285 goloxi.Serializable
11286 GetLength() uint16
11287 GetVrf() uint32
11288 GetValues() []*Uint64
11289}
11290
11291func (self *BsnVrfCounterStatsEntry) GetLength() uint16 {
11292 return self.Length
11293}
11294
11295func (self *BsnVrfCounterStatsEntry) SetLength(v uint16) {
11296 self.Length = v
11297}
11298
11299func (self *BsnVrfCounterStatsEntry) GetVrf() uint32 {
11300 return self.Vrf
11301}
11302
11303func (self *BsnVrfCounterStatsEntry) SetVrf(v uint32) {
11304 self.Vrf = v
11305}
11306
11307func (self *BsnVrfCounterStatsEntry) GetValues() []*Uint64 {
11308 return self.Values
11309}
11310
11311func (self *BsnVrfCounterStatsEntry) SetValues(v []*Uint64) {
11312 self.Values = v
11313}
11314
11315func (self *BsnVrfCounterStatsEntry) Serialize(encoder *goloxi.Encoder) error {
11316
11317 encoder.PutUint16(uint16(self.Length))
11318 encoder.Write(bytes.Repeat([]byte{0}, 2))
11319 encoder.PutUint32(uint32(self.Vrf))
11320 for _, obj := range self.Values {
11321 if err := obj.Serialize(encoder); err != nil {
11322 return err
11323 }
11324 }
11325
11326 binary.BigEndian.PutUint16(encoder.Bytes()[0:2], uint16(len(encoder.Bytes())))
11327
11328 return nil
11329}
11330
11331func DecodeBsnVrfCounterStatsEntry(decoder *goloxi.Decoder) (*BsnVrfCounterStatsEntry, error) {
11332 _bsnvrfcounterstatsentry := &BsnVrfCounterStatsEntry{}
11333 if decoder.Length() < 8 {
11334 return nil, fmt.Errorf("BsnVrfCounterStatsEntry packet too short: %d < 8", decoder.Length())
11335 }
11336 _bsnvrfcounterstatsentry.Length = uint16(decoder.ReadUint16())
11337 oldDecoder := decoder
11338 defer func() { decoder = oldDecoder }()
11339 decoder = decoder.SliceDecoder(int(_bsnvrfcounterstatsentry.Length), 2+0)
11340 decoder.Skip(2)
11341 _bsnvrfcounterstatsentry.Vrf = uint32(decoder.ReadUint32())
11342
11343 for decoder.Length() >= 8 {
11344 item, err := DecodeUint64(decoder)
11345 if err != nil {
11346 return nil, err
11347 }
11348 if item != nil {
11349 _bsnvrfcounterstatsentry.Values = append(_bsnvrfcounterstatsentry.Values, item)
11350 }
11351 }
11352 return _bsnvrfcounterstatsentry, nil
11353}
11354
11355func NewBsnVrfCounterStatsEntry() *BsnVrfCounterStatsEntry {
11356 obj := &BsnVrfCounterStatsEntry{}
11357 return obj
11358}
11359
11360type Bucket struct {
11361 Len uint16
11362 Weight uint16
11363 WatchPort Port
11364 WatchGroup uint32
11365 Actions []goloxi.IAction
11366}
11367
11368type IBucket interface {
11369 goloxi.Serializable
11370 GetLen() uint16
11371 GetWeight() uint16
11372 GetWatchPort() Port
11373 GetWatchGroup() uint32
11374 GetActions() []goloxi.IAction
11375}
11376
11377func (self *Bucket) GetLen() uint16 {
11378 return self.Len
11379}
11380
11381func (self *Bucket) SetLen(v uint16) {
11382 self.Len = v
11383}
11384
11385func (self *Bucket) GetWeight() uint16 {
11386 return self.Weight
11387}
11388
11389func (self *Bucket) SetWeight(v uint16) {
11390 self.Weight = v
11391}
11392
11393func (self *Bucket) GetWatchPort() Port {
11394 return self.WatchPort
11395}
11396
11397func (self *Bucket) SetWatchPort(v Port) {
11398 self.WatchPort = v
11399}
11400
11401func (self *Bucket) GetWatchGroup() uint32 {
11402 return self.WatchGroup
11403}
11404
11405func (self *Bucket) SetWatchGroup(v uint32) {
11406 self.WatchGroup = v
11407}
11408
11409func (self *Bucket) GetActions() []goloxi.IAction {
11410 return self.Actions
11411}
11412
11413func (self *Bucket) SetActions(v []goloxi.IAction) {
11414 self.Actions = v
11415}
11416
11417func (self *Bucket) Serialize(encoder *goloxi.Encoder) error {
11418
11419 encoder.PutUint16(uint16(self.Len))
11420 encoder.PutUint16(uint16(self.Weight))
11421 self.WatchPort.Serialize(encoder)
11422 encoder.PutUint32(uint32(self.WatchGroup))
11423 encoder.Write(bytes.Repeat([]byte{0}, 4))
11424 for _, obj := range self.Actions {
11425 if err := obj.Serialize(encoder); err != nil {
11426 return err
11427 }
11428 }
11429
11430 binary.BigEndian.PutUint16(encoder.Bytes()[0:2], uint16(len(encoder.Bytes())))
11431
11432 return nil
11433}
11434
11435func DecodeBucket(decoder *goloxi.Decoder) (*Bucket, error) {
11436 _bucket := &Bucket{}
11437 if decoder.Length() < 16 {
11438 return nil, fmt.Errorf("Bucket packet too short: %d < 16", decoder.Length())
11439 }
11440 _bucket.Len = uint16(decoder.ReadUint16())
11441 oldDecoder := decoder
11442 defer func() { decoder = oldDecoder }()
11443 decoder = decoder.SliceDecoder(int(_bucket.Len), 2+0)
11444 _bucket.Weight = uint16(decoder.ReadUint16())
11445 _bucket.WatchPort.Decode(decoder)
11446 _bucket.WatchGroup = uint32(decoder.ReadUint32())
11447 decoder.Skip(4)
11448
11449 for decoder.Length() >= 8 {
11450 item, err := DecodeAction(decoder)
11451 if err != nil {
11452 return nil, err
11453 }
11454 if item != nil {
11455 _bucket.Actions = append(_bucket.Actions, item)
11456 }
11457 }
11458 return _bucket, nil
11459}
11460
11461func NewBucket() *Bucket {
11462 obj := &Bucket{}
11463 return obj
11464}
11465
11466type BucketCounter struct {
11467 PacketCount uint64
11468 ByteCount uint64
11469}
11470
11471type IBucketCounter interface {
11472 goloxi.Serializable
11473 GetPacketCount() uint64
11474 GetByteCount() uint64
11475}
11476
11477func (self *BucketCounter) GetPacketCount() uint64 {
11478 return self.PacketCount
11479}
11480
11481func (self *BucketCounter) SetPacketCount(v uint64) {
11482 self.PacketCount = v
11483}
11484
11485func (self *BucketCounter) GetByteCount() uint64 {
11486 return self.ByteCount
11487}
11488
11489func (self *BucketCounter) SetByteCount(v uint64) {
11490 self.ByteCount = v
11491}
11492
11493func (self *BucketCounter) Serialize(encoder *goloxi.Encoder) error {
11494
11495 encoder.PutUint64(uint64(self.PacketCount))
11496 encoder.PutUint64(uint64(self.ByteCount))
11497
11498 return nil
11499}
11500
11501func DecodeBucketCounter(decoder *goloxi.Decoder) (*BucketCounter, error) {
11502 _bucketcounter := &BucketCounter{}
11503 if decoder.Length() < 16 {
11504 return nil, fmt.Errorf("BucketCounter packet too short: %d < 16", decoder.Length())
11505 }
11506 _bucketcounter.PacketCount = uint64(decoder.ReadUint64())
11507 _bucketcounter.ByteCount = uint64(decoder.ReadUint64())
11508 return _bucketcounter, nil
11509}
11510
11511func NewBucketCounter() *BucketCounter {
11512 obj := &BucketCounter{}
11513 return obj
11514}
11515
11516type EdPropHeader struct {
11517 PropClass uint16
11518}
11519
11520type IEdPropHeader interface {
11521 goloxi.Serializable
11522 GetPropClass() uint16
11523}
11524
11525func (self *EdPropHeader) GetPropClass() uint16 {
11526 return self.PropClass
11527}
11528
11529func (self *EdPropHeader) SetPropClass(v uint16) {
11530 self.PropClass = v
11531}
11532
11533func (self *EdPropHeader) Serialize(encoder *goloxi.Encoder) error {
11534
11535 encoder.PutUint16(uint16(self.PropClass))
11536
11537 return nil
11538}
11539
11540func DecodeEdPropHeader(decoder *goloxi.Decoder) (IEdPropHeader, error) {
11541 _edpropheader := &EdPropHeader{}
11542 if decoder.Length() < 2 {
11543 return nil, fmt.Errorf("EdPropHeader packet too short: %d < 2", decoder.Length())
11544 }
11545 _edpropheader.PropClass = uint16(decoder.ReadUint16())
11546
11547 switch _edpropheader.PropClass {
11548 case 4:
11549 return DecodeEdPropNsh(_edpropheader, decoder)
11550 default:
11551 return nil, fmt.Errorf("Invalid type '%d' for 'EdPropHeader'", _edpropheader.PropClass)
11552 }
11553}
11554
11555func NewEdPropHeader(_prop_class uint16) *EdPropHeader {
11556 obj := &EdPropHeader{}
11557 obj.PropClass = _prop_class
11558 return obj
11559}
11560
11561type EdPropNsh struct {
11562 *EdPropHeader
11563 Type uint8
11564 Len uint8
11565}
11566
11567type IEdPropNsh interface {
11568 IEdPropHeader
11569 GetType() uint8
11570 GetLen() uint8
11571}
11572
11573func (self *EdPropNsh) GetType() uint8 {
11574 return self.Type
11575}
11576
11577func (self *EdPropNsh) SetType(v uint8) {
11578 self.Type = v
11579}
11580
11581func (self *EdPropNsh) GetLen() uint8 {
11582 return self.Len
11583}
11584
11585func (self *EdPropNsh) SetLen(v uint8) {
11586 self.Len = v
11587}
11588
11589func (self *EdPropNsh) Serialize(encoder *goloxi.Encoder) error {
11590 if err := self.EdPropHeader.Serialize(encoder); err != nil {
11591 return err
11592 }
11593
11594 encoder.PutUint8(uint8(self.Type))
11595 encoder.PutUint8(uint8(self.Len))
11596
11597 encoder.SkipAlign()
11598
11599 return nil
11600}
11601
11602func DecodeEdPropNsh(parent *EdPropHeader, decoder *goloxi.Decoder) (IEdPropNsh, error) {
11603 _edpropnsh := &EdPropNsh{EdPropHeader: parent}
11604 if decoder.Length() < 2 {
11605 return nil, fmt.Errorf("EdPropNsh packet too short: %d < 2", decoder.Length())
11606 }
11607 defer decoder.SkipAlign()
11608
11609 _edpropnsh.Type = uint8(decoder.ReadByte())
11610 _edpropnsh.Len = uint8(decoder.ReadByte())
11611 oldDecoder := decoder
11612 defer func() { decoder = oldDecoder }()
11613 decoder = decoder.SliceDecoder(int(((_edpropnsh.Len)+7)/8*8), 1+3)
11614
11615 switch _edpropnsh.Type {
11616 case 1:
11617 return DecodeEdPropNshMdType(_edpropnsh, decoder)
11618 case 2:
11619 return DecodeEdPropNshTlv(_edpropnsh, decoder)
11620 default:
11621 return nil, fmt.Errorf("Invalid type '%d' for 'EdPropNsh'", _edpropnsh.Type)
11622 }
11623}
11624
11625func NewEdPropNsh(_type uint8) *EdPropNsh {
11626 obj := &EdPropNsh{
11627 EdPropHeader: NewEdPropHeader(4),
11628 }
11629 obj.Type = _type
11630 return obj
11631}
11632
11633type EdPropNshMdType struct {
11634 *EdPropNsh
11635 MdType uint8
11636}
11637
11638type IEdPropNshMdType interface {
11639 IEdPropNsh
11640 GetMdType() uint8
11641}
11642
11643func (self *EdPropNshMdType) GetMdType() uint8 {
11644 return self.MdType
11645}
11646
11647func (self *EdPropNshMdType) SetMdType(v uint8) {
11648 self.MdType = v
11649}
11650
11651func (self *EdPropNshMdType) Serialize(encoder *goloxi.Encoder) error {
11652 if err := self.EdPropNsh.Serialize(encoder); err != nil {
11653 return err
11654 }
11655
11656 encoder.PutUint8(uint8(self.MdType))
11657 encoder.Write(bytes.Repeat([]byte{0}, 3))
11658
11659 encoder.Bytes()[3] = uint8(len(encoder.Bytes()))
11660
11661 return nil
11662}
11663
11664func DecodeEdPropNshMdType(parent *EdPropNsh, decoder *goloxi.Decoder) (*EdPropNshMdType, error) {
11665 _edpropnshmdtype := &EdPropNshMdType{EdPropNsh: parent}
11666 if decoder.Length() < 4 {
11667 return nil, fmt.Errorf("EdPropNshMdType packet too short: %d < 4", decoder.Length())
11668 }
11669 _edpropnshmdtype.MdType = uint8(decoder.ReadByte())
11670 decoder.Skip(3)
11671 return _edpropnshmdtype, nil
11672}
11673
11674func NewEdPropNshMdType() *EdPropNshMdType {
11675 obj := &EdPropNshMdType{
11676 EdPropNsh: NewEdPropNsh(1),
11677 }
11678 return obj
11679}
11680
11681type EdPropNshTlv struct {
11682 *EdPropNsh
11683 TlvClass uint16
11684 TlvType uint8
11685 TlvLen uint8
11686 Value []byte
11687}
11688
11689type IEdPropNshTlv interface {
11690 IEdPropNsh
11691 GetTlvClass() uint16
11692 GetTlvType() uint8
11693 GetTlvLen() uint8
11694 GetValue() []byte
11695}
11696
11697func (self *EdPropNshTlv) GetTlvClass() uint16 {
11698 return self.TlvClass
11699}
11700
11701func (self *EdPropNshTlv) SetTlvClass(v uint16) {
11702 self.TlvClass = v
11703}
11704
11705func (self *EdPropNshTlv) GetTlvType() uint8 {
11706 return self.TlvType
11707}
11708
11709func (self *EdPropNshTlv) SetTlvType(v uint8) {
11710 self.TlvType = v
11711}
11712
11713func (self *EdPropNshTlv) GetTlvLen() uint8 {
11714 return self.TlvLen
11715}
11716
11717func (self *EdPropNshTlv) SetTlvLen(v uint8) {
11718 self.TlvLen = v
11719}
11720
11721func (self *EdPropNshTlv) GetValue() []byte {
11722 return self.Value
11723}
11724
11725func (self *EdPropNshTlv) SetValue(v []byte) {
11726 self.Value = v
11727}
11728
11729func (self *EdPropNshTlv) Serialize(encoder *goloxi.Encoder) error {
11730 if err := self.EdPropNsh.Serialize(encoder); err != nil {
11731 return err
11732 }
11733
11734 encoder.PutUint16(uint16(self.TlvClass))
11735 encoder.PutUint8(uint8(self.TlvType))
11736 encoder.PutUint8(uint8(self.TlvLen))
11737 encoder.Write(self.Value)
11738
11739 encoder.Bytes()[3] = uint8(len(encoder.Bytes()))
11740
11741 return nil
11742}
11743
11744func DecodeEdPropNshTlv(parent *EdPropNsh, decoder *goloxi.Decoder) (*EdPropNshTlv, error) {
11745 _edpropnshtlv := &EdPropNshTlv{EdPropNsh: parent}
11746 if decoder.Length() < 4 {
11747 return nil, fmt.Errorf("EdPropNshTlv packet too short: %d < 4", decoder.Length())
11748 }
11749 _edpropnshtlv.TlvClass = uint16(decoder.ReadUint16())
11750 _edpropnshtlv.TlvType = uint8(decoder.ReadByte())
11751 _edpropnshtlv.TlvLen = uint8(decoder.ReadByte())
11752 _edpropnshtlv.Value = decoder.SliceDecoder(int(_edpropnshtlv.TlvLen), 0).Read(int(_edpropnshtlv.TlvLen))
11753 return _edpropnshtlv, nil
11754}
11755
11756func NewEdPropNshTlv() *EdPropNshTlv {
11757 obj := &EdPropNshTlv{
11758 EdPropNsh: NewEdPropNsh(2),
11759 }
11760 return obj
11761}
11762
11763type FlowModSpec struct {
11764 SrcDst uint8
11765 NBits uint8
11766}
11767
11768type IFlowModSpec interface {
11769 goloxi.Serializable
11770 GetSrcDst() uint8
11771 GetNBits() uint8
11772}
11773
11774func (self *FlowModSpec) GetSrcDst() uint8 {
11775 return self.SrcDst
11776}
11777
11778func (self *FlowModSpec) SetSrcDst(v uint8) {
11779 self.SrcDst = v
11780}
11781
11782func (self *FlowModSpec) GetNBits() uint8 {
11783 return self.NBits
11784}
11785
11786func (self *FlowModSpec) SetNBits(v uint8) {
11787 self.NBits = v
11788}
11789
11790func (self *FlowModSpec) Serialize(encoder *goloxi.Encoder) error {
11791
11792 encoder.PutUint8(uint8(self.SrcDst))
11793 encoder.PutUint8(uint8(self.NBits))
11794
11795 return nil
11796}
11797
11798func DecodeFlowModSpec(decoder *goloxi.Decoder) (IFlowModSpec, error) {
11799 _flowmodspec := &FlowModSpec{}
11800 if decoder.Length() < 2 {
11801 return nil, fmt.Errorf("FlowModSpec packet too short: %d < 2", decoder.Length())
11802 }
11803 _flowmodspec.SrcDst = uint8(decoder.ReadByte())
11804 _flowmodspec.NBits = uint8(decoder.ReadByte())
11805 if _flowmodspec.SrcDst == 0 && _flowmodspec.NBits == 0 {
11806 return nil, nil
11807 }
11808
11809 switch _flowmodspec.SrcDst {
11810 case 0:
11811 return DecodeFlowModSpecSrc0Dst0(_flowmodspec, decoder)
11812 case 8:
11813 return DecodeFlowModSpecSrc0Dst1(_flowmodspec, decoder)
11814 case 40:
11815 return DecodeFlowModSpecSrc1Dst1(_flowmodspec, decoder)
11816 case 16:
11817 return DecodeFlowModSpecSrc0Dst2(_flowmodspec, decoder)
11818 case 32:
11819 return DecodeFlowModSpecSrc1Dst0(_flowmodspec, decoder)
11820 default:
11821 return nil, fmt.Errorf("Invalid type '%d' for 'FlowModSpec'", _flowmodspec.SrcDst)
11822 }
11823}
11824
11825func NewFlowModSpec(_src_dst uint8) *FlowModSpec {
11826 obj := &FlowModSpec{}
11827 obj.SrcDst = _src_dst
11828 return obj
11829}
11830
11831type FlowModSpecSrc0Dst0 struct {
11832 *FlowModSpec
11833 Src goloxi.IOxmId
11834 SrcOfs uint16
11835 Dst goloxi.IOxmId
11836 DstOfs uint16
11837}
11838
11839type IFlowModSpecSrc0Dst0 interface {
11840 IFlowModSpec
11841 GetSrc() goloxi.IOxmId
11842 GetSrcOfs() uint16
11843 GetDst() goloxi.IOxmId
11844 GetDstOfs() uint16
11845}
11846
11847func (self *FlowModSpecSrc0Dst0) GetSrc() goloxi.IOxmId {
11848 return self.Src
11849}
11850
11851func (self *FlowModSpecSrc0Dst0) SetSrc(v goloxi.IOxmId) {
11852 self.Src = v
11853}
11854
11855func (self *FlowModSpecSrc0Dst0) GetSrcOfs() uint16 {
11856 return self.SrcOfs
11857}
11858
11859func (self *FlowModSpecSrc0Dst0) SetSrcOfs(v uint16) {
11860 self.SrcOfs = v
11861}
11862
11863func (self *FlowModSpecSrc0Dst0) GetDst() goloxi.IOxmId {
11864 return self.Dst
11865}
11866
11867func (self *FlowModSpecSrc0Dst0) SetDst(v goloxi.IOxmId) {
11868 self.Dst = v
11869}
11870
11871func (self *FlowModSpecSrc0Dst0) GetDstOfs() uint16 {
11872 return self.DstOfs
11873}
11874
11875func (self *FlowModSpecSrc0Dst0) SetDstOfs(v uint16) {
11876 self.DstOfs = v
11877}
11878
11879func (self *FlowModSpecSrc0Dst0) Serialize(encoder *goloxi.Encoder) error {
11880 if err := self.FlowModSpec.Serialize(encoder); err != nil {
11881 return err
11882 }
11883
11884 self.Src.Serialize(encoder)
11885 encoder.PutUint16(uint16(self.SrcOfs))
11886 self.Dst.Serialize(encoder)
11887 encoder.PutUint16(uint16(self.DstOfs))
11888
11889 return nil
11890}
11891
11892func DecodeFlowModSpecSrc0Dst0(parent *FlowModSpec, decoder *goloxi.Decoder) (IFlowModSpecSrc0Dst0, error) {
11893 _flowmodspecsrc0dst0 := &FlowModSpecSrc0Dst0{FlowModSpec: parent}
11894 if decoder.Length() < 12 {
11895 return nil, fmt.Errorf("FlowModSpecSrc0Dst0 packet too short: %d < 12", decoder.Length())
11896 }
11897 if obj, err := DecodeOxmId(decoder); err != nil {
11898 return nil, err
11899 } else {
11900 _flowmodspecsrc0dst0.Src = obj
11901 }
11902
11903 _flowmodspecsrc0dst0.SrcOfs = uint16(decoder.ReadUint16())
11904 if obj, err := DecodeOxmId(decoder); err != nil {
11905 return nil, err
11906 } else {
11907 _flowmodspecsrc0dst0.Dst = obj
11908 }
11909
11910 _flowmodspecsrc0dst0.DstOfs = uint16(decoder.ReadUint16())
11911 return _flowmodspecsrc0dst0, nil
11912}
11913
11914func NewFlowModSpecSrc0Dst0(_n_bits uint8) *FlowModSpecSrc0Dst0 {
11915 obj := &FlowModSpecSrc0Dst0{
11916 FlowModSpec: NewFlowModSpec(0),
11917 }
11918 obj.NBits = _n_bits
11919 return obj
11920}
11921
11922type FlowModSpecSrc0Dst1 struct {
11923 *FlowModSpec
11924 Src goloxi.IOxmId
11925 SrcOfs uint16
11926 Dst goloxi.IOxmId
11927 DstOfs uint16
11928}
11929
11930type IFlowModSpecSrc0Dst1 interface {
11931 IFlowModSpec
11932 GetSrc() goloxi.IOxmId
11933 GetSrcOfs() uint16
11934 GetDst() goloxi.IOxmId
11935 GetDstOfs() uint16
11936}
11937
11938func (self *FlowModSpecSrc0Dst1) GetSrc() goloxi.IOxmId {
11939 return self.Src
11940}
11941
11942func (self *FlowModSpecSrc0Dst1) SetSrc(v goloxi.IOxmId) {
11943 self.Src = v
11944}
11945
11946func (self *FlowModSpecSrc0Dst1) GetSrcOfs() uint16 {
11947 return self.SrcOfs
11948}
11949
11950func (self *FlowModSpecSrc0Dst1) SetSrcOfs(v uint16) {
11951 self.SrcOfs = v
11952}
11953
11954func (self *FlowModSpecSrc0Dst1) GetDst() goloxi.IOxmId {
11955 return self.Dst
11956}
11957
11958func (self *FlowModSpecSrc0Dst1) SetDst(v goloxi.IOxmId) {
11959 self.Dst = v
11960}
11961
11962func (self *FlowModSpecSrc0Dst1) GetDstOfs() uint16 {
11963 return self.DstOfs
11964}
11965
11966func (self *FlowModSpecSrc0Dst1) SetDstOfs(v uint16) {
11967 self.DstOfs = v
11968}
11969
11970func (self *FlowModSpecSrc0Dst1) Serialize(encoder *goloxi.Encoder) error {
11971 if err := self.FlowModSpec.Serialize(encoder); err != nil {
11972 return err
11973 }
11974
11975 self.Src.Serialize(encoder)
11976 encoder.PutUint16(uint16(self.SrcOfs))
11977 self.Dst.Serialize(encoder)
11978 encoder.PutUint16(uint16(self.DstOfs))
11979
11980 return nil
11981}
11982
11983func DecodeFlowModSpecSrc0Dst1(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc0Dst1, error) {
11984 _flowmodspecsrc0dst1 := &FlowModSpecSrc0Dst1{FlowModSpec: parent}
11985 if decoder.Length() < 12 {
11986 return nil, fmt.Errorf("FlowModSpecSrc0Dst1 packet too short: %d < 12", decoder.Length())
11987 }
11988 if obj, err := DecodeOxmId(decoder); err != nil {
11989 return nil, err
11990 } else {
11991 _flowmodspecsrc0dst1.Src = obj
11992 }
11993
11994 _flowmodspecsrc0dst1.SrcOfs = uint16(decoder.ReadUint16())
11995 if obj, err := DecodeOxmId(decoder); err != nil {
11996 return nil, err
11997 } else {
11998 _flowmodspecsrc0dst1.Dst = obj
11999 }
12000
12001 _flowmodspecsrc0dst1.DstOfs = uint16(decoder.ReadUint16())
12002 return _flowmodspecsrc0dst1, nil
12003}
12004
12005func NewFlowModSpecSrc0Dst1() *FlowModSpecSrc0Dst1 {
12006 obj := &FlowModSpecSrc0Dst1{
12007 FlowModSpec: NewFlowModSpec(8),
12008 }
12009 return obj
12010}
12011
12012type FlowModSpecSrc0Dst2 struct {
12013 *FlowModSpec
12014 Src goloxi.IOxmId
12015 SrcOfs uint16
12016}
12017
12018type IFlowModSpecSrc0Dst2 interface {
12019 IFlowModSpec
12020 GetSrc() goloxi.IOxmId
12021 GetSrcOfs() uint16
12022}
12023
12024func (self *FlowModSpecSrc0Dst2) GetSrc() goloxi.IOxmId {
12025 return self.Src
12026}
12027
12028func (self *FlowModSpecSrc0Dst2) SetSrc(v goloxi.IOxmId) {
12029 self.Src = v
12030}
12031
12032func (self *FlowModSpecSrc0Dst2) GetSrcOfs() uint16 {
12033 return self.SrcOfs
12034}
12035
12036func (self *FlowModSpecSrc0Dst2) SetSrcOfs(v uint16) {
12037 self.SrcOfs = v
12038}
12039
12040func (self *FlowModSpecSrc0Dst2) Serialize(encoder *goloxi.Encoder) error {
12041 if err := self.FlowModSpec.Serialize(encoder); err != nil {
12042 return err
12043 }
12044
12045 self.Src.Serialize(encoder)
12046 encoder.PutUint16(uint16(self.SrcOfs))
12047
12048 return nil
12049}
12050
12051func DecodeFlowModSpecSrc0Dst2(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc0Dst2, error) {
12052 _flowmodspecsrc0dst2 := &FlowModSpecSrc0Dst2{FlowModSpec: parent}
12053 if decoder.Length() < 6 {
12054 return nil, fmt.Errorf("FlowModSpecSrc0Dst2 packet too short: %d < 6", decoder.Length())
12055 }
12056 if obj, err := DecodeOxmId(decoder); err != nil {
12057 return nil, err
12058 } else {
12059 _flowmodspecsrc0dst2.Src = obj
12060 }
12061
12062 _flowmodspecsrc0dst2.SrcOfs = uint16(decoder.ReadUint16())
12063 return _flowmodspecsrc0dst2, nil
12064}
12065
12066func NewFlowModSpecSrc0Dst2() *FlowModSpecSrc0Dst2 {
12067 obj := &FlowModSpecSrc0Dst2{
12068 FlowModSpec: NewFlowModSpec(16),
12069 }
12070 return obj
12071}
12072
12073type FlowModSpecSrc1Dst0 struct {
12074 *FlowModSpec
12075 Src []byte
12076 Dst goloxi.IOxmId
12077 DstOfs uint16
12078}
12079
12080type IFlowModSpecSrc1Dst0 interface {
12081 IFlowModSpec
12082 GetSrc() []byte
12083 GetDst() goloxi.IOxmId
12084 GetDstOfs() uint16
12085}
12086
12087func (self *FlowModSpecSrc1Dst0) GetSrc() []byte {
12088 return self.Src
12089}
12090
12091func (self *FlowModSpecSrc1Dst0) SetSrc(v []byte) {
12092 self.Src = v
12093}
12094
12095func (self *FlowModSpecSrc1Dst0) GetDst() goloxi.IOxmId {
12096 return self.Dst
12097}
12098
12099func (self *FlowModSpecSrc1Dst0) SetDst(v goloxi.IOxmId) {
12100 self.Dst = v
12101}
12102
12103func (self *FlowModSpecSrc1Dst0) GetDstOfs() uint16 {
12104 return self.DstOfs
12105}
12106
12107func (self *FlowModSpecSrc1Dst0) SetDstOfs(v uint16) {
12108 self.DstOfs = v
12109}
12110
12111func (self *FlowModSpecSrc1Dst0) Serialize(encoder *goloxi.Encoder) error {
12112 if err := self.FlowModSpec.Serialize(encoder); err != nil {
12113 return err
12114 }
12115
12116 encoder.Write(self.Src)
12117 self.Dst.Serialize(encoder)
12118 encoder.PutUint16(uint16(self.DstOfs))
12119
12120 return nil
12121}
12122
12123func DecodeFlowModSpecSrc1Dst0(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc1Dst0, error) {
12124 _flowmodspecsrc1dst0 := &FlowModSpecSrc1Dst0{FlowModSpec: parent}
12125 if decoder.Length() < 6 {
12126 return nil, fmt.Errorf("FlowModSpecSrc1Dst0 packet too short: %d < 6", decoder.Length())
12127 }
12128 _flowmodspecsrc1dst0.Src = decoder.SliceDecoder(int((_flowmodspecsrc1dst0.NBits+15)/16*2), 0).Read(int(_flowmodspecsrc1dst0.NBits))
12129 if obj, err := DecodeOxmId(decoder); err != nil {
12130 return nil, err
12131 } else {
12132 _flowmodspecsrc1dst0.Dst = obj
12133 }
12134
12135 _flowmodspecsrc1dst0.DstOfs = uint16(decoder.ReadUint16())
12136 return _flowmodspecsrc1dst0, nil
12137}
12138
12139func NewFlowModSpecSrc1Dst0() *FlowModSpecSrc1Dst0 {
12140 obj := &FlowModSpecSrc1Dst0{
12141 FlowModSpec: NewFlowModSpec(32),
12142 }
12143 return obj
12144}
12145
12146type FlowModSpecSrc1Dst1 struct {
12147 *FlowModSpec
12148 Src []byte
12149 Dst goloxi.IOxmId
12150 DstOfs uint16
12151}
12152
12153type IFlowModSpecSrc1Dst1 interface {
12154 IFlowModSpec
12155 GetSrc() []byte
12156 GetDst() goloxi.IOxmId
12157 GetDstOfs() uint16
12158}
12159
12160func (self *FlowModSpecSrc1Dst1) GetSrc() []byte {
12161 return self.Src
12162}
12163
12164func (self *FlowModSpecSrc1Dst1) SetSrc(v []byte) {
12165 self.Src = v
12166}
12167
12168func (self *FlowModSpecSrc1Dst1) GetDst() goloxi.IOxmId {
12169 return self.Dst
12170}
12171
12172func (self *FlowModSpecSrc1Dst1) SetDst(v goloxi.IOxmId) {
12173 self.Dst = v
12174}
12175
12176func (self *FlowModSpecSrc1Dst1) GetDstOfs() uint16 {
12177 return self.DstOfs
12178}
12179
12180func (self *FlowModSpecSrc1Dst1) SetDstOfs(v uint16) {
12181 self.DstOfs = v
12182}
12183
12184func (self *FlowModSpecSrc1Dst1) Serialize(encoder *goloxi.Encoder) error {
12185 if err := self.FlowModSpec.Serialize(encoder); err != nil {
12186 return err
12187 }
12188
12189 encoder.Write(self.Src)
12190 self.Dst.Serialize(encoder)
12191 encoder.PutUint16(uint16(self.DstOfs))
12192
12193 return nil
12194}
12195
12196func DecodeFlowModSpecSrc1Dst1(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc1Dst1, error) {
12197 _flowmodspecsrc1dst1 := &FlowModSpecSrc1Dst1{FlowModSpec: parent}
12198 if decoder.Length() < 6 {
12199 return nil, fmt.Errorf("FlowModSpecSrc1Dst1 packet too short: %d < 6", decoder.Length())
12200 }
12201 _flowmodspecsrc1dst1.Src = decoder.SliceDecoder(int((_flowmodspecsrc1dst1.NBits+15)/16*2), 0).Read(int(_flowmodspecsrc1dst1.NBits))
12202 if obj, err := DecodeOxmId(decoder); err != nil {
12203 return nil, err
12204 } else {
12205 _flowmodspecsrc1dst1.Dst = obj
12206 }
12207
12208 _flowmodspecsrc1dst1.DstOfs = uint16(decoder.ReadUint16())
12209 return _flowmodspecsrc1dst1, nil
12210}
12211
12212func NewFlowModSpecSrc1Dst1() *FlowModSpecSrc1Dst1 {
12213 obj := &FlowModSpecSrc1Dst1{
12214 FlowModSpec: NewFlowModSpec(40),
12215 }
12216 return obj
12217}
12218
12219type FlowStatsEntry struct {
12220 Length uint16
12221 TableId uint8
12222 DurationSec uint32
12223 DurationNsec uint32
12224 Priority uint16
12225 IdleTimeout uint16
12226 HardTimeout uint16
12227 Flags FlowModFlags
12228 Cookie uint64
12229 PacketCount uint64
12230 ByteCount uint64
12231 Match Match
12232 Instructions []IInstruction
12233}
12234
12235type IFlowStatsEntry interface {
12236 goloxi.Serializable
12237 GetLength() uint16
12238 GetTableId() uint8
12239 GetDurationSec() uint32
12240 GetDurationNsec() uint32
12241 GetPriority() uint16
12242 GetIdleTimeout() uint16
12243 GetHardTimeout() uint16
12244 GetFlags() FlowModFlags
12245 GetCookie() uint64
12246 GetPacketCount() uint64
12247 GetByteCount() uint64
12248 GetMatch() Match
12249 GetInstructions() []IInstruction
12250}
12251
12252func (self *FlowStatsEntry) GetLength() uint16 {
12253 return self.Length
12254}
12255
12256func (self *FlowStatsEntry) SetLength(v uint16) {
12257 self.Length = v
12258}
12259
12260func (self *FlowStatsEntry) GetTableId() uint8 {
12261 return self.TableId
12262}
12263
12264func (self *FlowStatsEntry) SetTableId(v uint8) {
12265 self.TableId = v
12266}
12267
12268func (self *FlowStatsEntry) GetDurationSec() uint32 {
12269 return self.DurationSec
12270}
12271
12272func (self *FlowStatsEntry) SetDurationSec(v uint32) {
12273 self.DurationSec = v
12274}
12275
12276func (self *FlowStatsEntry) GetDurationNsec() uint32 {
12277 return self.DurationNsec
12278}
12279
12280func (self *FlowStatsEntry) SetDurationNsec(v uint32) {
12281 self.DurationNsec = v
12282}
12283
12284func (self *FlowStatsEntry) GetPriority() uint16 {
12285 return self.Priority
12286}
12287
12288func (self *FlowStatsEntry) SetPriority(v uint16) {
12289 self.Priority = v
12290}
12291
12292func (self *FlowStatsEntry) GetIdleTimeout() uint16 {
12293 return self.IdleTimeout
12294}
12295
12296func (self *FlowStatsEntry) SetIdleTimeout(v uint16) {
12297 self.IdleTimeout = v
12298}
12299
12300func (self *FlowStatsEntry) GetHardTimeout() uint16 {
12301 return self.HardTimeout
12302}
12303
12304func (self *FlowStatsEntry) SetHardTimeout(v uint16) {
12305 self.HardTimeout = v
12306}
12307
12308func (self *FlowStatsEntry) GetFlags() FlowModFlags {
12309 return self.Flags
12310}
12311
12312func (self *FlowStatsEntry) SetFlags(v FlowModFlags) {
12313 self.Flags = v
12314}
12315
12316func (self *FlowStatsEntry) GetCookie() uint64 {
12317 return self.Cookie
12318}
12319
12320func (self *FlowStatsEntry) SetCookie(v uint64) {
12321 self.Cookie = v
12322}
12323
12324func (self *FlowStatsEntry) GetPacketCount() uint64 {
12325 return self.PacketCount
12326}
12327
12328func (self *FlowStatsEntry) SetPacketCount(v uint64) {
12329 self.PacketCount = v
12330}
12331
12332func (self *FlowStatsEntry) GetByteCount() uint64 {
12333 return self.ByteCount
12334}
12335
12336func (self *FlowStatsEntry) SetByteCount(v uint64) {
12337 self.ByteCount = v
12338}
12339
12340func (self *FlowStatsEntry) GetMatch() Match {
12341 return self.Match
12342}
12343
12344func (self *FlowStatsEntry) SetMatch(v Match) {
12345 self.Match = v
12346}
12347
12348func (self *FlowStatsEntry) GetInstructions() []IInstruction {
12349 return self.Instructions
12350}
12351
12352func (self *FlowStatsEntry) SetInstructions(v []IInstruction) {
12353 self.Instructions = v
12354}
12355
12356func (self *FlowStatsEntry) Serialize(encoder *goloxi.Encoder) error {
12357
12358 encoder.PutUint16(uint16(self.Length))
12359 encoder.PutUint8(uint8(self.TableId))
12360 encoder.Write(bytes.Repeat([]byte{0}, 1))
12361 encoder.PutUint32(uint32(self.DurationSec))
12362 encoder.PutUint32(uint32(self.DurationNsec))
12363 encoder.PutUint16(uint16(self.Priority))
12364 encoder.PutUint16(uint16(self.IdleTimeout))
12365 encoder.PutUint16(uint16(self.HardTimeout))
12366 encoder.PutUint16(uint16(self.Flags))
12367 encoder.Write(bytes.Repeat([]byte{0}, 4))
12368 encoder.PutUint64(uint64(self.Cookie))
12369 encoder.PutUint64(uint64(self.PacketCount))
12370 encoder.PutUint64(uint64(self.ByteCount))
12371 if err := self.Match.Serialize(encoder); err != nil {
12372 return err
12373 }
12374
12375 for _, obj := range self.Instructions {
12376 if err := obj.Serialize(encoder); err != nil {
12377 return err
12378 }
12379 }
12380
12381 binary.BigEndian.PutUint16(encoder.Bytes()[0:2], uint16(len(encoder.Bytes())))
12382
12383 return nil
12384}
12385
12386func DecodeFlowStatsEntry(decoder *goloxi.Decoder) (*FlowStatsEntry, error) {
12387 _flowstatsentry := &FlowStatsEntry{}
12388 if decoder.Length() < 56 {
12389 return nil, fmt.Errorf("FlowStatsEntry packet too short: %d < 56", decoder.Length())
12390 }
12391 _flowstatsentry.Length = uint16(decoder.ReadUint16())
12392 oldDecoder := decoder
12393 defer func() { decoder = oldDecoder }()
12394 decoder = decoder.SliceDecoder(int(_flowstatsentry.Length), 2+0)
12395 _flowstatsentry.TableId = uint8(decoder.ReadByte())
12396 decoder.Skip(1)
12397 _flowstatsentry.DurationSec = uint32(decoder.ReadUint32())
12398 _flowstatsentry.DurationNsec = uint32(decoder.ReadUint32())
12399 _flowstatsentry.Priority = uint16(decoder.ReadUint16())
12400 _flowstatsentry.IdleTimeout = uint16(decoder.ReadUint16())
12401 _flowstatsentry.HardTimeout = uint16(decoder.ReadUint16())
12402 _flowstatsentry.Flags = FlowModFlags(decoder.ReadUint16())
12403 decoder.Skip(4)
12404 _flowstatsentry.Cookie = uint64(decoder.ReadUint64())
12405 _flowstatsentry.PacketCount = uint64(decoder.ReadUint64())
12406 _flowstatsentry.ByteCount = uint64(decoder.ReadUint64())
12407 if err := _flowstatsentry.Match.Decode(decoder); err != nil {
12408 return nil, err
12409 }
12410
12411 decoder.SkipAlign()
12412
12413 for decoder.Length() >= 4 {
12414 item, err := DecodeInstruction(decoder)
12415 if err != nil {
12416 return nil, err
12417 }
12418 if item != nil {
12419 _flowstatsentry.Instructions = append(_flowstatsentry.Instructions, item)
12420 }
12421 }
12422 return _flowstatsentry, nil
12423}
12424
12425func NewFlowStatsEntry() *FlowStatsEntry {
12426 obj := &FlowStatsEntry{}
12427 return obj
12428}
12429
12430type GroupDescStatsEntry struct {
12431 Length uint16
12432 GroupType GroupType
12433 GroupId uint32
12434 Buckets []*Bucket
12435}
12436
12437type IGroupDescStatsEntry interface {
12438 goloxi.Serializable
12439 GetLength() uint16
12440 GetGroupType() GroupType
12441 GetGroupId() uint32
12442 GetBuckets() []*Bucket
12443}
12444
12445func (self *GroupDescStatsEntry) GetLength() uint16 {
12446 return self.Length
12447}
12448
12449func (self *GroupDescStatsEntry) SetLength(v uint16) {
12450 self.Length = v
12451}
12452
12453func (self *GroupDescStatsEntry) GetGroupType() GroupType {
12454 return self.GroupType
12455}
12456
12457func (self *GroupDescStatsEntry) SetGroupType(v GroupType) {
12458 self.GroupType = v
12459}
12460
12461func (self *GroupDescStatsEntry) GetGroupId() uint32 {
12462 return self.GroupId
12463}
12464
12465func (self *GroupDescStatsEntry) SetGroupId(v uint32) {
12466 self.GroupId = v
12467}
12468
12469func (self *GroupDescStatsEntry) GetBuckets() []*Bucket {
12470 return self.Buckets
12471}
12472
12473func (self *GroupDescStatsEntry) SetBuckets(v []*Bucket) {
12474 self.Buckets = v
12475}
12476
12477func (self *GroupDescStatsEntry) Serialize(encoder *goloxi.Encoder) error {
12478
12479 encoder.PutUint16(uint16(self.Length))
12480 encoder.PutUint8(uint8(self.GroupType))
12481 encoder.Write(bytes.Repeat([]byte{0}, 1))
12482 encoder.PutUint32(uint32(self.GroupId))
12483 for _, obj := range self.Buckets {
12484 if err := obj.Serialize(encoder); err != nil {
12485 return err
12486 }
12487 }
12488
12489 binary.BigEndian.PutUint16(encoder.Bytes()[0:2], uint16(len(encoder.Bytes())))
12490
12491 return nil
12492}
12493
12494func DecodeGroupDescStatsEntry(decoder *goloxi.Decoder) (*GroupDescStatsEntry, error) {
12495 _groupdescstatsentry := &GroupDescStatsEntry{}
12496 if decoder.Length() < 8 {
12497 return nil, fmt.Errorf("GroupDescStatsEntry packet too short: %d < 8", decoder.Length())
12498 }
12499 _groupdescstatsentry.Length = uint16(decoder.ReadUint16())
12500 oldDecoder := decoder
12501 defer func() { decoder = oldDecoder }()
12502 decoder = decoder.SliceDecoder(int(_groupdescstatsentry.Length), 2+0)
12503 _groupdescstatsentry.GroupType = GroupType(decoder.ReadByte())
12504 decoder.Skip(1)
12505 _groupdescstatsentry.GroupId = uint32(decoder.ReadUint32())
12506
12507 for decoder.Length() >= 16 {
12508 item, err := DecodeBucket(decoder)
12509 if err != nil {
12510 return nil, err
12511 }
12512 if item != nil {
12513 _groupdescstatsentry.Buckets = append(_groupdescstatsentry.Buckets, item)
12514 }
12515 }
12516 return _groupdescstatsentry, nil
12517}
12518
12519func NewGroupDescStatsEntry() *GroupDescStatsEntry {
12520 obj := &GroupDescStatsEntry{}
12521 return obj
12522}
12523
12524type GroupStatsEntry struct {
12525 Length uint16
12526 GroupId uint32
12527 RefCount uint32
12528 PacketCount uint64
12529 ByteCount uint64
12530 DurationSec uint32
12531 DurationNsec uint32
12532 BucketStats []*BucketCounter
12533}
12534
12535type IGroupStatsEntry interface {
12536 goloxi.Serializable
12537 GetLength() uint16
12538 GetGroupId() uint32
12539 GetRefCount() uint32
12540 GetPacketCount() uint64
12541 GetByteCount() uint64
12542 GetDurationSec() uint32
12543 GetDurationNsec() uint32
12544 GetBucketStats() []*BucketCounter
12545}
12546
12547func (self *GroupStatsEntry) GetLength() uint16 {
12548 return self.Length
12549}
12550
12551func (self *GroupStatsEntry) SetLength(v uint16) {
12552 self.Length = v
12553}
12554
12555func (self *GroupStatsEntry) GetGroupId() uint32 {
12556 return self.GroupId
12557}
12558
12559func (self *GroupStatsEntry) SetGroupId(v uint32) {
12560 self.GroupId = v
12561}
12562
12563func (self *GroupStatsEntry) GetRefCount() uint32 {
12564 return self.RefCount
12565}
12566
12567func (self *GroupStatsEntry) SetRefCount(v uint32) {
12568 self.RefCount = v
12569}
12570
12571func (self *GroupStatsEntry) GetPacketCount() uint64 {
12572 return self.PacketCount
12573}
12574
12575func (self *GroupStatsEntry) SetPacketCount(v uint64) {
12576 self.PacketCount = v
12577}
12578
12579func (self *GroupStatsEntry) GetByteCount() uint64 {
12580 return self.ByteCount
12581}
12582
12583func (self *GroupStatsEntry) SetByteCount(v uint64) {
12584 self.ByteCount = v
12585}
12586
12587func (self *GroupStatsEntry) GetDurationSec() uint32 {
12588 return self.DurationSec
12589}
12590
12591func (self *GroupStatsEntry) SetDurationSec(v uint32) {
12592 self.DurationSec = v
12593}
12594
12595func (self *GroupStatsEntry) GetDurationNsec() uint32 {
12596 return self.DurationNsec
12597}
12598
12599func (self *GroupStatsEntry) SetDurationNsec(v uint32) {
12600 self.DurationNsec = v
12601}
12602
12603func (self *GroupStatsEntry) GetBucketStats() []*BucketCounter {
12604 return self.BucketStats
12605}
12606
12607func (self *GroupStatsEntry) SetBucketStats(v []*BucketCounter) {
12608 self.BucketStats = v
12609}
12610
12611func (self *GroupStatsEntry) Serialize(encoder *goloxi.Encoder) error {
12612
12613 encoder.PutUint16(uint16(self.Length))
12614 encoder.Write(bytes.Repeat([]byte{0}, 2))
12615 encoder.PutUint32(uint32(self.GroupId))
12616 encoder.PutUint32(uint32(self.RefCount))
12617 encoder.Write(bytes.Repeat([]byte{0}, 4))
12618 encoder.PutUint64(uint64(self.PacketCount))
12619 encoder.PutUint64(uint64(self.ByteCount))
12620 encoder.PutUint32(uint32(self.DurationSec))
12621 encoder.PutUint32(uint32(self.DurationNsec))
12622 for _, obj := range self.BucketStats {
12623 if err := obj.Serialize(encoder); err != nil {
12624 return err
12625 }
12626 }
12627
12628 binary.BigEndian.PutUint16(encoder.Bytes()[0:2], uint16(len(encoder.Bytes())))
12629
12630 return nil
12631}
12632
12633func DecodeGroupStatsEntry(decoder *goloxi.Decoder) (*GroupStatsEntry, error) {
12634 _groupstatsentry := &GroupStatsEntry{}
12635 if decoder.Length() < 40 {
12636 return nil, fmt.Errorf("GroupStatsEntry packet too short: %d < 40", decoder.Length())
12637 }
12638 _groupstatsentry.Length = uint16(decoder.ReadUint16())
12639 oldDecoder := decoder
12640 defer func() { decoder = oldDecoder }()
12641 decoder = decoder.SliceDecoder(int(_groupstatsentry.Length), 2+0)
12642 decoder.Skip(2)
12643 _groupstatsentry.GroupId = uint32(decoder.ReadUint32())
12644 _groupstatsentry.RefCount = uint32(decoder.ReadUint32())
12645 decoder.Skip(4)
12646 _groupstatsentry.PacketCount = uint64(decoder.ReadUint64())
12647 _groupstatsentry.ByteCount = uint64(decoder.ReadUint64())
12648 _groupstatsentry.DurationSec = uint32(decoder.ReadUint32())
12649 _groupstatsentry.DurationNsec = uint32(decoder.ReadUint32())
12650
12651 for decoder.Length() >= 16 {
12652 item, err := DecodeBucketCounter(decoder)
12653 if err != nil {
12654 return nil, err
12655 }
12656 if item != nil {
12657 _groupstatsentry.BucketStats = append(_groupstatsentry.BucketStats, item)
12658 }
12659 }
12660 return _groupstatsentry, nil
12661}
12662
12663func NewGroupStatsEntry() *GroupStatsEntry {
12664 obj := &GroupStatsEntry{}
12665 return obj
12666}
12667
12668type HelloElem struct {
12669 Type uint16
12670 Length uint16
12671}
12672
12673type IHelloElem interface {
12674 goloxi.Serializable
12675 GetType() uint16
12676 GetLength() uint16
12677}
12678
12679func (self *HelloElem) GetType() uint16 {
12680 return self.Type
12681}
12682
12683func (self *HelloElem) SetType(v uint16) {
12684 self.Type = v
12685}
12686
12687func (self *HelloElem) GetLength() uint16 {
12688 return self.Length
12689}
12690
12691func (self *HelloElem) SetLength(v uint16) {
12692 self.Length = v
12693}
12694
12695func (self *HelloElem) Serialize(encoder *goloxi.Encoder) error {
12696
12697 encoder.PutUint16(uint16(self.Type))
12698 encoder.PutUint16(uint16(self.Length))
12699
12700 return nil
12701}
12702
12703func DecodeHelloElem(decoder *goloxi.Decoder) (IHelloElem, error) {
12704 _helloelem := &HelloElem{}
12705 if decoder.Length() < 4 {
12706 return nil, fmt.Errorf("HelloElem packet too short: %d < 4", decoder.Length())
12707 }
12708 _helloelem.Type = uint16(decoder.ReadUint16())
12709 _helloelem.Length = uint16(decoder.ReadUint16())
12710 oldDecoder := decoder
12711 defer func() { decoder = oldDecoder }()
12712 decoder = decoder.SliceDecoder(int(_helloelem.Length), 2+2)
12713
12714 switch _helloelem.Type {
12715 case 1:
12716 return DecodeHelloElemVersionbitmap(_helloelem, decoder)
12717 default:
12718 return nil, fmt.Errorf("Invalid type '%d' for 'HelloElem'", _helloelem.Type)
12719 }
12720}
12721
12722func NewHelloElem(_type uint16) *HelloElem {
12723 obj := &HelloElem{}
12724 obj.Type = _type
12725 return obj
12726}
12727
12728type HelloElemVersionbitmap struct {
12729 *HelloElem
12730 Bitmaps []*Uint32
12731}
12732
12733type IHelloElemVersionbitmap interface {
12734 IHelloElem
12735 GetBitmaps() []*Uint32
12736}
12737
12738func (self *HelloElemVersionbitmap) GetBitmaps() []*Uint32 {
12739 return self.Bitmaps
12740}
12741
12742func (self *HelloElemVersionbitmap) SetBitmaps(v []*Uint32) {
12743 self.Bitmaps = v
12744}
12745
12746func (self *HelloElemVersionbitmap) Serialize(encoder *goloxi.Encoder) error {
12747 if err := self.HelloElem.Serialize(encoder); err != nil {
12748 return err
12749 }
12750
12751 for _, obj := range self.Bitmaps {
12752 if err := obj.Serialize(encoder); err != nil {
12753 return err
12754 }
12755 }
12756
12757 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
12758
12759 return nil
12760}
12761
12762func DecodeHelloElemVersionbitmap(parent *HelloElem, decoder *goloxi.Decoder) (*HelloElemVersionbitmap, error) {
12763 _helloelemversionbitmap := &HelloElemVersionbitmap{HelloElem: parent}
12764
12765 for decoder.Length() >= 4 {
12766 item, err := DecodeUint32(decoder)
12767 if err != nil {
12768 return nil, err
12769 }
12770 if item != nil {
12771 _helloelemversionbitmap.Bitmaps = append(_helloelemversionbitmap.Bitmaps, item)
12772 }
12773 }
12774 return _helloelemversionbitmap, nil
12775}
12776
12777func NewHelloElemVersionbitmap() *HelloElemVersionbitmap {
12778 obj := &HelloElemVersionbitmap{
12779 HelloElem: NewHelloElem(1),
12780 }
12781 return obj
12782}
12783
12784type InstructionId struct {
12785 Type uint16
12786 Len uint16
12787}
12788
12789type IInstructionId interface {
12790 goloxi.Serializable
12791 GetType() uint16
12792 GetLen() uint16
12793}
12794
12795func (self *InstructionId) GetType() uint16 {
12796 return self.Type
12797}
12798
12799func (self *InstructionId) SetType(v uint16) {
12800 self.Type = v
12801}
12802
12803func (self *InstructionId) GetLen() uint16 {
12804 return self.Len
12805}
12806
12807func (self *InstructionId) SetLen(v uint16) {
12808 self.Len = v
12809}
12810
12811func (self *InstructionId) Serialize(encoder *goloxi.Encoder) error {
12812
12813 encoder.PutUint16(uint16(self.Type))
12814 encoder.PutUint16(uint16(self.Len))
12815
12816 return nil
12817}
12818
12819func DecodeInstructionId(decoder *goloxi.Decoder) (IInstructionId, error) {
12820 _instructionid := &InstructionId{}
12821 if decoder.Length() < 4 {
12822 return nil, fmt.Errorf("InstructionId packet too short: %d < 4", decoder.Length())
12823 }
12824 _instructionid.Type = uint16(decoder.ReadUint16())
12825 _instructionid.Len = uint16(decoder.ReadUint16())
12826 oldDecoder := decoder
12827 defer func() { decoder = oldDecoder }()
12828 decoder = decoder.SliceDecoder(int(_instructionid.Len), 2+2)
12829
12830 switch _instructionid.Type {
12831 case 1:
12832 return DecodeInstructionIdGotoTable(_instructionid, decoder)
12833 case 2:
12834 return DecodeInstructionIdWriteMetadata(_instructionid, decoder)
12835 case 3:
12836 return DecodeInstructionIdWriteActions(_instructionid, decoder)
12837 case 4:
12838 return DecodeInstructionIdApplyActions(_instructionid, decoder)
12839 case 5:
12840 return DecodeInstructionIdClearActions(_instructionid, decoder)
12841 case 6:
12842 return DecodeInstructionIdMeter(_instructionid, decoder)
12843 case 65535:
12844 return DecodeInstructionIdExperimenter(_instructionid, decoder)
12845 default:
12846 return nil, fmt.Errorf("Invalid type '%d' for 'InstructionId'", _instructionid.Type)
12847 }
12848}
12849
12850func NewInstructionId(_type uint16) *InstructionId {
12851 obj := &InstructionId{}
12852 obj.Type = _type
12853 return obj
12854}
12855
12856type InstructionIdApplyActions struct {
12857 *InstructionId
12858}
12859
12860type IInstructionIdApplyActions interface {
12861 IInstructionId
12862}
12863
12864func (self *InstructionIdApplyActions) Serialize(encoder *goloxi.Encoder) error {
12865 if err := self.InstructionId.Serialize(encoder); err != nil {
12866 return err
12867 }
12868
12869 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
12870
12871 return nil
12872}
12873
12874func DecodeInstructionIdApplyActions(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdApplyActions, error) {
12875 _instructionidapplyactions := &InstructionIdApplyActions{InstructionId: parent}
12876 return _instructionidapplyactions, nil
12877}
12878
12879func NewInstructionIdApplyActions() *InstructionIdApplyActions {
12880 obj := &InstructionIdApplyActions{
12881 InstructionId: NewInstructionId(4),
12882 }
12883 return obj
12884}
12885
12886type InstructionIdExperimenter struct {
12887 *InstructionId
12888 Experimenter uint32
12889}
12890
12891type IInstructionIdExperimenter interface {
12892 IInstructionId
12893 GetExperimenter() uint32
12894}
12895
12896func (self *InstructionIdExperimenter) GetExperimenter() uint32 {
12897 return self.Experimenter
12898}
12899
12900func (self *InstructionIdExperimenter) SetExperimenter(v uint32) {
12901 self.Experimenter = v
12902}
12903
12904func (self *InstructionIdExperimenter) Serialize(encoder *goloxi.Encoder) error {
12905 if err := self.InstructionId.Serialize(encoder); err != nil {
12906 return err
12907 }
12908
12909 encoder.PutUint32(uint32(self.Experimenter))
12910
12911 return nil
12912}
12913
12914func DecodeInstructionIdExperimenter(parent *InstructionId, decoder *goloxi.Decoder) (IInstructionIdExperimenter, error) {
12915 _instructionidexperimenter := &InstructionIdExperimenter{InstructionId: parent}
12916 if decoder.Length() < 4 {
12917 return nil, fmt.Errorf("InstructionIdExperimenter packet too short: %d < 4", decoder.Length())
12918 }
12919 _instructionidexperimenter.Experimenter = uint32(decoder.ReadUint32())
12920
12921 switch _instructionidexperimenter.Experimenter {
12922 case 6035143:
12923 return DecodeInstructionIdBsn(_instructionidexperimenter, decoder)
12924 default:
12925 return nil, fmt.Errorf("Invalid type '%d' for 'InstructionIdExperimenter'", _instructionidexperimenter.Experimenter)
12926 }
12927}
12928
12929func NewInstructionIdExperimenter(_experimenter uint32) *InstructionIdExperimenter {
12930 obj := &InstructionIdExperimenter{
12931 InstructionId: NewInstructionId(65535),
12932 }
12933 obj.Experimenter = _experimenter
12934 return obj
12935}
12936
12937type InstructionIdBsn struct {
12938 *InstructionIdExperimenter
12939 Subtype uint32
12940}
12941
12942type IInstructionIdBsn interface {
12943 IInstructionIdExperimenter
12944 GetSubtype() uint32
12945}
12946
12947func (self *InstructionIdBsn) GetSubtype() uint32 {
12948 return self.Subtype
12949}
12950
12951func (self *InstructionIdBsn) SetSubtype(v uint32) {
12952 self.Subtype = v
12953}
12954
12955func (self *InstructionIdBsn) Serialize(encoder *goloxi.Encoder) error {
12956 if err := self.InstructionIdExperimenter.Serialize(encoder); err != nil {
12957 return err
12958 }
12959
12960 encoder.PutUint32(uint32(self.Subtype))
12961
12962 return nil
12963}
12964
12965func DecodeInstructionIdBsn(parent *InstructionIdExperimenter, decoder *goloxi.Decoder) (IInstructionIdBsn, error) {
12966 _instructionidbsn := &InstructionIdBsn{InstructionIdExperimenter: parent}
12967 if decoder.Length() < 4 {
12968 return nil, fmt.Errorf("InstructionIdBsn packet too short: %d < 4", decoder.Length())
12969 }
12970 _instructionidbsn.Subtype = uint32(decoder.ReadUint32())
12971
12972 switch _instructionidbsn.Subtype {
12973 case 0:
12974 return DecodeInstructionIdBsnDisableSrcMacCheck(_instructionidbsn, decoder)
12975 case 1:
12976 return DecodeInstructionIdBsnArpOffload(_instructionidbsn, decoder)
12977 case 2:
12978 return DecodeInstructionIdBsnDhcpOffload(_instructionidbsn, decoder)
12979 case 3:
12980 return DecodeInstructionIdBsnDisableSplitHorizonCheck(_instructionidbsn, decoder)
12981 case 4:
12982 return DecodeInstructionIdBsnPermit(_instructionidbsn, decoder)
12983 case 5:
12984 return DecodeInstructionIdBsnDeny(_instructionidbsn, decoder)
12985 case 6:
12986 return DecodeInstructionIdBsnPacketOfDeath(_instructionidbsn, decoder)
12987 case 7:
12988 return DecodeInstructionIdBsnPrioritizePdus(_instructionidbsn, decoder)
12989 case 8:
12990 return DecodeInstructionIdBsnRequireVlanXlate(_instructionidbsn, decoder)
12991 case 9:
12992 return DecodeInstructionIdBsnDisableVlanCounters(_instructionidbsn, decoder)
12993 case 10:
12994 return DecodeInstructionIdBsnSpanDestination(_instructionidbsn, decoder)
12995 case 11:
12996 return DecodeInstructionIdBsnAutoNegotiation(_instructionidbsn, decoder)
12997 case 12:
12998 return DecodeInstructionIdBsnInternalPriority(_instructionidbsn, decoder)
12999 case 13:
13000 return DecodeInstructionIdBsnDisableL3(_instructionidbsn, decoder)
13001 case 14:
13002 return DecodeInstructionIdBsnNdpOffload(_instructionidbsn, decoder)
13003 case 15:
13004 return DecodeInstructionIdBsnHashSelect(_instructionidbsn, decoder)
13005 case 16:
13006 return DecodeInstructionIdBsnDirectedBroadcast(_instructionidbsn, decoder)
13007 default:
13008 return nil, fmt.Errorf("Invalid type '%d' for 'InstructionIdBsn'", _instructionidbsn.Subtype)
13009 }
13010}
13011
13012func NewInstructionIdBsn(_subtype uint32) *InstructionIdBsn {
13013 obj := &InstructionIdBsn{
13014 InstructionIdExperimenter: NewInstructionIdExperimenter(6035143),
13015 }
13016 obj.Subtype = _subtype
13017 return obj
13018}
13019
13020type InstructionIdBsnArpOffload struct {
13021 *InstructionIdBsn
13022}
13023
13024type IInstructionIdBsnArpOffload interface {
13025 IInstructionIdBsn
13026}
13027
13028func (self *InstructionIdBsnArpOffload) Serialize(encoder *goloxi.Encoder) error {
13029 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
13030 return err
13031 }
13032
13033 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
13034
13035 return nil
13036}
13037
13038func DecodeInstructionIdBsnArpOffload(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnArpOffload, error) {
13039 _instructionidbsnarpoffload := &InstructionIdBsnArpOffload{InstructionIdBsn: parent}
13040 return _instructionidbsnarpoffload, nil
13041}
13042
13043func NewInstructionIdBsnArpOffload() *InstructionIdBsnArpOffload {
13044 obj := &InstructionIdBsnArpOffload{
13045 InstructionIdBsn: NewInstructionIdBsn(1),
13046 }
13047 return obj
13048}
13049
13050type InstructionIdBsnAutoNegotiation struct {
13051 *InstructionIdBsn
13052}
13053
13054type IInstructionIdBsnAutoNegotiation interface {
13055 IInstructionIdBsn
13056}
13057
13058func (self *InstructionIdBsnAutoNegotiation) Serialize(encoder *goloxi.Encoder) error {
13059 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
13060 return err
13061 }
13062
13063 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
13064
13065 return nil
13066}
13067
13068func DecodeInstructionIdBsnAutoNegotiation(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnAutoNegotiation, error) {
13069 _instructionidbsnautonegotiation := &InstructionIdBsnAutoNegotiation{InstructionIdBsn: parent}
13070 return _instructionidbsnautonegotiation, nil
13071}
13072
13073func NewInstructionIdBsnAutoNegotiation() *InstructionIdBsnAutoNegotiation {
13074 obj := &InstructionIdBsnAutoNegotiation{
13075 InstructionIdBsn: NewInstructionIdBsn(11),
13076 }
13077 return obj
13078}
13079
13080type InstructionIdBsnDeny struct {
13081 *InstructionIdBsn
13082}
13083
13084type IInstructionIdBsnDeny interface {
13085 IInstructionIdBsn
13086}
13087
13088func (self *InstructionIdBsnDeny) Serialize(encoder *goloxi.Encoder) error {
13089 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
13090 return err
13091 }
13092
13093 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
13094
13095 return nil
13096}
13097
13098func DecodeInstructionIdBsnDeny(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnDeny, error) {
13099 _instructionidbsndeny := &InstructionIdBsnDeny{InstructionIdBsn: parent}
13100 return _instructionidbsndeny, nil
13101}
13102
13103func NewInstructionIdBsnDeny() *InstructionIdBsnDeny {
13104 obj := &InstructionIdBsnDeny{
13105 InstructionIdBsn: NewInstructionIdBsn(5),
13106 }
13107 return obj
13108}
13109
13110type InstructionIdBsnDhcpOffload struct {
13111 *InstructionIdBsn
13112}
13113
13114type IInstructionIdBsnDhcpOffload interface {
13115 IInstructionIdBsn
13116}
13117
13118func (self *InstructionIdBsnDhcpOffload) Serialize(encoder *goloxi.Encoder) error {
13119 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
13120 return err
13121 }
13122
13123 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
13124
13125 return nil
13126}
13127
13128func DecodeInstructionIdBsnDhcpOffload(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnDhcpOffload, error) {
13129 _instructionidbsndhcpoffload := &InstructionIdBsnDhcpOffload{InstructionIdBsn: parent}
13130 return _instructionidbsndhcpoffload, nil
13131}
13132
13133func NewInstructionIdBsnDhcpOffload() *InstructionIdBsnDhcpOffload {
13134 obj := &InstructionIdBsnDhcpOffload{
13135 InstructionIdBsn: NewInstructionIdBsn(2),
13136 }
13137 return obj
13138}
13139
13140type InstructionIdBsnDirectedBroadcast struct {
13141 *InstructionIdBsn
13142}
13143
13144type IInstructionIdBsnDirectedBroadcast interface {
13145 IInstructionIdBsn
13146}
13147
13148func (self *InstructionIdBsnDirectedBroadcast) Serialize(encoder *goloxi.Encoder) error {
13149 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
13150 return err
13151 }
13152
13153 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
13154
13155 return nil
13156}
13157
13158func DecodeInstructionIdBsnDirectedBroadcast(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnDirectedBroadcast, error) {
13159 _instructionidbsndirectedbroadcast := &InstructionIdBsnDirectedBroadcast{InstructionIdBsn: parent}
13160 return _instructionidbsndirectedbroadcast, nil
13161}
13162
13163func NewInstructionIdBsnDirectedBroadcast() *InstructionIdBsnDirectedBroadcast {
13164 obj := &InstructionIdBsnDirectedBroadcast{
13165 InstructionIdBsn: NewInstructionIdBsn(16),
13166 }
13167 return obj
13168}
13169
13170type InstructionIdBsnDisableL3 struct {
13171 *InstructionIdBsn
13172}
13173
13174type IInstructionIdBsnDisableL3 interface {
13175 IInstructionIdBsn
13176}
13177
13178func (self *InstructionIdBsnDisableL3) Serialize(encoder *goloxi.Encoder) error {
13179 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
13180 return err
13181 }
13182
13183 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
13184
13185 return nil
13186}
13187
13188func DecodeInstructionIdBsnDisableL3(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnDisableL3, error) {
13189 _instructionidbsndisablel3 := &InstructionIdBsnDisableL3{InstructionIdBsn: parent}
13190 return _instructionidbsndisablel3, nil
13191}
13192
13193func NewInstructionIdBsnDisableL3() *InstructionIdBsnDisableL3 {
13194 obj := &InstructionIdBsnDisableL3{
13195 InstructionIdBsn: NewInstructionIdBsn(13),
13196 }
13197 return obj
13198}
13199
13200type InstructionIdBsnDisableSplitHorizonCheck struct {
13201 *InstructionIdBsn
13202}
13203
13204type IInstructionIdBsnDisableSplitHorizonCheck interface {
13205 IInstructionIdBsn
13206}
13207
13208func (self *InstructionIdBsnDisableSplitHorizonCheck) Serialize(encoder *goloxi.Encoder) error {
13209 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
13210 return err
13211 }
13212
13213 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
13214
13215 return nil
13216}
13217
13218func DecodeInstructionIdBsnDisableSplitHorizonCheck(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnDisableSplitHorizonCheck, error) {
13219 _instructionidbsndisablesplithorizoncheck := &InstructionIdBsnDisableSplitHorizonCheck{InstructionIdBsn: parent}
13220 return _instructionidbsndisablesplithorizoncheck, nil
13221}
13222
13223func NewInstructionIdBsnDisableSplitHorizonCheck() *InstructionIdBsnDisableSplitHorizonCheck {
13224 obj := &InstructionIdBsnDisableSplitHorizonCheck{
13225 InstructionIdBsn: NewInstructionIdBsn(3),
13226 }
13227 return obj
13228}
13229
13230type InstructionIdBsnDisableSrcMacCheck struct {
13231 *InstructionIdBsn
13232}
13233
13234type IInstructionIdBsnDisableSrcMacCheck interface {
13235 IInstructionIdBsn
13236}
13237
13238func (self *InstructionIdBsnDisableSrcMacCheck) Serialize(encoder *goloxi.Encoder) error {
13239 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
13240 return err
13241 }
13242
13243 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
13244
13245 return nil
13246}
13247
13248func DecodeInstructionIdBsnDisableSrcMacCheck(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnDisableSrcMacCheck, error) {
13249 _instructionidbsndisablesrcmaccheck := &InstructionIdBsnDisableSrcMacCheck{InstructionIdBsn: parent}
13250 return _instructionidbsndisablesrcmaccheck, nil
13251}
13252
13253func NewInstructionIdBsnDisableSrcMacCheck() *InstructionIdBsnDisableSrcMacCheck {
13254 obj := &InstructionIdBsnDisableSrcMacCheck{
13255 InstructionIdBsn: NewInstructionIdBsn(0),
13256 }
13257 return obj
13258}
13259
13260type InstructionIdBsnDisableVlanCounters struct {
13261 *InstructionIdBsn
13262}
13263
13264type IInstructionIdBsnDisableVlanCounters interface {
13265 IInstructionIdBsn
13266}
13267
13268func (self *InstructionIdBsnDisableVlanCounters) Serialize(encoder *goloxi.Encoder) error {
13269 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
13270 return err
13271 }
13272
13273 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
13274
13275 return nil
13276}
13277
13278func DecodeInstructionIdBsnDisableVlanCounters(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnDisableVlanCounters, error) {
13279 _instructionidbsndisablevlancounters := &InstructionIdBsnDisableVlanCounters{InstructionIdBsn: parent}
13280 return _instructionidbsndisablevlancounters, nil
13281}
13282
13283func NewInstructionIdBsnDisableVlanCounters() *InstructionIdBsnDisableVlanCounters {
13284 obj := &InstructionIdBsnDisableVlanCounters{
13285 InstructionIdBsn: NewInstructionIdBsn(9),
13286 }
13287 return obj
13288}
13289
13290type InstructionIdBsnHashSelect struct {
13291 *InstructionIdBsn
13292}
13293
13294type IInstructionIdBsnHashSelect interface {
13295 IInstructionIdBsn
13296}
13297
13298func (self *InstructionIdBsnHashSelect) Serialize(encoder *goloxi.Encoder) error {
13299 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
13300 return err
13301 }
13302
13303 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
13304
13305 return nil
13306}
13307
13308func DecodeInstructionIdBsnHashSelect(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnHashSelect, error) {
13309 _instructionidbsnhashselect := &InstructionIdBsnHashSelect{InstructionIdBsn: parent}
13310 return _instructionidbsnhashselect, nil
13311}
13312
13313func NewInstructionIdBsnHashSelect() *InstructionIdBsnHashSelect {
13314 obj := &InstructionIdBsnHashSelect{
13315 InstructionIdBsn: NewInstructionIdBsn(15),
13316 }
13317 return obj
13318}
13319
13320type InstructionIdBsnInternalPriority struct {
13321 *InstructionIdBsn
13322}
13323
13324type IInstructionIdBsnInternalPriority interface {
13325 IInstructionIdBsn
13326}
13327
13328func (self *InstructionIdBsnInternalPriority) Serialize(encoder *goloxi.Encoder) error {
13329 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
13330 return err
13331 }
13332
13333 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
13334
13335 return nil
13336}
13337
13338func DecodeInstructionIdBsnInternalPriority(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnInternalPriority, error) {
13339 _instructionidbsninternalpriority := &InstructionIdBsnInternalPriority{InstructionIdBsn: parent}
13340 return _instructionidbsninternalpriority, nil
13341}
13342
13343func NewInstructionIdBsnInternalPriority() *InstructionIdBsnInternalPriority {
13344 obj := &InstructionIdBsnInternalPriority{
13345 InstructionIdBsn: NewInstructionIdBsn(12),
13346 }
13347 return obj
13348}
13349
13350type InstructionIdBsnNdpOffload struct {
13351 *InstructionIdBsn
13352}
13353
13354type IInstructionIdBsnNdpOffload interface {
13355 IInstructionIdBsn
13356}
13357
13358func (self *InstructionIdBsnNdpOffload) Serialize(encoder *goloxi.Encoder) error {
13359 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
13360 return err
13361 }
13362
13363 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
13364
13365 return nil
13366}
13367
13368func DecodeInstructionIdBsnNdpOffload(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnNdpOffload, error) {
13369 _instructionidbsnndpoffload := &InstructionIdBsnNdpOffload{InstructionIdBsn: parent}
13370 return _instructionidbsnndpoffload, nil
13371}
13372
13373func NewInstructionIdBsnNdpOffload() *InstructionIdBsnNdpOffload {
13374 obj := &InstructionIdBsnNdpOffload{
13375 InstructionIdBsn: NewInstructionIdBsn(14),
13376 }
13377 return obj
13378}
13379
13380type InstructionIdBsnPacketOfDeath struct {
13381 *InstructionIdBsn
13382}
13383
13384type IInstructionIdBsnPacketOfDeath interface {
13385 IInstructionIdBsn
13386}
13387
13388func (self *InstructionIdBsnPacketOfDeath) Serialize(encoder *goloxi.Encoder) error {
13389 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
13390 return err
13391 }
13392
13393 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
13394
13395 return nil
13396}
13397
13398func DecodeInstructionIdBsnPacketOfDeath(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnPacketOfDeath, error) {
13399 _instructionidbsnpacketofdeath := &InstructionIdBsnPacketOfDeath{InstructionIdBsn: parent}
13400 return _instructionidbsnpacketofdeath, nil
13401}
13402
13403func NewInstructionIdBsnPacketOfDeath() *InstructionIdBsnPacketOfDeath {
13404 obj := &InstructionIdBsnPacketOfDeath{
13405 InstructionIdBsn: NewInstructionIdBsn(6),
13406 }
13407 return obj
13408}
13409
13410type InstructionIdBsnPermit struct {
13411 *InstructionIdBsn
13412}
13413
13414type IInstructionIdBsnPermit interface {
13415 IInstructionIdBsn
13416}
13417
13418func (self *InstructionIdBsnPermit) Serialize(encoder *goloxi.Encoder) error {
13419 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
13420 return err
13421 }
13422
13423 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
13424
13425 return nil
13426}
13427
13428func DecodeInstructionIdBsnPermit(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnPermit, error) {
13429 _instructionidbsnpermit := &InstructionIdBsnPermit{InstructionIdBsn: parent}
13430 return _instructionidbsnpermit, nil
13431}
13432
13433func NewInstructionIdBsnPermit() *InstructionIdBsnPermit {
13434 obj := &InstructionIdBsnPermit{
13435 InstructionIdBsn: NewInstructionIdBsn(4),
13436 }
13437 return obj
13438}
13439
13440type InstructionIdBsnPrioritizePdus struct {
13441 *InstructionIdBsn
13442}
13443
13444type IInstructionIdBsnPrioritizePdus interface {
13445 IInstructionIdBsn
13446}
13447
13448func (self *InstructionIdBsnPrioritizePdus) Serialize(encoder *goloxi.Encoder) error {
13449 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
13450 return err
13451 }
13452
13453 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
13454
13455 return nil
13456}
13457
13458func DecodeInstructionIdBsnPrioritizePdus(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnPrioritizePdus, error) {
13459 _instructionidbsnprioritizepdus := &InstructionIdBsnPrioritizePdus{InstructionIdBsn: parent}
13460 return _instructionidbsnprioritizepdus, nil
13461}
13462
13463func NewInstructionIdBsnPrioritizePdus() *InstructionIdBsnPrioritizePdus {
13464 obj := &InstructionIdBsnPrioritizePdus{
13465 InstructionIdBsn: NewInstructionIdBsn(7),
13466 }
13467 return obj
13468}
13469
13470type InstructionIdBsnRequireVlanXlate struct {
13471 *InstructionIdBsn
13472}
13473
13474type IInstructionIdBsnRequireVlanXlate interface {
13475 IInstructionIdBsn
13476}
13477
13478func (self *InstructionIdBsnRequireVlanXlate) Serialize(encoder *goloxi.Encoder) error {
13479 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
13480 return err
13481 }
13482
13483 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
13484
13485 return nil
13486}
13487
13488func DecodeInstructionIdBsnRequireVlanXlate(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnRequireVlanXlate, error) {
13489 _instructionidbsnrequirevlanxlate := &InstructionIdBsnRequireVlanXlate{InstructionIdBsn: parent}
13490 return _instructionidbsnrequirevlanxlate, nil
13491}
13492
13493func NewInstructionIdBsnRequireVlanXlate() *InstructionIdBsnRequireVlanXlate {
13494 obj := &InstructionIdBsnRequireVlanXlate{
13495 InstructionIdBsn: NewInstructionIdBsn(8),
13496 }
13497 return obj
13498}
13499
13500type InstructionIdBsnSpanDestination struct {
13501 *InstructionIdBsn
13502}
13503
13504type IInstructionIdBsnSpanDestination interface {
13505 IInstructionIdBsn
13506}
13507
13508func (self *InstructionIdBsnSpanDestination) Serialize(encoder *goloxi.Encoder) error {
13509 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
13510 return err
13511 }
13512
13513 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
13514
13515 return nil
13516}
13517
13518func DecodeInstructionIdBsnSpanDestination(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnSpanDestination, error) {
13519 _instructionidbsnspandestination := &InstructionIdBsnSpanDestination{InstructionIdBsn: parent}
13520 return _instructionidbsnspandestination, nil
13521}
13522
13523func NewInstructionIdBsnSpanDestination() *InstructionIdBsnSpanDestination {
13524 obj := &InstructionIdBsnSpanDestination{
13525 InstructionIdBsn: NewInstructionIdBsn(10),
13526 }
13527 return obj
13528}
13529
13530type InstructionIdClearActions struct {
13531 *InstructionId
13532}
13533
13534type IInstructionIdClearActions interface {
13535 IInstructionId
13536}
13537
13538func (self *InstructionIdClearActions) Serialize(encoder *goloxi.Encoder) error {
13539 if err := self.InstructionId.Serialize(encoder); err != nil {
13540 return err
13541 }
13542
13543 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
13544
13545 return nil
13546}
13547
13548func DecodeInstructionIdClearActions(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdClearActions, error) {
13549 _instructionidclearactions := &InstructionIdClearActions{InstructionId: parent}
13550 return _instructionidclearactions, nil
13551}
13552
13553func NewInstructionIdClearActions() *InstructionIdClearActions {
13554 obj := &InstructionIdClearActions{
13555 InstructionId: NewInstructionId(5),
13556 }
13557 return obj
13558}
13559
13560type InstructionIdGotoTable struct {
13561 *InstructionId
13562}
13563
13564type IInstructionIdGotoTable interface {
13565 IInstructionId
13566}
13567
13568func (self *InstructionIdGotoTable) Serialize(encoder *goloxi.Encoder) error {
13569 if err := self.InstructionId.Serialize(encoder); err != nil {
13570 return err
13571 }
13572
13573 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
13574
13575 return nil
13576}
13577
13578func DecodeInstructionIdGotoTable(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdGotoTable, error) {
13579 _instructionidgototable := &InstructionIdGotoTable{InstructionId: parent}
13580 return _instructionidgototable, nil
13581}
13582
13583func NewInstructionIdGotoTable() *InstructionIdGotoTable {
13584 obj := &InstructionIdGotoTable{
13585 InstructionId: NewInstructionId(1),
13586 }
13587 return obj
13588}
13589
13590type InstructionIdMeter struct {
13591 *InstructionId
13592}
13593
13594type IInstructionIdMeter interface {
13595 IInstructionId
13596}
13597
13598func (self *InstructionIdMeter) Serialize(encoder *goloxi.Encoder) error {
13599 if err := self.InstructionId.Serialize(encoder); err != nil {
13600 return err
13601 }
13602
13603 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
13604
13605 return nil
13606}
13607
13608func DecodeInstructionIdMeter(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdMeter, error) {
13609 _instructionidmeter := &InstructionIdMeter{InstructionId: parent}
13610 return _instructionidmeter, nil
13611}
13612
13613func NewInstructionIdMeter() *InstructionIdMeter {
13614 obj := &InstructionIdMeter{
13615 InstructionId: NewInstructionId(6),
13616 }
13617 return obj
13618}
13619
13620type InstructionIdWriteActions struct {
13621 *InstructionId
13622}
13623
13624type IInstructionIdWriteActions interface {
13625 IInstructionId
13626}
13627
13628func (self *InstructionIdWriteActions) Serialize(encoder *goloxi.Encoder) error {
13629 if err := self.InstructionId.Serialize(encoder); err != nil {
13630 return err
13631 }
13632
13633 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
13634
13635 return nil
13636}
13637
13638func DecodeInstructionIdWriteActions(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdWriteActions, error) {
13639 _instructionidwriteactions := &InstructionIdWriteActions{InstructionId: parent}
13640 return _instructionidwriteactions, nil
13641}
13642
13643func NewInstructionIdWriteActions() *InstructionIdWriteActions {
13644 obj := &InstructionIdWriteActions{
13645 InstructionId: NewInstructionId(3),
13646 }
13647 return obj
13648}
13649
13650type InstructionIdWriteMetadata struct {
13651 *InstructionId
13652}
13653
13654type IInstructionIdWriteMetadata interface {
13655 IInstructionId
13656}
13657
13658func (self *InstructionIdWriteMetadata) Serialize(encoder *goloxi.Encoder) error {
13659 if err := self.InstructionId.Serialize(encoder); err != nil {
13660 return err
13661 }
13662
13663 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
13664
13665 return nil
13666}
13667
13668func DecodeInstructionIdWriteMetadata(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdWriteMetadata, error) {
13669 _instructionidwritemetadata := &InstructionIdWriteMetadata{InstructionId: parent}
13670 return _instructionidwritemetadata, nil
13671}
13672
13673func NewInstructionIdWriteMetadata() *InstructionIdWriteMetadata {
13674 obj := &InstructionIdWriteMetadata{
13675 InstructionId: NewInstructionId(2),
13676 }
13677 return obj
13678}
13679
13680type MatchV3 struct {
13681 Type uint16
13682 Length uint16
13683 OxmList []goloxi.IOxm
13684}
13685
13686type IMatchV3 interface {
13687 goloxi.Serializable
13688 GetType() uint16
13689 GetLength() uint16
13690 GetOxmList() []goloxi.IOxm
13691}
13692
13693func (self *MatchV3) GetType() uint16 {
13694 return self.Type
13695}
13696
13697func (self *MatchV3) SetType(v uint16) {
13698 self.Type = v
13699}
13700
13701func (self *MatchV3) GetLength() uint16 {
13702 return self.Length
13703}
13704
13705func (self *MatchV3) SetLength(v uint16) {
13706 self.Length = v
13707}
13708
13709func (self *MatchV3) GetOxmList() []goloxi.IOxm {
13710 return self.OxmList
13711}
13712
13713func (self *MatchV3) SetOxmList(v []goloxi.IOxm) {
13714 self.OxmList = v
13715}
13716
13717func (self *MatchV3) Serialize(encoder *goloxi.Encoder) error {
13718
13719 encoder.PutUint16(uint16(self.Type))
13720 encoder.PutUint16(uint16(self.Length))
13721 for _, obj := range self.OxmList {
13722 if err := obj.Serialize(encoder); err != nil {
13723 return err
13724 }
13725 }
13726
13727 encoder.SkipAlign()
13728
13729 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
13730
13731 return nil
13732}
13733func (self *MatchV3) Decode(decoder *goloxi.Decoder) error {
13734 if decoder.Length() < 4 {
13735 return fmt.Errorf("MatchV3 packet too short: %d < 4", decoder.Length())
13736 }
13737
13738 defer decoder.SkipAlign()
13739
13740 self.Type = uint16(decoder.ReadUint16())
13741 self.Length = uint16(decoder.ReadUint16())
13742 oldDecoder := decoder
13743 defer func() { decoder = oldDecoder }()
13744 decoder = decoder.SliceDecoder(int(((self.Length)+7)/8*8), 2+2)
13745
13746 for decoder.Length() >= 4 {
13747 item, err := DecodeOxm(decoder)
13748 if err != nil {
13749 return err
13750 }
13751 if item != nil {
13752 self.OxmList = append(self.OxmList, item)
13753 }
13754 }
13755
13756 return nil
13757}
13758
13759func NewMatchV3() *MatchV3 {
13760 obj := &MatchV3{}
13761 return obj
13762}
13763
13764type MeterBand struct {
13765 Type uint16
13766 Len uint16
13767}
13768
13769type IMeterBand interface {
13770 goloxi.Serializable
13771 GetType() uint16
13772 GetLen() uint16
13773}
13774
13775func (self *MeterBand) GetType() uint16 {
13776 return self.Type
13777}
13778
13779func (self *MeterBand) SetType(v uint16) {
13780 self.Type = v
13781}
13782
13783func (self *MeterBand) GetLen() uint16 {
13784 return self.Len
13785}
13786
13787func (self *MeterBand) SetLen(v uint16) {
13788 self.Len = v
13789}
13790
13791func (self *MeterBand) Serialize(encoder *goloxi.Encoder) error {
13792
13793 encoder.PutUint16(uint16(self.Type))
13794 encoder.PutUint16(uint16(self.Len))
13795
13796 return nil
13797}
13798
13799func DecodeMeterBand(decoder *goloxi.Decoder) (IMeterBand, error) {
13800 _meterband := &MeterBand{}
13801 if decoder.Length() < 4 {
13802 return nil, fmt.Errorf("MeterBand packet too short: %d < 4", decoder.Length())
13803 }
13804 _meterband.Type = uint16(decoder.ReadUint16())
13805 _meterband.Len = uint16(decoder.ReadUint16())
13806 oldDecoder := decoder
13807 defer func() { decoder = oldDecoder }()
13808 decoder = decoder.SliceDecoder(int(_meterband.Len), 2+2)
13809
13810 switch _meterband.Type {
13811 case 1:
13812 return DecodeMeterBandDrop(_meterband, decoder)
13813 case 2:
13814 return DecodeMeterBandDscpRemark(_meterband, decoder)
13815 case 65535:
13816 return DecodeMeterBandExperimenter(_meterband, decoder)
13817 default:
13818 return nil, fmt.Errorf("Invalid type '%d' for 'MeterBand'", _meterband.Type)
13819 }
13820}
13821
13822func NewMeterBand(_type uint16) *MeterBand {
13823 obj := &MeterBand{}
13824 obj.Type = _type
13825 return obj
13826}
13827
13828type MeterBandDrop struct {
13829 *MeterBand
13830 Rate uint32
13831 BurstSize uint32
13832}
13833
13834type IMeterBandDrop interface {
13835 IMeterBand
13836 GetRate() uint32
13837 GetBurstSize() uint32
13838}
13839
13840func (self *MeterBandDrop) GetRate() uint32 {
13841 return self.Rate
13842}
13843
13844func (self *MeterBandDrop) SetRate(v uint32) {
13845 self.Rate = v
13846}
13847
13848func (self *MeterBandDrop) GetBurstSize() uint32 {
13849 return self.BurstSize
13850}
13851
13852func (self *MeterBandDrop) SetBurstSize(v uint32) {
13853 self.BurstSize = v
13854}
13855
13856func (self *MeterBandDrop) Serialize(encoder *goloxi.Encoder) error {
13857 if err := self.MeterBand.Serialize(encoder); err != nil {
13858 return err
13859 }
13860
13861 encoder.PutUint32(uint32(self.Rate))
13862 encoder.PutUint32(uint32(self.BurstSize))
13863 encoder.Write(bytes.Repeat([]byte{0}, 4))
13864
13865 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
13866
13867 return nil
13868}
13869
13870func DecodeMeterBandDrop(parent *MeterBand, decoder *goloxi.Decoder) (*MeterBandDrop, error) {
13871 _meterbanddrop := &MeterBandDrop{MeterBand: parent}
13872 if decoder.Length() < 12 {
13873 return nil, fmt.Errorf("MeterBandDrop packet too short: %d < 12", decoder.Length())
13874 }
13875 _meterbanddrop.Rate = uint32(decoder.ReadUint32())
13876 _meterbanddrop.BurstSize = uint32(decoder.ReadUint32())
13877 decoder.Skip(4)
13878 return _meterbanddrop, nil
13879}
13880
13881func NewMeterBandDrop() *MeterBandDrop {
13882 obj := &MeterBandDrop{
13883 MeterBand: NewMeterBand(1),
13884 }
13885 return obj
13886}
13887
13888type MeterBandDscpRemark struct {
13889 *MeterBand
13890 Rate uint32
13891 BurstSize uint32
13892 PrecLevel uint8
13893}
13894
13895type IMeterBandDscpRemark interface {
13896 IMeterBand
13897 GetRate() uint32
13898 GetBurstSize() uint32
13899 GetPrecLevel() uint8
13900}
13901
13902func (self *MeterBandDscpRemark) GetRate() uint32 {
13903 return self.Rate
13904}
13905
13906func (self *MeterBandDscpRemark) SetRate(v uint32) {
13907 self.Rate = v
13908}
13909
13910func (self *MeterBandDscpRemark) GetBurstSize() uint32 {
13911 return self.BurstSize
13912}
13913
13914func (self *MeterBandDscpRemark) SetBurstSize(v uint32) {
13915 self.BurstSize = v
13916}
13917
13918func (self *MeterBandDscpRemark) GetPrecLevel() uint8 {
13919 return self.PrecLevel
13920}
13921
13922func (self *MeterBandDscpRemark) SetPrecLevel(v uint8) {
13923 self.PrecLevel = v
13924}
13925
13926func (self *MeterBandDscpRemark) Serialize(encoder *goloxi.Encoder) error {
13927 if err := self.MeterBand.Serialize(encoder); err != nil {
13928 return err
13929 }
13930
13931 encoder.PutUint32(uint32(self.Rate))
13932 encoder.PutUint32(uint32(self.BurstSize))
13933 encoder.PutUint8(uint8(self.PrecLevel))
13934 encoder.Write(bytes.Repeat([]byte{0}, 3))
13935
13936 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
13937
13938 return nil
13939}
13940
13941func DecodeMeterBandDscpRemark(parent *MeterBand, decoder *goloxi.Decoder) (*MeterBandDscpRemark, error) {
13942 _meterbanddscpremark := &MeterBandDscpRemark{MeterBand: parent}
13943 if decoder.Length() < 12 {
13944 return nil, fmt.Errorf("MeterBandDscpRemark packet too short: %d < 12", decoder.Length())
13945 }
13946 _meterbanddscpremark.Rate = uint32(decoder.ReadUint32())
13947 _meterbanddscpremark.BurstSize = uint32(decoder.ReadUint32())
13948 _meterbanddscpremark.PrecLevel = uint8(decoder.ReadByte())
13949 decoder.Skip(3)
13950 return _meterbanddscpremark, nil
13951}
13952
13953func NewMeterBandDscpRemark() *MeterBandDscpRemark {
13954 obj := &MeterBandDscpRemark{
13955 MeterBand: NewMeterBand(2),
13956 }
13957 return obj
13958}
13959
13960type MeterBandExperimenter struct {
13961 *MeterBand
13962 Rate uint32
13963 BurstSize uint32
13964 Experimenter uint32
13965}
13966
13967type IMeterBandExperimenter interface {
13968 IMeterBand
13969 GetRate() uint32
13970 GetBurstSize() uint32
13971 GetExperimenter() uint32
13972}
13973
13974func (self *MeterBandExperimenter) GetRate() uint32 {
13975 return self.Rate
13976}
13977
13978func (self *MeterBandExperimenter) SetRate(v uint32) {
13979 self.Rate = v
13980}
13981
13982func (self *MeterBandExperimenter) GetBurstSize() uint32 {
13983 return self.BurstSize
13984}
13985
13986func (self *MeterBandExperimenter) SetBurstSize(v uint32) {
13987 self.BurstSize = v
13988}
13989
13990func (self *MeterBandExperimenter) GetExperimenter() uint32 {
13991 return self.Experimenter
13992}
13993
13994func (self *MeterBandExperimenter) SetExperimenter(v uint32) {
13995 self.Experimenter = v
13996}
13997
13998func (self *MeterBandExperimenter) Serialize(encoder *goloxi.Encoder) error {
13999 if err := self.MeterBand.Serialize(encoder); err != nil {
14000 return err
14001 }
14002
14003 encoder.PutUint32(uint32(self.Rate))
14004 encoder.PutUint32(uint32(self.BurstSize))
14005 encoder.PutUint32(uint32(self.Experimenter))
14006
14007 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
14008
14009 return nil
14010}
14011
14012func DecodeMeterBandExperimenter(parent *MeterBand, decoder *goloxi.Decoder) (*MeterBandExperimenter, error) {
14013 _meterbandexperimenter := &MeterBandExperimenter{MeterBand: parent}
14014 if decoder.Length() < 12 {
14015 return nil, fmt.Errorf("MeterBandExperimenter packet too short: %d < 12", decoder.Length())
14016 }
14017 _meterbandexperimenter.Rate = uint32(decoder.ReadUint32())
14018 _meterbandexperimenter.BurstSize = uint32(decoder.ReadUint32())
14019 _meterbandexperimenter.Experimenter = uint32(decoder.ReadUint32())
14020 return _meterbandexperimenter, nil
14021}
14022
14023func NewMeterBandExperimenter() *MeterBandExperimenter {
14024 obj := &MeterBandExperimenter{
14025 MeterBand: NewMeterBand(65535),
14026 }
14027 return obj
14028}
14029
14030type MeterBandStats struct {
14031 PacketBandCount uint64
14032 ByteBandCount uint64
14033}
14034
14035type IMeterBandStats interface {
14036 goloxi.Serializable
14037 GetPacketBandCount() uint64
14038 GetByteBandCount() uint64
14039}
14040
14041func (self *MeterBandStats) GetPacketBandCount() uint64 {
14042 return self.PacketBandCount
14043}
14044
14045func (self *MeterBandStats) SetPacketBandCount(v uint64) {
14046 self.PacketBandCount = v
14047}
14048
14049func (self *MeterBandStats) GetByteBandCount() uint64 {
14050 return self.ByteBandCount
14051}
14052
14053func (self *MeterBandStats) SetByteBandCount(v uint64) {
14054 self.ByteBandCount = v
14055}
14056
14057func (self *MeterBandStats) Serialize(encoder *goloxi.Encoder) error {
14058
14059 encoder.PutUint64(uint64(self.PacketBandCount))
14060 encoder.PutUint64(uint64(self.ByteBandCount))
14061
14062 return nil
14063}
14064
14065func DecodeMeterBandStats(decoder *goloxi.Decoder) (*MeterBandStats, error) {
14066 _meterbandstats := &MeterBandStats{}
14067 if decoder.Length() < 16 {
14068 return nil, fmt.Errorf("MeterBandStats packet too short: %d < 16", decoder.Length())
14069 }
14070 _meterbandstats.PacketBandCount = uint64(decoder.ReadUint64())
14071 _meterbandstats.ByteBandCount = uint64(decoder.ReadUint64())
14072 return _meterbandstats, nil
14073}
14074
14075func NewMeterBandStats() *MeterBandStats {
14076 obj := &MeterBandStats{}
14077 return obj
14078}
14079
14080type MeterConfig struct {
14081 Length uint16
14082 Flags MeterFlags
14083 MeterId uint32
14084 Entries []IMeterBand
14085}
14086
14087type IMeterConfig interface {
14088 goloxi.Serializable
14089 GetLength() uint16
14090 GetFlags() MeterFlags
14091 GetMeterId() uint32
14092 GetEntries() []IMeterBand
14093}
14094
14095func (self *MeterConfig) GetLength() uint16 {
14096 return self.Length
14097}
14098
14099func (self *MeterConfig) SetLength(v uint16) {
14100 self.Length = v
14101}
14102
14103func (self *MeterConfig) GetFlags() MeterFlags {
14104 return self.Flags
14105}
14106
14107func (self *MeterConfig) SetFlags(v MeterFlags) {
14108 self.Flags = v
14109}
14110
14111func (self *MeterConfig) GetMeterId() uint32 {
14112 return self.MeterId
14113}
14114
14115func (self *MeterConfig) SetMeterId(v uint32) {
14116 self.MeterId = v
14117}
14118
14119func (self *MeterConfig) GetEntries() []IMeterBand {
14120 return self.Entries
14121}
14122
14123func (self *MeterConfig) SetEntries(v []IMeterBand) {
14124 self.Entries = v
14125}
14126
14127func (self *MeterConfig) Serialize(encoder *goloxi.Encoder) error {
14128
14129 encoder.PutUint16(uint16(self.Length))
14130 encoder.PutUint16(uint16(self.Flags))
14131 encoder.PutUint32(uint32(self.MeterId))
14132 for _, obj := range self.Entries {
14133 if err := obj.Serialize(encoder); err != nil {
14134 return err
14135 }
14136 }
14137
14138 binary.BigEndian.PutUint16(encoder.Bytes()[0:2], uint16(len(encoder.Bytes())))
14139
14140 return nil
14141}
14142
14143func DecodeMeterConfig(decoder *goloxi.Decoder) (*MeterConfig, error) {
14144 _meterconfig := &MeterConfig{}
14145 if decoder.Length() < 8 {
14146 return nil, fmt.Errorf("MeterConfig packet too short: %d < 8", decoder.Length())
14147 }
14148 _meterconfig.Length = uint16(decoder.ReadUint16())
14149 oldDecoder := decoder
14150 defer func() { decoder = oldDecoder }()
14151 decoder = decoder.SliceDecoder(int(_meterconfig.Length), 2+0)
14152 _meterconfig.Flags = MeterFlags(decoder.ReadUint16())
14153 _meterconfig.MeterId = uint32(decoder.ReadUint32())
14154
14155 for decoder.Length() >= 4 {
14156 item, err := DecodeMeterBand(decoder)
14157 if err != nil {
14158 return nil, err
14159 }
14160 if item != nil {
14161 _meterconfig.Entries = append(_meterconfig.Entries, item)
14162 }
14163 }
14164 return _meterconfig, nil
14165}
14166
14167func NewMeterConfig() *MeterConfig {
14168 obj := &MeterConfig{}
14169 return obj
14170}
14171
14172type MeterFeatures struct {
14173 MaxMeter uint32
14174 BandTypes uint32
14175 Capabilities uint32
14176 MaxBands uint8
14177 MaxColor uint8
14178}
14179
14180type IMeterFeatures interface {
14181 goloxi.Serializable
14182 GetMaxMeter() uint32
14183 GetBandTypes() uint32
14184 GetCapabilities() uint32
14185 GetMaxBands() uint8
14186 GetMaxColor() uint8
14187}
14188
14189func (self *MeterFeatures) GetMaxMeter() uint32 {
14190 return self.MaxMeter
14191}
14192
14193func (self *MeterFeatures) SetMaxMeter(v uint32) {
14194 self.MaxMeter = v
14195}
14196
14197func (self *MeterFeatures) GetBandTypes() uint32 {
14198 return self.BandTypes
14199}
14200
14201func (self *MeterFeatures) SetBandTypes(v uint32) {
14202 self.BandTypes = v
14203}
14204
14205func (self *MeterFeatures) GetCapabilities() uint32 {
14206 return self.Capabilities
14207}
14208
14209func (self *MeterFeatures) SetCapabilities(v uint32) {
14210 self.Capabilities = v
14211}
14212
14213func (self *MeterFeatures) GetMaxBands() uint8 {
14214 return self.MaxBands
14215}
14216
14217func (self *MeterFeatures) SetMaxBands(v uint8) {
14218 self.MaxBands = v
14219}
14220
14221func (self *MeterFeatures) GetMaxColor() uint8 {
14222 return self.MaxColor
14223}
14224
14225func (self *MeterFeatures) SetMaxColor(v uint8) {
14226 self.MaxColor = v
14227}
14228
14229func (self *MeterFeatures) Serialize(encoder *goloxi.Encoder) error {
14230
14231 encoder.PutUint32(uint32(self.MaxMeter))
14232 encoder.PutUint32(uint32(self.BandTypes))
14233 encoder.PutUint32(uint32(self.Capabilities))
14234 encoder.PutUint8(uint8(self.MaxBands))
14235 encoder.PutUint8(uint8(self.MaxColor))
14236 encoder.Write(bytes.Repeat([]byte{0}, 2))
14237
14238 return nil
14239}
14240func (self *MeterFeatures) Decode(decoder *goloxi.Decoder) error {
14241 if decoder.Length() < 16 {
14242 return fmt.Errorf("MeterFeatures packet too short: %d < 16", decoder.Length())
14243 }
14244
14245 self.MaxMeter = uint32(decoder.ReadUint32())
14246 self.BandTypes = uint32(decoder.ReadUint32())
14247 self.Capabilities = uint32(decoder.ReadUint32())
14248 self.MaxBands = uint8(decoder.ReadByte())
14249 self.MaxColor = uint8(decoder.ReadByte())
14250 decoder.Skip(2)
14251
14252 return nil
14253}
14254
14255func NewMeterFeatures() *MeterFeatures {
14256 obj := &MeterFeatures{}
14257 return obj
14258}
14259
14260type MeterStats struct {
14261 MeterId uint32
14262 Len uint16
14263 FlowCount uint32
14264 PacketInCount uint64
14265 ByteInCount uint64
14266 DurationSec uint32
14267 DurationNsec uint32
14268 BandStats []*MeterBandStats
14269}
14270
14271type IMeterStats interface {
14272 goloxi.Serializable
14273 GetMeterId() uint32
14274 GetLen() uint16
14275 GetFlowCount() uint32
14276 GetPacketInCount() uint64
14277 GetByteInCount() uint64
14278 GetDurationSec() uint32
14279 GetDurationNsec() uint32
14280 GetBandStats() []*MeterBandStats
14281}
14282
14283func (self *MeterStats) GetMeterId() uint32 {
14284 return self.MeterId
14285}
14286
14287func (self *MeterStats) SetMeterId(v uint32) {
14288 self.MeterId = v
14289}
14290
14291func (self *MeterStats) GetLen() uint16 {
14292 return self.Len
14293}
14294
14295func (self *MeterStats) SetLen(v uint16) {
14296 self.Len = v
14297}
14298
14299func (self *MeterStats) GetFlowCount() uint32 {
14300 return self.FlowCount
14301}
14302
14303func (self *MeterStats) SetFlowCount(v uint32) {
14304 self.FlowCount = v
14305}
14306
14307func (self *MeterStats) GetPacketInCount() uint64 {
14308 return self.PacketInCount
14309}
14310
14311func (self *MeterStats) SetPacketInCount(v uint64) {
14312 self.PacketInCount = v
14313}
14314
14315func (self *MeterStats) GetByteInCount() uint64 {
14316 return self.ByteInCount
14317}
14318
14319func (self *MeterStats) SetByteInCount(v uint64) {
14320 self.ByteInCount = v
14321}
14322
14323func (self *MeterStats) GetDurationSec() uint32 {
14324 return self.DurationSec
14325}
14326
14327func (self *MeterStats) SetDurationSec(v uint32) {
14328 self.DurationSec = v
14329}
14330
14331func (self *MeterStats) GetDurationNsec() uint32 {
14332 return self.DurationNsec
14333}
14334
14335func (self *MeterStats) SetDurationNsec(v uint32) {
14336 self.DurationNsec = v
14337}
14338
14339func (self *MeterStats) GetBandStats() []*MeterBandStats {
14340 return self.BandStats
14341}
14342
14343func (self *MeterStats) SetBandStats(v []*MeterBandStats) {
14344 self.BandStats = v
14345}
14346
14347func (self *MeterStats) Serialize(encoder *goloxi.Encoder) error {
14348
14349 encoder.PutUint32(uint32(self.MeterId))
14350 encoder.PutUint16(uint16(self.Len))
14351 encoder.Write(bytes.Repeat([]byte{0}, 6))
14352 encoder.PutUint32(uint32(self.FlowCount))
14353 encoder.PutUint64(uint64(self.PacketInCount))
14354 encoder.PutUint64(uint64(self.ByteInCount))
14355 encoder.PutUint32(uint32(self.DurationSec))
14356 encoder.PutUint32(uint32(self.DurationNsec))
14357 for _, obj := range self.BandStats {
14358 if err := obj.Serialize(encoder); err != nil {
14359 return err
14360 }
14361 }
14362
14363 binary.BigEndian.PutUint16(encoder.Bytes()[4:6], uint16(len(encoder.Bytes())))
14364
14365 return nil
14366}
14367
14368func DecodeMeterStats(decoder *goloxi.Decoder) (*MeterStats, error) {
14369 _meterstats := &MeterStats{}
14370 if decoder.Length() < 40 {
14371 return nil, fmt.Errorf("MeterStats packet too short: %d < 40", decoder.Length())
14372 }
14373 _meterstats.MeterId = uint32(decoder.ReadUint32())
14374 _meterstats.Len = uint16(decoder.ReadUint16())
14375 oldDecoder := decoder
14376 defer func() { decoder = oldDecoder }()
14377 decoder = decoder.SliceDecoder(int(_meterstats.Len), 2+4)
14378 decoder.Skip(6)
14379 _meterstats.FlowCount = uint32(decoder.ReadUint32())
14380 _meterstats.PacketInCount = uint64(decoder.ReadUint64())
14381 _meterstats.ByteInCount = uint64(decoder.ReadUint64())
14382 _meterstats.DurationSec = uint32(decoder.ReadUint32())
14383 _meterstats.DurationNsec = uint32(decoder.ReadUint32())
14384
14385 for decoder.Length() >= 16 {
14386 item, err := DecodeMeterBandStats(decoder)
14387 if err != nil {
14388 return nil, err
14389 }
14390 if item != nil {
14391 _meterstats.BandStats = append(_meterstats.BandStats, item)
14392 }
14393 }
14394 return _meterstats, nil
14395}
14396
14397func NewMeterStats() *MeterStats {
14398 obj := &MeterStats{}
14399 return obj
14400}
14401
14402type NiciraMatch struct {
14403 NxmEntries []goloxi.IOxm
14404}
14405
14406type INiciraMatch interface {
14407 goloxi.Serializable
14408 GetNxmEntries() []goloxi.IOxm
14409}
14410
14411func (self *NiciraMatch) GetNxmEntries() []goloxi.IOxm {
14412 return self.NxmEntries
14413}
14414
14415func (self *NiciraMatch) SetNxmEntries(v []goloxi.IOxm) {
14416 self.NxmEntries = v
14417}
14418
14419func (self *NiciraMatch) Serialize(encoder *goloxi.Encoder) error {
14420
14421 for _, obj := range self.NxmEntries {
14422 if err := obj.Serialize(encoder); err != nil {
14423 return err
14424 }
14425 }
14426
14427 encoder.SkipAlign()
14428
14429 return nil
14430}
14431func (self *NiciraMatch) Decode(decoder *goloxi.Decoder) error {
14432
14433 defer decoder.SkipAlign()
14434
14435 for decoder.Length() >= 4 {
14436 item, err := DecodeOxm(decoder)
14437 if err != nil {
14438 return err
14439 }
14440 if item != nil {
14441 self.NxmEntries = append(self.NxmEntries, item)
14442 }
14443 }
14444
14445 return nil
14446}
14447
14448func NewNiciraMatch() *NiciraMatch {
14449 obj := &NiciraMatch{}
14450 return obj
14451}
14452
14453type NiciraFlowStats struct {
14454 Length uint16
14455 TableId uint8
14456 DurationSec uint32
14457 DurationNsec uint32
14458 Priority uint16
14459 IdleTimeout uint16
14460 HardTimeout uint16
14461 MatchLen uint16
14462 IdleAge uint16
14463 HardAge uint16
14464 Cookie uint64
14465 PacketCount uint64
14466 ByteCount uint64
14467 Match NiciraMatch
14468 Actions []goloxi.IAction
14469}
14470
14471type INiciraFlowStats interface {
14472 goloxi.Serializable
14473 GetLength() uint16
14474 GetTableId() uint8
14475 GetDurationSec() uint32
14476 GetDurationNsec() uint32
14477 GetPriority() uint16
14478 GetIdleTimeout() uint16
14479 GetHardTimeout() uint16
14480 GetMatchLen() uint16
14481 GetIdleAge() uint16
14482 GetHardAge() uint16
14483 GetCookie() uint64
14484 GetPacketCount() uint64
14485 GetByteCount() uint64
14486 GetMatch() NiciraMatch
14487 GetActions() []goloxi.IAction
14488}
14489
14490func (self *NiciraFlowStats) GetLength() uint16 {
14491 return self.Length
14492}
14493
14494func (self *NiciraFlowStats) SetLength(v uint16) {
14495 self.Length = v
14496}
14497
14498func (self *NiciraFlowStats) GetTableId() uint8 {
14499 return self.TableId
14500}
14501
14502func (self *NiciraFlowStats) SetTableId(v uint8) {
14503 self.TableId = v
14504}
14505
14506func (self *NiciraFlowStats) GetDurationSec() uint32 {
14507 return self.DurationSec
14508}
14509
14510func (self *NiciraFlowStats) SetDurationSec(v uint32) {
14511 self.DurationSec = v
14512}
14513
14514func (self *NiciraFlowStats) GetDurationNsec() uint32 {
14515 return self.DurationNsec
14516}
14517
14518func (self *NiciraFlowStats) SetDurationNsec(v uint32) {
14519 self.DurationNsec = v
14520}
14521
14522func (self *NiciraFlowStats) GetPriority() uint16 {
14523 return self.Priority
14524}
14525
14526func (self *NiciraFlowStats) SetPriority(v uint16) {
14527 self.Priority = v
14528}
14529
14530func (self *NiciraFlowStats) GetIdleTimeout() uint16 {
14531 return self.IdleTimeout
14532}
14533
14534func (self *NiciraFlowStats) SetIdleTimeout(v uint16) {
14535 self.IdleTimeout = v
14536}
14537
14538func (self *NiciraFlowStats) GetHardTimeout() uint16 {
14539 return self.HardTimeout
14540}
14541
14542func (self *NiciraFlowStats) SetHardTimeout(v uint16) {
14543 self.HardTimeout = v
14544}
14545
14546func (self *NiciraFlowStats) GetMatchLen() uint16 {
14547 return self.MatchLen
14548}
14549
14550func (self *NiciraFlowStats) SetMatchLen(v uint16) {
14551 self.MatchLen = v
14552}
14553
14554func (self *NiciraFlowStats) GetIdleAge() uint16 {
14555 return self.IdleAge
14556}
14557
14558func (self *NiciraFlowStats) SetIdleAge(v uint16) {
14559 self.IdleAge = v
14560}
14561
14562func (self *NiciraFlowStats) GetHardAge() uint16 {
14563 return self.HardAge
14564}
14565
14566func (self *NiciraFlowStats) SetHardAge(v uint16) {
14567 self.HardAge = v
14568}
14569
14570func (self *NiciraFlowStats) GetCookie() uint64 {
14571 return self.Cookie
14572}
14573
14574func (self *NiciraFlowStats) SetCookie(v uint64) {
14575 self.Cookie = v
14576}
14577
14578func (self *NiciraFlowStats) GetPacketCount() uint64 {
14579 return self.PacketCount
14580}
14581
14582func (self *NiciraFlowStats) SetPacketCount(v uint64) {
14583 self.PacketCount = v
14584}
14585
14586func (self *NiciraFlowStats) GetByteCount() uint64 {
14587 return self.ByteCount
14588}
14589
14590func (self *NiciraFlowStats) SetByteCount(v uint64) {
14591 self.ByteCount = v
14592}
14593
14594func (self *NiciraFlowStats) GetMatch() NiciraMatch {
14595 return self.Match
14596}
14597
14598func (self *NiciraFlowStats) SetMatch(v NiciraMatch) {
14599 self.Match = v
14600}
14601
14602func (self *NiciraFlowStats) GetActions() []goloxi.IAction {
14603 return self.Actions
14604}
14605
14606func (self *NiciraFlowStats) SetActions(v []goloxi.IAction) {
14607 self.Actions = v
14608}
14609
14610func (self *NiciraFlowStats) Serialize(encoder *goloxi.Encoder) error {
14611
14612 encoder.PutUint16(uint16(self.Length))
14613 encoder.PutUint8(uint8(self.TableId))
14614 encoder.Write(bytes.Repeat([]byte{0}, 1))
14615 encoder.PutUint32(uint32(self.DurationSec))
14616 encoder.PutUint32(uint32(self.DurationNsec))
14617 encoder.PutUint16(uint16(self.Priority))
14618 encoder.PutUint16(uint16(self.IdleTimeout))
14619 encoder.PutUint16(uint16(self.HardTimeout))
14620 encoder.PutUint16(uint16(self.MatchLen))
14621 encoder.PutUint16(uint16(self.IdleAge))
14622 encoder.PutUint16(uint16(self.HardAge))
14623 encoder.PutUint64(uint64(self.Cookie))
14624 encoder.PutUint64(uint64(self.PacketCount))
14625 encoder.PutUint64(uint64(self.ByteCount))
14626 if err := self.Match.Serialize(encoder); err != nil {
14627 return err
14628 }
14629
14630 for _, obj := range self.Actions {
14631 if err := obj.Serialize(encoder); err != nil {
14632 return err
14633 }
14634 }
14635
14636 binary.BigEndian.PutUint16(encoder.Bytes()[0:2], uint16(len(encoder.Bytes())))
14637
14638 return nil
14639}
14640
14641func DecodeNiciraFlowStats(decoder *goloxi.Decoder) (*NiciraFlowStats, error) {
14642 _niciraflowstats := &NiciraFlowStats{}
14643 if decoder.Length() < 48 {
14644 return nil, fmt.Errorf("NiciraFlowStats packet too short: %d < 48", decoder.Length())
14645 }
14646 _niciraflowstats.Length = uint16(decoder.ReadUint16())
14647 oldDecoder := decoder
14648 defer func() { decoder = oldDecoder }()
14649 decoder = decoder.SliceDecoder(int(_niciraflowstats.Length), 2+0)
14650 _niciraflowstats.TableId = uint8(decoder.ReadByte())
14651 decoder.Skip(1)
14652 _niciraflowstats.DurationSec = uint32(decoder.ReadUint32())
14653 _niciraflowstats.DurationNsec = uint32(decoder.ReadUint32())
14654 _niciraflowstats.Priority = uint16(decoder.ReadUint16())
14655 _niciraflowstats.IdleTimeout = uint16(decoder.ReadUint16())
14656 _niciraflowstats.HardTimeout = uint16(decoder.ReadUint16())
14657 _niciraflowstats.MatchLen = uint16(decoder.ReadUint16())
14658 _niciraflowstats.IdleAge = uint16(decoder.ReadUint16())
14659 _niciraflowstats.HardAge = uint16(decoder.ReadUint16())
14660 _niciraflowstats.Cookie = uint64(decoder.ReadUint64())
14661 _niciraflowstats.PacketCount = uint64(decoder.ReadUint64())
14662 _niciraflowstats.ByteCount = uint64(decoder.ReadUint64())
14663 if err := _niciraflowstats.Match.Decode(decoder.SliceDecoder(int(_niciraflowstats.MatchLen), 0)); err != nil {
14664 return nil, err
14665 }
14666
14667 decoder.SkipAlign()
14668
14669 for decoder.Length() >= 8 {
14670 item, err := DecodeAction(decoder)
14671 if err != nil {
14672 return nil, err
14673 }
14674 if item != nil {
14675 _niciraflowstats.Actions = append(_niciraflowstats.Actions, item)
14676 }
14677 }
14678 return _niciraflowstats, nil
14679}
14680
14681func NewNiciraFlowStats() *NiciraFlowStats {
14682 obj := &NiciraFlowStats{}
14683 return obj
14684}
14685
14686type NiciraFlowUpdateEvent struct {
14687 Length uint16
14688 Event uint16
14689}
14690
14691type INiciraFlowUpdateEvent interface {
14692 goloxi.Serializable
14693 GetLength() uint16
14694 GetEvent() uint16
14695}
14696
14697func (self *NiciraFlowUpdateEvent) GetLength() uint16 {
14698 return self.Length
14699}
14700
14701func (self *NiciraFlowUpdateEvent) SetLength(v uint16) {
14702 self.Length = v
14703}
14704
14705func (self *NiciraFlowUpdateEvent) GetEvent() uint16 {
14706 return self.Event
14707}
14708
14709func (self *NiciraFlowUpdateEvent) SetEvent(v uint16) {
14710 self.Event = v
14711}
14712
14713func (self *NiciraFlowUpdateEvent) Serialize(encoder *goloxi.Encoder) error {
14714
14715 encoder.PutUint16(uint16(self.Length))
14716 encoder.PutUint16(uint16(self.Event))
14717
14718 return nil
14719}
14720
14721func DecodeNiciraFlowUpdateEvent(decoder *goloxi.Decoder) (INiciraFlowUpdateEvent, error) {
14722 _niciraflowupdateevent := &NiciraFlowUpdateEvent{}
14723 if decoder.Length() < 4 {
14724 return nil, fmt.Errorf("NiciraFlowUpdateEvent packet too short: %d < 4", decoder.Length())
14725 }
14726 _niciraflowupdateevent.Length = uint16(decoder.ReadUint16())
14727 oldDecoder := decoder
14728 defer func() { decoder = oldDecoder }()
14729 decoder = decoder.SliceDecoder(int(_niciraflowupdateevent.Length), 2+0)
14730 _niciraflowupdateevent.Event = uint16(decoder.ReadUint16())
14731
14732 switch _niciraflowupdateevent.Event {
14733 case 0:
14734 return DecodeNiciraFlowUpdateFullAdd(_niciraflowupdateevent, decoder)
14735 case 1:
14736 return DecodeNiciraFlowUpdateFullDeleted(_niciraflowupdateevent, decoder)
14737 case 2:
14738 return DecodeNiciraFlowUpdateFullModified(_niciraflowupdateevent, decoder)
14739 default:
14740 return nil, fmt.Errorf("Invalid type '%d' for 'NiciraFlowUpdateEvent'", _niciraflowupdateevent.Event)
14741 }
14742}
14743
14744func NewNiciraFlowUpdateEvent(_event uint16) *NiciraFlowUpdateEvent {
14745 obj := &NiciraFlowUpdateEvent{}
14746 obj.Event = _event
14747 return obj
14748}
14749
14750type NiciraFlowUpdateFullAdd struct {
14751 *NiciraFlowUpdateEvent
14752 Reason uint16
14753 Priority uint16
14754 IdleTimeout uint16
14755 HardTimeout uint16
14756 MatchLen uint16
14757 TableId uint8
14758 Cookie uint64
14759 Match NiciraMatch
14760 Actions []goloxi.IAction
14761}
14762
14763type INiciraFlowUpdateFullAdd interface {
14764 INiciraFlowUpdateEvent
14765 GetReason() uint16
14766 GetPriority() uint16
14767 GetIdleTimeout() uint16
14768 GetHardTimeout() uint16
14769 GetMatchLen() uint16
14770 GetTableId() uint8
14771 GetCookie() uint64
14772 GetMatch() NiciraMatch
14773 GetActions() []goloxi.IAction
14774}
14775
14776func (self *NiciraFlowUpdateFullAdd) GetReason() uint16 {
14777 return self.Reason
14778}
14779
14780func (self *NiciraFlowUpdateFullAdd) SetReason(v uint16) {
14781 self.Reason = v
14782}
14783
14784func (self *NiciraFlowUpdateFullAdd) GetPriority() uint16 {
14785 return self.Priority
14786}
14787
14788func (self *NiciraFlowUpdateFullAdd) SetPriority(v uint16) {
14789 self.Priority = v
14790}
14791
14792func (self *NiciraFlowUpdateFullAdd) GetIdleTimeout() uint16 {
14793 return self.IdleTimeout
14794}
14795
14796func (self *NiciraFlowUpdateFullAdd) SetIdleTimeout(v uint16) {
14797 self.IdleTimeout = v
14798}
14799
14800func (self *NiciraFlowUpdateFullAdd) GetHardTimeout() uint16 {
14801 return self.HardTimeout
14802}
14803
14804func (self *NiciraFlowUpdateFullAdd) SetHardTimeout(v uint16) {
14805 self.HardTimeout = v
14806}
14807
14808func (self *NiciraFlowUpdateFullAdd) GetMatchLen() uint16 {
14809 return self.MatchLen
14810}
14811
14812func (self *NiciraFlowUpdateFullAdd) SetMatchLen(v uint16) {
14813 self.MatchLen = v
14814}
14815
14816func (self *NiciraFlowUpdateFullAdd) GetTableId() uint8 {
14817 return self.TableId
14818}
14819
14820func (self *NiciraFlowUpdateFullAdd) SetTableId(v uint8) {
14821 self.TableId = v
14822}
14823
14824func (self *NiciraFlowUpdateFullAdd) GetCookie() uint64 {
14825 return self.Cookie
14826}
14827
14828func (self *NiciraFlowUpdateFullAdd) SetCookie(v uint64) {
14829 self.Cookie = v
14830}
14831
14832func (self *NiciraFlowUpdateFullAdd) GetMatch() NiciraMatch {
14833 return self.Match
14834}
14835
14836func (self *NiciraFlowUpdateFullAdd) SetMatch(v NiciraMatch) {
14837 self.Match = v
14838}
14839
14840func (self *NiciraFlowUpdateFullAdd) GetActions() []goloxi.IAction {
14841 return self.Actions
14842}
14843
14844func (self *NiciraFlowUpdateFullAdd) SetActions(v []goloxi.IAction) {
14845 self.Actions = v
14846}
14847
14848func (self *NiciraFlowUpdateFullAdd) Serialize(encoder *goloxi.Encoder) error {
14849 if err := self.NiciraFlowUpdateEvent.Serialize(encoder); err != nil {
14850 return err
14851 }
14852
14853 encoder.PutUint16(uint16(self.Reason))
14854 encoder.PutUint16(uint16(self.Priority))
14855 encoder.PutUint16(uint16(self.IdleTimeout))
14856 encoder.PutUint16(uint16(self.HardTimeout))
14857 encoder.PutUint16(uint16(self.MatchLen))
14858 encoder.PutUint8(uint8(self.TableId))
14859 encoder.Write(bytes.Repeat([]byte{0}, 1))
14860 encoder.PutUint64(uint64(self.Cookie))
14861 if err := self.Match.Serialize(encoder); err != nil {
14862 return err
14863 }
14864
14865 for _, obj := range self.Actions {
14866 if err := obj.Serialize(encoder); err != nil {
14867 return err
14868 }
14869 }
14870
14871 binary.BigEndian.PutUint16(encoder.Bytes()[0:2], uint16(len(encoder.Bytes())))
14872
14873 return nil
14874}
14875
14876func DecodeNiciraFlowUpdateFullAdd(parent *NiciraFlowUpdateEvent, decoder *goloxi.Decoder) (*NiciraFlowUpdateFullAdd, error) {
14877 _niciraflowupdatefulladd := &NiciraFlowUpdateFullAdd{NiciraFlowUpdateEvent: parent}
14878 if decoder.Length() < 20 {
14879 return nil, fmt.Errorf("NiciraFlowUpdateFullAdd packet too short: %d < 20", decoder.Length())
14880 }
14881 _niciraflowupdatefulladd.Reason = uint16(decoder.ReadUint16())
14882 _niciraflowupdatefulladd.Priority = uint16(decoder.ReadUint16())
14883 _niciraflowupdatefulladd.IdleTimeout = uint16(decoder.ReadUint16())
14884 _niciraflowupdatefulladd.HardTimeout = uint16(decoder.ReadUint16())
14885 _niciraflowupdatefulladd.MatchLen = uint16(decoder.ReadUint16())
14886 _niciraflowupdatefulladd.TableId = uint8(decoder.ReadByte())
14887 decoder.Skip(1)
14888 _niciraflowupdatefulladd.Cookie = uint64(decoder.ReadUint64())
14889 if err := _niciraflowupdatefulladd.Match.Decode(decoder.SliceDecoder(int(_niciraflowupdatefulladd.MatchLen), 0)); err != nil {
14890 return nil, err
14891 }
14892
14893 decoder.SkipAlign()
14894
14895 for decoder.Length() >= 8 {
14896 item, err := DecodeAction(decoder)
14897 if err != nil {
14898 return nil, err
14899 }
14900 if item != nil {
14901 _niciraflowupdatefulladd.Actions = append(_niciraflowupdatefulladd.Actions, item)
14902 }
14903 }
14904 return _niciraflowupdatefulladd, nil
14905}
14906
14907func NewNiciraFlowUpdateFullAdd() *NiciraFlowUpdateFullAdd {
14908 obj := &NiciraFlowUpdateFullAdd{
14909 NiciraFlowUpdateEvent: NewNiciraFlowUpdateEvent(0),
14910 }
14911 return obj
14912}
14913
14914type NiciraFlowUpdateFullDeleted struct {
14915 *NiciraFlowUpdateEvent
14916 Reason uint16
14917 Priority uint16
14918 IdleTimeout uint16
14919 HardTimeout uint16
14920 MatchLen uint16
14921 TableId uint8
14922 Cookie uint64
14923 Match NiciraMatch
14924 Actions []goloxi.IAction
14925}
14926
14927type INiciraFlowUpdateFullDeleted interface {
14928 INiciraFlowUpdateEvent
14929 GetReason() uint16
14930 GetPriority() uint16
14931 GetIdleTimeout() uint16
14932 GetHardTimeout() uint16
14933 GetMatchLen() uint16
14934 GetTableId() uint8
14935 GetCookie() uint64
14936 GetMatch() NiciraMatch
14937 GetActions() []goloxi.IAction
14938}
14939
14940func (self *NiciraFlowUpdateFullDeleted) GetReason() uint16 {
14941 return self.Reason
14942}
14943
14944func (self *NiciraFlowUpdateFullDeleted) SetReason(v uint16) {
14945 self.Reason = v
14946}
14947
14948func (self *NiciraFlowUpdateFullDeleted) GetPriority() uint16 {
14949 return self.Priority
14950}
14951
14952func (self *NiciraFlowUpdateFullDeleted) SetPriority(v uint16) {
14953 self.Priority = v
14954}
14955
14956func (self *NiciraFlowUpdateFullDeleted) GetIdleTimeout() uint16 {
14957 return self.IdleTimeout
14958}
14959
14960func (self *NiciraFlowUpdateFullDeleted) SetIdleTimeout(v uint16) {
14961 self.IdleTimeout = v
14962}
14963
14964func (self *NiciraFlowUpdateFullDeleted) GetHardTimeout() uint16 {
14965 return self.HardTimeout
14966}
14967
14968func (self *NiciraFlowUpdateFullDeleted) SetHardTimeout(v uint16) {
14969 self.HardTimeout = v
14970}
14971
14972func (self *NiciraFlowUpdateFullDeleted) GetMatchLen() uint16 {
14973 return self.MatchLen
14974}
14975
14976func (self *NiciraFlowUpdateFullDeleted) SetMatchLen(v uint16) {
14977 self.MatchLen = v
14978}
14979
14980func (self *NiciraFlowUpdateFullDeleted) GetTableId() uint8 {
14981 return self.TableId
14982}
14983
14984func (self *NiciraFlowUpdateFullDeleted) SetTableId(v uint8) {
14985 self.TableId = v
14986}
14987
14988func (self *NiciraFlowUpdateFullDeleted) GetCookie() uint64 {
14989 return self.Cookie
14990}
14991
14992func (self *NiciraFlowUpdateFullDeleted) SetCookie(v uint64) {
14993 self.Cookie = v
14994}
14995
14996func (self *NiciraFlowUpdateFullDeleted) GetMatch() NiciraMatch {
14997 return self.Match
14998}
14999
15000func (self *NiciraFlowUpdateFullDeleted) SetMatch(v NiciraMatch) {
15001 self.Match = v
15002}
15003
15004func (self *NiciraFlowUpdateFullDeleted) GetActions() []goloxi.IAction {
15005 return self.Actions
15006}
15007
15008func (self *NiciraFlowUpdateFullDeleted) SetActions(v []goloxi.IAction) {
15009 self.Actions = v
15010}
15011
15012func (self *NiciraFlowUpdateFullDeleted) Serialize(encoder *goloxi.Encoder) error {
15013 if err := self.NiciraFlowUpdateEvent.Serialize(encoder); err != nil {
15014 return err
15015 }
15016
15017 encoder.PutUint16(uint16(self.Reason))
15018 encoder.PutUint16(uint16(self.Priority))
15019 encoder.PutUint16(uint16(self.IdleTimeout))
15020 encoder.PutUint16(uint16(self.HardTimeout))
15021 encoder.PutUint16(uint16(self.MatchLen))
15022 encoder.PutUint8(uint8(self.TableId))
15023 encoder.Write(bytes.Repeat([]byte{0}, 1))
15024 encoder.PutUint64(uint64(self.Cookie))
15025 if err := self.Match.Serialize(encoder); err != nil {
15026 return err
15027 }
15028
15029 for _, obj := range self.Actions {
15030 if err := obj.Serialize(encoder); err != nil {
15031 return err
15032 }
15033 }
15034
15035 binary.BigEndian.PutUint16(encoder.Bytes()[0:2], uint16(len(encoder.Bytes())))
15036
15037 return nil
15038}
15039
15040func DecodeNiciraFlowUpdateFullDeleted(parent *NiciraFlowUpdateEvent, decoder *goloxi.Decoder) (*NiciraFlowUpdateFullDeleted, error) {
15041 _niciraflowupdatefulldeleted := &NiciraFlowUpdateFullDeleted{NiciraFlowUpdateEvent: parent}
15042 if decoder.Length() < 20 {
15043 return nil, fmt.Errorf("NiciraFlowUpdateFullDeleted packet too short: %d < 20", decoder.Length())
15044 }
15045 _niciraflowupdatefulldeleted.Reason = uint16(decoder.ReadUint16())
15046 _niciraflowupdatefulldeleted.Priority = uint16(decoder.ReadUint16())
15047 _niciraflowupdatefulldeleted.IdleTimeout = uint16(decoder.ReadUint16())
15048 _niciraflowupdatefulldeleted.HardTimeout = uint16(decoder.ReadUint16())
15049 _niciraflowupdatefulldeleted.MatchLen = uint16(decoder.ReadUint16())
15050 _niciraflowupdatefulldeleted.TableId = uint8(decoder.ReadByte())
15051 decoder.Skip(1)
15052 _niciraflowupdatefulldeleted.Cookie = uint64(decoder.ReadUint64())
15053 if err := _niciraflowupdatefulldeleted.Match.Decode(decoder.SliceDecoder(int(_niciraflowupdatefulldeleted.MatchLen), 0)); err != nil {
15054 return nil, err
15055 }
15056
15057 decoder.SkipAlign()
15058
15059 for decoder.Length() >= 8 {
15060 item, err := DecodeAction(decoder)
15061 if err != nil {
15062 return nil, err
15063 }
15064 if item != nil {
15065 _niciraflowupdatefulldeleted.Actions = append(_niciraflowupdatefulldeleted.Actions, item)
15066 }
15067 }
15068 return _niciraflowupdatefulldeleted, nil
15069}
15070
15071func NewNiciraFlowUpdateFullDeleted() *NiciraFlowUpdateFullDeleted {
15072 obj := &NiciraFlowUpdateFullDeleted{
15073 NiciraFlowUpdateEvent: NewNiciraFlowUpdateEvent(1),
15074 }
15075 return obj
15076}
15077
15078type NiciraFlowUpdateFullModified struct {
15079 *NiciraFlowUpdateEvent
15080 Reason uint16
15081 Priority uint16
15082 IdleTimeout uint16
15083 HardTimeout uint16
15084 MatchLen uint16
15085 TableId uint8
15086 Cookie uint64
15087 Match NiciraMatch
15088 Actions []goloxi.IAction
15089}
15090
15091type INiciraFlowUpdateFullModified interface {
15092 INiciraFlowUpdateEvent
15093 GetReason() uint16
15094 GetPriority() uint16
15095 GetIdleTimeout() uint16
15096 GetHardTimeout() uint16
15097 GetMatchLen() uint16
15098 GetTableId() uint8
15099 GetCookie() uint64
15100 GetMatch() NiciraMatch
15101 GetActions() []goloxi.IAction
15102}
15103
15104func (self *NiciraFlowUpdateFullModified) GetReason() uint16 {
15105 return self.Reason
15106}
15107
15108func (self *NiciraFlowUpdateFullModified) SetReason(v uint16) {
15109 self.Reason = v
15110}
15111
15112func (self *NiciraFlowUpdateFullModified) GetPriority() uint16 {
15113 return self.Priority
15114}
15115
15116func (self *NiciraFlowUpdateFullModified) SetPriority(v uint16) {
15117 self.Priority = v
15118}
15119
15120func (self *NiciraFlowUpdateFullModified) GetIdleTimeout() uint16 {
15121 return self.IdleTimeout
15122}
15123
15124func (self *NiciraFlowUpdateFullModified) SetIdleTimeout(v uint16) {
15125 self.IdleTimeout = v
15126}
15127
15128func (self *NiciraFlowUpdateFullModified) GetHardTimeout() uint16 {
15129 return self.HardTimeout
15130}
15131
15132func (self *NiciraFlowUpdateFullModified) SetHardTimeout(v uint16) {
15133 self.HardTimeout = v
15134}
15135
15136func (self *NiciraFlowUpdateFullModified) GetMatchLen() uint16 {
15137 return self.MatchLen
15138}
15139
15140func (self *NiciraFlowUpdateFullModified) SetMatchLen(v uint16) {
15141 self.MatchLen = v
15142}
15143
15144func (self *NiciraFlowUpdateFullModified) GetTableId() uint8 {
15145 return self.TableId
15146}
15147
15148func (self *NiciraFlowUpdateFullModified) SetTableId(v uint8) {
15149 self.TableId = v
15150}
15151
15152func (self *NiciraFlowUpdateFullModified) GetCookie() uint64 {
15153 return self.Cookie
15154}
15155
15156func (self *NiciraFlowUpdateFullModified) SetCookie(v uint64) {
15157 self.Cookie = v
15158}
15159
15160func (self *NiciraFlowUpdateFullModified) GetMatch() NiciraMatch {
15161 return self.Match
15162}
15163
15164func (self *NiciraFlowUpdateFullModified) SetMatch(v NiciraMatch) {
15165 self.Match = v
15166}
15167
15168func (self *NiciraFlowUpdateFullModified) GetActions() []goloxi.IAction {
15169 return self.Actions
15170}
15171
15172func (self *NiciraFlowUpdateFullModified) SetActions(v []goloxi.IAction) {
15173 self.Actions = v
15174}
15175
15176func (self *NiciraFlowUpdateFullModified) Serialize(encoder *goloxi.Encoder) error {
15177 if err := self.NiciraFlowUpdateEvent.Serialize(encoder); err != nil {
15178 return err
15179 }
15180
15181 encoder.PutUint16(uint16(self.Reason))
15182 encoder.PutUint16(uint16(self.Priority))
15183 encoder.PutUint16(uint16(self.IdleTimeout))
15184 encoder.PutUint16(uint16(self.HardTimeout))
15185 encoder.PutUint16(uint16(self.MatchLen))
15186 encoder.PutUint8(uint8(self.TableId))
15187 encoder.Write(bytes.Repeat([]byte{0}, 1))
15188 encoder.PutUint64(uint64(self.Cookie))
15189 if err := self.Match.Serialize(encoder); err != nil {
15190 return err
15191 }
15192
15193 for _, obj := range self.Actions {
15194 if err := obj.Serialize(encoder); err != nil {
15195 return err
15196 }
15197 }
15198
15199 binary.BigEndian.PutUint16(encoder.Bytes()[0:2], uint16(len(encoder.Bytes())))
15200
15201 return nil
15202}
15203
15204func DecodeNiciraFlowUpdateFullModified(parent *NiciraFlowUpdateEvent, decoder *goloxi.Decoder) (*NiciraFlowUpdateFullModified, error) {
15205 _niciraflowupdatefullmodified := &NiciraFlowUpdateFullModified{NiciraFlowUpdateEvent: parent}
15206 if decoder.Length() < 20 {
15207 return nil, fmt.Errorf("NiciraFlowUpdateFullModified packet too short: %d < 20", decoder.Length())
15208 }
15209 _niciraflowupdatefullmodified.Reason = uint16(decoder.ReadUint16())
15210 _niciraflowupdatefullmodified.Priority = uint16(decoder.ReadUint16())
15211 _niciraflowupdatefullmodified.IdleTimeout = uint16(decoder.ReadUint16())
15212 _niciraflowupdatefullmodified.HardTimeout = uint16(decoder.ReadUint16())
15213 _niciraflowupdatefullmodified.MatchLen = uint16(decoder.ReadUint16())
15214 _niciraflowupdatefullmodified.TableId = uint8(decoder.ReadByte())
15215 decoder.Skip(1)
15216 _niciraflowupdatefullmodified.Cookie = uint64(decoder.ReadUint64())
15217 if err := _niciraflowupdatefullmodified.Match.Decode(decoder.SliceDecoder(int(_niciraflowupdatefullmodified.MatchLen), 0)); err != nil {
15218 return nil, err
15219 }
15220
15221 decoder.SkipAlign()
15222
15223 for decoder.Length() >= 8 {
15224 item, err := DecodeAction(decoder)
15225 if err != nil {
15226 return nil, err
15227 }
15228 if item != nil {
15229 _niciraflowupdatefullmodified.Actions = append(_niciraflowupdatefullmodified.Actions, item)
15230 }
15231 }
15232 return _niciraflowupdatefullmodified, nil
15233}
15234
15235func NewNiciraFlowUpdateFullModified() *NiciraFlowUpdateFullModified {
15236 obj := &NiciraFlowUpdateFullModified{
15237 NiciraFlowUpdateEvent: NewNiciraFlowUpdateEvent(2),
15238 }
15239 return obj
15240}
15241
15242type OxmIdArpOp struct {
15243 *OxmId
15244}
15245
15246type IOxmIdArpOp interface {
15247 IOxmId
15248}
15249
15250func (self *OxmIdArpOp) Serialize(encoder *goloxi.Encoder) error {
15251 if err := self.OxmId.Serialize(encoder); err != nil {
15252 return err
15253 }
15254
15255 return nil
15256}
15257
15258func DecodeOxmIdArpOp(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpOp, error) {
15259 _oxmidarpop := &OxmIdArpOp{OxmId: parent}
15260 return _oxmidarpop, nil
15261}
15262
15263func NewOxmIdArpOp() *OxmIdArpOp {
15264 obj := &OxmIdArpOp{
15265 OxmId: NewOxmId(7682),
15266 }
15267 return obj
15268}
15269func (self *OxmIdArpOp) GetOXMName() string {
15270 return "arp_op"
15271}
15272
15273func (self *OxmIdArpOp) MarshalJSON() ([]byte, error) {
15274 if self.TypeLen == 0 {
15275 return []byte("\"\""), nil
15276 } else {
15277 return []byte("\"" + self.GetOXMName() + "\""), nil
15278 }
15279}
15280
15281type OxmIdArpSha struct {
15282 *OxmId
15283}
15284
15285type IOxmIdArpSha interface {
15286 IOxmId
15287}
15288
15289func (self *OxmIdArpSha) Serialize(encoder *goloxi.Encoder) error {
15290 if err := self.OxmId.Serialize(encoder); err != nil {
15291 return err
15292 }
15293
15294 return nil
15295}
15296
15297func DecodeOxmIdArpSha(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpSha, error) {
15298 _oxmidarpsha := &OxmIdArpSha{OxmId: parent}
15299 return _oxmidarpsha, nil
15300}
15301
15302func NewOxmIdArpSha() *OxmIdArpSha {
15303 obj := &OxmIdArpSha{
15304 OxmId: NewOxmId(74246),
15305 }
15306 return obj
15307}
15308func (self *OxmIdArpSha) GetOXMName() string {
15309 return "arp_sha"
15310}
15311
15312func (self *OxmIdArpSha) MarshalJSON() ([]byte, error) {
15313 if self.TypeLen == 0 {
15314 return []byte("\"\""), nil
15315 } else {
15316 return []byte("\"" + self.GetOXMName() + "\""), nil
15317 }
15318}
15319
15320type OxmIdArpShaMasked struct {
15321 *OxmId
15322}
15323
15324type IOxmIdArpShaMasked interface {
15325 IOxmId
15326}
15327
15328func (self *OxmIdArpShaMasked) Serialize(encoder *goloxi.Encoder) error {
15329 if err := self.OxmId.Serialize(encoder); err != nil {
15330 return err
15331 }
15332
15333 return nil
15334}
15335
15336func DecodeOxmIdArpShaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpShaMasked, error) {
15337 _oxmidarpshamasked := &OxmIdArpShaMasked{OxmId: parent}
15338 return _oxmidarpshamasked, nil
15339}
15340
15341func NewOxmIdArpShaMasked() *OxmIdArpShaMasked {
15342 obj := &OxmIdArpShaMasked{
15343 OxmId: NewOxmId(74507),
15344 }
15345 return obj
15346}
15347func (self *OxmIdArpShaMasked) GetOXMName() string {
15348 return "arp_sha_masked"
15349}
15350
15351func (self *OxmIdArpShaMasked) MarshalJSON() ([]byte, error) {
15352 if self.TypeLen == 0 {
15353 return []byte("\"\""), nil
15354 } else {
15355 return []byte("\"" + self.GetOXMName() + "\""), nil
15356 }
15357}
15358
15359type OxmIdArpSpa struct {
15360 *OxmId
15361}
15362
15363type IOxmIdArpSpa interface {
15364 IOxmId
15365}
15366
15367func (self *OxmIdArpSpa) Serialize(encoder *goloxi.Encoder) error {
15368 if err := self.OxmId.Serialize(encoder); err != nil {
15369 return err
15370 }
15371
15372 return nil
15373}
15374
15375func DecodeOxmIdArpSpa(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpSpa, error) {
15376 _oxmidarpspa := &OxmIdArpSpa{OxmId: parent}
15377 return _oxmidarpspa, nil
15378}
15379
15380func NewOxmIdArpSpa() *OxmIdArpSpa {
15381 obj := &OxmIdArpSpa{
15382 OxmId: NewOxmId(8196),
15383 }
15384 return obj
15385}
15386func (self *OxmIdArpSpa) GetOXMName() string {
15387 return "arp_spa"
15388}
15389
15390func (self *OxmIdArpSpa) MarshalJSON() ([]byte, error) {
15391 if self.TypeLen == 0 {
15392 return []byte("\"\""), nil
15393 } else {
15394 return []byte("\"" + self.GetOXMName() + "\""), nil
15395 }
15396}
15397
15398type OxmIdArpSpaMasked struct {
15399 *OxmId
15400}
15401
15402type IOxmIdArpSpaMasked interface {
15403 IOxmId
15404}
15405
15406func (self *OxmIdArpSpaMasked) Serialize(encoder *goloxi.Encoder) error {
15407 if err := self.OxmId.Serialize(encoder); err != nil {
15408 return err
15409 }
15410
15411 return nil
15412}
15413
15414func DecodeOxmIdArpSpaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpSpaMasked, error) {
15415 _oxmidarpspamasked := &OxmIdArpSpaMasked{OxmId: parent}
15416 return _oxmidarpspamasked, nil
15417}
15418
15419func NewOxmIdArpSpaMasked() *OxmIdArpSpaMasked {
15420 obj := &OxmIdArpSpaMasked{
15421 OxmId: NewOxmId(8452),
15422 }
15423 return obj
15424}
15425func (self *OxmIdArpSpaMasked) GetOXMName() string {
15426 return "arp_spa_masked"
15427}
15428
15429func (self *OxmIdArpSpaMasked) MarshalJSON() ([]byte, error) {
15430 if self.TypeLen == 0 {
15431 return []byte("\"\""), nil
15432 } else {
15433 return []byte("\"" + self.GetOXMName() + "\""), nil
15434 }
15435}
15436
15437type OxmIdArpTha struct {
15438 *OxmId
15439}
15440
15441type IOxmIdArpTha interface {
15442 IOxmId
15443}
15444
15445func (self *OxmIdArpTha) Serialize(encoder *goloxi.Encoder) error {
15446 if err := self.OxmId.Serialize(encoder); err != nil {
15447 return err
15448 }
15449
15450 return nil
15451}
15452
15453func DecodeOxmIdArpTha(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpTha, error) {
15454 _oxmidarptha := &OxmIdArpTha{OxmId: parent}
15455 return _oxmidarptha, nil
15456}
15457
15458func NewOxmIdArpTha() *OxmIdArpTha {
15459 obj := &OxmIdArpTha{
15460 OxmId: NewOxmId(74758),
15461 }
15462 return obj
15463}
15464func (self *OxmIdArpTha) GetOXMName() string {
15465 return "arp_tha"
15466}
15467
15468func (self *OxmIdArpTha) MarshalJSON() ([]byte, error) {
15469 if self.TypeLen == 0 {
15470 return []byte("\"\""), nil
15471 } else {
15472 return []byte("\"" + self.GetOXMName() + "\""), nil
15473 }
15474}
15475
15476type OxmIdArpThaMasked struct {
15477 *OxmId
15478}
15479
15480type IOxmIdArpThaMasked interface {
15481 IOxmId
15482}
15483
15484func (self *OxmIdArpThaMasked) Serialize(encoder *goloxi.Encoder) error {
15485 if err := self.OxmId.Serialize(encoder); err != nil {
15486 return err
15487 }
15488
15489 return nil
15490}
15491
15492func DecodeOxmIdArpThaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpThaMasked, error) {
15493 _oxmidarpthamasked := &OxmIdArpThaMasked{OxmId: parent}
15494 return _oxmidarpthamasked, nil
15495}
15496
15497func NewOxmIdArpThaMasked() *OxmIdArpThaMasked {
15498 obj := &OxmIdArpThaMasked{
15499 OxmId: NewOxmId(75019),
15500 }
15501 return obj
15502}
15503func (self *OxmIdArpThaMasked) GetOXMName() string {
15504 return "arp_tha_masked"
15505}
15506
15507func (self *OxmIdArpThaMasked) MarshalJSON() ([]byte, error) {
15508 if self.TypeLen == 0 {
15509 return []byte("\"\""), nil
15510 } else {
15511 return []byte("\"" + self.GetOXMName() + "\""), nil
15512 }
15513}
15514
15515type OxmIdArpTpa struct {
15516 *OxmId
15517}
15518
15519type IOxmIdArpTpa interface {
15520 IOxmId
15521}
15522
15523func (self *OxmIdArpTpa) Serialize(encoder *goloxi.Encoder) error {
15524 if err := self.OxmId.Serialize(encoder); err != nil {
15525 return err
15526 }
15527
15528 return nil
15529}
15530
15531func DecodeOxmIdArpTpa(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpTpa, error) {
15532 _oxmidarptpa := &OxmIdArpTpa{OxmId: parent}
15533 return _oxmidarptpa, nil
15534}
15535
15536func NewOxmIdArpTpa() *OxmIdArpTpa {
15537 obj := &OxmIdArpTpa{
15538 OxmId: NewOxmId(8708),
15539 }
15540 return obj
15541}
15542func (self *OxmIdArpTpa) GetOXMName() string {
15543 return "arp_tpa"
15544}
15545
15546func (self *OxmIdArpTpa) MarshalJSON() ([]byte, error) {
15547 if self.TypeLen == 0 {
15548 return []byte("\"\""), nil
15549 } else {
15550 return []byte("\"" + self.GetOXMName() + "\""), nil
15551 }
15552}
15553
15554type OxmIdArpTpaMasked struct {
15555 *OxmId
15556}
15557
15558type IOxmIdArpTpaMasked interface {
15559 IOxmId
15560}
15561
15562func (self *OxmIdArpTpaMasked) Serialize(encoder *goloxi.Encoder) error {
15563 if err := self.OxmId.Serialize(encoder); err != nil {
15564 return err
15565 }
15566
15567 return nil
15568}
15569
15570func DecodeOxmIdArpTpaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpTpaMasked, error) {
15571 _oxmidarptpamasked := &OxmIdArpTpaMasked{OxmId: parent}
15572 return _oxmidarptpamasked, nil
15573}
15574
15575func NewOxmIdArpTpaMasked() *OxmIdArpTpaMasked {
15576 obj := &OxmIdArpTpaMasked{
15577 OxmId: NewOxmId(8968),
15578 }
15579 return obj
15580}
15581func (self *OxmIdArpTpaMasked) GetOXMName() string {
15582 return "arp_tpa_masked"
15583}
15584
15585func (self *OxmIdArpTpaMasked) MarshalJSON() ([]byte, error) {
15586 if self.TypeLen == 0 {
15587 return []byte("\"\""), nil
15588 } else {
15589 return []byte("\"" + self.GetOXMName() + "\""), nil
15590 }
15591}
15592
15593type OxmIdConjId struct {
15594 *OxmId
15595}
15596
15597type IOxmIdConjId interface {
15598 IOxmId
15599}
15600
15601func (self *OxmIdConjId) Serialize(encoder *goloxi.Encoder) error {
15602 if err := self.OxmId.Serialize(encoder); err != nil {
15603 return err
15604 }
15605
15606 return nil
15607}
15608
15609func DecodeOxmIdConjId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConjId, error) {
15610 _oxmidconjid := &OxmIdConjId{OxmId: parent}
15611 return _oxmidconjid, nil
15612}
15613
15614func NewOxmIdConjId() *OxmIdConjId {
15615 obj := &OxmIdConjId{
15616 OxmId: NewOxmId(84484),
15617 }
15618 return obj
15619}
15620func (self *OxmIdConjId) GetOXMName() string {
15621 return "conj_id"
15622}
15623
15624func (self *OxmIdConjId) MarshalJSON() ([]byte, error) {
15625 if self.TypeLen == 0 {
15626 return []byte("\"\""), nil
15627 } else {
15628 return []byte("\"" + self.GetOXMName() + "\""), nil
15629 }
15630}
15631
15632type OxmIdCtIpv6Dst struct {
15633 *OxmId
15634}
15635
15636type IOxmIdCtIpv6Dst interface {
15637 IOxmId
15638}
15639
15640func (self *OxmIdCtIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
15641 if err := self.OxmId.Serialize(encoder); err != nil {
15642 return err
15643 }
15644
15645 return nil
15646}
15647
15648func DecodeOxmIdCtIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6Dst, error) {
15649 _oxmidctipv6dst := &OxmIdCtIpv6Dst{OxmId: parent}
15650 return _oxmidctipv6dst, nil
15651}
15652
15653func NewOxmIdCtIpv6Dst() *OxmIdCtIpv6Dst {
15654 obj := &OxmIdCtIpv6Dst{
15655 OxmId: NewOxmId(128528),
15656 }
15657 return obj
15658}
15659func (self *OxmIdCtIpv6Dst) GetOXMName() string {
15660 return "ct_ipv6_dst"
15661}
15662
15663func (self *OxmIdCtIpv6Dst) MarshalJSON() ([]byte, error) {
15664 if self.TypeLen == 0 {
15665 return []byte("\"\""), nil
15666 } else {
15667 return []byte("\"" + self.GetOXMName() + "\""), nil
15668 }
15669}
15670
15671type OxmIdCtIpv6DstMasked struct {
15672 *OxmId
15673}
15674
15675type IOxmIdCtIpv6DstMasked interface {
15676 IOxmId
15677}
15678
15679func (self *OxmIdCtIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
15680 if err := self.OxmId.Serialize(encoder); err != nil {
15681 return err
15682 }
15683
15684 return nil
15685}
15686
15687func DecodeOxmIdCtIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6DstMasked, error) {
15688 _oxmidctipv6dstmasked := &OxmIdCtIpv6DstMasked{OxmId: parent}
15689 return _oxmidctipv6dstmasked, nil
15690}
15691
15692func NewOxmIdCtIpv6DstMasked() *OxmIdCtIpv6DstMasked {
15693 obj := &OxmIdCtIpv6DstMasked{
15694 OxmId: NewOxmId(128800),
15695 }
15696 return obj
15697}
15698func (self *OxmIdCtIpv6DstMasked) GetOXMName() string {
15699 return "ct_ipv6_dst_masked"
15700}
15701
15702func (self *OxmIdCtIpv6DstMasked) MarshalJSON() ([]byte, error) {
15703 if self.TypeLen == 0 {
15704 return []byte("\"\""), nil
15705 } else {
15706 return []byte("\"" + self.GetOXMName() + "\""), nil
15707 }
15708}
15709
15710type OxmIdCtIpv6Src struct {
15711 *OxmId
15712}
15713
15714type IOxmIdCtIpv6Src interface {
15715 IOxmId
15716}
15717
15718func (self *OxmIdCtIpv6Src) Serialize(encoder *goloxi.Encoder) error {
15719 if err := self.OxmId.Serialize(encoder); err != nil {
15720 return err
15721 }
15722
15723 return nil
15724}
15725
15726func DecodeOxmIdCtIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6Src, error) {
15727 _oxmidctipv6src := &OxmIdCtIpv6Src{OxmId: parent}
15728 return _oxmidctipv6src, nil
15729}
15730
15731func NewOxmIdCtIpv6Src() *OxmIdCtIpv6Src {
15732 obj := &OxmIdCtIpv6Src{
15733 OxmId: NewOxmId(128016),
15734 }
15735 return obj
15736}
15737func (self *OxmIdCtIpv6Src) GetOXMName() string {
15738 return "ct_ipv6_src"
15739}
15740
15741func (self *OxmIdCtIpv6Src) MarshalJSON() ([]byte, error) {
15742 if self.TypeLen == 0 {
15743 return []byte("\"\""), nil
15744 } else {
15745 return []byte("\"" + self.GetOXMName() + "\""), nil
15746 }
15747}
15748
15749type OxmIdCtIpv6SrcMasked struct {
15750 *OxmId
15751}
15752
15753type IOxmIdCtIpv6SrcMasked interface {
15754 IOxmId
15755}
15756
15757func (self *OxmIdCtIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
15758 if err := self.OxmId.Serialize(encoder); err != nil {
15759 return err
15760 }
15761
15762 return nil
15763}
15764
15765func DecodeOxmIdCtIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6SrcMasked, error) {
15766 _oxmidctipv6srcmasked := &OxmIdCtIpv6SrcMasked{OxmId: parent}
15767 return _oxmidctipv6srcmasked, nil
15768}
15769
15770func NewOxmIdCtIpv6SrcMasked() *OxmIdCtIpv6SrcMasked {
15771 obj := &OxmIdCtIpv6SrcMasked{
15772 OxmId: NewOxmId(128288),
15773 }
15774 return obj
15775}
15776func (self *OxmIdCtIpv6SrcMasked) GetOXMName() string {
15777 return "ct_ipv6_src_masked"
15778}
15779
15780func (self *OxmIdCtIpv6SrcMasked) MarshalJSON() ([]byte, error) {
15781 if self.TypeLen == 0 {
15782 return []byte("\"\""), nil
15783 } else {
15784 return []byte("\"" + self.GetOXMName() + "\""), nil
15785 }
15786}
15787
15788type OxmIdCtLabel struct {
15789 *OxmId
15790}
15791
15792type IOxmIdCtLabel interface {
15793 IOxmId
15794}
15795
15796func (self *OxmIdCtLabel) Serialize(encoder *goloxi.Encoder) error {
15797 if err := self.OxmId.Serialize(encoder); err != nil {
15798 return err
15799 }
15800
15801 return nil
15802}
15803
15804func DecodeOxmIdCtLabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtLabel, error) {
15805 _oxmidctlabel := &OxmIdCtLabel{OxmId: parent}
15806 return _oxmidctlabel, nil
15807}
15808
15809func NewOxmIdCtLabel() *OxmIdCtLabel {
15810 obj := &OxmIdCtLabel{
15811 OxmId: NewOxmId(120848),
15812 }
15813 return obj
15814}
15815func (self *OxmIdCtLabel) GetOXMName() string {
15816 return "ct_label"
15817}
15818
15819func (self *OxmIdCtLabel) MarshalJSON() ([]byte, error) {
15820 if self.TypeLen == 0 {
15821 return []byte("\"\""), nil
15822 } else {
15823 return []byte("\"" + self.GetOXMName() + "\""), nil
15824 }
15825}
15826
15827type OxmIdCtLabelMasked struct {
15828 *OxmId
15829}
15830
15831type IOxmIdCtLabelMasked interface {
15832 IOxmId
15833}
15834
15835func (self *OxmIdCtLabelMasked) Serialize(encoder *goloxi.Encoder) error {
15836 if err := self.OxmId.Serialize(encoder); err != nil {
15837 return err
15838 }
15839
15840 return nil
15841}
15842
15843func DecodeOxmIdCtLabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtLabelMasked, error) {
15844 _oxmidctlabelmasked := &OxmIdCtLabelMasked{OxmId: parent}
15845 return _oxmidctlabelmasked, nil
15846}
15847
15848func NewOxmIdCtLabelMasked() *OxmIdCtLabelMasked {
15849 obj := &OxmIdCtLabelMasked{
15850 OxmId: NewOxmId(121120),
15851 }
15852 return obj
15853}
15854func (self *OxmIdCtLabelMasked) GetOXMName() string {
15855 return "ct_label_masked"
15856}
15857
15858func (self *OxmIdCtLabelMasked) MarshalJSON() ([]byte, error) {
15859 if self.TypeLen == 0 {
15860 return []byte("\"\""), nil
15861 } else {
15862 return []byte("\"" + self.GetOXMName() + "\""), nil
15863 }
15864}
15865
15866type OxmIdCtMark struct {
15867 *OxmId
15868}
15869
15870type IOxmIdCtMark interface {
15871 IOxmId
15872}
15873
15874func (self *OxmIdCtMark) Serialize(encoder *goloxi.Encoder) error {
15875 if err := self.OxmId.Serialize(encoder); err != nil {
15876 return err
15877 }
15878
15879 return nil
15880}
15881
15882func DecodeOxmIdCtMark(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtMark, error) {
15883 _oxmidctmark := &OxmIdCtMark{OxmId: parent}
15884 return _oxmidctmark, nil
15885}
15886
15887func NewOxmIdCtMark() *OxmIdCtMark {
15888 obj := &OxmIdCtMark{
15889 OxmId: NewOxmId(120324),
15890 }
15891 return obj
15892}
15893func (self *OxmIdCtMark) GetOXMName() string {
15894 return "ct_mark"
15895}
15896
15897func (self *OxmIdCtMark) MarshalJSON() ([]byte, error) {
15898 if self.TypeLen == 0 {
15899 return []byte("\"\""), nil
15900 } else {
15901 return []byte("\"" + self.GetOXMName() + "\""), nil
15902 }
15903}
15904
15905type OxmIdCtMarkMasked struct {
15906 *OxmId
15907}
15908
15909type IOxmIdCtMarkMasked interface {
15910 IOxmId
15911}
15912
15913func (self *OxmIdCtMarkMasked) Serialize(encoder *goloxi.Encoder) error {
15914 if err := self.OxmId.Serialize(encoder); err != nil {
15915 return err
15916 }
15917
15918 return nil
15919}
15920
15921func DecodeOxmIdCtMarkMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtMarkMasked, error) {
15922 _oxmidctmarkmasked := &OxmIdCtMarkMasked{OxmId: parent}
15923 return _oxmidctmarkmasked, nil
15924}
15925
15926func NewOxmIdCtMarkMasked() *OxmIdCtMarkMasked {
15927 obj := &OxmIdCtMarkMasked{
15928 OxmId: NewOxmId(120584),
15929 }
15930 return obj
15931}
15932func (self *OxmIdCtMarkMasked) GetOXMName() string {
15933 return "ct_mark_masked"
15934}
15935
15936func (self *OxmIdCtMarkMasked) MarshalJSON() ([]byte, error) {
15937 if self.TypeLen == 0 {
15938 return []byte("\"\""), nil
15939 } else {
15940 return []byte("\"" + self.GetOXMName() + "\""), nil
15941 }
15942}
15943
15944type OxmIdCtNwDst struct {
15945 *OxmId
15946}
15947
15948type IOxmIdCtNwDst interface {
15949 IOxmId
15950}
15951
15952func (self *OxmIdCtNwDst) Serialize(encoder *goloxi.Encoder) error {
15953 if err := self.OxmId.Serialize(encoder); err != nil {
15954 return err
15955 }
15956
15957 return nil
15958}
15959
15960func DecodeOxmIdCtNwDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwDst, error) {
15961 _oxmidctnwdst := &OxmIdCtNwDst{OxmId: parent}
15962 return _oxmidctnwdst, nil
15963}
15964
15965func NewOxmIdCtNwDst() *OxmIdCtNwDst {
15966 obj := &OxmIdCtNwDst{
15967 OxmId: NewOxmId(127492),
15968 }
15969 return obj
15970}
15971func (self *OxmIdCtNwDst) GetOXMName() string {
15972 return "ct_nw_dst"
15973}
15974
15975func (self *OxmIdCtNwDst) MarshalJSON() ([]byte, error) {
15976 if self.TypeLen == 0 {
15977 return []byte("\"\""), nil
15978 } else {
15979 return []byte("\"" + self.GetOXMName() + "\""), nil
15980 }
15981}
15982
15983type OxmIdCtNwDstMasked struct {
15984 *OxmId
15985}
15986
15987type IOxmIdCtNwDstMasked interface {
15988 IOxmId
15989}
15990
15991func (self *OxmIdCtNwDstMasked) Serialize(encoder *goloxi.Encoder) error {
15992 if err := self.OxmId.Serialize(encoder); err != nil {
15993 return err
15994 }
15995
15996 return nil
15997}
15998
15999func DecodeOxmIdCtNwDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwDstMasked, error) {
16000 _oxmidctnwdstmasked := &OxmIdCtNwDstMasked{OxmId: parent}
16001 return _oxmidctnwdstmasked, nil
16002}
16003
16004func NewOxmIdCtNwDstMasked() *OxmIdCtNwDstMasked {
16005 obj := &OxmIdCtNwDstMasked{
16006 OxmId: NewOxmId(127752),
16007 }
16008 return obj
16009}
16010func (self *OxmIdCtNwDstMasked) GetOXMName() string {
16011 return "ct_nw_dst_masked"
16012}
16013
16014func (self *OxmIdCtNwDstMasked) MarshalJSON() ([]byte, error) {
16015 if self.TypeLen == 0 {
16016 return []byte("\"\""), nil
16017 } else {
16018 return []byte("\"" + self.GetOXMName() + "\""), nil
16019 }
16020}
16021
16022type OxmIdCtNwProto struct {
16023 *OxmId
16024}
16025
16026type IOxmIdCtNwProto interface {
16027 IOxmId
16028}
16029
16030func (self *OxmIdCtNwProto) Serialize(encoder *goloxi.Encoder) error {
16031 if err := self.OxmId.Serialize(encoder); err != nil {
16032 return err
16033 }
16034
16035 return nil
16036}
16037
16038func DecodeOxmIdCtNwProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwProto, error) {
16039 _oxmidctnwproto := &OxmIdCtNwProto{OxmId: parent}
16040 return _oxmidctnwproto, nil
16041}
16042
16043func NewOxmIdCtNwProto() *OxmIdCtNwProto {
16044 obj := &OxmIdCtNwProto{
16045 OxmId: NewOxmId(126465),
16046 }
16047 return obj
16048}
16049func (self *OxmIdCtNwProto) GetOXMName() string {
16050 return "ct_nw_proto"
16051}
16052
16053func (self *OxmIdCtNwProto) MarshalJSON() ([]byte, error) {
16054 if self.TypeLen == 0 {
16055 return []byte("\"\""), nil
16056 } else {
16057 return []byte("\"" + self.GetOXMName() + "\""), nil
16058 }
16059}
16060
16061type OxmIdCtNwSrc struct {
16062 *OxmId
16063}
16064
16065type IOxmIdCtNwSrc interface {
16066 IOxmId
16067}
16068
16069func (self *OxmIdCtNwSrc) Serialize(encoder *goloxi.Encoder) error {
16070 if err := self.OxmId.Serialize(encoder); err != nil {
16071 return err
16072 }
16073
16074 return nil
16075}
16076
16077func DecodeOxmIdCtNwSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwSrc, error) {
16078 _oxmidctnwsrc := &OxmIdCtNwSrc{OxmId: parent}
16079 return _oxmidctnwsrc, nil
16080}
16081
16082func NewOxmIdCtNwSrc() *OxmIdCtNwSrc {
16083 obj := &OxmIdCtNwSrc{
16084 OxmId: NewOxmId(126980),
16085 }
16086 return obj
16087}
16088func (self *OxmIdCtNwSrc) GetOXMName() string {
16089 return "ct_nw_src"
16090}
16091
16092func (self *OxmIdCtNwSrc) MarshalJSON() ([]byte, error) {
16093 if self.TypeLen == 0 {
16094 return []byte("\"\""), nil
16095 } else {
16096 return []byte("\"" + self.GetOXMName() + "\""), nil
16097 }
16098}
16099
16100type OxmIdCtNwSrcMasked struct {
16101 *OxmId
16102}
16103
16104type IOxmIdCtNwSrcMasked interface {
16105 IOxmId
16106}
16107
16108func (self *OxmIdCtNwSrcMasked) Serialize(encoder *goloxi.Encoder) error {
16109 if err := self.OxmId.Serialize(encoder); err != nil {
16110 return err
16111 }
16112
16113 return nil
16114}
16115
16116func DecodeOxmIdCtNwSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwSrcMasked, error) {
16117 _oxmidctnwsrcmasked := &OxmIdCtNwSrcMasked{OxmId: parent}
16118 return _oxmidctnwsrcmasked, nil
16119}
16120
16121func NewOxmIdCtNwSrcMasked() *OxmIdCtNwSrcMasked {
16122 obj := &OxmIdCtNwSrcMasked{
16123 OxmId: NewOxmId(127240),
16124 }
16125 return obj
16126}
16127func (self *OxmIdCtNwSrcMasked) GetOXMName() string {
16128 return "ct_nw_src_masked"
16129}
16130
16131func (self *OxmIdCtNwSrcMasked) MarshalJSON() ([]byte, error) {
16132 if self.TypeLen == 0 {
16133 return []byte("\"\""), nil
16134 } else {
16135 return []byte("\"" + self.GetOXMName() + "\""), nil
16136 }
16137}
16138
16139type OxmIdCtState struct {
16140 *OxmId
16141}
16142
16143type IOxmIdCtState interface {
16144 IOxmId
16145}
16146
16147func (self *OxmIdCtState) Serialize(encoder *goloxi.Encoder) error {
16148 if err := self.OxmId.Serialize(encoder); err != nil {
16149 return err
16150 }
16151
16152 return nil
16153}
16154
16155func DecodeOxmIdCtState(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtState, error) {
16156 _oxmidctstate := &OxmIdCtState{OxmId: parent}
16157 return _oxmidctstate, nil
16158}
16159
16160func NewOxmIdCtState() *OxmIdCtState {
16161 obj := &OxmIdCtState{
16162 OxmId: NewOxmId(119300),
16163 }
16164 return obj
16165}
16166func (self *OxmIdCtState) GetOXMName() string {
16167 return "ct_state"
16168}
16169
16170func (self *OxmIdCtState) MarshalJSON() ([]byte, error) {
16171 if self.TypeLen == 0 {
16172 return []byte("\"\""), nil
16173 } else {
16174 return []byte("\"" + self.GetOXMName() + "\""), nil
16175 }
16176}
16177
16178type OxmIdCtStateMasked struct {
16179 *OxmId
16180}
16181
16182type IOxmIdCtStateMasked interface {
16183 IOxmId
16184}
16185
16186func (self *OxmIdCtStateMasked) Serialize(encoder *goloxi.Encoder) error {
16187 if err := self.OxmId.Serialize(encoder); err != nil {
16188 return err
16189 }
16190
16191 return nil
16192}
16193
16194func DecodeOxmIdCtStateMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtStateMasked, error) {
16195 _oxmidctstatemasked := &OxmIdCtStateMasked{OxmId: parent}
16196 return _oxmidctstatemasked, nil
16197}
16198
16199func NewOxmIdCtStateMasked() *OxmIdCtStateMasked {
16200 obj := &OxmIdCtStateMasked{
16201 OxmId: NewOxmId(119560),
16202 }
16203 return obj
16204}
16205func (self *OxmIdCtStateMasked) GetOXMName() string {
16206 return "ct_state_masked"
16207}
16208
16209func (self *OxmIdCtStateMasked) MarshalJSON() ([]byte, error) {
16210 if self.TypeLen == 0 {
16211 return []byte("\"\""), nil
16212 } else {
16213 return []byte("\"" + self.GetOXMName() + "\""), nil
16214 }
16215}
16216
16217type OxmIdCtTpDst struct {
16218 *OxmId
16219}
16220
16221type IOxmIdCtTpDst interface {
16222 IOxmId
16223}
16224
16225func (self *OxmIdCtTpDst) Serialize(encoder *goloxi.Encoder) error {
16226 if err := self.OxmId.Serialize(encoder); err != nil {
16227 return err
16228 }
16229
16230 return nil
16231}
16232
16233func DecodeOxmIdCtTpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpDst, error) {
16234 _oxmidcttpdst := &OxmIdCtTpDst{OxmId: parent}
16235 return _oxmidcttpdst, nil
16236}
16237
16238func NewOxmIdCtTpDst() *OxmIdCtTpDst {
16239 obj := &OxmIdCtTpDst{
16240 OxmId: NewOxmId(129538),
16241 }
16242 return obj
16243}
16244func (self *OxmIdCtTpDst) GetOXMName() string {
16245 return "ct_tp_dst"
16246}
16247
16248func (self *OxmIdCtTpDst) MarshalJSON() ([]byte, error) {
16249 if self.TypeLen == 0 {
16250 return []byte("\"\""), nil
16251 } else {
16252 return []byte("\"" + self.GetOXMName() + "\""), nil
16253 }
16254}
16255
16256type OxmIdCtTpDstMasked struct {
16257 *OxmId
16258}
16259
16260type IOxmIdCtTpDstMasked interface {
16261 IOxmId
16262}
16263
16264func (self *OxmIdCtTpDstMasked) Serialize(encoder *goloxi.Encoder) error {
16265 if err := self.OxmId.Serialize(encoder); err != nil {
16266 return err
16267 }
16268
16269 return nil
16270}
16271
16272func DecodeOxmIdCtTpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpDstMasked, error) {
16273 _oxmidcttpdstmasked := &OxmIdCtTpDstMasked{OxmId: parent}
16274 return _oxmidcttpdstmasked, nil
16275}
16276
16277func NewOxmIdCtTpDstMasked() *OxmIdCtTpDstMasked {
16278 obj := &OxmIdCtTpDstMasked{
16279 OxmId: NewOxmId(129796),
16280 }
16281 return obj
16282}
16283func (self *OxmIdCtTpDstMasked) GetOXMName() string {
16284 return "ct_tp_dst_masked"
16285}
16286
16287func (self *OxmIdCtTpDstMasked) MarshalJSON() ([]byte, error) {
16288 if self.TypeLen == 0 {
16289 return []byte("\"\""), nil
16290 } else {
16291 return []byte("\"" + self.GetOXMName() + "\""), nil
16292 }
16293}
16294
16295type OxmIdCtTpSrc struct {
16296 *OxmId
16297}
16298
16299type IOxmIdCtTpSrc interface {
16300 IOxmId
16301}
16302
16303func (self *OxmIdCtTpSrc) Serialize(encoder *goloxi.Encoder) error {
16304 if err := self.OxmId.Serialize(encoder); err != nil {
16305 return err
16306 }
16307
16308 return nil
16309}
16310
16311func DecodeOxmIdCtTpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpSrc, error) {
16312 _oxmidcttpsrc := &OxmIdCtTpSrc{OxmId: parent}
16313 return _oxmidcttpsrc, nil
16314}
16315
16316func NewOxmIdCtTpSrc() *OxmIdCtTpSrc {
16317 obj := &OxmIdCtTpSrc{
16318 OxmId: NewOxmId(129026),
16319 }
16320 return obj
16321}
16322func (self *OxmIdCtTpSrc) GetOXMName() string {
16323 return "ct_tp_src"
16324}
16325
16326func (self *OxmIdCtTpSrc) MarshalJSON() ([]byte, error) {
16327 if self.TypeLen == 0 {
16328 return []byte("\"\""), nil
16329 } else {
16330 return []byte("\"" + self.GetOXMName() + "\""), nil
16331 }
16332}
16333
16334type OxmIdCtTpSrcMasked struct {
16335 *OxmId
16336}
16337
16338type IOxmIdCtTpSrcMasked interface {
16339 IOxmId
16340}
16341
16342func (self *OxmIdCtTpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
16343 if err := self.OxmId.Serialize(encoder); err != nil {
16344 return err
16345 }
16346
16347 return nil
16348}
16349
16350func DecodeOxmIdCtTpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpSrcMasked, error) {
16351 _oxmidcttpsrcmasked := &OxmIdCtTpSrcMasked{OxmId: parent}
16352 return _oxmidcttpsrcmasked, nil
16353}
16354
16355func NewOxmIdCtTpSrcMasked() *OxmIdCtTpSrcMasked {
16356 obj := &OxmIdCtTpSrcMasked{
16357 OxmId: NewOxmId(129284),
16358 }
16359 return obj
16360}
16361func (self *OxmIdCtTpSrcMasked) GetOXMName() string {
16362 return "ct_tp_src_masked"
16363}
16364
16365func (self *OxmIdCtTpSrcMasked) MarshalJSON() ([]byte, error) {
16366 if self.TypeLen == 0 {
16367 return []byte("\"\""), nil
16368 } else {
16369 return []byte("\"" + self.GetOXMName() + "\""), nil
16370 }
16371}
16372
16373type OxmIdCtZone struct {
16374 *OxmId
16375}
16376
16377type IOxmIdCtZone interface {
16378 IOxmId
16379}
16380
16381func (self *OxmIdCtZone) Serialize(encoder *goloxi.Encoder) error {
16382 if err := self.OxmId.Serialize(encoder); err != nil {
16383 return err
16384 }
16385
16386 return nil
16387}
16388
16389func DecodeOxmIdCtZone(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtZone, error) {
16390 _oxmidctzone := &OxmIdCtZone{OxmId: parent}
16391 return _oxmidctzone, nil
16392}
16393
16394func NewOxmIdCtZone() *OxmIdCtZone {
16395 obj := &OxmIdCtZone{
16396 OxmId: NewOxmId(119810),
16397 }
16398 return obj
16399}
16400func (self *OxmIdCtZone) GetOXMName() string {
16401 return "ct_zone"
16402}
16403
16404func (self *OxmIdCtZone) MarshalJSON() ([]byte, error) {
16405 if self.TypeLen == 0 {
16406 return []byte("\"\""), nil
16407 } else {
16408 return []byte("\"" + self.GetOXMName() + "\""), nil
16409 }
16410}
16411
16412type OxmIdDpHash struct {
16413 *OxmId
16414}
16415
16416type IOxmIdDpHash interface {
16417 IOxmId
16418}
16419
16420func (self *OxmIdDpHash) Serialize(encoder *goloxi.Encoder) error {
16421 if err := self.OxmId.Serialize(encoder); err != nil {
16422 return err
16423 }
16424
16425 return nil
16426}
16427
16428func DecodeOxmIdDpHash(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdDpHash, error) {
16429 _oxmiddphash := &OxmIdDpHash{OxmId: parent}
16430 return _oxmiddphash, nil
16431}
16432
16433func NewOxmIdDpHash() *OxmIdDpHash {
16434 obj := &OxmIdDpHash{
16435 OxmId: NewOxmId(83460),
16436 }
16437 return obj
16438}
16439func (self *OxmIdDpHash) GetOXMName() string {
16440 return "dp_hash"
16441}
16442
16443func (self *OxmIdDpHash) MarshalJSON() ([]byte, error) {
16444 if self.TypeLen == 0 {
16445 return []byte("\"\""), nil
16446 } else {
16447 return []byte("\"" + self.GetOXMName() + "\""), nil
16448 }
16449}
16450
16451type OxmIdDpHashMasked struct {
16452 *OxmId
16453}
16454
16455type IOxmIdDpHashMasked interface {
16456 IOxmId
16457}
16458
16459func (self *OxmIdDpHashMasked) Serialize(encoder *goloxi.Encoder) error {
16460 if err := self.OxmId.Serialize(encoder); err != nil {
16461 return err
16462 }
16463
16464 return nil
16465}
16466
16467func DecodeOxmIdDpHashMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdDpHashMasked, error) {
16468 _oxmiddphashmasked := &OxmIdDpHashMasked{OxmId: parent}
16469 return _oxmiddphashmasked, nil
16470}
16471
16472func NewOxmIdDpHashMasked() *OxmIdDpHashMasked {
16473 obj := &OxmIdDpHashMasked{
16474 OxmId: NewOxmId(83720),
16475 }
16476 return obj
16477}
16478func (self *OxmIdDpHashMasked) GetOXMName() string {
16479 return "dp_hash_masked"
16480}
16481
16482func (self *OxmIdDpHashMasked) MarshalJSON() ([]byte, error) {
16483 if self.TypeLen == 0 {
16484 return []byte("\"\""), nil
16485 } else {
16486 return []byte("\"" + self.GetOXMName() + "\""), nil
16487 }
16488}
16489
16490type OxmIdEthDst struct {
16491 *OxmId
16492}
16493
16494type IOxmIdEthDst interface {
16495 IOxmId
16496}
16497
16498func (self *OxmIdEthDst) Serialize(encoder *goloxi.Encoder) error {
16499 if err := self.OxmId.Serialize(encoder); err != nil {
16500 return err
16501 }
16502
16503 return nil
16504}
16505
16506func DecodeOxmIdEthDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthDst, error) {
16507 _oxmidethdst := &OxmIdEthDst{OxmId: parent}
16508 return _oxmidethdst, nil
16509}
16510
16511func NewOxmIdEthDst() *OxmIdEthDst {
16512 obj := &OxmIdEthDst{
16513 OxmId: NewOxmId(518),
16514 }
16515 return obj
16516}
16517func (self *OxmIdEthDst) GetOXMName() string {
16518 return "eth_dst"
16519}
16520
16521func (self *OxmIdEthDst) MarshalJSON() ([]byte, error) {
16522 if self.TypeLen == 0 {
16523 return []byte("\"\""), nil
16524 } else {
16525 return []byte("\"" + self.GetOXMName() + "\""), nil
16526 }
16527}
16528
16529type OxmIdEthDstMasked struct {
16530 *OxmId
16531}
16532
16533type IOxmIdEthDstMasked interface {
16534 IOxmId
16535}
16536
16537func (self *OxmIdEthDstMasked) Serialize(encoder *goloxi.Encoder) error {
16538 if err := self.OxmId.Serialize(encoder); err != nil {
16539 return err
16540 }
16541
16542 return nil
16543}
16544
16545func DecodeOxmIdEthDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthDstMasked, error) {
16546 _oxmidethdstmasked := &OxmIdEthDstMasked{OxmId: parent}
16547 return _oxmidethdstmasked, nil
16548}
16549
16550func NewOxmIdEthDstMasked() *OxmIdEthDstMasked {
16551 obj := &OxmIdEthDstMasked{
16552 OxmId: NewOxmId(779),
16553 }
16554 return obj
16555}
16556func (self *OxmIdEthDstMasked) GetOXMName() string {
16557 return "eth_dst_masked"
16558}
16559
16560func (self *OxmIdEthDstMasked) MarshalJSON() ([]byte, error) {
16561 if self.TypeLen == 0 {
16562 return []byte("\"\""), nil
16563 } else {
16564 return []byte("\"" + self.GetOXMName() + "\""), nil
16565 }
16566}
16567
16568type OxmIdEthSrc struct {
16569 *OxmId
16570}
16571
16572type IOxmIdEthSrc interface {
16573 IOxmId
16574}
16575
16576func (self *OxmIdEthSrc) Serialize(encoder *goloxi.Encoder) error {
16577 if err := self.OxmId.Serialize(encoder); err != nil {
16578 return err
16579 }
16580
16581 return nil
16582}
16583
16584func DecodeOxmIdEthSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthSrc, error) {
16585 _oxmidethsrc := &OxmIdEthSrc{OxmId: parent}
16586 return _oxmidethsrc, nil
16587}
16588
16589func NewOxmIdEthSrc() *OxmIdEthSrc {
16590 obj := &OxmIdEthSrc{
16591 OxmId: NewOxmId(1030),
16592 }
16593 return obj
16594}
16595func (self *OxmIdEthSrc) GetOXMName() string {
16596 return "eth_src"
16597}
16598
16599func (self *OxmIdEthSrc) MarshalJSON() ([]byte, error) {
16600 if self.TypeLen == 0 {
16601 return []byte("\"\""), nil
16602 } else {
16603 return []byte("\"" + self.GetOXMName() + "\""), nil
16604 }
16605}
16606
16607type OxmIdEthSrcMasked struct {
16608 *OxmId
16609}
16610
16611type IOxmIdEthSrcMasked interface {
16612 IOxmId
16613}
16614
16615func (self *OxmIdEthSrcMasked) Serialize(encoder *goloxi.Encoder) error {
16616 if err := self.OxmId.Serialize(encoder); err != nil {
16617 return err
16618 }
16619
16620 return nil
16621}
16622
16623func DecodeOxmIdEthSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthSrcMasked, error) {
16624 _oxmidethsrcmasked := &OxmIdEthSrcMasked{OxmId: parent}
16625 return _oxmidethsrcmasked, nil
16626}
16627
16628func NewOxmIdEthSrcMasked() *OxmIdEthSrcMasked {
16629 obj := &OxmIdEthSrcMasked{
16630 OxmId: NewOxmId(1286),
16631 }
16632 return obj
16633}
16634func (self *OxmIdEthSrcMasked) GetOXMName() string {
16635 return "eth_src_masked"
16636}
16637
16638func (self *OxmIdEthSrcMasked) MarshalJSON() ([]byte, error) {
16639 if self.TypeLen == 0 {
16640 return []byte("\"\""), nil
16641 } else {
16642 return []byte("\"" + self.GetOXMName() + "\""), nil
16643 }
16644}
16645
16646type OxmIdEthType struct {
16647 *OxmId
16648}
16649
16650type IOxmIdEthType interface {
16651 IOxmId
16652}
16653
16654func (self *OxmIdEthType) Serialize(encoder *goloxi.Encoder) error {
16655 if err := self.OxmId.Serialize(encoder); err != nil {
16656 return err
16657 }
16658
16659 return nil
16660}
16661
16662func DecodeOxmIdEthType(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthType, error) {
16663 _oxmidethtype := &OxmIdEthType{OxmId: parent}
16664 return _oxmidethtype, nil
16665}
16666
16667func NewOxmIdEthType() *OxmIdEthType {
16668 obj := &OxmIdEthType{
16669 OxmId: NewOxmId(1538),
16670 }
16671 return obj
16672}
16673func (self *OxmIdEthType) GetOXMName() string {
16674 return "eth_type"
16675}
16676
16677func (self *OxmIdEthType) MarshalJSON() ([]byte, error) {
16678 if self.TypeLen == 0 {
16679 return []byte("\"\""), nil
16680 } else {
16681 return []byte("\"" + self.GetOXMName() + "\""), nil
16682 }
16683}
16684
16685type OxmIdIcmpCode struct {
16686 *OxmId
16687}
16688
16689type IOxmIdIcmpCode interface {
16690 IOxmId
16691}
16692
16693func (self *OxmIdIcmpCode) Serialize(encoder *goloxi.Encoder) error {
16694 if err := self.OxmId.Serialize(encoder); err != nil {
16695 return err
16696 }
16697
16698 return nil
16699}
16700
16701func DecodeOxmIdIcmpCode(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpCode, error) {
16702 _oxmidicmpcode := &OxmIdIcmpCode{OxmId: parent}
16703 return _oxmidicmpcode, nil
16704}
16705
16706func NewOxmIdIcmpCode() *OxmIdIcmpCode {
16707 obj := &OxmIdIcmpCode{
16708 OxmId: NewOxmId(7169),
16709 }
16710 return obj
16711}
16712func (self *OxmIdIcmpCode) GetOXMName() string {
16713 return "icmp_code"
16714}
16715
16716func (self *OxmIdIcmpCode) MarshalJSON() ([]byte, error) {
16717 if self.TypeLen == 0 {
16718 return []byte("\"\""), nil
16719 } else {
16720 return []byte("\"" + self.GetOXMName() + "\""), nil
16721 }
16722}
16723
16724type OxmIdIcmpType struct {
16725 *OxmId
16726}
16727
16728type IOxmIdIcmpType interface {
16729 IOxmId
16730}
16731
16732func (self *OxmIdIcmpType) Serialize(encoder *goloxi.Encoder) error {
16733 if err := self.OxmId.Serialize(encoder); err != nil {
16734 return err
16735 }
16736
16737 return nil
16738}
16739
16740func DecodeOxmIdIcmpType(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpType, error) {
16741 _oxmidicmptype := &OxmIdIcmpType{OxmId: parent}
16742 return _oxmidicmptype, nil
16743}
16744
16745func NewOxmIdIcmpType() *OxmIdIcmpType {
16746 obj := &OxmIdIcmpType{
16747 OxmId: NewOxmId(6657),
16748 }
16749 return obj
16750}
16751func (self *OxmIdIcmpType) GetOXMName() string {
16752 return "icmp_type"
16753}
16754
16755func (self *OxmIdIcmpType) MarshalJSON() ([]byte, error) {
16756 if self.TypeLen == 0 {
16757 return []byte("\"\""), nil
16758 } else {
16759 return []byte("\"" + self.GetOXMName() + "\""), nil
16760 }
16761}
16762
16763type OxmIdIcmpv6Code struct {
16764 *OxmId
16765}
16766
16767type IOxmIdIcmpv6Code interface {
16768 IOxmId
16769}
16770
16771func (self *OxmIdIcmpv6Code) Serialize(encoder *goloxi.Encoder) error {
16772 if err := self.OxmId.Serialize(encoder); err != nil {
16773 return err
16774 }
16775
16776 return nil
16777}
16778
16779func DecodeOxmIdIcmpv6Code(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6Code, error) {
16780 _oxmidicmpv6code := &OxmIdIcmpv6Code{OxmId: parent}
16781 return _oxmidicmpv6code, nil
16782}
16783
16784func NewOxmIdIcmpv6Code() *OxmIdIcmpv6Code {
16785 obj := &OxmIdIcmpv6Code{
16786 OxmId: NewOxmId(76801),
16787 }
16788 return obj
16789}
16790func (self *OxmIdIcmpv6Code) GetOXMName() string {
16791 return "icmpv6_code"
16792}
16793
16794func (self *OxmIdIcmpv6Code) MarshalJSON() ([]byte, error) {
16795 if self.TypeLen == 0 {
16796 return []byte("\"\""), nil
16797 } else {
16798 return []byte("\"" + self.GetOXMName() + "\""), nil
16799 }
16800}
16801
16802type OxmIdIcmpv6Type struct {
16803 *OxmId
16804}
16805
16806type IOxmIdIcmpv6Type interface {
16807 IOxmId
16808}
16809
16810func (self *OxmIdIcmpv6Type) Serialize(encoder *goloxi.Encoder) error {
16811 if err := self.OxmId.Serialize(encoder); err != nil {
16812 return err
16813 }
16814
16815 return nil
16816}
16817
16818func DecodeOxmIdIcmpv6Type(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6Type, error) {
16819 _oxmidicmpv6type := &OxmIdIcmpv6Type{OxmId: parent}
16820 return _oxmidicmpv6type, nil
16821}
16822
16823func NewOxmIdIcmpv6Type() *OxmIdIcmpv6Type {
16824 obj := &OxmIdIcmpv6Type{
16825 OxmId: NewOxmId(76289),
16826 }
16827 return obj
16828}
16829func (self *OxmIdIcmpv6Type) GetOXMName() string {
16830 return "icmpv6_type"
16831}
16832
16833func (self *OxmIdIcmpv6Type) MarshalJSON() ([]byte, error) {
16834 if self.TypeLen == 0 {
16835 return []byte("\"\""), nil
16836 } else {
16837 return []byte("\"" + self.GetOXMName() + "\""), nil
16838 }
16839}
16840
16841type OxmIdInPort struct {
16842 *OxmId
16843}
16844
16845type IOxmIdInPort interface {
16846 IOxmId
16847}
16848
16849func (self *OxmIdInPort) Serialize(encoder *goloxi.Encoder) error {
16850 if err := self.OxmId.Serialize(encoder); err != nil {
16851 return err
16852 }
16853
16854 return nil
16855}
16856
16857func DecodeOxmIdInPort(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPort, error) {
16858 _oxmidinport := &OxmIdInPort{OxmId: parent}
16859 return _oxmidinport, nil
16860}
16861
16862func NewOxmIdInPort() *OxmIdInPort {
16863 obj := &OxmIdInPort{
16864 OxmId: NewOxmId(2),
16865 }
16866 return obj
16867}
16868func (self *OxmIdInPort) GetOXMName() string {
16869 return "in_port"
16870}
16871
16872func (self *OxmIdInPort) MarshalJSON() ([]byte, error) {
16873 if self.TypeLen == 0 {
16874 return []byte("\"\""), nil
16875 } else {
16876 return []byte("\"" + self.GetOXMName() + "\""), nil
16877 }
16878}
16879
16880type OxmIdIpDst struct {
16881 *OxmId
16882}
16883
16884type IOxmIdIpDst interface {
16885 IOxmId
16886}
16887
16888func (self *OxmIdIpDst) Serialize(encoder *goloxi.Encoder) error {
16889 if err := self.OxmId.Serialize(encoder); err != nil {
16890 return err
16891 }
16892
16893 return nil
16894}
16895
16896func DecodeOxmIdIpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDst, error) {
16897 _oxmidipdst := &OxmIdIpDst{OxmId: parent}
16898 return _oxmidipdst, nil
16899}
16900
16901func NewOxmIdIpDst() *OxmIdIpDst {
16902 obj := &OxmIdIpDst{
16903 OxmId: NewOxmId(4100),
16904 }
16905 return obj
16906}
16907func (self *OxmIdIpDst) GetOXMName() string {
16908 return "ip_dst"
16909}
16910
16911func (self *OxmIdIpDst) MarshalJSON() ([]byte, error) {
16912 if self.TypeLen == 0 {
16913 return []byte("\"\""), nil
16914 } else {
16915 return []byte("\"" + self.GetOXMName() + "\""), nil
16916 }
16917}
16918
16919type OxmIdIpDstMasked struct {
16920 *OxmId
16921}
16922
16923type IOxmIdIpDstMasked interface {
16924 IOxmId
16925}
16926
16927func (self *OxmIdIpDstMasked) Serialize(encoder *goloxi.Encoder) error {
16928 if err := self.OxmId.Serialize(encoder); err != nil {
16929 return err
16930 }
16931
16932 return nil
16933}
16934
16935func DecodeOxmIdIpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDstMasked, error) {
16936 _oxmidipdstmasked := &OxmIdIpDstMasked{OxmId: parent}
16937 return _oxmidipdstmasked, nil
16938}
16939
16940func NewOxmIdIpDstMasked() *OxmIdIpDstMasked {
16941 obj := &OxmIdIpDstMasked{
16942 OxmId: NewOxmId(4360),
16943 }
16944 return obj
16945}
16946func (self *OxmIdIpDstMasked) GetOXMName() string {
16947 return "ip_dst_masked"
16948}
16949
16950func (self *OxmIdIpDstMasked) MarshalJSON() ([]byte, error) {
16951 if self.TypeLen == 0 {
16952 return []byte("\"\""), nil
16953 } else {
16954 return []byte("\"" + self.GetOXMName() + "\""), nil
16955 }
16956}
16957
16958type OxmIdIpFrag struct {
16959 *OxmId
16960}
16961
16962type IOxmIdIpFrag interface {
16963 IOxmId
16964}
16965
16966func (self *OxmIdIpFrag) Serialize(encoder *goloxi.Encoder) error {
16967 if err := self.OxmId.Serialize(encoder); err != nil {
16968 return err
16969 }
16970
16971 return nil
16972}
16973
16974func DecodeOxmIdIpFrag(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpFrag, error) {
16975 _oxmidipfrag := &OxmIdIpFrag{OxmId: parent}
16976 return _oxmidipfrag, nil
16977}
16978
16979func NewOxmIdIpFrag() *OxmIdIpFrag {
16980 obj := &OxmIdIpFrag{
16981 OxmId: NewOxmId(78849),
16982 }
16983 return obj
16984}
16985func (self *OxmIdIpFrag) GetOXMName() string {
16986 return "ip_frag"
16987}
16988
16989func (self *OxmIdIpFrag) MarshalJSON() ([]byte, error) {
16990 if self.TypeLen == 0 {
16991 return []byte("\"\""), nil
16992 } else {
16993 return []byte("\"" + self.GetOXMName() + "\""), nil
16994 }
16995}
16996
16997type OxmIdIpFragMasked struct {
16998 *OxmId
16999}
17000
17001type IOxmIdIpFragMasked interface {
17002 IOxmId
17003}
17004
17005func (self *OxmIdIpFragMasked) Serialize(encoder *goloxi.Encoder) error {
17006 if err := self.OxmId.Serialize(encoder); err != nil {
17007 return err
17008 }
17009
17010 return nil
17011}
17012
17013func DecodeOxmIdIpFragMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpFragMasked, error) {
17014 _oxmidipfragmasked := &OxmIdIpFragMasked{OxmId: parent}
17015 return _oxmidipfragmasked, nil
17016}
17017
17018func NewOxmIdIpFragMasked() *OxmIdIpFragMasked {
17019 obj := &OxmIdIpFragMasked{
17020 OxmId: NewOxmId(79106),
17021 }
17022 return obj
17023}
17024func (self *OxmIdIpFragMasked) GetOXMName() string {
17025 return "ip_frag_masked"
17026}
17027
17028func (self *OxmIdIpFragMasked) MarshalJSON() ([]byte, error) {
17029 if self.TypeLen == 0 {
17030 return []byte("\"\""), nil
17031 } else {
17032 return []byte("\"" + self.GetOXMName() + "\""), nil
17033 }
17034}
17035
17036type OxmIdIpSrc struct {
17037 *OxmId
17038}
17039
17040type IOxmIdIpSrc interface {
17041 IOxmId
17042}
17043
17044func (self *OxmIdIpSrc) Serialize(encoder *goloxi.Encoder) error {
17045 if err := self.OxmId.Serialize(encoder); err != nil {
17046 return err
17047 }
17048
17049 return nil
17050}
17051
17052func DecodeOxmIdIpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpSrc, error) {
17053 _oxmidipsrc := &OxmIdIpSrc{OxmId: parent}
17054 return _oxmidipsrc, nil
17055}
17056
17057func NewOxmIdIpSrc() *OxmIdIpSrc {
17058 obj := &OxmIdIpSrc{
17059 OxmId: NewOxmId(3588),
17060 }
17061 return obj
17062}
17063func (self *OxmIdIpSrc) GetOXMName() string {
17064 return "ip_src"
17065}
17066
17067func (self *OxmIdIpSrc) MarshalJSON() ([]byte, error) {
17068 if self.TypeLen == 0 {
17069 return []byte("\"\""), nil
17070 } else {
17071 return []byte("\"" + self.GetOXMName() + "\""), nil
17072 }
17073}
17074
17075type OxmIdIpSrcMasked struct {
17076 *OxmId
17077}
17078
17079type IOxmIdIpSrcMasked interface {
17080 IOxmId
17081}
17082
17083func (self *OxmIdIpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
17084 if err := self.OxmId.Serialize(encoder); err != nil {
17085 return err
17086 }
17087
17088 return nil
17089}
17090
17091func DecodeOxmIdIpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpSrcMasked, error) {
17092 _oxmidipsrcmasked := &OxmIdIpSrcMasked{OxmId: parent}
17093 return _oxmidipsrcmasked, nil
17094}
17095
17096func NewOxmIdIpSrcMasked() *OxmIdIpSrcMasked {
17097 obj := &OxmIdIpSrcMasked{
17098 OxmId: NewOxmId(3848),
17099 }
17100 return obj
17101}
17102func (self *OxmIdIpSrcMasked) GetOXMName() string {
17103 return "ip_src_masked"
17104}
17105
17106func (self *OxmIdIpSrcMasked) MarshalJSON() ([]byte, error) {
17107 if self.TypeLen == 0 {
17108 return []byte("\"\""), nil
17109 } else {
17110 return []byte("\"" + self.GetOXMName() + "\""), nil
17111 }
17112}
17113
17114type OxmIdIpv6Dst struct {
17115 *OxmId
17116}
17117
17118type IOxmIdIpv6Dst interface {
17119 IOxmId
17120}
17121
17122func (self *OxmIdIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
17123 if err := self.OxmId.Serialize(encoder); err != nil {
17124 return err
17125 }
17126
17127 return nil
17128}
17129
17130func DecodeOxmIdIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Dst, error) {
17131 _oxmidipv6dst := &OxmIdIpv6Dst{OxmId: parent}
17132 return _oxmidipv6dst, nil
17133}
17134
17135func NewOxmIdIpv6Dst() *OxmIdIpv6Dst {
17136 obj := &OxmIdIpv6Dst{
17137 OxmId: NewOxmId(75792),
17138 }
17139 return obj
17140}
17141func (self *OxmIdIpv6Dst) GetOXMName() string {
17142 return "ipv6_dst"
17143}
17144
17145func (self *OxmIdIpv6Dst) MarshalJSON() ([]byte, error) {
17146 if self.TypeLen == 0 {
17147 return []byte("\"\""), nil
17148 } else {
17149 return []byte("\"" + self.GetOXMName() + "\""), nil
17150 }
17151}
17152
17153type OxmIdIpv6DstMasked struct {
17154 *OxmId
17155}
17156
17157type IOxmIdIpv6DstMasked interface {
17158 IOxmId
17159}
17160
17161func (self *OxmIdIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
17162 if err := self.OxmId.Serialize(encoder); err != nil {
17163 return err
17164 }
17165
17166 return nil
17167}
17168
17169func DecodeOxmIdIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6DstMasked, error) {
17170 _oxmidipv6dstmasked := &OxmIdIpv6DstMasked{OxmId: parent}
17171 return _oxmidipv6dstmasked, nil
17172}
17173
17174func NewOxmIdIpv6DstMasked() *OxmIdIpv6DstMasked {
17175 obj := &OxmIdIpv6DstMasked{
17176 OxmId: NewOxmId(76064),
17177 }
17178 return obj
17179}
17180func (self *OxmIdIpv6DstMasked) GetOXMName() string {
17181 return "ipv6_dst_masked"
17182}
17183
17184func (self *OxmIdIpv6DstMasked) MarshalJSON() ([]byte, error) {
17185 if self.TypeLen == 0 {
17186 return []byte("\"\""), nil
17187 } else {
17188 return []byte("\"" + self.GetOXMName() + "\""), nil
17189 }
17190}
17191
17192type OxmIdIpv6Label struct {
17193 *OxmId
17194}
17195
17196type IOxmIdIpv6Label interface {
17197 IOxmId
17198}
17199
17200func (self *OxmIdIpv6Label) Serialize(encoder *goloxi.Encoder) error {
17201 if err := self.OxmId.Serialize(encoder); err != nil {
17202 return err
17203 }
17204
17205 return nil
17206}
17207
17208func DecodeOxmIdIpv6Label(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Label, error) {
17209 _oxmidipv6label := &OxmIdIpv6Label{OxmId: parent}
17210 return _oxmidipv6label, nil
17211}
17212
17213func NewOxmIdIpv6Label() *OxmIdIpv6Label {
17214 obj := &OxmIdIpv6Label{
17215 OxmId: NewOxmId(79364),
17216 }
17217 return obj
17218}
17219func (self *OxmIdIpv6Label) GetOXMName() string {
17220 return "ipv6_label"
17221}
17222
17223func (self *OxmIdIpv6Label) MarshalJSON() ([]byte, error) {
17224 if self.TypeLen == 0 {
17225 return []byte("\"\""), nil
17226 } else {
17227 return []byte("\"" + self.GetOXMName() + "\""), nil
17228 }
17229}
17230
17231type OxmIdIpv6LabelMasked struct {
17232 *OxmId
17233}
17234
17235type IOxmIdIpv6LabelMasked interface {
17236 IOxmId
17237}
17238
17239func (self *OxmIdIpv6LabelMasked) Serialize(encoder *goloxi.Encoder) error {
17240 if err := self.OxmId.Serialize(encoder); err != nil {
17241 return err
17242 }
17243
17244 return nil
17245}
17246
17247func DecodeOxmIdIpv6LabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6LabelMasked, error) {
17248 _oxmidipv6labelmasked := &OxmIdIpv6LabelMasked{OxmId: parent}
17249 return _oxmidipv6labelmasked, nil
17250}
17251
17252func NewOxmIdIpv6LabelMasked() *OxmIdIpv6LabelMasked {
17253 obj := &OxmIdIpv6LabelMasked{
17254 OxmId: NewOxmId(79624),
17255 }
17256 return obj
17257}
17258func (self *OxmIdIpv6LabelMasked) GetOXMName() string {
17259 return "ipv6_label_masked"
17260}
17261
17262func (self *OxmIdIpv6LabelMasked) MarshalJSON() ([]byte, error) {
17263 if self.TypeLen == 0 {
17264 return []byte("\"\""), nil
17265 } else {
17266 return []byte("\"" + self.GetOXMName() + "\""), nil
17267 }
17268}
17269
17270type OxmIdIpv6Src struct {
17271 *OxmId
17272}
17273
17274type IOxmIdIpv6Src interface {
17275 IOxmId
17276}
17277
17278func (self *OxmIdIpv6Src) Serialize(encoder *goloxi.Encoder) error {
17279 if err := self.OxmId.Serialize(encoder); err != nil {
17280 return err
17281 }
17282
17283 return nil
17284}
17285
17286func DecodeOxmIdIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Src, error) {
17287 _oxmidipv6src := &OxmIdIpv6Src{OxmId: parent}
17288 return _oxmidipv6src, nil
17289}
17290
17291func NewOxmIdIpv6Src() *OxmIdIpv6Src {
17292 obj := &OxmIdIpv6Src{
17293 OxmId: NewOxmId(75280),
17294 }
17295 return obj
17296}
17297func (self *OxmIdIpv6Src) GetOXMName() string {
17298 return "ipv6_src"
17299}
17300
17301func (self *OxmIdIpv6Src) MarshalJSON() ([]byte, error) {
17302 if self.TypeLen == 0 {
17303 return []byte("\"\""), nil
17304 } else {
17305 return []byte("\"" + self.GetOXMName() + "\""), nil
17306 }
17307}
17308
17309type OxmIdIpv6SrcMasked struct {
17310 *OxmId
17311}
17312
17313type IOxmIdIpv6SrcMasked interface {
17314 IOxmId
17315}
17316
17317func (self *OxmIdIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
17318 if err := self.OxmId.Serialize(encoder); err != nil {
17319 return err
17320 }
17321
17322 return nil
17323}
17324
17325func DecodeOxmIdIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6SrcMasked, error) {
17326 _oxmidipv6srcmasked := &OxmIdIpv6SrcMasked{OxmId: parent}
17327 return _oxmidipv6srcmasked, nil
17328}
17329
17330func NewOxmIdIpv6SrcMasked() *OxmIdIpv6SrcMasked {
17331 obj := &OxmIdIpv6SrcMasked{
17332 OxmId: NewOxmId(75552),
17333 }
17334 return obj
17335}
17336func (self *OxmIdIpv6SrcMasked) GetOXMName() string {
17337 return "ipv6_src_masked"
17338}
17339
17340func (self *OxmIdIpv6SrcMasked) MarshalJSON() ([]byte, error) {
17341 if self.TypeLen == 0 {
17342 return []byte("\"\""), nil
17343 } else {
17344 return []byte("\"" + self.GetOXMName() + "\""), nil
17345 }
17346}
17347
17348type OxmIdMplsTtl struct {
17349 *OxmId
17350}
17351
17352type IOxmIdMplsTtl interface {
17353 IOxmId
17354}
17355
17356func (self *OxmIdMplsTtl) Serialize(encoder *goloxi.Encoder) error {
17357 if err := self.OxmId.Serialize(encoder); err != nil {
17358 return err
17359 }
17360
17361 return nil
17362}
17363
17364func DecodeOxmIdMplsTtl(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsTtl, error) {
17365 _oxmidmplsttl := &OxmIdMplsTtl{OxmId: parent}
17366 return _oxmidmplsttl, nil
17367}
17368
17369func NewOxmIdMplsTtl() *OxmIdMplsTtl {
17370 obj := &OxmIdMplsTtl{
17371 OxmId: NewOxmId(80897),
17372 }
17373 return obj
17374}
17375func (self *OxmIdMplsTtl) GetOXMName() string {
17376 return "mpls_ttl"
17377}
17378
17379func (self *OxmIdMplsTtl) MarshalJSON() ([]byte, error) {
17380 if self.TypeLen == 0 {
17381 return []byte("\"\""), nil
17382 } else {
17383 return []byte("\"" + self.GetOXMName() + "\""), nil
17384 }
17385}
17386
17387type OxmIdNdSll struct {
17388 *OxmId
17389}
17390
17391type IOxmIdNdSll interface {
17392 IOxmId
17393}
17394
17395func (self *OxmIdNdSll) Serialize(encoder *goloxi.Encoder) error {
17396 if err := self.OxmId.Serialize(encoder); err != nil {
17397 return err
17398 }
17399
17400 return nil
17401}
17402
17403func DecodeOxmIdNdSll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdSll, error) {
17404 _oxmidndsll := &OxmIdNdSll{OxmId: parent}
17405 return _oxmidndsll, nil
17406}
17407
17408func NewOxmIdNdSll() *OxmIdNdSll {
17409 obj := &OxmIdNdSll{
17410 OxmId: NewOxmId(77830),
17411 }
17412 return obj
17413}
17414func (self *OxmIdNdSll) GetOXMName() string {
17415 return "nd_sll"
17416}
17417
17418func (self *OxmIdNdSll) MarshalJSON() ([]byte, error) {
17419 if self.TypeLen == 0 {
17420 return []byte("\"\""), nil
17421 } else {
17422 return []byte("\"" + self.GetOXMName() + "\""), nil
17423 }
17424}
17425
17426type OxmIdNdSllMasked struct {
17427 *OxmId
17428}
17429
17430type IOxmIdNdSllMasked interface {
17431 IOxmId
17432}
17433
17434func (self *OxmIdNdSllMasked) Serialize(encoder *goloxi.Encoder) error {
17435 if err := self.OxmId.Serialize(encoder); err != nil {
17436 return err
17437 }
17438
17439 return nil
17440}
17441
17442func DecodeOxmIdNdSllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdSllMasked, error) {
17443 _oxmidndsllmasked := &OxmIdNdSllMasked{OxmId: parent}
17444 return _oxmidndsllmasked, nil
17445}
17446
17447func NewOxmIdNdSllMasked() *OxmIdNdSllMasked {
17448 obj := &OxmIdNdSllMasked{
17449 OxmId: NewOxmId(78091),
17450 }
17451 return obj
17452}
17453func (self *OxmIdNdSllMasked) GetOXMName() string {
17454 return "nd_sll_masked"
17455}
17456
17457func (self *OxmIdNdSllMasked) MarshalJSON() ([]byte, error) {
17458 if self.TypeLen == 0 {
17459 return []byte("\"\""), nil
17460 } else {
17461 return []byte("\"" + self.GetOXMName() + "\""), nil
17462 }
17463}
17464
17465type OxmIdNdTarget struct {
17466 *OxmId
17467}
17468
17469type IOxmIdNdTarget interface {
17470 IOxmId
17471}
17472
17473func (self *OxmIdNdTarget) Serialize(encoder *goloxi.Encoder) error {
17474 if err := self.OxmId.Serialize(encoder); err != nil {
17475 return err
17476 }
17477
17478 return nil
17479}
17480
17481func DecodeOxmIdNdTarget(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTarget, error) {
17482 _oxmidndtarget := &OxmIdNdTarget{OxmId: parent}
17483 return _oxmidndtarget, nil
17484}
17485
17486func NewOxmIdNdTarget() *OxmIdNdTarget {
17487 obj := &OxmIdNdTarget{
17488 OxmId: NewOxmId(77328),
17489 }
17490 return obj
17491}
17492func (self *OxmIdNdTarget) GetOXMName() string {
17493 return "nd_target"
17494}
17495
17496func (self *OxmIdNdTarget) MarshalJSON() ([]byte, error) {
17497 if self.TypeLen == 0 {
17498 return []byte("\"\""), nil
17499 } else {
17500 return []byte("\"" + self.GetOXMName() + "\""), nil
17501 }
17502}
17503
17504type OxmIdNdTargetMasked struct {
17505 *OxmId
17506}
17507
17508type IOxmIdNdTargetMasked interface {
17509 IOxmId
17510}
17511
17512func (self *OxmIdNdTargetMasked) Serialize(encoder *goloxi.Encoder) error {
17513 if err := self.OxmId.Serialize(encoder); err != nil {
17514 return err
17515 }
17516
17517 return nil
17518}
17519
17520func DecodeOxmIdNdTargetMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTargetMasked, error) {
17521 _oxmidndtargetmasked := &OxmIdNdTargetMasked{OxmId: parent}
17522 return _oxmidndtargetmasked, nil
17523}
17524
17525func NewOxmIdNdTargetMasked() *OxmIdNdTargetMasked {
17526 obj := &OxmIdNdTargetMasked{
17527 OxmId: NewOxmId(77600),
17528 }
17529 return obj
17530}
17531func (self *OxmIdNdTargetMasked) GetOXMName() string {
17532 return "nd_target_masked"
17533}
17534
17535func (self *OxmIdNdTargetMasked) MarshalJSON() ([]byte, error) {
17536 if self.TypeLen == 0 {
17537 return []byte("\"\""), nil
17538 } else {
17539 return []byte("\"" + self.GetOXMName() + "\""), nil
17540 }
17541}
17542
17543type OxmIdNdTll struct {
17544 *OxmId
17545}
17546
17547type IOxmIdNdTll interface {
17548 IOxmId
17549}
17550
17551func (self *OxmIdNdTll) Serialize(encoder *goloxi.Encoder) error {
17552 if err := self.OxmId.Serialize(encoder); err != nil {
17553 return err
17554 }
17555
17556 return nil
17557}
17558
17559func DecodeOxmIdNdTll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTll, error) {
17560 _oxmidndtll := &OxmIdNdTll{OxmId: parent}
17561 return _oxmidndtll, nil
17562}
17563
17564func NewOxmIdNdTll() *OxmIdNdTll {
17565 obj := &OxmIdNdTll{
17566 OxmId: NewOxmId(78342),
17567 }
17568 return obj
17569}
17570func (self *OxmIdNdTll) GetOXMName() string {
17571 return "nd_tll"
17572}
17573
17574func (self *OxmIdNdTll) MarshalJSON() ([]byte, error) {
17575 if self.TypeLen == 0 {
17576 return []byte("\"\""), nil
17577 } else {
17578 return []byte("\"" + self.GetOXMName() + "\""), nil
17579 }
17580}
17581
17582type OxmIdNdTllMasked struct {
17583 *OxmId
17584}
17585
17586type IOxmIdNdTllMasked interface {
17587 IOxmId
17588}
17589
17590func (self *OxmIdNdTllMasked) Serialize(encoder *goloxi.Encoder) error {
17591 if err := self.OxmId.Serialize(encoder); err != nil {
17592 return err
17593 }
17594
17595 return nil
17596}
17597
17598func DecodeOxmIdNdTllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTllMasked, error) {
17599 _oxmidndtllmasked := &OxmIdNdTllMasked{OxmId: parent}
17600 return _oxmidndtllmasked, nil
17601}
17602
17603func NewOxmIdNdTllMasked() *OxmIdNdTllMasked {
17604 obj := &OxmIdNdTllMasked{
17605 OxmId: NewOxmId(78603),
17606 }
17607 return obj
17608}
17609func (self *OxmIdNdTllMasked) GetOXMName() string {
17610 return "nd_tll_masked"
17611}
17612
17613func (self *OxmIdNdTllMasked) MarshalJSON() ([]byte, error) {
17614 if self.TypeLen == 0 {
17615 return []byte("\"\""), nil
17616 } else {
17617 return []byte("\"" + self.GetOXMName() + "\""), nil
17618 }
17619}
17620
17621type OxmIdNwEcn struct {
17622 *OxmId
17623}
17624
17625type IOxmIdNwEcn interface {
17626 IOxmId
17627}
17628
17629func (self *OxmIdNwEcn) Serialize(encoder *goloxi.Encoder) error {
17630 if err := self.OxmId.Serialize(encoder); err != nil {
17631 return err
17632 }
17633
17634 return nil
17635}
17636
17637func DecodeOxmIdNwEcn(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwEcn, error) {
17638 _oxmidnwecn := &OxmIdNwEcn{OxmId: parent}
17639 return _oxmidnwecn, nil
17640}
17641
17642func NewOxmIdNwEcn() *OxmIdNwEcn {
17643 obj := &OxmIdNwEcn{
17644 OxmId: NewOxmId(79873),
17645 }
17646 return obj
17647}
17648func (self *OxmIdNwEcn) GetOXMName() string {
17649 return "nw_ecn"
17650}
17651
17652func (self *OxmIdNwEcn) MarshalJSON() ([]byte, error) {
17653 if self.TypeLen == 0 {
17654 return []byte("\"\""), nil
17655 } else {
17656 return []byte("\"" + self.GetOXMName() + "\""), nil
17657 }
17658}
17659
17660type OxmIdNwProto struct {
17661 *OxmId
17662}
17663
17664type IOxmIdNwProto interface {
17665 IOxmId
17666}
17667
17668func (self *OxmIdNwProto) Serialize(encoder *goloxi.Encoder) error {
17669 if err := self.OxmId.Serialize(encoder); err != nil {
17670 return err
17671 }
17672
17673 return nil
17674}
17675
17676func DecodeOxmIdNwProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwProto, error) {
17677 _oxmidnwproto := &OxmIdNwProto{OxmId: parent}
17678 return _oxmidnwproto, nil
17679}
17680
17681func NewOxmIdNwProto() *OxmIdNwProto {
17682 obj := &OxmIdNwProto{
17683 OxmId: NewOxmId(3073),
17684 }
17685 return obj
17686}
17687func (self *OxmIdNwProto) GetOXMName() string {
17688 return "nw_proto"
17689}
17690
17691func (self *OxmIdNwProto) MarshalJSON() ([]byte, error) {
17692 if self.TypeLen == 0 {
17693 return []byte("\"\""), nil
17694 } else {
17695 return []byte("\"" + self.GetOXMName() + "\""), nil
17696 }
17697}
17698
17699type OxmIdNwTos struct {
17700 *OxmId
17701}
17702
17703type IOxmIdNwTos interface {
17704 IOxmId
17705}
17706
17707func (self *OxmIdNwTos) Serialize(encoder *goloxi.Encoder) error {
17708 if err := self.OxmId.Serialize(encoder); err != nil {
17709 return err
17710 }
17711
17712 return nil
17713}
17714
17715func DecodeOxmIdNwTos(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwTos, error) {
17716 _oxmidnwtos := &OxmIdNwTos{OxmId: parent}
17717 return _oxmidnwtos, nil
17718}
17719
17720func NewOxmIdNwTos() *OxmIdNwTos {
17721 obj := &OxmIdNwTos{
17722 OxmId: NewOxmId(2561),
17723 }
17724 return obj
17725}
17726func (self *OxmIdNwTos) GetOXMName() string {
17727 return "nw_tos"
17728}
17729
17730func (self *OxmIdNwTos) MarshalJSON() ([]byte, error) {
17731 if self.TypeLen == 0 {
17732 return []byte("\"\""), nil
17733 } else {
17734 return []byte("\"" + self.GetOXMName() + "\""), nil
17735 }
17736}
17737
17738type OxmIdNwTtl struct {
17739 *OxmId
17740}
17741
17742type IOxmIdNwTtl interface {
17743 IOxmId
17744}
17745
17746func (self *OxmIdNwTtl) Serialize(encoder *goloxi.Encoder) error {
17747 if err := self.OxmId.Serialize(encoder); err != nil {
17748 return err
17749 }
17750
17751 return nil
17752}
17753
17754func DecodeOxmIdNwTtl(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwTtl, error) {
17755 _oxmidnwttl := &OxmIdNwTtl{OxmId: parent}
17756 return _oxmidnwttl, nil
17757}
17758
17759func NewOxmIdNwTtl() *OxmIdNwTtl {
17760 obj := &OxmIdNwTtl{
17761 OxmId: NewOxmId(80385),
17762 }
17763 return obj
17764}
17765func (self *OxmIdNwTtl) GetOXMName() string {
17766 return "nw_ttl"
17767}
17768
17769func (self *OxmIdNwTtl) MarshalJSON() ([]byte, error) {
17770 if self.TypeLen == 0 {
17771 return []byte("\"\""), nil
17772 } else {
17773 return []byte("\"" + self.GetOXMName() + "\""), nil
17774 }
17775}
17776
17777type OxmIdPktMark struct {
17778 *OxmId
17779}
17780
17781type IOxmIdPktMark interface {
17782 IOxmId
17783}
17784
17785func (self *OxmIdPktMark) Serialize(encoder *goloxi.Encoder) error {
17786 if err := self.OxmId.Serialize(encoder); err != nil {
17787 return err
17788 }
17789
17790 return nil
17791}
17792
17793func DecodeOxmIdPktMark(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdPktMark, error) {
17794 _oxmidpktmark := &OxmIdPktMark{OxmId: parent}
17795 return _oxmidpktmark, nil
17796}
17797
17798func NewOxmIdPktMark() *OxmIdPktMark {
17799 obj := &OxmIdPktMark{
17800 OxmId: NewOxmId(82436),
17801 }
17802 return obj
17803}
17804func (self *OxmIdPktMark) GetOXMName() string {
17805 return "pkt_mark"
17806}
17807
17808func (self *OxmIdPktMark) MarshalJSON() ([]byte, error) {
17809 if self.TypeLen == 0 {
17810 return []byte("\"\""), nil
17811 } else {
17812 return []byte("\"" + self.GetOXMName() + "\""), nil
17813 }
17814}
17815
17816type OxmIdPktMarkMasked struct {
17817 *OxmId
17818}
17819
17820type IOxmIdPktMarkMasked interface {
17821 IOxmId
17822}
17823
17824func (self *OxmIdPktMarkMasked) Serialize(encoder *goloxi.Encoder) error {
17825 if err := self.OxmId.Serialize(encoder); err != nil {
17826 return err
17827 }
17828
17829 return nil
17830}
17831
17832func DecodeOxmIdPktMarkMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdPktMarkMasked, error) {
17833 _oxmidpktmarkmasked := &OxmIdPktMarkMasked{OxmId: parent}
17834 return _oxmidpktmarkmasked, nil
17835}
17836
17837func NewOxmIdPktMarkMasked() *OxmIdPktMarkMasked {
17838 obj := &OxmIdPktMarkMasked{
17839 OxmId: NewOxmId(82696),
17840 }
17841 return obj
17842}
17843func (self *OxmIdPktMarkMasked) GetOXMName() string {
17844 return "pkt_mark_masked"
17845}
17846
17847func (self *OxmIdPktMarkMasked) MarshalJSON() ([]byte, error) {
17848 if self.TypeLen == 0 {
17849 return []byte("\"\""), nil
17850 } else {
17851 return []byte("\"" + self.GetOXMName() + "\""), nil
17852 }
17853}
17854
17855type OxmIdRecircId struct {
17856 *OxmId
17857}
17858
17859type IOxmIdRecircId interface {
17860 IOxmId
17861}
17862
17863func (self *OxmIdRecircId) Serialize(encoder *goloxi.Encoder) error {
17864 if err := self.OxmId.Serialize(encoder); err != nil {
17865 return err
17866 }
17867
17868 return nil
17869}
17870
17871func DecodeOxmIdRecircId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdRecircId, error) {
17872 _oxmidrecircid := &OxmIdRecircId{OxmId: parent}
17873 return _oxmidrecircid, nil
17874}
17875
17876func NewOxmIdRecircId() *OxmIdRecircId {
17877 obj := &OxmIdRecircId{
17878 OxmId: NewOxmId(83972),
17879 }
17880 return obj
17881}
17882func (self *OxmIdRecircId) GetOXMName() string {
17883 return "recirc_id"
17884}
17885
17886func (self *OxmIdRecircId) MarshalJSON() ([]byte, error) {
17887 if self.TypeLen == 0 {
17888 return []byte("\"\""), nil
17889 } else {
17890 return []byte("\"" + self.GetOXMName() + "\""), nil
17891 }
17892}
17893
17894type OxmIdReg0 struct {
17895 *OxmId
17896}
17897
17898type IOxmIdReg0 interface {
17899 IOxmId
17900}
17901
17902func (self *OxmIdReg0) Serialize(encoder *goloxi.Encoder) error {
17903 if err := self.OxmId.Serialize(encoder); err != nil {
17904 return err
17905 }
17906
17907 return nil
17908}
17909
17910func DecodeOxmIdReg0(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg0, error) {
17911 _oxmidreg0 := &OxmIdReg0{OxmId: parent}
17912 return _oxmidreg0, nil
17913}
17914
17915func NewOxmIdReg0() *OxmIdReg0 {
17916 obj := &OxmIdReg0{
17917 OxmId: NewOxmId(65540),
17918 }
17919 return obj
17920}
17921func (self *OxmIdReg0) GetOXMName() string {
17922 return "reg0"
17923}
17924
17925func (self *OxmIdReg0) MarshalJSON() ([]byte, error) {
17926 if self.TypeLen == 0 {
17927 return []byte("\"\""), nil
17928 } else {
17929 return []byte("\"" + self.GetOXMName() + "\""), nil
17930 }
17931}
17932
17933type OxmIdReg0Masked struct {
17934 *OxmId
17935}
17936
17937type IOxmIdReg0Masked interface {
17938 IOxmId
17939}
17940
17941func (self *OxmIdReg0Masked) Serialize(encoder *goloxi.Encoder) error {
17942 if err := self.OxmId.Serialize(encoder); err != nil {
17943 return err
17944 }
17945
17946 return nil
17947}
17948
17949func DecodeOxmIdReg0Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg0Masked, error) {
17950 _oxmidreg0masked := &OxmIdReg0Masked{OxmId: parent}
17951 return _oxmidreg0masked, nil
17952}
17953
17954func NewOxmIdReg0Masked() *OxmIdReg0Masked {
17955 obj := &OxmIdReg0Masked{
17956 OxmId: NewOxmId(65800),
17957 }
17958 return obj
17959}
17960func (self *OxmIdReg0Masked) GetOXMName() string {
17961 return "reg0_masked"
17962}
17963
17964func (self *OxmIdReg0Masked) MarshalJSON() ([]byte, error) {
17965 if self.TypeLen == 0 {
17966 return []byte("\"\""), nil
17967 } else {
17968 return []byte("\"" + self.GetOXMName() + "\""), nil
17969 }
17970}
17971
17972type OxmIdReg1 struct {
17973 *OxmId
17974}
17975
17976type IOxmIdReg1 interface {
17977 IOxmId
17978}
17979
17980func (self *OxmIdReg1) Serialize(encoder *goloxi.Encoder) error {
17981 if err := self.OxmId.Serialize(encoder); err != nil {
17982 return err
17983 }
17984
17985 return nil
17986}
17987
17988func DecodeOxmIdReg1(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg1, error) {
17989 _oxmidreg1 := &OxmIdReg1{OxmId: parent}
17990 return _oxmidreg1, nil
17991}
17992
17993func NewOxmIdReg1() *OxmIdReg1 {
17994 obj := &OxmIdReg1{
17995 OxmId: NewOxmId(66052),
17996 }
17997 return obj
17998}
17999func (self *OxmIdReg1) GetOXMName() string {
18000 return "reg1"
18001}
18002
18003func (self *OxmIdReg1) MarshalJSON() ([]byte, error) {
18004 if self.TypeLen == 0 {
18005 return []byte("\"\""), nil
18006 } else {
18007 return []byte("\"" + self.GetOXMName() + "\""), nil
18008 }
18009}
18010
18011type OxmIdReg10 struct {
18012 *OxmId
18013}
18014
18015type IOxmIdReg10 interface {
18016 IOxmId
18017}
18018
18019func (self *OxmIdReg10) Serialize(encoder *goloxi.Encoder) error {
18020 if err := self.OxmId.Serialize(encoder); err != nil {
18021 return err
18022 }
18023
18024 return nil
18025}
18026
18027func DecodeOxmIdReg10(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg10, error) {
18028 _oxmidreg10 := &OxmIdReg10{OxmId: parent}
18029 return _oxmidreg10, nil
18030}
18031
18032func NewOxmIdReg10() *OxmIdReg10 {
18033 obj := &OxmIdReg10{
18034 OxmId: NewOxmId(70660),
18035 }
18036 return obj
18037}
18038func (self *OxmIdReg10) GetOXMName() string {
18039 return "reg10"
18040}
18041
18042func (self *OxmIdReg10) MarshalJSON() ([]byte, error) {
18043 if self.TypeLen == 0 {
18044 return []byte("\"\""), nil
18045 } else {
18046 return []byte("\"" + self.GetOXMName() + "\""), nil
18047 }
18048}
18049
18050type OxmIdReg10Masked struct {
18051 *OxmId
18052}
18053
18054type IOxmIdReg10Masked interface {
18055 IOxmId
18056}
18057
18058func (self *OxmIdReg10Masked) Serialize(encoder *goloxi.Encoder) error {
18059 if err := self.OxmId.Serialize(encoder); err != nil {
18060 return err
18061 }
18062
18063 return nil
18064}
18065
18066func DecodeOxmIdReg10Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg10Masked, error) {
18067 _oxmidreg10masked := &OxmIdReg10Masked{OxmId: parent}
18068 return _oxmidreg10masked, nil
18069}
18070
18071func NewOxmIdReg10Masked() *OxmIdReg10Masked {
18072 obj := &OxmIdReg10Masked{
18073 OxmId: NewOxmId(70920),
18074 }
18075 return obj
18076}
18077func (self *OxmIdReg10Masked) GetOXMName() string {
18078 return "reg10_masked"
18079}
18080
18081func (self *OxmIdReg10Masked) MarshalJSON() ([]byte, error) {
18082 if self.TypeLen == 0 {
18083 return []byte("\"\""), nil
18084 } else {
18085 return []byte("\"" + self.GetOXMName() + "\""), nil
18086 }
18087}
18088
18089type OxmIdReg11 struct {
18090 *OxmId
18091}
18092
18093type IOxmIdReg11 interface {
18094 IOxmId
18095}
18096
18097func (self *OxmIdReg11) Serialize(encoder *goloxi.Encoder) error {
18098 if err := self.OxmId.Serialize(encoder); err != nil {
18099 return err
18100 }
18101
18102 return nil
18103}
18104
18105func DecodeOxmIdReg11(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg11, error) {
18106 _oxmidreg11 := &OxmIdReg11{OxmId: parent}
18107 return _oxmidreg11, nil
18108}
18109
18110func NewOxmIdReg11() *OxmIdReg11 {
18111 obj := &OxmIdReg11{
18112 OxmId: NewOxmId(71172),
18113 }
18114 return obj
18115}
18116func (self *OxmIdReg11) GetOXMName() string {
18117 return "reg11"
18118}
18119
18120func (self *OxmIdReg11) MarshalJSON() ([]byte, error) {
18121 if self.TypeLen == 0 {
18122 return []byte("\"\""), nil
18123 } else {
18124 return []byte("\"" + self.GetOXMName() + "\""), nil
18125 }
18126}
18127
18128type OxmIdReg11Masked struct {
18129 *OxmId
18130}
18131
18132type IOxmIdReg11Masked interface {
18133 IOxmId
18134}
18135
18136func (self *OxmIdReg11Masked) Serialize(encoder *goloxi.Encoder) error {
18137 if err := self.OxmId.Serialize(encoder); err != nil {
18138 return err
18139 }
18140
18141 return nil
18142}
18143
18144func DecodeOxmIdReg11Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg11Masked, error) {
18145 _oxmidreg11masked := &OxmIdReg11Masked{OxmId: parent}
18146 return _oxmidreg11masked, nil
18147}
18148
18149func NewOxmIdReg11Masked() *OxmIdReg11Masked {
18150 obj := &OxmIdReg11Masked{
18151 OxmId: NewOxmId(71432),
18152 }
18153 return obj
18154}
18155func (self *OxmIdReg11Masked) GetOXMName() string {
18156 return "reg11_masked"
18157}
18158
18159func (self *OxmIdReg11Masked) MarshalJSON() ([]byte, error) {
18160 if self.TypeLen == 0 {
18161 return []byte("\"\""), nil
18162 } else {
18163 return []byte("\"" + self.GetOXMName() + "\""), nil
18164 }
18165}
18166
18167type OxmIdReg12 struct {
18168 *OxmId
18169}
18170
18171type IOxmIdReg12 interface {
18172 IOxmId
18173}
18174
18175func (self *OxmIdReg12) Serialize(encoder *goloxi.Encoder) error {
18176 if err := self.OxmId.Serialize(encoder); err != nil {
18177 return err
18178 }
18179
18180 return nil
18181}
18182
18183func DecodeOxmIdReg12(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg12, error) {
18184 _oxmidreg12 := &OxmIdReg12{OxmId: parent}
18185 return _oxmidreg12, nil
18186}
18187
18188func NewOxmIdReg12() *OxmIdReg12 {
18189 obj := &OxmIdReg12{
18190 OxmId: NewOxmId(71684),
18191 }
18192 return obj
18193}
18194func (self *OxmIdReg12) GetOXMName() string {
18195 return "reg12"
18196}
18197
18198func (self *OxmIdReg12) MarshalJSON() ([]byte, error) {
18199 if self.TypeLen == 0 {
18200 return []byte("\"\""), nil
18201 } else {
18202 return []byte("\"" + self.GetOXMName() + "\""), nil
18203 }
18204}
18205
18206type OxmIdReg12Masked struct {
18207 *OxmId
18208}
18209
18210type IOxmIdReg12Masked interface {
18211 IOxmId
18212}
18213
18214func (self *OxmIdReg12Masked) Serialize(encoder *goloxi.Encoder) error {
18215 if err := self.OxmId.Serialize(encoder); err != nil {
18216 return err
18217 }
18218
18219 return nil
18220}
18221
18222func DecodeOxmIdReg12Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg12Masked, error) {
18223 _oxmidreg12masked := &OxmIdReg12Masked{OxmId: parent}
18224 return _oxmidreg12masked, nil
18225}
18226
18227func NewOxmIdReg12Masked() *OxmIdReg12Masked {
18228 obj := &OxmIdReg12Masked{
18229 OxmId: NewOxmId(71944),
18230 }
18231 return obj
18232}
18233func (self *OxmIdReg12Masked) GetOXMName() string {
18234 return "reg12_masked"
18235}
18236
18237func (self *OxmIdReg12Masked) MarshalJSON() ([]byte, error) {
18238 if self.TypeLen == 0 {
18239 return []byte("\"\""), nil
18240 } else {
18241 return []byte("\"" + self.GetOXMName() + "\""), nil
18242 }
18243}
18244
18245type OxmIdReg13 struct {
18246 *OxmId
18247}
18248
18249type IOxmIdReg13 interface {
18250 IOxmId
18251}
18252
18253func (self *OxmIdReg13) Serialize(encoder *goloxi.Encoder) error {
18254 if err := self.OxmId.Serialize(encoder); err != nil {
18255 return err
18256 }
18257
18258 return nil
18259}
18260
18261func DecodeOxmIdReg13(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg13, error) {
18262 _oxmidreg13 := &OxmIdReg13{OxmId: parent}
18263 return _oxmidreg13, nil
18264}
18265
18266func NewOxmIdReg13() *OxmIdReg13 {
18267 obj := &OxmIdReg13{
18268 OxmId: NewOxmId(72196),
18269 }
18270 return obj
18271}
18272func (self *OxmIdReg13) GetOXMName() string {
18273 return "reg13"
18274}
18275
18276func (self *OxmIdReg13) MarshalJSON() ([]byte, error) {
18277 if self.TypeLen == 0 {
18278 return []byte("\"\""), nil
18279 } else {
18280 return []byte("\"" + self.GetOXMName() + "\""), nil
18281 }
18282}
18283
18284type OxmIdReg13Masked struct {
18285 *OxmId
18286}
18287
18288type IOxmIdReg13Masked interface {
18289 IOxmId
18290}
18291
18292func (self *OxmIdReg13Masked) Serialize(encoder *goloxi.Encoder) error {
18293 if err := self.OxmId.Serialize(encoder); err != nil {
18294 return err
18295 }
18296
18297 return nil
18298}
18299
18300func DecodeOxmIdReg13Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg13Masked, error) {
18301 _oxmidreg13masked := &OxmIdReg13Masked{OxmId: parent}
18302 return _oxmidreg13masked, nil
18303}
18304
18305func NewOxmIdReg13Masked() *OxmIdReg13Masked {
18306 obj := &OxmIdReg13Masked{
18307 OxmId: NewOxmId(72456),
18308 }
18309 return obj
18310}
18311func (self *OxmIdReg13Masked) GetOXMName() string {
18312 return "reg13_masked"
18313}
18314
18315func (self *OxmIdReg13Masked) MarshalJSON() ([]byte, error) {
18316 if self.TypeLen == 0 {
18317 return []byte("\"\""), nil
18318 } else {
18319 return []byte("\"" + self.GetOXMName() + "\""), nil
18320 }
18321}
18322
18323type OxmIdReg14 struct {
18324 *OxmId
18325}
18326
18327type IOxmIdReg14 interface {
18328 IOxmId
18329}
18330
18331func (self *OxmIdReg14) Serialize(encoder *goloxi.Encoder) error {
18332 if err := self.OxmId.Serialize(encoder); err != nil {
18333 return err
18334 }
18335
18336 return nil
18337}
18338
18339func DecodeOxmIdReg14(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg14, error) {
18340 _oxmidreg14 := &OxmIdReg14{OxmId: parent}
18341 return _oxmidreg14, nil
18342}
18343
18344func NewOxmIdReg14() *OxmIdReg14 {
18345 obj := &OxmIdReg14{
18346 OxmId: NewOxmId(72708),
18347 }
18348 return obj
18349}
18350func (self *OxmIdReg14) GetOXMName() string {
18351 return "reg14"
18352}
18353
18354func (self *OxmIdReg14) MarshalJSON() ([]byte, error) {
18355 if self.TypeLen == 0 {
18356 return []byte("\"\""), nil
18357 } else {
18358 return []byte("\"" + self.GetOXMName() + "\""), nil
18359 }
18360}
18361
18362type OxmIdReg14Masked struct {
18363 *OxmId
18364}
18365
18366type IOxmIdReg14Masked interface {
18367 IOxmId
18368}
18369
18370func (self *OxmIdReg14Masked) Serialize(encoder *goloxi.Encoder) error {
18371 if err := self.OxmId.Serialize(encoder); err != nil {
18372 return err
18373 }
18374
18375 return nil
18376}
18377
18378func DecodeOxmIdReg14Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg14Masked, error) {
18379 _oxmidreg14masked := &OxmIdReg14Masked{OxmId: parent}
18380 return _oxmidreg14masked, nil
18381}
18382
18383func NewOxmIdReg14Masked() *OxmIdReg14Masked {
18384 obj := &OxmIdReg14Masked{
18385 OxmId: NewOxmId(72968),
18386 }
18387 return obj
18388}
18389func (self *OxmIdReg14Masked) GetOXMName() string {
18390 return "reg14_masked"
18391}
18392
18393func (self *OxmIdReg14Masked) MarshalJSON() ([]byte, error) {
18394 if self.TypeLen == 0 {
18395 return []byte("\"\""), nil
18396 } else {
18397 return []byte("\"" + self.GetOXMName() + "\""), nil
18398 }
18399}
18400
18401type OxmIdReg15 struct {
18402 *OxmId
18403}
18404
18405type IOxmIdReg15 interface {
18406 IOxmId
18407}
18408
18409func (self *OxmIdReg15) Serialize(encoder *goloxi.Encoder) error {
18410 if err := self.OxmId.Serialize(encoder); err != nil {
18411 return err
18412 }
18413
18414 return nil
18415}
18416
18417func DecodeOxmIdReg15(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg15, error) {
18418 _oxmidreg15 := &OxmIdReg15{OxmId: parent}
18419 return _oxmidreg15, nil
18420}
18421
18422func NewOxmIdReg15() *OxmIdReg15 {
18423 obj := &OxmIdReg15{
18424 OxmId: NewOxmId(73220),
18425 }
18426 return obj
18427}
18428func (self *OxmIdReg15) GetOXMName() string {
18429 return "reg15"
18430}
18431
18432func (self *OxmIdReg15) MarshalJSON() ([]byte, error) {
18433 if self.TypeLen == 0 {
18434 return []byte("\"\""), nil
18435 } else {
18436 return []byte("\"" + self.GetOXMName() + "\""), nil
18437 }
18438}
18439
18440type OxmIdReg15Masked struct {
18441 *OxmId
18442}
18443
18444type IOxmIdReg15Masked interface {
18445 IOxmId
18446}
18447
18448func (self *OxmIdReg15Masked) Serialize(encoder *goloxi.Encoder) error {
18449 if err := self.OxmId.Serialize(encoder); err != nil {
18450 return err
18451 }
18452
18453 return nil
18454}
18455
18456func DecodeOxmIdReg15Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg15Masked, error) {
18457 _oxmidreg15masked := &OxmIdReg15Masked{OxmId: parent}
18458 return _oxmidreg15masked, nil
18459}
18460
18461func NewOxmIdReg15Masked() *OxmIdReg15Masked {
18462 obj := &OxmIdReg15Masked{
18463 OxmId: NewOxmId(73480),
18464 }
18465 return obj
18466}
18467func (self *OxmIdReg15Masked) GetOXMName() string {
18468 return "reg15_masked"
18469}
18470
18471func (self *OxmIdReg15Masked) MarshalJSON() ([]byte, error) {
18472 if self.TypeLen == 0 {
18473 return []byte("\"\""), nil
18474 } else {
18475 return []byte("\"" + self.GetOXMName() + "\""), nil
18476 }
18477}
18478
18479type OxmIdReg1Masked struct {
18480 *OxmId
18481}
18482
18483type IOxmIdReg1Masked interface {
18484 IOxmId
18485}
18486
18487func (self *OxmIdReg1Masked) Serialize(encoder *goloxi.Encoder) error {
18488 if err := self.OxmId.Serialize(encoder); err != nil {
18489 return err
18490 }
18491
18492 return nil
18493}
18494
18495func DecodeOxmIdReg1Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg1Masked, error) {
18496 _oxmidreg1masked := &OxmIdReg1Masked{OxmId: parent}
18497 return _oxmidreg1masked, nil
18498}
18499
18500func NewOxmIdReg1Masked() *OxmIdReg1Masked {
18501 obj := &OxmIdReg1Masked{
18502 OxmId: NewOxmId(66312),
18503 }
18504 return obj
18505}
18506func (self *OxmIdReg1Masked) GetOXMName() string {
18507 return "reg1_masked"
18508}
18509
18510func (self *OxmIdReg1Masked) MarshalJSON() ([]byte, error) {
18511 if self.TypeLen == 0 {
18512 return []byte("\"\""), nil
18513 } else {
18514 return []byte("\"" + self.GetOXMName() + "\""), nil
18515 }
18516}
18517
18518type OxmIdReg2 struct {
18519 *OxmId
18520}
18521
18522type IOxmIdReg2 interface {
18523 IOxmId
18524}
18525
18526func (self *OxmIdReg2) Serialize(encoder *goloxi.Encoder) error {
18527 if err := self.OxmId.Serialize(encoder); err != nil {
18528 return err
18529 }
18530
18531 return nil
18532}
18533
18534func DecodeOxmIdReg2(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg2, error) {
18535 _oxmidreg2 := &OxmIdReg2{OxmId: parent}
18536 return _oxmidreg2, nil
18537}
18538
18539func NewOxmIdReg2() *OxmIdReg2 {
18540 obj := &OxmIdReg2{
18541 OxmId: NewOxmId(66564),
18542 }
18543 return obj
18544}
18545func (self *OxmIdReg2) GetOXMName() string {
18546 return "reg2"
18547}
18548
18549func (self *OxmIdReg2) MarshalJSON() ([]byte, error) {
18550 if self.TypeLen == 0 {
18551 return []byte("\"\""), nil
18552 } else {
18553 return []byte("\"" + self.GetOXMName() + "\""), nil
18554 }
18555}
18556
18557type OxmIdReg2Masked struct {
18558 *OxmId
18559}
18560
18561type IOxmIdReg2Masked interface {
18562 IOxmId
18563}
18564
18565func (self *OxmIdReg2Masked) Serialize(encoder *goloxi.Encoder) error {
18566 if err := self.OxmId.Serialize(encoder); err != nil {
18567 return err
18568 }
18569
18570 return nil
18571}
18572
18573func DecodeOxmIdReg2Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg2Masked, error) {
18574 _oxmidreg2masked := &OxmIdReg2Masked{OxmId: parent}
18575 return _oxmidreg2masked, nil
18576}
18577
18578func NewOxmIdReg2Masked() *OxmIdReg2Masked {
18579 obj := &OxmIdReg2Masked{
18580 OxmId: NewOxmId(66824),
18581 }
18582 return obj
18583}
18584func (self *OxmIdReg2Masked) GetOXMName() string {
18585 return "reg2_masked"
18586}
18587
18588func (self *OxmIdReg2Masked) MarshalJSON() ([]byte, error) {
18589 if self.TypeLen == 0 {
18590 return []byte("\"\""), nil
18591 } else {
18592 return []byte("\"" + self.GetOXMName() + "\""), nil
18593 }
18594}
18595
18596type OxmIdReg3 struct {
18597 *OxmId
18598}
18599
18600type IOxmIdReg3 interface {
18601 IOxmId
18602}
18603
18604func (self *OxmIdReg3) Serialize(encoder *goloxi.Encoder) error {
18605 if err := self.OxmId.Serialize(encoder); err != nil {
18606 return err
18607 }
18608
18609 return nil
18610}
18611
18612func DecodeOxmIdReg3(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg3, error) {
18613 _oxmidreg3 := &OxmIdReg3{OxmId: parent}
18614 return _oxmidreg3, nil
18615}
18616
18617func NewOxmIdReg3() *OxmIdReg3 {
18618 obj := &OxmIdReg3{
18619 OxmId: NewOxmId(67076),
18620 }
18621 return obj
18622}
18623func (self *OxmIdReg3) GetOXMName() string {
18624 return "reg3"
18625}
18626
18627func (self *OxmIdReg3) MarshalJSON() ([]byte, error) {
18628 if self.TypeLen == 0 {
18629 return []byte("\"\""), nil
18630 } else {
18631 return []byte("\"" + self.GetOXMName() + "\""), nil
18632 }
18633}
18634
18635type OxmIdReg3Masked struct {
18636 *OxmId
18637}
18638
18639type IOxmIdReg3Masked interface {
18640 IOxmId
18641}
18642
18643func (self *OxmIdReg3Masked) Serialize(encoder *goloxi.Encoder) error {
18644 if err := self.OxmId.Serialize(encoder); err != nil {
18645 return err
18646 }
18647
18648 return nil
18649}
18650
18651func DecodeOxmIdReg3Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg3Masked, error) {
18652 _oxmidreg3masked := &OxmIdReg3Masked{OxmId: parent}
18653 return _oxmidreg3masked, nil
18654}
18655
18656func NewOxmIdReg3Masked() *OxmIdReg3Masked {
18657 obj := &OxmIdReg3Masked{
18658 OxmId: NewOxmId(67336),
18659 }
18660 return obj
18661}
18662func (self *OxmIdReg3Masked) GetOXMName() string {
18663 return "reg3_masked"
18664}
18665
18666func (self *OxmIdReg3Masked) MarshalJSON() ([]byte, error) {
18667 if self.TypeLen == 0 {
18668 return []byte("\"\""), nil
18669 } else {
18670 return []byte("\"" + self.GetOXMName() + "\""), nil
18671 }
18672}
18673
18674type OxmIdReg4 struct {
18675 *OxmId
18676}
18677
18678type IOxmIdReg4 interface {
18679 IOxmId
18680}
18681
18682func (self *OxmIdReg4) Serialize(encoder *goloxi.Encoder) error {
18683 if err := self.OxmId.Serialize(encoder); err != nil {
18684 return err
18685 }
18686
18687 return nil
18688}
18689
18690func DecodeOxmIdReg4(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg4, error) {
18691 _oxmidreg4 := &OxmIdReg4{OxmId: parent}
18692 return _oxmidreg4, nil
18693}
18694
18695func NewOxmIdReg4() *OxmIdReg4 {
18696 obj := &OxmIdReg4{
18697 OxmId: NewOxmId(67588),
18698 }
18699 return obj
18700}
18701func (self *OxmIdReg4) GetOXMName() string {
18702 return "reg4"
18703}
18704
18705func (self *OxmIdReg4) MarshalJSON() ([]byte, error) {
18706 if self.TypeLen == 0 {
18707 return []byte("\"\""), nil
18708 } else {
18709 return []byte("\"" + self.GetOXMName() + "\""), nil
18710 }
18711}
18712
18713type OxmIdReg4Masked struct {
18714 *OxmId
18715}
18716
18717type IOxmIdReg4Masked interface {
18718 IOxmId
18719}
18720
18721func (self *OxmIdReg4Masked) Serialize(encoder *goloxi.Encoder) error {
18722 if err := self.OxmId.Serialize(encoder); err != nil {
18723 return err
18724 }
18725
18726 return nil
18727}
18728
18729func DecodeOxmIdReg4Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg4Masked, error) {
18730 _oxmidreg4masked := &OxmIdReg4Masked{OxmId: parent}
18731 return _oxmidreg4masked, nil
18732}
18733
18734func NewOxmIdReg4Masked() *OxmIdReg4Masked {
18735 obj := &OxmIdReg4Masked{
18736 OxmId: NewOxmId(67848),
18737 }
18738 return obj
18739}
18740func (self *OxmIdReg4Masked) GetOXMName() string {
18741 return "reg4_masked"
18742}
18743
18744func (self *OxmIdReg4Masked) MarshalJSON() ([]byte, error) {
18745 if self.TypeLen == 0 {
18746 return []byte("\"\""), nil
18747 } else {
18748 return []byte("\"" + self.GetOXMName() + "\""), nil
18749 }
18750}
18751
18752type OxmIdReg5 struct {
18753 *OxmId
18754}
18755
18756type IOxmIdReg5 interface {
18757 IOxmId
18758}
18759
18760func (self *OxmIdReg5) Serialize(encoder *goloxi.Encoder) error {
18761 if err := self.OxmId.Serialize(encoder); err != nil {
18762 return err
18763 }
18764
18765 return nil
18766}
18767
18768func DecodeOxmIdReg5(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg5, error) {
18769 _oxmidreg5 := &OxmIdReg5{OxmId: parent}
18770 return _oxmidreg5, nil
18771}
18772
18773func NewOxmIdReg5() *OxmIdReg5 {
18774 obj := &OxmIdReg5{
18775 OxmId: NewOxmId(68100),
18776 }
18777 return obj
18778}
18779func (self *OxmIdReg5) GetOXMName() string {
18780 return "reg5"
18781}
18782
18783func (self *OxmIdReg5) MarshalJSON() ([]byte, error) {
18784 if self.TypeLen == 0 {
18785 return []byte("\"\""), nil
18786 } else {
18787 return []byte("\"" + self.GetOXMName() + "\""), nil
18788 }
18789}
18790
18791type OxmIdReg5Masked struct {
18792 *OxmId
18793}
18794
18795type IOxmIdReg5Masked interface {
18796 IOxmId
18797}
18798
18799func (self *OxmIdReg5Masked) Serialize(encoder *goloxi.Encoder) error {
18800 if err := self.OxmId.Serialize(encoder); err != nil {
18801 return err
18802 }
18803
18804 return nil
18805}
18806
18807func DecodeOxmIdReg5Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg5Masked, error) {
18808 _oxmidreg5masked := &OxmIdReg5Masked{OxmId: parent}
18809 return _oxmidreg5masked, nil
18810}
18811
18812func NewOxmIdReg5Masked() *OxmIdReg5Masked {
18813 obj := &OxmIdReg5Masked{
18814 OxmId: NewOxmId(68360),
18815 }
18816 return obj
18817}
18818func (self *OxmIdReg5Masked) GetOXMName() string {
18819 return "reg5_masked"
18820}
18821
18822func (self *OxmIdReg5Masked) MarshalJSON() ([]byte, error) {
18823 if self.TypeLen == 0 {
18824 return []byte("\"\""), nil
18825 } else {
18826 return []byte("\"" + self.GetOXMName() + "\""), nil
18827 }
18828}
18829
18830type OxmIdReg6 struct {
18831 *OxmId
18832}
18833
18834type IOxmIdReg6 interface {
18835 IOxmId
18836}
18837
18838func (self *OxmIdReg6) Serialize(encoder *goloxi.Encoder) error {
18839 if err := self.OxmId.Serialize(encoder); err != nil {
18840 return err
18841 }
18842
18843 return nil
18844}
18845
18846func DecodeOxmIdReg6(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg6, error) {
18847 _oxmidreg6 := &OxmIdReg6{OxmId: parent}
18848 return _oxmidreg6, nil
18849}
18850
18851func NewOxmIdReg6() *OxmIdReg6 {
18852 obj := &OxmIdReg6{
18853 OxmId: NewOxmId(68612),
18854 }
18855 return obj
18856}
18857func (self *OxmIdReg6) GetOXMName() string {
18858 return "reg6"
18859}
18860
18861func (self *OxmIdReg6) MarshalJSON() ([]byte, error) {
18862 if self.TypeLen == 0 {
18863 return []byte("\"\""), nil
18864 } else {
18865 return []byte("\"" + self.GetOXMName() + "\""), nil
18866 }
18867}
18868
18869type OxmIdReg6Masked struct {
18870 *OxmId
18871}
18872
18873type IOxmIdReg6Masked interface {
18874 IOxmId
18875}
18876
18877func (self *OxmIdReg6Masked) Serialize(encoder *goloxi.Encoder) error {
18878 if err := self.OxmId.Serialize(encoder); err != nil {
18879 return err
18880 }
18881
18882 return nil
18883}
18884
18885func DecodeOxmIdReg6Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg6Masked, error) {
18886 _oxmidreg6masked := &OxmIdReg6Masked{OxmId: parent}
18887 return _oxmidreg6masked, nil
18888}
18889
18890func NewOxmIdReg6Masked() *OxmIdReg6Masked {
18891 obj := &OxmIdReg6Masked{
18892 OxmId: NewOxmId(68872),
18893 }
18894 return obj
18895}
18896func (self *OxmIdReg6Masked) GetOXMName() string {
18897 return "reg6_masked"
18898}
18899
18900func (self *OxmIdReg6Masked) MarshalJSON() ([]byte, error) {
18901 if self.TypeLen == 0 {
18902 return []byte("\"\""), nil
18903 } else {
18904 return []byte("\"" + self.GetOXMName() + "\""), nil
18905 }
18906}
18907
18908type OxmIdReg7 struct {
18909 *OxmId
18910}
18911
18912type IOxmIdReg7 interface {
18913 IOxmId
18914}
18915
18916func (self *OxmIdReg7) Serialize(encoder *goloxi.Encoder) error {
18917 if err := self.OxmId.Serialize(encoder); err != nil {
18918 return err
18919 }
18920
18921 return nil
18922}
18923
18924func DecodeOxmIdReg7(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg7, error) {
18925 _oxmidreg7 := &OxmIdReg7{OxmId: parent}
18926 return _oxmidreg7, nil
18927}
18928
18929func NewOxmIdReg7() *OxmIdReg7 {
18930 obj := &OxmIdReg7{
18931 OxmId: NewOxmId(69124),
18932 }
18933 return obj
18934}
18935func (self *OxmIdReg7) GetOXMName() string {
18936 return "reg7"
18937}
18938
18939func (self *OxmIdReg7) MarshalJSON() ([]byte, error) {
18940 if self.TypeLen == 0 {
18941 return []byte("\"\""), nil
18942 } else {
18943 return []byte("\"" + self.GetOXMName() + "\""), nil
18944 }
18945}
18946
18947type OxmIdReg7Masked struct {
18948 *OxmId
18949}
18950
18951type IOxmIdReg7Masked interface {
18952 IOxmId
18953}
18954
18955func (self *OxmIdReg7Masked) Serialize(encoder *goloxi.Encoder) error {
18956 if err := self.OxmId.Serialize(encoder); err != nil {
18957 return err
18958 }
18959
18960 return nil
18961}
18962
18963func DecodeOxmIdReg7Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg7Masked, error) {
18964 _oxmidreg7masked := &OxmIdReg7Masked{OxmId: parent}
18965 return _oxmidreg7masked, nil
18966}
18967
18968func NewOxmIdReg7Masked() *OxmIdReg7Masked {
18969 obj := &OxmIdReg7Masked{
18970 OxmId: NewOxmId(69384),
18971 }
18972 return obj
18973}
18974func (self *OxmIdReg7Masked) GetOXMName() string {
18975 return "reg7_masked"
18976}
18977
18978func (self *OxmIdReg7Masked) MarshalJSON() ([]byte, error) {
18979 if self.TypeLen == 0 {
18980 return []byte("\"\""), nil
18981 } else {
18982 return []byte("\"" + self.GetOXMName() + "\""), nil
18983 }
18984}
18985
18986type OxmIdReg8 struct {
18987 *OxmId
18988}
18989
18990type IOxmIdReg8 interface {
18991 IOxmId
18992}
18993
18994func (self *OxmIdReg8) Serialize(encoder *goloxi.Encoder) error {
18995 if err := self.OxmId.Serialize(encoder); err != nil {
18996 return err
18997 }
18998
18999 return nil
19000}
19001
19002func DecodeOxmIdReg8(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg8, error) {
19003 _oxmidreg8 := &OxmIdReg8{OxmId: parent}
19004 return _oxmidreg8, nil
19005}
19006
19007func NewOxmIdReg8() *OxmIdReg8 {
19008 obj := &OxmIdReg8{
19009 OxmId: NewOxmId(69636),
19010 }
19011 return obj
19012}
19013func (self *OxmIdReg8) GetOXMName() string {
19014 return "reg8"
19015}
19016
19017func (self *OxmIdReg8) MarshalJSON() ([]byte, error) {
19018 if self.TypeLen == 0 {
19019 return []byte("\"\""), nil
19020 } else {
19021 return []byte("\"" + self.GetOXMName() + "\""), nil
19022 }
19023}
19024
19025type OxmIdReg8Masked struct {
19026 *OxmId
19027}
19028
19029type IOxmIdReg8Masked interface {
19030 IOxmId
19031}
19032
19033func (self *OxmIdReg8Masked) Serialize(encoder *goloxi.Encoder) error {
19034 if err := self.OxmId.Serialize(encoder); err != nil {
19035 return err
19036 }
19037
19038 return nil
19039}
19040
19041func DecodeOxmIdReg8Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg8Masked, error) {
19042 _oxmidreg8masked := &OxmIdReg8Masked{OxmId: parent}
19043 return _oxmidreg8masked, nil
19044}
19045
19046func NewOxmIdReg8Masked() *OxmIdReg8Masked {
19047 obj := &OxmIdReg8Masked{
19048 OxmId: NewOxmId(69896),
19049 }
19050 return obj
19051}
19052func (self *OxmIdReg8Masked) GetOXMName() string {
19053 return "reg8_masked"
19054}
19055
19056func (self *OxmIdReg8Masked) MarshalJSON() ([]byte, error) {
19057 if self.TypeLen == 0 {
19058 return []byte("\"\""), nil
19059 } else {
19060 return []byte("\"" + self.GetOXMName() + "\""), nil
19061 }
19062}
19063
19064type OxmIdReg9 struct {
19065 *OxmId
19066}
19067
19068type IOxmIdReg9 interface {
19069 IOxmId
19070}
19071
19072func (self *OxmIdReg9) Serialize(encoder *goloxi.Encoder) error {
19073 if err := self.OxmId.Serialize(encoder); err != nil {
19074 return err
19075 }
19076
19077 return nil
19078}
19079
19080func DecodeOxmIdReg9(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg9, error) {
19081 _oxmidreg9 := &OxmIdReg9{OxmId: parent}
19082 return _oxmidreg9, nil
19083}
19084
19085func NewOxmIdReg9() *OxmIdReg9 {
19086 obj := &OxmIdReg9{
19087 OxmId: NewOxmId(70148),
19088 }
19089 return obj
19090}
19091func (self *OxmIdReg9) GetOXMName() string {
19092 return "reg9"
19093}
19094
19095func (self *OxmIdReg9) MarshalJSON() ([]byte, error) {
19096 if self.TypeLen == 0 {
19097 return []byte("\"\""), nil
19098 } else {
19099 return []byte("\"" + self.GetOXMName() + "\""), nil
19100 }
19101}
19102
19103type OxmIdReg9Masked struct {
19104 *OxmId
19105}
19106
19107type IOxmIdReg9Masked interface {
19108 IOxmId
19109}
19110
19111func (self *OxmIdReg9Masked) Serialize(encoder *goloxi.Encoder) error {
19112 if err := self.OxmId.Serialize(encoder); err != nil {
19113 return err
19114 }
19115
19116 return nil
19117}
19118
19119func DecodeOxmIdReg9Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg9Masked, error) {
19120 _oxmidreg9masked := &OxmIdReg9Masked{OxmId: parent}
19121 return _oxmidreg9masked, nil
19122}
19123
19124func NewOxmIdReg9Masked() *OxmIdReg9Masked {
19125 obj := &OxmIdReg9Masked{
19126 OxmId: NewOxmId(70408),
19127 }
19128 return obj
19129}
19130func (self *OxmIdReg9Masked) GetOXMName() string {
19131 return "reg9_masked"
19132}
19133
19134func (self *OxmIdReg9Masked) MarshalJSON() ([]byte, error) {
19135 if self.TypeLen == 0 {
19136 return []byte("\"\""), nil
19137 } else {
19138 return []byte("\"" + self.GetOXMName() + "\""), nil
19139 }
19140}
19141
19142type OxmIdTcpDst struct {
19143 *OxmId
19144}
19145
19146type IOxmIdTcpDst interface {
19147 IOxmId
19148}
19149
19150func (self *OxmIdTcpDst) Serialize(encoder *goloxi.Encoder) error {
19151 if err := self.OxmId.Serialize(encoder); err != nil {
19152 return err
19153 }
19154
19155 return nil
19156}
19157
19158func DecodeOxmIdTcpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpDst, error) {
19159 _oxmidtcpdst := &OxmIdTcpDst{OxmId: parent}
19160 return _oxmidtcpdst, nil
19161}
19162
19163func NewOxmIdTcpDst() *OxmIdTcpDst {
19164 obj := &OxmIdTcpDst{
19165 OxmId: NewOxmId(5122),
19166 }
19167 return obj
19168}
19169func (self *OxmIdTcpDst) GetOXMName() string {
19170 return "tcp_dst"
19171}
19172
19173func (self *OxmIdTcpDst) MarshalJSON() ([]byte, error) {
19174 if self.TypeLen == 0 {
19175 return []byte("\"\""), nil
19176 } else {
19177 return []byte("\"" + self.GetOXMName() + "\""), nil
19178 }
19179}
19180
19181type OxmIdTcpDstMasked struct {
19182 *OxmId
19183}
19184
19185type IOxmIdTcpDstMasked interface {
19186 IOxmId
19187}
19188
19189func (self *OxmIdTcpDstMasked) Serialize(encoder *goloxi.Encoder) error {
19190 if err := self.OxmId.Serialize(encoder); err != nil {
19191 return err
19192 }
19193
19194 return nil
19195}
19196
19197func DecodeOxmIdTcpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpDstMasked, error) {
19198 _oxmidtcpdstmasked := &OxmIdTcpDstMasked{OxmId: parent}
19199 return _oxmidtcpdstmasked, nil
19200}
19201
19202func NewOxmIdTcpDstMasked() *OxmIdTcpDstMasked {
19203 obj := &OxmIdTcpDstMasked{
19204 OxmId: NewOxmId(5378),
19205 }
19206 return obj
19207}
19208func (self *OxmIdTcpDstMasked) GetOXMName() string {
19209 return "tcp_dst_masked"
19210}
19211
19212func (self *OxmIdTcpDstMasked) MarshalJSON() ([]byte, error) {
19213 if self.TypeLen == 0 {
19214 return []byte("\"\""), nil
19215 } else {
19216 return []byte("\"" + self.GetOXMName() + "\""), nil
19217 }
19218}
19219
19220type OxmIdTcpFlags struct {
19221 *OxmId
19222}
19223
19224type IOxmIdTcpFlags interface {
19225 IOxmId
19226}
19227
19228func (self *OxmIdTcpFlags) Serialize(encoder *goloxi.Encoder) error {
19229 if err := self.OxmId.Serialize(encoder); err != nil {
19230 return err
19231 }
19232
19233 return nil
19234}
19235
19236func DecodeOxmIdTcpFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpFlags, error) {
19237 _oxmidtcpflags := &OxmIdTcpFlags{OxmId: parent}
19238 return _oxmidtcpflags, nil
19239}
19240
19241func NewOxmIdTcpFlags() *OxmIdTcpFlags {
19242 obj := &OxmIdTcpFlags{
19243 OxmId: NewOxmId(82946),
19244 }
19245 return obj
19246}
19247func (self *OxmIdTcpFlags) GetOXMName() string {
19248 return "tcp_flags"
19249}
19250
19251func (self *OxmIdTcpFlags) MarshalJSON() ([]byte, error) {
19252 if self.TypeLen == 0 {
19253 return []byte("\"\""), nil
19254 } else {
19255 return []byte("\"" + self.GetOXMName() + "\""), nil
19256 }
19257}
19258
19259type OxmIdTcpFlagsMasked struct {
19260 *OxmId
19261}
19262
19263type IOxmIdTcpFlagsMasked interface {
19264 IOxmId
19265}
19266
19267func (self *OxmIdTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
19268 if err := self.OxmId.Serialize(encoder); err != nil {
19269 return err
19270 }
19271
19272 return nil
19273}
19274
19275func DecodeOxmIdTcpFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpFlagsMasked, error) {
19276 _oxmidtcpflagsmasked := &OxmIdTcpFlagsMasked{OxmId: parent}
19277 return _oxmidtcpflagsmasked, nil
19278}
19279
19280func NewOxmIdTcpFlagsMasked() *OxmIdTcpFlagsMasked {
19281 obj := &OxmIdTcpFlagsMasked{
19282 OxmId: NewOxmId(83204),
19283 }
19284 return obj
19285}
19286func (self *OxmIdTcpFlagsMasked) GetOXMName() string {
19287 return "tcp_flags_masked"
19288}
19289
19290func (self *OxmIdTcpFlagsMasked) MarshalJSON() ([]byte, error) {
19291 if self.TypeLen == 0 {
19292 return []byte("\"\""), nil
19293 } else {
19294 return []byte("\"" + self.GetOXMName() + "\""), nil
19295 }
19296}
19297
19298type OxmIdTcpSrc struct {
19299 *OxmId
19300}
19301
19302type IOxmIdTcpSrc interface {
19303 IOxmId
19304}
19305
19306func (self *OxmIdTcpSrc) Serialize(encoder *goloxi.Encoder) error {
19307 if err := self.OxmId.Serialize(encoder); err != nil {
19308 return err
19309 }
19310
19311 return nil
19312}
19313
19314func DecodeOxmIdTcpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpSrc, error) {
19315 _oxmidtcpsrc := &OxmIdTcpSrc{OxmId: parent}
19316 return _oxmidtcpsrc, nil
19317}
19318
19319func NewOxmIdTcpSrc() *OxmIdTcpSrc {
19320 obj := &OxmIdTcpSrc{
19321 OxmId: NewOxmId(4610),
19322 }
19323 return obj
19324}
19325func (self *OxmIdTcpSrc) GetOXMName() string {
19326 return "tcp_src"
19327}
19328
19329func (self *OxmIdTcpSrc) MarshalJSON() ([]byte, error) {
19330 if self.TypeLen == 0 {
19331 return []byte("\"\""), nil
19332 } else {
19333 return []byte("\"" + self.GetOXMName() + "\""), nil
19334 }
19335}
19336
19337type OxmIdTcpSrcMasked struct {
19338 *OxmId
19339}
19340
19341type IOxmIdTcpSrcMasked interface {
19342 IOxmId
19343}
19344
19345func (self *OxmIdTcpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
19346 if err := self.OxmId.Serialize(encoder); err != nil {
19347 return err
19348 }
19349
19350 return nil
19351}
19352
19353func DecodeOxmIdTcpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpSrcMasked, error) {
19354 _oxmidtcpsrcmasked := &OxmIdTcpSrcMasked{OxmId: parent}
19355 return _oxmidtcpsrcmasked, nil
19356}
19357
19358func NewOxmIdTcpSrcMasked() *OxmIdTcpSrcMasked {
19359 obj := &OxmIdTcpSrcMasked{
19360 OxmId: NewOxmId(4868),
19361 }
19362 return obj
19363}
19364func (self *OxmIdTcpSrcMasked) GetOXMName() string {
19365 return "tcp_src_masked"
19366}
19367
19368func (self *OxmIdTcpSrcMasked) MarshalJSON() ([]byte, error) {
19369 if self.TypeLen == 0 {
19370 return []byte("\"\""), nil
19371 } else {
19372 return []byte("\"" + self.GetOXMName() + "\""), nil
19373 }
19374}
19375
19376type OxmIdTunDst struct {
19377 *OxmId
19378}
19379
19380type IOxmIdTunDst interface {
19381 IOxmId
19382}
19383
19384func (self *OxmIdTunDst) Serialize(encoder *goloxi.Encoder) error {
19385 if err := self.OxmId.Serialize(encoder); err != nil {
19386 return err
19387 }
19388
19389 return nil
19390}
19391
19392func DecodeOxmIdTunDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunDst, error) {
19393 _oxmidtundst := &OxmIdTunDst{OxmId: parent}
19394 return _oxmidtundst, nil
19395}
19396
19397func NewOxmIdTunDst() *OxmIdTunDst {
19398 obj := &OxmIdTunDst{
19399 OxmId: NewOxmId(81924),
19400 }
19401 return obj
19402}
19403func (self *OxmIdTunDst) GetOXMName() string {
19404 return "tun_dst"
19405}
19406
19407func (self *OxmIdTunDst) MarshalJSON() ([]byte, error) {
19408 if self.TypeLen == 0 {
19409 return []byte("\"\""), nil
19410 } else {
19411 return []byte("\"" + self.GetOXMName() + "\""), nil
19412 }
19413}
19414
19415type OxmIdTunDstMasked struct {
19416 *OxmId
19417}
19418
19419type IOxmIdTunDstMasked interface {
19420 IOxmId
19421}
19422
19423func (self *OxmIdTunDstMasked) Serialize(encoder *goloxi.Encoder) error {
19424 if err := self.OxmId.Serialize(encoder); err != nil {
19425 return err
19426 }
19427
19428 return nil
19429}
19430
19431func DecodeOxmIdTunDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunDstMasked, error) {
19432 _oxmidtundstmasked := &OxmIdTunDstMasked{OxmId: parent}
19433 return _oxmidtundstmasked, nil
19434}
19435
19436func NewOxmIdTunDstMasked() *OxmIdTunDstMasked {
19437 obj := &OxmIdTunDstMasked{
19438 OxmId: NewOxmId(82184),
19439 }
19440 return obj
19441}
19442func (self *OxmIdTunDstMasked) GetOXMName() string {
19443 return "tun_dst_masked"
19444}
19445
19446func (self *OxmIdTunDstMasked) MarshalJSON() ([]byte, error) {
19447 if self.TypeLen == 0 {
19448 return []byte("\"\""), nil
19449 } else {
19450 return []byte("\"" + self.GetOXMName() + "\""), nil
19451 }
19452}
19453
19454type OxmIdTunFlags struct {
19455 *OxmId
19456}
19457
19458type IOxmIdTunFlags interface {
19459 IOxmId
19460}
19461
19462func (self *OxmIdTunFlags) Serialize(encoder *goloxi.Encoder) error {
19463 if err := self.OxmId.Serialize(encoder); err != nil {
19464 return err
19465 }
19466
19467 return nil
19468}
19469
19470func DecodeOxmIdTunFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunFlags, error) {
19471 _oxmidtunflags := &OxmIdTunFlags{OxmId: parent}
19472 return _oxmidtunflags, nil
19473}
19474
19475func NewOxmIdTunFlags() *OxmIdTunFlags {
19476 obj := &OxmIdTunFlags{
19477 OxmId: NewOxmId(118786),
19478 }
19479 return obj
19480}
19481func (self *OxmIdTunFlags) GetOXMName() string {
19482 return "tun_flags"
19483}
19484
19485func (self *OxmIdTunFlags) MarshalJSON() ([]byte, error) {
19486 if self.TypeLen == 0 {
19487 return []byte("\"\""), nil
19488 } else {
19489 return []byte("\"" + self.GetOXMName() + "\""), nil
19490 }
19491}
19492
19493type OxmIdTunFlagsMasked struct {
19494 *OxmId
19495}
19496
19497type IOxmIdTunFlagsMasked interface {
19498 IOxmId
19499}
19500
19501func (self *OxmIdTunFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
19502 if err := self.OxmId.Serialize(encoder); err != nil {
19503 return err
19504 }
19505
19506 return nil
19507}
19508
19509func DecodeOxmIdTunFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunFlagsMasked, error) {
19510 _oxmidtunflagsmasked := &OxmIdTunFlagsMasked{OxmId: parent}
19511 return _oxmidtunflagsmasked, nil
19512}
19513
19514func NewOxmIdTunFlagsMasked() *OxmIdTunFlagsMasked {
19515 obj := &OxmIdTunFlagsMasked{
19516 OxmId: NewOxmId(119044),
19517 }
19518 return obj
19519}
19520func (self *OxmIdTunFlagsMasked) GetOXMName() string {
19521 return "tun_flags_masked"
19522}
19523
19524func (self *OxmIdTunFlagsMasked) MarshalJSON() ([]byte, error) {
19525 if self.TypeLen == 0 {
19526 return []byte("\"\""), nil
19527 } else {
19528 return []byte("\"" + self.GetOXMName() + "\""), nil
19529 }
19530}
19531
19532type OxmIdTunGbpFlags struct {
19533 *OxmId
19534}
19535
19536type IOxmIdTunGbpFlags interface {
19537 IOxmId
19538}
19539
19540func (self *OxmIdTunGbpFlags) Serialize(encoder *goloxi.Encoder) error {
19541 if err := self.OxmId.Serialize(encoder); err != nil {
19542 return err
19543 }
19544
19545 return nil
19546}
19547
19548func DecodeOxmIdTunGbpFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpFlags, error) {
19549 _oxmidtungbpflags := &OxmIdTunGbpFlags{OxmId: parent}
19550 return _oxmidtungbpflags, nil
19551}
19552
19553func NewOxmIdTunGbpFlags() *OxmIdTunGbpFlags {
19554 obj := &OxmIdTunGbpFlags{
19555 OxmId: NewOxmId(85505),
19556 }
19557 return obj
19558}
19559func (self *OxmIdTunGbpFlags) GetOXMName() string {
19560 return "tun_gbp_flags"
19561}
19562
19563func (self *OxmIdTunGbpFlags) MarshalJSON() ([]byte, error) {
19564 if self.TypeLen == 0 {
19565 return []byte("\"\""), nil
19566 } else {
19567 return []byte("\"" + self.GetOXMName() + "\""), nil
19568 }
19569}
19570
19571type OxmIdTunGbpFlagsMasked struct {
19572 *OxmId
19573}
19574
19575type IOxmIdTunGbpFlagsMasked interface {
19576 IOxmId
19577}
19578
19579func (self *OxmIdTunGbpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
19580 if err := self.OxmId.Serialize(encoder); err != nil {
19581 return err
19582 }
19583
19584 return nil
19585}
19586
19587func DecodeOxmIdTunGbpFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpFlagsMasked, error) {
19588 _oxmidtungbpflagsmasked := &OxmIdTunGbpFlagsMasked{OxmId: parent}
19589 return _oxmidtungbpflagsmasked, nil
19590}
19591
19592func NewOxmIdTunGbpFlagsMasked() *OxmIdTunGbpFlagsMasked {
19593 obj := &OxmIdTunGbpFlagsMasked{
19594 OxmId: NewOxmId(85762),
19595 }
19596 return obj
19597}
19598func (self *OxmIdTunGbpFlagsMasked) GetOXMName() string {
19599 return "tun_gbp_flags_masked"
19600}
19601
19602func (self *OxmIdTunGbpFlagsMasked) MarshalJSON() ([]byte, error) {
19603 if self.TypeLen == 0 {
19604 return []byte("\"\""), nil
19605 } else {
19606 return []byte("\"" + self.GetOXMName() + "\""), nil
19607 }
19608}
19609
19610type OxmIdTunGbpId struct {
19611 *OxmId
19612}
19613
19614type IOxmIdTunGbpId interface {
19615 IOxmId
19616}
19617
19618func (self *OxmIdTunGbpId) Serialize(encoder *goloxi.Encoder) error {
19619 if err := self.OxmId.Serialize(encoder); err != nil {
19620 return err
19621 }
19622
19623 return nil
19624}
19625
19626func DecodeOxmIdTunGbpId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpId, error) {
19627 _oxmidtungbpid := &OxmIdTunGbpId{OxmId: parent}
19628 return _oxmidtungbpid, nil
19629}
19630
19631func NewOxmIdTunGbpId() *OxmIdTunGbpId {
19632 obj := &OxmIdTunGbpId{
19633 OxmId: NewOxmId(84994),
19634 }
19635 return obj
19636}
19637func (self *OxmIdTunGbpId) GetOXMName() string {
19638 return "tun_gbp_id"
19639}
19640
19641func (self *OxmIdTunGbpId) MarshalJSON() ([]byte, error) {
19642 if self.TypeLen == 0 {
19643 return []byte("\"\""), nil
19644 } else {
19645 return []byte("\"" + self.GetOXMName() + "\""), nil
19646 }
19647}
19648
19649type OxmIdTunGbpIdMasked struct {
19650 *OxmId
19651}
19652
19653type IOxmIdTunGbpIdMasked interface {
19654 IOxmId
19655}
19656
19657func (self *OxmIdTunGbpIdMasked) Serialize(encoder *goloxi.Encoder) error {
19658 if err := self.OxmId.Serialize(encoder); err != nil {
19659 return err
19660 }
19661
19662 return nil
19663}
19664
19665func DecodeOxmIdTunGbpIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpIdMasked, error) {
19666 _oxmidtungbpidmasked := &OxmIdTunGbpIdMasked{OxmId: parent}
19667 return _oxmidtungbpidmasked, nil
19668}
19669
19670func NewOxmIdTunGbpIdMasked() *OxmIdTunGbpIdMasked {
19671 obj := &OxmIdTunGbpIdMasked{
19672 OxmId: NewOxmId(85252),
19673 }
19674 return obj
19675}
19676func (self *OxmIdTunGbpIdMasked) GetOXMName() string {
19677 return "tun_gbp_id_masked"
19678}
19679
19680func (self *OxmIdTunGbpIdMasked) MarshalJSON() ([]byte, error) {
19681 if self.TypeLen == 0 {
19682 return []byte("\"\""), nil
19683 } else {
19684 return []byte("\"" + self.GetOXMName() + "\""), nil
19685 }
19686}
19687
19688type OxmIdTunId struct {
19689 *OxmId
19690}
19691
19692type IOxmIdTunId interface {
19693 IOxmId
19694}
19695
19696func (self *OxmIdTunId) Serialize(encoder *goloxi.Encoder) error {
19697 if err := self.OxmId.Serialize(encoder); err != nil {
19698 return err
19699 }
19700
19701 return nil
19702}
19703
19704func DecodeOxmIdTunId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunId, error) {
19705 _oxmidtunid := &OxmIdTunId{OxmId: parent}
19706 return _oxmidtunid, nil
19707}
19708
19709func NewOxmIdTunId() *OxmIdTunId {
19710 obj := &OxmIdTunId{
19711 OxmId: NewOxmId(73736),
19712 }
19713 return obj
19714}
19715func (self *OxmIdTunId) GetOXMName() string {
19716 return "tun_id"
19717}
19718
19719func (self *OxmIdTunId) MarshalJSON() ([]byte, error) {
19720 if self.TypeLen == 0 {
19721 return []byte("\"\""), nil
19722 } else {
19723 return []byte("\"" + self.GetOXMName() + "\""), nil
19724 }
19725}
19726
19727type OxmIdTunIdMasked struct {
19728 *OxmId
19729}
19730
19731type IOxmIdTunIdMasked interface {
19732 IOxmId
19733}
19734
19735func (self *OxmIdTunIdMasked) Serialize(encoder *goloxi.Encoder) error {
19736 if err := self.OxmId.Serialize(encoder); err != nil {
19737 return err
19738 }
19739
19740 return nil
19741}
19742
19743func DecodeOxmIdTunIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIdMasked, error) {
19744 _oxmidtunidmasked := &OxmIdTunIdMasked{OxmId: parent}
19745 return _oxmidtunidmasked, nil
19746}
19747
19748func NewOxmIdTunIdMasked() *OxmIdTunIdMasked {
19749 obj := &OxmIdTunIdMasked{
19750 OxmId: NewOxmId(74000),
19751 }
19752 return obj
19753}
19754func (self *OxmIdTunIdMasked) GetOXMName() string {
19755 return "tun_id_masked"
19756}
19757
19758func (self *OxmIdTunIdMasked) MarshalJSON() ([]byte, error) {
19759 if self.TypeLen == 0 {
19760 return []byte("\"\""), nil
19761 } else {
19762 return []byte("\"" + self.GetOXMName() + "\""), nil
19763 }
19764}
19765
19766type OxmIdTunIpv6Dst struct {
19767 *OxmId
19768}
19769
19770type IOxmIdTunIpv6Dst interface {
19771 IOxmId
19772}
19773
19774func (self *OxmIdTunIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
19775 if err := self.OxmId.Serialize(encoder); err != nil {
19776 return err
19777 }
19778
19779 return nil
19780}
19781
19782func DecodeOxmIdTunIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6Dst, error) {
19783 _oxmidtunipv6dst := &OxmIdTunIpv6Dst{OxmId: parent}
19784 return _oxmidtunipv6dst, nil
19785}
19786
19787func NewOxmIdTunIpv6Dst() *OxmIdTunIpv6Dst {
19788 obj := &OxmIdTunIpv6Dst{
19789 OxmId: NewOxmId(121872),
19790 }
19791 return obj
19792}
19793func (self *OxmIdTunIpv6Dst) GetOXMName() string {
19794 return "tun_ipv6_dst"
19795}
19796
19797func (self *OxmIdTunIpv6Dst) MarshalJSON() ([]byte, error) {
19798 if self.TypeLen == 0 {
19799 return []byte("\"\""), nil
19800 } else {
19801 return []byte("\"" + self.GetOXMName() + "\""), nil
19802 }
19803}
19804
19805type OxmIdTunIpv6DstMasked struct {
19806 *OxmId
19807}
19808
19809type IOxmIdTunIpv6DstMasked interface {
19810 IOxmId
19811}
19812
19813func (self *OxmIdTunIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
19814 if err := self.OxmId.Serialize(encoder); err != nil {
19815 return err
19816 }
19817
19818 return nil
19819}
19820
19821func DecodeOxmIdTunIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6DstMasked, error) {
19822 _oxmidtunipv6dstmasked := &OxmIdTunIpv6DstMasked{OxmId: parent}
19823 return _oxmidtunipv6dstmasked, nil
19824}
19825
19826func NewOxmIdTunIpv6DstMasked() *OxmIdTunIpv6DstMasked {
19827 obj := &OxmIdTunIpv6DstMasked{
19828 OxmId: NewOxmId(122144),
19829 }
19830 return obj
19831}
19832func (self *OxmIdTunIpv6DstMasked) GetOXMName() string {
19833 return "tun_ipv6_dst_masked"
19834}
19835
19836func (self *OxmIdTunIpv6DstMasked) MarshalJSON() ([]byte, error) {
19837 if self.TypeLen == 0 {
19838 return []byte("\"\""), nil
19839 } else {
19840 return []byte("\"" + self.GetOXMName() + "\""), nil
19841 }
19842}
19843
19844type OxmIdTunIpv6Src struct {
19845 *OxmId
19846}
19847
19848type IOxmIdTunIpv6Src interface {
19849 IOxmId
19850}
19851
19852func (self *OxmIdTunIpv6Src) Serialize(encoder *goloxi.Encoder) error {
19853 if err := self.OxmId.Serialize(encoder); err != nil {
19854 return err
19855 }
19856
19857 return nil
19858}
19859
19860func DecodeOxmIdTunIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6Src, error) {
19861 _oxmidtunipv6src := &OxmIdTunIpv6Src{OxmId: parent}
19862 return _oxmidtunipv6src, nil
19863}
19864
19865func NewOxmIdTunIpv6Src() *OxmIdTunIpv6Src {
19866 obj := &OxmIdTunIpv6Src{
19867 OxmId: NewOxmId(121360),
19868 }
19869 return obj
19870}
19871func (self *OxmIdTunIpv6Src) GetOXMName() string {
19872 return "tun_ipv6_src"
19873}
19874
19875func (self *OxmIdTunIpv6Src) MarshalJSON() ([]byte, error) {
19876 if self.TypeLen == 0 {
19877 return []byte("\"\""), nil
19878 } else {
19879 return []byte("\"" + self.GetOXMName() + "\""), nil
19880 }
19881}
19882
19883type OxmIdTunIpv6SrcMasked struct {
19884 *OxmId
19885}
19886
19887type IOxmIdTunIpv6SrcMasked interface {
19888 IOxmId
19889}
19890
19891func (self *OxmIdTunIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
19892 if err := self.OxmId.Serialize(encoder); err != nil {
19893 return err
19894 }
19895
19896 return nil
19897}
19898
19899func DecodeOxmIdTunIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6SrcMasked, error) {
19900 _oxmidtunipv6srcmasked := &OxmIdTunIpv6SrcMasked{OxmId: parent}
19901 return _oxmidtunipv6srcmasked, nil
19902}
19903
19904func NewOxmIdTunIpv6SrcMasked() *OxmIdTunIpv6SrcMasked {
19905 obj := &OxmIdTunIpv6SrcMasked{
19906 OxmId: NewOxmId(121632),
19907 }
19908 return obj
19909}
19910func (self *OxmIdTunIpv6SrcMasked) GetOXMName() string {
19911 return "tun_ipv6_src_masked"
19912}
19913
19914func (self *OxmIdTunIpv6SrcMasked) MarshalJSON() ([]byte, error) {
19915 if self.TypeLen == 0 {
19916 return []byte("\"\""), nil
19917 } else {
19918 return []byte("\"" + self.GetOXMName() + "\""), nil
19919 }
19920}
19921
19922type OxmIdTunMetadata0 struct {
19923 *OxmId
19924}
19925
19926type IOxmIdTunMetadata0 interface {
19927 IOxmId
19928}
19929
19930func (self *OxmIdTunMetadata0) Serialize(encoder *goloxi.Encoder) error {
19931 if err := self.OxmId.Serialize(encoder); err != nil {
19932 return err
19933 }
19934
19935 return nil
19936}
19937
19938func DecodeOxmIdTunMetadata0(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata0, error) {
19939 _oxmidtunmetadata0 := &OxmIdTunMetadata0{OxmId: parent}
19940 return _oxmidtunmetadata0, nil
19941}
19942
19943func NewOxmIdTunMetadata0() *OxmIdTunMetadata0 {
19944 obj := &OxmIdTunMetadata0{
19945 OxmId: NewOxmId(86140),
19946 }
19947 return obj
19948}
19949func (self *OxmIdTunMetadata0) GetOXMName() string {
19950 return "tun_metadata0"
19951}
19952
19953func (self *OxmIdTunMetadata0) MarshalJSON() ([]byte, error) {
19954 if self.TypeLen == 0 {
19955 return []byte("\"\""), nil
19956 } else {
19957 return []byte("\"" + self.GetOXMName() + "\""), nil
19958 }
19959}
19960
19961type OxmIdTunMetadata0Masked struct {
19962 *OxmId
19963}
19964
19965type IOxmIdTunMetadata0Masked interface {
19966 IOxmId
19967}
19968
19969func (self *OxmIdTunMetadata0Masked) Serialize(encoder *goloxi.Encoder) error {
19970 if err := self.OxmId.Serialize(encoder); err != nil {
19971 return err
19972 }
19973
19974 return nil
19975}
19976
19977func DecodeOxmIdTunMetadata0Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata0Masked, error) {
19978 _oxmidtunmetadata0masked := &OxmIdTunMetadata0Masked{OxmId: parent}
19979 return _oxmidtunmetadata0masked, nil
19980}
19981
19982func NewOxmIdTunMetadata0Masked() *OxmIdTunMetadata0Masked {
19983 obj := &OxmIdTunMetadata0Masked{
19984 OxmId: NewOxmId(86520),
19985 }
19986 return obj
19987}
19988func (self *OxmIdTunMetadata0Masked) GetOXMName() string {
19989 return "tun_metadata0_masked"
19990}
19991
19992func (self *OxmIdTunMetadata0Masked) MarshalJSON() ([]byte, error) {
19993 if self.TypeLen == 0 {
19994 return []byte("\"\""), nil
19995 } else {
19996 return []byte("\"" + self.GetOXMName() + "\""), nil
19997 }
19998}
19999
20000type OxmIdTunMetadata1 struct {
20001 *OxmId
20002}
20003
20004type IOxmIdTunMetadata1 interface {
20005 IOxmId
20006}
20007
20008func (self *OxmIdTunMetadata1) Serialize(encoder *goloxi.Encoder) error {
20009 if err := self.OxmId.Serialize(encoder); err != nil {
20010 return err
20011 }
20012
20013 return nil
20014}
20015
20016func DecodeOxmIdTunMetadata1(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata1, error) {
20017 _oxmidtunmetadata1 := &OxmIdTunMetadata1{OxmId: parent}
20018 return _oxmidtunmetadata1, nil
20019}
20020
20021func NewOxmIdTunMetadata1() *OxmIdTunMetadata1 {
20022 obj := &OxmIdTunMetadata1{
20023 OxmId: NewOxmId(86652),
20024 }
20025 return obj
20026}
20027func (self *OxmIdTunMetadata1) GetOXMName() string {
20028 return "tun_metadata1"
20029}
20030
20031func (self *OxmIdTunMetadata1) MarshalJSON() ([]byte, error) {
20032 if self.TypeLen == 0 {
20033 return []byte("\"\""), nil
20034 } else {
20035 return []byte("\"" + self.GetOXMName() + "\""), nil
20036 }
20037}
20038
20039type OxmIdTunMetadata10 struct {
20040 *OxmId
20041}
20042
20043type IOxmIdTunMetadata10 interface {
20044 IOxmId
20045}
20046
20047func (self *OxmIdTunMetadata10) Serialize(encoder *goloxi.Encoder) error {
20048 if err := self.OxmId.Serialize(encoder); err != nil {
20049 return err
20050 }
20051
20052 return nil
20053}
20054
20055func DecodeOxmIdTunMetadata10(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata10, error) {
20056 _oxmidtunmetadata10 := &OxmIdTunMetadata10{OxmId: parent}
20057 return _oxmidtunmetadata10, nil
20058}
20059
20060func NewOxmIdTunMetadata10() *OxmIdTunMetadata10 {
20061 obj := &OxmIdTunMetadata10{
20062 OxmId: NewOxmId(91260),
20063 }
20064 return obj
20065}
20066func (self *OxmIdTunMetadata10) GetOXMName() string {
20067 return "tun_metadata10"
20068}
20069
20070func (self *OxmIdTunMetadata10) MarshalJSON() ([]byte, error) {
20071 if self.TypeLen == 0 {
20072 return []byte("\"\""), nil
20073 } else {
20074 return []byte("\"" + self.GetOXMName() + "\""), nil
20075 }
20076}
20077
20078type OxmIdTunMetadata10Masked struct {
20079 *OxmId
20080}
20081
20082type IOxmIdTunMetadata10Masked interface {
20083 IOxmId
20084}
20085
20086func (self *OxmIdTunMetadata10Masked) Serialize(encoder *goloxi.Encoder) error {
20087 if err := self.OxmId.Serialize(encoder); err != nil {
20088 return err
20089 }
20090
20091 return nil
20092}
20093
20094func DecodeOxmIdTunMetadata10Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata10Masked, error) {
20095 _oxmidtunmetadata10masked := &OxmIdTunMetadata10Masked{OxmId: parent}
20096 return _oxmidtunmetadata10masked, nil
20097}
20098
20099func NewOxmIdTunMetadata10Masked() *OxmIdTunMetadata10Masked {
20100 obj := &OxmIdTunMetadata10Masked{
20101 OxmId: NewOxmId(91640),
20102 }
20103 return obj
20104}
20105func (self *OxmIdTunMetadata10Masked) GetOXMName() string {
20106 return "tun_metadata10_masked"
20107}
20108
20109func (self *OxmIdTunMetadata10Masked) MarshalJSON() ([]byte, error) {
20110 if self.TypeLen == 0 {
20111 return []byte("\"\""), nil
20112 } else {
20113 return []byte("\"" + self.GetOXMName() + "\""), nil
20114 }
20115}
20116
20117type OxmIdTunMetadata11 struct {
20118 *OxmId
20119}
20120
20121type IOxmIdTunMetadata11 interface {
20122 IOxmId
20123}
20124
20125func (self *OxmIdTunMetadata11) Serialize(encoder *goloxi.Encoder) error {
20126 if err := self.OxmId.Serialize(encoder); err != nil {
20127 return err
20128 }
20129
20130 return nil
20131}
20132
20133func DecodeOxmIdTunMetadata11(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata11, error) {
20134 _oxmidtunmetadata11 := &OxmIdTunMetadata11{OxmId: parent}
20135 return _oxmidtunmetadata11, nil
20136}
20137
20138func NewOxmIdTunMetadata11() *OxmIdTunMetadata11 {
20139 obj := &OxmIdTunMetadata11{
20140 OxmId: NewOxmId(91772),
20141 }
20142 return obj
20143}
20144func (self *OxmIdTunMetadata11) GetOXMName() string {
20145 return "tun_metadata11"
20146}
20147
20148func (self *OxmIdTunMetadata11) MarshalJSON() ([]byte, error) {
20149 if self.TypeLen == 0 {
20150 return []byte("\"\""), nil
20151 } else {
20152 return []byte("\"" + self.GetOXMName() + "\""), nil
20153 }
20154}
20155
20156type OxmIdTunMetadata11Masked struct {
20157 *OxmId
20158}
20159
20160type IOxmIdTunMetadata11Masked interface {
20161 IOxmId
20162}
20163
20164func (self *OxmIdTunMetadata11Masked) Serialize(encoder *goloxi.Encoder) error {
20165 if err := self.OxmId.Serialize(encoder); err != nil {
20166 return err
20167 }
20168
20169 return nil
20170}
20171
20172func DecodeOxmIdTunMetadata11Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata11Masked, error) {
20173 _oxmidtunmetadata11masked := &OxmIdTunMetadata11Masked{OxmId: parent}
20174 return _oxmidtunmetadata11masked, nil
20175}
20176
20177func NewOxmIdTunMetadata11Masked() *OxmIdTunMetadata11Masked {
20178 obj := &OxmIdTunMetadata11Masked{
20179 OxmId: NewOxmId(92152),
20180 }
20181 return obj
20182}
20183func (self *OxmIdTunMetadata11Masked) GetOXMName() string {
20184 return "tun_metadata11_masked"
20185}
20186
20187func (self *OxmIdTunMetadata11Masked) MarshalJSON() ([]byte, error) {
20188 if self.TypeLen == 0 {
20189 return []byte("\"\""), nil
20190 } else {
20191 return []byte("\"" + self.GetOXMName() + "\""), nil
20192 }
20193}
20194
20195type OxmIdTunMetadata12 struct {
20196 *OxmId
20197}
20198
20199type IOxmIdTunMetadata12 interface {
20200 IOxmId
20201}
20202
20203func (self *OxmIdTunMetadata12) Serialize(encoder *goloxi.Encoder) error {
20204 if err := self.OxmId.Serialize(encoder); err != nil {
20205 return err
20206 }
20207
20208 return nil
20209}
20210
20211func DecodeOxmIdTunMetadata12(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata12, error) {
20212 _oxmidtunmetadata12 := &OxmIdTunMetadata12{OxmId: parent}
20213 return _oxmidtunmetadata12, nil
20214}
20215
20216func NewOxmIdTunMetadata12() *OxmIdTunMetadata12 {
20217 obj := &OxmIdTunMetadata12{
20218 OxmId: NewOxmId(92284),
20219 }
20220 return obj
20221}
20222func (self *OxmIdTunMetadata12) GetOXMName() string {
20223 return "tun_metadata12"
20224}
20225
20226func (self *OxmIdTunMetadata12) MarshalJSON() ([]byte, error) {
20227 if self.TypeLen == 0 {
20228 return []byte("\"\""), nil
20229 } else {
20230 return []byte("\"" + self.GetOXMName() + "\""), nil
20231 }
20232}
20233
20234type OxmIdTunMetadata12Masked struct {
20235 *OxmId
20236}
20237
20238type IOxmIdTunMetadata12Masked interface {
20239 IOxmId
20240}
20241
20242func (self *OxmIdTunMetadata12Masked) Serialize(encoder *goloxi.Encoder) error {
20243 if err := self.OxmId.Serialize(encoder); err != nil {
20244 return err
20245 }
20246
20247 return nil
20248}
20249
20250func DecodeOxmIdTunMetadata12Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata12Masked, error) {
20251 _oxmidtunmetadata12masked := &OxmIdTunMetadata12Masked{OxmId: parent}
20252 return _oxmidtunmetadata12masked, nil
20253}
20254
20255func NewOxmIdTunMetadata12Masked() *OxmIdTunMetadata12Masked {
20256 obj := &OxmIdTunMetadata12Masked{
20257 OxmId: NewOxmId(92664),
20258 }
20259 return obj
20260}
20261func (self *OxmIdTunMetadata12Masked) GetOXMName() string {
20262 return "tun_metadata12_masked"
20263}
20264
20265func (self *OxmIdTunMetadata12Masked) MarshalJSON() ([]byte, error) {
20266 if self.TypeLen == 0 {
20267 return []byte("\"\""), nil
20268 } else {
20269 return []byte("\"" + self.GetOXMName() + "\""), nil
20270 }
20271}
20272
20273type OxmIdTunMetadata13 struct {
20274 *OxmId
20275}
20276
20277type IOxmIdTunMetadata13 interface {
20278 IOxmId
20279}
20280
20281func (self *OxmIdTunMetadata13) Serialize(encoder *goloxi.Encoder) error {
20282 if err := self.OxmId.Serialize(encoder); err != nil {
20283 return err
20284 }
20285
20286 return nil
20287}
20288
20289func DecodeOxmIdTunMetadata13(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata13, error) {
20290 _oxmidtunmetadata13 := &OxmIdTunMetadata13{OxmId: parent}
20291 return _oxmidtunmetadata13, nil
20292}
20293
20294func NewOxmIdTunMetadata13() *OxmIdTunMetadata13 {
20295 obj := &OxmIdTunMetadata13{
20296 OxmId: NewOxmId(92796),
20297 }
20298 return obj
20299}
20300func (self *OxmIdTunMetadata13) GetOXMName() string {
20301 return "tun_metadata13"
20302}
20303
20304func (self *OxmIdTunMetadata13) MarshalJSON() ([]byte, error) {
20305 if self.TypeLen == 0 {
20306 return []byte("\"\""), nil
20307 } else {
20308 return []byte("\"" + self.GetOXMName() + "\""), nil
20309 }
20310}
20311
20312type OxmIdTunMetadata13Masked struct {
20313 *OxmId
20314}
20315
20316type IOxmIdTunMetadata13Masked interface {
20317 IOxmId
20318}
20319
20320func (self *OxmIdTunMetadata13Masked) Serialize(encoder *goloxi.Encoder) error {
20321 if err := self.OxmId.Serialize(encoder); err != nil {
20322 return err
20323 }
20324
20325 return nil
20326}
20327
20328func DecodeOxmIdTunMetadata13Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata13Masked, error) {
20329 _oxmidtunmetadata13masked := &OxmIdTunMetadata13Masked{OxmId: parent}
20330 return _oxmidtunmetadata13masked, nil
20331}
20332
20333func NewOxmIdTunMetadata13Masked() *OxmIdTunMetadata13Masked {
20334 obj := &OxmIdTunMetadata13Masked{
20335 OxmId: NewOxmId(93176),
20336 }
20337 return obj
20338}
20339func (self *OxmIdTunMetadata13Masked) GetOXMName() string {
20340 return "tun_metadata13_masked"
20341}
20342
20343func (self *OxmIdTunMetadata13Masked) MarshalJSON() ([]byte, error) {
20344 if self.TypeLen == 0 {
20345 return []byte("\"\""), nil
20346 } else {
20347 return []byte("\"" + self.GetOXMName() + "\""), nil
20348 }
20349}
20350
20351type OxmIdTunMetadata14 struct {
20352 *OxmId
20353}
20354
20355type IOxmIdTunMetadata14 interface {
20356 IOxmId
20357}
20358
20359func (self *OxmIdTunMetadata14) Serialize(encoder *goloxi.Encoder) error {
20360 if err := self.OxmId.Serialize(encoder); err != nil {
20361 return err
20362 }
20363
20364 return nil
20365}
20366
20367func DecodeOxmIdTunMetadata14(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata14, error) {
20368 _oxmidtunmetadata14 := &OxmIdTunMetadata14{OxmId: parent}
20369 return _oxmidtunmetadata14, nil
20370}
20371
20372func NewOxmIdTunMetadata14() *OxmIdTunMetadata14 {
20373 obj := &OxmIdTunMetadata14{
20374 OxmId: NewOxmId(93308),
20375 }
20376 return obj
20377}
20378func (self *OxmIdTunMetadata14) GetOXMName() string {
20379 return "tun_metadata14"
20380}
20381
20382func (self *OxmIdTunMetadata14) MarshalJSON() ([]byte, error) {
20383 if self.TypeLen == 0 {
20384 return []byte("\"\""), nil
20385 } else {
20386 return []byte("\"" + self.GetOXMName() + "\""), nil
20387 }
20388}
20389
20390type OxmIdTunMetadata14Masked struct {
20391 *OxmId
20392}
20393
20394type IOxmIdTunMetadata14Masked interface {
20395 IOxmId
20396}
20397
20398func (self *OxmIdTunMetadata14Masked) Serialize(encoder *goloxi.Encoder) error {
20399 if err := self.OxmId.Serialize(encoder); err != nil {
20400 return err
20401 }
20402
20403 return nil
20404}
20405
20406func DecodeOxmIdTunMetadata14Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata14Masked, error) {
20407 _oxmidtunmetadata14masked := &OxmIdTunMetadata14Masked{OxmId: parent}
20408 return _oxmidtunmetadata14masked, nil
20409}
20410
20411func NewOxmIdTunMetadata14Masked() *OxmIdTunMetadata14Masked {
20412 obj := &OxmIdTunMetadata14Masked{
20413 OxmId: NewOxmId(93688),
20414 }
20415 return obj
20416}
20417func (self *OxmIdTunMetadata14Masked) GetOXMName() string {
20418 return "tun_metadata14_masked"
20419}
20420
20421func (self *OxmIdTunMetadata14Masked) MarshalJSON() ([]byte, error) {
20422 if self.TypeLen == 0 {
20423 return []byte("\"\""), nil
20424 } else {
20425 return []byte("\"" + self.GetOXMName() + "\""), nil
20426 }
20427}
20428
20429type OxmIdTunMetadata15 struct {
20430 *OxmId
20431}
20432
20433type IOxmIdTunMetadata15 interface {
20434 IOxmId
20435}
20436
20437func (self *OxmIdTunMetadata15) Serialize(encoder *goloxi.Encoder) error {
20438 if err := self.OxmId.Serialize(encoder); err != nil {
20439 return err
20440 }
20441
20442 return nil
20443}
20444
20445func DecodeOxmIdTunMetadata15(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata15, error) {
20446 _oxmidtunmetadata15 := &OxmIdTunMetadata15{OxmId: parent}
20447 return _oxmidtunmetadata15, nil
20448}
20449
20450func NewOxmIdTunMetadata15() *OxmIdTunMetadata15 {
20451 obj := &OxmIdTunMetadata15{
20452 OxmId: NewOxmId(93820),
20453 }
20454 return obj
20455}
20456func (self *OxmIdTunMetadata15) GetOXMName() string {
20457 return "tun_metadata15"
20458}
20459
20460func (self *OxmIdTunMetadata15) MarshalJSON() ([]byte, error) {
20461 if self.TypeLen == 0 {
20462 return []byte("\"\""), nil
20463 } else {
20464 return []byte("\"" + self.GetOXMName() + "\""), nil
20465 }
20466}
20467
20468type OxmIdTunMetadata15Masked struct {
20469 *OxmId
20470}
20471
20472type IOxmIdTunMetadata15Masked interface {
20473 IOxmId
20474}
20475
20476func (self *OxmIdTunMetadata15Masked) Serialize(encoder *goloxi.Encoder) error {
20477 if err := self.OxmId.Serialize(encoder); err != nil {
20478 return err
20479 }
20480
20481 return nil
20482}
20483
20484func DecodeOxmIdTunMetadata15Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata15Masked, error) {
20485 _oxmidtunmetadata15masked := &OxmIdTunMetadata15Masked{OxmId: parent}
20486 return _oxmidtunmetadata15masked, nil
20487}
20488
20489func NewOxmIdTunMetadata15Masked() *OxmIdTunMetadata15Masked {
20490 obj := &OxmIdTunMetadata15Masked{
20491 OxmId: NewOxmId(94200),
20492 }
20493 return obj
20494}
20495func (self *OxmIdTunMetadata15Masked) GetOXMName() string {
20496 return "tun_metadata15_masked"
20497}
20498
20499func (self *OxmIdTunMetadata15Masked) MarshalJSON() ([]byte, error) {
20500 if self.TypeLen == 0 {
20501 return []byte("\"\""), nil
20502 } else {
20503 return []byte("\"" + self.GetOXMName() + "\""), nil
20504 }
20505}
20506
20507type OxmIdTunMetadata16 struct {
20508 *OxmId
20509}
20510
20511type IOxmIdTunMetadata16 interface {
20512 IOxmId
20513}
20514
20515func (self *OxmIdTunMetadata16) Serialize(encoder *goloxi.Encoder) error {
20516 if err := self.OxmId.Serialize(encoder); err != nil {
20517 return err
20518 }
20519
20520 return nil
20521}
20522
20523func DecodeOxmIdTunMetadata16(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata16, error) {
20524 _oxmidtunmetadata16 := &OxmIdTunMetadata16{OxmId: parent}
20525 return _oxmidtunmetadata16, nil
20526}
20527
20528func NewOxmIdTunMetadata16() *OxmIdTunMetadata16 {
20529 obj := &OxmIdTunMetadata16{
20530 OxmId: NewOxmId(94332),
20531 }
20532 return obj
20533}
20534func (self *OxmIdTunMetadata16) GetOXMName() string {
20535 return "tun_metadata16"
20536}
20537
20538func (self *OxmIdTunMetadata16) MarshalJSON() ([]byte, error) {
20539 if self.TypeLen == 0 {
20540 return []byte("\"\""), nil
20541 } else {
20542 return []byte("\"" + self.GetOXMName() + "\""), nil
20543 }
20544}
20545
20546type OxmIdTunMetadata16Masked struct {
20547 *OxmId
20548}
20549
20550type IOxmIdTunMetadata16Masked interface {
20551 IOxmId
20552}
20553
20554func (self *OxmIdTunMetadata16Masked) Serialize(encoder *goloxi.Encoder) error {
20555 if err := self.OxmId.Serialize(encoder); err != nil {
20556 return err
20557 }
20558
20559 return nil
20560}
20561
20562func DecodeOxmIdTunMetadata16Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata16Masked, error) {
20563 _oxmidtunmetadata16masked := &OxmIdTunMetadata16Masked{OxmId: parent}
20564 return _oxmidtunmetadata16masked, nil
20565}
20566
20567func NewOxmIdTunMetadata16Masked() *OxmIdTunMetadata16Masked {
20568 obj := &OxmIdTunMetadata16Masked{
20569 OxmId: NewOxmId(94712),
20570 }
20571 return obj
20572}
20573func (self *OxmIdTunMetadata16Masked) GetOXMName() string {
20574 return "tun_metadata16_masked"
20575}
20576
20577func (self *OxmIdTunMetadata16Masked) MarshalJSON() ([]byte, error) {
20578 if self.TypeLen == 0 {
20579 return []byte("\"\""), nil
20580 } else {
20581 return []byte("\"" + self.GetOXMName() + "\""), nil
20582 }
20583}
20584
20585type OxmIdTunMetadata17 struct {
20586 *OxmId
20587}
20588
20589type IOxmIdTunMetadata17 interface {
20590 IOxmId
20591}
20592
20593func (self *OxmIdTunMetadata17) Serialize(encoder *goloxi.Encoder) error {
20594 if err := self.OxmId.Serialize(encoder); err != nil {
20595 return err
20596 }
20597
20598 return nil
20599}
20600
20601func DecodeOxmIdTunMetadata17(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata17, error) {
20602 _oxmidtunmetadata17 := &OxmIdTunMetadata17{OxmId: parent}
20603 return _oxmidtunmetadata17, nil
20604}
20605
20606func NewOxmIdTunMetadata17() *OxmIdTunMetadata17 {
20607 obj := &OxmIdTunMetadata17{
20608 OxmId: NewOxmId(94844),
20609 }
20610 return obj
20611}
20612func (self *OxmIdTunMetadata17) GetOXMName() string {
20613 return "tun_metadata17"
20614}
20615
20616func (self *OxmIdTunMetadata17) MarshalJSON() ([]byte, error) {
20617 if self.TypeLen == 0 {
20618 return []byte("\"\""), nil
20619 } else {
20620 return []byte("\"" + self.GetOXMName() + "\""), nil
20621 }
20622}
20623
20624type OxmIdTunMetadata17Masked struct {
20625 *OxmId
20626}
20627
20628type IOxmIdTunMetadata17Masked interface {
20629 IOxmId
20630}
20631
20632func (self *OxmIdTunMetadata17Masked) Serialize(encoder *goloxi.Encoder) error {
20633 if err := self.OxmId.Serialize(encoder); err != nil {
20634 return err
20635 }
20636
20637 return nil
20638}
20639
20640func DecodeOxmIdTunMetadata17Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata17Masked, error) {
20641 _oxmidtunmetadata17masked := &OxmIdTunMetadata17Masked{OxmId: parent}
20642 return _oxmidtunmetadata17masked, nil
20643}
20644
20645func NewOxmIdTunMetadata17Masked() *OxmIdTunMetadata17Masked {
20646 obj := &OxmIdTunMetadata17Masked{
20647 OxmId: NewOxmId(95224),
20648 }
20649 return obj
20650}
20651func (self *OxmIdTunMetadata17Masked) GetOXMName() string {
20652 return "tun_metadata17_masked"
20653}
20654
20655func (self *OxmIdTunMetadata17Masked) MarshalJSON() ([]byte, error) {
20656 if self.TypeLen == 0 {
20657 return []byte("\"\""), nil
20658 } else {
20659 return []byte("\"" + self.GetOXMName() + "\""), nil
20660 }
20661}
20662
20663type OxmIdTunMetadata18 struct {
20664 *OxmId
20665}
20666
20667type IOxmIdTunMetadata18 interface {
20668 IOxmId
20669}
20670
20671func (self *OxmIdTunMetadata18) Serialize(encoder *goloxi.Encoder) error {
20672 if err := self.OxmId.Serialize(encoder); err != nil {
20673 return err
20674 }
20675
20676 return nil
20677}
20678
20679func DecodeOxmIdTunMetadata18(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata18, error) {
20680 _oxmidtunmetadata18 := &OxmIdTunMetadata18{OxmId: parent}
20681 return _oxmidtunmetadata18, nil
20682}
20683
20684func NewOxmIdTunMetadata18() *OxmIdTunMetadata18 {
20685 obj := &OxmIdTunMetadata18{
20686 OxmId: NewOxmId(95356),
20687 }
20688 return obj
20689}
20690func (self *OxmIdTunMetadata18) GetOXMName() string {
20691 return "tun_metadata18"
20692}
20693
20694func (self *OxmIdTunMetadata18) MarshalJSON() ([]byte, error) {
20695 if self.TypeLen == 0 {
20696 return []byte("\"\""), nil
20697 } else {
20698 return []byte("\"" + self.GetOXMName() + "\""), nil
20699 }
20700}
20701
20702type OxmIdTunMetadata18Masked struct {
20703 *OxmId
20704}
20705
20706type IOxmIdTunMetadata18Masked interface {
20707 IOxmId
20708}
20709
20710func (self *OxmIdTunMetadata18Masked) Serialize(encoder *goloxi.Encoder) error {
20711 if err := self.OxmId.Serialize(encoder); err != nil {
20712 return err
20713 }
20714
20715 return nil
20716}
20717
20718func DecodeOxmIdTunMetadata18Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata18Masked, error) {
20719 _oxmidtunmetadata18masked := &OxmIdTunMetadata18Masked{OxmId: parent}
20720 return _oxmidtunmetadata18masked, nil
20721}
20722
20723func NewOxmIdTunMetadata18Masked() *OxmIdTunMetadata18Masked {
20724 obj := &OxmIdTunMetadata18Masked{
20725 OxmId: NewOxmId(95736),
20726 }
20727 return obj
20728}
20729func (self *OxmIdTunMetadata18Masked) GetOXMName() string {
20730 return "tun_metadata18_masked"
20731}
20732
20733func (self *OxmIdTunMetadata18Masked) MarshalJSON() ([]byte, error) {
20734 if self.TypeLen == 0 {
20735 return []byte("\"\""), nil
20736 } else {
20737 return []byte("\"" + self.GetOXMName() + "\""), nil
20738 }
20739}
20740
20741type OxmIdTunMetadata19 struct {
20742 *OxmId
20743}
20744
20745type IOxmIdTunMetadata19 interface {
20746 IOxmId
20747}
20748
20749func (self *OxmIdTunMetadata19) Serialize(encoder *goloxi.Encoder) error {
20750 if err := self.OxmId.Serialize(encoder); err != nil {
20751 return err
20752 }
20753
20754 return nil
20755}
20756
20757func DecodeOxmIdTunMetadata19(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata19, error) {
20758 _oxmidtunmetadata19 := &OxmIdTunMetadata19{OxmId: parent}
20759 return _oxmidtunmetadata19, nil
20760}
20761
20762func NewOxmIdTunMetadata19() *OxmIdTunMetadata19 {
20763 obj := &OxmIdTunMetadata19{
20764 OxmId: NewOxmId(95868),
20765 }
20766 return obj
20767}
20768func (self *OxmIdTunMetadata19) GetOXMName() string {
20769 return "tun_metadata19"
20770}
20771
20772func (self *OxmIdTunMetadata19) MarshalJSON() ([]byte, error) {
20773 if self.TypeLen == 0 {
20774 return []byte("\"\""), nil
20775 } else {
20776 return []byte("\"" + self.GetOXMName() + "\""), nil
20777 }
20778}
20779
20780type OxmIdTunMetadata19Masked struct {
20781 *OxmId
20782}
20783
20784type IOxmIdTunMetadata19Masked interface {
20785 IOxmId
20786}
20787
20788func (self *OxmIdTunMetadata19Masked) Serialize(encoder *goloxi.Encoder) error {
20789 if err := self.OxmId.Serialize(encoder); err != nil {
20790 return err
20791 }
20792
20793 return nil
20794}
20795
20796func DecodeOxmIdTunMetadata19Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata19Masked, error) {
20797 _oxmidtunmetadata19masked := &OxmIdTunMetadata19Masked{OxmId: parent}
20798 return _oxmidtunmetadata19masked, nil
20799}
20800
20801func NewOxmIdTunMetadata19Masked() *OxmIdTunMetadata19Masked {
20802 obj := &OxmIdTunMetadata19Masked{
20803 OxmId: NewOxmId(96248),
20804 }
20805 return obj
20806}
20807func (self *OxmIdTunMetadata19Masked) GetOXMName() string {
20808 return "tun_metadata19_masked"
20809}
20810
20811func (self *OxmIdTunMetadata19Masked) MarshalJSON() ([]byte, error) {
20812 if self.TypeLen == 0 {
20813 return []byte("\"\""), nil
20814 } else {
20815 return []byte("\"" + self.GetOXMName() + "\""), nil
20816 }
20817}
20818
20819type OxmIdTunMetadata1Masked struct {
20820 *OxmId
20821}
20822
20823type IOxmIdTunMetadata1Masked interface {
20824 IOxmId
20825}
20826
20827func (self *OxmIdTunMetadata1Masked) Serialize(encoder *goloxi.Encoder) error {
20828 if err := self.OxmId.Serialize(encoder); err != nil {
20829 return err
20830 }
20831
20832 return nil
20833}
20834
20835func DecodeOxmIdTunMetadata1Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata1Masked, error) {
20836 _oxmidtunmetadata1masked := &OxmIdTunMetadata1Masked{OxmId: parent}
20837 return _oxmidtunmetadata1masked, nil
20838}
20839
20840func NewOxmIdTunMetadata1Masked() *OxmIdTunMetadata1Masked {
20841 obj := &OxmIdTunMetadata1Masked{
20842 OxmId: NewOxmId(87032),
20843 }
20844 return obj
20845}
20846func (self *OxmIdTunMetadata1Masked) GetOXMName() string {
20847 return "tun_metadata1_masked"
20848}
20849
20850func (self *OxmIdTunMetadata1Masked) MarshalJSON() ([]byte, error) {
20851 if self.TypeLen == 0 {
20852 return []byte("\"\""), nil
20853 } else {
20854 return []byte("\"" + self.GetOXMName() + "\""), nil
20855 }
20856}
20857
20858type OxmIdTunMetadata2 struct {
20859 *OxmId
20860}
20861
20862type IOxmIdTunMetadata2 interface {
20863 IOxmId
20864}
20865
20866func (self *OxmIdTunMetadata2) Serialize(encoder *goloxi.Encoder) error {
20867 if err := self.OxmId.Serialize(encoder); err != nil {
20868 return err
20869 }
20870
20871 return nil
20872}
20873
20874func DecodeOxmIdTunMetadata2(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata2, error) {
20875 _oxmidtunmetadata2 := &OxmIdTunMetadata2{OxmId: parent}
20876 return _oxmidtunmetadata2, nil
20877}
20878
20879func NewOxmIdTunMetadata2() *OxmIdTunMetadata2 {
20880 obj := &OxmIdTunMetadata2{
20881 OxmId: NewOxmId(87164),
20882 }
20883 return obj
20884}
20885func (self *OxmIdTunMetadata2) GetOXMName() string {
20886 return "tun_metadata2"
20887}
20888
20889func (self *OxmIdTunMetadata2) MarshalJSON() ([]byte, error) {
20890 if self.TypeLen == 0 {
20891 return []byte("\"\""), nil
20892 } else {
20893 return []byte("\"" + self.GetOXMName() + "\""), nil
20894 }
20895}
20896
20897type OxmIdTunMetadata20 struct {
20898 *OxmId
20899}
20900
20901type IOxmIdTunMetadata20 interface {
20902 IOxmId
20903}
20904
20905func (self *OxmIdTunMetadata20) Serialize(encoder *goloxi.Encoder) error {
20906 if err := self.OxmId.Serialize(encoder); err != nil {
20907 return err
20908 }
20909
20910 return nil
20911}
20912
20913func DecodeOxmIdTunMetadata20(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata20, error) {
20914 _oxmidtunmetadata20 := &OxmIdTunMetadata20{OxmId: parent}
20915 return _oxmidtunmetadata20, nil
20916}
20917
20918func NewOxmIdTunMetadata20() *OxmIdTunMetadata20 {
20919 obj := &OxmIdTunMetadata20{
20920 OxmId: NewOxmId(96380),
20921 }
20922 return obj
20923}
20924func (self *OxmIdTunMetadata20) GetOXMName() string {
20925 return "tun_metadata20"
20926}
20927
20928func (self *OxmIdTunMetadata20) MarshalJSON() ([]byte, error) {
20929 if self.TypeLen == 0 {
20930 return []byte("\"\""), nil
20931 } else {
20932 return []byte("\"" + self.GetOXMName() + "\""), nil
20933 }
20934}
20935
20936type OxmIdTunMetadata20Masked struct {
20937 *OxmId
20938}
20939
20940type IOxmIdTunMetadata20Masked interface {
20941 IOxmId
20942}
20943
20944func (self *OxmIdTunMetadata20Masked) Serialize(encoder *goloxi.Encoder) error {
20945 if err := self.OxmId.Serialize(encoder); err != nil {
20946 return err
20947 }
20948
20949 return nil
20950}
20951
20952func DecodeOxmIdTunMetadata20Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata20Masked, error) {
20953 _oxmidtunmetadata20masked := &OxmIdTunMetadata20Masked{OxmId: parent}
20954 return _oxmidtunmetadata20masked, nil
20955}
20956
20957func NewOxmIdTunMetadata20Masked() *OxmIdTunMetadata20Masked {
20958 obj := &OxmIdTunMetadata20Masked{
20959 OxmId: NewOxmId(96760),
20960 }
20961 return obj
20962}
20963func (self *OxmIdTunMetadata20Masked) GetOXMName() string {
20964 return "tun_metadata20_masked"
20965}
20966
20967func (self *OxmIdTunMetadata20Masked) MarshalJSON() ([]byte, error) {
20968 if self.TypeLen == 0 {
20969 return []byte("\"\""), nil
20970 } else {
20971 return []byte("\"" + self.GetOXMName() + "\""), nil
20972 }
20973}
20974
20975type OxmIdTunMetadata21 struct {
20976 *OxmId
20977}
20978
20979type IOxmIdTunMetadata21 interface {
20980 IOxmId
20981}
20982
20983func (self *OxmIdTunMetadata21) Serialize(encoder *goloxi.Encoder) error {
20984 if err := self.OxmId.Serialize(encoder); err != nil {
20985 return err
20986 }
20987
20988 return nil
20989}
20990
20991func DecodeOxmIdTunMetadata21(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata21, error) {
20992 _oxmidtunmetadata21 := &OxmIdTunMetadata21{OxmId: parent}
20993 return _oxmidtunmetadata21, nil
20994}
20995
20996func NewOxmIdTunMetadata21() *OxmIdTunMetadata21 {
20997 obj := &OxmIdTunMetadata21{
20998 OxmId: NewOxmId(96892),
20999 }
21000 return obj
21001}
21002func (self *OxmIdTunMetadata21) GetOXMName() string {
21003 return "tun_metadata21"
21004}
21005
21006func (self *OxmIdTunMetadata21) MarshalJSON() ([]byte, error) {
21007 if self.TypeLen == 0 {
21008 return []byte("\"\""), nil
21009 } else {
21010 return []byte("\"" + self.GetOXMName() + "\""), nil
21011 }
21012}
21013
21014type OxmIdTunMetadata21Masked struct {
21015 *OxmId
21016}
21017
21018type IOxmIdTunMetadata21Masked interface {
21019 IOxmId
21020}
21021
21022func (self *OxmIdTunMetadata21Masked) Serialize(encoder *goloxi.Encoder) error {
21023 if err := self.OxmId.Serialize(encoder); err != nil {
21024 return err
21025 }
21026
21027 return nil
21028}
21029
21030func DecodeOxmIdTunMetadata21Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata21Masked, error) {
21031 _oxmidtunmetadata21masked := &OxmIdTunMetadata21Masked{OxmId: parent}
21032 return _oxmidtunmetadata21masked, nil
21033}
21034
21035func NewOxmIdTunMetadata21Masked() *OxmIdTunMetadata21Masked {
21036 obj := &OxmIdTunMetadata21Masked{
21037 OxmId: NewOxmId(97272),
21038 }
21039 return obj
21040}
21041func (self *OxmIdTunMetadata21Masked) GetOXMName() string {
21042 return "tun_metadata21_masked"
21043}
21044
21045func (self *OxmIdTunMetadata21Masked) MarshalJSON() ([]byte, error) {
21046 if self.TypeLen == 0 {
21047 return []byte("\"\""), nil
21048 } else {
21049 return []byte("\"" + self.GetOXMName() + "\""), nil
21050 }
21051}
21052
21053type OxmIdTunMetadata22 struct {
21054 *OxmId
21055}
21056
21057type IOxmIdTunMetadata22 interface {
21058 IOxmId
21059}
21060
21061func (self *OxmIdTunMetadata22) Serialize(encoder *goloxi.Encoder) error {
21062 if err := self.OxmId.Serialize(encoder); err != nil {
21063 return err
21064 }
21065
21066 return nil
21067}
21068
21069func DecodeOxmIdTunMetadata22(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata22, error) {
21070 _oxmidtunmetadata22 := &OxmIdTunMetadata22{OxmId: parent}
21071 return _oxmidtunmetadata22, nil
21072}
21073
21074func NewOxmIdTunMetadata22() *OxmIdTunMetadata22 {
21075 obj := &OxmIdTunMetadata22{
21076 OxmId: NewOxmId(97404),
21077 }
21078 return obj
21079}
21080func (self *OxmIdTunMetadata22) GetOXMName() string {
21081 return "tun_metadata22"
21082}
21083
21084func (self *OxmIdTunMetadata22) MarshalJSON() ([]byte, error) {
21085 if self.TypeLen == 0 {
21086 return []byte("\"\""), nil
21087 } else {
21088 return []byte("\"" + self.GetOXMName() + "\""), nil
21089 }
21090}
21091
21092type OxmIdTunMetadata22Masked struct {
21093 *OxmId
21094}
21095
21096type IOxmIdTunMetadata22Masked interface {
21097 IOxmId
21098}
21099
21100func (self *OxmIdTunMetadata22Masked) Serialize(encoder *goloxi.Encoder) error {
21101 if err := self.OxmId.Serialize(encoder); err != nil {
21102 return err
21103 }
21104
21105 return nil
21106}
21107
21108func DecodeOxmIdTunMetadata22Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata22Masked, error) {
21109 _oxmidtunmetadata22masked := &OxmIdTunMetadata22Masked{OxmId: parent}
21110 return _oxmidtunmetadata22masked, nil
21111}
21112
21113func NewOxmIdTunMetadata22Masked() *OxmIdTunMetadata22Masked {
21114 obj := &OxmIdTunMetadata22Masked{
21115 OxmId: NewOxmId(97784),
21116 }
21117 return obj
21118}
21119func (self *OxmIdTunMetadata22Masked) GetOXMName() string {
21120 return "tun_metadata22_masked"
21121}
21122
21123func (self *OxmIdTunMetadata22Masked) MarshalJSON() ([]byte, error) {
21124 if self.TypeLen == 0 {
21125 return []byte("\"\""), nil
21126 } else {
21127 return []byte("\"" + self.GetOXMName() + "\""), nil
21128 }
21129}
21130
21131type OxmIdTunMetadata23 struct {
21132 *OxmId
21133}
21134
21135type IOxmIdTunMetadata23 interface {
21136 IOxmId
21137}
21138
21139func (self *OxmIdTunMetadata23) Serialize(encoder *goloxi.Encoder) error {
21140 if err := self.OxmId.Serialize(encoder); err != nil {
21141 return err
21142 }
21143
21144 return nil
21145}
21146
21147func DecodeOxmIdTunMetadata23(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata23, error) {
21148 _oxmidtunmetadata23 := &OxmIdTunMetadata23{OxmId: parent}
21149 return _oxmidtunmetadata23, nil
21150}
21151
21152func NewOxmIdTunMetadata23() *OxmIdTunMetadata23 {
21153 obj := &OxmIdTunMetadata23{
21154 OxmId: NewOxmId(97916),
21155 }
21156 return obj
21157}
21158func (self *OxmIdTunMetadata23) GetOXMName() string {
21159 return "tun_metadata23"
21160}
21161
21162func (self *OxmIdTunMetadata23) MarshalJSON() ([]byte, error) {
21163 if self.TypeLen == 0 {
21164 return []byte("\"\""), nil
21165 } else {
21166 return []byte("\"" + self.GetOXMName() + "\""), nil
21167 }
21168}
21169
21170type OxmIdTunMetadata23Masked struct {
21171 *OxmId
21172}
21173
21174type IOxmIdTunMetadata23Masked interface {
21175 IOxmId
21176}
21177
21178func (self *OxmIdTunMetadata23Masked) Serialize(encoder *goloxi.Encoder) error {
21179 if err := self.OxmId.Serialize(encoder); err != nil {
21180 return err
21181 }
21182
21183 return nil
21184}
21185
21186func DecodeOxmIdTunMetadata23Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata23Masked, error) {
21187 _oxmidtunmetadata23masked := &OxmIdTunMetadata23Masked{OxmId: parent}
21188 return _oxmidtunmetadata23masked, nil
21189}
21190
21191func NewOxmIdTunMetadata23Masked() *OxmIdTunMetadata23Masked {
21192 obj := &OxmIdTunMetadata23Masked{
21193 OxmId: NewOxmId(98296),
21194 }
21195 return obj
21196}
21197func (self *OxmIdTunMetadata23Masked) GetOXMName() string {
21198 return "tun_metadata23_masked"
21199}
21200
21201func (self *OxmIdTunMetadata23Masked) MarshalJSON() ([]byte, error) {
21202 if self.TypeLen == 0 {
21203 return []byte("\"\""), nil
21204 } else {
21205 return []byte("\"" + self.GetOXMName() + "\""), nil
21206 }
21207}
21208
21209type OxmIdTunMetadata24 struct {
21210 *OxmId
21211}
21212
21213type IOxmIdTunMetadata24 interface {
21214 IOxmId
21215}
21216
21217func (self *OxmIdTunMetadata24) Serialize(encoder *goloxi.Encoder) error {
21218 if err := self.OxmId.Serialize(encoder); err != nil {
21219 return err
21220 }
21221
21222 return nil
21223}
21224
21225func DecodeOxmIdTunMetadata24(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata24, error) {
21226 _oxmidtunmetadata24 := &OxmIdTunMetadata24{OxmId: parent}
21227 return _oxmidtunmetadata24, nil
21228}
21229
21230func NewOxmIdTunMetadata24() *OxmIdTunMetadata24 {
21231 obj := &OxmIdTunMetadata24{
21232 OxmId: NewOxmId(98428),
21233 }
21234 return obj
21235}
21236func (self *OxmIdTunMetadata24) GetOXMName() string {
21237 return "tun_metadata24"
21238}
21239
21240func (self *OxmIdTunMetadata24) MarshalJSON() ([]byte, error) {
21241 if self.TypeLen == 0 {
21242 return []byte("\"\""), nil
21243 } else {
21244 return []byte("\"" + self.GetOXMName() + "\""), nil
21245 }
21246}
21247
21248type OxmIdTunMetadata24Masked struct {
21249 *OxmId
21250}
21251
21252type IOxmIdTunMetadata24Masked interface {
21253 IOxmId
21254}
21255
21256func (self *OxmIdTunMetadata24Masked) Serialize(encoder *goloxi.Encoder) error {
21257 if err := self.OxmId.Serialize(encoder); err != nil {
21258 return err
21259 }
21260
21261 return nil
21262}
21263
21264func DecodeOxmIdTunMetadata24Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata24Masked, error) {
21265 _oxmidtunmetadata24masked := &OxmIdTunMetadata24Masked{OxmId: parent}
21266 return _oxmidtunmetadata24masked, nil
21267}
21268
21269func NewOxmIdTunMetadata24Masked() *OxmIdTunMetadata24Masked {
21270 obj := &OxmIdTunMetadata24Masked{
21271 OxmId: NewOxmId(98808),
21272 }
21273 return obj
21274}
21275func (self *OxmIdTunMetadata24Masked) GetOXMName() string {
21276 return "tun_metadata24_masked"
21277}
21278
21279func (self *OxmIdTunMetadata24Masked) MarshalJSON() ([]byte, error) {
21280 if self.TypeLen == 0 {
21281 return []byte("\"\""), nil
21282 } else {
21283 return []byte("\"" + self.GetOXMName() + "\""), nil
21284 }
21285}
21286
21287type OxmIdTunMetadata25 struct {
21288 *OxmId
21289}
21290
21291type IOxmIdTunMetadata25 interface {
21292 IOxmId
21293}
21294
21295func (self *OxmIdTunMetadata25) Serialize(encoder *goloxi.Encoder) error {
21296 if err := self.OxmId.Serialize(encoder); err != nil {
21297 return err
21298 }
21299
21300 return nil
21301}
21302
21303func DecodeOxmIdTunMetadata25(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata25, error) {
21304 _oxmidtunmetadata25 := &OxmIdTunMetadata25{OxmId: parent}
21305 return _oxmidtunmetadata25, nil
21306}
21307
21308func NewOxmIdTunMetadata25() *OxmIdTunMetadata25 {
21309 obj := &OxmIdTunMetadata25{
21310 OxmId: NewOxmId(98940),
21311 }
21312 return obj
21313}
21314func (self *OxmIdTunMetadata25) GetOXMName() string {
21315 return "tun_metadata25"
21316}
21317
21318func (self *OxmIdTunMetadata25) MarshalJSON() ([]byte, error) {
21319 if self.TypeLen == 0 {
21320 return []byte("\"\""), nil
21321 } else {
21322 return []byte("\"" + self.GetOXMName() + "\""), nil
21323 }
21324}
21325
21326type OxmIdTunMetadata25Masked struct {
21327 *OxmId
21328}
21329
21330type IOxmIdTunMetadata25Masked interface {
21331 IOxmId
21332}
21333
21334func (self *OxmIdTunMetadata25Masked) Serialize(encoder *goloxi.Encoder) error {
21335 if err := self.OxmId.Serialize(encoder); err != nil {
21336 return err
21337 }
21338
21339 return nil
21340}
21341
21342func DecodeOxmIdTunMetadata25Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata25Masked, error) {
21343 _oxmidtunmetadata25masked := &OxmIdTunMetadata25Masked{OxmId: parent}
21344 return _oxmidtunmetadata25masked, nil
21345}
21346
21347func NewOxmIdTunMetadata25Masked() *OxmIdTunMetadata25Masked {
21348 obj := &OxmIdTunMetadata25Masked{
21349 OxmId: NewOxmId(99320),
21350 }
21351 return obj
21352}
21353func (self *OxmIdTunMetadata25Masked) GetOXMName() string {
21354 return "tun_metadata25_masked"
21355}
21356
21357func (self *OxmIdTunMetadata25Masked) MarshalJSON() ([]byte, error) {
21358 if self.TypeLen == 0 {
21359 return []byte("\"\""), nil
21360 } else {
21361 return []byte("\"" + self.GetOXMName() + "\""), nil
21362 }
21363}
21364
21365type OxmIdTunMetadata26 struct {
21366 *OxmId
21367}
21368
21369type IOxmIdTunMetadata26 interface {
21370 IOxmId
21371}
21372
21373func (self *OxmIdTunMetadata26) Serialize(encoder *goloxi.Encoder) error {
21374 if err := self.OxmId.Serialize(encoder); err != nil {
21375 return err
21376 }
21377
21378 return nil
21379}
21380
21381func DecodeOxmIdTunMetadata26(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata26, error) {
21382 _oxmidtunmetadata26 := &OxmIdTunMetadata26{OxmId: parent}
21383 return _oxmidtunmetadata26, nil
21384}
21385
21386func NewOxmIdTunMetadata26() *OxmIdTunMetadata26 {
21387 obj := &OxmIdTunMetadata26{
21388 OxmId: NewOxmId(99452),
21389 }
21390 return obj
21391}
21392func (self *OxmIdTunMetadata26) GetOXMName() string {
21393 return "tun_metadata26"
21394}
21395
21396func (self *OxmIdTunMetadata26) MarshalJSON() ([]byte, error) {
21397 if self.TypeLen == 0 {
21398 return []byte("\"\""), nil
21399 } else {
21400 return []byte("\"" + self.GetOXMName() + "\""), nil
21401 }
21402}
21403
21404type OxmIdTunMetadata26Masked struct {
21405 *OxmId
21406}
21407
21408type IOxmIdTunMetadata26Masked interface {
21409 IOxmId
21410}
21411
21412func (self *OxmIdTunMetadata26Masked) Serialize(encoder *goloxi.Encoder) error {
21413 if err := self.OxmId.Serialize(encoder); err != nil {
21414 return err
21415 }
21416
21417 return nil
21418}
21419
21420func DecodeOxmIdTunMetadata26Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata26Masked, error) {
21421 _oxmidtunmetadata26masked := &OxmIdTunMetadata26Masked{OxmId: parent}
21422 return _oxmidtunmetadata26masked, nil
21423}
21424
21425func NewOxmIdTunMetadata26Masked() *OxmIdTunMetadata26Masked {
21426 obj := &OxmIdTunMetadata26Masked{
21427 OxmId: NewOxmId(99832),
21428 }
21429 return obj
21430}
21431func (self *OxmIdTunMetadata26Masked) GetOXMName() string {
21432 return "tun_metadata26_masked"
21433}
21434
21435func (self *OxmIdTunMetadata26Masked) MarshalJSON() ([]byte, error) {
21436 if self.TypeLen == 0 {
21437 return []byte("\"\""), nil
21438 } else {
21439 return []byte("\"" + self.GetOXMName() + "\""), nil
21440 }
21441}
21442
21443type OxmIdTunMetadata27 struct {
21444 *OxmId
21445}
21446
21447type IOxmIdTunMetadata27 interface {
21448 IOxmId
21449}
21450
21451func (self *OxmIdTunMetadata27) Serialize(encoder *goloxi.Encoder) error {
21452 if err := self.OxmId.Serialize(encoder); err != nil {
21453 return err
21454 }
21455
21456 return nil
21457}
21458
21459func DecodeOxmIdTunMetadata27(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata27, error) {
21460 _oxmidtunmetadata27 := &OxmIdTunMetadata27{OxmId: parent}
21461 return _oxmidtunmetadata27, nil
21462}
21463
21464func NewOxmIdTunMetadata27() *OxmIdTunMetadata27 {
21465 obj := &OxmIdTunMetadata27{
21466 OxmId: NewOxmId(99964),
21467 }
21468 return obj
21469}
21470func (self *OxmIdTunMetadata27) GetOXMName() string {
21471 return "tun_metadata27"
21472}
21473
21474func (self *OxmIdTunMetadata27) MarshalJSON() ([]byte, error) {
21475 if self.TypeLen == 0 {
21476 return []byte("\"\""), nil
21477 } else {
21478 return []byte("\"" + self.GetOXMName() + "\""), nil
21479 }
21480}
21481
21482type OxmIdTunMetadata27Masked struct {
21483 *OxmId
21484}
21485
21486type IOxmIdTunMetadata27Masked interface {
21487 IOxmId
21488}
21489
21490func (self *OxmIdTunMetadata27Masked) Serialize(encoder *goloxi.Encoder) error {
21491 if err := self.OxmId.Serialize(encoder); err != nil {
21492 return err
21493 }
21494
21495 return nil
21496}
21497
21498func DecodeOxmIdTunMetadata27Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata27Masked, error) {
21499 _oxmidtunmetadata27masked := &OxmIdTunMetadata27Masked{OxmId: parent}
21500 return _oxmidtunmetadata27masked, nil
21501}
21502
21503func NewOxmIdTunMetadata27Masked() *OxmIdTunMetadata27Masked {
21504 obj := &OxmIdTunMetadata27Masked{
21505 OxmId: NewOxmId(100344),
21506 }
21507 return obj
21508}
21509func (self *OxmIdTunMetadata27Masked) GetOXMName() string {
21510 return "tun_metadata27_masked"
21511}
21512
21513func (self *OxmIdTunMetadata27Masked) MarshalJSON() ([]byte, error) {
21514 if self.TypeLen == 0 {
21515 return []byte("\"\""), nil
21516 } else {
21517 return []byte("\"" + self.GetOXMName() + "\""), nil
21518 }
21519}
21520
21521type OxmIdTunMetadata28 struct {
21522 *OxmId
21523}
21524
21525type IOxmIdTunMetadata28 interface {
21526 IOxmId
21527}
21528
21529func (self *OxmIdTunMetadata28) Serialize(encoder *goloxi.Encoder) error {
21530 if err := self.OxmId.Serialize(encoder); err != nil {
21531 return err
21532 }
21533
21534 return nil
21535}
21536
21537func DecodeOxmIdTunMetadata28(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata28, error) {
21538 _oxmidtunmetadata28 := &OxmIdTunMetadata28{OxmId: parent}
21539 return _oxmidtunmetadata28, nil
21540}
21541
21542func NewOxmIdTunMetadata28() *OxmIdTunMetadata28 {
21543 obj := &OxmIdTunMetadata28{
21544 OxmId: NewOxmId(100476),
21545 }
21546 return obj
21547}
21548func (self *OxmIdTunMetadata28) GetOXMName() string {
21549 return "tun_metadata28"
21550}
21551
21552func (self *OxmIdTunMetadata28) MarshalJSON() ([]byte, error) {
21553 if self.TypeLen == 0 {
21554 return []byte("\"\""), nil
21555 } else {
21556 return []byte("\"" + self.GetOXMName() + "\""), nil
21557 }
21558}
21559
21560type OxmIdTunMetadata28Masked struct {
21561 *OxmId
21562}
21563
21564type IOxmIdTunMetadata28Masked interface {
21565 IOxmId
21566}
21567
21568func (self *OxmIdTunMetadata28Masked) Serialize(encoder *goloxi.Encoder) error {
21569 if err := self.OxmId.Serialize(encoder); err != nil {
21570 return err
21571 }
21572
21573 return nil
21574}
21575
21576func DecodeOxmIdTunMetadata28Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata28Masked, error) {
21577 _oxmidtunmetadata28masked := &OxmIdTunMetadata28Masked{OxmId: parent}
21578 return _oxmidtunmetadata28masked, nil
21579}
21580
21581func NewOxmIdTunMetadata28Masked() *OxmIdTunMetadata28Masked {
21582 obj := &OxmIdTunMetadata28Masked{
21583 OxmId: NewOxmId(100856),
21584 }
21585 return obj
21586}
21587func (self *OxmIdTunMetadata28Masked) GetOXMName() string {
21588 return "tun_metadata28_masked"
21589}
21590
21591func (self *OxmIdTunMetadata28Masked) MarshalJSON() ([]byte, error) {
21592 if self.TypeLen == 0 {
21593 return []byte("\"\""), nil
21594 } else {
21595 return []byte("\"" + self.GetOXMName() + "\""), nil
21596 }
21597}
21598
21599type OxmIdTunMetadata29 struct {
21600 *OxmId
21601}
21602
21603type IOxmIdTunMetadata29 interface {
21604 IOxmId
21605}
21606
21607func (self *OxmIdTunMetadata29) Serialize(encoder *goloxi.Encoder) error {
21608 if err := self.OxmId.Serialize(encoder); err != nil {
21609 return err
21610 }
21611
21612 return nil
21613}
21614
21615func DecodeOxmIdTunMetadata29(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata29, error) {
21616 _oxmidtunmetadata29 := &OxmIdTunMetadata29{OxmId: parent}
21617 return _oxmidtunmetadata29, nil
21618}
21619
21620func NewOxmIdTunMetadata29() *OxmIdTunMetadata29 {
21621 obj := &OxmIdTunMetadata29{
21622 OxmId: NewOxmId(100988),
21623 }
21624 return obj
21625}
21626func (self *OxmIdTunMetadata29) GetOXMName() string {
21627 return "tun_metadata29"
21628}
21629
21630func (self *OxmIdTunMetadata29) MarshalJSON() ([]byte, error) {
21631 if self.TypeLen == 0 {
21632 return []byte("\"\""), nil
21633 } else {
21634 return []byte("\"" + self.GetOXMName() + "\""), nil
21635 }
21636}
21637
21638type OxmIdTunMetadata29Masked struct {
21639 *OxmId
21640}
21641
21642type IOxmIdTunMetadata29Masked interface {
21643 IOxmId
21644}
21645
21646func (self *OxmIdTunMetadata29Masked) Serialize(encoder *goloxi.Encoder) error {
21647 if err := self.OxmId.Serialize(encoder); err != nil {
21648 return err
21649 }
21650
21651 return nil
21652}
21653
21654func DecodeOxmIdTunMetadata29Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata29Masked, error) {
21655 _oxmidtunmetadata29masked := &OxmIdTunMetadata29Masked{OxmId: parent}
21656 return _oxmidtunmetadata29masked, nil
21657}
21658
21659func NewOxmIdTunMetadata29Masked() *OxmIdTunMetadata29Masked {
21660 obj := &OxmIdTunMetadata29Masked{
21661 OxmId: NewOxmId(101368),
21662 }
21663 return obj
21664}
21665func (self *OxmIdTunMetadata29Masked) GetOXMName() string {
21666 return "tun_metadata29_masked"
21667}
21668
21669func (self *OxmIdTunMetadata29Masked) MarshalJSON() ([]byte, error) {
21670 if self.TypeLen == 0 {
21671 return []byte("\"\""), nil
21672 } else {
21673 return []byte("\"" + self.GetOXMName() + "\""), nil
21674 }
21675}
21676
21677type OxmIdTunMetadata2Masked struct {
21678 *OxmId
21679}
21680
21681type IOxmIdTunMetadata2Masked interface {
21682 IOxmId
21683}
21684
21685func (self *OxmIdTunMetadata2Masked) Serialize(encoder *goloxi.Encoder) error {
21686 if err := self.OxmId.Serialize(encoder); err != nil {
21687 return err
21688 }
21689
21690 return nil
21691}
21692
21693func DecodeOxmIdTunMetadata2Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata2Masked, error) {
21694 _oxmidtunmetadata2masked := &OxmIdTunMetadata2Masked{OxmId: parent}
21695 return _oxmidtunmetadata2masked, nil
21696}
21697
21698func NewOxmIdTunMetadata2Masked() *OxmIdTunMetadata2Masked {
21699 obj := &OxmIdTunMetadata2Masked{
21700 OxmId: NewOxmId(87544),
21701 }
21702 return obj
21703}
21704func (self *OxmIdTunMetadata2Masked) GetOXMName() string {
21705 return "tun_metadata2_masked"
21706}
21707
21708func (self *OxmIdTunMetadata2Masked) MarshalJSON() ([]byte, error) {
21709 if self.TypeLen == 0 {
21710 return []byte("\"\""), nil
21711 } else {
21712 return []byte("\"" + self.GetOXMName() + "\""), nil
21713 }
21714}
21715
21716type OxmIdTunMetadata3 struct {
21717 *OxmId
21718}
21719
21720type IOxmIdTunMetadata3 interface {
21721 IOxmId
21722}
21723
21724func (self *OxmIdTunMetadata3) Serialize(encoder *goloxi.Encoder) error {
21725 if err := self.OxmId.Serialize(encoder); err != nil {
21726 return err
21727 }
21728
21729 return nil
21730}
21731
21732func DecodeOxmIdTunMetadata3(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata3, error) {
21733 _oxmidtunmetadata3 := &OxmIdTunMetadata3{OxmId: parent}
21734 return _oxmidtunmetadata3, nil
21735}
21736
21737func NewOxmIdTunMetadata3() *OxmIdTunMetadata3 {
21738 obj := &OxmIdTunMetadata3{
21739 OxmId: NewOxmId(87676),
21740 }
21741 return obj
21742}
21743func (self *OxmIdTunMetadata3) GetOXMName() string {
21744 return "tun_metadata3"
21745}
21746
21747func (self *OxmIdTunMetadata3) MarshalJSON() ([]byte, error) {
21748 if self.TypeLen == 0 {
21749 return []byte("\"\""), nil
21750 } else {
21751 return []byte("\"" + self.GetOXMName() + "\""), nil
21752 }
21753}
21754
21755type OxmIdTunMetadata30 struct {
21756 *OxmId
21757}
21758
21759type IOxmIdTunMetadata30 interface {
21760 IOxmId
21761}
21762
21763func (self *OxmIdTunMetadata30) Serialize(encoder *goloxi.Encoder) error {
21764 if err := self.OxmId.Serialize(encoder); err != nil {
21765 return err
21766 }
21767
21768 return nil
21769}
21770
21771func DecodeOxmIdTunMetadata30(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata30, error) {
21772 _oxmidtunmetadata30 := &OxmIdTunMetadata30{OxmId: parent}
21773 return _oxmidtunmetadata30, nil
21774}
21775
21776func NewOxmIdTunMetadata30() *OxmIdTunMetadata30 {
21777 obj := &OxmIdTunMetadata30{
21778 OxmId: NewOxmId(101500),
21779 }
21780 return obj
21781}
21782func (self *OxmIdTunMetadata30) GetOXMName() string {
21783 return "tun_metadata30"
21784}
21785
21786func (self *OxmIdTunMetadata30) MarshalJSON() ([]byte, error) {
21787 if self.TypeLen == 0 {
21788 return []byte("\"\""), nil
21789 } else {
21790 return []byte("\"" + self.GetOXMName() + "\""), nil
21791 }
21792}
21793
21794type OxmIdTunMetadata30Masked struct {
21795 *OxmId
21796}
21797
21798type IOxmIdTunMetadata30Masked interface {
21799 IOxmId
21800}
21801
21802func (self *OxmIdTunMetadata30Masked) Serialize(encoder *goloxi.Encoder) error {
21803 if err := self.OxmId.Serialize(encoder); err != nil {
21804 return err
21805 }
21806
21807 return nil
21808}
21809
21810func DecodeOxmIdTunMetadata30Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata30Masked, error) {
21811 _oxmidtunmetadata30masked := &OxmIdTunMetadata30Masked{OxmId: parent}
21812 return _oxmidtunmetadata30masked, nil
21813}
21814
21815func NewOxmIdTunMetadata30Masked() *OxmIdTunMetadata30Masked {
21816 obj := &OxmIdTunMetadata30Masked{
21817 OxmId: NewOxmId(101880),
21818 }
21819 return obj
21820}
21821func (self *OxmIdTunMetadata30Masked) GetOXMName() string {
21822 return "tun_metadata30_masked"
21823}
21824
21825func (self *OxmIdTunMetadata30Masked) MarshalJSON() ([]byte, error) {
21826 if self.TypeLen == 0 {
21827 return []byte("\"\""), nil
21828 } else {
21829 return []byte("\"" + self.GetOXMName() + "\""), nil
21830 }
21831}
21832
21833type OxmIdTunMetadata31 struct {
21834 *OxmId
21835}
21836
21837type IOxmIdTunMetadata31 interface {
21838 IOxmId
21839}
21840
21841func (self *OxmIdTunMetadata31) Serialize(encoder *goloxi.Encoder) error {
21842 if err := self.OxmId.Serialize(encoder); err != nil {
21843 return err
21844 }
21845
21846 return nil
21847}
21848
21849func DecodeOxmIdTunMetadata31(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata31, error) {
21850 _oxmidtunmetadata31 := &OxmIdTunMetadata31{OxmId: parent}
21851 return _oxmidtunmetadata31, nil
21852}
21853
21854func NewOxmIdTunMetadata31() *OxmIdTunMetadata31 {
21855 obj := &OxmIdTunMetadata31{
21856 OxmId: NewOxmId(102012),
21857 }
21858 return obj
21859}
21860func (self *OxmIdTunMetadata31) GetOXMName() string {
21861 return "tun_metadata31"
21862}
21863
21864func (self *OxmIdTunMetadata31) MarshalJSON() ([]byte, error) {
21865 if self.TypeLen == 0 {
21866 return []byte("\"\""), nil
21867 } else {
21868 return []byte("\"" + self.GetOXMName() + "\""), nil
21869 }
21870}
21871
21872type OxmIdTunMetadata31Masked struct {
21873 *OxmId
21874}
21875
21876type IOxmIdTunMetadata31Masked interface {
21877 IOxmId
21878}
21879
21880func (self *OxmIdTunMetadata31Masked) Serialize(encoder *goloxi.Encoder) error {
21881 if err := self.OxmId.Serialize(encoder); err != nil {
21882 return err
21883 }
21884
21885 return nil
21886}
21887
21888func DecodeOxmIdTunMetadata31Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata31Masked, error) {
21889 _oxmidtunmetadata31masked := &OxmIdTunMetadata31Masked{OxmId: parent}
21890 return _oxmidtunmetadata31masked, nil
21891}
21892
21893func NewOxmIdTunMetadata31Masked() *OxmIdTunMetadata31Masked {
21894 obj := &OxmIdTunMetadata31Masked{
21895 OxmId: NewOxmId(102392),
21896 }
21897 return obj
21898}
21899func (self *OxmIdTunMetadata31Masked) GetOXMName() string {
21900 return "tun_metadata31_masked"
21901}
21902
21903func (self *OxmIdTunMetadata31Masked) MarshalJSON() ([]byte, error) {
21904 if self.TypeLen == 0 {
21905 return []byte("\"\""), nil
21906 } else {
21907 return []byte("\"" + self.GetOXMName() + "\""), nil
21908 }
21909}
21910
21911type OxmIdTunMetadata32 struct {
21912 *OxmId
21913}
21914
21915type IOxmIdTunMetadata32 interface {
21916 IOxmId
21917}
21918
21919func (self *OxmIdTunMetadata32) Serialize(encoder *goloxi.Encoder) error {
21920 if err := self.OxmId.Serialize(encoder); err != nil {
21921 return err
21922 }
21923
21924 return nil
21925}
21926
21927func DecodeOxmIdTunMetadata32(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata32, error) {
21928 _oxmidtunmetadata32 := &OxmIdTunMetadata32{OxmId: parent}
21929 return _oxmidtunmetadata32, nil
21930}
21931
21932func NewOxmIdTunMetadata32() *OxmIdTunMetadata32 {
21933 obj := &OxmIdTunMetadata32{
21934 OxmId: NewOxmId(102524),
21935 }
21936 return obj
21937}
21938func (self *OxmIdTunMetadata32) GetOXMName() string {
21939 return "tun_metadata32"
21940}
21941
21942func (self *OxmIdTunMetadata32) MarshalJSON() ([]byte, error) {
21943 if self.TypeLen == 0 {
21944 return []byte("\"\""), nil
21945 } else {
21946 return []byte("\"" + self.GetOXMName() + "\""), nil
21947 }
21948}
21949
21950type OxmIdTunMetadata32Masked struct {
21951 *OxmId
21952}
21953
21954type IOxmIdTunMetadata32Masked interface {
21955 IOxmId
21956}
21957
21958func (self *OxmIdTunMetadata32Masked) Serialize(encoder *goloxi.Encoder) error {
21959 if err := self.OxmId.Serialize(encoder); err != nil {
21960 return err
21961 }
21962
21963 return nil
21964}
21965
21966func DecodeOxmIdTunMetadata32Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata32Masked, error) {
21967 _oxmidtunmetadata32masked := &OxmIdTunMetadata32Masked{OxmId: parent}
21968 return _oxmidtunmetadata32masked, nil
21969}
21970
21971func NewOxmIdTunMetadata32Masked() *OxmIdTunMetadata32Masked {
21972 obj := &OxmIdTunMetadata32Masked{
21973 OxmId: NewOxmId(102904),
21974 }
21975 return obj
21976}
21977func (self *OxmIdTunMetadata32Masked) GetOXMName() string {
21978 return "tun_metadata32_masked"
21979}
21980
21981func (self *OxmIdTunMetadata32Masked) MarshalJSON() ([]byte, error) {
21982 if self.TypeLen == 0 {
21983 return []byte("\"\""), nil
21984 } else {
21985 return []byte("\"" + self.GetOXMName() + "\""), nil
21986 }
21987}
21988
21989type OxmIdTunMetadata33 struct {
21990 *OxmId
21991}
21992
21993type IOxmIdTunMetadata33 interface {
21994 IOxmId
21995}
21996
21997func (self *OxmIdTunMetadata33) Serialize(encoder *goloxi.Encoder) error {
21998 if err := self.OxmId.Serialize(encoder); err != nil {
21999 return err
22000 }
22001
22002 return nil
22003}
22004
22005func DecodeOxmIdTunMetadata33(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata33, error) {
22006 _oxmidtunmetadata33 := &OxmIdTunMetadata33{OxmId: parent}
22007 return _oxmidtunmetadata33, nil
22008}
22009
22010func NewOxmIdTunMetadata33() *OxmIdTunMetadata33 {
22011 obj := &OxmIdTunMetadata33{
22012 OxmId: NewOxmId(103036),
22013 }
22014 return obj
22015}
22016func (self *OxmIdTunMetadata33) GetOXMName() string {
22017 return "tun_metadata33"
22018}
22019
22020func (self *OxmIdTunMetadata33) MarshalJSON() ([]byte, error) {
22021 if self.TypeLen == 0 {
22022 return []byte("\"\""), nil
22023 } else {
22024 return []byte("\"" + self.GetOXMName() + "\""), nil
22025 }
22026}
22027
22028type OxmIdTunMetadata33Masked struct {
22029 *OxmId
22030}
22031
22032type IOxmIdTunMetadata33Masked interface {
22033 IOxmId
22034}
22035
22036func (self *OxmIdTunMetadata33Masked) Serialize(encoder *goloxi.Encoder) error {
22037 if err := self.OxmId.Serialize(encoder); err != nil {
22038 return err
22039 }
22040
22041 return nil
22042}
22043
22044func DecodeOxmIdTunMetadata33Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata33Masked, error) {
22045 _oxmidtunmetadata33masked := &OxmIdTunMetadata33Masked{OxmId: parent}
22046 return _oxmidtunmetadata33masked, nil
22047}
22048
22049func NewOxmIdTunMetadata33Masked() *OxmIdTunMetadata33Masked {
22050 obj := &OxmIdTunMetadata33Masked{
22051 OxmId: NewOxmId(103416),
22052 }
22053 return obj
22054}
22055func (self *OxmIdTunMetadata33Masked) GetOXMName() string {
22056 return "tun_metadata33_masked"
22057}
22058
22059func (self *OxmIdTunMetadata33Masked) MarshalJSON() ([]byte, error) {
22060 if self.TypeLen == 0 {
22061 return []byte("\"\""), nil
22062 } else {
22063 return []byte("\"" + self.GetOXMName() + "\""), nil
22064 }
22065}
22066
22067type OxmIdTunMetadata34 struct {
22068 *OxmId
22069}
22070
22071type IOxmIdTunMetadata34 interface {
22072 IOxmId
22073}
22074
22075func (self *OxmIdTunMetadata34) Serialize(encoder *goloxi.Encoder) error {
22076 if err := self.OxmId.Serialize(encoder); err != nil {
22077 return err
22078 }
22079
22080 return nil
22081}
22082
22083func DecodeOxmIdTunMetadata34(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata34, error) {
22084 _oxmidtunmetadata34 := &OxmIdTunMetadata34{OxmId: parent}
22085 return _oxmidtunmetadata34, nil
22086}
22087
22088func NewOxmIdTunMetadata34() *OxmIdTunMetadata34 {
22089 obj := &OxmIdTunMetadata34{
22090 OxmId: NewOxmId(103548),
22091 }
22092 return obj
22093}
22094func (self *OxmIdTunMetadata34) GetOXMName() string {
22095 return "tun_metadata34"
22096}
22097
22098func (self *OxmIdTunMetadata34) MarshalJSON() ([]byte, error) {
22099 if self.TypeLen == 0 {
22100 return []byte("\"\""), nil
22101 } else {
22102 return []byte("\"" + self.GetOXMName() + "\""), nil
22103 }
22104}
22105
22106type OxmIdTunMetadata34Masked struct {
22107 *OxmId
22108}
22109
22110type IOxmIdTunMetadata34Masked interface {
22111 IOxmId
22112}
22113
22114func (self *OxmIdTunMetadata34Masked) Serialize(encoder *goloxi.Encoder) error {
22115 if err := self.OxmId.Serialize(encoder); err != nil {
22116 return err
22117 }
22118
22119 return nil
22120}
22121
22122func DecodeOxmIdTunMetadata34Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata34Masked, error) {
22123 _oxmidtunmetadata34masked := &OxmIdTunMetadata34Masked{OxmId: parent}
22124 return _oxmidtunmetadata34masked, nil
22125}
22126
22127func NewOxmIdTunMetadata34Masked() *OxmIdTunMetadata34Masked {
22128 obj := &OxmIdTunMetadata34Masked{
22129 OxmId: NewOxmId(103928),
22130 }
22131 return obj
22132}
22133func (self *OxmIdTunMetadata34Masked) GetOXMName() string {
22134 return "tun_metadata34_masked"
22135}
22136
22137func (self *OxmIdTunMetadata34Masked) MarshalJSON() ([]byte, error) {
22138 if self.TypeLen == 0 {
22139 return []byte("\"\""), nil
22140 } else {
22141 return []byte("\"" + self.GetOXMName() + "\""), nil
22142 }
22143}
22144
22145type OxmIdTunMetadata35 struct {
22146 *OxmId
22147}
22148
22149type IOxmIdTunMetadata35 interface {
22150 IOxmId
22151}
22152
22153func (self *OxmIdTunMetadata35) Serialize(encoder *goloxi.Encoder) error {
22154 if err := self.OxmId.Serialize(encoder); err != nil {
22155 return err
22156 }
22157
22158 return nil
22159}
22160
22161func DecodeOxmIdTunMetadata35(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata35, error) {
22162 _oxmidtunmetadata35 := &OxmIdTunMetadata35{OxmId: parent}
22163 return _oxmidtunmetadata35, nil
22164}
22165
22166func NewOxmIdTunMetadata35() *OxmIdTunMetadata35 {
22167 obj := &OxmIdTunMetadata35{
22168 OxmId: NewOxmId(104060),
22169 }
22170 return obj
22171}
22172func (self *OxmIdTunMetadata35) GetOXMName() string {
22173 return "tun_metadata35"
22174}
22175
22176func (self *OxmIdTunMetadata35) MarshalJSON() ([]byte, error) {
22177 if self.TypeLen == 0 {
22178 return []byte("\"\""), nil
22179 } else {
22180 return []byte("\"" + self.GetOXMName() + "\""), nil
22181 }
22182}
22183
22184type OxmIdTunMetadata35Masked struct {
22185 *OxmId
22186}
22187
22188type IOxmIdTunMetadata35Masked interface {
22189 IOxmId
22190}
22191
22192func (self *OxmIdTunMetadata35Masked) Serialize(encoder *goloxi.Encoder) error {
22193 if err := self.OxmId.Serialize(encoder); err != nil {
22194 return err
22195 }
22196
22197 return nil
22198}
22199
22200func DecodeOxmIdTunMetadata35Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata35Masked, error) {
22201 _oxmidtunmetadata35masked := &OxmIdTunMetadata35Masked{OxmId: parent}
22202 return _oxmidtunmetadata35masked, nil
22203}
22204
22205func NewOxmIdTunMetadata35Masked() *OxmIdTunMetadata35Masked {
22206 obj := &OxmIdTunMetadata35Masked{
22207 OxmId: NewOxmId(104440),
22208 }
22209 return obj
22210}
22211func (self *OxmIdTunMetadata35Masked) GetOXMName() string {
22212 return "tun_metadata35_masked"
22213}
22214
22215func (self *OxmIdTunMetadata35Masked) MarshalJSON() ([]byte, error) {
22216 if self.TypeLen == 0 {
22217 return []byte("\"\""), nil
22218 } else {
22219 return []byte("\"" + self.GetOXMName() + "\""), nil
22220 }
22221}
22222
22223type OxmIdTunMetadata36 struct {
22224 *OxmId
22225}
22226
22227type IOxmIdTunMetadata36 interface {
22228 IOxmId
22229}
22230
22231func (self *OxmIdTunMetadata36) Serialize(encoder *goloxi.Encoder) error {
22232 if err := self.OxmId.Serialize(encoder); err != nil {
22233 return err
22234 }
22235
22236 return nil
22237}
22238
22239func DecodeOxmIdTunMetadata36(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata36, error) {
22240 _oxmidtunmetadata36 := &OxmIdTunMetadata36{OxmId: parent}
22241 return _oxmidtunmetadata36, nil
22242}
22243
22244func NewOxmIdTunMetadata36() *OxmIdTunMetadata36 {
22245 obj := &OxmIdTunMetadata36{
22246 OxmId: NewOxmId(104572),
22247 }
22248 return obj
22249}
22250func (self *OxmIdTunMetadata36) GetOXMName() string {
22251 return "tun_metadata36"
22252}
22253
22254func (self *OxmIdTunMetadata36) MarshalJSON() ([]byte, error) {
22255 if self.TypeLen == 0 {
22256 return []byte("\"\""), nil
22257 } else {
22258 return []byte("\"" + self.GetOXMName() + "\""), nil
22259 }
22260}
22261
22262type OxmIdTunMetadata36Masked struct {
22263 *OxmId
22264}
22265
22266type IOxmIdTunMetadata36Masked interface {
22267 IOxmId
22268}
22269
22270func (self *OxmIdTunMetadata36Masked) Serialize(encoder *goloxi.Encoder) error {
22271 if err := self.OxmId.Serialize(encoder); err != nil {
22272 return err
22273 }
22274
22275 return nil
22276}
22277
22278func DecodeOxmIdTunMetadata36Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata36Masked, error) {
22279 _oxmidtunmetadata36masked := &OxmIdTunMetadata36Masked{OxmId: parent}
22280 return _oxmidtunmetadata36masked, nil
22281}
22282
22283func NewOxmIdTunMetadata36Masked() *OxmIdTunMetadata36Masked {
22284 obj := &OxmIdTunMetadata36Masked{
22285 OxmId: NewOxmId(104952),
22286 }
22287 return obj
22288}
22289func (self *OxmIdTunMetadata36Masked) GetOXMName() string {
22290 return "tun_metadata36_masked"
22291}
22292
22293func (self *OxmIdTunMetadata36Masked) MarshalJSON() ([]byte, error) {
22294 if self.TypeLen == 0 {
22295 return []byte("\"\""), nil
22296 } else {
22297 return []byte("\"" + self.GetOXMName() + "\""), nil
22298 }
22299}
22300
22301type OxmIdTunMetadata37 struct {
22302 *OxmId
22303}
22304
22305type IOxmIdTunMetadata37 interface {
22306 IOxmId
22307}
22308
22309func (self *OxmIdTunMetadata37) Serialize(encoder *goloxi.Encoder) error {
22310 if err := self.OxmId.Serialize(encoder); err != nil {
22311 return err
22312 }
22313
22314 return nil
22315}
22316
22317func DecodeOxmIdTunMetadata37(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata37, error) {
22318 _oxmidtunmetadata37 := &OxmIdTunMetadata37{OxmId: parent}
22319 return _oxmidtunmetadata37, nil
22320}
22321
22322func NewOxmIdTunMetadata37() *OxmIdTunMetadata37 {
22323 obj := &OxmIdTunMetadata37{
22324 OxmId: NewOxmId(105084),
22325 }
22326 return obj
22327}
22328func (self *OxmIdTunMetadata37) GetOXMName() string {
22329 return "tun_metadata37"
22330}
22331
22332func (self *OxmIdTunMetadata37) MarshalJSON() ([]byte, error) {
22333 if self.TypeLen == 0 {
22334 return []byte("\"\""), nil
22335 } else {
22336 return []byte("\"" + self.GetOXMName() + "\""), nil
22337 }
22338}
22339
22340type OxmIdTunMetadata37Masked struct {
22341 *OxmId
22342}
22343
22344type IOxmIdTunMetadata37Masked interface {
22345 IOxmId
22346}
22347
22348func (self *OxmIdTunMetadata37Masked) Serialize(encoder *goloxi.Encoder) error {
22349 if err := self.OxmId.Serialize(encoder); err != nil {
22350 return err
22351 }
22352
22353 return nil
22354}
22355
22356func DecodeOxmIdTunMetadata37Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata37Masked, error) {
22357 _oxmidtunmetadata37masked := &OxmIdTunMetadata37Masked{OxmId: parent}
22358 return _oxmidtunmetadata37masked, nil
22359}
22360
22361func NewOxmIdTunMetadata37Masked() *OxmIdTunMetadata37Masked {
22362 obj := &OxmIdTunMetadata37Masked{
22363 OxmId: NewOxmId(105464),
22364 }
22365 return obj
22366}
22367func (self *OxmIdTunMetadata37Masked) GetOXMName() string {
22368 return "tun_metadata37_masked"
22369}
22370
22371func (self *OxmIdTunMetadata37Masked) MarshalJSON() ([]byte, error) {
22372 if self.TypeLen == 0 {
22373 return []byte("\"\""), nil
22374 } else {
22375 return []byte("\"" + self.GetOXMName() + "\""), nil
22376 }
22377}
22378
22379type OxmIdTunMetadata38 struct {
22380 *OxmId
22381}
22382
22383type IOxmIdTunMetadata38 interface {
22384 IOxmId
22385}
22386
22387func (self *OxmIdTunMetadata38) Serialize(encoder *goloxi.Encoder) error {
22388 if err := self.OxmId.Serialize(encoder); err != nil {
22389 return err
22390 }
22391
22392 return nil
22393}
22394
22395func DecodeOxmIdTunMetadata38(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata38, error) {
22396 _oxmidtunmetadata38 := &OxmIdTunMetadata38{OxmId: parent}
22397 return _oxmidtunmetadata38, nil
22398}
22399
22400func NewOxmIdTunMetadata38() *OxmIdTunMetadata38 {
22401 obj := &OxmIdTunMetadata38{
22402 OxmId: NewOxmId(105596),
22403 }
22404 return obj
22405}
22406func (self *OxmIdTunMetadata38) GetOXMName() string {
22407 return "tun_metadata38"
22408}
22409
22410func (self *OxmIdTunMetadata38) MarshalJSON() ([]byte, error) {
22411 if self.TypeLen == 0 {
22412 return []byte("\"\""), nil
22413 } else {
22414 return []byte("\"" + self.GetOXMName() + "\""), nil
22415 }
22416}
22417
22418type OxmIdTunMetadata38Masked struct {
22419 *OxmId
22420}
22421
22422type IOxmIdTunMetadata38Masked interface {
22423 IOxmId
22424}
22425
22426func (self *OxmIdTunMetadata38Masked) Serialize(encoder *goloxi.Encoder) error {
22427 if err := self.OxmId.Serialize(encoder); err != nil {
22428 return err
22429 }
22430
22431 return nil
22432}
22433
22434func DecodeOxmIdTunMetadata38Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata38Masked, error) {
22435 _oxmidtunmetadata38masked := &OxmIdTunMetadata38Masked{OxmId: parent}
22436 return _oxmidtunmetadata38masked, nil
22437}
22438
22439func NewOxmIdTunMetadata38Masked() *OxmIdTunMetadata38Masked {
22440 obj := &OxmIdTunMetadata38Masked{
22441 OxmId: NewOxmId(105976),
22442 }
22443 return obj
22444}
22445func (self *OxmIdTunMetadata38Masked) GetOXMName() string {
22446 return "tun_metadata38_masked"
22447}
22448
22449func (self *OxmIdTunMetadata38Masked) MarshalJSON() ([]byte, error) {
22450 if self.TypeLen == 0 {
22451 return []byte("\"\""), nil
22452 } else {
22453 return []byte("\"" + self.GetOXMName() + "\""), nil
22454 }
22455}
22456
22457type OxmIdTunMetadata39 struct {
22458 *OxmId
22459}
22460
22461type IOxmIdTunMetadata39 interface {
22462 IOxmId
22463}
22464
22465func (self *OxmIdTunMetadata39) Serialize(encoder *goloxi.Encoder) error {
22466 if err := self.OxmId.Serialize(encoder); err != nil {
22467 return err
22468 }
22469
22470 return nil
22471}
22472
22473func DecodeOxmIdTunMetadata39(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata39, error) {
22474 _oxmidtunmetadata39 := &OxmIdTunMetadata39{OxmId: parent}
22475 return _oxmidtunmetadata39, nil
22476}
22477
22478func NewOxmIdTunMetadata39() *OxmIdTunMetadata39 {
22479 obj := &OxmIdTunMetadata39{
22480 OxmId: NewOxmId(106108),
22481 }
22482 return obj
22483}
22484func (self *OxmIdTunMetadata39) GetOXMName() string {
22485 return "tun_metadata39"
22486}
22487
22488func (self *OxmIdTunMetadata39) MarshalJSON() ([]byte, error) {
22489 if self.TypeLen == 0 {
22490 return []byte("\"\""), nil
22491 } else {
22492 return []byte("\"" + self.GetOXMName() + "\""), nil
22493 }
22494}
22495
22496type OxmIdTunMetadata39Masked struct {
22497 *OxmId
22498}
22499
22500type IOxmIdTunMetadata39Masked interface {
22501 IOxmId
22502}
22503
22504func (self *OxmIdTunMetadata39Masked) Serialize(encoder *goloxi.Encoder) error {
22505 if err := self.OxmId.Serialize(encoder); err != nil {
22506 return err
22507 }
22508
22509 return nil
22510}
22511
22512func DecodeOxmIdTunMetadata39Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata39Masked, error) {
22513 _oxmidtunmetadata39masked := &OxmIdTunMetadata39Masked{OxmId: parent}
22514 return _oxmidtunmetadata39masked, nil
22515}
22516
22517func NewOxmIdTunMetadata39Masked() *OxmIdTunMetadata39Masked {
22518 obj := &OxmIdTunMetadata39Masked{
22519 OxmId: NewOxmId(106488),
22520 }
22521 return obj
22522}
22523func (self *OxmIdTunMetadata39Masked) GetOXMName() string {
22524 return "tun_metadata39_masked"
22525}
22526
22527func (self *OxmIdTunMetadata39Masked) MarshalJSON() ([]byte, error) {
22528 if self.TypeLen == 0 {
22529 return []byte("\"\""), nil
22530 } else {
22531 return []byte("\"" + self.GetOXMName() + "\""), nil
22532 }
22533}
22534
22535type OxmIdTunMetadata3Masked struct {
22536 *OxmId
22537}
22538
22539type IOxmIdTunMetadata3Masked interface {
22540 IOxmId
22541}
22542
22543func (self *OxmIdTunMetadata3Masked) Serialize(encoder *goloxi.Encoder) error {
22544 if err := self.OxmId.Serialize(encoder); err != nil {
22545 return err
22546 }
22547
22548 return nil
22549}
22550
22551func DecodeOxmIdTunMetadata3Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata3Masked, error) {
22552 _oxmidtunmetadata3masked := &OxmIdTunMetadata3Masked{OxmId: parent}
22553 return _oxmidtunmetadata3masked, nil
22554}
22555
22556func NewOxmIdTunMetadata3Masked() *OxmIdTunMetadata3Masked {
22557 obj := &OxmIdTunMetadata3Masked{
22558 OxmId: NewOxmId(88056),
22559 }
22560 return obj
22561}
22562func (self *OxmIdTunMetadata3Masked) GetOXMName() string {
22563 return "tun_metadata3_masked"
22564}
22565
22566func (self *OxmIdTunMetadata3Masked) MarshalJSON() ([]byte, error) {
22567 if self.TypeLen == 0 {
22568 return []byte("\"\""), nil
22569 } else {
22570 return []byte("\"" + self.GetOXMName() + "\""), nil
22571 }
22572}
22573
22574type OxmIdTunMetadata4 struct {
22575 *OxmId
22576}
22577
22578type IOxmIdTunMetadata4 interface {
22579 IOxmId
22580}
22581
22582func (self *OxmIdTunMetadata4) Serialize(encoder *goloxi.Encoder) error {
22583 if err := self.OxmId.Serialize(encoder); err != nil {
22584 return err
22585 }
22586
22587 return nil
22588}
22589
22590func DecodeOxmIdTunMetadata4(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata4, error) {
22591 _oxmidtunmetadata4 := &OxmIdTunMetadata4{OxmId: parent}
22592 return _oxmidtunmetadata4, nil
22593}
22594
22595func NewOxmIdTunMetadata4() *OxmIdTunMetadata4 {
22596 obj := &OxmIdTunMetadata4{
22597 OxmId: NewOxmId(88188),
22598 }
22599 return obj
22600}
22601func (self *OxmIdTunMetadata4) GetOXMName() string {
22602 return "tun_metadata4"
22603}
22604
22605func (self *OxmIdTunMetadata4) MarshalJSON() ([]byte, error) {
22606 if self.TypeLen == 0 {
22607 return []byte("\"\""), nil
22608 } else {
22609 return []byte("\"" + self.GetOXMName() + "\""), nil
22610 }
22611}
22612
22613type OxmIdTunMetadata40 struct {
22614 *OxmId
22615}
22616
22617type IOxmIdTunMetadata40 interface {
22618 IOxmId
22619}
22620
22621func (self *OxmIdTunMetadata40) Serialize(encoder *goloxi.Encoder) error {
22622 if err := self.OxmId.Serialize(encoder); err != nil {
22623 return err
22624 }
22625
22626 return nil
22627}
22628
22629func DecodeOxmIdTunMetadata40(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata40, error) {
22630 _oxmidtunmetadata40 := &OxmIdTunMetadata40{OxmId: parent}
22631 return _oxmidtunmetadata40, nil
22632}
22633
22634func NewOxmIdTunMetadata40() *OxmIdTunMetadata40 {
22635 obj := &OxmIdTunMetadata40{
22636 OxmId: NewOxmId(106620),
22637 }
22638 return obj
22639}
22640func (self *OxmIdTunMetadata40) GetOXMName() string {
22641 return "tun_metadata40"
22642}
22643
22644func (self *OxmIdTunMetadata40) MarshalJSON() ([]byte, error) {
22645 if self.TypeLen == 0 {
22646 return []byte("\"\""), nil
22647 } else {
22648 return []byte("\"" + self.GetOXMName() + "\""), nil
22649 }
22650}
22651
22652type OxmIdTunMetadata40Masked struct {
22653 *OxmId
22654}
22655
22656type IOxmIdTunMetadata40Masked interface {
22657 IOxmId
22658}
22659
22660func (self *OxmIdTunMetadata40Masked) Serialize(encoder *goloxi.Encoder) error {
22661 if err := self.OxmId.Serialize(encoder); err != nil {
22662 return err
22663 }
22664
22665 return nil
22666}
22667
22668func DecodeOxmIdTunMetadata40Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata40Masked, error) {
22669 _oxmidtunmetadata40masked := &OxmIdTunMetadata40Masked{OxmId: parent}
22670 return _oxmidtunmetadata40masked, nil
22671}
22672
22673func NewOxmIdTunMetadata40Masked() *OxmIdTunMetadata40Masked {
22674 obj := &OxmIdTunMetadata40Masked{
22675 OxmId: NewOxmId(107000),
22676 }
22677 return obj
22678}
22679func (self *OxmIdTunMetadata40Masked) GetOXMName() string {
22680 return "tun_metadata40_masked"
22681}
22682
22683func (self *OxmIdTunMetadata40Masked) MarshalJSON() ([]byte, error) {
22684 if self.TypeLen == 0 {
22685 return []byte("\"\""), nil
22686 } else {
22687 return []byte("\"" + self.GetOXMName() + "\""), nil
22688 }
22689}
22690
22691type OxmIdTunMetadata41 struct {
22692 *OxmId
22693}
22694
22695type IOxmIdTunMetadata41 interface {
22696 IOxmId
22697}
22698
22699func (self *OxmIdTunMetadata41) Serialize(encoder *goloxi.Encoder) error {
22700 if err := self.OxmId.Serialize(encoder); err != nil {
22701 return err
22702 }
22703
22704 return nil
22705}
22706
22707func DecodeOxmIdTunMetadata41(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata41, error) {
22708 _oxmidtunmetadata41 := &OxmIdTunMetadata41{OxmId: parent}
22709 return _oxmidtunmetadata41, nil
22710}
22711
22712func NewOxmIdTunMetadata41() *OxmIdTunMetadata41 {
22713 obj := &OxmIdTunMetadata41{
22714 OxmId: NewOxmId(107132),
22715 }
22716 return obj
22717}
22718func (self *OxmIdTunMetadata41) GetOXMName() string {
22719 return "tun_metadata41"
22720}
22721
22722func (self *OxmIdTunMetadata41) MarshalJSON() ([]byte, error) {
22723 if self.TypeLen == 0 {
22724 return []byte("\"\""), nil
22725 } else {
22726 return []byte("\"" + self.GetOXMName() + "\""), nil
22727 }
22728}
22729
22730type OxmIdTunMetadata41Masked struct {
22731 *OxmId
22732}
22733
22734type IOxmIdTunMetadata41Masked interface {
22735 IOxmId
22736}
22737
22738func (self *OxmIdTunMetadata41Masked) Serialize(encoder *goloxi.Encoder) error {
22739 if err := self.OxmId.Serialize(encoder); err != nil {
22740 return err
22741 }
22742
22743 return nil
22744}
22745
22746func DecodeOxmIdTunMetadata41Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata41Masked, error) {
22747 _oxmidtunmetadata41masked := &OxmIdTunMetadata41Masked{OxmId: parent}
22748 return _oxmidtunmetadata41masked, nil
22749}
22750
22751func NewOxmIdTunMetadata41Masked() *OxmIdTunMetadata41Masked {
22752 obj := &OxmIdTunMetadata41Masked{
22753 OxmId: NewOxmId(107512),
22754 }
22755 return obj
22756}
22757func (self *OxmIdTunMetadata41Masked) GetOXMName() string {
22758 return "tun_metadata41_masked"
22759}
22760
22761func (self *OxmIdTunMetadata41Masked) MarshalJSON() ([]byte, error) {
22762 if self.TypeLen == 0 {
22763 return []byte("\"\""), nil
22764 } else {
22765 return []byte("\"" + self.GetOXMName() + "\""), nil
22766 }
22767}
22768
22769type OxmIdTunMetadata42 struct {
22770 *OxmId
22771}
22772
22773type IOxmIdTunMetadata42 interface {
22774 IOxmId
22775}
22776
22777func (self *OxmIdTunMetadata42) Serialize(encoder *goloxi.Encoder) error {
22778 if err := self.OxmId.Serialize(encoder); err != nil {
22779 return err
22780 }
22781
22782 return nil
22783}
22784
22785func DecodeOxmIdTunMetadata42(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata42, error) {
22786 _oxmidtunmetadata42 := &OxmIdTunMetadata42{OxmId: parent}
22787 return _oxmidtunmetadata42, nil
22788}
22789
22790func NewOxmIdTunMetadata42() *OxmIdTunMetadata42 {
22791 obj := &OxmIdTunMetadata42{
22792 OxmId: NewOxmId(107644),
22793 }
22794 return obj
22795}
22796func (self *OxmIdTunMetadata42) GetOXMName() string {
22797 return "tun_metadata42"
22798}
22799
22800func (self *OxmIdTunMetadata42) MarshalJSON() ([]byte, error) {
22801 if self.TypeLen == 0 {
22802 return []byte("\"\""), nil
22803 } else {
22804 return []byte("\"" + self.GetOXMName() + "\""), nil
22805 }
22806}
22807
22808type OxmIdTunMetadata42Masked struct {
22809 *OxmId
22810}
22811
22812type IOxmIdTunMetadata42Masked interface {
22813 IOxmId
22814}
22815
22816func (self *OxmIdTunMetadata42Masked) Serialize(encoder *goloxi.Encoder) error {
22817 if err := self.OxmId.Serialize(encoder); err != nil {
22818 return err
22819 }
22820
22821 return nil
22822}
22823
22824func DecodeOxmIdTunMetadata42Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata42Masked, error) {
22825 _oxmidtunmetadata42masked := &OxmIdTunMetadata42Masked{OxmId: parent}
22826 return _oxmidtunmetadata42masked, nil
22827}
22828
22829func NewOxmIdTunMetadata42Masked() *OxmIdTunMetadata42Masked {
22830 obj := &OxmIdTunMetadata42Masked{
22831 OxmId: NewOxmId(108024),
22832 }
22833 return obj
22834}
22835func (self *OxmIdTunMetadata42Masked) GetOXMName() string {
22836 return "tun_metadata42_masked"
22837}
22838
22839func (self *OxmIdTunMetadata42Masked) MarshalJSON() ([]byte, error) {
22840 if self.TypeLen == 0 {
22841 return []byte("\"\""), nil
22842 } else {
22843 return []byte("\"" + self.GetOXMName() + "\""), nil
22844 }
22845}
22846
22847type OxmIdTunMetadata43 struct {
22848 *OxmId
22849}
22850
22851type IOxmIdTunMetadata43 interface {
22852 IOxmId
22853}
22854
22855func (self *OxmIdTunMetadata43) Serialize(encoder *goloxi.Encoder) error {
22856 if err := self.OxmId.Serialize(encoder); err != nil {
22857 return err
22858 }
22859
22860 return nil
22861}
22862
22863func DecodeOxmIdTunMetadata43(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata43, error) {
22864 _oxmidtunmetadata43 := &OxmIdTunMetadata43{OxmId: parent}
22865 return _oxmidtunmetadata43, nil
22866}
22867
22868func NewOxmIdTunMetadata43() *OxmIdTunMetadata43 {
22869 obj := &OxmIdTunMetadata43{
22870 OxmId: NewOxmId(108156),
22871 }
22872 return obj
22873}
22874func (self *OxmIdTunMetadata43) GetOXMName() string {
22875 return "tun_metadata43"
22876}
22877
22878func (self *OxmIdTunMetadata43) MarshalJSON() ([]byte, error) {
22879 if self.TypeLen == 0 {
22880 return []byte("\"\""), nil
22881 } else {
22882 return []byte("\"" + self.GetOXMName() + "\""), nil
22883 }
22884}
22885
22886type OxmIdTunMetadata43Masked struct {
22887 *OxmId
22888}
22889
22890type IOxmIdTunMetadata43Masked interface {
22891 IOxmId
22892}
22893
22894func (self *OxmIdTunMetadata43Masked) Serialize(encoder *goloxi.Encoder) error {
22895 if err := self.OxmId.Serialize(encoder); err != nil {
22896 return err
22897 }
22898
22899 return nil
22900}
22901
22902func DecodeOxmIdTunMetadata43Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata43Masked, error) {
22903 _oxmidtunmetadata43masked := &OxmIdTunMetadata43Masked{OxmId: parent}
22904 return _oxmidtunmetadata43masked, nil
22905}
22906
22907func NewOxmIdTunMetadata43Masked() *OxmIdTunMetadata43Masked {
22908 obj := &OxmIdTunMetadata43Masked{
22909 OxmId: NewOxmId(108536),
22910 }
22911 return obj
22912}
22913func (self *OxmIdTunMetadata43Masked) GetOXMName() string {
22914 return "tun_metadata43_masked"
22915}
22916
22917func (self *OxmIdTunMetadata43Masked) MarshalJSON() ([]byte, error) {
22918 if self.TypeLen == 0 {
22919 return []byte("\"\""), nil
22920 } else {
22921 return []byte("\"" + self.GetOXMName() + "\""), nil
22922 }
22923}
22924
22925type OxmIdTunMetadata44 struct {
22926 *OxmId
22927}
22928
22929type IOxmIdTunMetadata44 interface {
22930 IOxmId
22931}
22932
22933func (self *OxmIdTunMetadata44) Serialize(encoder *goloxi.Encoder) error {
22934 if err := self.OxmId.Serialize(encoder); err != nil {
22935 return err
22936 }
22937
22938 return nil
22939}
22940
22941func DecodeOxmIdTunMetadata44(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata44, error) {
22942 _oxmidtunmetadata44 := &OxmIdTunMetadata44{OxmId: parent}
22943 return _oxmidtunmetadata44, nil
22944}
22945
22946func NewOxmIdTunMetadata44() *OxmIdTunMetadata44 {
22947 obj := &OxmIdTunMetadata44{
22948 OxmId: NewOxmId(108668),
22949 }
22950 return obj
22951}
22952func (self *OxmIdTunMetadata44) GetOXMName() string {
22953 return "tun_metadata44"
22954}
22955
22956func (self *OxmIdTunMetadata44) MarshalJSON() ([]byte, error) {
22957 if self.TypeLen == 0 {
22958 return []byte("\"\""), nil
22959 } else {
22960 return []byte("\"" + self.GetOXMName() + "\""), nil
22961 }
22962}
22963
22964type OxmIdTunMetadata44Masked struct {
22965 *OxmId
22966}
22967
22968type IOxmIdTunMetadata44Masked interface {
22969 IOxmId
22970}
22971
22972func (self *OxmIdTunMetadata44Masked) Serialize(encoder *goloxi.Encoder) error {
22973 if err := self.OxmId.Serialize(encoder); err != nil {
22974 return err
22975 }
22976
22977 return nil
22978}
22979
22980func DecodeOxmIdTunMetadata44Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata44Masked, error) {
22981 _oxmidtunmetadata44masked := &OxmIdTunMetadata44Masked{OxmId: parent}
22982 return _oxmidtunmetadata44masked, nil
22983}
22984
22985func NewOxmIdTunMetadata44Masked() *OxmIdTunMetadata44Masked {
22986 obj := &OxmIdTunMetadata44Masked{
22987 OxmId: NewOxmId(109048),
22988 }
22989 return obj
22990}
22991func (self *OxmIdTunMetadata44Masked) GetOXMName() string {
22992 return "tun_metadata44_masked"
22993}
22994
22995func (self *OxmIdTunMetadata44Masked) MarshalJSON() ([]byte, error) {
22996 if self.TypeLen == 0 {
22997 return []byte("\"\""), nil
22998 } else {
22999 return []byte("\"" + self.GetOXMName() + "\""), nil
23000 }
23001}
23002
23003type OxmIdTunMetadata45 struct {
23004 *OxmId
23005}
23006
23007type IOxmIdTunMetadata45 interface {
23008 IOxmId
23009}
23010
23011func (self *OxmIdTunMetadata45) Serialize(encoder *goloxi.Encoder) error {
23012 if err := self.OxmId.Serialize(encoder); err != nil {
23013 return err
23014 }
23015
23016 return nil
23017}
23018
23019func DecodeOxmIdTunMetadata45(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata45, error) {
23020 _oxmidtunmetadata45 := &OxmIdTunMetadata45{OxmId: parent}
23021 return _oxmidtunmetadata45, nil
23022}
23023
23024func NewOxmIdTunMetadata45() *OxmIdTunMetadata45 {
23025 obj := &OxmIdTunMetadata45{
23026 OxmId: NewOxmId(109180),
23027 }
23028 return obj
23029}
23030func (self *OxmIdTunMetadata45) GetOXMName() string {
23031 return "tun_metadata45"
23032}
23033
23034func (self *OxmIdTunMetadata45) MarshalJSON() ([]byte, error) {
23035 if self.TypeLen == 0 {
23036 return []byte("\"\""), nil
23037 } else {
23038 return []byte("\"" + self.GetOXMName() + "\""), nil
23039 }
23040}
23041
23042type OxmIdTunMetadata45Masked struct {
23043 *OxmId
23044}
23045
23046type IOxmIdTunMetadata45Masked interface {
23047 IOxmId
23048}
23049
23050func (self *OxmIdTunMetadata45Masked) Serialize(encoder *goloxi.Encoder) error {
23051 if err := self.OxmId.Serialize(encoder); err != nil {
23052 return err
23053 }
23054
23055 return nil
23056}
23057
23058func DecodeOxmIdTunMetadata45Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata45Masked, error) {
23059 _oxmidtunmetadata45masked := &OxmIdTunMetadata45Masked{OxmId: parent}
23060 return _oxmidtunmetadata45masked, nil
23061}
23062
23063func NewOxmIdTunMetadata45Masked() *OxmIdTunMetadata45Masked {
23064 obj := &OxmIdTunMetadata45Masked{
23065 OxmId: NewOxmId(109560),
23066 }
23067 return obj
23068}
23069func (self *OxmIdTunMetadata45Masked) GetOXMName() string {
23070 return "tun_metadata45_masked"
23071}
23072
23073func (self *OxmIdTunMetadata45Masked) MarshalJSON() ([]byte, error) {
23074 if self.TypeLen == 0 {
23075 return []byte("\"\""), nil
23076 } else {
23077 return []byte("\"" + self.GetOXMName() + "\""), nil
23078 }
23079}
23080
23081type OxmIdTunMetadata46 struct {
23082 *OxmId
23083}
23084
23085type IOxmIdTunMetadata46 interface {
23086 IOxmId
23087}
23088
23089func (self *OxmIdTunMetadata46) Serialize(encoder *goloxi.Encoder) error {
23090 if err := self.OxmId.Serialize(encoder); err != nil {
23091 return err
23092 }
23093
23094 return nil
23095}
23096
23097func DecodeOxmIdTunMetadata46(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata46, error) {
23098 _oxmidtunmetadata46 := &OxmIdTunMetadata46{OxmId: parent}
23099 return _oxmidtunmetadata46, nil
23100}
23101
23102func NewOxmIdTunMetadata46() *OxmIdTunMetadata46 {
23103 obj := &OxmIdTunMetadata46{
23104 OxmId: NewOxmId(109692),
23105 }
23106 return obj
23107}
23108func (self *OxmIdTunMetadata46) GetOXMName() string {
23109 return "tun_metadata46"
23110}
23111
23112func (self *OxmIdTunMetadata46) MarshalJSON() ([]byte, error) {
23113 if self.TypeLen == 0 {
23114 return []byte("\"\""), nil
23115 } else {
23116 return []byte("\"" + self.GetOXMName() + "\""), nil
23117 }
23118}
23119
23120type OxmIdTunMetadata46Masked struct {
23121 *OxmId
23122}
23123
23124type IOxmIdTunMetadata46Masked interface {
23125 IOxmId
23126}
23127
23128func (self *OxmIdTunMetadata46Masked) Serialize(encoder *goloxi.Encoder) error {
23129 if err := self.OxmId.Serialize(encoder); err != nil {
23130 return err
23131 }
23132
23133 return nil
23134}
23135
23136func DecodeOxmIdTunMetadata46Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata46Masked, error) {
23137 _oxmidtunmetadata46masked := &OxmIdTunMetadata46Masked{OxmId: parent}
23138 return _oxmidtunmetadata46masked, nil
23139}
23140
23141func NewOxmIdTunMetadata46Masked() *OxmIdTunMetadata46Masked {
23142 obj := &OxmIdTunMetadata46Masked{
23143 OxmId: NewOxmId(110072),
23144 }
23145 return obj
23146}
23147func (self *OxmIdTunMetadata46Masked) GetOXMName() string {
23148 return "tun_metadata46_masked"
23149}
23150
23151func (self *OxmIdTunMetadata46Masked) MarshalJSON() ([]byte, error) {
23152 if self.TypeLen == 0 {
23153 return []byte("\"\""), nil
23154 } else {
23155 return []byte("\"" + self.GetOXMName() + "\""), nil
23156 }
23157}
23158
23159type OxmIdTunMetadata47 struct {
23160 *OxmId
23161}
23162
23163type IOxmIdTunMetadata47 interface {
23164 IOxmId
23165}
23166
23167func (self *OxmIdTunMetadata47) Serialize(encoder *goloxi.Encoder) error {
23168 if err := self.OxmId.Serialize(encoder); err != nil {
23169 return err
23170 }
23171
23172 return nil
23173}
23174
23175func DecodeOxmIdTunMetadata47(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata47, error) {
23176 _oxmidtunmetadata47 := &OxmIdTunMetadata47{OxmId: parent}
23177 return _oxmidtunmetadata47, nil
23178}
23179
23180func NewOxmIdTunMetadata47() *OxmIdTunMetadata47 {
23181 obj := &OxmIdTunMetadata47{
23182 OxmId: NewOxmId(110204),
23183 }
23184 return obj
23185}
23186func (self *OxmIdTunMetadata47) GetOXMName() string {
23187 return "tun_metadata47"
23188}
23189
23190func (self *OxmIdTunMetadata47) MarshalJSON() ([]byte, error) {
23191 if self.TypeLen == 0 {
23192 return []byte("\"\""), nil
23193 } else {
23194 return []byte("\"" + self.GetOXMName() + "\""), nil
23195 }
23196}
23197
23198type OxmIdTunMetadata47Masked struct {
23199 *OxmId
23200}
23201
23202type IOxmIdTunMetadata47Masked interface {
23203 IOxmId
23204}
23205
23206func (self *OxmIdTunMetadata47Masked) Serialize(encoder *goloxi.Encoder) error {
23207 if err := self.OxmId.Serialize(encoder); err != nil {
23208 return err
23209 }
23210
23211 return nil
23212}
23213
23214func DecodeOxmIdTunMetadata47Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata47Masked, error) {
23215 _oxmidtunmetadata47masked := &OxmIdTunMetadata47Masked{OxmId: parent}
23216 return _oxmidtunmetadata47masked, nil
23217}
23218
23219func NewOxmIdTunMetadata47Masked() *OxmIdTunMetadata47Masked {
23220 obj := &OxmIdTunMetadata47Masked{
23221 OxmId: NewOxmId(110584),
23222 }
23223 return obj
23224}
23225func (self *OxmIdTunMetadata47Masked) GetOXMName() string {
23226 return "tun_metadata47_masked"
23227}
23228
23229func (self *OxmIdTunMetadata47Masked) MarshalJSON() ([]byte, error) {
23230 if self.TypeLen == 0 {
23231 return []byte("\"\""), nil
23232 } else {
23233 return []byte("\"" + self.GetOXMName() + "\""), nil
23234 }
23235}
23236
23237type OxmIdTunMetadata48 struct {
23238 *OxmId
23239}
23240
23241type IOxmIdTunMetadata48 interface {
23242 IOxmId
23243}
23244
23245func (self *OxmIdTunMetadata48) Serialize(encoder *goloxi.Encoder) error {
23246 if err := self.OxmId.Serialize(encoder); err != nil {
23247 return err
23248 }
23249
23250 return nil
23251}
23252
23253func DecodeOxmIdTunMetadata48(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata48, error) {
23254 _oxmidtunmetadata48 := &OxmIdTunMetadata48{OxmId: parent}
23255 return _oxmidtunmetadata48, nil
23256}
23257
23258func NewOxmIdTunMetadata48() *OxmIdTunMetadata48 {
23259 obj := &OxmIdTunMetadata48{
23260 OxmId: NewOxmId(110716),
23261 }
23262 return obj
23263}
23264func (self *OxmIdTunMetadata48) GetOXMName() string {
23265 return "tun_metadata48"
23266}
23267
23268func (self *OxmIdTunMetadata48) MarshalJSON() ([]byte, error) {
23269 if self.TypeLen == 0 {
23270 return []byte("\"\""), nil
23271 } else {
23272 return []byte("\"" + self.GetOXMName() + "\""), nil
23273 }
23274}
23275
23276type OxmIdTunMetadata48Masked struct {
23277 *OxmId
23278}
23279
23280type IOxmIdTunMetadata48Masked interface {
23281 IOxmId
23282}
23283
23284func (self *OxmIdTunMetadata48Masked) Serialize(encoder *goloxi.Encoder) error {
23285 if err := self.OxmId.Serialize(encoder); err != nil {
23286 return err
23287 }
23288
23289 return nil
23290}
23291
23292func DecodeOxmIdTunMetadata48Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata48Masked, error) {
23293 _oxmidtunmetadata48masked := &OxmIdTunMetadata48Masked{OxmId: parent}
23294 return _oxmidtunmetadata48masked, nil
23295}
23296
23297func NewOxmIdTunMetadata48Masked() *OxmIdTunMetadata48Masked {
23298 obj := &OxmIdTunMetadata48Masked{
23299 OxmId: NewOxmId(111096),
23300 }
23301 return obj
23302}
23303func (self *OxmIdTunMetadata48Masked) GetOXMName() string {
23304 return "tun_metadata48_masked"
23305}
23306
23307func (self *OxmIdTunMetadata48Masked) MarshalJSON() ([]byte, error) {
23308 if self.TypeLen == 0 {
23309 return []byte("\"\""), nil
23310 } else {
23311 return []byte("\"" + self.GetOXMName() + "\""), nil
23312 }
23313}
23314
23315type OxmIdTunMetadata49 struct {
23316 *OxmId
23317}
23318
23319type IOxmIdTunMetadata49 interface {
23320 IOxmId
23321}
23322
23323func (self *OxmIdTunMetadata49) Serialize(encoder *goloxi.Encoder) error {
23324 if err := self.OxmId.Serialize(encoder); err != nil {
23325 return err
23326 }
23327
23328 return nil
23329}
23330
23331func DecodeOxmIdTunMetadata49(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata49, error) {
23332 _oxmidtunmetadata49 := &OxmIdTunMetadata49{OxmId: parent}
23333 return _oxmidtunmetadata49, nil
23334}
23335
23336func NewOxmIdTunMetadata49() *OxmIdTunMetadata49 {
23337 obj := &OxmIdTunMetadata49{
23338 OxmId: NewOxmId(111228),
23339 }
23340 return obj
23341}
23342func (self *OxmIdTunMetadata49) GetOXMName() string {
23343 return "tun_metadata49"
23344}
23345
23346func (self *OxmIdTunMetadata49) MarshalJSON() ([]byte, error) {
23347 if self.TypeLen == 0 {
23348 return []byte("\"\""), nil
23349 } else {
23350 return []byte("\"" + self.GetOXMName() + "\""), nil
23351 }
23352}
23353
23354type OxmIdTunMetadata49Masked struct {
23355 *OxmId
23356}
23357
23358type IOxmIdTunMetadata49Masked interface {
23359 IOxmId
23360}
23361
23362func (self *OxmIdTunMetadata49Masked) Serialize(encoder *goloxi.Encoder) error {
23363 if err := self.OxmId.Serialize(encoder); err != nil {
23364 return err
23365 }
23366
23367 return nil
23368}
23369
23370func DecodeOxmIdTunMetadata49Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata49Masked, error) {
23371 _oxmidtunmetadata49masked := &OxmIdTunMetadata49Masked{OxmId: parent}
23372 return _oxmidtunmetadata49masked, nil
23373}
23374
23375func NewOxmIdTunMetadata49Masked() *OxmIdTunMetadata49Masked {
23376 obj := &OxmIdTunMetadata49Masked{
23377 OxmId: NewOxmId(111608),
23378 }
23379 return obj
23380}
23381func (self *OxmIdTunMetadata49Masked) GetOXMName() string {
23382 return "tun_metadata49_masked"
23383}
23384
23385func (self *OxmIdTunMetadata49Masked) MarshalJSON() ([]byte, error) {
23386 if self.TypeLen == 0 {
23387 return []byte("\"\""), nil
23388 } else {
23389 return []byte("\"" + self.GetOXMName() + "\""), nil
23390 }
23391}
23392
23393type OxmIdTunMetadata4Masked struct {
23394 *OxmId
23395}
23396
23397type IOxmIdTunMetadata4Masked interface {
23398 IOxmId
23399}
23400
23401func (self *OxmIdTunMetadata4Masked) Serialize(encoder *goloxi.Encoder) error {
23402 if err := self.OxmId.Serialize(encoder); err != nil {
23403 return err
23404 }
23405
23406 return nil
23407}
23408
23409func DecodeOxmIdTunMetadata4Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata4Masked, error) {
23410 _oxmidtunmetadata4masked := &OxmIdTunMetadata4Masked{OxmId: parent}
23411 return _oxmidtunmetadata4masked, nil
23412}
23413
23414func NewOxmIdTunMetadata4Masked() *OxmIdTunMetadata4Masked {
23415 obj := &OxmIdTunMetadata4Masked{
23416 OxmId: NewOxmId(88568),
23417 }
23418 return obj
23419}
23420func (self *OxmIdTunMetadata4Masked) GetOXMName() string {
23421 return "tun_metadata4_masked"
23422}
23423
23424func (self *OxmIdTunMetadata4Masked) MarshalJSON() ([]byte, error) {
23425 if self.TypeLen == 0 {
23426 return []byte("\"\""), nil
23427 } else {
23428 return []byte("\"" + self.GetOXMName() + "\""), nil
23429 }
23430}
23431
23432type OxmIdTunMetadata5 struct {
23433 *OxmId
23434}
23435
23436type IOxmIdTunMetadata5 interface {
23437 IOxmId
23438}
23439
23440func (self *OxmIdTunMetadata5) Serialize(encoder *goloxi.Encoder) error {
23441 if err := self.OxmId.Serialize(encoder); err != nil {
23442 return err
23443 }
23444
23445 return nil
23446}
23447
23448func DecodeOxmIdTunMetadata5(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata5, error) {
23449 _oxmidtunmetadata5 := &OxmIdTunMetadata5{OxmId: parent}
23450 return _oxmidtunmetadata5, nil
23451}
23452
23453func NewOxmIdTunMetadata5() *OxmIdTunMetadata5 {
23454 obj := &OxmIdTunMetadata5{
23455 OxmId: NewOxmId(88700),
23456 }
23457 return obj
23458}
23459func (self *OxmIdTunMetadata5) GetOXMName() string {
23460 return "tun_metadata5"
23461}
23462
23463func (self *OxmIdTunMetadata5) MarshalJSON() ([]byte, error) {
23464 if self.TypeLen == 0 {
23465 return []byte("\"\""), nil
23466 } else {
23467 return []byte("\"" + self.GetOXMName() + "\""), nil
23468 }
23469}
23470
23471type OxmIdTunMetadata50 struct {
23472 *OxmId
23473}
23474
23475type IOxmIdTunMetadata50 interface {
23476 IOxmId
23477}
23478
23479func (self *OxmIdTunMetadata50) Serialize(encoder *goloxi.Encoder) error {
23480 if err := self.OxmId.Serialize(encoder); err != nil {
23481 return err
23482 }
23483
23484 return nil
23485}
23486
23487func DecodeOxmIdTunMetadata50(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata50, error) {
23488 _oxmidtunmetadata50 := &OxmIdTunMetadata50{OxmId: parent}
23489 return _oxmidtunmetadata50, nil
23490}
23491
23492func NewOxmIdTunMetadata50() *OxmIdTunMetadata50 {
23493 obj := &OxmIdTunMetadata50{
23494 OxmId: NewOxmId(111740),
23495 }
23496 return obj
23497}
23498func (self *OxmIdTunMetadata50) GetOXMName() string {
23499 return "tun_metadata50"
23500}
23501
23502func (self *OxmIdTunMetadata50) MarshalJSON() ([]byte, error) {
23503 if self.TypeLen == 0 {
23504 return []byte("\"\""), nil
23505 } else {
23506 return []byte("\"" + self.GetOXMName() + "\""), nil
23507 }
23508}
23509
23510type OxmIdTunMetadata50Masked struct {
23511 *OxmId
23512}
23513
23514type IOxmIdTunMetadata50Masked interface {
23515 IOxmId
23516}
23517
23518func (self *OxmIdTunMetadata50Masked) Serialize(encoder *goloxi.Encoder) error {
23519 if err := self.OxmId.Serialize(encoder); err != nil {
23520 return err
23521 }
23522
23523 return nil
23524}
23525
23526func DecodeOxmIdTunMetadata50Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata50Masked, error) {
23527 _oxmidtunmetadata50masked := &OxmIdTunMetadata50Masked{OxmId: parent}
23528 return _oxmidtunmetadata50masked, nil
23529}
23530
23531func NewOxmIdTunMetadata50Masked() *OxmIdTunMetadata50Masked {
23532 obj := &OxmIdTunMetadata50Masked{
23533 OxmId: NewOxmId(112120),
23534 }
23535 return obj
23536}
23537func (self *OxmIdTunMetadata50Masked) GetOXMName() string {
23538 return "tun_metadata50_masked"
23539}
23540
23541func (self *OxmIdTunMetadata50Masked) MarshalJSON() ([]byte, error) {
23542 if self.TypeLen == 0 {
23543 return []byte("\"\""), nil
23544 } else {
23545 return []byte("\"" + self.GetOXMName() + "\""), nil
23546 }
23547}
23548
23549type OxmIdTunMetadata51 struct {
23550 *OxmId
23551}
23552
23553type IOxmIdTunMetadata51 interface {
23554 IOxmId
23555}
23556
23557func (self *OxmIdTunMetadata51) Serialize(encoder *goloxi.Encoder) error {
23558 if err := self.OxmId.Serialize(encoder); err != nil {
23559 return err
23560 }
23561
23562 return nil
23563}
23564
23565func DecodeOxmIdTunMetadata51(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata51, error) {
23566 _oxmidtunmetadata51 := &OxmIdTunMetadata51{OxmId: parent}
23567 return _oxmidtunmetadata51, nil
23568}
23569
23570func NewOxmIdTunMetadata51() *OxmIdTunMetadata51 {
23571 obj := &OxmIdTunMetadata51{
23572 OxmId: NewOxmId(112252),
23573 }
23574 return obj
23575}
23576func (self *OxmIdTunMetadata51) GetOXMName() string {
23577 return "tun_metadata51"
23578}
23579
23580func (self *OxmIdTunMetadata51) MarshalJSON() ([]byte, error) {
23581 if self.TypeLen == 0 {
23582 return []byte("\"\""), nil
23583 } else {
23584 return []byte("\"" + self.GetOXMName() + "\""), nil
23585 }
23586}
23587
23588type OxmIdTunMetadata51Masked struct {
23589 *OxmId
23590}
23591
23592type IOxmIdTunMetadata51Masked interface {
23593 IOxmId
23594}
23595
23596func (self *OxmIdTunMetadata51Masked) Serialize(encoder *goloxi.Encoder) error {
23597 if err := self.OxmId.Serialize(encoder); err != nil {
23598 return err
23599 }
23600
23601 return nil
23602}
23603
23604func DecodeOxmIdTunMetadata51Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata51Masked, error) {
23605 _oxmidtunmetadata51masked := &OxmIdTunMetadata51Masked{OxmId: parent}
23606 return _oxmidtunmetadata51masked, nil
23607}
23608
23609func NewOxmIdTunMetadata51Masked() *OxmIdTunMetadata51Masked {
23610 obj := &OxmIdTunMetadata51Masked{
23611 OxmId: NewOxmId(112632),
23612 }
23613 return obj
23614}
23615func (self *OxmIdTunMetadata51Masked) GetOXMName() string {
23616 return "tun_metadata51_masked"
23617}
23618
23619func (self *OxmIdTunMetadata51Masked) MarshalJSON() ([]byte, error) {
23620 if self.TypeLen == 0 {
23621 return []byte("\"\""), nil
23622 } else {
23623 return []byte("\"" + self.GetOXMName() + "\""), nil
23624 }
23625}
23626
23627type OxmIdTunMetadata52 struct {
23628 *OxmId
23629}
23630
23631type IOxmIdTunMetadata52 interface {
23632 IOxmId
23633}
23634
23635func (self *OxmIdTunMetadata52) Serialize(encoder *goloxi.Encoder) error {
23636 if err := self.OxmId.Serialize(encoder); err != nil {
23637 return err
23638 }
23639
23640 return nil
23641}
23642
23643func DecodeOxmIdTunMetadata52(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata52, error) {
23644 _oxmidtunmetadata52 := &OxmIdTunMetadata52{OxmId: parent}
23645 return _oxmidtunmetadata52, nil
23646}
23647
23648func NewOxmIdTunMetadata52() *OxmIdTunMetadata52 {
23649 obj := &OxmIdTunMetadata52{
23650 OxmId: NewOxmId(112764),
23651 }
23652 return obj
23653}
23654func (self *OxmIdTunMetadata52) GetOXMName() string {
23655 return "tun_metadata52"
23656}
23657
23658func (self *OxmIdTunMetadata52) MarshalJSON() ([]byte, error) {
23659 if self.TypeLen == 0 {
23660 return []byte("\"\""), nil
23661 } else {
23662 return []byte("\"" + self.GetOXMName() + "\""), nil
23663 }
23664}
23665
23666type OxmIdTunMetadata52Masked struct {
23667 *OxmId
23668}
23669
23670type IOxmIdTunMetadata52Masked interface {
23671 IOxmId
23672}
23673
23674func (self *OxmIdTunMetadata52Masked) Serialize(encoder *goloxi.Encoder) error {
23675 if err := self.OxmId.Serialize(encoder); err != nil {
23676 return err
23677 }
23678
23679 return nil
23680}
23681
23682func DecodeOxmIdTunMetadata52Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata52Masked, error) {
23683 _oxmidtunmetadata52masked := &OxmIdTunMetadata52Masked{OxmId: parent}
23684 return _oxmidtunmetadata52masked, nil
23685}
23686
23687func NewOxmIdTunMetadata52Masked() *OxmIdTunMetadata52Masked {
23688 obj := &OxmIdTunMetadata52Masked{
23689 OxmId: NewOxmId(113144),
23690 }
23691 return obj
23692}
23693func (self *OxmIdTunMetadata52Masked) GetOXMName() string {
23694 return "tun_metadata52_masked"
23695}
23696
23697func (self *OxmIdTunMetadata52Masked) MarshalJSON() ([]byte, error) {
23698 if self.TypeLen == 0 {
23699 return []byte("\"\""), nil
23700 } else {
23701 return []byte("\"" + self.GetOXMName() + "\""), nil
23702 }
23703}
23704
23705type OxmIdTunMetadata53 struct {
23706 *OxmId
23707}
23708
23709type IOxmIdTunMetadata53 interface {
23710 IOxmId
23711}
23712
23713func (self *OxmIdTunMetadata53) Serialize(encoder *goloxi.Encoder) error {
23714 if err := self.OxmId.Serialize(encoder); err != nil {
23715 return err
23716 }
23717
23718 return nil
23719}
23720
23721func DecodeOxmIdTunMetadata53(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata53, error) {
23722 _oxmidtunmetadata53 := &OxmIdTunMetadata53{OxmId: parent}
23723 return _oxmidtunmetadata53, nil
23724}
23725
23726func NewOxmIdTunMetadata53() *OxmIdTunMetadata53 {
23727 obj := &OxmIdTunMetadata53{
23728 OxmId: NewOxmId(113276),
23729 }
23730 return obj
23731}
23732func (self *OxmIdTunMetadata53) GetOXMName() string {
23733 return "tun_metadata53"
23734}
23735
23736func (self *OxmIdTunMetadata53) MarshalJSON() ([]byte, error) {
23737 if self.TypeLen == 0 {
23738 return []byte("\"\""), nil
23739 } else {
23740 return []byte("\"" + self.GetOXMName() + "\""), nil
23741 }
23742}
23743
23744type OxmIdTunMetadata53Masked struct {
23745 *OxmId
23746}
23747
23748type IOxmIdTunMetadata53Masked interface {
23749 IOxmId
23750}
23751
23752func (self *OxmIdTunMetadata53Masked) Serialize(encoder *goloxi.Encoder) error {
23753 if err := self.OxmId.Serialize(encoder); err != nil {
23754 return err
23755 }
23756
23757 return nil
23758}
23759
23760func DecodeOxmIdTunMetadata53Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata53Masked, error) {
23761 _oxmidtunmetadata53masked := &OxmIdTunMetadata53Masked{OxmId: parent}
23762 return _oxmidtunmetadata53masked, nil
23763}
23764
23765func NewOxmIdTunMetadata53Masked() *OxmIdTunMetadata53Masked {
23766 obj := &OxmIdTunMetadata53Masked{
23767 OxmId: NewOxmId(113656),
23768 }
23769 return obj
23770}
23771func (self *OxmIdTunMetadata53Masked) GetOXMName() string {
23772 return "tun_metadata53_masked"
23773}
23774
23775func (self *OxmIdTunMetadata53Masked) MarshalJSON() ([]byte, error) {
23776 if self.TypeLen == 0 {
23777 return []byte("\"\""), nil
23778 } else {
23779 return []byte("\"" + self.GetOXMName() + "\""), nil
23780 }
23781}
23782
23783type OxmIdTunMetadata54 struct {
23784 *OxmId
23785}
23786
23787type IOxmIdTunMetadata54 interface {
23788 IOxmId
23789}
23790
23791func (self *OxmIdTunMetadata54) Serialize(encoder *goloxi.Encoder) error {
23792 if err := self.OxmId.Serialize(encoder); err != nil {
23793 return err
23794 }
23795
23796 return nil
23797}
23798
23799func DecodeOxmIdTunMetadata54(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata54, error) {
23800 _oxmidtunmetadata54 := &OxmIdTunMetadata54{OxmId: parent}
23801 return _oxmidtunmetadata54, nil
23802}
23803
23804func NewOxmIdTunMetadata54() *OxmIdTunMetadata54 {
23805 obj := &OxmIdTunMetadata54{
23806 OxmId: NewOxmId(113788),
23807 }
23808 return obj
23809}
23810func (self *OxmIdTunMetadata54) GetOXMName() string {
23811 return "tun_metadata54"
23812}
23813
23814func (self *OxmIdTunMetadata54) MarshalJSON() ([]byte, error) {
23815 if self.TypeLen == 0 {
23816 return []byte("\"\""), nil
23817 } else {
23818 return []byte("\"" + self.GetOXMName() + "\""), nil
23819 }
23820}
23821
23822type OxmIdTunMetadata54Masked struct {
23823 *OxmId
23824}
23825
23826type IOxmIdTunMetadata54Masked interface {
23827 IOxmId
23828}
23829
23830func (self *OxmIdTunMetadata54Masked) Serialize(encoder *goloxi.Encoder) error {
23831 if err := self.OxmId.Serialize(encoder); err != nil {
23832 return err
23833 }
23834
23835 return nil
23836}
23837
23838func DecodeOxmIdTunMetadata54Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata54Masked, error) {
23839 _oxmidtunmetadata54masked := &OxmIdTunMetadata54Masked{OxmId: parent}
23840 return _oxmidtunmetadata54masked, nil
23841}
23842
23843func NewOxmIdTunMetadata54Masked() *OxmIdTunMetadata54Masked {
23844 obj := &OxmIdTunMetadata54Masked{
23845 OxmId: NewOxmId(114168),
23846 }
23847 return obj
23848}
23849func (self *OxmIdTunMetadata54Masked) GetOXMName() string {
23850 return "tun_metadata54_masked"
23851}
23852
23853func (self *OxmIdTunMetadata54Masked) MarshalJSON() ([]byte, error) {
23854 if self.TypeLen == 0 {
23855 return []byte("\"\""), nil
23856 } else {
23857 return []byte("\"" + self.GetOXMName() + "\""), nil
23858 }
23859}
23860
23861type OxmIdTunMetadata55 struct {
23862 *OxmId
23863}
23864
23865type IOxmIdTunMetadata55 interface {
23866 IOxmId
23867}
23868
23869func (self *OxmIdTunMetadata55) Serialize(encoder *goloxi.Encoder) error {
23870 if err := self.OxmId.Serialize(encoder); err != nil {
23871 return err
23872 }
23873
23874 return nil
23875}
23876
23877func DecodeOxmIdTunMetadata55(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata55, error) {
23878 _oxmidtunmetadata55 := &OxmIdTunMetadata55{OxmId: parent}
23879 return _oxmidtunmetadata55, nil
23880}
23881
23882func NewOxmIdTunMetadata55() *OxmIdTunMetadata55 {
23883 obj := &OxmIdTunMetadata55{
23884 OxmId: NewOxmId(114300),
23885 }
23886 return obj
23887}
23888func (self *OxmIdTunMetadata55) GetOXMName() string {
23889 return "tun_metadata55"
23890}
23891
23892func (self *OxmIdTunMetadata55) MarshalJSON() ([]byte, error) {
23893 if self.TypeLen == 0 {
23894 return []byte("\"\""), nil
23895 } else {
23896 return []byte("\"" + self.GetOXMName() + "\""), nil
23897 }
23898}
23899
23900type OxmIdTunMetadata55Masked struct {
23901 *OxmId
23902}
23903
23904type IOxmIdTunMetadata55Masked interface {
23905 IOxmId
23906}
23907
23908func (self *OxmIdTunMetadata55Masked) Serialize(encoder *goloxi.Encoder) error {
23909 if err := self.OxmId.Serialize(encoder); err != nil {
23910 return err
23911 }
23912
23913 return nil
23914}
23915
23916func DecodeOxmIdTunMetadata55Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata55Masked, error) {
23917 _oxmidtunmetadata55masked := &OxmIdTunMetadata55Masked{OxmId: parent}
23918 return _oxmidtunmetadata55masked, nil
23919}
23920
23921func NewOxmIdTunMetadata55Masked() *OxmIdTunMetadata55Masked {
23922 obj := &OxmIdTunMetadata55Masked{
23923 OxmId: NewOxmId(114680),
23924 }
23925 return obj
23926}
23927func (self *OxmIdTunMetadata55Masked) GetOXMName() string {
23928 return "tun_metadata55_masked"
23929}
23930
23931func (self *OxmIdTunMetadata55Masked) MarshalJSON() ([]byte, error) {
23932 if self.TypeLen == 0 {
23933 return []byte("\"\""), nil
23934 } else {
23935 return []byte("\"" + self.GetOXMName() + "\""), nil
23936 }
23937}
23938
23939type OxmIdTunMetadata56 struct {
23940 *OxmId
23941}
23942
23943type IOxmIdTunMetadata56 interface {
23944 IOxmId
23945}
23946
23947func (self *OxmIdTunMetadata56) Serialize(encoder *goloxi.Encoder) error {
23948 if err := self.OxmId.Serialize(encoder); err != nil {
23949 return err
23950 }
23951
23952 return nil
23953}
23954
23955func DecodeOxmIdTunMetadata56(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata56, error) {
23956 _oxmidtunmetadata56 := &OxmIdTunMetadata56{OxmId: parent}
23957 return _oxmidtunmetadata56, nil
23958}
23959
23960func NewOxmIdTunMetadata56() *OxmIdTunMetadata56 {
23961 obj := &OxmIdTunMetadata56{
23962 OxmId: NewOxmId(114812),
23963 }
23964 return obj
23965}
23966func (self *OxmIdTunMetadata56) GetOXMName() string {
23967 return "tun_metadata56"
23968}
23969
23970func (self *OxmIdTunMetadata56) MarshalJSON() ([]byte, error) {
23971 if self.TypeLen == 0 {
23972 return []byte("\"\""), nil
23973 } else {
23974 return []byte("\"" + self.GetOXMName() + "\""), nil
23975 }
23976}
23977
23978type OxmIdTunMetadata56Masked struct {
23979 *OxmId
23980}
23981
23982type IOxmIdTunMetadata56Masked interface {
23983 IOxmId
23984}
23985
23986func (self *OxmIdTunMetadata56Masked) Serialize(encoder *goloxi.Encoder) error {
23987 if err := self.OxmId.Serialize(encoder); err != nil {
23988 return err
23989 }
23990
23991 return nil
23992}
23993
23994func DecodeOxmIdTunMetadata56Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata56Masked, error) {
23995 _oxmidtunmetadata56masked := &OxmIdTunMetadata56Masked{OxmId: parent}
23996 return _oxmidtunmetadata56masked, nil
23997}
23998
23999func NewOxmIdTunMetadata56Masked() *OxmIdTunMetadata56Masked {
24000 obj := &OxmIdTunMetadata56Masked{
24001 OxmId: NewOxmId(115192),
24002 }
24003 return obj
24004}
24005func (self *OxmIdTunMetadata56Masked) GetOXMName() string {
24006 return "tun_metadata56_masked"
24007}
24008
24009func (self *OxmIdTunMetadata56Masked) MarshalJSON() ([]byte, error) {
24010 if self.TypeLen == 0 {
24011 return []byte("\"\""), nil
24012 } else {
24013 return []byte("\"" + self.GetOXMName() + "\""), nil
24014 }
24015}
24016
24017type OxmIdTunMetadata57 struct {
24018 *OxmId
24019}
24020
24021type IOxmIdTunMetadata57 interface {
24022 IOxmId
24023}
24024
24025func (self *OxmIdTunMetadata57) Serialize(encoder *goloxi.Encoder) error {
24026 if err := self.OxmId.Serialize(encoder); err != nil {
24027 return err
24028 }
24029
24030 return nil
24031}
24032
24033func DecodeOxmIdTunMetadata57(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata57, error) {
24034 _oxmidtunmetadata57 := &OxmIdTunMetadata57{OxmId: parent}
24035 return _oxmidtunmetadata57, nil
24036}
24037
24038func NewOxmIdTunMetadata57() *OxmIdTunMetadata57 {
24039 obj := &OxmIdTunMetadata57{
24040 OxmId: NewOxmId(115324),
24041 }
24042 return obj
24043}
24044func (self *OxmIdTunMetadata57) GetOXMName() string {
24045 return "tun_metadata57"
24046}
24047
24048func (self *OxmIdTunMetadata57) MarshalJSON() ([]byte, error) {
24049 if self.TypeLen == 0 {
24050 return []byte("\"\""), nil
24051 } else {
24052 return []byte("\"" + self.GetOXMName() + "\""), nil
24053 }
24054}
24055
24056type OxmIdTunMetadata57Masked struct {
24057 *OxmId
24058}
24059
24060type IOxmIdTunMetadata57Masked interface {
24061 IOxmId
24062}
24063
24064func (self *OxmIdTunMetadata57Masked) Serialize(encoder *goloxi.Encoder) error {
24065 if err := self.OxmId.Serialize(encoder); err != nil {
24066 return err
24067 }
24068
24069 return nil
24070}
24071
24072func DecodeOxmIdTunMetadata57Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata57Masked, error) {
24073 _oxmidtunmetadata57masked := &OxmIdTunMetadata57Masked{OxmId: parent}
24074 return _oxmidtunmetadata57masked, nil
24075}
24076
24077func NewOxmIdTunMetadata57Masked() *OxmIdTunMetadata57Masked {
24078 obj := &OxmIdTunMetadata57Masked{
24079 OxmId: NewOxmId(115704),
24080 }
24081 return obj
24082}
24083func (self *OxmIdTunMetadata57Masked) GetOXMName() string {
24084 return "tun_metadata57_masked"
24085}
24086
24087func (self *OxmIdTunMetadata57Masked) MarshalJSON() ([]byte, error) {
24088 if self.TypeLen == 0 {
24089 return []byte("\"\""), nil
24090 } else {
24091 return []byte("\"" + self.GetOXMName() + "\""), nil
24092 }
24093}
24094
24095type OxmIdTunMetadata58 struct {
24096 *OxmId
24097}
24098
24099type IOxmIdTunMetadata58 interface {
24100 IOxmId
24101}
24102
24103func (self *OxmIdTunMetadata58) Serialize(encoder *goloxi.Encoder) error {
24104 if err := self.OxmId.Serialize(encoder); err != nil {
24105 return err
24106 }
24107
24108 return nil
24109}
24110
24111func DecodeOxmIdTunMetadata58(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata58, error) {
24112 _oxmidtunmetadata58 := &OxmIdTunMetadata58{OxmId: parent}
24113 return _oxmidtunmetadata58, nil
24114}
24115
24116func NewOxmIdTunMetadata58() *OxmIdTunMetadata58 {
24117 obj := &OxmIdTunMetadata58{
24118 OxmId: NewOxmId(115836),
24119 }
24120 return obj
24121}
24122func (self *OxmIdTunMetadata58) GetOXMName() string {
24123 return "tun_metadata58"
24124}
24125
24126func (self *OxmIdTunMetadata58) MarshalJSON() ([]byte, error) {
24127 if self.TypeLen == 0 {
24128 return []byte("\"\""), nil
24129 } else {
24130 return []byte("\"" + self.GetOXMName() + "\""), nil
24131 }
24132}
24133
24134type OxmIdTunMetadata58Masked struct {
24135 *OxmId
24136}
24137
24138type IOxmIdTunMetadata58Masked interface {
24139 IOxmId
24140}
24141
24142func (self *OxmIdTunMetadata58Masked) Serialize(encoder *goloxi.Encoder) error {
24143 if err := self.OxmId.Serialize(encoder); err != nil {
24144 return err
24145 }
24146
24147 return nil
24148}
24149
24150func DecodeOxmIdTunMetadata58Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata58Masked, error) {
24151 _oxmidtunmetadata58masked := &OxmIdTunMetadata58Masked{OxmId: parent}
24152 return _oxmidtunmetadata58masked, nil
24153}
24154
24155func NewOxmIdTunMetadata58Masked() *OxmIdTunMetadata58Masked {
24156 obj := &OxmIdTunMetadata58Masked{
24157 OxmId: NewOxmId(116216),
24158 }
24159 return obj
24160}
24161func (self *OxmIdTunMetadata58Masked) GetOXMName() string {
24162 return "tun_metadata58_masked"
24163}
24164
24165func (self *OxmIdTunMetadata58Masked) MarshalJSON() ([]byte, error) {
24166 if self.TypeLen == 0 {
24167 return []byte("\"\""), nil
24168 } else {
24169 return []byte("\"" + self.GetOXMName() + "\""), nil
24170 }
24171}
24172
24173type OxmIdTunMetadata59 struct {
24174 *OxmId
24175}
24176
24177type IOxmIdTunMetadata59 interface {
24178 IOxmId
24179}
24180
24181func (self *OxmIdTunMetadata59) Serialize(encoder *goloxi.Encoder) error {
24182 if err := self.OxmId.Serialize(encoder); err != nil {
24183 return err
24184 }
24185
24186 return nil
24187}
24188
24189func DecodeOxmIdTunMetadata59(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata59, error) {
24190 _oxmidtunmetadata59 := &OxmIdTunMetadata59{OxmId: parent}
24191 return _oxmidtunmetadata59, nil
24192}
24193
24194func NewOxmIdTunMetadata59() *OxmIdTunMetadata59 {
24195 obj := &OxmIdTunMetadata59{
24196 OxmId: NewOxmId(116348),
24197 }
24198 return obj
24199}
24200func (self *OxmIdTunMetadata59) GetOXMName() string {
24201 return "tun_metadata59"
24202}
24203
24204func (self *OxmIdTunMetadata59) MarshalJSON() ([]byte, error) {
24205 if self.TypeLen == 0 {
24206 return []byte("\"\""), nil
24207 } else {
24208 return []byte("\"" + self.GetOXMName() + "\""), nil
24209 }
24210}
24211
24212type OxmIdTunMetadata59Masked struct {
24213 *OxmId
24214}
24215
24216type IOxmIdTunMetadata59Masked interface {
24217 IOxmId
24218}
24219
24220func (self *OxmIdTunMetadata59Masked) Serialize(encoder *goloxi.Encoder) error {
24221 if err := self.OxmId.Serialize(encoder); err != nil {
24222 return err
24223 }
24224
24225 return nil
24226}
24227
24228func DecodeOxmIdTunMetadata59Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata59Masked, error) {
24229 _oxmidtunmetadata59masked := &OxmIdTunMetadata59Masked{OxmId: parent}
24230 return _oxmidtunmetadata59masked, nil
24231}
24232
24233func NewOxmIdTunMetadata59Masked() *OxmIdTunMetadata59Masked {
24234 obj := &OxmIdTunMetadata59Masked{
24235 OxmId: NewOxmId(116728),
24236 }
24237 return obj
24238}
24239func (self *OxmIdTunMetadata59Masked) GetOXMName() string {
24240 return "tun_metadata59_masked"
24241}
24242
24243func (self *OxmIdTunMetadata59Masked) MarshalJSON() ([]byte, error) {
24244 if self.TypeLen == 0 {
24245 return []byte("\"\""), nil
24246 } else {
24247 return []byte("\"" + self.GetOXMName() + "\""), nil
24248 }
24249}
24250
24251type OxmIdTunMetadata5Masked struct {
24252 *OxmId
24253}
24254
24255type IOxmIdTunMetadata5Masked interface {
24256 IOxmId
24257}
24258
24259func (self *OxmIdTunMetadata5Masked) Serialize(encoder *goloxi.Encoder) error {
24260 if err := self.OxmId.Serialize(encoder); err != nil {
24261 return err
24262 }
24263
24264 return nil
24265}
24266
24267func DecodeOxmIdTunMetadata5Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata5Masked, error) {
24268 _oxmidtunmetadata5masked := &OxmIdTunMetadata5Masked{OxmId: parent}
24269 return _oxmidtunmetadata5masked, nil
24270}
24271
24272func NewOxmIdTunMetadata5Masked() *OxmIdTunMetadata5Masked {
24273 obj := &OxmIdTunMetadata5Masked{
24274 OxmId: NewOxmId(89080),
24275 }
24276 return obj
24277}
24278func (self *OxmIdTunMetadata5Masked) GetOXMName() string {
24279 return "tun_metadata5_masked"
24280}
24281
24282func (self *OxmIdTunMetadata5Masked) MarshalJSON() ([]byte, error) {
24283 if self.TypeLen == 0 {
24284 return []byte("\"\""), nil
24285 } else {
24286 return []byte("\"" + self.GetOXMName() + "\""), nil
24287 }
24288}
24289
24290type OxmIdTunMetadata6 struct {
24291 *OxmId
24292}
24293
24294type IOxmIdTunMetadata6 interface {
24295 IOxmId
24296}
24297
24298func (self *OxmIdTunMetadata6) Serialize(encoder *goloxi.Encoder) error {
24299 if err := self.OxmId.Serialize(encoder); err != nil {
24300 return err
24301 }
24302
24303 return nil
24304}
24305
24306func DecodeOxmIdTunMetadata6(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata6, error) {
24307 _oxmidtunmetadata6 := &OxmIdTunMetadata6{OxmId: parent}
24308 return _oxmidtunmetadata6, nil
24309}
24310
24311func NewOxmIdTunMetadata6() *OxmIdTunMetadata6 {
24312 obj := &OxmIdTunMetadata6{
24313 OxmId: NewOxmId(89212),
24314 }
24315 return obj
24316}
24317func (self *OxmIdTunMetadata6) GetOXMName() string {
24318 return "tun_metadata6"
24319}
24320
24321func (self *OxmIdTunMetadata6) MarshalJSON() ([]byte, error) {
24322 if self.TypeLen == 0 {
24323 return []byte("\"\""), nil
24324 } else {
24325 return []byte("\"" + self.GetOXMName() + "\""), nil
24326 }
24327}
24328
24329type OxmIdTunMetadata60 struct {
24330 *OxmId
24331}
24332
24333type IOxmIdTunMetadata60 interface {
24334 IOxmId
24335}
24336
24337func (self *OxmIdTunMetadata60) Serialize(encoder *goloxi.Encoder) error {
24338 if err := self.OxmId.Serialize(encoder); err != nil {
24339 return err
24340 }
24341
24342 return nil
24343}
24344
24345func DecodeOxmIdTunMetadata60(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata60, error) {
24346 _oxmidtunmetadata60 := &OxmIdTunMetadata60{OxmId: parent}
24347 return _oxmidtunmetadata60, nil
24348}
24349
24350func NewOxmIdTunMetadata60() *OxmIdTunMetadata60 {
24351 obj := &OxmIdTunMetadata60{
24352 OxmId: NewOxmId(116860),
24353 }
24354 return obj
24355}
24356func (self *OxmIdTunMetadata60) GetOXMName() string {
24357 return "tun_metadata60"
24358}
24359
24360func (self *OxmIdTunMetadata60) MarshalJSON() ([]byte, error) {
24361 if self.TypeLen == 0 {
24362 return []byte("\"\""), nil
24363 } else {
24364 return []byte("\"" + self.GetOXMName() + "\""), nil
24365 }
24366}
24367
24368type OxmIdTunMetadata60Masked struct {
24369 *OxmId
24370}
24371
24372type IOxmIdTunMetadata60Masked interface {
24373 IOxmId
24374}
24375
24376func (self *OxmIdTunMetadata60Masked) Serialize(encoder *goloxi.Encoder) error {
24377 if err := self.OxmId.Serialize(encoder); err != nil {
24378 return err
24379 }
24380
24381 return nil
24382}
24383
24384func DecodeOxmIdTunMetadata60Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata60Masked, error) {
24385 _oxmidtunmetadata60masked := &OxmIdTunMetadata60Masked{OxmId: parent}
24386 return _oxmidtunmetadata60masked, nil
24387}
24388
24389func NewOxmIdTunMetadata60Masked() *OxmIdTunMetadata60Masked {
24390 obj := &OxmIdTunMetadata60Masked{
24391 OxmId: NewOxmId(117240),
24392 }
24393 return obj
24394}
24395func (self *OxmIdTunMetadata60Masked) GetOXMName() string {
24396 return "tun_metadata60_masked"
24397}
24398
24399func (self *OxmIdTunMetadata60Masked) MarshalJSON() ([]byte, error) {
24400 if self.TypeLen == 0 {
24401 return []byte("\"\""), nil
24402 } else {
24403 return []byte("\"" + self.GetOXMName() + "\""), nil
24404 }
24405}
24406
24407type OxmIdTunMetadata61 struct {
24408 *OxmId
24409}
24410
24411type IOxmIdTunMetadata61 interface {
24412 IOxmId
24413}
24414
24415func (self *OxmIdTunMetadata61) Serialize(encoder *goloxi.Encoder) error {
24416 if err := self.OxmId.Serialize(encoder); err != nil {
24417 return err
24418 }
24419
24420 return nil
24421}
24422
24423func DecodeOxmIdTunMetadata61(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata61, error) {
24424 _oxmidtunmetadata61 := &OxmIdTunMetadata61{OxmId: parent}
24425 return _oxmidtunmetadata61, nil
24426}
24427
24428func NewOxmIdTunMetadata61() *OxmIdTunMetadata61 {
24429 obj := &OxmIdTunMetadata61{
24430 OxmId: NewOxmId(117372),
24431 }
24432 return obj
24433}
24434func (self *OxmIdTunMetadata61) GetOXMName() string {
24435 return "tun_metadata61"
24436}
24437
24438func (self *OxmIdTunMetadata61) MarshalJSON() ([]byte, error) {
24439 if self.TypeLen == 0 {
24440 return []byte("\"\""), nil
24441 } else {
24442 return []byte("\"" + self.GetOXMName() + "\""), nil
24443 }
24444}
24445
24446type OxmIdTunMetadata61Masked struct {
24447 *OxmId
24448}
24449
24450type IOxmIdTunMetadata61Masked interface {
24451 IOxmId
24452}
24453
24454func (self *OxmIdTunMetadata61Masked) Serialize(encoder *goloxi.Encoder) error {
24455 if err := self.OxmId.Serialize(encoder); err != nil {
24456 return err
24457 }
24458
24459 return nil
24460}
24461
24462func DecodeOxmIdTunMetadata61Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata61Masked, error) {
24463 _oxmidtunmetadata61masked := &OxmIdTunMetadata61Masked{OxmId: parent}
24464 return _oxmidtunmetadata61masked, nil
24465}
24466
24467func NewOxmIdTunMetadata61Masked() *OxmIdTunMetadata61Masked {
24468 obj := &OxmIdTunMetadata61Masked{
24469 OxmId: NewOxmId(117752),
24470 }
24471 return obj
24472}
24473func (self *OxmIdTunMetadata61Masked) GetOXMName() string {
24474 return "tun_metadata61_masked"
24475}
24476
24477func (self *OxmIdTunMetadata61Masked) MarshalJSON() ([]byte, error) {
24478 if self.TypeLen == 0 {
24479 return []byte("\"\""), nil
24480 } else {
24481 return []byte("\"" + self.GetOXMName() + "\""), nil
24482 }
24483}
24484
24485type OxmIdTunMetadata62 struct {
24486 *OxmId
24487}
24488
24489type IOxmIdTunMetadata62 interface {
24490 IOxmId
24491}
24492
24493func (self *OxmIdTunMetadata62) Serialize(encoder *goloxi.Encoder) error {
24494 if err := self.OxmId.Serialize(encoder); err != nil {
24495 return err
24496 }
24497
24498 return nil
24499}
24500
24501func DecodeOxmIdTunMetadata62(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata62, error) {
24502 _oxmidtunmetadata62 := &OxmIdTunMetadata62{OxmId: parent}
24503 return _oxmidtunmetadata62, nil
24504}
24505
24506func NewOxmIdTunMetadata62() *OxmIdTunMetadata62 {
24507 obj := &OxmIdTunMetadata62{
24508 OxmId: NewOxmId(117884),
24509 }
24510 return obj
24511}
24512func (self *OxmIdTunMetadata62) GetOXMName() string {
24513 return "tun_metadata62"
24514}
24515
24516func (self *OxmIdTunMetadata62) MarshalJSON() ([]byte, error) {
24517 if self.TypeLen == 0 {
24518 return []byte("\"\""), nil
24519 } else {
24520 return []byte("\"" + self.GetOXMName() + "\""), nil
24521 }
24522}
24523
24524type OxmIdTunMetadata62Masked struct {
24525 *OxmId
24526}
24527
24528type IOxmIdTunMetadata62Masked interface {
24529 IOxmId
24530}
24531
24532func (self *OxmIdTunMetadata62Masked) Serialize(encoder *goloxi.Encoder) error {
24533 if err := self.OxmId.Serialize(encoder); err != nil {
24534 return err
24535 }
24536
24537 return nil
24538}
24539
24540func DecodeOxmIdTunMetadata62Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata62Masked, error) {
24541 _oxmidtunmetadata62masked := &OxmIdTunMetadata62Masked{OxmId: parent}
24542 return _oxmidtunmetadata62masked, nil
24543}
24544
24545func NewOxmIdTunMetadata62Masked() *OxmIdTunMetadata62Masked {
24546 obj := &OxmIdTunMetadata62Masked{
24547 OxmId: NewOxmId(118264),
24548 }
24549 return obj
24550}
24551func (self *OxmIdTunMetadata62Masked) GetOXMName() string {
24552 return "tun_metadata62_masked"
24553}
24554
24555func (self *OxmIdTunMetadata62Masked) MarshalJSON() ([]byte, error) {
24556 if self.TypeLen == 0 {
24557 return []byte("\"\""), nil
24558 } else {
24559 return []byte("\"" + self.GetOXMName() + "\""), nil
24560 }
24561}
24562
24563type OxmIdTunMetadata63 struct {
24564 *OxmId
24565}
24566
24567type IOxmIdTunMetadata63 interface {
24568 IOxmId
24569}
24570
24571func (self *OxmIdTunMetadata63) Serialize(encoder *goloxi.Encoder) error {
24572 if err := self.OxmId.Serialize(encoder); err != nil {
24573 return err
24574 }
24575
24576 return nil
24577}
24578
24579func DecodeOxmIdTunMetadata63(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata63, error) {
24580 _oxmidtunmetadata63 := &OxmIdTunMetadata63{OxmId: parent}
24581 return _oxmidtunmetadata63, nil
24582}
24583
24584func NewOxmIdTunMetadata63() *OxmIdTunMetadata63 {
24585 obj := &OxmIdTunMetadata63{
24586 OxmId: NewOxmId(118396),
24587 }
24588 return obj
24589}
24590func (self *OxmIdTunMetadata63) GetOXMName() string {
24591 return "tun_metadata63"
24592}
24593
24594func (self *OxmIdTunMetadata63) MarshalJSON() ([]byte, error) {
24595 if self.TypeLen == 0 {
24596 return []byte("\"\""), nil
24597 } else {
24598 return []byte("\"" + self.GetOXMName() + "\""), nil
24599 }
24600}
24601
24602type OxmIdTunMetadata63Masked struct {
24603 *OxmId
24604}
24605
24606type IOxmIdTunMetadata63Masked interface {
24607 IOxmId
24608}
24609
24610func (self *OxmIdTunMetadata63Masked) Serialize(encoder *goloxi.Encoder) error {
24611 if err := self.OxmId.Serialize(encoder); err != nil {
24612 return err
24613 }
24614
24615 return nil
24616}
24617
24618func DecodeOxmIdTunMetadata63Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata63Masked, error) {
24619 _oxmidtunmetadata63masked := &OxmIdTunMetadata63Masked{OxmId: parent}
24620 return _oxmidtunmetadata63masked, nil
24621}
24622
24623func NewOxmIdTunMetadata63Masked() *OxmIdTunMetadata63Masked {
24624 obj := &OxmIdTunMetadata63Masked{
24625 OxmId: NewOxmId(118776),
24626 }
24627 return obj
24628}
24629func (self *OxmIdTunMetadata63Masked) GetOXMName() string {
24630 return "tun_metadata63_masked"
24631}
24632
24633func (self *OxmIdTunMetadata63Masked) MarshalJSON() ([]byte, error) {
24634 if self.TypeLen == 0 {
24635 return []byte("\"\""), nil
24636 } else {
24637 return []byte("\"" + self.GetOXMName() + "\""), nil
24638 }
24639}
24640
24641type OxmIdTunMetadata6Masked struct {
24642 *OxmId
24643}
24644
24645type IOxmIdTunMetadata6Masked interface {
24646 IOxmId
24647}
24648
24649func (self *OxmIdTunMetadata6Masked) Serialize(encoder *goloxi.Encoder) error {
24650 if err := self.OxmId.Serialize(encoder); err != nil {
24651 return err
24652 }
24653
24654 return nil
24655}
24656
24657func DecodeOxmIdTunMetadata6Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata6Masked, error) {
24658 _oxmidtunmetadata6masked := &OxmIdTunMetadata6Masked{OxmId: parent}
24659 return _oxmidtunmetadata6masked, nil
24660}
24661
24662func NewOxmIdTunMetadata6Masked() *OxmIdTunMetadata6Masked {
24663 obj := &OxmIdTunMetadata6Masked{
24664 OxmId: NewOxmId(89592),
24665 }
24666 return obj
24667}
24668func (self *OxmIdTunMetadata6Masked) GetOXMName() string {
24669 return "tun_metadata6_masked"
24670}
24671
24672func (self *OxmIdTunMetadata6Masked) MarshalJSON() ([]byte, error) {
24673 if self.TypeLen == 0 {
24674 return []byte("\"\""), nil
24675 } else {
24676 return []byte("\"" + self.GetOXMName() + "\""), nil
24677 }
24678}
24679
24680type OxmIdTunMetadata7 struct {
24681 *OxmId
24682}
24683
24684type IOxmIdTunMetadata7 interface {
24685 IOxmId
24686}
24687
24688func (self *OxmIdTunMetadata7) Serialize(encoder *goloxi.Encoder) error {
24689 if err := self.OxmId.Serialize(encoder); err != nil {
24690 return err
24691 }
24692
24693 return nil
24694}
24695
24696func DecodeOxmIdTunMetadata7(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata7, error) {
24697 _oxmidtunmetadata7 := &OxmIdTunMetadata7{OxmId: parent}
24698 return _oxmidtunmetadata7, nil
24699}
24700
24701func NewOxmIdTunMetadata7() *OxmIdTunMetadata7 {
24702 obj := &OxmIdTunMetadata7{
24703 OxmId: NewOxmId(89724),
24704 }
24705 return obj
24706}
24707func (self *OxmIdTunMetadata7) GetOXMName() string {
24708 return "tun_metadata7"
24709}
24710
24711func (self *OxmIdTunMetadata7) MarshalJSON() ([]byte, error) {
24712 if self.TypeLen == 0 {
24713 return []byte("\"\""), nil
24714 } else {
24715 return []byte("\"" + self.GetOXMName() + "\""), nil
24716 }
24717}
24718
24719type OxmIdTunMetadata7Masked struct {
24720 *OxmId
24721}
24722
24723type IOxmIdTunMetadata7Masked interface {
24724 IOxmId
24725}
24726
24727func (self *OxmIdTunMetadata7Masked) Serialize(encoder *goloxi.Encoder) error {
24728 if err := self.OxmId.Serialize(encoder); err != nil {
24729 return err
24730 }
24731
24732 return nil
24733}
24734
24735func DecodeOxmIdTunMetadata7Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata7Masked, error) {
24736 _oxmidtunmetadata7masked := &OxmIdTunMetadata7Masked{OxmId: parent}
24737 return _oxmidtunmetadata7masked, nil
24738}
24739
24740func NewOxmIdTunMetadata7Masked() *OxmIdTunMetadata7Masked {
24741 obj := &OxmIdTunMetadata7Masked{
24742 OxmId: NewOxmId(90104),
24743 }
24744 return obj
24745}
24746func (self *OxmIdTunMetadata7Masked) GetOXMName() string {
24747 return "tun_metadata7_masked"
24748}
24749
24750func (self *OxmIdTunMetadata7Masked) MarshalJSON() ([]byte, error) {
24751 if self.TypeLen == 0 {
24752 return []byte("\"\""), nil
24753 } else {
24754 return []byte("\"" + self.GetOXMName() + "\""), nil
24755 }
24756}
24757
24758type OxmIdTunMetadata8 struct {
24759 *OxmId
24760}
24761
24762type IOxmIdTunMetadata8 interface {
24763 IOxmId
24764}
24765
24766func (self *OxmIdTunMetadata8) Serialize(encoder *goloxi.Encoder) error {
24767 if err := self.OxmId.Serialize(encoder); err != nil {
24768 return err
24769 }
24770
24771 return nil
24772}
24773
24774func DecodeOxmIdTunMetadata8(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata8, error) {
24775 _oxmidtunmetadata8 := &OxmIdTunMetadata8{OxmId: parent}
24776 return _oxmidtunmetadata8, nil
24777}
24778
24779func NewOxmIdTunMetadata8() *OxmIdTunMetadata8 {
24780 obj := &OxmIdTunMetadata8{
24781 OxmId: NewOxmId(90236),
24782 }
24783 return obj
24784}
24785func (self *OxmIdTunMetadata8) GetOXMName() string {
24786 return "tun_metadata8"
24787}
24788
24789func (self *OxmIdTunMetadata8) MarshalJSON() ([]byte, error) {
24790 if self.TypeLen == 0 {
24791 return []byte("\"\""), nil
24792 } else {
24793 return []byte("\"" + self.GetOXMName() + "\""), nil
24794 }
24795}
24796
24797type OxmIdTunMetadata8Masked struct {
24798 *OxmId
24799}
24800
24801type IOxmIdTunMetadata8Masked interface {
24802 IOxmId
24803}
24804
24805func (self *OxmIdTunMetadata8Masked) Serialize(encoder *goloxi.Encoder) error {
24806 if err := self.OxmId.Serialize(encoder); err != nil {
24807 return err
24808 }
24809
24810 return nil
24811}
24812
24813func DecodeOxmIdTunMetadata8Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata8Masked, error) {
24814 _oxmidtunmetadata8masked := &OxmIdTunMetadata8Masked{OxmId: parent}
24815 return _oxmidtunmetadata8masked, nil
24816}
24817
24818func NewOxmIdTunMetadata8Masked() *OxmIdTunMetadata8Masked {
24819 obj := &OxmIdTunMetadata8Masked{
24820 OxmId: NewOxmId(90616),
24821 }
24822 return obj
24823}
24824func (self *OxmIdTunMetadata8Masked) GetOXMName() string {
24825 return "tun_metadata8_masked"
24826}
24827
24828func (self *OxmIdTunMetadata8Masked) MarshalJSON() ([]byte, error) {
24829 if self.TypeLen == 0 {
24830 return []byte("\"\""), nil
24831 } else {
24832 return []byte("\"" + self.GetOXMName() + "\""), nil
24833 }
24834}
24835
24836type OxmIdTunMetadata9 struct {
24837 *OxmId
24838}
24839
24840type IOxmIdTunMetadata9 interface {
24841 IOxmId
24842}
24843
24844func (self *OxmIdTunMetadata9) Serialize(encoder *goloxi.Encoder) error {
24845 if err := self.OxmId.Serialize(encoder); err != nil {
24846 return err
24847 }
24848
24849 return nil
24850}
24851
24852func DecodeOxmIdTunMetadata9(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata9, error) {
24853 _oxmidtunmetadata9 := &OxmIdTunMetadata9{OxmId: parent}
24854 return _oxmidtunmetadata9, nil
24855}
24856
24857func NewOxmIdTunMetadata9() *OxmIdTunMetadata9 {
24858 obj := &OxmIdTunMetadata9{
24859 OxmId: NewOxmId(90748),
24860 }
24861 return obj
24862}
24863func (self *OxmIdTunMetadata9) GetOXMName() string {
24864 return "tun_metadata9"
24865}
24866
24867func (self *OxmIdTunMetadata9) MarshalJSON() ([]byte, error) {
24868 if self.TypeLen == 0 {
24869 return []byte("\"\""), nil
24870 } else {
24871 return []byte("\"" + self.GetOXMName() + "\""), nil
24872 }
24873}
24874
24875type OxmIdTunMetadata9Masked struct {
24876 *OxmId
24877}
24878
24879type IOxmIdTunMetadata9Masked interface {
24880 IOxmId
24881}
24882
24883func (self *OxmIdTunMetadata9Masked) Serialize(encoder *goloxi.Encoder) error {
24884 if err := self.OxmId.Serialize(encoder); err != nil {
24885 return err
24886 }
24887
24888 return nil
24889}
24890
24891func DecodeOxmIdTunMetadata9Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata9Masked, error) {
24892 _oxmidtunmetadata9masked := &OxmIdTunMetadata9Masked{OxmId: parent}
24893 return _oxmidtunmetadata9masked, nil
24894}
24895
24896func NewOxmIdTunMetadata9Masked() *OxmIdTunMetadata9Masked {
24897 obj := &OxmIdTunMetadata9Masked{
24898 OxmId: NewOxmId(91128),
24899 }
24900 return obj
24901}
24902func (self *OxmIdTunMetadata9Masked) GetOXMName() string {
24903 return "tun_metadata9_masked"
24904}
24905
24906func (self *OxmIdTunMetadata9Masked) MarshalJSON() ([]byte, error) {
24907 if self.TypeLen == 0 {
24908 return []byte("\"\""), nil
24909 } else {
24910 return []byte("\"" + self.GetOXMName() + "\""), nil
24911 }
24912}
24913
24914type OxmIdTunSrc struct {
24915 *OxmId
24916}
24917
24918type IOxmIdTunSrc interface {
24919 IOxmId
24920}
24921
24922func (self *OxmIdTunSrc) Serialize(encoder *goloxi.Encoder) error {
24923 if err := self.OxmId.Serialize(encoder); err != nil {
24924 return err
24925 }
24926
24927 return nil
24928}
24929
24930func DecodeOxmIdTunSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunSrc, error) {
24931 _oxmidtunsrc := &OxmIdTunSrc{OxmId: parent}
24932 return _oxmidtunsrc, nil
24933}
24934
24935func NewOxmIdTunSrc() *OxmIdTunSrc {
24936 obj := &OxmIdTunSrc{
24937 OxmId: NewOxmId(81412),
24938 }
24939 return obj
24940}
24941func (self *OxmIdTunSrc) GetOXMName() string {
24942 return "tun_src"
24943}
24944
24945func (self *OxmIdTunSrc) MarshalJSON() ([]byte, error) {
24946 if self.TypeLen == 0 {
24947 return []byte("\"\""), nil
24948 } else {
24949 return []byte("\"" + self.GetOXMName() + "\""), nil
24950 }
24951}
24952
24953type OxmIdTunSrcMasked struct {
24954 *OxmId
24955}
24956
24957type IOxmIdTunSrcMasked interface {
24958 IOxmId
24959}
24960
24961func (self *OxmIdTunSrcMasked) Serialize(encoder *goloxi.Encoder) error {
24962 if err := self.OxmId.Serialize(encoder); err != nil {
24963 return err
24964 }
24965
24966 return nil
24967}
24968
24969func DecodeOxmIdTunSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunSrcMasked, error) {
24970 _oxmidtunsrcmasked := &OxmIdTunSrcMasked{OxmId: parent}
24971 return _oxmidtunsrcmasked, nil
24972}
24973
24974func NewOxmIdTunSrcMasked() *OxmIdTunSrcMasked {
24975 obj := &OxmIdTunSrcMasked{
24976 OxmId: NewOxmId(81672),
24977 }
24978 return obj
24979}
24980func (self *OxmIdTunSrcMasked) GetOXMName() string {
24981 return "tun_src_masked"
24982}
24983
24984func (self *OxmIdTunSrcMasked) MarshalJSON() ([]byte, error) {
24985 if self.TypeLen == 0 {
24986 return []byte("\"\""), nil
24987 } else {
24988 return []byte("\"" + self.GetOXMName() + "\""), nil
24989 }
24990}
24991
24992type OxmIdUdpDst struct {
24993 *OxmId
24994}
24995
24996type IOxmIdUdpDst interface {
24997 IOxmId
24998}
24999
25000func (self *OxmIdUdpDst) Serialize(encoder *goloxi.Encoder) error {
25001 if err := self.OxmId.Serialize(encoder); err != nil {
25002 return err
25003 }
25004
25005 return nil
25006}
25007
25008func DecodeOxmIdUdpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpDst, error) {
25009 _oxmidudpdst := &OxmIdUdpDst{OxmId: parent}
25010 return _oxmidudpdst, nil
25011}
25012
25013func NewOxmIdUdpDst() *OxmIdUdpDst {
25014 obj := &OxmIdUdpDst{
25015 OxmId: NewOxmId(6146),
25016 }
25017 return obj
25018}
25019func (self *OxmIdUdpDst) GetOXMName() string {
25020 return "udp_dst"
25021}
25022
25023func (self *OxmIdUdpDst) MarshalJSON() ([]byte, error) {
25024 if self.TypeLen == 0 {
25025 return []byte("\"\""), nil
25026 } else {
25027 return []byte("\"" + self.GetOXMName() + "\""), nil
25028 }
25029}
25030
25031type OxmIdUdpDstMasked struct {
25032 *OxmId
25033}
25034
25035type IOxmIdUdpDstMasked interface {
25036 IOxmId
25037}
25038
25039func (self *OxmIdUdpDstMasked) Serialize(encoder *goloxi.Encoder) error {
25040 if err := self.OxmId.Serialize(encoder); err != nil {
25041 return err
25042 }
25043
25044 return nil
25045}
25046
25047func DecodeOxmIdUdpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpDstMasked, error) {
25048 _oxmidudpdstmasked := &OxmIdUdpDstMasked{OxmId: parent}
25049 return _oxmidudpdstmasked, nil
25050}
25051
25052func NewOxmIdUdpDstMasked() *OxmIdUdpDstMasked {
25053 obj := &OxmIdUdpDstMasked{
25054 OxmId: NewOxmId(6404),
25055 }
25056 return obj
25057}
25058func (self *OxmIdUdpDstMasked) GetOXMName() string {
25059 return "udp_dst_masked"
25060}
25061
25062func (self *OxmIdUdpDstMasked) MarshalJSON() ([]byte, error) {
25063 if self.TypeLen == 0 {
25064 return []byte("\"\""), nil
25065 } else {
25066 return []byte("\"" + self.GetOXMName() + "\""), nil
25067 }
25068}
25069
25070type OxmIdUdpSrc struct {
25071 *OxmId
25072}
25073
25074type IOxmIdUdpSrc interface {
25075 IOxmId
25076}
25077
25078func (self *OxmIdUdpSrc) Serialize(encoder *goloxi.Encoder) error {
25079 if err := self.OxmId.Serialize(encoder); err != nil {
25080 return err
25081 }
25082
25083 return nil
25084}
25085
25086func DecodeOxmIdUdpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpSrc, error) {
25087 _oxmidudpsrc := &OxmIdUdpSrc{OxmId: parent}
25088 return _oxmidudpsrc, nil
25089}
25090
25091func NewOxmIdUdpSrc() *OxmIdUdpSrc {
25092 obj := &OxmIdUdpSrc{
25093 OxmId: NewOxmId(5634),
25094 }
25095 return obj
25096}
25097func (self *OxmIdUdpSrc) GetOXMName() string {
25098 return "udp_src"
25099}
25100
25101func (self *OxmIdUdpSrc) MarshalJSON() ([]byte, error) {
25102 if self.TypeLen == 0 {
25103 return []byte("\"\""), nil
25104 } else {
25105 return []byte("\"" + self.GetOXMName() + "\""), nil
25106 }
25107}
25108
25109type OxmIdUdpSrcMasked struct {
25110 *OxmId
25111}
25112
25113type IOxmIdUdpSrcMasked interface {
25114 IOxmId
25115}
25116
25117func (self *OxmIdUdpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
25118 if err := self.OxmId.Serialize(encoder); err != nil {
25119 return err
25120 }
25121
25122 return nil
25123}
25124
25125func DecodeOxmIdUdpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpSrcMasked, error) {
25126 _oxmidudpsrcmasked := &OxmIdUdpSrcMasked{OxmId: parent}
25127 return _oxmidudpsrcmasked, nil
25128}
25129
25130func NewOxmIdUdpSrcMasked() *OxmIdUdpSrcMasked {
25131 obj := &OxmIdUdpSrcMasked{
25132 OxmId: NewOxmId(5892),
25133 }
25134 return obj
25135}
25136func (self *OxmIdUdpSrcMasked) GetOXMName() string {
25137 return "udp_src_masked"
25138}
25139
25140func (self *OxmIdUdpSrcMasked) MarshalJSON() ([]byte, error) {
25141 if self.TypeLen == 0 {
25142 return []byte("\"\""), nil
25143 } else {
25144 return []byte("\"" + self.GetOXMName() + "\""), nil
25145 }
25146}
25147
25148type OxmIdVlanTci struct {
25149 *OxmId
25150}
25151
25152type IOxmIdVlanTci interface {
25153 IOxmId
25154}
25155
25156func (self *OxmIdVlanTci) Serialize(encoder *goloxi.Encoder) error {
25157 if err := self.OxmId.Serialize(encoder); err != nil {
25158 return err
25159 }
25160
25161 return nil
25162}
25163
25164func DecodeOxmIdVlanTci(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanTci, error) {
25165 _oxmidvlantci := &OxmIdVlanTci{OxmId: parent}
25166 return _oxmidvlantci, nil
25167}
25168
25169func NewOxmIdVlanTci() *OxmIdVlanTci {
25170 obj := &OxmIdVlanTci{
25171 OxmId: NewOxmId(2050),
25172 }
25173 return obj
25174}
25175func (self *OxmIdVlanTci) GetOXMName() string {
25176 return "vlan_tci"
25177}
25178
25179func (self *OxmIdVlanTci) MarshalJSON() ([]byte, error) {
25180 if self.TypeLen == 0 {
25181 return []byte("\"\""), nil
25182 } else {
25183 return []byte("\"" + self.GetOXMName() + "\""), nil
25184 }
25185}
25186
25187type OxmIdVlanTciMasked struct {
25188 *OxmId
25189}
25190
25191type IOxmIdVlanTciMasked interface {
25192 IOxmId
25193}
25194
25195func (self *OxmIdVlanTciMasked) Serialize(encoder *goloxi.Encoder) error {
25196 if err := self.OxmId.Serialize(encoder); err != nil {
25197 return err
25198 }
25199
25200 return nil
25201}
25202
25203func DecodeOxmIdVlanTciMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanTciMasked, error) {
25204 _oxmidvlantcimasked := &OxmIdVlanTciMasked{OxmId: parent}
25205 return _oxmidvlantcimasked, nil
25206}
25207
25208func NewOxmIdVlanTciMasked() *OxmIdVlanTciMasked {
25209 obj := &OxmIdVlanTciMasked{
25210 OxmId: NewOxmId(2308),
25211 }
25212 return obj
25213}
25214func (self *OxmIdVlanTciMasked) GetOXMName() string {
25215 return "vlan_tci_masked"
25216}
25217
25218func (self *OxmIdVlanTciMasked) MarshalJSON() ([]byte, error) {
25219 if self.TypeLen == 0 {
25220 return []byte("\"\""), nil
25221 } else {
25222 return []byte("\"" + self.GetOXMName() + "\""), nil
25223 }
25224}
25225
25226type OxmIdXxreg0 struct {
25227 *OxmId
25228}
25229
25230type IOxmIdXxreg0 interface {
25231 IOxmId
25232}
25233
25234func (self *OxmIdXxreg0) Serialize(encoder *goloxi.Encoder) error {
25235 if err := self.OxmId.Serialize(encoder); err != nil {
25236 return err
25237 }
25238
25239 return nil
25240}
25241
25242func DecodeOxmIdXxreg0(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg0, error) {
25243 _oxmidxxreg0 := &OxmIdXxreg0{OxmId: parent}
25244 return _oxmidxxreg0, nil
25245}
25246
25247func NewOxmIdXxreg0() *OxmIdXxreg0 {
25248 obj := &OxmIdXxreg0{
25249 OxmId: NewOxmId(122384),
25250 }
25251 return obj
25252}
25253func (self *OxmIdXxreg0) GetOXMName() string {
25254 return "xxreg0"
25255}
25256
25257func (self *OxmIdXxreg0) MarshalJSON() ([]byte, error) {
25258 if self.TypeLen == 0 {
25259 return []byte("\"\""), nil
25260 } else {
25261 return []byte("\"" + self.GetOXMName() + "\""), nil
25262 }
25263}
25264
25265type OxmIdXxreg0Masked struct {
25266 *OxmId
25267}
25268
25269type IOxmIdXxreg0Masked interface {
25270 IOxmId
25271}
25272
25273func (self *OxmIdXxreg0Masked) Serialize(encoder *goloxi.Encoder) error {
25274 if err := self.OxmId.Serialize(encoder); err != nil {
25275 return err
25276 }
25277
25278 return nil
25279}
25280
25281func DecodeOxmIdXxreg0Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg0Masked, error) {
25282 _oxmidxxreg0masked := &OxmIdXxreg0Masked{OxmId: parent}
25283 return _oxmidxxreg0masked, nil
25284}
25285
25286func NewOxmIdXxreg0Masked() *OxmIdXxreg0Masked {
25287 obj := &OxmIdXxreg0Masked{
25288 OxmId: NewOxmId(122656),
25289 }
25290 return obj
25291}
25292func (self *OxmIdXxreg0Masked) GetOXMName() string {
25293 return "xxreg0_masked"
25294}
25295
25296func (self *OxmIdXxreg0Masked) MarshalJSON() ([]byte, error) {
25297 if self.TypeLen == 0 {
25298 return []byte("\"\""), nil
25299 } else {
25300 return []byte("\"" + self.GetOXMName() + "\""), nil
25301 }
25302}
25303
25304type OxmIdXxreg1 struct {
25305 *OxmId
25306}
25307
25308type IOxmIdXxreg1 interface {
25309 IOxmId
25310}
25311
25312func (self *OxmIdXxreg1) Serialize(encoder *goloxi.Encoder) error {
25313 if err := self.OxmId.Serialize(encoder); err != nil {
25314 return err
25315 }
25316
25317 return nil
25318}
25319
25320func DecodeOxmIdXxreg1(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg1, error) {
25321 _oxmidxxreg1 := &OxmIdXxreg1{OxmId: parent}
25322 return _oxmidxxreg1, nil
25323}
25324
25325func NewOxmIdXxreg1() *OxmIdXxreg1 {
25326 obj := &OxmIdXxreg1{
25327 OxmId: NewOxmId(122896),
25328 }
25329 return obj
25330}
25331func (self *OxmIdXxreg1) GetOXMName() string {
25332 return "xxreg1"
25333}
25334
25335func (self *OxmIdXxreg1) MarshalJSON() ([]byte, error) {
25336 if self.TypeLen == 0 {
25337 return []byte("\"\""), nil
25338 } else {
25339 return []byte("\"" + self.GetOXMName() + "\""), nil
25340 }
25341}
25342
25343type OxmIdXxreg1Masked struct {
25344 *OxmId
25345}
25346
25347type IOxmIdXxreg1Masked interface {
25348 IOxmId
25349}
25350
25351func (self *OxmIdXxreg1Masked) Serialize(encoder *goloxi.Encoder) error {
25352 if err := self.OxmId.Serialize(encoder); err != nil {
25353 return err
25354 }
25355
25356 return nil
25357}
25358
25359func DecodeOxmIdXxreg1Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg1Masked, error) {
25360 _oxmidxxreg1masked := &OxmIdXxreg1Masked{OxmId: parent}
25361 return _oxmidxxreg1masked, nil
25362}
25363
25364func NewOxmIdXxreg1Masked() *OxmIdXxreg1Masked {
25365 obj := &OxmIdXxreg1Masked{
25366 OxmId: NewOxmId(123168),
25367 }
25368 return obj
25369}
25370func (self *OxmIdXxreg1Masked) GetOXMName() string {
25371 return "xxreg1_masked"
25372}
25373
25374func (self *OxmIdXxreg1Masked) MarshalJSON() ([]byte, error) {
25375 if self.TypeLen == 0 {
25376 return []byte("\"\""), nil
25377 } else {
25378 return []byte("\"" + self.GetOXMName() + "\""), nil
25379 }
25380}
25381
25382type OxmIdXxreg2 struct {
25383 *OxmId
25384}
25385
25386type IOxmIdXxreg2 interface {
25387 IOxmId
25388}
25389
25390func (self *OxmIdXxreg2) Serialize(encoder *goloxi.Encoder) error {
25391 if err := self.OxmId.Serialize(encoder); err != nil {
25392 return err
25393 }
25394
25395 return nil
25396}
25397
25398func DecodeOxmIdXxreg2(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg2, error) {
25399 _oxmidxxreg2 := &OxmIdXxreg2{OxmId: parent}
25400 return _oxmidxxreg2, nil
25401}
25402
25403func NewOxmIdXxreg2() *OxmIdXxreg2 {
25404 obj := &OxmIdXxreg2{
25405 OxmId: NewOxmId(123408),
25406 }
25407 return obj
25408}
25409func (self *OxmIdXxreg2) GetOXMName() string {
25410 return "xxreg2"
25411}
25412
25413func (self *OxmIdXxreg2) MarshalJSON() ([]byte, error) {
25414 if self.TypeLen == 0 {
25415 return []byte("\"\""), nil
25416 } else {
25417 return []byte("\"" + self.GetOXMName() + "\""), nil
25418 }
25419}
25420
25421type OxmIdXxreg2Masked struct {
25422 *OxmId
25423}
25424
25425type IOxmIdXxreg2Masked interface {
25426 IOxmId
25427}
25428
25429func (self *OxmIdXxreg2Masked) Serialize(encoder *goloxi.Encoder) error {
25430 if err := self.OxmId.Serialize(encoder); err != nil {
25431 return err
25432 }
25433
25434 return nil
25435}
25436
25437func DecodeOxmIdXxreg2Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg2Masked, error) {
25438 _oxmidxxreg2masked := &OxmIdXxreg2Masked{OxmId: parent}
25439 return _oxmidxxreg2masked, nil
25440}
25441
25442func NewOxmIdXxreg2Masked() *OxmIdXxreg2Masked {
25443 obj := &OxmIdXxreg2Masked{
25444 OxmId: NewOxmId(123680),
25445 }
25446 return obj
25447}
25448func (self *OxmIdXxreg2Masked) GetOXMName() string {
25449 return "xxreg2_masked"
25450}
25451
25452func (self *OxmIdXxreg2Masked) MarshalJSON() ([]byte, error) {
25453 if self.TypeLen == 0 {
25454 return []byte("\"\""), nil
25455 } else {
25456 return []byte("\"" + self.GetOXMName() + "\""), nil
25457 }
25458}
25459
25460type OxmIdXxreg3 struct {
25461 *OxmId
25462}
25463
25464type IOxmIdXxreg3 interface {
25465 IOxmId
25466}
25467
25468func (self *OxmIdXxreg3) Serialize(encoder *goloxi.Encoder) error {
25469 if err := self.OxmId.Serialize(encoder); err != nil {
25470 return err
25471 }
25472
25473 return nil
25474}
25475
25476func DecodeOxmIdXxreg3(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg3, error) {
25477 _oxmidxxreg3 := &OxmIdXxreg3{OxmId: parent}
25478 return _oxmidxxreg3, nil
25479}
25480
25481func NewOxmIdXxreg3() *OxmIdXxreg3 {
25482 obj := &OxmIdXxreg3{
25483 OxmId: NewOxmId(123920),
25484 }
25485 return obj
25486}
25487func (self *OxmIdXxreg3) GetOXMName() string {
25488 return "xxreg3"
25489}
25490
25491func (self *OxmIdXxreg3) MarshalJSON() ([]byte, error) {
25492 if self.TypeLen == 0 {
25493 return []byte("\"\""), nil
25494 } else {
25495 return []byte("\"" + self.GetOXMName() + "\""), nil
25496 }
25497}
25498
25499type OxmIdXxreg3Masked struct {
25500 *OxmId
25501}
25502
25503type IOxmIdXxreg3Masked interface {
25504 IOxmId
25505}
25506
25507func (self *OxmIdXxreg3Masked) Serialize(encoder *goloxi.Encoder) error {
25508 if err := self.OxmId.Serialize(encoder); err != nil {
25509 return err
25510 }
25511
25512 return nil
25513}
25514
25515func DecodeOxmIdXxreg3Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg3Masked, error) {
25516 _oxmidxxreg3masked := &OxmIdXxreg3Masked{OxmId: parent}
25517 return _oxmidxxreg3masked, nil
25518}
25519
25520func NewOxmIdXxreg3Masked() *OxmIdXxreg3Masked {
25521 obj := &OxmIdXxreg3Masked{
25522 OxmId: NewOxmId(124192),
25523 }
25524 return obj
25525}
25526func (self *OxmIdXxreg3Masked) GetOXMName() string {
25527 return "xxreg3_masked"
25528}
25529
25530func (self *OxmIdXxreg3Masked) MarshalJSON() ([]byte, error) {
25531 if self.TypeLen == 0 {
25532 return []byte("\"\""), nil
25533 } else {
25534 return []byte("\"" + self.GetOXMName() + "\""), nil
25535 }
25536}
25537
25538type OxmIdArpOpMasked struct {
25539 *OxmId
25540}
25541
25542type IOxmIdArpOpMasked interface {
25543 IOxmId
25544}
25545
25546func (self *OxmIdArpOpMasked) Serialize(encoder *goloxi.Encoder) error {
25547 if err := self.OxmId.Serialize(encoder); err != nil {
25548 return err
25549 }
25550
25551 return nil
25552}
25553
25554func DecodeOxmIdArpOpMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpOpMasked, error) {
25555 _oxmidarpopmasked := &OxmIdArpOpMasked{OxmId: parent}
25556 return _oxmidarpopmasked, nil
25557}
25558
25559func NewOxmIdArpOpMasked() *OxmIdArpOpMasked {
25560 obj := &OxmIdArpOpMasked{
25561 OxmId: NewOxmId(2147494660),
25562 }
25563 return obj
25564}
25565func (self *OxmIdArpOpMasked) GetOXMName() string {
25566 return "arp_op_masked"
25567}
25568
25569func (self *OxmIdArpOpMasked) MarshalJSON() ([]byte, error) {
25570 if self.TypeLen == 0 {
25571 return []byte("\"\""), nil
25572 } else {
25573 return []byte("\"" + self.GetOXMName() + "\""), nil
25574 }
25575}
25576
25577type OxmIdBsnEgrPortGroupId struct {
25578 *OxmId
25579}
25580
25581type IOxmIdBsnEgrPortGroupId interface {
25582 IOxmId
25583}
25584
25585func (self *OxmIdBsnEgrPortGroupId) Serialize(encoder *goloxi.Encoder) error {
25586 if err := self.OxmId.Serialize(encoder); err != nil {
25587 return err
25588 }
25589
25590 return nil
25591}
25592
25593func DecodeOxmIdBsnEgrPortGroupId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnEgrPortGroupId, error) {
25594 _oxmidbsnegrportgroupid := &OxmIdBsnEgrPortGroupId{OxmId: parent}
25595 return _oxmidbsnegrportgroupid, nil
25596}
25597
25598func NewOxmIdBsnEgrPortGroupId() *OxmIdBsnEgrPortGroupId {
25599 obj := &OxmIdBsnEgrPortGroupId{
25600 OxmId: NewOxmId(200196),
25601 }
25602 return obj
25603}
25604func (self *OxmIdBsnEgrPortGroupId) GetOXMName() string {
25605 return "bsn_egr_port_group_id"
25606}
25607
25608func (self *OxmIdBsnEgrPortGroupId) MarshalJSON() ([]byte, error) {
25609 if self.TypeLen == 0 {
25610 return []byte("\"\""), nil
25611 } else {
25612 return []byte("\"" + self.GetOXMName() + "\""), nil
25613 }
25614}
25615
25616type OxmIdBsnEgrPortGroupIdMasked struct {
25617 *OxmId
25618}
25619
25620type IOxmIdBsnEgrPortGroupIdMasked interface {
25621 IOxmId
25622}
25623
25624func (self *OxmIdBsnEgrPortGroupIdMasked) Serialize(encoder *goloxi.Encoder) error {
25625 if err := self.OxmId.Serialize(encoder); err != nil {
25626 return err
25627 }
25628
25629 return nil
25630}
25631
25632func DecodeOxmIdBsnEgrPortGroupIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnEgrPortGroupIdMasked, error) {
25633 _oxmidbsnegrportgroupidmasked := &OxmIdBsnEgrPortGroupIdMasked{OxmId: parent}
25634 return _oxmidbsnegrportgroupidmasked, nil
25635}
25636
25637func NewOxmIdBsnEgrPortGroupIdMasked() *OxmIdBsnEgrPortGroupIdMasked {
25638 obj := &OxmIdBsnEgrPortGroupIdMasked{
25639 OxmId: NewOxmId(200456),
25640 }
25641 return obj
25642}
25643func (self *OxmIdBsnEgrPortGroupIdMasked) GetOXMName() string {
25644 return "bsn_egr_port_group_id_masked"
25645}
25646
25647func (self *OxmIdBsnEgrPortGroupIdMasked) MarshalJSON() ([]byte, error) {
25648 if self.TypeLen == 0 {
25649 return []byte("\"\""), nil
25650 } else {
25651 return []byte("\"" + self.GetOXMName() + "\""), nil
25652 }
25653}
25654
25655type OxmIdBsnGlobalVrfAllowed struct {
25656 *OxmId
25657}
25658
25659type IOxmIdBsnGlobalVrfAllowed interface {
25660 IOxmId
25661}
25662
25663func (self *OxmIdBsnGlobalVrfAllowed) Serialize(encoder *goloxi.Encoder) error {
25664 if err := self.OxmId.Serialize(encoder); err != nil {
25665 return err
25666 }
25667
25668 return nil
25669}
25670
25671func DecodeOxmIdBsnGlobalVrfAllowed(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnGlobalVrfAllowed, error) {
25672 _oxmidbsnglobalvrfallowed := &OxmIdBsnGlobalVrfAllowed{OxmId: parent}
25673 return _oxmidbsnglobalvrfallowed, nil
25674}
25675
25676func NewOxmIdBsnGlobalVrfAllowed() *OxmIdBsnGlobalVrfAllowed {
25677 obj := &OxmIdBsnGlobalVrfAllowed{
25678 OxmId: NewOxmId(198145),
25679 }
25680 return obj
25681}
25682func (self *OxmIdBsnGlobalVrfAllowed) GetOXMName() string {
25683 return "bsn_global_vrf_allowed"
25684}
25685
25686func (self *OxmIdBsnGlobalVrfAllowed) MarshalJSON() ([]byte, error) {
25687 if self.TypeLen == 0 {
25688 return []byte("\"\""), nil
25689 } else {
25690 return []byte("\"" + self.GetOXMName() + "\""), nil
25691 }
25692}
25693
25694type OxmIdBsnGlobalVrfAllowedMasked struct {
25695 *OxmId
25696}
25697
25698type IOxmIdBsnGlobalVrfAllowedMasked interface {
25699 IOxmId
25700}
25701
25702func (self *OxmIdBsnGlobalVrfAllowedMasked) Serialize(encoder *goloxi.Encoder) error {
25703 if err := self.OxmId.Serialize(encoder); err != nil {
25704 return err
25705 }
25706
25707 return nil
25708}
25709
25710func DecodeOxmIdBsnGlobalVrfAllowedMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnGlobalVrfAllowedMasked, error) {
25711 _oxmidbsnglobalvrfallowedmasked := &OxmIdBsnGlobalVrfAllowedMasked{OxmId: parent}
25712 return _oxmidbsnglobalvrfallowedmasked, nil
25713}
25714
25715func NewOxmIdBsnGlobalVrfAllowedMasked() *OxmIdBsnGlobalVrfAllowedMasked {
25716 obj := &OxmIdBsnGlobalVrfAllowedMasked{
25717 OxmId: NewOxmId(198402),
25718 }
25719 return obj
25720}
25721func (self *OxmIdBsnGlobalVrfAllowedMasked) GetOXMName() string {
25722 return "bsn_global_vrf_allowed_masked"
25723}
25724
25725func (self *OxmIdBsnGlobalVrfAllowedMasked) MarshalJSON() ([]byte, error) {
25726 if self.TypeLen == 0 {
25727 return []byte("\"\""), nil
25728 } else {
25729 return []byte("\"" + self.GetOXMName() + "\""), nil
25730 }
25731}
25732
25733type OxmIdBsnInPorts128 struct {
25734 *OxmId
25735}
25736
25737type IOxmIdBsnInPorts128 interface {
25738 IOxmId
25739}
25740
25741func (self *OxmIdBsnInPorts128) Serialize(encoder *goloxi.Encoder) error {
25742 if err := self.OxmId.Serialize(encoder); err != nil {
25743 return err
25744 }
25745
25746 return nil
25747}
25748
25749func DecodeOxmIdBsnInPorts128(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInPorts128, error) {
25750 _oxmidbsninports128 := &OxmIdBsnInPorts128{OxmId: parent}
25751 return _oxmidbsninports128, nil
25752}
25753
25754func NewOxmIdBsnInPorts128() *OxmIdBsnInPorts128 {
25755 obj := &OxmIdBsnInPorts128{
25756 OxmId: NewOxmId(196624),
25757 }
25758 return obj
25759}
25760func (self *OxmIdBsnInPorts128) GetOXMName() string {
25761 return "bsn_in_ports_128"
25762}
25763
25764func (self *OxmIdBsnInPorts128) MarshalJSON() ([]byte, error) {
25765 if self.TypeLen == 0 {
25766 return []byte("\"\""), nil
25767 } else {
25768 return []byte("\"" + self.GetOXMName() + "\""), nil
25769 }
25770}
25771
25772type OxmIdBsnInPorts128Masked struct {
25773 *OxmId
25774}
25775
25776type IOxmIdBsnInPorts128Masked interface {
25777 IOxmId
25778}
25779
25780func (self *OxmIdBsnInPorts128Masked) Serialize(encoder *goloxi.Encoder) error {
25781 if err := self.OxmId.Serialize(encoder); err != nil {
25782 return err
25783 }
25784
25785 return nil
25786}
25787
25788func DecodeOxmIdBsnInPorts128Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInPorts128Masked, error) {
25789 _oxmidbsninports128masked := &OxmIdBsnInPorts128Masked{OxmId: parent}
25790 return _oxmidbsninports128masked, nil
25791}
25792
25793func NewOxmIdBsnInPorts128Masked() *OxmIdBsnInPorts128Masked {
25794 obj := &OxmIdBsnInPorts128Masked{
25795 OxmId: NewOxmId(196896),
25796 }
25797 return obj
25798}
25799func (self *OxmIdBsnInPorts128Masked) GetOXMName() string {
25800 return "bsn_in_ports_128_masked"
25801}
25802
25803func (self *OxmIdBsnInPorts128Masked) MarshalJSON() ([]byte, error) {
25804 if self.TypeLen == 0 {
25805 return []byte("\"\""), nil
25806 } else {
25807 return []byte("\"" + self.GetOXMName() + "\""), nil
25808 }
25809}
25810
25811type OxmIdBsnInPorts512 struct {
25812 *OxmId
25813}
25814
25815type IOxmIdBsnInPorts512 interface {
25816 IOxmId
25817}
25818
25819func (self *OxmIdBsnInPorts512) Serialize(encoder *goloxi.Encoder) error {
25820 if err := self.OxmId.Serialize(encoder); err != nil {
25821 return err
25822 }
25823
25824 return nil
25825}
25826
25827func DecodeOxmIdBsnInPorts512(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInPorts512, error) {
25828 _oxmidbsninports512 := &OxmIdBsnInPorts512{OxmId: parent}
25829 return _oxmidbsninports512, nil
25830}
25831
25832func NewOxmIdBsnInPorts512() *OxmIdBsnInPorts512 {
25833 obj := &OxmIdBsnInPorts512{
25834 OxmId: NewOxmId(206400),
25835 }
25836 return obj
25837}
25838func (self *OxmIdBsnInPorts512) GetOXMName() string {
25839 return "bsn_in_ports_512"
25840}
25841
25842func (self *OxmIdBsnInPorts512) MarshalJSON() ([]byte, error) {
25843 if self.TypeLen == 0 {
25844 return []byte("\"\""), nil
25845 } else {
25846 return []byte("\"" + self.GetOXMName() + "\""), nil
25847 }
25848}
25849
25850type OxmIdBsnInPorts512Masked struct {
25851 *OxmId
25852}
25853
25854type IOxmIdBsnInPorts512Masked interface {
25855 IOxmId
25856}
25857
25858func (self *OxmIdBsnInPorts512Masked) Serialize(encoder *goloxi.Encoder) error {
25859 if err := self.OxmId.Serialize(encoder); err != nil {
25860 return err
25861 }
25862
25863 return nil
25864}
25865
25866func DecodeOxmIdBsnInPorts512Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInPorts512Masked, error) {
25867 _oxmidbsninports512masked := &OxmIdBsnInPorts512Masked{OxmId: parent}
25868 return _oxmidbsninports512masked, nil
25869}
25870
25871func NewOxmIdBsnInPorts512Masked() *OxmIdBsnInPorts512Masked {
25872 obj := &OxmIdBsnInPorts512Masked{
25873 OxmId: NewOxmId(206720),
25874 }
25875 return obj
25876}
25877func (self *OxmIdBsnInPorts512Masked) GetOXMName() string {
25878 return "bsn_in_ports_512_masked"
25879}
25880
25881func (self *OxmIdBsnInPorts512Masked) MarshalJSON() ([]byte, error) {
25882 if self.TypeLen == 0 {
25883 return []byte("\"\""), nil
25884 } else {
25885 return []byte("\"" + self.GetOXMName() + "\""), nil
25886 }
25887}
25888
25889type OxmIdBsnIngressPortGroupId struct {
25890 *OxmId
25891}
25892
25893type IOxmIdBsnIngressPortGroupId interface {
25894 IOxmId
25895}
25896
25897func (self *OxmIdBsnIngressPortGroupId) Serialize(encoder *goloxi.Encoder) error {
25898 if err := self.OxmId.Serialize(encoder); err != nil {
25899 return err
25900 }
25901
25902 return nil
25903}
25904
25905func DecodeOxmIdBsnIngressPortGroupId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnIngressPortGroupId, error) {
25906 _oxmidbsningressportgroupid := &OxmIdBsnIngressPortGroupId{OxmId: parent}
25907 return _oxmidbsningressportgroupid, nil
25908}
25909
25910func NewOxmIdBsnIngressPortGroupId() *OxmIdBsnIngressPortGroupId {
25911 obj := &OxmIdBsnIngressPortGroupId{
25912 OxmId: NewOxmId(206852),
25913 }
25914 return obj
25915}
25916func (self *OxmIdBsnIngressPortGroupId) GetOXMName() string {
25917 return "bsn_ingress_port_group_id"
25918}
25919
25920func (self *OxmIdBsnIngressPortGroupId) MarshalJSON() ([]byte, error) {
25921 if self.TypeLen == 0 {
25922 return []byte("\"\""), nil
25923 } else {
25924 return []byte("\"" + self.GetOXMName() + "\""), nil
25925 }
25926}
25927
25928type OxmIdBsnIngressPortGroupIdMasked struct {
25929 *OxmId
25930}
25931
25932type IOxmIdBsnIngressPortGroupIdMasked interface {
25933 IOxmId
25934}
25935
25936func (self *OxmIdBsnIngressPortGroupIdMasked) Serialize(encoder *goloxi.Encoder) error {
25937 if err := self.OxmId.Serialize(encoder); err != nil {
25938 return err
25939 }
25940
25941 return nil
25942}
25943
25944func DecodeOxmIdBsnIngressPortGroupIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnIngressPortGroupIdMasked, error) {
25945 _oxmidbsningressportgroupidmasked := &OxmIdBsnIngressPortGroupIdMasked{OxmId: parent}
25946 return _oxmidbsningressportgroupidmasked, nil
25947}
25948
25949func NewOxmIdBsnIngressPortGroupIdMasked() *OxmIdBsnIngressPortGroupIdMasked {
25950 obj := &OxmIdBsnIngressPortGroupIdMasked{
25951 OxmId: NewOxmId(207112),
25952 }
25953 return obj
25954}
25955func (self *OxmIdBsnIngressPortGroupIdMasked) GetOXMName() string {
25956 return "bsn_ingress_port_group_id_masked"
25957}
25958
25959func (self *OxmIdBsnIngressPortGroupIdMasked) MarshalJSON() ([]byte, error) {
25960 if self.TypeLen == 0 {
25961 return []byte("\"\""), nil
25962 } else {
25963 return []byte("\"" + self.GetOXMName() + "\""), nil
25964 }
25965}
25966
25967type OxmIdBsnInnerEthDst struct {
25968 *OxmId
25969}
25970
25971type IOxmIdBsnInnerEthDst interface {
25972 IOxmId
25973}
25974
25975func (self *OxmIdBsnInnerEthDst) Serialize(encoder *goloxi.Encoder) error {
25976 if err := self.OxmId.Serialize(encoder); err != nil {
25977 return err
25978 }
25979
25980 return nil
25981}
25982
25983func DecodeOxmIdBsnInnerEthDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInnerEthDst, error) {
25984 _oxmidbsninnerethdst := &OxmIdBsnInnerEthDst{OxmId: parent}
25985 return _oxmidbsninnerethdst, nil
25986}
25987
25988func NewOxmIdBsnInnerEthDst() *OxmIdBsnInnerEthDst {
25989 obj := &OxmIdBsnInnerEthDst{
25990 OxmId: NewOxmId(207878),
25991 }
25992 return obj
25993}
25994func (self *OxmIdBsnInnerEthDst) GetOXMName() string {
25995 return "bsn_inner_eth_dst"
25996}
25997
25998func (self *OxmIdBsnInnerEthDst) MarshalJSON() ([]byte, error) {
25999 if self.TypeLen == 0 {
26000 return []byte("\"\""), nil
26001 } else {
26002 return []byte("\"" + self.GetOXMName() + "\""), nil
26003 }
26004}
26005
26006type OxmIdBsnInnerEthDstMasked struct {
26007 *OxmId
26008}
26009
26010type IOxmIdBsnInnerEthDstMasked interface {
26011 IOxmId
26012}
26013
26014func (self *OxmIdBsnInnerEthDstMasked) Serialize(encoder *goloxi.Encoder) error {
26015 if err := self.OxmId.Serialize(encoder); err != nil {
26016 return err
26017 }
26018
26019 return nil
26020}
26021
26022func DecodeOxmIdBsnInnerEthDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInnerEthDstMasked, error) {
26023 _oxmidbsninnerethdstmasked := &OxmIdBsnInnerEthDstMasked{OxmId: parent}
26024 return _oxmidbsninnerethdstmasked, nil
26025}
26026
26027func NewOxmIdBsnInnerEthDstMasked() *OxmIdBsnInnerEthDstMasked {
26028 obj := &OxmIdBsnInnerEthDstMasked{
26029 OxmId: NewOxmId(208140),
26030 }
26031 return obj
26032}
26033func (self *OxmIdBsnInnerEthDstMasked) GetOXMName() string {
26034 return "bsn_inner_eth_dst_masked"
26035}
26036
26037func (self *OxmIdBsnInnerEthDstMasked) MarshalJSON() ([]byte, error) {
26038 if self.TypeLen == 0 {
26039 return []byte("\"\""), nil
26040 } else {
26041 return []byte("\"" + self.GetOXMName() + "\""), nil
26042 }
26043}
26044
26045type OxmIdBsnInnerEthSrc struct {
26046 *OxmId
26047}
26048
26049type IOxmIdBsnInnerEthSrc interface {
26050 IOxmId
26051}
26052
26053func (self *OxmIdBsnInnerEthSrc) Serialize(encoder *goloxi.Encoder) error {
26054 if err := self.OxmId.Serialize(encoder); err != nil {
26055 return err
26056 }
26057
26058 return nil
26059}
26060
26061func DecodeOxmIdBsnInnerEthSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInnerEthSrc, error) {
26062 _oxmidbsninnerethsrc := &OxmIdBsnInnerEthSrc{OxmId: parent}
26063 return _oxmidbsninnerethsrc, nil
26064}
26065
26066func NewOxmIdBsnInnerEthSrc() *OxmIdBsnInnerEthSrc {
26067 obj := &OxmIdBsnInnerEthSrc{
26068 OxmId: NewOxmId(208390),
26069 }
26070 return obj
26071}
26072func (self *OxmIdBsnInnerEthSrc) GetOXMName() string {
26073 return "bsn_inner_eth_src"
26074}
26075
26076func (self *OxmIdBsnInnerEthSrc) MarshalJSON() ([]byte, error) {
26077 if self.TypeLen == 0 {
26078 return []byte("\"\""), nil
26079 } else {
26080 return []byte("\"" + self.GetOXMName() + "\""), nil
26081 }
26082}
26083
26084type OxmIdBsnInnerEthSrcMasked struct {
26085 *OxmId
26086}
26087
26088type IOxmIdBsnInnerEthSrcMasked interface {
26089 IOxmId
26090}
26091
26092func (self *OxmIdBsnInnerEthSrcMasked) Serialize(encoder *goloxi.Encoder) error {
26093 if err := self.OxmId.Serialize(encoder); err != nil {
26094 return err
26095 }
26096
26097 return nil
26098}
26099
26100func DecodeOxmIdBsnInnerEthSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInnerEthSrcMasked, error) {
26101 _oxmidbsninnerethsrcmasked := &OxmIdBsnInnerEthSrcMasked{OxmId: parent}
26102 return _oxmidbsninnerethsrcmasked, nil
26103}
26104
26105func NewOxmIdBsnInnerEthSrcMasked() *OxmIdBsnInnerEthSrcMasked {
26106 obj := &OxmIdBsnInnerEthSrcMasked{
26107 OxmId: NewOxmId(208652),
26108 }
26109 return obj
26110}
26111func (self *OxmIdBsnInnerEthSrcMasked) GetOXMName() string {
26112 return "bsn_inner_eth_src_masked"
26113}
26114
26115func (self *OxmIdBsnInnerEthSrcMasked) MarshalJSON() ([]byte, error) {
26116 if self.TypeLen == 0 {
26117 return []byte("\"\""), nil
26118 } else {
26119 return []byte("\"" + self.GetOXMName() + "\""), nil
26120 }
26121}
26122
26123type OxmIdBsnInnerVlanVid struct {
26124 *OxmId
26125}
26126
26127type IOxmIdBsnInnerVlanVid interface {
26128 IOxmId
26129}
26130
26131func (self *OxmIdBsnInnerVlanVid) Serialize(encoder *goloxi.Encoder) error {
26132 if err := self.OxmId.Serialize(encoder); err != nil {
26133 return err
26134 }
26135
26136 return nil
26137}
26138
26139func DecodeOxmIdBsnInnerVlanVid(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInnerVlanVid, error) {
26140 _oxmidbsninnervlanvid := &OxmIdBsnInnerVlanVid{OxmId: parent}
26141 return _oxmidbsninnervlanvid, nil
26142}
26143
26144func NewOxmIdBsnInnerVlanVid() *OxmIdBsnInnerVlanVid {
26145 obj := &OxmIdBsnInnerVlanVid{
26146 OxmId: NewOxmId(208898),
26147 }
26148 return obj
26149}
26150func (self *OxmIdBsnInnerVlanVid) GetOXMName() string {
26151 return "bsn_inner_vlan_vid"
26152}
26153
26154func (self *OxmIdBsnInnerVlanVid) MarshalJSON() ([]byte, error) {
26155 if self.TypeLen == 0 {
26156 return []byte("\"\""), nil
26157 } else {
26158 return []byte("\"" + self.GetOXMName() + "\""), nil
26159 }
26160}
26161
26162type OxmIdBsnInnerVlanVidMasked struct {
26163 *OxmId
26164}
26165
26166type IOxmIdBsnInnerVlanVidMasked interface {
26167 IOxmId
26168}
26169
26170func (self *OxmIdBsnInnerVlanVidMasked) Serialize(encoder *goloxi.Encoder) error {
26171 if err := self.OxmId.Serialize(encoder); err != nil {
26172 return err
26173 }
26174
26175 return nil
26176}
26177
26178func DecodeOxmIdBsnInnerVlanVidMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInnerVlanVidMasked, error) {
26179 _oxmidbsninnervlanvidmasked := &OxmIdBsnInnerVlanVidMasked{OxmId: parent}
26180 return _oxmidbsninnervlanvidmasked, nil
26181}
26182
26183func NewOxmIdBsnInnerVlanVidMasked() *OxmIdBsnInnerVlanVidMasked {
26184 obj := &OxmIdBsnInnerVlanVidMasked{
26185 OxmId: NewOxmId(209156),
26186 }
26187 return obj
26188}
26189func (self *OxmIdBsnInnerVlanVidMasked) GetOXMName() string {
26190 return "bsn_inner_vlan_vid_masked"
26191}
26192
26193func (self *OxmIdBsnInnerVlanVidMasked) MarshalJSON() ([]byte, error) {
26194 if self.TypeLen == 0 {
26195 return []byte("\"\""), nil
26196 } else {
26197 return []byte("\"" + self.GetOXMName() + "\""), nil
26198 }
26199}
26200
26201type OxmIdBsnIpFragmentation struct {
26202 *OxmId
26203}
26204
26205type IOxmIdBsnIpFragmentation interface {
26206 IOxmId
26207}
26208
26209func (self *OxmIdBsnIpFragmentation) Serialize(encoder *goloxi.Encoder) error {
26210 if err := self.OxmId.Serialize(encoder); err != nil {
26211 return err
26212 }
26213
26214 return nil
26215}
26216
26217func DecodeOxmIdBsnIpFragmentation(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnIpFragmentation, error) {
26218 _oxmidbsnipfragmentation := &OxmIdBsnIpFragmentation{OxmId: parent}
26219 return _oxmidbsnipfragmentation, nil
26220}
26221
26222func NewOxmIdBsnIpFragmentation() *OxmIdBsnIpFragmentation {
26223 obj := &OxmIdBsnIpFragmentation{
26224 OxmId: NewOxmId(209921),
26225 }
26226 return obj
26227}
26228func (self *OxmIdBsnIpFragmentation) GetOXMName() string {
26229 return "bsn_ip_fragmentation"
26230}
26231
26232func (self *OxmIdBsnIpFragmentation) MarshalJSON() ([]byte, error) {
26233 if self.TypeLen == 0 {
26234 return []byte("\"\""), nil
26235 } else {
26236 return []byte("\"" + self.GetOXMName() + "\""), nil
26237 }
26238}
26239
26240type OxmIdBsnIpFragmentationMasked struct {
26241 *OxmId
26242}
26243
26244type IOxmIdBsnIpFragmentationMasked interface {
26245 IOxmId
26246}
26247
26248func (self *OxmIdBsnIpFragmentationMasked) Serialize(encoder *goloxi.Encoder) error {
26249 if err := self.OxmId.Serialize(encoder); err != nil {
26250 return err
26251 }
26252
26253 return nil
26254}
26255
26256func DecodeOxmIdBsnIpFragmentationMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnIpFragmentationMasked, error) {
26257 _oxmidbsnipfragmentationmasked := &OxmIdBsnIpFragmentationMasked{OxmId: parent}
26258 return _oxmidbsnipfragmentationmasked, nil
26259}
26260
26261func NewOxmIdBsnIpFragmentationMasked() *OxmIdBsnIpFragmentationMasked {
26262 obj := &OxmIdBsnIpFragmentationMasked{
26263 OxmId: NewOxmId(210178),
26264 }
26265 return obj
26266}
26267func (self *OxmIdBsnIpFragmentationMasked) GetOXMName() string {
26268 return "bsn_ip_fragmentation_masked"
26269}
26270
26271func (self *OxmIdBsnIpFragmentationMasked) MarshalJSON() ([]byte, error) {
26272 if self.TypeLen == 0 {
26273 return []byte("\"\""), nil
26274 } else {
26275 return []byte("\"" + self.GetOXMName() + "\""), nil
26276 }
26277}
26278
26279type OxmIdBsnL2CacheHit struct {
26280 *OxmId
26281}
26282
26283type IOxmIdBsnL2CacheHit interface {
26284 IOxmId
26285}
26286
26287func (self *OxmIdBsnL2CacheHit) Serialize(encoder *goloxi.Encoder) error {
26288 if err := self.OxmId.Serialize(encoder); err != nil {
26289 return err
26290 }
26291
26292 return nil
26293}
26294
26295func DecodeOxmIdBsnL2CacheHit(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL2CacheHit, error) {
26296 _oxmidbsnl2cachehit := &OxmIdBsnL2CacheHit{OxmId: parent}
26297 return _oxmidbsnl2cachehit, nil
26298}
26299
26300func NewOxmIdBsnL2CacheHit() *OxmIdBsnL2CacheHit {
26301 obj := &OxmIdBsnL2CacheHit{
26302 OxmId: NewOxmId(205825),
26303 }
26304 return obj
26305}
26306func (self *OxmIdBsnL2CacheHit) GetOXMName() string {
26307 return "bsn_l2_cache_hit"
26308}
26309
26310func (self *OxmIdBsnL2CacheHit) MarshalJSON() ([]byte, error) {
26311 if self.TypeLen == 0 {
26312 return []byte("\"\""), nil
26313 } else {
26314 return []byte("\"" + self.GetOXMName() + "\""), nil
26315 }
26316}
26317
26318type OxmIdBsnL2CacheHitMasked struct {
26319 *OxmId
26320}
26321
26322type IOxmIdBsnL2CacheHitMasked interface {
26323 IOxmId
26324}
26325
26326func (self *OxmIdBsnL2CacheHitMasked) Serialize(encoder *goloxi.Encoder) error {
26327 if err := self.OxmId.Serialize(encoder); err != nil {
26328 return err
26329 }
26330
26331 return nil
26332}
26333
26334func DecodeOxmIdBsnL2CacheHitMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL2CacheHitMasked, error) {
26335 _oxmidbsnl2cachehitmasked := &OxmIdBsnL2CacheHitMasked{OxmId: parent}
26336 return _oxmidbsnl2cachehitmasked, nil
26337}
26338
26339func NewOxmIdBsnL2CacheHitMasked() *OxmIdBsnL2CacheHitMasked {
26340 obj := &OxmIdBsnL2CacheHitMasked{
26341 OxmId: NewOxmId(206082),
26342 }
26343 return obj
26344}
26345func (self *OxmIdBsnL2CacheHitMasked) GetOXMName() string {
26346 return "bsn_l2_cache_hit_masked"
26347}
26348
26349func (self *OxmIdBsnL2CacheHitMasked) MarshalJSON() ([]byte, error) {
26350 if self.TypeLen == 0 {
26351 return []byte("\"\""), nil
26352 } else {
26353 return []byte("\"" + self.GetOXMName() + "\""), nil
26354 }
26355}
26356
26357type OxmIdBsnL3DstClassId struct {
26358 *OxmId
26359}
26360
26361type IOxmIdBsnL3DstClassId interface {
26362 IOxmId
26363}
26364
26365func (self *OxmIdBsnL3DstClassId) Serialize(encoder *goloxi.Encoder) error {
26366 if err := self.OxmId.Serialize(encoder); err != nil {
26367 return err
26368 }
26369
26370 return nil
26371}
26372
26373func DecodeOxmIdBsnL3DstClassId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL3DstClassId, error) {
26374 _oxmidbsnl3dstclassid := &OxmIdBsnL3DstClassId{OxmId: parent}
26375 return _oxmidbsnl3dstclassid, nil
26376}
26377
26378func NewOxmIdBsnL3DstClassId() *OxmIdBsnL3DstClassId {
26379 obj := &OxmIdBsnL3DstClassId{
26380 OxmId: NewOxmId(199684),
26381 }
26382 return obj
26383}
26384func (self *OxmIdBsnL3DstClassId) GetOXMName() string {
26385 return "bsn_l3_dst_class_id"
26386}
26387
26388func (self *OxmIdBsnL3DstClassId) MarshalJSON() ([]byte, error) {
26389 if self.TypeLen == 0 {
26390 return []byte("\"\""), nil
26391 } else {
26392 return []byte("\"" + self.GetOXMName() + "\""), nil
26393 }
26394}
26395
26396type OxmIdBsnL3DstClassIdMasked struct {
26397 *OxmId
26398}
26399
26400type IOxmIdBsnL3DstClassIdMasked interface {
26401 IOxmId
26402}
26403
26404func (self *OxmIdBsnL3DstClassIdMasked) Serialize(encoder *goloxi.Encoder) error {
26405 if err := self.OxmId.Serialize(encoder); err != nil {
26406 return err
26407 }
26408
26409 return nil
26410}
26411
26412func DecodeOxmIdBsnL3DstClassIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL3DstClassIdMasked, error) {
26413 _oxmidbsnl3dstclassidmasked := &OxmIdBsnL3DstClassIdMasked{OxmId: parent}
26414 return _oxmidbsnl3dstclassidmasked, nil
26415}
26416
26417func NewOxmIdBsnL3DstClassIdMasked() *OxmIdBsnL3DstClassIdMasked {
26418 obj := &OxmIdBsnL3DstClassIdMasked{
26419 OxmId: NewOxmId(199944),
26420 }
26421 return obj
26422}
26423func (self *OxmIdBsnL3DstClassIdMasked) GetOXMName() string {
26424 return "bsn_l3_dst_class_id_masked"
26425}
26426
26427func (self *OxmIdBsnL3DstClassIdMasked) MarshalJSON() ([]byte, error) {
26428 if self.TypeLen == 0 {
26429 return []byte("\"\""), nil
26430 } else {
26431 return []byte("\"" + self.GetOXMName() + "\""), nil
26432 }
26433}
26434
26435type OxmIdBsnL3InterfaceClassId struct {
26436 *OxmId
26437}
26438
26439type IOxmIdBsnL3InterfaceClassId interface {
26440 IOxmId
26441}
26442
26443func (self *OxmIdBsnL3InterfaceClassId) Serialize(encoder *goloxi.Encoder) error {
26444 if err := self.OxmId.Serialize(encoder); err != nil {
26445 return err
26446 }
26447
26448 return nil
26449}
26450
26451func DecodeOxmIdBsnL3InterfaceClassId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL3InterfaceClassId, error) {
26452 _oxmidbsnl3interfaceclassid := &OxmIdBsnL3InterfaceClassId{OxmId: parent}
26453 return _oxmidbsnl3interfaceclassid, nil
26454}
26455
26456func NewOxmIdBsnL3InterfaceClassId() *OxmIdBsnL3InterfaceClassId {
26457 obj := &OxmIdBsnL3InterfaceClassId{
26458 OxmId: NewOxmId(198660),
26459 }
26460 return obj
26461}
26462func (self *OxmIdBsnL3InterfaceClassId) GetOXMName() string {
26463 return "bsn_l3_interface_class_id"
26464}
26465
26466func (self *OxmIdBsnL3InterfaceClassId) MarshalJSON() ([]byte, error) {
26467 if self.TypeLen == 0 {
26468 return []byte("\"\""), nil
26469 } else {
26470 return []byte("\"" + self.GetOXMName() + "\""), nil
26471 }
26472}
26473
26474type OxmIdBsnL3InterfaceClassIdMasked struct {
26475 *OxmId
26476}
26477
26478type IOxmIdBsnL3InterfaceClassIdMasked interface {
26479 IOxmId
26480}
26481
26482func (self *OxmIdBsnL3InterfaceClassIdMasked) Serialize(encoder *goloxi.Encoder) error {
26483 if err := self.OxmId.Serialize(encoder); err != nil {
26484 return err
26485 }
26486
26487 return nil
26488}
26489
26490func DecodeOxmIdBsnL3InterfaceClassIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL3InterfaceClassIdMasked, error) {
26491 _oxmidbsnl3interfaceclassidmasked := &OxmIdBsnL3InterfaceClassIdMasked{OxmId: parent}
26492 return _oxmidbsnl3interfaceclassidmasked, nil
26493}
26494
26495func NewOxmIdBsnL3InterfaceClassIdMasked() *OxmIdBsnL3InterfaceClassIdMasked {
26496 obj := &OxmIdBsnL3InterfaceClassIdMasked{
26497 OxmId: NewOxmId(198920),
26498 }
26499 return obj
26500}
26501func (self *OxmIdBsnL3InterfaceClassIdMasked) GetOXMName() string {
26502 return "bsn_l3_interface_class_id_masked"
26503}
26504
26505func (self *OxmIdBsnL3InterfaceClassIdMasked) MarshalJSON() ([]byte, error) {
26506 if self.TypeLen == 0 {
26507 return []byte("\"\""), nil
26508 } else {
26509 return []byte("\"" + self.GetOXMName() + "\""), nil
26510 }
26511}
26512
26513type OxmIdBsnL3SrcClassId struct {
26514 *OxmId
26515}
26516
26517type IOxmIdBsnL3SrcClassId interface {
26518 IOxmId
26519}
26520
26521func (self *OxmIdBsnL3SrcClassId) Serialize(encoder *goloxi.Encoder) error {
26522 if err := self.OxmId.Serialize(encoder); err != nil {
26523 return err
26524 }
26525
26526 return nil
26527}
26528
26529func DecodeOxmIdBsnL3SrcClassId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL3SrcClassId, error) {
26530 _oxmidbsnl3srcclassid := &OxmIdBsnL3SrcClassId{OxmId: parent}
26531 return _oxmidbsnl3srcclassid, nil
26532}
26533
26534func NewOxmIdBsnL3SrcClassId() *OxmIdBsnL3SrcClassId {
26535 obj := &OxmIdBsnL3SrcClassId{
26536 OxmId: NewOxmId(199172),
26537 }
26538 return obj
26539}
26540func (self *OxmIdBsnL3SrcClassId) GetOXMName() string {
26541 return "bsn_l3_src_class_id"
26542}
26543
26544func (self *OxmIdBsnL3SrcClassId) MarshalJSON() ([]byte, error) {
26545 if self.TypeLen == 0 {
26546 return []byte("\"\""), nil
26547 } else {
26548 return []byte("\"" + self.GetOXMName() + "\""), nil
26549 }
26550}
26551
26552type OxmIdBsnL3SrcClassIdMasked struct {
26553 *OxmId
26554}
26555
26556type IOxmIdBsnL3SrcClassIdMasked interface {
26557 IOxmId
26558}
26559
26560func (self *OxmIdBsnL3SrcClassIdMasked) Serialize(encoder *goloxi.Encoder) error {
26561 if err := self.OxmId.Serialize(encoder); err != nil {
26562 return err
26563 }
26564
26565 return nil
26566}
26567
26568func DecodeOxmIdBsnL3SrcClassIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL3SrcClassIdMasked, error) {
26569 _oxmidbsnl3srcclassidmasked := &OxmIdBsnL3SrcClassIdMasked{OxmId: parent}
26570 return _oxmidbsnl3srcclassidmasked, nil
26571}
26572
26573func NewOxmIdBsnL3SrcClassIdMasked() *OxmIdBsnL3SrcClassIdMasked {
26574 obj := &OxmIdBsnL3SrcClassIdMasked{
26575 OxmId: NewOxmId(199432),
26576 }
26577 return obj
26578}
26579func (self *OxmIdBsnL3SrcClassIdMasked) GetOXMName() string {
26580 return "bsn_l3_src_class_id_masked"
26581}
26582
26583func (self *OxmIdBsnL3SrcClassIdMasked) MarshalJSON() ([]byte, error) {
26584 if self.TypeLen == 0 {
26585 return []byte("\"\""), nil
26586 } else {
26587 return []byte("\"" + self.GetOXMName() + "\""), nil
26588 }
26589}
26590
26591type OxmIdBsnLagId struct {
26592 *OxmId
26593}
26594
26595type IOxmIdBsnLagId interface {
26596 IOxmId
26597}
26598
26599func (self *OxmIdBsnLagId) Serialize(encoder *goloxi.Encoder) error {
26600 if err := self.OxmId.Serialize(encoder); err != nil {
26601 return err
26602 }
26603
26604 return nil
26605}
26606
26607func DecodeOxmIdBsnLagId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnLagId, error) {
26608 _oxmidbsnlagid := &OxmIdBsnLagId{OxmId: parent}
26609 return _oxmidbsnlagid, nil
26610}
26611
26612func NewOxmIdBsnLagId() *OxmIdBsnLagId {
26613 obj := &OxmIdBsnLagId{
26614 OxmId: NewOxmId(197124),
26615 }
26616 return obj
26617}
26618func (self *OxmIdBsnLagId) GetOXMName() string {
26619 return "bsn_lag_id"
26620}
26621
26622func (self *OxmIdBsnLagId) MarshalJSON() ([]byte, error) {
26623 if self.TypeLen == 0 {
26624 return []byte("\"\""), nil
26625 } else {
26626 return []byte("\"" + self.GetOXMName() + "\""), nil
26627 }
26628}
26629
26630type OxmIdBsnLagIdMasked struct {
26631 *OxmId
26632}
26633
26634type IOxmIdBsnLagIdMasked interface {
26635 IOxmId
26636}
26637
26638func (self *OxmIdBsnLagIdMasked) Serialize(encoder *goloxi.Encoder) error {
26639 if err := self.OxmId.Serialize(encoder); err != nil {
26640 return err
26641 }
26642
26643 return nil
26644}
26645
26646func DecodeOxmIdBsnLagIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnLagIdMasked, error) {
26647 _oxmidbsnlagidmasked := &OxmIdBsnLagIdMasked{OxmId: parent}
26648 return _oxmidbsnlagidmasked, nil
26649}
26650
26651func NewOxmIdBsnLagIdMasked() *OxmIdBsnLagIdMasked {
26652 obj := &OxmIdBsnLagIdMasked{
26653 OxmId: NewOxmId(197384),
26654 }
26655 return obj
26656}
26657func (self *OxmIdBsnLagIdMasked) GetOXMName() string {
26658 return "bsn_lag_id_masked"
26659}
26660
26661func (self *OxmIdBsnLagIdMasked) MarshalJSON() ([]byte, error) {
26662 if self.TypeLen == 0 {
26663 return []byte("\"\""), nil
26664 } else {
26665 return []byte("\"" + self.GetOXMName() + "\""), nil
26666 }
26667}
26668
26669type OxmIdBsnTcpFlags struct {
26670 *OxmId
26671}
26672
26673type IOxmIdBsnTcpFlags interface {
26674 IOxmId
26675}
26676
26677func (self *OxmIdBsnTcpFlags) Serialize(encoder *goloxi.Encoder) error {
26678 if err := self.OxmId.Serialize(encoder); err != nil {
26679 return err
26680 }
26681
26682 return nil
26683}
26684
26685func DecodeOxmIdBsnTcpFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnTcpFlags, error) {
26686 _oxmidbsntcpflags := &OxmIdBsnTcpFlags{OxmId: parent}
26687 return _oxmidbsntcpflags, nil
26688}
26689
26690func NewOxmIdBsnTcpFlags() *OxmIdBsnTcpFlags {
26691 obj := &OxmIdBsnTcpFlags{
26692 OxmId: NewOxmId(204802),
26693 }
26694 return obj
26695}
26696func (self *OxmIdBsnTcpFlags) GetOXMName() string {
26697 return "bsn_tcp_flags"
26698}
26699
26700func (self *OxmIdBsnTcpFlags) MarshalJSON() ([]byte, error) {
26701 if self.TypeLen == 0 {
26702 return []byte("\"\""), nil
26703 } else {
26704 return []byte("\"" + self.GetOXMName() + "\""), nil
26705 }
26706}
26707
26708type OxmIdBsnTcpFlagsMasked struct {
26709 *OxmId
26710}
26711
26712type IOxmIdBsnTcpFlagsMasked interface {
26713 IOxmId
26714}
26715
26716func (self *OxmIdBsnTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
26717 if err := self.OxmId.Serialize(encoder); err != nil {
26718 return err
26719 }
26720
26721 return nil
26722}
26723
26724func DecodeOxmIdBsnTcpFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnTcpFlagsMasked, error) {
26725 _oxmidbsntcpflagsmasked := &OxmIdBsnTcpFlagsMasked{OxmId: parent}
26726 return _oxmidbsntcpflagsmasked, nil
26727}
26728
26729func NewOxmIdBsnTcpFlagsMasked() *OxmIdBsnTcpFlagsMasked {
26730 obj := &OxmIdBsnTcpFlagsMasked{
26731 OxmId: NewOxmId(205060),
26732 }
26733 return obj
26734}
26735func (self *OxmIdBsnTcpFlagsMasked) GetOXMName() string {
26736 return "bsn_tcp_flags_masked"
26737}
26738
26739func (self *OxmIdBsnTcpFlagsMasked) MarshalJSON() ([]byte, error) {
26740 if self.TypeLen == 0 {
26741 return []byte("\"\""), nil
26742 } else {
26743 return []byte("\"" + self.GetOXMName() + "\""), nil
26744 }
26745}
26746
26747type OxmIdBsnUdf0 struct {
26748 *OxmId
26749}
26750
26751type IOxmIdBsnUdf0 interface {
26752 IOxmId
26753}
26754
26755func (self *OxmIdBsnUdf0) Serialize(encoder *goloxi.Encoder) error {
26756 if err := self.OxmId.Serialize(encoder); err != nil {
26757 return err
26758 }
26759
26760 return nil
26761}
26762
26763func DecodeOxmIdBsnUdf0(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf0, error) {
26764 _oxmidbsnudf0 := &OxmIdBsnUdf0{OxmId: parent}
26765 return _oxmidbsnudf0, nil
26766}
26767
26768func NewOxmIdBsnUdf0() *OxmIdBsnUdf0 {
26769 obj := &OxmIdBsnUdf0{
26770 OxmId: NewOxmId(200708),
26771 }
26772 return obj
26773}
26774func (self *OxmIdBsnUdf0) GetOXMName() string {
26775 return "bsn_udf0"
26776}
26777
26778func (self *OxmIdBsnUdf0) MarshalJSON() ([]byte, error) {
26779 if self.TypeLen == 0 {
26780 return []byte("\"\""), nil
26781 } else {
26782 return []byte("\"" + self.GetOXMName() + "\""), nil
26783 }
26784}
26785
26786type OxmIdBsnUdf0Masked struct {
26787 *OxmId
26788}
26789
26790type IOxmIdBsnUdf0Masked interface {
26791 IOxmId
26792}
26793
26794func (self *OxmIdBsnUdf0Masked) Serialize(encoder *goloxi.Encoder) error {
26795 if err := self.OxmId.Serialize(encoder); err != nil {
26796 return err
26797 }
26798
26799 return nil
26800}
26801
26802func DecodeOxmIdBsnUdf0Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf0Masked, error) {
26803 _oxmidbsnudf0masked := &OxmIdBsnUdf0Masked{OxmId: parent}
26804 return _oxmidbsnudf0masked, nil
26805}
26806
26807func NewOxmIdBsnUdf0Masked() *OxmIdBsnUdf0Masked {
26808 obj := &OxmIdBsnUdf0Masked{
26809 OxmId: NewOxmId(200968),
26810 }
26811 return obj
26812}
26813func (self *OxmIdBsnUdf0Masked) GetOXMName() string {
26814 return "bsn_udf0_masked"
26815}
26816
26817func (self *OxmIdBsnUdf0Masked) MarshalJSON() ([]byte, error) {
26818 if self.TypeLen == 0 {
26819 return []byte("\"\""), nil
26820 } else {
26821 return []byte("\"" + self.GetOXMName() + "\""), nil
26822 }
26823}
26824
26825type OxmIdBsnUdf1 struct {
26826 *OxmId
26827}
26828
26829type IOxmIdBsnUdf1 interface {
26830 IOxmId
26831}
26832
26833func (self *OxmIdBsnUdf1) Serialize(encoder *goloxi.Encoder) error {
26834 if err := self.OxmId.Serialize(encoder); err != nil {
26835 return err
26836 }
26837
26838 return nil
26839}
26840
26841func DecodeOxmIdBsnUdf1(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf1, error) {
26842 _oxmidbsnudf1 := &OxmIdBsnUdf1{OxmId: parent}
26843 return _oxmidbsnudf1, nil
26844}
26845
26846func NewOxmIdBsnUdf1() *OxmIdBsnUdf1 {
26847 obj := &OxmIdBsnUdf1{
26848 OxmId: NewOxmId(201220),
26849 }
26850 return obj
26851}
26852func (self *OxmIdBsnUdf1) GetOXMName() string {
26853 return "bsn_udf1"
26854}
26855
26856func (self *OxmIdBsnUdf1) MarshalJSON() ([]byte, error) {
26857 if self.TypeLen == 0 {
26858 return []byte("\"\""), nil
26859 } else {
26860 return []byte("\"" + self.GetOXMName() + "\""), nil
26861 }
26862}
26863
26864type OxmIdBsnUdf1Masked struct {
26865 *OxmId
26866}
26867
26868type IOxmIdBsnUdf1Masked interface {
26869 IOxmId
26870}
26871
26872func (self *OxmIdBsnUdf1Masked) Serialize(encoder *goloxi.Encoder) error {
26873 if err := self.OxmId.Serialize(encoder); err != nil {
26874 return err
26875 }
26876
26877 return nil
26878}
26879
26880func DecodeOxmIdBsnUdf1Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf1Masked, error) {
26881 _oxmidbsnudf1masked := &OxmIdBsnUdf1Masked{OxmId: parent}
26882 return _oxmidbsnudf1masked, nil
26883}
26884
26885func NewOxmIdBsnUdf1Masked() *OxmIdBsnUdf1Masked {
26886 obj := &OxmIdBsnUdf1Masked{
26887 OxmId: NewOxmId(201480),
26888 }
26889 return obj
26890}
26891func (self *OxmIdBsnUdf1Masked) GetOXMName() string {
26892 return "bsn_udf1_masked"
26893}
26894
26895func (self *OxmIdBsnUdf1Masked) MarshalJSON() ([]byte, error) {
26896 if self.TypeLen == 0 {
26897 return []byte("\"\""), nil
26898 } else {
26899 return []byte("\"" + self.GetOXMName() + "\""), nil
26900 }
26901}
26902
26903type OxmIdBsnUdf2 struct {
26904 *OxmId
26905}
26906
26907type IOxmIdBsnUdf2 interface {
26908 IOxmId
26909}
26910
26911func (self *OxmIdBsnUdf2) Serialize(encoder *goloxi.Encoder) error {
26912 if err := self.OxmId.Serialize(encoder); err != nil {
26913 return err
26914 }
26915
26916 return nil
26917}
26918
26919func DecodeOxmIdBsnUdf2(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf2, error) {
26920 _oxmidbsnudf2 := &OxmIdBsnUdf2{OxmId: parent}
26921 return _oxmidbsnudf2, nil
26922}
26923
26924func NewOxmIdBsnUdf2() *OxmIdBsnUdf2 {
26925 obj := &OxmIdBsnUdf2{
26926 OxmId: NewOxmId(201732),
26927 }
26928 return obj
26929}
26930func (self *OxmIdBsnUdf2) GetOXMName() string {
26931 return "bsn_udf2"
26932}
26933
26934func (self *OxmIdBsnUdf2) MarshalJSON() ([]byte, error) {
26935 if self.TypeLen == 0 {
26936 return []byte("\"\""), nil
26937 } else {
26938 return []byte("\"" + self.GetOXMName() + "\""), nil
26939 }
26940}
26941
26942type OxmIdBsnUdf2Masked struct {
26943 *OxmId
26944}
26945
26946type IOxmIdBsnUdf2Masked interface {
26947 IOxmId
26948}
26949
26950func (self *OxmIdBsnUdf2Masked) Serialize(encoder *goloxi.Encoder) error {
26951 if err := self.OxmId.Serialize(encoder); err != nil {
26952 return err
26953 }
26954
26955 return nil
26956}
26957
26958func DecodeOxmIdBsnUdf2Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf2Masked, error) {
26959 _oxmidbsnudf2masked := &OxmIdBsnUdf2Masked{OxmId: parent}
26960 return _oxmidbsnudf2masked, nil
26961}
26962
26963func NewOxmIdBsnUdf2Masked() *OxmIdBsnUdf2Masked {
26964 obj := &OxmIdBsnUdf2Masked{
26965 OxmId: NewOxmId(201992),
26966 }
26967 return obj
26968}
26969func (self *OxmIdBsnUdf2Masked) GetOXMName() string {
26970 return "bsn_udf2_masked"
26971}
26972
26973func (self *OxmIdBsnUdf2Masked) MarshalJSON() ([]byte, error) {
26974 if self.TypeLen == 0 {
26975 return []byte("\"\""), nil
26976 } else {
26977 return []byte("\"" + self.GetOXMName() + "\""), nil
26978 }
26979}
26980
26981type OxmIdBsnUdf3 struct {
26982 *OxmId
26983}
26984
26985type IOxmIdBsnUdf3 interface {
26986 IOxmId
26987}
26988
26989func (self *OxmIdBsnUdf3) Serialize(encoder *goloxi.Encoder) error {
26990 if err := self.OxmId.Serialize(encoder); err != nil {
26991 return err
26992 }
26993
26994 return nil
26995}
26996
26997func DecodeOxmIdBsnUdf3(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf3, error) {
26998 _oxmidbsnudf3 := &OxmIdBsnUdf3{OxmId: parent}
26999 return _oxmidbsnudf3, nil
27000}
27001
27002func NewOxmIdBsnUdf3() *OxmIdBsnUdf3 {
27003 obj := &OxmIdBsnUdf3{
27004 OxmId: NewOxmId(202244),
27005 }
27006 return obj
27007}
27008func (self *OxmIdBsnUdf3) GetOXMName() string {
27009 return "bsn_udf3"
27010}
27011
27012func (self *OxmIdBsnUdf3) MarshalJSON() ([]byte, error) {
27013 if self.TypeLen == 0 {
27014 return []byte("\"\""), nil
27015 } else {
27016 return []byte("\"" + self.GetOXMName() + "\""), nil
27017 }
27018}
27019
27020type OxmIdBsnUdf3Masked struct {
27021 *OxmId
27022}
27023
27024type IOxmIdBsnUdf3Masked interface {
27025 IOxmId
27026}
27027
27028func (self *OxmIdBsnUdf3Masked) Serialize(encoder *goloxi.Encoder) error {
27029 if err := self.OxmId.Serialize(encoder); err != nil {
27030 return err
27031 }
27032
27033 return nil
27034}
27035
27036func DecodeOxmIdBsnUdf3Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf3Masked, error) {
27037 _oxmidbsnudf3masked := &OxmIdBsnUdf3Masked{OxmId: parent}
27038 return _oxmidbsnudf3masked, nil
27039}
27040
27041func NewOxmIdBsnUdf3Masked() *OxmIdBsnUdf3Masked {
27042 obj := &OxmIdBsnUdf3Masked{
27043 OxmId: NewOxmId(202504),
27044 }
27045 return obj
27046}
27047func (self *OxmIdBsnUdf3Masked) GetOXMName() string {
27048 return "bsn_udf3_masked"
27049}
27050
27051func (self *OxmIdBsnUdf3Masked) MarshalJSON() ([]byte, error) {
27052 if self.TypeLen == 0 {
27053 return []byte("\"\""), nil
27054 } else {
27055 return []byte("\"" + self.GetOXMName() + "\""), nil
27056 }
27057}
27058
27059type OxmIdBsnUdf4 struct {
27060 *OxmId
27061}
27062
27063type IOxmIdBsnUdf4 interface {
27064 IOxmId
27065}
27066
27067func (self *OxmIdBsnUdf4) Serialize(encoder *goloxi.Encoder) error {
27068 if err := self.OxmId.Serialize(encoder); err != nil {
27069 return err
27070 }
27071
27072 return nil
27073}
27074
27075func DecodeOxmIdBsnUdf4(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf4, error) {
27076 _oxmidbsnudf4 := &OxmIdBsnUdf4{OxmId: parent}
27077 return _oxmidbsnudf4, nil
27078}
27079
27080func NewOxmIdBsnUdf4() *OxmIdBsnUdf4 {
27081 obj := &OxmIdBsnUdf4{
27082 OxmId: NewOxmId(202756),
27083 }
27084 return obj
27085}
27086func (self *OxmIdBsnUdf4) GetOXMName() string {
27087 return "bsn_udf4"
27088}
27089
27090func (self *OxmIdBsnUdf4) MarshalJSON() ([]byte, error) {
27091 if self.TypeLen == 0 {
27092 return []byte("\"\""), nil
27093 } else {
27094 return []byte("\"" + self.GetOXMName() + "\""), nil
27095 }
27096}
27097
27098type OxmIdBsnUdf4Masked struct {
27099 *OxmId
27100}
27101
27102type IOxmIdBsnUdf4Masked interface {
27103 IOxmId
27104}
27105
27106func (self *OxmIdBsnUdf4Masked) Serialize(encoder *goloxi.Encoder) error {
27107 if err := self.OxmId.Serialize(encoder); err != nil {
27108 return err
27109 }
27110
27111 return nil
27112}
27113
27114func DecodeOxmIdBsnUdf4Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf4Masked, error) {
27115 _oxmidbsnudf4masked := &OxmIdBsnUdf4Masked{OxmId: parent}
27116 return _oxmidbsnudf4masked, nil
27117}
27118
27119func NewOxmIdBsnUdf4Masked() *OxmIdBsnUdf4Masked {
27120 obj := &OxmIdBsnUdf4Masked{
27121 OxmId: NewOxmId(203016),
27122 }
27123 return obj
27124}
27125func (self *OxmIdBsnUdf4Masked) GetOXMName() string {
27126 return "bsn_udf4_masked"
27127}
27128
27129func (self *OxmIdBsnUdf4Masked) MarshalJSON() ([]byte, error) {
27130 if self.TypeLen == 0 {
27131 return []byte("\"\""), nil
27132 } else {
27133 return []byte("\"" + self.GetOXMName() + "\""), nil
27134 }
27135}
27136
27137type OxmIdBsnUdf5 struct {
27138 *OxmId
27139}
27140
27141type IOxmIdBsnUdf5 interface {
27142 IOxmId
27143}
27144
27145func (self *OxmIdBsnUdf5) Serialize(encoder *goloxi.Encoder) error {
27146 if err := self.OxmId.Serialize(encoder); err != nil {
27147 return err
27148 }
27149
27150 return nil
27151}
27152
27153func DecodeOxmIdBsnUdf5(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf5, error) {
27154 _oxmidbsnudf5 := &OxmIdBsnUdf5{OxmId: parent}
27155 return _oxmidbsnudf5, nil
27156}
27157
27158func NewOxmIdBsnUdf5() *OxmIdBsnUdf5 {
27159 obj := &OxmIdBsnUdf5{
27160 OxmId: NewOxmId(203268),
27161 }
27162 return obj
27163}
27164func (self *OxmIdBsnUdf5) GetOXMName() string {
27165 return "bsn_udf5"
27166}
27167
27168func (self *OxmIdBsnUdf5) MarshalJSON() ([]byte, error) {
27169 if self.TypeLen == 0 {
27170 return []byte("\"\""), nil
27171 } else {
27172 return []byte("\"" + self.GetOXMName() + "\""), nil
27173 }
27174}
27175
27176type OxmIdBsnUdf5Masked struct {
27177 *OxmId
27178}
27179
27180type IOxmIdBsnUdf5Masked interface {
27181 IOxmId
27182}
27183
27184func (self *OxmIdBsnUdf5Masked) Serialize(encoder *goloxi.Encoder) error {
27185 if err := self.OxmId.Serialize(encoder); err != nil {
27186 return err
27187 }
27188
27189 return nil
27190}
27191
27192func DecodeOxmIdBsnUdf5Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf5Masked, error) {
27193 _oxmidbsnudf5masked := &OxmIdBsnUdf5Masked{OxmId: parent}
27194 return _oxmidbsnudf5masked, nil
27195}
27196
27197func NewOxmIdBsnUdf5Masked() *OxmIdBsnUdf5Masked {
27198 obj := &OxmIdBsnUdf5Masked{
27199 OxmId: NewOxmId(203528),
27200 }
27201 return obj
27202}
27203func (self *OxmIdBsnUdf5Masked) GetOXMName() string {
27204 return "bsn_udf5_masked"
27205}
27206
27207func (self *OxmIdBsnUdf5Masked) MarshalJSON() ([]byte, error) {
27208 if self.TypeLen == 0 {
27209 return []byte("\"\""), nil
27210 } else {
27211 return []byte("\"" + self.GetOXMName() + "\""), nil
27212 }
27213}
27214
27215type OxmIdBsnUdf6 struct {
27216 *OxmId
27217}
27218
27219type IOxmIdBsnUdf6 interface {
27220 IOxmId
27221}
27222
27223func (self *OxmIdBsnUdf6) Serialize(encoder *goloxi.Encoder) error {
27224 if err := self.OxmId.Serialize(encoder); err != nil {
27225 return err
27226 }
27227
27228 return nil
27229}
27230
27231func DecodeOxmIdBsnUdf6(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf6, error) {
27232 _oxmidbsnudf6 := &OxmIdBsnUdf6{OxmId: parent}
27233 return _oxmidbsnudf6, nil
27234}
27235
27236func NewOxmIdBsnUdf6() *OxmIdBsnUdf6 {
27237 obj := &OxmIdBsnUdf6{
27238 OxmId: NewOxmId(203780),
27239 }
27240 return obj
27241}
27242func (self *OxmIdBsnUdf6) GetOXMName() string {
27243 return "bsn_udf6"
27244}
27245
27246func (self *OxmIdBsnUdf6) MarshalJSON() ([]byte, error) {
27247 if self.TypeLen == 0 {
27248 return []byte("\"\""), nil
27249 } else {
27250 return []byte("\"" + self.GetOXMName() + "\""), nil
27251 }
27252}
27253
27254type OxmIdBsnUdf6Masked struct {
27255 *OxmId
27256}
27257
27258type IOxmIdBsnUdf6Masked interface {
27259 IOxmId
27260}
27261
27262func (self *OxmIdBsnUdf6Masked) Serialize(encoder *goloxi.Encoder) error {
27263 if err := self.OxmId.Serialize(encoder); err != nil {
27264 return err
27265 }
27266
27267 return nil
27268}
27269
27270func DecodeOxmIdBsnUdf6Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf6Masked, error) {
27271 _oxmidbsnudf6masked := &OxmIdBsnUdf6Masked{OxmId: parent}
27272 return _oxmidbsnudf6masked, nil
27273}
27274
27275func NewOxmIdBsnUdf6Masked() *OxmIdBsnUdf6Masked {
27276 obj := &OxmIdBsnUdf6Masked{
27277 OxmId: NewOxmId(204040),
27278 }
27279 return obj
27280}
27281func (self *OxmIdBsnUdf6Masked) GetOXMName() string {
27282 return "bsn_udf6_masked"
27283}
27284
27285func (self *OxmIdBsnUdf6Masked) MarshalJSON() ([]byte, error) {
27286 if self.TypeLen == 0 {
27287 return []byte("\"\""), nil
27288 } else {
27289 return []byte("\"" + self.GetOXMName() + "\""), nil
27290 }
27291}
27292
27293type OxmIdBsnUdf7 struct {
27294 *OxmId
27295}
27296
27297type IOxmIdBsnUdf7 interface {
27298 IOxmId
27299}
27300
27301func (self *OxmIdBsnUdf7) Serialize(encoder *goloxi.Encoder) error {
27302 if err := self.OxmId.Serialize(encoder); err != nil {
27303 return err
27304 }
27305
27306 return nil
27307}
27308
27309func DecodeOxmIdBsnUdf7(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf7, error) {
27310 _oxmidbsnudf7 := &OxmIdBsnUdf7{OxmId: parent}
27311 return _oxmidbsnudf7, nil
27312}
27313
27314func NewOxmIdBsnUdf7() *OxmIdBsnUdf7 {
27315 obj := &OxmIdBsnUdf7{
27316 OxmId: NewOxmId(204292),
27317 }
27318 return obj
27319}
27320func (self *OxmIdBsnUdf7) GetOXMName() string {
27321 return "bsn_udf7"
27322}
27323
27324func (self *OxmIdBsnUdf7) MarshalJSON() ([]byte, error) {
27325 if self.TypeLen == 0 {
27326 return []byte("\"\""), nil
27327 } else {
27328 return []byte("\"" + self.GetOXMName() + "\""), nil
27329 }
27330}
27331
27332type OxmIdBsnUdf7Masked struct {
27333 *OxmId
27334}
27335
27336type IOxmIdBsnUdf7Masked interface {
27337 IOxmId
27338}
27339
27340func (self *OxmIdBsnUdf7Masked) Serialize(encoder *goloxi.Encoder) error {
27341 if err := self.OxmId.Serialize(encoder); err != nil {
27342 return err
27343 }
27344
27345 return nil
27346}
27347
27348func DecodeOxmIdBsnUdf7Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf7Masked, error) {
27349 _oxmidbsnudf7masked := &OxmIdBsnUdf7Masked{OxmId: parent}
27350 return _oxmidbsnudf7masked, nil
27351}
27352
27353func NewOxmIdBsnUdf7Masked() *OxmIdBsnUdf7Masked {
27354 obj := &OxmIdBsnUdf7Masked{
27355 OxmId: NewOxmId(204552),
27356 }
27357 return obj
27358}
27359func (self *OxmIdBsnUdf7Masked) GetOXMName() string {
27360 return "bsn_udf7_masked"
27361}
27362
27363func (self *OxmIdBsnUdf7Masked) MarshalJSON() ([]byte, error) {
27364 if self.TypeLen == 0 {
27365 return []byte("\"\""), nil
27366 } else {
27367 return []byte("\"" + self.GetOXMName() + "\""), nil
27368 }
27369}
27370
27371type OxmIdBsnVfi struct {
27372 *OxmId
27373}
27374
27375type IOxmIdBsnVfi interface {
27376 IOxmId
27377}
27378
27379func (self *OxmIdBsnVfi) Serialize(encoder *goloxi.Encoder) error {
27380 if err := self.OxmId.Serialize(encoder); err != nil {
27381 return err
27382 }
27383
27384 return nil
27385}
27386
27387func DecodeOxmIdBsnVfi(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVfi, error) {
27388 _oxmidbsnvfi := &OxmIdBsnVfi{OxmId: parent}
27389 return _oxmidbsnvfi, nil
27390}
27391
27392func NewOxmIdBsnVfi() *OxmIdBsnVfi {
27393 obj := &OxmIdBsnVfi{
27394 OxmId: NewOxmId(209410),
27395 }
27396 return obj
27397}
27398func (self *OxmIdBsnVfi) GetOXMName() string {
27399 return "bsn_vfi"
27400}
27401
27402func (self *OxmIdBsnVfi) MarshalJSON() ([]byte, error) {
27403 if self.TypeLen == 0 {
27404 return []byte("\"\""), nil
27405 } else {
27406 return []byte("\"" + self.GetOXMName() + "\""), nil
27407 }
27408}
27409
27410type OxmIdBsnVfiMasked struct {
27411 *OxmId
27412}
27413
27414type IOxmIdBsnVfiMasked interface {
27415 IOxmId
27416}
27417
27418func (self *OxmIdBsnVfiMasked) Serialize(encoder *goloxi.Encoder) error {
27419 if err := self.OxmId.Serialize(encoder); err != nil {
27420 return err
27421 }
27422
27423 return nil
27424}
27425
27426func DecodeOxmIdBsnVfiMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVfiMasked, error) {
27427 _oxmidbsnvfimasked := &OxmIdBsnVfiMasked{OxmId: parent}
27428 return _oxmidbsnvfimasked, nil
27429}
27430
27431func NewOxmIdBsnVfiMasked() *OxmIdBsnVfiMasked {
27432 obj := &OxmIdBsnVfiMasked{
27433 OxmId: NewOxmId(209668),
27434 }
27435 return obj
27436}
27437func (self *OxmIdBsnVfiMasked) GetOXMName() string {
27438 return "bsn_vfi_masked"
27439}
27440
27441func (self *OxmIdBsnVfiMasked) MarshalJSON() ([]byte, error) {
27442 if self.TypeLen == 0 {
27443 return []byte("\"\""), nil
27444 } else {
27445 return []byte("\"" + self.GetOXMName() + "\""), nil
27446 }
27447}
27448
27449type OxmIdBsnVlanXlatePortGroupId struct {
27450 *OxmId
27451}
27452
27453type IOxmIdBsnVlanXlatePortGroupId interface {
27454 IOxmId
27455}
27456
27457func (self *OxmIdBsnVlanXlatePortGroupId) Serialize(encoder *goloxi.Encoder) error {
27458 if err := self.OxmId.Serialize(encoder); err != nil {
27459 return err
27460 }
27461
27462 return nil
27463}
27464
27465func DecodeOxmIdBsnVlanXlatePortGroupId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVlanXlatePortGroupId, error) {
27466 _oxmidbsnvlanxlateportgroupid := &OxmIdBsnVlanXlatePortGroupId{OxmId: parent}
27467 return _oxmidbsnvlanxlateportgroupid, nil
27468}
27469
27470func NewOxmIdBsnVlanXlatePortGroupId() *OxmIdBsnVlanXlatePortGroupId {
27471 obj := &OxmIdBsnVlanXlatePortGroupId{
27472 OxmId: NewOxmId(205316),
27473 }
27474 return obj
27475}
27476func (self *OxmIdBsnVlanXlatePortGroupId) GetOXMName() string {
27477 return "bsn_vlan_xlate_port_group_id"
27478}
27479
27480func (self *OxmIdBsnVlanXlatePortGroupId) MarshalJSON() ([]byte, error) {
27481 if self.TypeLen == 0 {
27482 return []byte("\"\""), nil
27483 } else {
27484 return []byte("\"" + self.GetOXMName() + "\""), nil
27485 }
27486}
27487
27488type OxmIdBsnVlanXlatePortGroupIdMasked struct {
27489 *OxmId
27490}
27491
27492type IOxmIdBsnVlanXlatePortGroupIdMasked interface {
27493 IOxmId
27494}
27495
27496func (self *OxmIdBsnVlanXlatePortGroupIdMasked) Serialize(encoder *goloxi.Encoder) error {
27497 if err := self.OxmId.Serialize(encoder); err != nil {
27498 return err
27499 }
27500
27501 return nil
27502}
27503
27504func DecodeOxmIdBsnVlanXlatePortGroupIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVlanXlatePortGroupIdMasked, error) {
27505 _oxmidbsnvlanxlateportgroupidmasked := &OxmIdBsnVlanXlatePortGroupIdMasked{OxmId: parent}
27506 return _oxmidbsnvlanxlateportgroupidmasked, nil
27507}
27508
27509func NewOxmIdBsnVlanXlatePortGroupIdMasked() *OxmIdBsnVlanXlatePortGroupIdMasked {
27510 obj := &OxmIdBsnVlanXlatePortGroupIdMasked{
27511 OxmId: NewOxmId(205576),
27512 }
27513 return obj
27514}
27515func (self *OxmIdBsnVlanXlatePortGroupIdMasked) GetOXMName() string {
27516 return "bsn_vlan_xlate_port_group_id_masked"
27517}
27518
27519func (self *OxmIdBsnVlanXlatePortGroupIdMasked) MarshalJSON() ([]byte, error) {
27520 if self.TypeLen == 0 {
27521 return []byte("\"\""), nil
27522 } else {
27523 return []byte("\"" + self.GetOXMName() + "\""), nil
27524 }
27525}
27526
27527type OxmIdBsnVrf struct {
27528 *OxmId
27529}
27530
27531type IOxmIdBsnVrf interface {
27532 IOxmId
27533}
27534
27535func (self *OxmIdBsnVrf) Serialize(encoder *goloxi.Encoder) error {
27536 if err := self.OxmId.Serialize(encoder); err != nil {
27537 return err
27538 }
27539
27540 return nil
27541}
27542
27543func DecodeOxmIdBsnVrf(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVrf, error) {
27544 _oxmidbsnvrf := &OxmIdBsnVrf{OxmId: parent}
27545 return _oxmidbsnvrf, nil
27546}
27547
27548func NewOxmIdBsnVrf() *OxmIdBsnVrf {
27549 obj := &OxmIdBsnVrf{
27550 OxmId: NewOxmId(197636),
27551 }
27552 return obj
27553}
27554func (self *OxmIdBsnVrf) GetOXMName() string {
27555 return "bsn_vrf"
27556}
27557
27558func (self *OxmIdBsnVrf) MarshalJSON() ([]byte, error) {
27559 if self.TypeLen == 0 {
27560 return []byte("\"\""), nil
27561 } else {
27562 return []byte("\"" + self.GetOXMName() + "\""), nil
27563 }
27564}
27565
27566type OxmIdBsnVrfMasked struct {
27567 *OxmId
27568}
27569
27570type IOxmIdBsnVrfMasked interface {
27571 IOxmId
27572}
27573
27574func (self *OxmIdBsnVrfMasked) Serialize(encoder *goloxi.Encoder) error {
27575 if err := self.OxmId.Serialize(encoder); err != nil {
27576 return err
27577 }
27578
27579 return nil
27580}
27581
27582func DecodeOxmIdBsnVrfMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVrfMasked, error) {
27583 _oxmidbsnvrfmasked := &OxmIdBsnVrfMasked{OxmId: parent}
27584 return _oxmidbsnvrfmasked, nil
27585}
27586
27587func NewOxmIdBsnVrfMasked() *OxmIdBsnVrfMasked {
27588 obj := &OxmIdBsnVrfMasked{
27589 OxmId: NewOxmId(197896),
27590 }
27591 return obj
27592}
27593func (self *OxmIdBsnVrfMasked) GetOXMName() string {
27594 return "bsn_vrf_masked"
27595}
27596
27597func (self *OxmIdBsnVrfMasked) MarshalJSON() ([]byte, error) {
27598 if self.TypeLen == 0 {
27599 return []byte("\"\""), nil
27600 } else {
27601 return []byte("\"" + self.GetOXMName() + "\""), nil
27602 }
27603}
27604
27605type OxmIdBsnVxlanNetworkId struct {
27606 *OxmId
27607}
27608
27609type IOxmIdBsnVxlanNetworkId interface {
27610 IOxmId
27611}
27612
27613func (self *OxmIdBsnVxlanNetworkId) Serialize(encoder *goloxi.Encoder) error {
27614 if err := self.OxmId.Serialize(encoder); err != nil {
27615 return err
27616 }
27617
27618 return nil
27619}
27620
27621func DecodeOxmIdBsnVxlanNetworkId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVxlanNetworkId, error) {
27622 _oxmidbsnvxlannetworkid := &OxmIdBsnVxlanNetworkId{OxmId: parent}
27623 return _oxmidbsnvxlannetworkid, nil
27624}
27625
27626func NewOxmIdBsnVxlanNetworkId() *OxmIdBsnVxlanNetworkId {
27627 obj := &OxmIdBsnVxlanNetworkId{
27628 OxmId: NewOxmId(207364),
27629 }
27630 return obj
27631}
27632func (self *OxmIdBsnVxlanNetworkId) GetOXMName() string {
27633 return "bsn_vxlan_network_id"
27634}
27635
27636func (self *OxmIdBsnVxlanNetworkId) MarshalJSON() ([]byte, error) {
27637 if self.TypeLen == 0 {
27638 return []byte("\"\""), nil
27639 } else {
27640 return []byte("\"" + self.GetOXMName() + "\""), nil
27641 }
27642}
27643
27644type OxmIdBsnVxlanNetworkIdMasked struct {
27645 *OxmId
27646}
27647
27648type IOxmIdBsnVxlanNetworkIdMasked interface {
27649 IOxmId
27650}
27651
27652func (self *OxmIdBsnVxlanNetworkIdMasked) Serialize(encoder *goloxi.Encoder) error {
27653 if err := self.OxmId.Serialize(encoder); err != nil {
27654 return err
27655 }
27656
27657 return nil
27658}
27659
27660func DecodeOxmIdBsnVxlanNetworkIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVxlanNetworkIdMasked, error) {
27661 _oxmidbsnvxlannetworkidmasked := &OxmIdBsnVxlanNetworkIdMasked{OxmId: parent}
27662 return _oxmidbsnvxlannetworkidmasked, nil
27663}
27664
27665func NewOxmIdBsnVxlanNetworkIdMasked() *OxmIdBsnVxlanNetworkIdMasked {
27666 obj := &OxmIdBsnVxlanNetworkIdMasked{
27667 OxmId: NewOxmId(207624),
27668 }
27669 return obj
27670}
27671func (self *OxmIdBsnVxlanNetworkIdMasked) GetOXMName() string {
27672 return "bsn_vxlan_network_id_masked"
27673}
27674
27675func (self *OxmIdBsnVxlanNetworkIdMasked) MarshalJSON() ([]byte, error) {
27676 if self.TypeLen == 0 {
27677 return []byte("\"\""), nil
27678 } else {
27679 return []byte("\"" + self.GetOXMName() + "\""), nil
27680 }
27681}
27682
27683type OxmIdConnTrackingIpv6Dst struct {
27684 *OxmId
27685}
27686
27687type IOxmIdConnTrackingIpv6Dst interface {
27688 IOxmId
27689}
27690
27691func (self *OxmIdConnTrackingIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
27692 if err := self.OxmId.Serialize(encoder); err != nil {
27693 return err
27694 }
27695
27696 return nil
27697}
27698
27699func DecodeOxmIdConnTrackingIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6Dst, error) {
27700 _oxmidconntrackingipv6dst := &OxmIdConnTrackingIpv6Dst{OxmId: parent}
27701 return _oxmidconntrackingipv6dst, nil
27702}
27703
27704func NewOxmIdConnTrackingIpv6Dst() *OxmIdConnTrackingIpv6Dst {
27705 obj := &OxmIdConnTrackingIpv6Dst{
27706 OxmId: NewOxmId(128528),
27707 }
27708 return obj
27709}
27710func (self *OxmIdConnTrackingIpv6Dst) GetOXMName() string {
27711 return "conn_tracking_ipv6_dst"
27712}
27713
27714func (self *OxmIdConnTrackingIpv6Dst) MarshalJSON() ([]byte, error) {
27715 if self.TypeLen == 0 {
27716 return []byte("\"\""), nil
27717 } else {
27718 return []byte("\"" + self.GetOXMName() + "\""), nil
27719 }
27720}
27721
27722type OxmIdConnTrackingIpv6DstMasked struct {
27723 *OxmId
27724}
27725
27726type IOxmIdConnTrackingIpv6DstMasked interface {
27727 IOxmId
27728}
27729
27730func (self *OxmIdConnTrackingIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
27731 if err := self.OxmId.Serialize(encoder); err != nil {
27732 return err
27733 }
27734
27735 return nil
27736}
27737
27738func DecodeOxmIdConnTrackingIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6DstMasked, error) {
27739 _oxmidconntrackingipv6dstmasked := &OxmIdConnTrackingIpv6DstMasked{OxmId: parent}
27740 return _oxmidconntrackingipv6dstmasked, nil
27741}
27742
27743func NewOxmIdConnTrackingIpv6DstMasked() *OxmIdConnTrackingIpv6DstMasked {
27744 obj := &OxmIdConnTrackingIpv6DstMasked{
27745 OxmId: NewOxmId(128800),
27746 }
27747 return obj
27748}
27749func (self *OxmIdConnTrackingIpv6DstMasked) GetOXMName() string {
27750 return "conn_tracking_ipv6_dst_masked"
27751}
27752
27753func (self *OxmIdConnTrackingIpv6DstMasked) MarshalJSON() ([]byte, error) {
27754 if self.TypeLen == 0 {
27755 return []byte("\"\""), nil
27756 } else {
27757 return []byte("\"" + self.GetOXMName() + "\""), nil
27758 }
27759}
27760
27761type OxmIdConnTrackingIpv6Src struct {
27762 *OxmId
27763}
27764
27765type IOxmIdConnTrackingIpv6Src interface {
27766 IOxmId
27767}
27768
27769func (self *OxmIdConnTrackingIpv6Src) Serialize(encoder *goloxi.Encoder) error {
27770 if err := self.OxmId.Serialize(encoder); err != nil {
27771 return err
27772 }
27773
27774 return nil
27775}
27776
27777func DecodeOxmIdConnTrackingIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6Src, error) {
27778 _oxmidconntrackingipv6src := &OxmIdConnTrackingIpv6Src{OxmId: parent}
27779 return _oxmidconntrackingipv6src, nil
27780}
27781
27782func NewOxmIdConnTrackingIpv6Src() *OxmIdConnTrackingIpv6Src {
27783 obj := &OxmIdConnTrackingIpv6Src{
27784 OxmId: NewOxmId(128016),
27785 }
27786 return obj
27787}
27788func (self *OxmIdConnTrackingIpv6Src) GetOXMName() string {
27789 return "conn_tracking_ipv6_src"
27790}
27791
27792func (self *OxmIdConnTrackingIpv6Src) MarshalJSON() ([]byte, error) {
27793 if self.TypeLen == 0 {
27794 return []byte("\"\""), nil
27795 } else {
27796 return []byte("\"" + self.GetOXMName() + "\""), nil
27797 }
27798}
27799
27800type OxmIdConnTrackingIpv6SrcMasked struct {
27801 *OxmId
27802}
27803
27804type IOxmIdConnTrackingIpv6SrcMasked interface {
27805 IOxmId
27806}
27807
27808func (self *OxmIdConnTrackingIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
27809 if err := self.OxmId.Serialize(encoder); err != nil {
27810 return err
27811 }
27812
27813 return nil
27814}
27815
27816func DecodeOxmIdConnTrackingIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6SrcMasked, error) {
27817 _oxmidconntrackingipv6srcmasked := &OxmIdConnTrackingIpv6SrcMasked{OxmId: parent}
27818 return _oxmidconntrackingipv6srcmasked, nil
27819}
27820
27821func NewOxmIdConnTrackingIpv6SrcMasked() *OxmIdConnTrackingIpv6SrcMasked {
27822 obj := &OxmIdConnTrackingIpv6SrcMasked{
27823 OxmId: NewOxmId(128288),
27824 }
27825 return obj
27826}
27827func (self *OxmIdConnTrackingIpv6SrcMasked) GetOXMName() string {
27828 return "conn_tracking_ipv6_src_masked"
27829}
27830
27831func (self *OxmIdConnTrackingIpv6SrcMasked) MarshalJSON() ([]byte, error) {
27832 if self.TypeLen == 0 {
27833 return []byte("\"\""), nil
27834 } else {
27835 return []byte("\"" + self.GetOXMName() + "\""), nil
27836 }
27837}
27838
27839type OxmIdConnTrackingLabel struct {
27840 *OxmId
27841}
27842
27843type IOxmIdConnTrackingLabel interface {
27844 IOxmId
27845}
27846
27847func (self *OxmIdConnTrackingLabel) Serialize(encoder *goloxi.Encoder) error {
27848 if err := self.OxmId.Serialize(encoder); err != nil {
27849 return err
27850 }
27851
27852 return nil
27853}
27854
27855func DecodeOxmIdConnTrackingLabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingLabel, error) {
27856 _oxmidconntrackinglabel := &OxmIdConnTrackingLabel{OxmId: parent}
27857 return _oxmidconntrackinglabel, nil
27858}
27859
27860func NewOxmIdConnTrackingLabel() *OxmIdConnTrackingLabel {
27861 obj := &OxmIdConnTrackingLabel{
27862 OxmId: NewOxmId(120848),
27863 }
27864 return obj
27865}
27866func (self *OxmIdConnTrackingLabel) GetOXMName() string {
27867 return "conn_tracking_label"
27868}
27869
27870func (self *OxmIdConnTrackingLabel) MarshalJSON() ([]byte, error) {
27871 if self.TypeLen == 0 {
27872 return []byte("\"\""), nil
27873 } else {
27874 return []byte("\"" + self.GetOXMName() + "\""), nil
27875 }
27876}
27877
27878type OxmIdConnTrackingLabelMasked struct {
27879 *OxmId
27880}
27881
27882type IOxmIdConnTrackingLabelMasked interface {
27883 IOxmId
27884}
27885
27886func (self *OxmIdConnTrackingLabelMasked) Serialize(encoder *goloxi.Encoder) error {
27887 if err := self.OxmId.Serialize(encoder); err != nil {
27888 return err
27889 }
27890
27891 return nil
27892}
27893
27894func DecodeOxmIdConnTrackingLabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingLabelMasked, error) {
27895 _oxmidconntrackinglabelmasked := &OxmIdConnTrackingLabelMasked{OxmId: parent}
27896 return _oxmidconntrackinglabelmasked, nil
27897}
27898
27899func NewOxmIdConnTrackingLabelMasked() *OxmIdConnTrackingLabelMasked {
27900 obj := &OxmIdConnTrackingLabelMasked{
27901 OxmId: NewOxmId(121120),
27902 }
27903 return obj
27904}
27905func (self *OxmIdConnTrackingLabelMasked) GetOXMName() string {
27906 return "conn_tracking_label_masked"
27907}
27908
27909func (self *OxmIdConnTrackingLabelMasked) MarshalJSON() ([]byte, error) {
27910 if self.TypeLen == 0 {
27911 return []byte("\"\""), nil
27912 } else {
27913 return []byte("\"" + self.GetOXMName() + "\""), nil
27914 }
27915}
27916
27917type OxmIdConnTrackingMark struct {
27918 *OxmId
27919}
27920
27921type IOxmIdConnTrackingMark interface {
27922 IOxmId
27923}
27924
27925func (self *OxmIdConnTrackingMark) Serialize(encoder *goloxi.Encoder) error {
27926 if err := self.OxmId.Serialize(encoder); err != nil {
27927 return err
27928 }
27929
27930 return nil
27931}
27932
27933func DecodeOxmIdConnTrackingMark(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingMark, error) {
27934 _oxmidconntrackingmark := &OxmIdConnTrackingMark{OxmId: parent}
27935 return _oxmidconntrackingmark, nil
27936}
27937
27938func NewOxmIdConnTrackingMark() *OxmIdConnTrackingMark {
27939 obj := &OxmIdConnTrackingMark{
27940 OxmId: NewOxmId(120324),
27941 }
27942 return obj
27943}
27944func (self *OxmIdConnTrackingMark) GetOXMName() string {
27945 return "conn_tracking_mark"
27946}
27947
27948func (self *OxmIdConnTrackingMark) MarshalJSON() ([]byte, error) {
27949 if self.TypeLen == 0 {
27950 return []byte("\"\""), nil
27951 } else {
27952 return []byte("\"" + self.GetOXMName() + "\""), nil
27953 }
27954}
27955
27956type OxmIdConnTrackingMarkMasked struct {
27957 *OxmId
27958}
27959
27960type IOxmIdConnTrackingMarkMasked interface {
27961 IOxmId
27962}
27963
27964func (self *OxmIdConnTrackingMarkMasked) Serialize(encoder *goloxi.Encoder) error {
27965 if err := self.OxmId.Serialize(encoder); err != nil {
27966 return err
27967 }
27968
27969 return nil
27970}
27971
27972func DecodeOxmIdConnTrackingMarkMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingMarkMasked, error) {
27973 _oxmidconntrackingmarkmasked := &OxmIdConnTrackingMarkMasked{OxmId: parent}
27974 return _oxmidconntrackingmarkmasked, nil
27975}
27976
27977func NewOxmIdConnTrackingMarkMasked() *OxmIdConnTrackingMarkMasked {
27978 obj := &OxmIdConnTrackingMarkMasked{
27979 OxmId: NewOxmId(120584),
27980 }
27981 return obj
27982}
27983func (self *OxmIdConnTrackingMarkMasked) GetOXMName() string {
27984 return "conn_tracking_mark_masked"
27985}
27986
27987func (self *OxmIdConnTrackingMarkMasked) MarshalJSON() ([]byte, error) {
27988 if self.TypeLen == 0 {
27989 return []byte("\"\""), nil
27990 } else {
27991 return []byte("\"" + self.GetOXMName() + "\""), nil
27992 }
27993}
27994
27995type OxmIdConnTrackingNwDst struct {
27996 *OxmId
27997}
27998
27999type IOxmIdConnTrackingNwDst interface {
28000 IOxmId
28001}
28002
28003func (self *OxmIdConnTrackingNwDst) Serialize(encoder *goloxi.Encoder) error {
28004 if err := self.OxmId.Serialize(encoder); err != nil {
28005 return err
28006 }
28007
28008 return nil
28009}
28010
28011func DecodeOxmIdConnTrackingNwDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwDst, error) {
28012 _oxmidconntrackingnwdst := &OxmIdConnTrackingNwDst{OxmId: parent}
28013 return _oxmidconntrackingnwdst, nil
28014}
28015
28016func NewOxmIdConnTrackingNwDst() *OxmIdConnTrackingNwDst {
28017 obj := &OxmIdConnTrackingNwDst{
28018 OxmId: NewOxmId(127492),
28019 }
28020 return obj
28021}
28022func (self *OxmIdConnTrackingNwDst) GetOXMName() string {
28023 return "conn_tracking_nw_dst"
28024}
28025
28026func (self *OxmIdConnTrackingNwDst) MarshalJSON() ([]byte, error) {
28027 if self.TypeLen == 0 {
28028 return []byte("\"\""), nil
28029 } else {
28030 return []byte("\"" + self.GetOXMName() + "\""), nil
28031 }
28032}
28033
28034type OxmIdConnTrackingNwDstMasked struct {
28035 *OxmId
28036}
28037
28038type IOxmIdConnTrackingNwDstMasked interface {
28039 IOxmId
28040}
28041
28042func (self *OxmIdConnTrackingNwDstMasked) Serialize(encoder *goloxi.Encoder) error {
28043 if err := self.OxmId.Serialize(encoder); err != nil {
28044 return err
28045 }
28046
28047 return nil
28048}
28049
28050func DecodeOxmIdConnTrackingNwDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwDstMasked, error) {
28051 _oxmidconntrackingnwdstmasked := &OxmIdConnTrackingNwDstMasked{OxmId: parent}
28052 return _oxmidconntrackingnwdstmasked, nil
28053}
28054
28055func NewOxmIdConnTrackingNwDstMasked() *OxmIdConnTrackingNwDstMasked {
28056 obj := &OxmIdConnTrackingNwDstMasked{
28057 OxmId: NewOxmId(127752),
28058 }
28059 return obj
28060}
28061func (self *OxmIdConnTrackingNwDstMasked) GetOXMName() string {
28062 return "conn_tracking_nw_dst_masked"
28063}
28064
28065func (self *OxmIdConnTrackingNwDstMasked) MarshalJSON() ([]byte, error) {
28066 if self.TypeLen == 0 {
28067 return []byte("\"\""), nil
28068 } else {
28069 return []byte("\"" + self.GetOXMName() + "\""), nil
28070 }
28071}
28072
28073type OxmIdConnTrackingNwProto struct {
28074 *OxmId
28075}
28076
28077type IOxmIdConnTrackingNwProto interface {
28078 IOxmId
28079}
28080
28081func (self *OxmIdConnTrackingNwProto) Serialize(encoder *goloxi.Encoder) error {
28082 if err := self.OxmId.Serialize(encoder); err != nil {
28083 return err
28084 }
28085
28086 return nil
28087}
28088
28089func DecodeOxmIdConnTrackingNwProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwProto, error) {
28090 _oxmidconntrackingnwproto := &OxmIdConnTrackingNwProto{OxmId: parent}
28091 return _oxmidconntrackingnwproto, nil
28092}
28093
28094func NewOxmIdConnTrackingNwProto() *OxmIdConnTrackingNwProto {
28095 obj := &OxmIdConnTrackingNwProto{
28096 OxmId: NewOxmId(126465),
28097 }
28098 return obj
28099}
28100func (self *OxmIdConnTrackingNwProto) GetOXMName() string {
28101 return "conn_tracking_nw_proto"
28102}
28103
28104func (self *OxmIdConnTrackingNwProto) MarshalJSON() ([]byte, error) {
28105 if self.TypeLen == 0 {
28106 return []byte("\"\""), nil
28107 } else {
28108 return []byte("\"" + self.GetOXMName() + "\""), nil
28109 }
28110}
28111
28112type OxmIdConnTrackingNwProtoMasked struct {
28113 *OxmId
28114}
28115
28116type IOxmIdConnTrackingNwProtoMasked interface {
28117 IOxmId
28118}
28119
28120func (self *OxmIdConnTrackingNwProtoMasked) Serialize(encoder *goloxi.Encoder) error {
28121 if err := self.OxmId.Serialize(encoder); err != nil {
28122 return err
28123 }
28124
28125 return nil
28126}
28127
28128func DecodeOxmIdConnTrackingNwProtoMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwProtoMasked, error) {
28129 _oxmidconntrackingnwprotomasked := &OxmIdConnTrackingNwProtoMasked{OxmId: parent}
28130 return _oxmidconntrackingnwprotomasked, nil
28131}
28132
28133func NewOxmIdConnTrackingNwProtoMasked() *OxmIdConnTrackingNwProtoMasked {
28134 obj := &OxmIdConnTrackingNwProtoMasked{
28135 OxmId: NewOxmId(126722),
28136 }
28137 return obj
28138}
28139func (self *OxmIdConnTrackingNwProtoMasked) GetOXMName() string {
28140 return "conn_tracking_nw_proto_masked"
28141}
28142
28143func (self *OxmIdConnTrackingNwProtoMasked) MarshalJSON() ([]byte, error) {
28144 if self.TypeLen == 0 {
28145 return []byte("\"\""), nil
28146 } else {
28147 return []byte("\"" + self.GetOXMName() + "\""), nil
28148 }
28149}
28150
28151type OxmIdConnTrackingNwSrc struct {
28152 *OxmId
28153}
28154
28155type IOxmIdConnTrackingNwSrc interface {
28156 IOxmId
28157}
28158
28159func (self *OxmIdConnTrackingNwSrc) Serialize(encoder *goloxi.Encoder) error {
28160 if err := self.OxmId.Serialize(encoder); err != nil {
28161 return err
28162 }
28163
28164 return nil
28165}
28166
28167func DecodeOxmIdConnTrackingNwSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwSrc, error) {
28168 _oxmidconntrackingnwsrc := &OxmIdConnTrackingNwSrc{OxmId: parent}
28169 return _oxmidconntrackingnwsrc, nil
28170}
28171
28172func NewOxmIdConnTrackingNwSrc() *OxmIdConnTrackingNwSrc {
28173 obj := &OxmIdConnTrackingNwSrc{
28174 OxmId: NewOxmId(126980),
28175 }
28176 return obj
28177}
28178func (self *OxmIdConnTrackingNwSrc) GetOXMName() string {
28179 return "conn_tracking_nw_src"
28180}
28181
28182func (self *OxmIdConnTrackingNwSrc) MarshalJSON() ([]byte, error) {
28183 if self.TypeLen == 0 {
28184 return []byte("\"\""), nil
28185 } else {
28186 return []byte("\"" + self.GetOXMName() + "\""), nil
28187 }
28188}
28189
28190type OxmIdConnTrackingNwSrcMasked struct {
28191 *OxmId
28192}
28193
28194type IOxmIdConnTrackingNwSrcMasked interface {
28195 IOxmId
28196}
28197
28198func (self *OxmIdConnTrackingNwSrcMasked) Serialize(encoder *goloxi.Encoder) error {
28199 if err := self.OxmId.Serialize(encoder); err != nil {
28200 return err
28201 }
28202
28203 return nil
28204}
28205
28206func DecodeOxmIdConnTrackingNwSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwSrcMasked, error) {
28207 _oxmidconntrackingnwsrcmasked := &OxmIdConnTrackingNwSrcMasked{OxmId: parent}
28208 return _oxmidconntrackingnwsrcmasked, nil
28209}
28210
28211func NewOxmIdConnTrackingNwSrcMasked() *OxmIdConnTrackingNwSrcMasked {
28212 obj := &OxmIdConnTrackingNwSrcMasked{
28213 OxmId: NewOxmId(127240),
28214 }
28215 return obj
28216}
28217func (self *OxmIdConnTrackingNwSrcMasked) GetOXMName() string {
28218 return "conn_tracking_nw_src_masked"
28219}
28220
28221func (self *OxmIdConnTrackingNwSrcMasked) MarshalJSON() ([]byte, error) {
28222 if self.TypeLen == 0 {
28223 return []byte("\"\""), nil
28224 } else {
28225 return []byte("\"" + self.GetOXMName() + "\""), nil
28226 }
28227}
28228
28229type OxmIdConnTrackingState struct {
28230 *OxmId
28231}
28232
28233type IOxmIdConnTrackingState interface {
28234 IOxmId
28235}
28236
28237func (self *OxmIdConnTrackingState) Serialize(encoder *goloxi.Encoder) error {
28238 if err := self.OxmId.Serialize(encoder); err != nil {
28239 return err
28240 }
28241
28242 return nil
28243}
28244
28245func DecodeOxmIdConnTrackingState(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingState, error) {
28246 _oxmidconntrackingstate := &OxmIdConnTrackingState{OxmId: parent}
28247 return _oxmidconntrackingstate, nil
28248}
28249
28250func NewOxmIdConnTrackingState() *OxmIdConnTrackingState {
28251 obj := &OxmIdConnTrackingState{
28252 OxmId: NewOxmId(119300),
28253 }
28254 return obj
28255}
28256func (self *OxmIdConnTrackingState) GetOXMName() string {
28257 return "conn_tracking_state"
28258}
28259
28260func (self *OxmIdConnTrackingState) MarshalJSON() ([]byte, error) {
28261 if self.TypeLen == 0 {
28262 return []byte("\"\""), nil
28263 } else {
28264 return []byte("\"" + self.GetOXMName() + "\""), nil
28265 }
28266}
28267
28268type OxmIdConnTrackingStateMasked struct {
28269 *OxmId
28270}
28271
28272type IOxmIdConnTrackingStateMasked interface {
28273 IOxmId
28274}
28275
28276func (self *OxmIdConnTrackingStateMasked) Serialize(encoder *goloxi.Encoder) error {
28277 if err := self.OxmId.Serialize(encoder); err != nil {
28278 return err
28279 }
28280
28281 return nil
28282}
28283
28284func DecodeOxmIdConnTrackingStateMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingStateMasked, error) {
28285 _oxmidconntrackingstatemasked := &OxmIdConnTrackingStateMasked{OxmId: parent}
28286 return _oxmidconntrackingstatemasked, nil
28287}
28288
28289func NewOxmIdConnTrackingStateMasked() *OxmIdConnTrackingStateMasked {
28290 obj := &OxmIdConnTrackingStateMasked{
28291 OxmId: NewOxmId(119560),
28292 }
28293 return obj
28294}
28295func (self *OxmIdConnTrackingStateMasked) GetOXMName() string {
28296 return "conn_tracking_state_masked"
28297}
28298
28299func (self *OxmIdConnTrackingStateMasked) MarshalJSON() ([]byte, error) {
28300 if self.TypeLen == 0 {
28301 return []byte("\"\""), nil
28302 } else {
28303 return []byte("\"" + self.GetOXMName() + "\""), nil
28304 }
28305}
28306
28307type OxmIdConnTrackingTpDst struct {
28308 *OxmId
28309}
28310
28311type IOxmIdConnTrackingTpDst interface {
28312 IOxmId
28313}
28314
28315func (self *OxmIdConnTrackingTpDst) Serialize(encoder *goloxi.Encoder) error {
28316 if err := self.OxmId.Serialize(encoder); err != nil {
28317 return err
28318 }
28319
28320 return nil
28321}
28322
28323func DecodeOxmIdConnTrackingTpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpDst, error) {
28324 _oxmidconntrackingtpdst := &OxmIdConnTrackingTpDst{OxmId: parent}
28325 return _oxmidconntrackingtpdst, nil
28326}
28327
28328func NewOxmIdConnTrackingTpDst() *OxmIdConnTrackingTpDst {
28329 obj := &OxmIdConnTrackingTpDst{
28330 OxmId: NewOxmId(129538),
28331 }
28332 return obj
28333}
28334func (self *OxmIdConnTrackingTpDst) GetOXMName() string {
28335 return "conn_tracking_tp_dst"
28336}
28337
28338func (self *OxmIdConnTrackingTpDst) MarshalJSON() ([]byte, error) {
28339 if self.TypeLen == 0 {
28340 return []byte("\"\""), nil
28341 } else {
28342 return []byte("\"" + self.GetOXMName() + "\""), nil
28343 }
28344}
28345
28346type OxmIdConnTrackingTpDstMasked struct {
28347 *OxmId
28348}
28349
28350type IOxmIdConnTrackingTpDstMasked interface {
28351 IOxmId
28352}
28353
28354func (self *OxmIdConnTrackingTpDstMasked) Serialize(encoder *goloxi.Encoder) error {
28355 if err := self.OxmId.Serialize(encoder); err != nil {
28356 return err
28357 }
28358
28359 return nil
28360}
28361
28362func DecodeOxmIdConnTrackingTpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpDstMasked, error) {
28363 _oxmidconntrackingtpdstmasked := &OxmIdConnTrackingTpDstMasked{OxmId: parent}
28364 return _oxmidconntrackingtpdstmasked, nil
28365}
28366
28367func NewOxmIdConnTrackingTpDstMasked() *OxmIdConnTrackingTpDstMasked {
28368 obj := &OxmIdConnTrackingTpDstMasked{
28369 OxmId: NewOxmId(129796),
28370 }
28371 return obj
28372}
28373func (self *OxmIdConnTrackingTpDstMasked) GetOXMName() string {
28374 return "conn_tracking_tp_dst_masked"
28375}
28376
28377func (self *OxmIdConnTrackingTpDstMasked) MarshalJSON() ([]byte, error) {
28378 if self.TypeLen == 0 {
28379 return []byte("\"\""), nil
28380 } else {
28381 return []byte("\"" + self.GetOXMName() + "\""), nil
28382 }
28383}
28384
28385type OxmIdConnTrackingTpSrc struct {
28386 *OxmId
28387}
28388
28389type IOxmIdConnTrackingTpSrc interface {
28390 IOxmId
28391}
28392
28393func (self *OxmIdConnTrackingTpSrc) Serialize(encoder *goloxi.Encoder) error {
28394 if err := self.OxmId.Serialize(encoder); err != nil {
28395 return err
28396 }
28397
28398 return nil
28399}
28400
28401func DecodeOxmIdConnTrackingTpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpSrc, error) {
28402 _oxmidconntrackingtpsrc := &OxmIdConnTrackingTpSrc{OxmId: parent}
28403 return _oxmidconntrackingtpsrc, nil
28404}
28405
28406func NewOxmIdConnTrackingTpSrc() *OxmIdConnTrackingTpSrc {
28407 obj := &OxmIdConnTrackingTpSrc{
28408 OxmId: NewOxmId(129026),
28409 }
28410 return obj
28411}
28412func (self *OxmIdConnTrackingTpSrc) GetOXMName() string {
28413 return "conn_tracking_tp_src"
28414}
28415
28416func (self *OxmIdConnTrackingTpSrc) MarshalJSON() ([]byte, error) {
28417 if self.TypeLen == 0 {
28418 return []byte("\"\""), nil
28419 } else {
28420 return []byte("\"" + self.GetOXMName() + "\""), nil
28421 }
28422}
28423
28424type OxmIdConnTrackingTpSrcMasked struct {
28425 *OxmId
28426}
28427
28428type IOxmIdConnTrackingTpSrcMasked interface {
28429 IOxmId
28430}
28431
28432func (self *OxmIdConnTrackingTpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
28433 if err := self.OxmId.Serialize(encoder); err != nil {
28434 return err
28435 }
28436
28437 return nil
28438}
28439
28440func DecodeOxmIdConnTrackingTpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpSrcMasked, error) {
28441 _oxmidconntrackingtpsrcmasked := &OxmIdConnTrackingTpSrcMasked{OxmId: parent}
28442 return _oxmidconntrackingtpsrcmasked, nil
28443}
28444
28445func NewOxmIdConnTrackingTpSrcMasked() *OxmIdConnTrackingTpSrcMasked {
28446 obj := &OxmIdConnTrackingTpSrcMasked{
28447 OxmId: NewOxmId(129284),
28448 }
28449 return obj
28450}
28451func (self *OxmIdConnTrackingTpSrcMasked) GetOXMName() string {
28452 return "conn_tracking_tp_src_masked"
28453}
28454
28455func (self *OxmIdConnTrackingTpSrcMasked) MarshalJSON() ([]byte, error) {
28456 if self.TypeLen == 0 {
28457 return []byte("\"\""), nil
28458 } else {
28459 return []byte("\"" + self.GetOXMName() + "\""), nil
28460 }
28461}
28462
28463type OxmIdConnTrackingZone struct {
28464 *OxmId
28465}
28466
28467type IOxmIdConnTrackingZone interface {
28468 IOxmId
28469}
28470
28471func (self *OxmIdConnTrackingZone) Serialize(encoder *goloxi.Encoder) error {
28472 if err := self.OxmId.Serialize(encoder); err != nil {
28473 return err
28474 }
28475
28476 return nil
28477}
28478
28479func DecodeOxmIdConnTrackingZone(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingZone, error) {
28480 _oxmidconntrackingzone := &OxmIdConnTrackingZone{OxmId: parent}
28481 return _oxmidconntrackingzone, nil
28482}
28483
28484func NewOxmIdConnTrackingZone() *OxmIdConnTrackingZone {
28485 obj := &OxmIdConnTrackingZone{
28486 OxmId: NewOxmId(119810),
28487 }
28488 return obj
28489}
28490func (self *OxmIdConnTrackingZone) GetOXMName() string {
28491 return "conn_tracking_zone"
28492}
28493
28494func (self *OxmIdConnTrackingZone) MarshalJSON() ([]byte, error) {
28495 if self.TypeLen == 0 {
28496 return []byte("\"\""), nil
28497 } else {
28498 return []byte("\"" + self.GetOXMName() + "\""), nil
28499 }
28500}
28501
28502type OxmIdConnTrackingZoneMasked struct {
28503 *OxmId
28504}
28505
28506type IOxmIdConnTrackingZoneMasked interface {
28507 IOxmId
28508}
28509
28510func (self *OxmIdConnTrackingZoneMasked) Serialize(encoder *goloxi.Encoder) error {
28511 if err := self.OxmId.Serialize(encoder); err != nil {
28512 return err
28513 }
28514
28515 return nil
28516}
28517
28518func DecodeOxmIdConnTrackingZoneMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingZoneMasked, error) {
28519 _oxmidconntrackingzonemasked := &OxmIdConnTrackingZoneMasked{OxmId: parent}
28520 return _oxmidconntrackingzonemasked, nil
28521}
28522
28523func NewOxmIdConnTrackingZoneMasked() *OxmIdConnTrackingZoneMasked {
28524 obj := &OxmIdConnTrackingZoneMasked{
28525 OxmId: NewOxmId(120068),
28526 }
28527 return obj
28528}
28529func (self *OxmIdConnTrackingZoneMasked) GetOXMName() string {
28530 return "conn_tracking_zone_masked"
28531}
28532
28533func (self *OxmIdConnTrackingZoneMasked) MarshalJSON() ([]byte, error) {
28534 if self.TypeLen == 0 {
28535 return []byte("\"\""), nil
28536 } else {
28537 return []byte("\"" + self.GetOXMName() + "\""), nil
28538 }
28539}
28540
28541type OxmIdEthTypeMasked struct {
28542 *OxmId
28543}
28544
28545type IOxmIdEthTypeMasked interface {
28546 IOxmId
28547}
28548
28549func (self *OxmIdEthTypeMasked) Serialize(encoder *goloxi.Encoder) error {
28550 if err := self.OxmId.Serialize(encoder); err != nil {
28551 return err
28552 }
28553
28554 return nil
28555}
28556
28557func DecodeOxmIdEthTypeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthTypeMasked, error) {
28558 _oxmidethtypemasked := &OxmIdEthTypeMasked{OxmId: parent}
28559 return _oxmidethtypemasked, nil
28560}
28561
28562func NewOxmIdEthTypeMasked() *OxmIdEthTypeMasked {
28563 obj := &OxmIdEthTypeMasked{
28564 OxmId: NewOxmId(2147486468),
28565 }
28566 return obj
28567}
28568func (self *OxmIdEthTypeMasked) GetOXMName() string {
28569 return "eth_type_masked"
28570}
28571
28572func (self *OxmIdEthTypeMasked) MarshalJSON() ([]byte, error) {
28573 if self.TypeLen == 0 {
28574 return []byte("\"\""), nil
28575 } else {
28576 return []byte("\"" + self.GetOXMName() + "\""), nil
28577 }
28578}
28579
28580type OxmIdIcmpv4Code struct {
28581 *OxmId
28582}
28583
28584type IOxmIdIcmpv4Code interface {
28585 IOxmId
28586}
28587
28588func (self *OxmIdIcmpv4Code) Serialize(encoder *goloxi.Encoder) error {
28589 if err := self.OxmId.Serialize(encoder); err != nil {
28590 return err
28591 }
28592
28593 return nil
28594}
28595
28596func DecodeOxmIdIcmpv4Code(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4Code, error) {
28597 _oxmidicmpv4code := &OxmIdIcmpv4Code{OxmId: parent}
28598 return _oxmidicmpv4code, nil
28599}
28600
28601func NewOxmIdIcmpv4Code() *OxmIdIcmpv4Code {
28602 obj := &OxmIdIcmpv4Code{
28603 OxmId: NewOxmId(2147493889),
28604 }
28605 return obj
28606}
28607func (self *OxmIdIcmpv4Code) GetOXMName() string {
28608 return "icmpv4_code"
28609}
28610
28611func (self *OxmIdIcmpv4Code) MarshalJSON() ([]byte, error) {
28612 if self.TypeLen == 0 {
28613 return []byte("\"\""), nil
28614 } else {
28615 return []byte("\"" + self.GetOXMName() + "\""), nil
28616 }
28617}
28618
28619type OxmIdIcmpv4CodeMasked struct {
28620 *OxmId
28621}
28622
28623type IOxmIdIcmpv4CodeMasked interface {
28624 IOxmId
28625}
28626
28627func (self *OxmIdIcmpv4CodeMasked) Serialize(encoder *goloxi.Encoder) error {
28628 if err := self.OxmId.Serialize(encoder); err != nil {
28629 return err
28630 }
28631
28632 return nil
28633}
28634
28635func DecodeOxmIdIcmpv4CodeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4CodeMasked, error) {
28636 _oxmidicmpv4codemasked := &OxmIdIcmpv4CodeMasked{OxmId: parent}
28637 return _oxmidicmpv4codemasked, nil
28638}
28639
28640func NewOxmIdIcmpv4CodeMasked() *OxmIdIcmpv4CodeMasked {
28641 obj := &OxmIdIcmpv4CodeMasked{
28642 OxmId: NewOxmId(2147494146),
28643 }
28644 return obj
28645}
28646func (self *OxmIdIcmpv4CodeMasked) GetOXMName() string {
28647 return "icmpv4_code_masked"
28648}
28649
28650func (self *OxmIdIcmpv4CodeMasked) MarshalJSON() ([]byte, error) {
28651 if self.TypeLen == 0 {
28652 return []byte("\"\""), nil
28653 } else {
28654 return []byte("\"" + self.GetOXMName() + "\""), nil
28655 }
28656}
28657
28658type OxmIdIcmpv4Type struct {
28659 *OxmId
28660}
28661
28662type IOxmIdIcmpv4Type interface {
28663 IOxmId
28664}
28665
28666func (self *OxmIdIcmpv4Type) Serialize(encoder *goloxi.Encoder) error {
28667 if err := self.OxmId.Serialize(encoder); err != nil {
28668 return err
28669 }
28670
28671 return nil
28672}
28673
28674func DecodeOxmIdIcmpv4Type(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4Type, error) {
28675 _oxmidicmpv4type := &OxmIdIcmpv4Type{OxmId: parent}
28676 return _oxmidicmpv4type, nil
28677}
28678
28679func NewOxmIdIcmpv4Type() *OxmIdIcmpv4Type {
28680 obj := &OxmIdIcmpv4Type{
28681 OxmId: NewOxmId(2147493377),
28682 }
28683 return obj
28684}
28685func (self *OxmIdIcmpv4Type) GetOXMName() string {
28686 return "icmpv4_type"
28687}
28688
28689func (self *OxmIdIcmpv4Type) MarshalJSON() ([]byte, error) {
28690 if self.TypeLen == 0 {
28691 return []byte("\"\""), nil
28692 } else {
28693 return []byte("\"" + self.GetOXMName() + "\""), nil
28694 }
28695}
28696
28697type OxmIdIcmpv4TypeMasked struct {
28698 *OxmId
28699}
28700
28701type IOxmIdIcmpv4TypeMasked interface {
28702 IOxmId
28703}
28704
28705func (self *OxmIdIcmpv4TypeMasked) Serialize(encoder *goloxi.Encoder) error {
28706 if err := self.OxmId.Serialize(encoder); err != nil {
28707 return err
28708 }
28709
28710 return nil
28711}
28712
28713func DecodeOxmIdIcmpv4TypeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4TypeMasked, error) {
28714 _oxmidicmpv4typemasked := &OxmIdIcmpv4TypeMasked{OxmId: parent}
28715 return _oxmidicmpv4typemasked, nil
28716}
28717
28718func NewOxmIdIcmpv4TypeMasked() *OxmIdIcmpv4TypeMasked {
28719 obj := &OxmIdIcmpv4TypeMasked{
28720 OxmId: NewOxmId(2147493634),
28721 }
28722 return obj
28723}
28724func (self *OxmIdIcmpv4TypeMasked) GetOXMName() string {
28725 return "icmpv4_type_masked"
28726}
28727
28728func (self *OxmIdIcmpv4TypeMasked) MarshalJSON() ([]byte, error) {
28729 if self.TypeLen == 0 {
28730 return []byte("\"\""), nil
28731 } else {
28732 return []byte("\"" + self.GetOXMName() + "\""), nil
28733 }
28734}
28735
28736type OxmIdIcmpv6CodeMasked struct {
28737 *OxmId
28738}
28739
28740type IOxmIdIcmpv6CodeMasked interface {
28741 IOxmId
28742}
28743
28744func (self *OxmIdIcmpv6CodeMasked) Serialize(encoder *goloxi.Encoder) error {
28745 if err := self.OxmId.Serialize(encoder); err != nil {
28746 return err
28747 }
28748
28749 return nil
28750}
28751
28752func DecodeOxmIdIcmpv6CodeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6CodeMasked, error) {
28753 _oxmidicmpv6codemasked := &OxmIdIcmpv6CodeMasked{OxmId: parent}
28754 return _oxmidicmpv6codemasked, nil
28755}
28756
28757func NewOxmIdIcmpv6CodeMasked() *OxmIdIcmpv6CodeMasked {
28758 obj := &OxmIdIcmpv6CodeMasked{
28759 OxmId: NewOxmId(2147499266),
28760 }
28761 return obj
28762}
28763func (self *OxmIdIcmpv6CodeMasked) GetOXMName() string {
28764 return "icmpv6_code_masked"
28765}
28766
28767func (self *OxmIdIcmpv6CodeMasked) MarshalJSON() ([]byte, error) {
28768 if self.TypeLen == 0 {
28769 return []byte("\"\""), nil
28770 } else {
28771 return []byte("\"" + self.GetOXMName() + "\""), nil
28772 }
28773}
28774
28775type OxmIdIcmpv6TypeMasked struct {
28776 *OxmId
28777}
28778
28779type IOxmIdIcmpv6TypeMasked interface {
28780 IOxmId
28781}
28782
28783func (self *OxmIdIcmpv6TypeMasked) Serialize(encoder *goloxi.Encoder) error {
28784 if err := self.OxmId.Serialize(encoder); err != nil {
28785 return err
28786 }
28787
28788 return nil
28789}
28790
28791func DecodeOxmIdIcmpv6TypeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6TypeMasked, error) {
28792 _oxmidicmpv6typemasked := &OxmIdIcmpv6TypeMasked{OxmId: parent}
28793 return _oxmidicmpv6typemasked, nil
28794}
28795
28796func NewOxmIdIcmpv6TypeMasked() *OxmIdIcmpv6TypeMasked {
28797 obj := &OxmIdIcmpv6TypeMasked{
28798 OxmId: NewOxmId(2147498754),
28799 }
28800 return obj
28801}
28802func (self *OxmIdIcmpv6TypeMasked) GetOXMName() string {
28803 return "icmpv6_type_masked"
28804}
28805
28806func (self *OxmIdIcmpv6TypeMasked) MarshalJSON() ([]byte, error) {
28807 if self.TypeLen == 0 {
28808 return []byte("\"\""), nil
28809 } else {
28810 return []byte("\"" + self.GetOXMName() + "\""), nil
28811 }
28812}
28813
28814type OxmIdInPhyPort struct {
28815 *OxmId
28816}
28817
28818type IOxmIdInPhyPort interface {
28819 IOxmId
28820}
28821
28822func (self *OxmIdInPhyPort) Serialize(encoder *goloxi.Encoder) error {
28823 if err := self.OxmId.Serialize(encoder); err != nil {
28824 return err
28825 }
28826
28827 return nil
28828}
28829
28830func DecodeOxmIdInPhyPort(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPhyPort, error) {
28831 _oxmidinphyport := &OxmIdInPhyPort{OxmId: parent}
28832 return _oxmidinphyport, nil
28833}
28834
28835func NewOxmIdInPhyPort() *OxmIdInPhyPort {
28836 obj := &OxmIdInPhyPort{
28837 OxmId: NewOxmId(2147484164),
28838 }
28839 return obj
28840}
28841func (self *OxmIdInPhyPort) GetOXMName() string {
28842 return "in_phy_port"
28843}
28844
28845func (self *OxmIdInPhyPort) MarshalJSON() ([]byte, error) {
28846 if self.TypeLen == 0 {
28847 return []byte("\"\""), nil
28848 } else {
28849 return []byte("\"" + self.GetOXMName() + "\""), nil
28850 }
28851}
28852
28853type OxmIdInPhyPortMasked struct {
28854 *OxmId
28855}
28856
28857type IOxmIdInPhyPortMasked interface {
28858 IOxmId
28859}
28860
28861func (self *OxmIdInPhyPortMasked) Serialize(encoder *goloxi.Encoder) error {
28862 if err := self.OxmId.Serialize(encoder); err != nil {
28863 return err
28864 }
28865
28866 return nil
28867}
28868
28869func DecodeOxmIdInPhyPortMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPhyPortMasked, error) {
28870 _oxmidinphyportmasked := &OxmIdInPhyPortMasked{OxmId: parent}
28871 return _oxmidinphyportmasked, nil
28872}
28873
28874func NewOxmIdInPhyPortMasked() *OxmIdInPhyPortMasked {
28875 obj := &OxmIdInPhyPortMasked{
28876 OxmId: NewOxmId(2147484424),
28877 }
28878 return obj
28879}
28880func (self *OxmIdInPhyPortMasked) GetOXMName() string {
28881 return "in_phy_port_masked"
28882}
28883
28884func (self *OxmIdInPhyPortMasked) MarshalJSON() ([]byte, error) {
28885 if self.TypeLen == 0 {
28886 return []byte("\"\""), nil
28887 } else {
28888 return []byte("\"" + self.GetOXMName() + "\""), nil
28889 }
28890}
28891
28892type OxmIdInPortMasked struct {
28893 *OxmId
28894}
28895
28896type IOxmIdInPortMasked interface {
28897 IOxmId
28898}
28899
28900func (self *OxmIdInPortMasked) Serialize(encoder *goloxi.Encoder) error {
28901 if err := self.OxmId.Serialize(encoder); err != nil {
28902 return err
28903 }
28904
28905 return nil
28906}
28907
28908func DecodeOxmIdInPortMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPortMasked, error) {
28909 _oxmidinportmasked := &OxmIdInPortMasked{OxmId: parent}
28910 return _oxmidinportmasked, nil
28911}
28912
28913func NewOxmIdInPortMasked() *OxmIdInPortMasked {
28914 obj := &OxmIdInPortMasked{
28915 OxmId: NewOxmId(2147483912),
28916 }
28917 return obj
28918}
28919func (self *OxmIdInPortMasked) GetOXMName() string {
28920 return "in_port_masked"
28921}
28922
28923func (self *OxmIdInPortMasked) MarshalJSON() ([]byte, error) {
28924 if self.TypeLen == 0 {
28925 return []byte("\"\""), nil
28926 } else {
28927 return []byte("\"" + self.GetOXMName() + "\""), nil
28928 }
28929}
28930
28931type OxmIdIpDscp struct {
28932 *OxmId
28933}
28934
28935type IOxmIdIpDscp interface {
28936 IOxmId
28937}
28938
28939func (self *OxmIdIpDscp) Serialize(encoder *goloxi.Encoder) error {
28940 if err := self.OxmId.Serialize(encoder); err != nil {
28941 return err
28942 }
28943
28944 return nil
28945}
28946
28947func DecodeOxmIdIpDscp(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDscp, error) {
28948 _oxmidipdscp := &OxmIdIpDscp{OxmId: parent}
28949 return _oxmidipdscp, nil
28950}
28951
28952func NewOxmIdIpDscp() *OxmIdIpDscp {
28953 obj := &OxmIdIpDscp{
28954 OxmId: NewOxmId(2147487745),
28955 }
28956 return obj
28957}
28958func (self *OxmIdIpDscp) GetOXMName() string {
28959 return "ip_dscp"
28960}
28961
28962func (self *OxmIdIpDscp) MarshalJSON() ([]byte, error) {
28963 if self.TypeLen == 0 {
28964 return []byte("\"\""), nil
28965 } else {
28966 return []byte("\"" + self.GetOXMName() + "\""), nil
28967 }
28968}
28969
28970type OxmIdIpDscpMasked struct {
28971 *OxmId
28972}
28973
28974type IOxmIdIpDscpMasked interface {
28975 IOxmId
28976}
28977
28978func (self *OxmIdIpDscpMasked) Serialize(encoder *goloxi.Encoder) error {
28979 if err := self.OxmId.Serialize(encoder); err != nil {
28980 return err
28981 }
28982
28983 return nil
28984}
28985
28986func DecodeOxmIdIpDscpMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDscpMasked, error) {
28987 _oxmidipdscpmasked := &OxmIdIpDscpMasked{OxmId: parent}
28988 return _oxmidipdscpmasked, nil
28989}
28990
28991func NewOxmIdIpDscpMasked() *OxmIdIpDscpMasked {
28992 obj := &OxmIdIpDscpMasked{
28993 OxmId: NewOxmId(2147488002),
28994 }
28995 return obj
28996}
28997func (self *OxmIdIpDscpMasked) GetOXMName() string {
28998 return "ip_dscp_masked"
28999}
29000
29001func (self *OxmIdIpDscpMasked) MarshalJSON() ([]byte, error) {
29002 if self.TypeLen == 0 {
29003 return []byte("\"\""), nil
29004 } else {
29005 return []byte("\"" + self.GetOXMName() + "\""), nil
29006 }
29007}
29008
29009type OxmIdIpEcn struct {
29010 *OxmId
29011}
29012
29013type IOxmIdIpEcn interface {
29014 IOxmId
29015}
29016
29017func (self *OxmIdIpEcn) Serialize(encoder *goloxi.Encoder) error {
29018 if err := self.OxmId.Serialize(encoder); err != nil {
29019 return err
29020 }
29021
29022 return nil
29023}
29024
29025func DecodeOxmIdIpEcn(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpEcn, error) {
29026 _oxmidipecn := &OxmIdIpEcn{OxmId: parent}
29027 return _oxmidipecn, nil
29028}
29029
29030func NewOxmIdIpEcn() *OxmIdIpEcn {
29031 obj := &OxmIdIpEcn{
29032 OxmId: NewOxmId(2147488257),
29033 }
29034 return obj
29035}
29036func (self *OxmIdIpEcn) GetOXMName() string {
29037 return "ip_ecn"
29038}
29039
29040func (self *OxmIdIpEcn) MarshalJSON() ([]byte, error) {
29041 if self.TypeLen == 0 {
29042 return []byte("\"\""), nil
29043 } else {
29044 return []byte("\"" + self.GetOXMName() + "\""), nil
29045 }
29046}
29047
29048type OxmIdIpEcnMasked struct {
29049 *OxmId
29050}
29051
29052type IOxmIdIpEcnMasked interface {
29053 IOxmId
29054}
29055
29056func (self *OxmIdIpEcnMasked) Serialize(encoder *goloxi.Encoder) error {
29057 if err := self.OxmId.Serialize(encoder); err != nil {
29058 return err
29059 }
29060
29061 return nil
29062}
29063
29064func DecodeOxmIdIpEcnMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpEcnMasked, error) {
29065 _oxmidipecnmasked := &OxmIdIpEcnMasked{OxmId: parent}
29066 return _oxmidipecnmasked, nil
29067}
29068
29069func NewOxmIdIpEcnMasked() *OxmIdIpEcnMasked {
29070 obj := &OxmIdIpEcnMasked{
29071 OxmId: NewOxmId(2147488514),
29072 }
29073 return obj
29074}
29075func (self *OxmIdIpEcnMasked) GetOXMName() string {
29076 return "ip_ecn_masked"
29077}
29078
29079func (self *OxmIdIpEcnMasked) MarshalJSON() ([]byte, error) {
29080 if self.TypeLen == 0 {
29081 return []byte("\"\""), nil
29082 } else {
29083 return []byte("\"" + self.GetOXMName() + "\""), nil
29084 }
29085}
29086
29087type OxmIdIpProto struct {
29088 *OxmId
29089}
29090
29091type IOxmIdIpProto interface {
29092 IOxmId
29093}
29094
29095func (self *OxmIdIpProto) Serialize(encoder *goloxi.Encoder) error {
29096 if err := self.OxmId.Serialize(encoder); err != nil {
29097 return err
29098 }
29099
29100 return nil
29101}
29102
29103func DecodeOxmIdIpProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpProto, error) {
29104 _oxmidipproto := &OxmIdIpProto{OxmId: parent}
29105 return _oxmidipproto, nil
29106}
29107
29108func NewOxmIdIpProto() *OxmIdIpProto {
29109 obj := &OxmIdIpProto{
29110 OxmId: NewOxmId(2147488769),
29111 }
29112 return obj
29113}
29114func (self *OxmIdIpProto) GetOXMName() string {
29115 return "ip_proto"
29116}
29117
29118func (self *OxmIdIpProto) MarshalJSON() ([]byte, error) {
29119 if self.TypeLen == 0 {
29120 return []byte("\"\""), nil
29121 } else {
29122 return []byte("\"" + self.GetOXMName() + "\""), nil
29123 }
29124}
29125
29126type OxmIdIpProtoMasked struct {
29127 *OxmId
29128}
29129
29130type IOxmIdIpProtoMasked interface {
29131 IOxmId
29132}
29133
29134func (self *OxmIdIpProtoMasked) Serialize(encoder *goloxi.Encoder) error {
29135 if err := self.OxmId.Serialize(encoder); err != nil {
29136 return err
29137 }
29138
29139 return nil
29140}
29141
29142func DecodeOxmIdIpProtoMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpProtoMasked, error) {
29143 _oxmidipprotomasked := &OxmIdIpProtoMasked{OxmId: parent}
29144 return _oxmidipprotomasked, nil
29145}
29146
29147func NewOxmIdIpProtoMasked() *OxmIdIpProtoMasked {
29148 obj := &OxmIdIpProtoMasked{
29149 OxmId: NewOxmId(2147489026),
29150 }
29151 return obj
29152}
29153func (self *OxmIdIpProtoMasked) GetOXMName() string {
29154 return "ip_proto_masked"
29155}
29156
29157func (self *OxmIdIpProtoMasked) MarshalJSON() ([]byte, error) {
29158 if self.TypeLen == 0 {
29159 return []byte("\"\""), nil
29160 } else {
29161 return []byte("\"" + self.GetOXMName() + "\""), nil
29162 }
29163}
29164
29165type OxmIdIpv4Dst struct {
29166 *OxmId
29167}
29168
29169type IOxmIdIpv4Dst interface {
29170 IOxmId
29171}
29172
29173func (self *OxmIdIpv4Dst) Serialize(encoder *goloxi.Encoder) error {
29174 if err := self.OxmId.Serialize(encoder); err != nil {
29175 return err
29176 }
29177
29178 return nil
29179}
29180
29181func DecodeOxmIdIpv4Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4Dst, error) {
29182 _oxmidipv4dst := &OxmIdIpv4Dst{OxmId: parent}
29183 return _oxmidipv4dst, nil
29184}
29185
29186func NewOxmIdIpv4Dst() *OxmIdIpv4Dst {
29187 obj := &OxmIdIpv4Dst{
29188 OxmId: NewOxmId(2147489796),
29189 }
29190 return obj
29191}
29192func (self *OxmIdIpv4Dst) GetOXMName() string {
29193 return "ipv4_dst"
29194}
29195
29196func (self *OxmIdIpv4Dst) MarshalJSON() ([]byte, error) {
29197 if self.TypeLen == 0 {
29198 return []byte("\"\""), nil
29199 } else {
29200 return []byte("\"" + self.GetOXMName() + "\""), nil
29201 }
29202}
29203
29204type OxmIdIpv4DstMasked struct {
29205 *OxmId
29206}
29207
29208type IOxmIdIpv4DstMasked interface {
29209 IOxmId
29210}
29211
29212func (self *OxmIdIpv4DstMasked) Serialize(encoder *goloxi.Encoder) error {
29213 if err := self.OxmId.Serialize(encoder); err != nil {
29214 return err
29215 }
29216
29217 return nil
29218}
29219
29220func DecodeOxmIdIpv4DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4DstMasked, error) {
29221 _oxmidipv4dstmasked := &OxmIdIpv4DstMasked{OxmId: parent}
29222 return _oxmidipv4dstmasked, nil
29223}
29224
29225func NewOxmIdIpv4DstMasked() *OxmIdIpv4DstMasked {
29226 obj := &OxmIdIpv4DstMasked{
29227 OxmId: NewOxmId(2147490056),
29228 }
29229 return obj
29230}
29231func (self *OxmIdIpv4DstMasked) GetOXMName() string {
29232 return "ipv4_dst_masked"
29233}
29234
29235func (self *OxmIdIpv4DstMasked) MarshalJSON() ([]byte, error) {
29236 if self.TypeLen == 0 {
29237 return []byte("\"\""), nil
29238 } else {
29239 return []byte("\"" + self.GetOXMName() + "\""), nil
29240 }
29241}
29242
29243type OxmIdIpv4Src struct {
29244 *OxmId
29245}
29246
29247type IOxmIdIpv4Src interface {
29248 IOxmId
29249}
29250
29251func (self *OxmIdIpv4Src) Serialize(encoder *goloxi.Encoder) error {
29252 if err := self.OxmId.Serialize(encoder); err != nil {
29253 return err
29254 }
29255
29256 return nil
29257}
29258
29259func DecodeOxmIdIpv4Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4Src, error) {
29260 _oxmidipv4src := &OxmIdIpv4Src{OxmId: parent}
29261 return _oxmidipv4src, nil
29262}
29263
29264func NewOxmIdIpv4Src() *OxmIdIpv4Src {
29265 obj := &OxmIdIpv4Src{
29266 OxmId: NewOxmId(2147489284),
29267 }
29268 return obj
29269}
29270func (self *OxmIdIpv4Src) GetOXMName() string {
29271 return "ipv4_src"
29272}
29273
29274func (self *OxmIdIpv4Src) MarshalJSON() ([]byte, error) {
29275 if self.TypeLen == 0 {
29276 return []byte("\"\""), nil
29277 } else {
29278 return []byte("\"" + self.GetOXMName() + "\""), nil
29279 }
29280}
29281
29282type OxmIdIpv4SrcMasked struct {
29283 *OxmId
29284}
29285
29286type IOxmIdIpv4SrcMasked interface {
29287 IOxmId
29288}
29289
29290func (self *OxmIdIpv4SrcMasked) Serialize(encoder *goloxi.Encoder) error {
29291 if err := self.OxmId.Serialize(encoder); err != nil {
29292 return err
29293 }
29294
29295 return nil
29296}
29297
29298func DecodeOxmIdIpv4SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4SrcMasked, error) {
29299 _oxmidipv4srcmasked := &OxmIdIpv4SrcMasked{OxmId: parent}
29300 return _oxmidipv4srcmasked, nil
29301}
29302
29303func NewOxmIdIpv4SrcMasked() *OxmIdIpv4SrcMasked {
29304 obj := &OxmIdIpv4SrcMasked{
29305 OxmId: NewOxmId(2147489544),
29306 }
29307 return obj
29308}
29309func (self *OxmIdIpv4SrcMasked) GetOXMName() string {
29310 return "ipv4_src_masked"
29311}
29312
29313func (self *OxmIdIpv4SrcMasked) MarshalJSON() ([]byte, error) {
29314 if self.TypeLen == 0 {
29315 return []byte("\"\""), nil
29316 } else {
29317 return []byte("\"" + self.GetOXMName() + "\""), nil
29318 }
29319}
29320
29321type OxmIdIpv6Exthdr struct {
29322 *OxmId
29323}
29324
29325type IOxmIdIpv6Exthdr interface {
29326 IOxmId
29327}
29328
29329func (self *OxmIdIpv6Exthdr) Serialize(encoder *goloxi.Encoder) error {
29330 if err := self.OxmId.Serialize(encoder); err != nil {
29331 return err
29332 }
29333
29334 return nil
29335}
29336
29337func DecodeOxmIdIpv6Exthdr(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Exthdr, error) {
29338 _oxmidipv6exthdr := &OxmIdIpv6Exthdr{OxmId: parent}
29339 return _oxmidipv6exthdr, nil
29340}
29341
29342func NewOxmIdIpv6Exthdr() *OxmIdIpv6Exthdr {
29343 obj := &OxmIdIpv6Exthdr{
29344 OxmId: NewOxmId(2147503618),
29345 }
29346 return obj
29347}
29348func (self *OxmIdIpv6Exthdr) GetOXMName() string {
29349 return "ipv6_exthdr"
29350}
29351
29352func (self *OxmIdIpv6Exthdr) MarshalJSON() ([]byte, error) {
29353 if self.TypeLen == 0 {
29354 return []byte("\"\""), nil
29355 } else {
29356 return []byte("\"" + self.GetOXMName() + "\""), nil
29357 }
29358}
29359
29360type OxmIdIpv6ExthdrMasked struct {
29361 *OxmId
29362}
29363
29364type IOxmIdIpv6ExthdrMasked interface {
29365 IOxmId
29366}
29367
29368func (self *OxmIdIpv6ExthdrMasked) Serialize(encoder *goloxi.Encoder) error {
29369 if err := self.OxmId.Serialize(encoder); err != nil {
29370 return err
29371 }
29372
29373 return nil
29374}
29375
29376func DecodeOxmIdIpv6ExthdrMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6ExthdrMasked, error) {
29377 _oxmidipv6exthdrmasked := &OxmIdIpv6ExthdrMasked{OxmId: parent}
29378 return _oxmidipv6exthdrmasked, nil
29379}
29380
29381func NewOxmIdIpv6ExthdrMasked() *OxmIdIpv6ExthdrMasked {
29382 obj := &OxmIdIpv6ExthdrMasked{
29383 OxmId: NewOxmId(2147503876),
29384 }
29385 return obj
29386}
29387func (self *OxmIdIpv6ExthdrMasked) GetOXMName() string {
29388 return "ipv6_exthdr_masked"
29389}
29390
29391func (self *OxmIdIpv6ExthdrMasked) MarshalJSON() ([]byte, error) {
29392 if self.TypeLen == 0 {
29393 return []byte("\"\""), nil
29394 } else {
29395 return []byte("\"" + self.GetOXMName() + "\""), nil
29396 }
29397}
29398
29399type OxmIdIpv6Flabel struct {
29400 *OxmId
29401}
29402
29403type IOxmIdIpv6Flabel interface {
29404 IOxmId
29405}
29406
29407func (self *OxmIdIpv6Flabel) Serialize(encoder *goloxi.Encoder) error {
29408 if err := self.OxmId.Serialize(encoder); err != nil {
29409 return err
29410 }
29411
29412 return nil
29413}
29414
29415func DecodeOxmIdIpv6Flabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Flabel, error) {
29416 _oxmidipv6flabel := &OxmIdIpv6Flabel{OxmId: parent}
29417 return _oxmidipv6flabel, nil
29418}
29419
29420func NewOxmIdIpv6Flabel() *OxmIdIpv6Flabel {
29421 obj := &OxmIdIpv6Flabel{
29422 OxmId: NewOxmId(2147497988),
29423 }
29424 return obj
29425}
29426func (self *OxmIdIpv6Flabel) GetOXMName() string {
29427 return "ipv6_flabel"
29428}
29429
29430func (self *OxmIdIpv6Flabel) MarshalJSON() ([]byte, error) {
29431 if self.TypeLen == 0 {
29432 return []byte("\"\""), nil
29433 } else {
29434 return []byte("\"" + self.GetOXMName() + "\""), nil
29435 }
29436}
29437
29438type OxmIdIpv6FlabelMasked struct {
29439 *OxmId
29440}
29441
29442type IOxmIdIpv6FlabelMasked interface {
29443 IOxmId
29444}
29445
29446func (self *OxmIdIpv6FlabelMasked) Serialize(encoder *goloxi.Encoder) error {
29447 if err := self.OxmId.Serialize(encoder); err != nil {
29448 return err
29449 }
29450
29451 return nil
29452}
29453
29454func DecodeOxmIdIpv6FlabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6FlabelMasked, error) {
29455 _oxmidipv6flabelmasked := &OxmIdIpv6FlabelMasked{OxmId: parent}
29456 return _oxmidipv6flabelmasked, nil
29457}
29458
29459func NewOxmIdIpv6FlabelMasked() *OxmIdIpv6FlabelMasked {
29460 obj := &OxmIdIpv6FlabelMasked{
29461 OxmId: NewOxmId(2147498248),
29462 }
29463 return obj
29464}
29465func (self *OxmIdIpv6FlabelMasked) GetOXMName() string {
29466 return "ipv6_flabel_masked"
29467}
29468
29469func (self *OxmIdIpv6FlabelMasked) MarshalJSON() ([]byte, error) {
29470 if self.TypeLen == 0 {
29471 return []byte("\"\""), nil
29472 } else {
29473 return []byte("\"" + self.GetOXMName() + "\""), nil
29474 }
29475}
29476
29477type OxmIdIpv6NdSll struct {
29478 *OxmId
29479}
29480
29481type IOxmIdIpv6NdSll interface {
29482 IOxmId
29483}
29484
29485func (self *OxmIdIpv6NdSll) Serialize(encoder *goloxi.Encoder) error {
29486 if err := self.OxmId.Serialize(encoder); err != nil {
29487 return err
29488 }
29489
29490 return nil
29491}
29492
29493func DecodeOxmIdIpv6NdSll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdSll, error) {
29494 _oxmidipv6ndsll := &OxmIdIpv6NdSll{OxmId: parent}
29495 return _oxmidipv6ndsll, nil
29496}
29497
29498func NewOxmIdIpv6NdSll() *OxmIdIpv6NdSll {
29499 obj := &OxmIdIpv6NdSll{
29500 OxmId: NewOxmId(2147500038),
29501 }
29502 return obj
29503}
29504func (self *OxmIdIpv6NdSll) GetOXMName() string {
29505 return "ipv6_nd_sll"
29506}
29507
29508func (self *OxmIdIpv6NdSll) MarshalJSON() ([]byte, error) {
29509 if self.TypeLen == 0 {
29510 return []byte("\"\""), nil
29511 } else {
29512 return []byte("\"" + self.GetOXMName() + "\""), nil
29513 }
29514}
29515
29516type OxmIdIpv6NdSllMasked struct {
29517 *OxmId
29518}
29519
29520type IOxmIdIpv6NdSllMasked interface {
29521 IOxmId
29522}
29523
29524func (self *OxmIdIpv6NdSllMasked) Serialize(encoder *goloxi.Encoder) error {
29525 if err := self.OxmId.Serialize(encoder); err != nil {
29526 return err
29527 }
29528
29529 return nil
29530}
29531
29532func DecodeOxmIdIpv6NdSllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdSllMasked, error) {
29533 _oxmidipv6ndsllmasked := &OxmIdIpv6NdSllMasked{OxmId: parent}
29534 return _oxmidipv6ndsllmasked, nil
29535}
29536
29537func NewOxmIdIpv6NdSllMasked() *OxmIdIpv6NdSllMasked {
29538 obj := &OxmIdIpv6NdSllMasked{
29539 OxmId: NewOxmId(2147500300),
29540 }
29541 return obj
29542}
29543func (self *OxmIdIpv6NdSllMasked) GetOXMName() string {
29544 return "ipv6_nd_sll_masked"
29545}
29546
29547func (self *OxmIdIpv6NdSllMasked) MarshalJSON() ([]byte, error) {
29548 if self.TypeLen == 0 {
29549 return []byte("\"\""), nil
29550 } else {
29551 return []byte("\"" + self.GetOXMName() + "\""), nil
29552 }
29553}
29554
29555type OxmIdIpv6NdTarget struct {
29556 *OxmId
29557}
29558
29559type IOxmIdIpv6NdTarget interface {
29560 IOxmId
29561}
29562
29563func (self *OxmIdIpv6NdTarget) Serialize(encoder *goloxi.Encoder) error {
29564 if err := self.OxmId.Serialize(encoder); err != nil {
29565 return err
29566 }
29567
29568 return nil
29569}
29570
29571func DecodeOxmIdIpv6NdTarget(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTarget, error) {
29572 _oxmidipv6ndtarget := &OxmIdIpv6NdTarget{OxmId: parent}
29573 return _oxmidipv6ndtarget, nil
29574}
29575
29576func NewOxmIdIpv6NdTarget() *OxmIdIpv6NdTarget {
29577 obj := &OxmIdIpv6NdTarget{
29578 OxmId: NewOxmId(2147499536),
29579 }
29580 return obj
29581}
29582func (self *OxmIdIpv6NdTarget) GetOXMName() string {
29583 return "ipv6_nd_target"
29584}
29585
29586func (self *OxmIdIpv6NdTarget) MarshalJSON() ([]byte, error) {
29587 if self.TypeLen == 0 {
29588 return []byte("\"\""), nil
29589 } else {
29590 return []byte("\"" + self.GetOXMName() + "\""), nil
29591 }
29592}
29593
29594type OxmIdIpv6NdTargetMasked struct {
29595 *OxmId
29596}
29597
29598type IOxmIdIpv6NdTargetMasked interface {
29599 IOxmId
29600}
29601
29602func (self *OxmIdIpv6NdTargetMasked) Serialize(encoder *goloxi.Encoder) error {
29603 if err := self.OxmId.Serialize(encoder); err != nil {
29604 return err
29605 }
29606
29607 return nil
29608}
29609
29610func DecodeOxmIdIpv6NdTargetMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTargetMasked, error) {
29611 _oxmidipv6ndtargetmasked := &OxmIdIpv6NdTargetMasked{OxmId: parent}
29612 return _oxmidipv6ndtargetmasked, nil
29613}
29614
29615func NewOxmIdIpv6NdTargetMasked() *OxmIdIpv6NdTargetMasked {
29616 obj := &OxmIdIpv6NdTargetMasked{
29617 OxmId: NewOxmId(2147499808),
29618 }
29619 return obj
29620}
29621func (self *OxmIdIpv6NdTargetMasked) GetOXMName() string {
29622 return "ipv6_nd_target_masked"
29623}
29624
29625func (self *OxmIdIpv6NdTargetMasked) MarshalJSON() ([]byte, error) {
29626 if self.TypeLen == 0 {
29627 return []byte("\"\""), nil
29628 } else {
29629 return []byte("\"" + self.GetOXMName() + "\""), nil
29630 }
29631}
29632
29633type OxmIdIpv6NdTll struct {
29634 *OxmId
29635}
29636
29637type IOxmIdIpv6NdTll interface {
29638 IOxmId
29639}
29640
29641func (self *OxmIdIpv6NdTll) Serialize(encoder *goloxi.Encoder) error {
29642 if err := self.OxmId.Serialize(encoder); err != nil {
29643 return err
29644 }
29645
29646 return nil
29647}
29648
29649func DecodeOxmIdIpv6NdTll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTll, error) {
29650 _oxmidipv6ndtll := &OxmIdIpv6NdTll{OxmId: parent}
29651 return _oxmidipv6ndtll, nil
29652}
29653
29654func NewOxmIdIpv6NdTll() *OxmIdIpv6NdTll {
29655 obj := &OxmIdIpv6NdTll{
29656 OxmId: NewOxmId(2147500550),
29657 }
29658 return obj
29659}
29660func (self *OxmIdIpv6NdTll) GetOXMName() string {
29661 return "ipv6_nd_tll"
29662}
29663
29664func (self *OxmIdIpv6NdTll) MarshalJSON() ([]byte, error) {
29665 if self.TypeLen == 0 {
29666 return []byte("\"\""), nil
29667 } else {
29668 return []byte("\"" + self.GetOXMName() + "\""), nil
29669 }
29670}
29671
29672type OxmIdIpv6NdTllMasked struct {
29673 *OxmId
29674}
29675
29676type IOxmIdIpv6NdTllMasked interface {
29677 IOxmId
29678}
29679
29680func (self *OxmIdIpv6NdTllMasked) Serialize(encoder *goloxi.Encoder) error {
29681 if err := self.OxmId.Serialize(encoder); err != nil {
29682 return err
29683 }
29684
29685 return nil
29686}
29687
29688func DecodeOxmIdIpv6NdTllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTllMasked, error) {
29689 _oxmidipv6ndtllmasked := &OxmIdIpv6NdTllMasked{OxmId: parent}
29690 return _oxmidipv6ndtllmasked, nil
29691}
29692
29693func NewOxmIdIpv6NdTllMasked() *OxmIdIpv6NdTllMasked {
29694 obj := &OxmIdIpv6NdTllMasked{
29695 OxmId: NewOxmId(2147500812),
29696 }
29697 return obj
29698}
29699func (self *OxmIdIpv6NdTllMasked) GetOXMName() string {
29700 return "ipv6_nd_tll_masked"
29701}
29702
29703func (self *OxmIdIpv6NdTllMasked) MarshalJSON() ([]byte, error) {
29704 if self.TypeLen == 0 {
29705 return []byte("\"\""), nil
29706 } else {
29707 return []byte("\"" + self.GetOXMName() + "\""), nil
29708 }
29709}
29710
29711type OxmIdMetadata struct {
29712 *OxmId
29713}
29714
29715type IOxmIdMetadata interface {
29716 IOxmId
29717}
29718
29719func (self *OxmIdMetadata) Serialize(encoder *goloxi.Encoder) error {
29720 if err := self.OxmId.Serialize(encoder); err != nil {
29721 return err
29722 }
29723
29724 return nil
29725}
29726
29727func DecodeOxmIdMetadata(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMetadata, error) {
29728 _oxmidmetadata := &OxmIdMetadata{OxmId: parent}
29729 return _oxmidmetadata, nil
29730}
29731
29732func NewOxmIdMetadata() *OxmIdMetadata {
29733 obj := &OxmIdMetadata{
29734 OxmId: NewOxmId(2147484680),
29735 }
29736 return obj
29737}
29738func (self *OxmIdMetadata) GetOXMName() string {
29739 return "metadata"
29740}
29741
29742func (self *OxmIdMetadata) MarshalJSON() ([]byte, error) {
29743 if self.TypeLen == 0 {
29744 return []byte("\"\""), nil
29745 } else {
29746 return []byte("\"" + self.GetOXMName() + "\""), nil
29747 }
29748}
29749
29750type OxmIdMetadataMasked struct {
29751 *OxmId
29752}
29753
29754type IOxmIdMetadataMasked interface {
29755 IOxmId
29756}
29757
29758func (self *OxmIdMetadataMasked) Serialize(encoder *goloxi.Encoder) error {
29759 if err := self.OxmId.Serialize(encoder); err != nil {
29760 return err
29761 }
29762
29763 return nil
29764}
29765
29766func DecodeOxmIdMetadataMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMetadataMasked, error) {
29767 _oxmidmetadatamasked := &OxmIdMetadataMasked{OxmId: parent}
29768 return _oxmidmetadatamasked, nil
29769}
29770
29771func NewOxmIdMetadataMasked() *OxmIdMetadataMasked {
29772 obj := &OxmIdMetadataMasked{
29773 OxmId: NewOxmId(2147484944),
29774 }
29775 return obj
29776}
29777func (self *OxmIdMetadataMasked) GetOXMName() string {
29778 return "metadata_masked"
29779}
29780
29781func (self *OxmIdMetadataMasked) MarshalJSON() ([]byte, error) {
29782 if self.TypeLen == 0 {
29783 return []byte("\"\""), nil
29784 } else {
29785 return []byte("\"" + self.GetOXMName() + "\""), nil
29786 }
29787}
29788
29789type OxmIdMplsBos struct {
29790 *OxmId
29791}
29792
29793type IOxmIdMplsBos interface {
29794 IOxmId
29795}
29796
29797func (self *OxmIdMplsBos) Serialize(encoder *goloxi.Encoder) error {
29798 if err := self.OxmId.Serialize(encoder); err != nil {
29799 return err
29800 }
29801
29802 return nil
29803}
29804
29805func DecodeOxmIdMplsBos(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsBos, error) {
29806 _oxmidmplsbos := &OxmIdMplsBos{OxmId: parent}
29807 return _oxmidmplsbos, nil
29808}
29809
29810func NewOxmIdMplsBos() *OxmIdMplsBos {
29811 obj := &OxmIdMplsBos{
29812 OxmId: NewOxmId(2147502081),
29813 }
29814 return obj
29815}
29816func (self *OxmIdMplsBos) GetOXMName() string {
29817 return "mpls_bos"
29818}
29819
29820func (self *OxmIdMplsBos) MarshalJSON() ([]byte, error) {
29821 if self.TypeLen == 0 {
29822 return []byte("\"\""), nil
29823 } else {
29824 return []byte("\"" + self.GetOXMName() + "\""), nil
29825 }
29826}
29827
29828type OxmIdMplsBosMasked struct {
29829 *OxmId
29830}
29831
29832type IOxmIdMplsBosMasked interface {
29833 IOxmId
29834}
29835
29836func (self *OxmIdMplsBosMasked) Serialize(encoder *goloxi.Encoder) error {
29837 if err := self.OxmId.Serialize(encoder); err != nil {
29838 return err
29839 }
29840
29841 return nil
29842}
29843
29844func DecodeOxmIdMplsBosMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsBosMasked, error) {
29845 _oxmidmplsbosmasked := &OxmIdMplsBosMasked{OxmId: parent}
29846 return _oxmidmplsbosmasked, nil
29847}
29848
29849func NewOxmIdMplsBosMasked() *OxmIdMplsBosMasked {
29850 obj := &OxmIdMplsBosMasked{
29851 OxmId: NewOxmId(2147502338),
29852 }
29853 return obj
29854}
29855func (self *OxmIdMplsBosMasked) GetOXMName() string {
29856 return "mpls_bos_masked"
29857}
29858
29859func (self *OxmIdMplsBosMasked) MarshalJSON() ([]byte, error) {
29860 if self.TypeLen == 0 {
29861 return []byte("\"\""), nil
29862 } else {
29863 return []byte("\"" + self.GetOXMName() + "\""), nil
29864 }
29865}
29866
29867type OxmIdMplsLabel struct {
29868 *OxmId
29869}
29870
29871type IOxmIdMplsLabel interface {
29872 IOxmId
29873}
29874
29875func (self *OxmIdMplsLabel) Serialize(encoder *goloxi.Encoder) error {
29876 if err := self.OxmId.Serialize(encoder); err != nil {
29877 return err
29878 }
29879
29880 return nil
29881}
29882
29883func DecodeOxmIdMplsLabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsLabel, error) {
29884 _oxmidmplslabel := &OxmIdMplsLabel{OxmId: parent}
29885 return _oxmidmplslabel, nil
29886}
29887
29888func NewOxmIdMplsLabel() *OxmIdMplsLabel {
29889 obj := &OxmIdMplsLabel{
29890 OxmId: NewOxmId(2147501060),
29891 }
29892 return obj
29893}
29894func (self *OxmIdMplsLabel) GetOXMName() string {
29895 return "mpls_label"
29896}
29897
29898func (self *OxmIdMplsLabel) MarshalJSON() ([]byte, error) {
29899 if self.TypeLen == 0 {
29900 return []byte("\"\""), nil
29901 } else {
29902 return []byte("\"" + self.GetOXMName() + "\""), nil
29903 }
29904}
29905
29906type OxmIdMplsLabelMasked struct {
29907 *OxmId
29908}
29909
29910type IOxmIdMplsLabelMasked interface {
29911 IOxmId
29912}
29913
29914func (self *OxmIdMplsLabelMasked) Serialize(encoder *goloxi.Encoder) error {
29915 if err := self.OxmId.Serialize(encoder); err != nil {
29916 return err
29917 }
29918
29919 return nil
29920}
29921
29922func DecodeOxmIdMplsLabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsLabelMasked, error) {
29923 _oxmidmplslabelmasked := &OxmIdMplsLabelMasked{OxmId: parent}
29924 return _oxmidmplslabelmasked, nil
29925}
29926
29927func NewOxmIdMplsLabelMasked() *OxmIdMplsLabelMasked {
29928 obj := &OxmIdMplsLabelMasked{
29929 OxmId: NewOxmId(2147501320),
29930 }
29931 return obj
29932}
29933func (self *OxmIdMplsLabelMasked) GetOXMName() string {
29934 return "mpls_label_masked"
29935}
29936
29937func (self *OxmIdMplsLabelMasked) MarshalJSON() ([]byte, error) {
29938 if self.TypeLen == 0 {
29939 return []byte("\"\""), nil
29940 } else {
29941 return []byte("\"" + self.GetOXMName() + "\""), nil
29942 }
29943}
29944
29945type OxmIdMplsTc struct {
29946 *OxmId
29947}
29948
29949type IOxmIdMplsTc interface {
29950 IOxmId
29951}
29952
29953func (self *OxmIdMplsTc) Serialize(encoder *goloxi.Encoder) error {
29954 if err := self.OxmId.Serialize(encoder); err != nil {
29955 return err
29956 }
29957
29958 return nil
29959}
29960
29961func DecodeOxmIdMplsTc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsTc, error) {
29962 _oxmidmplstc := &OxmIdMplsTc{OxmId: parent}
29963 return _oxmidmplstc, nil
29964}
29965
29966func NewOxmIdMplsTc() *OxmIdMplsTc {
29967 obj := &OxmIdMplsTc{
29968 OxmId: NewOxmId(2147501569),
29969 }
29970 return obj
29971}
29972func (self *OxmIdMplsTc) GetOXMName() string {
29973 return "mpls_tc"
29974}
29975
29976func (self *OxmIdMplsTc) MarshalJSON() ([]byte, error) {
29977 if self.TypeLen == 0 {
29978 return []byte("\"\""), nil
29979 } else {
29980 return []byte("\"" + self.GetOXMName() + "\""), nil
29981 }
29982}
29983
29984type OxmIdMplsTcMasked struct {
29985 *OxmId
29986}
29987
29988type IOxmIdMplsTcMasked interface {
29989 IOxmId
29990}
29991
29992func (self *OxmIdMplsTcMasked) Serialize(encoder *goloxi.Encoder) error {
29993 if err := self.OxmId.Serialize(encoder); err != nil {
29994 return err
29995 }
29996
29997 return nil
29998}
29999
30000func DecodeOxmIdMplsTcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsTcMasked, error) {
30001 _oxmidmplstcmasked := &OxmIdMplsTcMasked{OxmId: parent}
30002 return _oxmidmplstcmasked, nil
30003}
30004
30005func NewOxmIdMplsTcMasked() *OxmIdMplsTcMasked {
30006 obj := &OxmIdMplsTcMasked{
30007 OxmId: NewOxmId(2147501826),
30008 }
30009 return obj
30010}
30011func (self *OxmIdMplsTcMasked) GetOXMName() string {
30012 return "mpls_tc_masked"
30013}
30014
30015func (self *OxmIdMplsTcMasked) MarshalJSON() ([]byte, error) {
30016 if self.TypeLen == 0 {
30017 return []byte("\"\""), nil
30018 } else {
30019 return []byte("\"" + self.GetOXMName() + "\""), nil
30020 }
30021}
30022
30023type OxmIdOvsTcpFlags struct {
30024 *OxmId
30025 ExperimenterId uint32
30026}
30027
30028type IOxmIdOvsTcpFlags interface {
30029 IOxmId
30030 GetExperimenterId() uint32
30031}
30032
30033func (self *OxmIdOvsTcpFlags) GetExperimenterId() uint32 {
30034 return self.ExperimenterId
30035}
30036
30037func (self *OxmIdOvsTcpFlags) SetExperimenterId(v uint32) {
30038 self.ExperimenterId = v
30039}
30040
30041func (self *OxmIdOvsTcpFlags) Serialize(encoder *goloxi.Encoder) error {
30042 if err := self.OxmId.Serialize(encoder); err != nil {
30043 return err
30044 }
30045
30046 encoder.PutUint32(uint32(self.ExperimenterId))
30047
30048 return nil
30049}
30050
30051func DecodeOxmIdOvsTcpFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdOvsTcpFlags, error) {
30052 _oxmidovstcpflags := &OxmIdOvsTcpFlags{OxmId: parent}
30053 if decoder.Length() < 4 {
30054 return nil, fmt.Errorf("OxmIdOvsTcpFlags packet too short: %d < 4", decoder.Length())
30055 }
30056 _oxmidovstcpflags.ExperimenterId = uint32(decoder.ReadUint32())
30057 return _oxmidovstcpflags, nil
30058}
30059
30060func NewOxmIdOvsTcpFlags() *OxmIdOvsTcpFlags {
30061 obj := &OxmIdOvsTcpFlags{
30062 OxmId: NewOxmId(4294923270),
30063 }
30064 return obj
30065}
30066func (self *OxmIdOvsTcpFlags) GetOXMName() string {
30067 return "ovs_tcp_flags"
30068}
30069
30070func (self *OxmIdOvsTcpFlags) MarshalJSON() ([]byte, error) {
30071 if self.TypeLen == 0 {
30072 return []byte("\"\""), nil
30073 } else {
30074 return []byte("\"" + self.GetOXMName() + "\""), nil
30075 }
30076}
30077
30078type OxmIdOvsTcpFlagsMasked struct {
30079 *OxmId
30080 ExperimenterId uint32
30081}
30082
30083type IOxmIdOvsTcpFlagsMasked interface {
30084 IOxmId
30085 GetExperimenterId() uint32
30086}
30087
30088func (self *OxmIdOvsTcpFlagsMasked) GetExperimenterId() uint32 {
30089 return self.ExperimenterId
30090}
30091
30092func (self *OxmIdOvsTcpFlagsMasked) SetExperimenterId(v uint32) {
30093 self.ExperimenterId = v
30094}
30095
30096func (self *OxmIdOvsTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
30097 if err := self.OxmId.Serialize(encoder); err != nil {
30098 return err
30099 }
30100
30101 encoder.PutUint32(uint32(self.ExperimenterId))
30102
30103 return nil
30104}
30105
30106func DecodeOxmIdOvsTcpFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdOvsTcpFlagsMasked, error) {
30107 _oxmidovstcpflagsmasked := &OxmIdOvsTcpFlagsMasked{OxmId: parent}
30108 if decoder.Length() < 4 {
30109 return nil, fmt.Errorf("OxmIdOvsTcpFlagsMasked packet too short: %d < 4", decoder.Length())
30110 }
30111 _oxmidovstcpflagsmasked.ExperimenterId = uint32(decoder.ReadUint32())
30112 return _oxmidovstcpflagsmasked, nil
30113}
30114
30115func NewOxmIdOvsTcpFlagsMasked() *OxmIdOvsTcpFlagsMasked {
30116 obj := &OxmIdOvsTcpFlagsMasked{
30117 OxmId: NewOxmId(4294923528),
30118 }
30119 return obj
30120}
30121func (self *OxmIdOvsTcpFlagsMasked) GetOXMName() string {
30122 return "ovs_tcp_flags_masked"
30123}
30124
30125func (self *OxmIdOvsTcpFlagsMasked) MarshalJSON() ([]byte, error) {
30126 if self.TypeLen == 0 {
30127 return []byte("\"\""), nil
30128 } else {
30129 return []byte("\"" + self.GetOXMName() + "\""), nil
30130 }
30131}
30132
30133type OxmIdSctpDst struct {
30134 *OxmId
30135}
30136
30137type IOxmIdSctpDst interface {
30138 IOxmId
30139}
30140
30141func (self *OxmIdSctpDst) Serialize(encoder *goloxi.Encoder) error {
30142 if err := self.OxmId.Serialize(encoder); err != nil {
30143 return err
30144 }
30145
30146 return nil
30147}
30148
30149func DecodeOxmIdSctpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpDst, error) {
30150 _oxmidsctpdst := &OxmIdSctpDst{OxmId: parent}
30151 return _oxmidsctpdst, nil
30152}
30153
30154func NewOxmIdSctpDst() *OxmIdSctpDst {
30155 obj := &OxmIdSctpDst{
30156 OxmId: NewOxmId(2147492866),
30157 }
30158 return obj
30159}
30160func (self *OxmIdSctpDst) GetOXMName() string {
30161 return "sctp_dst"
30162}
30163
30164func (self *OxmIdSctpDst) MarshalJSON() ([]byte, error) {
30165 if self.TypeLen == 0 {
30166 return []byte("\"\""), nil
30167 } else {
30168 return []byte("\"" + self.GetOXMName() + "\""), nil
30169 }
30170}
30171
30172type OxmIdSctpDstMasked struct {
30173 *OxmId
30174}
30175
30176type IOxmIdSctpDstMasked interface {
30177 IOxmId
30178}
30179
30180func (self *OxmIdSctpDstMasked) Serialize(encoder *goloxi.Encoder) error {
30181 if err := self.OxmId.Serialize(encoder); err != nil {
30182 return err
30183 }
30184
30185 return nil
30186}
30187
30188func DecodeOxmIdSctpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpDstMasked, error) {
30189 _oxmidsctpdstmasked := &OxmIdSctpDstMasked{OxmId: parent}
30190 return _oxmidsctpdstmasked, nil
30191}
30192
30193func NewOxmIdSctpDstMasked() *OxmIdSctpDstMasked {
30194 obj := &OxmIdSctpDstMasked{
30195 OxmId: NewOxmId(2147493124),
30196 }
30197 return obj
30198}
30199func (self *OxmIdSctpDstMasked) GetOXMName() string {
30200 return "sctp_dst_masked"
30201}
30202
30203func (self *OxmIdSctpDstMasked) MarshalJSON() ([]byte, error) {
30204 if self.TypeLen == 0 {
30205 return []byte("\"\""), nil
30206 } else {
30207 return []byte("\"" + self.GetOXMName() + "\""), nil
30208 }
30209}
30210
30211type OxmIdSctpSrc struct {
30212 *OxmId
30213}
30214
30215type IOxmIdSctpSrc interface {
30216 IOxmId
30217}
30218
30219func (self *OxmIdSctpSrc) Serialize(encoder *goloxi.Encoder) error {
30220 if err := self.OxmId.Serialize(encoder); err != nil {
30221 return err
30222 }
30223
30224 return nil
30225}
30226
30227func DecodeOxmIdSctpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpSrc, error) {
30228 _oxmidsctpsrc := &OxmIdSctpSrc{OxmId: parent}
30229 return _oxmidsctpsrc, nil
30230}
30231
30232func NewOxmIdSctpSrc() *OxmIdSctpSrc {
30233 obj := &OxmIdSctpSrc{
30234 OxmId: NewOxmId(2147492354),
30235 }
30236 return obj
30237}
30238func (self *OxmIdSctpSrc) GetOXMName() string {
30239 return "sctp_src"
30240}
30241
30242func (self *OxmIdSctpSrc) MarshalJSON() ([]byte, error) {
30243 if self.TypeLen == 0 {
30244 return []byte("\"\""), nil
30245 } else {
30246 return []byte("\"" + self.GetOXMName() + "\""), nil
30247 }
30248}
30249
30250type OxmIdSctpSrcMasked struct {
30251 *OxmId
30252}
30253
30254type IOxmIdSctpSrcMasked interface {
30255 IOxmId
30256}
30257
30258func (self *OxmIdSctpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
30259 if err := self.OxmId.Serialize(encoder); err != nil {
30260 return err
30261 }
30262
30263 return nil
30264}
30265
30266func DecodeOxmIdSctpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpSrcMasked, error) {
30267 _oxmidsctpsrcmasked := &OxmIdSctpSrcMasked{OxmId: parent}
30268 return _oxmidsctpsrcmasked, nil
30269}
30270
30271func NewOxmIdSctpSrcMasked() *OxmIdSctpSrcMasked {
30272 obj := &OxmIdSctpSrcMasked{
30273 OxmId: NewOxmId(2147492612),
30274 }
30275 return obj
30276}
30277func (self *OxmIdSctpSrcMasked) GetOXMName() string {
30278 return "sctp_src_masked"
30279}
30280
30281func (self *OxmIdSctpSrcMasked) MarshalJSON() ([]byte, error) {
30282 if self.TypeLen == 0 {
30283 return []byte("\"\""), nil
30284 } else {
30285 return []byte("\"" + self.GetOXMName() + "\""), nil
30286 }
30287}
30288
30289type OxmIdTunnelId struct {
30290 *OxmId
30291}
30292
30293type IOxmIdTunnelId interface {
30294 IOxmId
30295}
30296
30297func (self *OxmIdTunnelId) Serialize(encoder *goloxi.Encoder) error {
30298 if err := self.OxmId.Serialize(encoder); err != nil {
30299 return err
30300 }
30301
30302 return nil
30303}
30304
30305func DecodeOxmIdTunnelId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelId, error) {
30306 _oxmidtunnelid := &OxmIdTunnelId{OxmId: parent}
30307 return _oxmidtunnelid, nil
30308}
30309
30310func NewOxmIdTunnelId() *OxmIdTunnelId {
30311 obj := &OxmIdTunnelId{
30312 OxmId: NewOxmId(2147503112),
30313 }
30314 return obj
30315}
30316func (self *OxmIdTunnelId) GetOXMName() string {
30317 return "tunnel_id"
30318}
30319
30320func (self *OxmIdTunnelId) MarshalJSON() ([]byte, error) {
30321 if self.TypeLen == 0 {
30322 return []byte("\"\""), nil
30323 } else {
30324 return []byte("\"" + self.GetOXMName() + "\""), nil
30325 }
30326}
30327
30328type OxmIdTunnelIdMasked struct {
30329 *OxmId
30330}
30331
30332type IOxmIdTunnelIdMasked interface {
30333 IOxmId
30334}
30335
30336func (self *OxmIdTunnelIdMasked) Serialize(encoder *goloxi.Encoder) error {
30337 if err := self.OxmId.Serialize(encoder); err != nil {
30338 return err
30339 }
30340
30341 return nil
30342}
30343
30344func DecodeOxmIdTunnelIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelIdMasked, error) {
30345 _oxmidtunnelidmasked := &OxmIdTunnelIdMasked{OxmId: parent}
30346 return _oxmidtunnelidmasked, nil
30347}
30348
30349func NewOxmIdTunnelIdMasked() *OxmIdTunnelIdMasked {
30350 obj := &OxmIdTunnelIdMasked{
30351 OxmId: NewOxmId(2147503376),
30352 }
30353 return obj
30354}
30355func (self *OxmIdTunnelIdMasked) GetOXMName() string {
30356 return "tunnel_id_masked"
30357}
30358
30359func (self *OxmIdTunnelIdMasked) MarshalJSON() ([]byte, error) {
30360 if self.TypeLen == 0 {
30361 return []byte("\"\""), nil
30362 } else {
30363 return []byte("\"" + self.GetOXMName() + "\""), nil
30364 }
30365}
30366
30367type OxmIdTunnelIpv4Dst struct {
30368 *OxmId
30369}
30370
30371type IOxmIdTunnelIpv4Dst interface {
30372 IOxmId
30373}
30374
30375func (self *OxmIdTunnelIpv4Dst) Serialize(encoder *goloxi.Encoder) error {
30376 if err := self.OxmId.Serialize(encoder); err != nil {
30377 return err
30378 }
30379
30380 return nil
30381}
30382
30383func DecodeOxmIdTunnelIpv4Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelIpv4Dst, error) {
30384 _oxmidtunnelipv4dst := &OxmIdTunnelIpv4Dst{OxmId: parent}
30385 return _oxmidtunnelipv4dst, nil
30386}
30387
30388func NewOxmIdTunnelIpv4Dst() *OxmIdTunnelIpv4Dst {
30389 obj := &OxmIdTunnelIpv4Dst{
30390 OxmId: NewOxmId(81924),
30391 }
30392 return obj
30393}
30394func (self *OxmIdTunnelIpv4Dst) GetOXMName() string {
30395 return "tunnel_ipv4_dst"
30396}
30397
30398func (self *OxmIdTunnelIpv4Dst) MarshalJSON() ([]byte, error) {
30399 if self.TypeLen == 0 {
30400 return []byte("\"\""), nil
30401 } else {
30402 return []byte("\"" + self.GetOXMName() + "\""), nil
30403 }
30404}
30405
30406type OxmIdTunnelIpv4DstMasked struct {
30407 *OxmId
30408}
30409
30410type IOxmIdTunnelIpv4DstMasked interface {
30411 IOxmId
30412}
30413
30414func (self *OxmIdTunnelIpv4DstMasked) Serialize(encoder *goloxi.Encoder) error {
30415 if err := self.OxmId.Serialize(encoder); err != nil {
30416 return err
30417 }
30418
30419 return nil
30420}
30421
30422func DecodeOxmIdTunnelIpv4DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelIpv4DstMasked, error) {
30423 _oxmidtunnelipv4dstmasked := &OxmIdTunnelIpv4DstMasked{OxmId: parent}
30424 return _oxmidtunnelipv4dstmasked, nil
30425}
30426
30427func NewOxmIdTunnelIpv4DstMasked() *OxmIdTunnelIpv4DstMasked {
30428 obj := &OxmIdTunnelIpv4DstMasked{
30429 OxmId: NewOxmId(82184),
30430 }
30431 return obj
30432}
30433func (self *OxmIdTunnelIpv4DstMasked) GetOXMName() string {
30434 return "tunnel_ipv4_dst_masked"
30435}
30436
30437func (self *OxmIdTunnelIpv4DstMasked) MarshalJSON() ([]byte, error) {
30438 if self.TypeLen == 0 {
30439 return []byte("\"\""), nil
30440 } else {
30441 return []byte("\"" + self.GetOXMName() + "\""), nil
30442 }
30443}
30444
30445type OxmIdTunnelIpv4Src struct {
30446 *OxmId
30447}
30448
30449type IOxmIdTunnelIpv4Src interface {
30450 IOxmId
30451}
30452
30453func (self *OxmIdTunnelIpv4Src) Serialize(encoder *goloxi.Encoder) error {
30454 if err := self.OxmId.Serialize(encoder); err != nil {
30455 return err
30456 }
30457
30458 return nil
30459}
30460
30461func DecodeOxmIdTunnelIpv4Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelIpv4Src, error) {
30462 _oxmidtunnelipv4src := &OxmIdTunnelIpv4Src{OxmId: parent}
30463 return _oxmidtunnelipv4src, nil
30464}
30465
30466func NewOxmIdTunnelIpv4Src() *OxmIdTunnelIpv4Src {
30467 obj := &OxmIdTunnelIpv4Src{
30468 OxmId: NewOxmId(81412),
30469 }
30470 return obj
30471}
30472func (self *OxmIdTunnelIpv4Src) GetOXMName() string {
30473 return "tunnel_ipv4_src"
30474}
30475
30476func (self *OxmIdTunnelIpv4Src) MarshalJSON() ([]byte, error) {
30477 if self.TypeLen == 0 {
30478 return []byte("\"\""), nil
30479 } else {
30480 return []byte("\"" + self.GetOXMName() + "\""), nil
30481 }
30482}
30483
30484type OxmIdTunnelIpv4SrcMasked struct {
30485 *OxmId
30486}
30487
30488type IOxmIdTunnelIpv4SrcMasked interface {
30489 IOxmId
30490}
30491
30492func (self *OxmIdTunnelIpv4SrcMasked) Serialize(encoder *goloxi.Encoder) error {
30493 if err := self.OxmId.Serialize(encoder); err != nil {
30494 return err
30495 }
30496
30497 return nil
30498}
30499
30500func DecodeOxmIdTunnelIpv4SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelIpv4SrcMasked, error) {
30501 _oxmidtunnelipv4srcmasked := &OxmIdTunnelIpv4SrcMasked{OxmId: parent}
30502 return _oxmidtunnelipv4srcmasked, nil
30503}
30504
30505func NewOxmIdTunnelIpv4SrcMasked() *OxmIdTunnelIpv4SrcMasked {
30506 obj := &OxmIdTunnelIpv4SrcMasked{
30507 OxmId: NewOxmId(81672),
30508 }
30509 return obj
30510}
30511func (self *OxmIdTunnelIpv4SrcMasked) GetOXMName() string {
30512 return "tunnel_ipv4_src_masked"
30513}
30514
30515func (self *OxmIdTunnelIpv4SrcMasked) MarshalJSON() ([]byte, error) {
30516 if self.TypeLen == 0 {
30517 return []byte("\"\""), nil
30518 } else {
30519 return []byte("\"" + self.GetOXMName() + "\""), nil
30520 }
30521}
30522
30523type OxmIdVlanPcp struct {
30524 *OxmId
30525}
30526
30527type IOxmIdVlanPcp interface {
30528 IOxmId
30529}
30530
30531func (self *OxmIdVlanPcp) Serialize(encoder *goloxi.Encoder) error {
30532 if err := self.OxmId.Serialize(encoder); err != nil {
30533 return err
30534 }
30535
30536 return nil
30537}
30538
30539func DecodeOxmIdVlanPcp(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanPcp, error) {
30540 _oxmidvlanpcp := &OxmIdVlanPcp{OxmId: parent}
30541 return _oxmidvlanpcp, nil
30542}
30543
30544func NewOxmIdVlanPcp() *OxmIdVlanPcp {
30545 obj := &OxmIdVlanPcp{
30546 OxmId: NewOxmId(2147487233),
30547 }
30548 return obj
30549}
30550func (self *OxmIdVlanPcp) GetOXMName() string {
30551 return "vlan_pcp"
30552}
30553
30554func (self *OxmIdVlanPcp) MarshalJSON() ([]byte, error) {
30555 if self.TypeLen == 0 {
30556 return []byte("\"\""), nil
30557 } else {
30558 return []byte("\"" + self.GetOXMName() + "\""), nil
30559 }
30560}
30561
30562type OxmIdVlanPcpMasked struct {
30563 *OxmId
30564}
30565
30566type IOxmIdVlanPcpMasked interface {
30567 IOxmId
30568}
30569
30570func (self *OxmIdVlanPcpMasked) Serialize(encoder *goloxi.Encoder) error {
30571 if err := self.OxmId.Serialize(encoder); err != nil {
30572 return err
30573 }
30574
30575 return nil
30576}
30577
30578func DecodeOxmIdVlanPcpMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanPcpMasked, error) {
30579 _oxmidvlanpcpmasked := &OxmIdVlanPcpMasked{OxmId: parent}
30580 return _oxmidvlanpcpmasked, nil
30581}
30582
30583func NewOxmIdVlanPcpMasked() *OxmIdVlanPcpMasked {
30584 obj := &OxmIdVlanPcpMasked{
30585 OxmId: NewOxmId(2147487490),
30586 }
30587 return obj
30588}
30589func (self *OxmIdVlanPcpMasked) GetOXMName() string {
30590 return "vlan_pcp_masked"
30591}
30592
30593func (self *OxmIdVlanPcpMasked) MarshalJSON() ([]byte, error) {
30594 if self.TypeLen == 0 {
30595 return []byte("\"\""), nil
30596 } else {
30597 return []byte("\"" + self.GetOXMName() + "\""), nil
30598 }
30599}
30600
30601type OxmIdVlanVid struct {
30602 *OxmId
30603}
30604
30605type IOxmIdVlanVid interface {
30606 IOxmId
30607}
30608
30609func (self *OxmIdVlanVid) Serialize(encoder *goloxi.Encoder) error {
30610 if err := self.OxmId.Serialize(encoder); err != nil {
30611 return err
30612 }
30613
30614 return nil
30615}
30616
30617func DecodeOxmIdVlanVid(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanVid, error) {
30618 _oxmidvlanvid := &OxmIdVlanVid{OxmId: parent}
30619 return _oxmidvlanvid, nil
30620}
30621
30622func NewOxmIdVlanVid() *OxmIdVlanVid {
30623 obj := &OxmIdVlanVid{
30624 OxmId: NewOxmId(2147486722),
30625 }
30626 return obj
30627}
30628func (self *OxmIdVlanVid) GetOXMName() string {
30629 return "vlan_vid"
30630}
30631
30632func (self *OxmIdVlanVid) MarshalJSON() ([]byte, error) {
30633 if self.TypeLen == 0 {
30634 return []byte("\"\""), nil
30635 } else {
30636 return []byte("\"" + self.GetOXMName() + "\""), nil
30637 }
30638}
30639
30640type OxmIdVlanVidMasked struct {
30641 *OxmId
30642}
30643
30644type IOxmIdVlanVidMasked interface {
30645 IOxmId
30646}
30647
30648func (self *OxmIdVlanVidMasked) Serialize(encoder *goloxi.Encoder) error {
30649 if err := self.OxmId.Serialize(encoder); err != nil {
30650 return err
30651 }
30652
30653 return nil
30654}
30655
30656func DecodeOxmIdVlanVidMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanVidMasked, error) {
30657 _oxmidvlanvidmasked := &OxmIdVlanVidMasked{OxmId: parent}
30658 return _oxmidvlanvidmasked, nil
30659}
30660
30661func NewOxmIdVlanVidMasked() *OxmIdVlanVidMasked {
30662 obj := &OxmIdVlanVidMasked{
30663 OxmId: NewOxmId(2147486980),
30664 }
30665 return obj
30666}
30667func (self *OxmIdVlanVidMasked) GetOXMName() string {
30668 return "vlan_vid_masked"
30669}
30670
30671func (self *OxmIdVlanVidMasked) MarshalJSON() ([]byte, error) {
30672 if self.TypeLen == 0 {
30673 return []byte("\"\""), nil
30674 } else {
30675 return []byte("\"" + self.GetOXMName() + "\""), nil
30676 }
30677}
30678
30679type PacketQueue struct {
30680 QueueId uint32
30681 Port Port
30682 Len uint16
30683 Properties []IQueueProp
30684}
30685
30686type IPacketQueue interface {
30687 goloxi.Serializable
30688 GetQueueId() uint32
30689 GetPort() Port
30690 GetLen() uint16
30691 GetProperties() []IQueueProp
30692}
30693
30694func (self *PacketQueue) GetQueueId() uint32 {
30695 return self.QueueId
30696}
30697
30698func (self *PacketQueue) SetQueueId(v uint32) {
30699 self.QueueId = v
30700}
30701
30702func (self *PacketQueue) GetPort() Port {
30703 return self.Port
30704}
30705
30706func (self *PacketQueue) SetPort(v Port) {
30707 self.Port = v
30708}
30709
30710func (self *PacketQueue) GetLen() uint16 {
30711 return self.Len
30712}
30713
30714func (self *PacketQueue) SetLen(v uint16) {
30715 self.Len = v
30716}
30717
30718func (self *PacketQueue) GetProperties() []IQueueProp {
30719 return self.Properties
30720}
30721
30722func (self *PacketQueue) SetProperties(v []IQueueProp) {
30723 self.Properties = v
30724}
30725
30726func (self *PacketQueue) Serialize(encoder *goloxi.Encoder) error {
30727
30728 encoder.PutUint32(uint32(self.QueueId))
30729 self.Port.Serialize(encoder)
30730 encoder.PutUint16(uint16(self.Len))
30731 encoder.Write(bytes.Repeat([]byte{0}, 6))
30732 for _, obj := range self.Properties {
30733 if err := obj.Serialize(encoder); err != nil {
30734 return err
30735 }
30736 }
30737
30738 binary.BigEndian.PutUint16(encoder.Bytes()[8:10], uint16(len(encoder.Bytes())))
30739
30740 return nil
30741}
30742
30743func DecodePacketQueue(decoder *goloxi.Decoder) (*PacketQueue, error) {
30744 _packetqueue := &PacketQueue{}
30745 if decoder.Length() < 16 {
30746 return nil, fmt.Errorf("PacketQueue packet too short: %d < 16", decoder.Length())
30747 }
30748 _packetqueue.QueueId = uint32(decoder.ReadUint32())
30749 _packetqueue.Port.Decode(decoder)
30750 _packetqueue.Len = uint16(decoder.ReadUint16())
30751 oldDecoder := decoder
30752 defer func() { decoder = oldDecoder }()
30753 decoder = decoder.SliceDecoder(int(_packetqueue.Len), 2+8)
30754 decoder.Skip(6)
30755
30756 for decoder.Length() >= 8 {
30757 item, err := DecodeQueueProp(decoder)
30758 if err != nil {
30759 return nil, err
30760 }
30761 if item != nil {
30762 _packetqueue.Properties = append(_packetqueue.Properties, item)
30763 }
30764 }
30765 return _packetqueue, nil
30766}
30767
30768func NewPacketQueue() *PacketQueue {
30769 obj := &PacketQueue{}
30770 return obj
30771}
30772
30773type PortDesc struct {
30774 PortNo Port
30775 HwAddr net.HardwareAddr
30776 Name string
30777 Config PortConfig
30778 State PortState
30779 Curr PortFeatures
30780 Advertised PortFeatures
30781 Supported PortFeatures
30782 Peer PortFeatures
30783 CurrSpeed uint32
30784 MaxSpeed uint32
30785}
30786
30787type IPortDesc interface {
30788 goloxi.Serializable
30789 GetPortNo() Port
30790 GetHwAddr() net.HardwareAddr
30791 GetName() string
30792 GetConfig() PortConfig
30793 GetState() PortState
30794 GetCurr() PortFeatures
30795 GetAdvertised() PortFeatures
30796 GetSupported() PortFeatures
30797 GetPeer() PortFeatures
30798 GetCurrSpeed() uint32
30799 GetMaxSpeed() uint32
30800}
30801
30802func (self *PortDesc) GetPortNo() Port {
30803 return self.PortNo
30804}
30805
30806func (self *PortDesc) SetPortNo(v Port) {
30807 self.PortNo = v
30808}
30809
30810func (self *PortDesc) GetHwAddr() net.HardwareAddr {
30811 return self.HwAddr
30812}
30813
30814func (self *PortDesc) SetHwAddr(v net.HardwareAddr) {
30815 self.HwAddr = v
30816}
30817
30818func (self *PortDesc) GetName() string {
30819 return self.Name
30820}
30821
30822func (self *PortDesc) SetName(v string) {
30823 self.Name = v
30824}
30825
30826func (self *PortDesc) GetConfig() PortConfig {
30827 return self.Config
30828}
30829
30830func (self *PortDesc) SetConfig(v PortConfig) {
30831 self.Config = v
30832}
30833
30834func (self *PortDesc) GetState() PortState {
30835 return self.State
30836}
30837
30838func (self *PortDesc) SetState(v PortState) {
30839 self.State = v
30840}
30841
30842func (self *PortDesc) GetCurr() PortFeatures {
30843 return self.Curr
30844}
30845
30846func (self *PortDesc) SetCurr(v PortFeatures) {
30847 self.Curr = v
30848}
30849
30850func (self *PortDesc) GetAdvertised() PortFeatures {
30851 return self.Advertised
30852}
30853
30854func (self *PortDesc) SetAdvertised(v PortFeatures) {
30855 self.Advertised = v
30856}
30857
30858func (self *PortDesc) GetSupported() PortFeatures {
30859 return self.Supported
30860}
30861
30862func (self *PortDesc) SetSupported(v PortFeatures) {
30863 self.Supported = v
30864}
30865
30866func (self *PortDesc) GetPeer() PortFeatures {
30867 return self.Peer
30868}
30869
30870func (self *PortDesc) SetPeer(v PortFeatures) {
30871 self.Peer = v
30872}
30873
30874func (self *PortDesc) GetCurrSpeed() uint32 {
30875 return self.CurrSpeed
30876}
30877
30878func (self *PortDesc) SetCurrSpeed(v uint32) {
30879 self.CurrSpeed = v
30880}
30881
30882func (self *PortDesc) GetMaxSpeed() uint32 {
30883 return self.MaxSpeed
30884}
30885
30886func (self *PortDesc) SetMaxSpeed(v uint32) {
30887 self.MaxSpeed = v
30888}
30889
30890func (self *PortDesc) Serialize(encoder *goloxi.Encoder) error {
30891
30892 self.PortNo.Serialize(encoder)
30893 encoder.Write(bytes.Repeat([]byte{0}, 4))
30894 encoder.Write(self.HwAddr)
30895 encoder.Write(bytes.Repeat([]byte{0}, 2))
30896 encoder.Write([]byte(self.Name))
30897 encoder.PutUint32(uint32(self.Config))
30898 encoder.PutUint32(uint32(self.State))
30899 encoder.PutUint32(uint32(self.Curr))
30900 encoder.PutUint32(uint32(self.Advertised))
30901 encoder.PutUint32(uint32(self.Supported))
30902 encoder.PutUint32(uint32(self.Peer))
30903 encoder.PutUint32(uint32(self.CurrSpeed))
30904 encoder.PutUint32(uint32(self.MaxSpeed))
30905
30906 return nil
30907}
30908func (self *PortDesc) Decode(decoder *goloxi.Decoder) error {
30909 if decoder.Length() < 64 {
30910 return fmt.Errorf("PortDesc packet too short: %d < 64", decoder.Length())
30911 }
30912
30913 self.PortNo.Decode(decoder)
30914 decoder.Skip(4)
30915 self.HwAddr = net.HardwareAddr(decoder.Read(6))
30916 decoder.Skip(2)
30917 self.Name = string(bytes.Trim(decoder.Read(16), "\x00"))
30918 self.Config = PortConfig(decoder.ReadUint32())
30919 self.State = PortState(decoder.ReadUint32())
30920 self.Curr = PortFeatures(decoder.ReadUint32())
30921 self.Advertised = PortFeatures(decoder.ReadUint32())
30922 self.Supported = PortFeatures(decoder.ReadUint32())
30923 self.Peer = PortFeatures(decoder.ReadUint32())
30924 self.CurrSpeed = uint32(decoder.ReadUint32())
30925 self.MaxSpeed = uint32(decoder.ReadUint32())
30926
30927 return nil
30928}
30929
30930func NewPortDesc() *PortDesc {
30931 obj := &PortDesc{}
30932 return obj
30933}
30934
30935type PortStatsEntry struct {
30936 PortNo Port
30937 RxPackets uint64
30938 TxPackets uint64
30939 RxBytes uint64
30940 TxBytes uint64
30941 RxDropped uint64
30942 TxDropped uint64
30943 RxErrors uint64
30944 TxErrors uint64
30945 RxFrameErr uint64
30946 RxOverErr uint64
30947 RxCrcErr uint64
30948 Collisions uint64
30949 DurationSec uint32
30950 DurationNsec uint32
30951}
30952
30953type IPortStatsEntry interface {
30954 goloxi.Serializable
30955 GetPortNo() Port
30956 GetRxPackets() uint64
30957 GetTxPackets() uint64
30958 GetRxBytes() uint64
30959 GetTxBytes() uint64
30960 GetRxDropped() uint64
30961 GetTxDropped() uint64
30962 GetRxErrors() uint64
30963 GetTxErrors() uint64
30964 GetRxFrameErr() uint64
30965 GetRxOverErr() uint64
30966 GetRxCrcErr() uint64
30967 GetCollisions() uint64
30968 GetDurationSec() uint32
30969 GetDurationNsec() uint32
30970}
30971
30972func (self *PortStatsEntry) GetPortNo() Port {
30973 return self.PortNo
30974}
30975
30976func (self *PortStatsEntry) SetPortNo(v Port) {
30977 self.PortNo = v
30978}
30979
30980func (self *PortStatsEntry) GetRxPackets() uint64 {
30981 return self.RxPackets
30982}
30983
30984func (self *PortStatsEntry) SetRxPackets(v uint64) {
30985 self.RxPackets = v
30986}
30987
30988func (self *PortStatsEntry) GetTxPackets() uint64 {
30989 return self.TxPackets
30990}
30991
30992func (self *PortStatsEntry) SetTxPackets(v uint64) {
30993 self.TxPackets = v
30994}
30995
30996func (self *PortStatsEntry) GetRxBytes() uint64 {
30997 return self.RxBytes
30998}
30999
31000func (self *PortStatsEntry) SetRxBytes(v uint64) {
31001 self.RxBytes = v
31002}
31003
31004func (self *PortStatsEntry) GetTxBytes() uint64 {
31005 return self.TxBytes
31006}
31007
31008func (self *PortStatsEntry) SetTxBytes(v uint64) {
31009 self.TxBytes = v
31010}
31011
31012func (self *PortStatsEntry) GetRxDropped() uint64 {
31013 return self.RxDropped
31014}
31015
31016func (self *PortStatsEntry) SetRxDropped(v uint64) {
31017 self.RxDropped = v
31018}
31019
31020func (self *PortStatsEntry) GetTxDropped() uint64 {
31021 return self.TxDropped
31022}
31023
31024func (self *PortStatsEntry) SetTxDropped(v uint64) {
31025 self.TxDropped = v
31026}
31027
31028func (self *PortStatsEntry) GetRxErrors() uint64 {
31029 return self.RxErrors
31030}
31031
31032func (self *PortStatsEntry) SetRxErrors(v uint64) {
31033 self.RxErrors = v
31034}
31035
31036func (self *PortStatsEntry) GetTxErrors() uint64 {
31037 return self.TxErrors
31038}
31039
31040func (self *PortStatsEntry) SetTxErrors(v uint64) {
31041 self.TxErrors = v
31042}
31043
31044func (self *PortStatsEntry) GetRxFrameErr() uint64 {
31045 return self.RxFrameErr
31046}
31047
31048func (self *PortStatsEntry) SetRxFrameErr(v uint64) {
31049 self.RxFrameErr = v
31050}
31051
31052func (self *PortStatsEntry) GetRxOverErr() uint64 {
31053 return self.RxOverErr
31054}
31055
31056func (self *PortStatsEntry) SetRxOverErr(v uint64) {
31057 self.RxOverErr = v
31058}
31059
31060func (self *PortStatsEntry) GetRxCrcErr() uint64 {
31061 return self.RxCrcErr
31062}
31063
31064func (self *PortStatsEntry) SetRxCrcErr(v uint64) {
31065 self.RxCrcErr = v
31066}
31067
31068func (self *PortStatsEntry) GetCollisions() uint64 {
31069 return self.Collisions
31070}
31071
31072func (self *PortStatsEntry) SetCollisions(v uint64) {
31073 self.Collisions = v
31074}
31075
31076func (self *PortStatsEntry) GetDurationSec() uint32 {
31077 return self.DurationSec
31078}
31079
31080func (self *PortStatsEntry) SetDurationSec(v uint32) {
31081 self.DurationSec = v
31082}
31083
31084func (self *PortStatsEntry) GetDurationNsec() uint32 {
31085 return self.DurationNsec
31086}
31087
31088func (self *PortStatsEntry) SetDurationNsec(v uint32) {
31089 self.DurationNsec = v
31090}
31091
31092func (self *PortStatsEntry) Serialize(encoder *goloxi.Encoder) error {
31093
31094 self.PortNo.Serialize(encoder)
31095 encoder.Write(bytes.Repeat([]byte{0}, 4))
31096 encoder.PutUint64(uint64(self.RxPackets))
31097 encoder.PutUint64(uint64(self.TxPackets))
31098 encoder.PutUint64(uint64(self.RxBytes))
31099 encoder.PutUint64(uint64(self.TxBytes))
31100 encoder.PutUint64(uint64(self.RxDropped))
31101 encoder.PutUint64(uint64(self.TxDropped))
31102 encoder.PutUint64(uint64(self.RxErrors))
31103 encoder.PutUint64(uint64(self.TxErrors))
31104 encoder.PutUint64(uint64(self.RxFrameErr))
31105 encoder.PutUint64(uint64(self.RxOverErr))
31106 encoder.PutUint64(uint64(self.RxCrcErr))
31107 encoder.PutUint64(uint64(self.Collisions))
31108 encoder.PutUint32(uint32(self.DurationSec))
31109 encoder.PutUint32(uint32(self.DurationNsec))
31110
31111 return nil
31112}
31113
31114func DecodePortStatsEntry(decoder *goloxi.Decoder) (*PortStatsEntry, error) {
31115 _portstatsentry := &PortStatsEntry{}
31116 if decoder.Length() < 112 {
31117 return nil, fmt.Errorf("PortStatsEntry packet too short: %d < 112", decoder.Length())
31118 }
31119 _portstatsentry.PortNo.Decode(decoder)
31120 decoder.Skip(4)
31121 _portstatsentry.RxPackets = uint64(decoder.ReadUint64())
31122 _portstatsentry.TxPackets = uint64(decoder.ReadUint64())
31123 _portstatsentry.RxBytes = uint64(decoder.ReadUint64())
31124 _portstatsentry.TxBytes = uint64(decoder.ReadUint64())
31125 _portstatsentry.RxDropped = uint64(decoder.ReadUint64())
31126 _portstatsentry.TxDropped = uint64(decoder.ReadUint64())
31127 _portstatsentry.RxErrors = uint64(decoder.ReadUint64())
31128 _portstatsentry.TxErrors = uint64(decoder.ReadUint64())
31129 _portstatsentry.RxFrameErr = uint64(decoder.ReadUint64())
31130 _portstatsentry.RxOverErr = uint64(decoder.ReadUint64())
31131 _portstatsentry.RxCrcErr = uint64(decoder.ReadUint64())
31132 _portstatsentry.Collisions = uint64(decoder.ReadUint64())
31133 _portstatsentry.DurationSec = uint32(decoder.ReadUint32())
31134 _portstatsentry.DurationNsec = uint32(decoder.ReadUint32())
31135 return _portstatsentry, nil
31136}
31137
31138func NewPortStatsEntry() *PortStatsEntry {
31139 obj := &PortStatsEntry{}
31140 return obj
31141}
31142
31143type QueueProp struct {
31144 Type uint16
31145 Len uint16
31146}
31147
31148type IQueueProp interface {
31149 goloxi.Serializable
31150 GetType() uint16
31151 GetLen() uint16
31152}
31153
31154func (self *QueueProp) GetType() uint16 {
31155 return self.Type
31156}
31157
31158func (self *QueueProp) SetType(v uint16) {
31159 self.Type = v
31160}
31161
31162func (self *QueueProp) GetLen() uint16 {
31163 return self.Len
31164}
31165
31166func (self *QueueProp) SetLen(v uint16) {
31167 self.Len = v
31168}
31169
31170func (self *QueueProp) Serialize(encoder *goloxi.Encoder) error {
31171
31172 encoder.PutUint16(uint16(self.Type))
31173 encoder.PutUint16(uint16(self.Len))
31174
31175 return nil
31176}
31177
31178func DecodeQueueProp(decoder *goloxi.Decoder) (IQueueProp, error) {
31179 _queueprop := &QueueProp{}
31180 if decoder.Length() < 4 {
31181 return nil, fmt.Errorf("QueueProp packet too short: %d < 4", decoder.Length())
31182 }
31183 _queueprop.Type = uint16(decoder.ReadUint16())
31184 _queueprop.Len = uint16(decoder.ReadUint16())
31185 oldDecoder := decoder
31186 defer func() { decoder = oldDecoder }()
31187 decoder = decoder.SliceDecoder(int(_queueprop.Len), 2+2)
31188
31189 switch _queueprop.Type {
31190 case 1:
31191 return DecodeQueuePropMinRate(_queueprop, decoder)
31192 case 2:
31193 return DecodeQueuePropMaxRate(_queueprop, decoder)
31194 case 65535:
31195 return DecodeQueuePropExperimenter(_queueprop, decoder)
31196 default:
31197 return nil, fmt.Errorf("Invalid type '%d' for 'QueueProp'", _queueprop.Type)
31198 }
31199}
31200
31201func NewQueueProp(_type uint16) *QueueProp {
31202 obj := &QueueProp{}
31203 obj.Type = _type
31204 return obj
31205}
31206
31207type QueuePropExperimenter struct {
31208 *QueueProp
31209 Experimenter uint32
31210}
31211
31212type IQueuePropExperimenter interface {
31213 IQueueProp
31214 GetExperimenter() uint32
31215}
31216
31217func (self *QueuePropExperimenter) GetExperimenter() uint32 {
31218 return self.Experimenter
31219}
31220
31221func (self *QueuePropExperimenter) SetExperimenter(v uint32) {
31222 self.Experimenter = v
31223}
31224
31225func (self *QueuePropExperimenter) Serialize(encoder *goloxi.Encoder) error {
31226 if err := self.QueueProp.Serialize(encoder); err != nil {
31227 return err
31228 }
31229
31230 encoder.Write(bytes.Repeat([]byte{0}, 4))
31231 encoder.PutUint32(uint32(self.Experimenter))
31232 encoder.Write(bytes.Repeat([]byte{0}, 4))
31233
31234 return nil
31235}
31236
31237func DecodeQueuePropExperimenter(parent *QueueProp, decoder *goloxi.Decoder) (IQueuePropExperimenter, error) {
31238 _queuepropexperimenter := &QueuePropExperimenter{QueueProp: parent}
31239 if decoder.Length() < 4 {
31240 return nil, fmt.Errorf("QueuePropExperimenter packet too short: %d < 4", decoder.Length())
31241 }
31242 decoder.Skip(4)
31243 _queuepropexperimenter.Experimenter = uint32(decoder.ReadUint32())
31244 decoder.Skip(4)
31245 return _queuepropexperimenter, nil
31246}
31247
31248func NewQueuePropExperimenter(_experimenter uint32) *QueuePropExperimenter {
31249 obj := &QueuePropExperimenter{
31250 QueueProp: NewQueueProp(65535),
31251 }
31252 obj.Experimenter = _experimenter
31253 return obj
31254}
31255
31256type QueuePropMaxRate struct {
31257 *QueueProp
31258 Rate uint16
31259}
31260
31261type IQueuePropMaxRate interface {
31262 IQueueProp
31263 GetRate() uint16
31264}
31265
31266func (self *QueuePropMaxRate) GetRate() uint16 {
31267 return self.Rate
31268}
31269
31270func (self *QueuePropMaxRate) SetRate(v uint16) {
31271 self.Rate = v
31272}
31273
31274func (self *QueuePropMaxRate) Serialize(encoder *goloxi.Encoder) error {
31275 if err := self.QueueProp.Serialize(encoder); err != nil {
31276 return err
31277 }
31278
31279 encoder.Write(bytes.Repeat([]byte{0}, 4))
31280 encoder.PutUint16(uint16(self.Rate))
31281 encoder.Write(bytes.Repeat([]byte{0}, 6))
31282
31283 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
31284
31285 return nil
31286}
31287
31288func DecodeQueuePropMaxRate(parent *QueueProp, decoder *goloxi.Decoder) (*QueuePropMaxRate, error) {
31289 _queuepropmaxrate := &QueuePropMaxRate{QueueProp: parent}
31290 if decoder.Length() < 12 {
31291 return nil, fmt.Errorf("QueuePropMaxRate packet too short: %d < 12", decoder.Length())
31292 }
31293 decoder.Skip(4)
31294 _queuepropmaxrate.Rate = uint16(decoder.ReadUint16())
31295 decoder.Skip(6)
31296 return _queuepropmaxrate, nil
31297}
31298
31299func NewQueuePropMaxRate() *QueuePropMaxRate {
31300 obj := &QueuePropMaxRate{
31301 QueueProp: NewQueueProp(2),
31302 }
31303 return obj
31304}
31305
31306type QueuePropMinRate struct {
31307 *QueueProp
31308 Rate uint16
31309}
31310
31311type IQueuePropMinRate interface {
31312 IQueueProp
31313 GetRate() uint16
31314}
31315
31316func (self *QueuePropMinRate) GetRate() uint16 {
31317 return self.Rate
31318}
31319
31320func (self *QueuePropMinRate) SetRate(v uint16) {
31321 self.Rate = v
31322}
31323
31324func (self *QueuePropMinRate) Serialize(encoder *goloxi.Encoder) error {
31325 if err := self.QueueProp.Serialize(encoder); err != nil {
31326 return err
31327 }
31328
31329 encoder.Write(bytes.Repeat([]byte{0}, 4))
31330 encoder.PutUint16(uint16(self.Rate))
31331 encoder.Write(bytes.Repeat([]byte{0}, 6))
31332
31333 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
31334
31335 return nil
31336}
31337
31338func DecodeQueuePropMinRate(parent *QueueProp, decoder *goloxi.Decoder) (*QueuePropMinRate, error) {
31339 _queuepropminrate := &QueuePropMinRate{QueueProp: parent}
31340 if decoder.Length() < 12 {
31341 return nil, fmt.Errorf("QueuePropMinRate packet too short: %d < 12", decoder.Length())
31342 }
31343 decoder.Skip(4)
31344 _queuepropminrate.Rate = uint16(decoder.ReadUint16())
31345 decoder.Skip(6)
31346 return _queuepropminrate, nil
31347}
31348
31349func NewQueuePropMinRate() *QueuePropMinRate {
31350 obj := &QueuePropMinRate{
31351 QueueProp: NewQueueProp(1),
31352 }
31353 return obj
31354}
31355
31356type QueueStatsEntry struct {
31357 PortNo Port
31358 QueueId uint32
31359 TxBytes uint64
31360 TxPackets uint64
31361 TxErrors uint64
31362 DurationSec uint32
31363 DurationNsec uint32
31364}
31365
31366type IQueueStatsEntry interface {
31367 goloxi.Serializable
31368 GetPortNo() Port
31369 GetQueueId() uint32
31370 GetTxBytes() uint64
31371 GetTxPackets() uint64
31372 GetTxErrors() uint64
31373 GetDurationSec() uint32
31374 GetDurationNsec() uint32
31375}
31376
31377func (self *QueueStatsEntry) GetPortNo() Port {
31378 return self.PortNo
31379}
31380
31381func (self *QueueStatsEntry) SetPortNo(v Port) {
31382 self.PortNo = v
31383}
31384
31385func (self *QueueStatsEntry) GetQueueId() uint32 {
31386 return self.QueueId
31387}
31388
31389func (self *QueueStatsEntry) SetQueueId(v uint32) {
31390 self.QueueId = v
31391}
31392
31393func (self *QueueStatsEntry) GetTxBytes() uint64 {
31394 return self.TxBytes
31395}
31396
31397func (self *QueueStatsEntry) SetTxBytes(v uint64) {
31398 self.TxBytes = v
31399}
31400
31401func (self *QueueStatsEntry) GetTxPackets() uint64 {
31402 return self.TxPackets
31403}
31404
31405func (self *QueueStatsEntry) SetTxPackets(v uint64) {
31406 self.TxPackets = v
31407}
31408
31409func (self *QueueStatsEntry) GetTxErrors() uint64 {
31410 return self.TxErrors
31411}
31412
31413func (self *QueueStatsEntry) SetTxErrors(v uint64) {
31414 self.TxErrors = v
31415}
31416
31417func (self *QueueStatsEntry) GetDurationSec() uint32 {
31418 return self.DurationSec
31419}
31420
31421func (self *QueueStatsEntry) SetDurationSec(v uint32) {
31422 self.DurationSec = v
31423}
31424
31425func (self *QueueStatsEntry) GetDurationNsec() uint32 {
31426 return self.DurationNsec
31427}
31428
31429func (self *QueueStatsEntry) SetDurationNsec(v uint32) {
31430 self.DurationNsec = v
31431}
31432
31433func (self *QueueStatsEntry) Serialize(encoder *goloxi.Encoder) error {
31434
31435 self.PortNo.Serialize(encoder)
31436 encoder.PutUint32(uint32(self.QueueId))
31437 encoder.PutUint64(uint64(self.TxBytes))
31438 encoder.PutUint64(uint64(self.TxPackets))
31439 encoder.PutUint64(uint64(self.TxErrors))
31440 encoder.PutUint32(uint32(self.DurationSec))
31441 encoder.PutUint32(uint32(self.DurationNsec))
31442
31443 return nil
31444}
31445
31446func DecodeQueueStatsEntry(decoder *goloxi.Decoder) (*QueueStatsEntry, error) {
31447 _queuestatsentry := &QueueStatsEntry{}
31448 if decoder.Length() < 40 {
31449 return nil, fmt.Errorf("QueueStatsEntry packet too short: %d < 40", decoder.Length())
31450 }
31451 _queuestatsentry.PortNo.Decode(decoder)
31452 _queuestatsentry.QueueId = uint32(decoder.ReadUint32())
31453 _queuestatsentry.TxBytes = uint64(decoder.ReadUint64())
31454 _queuestatsentry.TxPackets = uint64(decoder.ReadUint64())
31455 _queuestatsentry.TxErrors = uint64(decoder.ReadUint64())
31456 _queuestatsentry.DurationSec = uint32(decoder.ReadUint32())
31457 _queuestatsentry.DurationNsec = uint32(decoder.ReadUint32())
31458 return _queuestatsentry, nil
31459}
31460
31461func NewQueueStatsEntry() *QueueStatsEntry {
31462 obj := &QueueStatsEntry{}
31463 return obj
31464}
31465
31466type TableFeatureProp struct {
31467 Type uint16
31468 Length uint16
31469}
31470
31471type ITableFeatureProp interface {
31472 goloxi.Serializable
31473 GetType() uint16
31474 GetLength() uint16
31475}
31476
31477func (self *TableFeatureProp) GetType() uint16 {
31478 return self.Type
31479}
31480
31481func (self *TableFeatureProp) SetType(v uint16) {
31482 self.Type = v
31483}
31484
31485func (self *TableFeatureProp) GetLength() uint16 {
31486 return self.Length
31487}
31488
31489func (self *TableFeatureProp) SetLength(v uint16) {
31490 self.Length = v
31491}
31492
31493func (self *TableFeatureProp) Serialize(encoder *goloxi.Encoder) error {
31494
31495 encoder.PutUint16(uint16(self.Type))
31496 encoder.PutUint16(uint16(self.Length))
31497
31498 return nil
31499}
31500
31501func DecodeTableFeatureProp(decoder *goloxi.Decoder) (ITableFeatureProp, error) {
31502 _tablefeatureprop := &TableFeatureProp{}
31503 if decoder.Length() < 4 {
31504 return nil, fmt.Errorf("TableFeatureProp packet too short: %d < 4", decoder.Length())
31505 }
31506 _tablefeatureprop.Type = uint16(decoder.ReadUint16())
31507 _tablefeatureprop.Length = uint16(decoder.ReadUint16())
31508 oldDecoder := decoder
31509 defer func() { decoder = oldDecoder }()
31510 decoder = decoder.SliceDecoder(int(_tablefeatureprop.Length), 2+2)
31511
31512 switch _tablefeatureprop.Type {
31513 case 0:
31514 return DecodeTableFeaturePropInstructions(_tablefeatureprop, decoder)
31515 case 1:
31516 return DecodeTableFeaturePropInstructionsMiss(_tablefeatureprop, decoder)
31517 case 2:
31518 return DecodeTableFeaturePropNextTables(_tablefeatureprop, decoder)
31519 case 3:
31520 return DecodeTableFeaturePropNextTablesMiss(_tablefeatureprop, decoder)
31521 case 4:
31522 return DecodeTableFeaturePropWriteActions(_tablefeatureprop, decoder)
31523 case 5:
31524 return DecodeTableFeaturePropWriteActionsMiss(_tablefeatureprop, decoder)
31525 case 6:
31526 return DecodeTableFeaturePropApplyActions(_tablefeatureprop, decoder)
31527 case 7:
31528 return DecodeTableFeaturePropApplyActionsMiss(_tablefeatureprop, decoder)
31529 case 8:
31530 return DecodeTableFeaturePropMatch(_tablefeatureprop, decoder)
31531 case 10:
31532 return DecodeTableFeaturePropWildcards(_tablefeatureprop, decoder)
31533 case 12:
31534 return DecodeTableFeaturePropWriteSetfield(_tablefeatureprop, decoder)
31535 case 13:
31536 return DecodeTableFeaturePropWriteSetfieldMiss(_tablefeatureprop, decoder)
31537 case 14:
31538 return DecodeTableFeaturePropApplySetfield(_tablefeatureprop, decoder)
31539 case 15:
31540 return DecodeTableFeaturePropApplySetfieldMiss(_tablefeatureprop, decoder)
31541 case 65534:
31542 return DecodeTableFeaturePropExperimenter(_tablefeatureprop, decoder)
31543 case 65535:
31544 return DecodeTableFeaturePropExperimenterMiss(_tablefeatureprop, decoder)
31545 default:
31546 return nil, fmt.Errorf("Invalid type '%d' for 'TableFeatureProp'", _tablefeatureprop.Type)
31547 }
31548}
31549
31550func NewTableFeatureProp(_type uint16) *TableFeatureProp {
31551 obj := &TableFeatureProp{}
31552 obj.Type = _type
31553 return obj
31554}
31555
31556type TableFeaturePropApplyActions struct {
31557 *TableFeatureProp
31558 ActionIds []IActionId
31559}
31560
31561type ITableFeaturePropApplyActions interface {
31562 ITableFeatureProp
31563 GetActionIds() []IActionId
31564}
31565
31566func (self *TableFeaturePropApplyActions) GetActionIds() []IActionId {
31567 return self.ActionIds
31568}
31569
31570func (self *TableFeaturePropApplyActions) SetActionIds(v []IActionId) {
31571 self.ActionIds = v
31572}
31573
31574func (self *TableFeaturePropApplyActions) Serialize(encoder *goloxi.Encoder) error {
31575 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
31576 return err
31577 }
31578
31579 for _, obj := range self.ActionIds {
31580 if err := obj.Serialize(encoder); err != nil {
31581 return err
31582 }
31583 }
31584
31585 encoder.SkipAlign()
31586
31587 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
31588
31589 return nil
31590}
31591
31592func DecodeTableFeaturePropApplyActions(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropApplyActions, error) {
31593 _tablefeaturepropapplyactions := &TableFeaturePropApplyActions{TableFeatureProp: parent}
31594 defer decoder.SkipAlign()
31595
31596 for decoder.Length() >= 4 {
31597 item, err := DecodeActionId(decoder)
31598 if err != nil {
31599 return nil, err
31600 }
31601 if item != nil {
31602 _tablefeaturepropapplyactions.ActionIds = append(_tablefeaturepropapplyactions.ActionIds, item)
31603 }
31604 }
31605 return _tablefeaturepropapplyactions, nil
31606}
31607
31608func NewTableFeaturePropApplyActions() *TableFeaturePropApplyActions {
31609 obj := &TableFeaturePropApplyActions{
31610 TableFeatureProp: NewTableFeatureProp(6),
31611 }
31612 return obj
31613}
31614
31615type TableFeaturePropApplyActionsMiss struct {
31616 *TableFeatureProp
31617 ActionIds []IActionId
31618}
31619
31620type ITableFeaturePropApplyActionsMiss interface {
31621 ITableFeatureProp
31622 GetActionIds() []IActionId
31623}
31624
31625func (self *TableFeaturePropApplyActionsMiss) GetActionIds() []IActionId {
31626 return self.ActionIds
31627}
31628
31629func (self *TableFeaturePropApplyActionsMiss) SetActionIds(v []IActionId) {
31630 self.ActionIds = v
31631}
31632
31633func (self *TableFeaturePropApplyActionsMiss) Serialize(encoder *goloxi.Encoder) error {
31634 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
31635 return err
31636 }
31637
31638 for _, obj := range self.ActionIds {
31639 if err := obj.Serialize(encoder); err != nil {
31640 return err
31641 }
31642 }
31643
31644 encoder.SkipAlign()
31645
31646 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
31647
31648 return nil
31649}
31650
31651func DecodeTableFeaturePropApplyActionsMiss(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropApplyActionsMiss, error) {
31652 _tablefeaturepropapplyactionsmiss := &TableFeaturePropApplyActionsMiss{TableFeatureProp: parent}
31653 defer decoder.SkipAlign()
31654
31655 for decoder.Length() >= 4 {
31656 item, err := DecodeActionId(decoder)
31657 if err != nil {
31658 return nil, err
31659 }
31660 if item != nil {
31661 _tablefeaturepropapplyactionsmiss.ActionIds = append(_tablefeaturepropapplyactionsmiss.ActionIds, item)
31662 }
31663 }
31664 return _tablefeaturepropapplyactionsmiss, nil
31665}
31666
31667func NewTableFeaturePropApplyActionsMiss() *TableFeaturePropApplyActionsMiss {
31668 obj := &TableFeaturePropApplyActionsMiss{
31669 TableFeatureProp: NewTableFeatureProp(7),
31670 }
31671 return obj
31672}
31673
31674type TableFeaturePropApplySetfield struct {
31675 *TableFeatureProp
31676 OxmIds []*Uint32
31677}
31678
31679type ITableFeaturePropApplySetfield interface {
31680 ITableFeatureProp
31681 GetOxmIds() []*Uint32
31682}
31683
31684func (self *TableFeaturePropApplySetfield) GetOxmIds() []*Uint32 {
31685 return self.OxmIds
31686}
31687
31688func (self *TableFeaturePropApplySetfield) SetOxmIds(v []*Uint32) {
31689 self.OxmIds = v
31690}
31691
31692func (self *TableFeaturePropApplySetfield) Serialize(encoder *goloxi.Encoder) error {
31693 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
31694 return err
31695 }
31696
31697 for _, obj := range self.OxmIds {
31698 if err := obj.Serialize(encoder); err != nil {
31699 return err
31700 }
31701 }
31702
31703 encoder.SkipAlign()
31704
31705 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
31706
31707 return nil
31708}
31709
31710func DecodeTableFeaturePropApplySetfield(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropApplySetfield, error) {
31711 _tablefeaturepropapplysetfield := &TableFeaturePropApplySetfield{TableFeatureProp: parent}
31712 defer decoder.SkipAlign()
31713
31714 for decoder.Length() >= 4 {
31715 item, err := DecodeUint32(decoder)
31716 if err != nil {
31717 return nil, err
31718 }
31719 if item != nil {
31720 _tablefeaturepropapplysetfield.OxmIds = append(_tablefeaturepropapplysetfield.OxmIds, item)
31721 }
31722 }
31723 return _tablefeaturepropapplysetfield, nil
31724}
31725
31726func NewTableFeaturePropApplySetfield() *TableFeaturePropApplySetfield {
31727 obj := &TableFeaturePropApplySetfield{
31728 TableFeatureProp: NewTableFeatureProp(14),
31729 }
31730 return obj
31731}
31732
31733type TableFeaturePropApplySetfieldMiss struct {
31734 *TableFeatureProp
31735 OxmIds []*Uint32
31736}
31737
31738type ITableFeaturePropApplySetfieldMiss interface {
31739 ITableFeatureProp
31740 GetOxmIds() []*Uint32
31741}
31742
31743func (self *TableFeaturePropApplySetfieldMiss) GetOxmIds() []*Uint32 {
31744 return self.OxmIds
31745}
31746
31747func (self *TableFeaturePropApplySetfieldMiss) SetOxmIds(v []*Uint32) {
31748 self.OxmIds = v
31749}
31750
31751func (self *TableFeaturePropApplySetfieldMiss) Serialize(encoder *goloxi.Encoder) error {
31752 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
31753 return err
31754 }
31755
31756 for _, obj := range self.OxmIds {
31757 if err := obj.Serialize(encoder); err != nil {
31758 return err
31759 }
31760 }
31761
31762 encoder.SkipAlign()
31763
31764 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
31765
31766 return nil
31767}
31768
31769func DecodeTableFeaturePropApplySetfieldMiss(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropApplySetfieldMiss, error) {
31770 _tablefeaturepropapplysetfieldmiss := &TableFeaturePropApplySetfieldMiss{TableFeatureProp: parent}
31771 defer decoder.SkipAlign()
31772
31773 for decoder.Length() >= 4 {
31774 item, err := DecodeUint32(decoder)
31775 if err != nil {
31776 return nil, err
31777 }
31778 if item != nil {
31779 _tablefeaturepropapplysetfieldmiss.OxmIds = append(_tablefeaturepropapplysetfieldmiss.OxmIds, item)
31780 }
31781 }
31782 return _tablefeaturepropapplysetfieldmiss, nil
31783}
31784
31785func NewTableFeaturePropApplySetfieldMiss() *TableFeaturePropApplySetfieldMiss {
31786 obj := &TableFeaturePropApplySetfieldMiss{
31787 TableFeatureProp: NewTableFeatureProp(15),
31788 }
31789 return obj
31790}
31791
31792type TableFeaturePropExperimenter struct {
31793 *TableFeatureProp
31794 Experimenter uint32
31795 Subtype uint32
31796}
31797
31798type ITableFeaturePropExperimenter interface {
31799 ITableFeatureProp
31800 GetExperimenter() uint32
31801 GetSubtype() uint32
31802}
31803
31804func (self *TableFeaturePropExperimenter) GetExperimenter() uint32 {
31805 return self.Experimenter
31806}
31807
31808func (self *TableFeaturePropExperimenter) SetExperimenter(v uint32) {
31809 self.Experimenter = v
31810}
31811
31812func (self *TableFeaturePropExperimenter) GetSubtype() uint32 {
31813 return self.Subtype
31814}
31815
31816func (self *TableFeaturePropExperimenter) SetSubtype(v uint32) {
31817 self.Subtype = v
31818}
31819
31820func (self *TableFeaturePropExperimenter) Serialize(encoder *goloxi.Encoder) error {
31821 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
31822 return err
31823 }
31824
31825 encoder.PutUint32(uint32(self.Experimenter))
31826 encoder.PutUint32(uint32(self.Subtype))
31827
31828 encoder.SkipAlign()
31829
31830 return nil
31831}
31832
31833func DecodeTableFeaturePropExperimenter(parent *TableFeatureProp, decoder *goloxi.Decoder) (ITableFeaturePropExperimenter, error) {
31834 _tablefeaturepropexperimenter := &TableFeaturePropExperimenter{TableFeatureProp: parent}
31835 if decoder.Length() < 8 {
31836 return nil, fmt.Errorf("TableFeaturePropExperimenter packet too short: %d < 8", decoder.Length())
31837 }
31838 defer decoder.SkipAlign()
31839
31840 _tablefeaturepropexperimenter.Experimenter = uint32(decoder.ReadUint32())
31841 _tablefeaturepropexperimenter.Subtype = uint32(decoder.ReadUint32())
31842 return _tablefeaturepropexperimenter, nil
31843}
31844
31845func NewTableFeaturePropExperimenter(_experimenter uint32) *TableFeaturePropExperimenter {
31846 obj := &TableFeaturePropExperimenter{
31847 TableFeatureProp: NewTableFeatureProp(65534),
31848 }
31849 obj.Experimenter = _experimenter
31850 return obj
31851}
31852
31853type TableFeaturePropExperimenterMiss struct {
31854 *TableFeatureProp
31855 Experimenter uint32
31856 Subtype uint32
31857}
31858
31859type ITableFeaturePropExperimenterMiss interface {
31860 ITableFeatureProp
31861 GetExperimenter() uint32
31862 GetSubtype() uint32
31863}
31864
31865func (self *TableFeaturePropExperimenterMiss) GetExperimenter() uint32 {
31866 return self.Experimenter
31867}
31868
31869func (self *TableFeaturePropExperimenterMiss) SetExperimenter(v uint32) {
31870 self.Experimenter = v
31871}
31872
31873func (self *TableFeaturePropExperimenterMiss) GetSubtype() uint32 {
31874 return self.Subtype
31875}
31876
31877func (self *TableFeaturePropExperimenterMiss) SetSubtype(v uint32) {
31878 self.Subtype = v
31879}
31880
31881func (self *TableFeaturePropExperimenterMiss) Serialize(encoder *goloxi.Encoder) error {
31882 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
31883 return err
31884 }
31885
31886 encoder.PutUint32(uint32(self.Experimenter))
31887 encoder.PutUint32(uint32(self.Subtype))
31888
31889 encoder.SkipAlign()
31890
31891 return nil
31892}
31893
31894func DecodeTableFeaturePropExperimenterMiss(parent *TableFeatureProp, decoder *goloxi.Decoder) (ITableFeaturePropExperimenterMiss, error) {
31895 _tablefeaturepropexperimentermiss := &TableFeaturePropExperimenterMiss{TableFeatureProp: parent}
31896 if decoder.Length() < 8 {
31897 return nil, fmt.Errorf("TableFeaturePropExperimenterMiss packet too short: %d < 8", decoder.Length())
31898 }
31899 defer decoder.SkipAlign()
31900
31901 _tablefeaturepropexperimentermiss.Experimenter = uint32(decoder.ReadUint32())
31902 _tablefeaturepropexperimentermiss.Subtype = uint32(decoder.ReadUint32())
31903 return _tablefeaturepropexperimentermiss, nil
31904}
31905
31906func NewTableFeaturePropExperimenterMiss(_experimenter uint32) *TableFeaturePropExperimenterMiss {
31907 obj := &TableFeaturePropExperimenterMiss{
31908 TableFeatureProp: NewTableFeatureProp(65535),
31909 }
31910 obj.Experimenter = _experimenter
31911 return obj
31912}
31913
31914type TableFeaturePropInstructions struct {
31915 *TableFeatureProp
31916 InstructionIds []IInstructionId
31917}
31918
31919type ITableFeaturePropInstructions interface {
31920 ITableFeatureProp
31921 GetInstructionIds() []IInstructionId
31922}
31923
31924func (self *TableFeaturePropInstructions) GetInstructionIds() []IInstructionId {
31925 return self.InstructionIds
31926}
31927
31928func (self *TableFeaturePropInstructions) SetInstructionIds(v []IInstructionId) {
31929 self.InstructionIds = v
31930}
31931
31932func (self *TableFeaturePropInstructions) Serialize(encoder *goloxi.Encoder) error {
31933 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
31934 return err
31935 }
31936
31937 for _, obj := range self.InstructionIds {
31938 if err := obj.Serialize(encoder); err != nil {
31939 return err
31940 }
31941 }
31942
31943 encoder.SkipAlign()
31944
31945 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
31946
31947 return nil
31948}
31949
31950func DecodeTableFeaturePropInstructions(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropInstructions, error) {
31951 _tablefeaturepropinstructions := &TableFeaturePropInstructions{TableFeatureProp: parent}
31952 defer decoder.SkipAlign()
31953
31954 for decoder.Length() >= 4 {
31955 item, err := DecodeInstructionId(decoder)
31956 if err != nil {
31957 return nil, err
31958 }
31959 if item != nil {
31960 _tablefeaturepropinstructions.InstructionIds = append(_tablefeaturepropinstructions.InstructionIds, item)
31961 }
31962 }
31963 return _tablefeaturepropinstructions, nil
31964}
31965
31966func NewTableFeaturePropInstructions() *TableFeaturePropInstructions {
31967 obj := &TableFeaturePropInstructions{
31968 TableFeatureProp: NewTableFeatureProp(0),
31969 }
31970 return obj
31971}
31972
31973type TableFeaturePropInstructionsMiss struct {
31974 *TableFeatureProp
31975 InstructionIds []IInstructionId
31976}
31977
31978type ITableFeaturePropInstructionsMiss interface {
31979 ITableFeatureProp
31980 GetInstructionIds() []IInstructionId
31981}
31982
31983func (self *TableFeaturePropInstructionsMiss) GetInstructionIds() []IInstructionId {
31984 return self.InstructionIds
31985}
31986
31987func (self *TableFeaturePropInstructionsMiss) SetInstructionIds(v []IInstructionId) {
31988 self.InstructionIds = v
31989}
31990
31991func (self *TableFeaturePropInstructionsMiss) Serialize(encoder *goloxi.Encoder) error {
31992 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
31993 return err
31994 }
31995
31996 for _, obj := range self.InstructionIds {
31997 if err := obj.Serialize(encoder); err != nil {
31998 return err
31999 }
32000 }
32001
32002 encoder.SkipAlign()
32003
32004 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
32005
32006 return nil
32007}
32008
32009func DecodeTableFeaturePropInstructionsMiss(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropInstructionsMiss, error) {
32010 _tablefeaturepropinstructionsmiss := &TableFeaturePropInstructionsMiss{TableFeatureProp: parent}
32011 defer decoder.SkipAlign()
32012
32013 for decoder.Length() >= 4 {
32014 item, err := DecodeInstructionId(decoder)
32015 if err != nil {
32016 return nil, err
32017 }
32018 if item != nil {
32019 _tablefeaturepropinstructionsmiss.InstructionIds = append(_tablefeaturepropinstructionsmiss.InstructionIds, item)
32020 }
32021 }
32022 return _tablefeaturepropinstructionsmiss, nil
32023}
32024
32025func NewTableFeaturePropInstructionsMiss() *TableFeaturePropInstructionsMiss {
32026 obj := &TableFeaturePropInstructionsMiss{
32027 TableFeatureProp: NewTableFeatureProp(1),
32028 }
32029 return obj
32030}
32031
32032type TableFeaturePropMatch struct {
32033 *TableFeatureProp
32034 OxmIds []*Uint32
32035}
32036
32037type ITableFeaturePropMatch interface {
32038 ITableFeatureProp
32039 GetOxmIds() []*Uint32
32040}
32041
32042func (self *TableFeaturePropMatch) GetOxmIds() []*Uint32 {
32043 return self.OxmIds
32044}
32045
32046func (self *TableFeaturePropMatch) SetOxmIds(v []*Uint32) {
32047 self.OxmIds = v
32048}
32049
32050func (self *TableFeaturePropMatch) Serialize(encoder *goloxi.Encoder) error {
32051 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
32052 return err
32053 }
32054
32055 for _, obj := range self.OxmIds {
32056 if err := obj.Serialize(encoder); err != nil {
32057 return err
32058 }
32059 }
32060
32061 encoder.SkipAlign()
32062
32063 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
32064
32065 return nil
32066}
32067
32068func DecodeTableFeaturePropMatch(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropMatch, error) {
32069 _tablefeaturepropmatch := &TableFeaturePropMatch{TableFeatureProp: parent}
32070 defer decoder.SkipAlign()
32071
32072 for decoder.Length() >= 4 {
32073 item, err := DecodeUint32(decoder)
32074 if err != nil {
32075 return nil, err
32076 }
32077 if item != nil {
32078 _tablefeaturepropmatch.OxmIds = append(_tablefeaturepropmatch.OxmIds, item)
32079 }
32080 }
32081 return _tablefeaturepropmatch, nil
32082}
32083
32084func NewTableFeaturePropMatch() *TableFeaturePropMatch {
32085 obj := &TableFeaturePropMatch{
32086 TableFeatureProp: NewTableFeatureProp(8),
32087 }
32088 return obj
32089}
32090
32091type TableFeaturePropNextTables struct {
32092 *TableFeatureProp
32093 NextTableIds []*Uint8
32094}
32095
32096type ITableFeaturePropNextTables interface {
32097 ITableFeatureProp
32098 GetNextTableIds() []*Uint8
32099}
32100
32101func (self *TableFeaturePropNextTables) GetNextTableIds() []*Uint8 {
32102 return self.NextTableIds
32103}
32104
32105func (self *TableFeaturePropNextTables) SetNextTableIds(v []*Uint8) {
32106 self.NextTableIds = v
32107}
32108
32109func (self *TableFeaturePropNextTables) Serialize(encoder *goloxi.Encoder) error {
32110 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
32111 return err
32112 }
32113
32114 for _, obj := range self.NextTableIds {
32115 if err := obj.Serialize(encoder); err != nil {
32116 return err
32117 }
32118 }
32119
32120 encoder.SkipAlign()
32121
32122 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
32123
32124 return nil
32125}
32126
32127func DecodeTableFeaturePropNextTables(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropNextTables, error) {
32128 _tablefeaturepropnexttables := &TableFeaturePropNextTables{TableFeatureProp: parent}
32129 defer decoder.SkipAlign()
32130
32131 for decoder.Length() >= 1 {
32132 item, err := DecodeUint8(decoder)
32133 if err != nil {
32134 return nil, err
32135 }
32136 if item != nil {
32137 _tablefeaturepropnexttables.NextTableIds = append(_tablefeaturepropnexttables.NextTableIds, item)
32138 }
32139 }
32140 return _tablefeaturepropnexttables, nil
32141}
32142
32143func NewTableFeaturePropNextTables() *TableFeaturePropNextTables {
32144 obj := &TableFeaturePropNextTables{
32145 TableFeatureProp: NewTableFeatureProp(2),
32146 }
32147 return obj
32148}
32149
32150type TableFeaturePropNextTablesMiss struct {
32151 *TableFeatureProp
32152 NextTableIds []*Uint8
32153}
32154
32155type ITableFeaturePropNextTablesMiss interface {
32156 ITableFeatureProp
32157 GetNextTableIds() []*Uint8
32158}
32159
32160func (self *TableFeaturePropNextTablesMiss) GetNextTableIds() []*Uint8 {
32161 return self.NextTableIds
32162}
32163
32164func (self *TableFeaturePropNextTablesMiss) SetNextTableIds(v []*Uint8) {
32165 self.NextTableIds = v
32166}
32167
32168func (self *TableFeaturePropNextTablesMiss) Serialize(encoder *goloxi.Encoder) error {
32169 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
32170 return err
32171 }
32172
32173 for _, obj := range self.NextTableIds {
32174 if err := obj.Serialize(encoder); err != nil {
32175 return err
32176 }
32177 }
32178
32179 encoder.SkipAlign()
32180
32181 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
32182
32183 return nil
32184}
32185
32186func DecodeTableFeaturePropNextTablesMiss(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropNextTablesMiss, error) {
32187 _tablefeaturepropnexttablesmiss := &TableFeaturePropNextTablesMiss{TableFeatureProp: parent}
32188 defer decoder.SkipAlign()
32189
32190 for decoder.Length() >= 1 {
32191 item, err := DecodeUint8(decoder)
32192 if err != nil {
32193 return nil, err
32194 }
32195 if item != nil {
32196 _tablefeaturepropnexttablesmiss.NextTableIds = append(_tablefeaturepropnexttablesmiss.NextTableIds, item)
32197 }
32198 }
32199 return _tablefeaturepropnexttablesmiss, nil
32200}
32201
32202func NewTableFeaturePropNextTablesMiss() *TableFeaturePropNextTablesMiss {
32203 obj := &TableFeaturePropNextTablesMiss{
32204 TableFeatureProp: NewTableFeatureProp(3),
32205 }
32206 return obj
32207}
32208
32209type TableFeaturePropWildcards struct {
32210 *TableFeatureProp
32211 OxmIds []*Uint32
32212}
32213
32214type ITableFeaturePropWildcards interface {
32215 ITableFeatureProp
32216 GetOxmIds() []*Uint32
32217}
32218
32219func (self *TableFeaturePropWildcards) GetOxmIds() []*Uint32 {
32220 return self.OxmIds
32221}
32222
32223func (self *TableFeaturePropWildcards) SetOxmIds(v []*Uint32) {
32224 self.OxmIds = v
32225}
32226
32227func (self *TableFeaturePropWildcards) Serialize(encoder *goloxi.Encoder) error {
32228 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
32229 return err
32230 }
32231
32232 for _, obj := range self.OxmIds {
32233 if err := obj.Serialize(encoder); err != nil {
32234 return err
32235 }
32236 }
32237
32238 encoder.SkipAlign()
32239
32240 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
32241
32242 return nil
32243}
32244
32245func DecodeTableFeaturePropWildcards(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropWildcards, error) {
32246 _tablefeaturepropwildcards := &TableFeaturePropWildcards{TableFeatureProp: parent}
32247 defer decoder.SkipAlign()
32248
32249 for decoder.Length() >= 4 {
32250 item, err := DecodeUint32(decoder)
32251 if err != nil {
32252 return nil, err
32253 }
32254 if item != nil {
32255 _tablefeaturepropwildcards.OxmIds = append(_tablefeaturepropwildcards.OxmIds, item)
32256 }
32257 }
32258 return _tablefeaturepropwildcards, nil
32259}
32260
32261func NewTableFeaturePropWildcards() *TableFeaturePropWildcards {
32262 obj := &TableFeaturePropWildcards{
32263 TableFeatureProp: NewTableFeatureProp(10),
32264 }
32265 return obj
32266}
32267
32268type TableFeaturePropWriteActions struct {
32269 *TableFeatureProp
32270 ActionIds []IActionId
32271}
32272
32273type ITableFeaturePropWriteActions interface {
32274 ITableFeatureProp
32275 GetActionIds() []IActionId
32276}
32277
32278func (self *TableFeaturePropWriteActions) GetActionIds() []IActionId {
32279 return self.ActionIds
32280}
32281
32282func (self *TableFeaturePropWriteActions) SetActionIds(v []IActionId) {
32283 self.ActionIds = v
32284}
32285
32286func (self *TableFeaturePropWriteActions) Serialize(encoder *goloxi.Encoder) error {
32287 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
32288 return err
32289 }
32290
32291 for _, obj := range self.ActionIds {
32292 if err := obj.Serialize(encoder); err != nil {
32293 return err
32294 }
32295 }
32296
32297 encoder.SkipAlign()
32298
32299 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
32300
32301 return nil
32302}
32303
32304func DecodeTableFeaturePropWriteActions(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropWriteActions, error) {
32305 _tablefeaturepropwriteactions := &TableFeaturePropWriteActions{TableFeatureProp: parent}
32306 defer decoder.SkipAlign()
32307
32308 for decoder.Length() >= 4 {
32309 item, err := DecodeActionId(decoder)
32310 if err != nil {
32311 return nil, err
32312 }
32313 if item != nil {
32314 _tablefeaturepropwriteactions.ActionIds = append(_tablefeaturepropwriteactions.ActionIds, item)
32315 }
32316 }
32317 return _tablefeaturepropwriteactions, nil
32318}
32319
32320func NewTableFeaturePropWriteActions() *TableFeaturePropWriteActions {
32321 obj := &TableFeaturePropWriteActions{
32322 TableFeatureProp: NewTableFeatureProp(4),
32323 }
32324 return obj
32325}
32326
32327type TableFeaturePropWriteActionsMiss struct {
32328 *TableFeatureProp
32329 ActionIds []IActionId
32330}
32331
32332type ITableFeaturePropWriteActionsMiss interface {
32333 ITableFeatureProp
32334 GetActionIds() []IActionId
32335}
32336
32337func (self *TableFeaturePropWriteActionsMiss) GetActionIds() []IActionId {
32338 return self.ActionIds
32339}
32340
32341func (self *TableFeaturePropWriteActionsMiss) SetActionIds(v []IActionId) {
32342 self.ActionIds = v
32343}
32344
32345func (self *TableFeaturePropWriteActionsMiss) Serialize(encoder *goloxi.Encoder) error {
32346 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
32347 return err
32348 }
32349
32350 for _, obj := range self.ActionIds {
32351 if err := obj.Serialize(encoder); err != nil {
32352 return err
32353 }
32354 }
32355
32356 encoder.SkipAlign()
32357
32358 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
32359
32360 return nil
32361}
32362
32363func DecodeTableFeaturePropWriteActionsMiss(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropWriteActionsMiss, error) {
32364 _tablefeaturepropwriteactionsmiss := &TableFeaturePropWriteActionsMiss{TableFeatureProp: parent}
32365 defer decoder.SkipAlign()
32366
32367 for decoder.Length() >= 4 {
32368 item, err := DecodeActionId(decoder)
32369 if err != nil {
32370 return nil, err
32371 }
32372 if item != nil {
32373 _tablefeaturepropwriteactionsmiss.ActionIds = append(_tablefeaturepropwriteactionsmiss.ActionIds, item)
32374 }
32375 }
32376 return _tablefeaturepropwriteactionsmiss, nil
32377}
32378
32379func NewTableFeaturePropWriteActionsMiss() *TableFeaturePropWriteActionsMiss {
32380 obj := &TableFeaturePropWriteActionsMiss{
32381 TableFeatureProp: NewTableFeatureProp(5),
32382 }
32383 return obj
32384}
32385
32386type TableFeaturePropWriteSetfield struct {
32387 *TableFeatureProp
32388 OxmIds []*Uint32
32389}
32390
32391type ITableFeaturePropWriteSetfield interface {
32392 ITableFeatureProp
32393 GetOxmIds() []*Uint32
32394}
32395
32396func (self *TableFeaturePropWriteSetfield) GetOxmIds() []*Uint32 {
32397 return self.OxmIds
32398}
32399
32400func (self *TableFeaturePropWriteSetfield) SetOxmIds(v []*Uint32) {
32401 self.OxmIds = v
32402}
32403
32404func (self *TableFeaturePropWriteSetfield) Serialize(encoder *goloxi.Encoder) error {
32405 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
32406 return err
32407 }
32408
32409 for _, obj := range self.OxmIds {
32410 if err := obj.Serialize(encoder); err != nil {
32411 return err
32412 }
32413 }
32414
32415 encoder.SkipAlign()
32416
32417 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
32418
32419 return nil
32420}
32421
32422func DecodeTableFeaturePropWriteSetfield(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropWriteSetfield, error) {
32423 _tablefeaturepropwritesetfield := &TableFeaturePropWriteSetfield{TableFeatureProp: parent}
32424 defer decoder.SkipAlign()
32425
32426 for decoder.Length() >= 4 {
32427 item, err := DecodeUint32(decoder)
32428 if err != nil {
32429 return nil, err
32430 }
32431 if item != nil {
32432 _tablefeaturepropwritesetfield.OxmIds = append(_tablefeaturepropwritesetfield.OxmIds, item)
32433 }
32434 }
32435 return _tablefeaturepropwritesetfield, nil
32436}
32437
32438func NewTableFeaturePropWriteSetfield() *TableFeaturePropWriteSetfield {
32439 obj := &TableFeaturePropWriteSetfield{
32440 TableFeatureProp: NewTableFeatureProp(12),
32441 }
32442 return obj
32443}
32444
32445type TableFeaturePropWriteSetfieldMiss struct {
32446 *TableFeatureProp
32447 OxmIds []*Uint32
32448}
32449
32450type ITableFeaturePropWriteSetfieldMiss interface {
32451 ITableFeatureProp
32452 GetOxmIds() []*Uint32
32453}
32454
32455func (self *TableFeaturePropWriteSetfieldMiss) GetOxmIds() []*Uint32 {
32456 return self.OxmIds
32457}
32458
32459func (self *TableFeaturePropWriteSetfieldMiss) SetOxmIds(v []*Uint32) {
32460 self.OxmIds = v
32461}
32462
32463func (self *TableFeaturePropWriteSetfieldMiss) Serialize(encoder *goloxi.Encoder) error {
32464 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
32465 return err
32466 }
32467
32468 for _, obj := range self.OxmIds {
32469 if err := obj.Serialize(encoder); err != nil {
32470 return err
32471 }
32472 }
32473
32474 encoder.SkipAlign()
32475
32476 binary.BigEndian.PutUint16(encoder.Bytes()[2:4], uint16(len(encoder.Bytes())))
32477
32478 return nil
32479}
32480
32481func DecodeTableFeaturePropWriteSetfieldMiss(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropWriteSetfieldMiss, error) {
32482 _tablefeaturepropwritesetfieldmiss := &TableFeaturePropWriteSetfieldMiss{TableFeatureProp: parent}
32483 defer decoder.SkipAlign()
32484
32485 for decoder.Length() >= 4 {
32486 item, err := DecodeUint32(decoder)
32487 if err != nil {
32488 return nil, err
32489 }
32490 if item != nil {
32491 _tablefeaturepropwritesetfieldmiss.OxmIds = append(_tablefeaturepropwritesetfieldmiss.OxmIds, item)
32492 }
32493 }
32494 return _tablefeaturepropwritesetfieldmiss, nil
32495}
32496
32497func NewTableFeaturePropWriteSetfieldMiss() *TableFeaturePropWriteSetfieldMiss {
32498 obj := &TableFeaturePropWriteSetfieldMiss{
32499 TableFeatureProp: NewTableFeatureProp(13),
32500 }
32501 return obj
32502}
32503
32504type TableFeatures struct {
32505 Length uint16
32506 TableId uint8
32507 Name string
32508 MetadataMatch uint64
32509 MetadataWrite uint64
32510 Config uint32
32511 MaxEntries uint32
32512 Properties []ITableFeatureProp
32513}
32514
32515type ITableFeatures interface {
32516 goloxi.Serializable
32517 GetLength() uint16
32518 GetTableId() uint8
32519 GetName() string
32520 GetMetadataMatch() uint64
32521 GetMetadataWrite() uint64
32522 GetConfig() uint32
32523 GetMaxEntries() uint32
32524 GetProperties() []ITableFeatureProp
32525}
32526
32527func (self *TableFeatures) GetLength() uint16 {
32528 return self.Length
32529}
32530
32531func (self *TableFeatures) SetLength(v uint16) {
32532 self.Length = v
32533}
32534
32535func (self *TableFeatures) GetTableId() uint8 {
32536 return self.TableId
32537}
32538
32539func (self *TableFeatures) SetTableId(v uint8) {
32540 self.TableId = v
32541}
32542
32543func (self *TableFeatures) GetName() string {
32544 return self.Name
32545}
32546
32547func (self *TableFeatures) SetName(v string) {
32548 self.Name = v
32549}
32550
32551func (self *TableFeatures) GetMetadataMatch() uint64 {
32552 return self.MetadataMatch
32553}
32554
32555func (self *TableFeatures) SetMetadataMatch(v uint64) {
32556 self.MetadataMatch = v
32557}
32558
32559func (self *TableFeatures) GetMetadataWrite() uint64 {
32560 return self.MetadataWrite
32561}
32562
32563func (self *TableFeatures) SetMetadataWrite(v uint64) {
32564 self.MetadataWrite = v
32565}
32566
32567func (self *TableFeatures) GetConfig() uint32 {
32568 return self.Config
32569}
32570
32571func (self *TableFeatures) SetConfig(v uint32) {
32572 self.Config = v
32573}
32574
32575func (self *TableFeatures) GetMaxEntries() uint32 {
32576 return self.MaxEntries
32577}
32578
32579func (self *TableFeatures) SetMaxEntries(v uint32) {
32580 self.MaxEntries = v
32581}
32582
32583func (self *TableFeatures) GetProperties() []ITableFeatureProp {
32584 return self.Properties
32585}
32586
32587func (self *TableFeatures) SetProperties(v []ITableFeatureProp) {
32588 self.Properties = v
32589}
32590
32591func (self *TableFeatures) Serialize(encoder *goloxi.Encoder) error {
32592
32593 encoder.PutUint16(uint16(self.Length))
32594 encoder.PutUint8(uint8(self.TableId))
32595 encoder.Write(bytes.Repeat([]byte{0}, 5))
32596 encoder.Write([]byte(self.Name))
32597 encoder.PutUint64(uint64(self.MetadataMatch))
32598 encoder.PutUint64(uint64(self.MetadataWrite))
32599 encoder.PutUint32(uint32(self.Config))
32600 encoder.PutUint32(uint32(self.MaxEntries))
32601 for _, obj := range self.Properties {
32602 if err := obj.Serialize(encoder); err != nil {
32603 return err
32604 }
32605 }
32606
32607 binary.BigEndian.PutUint16(encoder.Bytes()[0:2], uint16(len(encoder.Bytes())))
32608
32609 return nil
32610}
32611
32612func DecodeTableFeatures(decoder *goloxi.Decoder) (*TableFeatures, error) {
32613 _tablefeatures := &TableFeatures{}
32614 if decoder.Length() < 64 {
32615 return nil, fmt.Errorf("TableFeatures packet too short: %d < 64", decoder.Length())
32616 }
32617 _tablefeatures.Length = uint16(decoder.ReadUint16())
32618 oldDecoder := decoder
32619 defer func() { decoder = oldDecoder }()
32620 decoder = decoder.SliceDecoder(int(_tablefeatures.Length), 2+0)
32621 _tablefeatures.TableId = uint8(decoder.ReadByte())
32622 decoder.Skip(5)
32623 _tablefeatures.Name = string(bytes.Trim(decoder.Read(32), "\x00"))
32624 _tablefeatures.MetadataMatch = uint64(decoder.ReadUint64())
32625 _tablefeatures.MetadataWrite = uint64(decoder.ReadUint64())
32626 _tablefeatures.Config = uint32(decoder.ReadUint32())
32627 _tablefeatures.MaxEntries = uint32(decoder.ReadUint32())
32628
32629 for decoder.Length() >= 4 {
32630 item, err := DecodeTableFeatureProp(decoder)
32631 if err != nil {
32632 return nil, err
32633 }
32634 if item != nil {
32635 _tablefeatures.Properties = append(_tablefeatures.Properties, item)
32636 }
32637 }
32638 return _tablefeatures, nil
32639}
32640
32641func NewTableFeatures() *TableFeatures {
32642 obj := &TableFeatures{}
32643 return obj
32644}
32645
32646type TableStatsEntry struct {
32647 TableId uint8
32648 ActiveCount uint32
32649 LookupCount uint64
32650 MatchedCount uint64
32651}
32652
32653type ITableStatsEntry interface {
32654 goloxi.Serializable
32655 GetTableId() uint8
32656 GetActiveCount() uint32
32657 GetLookupCount() uint64
32658 GetMatchedCount() uint64
32659}
32660
32661func (self *TableStatsEntry) GetTableId() uint8 {
32662 return self.TableId
32663}
32664
32665func (self *TableStatsEntry) SetTableId(v uint8) {
32666 self.TableId = v
32667}
32668
32669func (self *TableStatsEntry) GetActiveCount() uint32 {
32670 return self.ActiveCount
32671}
32672
32673func (self *TableStatsEntry) SetActiveCount(v uint32) {
32674 self.ActiveCount = v
32675}
32676
32677func (self *TableStatsEntry) GetLookupCount() uint64 {
32678 return self.LookupCount
32679}
32680
32681func (self *TableStatsEntry) SetLookupCount(v uint64) {
32682 self.LookupCount = v
32683}
32684
32685func (self *TableStatsEntry) GetMatchedCount() uint64 {
32686 return self.MatchedCount
32687}
32688
32689func (self *TableStatsEntry) SetMatchedCount(v uint64) {
32690 self.MatchedCount = v
32691}
32692
32693func (self *TableStatsEntry) Serialize(encoder *goloxi.Encoder) error {
32694
32695 encoder.PutUint8(uint8(self.TableId))
32696 encoder.Write(bytes.Repeat([]byte{0}, 3))
32697 encoder.PutUint32(uint32(self.ActiveCount))
32698 encoder.PutUint64(uint64(self.LookupCount))
32699 encoder.PutUint64(uint64(self.MatchedCount))
32700
32701 return nil
32702}
32703
32704func DecodeTableStatsEntry(decoder *goloxi.Decoder) (*TableStatsEntry, error) {
32705 _tablestatsentry := &TableStatsEntry{}
32706 if decoder.Length() < 24 {
32707 return nil, fmt.Errorf("TableStatsEntry packet too short: %d < 24", decoder.Length())
32708 }
32709 _tablestatsentry.TableId = uint8(decoder.ReadByte())
32710 decoder.Skip(3)
32711 _tablestatsentry.ActiveCount = uint32(decoder.ReadUint32())
32712 _tablestatsentry.LookupCount = uint64(decoder.ReadUint64())
32713 _tablestatsentry.MatchedCount = uint64(decoder.ReadUint64())
32714 return _tablestatsentry, nil
32715}
32716
32717func NewTableStatsEntry() *TableStatsEntry {
32718 obj := &TableStatsEntry{}
32719 return obj
32720}
32721
32722type Uint32 struct {
32723 Value uint32
32724}
32725
32726type IUint32 interface {
32727 goloxi.Serializable
32728 GetValue() uint32
32729}
32730
32731func (self *Uint32) GetValue() uint32 {
32732 return self.Value
32733}
32734
32735func (self *Uint32) SetValue(v uint32) {
32736 self.Value = v
32737}
32738
32739func (self *Uint32) Serialize(encoder *goloxi.Encoder) error {
32740
32741 encoder.PutUint32(uint32(self.Value))
32742
32743 return nil
32744}
32745
32746func DecodeUint32(decoder *goloxi.Decoder) (*Uint32, error) {
32747 _uint32 := &Uint32{}
32748 if decoder.Length() < 4 {
32749 return nil, fmt.Errorf("Uint32 packet too short: %d < 4", decoder.Length())
32750 }
32751 _uint32.Value = uint32(decoder.ReadUint32())
32752 return _uint32, nil
32753}
32754
32755func NewUint32() *Uint32 {
32756 obj := &Uint32{}
32757 return obj
32758}
32759
32760type Uint64 struct {
32761 Value uint64
32762}
32763
32764type IUint64 interface {
32765 goloxi.Serializable
32766 GetValue() uint64
32767}
32768
32769func (self *Uint64) GetValue() uint64 {
32770 return self.Value
32771}
32772
32773func (self *Uint64) SetValue(v uint64) {
32774 self.Value = v
32775}
32776
32777func (self *Uint64) Serialize(encoder *goloxi.Encoder) error {
32778
32779 encoder.PutUint64(uint64(self.Value))
32780
32781 return nil
32782}
32783
32784func DecodeUint64(decoder *goloxi.Decoder) (*Uint64, error) {
32785 _uint64 := &Uint64{}
32786 if decoder.Length() < 8 {
32787 return nil, fmt.Errorf("Uint64 packet too short: %d < 8", decoder.Length())
32788 }
32789 _uint64.Value = uint64(decoder.ReadUint64())
32790 return _uint64, nil
32791}
32792
32793func NewUint64() *Uint64 {
32794 obj := &Uint64{}
32795 return obj
32796}
32797
32798type Uint8 struct {
32799 Value uint8
32800}
32801
32802type IUint8 interface {
32803 goloxi.Serializable
32804 GetValue() uint8
32805}
32806
32807func (self *Uint8) GetValue() uint8 {
32808 return self.Value
32809}
32810
32811func (self *Uint8) SetValue(v uint8) {
32812 self.Value = v
32813}
32814
32815func (self *Uint8) Serialize(encoder *goloxi.Encoder) error {
32816
32817 encoder.PutUint8(uint8(self.Value))
32818
32819 return nil
32820}
32821
32822func DecodeUint8(decoder *goloxi.Decoder) (*Uint8, error) {
32823 _uint8 := &Uint8{}
32824 if decoder.Length() < 1 {
32825 return nil, fmt.Errorf("Uint8 packet too short: %d < 1", decoder.Length())
32826 }
32827 _uint8.Value = uint8(decoder.ReadByte())
32828 return _uint8, nil
32829}
32830
32831func NewUint8() *Uint8 {
32832 obj := &Uint8{}
32833 return obj
32834}