Gitiles
Code Review Sign In
gerrit.opencord.org / goloxi / 5bac8afc8b617bc1ebc4394060337c6ec32f3819 / . / of14 / common.go
blob: 19d4190fc0491dd0ba3bd40d8577b93c3eb6a813 [file] [log] [blame]
Jonathan Hart44bdbfc2020-04-14 17:45:47 -0700[diff] [blame]1/*
2 * Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
3 * Copyright (c) 2011, 2012 Open Networking Foundation
4 * Copyright 2013, Big Switch Networks, Inc. This library was generated by the LoxiGen Compiler.
5 * Copyright 2018, Red Hat, Inc.
6 */
7// Automatically generated by LOXI from template module.go
8// Do not modify
9
10package of14
11
12import (
13 "bytes"
14 "encoding/binary"
15 "fmt"
16 "net"
17
18 "github.com/opencord/goloxi"
19)
20
21type OxmId struct {
22 TypeLen uint32
23}
24
25type IOxmId interface {
26 goloxi.Serializable
27 GetTypeLen() uint32
28 GetOXMName() string
29}
30
31func (self *OxmId) GetTypeLen() uint32 {
32 return self.TypeLen
33}
34
35func (self *OxmId) SetTypeLen(v uint32) {
36 self.TypeLen = v
37}
38
39func (self *OxmId) Serialize(encoder *goloxi.Encoder) error {
40
41 encoder.PutUint32(uint32(self.TypeLen))
42
43 return nil
44}
45
46func DecodeOxmId(decoder *goloxi.Decoder) (IOxmId, error) {
47 _oxmid := &OxmId{}
48 if decoder.Length() < 4 {
49 return nil, fmt.Errorf("OxmId packet too short: %d < 4", decoder.Length())
50 }
51 _oxmid.TypeLen = uint32(decoder.ReadUint32())
52
53 switch _oxmid.TypeLen {
54 case 110204:
55 return DecodeOxmIdTunMetadata47(_oxmid, decoder)
56 case 129026:
57 return DecodeOxmIdConnTrackingTpSrc(_oxmid, decoder)
58 case 2147489796:
59 return DecodeOxmIdIpv4Dst(_oxmid, decoder)
60 case 77830:
61 return DecodeOxmIdNdSll(_oxmid, decoder)
62 case 80897:
63 return DecodeOxmIdMplsTtl(_oxmid, decoder)
64 case 73736:
65 return DecodeOxmIdTunId(_oxmid, decoder)
66 case 2:
67 return DecodeOxmIdInPort(_oxmid, decoder)
68 case 120848:
69 return DecodeOxmIdConnTrackingLabel(_oxmid, decoder)
70 case 65540:
71 return DecodeOxmIdReg0(_oxmid, decoder)
72 case 111228:
73 return DecodeOxmIdTunMetadata49(_oxmid, decoder)
74 case 74758:
75 return DecodeOxmIdArpTha(_oxmid, decoder)
76 case 2147499266:
77 return DecodeOxmIdIcmpv6CodeMasked(_oxmid, decoder)
78 case 2147503112:
79 return DecodeOxmIdTunnelId(_oxmid, decoder)
80 case 112252:
81 return DecodeOxmIdTunMetadata51(_oxmid, decoder)
82 case 108024:
83 return DecodeOxmIdTunMetadata42Masked(_oxmid, decoder)
84 case 113276:
85 return DecodeOxmIdTunMetadata53(_oxmid, decoder)
86 case 109048:
87 return DecodeOxmIdTunMetadata44Masked(_oxmid, decoder)
88 case 94332:
89 return DecodeOxmIdTunMetadata16(_oxmid, decoder)
90 case 114300:
91 return DecodeOxmIdTunMetadata55(_oxmid, decoder)
92 case 2050:
93 return DecodeOxmIdVlanTci(_oxmid, decoder)
94 case 3073:
95 return DecodeOxmIdNwProto(_oxmid, decoder)
96 case 110072:
97 return DecodeOxmIdTunMetadata46Masked(_oxmid, decoder)
98 case 2147502338:
99 return DecodeOxmIdMplsBosMasked(_oxmid, decoder)
100 case 66564:
101 return DecodeOxmIdReg2(_oxmid, decoder)
102 case 115324:
103 return DecodeOxmIdTunMetadata57(_oxmid, decoder)
104 case 2147486722:
105 return DecodeOxmIdVlanVid(_oxmid, decoder)
106 case 2147487745:
107 return DecodeOxmIdIpDscp(_oxmid, decoder)
108 case 111096:
109 return DecodeOxmIdTunMetadata48Masked(_oxmid, decoder)
110 case 83204:
111 return DecodeOxmIdTcpFlagsMasked(_oxmid, decoder)
112 case 3588:
113 return DecodeOxmIdIpSrc(_oxmid, decoder)
114 case 198660:
115 return DecodeOxmIdBsnL3InterfaceClassId(_oxmid, decoder)
116 case 2147488769:
117 return DecodeOxmIdIpProto(_oxmid, decoder)
118 case 112120:
119 return DecodeOxmIdTunMetadata50Masked(_oxmid, decoder)
120 case 121872:
121 return DecodeOxmIdTunIpv6Dst(_oxmid, decoder)
122 case 199172:
123 return DecodeOxmIdBsnL3SrcClassId(_oxmid, decoder)
124 case 1030:
125 return DecodeOxmIdEthSrc(_oxmid, decoder)
126 case 68612:
127 return DecodeOxmIdReg6(_oxmid, decoder)
128 case 117372:
129 return DecodeOxmIdTunMetadata61(_oxmid, decoder)
130 case 5122:
131 return DecodeOxmIdTcpDst(_oxmid, decoder)
132 case 113144:
133 return DecodeOxmIdTunMetadata52Masked(_oxmid, decoder)
134 case 122896:
135 return DecodeOxmIdXxreg1(_oxmid, decoder)
136 case 209156:
137 return DecodeOxmIdBsnInnerVlanVidMasked(_oxmid, decoder)
138 case 124192:
139 return DecodeOxmIdXxreg3Masked(_oxmid, decoder)
140 case 81672:
141 return DecodeOxmIdTunnelIpv4SrcMasked(_oxmid, decoder)
142 case 4100:
143 return DecodeOxmIdIpDst(_oxmid, decoder)
144 case 118396:
145 return DecodeOxmIdTunMetadata63(_oxmid, decoder)
146 case 2147494146:
147 return DecodeOxmIdIcmpv4CodeMasked(_oxmid, decoder)
148 case 129284:
149 return DecodeOxmIdConnTrackingTpSrcMasked(_oxmid, decoder)
150 case 114168:
151 return DecodeOxmIdTunMetadata54Masked(_oxmid, decoder)
152 case 123920:
153 return DecodeOxmIdXxreg3(_oxmid, decoder)
154 case 200968:
155 return DecodeOxmIdBsnUdf0Masked(_oxmid, decoder)
156 case 78091:
157 return DecodeOxmIdNdSllMasked(_oxmid, decoder)
158 case 2147500300:
159 return DecodeOxmIdIpv6NdSllMasked(_oxmid, decoder)
160 case 74000:
161 return DecodeOxmIdTunIdMasked(_oxmid, decoder)
162 case 86140:
163 return DecodeOxmIdTunMetadata0(_oxmid, decoder)
164 case 70660:
165 return DecodeOxmIdReg10(_oxmid, decoder)
166 case 121120:
167 return DecodeOxmIdConnTrackingLabelMasked(_oxmid, decoder)
168 case 107000:
169 return DecodeOxmIdTunMetadata40Masked(_oxmid, decoder)
170 case 3848:
171 return DecodeOxmIdIpSrcMasked(_oxmid, decoder)
172 case 87164:
173 return DecodeOxmIdTunMetadata2(_oxmid, decoder)
174 case 202756:
175 return DecodeOxmIdBsnUdf4(_oxmid, decoder)
176 case 204802:
177 return DecodeOxmIdBsnTcpFlags(_oxmid, decoder)
178 case 205825:
179 return DecodeOxmIdBsnL2CacheHit(_oxmid, decoder)
180 case 116216:
181 return DecodeOxmIdTunMetadata58Masked(_oxmid, decoder)
182 case 199432:
183 return DecodeOxmIdBsnL3SrcClassIdMasked(_oxmid, decoder)
184 case 88188:
185 return DecodeOxmIdTunMetadata4(_oxmid, decoder)
186 case 72708:
187 return DecodeOxmIdReg14(_oxmid, decoder)
188 case 2147492866:
189 return DecodeOxmIdSctpDst(_oxmid, decoder)
190 case 2147493889:
191 return DecodeOxmIdIcmpv4Code(_oxmid, decoder)
192 case 117240:
193 return DecodeOxmIdTunMetadata60Masked(_oxmid, decoder)
194 case 200196:
195 return DecodeOxmIdBsnEgrPortGroupId(_oxmid, decoder)
196 case 128288:
197 return DecodeOxmIdConnTrackingIpv6SrcMasked(_oxmid, decoder)
198 case 89212:
199 return DecodeOxmIdTunMetadata6(_oxmid, decoder)
200 case 8196:
201 return DecodeOxmIdArpSpa(_oxmid, decoder)
202 case 76801:
203 return DecodeOxmIdIcmpv6Code(_oxmid, decoder)
204 case 118264:
205 return DecodeOxmIdTunMetadata62Masked(_oxmid, decoder)
206 case 70148:
207 return DecodeOxmIdReg9(_oxmid, decoder)
208 case 119560:
209 return DecodeOxmIdConnTrackingStateMasked(_oxmid, decoder)
210 case 90236:
211 return DecodeOxmIdTunMetadata8(_oxmid, decoder)
212 case 119044:
213 return DecodeOxmIdTunFlagsMasked(_oxmid, decoder)
214 case 82696:
215 return DecodeOxmIdPktMarkMasked(_oxmid, decoder)
216 case 4294923528:
217 return DecodeOxmIdOvsTcpFlagsMasked(_oxmid, decoder)
218 case 120584:
219 return DecodeOxmIdConnTrackingMarkMasked(_oxmid, decoder)
220 case 91260:
221 return DecodeOxmIdTunMetadata10(_oxmid, decoder)
222 case 87032:
223 return DecodeOxmIdTunMetadata1Masked(_oxmid, decoder)
224 case 126722:
225 return DecodeOxmIdConnTrackingNwProtoMasked(_oxmid, decoder)
226 case 206852:
227 return DecodeOxmIdBsnIngressPortGroupId(_oxmid, decoder)
228 case 208898:
229 return DecodeOxmIdBsnInnerVlanVid(_oxmid, decoder)
230 case 209921:
231 return DecodeOxmIdBsnIpFragmentation(_oxmid, decoder)
232 case 196896:
233 return DecodeOxmIdBsnInPorts128Masked(_oxmid, decoder)
234 case 92284:
235 return DecodeOxmIdTunMetadata12(_oxmid, decoder)
236 case 88056:
237 return DecodeOxmIdTunMetadata3Masked(_oxmid, decoder)
238 case 79873:
239 return DecodeOxmIdNwEcn(_oxmid, decoder)
240 case 196624:
241 return DecodeOxmIdBsnInPorts128(_oxmid, decoder)
242 case 200456:
243 return DecodeOxmIdBsnEgrPortGroupIdMasked(_oxmid, decoder)
244 case 2147489284:
245 return DecodeOxmIdIpv4Src(_oxmid, decoder)
246 case 93308:
247 return DecodeOxmIdTunMetadata14(_oxmid, decoder)
248 case 115192:
249 return DecodeOxmIdTunMetadata56Masked(_oxmid, decoder)
250 case 2561:
251 return DecodeOxmIdNwTos(_oxmid, decoder)
252 case 129538:
253 return DecodeOxmIdConnTrackingTpDst(_oxmid, decoder)
254 case 2147500550:
255 return DecodeOxmIdIpv6NdTll(_oxmid, decoder)
256 case 84484:
257 return DecodeOxmIdConjId(_oxmid, decoder)
258 case 74246:
259 return DecodeOxmIdArpSha(_oxmid, decoder)
260 case 2147488514:
261 return DecodeOxmIdIpEcnMasked(_oxmid, decoder)
262 case 123408:
263 return DecodeOxmIdXxreg2(_oxmid, decoder)
264 case 90104:
265 return DecodeOxmIdTunMetadata7Masked(_oxmid, decoder)
266 case 2147486468:
267 return DecodeOxmIdEthTypeMasked(_oxmid, decoder)
268 case 70408:
269 return DecodeOxmIdReg9Masked(_oxmid, decoder)
270 case 91128:
271 return DecodeOxmIdTunMetadata9Masked(_oxmid, decoder)
272 case 83720:
273 return DecodeOxmIdDpHashMasked(_oxmid, decoder)
274 case 2147497988:
275 return DecodeOxmIdIpv6Flabel(_oxmid, decoder)
276 case 78603:
277 return DecodeOxmIdNdTllMasked(_oxmid, decoder)
278 case 2147503376:
279 return DecodeOxmIdTunnelIdMasked(_oxmid, decoder)
280 case 96380:
281 return DecodeOxmIdTunMetadata20(_oxmid, decoder)
282 case 92152:
283 return DecodeOxmIdTunMetadata11Masked(_oxmid, decoder)
284 case 129796:
285 return DecodeOxmIdConnTrackingTpDstMasked(_oxmid, decoder)
286 case 2147502081:
287 return DecodeOxmIdMplsBos(_oxmid, decoder)
288 case 97404:
289 return DecodeOxmIdTunMetadata22(_oxmid, decoder)
290 case 93176:
291 return DecodeOxmIdTunMetadata13Masked(_oxmid, decoder)
292 case 94844:
293 return DecodeOxmIdTunMetadata17(_oxmid, decoder)
294 case 81924:
295 return DecodeOxmIdTunnelIpv4Dst(_oxmid, decoder)
296 case 127752:
297 return DecodeOxmIdConnTrackingNwDstMasked(_oxmid, decoder)
298 case 98428:
299 return DecodeOxmIdTunMetadata24(_oxmid, decoder)
300 case 94200:
301 return DecodeOxmIdTunMetadata15Masked(_oxmid, decoder)
302 case 2147501060:
303 return DecodeOxmIdMplsLabel(_oxmid, decoder)
304 case 84994:
305 return DecodeOxmIdTunGbpId(_oxmid, decoder)
306 case 71432:
307 return DecodeOxmIdReg11Masked(_oxmid, decoder)
308 case 99452:
309 return DecodeOxmIdTunMetadata26(_oxmid, decoder)
310 case 95224:
311 return DecodeOxmIdTunMetadata17Masked(_oxmid, decoder)
312 case 2147500038:
313 return DecodeOxmIdIpv6NdSll(_oxmid, decoder)
314 case 83972:
315 return DecodeOxmIdRecircId(_oxmid, decoder)
316 case 128800:
317 return DecodeOxmIdConnTrackingIpv6DstMasked(_oxmid, decoder)
318 case 72196:
319 return DecodeOxmIdReg13(_oxmid, decoder)
320 case 100476:
321 return DecodeOxmIdTunMetadata28(_oxmid, decoder)
322 case 96248:
323 return DecodeOxmIdTunMetadata19Masked(_oxmid, decoder)
324 case 112764:
325 return DecodeOxmIdTunMetadata52(_oxmid, decoder)
326 case 101500:
327 return DecodeOxmIdTunMetadata30(_oxmid, decoder)
328 case 97272:
329 return DecodeOxmIdTunMetadata21Masked(_oxmid, decoder)
330 case 2147498754:
331 return DecodeOxmIdIcmpv6TypeMasked(_oxmid, decoder)
332 case 209668:
333 return DecodeOxmIdBsnVfiMasked(_oxmid, decoder)
334 case 2147484424:
335 return DecodeOxmIdInPhyPortMasked(_oxmid, decoder)
336 case 74507:
337 return DecodeOxmIdArpShaMasked(_oxmid, decoder)
338 case 2147500812:
339 return DecodeOxmIdIpv6NdTllMasked(_oxmid, decoder)
340 case 197384:
341 return DecodeOxmIdBsnLagIdMasked(_oxmid, decoder)
342 case 76064:
343 return DecodeOxmIdIpv6DstMasked(_oxmid, decoder)
344 case 102524:
345 return DecodeOxmIdTunMetadata32(_oxmid, decoder)
346 case 98296:
347 return DecodeOxmIdTunMetadata23Masked(_oxmid, decoder)
348 case 4868:
349 return DecodeOxmIdTcpSrcMasked(_oxmid, decoder)
350 case 121632:
351 return DecodeOxmIdTunIpv6SrcMasked(_oxmid, decoder)
352 case 75792:
353 return DecodeOxmIdIpv6Dst(_oxmid, decoder)
354 case 202504:
355 return DecodeOxmIdBsnUdf3Masked(_oxmid, decoder)
356 case 120324:
357 return DecodeOxmIdConnTrackingMark(_oxmid, decoder)
358 case 99320:
359 return DecodeOxmIdTunMetadata25Masked(_oxmid, decoder)
360 case 65800:
361 return DecodeOxmIdReg0Masked(_oxmid, decoder)
362 case 66824:
363 return DecodeOxmIdReg2Masked(_oxmid, decoder)
364 case 2147506180:
365 return DecodeOxmIdPacketType(_oxmid, decoder)
366 case 72456:
367 return DecodeOxmIdReg13Masked(_oxmid, decoder)
368 case 68360:
369 return DecodeOxmIdReg5Masked(_oxmid, decoder)
370 case 104572:
371 return DecodeOxmIdTunMetadata36(_oxmid, decoder)
372 case 95356:
373 return DecodeOxmIdTunMetadata18(_oxmid, decoder)
374 case 100344:
375 return DecodeOxmIdTunMetadata27Masked(_oxmid, decoder)
376 case 4294923270:
377 return DecodeOxmIdOvsTcpFlags(_oxmid, decoder)
378 case 779:
379 return DecodeOxmIdEthDstMasked(_oxmid, decoder)
380 case 69384:
381 return DecodeOxmIdReg7Masked(_oxmid, decoder)
382 case 105596:
383 return DecodeOxmIdTunMetadata38(_oxmid, decoder)
384 case 101368:
385 return DecodeOxmIdTunMetadata29Masked(_oxmid, decoder)
386 case 2147493634:
387 return DecodeOxmIdIcmpv4TypeMasked(_oxmid, decoder)
388 case 108668:
389 return DecodeOxmIdTunMetadata44(_oxmid, decoder)
390 case 201480:
391 return DecodeOxmIdBsnUdf1Masked(_oxmid, decoder)
392 case 106620:
393 return DecodeOxmIdTunMetadata40(_oxmid, decoder)
394 case 102392:
395 return DecodeOxmIdTunMetadata31Masked(_oxmid, decoder)
396 case 2147492612:
397 return DecodeOxmIdSctpSrcMasked(_oxmid, decoder)
398 case 73480:
399 return DecodeOxmIdReg15Masked(_oxmid, decoder)
400 case 204292:
401 return DecodeOxmIdBsnUdf7(_oxmid, decoder)
402 case 2147489544:
403 return DecodeOxmIdIpv4SrcMasked(_oxmid, decoder)
404 case 107644:
405 return DecodeOxmIdTunMetadata42(_oxmid, decoder)
406 case 103416:
407 return DecodeOxmIdTunMetadata33Masked(_oxmid, decoder)
408 case 2147498248:
409 return DecodeOxmIdIpv6FlabelMasked(_oxmid, decoder)
410 case 203528:
411 return DecodeOxmIdBsnUdf5Masked(_oxmid, decoder)
412 case 89592:
413 return DecodeOxmIdTunMetadata6Masked(_oxmid, decoder)
414 case 104440:
415 return DecodeOxmIdTunMetadata35Masked(_oxmid, decoder)
416 case 2147494660:
417 return DecodeOxmIdArpOpMasked(_oxmid, decoder)
418 case 197636:
419 return DecodeOxmIdBsnVrf(_oxmid, decoder)
420 case 204552:
421 return DecodeOxmIdBsnUdf7Masked(_oxmid, decoder)
422 case 109692:
423 return DecodeOxmIdTunMetadata46(_oxmid, decoder)
424 case 105464:
425 return DecodeOxmIdTunMetadata37Masked(_oxmid, decoder)
426 case 89080:
427 return DecodeOxmIdTunMetadata5Masked(_oxmid, decoder)
428 case 67588:
429 return DecodeOxmIdReg4(_oxmid, decoder)
430 case 7169:
431 return DecodeOxmIdIcmpCode(_oxmid, decoder)
432 case 82946:
433 return DecodeOxmIdTcpFlags(_oxmid, decoder)
434 case 203780:
435 return DecodeOxmIdBsnUdf6(_oxmid, decoder)
436 case 207878:
437 return DecodeOxmIdBsnInnerEthDst(_oxmid, decoder)
438 case 85505:
439 return DecodeOxmIdTunGbpFlags(_oxmid, decoder)
440 case 2147484680:
441 return DecodeOxmIdMetadata(_oxmid, decoder)
442 case 1538:
443 return DecodeOxmIdEthType(_oxmid, decoder)
444 case 8968:
445 return DecodeOxmIdArpTpaMasked(_oxmid, decoder)
446 case 128016:
447 return DecodeOxmIdConnTrackingIpv6Src(_oxmid, decoder)
448 case 110716:
449 return DecodeOxmIdTunMetadata48(_oxmid, decoder)
450 case 127492:
451 return DecodeOxmIdConnTrackingNwDst(_oxmid, decoder)
452 case 78342:
453 return DecodeOxmIdNdTll(_oxmid, decoder)
454 case 111740:
455 return DecodeOxmIdTunMetadata50(_oxmid, decoder)
456 case 107512:
457 return DecodeOxmIdTunMetadata41Masked(_oxmid, decoder)
458 case 207624:
459 return DecodeOxmIdBsnVxlanNetworkIdMasked(_oxmid, decoder)
460 case 121360:
461 return DecodeOxmIdTunIpv6Src(_oxmid, decoder)
462 case 113788:
463 return DecodeOxmIdTunMetadata54(_oxmid, decoder)
464 case 109560:
465 return DecodeOxmIdTunMetadata45Masked(_oxmid, decoder)
466 case 2147501826:
467 return DecodeOxmIdMplsTcMasked(_oxmid, decoder)
468 case 103548:
469 return DecodeOxmIdTunMetadata34(_oxmid, decoder)
470 case 2147484164:
471 return DecodeOxmIdInPhyPort(_oxmid, decoder)
472 case 205316:
473 return DecodeOxmIdBsnVlanXlatePortGroupId(_oxmid, decoder)
474 case 114812:
475 return DecodeOxmIdTunMetadata56(_oxmid, decoder)
476 case 2147487233:
477 return DecodeOxmIdVlanPcp(_oxmid, decoder)
478 case 110584:
479 return DecodeOxmIdTunMetadata47Masked(_oxmid, decoder)
480 case 210696:
481 return DecodeOxmIdBsnIfpClassIdMasked(_oxmid, decoder)
482 case 115836:
483 return DecodeOxmIdTunMetadata58(_oxmid, decoder)
484 case 2147488257:
485 return DecodeOxmIdIpEcn(_oxmid, decoder)
486 case 111608:
487 return DecodeOxmIdTunMetadata49Masked(_oxmid, decoder)
488 case 518:
489 return DecodeOxmIdEthDst(_oxmid, decoder)
490 case 68100:
491 return DecodeOxmIdReg5(_oxmid, decoder)
492 case 116860:
493 return DecodeOxmIdTunMetadata60(_oxmid, decoder)
494 case 4610:
495 return DecodeOxmIdTcpSrc(_oxmid, decoder)
496 case 112632:
497 return DecodeOxmIdTunMetadata51Masked(_oxmid, decoder)
498 case 122384:
499 return DecodeOxmIdXxreg0(_oxmid, decoder)
500 case 2147504898:
501 return DecodeOxmIdPbbUcaMasked(_oxmid, decoder)
502 case 123680:
503 return DecodeOxmIdXxreg2Masked(_oxmid, decoder)
504 case 69124:
505 return DecodeOxmIdReg7(_oxmid, decoder)
506 case 117884:
507 return DecodeOxmIdTunMetadata62(_oxmid, decoder)
508 case 5634:
509 return DecodeOxmIdUdpSrc(_oxmid, decoder)
510 case 6657:
511 return DecodeOxmIdIcmpType(_oxmid, decoder)
512 case 113656:
513 return DecodeOxmIdTunMetadata53Masked(_oxmid, decoder)
514 case 2147503876:
515 return DecodeOxmIdIpv6ExthdrMasked(_oxmid, decoder)
516 case 198920:
517 return DecodeOxmIdBsnL3InterfaceClassIdMasked(_oxmid, decoder)
518 case 2147489026:
519 return DecodeOxmIdIpProtoMasked(_oxmid, decoder)
520 case 120068:
521 return DecodeOxmIdConnTrackingZoneMasked(_oxmid, decoder)
522 case 1286:
523 return DecodeOxmIdEthSrcMasked(_oxmid, decoder)
524 case 204040:
525 return DecodeOxmIdBsnUdf6Masked(_oxmid, decoder)
526 case 75019:
527 return DecodeOxmIdArpThaMasked(_oxmid, decoder)
528 case 208140:
529 return DecodeOxmIdBsnInnerEthDstMasked(_oxmid, decoder)
530 case 201220:
531 return DecodeOxmIdBsnUdf1(_oxmid, decoder)
532 case 205576:
533 return DecodeOxmIdBsnVlanXlatePortGroupIdMasked(_oxmid, decoder)
534 case 2147484944:
535 return DecodeOxmIdMetadataMasked(_oxmid, decoder)
536 case 6146:
537 return DecodeOxmIdUdpDst(_oxmid, decoder)
538 case 114680:
539 return DecodeOxmIdTunMetadata55Masked(_oxmid, decoder)
540 case 122144:
541 return DecodeOxmIdTunIpv6DstMasked(_oxmid, decoder)
542 case 86652:
543 return DecodeOxmIdTunMetadata1(_oxmid, decoder)
544 case 202244:
545 return DecodeOxmIdBsnUdf3(_oxmid, decoder)
546 case 115704:
547 return DecodeOxmIdTunMetadata57Masked(_oxmid, decoder)
548 case 69636:
549 return DecodeOxmIdReg8(_oxmid, decoder)
550 case 87676:
551 return DecodeOxmIdTunMetadata3(_oxmid, decoder)
552 case 82184:
553 return DecodeOxmIdTunnelIpv4DstMasked(_oxmid, decoder)
554 case 203268:
555 return DecodeOxmIdBsnUdf5(_oxmid, decoder)
556 case 2147492354:
557 return DecodeOxmIdSctpSrc(_oxmid, decoder)
558 case 2147493377:
559 return DecodeOxmIdIcmpv4Type(_oxmid, decoder)
560 case 116728:
561 return DecodeOxmIdTunMetadata59Masked(_oxmid, decoder)
562 case 88700:
563 return DecodeOxmIdTunMetadata5(_oxmid, decoder)
564 case 73220:
565 return DecodeOxmIdReg15(_oxmid, decoder)
566 case 76289:
567 return DecodeOxmIdIcmpv6Type(_oxmid, decoder)
568 case 117752:
569 return DecodeOxmIdTunMetadata61Masked(_oxmid, decoder)
570 case 4360:
571 return DecodeOxmIdIpDstMasked(_oxmid, decoder)
572 case 89724:
573 return DecodeOxmIdTunMetadata7(_oxmid, decoder)
574 case 8708:
575 return DecodeOxmIdArpTpa(_oxmid, decoder)
576 case 118776:
577 return DecodeOxmIdTunMetadata63Masked(_oxmid, decoder)
578 case 90748:
579 return DecodeOxmIdTunMetadata9(_oxmid, decoder)
580 case 86520:
581 return DecodeOxmIdTunMetadata0Masked(_oxmid, decoder)
582 case 2147487490:
583 return DecodeOxmIdVlanPcpMasked(_oxmid, decoder)
584 case 2147501320:
585 return DecodeOxmIdMplsLabelMasked(_oxmid, decoder)
586 case 197124:
587 return DecodeOxmIdBsnLagId(_oxmid, decoder)
588 case 78849:
589 return DecodeOxmIdIpFrag(_oxmid, decoder)
590 case 2147505928:
591 return DecodeOxmIdActsetOutputMasked(_oxmid, decoder)
592 case 200708:
593 return DecodeOxmIdBsnUdf0(_oxmid, decoder)
594 case 91772:
595 return DecodeOxmIdTunMetadata11(_oxmid, decoder)
596 case 87544:
597 return DecodeOxmIdTunMetadata2Masked(_oxmid, decoder)
598 case 207364:
599 return DecodeOxmIdBsnVxlanNetworkId(_oxmid, decoder)
600 case 209410:
601 return DecodeOxmIdBsnVfi(_oxmid, decoder)
602 case 92796:
603 return DecodeOxmIdTunMetadata13(_oxmid, decoder)
604 case 88568:
605 return DecodeOxmIdTunMetadata4Masked(_oxmid, decoder)
606 case 80385:
607 return DecodeOxmIdNwTtl(_oxmid, decoder)
608 case 105976:
609 return DecodeOxmIdTunMetadata38Masked(_oxmid, decoder)
610 case 126465:
611 return DecodeOxmIdConnTrackingNwProto(_oxmid, decoder)
612 case 7682:
613 return DecodeOxmIdArpOp(_oxmid, decoder)
614 case 71172:
615 return DecodeOxmIdReg11(_oxmid, decoder)
616 case 208390:
617 return DecodeOxmIdBsnInnerEthSrc(_oxmid, decoder)
618 case 210178:
619 return DecodeOxmIdBsnIpFragmentationMasked(_oxmid, decoder)
620 case 128528:
621 return DecodeOxmIdConnTrackingIpv6Dst(_oxmid, decoder)
622 case 85252:
623 return DecodeOxmIdTunGbpIdMasked(_oxmid, decoder)
624 case 90616:
625 return DecodeOxmIdTunMetadata8Masked(_oxmid, decoder)
626 case 79364:
627 return DecodeOxmIdIpv6Label(_oxmid, decoder)
628 case 207112:
629 return DecodeOxmIdBsnIngressPortGroupIdMasked(_oxmid, decoder)
630 case 206400:
631 return DecodeOxmIdBsnInPorts512(_oxmid, decoder)
632 case 95868:
633 return DecodeOxmIdTunMetadata19(_oxmid, decoder)
634 case 91640:
635 return DecodeOxmIdTunMetadata10Masked(_oxmid, decoder)
636 case 2147501569:
637 return DecodeOxmIdMplsTc(_oxmid, decoder)
638 case 70920:
639 return DecodeOxmIdReg10Masked(_oxmid, decoder)
640 case 96892:
641 return DecodeOxmIdTunMetadata21(_oxmid, decoder)
642 case 92664:
643 return DecodeOxmIdTunMetadata12Masked(_oxmid, decoder)
644 case 205060:
645 return DecodeOxmIdBsnTcpFlagsMasked(_oxmid, decoder)
646 case 81412:
647 return DecodeOxmIdTunnelIpv4Src(_oxmid, decoder)
648 case 99964:
649 return DecodeOxmIdTunMetadata27(_oxmid, decoder)
650 case 71684:
651 return DecodeOxmIdReg12(_oxmid, decoder)
652 case 127240:
653 return DecodeOxmIdConnTrackingNwSrcMasked(_oxmid, decoder)
654 case 97916:
655 return DecodeOxmIdTunMetadata23(_oxmid, decoder)
656 case 93688:
657 return DecodeOxmIdTunMetadata14Masked(_oxmid, decoder)
658 case 210436:
659 return DecodeOxmIdBsnIfpClassId(_oxmid, decoder)
660 case 82436:
661 return DecodeOxmIdPktMark(_oxmid, decoder)
662 case 98940:
663 return DecodeOxmIdTunMetadata25(_oxmid, decoder)
664 case 94712:
665 return DecodeOxmIdTunMetadata16Masked(_oxmid, decoder)
666 case 83460:
667 return DecodeOxmIdDpHash(_oxmid, decoder)
668 case 2147503618:
669 return DecodeOxmIdIpv6Exthdr(_oxmid, decoder)
670 case 2147504641:
671 return DecodeOxmIdPbbUca(_oxmid, decoder)
672 case 123168:
673 return DecodeOxmIdXxreg1Masked(_oxmid, decoder)
674 case 118786:
675 return DecodeOxmIdTunFlags(_oxmid, decoder)
676 case 95736:
677 return DecodeOxmIdTunMetadata18Masked(_oxmid, decoder)
678 case 2308:
679 return DecodeOxmIdVlanTciMasked(_oxmid, decoder)
680 case 2147488002:
681 return DecodeOxmIdIpDscpMasked(_oxmid, decoder)
682 case 100988:
683 return DecodeOxmIdTunMetadata29(_oxmid, decoder)
684 case 119810:
685 return DecodeOxmIdConnTrackingZone(_oxmid, decoder)
686 case 96760:
687 return DecodeOxmIdTunMetadata20Masked(_oxmid, decoder)
688 case 2147486980:
689 return DecodeOxmIdVlanVidMasked(_oxmid, decoder)
690 case 116348:
691 return DecodeOxmIdTunMetadata59(_oxmid, decoder)
692 case 5378:
693 return DecodeOxmIdTcpDstMasked(_oxmid, decoder)
694 case 71944:
695 return DecodeOxmIdReg12Masked(_oxmid, decoder)
696 case 2147483912:
697 return DecodeOxmIdInPortMasked(_oxmid, decoder)
698 case 75552:
699 return DecodeOxmIdIpv6SrcMasked(_oxmid, decoder)
700 case 102012:
701 return DecodeOxmIdTunMetadata31(_oxmid, decoder)
702 case 85762:
703 return DecodeOxmIdTunGbpFlagsMasked(_oxmid, decoder)
704 case 5892:
705 return DecodeOxmIdUdpSrcMasked(_oxmid, decoder)
706 case 97784:
707 return DecodeOxmIdTunMetadata22Masked(_oxmid, decoder)
708 case 66052:
709 return DecodeOxmIdReg1(_oxmid, decoder)
710 case 67336:
711 return DecodeOxmIdReg3Masked(_oxmid, decoder)
712 case 208652:
713 return DecodeOxmIdBsnInnerEthSrcMasked(_oxmid, decoder)
714 case 75280:
715 return DecodeOxmIdIpv6Src(_oxmid, decoder)
716 case 197896:
717 return DecodeOxmIdBsnVrfMasked(_oxmid, decoder)
718 case 122656:
719 return DecodeOxmIdXxreg0Masked(_oxmid, decoder)
720 case 103036:
721 return DecodeOxmIdTunMetadata33(_oxmid, decoder)
722 case 98808:
723 return DecodeOxmIdTunMetadata24Masked(_oxmid, decoder)
724 case 2147505668:
725 return DecodeOxmIdActsetOutput(_oxmid, decoder)
726 case 67848:
727 return DecodeOxmIdReg4Masked(_oxmid, decoder)
728 case 77600:
729 return DecodeOxmIdNdTargetMasked(_oxmid, decoder)
730 case 104060:
731 return DecodeOxmIdTunMetadata35(_oxmid, decoder)
732 case 99832:
733 return DecodeOxmIdTunMetadata26Masked(_oxmid, decoder)
734 case 6404:
735 return DecodeOxmIdUdpDstMasked(_oxmid, decoder)
736 case 77328:
737 return DecodeOxmIdNdTarget(_oxmid, decoder)
738 case 68872:
739 return DecodeOxmIdReg6Masked(_oxmid, decoder)
740 case 105084:
741 return DecodeOxmIdTunMetadata37(_oxmid, decoder)
742 case 100856:
743 return DecodeOxmIdTunMetadata28Masked(_oxmid, decoder)
744 case 206082:
745 return DecodeOxmIdBsnL2CacheHitMasked(_oxmid, decoder)
746 case 203016:
747 return DecodeOxmIdBsnUdf4Masked(_oxmid, decoder)
748 case 69896:
749 return DecodeOxmIdReg8Masked(_oxmid, decoder)
750 case 206720:
751 return DecodeOxmIdBsnInPorts512Masked(_oxmid, decoder)
752 case 106108:
753 return DecodeOxmIdTunMetadata39(_oxmid, decoder)
754 case 101880:
755 return DecodeOxmIdTunMetadata30Masked(_oxmid, decoder)
756 case 8452:
757 return DecodeOxmIdArpSpaMasked(_oxmid, decoder)
758 case 66312:
759 return DecodeOxmIdReg1Masked(_oxmid, decoder)
760 case 201992:
761 return DecodeOxmIdBsnUdf2Masked(_oxmid, decoder)
762 case 107132:
763 return DecodeOxmIdTunMetadata41(_oxmid, decoder)
764 case 102904:
765 return DecodeOxmIdTunMetadata32Masked(_oxmid, decoder)
766 case 2147493124:
767 return DecodeOxmIdSctpDstMasked(_oxmid, decoder)
768 case 67076:
769 return DecodeOxmIdReg3(_oxmid, decoder)
770 case 79624:
771 return DecodeOxmIdIpv6LabelMasked(_oxmid, decoder)
772 case 119300:
773 return DecodeOxmIdConnTrackingState(_oxmid, decoder)
774 case 2147490056:
775 return DecodeOxmIdIpv4DstMasked(_oxmid, decoder)
776 case 2147499808:
777 return DecodeOxmIdIpv6NdTargetMasked(_oxmid, decoder)
778 case 108156:
779 return DecodeOxmIdTunMetadata43(_oxmid, decoder)
780 case 103928:
781 return DecodeOxmIdTunMetadata34Masked(_oxmid, decoder)
782 case 106488:
783 return DecodeOxmIdTunMetadata39Masked(_oxmid, decoder)
784 case 201732:
785 return DecodeOxmIdBsnUdf2(_oxmid, decoder)
786 case 2147499536:
787 return DecodeOxmIdIpv6NdTarget(_oxmid, decoder)
788 case 72968:
789 return DecodeOxmIdReg14Masked(_oxmid, decoder)
790 case 109180:
791 return DecodeOxmIdTunMetadata45(_oxmid, decoder)
792 case 104952:
793 return DecodeOxmIdTunMetadata36Masked(_oxmid, decoder)
794 case 93820:
795 return DecodeOxmIdTunMetadata15(_oxmid, decoder)
796 case 79106:
797 return DecodeOxmIdIpFragMasked(_oxmid, decoder)
798 case 108536:
799 return DecodeOxmIdTunMetadata43Masked(_oxmid, decoder)
800 case 126980:
801 return DecodeOxmIdConnTrackingNwSrc(_oxmid, decoder)
802 default:
803 return _oxmid, nil
804 }
805}
806
807func NewOxmId(_type_len uint32) *OxmId {
808 obj := &OxmId{}
809 obj.TypeLen = _type_len
810 return obj
811}
812func (self *OxmId) GetOXMName() string {
813 return ""
814}
815
816func (self *OxmId) MarshalJSON() ([]byte, error) {
817 if self.TypeLen == 0 {
818 return []byte("\"\""), nil
819 } else {
820 return []byte("\"" + self.GetOXMName() + "\""), nil
821 }
822}
823
824type ActionNxBundleLoadSlave struct {
825 Port Port
826}
827
828type IActionNxBundleLoadSlave interface {
829 goloxi.Serializable
830 GetPort() Port
831}
832
833func (self *ActionNxBundleLoadSlave) GetPort() Port {
834 return self.Port
835}
836
837func (self *ActionNxBundleLoadSlave) SetPort(v Port) {
838 self.Port = v
839}
840
841func (self *ActionNxBundleLoadSlave) Serialize(encoder *goloxi.Encoder) error {
842
843 encoder.PutUint32(uint32(self.Port))
844
845 return nil
846}
847
848func DecodeActionNxBundleLoadSlave(decoder *goloxi.Decoder) (*ActionNxBundleLoadSlave, error) {
849 _actionnxbundleloadslave := &ActionNxBundleLoadSlave{}
850 if decoder.Length() < 4 {
851 return nil, fmt.Errorf("ActionNxBundleLoadSlave packet too short: %d < 4", decoder.Length())
852 }
853 _actionnxbundleloadslave.Port = Port(decoder.ReadUint32())
854 return _actionnxbundleloadslave, nil
855}
856
857func NewActionNxBundleLoadSlave() *ActionNxBundleLoadSlave {
858 obj := &ActionNxBundleLoadSlave{}
859 return obj
860}
861
862type ActionNxController2Property struct {
863 Type NxActionController2PropType
864}
865
866type IActionNxController2Property interface {
867 goloxi.Serializable
868 GetType() NxActionController2PropType
869}
870
871func (self *ActionNxController2Property) GetType() NxActionController2PropType {
872 return self.Type
873}
874
875func (self *ActionNxController2Property) SetType(v NxActionController2PropType) {
876 self.Type = v
877}
878
879func (self *ActionNxController2Property) Serialize(encoder *goloxi.Encoder) error {
880
881 encoder.PutUint16(uint16(self.Type))
882
883 return nil
884}
885
886func DecodeActionNxController2Property(decoder *goloxi.Decoder) (IActionNxController2Property, error) {
887 _actionnxcontroller2property := &ActionNxController2Property{}
888 if decoder.Length() < 2 {
889 return nil, fmt.Errorf("ActionNxController2Property packet too short: %d < 2", decoder.Length())
890 }
891 _actionnxcontroller2property.Type = NxActionController2PropType(decoder.ReadUint16())
892
893 switch _actionnxcontroller2property.Type {
894 case 0:
895 return DecodeActionNxController2PropertyMaxLen(_actionnxcontroller2property, decoder)
896 case 1:
897 return DecodeActionNxController2PropertyControllerId(_actionnxcontroller2property, decoder)
898 case 2:
899 return DecodeActionNxController2PropertyReason(_actionnxcontroller2property, decoder)
900 case 3:
901 return DecodeActionNxController2PropertyUserdata(_actionnxcontroller2property, decoder)
902 case 4:
903 return DecodeActionNxController2PropertyPause(_actionnxcontroller2property, decoder)
904 case 5:
905 return DecodeActionNxController2PropertyMeterId(_actionnxcontroller2property, decoder)
906 default:
907 return nil, fmt.Errorf("Invalid type '%d' for 'ActionNxController2Property'", _actionnxcontroller2property.Type)
908 }
909}
910
911func NewActionNxController2Property(_type NxActionController2PropType) *ActionNxController2Property {
912 obj := &ActionNxController2Property{}
913 obj.Type = _type
914 return obj
915}
916
917type ActionNxController2PropertyControllerId struct {
918 *ActionNxController2Property
919 ControllerId uint16
920}
921
922type IActionNxController2PropertyControllerId interface {
923 IActionNxController2Property
924 GetControllerId() uint16
925}
926
927func (self *ActionNxController2PropertyControllerId) GetControllerId() uint16 {
928 return self.ControllerId
929}
930
931func (self *ActionNxController2PropertyControllerId) SetControllerId(v uint16) {
932 self.ControllerId = v
933}
934
935func (self *ActionNxController2PropertyControllerId) Serialize(encoder *goloxi.Encoder) error {
936 startIndex := len(encoder.Bytes())
937 if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
938 return err
939 }
940
941 encoder.PutUint16(uint16(self.ControllerId))
942 length := len(encoder.Bytes()) - startIndex
943 alignedLength := ((length + 7) / 8 * 8)
944
945 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
946
947 return nil
948}
949
950func DecodeActionNxController2PropertyControllerId(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyControllerId, error) {
951 _actionnxcontroller2propertycontrollerid := &ActionNxController2PropertyControllerId{ActionNxController2Property: parent}
952 if decoder.Length() < 2 {
953 return nil, fmt.Errorf("ActionNxController2PropertyControllerId packet too short: %d < 2", decoder.Length())
954 }
955 defer decoder.SkipAlign()
956
957 _actionnxcontroller2propertycontrollerid.ControllerId = uint16(decoder.ReadUint16())
958 return _actionnxcontroller2propertycontrollerid, nil
959}
960
961func NewActionNxController2PropertyControllerId() *ActionNxController2PropertyControllerId {
962 obj := &ActionNxController2PropertyControllerId{
963 ActionNxController2Property: NewActionNxController2Property(1),
964 }
965 return obj
966}
967
968type ActionNxController2PropertyMaxLen struct {
969 *ActionNxController2Property
970 MaxLen uint16
971}
972
973type IActionNxController2PropertyMaxLen interface {
974 IActionNxController2Property
975 GetMaxLen() uint16
976}
977
978func (self *ActionNxController2PropertyMaxLen) GetMaxLen() uint16 {
979 return self.MaxLen
980}
981
982func (self *ActionNxController2PropertyMaxLen) SetMaxLen(v uint16) {
983 self.MaxLen = v
984}
985
986func (self *ActionNxController2PropertyMaxLen) Serialize(encoder *goloxi.Encoder) error {
987 startIndex := len(encoder.Bytes())
988 if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
989 return err
990 }
991
992 encoder.PutUint16(uint16(self.MaxLen))
993 length := len(encoder.Bytes()) - startIndex
994 alignedLength := ((length + 7) / 8 * 8)
995
996 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
997
998 return nil
999}
1000
1001func DecodeActionNxController2PropertyMaxLen(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyMaxLen, error) {
1002 _actionnxcontroller2propertymaxlen := &ActionNxController2PropertyMaxLen{ActionNxController2Property: parent}
1003 if decoder.Length() < 2 {
1004 return nil, fmt.Errorf("ActionNxController2PropertyMaxLen packet too short: %d < 2", decoder.Length())
1005 }
1006 defer decoder.SkipAlign()
1007
1008 _actionnxcontroller2propertymaxlen.MaxLen = uint16(decoder.ReadUint16())
1009 return _actionnxcontroller2propertymaxlen, nil
1010}
1011
1012func NewActionNxController2PropertyMaxLen() *ActionNxController2PropertyMaxLen {
1013 obj := &ActionNxController2PropertyMaxLen{
1014 ActionNxController2Property: NewActionNxController2Property(0),
1015 }
1016 return obj
1017}
1018
1019type ActionNxController2PropertyMeterId struct {
1020 *ActionNxController2Property
1021 MeterId uint32
1022}
1023
1024type IActionNxController2PropertyMeterId interface {
1025 IActionNxController2Property
1026 GetMeterId() uint32
1027}
1028
1029func (self *ActionNxController2PropertyMeterId) GetMeterId() uint32 {
1030 return self.MeterId
1031}
1032
1033func (self *ActionNxController2PropertyMeterId) SetMeterId(v uint32) {
1034 self.MeterId = v
1035}
1036
1037func (self *ActionNxController2PropertyMeterId) Serialize(encoder *goloxi.Encoder) error {
1038 startIndex := len(encoder.Bytes())
1039 if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
1040 return err
1041 }
1042
1043 encoder.PutUint32(uint32(self.MeterId))
1044 length := len(encoder.Bytes()) - startIndex
1045 alignedLength := ((length + 7) / 8 * 8)
1046
1047 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
1048
1049 return nil
1050}
1051
1052func DecodeActionNxController2PropertyMeterId(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyMeterId, error) {
1053 _actionnxcontroller2propertymeterid := &ActionNxController2PropertyMeterId{ActionNxController2Property: parent}
1054 if decoder.Length() < 4 {
1055 return nil, fmt.Errorf("ActionNxController2PropertyMeterId packet too short: %d < 4", decoder.Length())
1056 }
1057 defer decoder.SkipAlign()
1058
1059 _actionnxcontroller2propertymeterid.MeterId = uint32(decoder.ReadUint32())
1060 return _actionnxcontroller2propertymeterid, nil
1061}
1062
1063func NewActionNxController2PropertyMeterId() *ActionNxController2PropertyMeterId {
1064 obj := &ActionNxController2PropertyMeterId{
1065 ActionNxController2Property: NewActionNxController2Property(5),
1066 }
1067 return obj
1068}
1069
1070type ActionNxController2PropertyPause struct {
1071 *ActionNxController2Property
1072}
1073
1074type IActionNxController2PropertyPause interface {
1075 IActionNxController2Property
1076}
1077
1078func (self *ActionNxController2PropertyPause) Serialize(encoder *goloxi.Encoder) error {
1079 startIndex := len(encoder.Bytes())
1080 if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
1081 return err
1082 }
1083 length := len(encoder.Bytes()) - startIndex
1084 alignedLength := ((length + 7) / 8 * 8)
1085
1086 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
1087
1088 return nil
1089}
1090
1091func DecodeActionNxController2PropertyPause(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyPause, error) {
1092 _actionnxcontroller2propertypause := &ActionNxController2PropertyPause{ActionNxController2Property: parent}
1093 defer decoder.SkipAlign()
1094
1095 return _actionnxcontroller2propertypause, nil
1096}
1097
1098func NewActionNxController2PropertyPause() *ActionNxController2PropertyPause {
1099 obj := &ActionNxController2PropertyPause{
1100 ActionNxController2Property: NewActionNxController2Property(4),
1101 }
1102 return obj
1103}
1104
1105type ActionNxController2PropertyReason struct {
1106 *ActionNxController2Property
1107 Reason PacketInReason
1108}
1109
1110type IActionNxController2PropertyReason interface {
1111 IActionNxController2Property
1112 GetReason() PacketInReason
1113}
1114
1115func (self *ActionNxController2PropertyReason) GetReason() PacketInReason {
1116 return self.Reason
1117}
1118
1119func (self *ActionNxController2PropertyReason) SetReason(v PacketInReason) {
1120 self.Reason = v
1121}
1122
1123func (self *ActionNxController2PropertyReason) Serialize(encoder *goloxi.Encoder) error {
1124 startIndex := len(encoder.Bytes())
1125 if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
1126 return err
1127 }
1128
1129 encoder.PutUint8(uint8(self.Reason))
1130 length := len(encoder.Bytes()) - startIndex
1131 alignedLength := ((length + 7) / 8 * 8)
1132
1133 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
1134
1135 return nil
1136}
1137
1138func DecodeActionNxController2PropertyReason(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyReason, error) {
1139 _actionnxcontroller2propertyreason := &ActionNxController2PropertyReason{ActionNxController2Property: parent}
1140 if decoder.Length() < 1 {
1141 return nil, fmt.Errorf("ActionNxController2PropertyReason packet too short: %d < 1", decoder.Length())
1142 }
1143 defer decoder.SkipAlign()
1144
1145 _actionnxcontroller2propertyreason.Reason = PacketInReason(decoder.ReadByte())
1146 return _actionnxcontroller2propertyreason, nil
1147}
1148
1149func NewActionNxController2PropertyReason() *ActionNxController2PropertyReason {
1150 obj := &ActionNxController2PropertyReason{
1151 ActionNxController2Property: NewActionNxController2Property(2),
1152 }
1153 return obj
1154}
1155
1156type ActionNxController2PropertyUserdata struct {
1157 *ActionNxController2Property
1158 Length uint16
1159 Userdata []byte
1160}
1161
1162type IActionNxController2PropertyUserdata interface {
1163 IActionNxController2Property
1164 GetLength() uint16
1165 GetUserdata() []byte
1166}
1167
1168func (self *ActionNxController2PropertyUserdata) GetLength() uint16 {
1169 return self.Length
1170}
1171
1172func (self *ActionNxController2PropertyUserdata) SetLength(v uint16) {
1173 self.Length = v
1174}
1175
1176func (self *ActionNxController2PropertyUserdata) GetUserdata() []byte {
1177 return self.Userdata
1178}
1179
1180func (self *ActionNxController2PropertyUserdata) SetUserdata(v []byte) {
1181 self.Userdata = v
1182}
1183
1184func (self *ActionNxController2PropertyUserdata) Serialize(encoder *goloxi.Encoder) error {
1185 startIndex := len(encoder.Bytes())
1186 if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
1187 return err
1188 }
1189
1190 encoder.PutUint16(uint16(self.Length))
1191 encoder.Write(self.Userdata)
1192 length := len(encoder.Bytes()) - startIndex
1193 alignedLength := ((length + 7) / 8 * 8)
1194
1195 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1196
1197 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
1198
1199 return nil
1200}
1201
1202func DecodeActionNxController2PropertyUserdata(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyUserdata, error) {
1203 _actionnxcontroller2propertyuserdata := &ActionNxController2PropertyUserdata{ActionNxController2Property: parent}
1204 if decoder.Length() < 2 {
1205 return nil, fmt.Errorf("ActionNxController2PropertyUserdata packet too short: %d < 2", decoder.Length())
1206 }
1207 defer decoder.SkipAlign()
1208
1209 _actionnxcontroller2propertyuserdata.Length = uint16(decoder.ReadUint16())
1210 oldDecoder := decoder
1211 defer func() { decoder = oldDecoder }()
1212 decoder = decoder.SliceDecoder(int(((_actionnxcontroller2propertyuserdata.Length)+7)/8*8), 2+2)
1213 _actionnxcontroller2propertyuserdata.Userdata = decoder.Read(int(decoder.Length()))
1214 return _actionnxcontroller2propertyuserdata, nil
1215}
1216
1217func NewActionNxController2PropertyUserdata() *ActionNxController2PropertyUserdata {
1218 obj := &ActionNxController2PropertyUserdata{
1219 ActionNxController2Property: NewActionNxController2Property(3),
1220 }
1221 return obj
1222}
1223
1224type AsyncConfigProp struct {
1225 Type uint16
1226 Length uint16
1227}
1228
1229type IAsyncConfigProp interface {
1230 goloxi.Serializable
1231 GetType() uint16
1232 GetLength() uint16
1233}
1234
1235func (self *AsyncConfigProp) GetType() uint16 {
1236 return self.Type
1237}
1238
1239func (self *AsyncConfigProp) SetType(v uint16) {
1240 self.Type = v
1241}
1242
1243func (self *AsyncConfigProp) GetLength() uint16 {
1244 return self.Length
1245}
1246
1247func (self *AsyncConfigProp) SetLength(v uint16) {
1248 self.Length = v
1249}
1250
1251func (self *AsyncConfigProp) Serialize(encoder *goloxi.Encoder) error {
1252
1253 encoder.PutUint16(uint16(self.Type))
1254 encoder.PutUint16(uint16(self.Length))
1255
1256 return nil
1257}
1258
1259func DecodeAsyncConfigProp(decoder *goloxi.Decoder) (IAsyncConfigProp, error) {
1260 _asyncconfigprop := &AsyncConfigProp{}
1261 if decoder.Length() < 4 {
1262 return nil, fmt.Errorf("AsyncConfigProp packet too short: %d < 4", decoder.Length())
1263 }
1264 _asyncconfigprop.Type = uint16(decoder.ReadUint16())
1265 _asyncconfigprop.Length = uint16(decoder.ReadUint16())
1266 oldDecoder := decoder
1267 defer func() { decoder = oldDecoder }()
1268 decoder = decoder.SliceDecoder(int(_asyncconfigprop.Length), 2+2)
1269
1270 switch _asyncconfigprop.Type {
1271 case 0:
1272 return DecodeAsyncConfigPropPacketInSlave(_asyncconfigprop, decoder)
1273 case 1:
1274 return DecodeAsyncConfigPropPacketInMaster(_asyncconfigprop, decoder)
1275 case 2:
1276 return DecodeAsyncConfigPropPortStatusSlave(_asyncconfigprop, decoder)
1277 case 3:
1278 return DecodeAsyncConfigPropPortStatusMaster(_asyncconfigprop, decoder)
1279 case 4:
1280 return DecodeAsyncConfigPropFlowRemovedSlave(_asyncconfigprop, decoder)
1281 case 5:
1282 return DecodeAsyncConfigPropFlowRemovedMaster(_asyncconfigprop, decoder)
1283 case 6:
1284 return DecodeAsyncConfigPropRoleStatusSlave(_asyncconfigprop, decoder)
1285 case 7:
1286 return DecodeAsyncConfigPropRoleStatusMaster(_asyncconfigprop, decoder)
1287 case 8:
1288 return DecodeAsyncConfigPropTableStatusSlave(_asyncconfigprop, decoder)
1289 case 9:
1290 return DecodeAsyncConfigPropTableStatusMaster(_asyncconfigprop, decoder)
1291 case 10:
1292 return DecodeAsyncConfigPropRequestforwardSlave(_asyncconfigprop, decoder)
1293 case 11:
1294 return DecodeAsyncConfigPropRequestforwardMaster(_asyncconfigprop, decoder)
1295 case 65534:
1296 return DecodeAsyncConfigPropExperimenterSlave(_asyncconfigprop, decoder)
1297 case 65535:
1298 return DecodeAsyncConfigPropExperimenterMaster(_asyncconfigprop, decoder)
1299 default:
1300 return nil, fmt.Errorf("Invalid type '%d' for 'AsyncConfigProp'", _asyncconfigprop.Type)
1301 }
1302}
1303
1304func NewAsyncConfigProp(_type uint16) *AsyncConfigProp {
1305 obj := &AsyncConfigProp{}
1306 obj.Type = _type
1307 return obj
1308}
1309
1310type AsyncConfigPropExperimenterMaster struct {
1311 *AsyncConfigProp
1312}
1313
1314type IAsyncConfigPropExperimenterMaster interface {
1315 IAsyncConfigProp
1316}
1317
1318func (self *AsyncConfigPropExperimenterMaster) Serialize(encoder *goloxi.Encoder) error {
1319 startIndex := len(encoder.Bytes())
1320 if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
1321 return err
1322 }
1323 length := len(encoder.Bytes()) - startIndex
1324
1325 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1326
1327 return nil
1328}
1329
1330func DecodeAsyncConfigPropExperimenterMaster(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropExperimenterMaster, error) {
1331 _asyncconfigpropexperimentermaster := &AsyncConfigPropExperimenterMaster{AsyncConfigProp: parent}
1332 return _asyncconfigpropexperimentermaster, nil
1333}
1334
1335func NewAsyncConfigPropExperimenterMaster() *AsyncConfigPropExperimenterMaster {
1336 obj := &AsyncConfigPropExperimenterMaster{
1337 AsyncConfigProp: NewAsyncConfigProp(65535),
1338 }
1339 return obj
1340}
1341
1342type AsyncConfigPropExperimenterSlave struct {
1343 *AsyncConfigProp
1344}
1345
1346type IAsyncConfigPropExperimenterSlave interface {
1347 IAsyncConfigProp
1348}
1349
1350func (self *AsyncConfigPropExperimenterSlave) Serialize(encoder *goloxi.Encoder) error {
1351 startIndex := len(encoder.Bytes())
1352 if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
1353 return err
1354 }
1355 length := len(encoder.Bytes()) - startIndex
1356
1357 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1358
1359 return nil
1360}
1361
1362func DecodeAsyncConfigPropExperimenterSlave(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropExperimenterSlave, error) {
1363 _asyncconfigpropexperimenterslave := &AsyncConfigPropExperimenterSlave{AsyncConfigProp: parent}
1364 return _asyncconfigpropexperimenterslave, nil
1365}
1366
1367func NewAsyncConfigPropExperimenterSlave() *AsyncConfigPropExperimenterSlave {
1368 obj := &AsyncConfigPropExperimenterSlave{
1369 AsyncConfigProp: NewAsyncConfigProp(65534),
1370 }
1371 return obj
1372}
1373
1374type AsyncConfigPropFlowRemovedMaster struct {
1375 *AsyncConfigProp
1376 Mask uint32
1377}
1378
1379type IAsyncConfigPropFlowRemovedMaster interface {
1380 IAsyncConfigProp
1381 GetMask() uint32
1382}
1383
1384func (self *AsyncConfigPropFlowRemovedMaster) GetMask() uint32 {
1385 return self.Mask
1386}
1387
1388func (self *AsyncConfigPropFlowRemovedMaster) SetMask(v uint32) {
1389 self.Mask = v
1390}
1391
1392func (self *AsyncConfigPropFlowRemovedMaster) Serialize(encoder *goloxi.Encoder) error {
1393 startIndex := len(encoder.Bytes())
1394 if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
1395 return err
1396 }
1397
1398 encoder.PutUint32(uint32(self.Mask))
1399 length := len(encoder.Bytes()) - startIndex
1400
1401 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1402
1403 return nil
1404}
1405
1406func DecodeAsyncConfigPropFlowRemovedMaster(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropFlowRemovedMaster, error) {
1407 _asyncconfigpropflowremovedmaster := &AsyncConfigPropFlowRemovedMaster{AsyncConfigProp: parent}
1408 if decoder.Length() < 4 {
1409 return nil, fmt.Errorf("AsyncConfigPropFlowRemovedMaster packet too short: %d < 4", decoder.Length())
1410 }
1411 _asyncconfigpropflowremovedmaster.Mask = uint32(decoder.ReadUint32())
1412 return _asyncconfigpropflowremovedmaster, nil
1413}
1414
1415func NewAsyncConfigPropFlowRemovedMaster() *AsyncConfigPropFlowRemovedMaster {
1416 obj := &AsyncConfigPropFlowRemovedMaster{
1417 AsyncConfigProp: NewAsyncConfigProp(5),
1418 }
1419 return obj
1420}
1421
1422type AsyncConfigPropFlowRemovedSlave struct {
1423 *AsyncConfigProp
1424 Mask uint32
1425}
1426
1427type IAsyncConfigPropFlowRemovedSlave interface {
1428 IAsyncConfigProp
1429 GetMask() uint32
1430}
1431
1432func (self *AsyncConfigPropFlowRemovedSlave) GetMask() uint32 {
1433 return self.Mask
1434}
1435
1436func (self *AsyncConfigPropFlowRemovedSlave) SetMask(v uint32) {
1437 self.Mask = v
1438}
1439
1440func (self *AsyncConfigPropFlowRemovedSlave) Serialize(encoder *goloxi.Encoder) error {
1441 startIndex := len(encoder.Bytes())
1442 if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
1443 return err
1444 }
1445
1446 encoder.PutUint32(uint32(self.Mask))
1447 length := len(encoder.Bytes()) - startIndex
1448
1449 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1450
1451 return nil
1452}
1453
1454func DecodeAsyncConfigPropFlowRemovedSlave(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropFlowRemovedSlave, error) {
1455 _asyncconfigpropflowremovedslave := &AsyncConfigPropFlowRemovedSlave{AsyncConfigProp: parent}
1456 if decoder.Length() < 4 {
1457 return nil, fmt.Errorf("AsyncConfigPropFlowRemovedSlave packet too short: %d < 4", decoder.Length())
1458 }
1459 _asyncconfigpropflowremovedslave.Mask = uint32(decoder.ReadUint32())
1460 return _asyncconfigpropflowremovedslave, nil
1461}
1462
1463func NewAsyncConfigPropFlowRemovedSlave() *AsyncConfigPropFlowRemovedSlave {
1464 obj := &AsyncConfigPropFlowRemovedSlave{
1465 AsyncConfigProp: NewAsyncConfigProp(4),
1466 }
1467 return obj
1468}
1469
1470type AsyncConfigPropPacketInMaster struct {
1471 *AsyncConfigProp
1472 Mask uint32
1473}
1474
1475type IAsyncConfigPropPacketInMaster interface {
1476 IAsyncConfigProp
1477 GetMask() uint32
1478}
1479
1480func (self *AsyncConfigPropPacketInMaster) GetMask() uint32 {
1481 return self.Mask
1482}
1483
1484func (self *AsyncConfigPropPacketInMaster) SetMask(v uint32) {
1485 self.Mask = v
1486}
1487
1488func (self *AsyncConfigPropPacketInMaster) Serialize(encoder *goloxi.Encoder) error {
1489 startIndex := len(encoder.Bytes())
1490 if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
1491 return err
1492 }
1493
1494 encoder.PutUint32(uint32(self.Mask))
1495 length := len(encoder.Bytes()) - startIndex
1496
1497 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1498
1499 return nil
1500}
1501
1502func DecodeAsyncConfigPropPacketInMaster(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropPacketInMaster, error) {
1503 _asyncconfigproppacketinmaster := &AsyncConfigPropPacketInMaster{AsyncConfigProp: parent}
1504 if decoder.Length() < 4 {
1505 return nil, fmt.Errorf("AsyncConfigPropPacketInMaster packet too short: %d < 4", decoder.Length())
1506 }
1507 _asyncconfigproppacketinmaster.Mask = uint32(decoder.ReadUint32())
1508 return _asyncconfigproppacketinmaster, nil
1509}
1510
1511func NewAsyncConfigPropPacketInMaster() *AsyncConfigPropPacketInMaster {
1512 obj := &AsyncConfigPropPacketInMaster{
1513 AsyncConfigProp: NewAsyncConfigProp(1),
1514 }
1515 return obj
1516}
1517
1518type AsyncConfigPropPacketInSlave struct {
1519 *AsyncConfigProp
1520 Mask uint32
1521}
1522
1523type IAsyncConfigPropPacketInSlave interface {
1524 IAsyncConfigProp
1525 GetMask() uint32
1526}
1527
1528func (self *AsyncConfigPropPacketInSlave) GetMask() uint32 {
1529 return self.Mask
1530}
1531
1532func (self *AsyncConfigPropPacketInSlave) SetMask(v uint32) {
1533 self.Mask = v
1534}
1535
1536func (self *AsyncConfigPropPacketInSlave) Serialize(encoder *goloxi.Encoder) error {
1537 startIndex := len(encoder.Bytes())
1538 if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
1539 return err
1540 }
1541
1542 encoder.PutUint32(uint32(self.Mask))
1543 length := len(encoder.Bytes()) - startIndex
1544
1545 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1546
1547 return nil
1548}
1549
1550func DecodeAsyncConfigPropPacketInSlave(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropPacketInSlave, error) {
1551 _asyncconfigproppacketinslave := &AsyncConfigPropPacketInSlave{AsyncConfigProp: parent}
1552 if decoder.Length() < 4 {
1553 return nil, fmt.Errorf("AsyncConfigPropPacketInSlave packet too short: %d < 4", decoder.Length())
1554 }
1555 _asyncconfigproppacketinslave.Mask = uint32(decoder.ReadUint32())
1556 return _asyncconfigproppacketinslave, nil
1557}
1558
1559func NewAsyncConfigPropPacketInSlave() *AsyncConfigPropPacketInSlave {
1560 obj := &AsyncConfigPropPacketInSlave{
1561 AsyncConfigProp: NewAsyncConfigProp(0),
1562 }
1563 return obj
1564}
1565
1566type AsyncConfigPropPortStatusMaster struct {
1567 *AsyncConfigProp
1568 Mask uint32
1569}
1570
1571type IAsyncConfigPropPortStatusMaster interface {
1572 IAsyncConfigProp
1573 GetMask() uint32
1574}
1575
1576func (self *AsyncConfigPropPortStatusMaster) GetMask() uint32 {
1577 return self.Mask
1578}
1579
1580func (self *AsyncConfigPropPortStatusMaster) SetMask(v uint32) {
1581 self.Mask = v
1582}
1583
1584func (self *AsyncConfigPropPortStatusMaster) Serialize(encoder *goloxi.Encoder) error {
1585 startIndex := len(encoder.Bytes())
1586 if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
1587 return err
1588 }
1589
1590 encoder.PutUint32(uint32(self.Mask))
1591 length := len(encoder.Bytes()) - startIndex
1592
1593 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1594
1595 return nil
1596}
1597
1598func DecodeAsyncConfigPropPortStatusMaster(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropPortStatusMaster, error) {
1599 _asyncconfigpropportstatusmaster := &AsyncConfigPropPortStatusMaster{AsyncConfigProp: parent}
1600 if decoder.Length() < 4 {
1601 return nil, fmt.Errorf("AsyncConfigPropPortStatusMaster packet too short: %d < 4", decoder.Length())
1602 }
1603 _asyncconfigpropportstatusmaster.Mask = uint32(decoder.ReadUint32())
1604 return _asyncconfigpropportstatusmaster, nil
1605}
1606
1607func NewAsyncConfigPropPortStatusMaster() *AsyncConfigPropPortStatusMaster {
1608 obj := &AsyncConfigPropPortStatusMaster{
1609 AsyncConfigProp: NewAsyncConfigProp(3),
1610 }
1611 return obj
1612}
1613
1614type AsyncConfigPropPortStatusSlave struct {
1615 *AsyncConfigProp
1616 Mask uint32
1617}
1618
1619type IAsyncConfigPropPortStatusSlave interface {
1620 IAsyncConfigProp
1621 GetMask() uint32
1622}
1623
1624func (self *AsyncConfigPropPortStatusSlave) GetMask() uint32 {
1625 return self.Mask
1626}
1627
1628func (self *AsyncConfigPropPortStatusSlave) SetMask(v uint32) {
1629 self.Mask = v
1630}
1631
1632func (self *AsyncConfigPropPortStatusSlave) Serialize(encoder *goloxi.Encoder) error {
1633 startIndex := len(encoder.Bytes())
1634 if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
1635 return err
1636 }
1637
1638 encoder.PutUint32(uint32(self.Mask))
1639 length := len(encoder.Bytes()) - startIndex
1640
1641 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1642
1643 return nil
1644}
1645
1646func DecodeAsyncConfigPropPortStatusSlave(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropPortStatusSlave, error) {
1647 _asyncconfigpropportstatusslave := &AsyncConfigPropPortStatusSlave{AsyncConfigProp: parent}
1648 if decoder.Length() < 4 {
1649 return nil, fmt.Errorf("AsyncConfigPropPortStatusSlave packet too short: %d < 4", decoder.Length())
1650 }
1651 _asyncconfigpropportstatusslave.Mask = uint32(decoder.ReadUint32())
1652 return _asyncconfigpropportstatusslave, nil
1653}
1654
1655func NewAsyncConfigPropPortStatusSlave() *AsyncConfigPropPortStatusSlave {
1656 obj := &AsyncConfigPropPortStatusSlave{
1657 AsyncConfigProp: NewAsyncConfigProp(2),
1658 }
1659 return obj
1660}
1661
1662type AsyncConfigPropRequestforwardMaster struct {
1663 *AsyncConfigProp
1664 Mask uint32
1665}
1666
1667type IAsyncConfigPropRequestforwardMaster interface {
1668 IAsyncConfigProp
1669 GetMask() uint32
1670}
1671
1672func (self *AsyncConfigPropRequestforwardMaster) GetMask() uint32 {
1673 return self.Mask
1674}
1675
1676func (self *AsyncConfigPropRequestforwardMaster) SetMask(v uint32) {
1677 self.Mask = v
1678}
1679
1680func (self *AsyncConfigPropRequestforwardMaster) Serialize(encoder *goloxi.Encoder) error {
1681 startIndex := len(encoder.Bytes())
1682 if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
1683 return err
1684 }
1685
1686 encoder.PutUint32(uint32(self.Mask))
1687 length := len(encoder.Bytes()) - startIndex
1688
1689 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1690
1691 return nil
1692}
1693
1694func DecodeAsyncConfigPropRequestforwardMaster(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropRequestforwardMaster, error) {
1695 _asyncconfigproprequestforwardmaster := &AsyncConfigPropRequestforwardMaster{AsyncConfigProp: parent}
1696 if decoder.Length() < 4 {
1697 return nil, fmt.Errorf("AsyncConfigPropRequestforwardMaster packet too short: %d < 4", decoder.Length())
1698 }
1699 _asyncconfigproprequestforwardmaster.Mask = uint32(decoder.ReadUint32())
1700 return _asyncconfigproprequestforwardmaster, nil
1701}
1702
1703func NewAsyncConfigPropRequestforwardMaster() *AsyncConfigPropRequestforwardMaster {
1704 obj := &AsyncConfigPropRequestforwardMaster{
1705 AsyncConfigProp: NewAsyncConfigProp(11),
1706 }
1707 return obj
1708}
1709
1710type AsyncConfigPropRequestforwardSlave struct {
1711 *AsyncConfigProp
1712 Mask uint32
1713}
1714
1715type IAsyncConfigPropRequestforwardSlave interface {
1716 IAsyncConfigProp
1717 GetMask() uint32
1718}
1719
1720func (self *AsyncConfigPropRequestforwardSlave) GetMask() uint32 {
1721 return self.Mask
1722}
1723
1724func (self *AsyncConfigPropRequestforwardSlave) SetMask(v uint32) {
1725 self.Mask = v
1726}
1727
1728func (self *AsyncConfigPropRequestforwardSlave) Serialize(encoder *goloxi.Encoder) error {
1729 startIndex := len(encoder.Bytes())
1730 if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
1731 return err
1732 }
1733
1734 encoder.PutUint32(uint32(self.Mask))
1735 length := len(encoder.Bytes()) - startIndex
1736
1737 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1738
1739 return nil
1740}
1741
1742func DecodeAsyncConfigPropRequestforwardSlave(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropRequestforwardSlave, error) {
1743 _asyncconfigproprequestforwardslave := &AsyncConfigPropRequestforwardSlave{AsyncConfigProp: parent}
1744 if decoder.Length() < 4 {
1745 return nil, fmt.Errorf("AsyncConfigPropRequestforwardSlave packet too short: %d < 4", decoder.Length())
1746 }
1747 _asyncconfigproprequestforwardslave.Mask = uint32(decoder.ReadUint32())
1748 return _asyncconfigproprequestforwardslave, nil
1749}
1750
1751func NewAsyncConfigPropRequestforwardSlave() *AsyncConfigPropRequestforwardSlave {
1752 obj := &AsyncConfigPropRequestforwardSlave{
1753 AsyncConfigProp: NewAsyncConfigProp(10),
1754 }
1755 return obj
1756}
1757
1758type AsyncConfigPropRoleStatusMaster struct {
1759 *AsyncConfigProp
1760 Mask uint32
1761}
1762
1763type IAsyncConfigPropRoleStatusMaster interface {
1764 IAsyncConfigProp
1765 GetMask() uint32
1766}
1767
1768func (self *AsyncConfigPropRoleStatusMaster) GetMask() uint32 {
1769 return self.Mask
1770}
1771
1772func (self *AsyncConfigPropRoleStatusMaster) SetMask(v uint32) {
1773 self.Mask = v
1774}
1775
1776func (self *AsyncConfigPropRoleStatusMaster) Serialize(encoder *goloxi.Encoder) error {
1777 startIndex := len(encoder.Bytes())
1778 if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
1779 return err
1780 }
1781
1782 encoder.PutUint32(uint32(self.Mask))
1783 length := len(encoder.Bytes()) - startIndex
1784
1785 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1786
1787 return nil
1788}
1789
1790func DecodeAsyncConfigPropRoleStatusMaster(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropRoleStatusMaster, error) {
1791 _asyncconfigproprolestatusmaster := &AsyncConfigPropRoleStatusMaster{AsyncConfigProp: parent}
1792 if decoder.Length() < 4 {
1793 return nil, fmt.Errorf("AsyncConfigPropRoleStatusMaster packet too short: %d < 4", decoder.Length())
1794 }
1795 _asyncconfigproprolestatusmaster.Mask = uint32(decoder.ReadUint32())
1796 return _asyncconfigproprolestatusmaster, nil
1797}
1798
1799func NewAsyncConfigPropRoleStatusMaster() *AsyncConfigPropRoleStatusMaster {
1800 obj := &AsyncConfigPropRoleStatusMaster{
1801 AsyncConfigProp: NewAsyncConfigProp(7),
1802 }
1803 return obj
1804}
1805
1806type AsyncConfigPropRoleStatusSlave struct {
1807 *AsyncConfigProp
1808 Mask uint32
1809}
1810
1811type IAsyncConfigPropRoleStatusSlave interface {
1812 IAsyncConfigProp
1813 GetMask() uint32
1814}
1815
1816func (self *AsyncConfigPropRoleStatusSlave) GetMask() uint32 {
1817 return self.Mask
1818}
1819
1820func (self *AsyncConfigPropRoleStatusSlave) SetMask(v uint32) {
1821 self.Mask = v
1822}
1823
1824func (self *AsyncConfigPropRoleStatusSlave) Serialize(encoder *goloxi.Encoder) error {
1825 startIndex := len(encoder.Bytes())
1826 if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
1827 return err
1828 }
1829
1830 encoder.PutUint32(uint32(self.Mask))
1831 length := len(encoder.Bytes()) - startIndex
1832
1833 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1834
1835 return nil
1836}
1837
1838func DecodeAsyncConfigPropRoleStatusSlave(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropRoleStatusSlave, error) {
1839 _asyncconfigproprolestatusslave := &AsyncConfigPropRoleStatusSlave{AsyncConfigProp: parent}
1840 if decoder.Length() < 4 {
1841 return nil, fmt.Errorf("AsyncConfigPropRoleStatusSlave packet too short: %d < 4", decoder.Length())
1842 }
1843 _asyncconfigproprolestatusslave.Mask = uint32(decoder.ReadUint32())
1844 return _asyncconfigproprolestatusslave, nil
1845}
1846
1847func NewAsyncConfigPropRoleStatusSlave() *AsyncConfigPropRoleStatusSlave {
1848 obj := &AsyncConfigPropRoleStatusSlave{
1849 AsyncConfigProp: NewAsyncConfigProp(6),
1850 }
1851 return obj
1852}
1853
1854type AsyncConfigPropTableStatusMaster struct {
1855 *AsyncConfigProp
1856 Mask uint32
1857}
1858
1859type IAsyncConfigPropTableStatusMaster interface {
1860 IAsyncConfigProp
1861 GetMask() uint32
1862}
1863
1864func (self *AsyncConfigPropTableStatusMaster) GetMask() uint32 {
1865 return self.Mask
1866}
1867
1868func (self *AsyncConfigPropTableStatusMaster) SetMask(v uint32) {
1869 self.Mask = v
1870}
1871
1872func (self *AsyncConfigPropTableStatusMaster) Serialize(encoder *goloxi.Encoder) error {
1873 startIndex := len(encoder.Bytes())
1874 if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
1875 return err
1876 }
1877
1878 encoder.PutUint32(uint32(self.Mask))
1879 length := len(encoder.Bytes()) - startIndex
1880
1881 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1882
1883 return nil
1884}
1885
1886func DecodeAsyncConfigPropTableStatusMaster(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropTableStatusMaster, error) {
1887 _asyncconfigproptablestatusmaster := &AsyncConfigPropTableStatusMaster{AsyncConfigProp: parent}
1888 if decoder.Length() < 4 {
1889 return nil, fmt.Errorf("AsyncConfigPropTableStatusMaster packet too short: %d < 4", decoder.Length())
1890 }
1891 _asyncconfigproptablestatusmaster.Mask = uint32(decoder.ReadUint32())
1892 return _asyncconfigproptablestatusmaster, nil
1893}
1894
1895func NewAsyncConfigPropTableStatusMaster() *AsyncConfigPropTableStatusMaster {
1896 obj := &AsyncConfigPropTableStatusMaster{
1897 AsyncConfigProp: NewAsyncConfigProp(9),
1898 }
1899 return obj
1900}
1901
1902type AsyncConfigPropTableStatusSlave struct {
1903 *AsyncConfigProp
1904 Mask uint32
1905}
1906
1907type IAsyncConfigPropTableStatusSlave interface {
1908 IAsyncConfigProp
1909 GetMask() uint32
1910}
1911
1912func (self *AsyncConfigPropTableStatusSlave) GetMask() uint32 {
1913 return self.Mask
1914}
1915
1916func (self *AsyncConfigPropTableStatusSlave) SetMask(v uint32) {
1917 self.Mask = v
1918}
1919
1920func (self *AsyncConfigPropTableStatusSlave) Serialize(encoder *goloxi.Encoder) error {
1921 startIndex := len(encoder.Bytes())
1922 if err := self.AsyncConfigProp.Serialize(encoder); err != nil {
1923 return err
1924 }
1925
1926 encoder.PutUint32(uint32(self.Mask))
1927 length := len(encoder.Bytes()) - startIndex
1928
1929 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1930
1931 return nil
1932}
1933
1934func DecodeAsyncConfigPropTableStatusSlave(parent *AsyncConfigProp, decoder *goloxi.Decoder) (*AsyncConfigPropTableStatusSlave, error) {
1935 _asyncconfigproptablestatusslave := &AsyncConfigPropTableStatusSlave{AsyncConfigProp: parent}
1936 if decoder.Length() < 4 {
1937 return nil, fmt.Errorf("AsyncConfigPropTableStatusSlave packet too short: %d < 4", decoder.Length())
1938 }
1939 _asyncconfigproptablestatusslave.Mask = uint32(decoder.ReadUint32())
1940 return _asyncconfigproptablestatusslave, nil
1941}
1942
1943func NewAsyncConfigPropTableStatusSlave() *AsyncConfigPropTableStatusSlave {
1944 obj := &AsyncConfigPropTableStatusSlave{
1945 AsyncConfigProp: NewAsyncConfigProp(8),
1946 }
1947 return obj
1948}
1949
1950type BsnControllerConnection struct {
1951 State BsnControllerConnectionState
1952 AuxiliaryId uint8
1953 Role ControllerRole
1954 Uri string
1955}
1956
1957type IBsnControllerConnection interface {
1958 goloxi.Serializable
1959 GetState() BsnControllerConnectionState
1960 GetAuxiliaryId() uint8
1961 GetRole() ControllerRole
1962 GetUri() string
1963}
1964
1965func (self *BsnControllerConnection) GetState() BsnControllerConnectionState {
1966 return self.State
1967}
1968
1969func (self *BsnControllerConnection) SetState(v BsnControllerConnectionState) {
1970 self.State = v
1971}
1972
1973func (self *BsnControllerConnection) GetAuxiliaryId() uint8 {
1974 return self.AuxiliaryId
1975}
1976
1977func (self *BsnControllerConnection) SetAuxiliaryId(v uint8) {
1978 self.AuxiliaryId = v
1979}
1980
1981func (self *BsnControllerConnection) GetRole() ControllerRole {
1982 return self.Role
1983}
1984
1985func (self *BsnControllerConnection) SetRole(v ControllerRole) {
1986 self.Role = v
1987}
1988
1989func (self *BsnControllerConnection) GetUri() string {
1990 return self.Uri
1991}
1992
1993func (self *BsnControllerConnection) SetUri(v string) {
1994 self.Uri = v
1995}
1996
1997func (self *BsnControllerConnection) Serialize(encoder *goloxi.Encoder) error {
1998
1999 encoder.PutUint8(uint8(self.State))
2000 encoder.PutUint8(uint8(self.AuxiliaryId))
2001 encoder.Write(bytes.Repeat([]byte{0}, 2))
2002 encoder.PutUint32(uint32(self.Role))
2003 encoder.Write([]byte(self.Uri))
2004
2005 return nil
2006}
2007
2008func DecodeBsnControllerConnection(decoder *goloxi.Decoder) (*BsnControllerConnection, error) {
2009 _bsncontrollerconnection := &BsnControllerConnection{}
2010 if decoder.Length() < 264 {
2011 return nil, fmt.Errorf("BsnControllerConnection packet too short: %d < 264", decoder.Length())
2012 }
2013 _bsncontrollerconnection.State = BsnControllerConnectionState(decoder.ReadByte())
2014 _bsncontrollerconnection.AuxiliaryId = uint8(decoder.ReadByte())
2015 decoder.Skip(2)
2016 _bsncontrollerconnection.Role = ControllerRole(decoder.ReadUint32())
2017 _bsncontrollerconnection.Uri = string(bytes.Trim(decoder.Read(256), "\x00"))
2018 return _bsncontrollerconnection, nil
2019}
2020
2021func NewBsnControllerConnection() *BsnControllerConnection {
2022 obj := &BsnControllerConnection{}
2023 return obj
2024}
2025
2026type BsnDebugCounterDescStatsEntry struct {
2027 CounterId uint64
2028 Name string
2029 Description string
2030}
2031
2032type IBsnDebugCounterDescStatsEntry interface {
2033 goloxi.Serializable
2034 GetCounterId() uint64
2035 GetName() string
2036 GetDescription() string
2037}
2038
2039func (self *BsnDebugCounterDescStatsEntry) GetCounterId() uint64 {
2040 return self.CounterId
2041}
2042
2043func (self *BsnDebugCounterDescStatsEntry) SetCounterId(v uint64) {
2044 self.CounterId = v
2045}
2046
2047func (self *BsnDebugCounterDescStatsEntry) GetName() string {
2048 return self.Name
2049}
2050
2051func (self *BsnDebugCounterDescStatsEntry) SetName(v string) {
2052 self.Name = v
2053}
2054
2055func (self *BsnDebugCounterDescStatsEntry) GetDescription() string {
2056 return self.Description
2057}
2058
2059func (self *BsnDebugCounterDescStatsEntry) SetDescription(v string) {
2060 self.Description = v
2061}
2062
2063func (self *BsnDebugCounterDescStatsEntry) Serialize(encoder *goloxi.Encoder) error {
2064
2065 encoder.PutUint64(uint64(self.CounterId))
2066 encoder.Write([]byte(self.Name))
2067 encoder.Write([]byte(self.Description))
2068
2069 return nil
2070}
2071
2072func DecodeBsnDebugCounterDescStatsEntry(decoder *goloxi.Decoder) (*BsnDebugCounterDescStatsEntry, error) {
2073 _bsndebugcounterdescstatsentry := &BsnDebugCounterDescStatsEntry{}
2074 if decoder.Length() < 328 {
2075 return nil, fmt.Errorf("BsnDebugCounterDescStatsEntry packet too short: %d < 328", decoder.Length())
2076 }
2077 _bsndebugcounterdescstatsentry.CounterId = uint64(decoder.ReadUint64())
2078 _bsndebugcounterdescstatsentry.Name = string(bytes.Trim(decoder.Read(64), "\x00"))
2079 _bsndebugcounterdescstatsentry.Description = string(bytes.Trim(decoder.Read(256), "\x00"))
2080 return _bsndebugcounterdescstatsentry, nil
2081}
2082
2083func NewBsnDebugCounterDescStatsEntry() *BsnDebugCounterDescStatsEntry {
2084 obj := &BsnDebugCounterDescStatsEntry{}
2085 return obj
2086}
2087
2088type BsnDebugCounterStatsEntry struct {
2089 CounterId uint64
2090 Value uint64
2091}
2092
2093type IBsnDebugCounterStatsEntry interface {
2094 goloxi.Serializable
2095 GetCounterId() uint64
2096 GetValue() uint64
2097}
2098
2099func (self *BsnDebugCounterStatsEntry) GetCounterId() uint64 {
2100 return self.CounterId
2101}
2102
2103func (self *BsnDebugCounterStatsEntry) SetCounterId(v uint64) {
2104 self.CounterId = v
2105}
2106
2107func (self *BsnDebugCounterStatsEntry) GetValue() uint64 {
2108 return self.Value
2109}
2110
2111func (self *BsnDebugCounterStatsEntry) SetValue(v uint64) {
2112 self.Value = v
2113}
2114
2115func (self *BsnDebugCounterStatsEntry) Serialize(encoder *goloxi.Encoder) error {
2116
2117 encoder.PutUint64(uint64(self.CounterId))
2118 encoder.PutUint64(uint64(self.Value))
2119
2120 return nil
2121}
2122
2123func DecodeBsnDebugCounterStatsEntry(decoder *goloxi.Decoder) (*BsnDebugCounterStatsEntry, error) {
2124 _bsndebugcounterstatsentry := &BsnDebugCounterStatsEntry{}
2125 if decoder.Length() < 16 {
2126 return nil, fmt.Errorf("BsnDebugCounterStatsEntry packet too short: %d < 16", decoder.Length())
2127 }
2128 _bsndebugcounterstatsentry.CounterId = uint64(decoder.ReadUint64())
2129 _bsndebugcounterstatsentry.Value = uint64(decoder.ReadUint64())
2130 return _bsndebugcounterstatsentry, nil
2131}
2132
2133func NewBsnDebugCounterStatsEntry() *BsnDebugCounterStatsEntry {
2134 obj := &BsnDebugCounterStatsEntry{}
2135 return obj
2136}
2137
2138type BsnFlowChecksumBucketStatsEntry struct {
2139 Checksum uint64
2140}
2141
2142type IBsnFlowChecksumBucketStatsEntry interface {
2143 goloxi.Serializable
2144 GetChecksum() uint64
2145}
2146
2147func (self *BsnFlowChecksumBucketStatsEntry) GetChecksum() uint64 {
2148 return self.Checksum
2149}
2150
2151func (self *BsnFlowChecksumBucketStatsEntry) SetChecksum(v uint64) {
2152 self.Checksum = v
2153}
2154
2155func (self *BsnFlowChecksumBucketStatsEntry) Serialize(encoder *goloxi.Encoder) error {
2156
2157 encoder.PutUint64(uint64(self.Checksum))
2158
2159 return nil
2160}
2161
2162func DecodeBsnFlowChecksumBucketStatsEntry(decoder *goloxi.Decoder) (*BsnFlowChecksumBucketStatsEntry, error) {
2163 _bsnflowchecksumbucketstatsentry := &BsnFlowChecksumBucketStatsEntry{}
2164 if decoder.Length() < 8 {
2165 return nil, fmt.Errorf("BsnFlowChecksumBucketStatsEntry packet too short: %d < 8", decoder.Length())
2166 }
2167 _bsnflowchecksumbucketstatsentry.Checksum = uint64(decoder.ReadUint64())
2168 return _bsnflowchecksumbucketstatsentry, nil
2169}
2170
2171func NewBsnFlowChecksumBucketStatsEntry() *BsnFlowChecksumBucketStatsEntry {
2172 obj := &BsnFlowChecksumBucketStatsEntry{}
2173 return obj
2174}
2175
2176type BsnGenericStatsEntry struct {
2177 Length uint16
2178 Tlvs []IBsnTlv
2179}
2180
2181type IBsnGenericStatsEntry interface {
2182 goloxi.Serializable
2183 GetLength() uint16
2184 GetTlvs() []IBsnTlv
2185}
2186
2187func (self *BsnGenericStatsEntry) GetLength() uint16 {
2188 return self.Length
2189}
2190
2191func (self *BsnGenericStatsEntry) SetLength(v uint16) {
2192 self.Length = v
2193}
2194
2195func (self *BsnGenericStatsEntry) GetTlvs() []IBsnTlv {
2196 return self.Tlvs
2197}
2198
2199func (self *BsnGenericStatsEntry) SetTlvs(v []IBsnTlv) {
2200 self.Tlvs = v
2201}
2202
2203func (self *BsnGenericStatsEntry) Serialize(encoder *goloxi.Encoder) error {
2204 startIndex := len(encoder.Bytes())
2205
2206 encoder.PutUint16(uint16(self.Length))
2207 for _, obj := range self.Tlvs {
2208 if err := obj.Serialize(encoder); err != nil {
2209 return err
2210 }
2211 }
2212 length := len(encoder.Bytes()) - startIndex
2213
2214 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
2215
2216 return nil
2217}
2218
2219func DecodeBsnGenericStatsEntry(decoder *goloxi.Decoder) (*BsnGenericStatsEntry, error) {
2220 _bsngenericstatsentry := &BsnGenericStatsEntry{}
2221 if decoder.Length() < 2 {
2222 return nil, fmt.Errorf("BsnGenericStatsEntry packet too short: %d < 2", decoder.Length())
2223 }
2224 _bsngenericstatsentry.Length = uint16(decoder.ReadUint16())
2225 oldDecoder := decoder
2226 defer func() { decoder = oldDecoder }()
2227 decoder = decoder.SliceDecoder(int(_bsngenericstatsentry.Length), 2+0)
2228
2229 for decoder.Length() >= 4 {
2230 item, err := DecodeBsnTlv(decoder)
2231 if err != nil {
2232 return nil, err
2233 }
2234 if item != nil {
2235 _bsngenericstatsentry.Tlvs = append(_bsngenericstatsentry.Tlvs, item)
2236 }
2237 }
2238 return _bsngenericstatsentry, nil
2239}
2240
2241func NewBsnGenericStatsEntry() *BsnGenericStatsEntry {
2242 obj := &BsnGenericStatsEntry{}
2243 return obj
2244}
2245
2246type BsnGentableBucketStatsEntry struct {
2247 Checksum Checksum128
2248}
2249
2250type IBsnGentableBucketStatsEntry interface {
2251 goloxi.Serializable
2252 GetChecksum() Checksum128
2253}
2254
2255func (self *BsnGentableBucketStatsEntry) GetChecksum() Checksum128 {
2256 return self.Checksum
2257}
2258
2259func (self *BsnGentableBucketStatsEntry) SetChecksum(v Checksum128) {
2260 self.Checksum = v
2261}
2262
2263func (self *BsnGentableBucketStatsEntry) Serialize(encoder *goloxi.Encoder) error {
2264
2265 self.Checksum.Serialize(encoder)
2266
2267 return nil
2268}
2269
2270func DecodeBsnGentableBucketStatsEntry(decoder *goloxi.Decoder) (*BsnGentableBucketStatsEntry, error) {
2271 _bsngentablebucketstatsentry := &BsnGentableBucketStatsEntry{}
2272 if decoder.Length() < 16 {
2273 return nil, fmt.Errorf("BsnGentableBucketStatsEntry packet too short: %d < 16", decoder.Length())
2274 }
2275 _bsngentablebucketstatsentry.Checksum.Decode(decoder)
2276 return _bsngentablebucketstatsentry, nil
2277}
2278
2279func NewBsnGentableBucketStatsEntry() *BsnGentableBucketStatsEntry {
2280 obj := &BsnGentableBucketStatsEntry{}
2281 return obj
2282}
2283
2284type BsnGentableDescStatsEntry struct {
2285 Length uint16
2286 TableId uint16
2287 Name string
2288 BucketsSize uint32
2289 MaxEntries uint32
2290}
2291
2292type IBsnGentableDescStatsEntry interface {
2293 goloxi.Serializable
2294 GetLength() uint16
2295 GetTableId() uint16
2296 GetName() string
2297 GetBucketsSize() uint32
2298 GetMaxEntries() uint32
2299}
2300
2301func (self *BsnGentableDescStatsEntry) GetLength() uint16 {
2302 return self.Length
2303}
2304
2305func (self *BsnGentableDescStatsEntry) SetLength(v uint16) {
2306 self.Length = v
2307}
2308
2309func (self *BsnGentableDescStatsEntry) GetTableId() uint16 {
2310 return self.TableId
2311}
2312
2313func (self *BsnGentableDescStatsEntry) SetTableId(v uint16) {
2314 self.TableId = v
2315}
2316
2317func (self *BsnGentableDescStatsEntry) GetName() string {
2318 return self.Name
2319}
2320
2321func (self *BsnGentableDescStatsEntry) SetName(v string) {
2322 self.Name = v
2323}
2324
2325func (self *BsnGentableDescStatsEntry) GetBucketsSize() uint32 {
2326 return self.BucketsSize
2327}
2328
2329func (self *BsnGentableDescStatsEntry) SetBucketsSize(v uint32) {
2330 self.BucketsSize = v
2331}
2332
2333func (self *BsnGentableDescStatsEntry) GetMaxEntries() uint32 {
2334 return self.MaxEntries
2335}
2336
2337func (self *BsnGentableDescStatsEntry) SetMaxEntries(v uint32) {
2338 self.MaxEntries = v
2339}
2340
2341func (self *BsnGentableDescStatsEntry) Serialize(encoder *goloxi.Encoder) error {
2342 startIndex := len(encoder.Bytes())
2343
2344 encoder.PutUint16(uint16(self.Length))
2345 encoder.PutUint16(uint16(self.TableId))
2346 encoder.Write([]byte(self.Name))
2347 encoder.PutUint32(uint32(self.BucketsSize))
2348 encoder.PutUint32(uint32(self.MaxEntries))
2349 encoder.Write(bytes.Repeat([]byte{0}, 4))
2350 length := len(encoder.Bytes()) - startIndex
2351
2352 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
2353
2354 return nil
2355}
2356
2357func DecodeBsnGentableDescStatsEntry(decoder *goloxi.Decoder) (*BsnGentableDescStatsEntry, error) {
2358 _bsngentabledescstatsentry := &BsnGentableDescStatsEntry{}
2359 if decoder.Length() < 48 {
2360 return nil, fmt.Errorf("BsnGentableDescStatsEntry packet too short: %d < 48", decoder.Length())
2361 }
2362 _bsngentabledescstatsentry.Length = uint16(decoder.ReadUint16())
2363 oldDecoder := decoder
2364 defer func() { decoder = oldDecoder }()
2365 decoder = decoder.SliceDecoder(int(_bsngentabledescstatsentry.Length), 2+0)
2366 _bsngentabledescstatsentry.TableId = uint16(decoder.ReadUint16())
2367 _bsngentabledescstatsentry.Name = string(bytes.Trim(decoder.Read(32), "\x00"))
2368 _bsngentabledescstatsentry.BucketsSize = uint32(decoder.ReadUint32())
2369 _bsngentabledescstatsentry.MaxEntries = uint32(decoder.ReadUint32())
2370 decoder.Skip(4)
2371 return _bsngentabledescstatsentry, nil
2372}
2373
2374func NewBsnGentableDescStatsEntry() *BsnGentableDescStatsEntry {
2375 obj := &BsnGentableDescStatsEntry{}
2376 return obj
2377}
2378
2379type BsnGentableEntryDescStatsEntry struct {
2380 Length uint16
2381 KeyLength uint16
2382 Checksum Checksum128
2383 Key []IBsnTlv
2384 Value []IBsnTlv
2385}
2386
2387type IBsnGentableEntryDescStatsEntry interface {
2388 goloxi.Serializable
2389 GetLength() uint16
2390 GetKeyLength() uint16
2391 GetChecksum() Checksum128
2392 GetKey() []IBsnTlv
2393 GetValue() []IBsnTlv
2394}
2395
2396func (self *BsnGentableEntryDescStatsEntry) GetLength() uint16 {
2397 return self.Length
2398}
2399
2400func (self *BsnGentableEntryDescStatsEntry) SetLength(v uint16) {
2401 self.Length = v
2402}
2403
2404func (self *BsnGentableEntryDescStatsEntry) GetKeyLength() uint16 {
2405 return self.KeyLength
2406}
2407
2408func (self *BsnGentableEntryDescStatsEntry) SetKeyLength(v uint16) {
2409 self.KeyLength = v
2410}
2411
2412func (self *BsnGentableEntryDescStatsEntry) GetChecksum() Checksum128 {
2413 return self.Checksum
2414}
2415
2416func (self *BsnGentableEntryDescStatsEntry) SetChecksum(v Checksum128) {
2417 self.Checksum = v
2418}
2419
2420func (self *BsnGentableEntryDescStatsEntry) GetKey() []IBsnTlv {
2421 return self.Key
2422}
2423
2424func (self *BsnGentableEntryDescStatsEntry) SetKey(v []IBsnTlv) {
2425 self.Key = v
2426}
2427
2428func (self *BsnGentableEntryDescStatsEntry) GetValue() []IBsnTlv {
2429 return self.Value
2430}
2431
2432func (self *BsnGentableEntryDescStatsEntry) SetValue(v []IBsnTlv) {
2433 self.Value = v
2434}
2435
2436func (self *BsnGentableEntryDescStatsEntry) Serialize(encoder *goloxi.Encoder) error {
2437 startIndex := len(encoder.Bytes())
2438
2439 encoder.PutUint16(uint16(self.Length))
2440 encoder.PutUint16(uint16(self.KeyLength))
2441 self.Checksum.Serialize(encoder)
2442 for _, obj := range self.Key {
2443 if err := obj.Serialize(encoder); err != nil {
2444 return err
2445 }
2446 }
2447 for _, obj := range self.Value {
2448 if err := obj.Serialize(encoder); err != nil {
2449 return err
2450 }
2451 }
2452 length := len(encoder.Bytes()) - startIndex
2453
2454 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
2455
2456 return nil
2457}
2458
2459func DecodeBsnGentableEntryDescStatsEntry(decoder *goloxi.Decoder) (*BsnGentableEntryDescStatsEntry, error) {
2460 _bsngentableentrydescstatsentry := &BsnGentableEntryDescStatsEntry{}
2461 if decoder.Length() < 20 {
2462 return nil, fmt.Errorf("BsnGentableEntryDescStatsEntry packet too short: %d < 20", decoder.Length())
2463 }
2464 _bsngentableentrydescstatsentry.Length = uint16(decoder.ReadUint16())
2465 oldDecoder := decoder
2466 defer func() { decoder = oldDecoder }()
2467 decoder = decoder.SliceDecoder(int(_bsngentableentrydescstatsentry.Length), 2+0)
2468 _bsngentableentrydescstatsentry.KeyLength = uint16(decoder.ReadUint16())
2469 _bsngentableentrydescstatsentry.Checksum.Decode(decoder)
2470
2471 end := decoder.Offset() + int(_bsngentableentrydescstatsentry.KeyLength)
2472 for decoder.Offset() < end {
2473 item, err := DecodeBsnTlv(decoder)
2474 if err != nil {
2475 return nil, err
2476 }
2477 if item != nil {
2478 _bsngentableentrydescstatsentry.Key = append(_bsngentableentrydescstatsentry.Key, item)
2479 }
2480 }
2481
2482 for decoder.Length() >= 4 {
2483 item, err := DecodeBsnTlv(decoder)
2484 if err != nil {
2485 return nil, err
2486 }
2487 if item != nil {
2488 _bsngentableentrydescstatsentry.Value = append(_bsngentableentrydescstatsentry.Value, item)
2489 }
2490 }
2491 return _bsngentableentrydescstatsentry, nil
2492}
2493
2494func NewBsnGentableEntryDescStatsEntry() *BsnGentableEntryDescStatsEntry {
2495 obj := &BsnGentableEntryDescStatsEntry{}
2496 return obj
2497}
2498
2499type BsnGentableEntryStatsEntry struct {
2500 Length uint16
2501 KeyLength uint16
2502 Key []IBsnTlv
2503 Stats []IBsnTlv
2504}
2505
2506type IBsnGentableEntryStatsEntry interface {
2507 goloxi.Serializable
2508 GetLength() uint16
2509 GetKeyLength() uint16
2510 GetKey() []IBsnTlv
2511 GetStats() []IBsnTlv
2512}
2513
2514func (self *BsnGentableEntryStatsEntry) GetLength() uint16 {
2515 return self.Length
2516}
2517
2518func (self *BsnGentableEntryStatsEntry) SetLength(v uint16) {
2519 self.Length = v
2520}
2521
2522func (self *BsnGentableEntryStatsEntry) GetKeyLength() uint16 {
2523 return self.KeyLength
2524}
2525
2526func (self *BsnGentableEntryStatsEntry) SetKeyLength(v uint16) {
2527 self.KeyLength = v
2528}
2529
2530func (self *BsnGentableEntryStatsEntry) GetKey() []IBsnTlv {
2531 return self.Key
2532}
2533
2534func (self *BsnGentableEntryStatsEntry) SetKey(v []IBsnTlv) {
2535 self.Key = v
2536}
2537
2538func (self *BsnGentableEntryStatsEntry) GetStats() []IBsnTlv {
2539 return self.Stats
2540}
2541
2542func (self *BsnGentableEntryStatsEntry) SetStats(v []IBsnTlv) {
2543 self.Stats = v
2544}
2545
2546func (self *BsnGentableEntryStatsEntry) Serialize(encoder *goloxi.Encoder) error {
2547 startIndex := len(encoder.Bytes())
2548
2549 encoder.PutUint16(uint16(self.Length))
2550 encoder.PutUint16(uint16(self.KeyLength))
2551 for _, obj := range self.Key {
2552 if err := obj.Serialize(encoder); err != nil {
2553 return err
2554 }
2555 }
2556 for _, obj := range self.Stats {
2557 if err := obj.Serialize(encoder); err != nil {
2558 return err
2559 }
2560 }
2561 length := len(encoder.Bytes()) - startIndex
2562
2563 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
2564
2565 return nil
2566}
2567
2568func DecodeBsnGentableEntryStatsEntry(decoder *goloxi.Decoder) (*BsnGentableEntryStatsEntry, error) {
2569 _bsngentableentrystatsentry := &BsnGentableEntryStatsEntry{}
2570 if decoder.Length() < 4 {
2571 return nil, fmt.Errorf("BsnGentableEntryStatsEntry packet too short: %d < 4", decoder.Length())
2572 }
2573 _bsngentableentrystatsentry.Length = uint16(decoder.ReadUint16())
2574 oldDecoder := decoder
2575 defer func() { decoder = oldDecoder }()
2576 decoder = decoder.SliceDecoder(int(_bsngentableentrystatsentry.Length), 2+0)
2577 _bsngentableentrystatsentry.KeyLength = uint16(decoder.ReadUint16())
2578
2579 end := decoder.Offset() + int(_bsngentableentrystatsentry.KeyLength)
2580 for decoder.Offset() < end {
2581 item, err := DecodeBsnTlv(decoder)
2582 if err != nil {
2583 return nil, err
2584 }
2585 if item != nil {
2586 _bsngentableentrystatsentry.Key = append(_bsngentableentrystatsentry.Key, item)
2587 }
2588 }
2589
2590 for decoder.Length() >= 4 {
2591 item, err := DecodeBsnTlv(decoder)
2592 if err != nil {
2593 return nil, err
2594 }
2595 if item != nil {
2596 _bsngentableentrystatsentry.Stats = append(_bsngentableentrystatsentry.Stats, item)
2597 }
2598 }
2599 return _bsngentableentrystatsentry, nil
2600}
2601
2602func NewBsnGentableEntryStatsEntry() *BsnGentableEntryStatsEntry {
2603 obj := &BsnGentableEntryStatsEntry{}
2604 return obj
2605}
2606
2607type BsnGentableStatsEntry struct {
2608 TableId uint16
2609 EntryCount uint32
2610 Checksum Checksum128
2611}
2612
2613type IBsnGentableStatsEntry interface {
2614 goloxi.Serializable
2615 GetTableId() uint16
2616 GetEntryCount() uint32
2617 GetChecksum() Checksum128
2618}
2619
2620func (self *BsnGentableStatsEntry) GetTableId() uint16 {
2621 return self.TableId
2622}
2623
2624func (self *BsnGentableStatsEntry) SetTableId(v uint16) {
2625 self.TableId = v
2626}
2627
2628func (self *BsnGentableStatsEntry) GetEntryCount() uint32 {
2629 return self.EntryCount
2630}
2631
2632func (self *BsnGentableStatsEntry) SetEntryCount(v uint32) {
2633 self.EntryCount = v
2634}
2635
2636func (self *BsnGentableStatsEntry) GetChecksum() Checksum128 {
2637 return self.Checksum
2638}
2639
2640func (self *BsnGentableStatsEntry) SetChecksum(v Checksum128) {
2641 self.Checksum = v
2642}
2643
2644func (self *BsnGentableStatsEntry) Serialize(encoder *goloxi.Encoder) error {
2645
2646 encoder.PutUint16(uint16(self.TableId))
2647 encoder.Write(bytes.Repeat([]byte{0}, 2))
2648 encoder.PutUint32(uint32(self.EntryCount))
2649 self.Checksum.Serialize(encoder)
2650
2651 return nil
2652}
2653
2654func DecodeBsnGentableStatsEntry(decoder *goloxi.Decoder) (*BsnGentableStatsEntry, error) {
2655 _bsngentablestatsentry := &BsnGentableStatsEntry{}
2656 if decoder.Length() < 24 {
2657 return nil, fmt.Errorf("BsnGentableStatsEntry packet too short: %d < 24", decoder.Length())
2658 }
2659 _bsngentablestatsentry.TableId = uint16(decoder.ReadUint16())
2660 decoder.Skip(2)
2661 _bsngentablestatsentry.EntryCount = uint32(decoder.ReadUint32())
2662 _bsngentablestatsentry.Checksum.Decode(decoder)
2663 return _bsngentablestatsentry, nil
2664}
2665
2666func NewBsnGentableStatsEntry() *BsnGentableStatsEntry {
2667 obj := &BsnGentableStatsEntry{}
2668 return obj
2669}
2670
2671type BsnInterface struct {
2672 HwAddr net.HardwareAddr
2673 Name string
2674 Ipv4Addr net.IP
2675 Ipv4Netmask net.IP
2676}
2677
2678type IBsnInterface interface {
2679 goloxi.Serializable
2680 GetHwAddr() net.HardwareAddr
2681 GetName() string
2682 GetIpv4Addr() net.IP
2683 GetIpv4Netmask() net.IP
2684}
2685
2686func (self *BsnInterface) GetHwAddr() net.HardwareAddr {
2687 return self.HwAddr
2688}
2689
2690func (self *BsnInterface) SetHwAddr(v net.HardwareAddr) {
2691 self.HwAddr = v
2692}
2693
2694func (self *BsnInterface) GetName() string {
2695 return self.Name
2696}
2697
2698func (self *BsnInterface) SetName(v string) {
2699 self.Name = v
2700}
2701
2702func (self *BsnInterface) GetIpv4Addr() net.IP {
2703 return self.Ipv4Addr
2704}
2705
2706func (self *BsnInterface) SetIpv4Addr(v net.IP) {
2707 self.Ipv4Addr = v
2708}
2709
2710func (self *BsnInterface) GetIpv4Netmask() net.IP {
2711 return self.Ipv4Netmask
2712}
2713
2714func (self *BsnInterface) SetIpv4Netmask(v net.IP) {
2715 self.Ipv4Netmask = v
2716}
2717
2718func (self *BsnInterface) Serialize(encoder *goloxi.Encoder) error {
2719
2720 encoder.Write(self.HwAddr)
2721 encoder.Write(bytes.Repeat([]byte{0}, 2))
2722 encoder.Write([]byte(self.Name))
2723 encoder.Write(self.Ipv4Addr.To4())
2724 encoder.Write(self.Ipv4Netmask.To4())
2725
2726 return nil
2727}
2728
2729func DecodeBsnInterface(decoder *goloxi.Decoder) (*BsnInterface, error) {
2730 _bsninterface := &BsnInterface{}
2731 if decoder.Length() < 32 {
2732 return nil, fmt.Errorf("BsnInterface packet too short: %d < 32", decoder.Length())
2733 }
2734 _bsninterface.HwAddr = net.HardwareAddr(decoder.Read(6))
2735 decoder.Skip(2)
2736 _bsninterface.Name = string(bytes.Trim(decoder.Read(16), "\x00"))
2737 _bsninterface.Ipv4Addr = net.IP(decoder.Read(4))
2738 _bsninterface.Ipv4Netmask = net.IP(decoder.Read(4))
2739 return _bsninterface, nil
2740}
2741
2742func NewBsnInterface() *BsnInterface {
2743 obj := &BsnInterface{}
2744 return obj
2745}
2746
2747type BsnLacpStatsEntry struct {
2748 PortNo Port
2749 ActorSysPriority uint16
2750 ActorSysMac net.HardwareAddr
2751 ActorPortPriority uint16
2752 ActorPortNum uint16
2753 ActorKey uint16
2754 ConvergenceStatus uint8
2755 PartnerSysPriority uint16
2756 PartnerSysMac net.HardwareAddr
2757 PartnerPortPriority uint16
2758 PartnerPortNum uint16
2759 PartnerKey uint16
2760}
2761
2762type IBsnLacpStatsEntry interface {
2763 goloxi.Serializable
2764 GetPortNo() Port
2765 GetActorSysPriority() uint16
2766 GetActorSysMac() net.HardwareAddr
2767 GetActorPortPriority() uint16
2768 GetActorPortNum() uint16
2769 GetActorKey() uint16
2770 GetConvergenceStatus() uint8
2771 GetPartnerSysPriority() uint16
2772 GetPartnerSysMac() net.HardwareAddr
2773 GetPartnerPortPriority() uint16
2774 GetPartnerPortNum() uint16
2775 GetPartnerKey() uint16
2776}
2777
2778func (self *BsnLacpStatsEntry) GetPortNo() Port {
2779 return self.PortNo
2780}
2781
2782func (self *BsnLacpStatsEntry) SetPortNo(v Port) {
2783 self.PortNo = v
2784}
2785
2786func (self *BsnLacpStatsEntry) GetActorSysPriority() uint16 {
2787 return self.ActorSysPriority
2788}
2789
2790func (self *BsnLacpStatsEntry) SetActorSysPriority(v uint16) {
2791 self.ActorSysPriority = v
2792}
2793
2794func (self *BsnLacpStatsEntry) GetActorSysMac() net.HardwareAddr {
2795 return self.ActorSysMac
2796}
2797
2798func (self *BsnLacpStatsEntry) SetActorSysMac(v net.HardwareAddr) {
2799 self.ActorSysMac = v
2800}
2801
2802func (self *BsnLacpStatsEntry) GetActorPortPriority() uint16 {
2803 return self.ActorPortPriority
2804}
2805
2806func (self *BsnLacpStatsEntry) SetActorPortPriority(v uint16) {
2807 self.ActorPortPriority = v
2808}
2809
2810func (self *BsnLacpStatsEntry) GetActorPortNum() uint16 {
2811 return self.ActorPortNum
2812}
2813
2814func (self *BsnLacpStatsEntry) SetActorPortNum(v uint16) {
2815 self.ActorPortNum = v
2816}
2817
2818func (self *BsnLacpStatsEntry) GetActorKey() uint16 {
2819 return self.ActorKey
2820}
2821
2822func (self *BsnLacpStatsEntry) SetActorKey(v uint16) {
2823 self.ActorKey = v
2824}
2825
2826func (self *BsnLacpStatsEntry) GetConvergenceStatus() uint8 {
2827 return self.ConvergenceStatus
2828}
2829
2830func (self *BsnLacpStatsEntry) SetConvergenceStatus(v uint8) {
2831 self.ConvergenceStatus = v
2832}
2833
2834func (self *BsnLacpStatsEntry) GetPartnerSysPriority() uint16 {
2835 return self.PartnerSysPriority
2836}
2837
2838func (self *BsnLacpStatsEntry) SetPartnerSysPriority(v uint16) {
2839 self.PartnerSysPriority = v
2840}
2841
2842func (self *BsnLacpStatsEntry) GetPartnerSysMac() net.HardwareAddr {
2843 return self.PartnerSysMac
2844}
2845
2846func (self *BsnLacpStatsEntry) SetPartnerSysMac(v net.HardwareAddr) {
2847 self.PartnerSysMac = v
2848}
2849
2850func (self *BsnLacpStatsEntry) GetPartnerPortPriority() uint16 {
2851 return self.PartnerPortPriority
2852}
2853
2854func (self *BsnLacpStatsEntry) SetPartnerPortPriority(v uint16) {
2855 self.PartnerPortPriority = v
2856}
2857
2858func (self *BsnLacpStatsEntry) GetPartnerPortNum() uint16 {
2859 return self.PartnerPortNum
2860}
2861
2862func (self *BsnLacpStatsEntry) SetPartnerPortNum(v uint16) {
2863 self.PartnerPortNum = v
2864}
2865
2866func (self *BsnLacpStatsEntry) GetPartnerKey() uint16 {
2867 return self.PartnerKey
2868}
2869
2870func (self *BsnLacpStatsEntry) SetPartnerKey(v uint16) {
2871 self.PartnerKey = v
2872}
2873
2874func (self *BsnLacpStatsEntry) Serialize(encoder *goloxi.Encoder) error {
2875
2876 self.PortNo.Serialize(encoder)
2877 encoder.PutUint16(uint16(self.ActorSysPriority))
2878 encoder.Write(self.ActorSysMac)
2879 encoder.PutUint16(uint16(self.ActorPortPriority))
2880 encoder.PutUint16(uint16(self.ActorPortNum))
2881 encoder.PutUint16(uint16(self.ActorKey))
2882 encoder.PutUint8(uint8(self.ConvergenceStatus))
2883 encoder.Write(bytes.Repeat([]byte{0}, 1))
2884 encoder.PutUint16(uint16(self.PartnerSysPriority))
2885 encoder.Write(self.PartnerSysMac)
2886 encoder.PutUint16(uint16(self.PartnerPortPriority))
2887 encoder.PutUint16(uint16(self.PartnerPortNum))
2888 encoder.PutUint16(uint16(self.PartnerKey))
2889 encoder.Write(bytes.Repeat([]byte{0}, 2))
2890
2891 return nil
2892}
2893
2894func DecodeBsnLacpStatsEntry(decoder *goloxi.Decoder) (*BsnLacpStatsEntry, error) {
2895 _bsnlacpstatsentry := &BsnLacpStatsEntry{}
2896 if decoder.Length() < 36 {
2897 return nil, fmt.Errorf("BsnLacpStatsEntry packet too short: %d < 36", decoder.Length())
2898 }
2899 _bsnlacpstatsentry.PortNo.Decode(decoder)
2900 _bsnlacpstatsentry.ActorSysPriority = uint16(decoder.ReadUint16())
2901 _bsnlacpstatsentry.ActorSysMac = net.HardwareAddr(decoder.Read(6))
2902 _bsnlacpstatsentry.ActorPortPriority = uint16(decoder.ReadUint16())
2903 _bsnlacpstatsentry.ActorPortNum = uint16(decoder.ReadUint16())
2904 _bsnlacpstatsentry.ActorKey = uint16(decoder.ReadUint16())
2905 _bsnlacpstatsentry.ConvergenceStatus = uint8(decoder.ReadByte())
2906 decoder.Skip(1)
2907 _bsnlacpstatsentry.PartnerSysPriority = uint16(decoder.ReadUint16())
2908 _bsnlacpstatsentry.PartnerSysMac = net.HardwareAddr(decoder.Read(6))
2909 _bsnlacpstatsentry.PartnerPortPriority = uint16(decoder.ReadUint16())
2910 _bsnlacpstatsentry.PartnerPortNum = uint16(decoder.ReadUint16())
2911 _bsnlacpstatsentry.PartnerKey = uint16(decoder.ReadUint16())
2912 decoder.Skip(2)
2913 return _bsnlacpstatsentry, nil
2914}
2915
2916func NewBsnLacpStatsEntry() *BsnLacpStatsEntry {
2917 obj := &BsnLacpStatsEntry{}
2918 return obj
2919}
2920
2921type BsnPortCounterStatsEntry struct {
2922 Length uint16
2923 PortNo Port
2924 Values []*Uint64
2925}
2926
2927type IBsnPortCounterStatsEntry interface {
2928 goloxi.Serializable
2929 GetLength() uint16
2930 GetPortNo() Port
2931 GetValues() []*Uint64
2932}
2933
2934func (self *BsnPortCounterStatsEntry) GetLength() uint16 {
2935 return self.Length
2936}
2937
2938func (self *BsnPortCounterStatsEntry) SetLength(v uint16) {
2939 self.Length = v
2940}
2941
2942func (self *BsnPortCounterStatsEntry) GetPortNo() Port {
2943 return self.PortNo
2944}
2945
2946func (self *BsnPortCounterStatsEntry) SetPortNo(v Port) {
2947 self.PortNo = v
2948}
2949
2950func (self *BsnPortCounterStatsEntry) GetValues() []*Uint64 {
2951 return self.Values
2952}
2953
2954func (self *BsnPortCounterStatsEntry) SetValues(v []*Uint64) {
2955 self.Values = v
2956}
2957
2958func (self *BsnPortCounterStatsEntry) Serialize(encoder *goloxi.Encoder) error {
2959 startIndex := len(encoder.Bytes())
2960
2961 encoder.PutUint16(uint16(self.Length))
2962 encoder.Write(bytes.Repeat([]byte{0}, 2))
2963 self.PortNo.Serialize(encoder)
2964 for _, obj := range self.Values {
2965 if err := obj.Serialize(encoder); err != nil {
2966 return err
2967 }
2968 }
2969 length := len(encoder.Bytes()) - startIndex
2970
2971 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
2972
2973 return nil
2974}
2975
2976func DecodeBsnPortCounterStatsEntry(decoder *goloxi.Decoder) (*BsnPortCounterStatsEntry, error) {
2977 _bsnportcounterstatsentry := &BsnPortCounterStatsEntry{}
2978 if decoder.Length() < 8 {
2979 return nil, fmt.Errorf("BsnPortCounterStatsEntry packet too short: %d < 8", decoder.Length())
2980 }
2981 _bsnportcounterstatsentry.Length = uint16(decoder.ReadUint16())
2982 oldDecoder := decoder
2983 defer func() { decoder = oldDecoder }()
2984 decoder = decoder.SliceDecoder(int(_bsnportcounterstatsentry.Length), 2+0)
2985 decoder.Skip(2)
2986 _bsnportcounterstatsentry.PortNo.Decode(decoder)
2987
2988 for decoder.Length() >= 8 {
2989 item, err := DecodeUint64(decoder)
2990 if err != nil {
2991 return nil, err
2992 }
2993 if item != nil {
2994 _bsnportcounterstatsentry.Values = append(_bsnportcounterstatsentry.Values, item)
2995 }
2996 }
2997 return _bsnportcounterstatsentry, nil
2998}
2999
3000func NewBsnPortCounterStatsEntry() *BsnPortCounterStatsEntry {
3001 obj := &BsnPortCounterStatsEntry{}
3002 return obj
3003}
3004
3005type BsnSwitchPipelineStatsEntry struct {
3006 Pipeline string
3007}
3008
3009type IBsnSwitchPipelineStatsEntry interface {
3010 goloxi.Serializable
3011 GetPipeline() string
3012}
3013
3014func (self *BsnSwitchPipelineStatsEntry) GetPipeline() string {
3015 return self.Pipeline
3016}
3017
3018func (self *BsnSwitchPipelineStatsEntry) SetPipeline(v string) {
3019 self.Pipeline = v
3020}
3021
3022func (self *BsnSwitchPipelineStatsEntry) Serialize(encoder *goloxi.Encoder) error {
3023
3024 encoder.Write([]byte(self.Pipeline))
3025
3026 return nil
3027}
3028
3029func DecodeBsnSwitchPipelineStatsEntry(decoder *goloxi.Decoder) (*BsnSwitchPipelineStatsEntry, error) {
3030 _bsnswitchpipelinestatsentry := &BsnSwitchPipelineStatsEntry{}
3031 if decoder.Length() < 256 {
3032 return nil, fmt.Errorf("BsnSwitchPipelineStatsEntry packet too short: %d < 256", decoder.Length())
3033 }
3034 _bsnswitchpipelinestatsentry.Pipeline = string(bytes.Trim(decoder.Read(256), "\x00"))
3035 return _bsnswitchpipelinestatsentry, nil
3036}
3037
3038func NewBsnSwitchPipelineStatsEntry() *BsnSwitchPipelineStatsEntry {
3039 obj := &BsnSwitchPipelineStatsEntry{}
3040 return obj
3041}
3042
3043type BsnTableChecksumStatsEntry struct {
3044 TableId uint8
3045 Checksum uint64
3046}
3047
3048type IBsnTableChecksumStatsEntry interface {
3049 goloxi.Serializable
3050 GetTableId() uint8
3051 GetChecksum() uint64
3052}
3053
3054func (self *BsnTableChecksumStatsEntry) GetTableId() uint8 {
3055 return self.TableId
3056}
3057
3058func (self *BsnTableChecksumStatsEntry) SetTableId(v uint8) {
3059 self.TableId = v
3060}
3061
3062func (self *BsnTableChecksumStatsEntry) GetChecksum() uint64 {
3063 return self.Checksum
3064}
3065
3066func (self *BsnTableChecksumStatsEntry) SetChecksum(v uint64) {
3067 self.Checksum = v
3068}
3069
3070func (self *BsnTableChecksumStatsEntry) Serialize(encoder *goloxi.Encoder) error {
3071
3072 encoder.PutUint8(uint8(self.TableId))
3073 encoder.PutUint64(uint64(self.Checksum))
3074
3075 return nil
3076}
3077
3078func DecodeBsnTableChecksumStatsEntry(decoder *goloxi.Decoder) (*BsnTableChecksumStatsEntry, error) {
3079 _bsntablechecksumstatsentry := &BsnTableChecksumStatsEntry{}
3080 if decoder.Length() < 9 {
3081 return nil, fmt.Errorf("BsnTableChecksumStatsEntry packet too short: %d < 9", decoder.Length())
3082 }
3083 _bsntablechecksumstatsentry.TableId = uint8(decoder.ReadByte())
3084 _bsntablechecksumstatsentry.Checksum = uint64(decoder.ReadUint64())
3085 return _bsntablechecksumstatsentry, nil
3086}
3087
3088func NewBsnTableChecksumStatsEntry() *BsnTableChecksumStatsEntry {
3089 obj := &BsnTableChecksumStatsEntry{}
3090 return obj
3091}
3092
3093type BsnTlv struct {
3094 Type uint16
3095 Length uint16
3096}
3097
3098type IBsnTlv interface {
3099 goloxi.Serializable
3100 GetType() uint16
3101 GetLength() uint16
3102}
3103
3104func (self *BsnTlv) GetType() uint16 {
3105 return self.Type
3106}
3107
3108func (self *BsnTlv) SetType(v uint16) {
3109 self.Type = v
3110}
3111
3112func (self *BsnTlv) GetLength() uint16 {
3113 return self.Length
3114}
3115
3116func (self *BsnTlv) SetLength(v uint16) {
3117 self.Length = v
3118}
3119
3120func (self *BsnTlv) Serialize(encoder *goloxi.Encoder) error {
3121
3122 encoder.PutUint16(uint16(self.Type))
3123 encoder.PutUint16(uint16(self.Length))
3124
3125 return nil
3126}
3127
3128func DecodeBsnTlv(decoder *goloxi.Decoder) (IBsnTlv, error) {
3129 _bsntlv := &BsnTlv{}
3130 if decoder.Length() < 4 {
3131 return nil, fmt.Errorf("BsnTlv packet too short: %d < 4", decoder.Length())
3132 }
3133 _bsntlv.Type = uint16(decoder.ReadUint16())
3134 _bsntlv.Length = uint16(decoder.ReadUint16())
3135 oldDecoder := decoder
3136 defer func() { decoder = oldDecoder }()
3137 decoder = decoder.SliceDecoder(int(_bsntlv.Length), 2+2)
3138
3139 switch _bsntlv.Type {
3140 case 0:
3141 return DecodeBsnTlvPort(_bsntlv, decoder)
3142 case 1:
3143 return DecodeBsnTlvMac(_bsntlv, decoder)
3144 case 2:
3145 return DecodeBsnTlvRxPackets(_bsntlv, decoder)
3146 case 3:
3147 return DecodeBsnTlvTxPackets(_bsntlv, decoder)
3148 case 4:
3149 return DecodeBsnTlvIpv4(_bsntlv, decoder)
3150 case 5:
3151 return DecodeBsnTlvIdleTime(_bsntlv, decoder)
3152 case 6:
3153 return DecodeBsnTlvVlanVid(_bsntlv, decoder)
3154 case 7:
3155 return DecodeBsnTlvIdleNotification(_bsntlv, decoder)
3156 case 8:
3157 return DecodeBsnTlvIdleTimeout(_bsntlv, decoder)
3158 case 9:
3159 return DecodeBsnTlvUnicastQueryTimeout(_bsntlv, decoder)
3160 case 10:
3161 return DecodeBsnTlvBroadcastQueryTimeout(_bsntlv, decoder)
3162 case 11:
3163 return DecodeBsnTlvRequestPackets(_bsntlv, decoder)
3164 case 12:
3165 return DecodeBsnTlvReplyPackets(_bsntlv, decoder)
3166 case 13:
3167 return DecodeBsnTlvMissPackets(_bsntlv, decoder)
3168 case 14:
3169 return DecodeBsnTlvCircuitId(_bsntlv, decoder)
3170 case 15:
3171 return DecodeBsnTlvUdfId(_bsntlv, decoder)
3172 case 16:
3173 return DecodeBsnTlvUdfAnchor(_bsntlv, decoder)
3174 case 17:
3175 return DecodeBsnTlvUdfOffset(_bsntlv, decoder)
3176 case 18:
3177 return DecodeBsnTlvUdfLength(_bsntlv, decoder)
3178 case 19:
3179 return DecodeBsnTlvVrf(_bsntlv, decoder)
3180 case 20:
3181 return DecodeBsnTlvQueueId(_bsntlv, decoder)
3182 case 21:
3183 return DecodeBsnTlvQueueWeight(_bsntlv, decoder)
3184 case 22:
3185 return DecodeBsnTlvCrcEnabled(_bsntlv, decoder)
3186 case 23:
3187 return DecodeBsnTlvExternalIp(_bsntlv, decoder)
3188 case 24:
3189 return DecodeBsnTlvExternalMac(_bsntlv, decoder)
3190 case 25:
3191 return DecodeBsnTlvExternalNetmask(_bsntlv, decoder)
3192 case 26:
3193 return DecodeBsnTlvExternalGatewayIp(_bsntlv, decoder)
3194 case 27:
3195 return DecodeBsnTlvInternalMac(_bsntlv, decoder)
3196 case 28:
3197 return DecodeBsnTlvInternalGatewayMac(_bsntlv, decoder)
3198 case 29:
3199 return DecodeBsnTlvExternalGatewayMac(_bsntlv, decoder)
3200 case 30:
3201 return DecodeBsnTlvSamplingRate(_bsntlv, decoder)
3202 case 31:
3203 return DecodeBsnTlvHeaderSize(_bsntlv, decoder)
3204 case 32:
3205 return DecodeBsnTlvEthSrc(_bsntlv, decoder)
3206 case 33:
3207 return DecodeBsnTlvEthDst(_bsntlv, decoder)
3208 case 34:
3209 return DecodeBsnTlvIpv4Src(_bsntlv, decoder)
3210 case 35:
3211 return DecodeBsnTlvIpv4Dst(_bsntlv, decoder)
3212 case 36:
3213 return DecodeBsnTlvUdpSrc(_bsntlv, decoder)
3214 case 37:
3215 return DecodeBsnTlvUdpDst(_bsntlv, decoder)
3216 case 38:
3217 return DecodeBsnTlvSubAgentId(_bsntlv, decoder)
3218 case 39:
3219 return DecodeBsnTlvTxBytes(_bsntlv, decoder)
3220 case 40:
3221 return DecodeBsnTlvActorSystemPriority(_bsntlv, decoder)
3222 case 41:
3223 return DecodeBsnTlvActorSystemMac(_bsntlv, decoder)
3224 case 42:
3225 return DecodeBsnTlvActorPortPriority(_bsntlv, decoder)
3226 case 43:
3227 return DecodeBsnTlvActorPortNum(_bsntlv, decoder)
3228 case 44:
3229 return DecodeBsnTlvActorKey(_bsntlv, decoder)
3230 case 45:
3231 return DecodeBsnTlvConvergenceStatus(_bsntlv, decoder)
3232 case 47:
3233 return DecodeBsnTlvPartnerSystemPriority(_bsntlv, decoder)
3234 case 48:
3235 return DecodeBsnTlvPartnerSystemMac(_bsntlv, decoder)
3236 case 49:
3237 return DecodeBsnTlvPartnerPortPriority(_bsntlv, decoder)
3238 case 50:
3239 return DecodeBsnTlvPartnerPortNum(_bsntlv, decoder)
3240 case 51:
3241 return DecodeBsnTlvPartnerKey(_bsntlv, decoder)
3242 case 52:
3243 return DecodeBsnTlvName(_bsntlv, decoder)
3244 case 53:
3245 return DecodeBsnTlvActorState(_bsntlv, decoder)
3246 case 54:
3247 return DecodeBsnTlvPartnerState(_bsntlv, decoder)
3248 case 55:
3249 return DecodeBsnTlvData(_bsntlv, decoder)
3250 case 56:
3251 return DecodeBsnTlvMacMask(_bsntlv, decoder)
3252 case 57:
3253 return DecodeBsnTlvPriority(_bsntlv, decoder)
3254 case 58:
3255 return DecodeBsnTlvInterval(_bsntlv, decoder)
3256 case 59:
3257 return DecodeBsnTlvReference(_bsntlv, decoder)
3258 case 60:
3259 return DecodeBsnTlvIpv4Netmask(_bsntlv, decoder)
3260 case 61:
3261 return DecodeBsnTlvMplsLabel(_bsntlv, decoder)
3262 case 62:
3263 return DecodeBsnTlvMplsControlWord(_bsntlv, decoder)
3264 case 63:
3265 return DecodeBsnTlvMplsSequenced(_bsntlv, decoder)
3266 case 64:
3267 return DecodeBsnTlvBucket(_bsntlv, decoder)
3268 case 65:
3269 return DecodeBsnTlvTcpSrc(_bsntlv, decoder)
3270 case 66:
3271 return DecodeBsnTlvTcpDst(_bsntlv, decoder)
3272 case 67:
3273 return DecodeBsnTlvIpProto(_bsntlv, decoder)
3274 case 68:
3275 return DecodeBsnTlvIcmpType(_bsntlv, decoder)
3276 case 69:
3277 return DecodeBsnTlvIcmpCode(_bsntlv, decoder)
3278 case 70:
3279 return DecodeBsnTlvIcmpId(_bsntlv, decoder)
3280 case 71:
3281 return DecodeBsnTlvRxBytes(_bsntlv, decoder)
3282 case 72:
3283 return DecodeBsnTlvVlanPcp(_bsntlv, decoder)
3284 case 73:
3285 return DecodeBsnTlvStripVlanOnEgress(_bsntlv, decoder)
3286 case 74:
3287 return DecodeBsnTlvSetLoopbackMode(_bsntlv, decoder)
3288 case 75:
3289 return DecodeBsnTlvStripMplsL2OnIngress(_bsntlv, decoder)
3290 case 76:
3291 return DecodeBsnTlvStripMplsL3OnIngress(_bsntlv, decoder)
3292 case 77:
3293 return DecodeBsnTlvVlanVidMask(_bsntlv, decoder)
3294 case 78:
3295 return DecodeBsnTlvIgmpSnooping(_bsntlv, decoder)
3296 case 79:
3297 return DecodeBsnTlvL2MulticastLookup(_bsntlv, decoder)
3298 case 80:
3299 return DecodeBsnTlvGenerationId(_bsntlv, decoder)
3300 case 81:
3301 return DecodeBsnTlvAnchor(_bsntlv, decoder)
3302 case 82:
3303 return DecodeBsnTlvOffset(_bsntlv, decoder)
3304 case 83:
3305 return DecodeBsnTlvNegate(_bsntlv, decoder)
3306 case 84:
3307 return DecodeBsnTlvIpv6(_bsntlv, decoder)
3308 case 85:
3309 return DecodeBsnTlvDecap(_bsntlv, decoder)
3310 case 86:
3311 return DecodeBsnTlvVni(_bsntlv, decoder)
3312 case 87:
3313 return DecodeBsnTlvMcgTypeVxlan(_bsntlv, decoder)
3314 case 88:
3315 return DecodeBsnTlvPortVxlanMode(_bsntlv, decoder)
3316 case 89:
3317 return DecodeBsnTlvRateUnit(_bsntlv, decoder)
3318 case 90:
3319 return DecodeBsnTlvBroadcastRate(_bsntlv, decoder)
3320 case 91:
3321 return DecodeBsnTlvKnownMulticastRate(_bsntlv, decoder)
3322 case 92:
3323 return DecodeBsnTlvUnknownMulticastRate(_bsntlv, decoder)
3324 case 93:
3325 return DecodeBsnTlvUnicastRate(_bsntlv, decoder)
3326 case 94:
3327 return DecodeBsnTlvNexthopTypeVxlan(_bsntlv, decoder)
3328 case 95:
3329 return DecodeBsnTlvMulticastInterfaceId(_bsntlv, decoder)
3330 case 96:
3331 return DecodeBsnTlvUsePacketState(_bsntlv, decoder)
3332 case 97:
3333 return DecodeBsnTlvStatus(_bsntlv, decoder)
3334 case 98:
3335 return DecodeBsnTlvVlanMacList(_bsntlv, decoder)
3336 case 99:
3337 return DecodeBsnTlvVfi(_bsntlv, decoder)
3338 case 100:
3339 return DecodeBsnTlvHashSeed(_bsntlv, decoder)
3340 case 101:
3341 return DecodeBsnTlvHashType(_bsntlv, decoder)
3342 case 102:
3343 return DecodeBsnTlvHashPacketType(_bsntlv, decoder)
3344 case 103:
3345 return DecodeBsnTlvHashPacketField(_bsntlv, decoder)
3346 case 104:
3347 return DecodeBsnTlvHashGtpHeaderMatch(_bsntlv, decoder)
3348 case 105:
3349 return DecodeBsnTlvHashGtpPortMatch(_bsntlv, decoder)
3350 case 106:
3351 return DecodeBsnTlvUntagged(_bsntlv, decoder)
3352 case 107:
3353 return DecodeBsnTlvVfpClassId(_bsntlv, decoder)
3354 case 108:
3355 return DecodeBsnTlvQosPriority(_bsntlv, decoder)
3356 case 109:
3357 return DecodeBsnTlvParentPort(_bsntlv, decoder)
3358 case 110:
3359 return DecodeBsnTlvLoopbackPort(_bsntlv, decoder)
3360 case 111:
3361 return DecodeBsnTlvVpnKey(_bsntlv, decoder)
3362 case 112:
3363 return DecodeBsnTlvDscp(_bsntlv, decoder)
3364 case 113:
3365 return DecodeBsnTlvTtl(_bsntlv, decoder)
3366 case 114:
3367 return DecodeBsnTlvNextHopMac(_bsntlv, decoder)
3368 case 115:
3369 return DecodeBsnTlvNextHopIpv4(_bsntlv, decoder)
3370 case 116:
3371 return DecodeBsnTlvRateLimit(_bsntlv, decoder)
3372 case 117:
3373 return DecodeBsnTlvVxlanEgressLag(_bsntlv, decoder)
3374 case 118:
3375 return DecodeBsnTlvCpuLag(_bsntlv, decoder)
3376 case 119:
3377 return DecodeBsnTlvUint64List(_bsntlv, decoder)
3378 case 120:
3379 return DecodeBsnTlvDisableSrcMacCheck(_bsntlv, decoder)
3380 case 121:
3381 return DecodeBsnTlvDrop(_bsntlv, decoder)
3382 case 122:
3383 return DecodeBsnTlvIpv6Prefix(_bsntlv, decoder)
3384 case 123:
3385 return DecodeBsnTlvNdpOffload(_bsntlv, decoder)
3386 case 124:
3387 return DecodeBsnTlvNdpStatic(_bsntlv, decoder)
3388 case 125:
3389 return DecodeBsnTlvIcmpv6Chksum(_bsntlv, decoder)
3390 case 126:
3391 return DecodeBsnTlvIpv6Src(_bsntlv, decoder)
3392 case 127:
3393 return DecodeBsnTlvIpv6Dst(_bsntlv, decoder)
3394 case 128:
3395 return DecodeBsnTlvPushVlanOnIngress(_bsntlv, decoder)
3396 case 129:
3397 return DecodeBsnTlvApplyPackets(_bsntlv, decoder)
3398 case 130:
3399 return DecodeBsnTlvApplyBytes(_bsntlv, decoder)
3400 case 131:
3401 return DecodeBsnTlvEthType(_bsntlv, decoder)
3402 case 132:
3403 return DecodeBsnTlvEcn(_bsntlv, decoder)
3404 case 133:
3405 return DecodeBsnTlvTcpFlags(_bsntlv, decoder)
3406 case 134:
3407 return DecodeBsnTlvL3InterfaceClassId(_bsntlv, decoder)
3408 case 135:
3409 return DecodeBsnTlvL3SrcClassId(_bsntlv, decoder)
3410 case 136:
3411 return DecodeBsnTlvL3DstClassId(_bsntlv, decoder)
3412 case 137:
3413 return DecodeBsnTlvEgressOnly(_bsntlv, decoder)
3414 case 138:
3415 return DecodeBsnTlvIngressPortGroupId(_bsntlv, decoder)
3416 case 139:
3417 return DecodeBsnTlvEgressPortGroupId(_bsntlv, decoder)
3418 case 140:
3419 return DecodeBsnTlvDataMask(_bsntlv, decoder)
3420 case 141:
3421 return DecodeBsnTlvPortUsage(_bsntlv, decoder)
3422 case 142:
3423 return DecodeBsnTlvTunnelCapability(_bsntlv, decoder)
3424 case 143:
3425 return DecodeBsnTlvEnhancedHashCapability(_bsntlv, decoder)
3426 case 144:
3427 return DecodeBsnTlvAutoNegotiation(_bsntlv, decoder)
3428 case 145:
3429 return DecodeBsnTlvHashAlgorithm(_bsntlv, decoder)
3430 case 146:
3431 return DecodeBsnTlvLoopbackMode(_bsntlv, decoder)
3432 case 147:
3433 return DecodeBsnTlvNoArpResponse(_bsntlv, decoder)
3434 case 148:
3435 return DecodeBsnTlvNoNsResponse(_bsntlv, decoder)
3436 case 149:
3437 return DecodeBsnTlvForwardErrorCorrection(_bsntlv, decoder)
3438 case 150:
3439 return DecodeBsnTlvOpticsAlwaysEnabled(_bsntlv, decoder)
3440 case 151:
3441 return DecodeBsnTlvForceLinkUp(_bsntlv, decoder)
3442 case 152:
3443 return DecodeBsnTlvRestServer(_bsntlv, decoder)
3444 case 153:
3445 return DecodeBsnTlvUriScheme(_bsntlv, decoder)
3446 case 154:
3447 return DecodeBsnTlvTimestamp(_bsntlv, decoder)
3448 case 155:
3449 return DecodeBsnTlvRecordPackets(_bsntlv, decoder)
3450 case 156:
3451 return DecodeBsnTlvPortSpeedGbps(_bsntlv, decoder)
3452 case 157:
3453 return DecodeBsnTlvOuterSrcMac(_bsntlv, decoder)
3454 case 158:
3455 return DecodeBsnTlvVirtual(_bsntlv, decoder)
3456 case 159:
3457 return DecodeBsnTlvPduaRxInstance(_bsntlv, decoder)
3458 case 160:
3459 return DecodeBsnTlvLagOptions(_bsntlv, decoder)
3460 case 161:
3461 return DecodeBsnTlvRoutingParam(_bsntlv, decoder)
3462 case 162:
3463 return DecodeBsnTlvPushVlanOnEgress(_bsntlv, decoder)
3464 case 163:
3465 return DecodeBsnTlvFlood(_bsntlv, decoder)
3466 case 164:
3467 return DecodeBsnTlvUpgrade(_bsntlv, decoder)
3468 case 165:
3469 return DecodeBsnTlvFabricPortRole(_bsntlv, decoder)
3470 case 166:
3471 return DecodeBsnTlvUserConfigured(_bsntlv, decoder)
3472 case 167:
3473 return DecodeBsnTlvUint32(_bsntlv, decoder)
3474 case 168:
3475 return DecodeBsnTlvL3(_bsntlv, decoder)
3476 case 169:
3477 return DecodeBsnTlvIpTunnelType(_bsntlv, decoder)
3478 case 170:
3479 return DecodeBsnTlvMulticastPacket(_bsntlv, decoder)
3480 case 171:
3481 return DecodeBsnTlvPimDr(_bsntlv, decoder)
3482 case 172:
3483 return DecodeBsnTlvPassive(_bsntlv, decoder)
3484 case 173:
3485 return DecodeBsnTlvIdentifier(_bsntlv, decoder)
3486 case 174:
3487 return DecodeBsnTlvMultiplier(_bsntlv, decoder)
3488 case 175:
3489 return DecodeBsnTlvEncap(_bsntlv, decoder)
3490 case 176:
3491 return DecodeBsnTlvBfdEndpoint(_bsntlv, decoder)
3492 case 177:
3493 return DecodeBsnTlvBfdState(_bsntlv, decoder)
3494 case 178:
3495 return DecodeBsnTlvLrAllEnabled(_bsntlv, decoder)
3496 case 179:
3497 return DecodeBsnTlvPortMode(_bsntlv, decoder)
3498 case 180:
3499 return DecodeBsnTlvUdfCapability(_bsntlv, decoder)
3500 case 181:
3501 return DecodeBsnTlvPimHelloFlood(_bsntlv, decoder)
3502 case 182:
3503 return DecodeBsnTlvFlowClassify(_bsntlv, decoder)
3504 case 183:
3505 return DecodeBsnTlvFlowIdentifier(_bsntlv, decoder)
3506 case 184:
3507 return DecodeBsnTlvFlowClassifier(_bsntlv, decoder)
3508 case 185:
3509 return DecodeBsnTlvDisableXmit(_bsntlv, decoder)
3510 case 186:
3511 return DecodeBsnTlvPreserveVlan(_bsntlv, decoder)
3512 case 187:
3513 return DecodeBsnTlvDropControl(_bsntlv, decoder)
3514 case 188:
3515 return DecodeBsnTlvLossless(_bsntlv, decoder)
3516 case 189:
3517 return DecodeBsnTlvRedundantMgmt(_bsntlv, decoder)
3518 case 190:
3519 return DecodeBsnTlvDnsAnalytics(_bsntlv, decoder)
3520 case 191:
3521 return DecodeBsnTlvSrcMacCml(_bsntlv, decoder)
3522 case 192:
3523 return DecodeBsnTlvActive(_bsntlv, decoder)
3524 case 193:
3525 return DecodeBsnTlvLinkUp(_bsntlv, decoder)
3526 case 194:
3527 return DecodeBsnTlvFailCount(_bsntlv, decoder)
3528 case 195:
3529 return DecodeBsnTlvEgressSamplingRate(_bsntlv, decoder)
3530 default:
3531 return nil, fmt.Errorf("Invalid type '%d' for 'BsnTlv'", _bsntlv.Type)
3532 }
3533}
3534
3535func NewBsnTlv(_type uint16) *BsnTlv {
3536 obj := &BsnTlv{}
3537 obj.Type = _type
3538 return obj
3539}
3540
3541type BsnTlvActive struct {
3542 *BsnTlv
3543}
3544
3545type IBsnTlvActive interface {
3546 IBsnTlv
3547}
3548
3549func (self *BsnTlvActive) Serialize(encoder *goloxi.Encoder) error {
3550 startIndex := len(encoder.Bytes())
3551 if err := self.BsnTlv.Serialize(encoder); err != nil {
3552 return err
3553 }
3554 length := len(encoder.Bytes()) - startIndex
3555
3556 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
3557
3558 return nil
3559}
3560
3561func DecodeBsnTlvActive(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvActive, error) {
3562 _bsntlvactive := &BsnTlvActive{BsnTlv: parent}
3563 return _bsntlvactive, nil
3564}
3565
3566func NewBsnTlvActive() *BsnTlvActive {
3567 obj := &BsnTlvActive{
3568 BsnTlv: NewBsnTlv(192),
3569 }
3570 return obj
3571}
3572
3573type BsnTlvActorKey struct {
3574 *BsnTlv
3575 Value uint16
3576}
3577
3578type IBsnTlvActorKey interface {
3579 IBsnTlv
3580 GetValue() uint16
3581}
3582
3583func (self *BsnTlvActorKey) GetValue() uint16 {
3584 return self.Value
3585}
3586
3587func (self *BsnTlvActorKey) SetValue(v uint16) {
3588 self.Value = v
3589}
3590
3591func (self *BsnTlvActorKey) Serialize(encoder *goloxi.Encoder) error {
3592 startIndex := len(encoder.Bytes())
3593 if err := self.BsnTlv.Serialize(encoder); err != nil {
3594 return err
3595 }
3596
3597 encoder.PutUint16(uint16(self.Value))
3598 length := len(encoder.Bytes()) - startIndex
3599
3600 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
3601
3602 return nil
3603}
3604
3605func DecodeBsnTlvActorKey(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvActorKey, error) {
3606 _bsntlvactorkey := &BsnTlvActorKey{BsnTlv: parent}
3607 if decoder.Length() < 2 {
3608 return nil, fmt.Errorf("BsnTlvActorKey packet too short: %d < 2", decoder.Length())
3609 }
3610 _bsntlvactorkey.Value = uint16(decoder.ReadUint16())
3611 return _bsntlvactorkey, nil
3612}
3613
3614func NewBsnTlvActorKey() *BsnTlvActorKey {
3615 obj := &BsnTlvActorKey{
3616 BsnTlv: NewBsnTlv(44),
3617 }
3618 return obj
3619}
3620
3621type BsnTlvActorPortNum struct {
3622 *BsnTlv
3623 Value uint16
3624}
3625
3626type IBsnTlvActorPortNum interface {
3627 IBsnTlv
3628 GetValue() uint16
3629}
3630
3631func (self *BsnTlvActorPortNum) GetValue() uint16 {
3632 return self.Value
3633}
3634
3635func (self *BsnTlvActorPortNum) SetValue(v uint16) {
3636 self.Value = v
3637}
3638
3639func (self *BsnTlvActorPortNum) Serialize(encoder *goloxi.Encoder) error {
3640 startIndex := len(encoder.Bytes())
3641 if err := self.BsnTlv.Serialize(encoder); err != nil {
3642 return err
3643 }
3644
3645 encoder.PutUint16(uint16(self.Value))
3646 length := len(encoder.Bytes()) - startIndex
3647
3648 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
3649
3650 return nil
3651}
3652
3653func DecodeBsnTlvActorPortNum(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvActorPortNum, error) {
3654 _bsntlvactorportnum := &BsnTlvActorPortNum{BsnTlv: parent}
3655 if decoder.Length() < 2 {
3656 return nil, fmt.Errorf("BsnTlvActorPortNum packet too short: %d < 2", decoder.Length())
3657 }
3658 _bsntlvactorportnum.Value = uint16(decoder.ReadUint16())
3659 return _bsntlvactorportnum, nil
3660}
3661
3662func NewBsnTlvActorPortNum() *BsnTlvActorPortNum {
3663 obj := &BsnTlvActorPortNum{
3664 BsnTlv: NewBsnTlv(43),
3665 }
3666 return obj
3667}
3668
3669type BsnTlvActorPortPriority struct {
3670 *BsnTlv
3671 Value uint16
3672}
3673
3674type IBsnTlvActorPortPriority interface {
3675 IBsnTlv
3676 GetValue() uint16
3677}
3678
3679func (self *BsnTlvActorPortPriority) GetValue() uint16 {
3680 return self.Value
3681}
3682
3683func (self *BsnTlvActorPortPriority) SetValue(v uint16) {
3684 self.Value = v
3685}
3686
3687func (self *BsnTlvActorPortPriority) Serialize(encoder *goloxi.Encoder) error {
3688 startIndex := len(encoder.Bytes())
3689 if err := self.BsnTlv.Serialize(encoder); err != nil {
3690 return err
3691 }
3692
3693 encoder.PutUint16(uint16(self.Value))
3694 length := len(encoder.Bytes()) - startIndex
3695
3696 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
3697
3698 return nil
3699}
3700
3701func DecodeBsnTlvActorPortPriority(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvActorPortPriority, error) {
3702 _bsntlvactorportpriority := &BsnTlvActorPortPriority{BsnTlv: parent}
3703 if decoder.Length() < 2 {
3704 return nil, fmt.Errorf("BsnTlvActorPortPriority packet too short: %d < 2", decoder.Length())
3705 }
3706 _bsntlvactorportpriority.Value = uint16(decoder.ReadUint16())
3707 return _bsntlvactorportpriority, nil
3708}
3709
3710func NewBsnTlvActorPortPriority() *BsnTlvActorPortPriority {
3711 obj := &BsnTlvActorPortPriority{
3712 BsnTlv: NewBsnTlv(42),
3713 }
3714 return obj
3715}
3716
3717type BsnTlvActorState struct {
3718 *BsnTlv
3719 Value BsnLacpState
3720}
3721
3722type IBsnTlvActorState interface {
3723 IBsnTlv
3724 GetValue() BsnLacpState
3725}
3726
3727func (self *BsnTlvActorState) GetValue() BsnLacpState {
3728 return self.Value
3729}
3730
3731func (self *BsnTlvActorState) SetValue(v BsnLacpState) {
3732 self.Value = v
3733}
3734
3735func (self *BsnTlvActorState) Serialize(encoder *goloxi.Encoder) error {
3736 startIndex := len(encoder.Bytes())
3737 if err := self.BsnTlv.Serialize(encoder); err != nil {
3738 return err
3739 }
3740
3741 encoder.PutUint8(uint8(self.Value))
3742 length := len(encoder.Bytes()) - startIndex
3743
3744 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
3745
3746 return nil
3747}
3748
3749func DecodeBsnTlvActorState(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvActorState, error) {
3750 _bsntlvactorstate := &BsnTlvActorState{BsnTlv: parent}
3751 if decoder.Length() < 1 {
3752 return nil, fmt.Errorf("BsnTlvActorState packet too short: %d < 1", decoder.Length())
3753 }
3754 _bsntlvactorstate.Value = BsnLacpState(decoder.ReadByte())
3755 return _bsntlvactorstate, nil
3756}
3757
3758func NewBsnTlvActorState() *BsnTlvActorState {
3759 obj := &BsnTlvActorState{
3760 BsnTlv: NewBsnTlv(53),
3761 }
3762 return obj
3763}
3764
3765type BsnTlvActorSystemMac struct {
3766 *BsnTlv
3767 Value net.HardwareAddr
3768}
3769
3770type IBsnTlvActorSystemMac interface {
3771 IBsnTlv
3772 GetValue() net.HardwareAddr
3773}
3774
3775func (self *BsnTlvActorSystemMac) GetValue() net.HardwareAddr {
3776 return self.Value
3777}
3778
3779func (self *BsnTlvActorSystemMac) SetValue(v net.HardwareAddr) {
3780 self.Value = v
3781}
3782
3783func (self *BsnTlvActorSystemMac) Serialize(encoder *goloxi.Encoder) error {
3784 startIndex := len(encoder.Bytes())
3785 if err := self.BsnTlv.Serialize(encoder); err != nil {
3786 return err
3787 }
3788
3789 encoder.Write(self.Value)
3790 length := len(encoder.Bytes()) - startIndex
3791
3792 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
3793
3794 return nil
3795}
3796
3797func DecodeBsnTlvActorSystemMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvActorSystemMac, error) {
3798 _bsntlvactorsystemmac := &BsnTlvActorSystemMac{BsnTlv: parent}
3799 if decoder.Length() < 6 {
3800 return nil, fmt.Errorf("BsnTlvActorSystemMac packet too short: %d < 6", decoder.Length())
3801 }
3802 _bsntlvactorsystemmac.Value = net.HardwareAddr(decoder.Read(6))
3803 return _bsntlvactorsystemmac, nil
3804}
3805
3806func NewBsnTlvActorSystemMac() *BsnTlvActorSystemMac {
3807 obj := &BsnTlvActorSystemMac{
3808 BsnTlv: NewBsnTlv(41),
3809 }
3810 return obj
3811}
3812
3813type BsnTlvActorSystemPriority struct {
3814 *BsnTlv
3815 Value uint16
3816}
3817
3818type IBsnTlvActorSystemPriority interface {
3819 IBsnTlv
3820 GetValue() uint16
3821}
3822
3823func (self *BsnTlvActorSystemPriority) GetValue() uint16 {
3824 return self.Value
3825}
3826
3827func (self *BsnTlvActorSystemPriority) SetValue(v uint16) {
3828 self.Value = v
3829}
3830
3831func (self *BsnTlvActorSystemPriority) Serialize(encoder *goloxi.Encoder) error {
3832 startIndex := len(encoder.Bytes())
3833 if err := self.BsnTlv.Serialize(encoder); err != nil {
3834 return err
3835 }
3836
3837 encoder.PutUint16(uint16(self.Value))
3838 length := len(encoder.Bytes()) - startIndex
3839
3840 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
3841
3842 return nil
3843}
3844
3845func DecodeBsnTlvActorSystemPriority(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvActorSystemPriority, error) {
3846 _bsntlvactorsystempriority := &BsnTlvActorSystemPriority{BsnTlv: parent}
3847 if decoder.Length() < 2 {
3848 return nil, fmt.Errorf("BsnTlvActorSystemPriority packet too short: %d < 2", decoder.Length())
3849 }
3850 _bsntlvactorsystempriority.Value = uint16(decoder.ReadUint16())
3851 return _bsntlvactorsystempriority, nil
3852}
3853
3854func NewBsnTlvActorSystemPriority() *BsnTlvActorSystemPriority {
3855 obj := &BsnTlvActorSystemPriority{
3856 BsnTlv: NewBsnTlv(40),
3857 }
3858 return obj
3859}
3860
3861type BsnTlvAnchor struct {
3862 *BsnTlv
3863 Value BsnAnchor
3864}
3865
3866type IBsnTlvAnchor interface {
3867 IBsnTlv
3868 GetValue() BsnAnchor
3869}
3870
3871func (self *BsnTlvAnchor) GetValue() BsnAnchor {
3872 return self.Value
3873}
3874
3875func (self *BsnTlvAnchor) SetValue(v BsnAnchor) {
3876 self.Value = v
3877}
3878
3879func (self *BsnTlvAnchor) Serialize(encoder *goloxi.Encoder) error {
3880 startIndex := len(encoder.Bytes())
3881 if err := self.BsnTlv.Serialize(encoder); err != nil {
3882 return err
3883 }
3884
3885 encoder.PutUint16(uint16(self.Value))
3886 length := len(encoder.Bytes()) - startIndex
3887
3888 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
3889
3890 return nil
3891}
3892
3893func DecodeBsnTlvAnchor(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvAnchor, error) {
3894 _bsntlvanchor := &BsnTlvAnchor{BsnTlv: parent}
3895 if decoder.Length() < 2 {
3896 return nil, fmt.Errorf("BsnTlvAnchor packet too short: %d < 2", decoder.Length())
3897 }
3898 _bsntlvanchor.Value = BsnAnchor(decoder.ReadUint16())
3899 return _bsntlvanchor, nil
3900}
3901
3902func NewBsnTlvAnchor() *BsnTlvAnchor {
3903 obj := &BsnTlvAnchor{
3904 BsnTlv: NewBsnTlv(81),
3905 }
3906 return obj
3907}
3908
3909type BsnTlvApplyBytes struct {
3910 *BsnTlv
3911 Value uint64
3912}
3913
3914type IBsnTlvApplyBytes interface {
3915 IBsnTlv
3916 GetValue() uint64
3917}
3918
3919func (self *BsnTlvApplyBytes) GetValue() uint64 {
3920 return self.Value
3921}
3922
3923func (self *BsnTlvApplyBytes) SetValue(v uint64) {
3924 self.Value = v
3925}
3926
3927func (self *BsnTlvApplyBytes) Serialize(encoder *goloxi.Encoder) error {
3928 startIndex := len(encoder.Bytes())
3929 if err := self.BsnTlv.Serialize(encoder); err != nil {
3930 return err
3931 }
3932
3933 encoder.PutUint64(uint64(self.Value))
3934 length := len(encoder.Bytes()) - startIndex
3935
3936 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
3937
3938 return nil
3939}
3940
3941func DecodeBsnTlvApplyBytes(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvApplyBytes, error) {
3942 _bsntlvapplybytes := &BsnTlvApplyBytes{BsnTlv: parent}
3943 if decoder.Length() < 8 {
3944 return nil, fmt.Errorf("BsnTlvApplyBytes packet too short: %d < 8", decoder.Length())
3945 }
3946 _bsntlvapplybytes.Value = uint64(decoder.ReadUint64())
3947 return _bsntlvapplybytes, nil
3948}
3949
3950func NewBsnTlvApplyBytes() *BsnTlvApplyBytes {
3951 obj := &BsnTlvApplyBytes{
3952 BsnTlv: NewBsnTlv(130),
3953 }
3954 return obj
3955}
3956
3957type BsnTlvApplyPackets struct {
3958 *BsnTlv
3959 Value uint64
3960}
3961
3962type IBsnTlvApplyPackets interface {
3963 IBsnTlv
3964 GetValue() uint64
3965}
3966
3967func (self *BsnTlvApplyPackets) GetValue() uint64 {
3968 return self.Value
3969}
3970
3971func (self *BsnTlvApplyPackets) SetValue(v uint64) {
3972 self.Value = v
3973}
3974
3975func (self *BsnTlvApplyPackets) Serialize(encoder *goloxi.Encoder) error {
3976 startIndex := len(encoder.Bytes())
3977 if err := self.BsnTlv.Serialize(encoder); err != nil {
3978 return err
3979 }
3980
3981 encoder.PutUint64(uint64(self.Value))
3982 length := len(encoder.Bytes()) - startIndex
3983
3984 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
3985
3986 return nil
3987}
3988
3989func DecodeBsnTlvApplyPackets(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvApplyPackets, error) {
3990 _bsntlvapplypackets := &BsnTlvApplyPackets{BsnTlv: parent}
3991 if decoder.Length() < 8 {
3992 return nil, fmt.Errorf("BsnTlvApplyPackets packet too short: %d < 8", decoder.Length())
3993 }
3994 _bsntlvapplypackets.Value = uint64(decoder.ReadUint64())
3995 return _bsntlvapplypackets, nil
3996}
3997
3998func NewBsnTlvApplyPackets() *BsnTlvApplyPackets {
3999 obj := &BsnTlvApplyPackets{
4000 BsnTlv: NewBsnTlv(129),
4001 }
4002 return obj
4003}
4004
4005type BsnTlvAutoNegotiation struct {
4006 *BsnTlv
4007 Value BsnAutoNegotiationType
4008}
4009
4010type IBsnTlvAutoNegotiation interface {
4011 IBsnTlv
4012 GetValue() BsnAutoNegotiationType
4013}
4014
4015func (self *BsnTlvAutoNegotiation) GetValue() BsnAutoNegotiationType {
4016 return self.Value
4017}
4018
4019func (self *BsnTlvAutoNegotiation) SetValue(v BsnAutoNegotiationType) {
4020 self.Value = v
4021}
4022
4023func (self *BsnTlvAutoNegotiation) Serialize(encoder *goloxi.Encoder) error {
4024 startIndex := len(encoder.Bytes())
4025 if err := self.BsnTlv.Serialize(encoder); err != nil {
4026 return err
4027 }
4028
4029 encoder.PutUint8(uint8(self.Value))
4030 length := len(encoder.Bytes()) - startIndex
4031
4032 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4033
4034 return nil
4035}
4036
4037func DecodeBsnTlvAutoNegotiation(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvAutoNegotiation, error) {
4038 _bsntlvautonegotiation := &BsnTlvAutoNegotiation{BsnTlv: parent}
4039 if decoder.Length() < 1 {
4040 return nil, fmt.Errorf("BsnTlvAutoNegotiation packet too short: %d < 1", decoder.Length())
4041 }
4042 _bsntlvautonegotiation.Value = BsnAutoNegotiationType(decoder.ReadByte())
4043 return _bsntlvautonegotiation, nil
4044}
4045
4046func NewBsnTlvAutoNegotiation() *BsnTlvAutoNegotiation {
4047 obj := &BsnTlvAutoNegotiation{
4048 BsnTlv: NewBsnTlv(144),
4049 }
4050 return obj
4051}
4052
4053type BsnTlvBfdEndpoint struct {
4054 *BsnTlv
4055 Value BsnBfdEndpoint
4056}
4057
4058type IBsnTlvBfdEndpoint interface {
4059 IBsnTlv
4060 GetValue() BsnBfdEndpoint
4061}
4062
4063func (self *BsnTlvBfdEndpoint) GetValue() BsnBfdEndpoint {
4064 return self.Value
4065}
4066
4067func (self *BsnTlvBfdEndpoint) SetValue(v BsnBfdEndpoint) {
4068 self.Value = v
4069}
4070
4071func (self *BsnTlvBfdEndpoint) Serialize(encoder *goloxi.Encoder) error {
4072 startIndex := len(encoder.Bytes())
4073 if err := self.BsnTlv.Serialize(encoder); err != nil {
4074 return err
4075 }
4076
4077 encoder.PutUint8(uint8(self.Value))
4078 length := len(encoder.Bytes()) - startIndex
4079
4080 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4081
4082 return nil
4083}
4084
4085func DecodeBsnTlvBfdEndpoint(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvBfdEndpoint, error) {
4086 _bsntlvbfdendpoint := &BsnTlvBfdEndpoint{BsnTlv: parent}
4087 if decoder.Length() < 1 {
4088 return nil, fmt.Errorf("BsnTlvBfdEndpoint packet too short: %d < 1", decoder.Length())
4089 }
4090 _bsntlvbfdendpoint.Value = BsnBfdEndpoint(decoder.ReadByte())
4091 return _bsntlvbfdendpoint, nil
4092}
4093
4094func NewBsnTlvBfdEndpoint() *BsnTlvBfdEndpoint {
4095 obj := &BsnTlvBfdEndpoint{
4096 BsnTlv: NewBsnTlv(176),
4097 }
4098 return obj
4099}
4100
4101type BsnTlvBfdState struct {
4102 *BsnTlv
4103 Value BsnBfdEndpointState
4104}
4105
4106type IBsnTlvBfdState interface {
4107 IBsnTlv
4108 GetValue() BsnBfdEndpointState
4109}
4110
4111func (self *BsnTlvBfdState) GetValue() BsnBfdEndpointState {
4112 return self.Value
4113}
4114
4115func (self *BsnTlvBfdState) SetValue(v BsnBfdEndpointState) {
4116 self.Value = v
4117}
4118
4119func (self *BsnTlvBfdState) Serialize(encoder *goloxi.Encoder) error {
4120 startIndex := len(encoder.Bytes())
4121 if err := self.BsnTlv.Serialize(encoder); err != nil {
4122 return err
4123 }
4124
4125 encoder.PutUint8(uint8(self.Value))
4126 length := len(encoder.Bytes()) - startIndex
4127
4128 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4129
4130 return nil
4131}
4132
4133func DecodeBsnTlvBfdState(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvBfdState, error) {
4134 _bsntlvbfdstate := &BsnTlvBfdState{BsnTlv: parent}
4135 if decoder.Length() < 1 {
4136 return nil, fmt.Errorf("BsnTlvBfdState packet too short: %d < 1", decoder.Length())
4137 }
4138 _bsntlvbfdstate.Value = BsnBfdEndpointState(decoder.ReadByte())
4139 return _bsntlvbfdstate, nil
4140}
4141
4142func NewBsnTlvBfdState() *BsnTlvBfdState {
4143 obj := &BsnTlvBfdState{
4144 BsnTlv: NewBsnTlv(177),
4145 }
4146 return obj
4147}
4148
4149type BsnTlvBroadcastQueryTimeout struct {
4150 *BsnTlv
4151 Value uint32
4152}
4153
4154type IBsnTlvBroadcastQueryTimeout interface {
4155 IBsnTlv
4156 GetValue() uint32
4157}
4158
4159func (self *BsnTlvBroadcastQueryTimeout) GetValue() uint32 {
4160 return self.Value
4161}
4162
4163func (self *BsnTlvBroadcastQueryTimeout) SetValue(v uint32) {
4164 self.Value = v
4165}
4166
4167func (self *BsnTlvBroadcastQueryTimeout) Serialize(encoder *goloxi.Encoder) error {
4168 startIndex := len(encoder.Bytes())
4169 if err := self.BsnTlv.Serialize(encoder); err != nil {
4170 return err
4171 }
4172
4173 encoder.PutUint32(uint32(self.Value))
4174 length := len(encoder.Bytes()) - startIndex
4175
4176 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4177
4178 return nil
4179}
4180
4181func DecodeBsnTlvBroadcastQueryTimeout(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvBroadcastQueryTimeout, error) {
4182 _bsntlvbroadcastquerytimeout := &BsnTlvBroadcastQueryTimeout{BsnTlv: parent}
4183 if decoder.Length() < 4 {
4184 return nil, fmt.Errorf("BsnTlvBroadcastQueryTimeout packet too short: %d < 4", decoder.Length())
4185 }
4186 _bsntlvbroadcastquerytimeout.Value = uint32(decoder.ReadUint32())
4187 return _bsntlvbroadcastquerytimeout, nil
4188}
4189
4190func NewBsnTlvBroadcastQueryTimeout() *BsnTlvBroadcastQueryTimeout {
4191 obj := &BsnTlvBroadcastQueryTimeout{
4192 BsnTlv: NewBsnTlv(10),
4193 }
4194 return obj
4195}
4196
4197type BsnTlvBroadcastRate struct {
4198 *BsnTlv
4199 Value uint32
4200}
4201
4202type IBsnTlvBroadcastRate interface {
4203 IBsnTlv
4204 GetValue() uint32
4205}
4206
4207func (self *BsnTlvBroadcastRate) GetValue() uint32 {
4208 return self.Value
4209}
4210
4211func (self *BsnTlvBroadcastRate) SetValue(v uint32) {
4212 self.Value = v
4213}
4214
4215func (self *BsnTlvBroadcastRate) Serialize(encoder *goloxi.Encoder) error {
4216 startIndex := len(encoder.Bytes())
4217 if err := self.BsnTlv.Serialize(encoder); err != nil {
4218 return err
4219 }
4220
4221 encoder.PutUint32(uint32(self.Value))
4222 length := len(encoder.Bytes()) - startIndex
4223
4224 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4225
4226 return nil
4227}
4228
4229func DecodeBsnTlvBroadcastRate(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvBroadcastRate, error) {
4230 _bsntlvbroadcastrate := &BsnTlvBroadcastRate{BsnTlv: parent}
4231 if decoder.Length() < 4 {
4232 return nil, fmt.Errorf("BsnTlvBroadcastRate packet too short: %d < 4", decoder.Length())
4233 }
4234 _bsntlvbroadcastrate.Value = uint32(decoder.ReadUint32())
4235 return _bsntlvbroadcastrate, nil
4236}
4237
4238func NewBsnTlvBroadcastRate() *BsnTlvBroadcastRate {
4239 obj := &BsnTlvBroadcastRate{
4240 BsnTlv: NewBsnTlv(90),
4241 }
4242 return obj
4243}
4244
4245type BsnTlvBucket struct {
4246 *BsnTlv
4247 Value []IBsnTlv
4248}
4249
4250type IBsnTlvBucket interface {
4251 IBsnTlv
4252 GetValue() []IBsnTlv
4253}
4254
4255func (self *BsnTlvBucket) GetValue() []IBsnTlv {
4256 return self.Value
4257}
4258
4259func (self *BsnTlvBucket) SetValue(v []IBsnTlv) {
4260 self.Value = v
4261}
4262
4263func (self *BsnTlvBucket) Serialize(encoder *goloxi.Encoder) error {
4264 startIndex := len(encoder.Bytes())
4265 if err := self.BsnTlv.Serialize(encoder); err != nil {
4266 return err
4267 }
4268
4269 for _, obj := range self.Value {
4270 if err := obj.Serialize(encoder); err != nil {
4271 return err
4272 }
4273 }
4274 length := len(encoder.Bytes()) - startIndex
4275
4276 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4277
4278 return nil
4279}
4280
4281func DecodeBsnTlvBucket(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvBucket, error) {
4282 _bsntlvbucket := &BsnTlvBucket{BsnTlv: parent}
4283
4284 for decoder.Length() >= 4 {
4285 item, err := DecodeBsnTlv(decoder)
4286 if err != nil {
4287 return nil, err
4288 }
4289 if item != nil {
4290 _bsntlvbucket.Value = append(_bsntlvbucket.Value, item)
4291 }
4292 }
4293 return _bsntlvbucket, nil
4294}
4295
4296func NewBsnTlvBucket() *BsnTlvBucket {
4297 obj := &BsnTlvBucket{
4298 BsnTlv: NewBsnTlv(64),
4299 }
4300 return obj
4301}
4302
4303type BsnTlvCircuitId struct {
4304 *BsnTlv
4305 Value []byte
4306}
4307
4308type IBsnTlvCircuitId interface {
4309 IBsnTlv
4310 GetValue() []byte
4311}
4312
4313func (self *BsnTlvCircuitId) GetValue() []byte {
4314 return self.Value
4315}
4316
4317func (self *BsnTlvCircuitId) SetValue(v []byte) {
4318 self.Value = v
4319}
4320
4321func (self *BsnTlvCircuitId) Serialize(encoder *goloxi.Encoder) error {
4322 startIndex := len(encoder.Bytes())
4323 if err := self.BsnTlv.Serialize(encoder); err != nil {
4324 return err
4325 }
4326
4327 encoder.Write(self.Value)
4328 length := len(encoder.Bytes()) - startIndex
4329
4330 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4331
4332 return nil
4333}
4334
4335func DecodeBsnTlvCircuitId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvCircuitId, error) {
4336 _bsntlvcircuitid := &BsnTlvCircuitId{BsnTlv: parent}
4337 _bsntlvcircuitid.Value = decoder.Read(int(decoder.Length()))
4338 return _bsntlvcircuitid, nil
4339}
4340
4341func NewBsnTlvCircuitId() *BsnTlvCircuitId {
4342 obj := &BsnTlvCircuitId{
4343 BsnTlv: NewBsnTlv(14),
4344 }
4345 return obj
4346}
4347
4348type BsnTlvConvergenceStatus struct {
4349 *BsnTlv
4350 Value uint8
4351}
4352
4353type IBsnTlvConvergenceStatus interface {
4354 IBsnTlv
4355 GetValue() uint8
4356}
4357
4358func (self *BsnTlvConvergenceStatus) GetValue() uint8 {
4359 return self.Value
4360}
4361
4362func (self *BsnTlvConvergenceStatus) SetValue(v uint8) {
4363 self.Value = v
4364}
4365
4366func (self *BsnTlvConvergenceStatus) Serialize(encoder *goloxi.Encoder) error {
4367 startIndex := len(encoder.Bytes())
4368 if err := self.BsnTlv.Serialize(encoder); err != nil {
4369 return err
4370 }
4371
4372 encoder.PutUint8(uint8(self.Value))
4373 length := len(encoder.Bytes()) - startIndex
4374
4375 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4376
4377 return nil
4378}
4379
4380func DecodeBsnTlvConvergenceStatus(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvConvergenceStatus, error) {
4381 _bsntlvconvergencestatus := &BsnTlvConvergenceStatus{BsnTlv: parent}
4382 if decoder.Length() < 1 {
4383 return nil, fmt.Errorf("BsnTlvConvergenceStatus packet too short: %d < 1", decoder.Length())
4384 }
4385 _bsntlvconvergencestatus.Value = uint8(decoder.ReadByte())
4386 return _bsntlvconvergencestatus, nil
4387}
4388
4389func NewBsnTlvConvergenceStatus() *BsnTlvConvergenceStatus {
4390 obj := &BsnTlvConvergenceStatus{
4391 BsnTlv: NewBsnTlv(45),
4392 }
4393 return obj
4394}
4395
4396type BsnTlvCpuLag struct {
4397 *BsnTlv
4398}
4399
4400type IBsnTlvCpuLag interface {
4401 IBsnTlv
4402}
4403
4404func (self *BsnTlvCpuLag) Serialize(encoder *goloxi.Encoder) error {
4405 startIndex := len(encoder.Bytes())
4406 if err := self.BsnTlv.Serialize(encoder); err != nil {
4407 return err
4408 }
4409 length := len(encoder.Bytes()) - startIndex
4410
4411 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4412
4413 return nil
4414}
4415
4416func DecodeBsnTlvCpuLag(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvCpuLag, error) {
4417 _bsntlvcpulag := &BsnTlvCpuLag{BsnTlv: parent}
4418 return _bsntlvcpulag, nil
4419}
4420
4421func NewBsnTlvCpuLag() *BsnTlvCpuLag {
4422 obj := &BsnTlvCpuLag{
4423 BsnTlv: NewBsnTlv(118),
4424 }
4425 return obj
4426}
4427
4428type BsnTlvCrcEnabled struct {
4429 *BsnTlv
4430 Value uint8
4431}
4432
4433type IBsnTlvCrcEnabled interface {
4434 IBsnTlv
4435 GetValue() uint8
4436}
4437
4438func (self *BsnTlvCrcEnabled) GetValue() uint8 {
4439 return self.Value
4440}
4441
4442func (self *BsnTlvCrcEnabled) SetValue(v uint8) {
4443 self.Value = v
4444}
4445
4446func (self *BsnTlvCrcEnabled) Serialize(encoder *goloxi.Encoder) error {
4447 startIndex := len(encoder.Bytes())
4448 if err := self.BsnTlv.Serialize(encoder); err != nil {
4449 return err
4450 }
4451
4452 encoder.PutUint8(uint8(self.Value))
4453 length := len(encoder.Bytes()) - startIndex
4454
4455 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4456
4457 return nil
4458}
4459
4460func DecodeBsnTlvCrcEnabled(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvCrcEnabled, error) {
4461 _bsntlvcrcenabled := &BsnTlvCrcEnabled{BsnTlv: parent}
4462 if decoder.Length() < 1 {
4463 return nil, fmt.Errorf("BsnTlvCrcEnabled packet too short: %d < 1", decoder.Length())
4464 }
4465 _bsntlvcrcenabled.Value = uint8(decoder.ReadByte())
4466 return _bsntlvcrcenabled, nil
4467}
4468
4469func NewBsnTlvCrcEnabled() *BsnTlvCrcEnabled {
4470 obj := &BsnTlvCrcEnabled{
4471 BsnTlv: NewBsnTlv(22),
4472 }
4473 return obj
4474}
4475
4476type BsnTlvData struct {
4477 *BsnTlv
4478 Value []byte
4479}
4480
4481type IBsnTlvData interface {
4482 IBsnTlv
4483 GetValue() []byte
4484}
4485
4486func (self *BsnTlvData) GetValue() []byte {
4487 return self.Value
4488}
4489
4490func (self *BsnTlvData) SetValue(v []byte) {
4491 self.Value = v
4492}
4493
4494func (self *BsnTlvData) Serialize(encoder *goloxi.Encoder) error {
4495 startIndex := len(encoder.Bytes())
4496 if err := self.BsnTlv.Serialize(encoder); err != nil {
4497 return err
4498 }
4499
4500 encoder.Write(self.Value)
4501 length := len(encoder.Bytes()) - startIndex
4502
4503 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4504
4505 return nil
4506}
4507
4508func DecodeBsnTlvData(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvData, error) {
4509 _bsntlvdata := &BsnTlvData{BsnTlv: parent}
4510 _bsntlvdata.Value = decoder.Read(int(decoder.Length()))
4511 return _bsntlvdata, nil
4512}
4513
4514func NewBsnTlvData() *BsnTlvData {
4515 obj := &BsnTlvData{
4516 BsnTlv: NewBsnTlv(55),
4517 }
4518 return obj
4519}
4520
4521type BsnTlvDataMask struct {
4522 *BsnTlv
4523 Value []byte
4524}
4525
4526type IBsnTlvDataMask interface {
4527 IBsnTlv
4528 GetValue() []byte
4529}
4530
4531func (self *BsnTlvDataMask) GetValue() []byte {
4532 return self.Value
4533}
4534
4535func (self *BsnTlvDataMask) SetValue(v []byte) {
4536 self.Value = v
4537}
4538
4539func (self *BsnTlvDataMask) Serialize(encoder *goloxi.Encoder) error {
4540 startIndex := len(encoder.Bytes())
4541 if err := self.BsnTlv.Serialize(encoder); err != nil {
4542 return err
4543 }
4544
4545 encoder.Write(self.Value)
4546 length := len(encoder.Bytes()) - startIndex
4547
4548 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4549
4550 return nil
4551}
4552
4553func DecodeBsnTlvDataMask(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvDataMask, error) {
4554 _bsntlvdatamask := &BsnTlvDataMask{BsnTlv: parent}
4555 _bsntlvdatamask.Value = decoder.Read(int(decoder.Length()))
4556 return _bsntlvdatamask, nil
4557}
4558
4559func NewBsnTlvDataMask() *BsnTlvDataMask {
4560 obj := &BsnTlvDataMask{
4561 BsnTlv: NewBsnTlv(140),
4562 }
4563 return obj
4564}
4565
4566type BsnTlvDecap struct {
4567 *BsnTlv
4568 Value BsnDecap
4569}
4570
4571type IBsnTlvDecap interface {
4572 IBsnTlv
4573 GetValue() BsnDecap
4574}
4575
4576func (self *BsnTlvDecap) GetValue() BsnDecap {
4577 return self.Value
4578}
4579
4580func (self *BsnTlvDecap) SetValue(v BsnDecap) {
4581 self.Value = v
4582}
4583
4584func (self *BsnTlvDecap) Serialize(encoder *goloxi.Encoder) error {
4585 startIndex := len(encoder.Bytes())
4586 if err := self.BsnTlv.Serialize(encoder); err != nil {
4587 return err
4588 }
4589
4590 encoder.PutUint16(uint16(self.Value))
4591 length := len(encoder.Bytes()) - startIndex
4592
4593 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4594
4595 return nil
4596}
4597
4598func DecodeBsnTlvDecap(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvDecap, error) {
4599 _bsntlvdecap := &BsnTlvDecap{BsnTlv: parent}
4600 if decoder.Length() < 2 {
4601 return nil, fmt.Errorf("BsnTlvDecap packet too short: %d < 2", decoder.Length())
4602 }
4603 _bsntlvdecap.Value = BsnDecap(decoder.ReadUint16())
4604 return _bsntlvdecap, nil
4605}
4606
4607func NewBsnTlvDecap() *BsnTlvDecap {
4608 obj := &BsnTlvDecap{
4609 BsnTlv: NewBsnTlv(85),
4610 }
4611 return obj
4612}
4613
4614type BsnTlvDisableSrcMacCheck struct {
4615 *BsnTlv
4616}
4617
4618type IBsnTlvDisableSrcMacCheck interface {
4619 IBsnTlv
4620}
4621
4622func (self *BsnTlvDisableSrcMacCheck) Serialize(encoder *goloxi.Encoder) error {
4623 startIndex := len(encoder.Bytes())
4624 if err := self.BsnTlv.Serialize(encoder); err != nil {
4625 return err
4626 }
4627 length := len(encoder.Bytes()) - startIndex
4628
4629 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4630
4631 return nil
4632}
4633
4634func DecodeBsnTlvDisableSrcMacCheck(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvDisableSrcMacCheck, error) {
4635 _bsntlvdisablesrcmaccheck := &BsnTlvDisableSrcMacCheck{BsnTlv: parent}
4636 return _bsntlvdisablesrcmaccheck, nil
4637}
4638
4639func NewBsnTlvDisableSrcMacCheck() *BsnTlvDisableSrcMacCheck {
4640 obj := &BsnTlvDisableSrcMacCheck{
4641 BsnTlv: NewBsnTlv(120),
4642 }
4643 return obj
4644}
4645
4646type BsnTlvDisableXmit struct {
4647 *BsnTlv
4648}
4649
4650type IBsnTlvDisableXmit interface {
4651 IBsnTlv
4652}
4653
4654func (self *BsnTlvDisableXmit) Serialize(encoder *goloxi.Encoder) error {
4655 startIndex := len(encoder.Bytes())
4656 if err := self.BsnTlv.Serialize(encoder); err != nil {
4657 return err
4658 }
4659 length := len(encoder.Bytes()) - startIndex
4660
4661 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4662
4663 return nil
4664}
4665
4666func DecodeBsnTlvDisableXmit(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvDisableXmit, error) {
4667 _bsntlvdisablexmit := &BsnTlvDisableXmit{BsnTlv: parent}
4668 return _bsntlvdisablexmit, nil
4669}
4670
4671func NewBsnTlvDisableXmit() *BsnTlvDisableXmit {
4672 obj := &BsnTlvDisableXmit{
4673 BsnTlv: NewBsnTlv(185),
4674 }
4675 return obj
4676}
4677
4678type BsnTlvDnsAnalytics struct {
4679 *BsnTlv
4680}
4681
4682type IBsnTlvDnsAnalytics interface {
4683 IBsnTlv
4684}
4685
4686func (self *BsnTlvDnsAnalytics) Serialize(encoder *goloxi.Encoder) error {
4687 startIndex := len(encoder.Bytes())
4688 if err := self.BsnTlv.Serialize(encoder); err != nil {
4689 return err
4690 }
4691 length := len(encoder.Bytes()) - startIndex
4692
4693 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4694
4695 return nil
4696}
4697
4698func DecodeBsnTlvDnsAnalytics(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvDnsAnalytics, error) {
4699 _bsntlvdnsanalytics := &BsnTlvDnsAnalytics{BsnTlv: parent}
4700 return _bsntlvdnsanalytics, nil
4701}
4702
4703func NewBsnTlvDnsAnalytics() *BsnTlvDnsAnalytics {
4704 obj := &BsnTlvDnsAnalytics{
4705 BsnTlv: NewBsnTlv(190),
4706 }
4707 return obj
4708}
4709
4710type BsnTlvDrop struct {
4711 *BsnTlv
4712}
4713
4714type IBsnTlvDrop interface {
4715 IBsnTlv
4716}
4717
4718func (self *BsnTlvDrop) Serialize(encoder *goloxi.Encoder) error {
4719 startIndex := len(encoder.Bytes())
4720 if err := self.BsnTlv.Serialize(encoder); err != nil {
4721 return err
4722 }
4723 length := len(encoder.Bytes()) - startIndex
4724
4725 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4726
4727 return nil
4728}
4729
4730func DecodeBsnTlvDrop(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvDrop, error) {
4731 _bsntlvdrop := &BsnTlvDrop{BsnTlv: parent}
4732 return _bsntlvdrop, nil
4733}
4734
4735func NewBsnTlvDrop() *BsnTlvDrop {
4736 obj := &BsnTlvDrop{
4737 BsnTlv: NewBsnTlv(121),
4738 }
4739 return obj
4740}
4741
4742type BsnTlvDropControl struct {
4743 *BsnTlv
4744}
4745
4746type IBsnTlvDropControl interface {
4747 IBsnTlv
4748}
4749
4750func (self *BsnTlvDropControl) Serialize(encoder *goloxi.Encoder) error {
4751 startIndex := len(encoder.Bytes())
4752 if err := self.BsnTlv.Serialize(encoder); err != nil {
4753 return err
4754 }
4755 length := len(encoder.Bytes()) - startIndex
4756
4757 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4758
4759 return nil
4760}
4761
4762func DecodeBsnTlvDropControl(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvDropControl, error) {
4763 _bsntlvdropcontrol := &BsnTlvDropControl{BsnTlv: parent}
4764 return _bsntlvdropcontrol, nil
4765}
4766
4767func NewBsnTlvDropControl() *BsnTlvDropControl {
4768 obj := &BsnTlvDropControl{
4769 BsnTlv: NewBsnTlv(187),
4770 }
4771 return obj
4772}
4773
4774type BsnTlvDscp struct {
4775 *BsnTlv
4776 Value uint16
4777}
4778
4779type IBsnTlvDscp interface {
4780 IBsnTlv
4781 GetValue() uint16
4782}
4783
4784func (self *BsnTlvDscp) GetValue() uint16 {
4785 return self.Value
4786}
4787
4788func (self *BsnTlvDscp) SetValue(v uint16) {
4789 self.Value = v
4790}
4791
4792func (self *BsnTlvDscp) Serialize(encoder *goloxi.Encoder) error {
4793 startIndex := len(encoder.Bytes())
4794 if err := self.BsnTlv.Serialize(encoder); err != nil {
4795 return err
4796 }
4797
4798 encoder.PutUint16(uint16(self.Value))
4799 length := len(encoder.Bytes()) - startIndex
4800
4801 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4802
4803 return nil
4804}
4805
4806func DecodeBsnTlvDscp(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvDscp, error) {
4807 _bsntlvdscp := &BsnTlvDscp{BsnTlv: parent}
4808 if decoder.Length() < 2 {
4809 return nil, fmt.Errorf("BsnTlvDscp packet too short: %d < 2", decoder.Length())
4810 }
4811 _bsntlvdscp.Value = uint16(decoder.ReadUint16())
4812 return _bsntlvdscp, nil
4813}
4814
4815func NewBsnTlvDscp() *BsnTlvDscp {
4816 obj := &BsnTlvDscp{
4817 BsnTlv: NewBsnTlv(112),
4818 }
4819 return obj
4820}
4821
4822type BsnTlvEcn struct {
4823 *BsnTlv
4824 Value uint8
4825}
4826
4827type IBsnTlvEcn interface {
4828 IBsnTlv
4829 GetValue() uint8
4830}
4831
4832func (self *BsnTlvEcn) GetValue() uint8 {
4833 return self.Value
4834}
4835
4836func (self *BsnTlvEcn) SetValue(v uint8) {
4837 self.Value = v
4838}
4839
4840func (self *BsnTlvEcn) Serialize(encoder *goloxi.Encoder) error {
4841 startIndex := len(encoder.Bytes())
4842 if err := self.BsnTlv.Serialize(encoder); err != nil {
4843 return err
4844 }
4845
4846 encoder.PutUint8(uint8(self.Value))
4847 length := len(encoder.Bytes()) - startIndex
4848
4849 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4850
4851 return nil
4852}
4853
4854func DecodeBsnTlvEcn(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEcn, error) {
4855 _bsntlvecn := &BsnTlvEcn{BsnTlv: parent}
4856 if decoder.Length() < 1 {
4857 return nil, fmt.Errorf("BsnTlvEcn packet too short: %d < 1", decoder.Length())
4858 }
4859 _bsntlvecn.Value = uint8(decoder.ReadByte())
4860 return _bsntlvecn, nil
4861}
4862
4863func NewBsnTlvEcn() *BsnTlvEcn {
4864 obj := &BsnTlvEcn{
4865 BsnTlv: NewBsnTlv(132),
4866 }
4867 return obj
4868}
4869
4870type BsnTlvEgressOnly struct {
4871 *BsnTlv
4872}
4873
4874type IBsnTlvEgressOnly interface {
4875 IBsnTlv
4876}
4877
4878func (self *BsnTlvEgressOnly) Serialize(encoder *goloxi.Encoder) error {
4879 startIndex := len(encoder.Bytes())
4880 if err := self.BsnTlv.Serialize(encoder); err != nil {
4881 return err
4882 }
4883 length := len(encoder.Bytes()) - startIndex
4884
4885 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4886
4887 return nil
4888}
4889
4890func DecodeBsnTlvEgressOnly(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEgressOnly, error) {
4891 _bsntlvegressonly := &BsnTlvEgressOnly{BsnTlv: parent}
4892 return _bsntlvegressonly, nil
4893}
4894
4895func NewBsnTlvEgressOnly() *BsnTlvEgressOnly {
4896 obj := &BsnTlvEgressOnly{
4897 BsnTlv: NewBsnTlv(137),
4898 }
4899 return obj
4900}
4901
4902type BsnTlvEgressPortGroupId struct {
4903 *BsnTlv
4904 Value uint32
4905}
4906
4907type IBsnTlvEgressPortGroupId interface {
4908 IBsnTlv
4909 GetValue() uint32
4910}
4911
4912func (self *BsnTlvEgressPortGroupId) GetValue() uint32 {
4913 return self.Value
4914}
4915
4916func (self *BsnTlvEgressPortGroupId) SetValue(v uint32) {
4917 self.Value = v
4918}
4919
4920func (self *BsnTlvEgressPortGroupId) Serialize(encoder *goloxi.Encoder) error {
4921 startIndex := len(encoder.Bytes())
4922 if err := self.BsnTlv.Serialize(encoder); err != nil {
4923 return err
4924 }
4925
4926 encoder.PutUint32(uint32(self.Value))
4927 length := len(encoder.Bytes()) - startIndex
4928
4929 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4930
4931 return nil
4932}
4933
4934func DecodeBsnTlvEgressPortGroupId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEgressPortGroupId, error) {
4935 _bsntlvegressportgroupid := &BsnTlvEgressPortGroupId{BsnTlv: parent}
4936 if decoder.Length() < 4 {
4937 return nil, fmt.Errorf("BsnTlvEgressPortGroupId packet too short: %d < 4", decoder.Length())
4938 }
4939 _bsntlvegressportgroupid.Value = uint32(decoder.ReadUint32())
4940 return _bsntlvegressportgroupid, nil
4941}
4942
4943func NewBsnTlvEgressPortGroupId() *BsnTlvEgressPortGroupId {
4944 obj := &BsnTlvEgressPortGroupId{
4945 BsnTlv: NewBsnTlv(139),
4946 }
4947 return obj
4948}
4949
4950type BsnTlvEgressSamplingRate struct {
4951 *BsnTlv
4952 Value uint32
4953}
4954
4955type IBsnTlvEgressSamplingRate interface {
4956 IBsnTlv
4957 GetValue() uint32
4958}
4959
4960func (self *BsnTlvEgressSamplingRate) GetValue() uint32 {
4961 return self.Value
4962}
4963
4964func (self *BsnTlvEgressSamplingRate) SetValue(v uint32) {
4965 self.Value = v
4966}
4967
4968func (self *BsnTlvEgressSamplingRate) Serialize(encoder *goloxi.Encoder) error {
4969 startIndex := len(encoder.Bytes())
4970 if err := self.BsnTlv.Serialize(encoder); err != nil {
4971 return err
4972 }
4973
4974 encoder.PutUint32(uint32(self.Value))
4975 length := len(encoder.Bytes()) - startIndex
4976
4977 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
4978
4979 return nil
4980}
4981
4982func DecodeBsnTlvEgressSamplingRate(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEgressSamplingRate, error) {
4983 _bsntlvegresssamplingrate := &BsnTlvEgressSamplingRate{BsnTlv: parent}
4984 if decoder.Length() < 4 {
4985 return nil, fmt.Errorf("BsnTlvEgressSamplingRate packet too short: %d < 4", decoder.Length())
4986 }
4987 _bsntlvegresssamplingrate.Value = uint32(decoder.ReadUint32())
4988 return _bsntlvegresssamplingrate, nil
4989}
4990
4991func NewBsnTlvEgressSamplingRate() *BsnTlvEgressSamplingRate {
4992 obj := &BsnTlvEgressSamplingRate{
4993 BsnTlv: NewBsnTlv(195),
4994 }
4995 return obj
4996}
4997
4998type BsnTlvEncap struct {
4999 *BsnTlv
5000 Value BsnEncap
5001}
5002
5003type IBsnTlvEncap interface {
5004 IBsnTlv
5005 GetValue() BsnEncap
5006}
5007
5008func (self *BsnTlvEncap) GetValue() BsnEncap {
5009 return self.Value
5010}
5011
5012func (self *BsnTlvEncap) SetValue(v BsnEncap) {
5013 self.Value = v
5014}
5015
5016func (self *BsnTlvEncap) Serialize(encoder *goloxi.Encoder) error {
5017 startIndex := len(encoder.Bytes())
5018 if err := self.BsnTlv.Serialize(encoder); err != nil {
5019 return err
5020 }
5021
5022 encoder.PutUint8(uint8(self.Value))
5023 length := len(encoder.Bytes()) - startIndex
5024
5025 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5026
5027 return nil
5028}
5029
5030func DecodeBsnTlvEncap(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEncap, error) {
5031 _bsntlvencap := &BsnTlvEncap{BsnTlv: parent}
5032 if decoder.Length() < 1 {
5033 return nil, fmt.Errorf("BsnTlvEncap packet too short: %d < 1", decoder.Length())
5034 }
5035 _bsntlvencap.Value = BsnEncap(decoder.ReadByte())
5036 return _bsntlvencap, nil
5037}
5038
5039func NewBsnTlvEncap() *BsnTlvEncap {
5040 obj := &BsnTlvEncap{
5041 BsnTlv: NewBsnTlv(175),
5042 }
5043 return obj
5044}
5045
5046type BsnTlvEnhancedHashCapability struct {
5047 *BsnTlv
5048 Value BsnEnhancedHashType
5049}
5050
5051type IBsnTlvEnhancedHashCapability interface {
5052 IBsnTlv
5053 GetValue() BsnEnhancedHashType
5054}
5055
5056func (self *BsnTlvEnhancedHashCapability) GetValue() BsnEnhancedHashType {
5057 return self.Value
5058}
5059
5060func (self *BsnTlvEnhancedHashCapability) SetValue(v BsnEnhancedHashType) {
5061 self.Value = v
5062}
5063
5064func (self *BsnTlvEnhancedHashCapability) Serialize(encoder *goloxi.Encoder) error {
5065 startIndex := len(encoder.Bytes())
5066 if err := self.BsnTlv.Serialize(encoder); err != nil {
5067 return err
5068 }
5069
5070 encoder.PutUint64(uint64(self.Value))
5071 length := len(encoder.Bytes()) - startIndex
5072
5073 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5074
5075 return nil
5076}
5077
5078func DecodeBsnTlvEnhancedHashCapability(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEnhancedHashCapability, error) {
5079 _bsntlvenhancedhashcapability := &BsnTlvEnhancedHashCapability{BsnTlv: parent}
5080 if decoder.Length() < 8 {
5081 return nil, fmt.Errorf("BsnTlvEnhancedHashCapability packet too short: %d < 8", decoder.Length())
5082 }
5083 _bsntlvenhancedhashcapability.Value = BsnEnhancedHashType(decoder.ReadUint64())
5084 return _bsntlvenhancedhashcapability, nil
5085}
5086
5087func NewBsnTlvEnhancedHashCapability() *BsnTlvEnhancedHashCapability {
5088 obj := &BsnTlvEnhancedHashCapability{
5089 BsnTlv: NewBsnTlv(143),
5090 }
5091 return obj
5092}
5093
5094type BsnTlvEthDst struct {
5095 *BsnTlv
5096 Value net.HardwareAddr
5097}
5098
5099type IBsnTlvEthDst interface {
5100 IBsnTlv
5101 GetValue() net.HardwareAddr
5102}
5103
5104func (self *BsnTlvEthDst) GetValue() net.HardwareAddr {
5105 return self.Value
5106}
5107
5108func (self *BsnTlvEthDst) SetValue(v net.HardwareAddr) {
5109 self.Value = v
5110}
5111
5112func (self *BsnTlvEthDst) Serialize(encoder *goloxi.Encoder) error {
5113 startIndex := len(encoder.Bytes())
5114 if err := self.BsnTlv.Serialize(encoder); err != nil {
5115 return err
5116 }
5117
5118 encoder.Write(self.Value)
5119 length := len(encoder.Bytes()) - startIndex
5120
5121 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5122
5123 return nil
5124}
5125
5126func DecodeBsnTlvEthDst(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEthDst, error) {
5127 _bsntlvethdst := &BsnTlvEthDst{BsnTlv: parent}
5128 if decoder.Length() < 6 {
5129 return nil, fmt.Errorf("BsnTlvEthDst packet too short: %d < 6", decoder.Length())
5130 }
5131 _bsntlvethdst.Value = net.HardwareAddr(decoder.Read(6))
5132 return _bsntlvethdst, nil
5133}
5134
5135func NewBsnTlvEthDst() *BsnTlvEthDst {
5136 obj := &BsnTlvEthDst{
5137 BsnTlv: NewBsnTlv(33),
5138 }
5139 return obj
5140}
5141
5142type BsnTlvEthSrc struct {
5143 *BsnTlv
5144 Value net.HardwareAddr
5145}
5146
5147type IBsnTlvEthSrc interface {
5148 IBsnTlv
5149 GetValue() net.HardwareAddr
5150}
5151
5152func (self *BsnTlvEthSrc) GetValue() net.HardwareAddr {
5153 return self.Value
5154}
5155
5156func (self *BsnTlvEthSrc) SetValue(v net.HardwareAddr) {
5157 self.Value = v
5158}
5159
5160func (self *BsnTlvEthSrc) Serialize(encoder *goloxi.Encoder) error {
5161 startIndex := len(encoder.Bytes())
5162 if err := self.BsnTlv.Serialize(encoder); err != nil {
5163 return err
5164 }
5165
5166 encoder.Write(self.Value)
5167 length := len(encoder.Bytes()) - startIndex
5168
5169 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5170
5171 return nil
5172}
5173
5174func DecodeBsnTlvEthSrc(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEthSrc, error) {
5175 _bsntlvethsrc := &BsnTlvEthSrc{BsnTlv: parent}
5176 if decoder.Length() < 6 {
5177 return nil, fmt.Errorf("BsnTlvEthSrc packet too short: %d < 6", decoder.Length())
5178 }
5179 _bsntlvethsrc.Value = net.HardwareAddr(decoder.Read(6))
5180 return _bsntlvethsrc, nil
5181}
5182
5183func NewBsnTlvEthSrc() *BsnTlvEthSrc {
5184 obj := &BsnTlvEthSrc{
5185 BsnTlv: NewBsnTlv(32),
5186 }
5187 return obj
5188}
5189
5190type BsnTlvEthType struct {
5191 *BsnTlv
5192 Value uint16
5193}
5194
5195type IBsnTlvEthType interface {
5196 IBsnTlv
5197 GetValue() uint16
5198}
5199
5200func (self *BsnTlvEthType) GetValue() uint16 {
5201 return self.Value
5202}
5203
5204func (self *BsnTlvEthType) SetValue(v uint16) {
5205 self.Value = v
5206}
5207
5208func (self *BsnTlvEthType) Serialize(encoder *goloxi.Encoder) error {
5209 startIndex := len(encoder.Bytes())
5210 if err := self.BsnTlv.Serialize(encoder); err != nil {
5211 return err
5212 }
5213
5214 encoder.PutUint16(uint16(self.Value))
5215 length := len(encoder.Bytes()) - startIndex
5216
5217 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5218
5219 return nil
5220}
5221
5222func DecodeBsnTlvEthType(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvEthType, error) {
5223 _bsntlvethtype := &BsnTlvEthType{BsnTlv: parent}
5224 if decoder.Length() < 2 {
5225 return nil, fmt.Errorf("BsnTlvEthType packet too short: %d < 2", decoder.Length())
5226 }
5227 _bsntlvethtype.Value = uint16(decoder.ReadUint16())
5228 return _bsntlvethtype, nil
5229}
5230
5231func NewBsnTlvEthType() *BsnTlvEthType {
5232 obj := &BsnTlvEthType{
5233 BsnTlv: NewBsnTlv(131),
5234 }
5235 return obj
5236}
5237
5238type BsnTlvExternalGatewayIp struct {
5239 *BsnTlv
5240 Value net.IP
5241}
5242
5243type IBsnTlvExternalGatewayIp interface {
5244 IBsnTlv
5245 GetValue() net.IP
5246}
5247
5248func (self *BsnTlvExternalGatewayIp) GetValue() net.IP {
5249 return self.Value
5250}
5251
5252func (self *BsnTlvExternalGatewayIp) SetValue(v net.IP) {
5253 self.Value = v
5254}
5255
5256func (self *BsnTlvExternalGatewayIp) Serialize(encoder *goloxi.Encoder) error {
5257 startIndex := len(encoder.Bytes())
5258 if err := self.BsnTlv.Serialize(encoder); err != nil {
5259 return err
5260 }
5261
5262 encoder.Write(self.Value.To4())
5263 length := len(encoder.Bytes()) - startIndex
5264
5265 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5266
5267 return nil
5268}
5269
5270func DecodeBsnTlvExternalGatewayIp(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvExternalGatewayIp, error) {
5271 _bsntlvexternalgatewayip := &BsnTlvExternalGatewayIp{BsnTlv: parent}
5272 if decoder.Length() < 4 {
5273 return nil, fmt.Errorf("BsnTlvExternalGatewayIp packet too short: %d < 4", decoder.Length())
5274 }
5275 _bsntlvexternalgatewayip.Value = net.IP(decoder.Read(4))
5276 return _bsntlvexternalgatewayip, nil
5277}
5278
5279func NewBsnTlvExternalGatewayIp() *BsnTlvExternalGatewayIp {
5280 obj := &BsnTlvExternalGatewayIp{
5281 BsnTlv: NewBsnTlv(26),
5282 }
5283 return obj
5284}
5285
5286type BsnTlvExternalGatewayMac struct {
5287 *BsnTlv
5288 Value net.HardwareAddr
5289}
5290
5291type IBsnTlvExternalGatewayMac interface {
5292 IBsnTlv
5293 GetValue() net.HardwareAddr
5294}
5295
5296func (self *BsnTlvExternalGatewayMac) GetValue() net.HardwareAddr {
5297 return self.Value
5298}
5299
5300func (self *BsnTlvExternalGatewayMac) SetValue(v net.HardwareAddr) {
5301 self.Value = v
5302}
5303
5304func (self *BsnTlvExternalGatewayMac) Serialize(encoder *goloxi.Encoder) error {
5305 startIndex := len(encoder.Bytes())
5306 if err := self.BsnTlv.Serialize(encoder); err != nil {
5307 return err
5308 }
5309
5310 encoder.Write(self.Value)
5311 length := len(encoder.Bytes()) - startIndex
5312
5313 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5314
5315 return nil
5316}
5317
5318func DecodeBsnTlvExternalGatewayMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvExternalGatewayMac, error) {
5319 _bsntlvexternalgatewaymac := &BsnTlvExternalGatewayMac{BsnTlv: parent}
5320 if decoder.Length() < 6 {
5321 return nil, fmt.Errorf("BsnTlvExternalGatewayMac packet too short: %d < 6", decoder.Length())
5322 }
5323 _bsntlvexternalgatewaymac.Value = net.HardwareAddr(decoder.Read(6))
5324 return _bsntlvexternalgatewaymac, nil
5325}
5326
5327func NewBsnTlvExternalGatewayMac() *BsnTlvExternalGatewayMac {
5328 obj := &BsnTlvExternalGatewayMac{
5329 BsnTlv: NewBsnTlv(29),
5330 }
5331 return obj
5332}
5333
5334type BsnTlvExternalIp struct {
5335 *BsnTlv
5336 Value net.IP
5337}
5338
5339type IBsnTlvExternalIp interface {
5340 IBsnTlv
5341 GetValue() net.IP
5342}
5343
5344func (self *BsnTlvExternalIp) GetValue() net.IP {
5345 return self.Value
5346}
5347
5348func (self *BsnTlvExternalIp) SetValue(v net.IP) {
5349 self.Value = v
5350}
5351
5352func (self *BsnTlvExternalIp) Serialize(encoder *goloxi.Encoder) error {
5353 startIndex := len(encoder.Bytes())
5354 if err := self.BsnTlv.Serialize(encoder); err != nil {
5355 return err
5356 }
5357
5358 encoder.Write(self.Value.To4())
5359 length := len(encoder.Bytes()) - startIndex
5360
5361 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5362
5363 return nil
5364}
5365
5366func DecodeBsnTlvExternalIp(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvExternalIp, error) {
5367 _bsntlvexternalip := &BsnTlvExternalIp{BsnTlv: parent}
5368 if decoder.Length() < 4 {
5369 return nil, fmt.Errorf("BsnTlvExternalIp packet too short: %d < 4", decoder.Length())
5370 }
5371 _bsntlvexternalip.Value = net.IP(decoder.Read(4))
5372 return _bsntlvexternalip, nil
5373}
5374
5375func NewBsnTlvExternalIp() *BsnTlvExternalIp {
5376 obj := &BsnTlvExternalIp{
5377 BsnTlv: NewBsnTlv(23),
5378 }
5379 return obj
5380}
5381
5382type BsnTlvExternalMac struct {
5383 *BsnTlv
5384 Value net.HardwareAddr
5385}
5386
5387type IBsnTlvExternalMac interface {
5388 IBsnTlv
5389 GetValue() net.HardwareAddr
5390}
5391
5392func (self *BsnTlvExternalMac) GetValue() net.HardwareAddr {
5393 return self.Value
5394}
5395
5396func (self *BsnTlvExternalMac) SetValue(v net.HardwareAddr) {
5397 self.Value = v
5398}
5399
5400func (self *BsnTlvExternalMac) Serialize(encoder *goloxi.Encoder) error {
5401 startIndex := len(encoder.Bytes())
5402 if err := self.BsnTlv.Serialize(encoder); err != nil {
5403 return err
5404 }
5405
5406 encoder.Write(self.Value)
5407 length := len(encoder.Bytes()) - startIndex
5408
5409 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5410
5411 return nil
5412}
5413
5414func DecodeBsnTlvExternalMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvExternalMac, error) {
5415 _bsntlvexternalmac := &BsnTlvExternalMac{BsnTlv: parent}
5416 if decoder.Length() < 6 {
5417 return nil, fmt.Errorf("BsnTlvExternalMac packet too short: %d < 6", decoder.Length())
5418 }
5419 _bsntlvexternalmac.Value = net.HardwareAddr(decoder.Read(6))
5420 return _bsntlvexternalmac, nil
5421}
5422
5423func NewBsnTlvExternalMac() *BsnTlvExternalMac {
5424 obj := &BsnTlvExternalMac{
5425 BsnTlv: NewBsnTlv(24),
5426 }
5427 return obj
5428}
5429
5430type BsnTlvExternalNetmask struct {
5431 *BsnTlv
5432 Value net.IP
5433}
5434
5435type IBsnTlvExternalNetmask interface {
5436 IBsnTlv
5437 GetValue() net.IP
5438}
5439
5440func (self *BsnTlvExternalNetmask) GetValue() net.IP {
5441 return self.Value
5442}
5443
5444func (self *BsnTlvExternalNetmask) SetValue(v net.IP) {
5445 self.Value = v
5446}
5447
5448func (self *BsnTlvExternalNetmask) Serialize(encoder *goloxi.Encoder) error {
5449 startIndex := len(encoder.Bytes())
5450 if err := self.BsnTlv.Serialize(encoder); err != nil {
5451 return err
5452 }
5453
5454 encoder.Write(self.Value.To4())
5455 length := len(encoder.Bytes()) - startIndex
5456
5457 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5458
5459 return nil
5460}
5461
5462func DecodeBsnTlvExternalNetmask(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvExternalNetmask, error) {
5463 _bsntlvexternalnetmask := &BsnTlvExternalNetmask{BsnTlv: parent}
5464 if decoder.Length() < 4 {
5465 return nil, fmt.Errorf("BsnTlvExternalNetmask packet too short: %d < 4", decoder.Length())
5466 }
5467 _bsntlvexternalnetmask.Value = net.IP(decoder.Read(4))
5468 return _bsntlvexternalnetmask, nil
5469}
5470
5471func NewBsnTlvExternalNetmask() *BsnTlvExternalNetmask {
5472 obj := &BsnTlvExternalNetmask{
5473 BsnTlv: NewBsnTlv(25),
5474 }
5475 return obj
5476}
5477
5478type BsnTlvFabricPortRole struct {
5479 *BsnTlv
5480 Value BsnFabricPortRole
5481}
5482
5483type IBsnTlvFabricPortRole interface {
5484 IBsnTlv
5485 GetValue() BsnFabricPortRole
5486}
5487
5488func (self *BsnTlvFabricPortRole) GetValue() BsnFabricPortRole {
5489 return self.Value
5490}
5491
5492func (self *BsnTlvFabricPortRole) SetValue(v BsnFabricPortRole) {
5493 self.Value = v
5494}
5495
5496func (self *BsnTlvFabricPortRole) Serialize(encoder *goloxi.Encoder) error {
5497 startIndex := len(encoder.Bytes())
5498 if err := self.BsnTlv.Serialize(encoder); err != nil {
5499 return err
5500 }
5501
5502 encoder.PutUint16(uint16(self.Value))
5503 length := len(encoder.Bytes()) - startIndex
5504
5505 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5506
5507 return nil
5508}
5509
5510func DecodeBsnTlvFabricPortRole(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvFabricPortRole, error) {
5511 _bsntlvfabricportrole := &BsnTlvFabricPortRole{BsnTlv: parent}
5512 if decoder.Length() < 2 {
5513 return nil, fmt.Errorf("BsnTlvFabricPortRole packet too short: %d < 2", decoder.Length())
5514 }
5515 _bsntlvfabricportrole.Value = BsnFabricPortRole(decoder.ReadUint16())
5516 return _bsntlvfabricportrole, nil
5517}
5518
5519func NewBsnTlvFabricPortRole() *BsnTlvFabricPortRole {
5520 obj := &BsnTlvFabricPortRole{
5521 BsnTlv: NewBsnTlv(165),
5522 }
5523 return obj
5524}
5525
5526type BsnTlvFailCount struct {
5527 *BsnTlv
5528 Value uint64
5529}
5530
5531type IBsnTlvFailCount interface {
5532 IBsnTlv
5533 GetValue() uint64
5534}
5535
5536func (self *BsnTlvFailCount) GetValue() uint64 {
5537 return self.Value
5538}
5539
5540func (self *BsnTlvFailCount) SetValue(v uint64) {
5541 self.Value = v
5542}
5543
5544func (self *BsnTlvFailCount) Serialize(encoder *goloxi.Encoder) error {
5545 startIndex := len(encoder.Bytes())
5546 if err := self.BsnTlv.Serialize(encoder); err != nil {
5547 return err
5548 }
5549
5550 encoder.PutUint64(uint64(self.Value))
5551 length := len(encoder.Bytes()) - startIndex
5552
5553 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5554
5555 return nil
5556}
5557
5558func DecodeBsnTlvFailCount(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvFailCount, error) {
5559 _bsntlvfailcount := &BsnTlvFailCount{BsnTlv: parent}
5560 if decoder.Length() < 8 {
5561 return nil, fmt.Errorf("BsnTlvFailCount packet too short: %d < 8", decoder.Length())
5562 }
5563 _bsntlvfailcount.Value = uint64(decoder.ReadUint64())
5564 return _bsntlvfailcount, nil
5565}
5566
5567func NewBsnTlvFailCount() *BsnTlvFailCount {
5568 obj := &BsnTlvFailCount{
5569 BsnTlv: NewBsnTlv(194),
5570 }
5571 return obj
5572}
5573
5574type BsnTlvFlood struct {
5575 *BsnTlv
5576}
5577
5578type IBsnTlvFlood interface {
5579 IBsnTlv
5580}
5581
5582func (self *BsnTlvFlood) Serialize(encoder *goloxi.Encoder) error {
5583 startIndex := len(encoder.Bytes())
5584 if err := self.BsnTlv.Serialize(encoder); err != nil {
5585 return err
5586 }
5587 length := len(encoder.Bytes()) - startIndex
5588
5589 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5590
5591 return nil
5592}
5593
5594func DecodeBsnTlvFlood(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvFlood, error) {
5595 _bsntlvflood := &BsnTlvFlood{BsnTlv: parent}
5596 return _bsntlvflood, nil
5597}
5598
5599func NewBsnTlvFlood() *BsnTlvFlood {
5600 obj := &BsnTlvFlood{
5601 BsnTlv: NewBsnTlv(163),
5602 }
5603 return obj
5604}
5605
5606type BsnTlvFlowClassifier struct {
5607 *BsnTlv
5608 Value BsnFlowClassifier
5609}
5610
5611type IBsnTlvFlowClassifier interface {
5612 IBsnTlv
5613 GetValue() BsnFlowClassifier
5614}
5615
5616func (self *BsnTlvFlowClassifier) GetValue() BsnFlowClassifier {
5617 return self.Value
5618}
5619
5620func (self *BsnTlvFlowClassifier) SetValue(v BsnFlowClassifier) {
5621 self.Value = v
5622}
5623
5624func (self *BsnTlvFlowClassifier) Serialize(encoder *goloxi.Encoder) error {
5625 startIndex := len(encoder.Bytes())
5626 if err := self.BsnTlv.Serialize(encoder); err != nil {
5627 return err
5628 }
5629
5630 encoder.PutUint16(uint16(self.Value))
5631 length := len(encoder.Bytes()) - startIndex
5632
5633 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5634
5635 return nil
5636}
5637
5638func DecodeBsnTlvFlowClassifier(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvFlowClassifier, error) {
5639 _bsntlvflowclassifier := &BsnTlvFlowClassifier{BsnTlv: parent}
5640 if decoder.Length() < 2 {
5641 return nil, fmt.Errorf("BsnTlvFlowClassifier packet too short: %d < 2", decoder.Length())
5642 }
5643 _bsntlvflowclassifier.Value = BsnFlowClassifier(decoder.ReadUint16())
5644 return _bsntlvflowclassifier, nil
5645}
5646
5647func NewBsnTlvFlowClassifier() *BsnTlvFlowClassifier {
5648 obj := &BsnTlvFlowClassifier{
5649 BsnTlv: NewBsnTlv(184),
5650 }
5651 return obj
5652}
5653
5654type BsnTlvFlowClassify struct {
5655 *BsnTlv
5656}
5657
5658type IBsnTlvFlowClassify interface {
5659 IBsnTlv
5660}
5661
5662func (self *BsnTlvFlowClassify) Serialize(encoder *goloxi.Encoder) error {
5663 startIndex := len(encoder.Bytes())
5664 if err := self.BsnTlv.Serialize(encoder); err != nil {
5665 return err
5666 }
5667 length := len(encoder.Bytes()) - startIndex
5668
5669 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5670
5671 return nil
5672}
5673
5674func DecodeBsnTlvFlowClassify(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvFlowClassify, error) {
5675 _bsntlvflowclassify := &BsnTlvFlowClassify{BsnTlv: parent}
5676 return _bsntlvflowclassify, nil
5677}
5678
5679func NewBsnTlvFlowClassify() *BsnTlvFlowClassify {
5680 obj := &BsnTlvFlowClassify{
5681 BsnTlv: NewBsnTlv(182),
5682 }
5683 return obj
5684}
5685
5686type BsnTlvFlowIdentifier struct {
5687 *BsnTlv
5688 Value uint32
5689}
5690
5691type IBsnTlvFlowIdentifier interface {
5692 IBsnTlv
5693 GetValue() uint32
5694}
5695
5696func (self *BsnTlvFlowIdentifier) GetValue() uint32 {
5697 return self.Value
5698}
5699
5700func (self *BsnTlvFlowIdentifier) SetValue(v uint32) {
5701 self.Value = v
5702}
5703
5704func (self *BsnTlvFlowIdentifier) Serialize(encoder *goloxi.Encoder) error {
5705 startIndex := len(encoder.Bytes())
5706 if err := self.BsnTlv.Serialize(encoder); err != nil {
5707 return err
5708 }
5709
5710 encoder.PutUint32(uint32(self.Value))
5711 length := len(encoder.Bytes()) - startIndex
5712
5713 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5714
5715 return nil
5716}
5717
5718func DecodeBsnTlvFlowIdentifier(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvFlowIdentifier, error) {
5719 _bsntlvflowidentifier := &BsnTlvFlowIdentifier{BsnTlv: parent}
5720 if decoder.Length() < 4 {
5721 return nil, fmt.Errorf("BsnTlvFlowIdentifier packet too short: %d < 4", decoder.Length())
5722 }
5723 _bsntlvflowidentifier.Value = uint32(decoder.ReadUint32())
5724 return _bsntlvflowidentifier, nil
5725}
5726
5727func NewBsnTlvFlowIdentifier() *BsnTlvFlowIdentifier {
5728 obj := &BsnTlvFlowIdentifier{
5729 BsnTlv: NewBsnTlv(183),
5730 }
5731 return obj
5732}
5733
5734type BsnTlvForceLinkUp struct {
5735 *BsnTlv
5736}
5737
5738type IBsnTlvForceLinkUp interface {
5739 IBsnTlv
5740}
5741
5742func (self *BsnTlvForceLinkUp) Serialize(encoder *goloxi.Encoder) error {
5743 startIndex := len(encoder.Bytes())
5744 if err := self.BsnTlv.Serialize(encoder); err != nil {
5745 return err
5746 }
5747 length := len(encoder.Bytes()) - startIndex
5748
5749 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5750
5751 return nil
5752}
5753
5754func DecodeBsnTlvForceLinkUp(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvForceLinkUp, error) {
5755 _bsntlvforcelinkup := &BsnTlvForceLinkUp{BsnTlv: parent}
5756 return _bsntlvforcelinkup, nil
5757}
5758
5759func NewBsnTlvForceLinkUp() *BsnTlvForceLinkUp {
5760 obj := &BsnTlvForceLinkUp{
5761 BsnTlv: NewBsnTlv(151),
5762 }
5763 return obj
5764}
5765
5766type BsnTlvForwardErrorCorrection struct {
5767 *BsnTlv
5768 Value BsnForwardErrorCorrectionType
5769}
5770
5771type IBsnTlvForwardErrorCorrection interface {
5772 IBsnTlv
5773 GetValue() BsnForwardErrorCorrectionType
5774}
5775
5776func (self *BsnTlvForwardErrorCorrection) GetValue() BsnForwardErrorCorrectionType {
5777 return self.Value
5778}
5779
5780func (self *BsnTlvForwardErrorCorrection) SetValue(v BsnForwardErrorCorrectionType) {
5781 self.Value = v
5782}
5783
5784func (self *BsnTlvForwardErrorCorrection) Serialize(encoder *goloxi.Encoder) error {
5785 startIndex := len(encoder.Bytes())
5786 if err := self.BsnTlv.Serialize(encoder); err != nil {
5787 return err
5788 }
5789
5790 encoder.PutUint8(uint8(self.Value))
5791 length := len(encoder.Bytes()) - startIndex
5792
5793 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5794
5795 return nil
5796}
5797
5798func DecodeBsnTlvForwardErrorCorrection(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvForwardErrorCorrection, error) {
5799 _bsntlvforwarderrorcorrection := &BsnTlvForwardErrorCorrection{BsnTlv: parent}
5800 if decoder.Length() < 1 {
5801 return nil, fmt.Errorf("BsnTlvForwardErrorCorrection packet too short: %d < 1", decoder.Length())
5802 }
5803 _bsntlvforwarderrorcorrection.Value = BsnForwardErrorCorrectionType(decoder.ReadByte())
5804 return _bsntlvforwarderrorcorrection, nil
5805}
5806
5807func NewBsnTlvForwardErrorCorrection() *BsnTlvForwardErrorCorrection {
5808 obj := &BsnTlvForwardErrorCorrection{
5809 BsnTlv: NewBsnTlv(149),
5810 }
5811 return obj
5812}
5813
5814type BsnTlvGenerationId struct {
5815 *BsnTlv
5816 Value uint64
5817}
5818
5819type IBsnTlvGenerationId interface {
5820 IBsnTlv
5821 GetValue() uint64
5822}
5823
5824func (self *BsnTlvGenerationId) GetValue() uint64 {
5825 return self.Value
5826}
5827
5828func (self *BsnTlvGenerationId) SetValue(v uint64) {
5829 self.Value = v
5830}
5831
5832func (self *BsnTlvGenerationId) Serialize(encoder *goloxi.Encoder) error {
5833 startIndex := len(encoder.Bytes())
5834 if err := self.BsnTlv.Serialize(encoder); err != nil {
5835 return err
5836 }
5837
5838 encoder.PutUint64(uint64(self.Value))
5839 length := len(encoder.Bytes()) - startIndex
5840
5841 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5842
5843 return nil
5844}
5845
5846func DecodeBsnTlvGenerationId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvGenerationId, error) {
5847 _bsntlvgenerationid := &BsnTlvGenerationId{BsnTlv: parent}
5848 if decoder.Length() < 8 {
5849 return nil, fmt.Errorf("BsnTlvGenerationId packet too short: %d < 8", decoder.Length())
5850 }
5851 _bsntlvgenerationid.Value = uint64(decoder.ReadUint64())
5852 return _bsntlvgenerationid, nil
5853}
5854
5855func NewBsnTlvGenerationId() *BsnTlvGenerationId {
5856 obj := &BsnTlvGenerationId{
5857 BsnTlv: NewBsnTlv(80),
5858 }
5859 return obj
5860}
5861
5862type BsnTlvHashAlgorithm struct {
5863 *BsnTlv
5864 Value BsnHashAlgorithmType
5865}
5866
5867type IBsnTlvHashAlgorithm interface {
5868 IBsnTlv
5869 GetValue() BsnHashAlgorithmType
5870}
5871
5872func (self *BsnTlvHashAlgorithm) GetValue() BsnHashAlgorithmType {
5873 return self.Value
5874}
5875
5876func (self *BsnTlvHashAlgorithm) SetValue(v BsnHashAlgorithmType) {
5877 self.Value = v
5878}
5879
5880func (self *BsnTlvHashAlgorithm) Serialize(encoder *goloxi.Encoder) error {
5881 startIndex := len(encoder.Bytes())
5882 if err := self.BsnTlv.Serialize(encoder); err != nil {
5883 return err
5884 }
5885
5886 encoder.PutUint16(uint16(self.Value))
5887 length := len(encoder.Bytes()) - startIndex
5888
5889 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5890
5891 return nil
5892}
5893
5894func DecodeBsnTlvHashAlgorithm(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHashAlgorithm, error) {
5895 _bsntlvhashalgorithm := &BsnTlvHashAlgorithm{BsnTlv: parent}
5896 if decoder.Length() < 2 {
5897 return nil, fmt.Errorf("BsnTlvHashAlgorithm packet too short: %d < 2", decoder.Length())
5898 }
5899 _bsntlvhashalgorithm.Value = BsnHashAlgorithmType(decoder.ReadUint16())
5900 return _bsntlvhashalgorithm, nil
5901}
5902
5903func NewBsnTlvHashAlgorithm() *BsnTlvHashAlgorithm {
5904 obj := &BsnTlvHashAlgorithm{
5905 BsnTlv: NewBsnTlv(145),
5906 }
5907 return obj
5908}
5909
5910type BsnTlvHashGtpHeaderMatch struct {
5911 *BsnTlv
5912 FirstHeaderByte uint8
5913 FirstHeaderMask uint8
5914}
5915
5916type IBsnTlvHashGtpHeaderMatch interface {
5917 IBsnTlv
5918 GetFirstHeaderByte() uint8
5919 GetFirstHeaderMask() uint8
5920}
5921
5922func (self *BsnTlvHashGtpHeaderMatch) GetFirstHeaderByte() uint8 {
5923 return self.FirstHeaderByte
5924}
5925
5926func (self *BsnTlvHashGtpHeaderMatch) SetFirstHeaderByte(v uint8) {
5927 self.FirstHeaderByte = v
5928}
5929
5930func (self *BsnTlvHashGtpHeaderMatch) GetFirstHeaderMask() uint8 {
5931 return self.FirstHeaderMask
5932}
5933
5934func (self *BsnTlvHashGtpHeaderMatch) SetFirstHeaderMask(v uint8) {
5935 self.FirstHeaderMask = v
5936}
5937
5938func (self *BsnTlvHashGtpHeaderMatch) Serialize(encoder *goloxi.Encoder) error {
5939 startIndex := len(encoder.Bytes())
5940 if err := self.BsnTlv.Serialize(encoder); err != nil {
5941 return err
5942 }
5943
5944 encoder.PutUint8(uint8(self.FirstHeaderByte))
5945 encoder.PutUint8(uint8(self.FirstHeaderMask))
5946 length := len(encoder.Bytes()) - startIndex
5947
5948 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
5949
5950 return nil
5951}
5952
5953func DecodeBsnTlvHashGtpHeaderMatch(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHashGtpHeaderMatch, error) {
5954 _bsntlvhashgtpheadermatch := &BsnTlvHashGtpHeaderMatch{BsnTlv: parent}
5955 if decoder.Length() < 2 {
5956 return nil, fmt.Errorf("BsnTlvHashGtpHeaderMatch packet too short: %d < 2", decoder.Length())
5957 }
5958 _bsntlvhashgtpheadermatch.FirstHeaderByte = uint8(decoder.ReadByte())
5959 _bsntlvhashgtpheadermatch.FirstHeaderMask = uint8(decoder.ReadByte())
5960 return _bsntlvhashgtpheadermatch, nil
5961}
5962
5963func NewBsnTlvHashGtpHeaderMatch() *BsnTlvHashGtpHeaderMatch {
5964 obj := &BsnTlvHashGtpHeaderMatch{
5965 BsnTlv: NewBsnTlv(104),
5966 }
5967 return obj
5968}
5969
5970type BsnTlvHashGtpPortMatch struct {
5971 *BsnTlv
5972 Match BsnHashGtpPortMatch
5973 SrcPort uint16
5974 DstPort uint16
5975}
5976
5977type IBsnTlvHashGtpPortMatch interface {
5978 IBsnTlv
5979 GetMatch() BsnHashGtpPortMatch
5980 GetSrcPort() uint16
5981 GetDstPort() uint16
5982}
5983
5984func (self *BsnTlvHashGtpPortMatch) GetMatch() BsnHashGtpPortMatch {
5985 return self.Match
5986}
5987
5988func (self *BsnTlvHashGtpPortMatch) SetMatch(v BsnHashGtpPortMatch) {
5989 self.Match = v
5990}
5991
5992func (self *BsnTlvHashGtpPortMatch) GetSrcPort() uint16 {
5993 return self.SrcPort
5994}
5995
5996func (self *BsnTlvHashGtpPortMatch) SetSrcPort(v uint16) {
5997 self.SrcPort = v
5998}
5999
6000func (self *BsnTlvHashGtpPortMatch) GetDstPort() uint16 {
6001 return self.DstPort
6002}
6003
6004func (self *BsnTlvHashGtpPortMatch) SetDstPort(v uint16) {
6005 self.DstPort = v
6006}
6007
6008func (self *BsnTlvHashGtpPortMatch) Serialize(encoder *goloxi.Encoder) error {
6009 startIndex := len(encoder.Bytes())
6010 if err := self.BsnTlv.Serialize(encoder); err != nil {
6011 return err
6012 }
6013
6014 encoder.PutUint8(uint8(self.Match))
6015 encoder.PutUint16(uint16(self.SrcPort))
6016 encoder.PutUint16(uint16(self.DstPort))
6017 length := len(encoder.Bytes()) - startIndex
6018
6019 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6020
6021 return nil
6022}
6023
6024func DecodeBsnTlvHashGtpPortMatch(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHashGtpPortMatch, error) {
6025 _bsntlvhashgtpportmatch := &BsnTlvHashGtpPortMatch{BsnTlv: parent}
6026 if decoder.Length() < 5 {
6027 return nil, fmt.Errorf("BsnTlvHashGtpPortMatch packet too short: %d < 5", decoder.Length())
6028 }
6029 _bsntlvhashgtpportmatch.Match = BsnHashGtpPortMatch(decoder.ReadByte())
6030 _bsntlvhashgtpportmatch.SrcPort = uint16(decoder.ReadUint16())
6031 _bsntlvhashgtpportmatch.DstPort = uint16(decoder.ReadUint16())
6032 return _bsntlvhashgtpportmatch, nil
6033}
6034
6035func NewBsnTlvHashGtpPortMatch() *BsnTlvHashGtpPortMatch {
6036 obj := &BsnTlvHashGtpPortMatch{
6037 BsnTlv: NewBsnTlv(105),
6038 }
6039 return obj
6040}
6041
6042type BsnTlvHashPacketField struct {
6043 *BsnTlv
6044 Value BsnHashPacketField
6045}
6046
6047type IBsnTlvHashPacketField interface {
6048 IBsnTlv
6049 GetValue() BsnHashPacketField
6050}
6051
6052func (self *BsnTlvHashPacketField) GetValue() BsnHashPacketField {
6053 return self.Value
6054}
6055
6056func (self *BsnTlvHashPacketField) SetValue(v BsnHashPacketField) {
6057 self.Value = v
6058}
6059
6060func (self *BsnTlvHashPacketField) Serialize(encoder *goloxi.Encoder) error {
6061 startIndex := len(encoder.Bytes())
6062 if err := self.BsnTlv.Serialize(encoder); err != nil {
6063 return err
6064 }
6065
6066 encoder.PutUint64(uint64(self.Value))
6067 length := len(encoder.Bytes()) - startIndex
6068
6069 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6070
6071 return nil
6072}
6073
6074func DecodeBsnTlvHashPacketField(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHashPacketField, error) {
6075 _bsntlvhashpacketfield := &BsnTlvHashPacketField{BsnTlv: parent}
6076 if decoder.Length() < 8 {
6077 return nil, fmt.Errorf("BsnTlvHashPacketField packet too short: %d < 8", decoder.Length())
6078 }
6079 _bsntlvhashpacketfield.Value = BsnHashPacketField(decoder.ReadUint64())
6080 return _bsntlvhashpacketfield, nil
6081}
6082
6083func NewBsnTlvHashPacketField() *BsnTlvHashPacketField {
6084 obj := &BsnTlvHashPacketField{
6085 BsnTlv: NewBsnTlv(103),
6086 }
6087 return obj
6088}
6089
6090type BsnTlvHashPacketType struct {
6091 *BsnTlv
6092 Value BsnHashPacketType
6093}
6094
6095type IBsnTlvHashPacketType interface {
6096 IBsnTlv
6097 GetValue() BsnHashPacketType
6098}
6099
6100func (self *BsnTlvHashPacketType) GetValue() BsnHashPacketType {
6101 return self.Value
6102}
6103
6104func (self *BsnTlvHashPacketType) SetValue(v BsnHashPacketType) {
6105 self.Value = v
6106}
6107
6108func (self *BsnTlvHashPacketType) Serialize(encoder *goloxi.Encoder) error {
6109 startIndex := len(encoder.Bytes())
6110 if err := self.BsnTlv.Serialize(encoder); err != nil {
6111 return err
6112 }
6113
6114 encoder.PutUint8(uint8(self.Value))
6115 length := len(encoder.Bytes()) - startIndex
6116
6117 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6118
6119 return nil
6120}
6121
6122func DecodeBsnTlvHashPacketType(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHashPacketType, error) {
6123 _bsntlvhashpackettype := &BsnTlvHashPacketType{BsnTlv: parent}
6124 if decoder.Length() < 1 {
6125 return nil, fmt.Errorf("BsnTlvHashPacketType packet too short: %d < 1", decoder.Length())
6126 }
6127 _bsntlvhashpackettype.Value = BsnHashPacketType(decoder.ReadByte())
6128 return _bsntlvhashpackettype, nil
6129}
6130
6131func NewBsnTlvHashPacketType() *BsnTlvHashPacketType {
6132 obj := &BsnTlvHashPacketType{
6133 BsnTlv: NewBsnTlv(102),
6134 }
6135 return obj
6136}
6137
6138type BsnTlvHashSeed struct {
6139 *BsnTlv
6140 Seed1 uint32
6141 Seed2 uint32
6142}
6143
6144type IBsnTlvHashSeed interface {
6145 IBsnTlv
6146 GetSeed1() uint32
6147 GetSeed2() uint32
6148}
6149
6150func (self *BsnTlvHashSeed) GetSeed1() uint32 {
6151 return self.Seed1
6152}
6153
6154func (self *BsnTlvHashSeed) SetSeed1(v uint32) {
6155 self.Seed1 = v
6156}
6157
6158func (self *BsnTlvHashSeed) GetSeed2() uint32 {
6159 return self.Seed2
6160}
6161
6162func (self *BsnTlvHashSeed) SetSeed2(v uint32) {
6163 self.Seed2 = v
6164}
6165
6166func (self *BsnTlvHashSeed) Serialize(encoder *goloxi.Encoder) error {
6167 startIndex := len(encoder.Bytes())
6168 if err := self.BsnTlv.Serialize(encoder); err != nil {
6169 return err
6170 }
6171
6172 encoder.PutUint32(uint32(self.Seed1))
6173 encoder.PutUint32(uint32(self.Seed2))
6174 length := len(encoder.Bytes()) - startIndex
6175
6176 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6177
6178 return nil
6179}
6180
6181func DecodeBsnTlvHashSeed(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHashSeed, error) {
6182 _bsntlvhashseed := &BsnTlvHashSeed{BsnTlv: parent}
6183 if decoder.Length() < 8 {
6184 return nil, fmt.Errorf("BsnTlvHashSeed packet too short: %d < 8", decoder.Length())
6185 }
6186 _bsntlvhashseed.Seed1 = uint32(decoder.ReadUint32())
6187 _bsntlvhashseed.Seed2 = uint32(decoder.ReadUint32())
6188 return _bsntlvhashseed, nil
6189}
6190
6191func NewBsnTlvHashSeed() *BsnTlvHashSeed {
6192 obj := &BsnTlvHashSeed{
6193 BsnTlv: NewBsnTlv(100),
6194 }
6195 return obj
6196}
6197
6198type BsnTlvHashType struct {
6199 *BsnTlv
6200 Value BsnHashType
6201}
6202
6203type IBsnTlvHashType interface {
6204 IBsnTlv
6205 GetValue() BsnHashType
6206}
6207
6208func (self *BsnTlvHashType) GetValue() BsnHashType {
6209 return self.Value
6210}
6211
6212func (self *BsnTlvHashType) SetValue(v BsnHashType) {
6213 self.Value = v
6214}
6215
6216func (self *BsnTlvHashType) Serialize(encoder *goloxi.Encoder) error {
6217 startIndex := len(encoder.Bytes())
6218 if err := self.BsnTlv.Serialize(encoder); err != nil {
6219 return err
6220 }
6221
6222 encoder.PutUint8(uint8(self.Value))
6223 length := len(encoder.Bytes()) - startIndex
6224
6225 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6226
6227 return nil
6228}
6229
6230func DecodeBsnTlvHashType(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHashType, error) {
6231 _bsntlvhashtype := &BsnTlvHashType{BsnTlv: parent}
6232 if decoder.Length() < 1 {
6233 return nil, fmt.Errorf("BsnTlvHashType packet too short: %d < 1", decoder.Length())
6234 }
6235 _bsntlvhashtype.Value = BsnHashType(decoder.ReadByte())
6236 return _bsntlvhashtype, nil
6237}
6238
6239func NewBsnTlvHashType() *BsnTlvHashType {
6240 obj := &BsnTlvHashType{
6241 BsnTlv: NewBsnTlv(101),
6242 }
6243 return obj
6244}
6245
6246type BsnTlvHeaderSize struct {
6247 *BsnTlv
6248 Value uint32
6249}
6250
6251type IBsnTlvHeaderSize interface {
6252 IBsnTlv
6253 GetValue() uint32
6254}
6255
6256func (self *BsnTlvHeaderSize) GetValue() uint32 {
6257 return self.Value
6258}
6259
6260func (self *BsnTlvHeaderSize) SetValue(v uint32) {
6261 self.Value = v
6262}
6263
6264func (self *BsnTlvHeaderSize) Serialize(encoder *goloxi.Encoder) error {
6265 startIndex := len(encoder.Bytes())
6266 if err := self.BsnTlv.Serialize(encoder); err != nil {
6267 return err
6268 }
6269
6270 encoder.PutUint32(uint32(self.Value))
6271 length := len(encoder.Bytes()) - startIndex
6272
6273 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6274
6275 return nil
6276}
6277
6278func DecodeBsnTlvHeaderSize(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvHeaderSize, error) {
6279 _bsntlvheadersize := &BsnTlvHeaderSize{BsnTlv: parent}
6280 if decoder.Length() < 4 {
6281 return nil, fmt.Errorf("BsnTlvHeaderSize packet too short: %d < 4", decoder.Length())
6282 }
6283 _bsntlvheadersize.Value = uint32(decoder.ReadUint32())
6284 return _bsntlvheadersize, nil
6285}
6286
6287func NewBsnTlvHeaderSize() *BsnTlvHeaderSize {
6288 obj := &BsnTlvHeaderSize{
6289 BsnTlv: NewBsnTlv(31),
6290 }
6291 return obj
6292}
6293
6294type BsnTlvIcmpCode struct {
6295 *BsnTlv
6296 Value uint8
6297}
6298
6299type IBsnTlvIcmpCode interface {
6300 IBsnTlv
6301 GetValue() uint8
6302}
6303
6304func (self *BsnTlvIcmpCode) GetValue() uint8 {
6305 return self.Value
6306}
6307
6308func (self *BsnTlvIcmpCode) SetValue(v uint8) {
6309 self.Value = v
6310}
6311
6312func (self *BsnTlvIcmpCode) Serialize(encoder *goloxi.Encoder) error {
6313 startIndex := len(encoder.Bytes())
6314 if err := self.BsnTlv.Serialize(encoder); err != nil {
6315 return err
6316 }
6317
6318 encoder.PutUint8(uint8(self.Value))
6319 length := len(encoder.Bytes()) - startIndex
6320
6321 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6322
6323 return nil
6324}
6325
6326func DecodeBsnTlvIcmpCode(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIcmpCode, error) {
6327 _bsntlvicmpcode := &BsnTlvIcmpCode{BsnTlv: parent}
6328 if decoder.Length() < 1 {
6329 return nil, fmt.Errorf("BsnTlvIcmpCode packet too short: %d < 1", decoder.Length())
6330 }
6331 _bsntlvicmpcode.Value = uint8(decoder.ReadByte())
6332 return _bsntlvicmpcode, nil
6333}
6334
6335func NewBsnTlvIcmpCode() *BsnTlvIcmpCode {
6336 obj := &BsnTlvIcmpCode{
6337 BsnTlv: NewBsnTlv(69),
6338 }
6339 return obj
6340}
6341
6342type BsnTlvIcmpId struct {
6343 *BsnTlv
6344 Value uint16
6345}
6346
6347type IBsnTlvIcmpId interface {
6348 IBsnTlv
6349 GetValue() uint16
6350}
6351
6352func (self *BsnTlvIcmpId) GetValue() uint16 {
6353 return self.Value
6354}
6355
6356func (self *BsnTlvIcmpId) SetValue(v uint16) {
6357 self.Value = v
6358}
6359
6360func (self *BsnTlvIcmpId) Serialize(encoder *goloxi.Encoder) error {
6361 startIndex := len(encoder.Bytes())
6362 if err := self.BsnTlv.Serialize(encoder); err != nil {
6363 return err
6364 }
6365
6366 encoder.PutUint16(uint16(self.Value))
6367 length := len(encoder.Bytes()) - startIndex
6368
6369 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6370
6371 return nil
6372}
6373
6374func DecodeBsnTlvIcmpId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIcmpId, error) {
6375 _bsntlvicmpid := &BsnTlvIcmpId{BsnTlv: parent}
6376 if decoder.Length() < 2 {
6377 return nil, fmt.Errorf("BsnTlvIcmpId packet too short: %d < 2", decoder.Length())
6378 }
6379 _bsntlvicmpid.Value = uint16(decoder.ReadUint16())
6380 return _bsntlvicmpid, nil
6381}
6382
6383func NewBsnTlvIcmpId() *BsnTlvIcmpId {
6384 obj := &BsnTlvIcmpId{
6385 BsnTlv: NewBsnTlv(70),
6386 }
6387 return obj
6388}
6389
6390type BsnTlvIcmpType struct {
6391 *BsnTlv
6392 Value uint8
6393}
6394
6395type IBsnTlvIcmpType interface {
6396 IBsnTlv
6397 GetValue() uint8
6398}
6399
6400func (self *BsnTlvIcmpType) GetValue() uint8 {
6401 return self.Value
6402}
6403
6404func (self *BsnTlvIcmpType) SetValue(v uint8) {
6405 self.Value = v
6406}
6407
6408func (self *BsnTlvIcmpType) Serialize(encoder *goloxi.Encoder) error {
6409 startIndex := len(encoder.Bytes())
6410 if err := self.BsnTlv.Serialize(encoder); err != nil {
6411 return err
6412 }
6413
6414 encoder.PutUint8(uint8(self.Value))
6415 length := len(encoder.Bytes()) - startIndex
6416
6417 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6418
6419 return nil
6420}
6421
6422func DecodeBsnTlvIcmpType(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIcmpType, error) {
6423 _bsntlvicmptype := &BsnTlvIcmpType{BsnTlv: parent}
6424 if decoder.Length() < 1 {
6425 return nil, fmt.Errorf("BsnTlvIcmpType packet too short: %d < 1", decoder.Length())
6426 }
6427 _bsntlvicmptype.Value = uint8(decoder.ReadByte())
6428 return _bsntlvicmptype, nil
6429}
6430
6431func NewBsnTlvIcmpType() *BsnTlvIcmpType {
6432 obj := &BsnTlvIcmpType{
6433 BsnTlv: NewBsnTlv(68),
6434 }
6435 return obj
6436}
6437
6438type BsnTlvIcmpv6Chksum struct {
6439 *BsnTlv
6440 Value uint16
6441}
6442
6443type IBsnTlvIcmpv6Chksum interface {
6444 IBsnTlv
6445 GetValue() uint16
6446}
6447
6448func (self *BsnTlvIcmpv6Chksum) GetValue() uint16 {
6449 return self.Value
6450}
6451
6452func (self *BsnTlvIcmpv6Chksum) SetValue(v uint16) {
6453 self.Value = v
6454}
6455
6456func (self *BsnTlvIcmpv6Chksum) Serialize(encoder *goloxi.Encoder) error {
6457 startIndex := len(encoder.Bytes())
6458 if err := self.BsnTlv.Serialize(encoder); err != nil {
6459 return err
6460 }
6461
6462 encoder.PutUint16(uint16(self.Value))
6463 length := len(encoder.Bytes()) - startIndex
6464
6465 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6466
6467 return nil
6468}
6469
6470func DecodeBsnTlvIcmpv6Chksum(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIcmpv6Chksum, error) {
6471 _bsntlvicmpv6chksum := &BsnTlvIcmpv6Chksum{BsnTlv: parent}
6472 if decoder.Length() < 2 {
6473 return nil, fmt.Errorf("BsnTlvIcmpv6Chksum packet too short: %d < 2", decoder.Length())
6474 }
6475 _bsntlvicmpv6chksum.Value = uint16(decoder.ReadUint16())
6476 return _bsntlvicmpv6chksum, nil
6477}
6478
6479func NewBsnTlvIcmpv6Chksum() *BsnTlvIcmpv6Chksum {
6480 obj := &BsnTlvIcmpv6Chksum{
6481 BsnTlv: NewBsnTlv(125),
6482 }
6483 return obj
6484}
6485
6486type BsnTlvIdentifier struct {
6487 *BsnTlv
6488 Value uint32
6489}
6490
6491type IBsnTlvIdentifier interface {
6492 IBsnTlv
6493 GetValue() uint32
6494}
6495
6496func (self *BsnTlvIdentifier) GetValue() uint32 {
6497 return self.Value
6498}
6499
6500func (self *BsnTlvIdentifier) SetValue(v uint32) {
6501 self.Value = v
6502}
6503
6504func (self *BsnTlvIdentifier) Serialize(encoder *goloxi.Encoder) error {
6505 startIndex := len(encoder.Bytes())
6506 if err := self.BsnTlv.Serialize(encoder); err != nil {
6507 return err
6508 }
6509
6510 encoder.PutUint32(uint32(self.Value))
6511 length := len(encoder.Bytes()) - startIndex
6512
6513 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6514
6515 return nil
6516}
6517
6518func DecodeBsnTlvIdentifier(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIdentifier, error) {
6519 _bsntlvidentifier := &BsnTlvIdentifier{BsnTlv: parent}
6520 if decoder.Length() < 4 {
6521 return nil, fmt.Errorf("BsnTlvIdentifier packet too short: %d < 4", decoder.Length())
6522 }
6523 _bsntlvidentifier.Value = uint32(decoder.ReadUint32())
6524 return _bsntlvidentifier, nil
6525}
6526
6527func NewBsnTlvIdentifier() *BsnTlvIdentifier {
6528 obj := &BsnTlvIdentifier{
6529 BsnTlv: NewBsnTlv(173),
6530 }
6531 return obj
6532}
6533
6534type BsnTlvIdleNotification struct {
6535 *BsnTlv
6536}
6537
6538type IBsnTlvIdleNotification interface {
6539 IBsnTlv
6540}
6541
6542func (self *BsnTlvIdleNotification) Serialize(encoder *goloxi.Encoder) error {
6543 startIndex := len(encoder.Bytes())
6544 if err := self.BsnTlv.Serialize(encoder); err != nil {
6545 return err
6546 }
6547 length := len(encoder.Bytes()) - startIndex
6548
6549 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6550
6551 return nil
6552}
6553
6554func DecodeBsnTlvIdleNotification(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIdleNotification, error) {
6555 _bsntlvidlenotification := &BsnTlvIdleNotification{BsnTlv: parent}
6556 return _bsntlvidlenotification, nil
6557}
6558
6559func NewBsnTlvIdleNotification() *BsnTlvIdleNotification {
6560 obj := &BsnTlvIdleNotification{
6561 BsnTlv: NewBsnTlv(7),
6562 }
6563 return obj
6564}
6565
6566type BsnTlvIdleTime struct {
6567 *BsnTlv
6568 Value uint64
6569}
6570
6571type IBsnTlvIdleTime interface {
6572 IBsnTlv
6573 GetValue() uint64
6574}
6575
6576func (self *BsnTlvIdleTime) GetValue() uint64 {
6577 return self.Value
6578}
6579
6580func (self *BsnTlvIdleTime) SetValue(v uint64) {
6581 self.Value = v
6582}
6583
6584func (self *BsnTlvIdleTime) Serialize(encoder *goloxi.Encoder) error {
6585 startIndex := len(encoder.Bytes())
6586 if err := self.BsnTlv.Serialize(encoder); err != nil {
6587 return err
6588 }
6589
6590 encoder.PutUint64(uint64(self.Value))
6591 length := len(encoder.Bytes()) - startIndex
6592
6593 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6594
6595 return nil
6596}
6597
6598func DecodeBsnTlvIdleTime(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIdleTime, error) {
6599 _bsntlvidletime := &BsnTlvIdleTime{BsnTlv: parent}
6600 if decoder.Length() < 8 {
6601 return nil, fmt.Errorf("BsnTlvIdleTime packet too short: %d < 8", decoder.Length())
6602 }
6603 _bsntlvidletime.Value = uint64(decoder.ReadUint64())
6604 return _bsntlvidletime, nil
6605}
6606
6607func NewBsnTlvIdleTime() *BsnTlvIdleTime {
6608 obj := &BsnTlvIdleTime{
6609 BsnTlv: NewBsnTlv(5),
6610 }
6611 return obj
6612}
6613
6614type BsnTlvIdleTimeout struct {
6615 *BsnTlv
6616 Value uint32
6617}
6618
6619type IBsnTlvIdleTimeout interface {
6620 IBsnTlv
6621 GetValue() uint32
6622}
6623
6624func (self *BsnTlvIdleTimeout) GetValue() uint32 {
6625 return self.Value
6626}
6627
6628func (self *BsnTlvIdleTimeout) SetValue(v uint32) {
6629 self.Value = v
6630}
6631
6632func (self *BsnTlvIdleTimeout) Serialize(encoder *goloxi.Encoder) error {
6633 startIndex := len(encoder.Bytes())
6634 if err := self.BsnTlv.Serialize(encoder); err != nil {
6635 return err
6636 }
6637
6638 encoder.PutUint32(uint32(self.Value))
6639 length := len(encoder.Bytes()) - startIndex
6640
6641 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6642
6643 return nil
6644}
6645
6646func DecodeBsnTlvIdleTimeout(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIdleTimeout, error) {
6647 _bsntlvidletimeout := &BsnTlvIdleTimeout{BsnTlv: parent}
6648 if decoder.Length() < 4 {
6649 return nil, fmt.Errorf("BsnTlvIdleTimeout packet too short: %d < 4", decoder.Length())
6650 }
6651 _bsntlvidletimeout.Value = uint32(decoder.ReadUint32())
6652 return _bsntlvidletimeout, nil
6653}
6654
6655func NewBsnTlvIdleTimeout() *BsnTlvIdleTimeout {
6656 obj := &BsnTlvIdleTimeout{
6657 BsnTlv: NewBsnTlv(8),
6658 }
6659 return obj
6660}
6661
6662type BsnTlvIgmpSnooping struct {
6663 *BsnTlv
6664}
6665
6666type IBsnTlvIgmpSnooping interface {
6667 IBsnTlv
6668}
6669
6670func (self *BsnTlvIgmpSnooping) Serialize(encoder *goloxi.Encoder) error {
6671 startIndex := len(encoder.Bytes())
6672 if err := self.BsnTlv.Serialize(encoder); err != nil {
6673 return err
6674 }
6675 length := len(encoder.Bytes()) - startIndex
6676
6677 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6678
6679 return nil
6680}
6681
6682func DecodeBsnTlvIgmpSnooping(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIgmpSnooping, error) {
6683 _bsntlvigmpsnooping := &BsnTlvIgmpSnooping{BsnTlv: parent}
6684 return _bsntlvigmpsnooping, nil
6685}
6686
6687func NewBsnTlvIgmpSnooping() *BsnTlvIgmpSnooping {
6688 obj := &BsnTlvIgmpSnooping{
6689 BsnTlv: NewBsnTlv(78),
6690 }
6691 return obj
6692}
6693
6694type BsnTlvIngressPortGroupId struct {
6695 *BsnTlv
6696 Value uint32
6697}
6698
6699type IBsnTlvIngressPortGroupId interface {
6700 IBsnTlv
6701 GetValue() uint32
6702}
6703
6704func (self *BsnTlvIngressPortGroupId) GetValue() uint32 {
6705 return self.Value
6706}
6707
6708func (self *BsnTlvIngressPortGroupId) SetValue(v uint32) {
6709 self.Value = v
6710}
6711
6712func (self *BsnTlvIngressPortGroupId) Serialize(encoder *goloxi.Encoder) error {
6713 startIndex := len(encoder.Bytes())
6714 if err := self.BsnTlv.Serialize(encoder); err != nil {
6715 return err
6716 }
6717
6718 encoder.PutUint32(uint32(self.Value))
6719 length := len(encoder.Bytes()) - startIndex
6720
6721 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6722
6723 return nil
6724}
6725
6726func DecodeBsnTlvIngressPortGroupId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIngressPortGroupId, error) {
6727 _bsntlvingressportgroupid := &BsnTlvIngressPortGroupId{BsnTlv: parent}
6728 if decoder.Length() < 4 {
6729 return nil, fmt.Errorf("BsnTlvIngressPortGroupId packet too short: %d < 4", decoder.Length())
6730 }
6731 _bsntlvingressportgroupid.Value = uint32(decoder.ReadUint32())
6732 return _bsntlvingressportgroupid, nil
6733}
6734
6735func NewBsnTlvIngressPortGroupId() *BsnTlvIngressPortGroupId {
6736 obj := &BsnTlvIngressPortGroupId{
6737 BsnTlv: NewBsnTlv(138),
6738 }
6739 return obj
6740}
6741
6742type BsnTlvInternalGatewayMac struct {
6743 *BsnTlv
6744 Value net.HardwareAddr
6745}
6746
6747type IBsnTlvInternalGatewayMac interface {
6748 IBsnTlv
6749 GetValue() net.HardwareAddr
6750}
6751
6752func (self *BsnTlvInternalGatewayMac) GetValue() net.HardwareAddr {
6753 return self.Value
6754}
6755
6756func (self *BsnTlvInternalGatewayMac) SetValue(v net.HardwareAddr) {
6757 self.Value = v
6758}
6759
6760func (self *BsnTlvInternalGatewayMac) Serialize(encoder *goloxi.Encoder) error {
6761 startIndex := len(encoder.Bytes())
6762 if err := self.BsnTlv.Serialize(encoder); err != nil {
6763 return err
6764 }
6765
6766 encoder.Write(self.Value)
6767 length := len(encoder.Bytes()) - startIndex
6768
6769 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6770
6771 return nil
6772}
6773
6774func DecodeBsnTlvInternalGatewayMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvInternalGatewayMac, error) {
6775 _bsntlvinternalgatewaymac := &BsnTlvInternalGatewayMac{BsnTlv: parent}
6776 if decoder.Length() < 6 {
6777 return nil, fmt.Errorf("BsnTlvInternalGatewayMac packet too short: %d < 6", decoder.Length())
6778 }
6779 _bsntlvinternalgatewaymac.Value = net.HardwareAddr(decoder.Read(6))
6780 return _bsntlvinternalgatewaymac, nil
6781}
6782
6783func NewBsnTlvInternalGatewayMac() *BsnTlvInternalGatewayMac {
6784 obj := &BsnTlvInternalGatewayMac{
6785 BsnTlv: NewBsnTlv(28),
6786 }
6787 return obj
6788}
6789
6790type BsnTlvInternalMac struct {
6791 *BsnTlv
6792 Value net.HardwareAddr
6793}
6794
6795type IBsnTlvInternalMac interface {
6796 IBsnTlv
6797 GetValue() net.HardwareAddr
6798}
6799
6800func (self *BsnTlvInternalMac) GetValue() net.HardwareAddr {
6801 return self.Value
6802}
6803
6804func (self *BsnTlvInternalMac) SetValue(v net.HardwareAddr) {
6805 self.Value = v
6806}
6807
6808func (self *BsnTlvInternalMac) Serialize(encoder *goloxi.Encoder) error {
6809 startIndex := len(encoder.Bytes())
6810 if err := self.BsnTlv.Serialize(encoder); err != nil {
6811 return err
6812 }
6813
6814 encoder.Write(self.Value)
6815 length := len(encoder.Bytes()) - startIndex
6816
6817 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6818
6819 return nil
6820}
6821
6822func DecodeBsnTlvInternalMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvInternalMac, error) {
6823 _bsntlvinternalmac := &BsnTlvInternalMac{BsnTlv: parent}
6824 if decoder.Length() < 6 {
6825 return nil, fmt.Errorf("BsnTlvInternalMac packet too short: %d < 6", decoder.Length())
6826 }
6827 _bsntlvinternalmac.Value = net.HardwareAddr(decoder.Read(6))
6828 return _bsntlvinternalmac, nil
6829}
6830
6831func NewBsnTlvInternalMac() *BsnTlvInternalMac {
6832 obj := &BsnTlvInternalMac{
6833 BsnTlv: NewBsnTlv(27),
6834 }
6835 return obj
6836}
6837
6838type BsnTlvInterval struct {
6839 *BsnTlv
6840 Value uint32
6841}
6842
6843type IBsnTlvInterval interface {
6844 IBsnTlv
6845 GetValue() uint32
6846}
6847
6848func (self *BsnTlvInterval) GetValue() uint32 {
6849 return self.Value
6850}
6851
6852func (self *BsnTlvInterval) SetValue(v uint32) {
6853 self.Value = v
6854}
6855
6856func (self *BsnTlvInterval) Serialize(encoder *goloxi.Encoder) error {
6857 startIndex := len(encoder.Bytes())
6858 if err := self.BsnTlv.Serialize(encoder); err != nil {
6859 return err
6860 }
6861
6862 encoder.PutUint32(uint32(self.Value))
6863 length := len(encoder.Bytes()) - startIndex
6864
6865 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6866
6867 return nil
6868}
6869
6870func DecodeBsnTlvInterval(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvInterval, error) {
6871 _bsntlvinterval := &BsnTlvInterval{BsnTlv: parent}
6872 if decoder.Length() < 4 {
6873 return nil, fmt.Errorf("BsnTlvInterval packet too short: %d < 4", decoder.Length())
6874 }
6875 _bsntlvinterval.Value = uint32(decoder.ReadUint32())
6876 return _bsntlvinterval, nil
6877}
6878
6879func NewBsnTlvInterval() *BsnTlvInterval {
6880 obj := &BsnTlvInterval{
6881 BsnTlv: NewBsnTlv(58),
6882 }
6883 return obj
6884}
6885
6886type BsnTlvIpProto struct {
6887 *BsnTlv
6888 Value uint8
6889}
6890
6891type IBsnTlvIpProto interface {
6892 IBsnTlv
6893 GetValue() uint8
6894}
6895
6896func (self *BsnTlvIpProto) GetValue() uint8 {
6897 return self.Value
6898}
6899
6900func (self *BsnTlvIpProto) SetValue(v uint8) {
6901 self.Value = v
6902}
6903
6904func (self *BsnTlvIpProto) Serialize(encoder *goloxi.Encoder) error {
6905 startIndex := len(encoder.Bytes())
6906 if err := self.BsnTlv.Serialize(encoder); err != nil {
6907 return err
6908 }
6909
6910 encoder.PutUint8(uint8(self.Value))
6911 length := len(encoder.Bytes()) - startIndex
6912
6913 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6914
6915 return nil
6916}
6917
6918func DecodeBsnTlvIpProto(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpProto, error) {
6919 _bsntlvipproto := &BsnTlvIpProto{BsnTlv: parent}
6920 if decoder.Length() < 1 {
6921 return nil, fmt.Errorf("BsnTlvIpProto packet too short: %d < 1", decoder.Length())
6922 }
6923 _bsntlvipproto.Value = uint8(decoder.ReadByte())
6924 return _bsntlvipproto, nil
6925}
6926
6927func NewBsnTlvIpProto() *BsnTlvIpProto {
6928 obj := &BsnTlvIpProto{
6929 BsnTlv: NewBsnTlv(67),
6930 }
6931 return obj
6932}
6933
6934type BsnTlvIpTunnelType struct {
6935 *BsnTlv
6936 Value BsnIpTunnelType
6937}
6938
6939type IBsnTlvIpTunnelType interface {
6940 IBsnTlv
6941 GetValue() BsnIpTunnelType
6942}
6943
6944func (self *BsnTlvIpTunnelType) GetValue() BsnIpTunnelType {
6945 return self.Value
6946}
6947
6948func (self *BsnTlvIpTunnelType) SetValue(v BsnIpTunnelType) {
6949 self.Value = v
6950}
6951
6952func (self *BsnTlvIpTunnelType) Serialize(encoder *goloxi.Encoder) error {
6953 startIndex := len(encoder.Bytes())
6954 if err := self.BsnTlv.Serialize(encoder); err != nil {
6955 return err
6956 }
6957
6958 encoder.PutUint16(uint16(self.Value))
6959 length := len(encoder.Bytes()) - startIndex
6960
6961 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
6962
6963 return nil
6964}
6965
6966func DecodeBsnTlvIpTunnelType(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpTunnelType, error) {
6967 _bsntlviptunneltype := &BsnTlvIpTunnelType{BsnTlv: parent}
6968 if decoder.Length() < 2 {
6969 return nil, fmt.Errorf("BsnTlvIpTunnelType packet too short: %d < 2", decoder.Length())
6970 }
6971 _bsntlviptunneltype.Value = BsnIpTunnelType(decoder.ReadUint16())
6972 return _bsntlviptunneltype, nil
6973}
6974
6975func NewBsnTlvIpTunnelType() *BsnTlvIpTunnelType {
6976 obj := &BsnTlvIpTunnelType{
6977 BsnTlv: NewBsnTlv(169),
6978 }
6979 return obj
6980}
6981
6982type BsnTlvIpv4 struct {
6983 *BsnTlv
6984 Value net.IP
6985}
6986
6987type IBsnTlvIpv4 interface {
6988 IBsnTlv
6989 GetValue() net.IP
6990}
6991
6992func (self *BsnTlvIpv4) GetValue() net.IP {
6993 return self.Value
6994}
6995
6996func (self *BsnTlvIpv4) SetValue(v net.IP) {
6997 self.Value = v
6998}
6999
7000func (self *BsnTlvIpv4) Serialize(encoder *goloxi.Encoder) error {
7001 startIndex := len(encoder.Bytes())
7002 if err := self.BsnTlv.Serialize(encoder); err != nil {
7003 return err
7004 }
7005
7006 encoder.Write(self.Value.To4())
7007 length := len(encoder.Bytes()) - startIndex
7008
7009 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7010
7011 return nil
7012}
7013
7014func DecodeBsnTlvIpv4(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv4, error) {
7015 _bsntlvipv4 := &BsnTlvIpv4{BsnTlv: parent}
7016 if decoder.Length() < 4 {
7017 return nil, fmt.Errorf("BsnTlvIpv4 packet too short: %d < 4", decoder.Length())
7018 }
7019 _bsntlvipv4.Value = net.IP(decoder.Read(4))
7020 return _bsntlvipv4, nil
7021}
7022
7023func NewBsnTlvIpv4() *BsnTlvIpv4 {
7024 obj := &BsnTlvIpv4{
7025 BsnTlv: NewBsnTlv(4),
7026 }
7027 return obj
7028}
7029
7030type BsnTlvIpv4Dst struct {
7031 *BsnTlv
7032 Value net.IP
7033}
7034
7035type IBsnTlvIpv4Dst interface {
7036 IBsnTlv
7037 GetValue() net.IP
7038}
7039
7040func (self *BsnTlvIpv4Dst) GetValue() net.IP {
7041 return self.Value
7042}
7043
7044func (self *BsnTlvIpv4Dst) SetValue(v net.IP) {
7045 self.Value = v
7046}
7047
7048func (self *BsnTlvIpv4Dst) Serialize(encoder *goloxi.Encoder) error {
7049 startIndex := len(encoder.Bytes())
7050 if err := self.BsnTlv.Serialize(encoder); err != nil {
7051 return err
7052 }
7053
7054 encoder.Write(self.Value.To4())
7055 length := len(encoder.Bytes()) - startIndex
7056
7057 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7058
7059 return nil
7060}
7061
7062func DecodeBsnTlvIpv4Dst(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv4Dst, error) {
7063 _bsntlvipv4dst := &BsnTlvIpv4Dst{BsnTlv: parent}
7064 if decoder.Length() < 4 {
7065 return nil, fmt.Errorf("BsnTlvIpv4Dst packet too short: %d < 4", decoder.Length())
7066 }
7067 _bsntlvipv4dst.Value = net.IP(decoder.Read(4))
7068 return _bsntlvipv4dst, nil
7069}
7070
7071func NewBsnTlvIpv4Dst() *BsnTlvIpv4Dst {
7072 obj := &BsnTlvIpv4Dst{
7073 BsnTlv: NewBsnTlv(35),
7074 }
7075 return obj
7076}
7077
7078type BsnTlvIpv4Netmask struct {
7079 *BsnTlv
7080 Value net.IP
7081}
7082
7083type IBsnTlvIpv4Netmask interface {
7084 IBsnTlv
7085 GetValue() net.IP
7086}
7087
7088func (self *BsnTlvIpv4Netmask) GetValue() net.IP {
7089 return self.Value
7090}
7091
7092func (self *BsnTlvIpv4Netmask) SetValue(v net.IP) {
7093 self.Value = v
7094}
7095
7096func (self *BsnTlvIpv4Netmask) Serialize(encoder *goloxi.Encoder) error {
7097 startIndex := len(encoder.Bytes())
7098 if err := self.BsnTlv.Serialize(encoder); err != nil {
7099 return err
7100 }
7101
7102 encoder.Write(self.Value.To4())
7103 length := len(encoder.Bytes()) - startIndex
7104
7105 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7106
7107 return nil
7108}
7109
7110func DecodeBsnTlvIpv4Netmask(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv4Netmask, error) {
7111 _bsntlvipv4netmask := &BsnTlvIpv4Netmask{BsnTlv: parent}
7112 if decoder.Length() < 4 {
7113 return nil, fmt.Errorf("BsnTlvIpv4Netmask packet too short: %d < 4", decoder.Length())
7114 }
7115 _bsntlvipv4netmask.Value = net.IP(decoder.Read(4))
7116 return _bsntlvipv4netmask, nil
7117}
7118
7119func NewBsnTlvIpv4Netmask() *BsnTlvIpv4Netmask {
7120 obj := &BsnTlvIpv4Netmask{
7121 BsnTlv: NewBsnTlv(60),
7122 }
7123 return obj
7124}
7125
7126type BsnTlvIpv4Src struct {
7127 *BsnTlv
7128 Value net.IP
7129}
7130
7131type IBsnTlvIpv4Src interface {
7132 IBsnTlv
7133 GetValue() net.IP
7134}
7135
7136func (self *BsnTlvIpv4Src) GetValue() net.IP {
7137 return self.Value
7138}
7139
7140func (self *BsnTlvIpv4Src) SetValue(v net.IP) {
7141 self.Value = v
7142}
7143
7144func (self *BsnTlvIpv4Src) Serialize(encoder *goloxi.Encoder) error {
7145 startIndex := len(encoder.Bytes())
7146 if err := self.BsnTlv.Serialize(encoder); err != nil {
7147 return err
7148 }
7149
7150 encoder.Write(self.Value.To4())
7151 length := len(encoder.Bytes()) - startIndex
7152
7153 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7154
7155 return nil
7156}
7157
7158func DecodeBsnTlvIpv4Src(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv4Src, error) {
7159 _bsntlvipv4src := &BsnTlvIpv4Src{BsnTlv: parent}
7160 if decoder.Length() < 4 {
7161 return nil, fmt.Errorf("BsnTlvIpv4Src packet too short: %d < 4", decoder.Length())
7162 }
7163 _bsntlvipv4src.Value = net.IP(decoder.Read(4))
7164 return _bsntlvipv4src, nil
7165}
7166
7167func NewBsnTlvIpv4Src() *BsnTlvIpv4Src {
7168 obj := &BsnTlvIpv4Src{
7169 BsnTlv: NewBsnTlv(34),
7170 }
7171 return obj
7172}
7173
7174type BsnTlvIpv6 struct {
7175 *BsnTlv
7176 Value net.IP
7177}
7178
7179type IBsnTlvIpv6 interface {
7180 IBsnTlv
7181 GetValue() net.IP
7182}
7183
7184func (self *BsnTlvIpv6) GetValue() net.IP {
7185 return self.Value
7186}
7187
7188func (self *BsnTlvIpv6) SetValue(v net.IP) {
7189 self.Value = v
7190}
7191
7192func (self *BsnTlvIpv6) Serialize(encoder *goloxi.Encoder) error {
7193 startIndex := len(encoder.Bytes())
7194 if err := self.BsnTlv.Serialize(encoder); err != nil {
7195 return err
7196 }
7197
7198 encoder.Write(self.Value.To16())
7199 length := len(encoder.Bytes()) - startIndex
7200
7201 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7202
7203 return nil
7204}
7205
7206func DecodeBsnTlvIpv6(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv6, error) {
7207 _bsntlvipv6 := &BsnTlvIpv6{BsnTlv: parent}
7208 if decoder.Length() < 16 {
7209 return nil, fmt.Errorf("BsnTlvIpv6 packet too short: %d < 16", decoder.Length())
7210 }
7211 _bsntlvipv6.Value = net.IP(decoder.Read(16))
7212 return _bsntlvipv6, nil
7213}
7214
7215func NewBsnTlvIpv6() *BsnTlvIpv6 {
7216 obj := &BsnTlvIpv6{
7217 BsnTlv: NewBsnTlv(84),
7218 }
7219 return obj
7220}
7221
7222type BsnTlvIpv6Dst struct {
7223 *BsnTlv
7224 Value net.IP
7225}
7226
7227type IBsnTlvIpv6Dst interface {
7228 IBsnTlv
7229 GetValue() net.IP
7230}
7231
7232func (self *BsnTlvIpv6Dst) GetValue() net.IP {
7233 return self.Value
7234}
7235
7236func (self *BsnTlvIpv6Dst) SetValue(v net.IP) {
7237 self.Value = v
7238}
7239
7240func (self *BsnTlvIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
7241 startIndex := len(encoder.Bytes())
7242 if err := self.BsnTlv.Serialize(encoder); err != nil {
7243 return err
7244 }
7245
7246 encoder.Write(self.Value.To16())
7247 length := len(encoder.Bytes()) - startIndex
7248
7249 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7250
7251 return nil
7252}
7253
7254func DecodeBsnTlvIpv6Dst(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv6Dst, error) {
7255 _bsntlvipv6dst := &BsnTlvIpv6Dst{BsnTlv: parent}
7256 if decoder.Length() < 16 {
7257 return nil, fmt.Errorf("BsnTlvIpv6Dst packet too short: %d < 16", decoder.Length())
7258 }
7259 _bsntlvipv6dst.Value = net.IP(decoder.Read(16))
7260 return _bsntlvipv6dst, nil
7261}
7262
7263func NewBsnTlvIpv6Dst() *BsnTlvIpv6Dst {
7264 obj := &BsnTlvIpv6Dst{
7265 BsnTlv: NewBsnTlv(127),
7266 }
7267 return obj
7268}
7269
7270type BsnTlvIpv6Prefix struct {
7271 *BsnTlv
7272 Value net.IP
7273 PrefixLength uint8
7274}
7275
7276type IBsnTlvIpv6Prefix interface {
7277 IBsnTlv
7278 GetValue() net.IP
7279 GetPrefixLength() uint8
7280}
7281
7282func (self *BsnTlvIpv6Prefix) GetValue() net.IP {
7283 return self.Value
7284}
7285
7286func (self *BsnTlvIpv6Prefix) SetValue(v net.IP) {
7287 self.Value = v
7288}
7289
7290func (self *BsnTlvIpv6Prefix) GetPrefixLength() uint8 {
7291 return self.PrefixLength
7292}
7293
7294func (self *BsnTlvIpv6Prefix) SetPrefixLength(v uint8) {
7295 self.PrefixLength = v
7296}
7297
7298func (self *BsnTlvIpv6Prefix) Serialize(encoder *goloxi.Encoder) error {
7299 startIndex := len(encoder.Bytes())
7300 if err := self.BsnTlv.Serialize(encoder); err != nil {
7301 return err
7302 }
7303
7304 encoder.Write(self.Value.To16())
7305 encoder.PutUint8(uint8(self.PrefixLength))
7306 length := len(encoder.Bytes()) - startIndex
7307
7308 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7309
7310 return nil
7311}
7312
7313func DecodeBsnTlvIpv6Prefix(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv6Prefix, error) {
7314 _bsntlvipv6prefix := &BsnTlvIpv6Prefix{BsnTlv: parent}
7315 if decoder.Length() < 17 {
7316 return nil, fmt.Errorf("BsnTlvIpv6Prefix packet too short: %d < 17", decoder.Length())
7317 }
7318 _bsntlvipv6prefix.Value = net.IP(decoder.Read(16))
7319 _bsntlvipv6prefix.PrefixLength = uint8(decoder.ReadByte())
7320 return _bsntlvipv6prefix, nil
7321}
7322
7323func NewBsnTlvIpv6Prefix() *BsnTlvIpv6Prefix {
7324 obj := &BsnTlvIpv6Prefix{
7325 BsnTlv: NewBsnTlv(122),
7326 }
7327 return obj
7328}
7329
7330type BsnTlvIpv6Src struct {
7331 *BsnTlv
7332 Value net.IP
7333}
7334
7335type IBsnTlvIpv6Src interface {
7336 IBsnTlv
7337 GetValue() net.IP
7338}
7339
7340func (self *BsnTlvIpv6Src) GetValue() net.IP {
7341 return self.Value
7342}
7343
7344func (self *BsnTlvIpv6Src) SetValue(v net.IP) {
7345 self.Value = v
7346}
7347
7348func (self *BsnTlvIpv6Src) Serialize(encoder *goloxi.Encoder) error {
7349 startIndex := len(encoder.Bytes())
7350 if err := self.BsnTlv.Serialize(encoder); err != nil {
7351 return err
7352 }
7353
7354 encoder.Write(self.Value.To16())
7355 length := len(encoder.Bytes()) - startIndex
7356
7357 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7358
7359 return nil
7360}
7361
7362func DecodeBsnTlvIpv6Src(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvIpv6Src, error) {
7363 _bsntlvipv6src := &BsnTlvIpv6Src{BsnTlv: parent}
7364 if decoder.Length() < 16 {
7365 return nil, fmt.Errorf("BsnTlvIpv6Src packet too short: %d < 16", decoder.Length())
7366 }
7367 _bsntlvipv6src.Value = net.IP(decoder.Read(16))
7368 return _bsntlvipv6src, nil
7369}
7370
7371func NewBsnTlvIpv6Src() *BsnTlvIpv6Src {
7372 obj := &BsnTlvIpv6Src{
7373 BsnTlv: NewBsnTlv(126),
7374 }
7375 return obj
7376}
7377
7378type BsnTlvKnownMulticastRate struct {
7379 *BsnTlv
7380 Value uint32
7381}
7382
7383type IBsnTlvKnownMulticastRate interface {
7384 IBsnTlv
7385 GetValue() uint32
7386}
7387
7388func (self *BsnTlvKnownMulticastRate) GetValue() uint32 {
7389 return self.Value
7390}
7391
7392func (self *BsnTlvKnownMulticastRate) SetValue(v uint32) {
7393 self.Value = v
7394}
7395
7396func (self *BsnTlvKnownMulticastRate) Serialize(encoder *goloxi.Encoder) error {
7397 startIndex := len(encoder.Bytes())
7398 if err := self.BsnTlv.Serialize(encoder); err != nil {
7399 return err
7400 }
7401
7402 encoder.PutUint32(uint32(self.Value))
7403 length := len(encoder.Bytes()) - startIndex
7404
7405 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7406
7407 return nil
7408}
7409
7410func DecodeBsnTlvKnownMulticastRate(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvKnownMulticastRate, error) {
7411 _bsntlvknownmulticastrate := &BsnTlvKnownMulticastRate{BsnTlv: parent}
7412 if decoder.Length() < 4 {
7413 return nil, fmt.Errorf("BsnTlvKnownMulticastRate packet too short: %d < 4", decoder.Length())
7414 }
7415 _bsntlvknownmulticastrate.Value = uint32(decoder.ReadUint32())
7416 return _bsntlvknownmulticastrate, nil
7417}
7418
7419func NewBsnTlvKnownMulticastRate() *BsnTlvKnownMulticastRate {
7420 obj := &BsnTlvKnownMulticastRate{
7421 BsnTlv: NewBsnTlv(91),
7422 }
7423 return obj
7424}
7425
7426type BsnTlvL2MulticastLookup struct {
7427 *BsnTlv
7428}
7429
7430type IBsnTlvL2MulticastLookup interface {
7431 IBsnTlv
7432}
7433
7434func (self *BsnTlvL2MulticastLookup) Serialize(encoder *goloxi.Encoder) error {
7435 startIndex := len(encoder.Bytes())
7436 if err := self.BsnTlv.Serialize(encoder); err != nil {
7437 return err
7438 }
7439 length := len(encoder.Bytes()) - startIndex
7440
7441 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7442
7443 return nil
7444}
7445
7446func DecodeBsnTlvL2MulticastLookup(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvL2MulticastLookup, error) {
7447 _bsntlvl2multicastlookup := &BsnTlvL2MulticastLookup{BsnTlv: parent}
7448 return _bsntlvl2multicastlookup, nil
7449}
7450
7451func NewBsnTlvL2MulticastLookup() *BsnTlvL2MulticastLookup {
7452 obj := &BsnTlvL2MulticastLookup{
7453 BsnTlv: NewBsnTlv(79),
7454 }
7455 return obj
7456}
7457
7458type BsnTlvL3 struct {
7459 *BsnTlv
7460}
7461
7462type IBsnTlvL3 interface {
7463 IBsnTlv
7464}
7465
7466func (self *BsnTlvL3) Serialize(encoder *goloxi.Encoder) error {
7467 startIndex := len(encoder.Bytes())
7468 if err := self.BsnTlv.Serialize(encoder); err != nil {
7469 return err
7470 }
7471 length := len(encoder.Bytes()) - startIndex
7472
7473 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7474
7475 return nil
7476}
7477
7478func DecodeBsnTlvL3(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvL3, error) {
7479 _bsntlvl3 := &BsnTlvL3{BsnTlv: parent}
7480 return _bsntlvl3, nil
7481}
7482
7483func NewBsnTlvL3() *BsnTlvL3 {
7484 obj := &BsnTlvL3{
7485 BsnTlv: NewBsnTlv(168),
7486 }
7487 return obj
7488}
7489
7490type BsnTlvL3DstClassId struct {
7491 *BsnTlv
7492 Value uint32
7493}
7494
7495type IBsnTlvL3DstClassId interface {
7496 IBsnTlv
7497 GetValue() uint32
7498}
7499
7500func (self *BsnTlvL3DstClassId) GetValue() uint32 {
7501 return self.Value
7502}
7503
7504func (self *BsnTlvL3DstClassId) SetValue(v uint32) {
7505 self.Value = v
7506}
7507
7508func (self *BsnTlvL3DstClassId) Serialize(encoder *goloxi.Encoder) error {
7509 startIndex := len(encoder.Bytes())
7510 if err := self.BsnTlv.Serialize(encoder); err != nil {
7511 return err
7512 }
7513
7514 encoder.PutUint32(uint32(self.Value))
7515 length := len(encoder.Bytes()) - startIndex
7516
7517 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7518
7519 return nil
7520}
7521
7522func DecodeBsnTlvL3DstClassId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvL3DstClassId, error) {
7523 _bsntlvl3dstclassid := &BsnTlvL3DstClassId{BsnTlv: parent}
7524 if decoder.Length() < 4 {
7525 return nil, fmt.Errorf("BsnTlvL3DstClassId packet too short: %d < 4", decoder.Length())
7526 }
7527 _bsntlvl3dstclassid.Value = uint32(decoder.ReadUint32())
7528 return _bsntlvl3dstclassid, nil
7529}
7530
7531func NewBsnTlvL3DstClassId() *BsnTlvL3DstClassId {
7532 obj := &BsnTlvL3DstClassId{
7533 BsnTlv: NewBsnTlv(136),
7534 }
7535 return obj
7536}
7537
7538type BsnTlvL3InterfaceClassId struct {
7539 *BsnTlv
7540 Value uint32
7541}
7542
7543type IBsnTlvL3InterfaceClassId interface {
7544 IBsnTlv
7545 GetValue() uint32
7546}
7547
7548func (self *BsnTlvL3InterfaceClassId) GetValue() uint32 {
7549 return self.Value
7550}
7551
7552func (self *BsnTlvL3InterfaceClassId) SetValue(v uint32) {
7553 self.Value = v
7554}
7555
7556func (self *BsnTlvL3InterfaceClassId) Serialize(encoder *goloxi.Encoder) error {
7557 startIndex := len(encoder.Bytes())
7558 if err := self.BsnTlv.Serialize(encoder); err != nil {
7559 return err
7560 }
7561
7562 encoder.PutUint32(uint32(self.Value))
7563 length := len(encoder.Bytes()) - startIndex
7564
7565 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7566
7567 return nil
7568}
7569
7570func DecodeBsnTlvL3InterfaceClassId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvL3InterfaceClassId, error) {
7571 _bsntlvl3interfaceclassid := &BsnTlvL3InterfaceClassId{BsnTlv: parent}
7572 if decoder.Length() < 4 {
7573 return nil, fmt.Errorf("BsnTlvL3InterfaceClassId packet too short: %d < 4", decoder.Length())
7574 }
7575 _bsntlvl3interfaceclassid.Value = uint32(decoder.ReadUint32())
7576 return _bsntlvl3interfaceclassid, nil
7577}
7578
7579func NewBsnTlvL3InterfaceClassId() *BsnTlvL3InterfaceClassId {
7580 obj := &BsnTlvL3InterfaceClassId{
7581 BsnTlv: NewBsnTlv(134),
7582 }
7583 return obj
7584}
7585
7586type BsnTlvL3SrcClassId struct {
7587 *BsnTlv
7588 Value uint32
7589}
7590
7591type IBsnTlvL3SrcClassId interface {
7592 IBsnTlv
7593 GetValue() uint32
7594}
7595
7596func (self *BsnTlvL3SrcClassId) GetValue() uint32 {
7597 return self.Value
7598}
7599
7600func (self *BsnTlvL3SrcClassId) SetValue(v uint32) {
7601 self.Value = v
7602}
7603
7604func (self *BsnTlvL3SrcClassId) Serialize(encoder *goloxi.Encoder) error {
7605 startIndex := len(encoder.Bytes())
7606 if err := self.BsnTlv.Serialize(encoder); err != nil {
7607 return err
7608 }
7609
7610 encoder.PutUint32(uint32(self.Value))
7611 length := len(encoder.Bytes()) - startIndex
7612
7613 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7614
7615 return nil
7616}
7617
7618func DecodeBsnTlvL3SrcClassId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvL3SrcClassId, error) {
7619 _bsntlvl3srcclassid := &BsnTlvL3SrcClassId{BsnTlv: parent}
7620 if decoder.Length() < 4 {
7621 return nil, fmt.Errorf("BsnTlvL3SrcClassId packet too short: %d < 4", decoder.Length())
7622 }
7623 _bsntlvl3srcclassid.Value = uint32(decoder.ReadUint32())
7624 return _bsntlvl3srcclassid, nil
7625}
7626
7627func NewBsnTlvL3SrcClassId() *BsnTlvL3SrcClassId {
7628 obj := &BsnTlvL3SrcClassId{
7629 BsnTlv: NewBsnTlv(135),
7630 }
7631 return obj
7632}
7633
7634type BsnTlvLagOptions struct {
7635 *BsnTlv
7636 Flags BsnLagFlag
7637}
7638
7639type IBsnTlvLagOptions interface {
7640 IBsnTlv
7641 GetFlags() BsnLagFlag
7642}
7643
7644func (self *BsnTlvLagOptions) GetFlags() BsnLagFlag {
7645 return self.Flags
7646}
7647
7648func (self *BsnTlvLagOptions) SetFlags(v BsnLagFlag) {
7649 self.Flags = v
7650}
7651
7652func (self *BsnTlvLagOptions) Serialize(encoder *goloxi.Encoder) error {
7653 startIndex := len(encoder.Bytes())
7654 if err := self.BsnTlv.Serialize(encoder); err != nil {
7655 return err
7656 }
7657
7658 encoder.PutUint16(uint16(self.Flags))
7659 length := len(encoder.Bytes()) - startIndex
7660
7661 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7662
7663 return nil
7664}
7665
7666func DecodeBsnTlvLagOptions(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvLagOptions, error) {
7667 _bsntlvlagoptions := &BsnTlvLagOptions{BsnTlv: parent}
7668 if decoder.Length() < 2 {
7669 return nil, fmt.Errorf("BsnTlvLagOptions packet too short: %d < 2", decoder.Length())
7670 }
7671 _bsntlvlagoptions.Flags = BsnLagFlag(decoder.ReadUint16())
7672 return _bsntlvlagoptions, nil
7673}
7674
7675func NewBsnTlvLagOptions() *BsnTlvLagOptions {
7676 obj := &BsnTlvLagOptions{
7677 BsnTlv: NewBsnTlv(160),
7678 }
7679 return obj
7680}
7681
7682type BsnTlvLinkUp struct {
7683 *BsnTlv
7684}
7685
7686type IBsnTlvLinkUp interface {
7687 IBsnTlv
7688}
7689
7690func (self *BsnTlvLinkUp) Serialize(encoder *goloxi.Encoder) error {
7691 startIndex := len(encoder.Bytes())
7692 if err := self.BsnTlv.Serialize(encoder); err != nil {
7693 return err
7694 }
7695 length := len(encoder.Bytes()) - startIndex
7696
7697 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7698
7699 return nil
7700}
7701
7702func DecodeBsnTlvLinkUp(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvLinkUp, error) {
7703 _bsntlvlinkup := &BsnTlvLinkUp{BsnTlv: parent}
7704 return _bsntlvlinkup, nil
7705}
7706
7707func NewBsnTlvLinkUp() *BsnTlvLinkUp {
7708 obj := &BsnTlvLinkUp{
7709 BsnTlv: NewBsnTlv(193),
7710 }
7711 return obj
7712}
7713
7714type BsnTlvLoopbackMode struct {
7715 *BsnTlv
7716 Value BsnLoopbackMode
7717}
7718
7719type IBsnTlvLoopbackMode interface {
7720 IBsnTlv
7721 GetValue() BsnLoopbackMode
7722}
7723
7724func (self *BsnTlvLoopbackMode) GetValue() BsnLoopbackMode {
7725 return self.Value
7726}
7727
7728func (self *BsnTlvLoopbackMode) SetValue(v BsnLoopbackMode) {
7729 self.Value = v
7730}
7731
7732func (self *BsnTlvLoopbackMode) Serialize(encoder *goloxi.Encoder) error {
7733 startIndex := len(encoder.Bytes())
7734 if err := self.BsnTlv.Serialize(encoder); err != nil {
7735 return err
7736 }
7737
7738 encoder.PutUint8(uint8(self.Value))
7739 length := len(encoder.Bytes()) - startIndex
7740
7741 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7742
7743 return nil
7744}
7745
7746func DecodeBsnTlvLoopbackMode(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvLoopbackMode, error) {
7747 _bsntlvloopbackmode := &BsnTlvLoopbackMode{BsnTlv: parent}
7748 if decoder.Length() < 1 {
7749 return nil, fmt.Errorf("BsnTlvLoopbackMode packet too short: %d < 1", decoder.Length())
7750 }
7751 _bsntlvloopbackmode.Value = BsnLoopbackMode(decoder.ReadByte())
7752 return _bsntlvloopbackmode, nil
7753}
7754
7755func NewBsnTlvLoopbackMode() *BsnTlvLoopbackMode {
7756 obj := &BsnTlvLoopbackMode{
7757 BsnTlv: NewBsnTlv(146),
7758 }
7759 return obj
7760}
7761
7762type BsnTlvLoopbackPort struct {
7763 *BsnTlv
7764 Value Port
7765}
7766
7767type IBsnTlvLoopbackPort interface {
7768 IBsnTlv
7769 GetValue() Port
7770}
7771
7772func (self *BsnTlvLoopbackPort) GetValue() Port {
7773 return self.Value
7774}
7775
7776func (self *BsnTlvLoopbackPort) SetValue(v Port) {
7777 self.Value = v
7778}
7779
7780func (self *BsnTlvLoopbackPort) Serialize(encoder *goloxi.Encoder) error {
7781 startIndex := len(encoder.Bytes())
7782 if err := self.BsnTlv.Serialize(encoder); err != nil {
7783 return err
7784 }
7785
7786 self.Value.Serialize(encoder)
7787 length := len(encoder.Bytes()) - startIndex
7788
7789 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7790
7791 return nil
7792}
7793
7794func DecodeBsnTlvLoopbackPort(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvLoopbackPort, error) {
7795 _bsntlvloopbackport := &BsnTlvLoopbackPort{BsnTlv: parent}
7796 if decoder.Length() < 4 {
7797 return nil, fmt.Errorf("BsnTlvLoopbackPort packet too short: %d < 4", decoder.Length())
7798 }
7799 _bsntlvloopbackport.Value.Decode(decoder)
7800 return _bsntlvloopbackport, nil
7801}
7802
7803func NewBsnTlvLoopbackPort() *BsnTlvLoopbackPort {
7804 obj := &BsnTlvLoopbackPort{
7805 BsnTlv: NewBsnTlv(110),
7806 }
7807 return obj
7808}
7809
7810type BsnTlvLossless struct {
7811 *BsnTlv
7812}
7813
7814type IBsnTlvLossless interface {
7815 IBsnTlv
7816}
7817
7818func (self *BsnTlvLossless) Serialize(encoder *goloxi.Encoder) error {
7819 startIndex := len(encoder.Bytes())
7820 if err := self.BsnTlv.Serialize(encoder); err != nil {
7821 return err
7822 }
7823 length := len(encoder.Bytes()) - startIndex
7824
7825 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7826
7827 return nil
7828}
7829
7830func DecodeBsnTlvLossless(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvLossless, error) {
7831 _bsntlvlossless := &BsnTlvLossless{BsnTlv: parent}
7832 return _bsntlvlossless, nil
7833}
7834
7835func NewBsnTlvLossless() *BsnTlvLossless {
7836 obj := &BsnTlvLossless{
7837 BsnTlv: NewBsnTlv(188),
7838 }
7839 return obj
7840}
7841
7842type BsnTlvLrAllEnabled struct {
7843 *BsnTlv
7844}
7845
7846type IBsnTlvLrAllEnabled interface {
7847 IBsnTlv
7848}
7849
7850func (self *BsnTlvLrAllEnabled) Serialize(encoder *goloxi.Encoder) error {
7851 startIndex := len(encoder.Bytes())
7852 if err := self.BsnTlv.Serialize(encoder); err != nil {
7853 return err
7854 }
7855 length := len(encoder.Bytes()) - startIndex
7856
7857 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7858
7859 return nil
7860}
7861
7862func DecodeBsnTlvLrAllEnabled(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvLrAllEnabled, error) {
7863 _bsntlvlrallenabled := &BsnTlvLrAllEnabled{BsnTlv: parent}
7864 return _bsntlvlrallenabled, nil
7865}
7866
7867func NewBsnTlvLrAllEnabled() *BsnTlvLrAllEnabled {
7868 obj := &BsnTlvLrAllEnabled{
7869 BsnTlv: NewBsnTlv(178),
7870 }
7871 return obj
7872}
7873
7874type BsnTlvMac struct {
7875 *BsnTlv
7876 Value net.HardwareAddr
7877}
7878
7879type IBsnTlvMac interface {
7880 IBsnTlv
7881 GetValue() net.HardwareAddr
7882}
7883
7884func (self *BsnTlvMac) GetValue() net.HardwareAddr {
7885 return self.Value
7886}
7887
7888func (self *BsnTlvMac) SetValue(v net.HardwareAddr) {
7889 self.Value = v
7890}
7891
7892func (self *BsnTlvMac) Serialize(encoder *goloxi.Encoder) error {
7893 startIndex := len(encoder.Bytes())
7894 if err := self.BsnTlv.Serialize(encoder); err != nil {
7895 return err
7896 }
7897
7898 encoder.Write(self.Value)
7899 length := len(encoder.Bytes()) - startIndex
7900
7901 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7902
7903 return nil
7904}
7905
7906func DecodeBsnTlvMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMac, error) {
7907 _bsntlvmac := &BsnTlvMac{BsnTlv: parent}
7908 if decoder.Length() < 6 {
7909 return nil, fmt.Errorf("BsnTlvMac packet too short: %d < 6", decoder.Length())
7910 }
7911 _bsntlvmac.Value = net.HardwareAddr(decoder.Read(6))
7912 return _bsntlvmac, nil
7913}
7914
7915func NewBsnTlvMac() *BsnTlvMac {
7916 obj := &BsnTlvMac{
7917 BsnTlv: NewBsnTlv(1),
7918 }
7919 return obj
7920}
7921
7922type BsnTlvMacMask struct {
7923 *BsnTlv
7924 Value net.HardwareAddr
7925}
7926
7927type IBsnTlvMacMask interface {
7928 IBsnTlv
7929 GetValue() net.HardwareAddr
7930}
7931
7932func (self *BsnTlvMacMask) GetValue() net.HardwareAddr {
7933 return self.Value
7934}
7935
7936func (self *BsnTlvMacMask) SetValue(v net.HardwareAddr) {
7937 self.Value = v
7938}
7939
7940func (self *BsnTlvMacMask) Serialize(encoder *goloxi.Encoder) error {
7941 startIndex := len(encoder.Bytes())
7942 if err := self.BsnTlv.Serialize(encoder); err != nil {
7943 return err
7944 }
7945
7946 encoder.Write(self.Value)
7947 length := len(encoder.Bytes()) - startIndex
7948
7949 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7950
7951 return nil
7952}
7953
7954func DecodeBsnTlvMacMask(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMacMask, error) {
7955 _bsntlvmacmask := &BsnTlvMacMask{BsnTlv: parent}
7956 if decoder.Length() < 6 {
7957 return nil, fmt.Errorf("BsnTlvMacMask packet too short: %d < 6", decoder.Length())
7958 }
7959 _bsntlvmacmask.Value = net.HardwareAddr(decoder.Read(6))
7960 return _bsntlvmacmask, nil
7961}
7962
7963func NewBsnTlvMacMask() *BsnTlvMacMask {
7964 obj := &BsnTlvMacMask{
7965 BsnTlv: NewBsnTlv(56),
7966 }
7967 return obj
7968}
7969
7970type BsnTlvMcgTypeVxlan struct {
7971 *BsnTlv
7972}
7973
7974type IBsnTlvMcgTypeVxlan interface {
7975 IBsnTlv
7976}
7977
7978func (self *BsnTlvMcgTypeVxlan) Serialize(encoder *goloxi.Encoder) error {
7979 startIndex := len(encoder.Bytes())
7980 if err := self.BsnTlv.Serialize(encoder); err != nil {
7981 return err
7982 }
7983 length := len(encoder.Bytes()) - startIndex
7984
7985 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
7986
7987 return nil
7988}
7989
7990func DecodeBsnTlvMcgTypeVxlan(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMcgTypeVxlan, error) {
7991 _bsntlvmcgtypevxlan := &BsnTlvMcgTypeVxlan{BsnTlv: parent}
7992 return _bsntlvmcgtypevxlan, nil
7993}
7994
7995func NewBsnTlvMcgTypeVxlan() *BsnTlvMcgTypeVxlan {
7996 obj := &BsnTlvMcgTypeVxlan{
7997 BsnTlv: NewBsnTlv(87),
7998 }
7999 return obj
8000}
8001
8002type BsnTlvMissPackets struct {
8003 *BsnTlv
8004 Value uint64
8005}
8006
8007type IBsnTlvMissPackets interface {
8008 IBsnTlv
8009 GetValue() uint64
8010}
8011
8012func (self *BsnTlvMissPackets) GetValue() uint64 {
8013 return self.Value
8014}
8015
8016func (self *BsnTlvMissPackets) SetValue(v uint64) {
8017 self.Value = v
8018}
8019
8020func (self *BsnTlvMissPackets) Serialize(encoder *goloxi.Encoder) error {
8021 startIndex := len(encoder.Bytes())
8022 if err := self.BsnTlv.Serialize(encoder); err != nil {
8023 return err
8024 }
8025
8026 encoder.PutUint64(uint64(self.Value))
8027 length := len(encoder.Bytes()) - startIndex
8028
8029 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8030
8031 return nil
8032}
8033
8034func DecodeBsnTlvMissPackets(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMissPackets, error) {
8035 _bsntlvmisspackets := &BsnTlvMissPackets{BsnTlv: parent}
8036 if decoder.Length() < 8 {
8037 return nil, fmt.Errorf("BsnTlvMissPackets packet too short: %d < 8", decoder.Length())
8038 }
8039 _bsntlvmisspackets.Value = uint64(decoder.ReadUint64())
8040 return _bsntlvmisspackets, nil
8041}
8042
8043func NewBsnTlvMissPackets() *BsnTlvMissPackets {
8044 obj := &BsnTlvMissPackets{
8045 BsnTlv: NewBsnTlv(13),
8046 }
8047 return obj
8048}
8049
8050type BsnTlvMplsControlWord struct {
8051 *BsnTlv
8052 Value uint8
8053}
8054
8055type IBsnTlvMplsControlWord interface {
8056 IBsnTlv
8057 GetValue() uint8
8058}
8059
8060func (self *BsnTlvMplsControlWord) GetValue() uint8 {
8061 return self.Value
8062}
8063
8064func (self *BsnTlvMplsControlWord) SetValue(v uint8) {
8065 self.Value = v
8066}
8067
8068func (self *BsnTlvMplsControlWord) Serialize(encoder *goloxi.Encoder) error {
8069 startIndex := len(encoder.Bytes())
8070 if err := self.BsnTlv.Serialize(encoder); err != nil {
8071 return err
8072 }
8073
8074 encoder.PutUint8(uint8(self.Value))
8075 length := len(encoder.Bytes()) - startIndex
8076
8077 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8078
8079 return nil
8080}
8081
8082func DecodeBsnTlvMplsControlWord(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMplsControlWord, error) {
8083 _bsntlvmplscontrolword := &BsnTlvMplsControlWord{BsnTlv: parent}
8084 if decoder.Length() < 1 {
8085 return nil, fmt.Errorf("BsnTlvMplsControlWord packet too short: %d < 1", decoder.Length())
8086 }
8087 _bsntlvmplscontrolword.Value = uint8(decoder.ReadByte())
8088 return _bsntlvmplscontrolword, nil
8089}
8090
8091func NewBsnTlvMplsControlWord() *BsnTlvMplsControlWord {
8092 obj := &BsnTlvMplsControlWord{
8093 BsnTlv: NewBsnTlv(62),
8094 }
8095 return obj
8096}
8097
8098type BsnTlvMplsLabel struct {
8099 *BsnTlv
8100 Value uint32
8101}
8102
8103type IBsnTlvMplsLabel interface {
8104 IBsnTlv
8105 GetValue() uint32
8106}
8107
8108func (self *BsnTlvMplsLabel) GetValue() uint32 {
8109 return self.Value
8110}
8111
8112func (self *BsnTlvMplsLabel) SetValue(v uint32) {
8113 self.Value = v
8114}
8115
8116func (self *BsnTlvMplsLabel) Serialize(encoder *goloxi.Encoder) error {
8117 startIndex := len(encoder.Bytes())
8118 if err := self.BsnTlv.Serialize(encoder); err != nil {
8119 return err
8120 }
8121
8122 encoder.PutUint32(uint32(self.Value))
8123 length := len(encoder.Bytes()) - startIndex
8124
8125 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8126
8127 return nil
8128}
8129
8130func DecodeBsnTlvMplsLabel(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMplsLabel, error) {
8131 _bsntlvmplslabel := &BsnTlvMplsLabel{BsnTlv: parent}
8132 if decoder.Length() < 4 {
8133 return nil, fmt.Errorf("BsnTlvMplsLabel packet too short: %d < 4", decoder.Length())
8134 }
8135 _bsntlvmplslabel.Value = uint32(decoder.ReadUint32())
8136 return _bsntlvmplslabel, nil
8137}
8138
8139func NewBsnTlvMplsLabel() *BsnTlvMplsLabel {
8140 obj := &BsnTlvMplsLabel{
8141 BsnTlv: NewBsnTlv(61),
8142 }
8143 return obj
8144}
8145
8146type BsnTlvMplsSequenced struct {
8147 *BsnTlv
8148 Value uint8
8149}
8150
8151type IBsnTlvMplsSequenced interface {
8152 IBsnTlv
8153 GetValue() uint8
8154}
8155
8156func (self *BsnTlvMplsSequenced) GetValue() uint8 {
8157 return self.Value
8158}
8159
8160func (self *BsnTlvMplsSequenced) SetValue(v uint8) {
8161 self.Value = v
8162}
8163
8164func (self *BsnTlvMplsSequenced) Serialize(encoder *goloxi.Encoder) error {
8165 startIndex := len(encoder.Bytes())
8166 if err := self.BsnTlv.Serialize(encoder); err != nil {
8167 return err
8168 }
8169
8170 encoder.PutUint8(uint8(self.Value))
8171 length := len(encoder.Bytes()) - startIndex
8172
8173 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8174
8175 return nil
8176}
8177
8178func DecodeBsnTlvMplsSequenced(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMplsSequenced, error) {
8179 _bsntlvmplssequenced := &BsnTlvMplsSequenced{BsnTlv: parent}
8180 if decoder.Length() < 1 {
8181 return nil, fmt.Errorf("BsnTlvMplsSequenced packet too short: %d < 1", decoder.Length())
8182 }
8183 _bsntlvmplssequenced.Value = uint8(decoder.ReadByte())
8184 return _bsntlvmplssequenced, nil
8185}
8186
8187func NewBsnTlvMplsSequenced() *BsnTlvMplsSequenced {
8188 obj := &BsnTlvMplsSequenced{
8189 BsnTlv: NewBsnTlv(63),
8190 }
8191 return obj
8192}
8193
8194type BsnTlvMulticastInterfaceId struct {
8195 *BsnTlv
8196 Value uint32
8197}
8198
8199type IBsnTlvMulticastInterfaceId interface {
8200 IBsnTlv
8201 GetValue() uint32
8202}
8203
8204func (self *BsnTlvMulticastInterfaceId) GetValue() uint32 {
8205 return self.Value
8206}
8207
8208func (self *BsnTlvMulticastInterfaceId) SetValue(v uint32) {
8209 self.Value = v
8210}
8211
8212func (self *BsnTlvMulticastInterfaceId) Serialize(encoder *goloxi.Encoder) error {
8213 startIndex := len(encoder.Bytes())
8214 if err := self.BsnTlv.Serialize(encoder); err != nil {
8215 return err
8216 }
8217
8218 encoder.PutUint32(uint32(self.Value))
8219 length := len(encoder.Bytes()) - startIndex
8220
8221 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8222
8223 return nil
8224}
8225
8226func DecodeBsnTlvMulticastInterfaceId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMulticastInterfaceId, error) {
8227 _bsntlvmulticastinterfaceid := &BsnTlvMulticastInterfaceId{BsnTlv: parent}
8228 if decoder.Length() < 4 {
8229 return nil, fmt.Errorf("BsnTlvMulticastInterfaceId packet too short: %d < 4", decoder.Length())
8230 }
8231 _bsntlvmulticastinterfaceid.Value = uint32(decoder.ReadUint32())
8232 return _bsntlvmulticastinterfaceid, nil
8233}
8234
8235func NewBsnTlvMulticastInterfaceId() *BsnTlvMulticastInterfaceId {
8236 obj := &BsnTlvMulticastInterfaceId{
8237 BsnTlv: NewBsnTlv(95),
8238 }
8239 return obj
8240}
8241
8242type BsnTlvMulticastPacket struct {
8243 *BsnTlv
8244 Value BsnMulticastPacket
8245}
8246
8247type IBsnTlvMulticastPacket interface {
8248 IBsnTlv
8249 GetValue() BsnMulticastPacket
8250}
8251
8252func (self *BsnTlvMulticastPacket) GetValue() BsnMulticastPacket {
8253 return self.Value
8254}
8255
8256func (self *BsnTlvMulticastPacket) SetValue(v BsnMulticastPacket) {
8257 self.Value = v
8258}
8259
8260func (self *BsnTlvMulticastPacket) Serialize(encoder *goloxi.Encoder) error {
8261 startIndex := len(encoder.Bytes())
8262 if err := self.BsnTlv.Serialize(encoder); err != nil {
8263 return err
8264 }
8265
8266 encoder.PutUint16(uint16(self.Value))
8267 length := len(encoder.Bytes()) - startIndex
8268
8269 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8270
8271 return nil
8272}
8273
8274func DecodeBsnTlvMulticastPacket(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMulticastPacket, error) {
8275 _bsntlvmulticastpacket := &BsnTlvMulticastPacket{BsnTlv: parent}
8276 if decoder.Length() < 2 {
8277 return nil, fmt.Errorf("BsnTlvMulticastPacket packet too short: %d < 2", decoder.Length())
8278 }
8279 _bsntlvmulticastpacket.Value = BsnMulticastPacket(decoder.ReadUint16())
8280 return _bsntlvmulticastpacket, nil
8281}
8282
8283func NewBsnTlvMulticastPacket() *BsnTlvMulticastPacket {
8284 obj := &BsnTlvMulticastPacket{
8285 BsnTlv: NewBsnTlv(170),
8286 }
8287 return obj
8288}
8289
8290type BsnTlvMultiplier struct {
8291 *BsnTlv
8292 Value uint32
8293}
8294
8295type IBsnTlvMultiplier interface {
8296 IBsnTlv
8297 GetValue() uint32
8298}
8299
8300func (self *BsnTlvMultiplier) GetValue() uint32 {
8301 return self.Value
8302}
8303
8304func (self *BsnTlvMultiplier) SetValue(v uint32) {
8305 self.Value = v
8306}
8307
8308func (self *BsnTlvMultiplier) Serialize(encoder *goloxi.Encoder) error {
8309 startIndex := len(encoder.Bytes())
8310 if err := self.BsnTlv.Serialize(encoder); err != nil {
8311 return err
8312 }
8313
8314 encoder.PutUint32(uint32(self.Value))
8315 length := len(encoder.Bytes()) - startIndex
8316
8317 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8318
8319 return nil
8320}
8321
8322func DecodeBsnTlvMultiplier(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvMultiplier, error) {
8323 _bsntlvmultiplier := &BsnTlvMultiplier{BsnTlv: parent}
8324 if decoder.Length() < 4 {
8325 return nil, fmt.Errorf("BsnTlvMultiplier packet too short: %d < 4", decoder.Length())
8326 }
8327 _bsntlvmultiplier.Value = uint32(decoder.ReadUint32())
8328 return _bsntlvmultiplier, nil
8329}
8330
8331func NewBsnTlvMultiplier() *BsnTlvMultiplier {
8332 obj := &BsnTlvMultiplier{
8333 BsnTlv: NewBsnTlv(174),
8334 }
8335 return obj
8336}
8337
8338type BsnTlvName struct {
8339 *BsnTlv
8340 Value []byte
8341}
8342
8343type IBsnTlvName interface {
8344 IBsnTlv
8345 GetValue() []byte
8346}
8347
8348func (self *BsnTlvName) GetValue() []byte {
8349 return self.Value
8350}
8351
8352func (self *BsnTlvName) SetValue(v []byte) {
8353 self.Value = v
8354}
8355
8356func (self *BsnTlvName) Serialize(encoder *goloxi.Encoder) error {
8357 startIndex := len(encoder.Bytes())
8358 if err := self.BsnTlv.Serialize(encoder); err != nil {
8359 return err
8360 }
8361
8362 encoder.Write(self.Value)
8363 length := len(encoder.Bytes()) - startIndex
8364
8365 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8366
8367 return nil
8368}
8369
8370func DecodeBsnTlvName(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvName, error) {
8371 _bsntlvname := &BsnTlvName{BsnTlv: parent}
8372 _bsntlvname.Value = decoder.Read(int(decoder.Length()))
8373 return _bsntlvname, nil
8374}
8375
8376func NewBsnTlvName() *BsnTlvName {
8377 obj := &BsnTlvName{
8378 BsnTlv: NewBsnTlv(52),
8379 }
8380 return obj
8381}
8382
8383type BsnTlvNdpOffload struct {
8384 *BsnTlv
8385}
8386
8387type IBsnTlvNdpOffload interface {
8388 IBsnTlv
8389}
8390
8391func (self *BsnTlvNdpOffload) Serialize(encoder *goloxi.Encoder) error {
8392 startIndex := len(encoder.Bytes())
8393 if err := self.BsnTlv.Serialize(encoder); err != nil {
8394 return err
8395 }
8396 length := len(encoder.Bytes()) - startIndex
8397
8398 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8399
8400 return nil
8401}
8402
8403func DecodeBsnTlvNdpOffload(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNdpOffload, error) {
8404 _bsntlvndpoffload := &BsnTlvNdpOffload{BsnTlv: parent}
8405 return _bsntlvndpoffload, nil
8406}
8407
8408func NewBsnTlvNdpOffload() *BsnTlvNdpOffload {
8409 obj := &BsnTlvNdpOffload{
8410 BsnTlv: NewBsnTlv(123),
8411 }
8412 return obj
8413}
8414
8415type BsnTlvNdpStatic struct {
8416 *BsnTlv
8417}
8418
8419type IBsnTlvNdpStatic interface {
8420 IBsnTlv
8421}
8422
8423func (self *BsnTlvNdpStatic) Serialize(encoder *goloxi.Encoder) error {
8424 startIndex := len(encoder.Bytes())
8425 if err := self.BsnTlv.Serialize(encoder); err != nil {
8426 return err
8427 }
8428 length := len(encoder.Bytes()) - startIndex
8429
8430 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8431
8432 return nil
8433}
8434
8435func DecodeBsnTlvNdpStatic(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNdpStatic, error) {
8436 _bsntlvndpstatic := &BsnTlvNdpStatic{BsnTlv: parent}
8437 return _bsntlvndpstatic, nil
8438}
8439
8440func NewBsnTlvNdpStatic() *BsnTlvNdpStatic {
8441 obj := &BsnTlvNdpStatic{
8442 BsnTlv: NewBsnTlv(124),
8443 }
8444 return obj
8445}
8446
8447type BsnTlvNegate struct {
8448 *BsnTlv
8449}
8450
8451type IBsnTlvNegate interface {
8452 IBsnTlv
8453}
8454
8455func (self *BsnTlvNegate) Serialize(encoder *goloxi.Encoder) error {
8456 startIndex := len(encoder.Bytes())
8457 if err := self.BsnTlv.Serialize(encoder); err != nil {
8458 return err
8459 }
8460 length := len(encoder.Bytes()) - startIndex
8461
8462 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8463
8464 return nil
8465}
8466
8467func DecodeBsnTlvNegate(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNegate, error) {
8468 _bsntlvnegate := &BsnTlvNegate{BsnTlv: parent}
8469 return _bsntlvnegate, nil
8470}
8471
8472func NewBsnTlvNegate() *BsnTlvNegate {
8473 obj := &BsnTlvNegate{
8474 BsnTlv: NewBsnTlv(83),
8475 }
8476 return obj
8477}
8478
8479type BsnTlvNextHopIpv4 struct {
8480 *BsnTlv
8481 Value net.IP
8482}
8483
8484type IBsnTlvNextHopIpv4 interface {
8485 IBsnTlv
8486 GetValue() net.IP
8487}
8488
8489func (self *BsnTlvNextHopIpv4) GetValue() net.IP {
8490 return self.Value
8491}
8492
8493func (self *BsnTlvNextHopIpv4) SetValue(v net.IP) {
8494 self.Value = v
8495}
8496
8497func (self *BsnTlvNextHopIpv4) Serialize(encoder *goloxi.Encoder) error {
8498 startIndex := len(encoder.Bytes())
8499 if err := self.BsnTlv.Serialize(encoder); err != nil {
8500 return err
8501 }
8502
8503 encoder.Write(self.Value.To4())
8504 length := len(encoder.Bytes()) - startIndex
8505
8506 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8507
8508 return nil
8509}
8510
8511func DecodeBsnTlvNextHopIpv4(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNextHopIpv4, error) {
8512 _bsntlvnexthopipv4 := &BsnTlvNextHopIpv4{BsnTlv: parent}
8513 if decoder.Length() < 4 {
8514 return nil, fmt.Errorf("BsnTlvNextHopIpv4 packet too short: %d < 4", decoder.Length())
8515 }
8516 _bsntlvnexthopipv4.Value = net.IP(decoder.Read(4))
8517 return _bsntlvnexthopipv4, nil
8518}
8519
8520func NewBsnTlvNextHopIpv4() *BsnTlvNextHopIpv4 {
8521 obj := &BsnTlvNextHopIpv4{
8522 BsnTlv: NewBsnTlv(115),
8523 }
8524 return obj
8525}
8526
8527type BsnTlvNextHopMac struct {
8528 *BsnTlv
8529 Value net.HardwareAddr
8530}
8531
8532type IBsnTlvNextHopMac interface {
8533 IBsnTlv
8534 GetValue() net.HardwareAddr
8535}
8536
8537func (self *BsnTlvNextHopMac) GetValue() net.HardwareAddr {
8538 return self.Value
8539}
8540
8541func (self *BsnTlvNextHopMac) SetValue(v net.HardwareAddr) {
8542 self.Value = v
8543}
8544
8545func (self *BsnTlvNextHopMac) Serialize(encoder *goloxi.Encoder) error {
8546 startIndex := len(encoder.Bytes())
8547 if err := self.BsnTlv.Serialize(encoder); err != nil {
8548 return err
8549 }
8550
8551 encoder.Write(self.Value)
8552 length := len(encoder.Bytes()) - startIndex
8553
8554 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8555
8556 return nil
8557}
8558
8559func DecodeBsnTlvNextHopMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNextHopMac, error) {
8560 _bsntlvnexthopmac := &BsnTlvNextHopMac{BsnTlv: parent}
8561 if decoder.Length() < 6 {
8562 return nil, fmt.Errorf("BsnTlvNextHopMac packet too short: %d < 6", decoder.Length())
8563 }
8564 _bsntlvnexthopmac.Value = net.HardwareAddr(decoder.Read(6))
8565 return _bsntlvnexthopmac, nil
8566}
8567
8568func NewBsnTlvNextHopMac() *BsnTlvNextHopMac {
8569 obj := &BsnTlvNextHopMac{
8570 BsnTlv: NewBsnTlv(114),
8571 }
8572 return obj
8573}
8574
8575type BsnTlvNexthopTypeVxlan struct {
8576 *BsnTlv
8577}
8578
8579type IBsnTlvNexthopTypeVxlan interface {
8580 IBsnTlv
8581}
8582
8583func (self *BsnTlvNexthopTypeVxlan) Serialize(encoder *goloxi.Encoder) error {
8584 startIndex := len(encoder.Bytes())
8585 if err := self.BsnTlv.Serialize(encoder); err != nil {
8586 return err
8587 }
8588 length := len(encoder.Bytes()) - startIndex
8589
8590 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8591
8592 return nil
8593}
8594
8595func DecodeBsnTlvNexthopTypeVxlan(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNexthopTypeVxlan, error) {
8596 _bsntlvnexthoptypevxlan := &BsnTlvNexthopTypeVxlan{BsnTlv: parent}
8597 return _bsntlvnexthoptypevxlan, nil
8598}
8599
8600func NewBsnTlvNexthopTypeVxlan() *BsnTlvNexthopTypeVxlan {
8601 obj := &BsnTlvNexthopTypeVxlan{
8602 BsnTlv: NewBsnTlv(94),
8603 }
8604 return obj
8605}
8606
8607type BsnTlvNoArpResponse struct {
8608 *BsnTlv
8609}
8610
8611type IBsnTlvNoArpResponse interface {
8612 IBsnTlv
8613}
8614
8615func (self *BsnTlvNoArpResponse) Serialize(encoder *goloxi.Encoder) error {
8616 startIndex := len(encoder.Bytes())
8617 if err := self.BsnTlv.Serialize(encoder); err != nil {
8618 return err
8619 }
8620 length := len(encoder.Bytes()) - startIndex
8621
8622 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8623
8624 return nil
8625}
8626
8627func DecodeBsnTlvNoArpResponse(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNoArpResponse, error) {
8628 _bsntlvnoarpresponse := &BsnTlvNoArpResponse{BsnTlv: parent}
8629 return _bsntlvnoarpresponse, nil
8630}
8631
8632func NewBsnTlvNoArpResponse() *BsnTlvNoArpResponse {
8633 obj := &BsnTlvNoArpResponse{
8634 BsnTlv: NewBsnTlv(147),
8635 }
8636 return obj
8637}
8638
8639type BsnTlvNoNsResponse struct {
8640 *BsnTlv
8641}
8642
8643type IBsnTlvNoNsResponse interface {
8644 IBsnTlv
8645}
8646
8647func (self *BsnTlvNoNsResponse) Serialize(encoder *goloxi.Encoder) error {
8648 startIndex := len(encoder.Bytes())
8649 if err := self.BsnTlv.Serialize(encoder); err != nil {
8650 return err
8651 }
8652 length := len(encoder.Bytes()) - startIndex
8653
8654 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8655
8656 return nil
8657}
8658
8659func DecodeBsnTlvNoNsResponse(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvNoNsResponse, error) {
8660 _bsntlvnonsresponse := &BsnTlvNoNsResponse{BsnTlv: parent}
8661 return _bsntlvnonsresponse, nil
8662}
8663
8664func NewBsnTlvNoNsResponse() *BsnTlvNoNsResponse {
8665 obj := &BsnTlvNoNsResponse{
8666 BsnTlv: NewBsnTlv(148),
8667 }
8668 return obj
8669}
8670
8671type BsnTlvOffset struct {
8672 *BsnTlv
8673 Value uint16
8674}
8675
8676type IBsnTlvOffset interface {
8677 IBsnTlv
8678 GetValue() uint16
8679}
8680
8681func (self *BsnTlvOffset) GetValue() uint16 {
8682 return self.Value
8683}
8684
8685func (self *BsnTlvOffset) SetValue(v uint16) {
8686 self.Value = v
8687}
8688
8689func (self *BsnTlvOffset) Serialize(encoder *goloxi.Encoder) error {
8690 startIndex := len(encoder.Bytes())
8691 if err := self.BsnTlv.Serialize(encoder); err != nil {
8692 return err
8693 }
8694
8695 encoder.PutUint16(uint16(self.Value))
8696 length := len(encoder.Bytes()) - startIndex
8697
8698 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8699
8700 return nil
8701}
8702
8703func DecodeBsnTlvOffset(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvOffset, error) {
8704 _bsntlvoffset := &BsnTlvOffset{BsnTlv: parent}
8705 if decoder.Length() < 2 {
8706 return nil, fmt.Errorf("BsnTlvOffset packet too short: %d < 2", decoder.Length())
8707 }
8708 _bsntlvoffset.Value = uint16(decoder.ReadUint16())
8709 return _bsntlvoffset, nil
8710}
8711
8712func NewBsnTlvOffset() *BsnTlvOffset {
8713 obj := &BsnTlvOffset{
8714 BsnTlv: NewBsnTlv(82),
8715 }
8716 return obj
8717}
8718
8719type BsnTlvOpticsAlwaysEnabled struct {
8720 *BsnTlv
8721}
8722
8723type IBsnTlvOpticsAlwaysEnabled interface {
8724 IBsnTlv
8725}
8726
8727func (self *BsnTlvOpticsAlwaysEnabled) Serialize(encoder *goloxi.Encoder) error {
8728 startIndex := len(encoder.Bytes())
8729 if err := self.BsnTlv.Serialize(encoder); err != nil {
8730 return err
8731 }
8732 length := len(encoder.Bytes()) - startIndex
8733
8734 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8735
8736 return nil
8737}
8738
8739func DecodeBsnTlvOpticsAlwaysEnabled(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvOpticsAlwaysEnabled, error) {
8740 _bsntlvopticsalwaysenabled := &BsnTlvOpticsAlwaysEnabled{BsnTlv: parent}
8741 return _bsntlvopticsalwaysenabled, nil
8742}
8743
8744func NewBsnTlvOpticsAlwaysEnabled() *BsnTlvOpticsAlwaysEnabled {
8745 obj := &BsnTlvOpticsAlwaysEnabled{
8746 BsnTlv: NewBsnTlv(150),
8747 }
8748 return obj
8749}
8750
8751type BsnTlvOuterSrcMac struct {
8752 *BsnTlv
8753 Value net.HardwareAddr
8754}
8755
8756type IBsnTlvOuterSrcMac interface {
8757 IBsnTlv
8758 GetValue() net.HardwareAddr
8759}
8760
8761func (self *BsnTlvOuterSrcMac) GetValue() net.HardwareAddr {
8762 return self.Value
8763}
8764
8765func (self *BsnTlvOuterSrcMac) SetValue(v net.HardwareAddr) {
8766 self.Value = v
8767}
8768
8769func (self *BsnTlvOuterSrcMac) Serialize(encoder *goloxi.Encoder) error {
8770 startIndex := len(encoder.Bytes())
8771 if err := self.BsnTlv.Serialize(encoder); err != nil {
8772 return err
8773 }
8774
8775 encoder.Write(self.Value)
8776 length := len(encoder.Bytes()) - startIndex
8777
8778 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8779
8780 return nil
8781}
8782
8783func DecodeBsnTlvOuterSrcMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvOuterSrcMac, error) {
8784 _bsntlvoutersrcmac := &BsnTlvOuterSrcMac{BsnTlv: parent}
8785 if decoder.Length() < 6 {
8786 return nil, fmt.Errorf("BsnTlvOuterSrcMac packet too short: %d < 6", decoder.Length())
8787 }
8788 _bsntlvoutersrcmac.Value = net.HardwareAddr(decoder.Read(6))
8789 return _bsntlvoutersrcmac, nil
8790}
8791
8792func NewBsnTlvOuterSrcMac() *BsnTlvOuterSrcMac {
8793 obj := &BsnTlvOuterSrcMac{
8794 BsnTlv: NewBsnTlv(157),
8795 }
8796 return obj
8797}
8798
8799type BsnTlvParentPort struct {
8800 *BsnTlv
8801 Value Port
8802}
8803
8804type IBsnTlvParentPort interface {
8805 IBsnTlv
8806 GetValue() Port
8807}
8808
8809func (self *BsnTlvParentPort) GetValue() Port {
8810 return self.Value
8811}
8812
8813func (self *BsnTlvParentPort) SetValue(v Port) {
8814 self.Value = v
8815}
8816
8817func (self *BsnTlvParentPort) Serialize(encoder *goloxi.Encoder) error {
8818 startIndex := len(encoder.Bytes())
8819 if err := self.BsnTlv.Serialize(encoder); err != nil {
8820 return err
8821 }
8822
8823 self.Value.Serialize(encoder)
8824 length := len(encoder.Bytes()) - startIndex
8825
8826 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8827
8828 return nil
8829}
8830
8831func DecodeBsnTlvParentPort(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvParentPort, error) {
8832 _bsntlvparentport := &BsnTlvParentPort{BsnTlv: parent}
8833 if decoder.Length() < 4 {
8834 return nil, fmt.Errorf("BsnTlvParentPort packet too short: %d < 4", decoder.Length())
8835 }
8836 _bsntlvparentport.Value.Decode(decoder)
8837 return _bsntlvparentport, nil
8838}
8839
8840func NewBsnTlvParentPort() *BsnTlvParentPort {
8841 obj := &BsnTlvParentPort{
8842 BsnTlv: NewBsnTlv(109),
8843 }
8844 return obj
8845}
8846
8847type BsnTlvPartnerKey struct {
8848 *BsnTlv
8849 Value uint16
8850}
8851
8852type IBsnTlvPartnerKey interface {
8853 IBsnTlv
8854 GetValue() uint16
8855}
8856
8857func (self *BsnTlvPartnerKey) GetValue() uint16 {
8858 return self.Value
8859}
8860
8861func (self *BsnTlvPartnerKey) SetValue(v uint16) {
8862 self.Value = v
8863}
8864
8865func (self *BsnTlvPartnerKey) Serialize(encoder *goloxi.Encoder) error {
8866 startIndex := len(encoder.Bytes())
8867 if err := self.BsnTlv.Serialize(encoder); err != nil {
8868 return err
8869 }
8870
8871 encoder.PutUint16(uint16(self.Value))
8872 length := len(encoder.Bytes()) - startIndex
8873
8874 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8875
8876 return nil
8877}
8878
8879func DecodeBsnTlvPartnerKey(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPartnerKey, error) {
8880 _bsntlvpartnerkey := &BsnTlvPartnerKey{BsnTlv: parent}
8881 if decoder.Length() < 2 {
8882 return nil, fmt.Errorf("BsnTlvPartnerKey packet too short: %d < 2", decoder.Length())
8883 }
8884 _bsntlvpartnerkey.Value = uint16(decoder.ReadUint16())
8885 return _bsntlvpartnerkey, nil
8886}
8887
8888func NewBsnTlvPartnerKey() *BsnTlvPartnerKey {
8889 obj := &BsnTlvPartnerKey{
8890 BsnTlv: NewBsnTlv(51),
8891 }
8892 return obj
8893}
8894
8895type BsnTlvPartnerPortNum struct {
8896 *BsnTlv
8897 Value uint16
8898}
8899
8900type IBsnTlvPartnerPortNum interface {
8901 IBsnTlv
8902 GetValue() uint16
8903}
8904
8905func (self *BsnTlvPartnerPortNum) GetValue() uint16 {
8906 return self.Value
8907}
8908
8909func (self *BsnTlvPartnerPortNum) SetValue(v uint16) {
8910 self.Value = v
8911}
8912
8913func (self *BsnTlvPartnerPortNum) Serialize(encoder *goloxi.Encoder) error {
8914 startIndex := len(encoder.Bytes())
8915 if err := self.BsnTlv.Serialize(encoder); err != nil {
8916 return err
8917 }
8918
8919 encoder.PutUint16(uint16(self.Value))
8920 length := len(encoder.Bytes()) - startIndex
8921
8922 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8923
8924 return nil
8925}
8926
8927func DecodeBsnTlvPartnerPortNum(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPartnerPortNum, error) {
8928 _bsntlvpartnerportnum := &BsnTlvPartnerPortNum{BsnTlv: parent}
8929 if decoder.Length() < 2 {
8930 return nil, fmt.Errorf("BsnTlvPartnerPortNum packet too short: %d < 2", decoder.Length())
8931 }
8932 _bsntlvpartnerportnum.Value = uint16(decoder.ReadUint16())
8933 return _bsntlvpartnerportnum, nil
8934}
8935
8936func NewBsnTlvPartnerPortNum() *BsnTlvPartnerPortNum {
8937 obj := &BsnTlvPartnerPortNum{
8938 BsnTlv: NewBsnTlv(50),
8939 }
8940 return obj
8941}
8942
8943type BsnTlvPartnerPortPriority struct {
8944 *BsnTlv
8945 Value uint16
8946}
8947
8948type IBsnTlvPartnerPortPriority interface {
8949 IBsnTlv
8950 GetValue() uint16
8951}
8952
8953func (self *BsnTlvPartnerPortPriority) GetValue() uint16 {
8954 return self.Value
8955}
8956
8957func (self *BsnTlvPartnerPortPriority) SetValue(v uint16) {
8958 self.Value = v
8959}
8960
8961func (self *BsnTlvPartnerPortPriority) Serialize(encoder *goloxi.Encoder) error {
8962 startIndex := len(encoder.Bytes())
8963 if err := self.BsnTlv.Serialize(encoder); err != nil {
8964 return err
8965 }
8966
8967 encoder.PutUint16(uint16(self.Value))
8968 length := len(encoder.Bytes()) - startIndex
8969
8970 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
8971
8972 return nil
8973}
8974
8975func DecodeBsnTlvPartnerPortPriority(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPartnerPortPriority, error) {
8976 _bsntlvpartnerportpriority := &BsnTlvPartnerPortPriority{BsnTlv: parent}
8977 if decoder.Length() < 2 {
8978 return nil, fmt.Errorf("BsnTlvPartnerPortPriority packet too short: %d < 2", decoder.Length())
8979 }
8980 _bsntlvpartnerportpriority.Value = uint16(decoder.ReadUint16())
8981 return _bsntlvpartnerportpriority, nil
8982}
8983
8984func NewBsnTlvPartnerPortPriority() *BsnTlvPartnerPortPriority {
8985 obj := &BsnTlvPartnerPortPriority{
8986 BsnTlv: NewBsnTlv(49),
8987 }
8988 return obj
8989}
8990
8991type BsnTlvPartnerState struct {
8992 *BsnTlv
8993 Value BsnLacpState
8994}
8995
8996type IBsnTlvPartnerState interface {
8997 IBsnTlv
8998 GetValue() BsnLacpState
8999}
9000
9001func (self *BsnTlvPartnerState) GetValue() BsnLacpState {
9002 return self.Value
9003}
9004
9005func (self *BsnTlvPartnerState) SetValue(v BsnLacpState) {
9006 self.Value = v
9007}
9008
9009func (self *BsnTlvPartnerState) Serialize(encoder *goloxi.Encoder) error {
9010 startIndex := len(encoder.Bytes())
9011 if err := self.BsnTlv.Serialize(encoder); err != nil {
9012 return err
9013 }
9014
9015 encoder.PutUint8(uint8(self.Value))
9016 length := len(encoder.Bytes()) - startIndex
9017
9018 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9019
9020 return nil
9021}
9022
9023func DecodeBsnTlvPartnerState(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPartnerState, error) {
9024 _bsntlvpartnerstate := &BsnTlvPartnerState{BsnTlv: parent}
9025 if decoder.Length() < 1 {
9026 return nil, fmt.Errorf("BsnTlvPartnerState packet too short: %d < 1", decoder.Length())
9027 }
9028 _bsntlvpartnerstate.Value = BsnLacpState(decoder.ReadByte())
9029 return _bsntlvpartnerstate, nil
9030}
9031
9032func NewBsnTlvPartnerState() *BsnTlvPartnerState {
9033 obj := &BsnTlvPartnerState{
9034 BsnTlv: NewBsnTlv(54),
9035 }
9036 return obj
9037}
9038
9039type BsnTlvPartnerSystemMac struct {
9040 *BsnTlv
9041 Value net.HardwareAddr
9042}
9043
9044type IBsnTlvPartnerSystemMac interface {
9045 IBsnTlv
9046 GetValue() net.HardwareAddr
9047}
9048
9049func (self *BsnTlvPartnerSystemMac) GetValue() net.HardwareAddr {
9050 return self.Value
9051}
9052
9053func (self *BsnTlvPartnerSystemMac) SetValue(v net.HardwareAddr) {
9054 self.Value = v
9055}
9056
9057func (self *BsnTlvPartnerSystemMac) Serialize(encoder *goloxi.Encoder) error {
9058 startIndex := len(encoder.Bytes())
9059 if err := self.BsnTlv.Serialize(encoder); err != nil {
9060 return err
9061 }
9062
9063 encoder.Write(self.Value)
9064 length := len(encoder.Bytes()) - startIndex
9065
9066 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9067
9068 return nil
9069}
9070
9071func DecodeBsnTlvPartnerSystemMac(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPartnerSystemMac, error) {
9072 _bsntlvpartnersystemmac := &BsnTlvPartnerSystemMac{BsnTlv: parent}
9073 if decoder.Length() < 6 {
9074 return nil, fmt.Errorf("BsnTlvPartnerSystemMac packet too short: %d < 6", decoder.Length())
9075 }
9076 _bsntlvpartnersystemmac.Value = net.HardwareAddr(decoder.Read(6))
9077 return _bsntlvpartnersystemmac, nil
9078}
9079
9080func NewBsnTlvPartnerSystemMac() *BsnTlvPartnerSystemMac {
9081 obj := &BsnTlvPartnerSystemMac{
9082 BsnTlv: NewBsnTlv(48),
9083 }
9084 return obj
9085}
9086
9087type BsnTlvPartnerSystemPriority struct {
9088 *BsnTlv
9089 Value uint16
9090}
9091
9092type IBsnTlvPartnerSystemPriority interface {
9093 IBsnTlv
9094 GetValue() uint16
9095}
9096
9097func (self *BsnTlvPartnerSystemPriority) GetValue() uint16 {
9098 return self.Value
9099}
9100
9101func (self *BsnTlvPartnerSystemPriority) SetValue(v uint16) {
9102 self.Value = v
9103}
9104
9105func (self *BsnTlvPartnerSystemPriority) Serialize(encoder *goloxi.Encoder) error {
9106 startIndex := len(encoder.Bytes())
9107 if err := self.BsnTlv.Serialize(encoder); err != nil {
9108 return err
9109 }
9110
9111 encoder.PutUint16(uint16(self.Value))
9112 length := len(encoder.Bytes()) - startIndex
9113
9114 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9115
9116 return nil
9117}
9118
9119func DecodeBsnTlvPartnerSystemPriority(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPartnerSystemPriority, error) {
9120 _bsntlvpartnersystempriority := &BsnTlvPartnerSystemPriority{BsnTlv: parent}
9121 if decoder.Length() < 2 {
9122 return nil, fmt.Errorf("BsnTlvPartnerSystemPriority packet too short: %d < 2", decoder.Length())
9123 }
9124 _bsntlvpartnersystempriority.Value = uint16(decoder.ReadUint16())
9125 return _bsntlvpartnersystempriority, nil
9126}
9127
9128func NewBsnTlvPartnerSystemPriority() *BsnTlvPartnerSystemPriority {
9129 obj := &BsnTlvPartnerSystemPriority{
9130 BsnTlv: NewBsnTlv(47),
9131 }
9132 return obj
9133}
9134
9135type BsnTlvPassive struct {
9136 *BsnTlv
9137}
9138
9139type IBsnTlvPassive interface {
9140 IBsnTlv
9141}
9142
9143func (self *BsnTlvPassive) Serialize(encoder *goloxi.Encoder) error {
9144 startIndex := len(encoder.Bytes())
9145 if err := self.BsnTlv.Serialize(encoder); err != nil {
9146 return err
9147 }
9148 length := len(encoder.Bytes()) - startIndex
9149
9150 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9151
9152 return nil
9153}
9154
9155func DecodeBsnTlvPassive(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPassive, error) {
9156 _bsntlvpassive := &BsnTlvPassive{BsnTlv: parent}
9157 return _bsntlvpassive, nil
9158}
9159
9160func NewBsnTlvPassive() *BsnTlvPassive {
9161 obj := &BsnTlvPassive{
9162 BsnTlv: NewBsnTlv(172),
9163 }
9164 return obj
9165}
9166
9167type BsnTlvPduaRxInstance struct {
9168 *BsnTlv
9169 Value []byte
9170}
9171
9172type IBsnTlvPduaRxInstance interface {
9173 IBsnTlv
9174 GetValue() []byte
9175}
9176
9177func (self *BsnTlvPduaRxInstance) GetValue() []byte {
9178 return self.Value
9179}
9180
9181func (self *BsnTlvPduaRxInstance) SetValue(v []byte) {
9182 self.Value = v
9183}
9184
9185func (self *BsnTlvPduaRxInstance) Serialize(encoder *goloxi.Encoder) error {
9186 startIndex := len(encoder.Bytes())
9187 if err := self.BsnTlv.Serialize(encoder); err != nil {
9188 return err
9189 }
9190
9191 encoder.Write(self.Value)
9192 length := len(encoder.Bytes()) - startIndex
9193
9194 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9195
9196 return nil
9197}
9198
9199func DecodeBsnTlvPduaRxInstance(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPduaRxInstance, error) {
9200 _bsntlvpduarxinstance := &BsnTlvPduaRxInstance{BsnTlv: parent}
9201 _bsntlvpduarxinstance.Value = decoder.Read(int(decoder.Length()))
9202 return _bsntlvpduarxinstance, nil
9203}
9204
9205func NewBsnTlvPduaRxInstance() *BsnTlvPduaRxInstance {
9206 obj := &BsnTlvPduaRxInstance{
9207 BsnTlv: NewBsnTlv(159),
9208 }
9209 return obj
9210}
9211
9212type BsnTlvPimDr struct {
9213 *BsnTlv
9214}
9215
9216type IBsnTlvPimDr interface {
9217 IBsnTlv
9218}
9219
9220func (self *BsnTlvPimDr) Serialize(encoder *goloxi.Encoder) error {
9221 startIndex := len(encoder.Bytes())
9222 if err := self.BsnTlv.Serialize(encoder); err != nil {
9223 return err
9224 }
9225 length := len(encoder.Bytes()) - startIndex
9226
9227 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9228
9229 return nil
9230}
9231
9232func DecodeBsnTlvPimDr(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPimDr, error) {
9233 _bsntlvpimdr := &BsnTlvPimDr{BsnTlv: parent}
9234 return _bsntlvpimdr, nil
9235}
9236
9237func NewBsnTlvPimDr() *BsnTlvPimDr {
9238 obj := &BsnTlvPimDr{
9239 BsnTlv: NewBsnTlv(171),
9240 }
9241 return obj
9242}
9243
9244type BsnTlvPimHelloFlood struct {
9245 *BsnTlv
9246}
9247
9248type IBsnTlvPimHelloFlood interface {
9249 IBsnTlv
9250}
9251
9252func (self *BsnTlvPimHelloFlood) Serialize(encoder *goloxi.Encoder) error {
9253 startIndex := len(encoder.Bytes())
9254 if err := self.BsnTlv.Serialize(encoder); err != nil {
9255 return err
9256 }
9257 length := len(encoder.Bytes()) - startIndex
9258
9259 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9260
9261 return nil
9262}
9263
9264func DecodeBsnTlvPimHelloFlood(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPimHelloFlood, error) {
9265 _bsntlvpimhelloflood := &BsnTlvPimHelloFlood{BsnTlv: parent}
9266 return _bsntlvpimhelloflood, nil
9267}
9268
9269func NewBsnTlvPimHelloFlood() *BsnTlvPimHelloFlood {
9270 obj := &BsnTlvPimHelloFlood{
9271 BsnTlv: NewBsnTlv(181),
9272 }
9273 return obj
9274}
9275
9276type BsnTlvPort struct {
9277 *BsnTlv
9278 Value Port
9279}
9280
9281type IBsnTlvPort interface {
9282 IBsnTlv
9283 GetValue() Port
9284}
9285
9286func (self *BsnTlvPort) GetValue() Port {
9287 return self.Value
9288}
9289
9290func (self *BsnTlvPort) SetValue(v Port) {
9291 self.Value = v
9292}
9293
9294func (self *BsnTlvPort) Serialize(encoder *goloxi.Encoder) error {
9295 startIndex := len(encoder.Bytes())
9296 if err := self.BsnTlv.Serialize(encoder); err != nil {
9297 return err
9298 }
9299
9300 self.Value.Serialize(encoder)
9301 length := len(encoder.Bytes()) - startIndex
9302
9303 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9304
9305 return nil
9306}
9307
9308func DecodeBsnTlvPort(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPort, error) {
9309 _bsntlvport := &BsnTlvPort{BsnTlv: parent}
9310 if decoder.Length() < 4 {
9311 return nil, fmt.Errorf("BsnTlvPort packet too short: %d < 4", decoder.Length())
9312 }
9313 _bsntlvport.Value.Decode(decoder)
9314 return _bsntlvport, nil
9315}
9316
9317func NewBsnTlvPort() *BsnTlvPort {
9318 obj := &BsnTlvPort{
9319 BsnTlv: NewBsnTlv(0),
9320 }
9321 return obj
9322}
9323
9324type BsnTlvPortMode struct {
9325 *BsnTlv
9326 Value BsnPortMode
9327}
9328
9329type IBsnTlvPortMode interface {
9330 IBsnTlv
9331 GetValue() BsnPortMode
9332}
9333
9334func (self *BsnTlvPortMode) GetValue() BsnPortMode {
9335 return self.Value
9336}
9337
9338func (self *BsnTlvPortMode) SetValue(v BsnPortMode) {
9339 self.Value = v
9340}
9341
9342func (self *BsnTlvPortMode) Serialize(encoder *goloxi.Encoder) error {
9343 startIndex := len(encoder.Bytes())
9344 if err := self.BsnTlv.Serialize(encoder); err != nil {
9345 return err
9346 }
9347
9348 encoder.PutUint16(uint16(self.Value))
9349 length := len(encoder.Bytes()) - startIndex
9350
9351 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9352
9353 return nil
9354}
9355
9356func DecodeBsnTlvPortMode(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPortMode, error) {
9357 _bsntlvportmode := &BsnTlvPortMode{BsnTlv: parent}
9358 if decoder.Length() < 2 {
9359 return nil, fmt.Errorf("BsnTlvPortMode packet too short: %d < 2", decoder.Length())
9360 }
9361 _bsntlvportmode.Value = BsnPortMode(decoder.ReadUint16())
9362 return _bsntlvportmode, nil
9363}
9364
9365func NewBsnTlvPortMode() *BsnTlvPortMode {
9366 obj := &BsnTlvPortMode{
9367 BsnTlv: NewBsnTlv(179),
9368 }
9369 return obj
9370}
9371
9372type BsnTlvPortSpeedGbps struct {
9373 *BsnTlv
9374 Value uint32
9375}
9376
9377type IBsnTlvPortSpeedGbps interface {
9378 IBsnTlv
9379 GetValue() uint32
9380}
9381
9382func (self *BsnTlvPortSpeedGbps) GetValue() uint32 {
9383 return self.Value
9384}
9385
9386func (self *BsnTlvPortSpeedGbps) SetValue(v uint32) {
9387 self.Value = v
9388}
9389
9390func (self *BsnTlvPortSpeedGbps) Serialize(encoder *goloxi.Encoder) error {
9391 startIndex := len(encoder.Bytes())
9392 if err := self.BsnTlv.Serialize(encoder); err != nil {
9393 return err
9394 }
9395
9396 encoder.PutUint32(uint32(self.Value))
9397 length := len(encoder.Bytes()) - startIndex
9398
9399 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9400
9401 return nil
9402}
9403
9404func DecodeBsnTlvPortSpeedGbps(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPortSpeedGbps, error) {
9405 _bsntlvportspeedgbps := &BsnTlvPortSpeedGbps{BsnTlv: parent}
9406 if decoder.Length() < 4 {
9407 return nil, fmt.Errorf("BsnTlvPortSpeedGbps packet too short: %d < 4", decoder.Length())
9408 }
9409 _bsntlvportspeedgbps.Value = uint32(decoder.ReadUint32())
9410 return _bsntlvportspeedgbps, nil
9411}
9412
9413func NewBsnTlvPortSpeedGbps() *BsnTlvPortSpeedGbps {
9414 obj := &BsnTlvPortSpeedGbps{
9415 BsnTlv: NewBsnTlv(156),
9416 }
9417 return obj
9418}
9419
9420type BsnTlvPortUsage struct {
9421 *BsnTlv
9422 Value BsnPortUsage
9423}
9424
9425type IBsnTlvPortUsage interface {
9426 IBsnTlv
9427 GetValue() BsnPortUsage
9428}
9429
9430func (self *BsnTlvPortUsage) GetValue() BsnPortUsage {
9431 return self.Value
9432}
9433
9434func (self *BsnTlvPortUsage) SetValue(v BsnPortUsage) {
9435 self.Value = v
9436}
9437
9438func (self *BsnTlvPortUsage) Serialize(encoder *goloxi.Encoder) error {
9439 startIndex := len(encoder.Bytes())
9440 if err := self.BsnTlv.Serialize(encoder); err != nil {
9441 return err
9442 }
9443
9444 encoder.PutUint16(uint16(self.Value))
9445 length := len(encoder.Bytes()) - startIndex
9446
9447 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9448
9449 return nil
9450}
9451
9452func DecodeBsnTlvPortUsage(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPortUsage, error) {
9453 _bsntlvportusage := &BsnTlvPortUsage{BsnTlv: parent}
9454 if decoder.Length() < 2 {
9455 return nil, fmt.Errorf("BsnTlvPortUsage packet too short: %d < 2", decoder.Length())
9456 }
9457 _bsntlvportusage.Value = BsnPortUsage(decoder.ReadUint16())
9458 return _bsntlvportusage, nil
9459}
9460
9461func NewBsnTlvPortUsage() *BsnTlvPortUsage {
9462 obj := &BsnTlvPortUsage{
9463 BsnTlv: NewBsnTlv(141),
9464 }
9465 return obj
9466}
9467
9468type BsnTlvPortVxlanMode struct {
9469 *BsnTlv
9470 Value BsnPortVxlanMode
9471}
9472
9473type IBsnTlvPortVxlanMode interface {
9474 IBsnTlv
9475 GetValue() BsnPortVxlanMode
9476}
9477
9478func (self *BsnTlvPortVxlanMode) GetValue() BsnPortVxlanMode {
9479 return self.Value
9480}
9481
9482func (self *BsnTlvPortVxlanMode) SetValue(v BsnPortVxlanMode) {
9483 self.Value = v
9484}
9485
9486func (self *BsnTlvPortVxlanMode) Serialize(encoder *goloxi.Encoder) error {
9487 startIndex := len(encoder.Bytes())
9488 if err := self.BsnTlv.Serialize(encoder); err != nil {
9489 return err
9490 }
9491
9492 encoder.PutUint8(uint8(self.Value))
9493 length := len(encoder.Bytes()) - startIndex
9494
9495 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9496
9497 return nil
9498}
9499
9500func DecodeBsnTlvPortVxlanMode(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPortVxlanMode, error) {
9501 _bsntlvportvxlanmode := &BsnTlvPortVxlanMode{BsnTlv: parent}
9502 if decoder.Length() < 1 {
9503 return nil, fmt.Errorf("BsnTlvPortVxlanMode packet too short: %d < 1", decoder.Length())
9504 }
9505 _bsntlvportvxlanmode.Value = BsnPortVxlanMode(decoder.ReadByte())
9506 return _bsntlvportvxlanmode, nil
9507}
9508
9509func NewBsnTlvPortVxlanMode() *BsnTlvPortVxlanMode {
9510 obj := &BsnTlvPortVxlanMode{
9511 BsnTlv: NewBsnTlv(88),
9512 }
9513 return obj
9514}
9515
9516type BsnTlvPreserveVlan struct {
9517 *BsnTlv
9518}
9519
9520type IBsnTlvPreserveVlan interface {
9521 IBsnTlv
9522}
9523
9524func (self *BsnTlvPreserveVlan) Serialize(encoder *goloxi.Encoder) error {
9525 startIndex := len(encoder.Bytes())
9526 if err := self.BsnTlv.Serialize(encoder); err != nil {
9527 return err
9528 }
9529 length := len(encoder.Bytes()) - startIndex
9530
9531 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9532
9533 return nil
9534}
9535
9536func DecodeBsnTlvPreserveVlan(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPreserveVlan, error) {
9537 _bsntlvpreservevlan := &BsnTlvPreserveVlan{BsnTlv: parent}
9538 return _bsntlvpreservevlan, nil
9539}
9540
9541func NewBsnTlvPreserveVlan() *BsnTlvPreserveVlan {
9542 obj := &BsnTlvPreserveVlan{
9543 BsnTlv: NewBsnTlv(186),
9544 }
9545 return obj
9546}
9547
9548type BsnTlvPriority struct {
9549 *BsnTlv
9550 Value uint32
9551}
9552
9553type IBsnTlvPriority interface {
9554 IBsnTlv
9555 GetValue() uint32
9556}
9557
9558func (self *BsnTlvPriority) GetValue() uint32 {
9559 return self.Value
9560}
9561
9562func (self *BsnTlvPriority) SetValue(v uint32) {
9563 self.Value = v
9564}
9565
9566func (self *BsnTlvPriority) Serialize(encoder *goloxi.Encoder) error {
9567 startIndex := len(encoder.Bytes())
9568 if err := self.BsnTlv.Serialize(encoder); err != nil {
9569 return err
9570 }
9571
9572 encoder.PutUint32(uint32(self.Value))
9573 length := len(encoder.Bytes()) - startIndex
9574
9575 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9576
9577 return nil
9578}
9579
9580func DecodeBsnTlvPriority(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPriority, error) {
9581 _bsntlvpriority := &BsnTlvPriority{BsnTlv: parent}
9582 if decoder.Length() < 4 {
9583 return nil, fmt.Errorf("BsnTlvPriority packet too short: %d < 4", decoder.Length())
9584 }
9585 _bsntlvpriority.Value = uint32(decoder.ReadUint32())
9586 return _bsntlvpriority, nil
9587}
9588
9589func NewBsnTlvPriority() *BsnTlvPriority {
9590 obj := &BsnTlvPriority{
9591 BsnTlv: NewBsnTlv(57),
9592 }
9593 return obj
9594}
9595
9596type BsnTlvPushVlanOnEgress struct {
9597 *BsnTlv
9598}
9599
9600type IBsnTlvPushVlanOnEgress interface {
9601 IBsnTlv
9602}
9603
9604func (self *BsnTlvPushVlanOnEgress) Serialize(encoder *goloxi.Encoder) error {
9605 startIndex := len(encoder.Bytes())
9606 if err := self.BsnTlv.Serialize(encoder); err != nil {
9607 return err
9608 }
9609 length := len(encoder.Bytes()) - startIndex
9610
9611 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9612
9613 return nil
9614}
9615
9616func DecodeBsnTlvPushVlanOnEgress(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPushVlanOnEgress, error) {
9617 _bsntlvpushvlanonegress := &BsnTlvPushVlanOnEgress{BsnTlv: parent}
9618 return _bsntlvpushvlanonegress, nil
9619}
9620
9621func NewBsnTlvPushVlanOnEgress() *BsnTlvPushVlanOnEgress {
9622 obj := &BsnTlvPushVlanOnEgress{
9623 BsnTlv: NewBsnTlv(162),
9624 }
9625 return obj
9626}
9627
9628type BsnTlvPushVlanOnIngress struct {
9629 *BsnTlv
9630 Flags BsnPushVlan
9631}
9632
9633type IBsnTlvPushVlanOnIngress interface {
9634 IBsnTlv
9635 GetFlags() BsnPushVlan
9636}
9637
9638func (self *BsnTlvPushVlanOnIngress) GetFlags() BsnPushVlan {
9639 return self.Flags
9640}
9641
9642func (self *BsnTlvPushVlanOnIngress) SetFlags(v BsnPushVlan) {
9643 self.Flags = v
9644}
9645
9646func (self *BsnTlvPushVlanOnIngress) Serialize(encoder *goloxi.Encoder) error {
9647 startIndex := len(encoder.Bytes())
9648 if err := self.BsnTlv.Serialize(encoder); err != nil {
9649 return err
9650 }
9651
9652 encoder.PutUint8(uint8(self.Flags))
9653 length := len(encoder.Bytes()) - startIndex
9654
9655 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9656
9657 return nil
9658}
9659
9660func DecodeBsnTlvPushVlanOnIngress(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvPushVlanOnIngress, error) {
9661 _bsntlvpushvlanoningress := &BsnTlvPushVlanOnIngress{BsnTlv: parent}
9662 if decoder.Length() < 1 {
9663 return nil, fmt.Errorf("BsnTlvPushVlanOnIngress packet too short: %d < 1", decoder.Length())
9664 }
9665 _bsntlvpushvlanoningress.Flags = BsnPushVlan(decoder.ReadByte())
9666 return _bsntlvpushvlanoningress, nil
9667}
9668
9669func NewBsnTlvPushVlanOnIngress() *BsnTlvPushVlanOnIngress {
9670 obj := &BsnTlvPushVlanOnIngress{
9671 BsnTlv: NewBsnTlv(128),
9672 }
9673 return obj
9674}
9675
9676type BsnTlvQosPriority struct {
9677 *BsnTlv
9678 Value uint32
9679}
9680
9681type IBsnTlvQosPriority interface {
9682 IBsnTlv
9683 GetValue() uint32
9684}
9685
9686func (self *BsnTlvQosPriority) GetValue() uint32 {
9687 return self.Value
9688}
9689
9690func (self *BsnTlvQosPriority) SetValue(v uint32) {
9691 self.Value = v
9692}
9693
9694func (self *BsnTlvQosPriority) Serialize(encoder *goloxi.Encoder) error {
9695 startIndex := len(encoder.Bytes())
9696 if err := self.BsnTlv.Serialize(encoder); err != nil {
9697 return err
9698 }
9699
9700 encoder.PutUint32(uint32(self.Value))
9701 length := len(encoder.Bytes()) - startIndex
9702
9703 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9704
9705 return nil
9706}
9707
9708func DecodeBsnTlvQosPriority(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvQosPriority, error) {
9709 _bsntlvqospriority := &BsnTlvQosPriority{BsnTlv: parent}
9710 if decoder.Length() < 4 {
9711 return nil, fmt.Errorf("BsnTlvQosPriority packet too short: %d < 4", decoder.Length())
9712 }
9713 _bsntlvqospriority.Value = uint32(decoder.ReadUint32())
9714 return _bsntlvqospriority, nil
9715}
9716
9717func NewBsnTlvQosPriority() *BsnTlvQosPriority {
9718 obj := &BsnTlvQosPriority{
9719 BsnTlv: NewBsnTlv(108),
9720 }
9721 return obj
9722}
9723
9724type BsnTlvQueueId struct {
9725 *BsnTlv
9726 Value uint32
9727}
9728
9729type IBsnTlvQueueId interface {
9730 IBsnTlv
9731 GetValue() uint32
9732}
9733
9734func (self *BsnTlvQueueId) GetValue() uint32 {
9735 return self.Value
9736}
9737
9738func (self *BsnTlvQueueId) SetValue(v uint32) {
9739 self.Value = v
9740}
9741
9742func (self *BsnTlvQueueId) Serialize(encoder *goloxi.Encoder) error {
9743 startIndex := len(encoder.Bytes())
9744 if err := self.BsnTlv.Serialize(encoder); err != nil {
9745 return err
9746 }
9747
9748 encoder.PutUint32(uint32(self.Value))
9749 length := len(encoder.Bytes()) - startIndex
9750
9751 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9752
9753 return nil
9754}
9755
9756func DecodeBsnTlvQueueId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvQueueId, error) {
9757 _bsntlvqueueid := &BsnTlvQueueId{BsnTlv: parent}
9758 if decoder.Length() < 4 {
9759 return nil, fmt.Errorf("BsnTlvQueueId packet too short: %d < 4", decoder.Length())
9760 }
9761 _bsntlvqueueid.Value = uint32(decoder.ReadUint32())
9762 return _bsntlvqueueid, nil
9763}
9764
9765func NewBsnTlvQueueId() *BsnTlvQueueId {
9766 obj := &BsnTlvQueueId{
9767 BsnTlv: NewBsnTlv(20),
9768 }
9769 return obj
9770}
9771
9772type BsnTlvQueueWeight struct {
9773 *BsnTlv
9774 Value uint32
9775}
9776
9777type IBsnTlvQueueWeight interface {
9778 IBsnTlv
9779 GetValue() uint32
9780}
9781
9782func (self *BsnTlvQueueWeight) GetValue() uint32 {
9783 return self.Value
9784}
9785
9786func (self *BsnTlvQueueWeight) SetValue(v uint32) {
9787 self.Value = v
9788}
9789
9790func (self *BsnTlvQueueWeight) Serialize(encoder *goloxi.Encoder) error {
9791 startIndex := len(encoder.Bytes())
9792 if err := self.BsnTlv.Serialize(encoder); err != nil {
9793 return err
9794 }
9795
9796 encoder.PutUint32(uint32(self.Value))
9797 length := len(encoder.Bytes()) - startIndex
9798
9799 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9800
9801 return nil
9802}
9803
9804func DecodeBsnTlvQueueWeight(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvQueueWeight, error) {
9805 _bsntlvqueueweight := &BsnTlvQueueWeight{BsnTlv: parent}
9806 if decoder.Length() < 4 {
9807 return nil, fmt.Errorf("BsnTlvQueueWeight packet too short: %d < 4", decoder.Length())
9808 }
9809 _bsntlvqueueweight.Value = uint32(decoder.ReadUint32())
9810 return _bsntlvqueueweight, nil
9811}
9812
9813func NewBsnTlvQueueWeight() *BsnTlvQueueWeight {
9814 obj := &BsnTlvQueueWeight{
9815 BsnTlv: NewBsnTlv(21),
9816 }
9817 return obj
9818}
9819
9820type BsnTlvRateLimit struct {
9821 *BsnTlv
9822 Value uint32
9823}
9824
9825type IBsnTlvRateLimit interface {
9826 IBsnTlv
9827 GetValue() uint32
9828}
9829
9830func (self *BsnTlvRateLimit) GetValue() uint32 {
9831 return self.Value
9832}
9833
9834func (self *BsnTlvRateLimit) SetValue(v uint32) {
9835 self.Value = v
9836}
9837
9838func (self *BsnTlvRateLimit) Serialize(encoder *goloxi.Encoder) error {
9839 startIndex := len(encoder.Bytes())
9840 if err := self.BsnTlv.Serialize(encoder); err != nil {
9841 return err
9842 }
9843
9844 encoder.PutUint32(uint32(self.Value))
9845 length := len(encoder.Bytes()) - startIndex
9846
9847 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9848
9849 return nil
9850}
9851
9852func DecodeBsnTlvRateLimit(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRateLimit, error) {
9853 _bsntlvratelimit := &BsnTlvRateLimit{BsnTlv: parent}
9854 if decoder.Length() < 4 {
9855 return nil, fmt.Errorf("BsnTlvRateLimit packet too short: %d < 4", decoder.Length())
9856 }
9857 _bsntlvratelimit.Value = uint32(decoder.ReadUint32())
9858 return _bsntlvratelimit, nil
9859}
9860
9861func NewBsnTlvRateLimit() *BsnTlvRateLimit {
9862 obj := &BsnTlvRateLimit{
9863 BsnTlv: NewBsnTlv(116),
9864 }
9865 return obj
9866}
9867
9868type BsnTlvRateUnit struct {
9869 *BsnTlv
9870 Value BsnRateUnit
9871}
9872
9873type IBsnTlvRateUnit interface {
9874 IBsnTlv
9875 GetValue() BsnRateUnit
9876}
9877
9878func (self *BsnTlvRateUnit) GetValue() BsnRateUnit {
9879 return self.Value
9880}
9881
9882func (self *BsnTlvRateUnit) SetValue(v BsnRateUnit) {
9883 self.Value = v
9884}
9885
9886func (self *BsnTlvRateUnit) Serialize(encoder *goloxi.Encoder) error {
9887 startIndex := len(encoder.Bytes())
9888 if err := self.BsnTlv.Serialize(encoder); err != nil {
9889 return err
9890 }
9891
9892 encoder.PutUint8(uint8(self.Value))
9893 length := len(encoder.Bytes()) - startIndex
9894
9895 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9896
9897 return nil
9898}
9899
9900func DecodeBsnTlvRateUnit(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRateUnit, error) {
9901 _bsntlvrateunit := &BsnTlvRateUnit{BsnTlv: parent}
9902 if decoder.Length() < 1 {
9903 return nil, fmt.Errorf("BsnTlvRateUnit packet too short: %d < 1", decoder.Length())
9904 }
9905 _bsntlvrateunit.Value = BsnRateUnit(decoder.ReadByte())
9906 return _bsntlvrateunit, nil
9907}
9908
9909func NewBsnTlvRateUnit() *BsnTlvRateUnit {
9910 obj := &BsnTlvRateUnit{
9911 BsnTlv: NewBsnTlv(89),
9912 }
9913 return obj
9914}
9915
9916type BsnTlvRecordPackets struct {
9917 *BsnTlv
9918 Value uint32
9919}
9920
9921type IBsnTlvRecordPackets interface {
9922 IBsnTlv
9923 GetValue() uint32
9924}
9925
9926func (self *BsnTlvRecordPackets) GetValue() uint32 {
9927 return self.Value
9928}
9929
9930func (self *BsnTlvRecordPackets) SetValue(v uint32) {
9931 self.Value = v
9932}
9933
9934func (self *BsnTlvRecordPackets) Serialize(encoder *goloxi.Encoder) error {
9935 startIndex := len(encoder.Bytes())
9936 if err := self.BsnTlv.Serialize(encoder); err != nil {
9937 return err
9938 }
9939
9940 encoder.PutUint32(uint32(self.Value))
9941 length := len(encoder.Bytes()) - startIndex
9942
9943 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9944
9945 return nil
9946}
9947
9948func DecodeBsnTlvRecordPackets(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRecordPackets, error) {
9949 _bsntlvrecordpackets := &BsnTlvRecordPackets{BsnTlv: parent}
9950 if decoder.Length() < 4 {
9951 return nil, fmt.Errorf("BsnTlvRecordPackets packet too short: %d < 4", decoder.Length())
9952 }
9953 _bsntlvrecordpackets.Value = uint32(decoder.ReadUint32())
9954 return _bsntlvrecordpackets, nil
9955}
9956
9957func NewBsnTlvRecordPackets() *BsnTlvRecordPackets {
9958 obj := &BsnTlvRecordPackets{
9959 BsnTlv: NewBsnTlv(155),
9960 }
9961 return obj
9962}
9963
9964type BsnTlvRedundantMgmt struct {
9965 *BsnTlv
9966}
9967
9968type IBsnTlvRedundantMgmt interface {
9969 IBsnTlv
9970}
9971
9972func (self *BsnTlvRedundantMgmt) Serialize(encoder *goloxi.Encoder) error {
9973 startIndex := len(encoder.Bytes())
9974 if err := self.BsnTlv.Serialize(encoder); err != nil {
9975 return err
9976 }
9977 length := len(encoder.Bytes()) - startIndex
9978
9979 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
9980
9981 return nil
9982}
9983
9984func DecodeBsnTlvRedundantMgmt(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRedundantMgmt, error) {
9985 _bsntlvredundantmgmt := &BsnTlvRedundantMgmt{BsnTlv: parent}
9986 return _bsntlvredundantmgmt, nil
9987}
9988
9989func NewBsnTlvRedundantMgmt() *BsnTlvRedundantMgmt {
9990 obj := &BsnTlvRedundantMgmt{
9991 BsnTlv: NewBsnTlv(189),
9992 }
9993 return obj
9994}
9995
9996type BsnTlvReference struct {
9997 *BsnTlv
9998 TableId uint16
9999 Key []IBsnTlv
10000}
10001
10002type IBsnTlvReference interface {
10003 IBsnTlv
10004 GetTableId() uint16
10005 GetKey() []IBsnTlv
10006}
10007
10008func (self *BsnTlvReference) GetTableId() uint16 {
10009 return self.TableId
10010}
10011
10012func (self *BsnTlvReference) SetTableId(v uint16) {
10013 self.TableId = v
10014}
10015
10016func (self *BsnTlvReference) GetKey() []IBsnTlv {
10017 return self.Key
10018}
10019
10020func (self *BsnTlvReference) SetKey(v []IBsnTlv) {
10021 self.Key = v
10022}
10023
10024func (self *BsnTlvReference) Serialize(encoder *goloxi.Encoder) error {
10025 startIndex := len(encoder.Bytes())
10026 if err := self.BsnTlv.Serialize(encoder); err != nil {
10027 return err
10028 }
10029
10030 encoder.PutUint16(uint16(self.TableId))
10031 for _, obj := range self.Key {
10032 if err := obj.Serialize(encoder); err != nil {
10033 return err
10034 }
10035 }
10036 length := len(encoder.Bytes()) - startIndex
10037
10038 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10039
10040 return nil
10041}
10042
10043func DecodeBsnTlvReference(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvReference, error) {
10044 _bsntlvreference := &BsnTlvReference{BsnTlv: parent}
10045 if decoder.Length() < 2 {
10046 return nil, fmt.Errorf("BsnTlvReference packet too short: %d < 2", decoder.Length())
10047 }
10048 _bsntlvreference.TableId = uint16(decoder.ReadUint16())
10049
10050 for decoder.Length() >= 4 {
10051 item, err := DecodeBsnTlv(decoder)
10052 if err != nil {
10053 return nil, err
10054 }
10055 if item != nil {
10056 _bsntlvreference.Key = append(_bsntlvreference.Key, item)
10057 }
10058 }
10059 return _bsntlvreference, nil
10060}
10061
10062func NewBsnTlvReference() *BsnTlvReference {
10063 obj := &BsnTlvReference{
10064 BsnTlv: NewBsnTlv(59),
10065 }
10066 return obj
10067}
10068
10069type BsnTlvReplyPackets struct {
10070 *BsnTlv
10071 Value uint64
10072}
10073
10074type IBsnTlvReplyPackets interface {
10075 IBsnTlv
10076 GetValue() uint64
10077}
10078
10079func (self *BsnTlvReplyPackets) GetValue() uint64 {
10080 return self.Value
10081}
10082
10083func (self *BsnTlvReplyPackets) SetValue(v uint64) {
10084 self.Value = v
10085}
10086
10087func (self *BsnTlvReplyPackets) Serialize(encoder *goloxi.Encoder) error {
10088 startIndex := len(encoder.Bytes())
10089 if err := self.BsnTlv.Serialize(encoder); err != nil {
10090 return err
10091 }
10092
10093 encoder.PutUint64(uint64(self.Value))
10094 length := len(encoder.Bytes()) - startIndex
10095
10096 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10097
10098 return nil
10099}
10100
10101func DecodeBsnTlvReplyPackets(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvReplyPackets, error) {
10102 _bsntlvreplypackets := &BsnTlvReplyPackets{BsnTlv: parent}
10103 if decoder.Length() < 8 {
10104 return nil, fmt.Errorf("BsnTlvReplyPackets packet too short: %d < 8", decoder.Length())
10105 }
10106 _bsntlvreplypackets.Value = uint64(decoder.ReadUint64())
10107 return _bsntlvreplypackets, nil
10108}
10109
10110func NewBsnTlvReplyPackets() *BsnTlvReplyPackets {
10111 obj := &BsnTlvReplyPackets{
10112 BsnTlv: NewBsnTlv(12),
10113 }
10114 return obj
10115}
10116
10117type BsnTlvRequestPackets struct {
10118 *BsnTlv
10119 Value uint64
10120}
10121
10122type IBsnTlvRequestPackets interface {
10123 IBsnTlv
10124 GetValue() uint64
10125}
10126
10127func (self *BsnTlvRequestPackets) GetValue() uint64 {
10128 return self.Value
10129}
10130
10131func (self *BsnTlvRequestPackets) SetValue(v uint64) {
10132 self.Value = v
10133}
10134
10135func (self *BsnTlvRequestPackets) Serialize(encoder *goloxi.Encoder) error {
10136 startIndex := len(encoder.Bytes())
10137 if err := self.BsnTlv.Serialize(encoder); err != nil {
10138 return err
10139 }
10140
10141 encoder.PutUint64(uint64(self.Value))
10142 length := len(encoder.Bytes()) - startIndex
10143
10144 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10145
10146 return nil
10147}
10148
10149func DecodeBsnTlvRequestPackets(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRequestPackets, error) {
10150 _bsntlvrequestpackets := &BsnTlvRequestPackets{BsnTlv: parent}
10151 if decoder.Length() < 8 {
10152 return nil, fmt.Errorf("BsnTlvRequestPackets packet too short: %d < 8", decoder.Length())
10153 }
10154 _bsntlvrequestpackets.Value = uint64(decoder.ReadUint64())
10155 return _bsntlvrequestpackets, nil
10156}
10157
10158func NewBsnTlvRequestPackets() *BsnTlvRequestPackets {
10159 obj := &BsnTlvRequestPackets{
10160 BsnTlv: NewBsnTlv(11),
10161 }
10162 return obj
10163}
10164
10165type BsnTlvRestServer struct {
10166 *BsnTlv
10167}
10168
10169type IBsnTlvRestServer interface {
10170 IBsnTlv
10171}
10172
10173func (self *BsnTlvRestServer) Serialize(encoder *goloxi.Encoder) error {
10174 startIndex := len(encoder.Bytes())
10175 if err := self.BsnTlv.Serialize(encoder); err != nil {
10176 return err
10177 }
10178 length := len(encoder.Bytes()) - startIndex
10179
10180 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10181
10182 return nil
10183}
10184
10185func DecodeBsnTlvRestServer(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRestServer, error) {
10186 _bsntlvrestserver := &BsnTlvRestServer{BsnTlv: parent}
10187 return _bsntlvrestserver, nil
10188}
10189
10190func NewBsnTlvRestServer() *BsnTlvRestServer {
10191 obj := &BsnTlvRestServer{
10192 BsnTlv: NewBsnTlv(152),
10193 }
10194 return obj
10195}
10196
10197type BsnTlvRoutingParam struct {
10198 *BsnTlv
10199 Value BsnRoutingParam
10200}
10201
10202type IBsnTlvRoutingParam interface {
10203 IBsnTlv
10204 GetValue() BsnRoutingParam
10205}
10206
10207func (self *BsnTlvRoutingParam) GetValue() BsnRoutingParam {
10208 return self.Value
10209}
10210
10211func (self *BsnTlvRoutingParam) SetValue(v BsnRoutingParam) {
10212 self.Value = v
10213}
10214
10215func (self *BsnTlvRoutingParam) Serialize(encoder *goloxi.Encoder) error {
10216 startIndex := len(encoder.Bytes())
10217 if err := self.BsnTlv.Serialize(encoder); err != nil {
10218 return err
10219 }
10220
10221 encoder.PutUint16(uint16(self.Value))
10222 length := len(encoder.Bytes()) - startIndex
10223
10224 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10225
10226 return nil
10227}
10228
10229func DecodeBsnTlvRoutingParam(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRoutingParam, error) {
10230 _bsntlvroutingparam := &BsnTlvRoutingParam{BsnTlv: parent}
10231 if decoder.Length() < 2 {
10232 return nil, fmt.Errorf("BsnTlvRoutingParam packet too short: %d < 2", decoder.Length())
10233 }
10234 _bsntlvroutingparam.Value = BsnRoutingParam(decoder.ReadUint16())
10235 return _bsntlvroutingparam, nil
10236}
10237
10238func NewBsnTlvRoutingParam() *BsnTlvRoutingParam {
10239 obj := &BsnTlvRoutingParam{
10240 BsnTlv: NewBsnTlv(161),
10241 }
10242 return obj
10243}
10244
10245type BsnTlvRxBytes struct {
10246 *BsnTlv
10247 Value uint64
10248}
10249
10250type IBsnTlvRxBytes interface {
10251 IBsnTlv
10252 GetValue() uint64
10253}
10254
10255func (self *BsnTlvRxBytes) GetValue() uint64 {
10256 return self.Value
10257}
10258
10259func (self *BsnTlvRxBytes) SetValue(v uint64) {
10260 self.Value = v
10261}
10262
10263func (self *BsnTlvRxBytes) Serialize(encoder *goloxi.Encoder) error {
10264 startIndex := len(encoder.Bytes())
10265 if err := self.BsnTlv.Serialize(encoder); err != nil {
10266 return err
10267 }
10268
10269 encoder.PutUint64(uint64(self.Value))
10270 length := len(encoder.Bytes()) - startIndex
10271
10272 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10273
10274 return nil
10275}
10276
10277func DecodeBsnTlvRxBytes(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRxBytes, error) {
10278 _bsntlvrxbytes := &BsnTlvRxBytes{BsnTlv: parent}
10279 if decoder.Length() < 8 {
10280 return nil, fmt.Errorf("BsnTlvRxBytes packet too short: %d < 8", decoder.Length())
10281 }
10282 _bsntlvrxbytes.Value = uint64(decoder.ReadUint64())
10283 return _bsntlvrxbytes, nil
10284}
10285
10286func NewBsnTlvRxBytes() *BsnTlvRxBytes {
10287 obj := &BsnTlvRxBytes{
10288 BsnTlv: NewBsnTlv(71),
10289 }
10290 return obj
10291}
10292
10293type BsnTlvRxPackets struct {
10294 *BsnTlv
10295 Value uint64
10296}
10297
10298type IBsnTlvRxPackets interface {
10299 IBsnTlv
10300 GetValue() uint64
10301}
10302
10303func (self *BsnTlvRxPackets) GetValue() uint64 {
10304 return self.Value
10305}
10306
10307func (self *BsnTlvRxPackets) SetValue(v uint64) {
10308 self.Value = v
10309}
10310
10311func (self *BsnTlvRxPackets) Serialize(encoder *goloxi.Encoder) error {
10312 startIndex := len(encoder.Bytes())
10313 if err := self.BsnTlv.Serialize(encoder); err != nil {
10314 return err
10315 }
10316
10317 encoder.PutUint64(uint64(self.Value))
10318 length := len(encoder.Bytes()) - startIndex
10319
10320 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10321
10322 return nil
10323}
10324
10325func DecodeBsnTlvRxPackets(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvRxPackets, error) {
10326 _bsntlvrxpackets := &BsnTlvRxPackets{BsnTlv: parent}
10327 if decoder.Length() < 8 {
10328 return nil, fmt.Errorf("BsnTlvRxPackets packet too short: %d < 8", decoder.Length())
10329 }
10330 _bsntlvrxpackets.Value = uint64(decoder.ReadUint64())
10331 return _bsntlvrxpackets, nil
10332}
10333
10334func NewBsnTlvRxPackets() *BsnTlvRxPackets {
10335 obj := &BsnTlvRxPackets{
10336 BsnTlv: NewBsnTlv(2),
10337 }
10338 return obj
10339}
10340
10341type BsnTlvSamplingRate struct {
10342 *BsnTlv
10343 Value uint32
10344}
10345
10346type IBsnTlvSamplingRate interface {
10347 IBsnTlv
10348 GetValue() uint32
10349}
10350
10351func (self *BsnTlvSamplingRate) GetValue() uint32 {
10352 return self.Value
10353}
10354
10355func (self *BsnTlvSamplingRate) SetValue(v uint32) {
10356 self.Value = v
10357}
10358
10359func (self *BsnTlvSamplingRate) Serialize(encoder *goloxi.Encoder) error {
10360 startIndex := len(encoder.Bytes())
10361 if err := self.BsnTlv.Serialize(encoder); err != nil {
10362 return err
10363 }
10364
10365 encoder.PutUint32(uint32(self.Value))
10366 length := len(encoder.Bytes()) - startIndex
10367
10368 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10369
10370 return nil
10371}
10372
10373func DecodeBsnTlvSamplingRate(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvSamplingRate, error) {
10374 _bsntlvsamplingrate := &BsnTlvSamplingRate{BsnTlv: parent}
10375 if decoder.Length() < 4 {
10376 return nil, fmt.Errorf("BsnTlvSamplingRate packet too short: %d < 4", decoder.Length())
10377 }
10378 _bsntlvsamplingrate.Value = uint32(decoder.ReadUint32())
10379 return _bsntlvsamplingrate, nil
10380}
10381
10382func NewBsnTlvSamplingRate() *BsnTlvSamplingRate {
10383 obj := &BsnTlvSamplingRate{
10384 BsnTlv: NewBsnTlv(30),
10385 }
10386 return obj
10387}
10388
10389type BsnTlvSetLoopbackMode struct {
10390 *BsnTlv
10391}
10392
10393type IBsnTlvSetLoopbackMode interface {
10394 IBsnTlv
10395}
10396
10397func (self *BsnTlvSetLoopbackMode) Serialize(encoder *goloxi.Encoder) error {
10398 startIndex := len(encoder.Bytes())
10399 if err := self.BsnTlv.Serialize(encoder); err != nil {
10400 return err
10401 }
10402 length := len(encoder.Bytes()) - startIndex
10403
10404 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10405
10406 return nil
10407}
10408
10409func DecodeBsnTlvSetLoopbackMode(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvSetLoopbackMode, error) {
10410 _bsntlvsetloopbackmode := &BsnTlvSetLoopbackMode{BsnTlv: parent}
10411 return _bsntlvsetloopbackmode, nil
10412}
10413
10414func NewBsnTlvSetLoopbackMode() *BsnTlvSetLoopbackMode {
10415 obj := &BsnTlvSetLoopbackMode{
10416 BsnTlv: NewBsnTlv(74),
10417 }
10418 return obj
10419}
10420
10421type BsnTlvSrcMacCml struct {
10422 *BsnTlv
10423 Value BsnCml
10424}
10425
10426type IBsnTlvSrcMacCml interface {
10427 IBsnTlv
10428 GetValue() BsnCml
10429}
10430
10431func (self *BsnTlvSrcMacCml) GetValue() BsnCml {
10432 return self.Value
10433}
10434
10435func (self *BsnTlvSrcMacCml) SetValue(v BsnCml) {
10436 self.Value = v
10437}
10438
10439func (self *BsnTlvSrcMacCml) Serialize(encoder *goloxi.Encoder) error {
10440 startIndex := len(encoder.Bytes())
10441 if err := self.BsnTlv.Serialize(encoder); err != nil {
10442 return err
10443 }
10444
10445 encoder.PutUint16(uint16(self.Value))
10446 length := len(encoder.Bytes()) - startIndex
10447
10448 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10449
10450 return nil
10451}
10452
10453func DecodeBsnTlvSrcMacCml(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvSrcMacCml, error) {
10454 _bsntlvsrcmaccml := &BsnTlvSrcMacCml{BsnTlv: parent}
10455 if decoder.Length() < 2 {
10456 return nil, fmt.Errorf("BsnTlvSrcMacCml packet too short: %d < 2", decoder.Length())
10457 }
10458 _bsntlvsrcmaccml.Value = BsnCml(decoder.ReadUint16())
10459 return _bsntlvsrcmaccml, nil
10460}
10461
10462func NewBsnTlvSrcMacCml() *BsnTlvSrcMacCml {
10463 obj := &BsnTlvSrcMacCml{
10464 BsnTlv: NewBsnTlv(191),
10465 }
10466 return obj
10467}
10468
10469type BsnTlvStatus struct {
10470 *BsnTlv
10471 Value BsnStatus
10472}
10473
10474type IBsnTlvStatus interface {
10475 IBsnTlv
10476 GetValue() BsnStatus
10477}
10478
10479func (self *BsnTlvStatus) GetValue() BsnStatus {
10480 return self.Value
10481}
10482
10483func (self *BsnTlvStatus) SetValue(v BsnStatus) {
10484 self.Value = v
10485}
10486
10487func (self *BsnTlvStatus) Serialize(encoder *goloxi.Encoder) error {
10488 startIndex := len(encoder.Bytes())
10489 if err := self.BsnTlv.Serialize(encoder); err != nil {
10490 return err
10491 }
10492
10493 encoder.PutUint8(uint8(self.Value))
10494 length := len(encoder.Bytes()) - startIndex
10495
10496 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10497
10498 return nil
10499}
10500
10501func DecodeBsnTlvStatus(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvStatus, error) {
10502 _bsntlvstatus := &BsnTlvStatus{BsnTlv: parent}
10503 if decoder.Length() < 1 {
10504 return nil, fmt.Errorf("BsnTlvStatus packet too short: %d < 1", decoder.Length())
10505 }
10506 _bsntlvstatus.Value = BsnStatus(decoder.ReadByte())
10507 return _bsntlvstatus, nil
10508}
10509
10510func NewBsnTlvStatus() *BsnTlvStatus {
10511 obj := &BsnTlvStatus{
10512 BsnTlv: NewBsnTlv(97),
10513 }
10514 return obj
10515}
10516
10517type BsnTlvStripMplsL2OnIngress struct {
10518 *BsnTlv
10519}
10520
10521type IBsnTlvStripMplsL2OnIngress interface {
10522 IBsnTlv
10523}
10524
10525func (self *BsnTlvStripMplsL2OnIngress) Serialize(encoder *goloxi.Encoder) error {
10526 startIndex := len(encoder.Bytes())
10527 if err := self.BsnTlv.Serialize(encoder); err != nil {
10528 return err
10529 }
10530 length := len(encoder.Bytes()) - startIndex
10531
10532 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10533
10534 return nil
10535}
10536
10537func DecodeBsnTlvStripMplsL2OnIngress(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvStripMplsL2OnIngress, error) {
10538 _bsntlvstripmplsl2oningress := &BsnTlvStripMplsL2OnIngress{BsnTlv: parent}
10539 return _bsntlvstripmplsl2oningress, nil
10540}
10541
10542func NewBsnTlvStripMplsL2OnIngress() *BsnTlvStripMplsL2OnIngress {
10543 obj := &BsnTlvStripMplsL2OnIngress{
10544 BsnTlv: NewBsnTlv(75),
10545 }
10546 return obj
10547}
10548
10549type BsnTlvStripMplsL3OnIngress struct {
10550 *BsnTlv
10551}
10552
10553type IBsnTlvStripMplsL3OnIngress interface {
10554 IBsnTlv
10555}
10556
10557func (self *BsnTlvStripMplsL3OnIngress) Serialize(encoder *goloxi.Encoder) error {
10558 startIndex := len(encoder.Bytes())
10559 if err := self.BsnTlv.Serialize(encoder); err != nil {
10560 return err
10561 }
10562 length := len(encoder.Bytes()) - startIndex
10563
10564 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10565
10566 return nil
10567}
10568
10569func DecodeBsnTlvStripMplsL3OnIngress(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvStripMplsL3OnIngress, error) {
10570 _bsntlvstripmplsl3oningress := &BsnTlvStripMplsL3OnIngress{BsnTlv: parent}
10571 return _bsntlvstripmplsl3oningress, nil
10572}
10573
10574func NewBsnTlvStripMplsL3OnIngress() *BsnTlvStripMplsL3OnIngress {
10575 obj := &BsnTlvStripMplsL3OnIngress{
10576 BsnTlv: NewBsnTlv(76),
10577 }
10578 return obj
10579}
10580
10581type BsnTlvStripVlanOnEgress struct {
10582 *BsnTlv
10583 Flags BsnStripVlan
10584}
10585
10586type IBsnTlvStripVlanOnEgress interface {
10587 IBsnTlv
10588 GetFlags() BsnStripVlan
10589}
10590
10591func (self *BsnTlvStripVlanOnEgress) GetFlags() BsnStripVlan {
10592 return self.Flags
10593}
10594
10595func (self *BsnTlvStripVlanOnEgress) SetFlags(v BsnStripVlan) {
10596 self.Flags = v
10597}
10598
10599func (self *BsnTlvStripVlanOnEgress) Serialize(encoder *goloxi.Encoder) error {
10600 startIndex := len(encoder.Bytes())
10601 if err := self.BsnTlv.Serialize(encoder); err != nil {
10602 return err
10603 }
10604
10605 encoder.PutUint8(uint8(self.Flags))
10606 length := len(encoder.Bytes()) - startIndex
10607
10608 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10609
10610 return nil
10611}
10612
10613func DecodeBsnTlvStripVlanOnEgress(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvStripVlanOnEgress, error) {
10614 _bsntlvstripvlanonegress := &BsnTlvStripVlanOnEgress{BsnTlv: parent}
10615 if decoder.Length() < 1 {
10616 return nil, fmt.Errorf("BsnTlvStripVlanOnEgress packet too short: %d < 1", decoder.Length())
10617 }
10618 _bsntlvstripvlanonegress.Flags = BsnStripVlan(decoder.ReadByte())
10619 return _bsntlvstripvlanonegress, nil
10620}
10621
10622func NewBsnTlvStripVlanOnEgress() *BsnTlvStripVlanOnEgress {
10623 obj := &BsnTlvStripVlanOnEgress{
10624 BsnTlv: NewBsnTlv(73),
10625 }
10626 return obj
10627}
10628
10629type BsnTlvSubAgentId struct {
10630 *BsnTlv
10631 Value uint32
10632}
10633
10634type IBsnTlvSubAgentId interface {
10635 IBsnTlv
10636 GetValue() uint32
10637}
10638
10639func (self *BsnTlvSubAgentId) GetValue() uint32 {
10640 return self.Value
10641}
10642
10643func (self *BsnTlvSubAgentId) SetValue(v uint32) {
10644 self.Value = v
10645}
10646
10647func (self *BsnTlvSubAgentId) Serialize(encoder *goloxi.Encoder) error {
10648 startIndex := len(encoder.Bytes())
10649 if err := self.BsnTlv.Serialize(encoder); err != nil {
10650 return err
10651 }
10652
10653 encoder.PutUint32(uint32(self.Value))
10654 length := len(encoder.Bytes()) - startIndex
10655
10656 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10657
10658 return nil
10659}
10660
10661func DecodeBsnTlvSubAgentId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvSubAgentId, error) {
10662 _bsntlvsubagentid := &BsnTlvSubAgentId{BsnTlv: parent}
10663 if decoder.Length() < 4 {
10664 return nil, fmt.Errorf("BsnTlvSubAgentId packet too short: %d < 4", decoder.Length())
10665 }
10666 _bsntlvsubagentid.Value = uint32(decoder.ReadUint32())
10667 return _bsntlvsubagentid, nil
10668}
10669
10670func NewBsnTlvSubAgentId() *BsnTlvSubAgentId {
10671 obj := &BsnTlvSubAgentId{
10672 BsnTlv: NewBsnTlv(38),
10673 }
10674 return obj
10675}
10676
10677type BsnTlvTcpDst struct {
10678 *BsnTlv
10679 Value uint16
10680}
10681
10682type IBsnTlvTcpDst interface {
10683 IBsnTlv
10684 GetValue() uint16
10685}
10686
10687func (self *BsnTlvTcpDst) GetValue() uint16 {
10688 return self.Value
10689}
10690
10691func (self *BsnTlvTcpDst) SetValue(v uint16) {
10692 self.Value = v
10693}
10694
10695func (self *BsnTlvTcpDst) Serialize(encoder *goloxi.Encoder) error {
10696 startIndex := len(encoder.Bytes())
10697 if err := self.BsnTlv.Serialize(encoder); err != nil {
10698 return err
10699 }
10700
10701 encoder.PutUint16(uint16(self.Value))
10702 length := len(encoder.Bytes()) - startIndex
10703
10704 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10705
10706 return nil
10707}
10708
10709func DecodeBsnTlvTcpDst(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTcpDst, error) {
10710 _bsntlvtcpdst := &BsnTlvTcpDst{BsnTlv: parent}
10711 if decoder.Length() < 2 {
10712 return nil, fmt.Errorf("BsnTlvTcpDst packet too short: %d < 2", decoder.Length())
10713 }
10714 _bsntlvtcpdst.Value = uint16(decoder.ReadUint16())
10715 return _bsntlvtcpdst, nil
10716}
10717
10718func NewBsnTlvTcpDst() *BsnTlvTcpDst {
10719 obj := &BsnTlvTcpDst{
10720 BsnTlv: NewBsnTlv(66),
10721 }
10722 return obj
10723}
10724
10725type BsnTlvTcpFlags struct {
10726 *BsnTlv
10727 Value uint16
10728}
10729
10730type IBsnTlvTcpFlags interface {
10731 IBsnTlv
10732 GetValue() uint16
10733}
10734
10735func (self *BsnTlvTcpFlags) GetValue() uint16 {
10736 return self.Value
10737}
10738
10739func (self *BsnTlvTcpFlags) SetValue(v uint16) {
10740 self.Value = v
10741}
10742
10743func (self *BsnTlvTcpFlags) Serialize(encoder *goloxi.Encoder) error {
10744 startIndex := len(encoder.Bytes())
10745 if err := self.BsnTlv.Serialize(encoder); err != nil {
10746 return err
10747 }
10748
10749 encoder.PutUint16(uint16(self.Value))
10750 length := len(encoder.Bytes()) - startIndex
10751
10752 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10753
10754 return nil
10755}
10756
10757func DecodeBsnTlvTcpFlags(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTcpFlags, error) {
10758 _bsntlvtcpflags := &BsnTlvTcpFlags{BsnTlv: parent}
10759 if decoder.Length() < 2 {
10760 return nil, fmt.Errorf("BsnTlvTcpFlags packet too short: %d < 2", decoder.Length())
10761 }
10762 _bsntlvtcpflags.Value = uint16(decoder.ReadUint16())
10763 return _bsntlvtcpflags, nil
10764}
10765
10766func NewBsnTlvTcpFlags() *BsnTlvTcpFlags {
10767 obj := &BsnTlvTcpFlags{
10768 BsnTlv: NewBsnTlv(133),
10769 }
10770 return obj
10771}
10772
10773type BsnTlvTcpSrc struct {
10774 *BsnTlv
10775 Value uint16
10776}
10777
10778type IBsnTlvTcpSrc interface {
10779 IBsnTlv
10780 GetValue() uint16
10781}
10782
10783func (self *BsnTlvTcpSrc) GetValue() uint16 {
10784 return self.Value
10785}
10786
10787func (self *BsnTlvTcpSrc) SetValue(v uint16) {
10788 self.Value = v
10789}
10790
10791func (self *BsnTlvTcpSrc) Serialize(encoder *goloxi.Encoder) error {
10792 startIndex := len(encoder.Bytes())
10793 if err := self.BsnTlv.Serialize(encoder); err != nil {
10794 return err
10795 }
10796
10797 encoder.PutUint16(uint16(self.Value))
10798 length := len(encoder.Bytes()) - startIndex
10799
10800 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10801
10802 return nil
10803}
10804
10805func DecodeBsnTlvTcpSrc(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTcpSrc, error) {
10806 _bsntlvtcpsrc := &BsnTlvTcpSrc{BsnTlv: parent}
10807 if decoder.Length() < 2 {
10808 return nil, fmt.Errorf("BsnTlvTcpSrc packet too short: %d < 2", decoder.Length())
10809 }
10810 _bsntlvtcpsrc.Value = uint16(decoder.ReadUint16())
10811 return _bsntlvtcpsrc, nil
10812}
10813
10814func NewBsnTlvTcpSrc() *BsnTlvTcpSrc {
10815 obj := &BsnTlvTcpSrc{
10816 BsnTlv: NewBsnTlv(65),
10817 }
10818 return obj
10819}
10820
10821type BsnTlvTimestamp struct {
10822 *BsnTlv
10823 Value uint64
10824}
10825
10826type IBsnTlvTimestamp interface {
10827 IBsnTlv
10828 GetValue() uint64
10829}
10830
10831func (self *BsnTlvTimestamp) GetValue() uint64 {
10832 return self.Value
10833}
10834
10835func (self *BsnTlvTimestamp) SetValue(v uint64) {
10836 self.Value = v
10837}
10838
10839func (self *BsnTlvTimestamp) Serialize(encoder *goloxi.Encoder) error {
10840 startIndex := len(encoder.Bytes())
10841 if err := self.BsnTlv.Serialize(encoder); err != nil {
10842 return err
10843 }
10844
10845 encoder.PutUint64(uint64(self.Value))
10846 length := len(encoder.Bytes()) - startIndex
10847
10848 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10849
10850 return nil
10851}
10852
10853func DecodeBsnTlvTimestamp(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTimestamp, error) {
10854 _bsntlvtimestamp := &BsnTlvTimestamp{BsnTlv: parent}
10855 if decoder.Length() < 8 {
10856 return nil, fmt.Errorf("BsnTlvTimestamp packet too short: %d < 8", decoder.Length())
10857 }
10858 _bsntlvtimestamp.Value = uint64(decoder.ReadUint64())
10859 return _bsntlvtimestamp, nil
10860}
10861
10862func NewBsnTlvTimestamp() *BsnTlvTimestamp {
10863 obj := &BsnTlvTimestamp{
10864 BsnTlv: NewBsnTlv(154),
10865 }
10866 return obj
10867}
10868
10869type BsnTlvTtl struct {
10870 *BsnTlv
10871 Value uint16
10872}
10873
10874type IBsnTlvTtl interface {
10875 IBsnTlv
10876 GetValue() uint16
10877}
10878
10879func (self *BsnTlvTtl) GetValue() uint16 {
10880 return self.Value
10881}
10882
10883func (self *BsnTlvTtl) SetValue(v uint16) {
10884 self.Value = v
10885}
10886
10887func (self *BsnTlvTtl) Serialize(encoder *goloxi.Encoder) error {
10888 startIndex := len(encoder.Bytes())
10889 if err := self.BsnTlv.Serialize(encoder); err != nil {
10890 return err
10891 }
10892
10893 encoder.PutUint16(uint16(self.Value))
10894 length := len(encoder.Bytes()) - startIndex
10895
10896 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10897
10898 return nil
10899}
10900
10901func DecodeBsnTlvTtl(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTtl, error) {
10902 _bsntlvttl := &BsnTlvTtl{BsnTlv: parent}
10903 if decoder.Length() < 2 {
10904 return nil, fmt.Errorf("BsnTlvTtl packet too short: %d < 2", decoder.Length())
10905 }
10906 _bsntlvttl.Value = uint16(decoder.ReadUint16())
10907 return _bsntlvttl, nil
10908}
10909
10910func NewBsnTlvTtl() *BsnTlvTtl {
10911 obj := &BsnTlvTtl{
10912 BsnTlv: NewBsnTlv(113),
10913 }
10914 return obj
10915}
10916
10917type BsnTlvTunnelCapability struct {
10918 *BsnTlv
10919 Value BsnTunnelType
10920}
10921
10922type IBsnTlvTunnelCapability interface {
10923 IBsnTlv
10924 GetValue() BsnTunnelType
10925}
10926
10927func (self *BsnTlvTunnelCapability) GetValue() BsnTunnelType {
10928 return self.Value
10929}
10930
10931func (self *BsnTlvTunnelCapability) SetValue(v BsnTunnelType) {
10932 self.Value = v
10933}
10934
10935func (self *BsnTlvTunnelCapability) Serialize(encoder *goloxi.Encoder) error {
10936 startIndex := len(encoder.Bytes())
10937 if err := self.BsnTlv.Serialize(encoder); err != nil {
10938 return err
10939 }
10940
10941 encoder.PutUint64(uint64(self.Value))
10942 length := len(encoder.Bytes()) - startIndex
10943
10944 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10945
10946 return nil
10947}
10948
10949func DecodeBsnTlvTunnelCapability(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTunnelCapability, error) {
10950 _bsntlvtunnelcapability := &BsnTlvTunnelCapability{BsnTlv: parent}
10951 if decoder.Length() < 8 {
10952 return nil, fmt.Errorf("BsnTlvTunnelCapability packet too short: %d < 8", decoder.Length())
10953 }
10954 _bsntlvtunnelcapability.Value = BsnTunnelType(decoder.ReadUint64())
10955 return _bsntlvtunnelcapability, nil
10956}
10957
10958func NewBsnTlvTunnelCapability() *BsnTlvTunnelCapability {
10959 obj := &BsnTlvTunnelCapability{
10960 BsnTlv: NewBsnTlv(142),
10961 }
10962 return obj
10963}
10964
10965type BsnTlvTxBytes struct {
10966 *BsnTlv
10967 Value uint64
10968}
10969
10970type IBsnTlvTxBytes interface {
10971 IBsnTlv
10972 GetValue() uint64
10973}
10974
10975func (self *BsnTlvTxBytes) GetValue() uint64 {
10976 return self.Value
10977}
10978
10979func (self *BsnTlvTxBytes) SetValue(v uint64) {
10980 self.Value = v
10981}
10982
10983func (self *BsnTlvTxBytes) Serialize(encoder *goloxi.Encoder) error {
10984 startIndex := len(encoder.Bytes())
10985 if err := self.BsnTlv.Serialize(encoder); err != nil {
10986 return err
10987 }
10988
10989 encoder.PutUint64(uint64(self.Value))
10990 length := len(encoder.Bytes()) - startIndex
10991
10992 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
10993
10994 return nil
10995}
10996
10997func DecodeBsnTlvTxBytes(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTxBytes, error) {
10998 _bsntlvtxbytes := &BsnTlvTxBytes{BsnTlv: parent}
10999 if decoder.Length() < 8 {
11000 return nil, fmt.Errorf("BsnTlvTxBytes packet too short: %d < 8", decoder.Length())
11001 }
11002 _bsntlvtxbytes.Value = uint64(decoder.ReadUint64())
11003 return _bsntlvtxbytes, nil
11004}
11005
11006func NewBsnTlvTxBytes() *BsnTlvTxBytes {
11007 obj := &BsnTlvTxBytes{
11008 BsnTlv: NewBsnTlv(39),
11009 }
11010 return obj
11011}
11012
11013type BsnTlvTxPackets struct {
11014 *BsnTlv
11015 Value uint64
11016}
11017
11018type IBsnTlvTxPackets interface {
11019 IBsnTlv
11020 GetValue() uint64
11021}
11022
11023func (self *BsnTlvTxPackets) GetValue() uint64 {
11024 return self.Value
11025}
11026
11027func (self *BsnTlvTxPackets) SetValue(v uint64) {
11028 self.Value = v
11029}
11030
11031func (self *BsnTlvTxPackets) Serialize(encoder *goloxi.Encoder) error {
11032 startIndex := len(encoder.Bytes())
11033 if err := self.BsnTlv.Serialize(encoder); err != nil {
11034 return err
11035 }
11036
11037 encoder.PutUint64(uint64(self.Value))
11038 length := len(encoder.Bytes()) - startIndex
11039
11040 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11041
11042 return nil
11043}
11044
11045func DecodeBsnTlvTxPackets(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvTxPackets, error) {
11046 _bsntlvtxpackets := &BsnTlvTxPackets{BsnTlv: parent}
11047 if decoder.Length() < 8 {
11048 return nil, fmt.Errorf("BsnTlvTxPackets packet too short: %d < 8", decoder.Length())
11049 }
11050 _bsntlvtxpackets.Value = uint64(decoder.ReadUint64())
11051 return _bsntlvtxpackets, nil
11052}
11053
11054func NewBsnTlvTxPackets() *BsnTlvTxPackets {
11055 obj := &BsnTlvTxPackets{
11056 BsnTlv: NewBsnTlv(3),
11057 }
11058 return obj
11059}
11060
11061type BsnTlvUdfAnchor struct {
11062 *BsnTlv
11063 Value BsnUdfAnchor
11064}
11065
11066type IBsnTlvUdfAnchor interface {
11067 IBsnTlv
11068 GetValue() BsnUdfAnchor
11069}
11070
11071func (self *BsnTlvUdfAnchor) GetValue() BsnUdfAnchor {
11072 return self.Value
11073}
11074
11075func (self *BsnTlvUdfAnchor) SetValue(v BsnUdfAnchor) {
11076 self.Value = v
11077}
11078
11079func (self *BsnTlvUdfAnchor) Serialize(encoder *goloxi.Encoder) error {
11080 startIndex := len(encoder.Bytes())
11081 if err := self.BsnTlv.Serialize(encoder); err != nil {
11082 return err
11083 }
11084
11085 encoder.PutUint16(uint16(self.Value))
11086 length := len(encoder.Bytes()) - startIndex
11087
11088 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11089
11090 return nil
11091}
11092
11093func DecodeBsnTlvUdfAnchor(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUdfAnchor, error) {
11094 _bsntlvudfanchor := &BsnTlvUdfAnchor{BsnTlv: parent}
11095 if decoder.Length() < 2 {
11096 return nil, fmt.Errorf("BsnTlvUdfAnchor packet too short: %d < 2", decoder.Length())
11097 }
11098 _bsntlvudfanchor.Value = BsnUdfAnchor(decoder.ReadUint16())
11099 return _bsntlvudfanchor, nil
11100}
11101
11102func NewBsnTlvUdfAnchor() *BsnTlvUdfAnchor {
11103 obj := &BsnTlvUdfAnchor{
11104 BsnTlv: NewBsnTlv(16),
11105 }
11106 return obj
11107}
11108
11109type BsnTlvUdfCapability struct {
11110 *BsnTlv
11111 Value BsnUdfMode
11112}
11113
11114type IBsnTlvUdfCapability interface {
11115 IBsnTlv
11116 GetValue() BsnUdfMode
11117}
11118
11119func (self *BsnTlvUdfCapability) GetValue() BsnUdfMode {
11120 return self.Value
11121}
11122
11123func (self *BsnTlvUdfCapability) SetValue(v BsnUdfMode) {
11124 self.Value = v
11125}
11126
11127func (self *BsnTlvUdfCapability) Serialize(encoder *goloxi.Encoder) error {
11128 startIndex := len(encoder.Bytes())
11129 if err := self.BsnTlv.Serialize(encoder); err != nil {
11130 return err
11131 }
11132
11133 encoder.PutUint8(uint8(self.Value))
11134 length := len(encoder.Bytes()) - startIndex
11135
11136 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11137
11138 return nil
11139}
11140
11141func DecodeBsnTlvUdfCapability(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUdfCapability, error) {
11142 _bsntlvudfcapability := &BsnTlvUdfCapability{BsnTlv: parent}
11143 if decoder.Length() < 1 {
11144 return nil, fmt.Errorf("BsnTlvUdfCapability packet too short: %d < 1", decoder.Length())
11145 }
11146 _bsntlvudfcapability.Value = BsnUdfMode(decoder.ReadByte())
11147 return _bsntlvudfcapability, nil
11148}
11149
11150func NewBsnTlvUdfCapability() *BsnTlvUdfCapability {
11151 obj := &BsnTlvUdfCapability{
11152 BsnTlv: NewBsnTlv(180),
11153 }
11154 return obj
11155}
11156
11157type BsnTlvUdfId struct {
11158 *BsnTlv
11159 Value uint16
11160}
11161
11162type IBsnTlvUdfId interface {
11163 IBsnTlv
11164 GetValue() uint16
11165}
11166
11167func (self *BsnTlvUdfId) GetValue() uint16 {
11168 return self.Value
11169}
11170
11171func (self *BsnTlvUdfId) SetValue(v uint16) {
11172 self.Value = v
11173}
11174
11175func (self *BsnTlvUdfId) Serialize(encoder *goloxi.Encoder) error {
11176 startIndex := len(encoder.Bytes())
11177 if err := self.BsnTlv.Serialize(encoder); err != nil {
11178 return err
11179 }
11180
11181 encoder.PutUint16(uint16(self.Value))
11182 length := len(encoder.Bytes()) - startIndex
11183
11184 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11185
11186 return nil
11187}
11188
11189func DecodeBsnTlvUdfId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUdfId, error) {
11190 _bsntlvudfid := &BsnTlvUdfId{BsnTlv: parent}
11191 if decoder.Length() < 2 {
11192 return nil, fmt.Errorf("BsnTlvUdfId packet too short: %d < 2", decoder.Length())
11193 }
11194 _bsntlvudfid.Value = uint16(decoder.ReadUint16())
11195 return _bsntlvudfid, nil
11196}
11197
11198func NewBsnTlvUdfId() *BsnTlvUdfId {
11199 obj := &BsnTlvUdfId{
11200 BsnTlv: NewBsnTlv(15),
11201 }
11202 return obj
11203}
11204
11205type BsnTlvUdfLength struct {
11206 *BsnTlv
11207 Value uint16
11208}
11209
11210type IBsnTlvUdfLength interface {
11211 IBsnTlv
11212 GetValue() uint16
11213}
11214
11215func (self *BsnTlvUdfLength) GetValue() uint16 {
11216 return self.Value
11217}
11218
11219func (self *BsnTlvUdfLength) SetValue(v uint16) {
11220 self.Value = v
11221}
11222
11223func (self *BsnTlvUdfLength) Serialize(encoder *goloxi.Encoder) error {
11224 startIndex := len(encoder.Bytes())
11225 if err := self.BsnTlv.Serialize(encoder); err != nil {
11226 return err
11227 }
11228
11229 encoder.PutUint16(uint16(self.Value))
11230 length := len(encoder.Bytes()) - startIndex
11231
11232 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11233
11234 return nil
11235}
11236
11237func DecodeBsnTlvUdfLength(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUdfLength, error) {
11238 _bsntlvudflength := &BsnTlvUdfLength{BsnTlv: parent}
11239 if decoder.Length() < 2 {
11240 return nil, fmt.Errorf("BsnTlvUdfLength packet too short: %d < 2", decoder.Length())
11241 }
11242 _bsntlvudflength.Value = uint16(decoder.ReadUint16())
11243 return _bsntlvudflength, nil
11244}
11245
11246func NewBsnTlvUdfLength() *BsnTlvUdfLength {
11247 obj := &BsnTlvUdfLength{
11248 BsnTlv: NewBsnTlv(18),
11249 }
11250 return obj
11251}
11252
11253type BsnTlvUdfOffset struct {
11254 *BsnTlv
11255 Value uint16
11256}
11257
11258type IBsnTlvUdfOffset interface {
11259 IBsnTlv
11260 GetValue() uint16
11261}
11262
11263func (self *BsnTlvUdfOffset) GetValue() uint16 {
11264 return self.Value
11265}
11266
11267func (self *BsnTlvUdfOffset) SetValue(v uint16) {
11268 self.Value = v
11269}
11270
11271func (self *BsnTlvUdfOffset) Serialize(encoder *goloxi.Encoder) error {
11272 startIndex := len(encoder.Bytes())
11273 if err := self.BsnTlv.Serialize(encoder); err != nil {
11274 return err
11275 }
11276
11277 encoder.PutUint16(uint16(self.Value))
11278 length := len(encoder.Bytes()) - startIndex
11279
11280 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11281
11282 return nil
11283}
11284
11285func DecodeBsnTlvUdfOffset(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUdfOffset, error) {
11286 _bsntlvudfoffset := &BsnTlvUdfOffset{BsnTlv: parent}
11287 if decoder.Length() < 2 {
11288 return nil, fmt.Errorf("BsnTlvUdfOffset packet too short: %d < 2", decoder.Length())
11289 }
11290 _bsntlvudfoffset.Value = uint16(decoder.ReadUint16())
11291 return _bsntlvudfoffset, nil
11292}
11293
11294func NewBsnTlvUdfOffset() *BsnTlvUdfOffset {
11295 obj := &BsnTlvUdfOffset{
11296 BsnTlv: NewBsnTlv(17),
11297 }
11298 return obj
11299}
11300
11301type BsnTlvUdpDst struct {
11302 *BsnTlv
11303 Value uint16
11304}
11305
11306type IBsnTlvUdpDst interface {
11307 IBsnTlv
11308 GetValue() uint16
11309}
11310
11311func (self *BsnTlvUdpDst) GetValue() uint16 {
11312 return self.Value
11313}
11314
11315func (self *BsnTlvUdpDst) SetValue(v uint16) {
11316 self.Value = v
11317}
11318
11319func (self *BsnTlvUdpDst) Serialize(encoder *goloxi.Encoder) error {
11320 startIndex := len(encoder.Bytes())
11321 if err := self.BsnTlv.Serialize(encoder); err != nil {
11322 return err
11323 }
11324
11325 encoder.PutUint16(uint16(self.Value))
11326 length := len(encoder.Bytes()) - startIndex
11327
11328 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11329
11330 return nil
11331}
11332
11333func DecodeBsnTlvUdpDst(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUdpDst, error) {
11334 _bsntlvudpdst := &BsnTlvUdpDst{BsnTlv: parent}
11335 if decoder.Length() < 2 {
11336 return nil, fmt.Errorf("BsnTlvUdpDst packet too short: %d < 2", decoder.Length())
11337 }
11338 _bsntlvudpdst.Value = uint16(decoder.ReadUint16())
11339 return _bsntlvudpdst, nil
11340}
11341
11342func NewBsnTlvUdpDst() *BsnTlvUdpDst {
11343 obj := &BsnTlvUdpDst{
11344 BsnTlv: NewBsnTlv(37),
11345 }
11346 return obj
11347}
11348
11349type BsnTlvUdpSrc struct {
11350 *BsnTlv
11351 Value uint16
11352}
11353
11354type IBsnTlvUdpSrc interface {
11355 IBsnTlv
11356 GetValue() uint16
11357}
11358
11359func (self *BsnTlvUdpSrc) GetValue() uint16 {
11360 return self.Value
11361}
11362
11363func (self *BsnTlvUdpSrc) SetValue(v uint16) {
11364 self.Value = v
11365}
11366
11367func (self *BsnTlvUdpSrc) Serialize(encoder *goloxi.Encoder) error {
11368 startIndex := len(encoder.Bytes())
11369 if err := self.BsnTlv.Serialize(encoder); err != nil {
11370 return err
11371 }
11372
11373 encoder.PutUint16(uint16(self.Value))
11374 length := len(encoder.Bytes()) - startIndex
11375
11376 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11377
11378 return nil
11379}
11380
11381func DecodeBsnTlvUdpSrc(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUdpSrc, error) {
11382 _bsntlvudpsrc := &BsnTlvUdpSrc{BsnTlv: parent}
11383 if decoder.Length() < 2 {
11384 return nil, fmt.Errorf("BsnTlvUdpSrc packet too short: %d < 2", decoder.Length())
11385 }
11386 _bsntlvudpsrc.Value = uint16(decoder.ReadUint16())
11387 return _bsntlvudpsrc, nil
11388}
11389
11390func NewBsnTlvUdpSrc() *BsnTlvUdpSrc {
11391 obj := &BsnTlvUdpSrc{
11392 BsnTlv: NewBsnTlv(36),
11393 }
11394 return obj
11395}
11396
11397type BsnTlvUint32 struct {
11398 *BsnTlv
11399 Value uint32
11400}
11401
11402type IBsnTlvUint32 interface {
11403 IBsnTlv
11404 GetValue() uint32
11405}
11406
11407func (self *BsnTlvUint32) GetValue() uint32 {
11408 return self.Value
11409}
11410
11411func (self *BsnTlvUint32) SetValue(v uint32) {
11412 self.Value = v
11413}
11414
11415func (self *BsnTlvUint32) Serialize(encoder *goloxi.Encoder) error {
11416 startIndex := len(encoder.Bytes())
11417 if err := self.BsnTlv.Serialize(encoder); err != nil {
11418 return err
11419 }
11420
11421 encoder.PutUint32(uint32(self.Value))
11422 length := len(encoder.Bytes()) - startIndex
11423
11424 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11425
11426 return nil
11427}
11428
11429func DecodeBsnTlvUint32(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUint32, error) {
11430 _bsntlvuint32 := &BsnTlvUint32{BsnTlv: parent}
11431 if decoder.Length() < 4 {
11432 return nil, fmt.Errorf("BsnTlvUint32 packet too short: %d < 4", decoder.Length())
11433 }
11434 _bsntlvuint32.Value = uint32(decoder.ReadUint32())
11435 return _bsntlvuint32, nil
11436}
11437
11438func NewBsnTlvUint32() *BsnTlvUint32 {
11439 obj := &BsnTlvUint32{
11440 BsnTlv: NewBsnTlv(167),
11441 }
11442 return obj
11443}
11444
11445type BsnTlvUint64List struct {
11446 *BsnTlv
11447 Value []*Uint64
11448}
11449
11450type IBsnTlvUint64List interface {
11451 IBsnTlv
11452 GetValue() []*Uint64
11453}
11454
11455func (self *BsnTlvUint64List) GetValue() []*Uint64 {
11456 return self.Value
11457}
11458
11459func (self *BsnTlvUint64List) SetValue(v []*Uint64) {
11460 self.Value = v
11461}
11462
11463func (self *BsnTlvUint64List) Serialize(encoder *goloxi.Encoder) error {
11464 startIndex := len(encoder.Bytes())
11465 if err := self.BsnTlv.Serialize(encoder); err != nil {
11466 return err
11467 }
11468
11469 for _, obj := range self.Value {
11470 if err := obj.Serialize(encoder); err != nil {
11471 return err
11472 }
11473 }
11474 length := len(encoder.Bytes()) - startIndex
11475
11476 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11477
11478 return nil
11479}
11480
11481func DecodeBsnTlvUint64List(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUint64List, error) {
11482 _bsntlvuint64list := &BsnTlvUint64List{BsnTlv: parent}
11483
11484 for decoder.Length() >= 8 {
11485 item, err := DecodeUint64(decoder)
11486 if err != nil {
11487 return nil, err
11488 }
11489 if item != nil {
11490 _bsntlvuint64list.Value = append(_bsntlvuint64list.Value, item)
11491 }
11492 }
11493 return _bsntlvuint64list, nil
11494}
11495
11496func NewBsnTlvUint64List() *BsnTlvUint64List {
11497 obj := &BsnTlvUint64List{
11498 BsnTlv: NewBsnTlv(119),
11499 }
11500 return obj
11501}
11502
11503type BsnTlvUnicastQueryTimeout struct {
11504 *BsnTlv
11505 Value uint32
11506}
11507
11508type IBsnTlvUnicastQueryTimeout interface {
11509 IBsnTlv
11510 GetValue() uint32
11511}
11512
11513func (self *BsnTlvUnicastQueryTimeout) GetValue() uint32 {
11514 return self.Value
11515}
11516
11517func (self *BsnTlvUnicastQueryTimeout) SetValue(v uint32) {
11518 self.Value = v
11519}
11520
11521func (self *BsnTlvUnicastQueryTimeout) Serialize(encoder *goloxi.Encoder) error {
11522 startIndex := len(encoder.Bytes())
11523 if err := self.BsnTlv.Serialize(encoder); err != nil {
11524 return err
11525 }
11526
11527 encoder.PutUint32(uint32(self.Value))
11528 length := len(encoder.Bytes()) - startIndex
11529
11530 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11531
11532 return nil
11533}
11534
11535func DecodeBsnTlvUnicastQueryTimeout(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUnicastQueryTimeout, error) {
11536 _bsntlvunicastquerytimeout := &BsnTlvUnicastQueryTimeout{BsnTlv: parent}
11537 if decoder.Length() < 4 {
11538 return nil, fmt.Errorf("BsnTlvUnicastQueryTimeout packet too short: %d < 4", decoder.Length())
11539 }
11540 _bsntlvunicastquerytimeout.Value = uint32(decoder.ReadUint32())
11541 return _bsntlvunicastquerytimeout, nil
11542}
11543
11544func NewBsnTlvUnicastQueryTimeout() *BsnTlvUnicastQueryTimeout {
11545 obj := &BsnTlvUnicastQueryTimeout{
11546 BsnTlv: NewBsnTlv(9),
11547 }
11548 return obj
11549}
11550
11551type BsnTlvUnicastRate struct {
11552 *BsnTlv
11553 Value uint32
11554}
11555
11556type IBsnTlvUnicastRate interface {
11557 IBsnTlv
11558 GetValue() uint32
11559}
11560
11561func (self *BsnTlvUnicastRate) GetValue() uint32 {
11562 return self.Value
11563}
11564
11565func (self *BsnTlvUnicastRate) SetValue(v uint32) {
11566 self.Value = v
11567}
11568
11569func (self *BsnTlvUnicastRate) Serialize(encoder *goloxi.Encoder) error {
11570 startIndex := len(encoder.Bytes())
11571 if err := self.BsnTlv.Serialize(encoder); err != nil {
11572 return err
11573 }
11574
11575 encoder.PutUint32(uint32(self.Value))
11576 length := len(encoder.Bytes()) - startIndex
11577
11578 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11579
11580 return nil
11581}
11582
11583func DecodeBsnTlvUnicastRate(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUnicastRate, error) {
11584 _bsntlvunicastrate := &BsnTlvUnicastRate{BsnTlv: parent}
11585 if decoder.Length() < 4 {
11586 return nil, fmt.Errorf("BsnTlvUnicastRate packet too short: %d < 4", decoder.Length())
11587 }
11588 _bsntlvunicastrate.Value = uint32(decoder.ReadUint32())
11589 return _bsntlvunicastrate, nil
11590}
11591
11592func NewBsnTlvUnicastRate() *BsnTlvUnicastRate {
11593 obj := &BsnTlvUnicastRate{
11594 BsnTlv: NewBsnTlv(93),
11595 }
11596 return obj
11597}
11598
11599type BsnTlvUnknownMulticastRate struct {
11600 *BsnTlv
11601 Value uint32
11602}
11603
11604type IBsnTlvUnknownMulticastRate interface {
11605 IBsnTlv
11606 GetValue() uint32
11607}
11608
11609func (self *BsnTlvUnknownMulticastRate) GetValue() uint32 {
11610 return self.Value
11611}
11612
11613func (self *BsnTlvUnknownMulticastRate) SetValue(v uint32) {
11614 self.Value = v
11615}
11616
11617func (self *BsnTlvUnknownMulticastRate) Serialize(encoder *goloxi.Encoder) error {
11618 startIndex := len(encoder.Bytes())
11619 if err := self.BsnTlv.Serialize(encoder); err != nil {
11620 return err
11621 }
11622
11623 encoder.PutUint32(uint32(self.Value))
11624 length := len(encoder.Bytes()) - startIndex
11625
11626 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11627
11628 return nil
11629}
11630
11631func DecodeBsnTlvUnknownMulticastRate(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUnknownMulticastRate, error) {
11632 _bsntlvunknownmulticastrate := &BsnTlvUnknownMulticastRate{BsnTlv: parent}
11633 if decoder.Length() < 4 {
11634 return nil, fmt.Errorf("BsnTlvUnknownMulticastRate packet too short: %d < 4", decoder.Length())
11635 }
11636 _bsntlvunknownmulticastrate.Value = uint32(decoder.ReadUint32())
11637 return _bsntlvunknownmulticastrate, nil
11638}
11639
11640func NewBsnTlvUnknownMulticastRate() *BsnTlvUnknownMulticastRate {
11641 obj := &BsnTlvUnknownMulticastRate{
11642 BsnTlv: NewBsnTlv(92),
11643 }
11644 return obj
11645}
11646
11647type BsnTlvUntagged struct {
11648 *BsnTlv
11649}
11650
11651type IBsnTlvUntagged interface {
11652 IBsnTlv
11653}
11654
11655func (self *BsnTlvUntagged) Serialize(encoder *goloxi.Encoder) error {
11656 startIndex := len(encoder.Bytes())
11657 if err := self.BsnTlv.Serialize(encoder); err != nil {
11658 return err
11659 }
11660 length := len(encoder.Bytes()) - startIndex
11661
11662 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11663
11664 return nil
11665}
11666
11667func DecodeBsnTlvUntagged(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUntagged, error) {
11668 _bsntlvuntagged := &BsnTlvUntagged{BsnTlv: parent}
11669 return _bsntlvuntagged, nil
11670}
11671
11672func NewBsnTlvUntagged() *BsnTlvUntagged {
11673 obj := &BsnTlvUntagged{
11674 BsnTlv: NewBsnTlv(106),
11675 }
11676 return obj
11677}
11678
11679type BsnTlvUpgrade struct {
11680 *BsnTlv
11681 Value BsnUpgrade
11682}
11683
11684type IBsnTlvUpgrade interface {
11685 IBsnTlv
11686 GetValue() BsnUpgrade
11687}
11688
11689func (self *BsnTlvUpgrade) GetValue() BsnUpgrade {
11690 return self.Value
11691}
11692
11693func (self *BsnTlvUpgrade) SetValue(v BsnUpgrade) {
11694 self.Value = v
11695}
11696
11697func (self *BsnTlvUpgrade) Serialize(encoder *goloxi.Encoder) error {
11698 startIndex := len(encoder.Bytes())
11699 if err := self.BsnTlv.Serialize(encoder); err != nil {
11700 return err
11701 }
11702
11703 encoder.PutUint16(uint16(self.Value))
11704 length := len(encoder.Bytes()) - startIndex
11705
11706 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11707
11708 return nil
11709}
11710
11711func DecodeBsnTlvUpgrade(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUpgrade, error) {
11712 _bsntlvupgrade := &BsnTlvUpgrade{BsnTlv: parent}
11713 if decoder.Length() < 2 {
11714 return nil, fmt.Errorf("BsnTlvUpgrade packet too short: %d < 2", decoder.Length())
11715 }
11716 _bsntlvupgrade.Value = BsnUpgrade(decoder.ReadUint16())
11717 return _bsntlvupgrade, nil
11718}
11719
11720func NewBsnTlvUpgrade() *BsnTlvUpgrade {
11721 obj := &BsnTlvUpgrade{
11722 BsnTlv: NewBsnTlv(164),
11723 }
11724 return obj
11725}
11726
11727type BsnTlvUriScheme struct {
11728 *BsnTlv
11729 Value []byte
11730}
11731
11732type IBsnTlvUriScheme interface {
11733 IBsnTlv
11734 GetValue() []byte
11735}
11736
11737func (self *BsnTlvUriScheme) GetValue() []byte {
11738 return self.Value
11739}
11740
11741func (self *BsnTlvUriScheme) SetValue(v []byte) {
11742 self.Value = v
11743}
11744
11745func (self *BsnTlvUriScheme) Serialize(encoder *goloxi.Encoder) error {
11746 startIndex := len(encoder.Bytes())
11747 if err := self.BsnTlv.Serialize(encoder); err != nil {
11748 return err
11749 }
11750
11751 encoder.Write(self.Value)
11752 length := len(encoder.Bytes()) - startIndex
11753
11754 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11755
11756 return nil
11757}
11758
11759func DecodeBsnTlvUriScheme(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUriScheme, error) {
11760 _bsntlvurischeme := &BsnTlvUriScheme{BsnTlv: parent}
11761 _bsntlvurischeme.Value = decoder.Read(int(decoder.Length()))
11762 return _bsntlvurischeme, nil
11763}
11764
11765func NewBsnTlvUriScheme() *BsnTlvUriScheme {
11766 obj := &BsnTlvUriScheme{
11767 BsnTlv: NewBsnTlv(153),
11768 }
11769 return obj
11770}
11771
11772type BsnTlvUsePacketState struct {
11773 *BsnTlv
11774 Value uint8
11775}
11776
11777type IBsnTlvUsePacketState interface {
11778 IBsnTlv
11779 GetValue() uint8
11780}
11781
11782func (self *BsnTlvUsePacketState) GetValue() uint8 {
11783 return self.Value
11784}
11785
11786func (self *BsnTlvUsePacketState) SetValue(v uint8) {
11787 self.Value = v
11788}
11789
11790func (self *BsnTlvUsePacketState) Serialize(encoder *goloxi.Encoder) error {
11791 startIndex := len(encoder.Bytes())
11792 if err := self.BsnTlv.Serialize(encoder); err != nil {
11793 return err
11794 }
11795
11796 encoder.PutUint8(uint8(self.Value))
11797 length := len(encoder.Bytes()) - startIndex
11798
11799 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11800
11801 return nil
11802}
11803
11804func DecodeBsnTlvUsePacketState(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUsePacketState, error) {
11805 _bsntlvusepacketstate := &BsnTlvUsePacketState{BsnTlv: parent}
11806 if decoder.Length() < 1 {
11807 return nil, fmt.Errorf("BsnTlvUsePacketState packet too short: %d < 1", decoder.Length())
11808 }
11809 _bsntlvusepacketstate.Value = uint8(decoder.ReadByte())
11810 return _bsntlvusepacketstate, nil
11811}
11812
11813func NewBsnTlvUsePacketState() *BsnTlvUsePacketState {
11814 obj := &BsnTlvUsePacketState{
11815 BsnTlv: NewBsnTlv(96),
11816 }
11817 return obj
11818}
11819
11820type BsnTlvUserConfigured struct {
11821 *BsnTlv
11822}
11823
11824type IBsnTlvUserConfigured interface {
11825 IBsnTlv
11826}
11827
11828func (self *BsnTlvUserConfigured) Serialize(encoder *goloxi.Encoder) error {
11829 startIndex := len(encoder.Bytes())
11830 if err := self.BsnTlv.Serialize(encoder); err != nil {
11831 return err
11832 }
11833 length := len(encoder.Bytes()) - startIndex
11834
11835 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11836
11837 return nil
11838}
11839
11840func DecodeBsnTlvUserConfigured(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvUserConfigured, error) {
11841 _bsntlvuserconfigured := &BsnTlvUserConfigured{BsnTlv: parent}
11842 return _bsntlvuserconfigured, nil
11843}
11844
11845func NewBsnTlvUserConfigured() *BsnTlvUserConfigured {
11846 obj := &BsnTlvUserConfigured{
11847 BsnTlv: NewBsnTlv(166),
11848 }
11849 return obj
11850}
11851
11852type BsnTlvVfi struct {
11853 *BsnTlv
11854 Value uint16
11855}
11856
11857type IBsnTlvVfi interface {
11858 IBsnTlv
11859 GetValue() uint16
11860}
11861
11862func (self *BsnTlvVfi) GetValue() uint16 {
11863 return self.Value
11864}
11865
11866func (self *BsnTlvVfi) SetValue(v uint16) {
11867 self.Value = v
11868}
11869
11870func (self *BsnTlvVfi) Serialize(encoder *goloxi.Encoder) error {
11871 startIndex := len(encoder.Bytes())
11872 if err := self.BsnTlv.Serialize(encoder); err != nil {
11873 return err
11874 }
11875
11876 encoder.PutUint16(uint16(self.Value))
11877 length := len(encoder.Bytes()) - startIndex
11878
11879 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11880
11881 return nil
11882}
11883
11884func DecodeBsnTlvVfi(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVfi, error) {
11885 _bsntlvvfi := &BsnTlvVfi{BsnTlv: parent}
11886 if decoder.Length() < 2 {
11887 return nil, fmt.Errorf("BsnTlvVfi packet too short: %d < 2", decoder.Length())
11888 }
11889 _bsntlvvfi.Value = uint16(decoder.ReadUint16())
11890 return _bsntlvvfi, nil
11891}
11892
11893func NewBsnTlvVfi() *BsnTlvVfi {
11894 obj := &BsnTlvVfi{
11895 BsnTlv: NewBsnTlv(99),
11896 }
11897 return obj
11898}
11899
11900type BsnTlvVfpClassId struct {
11901 *BsnTlv
11902 Value uint32
11903}
11904
11905type IBsnTlvVfpClassId interface {
11906 IBsnTlv
11907 GetValue() uint32
11908}
11909
11910func (self *BsnTlvVfpClassId) GetValue() uint32 {
11911 return self.Value
11912}
11913
11914func (self *BsnTlvVfpClassId) SetValue(v uint32) {
11915 self.Value = v
11916}
11917
11918func (self *BsnTlvVfpClassId) Serialize(encoder *goloxi.Encoder) error {
11919 startIndex := len(encoder.Bytes())
11920 if err := self.BsnTlv.Serialize(encoder); err != nil {
11921 return err
11922 }
11923
11924 encoder.PutUint32(uint32(self.Value))
11925 length := len(encoder.Bytes()) - startIndex
11926
11927 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11928
11929 return nil
11930}
11931
11932func DecodeBsnTlvVfpClassId(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVfpClassId, error) {
11933 _bsntlvvfpclassid := &BsnTlvVfpClassId{BsnTlv: parent}
11934 if decoder.Length() < 4 {
11935 return nil, fmt.Errorf("BsnTlvVfpClassId packet too short: %d < 4", decoder.Length())
11936 }
11937 _bsntlvvfpclassid.Value = uint32(decoder.ReadUint32())
11938 return _bsntlvvfpclassid, nil
11939}
11940
11941func NewBsnTlvVfpClassId() *BsnTlvVfpClassId {
11942 obj := &BsnTlvVfpClassId{
11943 BsnTlv: NewBsnTlv(107),
11944 }
11945 return obj
11946}
11947
11948type BsnTlvVirtual struct {
11949 *BsnTlv
11950}
11951
11952type IBsnTlvVirtual interface {
11953 IBsnTlv
11954}
11955
11956func (self *BsnTlvVirtual) Serialize(encoder *goloxi.Encoder) error {
11957 startIndex := len(encoder.Bytes())
11958 if err := self.BsnTlv.Serialize(encoder); err != nil {
11959 return err
11960 }
11961 length := len(encoder.Bytes()) - startIndex
11962
11963 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
11964
11965 return nil
11966}
11967
11968func DecodeBsnTlvVirtual(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVirtual, error) {
11969 _bsntlvvirtual := &BsnTlvVirtual{BsnTlv: parent}
11970 return _bsntlvvirtual, nil
11971}
11972
11973func NewBsnTlvVirtual() *BsnTlvVirtual {
11974 obj := &BsnTlvVirtual{
11975 BsnTlv: NewBsnTlv(158),
11976 }
11977 return obj
11978}
11979
11980type BsnTlvVlanMacList struct {
11981 *BsnTlv
11982 Key []*BsnVlanMac
11983}
11984
11985type IBsnTlvVlanMacList interface {
11986 IBsnTlv
11987 GetKey() []*BsnVlanMac
11988}
11989
11990func (self *BsnTlvVlanMacList) GetKey() []*BsnVlanMac {
11991 return self.Key
11992}
11993
11994func (self *BsnTlvVlanMacList) SetKey(v []*BsnVlanMac) {
11995 self.Key = v
11996}
11997
11998func (self *BsnTlvVlanMacList) Serialize(encoder *goloxi.Encoder) error {
11999 startIndex := len(encoder.Bytes())
12000 if err := self.BsnTlv.Serialize(encoder); err != nil {
12001 return err
12002 }
12003
12004 for _, obj := range self.Key {
12005 if err := obj.Serialize(encoder); err != nil {
12006 return err
12007 }
12008 }
12009 length := len(encoder.Bytes()) - startIndex
12010
12011 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
12012
12013 return nil
12014}
12015
12016func DecodeBsnTlvVlanMacList(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVlanMacList, error) {
12017 _bsntlvvlanmaclist := &BsnTlvVlanMacList{BsnTlv: parent}
12018
12019 for decoder.Length() >= 8 {
12020 item, err := DecodeBsnVlanMac(decoder)
12021 if err != nil {
12022 return nil, err
12023 }
12024 if item != nil {
12025 _bsntlvvlanmaclist.Key = append(_bsntlvvlanmaclist.Key, item)
12026 }
12027 }
12028 return _bsntlvvlanmaclist, nil
12029}
12030
12031func NewBsnTlvVlanMacList() *BsnTlvVlanMacList {
12032 obj := &BsnTlvVlanMacList{
12033 BsnTlv: NewBsnTlv(98),
12034 }
12035 return obj
12036}
12037
12038type BsnTlvVlanPcp struct {
12039 *BsnTlv
12040 Value uint8
12041}
12042
12043type IBsnTlvVlanPcp interface {
12044 IBsnTlv
12045 GetValue() uint8
12046}
12047
12048func (self *BsnTlvVlanPcp) GetValue() uint8 {
12049 return self.Value
12050}
12051
12052func (self *BsnTlvVlanPcp) SetValue(v uint8) {
12053 self.Value = v
12054}
12055
12056func (self *BsnTlvVlanPcp) Serialize(encoder *goloxi.Encoder) error {
12057 startIndex := len(encoder.Bytes())
12058 if err := self.BsnTlv.Serialize(encoder); err != nil {
12059 return err
12060 }
12061
12062 encoder.PutUint8(uint8(self.Value))
12063 length := len(encoder.Bytes()) - startIndex
12064
12065 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
12066
12067 return nil
12068}
12069
12070func DecodeBsnTlvVlanPcp(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVlanPcp, error) {
12071 _bsntlvvlanpcp := &BsnTlvVlanPcp{BsnTlv: parent}
12072 if decoder.Length() < 1 {
12073 return nil, fmt.Errorf("BsnTlvVlanPcp packet too short: %d < 1", decoder.Length())
12074 }
12075 _bsntlvvlanpcp.Value = uint8(decoder.ReadByte())
12076 return _bsntlvvlanpcp, nil
12077}
12078
12079func NewBsnTlvVlanPcp() *BsnTlvVlanPcp {
12080 obj := &BsnTlvVlanPcp{
12081 BsnTlv: NewBsnTlv(72),
12082 }
12083 return obj
12084}
12085
12086type BsnTlvVlanVid struct {
12087 *BsnTlv
12088 Value uint16
12089}
12090
12091type IBsnTlvVlanVid interface {
12092 IBsnTlv
12093 GetValue() uint16
12094}
12095
12096func (self *BsnTlvVlanVid) GetValue() uint16 {
12097 return self.Value
12098}
12099
12100func (self *BsnTlvVlanVid) SetValue(v uint16) {
12101 self.Value = v
12102}
12103
12104func (self *BsnTlvVlanVid) Serialize(encoder *goloxi.Encoder) error {
12105 startIndex := len(encoder.Bytes())
12106 if err := self.BsnTlv.Serialize(encoder); err != nil {
12107 return err
12108 }
12109
12110 encoder.PutUint16(uint16(self.Value))
12111 length := len(encoder.Bytes()) - startIndex
12112
12113 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
12114
12115 return nil
12116}
12117
12118func DecodeBsnTlvVlanVid(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVlanVid, error) {
12119 _bsntlvvlanvid := &BsnTlvVlanVid{BsnTlv: parent}
12120 if decoder.Length() < 2 {
12121 return nil, fmt.Errorf("BsnTlvVlanVid packet too short: %d < 2", decoder.Length())
12122 }
12123 _bsntlvvlanvid.Value = uint16(decoder.ReadUint16())
12124 return _bsntlvvlanvid, nil
12125}
12126
12127func NewBsnTlvVlanVid() *BsnTlvVlanVid {
12128 obj := &BsnTlvVlanVid{
12129 BsnTlv: NewBsnTlv(6),
12130 }
12131 return obj
12132}
12133
12134type BsnTlvVlanVidMask struct {
12135 *BsnTlv
12136 Value uint16
12137}
12138
12139type IBsnTlvVlanVidMask interface {
12140 IBsnTlv
12141 GetValue() uint16
12142}
12143
12144func (self *BsnTlvVlanVidMask) GetValue() uint16 {
12145 return self.Value
12146}
12147
12148func (self *BsnTlvVlanVidMask) SetValue(v uint16) {
12149 self.Value = v
12150}
12151
12152func (self *BsnTlvVlanVidMask) Serialize(encoder *goloxi.Encoder) error {
12153 startIndex := len(encoder.Bytes())
12154 if err := self.BsnTlv.Serialize(encoder); err != nil {
12155 return err
12156 }
12157
12158 encoder.PutUint16(uint16(self.Value))
12159 length := len(encoder.Bytes()) - startIndex
12160
12161 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
12162
12163 return nil
12164}
12165
12166func DecodeBsnTlvVlanVidMask(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVlanVidMask, error) {
12167 _bsntlvvlanvidmask := &BsnTlvVlanVidMask{BsnTlv: parent}
12168 if decoder.Length() < 2 {
12169 return nil, fmt.Errorf("BsnTlvVlanVidMask packet too short: %d < 2", decoder.Length())
12170 }
12171 _bsntlvvlanvidmask.Value = uint16(decoder.ReadUint16())
12172 return _bsntlvvlanvidmask, nil
12173}
12174
12175func NewBsnTlvVlanVidMask() *BsnTlvVlanVidMask {
12176 obj := &BsnTlvVlanVidMask{
12177 BsnTlv: NewBsnTlv(77),
12178 }
12179 return obj
12180}
12181
12182type BsnTlvVni struct {
12183 *BsnTlv
12184 Value uint32
12185}
12186
12187type IBsnTlvVni interface {
12188 IBsnTlv
12189 GetValue() uint32
12190}
12191
12192func (self *BsnTlvVni) GetValue() uint32 {
12193 return self.Value
12194}
12195
12196func (self *BsnTlvVni) SetValue(v uint32) {
12197 self.Value = v
12198}
12199
12200func (self *BsnTlvVni) Serialize(encoder *goloxi.Encoder) error {
12201 startIndex := len(encoder.Bytes())
12202 if err := self.BsnTlv.Serialize(encoder); err != nil {
12203 return err
12204 }
12205
12206 encoder.PutUint32(uint32(self.Value))
12207 length := len(encoder.Bytes()) - startIndex
12208
12209 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
12210
12211 return nil
12212}
12213
12214func DecodeBsnTlvVni(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVni, error) {
12215 _bsntlvvni := &BsnTlvVni{BsnTlv: parent}
12216 if decoder.Length() < 4 {
12217 return nil, fmt.Errorf("BsnTlvVni packet too short: %d < 4", decoder.Length())
12218 }
12219 _bsntlvvni.Value = uint32(decoder.ReadUint32())
12220 return _bsntlvvni, nil
12221}
12222
12223func NewBsnTlvVni() *BsnTlvVni {
12224 obj := &BsnTlvVni{
12225 BsnTlv: NewBsnTlv(86),
12226 }
12227 return obj
12228}
12229
12230type BsnTlvVpnKey struct {
12231 *BsnTlv
12232 Value uint32
12233}
12234
12235type IBsnTlvVpnKey interface {
12236 IBsnTlv
12237 GetValue() uint32
12238}
12239
12240func (self *BsnTlvVpnKey) GetValue() uint32 {
12241 return self.Value
12242}
12243
12244func (self *BsnTlvVpnKey) SetValue(v uint32) {
12245 self.Value = v
12246}
12247
12248func (self *BsnTlvVpnKey) Serialize(encoder *goloxi.Encoder) error {
12249 startIndex := len(encoder.Bytes())
12250 if err := self.BsnTlv.Serialize(encoder); err != nil {
12251 return err
12252 }
12253
12254 encoder.PutUint32(uint32(self.Value))
12255 length := len(encoder.Bytes()) - startIndex
12256
12257 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
12258
12259 return nil
12260}
12261
12262func DecodeBsnTlvVpnKey(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVpnKey, error) {
12263 _bsntlvvpnkey := &BsnTlvVpnKey{BsnTlv: parent}
12264 if decoder.Length() < 4 {
12265 return nil, fmt.Errorf("BsnTlvVpnKey packet too short: %d < 4", decoder.Length())
12266 }
12267 _bsntlvvpnkey.Value = uint32(decoder.ReadUint32())
12268 return _bsntlvvpnkey, nil
12269}
12270
12271func NewBsnTlvVpnKey() *BsnTlvVpnKey {
12272 obj := &BsnTlvVpnKey{
12273 BsnTlv: NewBsnTlv(111),
12274 }
12275 return obj
12276}
12277
12278type BsnTlvVrf struct {
12279 *BsnTlv
12280 Value uint32
12281}
12282
12283type IBsnTlvVrf interface {
12284 IBsnTlv
12285 GetValue() uint32
12286}
12287
12288func (self *BsnTlvVrf) GetValue() uint32 {
12289 return self.Value
12290}
12291
12292func (self *BsnTlvVrf) SetValue(v uint32) {
12293 self.Value = v
12294}
12295
12296func (self *BsnTlvVrf) Serialize(encoder *goloxi.Encoder) error {
12297 startIndex := len(encoder.Bytes())
12298 if err := self.BsnTlv.Serialize(encoder); err != nil {
12299 return err
12300 }
12301
12302 encoder.PutUint32(uint32(self.Value))
12303 length := len(encoder.Bytes()) - startIndex
12304
12305 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
12306
12307 return nil
12308}
12309
12310func DecodeBsnTlvVrf(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVrf, error) {
12311 _bsntlvvrf := &BsnTlvVrf{BsnTlv: parent}
12312 if decoder.Length() < 4 {
12313 return nil, fmt.Errorf("BsnTlvVrf packet too short: %d < 4", decoder.Length())
12314 }
12315 _bsntlvvrf.Value = uint32(decoder.ReadUint32())
12316 return _bsntlvvrf, nil
12317}
12318
12319func NewBsnTlvVrf() *BsnTlvVrf {
12320 obj := &BsnTlvVrf{
12321 BsnTlv: NewBsnTlv(19),
12322 }
12323 return obj
12324}
12325
12326type BsnTlvVxlanEgressLag struct {
12327 *BsnTlv
12328}
12329
12330type IBsnTlvVxlanEgressLag interface {
12331 IBsnTlv
12332}
12333
12334func (self *BsnTlvVxlanEgressLag) Serialize(encoder *goloxi.Encoder) error {
12335 startIndex := len(encoder.Bytes())
12336 if err := self.BsnTlv.Serialize(encoder); err != nil {
12337 return err
12338 }
12339 length := len(encoder.Bytes()) - startIndex
12340
12341 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
12342
12343 return nil
12344}
12345
12346func DecodeBsnTlvVxlanEgressLag(parent *BsnTlv, decoder *goloxi.Decoder) (*BsnTlvVxlanEgressLag, error) {
12347 _bsntlvvxlanegresslag := &BsnTlvVxlanEgressLag{BsnTlv: parent}
12348 return _bsntlvvxlanegresslag, nil
12349}
12350
12351func NewBsnTlvVxlanEgressLag() *BsnTlvVxlanEgressLag {
12352 obj := &BsnTlvVxlanEgressLag{
12353 BsnTlv: NewBsnTlv(117),
12354 }
12355 return obj
12356}
12357
12358type BsnVport struct {
12359 Type uint16
12360 Length uint16
12361}
12362
12363type IBsnVport interface {
12364 goloxi.Serializable
12365 GetType() uint16
12366 GetLength() uint16
12367}
12368
12369func (self *BsnVport) GetType() uint16 {
12370 return self.Type
12371}
12372
12373func (self *BsnVport) SetType(v uint16) {
12374 self.Type = v
12375}
12376
12377func (self *BsnVport) GetLength() uint16 {
12378 return self.Length
12379}
12380
12381func (self *BsnVport) SetLength(v uint16) {
12382 self.Length = v
12383}
12384
12385func (self *BsnVport) Serialize(encoder *goloxi.Encoder) error {
12386
12387 encoder.PutUint16(uint16(self.Type))
12388 encoder.PutUint16(uint16(self.Length))
12389
12390 return nil
12391}
12392func (self *BsnVport) Decode(decoder *goloxi.Decoder) error {
12393 if decoder.Length() < 4 {
12394 return fmt.Errorf("BsnVport packet too short: %d < 4", decoder.Length())
12395 }
12396
12397 self.Type = uint16(decoder.ReadUint16())
12398 self.Length = uint16(decoder.ReadUint16())
12399 oldDecoder := decoder
12400 defer func() { decoder = oldDecoder }()
12401 decoder = decoder.SliceDecoder(int(self.Length), 2+2)
12402
12403 return nil
12404}
12405
12406func NewBsnVport(_type uint16) *BsnVport {
12407 obj := &BsnVport{}
12408 obj.Type = _type
12409 return obj
12410}
12411
12412type BsnVlanCounterStatsEntry struct {
12413 Length uint16
12414 VlanVid uint16
12415 Values []*Uint64
12416}
12417
12418type IBsnVlanCounterStatsEntry interface {
12419 goloxi.Serializable
12420 GetLength() uint16
12421 GetVlanVid() uint16
12422 GetValues() []*Uint64
12423}
12424
12425func (self *BsnVlanCounterStatsEntry) GetLength() uint16 {
12426 return self.Length
12427}
12428
12429func (self *BsnVlanCounterStatsEntry) SetLength(v uint16) {
12430 self.Length = v
12431}
12432
12433func (self *BsnVlanCounterStatsEntry) GetVlanVid() uint16 {
12434 return self.VlanVid
12435}
12436
12437func (self *BsnVlanCounterStatsEntry) SetVlanVid(v uint16) {
12438 self.VlanVid = v
12439}
12440
12441func (self *BsnVlanCounterStatsEntry) GetValues() []*Uint64 {
12442 return self.Values
12443}
12444
12445func (self *BsnVlanCounterStatsEntry) SetValues(v []*Uint64) {
12446 self.Values = v
12447}
12448
12449func (self *BsnVlanCounterStatsEntry) Serialize(encoder *goloxi.Encoder) error {
12450 startIndex := len(encoder.Bytes())
12451
12452 encoder.PutUint16(uint16(self.Length))
12453 encoder.PutUint16(uint16(self.VlanVid))
12454 encoder.Write(bytes.Repeat([]byte{0}, 4))
12455 for _, obj := range self.Values {
12456 if err := obj.Serialize(encoder); err != nil {
12457 return err
12458 }
12459 }
12460 length := len(encoder.Bytes()) - startIndex
12461
12462 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
12463
12464 return nil
12465}
12466
12467func DecodeBsnVlanCounterStatsEntry(decoder *goloxi.Decoder) (*BsnVlanCounterStatsEntry, error) {
12468 _bsnvlancounterstatsentry := &BsnVlanCounterStatsEntry{}
12469 if decoder.Length() < 8 {
12470 return nil, fmt.Errorf("BsnVlanCounterStatsEntry packet too short: %d < 8", decoder.Length())
12471 }
12472 _bsnvlancounterstatsentry.Length = uint16(decoder.ReadUint16())
12473 oldDecoder := decoder
12474 defer func() { decoder = oldDecoder }()
12475 decoder = decoder.SliceDecoder(int(_bsnvlancounterstatsentry.Length), 2+0)
12476 _bsnvlancounterstatsentry.VlanVid = uint16(decoder.ReadUint16())
12477 decoder.Skip(4)
12478
12479 for decoder.Length() >= 8 {
12480 item, err := DecodeUint64(decoder)
12481 if err != nil {
12482 return nil, err
12483 }
12484 if item != nil {
12485 _bsnvlancounterstatsentry.Values = append(_bsnvlancounterstatsentry.Values, item)
12486 }
12487 }
12488 return _bsnvlancounterstatsentry, nil
12489}
12490
12491func NewBsnVlanCounterStatsEntry() *BsnVlanCounterStatsEntry {
12492 obj := &BsnVlanCounterStatsEntry{}
12493 return obj
12494}
12495
12496type BsnVlanMac struct {
12497 VlanVid uint16
12498 Mac net.HardwareAddr
12499}
12500
12501type IBsnVlanMac interface {
12502 goloxi.Serializable
12503 GetVlanVid() uint16
12504 GetMac() net.HardwareAddr
12505}
12506
12507func (self *BsnVlanMac) GetVlanVid() uint16 {
12508 return self.VlanVid
12509}
12510
12511func (self *BsnVlanMac) SetVlanVid(v uint16) {
12512 self.VlanVid = v
12513}
12514
12515func (self *BsnVlanMac) GetMac() net.HardwareAddr {
12516 return self.Mac
12517}
12518
12519func (self *BsnVlanMac) SetMac(v net.HardwareAddr) {
12520 self.Mac = v
12521}
12522
12523func (self *BsnVlanMac) Serialize(encoder *goloxi.Encoder) error {
12524
12525 encoder.PutUint16(uint16(self.VlanVid))
12526 encoder.Write(self.Mac)
12527
12528 return nil
12529}
12530
12531func DecodeBsnVlanMac(decoder *goloxi.Decoder) (*BsnVlanMac, error) {
12532 _bsnvlanmac := &BsnVlanMac{}
12533 if decoder.Length() < 8 {
12534 return nil, fmt.Errorf("BsnVlanMac packet too short: %d < 8", decoder.Length())
12535 }
12536 _bsnvlanmac.VlanVid = uint16(decoder.ReadUint16())
12537 _bsnvlanmac.Mac = net.HardwareAddr(decoder.Read(6))
12538 return _bsnvlanmac, nil
12539}
12540
12541func NewBsnVlanMac() *BsnVlanMac {
12542 obj := &BsnVlanMac{}
12543 return obj
12544}
12545
12546type BsnVportL2Gre struct {
12547 *BsnVport
12548 Flags BsnVportL2GreFlags
12549 PortNo Port
12550 LoopbackPortNo Port
12551 LocalMac net.HardwareAddr
12552 NhMac net.HardwareAddr
12553 SrcIp net.IP
12554 DstIp net.IP
12555 Dscp uint8
12556 Ttl uint8
12557 Vpn uint32
12558 RateLimit uint32
12559 IfName string
12560}
12561
12562type IBsnVportL2Gre interface {
12563 IBsnVport
12564 GetFlags() BsnVportL2GreFlags
12565 GetPortNo() Port
12566 GetLoopbackPortNo() Port
12567 GetLocalMac() net.HardwareAddr
12568 GetNhMac() net.HardwareAddr
12569 GetSrcIp() net.IP
12570 GetDstIp() net.IP
12571 GetDscp() uint8
12572 GetTtl() uint8
12573 GetVpn() uint32
12574 GetRateLimit() uint32
12575 GetIfName() string
12576}
12577
12578func (self *BsnVportL2Gre) GetFlags() BsnVportL2GreFlags {
12579 return self.Flags
12580}
12581
12582func (self *BsnVportL2Gre) SetFlags(v BsnVportL2GreFlags) {
12583 self.Flags = v
12584}
12585
12586func (self *BsnVportL2Gre) GetPortNo() Port {
12587 return self.PortNo
12588}
12589
12590func (self *BsnVportL2Gre) SetPortNo(v Port) {
12591 self.PortNo = v
12592}
12593
12594func (self *BsnVportL2Gre) GetLoopbackPortNo() Port {
12595 return self.LoopbackPortNo
12596}
12597
12598func (self *BsnVportL2Gre) SetLoopbackPortNo(v Port) {
12599 self.LoopbackPortNo = v
12600}
12601
12602func (self *BsnVportL2Gre) GetLocalMac() net.HardwareAddr {
12603 return self.LocalMac
12604}
12605
12606func (self *BsnVportL2Gre) SetLocalMac(v net.HardwareAddr) {
12607 self.LocalMac = v
12608}
12609
12610func (self *BsnVportL2Gre) GetNhMac() net.HardwareAddr {
12611 return self.NhMac
12612}
12613
12614func (self *BsnVportL2Gre) SetNhMac(v net.HardwareAddr) {
12615 self.NhMac = v
12616}
12617
12618func (self *BsnVportL2Gre) GetSrcIp() net.IP {
12619 return self.SrcIp
12620}
12621
12622func (self *BsnVportL2Gre) SetSrcIp(v net.IP) {
12623 self.SrcIp = v
12624}
12625
12626func (self *BsnVportL2Gre) GetDstIp() net.IP {
12627 return self.DstIp
12628}
12629
12630func (self *BsnVportL2Gre) SetDstIp(v net.IP) {
12631 self.DstIp = v
12632}
12633
12634func (self *BsnVportL2Gre) GetDscp() uint8 {
12635 return self.Dscp
12636}
12637
12638func (self *BsnVportL2Gre) SetDscp(v uint8) {
12639 self.Dscp = v
12640}
12641
12642func (self *BsnVportL2Gre) GetTtl() uint8 {
12643 return self.Ttl
12644}
12645
12646func (self *BsnVportL2Gre) SetTtl(v uint8) {
12647 self.Ttl = v
12648}
12649
12650func (self *BsnVportL2Gre) GetVpn() uint32 {
12651 return self.Vpn
12652}
12653
12654func (self *BsnVportL2Gre) SetVpn(v uint32) {
12655 self.Vpn = v
12656}
12657
12658func (self *BsnVportL2Gre) GetRateLimit() uint32 {
12659 return self.RateLimit
12660}
12661
12662func (self *BsnVportL2Gre) SetRateLimit(v uint32) {
12663 self.RateLimit = v
12664}
12665
12666func (self *BsnVportL2Gre) GetIfName() string {
12667 return self.IfName
12668}
12669
12670func (self *BsnVportL2Gre) SetIfName(v string) {
12671 self.IfName = v
12672}
12673
12674func (self *BsnVportL2Gre) Serialize(encoder *goloxi.Encoder) error {
12675 startIndex := len(encoder.Bytes())
12676 if err := self.BsnVport.Serialize(encoder); err != nil {
12677 return err
12678 }
12679
12680 encoder.PutUint32(uint32(self.Flags))
12681 self.PortNo.Serialize(encoder)
12682 self.LoopbackPortNo.Serialize(encoder)
12683 encoder.Write(self.LocalMac)
12684 encoder.Write(self.NhMac)
12685 encoder.Write(self.SrcIp.To4())
12686 encoder.Write(self.DstIp.To4())
12687 encoder.PutUint8(uint8(self.Dscp))
12688 encoder.PutUint8(uint8(self.Ttl))
12689 encoder.Write(bytes.Repeat([]byte{0}, 2))
12690 encoder.PutUint32(uint32(self.Vpn))
12691 encoder.PutUint32(uint32(self.RateLimit))
12692 encoder.Write([]byte(self.IfName))
12693 length := len(encoder.Bytes()) - startIndex
12694
12695 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
12696
12697 return nil
12698}
12699
12700func DecodeBsnVportL2Gre(parent *BsnVport, decoder *goloxi.Decoder) (*BsnVportL2Gre, error) {
12701 _bsnvportl2gre := &BsnVportL2Gre{BsnVport: parent}
12702 if decoder.Length() < 60 {
12703 return nil, fmt.Errorf("BsnVportL2Gre packet too short: %d < 60", decoder.Length())
12704 }
12705 _bsnvportl2gre.Flags = BsnVportL2GreFlags(decoder.ReadUint32())
12706 _bsnvportl2gre.PortNo.Decode(decoder)
12707 _bsnvportl2gre.LoopbackPortNo.Decode(decoder)
12708 _bsnvportl2gre.LocalMac = net.HardwareAddr(decoder.Read(6))
12709 _bsnvportl2gre.NhMac = net.HardwareAddr(decoder.Read(6))
12710 _bsnvportl2gre.SrcIp = net.IP(decoder.Read(4))
12711 _bsnvportl2gre.DstIp = net.IP(decoder.Read(4))
12712 _bsnvportl2gre.Dscp = uint8(decoder.ReadByte())
12713 _bsnvportl2gre.Ttl = uint8(decoder.ReadByte())
12714 decoder.Skip(2)
12715 _bsnvportl2gre.Vpn = uint32(decoder.ReadUint32())
12716 _bsnvportl2gre.RateLimit = uint32(decoder.ReadUint32())
12717 _bsnvportl2gre.IfName = string(bytes.Trim(decoder.Read(16), "\x00"))
12718 return _bsnvportl2gre, nil
12719}
12720
12721func NewBsnVportL2Gre() *BsnVportL2Gre {
12722 obj := &BsnVportL2Gre{
12723 BsnVport: NewBsnVport(1),
12724 }
12725 return obj
12726}
12727
12728type BsnVportQInQ struct {
12729 *BsnVport
12730 PortNo uint32
12731 IngressTpid uint16
12732 IngressVlanId uint16
12733 EgressTpid uint16
12734 EgressVlanId uint16
12735 IfName string
12736}
12737
12738type IBsnVportQInQ interface {
12739 IBsnVport
12740 GetPortNo() uint32
12741 GetIngressTpid() uint16
12742 GetIngressVlanId() uint16
12743 GetEgressTpid() uint16
12744 GetEgressVlanId() uint16
12745 GetIfName() string
12746}
12747
12748func (self *BsnVportQInQ) GetPortNo() uint32 {
12749 return self.PortNo
12750}
12751
12752func (self *BsnVportQInQ) SetPortNo(v uint32) {
12753 self.PortNo = v
12754}
12755
12756func (self *BsnVportQInQ) GetIngressTpid() uint16 {
12757 return self.IngressTpid
12758}
12759
12760func (self *BsnVportQInQ) SetIngressTpid(v uint16) {
12761 self.IngressTpid = v
12762}
12763
12764func (self *BsnVportQInQ) GetIngressVlanId() uint16 {
12765 return self.IngressVlanId
12766}
12767
12768func (self *BsnVportQInQ) SetIngressVlanId(v uint16) {
12769 self.IngressVlanId = v
12770}
12771
12772func (self *BsnVportQInQ) GetEgressTpid() uint16 {
12773 return self.EgressTpid
12774}
12775
12776func (self *BsnVportQInQ) SetEgressTpid(v uint16) {
12777 self.EgressTpid = v
12778}
12779
12780func (self *BsnVportQInQ) GetEgressVlanId() uint16 {
12781 return self.EgressVlanId
12782}
12783
12784func (self *BsnVportQInQ) SetEgressVlanId(v uint16) {
12785 self.EgressVlanId = v
12786}
12787
12788func (self *BsnVportQInQ) GetIfName() string {
12789 return self.IfName
12790}
12791
12792func (self *BsnVportQInQ) SetIfName(v string) {
12793 self.IfName = v
12794}
12795
12796func (self *BsnVportQInQ) Serialize(encoder *goloxi.Encoder) error {
12797 startIndex := len(encoder.Bytes())
12798 if err := self.BsnVport.Serialize(encoder); err != nil {
12799 return err
12800 }
12801
12802 encoder.PutUint32(uint32(self.PortNo))
12803 encoder.PutUint16(uint16(self.IngressTpid))
12804 encoder.PutUint16(uint16(self.IngressVlanId))
12805 encoder.PutUint16(uint16(self.EgressTpid))
12806 encoder.PutUint16(uint16(self.EgressVlanId))
12807 encoder.Write([]byte(self.IfName))
12808 length := len(encoder.Bytes()) - startIndex
12809
12810 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
12811
12812 return nil
12813}
12814
12815func DecodeBsnVportQInQ(parent *BsnVport, decoder *goloxi.Decoder) (*BsnVportQInQ, error) {
12816 _bsnvportqinq := &BsnVportQInQ{BsnVport: parent}
12817 if decoder.Length() < 28 {
12818 return nil, fmt.Errorf("BsnVportQInQ packet too short: %d < 28", decoder.Length())
12819 }
12820 _bsnvportqinq.PortNo = uint32(decoder.ReadUint32())
12821 _bsnvportqinq.IngressTpid = uint16(decoder.ReadUint16())
12822 _bsnvportqinq.IngressVlanId = uint16(decoder.ReadUint16())
12823 _bsnvportqinq.EgressTpid = uint16(decoder.ReadUint16())
12824 _bsnvportqinq.EgressVlanId = uint16(decoder.ReadUint16())
12825 _bsnvportqinq.IfName = string(bytes.Trim(decoder.Read(16), "\x00"))
12826 return _bsnvportqinq, nil
12827}
12828
12829func NewBsnVportQInQ() *BsnVportQInQ {
12830 obj := &BsnVportQInQ{
12831 BsnVport: NewBsnVport(0),
12832 }
12833 return obj
12834}
12835
12836type BsnVrfCounterStatsEntry struct {
12837 Length uint16
12838 Vrf uint32
12839 Values []*Uint64
12840}
12841
12842type IBsnVrfCounterStatsEntry interface {
12843 goloxi.Serializable
12844 GetLength() uint16
12845 GetVrf() uint32
12846 GetValues() []*Uint64
12847}
12848
12849func (self *BsnVrfCounterStatsEntry) GetLength() uint16 {
12850 return self.Length
12851}
12852
12853func (self *BsnVrfCounterStatsEntry) SetLength(v uint16) {
12854 self.Length = v
12855}
12856
12857func (self *BsnVrfCounterStatsEntry) GetVrf() uint32 {
12858 return self.Vrf
12859}
12860
12861func (self *BsnVrfCounterStatsEntry) SetVrf(v uint32) {
12862 self.Vrf = v
12863}
12864
12865func (self *BsnVrfCounterStatsEntry) GetValues() []*Uint64 {
12866 return self.Values
12867}
12868
12869func (self *BsnVrfCounterStatsEntry) SetValues(v []*Uint64) {
12870 self.Values = v
12871}
12872
12873func (self *BsnVrfCounterStatsEntry) Serialize(encoder *goloxi.Encoder) error {
12874 startIndex := len(encoder.Bytes())
12875
12876 encoder.PutUint16(uint16(self.Length))
12877 encoder.Write(bytes.Repeat([]byte{0}, 2))
12878 encoder.PutUint32(uint32(self.Vrf))
12879 for _, obj := range self.Values {
12880 if err := obj.Serialize(encoder); err != nil {
12881 return err
12882 }
12883 }
12884 length := len(encoder.Bytes()) - startIndex
12885
12886 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
12887
12888 return nil
12889}
12890
12891func DecodeBsnVrfCounterStatsEntry(decoder *goloxi.Decoder) (*BsnVrfCounterStatsEntry, error) {
12892 _bsnvrfcounterstatsentry := &BsnVrfCounterStatsEntry{}
12893 if decoder.Length() < 8 {
12894 return nil, fmt.Errorf("BsnVrfCounterStatsEntry packet too short: %d < 8", decoder.Length())
12895 }
12896 _bsnvrfcounterstatsentry.Length = uint16(decoder.ReadUint16())
12897 oldDecoder := decoder
12898 defer func() { decoder = oldDecoder }()
12899 decoder = decoder.SliceDecoder(int(_bsnvrfcounterstatsentry.Length), 2+0)
12900 decoder.Skip(2)
12901 _bsnvrfcounterstatsentry.Vrf = uint32(decoder.ReadUint32())
12902
12903 for decoder.Length() >= 8 {
12904 item, err := DecodeUint64(decoder)
12905 if err != nil {
12906 return nil, err
12907 }
12908 if item != nil {
12909 _bsnvrfcounterstatsentry.Values = append(_bsnvrfcounterstatsentry.Values, item)
12910 }
12911 }
12912 return _bsnvrfcounterstatsentry, nil
12913}
12914
12915func NewBsnVrfCounterStatsEntry() *BsnVrfCounterStatsEntry {
12916 obj := &BsnVrfCounterStatsEntry{}
12917 return obj
12918}
12919
12920type Bucket struct {
12921 Len uint16
12922 Weight uint16
12923 WatchPort Port
12924 WatchGroup uint32
12925 Actions []goloxi.IAction
12926}
12927
12928type IBucket interface {
12929 goloxi.Serializable
12930 GetLen() uint16
12931 GetWeight() uint16
12932 GetWatchPort() Port
12933 GetWatchGroup() uint32
12934 GetActions() []goloxi.IAction
12935}
12936
12937func (self *Bucket) GetLen() uint16 {
12938 return self.Len
12939}
12940
12941func (self *Bucket) SetLen(v uint16) {
12942 self.Len = v
12943}
12944
12945func (self *Bucket) GetWeight() uint16 {
12946 return self.Weight
12947}
12948
12949func (self *Bucket) SetWeight(v uint16) {
12950 self.Weight = v
12951}
12952
12953func (self *Bucket) GetWatchPort() Port {
12954 return self.WatchPort
12955}
12956
12957func (self *Bucket) SetWatchPort(v Port) {
12958 self.WatchPort = v
12959}
12960
12961func (self *Bucket) GetWatchGroup() uint32 {
12962 return self.WatchGroup
12963}
12964
12965func (self *Bucket) SetWatchGroup(v uint32) {
12966 self.WatchGroup = v
12967}
12968
12969func (self *Bucket) GetActions() []goloxi.IAction {
12970 return self.Actions
12971}
12972
12973func (self *Bucket) SetActions(v []goloxi.IAction) {
12974 self.Actions = v
12975}
12976
12977func (self *Bucket) Serialize(encoder *goloxi.Encoder) error {
12978 startIndex := len(encoder.Bytes())
12979
12980 encoder.PutUint16(uint16(self.Len))
12981 encoder.PutUint16(uint16(self.Weight))
12982 self.WatchPort.Serialize(encoder)
12983 encoder.PutUint32(uint32(self.WatchGroup))
12984 encoder.Write(bytes.Repeat([]byte{0}, 4))
12985 for _, obj := range self.Actions {
12986 if err := obj.Serialize(encoder); err != nil {
12987 return err
12988 }
12989 }
12990 length := len(encoder.Bytes()) - startIndex
12991
12992 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
12993
12994 return nil
12995}
12996
12997func DecodeBucket(decoder *goloxi.Decoder) (*Bucket, error) {
12998 _bucket := &Bucket{}
12999 if decoder.Length() < 16 {
13000 return nil, fmt.Errorf("Bucket packet too short: %d < 16", decoder.Length())
13001 }
13002 _bucket.Len = uint16(decoder.ReadUint16())
13003 oldDecoder := decoder
13004 defer func() { decoder = oldDecoder }()
13005 decoder = decoder.SliceDecoder(int(_bucket.Len), 2+0)
13006 _bucket.Weight = uint16(decoder.ReadUint16())
13007 _bucket.WatchPort.Decode(decoder)
13008 _bucket.WatchGroup = uint32(decoder.ReadUint32())
13009 decoder.Skip(4)
13010
13011 for decoder.Length() >= 8 {
13012 item, err := DecodeAction(decoder)
13013 if err != nil {
13014 return nil, err
13015 }
13016 if item != nil {
13017 _bucket.Actions = append(_bucket.Actions, item)
13018 }
13019 }
13020 return _bucket, nil
13021}
13022
13023func NewBucket() *Bucket {
13024 obj := &Bucket{}
13025 return obj
13026}
13027
13028type BucketCounter struct {
13029 PacketCount uint64
13030 ByteCount uint64
13031}
13032
13033type IBucketCounter interface {
13034 goloxi.Serializable
13035 GetPacketCount() uint64
13036 GetByteCount() uint64
13037}
13038
13039func (self *BucketCounter) GetPacketCount() uint64 {
13040 return self.PacketCount
13041}
13042
13043func (self *BucketCounter) SetPacketCount(v uint64) {
13044 self.PacketCount = v
13045}
13046
13047func (self *BucketCounter) GetByteCount() uint64 {
13048 return self.ByteCount
13049}
13050
13051func (self *BucketCounter) SetByteCount(v uint64) {
13052 self.ByteCount = v
13053}
13054
13055func (self *BucketCounter) Serialize(encoder *goloxi.Encoder) error {
13056
13057 encoder.PutUint64(uint64(self.PacketCount))
13058 encoder.PutUint64(uint64(self.ByteCount))
13059
13060 return nil
13061}
13062
13063func DecodeBucketCounter(decoder *goloxi.Decoder) (*BucketCounter, error) {
13064 _bucketcounter := &BucketCounter{}
13065 if decoder.Length() < 16 {
13066 return nil, fmt.Errorf("BucketCounter packet too short: %d < 16", decoder.Length())
13067 }
13068 _bucketcounter.PacketCount = uint64(decoder.ReadUint64())
13069 _bucketcounter.ByteCount = uint64(decoder.ReadUint64())
13070 return _bucketcounter, nil
13071}
13072
13073func NewBucketCounter() *BucketCounter {
13074 obj := &BucketCounter{}
13075 return obj
13076}
13077
13078type BundleProp struct {
13079 Type uint16
13080 Length uint16
13081}
13082
13083type IBundleProp interface {
13084 goloxi.Serializable
13085 GetType() uint16
13086 GetLength() uint16
13087}
13088
13089func (self *BundleProp) GetType() uint16 {
13090 return self.Type
13091}
13092
13093func (self *BundleProp) SetType(v uint16) {
13094 self.Type = v
13095}
13096
13097func (self *BundleProp) GetLength() uint16 {
13098 return self.Length
13099}
13100
13101func (self *BundleProp) SetLength(v uint16) {
13102 self.Length = v
13103}
13104
13105func (self *BundleProp) Serialize(encoder *goloxi.Encoder) error {
13106
13107 encoder.PutUint16(uint16(self.Type))
13108 encoder.PutUint16(uint16(self.Length))
13109
13110 return nil
13111}
13112
13113func DecodeBundleProp(decoder *goloxi.Decoder) (IBundleProp, error) {
13114 _bundleprop := &BundleProp{}
13115 if decoder.Length() < 4 {
13116 return nil, fmt.Errorf("BundleProp packet too short: %d < 4", decoder.Length())
13117 }
13118 _bundleprop.Type = uint16(decoder.ReadUint16())
13119 _bundleprop.Length = uint16(decoder.ReadUint16())
13120 oldDecoder := decoder
13121 defer func() { decoder = oldDecoder }()
13122 decoder = decoder.SliceDecoder(int(_bundleprop.Length), 2+2)
13123
13124 switch _bundleprop.Type {
13125 case 65535:
13126 return DecodeBundlePropExperimenter(_bundleprop, decoder)
13127 default:
13128 return nil, fmt.Errorf("Invalid type '%d' for 'BundleProp'", _bundleprop.Type)
13129 }
13130}
13131
13132func NewBundleProp(_type uint16) *BundleProp {
13133 obj := &BundleProp{}
13134 obj.Type = _type
13135 return obj
13136}
13137
13138type BundlePropExperimenter struct {
13139 *BundleProp
13140 Experimenter uint32
13141 ExpType uint32
13142}
13143
13144type IBundlePropExperimenter interface {
13145 IBundleProp
13146 GetExperimenter() uint32
13147 GetExpType() uint32
13148}
13149
13150func (self *BundlePropExperimenter) GetExperimenter() uint32 {
13151 return self.Experimenter
13152}
13153
13154func (self *BundlePropExperimenter) SetExperimenter(v uint32) {
13155 self.Experimenter = v
13156}
13157
13158func (self *BundlePropExperimenter) GetExpType() uint32 {
13159 return self.ExpType
13160}
13161
13162func (self *BundlePropExperimenter) SetExpType(v uint32) {
13163 self.ExpType = v
13164}
13165
13166func (self *BundlePropExperimenter) Serialize(encoder *goloxi.Encoder) error {
13167 if err := self.BundleProp.Serialize(encoder); err != nil {
13168 return err
13169 }
13170
13171 encoder.PutUint32(uint32(self.Experimenter))
13172 encoder.PutUint32(uint32(self.ExpType))
13173
13174 return nil
13175}
13176
13177func DecodeBundlePropExperimenter(parent *BundleProp, decoder *goloxi.Decoder) (IBundlePropExperimenter, error) {
13178 _bundlepropexperimenter := &BundlePropExperimenter{BundleProp: parent}
13179 if decoder.Length() < 8 {
13180 return nil, fmt.Errorf("BundlePropExperimenter packet too short: %d < 8", decoder.Length())
13181 }
13182 _bundlepropexperimenter.Experimenter = uint32(decoder.ReadUint32())
13183 _bundlepropexperimenter.ExpType = uint32(decoder.ReadUint32())
13184 return _bundlepropexperimenter, nil
13185}
13186
13187func NewBundlePropExperimenter(_experimenter uint32) *BundlePropExperimenter {
13188 obj := &BundlePropExperimenter{
13189 BundleProp: NewBundleProp(65535),
13190 }
13191 obj.Experimenter = _experimenter
13192 return obj
13193}
13194
13195type EdPropHeader struct {
13196 PropClass uint16
13197}
13198
13199type IEdPropHeader interface {
13200 goloxi.Serializable
13201 GetPropClass() uint16
13202}
13203
13204func (self *EdPropHeader) GetPropClass() uint16 {
13205 return self.PropClass
13206}
13207
13208func (self *EdPropHeader) SetPropClass(v uint16) {
13209 self.PropClass = v
13210}
13211
13212func (self *EdPropHeader) Serialize(encoder *goloxi.Encoder) error {
13213
13214 encoder.PutUint16(uint16(self.PropClass))
13215
13216 return nil
13217}
13218
13219func DecodeEdPropHeader(decoder *goloxi.Decoder) (IEdPropHeader, error) {
13220 _edpropheader := &EdPropHeader{}
13221 if decoder.Length() < 2 {
13222 return nil, fmt.Errorf("EdPropHeader packet too short: %d < 2", decoder.Length())
13223 }
13224 _edpropheader.PropClass = uint16(decoder.ReadUint16())
13225
13226 switch _edpropheader.PropClass {
13227 case 4:
13228 return DecodeEdPropNsh(_edpropheader, decoder)
13229 default:
13230 return nil, fmt.Errorf("Invalid type '%d' for 'EdPropHeader'", _edpropheader.PropClass)
13231 }
13232}
13233
13234func NewEdPropHeader(_prop_class uint16) *EdPropHeader {
13235 obj := &EdPropHeader{}
13236 obj.PropClass = _prop_class
13237 return obj
13238}
13239
13240type EdPropNsh struct {
13241 *EdPropHeader
13242 Type uint8
13243 Len uint8
13244}
13245
13246type IEdPropNsh interface {
13247 IEdPropHeader
13248 GetType() uint8
13249 GetLen() uint8
13250}
13251
13252func (self *EdPropNsh) GetType() uint8 {
13253 return self.Type
13254}
13255
13256func (self *EdPropNsh) SetType(v uint8) {
13257 self.Type = v
13258}
13259
13260func (self *EdPropNsh) GetLen() uint8 {
13261 return self.Len
13262}
13263
13264func (self *EdPropNsh) SetLen(v uint8) {
13265 self.Len = v
13266}
13267
13268func (self *EdPropNsh) Serialize(encoder *goloxi.Encoder) error {
13269 if err := self.EdPropHeader.Serialize(encoder); err != nil {
13270 return err
13271 }
13272
13273 encoder.PutUint8(uint8(self.Type))
13274 encoder.PutUint8(uint8(self.Len))
13275
13276 return nil
13277}
13278
13279func DecodeEdPropNsh(parent *EdPropHeader, decoder *goloxi.Decoder) (IEdPropNsh, error) {
13280 _edpropnsh := &EdPropNsh{EdPropHeader: parent}
13281 if decoder.Length() < 2 {
13282 return nil, fmt.Errorf("EdPropNsh packet too short: %d < 2", decoder.Length())
13283 }
13284 defer decoder.SkipAlign()
13285
13286 _edpropnsh.Type = uint8(decoder.ReadByte())
13287 _edpropnsh.Len = uint8(decoder.ReadByte())
13288 oldDecoder := decoder
13289 defer func() { decoder = oldDecoder }()
13290 decoder = decoder.SliceDecoder(int(((_edpropnsh.Len)+7)/8*8), 1+3)
13291
13292 switch _edpropnsh.Type {
13293 case 1:
13294 return DecodeEdPropNshMdType(_edpropnsh, decoder)
13295 case 2:
13296 return DecodeEdPropNshTlv(_edpropnsh, decoder)
13297 default:
13298 return nil, fmt.Errorf("Invalid type '%d' for 'EdPropNsh'", _edpropnsh.Type)
13299 }
13300}
13301
13302func NewEdPropNsh(_type uint8) *EdPropNsh {
13303 obj := &EdPropNsh{
13304 EdPropHeader: NewEdPropHeader(4),
13305 }
13306 obj.Type = _type
13307 return obj
13308}
13309
13310type EdPropNshMdType struct {
13311 *EdPropNsh
13312 MdType uint8
13313}
13314
13315type IEdPropNshMdType interface {
13316 IEdPropNsh
13317 GetMdType() uint8
13318}
13319
13320func (self *EdPropNshMdType) GetMdType() uint8 {
13321 return self.MdType
13322}
13323
13324func (self *EdPropNshMdType) SetMdType(v uint8) {
13325 self.MdType = v
13326}
13327
13328func (self *EdPropNshMdType) Serialize(encoder *goloxi.Encoder) error {
13329 startIndex := len(encoder.Bytes())
13330 if err := self.EdPropNsh.Serialize(encoder); err != nil {
13331 return err
13332 }
13333
13334 encoder.PutUint8(uint8(self.MdType))
13335 encoder.Write(bytes.Repeat([]byte{0}, 3))
13336 length := len(encoder.Bytes()) - startIndex
13337
13338 encoder.Bytes()[startIndex+3] = uint8(length)
13339
13340 return nil
13341}
13342
13343func DecodeEdPropNshMdType(parent *EdPropNsh, decoder *goloxi.Decoder) (*EdPropNshMdType, error) {
13344 _edpropnshmdtype := &EdPropNshMdType{EdPropNsh: parent}
13345 if decoder.Length() < 4 {
13346 return nil, fmt.Errorf("EdPropNshMdType packet too short: %d < 4", decoder.Length())
13347 }
13348 _edpropnshmdtype.MdType = uint8(decoder.ReadByte())
13349 decoder.Skip(3)
13350 return _edpropnshmdtype, nil
13351}
13352
13353func NewEdPropNshMdType() *EdPropNshMdType {
13354 obj := &EdPropNshMdType{
13355 EdPropNsh: NewEdPropNsh(1),
13356 }
13357 return obj
13358}
13359
13360type EdPropNshTlv struct {
13361 *EdPropNsh
13362 TlvClass uint16
13363 TlvType uint8
13364 TlvLen uint8
13365 Value []byte
13366}
13367
13368type IEdPropNshTlv interface {
13369 IEdPropNsh
13370 GetTlvClass() uint16
13371 GetTlvType() uint8
13372 GetTlvLen() uint8
13373 GetValue() []byte
13374}
13375
13376func (self *EdPropNshTlv) GetTlvClass() uint16 {
13377 return self.TlvClass
13378}
13379
13380func (self *EdPropNshTlv) SetTlvClass(v uint16) {
13381 self.TlvClass = v
13382}
13383
13384func (self *EdPropNshTlv) GetTlvType() uint8 {
13385 return self.TlvType
13386}
13387
13388func (self *EdPropNshTlv) SetTlvType(v uint8) {
13389 self.TlvType = v
13390}
13391
13392func (self *EdPropNshTlv) GetTlvLen() uint8 {
13393 return self.TlvLen
13394}
13395
13396func (self *EdPropNshTlv) SetTlvLen(v uint8) {
13397 self.TlvLen = v
13398}
13399
13400func (self *EdPropNshTlv) GetValue() []byte {
13401 return self.Value
13402}
13403
13404func (self *EdPropNshTlv) SetValue(v []byte) {
13405 self.Value = v
13406}
13407
13408func (self *EdPropNshTlv) Serialize(encoder *goloxi.Encoder) error {
13409 startIndex := len(encoder.Bytes())
13410 if err := self.EdPropNsh.Serialize(encoder); err != nil {
13411 return err
13412 }
13413
13414 encoder.PutUint16(uint16(self.TlvClass))
13415 encoder.PutUint8(uint8(self.TlvType))
13416 encoder.PutUint8(uint8(self.TlvLen))
13417 encoder.Write(self.Value)
13418 length := len(encoder.Bytes()) - startIndex
13419
13420 encoder.Bytes()[startIndex+3] = uint8(length)
13421
13422 return nil
13423}
13424
13425func DecodeEdPropNshTlv(parent *EdPropNsh, decoder *goloxi.Decoder) (*EdPropNshTlv, error) {
13426 _edpropnshtlv := &EdPropNshTlv{EdPropNsh: parent}
13427 if decoder.Length() < 4 {
13428 return nil, fmt.Errorf("EdPropNshTlv packet too short: %d < 4", decoder.Length())
13429 }
13430 _edpropnshtlv.TlvClass = uint16(decoder.ReadUint16())
13431 _edpropnshtlv.TlvType = uint8(decoder.ReadByte())
13432 _edpropnshtlv.TlvLen = uint8(decoder.ReadByte())
13433 _edpropnshtlv.Value = decoder.SliceDecoder(int(_edpropnshtlv.TlvLen), 0).Read(int(_edpropnshtlv.TlvLen))
13434 return _edpropnshtlv, nil
13435}
13436
13437func NewEdPropNshTlv() *EdPropNshTlv {
13438 obj := &EdPropNshTlv{
13439 EdPropNsh: NewEdPropNsh(2),
13440 }
13441 return obj
13442}
13443
13444type FlowModSpec struct {
13445 SrcDst uint8
13446 NBits uint8
13447}
13448
13449type IFlowModSpec interface {
13450 goloxi.Serializable
13451 GetSrcDst() uint8
13452 GetNBits() uint8
13453}
13454
13455func (self *FlowModSpec) GetSrcDst() uint8 {
13456 return self.SrcDst
13457}
13458
13459func (self *FlowModSpec) SetSrcDst(v uint8) {
13460 self.SrcDst = v
13461}
13462
13463func (self *FlowModSpec) GetNBits() uint8 {
13464 return self.NBits
13465}
13466
13467func (self *FlowModSpec) SetNBits(v uint8) {
13468 self.NBits = v
13469}
13470
13471func (self *FlowModSpec) Serialize(encoder *goloxi.Encoder) error {
13472
13473 encoder.PutUint8(uint8(self.SrcDst))
13474 encoder.PutUint8(uint8(self.NBits))
13475
13476 return nil
13477}
13478
13479func DecodeFlowModSpec(decoder *goloxi.Decoder) (IFlowModSpec, error) {
13480 _flowmodspec := &FlowModSpec{}
13481 if decoder.Length() < 2 {
13482 return nil, fmt.Errorf("FlowModSpec packet too short: %d < 2", decoder.Length())
13483 }
13484 _flowmodspec.SrcDst = uint8(decoder.ReadByte())
13485 _flowmodspec.NBits = uint8(decoder.ReadByte())
13486 if _flowmodspec.SrcDst == 0 && _flowmodspec.NBits == 0 {
13487 return nil, nil
13488 }
13489
13490 switch _flowmodspec.SrcDst {
13491 case 0:
13492 return DecodeFlowModSpecSrc0Dst0(_flowmodspec, decoder)
13493 case 8:
13494 return DecodeFlowModSpecSrc0Dst1(_flowmodspec, decoder)
13495 case 40:
13496 return DecodeFlowModSpecSrc1Dst1(_flowmodspec, decoder)
13497 case 16:
13498 return DecodeFlowModSpecSrc0Dst2(_flowmodspec, decoder)
13499 case 32:
13500 return DecodeFlowModSpecSrc1Dst0(_flowmodspec, decoder)
13501 default:
13502 return nil, fmt.Errorf("Invalid type '%d' for 'FlowModSpec'", _flowmodspec.SrcDst)
13503 }
13504}
13505
13506func NewFlowModSpec(_src_dst uint8) *FlowModSpec {
13507 obj := &FlowModSpec{}
13508 obj.SrcDst = _src_dst
13509 return obj
13510}
13511
13512type FlowModSpecSrc0Dst0 struct {
13513 *FlowModSpec
13514 Src goloxi.IOxmId
13515 SrcOfs uint16
13516 Dst goloxi.IOxmId
13517 DstOfs uint16
13518}
13519
13520type IFlowModSpecSrc0Dst0 interface {
13521 IFlowModSpec
13522 GetSrc() goloxi.IOxmId
13523 GetSrcOfs() uint16
13524 GetDst() goloxi.IOxmId
13525 GetDstOfs() uint16
13526}
13527
13528func (self *FlowModSpecSrc0Dst0) GetSrc() goloxi.IOxmId {
13529 return self.Src
13530}
13531
13532func (self *FlowModSpecSrc0Dst0) SetSrc(v goloxi.IOxmId) {
13533 self.Src = v
13534}
13535
13536func (self *FlowModSpecSrc0Dst0) GetSrcOfs() uint16 {
13537 return self.SrcOfs
13538}
13539
13540func (self *FlowModSpecSrc0Dst0) SetSrcOfs(v uint16) {
13541 self.SrcOfs = v
13542}
13543
13544func (self *FlowModSpecSrc0Dst0) GetDst() goloxi.IOxmId {
13545 return self.Dst
13546}
13547
13548func (self *FlowModSpecSrc0Dst0) SetDst(v goloxi.IOxmId) {
13549 self.Dst = v
13550}
13551
13552func (self *FlowModSpecSrc0Dst0) GetDstOfs() uint16 {
13553 return self.DstOfs
13554}
13555
13556func (self *FlowModSpecSrc0Dst0) SetDstOfs(v uint16) {
13557 self.DstOfs = v
13558}
13559
13560func (self *FlowModSpecSrc0Dst0) Serialize(encoder *goloxi.Encoder) error {
13561 if err := self.FlowModSpec.Serialize(encoder); err != nil {
13562 return err
13563 }
13564
13565 self.Src.Serialize(encoder)
13566 encoder.PutUint16(uint16(self.SrcOfs))
13567 self.Dst.Serialize(encoder)
13568 encoder.PutUint16(uint16(self.DstOfs))
13569
13570 return nil
13571}
13572
13573func DecodeFlowModSpecSrc0Dst0(parent *FlowModSpec, decoder *goloxi.Decoder) (IFlowModSpecSrc0Dst0, error) {
13574 _flowmodspecsrc0dst0 := &FlowModSpecSrc0Dst0{FlowModSpec: parent}
13575 if decoder.Length() < 12 {
13576 return nil, fmt.Errorf("FlowModSpecSrc0Dst0 packet too short: %d < 12", decoder.Length())
13577 }
13578 if obj, err := DecodeOxmId(decoder); err != nil {
13579 return nil, err
13580 } else {
13581 _flowmodspecsrc0dst0.Src = obj
13582 }
13583
13584 _flowmodspecsrc0dst0.SrcOfs = uint16(decoder.ReadUint16())
13585 if obj, err := DecodeOxmId(decoder); err != nil {
13586 return nil, err
13587 } else {
13588 _flowmodspecsrc0dst0.Dst = obj
13589 }
13590
13591 _flowmodspecsrc0dst0.DstOfs = uint16(decoder.ReadUint16())
13592 return _flowmodspecsrc0dst0, nil
13593}
13594
13595func NewFlowModSpecSrc0Dst0(_n_bits uint8) *FlowModSpecSrc0Dst0 {
13596 obj := &FlowModSpecSrc0Dst0{
13597 FlowModSpec: NewFlowModSpec(0),
13598 }
13599 obj.NBits = _n_bits
13600 return obj
13601}
13602
13603type FlowModSpecSrc0Dst1 struct {
13604 *FlowModSpec
13605 Src goloxi.IOxmId
13606 SrcOfs uint16
13607 Dst goloxi.IOxmId
13608 DstOfs uint16
13609}
13610
13611type IFlowModSpecSrc0Dst1 interface {
13612 IFlowModSpec
13613 GetSrc() goloxi.IOxmId
13614 GetSrcOfs() uint16
13615 GetDst() goloxi.IOxmId
13616 GetDstOfs() uint16
13617}
13618
13619func (self *FlowModSpecSrc0Dst1) GetSrc() goloxi.IOxmId {
13620 return self.Src
13621}
13622
13623func (self *FlowModSpecSrc0Dst1) SetSrc(v goloxi.IOxmId) {
13624 self.Src = v
13625}
13626
13627func (self *FlowModSpecSrc0Dst1) GetSrcOfs() uint16 {
13628 return self.SrcOfs
13629}
13630
13631func (self *FlowModSpecSrc0Dst1) SetSrcOfs(v uint16) {
13632 self.SrcOfs = v
13633}
13634
13635func (self *FlowModSpecSrc0Dst1) GetDst() goloxi.IOxmId {
13636 return self.Dst
13637}
13638
13639func (self *FlowModSpecSrc0Dst1) SetDst(v goloxi.IOxmId) {
13640 self.Dst = v
13641}
13642
13643func (self *FlowModSpecSrc0Dst1) GetDstOfs() uint16 {
13644 return self.DstOfs
13645}
13646
13647func (self *FlowModSpecSrc0Dst1) SetDstOfs(v uint16) {
13648 self.DstOfs = v
13649}
13650
13651func (self *FlowModSpecSrc0Dst1) Serialize(encoder *goloxi.Encoder) error {
13652 if err := self.FlowModSpec.Serialize(encoder); err != nil {
13653 return err
13654 }
13655
13656 self.Src.Serialize(encoder)
13657 encoder.PutUint16(uint16(self.SrcOfs))
13658 self.Dst.Serialize(encoder)
13659 encoder.PutUint16(uint16(self.DstOfs))
13660
13661 return nil
13662}
13663
13664func DecodeFlowModSpecSrc0Dst1(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc0Dst1, error) {
13665 _flowmodspecsrc0dst1 := &FlowModSpecSrc0Dst1{FlowModSpec: parent}
13666 if decoder.Length() < 12 {
13667 return nil, fmt.Errorf("FlowModSpecSrc0Dst1 packet too short: %d < 12", decoder.Length())
13668 }
13669 if obj, err := DecodeOxmId(decoder); err != nil {
13670 return nil, err
13671 } else {
13672 _flowmodspecsrc0dst1.Src = obj
13673 }
13674
13675 _flowmodspecsrc0dst1.SrcOfs = uint16(decoder.ReadUint16())
13676 if obj, err := DecodeOxmId(decoder); err != nil {
13677 return nil, err
13678 } else {
13679 _flowmodspecsrc0dst1.Dst = obj
13680 }
13681
13682 _flowmodspecsrc0dst1.DstOfs = uint16(decoder.ReadUint16())
13683 return _flowmodspecsrc0dst1, nil
13684}
13685
13686func NewFlowModSpecSrc0Dst1() *FlowModSpecSrc0Dst1 {
13687 obj := &FlowModSpecSrc0Dst1{
13688 FlowModSpec: NewFlowModSpec(8),
13689 }
13690 return obj
13691}
13692
13693type FlowModSpecSrc0Dst2 struct {
13694 *FlowModSpec
13695 Src goloxi.IOxmId
13696 SrcOfs uint16
13697}
13698
13699type IFlowModSpecSrc0Dst2 interface {
13700 IFlowModSpec
13701 GetSrc() goloxi.IOxmId
13702 GetSrcOfs() uint16
13703}
13704
13705func (self *FlowModSpecSrc0Dst2) GetSrc() goloxi.IOxmId {
13706 return self.Src
13707}
13708
13709func (self *FlowModSpecSrc0Dst2) SetSrc(v goloxi.IOxmId) {
13710 self.Src = v
13711}
13712
13713func (self *FlowModSpecSrc0Dst2) GetSrcOfs() uint16 {
13714 return self.SrcOfs
13715}
13716
13717func (self *FlowModSpecSrc0Dst2) SetSrcOfs(v uint16) {
13718 self.SrcOfs = v
13719}
13720
13721func (self *FlowModSpecSrc0Dst2) Serialize(encoder *goloxi.Encoder) error {
13722 if err := self.FlowModSpec.Serialize(encoder); err != nil {
13723 return err
13724 }
13725
13726 self.Src.Serialize(encoder)
13727 encoder.PutUint16(uint16(self.SrcOfs))
13728
13729 return nil
13730}
13731
13732func DecodeFlowModSpecSrc0Dst2(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc0Dst2, error) {
13733 _flowmodspecsrc0dst2 := &FlowModSpecSrc0Dst2{FlowModSpec: parent}
13734 if decoder.Length() < 6 {
13735 return nil, fmt.Errorf("FlowModSpecSrc0Dst2 packet too short: %d < 6", decoder.Length())
13736 }
13737 if obj, err := DecodeOxmId(decoder); err != nil {
13738 return nil, err
13739 } else {
13740 _flowmodspecsrc0dst2.Src = obj
13741 }
13742
13743 _flowmodspecsrc0dst2.SrcOfs = uint16(decoder.ReadUint16())
13744 return _flowmodspecsrc0dst2, nil
13745}
13746
13747func NewFlowModSpecSrc0Dst2() *FlowModSpecSrc0Dst2 {
13748 obj := &FlowModSpecSrc0Dst2{
13749 FlowModSpec: NewFlowModSpec(16),
13750 }
13751 return obj
13752}
13753
13754type FlowModSpecSrc1Dst0 struct {
13755 *FlowModSpec
13756 Src []byte
13757 Dst goloxi.IOxmId
13758 DstOfs uint16
13759}
13760
13761type IFlowModSpecSrc1Dst0 interface {
13762 IFlowModSpec
13763 GetSrc() []byte
13764 GetDst() goloxi.IOxmId
13765 GetDstOfs() uint16
13766}
13767
13768func (self *FlowModSpecSrc1Dst0) GetSrc() []byte {
13769 return self.Src
13770}
13771
13772func (self *FlowModSpecSrc1Dst0) SetSrc(v []byte) {
13773 self.Src = v
13774}
13775
13776func (self *FlowModSpecSrc1Dst0) GetDst() goloxi.IOxmId {
13777 return self.Dst
13778}
13779
13780func (self *FlowModSpecSrc1Dst0) SetDst(v goloxi.IOxmId) {
13781 self.Dst = v
13782}
13783
13784func (self *FlowModSpecSrc1Dst0) GetDstOfs() uint16 {
13785 return self.DstOfs
13786}
13787
13788func (self *FlowModSpecSrc1Dst0) SetDstOfs(v uint16) {
13789 self.DstOfs = v
13790}
13791
13792func (self *FlowModSpecSrc1Dst0) Serialize(encoder *goloxi.Encoder) error {
13793 if err := self.FlowModSpec.Serialize(encoder); err != nil {
13794 return err
13795 }
13796
13797 encoder.Write(self.Src)
13798 self.Dst.Serialize(encoder)
13799 encoder.PutUint16(uint16(self.DstOfs))
13800
13801 return nil
13802}
13803
13804func DecodeFlowModSpecSrc1Dst0(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc1Dst0, error) {
13805 _flowmodspecsrc1dst0 := &FlowModSpecSrc1Dst0{FlowModSpec: parent}
13806 if decoder.Length() < 6 {
13807 return nil, fmt.Errorf("FlowModSpecSrc1Dst0 packet too short: %d < 6", decoder.Length())
13808 }
13809 _flowmodspecsrc1dst0.Src = decoder.SliceDecoder(int((_flowmodspecsrc1dst0.NBits+15)/16*2), 0).Read(int(_flowmodspecsrc1dst0.NBits))
13810 if obj, err := DecodeOxmId(decoder); err != nil {
13811 return nil, err
13812 } else {
13813 _flowmodspecsrc1dst0.Dst = obj
13814 }
13815
13816 _flowmodspecsrc1dst0.DstOfs = uint16(decoder.ReadUint16())
13817 return _flowmodspecsrc1dst0, nil
13818}
13819
13820func NewFlowModSpecSrc1Dst0() *FlowModSpecSrc1Dst0 {
13821 obj := &FlowModSpecSrc1Dst0{
13822 FlowModSpec: NewFlowModSpec(32),
13823 }
13824 return obj
13825}
13826
13827type FlowModSpecSrc1Dst1 struct {
13828 *FlowModSpec
13829 Src []byte
13830 Dst goloxi.IOxmId
13831 DstOfs uint16
13832}
13833
13834type IFlowModSpecSrc1Dst1 interface {
13835 IFlowModSpec
13836 GetSrc() []byte
13837 GetDst() goloxi.IOxmId
13838 GetDstOfs() uint16
13839}
13840
13841func (self *FlowModSpecSrc1Dst1) GetSrc() []byte {
13842 return self.Src
13843}
13844
13845func (self *FlowModSpecSrc1Dst1) SetSrc(v []byte) {
13846 self.Src = v
13847}
13848
13849func (self *FlowModSpecSrc1Dst1) GetDst() goloxi.IOxmId {
13850 return self.Dst
13851}
13852
13853func (self *FlowModSpecSrc1Dst1) SetDst(v goloxi.IOxmId) {
13854 self.Dst = v
13855}
13856
13857func (self *FlowModSpecSrc1Dst1) GetDstOfs() uint16 {
13858 return self.DstOfs
13859}
13860
13861func (self *FlowModSpecSrc1Dst1) SetDstOfs(v uint16) {
13862 self.DstOfs = v
13863}
13864
13865func (self *FlowModSpecSrc1Dst1) Serialize(encoder *goloxi.Encoder) error {
13866 if err := self.FlowModSpec.Serialize(encoder); err != nil {
13867 return err
13868 }
13869
13870 encoder.Write(self.Src)
13871 self.Dst.Serialize(encoder)
13872 encoder.PutUint16(uint16(self.DstOfs))
13873
13874 return nil
13875}
13876
13877func DecodeFlowModSpecSrc1Dst1(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc1Dst1, error) {
13878 _flowmodspecsrc1dst1 := &FlowModSpecSrc1Dst1{FlowModSpec: parent}
13879 if decoder.Length() < 6 {
13880 return nil, fmt.Errorf("FlowModSpecSrc1Dst1 packet too short: %d < 6", decoder.Length())
13881 }
13882 _flowmodspecsrc1dst1.Src = decoder.SliceDecoder(int((_flowmodspecsrc1dst1.NBits+15)/16*2), 0).Read(int(_flowmodspecsrc1dst1.NBits))
13883 if obj, err := DecodeOxmId(decoder); err != nil {
13884 return nil, err
13885 } else {
13886 _flowmodspecsrc1dst1.Dst = obj
13887 }
13888
13889 _flowmodspecsrc1dst1.DstOfs = uint16(decoder.ReadUint16())
13890 return _flowmodspecsrc1dst1, nil
13891}
13892
13893func NewFlowModSpecSrc1Dst1() *FlowModSpecSrc1Dst1 {
13894 obj := &FlowModSpecSrc1Dst1{
13895 FlowModSpec: NewFlowModSpec(40),
13896 }
13897 return obj
13898}
13899
13900type FlowMonitorEntry struct {
13901 MonitorId uint32
13902 OutPort uint32
13903 OutGroup uint32
13904 Flags FlowMonitorFlags
13905 TableId uint8
13906 Command FlowMonitorCommand
13907 Match Match
13908}
13909
13910type IFlowMonitorEntry interface {
13911 goloxi.Serializable
13912 GetMonitorId() uint32
13913 GetOutPort() uint32
13914 GetOutGroup() uint32
13915 GetFlags() FlowMonitorFlags
13916 GetTableId() uint8
13917 GetCommand() FlowMonitorCommand
13918 GetMatch() Match
13919}
13920
13921func (self *FlowMonitorEntry) GetMonitorId() uint32 {
13922 return self.MonitorId
13923}
13924
13925func (self *FlowMonitorEntry) SetMonitorId(v uint32) {
13926 self.MonitorId = v
13927}
13928
13929func (self *FlowMonitorEntry) GetOutPort() uint32 {
13930 return self.OutPort
13931}
13932
13933func (self *FlowMonitorEntry) SetOutPort(v uint32) {
13934 self.OutPort = v
13935}
13936
13937func (self *FlowMonitorEntry) GetOutGroup() uint32 {
13938 return self.OutGroup
13939}
13940
13941func (self *FlowMonitorEntry) SetOutGroup(v uint32) {
13942 self.OutGroup = v
13943}
13944
13945func (self *FlowMonitorEntry) GetFlags() FlowMonitorFlags {
13946 return self.Flags
13947}
13948
13949func (self *FlowMonitorEntry) SetFlags(v FlowMonitorFlags) {
13950 self.Flags = v
13951}
13952
13953func (self *FlowMonitorEntry) GetTableId() uint8 {
13954 return self.TableId
13955}
13956
13957func (self *FlowMonitorEntry) SetTableId(v uint8) {
13958 self.TableId = v
13959}
13960
13961func (self *FlowMonitorEntry) GetCommand() FlowMonitorCommand {
13962 return self.Command
13963}
13964
13965func (self *FlowMonitorEntry) SetCommand(v FlowMonitorCommand) {
13966 self.Command = v
13967}
13968
13969func (self *FlowMonitorEntry) GetMatch() Match {
13970 return self.Match
13971}
13972
13973func (self *FlowMonitorEntry) SetMatch(v Match) {
13974 self.Match = v
13975}
13976
13977func (self *FlowMonitorEntry) Serialize(encoder *goloxi.Encoder) error {
13978
13979 encoder.PutUint32(uint32(self.MonitorId))
13980 encoder.PutUint32(uint32(self.OutPort))
13981 encoder.PutUint32(uint32(self.OutGroup))
13982 encoder.PutUint16(uint16(self.Flags))
13983 encoder.PutUint8(uint8(self.TableId))
13984 encoder.PutUint8(uint8(self.Command))
13985 if err := self.Match.Serialize(encoder); err != nil {
13986 return err
13987 }
13988
13989 return nil
13990}
13991
13992func DecodeFlowMonitorEntry(decoder *goloxi.Decoder) (*FlowMonitorEntry, error) {
13993 _flowmonitorentry := &FlowMonitorEntry{}
13994 if decoder.Length() < 24 {
13995 return nil, fmt.Errorf("FlowMonitorEntry packet too short: %d < 24", decoder.Length())
13996 }
13997 _flowmonitorentry.MonitorId = uint32(decoder.ReadUint32())
13998 _flowmonitorentry.OutPort = uint32(decoder.ReadUint32())
13999 _flowmonitorentry.OutGroup = uint32(decoder.ReadUint32())
14000 _flowmonitorentry.Flags = FlowMonitorFlags(decoder.ReadUint16())
14001 _flowmonitorentry.TableId = uint8(decoder.ReadByte())
14002 _flowmonitorentry.Command = FlowMonitorCommand(decoder.ReadByte())
14003 if err := _flowmonitorentry.Match.Decode(decoder); err != nil {
14004 return nil, err
14005 }
14006
14007 decoder.SkipAlign()
14008 return _flowmonitorentry, nil
14009}
14010
14011func NewFlowMonitorEntry() *FlowMonitorEntry {
14012 obj := &FlowMonitorEntry{}
14013 return obj
14014}
14015
14016type FlowMonitorReplyEntry struct {
14017 Length uint16
14018 Event FlowUpdateEvent
14019}
14020
14021type IFlowMonitorReplyEntry interface {
14022 goloxi.Serializable
14023 GetLength() uint16
14024 GetEvent() FlowUpdateEvent
14025}
14026
14027func (self *FlowMonitorReplyEntry) GetLength() uint16 {
14028 return self.Length
14029}
14030
14031func (self *FlowMonitorReplyEntry) SetLength(v uint16) {
14032 self.Length = v
14033}
14034
14035func (self *FlowMonitorReplyEntry) GetEvent() FlowUpdateEvent {
14036 return self.Event
14037}
14038
14039func (self *FlowMonitorReplyEntry) SetEvent(v FlowUpdateEvent) {
14040 self.Event = v
14041}
14042
14043func (self *FlowMonitorReplyEntry) Serialize(encoder *goloxi.Encoder) error {
14044
14045 encoder.PutUint16(uint16(self.Length))
14046 encoder.PutUint16(uint16(self.Event))
14047
14048 return nil
14049}
14050
14051func DecodeFlowMonitorReplyEntry(decoder *goloxi.Decoder) (IFlowMonitorReplyEntry, error) {
14052 _flowmonitorreplyentry := &FlowMonitorReplyEntry{}
14053 if decoder.Length() < 4 {
14054 return nil, fmt.Errorf("FlowMonitorReplyEntry packet too short: %d < 4", decoder.Length())
14055 }
14056 _flowmonitorreplyentry.Length = uint16(decoder.ReadUint16())
14057 oldDecoder := decoder
14058 defer func() { decoder = oldDecoder }()
14059 decoder = decoder.SliceDecoder(int(_flowmonitorreplyentry.Length), 2+0)
14060 _flowmonitorreplyentry.Event = FlowUpdateEvent(decoder.ReadUint16())
14061
14062 switch _flowmonitorreplyentry.Event {
14063 case 0:
14064 return DecodeFlowUpdateFullInitial(_flowmonitorreplyentry, decoder)
14065 case 1:
14066 return DecodeFlowUpdateFullAdded(_flowmonitorreplyentry, decoder)
14067 case 2:
14068 return DecodeFlowUpdateFullRemoved(_flowmonitorreplyentry, decoder)
14069 case 3:
14070 return DecodeFlowUpdateFullModified(_flowmonitorreplyentry, decoder)
14071 default:
14072 return nil, fmt.Errorf("Invalid type '%d' for 'FlowMonitorReplyEntry'", _flowmonitorreplyentry.Event)
14073 }
14074}
14075
14076func NewFlowMonitorReplyEntry(_event FlowUpdateEvent) *FlowMonitorReplyEntry {
14077 obj := &FlowMonitorReplyEntry{}
14078 obj.Event = _event
14079 return obj
14080}
14081
14082type FlowStatsEntry struct {
14083 Length uint16
14084 TableId uint8
14085 DurationSec uint32
14086 DurationNsec uint32
14087 Priority uint16
14088 IdleTimeout uint16
14089 HardTimeout uint16
14090 Flags FlowModFlags
14091 Importance uint16
14092 Cookie uint64
14093 PacketCount uint64
14094 ByteCount uint64
14095 Match Match
14096 Instructions []IInstruction
14097}
14098
14099type IFlowStatsEntry interface {
14100 goloxi.Serializable
14101 GetLength() uint16
14102 GetTableId() uint8
14103 GetDurationSec() uint32
14104 GetDurationNsec() uint32
14105 GetPriority() uint16
14106 GetIdleTimeout() uint16
14107 GetHardTimeout() uint16
14108 GetFlags() FlowModFlags
14109 GetImportance() uint16
14110 GetCookie() uint64
14111 GetPacketCount() uint64
14112 GetByteCount() uint64
14113 GetMatch() Match
14114 GetInstructions() []IInstruction
14115}
14116
14117func (self *FlowStatsEntry) GetLength() uint16 {
14118 return self.Length
14119}
14120
14121func (self *FlowStatsEntry) SetLength(v uint16) {
14122 self.Length = v
14123}
14124
14125func (self *FlowStatsEntry) GetTableId() uint8 {
14126 return self.TableId
14127}
14128
14129func (self *FlowStatsEntry) SetTableId(v uint8) {
14130 self.TableId = v
14131}
14132
14133func (self *FlowStatsEntry) GetDurationSec() uint32 {
14134 return self.DurationSec
14135}
14136
14137func (self *FlowStatsEntry) SetDurationSec(v uint32) {
14138 self.DurationSec = v
14139}
14140
14141func (self *FlowStatsEntry) GetDurationNsec() uint32 {
14142 return self.DurationNsec
14143}
14144
14145func (self *FlowStatsEntry) SetDurationNsec(v uint32) {
14146 self.DurationNsec = v
14147}
14148
14149func (self *FlowStatsEntry) GetPriority() uint16 {
14150 return self.Priority
14151}
14152
14153func (self *FlowStatsEntry) SetPriority(v uint16) {
14154 self.Priority = v
14155}
14156
14157func (self *FlowStatsEntry) GetIdleTimeout() uint16 {
14158 return self.IdleTimeout
14159}
14160
14161func (self *FlowStatsEntry) SetIdleTimeout(v uint16) {
14162 self.IdleTimeout = v
14163}
14164
14165func (self *FlowStatsEntry) GetHardTimeout() uint16 {
14166 return self.HardTimeout
14167}
14168
14169func (self *FlowStatsEntry) SetHardTimeout(v uint16) {
14170 self.HardTimeout = v
14171}
14172
14173func (self *FlowStatsEntry) GetFlags() FlowModFlags {
14174 return self.Flags
14175}
14176
14177func (self *FlowStatsEntry) SetFlags(v FlowModFlags) {
14178 self.Flags = v
14179}
14180
14181func (self *FlowStatsEntry) GetImportance() uint16 {
14182 return self.Importance
14183}
14184
14185func (self *FlowStatsEntry) SetImportance(v uint16) {
14186 self.Importance = v
14187}
14188
14189func (self *FlowStatsEntry) GetCookie() uint64 {
14190 return self.Cookie
14191}
14192
14193func (self *FlowStatsEntry) SetCookie(v uint64) {
14194 self.Cookie = v
14195}
14196
14197func (self *FlowStatsEntry) GetPacketCount() uint64 {
14198 return self.PacketCount
14199}
14200
14201func (self *FlowStatsEntry) SetPacketCount(v uint64) {
14202 self.PacketCount = v
14203}
14204
14205func (self *FlowStatsEntry) GetByteCount() uint64 {
14206 return self.ByteCount
14207}
14208
14209func (self *FlowStatsEntry) SetByteCount(v uint64) {
14210 self.ByteCount = v
14211}
14212
14213func (self *FlowStatsEntry) GetMatch() Match {
14214 return self.Match
14215}
14216
14217func (self *FlowStatsEntry) SetMatch(v Match) {
14218 self.Match = v
14219}
14220
14221func (self *FlowStatsEntry) GetInstructions() []IInstruction {
14222 return self.Instructions
14223}
14224
14225func (self *FlowStatsEntry) SetInstructions(v []IInstruction) {
14226 self.Instructions = v
14227}
14228
14229func (self *FlowStatsEntry) Serialize(encoder *goloxi.Encoder) error {
14230 startIndex := len(encoder.Bytes())
14231
14232 encoder.PutUint16(uint16(self.Length))
14233 encoder.PutUint8(uint8(self.TableId))
14234 encoder.Write(bytes.Repeat([]byte{0}, 1))
14235 encoder.PutUint32(uint32(self.DurationSec))
14236 encoder.PutUint32(uint32(self.DurationNsec))
14237 encoder.PutUint16(uint16(self.Priority))
14238 encoder.PutUint16(uint16(self.IdleTimeout))
14239 encoder.PutUint16(uint16(self.HardTimeout))
14240 encoder.PutUint16(uint16(self.Flags))
14241 encoder.PutUint16(uint16(self.Importance))
14242 encoder.Write(bytes.Repeat([]byte{0}, 2))
14243 encoder.PutUint64(uint64(self.Cookie))
14244 encoder.PutUint64(uint64(self.PacketCount))
14245 encoder.PutUint64(uint64(self.ByteCount))
14246 if err := self.Match.Serialize(encoder); err != nil {
14247 return err
14248 }
14249
14250 for _, obj := range self.Instructions {
14251 if err := obj.Serialize(encoder); err != nil {
14252 return err
14253 }
14254 }
14255 length := len(encoder.Bytes()) - startIndex
14256
14257 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
14258
14259 return nil
14260}
14261
14262func DecodeFlowStatsEntry(decoder *goloxi.Decoder) (*FlowStatsEntry, error) {
14263 _flowstatsentry := &FlowStatsEntry{}
14264 if decoder.Length() < 56 {
14265 return nil, fmt.Errorf("FlowStatsEntry packet too short: %d < 56", decoder.Length())
14266 }
14267 _flowstatsentry.Length = uint16(decoder.ReadUint16())
14268 oldDecoder := decoder
14269 defer func() { decoder = oldDecoder }()
14270 decoder = decoder.SliceDecoder(int(_flowstatsentry.Length), 2+0)
14271 _flowstatsentry.TableId = uint8(decoder.ReadByte())
14272 decoder.Skip(1)
14273 _flowstatsentry.DurationSec = uint32(decoder.ReadUint32())
14274 _flowstatsentry.DurationNsec = uint32(decoder.ReadUint32())
14275 _flowstatsentry.Priority = uint16(decoder.ReadUint16())
14276 _flowstatsentry.IdleTimeout = uint16(decoder.ReadUint16())
14277 _flowstatsentry.HardTimeout = uint16(decoder.ReadUint16())
14278 _flowstatsentry.Flags = FlowModFlags(decoder.ReadUint16())
14279 _flowstatsentry.Importance = uint16(decoder.ReadUint16())
14280 decoder.Skip(2)
14281 _flowstatsentry.Cookie = uint64(decoder.ReadUint64())
14282 _flowstatsentry.PacketCount = uint64(decoder.ReadUint64())
14283 _flowstatsentry.ByteCount = uint64(decoder.ReadUint64())
14284 if err := _flowstatsentry.Match.Decode(decoder); err != nil {
14285 return nil, err
14286 }
14287
14288 decoder.SkipAlign()
14289
14290 for decoder.Length() >= 4 {
14291 item, err := DecodeInstruction(decoder)
14292 if err != nil {
14293 return nil, err
14294 }
14295 if item != nil {
14296 _flowstatsentry.Instructions = append(_flowstatsentry.Instructions, item)
14297 }
14298 }
14299 return _flowstatsentry, nil
14300}
14301
14302func NewFlowStatsEntry() *FlowStatsEntry {
14303 obj := &FlowStatsEntry{}
14304 return obj
14305}
14306
14307type FlowUpdateFullAdded struct {
14308 *FlowMonitorReplyEntry
14309 TableId uint8
14310 Reason uint8
14311 IdleTimeout uint16
14312 HardTimeout uint16
14313 Priority uint16
14314 Cookie uint64
14315 Match Match
14316 Instructions []IInstruction
14317}
14318
14319type IFlowUpdateFullAdded interface {
14320 IFlowMonitorReplyEntry
14321 GetTableId() uint8
14322 GetReason() uint8
14323 GetIdleTimeout() uint16
14324 GetHardTimeout() uint16
14325 GetPriority() uint16
14326 GetCookie() uint64
14327 GetMatch() Match
14328 GetInstructions() []IInstruction
14329}
14330
14331func (self *FlowUpdateFullAdded) GetTableId() uint8 {
14332 return self.TableId
14333}
14334
14335func (self *FlowUpdateFullAdded) SetTableId(v uint8) {
14336 self.TableId = v
14337}
14338
14339func (self *FlowUpdateFullAdded) GetReason() uint8 {
14340 return self.Reason
14341}
14342
14343func (self *FlowUpdateFullAdded) SetReason(v uint8) {
14344 self.Reason = v
14345}
14346
14347func (self *FlowUpdateFullAdded) GetIdleTimeout() uint16 {
14348 return self.IdleTimeout
14349}
14350
14351func (self *FlowUpdateFullAdded) SetIdleTimeout(v uint16) {
14352 self.IdleTimeout = v
14353}
14354
14355func (self *FlowUpdateFullAdded) GetHardTimeout() uint16 {
14356 return self.HardTimeout
14357}
14358
14359func (self *FlowUpdateFullAdded) SetHardTimeout(v uint16) {
14360 self.HardTimeout = v
14361}
14362
14363func (self *FlowUpdateFullAdded) GetPriority() uint16 {
14364 return self.Priority
14365}
14366
14367func (self *FlowUpdateFullAdded) SetPriority(v uint16) {
14368 self.Priority = v
14369}
14370
14371func (self *FlowUpdateFullAdded) GetCookie() uint64 {
14372 return self.Cookie
14373}
14374
14375func (self *FlowUpdateFullAdded) SetCookie(v uint64) {
14376 self.Cookie = v
14377}
14378
14379func (self *FlowUpdateFullAdded) GetMatch() Match {
14380 return self.Match
14381}
14382
14383func (self *FlowUpdateFullAdded) SetMatch(v Match) {
14384 self.Match = v
14385}
14386
14387func (self *FlowUpdateFullAdded) GetInstructions() []IInstruction {
14388 return self.Instructions
14389}
14390
14391func (self *FlowUpdateFullAdded) SetInstructions(v []IInstruction) {
14392 self.Instructions = v
14393}
14394
14395func (self *FlowUpdateFullAdded) Serialize(encoder *goloxi.Encoder) error {
14396 startIndex := len(encoder.Bytes())
14397 if err := self.FlowMonitorReplyEntry.Serialize(encoder); err != nil {
14398 return err
14399 }
14400
14401 encoder.PutUint8(uint8(self.TableId))
14402 encoder.PutUint8(uint8(self.Reason))
14403 encoder.PutUint16(uint16(self.IdleTimeout))
14404 encoder.PutUint16(uint16(self.HardTimeout))
14405 encoder.PutUint16(uint16(self.Priority))
14406 encoder.Write(bytes.Repeat([]byte{0}, 4))
14407 encoder.PutUint64(uint64(self.Cookie))
14408 if err := self.Match.Serialize(encoder); err != nil {
14409 return err
14410 }
14411
14412 for _, obj := range self.Instructions {
14413 if err := obj.Serialize(encoder); err != nil {
14414 return err
14415 }
14416 }
14417 length := len(encoder.Bytes()) - startIndex
14418
14419 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
14420
14421 return nil
14422}
14423
14424func DecodeFlowUpdateFullAdded(parent *FlowMonitorReplyEntry, decoder *goloxi.Decoder) (*FlowUpdateFullAdded, error) {
14425 _flowupdatefulladded := &FlowUpdateFullAdded{FlowMonitorReplyEntry: parent}
14426 if decoder.Length() < 28 {
14427 return nil, fmt.Errorf("FlowUpdateFullAdded packet too short: %d < 28", decoder.Length())
14428 }
14429 _flowupdatefulladded.TableId = uint8(decoder.ReadByte())
14430 _flowupdatefulladded.Reason = uint8(decoder.ReadByte())
14431 _flowupdatefulladded.IdleTimeout = uint16(decoder.ReadUint16())
14432 _flowupdatefulladded.HardTimeout = uint16(decoder.ReadUint16())
14433 _flowupdatefulladded.Priority = uint16(decoder.ReadUint16())
14434 decoder.Skip(4)
14435 _flowupdatefulladded.Cookie = uint64(decoder.ReadUint64())
14436 if err := _flowupdatefulladded.Match.Decode(decoder); err != nil {
14437 return nil, err
14438 }
14439
14440 decoder.SkipAlign()
14441
14442 for decoder.Length() >= 4 {
14443 item, err := DecodeInstruction(decoder)
14444 if err != nil {
14445 return nil, err
14446 }
14447 if item != nil {
14448 _flowupdatefulladded.Instructions = append(_flowupdatefulladded.Instructions, item)
14449 }
14450 }
14451 return _flowupdatefulladded, nil
14452}
14453
14454func NewFlowUpdateFullAdded() *FlowUpdateFullAdded {
14455 obj := &FlowUpdateFullAdded{
14456 FlowMonitorReplyEntry: NewFlowMonitorReplyEntry(1),
14457 }
14458 return obj
14459}
14460
14461type FlowUpdateFullInitial struct {
14462 *FlowMonitorReplyEntry
14463 TableId uint8
14464 Reason uint8
14465 IdleTimeout uint16
14466 HardTimeout uint16
14467 Priority uint16
14468 Cookie uint64
14469 Match Match
14470 Instructions []IInstruction
14471}
14472
14473type IFlowUpdateFullInitial interface {
14474 IFlowMonitorReplyEntry
14475 GetTableId() uint8
14476 GetReason() uint8
14477 GetIdleTimeout() uint16
14478 GetHardTimeout() uint16
14479 GetPriority() uint16
14480 GetCookie() uint64
14481 GetMatch() Match
14482 GetInstructions() []IInstruction
14483}
14484
14485func (self *FlowUpdateFullInitial) GetTableId() uint8 {
14486 return self.TableId
14487}
14488
14489func (self *FlowUpdateFullInitial) SetTableId(v uint8) {
14490 self.TableId = v
14491}
14492
14493func (self *FlowUpdateFullInitial) GetReason() uint8 {
14494 return self.Reason
14495}
14496
14497func (self *FlowUpdateFullInitial) SetReason(v uint8) {
14498 self.Reason = v
14499}
14500
14501func (self *FlowUpdateFullInitial) GetIdleTimeout() uint16 {
14502 return self.IdleTimeout
14503}
14504
14505func (self *FlowUpdateFullInitial) SetIdleTimeout(v uint16) {
14506 self.IdleTimeout = v
14507}
14508
14509func (self *FlowUpdateFullInitial) GetHardTimeout() uint16 {
14510 return self.HardTimeout
14511}
14512
14513func (self *FlowUpdateFullInitial) SetHardTimeout(v uint16) {
14514 self.HardTimeout = v
14515}
14516
14517func (self *FlowUpdateFullInitial) GetPriority() uint16 {
14518 return self.Priority
14519}
14520
14521func (self *FlowUpdateFullInitial) SetPriority(v uint16) {
14522 self.Priority = v
14523}
14524
14525func (self *FlowUpdateFullInitial) GetCookie() uint64 {
14526 return self.Cookie
14527}
14528
14529func (self *FlowUpdateFullInitial) SetCookie(v uint64) {
14530 self.Cookie = v
14531}
14532
14533func (self *FlowUpdateFullInitial) GetMatch() Match {
14534 return self.Match
14535}
14536
14537func (self *FlowUpdateFullInitial) SetMatch(v Match) {
14538 self.Match = v
14539}
14540
14541func (self *FlowUpdateFullInitial) GetInstructions() []IInstruction {
14542 return self.Instructions
14543}
14544
14545func (self *FlowUpdateFullInitial) SetInstructions(v []IInstruction) {
14546 self.Instructions = v
14547}
14548
14549func (self *FlowUpdateFullInitial) Serialize(encoder *goloxi.Encoder) error {
14550 startIndex := len(encoder.Bytes())
14551 if err := self.FlowMonitorReplyEntry.Serialize(encoder); err != nil {
14552 return err
14553 }
14554
14555 encoder.PutUint8(uint8(self.TableId))
14556 encoder.PutUint8(uint8(self.Reason))
14557 encoder.PutUint16(uint16(self.IdleTimeout))
14558 encoder.PutUint16(uint16(self.HardTimeout))
14559 encoder.PutUint16(uint16(self.Priority))
14560 encoder.Write(bytes.Repeat([]byte{0}, 4))
14561 encoder.PutUint64(uint64(self.Cookie))
14562 if err := self.Match.Serialize(encoder); err != nil {
14563 return err
14564 }
14565
14566 for _, obj := range self.Instructions {
14567 if err := obj.Serialize(encoder); err != nil {
14568 return err
14569 }
14570 }
14571 length := len(encoder.Bytes()) - startIndex
14572
14573 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
14574
14575 return nil
14576}
14577
14578func DecodeFlowUpdateFullInitial(parent *FlowMonitorReplyEntry, decoder *goloxi.Decoder) (*FlowUpdateFullInitial, error) {
14579 _flowupdatefullinitial := &FlowUpdateFullInitial{FlowMonitorReplyEntry: parent}
14580 if decoder.Length() < 28 {
14581 return nil, fmt.Errorf("FlowUpdateFullInitial packet too short: %d < 28", decoder.Length())
14582 }
14583 _flowupdatefullinitial.TableId = uint8(decoder.ReadByte())
14584 _flowupdatefullinitial.Reason = uint8(decoder.ReadByte())
14585 _flowupdatefullinitial.IdleTimeout = uint16(decoder.ReadUint16())
14586 _flowupdatefullinitial.HardTimeout = uint16(decoder.ReadUint16())
14587 _flowupdatefullinitial.Priority = uint16(decoder.ReadUint16())
14588 decoder.Skip(4)
14589 _flowupdatefullinitial.Cookie = uint64(decoder.ReadUint64())
14590 if err := _flowupdatefullinitial.Match.Decode(decoder); err != nil {
14591 return nil, err
14592 }
14593
14594 decoder.SkipAlign()
14595
14596 for decoder.Length() >= 4 {
14597 item, err := DecodeInstruction(decoder)
14598 if err != nil {
14599 return nil, err
14600 }
14601 if item != nil {
14602 _flowupdatefullinitial.Instructions = append(_flowupdatefullinitial.Instructions, item)
14603 }
14604 }
14605 return _flowupdatefullinitial, nil
14606}
14607
14608func NewFlowUpdateFullInitial() *FlowUpdateFullInitial {
14609 obj := &FlowUpdateFullInitial{
14610 FlowMonitorReplyEntry: NewFlowMonitorReplyEntry(0),
14611 }
14612 return obj
14613}
14614
14615type FlowUpdateFullModified struct {
14616 *FlowMonitorReplyEntry
14617 TableId uint8
14618 Reason uint8
14619 IdleTimeout uint16
14620 HardTimeout uint16
14621 Priority uint16
14622 Cookie uint64
14623 Match Match
14624 Instructions []IInstruction
14625}
14626
14627type IFlowUpdateFullModified interface {
14628 IFlowMonitorReplyEntry
14629 GetTableId() uint8
14630 GetReason() uint8
14631 GetIdleTimeout() uint16
14632 GetHardTimeout() uint16
14633 GetPriority() uint16
14634 GetCookie() uint64
14635 GetMatch() Match
14636 GetInstructions() []IInstruction
14637}
14638
14639func (self *FlowUpdateFullModified) GetTableId() uint8 {
14640 return self.TableId
14641}
14642
14643func (self *FlowUpdateFullModified) SetTableId(v uint8) {
14644 self.TableId = v
14645}
14646
14647func (self *FlowUpdateFullModified) GetReason() uint8 {
14648 return self.Reason
14649}
14650
14651func (self *FlowUpdateFullModified) SetReason(v uint8) {
14652 self.Reason = v
14653}
14654
14655func (self *FlowUpdateFullModified) GetIdleTimeout() uint16 {
14656 return self.IdleTimeout
14657}
14658
14659func (self *FlowUpdateFullModified) SetIdleTimeout(v uint16) {
14660 self.IdleTimeout = v
14661}
14662
14663func (self *FlowUpdateFullModified) GetHardTimeout() uint16 {
14664 return self.HardTimeout
14665}
14666
14667func (self *FlowUpdateFullModified) SetHardTimeout(v uint16) {
14668 self.HardTimeout = v
14669}
14670
14671func (self *FlowUpdateFullModified) GetPriority() uint16 {
14672 return self.Priority
14673}
14674
14675func (self *FlowUpdateFullModified) SetPriority(v uint16) {
14676 self.Priority = v
14677}
14678
14679func (self *FlowUpdateFullModified) GetCookie() uint64 {
14680 return self.Cookie
14681}
14682
14683func (self *FlowUpdateFullModified) SetCookie(v uint64) {
14684 self.Cookie = v
14685}
14686
14687func (self *FlowUpdateFullModified) GetMatch() Match {
14688 return self.Match
14689}
14690
14691func (self *FlowUpdateFullModified) SetMatch(v Match) {
14692 self.Match = v
14693}
14694
14695func (self *FlowUpdateFullModified) GetInstructions() []IInstruction {
14696 return self.Instructions
14697}
14698
14699func (self *FlowUpdateFullModified) SetInstructions(v []IInstruction) {
14700 self.Instructions = v
14701}
14702
14703func (self *FlowUpdateFullModified) Serialize(encoder *goloxi.Encoder) error {
14704 startIndex := len(encoder.Bytes())
14705 if err := self.FlowMonitorReplyEntry.Serialize(encoder); err != nil {
14706 return err
14707 }
14708
14709 encoder.PutUint8(uint8(self.TableId))
14710 encoder.PutUint8(uint8(self.Reason))
14711 encoder.PutUint16(uint16(self.IdleTimeout))
14712 encoder.PutUint16(uint16(self.HardTimeout))
14713 encoder.PutUint16(uint16(self.Priority))
14714 encoder.Write(bytes.Repeat([]byte{0}, 4))
14715 encoder.PutUint64(uint64(self.Cookie))
14716 if err := self.Match.Serialize(encoder); err != nil {
14717 return err
14718 }
14719
14720 for _, obj := range self.Instructions {
14721 if err := obj.Serialize(encoder); err != nil {
14722 return err
14723 }
14724 }
14725 length := len(encoder.Bytes()) - startIndex
14726
14727 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
14728
14729 return nil
14730}
14731
14732func DecodeFlowUpdateFullModified(parent *FlowMonitorReplyEntry, decoder *goloxi.Decoder) (*FlowUpdateFullModified, error) {
14733 _flowupdatefullmodified := &FlowUpdateFullModified{FlowMonitorReplyEntry: parent}
14734 if decoder.Length() < 28 {
14735 return nil, fmt.Errorf("FlowUpdateFullModified packet too short: %d < 28", decoder.Length())
14736 }
14737 _flowupdatefullmodified.TableId = uint8(decoder.ReadByte())
14738 _flowupdatefullmodified.Reason = uint8(decoder.ReadByte())
14739 _flowupdatefullmodified.IdleTimeout = uint16(decoder.ReadUint16())
14740 _flowupdatefullmodified.HardTimeout = uint16(decoder.ReadUint16())
14741 _flowupdatefullmodified.Priority = uint16(decoder.ReadUint16())
14742 decoder.Skip(4)
14743 _flowupdatefullmodified.Cookie = uint64(decoder.ReadUint64())
14744 if err := _flowupdatefullmodified.Match.Decode(decoder); err != nil {
14745 return nil, err
14746 }
14747
14748 decoder.SkipAlign()
14749
14750 for decoder.Length() >= 4 {
14751 item, err := DecodeInstruction(decoder)
14752 if err != nil {
14753 return nil, err
14754 }
14755 if item != nil {
14756 _flowupdatefullmodified.Instructions = append(_flowupdatefullmodified.Instructions, item)
14757 }
14758 }
14759 return _flowupdatefullmodified, nil
14760}
14761
14762func NewFlowUpdateFullModified() *FlowUpdateFullModified {
14763 obj := &FlowUpdateFullModified{
14764 FlowMonitorReplyEntry: NewFlowMonitorReplyEntry(3),
14765 }
14766 return obj
14767}
14768
14769type FlowUpdateFullRemoved struct {
14770 *FlowMonitorReplyEntry
14771 TableId uint8
14772 Reason uint8
14773 IdleTimeout uint16
14774 HardTimeout uint16
14775 Priority uint16
14776 Cookie uint64
14777 Match Match
14778 Instructions []IInstruction
14779}
14780
14781type IFlowUpdateFullRemoved interface {
14782 IFlowMonitorReplyEntry
14783 GetTableId() uint8
14784 GetReason() uint8
14785 GetIdleTimeout() uint16
14786 GetHardTimeout() uint16
14787 GetPriority() uint16
14788 GetCookie() uint64
14789 GetMatch() Match
14790 GetInstructions() []IInstruction
14791}
14792
14793func (self *FlowUpdateFullRemoved) GetTableId() uint8 {
14794 return self.TableId
14795}
14796
14797func (self *FlowUpdateFullRemoved) SetTableId(v uint8) {
14798 self.TableId = v
14799}
14800
14801func (self *FlowUpdateFullRemoved) GetReason() uint8 {
14802 return self.Reason
14803}
14804
14805func (self *FlowUpdateFullRemoved) SetReason(v uint8) {
14806 self.Reason = v
14807}
14808
14809func (self *FlowUpdateFullRemoved) GetIdleTimeout() uint16 {
14810 return self.IdleTimeout
14811}
14812
14813func (self *FlowUpdateFullRemoved) SetIdleTimeout(v uint16) {
14814 self.IdleTimeout = v
14815}
14816
14817func (self *FlowUpdateFullRemoved) GetHardTimeout() uint16 {
14818 return self.HardTimeout
14819}
14820
14821func (self *FlowUpdateFullRemoved) SetHardTimeout(v uint16) {
14822 self.HardTimeout = v
14823}
14824
14825func (self *FlowUpdateFullRemoved) GetPriority() uint16 {
14826 return self.Priority
14827}
14828
14829func (self *FlowUpdateFullRemoved) SetPriority(v uint16) {
14830 self.Priority = v
14831}
14832
14833func (self *FlowUpdateFullRemoved) GetCookie() uint64 {
14834 return self.Cookie
14835}
14836
14837func (self *FlowUpdateFullRemoved) SetCookie(v uint64) {
14838 self.Cookie = v
14839}
14840
14841func (self *FlowUpdateFullRemoved) GetMatch() Match {
14842 return self.Match
14843}
14844
14845func (self *FlowUpdateFullRemoved) SetMatch(v Match) {
14846 self.Match = v
14847}
14848
14849func (self *FlowUpdateFullRemoved) GetInstructions() []IInstruction {
14850 return self.Instructions
14851}
14852
14853func (self *FlowUpdateFullRemoved) SetInstructions(v []IInstruction) {
14854 self.Instructions = v
14855}
14856
14857func (self *FlowUpdateFullRemoved) Serialize(encoder *goloxi.Encoder) error {
14858 startIndex := len(encoder.Bytes())
14859 if err := self.FlowMonitorReplyEntry.Serialize(encoder); err != nil {
14860 return err
14861 }
14862
14863 encoder.PutUint8(uint8(self.TableId))
14864 encoder.PutUint8(uint8(self.Reason))
14865 encoder.PutUint16(uint16(self.IdleTimeout))
14866 encoder.PutUint16(uint16(self.HardTimeout))
14867 encoder.PutUint16(uint16(self.Priority))
14868 encoder.Write(bytes.Repeat([]byte{0}, 4))
14869 encoder.PutUint64(uint64(self.Cookie))
14870 if err := self.Match.Serialize(encoder); err != nil {
14871 return err
14872 }
14873
14874 for _, obj := range self.Instructions {
14875 if err := obj.Serialize(encoder); err != nil {
14876 return err
14877 }
14878 }
14879 length := len(encoder.Bytes()) - startIndex
14880
14881 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
14882
14883 return nil
14884}
14885
14886func DecodeFlowUpdateFullRemoved(parent *FlowMonitorReplyEntry, decoder *goloxi.Decoder) (*FlowUpdateFullRemoved, error) {
14887 _flowupdatefullremoved := &FlowUpdateFullRemoved{FlowMonitorReplyEntry: parent}
14888 if decoder.Length() < 28 {
14889 return nil, fmt.Errorf("FlowUpdateFullRemoved packet too short: %d < 28", decoder.Length())
14890 }
14891 _flowupdatefullremoved.TableId = uint8(decoder.ReadByte())
14892 _flowupdatefullremoved.Reason = uint8(decoder.ReadByte())
14893 _flowupdatefullremoved.IdleTimeout = uint16(decoder.ReadUint16())
14894 _flowupdatefullremoved.HardTimeout = uint16(decoder.ReadUint16())
14895 _flowupdatefullremoved.Priority = uint16(decoder.ReadUint16())
14896 decoder.Skip(4)
14897 _flowupdatefullremoved.Cookie = uint64(decoder.ReadUint64())
14898 if err := _flowupdatefullremoved.Match.Decode(decoder); err != nil {
14899 return nil, err
14900 }
14901
14902 decoder.SkipAlign()
14903
14904 for decoder.Length() >= 4 {
14905 item, err := DecodeInstruction(decoder)
14906 if err != nil {
14907 return nil, err
14908 }
14909 if item != nil {
14910 _flowupdatefullremoved.Instructions = append(_flowupdatefullremoved.Instructions, item)
14911 }
14912 }
14913 return _flowupdatefullremoved, nil
14914}
14915
14916func NewFlowUpdateFullRemoved() *FlowUpdateFullRemoved {
14917 obj := &FlowUpdateFullRemoved{
14918 FlowMonitorReplyEntry: NewFlowMonitorReplyEntry(2),
14919 }
14920 return obj
14921}
14922
14923type GroupDescStatsEntry struct {
14924 Length uint16
14925 GroupType GroupType
14926 GroupId uint32
14927 Buckets []*Bucket
14928}
14929
14930type IGroupDescStatsEntry interface {
14931 goloxi.Serializable
14932 GetLength() uint16
14933 GetGroupType() GroupType
14934 GetGroupId() uint32
14935 GetBuckets() []*Bucket
14936}
14937
14938func (self *GroupDescStatsEntry) GetLength() uint16 {
14939 return self.Length
14940}
14941
14942func (self *GroupDescStatsEntry) SetLength(v uint16) {
14943 self.Length = v
14944}
14945
14946func (self *GroupDescStatsEntry) GetGroupType() GroupType {
14947 return self.GroupType
14948}
14949
14950func (self *GroupDescStatsEntry) SetGroupType(v GroupType) {
14951 self.GroupType = v
14952}
14953
14954func (self *GroupDescStatsEntry) GetGroupId() uint32 {
14955 return self.GroupId
14956}
14957
14958func (self *GroupDescStatsEntry) SetGroupId(v uint32) {
14959 self.GroupId = v
14960}
14961
14962func (self *GroupDescStatsEntry) GetBuckets() []*Bucket {
14963 return self.Buckets
14964}
14965
14966func (self *GroupDescStatsEntry) SetBuckets(v []*Bucket) {
14967 self.Buckets = v
14968}
14969
14970func (self *GroupDescStatsEntry) Serialize(encoder *goloxi.Encoder) error {
14971 startIndex := len(encoder.Bytes())
14972
14973 encoder.PutUint16(uint16(self.Length))
14974 encoder.PutUint8(uint8(self.GroupType))
14975 encoder.Write(bytes.Repeat([]byte{0}, 1))
14976 encoder.PutUint32(uint32(self.GroupId))
14977 for _, obj := range self.Buckets {
14978 if err := obj.Serialize(encoder); err != nil {
14979 return err
14980 }
14981 }
14982 length := len(encoder.Bytes()) - startIndex
14983
14984 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
14985
14986 return nil
14987}
14988
14989func DecodeGroupDescStatsEntry(decoder *goloxi.Decoder) (*GroupDescStatsEntry, error) {
14990 _groupdescstatsentry := &GroupDescStatsEntry{}
14991 if decoder.Length() < 8 {
14992 return nil, fmt.Errorf("GroupDescStatsEntry packet too short: %d < 8", decoder.Length())
14993 }
14994 _groupdescstatsentry.Length = uint16(decoder.ReadUint16())
14995 oldDecoder := decoder
14996 defer func() { decoder = oldDecoder }()
14997 decoder = decoder.SliceDecoder(int(_groupdescstatsentry.Length), 2+0)
14998 _groupdescstatsentry.GroupType = GroupType(decoder.ReadByte())
14999 decoder.Skip(1)
15000 _groupdescstatsentry.GroupId = uint32(decoder.ReadUint32())
15001
15002 for decoder.Length() >= 16 {
15003 item, err := DecodeBucket(decoder)
15004 if err != nil {
15005 return nil, err
15006 }
15007 if item != nil {
15008 _groupdescstatsentry.Buckets = append(_groupdescstatsentry.Buckets, item)
15009 }
15010 }
15011 return _groupdescstatsentry, nil
15012}
15013
15014func NewGroupDescStatsEntry() *GroupDescStatsEntry {
15015 obj := &GroupDescStatsEntry{}
15016 return obj
15017}
15018
15019type GroupStatsEntry struct {
15020 Length uint16
15021 GroupId uint32
15022 RefCount uint32
15023 PacketCount uint64
15024 ByteCount uint64
15025 DurationSec uint32
15026 DurationNsec uint32
15027 BucketStats []*BucketCounter
15028}
15029
15030type IGroupStatsEntry interface {
15031 goloxi.Serializable
15032 GetLength() uint16
15033 GetGroupId() uint32
15034 GetRefCount() uint32
15035 GetPacketCount() uint64
15036 GetByteCount() uint64
15037 GetDurationSec() uint32
15038 GetDurationNsec() uint32
15039 GetBucketStats() []*BucketCounter
15040}
15041
15042func (self *GroupStatsEntry) GetLength() uint16 {
15043 return self.Length
15044}
15045
15046func (self *GroupStatsEntry) SetLength(v uint16) {
15047 self.Length = v
15048}
15049
15050func (self *GroupStatsEntry) GetGroupId() uint32 {
15051 return self.GroupId
15052}
15053
15054func (self *GroupStatsEntry) SetGroupId(v uint32) {
15055 self.GroupId = v
15056}
15057
15058func (self *GroupStatsEntry) GetRefCount() uint32 {
15059 return self.RefCount
15060}
15061
15062func (self *GroupStatsEntry) SetRefCount(v uint32) {
15063 self.RefCount = v
15064}
15065
15066func (self *GroupStatsEntry) GetPacketCount() uint64 {
15067 return self.PacketCount
15068}
15069
15070func (self *GroupStatsEntry) SetPacketCount(v uint64) {
15071 self.PacketCount = v
15072}
15073
15074func (self *GroupStatsEntry) GetByteCount() uint64 {
15075 return self.ByteCount
15076}
15077
15078func (self *GroupStatsEntry) SetByteCount(v uint64) {
15079 self.ByteCount = v
15080}
15081
15082func (self *GroupStatsEntry) GetDurationSec() uint32 {
15083 return self.DurationSec
15084}
15085
15086func (self *GroupStatsEntry) SetDurationSec(v uint32) {
15087 self.DurationSec = v
15088}
15089
15090func (self *GroupStatsEntry) GetDurationNsec() uint32 {
15091 return self.DurationNsec
15092}
15093
15094func (self *GroupStatsEntry) SetDurationNsec(v uint32) {
15095 self.DurationNsec = v
15096}
15097
15098func (self *GroupStatsEntry) GetBucketStats() []*BucketCounter {
15099 return self.BucketStats
15100}
15101
15102func (self *GroupStatsEntry) SetBucketStats(v []*BucketCounter) {
15103 self.BucketStats = v
15104}
15105
15106func (self *GroupStatsEntry) Serialize(encoder *goloxi.Encoder) error {
15107 startIndex := len(encoder.Bytes())
15108
15109 encoder.PutUint16(uint16(self.Length))
15110 encoder.Write(bytes.Repeat([]byte{0}, 2))
15111 encoder.PutUint32(uint32(self.GroupId))
15112 encoder.PutUint32(uint32(self.RefCount))
15113 encoder.Write(bytes.Repeat([]byte{0}, 4))
15114 encoder.PutUint64(uint64(self.PacketCount))
15115 encoder.PutUint64(uint64(self.ByteCount))
15116 encoder.PutUint32(uint32(self.DurationSec))
15117 encoder.PutUint32(uint32(self.DurationNsec))
15118 for _, obj := range self.BucketStats {
15119 if err := obj.Serialize(encoder); err != nil {
15120 return err
15121 }
15122 }
15123 length := len(encoder.Bytes()) - startIndex
15124
15125 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
15126
15127 return nil
15128}
15129
15130func DecodeGroupStatsEntry(decoder *goloxi.Decoder) (*GroupStatsEntry, error) {
15131 _groupstatsentry := &GroupStatsEntry{}
15132 if decoder.Length() < 40 {
15133 return nil, fmt.Errorf("GroupStatsEntry packet too short: %d < 40", decoder.Length())
15134 }
15135 _groupstatsentry.Length = uint16(decoder.ReadUint16())
15136 oldDecoder := decoder
15137 defer func() { decoder = oldDecoder }()
15138 decoder = decoder.SliceDecoder(int(_groupstatsentry.Length), 2+0)
15139 decoder.Skip(2)
15140 _groupstatsentry.GroupId = uint32(decoder.ReadUint32())
15141 _groupstatsentry.RefCount = uint32(decoder.ReadUint32())
15142 decoder.Skip(4)
15143 _groupstatsentry.PacketCount = uint64(decoder.ReadUint64())
15144 _groupstatsentry.ByteCount = uint64(decoder.ReadUint64())
15145 _groupstatsentry.DurationSec = uint32(decoder.ReadUint32())
15146 _groupstatsentry.DurationNsec = uint32(decoder.ReadUint32())
15147
15148 for decoder.Length() >= 16 {
15149 item, err := DecodeBucketCounter(decoder)
15150 if err != nil {
15151 return nil, err
15152 }
15153 if item != nil {
15154 _groupstatsentry.BucketStats = append(_groupstatsentry.BucketStats, item)
15155 }
15156 }
15157 return _groupstatsentry, nil
15158}
15159
15160func NewGroupStatsEntry() *GroupStatsEntry {
15161 obj := &GroupStatsEntry{}
15162 return obj
15163}
15164
15165type HelloElem struct {
15166 Type uint16
15167 Length uint16
15168}
15169
15170type IHelloElem interface {
15171 goloxi.Serializable
15172 GetType() uint16
15173 GetLength() uint16
15174}
15175
15176func (self *HelloElem) GetType() uint16 {
15177 return self.Type
15178}
15179
15180func (self *HelloElem) SetType(v uint16) {
15181 self.Type = v
15182}
15183
15184func (self *HelloElem) GetLength() uint16 {
15185 return self.Length
15186}
15187
15188func (self *HelloElem) SetLength(v uint16) {
15189 self.Length = v
15190}
15191
15192func (self *HelloElem) Serialize(encoder *goloxi.Encoder) error {
15193
15194 encoder.PutUint16(uint16(self.Type))
15195 encoder.PutUint16(uint16(self.Length))
15196
15197 return nil
15198}
15199
15200func DecodeHelloElem(decoder *goloxi.Decoder) (IHelloElem, error) {
15201 _helloelem := &HelloElem{}
15202 if decoder.Length() < 4 {
15203 return nil, fmt.Errorf("HelloElem packet too short: %d < 4", decoder.Length())
15204 }
15205 _helloelem.Type = uint16(decoder.ReadUint16())
15206 _helloelem.Length = uint16(decoder.ReadUint16())
15207 oldDecoder := decoder
15208 defer func() { decoder = oldDecoder }()
15209 decoder = decoder.SliceDecoder(int(_helloelem.Length), 2+2)
15210
15211 switch _helloelem.Type {
15212 case 1:
15213 return DecodeHelloElemVersionbitmap(_helloelem, decoder)
15214 default:
15215 return nil, fmt.Errorf("Invalid type '%d' for 'HelloElem'", _helloelem.Type)
15216 }
15217}
15218
15219func NewHelloElem(_type uint16) *HelloElem {
15220 obj := &HelloElem{}
15221 obj.Type = _type
15222 return obj
15223}
15224
15225type HelloElemVersionbitmap struct {
15226 *HelloElem
15227 Bitmaps []*Uint32
15228}
15229
15230type IHelloElemVersionbitmap interface {
15231 IHelloElem
15232 GetBitmaps() []*Uint32
15233}
15234
15235func (self *HelloElemVersionbitmap) GetBitmaps() []*Uint32 {
15236 return self.Bitmaps
15237}
15238
15239func (self *HelloElemVersionbitmap) SetBitmaps(v []*Uint32) {
15240 self.Bitmaps = v
15241}
15242
15243func (self *HelloElemVersionbitmap) Serialize(encoder *goloxi.Encoder) error {
15244 startIndex := len(encoder.Bytes())
15245 if err := self.HelloElem.Serialize(encoder); err != nil {
15246 return err
15247 }
15248
15249 for _, obj := range self.Bitmaps {
15250 if err := obj.Serialize(encoder); err != nil {
15251 return err
15252 }
15253 }
15254 length := len(encoder.Bytes()) - startIndex
15255 alignedLength := ((length + 7) / 8 * 8)
15256
15257 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
15258
15259 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
15260
15261 return nil
15262}
15263
15264func DecodeHelloElemVersionbitmap(parent *HelloElem, decoder *goloxi.Decoder) (*HelloElemVersionbitmap, error) {
15265 _helloelemversionbitmap := &HelloElemVersionbitmap{HelloElem: parent}
15266
15267 for decoder.Length() >= 4 {
15268 item, err := DecodeUint32(decoder)
15269 if err != nil {
15270 return nil, err
15271 }
15272 if item != nil {
15273 _helloelemversionbitmap.Bitmaps = append(_helloelemversionbitmap.Bitmaps, item)
15274 }
15275 }
15276 return _helloelemversionbitmap, nil
15277}
15278
15279func NewHelloElemVersionbitmap() *HelloElemVersionbitmap {
15280 obj := &HelloElemVersionbitmap{
15281 HelloElem: NewHelloElem(1),
15282 }
15283 return obj
15284}
15285
15286type InstructionId struct {
15287 Type uint16
15288 Len uint16
15289}
15290
15291type IInstructionId interface {
15292 goloxi.Serializable
15293 GetType() uint16
15294 GetLen() uint16
15295}
15296
15297func (self *InstructionId) GetType() uint16 {
15298 return self.Type
15299}
15300
15301func (self *InstructionId) SetType(v uint16) {
15302 self.Type = v
15303}
15304
15305func (self *InstructionId) GetLen() uint16 {
15306 return self.Len
15307}
15308
15309func (self *InstructionId) SetLen(v uint16) {
15310 self.Len = v
15311}
15312
15313func (self *InstructionId) Serialize(encoder *goloxi.Encoder) error {
15314
15315 encoder.PutUint16(uint16(self.Type))
15316 encoder.PutUint16(uint16(self.Len))
15317
15318 return nil
15319}
15320
15321func DecodeInstructionId(decoder *goloxi.Decoder) (IInstructionId, error) {
15322 _instructionid := &InstructionId{}
15323 if decoder.Length() < 4 {
15324 return nil, fmt.Errorf("InstructionId packet too short: %d < 4", decoder.Length())
15325 }
15326 _instructionid.Type = uint16(decoder.ReadUint16())
15327 _instructionid.Len = uint16(decoder.ReadUint16())
15328 oldDecoder := decoder
15329 defer func() { decoder = oldDecoder }()
15330 decoder = decoder.SliceDecoder(int(_instructionid.Len), 2+2)
15331
15332 switch _instructionid.Type {
15333 case 1:
15334 return DecodeInstructionIdGotoTable(_instructionid, decoder)
15335 case 2:
15336 return DecodeInstructionIdWriteMetadata(_instructionid, decoder)
15337 case 3:
15338 return DecodeInstructionIdWriteActions(_instructionid, decoder)
15339 case 4:
15340 return DecodeInstructionIdApplyActions(_instructionid, decoder)
15341 case 5:
15342 return DecodeInstructionIdClearActions(_instructionid, decoder)
15343 case 6:
15344 return DecodeInstructionIdMeter(_instructionid, decoder)
15345 case 65535:
15346 return DecodeInstructionIdExperimenter(_instructionid, decoder)
15347 default:
15348 return nil, fmt.Errorf("Invalid type '%d' for 'InstructionId'", _instructionid.Type)
15349 }
15350}
15351
15352func NewInstructionId(_type uint16) *InstructionId {
15353 obj := &InstructionId{}
15354 obj.Type = _type
15355 return obj
15356}
15357
15358type InstructionIdApplyActions struct {
15359 *InstructionId
15360}
15361
15362type IInstructionIdApplyActions interface {
15363 IInstructionId
15364}
15365
15366func (self *InstructionIdApplyActions) Serialize(encoder *goloxi.Encoder) error {
15367 startIndex := len(encoder.Bytes())
15368 if err := self.InstructionId.Serialize(encoder); err != nil {
15369 return err
15370 }
15371 length := len(encoder.Bytes()) - startIndex
15372
15373 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
15374
15375 return nil
15376}
15377
15378func DecodeInstructionIdApplyActions(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdApplyActions, error) {
15379 _instructionidapplyactions := &InstructionIdApplyActions{InstructionId: parent}
15380 return _instructionidapplyactions, nil
15381}
15382
15383func NewInstructionIdApplyActions() *InstructionIdApplyActions {
15384 obj := &InstructionIdApplyActions{
15385 InstructionId: NewInstructionId(4),
15386 }
15387 return obj
15388}
15389
15390type InstructionIdExperimenter struct {
15391 *InstructionId
15392 Experimenter uint32
15393}
15394
15395type IInstructionIdExperimenter interface {
15396 IInstructionId
15397 GetExperimenter() uint32
15398}
15399
15400func (self *InstructionIdExperimenter) GetExperimenter() uint32 {
15401 return self.Experimenter
15402}
15403
15404func (self *InstructionIdExperimenter) SetExperimenter(v uint32) {
15405 self.Experimenter = v
15406}
15407
15408func (self *InstructionIdExperimenter) Serialize(encoder *goloxi.Encoder) error {
15409 if err := self.InstructionId.Serialize(encoder); err != nil {
15410 return err
15411 }
15412
15413 encoder.PutUint32(uint32(self.Experimenter))
15414
15415 return nil
15416}
15417
15418func DecodeInstructionIdExperimenter(parent *InstructionId, decoder *goloxi.Decoder) (IInstructionIdExperimenter, error) {
15419 _instructionidexperimenter := &InstructionIdExperimenter{InstructionId: parent}
15420 if decoder.Length() < 4 {
15421 return nil, fmt.Errorf("InstructionIdExperimenter packet too short: %d < 4", decoder.Length())
15422 }
15423 _instructionidexperimenter.Experimenter = uint32(decoder.ReadUint32())
15424
15425 switch _instructionidexperimenter.Experimenter {
15426 case 6035143:
15427 return DecodeInstructionIdBsn(_instructionidexperimenter, decoder)
15428 default:
15429 return nil, fmt.Errorf("Invalid type '%d' for 'InstructionIdExperimenter'", _instructionidexperimenter.Experimenter)
15430 }
15431}
15432
15433func NewInstructionIdExperimenter(_experimenter uint32) *InstructionIdExperimenter {
15434 obj := &InstructionIdExperimenter{
15435 InstructionId: NewInstructionId(65535),
15436 }
15437 obj.Experimenter = _experimenter
15438 return obj
15439}
15440
15441type InstructionIdBsn struct {
15442 *InstructionIdExperimenter
15443 Subtype uint32
15444}
15445
15446type IInstructionIdBsn interface {
15447 IInstructionIdExperimenter
15448 GetSubtype() uint32
15449}
15450
15451func (self *InstructionIdBsn) GetSubtype() uint32 {
15452 return self.Subtype
15453}
15454
15455func (self *InstructionIdBsn) SetSubtype(v uint32) {
15456 self.Subtype = v
15457}
15458
15459func (self *InstructionIdBsn) Serialize(encoder *goloxi.Encoder) error {
15460 if err := self.InstructionIdExperimenter.Serialize(encoder); err != nil {
15461 return err
15462 }
15463
15464 encoder.PutUint32(uint32(self.Subtype))
15465
15466 return nil
15467}
15468
15469func DecodeInstructionIdBsn(parent *InstructionIdExperimenter, decoder *goloxi.Decoder) (IInstructionIdBsn, error) {
15470 _instructionidbsn := &InstructionIdBsn{InstructionIdExperimenter: parent}
15471 if decoder.Length() < 4 {
15472 return nil, fmt.Errorf("InstructionIdBsn packet too short: %d < 4", decoder.Length())
15473 }
15474 _instructionidbsn.Subtype = uint32(decoder.ReadUint32())
15475
15476 switch _instructionidbsn.Subtype {
15477 case 0:
15478 return DecodeInstructionIdBsnDisableSrcMacCheck(_instructionidbsn, decoder)
15479 case 1:
15480 return DecodeInstructionIdBsnArpOffload(_instructionidbsn, decoder)
15481 case 2:
15482 return DecodeInstructionIdBsnDhcpOffload(_instructionidbsn, decoder)
15483 case 4:
15484 return DecodeInstructionIdBsnPermit(_instructionidbsn, decoder)
15485 case 5:
15486 return DecodeInstructionIdBsnDeny(_instructionidbsn, decoder)
15487 case 6:
15488 return DecodeInstructionIdBsnPacketOfDeath(_instructionidbsn, decoder)
15489 case 7:
15490 return DecodeInstructionIdBsnPrioritizePdus(_instructionidbsn, decoder)
15491 case 8:
15492 return DecodeInstructionIdBsnRequireVlanXlate(_instructionidbsn, decoder)
15493 case 9:
15494 return DecodeInstructionIdBsnDisableVlanCounters(_instructionidbsn, decoder)
15495 case 10:
15496 return DecodeInstructionIdBsnSpanDestination(_instructionidbsn, decoder)
15497 case 11:
15498 return DecodeInstructionIdBsnAutoNegotiation(_instructionidbsn, decoder)
15499 case 12:
15500 return DecodeInstructionIdBsnInternalPriority(_instructionidbsn, decoder)
15501 case 13:
15502 return DecodeInstructionIdBsnDisableL3(_instructionidbsn, decoder)
15503 case 14:
15504 return DecodeInstructionIdBsnNdpOffload(_instructionidbsn, decoder)
15505 case 15:
15506 return DecodeInstructionIdBsnHashSelect(_instructionidbsn, decoder)
15507 case 16:
15508 return DecodeInstructionIdBsnDirectedBroadcast(_instructionidbsn, decoder)
15509 default:
15510 return nil, fmt.Errorf("Invalid type '%d' for 'InstructionIdBsn'", _instructionidbsn.Subtype)
15511 }
15512}
15513
15514func NewInstructionIdBsn(_subtype uint32) *InstructionIdBsn {
15515 obj := &InstructionIdBsn{
15516 InstructionIdExperimenter: NewInstructionIdExperimenter(6035143),
15517 }
15518 obj.Subtype = _subtype
15519 return obj
15520}
15521
15522type InstructionIdBsnArpOffload struct {
15523 *InstructionIdBsn
15524}
15525
15526type IInstructionIdBsnArpOffload interface {
15527 IInstructionIdBsn
15528}
15529
15530func (self *InstructionIdBsnArpOffload) Serialize(encoder *goloxi.Encoder) error {
15531 startIndex := len(encoder.Bytes())
15532 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
15533 return err
15534 }
15535 length := len(encoder.Bytes()) - startIndex
15536
15537 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
15538
15539 return nil
15540}
15541
15542func DecodeInstructionIdBsnArpOffload(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnArpOffload, error) {
15543 _instructionidbsnarpoffload := &InstructionIdBsnArpOffload{InstructionIdBsn: parent}
15544 return _instructionidbsnarpoffload, nil
15545}
15546
15547func NewInstructionIdBsnArpOffload() *InstructionIdBsnArpOffload {
15548 obj := &InstructionIdBsnArpOffload{
15549 InstructionIdBsn: NewInstructionIdBsn(1),
15550 }
15551 return obj
15552}
15553
15554type InstructionIdBsnAutoNegotiation struct {
15555 *InstructionIdBsn
15556}
15557
15558type IInstructionIdBsnAutoNegotiation interface {
15559 IInstructionIdBsn
15560}
15561
15562func (self *InstructionIdBsnAutoNegotiation) Serialize(encoder *goloxi.Encoder) error {
15563 startIndex := len(encoder.Bytes())
15564 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
15565 return err
15566 }
15567 length := len(encoder.Bytes()) - startIndex
15568
15569 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
15570
15571 return nil
15572}
15573
15574func DecodeInstructionIdBsnAutoNegotiation(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnAutoNegotiation, error) {
15575 _instructionidbsnautonegotiation := &InstructionIdBsnAutoNegotiation{InstructionIdBsn: parent}
15576 return _instructionidbsnautonegotiation, nil
15577}
15578
15579func NewInstructionIdBsnAutoNegotiation() *InstructionIdBsnAutoNegotiation {
15580 obj := &InstructionIdBsnAutoNegotiation{
15581 InstructionIdBsn: NewInstructionIdBsn(11),
15582 }
15583 return obj
15584}
15585
15586type InstructionIdBsnDeny struct {
15587 *InstructionIdBsn
15588}
15589
15590type IInstructionIdBsnDeny interface {
15591 IInstructionIdBsn
15592}
15593
15594func (self *InstructionIdBsnDeny) Serialize(encoder *goloxi.Encoder) error {
15595 startIndex := len(encoder.Bytes())
15596 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
15597 return err
15598 }
15599 length := len(encoder.Bytes()) - startIndex
15600
15601 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
15602
15603 return nil
15604}
15605
15606func DecodeInstructionIdBsnDeny(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnDeny, error) {
15607 _instructionidbsndeny := &InstructionIdBsnDeny{InstructionIdBsn: parent}
15608 return _instructionidbsndeny, nil
15609}
15610
15611func NewInstructionIdBsnDeny() *InstructionIdBsnDeny {
15612 obj := &InstructionIdBsnDeny{
15613 InstructionIdBsn: NewInstructionIdBsn(5),
15614 }
15615 return obj
15616}
15617
15618type InstructionIdBsnDhcpOffload struct {
15619 *InstructionIdBsn
15620}
15621
15622type IInstructionIdBsnDhcpOffload interface {
15623 IInstructionIdBsn
15624}
15625
15626func (self *InstructionIdBsnDhcpOffload) Serialize(encoder *goloxi.Encoder) error {
15627 startIndex := len(encoder.Bytes())
15628 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
15629 return err
15630 }
15631 length := len(encoder.Bytes()) - startIndex
15632
15633 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
15634
15635 return nil
15636}
15637
15638func DecodeInstructionIdBsnDhcpOffload(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnDhcpOffload, error) {
15639 _instructionidbsndhcpoffload := &InstructionIdBsnDhcpOffload{InstructionIdBsn: parent}
15640 return _instructionidbsndhcpoffload, nil
15641}
15642
15643func NewInstructionIdBsnDhcpOffload() *InstructionIdBsnDhcpOffload {
15644 obj := &InstructionIdBsnDhcpOffload{
15645 InstructionIdBsn: NewInstructionIdBsn(2),
15646 }
15647 return obj
15648}
15649
15650type InstructionIdBsnDirectedBroadcast struct {
15651 *InstructionIdBsn
15652}
15653
15654type IInstructionIdBsnDirectedBroadcast interface {
15655 IInstructionIdBsn
15656}
15657
15658func (self *InstructionIdBsnDirectedBroadcast) Serialize(encoder *goloxi.Encoder) error {
15659 startIndex := len(encoder.Bytes())
15660 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
15661 return err
15662 }
15663 length := len(encoder.Bytes()) - startIndex
15664
15665 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
15666
15667 return nil
15668}
15669
15670func DecodeInstructionIdBsnDirectedBroadcast(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnDirectedBroadcast, error) {
15671 _instructionidbsndirectedbroadcast := &InstructionIdBsnDirectedBroadcast{InstructionIdBsn: parent}
15672 return _instructionidbsndirectedbroadcast, nil
15673}
15674
15675func NewInstructionIdBsnDirectedBroadcast() *InstructionIdBsnDirectedBroadcast {
15676 obj := &InstructionIdBsnDirectedBroadcast{
15677 InstructionIdBsn: NewInstructionIdBsn(16),
15678 }
15679 return obj
15680}
15681
15682type InstructionIdBsnDisableL3 struct {
15683 *InstructionIdBsn
15684}
15685
15686type IInstructionIdBsnDisableL3 interface {
15687 IInstructionIdBsn
15688}
15689
15690func (self *InstructionIdBsnDisableL3) Serialize(encoder *goloxi.Encoder) error {
15691 startIndex := len(encoder.Bytes())
15692 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
15693 return err
15694 }
15695 length := len(encoder.Bytes()) - startIndex
15696
15697 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
15698
15699 return nil
15700}
15701
15702func DecodeInstructionIdBsnDisableL3(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnDisableL3, error) {
15703 _instructionidbsndisablel3 := &InstructionIdBsnDisableL3{InstructionIdBsn: parent}
15704 return _instructionidbsndisablel3, nil
15705}
15706
15707func NewInstructionIdBsnDisableL3() *InstructionIdBsnDisableL3 {
15708 obj := &InstructionIdBsnDisableL3{
15709 InstructionIdBsn: NewInstructionIdBsn(13),
15710 }
15711 return obj
15712}
15713
15714type InstructionIdBsnDisableSrcMacCheck struct {
15715 *InstructionIdBsn
15716}
15717
15718type IInstructionIdBsnDisableSrcMacCheck interface {
15719 IInstructionIdBsn
15720}
15721
15722func (self *InstructionIdBsnDisableSrcMacCheck) Serialize(encoder *goloxi.Encoder) error {
15723 startIndex := len(encoder.Bytes())
15724 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
15725 return err
15726 }
15727 length := len(encoder.Bytes()) - startIndex
15728
15729 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
15730
15731 return nil
15732}
15733
15734func DecodeInstructionIdBsnDisableSrcMacCheck(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnDisableSrcMacCheck, error) {
15735 _instructionidbsndisablesrcmaccheck := &InstructionIdBsnDisableSrcMacCheck{InstructionIdBsn: parent}
15736 return _instructionidbsndisablesrcmaccheck, nil
15737}
15738
15739func NewInstructionIdBsnDisableSrcMacCheck() *InstructionIdBsnDisableSrcMacCheck {
15740 obj := &InstructionIdBsnDisableSrcMacCheck{
15741 InstructionIdBsn: NewInstructionIdBsn(0),
15742 }
15743 return obj
15744}
15745
15746type InstructionIdBsnDisableVlanCounters struct {
15747 *InstructionIdBsn
15748}
15749
15750type IInstructionIdBsnDisableVlanCounters interface {
15751 IInstructionIdBsn
15752}
15753
15754func (self *InstructionIdBsnDisableVlanCounters) Serialize(encoder *goloxi.Encoder) error {
15755 startIndex := len(encoder.Bytes())
15756 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
15757 return err
15758 }
15759 length := len(encoder.Bytes()) - startIndex
15760
15761 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
15762
15763 return nil
15764}
15765
15766func DecodeInstructionIdBsnDisableVlanCounters(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnDisableVlanCounters, error) {
15767 _instructionidbsndisablevlancounters := &InstructionIdBsnDisableVlanCounters{InstructionIdBsn: parent}
15768 return _instructionidbsndisablevlancounters, nil
15769}
15770
15771func NewInstructionIdBsnDisableVlanCounters() *InstructionIdBsnDisableVlanCounters {
15772 obj := &InstructionIdBsnDisableVlanCounters{
15773 InstructionIdBsn: NewInstructionIdBsn(9),
15774 }
15775 return obj
15776}
15777
15778type InstructionIdBsnHashSelect struct {
15779 *InstructionIdBsn
15780}
15781
15782type IInstructionIdBsnHashSelect interface {
15783 IInstructionIdBsn
15784}
15785
15786func (self *InstructionIdBsnHashSelect) Serialize(encoder *goloxi.Encoder) error {
15787 startIndex := len(encoder.Bytes())
15788 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
15789 return err
15790 }
15791 length := len(encoder.Bytes()) - startIndex
15792
15793 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
15794
15795 return nil
15796}
15797
15798func DecodeInstructionIdBsnHashSelect(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnHashSelect, error) {
15799 _instructionidbsnhashselect := &InstructionIdBsnHashSelect{InstructionIdBsn: parent}
15800 return _instructionidbsnhashselect, nil
15801}
15802
15803func NewInstructionIdBsnHashSelect() *InstructionIdBsnHashSelect {
15804 obj := &InstructionIdBsnHashSelect{
15805 InstructionIdBsn: NewInstructionIdBsn(15),
15806 }
15807 return obj
15808}
15809
15810type InstructionIdBsnInternalPriority struct {
15811 *InstructionIdBsn
15812}
15813
15814type IInstructionIdBsnInternalPriority interface {
15815 IInstructionIdBsn
15816}
15817
15818func (self *InstructionIdBsnInternalPriority) Serialize(encoder *goloxi.Encoder) error {
15819 startIndex := len(encoder.Bytes())
15820 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
15821 return err
15822 }
15823 length := len(encoder.Bytes()) - startIndex
15824
15825 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
15826
15827 return nil
15828}
15829
15830func DecodeInstructionIdBsnInternalPriority(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnInternalPriority, error) {
15831 _instructionidbsninternalpriority := &InstructionIdBsnInternalPriority{InstructionIdBsn: parent}
15832 return _instructionidbsninternalpriority, nil
15833}
15834
15835func NewInstructionIdBsnInternalPriority() *InstructionIdBsnInternalPriority {
15836 obj := &InstructionIdBsnInternalPriority{
15837 InstructionIdBsn: NewInstructionIdBsn(12),
15838 }
15839 return obj
15840}
15841
15842type InstructionIdBsnNdpOffload struct {
15843 *InstructionIdBsn
15844}
15845
15846type IInstructionIdBsnNdpOffload interface {
15847 IInstructionIdBsn
15848}
15849
15850func (self *InstructionIdBsnNdpOffload) Serialize(encoder *goloxi.Encoder) error {
15851 startIndex := len(encoder.Bytes())
15852 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
15853 return err
15854 }
15855 length := len(encoder.Bytes()) - startIndex
15856
15857 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
15858
15859 return nil
15860}
15861
15862func DecodeInstructionIdBsnNdpOffload(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnNdpOffload, error) {
15863 _instructionidbsnndpoffload := &InstructionIdBsnNdpOffload{InstructionIdBsn: parent}
15864 return _instructionidbsnndpoffload, nil
15865}
15866
15867func NewInstructionIdBsnNdpOffload() *InstructionIdBsnNdpOffload {
15868 obj := &InstructionIdBsnNdpOffload{
15869 InstructionIdBsn: NewInstructionIdBsn(14),
15870 }
15871 return obj
15872}
15873
15874type InstructionIdBsnPacketOfDeath struct {
15875 *InstructionIdBsn
15876}
15877
15878type IInstructionIdBsnPacketOfDeath interface {
15879 IInstructionIdBsn
15880}
15881
15882func (self *InstructionIdBsnPacketOfDeath) Serialize(encoder *goloxi.Encoder) error {
15883 startIndex := len(encoder.Bytes())
15884 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
15885 return err
15886 }
15887 length := len(encoder.Bytes()) - startIndex
15888
15889 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
15890
15891 return nil
15892}
15893
15894func DecodeInstructionIdBsnPacketOfDeath(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnPacketOfDeath, error) {
15895 _instructionidbsnpacketofdeath := &InstructionIdBsnPacketOfDeath{InstructionIdBsn: parent}
15896 return _instructionidbsnpacketofdeath, nil
15897}
15898
15899func NewInstructionIdBsnPacketOfDeath() *InstructionIdBsnPacketOfDeath {
15900 obj := &InstructionIdBsnPacketOfDeath{
15901 InstructionIdBsn: NewInstructionIdBsn(6),
15902 }
15903 return obj
15904}
15905
15906type InstructionIdBsnPermit struct {
15907 *InstructionIdBsn
15908}
15909
15910type IInstructionIdBsnPermit interface {
15911 IInstructionIdBsn
15912}
15913
15914func (self *InstructionIdBsnPermit) Serialize(encoder *goloxi.Encoder) error {
15915 startIndex := len(encoder.Bytes())
15916 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
15917 return err
15918 }
15919 length := len(encoder.Bytes()) - startIndex
15920
15921 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
15922
15923 return nil
15924}
15925
15926func DecodeInstructionIdBsnPermit(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnPermit, error) {
15927 _instructionidbsnpermit := &InstructionIdBsnPermit{InstructionIdBsn: parent}
15928 return _instructionidbsnpermit, nil
15929}
15930
15931func NewInstructionIdBsnPermit() *InstructionIdBsnPermit {
15932 obj := &InstructionIdBsnPermit{
15933 InstructionIdBsn: NewInstructionIdBsn(4),
15934 }
15935 return obj
15936}
15937
15938type InstructionIdBsnPrioritizePdus struct {
15939 *InstructionIdBsn
15940}
15941
15942type IInstructionIdBsnPrioritizePdus interface {
15943 IInstructionIdBsn
15944}
15945
15946func (self *InstructionIdBsnPrioritizePdus) Serialize(encoder *goloxi.Encoder) error {
15947 startIndex := len(encoder.Bytes())
15948 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
15949 return err
15950 }
15951 length := len(encoder.Bytes()) - startIndex
15952
15953 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
15954
15955 return nil
15956}
15957
15958func DecodeInstructionIdBsnPrioritizePdus(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnPrioritizePdus, error) {
15959 _instructionidbsnprioritizepdus := &InstructionIdBsnPrioritizePdus{InstructionIdBsn: parent}
15960 return _instructionidbsnprioritizepdus, nil
15961}
15962
15963func NewInstructionIdBsnPrioritizePdus() *InstructionIdBsnPrioritizePdus {
15964 obj := &InstructionIdBsnPrioritizePdus{
15965 InstructionIdBsn: NewInstructionIdBsn(7),
15966 }
15967 return obj
15968}
15969
15970type InstructionIdBsnRequireVlanXlate struct {
15971 *InstructionIdBsn
15972}
15973
15974type IInstructionIdBsnRequireVlanXlate interface {
15975 IInstructionIdBsn
15976}
15977
15978func (self *InstructionIdBsnRequireVlanXlate) Serialize(encoder *goloxi.Encoder) error {
15979 startIndex := len(encoder.Bytes())
15980 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
15981 return err
15982 }
15983 length := len(encoder.Bytes()) - startIndex
15984
15985 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
15986
15987 return nil
15988}
15989
15990func DecodeInstructionIdBsnRequireVlanXlate(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnRequireVlanXlate, error) {
15991 _instructionidbsnrequirevlanxlate := &InstructionIdBsnRequireVlanXlate{InstructionIdBsn: parent}
15992 return _instructionidbsnrequirevlanxlate, nil
15993}
15994
15995func NewInstructionIdBsnRequireVlanXlate() *InstructionIdBsnRequireVlanXlate {
15996 obj := &InstructionIdBsnRequireVlanXlate{
15997 InstructionIdBsn: NewInstructionIdBsn(8),
15998 }
15999 return obj
16000}
16001
16002type InstructionIdBsnSpanDestination struct {
16003 *InstructionIdBsn
16004}
16005
16006type IInstructionIdBsnSpanDestination interface {
16007 IInstructionIdBsn
16008}
16009
16010func (self *InstructionIdBsnSpanDestination) Serialize(encoder *goloxi.Encoder) error {
16011 startIndex := len(encoder.Bytes())
16012 if err := self.InstructionIdBsn.Serialize(encoder); err != nil {
16013 return err
16014 }
16015 length := len(encoder.Bytes()) - startIndex
16016
16017 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
16018
16019 return nil
16020}
16021
16022func DecodeInstructionIdBsnSpanDestination(parent *InstructionIdBsn, decoder *goloxi.Decoder) (*InstructionIdBsnSpanDestination, error) {
16023 _instructionidbsnspandestination := &InstructionIdBsnSpanDestination{InstructionIdBsn: parent}
16024 return _instructionidbsnspandestination, nil
16025}
16026
16027func NewInstructionIdBsnSpanDestination() *InstructionIdBsnSpanDestination {
16028 obj := &InstructionIdBsnSpanDestination{
16029 InstructionIdBsn: NewInstructionIdBsn(10),
16030 }
16031 return obj
16032}
16033
16034type InstructionIdClearActions struct {
16035 *InstructionId
16036}
16037
16038type IInstructionIdClearActions interface {
16039 IInstructionId
16040}
16041
16042func (self *InstructionIdClearActions) Serialize(encoder *goloxi.Encoder) error {
16043 startIndex := len(encoder.Bytes())
16044 if err := self.InstructionId.Serialize(encoder); err != nil {
16045 return err
16046 }
16047 length := len(encoder.Bytes()) - startIndex
16048
16049 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
16050
16051 return nil
16052}
16053
16054func DecodeInstructionIdClearActions(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdClearActions, error) {
16055 _instructionidclearactions := &InstructionIdClearActions{InstructionId: parent}
16056 return _instructionidclearactions, nil
16057}
16058
16059func NewInstructionIdClearActions() *InstructionIdClearActions {
16060 obj := &InstructionIdClearActions{
16061 InstructionId: NewInstructionId(5),
16062 }
16063 return obj
16064}
16065
16066type InstructionIdGotoTable struct {
16067 *InstructionId
16068}
16069
16070type IInstructionIdGotoTable interface {
16071 IInstructionId
16072}
16073
16074func (self *InstructionIdGotoTable) Serialize(encoder *goloxi.Encoder) error {
16075 startIndex := len(encoder.Bytes())
16076 if err := self.InstructionId.Serialize(encoder); err != nil {
16077 return err
16078 }
16079 length := len(encoder.Bytes()) - startIndex
16080
16081 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
16082
16083 return nil
16084}
16085
16086func DecodeInstructionIdGotoTable(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdGotoTable, error) {
16087 _instructionidgototable := &InstructionIdGotoTable{InstructionId: parent}
16088 return _instructionidgototable, nil
16089}
16090
16091func NewInstructionIdGotoTable() *InstructionIdGotoTable {
16092 obj := &InstructionIdGotoTable{
16093 InstructionId: NewInstructionId(1),
16094 }
16095 return obj
16096}
16097
16098type InstructionIdMeter struct {
16099 *InstructionId
16100}
16101
16102type IInstructionIdMeter interface {
16103 IInstructionId
16104}
16105
16106func (self *InstructionIdMeter) Serialize(encoder *goloxi.Encoder) error {
16107 startIndex := len(encoder.Bytes())
16108 if err := self.InstructionId.Serialize(encoder); err != nil {
16109 return err
16110 }
16111 length := len(encoder.Bytes()) - startIndex
16112
16113 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
16114
16115 return nil
16116}
16117
16118func DecodeInstructionIdMeter(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdMeter, error) {
16119 _instructionidmeter := &InstructionIdMeter{InstructionId: parent}
16120 return _instructionidmeter, nil
16121}
16122
16123func NewInstructionIdMeter() *InstructionIdMeter {
16124 obj := &InstructionIdMeter{
16125 InstructionId: NewInstructionId(6),
16126 }
16127 return obj
16128}
16129
16130type InstructionIdWriteActions struct {
16131 *InstructionId
16132}
16133
16134type IInstructionIdWriteActions interface {
16135 IInstructionId
16136}
16137
16138func (self *InstructionIdWriteActions) Serialize(encoder *goloxi.Encoder) error {
16139 startIndex := len(encoder.Bytes())
16140 if err := self.InstructionId.Serialize(encoder); err != nil {
16141 return err
16142 }
16143 length := len(encoder.Bytes()) - startIndex
16144
16145 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
16146
16147 return nil
16148}
16149
16150func DecodeInstructionIdWriteActions(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdWriteActions, error) {
16151 _instructionidwriteactions := &InstructionIdWriteActions{InstructionId: parent}
16152 return _instructionidwriteactions, nil
16153}
16154
16155func NewInstructionIdWriteActions() *InstructionIdWriteActions {
16156 obj := &InstructionIdWriteActions{
16157 InstructionId: NewInstructionId(3),
16158 }
16159 return obj
16160}
16161
16162type InstructionIdWriteMetadata struct {
16163 *InstructionId
16164}
16165
16166type IInstructionIdWriteMetadata interface {
16167 IInstructionId
16168}
16169
16170func (self *InstructionIdWriteMetadata) Serialize(encoder *goloxi.Encoder) error {
16171 startIndex := len(encoder.Bytes())
16172 if err := self.InstructionId.Serialize(encoder); err != nil {
16173 return err
16174 }
16175 length := len(encoder.Bytes()) - startIndex
16176
16177 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
16178
16179 return nil
16180}
16181
16182func DecodeInstructionIdWriteMetadata(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdWriteMetadata, error) {
16183 _instructionidwritemetadata := &InstructionIdWriteMetadata{InstructionId: parent}
16184 return _instructionidwritemetadata, nil
16185}
16186
16187func NewInstructionIdWriteMetadata() *InstructionIdWriteMetadata {
16188 obj := &InstructionIdWriteMetadata{
16189 InstructionId: NewInstructionId(2),
16190 }
16191 return obj
16192}
16193
16194type MatchV3 struct {
16195 Type uint16
16196 Length uint16
16197 OxmList []goloxi.IOxm
16198}
16199
16200type IMatchV3 interface {
16201 goloxi.Serializable
16202 GetType() uint16
16203 GetLength() uint16
16204 GetOxmList() []goloxi.IOxm
16205}
16206
16207func (self *MatchV3) GetType() uint16 {
16208 return self.Type
16209}
16210
16211func (self *MatchV3) SetType(v uint16) {
16212 self.Type = v
16213}
16214
16215func (self *MatchV3) GetLength() uint16 {
16216 return self.Length
16217}
16218
16219func (self *MatchV3) SetLength(v uint16) {
16220 self.Length = v
16221}
16222
16223func (self *MatchV3) GetOxmList() []goloxi.IOxm {
16224 return self.OxmList
16225}
16226
16227func (self *MatchV3) SetOxmList(v []goloxi.IOxm) {
16228 self.OxmList = v
16229}
16230
16231func (self *MatchV3) Serialize(encoder *goloxi.Encoder) error {
16232 startIndex := len(encoder.Bytes())
16233
16234 encoder.PutUint16(uint16(self.Type))
16235 encoder.PutUint16(uint16(self.Length))
16236 for _, obj := range self.OxmList {
16237 if err := obj.Serialize(encoder); err != nil {
16238 return err
16239 }
16240 }
16241 length := len(encoder.Bytes()) - startIndex
16242 alignedLength := ((length + 7) / 8 * 8)
16243
16244 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
16245
16246 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
16247
16248 return nil
16249}
16250func (self *MatchV3) Decode(decoder *goloxi.Decoder) error {
16251 if decoder.Length() < 4 {
16252 return fmt.Errorf("MatchV3 packet too short: %d < 4", decoder.Length())
16253 }
16254
16255 defer decoder.SkipAlign()
16256
16257 self.Type = uint16(decoder.ReadUint16())
16258 self.Length = uint16(decoder.ReadUint16())
16259 oldDecoder := decoder
16260 defer func() { decoder = oldDecoder }()
16261 decoder = decoder.SliceDecoder(int(((self.Length)+7)/8*8), 2+2)
16262
16263 for decoder.Length() >= 4 {
16264 item, err := DecodeOxm(decoder)
16265 if err != nil {
16266 return err
16267 }
16268 if item != nil {
16269 self.OxmList = append(self.OxmList, item)
16270 }
16271 }
16272
16273 return nil
16274}
16275
16276func NewMatchV3() *MatchV3 {
16277 obj := &MatchV3{}
16278 return obj
16279}
16280
16281type MeterBand struct {
16282 Type uint16
16283 Len uint16
16284}
16285
16286type IMeterBand interface {
16287 goloxi.Serializable
16288 GetType() uint16
16289 GetLen() uint16
16290}
16291
16292func (self *MeterBand) GetType() uint16 {
16293 return self.Type
16294}
16295
16296func (self *MeterBand) SetType(v uint16) {
16297 self.Type = v
16298}
16299
16300func (self *MeterBand) GetLen() uint16 {
16301 return self.Len
16302}
16303
16304func (self *MeterBand) SetLen(v uint16) {
16305 self.Len = v
16306}
16307
16308func (self *MeterBand) Serialize(encoder *goloxi.Encoder) error {
16309
16310 encoder.PutUint16(uint16(self.Type))
16311 encoder.PutUint16(uint16(self.Len))
16312
16313 return nil
16314}
16315
16316func DecodeMeterBand(decoder *goloxi.Decoder) (IMeterBand, error) {
16317 _meterband := &MeterBand{}
16318 if decoder.Length() < 4 {
16319 return nil, fmt.Errorf("MeterBand packet too short: %d < 4", decoder.Length())
16320 }
16321 _meterband.Type = uint16(decoder.ReadUint16())
16322 _meterband.Len = uint16(decoder.ReadUint16())
16323 oldDecoder := decoder
16324 defer func() { decoder = oldDecoder }()
16325 decoder = decoder.SliceDecoder(int(_meterband.Len), 2+2)
16326
16327 switch _meterband.Type {
16328 case 1:
16329 return DecodeMeterBandDrop(_meterband, decoder)
16330 case 2:
16331 return DecodeMeterBandDscpRemark(_meterband, decoder)
16332 case 65535:
16333 return DecodeMeterBandExperimenter(_meterband, decoder)
16334 default:
16335 return nil, fmt.Errorf("Invalid type '%d' for 'MeterBand'", _meterband.Type)
16336 }
16337}
16338
16339func NewMeterBand(_type uint16) *MeterBand {
16340 obj := &MeterBand{}
16341 obj.Type = _type
16342 return obj
16343}
16344
16345type MeterBandDrop struct {
16346 *MeterBand
16347 Rate uint32
16348 BurstSize uint32
16349}
16350
16351type IMeterBandDrop interface {
16352 IMeterBand
16353 GetRate() uint32
16354 GetBurstSize() uint32
16355}
16356
16357func (self *MeterBandDrop) GetRate() uint32 {
16358 return self.Rate
16359}
16360
16361func (self *MeterBandDrop) SetRate(v uint32) {
16362 self.Rate = v
16363}
16364
16365func (self *MeterBandDrop) GetBurstSize() uint32 {
16366 return self.BurstSize
16367}
16368
16369func (self *MeterBandDrop) SetBurstSize(v uint32) {
16370 self.BurstSize = v
16371}
16372
16373func (self *MeterBandDrop) Serialize(encoder *goloxi.Encoder) error {
16374 startIndex := len(encoder.Bytes())
16375 if err := self.MeterBand.Serialize(encoder); err != nil {
16376 return err
16377 }
16378
16379 encoder.PutUint32(uint32(self.Rate))
16380 encoder.PutUint32(uint32(self.BurstSize))
16381 encoder.Write(bytes.Repeat([]byte{0}, 4))
16382 length := len(encoder.Bytes()) - startIndex
16383
16384 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
16385
16386 return nil
16387}
16388
16389func DecodeMeterBandDrop(parent *MeterBand, decoder *goloxi.Decoder) (*MeterBandDrop, error) {
16390 _meterbanddrop := &MeterBandDrop{MeterBand: parent}
16391 if decoder.Length() < 12 {
16392 return nil, fmt.Errorf("MeterBandDrop packet too short: %d < 12", decoder.Length())
16393 }
16394 _meterbanddrop.Rate = uint32(decoder.ReadUint32())
16395 _meterbanddrop.BurstSize = uint32(decoder.ReadUint32())
16396 decoder.Skip(4)
16397 return _meterbanddrop, nil
16398}
16399
16400func NewMeterBandDrop() *MeterBandDrop {
16401 obj := &MeterBandDrop{
16402 MeterBand: NewMeterBand(1),
16403 }
16404 return obj
16405}
16406
16407type MeterBandDscpRemark struct {
16408 *MeterBand
16409 Rate uint32
16410 BurstSize uint32
16411 PrecLevel uint8
16412}
16413
16414type IMeterBandDscpRemark interface {
16415 IMeterBand
16416 GetRate() uint32
16417 GetBurstSize() uint32
16418 GetPrecLevel() uint8
16419}
16420
16421func (self *MeterBandDscpRemark) GetRate() uint32 {
16422 return self.Rate
16423}
16424
16425func (self *MeterBandDscpRemark) SetRate(v uint32) {
16426 self.Rate = v
16427}
16428
16429func (self *MeterBandDscpRemark) GetBurstSize() uint32 {
16430 return self.BurstSize
16431}
16432
16433func (self *MeterBandDscpRemark) SetBurstSize(v uint32) {
16434 self.BurstSize = v
16435}
16436
16437func (self *MeterBandDscpRemark) GetPrecLevel() uint8 {
16438 return self.PrecLevel
16439}
16440
16441func (self *MeterBandDscpRemark) SetPrecLevel(v uint8) {
16442 self.PrecLevel = v
16443}
16444
16445func (self *MeterBandDscpRemark) Serialize(encoder *goloxi.Encoder) error {
16446 startIndex := len(encoder.Bytes())
16447 if err := self.MeterBand.Serialize(encoder); err != nil {
16448 return err
16449 }
16450
16451 encoder.PutUint32(uint32(self.Rate))
16452 encoder.PutUint32(uint32(self.BurstSize))
16453 encoder.PutUint8(uint8(self.PrecLevel))
16454 encoder.Write(bytes.Repeat([]byte{0}, 3))
16455 length := len(encoder.Bytes()) - startIndex
16456
16457 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
16458
16459 return nil
16460}
16461
16462func DecodeMeterBandDscpRemark(parent *MeterBand, decoder *goloxi.Decoder) (*MeterBandDscpRemark, error) {
16463 _meterbanddscpremark := &MeterBandDscpRemark{MeterBand: parent}
16464 if decoder.Length() < 12 {
16465 return nil, fmt.Errorf("MeterBandDscpRemark packet too short: %d < 12", decoder.Length())
16466 }
16467 _meterbanddscpremark.Rate = uint32(decoder.ReadUint32())
16468 _meterbanddscpremark.BurstSize = uint32(decoder.ReadUint32())
16469 _meterbanddscpremark.PrecLevel = uint8(decoder.ReadByte())
16470 decoder.Skip(3)
16471 return _meterbanddscpremark, nil
16472}
16473
16474func NewMeterBandDscpRemark() *MeterBandDscpRemark {
16475 obj := &MeterBandDscpRemark{
16476 MeterBand: NewMeterBand(2),
16477 }
16478 return obj
16479}
16480
16481type MeterBandExperimenter struct {
16482 *MeterBand
16483 Rate uint32
16484 BurstSize uint32
16485 Experimenter uint32
16486}
16487
16488type IMeterBandExperimenter interface {
16489 IMeterBand
16490 GetRate() uint32
16491 GetBurstSize() uint32
16492 GetExperimenter() uint32
16493}
16494
16495func (self *MeterBandExperimenter) GetRate() uint32 {
16496 return self.Rate
16497}
16498
16499func (self *MeterBandExperimenter) SetRate(v uint32) {
16500 self.Rate = v
16501}
16502
16503func (self *MeterBandExperimenter) GetBurstSize() uint32 {
16504 return self.BurstSize
16505}
16506
16507func (self *MeterBandExperimenter) SetBurstSize(v uint32) {
16508 self.BurstSize = v
16509}
16510
16511func (self *MeterBandExperimenter) GetExperimenter() uint32 {
16512 return self.Experimenter
16513}
16514
16515func (self *MeterBandExperimenter) SetExperimenter(v uint32) {
16516 self.Experimenter = v
16517}
16518
16519func (self *MeterBandExperimenter) Serialize(encoder *goloxi.Encoder) error {
16520 startIndex := len(encoder.Bytes())
16521 if err := self.MeterBand.Serialize(encoder); err != nil {
16522 return err
16523 }
16524
16525 encoder.PutUint32(uint32(self.Rate))
16526 encoder.PutUint32(uint32(self.BurstSize))
16527 encoder.PutUint32(uint32(self.Experimenter))
16528 length := len(encoder.Bytes()) - startIndex
16529
16530 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
16531
16532 return nil
16533}
16534
16535func DecodeMeterBandExperimenter(parent *MeterBand, decoder *goloxi.Decoder) (*MeterBandExperimenter, error) {
16536 _meterbandexperimenter := &MeterBandExperimenter{MeterBand: parent}
16537 if decoder.Length() < 12 {
16538 return nil, fmt.Errorf("MeterBandExperimenter packet too short: %d < 12", decoder.Length())
16539 }
16540 _meterbandexperimenter.Rate = uint32(decoder.ReadUint32())
16541 _meterbandexperimenter.BurstSize = uint32(decoder.ReadUint32())
16542 _meterbandexperimenter.Experimenter = uint32(decoder.ReadUint32())
16543 return _meterbandexperimenter, nil
16544}
16545
16546func NewMeterBandExperimenter() *MeterBandExperimenter {
16547 obj := &MeterBandExperimenter{
16548 MeterBand: NewMeterBand(65535),
16549 }
16550 return obj
16551}
16552
16553type MeterBandStats struct {
16554 PacketBandCount uint64
16555 ByteBandCount uint64
16556}
16557
16558type IMeterBandStats interface {
16559 goloxi.Serializable
16560 GetPacketBandCount() uint64
16561 GetByteBandCount() uint64
16562}
16563
16564func (self *MeterBandStats) GetPacketBandCount() uint64 {
16565 return self.PacketBandCount
16566}
16567
16568func (self *MeterBandStats) SetPacketBandCount(v uint64) {
16569 self.PacketBandCount = v
16570}
16571
16572func (self *MeterBandStats) GetByteBandCount() uint64 {
16573 return self.ByteBandCount
16574}
16575
16576func (self *MeterBandStats) SetByteBandCount(v uint64) {
16577 self.ByteBandCount = v
16578}
16579
16580func (self *MeterBandStats) Serialize(encoder *goloxi.Encoder) error {
16581
16582 encoder.PutUint64(uint64(self.PacketBandCount))
16583 encoder.PutUint64(uint64(self.ByteBandCount))
16584
16585 return nil
16586}
16587
16588func DecodeMeterBandStats(decoder *goloxi.Decoder) (*MeterBandStats, error) {
16589 _meterbandstats := &MeterBandStats{}
16590 if decoder.Length() < 16 {
16591 return nil, fmt.Errorf("MeterBandStats packet too short: %d < 16", decoder.Length())
16592 }
16593 _meterbandstats.PacketBandCount = uint64(decoder.ReadUint64())
16594 _meterbandstats.ByteBandCount = uint64(decoder.ReadUint64())
16595 return _meterbandstats, nil
16596}
16597
16598func NewMeterBandStats() *MeterBandStats {
16599 obj := &MeterBandStats{}
16600 return obj
16601}
16602
16603type MeterConfig struct {
16604 Length uint16
16605 Flags MeterFlags
16606 MeterId uint32
16607 Entries []IMeterBand
16608}
16609
16610type IMeterConfig interface {
16611 goloxi.Serializable
16612 GetLength() uint16
16613 GetFlags() MeterFlags
16614 GetMeterId() uint32
16615 GetEntries() []IMeterBand
16616}
16617
16618func (self *MeterConfig) GetLength() uint16 {
16619 return self.Length
16620}
16621
16622func (self *MeterConfig) SetLength(v uint16) {
16623 self.Length = v
16624}
16625
16626func (self *MeterConfig) GetFlags() MeterFlags {
16627 return self.Flags
16628}
16629
16630func (self *MeterConfig) SetFlags(v MeterFlags) {
16631 self.Flags = v
16632}
16633
16634func (self *MeterConfig) GetMeterId() uint32 {
16635 return self.MeterId
16636}
16637
16638func (self *MeterConfig) SetMeterId(v uint32) {
16639 self.MeterId = v
16640}
16641
16642func (self *MeterConfig) GetEntries() []IMeterBand {
16643 return self.Entries
16644}
16645
16646func (self *MeterConfig) SetEntries(v []IMeterBand) {
16647 self.Entries = v
16648}
16649
16650func (self *MeterConfig) Serialize(encoder *goloxi.Encoder) error {
16651 startIndex := len(encoder.Bytes())
16652
16653 encoder.PutUint16(uint16(self.Length))
16654 encoder.PutUint16(uint16(self.Flags))
16655 encoder.PutUint32(uint32(self.MeterId))
16656 for _, obj := range self.Entries {
16657 if err := obj.Serialize(encoder); err != nil {
16658 return err
16659 }
16660 }
16661 length := len(encoder.Bytes()) - startIndex
16662
16663 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
16664
16665 return nil
16666}
16667
16668func DecodeMeterConfig(decoder *goloxi.Decoder) (*MeterConfig, error) {
16669 _meterconfig := &MeterConfig{}
16670 if decoder.Length() < 8 {
16671 return nil, fmt.Errorf("MeterConfig packet too short: %d < 8", decoder.Length())
16672 }
16673 _meterconfig.Length = uint16(decoder.ReadUint16())
16674 oldDecoder := decoder
16675 defer func() { decoder = oldDecoder }()
16676 decoder = decoder.SliceDecoder(int(_meterconfig.Length), 2+0)
16677 _meterconfig.Flags = MeterFlags(decoder.ReadUint16())
16678 _meterconfig.MeterId = uint32(decoder.ReadUint32())
16679
16680 for decoder.Length() >= 4 {
16681 item, err := DecodeMeterBand(decoder)
16682 if err != nil {
16683 return nil, err
16684 }
16685 if item != nil {
16686 _meterconfig.Entries = append(_meterconfig.Entries, item)
16687 }
16688 }
16689 return _meterconfig, nil
16690}
16691
16692func NewMeterConfig() *MeterConfig {
16693 obj := &MeterConfig{}
16694 return obj
16695}
16696
16697type MeterFeatures struct {
16698 MaxMeter uint32
16699 BandTypes uint32
16700 Capabilities uint32
16701 MaxBands uint8
16702 MaxColor uint8
16703}
16704
16705type IMeterFeatures interface {
16706 goloxi.Serializable
16707 GetMaxMeter() uint32
16708 GetBandTypes() uint32
16709 GetCapabilities() uint32
16710 GetMaxBands() uint8
16711 GetMaxColor() uint8
16712}
16713
16714func (self *MeterFeatures) GetMaxMeter() uint32 {
16715 return self.MaxMeter
16716}
16717
16718func (self *MeterFeatures) SetMaxMeter(v uint32) {
16719 self.MaxMeter = v
16720}
16721
16722func (self *MeterFeatures) GetBandTypes() uint32 {
16723 return self.BandTypes
16724}
16725
16726func (self *MeterFeatures) SetBandTypes(v uint32) {
16727 self.BandTypes = v
16728}
16729
16730func (self *MeterFeatures) GetCapabilities() uint32 {
16731 return self.Capabilities
16732}
16733
16734func (self *MeterFeatures) SetCapabilities(v uint32) {
16735 self.Capabilities = v
16736}
16737
16738func (self *MeterFeatures) GetMaxBands() uint8 {
16739 return self.MaxBands
16740}
16741
16742func (self *MeterFeatures) SetMaxBands(v uint8) {
16743 self.MaxBands = v
16744}
16745
16746func (self *MeterFeatures) GetMaxColor() uint8 {
16747 return self.MaxColor
16748}
16749
16750func (self *MeterFeatures) SetMaxColor(v uint8) {
16751 self.MaxColor = v
16752}
16753
16754func (self *MeterFeatures) Serialize(encoder *goloxi.Encoder) error {
16755
16756 encoder.PutUint32(uint32(self.MaxMeter))
16757 encoder.PutUint32(uint32(self.BandTypes))
16758 encoder.PutUint32(uint32(self.Capabilities))
16759 encoder.PutUint8(uint8(self.MaxBands))
16760 encoder.PutUint8(uint8(self.MaxColor))
16761 encoder.Write(bytes.Repeat([]byte{0}, 2))
16762
16763 return nil
16764}
16765func (self *MeterFeatures) Decode(decoder *goloxi.Decoder) error {
16766 if decoder.Length() < 16 {
16767 return fmt.Errorf("MeterFeatures packet too short: %d < 16", decoder.Length())
16768 }
16769
16770 self.MaxMeter = uint32(decoder.ReadUint32())
16771 self.BandTypes = uint32(decoder.ReadUint32())
16772 self.Capabilities = uint32(decoder.ReadUint32())
16773 self.MaxBands = uint8(decoder.ReadByte())
16774 self.MaxColor = uint8(decoder.ReadByte())
16775 decoder.Skip(2)
16776
16777 return nil
16778}
16779
16780func NewMeterFeatures() *MeterFeatures {
16781 obj := &MeterFeatures{}
16782 return obj
16783}
16784
16785type MeterStats struct {
16786 MeterId uint32
16787 Len uint16
16788 FlowCount uint32
16789 PacketInCount uint64
16790 ByteInCount uint64
16791 DurationSec uint32
16792 DurationNsec uint32
16793 BandStats []*MeterBandStats
16794}
16795
16796type IMeterStats interface {
16797 goloxi.Serializable
16798 GetMeterId() uint32
16799 GetLen() uint16
16800 GetFlowCount() uint32
16801 GetPacketInCount() uint64
16802 GetByteInCount() uint64
16803 GetDurationSec() uint32
16804 GetDurationNsec() uint32
16805 GetBandStats() []*MeterBandStats
16806}
16807
16808func (self *MeterStats) GetMeterId() uint32 {
16809 return self.MeterId
16810}
16811
16812func (self *MeterStats) SetMeterId(v uint32) {
16813 self.MeterId = v
16814}
16815
16816func (self *MeterStats) GetLen() uint16 {
16817 return self.Len
16818}
16819
16820func (self *MeterStats) SetLen(v uint16) {
16821 self.Len = v
16822}
16823
16824func (self *MeterStats) GetFlowCount() uint32 {
16825 return self.FlowCount
16826}
16827
16828func (self *MeterStats) SetFlowCount(v uint32) {
16829 self.FlowCount = v
16830}
16831
16832func (self *MeterStats) GetPacketInCount() uint64 {
16833 return self.PacketInCount
16834}
16835
16836func (self *MeterStats) SetPacketInCount(v uint64) {
16837 self.PacketInCount = v
16838}
16839
16840func (self *MeterStats) GetByteInCount() uint64 {
16841 return self.ByteInCount
16842}
16843
16844func (self *MeterStats) SetByteInCount(v uint64) {
16845 self.ByteInCount = v
16846}
16847
16848func (self *MeterStats) GetDurationSec() uint32 {
16849 return self.DurationSec
16850}
16851
16852func (self *MeterStats) SetDurationSec(v uint32) {
16853 self.DurationSec = v
16854}
16855
16856func (self *MeterStats) GetDurationNsec() uint32 {
16857 return self.DurationNsec
16858}
16859
16860func (self *MeterStats) SetDurationNsec(v uint32) {
16861 self.DurationNsec = v
16862}
16863
16864func (self *MeterStats) GetBandStats() []*MeterBandStats {
16865 return self.BandStats
16866}
16867
16868func (self *MeterStats) SetBandStats(v []*MeterBandStats) {
16869 self.BandStats = v
16870}
16871
16872func (self *MeterStats) Serialize(encoder *goloxi.Encoder) error {
16873 startIndex := len(encoder.Bytes())
16874
16875 encoder.PutUint32(uint32(self.MeterId))
16876 encoder.PutUint16(uint16(self.Len))
16877 encoder.Write(bytes.Repeat([]byte{0}, 6))
16878 encoder.PutUint32(uint32(self.FlowCount))
16879 encoder.PutUint64(uint64(self.PacketInCount))
16880 encoder.PutUint64(uint64(self.ByteInCount))
16881 encoder.PutUint32(uint32(self.DurationSec))
16882 encoder.PutUint32(uint32(self.DurationNsec))
16883 for _, obj := range self.BandStats {
16884 if err := obj.Serialize(encoder); err != nil {
16885 return err
16886 }
16887 }
16888 length := len(encoder.Bytes()) - startIndex
16889
16890 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+4:startIndex+6], uint16(length))
16891
16892 return nil
16893}
16894
16895func DecodeMeterStats(decoder *goloxi.Decoder) (*MeterStats, error) {
16896 _meterstats := &MeterStats{}
16897 if decoder.Length() < 40 {
16898 return nil, fmt.Errorf("MeterStats packet too short: %d < 40", decoder.Length())
16899 }
16900 _meterstats.MeterId = uint32(decoder.ReadUint32())
16901 _meterstats.Len = uint16(decoder.ReadUint16())
16902 oldDecoder := decoder
16903 defer func() { decoder = oldDecoder }()
16904 decoder = decoder.SliceDecoder(int(_meterstats.Len), 2+4)
16905 decoder.Skip(6)
16906 _meterstats.FlowCount = uint32(decoder.ReadUint32())
16907 _meterstats.PacketInCount = uint64(decoder.ReadUint64())
16908 _meterstats.ByteInCount = uint64(decoder.ReadUint64())
16909 _meterstats.DurationSec = uint32(decoder.ReadUint32())
16910 _meterstats.DurationNsec = uint32(decoder.ReadUint32())
16911
16912 for decoder.Length() >= 16 {
16913 item, err := DecodeMeterBandStats(decoder)
16914 if err != nil {
16915 return nil, err
16916 }
16917 if item != nil {
16918 _meterstats.BandStats = append(_meterstats.BandStats, item)
16919 }
16920 }
16921 return _meterstats, nil
16922}
16923
16924func NewMeterStats() *MeterStats {
16925 obj := &MeterStats{}
16926 return obj
16927}
16928
16929type NiciraMatch struct {
16930 NxmEntries []goloxi.IOxm
16931}
16932
16933type INiciraMatch interface {
16934 goloxi.Serializable
16935 GetNxmEntries() []goloxi.IOxm
16936}
16937
16938func (self *NiciraMatch) GetNxmEntries() []goloxi.IOxm {
16939 return self.NxmEntries
16940}
16941
16942func (self *NiciraMatch) SetNxmEntries(v []goloxi.IOxm) {
16943 self.NxmEntries = v
16944}
16945
16946func (self *NiciraMatch) Serialize(encoder *goloxi.Encoder) error {
16947 startIndex := len(encoder.Bytes())
16948
16949 for _, obj := range self.NxmEntries {
16950 if err := obj.Serialize(encoder); err != nil {
16951 return err
16952 }
16953 }
16954 length := len(encoder.Bytes()) - startIndex
16955 alignedLength := ((length + 7) / 8 * 8)
16956
16957 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
16958
16959 return nil
16960}
16961func (self *NiciraMatch) Decode(decoder *goloxi.Decoder) error {
16962
16963 defer decoder.SkipAlign()
16964
16965 for decoder.Length() >= 4 {
16966 item, err := DecodeOxm(decoder)
16967 if err != nil {
16968 return err
16969 }
16970 if item != nil {
16971 self.NxmEntries = append(self.NxmEntries, item)
16972 }
16973 }
16974
16975 return nil
16976}
16977
16978func NewNiciraMatch() *NiciraMatch {
16979 obj := &NiciraMatch{}
16980 return obj
16981}
16982
16983type NiciraFlowStats struct {
16984 Length uint16
16985 TableId uint8
16986 DurationSec uint32
16987 DurationNsec uint32
16988 Priority uint16
16989 IdleTimeout uint16
16990 HardTimeout uint16
16991 MatchLen uint16
16992 IdleAge uint16
16993 HardAge uint16
16994 Cookie uint64
16995 PacketCount uint64
16996 ByteCount uint64
16997 Match NiciraMatch
16998 Actions []goloxi.IAction
16999}
17000
17001type INiciraFlowStats interface {
17002 goloxi.Serializable
17003 GetLength() uint16
17004 GetTableId() uint8
17005 GetDurationSec() uint32
17006 GetDurationNsec() uint32
17007 GetPriority() uint16
17008 GetIdleTimeout() uint16
17009 GetHardTimeout() uint16
17010 GetMatchLen() uint16
17011 GetIdleAge() uint16
17012 GetHardAge() uint16
17013 GetCookie() uint64
17014 GetPacketCount() uint64
17015 GetByteCount() uint64
17016 GetMatch() NiciraMatch
17017 GetActions() []goloxi.IAction
17018}
17019
17020func (self *NiciraFlowStats) GetLength() uint16 {
17021 return self.Length
17022}
17023
17024func (self *NiciraFlowStats) SetLength(v uint16) {
17025 self.Length = v
17026}
17027
17028func (self *NiciraFlowStats) GetTableId() uint8 {
17029 return self.TableId
17030}
17031
17032func (self *NiciraFlowStats) SetTableId(v uint8) {
17033 self.TableId = v
17034}
17035
17036func (self *NiciraFlowStats) GetDurationSec() uint32 {
17037 return self.DurationSec
17038}
17039
17040func (self *NiciraFlowStats) SetDurationSec(v uint32) {
17041 self.DurationSec = v
17042}
17043
17044func (self *NiciraFlowStats) GetDurationNsec() uint32 {
17045 return self.DurationNsec
17046}
17047
17048func (self *NiciraFlowStats) SetDurationNsec(v uint32) {
17049 self.DurationNsec = v
17050}
17051
17052func (self *NiciraFlowStats) GetPriority() uint16 {
17053 return self.Priority
17054}
17055
17056func (self *NiciraFlowStats) SetPriority(v uint16) {
17057 self.Priority = v
17058}
17059
17060func (self *NiciraFlowStats) GetIdleTimeout() uint16 {
17061 return self.IdleTimeout
17062}
17063
17064func (self *NiciraFlowStats) SetIdleTimeout(v uint16) {
17065 self.IdleTimeout = v
17066}
17067
17068func (self *NiciraFlowStats) GetHardTimeout() uint16 {
17069 return self.HardTimeout
17070}
17071
17072func (self *NiciraFlowStats) SetHardTimeout(v uint16) {
17073 self.HardTimeout = v
17074}
17075
17076func (self *NiciraFlowStats) GetMatchLen() uint16 {
17077 return self.MatchLen
17078}
17079
17080func (self *NiciraFlowStats) SetMatchLen(v uint16) {
17081 self.MatchLen = v
17082}
17083
17084func (self *NiciraFlowStats) GetIdleAge() uint16 {
17085 return self.IdleAge
17086}
17087
17088func (self *NiciraFlowStats) SetIdleAge(v uint16) {
17089 self.IdleAge = v
17090}
17091
17092func (self *NiciraFlowStats) GetHardAge() uint16 {
17093 return self.HardAge
17094}
17095
17096func (self *NiciraFlowStats) SetHardAge(v uint16) {
17097 self.HardAge = v
17098}
17099
17100func (self *NiciraFlowStats) GetCookie() uint64 {
17101 return self.Cookie
17102}
17103
17104func (self *NiciraFlowStats) SetCookie(v uint64) {
17105 self.Cookie = v
17106}
17107
17108func (self *NiciraFlowStats) GetPacketCount() uint64 {
17109 return self.PacketCount
17110}
17111
17112func (self *NiciraFlowStats) SetPacketCount(v uint64) {
17113 self.PacketCount = v
17114}
17115
17116func (self *NiciraFlowStats) GetByteCount() uint64 {
17117 return self.ByteCount
17118}
17119
17120func (self *NiciraFlowStats) SetByteCount(v uint64) {
17121 self.ByteCount = v
17122}
17123
17124func (self *NiciraFlowStats) GetMatch() NiciraMatch {
17125 return self.Match
17126}
17127
17128func (self *NiciraFlowStats) SetMatch(v NiciraMatch) {
17129 self.Match = v
17130}
17131
17132func (self *NiciraFlowStats) GetActions() []goloxi.IAction {
17133 return self.Actions
17134}
17135
17136func (self *NiciraFlowStats) SetActions(v []goloxi.IAction) {
17137 self.Actions = v
17138}
17139
17140func (self *NiciraFlowStats) Serialize(encoder *goloxi.Encoder) error {
17141 startIndex := len(encoder.Bytes())
17142
17143 encoder.PutUint16(uint16(self.Length))
17144 encoder.PutUint8(uint8(self.TableId))
17145 encoder.Write(bytes.Repeat([]byte{0}, 1))
17146 encoder.PutUint32(uint32(self.DurationSec))
17147 encoder.PutUint32(uint32(self.DurationNsec))
17148 encoder.PutUint16(uint16(self.Priority))
17149 encoder.PutUint16(uint16(self.IdleTimeout))
17150 encoder.PutUint16(uint16(self.HardTimeout))
17151 encoder.PutUint16(uint16(self.MatchLen))
17152 encoder.PutUint16(uint16(self.IdleAge))
17153 encoder.PutUint16(uint16(self.HardAge))
17154 encoder.PutUint64(uint64(self.Cookie))
17155 encoder.PutUint64(uint64(self.PacketCount))
17156 encoder.PutUint64(uint64(self.ByteCount))
17157 if err := self.Match.Serialize(encoder); err != nil {
17158 return err
17159 }
17160
17161 for _, obj := range self.Actions {
17162 if err := obj.Serialize(encoder); err != nil {
17163 return err
17164 }
17165 }
17166 length := len(encoder.Bytes()) - startIndex
17167
17168 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
17169
17170 return nil
17171}
17172
17173func DecodeNiciraFlowStats(decoder *goloxi.Decoder) (*NiciraFlowStats, error) {
17174 _niciraflowstats := &NiciraFlowStats{}
17175 if decoder.Length() < 48 {
17176 return nil, fmt.Errorf("NiciraFlowStats packet too short: %d < 48", decoder.Length())
17177 }
17178 _niciraflowstats.Length = uint16(decoder.ReadUint16())
17179 oldDecoder := decoder
17180 defer func() { decoder = oldDecoder }()
17181 decoder = decoder.SliceDecoder(int(_niciraflowstats.Length), 2+0)
17182 _niciraflowstats.TableId = uint8(decoder.ReadByte())
17183 decoder.Skip(1)
17184 _niciraflowstats.DurationSec = uint32(decoder.ReadUint32())
17185 _niciraflowstats.DurationNsec = uint32(decoder.ReadUint32())
17186 _niciraflowstats.Priority = uint16(decoder.ReadUint16())
17187 _niciraflowstats.IdleTimeout = uint16(decoder.ReadUint16())
17188 _niciraflowstats.HardTimeout = uint16(decoder.ReadUint16())
17189 _niciraflowstats.MatchLen = uint16(decoder.ReadUint16())
17190 _niciraflowstats.IdleAge = uint16(decoder.ReadUint16())
17191 _niciraflowstats.HardAge = uint16(decoder.ReadUint16())
17192 _niciraflowstats.Cookie = uint64(decoder.ReadUint64())
17193 _niciraflowstats.PacketCount = uint64(decoder.ReadUint64())
17194 _niciraflowstats.ByteCount = uint64(decoder.ReadUint64())
17195 if err := _niciraflowstats.Match.Decode(decoder.SliceDecoder(int(_niciraflowstats.MatchLen), 0)); err != nil {
17196 return nil, err
17197 }
17198
17199 decoder.SkipAlign()
17200
17201 for decoder.Length() >= 8 {
17202 item, err := DecodeAction(decoder)
17203 if err != nil {
17204 return nil, err
17205 }
17206 if item != nil {
17207 _niciraflowstats.Actions = append(_niciraflowstats.Actions, item)
17208 }
17209 }
17210 return _niciraflowstats, nil
17211}
17212
17213func NewNiciraFlowStats() *NiciraFlowStats {
17214 obj := &NiciraFlowStats{}
17215 return obj
17216}
17217
17218type NiciraFlowUpdateEvent struct {
17219 Length uint16
17220 Event uint16
17221}
17222
17223type INiciraFlowUpdateEvent interface {
17224 goloxi.Serializable
17225 GetLength() uint16
17226 GetEvent() uint16
17227}
17228
17229func (self *NiciraFlowUpdateEvent) GetLength() uint16 {
17230 return self.Length
17231}
17232
17233func (self *NiciraFlowUpdateEvent) SetLength(v uint16) {
17234 self.Length = v
17235}
17236
17237func (self *NiciraFlowUpdateEvent) GetEvent() uint16 {
17238 return self.Event
17239}
17240
17241func (self *NiciraFlowUpdateEvent) SetEvent(v uint16) {
17242 self.Event = v
17243}
17244
17245func (self *NiciraFlowUpdateEvent) Serialize(encoder *goloxi.Encoder) error {
17246
17247 encoder.PutUint16(uint16(self.Length))
17248 encoder.PutUint16(uint16(self.Event))
17249
17250 return nil
17251}
17252
17253func DecodeNiciraFlowUpdateEvent(decoder *goloxi.Decoder) (INiciraFlowUpdateEvent, error) {
17254 _niciraflowupdateevent := &NiciraFlowUpdateEvent{}
17255 if decoder.Length() < 4 {
17256 return nil, fmt.Errorf("NiciraFlowUpdateEvent packet too short: %d < 4", decoder.Length())
17257 }
17258 _niciraflowupdateevent.Length = uint16(decoder.ReadUint16())
17259 oldDecoder := decoder
17260 defer func() { decoder = oldDecoder }()
17261 decoder = decoder.SliceDecoder(int(_niciraflowupdateevent.Length), 2+0)
17262 _niciraflowupdateevent.Event = uint16(decoder.ReadUint16())
17263
17264 switch _niciraflowupdateevent.Event {
17265 case 0:
17266 return DecodeNiciraFlowUpdateFullAdd(_niciraflowupdateevent, decoder)
17267 case 1:
17268 return DecodeNiciraFlowUpdateFullDeleted(_niciraflowupdateevent, decoder)
17269 case 2:
17270 return DecodeNiciraFlowUpdateFullModified(_niciraflowupdateevent, decoder)
17271 default:
17272 return nil, fmt.Errorf("Invalid type '%d' for 'NiciraFlowUpdateEvent'", _niciraflowupdateevent.Event)
17273 }
17274}
17275
17276func NewNiciraFlowUpdateEvent(_event uint16) *NiciraFlowUpdateEvent {
17277 obj := &NiciraFlowUpdateEvent{}
17278 obj.Event = _event
17279 return obj
17280}
17281
17282type NiciraFlowUpdateFullAdd struct {
17283 *NiciraFlowUpdateEvent
17284 Reason uint16
17285 Priority uint16
17286 IdleTimeout uint16
17287 HardTimeout uint16
17288 MatchLen uint16
17289 TableId uint8
17290 Cookie uint64
17291 Match NiciraMatch
17292 Actions []goloxi.IAction
17293}
17294
17295type INiciraFlowUpdateFullAdd interface {
17296 INiciraFlowUpdateEvent
17297 GetReason() uint16
17298 GetPriority() uint16
17299 GetIdleTimeout() uint16
17300 GetHardTimeout() uint16
17301 GetMatchLen() uint16
17302 GetTableId() uint8
17303 GetCookie() uint64
17304 GetMatch() NiciraMatch
17305 GetActions() []goloxi.IAction
17306}
17307
17308func (self *NiciraFlowUpdateFullAdd) GetReason() uint16 {
17309 return self.Reason
17310}
17311
17312func (self *NiciraFlowUpdateFullAdd) SetReason(v uint16) {
17313 self.Reason = v
17314}
17315
17316func (self *NiciraFlowUpdateFullAdd) GetPriority() uint16 {
17317 return self.Priority
17318}
17319
17320func (self *NiciraFlowUpdateFullAdd) SetPriority(v uint16) {
17321 self.Priority = v
17322}
17323
17324func (self *NiciraFlowUpdateFullAdd) GetIdleTimeout() uint16 {
17325 return self.IdleTimeout
17326}
17327
17328func (self *NiciraFlowUpdateFullAdd) SetIdleTimeout(v uint16) {
17329 self.IdleTimeout = v
17330}
17331
17332func (self *NiciraFlowUpdateFullAdd) GetHardTimeout() uint16 {
17333 return self.HardTimeout
17334}
17335
17336func (self *NiciraFlowUpdateFullAdd) SetHardTimeout(v uint16) {
17337 self.HardTimeout = v
17338}
17339
17340func (self *NiciraFlowUpdateFullAdd) GetMatchLen() uint16 {
17341 return self.MatchLen
17342}
17343
17344func (self *NiciraFlowUpdateFullAdd) SetMatchLen(v uint16) {
17345 self.MatchLen = v
17346}
17347
17348func (self *NiciraFlowUpdateFullAdd) GetTableId() uint8 {
17349 return self.TableId
17350}
17351
17352func (self *NiciraFlowUpdateFullAdd) SetTableId(v uint8) {
17353 self.TableId = v
17354}
17355
17356func (self *NiciraFlowUpdateFullAdd) GetCookie() uint64 {
17357 return self.Cookie
17358}
17359
17360func (self *NiciraFlowUpdateFullAdd) SetCookie(v uint64) {
17361 self.Cookie = v
17362}
17363
17364func (self *NiciraFlowUpdateFullAdd) GetMatch() NiciraMatch {
17365 return self.Match
17366}
17367
17368func (self *NiciraFlowUpdateFullAdd) SetMatch(v NiciraMatch) {
17369 self.Match = v
17370}
17371
17372func (self *NiciraFlowUpdateFullAdd) GetActions() []goloxi.IAction {
17373 return self.Actions
17374}
17375
17376func (self *NiciraFlowUpdateFullAdd) SetActions(v []goloxi.IAction) {
17377 self.Actions = v
17378}
17379
17380func (self *NiciraFlowUpdateFullAdd) Serialize(encoder *goloxi.Encoder) error {
17381 startIndex := len(encoder.Bytes())
17382 if err := self.NiciraFlowUpdateEvent.Serialize(encoder); err != nil {
17383 return err
17384 }
17385
17386 encoder.PutUint16(uint16(self.Reason))
17387 encoder.PutUint16(uint16(self.Priority))
17388 encoder.PutUint16(uint16(self.IdleTimeout))
17389 encoder.PutUint16(uint16(self.HardTimeout))
17390 encoder.PutUint16(uint16(self.MatchLen))
17391 encoder.PutUint8(uint8(self.TableId))
17392 encoder.Write(bytes.Repeat([]byte{0}, 1))
17393 encoder.PutUint64(uint64(self.Cookie))
17394 if err := self.Match.Serialize(encoder); err != nil {
17395 return err
17396 }
17397
17398 for _, obj := range self.Actions {
17399 if err := obj.Serialize(encoder); err != nil {
17400 return err
17401 }
17402 }
17403 length := len(encoder.Bytes()) - startIndex
17404
17405 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
17406
17407 return nil
17408}
17409
17410func DecodeNiciraFlowUpdateFullAdd(parent *NiciraFlowUpdateEvent, decoder *goloxi.Decoder) (*NiciraFlowUpdateFullAdd, error) {
17411 _niciraflowupdatefulladd := &NiciraFlowUpdateFullAdd{NiciraFlowUpdateEvent: parent}
17412 if decoder.Length() < 20 {
17413 return nil, fmt.Errorf("NiciraFlowUpdateFullAdd packet too short: %d < 20", decoder.Length())
17414 }
17415 _niciraflowupdatefulladd.Reason = uint16(decoder.ReadUint16())
17416 _niciraflowupdatefulladd.Priority = uint16(decoder.ReadUint16())
17417 _niciraflowupdatefulladd.IdleTimeout = uint16(decoder.ReadUint16())
17418 _niciraflowupdatefulladd.HardTimeout = uint16(decoder.ReadUint16())
17419 _niciraflowupdatefulladd.MatchLen = uint16(decoder.ReadUint16())
17420 _niciraflowupdatefulladd.TableId = uint8(decoder.ReadByte())
17421 decoder.Skip(1)
17422 _niciraflowupdatefulladd.Cookie = uint64(decoder.ReadUint64())
17423 if err := _niciraflowupdatefulladd.Match.Decode(decoder.SliceDecoder(int(_niciraflowupdatefulladd.MatchLen), 0)); err != nil {
17424 return nil, err
17425 }
17426
17427 decoder.SkipAlign()
17428
17429 for decoder.Length() >= 8 {
17430 item, err := DecodeAction(decoder)
17431 if err != nil {
17432 return nil, err
17433 }
17434 if item != nil {
17435 _niciraflowupdatefulladd.Actions = append(_niciraflowupdatefulladd.Actions, item)
17436 }
17437 }
17438 return _niciraflowupdatefulladd, nil
17439}
17440
17441func NewNiciraFlowUpdateFullAdd() *NiciraFlowUpdateFullAdd {
17442 obj := &NiciraFlowUpdateFullAdd{
17443 NiciraFlowUpdateEvent: NewNiciraFlowUpdateEvent(0),
17444 }
17445 return obj
17446}
17447
17448type NiciraFlowUpdateFullDeleted struct {
17449 *NiciraFlowUpdateEvent
17450 Reason uint16
17451 Priority uint16
17452 IdleTimeout uint16
17453 HardTimeout uint16
17454 MatchLen uint16
17455 TableId uint8
17456 Cookie uint64
17457 Match NiciraMatch
17458 Actions []goloxi.IAction
17459}
17460
17461type INiciraFlowUpdateFullDeleted interface {
17462 INiciraFlowUpdateEvent
17463 GetReason() uint16
17464 GetPriority() uint16
17465 GetIdleTimeout() uint16
17466 GetHardTimeout() uint16
17467 GetMatchLen() uint16
17468 GetTableId() uint8
17469 GetCookie() uint64
17470 GetMatch() NiciraMatch
17471 GetActions() []goloxi.IAction
17472}
17473
17474func (self *NiciraFlowUpdateFullDeleted) GetReason() uint16 {
17475 return self.Reason
17476}
17477
17478func (self *NiciraFlowUpdateFullDeleted) SetReason(v uint16) {
17479 self.Reason = v
17480}
17481
17482func (self *NiciraFlowUpdateFullDeleted) GetPriority() uint16 {
17483 return self.Priority
17484}
17485
17486func (self *NiciraFlowUpdateFullDeleted) SetPriority(v uint16) {
17487 self.Priority = v
17488}
17489
17490func (self *NiciraFlowUpdateFullDeleted) GetIdleTimeout() uint16 {
17491 return self.IdleTimeout
17492}
17493
17494func (self *NiciraFlowUpdateFullDeleted) SetIdleTimeout(v uint16) {
17495 self.IdleTimeout = v
17496}
17497
17498func (self *NiciraFlowUpdateFullDeleted) GetHardTimeout() uint16 {
17499 return self.HardTimeout
17500}
17501
17502func (self *NiciraFlowUpdateFullDeleted) SetHardTimeout(v uint16) {
17503 self.HardTimeout = v
17504}
17505
17506func (self *NiciraFlowUpdateFullDeleted) GetMatchLen() uint16 {
17507 return self.MatchLen
17508}
17509
17510func (self *NiciraFlowUpdateFullDeleted) SetMatchLen(v uint16) {
17511 self.MatchLen = v
17512}
17513
17514func (self *NiciraFlowUpdateFullDeleted) GetTableId() uint8 {
17515 return self.TableId
17516}
17517
17518func (self *NiciraFlowUpdateFullDeleted) SetTableId(v uint8) {
17519 self.TableId = v
17520}
17521
17522func (self *NiciraFlowUpdateFullDeleted) GetCookie() uint64 {
17523 return self.Cookie
17524}
17525
17526func (self *NiciraFlowUpdateFullDeleted) SetCookie(v uint64) {
17527 self.Cookie = v
17528}
17529
17530func (self *NiciraFlowUpdateFullDeleted) GetMatch() NiciraMatch {
17531 return self.Match
17532}
17533
17534func (self *NiciraFlowUpdateFullDeleted) SetMatch(v NiciraMatch) {
17535 self.Match = v
17536}
17537
17538func (self *NiciraFlowUpdateFullDeleted) GetActions() []goloxi.IAction {
17539 return self.Actions
17540}
17541
17542func (self *NiciraFlowUpdateFullDeleted) SetActions(v []goloxi.IAction) {
17543 self.Actions = v
17544}
17545
17546func (self *NiciraFlowUpdateFullDeleted) Serialize(encoder *goloxi.Encoder) error {
17547 startIndex := len(encoder.Bytes())
17548 if err := self.NiciraFlowUpdateEvent.Serialize(encoder); err != nil {
17549 return err
17550 }
17551
17552 encoder.PutUint16(uint16(self.Reason))
17553 encoder.PutUint16(uint16(self.Priority))
17554 encoder.PutUint16(uint16(self.IdleTimeout))
17555 encoder.PutUint16(uint16(self.HardTimeout))
17556 encoder.PutUint16(uint16(self.MatchLen))
17557 encoder.PutUint8(uint8(self.TableId))
17558 encoder.Write(bytes.Repeat([]byte{0}, 1))
17559 encoder.PutUint64(uint64(self.Cookie))
17560 if err := self.Match.Serialize(encoder); err != nil {
17561 return err
17562 }
17563
17564 for _, obj := range self.Actions {
17565 if err := obj.Serialize(encoder); err != nil {
17566 return err
17567 }
17568 }
17569 length := len(encoder.Bytes()) - startIndex
17570
17571 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
17572
17573 return nil
17574}
17575
17576func DecodeNiciraFlowUpdateFullDeleted(parent *NiciraFlowUpdateEvent, decoder *goloxi.Decoder) (*NiciraFlowUpdateFullDeleted, error) {
17577 _niciraflowupdatefulldeleted := &NiciraFlowUpdateFullDeleted{NiciraFlowUpdateEvent: parent}
17578 if decoder.Length() < 20 {
17579 return nil, fmt.Errorf("NiciraFlowUpdateFullDeleted packet too short: %d < 20", decoder.Length())
17580 }
17581 _niciraflowupdatefulldeleted.Reason = uint16(decoder.ReadUint16())
17582 _niciraflowupdatefulldeleted.Priority = uint16(decoder.ReadUint16())
17583 _niciraflowupdatefulldeleted.IdleTimeout = uint16(decoder.ReadUint16())
17584 _niciraflowupdatefulldeleted.HardTimeout = uint16(decoder.ReadUint16())
17585 _niciraflowupdatefulldeleted.MatchLen = uint16(decoder.ReadUint16())
17586 _niciraflowupdatefulldeleted.TableId = uint8(decoder.ReadByte())
17587 decoder.Skip(1)
17588 _niciraflowupdatefulldeleted.Cookie = uint64(decoder.ReadUint64())
17589 if err := _niciraflowupdatefulldeleted.Match.Decode(decoder.SliceDecoder(int(_niciraflowupdatefulldeleted.MatchLen), 0)); err != nil {
17590 return nil, err
17591 }
17592
17593 decoder.SkipAlign()
17594
17595 for decoder.Length() >= 8 {
17596 item, err := DecodeAction(decoder)
17597 if err != nil {
17598 return nil, err
17599 }
17600 if item != nil {
17601 _niciraflowupdatefulldeleted.Actions = append(_niciraflowupdatefulldeleted.Actions, item)
17602 }
17603 }
17604 return _niciraflowupdatefulldeleted, nil
17605}
17606
17607func NewNiciraFlowUpdateFullDeleted() *NiciraFlowUpdateFullDeleted {
17608 obj := &NiciraFlowUpdateFullDeleted{
17609 NiciraFlowUpdateEvent: NewNiciraFlowUpdateEvent(1),
17610 }
17611 return obj
17612}
17613
17614type NiciraFlowUpdateFullModified struct {
17615 *NiciraFlowUpdateEvent
17616 Reason uint16
17617 Priority uint16
17618 IdleTimeout uint16
17619 HardTimeout uint16
17620 MatchLen uint16
17621 TableId uint8
17622 Cookie uint64
17623 Match NiciraMatch
17624 Actions []goloxi.IAction
17625}
17626
17627type INiciraFlowUpdateFullModified interface {
17628 INiciraFlowUpdateEvent
17629 GetReason() uint16
17630 GetPriority() uint16
17631 GetIdleTimeout() uint16
17632 GetHardTimeout() uint16
17633 GetMatchLen() uint16
17634 GetTableId() uint8
17635 GetCookie() uint64
17636 GetMatch() NiciraMatch
17637 GetActions() []goloxi.IAction
17638}
17639
17640func (self *NiciraFlowUpdateFullModified) GetReason() uint16 {
17641 return self.Reason
17642}
17643
17644func (self *NiciraFlowUpdateFullModified) SetReason(v uint16) {
17645 self.Reason = v
17646}
17647
17648func (self *NiciraFlowUpdateFullModified) GetPriority() uint16 {
17649 return self.Priority
17650}
17651
17652func (self *NiciraFlowUpdateFullModified) SetPriority(v uint16) {
17653 self.Priority = v
17654}
17655
17656func (self *NiciraFlowUpdateFullModified) GetIdleTimeout() uint16 {
17657 return self.IdleTimeout
17658}
17659
17660func (self *NiciraFlowUpdateFullModified) SetIdleTimeout(v uint16) {
17661 self.IdleTimeout = v
17662}
17663
17664func (self *NiciraFlowUpdateFullModified) GetHardTimeout() uint16 {
17665 return self.HardTimeout
17666}
17667
17668func (self *NiciraFlowUpdateFullModified) SetHardTimeout(v uint16) {
17669 self.HardTimeout = v
17670}
17671
17672func (self *NiciraFlowUpdateFullModified) GetMatchLen() uint16 {
17673 return self.MatchLen
17674}
17675
17676func (self *NiciraFlowUpdateFullModified) SetMatchLen(v uint16) {
17677 self.MatchLen = v
17678}
17679
17680func (self *NiciraFlowUpdateFullModified) GetTableId() uint8 {
17681 return self.TableId
17682}
17683
17684func (self *NiciraFlowUpdateFullModified) SetTableId(v uint8) {
17685 self.TableId = v
17686}
17687
17688func (self *NiciraFlowUpdateFullModified) GetCookie() uint64 {
17689 return self.Cookie
17690}
17691
17692func (self *NiciraFlowUpdateFullModified) SetCookie(v uint64) {
17693 self.Cookie = v
17694}
17695
17696func (self *NiciraFlowUpdateFullModified) GetMatch() NiciraMatch {
17697 return self.Match
17698}
17699
17700func (self *NiciraFlowUpdateFullModified) SetMatch(v NiciraMatch) {
17701 self.Match = v
17702}
17703
17704func (self *NiciraFlowUpdateFullModified) GetActions() []goloxi.IAction {
17705 return self.Actions
17706}
17707
17708func (self *NiciraFlowUpdateFullModified) SetActions(v []goloxi.IAction) {
17709 self.Actions = v
17710}
17711
17712func (self *NiciraFlowUpdateFullModified) Serialize(encoder *goloxi.Encoder) error {
17713 startIndex := len(encoder.Bytes())
17714 if err := self.NiciraFlowUpdateEvent.Serialize(encoder); err != nil {
17715 return err
17716 }
17717
17718 encoder.PutUint16(uint16(self.Reason))
17719 encoder.PutUint16(uint16(self.Priority))
17720 encoder.PutUint16(uint16(self.IdleTimeout))
17721 encoder.PutUint16(uint16(self.HardTimeout))
17722 encoder.PutUint16(uint16(self.MatchLen))
17723 encoder.PutUint8(uint8(self.TableId))
17724 encoder.Write(bytes.Repeat([]byte{0}, 1))
17725 encoder.PutUint64(uint64(self.Cookie))
17726 if err := self.Match.Serialize(encoder); err != nil {
17727 return err
17728 }
17729
17730 for _, obj := range self.Actions {
17731 if err := obj.Serialize(encoder); err != nil {
17732 return err
17733 }
17734 }
17735 length := len(encoder.Bytes()) - startIndex
17736
17737 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
17738
17739 return nil
17740}
17741
17742func DecodeNiciraFlowUpdateFullModified(parent *NiciraFlowUpdateEvent, decoder *goloxi.Decoder) (*NiciraFlowUpdateFullModified, error) {
17743 _niciraflowupdatefullmodified := &NiciraFlowUpdateFullModified{NiciraFlowUpdateEvent: parent}
17744 if decoder.Length() < 20 {
17745 return nil, fmt.Errorf("NiciraFlowUpdateFullModified packet too short: %d < 20", decoder.Length())
17746 }
17747 _niciraflowupdatefullmodified.Reason = uint16(decoder.ReadUint16())
17748 _niciraflowupdatefullmodified.Priority = uint16(decoder.ReadUint16())
17749 _niciraflowupdatefullmodified.IdleTimeout = uint16(decoder.ReadUint16())
17750 _niciraflowupdatefullmodified.HardTimeout = uint16(decoder.ReadUint16())
17751 _niciraflowupdatefullmodified.MatchLen = uint16(decoder.ReadUint16())
17752 _niciraflowupdatefullmodified.TableId = uint8(decoder.ReadByte())
17753 decoder.Skip(1)
17754 _niciraflowupdatefullmodified.Cookie = uint64(decoder.ReadUint64())
17755 if err := _niciraflowupdatefullmodified.Match.Decode(decoder.SliceDecoder(int(_niciraflowupdatefullmodified.MatchLen), 0)); err != nil {
17756 return nil, err
17757 }
17758
17759 decoder.SkipAlign()
17760
17761 for decoder.Length() >= 8 {
17762 item, err := DecodeAction(decoder)
17763 if err != nil {
17764 return nil, err
17765 }
17766 if item != nil {
17767 _niciraflowupdatefullmodified.Actions = append(_niciraflowupdatefullmodified.Actions, item)
17768 }
17769 }
17770 return _niciraflowupdatefullmodified, nil
17771}
17772
17773func NewNiciraFlowUpdateFullModified() *NiciraFlowUpdateFullModified {
17774 obj := &NiciraFlowUpdateFullModified{
17775 NiciraFlowUpdateEvent: NewNiciraFlowUpdateEvent(2),
17776 }
17777 return obj
17778}
17779
17780type OxmIdArpOp struct {
17781 *OxmId
17782}
17783
17784type IOxmIdArpOp interface {
17785 IOxmId
17786}
17787
17788func (self *OxmIdArpOp) Serialize(encoder *goloxi.Encoder) error {
17789 if err := self.OxmId.Serialize(encoder); err != nil {
17790 return err
17791 }
17792
17793 return nil
17794}
17795
17796func DecodeOxmIdArpOp(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpOp, error) {
17797 _oxmidarpop := &OxmIdArpOp{OxmId: parent}
17798 return _oxmidarpop, nil
17799}
17800
17801func NewOxmIdArpOp() *OxmIdArpOp {
17802 obj := &OxmIdArpOp{
17803 OxmId: NewOxmId(7682),
17804 }
17805 return obj
17806}
17807func (self *OxmIdArpOp) GetOXMName() string {
17808 return "arp_op"
17809}
17810
17811func (self *OxmIdArpOp) MarshalJSON() ([]byte, error) {
17812 if self.TypeLen == 0 {
17813 return []byte("\"\""), nil
17814 } else {
17815 return []byte("\"" + self.GetOXMName() + "\""), nil
17816 }
17817}
17818
17819type OxmIdArpSha struct {
17820 *OxmId
17821}
17822
17823type IOxmIdArpSha interface {
17824 IOxmId
17825}
17826
17827func (self *OxmIdArpSha) Serialize(encoder *goloxi.Encoder) error {
17828 if err := self.OxmId.Serialize(encoder); err != nil {
17829 return err
17830 }
17831
17832 return nil
17833}
17834
17835func DecodeOxmIdArpSha(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpSha, error) {
17836 _oxmidarpsha := &OxmIdArpSha{OxmId: parent}
17837 return _oxmidarpsha, nil
17838}
17839
17840func NewOxmIdArpSha() *OxmIdArpSha {
17841 obj := &OxmIdArpSha{
17842 OxmId: NewOxmId(74246),
17843 }
17844 return obj
17845}
17846func (self *OxmIdArpSha) GetOXMName() string {
17847 return "arp_sha"
17848}
17849
17850func (self *OxmIdArpSha) MarshalJSON() ([]byte, error) {
17851 if self.TypeLen == 0 {
17852 return []byte("\"\""), nil
17853 } else {
17854 return []byte("\"" + self.GetOXMName() + "\""), nil
17855 }
17856}
17857
17858type OxmIdArpShaMasked struct {
17859 *OxmId
17860}
17861
17862type IOxmIdArpShaMasked interface {
17863 IOxmId
17864}
17865
17866func (self *OxmIdArpShaMasked) Serialize(encoder *goloxi.Encoder) error {
17867 if err := self.OxmId.Serialize(encoder); err != nil {
17868 return err
17869 }
17870
17871 return nil
17872}
17873
17874func DecodeOxmIdArpShaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpShaMasked, error) {
17875 _oxmidarpshamasked := &OxmIdArpShaMasked{OxmId: parent}
17876 return _oxmidarpshamasked, nil
17877}
17878
17879func NewOxmIdArpShaMasked() *OxmIdArpShaMasked {
17880 obj := &OxmIdArpShaMasked{
17881 OxmId: NewOxmId(74507),
17882 }
17883 return obj
17884}
17885func (self *OxmIdArpShaMasked) GetOXMName() string {
17886 return "arp_sha_masked"
17887}
17888
17889func (self *OxmIdArpShaMasked) MarshalJSON() ([]byte, error) {
17890 if self.TypeLen == 0 {
17891 return []byte("\"\""), nil
17892 } else {
17893 return []byte("\"" + self.GetOXMName() + "\""), nil
17894 }
17895}
17896
17897type OxmIdArpSpa struct {
17898 *OxmId
17899}
17900
17901type IOxmIdArpSpa interface {
17902 IOxmId
17903}
17904
17905func (self *OxmIdArpSpa) Serialize(encoder *goloxi.Encoder) error {
17906 if err := self.OxmId.Serialize(encoder); err != nil {
17907 return err
17908 }
17909
17910 return nil
17911}
17912
17913func DecodeOxmIdArpSpa(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpSpa, error) {
17914 _oxmidarpspa := &OxmIdArpSpa{OxmId: parent}
17915 return _oxmidarpspa, nil
17916}
17917
17918func NewOxmIdArpSpa() *OxmIdArpSpa {
17919 obj := &OxmIdArpSpa{
17920 OxmId: NewOxmId(8196),
17921 }
17922 return obj
17923}
17924func (self *OxmIdArpSpa) GetOXMName() string {
17925 return "arp_spa"
17926}
17927
17928func (self *OxmIdArpSpa) MarshalJSON() ([]byte, error) {
17929 if self.TypeLen == 0 {
17930 return []byte("\"\""), nil
17931 } else {
17932 return []byte("\"" + self.GetOXMName() + "\""), nil
17933 }
17934}
17935
17936type OxmIdArpSpaMasked struct {
17937 *OxmId
17938}
17939
17940type IOxmIdArpSpaMasked interface {
17941 IOxmId
17942}
17943
17944func (self *OxmIdArpSpaMasked) Serialize(encoder *goloxi.Encoder) error {
17945 if err := self.OxmId.Serialize(encoder); err != nil {
17946 return err
17947 }
17948
17949 return nil
17950}
17951
17952func DecodeOxmIdArpSpaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpSpaMasked, error) {
17953 _oxmidarpspamasked := &OxmIdArpSpaMasked{OxmId: parent}
17954 return _oxmidarpspamasked, nil
17955}
17956
17957func NewOxmIdArpSpaMasked() *OxmIdArpSpaMasked {
17958 obj := &OxmIdArpSpaMasked{
17959 OxmId: NewOxmId(8452),
17960 }
17961 return obj
17962}
17963func (self *OxmIdArpSpaMasked) GetOXMName() string {
17964 return "arp_spa_masked"
17965}
17966
17967func (self *OxmIdArpSpaMasked) MarshalJSON() ([]byte, error) {
17968 if self.TypeLen == 0 {
17969 return []byte("\"\""), nil
17970 } else {
17971 return []byte("\"" + self.GetOXMName() + "\""), nil
17972 }
17973}
17974
17975type OxmIdArpTha struct {
17976 *OxmId
17977}
17978
17979type IOxmIdArpTha interface {
17980 IOxmId
17981}
17982
17983func (self *OxmIdArpTha) Serialize(encoder *goloxi.Encoder) error {
17984 if err := self.OxmId.Serialize(encoder); err != nil {
17985 return err
17986 }
17987
17988 return nil
17989}
17990
17991func DecodeOxmIdArpTha(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpTha, error) {
17992 _oxmidarptha := &OxmIdArpTha{OxmId: parent}
17993 return _oxmidarptha, nil
17994}
17995
17996func NewOxmIdArpTha() *OxmIdArpTha {
17997 obj := &OxmIdArpTha{
17998 OxmId: NewOxmId(74758),
17999 }
18000 return obj
18001}
18002func (self *OxmIdArpTha) GetOXMName() string {
18003 return "arp_tha"
18004}
18005
18006func (self *OxmIdArpTha) MarshalJSON() ([]byte, error) {
18007 if self.TypeLen == 0 {
18008 return []byte("\"\""), nil
18009 } else {
18010 return []byte("\"" + self.GetOXMName() + "\""), nil
18011 }
18012}
18013
18014type OxmIdArpThaMasked struct {
18015 *OxmId
18016}
18017
18018type IOxmIdArpThaMasked interface {
18019 IOxmId
18020}
18021
18022func (self *OxmIdArpThaMasked) Serialize(encoder *goloxi.Encoder) error {
18023 if err := self.OxmId.Serialize(encoder); err != nil {
18024 return err
18025 }
18026
18027 return nil
18028}
18029
18030func DecodeOxmIdArpThaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpThaMasked, error) {
18031 _oxmidarpthamasked := &OxmIdArpThaMasked{OxmId: parent}
18032 return _oxmidarpthamasked, nil
18033}
18034
18035func NewOxmIdArpThaMasked() *OxmIdArpThaMasked {
18036 obj := &OxmIdArpThaMasked{
18037 OxmId: NewOxmId(75019),
18038 }
18039 return obj
18040}
18041func (self *OxmIdArpThaMasked) GetOXMName() string {
18042 return "arp_tha_masked"
18043}
18044
18045func (self *OxmIdArpThaMasked) MarshalJSON() ([]byte, error) {
18046 if self.TypeLen == 0 {
18047 return []byte("\"\""), nil
18048 } else {
18049 return []byte("\"" + self.GetOXMName() + "\""), nil
18050 }
18051}
18052
18053type OxmIdArpTpa struct {
18054 *OxmId
18055}
18056
18057type IOxmIdArpTpa interface {
18058 IOxmId
18059}
18060
18061func (self *OxmIdArpTpa) Serialize(encoder *goloxi.Encoder) error {
18062 if err := self.OxmId.Serialize(encoder); err != nil {
18063 return err
18064 }
18065
18066 return nil
18067}
18068
18069func DecodeOxmIdArpTpa(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpTpa, error) {
18070 _oxmidarptpa := &OxmIdArpTpa{OxmId: parent}
18071 return _oxmidarptpa, nil
18072}
18073
18074func NewOxmIdArpTpa() *OxmIdArpTpa {
18075 obj := &OxmIdArpTpa{
18076 OxmId: NewOxmId(8708),
18077 }
18078 return obj
18079}
18080func (self *OxmIdArpTpa) GetOXMName() string {
18081 return "arp_tpa"
18082}
18083
18084func (self *OxmIdArpTpa) MarshalJSON() ([]byte, error) {
18085 if self.TypeLen == 0 {
18086 return []byte("\"\""), nil
18087 } else {
18088 return []byte("\"" + self.GetOXMName() + "\""), nil
18089 }
18090}
18091
18092type OxmIdArpTpaMasked struct {
18093 *OxmId
18094}
18095
18096type IOxmIdArpTpaMasked interface {
18097 IOxmId
18098}
18099
18100func (self *OxmIdArpTpaMasked) Serialize(encoder *goloxi.Encoder) error {
18101 if err := self.OxmId.Serialize(encoder); err != nil {
18102 return err
18103 }
18104
18105 return nil
18106}
18107
18108func DecodeOxmIdArpTpaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpTpaMasked, error) {
18109 _oxmidarptpamasked := &OxmIdArpTpaMasked{OxmId: parent}
18110 return _oxmidarptpamasked, nil
18111}
18112
18113func NewOxmIdArpTpaMasked() *OxmIdArpTpaMasked {
18114 obj := &OxmIdArpTpaMasked{
18115 OxmId: NewOxmId(8968),
18116 }
18117 return obj
18118}
18119func (self *OxmIdArpTpaMasked) GetOXMName() string {
18120 return "arp_tpa_masked"
18121}
18122
18123func (self *OxmIdArpTpaMasked) MarshalJSON() ([]byte, error) {
18124 if self.TypeLen == 0 {
18125 return []byte("\"\""), nil
18126 } else {
18127 return []byte("\"" + self.GetOXMName() + "\""), nil
18128 }
18129}
18130
18131type OxmIdConjId struct {
18132 *OxmId
18133}
18134
18135type IOxmIdConjId interface {
18136 IOxmId
18137}
18138
18139func (self *OxmIdConjId) Serialize(encoder *goloxi.Encoder) error {
18140 if err := self.OxmId.Serialize(encoder); err != nil {
18141 return err
18142 }
18143
18144 return nil
18145}
18146
18147func DecodeOxmIdConjId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConjId, error) {
18148 _oxmidconjid := &OxmIdConjId{OxmId: parent}
18149 return _oxmidconjid, nil
18150}
18151
18152func NewOxmIdConjId() *OxmIdConjId {
18153 obj := &OxmIdConjId{
18154 OxmId: NewOxmId(84484),
18155 }
18156 return obj
18157}
18158func (self *OxmIdConjId) GetOXMName() string {
18159 return "conj_id"
18160}
18161
18162func (self *OxmIdConjId) MarshalJSON() ([]byte, error) {
18163 if self.TypeLen == 0 {
18164 return []byte("\"\""), nil
18165 } else {
18166 return []byte("\"" + self.GetOXMName() + "\""), nil
18167 }
18168}
18169
18170type OxmIdCtIpv6Dst struct {
18171 *OxmId
18172}
18173
18174type IOxmIdCtIpv6Dst interface {
18175 IOxmId
18176}
18177
18178func (self *OxmIdCtIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
18179 if err := self.OxmId.Serialize(encoder); err != nil {
18180 return err
18181 }
18182
18183 return nil
18184}
18185
18186func DecodeOxmIdCtIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6Dst, error) {
18187 _oxmidctipv6dst := &OxmIdCtIpv6Dst{OxmId: parent}
18188 return _oxmidctipv6dst, nil
18189}
18190
18191func NewOxmIdCtIpv6Dst() *OxmIdCtIpv6Dst {
18192 obj := &OxmIdCtIpv6Dst{
18193 OxmId: NewOxmId(128528),
18194 }
18195 return obj
18196}
18197func (self *OxmIdCtIpv6Dst) GetOXMName() string {
18198 return "ct_ipv6_dst"
18199}
18200
18201func (self *OxmIdCtIpv6Dst) MarshalJSON() ([]byte, error) {
18202 if self.TypeLen == 0 {
18203 return []byte("\"\""), nil
18204 } else {
18205 return []byte("\"" + self.GetOXMName() + "\""), nil
18206 }
18207}
18208
18209type OxmIdCtIpv6DstMasked struct {
18210 *OxmId
18211}
18212
18213type IOxmIdCtIpv6DstMasked interface {
18214 IOxmId
18215}
18216
18217func (self *OxmIdCtIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
18218 if err := self.OxmId.Serialize(encoder); err != nil {
18219 return err
18220 }
18221
18222 return nil
18223}
18224
18225func DecodeOxmIdCtIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6DstMasked, error) {
18226 _oxmidctipv6dstmasked := &OxmIdCtIpv6DstMasked{OxmId: parent}
18227 return _oxmidctipv6dstmasked, nil
18228}
18229
18230func NewOxmIdCtIpv6DstMasked() *OxmIdCtIpv6DstMasked {
18231 obj := &OxmIdCtIpv6DstMasked{
18232 OxmId: NewOxmId(128800),
18233 }
18234 return obj
18235}
18236func (self *OxmIdCtIpv6DstMasked) GetOXMName() string {
18237 return "ct_ipv6_dst_masked"
18238}
18239
18240func (self *OxmIdCtIpv6DstMasked) MarshalJSON() ([]byte, error) {
18241 if self.TypeLen == 0 {
18242 return []byte("\"\""), nil
18243 } else {
18244 return []byte("\"" + self.GetOXMName() + "\""), nil
18245 }
18246}
18247
18248type OxmIdCtIpv6Src struct {
18249 *OxmId
18250}
18251
18252type IOxmIdCtIpv6Src interface {
18253 IOxmId
18254}
18255
18256func (self *OxmIdCtIpv6Src) Serialize(encoder *goloxi.Encoder) error {
18257 if err := self.OxmId.Serialize(encoder); err != nil {
18258 return err
18259 }
18260
18261 return nil
18262}
18263
18264func DecodeOxmIdCtIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6Src, error) {
18265 _oxmidctipv6src := &OxmIdCtIpv6Src{OxmId: parent}
18266 return _oxmidctipv6src, nil
18267}
18268
18269func NewOxmIdCtIpv6Src() *OxmIdCtIpv6Src {
18270 obj := &OxmIdCtIpv6Src{
18271 OxmId: NewOxmId(128016),
18272 }
18273 return obj
18274}
18275func (self *OxmIdCtIpv6Src) GetOXMName() string {
18276 return "ct_ipv6_src"
18277}
18278
18279func (self *OxmIdCtIpv6Src) MarshalJSON() ([]byte, error) {
18280 if self.TypeLen == 0 {
18281 return []byte("\"\""), nil
18282 } else {
18283 return []byte("\"" + self.GetOXMName() + "\""), nil
18284 }
18285}
18286
18287type OxmIdCtIpv6SrcMasked struct {
18288 *OxmId
18289}
18290
18291type IOxmIdCtIpv6SrcMasked interface {
18292 IOxmId
18293}
18294
18295func (self *OxmIdCtIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
18296 if err := self.OxmId.Serialize(encoder); err != nil {
18297 return err
18298 }
18299
18300 return nil
18301}
18302
18303func DecodeOxmIdCtIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6SrcMasked, error) {
18304 _oxmidctipv6srcmasked := &OxmIdCtIpv6SrcMasked{OxmId: parent}
18305 return _oxmidctipv6srcmasked, nil
18306}
18307
18308func NewOxmIdCtIpv6SrcMasked() *OxmIdCtIpv6SrcMasked {
18309 obj := &OxmIdCtIpv6SrcMasked{
18310 OxmId: NewOxmId(128288),
18311 }
18312 return obj
18313}
18314func (self *OxmIdCtIpv6SrcMasked) GetOXMName() string {
18315 return "ct_ipv6_src_masked"
18316}
18317
18318func (self *OxmIdCtIpv6SrcMasked) MarshalJSON() ([]byte, error) {
18319 if self.TypeLen == 0 {
18320 return []byte("\"\""), nil
18321 } else {
18322 return []byte("\"" + self.GetOXMName() + "\""), nil
18323 }
18324}
18325
18326type OxmIdCtLabel struct {
18327 *OxmId
18328}
18329
18330type IOxmIdCtLabel interface {
18331 IOxmId
18332}
18333
18334func (self *OxmIdCtLabel) Serialize(encoder *goloxi.Encoder) error {
18335 if err := self.OxmId.Serialize(encoder); err != nil {
18336 return err
18337 }
18338
18339 return nil
18340}
18341
18342func DecodeOxmIdCtLabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtLabel, error) {
18343 _oxmidctlabel := &OxmIdCtLabel{OxmId: parent}
18344 return _oxmidctlabel, nil
18345}
18346
18347func NewOxmIdCtLabel() *OxmIdCtLabel {
18348 obj := &OxmIdCtLabel{
18349 OxmId: NewOxmId(120848),
18350 }
18351 return obj
18352}
18353func (self *OxmIdCtLabel) GetOXMName() string {
18354 return "ct_label"
18355}
18356
18357func (self *OxmIdCtLabel) MarshalJSON() ([]byte, error) {
18358 if self.TypeLen == 0 {
18359 return []byte("\"\""), nil
18360 } else {
18361 return []byte("\"" + self.GetOXMName() + "\""), nil
18362 }
18363}
18364
18365type OxmIdCtLabelMasked struct {
18366 *OxmId
18367}
18368
18369type IOxmIdCtLabelMasked interface {
18370 IOxmId
18371}
18372
18373func (self *OxmIdCtLabelMasked) Serialize(encoder *goloxi.Encoder) error {
18374 if err := self.OxmId.Serialize(encoder); err != nil {
18375 return err
18376 }
18377
18378 return nil
18379}
18380
18381func DecodeOxmIdCtLabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtLabelMasked, error) {
18382 _oxmidctlabelmasked := &OxmIdCtLabelMasked{OxmId: parent}
18383 return _oxmidctlabelmasked, nil
18384}
18385
18386func NewOxmIdCtLabelMasked() *OxmIdCtLabelMasked {
18387 obj := &OxmIdCtLabelMasked{
18388 OxmId: NewOxmId(121120),
18389 }
18390 return obj
18391}
18392func (self *OxmIdCtLabelMasked) GetOXMName() string {
18393 return "ct_label_masked"
18394}
18395
18396func (self *OxmIdCtLabelMasked) MarshalJSON() ([]byte, error) {
18397 if self.TypeLen == 0 {
18398 return []byte("\"\""), nil
18399 } else {
18400 return []byte("\"" + self.GetOXMName() + "\""), nil
18401 }
18402}
18403
18404type OxmIdCtMark struct {
18405 *OxmId
18406}
18407
18408type IOxmIdCtMark interface {
18409 IOxmId
18410}
18411
18412func (self *OxmIdCtMark) Serialize(encoder *goloxi.Encoder) error {
18413 if err := self.OxmId.Serialize(encoder); err != nil {
18414 return err
18415 }
18416
18417 return nil
18418}
18419
18420func DecodeOxmIdCtMark(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtMark, error) {
18421 _oxmidctmark := &OxmIdCtMark{OxmId: parent}
18422 return _oxmidctmark, nil
18423}
18424
18425func NewOxmIdCtMark() *OxmIdCtMark {
18426 obj := &OxmIdCtMark{
18427 OxmId: NewOxmId(120324),
18428 }
18429 return obj
18430}
18431func (self *OxmIdCtMark) GetOXMName() string {
18432 return "ct_mark"
18433}
18434
18435func (self *OxmIdCtMark) MarshalJSON() ([]byte, error) {
18436 if self.TypeLen == 0 {
18437 return []byte("\"\""), nil
18438 } else {
18439 return []byte("\"" + self.GetOXMName() + "\""), nil
18440 }
18441}
18442
18443type OxmIdCtMarkMasked struct {
18444 *OxmId
18445}
18446
18447type IOxmIdCtMarkMasked interface {
18448 IOxmId
18449}
18450
18451func (self *OxmIdCtMarkMasked) Serialize(encoder *goloxi.Encoder) error {
18452 if err := self.OxmId.Serialize(encoder); err != nil {
18453 return err
18454 }
18455
18456 return nil
18457}
18458
18459func DecodeOxmIdCtMarkMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtMarkMasked, error) {
18460 _oxmidctmarkmasked := &OxmIdCtMarkMasked{OxmId: parent}
18461 return _oxmidctmarkmasked, nil
18462}
18463
18464func NewOxmIdCtMarkMasked() *OxmIdCtMarkMasked {
18465 obj := &OxmIdCtMarkMasked{
18466 OxmId: NewOxmId(120584),
18467 }
18468 return obj
18469}
18470func (self *OxmIdCtMarkMasked) GetOXMName() string {
18471 return "ct_mark_masked"
18472}
18473
18474func (self *OxmIdCtMarkMasked) MarshalJSON() ([]byte, error) {
18475 if self.TypeLen == 0 {
18476 return []byte("\"\""), nil
18477 } else {
18478 return []byte("\"" + self.GetOXMName() + "\""), nil
18479 }
18480}
18481
18482type OxmIdCtNwDst struct {
18483 *OxmId
18484}
18485
18486type IOxmIdCtNwDst interface {
18487 IOxmId
18488}
18489
18490func (self *OxmIdCtNwDst) Serialize(encoder *goloxi.Encoder) error {
18491 if err := self.OxmId.Serialize(encoder); err != nil {
18492 return err
18493 }
18494
18495 return nil
18496}
18497
18498func DecodeOxmIdCtNwDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwDst, error) {
18499 _oxmidctnwdst := &OxmIdCtNwDst{OxmId: parent}
18500 return _oxmidctnwdst, nil
18501}
18502
18503func NewOxmIdCtNwDst() *OxmIdCtNwDst {
18504 obj := &OxmIdCtNwDst{
18505 OxmId: NewOxmId(127492),
18506 }
18507 return obj
18508}
18509func (self *OxmIdCtNwDst) GetOXMName() string {
18510 return "ct_nw_dst"
18511}
18512
18513func (self *OxmIdCtNwDst) MarshalJSON() ([]byte, error) {
18514 if self.TypeLen == 0 {
18515 return []byte("\"\""), nil
18516 } else {
18517 return []byte("\"" + self.GetOXMName() + "\""), nil
18518 }
18519}
18520
18521type OxmIdCtNwDstMasked struct {
18522 *OxmId
18523}
18524
18525type IOxmIdCtNwDstMasked interface {
18526 IOxmId
18527}
18528
18529func (self *OxmIdCtNwDstMasked) Serialize(encoder *goloxi.Encoder) error {
18530 if err := self.OxmId.Serialize(encoder); err != nil {
18531 return err
18532 }
18533
18534 return nil
18535}
18536
18537func DecodeOxmIdCtNwDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwDstMasked, error) {
18538 _oxmidctnwdstmasked := &OxmIdCtNwDstMasked{OxmId: parent}
18539 return _oxmidctnwdstmasked, nil
18540}
18541
18542func NewOxmIdCtNwDstMasked() *OxmIdCtNwDstMasked {
18543 obj := &OxmIdCtNwDstMasked{
18544 OxmId: NewOxmId(127752),
18545 }
18546 return obj
18547}
18548func (self *OxmIdCtNwDstMasked) GetOXMName() string {
18549 return "ct_nw_dst_masked"
18550}
18551
18552func (self *OxmIdCtNwDstMasked) MarshalJSON() ([]byte, error) {
18553 if self.TypeLen == 0 {
18554 return []byte("\"\""), nil
18555 } else {
18556 return []byte("\"" + self.GetOXMName() + "\""), nil
18557 }
18558}
18559
18560type OxmIdCtNwProto struct {
18561 *OxmId
18562}
18563
18564type IOxmIdCtNwProto interface {
18565 IOxmId
18566}
18567
18568func (self *OxmIdCtNwProto) Serialize(encoder *goloxi.Encoder) error {
18569 if err := self.OxmId.Serialize(encoder); err != nil {
18570 return err
18571 }
18572
18573 return nil
18574}
18575
18576func DecodeOxmIdCtNwProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwProto, error) {
18577 _oxmidctnwproto := &OxmIdCtNwProto{OxmId: parent}
18578 return _oxmidctnwproto, nil
18579}
18580
18581func NewOxmIdCtNwProto() *OxmIdCtNwProto {
18582 obj := &OxmIdCtNwProto{
18583 OxmId: NewOxmId(126465),
18584 }
18585 return obj
18586}
18587func (self *OxmIdCtNwProto) GetOXMName() string {
18588 return "ct_nw_proto"
18589}
18590
18591func (self *OxmIdCtNwProto) MarshalJSON() ([]byte, error) {
18592 if self.TypeLen == 0 {
18593 return []byte("\"\""), nil
18594 } else {
18595 return []byte("\"" + self.GetOXMName() + "\""), nil
18596 }
18597}
18598
18599type OxmIdCtNwSrc struct {
18600 *OxmId
18601}
18602
18603type IOxmIdCtNwSrc interface {
18604 IOxmId
18605}
18606
18607func (self *OxmIdCtNwSrc) Serialize(encoder *goloxi.Encoder) error {
18608 if err := self.OxmId.Serialize(encoder); err != nil {
18609 return err
18610 }
18611
18612 return nil
18613}
18614
18615func DecodeOxmIdCtNwSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwSrc, error) {
18616 _oxmidctnwsrc := &OxmIdCtNwSrc{OxmId: parent}
18617 return _oxmidctnwsrc, nil
18618}
18619
18620func NewOxmIdCtNwSrc() *OxmIdCtNwSrc {
18621 obj := &OxmIdCtNwSrc{
18622 OxmId: NewOxmId(126980),
18623 }
18624 return obj
18625}
18626func (self *OxmIdCtNwSrc) GetOXMName() string {
18627 return "ct_nw_src"
18628}
18629
18630func (self *OxmIdCtNwSrc) MarshalJSON() ([]byte, error) {
18631 if self.TypeLen == 0 {
18632 return []byte("\"\""), nil
18633 } else {
18634 return []byte("\"" + self.GetOXMName() + "\""), nil
18635 }
18636}
18637
18638type OxmIdCtNwSrcMasked struct {
18639 *OxmId
18640}
18641
18642type IOxmIdCtNwSrcMasked interface {
18643 IOxmId
18644}
18645
18646func (self *OxmIdCtNwSrcMasked) Serialize(encoder *goloxi.Encoder) error {
18647 if err := self.OxmId.Serialize(encoder); err != nil {
18648 return err
18649 }
18650
18651 return nil
18652}
18653
18654func DecodeOxmIdCtNwSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwSrcMasked, error) {
18655 _oxmidctnwsrcmasked := &OxmIdCtNwSrcMasked{OxmId: parent}
18656 return _oxmidctnwsrcmasked, nil
18657}
18658
18659func NewOxmIdCtNwSrcMasked() *OxmIdCtNwSrcMasked {
18660 obj := &OxmIdCtNwSrcMasked{
18661 OxmId: NewOxmId(127240),
18662 }
18663 return obj
18664}
18665func (self *OxmIdCtNwSrcMasked) GetOXMName() string {
18666 return "ct_nw_src_masked"
18667}
18668
18669func (self *OxmIdCtNwSrcMasked) MarshalJSON() ([]byte, error) {
18670 if self.TypeLen == 0 {
18671 return []byte("\"\""), nil
18672 } else {
18673 return []byte("\"" + self.GetOXMName() + "\""), nil
18674 }
18675}
18676
18677type OxmIdCtState struct {
18678 *OxmId
18679}
18680
18681type IOxmIdCtState interface {
18682 IOxmId
18683}
18684
18685func (self *OxmIdCtState) Serialize(encoder *goloxi.Encoder) error {
18686 if err := self.OxmId.Serialize(encoder); err != nil {
18687 return err
18688 }
18689
18690 return nil
18691}
18692
18693func DecodeOxmIdCtState(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtState, error) {
18694 _oxmidctstate := &OxmIdCtState{OxmId: parent}
18695 return _oxmidctstate, nil
18696}
18697
18698func NewOxmIdCtState() *OxmIdCtState {
18699 obj := &OxmIdCtState{
18700 OxmId: NewOxmId(119300),
18701 }
18702 return obj
18703}
18704func (self *OxmIdCtState) GetOXMName() string {
18705 return "ct_state"
18706}
18707
18708func (self *OxmIdCtState) MarshalJSON() ([]byte, error) {
18709 if self.TypeLen == 0 {
18710 return []byte("\"\""), nil
18711 } else {
18712 return []byte("\"" + self.GetOXMName() + "\""), nil
18713 }
18714}
18715
18716type OxmIdCtStateMasked struct {
18717 *OxmId
18718}
18719
18720type IOxmIdCtStateMasked interface {
18721 IOxmId
18722}
18723
18724func (self *OxmIdCtStateMasked) Serialize(encoder *goloxi.Encoder) error {
18725 if err := self.OxmId.Serialize(encoder); err != nil {
18726 return err
18727 }
18728
18729 return nil
18730}
18731
18732func DecodeOxmIdCtStateMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtStateMasked, error) {
18733 _oxmidctstatemasked := &OxmIdCtStateMasked{OxmId: parent}
18734 return _oxmidctstatemasked, nil
18735}
18736
18737func NewOxmIdCtStateMasked() *OxmIdCtStateMasked {
18738 obj := &OxmIdCtStateMasked{
18739 OxmId: NewOxmId(119560),
18740 }
18741 return obj
18742}
18743func (self *OxmIdCtStateMasked) GetOXMName() string {
18744 return "ct_state_masked"
18745}
18746
18747func (self *OxmIdCtStateMasked) MarshalJSON() ([]byte, error) {
18748 if self.TypeLen == 0 {
18749 return []byte("\"\""), nil
18750 } else {
18751 return []byte("\"" + self.GetOXMName() + "\""), nil
18752 }
18753}
18754
18755type OxmIdCtTpDst struct {
18756 *OxmId
18757}
18758
18759type IOxmIdCtTpDst interface {
18760 IOxmId
18761}
18762
18763func (self *OxmIdCtTpDst) Serialize(encoder *goloxi.Encoder) error {
18764 if err := self.OxmId.Serialize(encoder); err != nil {
18765 return err
18766 }
18767
18768 return nil
18769}
18770
18771func DecodeOxmIdCtTpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpDst, error) {
18772 _oxmidcttpdst := &OxmIdCtTpDst{OxmId: parent}
18773 return _oxmidcttpdst, nil
18774}
18775
18776func NewOxmIdCtTpDst() *OxmIdCtTpDst {
18777 obj := &OxmIdCtTpDst{
18778 OxmId: NewOxmId(129538),
18779 }
18780 return obj
18781}
18782func (self *OxmIdCtTpDst) GetOXMName() string {
18783 return "ct_tp_dst"
18784}
18785
18786func (self *OxmIdCtTpDst) MarshalJSON() ([]byte, error) {
18787 if self.TypeLen == 0 {
18788 return []byte("\"\""), nil
18789 } else {
18790 return []byte("\"" + self.GetOXMName() + "\""), nil
18791 }
18792}
18793
18794type OxmIdCtTpDstMasked struct {
18795 *OxmId
18796}
18797
18798type IOxmIdCtTpDstMasked interface {
18799 IOxmId
18800}
18801
18802func (self *OxmIdCtTpDstMasked) Serialize(encoder *goloxi.Encoder) error {
18803 if err := self.OxmId.Serialize(encoder); err != nil {
18804 return err
18805 }
18806
18807 return nil
18808}
18809
18810func DecodeOxmIdCtTpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpDstMasked, error) {
18811 _oxmidcttpdstmasked := &OxmIdCtTpDstMasked{OxmId: parent}
18812 return _oxmidcttpdstmasked, nil
18813}
18814
18815func NewOxmIdCtTpDstMasked() *OxmIdCtTpDstMasked {
18816 obj := &OxmIdCtTpDstMasked{
18817 OxmId: NewOxmId(129796),
18818 }
18819 return obj
18820}
18821func (self *OxmIdCtTpDstMasked) GetOXMName() string {
18822 return "ct_tp_dst_masked"
18823}
18824
18825func (self *OxmIdCtTpDstMasked) MarshalJSON() ([]byte, error) {
18826 if self.TypeLen == 0 {
18827 return []byte("\"\""), nil
18828 } else {
18829 return []byte("\"" + self.GetOXMName() + "\""), nil
18830 }
18831}
18832
18833type OxmIdCtTpSrc struct {
18834 *OxmId
18835}
18836
18837type IOxmIdCtTpSrc interface {
18838 IOxmId
18839}
18840
18841func (self *OxmIdCtTpSrc) Serialize(encoder *goloxi.Encoder) error {
18842 if err := self.OxmId.Serialize(encoder); err != nil {
18843 return err
18844 }
18845
18846 return nil
18847}
18848
18849func DecodeOxmIdCtTpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpSrc, error) {
18850 _oxmidcttpsrc := &OxmIdCtTpSrc{OxmId: parent}
18851 return _oxmidcttpsrc, nil
18852}
18853
18854func NewOxmIdCtTpSrc() *OxmIdCtTpSrc {
18855 obj := &OxmIdCtTpSrc{
18856 OxmId: NewOxmId(129026),
18857 }
18858 return obj
18859}
18860func (self *OxmIdCtTpSrc) GetOXMName() string {
18861 return "ct_tp_src"
18862}
18863
18864func (self *OxmIdCtTpSrc) MarshalJSON() ([]byte, error) {
18865 if self.TypeLen == 0 {
18866 return []byte("\"\""), nil
18867 } else {
18868 return []byte("\"" + self.GetOXMName() + "\""), nil
18869 }
18870}
18871
18872type OxmIdCtTpSrcMasked struct {
18873 *OxmId
18874}
18875
18876type IOxmIdCtTpSrcMasked interface {
18877 IOxmId
18878}
18879
18880func (self *OxmIdCtTpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
18881 if err := self.OxmId.Serialize(encoder); err != nil {
18882 return err
18883 }
18884
18885 return nil
18886}
18887
18888func DecodeOxmIdCtTpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpSrcMasked, error) {
18889 _oxmidcttpsrcmasked := &OxmIdCtTpSrcMasked{OxmId: parent}
18890 return _oxmidcttpsrcmasked, nil
18891}
18892
18893func NewOxmIdCtTpSrcMasked() *OxmIdCtTpSrcMasked {
18894 obj := &OxmIdCtTpSrcMasked{
18895 OxmId: NewOxmId(129284),
18896 }
18897 return obj
18898}
18899func (self *OxmIdCtTpSrcMasked) GetOXMName() string {
18900 return "ct_tp_src_masked"
18901}
18902
18903func (self *OxmIdCtTpSrcMasked) MarshalJSON() ([]byte, error) {
18904 if self.TypeLen == 0 {
18905 return []byte("\"\""), nil
18906 } else {
18907 return []byte("\"" + self.GetOXMName() + "\""), nil
18908 }
18909}
18910
18911type OxmIdCtZone struct {
18912 *OxmId
18913}
18914
18915type IOxmIdCtZone interface {
18916 IOxmId
18917}
18918
18919func (self *OxmIdCtZone) Serialize(encoder *goloxi.Encoder) error {
18920 if err := self.OxmId.Serialize(encoder); err != nil {
18921 return err
18922 }
18923
18924 return nil
18925}
18926
18927func DecodeOxmIdCtZone(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtZone, error) {
18928 _oxmidctzone := &OxmIdCtZone{OxmId: parent}
18929 return _oxmidctzone, nil
18930}
18931
18932func NewOxmIdCtZone() *OxmIdCtZone {
18933 obj := &OxmIdCtZone{
18934 OxmId: NewOxmId(119810),
18935 }
18936 return obj
18937}
18938func (self *OxmIdCtZone) GetOXMName() string {
18939 return "ct_zone"
18940}
18941
18942func (self *OxmIdCtZone) MarshalJSON() ([]byte, error) {
18943 if self.TypeLen == 0 {
18944 return []byte("\"\""), nil
18945 } else {
18946 return []byte("\"" + self.GetOXMName() + "\""), nil
18947 }
18948}
18949
18950type OxmIdDpHash struct {
18951 *OxmId
18952}
18953
18954type IOxmIdDpHash interface {
18955 IOxmId
18956}
18957
18958func (self *OxmIdDpHash) Serialize(encoder *goloxi.Encoder) error {
18959 if err := self.OxmId.Serialize(encoder); err != nil {
18960 return err
18961 }
18962
18963 return nil
18964}
18965
18966func DecodeOxmIdDpHash(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdDpHash, error) {
18967 _oxmiddphash := &OxmIdDpHash{OxmId: parent}
18968 return _oxmiddphash, nil
18969}
18970
18971func NewOxmIdDpHash() *OxmIdDpHash {
18972 obj := &OxmIdDpHash{
18973 OxmId: NewOxmId(83460),
18974 }
18975 return obj
18976}
18977func (self *OxmIdDpHash) GetOXMName() string {
18978 return "dp_hash"
18979}
18980
18981func (self *OxmIdDpHash) MarshalJSON() ([]byte, error) {
18982 if self.TypeLen == 0 {
18983 return []byte("\"\""), nil
18984 } else {
18985 return []byte("\"" + self.GetOXMName() + "\""), nil
18986 }
18987}
18988
18989type OxmIdDpHashMasked struct {
18990 *OxmId
18991}
18992
18993type IOxmIdDpHashMasked interface {
18994 IOxmId
18995}
18996
18997func (self *OxmIdDpHashMasked) Serialize(encoder *goloxi.Encoder) error {
18998 if err := self.OxmId.Serialize(encoder); err != nil {
18999 return err
19000 }
19001
19002 return nil
19003}
19004
19005func DecodeOxmIdDpHashMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdDpHashMasked, error) {
19006 _oxmiddphashmasked := &OxmIdDpHashMasked{OxmId: parent}
19007 return _oxmiddphashmasked, nil
19008}
19009
19010func NewOxmIdDpHashMasked() *OxmIdDpHashMasked {
19011 obj := &OxmIdDpHashMasked{
19012 OxmId: NewOxmId(83720),
19013 }
19014 return obj
19015}
19016func (self *OxmIdDpHashMasked) GetOXMName() string {
19017 return "dp_hash_masked"
19018}
19019
19020func (self *OxmIdDpHashMasked) MarshalJSON() ([]byte, error) {
19021 if self.TypeLen == 0 {
19022 return []byte("\"\""), nil
19023 } else {
19024 return []byte("\"" + self.GetOXMName() + "\""), nil
19025 }
19026}
19027
19028type OxmIdEthDst struct {
19029 *OxmId
19030}
19031
19032type IOxmIdEthDst interface {
19033 IOxmId
19034}
19035
19036func (self *OxmIdEthDst) Serialize(encoder *goloxi.Encoder) error {
19037 if err := self.OxmId.Serialize(encoder); err != nil {
19038 return err
19039 }
19040
19041 return nil
19042}
19043
19044func DecodeOxmIdEthDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthDst, error) {
19045 _oxmidethdst := &OxmIdEthDst{OxmId: parent}
19046 return _oxmidethdst, nil
19047}
19048
19049func NewOxmIdEthDst() *OxmIdEthDst {
19050 obj := &OxmIdEthDst{
19051 OxmId: NewOxmId(518),
19052 }
19053 return obj
19054}
19055func (self *OxmIdEthDst) GetOXMName() string {
19056 return "eth_dst"
19057}
19058
19059func (self *OxmIdEthDst) MarshalJSON() ([]byte, error) {
19060 if self.TypeLen == 0 {
19061 return []byte("\"\""), nil
19062 } else {
19063 return []byte("\"" + self.GetOXMName() + "\""), nil
19064 }
19065}
19066
19067type OxmIdEthDstMasked struct {
19068 *OxmId
19069}
19070
19071type IOxmIdEthDstMasked interface {
19072 IOxmId
19073}
19074
19075func (self *OxmIdEthDstMasked) Serialize(encoder *goloxi.Encoder) error {
19076 if err := self.OxmId.Serialize(encoder); err != nil {
19077 return err
19078 }
19079
19080 return nil
19081}
19082
19083func DecodeOxmIdEthDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthDstMasked, error) {
19084 _oxmidethdstmasked := &OxmIdEthDstMasked{OxmId: parent}
19085 return _oxmidethdstmasked, nil
19086}
19087
19088func NewOxmIdEthDstMasked() *OxmIdEthDstMasked {
19089 obj := &OxmIdEthDstMasked{
19090 OxmId: NewOxmId(779),
19091 }
19092 return obj
19093}
19094func (self *OxmIdEthDstMasked) GetOXMName() string {
19095 return "eth_dst_masked"
19096}
19097
19098func (self *OxmIdEthDstMasked) MarshalJSON() ([]byte, error) {
19099 if self.TypeLen == 0 {
19100 return []byte("\"\""), nil
19101 } else {
19102 return []byte("\"" + self.GetOXMName() + "\""), nil
19103 }
19104}
19105
19106type OxmIdEthSrc struct {
19107 *OxmId
19108}
19109
19110type IOxmIdEthSrc interface {
19111 IOxmId
19112}
19113
19114func (self *OxmIdEthSrc) Serialize(encoder *goloxi.Encoder) error {
19115 if err := self.OxmId.Serialize(encoder); err != nil {
19116 return err
19117 }
19118
19119 return nil
19120}
19121
19122func DecodeOxmIdEthSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthSrc, error) {
19123 _oxmidethsrc := &OxmIdEthSrc{OxmId: parent}
19124 return _oxmidethsrc, nil
19125}
19126
19127func NewOxmIdEthSrc() *OxmIdEthSrc {
19128 obj := &OxmIdEthSrc{
19129 OxmId: NewOxmId(1030),
19130 }
19131 return obj
19132}
19133func (self *OxmIdEthSrc) GetOXMName() string {
19134 return "eth_src"
19135}
19136
19137func (self *OxmIdEthSrc) MarshalJSON() ([]byte, error) {
19138 if self.TypeLen == 0 {
19139 return []byte("\"\""), nil
19140 } else {
19141 return []byte("\"" + self.GetOXMName() + "\""), nil
19142 }
19143}
19144
19145type OxmIdEthSrcMasked struct {
19146 *OxmId
19147}
19148
19149type IOxmIdEthSrcMasked interface {
19150 IOxmId
19151}
19152
19153func (self *OxmIdEthSrcMasked) Serialize(encoder *goloxi.Encoder) error {
19154 if err := self.OxmId.Serialize(encoder); err != nil {
19155 return err
19156 }
19157
19158 return nil
19159}
19160
19161func DecodeOxmIdEthSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthSrcMasked, error) {
19162 _oxmidethsrcmasked := &OxmIdEthSrcMasked{OxmId: parent}
19163 return _oxmidethsrcmasked, nil
19164}
19165
19166func NewOxmIdEthSrcMasked() *OxmIdEthSrcMasked {
19167 obj := &OxmIdEthSrcMasked{
19168 OxmId: NewOxmId(1286),
19169 }
19170 return obj
19171}
19172func (self *OxmIdEthSrcMasked) GetOXMName() string {
19173 return "eth_src_masked"
19174}
19175
19176func (self *OxmIdEthSrcMasked) MarshalJSON() ([]byte, error) {
19177 if self.TypeLen == 0 {
19178 return []byte("\"\""), nil
19179 } else {
19180 return []byte("\"" + self.GetOXMName() + "\""), nil
19181 }
19182}
19183
19184type OxmIdEthType struct {
19185 *OxmId
19186}
19187
19188type IOxmIdEthType interface {
19189 IOxmId
19190}
19191
19192func (self *OxmIdEthType) Serialize(encoder *goloxi.Encoder) error {
19193 if err := self.OxmId.Serialize(encoder); err != nil {
19194 return err
19195 }
19196
19197 return nil
19198}
19199
19200func DecodeOxmIdEthType(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthType, error) {
19201 _oxmidethtype := &OxmIdEthType{OxmId: parent}
19202 return _oxmidethtype, nil
19203}
19204
19205func NewOxmIdEthType() *OxmIdEthType {
19206 obj := &OxmIdEthType{
19207 OxmId: NewOxmId(1538),
19208 }
19209 return obj
19210}
19211func (self *OxmIdEthType) GetOXMName() string {
19212 return "eth_type"
19213}
19214
19215func (self *OxmIdEthType) MarshalJSON() ([]byte, error) {
19216 if self.TypeLen == 0 {
19217 return []byte("\"\""), nil
19218 } else {
19219 return []byte("\"" + self.GetOXMName() + "\""), nil
19220 }
19221}
19222
19223type OxmIdIcmpCode struct {
19224 *OxmId
19225}
19226
19227type IOxmIdIcmpCode interface {
19228 IOxmId
19229}
19230
19231func (self *OxmIdIcmpCode) Serialize(encoder *goloxi.Encoder) error {
19232 if err := self.OxmId.Serialize(encoder); err != nil {
19233 return err
19234 }
19235
19236 return nil
19237}
19238
19239func DecodeOxmIdIcmpCode(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpCode, error) {
19240 _oxmidicmpcode := &OxmIdIcmpCode{OxmId: parent}
19241 return _oxmidicmpcode, nil
19242}
19243
19244func NewOxmIdIcmpCode() *OxmIdIcmpCode {
19245 obj := &OxmIdIcmpCode{
19246 OxmId: NewOxmId(7169),
19247 }
19248 return obj
19249}
19250func (self *OxmIdIcmpCode) GetOXMName() string {
19251 return "icmp_code"
19252}
19253
19254func (self *OxmIdIcmpCode) MarshalJSON() ([]byte, error) {
19255 if self.TypeLen == 0 {
19256 return []byte("\"\""), nil
19257 } else {
19258 return []byte("\"" + self.GetOXMName() + "\""), nil
19259 }
19260}
19261
19262type OxmIdIcmpType struct {
19263 *OxmId
19264}
19265
19266type IOxmIdIcmpType interface {
19267 IOxmId
19268}
19269
19270func (self *OxmIdIcmpType) Serialize(encoder *goloxi.Encoder) error {
19271 if err := self.OxmId.Serialize(encoder); err != nil {
19272 return err
19273 }
19274
19275 return nil
19276}
19277
19278func DecodeOxmIdIcmpType(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpType, error) {
19279 _oxmidicmptype := &OxmIdIcmpType{OxmId: parent}
19280 return _oxmidicmptype, nil
19281}
19282
19283func NewOxmIdIcmpType() *OxmIdIcmpType {
19284 obj := &OxmIdIcmpType{
19285 OxmId: NewOxmId(6657),
19286 }
19287 return obj
19288}
19289func (self *OxmIdIcmpType) GetOXMName() string {
19290 return "icmp_type"
19291}
19292
19293func (self *OxmIdIcmpType) MarshalJSON() ([]byte, error) {
19294 if self.TypeLen == 0 {
19295 return []byte("\"\""), nil
19296 } else {
19297 return []byte("\"" + self.GetOXMName() + "\""), nil
19298 }
19299}
19300
19301type OxmIdIcmpv6Code struct {
19302 *OxmId
19303}
19304
19305type IOxmIdIcmpv6Code interface {
19306 IOxmId
19307}
19308
19309func (self *OxmIdIcmpv6Code) Serialize(encoder *goloxi.Encoder) error {
19310 if err := self.OxmId.Serialize(encoder); err != nil {
19311 return err
19312 }
19313
19314 return nil
19315}
19316
19317func DecodeOxmIdIcmpv6Code(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6Code, error) {
19318 _oxmidicmpv6code := &OxmIdIcmpv6Code{OxmId: parent}
19319 return _oxmidicmpv6code, nil
19320}
19321
19322func NewOxmIdIcmpv6Code() *OxmIdIcmpv6Code {
19323 obj := &OxmIdIcmpv6Code{
19324 OxmId: NewOxmId(76801),
19325 }
19326 return obj
19327}
19328func (self *OxmIdIcmpv6Code) GetOXMName() string {
19329 return "icmpv6_code"
19330}
19331
19332func (self *OxmIdIcmpv6Code) MarshalJSON() ([]byte, error) {
19333 if self.TypeLen == 0 {
19334 return []byte("\"\""), nil
19335 } else {
19336 return []byte("\"" + self.GetOXMName() + "\""), nil
19337 }
19338}
19339
19340type OxmIdIcmpv6Type struct {
19341 *OxmId
19342}
19343
19344type IOxmIdIcmpv6Type interface {
19345 IOxmId
19346}
19347
19348func (self *OxmIdIcmpv6Type) Serialize(encoder *goloxi.Encoder) error {
19349 if err := self.OxmId.Serialize(encoder); err != nil {
19350 return err
19351 }
19352
19353 return nil
19354}
19355
19356func DecodeOxmIdIcmpv6Type(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6Type, error) {
19357 _oxmidicmpv6type := &OxmIdIcmpv6Type{OxmId: parent}
19358 return _oxmidicmpv6type, nil
19359}
19360
19361func NewOxmIdIcmpv6Type() *OxmIdIcmpv6Type {
19362 obj := &OxmIdIcmpv6Type{
19363 OxmId: NewOxmId(76289),
19364 }
19365 return obj
19366}
19367func (self *OxmIdIcmpv6Type) GetOXMName() string {
19368 return "icmpv6_type"
19369}
19370
19371func (self *OxmIdIcmpv6Type) MarshalJSON() ([]byte, error) {
19372 if self.TypeLen == 0 {
19373 return []byte("\"\""), nil
19374 } else {
19375 return []byte("\"" + self.GetOXMName() + "\""), nil
19376 }
19377}
19378
19379type OxmIdInPort struct {
19380 *OxmId
19381}
19382
19383type IOxmIdInPort interface {
19384 IOxmId
19385}
19386
19387func (self *OxmIdInPort) Serialize(encoder *goloxi.Encoder) error {
19388 if err := self.OxmId.Serialize(encoder); err != nil {
19389 return err
19390 }
19391
19392 return nil
19393}
19394
19395func DecodeOxmIdInPort(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPort, error) {
19396 _oxmidinport := &OxmIdInPort{OxmId: parent}
19397 return _oxmidinport, nil
19398}
19399
19400func NewOxmIdInPort() *OxmIdInPort {
19401 obj := &OxmIdInPort{
19402 OxmId: NewOxmId(2),
19403 }
19404 return obj
19405}
19406func (self *OxmIdInPort) GetOXMName() string {
19407 return "in_port"
19408}
19409
19410func (self *OxmIdInPort) MarshalJSON() ([]byte, error) {
19411 if self.TypeLen == 0 {
19412 return []byte("\"\""), nil
19413 } else {
19414 return []byte("\"" + self.GetOXMName() + "\""), nil
19415 }
19416}
19417
19418type OxmIdIpDst struct {
19419 *OxmId
19420}
19421
19422type IOxmIdIpDst interface {
19423 IOxmId
19424}
19425
19426func (self *OxmIdIpDst) Serialize(encoder *goloxi.Encoder) error {
19427 if err := self.OxmId.Serialize(encoder); err != nil {
19428 return err
19429 }
19430
19431 return nil
19432}
19433
19434func DecodeOxmIdIpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDst, error) {
19435 _oxmidipdst := &OxmIdIpDst{OxmId: parent}
19436 return _oxmidipdst, nil
19437}
19438
19439func NewOxmIdIpDst() *OxmIdIpDst {
19440 obj := &OxmIdIpDst{
19441 OxmId: NewOxmId(4100),
19442 }
19443 return obj
19444}
19445func (self *OxmIdIpDst) GetOXMName() string {
19446 return "ip_dst"
19447}
19448
19449func (self *OxmIdIpDst) MarshalJSON() ([]byte, error) {
19450 if self.TypeLen == 0 {
19451 return []byte("\"\""), nil
19452 } else {
19453 return []byte("\"" + self.GetOXMName() + "\""), nil
19454 }
19455}
19456
19457type OxmIdIpDstMasked struct {
19458 *OxmId
19459}
19460
19461type IOxmIdIpDstMasked interface {
19462 IOxmId
19463}
19464
19465func (self *OxmIdIpDstMasked) Serialize(encoder *goloxi.Encoder) error {
19466 if err := self.OxmId.Serialize(encoder); err != nil {
19467 return err
19468 }
19469
19470 return nil
19471}
19472
19473func DecodeOxmIdIpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDstMasked, error) {
19474 _oxmidipdstmasked := &OxmIdIpDstMasked{OxmId: parent}
19475 return _oxmidipdstmasked, nil
19476}
19477
19478func NewOxmIdIpDstMasked() *OxmIdIpDstMasked {
19479 obj := &OxmIdIpDstMasked{
19480 OxmId: NewOxmId(4360),
19481 }
19482 return obj
19483}
19484func (self *OxmIdIpDstMasked) GetOXMName() string {
19485 return "ip_dst_masked"
19486}
19487
19488func (self *OxmIdIpDstMasked) MarshalJSON() ([]byte, error) {
19489 if self.TypeLen == 0 {
19490 return []byte("\"\""), nil
19491 } else {
19492 return []byte("\"" + self.GetOXMName() + "\""), nil
19493 }
19494}
19495
19496type OxmIdIpFrag struct {
19497 *OxmId
19498}
19499
19500type IOxmIdIpFrag interface {
19501 IOxmId
19502}
19503
19504func (self *OxmIdIpFrag) Serialize(encoder *goloxi.Encoder) error {
19505 if err := self.OxmId.Serialize(encoder); err != nil {
19506 return err
19507 }
19508
19509 return nil
19510}
19511
19512func DecodeOxmIdIpFrag(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpFrag, error) {
19513 _oxmidipfrag := &OxmIdIpFrag{OxmId: parent}
19514 return _oxmidipfrag, nil
19515}
19516
19517func NewOxmIdIpFrag() *OxmIdIpFrag {
19518 obj := &OxmIdIpFrag{
19519 OxmId: NewOxmId(78849),
19520 }
19521 return obj
19522}
19523func (self *OxmIdIpFrag) GetOXMName() string {
19524 return "ip_frag"
19525}
19526
19527func (self *OxmIdIpFrag) MarshalJSON() ([]byte, error) {
19528 if self.TypeLen == 0 {
19529 return []byte("\"\""), nil
19530 } else {
19531 return []byte("\"" + self.GetOXMName() + "\""), nil
19532 }
19533}
19534
19535type OxmIdIpFragMasked struct {
19536 *OxmId
19537}
19538
19539type IOxmIdIpFragMasked interface {
19540 IOxmId
19541}
19542
19543func (self *OxmIdIpFragMasked) Serialize(encoder *goloxi.Encoder) error {
19544 if err := self.OxmId.Serialize(encoder); err != nil {
19545 return err
19546 }
19547
19548 return nil
19549}
19550
19551func DecodeOxmIdIpFragMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpFragMasked, error) {
19552 _oxmidipfragmasked := &OxmIdIpFragMasked{OxmId: parent}
19553 return _oxmidipfragmasked, nil
19554}
19555
19556func NewOxmIdIpFragMasked() *OxmIdIpFragMasked {
19557 obj := &OxmIdIpFragMasked{
19558 OxmId: NewOxmId(79106),
19559 }
19560 return obj
19561}
19562func (self *OxmIdIpFragMasked) GetOXMName() string {
19563 return "ip_frag_masked"
19564}
19565
19566func (self *OxmIdIpFragMasked) MarshalJSON() ([]byte, error) {
19567 if self.TypeLen == 0 {
19568 return []byte("\"\""), nil
19569 } else {
19570 return []byte("\"" + self.GetOXMName() + "\""), nil
19571 }
19572}
19573
19574type OxmIdIpSrc struct {
19575 *OxmId
19576}
19577
19578type IOxmIdIpSrc interface {
19579 IOxmId
19580}
19581
19582func (self *OxmIdIpSrc) Serialize(encoder *goloxi.Encoder) error {
19583 if err := self.OxmId.Serialize(encoder); err != nil {
19584 return err
19585 }
19586
19587 return nil
19588}
19589
19590func DecodeOxmIdIpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpSrc, error) {
19591 _oxmidipsrc := &OxmIdIpSrc{OxmId: parent}
19592 return _oxmidipsrc, nil
19593}
19594
19595func NewOxmIdIpSrc() *OxmIdIpSrc {
19596 obj := &OxmIdIpSrc{
19597 OxmId: NewOxmId(3588),
19598 }
19599 return obj
19600}
19601func (self *OxmIdIpSrc) GetOXMName() string {
19602 return "ip_src"
19603}
19604
19605func (self *OxmIdIpSrc) MarshalJSON() ([]byte, error) {
19606 if self.TypeLen == 0 {
19607 return []byte("\"\""), nil
19608 } else {
19609 return []byte("\"" + self.GetOXMName() + "\""), nil
19610 }
19611}
19612
19613type OxmIdIpSrcMasked struct {
19614 *OxmId
19615}
19616
19617type IOxmIdIpSrcMasked interface {
19618 IOxmId
19619}
19620
19621func (self *OxmIdIpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
19622 if err := self.OxmId.Serialize(encoder); err != nil {
19623 return err
19624 }
19625
19626 return nil
19627}
19628
19629func DecodeOxmIdIpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpSrcMasked, error) {
19630 _oxmidipsrcmasked := &OxmIdIpSrcMasked{OxmId: parent}
19631 return _oxmidipsrcmasked, nil
19632}
19633
19634func NewOxmIdIpSrcMasked() *OxmIdIpSrcMasked {
19635 obj := &OxmIdIpSrcMasked{
19636 OxmId: NewOxmId(3848),
19637 }
19638 return obj
19639}
19640func (self *OxmIdIpSrcMasked) GetOXMName() string {
19641 return "ip_src_masked"
19642}
19643
19644func (self *OxmIdIpSrcMasked) MarshalJSON() ([]byte, error) {
19645 if self.TypeLen == 0 {
19646 return []byte("\"\""), nil
19647 } else {
19648 return []byte("\"" + self.GetOXMName() + "\""), nil
19649 }
19650}
19651
19652type OxmIdIpv6Dst struct {
19653 *OxmId
19654}
19655
19656type IOxmIdIpv6Dst interface {
19657 IOxmId
19658}
19659
19660func (self *OxmIdIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
19661 if err := self.OxmId.Serialize(encoder); err != nil {
19662 return err
19663 }
19664
19665 return nil
19666}
19667
19668func DecodeOxmIdIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Dst, error) {
19669 _oxmidipv6dst := &OxmIdIpv6Dst{OxmId: parent}
19670 return _oxmidipv6dst, nil
19671}
19672
19673func NewOxmIdIpv6Dst() *OxmIdIpv6Dst {
19674 obj := &OxmIdIpv6Dst{
19675 OxmId: NewOxmId(75792),
19676 }
19677 return obj
19678}
19679func (self *OxmIdIpv6Dst) GetOXMName() string {
19680 return "ipv6_dst"
19681}
19682
19683func (self *OxmIdIpv6Dst) MarshalJSON() ([]byte, error) {
19684 if self.TypeLen == 0 {
19685 return []byte("\"\""), nil
19686 } else {
19687 return []byte("\"" + self.GetOXMName() + "\""), nil
19688 }
19689}
19690
19691type OxmIdIpv6DstMasked struct {
19692 *OxmId
19693}
19694
19695type IOxmIdIpv6DstMasked interface {
19696 IOxmId
19697}
19698
19699func (self *OxmIdIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
19700 if err := self.OxmId.Serialize(encoder); err != nil {
19701 return err
19702 }
19703
19704 return nil
19705}
19706
19707func DecodeOxmIdIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6DstMasked, error) {
19708 _oxmidipv6dstmasked := &OxmIdIpv6DstMasked{OxmId: parent}
19709 return _oxmidipv6dstmasked, nil
19710}
19711
19712func NewOxmIdIpv6DstMasked() *OxmIdIpv6DstMasked {
19713 obj := &OxmIdIpv6DstMasked{
19714 OxmId: NewOxmId(76064),
19715 }
19716 return obj
19717}
19718func (self *OxmIdIpv6DstMasked) GetOXMName() string {
19719 return "ipv6_dst_masked"
19720}
19721
19722func (self *OxmIdIpv6DstMasked) MarshalJSON() ([]byte, error) {
19723 if self.TypeLen == 0 {
19724 return []byte("\"\""), nil
19725 } else {
19726 return []byte("\"" + self.GetOXMName() + "\""), nil
19727 }
19728}
19729
19730type OxmIdIpv6Label struct {
19731 *OxmId
19732}
19733
19734type IOxmIdIpv6Label interface {
19735 IOxmId
19736}
19737
19738func (self *OxmIdIpv6Label) Serialize(encoder *goloxi.Encoder) error {
19739 if err := self.OxmId.Serialize(encoder); err != nil {
19740 return err
19741 }
19742
19743 return nil
19744}
19745
19746func DecodeOxmIdIpv6Label(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Label, error) {
19747 _oxmidipv6label := &OxmIdIpv6Label{OxmId: parent}
19748 return _oxmidipv6label, nil
19749}
19750
19751func NewOxmIdIpv6Label() *OxmIdIpv6Label {
19752 obj := &OxmIdIpv6Label{
19753 OxmId: NewOxmId(79364),
19754 }
19755 return obj
19756}
19757func (self *OxmIdIpv6Label) GetOXMName() string {
19758 return "ipv6_label"
19759}
19760
19761func (self *OxmIdIpv6Label) MarshalJSON() ([]byte, error) {
19762 if self.TypeLen == 0 {
19763 return []byte("\"\""), nil
19764 } else {
19765 return []byte("\"" + self.GetOXMName() + "\""), nil
19766 }
19767}
19768
19769type OxmIdIpv6LabelMasked struct {
19770 *OxmId
19771}
19772
19773type IOxmIdIpv6LabelMasked interface {
19774 IOxmId
19775}
19776
19777func (self *OxmIdIpv6LabelMasked) Serialize(encoder *goloxi.Encoder) error {
19778 if err := self.OxmId.Serialize(encoder); err != nil {
19779 return err
19780 }
19781
19782 return nil
19783}
19784
19785func DecodeOxmIdIpv6LabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6LabelMasked, error) {
19786 _oxmidipv6labelmasked := &OxmIdIpv6LabelMasked{OxmId: parent}
19787 return _oxmidipv6labelmasked, nil
19788}
19789
19790func NewOxmIdIpv6LabelMasked() *OxmIdIpv6LabelMasked {
19791 obj := &OxmIdIpv6LabelMasked{
19792 OxmId: NewOxmId(79624),
19793 }
19794 return obj
19795}
19796func (self *OxmIdIpv6LabelMasked) GetOXMName() string {
19797 return "ipv6_label_masked"
19798}
19799
19800func (self *OxmIdIpv6LabelMasked) MarshalJSON() ([]byte, error) {
19801 if self.TypeLen == 0 {
19802 return []byte("\"\""), nil
19803 } else {
19804 return []byte("\"" + self.GetOXMName() + "\""), nil
19805 }
19806}
19807
19808type OxmIdIpv6Src struct {
19809 *OxmId
19810}
19811
19812type IOxmIdIpv6Src interface {
19813 IOxmId
19814}
19815
19816func (self *OxmIdIpv6Src) Serialize(encoder *goloxi.Encoder) error {
19817 if err := self.OxmId.Serialize(encoder); err != nil {
19818 return err
19819 }
19820
19821 return nil
19822}
19823
19824func DecodeOxmIdIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Src, error) {
19825 _oxmidipv6src := &OxmIdIpv6Src{OxmId: parent}
19826 return _oxmidipv6src, nil
19827}
19828
19829func NewOxmIdIpv6Src() *OxmIdIpv6Src {
19830 obj := &OxmIdIpv6Src{
19831 OxmId: NewOxmId(75280),
19832 }
19833 return obj
19834}
19835func (self *OxmIdIpv6Src) GetOXMName() string {
19836 return "ipv6_src"
19837}
19838
19839func (self *OxmIdIpv6Src) MarshalJSON() ([]byte, error) {
19840 if self.TypeLen == 0 {
19841 return []byte("\"\""), nil
19842 } else {
19843 return []byte("\"" + self.GetOXMName() + "\""), nil
19844 }
19845}
19846
19847type OxmIdIpv6SrcMasked struct {
19848 *OxmId
19849}
19850
19851type IOxmIdIpv6SrcMasked interface {
19852 IOxmId
19853}
19854
19855func (self *OxmIdIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
19856 if err := self.OxmId.Serialize(encoder); err != nil {
19857 return err
19858 }
19859
19860 return nil
19861}
19862
19863func DecodeOxmIdIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6SrcMasked, error) {
19864 _oxmidipv6srcmasked := &OxmIdIpv6SrcMasked{OxmId: parent}
19865 return _oxmidipv6srcmasked, nil
19866}
19867
19868func NewOxmIdIpv6SrcMasked() *OxmIdIpv6SrcMasked {
19869 obj := &OxmIdIpv6SrcMasked{
19870 OxmId: NewOxmId(75552),
19871 }
19872 return obj
19873}
19874func (self *OxmIdIpv6SrcMasked) GetOXMName() string {
19875 return "ipv6_src_masked"
19876}
19877
19878func (self *OxmIdIpv6SrcMasked) MarshalJSON() ([]byte, error) {
19879 if self.TypeLen == 0 {
19880 return []byte("\"\""), nil
19881 } else {
19882 return []byte("\"" + self.GetOXMName() + "\""), nil
19883 }
19884}
19885
19886type OxmIdMplsTtl struct {
19887 *OxmId
19888}
19889
19890type IOxmIdMplsTtl interface {
19891 IOxmId
19892}
19893
19894func (self *OxmIdMplsTtl) Serialize(encoder *goloxi.Encoder) error {
19895 if err := self.OxmId.Serialize(encoder); err != nil {
19896 return err
19897 }
19898
19899 return nil
19900}
19901
19902func DecodeOxmIdMplsTtl(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsTtl, error) {
19903 _oxmidmplsttl := &OxmIdMplsTtl{OxmId: parent}
19904 return _oxmidmplsttl, nil
19905}
19906
19907func NewOxmIdMplsTtl() *OxmIdMplsTtl {
19908 obj := &OxmIdMplsTtl{
19909 OxmId: NewOxmId(80897),
19910 }
19911 return obj
19912}
19913func (self *OxmIdMplsTtl) GetOXMName() string {
19914 return "mpls_ttl"
19915}
19916
19917func (self *OxmIdMplsTtl) MarshalJSON() ([]byte, error) {
19918 if self.TypeLen == 0 {
19919 return []byte("\"\""), nil
19920 } else {
19921 return []byte("\"" + self.GetOXMName() + "\""), nil
19922 }
19923}
19924
19925type OxmIdNdSll struct {
19926 *OxmId
19927}
19928
19929type IOxmIdNdSll interface {
19930 IOxmId
19931}
19932
19933func (self *OxmIdNdSll) Serialize(encoder *goloxi.Encoder) error {
19934 if err := self.OxmId.Serialize(encoder); err != nil {
19935 return err
19936 }
19937
19938 return nil
19939}
19940
19941func DecodeOxmIdNdSll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdSll, error) {
19942 _oxmidndsll := &OxmIdNdSll{OxmId: parent}
19943 return _oxmidndsll, nil
19944}
19945
19946func NewOxmIdNdSll() *OxmIdNdSll {
19947 obj := &OxmIdNdSll{
19948 OxmId: NewOxmId(77830),
19949 }
19950 return obj
19951}
19952func (self *OxmIdNdSll) GetOXMName() string {
19953 return "nd_sll"
19954}
19955
19956func (self *OxmIdNdSll) MarshalJSON() ([]byte, error) {
19957 if self.TypeLen == 0 {
19958 return []byte("\"\""), nil
19959 } else {
19960 return []byte("\"" + self.GetOXMName() + "\""), nil
19961 }
19962}
19963
19964type OxmIdNdSllMasked struct {
19965 *OxmId
19966}
19967
19968type IOxmIdNdSllMasked interface {
19969 IOxmId
19970}
19971
19972func (self *OxmIdNdSllMasked) Serialize(encoder *goloxi.Encoder) error {
19973 if err := self.OxmId.Serialize(encoder); err != nil {
19974 return err
19975 }
19976
19977 return nil
19978}
19979
19980func DecodeOxmIdNdSllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdSllMasked, error) {
19981 _oxmidndsllmasked := &OxmIdNdSllMasked{OxmId: parent}
19982 return _oxmidndsllmasked, nil
19983}
19984
19985func NewOxmIdNdSllMasked() *OxmIdNdSllMasked {
19986 obj := &OxmIdNdSllMasked{
19987 OxmId: NewOxmId(78091),
19988 }
19989 return obj
19990}
19991func (self *OxmIdNdSllMasked) GetOXMName() string {
19992 return "nd_sll_masked"
19993}
19994
19995func (self *OxmIdNdSllMasked) MarshalJSON() ([]byte, error) {
19996 if self.TypeLen == 0 {
19997 return []byte("\"\""), nil
19998 } else {
19999 return []byte("\"" + self.GetOXMName() + "\""), nil
20000 }
20001}
20002
20003type OxmIdNdTarget struct {
20004 *OxmId
20005}
20006
20007type IOxmIdNdTarget interface {
20008 IOxmId
20009}
20010
20011func (self *OxmIdNdTarget) Serialize(encoder *goloxi.Encoder) error {
20012 if err := self.OxmId.Serialize(encoder); err != nil {
20013 return err
20014 }
20015
20016 return nil
20017}
20018
20019func DecodeOxmIdNdTarget(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTarget, error) {
20020 _oxmidndtarget := &OxmIdNdTarget{OxmId: parent}
20021 return _oxmidndtarget, nil
20022}
20023
20024func NewOxmIdNdTarget() *OxmIdNdTarget {
20025 obj := &OxmIdNdTarget{
20026 OxmId: NewOxmId(77328),
20027 }
20028 return obj
20029}
20030func (self *OxmIdNdTarget) GetOXMName() string {
20031 return "nd_target"
20032}
20033
20034func (self *OxmIdNdTarget) MarshalJSON() ([]byte, error) {
20035 if self.TypeLen == 0 {
20036 return []byte("\"\""), nil
20037 } else {
20038 return []byte("\"" + self.GetOXMName() + "\""), nil
20039 }
20040}
20041
20042type OxmIdNdTargetMasked struct {
20043 *OxmId
20044}
20045
20046type IOxmIdNdTargetMasked interface {
20047 IOxmId
20048}
20049
20050func (self *OxmIdNdTargetMasked) Serialize(encoder *goloxi.Encoder) error {
20051 if err := self.OxmId.Serialize(encoder); err != nil {
20052 return err
20053 }
20054
20055 return nil
20056}
20057
20058func DecodeOxmIdNdTargetMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTargetMasked, error) {
20059 _oxmidndtargetmasked := &OxmIdNdTargetMasked{OxmId: parent}
20060 return _oxmidndtargetmasked, nil
20061}
20062
20063func NewOxmIdNdTargetMasked() *OxmIdNdTargetMasked {
20064 obj := &OxmIdNdTargetMasked{
20065 OxmId: NewOxmId(77600),
20066 }
20067 return obj
20068}
20069func (self *OxmIdNdTargetMasked) GetOXMName() string {
20070 return "nd_target_masked"
20071}
20072
20073func (self *OxmIdNdTargetMasked) MarshalJSON() ([]byte, error) {
20074 if self.TypeLen == 0 {
20075 return []byte("\"\""), nil
20076 } else {
20077 return []byte("\"" + self.GetOXMName() + "\""), nil
20078 }
20079}
20080
20081type OxmIdNdTll struct {
20082 *OxmId
20083}
20084
20085type IOxmIdNdTll interface {
20086 IOxmId
20087}
20088
20089func (self *OxmIdNdTll) Serialize(encoder *goloxi.Encoder) error {
20090 if err := self.OxmId.Serialize(encoder); err != nil {
20091 return err
20092 }
20093
20094 return nil
20095}
20096
20097func DecodeOxmIdNdTll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTll, error) {
20098 _oxmidndtll := &OxmIdNdTll{OxmId: parent}
20099 return _oxmidndtll, nil
20100}
20101
20102func NewOxmIdNdTll() *OxmIdNdTll {
20103 obj := &OxmIdNdTll{
20104 OxmId: NewOxmId(78342),
20105 }
20106 return obj
20107}
20108func (self *OxmIdNdTll) GetOXMName() string {
20109 return "nd_tll"
20110}
20111
20112func (self *OxmIdNdTll) MarshalJSON() ([]byte, error) {
20113 if self.TypeLen == 0 {
20114 return []byte("\"\""), nil
20115 } else {
20116 return []byte("\"" + self.GetOXMName() + "\""), nil
20117 }
20118}
20119
20120type OxmIdNdTllMasked struct {
20121 *OxmId
20122}
20123
20124type IOxmIdNdTllMasked interface {
20125 IOxmId
20126}
20127
20128func (self *OxmIdNdTllMasked) Serialize(encoder *goloxi.Encoder) error {
20129 if err := self.OxmId.Serialize(encoder); err != nil {
20130 return err
20131 }
20132
20133 return nil
20134}
20135
20136func DecodeOxmIdNdTllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTllMasked, error) {
20137 _oxmidndtllmasked := &OxmIdNdTllMasked{OxmId: parent}
20138 return _oxmidndtllmasked, nil
20139}
20140
20141func NewOxmIdNdTllMasked() *OxmIdNdTllMasked {
20142 obj := &OxmIdNdTllMasked{
20143 OxmId: NewOxmId(78603),
20144 }
20145 return obj
20146}
20147func (self *OxmIdNdTllMasked) GetOXMName() string {
20148 return "nd_tll_masked"
20149}
20150
20151func (self *OxmIdNdTllMasked) MarshalJSON() ([]byte, error) {
20152 if self.TypeLen == 0 {
20153 return []byte("\"\""), nil
20154 } else {
20155 return []byte("\"" + self.GetOXMName() + "\""), nil
20156 }
20157}
20158
20159type OxmIdNwEcn struct {
20160 *OxmId
20161}
20162
20163type IOxmIdNwEcn interface {
20164 IOxmId
20165}
20166
20167func (self *OxmIdNwEcn) Serialize(encoder *goloxi.Encoder) error {
20168 if err := self.OxmId.Serialize(encoder); err != nil {
20169 return err
20170 }
20171
20172 return nil
20173}
20174
20175func DecodeOxmIdNwEcn(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwEcn, error) {
20176 _oxmidnwecn := &OxmIdNwEcn{OxmId: parent}
20177 return _oxmidnwecn, nil
20178}
20179
20180func NewOxmIdNwEcn() *OxmIdNwEcn {
20181 obj := &OxmIdNwEcn{
20182 OxmId: NewOxmId(79873),
20183 }
20184 return obj
20185}
20186func (self *OxmIdNwEcn) GetOXMName() string {
20187 return "nw_ecn"
20188}
20189
20190func (self *OxmIdNwEcn) MarshalJSON() ([]byte, error) {
20191 if self.TypeLen == 0 {
20192 return []byte("\"\""), nil
20193 } else {
20194 return []byte("\"" + self.GetOXMName() + "\""), nil
20195 }
20196}
20197
20198type OxmIdNwProto struct {
20199 *OxmId
20200}
20201
20202type IOxmIdNwProto interface {
20203 IOxmId
20204}
20205
20206func (self *OxmIdNwProto) Serialize(encoder *goloxi.Encoder) error {
20207 if err := self.OxmId.Serialize(encoder); err != nil {
20208 return err
20209 }
20210
20211 return nil
20212}
20213
20214func DecodeOxmIdNwProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwProto, error) {
20215 _oxmidnwproto := &OxmIdNwProto{OxmId: parent}
20216 return _oxmidnwproto, nil
20217}
20218
20219func NewOxmIdNwProto() *OxmIdNwProto {
20220 obj := &OxmIdNwProto{
20221 OxmId: NewOxmId(3073),
20222 }
20223 return obj
20224}
20225func (self *OxmIdNwProto) GetOXMName() string {
20226 return "nw_proto"
20227}
20228
20229func (self *OxmIdNwProto) MarshalJSON() ([]byte, error) {
20230 if self.TypeLen == 0 {
20231 return []byte("\"\""), nil
20232 } else {
20233 return []byte("\"" + self.GetOXMName() + "\""), nil
20234 }
20235}
20236
20237type OxmIdNwTos struct {
20238 *OxmId
20239}
20240
20241type IOxmIdNwTos interface {
20242 IOxmId
20243}
20244
20245func (self *OxmIdNwTos) Serialize(encoder *goloxi.Encoder) error {
20246 if err := self.OxmId.Serialize(encoder); err != nil {
20247 return err
20248 }
20249
20250 return nil
20251}
20252
20253func DecodeOxmIdNwTos(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwTos, error) {
20254 _oxmidnwtos := &OxmIdNwTos{OxmId: parent}
20255 return _oxmidnwtos, nil
20256}
20257
20258func NewOxmIdNwTos() *OxmIdNwTos {
20259 obj := &OxmIdNwTos{
20260 OxmId: NewOxmId(2561),
20261 }
20262 return obj
20263}
20264func (self *OxmIdNwTos) GetOXMName() string {
20265 return "nw_tos"
20266}
20267
20268func (self *OxmIdNwTos) MarshalJSON() ([]byte, error) {
20269 if self.TypeLen == 0 {
20270 return []byte("\"\""), nil
20271 } else {
20272 return []byte("\"" + self.GetOXMName() + "\""), nil
20273 }
20274}
20275
20276type OxmIdNwTtl struct {
20277 *OxmId
20278}
20279
20280type IOxmIdNwTtl interface {
20281 IOxmId
20282}
20283
20284func (self *OxmIdNwTtl) Serialize(encoder *goloxi.Encoder) error {
20285 if err := self.OxmId.Serialize(encoder); err != nil {
20286 return err
20287 }
20288
20289 return nil
20290}
20291
20292func DecodeOxmIdNwTtl(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwTtl, error) {
20293 _oxmidnwttl := &OxmIdNwTtl{OxmId: parent}
20294 return _oxmidnwttl, nil
20295}
20296
20297func NewOxmIdNwTtl() *OxmIdNwTtl {
20298 obj := &OxmIdNwTtl{
20299 OxmId: NewOxmId(80385),
20300 }
20301 return obj
20302}
20303func (self *OxmIdNwTtl) GetOXMName() string {
20304 return "nw_ttl"
20305}
20306
20307func (self *OxmIdNwTtl) MarshalJSON() ([]byte, error) {
20308 if self.TypeLen == 0 {
20309 return []byte("\"\""), nil
20310 } else {
20311 return []byte("\"" + self.GetOXMName() + "\""), nil
20312 }
20313}
20314
20315type OxmIdPktMark struct {
20316 *OxmId
20317}
20318
20319type IOxmIdPktMark interface {
20320 IOxmId
20321}
20322
20323func (self *OxmIdPktMark) Serialize(encoder *goloxi.Encoder) error {
20324 if err := self.OxmId.Serialize(encoder); err != nil {
20325 return err
20326 }
20327
20328 return nil
20329}
20330
20331func DecodeOxmIdPktMark(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdPktMark, error) {
20332 _oxmidpktmark := &OxmIdPktMark{OxmId: parent}
20333 return _oxmidpktmark, nil
20334}
20335
20336func NewOxmIdPktMark() *OxmIdPktMark {
20337 obj := &OxmIdPktMark{
20338 OxmId: NewOxmId(82436),
20339 }
20340 return obj
20341}
20342func (self *OxmIdPktMark) GetOXMName() string {
20343 return "pkt_mark"
20344}
20345
20346func (self *OxmIdPktMark) MarshalJSON() ([]byte, error) {
20347 if self.TypeLen == 0 {
20348 return []byte("\"\""), nil
20349 } else {
20350 return []byte("\"" + self.GetOXMName() + "\""), nil
20351 }
20352}
20353
20354type OxmIdPktMarkMasked struct {
20355 *OxmId
20356}
20357
20358type IOxmIdPktMarkMasked interface {
20359 IOxmId
20360}
20361
20362func (self *OxmIdPktMarkMasked) Serialize(encoder *goloxi.Encoder) error {
20363 if err := self.OxmId.Serialize(encoder); err != nil {
20364 return err
20365 }
20366
20367 return nil
20368}
20369
20370func DecodeOxmIdPktMarkMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdPktMarkMasked, error) {
20371 _oxmidpktmarkmasked := &OxmIdPktMarkMasked{OxmId: parent}
20372 return _oxmidpktmarkmasked, nil
20373}
20374
20375func NewOxmIdPktMarkMasked() *OxmIdPktMarkMasked {
20376 obj := &OxmIdPktMarkMasked{
20377 OxmId: NewOxmId(82696),
20378 }
20379 return obj
20380}
20381func (self *OxmIdPktMarkMasked) GetOXMName() string {
20382 return "pkt_mark_masked"
20383}
20384
20385func (self *OxmIdPktMarkMasked) MarshalJSON() ([]byte, error) {
20386 if self.TypeLen == 0 {
20387 return []byte("\"\""), nil
20388 } else {
20389 return []byte("\"" + self.GetOXMName() + "\""), nil
20390 }
20391}
20392
20393type OxmIdRecircId struct {
20394 *OxmId
20395}
20396
20397type IOxmIdRecircId interface {
20398 IOxmId
20399}
20400
20401func (self *OxmIdRecircId) Serialize(encoder *goloxi.Encoder) error {
20402 if err := self.OxmId.Serialize(encoder); err != nil {
20403 return err
20404 }
20405
20406 return nil
20407}
20408
20409func DecodeOxmIdRecircId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdRecircId, error) {
20410 _oxmidrecircid := &OxmIdRecircId{OxmId: parent}
20411 return _oxmidrecircid, nil
20412}
20413
20414func NewOxmIdRecircId() *OxmIdRecircId {
20415 obj := &OxmIdRecircId{
20416 OxmId: NewOxmId(83972),
20417 }
20418 return obj
20419}
20420func (self *OxmIdRecircId) GetOXMName() string {
20421 return "recirc_id"
20422}
20423
20424func (self *OxmIdRecircId) MarshalJSON() ([]byte, error) {
20425 if self.TypeLen == 0 {
20426 return []byte("\"\""), nil
20427 } else {
20428 return []byte("\"" + self.GetOXMName() + "\""), nil
20429 }
20430}
20431
20432type OxmIdReg0 struct {
20433 *OxmId
20434}
20435
20436type IOxmIdReg0 interface {
20437 IOxmId
20438}
20439
20440func (self *OxmIdReg0) Serialize(encoder *goloxi.Encoder) error {
20441 if err := self.OxmId.Serialize(encoder); err != nil {
20442 return err
20443 }
20444
20445 return nil
20446}
20447
20448func DecodeOxmIdReg0(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg0, error) {
20449 _oxmidreg0 := &OxmIdReg0{OxmId: parent}
20450 return _oxmidreg0, nil
20451}
20452
20453func NewOxmIdReg0() *OxmIdReg0 {
20454 obj := &OxmIdReg0{
20455 OxmId: NewOxmId(65540),
20456 }
20457 return obj
20458}
20459func (self *OxmIdReg0) GetOXMName() string {
20460 return "reg0"
20461}
20462
20463func (self *OxmIdReg0) MarshalJSON() ([]byte, error) {
20464 if self.TypeLen == 0 {
20465 return []byte("\"\""), nil
20466 } else {
20467 return []byte("\"" + self.GetOXMName() + "\""), nil
20468 }
20469}
20470
20471type OxmIdReg0Masked struct {
20472 *OxmId
20473}
20474
20475type IOxmIdReg0Masked interface {
20476 IOxmId
20477}
20478
20479func (self *OxmIdReg0Masked) Serialize(encoder *goloxi.Encoder) error {
20480 if err := self.OxmId.Serialize(encoder); err != nil {
20481 return err
20482 }
20483
20484 return nil
20485}
20486
20487func DecodeOxmIdReg0Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg0Masked, error) {
20488 _oxmidreg0masked := &OxmIdReg0Masked{OxmId: parent}
20489 return _oxmidreg0masked, nil
20490}
20491
20492func NewOxmIdReg0Masked() *OxmIdReg0Masked {
20493 obj := &OxmIdReg0Masked{
20494 OxmId: NewOxmId(65800),
20495 }
20496 return obj
20497}
20498func (self *OxmIdReg0Masked) GetOXMName() string {
20499 return "reg0_masked"
20500}
20501
20502func (self *OxmIdReg0Masked) MarshalJSON() ([]byte, error) {
20503 if self.TypeLen == 0 {
20504 return []byte("\"\""), nil
20505 } else {
20506 return []byte("\"" + self.GetOXMName() + "\""), nil
20507 }
20508}
20509
20510type OxmIdReg1 struct {
20511 *OxmId
20512}
20513
20514type IOxmIdReg1 interface {
20515 IOxmId
20516}
20517
20518func (self *OxmIdReg1) Serialize(encoder *goloxi.Encoder) error {
20519 if err := self.OxmId.Serialize(encoder); err != nil {
20520 return err
20521 }
20522
20523 return nil
20524}
20525
20526func DecodeOxmIdReg1(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg1, error) {
20527 _oxmidreg1 := &OxmIdReg1{OxmId: parent}
20528 return _oxmidreg1, nil
20529}
20530
20531func NewOxmIdReg1() *OxmIdReg1 {
20532 obj := &OxmIdReg1{
20533 OxmId: NewOxmId(66052),
20534 }
20535 return obj
20536}
20537func (self *OxmIdReg1) GetOXMName() string {
20538 return "reg1"
20539}
20540
20541func (self *OxmIdReg1) MarshalJSON() ([]byte, error) {
20542 if self.TypeLen == 0 {
20543 return []byte("\"\""), nil
20544 } else {
20545 return []byte("\"" + self.GetOXMName() + "\""), nil
20546 }
20547}
20548
20549type OxmIdReg10 struct {
20550 *OxmId
20551}
20552
20553type IOxmIdReg10 interface {
20554 IOxmId
20555}
20556
20557func (self *OxmIdReg10) Serialize(encoder *goloxi.Encoder) error {
20558 if err := self.OxmId.Serialize(encoder); err != nil {
20559 return err
20560 }
20561
20562 return nil
20563}
20564
20565func DecodeOxmIdReg10(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg10, error) {
20566 _oxmidreg10 := &OxmIdReg10{OxmId: parent}
20567 return _oxmidreg10, nil
20568}
20569
20570func NewOxmIdReg10() *OxmIdReg10 {
20571 obj := &OxmIdReg10{
20572 OxmId: NewOxmId(70660),
20573 }
20574 return obj
20575}
20576func (self *OxmIdReg10) GetOXMName() string {
20577 return "reg10"
20578}
20579
20580func (self *OxmIdReg10) MarshalJSON() ([]byte, error) {
20581 if self.TypeLen == 0 {
20582 return []byte("\"\""), nil
20583 } else {
20584 return []byte("\"" + self.GetOXMName() + "\""), nil
20585 }
20586}
20587
20588type OxmIdReg10Masked struct {
20589 *OxmId
20590}
20591
20592type IOxmIdReg10Masked interface {
20593 IOxmId
20594}
20595
20596func (self *OxmIdReg10Masked) Serialize(encoder *goloxi.Encoder) error {
20597 if err := self.OxmId.Serialize(encoder); err != nil {
20598 return err
20599 }
20600
20601 return nil
20602}
20603
20604func DecodeOxmIdReg10Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg10Masked, error) {
20605 _oxmidreg10masked := &OxmIdReg10Masked{OxmId: parent}
20606 return _oxmidreg10masked, nil
20607}
20608
20609func NewOxmIdReg10Masked() *OxmIdReg10Masked {
20610 obj := &OxmIdReg10Masked{
20611 OxmId: NewOxmId(70920),
20612 }
20613 return obj
20614}
20615func (self *OxmIdReg10Masked) GetOXMName() string {
20616 return "reg10_masked"
20617}
20618
20619func (self *OxmIdReg10Masked) MarshalJSON() ([]byte, error) {
20620 if self.TypeLen == 0 {
20621 return []byte("\"\""), nil
20622 } else {
20623 return []byte("\"" + self.GetOXMName() + "\""), nil
20624 }
20625}
20626
20627type OxmIdReg11 struct {
20628 *OxmId
20629}
20630
20631type IOxmIdReg11 interface {
20632 IOxmId
20633}
20634
20635func (self *OxmIdReg11) Serialize(encoder *goloxi.Encoder) error {
20636 if err := self.OxmId.Serialize(encoder); err != nil {
20637 return err
20638 }
20639
20640 return nil
20641}
20642
20643func DecodeOxmIdReg11(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg11, error) {
20644 _oxmidreg11 := &OxmIdReg11{OxmId: parent}
20645 return _oxmidreg11, nil
20646}
20647
20648func NewOxmIdReg11() *OxmIdReg11 {
20649 obj := &OxmIdReg11{
20650 OxmId: NewOxmId(71172),
20651 }
20652 return obj
20653}
20654func (self *OxmIdReg11) GetOXMName() string {
20655 return "reg11"
20656}
20657
20658func (self *OxmIdReg11) MarshalJSON() ([]byte, error) {
20659 if self.TypeLen == 0 {
20660 return []byte("\"\""), nil
20661 } else {
20662 return []byte("\"" + self.GetOXMName() + "\""), nil
20663 }
20664}
20665
20666type OxmIdReg11Masked struct {
20667 *OxmId
20668}
20669
20670type IOxmIdReg11Masked interface {
20671 IOxmId
20672}
20673
20674func (self *OxmIdReg11Masked) Serialize(encoder *goloxi.Encoder) error {
20675 if err := self.OxmId.Serialize(encoder); err != nil {
20676 return err
20677 }
20678
20679 return nil
20680}
20681
20682func DecodeOxmIdReg11Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg11Masked, error) {
20683 _oxmidreg11masked := &OxmIdReg11Masked{OxmId: parent}
20684 return _oxmidreg11masked, nil
20685}
20686
20687func NewOxmIdReg11Masked() *OxmIdReg11Masked {
20688 obj := &OxmIdReg11Masked{
20689 OxmId: NewOxmId(71432),
20690 }
20691 return obj
20692}
20693func (self *OxmIdReg11Masked) GetOXMName() string {
20694 return "reg11_masked"
20695}
20696
20697func (self *OxmIdReg11Masked) MarshalJSON() ([]byte, error) {
20698 if self.TypeLen == 0 {
20699 return []byte("\"\""), nil
20700 } else {
20701 return []byte("\"" + self.GetOXMName() + "\""), nil
20702 }
20703}
20704
20705type OxmIdReg12 struct {
20706 *OxmId
20707}
20708
20709type IOxmIdReg12 interface {
20710 IOxmId
20711}
20712
20713func (self *OxmIdReg12) Serialize(encoder *goloxi.Encoder) error {
20714 if err := self.OxmId.Serialize(encoder); err != nil {
20715 return err
20716 }
20717
20718 return nil
20719}
20720
20721func DecodeOxmIdReg12(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg12, error) {
20722 _oxmidreg12 := &OxmIdReg12{OxmId: parent}
20723 return _oxmidreg12, nil
20724}
20725
20726func NewOxmIdReg12() *OxmIdReg12 {
20727 obj := &OxmIdReg12{
20728 OxmId: NewOxmId(71684),
20729 }
20730 return obj
20731}
20732func (self *OxmIdReg12) GetOXMName() string {
20733 return "reg12"
20734}
20735
20736func (self *OxmIdReg12) MarshalJSON() ([]byte, error) {
20737 if self.TypeLen == 0 {
20738 return []byte("\"\""), nil
20739 } else {
20740 return []byte("\"" + self.GetOXMName() + "\""), nil
20741 }
20742}
20743
20744type OxmIdReg12Masked struct {
20745 *OxmId
20746}
20747
20748type IOxmIdReg12Masked interface {
20749 IOxmId
20750}
20751
20752func (self *OxmIdReg12Masked) Serialize(encoder *goloxi.Encoder) error {
20753 if err := self.OxmId.Serialize(encoder); err != nil {
20754 return err
20755 }
20756
20757 return nil
20758}
20759
20760func DecodeOxmIdReg12Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg12Masked, error) {
20761 _oxmidreg12masked := &OxmIdReg12Masked{OxmId: parent}
20762 return _oxmidreg12masked, nil
20763}
20764
20765func NewOxmIdReg12Masked() *OxmIdReg12Masked {
20766 obj := &OxmIdReg12Masked{
20767 OxmId: NewOxmId(71944),
20768 }
20769 return obj
20770}
20771func (self *OxmIdReg12Masked) GetOXMName() string {
20772 return "reg12_masked"
20773}
20774
20775func (self *OxmIdReg12Masked) MarshalJSON() ([]byte, error) {
20776 if self.TypeLen == 0 {
20777 return []byte("\"\""), nil
20778 } else {
20779 return []byte("\"" + self.GetOXMName() + "\""), nil
20780 }
20781}
20782
20783type OxmIdReg13 struct {
20784 *OxmId
20785}
20786
20787type IOxmIdReg13 interface {
20788 IOxmId
20789}
20790
20791func (self *OxmIdReg13) Serialize(encoder *goloxi.Encoder) error {
20792 if err := self.OxmId.Serialize(encoder); err != nil {
20793 return err
20794 }
20795
20796 return nil
20797}
20798
20799func DecodeOxmIdReg13(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg13, error) {
20800 _oxmidreg13 := &OxmIdReg13{OxmId: parent}
20801 return _oxmidreg13, nil
20802}
20803
20804func NewOxmIdReg13() *OxmIdReg13 {
20805 obj := &OxmIdReg13{
20806 OxmId: NewOxmId(72196),
20807 }
20808 return obj
20809}
20810func (self *OxmIdReg13) GetOXMName() string {
20811 return "reg13"
20812}
20813
20814func (self *OxmIdReg13) MarshalJSON() ([]byte, error) {
20815 if self.TypeLen == 0 {
20816 return []byte("\"\""), nil
20817 } else {
20818 return []byte("\"" + self.GetOXMName() + "\""), nil
20819 }
20820}
20821
20822type OxmIdReg13Masked struct {
20823 *OxmId
20824}
20825
20826type IOxmIdReg13Masked interface {
20827 IOxmId
20828}
20829
20830func (self *OxmIdReg13Masked) Serialize(encoder *goloxi.Encoder) error {
20831 if err := self.OxmId.Serialize(encoder); err != nil {
20832 return err
20833 }
20834
20835 return nil
20836}
20837
20838func DecodeOxmIdReg13Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg13Masked, error) {
20839 _oxmidreg13masked := &OxmIdReg13Masked{OxmId: parent}
20840 return _oxmidreg13masked, nil
20841}
20842
20843func NewOxmIdReg13Masked() *OxmIdReg13Masked {
20844 obj := &OxmIdReg13Masked{
20845 OxmId: NewOxmId(72456),
20846 }
20847 return obj
20848}
20849func (self *OxmIdReg13Masked) GetOXMName() string {
20850 return "reg13_masked"
20851}
20852
20853func (self *OxmIdReg13Masked) MarshalJSON() ([]byte, error) {
20854 if self.TypeLen == 0 {
20855 return []byte("\"\""), nil
20856 } else {
20857 return []byte("\"" + self.GetOXMName() + "\""), nil
20858 }
20859}
20860
20861type OxmIdReg14 struct {
20862 *OxmId
20863}
20864
20865type IOxmIdReg14 interface {
20866 IOxmId
20867}
20868
20869func (self *OxmIdReg14) Serialize(encoder *goloxi.Encoder) error {
20870 if err := self.OxmId.Serialize(encoder); err != nil {
20871 return err
20872 }
20873
20874 return nil
20875}
20876
20877func DecodeOxmIdReg14(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg14, error) {
20878 _oxmidreg14 := &OxmIdReg14{OxmId: parent}
20879 return _oxmidreg14, nil
20880}
20881
20882func NewOxmIdReg14() *OxmIdReg14 {
20883 obj := &OxmIdReg14{
20884 OxmId: NewOxmId(72708),
20885 }
20886 return obj
20887}
20888func (self *OxmIdReg14) GetOXMName() string {
20889 return "reg14"
20890}
20891
20892func (self *OxmIdReg14) MarshalJSON() ([]byte, error) {
20893 if self.TypeLen == 0 {
20894 return []byte("\"\""), nil
20895 } else {
20896 return []byte("\"" + self.GetOXMName() + "\""), nil
20897 }
20898}
20899
20900type OxmIdReg14Masked struct {
20901 *OxmId
20902}
20903
20904type IOxmIdReg14Masked interface {
20905 IOxmId
20906}
20907
20908func (self *OxmIdReg14Masked) Serialize(encoder *goloxi.Encoder) error {
20909 if err := self.OxmId.Serialize(encoder); err != nil {
20910 return err
20911 }
20912
20913 return nil
20914}
20915
20916func DecodeOxmIdReg14Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg14Masked, error) {
20917 _oxmidreg14masked := &OxmIdReg14Masked{OxmId: parent}
20918 return _oxmidreg14masked, nil
20919}
20920
20921func NewOxmIdReg14Masked() *OxmIdReg14Masked {
20922 obj := &OxmIdReg14Masked{
20923 OxmId: NewOxmId(72968),
20924 }
20925 return obj
20926}
20927func (self *OxmIdReg14Masked) GetOXMName() string {
20928 return "reg14_masked"
20929}
20930
20931func (self *OxmIdReg14Masked) MarshalJSON() ([]byte, error) {
20932 if self.TypeLen == 0 {
20933 return []byte("\"\""), nil
20934 } else {
20935 return []byte("\"" + self.GetOXMName() + "\""), nil
20936 }
20937}
20938
20939type OxmIdReg15 struct {
20940 *OxmId
20941}
20942
20943type IOxmIdReg15 interface {
20944 IOxmId
20945}
20946
20947func (self *OxmIdReg15) Serialize(encoder *goloxi.Encoder) error {
20948 if err := self.OxmId.Serialize(encoder); err != nil {
20949 return err
20950 }
20951
20952 return nil
20953}
20954
20955func DecodeOxmIdReg15(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg15, error) {
20956 _oxmidreg15 := &OxmIdReg15{OxmId: parent}
20957 return _oxmidreg15, nil
20958}
20959
20960func NewOxmIdReg15() *OxmIdReg15 {
20961 obj := &OxmIdReg15{
20962 OxmId: NewOxmId(73220),
20963 }
20964 return obj
20965}
20966func (self *OxmIdReg15) GetOXMName() string {
20967 return "reg15"
20968}
20969
20970func (self *OxmIdReg15) MarshalJSON() ([]byte, error) {
20971 if self.TypeLen == 0 {
20972 return []byte("\"\""), nil
20973 } else {
20974 return []byte("\"" + self.GetOXMName() + "\""), nil
20975 }
20976}
20977
20978type OxmIdReg15Masked struct {
20979 *OxmId
20980}
20981
20982type IOxmIdReg15Masked interface {
20983 IOxmId
20984}
20985
20986func (self *OxmIdReg15Masked) Serialize(encoder *goloxi.Encoder) error {
20987 if err := self.OxmId.Serialize(encoder); err != nil {
20988 return err
20989 }
20990
20991 return nil
20992}
20993
20994func DecodeOxmIdReg15Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg15Masked, error) {
20995 _oxmidreg15masked := &OxmIdReg15Masked{OxmId: parent}
20996 return _oxmidreg15masked, nil
20997}
20998
20999func NewOxmIdReg15Masked() *OxmIdReg15Masked {
21000 obj := &OxmIdReg15Masked{
21001 OxmId: NewOxmId(73480),
21002 }
21003 return obj
21004}
21005func (self *OxmIdReg15Masked) GetOXMName() string {
21006 return "reg15_masked"
21007}
21008
21009func (self *OxmIdReg15Masked) MarshalJSON() ([]byte, error) {
21010 if self.TypeLen == 0 {
21011 return []byte("\"\""), nil
21012 } else {
21013 return []byte("\"" + self.GetOXMName() + "\""), nil
21014 }
21015}
21016
21017type OxmIdReg1Masked struct {
21018 *OxmId
21019}
21020
21021type IOxmIdReg1Masked interface {
21022 IOxmId
21023}
21024
21025func (self *OxmIdReg1Masked) Serialize(encoder *goloxi.Encoder) error {
21026 if err := self.OxmId.Serialize(encoder); err != nil {
21027 return err
21028 }
21029
21030 return nil
21031}
21032
21033func DecodeOxmIdReg1Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg1Masked, error) {
21034 _oxmidreg1masked := &OxmIdReg1Masked{OxmId: parent}
21035 return _oxmidreg1masked, nil
21036}
21037
21038func NewOxmIdReg1Masked() *OxmIdReg1Masked {
21039 obj := &OxmIdReg1Masked{
21040 OxmId: NewOxmId(66312),
21041 }
21042 return obj
21043}
21044func (self *OxmIdReg1Masked) GetOXMName() string {
21045 return "reg1_masked"
21046}
21047
21048func (self *OxmIdReg1Masked) MarshalJSON() ([]byte, error) {
21049 if self.TypeLen == 0 {
21050 return []byte("\"\""), nil
21051 } else {
21052 return []byte("\"" + self.GetOXMName() + "\""), nil
21053 }
21054}
21055
21056type OxmIdReg2 struct {
21057 *OxmId
21058}
21059
21060type IOxmIdReg2 interface {
21061 IOxmId
21062}
21063
21064func (self *OxmIdReg2) Serialize(encoder *goloxi.Encoder) error {
21065 if err := self.OxmId.Serialize(encoder); err != nil {
21066 return err
21067 }
21068
21069 return nil
21070}
21071
21072func DecodeOxmIdReg2(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg2, error) {
21073 _oxmidreg2 := &OxmIdReg2{OxmId: parent}
21074 return _oxmidreg2, nil
21075}
21076
21077func NewOxmIdReg2() *OxmIdReg2 {
21078 obj := &OxmIdReg2{
21079 OxmId: NewOxmId(66564),
21080 }
21081 return obj
21082}
21083func (self *OxmIdReg2) GetOXMName() string {
21084 return "reg2"
21085}
21086
21087func (self *OxmIdReg2) MarshalJSON() ([]byte, error) {
21088 if self.TypeLen == 0 {
21089 return []byte("\"\""), nil
21090 } else {
21091 return []byte("\"" + self.GetOXMName() + "\""), nil
21092 }
21093}
21094
21095type OxmIdReg2Masked struct {
21096 *OxmId
21097}
21098
21099type IOxmIdReg2Masked interface {
21100 IOxmId
21101}
21102
21103func (self *OxmIdReg2Masked) Serialize(encoder *goloxi.Encoder) error {
21104 if err := self.OxmId.Serialize(encoder); err != nil {
21105 return err
21106 }
21107
21108 return nil
21109}
21110
21111func DecodeOxmIdReg2Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg2Masked, error) {
21112 _oxmidreg2masked := &OxmIdReg2Masked{OxmId: parent}
21113 return _oxmidreg2masked, nil
21114}
21115
21116func NewOxmIdReg2Masked() *OxmIdReg2Masked {
21117 obj := &OxmIdReg2Masked{
21118 OxmId: NewOxmId(66824),
21119 }
21120 return obj
21121}
21122func (self *OxmIdReg2Masked) GetOXMName() string {
21123 return "reg2_masked"
21124}
21125
21126func (self *OxmIdReg2Masked) MarshalJSON() ([]byte, error) {
21127 if self.TypeLen == 0 {
21128 return []byte("\"\""), nil
21129 } else {
21130 return []byte("\"" + self.GetOXMName() + "\""), nil
21131 }
21132}
21133
21134type OxmIdReg3 struct {
21135 *OxmId
21136}
21137
21138type IOxmIdReg3 interface {
21139 IOxmId
21140}
21141
21142func (self *OxmIdReg3) Serialize(encoder *goloxi.Encoder) error {
21143 if err := self.OxmId.Serialize(encoder); err != nil {
21144 return err
21145 }
21146
21147 return nil
21148}
21149
21150func DecodeOxmIdReg3(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg3, error) {
21151 _oxmidreg3 := &OxmIdReg3{OxmId: parent}
21152 return _oxmidreg3, nil
21153}
21154
21155func NewOxmIdReg3() *OxmIdReg3 {
21156 obj := &OxmIdReg3{
21157 OxmId: NewOxmId(67076),
21158 }
21159 return obj
21160}
21161func (self *OxmIdReg3) GetOXMName() string {
21162 return "reg3"
21163}
21164
21165func (self *OxmIdReg3) MarshalJSON() ([]byte, error) {
21166 if self.TypeLen == 0 {
21167 return []byte("\"\""), nil
21168 } else {
21169 return []byte("\"" + self.GetOXMName() + "\""), nil
21170 }
21171}
21172
21173type OxmIdReg3Masked struct {
21174 *OxmId
21175}
21176
21177type IOxmIdReg3Masked interface {
21178 IOxmId
21179}
21180
21181func (self *OxmIdReg3Masked) Serialize(encoder *goloxi.Encoder) error {
21182 if err := self.OxmId.Serialize(encoder); err != nil {
21183 return err
21184 }
21185
21186 return nil
21187}
21188
21189func DecodeOxmIdReg3Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg3Masked, error) {
21190 _oxmidreg3masked := &OxmIdReg3Masked{OxmId: parent}
21191 return _oxmidreg3masked, nil
21192}
21193
21194func NewOxmIdReg3Masked() *OxmIdReg3Masked {
21195 obj := &OxmIdReg3Masked{
21196 OxmId: NewOxmId(67336),
21197 }
21198 return obj
21199}
21200func (self *OxmIdReg3Masked) GetOXMName() string {
21201 return "reg3_masked"
21202}
21203
21204func (self *OxmIdReg3Masked) MarshalJSON() ([]byte, error) {
21205 if self.TypeLen == 0 {
21206 return []byte("\"\""), nil
21207 } else {
21208 return []byte("\"" + self.GetOXMName() + "\""), nil
21209 }
21210}
21211
21212type OxmIdReg4 struct {
21213 *OxmId
21214}
21215
21216type IOxmIdReg4 interface {
21217 IOxmId
21218}
21219
21220func (self *OxmIdReg4) Serialize(encoder *goloxi.Encoder) error {
21221 if err := self.OxmId.Serialize(encoder); err != nil {
21222 return err
21223 }
21224
21225 return nil
21226}
21227
21228func DecodeOxmIdReg4(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg4, error) {
21229 _oxmidreg4 := &OxmIdReg4{OxmId: parent}
21230 return _oxmidreg4, nil
21231}
21232
21233func NewOxmIdReg4() *OxmIdReg4 {
21234 obj := &OxmIdReg4{
21235 OxmId: NewOxmId(67588),
21236 }
21237 return obj
21238}
21239func (self *OxmIdReg4) GetOXMName() string {
21240 return "reg4"
21241}
21242
21243func (self *OxmIdReg4) MarshalJSON() ([]byte, error) {
21244 if self.TypeLen == 0 {
21245 return []byte("\"\""), nil
21246 } else {
21247 return []byte("\"" + self.GetOXMName() + "\""), nil
21248 }
21249}
21250
21251type OxmIdReg4Masked struct {
21252 *OxmId
21253}
21254
21255type IOxmIdReg4Masked interface {
21256 IOxmId
21257}
21258
21259func (self *OxmIdReg4Masked) Serialize(encoder *goloxi.Encoder) error {
21260 if err := self.OxmId.Serialize(encoder); err != nil {
21261 return err
21262 }
21263
21264 return nil
21265}
21266
21267func DecodeOxmIdReg4Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg4Masked, error) {
21268 _oxmidreg4masked := &OxmIdReg4Masked{OxmId: parent}
21269 return _oxmidreg4masked, nil
21270}
21271
21272func NewOxmIdReg4Masked() *OxmIdReg4Masked {
21273 obj := &OxmIdReg4Masked{
21274 OxmId: NewOxmId(67848),
21275 }
21276 return obj
21277}
21278func (self *OxmIdReg4Masked) GetOXMName() string {
21279 return "reg4_masked"
21280}
21281
21282func (self *OxmIdReg4Masked) MarshalJSON() ([]byte, error) {
21283 if self.TypeLen == 0 {
21284 return []byte("\"\""), nil
21285 } else {
21286 return []byte("\"" + self.GetOXMName() + "\""), nil
21287 }
21288}
21289
21290type OxmIdReg5 struct {
21291 *OxmId
21292}
21293
21294type IOxmIdReg5 interface {
21295 IOxmId
21296}
21297
21298func (self *OxmIdReg5) Serialize(encoder *goloxi.Encoder) error {
21299 if err := self.OxmId.Serialize(encoder); err != nil {
21300 return err
21301 }
21302
21303 return nil
21304}
21305
21306func DecodeOxmIdReg5(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg5, error) {
21307 _oxmidreg5 := &OxmIdReg5{OxmId: parent}
21308 return _oxmidreg5, nil
21309}
21310
21311func NewOxmIdReg5() *OxmIdReg5 {
21312 obj := &OxmIdReg5{
21313 OxmId: NewOxmId(68100),
21314 }
21315 return obj
21316}
21317func (self *OxmIdReg5) GetOXMName() string {
21318 return "reg5"
21319}
21320
21321func (self *OxmIdReg5) MarshalJSON() ([]byte, error) {
21322 if self.TypeLen == 0 {
21323 return []byte("\"\""), nil
21324 } else {
21325 return []byte("\"" + self.GetOXMName() + "\""), nil
21326 }
21327}
21328
21329type OxmIdReg5Masked struct {
21330 *OxmId
21331}
21332
21333type IOxmIdReg5Masked interface {
21334 IOxmId
21335}
21336
21337func (self *OxmIdReg5Masked) Serialize(encoder *goloxi.Encoder) error {
21338 if err := self.OxmId.Serialize(encoder); err != nil {
21339 return err
21340 }
21341
21342 return nil
21343}
21344
21345func DecodeOxmIdReg5Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg5Masked, error) {
21346 _oxmidreg5masked := &OxmIdReg5Masked{OxmId: parent}
21347 return _oxmidreg5masked, nil
21348}
21349
21350func NewOxmIdReg5Masked() *OxmIdReg5Masked {
21351 obj := &OxmIdReg5Masked{
21352 OxmId: NewOxmId(68360),
21353 }
21354 return obj
21355}
21356func (self *OxmIdReg5Masked) GetOXMName() string {
21357 return "reg5_masked"
21358}
21359
21360func (self *OxmIdReg5Masked) MarshalJSON() ([]byte, error) {
21361 if self.TypeLen == 0 {
21362 return []byte("\"\""), nil
21363 } else {
21364 return []byte("\"" + self.GetOXMName() + "\""), nil
21365 }
21366}
21367
21368type OxmIdReg6 struct {
21369 *OxmId
21370}
21371
21372type IOxmIdReg6 interface {
21373 IOxmId
21374}
21375
21376func (self *OxmIdReg6) Serialize(encoder *goloxi.Encoder) error {
21377 if err := self.OxmId.Serialize(encoder); err != nil {
21378 return err
21379 }
21380
21381 return nil
21382}
21383
21384func DecodeOxmIdReg6(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg6, error) {
21385 _oxmidreg6 := &OxmIdReg6{OxmId: parent}
21386 return _oxmidreg6, nil
21387}
21388
21389func NewOxmIdReg6() *OxmIdReg6 {
21390 obj := &OxmIdReg6{
21391 OxmId: NewOxmId(68612),
21392 }
21393 return obj
21394}
21395func (self *OxmIdReg6) GetOXMName() string {
21396 return "reg6"
21397}
21398
21399func (self *OxmIdReg6) MarshalJSON() ([]byte, error) {
21400 if self.TypeLen == 0 {
21401 return []byte("\"\""), nil
21402 } else {
21403 return []byte("\"" + self.GetOXMName() + "\""), nil
21404 }
21405}
21406
21407type OxmIdReg6Masked struct {
21408 *OxmId
21409}
21410
21411type IOxmIdReg6Masked interface {
21412 IOxmId
21413}
21414
21415func (self *OxmIdReg6Masked) Serialize(encoder *goloxi.Encoder) error {
21416 if err := self.OxmId.Serialize(encoder); err != nil {
21417 return err
21418 }
21419
21420 return nil
21421}
21422
21423func DecodeOxmIdReg6Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg6Masked, error) {
21424 _oxmidreg6masked := &OxmIdReg6Masked{OxmId: parent}
21425 return _oxmidreg6masked, nil
21426}
21427
21428func NewOxmIdReg6Masked() *OxmIdReg6Masked {
21429 obj := &OxmIdReg6Masked{
21430 OxmId: NewOxmId(68872),
21431 }
21432 return obj
21433}
21434func (self *OxmIdReg6Masked) GetOXMName() string {
21435 return "reg6_masked"
21436}
21437
21438func (self *OxmIdReg6Masked) MarshalJSON() ([]byte, error) {
21439 if self.TypeLen == 0 {
21440 return []byte("\"\""), nil
21441 } else {
21442 return []byte("\"" + self.GetOXMName() + "\""), nil
21443 }
21444}
21445
21446type OxmIdReg7 struct {
21447 *OxmId
21448}
21449
21450type IOxmIdReg7 interface {
21451 IOxmId
21452}
21453
21454func (self *OxmIdReg7) Serialize(encoder *goloxi.Encoder) error {
21455 if err := self.OxmId.Serialize(encoder); err != nil {
21456 return err
21457 }
21458
21459 return nil
21460}
21461
21462func DecodeOxmIdReg7(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg7, error) {
21463 _oxmidreg7 := &OxmIdReg7{OxmId: parent}
21464 return _oxmidreg7, nil
21465}
21466
21467func NewOxmIdReg7() *OxmIdReg7 {
21468 obj := &OxmIdReg7{
21469 OxmId: NewOxmId(69124),
21470 }
21471 return obj
21472}
21473func (self *OxmIdReg7) GetOXMName() string {
21474 return "reg7"
21475}
21476
21477func (self *OxmIdReg7) MarshalJSON() ([]byte, error) {
21478 if self.TypeLen == 0 {
21479 return []byte("\"\""), nil
21480 } else {
21481 return []byte("\"" + self.GetOXMName() + "\""), nil
21482 }
21483}
21484
21485type OxmIdReg7Masked struct {
21486 *OxmId
21487}
21488
21489type IOxmIdReg7Masked interface {
21490 IOxmId
21491}
21492
21493func (self *OxmIdReg7Masked) Serialize(encoder *goloxi.Encoder) error {
21494 if err := self.OxmId.Serialize(encoder); err != nil {
21495 return err
21496 }
21497
21498 return nil
21499}
21500
21501func DecodeOxmIdReg7Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg7Masked, error) {
21502 _oxmidreg7masked := &OxmIdReg7Masked{OxmId: parent}
21503 return _oxmidreg7masked, nil
21504}
21505
21506func NewOxmIdReg7Masked() *OxmIdReg7Masked {
21507 obj := &OxmIdReg7Masked{
21508 OxmId: NewOxmId(69384),
21509 }
21510 return obj
21511}
21512func (self *OxmIdReg7Masked) GetOXMName() string {
21513 return "reg7_masked"
21514}
21515
21516func (self *OxmIdReg7Masked) MarshalJSON() ([]byte, error) {
21517 if self.TypeLen == 0 {
21518 return []byte("\"\""), nil
21519 } else {
21520 return []byte("\"" + self.GetOXMName() + "\""), nil
21521 }
21522}
21523
21524type OxmIdReg8 struct {
21525 *OxmId
21526}
21527
21528type IOxmIdReg8 interface {
21529 IOxmId
21530}
21531
21532func (self *OxmIdReg8) Serialize(encoder *goloxi.Encoder) error {
21533 if err := self.OxmId.Serialize(encoder); err != nil {
21534 return err
21535 }
21536
21537 return nil
21538}
21539
21540func DecodeOxmIdReg8(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg8, error) {
21541 _oxmidreg8 := &OxmIdReg8{OxmId: parent}
21542 return _oxmidreg8, nil
21543}
21544
21545func NewOxmIdReg8() *OxmIdReg8 {
21546 obj := &OxmIdReg8{
21547 OxmId: NewOxmId(69636),
21548 }
21549 return obj
21550}
21551func (self *OxmIdReg8) GetOXMName() string {
21552 return "reg8"
21553}
21554
21555func (self *OxmIdReg8) MarshalJSON() ([]byte, error) {
21556 if self.TypeLen == 0 {
21557 return []byte("\"\""), nil
21558 } else {
21559 return []byte("\"" + self.GetOXMName() + "\""), nil
21560 }
21561}
21562
21563type OxmIdReg8Masked struct {
21564 *OxmId
21565}
21566
21567type IOxmIdReg8Masked interface {
21568 IOxmId
21569}
21570
21571func (self *OxmIdReg8Masked) Serialize(encoder *goloxi.Encoder) error {
21572 if err := self.OxmId.Serialize(encoder); err != nil {
21573 return err
21574 }
21575
21576 return nil
21577}
21578
21579func DecodeOxmIdReg8Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg8Masked, error) {
21580 _oxmidreg8masked := &OxmIdReg8Masked{OxmId: parent}
21581 return _oxmidreg8masked, nil
21582}
21583
21584func NewOxmIdReg8Masked() *OxmIdReg8Masked {
21585 obj := &OxmIdReg8Masked{
21586 OxmId: NewOxmId(69896),
21587 }
21588 return obj
21589}
21590func (self *OxmIdReg8Masked) GetOXMName() string {
21591 return "reg8_masked"
21592}
21593
21594func (self *OxmIdReg8Masked) MarshalJSON() ([]byte, error) {
21595 if self.TypeLen == 0 {
21596 return []byte("\"\""), nil
21597 } else {
21598 return []byte("\"" + self.GetOXMName() + "\""), nil
21599 }
21600}
21601
21602type OxmIdReg9 struct {
21603 *OxmId
21604}
21605
21606type IOxmIdReg9 interface {
21607 IOxmId
21608}
21609
21610func (self *OxmIdReg9) Serialize(encoder *goloxi.Encoder) error {
21611 if err := self.OxmId.Serialize(encoder); err != nil {
21612 return err
21613 }
21614
21615 return nil
21616}
21617
21618func DecodeOxmIdReg9(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg9, error) {
21619 _oxmidreg9 := &OxmIdReg9{OxmId: parent}
21620 return _oxmidreg9, nil
21621}
21622
21623func NewOxmIdReg9() *OxmIdReg9 {
21624 obj := &OxmIdReg9{
21625 OxmId: NewOxmId(70148),
21626 }
21627 return obj
21628}
21629func (self *OxmIdReg9) GetOXMName() string {
21630 return "reg9"
21631}
21632
21633func (self *OxmIdReg9) MarshalJSON() ([]byte, error) {
21634 if self.TypeLen == 0 {
21635 return []byte("\"\""), nil
21636 } else {
21637 return []byte("\"" + self.GetOXMName() + "\""), nil
21638 }
21639}
21640
21641type OxmIdReg9Masked struct {
21642 *OxmId
21643}
21644
21645type IOxmIdReg9Masked interface {
21646 IOxmId
21647}
21648
21649func (self *OxmIdReg9Masked) Serialize(encoder *goloxi.Encoder) error {
21650 if err := self.OxmId.Serialize(encoder); err != nil {
21651 return err
21652 }
21653
21654 return nil
21655}
21656
21657func DecodeOxmIdReg9Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg9Masked, error) {
21658 _oxmidreg9masked := &OxmIdReg9Masked{OxmId: parent}
21659 return _oxmidreg9masked, nil
21660}
21661
21662func NewOxmIdReg9Masked() *OxmIdReg9Masked {
21663 obj := &OxmIdReg9Masked{
21664 OxmId: NewOxmId(70408),
21665 }
21666 return obj
21667}
21668func (self *OxmIdReg9Masked) GetOXMName() string {
21669 return "reg9_masked"
21670}
21671
21672func (self *OxmIdReg9Masked) MarshalJSON() ([]byte, error) {
21673 if self.TypeLen == 0 {
21674 return []byte("\"\""), nil
21675 } else {
21676 return []byte("\"" + self.GetOXMName() + "\""), nil
21677 }
21678}
21679
21680type OxmIdTcpDst struct {
21681 *OxmId
21682}
21683
21684type IOxmIdTcpDst interface {
21685 IOxmId
21686}
21687
21688func (self *OxmIdTcpDst) Serialize(encoder *goloxi.Encoder) error {
21689 if err := self.OxmId.Serialize(encoder); err != nil {
21690 return err
21691 }
21692
21693 return nil
21694}
21695
21696func DecodeOxmIdTcpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpDst, error) {
21697 _oxmidtcpdst := &OxmIdTcpDst{OxmId: parent}
21698 return _oxmidtcpdst, nil
21699}
21700
21701func NewOxmIdTcpDst() *OxmIdTcpDst {
21702 obj := &OxmIdTcpDst{
21703 OxmId: NewOxmId(5122),
21704 }
21705 return obj
21706}
21707func (self *OxmIdTcpDst) GetOXMName() string {
21708 return "tcp_dst"
21709}
21710
21711func (self *OxmIdTcpDst) MarshalJSON() ([]byte, error) {
21712 if self.TypeLen == 0 {
21713 return []byte("\"\""), nil
21714 } else {
21715 return []byte("\"" + self.GetOXMName() + "\""), nil
21716 }
21717}
21718
21719type OxmIdTcpDstMasked struct {
21720 *OxmId
21721}
21722
21723type IOxmIdTcpDstMasked interface {
21724 IOxmId
21725}
21726
21727func (self *OxmIdTcpDstMasked) Serialize(encoder *goloxi.Encoder) error {
21728 if err := self.OxmId.Serialize(encoder); err != nil {
21729 return err
21730 }
21731
21732 return nil
21733}
21734
21735func DecodeOxmIdTcpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpDstMasked, error) {
21736 _oxmidtcpdstmasked := &OxmIdTcpDstMasked{OxmId: parent}
21737 return _oxmidtcpdstmasked, nil
21738}
21739
21740func NewOxmIdTcpDstMasked() *OxmIdTcpDstMasked {
21741 obj := &OxmIdTcpDstMasked{
21742 OxmId: NewOxmId(5378),
21743 }
21744 return obj
21745}
21746func (self *OxmIdTcpDstMasked) GetOXMName() string {
21747 return "tcp_dst_masked"
21748}
21749
21750func (self *OxmIdTcpDstMasked) MarshalJSON() ([]byte, error) {
21751 if self.TypeLen == 0 {
21752 return []byte("\"\""), nil
21753 } else {
21754 return []byte("\"" + self.GetOXMName() + "\""), nil
21755 }
21756}
21757
21758type OxmIdTcpFlags struct {
21759 *OxmId
21760}
21761
21762type IOxmIdTcpFlags interface {
21763 IOxmId
21764}
21765
21766func (self *OxmIdTcpFlags) Serialize(encoder *goloxi.Encoder) error {
21767 if err := self.OxmId.Serialize(encoder); err != nil {
21768 return err
21769 }
21770
21771 return nil
21772}
21773
21774func DecodeOxmIdTcpFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpFlags, error) {
21775 _oxmidtcpflags := &OxmIdTcpFlags{OxmId: parent}
21776 return _oxmidtcpflags, nil
21777}
21778
21779func NewOxmIdTcpFlags() *OxmIdTcpFlags {
21780 obj := &OxmIdTcpFlags{
21781 OxmId: NewOxmId(82946),
21782 }
21783 return obj
21784}
21785func (self *OxmIdTcpFlags) GetOXMName() string {
21786 return "tcp_flags"
21787}
21788
21789func (self *OxmIdTcpFlags) MarshalJSON() ([]byte, error) {
21790 if self.TypeLen == 0 {
21791 return []byte("\"\""), nil
21792 } else {
21793 return []byte("\"" + self.GetOXMName() + "\""), nil
21794 }
21795}
21796
21797type OxmIdTcpFlagsMasked struct {
21798 *OxmId
21799}
21800
21801type IOxmIdTcpFlagsMasked interface {
21802 IOxmId
21803}
21804
21805func (self *OxmIdTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
21806 if err := self.OxmId.Serialize(encoder); err != nil {
21807 return err
21808 }
21809
21810 return nil
21811}
21812
21813func DecodeOxmIdTcpFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpFlagsMasked, error) {
21814 _oxmidtcpflagsmasked := &OxmIdTcpFlagsMasked{OxmId: parent}
21815 return _oxmidtcpflagsmasked, nil
21816}
21817
21818func NewOxmIdTcpFlagsMasked() *OxmIdTcpFlagsMasked {
21819 obj := &OxmIdTcpFlagsMasked{
21820 OxmId: NewOxmId(83204),
21821 }
21822 return obj
21823}
21824func (self *OxmIdTcpFlagsMasked) GetOXMName() string {
21825 return "tcp_flags_masked"
21826}
21827
21828func (self *OxmIdTcpFlagsMasked) MarshalJSON() ([]byte, error) {
21829 if self.TypeLen == 0 {
21830 return []byte("\"\""), nil
21831 } else {
21832 return []byte("\"" + self.GetOXMName() + "\""), nil
21833 }
21834}
21835
21836type OxmIdTcpSrc struct {
21837 *OxmId
21838}
21839
21840type IOxmIdTcpSrc interface {
21841 IOxmId
21842}
21843
21844func (self *OxmIdTcpSrc) Serialize(encoder *goloxi.Encoder) error {
21845 if err := self.OxmId.Serialize(encoder); err != nil {
21846 return err
21847 }
21848
21849 return nil
21850}
21851
21852func DecodeOxmIdTcpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpSrc, error) {
21853 _oxmidtcpsrc := &OxmIdTcpSrc{OxmId: parent}
21854 return _oxmidtcpsrc, nil
21855}
21856
21857func NewOxmIdTcpSrc() *OxmIdTcpSrc {
21858 obj := &OxmIdTcpSrc{
21859 OxmId: NewOxmId(4610),
21860 }
21861 return obj
21862}
21863func (self *OxmIdTcpSrc) GetOXMName() string {
21864 return "tcp_src"
21865}
21866
21867func (self *OxmIdTcpSrc) MarshalJSON() ([]byte, error) {
21868 if self.TypeLen == 0 {
21869 return []byte("\"\""), nil
21870 } else {
21871 return []byte("\"" + self.GetOXMName() + "\""), nil
21872 }
21873}
21874
21875type OxmIdTcpSrcMasked struct {
21876 *OxmId
21877}
21878
21879type IOxmIdTcpSrcMasked interface {
21880 IOxmId
21881}
21882
21883func (self *OxmIdTcpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
21884 if err := self.OxmId.Serialize(encoder); err != nil {
21885 return err
21886 }
21887
21888 return nil
21889}
21890
21891func DecodeOxmIdTcpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpSrcMasked, error) {
21892 _oxmidtcpsrcmasked := &OxmIdTcpSrcMasked{OxmId: parent}
21893 return _oxmidtcpsrcmasked, nil
21894}
21895
21896func NewOxmIdTcpSrcMasked() *OxmIdTcpSrcMasked {
21897 obj := &OxmIdTcpSrcMasked{
21898 OxmId: NewOxmId(4868),
21899 }
21900 return obj
21901}
21902func (self *OxmIdTcpSrcMasked) GetOXMName() string {
21903 return "tcp_src_masked"
21904}
21905
21906func (self *OxmIdTcpSrcMasked) MarshalJSON() ([]byte, error) {
21907 if self.TypeLen == 0 {
21908 return []byte("\"\""), nil
21909 } else {
21910 return []byte("\"" + self.GetOXMName() + "\""), nil
21911 }
21912}
21913
21914type OxmIdTunDst struct {
21915 *OxmId
21916}
21917
21918type IOxmIdTunDst interface {
21919 IOxmId
21920}
21921
21922func (self *OxmIdTunDst) Serialize(encoder *goloxi.Encoder) error {
21923 if err := self.OxmId.Serialize(encoder); err != nil {
21924 return err
21925 }
21926
21927 return nil
21928}
21929
21930func DecodeOxmIdTunDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunDst, error) {
21931 _oxmidtundst := &OxmIdTunDst{OxmId: parent}
21932 return _oxmidtundst, nil
21933}
21934
21935func NewOxmIdTunDst() *OxmIdTunDst {
21936 obj := &OxmIdTunDst{
21937 OxmId: NewOxmId(81924),
21938 }
21939 return obj
21940}
21941func (self *OxmIdTunDst) GetOXMName() string {
21942 return "tun_dst"
21943}
21944
21945func (self *OxmIdTunDst) MarshalJSON() ([]byte, error) {
21946 if self.TypeLen == 0 {
21947 return []byte("\"\""), nil
21948 } else {
21949 return []byte("\"" + self.GetOXMName() + "\""), nil
21950 }
21951}
21952
21953type OxmIdTunDstMasked struct {
21954 *OxmId
21955}
21956
21957type IOxmIdTunDstMasked interface {
21958 IOxmId
21959}
21960
21961func (self *OxmIdTunDstMasked) Serialize(encoder *goloxi.Encoder) error {
21962 if err := self.OxmId.Serialize(encoder); err != nil {
21963 return err
21964 }
21965
21966 return nil
21967}
21968
21969func DecodeOxmIdTunDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunDstMasked, error) {
21970 _oxmidtundstmasked := &OxmIdTunDstMasked{OxmId: parent}
21971 return _oxmidtundstmasked, nil
21972}
21973
21974func NewOxmIdTunDstMasked() *OxmIdTunDstMasked {
21975 obj := &OxmIdTunDstMasked{
21976 OxmId: NewOxmId(82184),
21977 }
21978 return obj
21979}
21980func (self *OxmIdTunDstMasked) GetOXMName() string {
21981 return "tun_dst_masked"
21982}
21983
21984func (self *OxmIdTunDstMasked) MarshalJSON() ([]byte, error) {
21985 if self.TypeLen == 0 {
21986 return []byte("\"\""), nil
21987 } else {
21988 return []byte("\"" + self.GetOXMName() + "\""), nil
21989 }
21990}
21991
21992type OxmIdTunFlags struct {
21993 *OxmId
21994}
21995
21996type IOxmIdTunFlags interface {
21997 IOxmId
21998}
21999
22000func (self *OxmIdTunFlags) Serialize(encoder *goloxi.Encoder) error {
22001 if err := self.OxmId.Serialize(encoder); err != nil {
22002 return err
22003 }
22004
22005 return nil
22006}
22007
22008func DecodeOxmIdTunFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunFlags, error) {
22009 _oxmidtunflags := &OxmIdTunFlags{OxmId: parent}
22010 return _oxmidtunflags, nil
22011}
22012
22013func NewOxmIdTunFlags() *OxmIdTunFlags {
22014 obj := &OxmIdTunFlags{
22015 OxmId: NewOxmId(118786),
22016 }
22017 return obj
22018}
22019func (self *OxmIdTunFlags) GetOXMName() string {
22020 return "tun_flags"
22021}
22022
22023func (self *OxmIdTunFlags) MarshalJSON() ([]byte, error) {
22024 if self.TypeLen == 0 {
22025 return []byte("\"\""), nil
22026 } else {
22027 return []byte("\"" + self.GetOXMName() + "\""), nil
22028 }
22029}
22030
22031type OxmIdTunFlagsMasked struct {
22032 *OxmId
22033}
22034
22035type IOxmIdTunFlagsMasked interface {
22036 IOxmId
22037}
22038
22039func (self *OxmIdTunFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
22040 if err := self.OxmId.Serialize(encoder); err != nil {
22041 return err
22042 }
22043
22044 return nil
22045}
22046
22047func DecodeOxmIdTunFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunFlagsMasked, error) {
22048 _oxmidtunflagsmasked := &OxmIdTunFlagsMasked{OxmId: parent}
22049 return _oxmidtunflagsmasked, nil
22050}
22051
22052func NewOxmIdTunFlagsMasked() *OxmIdTunFlagsMasked {
22053 obj := &OxmIdTunFlagsMasked{
22054 OxmId: NewOxmId(119044),
22055 }
22056 return obj
22057}
22058func (self *OxmIdTunFlagsMasked) GetOXMName() string {
22059 return "tun_flags_masked"
22060}
22061
22062func (self *OxmIdTunFlagsMasked) MarshalJSON() ([]byte, error) {
22063 if self.TypeLen == 0 {
22064 return []byte("\"\""), nil
22065 } else {
22066 return []byte("\"" + self.GetOXMName() + "\""), nil
22067 }
22068}
22069
22070type OxmIdTunGbpFlags struct {
22071 *OxmId
22072}
22073
22074type IOxmIdTunGbpFlags interface {
22075 IOxmId
22076}
22077
22078func (self *OxmIdTunGbpFlags) Serialize(encoder *goloxi.Encoder) error {
22079 if err := self.OxmId.Serialize(encoder); err != nil {
22080 return err
22081 }
22082
22083 return nil
22084}
22085
22086func DecodeOxmIdTunGbpFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpFlags, error) {
22087 _oxmidtungbpflags := &OxmIdTunGbpFlags{OxmId: parent}
22088 return _oxmidtungbpflags, nil
22089}
22090
22091func NewOxmIdTunGbpFlags() *OxmIdTunGbpFlags {
22092 obj := &OxmIdTunGbpFlags{
22093 OxmId: NewOxmId(85505),
22094 }
22095 return obj
22096}
22097func (self *OxmIdTunGbpFlags) GetOXMName() string {
22098 return "tun_gbp_flags"
22099}
22100
22101func (self *OxmIdTunGbpFlags) MarshalJSON() ([]byte, error) {
22102 if self.TypeLen == 0 {
22103 return []byte("\"\""), nil
22104 } else {
22105 return []byte("\"" + self.GetOXMName() + "\""), nil
22106 }
22107}
22108
22109type OxmIdTunGbpFlagsMasked struct {
22110 *OxmId
22111}
22112
22113type IOxmIdTunGbpFlagsMasked interface {
22114 IOxmId
22115}
22116
22117func (self *OxmIdTunGbpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
22118 if err := self.OxmId.Serialize(encoder); err != nil {
22119 return err
22120 }
22121
22122 return nil
22123}
22124
22125func DecodeOxmIdTunGbpFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpFlagsMasked, error) {
22126 _oxmidtungbpflagsmasked := &OxmIdTunGbpFlagsMasked{OxmId: parent}
22127 return _oxmidtungbpflagsmasked, nil
22128}
22129
22130func NewOxmIdTunGbpFlagsMasked() *OxmIdTunGbpFlagsMasked {
22131 obj := &OxmIdTunGbpFlagsMasked{
22132 OxmId: NewOxmId(85762),
22133 }
22134 return obj
22135}
22136func (self *OxmIdTunGbpFlagsMasked) GetOXMName() string {
22137 return "tun_gbp_flags_masked"
22138}
22139
22140func (self *OxmIdTunGbpFlagsMasked) MarshalJSON() ([]byte, error) {
22141 if self.TypeLen == 0 {
22142 return []byte("\"\""), nil
22143 } else {
22144 return []byte("\"" + self.GetOXMName() + "\""), nil
22145 }
22146}
22147
22148type OxmIdTunGbpId struct {
22149 *OxmId
22150}
22151
22152type IOxmIdTunGbpId interface {
22153 IOxmId
22154}
22155
22156func (self *OxmIdTunGbpId) Serialize(encoder *goloxi.Encoder) error {
22157 if err := self.OxmId.Serialize(encoder); err != nil {
22158 return err
22159 }
22160
22161 return nil
22162}
22163
22164func DecodeOxmIdTunGbpId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpId, error) {
22165 _oxmidtungbpid := &OxmIdTunGbpId{OxmId: parent}
22166 return _oxmidtungbpid, nil
22167}
22168
22169func NewOxmIdTunGbpId() *OxmIdTunGbpId {
22170 obj := &OxmIdTunGbpId{
22171 OxmId: NewOxmId(84994),
22172 }
22173 return obj
22174}
22175func (self *OxmIdTunGbpId) GetOXMName() string {
22176 return "tun_gbp_id"
22177}
22178
22179func (self *OxmIdTunGbpId) MarshalJSON() ([]byte, error) {
22180 if self.TypeLen == 0 {
22181 return []byte("\"\""), nil
22182 } else {
22183 return []byte("\"" + self.GetOXMName() + "\""), nil
22184 }
22185}
22186
22187type OxmIdTunGbpIdMasked struct {
22188 *OxmId
22189}
22190
22191type IOxmIdTunGbpIdMasked interface {
22192 IOxmId
22193}
22194
22195func (self *OxmIdTunGbpIdMasked) Serialize(encoder *goloxi.Encoder) error {
22196 if err := self.OxmId.Serialize(encoder); err != nil {
22197 return err
22198 }
22199
22200 return nil
22201}
22202
22203func DecodeOxmIdTunGbpIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpIdMasked, error) {
22204 _oxmidtungbpidmasked := &OxmIdTunGbpIdMasked{OxmId: parent}
22205 return _oxmidtungbpidmasked, nil
22206}
22207
22208func NewOxmIdTunGbpIdMasked() *OxmIdTunGbpIdMasked {
22209 obj := &OxmIdTunGbpIdMasked{
22210 OxmId: NewOxmId(85252),
22211 }
22212 return obj
22213}
22214func (self *OxmIdTunGbpIdMasked) GetOXMName() string {
22215 return "tun_gbp_id_masked"
22216}
22217
22218func (self *OxmIdTunGbpIdMasked) MarshalJSON() ([]byte, error) {
22219 if self.TypeLen == 0 {
22220 return []byte("\"\""), nil
22221 } else {
22222 return []byte("\"" + self.GetOXMName() + "\""), nil
22223 }
22224}
22225
22226type OxmIdTunId struct {
22227 *OxmId
22228}
22229
22230type IOxmIdTunId interface {
22231 IOxmId
22232}
22233
22234func (self *OxmIdTunId) Serialize(encoder *goloxi.Encoder) error {
22235 if err := self.OxmId.Serialize(encoder); err != nil {
22236 return err
22237 }
22238
22239 return nil
22240}
22241
22242func DecodeOxmIdTunId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunId, error) {
22243 _oxmidtunid := &OxmIdTunId{OxmId: parent}
22244 return _oxmidtunid, nil
22245}
22246
22247func NewOxmIdTunId() *OxmIdTunId {
22248 obj := &OxmIdTunId{
22249 OxmId: NewOxmId(73736),
22250 }
22251 return obj
22252}
22253func (self *OxmIdTunId) GetOXMName() string {
22254 return "tun_id"
22255}
22256
22257func (self *OxmIdTunId) MarshalJSON() ([]byte, error) {
22258 if self.TypeLen == 0 {
22259 return []byte("\"\""), nil
22260 } else {
22261 return []byte("\"" + self.GetOXMName() + "\""), nil
22262 }
22263}
22264
22265type OxmIdTunIdMasked struct {
22266 *OxmId
22267}
22268
22269type IOxmIdTunIdMasked interface {
22270 IOxmId
22271}
22272
22273func (self *OxmIdTunIdMasked) Serialize(encoder *goloxi.Encoder) error {
22274 if err := self.OxmId.Serialize(encoder); err != nil {
22275 return err
22276 }
22277
22278 return nil
22279}
22280
22281func DecodeOxmIdTunIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIdMasked, error) {
22282 _oxmidtunidmasked := &OxmIdTunIdMasked{OxmId: parent}
22283 return _oxmidtunidmasked, nil
22284}
22285
22286func NewOxmIdTunIdMasked() *OxmIdTunIdMasked {
22287 obj := &OxmIdTunIdMasked{
22288 OxmId: NewOxmId(74000),
22289 }
22290 return obj
22291}
22292func (self *OxmIdTunIdMasked) GetOXMName() string {
22293 return "tun_id_masked"
22294}
22295
22296func (self *OxmIdTunIdMasked) MarshalJSON() ([]byte, error) {
22297 if self.TypeLen == 0 {
22298 return []byte("\"\""), nil
22299 } else {
22300 return []byte("\"" + self.GetOXMName() + "\""), nil
22301 }
22302}
22303
22304type OxmIdTunIpv6Dst struct {
22305 *OxmId
22306}
22307
22308type IOxmIdTunIpv6Dst interface {
22309 IOxmId
22310}
22311
22312func (self *OxmIdTunIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
22313 if err := self.OxmId.Serialize(encoder); err != nil {
22314 return err
22315 }
22316
22317 return nil
22318}
22319
22320func DecodeOxmIdTunIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6Dst, error) {
22321 _oxmidtunipv6dst := &OxmIdTunIpv6Dst{OxmId: parent}
22322 return _oxmidtunipv6dst, nil
22323}
22324
22325func NewOxmIdTunIpv6Dst() *OxmIdTunIpv6Dst {
22326 obj := &OxmIdTunIpv6Dst{
22327 OxmId: NewOxmId(121872),
22328 }
22329 return obj
22330}
22331func (self *OxmIdTunIpv6Dst) GetOXMName() string {
22332 return "tun_ipv6_dst"
22333}
22334
22335func (self *OxmIdTunIpv6Dst) MarshalJSON() ([]byte, error) {
22336 if self.TypeLen == 0 {
22337 return []byte("\"\""), nil
22338 } else {
22339 return []byte("\"" + self.GetOXMName() + "\""), nil
22340 }
22341}
22342
22343type OxmIdTunIpv6DstMasked struct {
22344 *OxmId
22345}
22346
22347type IOxmIdTunIpv6DstMasked interface {
22348 IOxmId
22349}
22350
22351func (self *OxmIdTunIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
22352 if err := self.OxmId.Serialize(encoder); err != nil {
22353 return err
22354 }
22355
22356 return nil
22357}
22358
22359func DecodeOxmIdTunIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6DstMasked, error) {
22360 _oxmidtunipv6dstmasked := &OxmIdTunIpv6DstMasked{OxmId: parent}
22361 return _oxmidtunipv6dstmasked, nil
22362}
22363
22364func NewOxmIdTunIpv6DstMasked() *OxmIdTunIpv6DstMasked {
22365 obj := &OxmIdTunIpv6DstMasked{
22366 OxmId: NewOxmId(122144),
22367 }
22368 return obj
22369}
22370func (self *OxmIdTunIpv6DstMasked) GetOXMName() string {
22371 return "tun_ipv6_dst_masked"
22372}
22373
22374func (self *OxmIdTunIpv6DstMasked) MarshalJSON() ([]byte, error) {
22375 if self.TypeLen == 0 {
22376 return []byte("\"\""), nil
22377 } else {
22378 return []byte("\"" + self.GetOXMName() + "\""), nil
22379 }
22380}
22381
22382type OxmIdTunIpv6Src struct {
22383 *OxmId
22384}
22385
22386type IOxmIdTunIpv6Src interface {
22387 IOxmId
22388}
22389
22390func (self *OxmIdTunIpv6Src) Serialize(encoder *goloxi.Encoder) error {
22391 if err := self.OxmId.Serialize(encoder); err != nil {
22392 return err
22393 }
22394
22395 return nil
22396}
22397
22398func DecodeOxmIdTunIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6Src, error) {
22399 _oxmidtunipv6src := &OxmIdTunIpv6Src{OxmId: parent}
22400 return _oxmidtunipv6src, nil
22401}
22402
22403func NewOxmIdTunIpv6Src() *OxmIdTunIpv6Src {
22404 obj := &OxmIdTunIpv6Src{
22405 OxmId: NewOxmId(121360),
22406 }
22407 return obj
22408}
22409func (self *OxmIdTunIpv6Src) GetOXMName() string {
22410 return "tun_ipv6_src"
22411}
22412
22413func (self *OxmIdTunIpv6Src) MarshalJSON() ([]byte, error) {
22414 if self.TypeLen == 0 {
22415 return []byte("\"\""), nil
22416 } else {
22417 return []byte("\"" + self.GetOXMName() + "\""), nil
22418 }
22419}
22420
22421type OxmIdTunIpv6SrcMasked struct {
22422 *OxmId
22423}
22424
22425type IOxmIdTunIpv6SrcMasked interface {
22426 IOxmId
22427}
22428
22429func (self *OxmIdTunIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
22430 if err := self.OxmId.Serialize(encoder); err != nil {
22431 return err
22432 }
22433
22434 return nil
22435}
22436
22437func DecodeOxmIdTunIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6SrcMasked, error) {
22438 _oxmidtunipv6srcmasked := &OxmIdTunIpv6SrcMasked{OxmId: parent}
22439 return _oxmidtunipv6srcmasked, nil
22440}
22441
22442func NewOxmIdTunIpv6SrcMasked() *OxmIdTunIpv6SrcMasked {
22443 obj := &OxmIdTunIpv6SrcMasked{
22444 OxmId: NewOxmId(121632),
22445 }
22446 return obj
22447}
22448func (self *OxmIdTunIpv6SrcMasked) GetOXMName() string {
22449 return "tun_ipv6_src_masked"
22450}
22451
22452func (self *OxmIdTunIpv6SrcMasked) MarshalJSON() ([]byte, error) {
22453 if self.TypeLen == 0 {
22454 return []byte("\"\""), nil
22455 } else {
22456 return []byte("\"" + self.GetOXMName() + "\""), nil
22457 }
22458}
22459
22460type OxmIdTunMetadata0 struct {
22461 *OxmId
22462}
22463
22464type IOxmIdTunMetadata0 interface {
22465 IOxmId
22466}
22467
22468func (self *OxmIdTunMetadata0) Serialize(encoder *goloxi.Encoder) error {
22469 if err := self.OxmId.Serialize(encoder); err != nil {
22470 return err
22471 }
22472
22473 return nil
22474}
22475
22476func DecodeOxmIdTunMetadata0(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata0, error) {
22477 _oxmidtunmetadata0 := &OxmIdTunMetadata0{OxmId: parent}
22478 return _oxmidtunmetadata0, nil
22479}
22480
22481func NewOxmIdTunMetadata0() *OxmIdTunMetadata0 {
22482 obj := &OxmIdTunMetadata0{
22483 OxmId: NewOxmId(86140),
22484 }
22485 return obj
22486}
22487func (self *OxmIdTunMetadata0) GetOXMName() string {
22488 return "tun_metadata0"
22489}
22490
22491func (self *OxmIdTunMetadata0) MarshalJSON() ([]byte, error) {
22492 if self.TypeLen == 0 {
22493 return []byte("\"\""), nil
22494 } else {
22495 return []byte("\"" + self.GetOXMName() + "\""), nil
22496 }
22497}
22498
22499type OxmIdTunMetadata0Masked struct {
22500 *OxmId
22501}
22502
22503type IOxmIdTunMetadata0Masked interface {
22504 IOxmId
22505}
22506
22507func (self *OxmIdTunMetadata0Masked) Serialize(encoder *goloxi.Encoder) error {
22508 if err := self.OxmId.Serialize(encoder); err != nil {
22509 return err
22510 }
22511
22512 return nil
22513}
22514
22515func DecodeOxmIdTunMetadata0Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata0Masked, error) {
22516 _oxmidtunmetadata0masked := &OxmIdTunMetadata0Masked{OxmId: parent}
22517 return _oxmidtunmetadata0masked, nil
22518}
22519
22520func NewOxmIdTunMetadata0Masked() *OxmIdTunMetadata0Masked {
22521 obj := &OxmIdTunMetadata0Masked{
22522 OxmId: NewOxmId(86520),
22523 }
22524 return obj
22525}
22526func (self *OxmIdTunMetadata0Masked) GetOXMName() string {
22527 return "tun_metadata0_masked"
22528}
22529
22530func (self *OxmIdTunMetadata0Masked) MarshalJSON() ([]byte, error) {
22531 if self.TypeLen == 0 {
22532 return []byte("\"\""), nil
22533 } else {
22534 return []byte("\"" + self.GetOXMName() + "\""), nil
22535 }
22536}
22537
22538type OxmIdTunMetadata1 struct {
22539 *OxmId
22540}
22541
22542type IOxmIdTunMetadata1 interface {
22543 IOxmId
22544}
22545
22546func (self *OxmIdTunMetadata1) Serialize(encoder *goloxi.Encoder) error {
22547 if err := self.OxmId.Serialize(encoder); err != nil {
22548 return err
22549 }
22550
22551 return nil
22552}
22553
22554func DecodeOxmIdTunMetadata1(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata1, error) {
22555 _oxmidtunmetadata1 := &OxmIdTunMetadata1{OxmId: parent}
22556 return _oxmidtunmetadata1, nil
22557}
22558
22559func NewOxmIdTunMetadata1() *OxmIdTunMetadata1 {
22560 obj := &OxmIdTunMetadata1{
22561 OxmId: NewOxmId(86652),
22562 }
22563 return obj
22564}
22565func (self *OxmIdTunMetadata1) GetOXMName() string {
22566 return "tun_metadata1"
22567}
22568
22569func (self *OxmIdTunMetadata1) MarshalJSON() ([]byte, error) {
22570 if self.TypeLen == 0 {
22571 return []byte("\"\""), nil
22572 } else {
22573 return []byte("\"" + self.GetOXMName() + "\""), nil
22574 }
22575}
22576
22577type OxmIdTunMetadata10 struct {
22578 *OxmId
22579}
22580
22581type IOxmIdTunMetadata10 interface {
22582 IOxmId
22583}
22584
22585func (self *OxmIdTunMetadata10) Serialize(encoder *goloxi.Encoder) error {
22586 if err := self.OxmId.Serialize(encoder); err != nil {
22587 return err
22588 }
22589
22590 return nil
22591}
22592
22593func DecodeOxmIdTunMetadata10(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata10, error) {
22594 _oxmidtunmetadata10 := &OxmIdTunMetadata10{OxmId: parent}
22595 return _oxmidtunmetadata10, nil
22596}
22597
22598func NewOxmIdTunMetadata10() *OxmIdTunMetadata10 {
22599 obj := &OxmIdTunMetadata10{
22600 OxmId: NewOxmId(91260),
22601 }
22602 return obj
22603}
22604func (self *OxmIdTunMetadata10) GetOXMName() string {
22605 return "tun_metadata10"
22606}
22607
22608func (self *OxmIdTunMetadata10) MarshalJSON() ([]byte, error) {
22609 if self.TypeLen == 0 {
22610 return []byte("\"\""), nil
22611 } else {
22612 return []byte("\"" + self.GetOXMName() + "\""), nil
22613 }
22614}
22615
22616type OxmIdTunMetadata10Masked struct {
22617 *OxmId
22618}
22619
22620type IOxmIdTunMetadata10Masked interface {
22621 IOxmId
22622}
22623
22624func (self *OxmIdTunMetadata10Masked) Serialize(encoder *goloxi.Encoder) error {
22625 if err := self.OxmId.Serialize(encoder); err != nil {
22626 return err
22627 }
22628
22629 return nil
22630}
22631
22632func DecodeOxmIdTunMetadata10Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata10Masked, error) {
22633 _oxmidtunmetadata10masked := &OxmIdTunMetadata10Masked{OxmId: parent}
22634 return _oxmidtunmetadata10masked, nil
22635}
22636
22637func NewOxmIdTunMetadata10Masked() *OxmIdTunMetadata10Masked {
22638 obj := &OxmIdTunMetadata10Masked{
22639 OxmId: NewOxmId(91640),
22640 }
22641 return obj
22642}
22643func (self *OxmIdTunMetadata10Masked) GetOXMName() string {
22644 return "tun_metadata10_masked"
22645}
22646
22647func (self *OxmIdTunMetadata10Masked) MarshalJSON() ([]byte, error) {
22648 if self.TypeLen == 0 {
22649 return []byte("\"\""), nil
22650 } else {
22651 return []byte("\"" + self.GetOXMName() + "\""), nil
22652 }
22653}
22654
22655type OxmIdTunMetadata11 struct {
22656 *OxmId
22657}
22658
22659type IOxmIdTunMetadata11 interface {
22660 IOxmId
22661}
22662
22663func (self *OxmIdTunMetadata11) Serialize(encoder *goloxi.Encoder) error {
22664 if err := self.OxmId.Serialize(encoder); err != nil {
22665 return err
22666 }
22667
22668 return nil
22669}
22670
22671func DecodeOxmIdTunMetadata11(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata11, error) {
22672 _oxmidtunmetadata11 := &OxmIdTunMetadata11{OxmId: parent}
22673 return _oxmidtunmetadata11, nil
22674}
22675
22676func NewOxmIdTunMetadata11() *OxmIdTunMetadata11 {
22677 obj := &OxmIdTunMetadata11{
22678 OxmId: NewOxmId(91772),
22679 }
22680 return obj
22681}
22682func (self *OxmIdTunMetadata11) GetOXMName() string {
22683 return "tun_metadata11"
22684}
22685
22686func (self *OxmIdTunMetadata11) MarshalJSON() ([]byte, error) {
22687 if self.TypeLen == 0 {
22688 return []byte("\"\""), nil
22689 } else {
22690 return []byte("\"" + self.GetOXMName() + "\""), nil
22691 }
22692}
22693
22694type OxmIdTunMetadata11Masked struct {
22695 *OxmId
22696}
22697
22698type IOxmIdTunMetadata11Masked interface {
22699 IOxmId
22700}
22701
22702func (self *OxmIdTunMetadata11Masked) Serialize(encoder *goloxi.Encoder) error {
22703 if err := self.OxmId.Serialize(encoder); err != nil {
22704 return err
22705 }
22706
22707 return nil
22708}
22709
22710func DecodeOxmIdTunMetadata11Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata11Masked, error) {
22711 _oxmidtunmetadata11masked := &OxmIdTunMetadata11Masked{OxmId: parent}
22712 return _oxmidtunmetadata11masked, nil
22713}
22714
22715func NewOxmIdTunMetadata11Masked() *OxmIdTunMetadata11Masked {
22716 obj := &OxmIdTunMetadata11Masked{
22717 OxmId: NewOxmId(92152),
22718 }
22719 return obj
22720}
22721func (self *OxmIdTunMetadata11Masked) GetOXMName() string {
22722 return "tun_metadata11_masked"
22723}
22724
22725func (self *OxmIdTunMetadata11Masked) MarshalJSON() ([]byte, error) {
22726 if self.TypeLen == 0 {
22727 return []byte("\"\""), nil
22728 } else {
22729 return []byte("\"" + self.GetOXMName() + "\""), nil
22730 }
22731}
22732
22733type OxmIdTunMetadata12 struct {
22734 *OxmId
22735}
22736
22737type IOxmIdTunMetadata12 interface {
22738 IOxmId
22739}
22740
22741func (self *OxmIdTunMetadata12) Serialize(encoder *goloxi.Encoder) error {
22742 if err := self.OxmId.Serialize(encoder); err != nil {
22743 return err
22744 }
22745
22746 return nil
22747}
22748
22749func DecodeOxmIdTunMetadata12(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata12, error) {
22750 _oxmidtunmetadata12 := &OxmIdTunMetadata12{OxmId: parent}
22751 return _oxmidtunmetadata12, nil
22752}
22753
22754func NewOxmIdTunMetadata12() *OxmIdTunMetadata12 {
22755 obj := &OxmIdTunMetadata12{
22756 OxmId: NewOxmId(92284),
22757 }
22758 return obj
22759}
22760func (self *OxmIdTunMetadata12) GetOXMName() string {
22761 return "tun_metadata12"
22762}
22763
22764func (self *OxmIdTunMetadata12) MarshalJSON() ([]byte, error) {
22765 if self.TypeLen == 0 {
22766 return []byte("\"\""), nil
22767 } else {
22768 return []byte("\"" + self.GetOXMName() + "\""), nil
22769 }
22770}
22771
22772type OxmIdTunMetadata12Masked struct {
22773 *OxmId
22774}
22775
22776type IOxmIdTunMetadata12Masked interface {
22777 IOxmId
22778}
22779
22780func (self *OxmIdTunMetadata12Masked) Serialize(encoder *goloxi.Encoder) error {
22781 if err := self.OxmId.Serialize(encoder); err != nil {
22782 return err
22783 }
22784
22785 return nil
22786}
22787
22788func DecodeOxmIdTunMetadata12Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata12Masked, error) {
22789 _oxmidtunmetadata12masked := &OxmIdTunMetadata12Masked{OxmId: parent}
22790 return _oxmidtunmetadata12masked, nil
22791}
22792
22793func NewOxmIdTunMetadata12Masked() *OxmIdTunMetadata12Masked {
22794 obj := &OxmIdTunMetadata12Masked{
22795 OxmId: NewOxmId(92664),
22796 }
22797 return obj
22798}
22799func (self *OxmIdTunMetadata12Masked) GetOXMName() string {
22800 return "tun_metadata12_masked"
22801}
22802
22803func (self *OxmIdTunMetadata12Masked) MarshalJSON() ([]byte, error) {
22804 if self.TypeLen == 0 {
22805 return []byte("\"\""), nil
22806 } else {
22807 return []byte("\"" + self.GetOXMName() + "\""), nil
22808 }
22809}
22810
22811type OxmIdTunMetadata13 struct {
22812 *OxmId
22813}
22814
22815type IOxmIdTunMetadata13 interface {
22816 IOxmId
22817}
22818
22819func (self *OxmIdTunMetadata13) Serialize(encoder *goloxi.Encoder) error {
22820 if err := self.OxmId.Serialize(encoder); err != nil {
22821 return err
22822 }
22823
22824 return nil
22825}
22826
22827func DecodeOxmIdTunMetadata13(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata13, error) {
22828 _oxmidtunmetadata13 := &OxmIdTunMetadata13{OxmId: parent}
22829 return _oxmidtunmetadata13, nil
22830}
22831
22832func NewOxmIdTunMetadata13() *OxmIdTunMetadata13 {
22833 obj := &OxmIdTunMetadata13{
22834 OxmId: NewOxmId(92796),
22835 }
22836 return obj
22837}
22838func (self *OxmIdTunMetadata13) GetOXMName() string {
22839 return "tun_metadata13"
22840}
22841
22842func (self *OxmIdTunMetadata13) MarshalJSON() ([]byte, error) {
22843 if self.TypeLen == 0 {
22844 return []byte("\"\""), nil
22845 } else {
22846 return []byte("\"" + self.GetOXMName() + "\""), nil
22847 }
22848}
22849
22850type OxmIdTunMetadata13Masked struct {
22851 *OxmId
22852}
22853
22854type IOxmIdTunMetadata13Masked interface {
22855 IOxmId
22856}
22857
22858func (self *OxmIdTunMetadata13Masked) Serialize(encoder *goloxi.Encoder) error {
22859 if err := self.OxmId.Serialize(encoder); err != nil {
22860 return err
22861 }
22862
22863 return nil
22864}
22865
22866func DecodeOxmIdTunMetadata13Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata13Masked, error) {
22867 _oxmidtunmetadata13masked := &OxmIdTunMetadata13Masked{OxmId: parent}
22868 return _oxmidtunmetadata13masked, nil
22869}
22870
22871func NewOxmIdTunMetadata13Masked() *OxmIdTunMetadata13Masked {
22872 obj := &OxmIdTunMetadata13Masked{
22873 OxmId: NewOxmId(93176),
22874 }
22875 return obj
22876}
22877func (self *OxmIdTunMetadata13Masked) GetOXMName() string {
22878 return "tun_metadata13_masked"
22879}
22880
22881func (self *OxmIdTunMetadata13Masked) MarshalJSON() ([]byte, error) {
22882 if self.TypeLen == 0 {
22883 return []byte("\"\""), nil
22884 } else {
22885 return []byte("\"" + self.GetOXMName() + "\""), nil
22886 }
22887}
22888
22889type OxmIdTunMetadata14 struct {
22890 *OxmId
22891}
22892
22893type IOxmIdTunMetadata14 interface {
22894 IOxmId
22895}
22896
22897func (self *OxmIdTunMetadata14) Serialize(encoder *goloxi.Encoder) error {
22898 if err := self.OxmId.Serialize(encoder); err != nil {
22899 return err
22900 }
22901
22902 return nil
22903}
22904
22905func DecodeOxmIdTunMetadata14(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata14, error) {
22906 _oxmidtunmetadata14 := &OxmIdTunMetadata14{OxmId: parent}
22907 return _oxmidtunmetadata14, nil
22908}
22909
22910func NewOxmIdTunMetadata14() *OxmIdTunMetadata14 {
22911 obj := &OxmIdTunMetadata14{
22912 OxmId: NewOxmId(93308),
22913 }
22914 return obj
22915}
22916func (self *OxmIdTunMetadata14) GetOXMName() string {
22917 return "tun_metadata14"
22918}
22919
22920func (self *OxmIdTunMetadata14) MarshalJSON() ([]byte, error) {
22921 if self.TypeLen == 0 {
22922 return []byte("\"\""), nil
22923 } else {
22924 return []byte("\"" + self.GetOXMName() + "\""), nil
22925 }
22926}
22927
22928type OxmIdTunMetadata14Masked struct {
22929 *OxmId
22930}
22931
22932type IOxmIdTunMetadata14Masked interface {
22933 IOxmId
22934}
22935
22936func (self *OxmIdTunMetadata14Masked) Serialize(encoder *goloxi.Encoder) error {
22937 if err := self.OxmId.Serialize(encoder); err != nil {
22938 return err
22939 }
22940
22941 return nil
22942}
22943
22944func DecodeOxmIdTunMetadata14Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata14Masked, error) {
22945 _oxmidtunmetadata14masked := &OxmIdTunMetadata14Masked{OxmId: parent}
22946 return _oxmidtunmetadata14masked, nil
22947}
22948
22949func NewOxmIdTunMetadata14Masked() *OxmIdTunMetadata14Masked {
22950 obj := &OxmIdTunMetadata14Masked{
22951 OxmId: NewOxmId(93688),
22952 }
22953 return obj
22954}
22955func (self *OxmIdTunMetadata14Masked) GetOXMName() string {
22956 return "tun_metadata14_masked"
22957}
22958
22959func (self *OxmIdTunMetadata14Masked) MarshalJSON() ([]byte, error) {
22960 if self.TypeLen == 0 {
22961 return []byte("\"\""), nil
22962 } else {
22963 return []byte("\"" + self.GetOXMName() + "\""), nil
22964 }
22965}
22966
22967type OxmIdTunMetadata15 struct {
22968 *OxmId
22969}
22970
22971type IOxmIdTunMetadata15 interface {
22972 IOxmId
22973}
22974
22975func (self *OxmIdTunMetadata15) Serialize(encoder *goloxi.Encoder) error {
22976 if err := self.OxmId.Serialize(encoder); err != nil {
22977 return err
22978 }
22979
22980 return nil
22981}
22982
22983func DecodeOxmIdTunMetadata15(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata15, error) {
22984 _oxmidtunmetadata15 := &OxmIdTunMetadata15{OxmId: parent}
22985 return _oxmidtunmetadata15, nil
22986}
22987
22988func NewOxmIdTunMetadata15() *OxmIdTunMetadata15 {
22989 obj := &OxmIdTunMetadata15{
22990 OxmId: NewOxmId(93820),
22991 }
22992 return obj
22993}
22994func (self *OxmIdTunMetadata15) GetOXMName() string {
22995 return "tun_metadata15"
22996}
22997
22998func (self *OxmIdTunMetadata15) MarshalJSON() ([]byte, error) {
22999 if self.TypeLen == 0 {
23000 return []byte("\"\""), nil
23001 } else {
23002 return []byte("\"" + self.GetOXMName() + "\""), nil
23003 }
23004}
23005
23006type OxmIdTunMetadata15Masked struct {
23007 *OxmId
23008}
23009
23010type IOxmIdTunMetadata15Masked interface {
23011 IOxmId
23012}
23013
23014func (self *OxmIdTunMetadata15Masked) Serialize(encoder *goloxi.Encoder) error {
23015 if err := self.OxmId.Serialize(encoder); err != nil {
23016 return err
23017 }
23018
23019 return nil
23020}
23021
23022func DecodeOxmIdTunMetadata15Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata15Masked, error) {
23023 _oxmidtunmetadata15masked := &OxmIdTunMetadata15Masked{OxmId: parent}
23024 return _oxmidtunmetadata15masked, nil
23025}
23026
23027func NewOxmIdTunMetadata15Masked() *OxmIdTunMetadata15Masked {
23028 obj := &OxmIdTunMetadata15Masked{
23029 OxmId: NewOxmId(94200),
23030 }
23031 return obj
23032}
23033func (self *OxmIdTunMetadata15Masked) GetOXMName() string {
23034 return "tun_metadata15_masked"
23035}
23036
23037func (self *OxmIdTunMetadata15Masked) MarshalJSON() ([]byte, error) {
23038 if self.TypeLen == 0 {
23039 return []byte("\"\""), nil
23040 } else {
23041 return []byte("\"" + self.GetOXMName() + "\""), nil
23042 }
23043}
23044
23045type OxmIdTunMetadata16 struct {
23046 *OxmId
23047}
23048
23049type IOxmIdTunMetadata16 interface {
23050 IOxmId
23051}
23052
23053func (self *OxmIdTunMetadata16) Serialize(encoder *goloxi.Encoder) error {
23054 if err := self.OxmId.Serialize(encoder); err != nil {
23055 return err
23056 }
23057
23058 return nil
23059}
23060
23061func DecodeOxmIdTunMetadata16(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata16, error) {
23062 _oxmidtunmetadata16 := &OxmIdTunMetadata16{OxmId: parent}
23063 return _oxmidtunmetadata16, nil
23064}
23065
23066func NewOxmIdTunMetadata16() *OxmIdTunMetadata16 {
23067 obj := &OxmIdTunMetadata16{
23068 OxmId: NewOxmId(94332),
23069 }
23070 return obj
23071}
23072func (self *OxmIdTunMetadata16) GetOXMName() string {
23073 return "tun_metadata16"
23074}
23075
23076func (self *OxmIdTunMetadata16) MarshalJSON() ([]byte, error) {
23077 if self.TypeLen == 0 {
23078 return []byte("\"\""), nil
23079 } else {
23080 return []byte("\"" + self.GetOXMName() + "\""), nil
23081 }
23082}
23083
23084type OxmIdTunMetadata16Masked struct {
23085 *OxmId
23086}
23087
23088type IOxmIdTunMetadata16Masked interface {
23089 IOxmId
23090}
23091
23092func (self *OxmIdTunMetadata16Masked) Serialize(encoder *goloxi.Encoder) error {
23093 if err := self.OxmId.Serialize(encoder); err != nil {
23094 return err
23095 }
23096
23097 return nil
23098}
23099
23100func DecodeOxmIdTunMetadata16Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata16Masked, error) {
23101 _oxmidtunmetadata16masked := &OxmIdTunMetadata16Masked{OxmId: parent}
23102 return _oxmidtunmetadata16masked, nil
23103}
23104
23105func NewOxmIdTunMetadata16Masked() *OxmIdTunMetadata16Masked {
23106 obj := &OxmIdTunMetadata16Masked{
23107 OxmId: NewOxmId(94712),
23108 }
23109 return obj
23110}
23111func (self *OxmIdTunMetadata16Masked) GetOXMName() string {
23112 return "tun_metadata16_masked"
23113}
23114
23115func (self *OxmIdTunMetadata16Masked) MarshalJSON() ([]byte, error) {
23116 if self.TypeLen == 0 {
23117 return []byte("\"\""), nil
23118 } else {
23119 return []byte("\"" + self.GetOXMName() + "\""), nil
23120 }
23121}
23122
23123type OxmIdTunMetadata17 struct {
23124 *OxmId
23125}
23126
23127type IOxmIdTunMetadata17 interface {
23128 IOxmId
23129}
23130
23131func (self *OxmIdTunMetadata17) Serialize(encoder *goloxi.Encoder) error {
23132 if err := self.OxmId.Serialize(encoder); err != nil {
23133 return err
23134 }
23135
23136 return nil
23137}
23138
23139func DecodeOxmIdTunMetadata17(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata17, error) {
23140 _oxmidtunmetadata17 := &OxmIdTunMetadata17{OxmId: parent}
23141 return _oxmidtunmetadata17, nil
23142}
23143
23144func NewOxmIdTunMetadata17() *OxmIdTunMetadata17 {
23145 obj := &OxmIdTunMetadata17{
23146 OxmId: NewOxmId(94844),
23147 }
23148 return obj
23149}
23150func (self *OxmIdTunMetadata17) GetOXMName() string {
23151 return "tun_metadata17"
23152}
23153
23154func (self *OxmIdTunMetadata17) MarshalJSON() ([]byte, error) {
23155 if self.TypeLen == 0 {
23156 return []byte("\"\""), nil
23157 } else {
23158 return []byte("\"" + self.GetOXMName() + "\""), nil
23159 }
23160}
23161
23162type OxmIdTunMetadata17Masked struct {
23163 *OxmId
23164}
23165
23166type IOxmIdTunMetadata17Masked interface {
23167 IOxmId
23168}
23169
23170func (self *OxmIdTunMetadata17Masked) Serialize(encoder *goloxi.Encoder) error {
23171 if err := self.OxmId.Serialize(encoder); err != nil {
23172 return err
23173 }
23174
23175 return nil
23176}
23177
23178func DecodeOxmIdTunMetadata17Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata17Masked, error) {
23179 _oxmidtunmetadata17masked := &OxmIdTunMetadata17Masked{OxmId: parent}
23180 return _oxmidtunmetadata17masked, nil
23181}
23182
23183func NewOxmIdTunMetadata17Masked() *OxmIdTunMetadata17Masked {
23184 obj := &OxmIdTunMetadata17Masked{
23185 OxmId: NewOxmId(95224),
23186 }
23187 return obj
23188}
23189func (self *OxmIdTunMetadata17Masked) GetOXMName() string {
23190 return "tun_metadata17_masked"
23191}
23192
23193func (self *OxmIdTunMetadata17Masked) MarshalJSON() ([]byte, error) {
23194 if self.TypeLen == 0 {
23195 return []byte("\"\""), nil
23196 } else {
23197 return []byte("\"" + self.GetOXMName() + "\""), nil
23198 }
23199}
23200
23201type OxmIdTunMetadata18 struct {
23202 *OxmId
23203}
23204
23205type IOxmIdTunMetadata18 interface {
23206 IOxmId
23207}
23208
23209func (self *OxmIdTunMetadata18) Serialize(encoder *goloxi.Encoder) error {
23210 if err := self.OxmId.Serialize(encoder); err != nil {
23211 return err
23212 }
23213
23214 return nil
23215}
23216
23217func DecodeOxmIdTunMetadata18(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata18, error) {
23218 _oxmidtunmetadata18 := &OxmIdTunMetadata18{OxmId: parent}
23219 return _oxmidtunmetadata18, nil
23220}
23221
23222func NewOxmIdTunMetadata18() *OxmIdTunMetadata18 {
23223 obj := &OxmIdTunMetadata18{
23224 OxmId: NewOxmId(95356),
23225 }
23226 return obj
23227}
23228func (self *OxmIdTunMetadata18) GetOXMName() string {
23229 return "tun_metadata18"
23230}
23231
23232func (self *OxmIdTunMetadata18) MarshalJSON() ([]byte, error) {
23233 if self.TypeLen == 0 {
23234 return []byte("\"\""), nil
23235 } else {
23236 return []byte("\"" + self.GetOXMName() + "\""), nil
23237 }
23238}
23239
23240type OxmIdTunMetadata18Masked struct {
23241 *OxmId
23242}
23243
23244type IOxmIdTunMetadata18Masked interface {
23245 IOxmId
23246}
23247
23248func (self *OxmIdTunMetadata18Masked) Serialize(encoder *goloxi.Encoder) error {
23249 if err := self.OxmId.Serialize(encoder); err != nil {
23250 return err
23251 }
23252
23253 return nil
23254}
23255
23256func DecodeOxmIdTunMetadata18Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata18Masked, error) {
23257 _oxmidtunmetadata18masked := &OxmIdTunMetadata18Masked{OxmId: parent}
23258 return _oxmidtunmetadata18masked, nil
23259}
23260
23261func NewOxmIdTunMetadata18Masked() *OxmIdTunMetadata18Masked {
23262 obj := &OxmIdTunMetadata18Masked{
23263 OxmId: NewOxmId(95736),
23264 }
23265 return obj
23266}
23267func (self *OxmIdTunMetadata18Masked) GetOXMName() string {
23268 return "tun_metadata18_masked"
23269}
23270
23271func (self *OxmIdTunMetadata18Masked) MarshalJSON() ([]byte, error) {
23272 if self.TypeLen == 0 {
23273 return []byte("\"\""), nil
23274 } else {
23275 return []byte("\"" + self.GetOXMName() + "\""), nil
23276 }
23277}
23278
23279type OxmIdTunMetadata19 struct {
23280 *OxmId
23281}
23282
23283type IOxmIdTunMetadata19 interface {
23284 IOxmId
23285}
23286
23287func (self *OxmIdTunMetadata19) Serialize(encoder *goloxi.Encoder) error {
23288 if err := self.OxmId.Serialize(encoder); err != nil {
23289 return err
23290 }
23291
23292 return nil
23293}
23294
23295func DecodeOxmIdTunMetadata19(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata19, error) {
23296 _oxmidtunmetadata19 := &OxmIdTunMetadata19{OxmId: parent}
23297 return _oxmidtunmetadata19, nil
23298}
23299
23300func NewOxmIdTunMetadata19() *OxmIdTunMetadata19 {
23301 obj := &OxmIdTunMetadata19{
23302 OxmId: NewOxmId(95868),
23303 }
23304 return obj
23305}
23306func (self *OxmIdTunMetadata19) GetOXMName() string {
23307 return "tun_metadata19"
23308}
23309
23310func (self *OxmIdTunMetadata19) MarshalJSON() ([]byte, error) {
23311 if self.TypeLen == 0 {
23312 return []byte("\"\""), nil
23313 } else {
23314 return []byte("\"" + self.GetOXMName() + "\""), nil
23315 }
23316}
23317
23318type OxmIdTunMetadata19Masked struct {
23319 *OxmId
23320}
23321
23322type IOxmIdTunMetadata19Masked interface {
23323 IOxmId
23324}
23325
23326func (self *OxmIdTunMetadata19Masked) Serialize(encoder *goloxi.Encoder) error {
23327 if err := self.OxmId.Serialize(encoder); err != nil {
23328 return err
23329 }
23330
23331 return nil
23332}
23333
23334func DecodeOxmIdTunMetadata19Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata19Masked, error) {
23335 _oxmidtunmetadata19masked := &OxmIdTunMetadata19Masked{OxmId: parent}
23336 return _oxmidtunmetadata19masked, nil
23337}
23338
23339func NewOxmIdTunMetadata19Masked() *OxmIdTunMetadata19Masked {
23340 obj := &OxmIdTunMetadata19Masked{
23341 OxmId: NewOxmId(96248),
23342 }
23343 return obj
23344}
23345func (self *OxmIdTunMetadata19Masked) GetOXMName() string {
23346 return "tun_metadata19_masked"
23347}
23348
23349func (self *OxmIdTunMetadata19Masked) MarshalJSON() ([]byte, error) {
23350 if self.TypeLen == 0 {
23351 return []byte("\"\""), nil
23352 } else {
23353 return []byte("\"" + self.GetOXMName() + "\""), nil
23354 }
23355}
23356
23357type OxmIdTunMetadata1Masked struct {
23358 *OxmId
23359}
23360
23361type IOxmIdTunMetadata1Masked interface {
23362 IOxmId
23363}
23364
23365func (self *OxmIdTunMetadata1Masked) Serialize(encoder *goloxi.Encoder) error {
23366 if err := self.OxmId.Serialize(encoder); err != nil {
23367 return err
23368 }
23369
23370 return nil
23371}
23372
23373func DecodeOxmIdTunMetadata1Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata1Masked, error) {
23374 _oxmidtunmetadata1masked := &OxmIdTunMetadata1Masked{OxmId: parent}
23375 return _oxmidtunmetadata1masked, nil
23376}
23377
23378func NewOxmIdTunMetadata1Masked() *OxmIdTunMetadata1Masked {
23379 obj := &OxmIdTunMetadata1Masked{
23380 OxmId: NewOxmId(87032),
23381 }
23382 return obj
23383}
23384func (self *OxmIdTunMetadata1Masked) GetOXMName() string {
23385 return "tun_metadata1_masked"
23386}
23387
23388func (self *OxmIdTunMetadata1Masked) MarshalJSON() ([]byte, error) {
23389 if self.TypeLen == 0 {
23390 return []byte("\"\""), nil
23391 } else {
23392 return []byte("\"" + self.GetOXMName() + "\""), nil
23393 }
23394}
23395
23396type OxmIdTunMetadata2 struct {
23397 *OxmId
23398}
23399
23400type IOxmIdTunMetadata2 interface {
23401 IOxmId
23402}
23403
23404func (self *OxmIdTunMetadata2) Serialize(encoder *goloxi.Encoder) error {
23405 if err := self.OxmId.Serialize(encoder); err != nil {
23406 return err
23407 }
23408
23409 return nil
23410}
23411
23412func DecodeOxmIdTunMetadata2(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata2, error) {
23413 _oxmidtunmetadata2 := &OxmIdTunMetadata2{OxmId: parent}
23414 return _oxmidtunmetadata2, nil
23415}
23416
23417func NewOxmIdTunMetadata2() *OxmIdTunMetadata2 {
23418 obj := &OxmIdTunMetadata2{
23419 OxmId: NewOxmId(87164),
23420 }
23421 return obj
23422}
23423func (self *OxmIdTunMetadata2) GetOXMName() string {
23424 return "tun_metadata2"
23425}
23426
23427func (self *OxmIdTunMetadata2) MarshalJSON() ([]byte, error) {
23428 if self.TypeLen == 0 {
23429 return []byte("\"\""), nil
23430 } else {
23431 return []byte("\"" + self.GetOXMName() + "\""), nil
23432 }
23433}
23434
23435type OxmIdTunMetadata20 struct {
23436 *OxmId
23437}
23438
23439type IOxmIdTunMetadata20 interface {
23440 IOxmId
23441}
23442
23443func (self *OxmIdTunMetadata20) Serialize(encoder *goloxi.Encoder) error {
23444 if err := self.OxmId.Serialize(encoder); err != nil {
23445 return err
23446 }
23447
23448 return nil
23449}
23450
23451func DecodeOxmIdTunMetadata20(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata20, error) {
23452 _oxmidtunmetadata20 := &OxmIdTunMetadata20{OxmId: parent}
23453 return _oxmidtunmetadata20, nil
23454}
23455
23456func NewOxmIdTunMetadata20() *OxmIdTunMetadata20 {
23457 obj := &OxmIdTunMetadata20{
23458 OxmId: NewOxmId(96380),
23459 }
23460 return obj
23461}
23462func (self *OxmIdTunMetadata20) GetOXMName() string {
23463 return "tun_metadata20"
23464}
23465
23466func (self *OxmIdTunMetadata20) MarshalJSON() ([]byte, error) {
23467 if self.TypeLen == 0 {
23468 return []byte("\"\""), nil
23469 } else {
23470 return []byte("\"" + self.GetOXMName() + "\""), nil
23471 }
23472}
23473
23474type OxmIdTunMetadata20Masked struct {
23475 *OxmId
23476}
23477
23478type IOxmIdTunMetadata20Masked interface {
23479 IOxmId
23480}
23481
23482func (self *OxmIdTunMetadata20Masked) Serialize(encoder *goloxi.Encoder) error {
23483 if err := self.OxmId.Serialize(encoder); err != nil {
23484 return err
23485 }
23486
23487 return nil
23488}
23489
23490func DecodeOxmIdTunMetadata20Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata20Masked, error) {
23491 _oxmidtunmetadata20masked := &OxmIdTunMetadata20Masked{OxmId: parent}
23492 return _oxmidtunmetadata20masked, nil
23493}
23494
23495func NewOxmIdTunMetadata20Masked() *OxmIdTunMetadata20Masked {
23496 obj := &OxmIdTunMetadata20Masked{
23497 OxmId: NewOxmId(96760),
23498 }
23499 return obj
23500}
23501func (self *OxmIdTunMetadata20Masked) GetOXMName() string {
23502 return "tun_metadata20_masked"
23503}
23504
23505func (self *OxmIdTunMetadata20Masked) MarshalJSON() ([]byte, error) {
23506 if self.TypeLen == 0 {
23507 return []byte("\"\""), nil
23508 } else {
23509 return []byte("\"" + self.GetOXMName() + "\""), nil
23510 }
23511}
23512
23513type OxmIdTunMetadata21 struct {
23514 *OxmId
23515}
23516
23517type IOxmIdTunMetadata21 interface {
23518 IOxmId
23519}
23520
23521func (self *OxmIdTunMetadata21) Serialize(encoder *goloxi.Encoder) error {
23522 if err := self.OxmId.Serialize(encoder); err != nil {
23523 return err
23524 }
23525
23526 return nil
23527}
23528
23529func DecodeOxmIdTunMetadata21(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata21, error) {
23530 _oxmidtunmetadata21 := &OxmIdTunMetadata21{OxmId: parent}
23531 return _oxmidtunmetadata21, nil
23532}
23533
23534func NewOxmIdTunMetadata21() *OxmIdTunMetadata21 {
23535 obj := &OxmIdTunMetadata21{
23536 OxmId: NewOxmId(96892),
23537 }
23538 return obj
23539}
23540func (self *OxmIdTunMetadata21) GetOXMName() string {
23541 return "tun_metadata21"
23542}
23543
23544func (self *OxmIdTunMetadata21) MarshalJSON() ([]byte, error) {
23545 if self.TypeLen == 0 {
23546 return []byte("\"\""), nil
23547 } else {
23548 return []byte("\"" + self.GetOXMName() + "\""), nil
23549 }
23550}
23551
23552type OxmIdTunMetadata21Masked struct {
23553 *OxmId
23554}
23555
23556type IOxmIdTunMetadata21Masked interface {
23557 IOxmId
23558}
23559
23560func (self *OxmIdTunMetadata21Masked) Serialize(encoder *goloxi.Encoder) error {
23561 if err := self.OxmId.Serialize(encoder); err != nil {
23562 return err
23563 }
23564
23565 return nil
23566}
23567
23568func DecodeOxmIdTunMetadata21Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata21Masked, error) {
23569 _oxmidtunmetadata21masked := &OxmIdTunMetadata21Masked{OxmId: parent}
23570 return _oxmidtunmetadata21masked, nil
23571}
23572
23573func NewOxmIdTunMetadata21Masked() *OxmIdTunMetadata21Masked {
23574 obj := &OxmIdTunMetadata21Masked{
23575 OxmId: NewOxmId(97272),
23576 }
23577 return obj
23578}
23579func (self *OxmIdTunMetadata21Masked) GetOXMName() string {
23580 return "tun_metadata21_masked"
23581}
23582
23583func (self *OxmIdTunMetadata21Masked) MarshalJSON() ([]byte, error) {
23584 if self.TypeLen == 0 {
23585 return []byte("\"\""), nil
23586 } else {
23587 return []byte("\"" + self.GetOXMName() + "\""), nil
23588 }
23589}
23590
23591type OxmIdTunMetadata22 struct {
23592 *OxmId
23593}
23594
23595type IOxmIdTunMetadata22 interface {
23596 IOxmId
23597}
23598
23599func (self *OxmIdTunMetadata22) Serialize(encoder *goloxi.Encoder) error {
23600 if err := self.OxmId.Serialize(encoder); err != nil {
23601 return err
23602 }
23603
23604 return nil
23605}
23606
23607func DecodeOxmIdTunMetadata22(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata22, error) {
23608 _oxmidtunmetadata22 := &OxmIdTunMetadata22{OxmId: parent}
23609 return _oxmidtunmetadata22, nil
23610}
23611
23612func NewOxmIdTunMetadata22() *OxmIdTunMetadata22 {
23613 obj := &OxmIdTunMetadata22{
23614 OxmId: NewOxmId(97404),
23615 }
23616 return obj
23617}
23618func (self *OxmIdTunMetadata22) GetOXMName() string {
23619 return "tun_metadata22"
23620}
23621
23622func (self *OxmIdTunMetadata22) MarshalJSON() ([]byte, error) {
23623 if self.TypeLen == 0 {
23624 return []byte("\"\""), nil
23625 } else {
23626 return []byte("\"" + self.GetOXMName() + "\""), nil
23627 }
23628}
23629
23630type OxmIdTunMetadata22Masked struct {
23631 *OxmId
23632}
23633
23634type IOxmIdTunMetadata22Masked interface {
23635 IOxmId
23636}
23637
23638func (self *OxmIdTunMetadata22Masked) Serialize(encoder *goloxi.Encoder) error {
23639 if err := self.OxmId.Serialize(encoder); err != nil {
23640 return err
23641 }
23642
23643 return nil
23644}
23645
23646func DecodeOxmIdTunMetadata22Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata22Masked, error) {
23647 _oxmidtunmetadata22masked := &OxmIdTunMetadata22Masked{OxmId: parent}
23648 return _oxmidtunmetadata22masked, nil
23649}
23650
23651func NewOxmIdTunMetadata22Masked() *OxmIdTunMetadata22Masked {
23652 obj := &OxmIdTunMetadata22Masked{
23653 OxmId: NewOxmId(97784),
23654 }
23655 return obj
23656}
23657func (self *OxmIdTunMetadata22Masked) GetOXMName() string {
23658 return "tun_metadata22_masked"
23659}
23660
23661func (self *OxmIdTunMetadata22Masked) MarshalJSON() ([]byte, error) {
23662 if self.TypeLen == 0 {
23663 return []byte("\"\""), nil
23664 } else {
23665 return []byte("\"" + self.GetOXMName() + "\""), nil
23666 }
23667}
23668
23669type OxmIdTunMetadata23 struct {
23670 *OxmId
23671}
23672
23673type IOxmIdTunMetadata23 interface {
23674 IOxmId
23675}
23676
23677func (self *OxmIdTunMetadata23) Serialize(encoder *goloxi.Encoder) error {
23678 if err := self.OxmId.Serialize(encoder); err != nil {
23679 return err
23680 }
23681
23682 return nil
23683}
23684
23685func DecodeOxmIdTunMetadata23(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata23, error) {
23686 _oxmidtunmetadata23 := &OxmIdTunMetadata23{OxmId: parent}
23687 return _oxmidtunmetadata23, nil
23688}
23689
23690func NewOxmIdTunMetadata23() *OxmIdTunMetadata23 {
23691 obj := &OxmIdTunMetadata23{
23692 OxmId: NewOxmId(97916),
23693 }
23694 return obj
23695}
23696func (self *OxmIdTunMetadata23) GetOXMName() string {
23697 return "tun_metadata23"
23698}
23699
23700func (self *OxmIdTunMetadata23) MarshalJSON() ([]byte, error) {
23701 if self.TypeLen == 0 {
23702 return []byte("\"\""), nil
23703 } else {
23704 return []byte("\"" + self.GetOXMName() + "\""), nil
23705 }
23706}
23707
23708type OxmIdTunMetadata23Masked struct {
23709 *OxmId
23710}
23711
23712type IOxmIdTunMetadata23Masked interface {
23713 IOxmId
23714}
23715
23716func (self *OxmIdTunMetadata23Masked) Serialize(encoder *goloxi.Encoder) error {
23717 if err := self.OxmId.Serialize(encoder); err != nil {
23718 return err
23719 }
23720
23721 return nil
23722}
23723
23724func DecodeOxmIdTunMetadata23Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata23Masked, error) {
23725 _oxmidtunmetadata23masked := &OxmIdTunMetadata23Masked{OxmId: parent}
23726 return _oxmidtunmetadata23masked, nil
23727}
23728
23729func NewOxmIdTunMetadata23Masked() *OxmIdTunMetadata23Masked {
23730 obj := &OxmIdTunMetadata23Masked{
23731 OxmId: NewOxmId(98296),
23732 }
23733 return obj
23734}
23735func (self *OxmIdTunMetadata23Masked) GetOXMName() string {
23736 return "tun_metadata23_masked"
23737}
23738
23739func (self *OxmIdTunMetadata23Masked) MarshalJSON() ([]byte, error) {
23740 if self.TypeLen == 0 {
23741 return []byte("\"\""), nil
23742 } else {
23743 return []byte("\"" + self.GetOXMName() + "\""), nil
23744 }
23745}
23746
23747type OxmIdTunMetadata24 struct {
23748 *OxmId
23749}
23750
23751type IOxmIdTunMetadata24 interface {
23752 IOxmId
23753}
23754
23755func (self *OxmIdTunMetadata24) Serialize(encoder *goloxi.Encoder) error {
23756 if err := self.OxmId.Serialize(encoder); err != nil {
23757 return err
23758 }
23759
23760 return nil
23761}
23762
23763func DecodeOxmIdTunMetadata24(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata24, error) {
23764 _oxmidtunmetadata24 := &OxmIdTunMetadata24{OxmId: parent}
23765 return _oxmidtunmetadata24, nil
23766}
23767
23768func NewOxmIdTunMetadata24() *OxmIdTunMetadata24 {
23769 obj := &OxmIdTunMetadata24{
23770 OxmId: NewOxmId(98428),
23771 }
23772 return obj
23773}
23774func (self *OxmIdTunMetadata24) GetOXMName() string {
23775 return "tun_metadata24"
23776}
23777
23778func (self *OxmIdTunMetadata24) MarshalJSON() ([]byte, error) {
23779 if self.TypeLen == 0 {
23780 return []byte("\"\""), nil
23781 } else {
23782 return []byte("\"" + self.GetOXMName() + "\""), nil
23783 }
23784}
23785
23786type OxmIdTunMetadata24Masked struct {
23787 *OxmId
23788}
23789
23790type IOxmIdTunMetadata24Masked interface {
23791 IOxmId
23792}
23793
23794func (self *OxmIdTunMetadata24Masked) Serialize(encoder *goloxi.Encoder) error {
23795 if err := self.OxmId.Serialize(encoder); err != nil {
23796 return err
23797 }
23798
23799 return nil
23800}
23801
23802func DecodeOxmIdTunMetadata24Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata24Masked, error) {
23803 _oxmidtunmetadata24masked := &OxmIdTunMetadata24Masked{OxmId: parent}
23804 return _oxmidtunmetadata24masked, nil
23805}
23806
23807func NewOxmIdTunMetadata24Masked() *OxmIdTunMetadata24Masked {
23808 obj := &OxmIdTunMetadata24Masked{
23809 OxmId: NewOxmId(98808),
23810 }
23811 return obj
23812}
23813func (self *OxmIdTunMetadata24Masked) GetOXMName() string {
23814 return "tun_metadata24_masked"
23815}
23816
23817func (self *OxmIdTunMetadata24Masked) MarshalJSON() ([]byte, error) {
23818 if self.TypeLen == 0 {
23819 return []byte("\"\""), nil
23820 } else {
23821 return []byte("\"" + self.GetOXMName() + "\""), nil
23822 }
23823}
23824
23825type OxmIdTunMetadata25 struct {
23826 *OxmId
23827}
23828
23829type IOxmIdTunMetadata25 interface {
23830 IOxmId
23831}
23832
23833func (self *OxmIdTunMetadata25) Serialize(encoder *goloxi.Encoder) error {
23834 if err := self.OxmId.Serialize(encoder); err != nil {
23835 return err
23836 }
23837
23838 return nil
23839}
23840
23841func DecodeOxmIdTunMetadata25(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata25, error) {
23842 _oxmidtunmetadata25 := &OxmIdTunMetadata25{OxmId: parent}
23843 return _oxmidtunmetadata25, nil
23844}
23845
23846func NewOxmIdTunMetadata25() *OxmIdTunMetadata25 {
23847 obj := &OxmIdTunMetadata25{
23848 OxmId: NewOxmId(98940),
23849 }
23850 return obj
23851}
23852func (self *OxmIdTunMetadata25) GetOXMName() string {
23853 return "tun_metadata25"
23854}
23855
23856func (self *OxmIdTunMetadata25) MarshalJSON() ([]byte, error) {
23857 if self.TypeLen == 0 {
23858 return []byte("\"\""), nil
23859 } else {
23860 return []byte("\"" + self.GetOXMName() + "\""), nil
23861 }
23862}
23863
23864type OxmIdTunMetadata25Masked struct {
23865 *OxmId
23866}
23867
23868type IOxmIdTunMetadata25Masked interface {
23869 IOxmId
23870}
23871
23872func (self *OxmIdTunMetadata25Masked) Serialize(encoder *goloxi.Encoder) error {
23873 if err := self.OxmId.Serialize(encoder); err != nil {
23874 return err
23875 }
23876
23877 return nil
23878}
23879
23880func DecodeOxmIdTunMetadata25Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata25Masked, error) {
23881 _oxmidtunmetadata25masked := &OxmIdTunMetadata25Masked{OxmId: parent}
23882 return _oxmidtunmetadata25masked, nil
23883}
23884
23885func NewOxmIdTunMetadata25Masked() *OxmIdTunMetadata25Masked {
23886 obj := &OxmIdTunMetadata25Masked{
23887 OxmId: NewOxmId(99320),
23888 }
23889 return obj
23890}
23891func (self *OxmIdTunMetadata25Masked) GetOXMName() string {
23892 return "tun_metadata25_masked"
23893}
23894
23895func (self *OxmIdTunMetadata25Masked) MarshalJSON() ([]byte, error) {
23896 if self.TypeLen == 0 {
23897 return []byte("\"\""), nil
23898 } else {
23899 return []byte("\"" + self.GetOXMName() + "\""), nil
23900 }
23901}
23902
23903type OxmIdTunMetadata26 struct {
23904 *OxmId
23905}
23906
23907type IOxmIdTunMetadata26 interface {
23908 IOxmId
23909}
23910
23911func (self *OxmIdTunMetadata26) Serialize(encoder *goloxi.Encoder) error {
23912 if err := self.OxmId.Serialize(encoder); err != nil {
23913 return err
23914 }
23915
23916 return nil
23917}
23918
23919func DecodeOxmIdTunMetadata26(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata26, error) {
23920 _oxmidtunmetadata26 := &OxmIdTunMetadata26{OxmId: parent}
23921 return _oxmidtunmetadata26, nil
23922}
23923
23924func NewOxmIdTunMetadata26() *OxmIdTunMetadata26 {
23925 obj := &OxmIdTunMetadata26{
23926 OxmId: NewOxmId(99452),
23927 }
23928 return obj
23929}
23930func (self *OxmIdTunMetadata26) GetOXMName() string {
23931 return "tun_metadata26"
23932}
23933
23934func (self *OxmIdTunMetadata26) MarshalJSON() ([]byte, error) {
23935 if self.TypeLen == 0 {
23936 return []byte("\"\""), nil
23937 } else {
23938 return []byte("\"" + self.GetOXMName() + "\""), nil
23939 }
23940}
23941
23942type OxmIdTunMetadata26Masked struct {
23943 *OxmId
23944}
23945
23946type IOxmIdTunMetadata26Masked interface {
23947 IOxmId
23948}
23949
23950func (self *OxmIdTunMetadata26Masked) Serialize(encoder *goloxi.Encoder) error {
23951 if err := self.OxmId.Serialize(encoder); err != nil {
23952 return err
23953 }
23954
23955 return nil
23956}
23957
23958func DecodeOxmIdTunMetadata26Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata26Masked, error) {
23959 _oxmidtunmetadata26masked := &OxmIdTunMetadata26Masked{OxmId: parent}
23960 return _oxmidtunmetadata26masked, nil
23961}
23962
23963func NewOxmIdTunMetadata26Masked() *OxmIdTunMetadata26Masked {
23964 obj := &OxmIdTunMetadata26Masked{
23965 OxmId: NewOxmId(99832),
23966 }
23967 return obj
23968}
23969func (self *OxmIdTunMetadata26Masked) GetOXMName() string {
23970 return "tun_metadata26_masked"
23971}
23972
23973func (self *OxmIdTunMetadata26Masked) MarshalJSON() ([]byte, error) {
23974 if self.TypeLen == 0 {
23975 return []byte("\"\""), nil
23976 } else {
23977 return []byte("\"" + self.GetOXMName() + "\""), nil
23978 }
23979}
23980
23981type OxmIdTunMetadata27 struct {
23982 *OxmId
23983}
23984
23985type IOxmIdTunMetadata27 interface {
23986 IOxmId
23987}
23988
23989func (self *OxmIdTunMetadata27) Serialize(encoder *goloxi.Encoder) error {
23990 if err := self.OxmId.Serialize(encoder); err != nil {
23991 return err
23992 }
23993
23994 return nil
23995}
23996
23997func DecodeOxmIdTunMetadata27(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata27, error) {
23998 _oxmidtunmetadata27 := &OxmIdTunMetadata27{OxmId: parent}
23999 return _oxmidtunmetadata27, nil
24000}
24001
24002func NewOxmIdTunMetadata27() *OxmIdTunMetadata27 {
24003 obj := &OxmIdTunMetadata27{
24004 OxmId: NewOxmId(99964),
24005 }
24006 return obj
24007}
24008func (self *OxmIdTunMetadata27) GetOXMName() string {
24009 return "tun_metadata27"
24010}
24011
24012func (self *OxmIdTunMetadata27) MarshalJSON() ([]byte, error) {
24013 if self.TypeLen == 0 {
24014 return []byte("\"\""), nil
24015 } else {
24016 return []byte("\"" + self.GetOXMName() + "\""), nil
24017 }
24018}
24019
24020type OxmIdTunMetadata27Masked struct {
24021 *OxmId
24022}
24023
24024type IOxmIdTunMetadata27Masked interface {
24025 IOxmId
24026}
24027
24028func (self *OxmIdTunMetadata27Masked) Serialize(encoder *goloxi.Encoder) error {
24029 if err := self.OxmId.Serialize(encoder); err != nil {
24030 return err
24031 }
24032
24033 return nil
24034}
24035
24036func DecodeOxmIdTunMetadata27Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata27Masked, error) {
24037 _oxmidtunmetadata27masked := &OxmIdTunMetadata27Masked{OxmId: parent}
24038 return _oxmidtunmetadata27masked, nil
24039}
24040
24041func NewOxmIdTunMetadata27Masked() *OxmIdTunMetadata27Masked {
24042 obj := &OxmIdTunMetadata27Masked{
24043 OxmId: NewOxmId(100344),
24044 }
24045 return obj
24046}
24047func (self *OxmIdTunMetadata27Masked) GetOXMName() string {
24048 return "tun_metadata27_masked"
24049}
24050
24051func (self *OxmIdTunMetadata27Masked) MarshalJSON() ([]byte, error) {
24052 if self.TypeLen == 0 {
24053 return []byte("\"\""), nil
24054 } else {
24055 return []byte("\"" + self.GetOXMName() + "\""), nil
24056 }
24057}
24058
24059type OxmIdTunMetadata28 struct {
24060 *OxmId
24061}
24062
24063type IOxmIdTunMetadata28 interface {
24064 IOxmId
24065}
24066
24067func (self *OxmIdTunMetadata28) Serialize(encoder *goloxi.Encoder) error {
24068 if err := self.OxmId.Serialize(encoder); err != nil {
24069 return err
24070 }
24071
24072 return nil
24073}
24074
24075func DecodeOxmIdTunMetadata28(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata28, error) {
24076 _oxmidtunmetadata28 := &OxmIdTunMetadata28{OxmId: parent}
24077 return _oxmidtunmetadata28, nil
24078}
24079
24080func NewOxmIdTunMetadata28() *OxmIdTunMetadata28 {
24081 obj := &OxmIdTunMetadata28{
24082 OxmId: NewOxmId(100476),
24083 }
24084 return obj
24085}
24086func (self *OxmIdTunMetadata28) GetOXMName() string {
24087 return "tun_metadata28"
24088}
24089
24090func (self *OxmIdTunMetadata28) MarshalJSON() ([]byte, error) {
24091 if self.TypeLen == 0 {
24092 return []byte("\"\""), nil
24093 } else {
24094 return []byte("\"" + self.GetOXMName() + "\""), nil
24095 }
24096}
24097
24098type OxmIdTunMetadata28Masked struct {
24099 *OxmId
24100}
24101
24102type IOxmIdTunMetadata28Masked interface {
24103 IOxmId
24104}
24105
24106func (self *OxmIdTunMetadata28Masked) Serialize(encoder *goloxi.Encoder) error {
24107 if err := self.OxmId.Serialize(encoder); err != nil {
24108 return err
24109 }
24110
24111 return nil
24112}
24113
24114func DecodeOxmIdTunMetadata28Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata28Masked, error) {
24115 _oxmidtunmetadata28masked := &OxmIdTunMetadata28Masked{OxmId: parent}
24116 return _oxmidtunmetadata28masked, nil
24117}
24118
24119func NewOxmIdTunMetadata28Masked() *OxmIdTunMetadata28Masked {
24120 obj := &OxmIdTunMetadata28Masked{
24121 OxmId: NewOxmId(100856),
24122 }
24123 return obj
24124}
24125func (self *OxmIdTunMetadata28Masked) GetOXMName() string {
24126 return "tun_metadata28_masked"
24127}
24128
24129func (self *OxmIdTunMetadata28Masked) MarshalJSON() ([]byte, error) {
24130 if self.TypeLen == 0 {
24131 return []byte("\"\""), nil
24132 } else {
24133 return []byte("\"" + self.GetOXMName() + "\""), nil
24134 }
24135}
24136
24137type OxmIdTunMetadata29 struct {
24138 *OxmId
24139}
24140
24141type IOxmIdTunMetadata29 interface {
24142 IOxmId
24143}
24144
24145func (self *OxmIdTunMetadata29) Serialize(encoder *goloxi.Encoder) error {
24146 if err := self.OxmId.Serialize(encoder); err != nil {
24147 return err
24148 }
24149
24150 return nil
24151}
24152
24153func DecodeOxmIdTunMetadata29(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata29, error) {
24154 _oxmidtunmetadata29 := &OxmIdTunMetadata29{OxmId: parent}
24155 return _oxmidtunmetadata29, nil
24156}
24157
24158func NewOxmIdTunMetadata29() *OxmIdTunMetadata29 {
24159 obj := &OxmIdTunMetadata29{
24160 OxmId: NewOxmId(100988),
24161 }
24162 return obj
24163}
24164func (self *OxmIdTunMetadata29) GetOXMName() string {
24165 return "tun_metadata29"
24166}
24167
24168func (self *OxmIdTunMetadata29) MarshalJSON() ([]byte, error) {
24169 if self.TypeLen == 0 {
24170 return []byte("\"\""), nil
24171 } else {
24172 return []byte("\"" + self.GetOXMName() + "\""), nil
24173 }
24174}
24175
24176type OxmIdTunMetadata29Masked struct {
24177 *OxmId
24178}
24179
24180type IOxmIdTunMetadata29Masked interface {
24181 IOxmId
24182}
24183
24184func (self *OxmIdTunMetadata29Masked) Serialize(encoder *goloxi.Encoder) error {
24185 if err := self.OxmId.Serialize(encoder); err != nil {
24186 return err
24187 }
24188
24189 return nil
24190}
24191
24192func DecodeOxmIdTunMetadata29Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata29Masked, error) {
24193 _oxmidtunmetadata29masked := &OxmIdTunMetadata29Masked{OxmId: parent}
24194 return _oxmidtunmetadata29masked, nil
24195}
24196
24197func NewOxmIdTunMetadata29Masked() *OxmIdTunMetadata29Masked {
24198 obj := &OxmIdTunMetadata29Masked{
24199 OxmId: NewOxmId(101368),
24200 }
24201 return obj
24202}
24203func (self *OxmIdTunMetadata29Masked) GetOXMName() string {
24204 return "tun_metadata29_masked"
24205}
24206
24207func (self *OxmIdTunMetadata29Masked) MarshalJSON() ([]byte, error) {
24208 if self.TypeLen == 0 {
24209 return []byte("\"\""), nil
24210 } else {
24211 return []byte("\"" + self.GetOXMName() + "\""), nil
24212 }
24213}
24214
24215type OxmIdTunMetadata2Masked struct {
24216 *OxmId
24217}
24218
24219type IOxmIdTunMetadata2Masked interface {
24220 IOxmId
24221}
24222
24223func (self *OxmIdTunMetadata2Masked) Serialize(encoder *goloxi.Encoder) error {
24224 if err := self.OxmId.Serialize(encoder); err != nil {
24225 return err
24226 }
24227
24228 return nil
24229}
24230
24231func DecodeOxmIdTunMetadata2Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata2Masked, error) {
24232 _oxmidtunmetadata2masked := &OxmIdTunMetadata2Masked{OxmId: parent}
24233 return _oxmidtunmetadata2masked, nil
24234}
24235
24236func NewOxmIdTunMetadata2Masked() *OxmIdTunMetadata2Masked {
24237 obj := &OxmIdTunMetadata2Masked{
24238 OxmId: NewOxmId(87544),
24239 }
24240 return obj
24241}
24242func (self *OxmIdTunMetadata2Masked) GetOXMName() string {
24243 return "tun_metadata2_masked"
24244}
24245
24246func (self *OxmIdTunMetadata2Masked) MarshalJSON() ([]byte, error) {
24247 if self.TypeLen == 0 {
24248 return []byte("\"\""), nil
24249 } else {
24250 return []byte("\"" + self.GetOXMName() + "\""), nil
24251 }
24252}
24253
24254type OxmIdTunMetadata3 struct {
24255 *OxmId
24256}
24257
24258type IOxmIdTunMetadata3 interface {
24259 IOxmId
24260}
24261
24262func (self *OxmIdTunMetadata3) Serialize(encoder *goloxi.Encoder) error {
24263 if err := self.OxmId.Serialize(encoder); err != nil {
24264 return err
24265 }
24266
24267 return nil
24268}
24269
24270func DecodeOxmIdTunMetadata3(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata3, error) {
24271 _oxmidtunmetadata3 := &OxmIdTunMetadata3{OxmId: parent}
24272 return _oxmidtunmetadata3, nil
24273}
24274
24275func NewOxmIdTunMetadata3() *OxmIdTunMetadata3 {
24276 obj := &OxmIdTunMetadata3{
24277 OxmId: NewOxmId(87676),
24278 }
24279 return obj
24280}
24281func (self *OxmIdTunMetadata3) GetOXMName() string {
24282 return "tun_metadata3"
24283}
24284
24285func (self *OxmIdTunMetadata3) MarshalJSON() ([]byte, error) {
24286 if self.TypeLen == 0 {
24287 return []byte("\"\""), nil
24288 } else {
24289 return []byte("\"" + self.GetOXMName() + "\""), nil
24290 }
24291}
24292
24293type OxmIdTunMetadata30 struct {
24294 *OxmId
24295}
24296
24297type IOxmIdTunMetadata30 interface {
24298 IOxmId
24299}
24300
24301func (self *OxmIdTunMetadata30) Serialize(encoder *goloxi.Encoder) error {
24302 if err := self.OxmId.Serialize(encoder); err != nil {
24303 return err
24304 }
24305
24306 return nil
24307}
24308
24309func DecodeOxmIdTunMetadata30(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata30, error) {
24310 _oxmidtunmetadata30 := &OxmIdTunMetadata30{OxmId: parent}
24311 return _oxmidtunmetadata30, nil
24312}
24313
24314func NewOxmIdTunMetadata30() *OxmIdTunMetadata30 {
24315 obj := &OxmIdTunMetadata30{
24316 OxmId: NewOxmId(101500),
24317 }
24318 return obj
24319}
24320func (self *OxmIdTunMetadata30) GetOXMName() string {
24321 return "tun_metadata30"
24322}
24323
24324func (self *OxmIdTunMetadata30) MarshalJSON() ([]byte, error) {
24325 if self.TypeLen == 0 {
24326 return []byte("\"\""), nil
24327 } else {
24328 return []byte("\"" + self.GetOXMName() + "\""), nil
24329 }
24330}
24331
24332type OxmIdTunMetadata30Masked struct {
24333 *OxmId
24334}
24335
24336type IOxmIdTunMetadata30Masked interface {
24337 IOxmId
24338}
24339
24340func (self *OxmIdTunMetadata30Masked) Serialize(encoder *goloxi.Encoder) error {
24341 if err := self.OxmId.Serialize(encoder); err != nil {
24342 return err
24343 }
24344
24345 return nil
24346}
24347
24348func DecodeOxmIdTunMetadata30Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata30Masked, error) {
24349 _oxmidtunmetadata30masked := &OxmIdTunMetadata30Masked{OxmId: parent}
24350 return _oxmidtunmetadata30masked, nil
24351}
24352
24353func NewOxmIdTunMetadata30Masked() *OxmIdTunMetadata30Masked {
24354 obj := &OxmIdTunMetadata30Masked{
24355 OxmId: NewOxmId(101880),
24356 }
24357 return obj
24358}
24359func (self *OxmIdTunMetadata30Masked) GetOXMName() string {
24360 return "tun_metadata30_masked"
24361}
24362
24363func (self *OxmIdTunMetadata30Masked) MarshalJSON() ([]byte, error) {
24364 if self.TypeLen == 0 {
24365 return []byte("\"\""), nil
24366 } else {
24367 return []byte("\"" + self.GetOXMName() + "\""), nil
24368 }
24369}
24370
24371type OxmIdTunMetadata31 struct {
24372 *OxmId
24373}
24374
24375type IOxmIdTunMetadata31 interface {
24376 IOxmId
24377}
24378
24379func (self *OxmIdTunMetadata31) Serialize(encoder *goloxi.Encoder) error {
24380 if err := self.OxmId.Serialize(encoder); err != nil {
24381 return err
24382 }
24383
24384 return nil
24385}
24386
24387func DecodeOxmIdTunMetadata31(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata31, error) {
24388 _oxmidtunmetadata31 := &OxmIdTunMetadata31{OxmId: parent}
24389 return _oxmidtunmetadata31, nil
24390}
24391
24392func NewOxmIdTunMetadata31() *OxmIdTunMetadata31 {
24393 obj := &OxmIdTunMetadata31{
24394 OxmId: NewOxmId(102012),
24395 }
24396 return obj
24397}
24398func (self *OxmIdTunMetadata31) GetOXMName() string {
24399 return "tun_metadata31"
24400}
24401
24402func (self *OxmIdTunMetadata31) MarshalJSON() ([]byte, error) {
24403 if self.TypeLen == 0 {
24404 return []byte("\"\""), nil
24405 } else {
24406 return []byte("\"" + self.GetOXMName() + "\""), nil
24407 }
24408}
24409
24410type OxmIdTunMetadata31Masked struct {
24411 *OxmId
24412}
24413
24414type IOxmIdTunMetadata31Masked interface {
24415 IOxmId
24416}
24417
24418func (self *OxmIdTunMetadata31Masked) Serialize(encoder *goloxi.Encoder) error {
24419 if err := self.OxmId.Serialize(encoder); err != nil {
24420 return err
24421 }
24422
24423 return nil
24424}
24425
24426func DecodeOxmIdTunMetadata31Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata31Masked, error) {
24427 _oxmidtunmetadata31masked := &OxmIdTunMetadata31Masked{OxmId: parent}
24428 return _oxmidtunmetadata31masked, nil
24429}
24430
24431func NewOxmIdTunMetadata31Masked() *OxmIdTunMetadata31Masked {
24432 obj := &OxmIdTunMetadata31Masked{
24433 OxmId: NewOxmId(102392),
24434 }
24435 return obj
24436}
24437func (self *OxmIdTunMetadata31Masked) GetOXMName() string {
24438 return "tun_metadata31_masked"
24439}
24440
24441func (self *OxmIdTunMetadata31Masked) MarshalJSON() ([]byte, error) {
24442 if self.TypeLen == 0 {
24443 return []byte("\"\""), nil
24444 } else {
24445 return []byte("\"" + self.GetOXMName() + "\""), nil
24446 }
24447}
24448
24449type OxmIdTunMetadata32 struct {
24450 *OxmId
24451}
24452
24453type IOxmIdTunMetadata32 interface {
24454 IOxmId
24455}
24456
24457func (self *OxmIdTunMetadata32) Serialize(encoder *goloxi.Encoder) error {
24458 if err := self.OxmId.Serialize(encoder); err != nil {
24459 return err
24460 }
24461
24462 return nil
24463}
24464
24465func DecodeOxmIdTunMetadata32(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata32, error) {
24466 _oxmidtunmetadata32 := &OxmIdTunMetadata32{OxmId: parent}
24467 return _oxmidtunmetadata32, nil
24468}
24469
24470func NewOxmIdTunMetadata32() *OxmIdTunMetadata32 {
24471 obj := &OxmIdTunMetadata32{
24472 OxmId: NewOxmId(102524),
24473 }
24474 return obj
24475}
24476func (self *OxmIdTunMetadata32) GetOXMName() string {
24477 return "tun_metadata32"
24478}
24479
24480func (self *OxmIdTunMetadata32) MarshalJSON() ([]byte, error) {
24481 if self.TypeLen == 0 {
24482 return []byte("\"\""), nil
24483 } else {
24484 return []byte("\"" + self.GetOXMName() + "\""), nil
24485 }
24486}
24487
24488type OxmIdTunMetadata32Masked struct {
24489 *OxmId
24490}
24491
24492type IOxmIdTunMetadata32Masked interface {
24493 IOxmId
24494}
24495
24496func (self *OxmIdTunMetadata32Masked) Serialize(encoder *goloxi.Encoder) error {
24497 if err := self.OxmId.Serialize(encoder); err != nil {
24498 return err
24499 }
24500
24501 return nil
24502}
24503
24504func DecodeOxmIdTunMetadata32Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata32Masked, error) {
24505 _oxmidtunmetadata32masked := &OxmIdTunMetadata32Masked{OxmId: parent}
24506 return _oxmidtunmetadata32masked, nil
24507}
24508
24509func NewOxmIdTunMetadata32Masked() *OxmIdTunMetadata32Masked {
24510 obj := &OxmIdTunMetadata32Masked{
24511 OxmId: NewOxmId(102904),
24512 }
24513 return obj
24514}
24515func (self *OxmIdTunMetadata32Masked) GetOXMName() string {
24516 return "tun_metadata32_masked"
24517}
24518
24519func (self *OxmIdTunMetadata32Masked) MarshalJSON() ([]byte, error) {
24520 if self.TypeLen == 0 {
24521 return []byte("\"\""), nil
24522 } else {
24523 return []byte("\"" + self.GetOXMName() + "\""), nil
24524 }
24525}
24526
24527type OxmIdTunMetadata33 struct {
24528 *OxmId
24529}
24530
24531type IOxmIdTunMetadata33 interface {
24532 IOxmId
24533}
24534
24535func (self *OxmIdTunMetadata33) Serialize(encoder *goloxi.Encoder) error {
24536 if err := self.OxmId.Serialize(encoder); err != nil {
24537 return err
24538 }
24539
24540 return nil
24541}
24542
24543func DecodeOxmIdTunMetadata33(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata33, error) {
24544 _oxmidtunmetadata33 := &OxmIdTunMetadata33{OxmId: parent}
24545 return _oxmidtunmetadata33, nil
24546}
24547
24548func NewOxmIdTunMetadata33() *OxmIdTunMetadata33 {
24549 obj := &OxmIdTunMetadata33{
24550 OxmId: NewOxmId(103036),
24551 }
24552 return obj
24553}
24554func (self *OxmIdTunMetadata33) GetOXMName() string {
24555 return "tun_metadata33"
24556}
24557
24558func (self *OxmIdTunMetadata33) MarshalJSON() ([]byte, error) {
24559 if self.TypeLen == 0 {
24560 return []byte("\"\""), nil
24561 } else {
24562 return []byte("\"" + self.GetOXMName() + "\""), nil
24563 }
24564}
24565
24566type OxmIdTunMetadata33Masked struct {
24567 *OxmId
24568}
24569
24570type IOxmIdTunMetadata33Masked interface {
24571 IOxmId
24572}
24573
24574func (self *OxmIdTunMetadata33Masked) Serialize(encoder *goloxi.Encoder) error {
24575 if err := self.OxmId.Serialize(encoder); err != nil {
24576 return err
24577 }
24578
24579 return nil
24580}
24581
24582func DecodeOxmIdTunMetadata33Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata33Masked, error) {
24583 _oxmidtunmetadata33masked := &OxmIdTunMetadata33Masked{OxmId: parent}
24584 return _oxmidtunmetadata33masked, nil
24585}
24586
24587func NewOxmIdTunMetadata33Masked() *OxmIdTunMetadata33Masked {
24588 obj := &OxmIdTunMetadata33Masked{
24589 OxmId: NewOxmId(103416),
24590 }
24591 return obj
24592}
24593func (self *OxmIdTunMetadata33Masked) GetOXMName() string {
24594 return "tun_metadata33_masked"
24595}
24596
24597func (self *OxmIdTunMetadata33Masked) MarshalJSON() ([]byte, error) {
24598 if self.TypeLen == 0 {
24599 return []byte("\"\""), nil
24600 } else {
24601 return []byte("\"" + self.GetOXMName() + "\""), nil
24602 }
24603}
24604
24605type OxmIdTunMetadata34 struct {
24606 *OxmId
24607}
24608
24609type IOxmIdTunMetadata34 interface {
24610 IOxmId
24611}
24612
24613func (self *OxmIdTunMetadata34) Serialize(encoder *goloxi.Encoder) error {
24614 if err := self.OxmId.Serialize(encoder); err != nil {
24615 return err
24616 }
24617
24618 return nil
24619}
24620
24621func DecodeOxmIdTunMetadata34(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata34, error) {
24622 _oxmidtunmetadata34 := &OxmIdTunMetadata34{OxmId: parent}
24623 return _oxmidtunmetadata34, nil
24624}
24625
24626func NewOxmIdTunMetadata34() *OxmIdTunMetadata34 {
24627 obj := &OxmIdTunMetadata34{
24628 OxmId: NewOxmId(103548),
24629 }
24630 return obj
24631}
24632func (self *OxmIdTunMetadata34) GetOXMName() string {
24633 return "tun_metadata34"
24634}
24635
24636func (self *OxmIdTunMetadata34) MarshalJSON() ([]byte, error) {
24637 if self.TypeLen == 0 {
24638 return []byte("\"\""), nil
24639 } else {
24640 return []byte("\"" + self.GetOXMName() + "\""), nil
24641 }
24642}
24643
24644type OxmIdTunMetadata34Masked struct {
24645 *OxmId
24646}
24647
24648type IOxmIdTunMetadata34Masked interface {
24649 IOxmId
24650}
24651
24652func (self *OxmIdTunMetadata34Masked) Serialize(encoder *goloxi.Encoder) error {
24653 if err := self.OxmId.Serialize(encoder); err != nil {
24654 return err
24655 }
24656
24657 return nil
24658}
24659
24660func DecodeOxmIdTunMetadata34Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata34Masked, error) {
24661 _oxmidtunmetadata34masked := &OxmIdTunMetadata34Masked{OxmId: parent}
24662 return _oxmidtunmetadata34masked, nil
24663}
24664
24665func NewOxmIdTunMetadata34Masked() *OxmIdTunMetadata34Masked {
24666 obj := &OxmIdTunMetadata34Masked{
24667 OxmId: NewOxmId(103928),
24668 }
24669 return obj
24670}
24671func (self *OxmIdTunMetadata34Masked) GetOXMName() string {
24672 return "tun_metadata34_masked"
24673}
24674
24675func (self *OxmIdTunMetadata34Masked) MarshalJSON() ([]byte, error) {
24676 if self.TypeLen == 0 {
24677 return []byte("\"\""), nil
24678 } else {
24679 return []byte("\"" + self.GetOXMName() + "\""), nil
24680 }
24681}
24682
24683type OxmIdTunMetadata35 struct {
24684 *OxmId
24685}
24686
24687type IOxmIdTunMetadata35 interface {
24688 IOxmId
24689}
24690
24691func (self *OxmIdTunMetadata35) Serialize(encoder *goloxi.Encoder) error {
24692 if err := self.OxmId.Serialize(encoder); err != nil {
24693 return err
24694 }
24695
24696 return nil
24697}
24698
24699func DecodeOxmIdTunMetadata35(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata35, error) {
24700 _oxmidtunmetadata35 := &OxmIdTunMetadata35{OxmId: parent}
24701 return _oxmidtunmetadata35, nil
24702}
24703
24704func NewOxmIdTunMetadata35() *OxmIdTunMetadata35 {
24705 obj := &OxmIdTunMetadata35{
24706 OxmId: NewOxmId(104060),
24707 }
24708 return obj
24709}
24710func (self *OxmIdTunMetadata35) GetOXMName() string {
24711 return "tun_metadata35"
24712}
24713
24714func (self *OxmIdTunMetadata35) MarshalJSON() ([]byte, error) {
24715 if self.TypeLen == 0 {
24716 return []byte("\"\""), nil
24717 } else {
24718 return []byte("\"" + self.GetOXMName() + "\""), nil
24719 }
24720}
24721
24722type OxmIdTunMetadata35Masked struct {
24723 *OxmId
24724}
24725
24726type IOxmIdTunMetadata35Masked interface {
24727 IOxmId
24728}
24729
24730func (self *OxmIdTunMetadata35Masked) Serialize(encoder *goloxi.Encoder) error {
24731 if err := self.OxmId.Serialize(encoder); err != nil {
24732 return err
24733 }
24734
24735 return nil
24736}
24737
24738func DecodeOxmIdTunMetadata35Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata35Masked, error) {
24739 _oxmidtunmetadata35masked := &OxmIdTunMetadata35Masked{OxmId: parent}
24740 return _oxmidtunmetadata35masked, nil
24741}
24742
24743func NewOxmIdTunMetadata35Masked() *OxmIdTunMetadata35Masked {
24744 obj := &OxmIdTunMetadata35Masked{
24745 OxmId: NewOxmId(104440),
24746 }
24747 return obj
24748}
24749func (self *OxmIdTunMetadata35Masked) GetOXMName() string {
24750 return "tun_metadata35_masked"
24751}
24752
24753func (self *OxmIdTunMetadata35Masked) MarshalJSON() ([]byte, error) {
24754 if self.TypeLen == 0 {
24755 return []byte("\"\""), nil
24756 } else {
24757 return []byte("\"" + self.GetOXMName() + "\""), nil
24758 }
24759}
24760
24761type OxmIdTunMetadata36 struct {
24762 *OxmId
24763}
24764
24765type IOxmIdTunMetadata36 interface {
24766 IOxmId
24767}
24768
24769func (self *OxmIdTunMetadata36) Serialize(encoder *goloxi.Encoder) error {
24770 if err := self.OxmId.Serialize(encoder); err != nil {
24771 return err
24772 }
24773
24774 return nil
24775}
24776
24777func DecodeOxmIdTunMetadata36(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata36, error) {
24778 _oxmidtunmetadata36 := &OxmIdTunMetadata36{OxmId: parent}
24779 return _oxmidtunmetadata36, nil
24780}
24781
24782func NewOxmIdTunMetadata36() *OxmIdTunMetadata36 {
24783 obj := &OxmIdTunMetadata36{
24784 OxmId: NewOxmId(104572),
24785 }
24786 return obj
24787}
24788func (self *OxmIdTunMetadata36) GetOXMName() string {
24789 return "tun_metadata36"
24790}
24791
24792func (self *OxmIdTunMetadata36) MarshalJSON() ([]byte, error) {
24793 if self.TypeLen == 0 {
24794 return []byte("\"\""), nil
24795 } else {
24796 return []byte("\"" + self.GetOXMName() + "\""), nil
24797 }
24798}
24799
24800type OxmIdTunMetadata36Masked struct {
24801 *OxmId
24802}
24803
24804type IOxmIdTunMetadata36Masked interface {
24805 IOxmId
24806}
24807
24808func (self *OxmIdTunMetadata36Masked) Serialize(encoder *goloxi.Encoder) error {
24809 if err := self.OxmId.Serialize(encoder); err != nil {
24810 return err
24811 }
24812
24813 return nil
24814}
24815
24816func DecodeOxmIdTunMetadata36Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata36Masked, error) {
24817 _oxmidtunmetadata36masked := &OxmIdTunMetadata36Masked{OxmId: parent}
24818 return _oxmidtunmetadata36masked, nil
24819}
24820
24821func NewOxmIdTunMetadata36Masked() *OxmIdTunMetadata36Masked {
24822 obj := &OxmIdTunMetadata36Masked{
24823 OxmId: NewOxmId(104952),
24824 }
24825 return obj
24826}
24827func (self *OxmIdTunMetadata36Masked) GetOXMName() string {
24828 return "tun_metadata36_masked"
24829}
24830
24831func (self *OxmIdTunMetadata36Masked) MarshalJSON() ([]byte, error) {
24832 if self.TypeLen == 0 {
24833 return []byte("\"\""), nil
24834 } else {
24835 return []byte("\"" + self.GetOXMName() + "\""), nil
24836 }
24837}
24838
24839type OxmIdTunMetadata37 struct {
24840 *OxmId
24841}
24842
24843type IOxmIdTunMetadata37 interface {
24844 IOxmId
24845}
24846
24847func (self *OxmIdTunMetadata37) Serialize(encoder *goloxi.Encoder) error {
24848 if err := self.OxmId.Serialize(encoder); err != nil {
24849 return err
24850 }
24851
24852 return nil
24853}
24854
24855func DecodeOxmIdTunMetadata37(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata37, error) {
24856 _oxmidtunmetadata37 := &OxmIdTunMetadata37{OxmId: parent}
24857 return _oxmidtunmetadata37, nil
24858}
24859
24860func NewOxmIdTunMetadata37() *OxmIdTunMetadata37 {
24861 obj := &OxmIdTunMetadata37{
24862 OxmId: NewOxmId(105084),
24863 }
24864 return obj
24865}
24866func (self *OxmIdTunMetadata37) GetOXMName() string {
24867 return "tun_metadata37"
24868}
24869
24870func (self *OxmIdTunMetadata37) MarshalJSON() ([]byte, error) {
24871 if self.TypeLen == 0 {
24872 return []byte("\"\""), nil
24873 } else {
24874 return []byte("\"" + self.GetOXMName() + "\""), nil
24875 }
24876}
24877
24878type OxmIdTunMetadata37Masked struct {
24879 *OxmId
24880}
24881
24882type IOxmIdTunMetadata37Masked interface {
24883 IOxmId
24884}
24885
24886func (self *OxmIdTunMetadata37Masked) Serialize(encoder *goloxi.Encoder) error {
24887 if err := self.OxmId.Serialize(encoder); err != nil {
24888 return err
24889 }
24890
24891 return nil
24892}
24893
24894func DecodeOxmIdTunMetadata37Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata37Masked, error) {
24895 _oxmidtunmetadata37masked := &OxmIdTunMetadata37Masked{OxmId: parent}
24896 return _oxmidtunmetadata37masked, nil
24897}
24898
24899func NewOxmIdTunMetadata37Masked() *OxmIdTunMetadata37Masked {
24900 obj := &OxmIdTunMetadata37Masked{
24901 OxmId: NewOxmId(105464),
24902 }
24903 return obj
24904}
24905func (self *OxmIdTunMetadata37Masked) GetOXMName() string {
24906 return "tun_metadata37_masked"
24907}
24908
24909func (self *OxmIdTunMetadata37Masked) MarshalJSON() ([]byte, error) {
24910 if self.TypeLen == 0 {
24911 return []byte("\"\""), nil
24912 } else {
24913 return []byte("\"" + self.GetOXMName() + "\""), nil
24914 }
24915}
24916
24917type OxmIdTunMetadata38 struct {
24918 *OxmId
24919}
24920
24921type IOxmIdTunMetadata38 interface {
24922 IOxmId
24923}
24924
24925func (self *OxmIdTunMetadata38) Serialize(encoder *goloxi.Encoder) error {
24926 if err := self.OxmId.Serialize(encoder); err != nil {
24927 return err
24928 }
24929
24930 return nil
24931}
24932
24933func DecodeOxmIdTunMetadata38(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata38, error) {
24934 _oxmidtunmetadata38 := &OxmIdTunMetadata38{OxmId: parent}
24935 return _oxmidtunmetadata38, nil
24936}
24937
24938func NewOxmIdTunMetadata38() *OxmIdTunMetadata38 {
24939 obj := &OxmIdTunMetadata38{
24940 OxmId: NewOxmId(105596),
24941 }
24942 return obj
24943}
24944func (self *OxmIdTunMetadata38) GetOXMName() string {
24945 return "tun_metadata38"
24946}
24947
24948func (self *OxmIdTunMetadata38) MarshalJSON() ([]byte, error) {
24949 if self.TypeLen == 0 {
24950 return []byte("\"\""), nil
24951 } else {
24952 return []byte("\"" + self.GetOXMName() + "\""), nil
24953 }
24954}
24955
24956type OxmIdTunMetadata38Masked struct {
24957 *OxmId
24958}
24959
24960type IOxmIdTunMetadata38Masked interface {
24961 IOxmId
24962}
24963
24964func (self *OxmIdTunMetadata38Masked) Serialize(encoder *goloxi.Encoder) error {
24965 if err := self.OxmId.Serialize(encoder); err != nil {
24966 return err
24967 }
24968
24969 return nil
24970}
24971
24972func DecodeOxmIdTunMetadata38Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata38Masked, error) {
24973 _oxmidtunmetadata38masked := &OxmIdTunMetadata38Masked{OxmId: parent}
24974 return _oxmidtunmetadata38masked, nil
24975}
24976
24977func NewOxmIdTunMetadata38Masked() *OxmIdTunMetadata38Masked {
24978 obj := &OxmIdTunMetadata38Masked{
24979 OxmId: NewOxmId(105976),
24980 }
24981 return obj
24982}
24983func (self *OxmIdTunMetadata38Masked) GetOXMName() string {
24984 return "tun_metadata38_masked"
24985}
24986
24987func (self *OxmIdTunMetadata38Masked) MarshalJSON() ([]byte, error) {
24988 if self.TypeLen == 0 {
24989 return []byte("\"\""), nil
24990 } else {
24991 return []byte("\"" + self.GetOXMName() + "\""), nil
24992 }
24993}
24994
24995type OxmIdTunMetadata39 struct {
24996 *OxmId
24997}
24998
24999type IOxmIdTunMetadata39 interface {
25000 IOxmId
25001}
25002
25003func (self *OxmIdTunMetadata39) Serialize(encoder *goloxi.Encoder) error {
25004 if err := self.OxmId.Serialize(encoder); err != nil {
25005 return err
25006 }
25007
25008 return nil
25009}
25010
25011func DecodeOxmIdTunMetadata39(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata39, error) {
25012 _oxmidtunmetadata39 := &OxmIdTunMetadata39{OxmId: parent}
25013 return _oxmidtunmetadata39, nil
25014}
25015
25016func NewOxmIdTunMetadata39() *OxmIdTunMetadata39 {
25017 obj := &OxmIdTunMetadata39{
25018 OxmId: NewOxmId(106108),
25019 }
25020 return obj
25021}
25022func (self *OxmIdTunMetadata39) GetOXMName() string {
25023 return "tun_metadata39"
25024}
25025
25026func (self *OxmIdTunMetadata39) MarshalJSON() ([]byte, error) {
25027 if self.TypeLen == 0 {
25028 return []byte("\"\""), nil
25029 } else {
25030 return []byte("\"" + self.GetOXMName() + "\""), nil
25031 }
25032}
25033
25034type OxmIdTunMetadata39Masked struct {
25035 *OxmId
25036}
25037
25038type IOxmIdTunMetadata39Masked interface {
25039 IOxmId
25040}
25041
25042func (self *OxmIdTunMetadata39Masked) Serialize(encoder *goloxi.Encoder) error {
25043 if err := self.OxmId.Serialize(encoder); err != nil {
25044 return err
25045 }
25046
25047 return nil
25048}
25049
25050func DecodeOxmIdTunMetadata39Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata39Masked, error) {
25051 _oxmidtunmetadata39masked := &OxmIdTunMetadata39Masked{OxmId: parent}
25052 return _oxmidtunmetadata39masked, nil
25053}
25054
25055func NewOxmIdTunMetadata39Masked() *OxmIdTunMetadata39Masked {
25056 obj := &OxmIdTunMetadata39Masked{
25057 OxmId: NewOxmId(106488),
25058 }
25059 return obj
25060}
25061func (self *OxmIdTunMetadata39Masked) GetOXMName() string {
25062 return "tun_metadata39_masked"
25063}
25064
25065func (self *OxmIdTunMetadata39Masked) MarshalJSON() ([]byte, error) {
25066 if self.TypeLen == 0 {
25067 return []byte("\"\""), nil
25068 } else {
25069 return []byte("\"" + self.GetOXMName() + "\""), nil
25070 }
25071}
25072
25073type OxmIdTunMetadata3Masked struct {
25074 *OxmId
25075}
25076
25077type IOxmIdTunMetadata3Masked interface {
25078 IOxmId
25079}
25080
25081func (self *OxmIdTunMetadata3Masked) Serialize(encoder *goloxi.Encoder) error {
25082 if err := self.OxmId.Serialize(encoder); err != nil {
25083 return err
25084 }
25085
25086 return nil
25087}
25088
25089func DecodeOxmIdTunMetadata3Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata3Masked, error) {
25090 _oxmidtunmetadata3masked := &OxmIdTunMetadata3Masked{OxmId: parent}
25091 return _oxmidtunmetadata3masked, nil
25092}
25093
25094func NewOxmIdTunMetadata3Masked() *OxmIdTunMetadata3Masked {
25095 obj := &OxmIdTunMetadata3Masked{
25096 OxmId: NewOxmId(88056),
25097 }
25098 return obj
25099}
25100func (self *OxmIdTunMetadata3Masked) GetOXMName() string {
25101 return "tun_metadata3_masked"
25102}
25103
25104func (self *OxmIdTunMetadata3Masked) MarshalJSON() ([]byte, error) {
25105 if self.TypeLen == 0 {
25106 return []byte("\"\""), nil
25107 } else {
25108 return []byte("\"" + self.GetOXMName() + "\""), nil
25109 }
25110}
25111
25112type OxmIdTunMetadata4 struct {
25113 *OxmId
25114}
25115
25116type IOxmIdTunMetadata4 interface {
25117 IOxmId
25118}
25119
25120func (self *OxmIdTunMetadata4) Serialize(encoder *goloxi.Encoder) error {
25121 if err := self.OxmId.Serialize(encoder); err != nil {
25122 return err
25123 }
25124
25125 return nil
25126}
25127
25128func DecodeOxmIdTunMetadata4(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata4, error) {
25129 _oxmidtunmetadata4 := &OxmIdTunMetadata4{OxmId: parent}
25130 return _oxmidtunmetadata4, nil
25131}
25132
25133func NewOxmIdTunMetadata4() *OxmIdTunMetadata4 {
25134 obj := &OxmIdTunMetadata4{
25135 OxmId: NewOxmId(88188),
25136 }
25137 return obj
25138}
25139func (self *OxmIdTunMetadata4) GetOXMName() string {
25140 return "tun_metadata4"
25141}
25142
25143func (self *OxmIdTunMetadata4) MarshalJSON() ([]byte, error) {
25144 if self.TypeLen == 0 {
25145 return []byte("\"\""), nil
25146 } else {
25147 return []byte("\"" + self.GetOXMName() + "\""), nil
25148 }
25149}
25150
25151type OxmIdTunMetadata40 struct {
25152 *OxmId
25153}
25154
25155type IOxmIdTunMetadata40 interface {
25156 IOxmId
25157}
25158
25159func (self *OxmIdTunMetadata40) Serialize(encoder *goloxi.Encoder) error {
25160 if err := self.OxmId.Serialize(encoder); err != nil {
25161 return err
25162 }
25163
25164 return nil
25165}
25166
25167func DecodeOxmIdTunMetadata40(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata40, error) {
25168 _oxmidtunmetadata40 := &OxmIdTunMetadata40{OxmId: parent}
25169 return _oxmidtunmetadata40, nil
25170}
25171
25172func NewOxmIdTunMetadata40() *OxmIdTunMetadata40 {
25173 obj := &OxmIdTunMetadata40{
25174 OxmId: NewOxmId(106620),
25175 }
25176 return obj
25177}
25178func (self *OxmIdTunMetadata40) GetOXMName() string {
25179 return "tun_metadata40"
25180}
25181
25182func (self *OxmIdTunMetadata40) MarshalJSON() ([]byte, error) {
25183 if self.TypeLen == 0 {
25184 return []byte("\"\""), nil
25185 } else {
25186 return []byte("\"" + self.GetOXMName() + "\""), nil
25187 }
25188}
25189
25190type OxmIdTunMetadata40Masked struct {
25191 *OxmId
25192}
25193
25194type IOxmIdTunMetadata40Masked interface {
25195 IOxmId
25196}
25197
25198func (self *OxmIdTunMetadata40Masked) Serialize(encoder *goloxi.Encoder) error {
25199 if err := self.OxmId.Serialize(encoder); err != nil {
25200 return err
25201 }
25202
25203 return nil
25204}
25205
25206func DecodeOxmIdTunMetadata40Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata40Masked, error) {
25207 _oxmidtunmetadata40masked := &OxmIdTunMetadata40Masked{OxmId: parent}
25208 return _oxmidtunmetadata40masked, nil
25209}
25210
25211func NewOxmIdTunMetadata40Masked() *OxmIdTunMetadata40Masked {
25212 obj := &OxmIdTunMetadata40Masked{
25213 OxmId: NewOxmId(107000),
25214 }
25215 return obj
25216}
25217func (self *OxmIdTunMetadata40Masked) GetOXMName() string {
25218 return "tun_metadata40_masked"
25219}
25220
25221func (self *OxmIdTunMetadata40Masked) MarshalJSON() ([]byte, error) {
25222 if self.TypeLen == 0 {
25223 return []byte("\"\""), nil
25224 } else {
25225 return []byte("\"" + self.GetOXMName() + "\""), nil
25226 }
25227}
25228
25229type OxmIdTunMetadata41 struct {
25230 *OxmId
25231}
25232
25233type IOxmIdTunMetadata41 interface {
25234 IOxmId
25235}
25236
25237func (self *OxmIdTunMetadata41) Serialize(encoder *goloxi.Encoder) error {
25238 if err := self.OxmId.Serialize(encoder); err != nil {
25239 return err
25240 }
25241
25242 return nil
25243}
25244
25245func DecodeOxmIdTunMetadata41(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata41, error) {
25246 _oxmidtunmetadata41 := &OxmIdTunMetadata41{OxmId: parent}
25247 return _oxmidtunmetadata41, nil
25248}
25249
25250func NewOxmIdTunMetadata41() *OxmIdTunMetadata41 {
25251 obj := &OxmIdTunMetadata41{
25252 OxmId: NewOxmId(107132),
25253 }
25254 return obj
25255}
25256func (self *OxmIdTunMetadata41) GetOXMName() string {
25257 return "tun_metadata41"
25258}
25259
25260func (self *OxmIdTunMetadata41) MarshalJSON() ([]byte, error) {
25261 if self.TypeLen == 0 {
25262 return []byte("\"\""), nil
25263 } else {
25264 return []byte("\"" + self.GetOXMName() + "\""), nil
25265 }
25266}
25267
25268type OxmIdTunMetadata41Masked struct {
25269 *OxmId
25270}
25271
25272type IOxmIdTunMetadata41Masked interface {
25273 IOxmId
25274}
25275
25276func (self *OxmIdTunMetadata41Masked) Serialize(encoder *goloxi.Encoder) error {
25277 if err := self.OxmId.Serialize(encoder); err != nil {
25278 return err
25279 }
25280
25281 return nil
25282}
25283
25284func DecodeOxmIdTunMetadata41Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata41Masked, error) {
25285 _oxmidtunmetadata41masked := &OxmIdTunMetadata41Masked{OxmId: parent}
25286 return _oxmidtunmetadata41masked, nil
25287}
25288
25289func NewOxmIdTunMetadata41Masked() *OxmIdTunMetadata41Masked {
25290 obj := &OxmIdTunMetadata41Masked{
25291 OxmId: NewOxmId(107512),
25292 }
25293 return obj
25294}
25295func (self *OxmIdTunMetadata41Masked) GetOXMName() string {
25296 return "tun_metadata41_masked"
25297}
25298
25299func (self *OxmIdTunMetadata41Masked) MarshalJSON() ([]byte, error) {
25300 if self.TypeLen == 0 {
25301 return []byte("\"\""), nil
25302 } else {
25303 return []byte("\"" + self.GetOXMName() + "\""), nil
25304 }
25305}
25306
25307type OxmIdTunMetadata42 struct {
25308 *OxmId
25309}
25310
25311type IOxmIdTunMetadata42 interface {
25312 IOxmId
25313}
25314
25315func (self *OxmIdTunMetadata42) Serialize(encoder *goloxi.Encoder) error {
25316 if err := self.OxmId.Serialize(encoder); err != nil {
25317 return err
25318 }
25319
25320 return nil
25321}
25322
25323func DecodeOxmIdTunMetadata42(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata42, error) {
25324 _oxmidtunmetadata42 := &OxmIdTunMetadata42{OxmId: parent}
25325 return _oxmidtunmetadata42, nil
25326}
25327
25328func NewOxmIdTunMetadata42() *OxmIdTunMetadata42 {
25329 obj := &OxmIdTunMetadata42{
25330 OxmId: NewOxmId(107644),
25331 }
25332 return obj
25333}
25334func (self *OxmIdTunMetadata42) GetOXMName() string {
25335 return "tun_metadata42"
25336}
25337
25338func (self *OxmIdTunMetadata42) MarshalJSON() ([]byte, error) {
25339 if self.TypeLen == 0 {
25340 return []byte("\"\""), nil
25341 } else {
25342 return []byte("\"" + self.GetOXMName() + "\""), nil
25343 }
25344}
25345
25346type OxmIdTunMetadata42Masked struct {
25347 *OxmId
25348}
25349
25350type IOxmIdTunMetadata42Masked interface {
25351 IOxmId
25352}
25353
25354func (self *OxmIdTunMetadata42Masked) Serialize(encoder *goloxi.Encoder) error {
25355 if err := self.OxmId.Serialize(encoder); err != nil {
25356 return err
25357 }
25358
25359 return nil
25360}
25361
25362func DecodeOxmIdTunMetadata42Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata42Masked, error) {
25363 _oxmidtunmetadata42masked := &OxmIdTunMetadata42Masked{OxmId: parent}
25364 return _oxmidtunmetadata42masked, nil
25365}
25366
25367func NewOxmIdTunMetadata42Masked() *OxmIdTunMetadata42Masked {
25368 obj := &OxmIdTunMetadata42Masked{
25369 OxmId: NewOxmId(108024),
25370 }
25371 return obj
25372}
25373func (self *OxmIdTunMetadata42Masked) GetOXMName() string {
25374 return "tun_metadata42_masked"
25375}
25376
25377func (self *OxmIdTunMetadata42Masked) MarshalJSON() ([]byte, error) {
25378 if self.TypeLen == 0 {
25379 return []byte("\"\""), nil
25380 } else {
25381 return []byte("\"" + self.GetOXMName() + "\""), nil
25382 }
25383}
25384
25385type OxmIdTunMetadata43 struct {
25386 *OxmId
25387}
25388
25389type IOxmIdTunMetadata43 interface {
25390 IOxmId
25391}
25392
25393func (self *OxmIdTunMetadata43) Serialize(encoder *goloxi.Encoder) error {
25394 if err := self.OxmId.Serialize(encoder); err != nil {
25395 return err
25396 }
25397
25398 return nil
25399}
25400
25401func DecodeOxmIdTunMetadata43(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata43, error) {
25402 _oxmidtunmetadata43 := &OxmIdTunMetadata43{OxmId: parent}
25403 return _oxmidtunmetadata43, nil
25404}
25405
25406func NewOxmIdTunMetadata43() *OxmIdTunMetadata43 {
25407 obj := &OxmIdTunMetadata43{
25408 OxmId: NewOxmId(108156),
25409 }
25410 return obj
25411}
25412func (self *OxmIdTunMetadata43) GetOXMName() string {
25413 return "tun_metadata43"
25414}
25415
25416func (self *OxmIdTunMetadata43) MarshalJSON() ([]byte, error) {
25417 if self.TypeLen == 0 {
25418 return []byte("\"\""), nil
25419 } else {
25420 return []byte("\"" + self.GetOXMName() + "\""), nil
25421 }
25422}
25423
25424type OxmIdTunMetadata43Masked struct {
25425 *OxmId
25426}
25427
25428type IOxmIdTunMetadata43Masked interface {
25429 IOxmId
25430}
25431
25432func (self *OxmIdTunMetadata43Masked) Serialize(encoder *goloxi.Encoder) error {
25433 if err := self.OxmId.Serialize(encoder); err != nil {
25434 return err
25435 }
25436
25437 return nil
25438}
25439
25440func DecodeOxmIdTunMetadata43Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata43Masked, error) {
25441 _oxmidtunmetadata43masked := &OxmIdTunMetadata43Masked{OxmId: parent}
25442 return _oxmidtunmetadata43masked, nil
25443}
25444
25445func NewOxmIdTunMetadata43Masked() *OxmIdTunMetadata43Masked {
25446 obj := &OxmIdTunMetadata43Masked{
25447 OxmId: NewOxmId(108536),
25448 }
25449 return obj
25450}
25451func (self *OxmIdTunMetadata43Masked) GetOXMName() string {
25452 return "tun_metadata43_masked"
25453}
25454
25455func (self *OxmIdTunMetadata43Masked) MarshalJSON() ([]byte, error) {
25456 if self.TypeLen == 0 {
25457 return []byte("\"\""), nil
25458 } else {
25459 return []byte("\"" + self.GetOXMName() + "\""), nil
25460 }
25461}
25462
25463type OxmIdTunMetadata44 struct {
25464 *OxmId
25465}
25466
25467type IOxmIdTunMetadata44 interface {
25468 IOxmId
25469}
25470
25471func (self *OxmIdTunMetadata44) Serialize(encoder *goloxi.Encoder) error {
25472 if err := self.OxmId.Serialize(encoder); err != nil {
25473 return err
25474 }
25475
25476 return nil
25477}
25478
25479func DecodeOxmIdTunMetadata44(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata44, error) {
25480 _oxmidtunmetadata44 := &OxmIdTunMetadata44{OxmId: parent}
25481 return _oxmidtunmetadata44, nil
25482}
25483
25484func NewOxmIdTunMetadata44() *OxmIdTunMetadata44 {
25485 obj := &OxmIdTunMetadata44{
25486 OxmId: NewOxmId(108668),
25487 }
25488 return obj
25489}
25490func (self *OxmIdTunMetadata44) GetOXMName() string {
25491 return "tun_metadata44"
25492}
25493
25494func (self *OxmIdTunMetadata44) MarshalJSON() ([]byte, error) {
25495 if self.TypeLen == 0 {
25496 return []byte("\"\""), nil
25497 } else {
25498 return []byte("\"" + self.GetOXMName() + "\""), nil
25499 }
25500}
25501
25502type OxmIdTunMetadata44Masked struct {
25503 *OxmId
25504}
25505
25506type IOxmIdTunMetadata44Masked interface {
25507 IOxmId
25508}
25509
25510func (self *OxmIdTunMetadata44Masked) Serialize(encoder *goloxi.Encoder) error {
25511 if err := self.OxmId.Serialize(encoder); err != nil {
25512 return err
25513 }
25514
25515 return nil
25516}
25517
25518func DecodeOxmIdTunMetadata44Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata44Masked, error) {
25519 _oxmidtunmetadata44masked := &OxmIdTunMetadata44Masked{OxmId: parent}
25520 return _oxmidtunmetadata44masked, nil
25521}
25522
25523func NewOxmIdTunMetadata44Masked() *OxmIdTunMetadata44Masked {
25524 obj := &OxmIdTunMetadata44Masked{
25525 OxmId: NewOxmId(109048),
25526 }
25527 return obj
25528}
25529func (self *OxmIdTunMetadata44Masked) GetOXMName() string {
25530 return "tun_metadata44_masked"
25531}
25532
25533func (self *OxmIdTunMetadata44Masked) MarshalJSON() ([]byte, error) {
25534 if self.TypeLen == 0 {
25535 return []byte("\"\""), nil
25536 } else {
25537 return []byte("\"" + self.GetOXMName() + "\""), nil
25538 }
25539}
25540
25541type OxmIdTunMetadata45 struct {
25542 *OxmId
25543}
25544
25545type IOxmIdTunMetadata45 interface {
25546 IOxmId
25547}
25548
25549func (self *OxmIdTunMetadata45) Serialize(encoder *goloxi.Encoder) error {
25550 if err := self.OxmId.Serialize(encoder); err != nil {
25551 return err
25552 }
25553
25554 return nil
25555}
25556
25557func DecodeOxmIdTunMetadata45(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata45, error) {
25558 _oxmidtunmetadata45 := &OxmIdTunMetadata45{OxmId: parent}
25559 return _oxmidtunmetadata45, nil
25560}
25561
25562func NewOxmIdTunMetadata45() *OxmIdTunMetadata45 {
25563 obj := &OxmIdTunMetadata45{
25564 OxmId: NewOxmId(109180),
25565 }
25566 return obj
25567}
25568func (self *OxmIdTunMetadata45) GetOXMName() string {
25569 return "tun_metadata45"
25570}
25571
25572func (self *OxmIdTunMetadata45) MarshalJSON() ([]byte, error) {
25573 if self.TypeLen == 0 {
25574 return []byte("\"\""), nil
25575 } else {
25576 return []byte("\"" + self.GetOXMName() + "\""), nil
25577 }
25578}
25579
25580type OxmIdTunMetadata45Masked struct {
25581 *OxmId
25582}
25583
25584type IOxmIdTunMetadata45Masked interface {
25585 IOxmId
25586}
25587
25588func (self *OxmIdTunMetadata45Masked) Serialize(encoder *goloxi.Encoder) error {
25589 if err := self.OxmId.Serialize(encoder); err != nil {
25590 return err
25591 }
25592
25593 return nil
25594}
25595
25596func DecodeOxmIdTunMetadata45Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata45Masked, error) {
25597 _oxmidtunmetadata45masked := &OxmIdTunMetadata45Masked{OxmId: parent}
25598 return _oxmidtunmetadata45masked, nil
25599}
25600
25601func NewOxmIdTunMetadata45Masked() *OxmIdTunMetadata45Masked {
25602 obj := &OxmIdTunMetadata45Masked{
25603 OxmId: NewOxmId(109560),
25604 }
25605 return obj
25606}
25607func (self *OxmIdTunMetadata45Masked) GetOXMName() string {
25608 return "tun_metadata45_masked"
25609}
25610
25611func (self *OxmIdTunMetadata45Masked) MarshalJSON() ([]byte, error) {
25612 if self.TypeLen == 0 {
25613 return []byte("\"\""), nil
25614 } else {
25615 return []byte("\"" + self.GetOXMName() + "\""), nil
25616 }
25617}
25618
25619type OxmIdTunMetadata46 struct {
25620 *OxmId
25621}
25622
25623type IOxmIdTunMetadata46 interface {
25624 IOxmId
25625}
25626
25627func (self *OxmIdTunMetadata46) Serialize(encoder *goloxi.Encoder) error {
25628 if err := self.OxmId.Serialize(encoder); err != nil {
25629 return err
25630 }
25631
25632 return nil
25633}
25634
25635func DecodeOxmIdTunMetadata46(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata46, error) {
25636 _oxmidtunmetadata46 := &OxmIdTunMetadata46{OxmId: parent}
25637 return _oxmidtunmetadata46, nil
25638}
25639
25640func NewOxmIdTunMetadata46() *OxmIdTunMetadata46 {
25641 obj := &OxmIdTunMetadata46{
25642 OxmId: NewOxmId(109692),
25643 }
25644 return obj
25645}
25646func (self *OxmIdTunMetadata46) GetOXMName() string {
25647 return "tun_metadata46"
25648}
25649
25650func (self *OxmIdTunMetadata46) MarshalJSON() ([]byte, error) {
25651 if self.TypeLen == 0 {
25652 return []byte("\"\""), nil
25653 } else {
25654 return []byte("\"" + self.GetOXMName() + "\""), nil
25655 }
25656}
25657
25658type OxmIdTunMetadata46Masked struct {
25659 *OxmId
25660}
25661
25662type IOxmIdTunMetadata46Masked interface {
25663 IOxmId
25664}
25665
25666func (self *OxmIdTunMetadata46Masked) Serialize(encoder *goloxi.Encoder) error {
25667 if err := self.OxmId.Serialize(encoder); err != nil {
25668 return err
25669 }
25670
25671 return nil
25672}
25673
25674func DecodeOxmIdTunMetadata46Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata46Masked, error) {
25675 _oxmidtunmetadata46masked := &OxmIdTunMetadata46Masked{OxmId: parent}
25676 return _oxmidtunmetadata46masked, nil
25677}
25678
25679func NewOxmIdTunMetadata46Masked() *OxmIdTunMetadata46Masked {
25680 obj := &OxmIdTunMetadata46Masked{
25681 OxmId: NewOxmId(110072),
25682 }
25683 return obj
25684}
25685func (self *OxmIdTunMetadata46Masked) GetOXMName() string {
25686 return "tun_metadata46_masked"
25687}
25688
25689func (self *OxmIdTunMetadata46Masked) MarshalJSON() ([]byte, error) {
25690 if self.TypeLen == 0 {
25691 return []byte("\"\""), nil
25692 } else {
25693 return []byte("\"" + self.GetOXMName() + "\""), nil
25694 }
25695}
25696
25697type OxmIdTunMetadata47 struct {
25698 *OxmId
25699}
25700
25701type IOxmIdTunMetadata47 interface {
25702 IOxmId
25703}
25704
25705func (self *OxmIdTunMetadata47) Serialize(encoder *goloxi.Encoder) error {
25706 if err := self.OxmId.Serialize(encoder); err != nil {
25707 return err
25708 }
25709
25710 return nil
25711}
25712
25713func DecodeOxmIdTunMetadata47(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata47, error) {
25714 _oxmidtunmetadata47 := &OxmIdTunMetadata47{OxmId: parent}
25715 return _oxmidtunmetadata47, nil
25716}
25717
25718func NewOxmIdTunMetadata47() *OxmIdTunMetadata47 {
25719 obj := &OxmIdTunMetadata47{
25720 OxmId: NewOxmId(110204),
25721 }
25722 return obj
25723}
25724func (self *OxmIdTunMetadata47) GetOXMName() string {
25725 return "tun_metadata47"
25726}
25727
25728func (self *OxmIdTunMetadata47) MarshalJSON() ([]byte, error) {
25729 if self.TypeLen == 0 {
25730 return []byte("\"\""), nil
25731 } else {
25732 return []byte("\"" + self.GetOXMName() + "\""), nil
25733 }
25734}
25735
25736type OxmIdTunMetadata47Masked struct {
25737 *OxmId
25738}
25739
25740type IOxmIdTunMetadata47Masked interface {
25741 IOxmId
25742}
25743
25744func (self *OxmIdTunMetadata47Masked) Serialize(encoder *goloxi.Encoder) error {
25745 if err := self.OxmId.Serialize(encoder); err != nil {
25746 return err
25747 }
25748
25749 return nil
25750}
25751
25752func DecodeOxmIdTunMetadata47Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata47Masked, error) {
25753 _oxmidtunmetadata47masked := &OxmIdTunMetadata47Masked{OxmId: parent}
25754 return _oxmidtunmetadata47masked, nil
25755}
25756
25757func NewOxmIdTunMetadata47Masked() *OxmIdTunMetadata47Masked {
25758 obj := &OxmIdTunMetadata47Masked{
25759 OxmId: NewOxmId(110584),
25760 }
25761 return obj
25762}
25763func (self *OxmIdTunMetadata47Masked) GetOXMName() string {
25764 return "tun_metadata47_masked"
25765}
25766
25767func (self *OxmIdTunMetadata47Masked) MarshalJSON() ([]byte, error) {
25768 if self.TypeLen == 0 {
25769 return []byte("\"\""), nil
25770 } else {
25771 return []byte("\"" + self.GetOXMName() + "\""), nil
25772 }
25773}
25774
25775type OxmIdTunMetadata48 struct {
25776 *OxmId
25777}
25778
25779type IOxmIdTunMetadata48 interface {
25780 IOxmId
25781}
25782
25783func (self *OxmIdTunMetadata48) Serialize(encoder *goloxi.Encoder) error {
25784 if err := self.OxmId.Serialize(encoder); err != nil {
25785 return err
25786 }
25787
25788 return nil
25789}
25790
25791func DecodeOxmIdTunMetadata48(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata48, error) {
25792 _oxmidtunmetadata48 := &OxmIdTunMetadata48{OxmId: parent}
25793 return _oxmidtunmetadata48, nil
25794}
25795
25796func NewOxmIdTunMetadata48() *OxmIdTunMetadata48 {
25797 obj := &OxmIdTunMetadata48{
25798 OxmId: NewOxmId(110716),
25799 }
25800 return obj
25801}
25802func (self *OxmIdTunMetadata48) GetOXMName() string {
25803 return "tun_metadata48"
25804}
25805
25806func (self *OxmIdTunMetadata48) MarshalJSON() ([]byte, error) {
25807 if self.TypeLen == 0 {
25808 return []byte("\"\""), nil
25809 } else {
25810 return []byte("\"" + self.GetOXMName() + "\""), nil
25811 }
25812}
25813
25814type OxmIdTunMetadata48Masked struct {
25815 *OxmId
25816}
25817
25818type IOxmIdTunMetadata48Masked interface {
25819 IOxmId
25820}
25821
25822func (self *OxmIdTunMetadata48Masked) Serialize(encoder *goloxi.Encoder) error {
25823 if err := self.OxmId.Serialize(encoder); err != nil {
25824 return err
25825 }
25826
25827 return nil
25828}
25829
25830func DecodeOxmIdTunMetadata48Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata48Masked, error) {
25831 _oxmidtunmetadata48masked := &OxmIdTunMetadata48Masked{OxmId: parent}
25832 return _oxmidtunmetadata48masked, nil
25833}
25834
25835func NewOxmIdTunMetadata48Masked() *OxmIdTunMetadata48Masked {
25836 obj := &OxmIdTunMetadata48Masked{
25837 OxmId: NewOxmId(111096),
25838 }
25839 return obj
25840}
25841func (self *OxmIdTunMetadata48Masked) GetOXMName() string {
25842 return "tun_metadata48_masked"
25843}
25844
25845func (self *OxmIdTunMetadata48Masked) MarshalJSON() ([]byte, error) {
25846 if self.TypeLen == 0 {
25847 return []byte("\"\""), nil
25848 } else {
25849 return []byte("\"" + self.GetOXMName() + "\""), nil
25850 }
25851}
25852
25853type OxmIdTunMetadata49 struct {
25854 *OxmId
25855}
25856
25857type IOxmIdTunMetadata49 interface {
25858 IOxmId
25859}
25860
25861func (self *OxmIdTunMetadata49) Serialize(encoder *goloxi.Encoder) error {
25862 if err := self.OxmId.Serialize(encoder); err != nil {
25863 return err
25864 }
25865
25866 return nil
25867}
25868
25869func DecodeOxmIdTunMetadata49(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata49, error) {
25870 _oxmidtunmetadata49 := &OxmIdTunMetadata49{OxmId: parent}
25871 return _oxmidtunmetadata49, nil
25872}
25873
25874func NewOxmIdTunMetadata49() *OxmIdTunMetadata49 {
25875 obj := &OxmIdTunMetadata49{
25876 OxmId: NewOxmId(111228),
25877 }
25878 return obj
25879}
25880func (self *OxmIdTunMetadata49) GetOXMName() string {
25881 return "tun_metadata49"
25882}
25883
25884func (self *OxmIdTunMetadata49) MarshalJSON() ([]byte, error) {
25885 if self.TypeLen == 0 {
25886 return []byte("\"\""), nil
25887 } else {
25888 return []byte("\"" + self.GetOXMName() + "\""), nil
25889 }
25890}
25891
25892type OxmIdTunMetadata49Masked struct {
25893 *OxmId
25894}
25895
25896type IOxmIdTunMetadata49Masked interface {
25897 IOxmId
25898}
25899
25900func (self *OxmIdTunMetadata49Masked) Serialize(encoder *goloxi.Encoder) error {
25901 if err := self.OxmId.Serialize(encoder); err != nil {
25902 return err
25903 }
25904
25905 return nil
25906}
25907
25908func DecodeOxmIdTunMetadata49Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata49Masked, error) {
25909 _oxmidtunmetadata49masked := &OxmIdTunMetadata49Masked{OxmId: parent}
25910 return _oxmidtunmetadata49masked, nil
25911}
25912
25913func NewOxmIdTunMetadata49Masked() *OxmIdTunMetadata49Masked {
25914 obj := &OxmIdTunMetadata49Masked{
25915 OxmId: NewOxmId(111608),
25916 }
25917 return obj
25918}
25919func (self *OxmIdTunMetadata49Masked) GetOXMName() string {
25920 return "tun_metadata49_masked"
25921}
25922
25923func (self *OxmIdTunMetadata49Masked) MarshalJSON() ([]byte, error) {
25924 if self.TypeLen == 0 {
25925 return []byte("\"\""), nil
25926 } else {
25927 return []byte("\"" + self.GetOXMName() + "\""), nil
25928 }
25929}
25930
25931type OxmIdTunMetadata4Masked struct {
25932 *OxmId
25933}
25934
25935type IOxmIdTunMetadata4Masked interface {
25936 IOxmId
25937}
25938
25939func (self *OxmIdTunMetadata4Masked) Serialize(encoder *goloxi.Encoder) error {
25940 if err := self.OxmId.Serialize(encoder); err != nil {
25941 return err
25942 }
25943
25944 return nil
25945}
25946
25947func DecodeOxmIdTunMetadata4Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata4Masked, error) {
25948 _oxmidtunmetadata4masked := &OxmIdTunMetadata4Masked{OxmId: parent}
25949 return _oxmidtunmetadata4masked, nil
25950}
25951
25952func NewOxmIdTunMetadata4Masked() *OxmIdTunMetadata4Masked {
25953 obj := &OxmIdTunMetadata4Masked{
25954 OxmId: NewOxmId(88568),
25955 }
25956 return obj
25957}
25958func (self *OxmIdTunMetadata4Masked) GetOXMName() string {
25959 return "tun_metadata4_masked"
25960}
25961
25962func (self *OxmIdTunMetadata4Masked) MarshalJSON() ([]byte, error) {
25963 if self.TypeLen == 0 {
25964 return []byte("\"\""), nil
25965 } else {
25966 return []byte("\"" + self.GetOXMName() + "\""), nil
25967 }
25968}
25969
25970type OxmIdTunMetadata5 struct {
25971 *OxmId
25972}
25973
25974type IOxmIdTunMetadata5 interface {
25975 IOxmId
25976}
25977
25978func (self *OxmIdTunMetadata5) Serialize(encoder *goloxi.Encoder) error {
25979 if err := self.OxmId.Serialize(encoder); err != nil {
25980 return err
25981 }
25982
25983 return nil
25984}
25985
25986func DecodeOxmIdTunMetadata5(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata5, error) {
25987 _oxmidtunmetadata5 := &OxmIdTunMetadata5{OxmId: parent}
25988 return _oxmidtunmetadata5, nil
25989}
25990
25991func NewOxmIdTunMetadata5() *OxmIdTunMetadata5 {
25992 obj := &OxmIdTunMetadata5{
25993 OxmId: NewOxmId(88700),
25994 }
25995 return obj
25996}
25997func (self *OxmIdTunMetadata5) GetOXMName() string {
25998 return "tun_metadata5"
25999}
26000
26001func (self *OxmIdTunMetadata5) MarshalJSON() ([]byte, error) {
26002 if self.TypeLen == 0 {
26003 return []byte("\"\""), nil
26004 } else {
26005 return []byte("\"" + self.GetOXMName() + "\""), nil
26006 }
26007}
26008
26009type OxmIdTunMetadata50 struct {
26010 *OxmId
26011}
26012
26013type IOxmIdTunMetadata50 interface {
26014 IOxmId
26015}
26016
26017func (self *OxmIdTunMetadata50) Serialize(encoder *goloxi.Encoder) error {
26018 if err := self.OxmId.Serialize(encoder); err != nil {
26019 return err
26020 }
26021
26022 return nil
26023}
26024
26025func DecodeOxmIdTunMetadata50(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata50, error) {
26026 _oxmidtunmetadata50 := &OxmIdTunMetadata50{OxmId: parent}
26027 return _oxmidtunmetadata50, nil
26028}
26029
26030func NewOxmIdTunMetadata50() *OxmIdTunMetadata50 {
26031 obj := &OxmIdTunMetadata50{
26032 OxmId: NewOxmId(111740),
26033 }
26034 return obj
26035}
26036func (self *OxmIdTunMetadata50) GetOXMName() string {
26037 return "tun_metadata50"
26038}
26039
26040func (self *OxmIdTunMetadata50) MarshalJSON() ([]byte, error) {
26041 if self.TypeLen == 0 {
26042 return []byte("\"\""), nil
26043 } else {
26044 return []byte("\"" + self.GetOXMName() + "\""), nil
26045 }
26046}
26047
26048type OxmIdTunMetadata50Masked struct {
26049 *OxmId
26050}
26051
26052type IOxmIdTunMetadata50Masked interface {
26053 IOxmId
26054}
26055
26056func (self *OxmIdTunMetadata50Masked) Serialize(encoder *goloxi.Encoder) error {
26057 if err := self.OxmId.Serialize(encoder); err != nil {
26058 return err
26059 }
26060
26061 return nil
26062}
26063
26064func DecodeOxmIdTunMetadata50Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata50Masked, error) {
26065 _oxmidtunmetadata50masked := &OxmIdTunMetadata50Masked{OxmId: parent}
26066 return _oxmidtunmetadata50masked, nil
26067}
26068
26069func NewOxmIdTunMetadata50Masked() *OxmIdTunMetadata50Masked {
26070 obj := &OxmIdTunMetadata50Masked{
26071 OxmId: NewOxmId(112120),
26072 }
26073 return obj
26074}
26075func (self *OxmIdTunMetadata50Masked) GetOXMName() string {
26076 return "tun_metadata50_masked"
26077}
26078
26079func (self *OxmIdTunMetadata50Masked) MarshalJSON() ([]byte, error) {
26080 if self.TypeLen == 0 {
26081 return []byte("\"\""), nil
26082 } else {
26083 return []byte("\"" + self.GetOXMName() + "\""), nil
26084 }
26085}
26086
26087type OxmIdTunMetadata51 struct {
26088 *OxmId
26089}
26090
26091type IOxmIdTunMetadata51 interface {
26092 IOxmId
26093}
26094
26095func (self *OxmIdTunMetadata51) Serialize(encoder *goloxi.Encoder) error {
26096 if err := self.OxmId.Serialize(encoder); err != nil {
26097 return err
26098 }
26099
26100 return nil
26101}
26102
26103func DecodeOxmIdTunMetadata51(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata51, error) {
26104 _oxmidtunmetadata51 := &OxmIdTunMetadata51{OxmId: parent}
26105 return _oxmidtunmetadata51, nil
26106}
26107
26108func NewOxmIdTunMetadata51() *OxmIdTunMetadata51 {
26109 obj := &OxmIdTunMetadata51{
26110 OxmId: NewOxmId(112252),
26111 }
26112 return obj
26113}
26114func (self *OxmIdTunMetadata51) GetOXMName() string {
26115 return "tun_metadata51"
26116}
26117
26118func (self *OxmIdTunMetadata51) MarshalJSON() ([]byte, error) {
26119 if self.TypeLen == 0 {
26120 return []byte("\"\""), nil
26121 } else {
26122 return []byte("\"" + self.GetOXMName() + "\""), nil
26123 }
26124}
26125
26126type OxmIdTunMetadata51Masked struct {
26127 *OxmId
26128}
26129
26130type IOxmIdTunMetadata51Masked interface {
26131 IOxmId
26132}
26133
26134func (self *OxmIdTunMetadata51Masked) Serialize(encoder *goloxi.Encoder) error {
26135 if err := self.OxmId.Serialize(encoder); err != nil {
26136 return err
26137 }
26138
26139 return nil
26140}
26141
26142func DecodeOxmIdTunMetadata51Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata51Masked, error) {
26143 _oxmidtunmetadata51masked := &OxmIdTunMetadata51Masked{OxmId: parent}
26144 return _oxmidtunmetadata51masked, nil
26145}
26146
26147func NewOxmIdTunMetadata51Masked() *OxmIdTunMetadata51Masked {
26148 obj := &OxmIdTunMetadata51Masked{
26149 OxmId: NewOxmId(112632),
26150 }
26151 return obj
26152}
26153func (self *OxmIdTunMetadata51Masked) GetOXMName() string {
26154 return "tun_metadata51_masked"
26155}
26156
26157func (self *OxmIdTunMetadata51Masked) MarshalJSON() ([]byte, error) {
26158 if self.TypeLen == 0 {
26159 return []byte("\"\""), nil
26160 } else {
26161 return []byte("\"" + self.GetOXMName() + "\""), nil
26162 }
26163}
26164
26165type OxmIdTunMetadata52 struct {
26166 *OxmId
26167}
26168
26169type IOxmIdTunMetadata52 interface {
26170 IOxmId
26171}
26172
26173func (self *OxmIdTunMetadata52) Serialize(encoder *goloxi.Encoder) error {
26174 if err := self.OxmId.Serialize(encoder); err != nil {
26175 return err
26176 }
26177
26178 return nil
26179}
26180
26181func DecodeOxmIdTunMetadata52(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata52, error) {
26182 _oxmidtunmetadata52 := &OxmIdTunMetadata52{OxmId: parent}
26183 return _oxmidtunmetadata52, nil
26184}
26185
26186func NewOxmIdTunMetadata52() *OxmIdTunMetadata52 {
26187 obj := &OxmIdTunMetadata52{
26188 OxmId: NewOxmId(112764),
26189 }
26190 return obj
26191}
26192func (self *OxmIdTunMetadata52) GetOXMName() string {
26193 return "tun_metadata52"
26194}
26195
26196func (self *OxmIdTunMetadata52) MarshalJSON() ([]byte, error) {
26197 if self.TypeLen == 0 {
26198 return []byte("\"\""), nil
26199 } else {
26200 return []byte("\"" + self.GetOXMName() + "\""), nil
26201 }
26202}
26203
26204type OxmIdTunMetadata52Masked struct {
26205 *OxmId
26206}
26207
26208type IOxmIdTunMetadata52Masked interface {
26209 IOxmId
26210}
26211
26212func (self *OxmIdTunMetadata52Masked) Serialize(encoder *goloxi.Encoder) error {
26213 if err := self.OxmId.Serialize(encoder); err != nil {
26214 return err
26215 }
26216
26217 return nil
26218}
26219
26220func DecodeOxmIdTunMetadata52Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata52Masked, error) {
26221 _oxmidtunmetadata52masked := &OxmIdTunMetadata52Masked{OxmId: parent}
26222 return _oxmidtunmetadata52masked, nil
26223}
26224
26225func NewOxmIdTunMetadata52Masked() *OxmIdTunMetadata52Masked {
26226 obj := &OxmIdTunMetadata52Masked{
26227 OxmId: NewOxmId(113144),
26228 }
26229 return obj
26230}
26231func (self *OxmIdTunMetadata52Masked) GetOXMName() string {
26232 return "tun_metadata52_masked"
26233}
26234
26235func (self *OxmIdTunMetadata52Masked) MarshalJSON() ([]byte, error) {
26236 if self.TypeLen == 0 {
26237 return []byte("\"\""), nil
26238 } else {
26239 return []byte("\"" + self.GetOXMName() + "\""), nil
26240 }
26241}
26242
26243type OxmIdTunMetadata53 struct {
26244 *OxmId
26245}
26246
26247type IOxmIdTunMetadata53 interface {
26248 IOxmId
26249}
26250
26251func (self *OxmIdTunMetadata53) Serialize(encoder *goloxi.Encoder) error {
26252 if err := self.OxmId.Serialize(encoder); err != nil {
26253 return err
26254 }
26255
26256 return nil
26257}
26258
26259func DecodeOxmIdTunMetadata53(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata53, error) {
26260 _oxmidtunmetadata53 := &OxmIdTunMetadata53{OxmId: parent}
26261 return _oxmidtunmetadata53, nil
26262}
26263
26264func NewOxmIdTunMetadata53() *OxmIdTunMetadata53 {
26265 obj := &OxmIdTunMetadata53{
26266 OxmId: NewOxmId(113276),
26267 }
26268 return obj
26269}
26270func (self *OxmIdTunMetadata53) GetOXMName() string {
26271 return "tun_metadata53"
26272}
26273
26274func (self *OxmIdTunMetadata53) MarshalJSON() ([]byte, error) {
26275 if self.TypeLen == 0 {
26276 return []byte("\"\""), nil
26277 } else {
26278 return []byte("\"" + self.GetOXMName() + "\""), nil
26279 }
26280}
26281
26282type OxmIdTunMetadata53Masked struct {
26283 *OxmId
26284}
26285
26286type IOxmIdTunMetadata53Masked interface {
26287 IOxmId
26288}
26289
26290func (self *OxmIdTunMetadata53Masked) Serialize(encoder *goloxi.Encoder) error {
26291 if err := self.OxmId.Serialize(encoder); err != nil {
26292 return err
26293 }
26294
26295 return nil
26296}
26297
26298func DecodeOxmIdTunMetadata53Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata53Masked, error) {
26299 _oxmidtunmetadata53masked := &OxmIdTunMetadata53Masked{OxmId: parent}
26300 return _oxmidtunmetadata53masked, nil
26301}
26302
26303func NewOxmIdTunMetadata53Masked() *OxmIdTunMetadata53Masked {
26304 obj := &OxmIdTunMetadata53Masked{
26305 OxmId: NewOxmId(113656),
26306 }
26307 return obj
26308}
26309func (self *OxmIdTunMetadata53Masked) GetOXMName() string {
26310 return "tun_metadata53_masked"
26311}
26312
26313func (self *OxmIdTunMetadata53Masked) MarshalJSON() ([]byte, error) {
26314 if self.TypeLen == 0 {
26315 return []byte("\"\""), nil
26316 } else {
26317 return []byte("\"" + self.GetOXMName() + "\""), nil
26318 }
26319}
26320
26321type OxmIdTunMetadata54 struct {
26322 *OxmId
26323}
26324
26325type IOxmIdTunMetadata54 interface {
26326 IOxmId
26327}
26328
26329func (self *OxmIdTunMetadata54) Serialize(encoder *goloxi.Encoder) error {
26330 if err := self.OxmId.Serialize(encoder); err != nil {
26331 return err
26332 }
26333
26334 return nil
26335}
26336
26337func DecodeOxmIdTunMetadata54(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata54, error) {
26338 _oxmidtunmetadata54 := &OxmIdTunMetadata54{OxmId: parent}
26339 return _oxmidtunmetadata54, nil
26340}
26341
26342func NewOxmIdTunMetadata54() *OxmIdTunMetadata54 {
26343 obj := &OxmIdTunMetadata54{
26344 OxmId: NewOxmId(113788),
26345 }
26346 return obj
26347}
26348func (self *OxmIdTunMetadata54) GetOXMName() string {
26349 return "tun_metadata54"
26350}
26351
26352func (self *OxmIdTunMetadata54) MarshalJSON() ([]byte, error) {
26353 if self.TypeLen == 0 {
26354 return []byte("\"\""), nil
26355 } else {
26356 return []byte("\"" + self.GetOXMName() + "\""), nil
26357 }
26358}
26359
26360type OxmIdTunMetadata54Masked struct {
26361 *OxmId
26362}
26363
26364type IOxmIdTunMetadata54Masked interface {
26365 IOxmId
26366}
26367
26368func (self *OxmIdTunMetadata54Masked) Serialize(encoder *goloxi.Encoder) error {
26369 if err := self.OxmId.Serialize(encoder); err != nil {
26370 return err
26371 }
26372
26373 return nil
26374}
26375
26376func DecodeOxmIdTunMetadata54Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata54Masked, error) {
26377 _oxmidtunmetadata54masked := &OxmIdTunMetadata54Masked{OxmId: parent}
26378 return _oxmidtunmetadata54masked, nil
26379}
26380
26381func NewOxmIdTunMetadata54Masked() *OxmIdTunMetadata54Masked {
26382 obj := &OxmIdTunMetadata54Masked{
26383 OxmId: NewOxmId(114168),
26384 }
26385 return obj
26386}
26387func (self *OxmIdTunMetadata54Masked) GetOXMName() string {
26388 return "tun_metadata54_masked"
26389}
26390
26391func (self *OxmIdTunMetadata54Masked) MarshalJSON() ([]byte, error) {
26392 if self.TypeLen == 0 {
26393 return []byte("\"\""), nil
26394 } else {
26395 return []byte("\"" + self.GetOXMName() + "\""), nil
26396 }
26397}
26398
26399type OxmIdTunMetadata55 struct {
26400 *OxmId
26401}
26402
26403type IOxmIdTunMetadata55 interface {
26404 IOxmId
26405}
26406
26407func (self *OxmIdTunMetadata55) Serialize(encoder *goloxi.Encoder) error {
26408 if err := self.OxmId.Serialize(encoder); err != nil {
26409 return err
26410 }
26411
26412 return nil
26413}
26414
26415func DecodeOxmIdTunMetadata55(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata55, error) {
26416 _oxmidtunmetadata55 := &OxmIdTunMetadata55{OxmId: parent}
26417 return _oxmidtunmetadata55, nil
26418}
26419
26420func NewOxmIdTunMetadata55() *OxmIdTunMetadata55 {
26421 obj := &OxmIdTunMetadata55{
26422 OxmId: NewOxmId(114300),
26423 }
26424 return obj
26425}
26426func (self *OxmIdTunMetadata55) GetOXMName() string {
26427 return "tun_metadata55"
26428}
26429
26430func (self *OxmIdTunMetadata55) MarshalJSON() ([]byte, error) {
26431 if self.TypeLen == 0 {
26432 return []byte("\"\""), nil
26433 } else {
26434 return []byte("\"" + self.GetOXMName() + "\""), nil
26435 }
26436}
26437
26438type OxmIdTunMetadata55Masked struct {
26439 *OxmId
26440}
26441
26442type IOxmIdTunMetadata55Masked interface {
26443 IOxmId
26444}
26445
26446func (self *OxmIdTunMetadata55Masked) Serialize(encoder *goloxi.Encoder) error {
26447 if err := self.OxmId.Serialize(encoder); err != nil {
26448 return err
26449 }
26450
26451 return nil
26452}
26453
26454func DecodeOxmIdTunMetadata55Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata55Masked, error) {
26455 _oxmidtunmetadata55masked := &OxmIdTunMetadata55Masked{OxmId: parent}
26456 return _oxmidtunmetadata55masked, nil
26457}
26458
26459func NewOxmIdTunMetadata55Masked() *OxmIdTunMetadata55Masked {
26460 obj := &OxmIdTunMetadata55Masked{
26461 OxmId: NewOxmId(114680),
26462 }
26463 return obj
26464}
26465func (self *OxmIdTunMetadata55Masked) GetOXMName() string {
26466 return "tun_metadata55_masked"
26467}
26468
26469func (self *OxmIdTunMetadata55Masked) MarshalJSON() ([]byte, error) {
26470 if self.TypeLen == 0 {
26471 return []byte("\"\""), nil
26472 } else {
26473 return []byte("\"" + self.GetOXMName() + "\""), nil
26474 }
26475}
26476
26477type OxmIdTunMetadata56 struct {
26478 *OxmId
26479}
26480
26481type IOxmIdTunMetadata56 interface {
26482 IOxmId
26483}
26484
26485func (self *OxmIdTunMetadata56) Serialize(encoder *goloxi.Encoder) error {
26486 if err := self.OxmId.Serialize(encoder); err != nil {
26487 return err
26488 }
26489
26490 return nil
26491}
26492
26493func DecodeOxmIdTunMetadata56(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata56, error) {
26494 _oxmidtunmetadata56 := &OxmIdTunMetadata56{OxmId: parent}
26495 return _oxmidtunmetadata56, nil
26496}
26497
26498func NewOxmIdTunMetadata56() *OxmIdTunMetadata56 {
26499 obj := &OxmIdTunMetadata56{
26500 OxmId: NewOxmId(114812),
26501 }
26502 return obj
26503}
26504func (self *OxmIdTunMetadata56) GetOXMName() string {
26505 return "tun_metadata56"
26506}
26507
26508func (self *OxmIdTunMetadata56) MarshalJSON() ([]byte, error) {
26509 if self.TypeLen == 0 {
26510 return []byte("\"\""), nil
26511 } else {
26512 return []byte("\"" + self.GetOXMName() + "\""), nil
26513 }
26514}
26515
26516type OxmIdTunMetadata56Masked struct {
26517 *OxmId
26518}
26519
26520type IOxmIdTunMetadata56Masked interface {
26521 IOxmId
26522}
26523
26524func (self *OxmIdTunMetadata56Masked) Serialize(encoder *goloxi.Encoder) error {
26525 if err := self.OxmId.Serialize(encoder); err != nil {
26526 return err
26527 }
26528
26529 return nil
26530}
26531
26532func DecodeOxmIdTunMetadata56Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata56Masked, error) {
26533 _oxmidtunmetadata56masked := &OxmIdTunMetadata56Masked{OxmId: parent}
26534 return _oxmidtunmetadata56masked, nil
26535}
26536
26537func NewOxmIdTunMetadata56Masked() *OxmIdTunMetadata56Masked {
26538 obj := &OxmIdTunMetadata56Masked{
26539 OxmId: NewOxmId(115192),
26540 }
26541 return obj
26542}
26543func (self *OxmIdTunMetadata56Masked) GetOXMName() string {
26544 return "tun_metadata56_masked"
26545}
26546
26547func (self *OxmIdTunMetadata56Masked) MarshalJSON() ([]byte, error) {
26548 if self.TypeLen == 0 {
26549 return []byte("\"\""), nil
26550 } else {
26551 return []byte("\"" + self.GetOXMName() + "\""), nil
26552 }
26553}
26554
26555type OxmIdTunMetadata57 struct {
26556 *OxmId
26557}
26558
26559type IOxmIdTunMetadata57 interface {
26560 IOxmId
26561}
26562
26563func (self *OxmIdTunMetadata57) Serialize(encoder *goloxi.Encoder) error {
26564 if err := self.OxmId.Serialize(encoder); err != nil {
26565 return err
26566 }
26567
26568 return nil
26569}
26570
26571func DecodeOxmIdTunMetadata57(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata57, error) {
26572 _oxmidtunmetadata57 := &OxmIdTunMetadata57{OxmId: parent}
26573 return _oxmidtunmetadata57, nil
26574}
26575
26576func NewOxmIdTunMetadata57() *OxmIdTunMetadata57 {
26577 obj := &OxmIdTunMetadata57{
26578 OxmId: NewOxmId(115324),
26579 }
26580 return obj
26581}
26582func (self *OxmIdTunMetadata57) GetOXMName() string {
26583 return "tun_metadata57"
26584}
26585
26586func (self *OxmIdTunMetadata57) MarshalJSON() ([]byte, error) {
26587 if self.TypeLen == 0 {
26588 return []byte("\"\""), nil
26589 } else {
26590 return []byte("\"" + self.GetOXMName() + "\""), nil
26591 }
26592}
26593
26594type OxmIdTunMetadata57Masked struct {
26595 *OxmId
26596}
26597
26598type IOxmIdTunMetadata57Masked interface {
26599 IOxmId
26600}
26601
26602func (self *OxmIdTunMetadata57Masked) Serialize(encoder *goloxi.Encoder) error {
26603 if err := self.OxmId.Serialize(encoder); err != nil {
26604 return err
26605 }
26606
26607 return nil
26608}
26609
26610func DecodeOxmIdTunMetadata57Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata57Masked, error) {
26611 _oxmidtunmetadata57masked := &OxmIdTunMetadata57Masked{OxmId: parent}
26612 return _oxmidtunmetadata57masked, nil
26613}
26614
26615func NewOxmIdTunMetadata57Masked() *OxmIdTunMetadata57Masked {
26616 obj := &OxmIdTunMetadata57Masked{
26617 OxmId: NewOxmId(115704),
26618 }
26619 return obj
26620}
26621func (self *OxmIdTunMetadata57Masked) GetOXMName() string {
26622 return "tun_metadata57_masked"
26623}
26624
26625func (self *OxmIdTunMetadata57Masked) MarshalJSON() ([]byte, error) {
26626 if self.TypeLen == 0 {
26627 return []byte("\"\""), nil
26628 } else {
26629 return []byte("\"" + self.GetOXMName() + "\""), nil
26630 }
26631}
26632
26633type OxmIdTunMetadata58 struct {
26634 *OxmId
26635}
26636
26637type IOxmIdTunMetadata58 interface {
26638 IOxmId
26639}
26640
26641func (self *OxmIdTunMetadata58) Serialize(encoder *goloxi.Encoder) error {
26642 if err := self.OxmId.Serialize(encoder); err != nil {
26643 return err
26644 }
26645
26646 return nil
26647}
26648
26649func DecodeOxmIdTunMetadata58(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata58, error) {
26650 _oxmidtunmetadata58 := &OxmIdTunMetadata58{OxmId: parent}
26651 return _oxmidtunmetadata58, nil
26652}
26653
26654func NewOxmIdTunMetadata58() *OxmIdTunMetadata58 {
26655 obj := &OxmIdTunMetadata58{
26656 OxmId: NewOxmId(115836),
26657 }
26658 return obj
26659}
26660func (self *OxmIdTunMetadata58) GetOXMName() string {
26661 return "tun_metadata58"
26662}
26663
26664func (self *OxmIdTunMetadata58) MarshalJSON() ([]byte, error) {
26665 if self.TypeLen == 0 {
26666 return []byte("\"\""), nil
26667 } else {
26668 return []byte("\"" + self.GetOXMName() + "\""), nil
26669 }
26670}
26671
26672type OxmIdTunMetadata58Masked struct {
26673 *OxmId
26674}
26675
26676type IOxmIdTunMetadata58Masked interface {
26677 IOxmId
26678}
26679
26680func (self *OxmIdTunMetadata58Masked) Serialize(encoder *goloxi.Encoder) error {
26681 if err := self.OxmId.Serialize(encoder); err != nil {
26682 return err
26683 }
26684
26685 return nil
26686}
26687
26688func DecodeOxmIdTunMetadata58Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata58Masked, error) {
26689 _oxmidtunmetadata58masked := &OxmIdTunMetadata58Masked{OxmId: parent}
26690 return _oxmidtunmetadata58masked, nil
26691}
26692
26693func NewOxmIdTunMetadata58Masked() *OxmIdTunMetadata58Masked {
26694 obj := &OxmIdTunMetadata58Masked{
26695 OxmId: NewOxmId(116216),
26696 }
26697 return obj
26698}
26699func (self *OxmIdTunMetadata58Masked) GetOXMName() string {
26700 return "tun_metadata58_masked"
26701}
26702
26703func (self *OxmIdTunMetadata58Masked) MarshalJSON() ([]byte, error) {
26704 if self.TypeLen == 0 {
26705 return []byte("\"\""), nil
26706 } else {
26707 return []byte("\"" + self.GetOXMName() + "\""), nil
26708 }
26709}
26710
26711type OxmIdTunMetadata59 struct {
26712 *OxmId
26713}
26714
26715type IOxmIdTunMetadata59 interface {
26716 IOxmId
26717}
26718
26719func (self *OxmIdTunMetadata59) Serialize(encoder *goloxi.Encoder) error {
26720 if err := self.OxmId.Serialize(encoder); err != nil {
26721 return err
26722 }
26723
26724 return nil
26725}
26726
26727func DecodeOxmIdTunMetadata59(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata59, error) {
26728 _oxmidtunmetadata59 := &OxmIdTunMetadata59{OxmId: parent}
26729 return _oxmidtunmetadata59, nil
26730}
26731
26732func NewOxmIdTunMetadata59() *OxmIdTunMetadata59 {
26733 obj := &OxmIdTunMetadata59{
26734 OxmId: NewOxmId(116348),
26735 }
26736 return obj
26737}
26738func (self *OxmIdTunMetadata59) GetOXMName() string {
26739 return "tun_metadata59"
26740}
26741
26742func (self *OxmIdTunMetadata59) MarshalJSON() ([]byte, error) {
26743 if self.TypeLen == 0 {
26744 return []byte("\"\""), nil
26745 } else {
26746 return []byte("\"" + self.GetOXMName() + "\""), nil
26747 }
26748}
26749
26750type OxmIdTunMetadata59Masked struct {
26751 *OxmId
26752}
26753
26754type IOxmIdTunMetadata59Masked interface {
26755 IOxmId
26756}
26757
26758func (self *OxmIdTunMetadata59Masked) Serialize(encoder *goloxi.Encoder) error {
26759 if err := self.OxmId.Serialize(encoder); err != nil {
26760 return err
26761 }
26762
26763 return nil
26764}
26765
26766func DecodeOxmIdTunMetadata59Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata59Masked, error) {
26767 _oxmidtunmetadata59masked := &OxmIdTunMetadata59Masked{OxmId: parent}
26768 return _oxmidtunmetadata59masked, nil
26769}
26770
26771func NewOxmIdTunMetadata59Masked() *OxmIdTunMetadata59Masked {
26772 obj := &OxmIdTunMetadata59Masked{
26773 OxmId: NewOxmId(116728),
26774 }
26775 return obj
26776}
26777func (self *OxmIdTunMetadata59Masked) GetOXMName() string {
26778 return "tun_metadata59_masked"
26779}
26780
26781func (self *OxmIdTunMetadata59Masked) MarshalJSON() ([]byte, error) {
26782 if self.TypeLen == 0 {
26783 return []byte("\"\""), nil
26784 } else {
26785 return []byte("\"" + self.GetOXMName() + "\""), nil
26786 }
26787}
26788
26789type OxmIdTunMetadata5Masked struct {
26790 *OxmId
26791}
26792
26793type IOxmIdTunMetadata5Masked interface {
26794 IOxmId
26795}
26796
26797func (self *OxmIdTunMetadata5Masked) Serialize(encoder *goloxi.Encoder) error {
26798 if err := self.OxmId.Serialize(encoder); err != nil {
26799 return err
26800 }
26801
26802 return nil
26803}
26804
26805func DecodeOxmIdTunMetadata5Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata5Masked, error) {
26806 _oxmidtunmetadata5masked := &OxmIdTunMetadata5Masked{OxmId: parent}
26807 return _oxmidtunmetadata5masked, nil
26808}
26809
26810func NewOxmIdTunMetadata5Masked() *OxmIdTunMetadata5Masked {
26811 obj := &OxmIdTunMetadata5Masked{
26812 OxmId: NewOxmId(89080),
26813 }
26814 return obj
26815}
26816func (self *OxmIdTunMetadata5Masked) GetOXMName() string {
26817 return "tun_metadata5_masked"
26818}
26819
26820func (self *OxmIdTunMetadata5Masked) MarshalJSON() ([]byte, error) {
26821 if self.TypeLen == 0 {
26822 return []byte("\"\""), nil
26823 } else {
26824 return []byte("\"" + self.GetOXMName() + "\""), nil
26825 }
26826}
26827
26828type OxmIdTunMetadata6 struct {
26829 *OxmId
26830}
26831
26832type IOxmIdTunMetadata6 interface {
26833 IOxmId
26834}
26835
26836func (self *OxmIdTunMetadata6) Serialize(encoder *goloxi.Encoder) error {
26837 if err := self.OxmId.Serialize(encoder); err != nil {
26838 return err
26839 }
26840
26841 return nil
26842}
26843
26844func DecodeOxmIdTunMetadata6(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata6, error) {
26845 _oxmidtunmetadata6 := &OxmIdTunMetadata6{OxmId: parent}
26846 return _oxmidtunmetadata6, nil
26847}
26848
26849func NewOxmIdTunMetadata6() *OxmIdTunMetadata6 {
26850 obj := &OxmIdTunMetadata6{
26851 OxmId: NewOxmId(89212),
26852 }
26853 return obj
26854}
26855func (self *OxmIdTunMetadata6) GetOXMName() string {
26856 return "tun_metadata6"
26857}
26858
26859func (self *OxmIdTunMetadata6) MarshalJSON() ([]byte, error) {
26860 if self.TypeLen == 0 {
26861 return []byte("\"\""), nil
26862 } else {
26863 return []byte("\"" + self.GetOXMName() + "\""), nil
26864 }
26865}
26866
26867type OxmIdTunMetadata60 struct {
26868 *OxmId
26869}
26870
26871type IOxmIdTunMetadata60 interface {
26872 IOxmId
26873}
26874
26875func (self *OxmIdTunMetadata60) Serialize(encoder *goloxi.Encoder) error {
26876 if err := self.OxmId.Serialize(encoder); err != nil {
26877 return err
26878 }
26879
26880 return nil
26881}
26882
26883func DecodeOxmIdTunMetadata60(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata60, error) {
26884 _oxmidtunmetadata60 := &OxmIdTunMetadata60{OxmId: parent}
26885 return _oxmidtunmetadata60, nil
26886}
26887
26888func NewOxmIdTunMetadata60() *OxmIdTunMetadata60 {
26889 obj := &OxmIdTunMetadata60{
26890 OxmId: NewOxmId(116860),
26891 }
26892 return obj
26893}
26894func (self *OxmIdTunMetadata60) GetOXMName() string {
26895 return "tun_metadata60"
26896}
26897
26898func (self *OxmIdTunMetadata60) MarshalJSON() ([]byte, error) {
26899 if self.TypeLen == 0 {
26900 return []byte("\"\""), nil
26901 } else {
26902 return []byte("\"" + self.GetOXMName() + "\""), nil
26903 }
26904}
26905
26906type OxmIdTunMetadata60Masked struct {
26907 *OxmId
26908}
26909
26910type IOxmIdTunMetadata60Masked interface {
26911 IOxmId
26912}
26913
26914func (self *OxmIdTunMetadata60Masked) Serialize(encoder *goloxi.Encoder) error {
26915 if err := self.OxmId.Serialize(encoder); err != nil {
26916 return err
26917 }
26918
26919 return nil
26920}
26921
26922func DecodeOxmIdTunMetadata60Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata60Masked, error) {
26923 _oxmidtunmetadata60masked := &OxmIdTunMetadata60Masked{OxmId: parent}
26924 return _oxmidtunmetadata60masked, nil
26925}
26926
26927func NewOxmIdTunMetadata60Masked() *OxmIdTunMetadata60Masked {
26928 obj := &OxmIdTunMetadata60Masked{
26929 OxmId: NewOxmId(117240),
26930 }
26931 return obj
26932}
26933func (self *OxmIdTunMetadata60Masked) GetOXMName() string {
26934 return "tun_metadata60_masked"
26935}
26936
26937func (self *OxmIdTunMetadata60Masked) MarshalJSON() ([]byte, error) {
26938 if self.TypeLen == 0 {
26939 return []byte("\"\""), nil
26940 } else {
26941 return []byte("\"" + self.GetOXMName() + "\""), nil
26942 }
26943}
26944
26945type OxmIdTunMetadata61 struct {
26946 *OxmId
26947}
26948
26949type IOxmIdTunMetadata61 interface {
26950 IOxmId
26951}
26952
26953func (self *OxmIdTunMetadata61) Serialize(encoder *goloxi.Encoder) error {
26954 if err := self.OxmId.Serialize(encoder); err != nil {
26955 return err
26956 }
26957
26958 return nil
26959}
26960
26961func DecodeOxmIdTunMetadata61(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata61, error) {
26962 _oxmidtunmetadata61 := &OxmIdTunMetadata61{OxmId: parent}
26963 return _oxmidtunmetadata61, nil
26964}
26965
26966func NewOxmIdTunMetadata61() *OxmIdTunMetadata61 {
26967 obj := &OxmIdTunMetadata61{
26968 OxmId: NewOxmId(117372),
26969 }
26970 return obj
26971}
26972func (self *OxmIdTunMetadata61) GetOXMName() string {
26973 return "tun_metadata61"
26974}
26975
26976func (self *OxmIdTunMetadata61) MarshalJSON() ([]byte, error) {
26977 if self.TypeLen == 0 {
26978 return []byte("\"\""), nil
26979 } else {
26980 return []byte("\"" + self.GetOXMName() + "\""), nil
26981 }
26982}
26983
26984type OxmIdTunMetadata61Masked struct {
26985 *OxmId
26986}
26987
26988type IOxmIdTunMetadata61Masked interface {
26989 IOxmId
26990}
26991
26992func (self *OxmIdTunMetadata61Masked) Serialize(encoder *goloxi.Encoder) error {
26993 if err := self.OxmId.Serialize(encoder); err != nil {
26994 return err
26995 }
26996
26997 return nil
26998}
26999
27000func DecodeOxmIdTunMetadata61Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata61Masked, error) {
27001 _oxmidtunmetadata61masked := &OxmIdTunMetadata61Masked{OxmId: parent}
27002 return _oxmidtunmetadata61masked, nil
27003}
27004
27005func NewOxmIdTunMetadata61Masked() *OxmIdTunMetadata61Masked {
27006 obj := &OxmIdTunMetadata61Masked{
27007 OxmId: NewOxmId(117752),
27008 }
27009 return obj
27010}
27011func (self *OxmIdTunMetadata61Masked) GetOXMName() string {
27012 return "tun_metadata61_masked"
27013}
27014
27015func (self *OxmIdTunMetadata61Masked) MarshalJSON() ([]byte, error) {
27016 if self.TypeLen == 0 {
27017 return []byte("\"\""), nil
27018 } else {
27019 return []byte("\"" + self.GetOXMName() + "\""), nil
27020 }
27021}
27022
27023type OxmIdTunMetadata62 struct {
27024 *OxmId
27025}
27026
27027type IOxmIdTunMetadata62 interface {
27028 IOxmId
27029}
27030
27031func (self *OxmIdTunMetadata62) Serialize(encoder *goloxi.Encoder) error {
27032 if err := self.OxmId.Serialize(encoder); err != nil {
27033 return err
27034 }
27035
27036 return nil
27037}
27038
27039func DecodeOxmIdTunMetadata62(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata62, error) {
27040 _oxmidtunmetadata62 := &OxmIdTunMetadata62{OxmId: parent}
27041 return _oxmidtunmetadata62, nil
27042}
27043
27044func NewOxmIdTunMetadata62() *OxmIdTunMetadata62 {
27045 obj := &OxmIdTunMetadata62{
27046 OxmId: NewOxmId(117884),
27047 }
27048 return obj
27049}
27050func (self *OxmIdTunMetadata62) GetOXMName() string {
27051 return "tun_metadata62"
27052}
27053
27054func (self *OxmIdTunMetadata62) MarshalJSON() ([]byte, error) {
27055 if self.TypeLen == 0 {
27056 return []byte("\"\""), nil
27057 } else {
27058 return []byte("\"" + self.GetOXMName() + "\""), nil
27059 }
27060}
27061
27062type OxmIdTunMetadata62Masked struct {
27063 *OxmId
27064}
27065
27066type IOxmIdTunMetadata62Masked interface {
27067 IOxmId
27068}
27069
27070func (self *OxmIdTunMetadata62Masked) Serialize(encoder *goloxi.Encoder) error {
27071 if err := self.OxmId.Serialize(encoder); err != nil {
27072 return err
27073 }
27074
27075 return nil
27076}
27077
27078func DecodeOxmIdTunMetadata62Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata62Masked, error) {
27079 _oxmidtunmetadata62masked := &OxmIdTunMetadata62Masked{OxmId: parent}
27080 return _oxmidtunmetadata62masked, nil
27081}
27082
27083func NewOxmIdTunMetadata62Masked() *OxmIdTunMetadata62Masked {
27084 obj := &OxmIdTunMetadata62Masked{
27085 OxmId: NewOxmId(118264),
27086 }
27087 return obj
27088}
27089func (self *OxmIdTunMetadata62Masked) GetOXMName() string {
27090 return "tun_metadata62_masked"
27091}
27092
27093func (self *OxmIdTunMetadata62Masked) MarshalJSON() ([]byte, error) {
27094 if self.TypeLen == 0 {
27095 return []byte("\"\""), nil
27096 } else {
27097 return []byte("\"" + self.GetOXMName() + "\""), nil
27098 }
27099}
27100
27101type OxmIdTunMetadata63 struct {
27102 *OxmId
27103}
27104
27105type IOxmIdTunMetadata63 interface {
27106 IOxmId
27107}
27108
27109func (self *OxmIdTunMetadata63) Serialize(encoder *goloxi.Encoder) error {
27110 if err := self.OxmId.Serialize(encoder); err != nil {
27111 return err
27112 }
27113
27114 return nil
27115}
27116
27117func DecodeOxmIdTunMetadata63(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata63, error) {
27118 _oxmidtunmetadata63 := &OxmIdTunMetadata63{OxmId: parent}
27119 return _oxmidtunmetadata63, nil
27120}
27121
27122func NewOxmIdTunMetadata63() *OxmIdTunMetadata63 {
27123 obj := &OxmIdTunMetadata63{
27124 OxmId: NewOxmId(118396),
27125 }
27126 return obj
27127}
27128func (self *OxmIdTunMetadata63) GetOXMName() string {
27129 return "tun_metadata63"
27130}
27131
27132func (self *OxmIdTunMetadata63) MarshalJSON() ([]byte, error) {
27133 if self.TypeLen == 0 {
27134 return []byte("\"\""), nil
27135 } else {
27136 return []byte("\"" + self.GetOXMName() + "\""), nil
27137 }
27138}
27139
27140type OxmIdTunMetadata63Masked struct {
27141 *OxmId
27142}
27143
27144type IOxmIdTunMetadata63Masked interface {
27145 IOxmId
27146}
27147
27148func (self *OxmIdTunMetadata63Masked) Serialize(encoder *goloxi.Encoder) error {
27149 if err := self.OxmId.Serialize(encoder); err != nil {
27150 return err
27151 }
27152
27153 return nil
27154}
27155
27156func DecodeOxmIdTunMetadata63Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata63Masked, error) {
27157 _oxmidtunmetadata63masked := &OxmIdTunMetadata63Masked{OxmId: parent}
27158 return _oxmidtunmetadata63masked, nil
27159}
27160
27161func NewOxmIdTunMetadata63Masked() *OxmIdTunMetadata63Masked {
27162 obj := &OxmIdTunMetadata63Masked{
27163 OxmId: NewOxmId(118776),
27164 }
27165 return obj
27166}
27167func (self *OxmIdTunMetadata63Masked) GetOXMName() string {
27168 return "tun_metadata63_masked"
27169}
27170
27171func (self *OxmIdTunMetadata63Masked) MarshalJSON() ([]byte, error) {
27172 if self.TypeLen == 0 {
27173 return []byte("\"\""), nil
27174 } else {
27175 return []byte("\"" + self.GetOXMName() + "\""), nil
27176 }
27177}
27178
27179type OxmIdTunMetadata6Masked struct {
27180 *OxmId
27181}
27182
27183type IOxmIdTunMetadata6Masked interface {
27184 IOxmId
27185}
27186
27187func (self *OxmIdTunMetadata6Masked) Serialize(encoder *goloxi.Encoder) error {
27188 if err := self.OxmId.Serialize(encoder); err != nil {
27189 return err
27190 }
27191
27192 return nil
27193}
27194
27195func DecodeOxmIdTunMetadata6Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata6Masked, error) {
27196 _oxmidtunmetadata6masked := &OxmIdTunMetadata6Masked{OxmId: parent}
27197 return _oxmidtunmetadata6masked, nil
27198}
27199
27200func NewOxmIdTunMetadata6Masked() *OxmIdTunMetadata6Masked {
27201 obj := &OxmIdTunMetadata6Masked{
27202 OxmId: NewOxmId(89592),
27203 }
27204 return obj
27205}
27206func (self *OxmIdTunMetadata6Masked) GetOXMName() string {
27207 return "tun_metadata6_masked"
27208}
27209
27210func (self *OxmIdTunMetadata6Masked) MarshalJSON() ([]byte, error) {
27211 if self.TypeLen == 0 {
27212 return []byte("\"\""), nil
27213 } else {
27214 return []byte("\"" + self.GetOXMName() + "\""), nil
27215 }
27216}
27217
27218type OxmIdTunMetadata7 struct {
27219 *OxmId
27220}
27221
27222type IOxmIdTunMetadata7 interface {
27223 IOxmId
27224}
27225
27226func (self *OxmIdTunMetadata7) Serialize(encoder *goloxi.Encoder) error {
27227 if err := self.OxmId.Serialize(encoder); err != nil {
27228 return err
27229 }
27230
27231 return nil
27232}
27233
27234func DecodeOxmIdTunMetadata7(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata7, error) {
27235 _oxmidtunmetadata7 := &OxmIdTunMetadata7{OxmId: parent}
27236 return _oxmidtunmetadata7, nil
27237}
27238
27239func NewOxmIdTunMetadata7() *OxmIdTunMetadata7 {
27240 obj := &OxmIdTunMetadata7{
27241 OxmId: NewOxmId(89724),
27242 }
27243 return obj
27244}
27245func (self *OxmIdTunMetadata7) GetOXMName() string {
27246 return "tun_metadata7"
27247}
27248
27249func (self *OxmIdTunMetadata7) MarshalJSON() ([]byte, error) {
27250 if self.TypeLen == 0 {
27251 return []byte("\"\""), nil
27252 } else {
27253 return []byte("\"" + self.GetOXMName() + "\""), nil
27254 }
27255}
27256
27257type OxmIdTunMetadata7Masked struct {
27258 *OxmId
27259}
27260
27261type IOxmIdTunMetadata7Masked interface {
27262 IOxmId
27263}
27264
27265func (self *OxmIdTunMetadata7Masked) Serialize(encoder *goloxi.Encoder) error {
27266 if err := self.OxmId.Serialize(encoder); err != nil {
27267 return err
27268 }
27269
27270 return nil
27271}
27272
27273func DecodeOxmIdTunMetadata7Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata7Masked, error) {
27274 _oxmidtunmetadata7masked := &OxmIdTunMetadata7Masked{OxmId: parent}
27275 return _oxmidtunmetadata7masked, nil
27276}
27277
27278func NewOxmIdTunMetadata7Masked() *OxmIdTunMetadata7Masked {
27279 obj := &OxmIdTunMetadata7Masked{
27280 OxmId: NewOxmId(90104),
27281 }
27282 return obj
27283}
27284func (self *OxmIdTunMetadata7Masked) GetOXMName() string {
27285 return "tun_metadata7_masked"
27286}
27287
27288func (self *OxmIdTunMetadata7Masked) MarshalJSON() ([]byte, error) {
27289 if self.TypeLen == 0 {
27290 return []byte("\"\""), nil
27291 } else {
27292 return []byte("\"" + self.GetOXMName() + "\""), nil
27293 }
27294}
27295
27296type OxmIdTunMetadata8 struct {
27297 *OxmId
27298}
27299
27300type IOxmIdTunMetadata8 interface {
27301 IOxmId
27302}
27303
27304func (self *OxmIdTunMetadata8) Serialize(encoder *goloxi.Encoder) error {
27305 if err := self.OxmId.Serialize(encoder); err != nil {
27306 return err
27307 }
27308
27309 return nil
27310}
27311
27312func DecodeOxmIdTunMetadata8(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata8, error) {
27313 _oxmidtunmetadata8 := &OxmIdTunMetadata8{OxmId: parent}
27314 return _oxmidtunmetadata8, nil
27315}
27316
27317func NewOxmIdTunMetadata8() *OxmIdTunMetadata8 {
27318 obj := &OxmIdTunMetadata8{
27319 OxmId: NewOxmId(90236),
27320 }
27321 return obj
27322}
27323func (self *OxmIdTunMetadata8) GetOXMName() string {
27324 return "tun_metadata8"
27325}
27326
27327func (self *OxmIdTunMetadata8) MarshalJSON() ([]byte, error) {
27328 if self.TypeLen == 0 {
27329 return []byte("\"\""), nil
27330 } else {
27331 return []byte("\"" + self.GetOXMName() + "\""), nil
27332 }
27333}
27334
27335type OxmIdTunMetadata8Masked struct {
27336 *OxmId
27337}
27338
27339type IOxmIdTunMetadata8Masked interface {
27340 IOxmId
27341}
27342
27343func (self *OxmIdTunMetadata8Masked) Serialize(encoder *goloxi.Encoder) error {
27344 if err := self.OxmId.Serialize(encoder); err != nil {
27345 return err
27346 }
27347
27348 return nil
27349}
27350
27351func DecodeOxmIdTunMetadata8Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata8Masked, error) {
27352 _oxmidtunmetadata8masked := &OxmIdTunMetadata8Masked{OxmId: parent}
27353 return _oxmidtunmetadata8masked, nil
27354}
27355
27356func NewOxmIdTunMetadata8Masked() *OxmIdTunMetadata8Masked {
27357 obj := &OxmIdTunMetadata8Masked{
27358 OxmId: NewOxmId(90616),
27359 }
27360 return obj
27361}
27362func (self *OxmIdTunMetadata8Masked) GetOXMName() string {
27363 return "tun_metadata8_masked"
27364}
27365
27366func (self *OxmIdTunMetadata8Masked) MarshalJSON() ([]byte, error) {
27367 if self.TypeLen == 0 {
27368 return []byte("\"\""), nil
27369 } else {
27370 return []byte("\"" + self.GetOXMName() + "\""), nil
27371 }
27372}
27373
27374type OxmIdTunMetadata9 struct {
27375 *OxmId
27376}
27377
27378type IOxmIdTunMetadata9 interface {
27379 IOxmId
27380}
27381
27382func (self *OxmIdTunMetadata9) Serialize(encoder *goloxi.Encoder) error {
27383 if err := self.OxmId.Serialize(encoder); err != nil {
27384 return err
27385 }
27386
27387 return nil
27388}
27389
27390func DecodeOxmIdTunMetadata9(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata9, error) {
27391 _oxmidtunmetadata9 := &OxmIdTunMetadata9{OxmId: parent}
27392 return _oxmidtunmetadata9, nil
27393}
27394
27395func NewOxmIdTunMetadata9() *OxmIdTunMetadata9 {
27396 obj := &OxmIdTunMetadata9{
27397 OxmId: NewOxmId(90748),
27398 }
27399 return obj
27400}
27401func (self *OxmIdTunMetadata9) GetOXMName() string {
27402 return "tun_metadata9"
27403}
27404
27405func (self *OxmIdTunMetadata9) MarshalJSON() ([]byte, error) {
27406 if self.TypeLen == 0 {
27407 return []byte("\"\""), nil
27408 } else {
27409 return []byte("\"" + self.GetOXMName() + "\""), nil
27410 }
27411}
27412
27413type OxmIdTunMetadata9Masked struct {
27414 *OxmId
27415}
27416
27417type IOxmIdTunMetadata9Masked interface {
27418 IOxmId
27419}
27420
27421func (self *OxmIdTunMetadata9Masked) Serialize(encoder *goloxi.Encoder) error {
27422 if err := self.OxmId.Serialize(encoder); err != nil {
27423 return err
27424 }
27425
27426 return nil
27427}
27428
27429func DecodeOxmIdTunMetadata9Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata9Masked, error) {
27430 _oxmidtunmetadata9masked := &OxmIdTunMetadata9Masked{OxmId: parent}
27431 return _oxmidtunmetadata9masked, nil
27432}
27433
27434func NewOxmIdTunMetadata9Masked() *OxmIdTunMetadata9Masked {
27435 obj := &OxmIdTunMetadata9Masked{
27436 OxmId: NewOxmId(91128),
27437 }
27438 return obj
27439}
27440func (self *OxmIdTunMetadata9Masked) GetOXMName() string {
27441 return "tun_metadata9_masked"
27442}
27443
27444func (self *OxmIdTunMetadata9Masked) MarshalJSON() ([]byte, error) {
27445 if self.TypeLen == 0 {
27446 return []byte("\"\""), nil
27447 } else {
27448 return []byte("\"" + self.GetOXMName() + "\""), nil
27449 }
27450}
27451
27452type OxmIdTunSrc struct {
27453 *OxmId
27454}
27455
27456type IOxmIdTunSrc interface {
27457 IOxmId
27458}
27459
27460func (self *OxmIdTunSrc) Serialize(encoder *goloxi.Encoder) error {
27461 if err := self.OxmId.Serialize(encoder); err != nil {
27462 return err
27463 }
27464
27465 return nil
27466}
27467
27468func DecodeOxmIdTunSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunSrc, error) {
27469 _oxmidtunsrc := &OxmIdTunSrc{OxmId: parent}
27470 return _oxmidtunsrc, nil
27471}
27472
27473func NewOxmIdTunSrc() *OxmIdTunSrc {
27474 obj := &OxmIdTunSrc{
27475 OxmId: NewOxmId(81412),
27476 }
27477 return obj
27478}
27479func (self *OxmIdTunSrc) GetOXMName() string {
27480 return "tun_src"
27481}
27482
27483func (self *OxmIdTunSrc) MarshalJSON() ([]byte, error) {
27484 if self.TypeLen == 0 {
27485 return []byte("\"\""), nil
27486 } else {
27487 return []byte("\"" + self.GetOXMName() + "\""), nil
27488 }
27489}
27490
27491type OxmIdTunSrcMasked struct {
27492 *OxmId
27493}
27494
27495type IOxmIdTunSrcMasked interface {
27496 IOxmId
27497}
27498
27499func (self *OxmIdTunSrcMasked) Serialize(encoder *goloxi.Encoder) error {
27500 if err := self.OxmId.Serialize(encoder); err != nil {
27501 return err
27502 }
27503
27504 return nil
27505}
27506
27507func DecodeOxmIdTunSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunSrcMasked, error) {
27508 _oxmidtunsrcmasked := &OxmIdTunSrcMasked{OxmId: parent}
27509 return _oxmidtunsrcmasked, nil
27510}
27511
27512func NewOxmIdTunSrcMasked() *OxmIdTunSrcMasked {
27513 obj := &OxmIdTunSrcMasked{
27514 OxmId: NewOxmId(81672),
27515 }
27516 return obj
27517}
27518func (self *OxmIdTunSrcMasked) GetOXMName() string {
27519 return "tun_src_masked"
27520}
27521
27522func (self *OxmIdTunSrcMasked) MarshalJSON() ([]byte, error) {
27523 if self.TypeLen == 0 {
27524 return []byte("\"\""), nil
27525 } else {
27526 return []byte("\"" + self.GetOXMName() + "\""), nil
27527 }
27528}
27529
27530type OxmIdUdpDst struct {
27531 *OxmId
27532}
27533
27534type IOxmIdUdpDst interface {
27535 IOxmId
27536}
27537
27538func (self *OxmIdUdpDst) Serialize(encoder *goloxi.Encoder) error {
27539 if err := self.OxmId.Serialize(encoder); err != nil {
27540 return err
27541 }
27542
27543 return nil
27544}
27545
27546func DecodeOxmIdUdpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpDst, error) {
27547 _oxmidudpdst := &OxmIdUdpDst{OxmId: parent}
27548 return _oxmidudpdst, nil
27549}
27550
27551func NewOxmIdUdpDst() *OxmIdUdpDst {
27552 obj := &OxmIdUdpDst{
27553 OxmId: NewOxmId(6146),
27554 }
27555 return obj
27556}
27557func (self *OxmIdUdpDst) GetOXMName() string {
27558 return "udp_dst"
27559}
27560
27561func (self *OxmIdUdpDst) MarshalJSON() ([]byte, error) {
27562 if self.TypeLen == 0 {
27563 return []byte("\"\""), nil
27564 } else {
27565 return []byte("\"" + self.GetOXMName() + "\""), nil
27566 }
27567}
27568
27569type OxmIdUdpDstMasked struct {
27570 *OxmId
27571}
27572
27573type IOxmIdUdpDstMasked interface {
27574 IOxmId
27575}
27576
27577func (self *OxmIdUdpDstMasked) Serialize(encoder *goloxi.Encoder) error {
27578 if err := self.OxmId.Serialize(encoder); err != nil {
27579 return err
27580 }
27581
27582 return nil
27583}
27584
27585func DecodeOxmIdUdpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpDstMasked, error) {
27586 _oxmidudpdstmasked := &OxmIdUdpDstMasked{OxmId: parent}
27587 return _oxmidudpdstmasked, nil
27588}
27589
27590func NewOxmIdUdpDstMasked() *OxmIdUdpDstMasked {
27591 obj := &OxmIdUdpDstMasked{
27592 OxmId: NewOxmId(6404),
27593 }
27594 return obj
27595}
27596func (self *OxmIdUdpDstMasked) GetOXMName() string {
27597 return "udp_dst_masked"
27598}
27599
27600func (self *OxmIdUdpDstMasked) MarshalJSON() ([]byte, error) {
27601 if self.TypeLen == 0 {
27602 return []byte("\"\""), nil
27603 } else {
27604 return []byte("\"" + self.GetOXMName() + "\""), nil
27605 }
27606}
27607
27608type OxmIdUdpSrc struct {
27609 *OxmId
27610}
27611
27612type IOxmIdUdpSrc interface {
27613 IOxmId
27614}
27615
27616func (self *OxmIdUdpSrc) Serialize(encoder *goloxi.Encoder) error {
27617 if err := self.OxmId.Serialize(encoder); err != nil {
27618 return err
27619 }
27620
27621 return nil
27622}
27623
27624func DecodeOxmIdUdpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpSrc, error) {
27625 _oxmidudpsrc := &OxmIdUdpSrc{OxmId: parent}
27626 return _oxmidudpsrc, nil
27627}
27628
27629func NewOxmIdUdpSrc() *OxmIdUdpSrc {
27630 obj := &OxmIdUdpSrc{
27631 OxmId: NewOxmId(5634),
27632 }
27633 return obj
27634}
27635func (self *OxmIdUdpSrc) GetOXMName() string {
27636 return "udp_src"
27637}
27638
27639func (self *OxmIdUdpSrc) MarshalJSON() ([]byte, error) {
27640 if self.TypeLen == 0 {
27641 return []byte("\"\""), nil
27642 } else {
27643 return []byte("\"" + self.GetOXMName() + "\""), nil
27644 }
27645}
27646
27647type OxmIdUdpSrcMasked struct {
27648 *OxmId
27649}
27650
27651type IOxmIdUdpSrcMasked interface {
27652 IOxmId
27653}
27654
27655func (self *OxmIdUdpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
27656 if err := self.OxmId.Serialize(encoder); err != nil {
27657 return err
27658 }
27659
27660 return nil
27661}
27662
27663func DecodeOxmIdUdpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpSrcMasked, error) {
27664 _oxmidudpsrcmasked := &OxmIdUdpSrcMasked{OxmId: parent}
27665 return _oxmidudpsrcmasked, nil
27666}
27667
27668func NewOxmIdUdpSrcMasked() *OxmIdUdpSrcMasked {
27669 obj := &OxmIdUdpSrcMasked{
27670 OxmId: NewOxmId(5892),
27671 }
27672 return obj
27673}
27674func (self *OxmIdUdpSrcMasked) GetOXMName() string {
27675 return "udp_src_masked"
27676}
27677
27678func (self *OxmIdUdpSrcMasked) MarshalJSON() ([]byte, error) {
27679 if self.TypeLen == 0 {
27680 return []byte("\"\""), nil
27681 } else {
27682 return []byte("\"" + self.GetOXMName() + "\""), nil
27683 }
27684}
27685
27686type OxmIdVlanTci struct {
27687 *OxmId
27688}
27689
27690type IOxmIdVlanTci interface {
27691 IOxmId
27692}
27693
27694func (self *OxmIdVlanTci) Serialize(encoder *goloxi.Encoder) error {
27695 if err := self.OxmId.Serialize(encoder); err != nil {
27696 return err
27697 }
27698
27699 return nil
27700}
27701
27702func DecodeOxmIdVlanTci(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanTci, error) {
27703 _oxmidvlantci := &OxmIdVlanTci{OxmId: parent}
27704 return _oxmidvlantci, nil
27705}
27706
27707func NewOxmIdVlanTci() *OxmIdVlanTci {
27708 obj := &OxmIdVlanTci{
27709 OxmId: NewOxmId(2050),
27710 }
27711 return obj
27712}
27713func (self *OxmIdVlanTci) GetOXMName() string {
27714 return "vlan_tci"
27715}
27716
27717func (self *OxmIdVlanTci) MarshalJSON() ([]byte, error) {
27718 if self.TypeLen == 0 {
27719 return []byte("\"\""), nil
27720 } else {
27721 return []byte("\"" + self.GetOXMName() + "\""), nil
27722 }
27723}
27724
27725type OxmIdVlanTciMasked struct {
27726 *OxmId
27727}
27728
27729type IOxmIdVlanTciMasked interface {
27730 IOxmId
27731}
27732
27733func (self *OxmIdVlanTciMasked) Serialize(encoder *goloxi.Encoder) error {
27734 if err := self.OxmId.Serialize(encoder); err != nil {
27735 return err
27736 }
27737
27738 return nil
27739}
27740
27741func DecodeOxmIdVlanTciMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanTciMasked, error) {
27742 _oxmidvlantcimasked := &OxmIdVlanTciMasked{OxmId: parent}
27743 return _oxmidvlantcimasked, nil
27744}
27745
27746func NewOxmIdVlanTciMasked() *OxmIdVlanTciMasked {
27747 obj := &OxmIdVlanTciMasked{
27748 OxmId: NewOxmId(2308),
27749 }
27750 return obj
27751}
27752func (self *OxmIdVlanTciMasked) GetOXMName() string {
27753 return "vlan_tci_masked"
27754}
27755
27756func (self *OxmIdVlanTciMasked) MarshalJSON() ([]byte, error) {
27757 if self.TypeLen == 0 {
27758 return []byte("\"\""), nil
27759 } else {
27760 return []byte("\"" + self.GetOXMName() + "\""), nil
27761 }
27762}
27763
27764type OxmIdXxreg0 struct {
27765 *OxmId
27766}
27767
27768type IOxmIdXxreg0 interface {
27769 IOxmId
27770}
27771
27772func (self *OxmIdXxreg0) Serialize(encoder *goloxi.Encoder) error {
27773 if err := self.OxmId.Serialize(encoder); err != nil {
27774 return err
27775 }
27776
27777 return nil
27778}
27779
27780func DecodeOxmIdXxreg0(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg0, error) {
27781 _oxmidxxreg0 := &OxmIdXxreg0{OxmId: parent}
27782 return _oxmidxxreg0, nil
27783}
27784
27785func NewOxmIdXxreg0() *OxmIdXxreg0 {
27786 obj := &OxmIdXxreg0{
27787 OxmId: NewOxmId(122384),
27788 }
27789 return obj
27790}
27791func (self *OxmIdXxreg0) GetOXMName() string {
27792 return "xxreg0"
27793}
27794
27795func (self *OxmIdXxreg0) MarshalJSON() ([]byte, error) {
27796 if self.TypeLen == 0 {
27797 return []byte("\"\""), nil
27798 } else {
27799 return []byte("\"" + self.GetOXMName() + "\""), nil
27800 }
27801}
27802
27803type OxmIdXxreg0Masked struct {
27804 *OxmId
27805}
27806
27807type IOxmIdXxreg0Masked interface {
27808 IOxmId
27809}
27810
27811func (self *OxmIdXxreg0Masked) Serialize(encoder *goloxi.Encoder) error {
27812 if err := self.OxmId.Serialize(encoder); err != nil {
27813 return err
27814 }
27815
27816 return nil
27817}
27818
27819func DecodeOxmIdXxreg0Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg0Masked, error) {
27820 _oxmidxxreg0masked := &OxmIdXxreg0Masked{OxmId: parent}
27821 return _oxmidxxreg0masked, nil
27822}
27823
27824func NewOxmIdXxreg0Masked() *OxmIdXxreg0Masked {
27825 obj := &OxmIdXxreg0Masked{
27826 OxmId: NewOxmId(122656),
27827 }
27828 return obj
27829}
27830func (self *OxmIdXxreg0Masked) GetOXMName() string {
27831 return "xxreg0_masked"
27832}
27833
27834func (self *OxmIdXxreg0Masked) MarshalJSON() ([]byte, error) {
27835 if self.TypeLen == 0 {
27836 return []byte("\"\""), nil
27837 } else {
27838 return []byte("\"" + self.GetOXMName() + "\""), nil
27839 }
27840}
27841
27842type OxmIdXxreg1 struct {
27843 *OxmId
27844}
27845
27846type IOxmIdXxreg1 interface {
27847 IOxmId
27848}
27849
27850func (self *OxmIdXxreg1) Serialize(encoder *goloxi.Encoder) error {
27851 if err := self.OxmId.Serialize(encoder); err != nil {
27852 return err
27853 }
27854
27855 return nil
27856}
27857
27858func DecodeOxmIdXxreg1(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg1, error) {
27859 _oxmidxxreg1 := &OxmIdXxreg1{OxmId: parent}
27860 return _oxmidxxreg1, nil
27861}
27862
27863func NewOxmIdXxreg1() *OxmIdXxreg1 {
27864 obj := &OxmIdXxreg1{
27865 OxmId: NewOxmId(122896),
27866 }
27867 return obj
27868}
27869func (self *OxmIdXxreg1) GetOXMName() string {
27870 return "xxreg1"
27871}
27872
27873func (self *OxmIdXxreg1) MarshalJSON() ([]byte, error) {
27874 if self.TypeLen == 0 {
27875 return []byte("\"\""), nil
27876 } else {
27877 return []byte("\"" + self.GetOXMName() + "\""), nil
27878 }
27879}
27880
27881type OxmIdXxreg1Masked struct {
27882 *OxmId
27883}
27884
27885type IOxmIdXxreg1Masked interface {
27886 IOxmId
27887}
27888
27889func (self *OxmIdXxreg1Masked) Serialize(encoder *goloxi.Encoder) error {
27890 if err := self.OxmId.Serialize(encoder); err != nil {
27891 return err
27892 }
27893
27894 return nil
27895}
27896
27897func DecodeOxmIdXxreg1Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg1Masked, error) {
27898 _oxmidxxreg1masked := &OxmIdXxreg1Masked{OxmId: parent}
27899 return _oxmidxxreg1masked, nil
27900}
27901
27902func NewOxmIdXxreg1Masked() *OxmIdXxreg1Masked {
27903 obj := &OxmIdXxreg1Masked{
27904 OxmId: NewOxmId(123168),
27905 }
27906 return obj
27907}
27908func (self *OxmIdXxreg1Masked) GetOXMName() string {
27909 return "xxreg1_masked"
27910}
27911
27912func (self *OxmIdXxreg1Masked) MarshalJSON() ([]byte, error) {
27913 if self.TypeLen == 0 {
27914 return []byte("\"\""), nil
27915 } else {
27916 return []byte("\"" + self.GetOXMName() + "\""), nil
27917 }
27918}
27919
27920type OxmIdXxreg2 struct {
27921 *OxmId
27922}
27923
27924type IOxmIdXxreg2 interface {
27925 IOxmId
27926}
27927
27928func (self *OxmIdXxreg2) Serialize(encoder *goloxi.Encoder) error {
27929 if err := self.OxmId.Serialize(encoder); err != nil {
27930 return err
27931 }
27932
27933 return nil
27934}
27935
27936func DecodeOxmIdXxreg2(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg2, error) {
27937 _oxmidxxreg2 := &OxmIdXxreg2{OxmId: parent}
27938 return _oxmidxxreg2, nil
27939}
27940
27941func NewOxmIdXxreg2() *OxmIdXxreg2 {
27942 obj := &OxmIdXxreg2{
27943 OxmId: NewOxmId(123408),
27944 }
27945 return obj
27946}
27947func (self *OxmIdXxreg2) GetOXMName() string {
27948 return "xxreg2"
27949}
27950
27951func (self *OxmIdXxreg2) MarshalJSON() ([]byte, error) {
27952 if self.TypeLen == 0 {
27953 return []byte("\"\""), nil
27954 } else {
27955 return []byte("\"" + self.GetOXMName() + "\""), nil
27956 }
27957}
27958
27959type OxmIdXxreg2Masked struct {
27960 *OxmId
27961}
27962
27963type IOxmIdXxreg2Masked interface {
27964 IOxmId
27965}
27966
27967func (self *OxmIdXxreg2Masked) Serialize(encoder *goloxi.Encoder) error {
27968 if err := self.OxmId.Serialize(encoder); err != nil {
27969 return err
27970 }
27971
27972 return nil
27973}
27974
27975func DecodeOxmIdXxreg2Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg2Masked, error) {
27976 _oxmidxxreg2masked := &OxmIdXxreg2Masked{OxmId: parent}
27977 return _oxmidxxreg2masked, nil
27978}
27979
27980func NewOxmIdXxreg2Masked() *OxmIdXxreg2Masked {
27981 obj := &OxmIdXxreg2Masked{
27982 OxmId: NewOxmId(123680),
27983 }
27984 return obj
27985}
27986func (self *OxmIdXxreg2Masked) GetOXMName() string {
27987 return "xxreg2_masked"
27988}
27989
27990func (self *OxmIdXxreg2Masked) MarshalJSON() ([]byte, error) {
27991 if self.TypeLen == 0 {
27992 return []byte("\"\""), nil
27993 } else {
27994 return []byte("\"" + self.GetOXMName() + "\""), nil
27995 }
27996}
27997
27998type OxmIdXxreg3 struct {
27999 *OxmId
28000}
28001
28002type IOxmIdXxreg3 interface {
28003 IOxmId
28004}
28005
28006func (self *OxmIdXxreg3) Serialize(encoder *goloxi.Encoder) error {
28007 if err := self.OxmId.Serialize(encoder); err != nil {
28008 return err
28009 }
28010
28011 return nil
28012}
28013
28014func DecodeOxmIdXxreg3(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg3, error) {
28015 _oxmidxxreg3 := &OxmIdXxreg3{OxmId: parent}
28016 return _oxmidxxreg3, nil
28017}
28018
28019func NewOxmIdXxreg3() *OxmIdXxreg3 {
28020 obj := &OxmIdXxreg3{
28021 OxmId: NewOxmId(123920),
28022 }
28023 return obj
28024}
28025func (self *OxmIdXxreg3) GetOXMName() string {
28026 return "xxreg3"
28027}
28028
28029func (self *OxmIdXxreg3) MarshalJSON() ([]byte, error) {
28030 if self.TypeLen == 0 {
28031 return []byte("\"\""), nil
28032 } else {
28033 return []byte("\"" + self.GetOXMName() + "\""), nil
28034 }
28035}
28036
28037type OxmIdXxreg3Masked struct {
28038 *OxmId
28039}
28040
28041type IOxmIdXxreg3Masked interface {
28042 IOxmId
28043}
28044
28045func (self *OxmIdXxreg3Masked) Serialize(encoder *goloxi.Encoder) error {
28046 if err := self.OxmId.Serialize(encoder); err != nil {
28047 return err
28048 }
28049
28050 return nil
28051}
28052
28053func DecodeOxmIdXxreg3Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg3Masked, error) {
28054 _oxmidxxreg3masked := &OxmIdXxreg3Masked{OxmId: parent}
28055 return _oxmidxxreg3masked, nil
28056}
28057
28058func NewOxmIdXxreg3Masked() *OxmIdXxreg3Masked {
28059 obj := &OxmIdXxreg3Masked{
28060 OxmId: NewOxmId(124192),
28061 }
28062 return obj
28063}
28064func (self *OxmIdXxreg3Masked) GetOXMName() string {
28065 return "xxreg3_masked"
28066}
28067
28068func (self *OxmIdXxreg3Masked) MarshalJSON() ([]byte, error) {
28069 if self.TypeLen == 0 {
28070 return []byte("\"\""), nil
28071 } else {
28072 return []byte("\"" + self.GetOXMName() + "\""), nil
28073 }
28074}
28075
28076type OxmIdActsetOutput struct {
28077 *OxmId
28078}
28079
28080type IOxmIdActsetOutput interface {
28081 IOxmId
28082}
28083
28084func (self *OxmIdActsetOutput) Serialize(encoder *goloxi.Encoder) error {
28085 if err := self.OxmId.Serialize(encoder); err != nil {
28086 return err
28087 }
28088
28089 return nil
28090}
28091
28092func DecodeOxmIdActsetOutput(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdActsetOutput, error) {
28093 _oxmidactsetoutput := &OxmIdActsetOutput{OxmId: parent}
28094 return _oxmidactsetoutput, nil
28095}
28096
28097func NewOxmIdActsetOutput() *OxmIdActsetOutput {
28098 obj := &OxmIdActsetOutput{
28099 OxmId: NewOxmId(2147505668),
28100 }
28101 return obj
28102}
28103func (self *OxmIdActsetOutput) GetOXMName() string {
28104 return "actset_output"
28105}
28106
28107func (self *OxmIdActsetOutput) MarshalJSON() ([]byte, error) {
28108 if self.TypeLen == 0 {
28109 return []byte("\"\""), nil
28110 } else {
28111 return []byte("\"" + self.GetOXMName() + "\""), nil
28112 }
28113}
28114
28115type OxmIdActsetOutputMasked struct {
28116 *OxmId
28117}
28118
28119type IOxmIdActsetOutputMasked interface {
28120 IOxmId
28121}
28122
28123func (self *OxmIdActsetOutputMasked) Serialize(encoder *goloxi.Encoder) error {
28124 if err := self.OxmId.Serialize(encoder); err != nil {
28125 return err
28126 }
28127
28128 return nil
28129}
28130
28131func DecodeOxmIdActsetOutputMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdActsetOutputMasked, error) {
28132 _oxmidactsetoutputmasked := &OxmIdActsetOutputMasked{OxmId: parent}
28133 return _oxmidactsetoutputmasked, nil
28134}
28135
28136func NewOxmIdActsetOutputMasked() *OxmIdActsetOutputMasked {
28137 obj := &OxmIdActsetOutputMasked{
28138 OxmId: NewOxmId(2147505928),
28139 }
28140 return obj
28141}
28142func (self *OxmIdActsetOutputMasked) GetOXMName() string {
28143 return "actset_output_masked"
28144}
28145
28146func (self *OxmIdActsetOutputMasked) MarshalJSON() ([]byte, error) {
28147 if self.TypeLen == 0 {
28148 return []byte("\"\""), nil
28149 } else {
28150 return []byte("\"" + self.GetOXMName() + "\""), nil
28151 }
28152}
28153
28154type OxmIdArpOpMasked struct {
28155 *OxmId
28156}
28157
28158type IOxmIdArpOpMasked interface {
28159 IOxmId
28160}
28161
28162func (self *OxmIdArpOpMasked) Serialize(encoder *goloxi.Encoder) error {
28163 if err := self.OxmId.Serialize(encoder); err != nil {
28164 return err
28165 }
28166
28167 return nil
28168}
28169
28170func DecodeOxmIdArpOpMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpOpMasked, error) {
28171 _oxmidarpopmasked := &OxmIdArpOpMasked{OxmId: parent}
28172 return _oxmidarpopmasked, nil
28173}
28174
28175func NewOxmIdArpOpMasked() *OxmIdArpOpMasked {
28176 obj := &OxmIdArpOpMasked{
28177 OxmId: NewOxmId(2147494660),
28178 }
28179 return obj
28180}
28181func (self *OxmIdArpOpMasked) GetOXMName() string {
28182 return "arp_op_masked"
28183}
28184
28185func (self *OxmIdArpOpMasked) MarshalJSON() ([]byte, error) {
28186 if self.TypeLen == 0 {
28187 return []byte("\"\""), nil
28188 } else {
28189 return []byte("\"" + self.GetOXMName() + "\""), nil
28190 }
28191}
28192
28193type OxmIdBsnEgrPortGroupId struct {
28194 *OxmId
28195}
28196
28197type IOxmIdBsnEgrPortGroupId interface {
28198 IOxmId
28199}
28200
28201func (self *OxmIdBsnEgrPortGroupId) Serialize(encoder *goloxi.Encoder) error {
28202 if err := self.OxmId.Serialize(encoder); err != nil {
28203 return err
28204 }
28205
28206 return nil
28207}
28208
28209func DecodeOxmIdBsnEgrPortGroupId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnEgrPortGroupId, error) {
28210 _oxmidbsnegrportgroupid := &OxmIdBsnEgrPortGroupId{OxmId: parent}
28211 return _oxmidbsnegrportgroupid, nil
28212}
28213
28214func NewOxmIdBsnEgrPortGroupId() *OxmIdBsnEgrPortGroupId {
28215 obj := &OxmIdBsnEgrPortGroupId{
28216 OxmId: NewOxmId(200196),
28217 }
28218 return obj
28219}
28220func (self *OxmIdBsnEgrPortGroupId) GetOXMName() string {
28221 return "bsn_egr_port_group_id"
28222}
28223
28224func (self *OxmIdBsnEgrPortGroupId) MarshalJSON() ([]byte, error) {
28225 if self.TypeLen == 0 {
28226 return []byte("\"\""), nil
28227 } else {
28228 return []byte("\"" + self.GetOXMName() + "\""), nil
28229 }
28230}
28231
28232type OxmIdBsnEgrPortGroupIdMasked struct {
28233 *OxmId
28234}
28235
28236type IOxmIdBsnEgrPortGroupIdMasked interface {
28237 IOxmId
28238}
28239
28240func (self *OxmIdBsnEgrPortGroupIdMasked) Serialize(encoder *goloxi.Encoder) error {
28241 if err := self.OxmId.Serialize(encoder); err != nil {
28242 return err
28243 }
28244
28245 return nil
28246}
28247
28248func DecodeOxmIdBsnEgrPortGroupIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnEgrPortGroupIdMasked, error) {
28249 _oxmidbsnegrportgroupidmasked := &OxmIdBsnEgrPortGroupIdMasked{OxmId: parent}
28250 return _oxmidbsnegrportgroupidmasked, nil
28251}
28252
28253func NewOxmIdBsnEgrPortGroupIdMasked() *OxmIdBsnEgrPortGroupIdMasked {
28254 obj := &OxmIdBsnEgrPortGroupIdMasked{
28255 OxmId: NewOxmId(200456),
28256 }
28257 return obj
28258}
28259func (self *OxmIdBsnEgrPortGroupIdMasked) GetOXMName() string {
28260 return "bsn_egr_port_group_id_masked"
28261}
28262
28263func (self *OxmIdBsnEgrPortGroupIdMasked) MarshalJSON() ([]byte, error) {
28264 if self.TypeLen == 0 {
28265 return []byte("\"\""), nil
28266 } else {
28267 return []byte("\"" + self.GetOXMName() + "\""), nil
28268 }
28269}
28270
28271type OxmIdBsnIfpClassId struct {
28272 *OxmId
28273}
28274
28275type IOxmIdBsnIfpClassId interface {
28276 IOxmId
28277}
28278
28279func (self *OxmIdBsnIfpClassId) Serialize(encoder *goloxi.Encoder) error {
28280 if err := self.OxmId.Serialize(encoder); err != nil {
28281 return err
28282 }
28283
28284 return nil
28285}
28286
28287func DecodeOxmIdBsnIfpClassId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnIfpClassId, error) {
28288 _oxmidbsnifpclassid := &OxmIdBsnIfpClassId{OxmId: parent}
28289 return _oxmidbsnifpclassid, nil
28290}
28291
28292func NewOxmIdBsnIfpClassId() *OxmIdBsnIfpClassId {
28293 obj := &OxmIdBsnIfpClassId{
28294 OxmId: NewOxmId(210436),
28295 }
28296 return obj
28297}
28298func (self *OxmIdBsnIfpClassId) GetOXMName() string {
28299 return "bsn_ifp_class_id"
28300}
28301
28302func (self *OxmIdBsnIfpClassId) MarshalJSON() ([]byte, error) {
28303 if self.TypeLen == 0 {
28304 return []byte("\"\""), nil
28305 } else {
28306 return []byte("\"" + self.GetOXMName() + "\""), nil
28307 }
28308}
28309
28310type OxmIdBsnIfpClassIdMasked struct {
28311 *OxmId
28312}
28313
28314type IOxmIdBsnIfpClassIdMasked interface {
28315 IOxmId
28316}
28317
28318func (self *OxmIdBsnIfpClassIdMasked) Serialize(encoder *goloxi.Encoder) error {
28319 if err := self.OxmId.Serialize(encoder); err != nil {
28320 return err
28321 }
28322
28323 return nil
28324}
28325
28326func DecodeOxmIdBsnIfpClassIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnIfpClassIdMasked, error) {
28327 _oxmidbsnifpclassidmasked := &OxmIdBsnIfpClassIdMasked{OxmId: parent}
28328 return _oxmidbsnifpclassidmasked, nil
28329}
28330
28331func NewOxmIdBsnIfpClassIdMasked() *OxmIdBsnIfpClassIdMasked {
28332 obj := &OxmIdBsnIfpClassIdMasked{
28333 OxmId: NewOxmId(210696),
28334 }
28335 return obj
28336}
28337func (self *OxmIdBsnIfpClassIdMasked) GetOXMName() string {
28338 return "bsn_ifp_class_id_masked"
28339}
28340
28341func (self *OxmIdBsnIfpClassIdMasked) MarshalJSON() ([]byte, error) {
28342 if self.TypeLen == 0 {
28343 return []byte("\"\""), nil
28344 } else {
28345 return []byte("\"" + self.GetOXMName() + "\""), nil
28346 }
28347}
28348
28349type OxmIdBsnInPorts128 struct {
28350 *OxmId
28351}
28352
28353type IOxmIdBsnInPorts128 interface {
28354 IOxmId
28355}
28356
28357func (self *OxmIdBsnInPorts128) Serialize(encoder *goloxi.Encoder) error {
28358 if err := self.OxmId.Serialize(encoder); err != nil {
28359 return err
28360 }
28361
28362 return nil
28363}
28364
28365func DecodeOxmIdBsnInPorts128(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInPorts128, error) {
28366 _oxmidbsninports128 := &OxmIdBsnInPorts128{OxmId: parent}
28367 return _oxmidbsninports128, nil
28368}
28369
28370func NewOxmIdBsnInPorts128() *OxmIdBsnInPorts128 {
28371 obj := &OxmIdBsnInPorts128{
28372 OxmId: NewOxmId(196624),
28373 }
28374 return obj
28375}
28376func (self *OxmIdBsnInPorts128) GetOXMName() string {
28377 return "bsn_in_ports_128"
28378}
28379
28380func (self *OxmIdBsnInPorts128) MarshalJSON() ([]byte, error) {
28381 if self.TypeLen == 0 {
28382 return []byte("\"\""), nil
28383 } else {
28384 return []byte("\"" + self.GetOXMName() + "\""), nil
28385 }
28386}
28387
28388type OxmIdBsnInPorts128Masked struct {
28389 *OxmId
28390}
28391
28392type IOxmIdBsnInPorts128Masked interface {
28393 IOxmId
28394}
28395
28396func (self *OxmIdBsnInPorts128Masked) Serialize(encoder *goloxi.Encoder) error {
28397 if err := self.OxmId.Serialize(encoder); err != nil {
28398 return err
28399 }
28400
28401 return nil
28402}
28403
28404func DecodeOxmIdBsnInPorts128Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInPorts128Masked, error) {
28405 _oxmidbsninports128masked := &OxmIdBsnInPorts128Masked{OxmId: parent}
28406 return _oxmidbsninports128masked, nil
28407}
28408
28409func NewOxmIdBsnInPorts128Masked() *OxmIdBsnInPorts128Masked {
28410 obj := &OxmIdBsnInPorts128Masked{
28411 OxmId: NewOxmId(196896),
28412 }
28413 return obj
28414}
28415func (self *OxmIdBsnInPorts128Masked) GetOXMName() string {
28416 return "bsn_in_ports_128_masked"
28417}
28418
28419func (self *OxmIdBsnInPorts128Masked) MarshalJSON() ([]byte, error) {
28420 if self.TypeLen == 0 {
28421 return []byte("\"\""), nil
28422 } else {
28423 return []byte("\"" + self.GetOXMName() + "\""), nil
28424 }
28425}
28426
28427type OxmIdBsnInPorts512 struct {
28428 *OxmId
28429}
28430
28431type IOxmIdBsnInPorts512 interface {
28432 IOxmId
28433}
28434
28435func (self *OxmIdBsnInPorts512) Serialize(encoder *goloxi.Encoder) error {
28436 if err := self.OxmId.Serialize(encoder); err != nil {
28437 return err
28438 }
28439
28440 return nil
28441}
28442
28443func DecodeOxmIdBsnInPorts512(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInPorts512, error) {
28444 _oxmidbsninports512 := &OxmIdBsnInPorts512{OxmId: parent}
28445 return _oxmidbsninports512, nil
28446}
28447
28448func NewOxmIdBsnInPorts512() *OxmIdBsnInPorts512 {
28449 obj := &OxmIdBsnInPorts512{
28450 OxmId: NewOxmId(206400),
28451 }
28452 return obj
28453}
28454func (self *OxmIdBsnInPorts512) GetOXMName() string {
28455 return "bsn_in_ports_512"
28456}
28457
28458func (self *OxmIdBsnInPorts512) MarshalJSON() ([]byte, error) {
28459 if self.TypeLen == 0 {
28460 return []byte("\"\""), nil
28461 } else {
28462 return []byte("\"" + self.GetOXMName() + "\""), nil
28463 }
28464}
28465
28466type OxmIdBsnInPorts512Masked struct {
28467 *OxmId
28468}
28469
28470type IOxmIdBsnInPorts512Masked interface {
28471 IOxmId
28472}
28473
28474func (self *OxmIdBsnInPorts512Masked) Serialize(encoder *goloxi.Encoder) error {
28475 if err := self.OxmId.Serialize(encoder); err != nil {
28476 return err
28477 }
28478
28479 return nil
28480}
28481
28482func DecodeOxmIdBsnInPorts512Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInPorts512Masked, error) {
28483 _oxmidbsninports512masked := &OxmIdBsnInPorts512Masked{OxmId: parent}
28484 return _oxmidbsninports512masked, nil
28485}
28486
28487func NewOxmIdBsnInPorts512Masked() *OxmIdBsnInPorts512Masked {
28488 obj := &OxmIdBsnInPorts512Masked{
28489 OxmId: NewOxmId(206720),
28490 }
28491 return obj
28492}
28493func (self *OxmIdBsnInPorts512Masked) GetOXMName() string {
28494 return "bsn_in_ports_512_masked"
28495}
28496
28497func (self *OxmIdBsnInPorts512Masked) MarshalJSON() ([]byte, error) {
28498 if self.TypeLen == 0 {
28499 return []byte("\"\""), nil
28500 } else {
28501 return []byte("\"" + self.GetOXMName() + "\""), nil
28502 }
28503}
28504
28505type OxmIdBsnIngressPortGroupId struct {
28506 *OxmId
28507}
28508
28509type IOxmIdBsnIngressPortGroupId interface {
28510 IOxmId
28511}
28512
28513func (self *OxmIdBsnIngressPortGroupId) Serialize(encoder *goloxi.Encoder) error {
28514 if err := self.OxmId.Serialize(encoder); err != nil {
28515 return err
28516 }
28517
28518 return nil
28519}
28520
28521func DecodeOxmIdBsnIngressPortGroupId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnIngressPortGroupId, error) {
28522 _oxmidbsningressportgroupid := &OxmIdBsnIngressPortGroupId{OxmId: parent}
28523 return _oxmidbsningressportgroupid, nil
28524}
28525
28526func NewOxmIdBsnIngressPortGroupId() *OxmIdBsnIngressPortGroupId {
28527 obj := &OxmIdBsnIngressPortGroupId{
28528 OxmId: NewOxmId(206852),
28529 }
28530 return obj
28531}
28532func (self *OxmIdBsnIngressPortGroupId) GetOXMName() string {
28533 return "bsn_ingress_port_group_id"
28534}
28535
28536func (self *OxmIdBsnIngressPortGroupId) MarshalJSON() ([]byte, error) {
28537 if self.TypeLen == 0 {
28538 return []byte("\"\""), nil
28539 } else {
28540 return []byte("\"" + self.GetOXMName() + "\""), nil
28541 }
28542}
28543
28544type OxmIdBsnIngressPortGroupIdMasked struct {
28545 *OxmId
28546}
28547
28548type IOxmIdBsnIngressPortGroupIdMasked interface {
28549 IOxmId
28550}
28551
28552func (self *OxmIdBsnIngressPortGroupIdMasked) Serialize(encoder *goloxi.Encoder) error {
28553 if err := self.OxmId.Serialize(encoder); err != nil {
28554 return err
28555 }
28556
28557 return nil
28558}
28559
28560func DecodeOxmIdBsnIngressPortGroupIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnIngressPortGroupIdMasked, error) {
28561 _oxmidbsningressportgroupidmasked := &OxmIdBsnIngressPortGroupIdMasked{OxmId: parent}
28562 return _oxmidbsningressportgroupidmasked, nil
28563}
28564
28565func NewOxmIdBsnIngressPortGroupIdMasked() *OxmIdBsnIngressPortGroupIdMasked {
28566 obj := &OxmIdBsnIngressPortGroupIdMasked{
28567 OxmId: NewOxmId(207112),
28568 }
28569 return obj
28570}
28571func (self *OxmIdBsnIngressPortGroupIdMasked) GetOXMName() string {
28572 return "bsn_ingress_port_group_id_masked"
28573}
28574
28575func (self *OxmIdBsnIngressPortGroupIdMasked) MarshalJSON() ([]byte, error) {
28576 if self.TypeLen == 0 {
28577 return []byte("\"\""), nil
28578 } else {
28579 return []byte("\"" + self.GetOXMName() + "\""), nil
28580 }
28581}
28582
28583type OxmIdBsnInnerEthDst struct {
28584 *OxmId
28585}
28586
28587type IOxmIdBsnInnerEthDst interface {
28588 IOxmId
28589}
28590
28591func (self *OxmIdBsnInnerEthDst) Serialize(encoder *goloxi.Encoder) error {
28592 if err := self.OxmId.Serialize(encoder); err != nil {
28593 return err
28594 }
28595
28596 return nil
28597}
28598
28599func DecodeOxmIdBsnInnerEthDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInnerEthDst, error) {
28600 _oxmidbsninnerethdst := &OxmIdBsnInnerEthDst{OxmId: parent}
28601 return _oxmidbsninnerethdst, nil
28602}
28603
28604func NewOxmIdBsnInnerEthDst() *OxmIdBsnInnerEthDst {
28605 obj := &OxmIdBsnInnerEthDst{
28606 OxmId: NewOxmId(207878),
28607 }
28608 return obj
28609}
28610func (self *OxmIdBsnInnerEthDst) GetOXMName() string {
28611 return "bsn_inner_eth_dst"
28612}
28613
28614func (self *OxmIdBsnInnerEthDst) MarshalJSON() ([]byte, error) {
28615 if self.TypeLen == 0 {
28616 return []byte("\"\""), nil
28617 } else {
28618 return []byte("\"" + self.GetOXMName() + "\""), nil
28619 }
28620}
28621
28622type OxmIdBsnInnerEthDstMasked struct {
28623 *OxmId
28624}
28625
28626type IOxmIdBsnInnerEthDstMasked interface {
28627 IOxmId
28628}
28629
28630func (self *OxmIdBsnInnerEthDstMasked) Serialize(encoder *goloxi.Encoder) error {
28631 if err := self.OxmId.Serialize(encoder); err != nil {
28632 return err
28633 }
28634
28635 return nil
28636}
28637
28638func DecodeOxmIdBsnInnerEthDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInnerEthDstMasked, error) {
28639 _oxmidbsninnerethdstmasked := &OxmIdBsnInnerEthDstMasked{OxmId: parent}
28640 return _oxmidbsninnerethdstmasked, nil
28641}
28642
28643func NewOxmIdBsnInnerEthDstMasked() *OxmIdBsnInnerEthDstMasked {
28644 obj := &OxmIdBsnInnerEthDstMasked{
28645 OxmId: NewOxmId(208140),
28646 }
28647 return obj
28648}
28649func (self *OxmIdBsnInnerEthDstMasked) GetOXMName() string {
28650 return "bsn_inner_eth_dst_masked"
28651}
28652
28653func (self *OxmIdBsnInnerEthDstMasked) MarshalJSON() ([]byte, error) {
28654 if self.TypeLen == 0 {
28655 return []byte("\"\""), nil
28656 } else {
28657 return []byte("\"" + self.GetOXMName() + "\""), nil
28658 }
28659}
28660
28661type OxmIdBsnInnerEthSrc struct {
28662 *OxmId
28663}
28664
28665type IOxmIdBsnInnerEthSrc interface {
28666 IOxmId
28667}
28668
28669func (self *OxmIdBsnInnerEthSrc) Serialize(encoder *goloxi.Encoder) error {
28670 if err := self.OxmId.Serialize(encoder); err != nil {
28671 return err
28672 }
28673
28674 return nil
28675}
28676
28677func DecodeOxmIdBsnInnerEthSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInnerEthSrc, error) {
28678 _oxmidbsninnerethsrc := &OxmIdBsnInnerEthSrc{OxmId: parent}
28679 return _oxmidbsninnerethsrc, nil
28680}
28681
28682func NewOxmIdBsnInnerEthSrc() *OxmIdBsnInnerEthSrc {
28683 obj := &OxmIdBsnInnerEthSrc{
28684 OxmId: NewOxmId(208390),
28685 }
28686 return obj
28687}
28688func (self *OxmIdBsnInnerEthSrc) GetOXMName() string {
28689 return "bsn_inner_eth_src"
28690}
28691
28692func (self *OxmIdBsnInnerEthSrc) MarshalJSON() ([]byte, error) {
28693 if self.TypeLen == 0 {
28694 return []byte("\"\""), nil
28695 } else {
28696 return []byte("\"" + self.GetOXMName() + "\""), nil
28697 }
28698}
28699
28700type OxmIdBsnInnerEthSrcMasked struct {
28701 *OxmId
28702}
28703
28704type IOxmIdBsnInnerEthSrcMasked interface {
28705 IOxmId
28706}
28707
28708func (self *OxmIdBsnInnerEthSrcMasked) Serialize(encoder *goloxi.Encoder) error {
28709 if err := self.OxmId.Serialize(encoder); err != nil {
28710 return err
28711 }
28712
28713 return nil
28714}
28715
28716func DecodeOxmIdBsnInnerEthSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInnerEthSrcMasked, error) {
28717 _oxmidbsninnerethsrcmasked := &OxmIdBsnInnerEthSrcMasked{OxmId: parent}
28718 return _oxmidbsninnerethsrcmasked, nil
28719}
28720
28721func NewOxmIdBsnInnerEthSrcMasked() *OxmIdBsnInnerEthSrcMasked {
28722 obj := &OxmIdBsnInnerEthSrcMasked{
28723 OxmId: NewOxmId(208652),
28724 }
28725 return obj
28726}
28727func (self *OxmIdBsnInnerEthSrcMasked) GetOXMName() string {
28728 return "bsn_inner_eth_src_masked"
28729}
28730
28731func (self *OxmIdBsnInnerEthSrcMasked) MarshalJSON() ([]byte, error) {
28732 if self.TypeLen == 0 {
28733 return []byte("\"\""), nil
28734 } else {
28735 return []byte("\"" + self.GetOXMName() + "\""), nil
28736 }
28737}
28738
28739type OxmIdBsnInnerVlanVid struct {
28740 *OxmId
28741}
28742
28743type IOxmIdBsnInnerVlanVid interface {
28744 IOxmId
28745}
28746
28747func (self *OxmIdBsnInnerVlanVid) Serialize(encoder *goloxi.Encoder) error {
28748 if err := self.OxmId.Serialize(encoder); err != nil {
28749 return err
28750 }
28751
28752 return nil
28753}
28754
28755func DecodeOxmIdBsnInnerVlanVid(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInnerVlanVid, error) {
28756 _oxmidbsninnervlanvid := &OxmIdBsnInnerVlanVid{OxmId: parent}
28757 return _oxmidbsninnervlanvid, nil
28758}
28759
28760func NewOxmIdBsnInnerVlanVid() *OxmIdBsnInnerVlanVid {
28761 obj := &OxmIdBsnInnerVlanVid{
28762 OxmId: NewOxmId(208898),
28763 }
28764 return obj
28765}
28766func (self *OxmIdBsnInnerVlanVid) GetOXMName() string {
28767 return "bsn_inner_vlan_vid"
28768}
28769
28770func (self *OxmIdBsnInnerVlanVid) MarshalJSON() ([]byte, error) {
28771 if self.TypeLen == 0 {
28772 return []byte("\"\""), nil
28773 } else {
28774 return []byte("\"" + self.GetOXMName() + "\""), nil
28775 }
28776}
28777
28778type OxmIdBsnInnerVlanVidMasked struct {
28779 *OxmId
28780}
28781
28782type IOxmIdBsnInnerVlanVidMasked interface {
28783 IOxmId
28784}
28785
28786func (self *OxmIdBsnInnerVlanVidMasked) Serialize(encoder *goloxi.Encoder) error {
28787 if err := self.OxmId.Serialize(encoder); err != nil {
28788 return err
28789 }
28790
28791 return nil
28792}
28793
28794func DecodeOxmIdBsnInnerVlanVidMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInnerVlanVidMasked, error) {
28795 _oxmidbsninnervlanvidmasked := &OxmIdBsnInnerVlanVidMasked{OxmId: parent}
28796 return _oxmidbsninnervlanvidmasked, nil
28797}
28798
28799func NewOxmIdBsnInnerVlanVidMasked() *OxmIdBsnInnerVlanVidMasked {
28800 obj := &OxmIdBsnInnerVlanVidMasked{
28801 OxmId: NewOxmId(209156),
28802 }
28803 return obj
28804}
28805func (self *OxmIdBsnInnerVlanVidMasked) GetOXMName() string {
28806 return "bsn_inner_vlan_vid_masked"
28807}
28808
28809func (self *OxmIdBsnInnerVlanVidMasked) MarshalJSON() ([]byte, error) {
28810 if self.TypeLen == 0 {
28811 return []byte("\"\""), nil
28812 } else {
28813 return []byte("\"" + self.GetOXMName() + "\""), nil
28814 }
28815}
28816
28817type OxmIdBsnIpFragmentation struct {
28818 *OxmId
28819}
28820
28821type IOxmIdBsnIpFragmentation interface {
28822 IOxmId
28823}
28824
28825func (self *OxmIdBsnIpFragmentation) Serialize(encoder *goloxi.Encoder) error {
28826 if err := self.OxmId.Serialize(encoder); err != nil {
28827 return err
28828 }
28829
28830 return nil
28831}
28832
28833func DecodeOxmIdBsnIpFragmentation(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnIpFragmentation, error) {
28834 _oxmidbsnipfragmentation := &OxmIdBsnIpFragmentation{OxmId: parent}
28835 return _oxmidbsnipfragmentation, nil
28836}
28837
28838func NewOxmIdBsnIpFragmentation() *OxmIdBsnIpFragmentation {
28839 obj := &OxmIdBsnIpFragmentation{
28840 OxmId: NewOxmId(209921),
28841 }
28842 return obj
28843}
28844func (self *OxmIdBsnIpFragmentation) GetOXMName() string {
28845 return "bsn_ip_fragmentation"
28846}
28847
28848func (self *OxmIdBsnIpFragmentation) MarshalJSON() ([]byte, error) {
28849 if self.TypeLen == 0 {
28850 return []byte("\"\""), nil
28851 } else {
28852 return []byte("\"" + self.GetOXMName() + "\""), nil
28853 }
28854}
28855
28856type OxmIdBsnIpFragmentationMasked struct {
28857 *OxmId
28858}
28859
28860type IOxmIdBsnIpFragmentationMasked interface {
28861 IOxmId
28862}
28863
28864func (self *OxmIdBsnIpFragmentationMasked) Serialize(encoder *goloxi.Encoder) error {
28865 if err := self.OxmId.Serialize(encoder); err != nil {
28866 return err
28867 }
28868
28869 return nil
28870}
28871
28872func DecodeOxmIdBsnIpFragmentationMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnIpFragmentationMasked, error) {
28873 _oxmidbsnipfragmentationmasked := &OxmIdBsnIpFragmentationMasked{OxmId: parent}
28874 return _oxmidbsnipfragmentationmasked, nil
28875}
28876
28877func NewOxmIdBsnIpFragmentationMasked() *OxmIdBsnIpFragmentationMasked {
28878 obj := &OxmIdBsnIpFragmentationMasked{
28879 OxmId: NewOxmId(210178),
28880 }
28881 return obj
28882}
28883func (self *OxmIdBsnIpFragmentationMasked) GetOXMName() string {
28884 return "bsn_ip_fragmentation_masked"
28885}
28886
28887func (self *OxmIdBsnIpFragmentationMasked) MarshalJSON() ([]byte, error) {
28888 if self.TypeLen == 0 {
28889 return []byte("\"\""), nil
28890 } else {
28891 return []byte("\"" + self.GetOXMName() + "\""), nil
28892 }
28893}
28894
28895type OxmIdBsnL2CacheHit struct {
28896 *OxmId
28897}
28898
28899type IOxmIdBsnL2CacheHit interface {
28900 IOxmId
28901}
28902
28903func (self *OxmIdBsnL2CacheHit) Serialize(encoder *goloxi.Encoder) error {
28904 if err := self.OxmId.Serialize(encoder); err != nil {
28905 return err
28906 }
28907
28908 return nil
28909}
28910
28911func DecodeOxmIdBsnL2CacheHit(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL2CacheHit, error) {
28912 _oxmidbsnl2cachehit := &OxmIdBsnL2CacheHit{OxmId: parent}
28913 return _oxmidbsnl2cachehit, nil
28914}
28915
28916func NewOxmIdBsnL2CacheHit() *OxmIdBsnL2CacheHit {
28917 obj := &OxmIdBsnL2CacheHit{
28918 OxmId: NewOxmId(205825),
28919 }
28920 return obj
28921}
28922func (self *OxmIdBsnL2CacheHit) GetOXMName() string {
28923 return "bsn_l2_cache_hit"
28924}
28925
28926func (self *OxmIdBsnL2CacheHit) MarshalJSON() ([]byte, error) {
28927 if self.TypeLen == 0 {
28928 return []byte("\"\""), nil
28929 } else {
28930 return []byte("\"" + self.GetOXMName() + "\""), nil
28931 }
28932}
28933
28934type OxmIdBsnL2CacheHitMasked struct {
28935 *OxmId
28936}
28937
28938type IOxmIdBsnL2CacheHitMasked interface {
28939 IOxmId
28940}
28941
28942func (self *OxmIdBsnL2CacheHitMasked) Serialize(encoder *goloxi.Encoder) error {
28943 if err := self.OxmId.Serialize(encoder); err != nil {
28944 return err
28945 }
28946
28947 return nil
28948}
28949
28950func DecodeOxmIdBsnL2CacheHitMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL2CacheHitMasked, error) {
28951 _oxmidbsnl2cachehitmasked := &OxmIdBsnL2CacheHitMasked{OxmId: parent}
28952 return _oxmidbsnl2cachehitmasked, nil
28953}
28954
28955func NewOxmIdBsnL2CacheHitMasked() *OxmIdBsnL2CacheHitMasked {
28956 obj := &OxmIdBsnL2CacheHitMasked{
28957 OxmId: NewOxmId(206082),
28958 }
28959 return obj
28960}
28961func (self *OxmIdBsnL2CacheHitMasked) GetOXMName() string {
28962 return "bsn_l2_cache_hit_masked"
28963}
28964
28965func (self *OxmIdBsnL2CacheHitMasked) MarshalJSON() ([]byte, error) {
28966 if self.TypeLen == 0 {
28967 return []byte("\"\""), nil
28968 } else {
28969 return []byte("\"" + self.GetOXMName() + "\""), nil
28970 }
28971}
28972
28973type OxmIdBsnL3InterfaceClassId struct {
28974 *OxmId
28975}
28976
28977type IOxmIdBsnL3InterfaceClassId interface {
28978 IOxmId
28979}
28980
28981func (self *OxmIdBsnL3InterfaceClassId) Serialize(encoder *goloxi.Encoder) error {
28982 if err := self.OxmId.Serialize(encoder); err != nil {
28983 return err
28984 }
28985
28986 return nil
28987}
28988
28989func DecodeOxmIdBsnL3InterfaceClassId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL3InterfaceClassId, error) {
28990 _oxmidbsnl3interfaceclassid := &OxmIdBsnL3InterfaceClassId{OxmId: parent}
28991 return _oxmidbsnl3interfaceclassid, nil
28992}
28993
28994func NewOxmIdBsnL3InterfaceClassId() *OxmIdBsnL3InterfaceClassId {
28995 obj := &OxmIdBsnL3InterfaceClassId{
28996 OxmId: NewOxmId(198660),
28997 }
28998 return obj
28999}
29000func (self *OxmIdBsnL3InterfaceClassId) GetOXMName() string {
29001 return "bsn_l3_interface_class_id"
29002}
29003
29004func (self *OxmIdBsnL3InterfaceClassId) MarshalJSON() ([]byte, error) {
29005 if self.TypeLen == 0 {
29006 return []byte("\"\""), nil
29007 } else {
29008 return []byte("\"" + self.GetOXMName() + "\""), nil
29009 }
29010}
29011
29012type OxmIdBsnL3InterfaceClassIdMasked struct {
29013 *OxmId
29014}
29015
29016type IOxmIdBsnL3InterfaceClassIdMasked interface {
29017 IOxmId
29018}
29019
29020func (self *OxmIdBsnL3InterfaceClassIdMasked) Serialize(encoder *goloxi.Encoder) error {
29021 if err := self.OxmId.Serialize(encoder); err != nil {
29022 return err
29023 }
29024
29025 return nil
29026}
29027
29028func DecodeOxmIdBsnL3InterfaceClassIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL3InterfaceClassIdMasked, error) {
29029 _oxmidbsnl3interfaceclassidmasked := &OxmIdBsnL3InterfaceClassIdMasked{OxmId: parent}
29030 return _oxmidbsnl3interfaceclassidmasked, nil
29031}
29032
29033func NewOxmIdBsnL3InterfaceClassIdMasked() *OxmIdBsnL3InterfaceClassIdMasked {
29034 obj := &OxmIdBsnL3InterfaceClassIdMasked{
29035 OxmId: NewOxmId(198920),
29036 }
29037 return obj
29038}
29039func (self *OxmIdBsnL3InterfaceClassIdMasked) GetOXMName() string {
29040 return "bsn_l3_interface_class_id_masked"
29041}
29042
29043func (self *OxmIdBsnL3InterfaceClassIdMasked) MarshalJSON() ([]byte, error) {
29044 if self.TypeLen == 0 {
29045 return []byte("\"\""), nil
29046 } else {
29047 return []byte("\"" + self.GetOXMName() + "\""), nil
29048 }
29049}
29050
29051type OxmIdBsnL3SrcClassId struct {
29052 *OxmId
29053}
29054
29055type IOxmIdBsnL3SrcClassId interface {
29056 IOxmId
29057}
29058
29059func (self *OxmIdBsnL3SrcClassId) Serialize(encoder *goloxi.Encoder) error {
29060 if err := self.OxmId.Serialize(encoder); err != nil {
29061 return err
29062 }
29063
29064 return nil
29065}
29066
29067func DecodeOxmIdBsnL3SrcClassId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL3SrcClassId, error) {
29068 _oxmidbsnl3srcclassid := &OxmIdBsnL3SrcClassId{OxmId: parent}
29069 return _oxmidbsnl3srcclassid, nil
29070}
29071
29072func NewOxmIdBsnL3SrcClassId() *OxmIdBsnL3SrcClassId {
29073 obj := &OxmIdBsnL3SrcClassId{
29074 OxmId: NewOxmId(199172),
29075 }
29076 return obj
29077}
29078func (self *OxmIdBsnL3SrcClassId) GetOXMName() string {
29079 return "bsn_l3_src_class_id"
29080}
29081
29082func (self *OxmIdBsnL3SrcClassId) MarshalJSON() ([]byte, error) {
29083 if self.TypeLen == 0 {
29084 return []byte("\"\""), nil
29085 } else {
29086 return []byte("\"" + self.GetOXMName() + "\""), nil
29087 }
29088}
29089
29090type OxmIdBsnL3SrcClassIdMasked struct {
29091 *OxmId
29092}
29093
29094type IOxmIdBsnL3SrcClassIdMasked interface {
29095 IOxmId
29096}
29097
29098func (self *OxmIdBsnL3SrcClassIdMasked) Serialize(encoder *goloxi.Encoder) error {
29099 if err := self.OxmId.Serialize(encoder); err != nil {
29100 return err
29101 }
29102
29103 return nil
29104}
29105
29106func DecodeOxmIdBsnL3SrcClassIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL3SrcClassIdMasked, error) {
29107 _oxmidbsnl3srcclassidmasked := &OxmIdBsnL3SrcClassIdMasked{OxmId: parent}
29108 return _oxmidbsnl3srcclassidmasked, nil
29109}
29110
29111func NewOxmIdBsnL3SrcClassIdMasked() *OxmIdBsnL3SrcClassIdMasked {
29112 obj := &OxmIdBsnL3SrcClassIdMasked{
29113 OxmId: NewOxmId(199432),
29114 }
29115 return obj
29116}
29117func (self *OxmIdBsnL3SrcClassIdMasked) GetOXMName() string {
29118 return "bsn_l3_src_class_id_masked"
29119}
29120
29121func (self *OxmIdBsnL3SrcClassIdMasked) MarshalJSON() ([]byte, error) {
29122 if self.TypeLen == 0 {
29123 return []byte("\"\""), nil
29124 } else {
29125 return []byte("\"" + self.GetOXMName() + "\""), nil
29126 }
29127}
29128
29129type OxmIdBsnLagId struct {
29130 *OxmId
29131}
29132
29133type IOxmIdBsnLagId interface {
29134 IOxmId
29135}
29136
29137func (self *OxmIdBsnLagId) Serialize(encoder *goloxi.Encoder) error {
29138 if err := self.OxmId.Serialize(encoder); err != nil {
29139 return err
29140 }
29141
29142 return nil
29143}
29144
29145func DecodeOxmIdBsnLagId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnLagId, error) {
29146 _oxmidbsnlagid := &OxmIdBsnLagId{OxmId: parent}
29147 return _oxmidbsnlagid, nil
29148}
29149
29150func NewOxmIdBsnLagId() *OxmIdBsnLagId {
29151 obj := &OxmIdBsnLagId{
29152 OxmId: NewOxmId(197124),
29153 }
29154 return obj
29155}
29156func (self *OxmIdBsnLagId) GetOXMName() string {
29157 return "bsn_lag_id"
29158}
29159
29160func (self *OxmIdBsnLagId) MarshalJSON() ([]byte, error) {
29161 if self.TypeLen == 0 {
29162 return []byte("\"\""), nil
29163 } else {
29164 return []byte("\"" + self.GetOXMName() + "\""), nil
29165 }
29166}
29167
29168type OxmIdBsnLagIdMasked struct {
29169 *OxmId
29170}
29171
29172type IOxmIdBsnLagIdMasked interface {
29173 IOxmId
29174}
29175
29176func (self *OxmIdBsnLagIdMasked) Serialize(encoder *goloxi.Encoder) error {
29177 if err := self.OxmId.Serialize(encoder); err != nil {
29178 return err
29179 }
29180
29181 return nil
29182}
29183
29184func DecodeOxmIdBsnLagIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnLagIdMasked, error) {
29185 _oxmidbsnlagidmasked := &OxmIdBsnLagIdMasked{OxmId: parent}
29186 return _oxmidbsnlagidmasked, nil
29187}
29188
29189func NewOxmIdBsnLagIdMasked() *OxmIdBsnLagIdMasked {
29190 obj := &OxmIdBsnLagIdMasked{
29191 OxmId: NewOxmId(197384),
29192 }
29193 return obj
29194}
29195func (self *OxmIdBsnLagIdMasked) GetOXMName() string {
29196 return "bsn_lag_id_masked"
29197}
29198
29199func (self *OxmIdBsnLagIdMasked) MarshalJSON() ([]byte, error) {
29200 if self.TypeLen == 0 {
29201 return []byte("\"\""), nil
29202 } else {
29203 return []byte("\"" + self.GetOXMName() + "\""), nil
29204 }
29205}
29206
29207type OxmIdBsnTcpFlags struct {
29208 *OxmId
29209}
29210
29211type IOxmIdBsnTcpFlags interface {
29212 IOxmId
29213}
29214
29215func (self *OxmIdBsnTcpFlags) Serialize(encoder *goloxi.Encoder) error {
29216 if err := self.OxmId.Serialize(encoder); err != nil {
29217 return err
29218 }
29219
29220 return nil
29221}
29222
29223func DecodeOxmIdBsnTcpFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnTcpFlags, error) {
29224 _oxmidbsntcpflags := &OxmIdBsnTcpFlags{OxmId: parent}
29225 return _oxmidbsntcpflags, nil
29226}
29227
29228func NewOxmIdBsnTcpFlags() *OxmIdBsnTcpFlags {
29229 obj := &OxmIdBsnTcpFlags{
29230 OxmId: NewOxmId(204802),
29231 }
29232 return obj
29233}
29234func (self *OxmIdBsnTcpFlags) GetOXMName() string {
29235 return "bsn_tcp_flags"
29236}
29237
29238func (self *OxmIdBsnTcpFlags) MarshalJSON() ([]byte, error) {
29239 if self.TypeLen == 0 {
29240 return []byte("\"\""), nil
29241 } else {
29242 return []byte("\"" + self.GetOXMName() + "\""), nil
29243 }
29244}
29245
29246type OxmIdBsnTcpFlagsMasked struct {
29247 *OxmId
29248}
29249
29250type IOxmIdBsnTcpFlagsMasked interface {
29251 IOxmId
29252}
29253
29254func (self *OxmIdBsnTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
29255 if err := self.OxmId.Serialize(encoder); err != nil {
29256 return err
29257 }
29258
29259 return nil
29260}
29261
29262func DecodeOxmIdBsnTcpFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnTcpFlagsMasked, error) {
29263 _oxmidbsntcpflagsmasked := &OxmIdBsnTcpFlagsMasked{OxmId: parent}
29264 return _oxmidbsntcpflagsmasked, nil
29265}
29266
29267func NewOxmIdBsnTcpFlagsMasked() *OxmIdBsnTcpFlagsMasked {
29268 obj := &OxmIdBsnTcpFlagsMasked{
29269 OxmId: NewOxmId(205060),
29270 }
29271 return obj
29272}
29273func (self *OxmIdBsnTcpFlagsMasked) GetOXMName() string {
29274 return "bsn_tcp_flags_masked"
29275}
29276
29277func (self *OxmIdBsnTcpFlagsMasked) MarshalJSON() ([]byte, error) {
29278 if self.TypeLen == 0 {
29279 return []byte("\"\""), nil
29280 } else {
29281 return []byte("\"" + self.GetOXMName() + "\""), nil
29282 }
29283}
29284
29285type OxmIdBsnUdf0 struct {
29286 *OxmId
29287}
29288
29289type IOxmIdBsnUdf0 interface {
29290 IOxmId
29291}
29292
29293func (self *OxmIdBsnUdf0) Serialize(encoder *goloxi.Encoder) error {
29294 if err := self.OxmId.Serialize(encoder); err != nil {
29295 return err
29296 }
29297
29298 return nil
29299}
29300
29301func DecodeOxmIdBsnUdf0(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf0, error) {
29302 _oxmidbsnudf0 := &OxmIdBsnUdf0{OxmId: parent}
29303 return _oxmidbsnudf0, nil
29304}
29305
29306func NewOxmIdBsnUdf0() *OxmIdBsnUdf0 {
29307 obj := &OxmIdBsnUdf0{
29308 OxmId: NewOxmId(200708),
29309 }
29310 return obj
29311}
29312func (self *OxmIdBsnUdf0) GetOXMName() string {
29313 return "bsn_udf0"
29314}
29315
29316func (self *OxmIdBsnUdf0) MarshalJSON() ([]byte, error) {
29317 if self.TypeLen == 0 {
29318 return []byte("\"\""), nil
29319 } else {
29320 return []byte("\"" + self.GetOXMName() + "\""), nil
29321 }
29322}
29323
29324type OxmIdBsnUdf0Masked struct {
29325 *OxmId
29326}
29327
29328type IOxmIdBsnUdf0Masked interface {
29329 IOxmId
29330}
29331
29332func (self *OxmIdBsnUdf0Masked) Serialize(encoder *goloxi.Encoder) error {
29333 if err := self.OxmId.Serialize(encoder); err != nil {
29334 return err
29335 }
29336
29337 return nil
29338}
29339
29340func DecodeOxmIdBsnUdf0Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf0Masked, error) {
29341 _oxmidbsnudf0masked := &OxmIdBsnUdf0Masked{OxmId: parent}
29342 return _oxmidbsnudf0masked, nil
29343}
29344
29345func NewOxmIdBsnUdf0Masked() *OxmIdBsnUdf0Masked {
29346 obj := &OxmIdBsnUdf0Masked{
29347 OxmId: NewOxmId(200968),
29348 }
29349 return obj
29350}
29351func (self *OxmIdBsnUdf0Masked) GetOXMName() string {
29352 return "bsn_udf0_masked"
29353}
29354
29355func (self *OxmIdBsnUdf0Masked) MarshalJSON() ([]byte, error) {
29356 if self.TypeLen == 0 {
29357 return []byte("\"\""), nil
29358 } else {
29359 return []byte("\"" + self.GetOXMName() + "\""), nil
29360 }
29361}
29362
29363type OxmIdBsnUdf1 struct {
29364 *OxmId
29365}
29366
29367type IOxmIdBsnUdf1 interface {
29368 IOxmId
29369}
29370
29371func (self *OxmIdBsnUdf1) Serialize(encoder *goloxi.Encoder) error {
29372 if err := self.OxmId.Serialize(encoder); err != nil {
29373 return err
29374 }
29375
29376 return nil
29377}
29378
29379func DecodeOxmIdBsnUdf1(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf1, error) {
29380 _oxmidbsnudf1 := &OxmIdBsnUdf1{OxmId: parent}
29381 return _oxmidbsnudf1, nil
29382}
29383
29384func NewOxmIdBsnUdf1() *OxmIdBsnUdf1 {
29385 obj := &OxmIdBsnUdf1{
29386 OxmId: NewOxmId(201220),
29387 }
29388 return obj
29389}
29390func (self *OxmIdBsnUdf1) GetOXMName() string {
29391 return "bsn_udf1"
29392}
29393
29394func (self *OxmIdBsnUdf1) MarshalJSON() ([]byte, error) {
29395 if self.TypeLen == 0 {
29396 return []byte("\"\""), nil
29397 } else {
29398 return []byte("\"" + self.GetOXMName() + "\""), nil
29399 }
29400}
29401
29402type OxmIdBsnUdf1Masked struct {
29403 *OxmId
29404}
29405
29406type IOxmIdBsnUdf1Masked interface {
29407 IOxmId
29408}
29409
29410func (self *OxmIdBsnUdf1Masked) Serialize(encoder *goloxi.Encoder) error {
29411 if err := self.OxmId.Serialize(encoder); err != nil {
29412 return err
29413 }
29414
29415 return nil
29416}
29417
29418func DecodeOxmIdBsnUdf1Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf1Masked, error) {
29419 _oxmidbsnudf1masked := &OxmIdBsnUdf1Masked{OxmId: parent}
29420 return _oxmidbsnudf1masked, nil
29421}
29422
29423func NewOxmIdBsnUdf1Masked() *OxmIdBsnUdf1Masked {
29424 obj := &OxmIdBsnUdf1Masked{
29425 OxmId: NewOxmId(201480),
29426 }
29427 return obj
29428}
29429func (self *OxmIdBsnUdf1Masked) GetOXMName() string {
29430 return "bsn_udf1_masked"
29431}
29432
29433func (self *OxmIdBsnUdf1Masked) MarshalJSON() ([]byte, error) {
29434 if self.TypeLen == 0 {
29435 return []byte("\"\""), nil
29436 } else {
29437 return []byte("\"" + self.GetOXMName() + "\""), nil
29438 }
29439}
29440
29441type OxmIdBsnUdf2 struct {
29442 *OxmId
29443}
29444
29445type IOxmIdBsnUdf2 interface {
29446 IOxmId
29447}
29448
29449func (self *OxmIdBsnUdf2) Serialize(encoder *goloxi.Encoder) error {
29450 if err := self.OxmId.Serialize(encoder); err != nil {
29451 return err
29452 }
29453
29454 return nil
29455}
29456
29457func DecodeOxmIdBsnUdf2(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf2, error) {
29458 _oxmidbsnudf2 := &OxmIdBsnUdf2{OxmId: parent}
29459 return _oxmidbsnudf2, nil
29460}
29461
29462func NewOxmIdBsnUdf2() *OxmIdBsnUdf2 {
29463 obj := &OxmIdBsnUdf2{
29464 OxmId: NewOxmId(201732),
29465 }
29466 return obj
29467}
29468func (self *OxmIdBsnUdf2) GetOXMName() string {
29469 return "bsn_udf2"
29470}
29471
29472func (self *OxmIdBsnUdf2) MarshalJSON() ([]byte, error) {
29473 if self.TypeLen == 0 {
29474 return []byte("\"\""), nil
29475 } else {
29476 return []byte("\"" + self.GetOXMName() + "\""), nil
29477 }
29478}
29479
29480type OxmIdBsnUdf2Masked struct {
29481 *OxmId
29482}
29483
29484type IOxmIdBsnUdf2Masked interface {
29485 IOxmId
29486}
29487
29488func (self *OxmIdBsnUdf2Masked) Serialize(encoder *goloxi.Encoder) error {
29489 if err := self.OxmId.Serialize(encoder); err != nil {
29490 return err
29491 }
29492
29493 return nil
29494}
29495
29496func DecodeOxmIdBsnUdf2Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf2Masked, error) {
29497 _oxmidbsnudf2masked := &OxmIdBsnUdf2Masked{OxmId: parent}
29498 return _oxmidbsnudf2masked, nil
29499}
29500
29501func NewOxmIdBsnUdf2Masked() *OxmIdBsnUdf2Masked {
29502 obj := &OxmIdBsnUdf2Masked{
29503 OxmId: NewOxmId(201992),
29504 }
29505 return obj
29506}
29507func (self *OxmIdBsnUdf2Masked) GetOXMName() string {
29508 return "bsn_udf2_masked"
29509}
29510
29511func (self *OxmIdBsnUdf2Masked) MarshalJSON() ([]byte, error) {
29512 if self.TypeLen == 0 {
29513 return []byte("\"\""), nil
29514 } else {
29515 return []byte("\"" + self.GetOXMName() + "\""), nil
29516 }
29517}
29518
29519type OxmIdBsnUdf3 struct {
29520 *OxmId
29521}
29522
29523type IOxmIdBsnUdf3 interface {
29524 IOxmId
29525}
29526
29527func (self *OxmIdBsnUdf3) Serialize(encoder *goloxi.Encoder) error {
29528 if err := self.OxmId.Serialize(encoder); err != nil {
29529 return err
29530 }
29531
29532 return nil
29533}
29534
29535func DecodeOxmIdBsnUdf3(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf3, error) {
29536 _oxmidbsnudf3 := &OxmIdBsnUdf3{OxmId: parent}
29537 return _oxmidbsnudf3, nil
29538}
29539
29540func NewOxmIdBsnUdf3() *OxmIdBsnUdf3 {
29541 obj := &OxmIdBsnUdf3{
29542 OxmId: NewOxmId(202244),
29543 }
29544 return obj
29545}
29546func (self *OxmIdBsnUdf3) GetOXMName() string {
29547 return "bsn_udf3"
29548}
29549
29550func (self *OxmIdBsnUdf3) MarshalJSON() ([]byte, error) {
29551 if self.TypeLen == 0 {
29552 return []byte("\"\""), nil
29553 } else {
29554 return []byte("\"" + self.GetOXMName() + "\""), nil
29555 }
29556}
29557
29558type OxmIdBsnUdf3Masked struct {
29559 *OxmId
29560}
29561
29562type IOxmIdBsnUdf3Masked interface {
29563 IOxmId
29564}
29565
29566func (self *OxmIdBsnUdf3Masked) Serialize(encoder *goloxi.Encoder) error {
29567 if err := self.OxmId.Serialize(encoder); err != nil {
29568 return err
29569 }
29570
29571 return nil
29572}
29573
29574func DecodeOxmIdBsnUdf3Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf3Masked, error) {
29575 _oxmidbsnudf3masked := &OxmIdBsnUdf3Masked{OxmId: parent}
29576 return _oxmidbsnudf3masked, nil
29577}
29578
29579func NewOxmIdBsnUdf3Masked() *OxmIdBsnUdf3Masked {
29580 obj := &OxmIdBsnUdf3Masked{
29581 OxmId: NewOxmId(202504),
29582 }
29583 return obj
29584}
29585func (self *OxmIdBsnUdf3Masked) GetOXMName() string {
29586 return "bsn_udf3_masked"
29587}
29588
29589func (self *OxmIdBsnUdf3Masked) MarshalJSON() ([]byte, error) {
29590 if self.TypeLen == 0 {
29591 return []byte("\"\""), nil
29592 } else {
29593 return []byte("\"" + self.GetOXMName() + "\""), nil
29594 }
29595}
29596
29597type OxmIdBsnUdf4 struct {
29598 *OxmId
29599}
29600
29601type IOxmIdBsnUdf4 interface {
29602 IOxmId
29603}
29604
29605func (self *OxmIdBsnUdf4) Serialize(encoder *goloxi.Encoder) error {
29606 if err := self.OxmId.Serialize(encoder); err != nil {
29607 return err
29608 }
29609
29610 return nil
29611}
29612
29613func DecodeOxmIdBsnUdf4(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf4, error) {
29614 _oxmidbsnudf4 := &OxmIdBsnUdf4{OxmId: parent}
29615 return _oxmidbsnudf4, nil
29616}
29617
29618func NewOxmIdBsnUdf4() *OxmIdBsnUdf4 {
29619 obj := &OxmIdBsnUdf4{
29620 OxmId: NewOxmId(202756),
29621 }
29622 return obj
29623}
29624func (self *OxmIdBsnUdf4) GetOXMName() string {
29625 return "bsn_udf4"
29626}
29627
29628func (self *OxmIdBsnUdf4) MarshalJSON() ([]byte, error) {
29629 if self.TypeLen == 0 {
29630 return []byte("\"\""), nil
29631 } else {
29632 return []byte("\"" + self.GetOXMName() + "\""), nil
29633 }
29634}
29635
29636type OxmIdBsnUdf4Masked struct {
29637 *OxmId
29638}
29639
29640type IOxmIdBsnUdf4Masked interface {
29641 IOxmId
29642}
29643
29644func (self *OxmIdBsnUdf4Masked) Serialize(encoder *goloxi.Encoder) error {
29645 if err := self.OxmId.Serialize(encoder); err != nil {
29646 return err
29647 }
29648
29649 return nil
29650}
29651
29652func DecodeOxmIdBsnUdf4Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf4Masked, error) {
29653 _oxmidbsnudf4masked := &OxmIdBsnUdf4Masked{OxmId: parent}
29654 return _oxmidbsnudf4masked, nil
29655}
29656
29657func NewOxmIdBsnUdf4Masked() *OxmIdBsnUdf4Masked {
29658 obj := &OxmIdBsnUdf4Masked{
29659 OxmId: NewOxmId(203016),
29660 }
29661 return obj
29662}
29663func (self *OxmIdBsnUdf4Masked) GetOXMName() string {
29664 return "bsn_udf4_masked"
29665}
29666
29667func (self *OxmIdBsnUdf4Masked) MarshalJSON() ([]byte, error) {
29668 if self.TypeLen == 0 {
29669 return []byte("\"\""), nil
29670 } else {
29671 return []byte("\"" + self.GetOXMName() + "\""), nil
29672 }
29673}
29674
29675type OxmIdBsnUdf5 struct {
29676 *OxmId
29677}
29678
29679type IOxmIdBsnUdf5 interface {
29680 IOxmId
29681}
29682
29683func (self *OxmIdBsnUdf5) Serialize(encoder *goloxi.Encoder) error {
29684 if err := self.OxmId.Serialize(encoder); err != nil {
29685 return err
29686 }
29687
29688 return nil
29689}
29690
29691func DecodeOxmIdBsnUdf5(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf5, error) {
29692 _oxmidbsnudf5 := &OxmIdBsnUdf5{OxmId: parent}
29693 return _oxmidbsnudf5, nil
29694}
29695
29696func NewOxmIdBsnUdf5() *OxmIdBsnUdf5 {
29697 obj := &OxmIdBsnUdf5{
29698 OxmId: NewOxmId(203268),
29699 }
29700 return obj
29701}
29702func (self *OxmIdBsnUdf5) GetOXMName() string {
29703 return "bsn_udf5"
29704}
29705
29706func (self *OxmIdBsnUdf5) MarshalJSON() ([]byte, error) {
29707 if self.TypeLen == 0 {
29708 return []byte("\"\""), nil
29709 } else {
29710 return []byte("\"" + self.GetOXMName() + "\""), nil
29711 }
29712}
29713
29714type OxmIdBsnUdf5Masked struct {
29715 *OxmId
29716}
29717
29718type IOxmIdBsnUdf5Masked interface {
29719 IOxmId
29720}
29721
29722func (self *OxmIdBsnUdf5Masked) Serialize(encoder *goloxi.Encoder) error {
29723 if err := self.OxmId.Serialize(encoder); err != nil {
29724 return err
29725 }
29726
29727 return nil
29728}
29729
29730func DecodeOxmIdBsnUdf5Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf5Masked, error) {
29731 _oxmidbsnudf5masked := &OxmIdBsnUdf5Masked{OxmId: parent}
29732 return _oxmidbsnudf5masked, nil
29733}
29734
29735func NewOxmIdBsnUdf5Masked() *OxmIdBsnUdf5Masked {
29736 obj := &OxmIdBsnUdf5Masked{
29737 OxmId: NewOxmId(203528),
29738 }
29739 return obj
29740}
29741func (self *OxmIdBsnUdf5Masked) GetOXMName() string {
29742 return "bsn_udf5_masked"
29743}
29744
29745func (self *OxmIdBsnUdf5Masked) MarshalJSON() ([]byte, error) {
29746 if self.TypeLen == 0 {
29747 return []byte("\"\""), nil
29748 } else {
29749 return []byte("\"" + self.GetOXMName() + "\""), nil
29750 }
29751}
29752
29753type OxmIdBsnUdf6 struct {
29754 *OxmId
29755}
29756
29757type IOxmIdBsnUdf6 interface {
29758 IOxmId
29759}
29760
29761func (self *OxmIdBsnUdf6) Serialize(encoder *goloxi.Encoder) error {
29762 if err := self.OxmId.Serialize(encoder); err != nil {
29763 return err
29764 }
29765
29766 return nil
29767}
29768
29769func DecodeOxmIdBsnUdf6(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf6, error) {
29770 _oxmidbsnudf6 := &OxmIdBsnUdf6{OxmId: parent}
29771 return _oxmidbsnudf6, nil
29772}
29773
29774func NewOxmIdBsnUdf6() *OxmIdBsnUdf6 {
29775 obj := &OxmIdBsnUdf6{
29776 OxmId: NewOxmId(203780),
29777 }
29778 return obj
29779}
29780func (self *OxmIdBsnUdf6) GetOXMName() string {
29781 return "bsn_udf6"
29782}
29783
29784func (self *OxmIdBsnUdf6) MarshalJSON() ([]byte, error) {
29785 if self.TypeLen == 0 {
29786 return []byte("\"\""), nil
29787 } else {
29788 return []byte("\"" + self.GetOXMName() + "\""), nil
29789 }
29790}
29791
29792type OxmIdBsnUdf6Masked struct {
29793 *OxmId
29794}
29795
29796type IOxmIdBsnUdf6Masked interface {
29797 IOxmId
29798}
29799
29800func (self *OxmIdBsnUdf6Masked) Serialize(encoder *goloxi.Encoder) error {
29801 if err := self.OxmId.Serialize(encoder); err != nil {
29802 return err
29803 }
29804
29805 return nil
29806}
29807
29808func DecodeOxmIdBsnUdf6Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf6Masked, error) {
29809 _oxmidbsnudf6masked := &OxmIdBsnUdf6Masked{OxmId: parent}
29810 return _oxmidbsnudf6masked, nil
29811}
29812
29813func NewOxmIdBsnUdf6Masked() *OxmIdBsnUdf6Masked {
29814 obj := &OxmIdBsnUdf6Masked{
29815 OxmId: NewOxmId(204040),
29816 }
29817 return obj
29818}
29819func (self *OxmIdBsnUdf6Masked) GetOXMName() string {
29820 return "bsn_udf6_masked"
29821}
29822
29823func (self *OxmIdBsnUdf6Masked) MarshalJSON() ([]byte, error) {
29824 if self.TypeLen == 0 {
29825 return []byte("\"\""), nil
29826 } else {
29827 return []byte("\"" + self.GetOXMName() + "\""), nil
29828 }
29829}
29830
29831type OxmIdBsnUdf7 struct {
29832 *OxmId
29833}
29834
29835type IOxmIdBsnUdf7 interface {
29836 IOxmId
29837}
29838
29839func (self *OxmIdBsnUdf7) Serialize(encoder *goloxi.Encoder) error {
29840 if err := self.OxmId.Serialize(encoder); err != nil {
29841 return err
29842 }
29843
29844 return nil
29845}
29846
29847func DecodeOxmIdBsnUdf7(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf7, error) {
29848 _oxmidbsnudf7 := &OxmIdBsnUdf7{OxmId: parent}
29849 return _oxmidbsnudf7, nil
29850}
29851
29852func NewOxmIdBsnUdf7() *OxmIdBsnUdf7 {
29853 obj := &OxmIdBsnUdf7{
29854 OxmId: NewOxmId(204292),
29855 }
29856 return obj
29857}
29858func (self *OxmIdBsnUdf7) GetOXMName() string {
29859 return "bsn_udf7"
29860}
29861
29862func (self *OxmIdBsnUdf7) MarshalJSON() ([]byte, error) {
29863 if self.TypeLen == 0 {
29864 return []byte("\"\""), nil
29865 } else {
29866 return []byte("\"" + self.GetOXMName() + "\""), nil
29867 }
29868}
29869
29870type OxmIdBsnUdf7Masked struct {
29871 *OxmId
29872}
29873
29874type IOxmIdBsnUdf7Masked interface {
29875 IOxmId
29876}
29877
29878func (self *OxmIdBsnUdf7Masked) Serialize(encoder *goloxi.Encoder) error {
29879 if err := self.OxmId.Serialize(encoder); err != nil {
29880 return err
29881 }
29882
29883 return nil
29884}
29885
29886func DecodeOxmIdBsnUdf7Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf7Masked, error) {
29887 _oxmidbsnudf7masked := &OxmIdBsnUdf7Masked{OxmId: parent}
29888 return _oxmidbsnudf7masked, nil
29889}
29890
29891func NewOxmIdBsnUdf7Masked() *OxmIdBsnUdf7Masked {
29892 obj := &OxmIdBsnUdf7Masked{
29893 OxmId: NewOxmId(204552),
29894 }
29895 return obj
29896}
29897func (self *OxmIdBsnUdf7Masked) GetOXMName() string {
29898 return "bsn_udf7_masked"
29899}
29900
29901func (self *OxmIdBsnUdf7Masked) MarshalJSON() ([]byte, error) {
29902 if self.TypeLen == 0 {
29903 return []byte("\"\""), nil
29904 } else {
29905 return []byte("\"" + self.GetOXMName() + "\""), nil
29906 }
29907}
29908
29909type OxmIdBsnVfi struct {
29910 *OxmId
29911}
29912
29913type IOxmIdBsnVfi interface {
29914 IOxmId
29915}
29916
29917func (self *OxmIdBsnVfi) Serialize(encoder *goloxi.Encoder) error {
29918 if err := self.OxmId.Serialize(encoder); err != nil {
29919 return err
29920 }
29921
29922 return nil
29923}
29924
29925func DecodeOxmIdBsnVfi(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVfi, error) {
29926 _oxmidbsnvfi := &OxmIdBsnVfi{OxmId: parent}
29927 return _oxmidbsnvfi, nil
29928}
29929
29930func NewOxmIdBsnVfi() *OxmIdBsnVfi {
29931 obj := &OxmIdBsnVfi{
29932 OxmId: NewOxmId(209410),
29933 }
29934 return obj
29935}
29936func (self *OxmIdBsnVfi) GetOXMName() string {
29937 return "bsn_vfi"
29938}
29939
29940func (self *OxmIdBsnVfi) MarshalJSON() ([]byte, error) {
29941 if self.TypeLen == 0 {
29942 return []byte("\"\""), nil
29943 } else {
29944 return []byte("\"" + self.GetOXMName() + "\""), nil
29945 }
29946}
29947
29948type OxmIdBsnVfiMasked struct {
29949 *OxmId
29950}
29951
29952type IOxmIdBsnVfiMasked interface {
29953 IOxmId
29954}
29955
29956func (self *OxmIdBsnVfiMasked) Serialize(encoder *goloxi.Encoder) error {
29957 if err := self.OxmId.Serialize(encoder); err != nil {
29958 return err
29959 }
29960
29961 return nil
29962}
29963
29964func DecodeOxmIdBsnVfiMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVfiMasked, error) {
29965 _oxmidbsnvfimasked := &OxmIdBsnVfiMasked{OxmId: parent}
29966 return _oxmidbsnvfimasked, nil
29967}
29968
29969func NewOxmIdBsnVfiMasked() *OxmIdBsnVfiMasked {
29970 obj := &OxmIdBsnVfiMasked{
29971 OxmId: NewOxmId(209668),
29972 }
29973 return obj
29974}
29975func (self *OxmIdBsnVfiMasked) GetOXMName() string {
29976 return "bsn_vfi_masked"
29977}
29978
29979func (self *OxmIdBsnVfiMasked) MarshalJSON() ([]byte, error) {
29980 if self.TypeLen == 0 {
29981 return []byte("\"\""), nil
29982 } else {
29983 return []byte("\"" + self.GetOXMName() + "\""), nil
29984 }
29985}
29986
29987type OxmIdBsnVlanXlatePortGroupId struct {
29988 *OxmId
29989}
29990
29991type IOxmIdBsnVlanXlatePortGroupId interface {
29992 IOxmId
29993}
29994
29995func (self *OxmIdBsnVlanXlatePortGroupId) Serialize(encoder *goloxi.Encoder) error {
29996 if err := self.OxmId.Serialize(encoder); err != nil {
29997 return err
29998 }
29999
30000 return nil
30001}
30002
30003func DecodeOxmIdBsnVlanXlatePortGroupId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVlanXlatePortGroupId, error) {
30004 _oxmidbsnvlanxlateportgroupid := &OxmIdBsnVlanXlatePortGroupId{OxmId: parent}
30005 return _oxmidbsnvlanxlateportgroupid, nil
30006}
30007
30008func NewOxmIdBsnVlanXlatePortGroupId() *OxmIdBsnVlanXlatePortGroupId {
30009 obj := &OxmIdBsnVlanXlatePortGroupId{
30010 OxmId: NewOxmId(205316),
30011 }
30012 return obj
30013}
30014func (self *OxmIdBsnVlanXlatePortGroupId) GetOXMName() string {
30015 return "bsn_vlan_xlate_port_group_id"
30016}
30017
30018func (self *OxmIdBsnVlanXlatePortGroupId) MarshalJSON() ([]byte, error) {
30019 if self.TypeLen == 0 {
30020 return []byte("\"\""), nil
30021 } else {
30022 return []byte("\"" + self.GetOXMName() + "\""), nil
30023 }
30024}
30025
30026type OxmIdBsnVlanXlatePortGroupIdMasked struct {
30027 *OxmId
30028}
30029
30030type IOxmIdBsnVlanXlatePortGroupIdMasked interface {
30031 IOxmId
30032}
30033
30034func (self *OxmIdBsnVlanXlatePortGroupIdMasked) Serialize(encoder *goloxi.Encoder) error {
30035 if err := self.OxmId.Serialize(encoder); err != nil {
30036 return err
30037 }
30038
30039 return nil
30040}
30041
30042func DecodeOxmIdBsnVlanXlatePortGroupIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVlanXlatePortGroupIdMasked, error) {
30043 _oxmidbsnvlanxlateportgroupidmasked := &OxmIdBsnVlanXlatePortGroupIdMasked{OxmId: parent}
30044 return _oxmidbsnvlanxlateportgroupidmasked, nil
30045}
30046
30047func NewOxmIdBsnVlanXlatePortGroupIdMasked() *OxmIdBsnVlanXlatePortGroupIdMasked {
30048 obj := &OxmIdBsnVlanXlatePortGroupIdMasked{
30049 OxmId: NewOxmId(205576),
30050 }
30051 return obj
30052}
30053func (self *OxmIdBsnVlanXlatePortGroupIdMasked) GetOXMName() string {
30054 return "bsn_vlan_xlate_port_group_id_masked"
30055}
30056
30057func (self *OxmIdBsnVlanXlatePortGroupIdMasked) MarshalJSON() ([]byte, error) {
30058 if self.TypeLen == 0 {
30059 return []byte("\"\""), nil
30060 } else {
30061 return []byte("\"" + self.GetOXMName() + "\""), nil
30062 }
30063}
30064
30065type OxmIdBsnVrf struct {
30066 *OxmId
30067}
30068
30069type IOxmIdBsnVrf interface {
30070 IOxmId
30071}
30072
30073func (self *OxmIdBsnVrf) Serialize(encoder *goloxi.Encoder) error {
30074 if err := self.OxmId.Serialize(encoder); err != nil {
30075 return err
30076 }
30077
30078 return nil
30079}
30080
30081func DecodeOxmIdBsnVrf(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVrf, error) {
30082 _oxmidbsnvrf := &OxmIdBsnVrf{OxmId: parent}
30083 return _oxmidbsnvrf, nil
30084}
30085
30086func NewOxmIdBsnVrf() *OxmIdBsnVrf {
30087 obj := &OxmIdBsnVrf{
30088 OxmId: NewOxmId(197636),
30089 }
30090 return obj
30091}
30092func (self *OxmIdBsnVrf) GetOXMName() string {
30093 return "bsn_vrf"
30094}
30095
30096func (self *OxmIdBsnVrf) MarshalJSON() ([]byte, error) {
30097 if self.TypeLen == 0 {
30098 return []byte("\"\""), nil
30099 } else {
30100 return []byte("\"" + self.GetOXMName() + "\""), nil
30101 }
30102}
30103
30104type OxmIdBsnVrfMasked struct {
30105 *OxmId
30106}
30107
30108type IOxmIdBsnVrfMasked interface {
30109 IOxmId
30110}
30111
30112func (self *OxmIdBsnVrfMasked) Serialize(encoder *goloxi.Encoder) error {
30113 if err := self.OxmId.Serialize(encoder); err != nil {
30114 return err
30115 }
30116
30117 return nil
30118}
30119
30120func DecodeOxmIdBsnVrfMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVrfMasked, error) {
30121 _oxmidbsnvrfmasked := &OxmIdBsnVrfMasked{OxmId: parent}
30122 return _oxmidbsnvrfmasked, nil
30123}
30124
30125func NewOxmIdBsnVrfMasked() *OxmIdBsnVrfMasked {
30126 obj := &OxmIdBsnVrfMasked{
30127 OxmId: NewOxmId(197896),
30128 }
30129 return obj
30130}
30131func (self *OxmIdBsnVrfMasked) GetOXMName() string {
30132 return "bsn_vrf_masked"
30133}
30134
30135func (self *OxmIdBsnVrfMasked) MarshalJSON() ([]byte, error) {
30136 if self.TypeLen == 0 {
30137 return []byte("\"\""), nil
30138 } else {
30139 return []byte("\"" + self.GetOXMName() + "\""), nil
30140 }
30141}
30142
30143type OxmIdBsnVxlanNetworkId struct {
30144 *OxmId
30145}
30146
30147type IOxmIdBsnVxlanNetworkId interface {
30148 IOxmId
30149}
30150
30151func (self *OxmIdBsnVxlanNetworkId) Serialize(encoder *goloxi.Encoder) error {
30152 if err := self.OxmId.Serialize(encoder); err != nil {
30153 return err
30154 }
30155
30156 return nil
30157}
30158
30159func DecodeOxmIdBsnVxlanNetworkId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVxlanNetworkId, error) {
30160 _oxmidbsnvxlannetworkid := &OxmIdBsnVxlanNetworkId{OxmId: parent}
30161 return _oxmidbsnvxlannetworkid, nil
30162}
30163
30164func NewOxmIdBsnVxlanNetworkId() *OxmIdBsnVxlanNetworkId {
30165 obj := &OxmIdBsnVxlanNetworkId{
30166 OxmId: NewOxmId(207364),
30167 }
30168 return obj
30169}
30170func (self *OxmIdBsnVxlanNetworkId) GetOXMName() string {
30171 return "bsn_vxlan_network_id"
30172}
30173
30174func (self *OxmIdBsnVxlanNetworkId) MarshalJSON() ([]byte, error) {
30175 if self.TypeLen == 0 {
30176 return []byte("\"\""), nil
30177 } else {
30178 return []byte("\"" + self.GetOXMName() + "\""), nil
30179 }
30180}
30181
30182type OxmIdBsnVxlanNetworkIdMasked struct {
30183 *OxmId
30184}
30185
30186type IOxmIdBsnVxlanNetworkIdMasked interface {
30187 IOxmId
30188}
30189
30190func (self *OxmIdBsnVxlanNetworkIdMasked) Serialize(encoder *goloxi.Encoder) error {
30191 if err := self.OxmId.Serialize(encoder); err != nil {
30192 return err
30193 }
30194
30195 return nil
30196}
30197
30198func DecodeOxmIdBsnVxlanNetworkIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVxlanNetworkIdMasked, error) {
30199 _oxmidbsnvxlannetworkidmasked := &OxmIdBsnVxlanNetworkIdMasked{OxmId: parent}
30200 return _oxmidbsnvxlannetworkidmasked, nil
30201}
30202
30203func NewOxmIdBsnVxlanNetworkIdMasked() *OxmIdBsnVxlanNetworkIdMasked {
30204 obj := &OxmIdBsnVxlanNetworkIdMasked{
30205 OxmId: NewOxmId(207624),
30206 }
30207 return obj
30208}
30209func (self *OxmIdBsnVxlanNetworkIdMasked) GetOXMName() string {
30210 return "bsn_vxlan_network_id_masked"
30211}
30212
30213func (self *OxmIdBsnVxlanNetworkIdMasked) MarshalJSON() ([]byte, error) {
30214 if self.TypeLen == 0 {
30215 return []byte("\"\""), nil
30216 } else {
30217 return []byte("\"" + self.GetOXMName() + "\""), nil
30218 }
30219}
30220
30221type OxmIdConnTrackingIpv6Dst struct {
30222 *OxmId
30223}
30224
30225type IOxmIdConnTrackingIpv6Dst interface {
30226 IOxmId
30227}
30228
30229func (self *OxmIdConnTrackingIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
30230 if err := self.OxmId.Serialize(encoder); err != nil {
30231 return err
30232 }
30233
30234 return nil
30235}
30236
30237func DecodeOxmIdConnTrackingIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6Dst, error) {
30238 _oxmidconntrackingipv6dst := &OxmIdConnTrackingIpv6Dst{OxmId: parent}
30239 return _oxmidconntrackingipv6dst, nil
30240}
30241
30242func NewOxmIdConnTrackingIpv6Dst() *OxmIdConnTrackingIpv6Dst {
30243 obj := &OxmIdConnTrackingIpv6Dst{
30244 OxmId: NewOxmId(128528),
30245 }
30246 return obj
30247}
30248func (self *OxmIdConnTrackingIpv6Dst) GetOXMName() string {
30249 return "conn_tracking_ipv6_dst"
30250}
30251
30252func (self *OxmIdConnTrackingIpv6Dst) MarshalJSON() ([]byte, error) {
30253 if self.TypeLen == 0 {
30254 return []byte("\"\""), nil
30255 } else {
30256 return []byte("\"" + self.GetOXMName() + "\""), nil
30257 }
30258}
30259
30260type OxmIdConnTrackingIpv6DstMasked struct {
30261 *OxmId
30262}
30263
30264type IOxmIdConnTrackingIpv6DstMasked interface {
30265 IOxmId
30266}
30267
30268func (self *OxmIdConnTrackingIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
30269 if err := self.OxmId.Serialize(encoder); err != nil {
30270 return err
30271 }
30272
30273 return nil
30274}
30275
30276func DecodeOxmIdConnTrackingIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6DstMasked, error) {
30277 _oxmidconntrackingipv6dstmasked := &OxmIdConnTrackingIpv6DstMasked{OxmId: parent}
30278 return _oxmidconntrackingipv6dstmasked, nil
30279}
30280
30281func NewOxmIdConnTrackingIpv6DstMasked() *OxmIdConnTrackingIpv6DstMasked {
30282 obj := &OxmIdConnTrackingIpv6DstMasked{
30283 OxmId: NewOxmId(128800),
30284 }
30285 return obj
30286}
30287func (self *OxmIdConnTrackingIpv6DstMasked) GetOXMName() string {
30288 return "conn_tracking_ipv6_dst_masked"
30289}
30290
30291func (self *OxmIdConnTrackingIpv6DstMasked) MarshalJSON() ([]byte, error) {
30292 if self.TypeLen == 0 {
30293 return []byte("\"\""), nil
30294 } else {
30295 return []byte("\"" + self.GetOXMName() + "\""), nil
30296 }
30297}
30298
30299type OxmIdConnTrackingIpv6Src struct {
30300 *OxmId
30301}
30302
30303type IOxmIdConnTrackingIpv6Src interface {
30304 IOxmId
30305}
30306
30307func (self *OxmIdConnTrackingIpv6Src) Serialize(encoder *goloxi.Encoder) error {
30308 if err := self.OxmId.Serialize(encoder); err != nil {
30309 return err
30310 }
30311
30312 return nil
30313}
30314
30315func DecodeOxmIdConnTrackingIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6Src, error) {
30316 _oxmidconntrackingipv6src := &OxmIdConnTrackingIpv6Src{OxmId: parent}
30317 return _oxmidconntrackingipv6src, nil
30318}
30319
30320func NewOxmIdConnTrackingIpv6Src() *OxmIdConnTrackingIpv6Src {
30321 obj := &OxmIdConnTrackingIpv6Src{
30322 OxmId: NewOxmId(128016),
30323 }
30324 return obj
30325}
30326func (self *OxmIdConnTrackingIpv6Src) GetOXMName() string {
30327 return "conn_tracking_ipv6_src"
30328}
30329
30330func (self *OxmIdConnTrackingIpv6Src) MarshalJSON() ([]byte, error) {
30331 if self.TypeLen == 0 {
30332 return []byte("\"\""), nil
30333 } else {
30334 return []byte("\"" + self.GetOXMName() + "\""), nil
30335 }
30336}
30337
30338type OxmIdConnTrackingIpv6SrcMasked struct {
30339 *OxmId
30340}
30341
30342type IOxmIdConnTrackingIpv6SrcMasked interface {
30343 IOxmId
30344}
30345
30346func (self *OxmIdConnTrackingIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
30347 if err := self.OxmId.Serialize(encoder); err != nil {
30348 return err
30349 }
30350
30351 return nil
30352}
30353
30354func DecodeOxmIdConnTrackingIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6SrcMasked, error) {
30355 _oxmidconntrackingipv6srcmasked := &OxmIdConnTrackingIpv6SrcMasked{OxmId: parent}
30356 return _oxmidconntrackingipv6srcmasked, nil
30357}
30358
30359func NewOxmIdConnTrackingIpv6SrcMasked() *OxmIdConnTrackingIpv6SrcMasked {
30360 obj := &OxmIdConnTrackingIpv6SrcMasked{
30361 OxmId: NewOxmId(128288),
30362 }
30363 return obj
30364}
30365func (self *OxmIdConnTrackingIpv6SrcMasked) GetOXMName() string {
30366 return "conn_tracking_ipv6_src_masked"
30367}
30368
30369func (self *OxmIdConnTrackingIpv6SrcMasked) MarshalJSON() ([]byte, error) {
30370 if self.TypeLen == 0 {
30371 return []byte("\"\""), nil
30372 } else {
30373 return []byte("\"" + self.GetOXMName() + "\""), nil
30374 }
30375}
30376
30377type OxmIdConnTrackingLabel struct {
30378 *OxmId
30379}
30380
30381type IOxmIdConnTrackingLabel interface {
30382 IOxmId
30383}
30384
30385func (self *OxmIdConnTrackingLabel) Serialize(encoder *goloxi.Encoder) error {
30386 if err := self.OxmId.Serialize(encoder); err != nil {
30387 return err
30388 }
30389
30390 return nil
30391}
30392
30393func DecodeOxmIdConnTrackingLabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingLabel, error) {
30394 _oxmidconntrackinglabel := &OxmIdConnTrackingLabel{OxmId: parent}
30395 return _oxmidconntrackinglabel, nil
30396}
30397
30398func NewOxmIdConnTrackingLabel() *OxmIdConnTrackingLabel {
30399 obj := &OxmIdConnTrackingLabel{
30400 OxmId: NewOxmId(120848),
30401 }
30402 return obj
30403}
30404func (self *OxmIdConnTrackingLabel) GetOXMName() string {
30405 return "conn_tracking_label"
30406}
30407
30408func (self *OxmIdConnTrackingLabel) MarshalJSON() ([]byte, error) {
30409 if self.TypeLen == 0 {
30410 return []byte("\"\""), nil
30411 } else {
30412 return []byte("\"" + self.GetOXMName() + "\""), nil
30413 }
30414}
30415
30416type OxmIdConnTrackingLabelMasked struct {
30417 *OxmId
30418}
30419
30420type IOxmIdConnTrackingLabelMasked interface {
30421 IOxmId
30422}
30423
30424func (self *OxmIdConnTrackingLabelMasked) Serialize(encoder *goloxi.Encoder) error {
30425 if err := self.OxmId.Serialize(encoder); err != nil {
30426 return err
30427 }
30428
30429 return nil
30430}
30431
30432func DecodeOxmIdConnTrackingLabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingLabelMasked, error) {
30433 _oxmidconntrackinglabelmasked := &OxmIdConnTrackingLabelMasked{OxmId: parent}
30434 return _oxmidconntrackinglabelmasked, nil
30435}
30436
30437func NewOxmIdConnTrackingLabelMasked() *OxmIdConnTrackingLabelMasked {
30438 obj := &OxmIdConnTrackingLabelMasked{
30439 OxmId: NewOxmId(121120),
30440 }
30441 return obj
30442}
30443func (self *OxmIdConnTrackingLabelMasked) GetOXMName() string {
30444 return "conn_tracking_label_masked"
30445}
30446
30447func (self *OxmIdConnTrackingLabelMasked) MarshalJSON() ([]byte, error) {
30448 if self.TypeLen == 0 {
30449 return []byte("\"\""), nil
30450 } else {
30451 return []byte("\"" + self.GetOXMName() + "\""), nil
30452 }
30453}
30454
30455type OxmIdConnTrackingMark struct {
30456 *OxmId
30457}
30458
30459type IOxmIdConnTrackingMark interface {
30460 IOxmId
30461}
30462
30463func (self *OxmIdConnTrackingMark) Serialize(encoder *goloxi.Encoder) error {
30464 if err := self.OxmId.Serialize(encoder); err != nil {
30465 return err
30466 }
30467
30468 return nil
30469}
30470
30471func DecodeOxmIdConnTrackingMark(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingMark, error) {
30472 _oxmidconntrackingmark := &OxmIdConnTrackingMark{OxmId: parent}
30473 return _oxmidconntrackingmark, nil
30474}
30475
30476func NewOxmIdConnTrackingMark() *OxmIdConnTrackingMark {
30477 obj := &OxmIdConnTrackingMark{
30478 OxmId: NewOxmId(120324),
30479 }
30480 return obj
30481}
30482func (self *OxmIdConnTrackingMark) GetOXMName() string {
30483 return "conn_tracking_mark"
30484}
30485
30486func (self *OxmIdConnTrackingMark) MarshalJSON() ([]byte, error) {
30487 if self.TypeLen == 0 {
30488 return []byte("\"\""), nil
30489 } else {
30490 return []byte("\"" + self.GetOXMName() + "\""), nil
30491 }
30492}
30493
30494type OxmIdConnTrackingMarkMasked struct {
30495 *OxmId
30496}
30497
30498type IOxmIdConnTrackingMarkMasked interface {
30499 IOxmId
30500}
30501
30502func (self *OxmIdConnTrackingMarkMasked) Serialize(encoder *goloxi.Encoder) error {
30503 if err := self.OxmId.Serialize(encoder); err != nil {
30504 return err
30505 }
30506
30507 return nil
30508}
30509
30510func DecodeOxmIdConnTrackingMarkMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingMarkMasked, error) {
30511 _oxmidconntrackingmarkmasked := &OxmIdConnTrackingMarkMasked{OxmId: parent}
30512 return _oxmidconntrackingmarkmasked, nil
30513}
30514
30515func NewOxmIdConnTrackingMarkMasked() *OxmIdConnTrackingMarkMasked {
30516 obj := &OxmIdConnTrackingMarkMasked{
30517 OxmId: NewOxmId(120584),
30518 }
30519 return obj
30520}
30521func (self *OxmIdConnTrackingMarkMasked) GetOXMName() string {
30522 return "conn_tracking_mark_masked"
30523}
30524
30525func (self *OxmIdConnTrackingMarkMasked) MarshalJSON() ([]byte, error) {
30526 if self.TypeLen == 0 {
30527 return []byte("\"\""), nil
30528 } else {
30529 return []byte("\"" + self.GetOXMName() + "\""), nil
30530 }
30531}
30532
30533type OxmIdConnTrackingNwDst struct {
30534 *OxmId
30535}
30536
30537type IOxmIdConnTrackingNwDst interface {
30538 IOxmId
30539}
30540
30541func (self *OxmIdConnTrackingNwDst) Serialize(encoder *goloxi.Encoder) error {
30542 if err := self.OxmId.Serialize(encoder); err != nil {
30543 return err
30544 }
30545
30546 return nil
30547}
30548
30549func DecodeOxmIdConnTrackingNwDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwDst, error) {
30550 _oxmidconntrackingnwdst := &OxmIdConnTrackingNwDst{OxmId: parent}
30551 return _oxmidconntrackingnwdst, nil
30552}
30553
30554func NewOxmIdConnTrackingNwDst() *OxmIdConnTrackingNwDst {
30555 obj := &OxmIdConnTrackingNwDst{
30556 OxmId: NewOxmId(127492),
30557 }
30558 return obj
30559}
30560func (self *OxmIdConnTrackingNwDst) GetOXMName() string {
30561 return "conn_tracking_nw_dst"
30562}
30563
30564func (self *OxmIdConnTrackingNwDst) MarshalJSON() ([]byte, error) {
30565 if self.TypeLen == 0 {
30566 return []byte("\"\""), nil
30567 } else {
30568 return []byte("\"" + self.GetOXMName() + "\""), nil
30569 }
30570}
30571
30572type OxmIdConnTrackingNwDstMasked struct {
30573 *OxmId
30574}
30575
30576type IOxmIdConnTrackingNwDstMasked interface {
30577 IOxmId
30578}
30579
30580func (self *OxmIdConnTrackingNwDstMasked) Serialize(encoder *goloxi.Encoder) error {
30581 if err := self.OxmId.Serialize(encoder); err != nil {
30582 return err
30583 }
30584
30585 return nil
30586}
30587
30588func DecodeOxmIdConnTrackingNwDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwDstMasked, error) {
30589 _oxmidconntrackingnwdstmasked := &OxmIdConnTrackingNwDstMasked{OxmId: parent}
30590 return _oxmidconntrackingnwdstmasked, nil
30591}
30592
30593func NewOxmIdConnTrackingNwDstMasked() *OxmIdConnTrackingNwDstMasked {
30594 obj := &OxmIdConnTrackingNwDstMasked{
30595 OxmId: NewOxmId(127752),
30596 }
30597 return obj
30598}
30599func (self *OxmIdConnTrackingNwDstMasked) GetOXMName() string {
30600 return "conn_tracking_nw_dst_masked"
30601}
30602
30603func (self *OxmIdConnTrackingNwDstMasked) MarshalJSON() ([]byte, error) {
30604 if self.TypeLen == 0 {
30605 return []byte("\"\""), nil
30606 } else {
30607 return []byte("\"" + self.GetOXMName() + "\""), nil
30608 }
30609}
30610
30611type OxmIdConnTrackingNwProto struct {
30612 *OxmId
30613}
30614
30615type IOxmIdConnTrackingNwProto interface {
30616 IOxmId
30617}
30618
30619func (self *OxmIdConnTrackingNwProto) Serialize(encoder *goloxi.Encoder) error {
30620 if err := self.OxmId.Serialize(encoder); err != nil {
30621 return err
30622 }
30623
30624 return nil
30625}
30626
30627func DecodeOxmIdConnTrackingNwProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwProto, error) {
30628 _oxmidconntrackingnwproto := &OxmIdConnTrackingNwProto{OxmId: parent}
30629 return _oxmidconntrackingnwproto, nil
30630}
30631
30632func NewOxmIdConnTrackingNwProto() *OxmIdConnTrackingNwProto {
30633 obj := &OxmIdConnTrackingNwProto{
30634 OxmId: NewOxmId(126465),
30635 }
30636 return obj
30637}
30638func (self *OxmIdConnTrackingNwProto) GetOXMName() string {
30639 return "conn_tracking_nw_proto"
30640}
30641
30642func (self *OxmIdConnTrackingNwProto) MarshalJSON() ([]byte, error) {
30643 if self.TypeLen == 0 {
30644 return []byte("\"\""), nil
30645 } else {
30646 return []byte("\"" + self.GetOXMName() + "\""), nil
30647 }
30648}
30649
30650type OxmIdConnTrackingNwProtoMasked struct {
30651 *OxmId
30652}
30653
30654type IOxmIdConnTrackingNwProtoMasked interface {
30655 IOxmId
30656}
30657
30658func (self *OxmIdConnTrackingNwProtoMasked) Serialize(encoder *goloxi.Encoder) error {
30659 if err := self.OxmId.Serialize(encoder); err != nil {
30660 return err
30661 }
30662
30663 return nil
30664}
30665
30666func DecodeOxmIdConnTrackingNwProtoMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwProtoMasked, error) {
30667 _oxmidconntrackingnwprotomasked := &OxmIdConnTrackingNwProtoMasked{OxmId: parent}
30668 return _oxmidconntrackingnwprotomasked, nil
30669}
30670
30671func NewOxmIdConnTrackingNwProtoMasked() *OxmIdConnTrackingNwProtoMasked {
30672 obj := &OxmIdConnTrackingNwProtoMasked{
30673 OxmId: NewOxmId(126722),
30674 }
30675 return obj
30676}
30677func (self *OxmIdConnTrackingNwProtoMasked) GetOXMName() string {
30678 return "conn_tracking_nw_proto_masked"
30679}
30680
30681func (self *OxmIdConnTrackingNwProtoMasked) MarshalJSON() ([]byte, error) {
30682 if self.TypeLen == 0 {
30683 return []byte("\"\""), nil
30684 } else {
30685 return []byte("\"" + self.GetOXMName() + "\""), nil
30686 }
30687}
30688
30689type OxmIdConnTrackingNwSrc struct {
30690 *OxmId
30691}
30692
30693type IOxmIdConnTrackingNwSrc interface {
30694 IOxmId
30695}
30696
30697func (self *OxmIdConnTrackingNwSrc) Serialize(encoder *goloxi.Encoder) error {
30698 if err := self.OxmId.Serialize(encoder); err != nil {
30699 return err
30700 }
30701
30702 return nil
30703}
30704
30705func DecodeOxmIdConnTrackingNwSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwSrc, error) {
30706 _oxmidconntrackingnwsrc := &OxmIdConnTrackingNwSrc{OxmId: parent}
30707 return _oxmidconntrackingnwsrc, nil
30708}
30709
30710func NewOxmIdConnTrackingNwSrc() *OxmIdConnTrackingNwSrc {
30711 obj := &OxmIdConnTrackingNwSrc{
30712 OxmId: NewOxmId(126980),
30713 }
30714 return obj
30715}
30716func (self *OxmIdConnTrackingNwSrc) GetOXMName() string {
30717 return "conn_tracking_nw_src"
30718}
30719
30720func (self *OxmIdConnTrackingNwSrc) MarshalJSON() ([]byte, error) {
30721 if self.TypeLen == 0 {
30722 return []byte("\"\""), nil
30723 } else {
30724 return []byte("\"" + self.GetOXMName() + "\""), nil
30725 }
30726}
30727
30728type OxmIdConnTrackingNwSrcMasked struct {
30729 *OxmId
30730}
30731
30732type IOxmIdConnTrackingNwSrcMasked interface {
30733 IOxmId
30734}
30735
30736func (self *OxmIdConnTrackingNwSrcMasked) Serialize(encoder *goloxi.Encoder) error {
30737 if err := self.OxmId.Serialize(encoder); err != nil {
30738 return err
30739 }
30740
30741 return nil
30742}
30743
30744func DecodeOxmIdConnTrackingNwSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwSrcMasked, error) {
30745 _oxmidconntrackingnwsrcmasked := &OxmIdConnTrackingNwSrcMasked{OxmId: parent}
30746 return _oxmidconntrackingnwsrcmasked, nil
30747}
30748
30749func NewOxmIdConnTrackingNwSrcMasked() *OxmIdConnTrackingNwSrcMasked {
30750 obj := &OxmIdConnTrackingNwSrcMasked{
30751 OxmId: NewOxmId(127240),
30752 }
30753 return obj
30754}
30755func (self *OxmIdConnTrackingNwSrcMasked) GetOXMName() string {
30756 return "conn_tracking_nw_src_masked"
30757}
30758
30759func (self *OxmIdConnTrackingNwSrcMasked) MarshalJSON() ([]byte, error) {
30760 if self.TypeLen == 0 {
30761 return []byte("\"\""), nil
30762 } else {
30763 return []byte("\"" + self.GetOXMName() + "\""), nil
30764 }
30765}
30766
30767type OxmIdConnTrackingState struct {
30768 *OxmId
30769}
30770
30771type IOxmIdConnTrackingState interface {
30772 IOxmId
30773}
30774
30775func (self *OxmIdConnTrackingState) Serialize(encoder *goloxi.Encoder) error {
30776 if err := self.OxmId.Serialize(encoder); err != nil {
30777 return err
30778 }
30779
30780 return nil
30781}
30782
30783func DecodeOxmIdConnTrackingState(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingState, error) {
30784 _oxmidconntrackingstate := &OxmIdConnTrackingState{OxmId: parent}
30785 return _oxmidconntrackingstate, nil
30786}
30787
30788func NewOxmIdConnTrackingState() *OxmIdConnTrackingState {
30789 obj := &OxmIdConnTrackingState{
30790 OxmId: NewOxmId(119300),
30791 }
30792 return obj
30793}
30794func (self *OxmIdConnTrackingState) GetOXMName() string {
30795 return "conn_tracking_state"
30796}
30797
30798func (self *OxmIdConnTrackingState) MarshalJSON() ([]byte, error) {
30799 if self.TypeLen == 0 {
30800 return []byte("\"\""), nil
30801 } else {
30802 return []byte("\"" + self.GetOXMName() + "\""), nil
30803 }
30804}
30805
30806type OxmIdConnTrackingStateMasked struct {
30807 *OxmId
30808}
30809
30810type IOxmIdConnTrackingStateMasked interface {
30811 IOxmId
30812}
30813
30814func (self *OxmIdConnTrackingStateMasked) Serialize(encoder *goloxi.Encoder) error {
30815 if err := self.OxmId.Serialize(encoder); err != nil {
30816 return err
30817 }
30818
30819 return nil
30820}
30821
30822func DecodeOxmIdConnTrackingStateMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingStateMasked, error) {
30823 _oxmidconntrackingstatemasked := &OxmIdConnTrackingStateMasked{OxmId: parent}
30824 return _oxmidconntrackingstatemasked, nil
30825}
30826
30827func NewOxmIdConnTrackingStateMasked() *OxmIdConnTrackingStateMasked {
30828 obj := &OxmIdConnTrackingStateMasked{
30829 OxmId: NewOxmId(119560),
30830 }
30831 return obj
30832}
30833func (self *OxmIdConnTrackingStateMasked) GetOXMName() string {
30834 return "conn_tracking_state_masked"
30835}
30836
30837func (self *OxmIdConnTrackingStateMasked) MarshalJSON() ([]byte, error) {
30838 if self.TypeLen == 0 {
30839 return []byte("\"\""), nil
30840 } else {
30841 return []byte("\"" + self.GetOXMName() + "\""), nil
30842 }
30843}
30844
30845type OxmIdConnTrackingTpDst struct {
30846 *OxmId
30847}
30848
30849type IOxmIdConnTrackingTpDst interface {
30850 IOxmId
30851}
30852
30853func (self *OxmIdConnTrackingTpDst) Serialize(encoder *goloxi.Encoder) error {
30854 if err := self.OxmId.Serialize(encoder); err != nil {
30855 return err
30856 }
30857
30858 return nil
30859}
30860
30861func DecodeOxmIdConnTrackingTpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpDst, error) {
30862 _oxmidconntrackingtpdst := &OxmIdConnTrackingTpDst{OxmId: parent}
30863 return _oxmidconntrackingtpdst, nil
30864}
30865
30866func NewOxmIdConnTrackingTpDst() *OxmIdConnTrackingTpDst {
30867 obj := &OxmIdConnTrackingTpDst{
30868 OxmId: NewOxmId(129538),
30869 }
30870 return obj
30871}
30872func (self *OxmIdConnTrackingTpDst) GetOXMName() string {
30873 return "conn_tracking_tp_dst"
30874}
30875
30876func (self *OxmIdConnTrackingTpDst) MarshalJSON() ([]byte, error) {
30877 if self.TypeLen == 0 {
30878 return []byte("\"\""), nil
30879 } else {
30880 return []byte("\"" + self.GetOXMName() + "\""), nil
30881 }
30882}
30883
30884type OxmIdConnTrackingTpDstMasked struct {
30885 *OxmId
30886}
30887
30888type IOxmIdConnTrackingTpDstMasked interface {
30889 IOxmId
30890}
30891
30892func (self *OxmIdConnTrackingTpDstMasked) Serialize(encoder *goloxi.Encoder) error {
30893 if err := self.OxmId.Serialize(encoder); err != nil {
30894 return err
30895 }
30896
30897 return nil
30898}
30899
30900func DecodeOxmIdConnTrackingTpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpDstMasked, error) {
30901 _oxmidconntrackingtpdstmasked := &OxmIdConnTrackingTpDstMasked{OxmId: parent}
30902 return _oxmidconntrackingtpdstmasked, nil
30903}
30904
30905func NewOxmIdConnTrackingTpDstMasked() *OxmIdConnTrackingTpDstMasked {
30906 obj := &OxmIdConnTrackingTpDstMasked{
30907 OxmId: NewOxmId(129796),
30908 }
30909 return obj
30910}
30911func (self *OxmIdConnTrackingTpDstMasked) GetOXMName() string {
30912 return "conn_tracking_tp_dst_masked"
30913}
30914
30915func (self *OxmIdConnTrackingTpDstMasked) MarshalJSON() ([]byte, error) {
30916 if self.TypeLen == 0 {
30917 return []byte("\"\""), nil
30918 } else {
30919 return []byte("\"" + self.GetOXMName() + "\""), nil
30920 }
30921}
30922
30923type OxmIdConnTrackingTpSrc struct {
30924 *OxmId
30925}
30926
30927type IOxmIdConnTrackingTpSrc interface {
30928 IOxmId
30929}
30930
30931func (self *OxmIdConnTrackingTpSrc) Serialize(encoder *goloxi.Encoder) error {
30932 if err := self.OxmId.Serialize(encoder); err != nil {
30933 return err
30934 }
30935
30936 return nil
30937}
30938
30939func DecodeOxmIdConnTrackingTpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpSrc, error) {
30940 _oxmidconntrackingtpsrc := &OxmIdConnTrackingTpSrc{OxmId: parent}
30941 return _oxmidconntrackingtpsrc, nil
30942}
30943
30944func NewOxmIdConnTrackingTpSrc() *OxmIdConnTrackingTpSrc {
30945 obj := &OxmIdConnTrackingTpSrc{
30946 OxmId: NewOxmId(129026),
30947 }
30948 return obj
30949}
30950func (self *OxmIdConnTrackingTpSrc) GetOXMName() string {
30951 return "conn_tracking_tp_src"
30952}
30953
30954func (self *OxmIdConnTrackingTpSrc) MarshalJSON() ([]byte, error) {
30955 if self.TypeLen == 0 {
30956 return []byte("\"\""), nil
30957 } else {
30958 return []byte("\"" + self.GetOXMName() + "\""), nil
30959 }
30960}
30961
30962type OxmIdConnTrackingTpSrcMasked struct {
30963 *OxmId
30964}
30965
30966type IOxmIdConnTrackingTpSrcMasked interface {
30967 IOxmId
30968}
30969
30970func (self *OxmIdConnTrackingTpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
30971 if err := self.OxmId.Serialize(encoder); err != nil {
30972 return err
30973 }
30974
30975 return nil
30976}
30977
30978func DecodeOxmIdConnTrackingTpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpSrcMasked, error) {
30979 _oxmidconntrackingtpsrcmasked := &OxmIdConnTrackingTpSrcMasked{OxmId: parent}
30980 return _oxmidconntrackingtpsrcmasked, nil
30981}
30982
30983func NewOxmIdConnTrackingTpSrcMasked() *OxmIdConnTrackingTpSrcMasked {
30984 obj := &OxmIdConnTrackingTpSrcMasked{
30985 OxmId: NewOxmId(129284),
30986 }
30987 return obj
30988}
30989func (self *OxmIdConnTrackingTpSrcMasked) GetOXMName() string {
30990 return "conn_tracking_tp_src_masked"
30991}
30992
30993func (self *OxmIdConnTrackingTpSrcMasked) MarshalJSON() ([]byte, error) {
30994 if self.TypeLen == 0 {
30995 return []byte("\"\""), nil
30996 } else {
30997 return []byte("\"" + self.GetOXMName() + "\""), nil
30998 }
30999}
31000
31001type OxmIdConnTrackingZone struct {
31002 *OxmId
31003}
31004
31005type IOxmIdConnTrackingZone interface {
31006 IOxmId
31007}
31008
31009func (self *OxmIdConnTrackingZone) Serialize(encoder *goloxi.Encoder) error {
31010 if err := self.OxmId.Serialize(encoder); err != nil {
31011 return err
31012 }
31013
31014 return nil
31015}
31016
31017func DecodeOxmIdConnTrackingZone(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingZone, error) {
31018 _oxmidconntrackingzone := &OxmIdConnTrackingZone{OxmId: parent}
31019 return _oxmidconntrackingzone, nil
31020}
31021
31022func NewOxmIdConnTrackingZone() *OxmIdConnTrackingZone {
31023 obj := &OxmIdConnTrackingZone{
31024 OxmId: NewOxmId(119810),
31025 }
31026 return obj
31027}
31028func (self *OxmIdConnTrackingZone) GetOXMName() string {
31029 return "conn_tracking_zone"
31030}
31031
31032func (self *OxmIdConnTrackingZone) MarshalJSON() ([]byte, error) {
31033 if self.TypeLen == 0 {
31034 return []byte("\"\""), nil
31035 } else {
31036 return []byte("\"" + self.GetOXMName() + "\""), nil
31037 }
31038}
31039
31040type OxmIdConnTrackingZoneMasked struct {
31041 *OxmId
31042}
31043
31044type IOxmIdConnTrackingZoneMasked interface {
31045 IOxmId
31046}
31047
31048func (self *OxmIdConnTrackingZoneMasked) Serialize(encoder *goloxi.Encoder) error {
31049 if err := self.OxmId.Serialize(encoder); err != nil {
31050 return err
31051 }
31052
31053 return nil
31054}
31055
31056func DecodeOxmIdConnTrackingZoneMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingZoneMasked, error) {
31057 _oxmidconntrackingzonemasked := &OxmIdConnTrackingZoneMasked{OxmId: parent}
31058 return _oxmidconntrackingzonemasked, nil
31059}
31060
31061func NewOxmIdConnTrackingZoneMasked() *OxmIdConnTrackingZoneMasked {
31062 obj := &OxmIdConnTrackingZoneMasked{
31063 OxmId: NewOxmId(120068),
31064 }
31065 return obj
31066}
31067func (self *OxmIdConnTrackingZoneMasked) GetOXMName() string {
31068 return "conn_tracking_zone_masked"
31069}
31070
31071func (self *OxmIdConnTrackingZoneMasked) MarshalJSON() ([]byte, error) {
31072 if self.TypeLen == 0 {
31073 return []byte("\"\""), nil
31074 } else {
31075 return []byte("\"" + self.GetOXMName() + "\""), nil
31076 }
31077}
31078
31079type OxmIdEthTypeMasked struct {
31080 *OxmId
31081}
31082
31083type IOxmIdEthTypeMasked interface {
31084 IOxmId
31085}
31086
31087func (self *OxmIdEthTypeMasked) Serialize(encoder *goloxi.Encoder) error {
31088 if err := self.OxmId.Serialize(encoder); err != nil {
31089 return err
31090 }
31091
31092 return nil
31093}
31094
31095func DecodeOxmIdEthTypeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthTypeMasked, error) {
31096 _oxmidethtypemasked := &OxmIdEthTypeMasked{OxmId: parent}
31097 return _oxmidethtypemasked, nil
31098}
31099
31100func NewOxmIdEthTypeMasked() *OxmIdEthTypeMasked {
31101 obj := &OxmIdEthTypeMasked{
31102 OxmId: NewOxmId(2147486468),
31103 }
31104 return obj
31105}
31106func (self *OxmIdEthTypeMasked) GetOXMName() string {
31107 return "eth_type_masked"
31108}
31109
31110func (self *OxmIdEthTypeMasked) MarshalJSON() ([]byte, error) {
31111 if self.TypeLen == 0 {
31112 return []byte("\"\""), nil
31113 } else {
31114 return []byte("\"" + self.GetOXMName() + "\""), nil
31115 }
31116}
31117
31118type OxmIdIcmpv4Code struct {
31119 *OxmId
31120}
31121
31122type IOxmIdIcmpv4Code interface {
31123 IOxmId
31124}
31125
31126func (self *OxmIdIcmpv4Code) Serialize(encoder *goloxi.Encoder) error {
31127 if err := self.OxmId.Serialize(encoder); err != nil {
31128 return err
31129 }
31130
31131 return nil
31132}
31133
31134func DecodeOxmIdIcmpv4Code(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4Code, error) {
31135 _oxmidicmpv4code := &OxmIdIcmpv4Code{OxmId: parent}
31136 return _oxmidicmpv4code, nil
31137}
31138
31139func NewOxmIdIcmpv4Code() *OxmIdIcmpv4Code {
31140 obj := &OxmIdIcmpv4Code{
31141 OxmId: NewOxmId(2147493889),
31142 }
31143 return obj
31144}
31145func (self *OxmIdIcmpv4Code) GetOXMName() string {
31146 return "icmpv4_code"
31147}
31148
31149func (self *OxmIdIcmpv4Code) MarshalJSON() ([]byte, error) {
31150 if self.TypeLen == 0 {
31151 return []byte("\"\""), nil
31152 } else {
31153 return []byte("\"" + self.GetOXMName() + "\""), nil
31154 }
31155}
31156
31157type OxmIdIcmpv4CodeMasked struct {
31158 *OxmId
31159}
31160
31161type IOxmIdIcmpv4CodeMasked interface {
31162 IOxmId
31163}
31164
31165func (self *OxmIdIcmpv4CodeMasked) Serialize(encoder *goloxi.Encoder) error {
31166 if err := self.OxmId.Serialize(encoder); err != nil {
31167 return err
31168 }
31169
31170 return nil
31171}
31172
31173func DecodeOxmIdIcmpv4CodeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4CodeMasked, error) {
31174 _oxmidicmpv4codemasked := &OxmIdIcmpv4CodeMasked{OxmId: parent}
31175 return _oxmidicmpv4codemasked, nil
31176}
31177
31178func NewOxmIdIcmpv4CodeMasked() *OxmIdIcmpv4CodeMasked {
31179 obj := &OxmIdIcmpv4CodeMasked{
31180 OxmId: NewOxmId(2147494146),
31181 }
31182 return obj
31183}
31184func (self *OxmIdIcmpv4CodeMasked) GetOXMName() string {
31185 return "icmpv4_code_masked"
31186}
31187
31188func (self *OxmIdIcmpv4CodeMasked) MarshalJSON() ([]byte, error) {
31189 if self.TypeLen == 0 {
31190 return []byte("\"\""), nil
31191 } else {
31192 return []byte("\"" + self.GetOXMName() + "\""), nil
31193 }
31194}
31195
31196type OxmIdIcmpv4Type struct {
31197 *OxmId
31198}
31199
31200type IOxmIdIcmpv4Type interface {
31201 IOxmId
31202}
31203
31204func (self *OxmIdIcmpv4Type) Serialize(encoder *goloxi.Encoder) error {
31205 if err := self.OxmId.Serialize(encoder); err != nil {
31206 return err
31207 }
31208
31209 return nil
31210}
31211
31212func DecodeOxmIdIcmpv4Type(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4Type, error) {
31213 _oxmidicmpv4type := &OxmIdIcmpv4Type{OxmId: parent}
31214 return _oxmidicmpv4type, nil
31215}
31216
31217func NewOxmIdIcmpv4Type() *OxmIdIcmpv4Type {
31218 obj := &OxmIdIcmpv4Type{
31219 OxmId: NewOxmId(2147493377),
31220 }
31221 return obj
31222}
31223func (self *OxmIdIcmpv4Type) GetOXMName() string {
31224 return "icmpv4_type"
31225}
31226
31227func (self *OxmIdIcmpv4Type) MarshalJSON() ([]byte, error) {
31228 if self.TypeLen == 0 {
31229 return []byte("\"\""), nil
31230 } else {
31231 return []byte("\"" + self.GetOXMName() + "\""), nil
31232 }
31233}
31234
31235type OxmIdIcmpv4TypeMasked struct {
31236 *OxmId
31237}
31238
31239type IOxmIdIcmpv4TypeMasked interface {
31240 IOxmId
31241}
31242
31243func (self *OxmIdIcmpv4TypeMasked) Serialize(encoder *goloxi.Encoder) error {
31244 if err := self.OxmId.Serialize(encoder); err != nil {
31245 return err
31246 }
31247
31248 return nil
31249}
31250
31251func DecodeOxmIdIcmpv4TypeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4TypeMasked, error) {
31252 _oxmidicmpv4typemasked := &OxmIdIcmpv4TypeMasked{OxmId: parent}
31253 return _oxmidicmpv4typemasked, nil
31254}
31255
31256func NewOxmIdIcmpv4TypeMasked() *OxmIdIcmpv4TypeMasked {
31257 obj := &OxmIdIcmpv4TypeMasked{
31258 OxmId: NewOxmId(2147493634),
31259 }
31260 return obj
31261}
31262func (self *OxmIdIcmpv4TypeMasked) GetOXMName() string {
31263 return "icmpv4_type_masked"
31264}
31265
31266func (self *OxmIdIcmpv4TypeMasked) MarshalJSON() ([]byte, error) {
31267 if self.TypeLen == 0 {
31268 return []byte("\"\""), nil
31269 } else {
31270 return []byte("\"" + self.GetOXMName() + "\""), nil
31271 }
31272}
31273
31274type OxmIdIcmpv6CodeMasked struct {
31275 *OxmId
31276}
31277
31278type IOxmIdIcmpv6CodeMasked interface {
31279 IOxmId
31280}
31281
31282func (self *OxmIdIcmpv6CodeMasked) Serialize(encoder *goloxi.Encoder) error {
31283 if err := self.OxmId.Serialize(encoder); err != nil {
31284 return err
31285 }
31286
31287 return nil
31288}
31289
31290func DecodeOxmIdIcmpv6CodeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6CodeMasked, error) {
31291 _oxmidicmpv6codemasked := &OxmIdIcmpv6CodeMasked{OxmId: parent}
31292 return _oxmidicmpv6codemasked, nil
31293}
31294
31295func NewOxmIdIcmpv6CodeMasked() *OxmIdIcmpv6CodeMasked {
31296 obj := &OxmIdIcmpv6CodeMasked{
31297 OxmId: NewOxmId(2147499266),
31298 }
31299 return obj
31300}
31301func (self *OxmIdIcmpv6CodeMasked) GetOXMName() string {
31302 return "icmpv6_code_masked"
31303}
31304
31305func (self *OxmIdIcmpv6CodeMasked) MarshalJSON() ([]byte, error) {
31306 if self.TypeLen == 0 {
31307 return []byte("\"\""), nil
31308 } else {
31309 return []byte("\"" + self.GetOXMName() + "\""), nil
31310 }
31311}
31312
31313type OxmIdIcmpv6TypeMasked struct {
31314 *OxmId
31315}
31316
31317type IOxmIdIcmpv6TypeMasked interface {
31318 IOxmId
31319}
31320
31321func (self *OxmIdIcmpv6TypeMasked) Serialize(encoder *goloxi.Encoder) error {
31322 if err := self.OxmId.Serialize(encoder); err != nil {
31323 return err
31324 }
31325
31326 return nil
31327}
31328
31329func DecodeOxmIdIcmpv6TypeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6TypeMasked, error) {
31330 _oxmidicmpv6typemasked := &OxmIdIcmpv6TypeMasked{OxmId: parent}
31331 return _oxmidicmpv6typemasked, nil
31332}
31333
31334func NewOxmIdIcmpv6TypeMasked() *OxmIdIcmpv6TypeMasked {
31335 obj := &OxmIdIcmpv6TypeMasked{
31336 OxmId: NewOxmId(2147498754),
31337 }
31338 return obj
31339}
31340func (self *OxmIdIcmpv6TypeMasked) GetOXMName() string {
31341 return "icmpv6_type_masked"
31342}
31343
31344func (self *OxmIdIcmpv6TypeMasked) MarshalJSON() ([]byte, error) {
31345 if self.TypeLen == 0 {
31346 return []byte("\"\""), nil
31347 } else {
31348 return []byte("\"" + self.GetOXMName() + "\""), nil
31349 }
31350}
31351
31352type OxmIdInPhyPort struct {
31353 *OxmId
31354}
31355
31356type IOxmIdInPhyPort interface {
31357 IOxmId
31358}
31359
31360func (self *OxmIdInPhyPort) Serialize(encoder *goloxi.Encoder) error {
31361 if err := self.OxmId.Serialize(encoder); err != nil {
31362 return err
31363 }
31364
31365 return nil
31366}
31367
31368func DecodeOxmIdInPhyPort(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPhyPort, error) {
31369 _oxmidinphyport := &OxmIdInPhyPort{OxmId: parent}
31370 return _oxmidinphyport, nil
31371}
31372
31373func NewOxmIdInPhyPort() *OxmIdInPhyPort {
31374 obj := &OxmIdInPhyPort{
31375 OxmId: NewOxmId(2147484164),
31376 }
31377 return obj
31378}
31379func (self *OxmIdInPhyPort) GetOXMName() string {
31380 return "in_phy_port"
31381}
31382
31383func (self *OxmIdInPhyPort) MarshalJSON() ([]byte, error) {
31384 if self.TypeLen == 0 {
31385 return []byte("\"\""), nil
31386 } else {
31387 return []byte("\"" + self.GetOXMName() + "\""), nil
31388 }
31389}
31390
31391type OxmIdInPhyPortMasked struct {
31392 *OxmId
31393}
31394
31395type IOxmIdInPhyPortMasked interface {
31396 IOxmId
31397}
31398
31399func (self *OxmIdInPhyPortMasked) Serialize(encoder *goloxi.Encoder) error {
31400 if err := self.OxmId.Serialize(encoder); err != nil {
31401 return err
31402 }
31403
31404 return nil
31405}
31406
31407func DecodeOxmIdInPhyPortMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPhyPortMasked, error) {
31408 _oxmidinphyportmasked := &OxmIdInPhyPortMasked{OxmId: parent}
31409 return _oxmidinphyportmasked, nil
31410}
31411
31412func NewOxmIdInPhyPortMasked() *OxmIdInPhyPortMasked {
31413 obj := &OxmIdInPhyPortMasked{
31414 OxmId: NewOxmId(2147484424),
31415 }
31416 return obj
31417}
31418func (self *OxmIdInPhyPortMasked) GetOXMName() string {
31419 return "in_phy_port_masked"
31420}
31421
31422func (self *OxmIdInPhyPortMasked) MarshalJSON() ([]byte, error) {
31423 if self.TypeLen == 0 {
31424 return []byte("\"\""), nil
31425 } else {
31426 return []byte("\"" + self.GetOXMName() + "\""), nil
31427 }
31428}
31429
31430type OxmIdInPortMasked struct {
31431 *OxmId
31432}
31433
31434type IOxmIdInPortMasked interface {
31435 IOxmId
31436}
31437
31438func (self *OxmIdInPortMasked) Serialize(encoder *goloxi.Encoder) error {
31439 if err := self.OxmId.Serialize(encoder); err != nil {
31440 return err
31441 }
31442
31443 return nil
31444}
31445
31446func DecodeOxmIdInPortMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPortMasked, error) {
31447 _oxmidinportmasked := &OxmIdInPortMasked{OxmId: parent}
31448 return _oxmidinportmasked, nil
31449}
31450
31451func NewOxmIdInPortMasked() *OxmIdInPortMasked {
31452 obj := &OxmIdInPortMasked{
31453 OxmId: NewOxmId(2147483912),
31454 }
31455 return obj
31456}
31457func (self *OxmIdInPortMasked) GetOXMName() string {
31458 return "in_port_masked"
31459}
31460
31461func (self *OxmIdInPortMasked) MarshalJSON() ([]byte, error) {
31462 if self.TypeLen == 0 {
31463 return []byte("\"\""), nil
31464 } else {
31465 return []byte("\"" + self.GetOXMName() + "\""), nil
31466 }
31467}
31468
31469type OxmIdIpDscp struct {
31470 *OxmId
31471}
31472
31473type IOxmIdIpDscp interface {
31474 IOxmId
31475}
31476
31477func (self *OxmIdIpDscp) Serialize(encoder *goloxi.Encoder) error {
31478 if err := self.OxmId.Serialize(encoder); err != nil {
31479 return err
31480 }
31481
31482 return nil
31483}
31484
31485func DecodeOxmIdIpDscp(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDscp, error) {
31486 _oxmidipdscp := &OxmIdIpDscp{OxmId: parent}
31487 return _oxmidipdscp, nil
31488}
31489
31490func NewOxmIdIpDscp() *OxmIdIpDscp {
31491 obj := &OxmIdIpDscp{
31492 OxmId: NewOxmId(2147487745),
31493 }
31494 return obj
31495}
31496func (self *OxmIdIpDscp) GetOXMName() string {
31497 return "ip_dscp"
31498}
31499
31500func (self *OxmIdIpDscp) MarshalJSON() ([]byte, error) {
31501 if self.TypeLen == 0 {
31502 return []byte("\"\""), nil
31503 } else {
31504 return []byte("\"" + self.GetOXMName() + "\""), nil
31505 }
31506}
31507
31508type OxmIdIpDscpMasked struct {
31509 *OxmId
31510}
31511
31512type IOxmIdIpDscpMasked interface {
31513 IOxmId
31514}
31515
31516func (self *OxmIdIpDscpMasked) Serialize(encoder *goloxi.Encoder) error {
31517 if err := self.OxmId.Serialize(encoder); err != nil {
31518 return err
31519 }
31520
31521 return nil
31522}
31523
31524func DecodeOxmIdIpDscpMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDscpMasked, error) {
31525 _oxmidipdscpmasked := &OxmIdIpDscpMasked{OxmId: parent}
31526 return _oxmidipdscpmasked, nil
31527}
31528
31529func NewOxmIdIpDscpMasked() *OxmIdIpDscpMasked {
31530 obj := &OxmIdIpDscpMasked{
31531 OxmId: NewOxmId(2147488002),
31532 }
31533 return obj
31534}
31535func (self *OxmIdIpDscpMasked) GetOXMName() string {
31536 return "ip_dscp_masked"
31537}
31538
31539func (self *OxmIdIpDscpMasked) MarshalJSON() ([]byte, error) {
31540 if self.TypeLen == 0 {
31541 return []byte("\"\""), nil
31542 } else {
31543 return []byte("\"" + self.GetOXMName() + "\""), nil
31544 }
31545}
31546
31547type OxmIdIpEcn struct {
31548 *OxmId
31549}
31550
31551type IOxmIdIpEcn interface {
31552 IOxmId
31553}
31554
31555func (self *OxmIdIpEcn) Serialize(encoder *goloxi.Encoder) error {
31556 if err := self.OxmId.Serialize(encoder); err != nil {
31557 return err
31558 }
31559
31560 return nil
31561}
31562
31563func DecodeOxmIdIpEcn(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpEcn, error) {
31564 _oxmidipecn := &OxmIdIpEcn{OxmId: parent}
31565 return _oxmidipecn, nil
31566}
31567
31568func NewOxmIdIpEcn() *OxmIdIpEcn {
31569 obj := &OxmIdIpEcn{
31570 OxmId: NewOxmId(2147488257),
31571 }
31572 return obj
31573}
31574func (self *OxmIdIpEcn) GetOXMName() string {
31575 return "ip_ecn"
31576}
31577
31578func (self *OxmIdIpEcn) MarshalJSON() ([]byte, error) {
31579 if self.TypeLen == 0 {
31580 return []byte("\"\""), nil
31581 } else {
31582 return []byte("\"" + self.GetOXMName() + "\""), nil
31583 }
31584}
31585
31586type OxmIdIpEcnMasked struct {
31587 *OxmId
31588}
31589
31590type IOxmIdIpEcnMasked interface {
31591 IOxmId
31592}
31593
31594func (self *OxmIdIpEcnMasked) Serialize(encoder *goloxi.Encoder) error {
31595 if err := self.OxmId.Serialize(encoder); err != nil {
31596 return err
31597 }
31598
31599 return nil
31600}
31601
31602func DecodeOxmIdIpEcnMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpEcnMasked, error) {
31603 _oxmidipecnmasked := &OxmIdIpEcnMasked{OxmId: parent}
31604 return _oxmidipecnmasked, nil
31605}
31606
31607func NewOxmIdIpEcnMasked() *OxmIdIpEcnMasked {
31608 obj := &OxmIdIpEcnMasked{
31609 OxmId: NewOxmId(2147488514),
31610 }
31611 return obj
31612}
31613func (self *OxmIdIpEcnMasked) GetOXMName() string {
31614 return "ip_ecn_masked"
31615}
31616
31617func (self *OxmIdIpEcnMasked) MarshalJSON() ([]byte, error) {
31618 if self.TypeLen == 0 {
31619 return []byte("\"\""), nil
31620 } else {
31621 return []byte("\"" + self.GetOXMName() + "\""), nil
31622 }
31623}
31624
31625type OxmIdIpProto struct {
31626 *OxmId
31627}
31628
31629type IOxmIdIpProto interface {
31630 IOxmId
31631}
31632
31633func (self *OxmIdIpProto) Serialize(encoder *goloxi.Encoder) error {
31634 if err := self.OxmId.Serialize(encoder); err != nil {
31635 return err
31636 }
31637
31638 return nil
31639}
31640
31641func DecodeOxmIdIpProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpProto, error) {
31642 _oxmidipproto := &OxmIdIpProto{OxmId: parent}
31643 return _oxmidipproto, nil
31644}
31645
31646func NewOxmIdIpProto() *OxmIdIpProto {
31647 obj := &OxmIdIpProto{
31648 OxmId: NewOxmId(2147488769),
31649 }
31650 return obj
31651}
31652func (self *OxmIdIpProto) GetOXMName() string {
31653 return "ip_proto"
31654}
31655
31656func (self *OxmIdIpProto) MarshalJSON() ([]byte, error) {
31657 if self.TypeLen == 0 {
31658 return []byte("\"\""), nil
31659 } else {
31660 return []byte("\"" + self.GetOXMName() + "\""), nil
31661 }
31662}
31663
31664type OxmIdIpProtoMasked struct {
31665 *OxmId
31666}
31667
31668type IOxmIdIpProtoMasked interface {
31669 IOxmId
31670}
31671
31672func (self *OxmIdIpProtoMasked) Serialize(encoder *goloxi.Encoder) error {
31673 if err := self.OxmId.Serialize(encoder); err != nil {
31674 return err
31675 }
31676
31677 return nil
31678}
31679
31680func DecodeOxmIdIpProtoMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpProtoMasked, error) {
31681 _oxmidipprotomasked := &OxmIdIpProtoMasked{OxmId: parent}
31682 return _oxmidipprotomasked, nil
31683}
31684
31685func NewOxmIdIpProtoMasked() *OxmIdIpProtoMasked {
31686 obj := &OxmIdIpProtoMasked{
31687 OxmId: NewOxmId(2147489026),
31688 }
31689 return obj
31690}
31691func (self *OxmIdIpProtoMasked) GetOXMName() string {
31692 return "ip_proto_masked"
31693}
31694
31695func (self *OxmIdIpProtoMasked) MarshalJSON() ([]byte, error) {
31696 if self.TypeLen == 0 {
31697 return []byte("\"\""), nil
31698 } else {
31699 return []byte("\"" + self.GetOXMName() + "\""), nil
31700 }
31701}
31702
31703type OxmIdIpv4Dst struct {
31704 *OxmId
31705}
31706
31707type IOxmIdIpv4Dst interface {
31708 IOxmId
31709}
31710
31711func (self *OxmIdIpv4Dst) Serialize(encoder *goloxi.Encoder) error {
31712 if err := self.OxmId.Serialize(encoder); err != nil {
31713 return err
31714 }
31715
31716 return nil
31717}
31718
31719func DecodeOxmIdIpv4Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4Dst, error) {
31720 _oxmidipv4dst := &OxmIdIpv4Dst{OxmId: parent}
31721 return _oxmidipv4dst, nil
31722}
31723
31724func NewOxmIdIpv4Dst() *OxmIdIpv4Dst {
31725 obj := &OxmIdIpv4Dst{
31726 OxmId: NewOxmId(2147489796),
31727 }
31728 return obj
31729}
31730func (self *OxmIdIpv4Dst) GetOXMName() string {
31731 return "ipv4_dst"
31732}
31733
31734func (self *OxmIdIpv4Dst) MarshalJSON() ([]byte, error) {
31735 if self.TypeLen == 0 {
31736 return []byte("\"\""), nil
31737 } else {
31738 return []byte("\"" + self.GetOXMName() + "\""), nil
31739 }
31740}
31741
31742type OxmIdIpv4DstMasked struct {
31743 *OxmId
31744}
31745
31746type IOxmIdIpv4DstMasked interface {
31747 IOxmId
31748}
31749
31750func (self *OxmIdIpv4DstMasked) Serialize(encoder *goloxi.Encoder) error {
31751 if err := self.OxmId.Serialize(encoder); err != nil {
31752 return err
31753 }
31754
31755 return nil
31756}
31757
31758func DecodeOxmIdIpv4DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4DstMasked, error) {
31759 _oxmidipv4dstmasked := &OxmIdIpv4DstMasked{OxmId: parent}
31760 return _oxmidipv4dstmasked, nil
31761}
31762
31763func NewOxmIdIpv4DstMasked() *OxmIdIpv4DstMasked {
31764 obj := &OxmIdIpv4DstMasked{
31765 OxmId: NewOxmId(2147490056),
31766 }
31767 return obj
31768}
31769func (self *OxmIdIpv4DstMasked) GetOXMName() string {
31770 return "ipv4_dst_masked"
31771}
31772
31773func (self *OxmIdIpv4DstMasked) MarshalJSON() ([]byte, error) {
31774 if self.TypeLen == 0 {
31775 return []byte("\"\""), nil
31776 } else {
31777 return []byte("\"" + self.GetOXMName() + "\""), nil
31778 }
31779}
31780
31781type OxmIdIpv4Src struct {
31782 *OxmId
31783}
31784
31785type IOxmIdIpv4Src interface {
31786 IOxmId
31787}
31788
31789func (self *OxmIdIpv4Src) Serialize(encoder *goloxi.Encoder) error {
31790 if err := self.OxmId.Serialize(encoder); err != nil {
31791 return err
31792 }
31793
31794 return nil
31795}
31796
31797func DecodeOxmIdIpv4Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4Src, error) {
31798 _oxmidipv4src := &OxmIdIpv4Src{OxmId: parent}
31799 return _oxmidipv4src, nil
31800}
31801
31802func NewOxmIdIpv4Src() *OxmIdIpv4Src {
31803 obj := &OxmIdIpv4Src{
31804 OxmId: NewOxmId(2147489284),
31805 }
31806 return obj
31807}
31808func (self *OxmIdIpv4Src) GetOXMName() string {
31809 return "ipv4_src"
31810}
31811
31812func (self *OxmIdIpv4Src) MarshalJSON() ([]byte, error) {
31813 if self.TypeLen == 0 {
31814 return []byte("\"\""), nil
31815 } else {
31816 return []byte("\"" + self.GetOXMName() + "\""), nil
31817 }
31818}
31819
31820type OxmIdIpv4SrcMasked struct {
31821 *OxmId
31822}
31823
31824type IOxmIdIpv4SrcMasked interface {
31825 IOxmId
31826}
31827
31828func (self *OxmIdIpv4SrcMasked) Serialize(encoder *goloxi.Encoder) error {
31829 if err := self.OxmId.Serialize(encoder); err != nil {
31830 return err
31831 }
31832
31833 return nil
31834}
31835
31836func DecodeOxmIdIpv4SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4SrcMasked, error) {
31837 _oxmidipv4srcmasked := &OxmIdIpv4SrcMasked{OxmId: parent}
31838 return _oxmidipv4srcmasked, nil
31839}
31840
31841func NewOxmIdIpv4SrcMasked() *OxmIdIpv4SrcMasked {
31842 obj := &OxmIdIpv4SrcMasked{
31843 OxmId: NewOxmId(2147489544),
31844 }
31845 return obj
31846}
31847func (self *OxmIdIpv4SrcMasked) GetOXMName() string {
31848 return "ipv4_src_masked"
31849}
31850
31851func (self *OxmIdIpv4SrcMasked) MarshalJSON() ([]byte, error) {
31852 if self.TypeLen == 0 {
31853 return []byte("\"\""), nil
31854 } else {
31855 return []byte("\"" + self.GetOXMName() + "\""), nil
31856 }
31857}
31858
31859type OxmIdIpv6Exthdr struct {
31860 *OxmId
31861}
31862
31863type IOxmIdIpv6Exthdr interface {
31864 IOxmId
31865}
31866
31867func (self *OxmIdIpv6Exthdr) Serialize(encoder *goloxi.Encoder) error {
31868 if err := self.OxmId.Serialize(encoder); err != nil {
31869 return err
31870 }
31871
31872 return nil
31873}
31874
31875func DecodeOxmIdIpv6Exthdr(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Exthdr, error) {
31876 _oxmidipv6exthdr := &OxmIdIpv6Exthdr{OxmId: parent}
31877 return _oxmidipv6exthdr, nil
31878}
31879
31880func NewOxmIdIpv6Exthdr() *OxmIdIpv6Exthdr {
31881 obj := &OxmIdIpv6Exthdr{
31882 OxmId: NewOxmId(2147503618),
31883 }
31884 return obj
31885}
31886func (self *OxmIdIpv6Exthdr) GetOXMName() string {
31887 return "ipv6_exthdr"
31888}
31889
31890func (self *OxmIdIpv6Exthdr) MarshalJSON() ([]byte, error) {
31891 if self.TypeLen == 0 {
31892 return []byte("\"\""), nil
31893 } else {
31894 return []byte("\"" + self.GetOXMName() + "\""), nil
31895 }
31896}
31897
31898type OxmIdIpv6ExthdrMasked struct {
31899 *OxmId
31900}
31901
31902type IOxmIdIpv6ExthdrMasked interface {
31903 IOxmId
31904}
31905
31906func (self *OxmIdIpv6ExthdrMasked) Serialize(encoder *goloxi.Encoder) error {
31907 if err := self.OxmId.Serialize(encoder); err != nil {
31908 return err
31909 }
31910
31911 return nil
31912}
31913
31914func DecodeOxmIdIpv6ExthdrMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6ExthdrMasked, error) {
31915 _oxmidipv6exthdrmasked := &OxmIdIpv6ExthdrMasked{OxmId: parent}
31916 return _oxmidipv6exthdrmasked, nil
31917}
31918
31919func NewOxmIdIpv6ExthdrMasked() *OxmIdIpv6ExthdrMasked {
31920 obj := &OxmIdIpv6ExthdrMasked{
31921 OxmId: NewOxmId(2147503876),
31922 }
31923 return obj
31924}
31925func (self *OxmIdIpv6ExthdrMasked) GetOXMName() string {
31926 return "ipv6_exthdr_masked"
31927}
31928
31929func (self *OxmIdIpv6ExthdrMasked) MarshalJSON() ([]byte, error) {
31930 if self.TypeLen == 0 {
31931 return []byte("\"\""), nil
31932 } else {
31933 return []byte("\"" + self.GetOXMName() + "\""), nil
31934 }
31935}
31936
31937type OxmIdIpv6Flabel struct {
31938 *OxmId
31939}
31940
31941type IOxmIdIpv6Flabel interface {
31942 IOxmId
31943}
31944
31945func (self *OxmIdIpv6Flabel) Serialize(encoder *goloxi.Encoder) error {
31946 if err := self.OxmId.Serialize(encoder); err != nil {
31947 return err
31948 }
31949
31950 return nil
31951}
31952
31953func DecodeOxmIdIpv6Flabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Flabel, error) {
31954 _oxmidipv6flabel := &OxmIdIpv6Flabel{OxmId: parent}
31955 return _oxmidipv6flabel, nil
31956}
31957
31958func NewOxmIdIpv6Flabel() *OxmIdIpv6Flabel {
31959 obj := &OxmIdIpv6Flabel{
31960 OxmId: NewOxmId(2147497988),
31961 }
31962 return obj
31963}
31964func (self *OxmIdIpv6Flabel) GetOXMName() string {
31965 return "ipv6_flabel"
31966}
31967
31968func (self *OxmIdIpv6Flabel) MarshalJSON() ([]byte, error) {
31969 if self.TypeLen == 0 {
31970 return []byte("\"\""), nil
31971 } else {
31972 return []byte("\"" + self.GetOXMName() + "\""), nil
31973 }
31974}
31975
31976type OxmIdIpv6FlabelMasked struct {
31977 *OxmId
31978}
31979
31980type IOxmIdIpv6FlabelMasked interface {
31981 IOxmId
31982}
31983
31984func (self *OxmIdIpv6FlabelMasked) Serialize(encoder *goloxi.Encoder) error {
31985 if err := self.OxmId.Serialize(encoder); err != nil {
31986 return err
31987 }
31988
31989 return nil
31990}
31991
31992func DecodeOxmIdIpv6FlabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6FlabelMasked, error) {
31993 _oxmidipv6flabelmasked := &OxmIdIpv6FlabelMasked{OxmId: parent}
31994 return _oxmidipv6flabelmasked, nil
31995}
31996
31997func NewOxmIdIpv6FlabelMasked() *OxmIdIpv6FlabelMasked {
31998 obj := &OxmIdIpv6FlabelMasked{
31999 OxmId: NewOxmId(2147498248),
32000 }
32001 return obj
32002}
32003func (self *OxmIdIpv6FlabelMasked) GetOXMName() string {
32004 return "ipv6_flabel_masked"
32005}
32006
32007func (self *OxmIdIpv6FlabelMasked) MarshalJSON() ([]byte, error) {
32008 if self.TypeLen == 0 {
32009 return []byte("\"\""), nil
32010 } else {
32011 return []byte("\"" + self.GetOXMName() + "\""), nil
32012 }
32013}
32014
32015type OxmIdIpv6NdSll struct {
32016 *OxmId
32017}
32018
32019type IOxmIdIpv6NdSll interface {
32020 IOxmId
32021}
32022
32023func (self *OxmIdIpv6NdSll) Serialize(encoder *goloxi.Encoder) error {
32024 if err := self.OxmId.Serialize(encoder); err != nil {
32025 return err
32026 }
32027
32028 return nil
32029}
32030
32031func DecodeOxmIdIpv6NdSll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdSll, error) {
32032 _oxmidipv6ndsll := &OxmIdIpv6NdSll{OxmId: parent}
32033 return _oxmidipv6ndsll, nil
32034}
32035
32036func NewOxmIdIpv6NdSll() *OxmIdIpv6NdSll {
32037 obj := &OxmIdIpv6NdSll{
32038 OxmId: NewOxmId(2147500038),
32039 }
32040 return obj
32041}
32042func (self *OxmIdIpv6NdSll) GetOXMName() string {
32043 return "ipv6_nd_sll"
32044}
32045
32046func (self *OxmIdIpv6NdSll) MarshalJSON() ([]byte, error) {
32047 if self.TypeLen == 0 {
32048 return []byte("\"\""), nil
32049 } else {
32050 return []byte("\"" + self.GetOXMName() + "\""), nil
32051 }
32052}
32053
32054type OxmIdIpv6NdSllMasked struct {
32055 *OxmId
32056}
32057
32058type IOxmIdIpv6NdSllMasked interface {
32059 IOxmId
32060}
32061
32062func (self *OxmIdIpv6NdSllMasked) Serialize(encoder *goloxi.Encoder) error {
32063 if err := self.OxmId.Serialize(encoder); err != nil {
32064 return err
32065 }
32066
32067 return nil
32068}
32069
32070func DecodeOxmIdIpv6NdSllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdSllMasked, error) {
32071 _oxmidipv6ndsllmasked := &OxmIdIpv6NdSllMasked{OxmId: parent}
32072 return _oxmidipv6ndsllmasked, nil
32073}
32074
32075func NewOxmIdIpv6NdSllMasked() *OxmIdIpv6NdSllMasked {
32076 obj := &OxmIdIpv6NdSllMasked{
32077 OxmId: NewOxmId(2147500300),
32078 }
32079 return obj
32080}
32081func (self *OxmIdIpv6NdSllMasked) GetOXMName() string {
32082 return "ipv6_nd_sll_masked"
32083}
32084
32085func (self *OxmIdIpv6NdSllMasked) MarshalJSON() ([]byte, error) {
32086 if self.TypeLen == 0 {
32087 return []byte("\"\""), nil
32088 } else {
32089 return []byte("\"" + self.GetOXMName() + "\""), nil
32090 }
32091}
32092
32093type OxmIdIpv6NdTarget struct {
32094 *OxmId
32095}
32096
32097type IOxmIdIpv6NdTarget interface {
32098 IOxmId
32099}
32100
32101func (self *OxmIdIpv6NdTarget) Serialize(encoder *goloxi.Encoder) error {
32102 if err := self.OxmId.Serialize(encoder); err != nil {
32103 return err
32104 }
32105
32106 return nil
32107}
32108
32109func DecodeOxmIdIpv6NdTarget(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTarget, error) {
32110 _oxmidipv6ndtarget := &OxmIdIpv6NdTarget{OxmId: parent}
32111 return _oxmidipv6ndtarget, nil
32112}
32113
32114func NewOxmIdIpv6NdTarget() *OxmIdIpv6NdTarget {
32115 obj := &OxmIdIpv6NdTarget{
32116 OxmId: NewOxmId(2147499536),
32117 }
32118 return obj
32119}
32120func (self *OxmIdIpv6NdTarget) GetOXMName() string {
32121 return "ipv6_nd_target"
32122}
32123
32124func (self *OxmIdIpv6NdTarget) MarshalJSON() ([]byte, error) {
32125 if self.TypeLen == 0 {
32126 return []byte("\"\""), nil
32127 } else {
32128 return []byte("\"" + self.GetOXMName() + "\""), nil
32129 }
32130}
32131
32132type OxmIdIpv6NdTargetMasked struct {
32133 *OxmId
32134}
32135
32136type IOxmIdIpv6NdTargetMasked interface {
32137 IOxmId
32138}
32139
32140func (self *OxmIdIpv6NdTargetMasked) Serialize(encoder *goloxi.Encoder) error {
32141 if err := self.OxmId.Serialize(encoder); err != nil {
32142 return err
32143 }
32144
32145 return nil
32146}
32147
32148func DecodeOxmIdIpv6NdTargetMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTargetMasked, error) {
32149 _oxmidipv6ndtargetmasked := &OxmIdIpv6NdTargetMasked{OxmId: parent}
32150 return _oxmidipv6ndtargetmasked, nil
32151}
32152
32153func NewOxmIdIpv6NdTargetMasked() *OxmIdIpv6NdTargetMasked {
32154 obj := &OxmIdIpv6NdTargetMasked{
32155 OxmId: NewOxmId(2147499808),
32156 }
32157 return obj
32158}
32159func (self *OxmIdIpv6NdTargetMasked) GetOXMName() string {
32160 return "ipv6_nd_target_masked"
32161}
32162
32163func (self *OxmIdIpv6NdTargetMasked) MarshalJSON() ([]byte, error) {
32164 if self.TypeLen == 0 {
32165 return []byte("\"\""), nil
32166 } else {
32167 return []byte("\"" + self.GetOXMName() + "\""), nil
32168 }
32169}
32170
32171type OxmIdIpv6NdTll struct {
32172 *OxmId
32173}
32174
32175type IOxmIdIpv6NdTll interface {
32176 IOxmId
32177}
32178
32179func (self *OxmIdIpv6NdTll) Serialize(encoder *goloxi.Encoder) error {
32180 if err := self.OxmId.Serialize(encoder); err != nil {
32181 return err
32182 }
32183
32184 return nil
32185}
32186
32187func DecodeOxmIdIpv6NdTll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTll, error) {
32188 _oxmidipv6ndtll := &OxmIdIpv6NdTll{OxmId: parent}
32189 return _oxmidipv6ndtll, nil
32190}
32191
32192func NewOxmIdIpv6NdTll() *OxmIdIpv6NdTll {
32193 obj := &OxmIdIpv6NdTll{
32194 OxmId: NewOxmId(2147500550),
32195 }
32196 return obj
32197}
32198func (self *OxmIdIpv6NdTll) GetOXMName() string {
32199 return "ipv6_nd_tll"
32200}
32201
32202func (self *OxmIdIpv6NdTll) MarshalJSON() ([]byte, error) {
32203 if self.TypeLen == 0 {
32204 return []byte("\"\""), nil
32205 } else {
32206 return []byte("\"" + self.GetOXMName() + "\""), nil
32207 }
32208}
32209
32210type OxmIdIpv6NdTllMasked struct {
32211 *OxmId
32212}
32213
32214type IOxmIdIpv6NdTllMasked interface {
32215 IOxmId
32216}
32217
32218func (self *OxmIdIpv6NdTllMasked) Serialize(encoder *goloxi.Encoder) error {
32219 if err := self.OxmId.Serialize(encoder); err != nil {
32220 return err
32221 }
32222
32223 return nil
32224}
32225
32226func DecodeOxmIdIpv6NdTllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTllMasked, error) {
32227 _oxmidipv6ndtllmasked := &OxmIdIpv6NdTllMasked{OxmId: parent}
32228 return _oxmidipv6ndtllmasked, nil
32229}
32230
32231func NewOxmIdIpv6NdTllMasked() *OxmIdIpv6NdTllMasked {
32232 obj := &OxmIdIpv6NdTllMasked{
32233 OxmId: NewOxmId(2147500812),
32234 }
32235 return obj
32236}
32237func (self *OxmIdIpv6NdTllMasked) GetOXMName() string {
32238 return "ipv6_nd_tll_masked"
32239}
32240
32241func (self *OxmIdIpv6NdTllMasked) MarshalJSON() ([]byte, error) {
32242 if self.TypeLen == 0 {
32243 return []byte("\"\""), nil
32244 } else {
32245 return []byte("\"" + self.GetOXMName() + "\""), nil
32246 }
32247}
32248
32249type OxmIdMetadata struct {
32250 *OxmId
32251}
32252
32253type IOxmIdMetadata interface {
32254 IOxmId
32255}
32256
32257func (self *OxmIdMetadata) Serialize(encoder *goloxi.Encoder) error {
32258 if err := self.OxmId.Serialize(encoder); err != nil {
32259 return err
32260 }
32261
32262 return nil
32263}
32264
32265func DecodeOxmIdMetadata(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMetadata, error) {
32266 _oxmidmetadata := &OxmIdMetadata{OxmId: parent}
32267 return _oxmidmetadata, nil
32268}
32269
32270func NewOxmIdMetadata() *OxmIdMetadata {
32271 obj := &OxmIdMetadata{
32272 OxmId: NewOxmId(2147484680),
32273 }
32274 return obj
32275}
32276func (self *OxmIdMetadata) GetOXMName() string {
32277 return "metadata"
32278}
32279
32280func (self *OxmIdMetadata) MarshalJSON() ([]byte, error) {
32281 if self.TypeLen == 0 {
32282 return []byte("\"\""), nil
32283 } else {
32284 return []byte("\"" + self.GetOXMName() + "\""), nil
32285 }
32286}
32287
32288type OxmIdMetadataMasked struct {
32289 *OxmId
32290}
32291
32292type IOxmIdMetadataMasked interface {
32293 IOxmId
32294}
32295
32296func (self *OxmIdMetadataMasked) Serialize(encoder *goloxi.Encoder) error {
32297 if err := self.OxmId.Serialize(encoder); err != nil {
32298 return err
32299 }
32300
32301 return nil
32302}
32303
32304func DecodeOxmIdMetadataMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMetadataMasked, error) {
32305 _oxmidmetadatamasked := &OxmIdMetadataMasked{OxmId: parent}
32306 return _oxmidmetadatamasked, nil
32307}
32308
32309func NewOxmIdMetadataMasked() *OxmIdMetadataMasked {
32310 obj := &OxmIdMetadataMasked{
32311 OxmId: NewOxmId(2147484944),
32312 }
32313 return obj
32314}
32315func (self *OxmIdMetadataMasked) GetOXMName() string {
32316 return "metadata_masked"
32317}
32318
32319func (self *OxmIdMetadataMasked) MarshalJSON() ([]byte, error) {
32320 if self.TypeLen == 0 {
32321 return []byte("\"\""), nil
32322 } else {
32323 return []byte("\"" + self.GetOXMName() + "\""), nil
32324 }
32325}
32326
32327type OxmIdMplsBos struct {
32328 *OxmId
32329}
32330
32331type IOxmIdMplsBos interface {
32332 IOxmId
32333}
32334
32335func (self *OxmIdMplsBos) Serialize(encoder *goloxi.Encoder) error {
32336 if err := self.OxmId.Serialize(encoder); err != nil {
32337 return err
32338 }
32339
32340 return nil
32341}
32342
32343func DecodeOxmIdMplsBos(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsBos, error) {
32344 _oxmidmplsbos := &OxmIdMplsBos{OxmId: parent}
32345 return _oxmidmplsbos, nil
32346}
32347
32348func NewOxmIdMplsBos() *OxmIdMplsBos {
32349 obj := &OxmIdMplsBos{
32350 OxmId: NewOxmId(2147502081),
32351 }
32352 return obj
32353}
32354func (self *OxmIdMplsBos) GetOXMName() string {
32355 return "mpls_bos"
32356}
32357
32358func (self *OxmIdMplsBos) MarshalJSON() ([]byte, error) {
32359 if self.TypeLen == 0 {
32360 return []byte("\"\""), nil
32361 } else {
32362 return []byte("\"" + self.GetOXMName() + "\""), nil
32363 }
32364}
32365
32366type OxmIdMplsBosMasked struct {
32367 *OxmId
32368}
32369
32370type IOxmIdMplsBosMasked interface {
32371 IOxmId
32372}
32373
32374func (self *OxmIdMplsBosMasked) Serialize(encoder *goloxi.Encoder) error {
32375 if err := self.OxmId.Serialize(encoder); err != nil {
32376 return err
32377 }
32378
32379 return nil
32380}
32381
32382func DecodeOxmIdMplsBosMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsBosMasked, error) {
32383 _oxmidmplsbosmasked := &OxmIdMplsBosMasked{OxmId: parent}
32384 return _oxmidmplsbosmasked, nil
32385}
32386
32387func NewOxmIdMplsBosMasked() *OxmIdMplsBosMasked {
32388 obj := &OxmIdMplsBosMasked{
32389 OxmId: NewOxmId(2147502338),
32390 }
32391 return obj
32392}
32393func (self *OxmIdMplsBosMasked) GetOXMName() string {
32394 return "mpls_bos_masked"
32395}
32396
32397func (self *OxmIdMplsBosMasked) MarshalJSON() ([]byte, error) {
32398 if self.TypeLen == 0 {
32399 return []byte("\"\""), nil
32400 } else {
32401 return []byte("\"" + self.GetOXMName() + "\""), nil
32402 }
32403}
32404
32405type OxmIdMplsLabel struct {
32406 *OxmId
32407}
32408
32409type IOxmIdMplsLabel interface {
32410 IOxmId
32411}
32412
32413func (self *OxmIdMplsLabel) Serialize(encoder *goloxi.Encoder) error {
32414 if err := self.OxmId.Serialize(encoder); err != nil {
32415 return err
32416 }
32417
32418 return nil
32419}
32420
32421func DecodeOxmIdMplsLabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsLabel, error) {
32422 _oxmidmplslabel := &OxmIdMplsLabel{OxmId: parent}
32423 return _oxmidmplslabel, nil
32424}
32425
32426func NewOxmIdMplsLabel() *OxmIdMplsLabel {
32427 obj := &OxmIdMplsLabel{
32428 OxmId: NewOxmId(2147501060),
32429 }
32430 return obj
32431}
32432func (self *OxmIdMplsLabel) GetOXMName() string {
32433 return "mpls_label"
32434}
32435
32436func (self *OxmIdMplsLabel) MarshalJSON() ([]byte, error) {
32437 if self.TypeLen == 0 {
32438 return []byte("\"\""), nil
32439 } else {
32440 return []byte("\"" + self.GetOXMName() + "\""), nil
32441 }
32442}
32443
32444type OxmIdMplsLabelMasked struct {
32445 *OxmId
32446}
32447
32448type IOxmIdMplsLabelMasked interface {
32449 IOxmId
32450}
32451
32452func (self *OxmIdMplsLabelMasked) Serialize(encoder *goloxi.Encoder) error {
32453 if err := self.OxmId.Serialize(encoder); err != nil {
32454 return err
32455 }
32456
32457 return nil
32458}
32459
32460func DecodeOxmIdMplsLabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsLabelMasked, error) {
32461 _oxmidmplslabelmasked := &OxmIdMplsLabelMasked{OxmId: parent}
32462 return _oxmidmplslabelmasked, nil
32463}
32464
32465func NewOxmIdMplsLabelMasked() *OxmIdMplsLabelMasked {
32466 obj := &OxmIdMplsLabelMasked{
32467 OxmId: NewOxmId(2147501320),
32468 }
32469 return obj
32470}
32471func (self *OxmIdMplsLabelMasked) GetOXMName() string {
32472 return "mpls_label_masked"
32473}
32474
32475func (self *OxmIdMplsLabelMasked) MarshalJSON() ([]byte, error) {
32476 if self.TypeLen == 0 {
32477 return []byte("\"\""), nil
32478 } else {
32479 return []byte("\"" + self.GetOXMName() + "\""), nil
32480 }
32481}
32482
32483type OxmIdMplsTc struct {
32484 *OxmId
32485}
32486
32487type IOxmIdMplsTc interface {
32488 IOxmId
32489}
32490
32491func (self *OxmIdMplsTc) Serialize(encoder *goloxi.Encoder) error {
32492 if err := self.OxmId.Serialize(encoder); err != nil {
32493 return err
32494 }
32495
32496 return nil
32497}
32498
32499func DecodeOxmIdMplsTc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsTc, error) {
32500 _oxmidmplstc := &OxmIdMplsTc{OxmId: parent}
32501 return _oxmidmplstc, nil
32502}
32503
32504func NewOxmIdMplsTc() *OxmIdMplsTc {
32505 obj := &OxmIdMplsTc{
32506 OxmId: NewOxmId(2147501569),
32507 }
32508 return obj
32509}
32510func (self *OxmIdMplsTc) GetOXMName() string {
32511 return "mpls_tc"
32512}
32513
32514func (self *OxmIdMplsTc) MarshalJSON() ([]byte, error) {
32515 if self.TypeLen == 0 {
32516 return []byte("\"\""), nil
32517 } else {
32518 return []byte("\"" + self.GetOXMName() + "\""), nil
32519 }
32520}
32521
32522type OxmIdMplsTcMasked struct {
32523 *OxmId
32524}
32525
32526type IOxmIdMplsTcMasked interface {
32527 IOxmId
32528}
32529
32530func (self *OxmIdMplsTcMasked) Serialize(encoder *goloxi.Encoder) error {
32531 if err := self.OxmId.Serialize(encoder); err != nil {
32532 return err
32533 }
32534
32535 return nil
32536}
32537
32538func DecodeOxmIdMplsTcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsTcMasked, error) {
32539 _oxmidmplstcmasked := &OxmIdMplsTcMasked{OxmId: parent}
32540 return _oxmidmplstcmasked, nil
32541}
32542
32543func NewOxmIdMplsTcMasked() *OxmIdMplsTcMasked {
32544 obj := &OxmIdMplsTcMasked{
32545 OxmId: NewOxmId(2147501826),
32546 }
32547 return obj
32548}
32549func (self *OxmIdMplsTcMasked) GetOXMName() string {
32550 return "mpls_tc_masked"
32551}
32552
32553func (self *OxmIdMplsTcMasked) MarshalJSON() ([]byte, error) {
32554 if self.TypeLen == 0 {
32555 return []byte("\"\""), nil
32556 } else {
32557 return []byte("\"" + self.GetOXMName() + "\""), nil
32558 }
32559}
32560
32561type OxmIdOvsTcpFlags struct {
32562 *OxmId
32563 ExperimenterId uint32
32564}
32565
32566type IOxmIdOvsTcpFlags interface {
32567 IOxmId
32568 GetExperimenterId() uint32
32569}
32570
32571func (self *OxmIdOvsTcpFlags) GetExperimenterId() uint32 {
32572 return self.ExperimenterId
32573}
32574
32575func (self *OxmIdOvsTcpFlags) SetExperimenterId(v uint32) {
32576 self.ExperimenterId = v
32577}
32578
32579func (self *OxmIdOvsTcpFlags) Serialize(encoder *goloxi.Encoder) error {
32580 if err := self.OxmId.Serialize(encoder); err != nil {
32581 return err
32582 }
32583
32584 encoder.PutUint32(uint32(self.ExperimenterId))
32585
32586 return nil
32587}
32588
32589func DecodeOxmIdOvsTcpFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdOvsTcpFlags, error) {
32590 _oxmidovstcpflags := &OxmIdOvsTcpFlags{OxmId: parent}
32591 if decoder.Length() < 4 {
32592 return nil, fmt.Errorf("OxmIdOvsTcpFlags packet too short: %d < 4", decoder.Length())
32593 }
32594 _oxmidovstcpflags.ExperimenterId = uint32(decoder.ReadUint32())
32595 return _oxmidovstcpflags, nil
32596}
32597
32598func NewOxmIdOvsTcpFlags() *OxmIdOvsTcpFlags {
32599 obj := &OxmIdOvsTcpFlags{
32600 OxmId: NewOxmId(4294923270),
32601 }
32602 return obj
32603}
32604func (self *OxmIdOvsTcpFlags) GetOXMName() string {
32605 return "ovs_tcp_flags"
32606}
32607
32608func (self *OxmIdOvsTcpFlags) MarshalJSON() ([]byte, error) {
32609 if self.TypeLen == 0 {
32610 return []byte("\"\""), nil
32611 } else {
32612 return []byte("\"" + self.GetOXMName() + "\""), nil
32613 }
32614}
32615
32616type OxmIdOvsTcpFlagsMasked struct {
32617 *OxmId
32618 ExperimenterId uint32
32619}
32620
32621type IOxmIdOvsTcpFlagsMasked interface {
32622 IOxmId
32623 GetExperimenterId() uint32
32624}
32625
32626func (self *OxmIdOvsTcpFlagsMasked) GetExperimenterId() uint32 {
32627 return self.ExperimenterId
32628}
32629
32630func (self *OxmIdOvsTcpFlagsMasked) SetExperimenterId(v uint32) {
32631 self.ExperimenterId = v
32632}
32633
32634func (self *OxmIdOvsTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
32635 if err := self.OxmId.Serialize(encoder); err != nil {
32636 return err
32637 }
32638
32639 encoder.PutUint32(uint32(self.ExperimenterId))
32640
32641 return nil
32642}
32643
32644func DecodeOxmIdOvsTcpFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdOvsTcpFlagsMasked, error) {
32645 _oxmidovstcpflagsmasked := &OxmIdOvsTcpFlagsMasked{OxmId: parent}
32646 if decoder.Length() < 4 {
32647 return nil, fmt.Errorf("OxmIdOvsTcpFlagsMasked packet too short: %d < 4", decoder.Length())
32648 }
32649 _oxmidovstcpflagsmasked.ExperimenterId = uint32(decoder.ReadUint32())
32650 return _oxmidovstcpflagsmasked, nil
32651}
32652
32653func NewOxmIdOvsTcpFlagsMasked() *OxmIdOvsTcpFlagsMasked {
32654 obj := &OxmIdOvsTcpFlagsMasked{
32655 OxmId: NewOxmId(4294923528),
32656 }
32657 return obj
32658}
32659func (self *OxmIdOvsTcpFlagsMasked) GetOXMName() string {
32660 return "ovs_tcp_flags_masked"
32661}
32662
32663func (self *OxmIdOvsTcpFlagsMasked) MarshalJSON() ([]byte, error) {
32664 if self.TypeLen == 0 {
32665 return []byte("\"\""), nil
32666 } else {
32667 return []byte("\"" + self.GetOXMName() + "\""), nil
32668 }
32669}
32670
32671type OxmIdPacketType struct {
32672 *OxmId
32673}
32674
32675type IOxmIdPacketType interface {
32676 IOxmId
32677}
32678
32679func (self *OxmIdPacketType) Serialize(encoder *goloxi.Encoder) error {
32680 if err := self.OxmId.Serialize(encoder); err != nil {
32681 return err
32682 }
32683
32684 return nil
32685}
32686
32687func DecodeOxmIdPacketType(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdPacketType, error) {
32688 _oxmidpackettype := &OxmIdPacketType{OxmId: parent}
32689 return _oxmidpackettype, nil
32690}
32691
32692func NewOxmIdPacketType() *OxmIdPacketType {
32693 obj := &OxmIdPacketType{
32694 OxmId: NewOxmId(2147506180),
32695 }
32696 return obj
32697}
32698func (self *OxmIdPacketType) GetOXMName() string {
32699 return "packet_type"
32700}
32701
32702func (self *OxmIdPacketType) MarshalJSON() ([]byte, error) {
32703 if self.TypeLen == 0 {
32704 return []byte("\"\""), nil
32705 } else {
32706 return []byte("\"" + self.GetOXMName() + "\""), nil
32707 }
32708}
32709
32710type OxmIdPbbUca struct {
32711 *OxmId
32712}
32713
32714type IOxmIdPbbUca interface {
32715 IOxmId
32716}
32717
32718func (self *OxmIdPbbUca) Serialize(encoder *goloxi.Encoder) error {
32719 if err := self.OxmId.Serialize(encoder); err != nil {
32720 return err
32721 }
32722
32723 return nil
32724}
32725
32726func DecodeOxmIdPbbUca(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdPbbUca, error) {
32727 _oxmidpbbuca := &OxmIdPbbUca{OxmId: parent}
32728 return _oxmidpbbuca, nil
32729}
32730
32731func NewOxmIdPbbUca() *OxmIdPbbUca {
32732 obj := &OxmIdPbbUca{
32733 OxmId: NewOxmId(2147504641),
32734 }
32735 return obj
32736}
32737func (self *OxmIdPbbUca) GetOXMName() string {
32738 return "pbb_uca"
32739}
32740
32741func (self *OxmIdPbbUca) MarshalJSON() ([]byte, error) {
32742 if self.TypeLen == 0 {
32743 return []byte("\"\""), nil
32744 } else {
32745 return []byte("\"" + self.GetOXMName() + "\""), nil
32746 }
32747}
32748
32749type OxmIdPbbUcaMasked struct {
32750 *OxmId
32751}
32752
32753type IOxmIdPbbUcaMasked interface {
32754 IOxmId
32755}
32756
32757func (self *OxmIdPbbUcaMasked) Serialize(encoder *goloxi.Encoder) error {
32758 if err := self.OxmId.Serialize(encoder); err != nil {
32759 return err
32760 }
32761
32762 return nil
32763}
32764
32765func DecodeOxmIdPbbUcaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdPbbUcaMasked, error) {
32766 _oxmidpbbucamasked := &OxmIdPbbUcaMasked{OxmId: parent}
32767 return _oxmidpbbucamasked, nil
32768}
32769
32770func NewOxmIdPbbUcaMasked() *OxmIdPbbUcaMasked {
32771 obj := &OxmIdPbbUcaMasked{
32772 OxmId: NewOxmId(2147504898),
32773 }
32774 return obj
32775}
32776func (self *OxmIdPbbUcaMasked) GetOXMName() string {
32777 return "pbb_uca_masked"
32778}
32779
32780func (self *OxmIdPbbUcaMasked) MarshalJSON() ([]byte, error) {
32781 if self.TypeLen == 0 {
32782 return []byte("\"\""), nil
32783 } else {
32784 return []byte("\"" + self.GetOXMName() + "\""), nil
32785 }
32786}
32787
32788type OxmIdSctpDst struct {
32789 *OxmId
32790}
32791
32792type IOxmIdSctpDst interface {
32793 IOxmId
32794}
32795
32796func (self *OxmIdSctpDst) Serialize(encoder *goloxi.Encoder) error {
32797 if err := self.OxmId.Serialize(encoder); err != nil {
32798 return err
32799 }
32800
32801 return nil
32802}
32803
32804func DecodeOxmIdSctpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpDst, error) {
32805 _oxmidsctpdst := &OxmIdSctpDst{OxmId: parent}
32806 return _oxmidsctpdst, nil
32807}
32808
32809func NewOxmIdSctpDst() *OxmIdSctpDst {
32810 obj := &OxmIdSctpDst{
32811 OxmId: NewOxmId(2147492866),
32812 }
32813 return obj
32814}
32815func (self *OxmIdSctpDst) GetOXMName() string {
32816 return "sctp_dst"
32817}
32818
32819func (self *OxmIdSctpDst) MarshalJSON() ([]byte, error) {
32820 if self.TypeLen == 0 {
32821 return []byte("\"\""), nil
32822 } else {
32823 return []byte("\"" + self.GetOXMName() + "\""), nil
32824 }
32825}
32826
32827type OxmIdSctpDstMasked struct {
32828 *OxmId
32829}
32830
32831type IOxmIdSctpDstMasked interface {
32832 IOxmId
32833}
32834
32835func (self *OxmIdSctpDstMasked) Serialize(encoder *goloxi.Encoder) error {
32836 if err := self.OxmId.Serialize(encoder); err != nil {
32837 return err
32838 }
32839
32840 return nil
32841}
32842
32843func DecodeOxmIdSctpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpDstMasked, error) {
32844 _oxmidsctpdstmasked := &OxmIdSctpDstMasked{OxmId: parent}
32845 return _oxmidsctpdstmasked, nil
32846}
32847
32848func NewOxmIdSctpDstMasked() *OxmIdSctpDstMasked {
32849 obj := &OxmIdSctpDstMasked{
32850 OxmId: NewOxmId(2147493124),
32851 }
32852 return obj
32853}
32854func (self *OxmIdSctpDstMasked) GetOXMName() string {
32855 return "sctp_dst_masked"
32856}
32857
32858func (self *OxmIdSctpDstMasked) MarshalJSON() ([]byte, error) {
32859 if self.TypeLen == 0 {
32860 return []byte("\"\""), nil
32861 } else {
32862 return []byte("\"" + self.GetOXMName() + "\""), nil
32863 }
32864}
32865
32866type OxmIdSctpSrc struct {
32867 *OxmId
32868}
32869
32870type IOxmIdSctpSrc interface {
32871 IOxmId
32872}
32873
32874func (self *OxmIdSctpSrc) Serialize(encoder *goloxi.Encoder) error {
32875 if err := self.OxmId.Serialize(encoder); err != nil {
32876 return err
32877 }
32878
32879 return nil
32880}
32881
32882func DecodeOxmIdSctpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpSrc, error) {
32883 _oxmidsctpsrc := &OxmIdSctpSrc{OxmId: parent}
32884 return _oxmidsctpsrc, nil
32885}
32886
32887func NewOxmIdSctpSrc() *OxmIdSctpSrc {
32888 obj := &OxmIdSctpSrc{
32889 OxmId: NewOxmId(2147492354),
32890 }
32891 return obj
32892}
32893func (self *OxmIdSctpSrc) GetOXMName() string {
32894 return "sctp_src"
32895}
32896
32897func (self *OxmIdSctpSrc) MarshalJSON() ([]byte, error) {
32898 if self.TypeLen == 0 {
32899 return []byte("\"\""), nil
32900 } else {
32901 return []byte("\"" + self.GetOXMName() + "\""), nil
32902 }
32903}
32904
32905type OxmIdSctpSrcMasked struct {
32906 *OxmId
32907}
32908
32909type IOxmIdSctpSrcMasked interface {
32910 IOxmId
32911}
32912
32913func (self *OxmIdSctpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
32914 if err := self.OxmId.Serialize(encoder); err != nil {
32915 return err
32916 }
32917
32918 return nil
32919}
32920
32921func DecodeOxmIdSctpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpSrcMasked, error) {
32922 _oxmidsctpsrcmasked := &OxmIdSctpSrcMasked{OxmId: parent}
32923 return _oxmidsctpsrcmasked, nil
32924}
32925
32926func NewOxmIdSctpSrcMasked() *OxmIdSctpSrcMasked {
32927 obj := &OxmIdSctpSrcMasked{
32928 OxmId: NewOxmId(2147492612),
32929 }
32930 return obj
32931}
32932func (self *OxmIdSctpSrcMasked) GetOXMName() string {
32933 return "sctp_src_masked"
32934}
32935
32936func (self *OxmIdSctpSrcMasked) MarshalJSON() ([]byte, error) {
32937 if self.TypeLen == 0 {
32938 return []byte("\"\""), nil
32939 } else {
32940 return []byte("\"" + self.GetOXMName() + "\""), nil
32941 }
32942}
32943
32944type OxmIdTunnelId struct {
32945 *OxmId
32946}
32947
32948type IOxmIdTunnelId interface {
32949 IOxmId
32950}
32951
32952func (self *OxmIdTunnelId) Serialize(encoder *goloxi.Encoder) error {
32953 if err := self.OxmId.Serialize(encoder); err != nil {
32954 return err
32955 }
32956
32957 return nil
32958}
32959
32960func DecodeOxmIdTunnelId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelId, error) {
32961 _oxmidtunnelid := &OxmIdTunnelId{OxmId: parent}
32962 return _oxmidtunnelid, nil
32963}
32964
32965func NewOxmIdTunnelId() *OxmIdTunnelId {
32966 obj := &OxmIdTunnelId{
32967 OxmId: NewOxmId(2147503112),
32968 }
32969 return obj
32970}
32971func (self *OxmIdTunnelId) GetOXMName() string {
32972 return "tunnel_id"
32973}
32974
32975func (self *OxmIdTunnelId) MarshalJSON() ([]byte, error) {
32976 if self.TypeLen == 0 {
32977 return []byte("\"\""), nil
32978 } else {
32979 return []byte("\"" + self.GetOXMName() + "\""), nil
32980 }
32981}
32982
32983type OxmIdTunnelIdMasked struct {
32984 *OxmId
32985}
32986
32987type IOxmIdTunnelIdMasked interface {
32988 IOxmId
32989}
32990
32991func (self *OxmIdTunnelIdMasked) Serialize(encoder *goloxi.Encoder) error {
32992 if err := self.OxmId.Serialize(encoder); err != nil {
32993 return err
32994 }
32995
32996 return nil
32997}
32998
32999func DecodeOxmIdTunnelIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelIdMasked, error) {
33000 _oxmidtunnelidmasked := &OxmIdTunnelIdMasked{OxmId: parent}
33001 return _oxmidtunnelidmasked, nil
33002}
33003
33004func NewOxmIdTunnelIdMasked() *OxmIdTunnelIdMasked {
33005 obj := &OxmIdTunnelIdMasked{
33006 OxmId: NewOxmId(2147503376),
33007 }
33008 return obj
33009}
33010func (self *OxmIdTunnelIdMasked) GetOXMName() string {
33011 return "tunnel_id_masked"
33012}
33013
33014func (self *OxmIdTunnelIdMasked) MarshalJSON() ([]byte, error) {
33015 if self.TypeLen == 0 {
33016 return []byte("\"\""), nil
33017 } else {
33018 return []byte("\"" + self.GetOXMName() + "\""), nil
33019 }
33020}
33021
33022type OxmIdTunnelIpv4Dst struct {
33023 *OxmId
33024}
33025
33026type IOxmIdTunnelIpv4Dst interface {
33027 IOxmId
33028}
33029
33030func (self *OxmIdTunnelIpv4Dst) Serialize(encoder *goloxi.Encoder) error {
33031 if err := self.OxmId.Serialize(encoder); err != nil {
33032 return err
33033 }
33034
33035 return nil
33036}
33037
33038func DecodeOxmIdTunnelIpv4Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelIpv4Dst, error) {
33039 _oxmidtunnelipv4dst := &OxmIdTunnelIpv4Dst{OxmId: parent}
33040 return _oxmidtunnelipv4dst, nil
33041}
33042
33043func NewOxmIdTunnelIpv4Dst() *OxmIdTunnelIpv4Dst {
33044 obj := &OxmIdTunnelIpv4Dst{
33045 OxmId: NewOxmId(81924),
33046 }
33047 return obj
33048}
33049func (self *OxmIdTunnelIpv4Dst) GetOXMName() string {
33050 return "tunnel_ipv4_dst"
33051}
33052
33053func (self *OxmIdTunnelIpv4Dst) MarshalJSON() ([]byte, error) {
33054 if self.TypeLen == 0 {
33055 return []byte("\"\""), nil
33056 } else {
33057 return []byte("\"" + self.GetOXMName() + "\""), nil
33058 }
33059}
33060
33061type OxmIdTunnelIpv4DstMasked struct {
33062 *OxmId
33063}
33064
33065type IOxmIdTunnelIpv4DstMasked interface {
33066 IOxmId
33067}
33068
33069func (self *OxmIdTunnelIpv4DstMasked) Serialize(encoder *goloxi.Encoder) error {
33070 if err := self.OxmId.Serialize(encoder); err != nil {
33071 return err
33072 }
33073
33074 return nil
33075}
33076
33077func DecodeOxmIdTunnelIpv4DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelIpv4DstMasked, error) {
33078 _oxmidtunnelipv4dstmasked := &OxmIdTunnelIpv4DstMasked{OxmId: parent}
33079 return _oxmidtunnelipv4dstmasked, nil
33080}
33081
33082func NewOxmIdTunnelIpv4DstMasked() *OxmIdTunnelIpv4DstMasked {
33083 obj := &OxmIdTunnelIpv4DstMasked{
33084 OxmId: NewOxmId(82184),
33085 }
33086 return obj
33087}
33088func (self *OxmIdTunnelIpv4DstMasked) GetOXMName() string {
33089 return "tunnel_ipv4_dst_masked"
33090}
33091
33092func (self *OxmIdTunnelIpv4DstMasked) MarshalJSON() ([]byte, error) {
33093 if self.TypeLen == 0 {
33094 return []byte("\"\""), nil
33095 } else {
33096 return []byte("\"" + self.GetOXMName() + "\""), nil
33097 }
33098}
33099
33100type OxmIdTunnelIpv4Src struct {
33101 *OxmId
33102}
33103
33104type IOxmIdTunnelIpv4Src interface {
33105 IOxmId
33106}
33107
33108func (self *OxmIdTunnelIpv4Src) Serialize(encoder *goloxi.Encoder) error {
33109 if err := self.OxmId.Serialize(encoder); err != nil {
33110 return err
33111 }
33112
33113 return nil
33114}
33115
33116func DecodeOxmIdTunnelIpv4Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelIpv4Src, error) {
33117 _oxmidtunnelipv4src := &OxmIdTunnelIpv4Src{OxmId: parent}
33118 return _oxmidtunnelipv4src, nil
33119}
33120
33121func NewOxmIdTunnelIpv4Src() *OxmIdTunnelIpv4Src {
33122 obj := &OxmIdTunnelIpv4Src{
33123 OxmId: NewOxmId(81412),
33124 }
33125 return obj
33126}
33127func (self *OxmIdTunnelIpv4Src) GetOXMName() string {
33128 return "tunnel_ipv4_src"
33129}
33130
33131func (self *OxmIdTunnelIpv4Src) MarshalJSON() ([]byte, error) {
33132 if self.TypeLen == 0 {
33133 return []byte("\"\""), nil
33134 } else {
33135 return []byte("\"" + self.GetOXMName() + "\""), nil
33136 }
33137}
33138
33139type OxmIdTunnelIpv4SrcMasked struct {
33140 *OxmId
33141}
33142
33143type IOxmIdTunnelIpv4SrcMasked interface {
33144 IOxmId
33145}
33146
33147func (self *OxmIdTunnelIpv4SrcMasked) Serialize(encoder *goloxi.Encoder) error {
33148 if err := self.OxmId.Serialize(encoder); err != nil {
33149 return err
33150 }
33151
33152 return nil
33153}
33154
33155func DecodeOxmIdTunnelIpv4SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelIpv4SrcMasked, error) {
33156 _oxmidtunnelipv4srcmasked := &OxmIdTunnelIpv4SrcMasked{OxmId: parent}
33157 return _oxmidtunnelipv4srcmasked, nil
33158}
33159
33160func NewOxmIdTunnelIpv4SrcMasked() *OxmIdTunnelIpv4SrcMasked {
33161 obj := &OxmIdTunnelIpv4SrcMasked{
33162 OxmId: NewOxmId(81672),
33163 }
33164 return obj
33165}
33166func (self *OxmIdTunnelIpv4SrcMasked) GetOXMName() string {
33167 return "tunnel_ipv4_src_masked"
33168}
33169
33170func (self *OxmIdTunnelIpv4SrcMasked) MarshalJSON() ([]byte, error) {
33171 if self.TypeLen == 0 {
33172 return []byte("\"\""), nil
33173 } else {
33174 return []byte("\"" + self.GetOXMName() + "\""), nil
33175 }
33176}
33177
33178type OxmIdVlanPcp struct {
33179 *OxmId
33180}
33181
33182type IOxmIdVlanPcp interface {
33183 IOxmId
33184}
33185
33186func (self *OxmIdVlanPcp) Serialize(encoder *goloxi.Encoder) error {
33187 if err := self.OxmId.Serialize(encoder); err != nil {
33188 return err
33189 }
33190
33191 return nil
33192}
33193
33194func DecodeOxmIdVlanPcp(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanPcp, error) {
33195 _oxmidvlanpcp := &OxmIdVlanPcp{OxmId: parent}
33196 return _oxmidvlanpcp, nil
33197}
33198
33199func NewOxmIdVlanPcp() *OxmIdVlanPcp {
33200 obj := &OxmIdVlanPcp{
33201 OxmId: NewOxmId(2147487233),
33202 }
33203 return obj
33204}
33205func (self *OxmIdVlanPcp) GetOXMName() string {
33206 return "vlan_pcp"
33207}
33208
33209func (self *OxmIdVlanPcp) MarshalJSON() ([]byte, error) {
33210 if self.TypeLen == 0 {
33211 return []byte("\"\""), nil
33212 } else {
33213 return []byte("\"" + self.GetOXMName() + "\""), nil
33214 }
33215}
33216
33217type OxmIdVlanPcpMasked struct {
33218 *OxmId
33219}
33220
33221type IOxmIdVlanPcpMasked interface {
33222 IOxmId
33223}
33224
33225func (self *OxmIdVlanPcpMasked) Serialize(encoder *goloxi.Encoder) error {
33226 if err := self.OxmId.Serialize(encoder); err != nil {
33227 return err
33228 }
33229
33230 return nil
33231}
33232
33233func DecodeOxmIdVlanPcpMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanPcpMasked, error) {
33234 _oxmidvlanpcpmasked := &OxmIdVlanPcpMasked{OxmId: parent}
33235 return _oxmidvlanpcpmasked, nil
33236}
33237
33238func NewOxmIdVlanPcpMasked() *OxmIdVlanPcpMasked {
33239 obj := &OxmIdVlanPcpMasked{
33240 OxmId: NewOxmId(2147487490),
33241 }
33242 return obj
33243}
33244func (self *OxmIdVlanPcpMasked) GetOXMName() string {
33245 return "vlan_pcp_masked"
33246}
33247
33248func (self *OxmIdVlanPcpMasked) MarshalJSON() ([]byte, error) {
33249 if self.TypeLen == 0 {
33250 return []byte("\"\""), nil
33251 } else {
33252 return []byte("\"" + self.GetOXMName() + "\""), nil
33253 }
33254}
33255
33256type OxmIdVlanVid struct {
33257 *OxmId
33258}
33259
33260type IOxmIdVlanVid interface {
33261 IOxmId
33262}
33263
33264func (self *OxmIdVlanVid) Serialize(encoder *goloxi.Encoder) error {
33265 if err := self.OxmId.Serialize(encoder); err != nil {
33266 return err
33267 }
33268
33269 return nil
33270}
33271
33272func DecodeOxmIdVlanVid(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanVid, error) {
33273 _oxmidvlanvid := &OxmIdVlanVid{OxmId: parent}
33274 return _oxmidvlanvid, nil
33275}
33276
33277func NewOxmIdVlanVid() *OxmIdVlanVid {
33278 obj := &OxmIdVlanVid{
33279 OxmId: NewOxmId(2147486722),
33280 }
33281 return obj
33282}
33283func (self *OxmIdVlanVid) GetOXMName() string {
33284 return "vlan_vid"
33285}
33286
33287func (self *OxmIdVlanVid) MarshalJSON() ([]byte, error) {
33288 if self.TypeLen == 0 {
33289 return []byte("\"\""), nil
33290 } else {
33291 return []byte("\"" + self.GetOXMName() + "\""), nil
33292 }
33293}
33294
33295type OxmIdVlanVidMasked struct {
33296 *OxmId
33297}
33298
33299type IOxmIdVlanVidMasked interface {
33300 IOxmId
33301}
33302
33303func (self *OxmIdVlanVidMasked) Serialize(encoder *goloxi.Encoder) error {
33304 if err := self.OxmId.Serialize(encoder); err != nil {
33305 return err
33306 }
33307
33308 return nil
33309}
33310
33311func DecodeOxmIdVlanVidMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanVidMasked, error) {
33312 _oxmidvlanvidmasked := &OxmIdVlanVidMasked{OxmId: parent}
33313 return _oxmidvlanvidmasked, nil
33314}
33315
33316func NewOxmIdVlanVidMasked() *OxmIdVlanVidMasked {
33317 obj := &OxmIdVlanVidMasked{
33318 OxmId: NewOxmId(2147486980),
33319 }
33320 return obj
33321}
33322func (self *OxmIdVlanVidMasked) GetOXMName() string {
33323 return "vlan_vid_masked"
33324}
33325
33326func (self *OxmIdVlanVidMasked) MarshalJSON() ([]byte, error) {
33327 if self.TypeLen == 0 {
33328 return []byte("\"\""), nil
33329 } else {
33330 return []byte("\"" + self.GetOXMName() + "\""), nil
33331 }
33332}
33333
33334type PacketQueue struct {
33335 QueueId uint32
33336 Port Port
33337 Len uint16
33338 Properties []IQueueProp
33339}
33340
33341type IPacketQueue interface {
33342 goloxi.Serializable
33343 GetQueueId() uint32
33344 GetPort() Port
33345 GetLen() uint16
33346 GetProperties() []IQueueProp
33347}
33348
33349func (self *PacketQueue) GetQueueId() uint32 {
33350 return self.QueueId
33351}
33352
33353func (self *PacketQueue) SetQueueId(v uint32) {
33354 self.QueueId = v
33355}
33356
33357func (self *PacketQueue) GetPort() Port {
33358 return self.Port
33359}
33360
33361func (self *PacketQueue) SetPort(v Port) {
33362 self.Port = v
33363}
33364
33365func (self *PacketQueue) GetLen() uint16 {
33366 return self.Len
33367}
33368
33369func (self *PacketQueue) SetLen(v uint16) {
33370 self.Len = v
33371}
33372
33373func (self *PacketQueue) GetProperties() []IQueueProp {
33374 return self.Properties
33375}
33376
33377func (self *PacketQueue) SetProperties(v []IQueueProp) {
33378 self.Properties = v
33379}
33380
33381func (self *PacketQueue) Serialize(encoder *goloxi.Encoder) error {
33382 startIndex := len(encoder.Bytes())
33383
33384 encoder.PutUint32(uint32(self.QueueId))
33385 self.Port.Serialize(encoder)
33386 encoder.PutUint16(uint16(self.Len))
33387 encoder.Write(bytes.Repeat([]byte{0}, 6))
33388 for _, obj := range self.Properties {
33389 if err := obj.Serialize(encoder); err != nil {
33390 return err
33391 }
33392 }
33393 length := len(encoder.Bytes()) - startIndex
33394
33395 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+8:startIndex+10], uint16(length))
33396
33397 return nil
33398}
33399
33400func DecodePacketQueue(decoder *goloxi.Decoder) (*PacketQueue, error) {
33401 _packetqueue := &PacketQueue{}
33402 if decoder.Length() < 16 {
33403 return nil, fmt.Errorf("PacketQueue packet too short: %d < 16", decoder.Length())
33404 }
33405 _packetqueue.QueueId = uint32(decoder.ReadUint32())
33406 _packetqueue.Port.Decode(decoder)
33407 _packetqueue.Len = uint16(decoder.ReadUint16())
33408 oldDecoder := decoder
33409 defer func() { decoder = oldDecoder }()
33410 decoder = decoder.SliceDecoder(int(_packetqueue.Len), 2+8)
33411 decoder.Skip(6)
33412
33413 for decoder.Length() >= 8 {
33414 item, err := DecodeQueueProp(decoder)
33415 if err != nil {
33416 return nil, err
33417 }
33418 if item != nil {
33419 _packetqueue.Properties = append(_packetqueue.Properties, item)
33420 }
33421 }
33422 return _packetqueue, nil
33423}
33424
33425func NewPacketQueue() *PacketQueue {
33426 obj := &PacketQueue{}
33427 return obj
33428}
33429
33430type PortDesc struct {
33431 PortNo Port
33432 Length uint16
33433 HwAddr net.HardwareAddr
33434 Name string
33435 Config PortConfig
33436 State PortState
33437 Properties []IPortDescProp
33438}
33439
33440type IPortDesc interface {
33441 goloxi.Serializable
33442 GetPortNo() Port
33443 GetLength() uint16
33444 GetHwAddr() net.HardwareAddr
33445 GetName() string
33446 GetConfig() PortConfig
33447 GetState() PortState
33448 GetProperties() []IPortDescProp
33449}
33450
33451func (self *PortDesc) GetPortNo() Port {
33452 return self.PortNo
33453}
33454
33455func (self *PortDesc) SetPortNo(v Port) {
33456 self.PortNo = v
33457}
33458
33459func (self *PortDesc) GetLength() uint16 {
33460 return self.Length
33461}
33462
33463func (self *PortDesc) SetLength(v uint16) {
33464 self.Length = v
33465}
33466
33467func (self *PortDesc) GetHwAddr() net.HardwareAddr {
33468 return self.HwAddr
33469}
33470
33471func (self *PortDesc) SetHwAddr(v net.HardwareAddr) {
33472 self.HwAddr = v
33473}
33474
33475func (self *PortDesc) GetName() string {
33476 return self.Name
33477}
33478
33479func (self *PortDesc) SetName(v string) {
33480 self.Name = v
33481}
33482
33483func (self *PortDesc) GetConfig() PortConfig {
33484 return self.Config
33485}
33486
33487func (self *PortDesc) SetConfig(v PortConfig) {
33488 self.Config = v
33489}
33490
33491func (self *PortDesc) GetState() PortState {
33492 return self.State
33493}
33494
33495func (self *PortDesc) SetState(v PortState) {
33496 self.State = v
33497}
33498
33499func (self *PortDesc) GetProperties() []IPortDescProp {
33500 return self.Properties
33501}
33502
33503func (self *PortDesc) SetProperties(v []IPortDescProp) {
33504 self.Properties = v
33505}
33506
33507func (self *PortDesc) Serialize(encoder *goloxi.Encoder) error {
33508 startIndex := len(encoder.Bytes())
33509
33510 self.PortNo.Serialize(encoder)
33511 encoder.PutUint16(uint16(self.Length))
33512 encoder.Write(bytes.Repeat([]byte{0}, 2))
33513 encoder.Write(self.HwAddr)
33514 encoder.Write(bytes.Repeat([]byte{0}, 2))
33515 encoder.Write([]byte(self.Name))
33516 encoder.PutUint32(uint32(self.Config))
33517 encoder.PutUint32(uint32(self.State))
33518 for _, obj := range self.Properties {
33519 if err := obj.Serialize(encoder); err != nil {
33520 return err
33521 }
33522 }
33523 length := len(encoder.Bytes()) - startIndex
33524
33525 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+4:startIndex+6], uint16(length))
33526
33527 return nil
33528}
33529func (self *PortDesc) Decode(decoder *goloxi.Decoder) error {
33530 if decoder.Length() < 40 {
33531 return fmt.Errorf("PortDesc packet too short: %d < 40", decoder.Length())
33532 }
33533
33534 self.PortNo.Decode(decoder)
33535 self.Length = uint16(decoder.ReadUint16())
33536 oldDecoder := decoder
33537 defer func() { decoder = oldDecoder }()
33538 decoder = decoder.SliceDecoder(int(self.Length), 2+4)
33539 decoder.Skip(2)
33540 self.HwAddr = net.HardwareAddr(decoder.Read(6))
33541 decoder.Skip(2)
33542 self.Name = string(bytes.Trim(decoder.Read(16), "\x00"))
33543 self.Config = PortConfig(decoder.ReadUint32())
33544 self.State = PortState(decoder.ReadUint32())
33545
33546 for decoder.Length() >= 4 {
33547 item, err := DecodePortDescProp(decoder)
33548 if err != nil {
33549 return err
33550 }
33551 if item != nil {
33552 self.Properties = append(self.Properties, item)
33553 }
33554 }
33555
33556 return nil
33557}
33558
33559func NewPortDesc() *PortDesc {
33560 obj := &PortDesc{}
33561 return obj
33562}
33563
33564type PortDescProp struct {
33565 Type uint16
33566 Length uint16
33567}
33568
33569type IPortDescProp interface {
33570 goloxi.Serializable
33571 GetType() uint16
33572 GetLength() uint16
33573}
33574
33575func (self *PortDescProp) GetType() uint16 {
33576 return self.Type
33577}
33578
33579func (self *PortDescProp) SetType(v uint16) {
33580 self.Type = v
33581}
33582
33583func (self *PortDescProp) GetLength() uint16 {
33584 return self.Length
33585}
33586
33587func (self *PortDescProp) SetLength(v uint16) {
33588 self.Length = v
33589}
33590
33591func (self *PortDescProp) Serialize(encoder *goloxi.Encoder) error {
33592
33593 encoder.PutUint16(uint16(self.Type))
33594 encoder.PutUint16(uint16(self.Length))
33595
33596 return nil
33597}
33598
33599func DecodePortDescProp(decoder *goloxi.Decoder) (IPortDescProp, error) {
33600 _portdescprop := &PortDescProp{}
33601 if decoder.Length() < 4 {
33602 return nil, fmt.Errorf("PortDescProp packet too short: %d < 4", decoder.Length())
33603 }
33604 _portdescprop.Type = uint16(decoder.ReadUint16())
33605 _portdescprop.Length = uint16(decoder.ReadUint16())
33606 oldDecoder := decoder
33607 defer func() { decoder = oldDecoder }()
33608 decoder = decoder.SliceDecoder(int(_portdescprop.Length), 2+2)
33609
33610 switch _portdescprop.Type {
33611 case 0:
33612 return DecodePortDescPropEthernet(_portdescprop, decoder)
33613 case 1:
33614 return DecodePortDescPropOptical(_portdescprop, decoder)
33615 case 65535:
33616 return DecodePortDescPropExperimenter(_portdescprop, decoder)
33617 default:
33618 return nil, fmt.Errorf("Invalid type '%d' for 'PortDescProp'", _portdescprop.Type)
33619 }
33620}
33621
33622func NewPortDescProp(_type uint16) *PortDescProp {
33623 obj := &PortDescProp{}
33624 obj.Type = _type
33625 return obj
33626}
33627
33628type PortDescPropExperimenter struct {
33629 *PortDescProp
33630 Experimenter uint32
33631 ExpType uint32
33632}
33633
33634type IPortDescPropExperimenter interface {
33635 IPortDescProp
33636 GetExperimenter() uint32
33637 GetExpType() uint32
33638}
33639
33640func (self *PortDescPropExperimenter) GetExperimenter() uint32 {
33641 return self.Experimenter
33642}
33643
33644func (self *PortDescPropExperimenter) SetExperimenter(v uint32) {
33645 self.Experimenter = v
33646}
33647
33648func (self *PortDescPropExperimenter) GetExpType() uint32 {
33649 return self.ExpType
33650}
33651
33652func (self *PortDescPropExperimenter) SetExpType(v uint32) {
33653 self.ExpType = v
33654}
33655
33656func (self *PortDescPropExperimenter) Serialize(encoder *goloxi.Encoder) error {
33657 if err := self.PortDescProp.Serialize(encoder); err != nil {
33658 return err
33659 }
33660
33661 encoder.PutUint32(uint32(self.Experimenter))
33662 encoder.PutUint32(uint32(self.ExpType))
33663
33664 return nil
33665}
33666
33667func DecodePortDescPropExperimenter(parent *PortDescProp, decoder *goloxi.Decoder) (IPortDescPropExperimenter, error) {
33668 _portdescpropexperimenter := &PortDescPropExperimenter{PortDescProp: parent}
33669 if decoder.Length() < 8 {
33670 return nil, fmt.Errorf("PortDescPropExperimenter packet too short: %d < 8", decoder.Length())
33671 }
33672 _portdescpropexperimenter.Experimenter = uint32(decoder.ReadUint32())
33673 _portdescpropexperimenter.ExpType = uint32(decoder.ReadUint32())
33674
33675 switch _portdescpropexperimenter.Experimenter {
33676 case 6035143:
33677 return DecodePortDescPropBsn(_portdescpropexperimenter, decoder)
33678 default:
33679 return nil, fmt.Errorf("Invalid type '%d' for 'PortDescPropExperimenter'", _portdescpropexperimenter.Experimenter)
33680 }
33681}
33682
33683func NewPortDescPropExperimenter(_experimenter uint32) *PortDescPropExperimenter {
33684 obj := &PortDescPropExperimenter{
33685 PortDescProp: NewPortDescProp(65535),
33686 }
33687 obj.Experimenter = _experimenter
33688 return obj
33689}
33690
33691type PortDescPropBsn struct {
33692 *PortDescPropExperimenter
33693}
33694
33695type IPortDescPropBsn interface {
33696 IPortDescPropExperimenter
33697}
33698
33699func (self *PortDescPropBsn) Serialize(encoder *goloxi.Encoder) error {
33700 if err := self.PortDescPropExperimenter.Serialize(encoder); err != nil {
33701 return err
33702 }
33703
33704 return nil
33705}
33706
33707func DecodePortDescPropBsn(parent *PortDescPropExperimenter, decoder *goloxi.Decoder) (IPortDescPropBsn, error) {
33708 _portdescpropbsn := &PortDescPropBsn{PortDescPropExperimenter: parent}
33709
33710 switch _portdescpropbsn.ExpType {
33711 case 0:
33712 return DecodePortDescPropBsnUplink(_portdescpropbsn, decoder)
33713 case 1:
33714 return DecodePortDescPropBsnGenerationId(_portdescpropbsn, decoder)
33715 case 2:
33716 return DecodePortDescPropBsnForwardErrorCorrection(_portdescpropbsn, decoder)
33717 case 3:
33718 return DecodePortDescPropBsnBreakout(_portdescpropbsn, decoder)
33719 case 4:
33720 return DecodePortDescPropBsnSpeedCapabilities(_portdescpropbsn, decoder)
33721 case 5:
33722 return DecodePortDescPropBsnMiscCapabilities(_portdescpropbsn, decoder)
33723 case 6:
33724 return DecodePortDescPropBsnSffJson(_portdescpropbsn, decoder)
33725 case 7:
33726 return DecodePortDescPropBsnDriverInfoJson(_portdescpropbsn, decoder)
33727 case 8:
33728 return DecodePortDescPropBsnExtendedCapabilities(_portdescpropbsn, decoder)
33729 default:
33730 return nil, fmt.Errorf("Invalid type '%d' for 'PortDescPropBsn'", _portdescpropbsn.ExpType)
33731 }
33732}
33733
33734func NewPortDescPropBsn(_exp_type uint32) *PortDescPropBsn {
33735 obj := &PortDescPropBsn{
33736 PortDescPropExperimenter: NewPortDescPropExperimenter(6035143),
33737 }
33738 obj.ExpType = _exp_type
33739 return obj
33740}
33741
33742type PortDescPropBsnBreakout struct {
33743 *PortDescPropBsn
33744 SubInterfaceCount uint16
33745 SubInterfaceSpeedGbps uint16
33746}
33747
33748type IPortDescPropBsnBreakout interface {
33749 IPortDescPropBsn
33750 GetSubInterfaceCount() uint16
33751 GetSubInterfaceSpeedGbps() uint16
33752}
33753
33754func (self *PortDescPropBsnBreakout) GetSubInterfaceCount() uint16 {
33755 return self.SubInterfaceCount
33756}
33757
33758func (self *PortDescPropBsnBreakout) SetSubInterfaceCount(v uint16) {
33759 self.SubInterfaceCount = v
33760}
33761
33762func (self *PortDescPropBsnBreakout) GetSubInterfaceSpeedGbps() uint16 {
33763 return self.SubInterfaceSpeedGbps
33764}
33765
33766func (self *PortDescPropBsnBreakout) SetSubInterfaceSpeedGbps(v uint16) {
33767 self.SubInterfaceSpeedGbps = v
33768}
33769
33770func (self *PortDescPropBsnBreakout) Serialize(encoder *goloxi.Encoder) error {
33771 startIndex := len(encoder.Bytes())
33772 if err := self.PortDescPropBsn.Serialize(encoder); err != nil {
33773 return err
33774 }
33775
33776 encoder.PutUint16(uint16(self.SubInterfaceCount))
33777 encoder.PutUint16(uint16(self.SubInterfaceSpeedGbps))
33778 length := len(encoder.Bytes()) - startIndex
33779
33780 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
33781
33782 return nil
33783}
33784
33785func DecodePortDescPropBsnBreakout(parent *PortDescPropBsn, decoder *goloxi.Decoder) (*PortDescPropBsnBreakout, error) {
33786 _portdescpropbsnbreakout := &PortDescPropBsnBreakout{PortDescPropBsn: parent}
33787 if decoder.Length() < 4 {
33788 return nil, fmt.Errorf("PortDescPropBsnBreakout packet too short: %d < 4", decoder.Length())
33789 }
33790 _portdescpropbsnbreakout.SubInterfaceCount = uint16(decoder.ReadUint16())
33791 _portdescpropbsnbreakout.SubInterfaceSpeedGbps = uint16(decoder.ReadUint16())
33792 return _portdescpropbsnbreakout, nil
33793}
33794
33795func NewPortDescPropBsnBreakout() *PortDescPropBsnBreakout {
33796 obj := &PortDescPropBsnBreakout{
33797 PortDescPropBsn: NewPortDescPropBsn(3),
33798 }
33799 return obj
33800}
33801
33802type PortDescPropBsnDriverInfoJson struct {
33803 *PortDescPropBsn
33804 DriverInfoJson []byte
33805}
33806
33807type IPortDescPropBsnDriverInfoJson interface {
33808 IPortDescPropBsn
33809 GetDriverInfoJson() []byte
33810}
33811
33812func (self *PortDescPropBsnDriverInfoJson) GetDriverInfoJson() []byte {
33813 return self.DriverInfoJson
33814}
33815
33816func (self *PortDescPropBsnDriverInfoJson) SetDriverInfoJson(v []byte) {
33817 self.DriverInfoJson = v
33818}
33819
33820func (self *PortDescPropBsnDriverInfoJson) Serialize(encoder *goloxi.Encoder) error {
33821 startIndex := len(encoder.Bytes())
33822 if err := self.PortDescPropBsn.Serialize(encoder); err != nil {
33823 return err
33824 }
33825
33826 encoder.Write(self.DriverInfoJson)
33827 length := len(encoder.Bytes()) - startIndex
33828
33829 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
33830
33831 return nil
33832}
33833
33834func DecodePortDescPropBsnDriverInfoJson(parent *PortDescPropBsn, decoder *goloxi.Decoder) (*PortDescPropBsnDriverInfoJson, error) {
33835 _portdescpropbsndriverinfojson := &PortDescPropBsnDriverInfoJson{PortDescPropBsn: parent}
33836 _portdescpropbsndriverinfojson.DriverInfoJson = decoder.Read(int(decoder.Length()))
33837 return _portdescpropbsndriverinfojson, nil
33838}
33839
33840func NewPortDescPropBsnDriverInfoJson() *PortDescPropBsnDriverInfoJson {
33841 obj := &PortDescPropBsnDriverInfoJson{
33842 PortDescPropBsn: NewPortDescPropBsn(7),
33843 }
33844 return obj
33845}
33846
33847type PortDescPropBsnExtendedCapabilities struct {
33848 *PortDescPropBsn
33849 Configurability uint64
33850 Conflict uint64
33851 Reserved1 uint64
33852 Reserved2 uint64
33853}
33854
33855type IPortDescPropBsnExtendedCapabilities interface {
33856 IPortDescPropBsn
33857 GetConfigurability() uint64
33858 GetConflict() uint64
33859 GetReserved1() uint64
33860 GetReserved2() uint64
33861}
33862
33863func (self *PortDescPropBsnExtendedCapabilities) GetConfigurability() uint64 {
33864 return self.Configurability
33865}
33866
33867func (self *PortDescPropBsnExtendedCapabilities) SetConfigurability(v uint64) {
33868 self.Configurability = v
33869}
33870
33871func (self *PortDescPropBsnExtendedCapabilities) GetConflict() uint64 {
33872 return self.Conflict
33873}
33874
33875func (self *PortDescPropBsnExtendedCapabilities) SetConflict(v uint64) {
33876 self.Conflict = v
33877}
33878
33879func (self *PortDescPropBsnExtendedCapabilities) GetReserved1() uint64 {
33880 return self.Reserved1
33881}
33882
33883func (self *PortDescPropBsnExtendedCapabilities) SetReserved1(v uint64) {
33884 self.Reserved1 = v
33885}
33886
33887func (self *PortDescPropBsnExtendedCapabilities) GetReserved2() uint64 {
33888 return self.Reserved2
33889}
33890
33891func (self *PortDescPropBsnExtendedCapabilities) SetReserved2(v uint64) {
33892 self.Reserved2 = v
33893}
33894
33895func (self *PortDescPropBsnExtendedCapabilities) Serialize(encoder *goloxi.Encoder) error {
33896 startIndex := len(encoder.Bytes())
33897 if err := self.PortDescPropBsn.Serialize(encoder); err != nil {
33898 return err
33899 }
33900
33901 encoder.PutUint64(uint64(self.Configurability))
33902 encoder.PutUint64(uint64(self.Conflict))
33903 encoder.PutUint64(uint64(self.Reserved1))
33904 encoder.PutUint64(uint64(self.Reserved2))
33905 length := len(encoder.Bytes()) - startIndex
33906
33907 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
33908
33909 return nil
33910}
33911
33912func DecodePortDescPropBsnExtendedCapabilities(parent *PortDescPropBsn, decoder *goloxi.Decoder) (*PortDescPropBsnExtendedCapabilities, error) {
33913 _portdescpropbsnextendedcapabilities := &PortDescPropBsnExtendedCapabilities{PortDescPropBsn: parent}
33914 if decoder.Length() < 32 {
33915 return nil, fmt.Errorf("PortDescPropBsnExtendedCapabilities packet too short: %d < 32", decoder.Length())
33916 }
33917 _portdescpropbsnextendedcapabilities.Configurability = uint64(decoder.ReadUint64())
33918 _portdescpropbsnextendedcapabilities.Conflict = uint64(decoder.ReadUint64())
33919 _portdescpropbsnextendedcapabilities.Reserved1 = uint64(decoder.ReadUint64())
33920 _portdescpropbsnextendedcapabilities.Reserved2 = uint64(decoder.ReadUint64())
33921 return _portdescpropbsnextendedcapabilities, nil
33922}
33923
33924func NewPortDescPropBsnExtendedCapabilities() *PortDescPropBsnExtendedCapabilities {
33925 obj := &PortDescPropBsnExtendedCapabilities{
33926 PortDescPropBsn: NewPortDescPropBsn(8),
33927 }
33928 return obj
33929}
33930
33931type PortDescPropBsnForwardErrorCorrection struct {
33932 *PortDescPropBsn
33933 Configured BsnFecConfigState
33934 Enabled uint32
33935}
33936
33937type IPortDescPropBsnForwardErrorCorrection interface {
33938 IPortDescPropBsn
33939 GetConfigured() BsnFecConfigState
33940 GetEnabled() uint32
33941}
33942
33943func (self *PortDescPropBsnForwardErrorCorrection) GetConfigured() BsnFecConfigState {
33944 return self.Configured
33945}
33946
33947func (self *PortDescPropBsnForwardErrorCorrection) SetConfigured(v BsnFecConfigState) {
33948 self.Configured = v
33949}
33950
33951func (self *PortDescPropBsnForwardErrorCorrection) GetEnabled() uint32 {
33952 return self.Enabled
33953}
33954
33955func (self *PortDescPropBsnForwardErrorCorrection) SetEnabled(v uint32) {
33956 self.Enabled = v
33957}
33958
33959func (self *PortDescPropBsnForwardErrorCorrection) Serialize(encoder *goloxi.Encoder) error {
33960 startIndex := len(encoder.Bytes())
33961 if err := self.PortDescPropBsn.Serialize(encoder); err != nil {
33962 return err
33963 }
33964
33965 encoder.PutUint32(uint32(self.Configured))
33966 encoder.PutUint32(uint32(self.Enabled))
33967 length := len(encoder.Bytes()) - startIndex
33968
33969 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
33970
33971 return nil
33972}
33973
33974func DecodePortDescPropBsnForwardErrorCorrection(parent *PortDescPropBsn, decoder *goloxi.Decoder) (*PortDescPropBsnForwardErrorCorrection, error) {
33975 _portdescpropbsnforwarderrorcorrection := &PortDescPropBsnForwardErrorCorrection{PortDescPropBsn: parent}
33976 if decoder.Length() < 8 {
33977 return nil, fmt.Errorf("PortDescPropBsnForwardErrorCorrection packet too short: %d < 8", decoder.Length())
33978 }
33979 _portdescpropbsnforwarderrorcorrection.Configured = BsnFecConfigState(decoder.ReadUint32())
33980 _portdescpropbsnforwarderrorcorrection.Enabled = uint32(decoder.ReadUint32())
33981 return _portdescpropbsnforwarderrorcorrection, nil
33982}
33983
33984func NewPortDescPropBsnForwardErrorCorrection() *PortDescPropBsnForwardErrorCorrection {
33985 obj := &PortDescPropBsnForwardErrorCorrection{
33986 PortDescPropBsn: NewPortDescPropBsn(2),
33987 }
33988 return obj
33989}
33990
33991type PortDescPropBsnGenerationId struct {
33992 *PortDescPropBsn
33993 GenerationId uint64
33994}
33995
33996type IPortDescPropBsnGenerationId interface {
33997 IPortDescPropBsn
33998 GetGenerationId() uint64
33999}
34000
34001func (self *PortDescPropBsnGenerationId) GetGenerationId() uint64 {
34002 return self.GenerationId
34003}
34004
34005func (self *PortDescPropBsnGenerationId) SetGenerationId(v uint64) {
34006 self.GenerationId = v
34007}
34008
34009func (self *PortDescPropBsnGenerationId) Serialize(encoder *goloxi.Encoder) error {
34010 startIndex := len(encoder.Bytes())
34011 if err := self.PortDescPropBsn.Serialize(encoder); err != nil {
34012 return err
34013 }
34014
34015 encoder.PutUint64(uint64(self.GenerationId))
34016 length := len(encoder.Bytes()) - startIndex
34017
34018 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
34019
34020 return nil
34021}
34022
34023func DecodePortDescPropBsnGenerationId(parent *PortDescPropBsn, decoder *goloxi.Decoder) (*PortDescPropBsnGenerationId, error) {
34024 _portdescpropbsngenerationid := &PortDescPropBsnGenerationId{PortDescPropBsn: parent}
34025 if decoder.Length() < 8 {
34026 return nil, fmt.Errorf("PortDescPropBsnGenerationId packet too short: %d < 8", decoder.Length())
34027 }
34028 _portdescpropbsngenerationid.GenerationId = uint64(decoder.ReadUint64())
34029 return _portdescpropbsngenerationid, nil
34030}
34031
34032func NewPortDescPropBsnGenerationId() *PortDescPropBsnGenerationId {
34033 obj := &PortDescPropBsnGenerationId{
34034 PortDescPropBsn: NewPortDescPropBsn(1),
34035 }
34036 return obj
34037}
34038
34039type PortDescPropBsnMiscCapabilities struct {
34040 *PortDescPropBsn
34041 Current uint64
34042 Available uint64
34043 Supported uint64
34044}
34045
34046type IPortDescPropBsnMiscCapabilities interface {
34047 IPortDescPropBsn
34048 GetCurrent() uint64
34049 GetAvailable() uint64
34050 GetSupported() uint64
34051}
34052
34053func (self *PortDescPropBsnMiscCapabilities) GetCurrent() uint64 {
34054 return self.Current
34055}
34056
34057func (self *PortDescPropBsnMiscCapabilities) SetCurrent(v uint64) {
34058 self.Current = v
34059}
34060
34061func (self *PortDescPropBsnMiscCapabilities) GetAvailable() uint64 {
34062 return self.Available
34063}
34064
34065func (self *PortDescPropBsnMiscCapabilities) SetAvailable(v uint64) {
34066 self.Available = v
34067}
34068
34069func (self *PortDescPropBsnMiscCapabilities) GetSupported() uint64 {
34070 return self.Supported
34071}
34072
34073func (self *PortDescPropBsnMiscCapabilities) SetSupported(v uint64) {
34074 self.Supported = v
34075}
34076
34077func (self *PortDescPropBsnMiscCapabilities) Serialize(encoder *goloxi.Encoder) error {
34078 startIndex := len(encoder.Bytes())
34079 if err := self.PortDescPropBsn.Serialize(encoder); err != nil {
34080 return err
34081 }
34082
34083 encoder.PutUint64(uint64(self.Current))
34084 encoder.PutUint64(uint64(self.Available))
34085 encoder.PutUint64(uint64(self.Supported))
34086 length := len(encoder.Bytes()) - startIndex
34087
34088 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
34089
34090 return nil
34091}
34092
34093func DecodePortDescPropBsnMiscCapabilities(parent *PortDescPropBsn, decoder *goloxi.Decoder) (*PortDescPropBsnMiscCapabilities, error) {
34094 _portdescpropbsnmisccapabilities := &PortDescPropBsnMiscCapabilities{PortDescPropBsn: parent}
34095 if decoder.Length() < 24 {
34096 return nil, fmt.Errorf("PortDescPropBsnMiscCapabilities packet too short: %d < 24", decoder.Length())
34097 }
34098 _portdescpropbsnmisccapabilities.Current = uint64(decoder.ReadUint64())
34099 _portdescpropbsnmisccapabilities.Available = uint64(decoder.ReadUint64())
34100 _portdescpropbsnmisccapabilities.Supported = uint64(decoder.ReadUint64())
34101 return _portdescpropbsnmisccapabilities, nil
34102}
34103
34104func NewPortDescPropBsnMiscCapabilities() *PortDescPropBsnMiscCapabilities {
34105 obj := &PortDescPropBsnMiscCapabilities{
34106 PortDescPropBsn: NewPortDescPropBsn(5),
34107 }
34108 return obj
34109}
34110
34111type PortDescPropBsnSffJson struct {
34112 *PortDescPropBsn
34113 DataJson []byte
34114}
34115
34116type IPortDescPropBsnSffJson interface {
34117 IPortDescPropBsn
34118 GetDataJson() []byte
34119}
34120
34121func (self *PortDescPropBsnSffJson) GetDataJson() []byte {
34122 return self.DataJson
34123}
34124
34125func (self *PortDescPropBsnSffJson) SetDataJson(v []byte) {
34126 self.DataJson = v
34127}
34128
34129func (self *PortDescPropBsnSffJson) Serialize(encoder *goloxi.Encoder) error {
34130 startIndex := len(encoder.Bytes())
34131 if err := self.PortDescPropBsn.Serialize(encoder); err != nil {
34132 return err
34133 }
34134
34135 encoder.Write(self.DataJson)
34136 length := len(encoder.Bytes()) - startIndex
34137
34138 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
34139
34140 return nil
34141}
34142
34143func DecodePortDescPropBsnSffJson(parent *PortDescPropBsn, decoder *goloxi.Decoder) (*PortDescPropBsnSffJson, error) {
34144 _portdescpropbsnsffjson := &PortDescPropBsnSffJson{PortDescPropBsn: parent}
34145 _portdescpropbsnsffjson.DataJson = decoder.Read(int(decoder.Length()))
34146 return _portdescpropbsnsffjson, nil
34147}
34148
34149func NewPortDescPropBsnSffJson() *PortDescPropBsnSffJson {
34150 obj := &PortDescPropBsnSffJson{
34151 PortDescPropBsn: NewPortDescPropBsn(6),
34152 }
34153 return obj
34154}
34155
34156type PortDescPropBsnSpeedCapabilities struct {
34157 *PortDescPropBsn
34158 Current uint64
34159 Available uint64
34160 Supported uint64
34161}
34162
34163type IPortDescPropBsnSpeedCapabilities interface {
34164 IPortDescPropBsn
34165 GetCurrent() uint64
34166 GetAvailable() uint64
34167 GetSupported() uint64
34168}
34169
34170func (self *PortDescPropBsnSpeedCapabilities) GetCurrent() uint64 {
34171 return self.Current
34172}
34173
34174func (self *PortDescPropBsnSpeedCapabilities) SetCurrent(v uint64) {
34175 self.Current = v
34176}
34177
34178func (self *PortDescPropBsnSpeedCapabilities) GetAvailable() uint64 {
34179 return self.Available
34180}
34181
34182func (self *PortDescPropBsnSpeedCapabilities) SetAvailable(v uint64) {
34183 self.Available = v
34184}
34185
34186func (self *PortDescPropBsnSpeedCapabilities) GetSupported() uint64 {
34187 return self.Supported
34188}
34189
34190func (self *PortDescPropBsnSpeedCapabilities) SetSupported(v uint64) {
34191 self.Supported = v
34192}
34193
34194func (self *PortDescPropBsnSpeedCapabilities) Serialize(encoder *goloxi.Encoder) error {
34195 startIndex := len(encoder.Bytes())
34196 if err := self.PortDescPropBsn.Serialize(encoder); err != nil {
34197 return err
34198 }
34199
34200 encoder.PutUint64(uint64(self.Current))
34201 encoder.PutUint64(uint64(self.Available))
34202 encoder.PutUint64(uint64(self.Supported))
34203 length := len(encoder.Bytes()) - startIndex
34204
34205 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
34206
34207 return nil
34208}
34209
34210func DecodePortDescPropBsnSpeedCapabilities(parent *PortDescPropBsn, decoder *goloxi.Decoder) (*PortDescPropBsnSpeedCapabilities, error) {
34211 _portdescpropbsnspeedcapabilities := &PortDescPropBsnSpeedCapabilities{PortDescPropBsn: parent}
34212 if decoder.Length() < 24 {
34213 return nil, fmt.Errorf("PortDescPropBsnSpeedCapabilities packet too short: %d < 24", decoder.Length())
34214 }
34215 _portdescpropbsnspeedcapabilities.Current = uint64(decoder.ReadUint64())
34216 _portdescpropbsnspeedcapabilities.Available = uint64(decoder.ReadUint64())
34217 _portdescpropbsnspeedcapabilities.Supported = uint64(decoder.ReadUint64())
34218 return _portdescpropbsnspeedcapabilities, nil
34219}
34220
34221func NewPortDescPropBsnSpeedCapabilities() *PortDescPropBsnSpeedCapabilities {
34222 obj := &PortDescPropBsnSpeedCapabilities{
34223 PortDescPropBsn: NewPortDescPropBsn(4),
34224 }
34225 return obj
34226}
34227
34228type PortDescPropBsnUplink struct {
34229 *PortDescPropBsn
34230}
34231
34232type IPortDescPropBsnUplink interface {
34233 IPortDescPropBsn
34234}
34235
34236func (self *PortDescPropBsnUplink) Serialize(encoder *goloxi.Encoder) error {
34237 startIndex := len(encoder.Bytes())
34238 if err := self.PortDescPropBsn.Serialize(encoder); err != nil {
34239 return err
34240 }
34241 length := len(encoder.Bytes()) - startIndex
34242
34243 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
34244
34245 return nil
34246}
34247
34248func DecodePortDescPropBsnUplink(parent *PortDescPropBsn, decoder *goloxi.Decoder) (*PortDescPropBsnUplink, error) {
34249 _portdescpropbsnuplink := &PortDescPropBsnUplink{PortDescPropBsn: parent}
34250 return _portdescpropbsnuplink, nil
34251}
34252
34253func NewPortDescPropBsnUplink() *PortDescPropBsnUplink {
34254 obj := &PortDescPropBsnUplink{
34255 PortDescPropBsn: NewPortDescPropBsn(0),
34256 }
34257 return obj
34258}
34259
34260type PortDescPropEthernet struct {
34261 *PortDescProp
34262 Curr uint32
34263 Advertised uint32
34264 Supported uint32
34265 Peer uint32
34266 CurrSpeed uint32
34267 MaxSpeed uint32
34268}
34269
34270type IPortDescPropEthernet interface {
34271 IPortDescProp
34272 GetCurr() uint32
34273 GetAdvertised() uint32
34274 GetSupported() uint32
34275 GetPeer() uint32
34276 GetCurrSpeed() uint32
34277 GetMaxSpeed() uint32
34278}
34279
34280func (self *PortDescPropEthernet) GetCurr() uint32 {
34281 return self.Curr
34282}
34283
34284func (self *PortDescPropEthernet) SetCurr(v uint32) {
34285 self.Curr = v
34286}
34287
34288func (self *PortDescPropEthernet) GetAdvertised() uint32 {
34289 return self.Advertised
34290}
34291
34292func (self *PortDescPropEthernet) SetAdvertised(v uint32) {
34293 self.Advertised = v
34294}
34295
34296func (self *PortDescPropEthernet) GetSupported() uint32 {
34297 return self.Supported
34298}
34299
34300func (self *PortDescPropEthernet) SetSupported(v uint32) {
34301 self.Supported = v
34302}
34303
34304func (self *PortDescPropEthernet) GetPeer() uint32 {
34305 return self.Peer
34306}
34307
34308func (self *PortDescPropEthernet) SetPeer(v uint32) {
34309 self.Peer = v
34310}
34311
34312func (self *PortDescPropEthernet) GetCurrSpeed() uint32 {
34313 return self.CurrSpeed
34314}
34315
34316func (self *PortDescPropEthernet) SetCurrSpeed(v uint32) {
34317 self.CurrSpeed = v
34318}
34319
34320func (self *PortDescPropEthernet) GetMaxSpeed() uint32 {
34321 return self.MaxSpeed
34322}
34323
34324func (self *PortDescPropEthernet) SetMaxSpeed(v uint32) {
34325 self.MaxSpeed = v
34326}
34327
34328func (self *PortDescPropEthernet) Serialize(encoder *goloxi.Encoder) error {
34329 startIndex := len(encoder.Bytes())
34330 if err := self.PortDescProp.Serialize(encoder); err != nil {
34331 return err
34332 }
34333
34334 encoder.Write(bytes.Repeat([]byte{0}, 4))
34335 encoder.PutUint32(uint32(self.Curr))
34336 encoder.PutUint32(uint32(self.Advertised))
34337 encoder.PutUint32(uint32(self.Supported))
34338 encoder.PutUint32(uint32(self.Peer))
34339 encoder.PutUint32(uint32(self.CurrSpeed))
34340 encoder.PutUint32(uint32(self.MaxSpeed))
34341 length := len(encoder.Bytes()) - startIndex
34342
34343 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
34344
34345 return nil
34346}
34347
34348func DecodePortDescPropEthernet(parent *PortDescProp, decoder *goloxi.Decoder) (*PortDescPropEthernet, error) {
34349 _portdescpropethernet := &PortDescPropEthernet{PortDescProp: parent}
34350 if decoder.Length() < 28 {
34351 return nil, fmt.Errorf("PortDescPropEthernet packet too short: %d < 28", decoder.Length())
34352 }
34353 decoder.Skip(4)
34354 _portdescpropethernet.Curr = uint32(decoder.ReadUint32())
34355 _portdescpropethernet.Advertised = uint32(decoder.ReadUint32())
34356 _portdescpropethernet.Supported = uint32(decoder.ReadUint32())
34357 _portdescpropethernet.Peer = uint32(decoder.ReadUint32())
34358 _portdescpropethernet.CurrSpeed = uint32(decoder.ReadUint32())
34359 _portdescpropethernet.MaxSpeed = uint32(decoder.ReadUint32())
34360 return _portdescpropethernet, nil
34361}
34362
34363func NewPortDescPropEthernet() *PortDescPropEthernet {
34364 obj := &PortDescPropEthernet{
34365 PortDescProp: NewPortDescProp(0),
34366 }
34367 return obj
34368}
34369
34370type PortDescPropOptical struct {
34371 *PortDescProp
34372 Supported uint32
34373 TxMinFreqLmda uint32
34374 TxMaxFreqLmda uint32
34375 TxGridFreqLmda uint32
34376 RxMinFreqLmda uint32
34377 RxMaxFreqLmda uint32
34378 RxGridFreqLmda uint32
34379 TxPwrMin uint32
34380 TxPwrMax uint32
34381}
34382
34383type IPortDescPropOptical interface {
34384 IPortDescProp
34385 GetSupported() uint32
34386 GetTxMinFreqLmda() uint32
34387 GetTxMaxFreqLmda() uint32
34388 GetTxGridFreqLmda() uint32
34389 GetRxMinFreqLmda() uint32
34390 GetRxMaxFreqLmda() uint32
34391 GetRxGridFreqLmda() uint32
34392 GetTxPwrMin() uint32
34393 GetTxPwrMax() uint32
34394}
34395
34396func (self *PortDescPropOptical) GetSupported() uint32 {
34397 return self.Supported
34398}
34399
34400func (self *PortDescPropOptical) SetSupported(v uint32) {
34401 self.Supported = v
34402}
34403
34404func (self *PortDescPropOptical) GetTxMinFreqLmda() uint32 {
34405 return self.TxMinFreqLmda
34406}
34407
34408func (self *PortDescPropOptical) SetTxMinFreqLmda(v uint32) {
34409 self.TxMinFreqLmda = v
34410}
34411
34412func (self *PortDescPropOptical) GetTxMaxFreqLmda() uint32 {
34413 return self.TxMaxFreqLmda
34414}
34415
34416func (self *PortDescPropOptical) SetTxMaxFreqLmda(v uint32) {
34417 self.TxMaxFreqLmda = v
34418}
34419
34420func (self *PortDescPropOptical) GetTxGridFreqLmda() uint32 {
34421 return self.TxGridFreqLmda
34422}
34423
34424func (self *PortDescPropOptical) SetTxGridFreqLmda(v uint32) {
34425 self.TxGridFreqLmda = v
34426}
34427
34428func (self *PortDescPropOptical) GetRxMinFreqLmda() uint32 {
34429 return self.RxMinFreqLmda
34430}
34431
34432func (self *PortDescPropOptical) SetRxMinFreqLmda(v uint32) {
34433 self.RxMinFreqLmda = v
34434}
34435
34436func (self *PortDescPropOptical) GetRxMaxFreqLmda() uint32 {
34437 return self.RxMaxFreqLmda
34438}
34439
34440func (self *PortDescPropOptical) SetRxMaxFreqLmda(v uint32) {
34441 self.RxMaxFreqLmda = v
34442}
34443
34444func (self *PortDescPropOptical) GetRxGridFreqLmda() uint32 {
34445 return self.RxGridFreqLmda
34446}
34447
34448func (self *PortDescPropOptical) SetRxGridFreqLmda(v uint32) {
34449 self.RxGridFreqLmda = v
34450}
34451
34452func (self *PortDescPropOptical) GetTxPwrMin() uint32 {
34453 return self.TxPwrMin
34454}
34455
34456func (self *PortDescPropOptical) SetTxPwrMin(v uint32) {
34457 self.TxPwrMin = v
34458}
34459
34460func (self *PortDescPropOptical) GetTxPwrMax() uint32 {
34461 return self.TxPwrMax
34462}
34463
34464func (self *PortDescPropOptical) SetTxPwrMax(v uint32) {
34465 self.TxPwrMax = v
34466}
34467
34468func (self *PortDescPropOptical) Serialize(encoder *goloxi.Encoder) error {
34469 startIndex := len(encoder.Bytes())
34470 if err := self.PortDescProp.Serialize(encoder); err != nil {
34471 return err
34472 }
34473
34474 encoder.Write(bytes.Repeat([]byte{0}, 4))
34475 encoder.PutUint32(uint32(self.Supported))
34476 encoder.PutUint32(uint32(self.TxMinFreqLmda))
34477 encoder.PutUint32(uint32(self.TxMaxFreqLmda))
34478 encoder.PutUint32(uint32(self.TxGridFreqLmda))
34479 encoder.PutUint32(uint32(self.RxMinFreqLmda))
34480 encoder.PutUint32(uint32(self.RxMaxFreqLmda))
34481 encoder.PutUint32(uint32(self.RxGridFreqLmda))
34482 encoder.PutUint32(uint32(self.TxPwrMin))
34483 encoder.PutUint32(uint32(self.TxPwrMax))
34484 length := len(encoder.Bytes()) - startIndex
34485
34486 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
34487
34488 return nil
34489}
34490
34491func DecodePortDescPropOptical(parent *PortDescProp, decoder *goloxi.Decoder) (*PortDescPropOptical, error) {
34492 _portdescpropoptical := &PortDescPropOptical{PortDescProp: parent}
34493 if decoder.Length() < 40 {
34494 return nil, fmt.Errorf("PortDescPropOptical packet too short: %d < 40", decoder.Length())
34495 }
34496 decoder.Skip(4)
34497 _portdescpropoptical.Supported = uint32(decoder.ReadUint32())
34498 _portdescpropoptical.TxMinFreqLmda = uint32(decoder.ReadUint32())
34499 _portdescpropoptical.TxMaxFreqLmda = uint32(decoder.ReadUint32())
34500 _portdescpropoptical.TxGridFreqLmda = uint32(decoder.ReadUint32())
34501 _portdescpropoptical.RxMinFreqLmda = uint32(decoder.ReadUint32())
34502 _portdescpropoptical.RxMaxFreqLmda = uint32(decoder.ReadUint32())
34503 _portdescpropoptical.RxGridFreqLmda = uint32(decoder.ReadUint32())
34504 _portdescpropoptical.TxPwrMin = uint32(decoder.ReadUint32())
34505 _portdescpropoptical.TxPwrMax = uint32(decoder.ReadUint32())
34506 return _portdescpropoptical, nil
34507}
34508
34509func NewPortDescPropOptical() *PortDescPropOptical {
34510 obj := &PortDescPropOptical{
34511 PortDescProp: NewPortDescProp(1),
34512 }
34513 return obj
34514}
34515
34516type PortModProp struct {
34517 Type uint16
34518 Length uint16
34519}
34520
34521type IPortModProp interface {
34522 goloxi.Serializable
34523 GetType() uint16
34524 GetLength() uint16
34525}
34526
34527func (self *PortModProp) GetType() uint16 {
34528 return self.Type
34529}
34530
34531func (self *PortModProp) SetType(v uint16) {
34532 self.Type = v
34533}
34534
34535func (self *PortModProp) GetLength() uint16 {
34536 return self.Length
34537}
34538
34539func (self *PortModProp) SetLength(v uint16) {
34540 self.Length = v
34541}
34542
34543func (self *PortModProp) Serialize(encoder *goloxi.Encoder) error {
34544
34545 encoder.PutUint16(uint16(self.Type))
34546 encoder.PutUint16(uint16(self.Length))
34547
34548 return nil
34549}
34550
34551func DecodePortModProp(decoder *goloxi.Decoder) (IPortModProp, error) {
34552 _portmodprop := &PortModProp{}
34553 if decoder.Length() < 4 {
34554 return nil, fmt.Errorf("PortModProp packet too short: %d < 4", decoder.Length())
34555 }
34556 _portmodprop.Type = uint16(decoder.ReadUint16())
34557 _portmodprop.Length = uint16(decoder.ReadUint16())
34558 oldDecoder := decoder
34559 defer func() { decoder = oldDecoder }()
34560 decoder = decoder.SliceDecoder(int(_portmodprop.Length), 2+2)
34561
34562 switch _portmodprop.Type {
34563 case 0:
34564 return DecodePortModPropEthernet(_portmodprop, decoder)
34565 case 1:
34566 return DecodePortModPropOptical(_portmodprop, decoder)
34567 case 65535:
34568 return DecodePortModPropExperimenter(_portmodprop, decoder)
34569 default:
34570 return nil, fmt.Errorf("Invalid type '%d' for 'PortModProp'", _portmodprop.Type)
34571 }
34572}
34573
34574func NewPortModProp(_type uint16) *PortModProp {
34575 obj := &PortModProp{}
34576 obj.Type = _type
34577 return obj
34578}
34579
34580type PortModPropEthernet struct {
34581 *PortModProp
34582 Advertise PortFeatures
34583}
34584
34585type IPortModPropEthernet interface {
34586 IPortModProp
34587 GetAdvertise() PortFeatures
34588}
34589
34590func (self *PortModPropEthernet) GetAdvertise() PortFeatures {
34591 return self.Advertise
34592}
34593
34594func (self *PortModPropEthernet) SetAdvertise(v PortFeatures) {
34595 self.Advertise = v
34596}
34597
34598func (self *PortModPropEthernet) Serialize(encoder *goloxi.Encoder) error {
34599 startIndex := len(encoder.Bytes())
34600 if err := self.PortModProp.Serialize(encoder); err != nil {
34601 return err
34602 }
34603
34604 encoder.PutUint32(uint32(self.Advertise))
34605 length := len(encoder.Bytes()) - startIndex
34606
34607 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
34608
34609 return nil
34610}
34611
34612func DecodePortModPropEthernet(parent *PortModProp, decoder *goloxi.Decoder) (*PortModPropEthernet, error) {
34613 _portmodpropethernet := &PortModPropEthernet{PortModProp: parent}
34614 if decoder.Length() < 4 {
34615 return nil, fmt.Errorf("PortModPropEthernet packet too short: %d < 4", decoder.Length())
34616 }
34617 _portmodpropethernet.Advertise = PortFeatures(decoder.ReadUint32())
34618 return _portmodpropethernet, nil
34619}
34620
34621func NewPortModPropEthernet() *PortModPropEthernet {
34622 obj := &PortModPropEthernet{
34623 PortModProp: NewPortModProp(0),
34624 }
34625 return obj
34626}
34627
34628type PortModPropExperimenter struct {
34629 *PortModProp
34630 Experimenter uint32
34631 ExpType uint32
34632}
34633
34634type IPortModPropExperimenter interface {
34635 IPortModProp
34636 GetExperimenter() uint32
34637 GetExpType() uint32
34638}
34639
34640func (self *PortModPropExperimenter) GetExperimenter() uint32 {
34641 return self.Experimenter
34642}
34643
34644func (self *PortModPropExperimenter) SetExperimenter(v uint32) {
34645 self.Experimenter = v
34646}
34647
34648func (self *PortModPropExperimenter) GetExpType() uint32 {
34649 return self.ExpType
34650}
34651
34652func (self *PortModPropExperimenter) SetExpType(v uint32) {
34653 self.ExpType = v
34654}
34655
34656func (self *PortModPropExperimenter) Serialize(encoder *goloxi.Encoder) error {
34657 if err := self.PortModProp.Serialize(encoder); err != nil {
34658 return err
34659 }
34660
34661 encoder.PutUint32(uint32(self.Experimenter))
34662 encoder.PutUint32(uint32(self.ExpType))
34663
34664 return nil
34665}
34666
34667func DecodePortModPropExperimenter(parent *PortModProp, decoder *goloxi.Decoder) (IPortModPropExperimenter, error) {
34668 _portmodpropexperimenter := &PortModPropExperimenter{PortModProp: parent}
34669 if decoder.Length() < 8 {
34670 return nil, fmt.Errorf("PortModPropExperimenter packet too short: %d < 8", decoder.Length())
34671 }
34672 _portmodpropexperimenter.Experimenter = uint32(decoder.ReadUint32())
34673 _portmodpropexperimenter.ExpType = uint32(decoder.ReadUint32())
34674 return _portmodpropexperimenter, nil
34675}
34676
34677func NewPortModPropExperimenter(_experimenter uint32) *PortModPropExperimenter {
34678 obj := &PortModPropExperimenter{
34679 PortModProp: NewPortModProp(65535),
34680 }
34681 obj.Experimenter = _experimenter
34682 return obj
34683}
34684
34685type PortModPropOptical struct {
34686 *PortModProp
34687 Configure uint32
34688 FreqLdma uint32
34689 FlOffset uint32
34690 GridSpan uint32
34691 TxPwr uint32
34692}
34693
34694type IPortModPropOptical interface {
34695 IPortModProp
34696 GetConfigure() uint32
34697 GetFreqLdma() uint32
34698 GetFlOffset() uint32
34699 GetGridSpan() uint32
34700 GetTxPwr() uint32
34701}
34702
34703func (self *PortModPropOptical) GetConfigure() uint32 {
34704 return self.Configure
34705}
34706
34707func (self *PortModPropOptical) SetConfigure(v uint32) {
34708 self.Configure = v
34709}
34710
34711func (self *PortModPropOptical) GetFreqLdma() uint32 {
34712 return self.FreqLdma
34713}
34714
34715func (self *PortModPropOptical) SetFreqLdma(v uint32) {
34716 self.FreqLdma = v
34717}
34718
34719func (self *PortModPropOptical) GetFlOffset() uint32 {
34720 return self.FlOffset
34721}
34722
34723func (self *PortModPropOptical) SetFlOffset(v uint32) {
34724 self.FlOffset = v
34725}
34726
34727func (self *PortModPropOptical) GetGridSpan() uint32 {
34728 return self.GridSpan
34729}
34730
34731func (self *PortModPropOptical) SetGridSpan(v uint32) {
34732 self.GridSpan = v
34733}
34734
34735func (self *PortModPropOptical) GetTxPwr() uint32 {
34736 return self.TxPwr
34737}
34738
34739func (self *PortModPropOptical) SetTxPwr(v uint32) {
34740 self.TxPwr = v
34741}
34742
34743func (self *PortModPropOptical) Serialize(encoder *goloxi.Encoder) error {
34744 startIndex := len(encoder.Bytes())
34745 if err := self.PortModProp.Serialize(encoder); err != nil {
34746 return err
34747 }
34748
34749 encoder.PutUint32(uint32(self.Configure))
34750 encoder.PutUint32(uint32(self.FreqLdma))
34751 encoder.PutUint32(uint32(self.FlOffset))
34752 encoder.PutUint32(uint32(self.GridSpan))
34753 encoder.PutUint32(uint32(self.TxPwr))
34754 length := len(encoder.Bytes()) - startIndex
34755
34756 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
34757
34758 return nil
34759}
34760
34761func DecodePortModPropOptical(parent *PortModProp, decoder *goloxi.Decoder) (*PortModPropOptical, error) {
34762 _portmodpropoptical := &PortModPropOptical{PortModProp: parent}
34763 if decoder.Length() < 20 {
34764 return nil, fmt.Errorf("PortModPropOptical packet too short: %d < 20", decoder.Length())
34765 }
34766 _portmodpropoptical.Configure = uint32(decoder.ReadUint32())
34767 _portmodpropoptical.FreqLdma = uint32(decoder.ReadUint32())
34768 _portmodpropoptical.FlOffset = uint32(decoder.ReadUint32())
34769 _portmodpropoptical.GridSpan = uint32(decoder.ReadUint32())
34770 _portmodpropoptical.TxPwr = uint32(decoder.ReadUint32())
34771 return _portmodpropoptical, nil
34772}
34773
34774func NewPortModPropOptical() *PortModPropOptical {
34775 obj := &PortModPropOptical{
34776 PortModProp: NewPortModProp(1),
34777 }
34778 return obj
34779}
34780
34781type PortStatsEntry struct {
34782 Length uint16
34783 PortNo Port
34784 DurationSec uint32
34785 DurationNsec uint32
34786 RxPackets uint64
34787 TxPackets uint64
34788 RxBytes uint64
34789 TxBytes uint64
34790 RxDropped uint64
34791 TxDropped uint64
34792 RxErrors uint64
34793 TxErrors uint64
34794 Properties []IPortStatsProp
34795}
34796
34797type IPortStatsEntry interface {
34798 goloxi.Serializable
34799 GetLength() uint16
34800 GetPortNo() Port
34801 GetDurationSec() uint32
34802 GetDurationNsec() uint32
34803 GetRxPackets() uint64
34804 GetTxPackets() uint64
34805 GetRxBytes() uint64
34806 GetTxBytes() uint64
34807 GetRxDropped() uint64
34808 GetTxDropped() uint64
34809 GetRxErrors() uint64
34810 GetTxErrors() uint64
34811 GetProperties() []IPortStatsProp
34812}
34813
34814func (self *PortStatsEntry) GetLength() uint16 {
34815 return self.Length
34816}
34817
34818func (self *PortStatsEntry) SetLength(v uint16) {
34819 self.Length = v
34820}
34821
34822func (self *PortStatsEntry) GetPortNo() Port {
34823 return self.PortNo
34824}
34825
34826func (self *PortStatsEntry) SetPortNo(v Port) {
34827 self.PortNo = v
34828}
34829
34830func (self *PortStatsEntry) GetDurationSec() uint32 {
34831 return self.DurationSec
34832}
34833
34834func (self *PortStatsEntry) SetDurationSec(v uint32) {
34835 self.DurationSec = v
34836}
34837
34838func (self *PortStatsEntry) GetDurationNsec() uint32 {
34839 return self.DurationNsec
34840}
34841
34842func (self *PortStatsEntry) SetDurationNsec(v uint32) {
34843 self.DurationNsec = v
34844}
34845
34846func (self *PortStatsEntry) GetRxPackets() uint64 {
34847 return self.RxPackets
34848}
34849
34850func (self *PortStatsEntry) SetRxPackets(v uint64) {
34851 self.RxPackets = v
34852}
34853
34854func (self *PortStatsEntry) GetTxPackets() uint64 {
34855 return self.TxPackets
34856}
34857
34858func (self *PortStatsEntry) SetTxPackets(v uint64) {
34859 self.TxPackets = v
34860}
34861
34862func (self *PortStatsEntry) GetRxBytes() uint64 {
34863 return self.RxBytes
34864}
34865
34866func (self *PortStatsEntry) SetRxBytes(v uint64) {
34867 self.RxBytes = v
34868}
34869
34870func (self *PortStatsEntry) GetTxBytes() uint64 {
34871 return self.TxBytes
34872}
34873
34874func (self *PortStatsEntry) SetTxBytes(v uint64) {
34875 self.TxBytes = v
34876}
34877
34878func (self *PortStatsEntry) GetRxDropped() uint64 {
34879 return self.RxDropped
34880}
34881
34882func (self *PortStatsEntry) SetRxDropped(v uint64) {
34883 self.RxDropped = v
34884}
34885
34886func (self *PortStatsEntry) GetTxDropped() uint64 {
34887 return self.TxDropped
34888}
34889
34890func (self *PortStatsEntry) SetTxDropped(v uint64) {
34891 self.TxDropped = v
34892}
34893
34894func (self *PortStatsEntry) GetRxErrors() uint64 {
34895 return self.RxErrors
34896}
34897
34898func (self *PortStatsEntry) SetRxErrors(v uint64) {
34899 self.RxErrors = v
34900}
34901
34902func (self *PortStatsEntry) GetTxErrors() uint64 {
34903 return self.TxErrors
34904}
34905
34906func (self *PortStatsEntry) SetTxErrors(v uint64) {
34907 self.TxErrors = v
34908}
34909
34910func (self *PortStatsEntry) GetProperties() []IPortStatsProp {
34911 return self.Properties
34912}
34913
34914func (self *PortStatsEntry) SetProperties(v []IPortStatsProp) {
34915 self.Properties = v
34916}
34917
34918func (self *PortStatsEntry) Serialize(encoder *goloxi.Encoder) error {
34919 startIndex := len(encoder.Bytes())
34920
34921 encoder.PutUint16(uint16(self.Length))
34922 encoder.Write(bytes.Repeat([]byte{0}, 2))
34923 self.PortNo.Serialize(encoder)
34924 encoder.PutUint32(uint32(self.DurationSec))
34925 encoder.PutUint32(uint32(self.DurationNsec))
34926 encoder.PutUint64(uint64(self.RxPackets))
34927 encoder.PutUint64(uint64(self.TxPackets))
34928 encoder.PutUint64(uint64(self.RxBytes))
34929 encoder.PutUint64(uint64(self.TxBytes))
34930 encoder.PutUint64(uint64(self.RxDropped))
34931 encoder.PutUint64(uint64(self.TxDropped))
34932 encoder.PutUint64(uint64(self.RxErrors))
34933 encoder.PutUint64(uint64(self.TxErrors))
34934 for _, obj := range self.Properties {
34935 if err := obj.Serialize(encoder); err != nil {
34936 return err
34937 }
34938 }
34939 length := len(encoder.Bytes()) - startIndex
34940
34941 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
34942
34943 return nil
34944}
34945
34946func DecodePortStatsEntry(decoder *goloxi.Decoder) (*PortStatsEntry, error) {
34947 _portstatsentry := &PortStatsEntry{}
34948 if decoder.Length() < 80 {
34949 return nil, fmt.Errorf("PortStatsEntry packet too short: %d < 80", decoder.Length())
34950 }
34951 _portstatsentry.Length = uint16(decoder.ReadUint16())
34952 oldDecoder := decoder
34953 defer func() { decoder = oldDecoder }()
34954 decoder = decoder.SliceDecoder(int(_portstatsentry.Length), 2+0)
34955 decoder.Skip(2)
34956 _portstatsentry.PortNo.Decode(decoder)
34957 _portstatsentry.DurationSec = uint32(decoder.ReadUint32())
34958 _portstatsentry.DurationNsec = uint32(decoder.ReadUint32())
34959 _portstatsentry.RxPackets = uint64(decoder.ReadUint64())
34960 _portstatsentry.TxPackets = uint64(decoder.ReadUint64())
34961 _portstatsentry.RxBytes = uint64(decoder.ReadUint64())
34962 _portstatsentry.TxBytes = uint64(decoder.ReadUint64())
34963 _portstatsentry.RxDropped = uint64(decoder.ReadUint64())
34964 _portstatsentry.TxDropped = uint64(decoder.ReadUint64())
34965 _portstatsentry.RxErrors = uint64(decoder.ReadUint64())
34966 _portstatsentry.TxErrors = uint64(decoder.ReadUint64())
34967
34968 for decoder.Length() >= 4 {
34969 item, err := DecodePortStatsProp(decoder)
34970 if err != nil {
34971 return nil, err
34972 }
34973 if item != nil {
34974 _portstatsentry.Properties = append(_portstatsentry.Properties, item)
34975 }
34976 }
34977 return _portstatsentry, nil
34978}
34979
34980func NewPortStatsEntry() *PortStatsEntry {
34981 obj := &PortStatsEntry{}
34982 return obj
34983}
34984
34985type PortStatsProp struct {
34986 Type uint16
34987 Length uint16
34988}
34989
34990type IPortStatsProp interface {
34991 goloxi.Serializable
34992 GetType() uint16
34993 GetLength() uint16
34994}
34995
34996func (self *PortStatsProp) GetType() uint16 {
34997 return self.Type
34998}
34999
35000func (self *PortStatsProp) SetType(v uint16) {
35001 self.Type = v
35002}
35003
35004func (self *PortStatsProp) GetLength() uint16 {
35005 return self.Length
35006}
35007
35008func (self *PortStatsProp) SetLength(v uint16) {
35009 self.Length = v
35010}
35011
35012func (self *PortStatsProp) Serialize(encoder *goloxi.Encoder) error {
35013
35014 encoder.PutUint16(uint16(self.Type))
35015 encoder.PutUint16(uint16(self.Length))
35016
35017 return nil
35018}
35019
35020func DecodePortStatsProp(decoder *goloxi.Decoder) (IPortStatsProp, error) {
35021 _portstatsprop := &PortStatsProp{}
35022 if decoder.Length() < 4 {
35023 return nil, fmt.Errorf("PortStatsProp packet too short: %d < 4", decoder.Length())
35024 }
35025 _portstatsprop.Type = uint16(decoder.ReadUint16())
35026 _portstatsprop.Length = uint16(decoder.ReadUint16())
35027 oldDecoder := decoder
35028 defer func() { decoder = oldDecoder }()
35029 decoder = decoder.SliceDecoder(int(_portstatsprop.Length), 2+2)
35030
35031 switch _portstatsprop.Type {
35032 case 0:
35033 return DecodePortStatsPropEthernet(_portstatsprop, decoder)
35034 case 1:
35035 return DecodePortStatsPropOptical(_portstatsprop, decoder)
35036 case 65535:
35037 return DecodePortStatsPropExperimenter(_portstatsprop, decoder)
35038 default:
35039 return nil, fmt.Errorf("Invalid type '%d' for 'PortStatsProp'", _portstatsprop.Type)
35040 }
35041}
35042
35043func NewPortStatsProp(_type uint16) *PortStatsProp {
35044 obj := &PortStatsProp{}
35045 obj.Type = _type
35046 return obj
35047}
35048
35049type PortStatsPropEthernet struct {
35050 *PortStatsProp
35051 RxFrameErr uint64
35052 RxOverErr uint64
35053 RxCrcErr uint64
35054 Collisions uint64
35055}
35056
35057type IPortStatsPropEthernet interface {
35058 IPortStatsProp
35059 GetRxFrameErr() uint64
35060 GetRxOverErr() uint64
35061 GetRxCrcErr() uint64
35062 GetCollisions() uint64
35063}
35064
35065func (self *PortStatsPropEthernet) GetRxFrameErr() uint64 {
35066 return self.RxFrameErr
35067}
35068
35069func (self *PortStatsPropEthernet) SetRxFrameErr(v uint64) {
35070 self.RxFrameErr = v
35071}
35072
35073func (self *PortStatsPropEthernet) GetRxOverErr() uint64 {
35074 return self.RxOverErr
35075}
35076
35077func (self *PortStatsPropEthernet) SetRxOverErr(v uint64) {
35078 self.RxOverErr = v
35079}
35080
35081func (self *PortStatsPropEthernet) GetRxCrcErr() uint64 {
35082 return self.RxCrcErr
35083}
35084
35085func (self *PortStatsPropEthernet) SetRxCrcErr(v uint64) {
35086 self.RxCrcErr = v
35087}
35088
35089func (self *PortStatsPropEthernet) GetCollisions() uint64 {
35090 return self.Collisions
35091}
35092
35093func (self *PortStatsPropEthernet) SetCollisions(v uint64) {
35094 self.Collisions = v
35095}
35096
35097func (self *PortStatsPropEthernet) Serialize(encoder *goloxi.Encoder) error {
35098 startIndex := len(encoder.Bytes())
35099 if err := self.PortStatsProp.Serialize(encoder); err != nil {
35100 return err
35101 }
35102
35103 encoder.Write(bytes.Repeat([]byte{0}, 4))
35104 encoder.PutUint64(uint64(self.RxFrameErr))
35105 encoder.PutUint64(uint64(self.RxOverErr))
35106 encoder.PutUint64(uint64(self.RxCrcErr))
35107 encoder.PutUint64(uint64(self.Collisions))
35108 length := len(encoder.Bytes()) - startIndex
35109
35110 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
35111
35112 return nil
35113}
35114
35115func DecodePortStatsPropEthernet(parent *PortStatsProp, decoder *goloxi.Decoder) (*PortStatsPropEthernet, error) {
35116 _portstatspropethernet := &PortStatsPropEthernet{PortStatsProp: parent}
35117 if decoder.Length() < 36 {
35118 return nil, fmt.Errorf("PortStatsPropEthernet packet too short: %d < 36", decoder.Length())
35119 }
35120 decoder.Skip(4)
35121 _portstatspropethernet.RxFrameErr = uint64(decoder.ReadUint64())
35122 _portstatspropethernet.RxOverErr = uint64(decoder.ReadUint64())
35123 _portstatspropethernet.RxCrcErr = uint64(decoder.ReadUint64())
35124 _portstatspropethernet.Collisions = uint64(decoder.ReadUint64())
35125 return _portstatspropethernet, nil
35126}
35127
35128func NewPortStatsPropEthernet() *PortStatsPropEthernet {
35129 obj := &PortStatsPropEthernet{
35130 PortStatsProp: NewPortStatsProp(0),
35131 }
35132 return obj
35133}
35134
35135type PortStatsPropExperimenter struct {
35136 *PortStatsProp
35137 Experimenter uint32
35138 ExpType uint32
35139}
35140
35141type IPortStatsPropExperimenter interface {
35142 IPortStatsProp
35143 GetExperimenter() uint32
35144 GetExpType() uint32
35145}
35146
35147func (self *PortStatsPropExperimenter) GetExperimenter() uint32 {
35148 return self.Experimenter
35149}
35150
35151func (self *PortStatsPropExperimenter) SetExperimenter(v uint32) {
35152 self.Experimenter = v
35153}
35154
35155func (self *PortStatsPropExperimenter) GetExpType() uint32 {
35156 return self.ExpType
35157}
35158
35159func (self *PortStatsPropExperimenter) SetExpType(v uint32) {
35160 self.ExpType = v
35161}
35162
35163func (self *PortStatsPropExperimenter) Serialize(encoder *goloxi.Encoder) error {
35164 if err := self.PortStatsProp.Serialize(encoder); err != nil {
35165 return err
35166 }
35167
35168 encoder.PutUint32(uint32(self.Experimenter))
35169 encoder.PutUint32(uint32(self.ExpType))
35170
35171 return nil
35172}
35173
35174func DecodePortStatsPropExperimenter(parent *PortStatsProp, decoder *goloxi.Decoder) (IPortStatsPropExperimenter, error) {
35175 _portstatspropexperimenter := &PortStatsPropExperimenter{PortStatsProp: parent}
35176 if decoder.Length() < 8 {
35177 return nil, fmt.Errorf("PortStatsPropExperimenter packet too short: %d < 8", decoder.Length())
35178 }
35179 _portstatspropexperimenter.Experimenter = uint32(decoder.ReadUint32())
35180 _portstatspropexperimenter.ExpType = uint32(decoder.ReadUint32())
35181
35182 switch _portstatspropexperimenter.Experimenter {
35183 case 43521:
35184 return DecodePortStatsPropExperimenterIntel(_portstatspropexperimenter, decoder)
35185 default:
35186 return nil, fmt.Errorf("Invalid type '%d' for 'PortStatsPropExperimenter'", _portstatspropexperimenter.Experimenter)
35187 }
35188}
35189
35190func NewPortStatsPropExperimenter(_experimenter uint32) *PortStatsPropExperimenter {
35191 obj := &PortStatsPropExperimenter{
35192 PortStatsProp: NewPortStatsProp(65535),
35193 }
35194 obj.Experimenter = _experimenter
35195 return obj
35196}
35197
35198type PortStatsPropExperimenterIntel struct {
35199 *PortStatsPropExperimenter
35200 Rx1To64Packets uint64
35201 Rx65To127Packets uint64
35202 Rx128To255Packets uint64
35203 Rx256To511Packets uint64
35204 Rx512To1023Packets uint64
35205 Rx1024To1522Packets uint64
35206 Rx1523ToMaxPackets uint64
35207 Tx1To64Packets uint64
35208 Tx65To127Packets uint64
35209 Tx128To255Packets uint64
35210 Tx256To511Packets uint64
35211 Tx512To1023Packets uint64
35212 Tx1024To1522Packets uint64
35213 Tx1523ToMaxPackets uint64
35214 TxMulticastPackets uint64
35215 RxBroadcastPackets uint64
35216 TxBroadcastPackets uint64
35217 RxUndersizedErrors uint64
35218 RxOversizeErrors uint64
35219 RxFragmentedErrors uint64
35220 RxJabberErrors uint64
35221}
35222
35223type IPortStatsPropExperimenterIntel interface {
35224 IPortStatsPropExperimenter
35225 GetRx1To64Packets() uint64
35226 GetRx65To127Packets() uint64
35227 GetRx128To255Packets() uint64
35228 GetRx256To511Packets() uint64
35229 GetRx512To1023Packets() uint64
35230 GetRx1024To1522Packets() uint64
35231 GetRx1523ToMaxPackets() uint64
35232 GetTx1To64Packets() uint64
35233 GetTx65To127Packets() uint64
35234 GetTx128To255Packets() uint64
35235 GetTx256To511Packets() uint64
35236 GetTx512To1023Packets() uint64
35237 GetTx1024To1522Packets() uint64
35238 GetTx1523ToMaxPackets() uint64
35239 GetTxMulticastPackets() uint64
35240 GetRxBroadcastPackets() uint64
35241 GetTxBroadcastPackets() uint64
35242 GetRxUndersizedErrors() uint64
35243 GetRxOversizeErrors() uint64
35244 GetRxFragmentedErrors() uint64
35245 GetRxJabberErrors() uint64
35246}
35247
35248func (self *PortStatsPropExperimenterIntel) GetRx1To64Packets() uint64 {
35249 return self.Rx1To64Packets
35250}
35251
35252func (self *PortStatsPropExperimenterIntel) SetRx1To64Packets(v uint64) {
35253 self.Rx1To64Packets = v
35254}
35255
35256func (self *PortStatsPropExperimenterIntel) GetRx65To127Packets() uint64 {
35257 return self.Rx65To127Packets
35258}
35259
35260func (self *PortStatsPropExperimenterIntel) SetRx65To127Packets(v uint64) {
35261 self.Rx65To127Packets = v
35262}
35263
35264func (self *PortStatsPropExperimenterIntel) GetRx128To255Packets() uint64 {
35265 return self.Rx128To255Packets
35266}
35267
35268func (self *PortStatsPropExperimenterIntel) SetRx128To255Packets(v uint64) {
35269 self.Rx128To255Packets = v
35270}
35271
35272func (self *PortStatsPropExperimenterIntel) GetRx256To511Packets() uint64 {
35273 return self.Rx256To511Packets
35274}
35275
35276func (self *PortStatsPropExperimenterIntel) SetRx256To511Packets(v uint64) {
35277 self.Rx256To511Packets = v
35278}
35279
35280func (self *PortStatsPropExperimenterIntel) GetRx512To1023Packets() uint64 {
35281 return self.Rx512To1023Packets
35282}
35283
35284func (self *PortStatsPropExperimenterIntel) SetRx512To1023Packets(v uint64) {
35285 self.Rx512To1023Packets = v
35286}
35287
35288func (self *PortStatsPropExperimenterIntel) GetRx1024To1522Packets() uint64 {
35289 return self.Rx1024To1522Packets
35290}
35291
35292func (self *PortStatsPropExperimenterIntel) SetRx1024To1522Packets(v uint64) {
35293 self.Rx1024To1522Packets = v
35294}
35295
35296func (self *PortStatsPropExperimenterIntel) GetRx1523ToMaxPackets() uint64 {
35297 return self.Rx1523ToMaxPackets
35298}
35299
35300func (self *PortStatsPropExperimenterIntel) SetRx1523ToMaxPackets(v uint64) {
35301 self.Rx1523ToMaxPackets = v
35302}
35303
35304func (self *PortStatsPropExperimenterIntel) GetTx1To64Packets() uint64 {
35305 return self.Tx1To64Packets
35306}
35307
35308func (self *PortStatsPropExperimenterIntel) SetTx1To64Packets(v uint64) {
35309 self.Tx1To64Packets = v
35310}
35311
35312func (self *PortStatsPropExperimenterIntel) GetTx65To127Packets() uint64 {
35313 return self.Tx65To127Packets
35314}
35315
35316func (self *PortStatsPropExperimenterIntel) SetTx65To127Packets(v uint64) {
35317 self.Tx65To127Packets = v
35318}
35319
35320func (self *PortStatsPropExperimenterIntel) GetTx128To255Packets() uint64 {
35321 return self.Tx128To255Packets
35322}
35323
35324func (self *PortStatsPropExperimenterIntel) SetTx128To255Packets(v uint64) {
35325 self.Tx128To255Packets = v
35326}
35327
35328func (self *PortStatsPropExperimenterIntel) GetTx256To511Packets() uint64 {
35329 return self.Tx256To511Packets
35330}
35331
35332func (self *PortStatsPropExperimenterIntel) SetTx256To511Packets(v uint64) {
35333 self.Tx256To511Packets = v
35334}
35335
35336func (self *PortStatsPropExperimenterIntel) GetTx512To1023Packets() uint64 {
35337 return self.Tx512To1023Packets
35338}
35339
35340func (self *PortStatsPropExperimenterIntel) SetTx512To1023Packets(v uint64) {
35341 self.Tx512To1023Packets = v
35342}
35343
35344func (self *PortStatsPropExperimenterIntel) GetTx1024To1522Packets() uint64 {
35345 return self.Tx1024To1522Packets
35346}
35347
35348func (self *PortStatsPropExperimenterIntel) SetTx1024To1522Packets(v uint64) {
35349 self.Tx1024To1522Packets = v
35350}
35351
35352func (self *PortStatsPropExperimenterIntel) GetTx1523ToMaxPackets() uint64 {
35353 return self.Tx1523ToMaxPackets
35354}
35355
35356func (self *PortStatsPropExperimenterIntel) SetTx1523ToMaxPackets(v uint64) {
35357 self.Tx1523ToMaxPackets = v
35358}
35359
35360func (self *PortStatsPropExperimenterIntel) GetTxMulticastPackets() uint64 {
35361 return self.TxMulticastPackets
35362}
35363
35364func (self *PortStatsPropExperimenterIntel) SetTxMulticastPackets(v uint64) {
35365 self.TxMulticastPackets = v
35366}
35367
35368func (self *PortStatsPropExperimenterIntel) GetRxBroadcastPackets() uint64 {
35369 return self.RxBroadcastPackets
35370}
35371
35372func (self *PortStatsPropExperimenterIntel) SetRxBroadcastPackets(v uint64) {
35373 self.RxBroadcastPackets = v
35374}
35375
35376func (self *PortStatsPropExperimenterIntel) GetTxBroadcastPackets() uint64 {
35377 return self.TxBroadcastPackets
35378}
35379
35380func (self *PortStatsPropExperimenterIntel) SetTxBroadcastPackets(v uint64) {
35381 self.TxBroadcastPackets = v
35382}
35383
35384func (self *PortStatsPropExperimenterIntel) GetRxUndersizedErrors() uint64 {
35385 return self.RxUndersizedErrors
35386}
35387
35388func (self *PortStatsPropExperimenterIntel) SetRxUndersizedErrors(v uint64) {
35389 self.RxUndersizedErrors = v
35390}
35391
35392func (self *PortStatsPropExperimenterIntel) GetRxOversizeErrors() uint64 {
35393 return self.RxOversizeErrors
35394}
35395
35396func (self *PortStatsPropExperimenterIntel) SetRxOversizeErrors(v uint64) {
35397 self.RxOversizeErrors = v
35398}
35399
35400func (self *PortStatsPropExperimenterIntel) GetRxFragmentedErrors() uint64 {
35401 return self.RxFragmentedErrors
35402}
35403
35404func (self *PortStatsPropExperimenterIntel) SetRxFragmentedErrors(v uint64) {
35405 self.RxFragmentedErrors = v
35406}
35407
35408func (self *PortStatsPropExperimenterIntel) GetRxJabberErrors() uint64 {
35409 return self.RxJabberErrors
35410}
35411
35412func (self *PortStatsPropExperimenterIntel) SetRxJabberErrors(v uint64) {
35413 self.RxJabberErrors = v
35414}
35415
35416func (self *PortStatsPropExperimenterIntel) Serialize(encoder *goloxi.Encoder) error {
35417 startIndex := len(encoder.Bytes())
35418 if err := self.PortStatsPropExperimenter.Serialize(encoder); err != nil {
35419 return err
35420 }
35421
35422 encoder.Write(bytes.Repeat([]byte{0}, 4))
35423 encoder.PutUint64(uint64(self.Rx1To64Packets))
35424 encoder.PutUint64(uint64(self.Rx65To127Packets))
35425 encoder.PutUint64(uint64(self.Rx128To255Packets))
35426 encoder.PutUint64(uint64(self.Rx256To511Packets))
35427 encoder.PutUint64(uint64(self.Rx512To1023Packets))
35428 encoder.PutUint64(uint64(self.Rx1024To1522Packets))
35429 encoder.PutUint64(uint64(self.Rx1523ToMaxPackets))
35430 encoder.PutUint64(uint64(self.Tx1To64Packets))
35431 encoder.PutUint64(uint64(self.Tx65To127Packets))
35432 encoder.PutUint64(uint64(self.Tx128To255Packets))
35433 encoder.PutUint64(uint64(self.Tx256To511Packets))
35434 encoder.PutUint64(uint64(self.Tx512To1023Packets))
35435 encoder.PutUint64(uint64(self.Tx1024To1522Packets))
35436 encoder.PutUint64(uint64(self.Tx1523ToMaxPackets))
35437 encoder.PutUint64(uint64(self.TxMulticastPackets))
35438 encoder.PutUint64(uint64(self.RxBroadcastPackets))
35439 encoder.PutUint64(uint64(self.TxBroadcastPackets))
35440 encoder.PutUint64(uint64(self.RxUndersizedErrors))
35441 encoder.PutUint64(uint64(self.RxOversizeErrors))
35442 encoder.PutUint64(uint64(self.RxFragmentedErrors))
35443 encoder.PutUint64(uint64(self.RxJabberErrors))
35444 length := len(encoder.Bytes()) - startIndex
35445
35446 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
35447
35448 return nil
35449}
35450
35451func DecodePortStatsPropExperimenterIntel(parent *PortStatsPropExperimenter, decoder *goloxi.Decoder) (*PortStatsPropExperimenterIntel, error) {
35452 _portstatspropexperimenterintel := &PortStatsPropExperimenterIntel{PortStatsPropExperimenter: parent}
35453 if decoder.Length() < 172 {
35454 return nil, fmt.Errorf("PortStatsPropExperimenterIntel packet too short: %d < 172", decoder.Length())
35455 }
35456 decoder.Skip(4)
35457 _portstatspropexperimenterintel.Rx1To64Packets = uint64(decoder.ReadUint64())
35458 _portstatspropexperimenterintel.Rx65To127Packets = uint64(decoder.ReadUint64())
35459 _portstatspropexperimenterintel.Rx128To255Packets = uint64(decoder.ReadUint64())
35460 _portstatspropexperimenterintel.Rx256To511Packets = uint64(decoder.ReadUint64())
35461 _portstatspropexperimenterintel.Rx512To1023Packets = uint64(decoder.ReadUint64())
35462 _portstatspropexperimenterintel.Rx1024To1522Packets = uint64(decoder.ReadUint64())
35463 _portstatspropexperimenterintel.Rx1523ToMaxPackets = uint64(decoder.ReadUint64())
35464 _portstatspropexperimenterintel.Tx1To64Packets = uint64(decoder.ReadUint64())
35465 _portstatspropexperimenterintel.Tx65To127Packets = uint64(decoder.ReadUint64())
35466 _portstatspropexperimenterintel.Tx128To255Packets = uint64(decoder.ReadUint64())
35467 _portstatspropexperimenterintel.Tx256To511Packets = uint64(decoder.ReadUint64())
35468 _portstatspropexperimenterintel.Tx512To1023Packets = uint64(decoder.ReadUint64())
35469 _portstatspropexperimenterintel.Tx1024To1522Packets = uint64(decoder.ReadUint64())
35470 _portstatspropexperimenterintel.Tx1523ToMaxPackets = uint64(decoder.ReadUint64())
35471 _portstatspropexperimenterintel.TxMulticastPackets = uint64(decoder.ReadUint64())
35472 _portstatspropexperimenterintel.RxBroadcastPackets = uint64(decoder.ReadUint64())
35473 _portstatspropexperimenterintel.TxBroadcastPackets = uint64(decoder.ReadUint64())
35474 _portstatspropexperimenterintel.RxUndersizedErrors = uint64(decoder.ReadUint64())
35475 _portstatspropexperimenterintel.RxOversizeErrors = uint64(decoder.ReadUint64())
35476 _portstatspropexperimenterintel.RxFragmentedErrors = uint64(decoder.ReadUint64())
35477 _portstatspropexperimenterintel.RxJabberErrors = uint64(decoder.ReadUint64())
35478 return _portstatspropexperimenterintel, nil
35479}
35480
35481func NewPortStatsPropExperimenterIntel() *PortStatsPropExperimenterIntel {
35482 obj := &PortStatsPropExperimenterIntel{
35483 PortStatsPropExperimenter: NewPortStatsPropExperimenter(43521),
35484 }
35485 return obj
35486}
35487
35488type PortStatsPropOptical struct {
35489 *PortStatsProp
35490 Flags uint32
35491 TxFreqLmda uint32
35492 TxOffset uint32
35493 TxGridSpan uint32
35494 RxFreqLmda uint32
35495 RxOffset uint32
35496 RxGridSpan uint32
35497 TxPwr uint16
35498 RxPwr uint16
35499 BiasCurrent uint16
35500 Temperature uint16
35501}
35502
35503type IPortStatsPropOptical interface {
35504 IPortStatsProp
35505 GetFlags() uint32
35506 GetTxFreqLmda() uint32
35507 GetTxOffset() uint32
35508 GetTxGridSpan() uint32
35509 GetRxFreqLmda() uint32
35510 GetRxOffset() uint32
35511 GetRxGridSpan() uint32
35512 GetTxPwr() uint16
35513 GetRxPwr() uint16
35514 GetBiasCurrent() uint16
35515 GetTemperature() uint16
35516}
35517
35518func (self *PortStatsPropOptical) GetFlags() uint32 {
35519 return self.Flags
35520}
35521
35522func (self *PortStatsPropOptical) SetFlags(v uint32) {
35523 self.Flags = v
35524}
35525
35526func (self *PortStatsPropOptical) GetTxFreqLmda() uint32 {
35527 return self.TxFreqLmda
35528}
35529
35530func (self *PortStatsPropOptical) SetTxFreqLmda(v uint32) {
35531 self.TxFreqLmda = v
35532}
35533
35534func (self *PortStatsPropOptical) GetTxOffset() uint32 {
35535 return self.TxOffset
35536}
35537
35538func (self *PortStatsPropOptical) SetTxOffset(v uint32) {
35539 self.TxOffset = v
35540}
35541
35542func (self *PortStatsPropOptical) GetTxGridSpan() uint32 {
35543 return self.TxGridSpan
35544}
35545
35546func (self *PortStatsPropOptical) SetTxGridSpan(v uint32) {
35547 self.TxGridSpan = v
35548}
35549
35550func (self *PortStatsPropOptical) GetRxFreqLmda() uint32 {
35551 return self.RxFreqLmda
35552}
35553
35554func (self *PortStatsPropOptical) SetRxFreqLmda(v uint32) {
35555 self.RxFreqLmda = v
35556}
35557
35558func (self *PortStatsPropOptical) GetRxOffset() uint32 {
35559 return self.RxOffset
35560}
35561
35562func (self *PortStatsPropOptical) SetRxOffset(v uint32) {
35563 self.RxOffset = v
35564}
35565
35566func (self *PortStatsPropOptical) GetRxGridSpan() uint32 {
35567 return self.RxGridSpan
35568}
35569
35570func (self *PortStatsPropOptical) SetRxGridSpan(v uint32) {
35571 self.RxGridSpan = v
35572}
35573
35574func (self *PortStatsPropOptical) GetTxPwr() uint16 {
35575 return self.TxPwr
35576}
35577
35578func (self *PortStatsPropOptical) SetTxPwr(v uint16) {
35579 self.TxPwr = v
35580}
35581
35582func (self *PortStatsPropOptical) GetRxPwr() uint16 {
35583 return self.RxPwr
35584}
35585
35586func (self *PortStatsPropOptical) SetRxPwr(v uint16) {
35587 self.RxPwr = v
35588}
35589
35590func (self *PortStatsPropOptical) GetBiasCurrent() uint16 {
35591 return self.BiasCurrent
35592}
35593
35594func (self *PortStatsPropOptical) SetBiasCurrent(v uint16) {
35595 self.BiasCurrent = v
35596}
35597
35598func (self *PortStatsPropOptical) GetTemperature() uint16 {
35599 return self.Temperature
35600}
35601
35602func (self *PortStatsPropOptical) SetTemperature(v uint16) {
35603 self.Temperature = v
35604}
35605
35606func (self *PortStatsPropOptical) Serialize(encoder *goloxi.Encoder) error {
35607 startIndex := len(encoder.Bytes())
35608 if err := self.PortStatsProp.Serialize(encoder); err != nil {
35609 return err
35610 }
35611
35612 encoder.Write(bytes.Repeat([]byte{0}, 4))
35613 encoder.PutUint32(uint32(self.Flags))
35614 encoder.PutUint32(uint32(self.TxFreqLmda))
35615 encoder.PutUint32(uint32(self.TxOffset))
35616 encoder.PutUint32(uint32(self.TxGridSpan))
35617 encoder.PutUint32(uint32(self.RxFreqLmda))
35618 encoder.PutUint32(uint32(self.RxOffset))
35619 encoder.PutUint32(uint32(self.RxGridSpan))
35620 encoder.PutUint16(uint16(self.TxPwr))
35621 encoder.PutUint16(uint16(self.RxPwr))
35622 encoder.PutUint16(uint16(self.BiasCurrent))
35623 encoder.PutUint16(uint16(self.Temperature))
35624 length := len(encoder.Bytes()) - startIndex
35625
35626 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
35627
35628 return nil
35629}
35630
35631func DecodePortStatsPropOptical(parent *PortStatsProp, decoder *goloxi.Decoder) (*PortStatsPropOptical, error) {
35632 _portstatspropoptical := &PortStatsPropOptical{PortStatsProp: parent}
35633 if decoder.Length() < 40 {
35634 return nil, fmt.Errorf("PortStatsPropOptical packet too short: %d < 40", decoder.Length())
35635 }
35636 decoder.Skip(4)
35637 _portstatspropoptical.Flags = uint32(decoder.ReadUint32())
35638 _portstatspropoptical.TxFreqLmda = uint32(decoder.ReadUint32())
35639 _portstatspropoptical.TxOffset = uint32(decoder.ReadUint32())
35640 _portstatspropoptical.TxGridSpan = uint32(decoder.ReadUint32())
35641 _portstatspropoptical.RxFreqLmda = uint32(decoder.ReadUint32())
35642 _portstatspropoptical.RxOffset = uint32(decoder.ReadUint32())
35643 _portstatspropoptical.RxGridSpan = uint32(decoder.ReadUint32())
35644 _portstatspropoptical.TxPwr = uint16(decoder.ReadUint16())
35645 _portstatspropoptical.RxPwr = uint16(decoder.ReadUint16())
35646 _portstatspropoptical.BiasCurrent = uint16(decoder.ReadUint16())
35647 _portstatspropoptical.Temperature = uint16(decoder.ReadUint16())
35648 return _portstatspropoptical, nil
35649}
35650
35651func NewPortStatsPropOptical() *PortStatsPropOptical {
35652 obj := &PortStatsPropOptical{
35653 PortStatsProp: NewPortStatsProp(1),
35654 }
35655 return obj
35656}
35657
35658type QueueDesc struct {
35659 PortNo uint32
35660 QueueId uint32
35661 Length uint16
35662 Properties []IQueueDescProp
35663}
35664
35665type IQueueDesc interface {
35666 goloxi.Serializable
35667 GetPortNo() uint32
35668 GetQueueId() uint32
35669 GetLength() uint16
35670 GetProperties() []IQueueDescProp
35671}
35672
35673func (self *QueueDesc) GetPortNo() uint32 {
35674 return self.PortNo
35675}
35676
35677func (self *QueueDesc) SetPortNo(v uint32) {
35678 self.PortNo = v
35679}
35680
35681func (self *QueueDesc) GetQueueId() uint32 {
35682 return self.QueueId
35683}
35684
35685func (self *QueueDesc) SetQueueId(v uint32) {
35686 self.QueueId = v
35687}
35688
35689func (self *QueueDesc) GetLength() uint16 {
35690 return self.Length
35691}
35692
35693func (self *QueueDesc) SetLength(v uint16) {
35694 self.Length = v
35695}
35696
35697func (self *QueueDesc) GetProperties() []IQueueDescProp {
35698 return self.Properties
35699}
35700
35701func (self *QueueDesc) SetProperties(v []IQueueDescProp) {
35702 self.Properties = v
35703}
35704
35705func (self *QueueDesc) Serialize(encoder *goloxi.Encoder) error {
35706 startIndex := len(encoder.Bytes())
35707
35708 encoder.PutUint32(uint32(self.PortNo))
35709 encoder.PutUint32(uint32(self.QueueId))
35710 encoder.PutUint16(uint16(self.Length))
35711 encoder.Write(bytes.Repeat([]byte{0}, 6))
35712 for _, obj := range self.Properties {
35713 if err := obj.Serialize(encoder); err != nil {
35714 return err
35715 }
35716 }
35717 length := len(encoder.Bytes()) - startIndex
35718
35719 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+8:startIndex+10], uint16(length))
35720
35721 return nil
35722}
35723
35724func DecodeQueueDesc(decoder *goloxi.Decoder) (*QueueDesc, error) {
35725 _queuedesc := &QueueDesc{}
35726 if decoder.Length() < 16 {
35727 return nil, fmt.Errorf("QueueDesc packet too short: %d < 16", decoder.Length())
35728 }
35729 _queuedesc.PortNo = uint32(decoder.ReadUint32())
35730 _queuedesc.QueueId = uint32(decoder.ReadUint32())
35731 _queuedesc.Length = uint16(decoder.ReadUint16())
35732 oldDecoder := decoder
35733 defer func() { decoder = oldDecoder }()
35734 decoder = decoder.SliceDecoder(int(_queuedesc.Length), 2+8)
35735 decoder.Skip(6)
35736
35737 for decoder.Length() >= 4 {
35738 item, err := DecodeQueueDescProp(decoder)
35739 if err != nil {
35740 return nil, err
35741 }
35742 if item != nil {
35743 _queuedesc.Properties = append(_queuedesc.Properties, item)
35744 }
35745 }
35746 return _queuedesc, nil
35747}
35748
35749func NewQueueDesc() *QueueDesc {
35750 obj := &QueueDesc{}
35751 return obj
35752}
35753
35754type QueueDescProp struct {
35755 Type uint16
35756 Length uint16
35757}
35758
35759type IQueueDescProp interface {
35760 goloxi.Serializable
35761 GetType() uint16
35762 GetLength() uint16
35763}
35764
35765func (self *QueueDescProp) GetType() uint16 {
35766 return self.Type
35767}
35768
35769func (self *QueueDescProp) SetType(v uint16) {
35770 self.Type = v
35771}
35772
35773func (self *QueueDescProp) GetLength() uint16 {
35774 return self.Length
35775}
35776
35777func (self *QueueDescProp) SetLength(v uint16) {
35778 self.Length = v
35779}
35780
35781func (self *QueueDescProp) Serialize(encoder *goloxi.Encoder) error {
35782
35783 encoder.PutUint16(uint16(self.Type))
35784 encoder.PutUint16(uint16(self.Length))
35785
35786 return nil
35787}
35788
35789func DecodeQueueDescProp(decoder *goloxi.Decoder) (IQueueDescProp, error) {
35790 _queuedescprop := &QueueDescProp{}
35791 if decoder.Length() < 4 {
35792 return nil, fmt.Errorf("QueueDescProp packet too short: %d < 4", decoder.Length())
35793 }
35794 _queuedescprop.Type = uint16(decoder.ReadUint16())
35795 _queuedescprop.Length = uint16(decoder.ReadUint16())
35796 oldDecoder := decoder
35797 defer func() { decoder = oldDecoder }()
35798 decoder = decoder.SliceDecoder(int(_queuedescprop.Length), 2+2)
35799
35800 switch _queuedescprop.Type {
35801 case 1:
35802 return DecodeQueueDescPropMinRate(_queuedescprop, decoder)
35803 case 2:
35804 return DecodeQueueDescPropMaxRate(_queuedescprop, decoder)
35805 case 65535:
35806 return DecodeQueueDescPropExperimenter(_queuedescprop, decoder)
35807 default:
35808 return nil, fmt.Errorf("Invalid type '%d' for 'QueueDescProp'", _queuedescprop.Type)
35809 }
35810}
35811
35812func NewQueueDescProp(_type uint16) *QueueDescProp {
35813 obj := &QueueDescProp{}
35814 obj.Type = _type
35815 return obj
35816}
35817
35818type QueueDescPropExperimenter struct {
35819 *QueueDescProp
35820 Experimenter uint32
35821 ExpType uint32
35822}
35823
35824type IQueueDescPropExperimenter interface {
35825 IQueueDescProp
35826 GetExperimenter() uint32
35827 GetExpType() uint32
35828}
35829
35830func (self *QueueDescPropExperimenter) GetExperimenter() uint32 {
35831 return self.Experimenter
35832}
35833
35834func (self *QueueDescPropExperimenter) SetExperimenter(v uint32) {
35835 self.Experimenter = v
35836}
35837
35838func (self *QueueDescPropExperimenter) GetExpType() uint32 {
35839 return self.ExpType
35840}
35841
35842func (self *QueueDescPropExperimenter) SetExpType(v uint32) {
35843 self.ExpType = v
35844}
35845
35846func (self *QueueDescPropExperimenter) Serialize(encoder *goloxi.Encoder) error {
35847 if err := self.QueueDescProp.Serialize(encoder); err != nil {
35848 return err
35849 }
35850
35851 encoder.PutUint32(uint32(self.Experimenter))
35852 encoder.PutUint32(uint32(self.ExpType))
35853
35854 return nil
35855}
35856
35857func DecodeQueueDescPropExperimenter(parent *QueueDescProp, decoder *goloxi.Decoder) (IQueueDescPropExperimenter, error) {
35858 _queuedescpropexperimenter := &QueueDescPropExperimenter{QueueDescProp: parent}
35859 if decoder.Length() < 8 {
35860 return nil, fmt.Errorf("QueueDescPropExperimenter packet too short: %d < 8", decoder.Length())
35861 }
35862 _queuedescpropexperimenter.Experimenter = uint32(decoder.ReadUint32())
35863 _queuedescpropexperimenter.ExpType = uint32(decoder.ReadUint32())
35864
35865 switch _queuedescpropexperimenter.Experimenter {
35866 case 6035143:
35867 return DecodeQueueDescPropBsn(_queuedescpropexperimenter, decoder)
35868 default:
35869 return nil, fmt.Errorf("Invalid type '%d' for 'QueueDescPropExperimenter'", _queuedescpropexperimenter.Experimenter)
35870 }
35871}
35872
35873func NewQueueDescPropExperimenter(_experimenter uint32) *QueueDescPropExperimenter {
35874 obj := &QueueDescPropExperimenter{
35875 QueueDescProp: NewQueueDescProp(65535),
35876 }
35877 obj.Experimenter = _experimenter
35878 return obj
35879}
35880
35881type QueueDescPropBsn struct {
35882 *QueueDescPropExperimenter
35883}
35884
35885type IQueueDescPropBsn interface {
35886 IQueueDescPropExperimenter
35887}
35888
35889func (self *QueueDescPropBsn) Serialize(encoder *goloxi.Encoder) error {
35890 if err := self.QueueDescPropExperimenter.Serialize(encoder); err != nil {
35891 return err
35892 }
35893
35894 return nil
35895}
35896
35897func DecodeQueueDescPropBsn(parent *QueueDescPropExperimenter, decoder *goloxi.Decoder) (IQueueDescPropBsn, error) {
35898 _queuedescpropbsn := &QueueDescPropBsn{QueueDescPropExperimenter: parent}
35899
35900 switch _queuedescpropbsn.ExpType {
35901 case 0:
35902 return DecodeQueueDescPropBsnQueueName(_queuedescpropbsn, decoder)
35903 default:
35904 return nil, fmt.Errorf("Invalid type '%d' for 'QueueDescPropBsn'", _queuedescpropbsn.ExpType)
35905 }
35906}
35907
35908func NewQueueDescPropBsn(_exp_type uint32) *QueueDescPropBsn {
35909 obj := &QueueDescPropBsn{
35910 QueueDescPropExperimenter: NewQueueDescPropExperimenter(6035143),
35911 }
35912 obj.ExpType = _exp_type
35913 return obj
35914}
35915
35916type QueueDescPropBsnQueueName struct {
35917 *QueueDescPropBsn
35918 Name []byte
35919}
35920
35921type IQueueDescPropBsnQueueName interface {
35922 IQueueDescPropBsn
35923 GetName() []byte
35924}
35925
35926func (self *QueueDescPropBsnQueueName) GetName() []byte {
35927 return self.Name
35928}
35929
35930func (self *QueueDescPropBsnQueueName) SetName(v []byte) {
35931 self.Name = v
35932}
35933
35934func (self *QueueDescPropBsnQueueName) Serialize(encoder *goloxi.Encoder) error {
35935 startIndex := len(encoder.Bytes())
35936 if err := self.QueueDescPropBsn.Serialize(encoder); err != nil {
35937 return err
35938 }
35939
35940 encoder.Write(self.Name)
35941 length := len(encoder.Bytes()) - startIndex
35942
35943 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
35944
35945 return nil
35946}
35947
35948func DecodeQueueDescPropBsnQueueName(parent *QueueDescPropBsn, decoder *goloxi.Decoder) (*QueueDescPropBsnQueueName, error) {
35949 _queuedescpropbsnqueuename := &QueueDescPropBsnQueueName{QueueDescPropBsn: parent}
35950 _queuedescpropbsnqueuename.Name = decoder.Read(int(decoder.Length()))
35951 return _queuedescpropbsnqueuename, nil
35952}
35953
35954func NewQueueDescPropBsnQueueName() *QueueDescPropBsnQueueName {
35955 obj := &QueueDescPropBsnQueueName{
35956 QueueDescPropBsn: NewQueueDescPropBsn(0),
35957 }
35958 return obj
35959}
35960
35961type QueueDescPropMaxRate struct {
35962 *QueueDescProp
35963 Rate uint16
35964}
35965
35966type IQueueDescPropMaxRate interface {
35967 IQueueDescProp
35968 GetRate() uint16
35969}
35970
35971func (self *QueueDescPropMaxRate) GetRate() uint16 {
35972 return self.Rate
35973}
35974
35975func (self *QueueDescPropMaxRate) SetRate(v uint16) {
35976 self.Rate = v
35977}
35978
35979func (self *QueueDescPropMaxRate) Serialize(encoder *goloxi.Encoder) error {
35980 startIndex := len(encoder.Bytes())
35981 if err := self.QueueDescProp.Serialize(encoder); err != nil {
35982 return err
35983 }
35984
35985 encoder.PutUint16(uint16(self.Rate))
35986 encoder.Write(bytes.Repeat([]byte{0}, 2))
35987 length := len(encoder.Bytes()) - startIndex
35988
35989 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
35990
35991 return nil
35992}
35993
35994func DecodeQueueDescPropMaxRate(parent *QueueDescProp, decoder *goloxi.Decoder) (*QueueDescPropMaxRate, error) {
35995 _queuedescpropmaxrate := &QueueDescPropMaxRate{QueueDescProp: parent}
35996 if decoder.Length() < 4 {
35997 return nil, fmt.Errorf("QueueDescPropMaxRate packet too short: %d < 4", decoder.Length())
35998 }
35999 _queuedescpropmaxrate.Rate = uint16(decoder.ReadUint16())
36000 decoder.Skip(2)
36001 return _queuedescpropmaxrate, nil
36002}
36003
36004func NewQueueDescPropMaxRate() *QueueDescPropMaxRate {
36005 obj := &QueueDescPropMaxRate{
36006 QueueDescProp: NewQueueDescProp(2),
36007 }
36008 return obj
36009}
36010
36011type QueueDescPropMinRate struct {
36012 *QueueDescProp
36013 Rate uint16
36014}
36015
36016type IQueueDescPropMinRate interface {
36017 IQueueDescProp
36018 GetRate() uint16
36019}
36020
36021func (self *QueueDescPropMinRate) GetRate() uint16 {
36022 return self.Rate
36023}
36024
36025func (self *QueueDescPropMinRate) SetRate(v uint16) {
36026 self.Rate = v
36027}
36028
36029func (self *QueueDescPropMinRate) Serialize(encoder *goloxi.Encoder) error {
36030 startIndex := len(encoder.Bytes())
36031 if err := self.QueueDescProp.Serialize(encoder); err != nil {
36032 return err
36033 }
36034
36035 encoder.PutUint16(uint16(self.Rate))
36036 encoder.Write(bytes.Repeat([]byte{0}, 2))
36037 length := len(encoder.Bytes()) - startIndex
36038
36039 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
36040
36041 return nil
36042}
36043
36044func DecodeQueueDescPropMinRate(parent *QueueDescProp, decoder *goloxi.Decoder) (*QueueDescPropMinRate, error) {
36045 _queuedescpropminrate := &QueueDescPropMinRate{QueueDescProp: parent}
36046 if decoder.Length() < 4 {
36047 return nil, fmt.Errorf("QueueDescPropMinRate packet too short: %d < 4", decoder.Length())
36048 }
36049 _queuedescpropminrate.Rate = uint16(decoder.ReadUint16())
36050 decoder.Skip(2)
36051 return _queuedescpropminrate, nil
36052}
36053
36054func NewQueueDescPropMinRate() *QueueDescPropMinRate {
36055 obj := &QueueDescPropMinRate{
36056 QueueDescProp: NewQueueDescProp(1),
36057 }
36058 return obj
36059}
36060
36061type QueueProp struct {
36062 Type uint16
36063 Len uint16
36064}
36065
36066type IQueueProp interface {
36067 goloxi.Serializable
36068 GetType() uint16
36069 GetLen() uint16
36070}
36071
36072func (self *QueueProp) GetType() uint16 {
36073 return self.Type
36074}
36075
36076func (self *QueueProp) SetType(v uint16) {
36077 self.Type = v
36078}
36079
36080func (self *QueueProp) GetLen() uint16 {
36081 return self.Len
36082}
36083
36084func (self *QueueProp) SetLen(v uint16) {
36085 self.Len = v
36086}
36087
36088func (self *QueueProp) Serialize(encoder *goloxi.Encoder) error {
36089
36090 encoder.PutUint16(uint16(self.Type))
36091 encoder.PutUint16(uint16(self.Len))
36092
36093 return nil
36094}
36095
36096func DecodeQueueProp(decoder *goloxi.Decoder) (IQueueProp, error) {
36097 _queueprop := &QueueProp{}
36098 if decoder.Length() < 4 {
36099 return nil, fmt.Errorf("QueueProp packet too short: %d < 4", decoder.Length())
36100 }
36101 _queueprop.Type = uint16(decoder.ReadUint16())
36102 _queueprop.Len = uint16(decoder.ReadUint16())
36103 oldDecoder := decoder
36104 defer func() { decoder = oldDecoder }()
36105 decoder = decoder.SliceDecoder(int(_queueprop.Len), 2+2)
36106
36107 switch _queueprop.Type {
36108 case 1:
36109 return DecodeQueuePropMinRate(_queueprop, decoder)
36110 case 2:
36111 return DecodeQueuePropMaxRate(_queueprop, decoder)
36112 case 65535:
36113 return DecodeQueuePropExperimenter(_queueprop, decoder)
36114 default:
36115 return nil, fmt.Errorf("Invalid type '%d' for 'QueueProp'", _queueprop.Type)
36116 }
36117}
36118
36119func NewQueueProp(_type uint16) *QueueProp {
36120 obj := &QueueProp{}
36121 obj.Type = _type
36122 return obj
36123}
36124
36125type QueuePropExperimenter struct {
36126 *QueueProp
36127 Experimenter uint32
36128}
36129
36130type IQueuePropExperimenter interface {
36131 IQueueProp
36132 GetExperimenter() uint32
36133}
36134
36135func (self *QueuePropExperimenter) GetExperimenter() uint32 {
36136 return self.Experimenter
36137}
36138
36139func (self *QueuePropExperimenter) SetExperimenter(v uint32) {
36140 self.Experimenter = v
36141}
36142
36143func (self *QueuePropExperimenter) Serialize(encoder *goloxi.Encoder) error {
36144 if err := self.QueueProp.Serialize(encoder); err != nil {
36145 return err
36146 }
36147
36148 encoder.Write(bytes.Repeat([]byte{0}, 4))
36149 encoder.PutUint32(uint32(self.Experimenter))
36150 encoder.Write(bytes.Repeat([]byte{0}, 4))
36151
36152 return nil
36153}
36154
36155func DecodeQueuePropExperimenter(parent *QueueProp, decoder *goloxi.Decoder) (IQueuePropExperimenter, error) {
36156 _queuepropexperimenter := &QueuePropExperimenter{QueueProp: parent}
36157 if decoder.Length() < 4 {
36158 return nil, fmt.Errorf("QueuePropExperimenter packet too short: %d < 4", decoder.Length())
36159 }
36160 decoder.Skip(4)
36161 _queuepropexperimenter.Experimenter = uint32(decoder.ReadUint32())
36162 decoder.Skip(4)
36163 return _queuepropexperimenter, nil
36164}
36165
36166func NewQueuePropExperimenter(_experimenter uint32) *QueuePropExperimenter {
36167 obj := &QueuePropExperimenter{
36168 QueueProp: NewQueueProp(65535),
36169 }
36170 obj.Experimenter = _experimenter
36171 return obj
36172}
36173
36174type QueuePropMaxRate struct {
36175 *QueueProp
36176 Rate uint16
36177}
36178
36179type IQueuePropMaxRate interface {
36180 IQueueProp
36181 GetRate() uint16
36182}
36183
36184func (self *QueuePropMaxRate) GetRate() uint16 {
36185 return self.Rate
36186}
36187
36188func (self *QueuePropMaxRate) SetRate(v uint16) {
36189 self.Rate = v
36190}
36191
36192func (self *QueuePropMaxRate) Serialize(encoder *goloxi.Encoder) error {
36193 startIndex := len(encoder.Bytes())
36194 if err := self.QueueProp.Serialize(encoder); err != nil {
36195 return err
36196 }
36197
36198 encoder.Write(bytes.Repeat([]byte{0}, 4))
36199 encoder.PutUint16(uint16(self.Rate))
36200 encoder.Write(bytes.Repeat([]byte{0}, 6))
36201 length := len(encoder.Bytes()) - startIndex
36202
36203 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
36204
36205 return nil
36206}
36207
36208func DecodeQueuePropMaxRate(parent *QueueProp, decoder *goloxi.Decoder) (*QueuePropMaxRate, error) {
36209 _queuepropmaxrate := &QueuePropMaxRate{QueueProp: parent}
36210 if decoder.Length() < 12 {
36211 return nil, fmt.Errorf("QueuePropMaxRate packet too short: %d < 12", decoder.Length())
36212 }
36213 decoder.Skip(4)
36214 _queuepropmaxrate.Rate = uint16(decoder.ReadUint16())
36215 decoder.Skip(6)
36216 return _queuepropmaxrate, nil
36217}
36218
36219func NewQueuePropMaxRate() *QueuePropMaxRate {
36220 obj := &QueuePropMaxRate{
36221 QueueProp: NewQueueProp(2),
36222 }
36223 return obj
36224}
36225
36226type QueuePropMinRate struct {
36227 *QueueProp
36228 Rate uint16
36229}
36230
36231type IQueuePropMinRate interface {
36232 IQueueProp
36233 GetRate() uint16
36234}
36235
36236func (self *QueuePropMinRate) GetRate() uint16 {
36237 return self.Rate
36238}
36239
36240func (self *QueuePropMinRate) SetRate(v uint16) {
36241 self.Rate = v
36242}
36243
36244func (self *QueuePropMinRate) Serialize(encoder *goloxi.Encoder) error {
36245 startIndex := len(encoder.Bytes())
36246 if err := self.QueueProp.Serialize(encoder); err != nil {
36247 return err
36248 }
36249
36250 encoder.Write(bytes.Repeat([]byte{0}, 4))
36251 encoder.PutUint16(uint16(self.Rate))
36252 encoder.Write(bytes.Repeat([]byte{0}, 6))
36253 length := len(encoder.Bytes()) - startIndex
36254
36255 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
36256
36257 return nil
36258}
36259
36260func DecodeQueuePropMinRate(parent *QueueProp, decoder *goloxi.Decoder) (*QueuePropMinRate, error) {
36261 _queuepropminrate := &QueuePropMinRate{QueueProp: parent}
36262 if decoder.Length() < 12 {
36263 return nil, fmt.Errorf("QueuePropMinRate packet too short: %d < 12", decoder.Length())
36264 }
36265 decoder.Skip(4)
36266 _queuepropminrate.Rate = uint16(decoder.ReadUint16())
36267 decoder.Skip(6)
36268 return _queuepropminrate, nil
36269}
36270
36271func NewQueuePropMinRate() *QueuePropMinRate {
36272 obj := &QueuePropMinRate{
36273 QueueProp: NewQueueProp(1),
36274 }
36275 return obj
36276}
36277
36278type QueueStatsEntry struct {
36279 Length uint16
36280 PortNo Port
36281 QueueId uint32
36282 TxBytes uint64
36283 TxPackets uint64
36284 TxErrors uint64
36285 DurationSec uint32
36286 DurationNsec uint32
36287 Properties []IQueueStatsProp
36288}
36289
36290type IQueueStatsEntry interface {
36291 goloxi.Serializable
36292 GetLength() uint16
36293 GetPortNo() Port
36294 GetQueueId() uint32
36295 GetTxBytes() uint64
36296 GetTxPackets() uint64
36297 GetTxErrors() uint64
36298 GetDurationSec() uint32
36299 GetDurationNsec() uint32
36300 GetProperties() []IQueueStatsProp
36301}
36302
36303func (self *QueueStatsEntry) GetLength() uint16 {
36304 return self.Length
36305}
36306
36307func (self *QueueStatsEntry) SetLength(v uint16) {
36308 self.Length = v
36309}
36310
36311func (self *QueueStatsEntry) GetPortNo() Port {
36312 return self.PortNo
36313}
36314
36315func (self *QueueStatsEntry) SetPortNo(v Port) {
36316 self.PortNo = v
36317}
36318
36319func (self *QueueStatsEntry) GetQueueId() uint32 {
36320 return self.QueueId
36321}
36322
36323func (self *QueueStatsEntry) SetQueueId(v uint32) {
36324 self.QueueId = v
36325}
36326
36327func (self *QueueStatsEntry) GetTxBytes() uint64 {
36328 return self.TxBytes
36329}
36330
36331func (self *QueueStatsEntry) SetTxBytes(v uint64) {
36332 self.TxBytes = v
36333}
36334
36335func (self *QueueStatsEntry) GetTxPackets() uint64 {
36336 return self.TxPackets
36337}
36338
36339func (self *QueueStatsEntry) SetTxPackets(v uint64) {
36340 self.TxPackets = v
36341}
36342
36343func (self *QueueStatsEntry) GetTxErrors() uint64 {
36344 return self.TxErrors
36345}
36346
36347func (self *QueueStatsEntry) SetTxErrors(v uint64) {
36348 self.TxErrors = v
36349}
36350
36351func (self *QueueStatsEntry) GetDurationSec() uint32 {
36352 return self.DurationSec
36353}
36354
36355func (self *QueueStatsEntry) SetDurationSec(v uint32) {
36356 self.DurationSec = v
36357}
36358
36359func (self *QueueStatsEntry) GetDurationNsec() uint32 {
36360 return self.DurationNsec
36361}
36362
36363func (self *QueueStatsEntry) SetDurationNsec(v uint32) {
36364 self.DurationNsec = v
36365}
36366
36367func (self *QueueStatsEntry) GetProperties() []IQueueStatsProp {
36368 return self.Properties
36369}
36370
36371func (self *QueueStatsEntry) SetProperties(v []IQueueStatsProp) {
36372 self.Properties = v
36373}
36374
36375func (self *QueueStatsEntry) Serialize(encoder *goloxi.Encoder) error {
36376 startIndex := len(encoder.Bytes())
36377
36378 encoder.PutUint16(uint16(self.Length))
36379 encoder.Write(bytes.Repeat([]byte{0}, 6))
36380 self.PortNo.Serialize(encoder)
36381 encoder.PutUint32(uint32(self.QueueId))
36382 encoder.PutUint64(uint64(self.TxBytes))
36383 encoder.PutUint64(uint64(self.TxPackets))
36384 encoder.PutUint64(uint64(self.TxErrors))
36385 encoder.PutUint32(uint32(self.DurationSec))
36386 encoder.PutUint32(uint32(self.DurationNsec))
36387 for _, obj := range self.Properties {
36388 if err := obj.Serialize(encoder); err != nil {
36389 return err
36390 }
36391 }
36392 length := len(encoder.Bytes()) - startIndex
36393
36394 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
36395
36396 return nil
36397}
36398
36399func DecodeQueueStatsEntry(decoder *goloxi.Decoder) (*QueueStatsEntry, error) {
36400 _queuestatsentry := &QueueStatsEntry{}
36401 if decoder.Length() < 48 {
36402 return nil, fmt.Errorf("QueueStatsEntry packet too short: %d < 48", decoder.Length())
36403 }
36404 _queuestatsentry.Length = uint16(decoder.ReadUint16())
36405 oldDecoder := decoder
36406 defer func() { decoder = oldDecoder }()
36407 decoder = decoder.SliceDecoder(int(_queuestatsentry.Length), 2+0)
36408 decoder.Skip(6)
36409 _queuestatsentry.PortNo.Decode(decoder)
36410 _queuestatsentry.QueueId = uint32(decoder.ReadUint32())
36411 _queuestatsentry.TxBytes = uint64(decoder.ReadUint64())
36412 _queuestatsentry.TxPackets = uint64(decoder.ReadUint64())
36413 _queuestatsentry.TxErrors = uint64(decoder.ReadUint64())
36414 _queuestatsentry.DurationSec = uint32(decoder.ReadUint32())
36415 _queuestatsentry.DurationNsec = uint32(decoder.ReadUint32())
36416
36417 for decoder.Length() >= 4 {
36418 item, err := DecodeQueueStatsProp(decoder)
36419 if err != nil {
36420 return nil, err
36421 }
36422 if item != nil {
36423 _queuestatsentry.Properties = append(_queuestatsentry.Properties, item)
36424 }
36425 }
36426 return _queuestatsentry, nil
36427}
36428
36429func NewQueueStatsEntry() *QueueStatsEntry {
36430 obj := &QueueStatsEntry{}
36431 return obj
36432}
36433
36434type QueueStatsProp struct {
36435 Type uint16
36436 Length uint16
36437}
36438
36439type IQueueStatsProp interface {
36440 goloxi.Serializable
36441 GetType() uint16
36442 GetLength() uint16
36443}
36444
36445func (self *QueueStatsProp) GetType() uint16 {
36446 return self.Type
36447}
36448
36449func (self *QueueStatsProp) SetType(v uint16) {
36450 self.Type = v
36451}
36452
36453func (self *QueueStatsProp) GetLength() uint16 {
36454 return self.Length
36455}
36456
36457func (self *QueueStatsProp) SetLength(v uint16) {
36458 self.Length = v
36459}
36460
36461func (self *QueueStatsProp) Serialize(encoder *goloxi.Encoder) error {
36462
36463 encoder.PutUint16(uint16(self.Type))
36464 encoder.PutUint16(uint16(self.Length))
36465
36466 return nil
36467}
36468
36469func DecodeQueueStatsProp(decoder *goloxi.Decoder) (IQueueStatsProp, error) {
36470 _queuestatsprop := &QueueStatsProp{}
36471 if decoder.Length() < 4 {
36472 return nil, fmt.Errorf("QueueStatsProp packet too short: %d < 4", decoder.Length())
36473 }
36474 _queuestatsprop.Type = uint16(decoder.ReadUint16())
36475 _queuestatsprop.Length = uint16(decoder.ReadUint16())
36476 oldDecoder := decoder
36477 defer func() { decoder = oldDecoder }()
36478 decoder = decoder.SliceDecoder(int(_queuestatsprop.Length), 2+2)
36479
36480 switch _queuestatsprop.Type {
36481 case 65535:
36482 return DecodeQueueStatsPropExperimenter(_queuestatsprop, decoder)
36483 default:
36484 return nil, fmt.Errorf("Invalid type '%d' for 'QueueStatsProp'", _queuestatsprop.Type)
36485 }
36486}
36487
36488func NewQueueStatsProp(_type uint16) *QueueStatsProp {
36489 obj := &QueueStatsProp{}
36490 obj.Type = _type
36491 return obj
36492}
36493
36494type QueueStatsPropExperimenter struct {
36495 *QueueStatsProp
36496 Experimenter uint32
36497 ExpType uint32
36498}
36499
36500type IQueueStatsPropExperimenter interface {
36501 IQueueStatsProp
36502 GetExperimenter() uint32
36503 GetExpType() uint32
36504}
36505
36506func (self *QueueStatsPropExperimenter) GetExperimenter() uint32 {
36507 return self.Experimenter
36508}
36509
36510func (self *QueueStatsPropExperimenter) SetExperimenter(v uint32) {
36511 self.Experimenter = v
36512}
36513
36514func (self *QueueStatsPropExperimenter) GetExpType() uint32 {
36515 return self.ExpType
36516}
36517
36518func (self *QueueStatsPropExperimenter) SetExpType(v uint32) {
36519 self.ExpType = v
36520}
36521
36522func (self *QueueStatsPropExperimenter) Serialize(encoder *goloxi.Encoder) error {
36523 if err := self.QueueStatsProp.Serialize(encoder); err != nil {
36524 return err
36525 }
36526
36527 encoder.PutUint32(uint32(self.Experimenter))
36528 encoder.PutUint32(uint32(self.ExpType))
36529
36530 return nil
36531}
36532
36533func DecodeQueueStatsPropExperimenter(parent *QueueStatsProp, decoder *goloxi.Decoder) (IQueueStatsPropExperimenter, error) {
36534 _queuestatspropexperimenter := &QueueStatsPropExperimenter{QueueStatsProp: parent}
36535 if decoder.Length() < 8 {
36536 return nil, fmt.Errorf("QueueStatsPropExperimenter packet too short: %d < 8", decoder.Length())
36537 }
36538 _queuestatspropexperimenter.Experimenter = uint32(decoder.ReadUint32())
36539 _queuestatspropexperimenter.ExpType = uint32(decoder.ReadUint32())
36540 return _queuestatspropexperimenter, nil
36541}
36542
36543func NewQueueStatsPropExperimenter(_experimenter uint32) *QueueStatsPropExperimenter {
36544 obj := &QueueStatsPropExperimenter{
36545 QueueStatsProp: NewQueueStatsProp(65535),
36546 }
36547 obj.Experimenter = _experimenter
36548 return obj
36549}
36550
36551type RoleProp struct {
36552 Type uint16
36553 Length uint16
36554}
36555
36556type IRoleProp interface {
36557 goloxi.Serializable
36558 GetType() uint16
36559 GetLength() uint16
36560}
36561
36562func (self *RoleProp) GetType() uint16 {
36563 return self.Type
36564}
36565
36566func (self *RoleProp) SetType(v uint16) {
36567 self.Type = v
36568}
36569
36570func (self *RoleProp) GetLength() uint16 {
36571 return self.Length
36572}
36573
36574func (self *RoleProp) SetLength(v uint16) {
36575 self.Length = v
36576}
36577
36578func (self *RoleProp) Serialize(encoder *goloxi.Encoder) error {
36579
36580 encoder.PutUint16(uint16(self.Type))
36581 encoder.PutUint16(uint16(self.Length))
36582
36583 return nil
36584}
36585
36586func DecodeRoleProp(decoder *goloxi.Decoder) (IRoleProp, error) {
36587 _roleprop := &RoleProp{}
36588 if decoder.Length() < 4 {
36589 return nil, fmt.Errorf("RoleProp packet too short: %d < 4", decoder.Length())
36590 }
36591 _roleprop.Type = uint16(decoder.ReadUint16())
36592 _roleprop.Length = uint16(decoder.ReadUint16())
36593 oldDecoder := decoder
36594 defer func() { decoder = oldDecoder }()
36595 decoder = decoder.SliceDecoder(int(_roleprop.Length), 2+2)
36596
36597 switch _roleprop.Type {
36598 case 65535:
36599 return DecodeRolePropExperimenter(_roleprop, decoder)
36600 default:
36601 return nil, fmt.Errorf("Invalid type '%d' for 'RoleProp'", _roleprop.Type)
36602 }
36603}
36604
36605func NewRoleProp(_type uint16) *RoleProp {
36606 obj := &RoleProp{}
36607 obj.Type = _type
36608 return obj
36609}
36610
36611type RolePropExperimenter struct {
36612 *RoleProp
36613 Experimenter uint32
36614 ExpType uint32
36615}
36616
36617type IRolePropExperimenter interface {
36618 IRoleProp
36619 GetExperimenter() uint32
36620 GetExpType() uint32
36621}
36622
36623func (self *RolePropExperimenter) GetExperimenter() uint32 {
36624 return self.Experimenter
36625}
36626
36627func (self *RolePropExperimenter) SetExperimenter(v uint32) {
36628 self.Experimenter = v
36629}
36630
36631func (self *RolePropExperimenter) GetExpType() uint32 {
36632 return self.ExpType
36633}
36634
36635func (self *RolePropExperimenter) SetExpType(v uint32) {
36636 self.ExpType = v
36637}
36638
36639func (self *RolePropExperimenter) Serialize(encoder *goloxi.Encoder) error {
36640 if err := self.RoleProp.Serialize(encoder); err != nil {
36641 return err
36642 }
36643
36644 encoder.PutUint32(uint32(self.Experimenter))
36645 encoder.PutUint32(uint32(self.ExpType))
36646
36647 return nil
36648}
36649
36650func DecodeRolePropExperimenter(parent *RoleProp, decoder *goloxi.Decoder) (IRolePropExperimenter, error) {
36651 _rolepropexperimenter := &RolePropExperimenter{RoleProp: parent}
36652 if decoder.Length() < 8 {
36653 return nil, fmt.Errorf("RolePropExperimenter packet too short: %d < 8", decoder.Length())
36654 }
36655 _rolepropexperimenter.Experimenter = uint32(decoder.ReadUint32())
36656 _rolepropexperimenter.ExpType = uint32(decoder.ReadUint32())
36657 return _rolepropexperimenter, nil
36658}
36659
36660func NewRolePropExperimenter(_experimenter uint32) *RolePropExperimenter {
36661 obj := &RolePropExperimenter{
36662 RoleProp: NewRoleProp(65535),
36663 }
36664 obj.Experimenter = _experimenter
36665 return obj
36666}
36667
36668type TableDesc struct {
36669 Length uint16
36670 TableId uint8
36671 Config TableConfig
36672}
36673
36674type ITableDesc interface {
36675 goloxi.Serializable
36676 GetLength() uint16
36677 GetTableId() uint8
36678 GetConfig() TableConfig
36679}
36680
36681func (self *TableDesc) GetLength() uint16 {
36682 return self.Length
36683}
36684
36685func (self *TableDesc) SetLength(v uint16) {
36686 self.Length = v
36687}
36688
36689func (self *TableDesc) GetTableId() uint8 {
36690 return self.TableId
36691}
36692
36693func (self *TableDesc) SetTableId(v uint8) {
36694 self.TableId = v
36695}
36696
36697func (self *TableDesc) GetConfig() TableConfig {
36698 return self.Config
36699}
36700
36701func (self *TableDesc) SetConfig(v TableConfig) {
36702 self.Config = v
36703}
36704
36705func (self *TableDesc) Serialize(encoder *goloxi.Encoder) error {
36706 startIndex := len(encoder.Bytes())
36707
36708 encoder.PutUint16(uint16(self.Length))
36709 encoder.PutUint8(uint8(self.TableId))
36710 encoder.Write(bytes.Repeat([]byte{0}, 1))
36711 encoder.PutUint32(uint32(self.Config))
36712 length := len(encoder.Bytes()) - startIndex
36713
36714 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
36715
36716 return nil
36717}
36718func (self *TableDesc) Decode(decoder *goloxi.Decoder) error {
36719 if decoder.Length() < 8 {
36720 return fmt.Errorf("TableDesc packet too short: %d < 8", decoder.Length())
36721 }
36722
36723 self.Length = uint16(decoder.ReadUint16())
36724 oldDecoder := decoder
36725 defer func() { decoder = oldDecoder }()
36726 decoder = decoder.SliceDecoder(int(self.Length), 2+0)
36727 self.TableId = uint8(decoder.ReadByte())
36728 decoder.Skip(1)
36729 self.Config = TableConfig(decoder.ReadUint32())
36730
36731 return nil
36732}
36733
36734func NewTableDesc() *TableDesc {
36735 obj := &TableDesc{}
36736 return obj
36737}
36738
36739type TableFeatureProp struct {
36740 Type uint16
36741 Length uint16
36742}
36743
36744type ITableFeatureProp interface {
36745 goloxi.Serializable
36746 GetType() uint16
36747 GetLength() uint16
36748}
36749
36750func (self *TableFeatureProp) GetType() uint16 {
36751 return self.Type
36752}
36753
36754func (self *TableFeatureProp) SetType(v uint16) {
36755 self.Type = v
36756}
36757
36758func (self *TableFeatureProp) GetLength() uint16 {
36759 return self.Length
36760}
36761
36762func (self *TableFeatureProp) SetLength(v uint16) {
36763 self.Length = v
36764}
36765
36766func (self *TableFeatureProp) Serialize(encoder *goloxi.Encoder) error {
36767
36768 encoder.PutUint16(uint16(self.Type))
36769 encoder.PutUint16(uint16(self.Length))
36770
36771 return nil
36772}
36773
36774func DecodeTableFeatureProp(decoder *goloxi.Decoder) (ITableFeatureProp, error) {
36775 _tablefeatureprop := &TableFeatureProp{}
36776 if decoder.Length() < 4 {
36777 return nil, fmt.Errorf("TableFeatureProp packet too short: %d < 4", decoder.Length())
36778 }
36779 _tablefeatureprop.Type = uint16(decoder.ReadUint16())
36780 _tablefeatureprop.Length = uint16(decoder.ReadUint16())
36781 oldDecoder := decoder
36782 defer func() { decoder = oldDecoder }()
36783 decoder = decoder.SliceDecoder(int(_tablefeatureprop.Length), 2+2)
36784
36785 switch _tablefeatureprop.Type {
36786 case 0:
36787 return DecodeTableFeaturePropInstructions(_tablefeatureprop, decoder)
36788 case 1:
36789 return DecodeTableFeaturePropInstructionsMiss(_tablefeatureprop, decoder)
36790 case 2:
36791 return DecodeTableFeaturePropNextTables(_tablefeatureprop, decoder)
36792 case 3:
36793 return DecodeTableFeaturePropNextTablesMiss(_tablefeatureprop, decoder)
36794 case 4:
36795 return DecodeTableFeaturePropWriteActions(_tablefeatureprop, decoder)
36796 case 5:
36797 return DecodeTableFeaturePropWriteActionsMiss(_tablefeatureprop, decoder)
36798 case 6:
36799 return DecodeTableFeaturePropApplyActions(_tablefeatureprop, decoder)
36800 case 7:
36801 return DecodeTableFeaturePropApplyActionsMiss(_tablefeatureprop, decoder)
36802 case 8:
36803 return DecodeTableFeaturePropMatch(_tablefeatureprop, decoder)
36804 case 10:
36805 return DecodeTableFeaturePropWildcards(_tablefeatureprop, decoder)
36806 case 12:
36807 return DecodeTableFeaturePropWriteSetfield(_tablefeatureprop, decoder)
36808 case 13:
36809 return DecodeTableFeaturePropWriteSetfieldMiss(_tablefeatureprop, decoder)
36810 case 14:
36811 return DecodeTableFeaturePropApplySetfield(_tablefeatureprop, decoder)
36812 case 15:
36813 return DecodeTableFeaturePropApplySetfieldMiss(_tablefeatureprop, decoder)
36814 case 16:
36815 return DecodeTableFeaturePropTableSyncFrom(_tablefeatureprop, decoder)
36816 case 65534:
36817 return DecodeTableFeaturePropExperimenter(_tablefeatureprop, decoder)
36818 case 65535:
36819 return DecodeTableFeaturePropExperimenterMiss(_tablefeatureprop, decoder)
36820 default:
36821 return nil, fmt.Errorf("Invalid type '%d' for 'TableFeatureProp'", _tablefeatureprop.Type)
36822 }
36823}
36824
36825func NewTableFeatureProp(_type uint16) *TableFeatureProp {
36826 obj := &TableFeatureProp{}
36827 obj.Type = _type
36828 return obj
36829}
36830
36831type TableFeaturePropApplyActions struct {
36832 *TableFeatureProp
36833 ActionIds []IActionId
36834}
36835
36836type ITableFeaturePropApplyActions interface {
36837 ITableFeatureProp
36838 GetActionIds() []IActionId
36839}
36840
36841func (self *TableFeaturePropApplyActions) GetActionIds() []IActionId {
36842 return self.ActionIds
36843}
36844
36845func (self *TableFeaturePropApplyActions) SetActionIds(v []IActionId) {
36846 self.ActionIds = v
36847}
36848
36849func (self *TableFeaturePropApplyActions) Serialize(encoder *goloxi.Encoder) error {
36850 startIndex := len(encoder.Bytes())
36851 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
36852 return err
36853 }
36854
36855 for _, obj := range self.ActionIds {
36856 if err := obj.Serialize(encoder); err != nil {
36857 return err
36858 }
36859 }
36860 length := len(encoder.Bytes()) - startIndex
36861 alignedLength := ((length + 7) / 8 * 8)
36862
36863 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
36864
36865 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
36866
36867 return nil
36868}
36869
36870func DecodeTableFeaturePropApplyActions(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropApplyActions, error) {
36871 _tablefeaturepropapplyactions := &TableFeaturePropApplyActions{TableFeatureProp: parent}
36872 defer decoder.SkipAlign()
36873
36874 for decoder.Length() >= 4 {
36875 item, err := DecodeActionId(decoder)
36876 if err != nil {
36877 return nil, err
36878 }
36879 if item != nil {
36880 _tablefeaturepropapplyactions.ActionIds = append(_tablefeaturepropapplyactions.ActionIds, item)
36881 }
36882 }
36883 return _tablefeaturepropapplyactions, nil
36884}
36885
36886func NewTableFeaturePropApplyActions() *TableFeaturePropApplyActions {
36887 obj := &TableFeaturePropApplyActions{
36888 TableFeatureProp: NewTableFeatureProp(6),
36889 }
36890 return obj
36891}
36892
36893type TableFeaturePropApplyActionsMiss struct {
36894 *TableFeatureProp
36895 ActionIds []IActionId
36896}
36897
36898type ITableFeaturePropApplyActionsMiss interface {
36899 ITableFeatureProp
36900 GetActionIds() []IActionId
36901}
36902
36903func (self *TableFeaturePropApplyActionsMiss) GetActionIds() []IActionId {
36904 return self.ActionIds
36905}
36906
36907func (self *TableFeaturePropApplyActionsMiss) SetActionIds(v []IActionId) {
36908 self.ActionIds = v
36909}
36910
36911func (self *TableFeaturePropApplyActionsMiss) Serialize(encoder *goloxi.Encoder) error {
36912 startIndex := len(encoder.Bytes())
36913 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
36914 return err
36915 }
36916
36917 for _, obj := range self.ActionIds {
36918 if err := obj.Serialize(encoder); err != nil {
36919 return err
36920 }
36921 }
36922 length := len(encoder.Bytes()) - startIndex
36923 alignedLength := ((length + 7) / 8 * 8)
36924
36925 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
36926
36927 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
36928
36929 return nil
36930}
36931
36932func DecodeTableFeaturePropApplyActionsMiss(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropApplyActionsMiss, error) {
36933 _tablefeaturepropapplyactionsmiss := &TableFeaturePropApplyActionsMiss{TableFeatureProp: parent}
36934 defer decoder.SkipAlign()
36935
36936 for decoder.Length() >= 4 {
36937 item, err := DecodeActionId(decoder)
36938 if err != nil {
36939 return nil, err
36940 }
36941 if item != nil {
36942 _tablefeaturepropapplyactionsmiss.ActionIds = append(_tablefeaturepropapplyactionsmiss.ActionIds, item)
36943 }
36944 }
36945 return _tablefeaturepropapplyactionsmiss, nil
36946}
36947
36948func NewTableFeaturePropApplyActionsMiss() *TableFeaturePropApplyActionsMiss {
36949 obj := &TableFeaturePropApplyActionsMiss{
36950 TableFeatureProp: NewTableFeatureProp(7),
36951 }
36952 return obj
36953}
36954
36955type TableFeaturePropApplySetfield struct {
36956 *TableFeatureProp
36957 OxmIds []*Uint32
36958}
36959
36960type ITableFeaturePropApplySetfield interface {
36961 ITableFeatureProp
36962 GetOxmIds() []*Uint32
36963}
36964
36965func (self *TableFeaturePropApplySetfield) GetOxmIds() []*Uint32 {
36966 return self.OxmIds
36967}
36968
36969func (self *TableFeaturePropApplySetfield) SetOxmIds(v []*Uint32) {
36970 self.OxmIds = v
36971}
36972
36973func (self *TableFeaturePropApplySetfield) Serialize(encoder *goloxi.Encoder) error {
36974 startIndex := len(encoder.Bytes())
36975 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
36976 return err
36977 }
36978
36979 for _, obj := range self.OxmIds {
36980 if err := obj.Serialize(encoder); err != nil {
36981 return err
36982 }
36983 }
36984 length := len(encoder.Bytes()) - startIndex
36985 alignedLength := ((length + 7) / 8 * 8)
36986
36987 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
36988
36989 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
36990
36991 return nil
36992}
36993
36994func DecodeTableFeaturePropApplySetfield(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropApplySetfield, error) {
36995 _tablefeaturepropapplysetfield := &TableFeaturePropApplySetfield{TableFeatureProp: parent}
36996 defer decoder.SkipAlign()
36997
36998 for decoder.Length() >= 4 {
36999 item, err := DecodeUint32(decoder)
37000 if err != nil {
37001 return nil, err
37002 }
37003 if item != nil {
37004 _tablefeaturepropapplysetfield.OxmIds = append(_tablefeaturepropapplysetfield.OxmIds, item)
37005 }
37006 }
37007 return _tablefeaturepropapplysetfield, nil
37008}
37009
37010func NewTableFeaturePropApplySetfield() *TableFeaturePropApplySetfield {
37011 obj := &TableFeaturePropApplySetfield{
37012 TableFeatureProp: NewTableFeatureProp(14),
37013 }
37014 return obj
37015}
37016
37017type TableFeaturePropApplySetfieldMiss struct {
37018 *TableFeatureProp
37019 OxmIds []*Uint32
37020}
37021
37022type ITableFeaturePropApplySetfieldMiss interface {
37023 ITableFeatureProp
37024 GetOxmIds() []*Uint32
37025}
37026
37027func (self *TableFeaturePropApplySetfieldMiss) GetOxmIds() []*Uint32 {
37028 return self.OxmIds
37029}
37030
37031func (self *TableFeaturePropApplySetfieldMiss) SetOxmIds(v []*Uint32) {
37032 self.OxmIds = v
37033}
37034
37035func (self *TableFeaturePropApplySetfieldMiss) Serialize(encoder *goloxi.Encoder) error {
37036 startIndex := len(encoder.Bytes())
37037 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
37038 return err
37039 }
37040
37041 for _, obj := range self.OxmIds {
37042 if err := obj.Serialize(encoder); err != nil {
37043 return err
37044 }
37045 }
37046 length := len(encoder.Bytes()) - startIndex
37047 alignedLength := ((length + 7) / 8 * 8)
37048
37049 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
37050
37051 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
37052
37053 return nil
37054}
37055
37056func DecodeTableFeaturePropApplySetfieldMiss(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropApplySetfieldMiss, error) {
37057 _tablefeaturepropapplysetfieldmiss := &TableFeaturePropApplySetfieldMiss{TableFeatureProp: parent}
37058 defer decoder.SkipAlign()
37059
37060 for decoder.Length() >= 4 {
37061 item, err := DecodeUint32(decoder)
37062 if err != nil {
37063 return nil, err
37064 }
37065 if item != nil {
37066 _tablefeaturepropapplysetfieldmiss.OxmIds = append(_tablefeaturepropapplysetfieldmiss.OxmIds, item)
37067 }
37068 }
37069 return _tablefeaturepropapplysetfieldmiss, nil
37070}
37071
37072func NewTableFeaturePropApplySetfieldMiss() *TableFeaturePropApplySetfieldMiss {
37073 obj := &TableFeaturePropApplySetfieldMiss{
37074 TableFeatureProp: NewTableFeatureProp(15),
37075 }
37076 return obj
37077}
37078
37079type TableFeaturePropExperimenter struct {
37080 *TableFeatureProp
37081 Experimenter uint32
37082 Subtype uint32
37083}
37084
37085type ITableFeaturePropExperimenter interface {
37086 ITableFeatureProp
37087 GetExperimenter() uint32
37088 GetSubtype() uint32
37089}
37090
37091func (self *TableFeaturePropExperimenter) GetExperimenter() uint32 {
37092 return self.Experimenter
37093}
37094
37095func (self *TableFeaturePropExperimenter) SetExperimenter(v uint32) {
37096 self.Experimenter = v
37097}
37098
37099func (self *TableFeaturePropExperimenter) GetSubtype() uint32 {
37100 return self.Subtype
37101}
37102
37103func (self *TableFeaturePropExperimenter) SetSubtype(v uint32) {
37104 self.Subtype = v
37105}
37106
37107func (self *TableFeaturePropExperimenter) Serialize(encoder *goloxi.Encoder) error {
37108 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
37109 return err
37110 }
37111
37112 encoder.PutUint32(uint32(self.Experimenter))
37113 encoder.PutUint32(uint32(self.Subtype))
37114
37115 return nil
37116}
37117
37118func DecodeTableFeaturePropExperimenter(parent *TableFeatureProp, decoder *goloxi.Decoder) (ITableFeaturePropExperimenter, error) {
37119 _tablefeaturepropexperimenter := &TableFeaturePropExperimenter{TableFeatureProp: parent}
37120 if decoder.Length() < 8 {
37121 return nil, fmt.Errorf("TableFeaturePropExperimenter packet too short: %d < 8", decoder.Length())
37122 }
37123 defer decoder.SkipAlign()
37124
37125 _tablefeaturepropexperimenter.Experimenter = uint32(decoder.ReadUint32())
37126 _tablefeaturepropexperimenter.Subtype = uint32(decoder.ReadUint32())
37127 return _tablefeaturepropexperimenter, nil
37128}
37129
37130func NewTableFeaturePropExperimenter(_experimenter uint32) *TableFeaturePropExperimenter {
37131 obj := &TableFeaturePropExperimenter{
37132 TableFeatureProp: NewTableFeatureProp(65534),
37133 }
37134 obj.Experimenter = _experimenter
37135 return obj
37136}
37137
37138type TableFeaturePropExperimenterMiss struct {
37139 *TableFeatureProp
37140 Experimenter uint32
37141 Subtype uint32
37142}
37143
37144type ITableFeaturePropExperimenterMiss interface {
37145 ITableFeatureProp
37146 GetExperimenter() uint32
37147 GetSubtype() uint32
37148}
37149
37150func (self *TableFeaturePropExperimenterMiss) GetExperimenter() uint32 {
37151 return self.Experimenter
37152}
37153
37154func (self *TableFeaturePropExperimenterMiss) SetExperimenter(v uint32) {
37155 self.Experimenter = v
37156}
37157
37158func (self *TableFeaturePropExperimenterMiss) GetSubtype() uint32 {
37159 return self.Subtype
37160}
37161
37162func (self *TableFeaturePropExperimenterMiss) SetSubtype(v uint32) {
37163 self.Subtype = v
37164}
37165
37166func (self *TableFeaturePropExperimenterMiss) Serialize(encoder *goloxi.Encoder) error {
37167 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
37168 return err
37169 }
37170
37171 encoder.PutUint32(uint32(self.Experimenter))
37172 encoder.PutUint32(uint32(self.Subtype))
37173
37174 return nil
37175}
37176
37177func DecodeTableFeaturePropExperimenterMiss(parent *TableFeatureProp, decoder *goloxi.Decoder) (ITableFeaturePropExperimenterMiss, error) {
37178 _tablefeaturepropexperimentermiss := &TableFeaturePropExperimenterMiss{TableFeatureProp: parent}
37179 if decoder.Length() < 8 {
37180 return nil, fmt.Errorf("TableFeaturePropExperimenterMiss packet too short: %d < 8", decoder.Length())
37181 }
37182 defer decoder.SkipAlign()
37183
37184 _tablefeaturepropexperimentermiss.Experimenter = uint32(decoder.ReadUint32())
37185 _tablefeaturepropexperimentermiss.Subtype = uint32(decoder.ReadUint32())
37186 return _tablefeaturepropexperimentermiss, nil
37187}
37188
37189func NewTableFeaturePropExperimenterMiss(_experimenter uint32) *TableFeaturePropExperimenterMiss {
37190 obj := &TableFeaturePropExperimenterMiss{
37191 TableFeatureProp: NewTableFeatureProp(65535),
37192 }
37193 obj.Experimenter = _experimenter
37194 return obj
37195}
37196
37197type TableFeaturePropInstructions struct {
37198 *TableFeatureProp
37199 InstructionIds []IInstructionId
37200}
37201
37202type ITableFeaturePropInstructions interface {
37203 ITableFeatureProp
37204 GetInstructionIds() []IInstructionId
37205}
37206
37207func (self *TableFeaturePropInstructions) GetInstructionIds() []IInstructionId {
37208 return self.InstructionIds
37209}
37210
37211func (self *TableFeaturePropInstructions) SetInstructionIds(v []IInstructionId) {
37212 self.InstructionIds = v
37213}
37214
37215func (self *TableFeaturePropInstructions) Serialize(encoder *goloxi.Encoder) error {
37216 startIndex := len(encoder.Bytes())
37217 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
37218 return err
37219 }
37220
37221 for _, obj := range self.InstructionIds {
37222 if err := obj.Serialize(encoder); err != nil {
37223 return err
37224 }
37225 }
37226 length := len(encoder.Bytes()) - startIndex
37227 alignedLength := ((length + 7) / 8 * 8)
37228
37229 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
37230
37231 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
37232
37233 return nil
37234}
37235
37236func DecodeTableFeaturePropInstructions(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropInstructions, error) {
37237 _tablefeaturepropinstructions := &TableFeaturePropInstructions{TableFeatureProp: parent}
37238 defer decoder.SkipAlign()
37239
37240 for decoder.Length() >= 4 {
37241 item, err := DecodeInstructionId(decoder)
37242 if err != nil {
37243 return nil, err
37244 }
37245 if item != nil {
37246 _tablefeaturepropinstructions.InstructionIds = append(_tablefeaturepropinstructions.InstructionIds, item)
37247 }
37248 }
37249 return _tablefeaturepropinstructions, nil
37250}
37251
37252func NewTableFeaturePropInstructions() *TableFeaturePropInstructions {
37253 obj := &TableFeaturePropInstructions{
37254 TableFeatureProp: NewTableFeatureProp(0),
37255 }
37256 return obj
37257}
37258
37259type TableFeaturePropInstructionsMiss struct {
37260 *TableFeatureProp
37261 InstructionIds []IInstructionId
37262}
37263
37264type ITableFeaturePropInstructionsMiss interface {
37265 ITableFeatureProp
37266 GetInstructionIds() []IInstructionId
37267}
37268
37269func (self *TableFeaturePropInstructionsMiss) GetInstructionIds() []IInstructionId {
37270 return self.InstructionIds
37271}
37272
37273func (self *TableFeaturePropInstructionsMiss) SetInstructionIds(v []IInstructionId) {
37274 self.InstructionIds = v
37275}
37276
37277func (self *TableFeaturePropInstructionsMiss) Serialize(encoder *goloxi.Encoder) error {
37278 startIndex := len(encoder.Bytes())
37279 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
37280 return err
37281 }
37282
37283 for _, obj := range self.InstructionIds {
37284 if err := obj.Serialize(encoder); err != nil {
37285 return err
37286 }
37287 }
37288 length := len(encoder.Bytes()) - startIndex
37289 alignedLength := ((length + 7) / 8 * 8)
37290
37291 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
37292
37293 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
37294
37295 return nil
37296}
37297
37298func DecodeTableFeaturePropInstructionsMiss(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropInstructionsMiss, error) {
37299 _tablefeaturepropinstructionsmiss := &TableFeaturePropInstructionsMiss{TableFeatureProp: parent}
37300 defer decoder.SkipAlign()
37301
37302 for decoder.Length() >= 4 {
37303 item, err := DecodeInstructionId(decoder)
37304 if err != nil {
37305 return nil, err
37306 }
37307 if item != nil {
37308 _tablefeaturepropinstructionsmiss.InstructionIds = append(_tablefeaturepropinstructionsmiss.InstructionIds, item)
37309 }
37310 }
37311 return _tablefeaturepropinstructionsmiss, nil
37312}
37313
37314func NewTableFeaturePropInstructionsMiss() *TableFeaturePropInstructionsMiss {
37315 obj := &TableFeaturePropInstructionsMiss{
37316 TableFeatureProp: NewTableFeatureProp(1),
37317 }
37318 return obj
37319}
37320
37321type TableFeaturePropMatch struct {
37322 *TableFeatureProp
37323 OxmIds []*Uint32
37324}
37325
37326type ITableFeaturePropMatch interface {
37327 ITableFeatureProp
37328 GetOxmIds() []*Uint32
37329}
37330
37331func (self *TableFeaturePropMatch) GetOxmIds() []*Uint32 {
37332 return self.OxmIds
37333}
37334
37335func (self *TableFeaturePropMatch) SetOxmIds(v []*Uint32) {
37336 self.OxmIds = v
37337}
37338
37339func (self *TableFeaturePropMatch) Serialize(encoder *goloxi.Encoder) error {
37340 startIndex := len(encoder.Bytes())
37341 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
37342 return err
37343 }
37344
37345 for _, obj := range self.OxmIds {
37346 if err := obj.Serialize(encoder); err != nil {
37347 return err
37348 }
37349 }
37350 length := len(encoder.Bytes()) - startIndex
37351 alignedLength := ((length + 7) / 8 * 8)
37352
37353 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
37354
37355 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
37356
37357 return nil
37358}
37359
37360func DecodeTableFeaturePropMatch(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropMatch, error) {
37361 _tablefeaturepropmatch := &TableFeaturePropMatch{TableFeatureProp: parent}
37362 defer decoder.SkipAlign()
37363
37364 for decoder.Length() >= 4 {
37365 item, err := DecodeUint32(decoder)
37366 if err != nil {
37367 return nil, err
37368 }
37369 if item != nil {
37370 _tablefeaturepropmatch.OxmIds = append(_tablefeaturepropmatch.OxmIds, item)
37371 }
37372 }
37373 return _tablefeaturepropmatch, nil
37374}
37375
37376func NewTableFeaturePropMatch() *TableFeaturePropMatch {
37377 obj := &TableFeaturePropMatch{
37378 TableFeatureProp: NewTableFeatureProp(8),
37379 }
37380 return obj
37381}
37382
37383type TableFeaturePropNextTables struct {
37384 *TableFeatureProp
37385 NextTableIds []*Uint8
37386}
37387
37388type ITableFeaturePropNextTables interface {
37389 ITableFeatureProp
37390 GetNextTableIds() []*Uint8
37391}
37392
37393func (self *TableFeaturePropNextTables) GetNextTableIds() []*Uint8 {
37394 return self.NextTableIds
37395}
37396
37397func (self *TableFeaturePropNextTables) SetNextTableIds(v []*Uint8) {
37398 self.NextTableIds = v
37399}
37400
37401func (self *TableFeaturePropNextTables) Serialize(encoder *goloxi.Encoder) error {
37402 startIndex := len(encoder.Bytes())
37403 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
37404 return err
37405 }
37406
37407 for _, obj := range self.NextTableIds {
37408 if err := obj.Serialize(encoder); err != nil {
37409 return err
37410 }
37411 }
37412 length := len(encoder.Bytes()) - startIndex
37413 alignedLength := ((length + 7) / 8 * 8)
37414
37415 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
37416
37417 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
37418
37419 return nil
37420}
37421
37422func DecodeTableFeaturePropNextTables(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropNextTables, error) {
37423 _tablefeaturepropnexttables := &TableFeaturePropNextTables{TableFeatureProp: parent}
37424 defer decoder.SkipAlign()
37425
37426 for decoder.Length() >= 1 {
37427 item, err := DecodeUint8(decoder)
37428 if err != nil {
37429 return nil, err
37430 }
37431 if item != nil {
37432 _tablefeaturepropnexttables.NextTableIds = append(_tablefeaturepropnexttables.NextTableIds, item)
37433 }
37434 }
37435 return _tablefeaturepropnexttables, nil
37436}
37437
37438func NewTableFeaturePropNextTables() *TableFeaturePropNextTables {
37439 obj := &TableFeaturePropNextTables{
37440 TableFeatureProp: NewTableFeatureProp(2),
37441 }
37442 return obj
37443}
37444
37445type TableFeaturePropNextTablesMiss struct {
37446 *TableFeatureProp
37447 NextTableIds []*Uint8
37448}
37449
37450type ITableFeaturePropNextTablesMiss interface {
37451 ITableFeatureProp
37452 GetNextTableIds() []*Uint8
37453}
37454
37455func (self *TableFeaturePropNextTablesMiss) GetNextTableIds() []*Uint8 {
37456 return self.NextTableIds
37457}
37458
37459func (self *TableFeaturePropNextTablesMiss) SetNextTableIds(v []*Uint8) {
37460 self.NextTableIds = v
37461}
37462
37463func (self *TableFeaturePropNextTablesMiss) Serialize(encoder *goloxi.Encoder) error {
37464 startIndex := len(encoder.Bytes())
37465 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
37466 return err
37467 }
37468
37469 for _, obj := range self.NextTableIds {
37470 if err := obj.Serialize(encoder); err != nil {
37471 return err
37472 }
37473 }
37474 length := len(encoder.Bytes()) - startIndex
37475 alignedLength := ((length + 7) / 8 * 8)
37476
37477 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
37478
37479 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
37480
37481 return nil
37482}
37483
37484func DecodeTableFeaturePropNextTablesMiss(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropNextTablesMiss, error) {
37485 _tablefeaturepropnexttablesmiss := &TableFeaturePropNextTablesMiss{TableFeatureProp: parent}
37486 defer decoder.SkipAlign()
37487
37488 for decoder.Length() >= 1 {
37489 item, err := DecodeUint8(decoder)
37490 if err != nil {
37491 return nil, err
37492 }
37493 if item != nil {
37494 _tablefeaturepropnexttablesmiss.NextTableIds = append(_tablefeaturepropnexttablesmiss.NextTableIds, item)
37495 }
37496 }
37497 return _tablefeaturepropnexttablesmiss, nil
37498}
37499
37500func NewTableFeaturePropNextTablesMiss() *TableFeaturePropNextTablesMiss {
37501 obj := &TableFeaturePropNextTablesMiss{
37502 TableFeatureProp: NewTableFeatureProp(3),
37503 }
37504 return obj
37505}
37506
37507type TableFeaturePropTableSyncFrom struct {
37508 *TableFeatureProp
37509 TableIds []*Uint8
37510}
37511
37512type ITableFeaturePropTableSyncFrom interface {
37513 ITableFeatureProp
37514 GetTableIds() []*Uint8
37515}
37516
37517func (self *TableFeaturePropTableSyncFrom) GetTableIds() []*Uint8 {
37518 return self.TableIds
37519}
37520
37521func (self *TableFeaturePropTableSyncFrom) SetTableIds(v []*Uint8) {
37522 self.TableIds = v
37523}
37524
37525func (self *TableFeaturePropTableSyncFrom) Serialize(encoder *goloxi.Encoder) error {
37526 startIndex := len(encoder.Bytes())
37527 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
37528 return err
37529 }
37530
37531 for _, obj := range self.TableIds {
37532 if err := obj.Serialize(encoder); err != nil {
37533 return err
37534 }
37535 }
37536 length := len(encoder.Bytes()) - startIndex
37537 alignedLength := ((length + 7) / 8 * 8)
37538
37539 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
37540
37541 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
37542
37543 return nil
37544}
37545
37546func DecodeTableFeaturePropTableSyncFrom(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropTableSyncFrom, error) {
37547 _tablefeatureproptablesyncfrom := &TableFeaturePropTableSyncFrom{TableFeatureProp: parent}
37548 defer decoder.SkipAlign()
37549
37550 for decoder.Length() >= 1 {
37551 item, err := DecodeUint8(decoder)
37552 if err != nil {
37553 return nil, err
37554 }
37555 if item != nil {
37556 _tablefeatureproptablesyncfrom.TableIds = append(_tablefeatureproptablesyncfrom.TableIds, item)
37557 }
37558 }
37559 return _tablefeatureproptablesyncfrom, nil
37560}
37561
37562func NewTableFeaturePropTableSyncFrom() *TableFeaturePropTableSyncFrom {
37563 obj := &TableFeaturePropTableSyncFrom{
37564 TableFeatureProp: NewTableFeatureProp(16),
37565 }
37566 return obj
37567}
37568
37569type TableFeaturePropWildcards struct {
37570 *TableFeatureProp
37571 OxmIds []*Uint32
37572}
37573
37574type ITableFeaturePropWildcards interface {
37575 ITableFeatureProp
37576 GetOxmIds() []*Uint32
37577}
37578
37579func (self *TableFeaturePropWildcards) GetOxmIds() []*Uint32 {
37580 return self.OxmIds
37581}
37582
37583func (self *TableFeaturePropWildcards) SetOxmIds(v []*Uint32) {
37584 self.OxmIds = v
37585}
37586
37587func (self *TableFeaturePropWildcards) Serialize(encoder *goloxi.Encoder) error {
37588 startIndex := len(encoder.Bytes())
37589 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
37590 return err
37591 }
37592
37593 for _, obj := range self.OxmIds {
37594 if err := obj.Serialize(encoder); err != nil {
37595 return err
37596 }
37597 }
37598 length := len(encoder.Bytes()) - startIndex
37599 alignedLength := ((length + 7) / 8 * 8)
37600
37601 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
37602
37603 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
37604
37605 return nil
37606}
37607
37608func DecodeTableFeaturePropWildcards(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropWildcards, error) {
37609 _tablefeaturepropwildcards := &TableFeaturePropWildcards{TableFeatureProp: parent}
37610 defer decoder.SkipAlign()
37611
37612 for decoder.Length() >= 4 {
37613 item, err := DecodeUint32(decoder)
37614 if err != nil {
37615 return nil, err
37616 }
37617 if item != nil {
37618 _tablefeaturepropwildcards.OxmIds = append(_tablefeaturepropwildcards.OxmIds, item)
37619 }
37620 }
37621 return _tablefeaturepropwildcards, nil
37622}
37623
37624func NewTableFeaturePropWildcards() *TableFeaturePropWildcards {
37625 obj := &TableFeaturePropWildcards{
37626 TableFeatureProp: NewTableFeatureProp(10),
37627 }
37628 return obj
37629}
37630
37631type TableFeaturePropWriteActions struct {
37632 *TableFeatureProp
37633 ActionIds []IActionId
37634}
37635
37636type ITableFeaturePropWriteActions interface {
37637 ITableFeatureProp
37638 GetActionIds() []IActionId
37639}
37640
37641func (self *TableFeaturePropWriteActions) GetActionIds() []IActionId {
37642 return self.ActionIds
37643}
37644
37645func (self *TableFeaturePropWriteActions) SetActionIds(v []IActionId) {
37646 self.ActionIds = v
37647}
37648
37649func (self *TableFeaturePropWriteActions) Serialize(encoder *goloxi.Encoder) error {
37650 startIndex := len(encoder.Bytes())
37651 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
37652 return err
37653 }
37654
37655 for _, obj := range self.ActionIds {
37656 if err := obj.Serialize(encoder); err != nil {
37657 return err
37658 }
37659 }
37660 length := len(encoder.Bytes()) - startIndex
37661 alignedLength := ((length + 7) / 8 * 8)
37662
37663 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
37664
37665 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
37666
37667 return nil
37668}
37669
37670func DecodeTableFeaturePropWriteActions(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropWriteActions, error) {
37671 _tablefeaturepropwriteactions := &TableFeaturePropWriteActions{TableFeatureProp: parent}
37672 defer decoder.SkipAlign()
37673
37674 for decoder.Length() >= 4 {
37675 item, err := DecodeActionId(decoder)
37676 if err != nil {
37677 return nil, err
37678 }
37679 if item != nil {
37680 _tablefeaturepropwriteactions.ActionIds = append(_tablefeaturepropwriteactions.ActionIds, item)
37681 }
37682 }
37683 return _tablefeaturepropwriteactions, nil
37684}
37685
37686func NewTableFeaturePropWriteActions() *TableFeaturePropWriteActions {
37687 obj := &TableFeaturePropWriteActions{
37688 TableFeatureProp: NewTableFeatureProp(4),
37689 }
37690 return obj
37691}
37692
37693type TableFeaturePropWriteActionsMiss struct {
37694 *TableFeatureProp
37695 ActionIds []IActionId
37696}
37697
37698type ITableFeaturePropWriteActionsMiss interface {
37699 ITableFeatureProp
37700 GetActionIds() []IActionId
37701}
37702
37703func (self *TableFeaturePropWriteActionsMiss) GetActionIds() []IActionId {
37704 return self.ActionIds
37705}
37706
37707func (self *TableFeaturePropWriteActionsMiss) SetActionIds(v []IActionId) {
37708 self.ActionIds = v
37709}
37710
37711func (self *TableFeaturePropWriteActionsMiss) Serialize(encoder *goloxi.Encoder) error {
37712 startIndex := len(encoder.Bytes())
37713 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
37714 return err
37715 }
37716
37717 for _, obj := range self.ActionIds {
37718 if err := obj.Serialize(encoder); err != nil {
37719 return err
37720 }
37721 }
37722 length := len(encoder.Bytes()) - startIndex
37723 alignedLength := ((length + 7) / 8 * 8)
37724
37725 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
37726
37727 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
37728
37729 return nil
37730}
37731
37732func DecodeTableFeaturePropWriteActionsMiss(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropWriteActionsMiss, error) {
37733 _tablefeaturepropwriteactionsmiss := &TableFeaturePropWriteActionsMiss{TableFeatureProp: parent}
37734 defer decoder.SkipAlign()
37735
37736 for decoder.Length() >= 4 {
37737 item, err := DecodeActionId(decoder)
37738 if err != nil {
37739 return nil, err
37740 }
37741 if item != nil {
37742 _tablefeaturepropwriteactionsmiss.ActionIds = append(_tablefeaturepropwriteactionsmiss.ActionIds, item)
37743 }
37744 }
37745 return _tablefeaturepropwriteactionsmiss, nil
37746}
37747
37748func NewTableFeaturePropWriteActionsMiss() *TableFeaturePropWriteActionsMiss {
37749 obj := &TableFeaturePropWriteActionsMiss{
37750 TableFeatureProp: NewTableFeatureProp(5),
37751 }
37752 return obj
37753}
37754
37755type TableFeaturePropWriteSetfield struct {
37756 *TableFeatureProp
37757 OxmIds []*Uint32
37758}
37759
37760type ITableFeaturePropWriteSetfield interface {
37761 ITableFeatureProp
37762 GetOxmIds() []*Uint32
37763}
37764
37765func (self *TableFeaturePropWriteSetfield) GetOxmIds() []*Uint32 {
37766 return self.OxmIds
37767}
37768
37769func (self *TableFeaturePropWriteSetfield) SetOxmIds(v []*Uint32) {
37770 self.OxmIds = v
37771}
37772
37773func (self *TableFeaturePropWriteSetfield) Serialize(encoder *goloxi.Encoder) error {
37774 startIndex := len(encoder.Bytes())
37775 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
37776 return err
37777 }
37778
37779 for _, obj := range self.OxmIds {
37780 if err := obj.Serialize(encoder); err != nil {
37781 return err
37782 }
37783 }
37784 length := len(encoder.Bytes()) - startIndex
37785 alignedLength := ((length + 7) / 8 * 8)
37786
37787 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
37788
37789 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
37790
37791 return nil
37792}
37793
37794func DecodeTableFeaturePropWriteSetfield(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropWriteSetfield, error) {
37795 _tablefeaturepropwritesetfield := &TableFeaturePropWriteSetfield{TableFeatureProp: parent}
37796 defer decoder.SkipAlign()
37797
37798 for decoder.Length() >= 4 {
37799 item, err := DecodeUint32(decoder)
37800 if err != nil {
37801 return nil, err
37802 }
37803 if item != nil {
37804 _tablefeaturepropwritesetfield.OxmIds = append(_tablefeaturepropwritesetfield.OxmIds, item)
37805 }
37806 }
37807 return _tablefeaturepropwritesetfield, nil
37808}
37809
37810func NewTableFeaturePropWriteSetfield() *TableFeaturePropWriteSetfield {
37811 obj := &TableFeaturePropWriteSetfield{
37812 TableFeatureProp: NewTableFeatureProp(12),
37813 }
37814 return obj
37815}
37816
37817type TableFeaturePropWriteSetfieldMiss struct {
37818 *TableFeatureProp
37819 OxmIds []*Uint32
37820}
37821
37822type ITableFeaturePropWriteSetfieldMiss interface {
37823 ITableFeatureProp
37824 GetOxmIds() []*Uint32
37825}
37826
37827func (self *TableFeaturePropWriteSetfieldMiss) GetOxmIds() []*Uint32 {
37828 return self.OxmIds
37829}
37830
37831func (self *TableFeaturePropWriteSetfieldMiss) SetOxmIds(v []*Uint32) {
37832 self.OxmIds = v
37833}
37834
37835func (self *TableFeaturePropWriteSetfieldMiss) Serialize(encoder *goloxi.Encoder) error {
37836 startIndex := len(encoder.Bytes())
37837 if err := self.TableFeatureProp.Serialize(encoder); err != nil {
37838 return err
37839 }
37840
37841 for _, obj := range self.OxmIds {
37842 if err := obj.Serialize(encoder); err != nil {
37843 return err
37844 }
37845 }
37846 length := len(encoder.Bytes()) - startIndex
37847 alignedLength := ((length + 7) / 8 * 8)
37848
37849 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
37850
37851 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
37852
37853 return nil
37854}
37855
37856func DecodeTableFeaturePropWriteSetfieldMiss(parent *TableFeatureProp, decoder *goloxi.Decoder) (*TableFeaturePropWriteSetfieldMiss, error) {
37857 _tablefeaturepropwritesetfieldmiss := &TableFeaturePropWriteSetfieldMiss{TableFeatureProp: parent}
37858 defer decoder.SkipAlign()
37859
37860 for decoder.Length() >= 4 {
37861 item, err := DecodeUint32(decoder)
37862 if err != nil {
37863 return nil, err
37864 }
37865 if item != nil {
37866 _tablefeaturepropwritesetfieldmiss.OxmIds = append(_tablefeaturepropwritesetfieldmiss.OxmIds, item)
37867 }
37868 }
37869 return _tablefeaturepropwritesetfieldmiss, nil
37870}
37871
37872func NewTableFeaturePropWriteSetfieldMiss() *TableFeaturePropWriteSetfieldMiss {
37873 obj := &TableFeaturePropWriteSetfieldMiss{
37874 TableFeatureProp: NewTableFeatureProp(13),
37875 }
37876 return obj
37877}
37878
37879type TableFeatures struct {
37880 Length uint16
37881 TableId uint8
37882 Name string
37883 MetadataMatch uint64
37884 MetadataWrite uint64
37885 Config uint32
37886 MaxEntries uint32
37887 Properties []ITableFeatureProp
37888}
37889
37890type ITableFeatures interface {
37891 goloxi.Serializable
37892 GetLength() uint16
37893 GetTableId() uint8
37894 GetName() string
37895 GetMetadataMatch() uint64
37896 GetMetadataWrite() uint64
37897 GetConfig() uint32
37898 GetMaxEntries() uint32
37899 GetProperties() []ITableFeatureProp
37900}
37901
37902func (self *TableFeatures) GetLength() uint16 {
37903 return self.Length
37904}
37905
37906func (self *TableFeatures) SetLength(v uint16) {
37907 self.Length = v
37908}
37909
37910func (self *TableFeatures) GetTableId() uint8 {
37911 return self.TableId
37912}
37913
37914func (self *TableFeatures) SetTableId(v uint8) {
37915 self.TableId = v
37916}
37917
37918func (self *TableFeatures) GetName() string {
37919 return self.Name
37920}
37921
37922func (self *TableFeatures) SetName(v string) {
37923 self.Name = v
37924}
37925
37926func (self *TableFeatures) GetMetadataMatch() uint64 {
37927 return self.MetadataMatch
37928}
37929
37930func (self *TableFeatures) SetMetadataMatch(v uint64) {
37931 self.MetadataMatch = v
37932}
37933
37934func (self *TableFeatures) GetMetadataWrite() uint64 {
37935 return self.MetadataWrite
37936}
37937
37938func (self *TableFeatures) SetMetadataWrite(v uint64) {
37939 self.MetadataWrite = v
37940}
37941
37942func (self *TableFeatures) GetConfig() uint32 {
37943 return self.Config
37944}
37945
37946func (self *TableFeatures) SetConfig(v uint32) {
37947 self.Config = v
37948}
37949
37950func (self *TableFeatures) GetMaxEntries() uint32 {
37951 return self.MaxEntries
37952}
37953
37954func (self *TableFeatures) SetMaxEntries(v uint32) {
37955 self.MaxEntries = v
37956}
37957
37958func (self *TableFeatures) GetProperties() []ITableFeatureProp {
37959 return self.Properties
37960}
37961
37962func (self *TableFeatures) SetProperties(v []ITableFeatureProp) {
37963 self.Properties = v
37964}
37965
37966func (self *TableFeatures) Serialize(encoder *goloxi.Encoder) error {
37967 startIndex := len(encoder.Bytes())
37968
37969 encoder.PutUint16(uint16(self.Length))
37970 encoder.PutUint8(uint8(self.TableId))
37971 encoder.Write(bytes.Repeat([]byte{0}, 5))
37972 encoder.Write([]byte(self.Name))
37973 encoder.PutUint64(uint64(self.MetadataMatch))
37974 encoder.PutUint64(uint64(self.MetadataWrite))
37975 encoder.PutUint32(uint32(self.Config))
37976 encoder.PutUint32(uint32(self.MaxEntries))
37977 for _, obj := range self.Properties {
37978 if err := obj.Serialize(encoder); err != nil {
37979 return err
37980 }
37981 }
37982 length := len(encoder.Bytes()) - startIndex
37983
37984 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
37985
37986 return nil
37987}
37988
37989func DecodeTableFeatures(decoder *goloxi.Decoder) (*TableFeatures, error) {
37990 _tablefeatures := &TableFeatures{}
37991 if decoder.Length() < 64 {
37992 return nil, fmt.Errorf("TableFeatures packet too short: %d < 64", decoder.Length())
37993 }
37994 _tablefeatures.Length = uint16(decoder.ReadUint16())
37995 oldDecoder := decoder
37996 defer func() { decoder = oldDecoder }()
37997 decoder = decoder.SliceDecoder(int(_tablefeatures.Length), 2+0)
37998 _tablefeatures.TableId = uint8(decoder.ReadByte())
37999 decoder.Skip(5)
38000 _tablefeatures.Name = string(bytes.Trim(decoder.Read(32), "\x00"))
38001 _tablefeatures.MetadataMatch = uint64(decoder.ReadUint64())
38002 _tablefeatures.MetadataWrite = uint64(decoder.ReadUint64())
38003 _tablefeatures.Config = uint32(decoder.ReadUint32())
38004 _tablefeatures.MaxEntries = uint32(decoder.ReadUint32())
38005
38006 for decoder.Length() >= 4 {
38007 item, err := DecodeTableFeatureProp(decoder)
38008 if err != nil {
38009 return nil, err
38010 }
38011 if item != nil {
38012 _tablefeatures.Properties = append(_tablefeatures.Properties, item)
38013 }
38014 }
38015 return _tablefeatures, nil
38016}
38017
38018func NewTableFeatures() *TableFeatures {
38019 obj := &TableFeatures{}
38020 return obj
38021}
38022
38023type TableModProp struct {
38024 Type uint16
38025 Length uint16
38026}
38027
38028type ITableModProp interface {
38029 goloxi.Serializable
38030 GetType() uint16
38031 GetLength() uint16
38032}
38033
38034func (self *TableModProp) GetType() uint16 {
38035 return self.Type
38036}
38037
38038func (self *TableModProp) SetType(v uint16) {
38039 self.Type = v
38040}
38041
38042func (self *TableModProp) GetLength() uint16 {
38043 return self.Length
38044}
38045
38046func (self *TableModProp) SetLength(v uint16) {
38047 self.Length = v
38048}
38049
38050func (self *TableModProp) Serialize(encoder *goloxi.Encoder) error {
38051
38052 encoder.PutUint16(uint16(self.Type))
38053 encoder.PutUint16(uint16(self.Length))
38054
38055 return nil
38056}
38057
38058func DecodeTableModProp(decoder *goloxi.Decoder) (ITableModProp, error) {
38059 _tablemodprop := &TableModProp{}
38060 if decoder.Length() < 4 {
38061 return nil, fmt.Errorf("TableModProp packet too short: %d < 4", decoder.Length())
38062 }
38063 _tablemodprop.Type = uint16(decoder.ReadUint16())
38064 _tablemodprop.Length = uint16(decoder.ReadUint16())
38065 oldDecoder := decoder
38066 defer func() { decoder = oldDecoder }()
38067 decoder = decoder.SliceDecoder(int(_tablemodprop.Length), 2+2)
38068 return _tablemodprop, nil
38069}
38070
38071func NewTableModProp(_type uint16) *TableModProp {
38072 obj := &TableModProp{}
38073 obj.Type = _type
38074 return obj
38075}
38076
38077type TableModPropEviction struct {
38078 Type uint16
38079 Length uint16
38080 Flags TableModPropEvictionFlag
38081}
38082
38083type ITableModPropEviction interface {
38084 goloxi.Serializable
38085 GetType() uint16
38086 GetLength() uint16
38087 GetFlags() TableModPropEvictionFlag
38088}
38089
38090func (self *TableModPropEviction) GetType() uint16 {
38091 return self.Type
38092}
38093
38094func (self *TableModPropEviction) SetType(v uint16) {
38095 self.Type = v
38096}
38097
38098func (self *TableModPropEviction) GetLength() uint16 {
38099 return self.Length
38100}
38101
38102func (self *TableModPropEviction) SetLength(v uint16) {
38103 self.Length = v
38104}
38105
38106func (self *TableModPropEviction) GetFlags() TableModPropEvictionFlag {
38107 return self.Flags
38108}
38109
38110func (self *TableModPropEviction) SetFlags(v TableModPropEvictionFlag) {
38111 self.Flags = v
38112}
38113
38114func (self *TableModPropEviction) Serialize(encoder *goloxi.Encoder) error {
38115 startIndex := len(encoder.Bytes())
38116
38117 encoder.PutUint16(uint16(self.Type))
38118 encoder.PutUint16(uint16(self.Length))
38119 encoder.PutUint32(uint32(self.Flags))
38120 length := len(encoder.Bytes()) - startIndex
38121
38122 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
38123
38124 return nil
38125}
38126
38127func DecodeTableModPropEviction(decoder *goloxi.Decoder) (*TableModPropEviction, error) {
38128 _tablemodpropeviction := &TableModPropEviction{}
38129 if decoder.Length() < 8 {
38130 return nil, fmt.Errorf("TableModPropEviction packet too short: %d < 8", decoder.Length())
38131 }
38132 _tablemodpropeviction.Type = uint16(decoder.ReadUint16())
38133 _tablemodpropeviction.Length = uint16(decoder.ReadUint16())
38134 oldDecoder := decoder
38135 defer func() { decoder = oldDecoder }()
38136 decoder = decoder.SliceDecoder(int(_tablemodpropeviction.Length), 2+2)
38137 _tablemodpropeviction.Flags = TableModPropEvictionFlag(decoder.ReadUint32())
38138 return _tablemodpropeviction, nil
38139}
38140
38141func NewTableModPropEviction() *TableModPropEviction {
38142 obj := &TableModPropEviction{}
38143 return obj
38144}
38145
38146type TableModPropExperimenter struct {
38147 Type uint16
38148 Length uint16
38149 Experimenter uint32
38150 ExpType uint32
38151}
38152
38153type ITableModPropExperimenter interface {
38154 goloxi.Serializable
38155 GetType() uint16
38156 GetLength() uint16
38157 GetExperimenter() uint32
38158 GetExpType() uint32
38159}
38160
38161func (self *TableModPropExperimenter) GetType() uint16 {
38162 return self.Type
38163}
38164
38165func (self *TableModPropExperimenter) SetType(v uint16) {
38166 self.Type = v
38167}
38168
38169func (self *TableModPropExperimenter) GetLength() uint16 {
38170 return self.Length
38171}
38172
38173func (self *TableModPropExperimenter) SetLength(v uint16) {
38174 self.Length = v
38175}
38176
38177func (self *TableModPropExperimenter) GetExperimenter() uint32 {
38178 return self.Experimenter
38179}
38180
38181func (self *TableModPropExperimenter) SetExperimenter(v uint32) {
38182 self.Experimenter = v
38183}
38184
38185func (self *TableModPropExperimenter) GetExpType() uint32 {
38186 return self.ExpType
38187}
38188
38189func (self *TableModPropExperimenter) SetExpType(v uint32) {
38190 self.ExpType = v
38191}
38192
38193func (self *TableModPropExperimenter) Serialize(encoder *goloxi.Encoder) error {
38194
38195 encoder.PutUint16(uint16(self.Type))
38196 encoder.PutUint16(uint16(self.Length))
38197 encoder.PutUint32(uint32(self.Experimenter))
38198 encoder.PutUint32(uint32(self.ExpType))
38199
38200 return nil
38201}
38202
38203func DecodeTableModPropExperimenter(decoder *goloxi.Decoder) (ITableModPropExperimenter, error) {
38204 _tablemodpropexperimenter := &TableModPropExperimenter{}
38205 if decoder.Length() < 12 {
38206 return nil, fmt.Errorf("TableModPropExperimenter packet too short: %d < 12", decoder.Length())
38207 }
38208 _tablemodpropexperimenter.Type = uint16(decoder.ReadUint16())
38209 _tablemodpropexperimenter.Length = uint16(decoder.ReadUint16())
38210 oldDecoder := decoder
38211 defer func() { decoder = oldDecoder }()
38212 decoder = decoder.SliceDecoder(int(_tablemodpropexperimenter.Length), 2+2)
38213 _tablemodpropexperimenter.Experimenter = uint32(decoder.ReadUint32())
38214 _tablemodpropexperimenter.ExpType = uint32(decoder.ReadUint32())
38215 return _tablemodpropexperimenter, nil
38216}
38217
38218func NewTableModPropExperimenter(_experimenter uint32) *TableModPropExperimenter {
38219 obj := &TableModPropExperimenter{}
38220 obj.Experimenter = _experimenter
38221 return obj
38222}
38223
38224type TableModPropVacancy struct {
38225 Type uint16
38226 Length uint16
38227 VacancyDown uint8
38228 VacancyUp uint8
38229 Vacancy uint8
38230}
38231
38232type ITableModPropVacancy interface {
38233 goloxi.Serializable
38234 GetType() uint16
38235 GetLength() uint16
38236 GetVacancyDown() uint8
38237 GetVacancyUp() uint8
38238 GetVacancy() uint8
38239}
38240
38241func (self *TableModPropVacancy) GetType() uint16 {
38242 return self.Type
38243}
38244
38245func (self *TableModPropVacancy) SetType(v uint16) {
38246 self.Type = v
38247}
38248
38249func (self *TableModPropVacancy) GetLength() uint16 {
38250 return self.Length
38251}
38252
38253func (self *TableModPropVacancy) SetLength(v uint16) {
38254 self.Length = v
38255}
38256
38257func (self *TableModPropVacancy) GetVacancyDown() uint8 {
38258 return self.VacancyDown
38259}
38260
38261func (self *TableModPropVacancy) SetVacancyDown(v uint8) {
38262 self.VacancyDown = v
38263}
38264
38265func (self *TableModPropVacancy) GetVacancyUp() uint8 {
38266 return self.VacancyUp
38267}
38268
38269func (self *TableModPropVacancy) SetVacancyUp(v uint8) {
38270 self.VacancyUp = v
38271}
38272
38273func (self *TableModPropVacancy) GetVacancy() uint8 {
38274 return self.Vacancy
38275}
38276
38277func (self *TableModPropVacancy) SetVacancy(v uint8) {
38278 self.Vacancy = v
38279}
38280
38281func (self *TableModPropVacancy) Serialize(encoder *goloxi.Encoder) error {
38282 startIndex := len(encoder.Bytes())
38283
38284 encoder.PutUint16(uint16(self.Type))
38285 encoder.PutUint16(uint16(self.Length))
38286 encoder.PutUint8(uint8(self.VacancyDown))
38287 encoder.PutUint8(uint8(self.VacancyUp))
38288 encoder.PutUint8(uint8(self.Vacancy))
38289 encoder.Write(bytes.Repeat([]byte{0}, 1))
38290 length := len(encoder.Bytes()) - startIndex
38291
38292 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
38293
38294 return nil
38295}
38296
38297func DecodeTableModPropVacancy(decoder *goloxi.Decoder) (*TableModPropVacancy, error) {
38298 _tablemodpropvacancy := &TableModPropVacancy{}
38299 if decoder.Length() < 8 {
38300 return nil, fmt.Errorf("TableModPropVacancy packet too short: %d < 8", decoder.Length())
38301 }
38302 _tablemodpropvacancy.Type = uint16(decoder.ReadUint16())
38303 _tablemodpropvacancy.Length = uint16(decoder.ReadUint16())
38304 oldDecoder := decoder
38305 defer func() { decoder = oldDecoder }()
38306 decoder = decoder.SliceDecoder(int(_tablemodpropvacancy.Length), 2+2)
38307 _tablemodpropvacancy.VacancyDown = uint8(decoder.ReadByte())
38308 _tablemodpropvacancy.VacancyUp = uint8(decoder.ReadByte())
38309 _tablemodpropvacancy.Vacancy = uint8(decoder.ReadByte())
38310 decoder.Skip(1)
38311 return _tablemodpropvacancy, nil
38312}
38313
38314func NewTableModPropVacancy() *TableModPropVacancy {
38315 obj := &TableModPropVacancy{}
38316 return obj
38317}
38318
38319type TableStatsEntry struct {
38320 TableId uint8
38321 ActiveCount uint32
38322 LookupCount uint64
38323 MatchedCount uint64
38324}
38325
38326type ITableStatsEntry interface {
38327 goloxi.Serializable
38328 GetTableId() uint8
38329 GetActiveCount() uint32
38330 GetLookupCount() uint64
38331 GetMatchedCount() uint64
38332}
38333
38334func (self *TableStatsEntry) GetTableId() uint8 {
38335 return self.TableId
38336}
38337
38338func (self *TableStatsEntry) SetTableId(v uint8) {
38339 self.TableId = v
38340}
38341
38342func (self *TableStatsEntry) GetActiveCount() uint32 {
38343 return self.ActiveCount
38344}
38345
38346func (self *TableStatsEntry) SetActiveCount(v uint32) {
38347 self.ActiveCount = v
38348}
38349
38350func (self *TableStatsEntry) GetLookupCount() uint64 {
38351 return self.LookupCount
38352}
38353
38354func (self *TableStatsEntry) SetLookupCount(v uint64) {
38355 self.LookupCount = v
38356}
38357
38358func (self *TableStatsEntry) GetMatchedCount() uint64 {
38359 return self.MatchedCount
38360}
38361
38362func (self *TableStatsEntry) SetMatchedCount(v uint64) {
38363 self.MatchedCount = v
38364}
38365
38366func (self *TableStatsEntry) Serialize(encoder *goloxi.Encoder) error {
38367
38368 encoder.PutUint8(uint8(self.TableId))
38369 encoder.Write(bytes.Repeat([]byte{0}, 3))
38370 encoder.PutUint32(uint32(self.ActiveCount))
38371 encoder.PutUint64(uint64(self.LookupCount))
38372 encoder.PutUint64(uint64(self.MatchedCount))
38373
38374 return nil
38375}
38376
38377func DecodeTableStatsEntry(decoder *goloxi.Decoder) (*TableStatsEntry, error) {
38378 _tablestatsentry := &TableStatsEntry{}
38379 if decoder.Length() < 24 {
38380 return nil, fmt.Errorf("TableStatsEntry packet too short: %d < 24", decoder.Length())
38381 }
38382 _tablestatsentry.TableId = uint8(decoder.ReadByte())
38383 decoder.Skip(3)
38384 _tablestatsentry.ActiveCount = uint32(decoder.ReadUint32())
38385 _tablestatsentry.LookupCount = uint64(decoder.ReadUint64())
38386 _tablestatsentry.MatchedCount = uint64(decoder.ReadUint64())
38387 return _tablestatsentry, nil
38388}
38389
38390func NewTableStatsEntry() *TableStatsEntry {
38391 obj := &TableStatsEntry{}
38392 return obj
38393}
38394
38395type Uint32 struct {
38396 Value uint32
38397}
38398
38399type IUint32 interface {
38400 goloxi.Serializable
38401 GetValue() uint32
38402}
38403
38404func (self *Uint32) GetValue() uint32 {
38405 return self.Value
38406}
38407
38408func (self *Uint32) SetValue(v uint32) {
38409 self.Value = v
38410}
38411
38412func (self *Uint32) Serialize(encoder *goloxi.Encoder) error {
38413
38414 encoder.PutUint32(uint32(self.Value))
38415
38416 return nil
38417}
38418
38419func DecodeUint32(decoder *goloxi.Decoder) (*Uint32, error) {
38420 _uint32 := &Uint32{}
38421 if decoder.Length() < 4 {
38422 return nil, fmt.Errorf("Uint32 packet too short: %d < 4", decoder.Length())
38423 }
38424 _uint32.Value = uint32(decoder.ReadUint32())
38425 return _uint32, nil
38426}
38427
38428func NewUint32() *Uint32 {
38429 obj := &Uint32{}
38430 return obj
38431}
38432
38433type Uint64 struct {
38434 Value uint64
38435}
38436
38437type IUint64 interface {
38438 goloxi.Serializable
38439 GetValue() uint64
38440}
38441
38442func (self *Uint64) GetValue() uint64 {
38443 return self.Value
38444}
38445
38446func (self *Uint64) SetValue(v uint64) {
38447 self.Value = v
38448}
38449
38450func (self *Uint64) Serialize(encoder *goloxi.Encoder) error {
38451
38452 encoder.PutUint64(uint64(self.Value))
38453
38454 return nil
38455}
38456
38457func DecodeUint64(decoder *goloxi.Decoder) (*Uint64, error) {
38458 _uint64 := &Uint64{}
38459 if decoder.Length() < 8 {
38460 return nil, fmt.Errorf("Uint64 packet too short: %d < 8", decoder.Length())
38461 }
38462 _uint64.Value = uint64(decoder.ReadUint64())
38463 return _uint64, nil
38464}
38465
38466func NewUint64() *Uint64 {
38467 obj := &Uint64{}
38468 return obj
38469}
38470
38471type Uint8 struct {
38472 Value uint8
38473}
38474
38475type IUint8 interface {
38476 goloxi.Serializable
38477 GetValue() uint8
38478}
38479
38480func (self *Uint8) GetValue() uint8 {
38481 return self.Value
38482}
38483
38484func (self *Uint8) SetValue(v uint8) {
38485 self.Value = v
38486}
38487
38488func (self *Uint8) Serialize(encoder *goloxi.Encoder) error {
38489
38490 encoder.PutUint8(uint8(self.Value))
38491
38492 return nil
38493}
38494
38495func DecodeUint8(decoder *goloxi.Decoder) (*Uint8, error) {
38496 _uint8 := &Uint8{}
38497 if decoder.Length() < 1 {
38498 return nil, fmt.Errorf("Uint8 packet too short: %d < 1", decoder.Length())
38499 }
38500 _uint8.Value = uint8(decoder.ReadByte())
38501 return _uint8, nil
38502}
38503
38504func NewUint8() *Uint8 {
38505 obj := &Uint8{}
38506 return obj
38507}