Gitiles
Code Review Sign In
gerrit.opencord.org / goloxi / 44bdbfc319927fdbd8a09267da232ae09bc39962 / . / of12 / common.go
blob: 44566c44de4a34f788eaac2372f34833a6f46fa1 [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 of12
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 2147497988:
71 return DecodeOxmIdIpv6Flabel(_oxmid, decoder)
72 case 111228:
73 return DecodeOxmIdTunMetadata49(_oxmid, decoder)
74 case 2147500038:
75 return DecodeOxmIdIpv6NdSll(_oxmid, decoder)
76 case 2147499266:
77 return DecodeOxmIdIcmpv6CodeMasked(_oxmid, decoder)
78 case 207112:
79 return DecodeOxmIdBsnIngressPortGroupIdMasked(_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 65540:
91 return DecodeOxmIdReg0(_oxmid, decoder)
92 case 114300:
93 return DecodeOxmIdTunMetadata55(_oxmid, decoder)
94 case 2050:
95 return DecodeOxmIdVlanTci(_oxmid, decoder)
96 case 3073:
97 return DecodeOxmIdNwProto(_oxmid, decoder)
98 case 110072:
99 return DecodeOxmIdTunMetadata46Masked(_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 199684:
127 return DecodeOxmIdBsnL3DstClassId(_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 124192:
137 return DecodeOxmIdXxreg3Masked(_oxmid, decoder)
138 case 81672:
139 return DecodeOxmIdTunnelIpv4SrcMasked(_oxmid, decoder)
140 case 4100:
141 return DecodeOxmIdIpDst(_oxmid, decoder)
142 case 118396:
143 return DecodeOxmIdTunMetadata63(_oxmid, decoder)
144 case 2147494146:
145 return DecodeOxmIdIcmpv4CodeMasked(_oxmid, decoder)
146 case 129284:
147 return DecodeOxmIdConnTrackingTpSrcMasked(_oxmid, decoder)
148 case 114168:
149 return DecodeOxmIdTunMetadata54Masked(_oxmid, decoder)
150 case 123920:
151 return DecodeOxmIdXxreg3(_oxmid, decoder)
152 case 2147498248:
153 return DecodeOxmIdIpv6FlabelMasked(_oxmid, decoder)
154 case 78091:
155 return DecodeOxmIdNdSllMasked(_oxmid, decoder)
156 case 2147500300:
157 return DecodeOxmIdIpv6NdSllMasked(_oxmid, decoder)
158 case 74000:
159 return DecodeOxmIdTunIdMasked(_oxmid, decoder)
160 case 86140:
161 return DecodeOxmIdTunMetadata0(_oxmid, decoder)
162 case 70660:
163 return DecodeOxmIdReg10(_oxmid, decoder)
164 case 121120:
165 return DecodeOxmIdConnTrackingLabelMasked(_oxmid, decoder)
166 case 107000:
167 return DecodeOxmIdTunMetadata40Masked(_oxmid, decoder)
168 case 3848:
169 return DecodeOxmIdIpSrcMasked(_oxmid, decoder)
170 case 87164:
171 return DecodeOxmIdTunMetadata2(_oxmid, decoder)
172 case 202756:
173 return DecodeOxmIdBsnUdf4(_oxmid, decoder)
174 case 204802:
175 return DecodeOxmIdBsnTcpFlags(_oxmid, decoder)
176 case 205825:
177 return DecodeOxmIdBsnL2CacheHit(_oxmid, decoder)
178 case 116216:
179 return DecodeOxmIdTunMetadata58Masked(_oxmid, decoder)
180 case 199432:
181 return DecodeOxmIdBsnL3SrcClassIdMasked(_oxmid, decoder)
182 case 88188:
183 return DecodeOxmIdTunMetadata4(_oxmid, decoder)
184 case 72708:
185 return DecodeOxmIdReg14(_oxmid, decoder)
186 case 2147492866:
187 return DecodeOxmIdSctpDst(_oxmid, decoder)
188 case 2147493889:
189 return DecodeOxmIdIcmpv4Code(_oxmid, decoder)
190 case 117240:
191 return DecodeOxmIdTunMetadata60Masked(_oxmid, decoder)
192 case 200196:
193 return DecodeOxmIdBsnEgrPortGroupId(_oxmid, decoder)
194 case 128288:
195 return DecodeOxmIdConnTrackingIpv6SrcMasked(_oxmid, decoder)
196 case 89212:
197 return DecodeOxmIdTunMetadata6(_oxmid, decoder)
198 case 8196:
199 return DecodeOxmIdArpSpa(_oxmid, decoder)
200 case 76801:
201 return DecodeOxmIdIcmpv6Code(_oxmid, decoder)
202 case 118264:
203 return DecodeOxmIdTunMetadata62Masked(_oxmid, decoder)
204 case 70148:
205 return DecodeOxmIdReg9(_oxmid, decoder)
206 case 119560:
207 return DecodeOxmIdConnTrackingStateMasked(_oxmid, decoder)
208 case 90236:
209 return DecodeOxmIdTunMetadata8(_oxmid, decoder)
210 case 119044:
211 return DecodeOxmIdTunFlagsMasked(_oxmid, decoder)
212 case 82696:
213 return DecodeOxmIdPktMarkMasked(_oxmid, decoder)
214 case 4294923528:
215 return DecodeOxmIdOvsTcpFlagsMasked(_oxmid, decoder)
216 case 120584:
217 return DecodeOxmIdConnTrackingMarkMasked(_oxmid, decoder)
218 case 91260:
219 return DecodeOxmIdTunMetadata10(_oxmid, decoder)
220 case 87032:
221 return DecodeOxmIdTunMetadata1Masked(_oxmid, decoder)
222 case 126722:
223 return DecodeOxmIdConnTrackingNwProtoMasked(_oxmid, decoder)
224 case 206852:
225 return DecodeOxmIdBsnIngressPortGroupId(_oxmid, decoder)
226 case 209921:
227 return DecodeOxmIdBsnIpFragmentation(_oxmid, decoder)
228 case 196896:
229 return DecodeOxmIdBsnInPorts128Masked(_oxmid, decoder)
230 case 92284:
231 return DecodeOxmIdTunMetadata12(_oxmid, decoder)
232 case 88056:
233 return DecodeOxmIdTunMetadata3Masked(_oxmid, decoder)
234 case 79873:
235 return DecodeOxmIdNwEcn(_oxmid, decoder)
236 case 196624:
237 return DecodeOxmIdBsnInPorts128(_oxmid, decoder)
238 case 200456:
239 return DecodeOxmIdBsnEgrPortGroupIdMasked(_oxmid, decoder)
240 case 2147489284:
241 return DecodeOxmIdIpv4Src(_oxmid, decoder)
242 case 93308:
243 return DecodeOxmIdTunMetadata14(_oxmid, decoder)
244 case 115192:
245 return DecodeOxmIdTunMetadata56Masked(_oxmid, decoder)
246 case 2561:
247 return DecodeOxmIdNwTos(_oxmid, decoder)
248 case 129538:
249 return DecodeOxmIdConnTrackingTpDst(_oxmid, decoder)
250 case 84484:
251 return DecodeOxmIdConjId(_oxmid, decoder)
252 case 2147500550:
253 return DecodeOxmIdIpv6NdTll(_oxmid, decoder)
254 case 85762:
255 return DecodeOxmIdTunGbpFlagsMasked(_oxmid, decoder)
256 case 123408:
257 return DecodeOxmIdXxreg2(_oxmid, decoder)
258 case 90104:
259 return DecodeOxmIdTunMetadata7Masked(_oxmid, decoder)
260 case 129796:
261 return DecodeOxmIdConnTrackingTpDstMasked(_oxmid, decoder)
262 case 70408:
263 return DecodeOxmIdReg9Masked(_oxmid, decoder)
264 case 91128:
265 return DecodeOxmIdTunMetadata9Masked(_oxmid, decoder)
266 case 83720:
267 return DecodeOxmIdDpHashMasked(_oxmid, decoder)
268 case 78603:
269 return DecodeOxmIdNdTllMasked(_oxmid, decoder)
270 case 96380:
271 return DecodeOxmIdTunMetadata20(_oxmid, decoder)
272 case 92152:
273 return DecodeOxmIdTunMetadata11Masked(_oxmid, decoder)
274 case 97404:
275 return DecodeOxmIdTunMetadata22(_oxmid, decoder)
276 case 93176:
277 return DecodeOxmIdTunMetadata13Masked(_oxmid, decoder)
278 case 94844:
279 return DecodeOxmIdTunMetadata17(_oxmid, decoder)
280 case 81924:
281 return DecodeOxmIdTunnelIpv4Dst(_oxmid, decoder)
282 case 127752:
283 return DecodeOxmIdConnTrackingNwDstMasked(_oxmid, decoder)
284 case 98428:
285 return DecodeOxmIdTunMetadata24(_oxmid, decoder)
286 case 94200:
287 return DecodeOxmIdTunMetadata15Masked(_oxmid, decoder)
288 case 2147501060:
289 return DecodeOxmIdMplsLabel(_oxmid, decoder)
290 case 84994:
291 return DecodeOxmIdTunGbpId(_oxmid, decoder)
292 case 71432:
293 return DecodeOxmIdReg11Masked(_oxmid, decoder)
294 case 99452:
295 return DecodeOxmIdTunMetadata26(_oxmid, decoder)
296 case 95224:
297 return DecodeOxmIdTunMetadata17Masked(_oxmid, decoder)
298 case 2147487490:
299 return DecodeOxmIdVlanPcpMasked(_oxmid, decoder)
300 case 83972:
301 return DecodeOxmIdRecircId(_oxmid, decoder)
302 case 128800:
303 return DecodeOxmIdConnTrackingIpv6DstMasked(_oxmid, decoder)
304 case 72196:
305 return DecodeOxmIdReg13(_oxmid, decoder)
306 case 100476:
307 return DecodeOxmIdTunMetadata28(_oxmid, decoder)
308 case 96248:
309 return DecodeOxmIdTunMetadata19Masked(_oxmid, decoder)
310 case 2147488514:
311 return DecodeOxmIdIpEcnMasked(_oxmid, decoder)
312 case 112764:
313 return DecodeOxmIdTunMetadata52(_oxmid, decoder)
314 case 101500:
315 return DecodeOxmIdTunMetadata30(_oxmid, decoder)
316 case 97272:
317 return DecodeOxmIdTunMetadata21Masked(_oxmid, decoder)
318 case 2147498754:
319 return DecodeOxmIdIcmpv6TypeMasked(_oxmid, decoder)
320 case 2147486468:
321 return DecodeOxmIdEthTypeMasked(_oxmid, decoder)
322 case 2147484424:
323 return DecodeOxmIdInPhyPortMasked(_oxmid, decoder)
324 case 74507:
325 return DecodeOxmIdArpShaMasked(_oxmid, decoder)
326 case 2147500812:
327 return DecodeOxmIdIpv6NdTllMasked(_oxmid, decoder)
328 case 197384:
329 return DecodeOxmIdBsnLagIdMasked(_oxmid, decoder)
330 case 76064:
331 return DecodeOxmIdIpv6DstMasked(_oxmid, decoder)
332 case 102524:
333 return DecodeOxmIdTunMetadata32(_oxmid, decoder)
334 case 98296:
335 return DecodeOxmIdTunMetadata23Masked(_oxmid, decoder)
336 case 4868:
337 return DecodeOxmIdTcpSrcMasked(_oxmid, decoder)
338 case 121632:
339 return DecodeOxmIdTunIpv6SrcMasked(_oxmid, decoder)
340 case 75792:
341 return DecodeOxmIdIpv6Dst(_oxmid, decoder)
342 case 202504:
343 return DecodeOxmIdBsnUdf3Masked(_oxmid, decoder)
344 case 120324:
345 return DecodeOxmIdConnTrackingMark(_oxmid, decoder)
346 case 99320:
347 return DecodeOxmIdTunMetadata25Masked(_oxmid, decoder)
348 case 65800:
349 return DecodeOxmIdReg0Masked(_oxmid, decoder)
350 case 66824:
351 return DecodeOxmIdReg2Masked(_oxmid, decoder)
352 case 72456:
353 return DecodeOxmIdReg13Masked(_oxmid, decoder)
354 case 68360:
355 return DecodeOxmIdReg5Masked(_oxmid, decoder)
356 case 104572:
357 return DecodeOxmIdTunMetadata36(_oxmid, decoder)
358 case 95356:
359 return DecodeOxmIdTunMetadata18(_oxmid, decoder)
360 case 100344:
361 return DecodeOxmIdTunMetadata27Masked(_oxmid, decoder)
362 case 4294923270:
363 return DecodeOxmIdOvsTcpFlags(_oxmid, decoder)
364 case 779:
365 return DecodeOxmIdEthDstMasked(_oxmid, decoder)
366 case 69384:
367 return DecodeOxmIdReg7Masked(_oxmid, decoder)
368 case 105596:
369 return DecodeOxmIdTunMetadata38(_oxmid, decoder)
370 case 101368:
371 return DecodeOxmIdTunMetadata29Masked(_oxmid, decoder)
372 case 2147493634:
373 return DecodeOxmIdIcmpv4TypeMasked(_oxmid, decoder)
374 case 108668:
375 return DecodeOxmIdTunMetadata44(_oxmid, decoder)
376 case 201480:
377 return DecodeOxmIdBsnUdf1Masked(_oxmid, decoder)
378 case 106620:
379 return DecodeOxmIdTunMetadata40(_oxmid, decoder)
380 case 102392:
381 return DecodeOxmIdTunMetadata31Masked(_oxmid, decoder)
382 case 2147492612:
383 return DecodeOxmIdSctpSrcMasked(_oxmid, decoder)
384 case 73480:
385 return DecodeOxmIdReg15Masked(_oxmid, decoder)
386 case 204292:
387 return DecodeOxmIdBsnUdf7(_oxmid, decoder)
388 case 2147489544:
389 return DecodeOxmIdIpv4SrcMasked(_oxmid, decoder)
390 case 107644:
391 return DecodeOxmIdTunMetadata42(_oxmid, decoder)
392 case 103416:
393 return DecodeOxmIdTunMetadata33Masked(_oxmid, decoder)
394 case 203528:
395 return DecodeOxmIdBsnUdf5Masked(_oxmid, decoder)
396 case 89592:
397 return DecodeOxmIdTunMetadata6Masked(_oxmid, decoder)
398 case 104440:
399 return DecodeOxmIdTunMetadata35Masked(_oxmid, decoder)
400 case 2147494660:
401 return DecodeOxmIdArpOpMasked(_oxmid, decoder)
402 case 197636:
403 return DecodeOxmIdBsnVrf(_oxmid, decoder)
404 case 204552:
405 return DecodeOxmIdBsnUdf7Masked(_oxmid, decoder)
406 case 109692:
407 return DecodeOxmIdTunMetadata46(_oxmid, decoder)
408 case 105464:
409 return DecodeOxmIdTunMetadata37Masked(_oxmid, decoder)
410 case 89080:
411 return DecodeOxmIdTunMetadata5Masked(_oxmid, decoder)
412 case 67588:
413 return DecodeOxmIdReg4(_oxmid, decoder)
414 case 7169:
415 return DecodeOxmIdIcmpCode(_oxmid, decoder)
416 case 82946:
417 return DecodeOxmIdTcpFlags(_oxmid, decoder)
418 case 203780:
419 return DecodeOxmIdBsnUdf6(_oxmid, decoder)
420 case 74758:
421 return DecodeOxmIdArpTha(_oxmid, decoder)
422 case 198145:
423 return DecodeOxmIdBsnGlobalVrfAllowed(_oxmid, decoder)
424 case 2147484680:
425 return DecodeOxmIdMetadata(_oxmid, decoder)
426 case 1538:
427 return DecodeOxmIdEthType(_oxmid, decoder)
428 case 8968:
429 return DecodeOxmIdArpTpaMasked(_oxmid, decoder)
430 case 128016:
431 return DecodeOxmIdConnTrackingIpv6Src(_oxmid, decoder)
432 case 110716:
433 return DecodeOxmIdTunMetadata48(_oxmid, decoder)
434 case 127492:
435 return DecodeOxmIdConnTrackingNwDst(_oxmid, decoder)
436 case 74246:
437 return DecodeOxmIdArpSha(_oxmid, decoder)
438 case 111740:
439 return DecodeOxmIdTunMetadata50(_oxmid, decoder)
440 case 107512:
441 return DecodeOxmIdTunMetadata41Masked(_oxmid, decoder)
442 case 121360:
443 return DecodeOxmIdTunIpv6Src(_oxmid, decoder)
444 case 113788:
445 return DecodeOxmIdTunMetadata54(_oxmid, decoder)
446 case 109560:
447 return DecodeOxmIdTunMetadata45Masked(_oxmid, decoder)
448 case 2147501826:
449 return DecodeOxmIdMplsTcMasked(_oxmid, decoder)
450 case 103548:
451 return DecodeOxmIdTunMetadata34(_oxmid, decoder)
452 case 2147484164:
453 return DecodeOxmIdInPhyPort(_oxmid, decoder)
454 case 205316:
455 return DecodeOxmIdBsnVlanXlatePortGroupId(_oxmid, decoder)
456 case 114812:
457 return DecodeOxmIdTunMetadata56(_oxmid, decoder)
458 case 2147487233:
459 return DecodeOxmIdVlanPcp(_oxmid, decoder)
460 case 110584:
461 return DecodeOxmIdTunMetadata47Masked(_oxmid, decoder)
462 case 68612:
463 return DecodeOxmIdReg6(_oxmid, decoder)
464 case 79624:
465 return DecodeOxmIdIpv6LabelMasked(_oxmid, decoder)
466 case 115836:
467 return DecodeOxmIdTunMetadata58(_oxmid, decoder)
468 case 2147488257:
469 return DecodeOxmIdIpEcn(_oxmid, decoder)
470 case 111608:
471 return DecodeOxmIdTunMetadata49Masked(_oxmid, decoder)
472 case 518:
473 return DecodeOxmIdEthDst(_oxmid, decoder)
474 case 68100:
475 return DecodeOxmIdReg5(_oxmid, decoder)
476 case 116860:
477 return DecodeOxmIdTunMetadata60(_oxmid, decoder)
478 case 4610:
479 return DecodeOxmIdTcpSrc(_oxmid, decoder)
480 case 112632:
481 return DecodeOxmIdTunMetadata51Masked(_oxmid, decoder)
482 case 122384:
483 return DecodeOxmIdXxreg0(_oxmid, decoder)
484 case 123680:
485 return DecodeOxmIdXxreg2Masked(_oxmid, decoder)
486 case 69124:
487 return DecodeOxmIdReg7(_oxmid, decoder)
488 case 117884:
489 return DecodeOxmIdTunMetadata62(_oxmid, decoder)
490 case 5634:
491 return DecodeOxmIdUdpSrc(_oxmid, decoder)
492 case 6657:
493 return DecodeOxmIdIcmpType(_oxmid, decoder)
494 case 113656:
495 return DecodeOxmIdTunMetadata53Masked(_oxmid, decoder)
496 case 198920:
497 return DecodeOxmIdBsnL3InterfaceClassIdMasked(_oxmid, decoder)
498 case 2147489026:
499 return DecodeOxmIdIpProtoMasked(_oxmid, decoder)
500 case 120068:
501 return DecodeOxmIdConnTrackingZoneMasked(_oxmid, decoder)
502 case 1286:
503 return DecodeOxmIdEthSrcMasked(_oxmid, decoder)
504 case 204040:
505 return DecodeOxmIdBsnUdf6Masked(_oxmid, decoder)
506 case 75019:
507 return DecodeOxmIdArpThaMasked(_oxmid, decoder)
508 case 201220:
509 return DecodeOxmIdBsnUdf1(_oxmid, decoder)
510 case 205576:
511 return DecodeOxmIdBsnVlanXlatePortGroupIdMasked(_oxmid, decoder)
512 case 2147484944:
513 return DecodeOxmIdMetadataMasked(_oxmid, decoder)
514 case 6146:
515 return DecodeOxmIdUdpDst(_oxmid, decoder)
516 case 114680:
517 return DecodeOxmIdTunMetadata55Masked(_oxmid, decoder)
518 case 122144:
519 return DecodeOxmIdTunIpv6DstMasked(_oxmid, decoder)
520 case 86652:
521 return DecodeOxmIdTunMetadata1(_oxmid, decoder)
522 case 202244:
523 return DecodeOxmIdBsnUdf3(_oxmid, decoder)
524 case 115704:
525 return DecodeOxmIdTunMetadata57Masked(_oxmid, decoder)
526 case 69636:
527 return DecodeOxmIdReg8(_oxmid, decoder)
528 case 87676:
529 return DecodeOxmIdTunMetadata3(_oxmid, decoder)
530 case 82184:
531 return DecodeOxmIdTunnelIpv4DstMasked(_oxmid, decoder)
532 case 203268:
533 return DecodeOxmIdBsnUdf5(_oxmid, decoder)
534 case 2147492354:
535 return DecodeOxmIdSctpSrc(_oxmid, decoder)
536 case 2147493377:
537 return DecodeOxmIdIcmpv4Type(_oxmid, decoder)
538 case 116728:
539 return DecodeOxmIdTunMetadata59Masked(_oxmid, decoder)
540 case 88700:
541 return DecodeOxmIdTunMetadata5(_oxmid, decoder)
542 case 73220:
543 return DecodeOxmIdReg15(_oxmid, decoder)
544 case 76289:
545 return DecodeOxmIdIcmpv6Type(_oxmid, decoder)
546 case 117752:
547 return DecodeOxmIdTunMetadata61Masked(_oxmid, decoder)
548 case 4360:
549 return DecodeOxmIdIpDstMasked(_oxmid, decoder)
550 case 89724:
551 return DecodeOxmIdTunMetadata7(_oxmid, decoder)
552 case 8708:
553 return DecodeOxmIdArpTpa(_oxmid, decoder)
554 case 118776:
555 return DecodeOxmIdTunMetadata63Masked(_oxmid, decoder)
556 case 199944:
557 return DecodeOxmIdBsnL3DstClassIdMasked(_oxmid, decoder)
558 case 90748:
559 return DecodeOxmIdTunMetadata9(_oxmid, decoder)
560 case 86520:
561 return DecodeOxmIdTunMetadata0Masked(_oxmid, decoder)
562 case 2147501320:
563 return DecodeOxmIdMplsLabelMasked(_oxmid, decoder)
564 case 197124:
565 return DecodeOxmIdBsnLagId(_oxmid, decoder)
566 case 78849:
567 return DecodeOxmIdIpFrag(_oxmid, decoder)
568 case 200708:
569 return DecodeOxmIdBsnUdf0(_oxmid, decoder)
570 case 91772:
571 return DecodeOxmIdTunMetadata11(_oxmid, decoder)
572 case 87544:
573 return DecodeOxmIdTunMetadata2Masked(_oxmid, decoder)
574 case 92796:
575 return DecodeOxmIdTunMetadata13(_oxmid, decoder)
576 case 88568:
577 return DecodeOxmIdTunMetadata4Masked(_oxmid, decoder)
578 case 80385:
579 return DecodeOxmIdNwTtl(_oxmid, decoder)
580 case 105976:
581 return DecodeOxmIdTunMetadata38Masked(_oxmid, decoder)
582 case 126465:
583 return DecodeOxmIdConnTrackingNwProto(_oxmid, decoder)
584 case 7682:
585 return DecodeOxmIdArpOp(_oxmid, decoder)
586 case 71172:
587 return DecodeOxmIdReg11(_oxmid, decoder)
588 case 210178:
589 return DecodeOxmIdBsnIpFragmentationMasked(_oxmid, decoder)
590 case 128528:
591 return DecodeOxmIdConnTrackingIpv6Dst(_oxmid, decoder)
592 case 85252:
593 return DecodeOxmIdTunGbpIdMasked(_oxmid, decoder)
594 case 90616:
595 return DecodeOxmIdTunMetadata8Masked(_oxmid, decoder)
596 case 79364:
597 return DecodeOxmIdIpv6Label(_oxmid, decoder)
598 case 200968:
599 return DecodeOxmIdBsnUdf0Masked(_oxmid, decoder)
600 case 206400:
601 return DecodeOxmIdBsnInPorts512(_oxmid, decoder)
602 case 95868:
603 return DecodeOxmIdTunMetadata19(_oxmid, decoder)
604 case 91640:
605 return DecodeOxmIdTunMetadata10Masked(_oxmid, decoder)
606 case 78342:
607 return DecodeOxmIdNdTll(_oxmid, decoder)
608 case 2147501569:
609 return DecodeOxmIdMplsTc(_oxmid, decoder)
610 case 70920:
611 return DecodeOxmIdReg10Masked(_oxmid, decoder)
612 case 96892:
613 return DecodeOxmIdTunMetadata21(_oxmid, decoder)
614 case 92664:
615 return DecodeOxmIdTunMetadata12Masked(_oxmid, decoder)
616 case 205060:
617 return DecodeOxmIdBsnTcpFlagsMasked(_oxmid, decoder)
618 case 81412:
619 return DecodeOxmIdTunnelIpv4Src(_oxmid, decoder)
620 case 99964:
621 return DecodeOxmIdTunMetadata27(_oxmid, decoder)
622 case 71684:
623 return DecodeOxmIdReg12(_oxmid, decoder)
624 case 127240:
625 return DecodeOxmIdConnTrackingNwSrcMasked(_oxmid, decoder)
626 case 97916:
627 return DecodeOxmIdTunMetadata23(_oxmid, decoder)
628 case 93688:
629 return DecodeOxmIdTunMetadata14Masked(_oxmid, decoder)
630 case 82436:
631 return DecodeOxmIdPktMark(_oxmid, decoder)
632 case 85505:
633 return DecodeOxmIdTunGbpFlags(_oxmid, decoder)
634 case 98940:
635 return DecodeOxmIdTunMetadata25(_oxmid, decoder)
636 case 94712:
637 return DecodeOxmIdTunMetadata16Masked(_oxmid, decoder)
638 case 83460:
639 return DecodeOxmIdDpHash(_oxmid, decoder)
640 case 123168:
641 return DecodeOxmIdXxreg1Masked(_oxmid, decoder)
642 case 118786:
643 return DecodeOxmIdTunFlags(_oxmid, decoder)
644 case 95736:
645 return DecodeOxmIdTunMetadata18Masked(_oxmid, decoder)
646 case 2308:
647 return DecodeOxmIdVlanTciMasked(_oxmid, decoder)
648 case 2147488002:
649 return DecodeOxmIdIpDscpMasked(_oxmid, decoder)
650 case 100988:
651 return DecodeOxmIdTunMetadata29(_oxmid, decoder)
652 case 119810:
653 return DecodeOxmIdConnTrackingZone(_oxmid, decoder)
654 case 96760:
655 return DecodeOxmIdTunMetadata20Masked(_oxmid, decoder)
656 case 2147486980:
657 return DecodeOxmIdVlanVidMasked(_oxmid, decoder)
658 case 116348:
659 return DecodeOxmIdTunMetadata59(_oxmid, decoder)
660 case 5378:
661 return DecodeOxmIdTcpDstMasked(_oxmid, decoder)
662 case 71944:
663 return DecodeOxmIdReg12Masked(_oxmid, decoder)
664 case 2147483912:
665 return DecodeOxmIdInPortMasked(_oxmid, decoder)
666 case 75552:
667 return DecodeOxmIdIpv6SrcMasked(_oxmid, decoder)
668 case 102012:
669 return DecodeOxmIdTunMetadata31(_oxmid, decoder)
670 case 198402:
671 return DecodeOxmIdBsnGlobalVrfAllowedMasked(_oxmid, decoder)
672 case 5892:
673 return DecodeOxmIdUdpSrcMasked(_oxmid, decoder)
674 case 97784:
675 return DecodeOxmIdTunMetadata22Masked(_oxmid, decoder)
676 case 66052:
677 return DecodeOxmIdReg1(_oxmid, decoder)
678 case 67336:
679 return DecodeOxmIdReg3Masked(_oxmid, decoder)
680 case 75280:
681 return DecodeOxmIdIpv6Src(_oxmid, decoder)
682 case 197896:
683 return DecodeOxmIdBsnVrfMasked(_oxmid, decoder)
684 case 122656:
685 return DecodeOxmIdXxreg0Masked(_oxmid, decoder)
686 case 103036:
687 return DecodeOxmIdTunMetadata33(_oxmid, decoder)
688 case 98808:
689 return DecodeOxmIdTunMetadata24Masked(_oxmid, decoder)
690 case 67848:
691 return DecodeOxmIdReg4Masked(_oxmid, decoder)
692 case 77600:
693 return DecodeOxmIdNdTargetMasked(_oxmid, decoder)
694 case 104060:
695 return DecodeOxmIdTunMetadata35(_oxmid, decoder)
696 case 99832:
697 return DecodeOxmIdTunMetadata26Masked(_oxmid, decoder)
698 case 6404:
699 return DecodeOxmIdUdpDstMasked(_oxmid, decoder)
700 case 77328:
701 return DecodeOxmIdNdTarget(_oxmid, decoder)
702 case 68872:
703 return DecodeOxmIdReg6Masked(_oxmid, decoder)
704 case 105084:
705 return DecodeOxmIdTunMetadata37(_oxmid, decoder)
706 case 100856:
707 return DecodeOxmIdTunMetadata28Masked(_oxmid, decoder)
708 case 206082:
709 return DecodeOxmIdBsnL2CacheHitMasked(_oxmid, decoder)
710 case 203016:
711 return DecodeOxmIdBsnUdf4Masked(_oxmid, decoder)
712 case 69896:
713 return DecodeOxmIdReg8Masked(_oxmid, decoder)
714 case 206720:
715 return DecodeOxmIdBsnInPorts512Masked(_oxmid, decoder)
716 case 106108:
717 return DecodeOxmIdTunMetadata39(_oxmid, decoder)
718 case 101880:
719 return DecodeOxmIdTunMetadata30Masked(_oxmid, decoder)
720 case 8452:
721 return DecodeOxmIdArpSpaMasked(_oxmid, decoder)
722 case 66312:
723 return DecodeOxmIdReg1Masked(_oxmid, decoder)
724 case 201992:
725 return DecodeOxmIdBsnUdf2Masked(_oxmid, decoder)
726 case 107132:
727 return DecodeOxmIdTunMetadata41(_oxmid, decoder)
728 case 102904:
729 return DecodeOxmIdTunMetadata32Masked(_oxmid, decoder)
730 case 2147493124:
731 return DecodeOxmIdSctpDstMasked(_oxmid, decoder)
732 case 67076:
733 return DecodeOxmIdReg3(_oxmid, decoder)
734 case 119300:
735 return DecodeOxmIdConnTrackingState(_oxmid, decoder)
736 case 2147490056:
737 return DecodeOxmIdIpv4DstMasked(_oxmid, decoder)
738 case 2147499808:
739 return DecodeOxmIdIpv6NdTargetMasked(_oxmid, decoder)
740 case 108156:
741 return DecodeOxmIdTunMetadata43(_oxmid, decoder)
742 case 103928:
743 return DecodeOxmIdTunMetadata34Masked(_oxmid, decoder)
744 case 106488:
745 return DecodeOxmIdTunMetadata39Masked(_oxmid, decoder)
746 case 201732:
747 return DecodeOxmIdBsnUdf2(_oxmid, decoder)
748 case 2147499536:
749 return DecodeOxmIdIpv6NdTarget(_oxmid, decoder)
750 case 72968:
751 return DecodeOxmIdReg14Masked(_oxmid, decoder)
752 case 109180:
753 return DecodeOxmIdTunMetadata45(_oxmid, decoder)
754 case 104952:
755 return DecodeOxmIdTunMetadata36Masked(_oxmid, decoder)
756 case 93820:
757 return DecodeOxmIdTunMetadata15(_oxmid, decoder)
758 case 79106:
759 return DecodeOxmIdIpFragMasked(_oxmid, decoder)
760 case 108536:
761 return DecodeOxmIdTunMetadata43Masked(_oxmid, decoder)
762 case 126980:
763 return DecodeOxmIdConnTrackingNwSrc(_oxmid, decoder)
764 default:
765 return _oxmid, nil
766 }
767}
768
769func NewOxmId(_type_len uint32) *OxmId {
770 obj := &OxmId{}
771 obj.TypeLen = _type_len
772 return obj
773}
774func (self *OxmId) GetOXMName() string {
775 return ""
776}
777
778func (self *OxmId) MarshalJSON() ([]byte, error) {
779 if self.TypeLen == 0 {
780 return []byte("\"\""), nil
781 } else {
782 return []byte("\"" + self.GetOXMName() + "\""), nil
783 }
784}
785
786type ActionNxBundleLoadSlave struct {
787 Port Port
788}
789
790type IActionNxBundleLoadSlave interface {
791 goloxi.Serializable
792 GetPort() Port
793}
794
795func (self *ActionNxBundleLoadSlave) GetPort() Port {
796 return self.Port
797}
798
799func (self *ActionNxBundleLoadSlave) SetPort(v Port) {
800 self.Port = v
801}
802
803func (self *ActionNxBundleLoadSlave) Serialize(encoder *goloxi.Encoder) error {
804
805 encoder.PutUint32(uint32(self.Port))
806
807 return nil
808}
809
810func DecodeActionNxBundleLoadSlave(decoder *goloxi.Decoder) (*ActionNxBundleLoadSlave, error) {
811 _actionnxbundleloadslave := &ActionNxBundleLoadSlave{}
812 if decoder.Length() < 4 {
813 return nil, fmt.Errorf("ActionNxBundleLoadSlave packet too short: %d < 4", decoder.Length())
814 }
815 _actionnxbundleloadslave.Port = Port(decoder.ReadUint32())
816 return _actionnxbundleloadslave, nil
817}
818
819func NewActionNxBundleLoadSlave() *ActionNxBundleLoadSlave {
820 obj := &ActionNxBundleLoadSlave{}
821 return obj
822}
823
824type ActionNxController2Property struct {
825 Type NxActionController2PropType
826}
827
828type IActionNxController2Property interface {
829 goloxi.Serializable
830 GetType() NxActionController2PropType
831}
832
833func (self *ActionNxController2Property) GetType() NxActionController2PropType {
834 return self.Type
835}
836
837func (self *ActionNxController2Property) SetType(v NxActionController2PropType) {
838 self.Type = v
839}
840
841func (self *ActionNxController2Property) Serialize(encoder *goloxi.Encoder) error {
842
843 encoder.PutUint16(uint16(self.Type))
844
845 return nil
846}
847
848func DecodeActionNxController2Property(decoder *goloxi.Decoder) (IActionNxController2Property, error) {
849 _actionnxcontroller2property := &ActionNxController2Property{}
850 if decoder.Length() < 2 {
851 return nil, fmt.Errorf("ActionNxController2Property packet too short: %d < 2", decoder.Length())
852 }
853 _actionnxcontroller2property.Type = NxActionController2PropType(decoder.ReadUint16())
854
855 switch _actionnxcontroller2property.Type {
856 case 0:
857 return DecodeActionNxController2PropertyMaxLen(_actionnxcontroller2property, decoder)
858 case 1:
859 return DecodeActionNxController2PropertyControllerId(_actionnxcontroller2property, decoder)
860 case 2:
861 return DecodeActionNxController2PropertyReason(_actionnxcontroller2property, decoder)
862 case 3:
863 return DecodeActionNxController2PropertyUserdata(_actionnxcontroller2property, decoder)
864 case 4:
865 return DecodeActionNxController2PropertyPause(_actionnxcontroller2property, decoder)
866 case 5:
867 return DecodeActionNxController2PropertyMeterId(_actionnxcontroller2property, decoder)
868 default:
869 return nil, fmt.Errorf("Invalid type '%d' for 'ActionNxController2Property'", _actionnxcontroller2property.Type)
870 }
871}
872
873func NewActionNxController2Property(_type NxActionController2PropType) *ActionNxController2Property {
874 obj := &ActionNxController2Property{}
875 obj.Type = _type
876 return obj
877}
878
879type ActionNxController2PropertyControllerId struct {
880 *ActionNxController2Property
881 ControllerId uint16
882}
883
884type IActionNxController2PropertyControllerId interface {
885 IActionNxController2Property
886 GetControllerId() uint16
887}
888
889func (self *ActionNxController2PropertyControllerId) GetControllerId() uint16 {
890 return self.ControllerId
891}
892
893func (self *ActionNxController2PropertyControllerId) SetControllerId(v uint16) {
894 self.ControllerId = v
895}
896
897func (self *ActionNxController2PropertyControllerId) Serialize(encoder *goloxi.Encoder) error {
898 startIndex := len(encoder.Bytes())
899 if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
900 return err
901 }
902
903 encoder.PutUint16(uint16(self.ControllerId))
904 length := len(encoder.Bytes()) - startIndex
905 alignedLength := ((length + 7) / 8 * 8)
906
907 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
908
909 return nil
910}
911
912func DecodeActionNxController2PropertyControllerId(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyControllerId, error) {
913 _actionnxcontroller2propertycontrollerid := &ActionNxController2PropertyControllerId{ActionNxController2Property: parent}
914 if decoder.Length() < 2 {
915 return nil, fmt.Errorf("ActionNxController2PropertyControllerId packet too short: %d < 2", decoder.Length())
916 }
917 defer decoder.SkipAlign()
918
919 _actionnxcontroller2propertycontrollerid.ControllerId = uint16(decoder.ReadUint16())
920 return _actionnxcontroller2propertycontrollerid, nil
921}
922
923func NewActionNxController2PropertyControllerId() *ActionNxController2PropertyControllerId {
924 obj := &ActionNxController2PropertyControllerId{
925 ActionNxController2Property: NewActionNxController2Property(1),
926 }
927 return obj
928}
929
930type ActionNxController2PropertyMaxLen struct {
931 *ActionNxController2Property
932 MaxLen uint16
933}
934
935type IActionNxController2PropertyMaxLen interface {
936 IActionNxController2Property
937 GetMaxLen() uint16
938}
939
940func (self *ActionNxController2PropertyMaxLen) GetMaxLen() uint16 {
941 return self.MaxLen
942}
943
944func (self *ActionNxController2PropertyMaxLen) SetMaxLen(v uint16) {
945 self.MaxLen = v
946}
947
948func (self *ActionNxController2PropertyMaxLen) Serialize(encoder *goloxi.Encoder) error {
949 startIndex := len(encoder.Bytes())
950 if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
951 return err
952 }
953
954 encoder.PutUint16(uint16(self.MaxLen))
955 length := len(encoder.Bytes()) - startIndex
956 alignedLength := ((length + 7) / 8 * 8)
957
958 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
959
960 return nil
961}
962
963func DecodeActionNxController2PropertyMaxLen(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyMaxLen, error) {
964 _actionnxcontroller2propertymaxlen := &ActionNxController2PropertyMaxLen{ActionNxController2Property: parent}
965 if decoder.Length() < 2 {
966 return nil, fmt.Errorf("ActionNxController2PropertyMaxLen packet too short: %d < 2", decoder.Length())
967 }
968 defer decoder.SkipAlign()
969
970 _actionnxcontroller2propertymaxlen.MaxLen = uint16(decoder.ReadUint16())
971 return _actionnxcontroller2propertymaxlen, nil
972}
973
974func NewActionNxController2PropertyMaxLen() *ActionNxController2PropertyMaxLen {
975 obj := &ActionNxController2PropertyMaxLen{
976 ActionNxController2Property: NewActionNxController2Property(0),
977 }
978 return obj
979}
980
981type ActionNxController2PropertyMeterId struct {
982 *ActionNxController2Property
983 MeterId uint32
984}
985
986type IActionNxController2PropertyMeterId interface {
987 IActionNxController2Property
988 GetMeterId() uint32
989}
990
991func (self *ActionNxController2PropertyMeterId) GetMeterId() uint32 {
992 return self.MeterId
993}
994
995func (self *ActionNxController2PropertyMeterId) SetMeterId(v uint32) {
996 self.MeterId = v
997}
998
999func (self *ActionNxController2PropertyMeterId) Serialize(encoder *goloxi.Encoder) error {
1000 startIndex := len(encoder.Bytes())
1001 if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
1002 return err
1003 }
1004
1005 encoder.PutUint32(uint32(self.MeterId))
1006 length := len(encoder.Bytes()) - startIndex
1007 alignedLength := ((length + 7) / 8 * 8)
1008
1009 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
1010
1011 return nil
1012}
1013
1014func DecodeActionNxController2PropertyMeterId(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyMeterId, error) {
1015 _actionnxcontroller2propertymeterid := &ActionNxController2PropertyMeterId{ActionNxController2Property: parent}
1016 if decoder.Length() < 4 {
1017 return nil, fmt.Errorf("ActionNxController2PropertyMeterId packet too short: %d < 4", decoder.Length())
1018 }
1019 defer decoder.SkipAlign()
1020
1021 _actionnxcontroller2propertymeterid.MeterId = uint32(decoder.ReadUint32())
1022 return _actionnxcontroller2propertymeterid, nil
1023}
1024
1025func NewActionNxController2PropertyMeterId() *ActionNxController2PropertyMeterId {
1026 obj := &ActionNxController2PropertyMeterId{
1027 ActionNxController2Property: NewActionNxController2Property(5),
1028 }
1029 return obj
1030}
1031
1032type ActionNxController2PropertyPause struct {
1033 *ActionNxController2Property
1034}
1035
1036type IActionNxController2PropertyPause interface {
1037 IActionNxController2Property
1038}
1039
1040func (self *ActionNxController2PropertyPause) Serialize(encoder *goloxi.Encoder) error {
1041 startIndex := len(encoder.Bytes())
1042 if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
1043 return err
1044 }
1045 length := len(encoder.Bytes()) - startIndex
1046 alignedLength := ((length + 7) / 8 * 8)
1047
1048 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
1049
1050 return nil
1051}
1052
1053func DecodeActionNxController2PropertyPause(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyPause, error) {
1054 _actionnxcontroller2propertypause := &ActionNxController2PropertyPause{ActionNxController2Property: parent}
1055 defer decoder.SkipAlign()
1056
1057 return _actionnxcontroller2propertypause, nil
1058}
1059
1060func NewActionNxController2PropertyPause() *ActionNxController2PropertyPause {
1061 obj := &ActionNxController2PropertyPause{
1062 ActionNxController2Property: NewActionNxController2Property(4),
1063 }
1064 return obj
1065}
1066
1067type ActionNxController2PropertyReason struct {
1068 *ActionNxController2Property
1069 Reason PacketInReason
1070}
1071
1072type IActionNxController2PropertyReason interface {
1073 IActionNxController2Property
1074 GetReason() PacketInReason
1075}
1076
1077func (self *ActionNxController2PropertyReason) GetReason() PacketInReason {
1078 return self.Reason
1079}
1080
1081func (self *ActionNxController2PropertyReason) SetReason(v PacketInReason) {
1082 self.Reason = v
1083}
1084
1085func (self *ActionNxController2PropertyReason) Serialize(encoder *goloxi.Encoder) error {
1086 startIndex := len(encoder.Bytes())
1087 if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
1088 return err
1089 }
1090
1091 encoder.PutUint8(uint8(self.Reason))
1092 length := len(encoder.Bytes()) - startIndex
1093 alignedLength := ((length + 7) / 8 * 8)
1094
1095 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
1096
1097 return nil
1098}
1099
1100func DecodeActionNxController2PropertyReason(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyReason, error) {
1101 _actionnxcontroller2propertyreason := &ActionNxController2PropertyReason{ActionNxController2Property: parent}
1102 if decoder.Length() < 1 {
1103 return nil, fmt.Errorf("ActionNxController2PropertyReason packet too short: %d < 1", decoder.Length())
1104 }
1105 defer decoder.SkipAlign()
1106
1107 _actionnxcontroller2propertyreason.Reason = PacketInReason(decoder.ReadByte())
1108 return _actionnxcontroller2propertyreason, nil
1109}
1110
1111func NewActionNxController2PropertyReason() *ActionNxController2PropertyReason {
1112 obj := &ActionNxController2PropertyReason{
1113 ActionNxController2Property: NewActionNxController2Property(2),
1114 }
1115 return obj
1116}
1117
1118type ActionNxController2PropertyUserdata struct {
1119 *ActionNxController2Property
1120 Length uint16
1121 Userdata []byte
1122}
1123
1124type IActionNxController2PropertyUserdata interface {
1125 IActionNxController2Property
1126 GetLength() uint16
1127 GetUserdata() []byte
1128}
1129
1130func (self *ActionNxController2PropertyUserdata) GetLength() uint16 {
1131 return self.Length
1132}
1133
1134func (self *ActionNxController2PropertyUserdata) SetLength(v uint16) {
1135 self.Length = v
1136}
1137
1138func (self *ActionNxController2PropertyUserdata) GetUserdata() []byte {
1139 return self.Userdata
1140}
1141
1142func (self *ActionNxController2PropertyUserdata) SetUserdata(v []byte) {
1143 self.Userdata = v
1144}
1145
1146func (self *ActionNxController2PropertyUserdata) Serialize(encoder *goloxi.Encoder) error {
1147 startIndex := len(encoder.Bytes())
1148 if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
1149 return err
1150 }
1151
1152 encoder.PutUint16(uint16(self.Length))
1153 encoder.Write(self.Userdata)
1154 length := len(encoder.Bytes()) - startIndex
1155 alignedLength := ((length + 7) / 8 * 8)
1156
1157 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1158
1159 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
1160
1161 return nil
1162}
1163
1164func DecodeActionNxController2PropertyUserdata(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyUserdata, error) {
1165 _actionnxcontroller2propertyuserdata := &ActionNxController2PropertyUserdata{ActionNxController2Property: parent}
1166 if decoder.Length() < 2 {
1167 return nil, fmt.Errorf("ActionNxController2PropertyUserdata packet too short: %d < 2", decoder.Length())
1168 }
1169 defer decoder.SkipAlign()
1170
1171 _actionnxcontroller2propertyuserdata.Length = uint16(decoder.ReadUint16())
1172 oldDecoder := decoder
1173 defer func() { decoder = oldDecoder }()
1174 decoder = decoder.SliceDecoder(int(((_actionnxcontroller2propertyuserdata.Length)+7)/8*8), 2+2)
1175 _actionnxcontroller2propertyuserdata.Userdata = decoder.Read(int(decoder.Length()))
1176 return _actionnxcontroller2propertyuserdata, nil
1177}
1178
1179func NewActionNxController2PropertyUserdata() *ActionNxController2PropertyUserdata {
1180 obj := &ActionNxController2PropertyUserdata{
1181 ActionNxController2Property: NewActionNxController2Property(3),
1182 }
1183 return obj
1184}
1185
1186type BsnInterface struct {
1187 HwAddr net.HardwareAddr
1188 Name string
1189 Ipv4Addr net.IP
1190 Ipv4Netmask net.IP
1191}
1192
1193type IBsnInterface interface {
1194 goloxi.Serializable
1195 GetHwAddr() net.HardwareAddr
1196 GetName() string
1197 GetIpv4Addr() net.IP
1198 GetIpv4Netmask() net.IP
1199}
1200
1201func (self *BsnInterface) GetHwAddr() net.HardwareAddr {
1202 return self.HwAddr
1203}
1204
1205func (self *BsnInterface) SetHwAddr(v net.HardwareAddr) {
1206 self.HwAddr = v
1207}
1208
1209func (self *BsnInterface) GetName() string {
1210 return self.Name
1211}
1212
1213func (self *BsnInterface) SetName(v string) {
1214 self.Name = v
1215}
1216
1217func (self *BsnInterface) GetIpv4Addr() net.IP {
1218 return self.Ipv4Addr
1219}
1220
1221func (self *BsnInterface) SetIpv4Addr(v net.IP) {
1222 self.Ipv4Addr = v
1223}
1224
1225func (self *BsnInterface) GetIpv4Netmask() net.IP {
1226 return self.Ipv4Netmask
1227}
1228
1229func (self *BsnInterface) SetIpv4Netmask(v net.IP) {
1230 self.Ipv4Netmask = v
1231}
1232
1233func (self *BsnInterface) Serialize(encoder *goloxi.Encoder) error {
1234
1235 encoder.Write(self.HwAddr)
1236 encoder.Write(bytes.Repeat([]byte{0}, 2))
1237 encoder.Write([]byte(self.Name))
1238 encoder.Write(self.Ipv4Addr.To4())
1239 encoder.Write(self.Ipv4Netmask.To4())
1240
1241 return nil
1242}
1243
1244func DecodeBsnInterface(decoder *goloxi.Decoder) (*BsnInterface, error) {
1245 _bsninterface := &BsnInterface{}
1246 if decoder.Length() < 32 {
1247 return nil, fmt.Errorf("BsnInterface packet too short: %d < 32", decoder.Length())
1248 }
1249 _bsninterface.HwAddr = net.HardwareAddr(decoder.Read(6))
1250 decoder.Skip(2)
1251 _bsninterface.Name = string(bytes.Trim(decoder.Read(16), "\x00"))
1252 _bsninterface.Ipv4Addr = net.IP(decoder.Read(4))
1253 _bsninterface.Ipv4Netmask = net.IP(decoder.Read(4))
1254 return _bsninterface, nil
1255}
1256
1257func NewBsnInterface() *BsnInterface {
1258 obj := &BsnInterface{}
1259 return obj
1260}
1261
1262type BsnVport struct {
1263 Type uint16
1264 Length uint16
1265}
1266
1267type IBsnVport interface {
1268 goloxi.Serializable
1269 GetType() uint16
1270 GetLength() uint16
1271}
1272
1273func (self *BsnVport) GetType() uint16 {
1274 return self.Type
1275}
1276
1277func (self *BsnVport) SetType(v uint16) {
1278 self.Type = v
1279}
1280
1281func (self *BsnVport) GetLength() uint16 {
1282 return self.Length
1283}
1284
1285func (self *BsnVport) SetLength(v uint16) {
1286 self.Length = v
1287}
1288
1289func (self *BsnVport) Serialize(encoder *goloxi.Encoder) error {
1290
1291 encoder.PutUint16(uint16(self.Type))
1292 encoder.PutUint16(uint16(self.Length))
1293
1294 return nil
1295}
1296func (self *BsnVport) Decode(decoder *goloxi.Decoder) error {
1297 if decoder.Length() < 4 {
1298 return fmt.Errorf("BsnVport packet too short: %d < 4", decoder.Length())
1299 }
1300
1301 self.Type = uint16(decoder.ReadUint16())
1302 self.Length = uint16(decoder.ReadUint16())
1303 oldDecoder := decoder
1304 defer func() { decoder = oldDecoder }()
1305 decoder = decoder.SliceDecoder(int(self.Length), 2+2)
1306
1307 return nil
1308}
1309
1310func NewBsnVport(_type uint16) *BsnVport {
1311 obj := &BsnVport{}
1312 obj.Type = _type
1313 return obj
1314}
1315
1316type BsnVportL2Gre struct {
1317 *BsnVport
1318 Flags BsnVportL2GreFlags
1319 PortNo Port
1320 LoopbackPortNo Port
1321 LocalMac net.HardwareAddr
1322 NhMac net.HardwareAddr
1323 SrcIp net.IP
1324 DstIp net.IP
1325 Dscp uint8
1326 Ttl uint8
1327 Vpn uint32
1328 RateLimit uint32
1329 IfName string
1330}
1331
1332type IBsnVportL2Gre interface {
1333 IBsnVport
1334 GetFlags() BsnVportL2GreFlags
1335 GetPortNo() Port
1336 GetLoopbackPortNo() Port
1337 GetLocalMac() net.HardwareAddr
1338 GetNhMac() net.HardwareAddr
1339 GetSrcIp() net.IP
1340 GetDstIp() net.IP
1341 GetDscp() uint8
1342 GetTtl() uint8
1343 GetVpn() uint32
1344 GetRateLimit() uint32
1345 GetIfName() string
1346}
1347
1348func (self *BsnVportL2Gre) GetFlags() BsnVportL2GreFlags {
1349 return self.Flags
1350}
1351
1352func (self *BsnVportL2Gre) SetFlags(v BsnVportL2GreFlags) {
1353 self.Flags = v
1354}
1355
1356func (self *BsnVportL2Gre) GetPortNo() Port {
1357 return self.PortNo
1358}
1359
1360func (self *BsnVportL2Gre) SetPortNo(v Port) {
1361 self.PortNo = v
1362}
1363
1364func (self *BsnVportL2Gre) GetLoopbackPortNo() Port {
1365 return self.LoopbackPortNo
1366}
1367
1368func (self *BsnVportL2Gre) SetLoopbackPortNo(v Port) {
1369 self.LoopbackPortNo = v
1370}
1371
1372func (self *BsnVportL2Gre) GetLocalMac() net.HardwareAddr {
1373 return self.LocalMac
1374}
1375
1376func (self *BsnVportL2Gre) SetLocalMac(v net.HardwareAddr) {
1377 self.LocalMac = v
1378}
1379
1380func (self *BsnVportL2Gre) GetNhMac() net.HardwareAddr {
1381 return self.NhMac
1382}
1383
1384func (self *BsnVportL2Gre) SetNhMac(v net.HardwareAddr) {
1385 self.NhMac = v
1386}
1387
1388func (self *BsnVportL2Gre) GetSrcIp() net.IP {
1389 return self.SrcIp
1390}
1391
1392func (self *BsnVportL2Gre) SetSrcIp(v net.IP) {
1393 self.SrcIp = v
1394}
1395
1396func (self *BsnVportL2Gre) GetDstIp() net.IP {
1397 return self.DstIp
1398}
1399
1400func (self *BsnVportL2Gre) SetDstIp(v net.IP) {
1401 self.DstIp = v
1402}
1403
1404func (self *BsnVportL2Gre) GetDscp() uint8 {
1405 return self.Dscp
1406}
1407
1408func (self *BsnVportL2Gre) SetDscp(v uint8) {
1409 self.Dscp = v
1410}
1411
1412func (self *BsnVportL2Gre) GetTtl() uint8 {
1413 return self.Ttl
1414}
1415
1416func (self *BsnVportL2Gre) SetTtl(v uint8) {
1417 self.Ttl = v
1418}
1419
1420func (self *BsnVportL2Gre) GetVpn() uint32 {
1421 return self.Vpn
1422}
1423
1424func (self *BsnVportL2Gre) SetVpn(v uint32) {
1425 self.Vpn = v
1426}
1427
1428func (self *BsnVportL2Gre) GetRateLimit() uint32 {
1429 return self.RateLimit
1430}
1431
1432func (self *BsnVportL2Gre) SetRateLimit(v uint32) {
1433 self.RateLimit = v
1434}
1435
1436func (self *BsnVportL2Gre) GetIfName() string {
1437 return self.IfName
1438}
1439
1440func (self *BsnVportL2Gre) SetIfName(v string) {
1441 self.IfName = v
1442}
1443
1444func (self *BsnVportL2Gre) Serialize(encoder *goloxi.Encoder) error {
1445 startIndex := len(encoder.Bytes())
1446 if err := self.BsnVport.Serialize(encoder); err != nil {
1447 return err
1448 }
1449
1450 encoder.PutUint32(uint32(self.Flags))
1451 self.PortNo.Serialize(encoder)
1452 self.LoopbackPortNo.Serialize(encoder)
1453 encoder.Write(self.LocalMac)
1454 encoder.Write(self.NhMac)
1455 encoder.Write(self.SrcIp.To4())
1456 encoder.Write(self.DstIp.To4())
1457 encoder.PutUint8(uint8(self.Dscp))
1458 encoder.PutUint8(uint8(self.Ttl))
1459 encoder.Write(bytes.Repeat([]byte{0}, 2))
1460 encoder.PutUint32(uint32(self.Vpn))
1461 encoder.PutUint32(uint32(self.RateLimit))
1462 encoder.Write([]byte(self.IfName))
1463 length := len(encoder.Bytes()) - startIndex
1464
1465 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1466
1467 return nil
1468}
1469
1470func DecodeBsnVportL2Gre(parent *BsnVport, decoder *goloxi.Decoder) (*BsnVportL2Gre, error) {
1471 _bsnvportl2gre := &BsnVportL2Gre{BsnVport: parent}
1472 if decoder.Length() < 60 {
1473 return nil, fmt.Errorf("BsnVportL2Gre packet too short: %d < 60", decoder.Length())
1474 }
1475 _bsnvportl2gre.Flags = BsnVportL2GreFlags(decoder.ReadUint32())
1476 _bsnvportl2gre.PortNo.Decode(decoder)
1477 _bsnvportl2gre.LoopbackPortNo.Decode(decoder)
1478 _bsnvportl2gre.LocalMac = net.HardwareAddr(decoder.Read(6))
1479 _bsnvportl2gre.NhMac = net.HardwareAddr(decoder.Read(6))
1480 _bsnvportl2gre.SrcIp = net.IP(decoder.Read(4))
1481 _bsnvportl2gre.DstIp = net.IP(decoder.Read(4))
1482 _bsnvportl2gre.Dscp = uint8(decoder.ReadByte())
1483 _bsnvportl2gre.Ttl = uint8(decoder.ReadByte())
1484 decoder.Skip(2)
1485 _bsnvportl2gre.Vpn = uint32(decoder.ReadUint32())
1486 _bsnvportl2gre.RateLimit = uint32(decoder.ReadUint32())
1487 _bsnvportl2gre.IfName = string(bytes.Trim(decoder.Read(16), "\x00"))
1488 return _bsnvportl2gre, nil
1489}
1490
1491func NewBsnVportL2Gre() *BsnVportL2Gre {
1492 obj := &BsnVportL2Gre{
1493 BsnVport: NewBsnVport(1),
1494 }
1495 return obj
1496}
1497
1498type BsnVportQInQ struct {
1499 *BsnVport
1500 PortNo uint32
1501 IngressTpid uint16
1502 IngressVlanId uint16
1503 EgressTpid uint16
1504 EgressVlanId uint16
1505 IfName string
1506}
1507
1508type IBsnVportQInQ interface {
1509 IBsnVport
1510 GetPortNo() uint32
1511 GetIngressTpid() uint16
1512 GetIngressVlanId() uint16
1513 GetEgressTpid() uint16
1514 GetEgressVlanId() uint16
1515 GetIfName() string
1516}
1517
1518func (self *BsnVportQInQ) GetPortNo() uint32 {
1519 return self.PortNo
1520}
1521
1522func (self *BsnVportQInQ) SetPortNo(v uint32) {
1523 self.PortNo = v
1524}
1525
1526func (self *BsnVportQInQ) GetIngressTpid() uint16 {
1527 return self.IngressTpid
1528}
1529
1530func (self *BsnVportQInQ) SetIngressTpid(v uint16) {
1531 self.IngressTpid = v
1532}
1533
1534func (self *BsnVportQInQ) GetIngressVlanId() uint16 {
1535 return self.IngressVlanId
1536}
1537
1538func (self *BsnVportQInQ) SetIngressVlanId(v uint16) {
1539 self.IngressVlanId = v
1540}
1541
1542func (self *BsnVportQInQ) GetEgressTpid() uint16 {
1543 return self.EgressTpid
1544}
1545
1546func (self *BsnVportQInQ) SetEgressTpid(v uint16) {
1547 self.EgressTpid = v
1548}
1549
1550func (self *BsnVportQInQ) GetEgressVlanId() uint16 {
1551 return self.EgressVlanId
1552}
1553
1554func (self *BsnVportQInQ) SetEgressVlanId(v uint16) {
1555 self.EgressVlanId = v
1556}
1557
1558func (self *BsnVportQInQ) GetIfName() string {
1559 return self.IfName
1560}
1561
1562func (self *BsnVportQInQ) SetIfName(v string) {
1563 self.IfName = v
1564}
1565
1566func (self *BsnVportQInQ) Serialize(encoder *goloxi.Encoder) error {
1567 startIndex := len(encoder.Bytes())
1568 if err := self.BsnVport.Serialize(encoder); err != nil {
1569 return err
1570 }
1571
1572 encoder.PutUint32(uint32(self.PortNo))
1573 encoder.PutUint16(uint16(self.IngressTpid))
1574 encoder.PutUint16(uint16(self.IngressVlanId))
1575 encoder.PutUint16(uint16(self.EgressTpid))
1576 encoder.PutUint16(uint16(self.EgressVlanId))
1577 encoder.Write([]byte(self.IfName))
1578 length := len(encoder.Bytes()) - startIndex
1579
1580 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1581
1582 return nil
1583}
1584
1585func DecodeBsnVportQInQ(parent *BsnVport, decoder *goloxi.Decoder) (*BsnVportQInQ, error) {
1586 _bsnvportqinq := &BsnVportQInQ{BsnVport: parent}
1587 if decoder.Length() < 28 {
1588 return nil, fmt.Errorf("BsnVportQInQ packet too short: %d < 28", decoder.Length())
1589 }
1590 _bsnvportqinq.PortNo = uint32(decoder.ReadUint32())
1591 _bsnvportqinq.IngressTpid = uint16(decoder.ReadUint16())
1592 _bsnvportqinq.IngressVlanId = uint16(decoder.ReadUint16())
1593 _bsnvportqinq.EgressTpid = uint16(decoder.ReadUint16())
1594 _bsnvportqinq.EgressVlanId = uint16(decoder.ReadUint16())
1595 _bsnvportqinq.IfName = string(bytes.Trim(decoder.Read(16), "\x00"))
1596 return _bsnvportqinq, nil
1597}
1598
1599func NewBsnVportQInQ() *BsnVportQInQ {
1600 obj := &BsnVportQInQ{
1601 BsnVport: NewBsnVport(0),
1602 }
1603 return obj
1604}
1605
1606type Bucket struct {
1607 Len uint16
1608 Weight uint16
1609 WatchPort Port
1610 WatchGroup uint32
1611 Actions []goloxi.IAction
1612}
1613
1614type IBucket interface {
1615 goloxi.Serializable
1616 GetLen() uint16
1617 GetWeight() uint16
1618 GetWatchPort() Port
1619 GetWatchGroup() uint32
1620 GetActions() []goloxi.IAction
1621}
1622
1623func (self *Bucket) GetLen() uint16 {
1624 return self.Len
1625}
1626
1627func (self *Bucket) SetLen(v uint16) {
1628 self.Len = v
1629}
1630
1631func (self *Bucket) GetWeight() uint16 {
1632 return self.Weight
1633}
1634
1635func (self *Bucket) SetWeight(v uint16) {
1636 self.Weight = v
1637}
1638
1639func (self *Bucket) GetWatchPort() Port {
1640 return self.WatchPort
1641}
1642
1643func (self *Bucket) SetWatchPort(v Port) {
1644 self.WatchPort = v
1645}
1646
1647func (self *Bucket) GetWatchGroup() uint32 {
1648 return self.WatchGroup
1649}
1650
1651func (self *Bucket) SetWatchGroup(v uint32) {
1652 self.WatchGroup = v
1653}
1654
1655func (self *Bucket) GetActions() []goloxi.IAction {
1656 return self.Actions
1657}
1658
1659func (self *Bucket) SetActions(v []goloxi.IAction) {
1660 self.Actions = v
1661}
1662
1663func (self *Bucket) Serialize(encoder *goloxi.Encoder) error {
1664 startIndex := len(encoder.Bytes())
1665
1666 encoder.PutUint16(uint16(self.Len))
1667 encoder.PutUint16(uint16(self.Weight))
1668 self.WatchPort.Serialize(encoder)
1669 encoder.PutUint32(uint32(self.WatchGroup))
1670 encoder.Write(bytes.Repeat([]byte{0}, 4))
1671 for _, obj := range self.Actions {
1672 if err := obj.Serialize(encoder); err != nil {
1673 return err
1674 }
1675 }
1676 length := len(encoder.Bytes()) - startIndex
1677
1678 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
1679
1680 return nil
1681}
1682
1683func DecodeBucket(decoder *goloxi.Decoder) (*Bucket, error) {
1684 _bucket := &Bucket{}
1685 if decoder.Length() < 16 {
1686 return nil, fmt.Errorf("Bucket packet too short: %d < 16", decoder.Length())
1687 }
1688 _bucket.Len = uint16(decoder.ReadUint16())
1689 oldDecoder := decoder
1690 defer func() { decoder = oldDecoder }()
1691 decoder = decoder.SliceDecoder(int(_bucket.Len), 2+0)
1692 _bucket.Weight = uint16(decoder.ReadUint16())
1693 _bucket.WatchPort.Decode(decoder)
1694 _bucket.WatchGroup = uint32(decoder.ReadUint32())
1695 decoder.Skip(4)
1696
1697 for decoder.Length() >= 8 {
1698 item, err := DecodeAction(decoder)
1699 if err != nil {
1700 return nil, err
1701 }
1702 if item != nil {
1703 _bucket.Actions = append(_bucket.Actions, item)
1704 }
1705 }
1706 return _bucket, nil
1707}
1708
1709func NewBucket() *Bucket {
1710 obj := &Bucket{}
1711 return obj
1712}
1713
1714type BucketCounter struct {
1715 PacketCount uint64
1716 ByteCount uint64
1717}
1718
1719type IBucketCounter interface {
1720 goloxi.Serializable
1721 GetPacketCount() uint64
1722 GetByteCount() uint64
1723}
1724
1725func (self *BucketCounter) GetPacketCount() uint64 {
1726 return self.PacketCount
1727}
1728
1729func (self *BucketCounter) SetPacketCount(v uint64) {
1730 self.PacketCount = v
1731}
1732
1733func (self *BucketCounter) GetByteCount() uint64 {
1734 return self.ByteCount
1735}
1736
1737func (self *BucketCounter) SetByteCount(v uint64) {
1738 self.ByteCount = v
1739}
1740
1741func (self *BucketCounter) Serialize(encoder *goloxi.Encoder) error {
1742
1743 encoder.PutUint64(uint64(self.PacketCount))
1744 encoder.PutUint64(uint64(self.ByteCount))
1745
1746 return nil
1747}
1748
1749func DecodeBucketCounter(decoder *goloxi.Decoder) (*BucketCounter, error) {
1750 _bucketcounter := &BucketCounter{}
1751 if decoder.Length() < 16 {
1752 return nil, fmt.Errorf("BucketCounter packet too short: %d < 16", decoder.Length())
1753 }
1754 _bucketcounter.PacketCount = uint64(decoder.ReadUint64())
1755 _bucketcounter.ByteCount = uint64(decoder.ReadUint64())
1756 return _bucketcounter, nil
1757}
1758
1759func NewBucketCounter() *BucketCounter {
1760 obj := &BucketCounter{}
1761 return obj
1762}
1763
1764type EdPropHeader struct {
1765 PropClass uint16
1766}
1767
1768type IEdPropHeader interface {
1769 goloxi.Serializable
1770 GetPropClass() uint16
1771}
1772
1773func (self *EdPropHeader) GetPropClass() uint16 {
1774 return self.PropClass
1775}
1776
1777func (self *EdPropHeader) SetPropClass(v uint16) {
1778 self.PropClass = v
1779}
1780
1781func (self *EdPropHeader) Serialize(encoder *goloxi.Encoder) error {
1782
1783 encoder.PutUint16(uint16(self.PropClass))
1784
1785 return nil
1786}
1787
1788func DecodeEdPropHeader(decoder *goloxi.Decoder) (IEdPropHeader, error) {
1789 _edpropheader := &EdPropHeader{}
1790 if decoder.Length() < 2 {
1791 return nil, fmt.Errorf("EdPropHeader packet too short: %d < 2", decoder.Length())
1792 }
1793 _edpropheader.PropClass = uint16(decoder.ReadUint16())
1794
1795 switch _edpropheader.PropClass {
1796 case 4:
1797 return DecodeEdPropNsh(_edpropheader, decoder)
1798 default:
1799 return nil, fmt.Errorf("Invalid type '%d' for 'EdPropHeader'", _edpropheader.PropClass)
1800 }
1801}
1802
1803func NewEdPropHeader(_prop_class uint16) *EdPropHeader {
1804 obj := &EdPropHeader{}
1805 obj.PropClass = _prop_class
1806 return obj
1807}
1808
1809type EdPropNsh struct {
1810 *EdPropHeader
1811 Type uint8
1812 Len uint8
1813}
1814
1815type IEdPropNsh interface {
1816 IEdPropHeader
1817 GetType() uint8
1818 GetLen() uint8
1819}
1820
1821func (self *EdPropNsh) GetType() uint8 {
1822 return self.Type
1823}
1824
1825func (self *EdPropNsh) SetType(v uint8) {
1826 self.Type = v
1827}
1828
1829func (self *EdPropNsh) GetLen() uint8 {
1830 return self.Len
1831}
1832
1833func (self *EdPropNsh) SetLen(v uint8) {
1834 self.Len = v
1835}
1836
1837func (self *EdPropNsh) Serialize(encoder *goloxi.Encoder) error {
1838 if err := self.EdPropHeader.Serialize(encoder); err != nil {
1839 return err
1840 }
1841
1842 encoder.PutUint8(uint8(self.Type))
1843 encoder.PutUint8(uint8(self.Len))
1844
1845 return nil
1846}
1847
1848func DecodeEdPropNsh(parent *EdPropHeader, decoder *goloxi.Decoder) (IEdPropNsh, error) {
1849 _edpropnsh := &EdPropNsh{EdPropHeader: parent}
1850 if decoder.Length() < 2 {
1851 return nil, fmt.Errorf("EdPropNsh packet too short: %d < 2", decoder.Length())
1852 }
1853 defer decoder.SkipAlign()
1854
1855 _edpropnsh.Type = uint8(decoder.ReadByte())
1856 _edpropnsh.Len = uint8(decoder.ReadByte())
1857 oldDecoder := decoder
1858 defer func() { decoder = oldDecoder }()
1859 decoder = decoder.SliceDecoder(int(((_edpropnsh.Len)+7)/8*8), 1+3)
1860
1861 switch _edpropnsh.Type {
1862 case 1:
1863 return DecodeEdPropNshMdType(_edpropnsh, decoder)
1864 case 2:
1865 return DecodeEdPropNshTlv(_edpropnsh, decoder)
1866 default:
1867 return nil, fmt.Errorf("Invalid type '%d' for 'EdPropNsh'", _edpropnsh.Type)
1868 }
1869}
1870
1871func NewEdPropNsh(_type uint8) *EdPropNsh {
1872 obj := &EdPropNsh{
1873 EdPropHeader: NewEdPropHeader(4),
1874 }
1875 obj.Type = _type
1876 return obj
1877}
1878
1879type EdPropNshMdType struct {
1880 *EdPropNsh
1881 MdType uint8
1882}
1883
1884type IEdPropNshMdType interface {
1885 IEdPropNsh
1886 GetMdType() uint8
1887}
1888
1889func (self *EdPropNshMdType) GetMdType() uint8 {
1890 return self.MdType
1891}
1892
1893func (self *EdPropNshMdType) SetMdType(v uint8) {
1894 self.MdType = v
1895}
1896
1897func (self *EdPropNshMdType) Serialize(encoder *goloxi.Encoder) error {
1898 startIndex := len(encoder.Bytes())
1899 if err := self.EdPropNsh.Serialize(encoder); err != nil {
1900 return err
1901 }
1902
1903 encoder.PutUint8(uint8(self.MdType))
1904 encoder.Write(bytes.Repeat([]byte{0}, 3))
1905 length := len(encoder.Bytes()) - startIndex
1906
1907 encoder.Bytes()[startIndex+3] = uint8(length)
1908
1909 return nil
1910}
1911
1912func DecodeEdPropNshMdType(parent *EdPropNsh, decoder *goloxi.Decoder) (*EdPropNshMdType, error) {
1913 _edpropnshmdtype := &EdPropNshMdType{EdPropNsh: parent}
1914 if decoder.Length() < 4 {
1915 return nil, fmt.Errorf("EdPropNshMdType packet too short: %d < 4", decoder.Length())
1916 }
1917 _edpropnshmdtype.MdType = uint8(decoder.ReadByte())
1918 decoder.Skip(3)
1919 return _edpropnshmdtype, nil
1920}
1921
1922func NewEdPropNshMdType() *EdPropNshMdType {
1923 obj := &EdPropNshMdType{
1924 EdPropNsh: NewEdPropNsh(1),
1925 }
1926 return obj
1927}
1928
1929type EdPropNshTlv struct {
1930 *EdPropNsh
1931 TlvClass uint16
1932 TlvType uint8
1933 TlvLen uint8
1934 Value []byte
1935}
1936
1937type IEdPropNshTlv interface {
1938 IEdPropNsh
1939 GetTlvClass() uint16
1940 GetTlvType() uint8
1941 GetTlvLen() uint8
1942 GetValue() []byte
1943}
1944
1945func (self *EdPropNshTlv) GetTlvClass() uint16 {
1946 return self.TlvClass
1947}
1948
1949func (self *EdPropNshTlv) SetTlvClass(v uint16) {
1950 self.TlvClass = v
1951}
1952
1953func (self *EdPropNshTlv) GetTlvType() uint8 {
1954 return self.TlvType
1955}
1956
1957func (self *EdPropNshTlv) SetTlvType(v uint8) {
1958 self.TlvType = v
1959}
1960
1961func (self *EdPropNshTlv) GetTlvLen() uint8 {
1962 return self.TlvLen
1963}
1964
1965func (self *EdPropNshTlv) SetTlvLen(v uint8) {
1966 self.TlvLen = v
1967}
1968
1969func (self *EdPropNshTlv) GetValue() []byte {
1970 return self.Value
1971}
1972
1973func (self *EdPropNshTlv) SetValue(v []byte) {
1974 self.Value = v
1975}
1976
1977func (self *EdPropNshTlv) Serialize(encoder *goloxi.Encoder) error {
1978 startIndex := len(encoder.Bytes())
1979 if err := self.EdPropNsh.Serialize(encoder); err != nil {
1980 return err
1981 }
1982
1983 encoder.PutUint16(uint16(self.TlvClass))
1984 encoder.PutUint8(uint8(self.TlvType))
1985 encoder.PutUint8(uint8(self.TlvLen))
1986 encoder.Write(self.Value)
1987 length := len(encoder.Bytes()) - startIndex
1988
1989 encoder.Bytes()[startIndex+3] = uint8(length)
1990
1991 return nil
1992}
1993
1994func DecodeEdPropNshTlv(parent *EdPropNsh, decoder *goloxi.Decoder) (*EdPropNshTlv, error) {
1995 _edpropnshtlv := &EdPropNshTlv{EdPropNsh: parent}
1996 if decoder.Length() < 4 {
1997 return nil, fmt.Errorf("EdPropNshTlv packet too short: %d < 4", decoder.Length())
1998 }
1999 _edpropnshtlv.TlvClass = uint16(decoder.ReadUint16())
2000 _edpropnshtlv.TlvType = uint8(decoder.ReadByte())
2001 _edpropnshtlv.TlvLen = uint8(decoder.ReadByte())
2002 _edpropnshtlv.Value = decoder.SliceDecoder(int(_edpropnshtlv.TlvLen), 0).Read(int(_edpropnshtlv.TlvLen))
2003 return _edpropnshtlv, nil
2004}
2005
2006func NewEdPropNshTlv() *EdPropNshTlv {
2007 obj := &EdPropNshTlv{
2008 EdPropNsh: NewEdPropNsh(2),
2009 }
2010 return obj
2011}
2012
2013type FlowModSpec struct {
2014 SrcDst uint8
2015 NBits uint8
2016}
2017
2018type IFlowModSpec interface {
2019 goloxi.Serializable
2020 GetSrcDst() uint8
2021 GetNBits() uint8
2022}
2023
2024func (self *FlowModSpec) GetSrcDst() uint8 {
2025 return self.SrcDst
2026}
2027
2028func (self *FlowModSpec) SetSrcDst(v uint8) {
2029 self.SrcDst = v
2030}
2031
2032func (self *FlowModSpec) GetNBits() uint8 {
2033 return self.NBits
2034}
2035
2036func (self *FlowModSpec) SetNBits(v uint8) {
2037 self.NBits = v
2038}
2039
2040func (self *FlowModSpec) Serialize(encoder *goloxi.Encoder) error {
2041
2042 encoder.PutUint8(uint8(self.SrcDst))
2043 encoder.PutUint8(uint8(self.NBits))
2044
2045 return nil
2046}
2047
2048func DecodeFlowModSpec(decoder *goloxi.Decoder) (IFlowModSpec, error) {
2049 _flowmodspec := &FlowModSpec{}
2050 if decoder.Length() < 2 {
2051 return nil, fmt.Errorf("FlowModSpec packet too short: %d < 2", decoder.Length())
2052 }
2053 _flowmodspec.SrcDst = uint8(decoder.ReadByte())
2054 _flowmodspec.NBits = uint8(decoder.ReadByte())
2055 if _flowmodspec.SrcDst == 0 && _flowmodspec.NBits == 0 {
2056 return nil, nil
2057 }
2058
2059 switch _flowmodspec.SrcDst {
2060 case 0:
2061 return DecodeFlowModSpecSrc0Dst0(_flowmodspec, decoder)
2062 case 8:
2063 return DecodeFlowModSpecSrc0Dst1(_flowmodspec, decoder)
2064 case 40:
2065 return DecodeFlowModSpecSrc1Dst1(_flowmodspec, decoder)
2066 case 16:
2067 return DecodeFlowModSpecSrc0Dst2(_flowmodspec, decoder)
2068 case 32:
2069 return DecodeFlowModSpecSrc1Dst0(_flowmodspec, decoder)
2070 default:
2071 return nil, fmt.Errorf("Invalid type '%d' for 'FlowModSpec'", _flowmodspec.SrcDst)
2072 }
2073}
2074
2075func NewFlowModSpec(_src_dst uint8) *FlowModSpec {
2076 obj := &FlowModSpec{}
2077 obj.SrcDst = _src_dst
2078 return obj
2079}
2080
2081type FlowModSpecSrc0Dst0 struct {
2082 *FlowModSpec
2083 Src goloxi.IOxmId
2084 SrcOfs uint16
2085 Dst goloxi.IOxmId
2086 DstOfs uint16
2087}
2088
2089type IFlowModSpecSrc0Dst0 interface {
2090 IFlowModSpec
2091 GetSrc() goloxi.IOxmId
2092 GetSrcOfs() uint16
2093 GetDst() goloxi.IOxmId
2094 GetDstOfs() uint16
2095}
2096
2097func (self *FlowModSpecSrc0Dst0) GetSrc() goloxi.IOxmId {
2098 return self.Src
2099}
2100
2101func (self *FlowModSpecSrc0Dst0) SetSrc(v goloxi.IOxmId) {
2102 self.Src = v
2103}
2104
2105func (self *FlowModSpecSrc0Dst0) GetSrcOfs() uint16 {
2106 return self.SrcOfs
2107}
2108
2109func (self *FlowModSpecSrc0Dst0) SetSrcOfs(v uint16) {
2110 self.SrcOfs = v
2111}
2112
2113func (self *FlowModSpecSrc0Dst0) GetDst() goloxi.IOxmId {
2114 return self.Dst
2115}
2116
2117func (self *FlowModSpecSrc0Dst0) SetDst(v goloxi.IOxmId) {
2118 self.Dst = v
2119}
2120
2121func (self *FlowModSpecSrc0Dst0) GetDstOfs() uint16 {
2122 return self.DstOfs
2123}
2124
2125func (self *FlowModSpecSrc0Dst0) SetDstOfs(v uint16) {
2126 self.DstOfs = v
2127}
2128
2129func (self *FlowModSpecSrc0Dst0) Serialize(encoder *goloxi.Encoder) error {
2130 if err := self.FlowModSpec.Serialize(encoder); err != nil {
2131 return err
2132 }
2133
2134 self.Src.Serialize(encoder)
2135 encoder.PutUint16(uint16(self.SrcOfs))
2136 self.Dst.Serialize(encoder)
2137 encoder.PutUint16(uint16(self.DstOfs))
2138
2139 return nil
2140}
2141
2142func DecodeFlowModSpecSrc0Dst0(parent *FlowModSpec, decoder *goloxi.Decoder) (IFlowModSpecSrc0Dst0, error) {
2143 _flowmodspecsrc0dst0 := &FlowModSpecSrc0Dst0{FlowModSpec: parent}
2144 if decoder.Length() < 12 {
2145 return nil, fmt.Errorf("FlowModSpecSrc0Dst0 packet too short: %d < 12", decoder.Length())
2146 }
2147 if obj, err := DecodeOxmId(decoder); err != nil {
2148 return nil, err
2149 } else {
2150 _flowmodspecsrc0dst0.Src = obj
2151 }
2152
2153 _flowmodspecsrc0dst0.SrcOfs = uint16(decoder.ReadUint16())
2154 if obj, err := DecodeOxmId(decoder); err != nil {
2155 return nil, err
2156 } else {
2157 _flowmodspecsrc0dst0.Dst = obj
2158 }
2159
2160 _flowmodspecsrc0dst0.DstOfs = uint16(decoder.ReadUint16())
2161 return _flowmodspecsrc0dst0, nil
2162}
2163
2164func NewFlowModSpecSrc0Dst0(_n_bits uint8) *FlowModSpecSrc0Dst0 {
2165 obj := &FlowModSpecSrc0Dst0{
2166 FlowModSpec: NewFlowModSpec(0),
2167 }
2168 obj.NBits = _n_bits
2169 return obj
2170}
2171
2172type FlowModSpecSrc0Dst1 struct {
2173 *FlowModSpec
2174 Src goloxi.IOxmId
2175 SrcOfs uint16
2176 Dst goloxi.IOxmId
2177 DstOfs uint16
2178}
2179
2180type IFlowModSpecSrc0Dst1 interface {
2181 IFlowModSpec
2182 GetSrc() goloxi.IOxmId
2183 GetSrcOfs() uint16
2184 GetDst() goloxi.IOxmId
2185 GetDstOfs() uint16
2186}
2187
2188func (self *FlowModSpecSrc0Dst1) GetSrc() goloxi.IOxmId {
2189 return self.Src
2190}
2191
2192func (self *FlowModSpecSrc0Dst1) SetSrc(v goloxi.IOxmId) {
2193 self.Src = v
2194}
2195
2196func (self *FlowModSpecSrc0Dst1) GetSrcOfs() uint16 {
2197 return self.SrcOfs
2198}
2199
2200func (self *FlowModSpecSrc0Dst1) SetSrcOfs(v uint16) {
2201 self.SrcOfs = v
2202}
2203
2204func (self *FlowModSpecSrc0Dst1) GetDst() goloxi.IOxmId {
2205 return self.Dst
2206}
2207
2208func (self *FlowModSpecSrc0Dst1) SetDst(v goloxi.IOxmId) {
2209 self.Dst = v
2210}
2211
2212func (self *FlowModSpecSrc0Dst1) GetDstOfs() uint16 {
2213 return self.DstOfs
2214}
2215
2216func (self *FlowModSpecSrc0Dst1) SetDstOfs(v uint16) {
2217 self.DstOfs = v
2218}
2219
2220func (self *FlowModSpecSrc0Dst1) Serialize(encoder *goloxi.Encoder) error {
2221 if err := self.FlowModSpec.Serialize(encoder); err != nil {
2222 return err
2223 }
2224
2225 self.Src.Serialize(encoder)
2226 encoder.PutUint16(uint16(self.SrcOfs))
2227 self.Dst.Serialize(encoder)
2228 encoder.PutUint16(uint16(self.DstOfs))
2229
2230 return nil
2231}
2232
2233func DecodeFlowModSpecSrc0Dst1(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc0Dst1, error) {
2234 _flowmodspecsrc0dst1 := &FlowModSpecSrc0Dst1{FlowModSpec: parent}
2235 if decoder.Length() < 12 {
2236 return nil, fmt.Errorf("FlowModSpecSrc0Dst1 packet too short: %d < 12", decoder.Length())
2237 }
2238 if obj, err := DecodeOxmId(decoder); err != nil {
2239 return nil, err
2240 } else {
2241 _flowmodspecsrc0dst1.Src = obj
2242 }
2243
2244 _flowmodspecsrc0dst1.SrcOfs = uint16(decoder.ReadUint16())
2245 if obj, err := DecodeOxmId(decoder); err != nil {
2246 return nil, err
2247 } else {
2248 _flowmodspecsrc0dst1.Dst = obj
2249 }
2250
2251 _flowmodspecsrc0dst1.DstOfs = uint16(decoder.ReadUint16())
2252 return _flowmodspecsrc0dst1, nil
2253}
2254
2255func NewFlowModSpecSrc0Dst1() *FlowModSpecSrc0Dst1 {
2256 obj := &FlowModSpecSrc0Dst1{
2257 FlowModSpec: NewFlowModSpec(8),
2258 }
2259 return obj
2260}
2261
2262type FlowModSpecSrc0Dst2 struct {
2263 *FlowModSpec
2264 Src goloxi.IOxmId
2265 SrcOfs uint16
2266}
2267
2268type IFlowModSpecSrc0Dst2 interface {
2269 IFlowModSpec
2270 GetSrc() goloxi.IOxmId
2271 GetSrcOfs() uint16
2272}
2273
2274func (self *FlowModSpecSrc0Dst2) GetSrc() goloxi.IOxmId {
2275 return self.Src
2276}
2277
2278func (self *FlowModSpecSrc0Dst2) SetSrc(v goloxi.IOxmId) {
2279 self.Src = v
2280}
2281
2282func (self *FlowModSpecSrc0Dst2) GetSrcOfs() uint16 {
2283 return self.SrcOfs
2284}
2285
2286func (self *FlowModSpecSrc0Dst2) SetSrcOfs(v uint16) {
2287 self.SrcOfs = v
2288}
2289
2290func (self *FlowModSpecSrc0Dst2) Serialize(encoder *goloxi.Encoder) error {
2291 if err := self.FlowModSpec.Serialize(encoder); err != nil {
2292 return err
2293 }
2294
2295 self.Src.Serialize(encoder)
2296 encoder.PutUint16(uint16(self.SrcOfs))
2297
2298 return nil
2299}
2300
2301func DecodeFlowModSpecSrc0Dst2(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc0Dst2, error) {
2302 _flowmodspecsrc0dst2 := &FlowModSpecSrc0Dst2{FlowModSpec: parent}
2303 if decoder.Length() < 6 {
2304 return nil, fmt.Errorf("FlowModSpecSrc0Dst2 packet too short: %d < 6", decoder.Length())
2305 }
2306 if obj, err := DecodeOxmId(decoder); err != nil {
2307 return nil, err
2308 } else {
2309 _flowmodspecsrc0dst2.Src = obj
2310 }
2311
2312 _flowmodspecsrc0dst2.SrcOfs = uint16(decoder.ReadUint16())
2313 return _flowmodspecsrc0dst2, nil
2314}
2315
2316func NewFlowModSpecSrc0Dst2() *FlowModSpecSrc0Dst2 {
2317 obj := &FlowModSpecSrc0Dst2{
2318 FlowModSpec: NewFlowModSpec(16),
2319 }
2320 return obj
2321}
2322
2323type FlowModSpecSrc1Dst0 struct {
2324 *FlowModSpec
2325 Src []byte
2326 Dst goloxi.IOxmId
2327 DstOfs uint16
2328}
2329
2330type IFlowModSpecSrc1Dst0 interface {
2331 IFlowModSpec
2332 GetSrc() []byte
2333 GetDst() goloxi.IOxmId
2334 GetDstOfs() uint16
2335}
2336
2337func (self *FlowModSpecSrc1Dst0) GetSrc() []byte {
2338 return self.Src
2339}
2340
2341func (self *FlowModSpecSrc1Dst0) SetSrc(v []byte) {
2342 self.Src = v
2343}
2344
2345func (self *FlowModSpecSrc1Dst0) GetDst() goloxi.IOxmId {
2346 return self.Dst
2347}
2348
2349func (self *FlowModSpecSrc1Dst0) SetDst(v goloxi.IOxmId) {
2350 self.Dst = v
2351}
2352
2353func (self *FlowModSpecSrc1Dst0) GetDstOfs() uint16 {
2354 return self.DstOfs
2355}
2356
2357func (self *FlowModSpecSrc1Dst0) SetDstOfs(v uint16) {
2358 self.DstOfs = v
2359}
2360
2361func (self *FlowModSpecSrc1Dst0) Serialize(encoder *goloxi.Encoder) error {
2362 if err := self.FlowModSpec.Serialize(encoder); err != nil {
2363 return err
2364 }
2365
2366 encoder.Write(self.Src)
2367 self.Dst.Serialize(encoder)
2368 encoder.PutUint16(uint16(self.DstOfs))
2369
2370 return nil
2371}
2372
2373func DecodeFlowModSpecSrc1Dst0(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc1Dst0, error) {
2374 _flowmodspecsrc1dst0 := &FlowModSpecSrc1Dst0{FlowModSpec: parent}
2375 if decoder.Length() < 6 {
2376 return nil, fmt.Errorf("FlowModSpecSrc1Dst0 packet too short: %d < 6", decoder.Length())
2377 }
2378 _flowmodspecsrc1dst0.Src = decoder.SliceDecoder(int((_flowmodspecsrc1dst0.NBits+15)/16*2), 0).Read(int(_flowmodspecsrc1dst0.NBits))
2379 if obj, err := DecodeOxmId(decoder); err != nil {
2380 return nil, err
2381 } else {
2382 _flowmodspecsrc1dst0.Dst = obj
2383 }
2384
2385 _flowmodspecsrc1dst0.DstOfs = uint16(decoder.ReadUint16())
2386 return _flowmodspecsrc1dst0, nil
2387}
2388
2389func NewFlowModSpecSrc1Dst0() *FlowModSpecSrc1Dst0 {
2390 obj := &FlowModSpecSrc1Dst0{
2391 FlowModSpec: NewFlowModSpec(32),
2392 }
2393 return obj
2394}
2395
2396type FlowModSpecSrc1Dst1 struct {
2397 *FlowModSpec
2398 Src []byte
2399 Dst goloxi.IOxmId
2400 DstOfs uint16
2401}
2402
2403type IFlowModSpecSrc1Dst1 interface {
2404 IFlowModSpec
2405 GetSrc() []byte
2406 GetDst() goloxi.IOxmId
2407 GetDstOfs() uint16
2408}
2409
2410func (self *FlowModSpecSrc1Dst1) GetSrc() []byte {
2411 return self.Src
2412}
2413
2414func (self *FlowModSpecSrc1Dst1) SetSrc(v []byte) {
2415 self.Src = v
2416}
2417
2418func (self *FlowModSpecSrc1Dst1) GetDst() goloxi.IOxmId {
2419 return self.Dst
2420}
2421
2422func (self *FlowModSpecSrc1Dst1) SetDst(v goloxi.IOxmId) {
2423 self.Dst = v
2424}
2425
2426func (self *FlowModSpecSrc1Dst1) GetDstOfs() uint16 {
2427 return self.DstOfs
2428}
2429
2430func (self *FlowModSpecSrc1Dst1) SetDstOfs(v uint16) {
2431 self.DstOfs = v
2432}
2433
2434func (self *FlowModSpecSrc1Dst1) Serialize(encoder *goloxi.Encoder) error {
2435 if err := self.FlowModSpec.Serialize(encoder); err != nil {
2436 return err
2437 }
2438
2439 encoder.Write(self.Src)
2440 self.Dst.Serialize(encoder)
2441 encoder.PutUint16(uint16(self.DstOfs))
2442
2443 return nil
2444}
2445
2446func DecodeFlowModSpecSrc1Dst1(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc1Dst1, error) {
2447 _flowmodspecsrc1dst1 := &FlowModSpecSrc1Dst1{FlowModSpec: parent}
2448 if decoder.Length() < 6 {
2449 return nil, fmt.Errorf("FlowModSpecSrc1Dst1 packet too short: %d < 6", decoder.Length())
2450 }
2451 _flowmodspecsrc1dst1.Src = decoder.SliceDecoder(int((_flowmodspecsrc1dst1.NBits+15)/16*2), 0).Read(int(_flowmodspecsrc1dst1.NBits))
2452 if obj, err := DecodeOxmId(decoder); err != nil {
2453 return nil, err
2454 } else {
2455 _flowmodspecsrc1dst1.Dst = obj
2456 }
2457
2458 _flowmodspecsrc1dst1.DstOfs = uint16(decoder.ReadUint16())
2459 return _flowmodspecsrc1dst1, nil
2460}
2461
2462func NewFlowModSpecSrc1Dst1() *FlowModSpecSrc1Dst1 {
2463 obj := &FlowModSpecSrc1Dst1{
2464 FlowModSpec: NewFlowModSpec(40),
2465 }
2466 return obj
2467}
2468
2469type FlowStatsEntry struct {
2470 Length uint16
2471 TableId uint8
2472 DurationSec uint32
2473 DurationNsec uint32
2474 Priority uint16
2475 IdleTimeout uint16
2476 HardTimeout uint16
2477 Cookie uint64
2478 PacketCount uint64
2479 ByteCount uint64
2480 Match Match
2481 Instructions []IInstruction
2482}
2483
2484type IFlowStatsEntry interface {
2485 goloxi.Serializable
2486 GetLength() uint16
2487 GetTableId() uint8
2488 GetDurationSec() uint32
2489 GetDurationNsec() uint32
2490 GetPriority() uint16
2491 GetIdleTimeout() uint16
2492 GetHardTimeout() uint16
2493 GetCookie() uint64
2494 GetPacketCount() uint64
2495 GetByteCount() uint64
2496 GetMatch() Match
2497 GetInstructions() []IInstruction
2498}
2499
2500func (self *FlowStatsEntry) GetLength() uint16 {
2501 return self.Length
2502}
2503
2504func (self *FlowStatsEntry) SetLength(v uint16) {
2505 self.Length = v
2506}
2507
2508func (self *FlowStatsEntry) GetTableId() uint8 {
2509 return self.TableId
2510}
2511
2512func (self *FlowStatsEntry) SetTableId(v uint8) {
2513 self.TableId = v
2514}
2515
2516func (self *FlowStatsEntry) GetDurationSec() uint32 {
2517 return self.DurationSec
2518}
2519
2520func (self *FlowStatsEntry) SetDurationSec(v uint32) {
2521 self.DurationSec = v
2522}
2523
2524func (self *FlowStatsEntry) GetDurationNsec() uint32 {
2525 return self.DurationNsec
2526}
2527
2528func (self *FlowStatsEntry) SetDurationNsec(v uint32) {
2529 self.DurationNsec = v
2530}
2531
2532func (self *FlowStatsEntry) GetPriority() uint16 {
2533 return self.Priority
2534}
2535
2536func (self *FlowStatsEntry) SetPriority(v uint16) {
2537 self.Priority = v
2538}
2539
2540func (self *FlowStatsEntry) GetIdleTimeout() uint16 {
2541 return self.IdleTimeout
2542}
2543
2544func (self *FlowStatsEntry) SetIdleTimeout(v uint16) {
2545 self.IdleTimeout = v
2546}
2547
2548func (self *FlowStatsEntry) GetHardTimeout() uint16 {
2549 return self.HardTimeout
2550}
2551
2552func (self *FlowStatsEntry) SetHardTimeout(v uint16) {
2553 self.HardTimeout = v
2554}
2555
2556func (self *FlowStatsEntry) GetCookie() uint64 {
2557 return self.Cookie
2558}
2559
2560func (self *FlowStatsEntry) SetCookie(v uint64) {
2561 self.Cookie = v
2562}
2563
2564func (self *FlowStatsEntry) GetPacketCount() uint64 {
2565 return self.PacketCount
2566}
2567
2568func (self *FlowStatsEntry) SetPacketCount(v uint64) {
2569 self.PacketCount = v
2570}
2571
2572func (self *FlowStatsEntry) GetByteCount() uint64 {
2573 return self.ByteCount
2574}
2575
2576func (self *FlowStatsEntry) SetByteCount(v uint64) {
2577 self.ByteCount = v
2578}
2579
2580func (self *FlowStatsEntry) GetMatch() Match {
2581 return self.Match
2582}
2583
2584func (self *FlowStatsEntry) SetMatch(v Match) {
2585 self.Match = v
2586}
2587
2588func (self *FlowStatsEntry) GetInstructions() []IInstruction {
2589 return self.Instructions
2590}
2591
2592func (self *FlowStatsEntry) SetInstructions(v []IInstruction) {
2593 self.Instructions = v
2594}
2595
2596func (self *FlowStatsEntry) Serialize(encoder *goloxi.Encoder) error {
2597 startIndex := len(encoder.Bytes())
2598
2599 encoder.PutUint16(uint16(self.Length))
2600 encoder.PutUint8(uint8(self.TableId))
2601 encoder.Write(bytes.Repeat([]byte{0}, 1))
2602 encoder.PutUint32(uint32(self.DurationSec))
2603 encoder.PutUint32(uint32(self.DurationNsec))
2604 encoder.PutUint16(uint16(self.Priority))
2605 encoder.PutUint16(uint16(self.IdleTimeout))
2606 encoder.PutUint16(uint16(self.HardTimeout))
2607 encoder.Write(bytes.Repeat([]byte{0}, 6))
2608 encoder.PutUint64(uint64(self.Cookie))
2609 encoder.PutUint64(uint64(self.PacketCount))
2610 encoder.PutUint64(uint64(self.ByteCount))
2611 if err := self.Match.Serialize(encoder); err != nil {
2612 return err
2613 }
2614
2615 for _, obj := range self.Instructions {
2616 if err := obj.Serialize(encoder); err != nil {
2617 return err
2618 }
2619 }
2620 length := len(encoder.Bytes()) - startIndex
2621
2622 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
2623
2624 return nil
2625}
2626
2627func DecodeFlowStatsEntry(decoder *goloxi.Decoder) (*FlowStatsEntry, error) {
2628 _flowstatsentry := &FlowStatsEntry{}
2629 if decoder.Length() < 56 {
2630 return nil, fmt.Errorf("FlowStatsEntry packet too short: %d < 56", decoder.Length())
2631 }
2632 _flowstatsentry.Length = uint16(decoder.ReadUint16())
2633 oldDecoder := decoder
2634 defer func() { decoder = oldDecoder }()
2635 decoder = decoder.SliceDecoder(int(_flowstatsentry.Length), 2+0)
2636 _flowstatsentry.TableId = uint8(decoder.ReadByte())
2637 decoder.Skip(1)
2638 _flowstatsentry.DurationSec = uint32(decoder.ReadUint32())
2639 _flowstatsentry.DurationNsec = uint32(decoder.ReadUint32())
2640 _flowstatsentry.Priority = uint16(decoder.ReadUint16())
2641 _flowstatsentry.IdleTimeout = uint16(decoder.ReadUint16())
2642 _flowstatsentry.HardTimeout = uint16(decoder.ReadUint16())
2643 decoder.Skip(6)
2644 _flowstatsentry.Cookie = uint64(decoder.ReadUint64())
2645 _flowstatsentry.PacketCount = uint64(decoder.ReadUint64())
2646 _flowstatsentry.ByteCount = uint64(decoder.ReadUint64())
2647 if err := _flowstatsentry.Match.Decode(decoder); err != nil {
2648 return nil, err
2649 }
2650
2651 decoder.SkipAlign()
2652
2653 for decoder.Length() >= 8 {
2654 item, err := DecodeInstruction(decoder)
2655 if err != nil {
2656 return nil, err
2657 }
2658 if item != nil {
2659 _flowstatsentry.Instructions = append(_flowstatsentry.Instructions, item)
2660 }
2661 }
2662 return _flowstatsentry, nil
2663}
2664
2665func NewFlowStatsEntry() *FlowStatsEntry {
2666 obj := &FlowStatsEntry{}
2667 return obj
2668}
2669
2670type GroupDescStatsEntry struct {
2671 Length uint16
2672 GroupType GroupType
2673 GroupId uint32
2674 Buckets []*Bucket
2675}
2676
2677type IGroupDescStatsEntry interface {
2678 goloxi.Serializable
2679 GetLength() uint16
2680 GetGroupType() GroupType
2681 GetGroupId() uint32
2682 GetBuckets() []*Bucket
2683}
2684
2685func (self *GroupDescStatsEntry) GetLength() uint16 {
2686 return self.Length
2687}
2688
2689func (self *GroupDescStatsEntry) SetLength(v uint16) {
2690 self.Length = v
2691}
2692
2693func (self *GroupDescStatsEntry) GetGroupType() GroupType {
2694 return self.GroupType
2695}
2696
2697func (self *GroupDescStatsEntry) SetGroupType(v GroupType) {
2698 self.GroupType = v
2699}
2700
2701func (self *GroupDescStatsEntry) GetGroupId() uint32 {
2702 return self.GroupId
2703}
2704
2705func (self *GroupDescStatsEntry) SetGroupId(v uint32) {
2706 self.GroupId = v
2707}
2708
2709func (self *GroupDescStatsEntry) GetBuckets() []*Bucket {
2710 return self.Buckets
2711}
2712
2713func (self *GroupDescStatsEntry) SetBuckets(v []*Bucket) {
2714 self.Buckets = v
2715}
2716
2717func (self *GroupDescStatsEntry) Serialize(encoder *goloxi.Encoder) error {
2718 startIndex := len(encoder.Bytes())
2719
2720 encoder.PutUint16(uint16(self.Length))
2721 encoder.PutUint8(uint8(self.GroupType))
2722 encoder.Write(bytes.Repeat([]byte{0}, 1))
2723 encoder.PutUint32(uint32(self.GroupId))
2724 for _, obj := range self.Buckets {
2725 if err := obj.Serialize(encoder); err != nil {
2726 return err
2727 }
2728 }
2729 length := len(encoder.Bytes()) - startIndex
2730
2731 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
2732
2733 return nil
2734}
2735
2736func DecodeGroupDescStatsEntry(decoder *goloxi.Decoder) (*GroupDescStatsEntry, error) {
2737 _groupdescstatsentry := &GroupDescStatsEntry{}
2738 if decoder.Length() < 8 {
2739 return nil, fmt.Errorf("GroupDescStatsEntry packet too short: %d < 8", decoder.Length())
2740 }
2741 _groupdescstatsentry.Length = uint16(decoder.ReadUint16())
2742 oldDecoder := decoder
2743 defer func() { decoder = oldDecoder }()
2744 decoder = decoder.SliceDecoder(int(_groupdescstatsentry.Length), 2+0)
2745 _groupdescstatsentry.GroupType = GroupType(decoder.ReadByte())
2746 decoder.Skip(1)
2747 _groupdescstatsentry.GroupId = uint32(decoder.ReadUint32())
2748
2749 for decoder.Length() >= 16 {
2750 item, err := DecodeBucket(decoder)
2751 if err != nil {
2752 return nil, err
2753 }
2754 if item != nil {
2755 _groupdescstatsentry.Buckets = append(_groupdescstatsentry.Buckets, item)
2756 }
2757 }
2758 return _groupdescstatsentry, nil
2759}
2760
2761func NewGroupDescStatsEntry() *GroupDescStatsEntry {
2762 obj := &GroupDescStatsEntry{}
2763 return obj
2764}
2765
2766type GroupStatsEntry struct {
2767 Length uint16
2768 GroupId uint32
2769 RefCount uint32
2770 PacketCount uint64
2771 ByteCount uint64
2772 BucketStats []*BucketCounter
2773}
2774
2775type IGroupStatsEntry interface {
2776 goloxi.Serializable
2777 GetLength() uint16
2778 GetGroupId() uint32
2779 GetRefCount() uint32
2780 GetPacketCount() uint64
2781 GetByteCount() uint64
2782 GetBucketStats() []*BucketCounter
2783}
2784
2785func (self *GroupStatsEntry) GetLength() uint16 {
2786 return self.Length
2787}
2788
2789func (self *GroupStatsEntry) SetLength(v uint16) {
2790 self.Length = v
2791}
2792
2793func (self *GroupStatsEntry) GetGroupId() uint32 {
2794 return self.GroupId
2795}
2796
2797func (self *GroupStatsEntry) SetGroupId(v uint32) {
2798 self.GroupId = v
2799}
2800
2801func (self *GroupStatsEntry) GetRefCount() uint32 {
2802 return self.RefCount
2803}
2804
2805func (self *GroupStatsEntry) SetRefCount(v uint32) {
2806 self.RefCount = v
2807}
2808
2809func (self *GroupStatsEntry) GetPacketCount() uint64 {
2810 return self.PacketCount
2811}
2812
2813func (self *GroupStatsEntry) SetPacketCount(v uint64) {
2814 self.PacketCount = v
2815}
2816
2817func (self *GroupStatsEntry) GetByteCount() uint64 {
2818 return self.ByteCount
2819}
2820
2821func (self *GroupStatsEntry) SetByteCount(v uint64) {
2822 self.ByteCount = v
2823}
2824
2825func (self *GroupStatsEntry) GetBucketStats() []*BucketCounter {
2826 return self.BucketStats
2827}
2828
2829func (self *GroupStatsEntry) SetBucketStats(v []*BucketCounter) {
2830 self.BucketStats = v
2831}
2832
2833func (self *GroupStatsEntry) Serialize(encoder *goloxi.Encoder) error {
2834 startIndex := len(encoder.Bytes())
2835
2836 encoder.PutUint16(uint16(self.Length))
2837 encoder.Write(bytes.Repeat([]byte{0}, 2))
2838 encoder.PutUint32(uint32(self.GroupId))
2839 encoder.PutUint32(uint32(self.RefCount))
2840 encoder.Write(bytes.Repeat([]byte{0}, 4))
2841 encoder.PutUint64(uint64(self.PacketCount))
2842 encoder.PutUint64(uint64(self.ByteCount))
2843 for _, obj := range self.BucketStats {
2844 if err := obj.Serialize(encoder); err != nil {
2845 return err
2846 }
2847 }
2848 length := len(encoder.Bytes()) - startIndex
2849
2850 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
2851
2852 return nil
2853}
2854
2855func DecodeGroupStatsEntry(decoder *goloxi.Decoder) (*GroupStatsEntry, error) {
2856 _groupstatsentry := &GroupStatsEntry{}
2857 if decoder.Length() < 32 {
2858 return nil, fmt.Errorf("GroupStatsEntry packet too short: %d < 32", decoder.Length())
2859 }
2860 _groupstatsentry.Length = uint16(decoder.ReadUint16())
2861 oldDecoder := decoder
2862 defer func() { decoder = oldDecoder }()
2863 decoder = decoder.SliceDecoder(int(_groupstatsentry.Length), 2+0)
2864 decoder.Skip(2)
2865 _groupstatsentry.GroupId = uint32(decoder.ReadUint32())
2866 _groupstatsentry.RefCount = uint32(decoder.ReadUint32())
2867 decoder.Skip(4)
2868 _groupstatsentry.PacketCount = uint64(decoder.ReadUint64())
2869 _groupstatsentry.ByteCount = uint64(decoder.ReadUint64())
2870
2871 for decoder.Length() >= 16 {
2872 item, err := DecodeBucketCounter(decoder)
2873 if err != nil {
2874 return nil, err
2875 }
2876 if item != nil {
2877 _groupstatsentry.BucketStats = append(_groupstatsentry.BucketStats, item)
2878 }
2879 }
2880 return _groupstatsentry, nil
2881}
2882
2883func NewGroupStatsEntry() *GroupStatsEntry {
2884 obj := &GroupStatsEntry{}
2885 return obj
2886}
2887
2888type InstructionId struct {
2889 Type uint16
2890 Len uint16
2891}
2892
2893type IInstructionId interface {
2894 goloxi.Serializable
2895 GetType() uint16
2896 GetLen() uint16
2897}
2898
2899func (self *InstructionId) GetType() uint16 {
2900 return self.Type
2901}
2902
2903func (self *InstructionId) SetType(v uint16) {
2904 self.Type = v
2905}
2906
2907func (self *InstructionId) GetLen() uint16 {
2908 return self.Len
2909}
2910
2911func (self *InstructionId) SetLen(v uint16) {
2912 self.Len = v
2913}
2914
2915func (self *InstructionId) Serialize(encoder *goloxi.Encoder) error {
2916
2917 encoder.PutUint16(uint16(self.Type))
2918 encoder.PutUint16(uint16(self.Len))
2919
2920 return nil
2921}
2922
2923func DecodeInstructionId(decoder *goloxi.Decoder) (IInstructionId, error) {
2924 _instructionid := &InstructionId{}
2925 if decoder.Length() < 4 {
2926 return nil, fmt.Errorf("InstructionId packet too short: %d < 4", decoder.Length())
2927 }
2928 _instructionid.Type = uint16(decoder.ReadUint16())
2929 _instructionid.Len = uint16(decoder.ReadUint16())
2930 oldDecoder := decoder
2931 defer func() { decoder = oldDecoder }()
2932 decoder = decoder.SliceDecoder(int(_instructionid.Len), 2+2)
2933
2934 switch _instructionid.Type {
2935 case 1:
2936 return DecodeInstructionIdGotoTable(_instructionid, decoder)
2937 case 2:
2938 return DecodeInstructionIdWriteMetadata(_instructionid, decoder)
2939 case 3:
2940 return DecodeInstructionIdWriteActions(_instructionid, decoder)
2941 case 4:
2942 return DecodeInstructionIdApplyActions(_instructionid, decoder)
2943 case 5:
2944 return DecodeInstructionIdClearActions(_instructionid, decoder)
2945 case 65535:
2946 return DecodeInstructionIdExperimenter(_instructionid, decoder)
2947 default:
2948 return nil, fmt.Errorf("Invalid type '%d' for 'InstructionId'", _instructionid.Type)
2949 }
2950}
2951
2952func NewInstructionId(_type uint16) *InstructionId {
2953 obj := &InstructionId{}
2954 obj.Type = _type
2955 return obj
2956}
2957
2958type InstructionIdApplyActions struct {
2959 *InstructionId
2960}
2961
2962type IInstructionIdApplyActions interface {
2963 IInstructionId
2964}
2965
2966func (self *InstructionIdApplyActions) Serialize(encoder *goloxi.Encoder) error {
2967 startIndex := len(encoder.Bytes())
2968 if err := self.InstructionId.Serialize(encoder); err != nil {
2969 return err
2970 }
2971 length := len(encoder.Bytes()) - startIndex
2972
2973 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
2974
2975 return nil
2976}
2977
2978func DecodeInstructionIdApplyActions(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdApplyActions, error) {
2979 _instructionidapplyactions := &InstructionIdApplyActions{InstructionId: parent}
2980 return _instructionidapplyactions, nil
2981}
2982
2983func NewInstructionIdApplyActions() *InstructionIdApplyActions {
2984 obj := &InstructionIdApplyActions{
2985 InstructionId: NewInstructionId(4),
2986 }
2987 return obj
2988}
2989
2990type InstructionIdClearActions struct {
2991 *InstructionId
2992}
2993
2994type IInstructionIdClearActions interface {
2995 IInstructionId
2996}
2997
2998func (self *InstructionIdClearActions) Serialize(encoder *goloxi.Encoder) error {
2999 startIndex := len(encoder.Bytes())
3000 if err := self.InstructionId.Serialize(encoder); err != nil {
3001 return err
3002 }
3003 length := len(encoder.Bytes()) - startIndex
3004
3005 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
3006
3007 return nil
3008}
3009
3010func DecodeInstructionIdClearActions(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdClearActions, error) {
3011 _instructionidclearactions := &InstructionIdClearActions{InstructionId: parent}
3012 return _instructionidclearactions, nil
3013}
3014
3015func NewInstructionIdClearActions() *InstructionIdClearActions {
3016 obj := &InstructionIdClearActions{
3017 InstructionId: NewInstructionId(5),
3018 }
3019 return obj
3020}
3021
3022type InstructionIdExperimenter struct {
3023 *InstructionId
3024 Experimenter uint32
3025}
3026
3027type IInstructionIdExperimenter interface {
3028 IInstructionId
3029 GetExperimenter() uint32
3030}
3031
3032func (self *InstructionIdExperimenter) GetExperimenter() uint32 {
3033 return self.Experimenter
3034}
3035
3036func (self *InstructionIdExperimenter) SetExperimenter(v uint32) {
3037 self.Experimenter = v
3038}
3039
3040func (self *InstructionIdExperimenter) Serialize(encoder *goloxi.Encoder) error {
3041 if err := self.InstructionId.Serialize(encoder); err != nil {
3042 return err
3043 }
3044
3045 encoder.PutUint32(uint32(self.Experimenter))
3046
3047 return nil
3048}
3049
3050func DecodeInstructionIdExperimenter(parent *InstructionId, decoder *goloxi.Decoder) (IInstructionIdExperimenter, error) {
3051 _instructionidexperimenter := &InstructionIdExperimenter{InstructionId: parent}
3052 if decoder.Length() < 4 {
3053 return nil, fmt.Errorf("InstructionIdExperimenter packet too short: %d < 4", decoder.Length())
3054 }
3055 _instructionidexperimenter.Experimenter = uint32(decoder.ReadUint32())
3056 return _instructionidexperimenter, nil
3057}
3058
3059func NewInstructionIdExperimenter(_experimenter uint32) *InstructionIdExperimenter {
3060 obj := &InstructionIdExperimenter{
3061 InstructionId: NewInstructionId(65535),
3062 }
3063 obj.Experimenter = _experimenter
3064 return obj
3065}
3066
3067type InstructionIdGotoTable struct {
3068 *InstructionId
3069}
3070
3071type IInstructionIdGotoTable interface {
3072 IInstructionId
3073}
3074
3075func (self *InstructionIdGotoTable) Serialize(encoder *goloxi.Encoder) error {
3076 startIndex := len(encoder.Bytes())
3077 if err := self.InstructionId.Serialize(encoder); err != nil {
3078 return err
3079 }
3080 length := len(encoder.Bytes()) - startIndex
3081
3082 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
3083
3084 return nil
3085}
3086
3087func DecodeInstructionIdGotoTable(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdGotoTable, error) {
3088 _instructionidgototable := &InstructionIdGotoTable{InstructionId: parent}
3089 return _instructionidgototable, nil
3090}
3091
3092func NewInstructionIdGotoTable() *InstructionIdGotoTable {
3093 obj := &InstructionIdGotoTable{
3094 InstructionId: NewInstructionId(1),
3095 }
3096 return obj
3097}
3098
3099type InstructionIdWriteActions struct {
3100 *InstructionId
3101}
3102
3103type IInstructionIdWriteActions interface {
3104 IInstructionId
3105}
3106
3107func (self *InstructionIdWriteActions) Serialize(encoder *goloxi.Encoder) error {
3108 startIndex := len(encoder.Bytes())
3109 if err := self.InstructionId.Serialize(encoder); err != nil {
3110 return err
3111 }
3112 length := len(encoder.Bytes()) - startIndex
3113
3114 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
3115
3116 return nil
3117}
3118
3119func DecodeInstructionIdWriteActions(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdWriteActions, error) {
3120 _instructionidwriteactions := &InstructionIdWriteActions{InstructionId: parent}
3121 return _instructionidwriteactions, nil
3122}
3123
3124func NewInstructionIdWriteActions() *InstructionIdWriteActions {
3125 obj := &InstructionIdWriteActions{
3126 InstructionId: NewInstructionId(3),
3127 }
3128 return obj
3129}
3130
3131type InstructionIdWriteMetadata struct {
3132 *InstructionId
3133}
3134
3135type IInstructionIdWriteMetadata interface {
3136 IInstructionId
3137}
3138
3139func (self *InstructionIdWriteMetadata) Serialize(encoder *goloxi.Encoder) error {
3140 startIndex := len(encoder.Bytes())
3141 if err := self.InstructionId.Serialize(encoder); err != nil {
3142 return err
3143 }
3144 length := len(encoder.Bytes()) - startIndex
3145
3146 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
3147
3148 return nil
3149}
3150
3151func DecodeInstructionIdWriteMetadata(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdWriteMetadata, error) {
3152 _instructionidwritemetadata := &InstructionIdWriteMetadata{InstructionId: parent}
3153 return _instructionidwritemetadata, nil
3154}
3155
3156func NewInstructionIdWriteMetadata() *InstructionIdWriteMetadata {
3157 obj := &InstructionIdWriteMetadata{
3158 InstructionId: NewInstructionId(2),
3159 }
3160 return obj
3161}
3162
3163type MatchV3 struct {
3164 Type uint16
3165 Length uint16
3166 OxmList []goloxi.IOxm
3167}
3168
3169type IMatchV3 interface {
3170 goloxi.Serializable
3171 GetType() uint16
3172 GetLength() uint16
3173 GetOxmList() []goloxi.IOxm
3174}
3175
3176func (self *MatchV3) GetType() uint16 {
3177 return self.Type
3178}
3179
3180func (self *MatchV3) SetType(v uint16) {
3181 self.Type = v
3182}
3183
3184func (self *MatchV3) GetLength() uint16 {
3185 return self.Length
3186}
3187
3188func (self *MatchV3) SetLength(v uint16) {
3189 self.Length = v
3190}
3191
3192func (self *MatchV3) GetOxmList() []goloxi.IOxm {
3193 return self.OxmList
3194}
3195
3196func (self *MatchV3) SetOxmList(v []goloxi.IOxm) {
3197 self.OxmList = v
3198}
3199
3200func (self *MatchV3) Serialize(encoder *goloxi.Encoder) error {
3201 startIndex := len(encoder.Bytes())
3202
3203 encoder.PutUint16(uint16(self.Type))
3204 encoder.PutUint16(uint16(self.Length))
3205 for _, obj := range self.OxmList {
3206 if err := obj.Serialize(encoder); err != nil {
3207 return err
3208 }
3209 }
3210 length := len(encoder.Bytes()) - startIndex
3211 alignedLength := ((length + 7) / 8 * 8)
3212
3213 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
3214
3215 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
3216
3217 return nil
3218}
3219func (self *MatchV3) Decode(decoder *goloxi.Decoder) error {
3220 if decoder.Length() < 4 {
3221 return fmt.Errorf("MatchV3 packet too short: %d < 4", decoder.Length())
3222 }
3223
3224 defer decoder.SkipAlign()
3225
3226 self.Type = uint16(decoder.ReadUint16())
3227 self.Length = uint16(decoder.ReadUint16())
3228 oldDecoder := decoder
3229 defer func() { decoder = oldDecoder }()
3230 decoder = decoder.SliceDecoder(int(((self.Length)+7)/8*8), 2+2)
3231
3232 for decoder.Length() >= 4 {
3233 item, err := DecodeOxm(decoder)
3234 if err != nil {
3235 return err
3236 }
3237 if item != nil {
3238 self.OxmList = append(self.OxmList, item)
3239 }
3240 }
3241
3242 return nil
3243}
3244
3245func NewMatchV3() *MatchV3 {
3246 obj := &MatchV3{}
3247 return obj
3248}
3249
3250type NiciraMatch struct {
3251 NxmEntries []goloxi.IOxm
3252}
3253
3254type INiciraMatch interface {
3255 goloxi.Serializable
3256 GetNxmEntries() []goloxi.IOxm
3257}
3258
3259func (self *NiciraMatch) GetNxmEntries() []goloxi.IOxm {
3260 return self.NxmEntries
3261}
3262
3263func (self *NiciraMatch) SetNxmEntries(v []goloxi.IOxm) {
3264 self.NxmEntries = v
3265}
3266
3267func (self *NiciraMatch) Serialize(encoder *goloxi.Encoder) error {
3268 startIndex := len(encoder.Bytes())
3269
3270 for _, obj := range self.NxmEntries {
3271 if err := obj.Serialize(encoder); err != nil {
3272 return err
3273 }
3274 }
3275 length := len(encoder.Bytes()) - startIndex
3276 alignedLength := ((length + 7) / 8 * 8)
3277
3278 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
3279
3280 return nil
3281}
3282func (self *NiciraMatch) Decode(decoder *goloxi.Decoder) error {
3283
3284 defer decoder.SkipAlign()
3285
3286 for decoder.Length() >= 4 {
3287 item, err := DecodeOxm(decoder)
3288 if err != nil {
3289 return err
3290 }
3291 if item != nil {
3292 self.NxmEntries = append(self.NxmEntries, item)
3293 }
3294 }
3295
3296 return nil
3297}
3298
3299func NewNiciraMatch() *NiciraMatch {
3300 obj := &NiciraMatch{}
3301 return obj
3302}
3303
3304type NiciraFlowStats struct {
3305 Length uint16
3306 TableId uint8
3307 DurationSec uint32
3308 DurationNsec uint32
3309 Priority uint16
3310 IdleTimeout uint16
3311 HardTimeout uint16
3312 MatchLen uint16
3313 IdleAge uint16
3314 HardAge uint16
3315 Cookie uint64
3316 PacketCount uint64
3317 ByteCount uint64
3318 Match NiciraMatch
3319 Actions []goloxi.IAction
3320}
3321
3322type INiciraFlowStats interface {
3323 goloxi.Serializable
3324 GetLength() uint16
3325 GetTableId() uint8
3326 GetDurationSec() uint32
3327 GetDurationNsec() uint32
3328 GetPriority() uint16
3329 GetIdleTimeout() uint16
3330 GetHardTimeout() uint16
3331 GetMatchLen() uint16
3332 GetIdleAge() uint16
3333 GetHardAge() uint16
3334 GetCookie() uint64
3335 GetPacketCount() uint64
3336 GetByteCount() uint64
3337 GetMatch() NiciraMatch
3338 GetActions() []goloxi.IAction
3339}
3340
3341func (self *NiciraFlowStats) GetLength() uint16 {
3342 return self.Length
3343}
3344
3345func (self *NiciraFlowStats) SetLength(v uint16) {
3346 self.Length = v
3347}
3348
3349func (self *NiciraFlowStats) GetTableId() uint8 {
3350 return self.TableId
3351}
3352
3353func (self *NiciraFlowStats) SetTableId(v uint8) {
3354 self.TableId = v
3355}
3356
3357func (self *NiciraFlowStats) GetDurationSec() uint32 {
3358 return self.DurationSec
3359}
3360
3361func (self *NiciraFlowStats) SetDurationSec(v uint32) {
3362 self.DurationSec = v
3363}
3364
3365func (self *NiciraFlowStats) GetDurationNsec() uint32 {
3366 return self.DurationNsec
3367}
3368
3369func (self *NiciraFlowStats) SetDurationNsec(v uint32) {
3370 self.DurationNsec = v
3371}
3372
3373func (self *NiciraFlowStats) GetPriority() uint16 {
3374 return self.Priority
3375}
3376
3377func (self *NiciraFlowStats) SetPriority(v uint16) {
3378 self.Priority = v
3379}
3380
3381func (self *NiciraFlowStats) GetIdleTimeout() uint16 {
3382 return self.IdleTimeout
3383}
3384
3385func (self *NiciraFlowStats) SetIdleTimeout(v uint16) {
3386 self.IdleTimeout = v
3387}
3388
3389func (self *NiciraFlowStats) GetHardTimeout() uint16 {
3390 return self.HardTimeout
3391}
3392
3393func (self *NiciraFlowStats) SetHardTimeout(v uint16) {
3394 self.HardTimeout = v
3395}
3396
3397func (self *NiciraFlowStats) GetMatchLen() uint16 {
3398 return self.MatchLen
3399}
3400
3401func (self *NiciraFlowStats) SetMatchLen(v uint16) {
3402 self.MatchLen = v
3403}
3404
3405func (self *NiciraFlowStats) GetIdleAge() uint16 {
3406 return self.IdleAge
3407}
3408
3409func (self *NiciraFlowStats) SetIdleAge(v uint16) {
3410 self.IdleAge = v
3411}
3412
3413func (self *NiciraFlowStats) GetHardAge() uint16 {
3414 return self.HardAge
3415}
3416
3417func (self *NiciraFlowStats) SetHardAge(v uint16) {
3418 self.HardAge = v
3419}
3420
3421func (self *NiciraFlowStats) GetCookie() uint64 {
3422 return self.Cookie
3423}
3424
3425func (self *NiciraFlowStats) SetCookie(v uint64) {
3426 self.Cookie = v
3427}
3428
3429func (self *NiciraFlowStats) GetPacketCount() uint64 {
3430 return self.PacketCount
3431}
3432
3433func (self *NiciraFlowStats) SetPacketCount(v uint64) {
3434 self.PacketCount = v
3435}
3436
3437func (self *NiciraFlowStats) GetByteCount() uint64 {
3438 return self.ByteCount
3439}
3440
3441func (self *NiciraFlowStats) SetByteCount(v uint64) {
3442 self.ByteCount = v
3443}
3444
3445func (self *NiciraFlowStats) GetMatch() NiciraMatch {
3446 return self.Match
3447}
3448
3449func (self *NiciraFlowStats) SetMatch(v NiciraMatch) {
3450 self.Match = v
3451}
3452
3453func (self *NiciraFlowStats) GetActions() []goloxi.IAction {
3454 return self.Actions
3455}
3456
3457func (self *NiciraFlowStats) SetActions(v []goloxi.IAction) {
3458 self.Actions = v
3459}
3460
3461func (self *NiciraFlowStats) Serialize(encoder *goloxi.Encoder) error {
3462 startIndex := len(encoder.Bytes())
3463
3464 encoder.PutUint16(uint16(self.Length))
3465 encoder.PutUint8(uint8(self.TableId))
3466 encoder.Write(bytes.Repeat([]byte{0}, 1))
3467 encoder.PutUint32(uint32(self.DurationSec))
3468 encoder.PutUint32(uint32(self.DurationNsec))
3469 encoder.PutUint16(uint16(self.Priority))
3470 encoder.PutUint16(uint16(self.IdleTimeout))
3471 encoder.PutUint16(uint16(self.HardTimeout))
3472 encoder.PutUint16(uint16(self.MatchLen))
3473 encoder.PutUint16(uint16(self.IdleAge))
3474 encoder.PutUint16(uint16(self.HardAge))
3475 encoder.PutUint64(uint64(self.Cookie))
3476 encoder.PutUint64(uint64(self.PacketCount))
3477 encoder.PutUint64(uint64(self.ByteCount))
3478 if err := self.Match.Serialize(encoder); err != nil {
3479 return err
3480 }
3481
3482 for _, obj := range self.Actions {
3483 if err := obj.Serialize(encoder); err != nil {
3484 return err
3485 }
3486 }
3487 length := len(encoder.Bytes()) - startIndex
3488
3489 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
3490
3491 return nil
3492}
3493
3494func DecodeNiciraFlowStats(decoder *goloxi.Decoder) (*NiciraFlowStats, error) {
3495 _niciraflowstats := &NiciraFlowStats{}
3496 if decoder.Length() < 48 {
3497 return nil, fmt.Errorf("NiciraFlowStats packet too short: %d < 48", decoder.Length())
3498 }
3499 _niciraflowstats.Length = uint16(decoder.ReadUint16())
3500 oldDecoder := decoder
3501 defer func() { decoder = oldDecoder }()
3502 decoder = decoder.SliceDecoder(int(_niciraflowstats.Length), 2+0)
3503 _niciraflowstats.TableId = uint8(decoder.ReadByte())
3504 decoder.Skip(1)
3505 _niciraflowstats.DurationSec = uint32(decoder.ReadUint32())
3506 _niciraflowstats.DurationNsec = uint32(decoder.ReadUint32())
3507 _niciraflowstats.Priority = uint16(decoder.ReadUint16())
3508 _niciraflowstats.IdleTimeout = uint16(decoder.ReadUint16())
3509 _niciraflowstats.HardTimeout = uint16(decoder.ReadUint16())
3510 _niciraflowstats.MatchLen = uint16(decoder.ReadUint16())
3511 _niciraflowstats.IdleAge = uint16(decoder.ReadUint16())
3512 _niciraflowstats.HardAge = uint16(decoder.ReadUint16())
3513 _niciraflowstats.Cookie = uint64(decoder.ReadUint64())
3514 _niciraflowstats.PacketCount = uint64(decoder.ReadUint64())
3515 _niciraflowstats.ByteCount = uint64(decoder.ReadUint64())
3516 if err := _niciraflowstats.Match.Decode(decoder.SliceDecoder(int(_niciraflowstats.MatchLen), 0)); err != nil {
3517 return nil, err
3518 }
3519
3520 decoder.SkipAlign()
3521
3522 for decoder.Length() >= 8 {
3523 item, err := DecodeAction(decoder)
3524 if err != nil {
3525 return nil, err
3526 }
3527 if item != nil {
3528 _niciraflowstats.Actions = append(_niciraflowstats.Actions, item)
3529 }
3530 }
3531 return _niciraflowstats, nil
3532}
3533
3534func NewNiciraFlowStats() *NiciraFlowStats {
3535 obj := &NiciraFlowStats{}
3536 return obj
3537}
3538
3539type NiciraFlowUpdateEvent struct {
3540 Length uint16
3541 Event uint16
3542}
3543
3544type INiciraFlowUpdateEvent interface {
3545 goloxi.Serializable
3546 GetLength() uint16
3547 GetEvent() uint16
3548}
3549
3550func (self *NiciraFlowUpdateEvent) GetLength() uint16 {
3551 return self.Length
3552}
3553
3554func (self *NiciraFlowUpdateEvent) SetLength(v uint16) {
3555 self.Length = v
3556}
3557
3558func (self *NiciraFlowUpdateEvent) GetEvent() uint16 {
3559 return self.Event
3560}
3561
3562func (self *NiciraFlowUpdateEvent) SetEvent(v uint16) {
3563 self.Event = v
3564}
3565
3566func (self *NiciraFlowUpdateEvent) Serialize(encoder *goloxi.Encoder) error {
3567
3568 encoder.PutUint16(uint16(self.Length))
3569 encoder.PutUint16(uint16(self.Event))
3570
3571 return nil
3572}
3573
3574func DecodeNiciraFlowUpdateEvent(decoder *goloxi.Decoder) (INiciraFlowUpdateEvent, error) {
3575 _niciraflowupdateevent := &NiciraFlowUpdateEvent{}
3576 if decoder.Length() < 4 {
3577 return nil, fmt.Errorf("NiciraFlowUpdateEvent packet too short: %d < 4", decoder.Length())
3578 }
3579 _niciraflowupdateevent.Length = uint16(decoder.ReadUint16())
3580 oldDecoder := decoder
3581 defer func() { decoder = oldDecoder }()
3582 decoder = decoder.SliceDecoder(int(_niciraflowupdateevent.Length), 2+0)
3583 _niciraflowupdateevent.Event = uint16(decoder.ReadUint16())
3584
3585 switch _niciraflowupdateevent.Event {
3586 case 0:
3587 return DecodeNiciraFlowUpdateFullAdd(_niciraflowupdateevent, decoder)
3588 case 1:
3589 return DecodeNiciraFlowUpdateFullDeleted(_niciraflowupdateevent, decoder)
3590 case 2:
3591 return DecodeNiciraFlowUpdateFullModified(_niciraflowupdateevent, decoder)
3592 default:
3593 return nil, fmt.Errorf("Invalid type '%d' for 'NiciraFlowUpdateEvent'", _niciraflowupdateevent.Event)
3594 }
3595}
3596
3597func NewNiciraFlowUpdateEvent(_event uint16) *NiciraFlowUpdateEvent {
3598 obj := &NiciraFlowUpdateEvent{}
3599 obj.Event = _event
3600 return obj
3601}
3602
3603type NiciraFlowUpdateFullAdd struct {
3604 *NiciraFlowUpdateEvent
3605 Reason uint16
3606 Priority uint16
3607 IdleTimeout uint16
3608 HardTimeout uint16
3609 MatchLen uint16
3610 TableId uint8
3611 Cookie uint64
3612 Match NiciraMatch
3613 Actions []goloxi.IAction
3614}
3615
3616type INiciraFlowUpdateFullAdd interface {
3617 INiciraFlowUpdateEvent
3618 GetReason() uint16
3619 GetPriority() uint16
3620 GetIdleTimeout() uint16
3621 GetHardTimeout() uint16
3622 GetMatchLen() uint16
3623 GetTableId() uint8
3624 GetCookie() uint64
3625 GetMatch() NiciraMatch
3626 GetActions() []goloxi.IAction
3627}
3628
3629func (self *NiciraFlowUpdateFullAdd) GetReason() uint16 {
3630 return self.Reason
3631}
3632
3633func (self *NiciraFlowUpdateFullAdd) SetReason(v uint16) {
3634 self.Reason = v
3635}
3636
3637func (self *NiciraFlowUpdateFullAdd) GetPriority() uint16 {
3638 return self.Priority
3639}
3640
3641func (self *NiciraFlowUpdateFullAdd) SetPriority(v uint16) {
3642 self.Priority = v
3643}
3644
3645func (self *NiciraFlowUpdateFullAdd) GetIdleTimeout() uint16 {
3646 return self.IdleTimeout
3647}
3648
3649func (self *NiciraFlowUpdateFullAdd) SetIdleTimeout(v uint16) {
3650 self.IdleTimeout = v
3651}
3652
3653func (self *NiciraFlowUpdateFullAdd) GetHardTimeout() uint16 {
3654 return self.HardTimeout
3655}
3656
3657func (self *NiciraFlowUpdateFullAdd) SetHardTimeout(v uint16) {
3658 self.HardTimeout = v
3659}
3660
3661func (self *NiciraFlowUpdateFullAdd) GetMatchLen() uint16 {
3662 return self.MatchLen
3663}
3664
3665func (self *NiciraFlowUpdateFullAdd) SetMatchLen(v uint16) {
3666 self.MatchLen = v
3667}
3668
3669func (self *NiciraFlowUpdateFullAdd) GetTableId() uint8 {
3670 return self.TableId
3671}
3672
3673func (self *NiciraFlowUpdateFullAdd) SetTableId(v uint8) {
3674 self.TableId = v
3675}
3676
3677func (self *NiciraFlowUpdateFullAdd) GetCookie() uint64 {
3678 return self.Cookie
3679}
3680
3681func (self *NiciraFlowUpdateFullAdd) SetCookie(v uint64) {
3682 self.Cookie = v
3683}
3684
3685func (self *NiciraFlowUpdateFullAdd) GetMatch() NiciraMatch {
3686 return self.Match
3687}
3688
3689func (self *NiciraFlowUpdateFullAdd) SetMatch(v NiciraMatch) {
3690 self.Match = v
3691}
3692
3693func (self *NiciraFlowUpdateFullAdd) GetActions() []goloxi.IAction {
3694 return self.Actions
3695}
3696
3697func (self *NiciraFlowUpdateFullAdd) SetActions(v []goloxi.IAction) {
3698 self.Actions = v
3699}
3700
3701func (self *NiciraFlowUpdateFullAdd) Serialize(encoder *goloxi.Encoder) error {
3702 startIndex := len(encoder.Bytes())
3703 if err := self.NiciraFlowUpdateEvent.Serialize(encoder); err != nil {
3704 return err
3705 }
3706
3707 encoder.PutUint16(uint16(self.Reason))
3708 encoder.PutUint16(uint16(self.Priority))
3709 encoder.PutUint16(uint16(self.IdleTimeout))
3710 encoder.PutUint16(uint16(self.HardTimeout))
3711 encoder.PutUint16(uint16(self.MatchLen))
3712 encoder.PutUint8(uint8(self.TableId))
3713 encoder.Write(bytes.Repeat([]byte{0}, 1))
3714 encoder.PutUint64(uint64(self.Cookie))
3715 if err := self.Match.Serialize(encoder); err != nil {
3716 return err
3717 }
3718
3719 for _, obj := range self.Actions {
3720 if err := obj.Serialize(encoder); err != nil {
3721 return err
3722 }
3723 }
3724 length := len(encoder.Bytes()) - startIndex
3725
3726 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
3727
3728 return nil
3729}
3730
3731func DecodeNiciraFlowUpdateFullAdd(parent *NiciraFlowUpdateEvent, decoder *goloxi.Decoder) (*NiciraFlowUpdateFullAdd, error) {
3732 _niciraflowupdatefulladd := &NiciraFlowUpdateFullAdd{NiciraFlowUpdateEvent: parent}
3733 if decoder.Length() < 20 {
3734 return nil, fmt.Errorf("NiciraFlowUpdateFullAdd packet too short: %d < 20", decoder.Length())
3735 }
3736 _niciraflowupdatefulladd.Reason = uint16(decoder.ReadUint16())
3737 _niciraflowupdatefulladd.Priority = uint16(decoder.ReadUint16())
3738 _niciraflowupdatefulladd.IdleTimeout = uint16(decoder.ReadUint16())
3739 _niciraflowupdatefulladd.HardTimeout = uint16(decoder.ReadUint16())
3740 _niciraflowupdatefulladd.MatchLen = uint16(decoder.ReadUint16())
3741 _niciraflowupdatefulladd.TableId = uint8(decoder.ReadByte())
3742 decoder.Skip(1)
3743 _niciraflowupdatefulladd.Cookie = uint64(decoder.ReadUint64())
3744 if err := _niciraflowupdatefulladd.Match.Decode(decoder.SliceDecoder(int(_niciraflowupdatefulladd.MatchLen), 0)); err != nil {
3745 return nil, err
3746 }
3747
3748 decoder.SkipAlign()
3749
3750 for decoder.Length() >= 8 {
3751 item, err := DecodeAction(decoder)
3752 if err != nil {
3753 return nil, err
3754 }
3755 if item != nil {
3756 _niciraflowupdatefulladd.Actions = append(_niciraflowupdatefulladd.Actions, item)
3757 }
3758 }
3759 return _niciraflowupdatefulladd, nil
3760}
3761
3762func NewNiciraFlowUpdateFullAdd() *NiciraFlowUpdateFullAdd {
3763 obj := &NiciraFlowUpdateFullAdd{
3764 NiciraFlowUpdateEvent: NewNiciraFlowUpdateEvent(0),
3765 }
3766 return obj
3767}
3768
3769type NiciraFlowUpdateFullDeleted struct {
3770 *NiciraFlowUpdateEvent
3771 Reason uint16
3772 Priority uint16
3773 IdleTimeout uint16
3774 HardTimeout uint16
3775 MatchLen uint16
3776 TableId uint8
3777 Cookie uint64
3778 Match NiciraMatch
3779 Actions []goloxi.IAction
3780}
3781
3782type INiciraFlowUpdateFullDeleted interface {
3783 INiciraFlowUpdateEvent
3784 GetReason() uint16
3785 GetPriority() uint16
3786 GetIdleTimeout() uint16
3787 GetHardTimeout() uint16
3788 GetMatchLen() uint16
3789 GetTableId() uint8
3790 GetCookie() uint64
3791 GetMatch() NiciraMatch
3792 GetActions() []goloxi.IAction
3793}
3794
3795func (self *NiciraFlowUpdateFullDeleted) GetReason() uint16 {
3796 return self.Reason
3797}
3798
3799func (self *NiciraFlowUpdateFullDeleted) SetReason(v uint16) {
3800 self.Reason = v
3801}
3802
3803func (self *NiciraFlowUpdateFullDeleted) GetPriority() uint16 {
3804 return self.Priority
3805}
3806
3807func (self *NiciraFlowUpdateFullDeleted) SetPriority(v uint16) {
3808 self.Priority = v
3809}
3810
3811func (self *NiciraFlowUpdateFullDeleted) GetIdleTimeout() uint16 {
3812 return self.IdleTimeout
3813}
3814
3815func (self *NiciraFlowUpdateFullDeleted) SetIdleTimeout(v uint16) {
3816 self.IdleTimeout = v
3817}
3818
3819func (self *NiciraFlowUpdateFullDeleted) GetHardTimeout() uint16 {
3820 return self.HardTimeout
3821}
3822
3823func (self *NiciraFlowUpdateFullDeleted) SetHardTimeout(v uint16) {
3824 self.HardTimeout = v
3825}
3826
3827func (self *NiciraFlowUpdateFullDeleted) GetMatchLen() uint16 {
3828 return self.MatchLen
3829}
3830
3831func (self *NiciraFlowUpdateFullDeleted) SetMatchLen(v uint16) {
3832 self.MatchLen = v
3833}
3834
3835func (self *NiciraFlowUpdateFullDeleted) GetTableId() uint8 {
3836 return self.TableId
3837}
3838
3839func (self *NiciraFlowUpdateFullDeleted) SetTableId(v uint8) {
3840 self.TableId = v
3841}
3842
3843func (self *NiciraFlowUpdateFullDeleted) GetCookie() uint64 {
3844 return self.Cookie
3845}
3846
3847func (self *NiciraFlowUpdateFullDeleted) SetCookie(v uint64) {
3848 self.Cookie = v
3849}
3850
3851func (self *NiciraFlowUpdateFullDeleted) GetMatch() NiciraMatch {
3852 return self.Match
3853}
3854
3855func (self *NiciraFlowUpdateFullDeleted) SetMatch(v NiciraMatch) {
3856 self.Match = v
3857}
3858
3859func (self *NiciraFlowUpdateFullDeleted) GetActions() []goloxi.IAction {
3860 return self.Actions
3861}
3862
3863func (self *NiciraFlowUpdateFullDeleted) SetActions(v []goloxi.IAction) {
3864 self.Actions = v
3865}
3866
3867func (self *NiciraFlowUpdateFullDeleted) Serialize(encoder *goloxi.Encoder) error {
3868 startIndex := len(encoder.Bytes())
3869 if err := self.NiciraFlowUpdateEvent.Serialize(encoder); err != nil {
3870 return err
3871 }
3872
3873 encoder.PutUint16(uint16(self.Reason))
3874 encoder.PutUint16(uint16(self.Priority))
3875 encoder.PutUint16(uint16(self.IdleTimeout))
3876 encoder.PutUint16(uint16(self.HardTimeout))
3877 encoder.PutUint16(uint16(self.MatchLen))
3878 encoder.PutUint8(uint8(self.TableId))
3879 encoder.Write(bytes.Repeat([]byte{0}, 1))
3880 encoder.PutUint64(uint64(self.Cookie))
3881 if err := self.Match.Serialize(encoder); err != nil {
3882 return err
3883 }
3884
3885 for _, obj := range self.Actions {
3886 if err := obj.Serialize(encoder); err != nil {
3887 return err
3888 }
3889 }
3890 length := len(encoder.Bytes()) - startIndex
3891
3892 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
3893
3894 return nil
3895}
3896
3897func DecodeNiciraFlowUpdateFullDeleted(parent *NiciraFlowUpdateEvent, decoder *goloxi.Decoder) (*NiciraFlowUpdateFullDeleted, error) {
3898 _niciraflowupdatefulldeleted := &NiciraFlowUpdateFullDeleted{NiciraFlowUpdateEvent: parent}
3899 if decoder.Length() < 20 {
3900 return nil, fmt.Errorf("NiciraFlowUpdateFullDeleted packet too short: %d < 20", decoder.Length())
3901 }
3902 _niciraflowupdatefulldeleted.Reason = uint16(decoder.ReadUint16())
3903 _niciraflowupdatefulldeleted.Priority = uint16(decoder.ReadUint16())
3904 _niciraflowupdatefulldeleted.IdleTimeout = uint16(decoder.ReadUint16())
3905 _niciraflowupdatefulldeleted.HardTimeout = uint16(decoder.ReadUint16())
3906 _niciraflowupdatefulldeleted.MatchLen = uint16(decoder.ReadUint16())
3907 _niciraflowupdatefulldeleted.TableId = uint8(decoder.ReadByte())
3908 decoder.Skip(1)
3909 _niciraflowupdatefulldeleted.Cookie = uint64(decoder.ReadUint64())
3910 if err := _niciraflowupdatefulldeleted.Match.Decode(decoder.SliceDecoder(int(_niciraflowupdatefulldeleted.MatchLen), 0)); err != nil {
3911 return nil, err
3912 }
3913
3914 decoder.SkipAlign()
3915
3916 for decoder.Length() >= 8 {
3917 item, err := DecodeAction(decoder)
3918 if err != nil {
3919 return nil, err
3920 }
3921 if item != nil {
3922 _niciraflowupdatefulldeleted.Actions = append(_niciraflowupdatefulldeleted.Actions, item)
3923 }
3924 }
3925 return _niciraflowupdatefulldeleted, nil
3926}
3927
3928func NewNiciraFlowUpdateFullDeleted() *NiciraFlowUpdateFullDeleted {
3929 obj := &NiciraFlowUpdateFullDeleted{
3930 NiciraFlowUpdateEvent: NewNiciraFlowUpdateEvent(1),
3931 }
3932 return obj
3933}
3934
3935type NiciraFlowUpdateFullModified struct {
3936 *NiciraFlowUpdateEvent
3937 Reason uint16
3938 Priority uint16
3939 IdleTimeout uint16
3940 HardTimeout uint16
3941 MatchLen uint16
3942 TableId uint8
3943 Cookie uint64
3944 Match NiciraMatch
3945 Actions []goloxi.IAction
3946}
3947
3948type INiciraFlowUpdateFullModified interface {
3949 INiciraFlowUpdateEvent
3950 GetReason() uint16
3951 GetPriority() uint16
3952 GetIdleTimeout() uint16
3953 GetHardTimeout() uint16
3954 GetMatchLen() uint16
3955 GetTableId() uint8
3956 GetCookie() uint64
3957 GetMatch() NiciraMatch
3958 GetActions() []goloxi.IAction
3959}
3960
3961func (self *NiciraFlowUpdateFullModified) GetReason() uint16 {
3962 return self.Reason
3963}
3964
3965func (self *NiciraFlowUpdateFullModified) SetReason(v uint16) {
3966 self.Reason = v
3967}
3968
3969func (self *NiciraFlowUpdateFullModified) GetPriority() uint16 {
3970 return self.Priority
3971}
3972
3973func (self *NiciraFlowUpdateFullModified) SetPriority(v uint16) {
3974 self.Priority = v
3975}
3976
3977func (self *NiciraFlowUpdateFullModified) GetIdleTimeout() uint16 {
3978 return self.IdleTimeout
3979}
3980
3981func (self *NiciraFlowUpdateFullModified) SetIdleTimeout(v uint16) {
3982 self.IdleTimeout = v
3983}
3984
3985func (self *NiciraFlowUpdateFullModified) GetHardTimeout() uint16 {
3986 return self.HardTimeout
3987}
3988
3989func (self *NiciraFlowUpdateFullModified) SetHardTimeout(v uint16) {
3990 self.HardTimeout = v
3991}
3992
3993func (self *NiciraFlowUpdateFullModified) GetMatchLen() uint16 {
3994 return self.MatchLen
3995}
3996
3997func (self *NiciraFlowUpdateFullModified) SetMatchLen(v uint16) {
3998 self.MatchLen = v
3999}
4000
4001func (self *NiciraFlowUpdateFullModified) GetTableId() uint8 {
4002 return self.TableId
4003}
4004
4005func (self *NiciraFlowUpdateFullModified) SetTableId(v uint8) {
4006 self.TableId = v
4007}
4008
4009func (self *NiciraFlowUpdateFullModified) GetCookie() uint64 {
4010 return self.Cookie
4011}
4012
4013func (self *NiciraFlowUpdateFullModified) SetCookie(v uint64) {
4014 self.Cookie = v
4015}
4016
4017func (self *NiciraFlowUpdateFullModified) GetMatch() NiciraMatch {
4018 return self.Match
4019}
4020
4021func (self *NiciraFlowUpdateFullModified) SetMatch(v NiciraMatch) {
4022 self.Match = v
4023}
4024
4025func (self *NiciraFlowUpdateFullModified) GetActions() []goloxi.IAction {
4026 return self.Actions
4027}
4028
4029func (self *NiciraFlowUpdateFullModified) SetActions(v []goloxi.IAction) {
4030 self.Actions = v
4031}
4032
4033func (self *NiciraFlowUpdateFullModified) Serialize(encoder *goloxi.Encoder) error {
4034 startIndex := len(encoder.Bytes())
4035 if err := self.NiciraFlowUpdateEvent.Serialize(encoder); err != nil {
4036 return err
4037 }
4038
4039 encoder.PutUint16(uint16(self.Reason))
4040 encoder.PutUint16(uint16(self.Priority))
4041 encoder.PutUint16(uint16(self.IdleTimeout))
4042 encoder.PutUint16(uint16(self.HardTimeout))
4043 encoder.PutUint16(uint16(self.MatchLen))
4044 encoder.PutUint8(uint8(self.TableId))
4045 encoder.Write(bytes.Repeat([]byte{0}, 1))
4046 encoder.PutUint64(uint64(self.Cookie))
4047 if err := self.Match.Serialize(encoder); err != nil {
4048 return err
4049 }
4050
4051 for _, obj := range self.Actions {
4052 if err := obj.Serialize(encoder); err != nil {
4053 return err
4054 }
4055 }
4056 length := len(encoder.Bytes()) - startIndex
4057
4058 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
4059
4060 return nil
4061}
4062
4063func DecodeNiciraFlowUpdateFullModified(parent *NiciraFlowUpdateEvent, decoder *goloxi.Decoder) (*NiciraFlowUpdateFullModified, error) {
4064 _niciraflowupdatefullmodified := &NiciraFlowUpdateFullModified{NiciraFlowUpdateEvent: parent}
4065 if decoder.Length() < 20 {
4066 return nil, fmt.Errorf("NiciraFlowUpdateFullModified packet too short: %d < 20", decoder.Length())
4067 }
4068 _niciraflowupdatefullmodified.Reason = uint16(decoder.ReadUint16())
4069 _niciraflowupdatefullmodified.Priority = uint16(decoder.ReadUint16())
4070 _niciraflowupdatefullmodified.IdleTimeout = uint16(decoder.ReadUint16())
4071 _niciraflowupdatefullmodified.HardTimeout = uint16(decoder.ReadUint16())
4072 _niciraflowupdatefullmodified.MatchLen = uint16(decoder.ReadUint16())
4073 _niciraflowupdatefullmodified.TableId = uint8(decoder.ReadByte())
4074 decoder.Skip(1)
4075 _niciraflowupdatefullmodified.Cookie = uint64(decoder.ReadUint64())
4076 if err := _niciraflowupdatefullmodified.Match.Decode(decoder.SliceDecoder(int(_niciraflowupdatefullmodified.MatchLen), 0)); err != nil {
4077 return nil, err
4078 }
4079
4080 decoder.SkipAlign()
4081
4082 for decoder.Length() >= 8 {
4083 item, err := DecodeAction(decoder)
4084 if err != nil {
4085 return nil, err
4086 }
4087 if item != nil {
4088 _niciraflowupdatefullmodified.Actions = append(_niciraflowupdatefullmodified.Actions, item)
4089 }
4090 }
4091 return _niciraflowupdatefullmodified, nil
4092}
4093
4094func NewNiciraFlowUpdateFullModified() *NiciraFlowUpdateFullModified {
4095 obj := &NiciraFlowUpdateFullModified{
4096 NiciraFlowUpdateEvent: NewNiciraFlowUpdateEvent(2),
4097 }
4098 return obj
4099}
4100
4101type OxmIdArpOp struct {
4102 *OxmId
4103}
4104
4105type IOxmIdArpOp interface {
4106 IOxmId
4107}
4108
4109func (self *OxmIdArpOp) Serialize(encoder *goloxi.Encoder) error {
4110 if err := self.OxmId.Serialize(encoder); err != nil {
4111 return err
4112 }
4113
4114 return nil
4115}
4116
4117func DecodeOxmIdArpOp(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpOp, error) {
4118 _oxmidarpop := &OxmIdArpOp{OxmId: parent}
4119 return _oxmidarpop, nil
4120}
4121
4122func NewOxmIdArpOp() *OxmIdArpOp {
4123 obj := &OxmIdArpOp{
4124 OxmId: NewOxmId(7682),
4125 }
4126 return obj
4127}
4128func (self *OxmIdArpOp) GetOXMName() string {
4129 return "arp_op"
4130}
4131
4132func (self *OxmIdArpOp) MarshalJSON() ([]byte, error) {
4133 if self.TypeLen == 0 {
4134 return []byte("\"\""), nil
4135 } else {
4136 return []byte("\"" + self.GetOXMName() + "\""), nil
4137 }
4138}
4139
4140type OxmIdArpSha struct {
4141 *OxmId
4142}
4143
4144type IOxmIdArpSha interface {
4145 IOxmId
4146}
4147
4148func (self *OxmIdArpSha) Serialize(encoder *goloxi.Encoder) error {
4149 if err := self.OxmId.Serialize(encoder); err != nil {
4150 return err
4151 }
4152
4153 return nil
4154}
4155
4156func DecodeOxmIdArpSha(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpSha, error) {
4157 _oxmidarpsha := &OxmIdArpSha{OxmId: parent}
4158 return _oxmidarpsha, nil
4159}
4160
4161func NewOxmIdArpSha() *OxmIdArpSha {
4162 obj := &OxmIdArpSha{
4163 OxmId: NewOxmId(74246),
4164 }
4165 return obj
4166}
4167func (self *OxmIdArpSha) GetOXMName() string {
4168 return "arp_sha"
4169}
4170
4171func (self *OxmIdArpSha) MarshalJSON() ([]byte, error) {
4172 if self.TypeLen == 0 {
4173 return []byte("\"\""), nil
4174 } else {
4175 return []byte("\"" + self.GetOXMName() + "\""), nil
4176 }
4177}
4178
4179type OxmIdArpShaMasked struct {
4180 *OxmId
4181}
4182
4183type IOxmIdArpShaMasked interface {
4184 IOxmId
4185}
4186
4187func (self *OxmIdArpShaMasked) Serialize(encoder *goloxi.Encoder) error {
4188 if err := self.OxmId.Serialize(encoder); err != nil {
4189 return err
4190 }
4191
4192 return nil
4193}
4194
4195func DecodeOxmIdArpShaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpShaMasked, error) {
4196 _oxmidarpshamasked := &OxmIdArpShaMasked{OxmId: parent}
4197 return _oxmidarpshamasked, nil
4198}
4199
4200func NewOxmIdArpShaMasked() *OxmIdArpShaMasked {
4201 obj := &OxmIdArpShaMasked{
4202 OxmId: NewOxmId(74507),
4203 }
4204 return obj
4205}
4206func (self *OxmIdArpShaMasked) GetOXMName() string {
4207 return "arp_sha_masked"
4208}
4209
4210func (self *OxmIdArpShaMasked) MarshalJSON() ([]byte, error) {
4211 if self.TypeLen == 0 {
4212 return []byte("\"\""), nil
4213 } else {
4214 return []byte("\"" + self.GetOXMName() + "\""), nil
4215 }
4216}
4217
4218type OxmIdArpSpa struct {
4219 *OxmId
4220}
4221
4222type IOxmIdArpSpa interface {
4223 IOxmId
4224}
4225
4226func (self *OxmIdArpSpa) Serialize(encoder *goloxi.Encoder) error {
4227 if err := self.OxmId.Serialize(encoder); err != nil {
4228 return err
4229 }
4230
4231 return nil
4232}
4233
4234func DecodeOxmIdArpSpa(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpSpa, error) {
4235 _oxmidarpspa := &OxmIdArpSpa{OxmId: parent}
4236 return _oxmidarpspa, nil
4237}
4238
4239func NewOxmIdArpSpa() *OxmIdArpSpa {
4240 obj := &OxmIdArpSpa{
4241 OxmId: NewOxmId(8196),
4242 }
4243 return obj
4244}
4245func (self *OxmIdArpSpa) GetOXMName() string {
4246 return "arp_spa"
4247}
4248
4249func (self *OxmIdArpSpa) MarshalJSON() ([]byte, error) {
4250 if self.TypeLen == 0 {
4251 return []byte("\"\""), nil
4252 } else {
4253 return []byte("\"" + self.GetOXMName() + "\""), nil
4254 }
4255}
4256
4257type OxmIdArpSpaMasked struct {
4258 *OxmId
4259}
4260
4261type IOxmIdArpSpaMasked interface {
4262 IOxmId
4263}
4264
4265func (self *OxmIdArpSpaMasked) Serialize(encoder *goloxi.Encoder) error {
4266 if err := self.OxmId.Serialize(encoder); err != nil {
4267 return err
4268 }
4269
4270 return nil
4271}
4272
4273func DecodeOxmIdArpSpaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpSpaMasked, error) {
4274 _oxmidarpspamasked := &OxmIdArpSpaMasked{OxmId: parent}
4275 return _oxmidarpspamasked, nil
4276}
4277
4278func NewOxmIdArpSpaMasked() *OxmIdArpSpaMasked {
4279 obj := &OxmIdArpSpaMasked{
4280 OxmId: NewOxmId(8452),
4281 }
4282 return obj
4283}
4284func (self *OxmIdArpSpaMasked) GetOXMName() string {
4285 return "arp_spa_masked"
4286}
4287
4288func (self *OxmIdArpSpaMasked) MarshalJSON() ([]byte, error) {
4289 if self.TypeLen == 0 {
4290 return []byte("\"\""), nil
4291 } else {
4292 return []byte("\"" + self.GetOXMName() + "\""), nil
4293 }
4294}
4295
4296type OxmIdArpTha struct {
4297 *OxmId
4298}
4299
4300type IOxmIdArpTha interface {
4301 IOxmId
4302}
4303
4304func (self *OxmIdArpTha) Serialize(encoder *goloxi.Encoder) error {
4305 if err := self.OxmId.Serialize(encoder); err != nil {
4306 return err
4307 }
4308
4309 return nil
4310}
4311
4312func DecodeOxmIdArpTha(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpTha, error) {
4313 _oxmidarptha := &OxmIdArpTha{OxmId: parent}
4314 return _oxmidarptha, nil
4315}
4316
4317func NewOxmIdArpTha() *OxmIdArpTha {
4318 obj := &OxmIdArpTha{
4319 OxmId: NewOxmId(74758),
4320 }
4321 return obj
4322}
4323func (self *OxmIdArpTha) GetOXMName() string {
4324 return "arp_tha"
4325}
4326
4327func (self *OxmIdArpTha) MarshalJSON() ([]byte, error) {
4328 if self.TypeLen == 0 {
4329 return []byte("\"\""), nil
4330 } else {
4331 return []byte("\"" + self.GetOXMName() + "\""), nil
4332 }
4333}
4334
4335type OxmIdArpThaMasked struct {
4336 *OxmId
4337}
4338
4339type IOxmIdArpThaMasked interface {
4340 IOxmId
4341}
4342
4343func (self *OxmIdArpThaMasked) Serialize(encoder *goloxi.Encoder) error {
4344 if err := self.OxmId.Serialize(encoder); err != nil {
4345 return err
4346 }
4347
4348 return nil
4349}
4350
4351func DecodeOxmIdArpThaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpThaMasked, error) {
4352 _oxmidarpthamasked := &OxmIdArpThaMasked{OxmId: parent}
4353 return _oxmidarpthamasked, nil
4354}
4355
4356func NewOxmIdArpThaMasked() *OxmIdArpThaMasked {
4357 obj := &OxmIdArpThaMasked{
4358 OxmId: NewOxmId(75019),
4359 }
4360 return obj
4361}
4362func (self *OxmIdArpThaMasked) GetOXMName() string {
4363 return "arp_tha_masked"
4364}
4365
4366func (self *OxmIdArpThaMasked) MarshalJSON() ([]byte, error) {
4367 if self.TypeLen == 0 {
4368 return []byte("\"\""), nil
4369 } else {
4370 return []byte("\"" + self.GetOXMName() + "\""), nil
4371 }
4372}
4373
4374type OxmIdArpTpa struct {
4375 *OxmId
4376}
4377
4378type IOxmIdArpTpa interface {
4379 IOxmId
4380}
4381
4382func (self *OxmIdArpTpa) Serialize(encoder *goloxi.Encoder) error {
4383 if err := self.OxmId.Serialize(encoder); err != nil {
4384 return err
4385 }
4386
4387 return nil
4388}
4389
4390func DecodeOxmIdArpTpa(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpTpa, error) {
4391 _oxmidarptpa := &OxmIdArpTpa{OxmId: parent}
4392 return _oxmidarptpa, nil
4393}
4394
4395func NewOxmIdArpTpa() *OxmIdArpTpa {
4396 obj := &OxmIdArpTpa{
4397 OxmId: NewOxmId(8708),
4398 }
4399 return obj
4400}
4401func (self *OxmIdArpTpa) GetOXMName() string {
4402 return "arp_tpa"
4403}
4404
4405func (self *OxmIdArpTpa) MarshalJSON() ([]byte, error) {
4406 if self.TypeLen == 0 {
4407 return []byte("\"\""), nil
4408 } else {
4409 return []byte("\"" + self.GetOXMName() + "\""), nil
4410 }
4411}
4412
4413type OxmIdArpTpaMasked struct {
4414 *OxmId
4415}
4416
4417type IOxmIdArpTpaMasked interface {
4418 IOxmId
4419}
4420
4421func (self *OxmIdArpTpaMasked) Serialize(encoder *goloxi.Encoder) error {
4422 if err := self.OxmId.Serialize(encoder); err != nil {
4423 return err
4424 }
4425
4426 return nil
4427}
4428
4429func DecodeOxmIdArpTpaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpTpaMasked, error) {
4430 _oxmidarptpamasked := &OxmIdArpTpaMasked{OxmId: parent}
4431 return _oxmidarptpamasked, nil
4432}
4433
4434func NewOxmIdArpTpaMasked() *OxmIdArpTpaMasked {
4435 obj := &OxmIdArpTpaMasked{
4436 OxmId: NewOxmId(8968),
4437 }
4438 return obj
4439}
4440func (self *OxmIdArpTpaMasked) GetOXMName() string {
4441 return "arp_tpa_masked"
4442}
4443
4444func (self *OxmIdArpTpaMasked) MarshalJSON() ([]byte, error) {
4445 if self.TypeLen == 0 {
4446 return []byte("\"\""), nil
4447 } else {
4448 return []byte("\"" + self.GetOXMName() + "\""), nil
4449 }
4450}
4451
4452type OxmIdConjId struct {
4453 *OxmId
4454}
4455
4456type IOxmIdConjId interface {
4457 IOxmId
4458}
4459
4460func (self *OxmIdConjId) Serialize(encoder *goloxi.Encoder) error {
4461 if err := self.OxmId.Serialize(encoder); err != nil {
4462 return err
4463 }
4464
4465 return nil
4466}
4467
4468func DecodeOxmIdConjId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConjId, error) {
4469 _oxmidconjid := &OxmIdConjId{OxmId: parent}
4470 return _oxmidconjid, nil
4471}
4472
4473func NewOxmIdConjId() *OxmIdConjId {
4474 obj := &OxmIdConjId{
4475 OxmId: NewOxmId(84484),
4476 }
4477 return obj
4478}
4479func (self *OxmIdConjId) GetOXMName() string {
4480 return "conj_id"
4481}
4482
4483func (self *OxmIdConjId) MarshalJSON() ([]byte, error) {
4484 if self.TypeLen == 0 {
4485 return []byte("\"\""), nil
4486 } else {
4487 return []byte("\"" + self.GetOXMName() + "\""), nil
4488 }
4489}
4490
4491type OxmIdCtIpv6Dst struct {
4492 *OxmId
4493}
4494
4495type IOxmIdCtIpv6Dst interface {
4496 IOxmId
4497}
4498
4499func (self *OxmIdCtIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
4500 if err := self.OxmId.Serialize(encoder); err != nil {
4501 return err
4502 }
4503
4504 return nil
4505}
4506
4507func DecodeOxmIdCtIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6Dst, error) {
4508 _oxmidctipv6dst := &OxmIdCtIpv6Dst{OxmId: parent}
4509 return _oxmidctipv6dst, nil
4510}
4511
4512func NewOxmIdCtIpv6Dst() *OxmIdCtIpv6Dst {
4513 obj := &OxmIdCtIpv6Dst{
4514 OxmId: NewOxmId(128528),
4515 }
4516 return obj
4517}
4518func (self *OxmIdCtIpv6Dst) GetOXMName() string {
4519 return "ct_ipv6_dst"
4520}
4521
4522func (self *OxmIdCtIpv6Dst) MarshalJSON() ([]byte, error) {
4523 if self.TypeLen == 0 {
4524 return []byte("\"\""), nil
4525 } else {
4526 return []byte("\"" + self.GetOXMName() + "\""), nil
4527 }
4528}
4529
4530type OxmIdCtIpv6DstMasked struct {
4531 *OxmId
4532}
4533
4534type IOxmIdCtIpv6DstMasked interface {
4535 IOxmId
4536}
4537
4538func (self *OxmIdCtIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
4539 if err := self.OxmId.Serialize(encoder); err != nil {
4540 return err
4541 }
4542
4543 return nil
4544}
4545
4546func DecodeOxmIdCtIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6DstMasked, error) {
4547 _oxmidctipv6dstmasked := &OxmIdCtIpv6DstMasked{OxmId: parent}
4548 return _oxmidctipv6dstmasked, nil
4549}
4550
4551func NewOxmIdCtIpv6DstMasked() *OxmIdCtIpv6DstMasked {
4552 obj := &OxmIdCtIpv6DstMasked{
4553 OxmId: NewOxmId(128800),
4554 }
4555 return obj
4556}
4557func (self *OxmIdCtIpv6DstMasked) GetOXMName() string {
4558 return "ct_ipv6_dst_masked"
4559}
4560
4561func (self *OxmIdCtIpv6DstMasked) MarshalJSON() ([]byte, error) {
4562 if self.TypeLen == 0 {
4563 return []byte("\"\""), nil
4564 } else {
4565 return []byte("\"" + self.GetOXMName() + "\""), nil
4566 }
4567}
4568
4569type OxmIdCtIpv6Src struct {
4570 *OxmId
4571}
4572
4573type IOxmIdCtIpv6Src interface {
4574 IOxmId
4575}
4576
4577func (self *OxmIdCtIpv6Src) Serialize(encoder *goloxi.Encoder) error {
4578 if err := self.OxmId.Serialize(encoder); err != nil {
4579 return err
4580 }
4581
4582 return nil
4583}
4584
4585func DecodeOxmIdCtIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6Src, error) {
4586 _oxmidctipv6src := &OxmIdCtIpv6Src{OxmId: parent}
4587 return _oxmidctipv6src, nil
4588}
4589
4590func NewOxmIdCtIpv6Src() *OxmIdCtIpv6Src {
4591 obj := &OxmIdCtIpv6Src{
4592 OxmId: NewOxmId(128016),
4593 }
4594 return obj
4595}
4596func (self *OxmIdCtIpv6Src) GetOXMName() string {
4597 return "ct_ipv6_src"
4598}
4599
4600func (self *OxmIdCtIpv6Src) MarshalJSON() ([]byte, error) {
4601 if self.TypeLen == 0 {
4602 return []byte("\"\""), nil
4603 } else {
4604 return []byte("\"" + self.GetOXMName() + "\""), nil
4605 }
4606}
4607
4608type OxmIdCtIpv6SrcMasked struct {
4609 *OxmId
4610}
4611
4612type IOxmIdCtIpv6SrcMasked interface {
4613 IOxmId
4614}
4615
4616func (self *OxmIdCtIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
4617 if err := self.OxmId.Serialize(encoder); err != nil {
4618 return err
4619 }
4620
4621 return nil
4622}
4623
4624func DecodeOxmIdCtIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6SrcMasked, error) {
4625 _oxmidctipv6srcmasked := &OxmIdCtIpv6SrcMasked{OxmId: parent}
4626 return _oxmidctipv6srcmasked, nil
4627}
4628
4629func NewOxmIdCtIpv6SrcMasked() *OxmIdCtIpv6SrcMasked {
4630 obj := &OxmIdCtIpv6SrcMasked{
4631 OxmId: NewOxmId(128288),
4632 }
4633 return obj
4634}
4635func (self *OxmIdCtIpv6SrcMasked) GetOXMName() string {
4636 return "ct_ipv6_src_masked"
4637}
4638
4639func (self *OxmIdCtIpv6SrcMasked) MarshalJSON() ([]byte, error) {
4640 if self.TypeLen == 0 {
4641 return []byte("\"\""), nil
4642 } else {
4643 return []byte("\"" + self.GetOXMName() + "\""), nil
4644 }
4645}
4646
4647type OxmIdCtLabel struct {
4648 *OxmId
4649}
4650
4651type IOxmIdCtLabel interface {
4652 IOxmId
4653}
4654
4655func (self *OxmIdCtLabel) Serialize(encoder *goloxi.Encoder) error {
4656 if err := self.OxmId.Serialize(encoder); err != nil {
4657 return err
4658 }
4659
4660 return nil
4661}
4662
4663func DecodeOxmIdCtLabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtLabel, error) {
4664 _oxmidctlabel := &OxmIdCtLabel{OxmId: parent}
4665 return _oxmidctlabel, nil
4666}
4667
4668func NewOxmIdCtLabel() *OxmIdCtLabel {
4669 obj := &OxmIdCtLabel{
4670 OxmId: NewOxmId(120848),
4671 }
4672 return obj
4673}
4674func (self *OxmIdCtLabel) GetOXMName() string {
4675 return "ct_label"
4676}
4677
4678func (self *OxmIdCtLabel) MarshalJSON() ([]byte, error) {
4679 if self.TypeLen == 0 {
4680 return []byte("\"\""), nil
4681 } else {
4682 return []byte("\"" + self.GetOXMName() + "\""), nil
4683 }
4684}
4685
4686type OxmIdCtLabelMasked struct {
4687 *OxmId
4688}
4689
4690type IOxmIdCtLabelMasked interface {
4691 IOxmId
4692}
4693
4694func (self *OxmIdCtLabelMasked) Serialize(encoder *goloxi.Encoder) error {
4695 if err := self.OxmId.Serialize(encoder); err != nil {
4696 return err
4697 }
4698
4699 return nil
4700}
4701
4702func DecodeOxmIdCtLabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtLabelMasked, error) {
4703 _oxmidctlabelmasked := &OxmIdCtLabelMasked{OxmId: parent}
4704 return _oxmidctlabelmasked, nil
4705}
4706
4707func NewOxmIdCtLabelMasked() *OxmIdCtLabelMasked {
4708 obj := &OxmIdCtLabelMasked{
4709 OxmId: NewOxmId(121120),
4710 }
4711 return obj
4712}
4713func (self *OxmIdCtLabelMasked) GetOXMName() string {
4714 return "ct_label_masked"
4715}
4716
4717func (self *OxmIdCtLabelMasked) MarshalJSON() ([]byte, error) {
4718 if self.TypeLen == 0 {
4719 return []byte("\"\""), nil
4720 } else {
4721 return []byte("\"" + self.GetOXMName() + "\""), nil
4722 }
4723}
4724
4725type OxmIdCtMark struct {
4726 *OxmId
4727}
4728
4729type IOxmIdCtMark interface {
4730 IOxmId
4731}
4732
4733func (self *OxmIdCtMark) Serialize(encoder *goloxi.Encoder) error {
4734 if err := self.OxmId.Serialize(encoder); err != nil {
4735 return err
4736 }
4737
4738 return nil
4739}
4740
4741func DecodeOxmIdCtMark(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtMark, error) {
4742 _oxmidctmark := &OxmIdCtMark{OxmId: parent}
4743 return _oxmidctmark, nil
4744}
4745
4746func NewOxmIdCtMark() *OxmIdCtMark {
4747 obj := &OxmIdCtMark{
4748 OxmId: NewOxmId(120324),
4749 }
4750 return obj
4751}
4752func (self *OxmIdCtMark) GetOXMName() string {
4753 return "ct_mark"
4754}
4755
4756func (self *OxmIdCtMark) MarshalJSON() ([]byte, error) {
4757 if self.TypeLen == 0 {
4758 return []byte("\"\""), nil
4759 } else {
4760 return []byte("\"" + self.GetOXMName() + "\""), nil
4761 }
4762}
4763
4764type OxmIdCtMarkMasked struct {
4765 *OxmId
4766}
4767
4768type IOxmIdCtMarkMasked interface {
4769 IOxmId
4770}
4771
4772func (self *OxmIdCtMarkMasked) Serialize(encoder *goloxi.Encoder) error {
4773 if err := self.OxmId.Serialize(encoder); err != nil {
4774 return err
4775 }
4776
4777 return nil
4778}
4779
4780func DecodeOxmIdCtMarkMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtMarkMasked, error) {
4781 _oxmidctmarkmasked := &OxmIdCtMarkMasked{OxmId: parent}
4782 return _oxmidctmarkmasked, nil
4783}
4784
4785func NewOxmIdCtMarkMasked() *OxmIdCtMarkMasked {
4786 obj := &OxmIdCtMarkMasked{
4787 OxmId: NewOxmId(120584),
4788 }
4789 return obj
4790}
4791func (self *OxmIdCtMarkMasked) GetOXMName() string {
4792 return "ct_mark_masked"
4793}
4794
4795func (self *OxmIdCtMarkMasked) MarshalJSON() ([]byte, error) {
4796 if self.TypeLen == 0 {
4797 return []byte("\"\""), nil
4798 } else {
4799 return []byte("\"" + self.GetOXMName() + "\""), nil
4800 }
4801}
4802
4803type OxmIdCtNwDst struct {
4804 *OxmId
4805}
4806
4807type IOxmIdCtNwDst interface {
4808 IOxmId
4809}
4810
4811func (self *OxmIdCtNwDst) Serialize(encoder *goloxi.Encoder) error {
4812 if err := self.OxmId.Serialize(encoder); err != nil {
4813 return err
4814 }
4815
4816 return nil
4817}
4818
4819func DecodeOxmIdCtNwDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwDst, error) {
4820 _oxmidctnwdst := &OxmIdCtNwDst{OxmId: parent}
4821 return _oxmidctnwdst, nil
4822}
4823
4824func NewOxmIdCtNwDst() *OxmIdCtNwDst {
4825 obj := &OxmIdCtNwDst{
4826 OxmId: NewOxmId(127492),
4827 }
4828 return obj
4829}
4830func (self *OxmIdCtNwDst) GetOXMName() string {
4831 return "ct_nw_dst"
4832}
4833
4834func (self *OxmIdCtNwDst) MarshalJSON() ([]byte, error) {
4835 if self.TypeLen == 0 {
4836 return []byte("\"\""), nil
4837 } else {
4838 return []byte("\"" + self.GetOXMName() + "\""), nil
4839 }
4840}
4841
4842type OxmIdCtNwDstMasked struct {
4843 *OxmId
4844}
4845
4846type IOxmIdCtNwDstMasked interface {
4847 IOxmId
4848}
4849
4850func (self *OxmIdCtNwDstMasked) Serialize(encoder *goloxi.Encoder) error {
4851 if err := self.OxmId.Serialize(encoder); err != nil {
4852 return err
4853 }
4854
4855 return nil
4856}
4857
4858func DecodeOxmIdCtNwDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwDstMasked, error) {
4859 _oxmidctnwdstmasked := &OxmIdCtNwDstMasked{OxmId: parent}
4860 return _oxmidctnwdstmasked, nil
4861}
4862
4863func NewOxmIdCtNwDstMasked() *OxmIdCtNwDstMasked {
4864 obj := &OxmIdCtNwDstMasked{
4865 OxmId: NewOxmId(127752),
4866 }
4867 return obj
4868}
4869func (self *OxmIdCtNwDstMasked) GetOXMName() string {
4870 return "ct_nw_dst_masked"
4871}
4872
4873func (self *OxmIdCtNwDstMasked) MarshalJSON() ([]byte, error) {
4874 if self.TypeLen == 0 {
4875 return []byte("\"\""), nil
4876 } else {
4877 return []byte("\"" + self.GetOXMName() + "\""), nil
4878 }
4879}
4880
4881type OxmIdCtNwProto struct {
4882 *OxmId
4883}
4884
4885type IOxmIdCtNwProto interface {
4886 IOxmId
4887}
4888
4889func (self *OxmIdCtNwProto) Serialize(encoder *goloxi.Encoder) error {
4890 if err := self.OxmId.Serialize(encoder); err != nil {
4891 return err
4892 }
4893
4894 return nil
4895}
4896
4897func DecodeOxmIdCtNwProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwProto, error) {
4898 _oxmidctnwproto := &OxmIdCtNwProto{OxmId: parent}
4899 return _oxmidctnwproto, nil
4900}
4901
4902func NewOxmIdCtNwProto() *OxmIdCtNwProto {
4903 obj := &OxmIdCtNwProto{
4904 OxmId: NewOxmId(126465),
4905 }
4906 return obj
4907}
4908func (self *OxmIdCtNwProto) GetOXMName() string {
4909 return "ct_nw_proto"
4910}
4911
4912func (self *OxmIdCtNwProto) MarshalJSON() ([]byte, error) {
4913 if self.TypeLen == 0 {
4914 return []byte("\"\""), nil
4915 } else {
4916 return []byte("\"" + self.GetOXMName() + "\""), nil
4917 }
4918}
4919
4920type OxmIdCtNwSrc struct {
4921 *OxmId
4922}
4923
4924type IOxmIdCtNwSrc interface {
4925 IOxmId
4926}
4927
4928func (self *OxmIdCtNwSrc) Serialize(encoder *goloxi.Encoder) error {
4929 if err := self.OxmId.Serialize(encoder); err != nil {
4930 return err
4931 }
4932
4933 return nil
4934}
4935
4936func DecodeOxmIdCtNwSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwSrc, error) {
4937 _oxmidctnwsrc := &OxmIdCtNwSrc{OxmId: parent}
4938 return _oxmidctnwsrc, nil
4939}
4940
4941func NewOxmIdCtNwSrc() *OxmIdCtNwSrc {
4942 obj := &OxmIdCtNwSrc{
4943 OxmId: NewOxmId(126980),
4944 }
4945 return obj
4946}
4947func (self *OxmIdCtNwSrc) GetOXMName() string {
4948 return "ct_nw_src"
4949}
4950
4951func (self *OxmIdCtNwSrc) MarshalJSON() ([]byte, error) {
4952 if self.TypeLen == 0 {
4953 return []byte("\"\""), nil
4954 } else {
4955 return []byte("\"" + self.GetOXMName() + "\""), nil
4956 }
4957}
4958
4959type OxmIdCtNwSrcMasked struct {
4960 *OxmId
4961}
4962
4963type IOxmIdCtNwSrcMasked interface {
4964 IOxmId
4965}
4966
4967func (self *OxmIdCtNwSrcMasked) Serialize(encoder *goloxi.Encoder) error {
4968 if err := self.OxmId.Serialize(encoder); err != nil {
4969 return err
4970 }
4971
4972 return nil
4973}
4974
4975func DecodeOxmIdCtNwSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwSrcMasked, error) {
4976 _oxmidctnwsrcmasked := &OxmIdCtNwSrcMasked{OxmId: parent}
4977 return _oxmidctnwsrcmasked, nil
4978}
4979
4980func NewOxmIdCtNwSrcMasked() *OxmIdCtNwSrcMasked {
4981 obj := &OxmIdCtNwSrcMasked{
4982 OxmId: NewOxmId(127240),
4983 }
4984 return obj
4985}
4986func (self *OxmIdCtNwSrcMasked) GetOXMName() string {
4987 return "ct_nw_src_masked"
4988}
4989
4990func (self *OxmIdCtNwSrcMasked) MarshalJSON() ([]byte, error) {
4991 if self.TypeLen == 0 {
4992 return []byte("\"\""), nil
4993 } else {
4994 return []byte("\"" + self.GetOXMName() + "\""), nil
4995 }
4996}
4997
4998type OxmIdCtState struct {
4999 *OxmId
5000}
5001
5002type IOxmIdCtState interface {
5003 IOxmId
5004}
5005
5006func (self *OxmIdCtState) Serialize(encoder *goloxi.Encoder) error {
5007 if err := self.OxmId.Serialize(encoder); err != nil {
5008 return err
5009 }
5010
5011 return nil
5012}
5013
5014func DecodeOxmIdCtState(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtState, error) {
5015 _oxmidctstate := &OxmIdCtState{OxmId: parent}
5016 return _oxmidctstate, nil
5017}
5018
5019func NewOxmIdCtState() *OxmIdCtState {
5020 obj := &OxmIdCtState{
5021 OxmId: NewOxmId(119300),
5022 }
5023 return obj
5024}
5025func (self *OxmIdCtState) GetOXMName() string {
5026 return "ct_state"
5027}
5028
5029func (self *OxmIdCtState) MarshalJSON() ([]byte, error) {
5030 if self.TypeLen == 0 {
5031 return []byte("\"\""), nil
5032 } else {
5033 return []byte("\"" + self.GetOXMName() + "\""), nil
5034 }
5035}
5036
5037type OxmIdCtStateMasked struct {
5038 *OxmId
5039}
5040
5041type IOxmIdCtStateMasked interface {
5042 IOxmId
5043}
5044
5045func (self *OxmIdCtStateMasked) Serialize(encoder *goloxi.Encoder) error {
5046 if err := self.OxmId.Serialize(encoder); err != nil {
5047 return err
5048 }
5049
5050 return nil
5051}
5052
5053func DecodeOxmIdCtStateMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtStateMasked, error) {
5054 _oxmidctstatemasked := &OxmIdCtStateMasked{OxmId: parent}
5055 return _oxmidctstatemasked, nil
5056}
5057
5058func NewOxmIdCtStateMasked() *OxmIdCtStateMasked {
5059 obj := &OxmIdCtStateMasked{
5060 OxmId: NewOxmId(119560),
5061 }
5062 return obj
5063}
5064func (self *OxmIdCtStateMasked) GetOXMName() string {
5065 return "ct_state_masked"
5066}
5067
5068func (self *OxmIdCtStateMasked) MarshalJSON() ([]byte, error) {
5069 if self.TypeLen == 0 {
5070 return []byte("\"\""), nil
5071 } else {
5072 return []byte("\"" + self.GetOXMName() + "\""), nil
5073 }
5074}
5075
5076type OxmIdCtTpDst struct {
5077 *OxmId
5078}
5079
5080type IOxmIdCtTpDst interface {
5081 IOxmId
5082}
5083
5084func (self *OxmIdCtTpDst) Serialize(encoder *goloxi.Encoder) error {
5085 if err := self.OxmId.Serialize(encoder); err != nil {
5086 return err
5087 }
5088
5089 return nil
5090}
5091
5092func DecodeOxmIdCtTpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpDst, error) {
5093 _oxmidcttpdst := &OxmIdCtTpDst{OxmId: parent}
5094 return _oxmidcttpdst, nil
5095}
5096
5097func NewOxmIdCtTpDst() *OxmIdCtTpDst {
5098 obj := &OxmIdCtTpDst{
5099 OxmId: NewOxmId(129538),
5100 }
5101 return obj
5102}
5103func (self *OxmIdCtTpDst) GetOXMName() string {
5104 return "ct_tp_dst"
5105}
5106
5107func (self *OxmIdCtTpDst) MarshalJSON() ([]byte, error) {
5108 if self.TypeLen == 0 {
5109 return []byte("\"\""), nil
5110 } else {
5111 return []byte("\"" + self.GetOXMName() + "\""), nil
5112 }
5113}
5114
5115type OxmIdCtTpDstMasked struct {
5116 *OxmId
5117}
5118
5119type IOxmIdCtTpDstMasked interface {
5120 IOxmId
5121}
5122
5123func (self *OxmIdCtTpDstMasked) Serialize(encoder *goloxi.Encoder) error {
5124 if err := self.OxmId.Serialize(encoder); err != nil {
5125 return err
5126 }
5127
5128 return nil
5129}
5130
5131func DecodeOxmIdCtTpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpDstMasked, error) {
5132 _oxmidcttpdstmasked := &OxmIdCtTpDstMasked{OxmId: parent}
5133 return _oxmidcttpdstmasked, nil
5134}
5135
5136func NewOxmIdCtTpDstMasked() *OxmIdCtTpDstMasked {
5137 obj := &OxmIdCtTpDstMasked{
5138 OxmId: NewOxmId(129796),
5139 }
5140 return obj
5141}
5142func (self *OxmIdCtTpDstMasked) GetOXMName() string {
5143 return "ct_tp_dst_masked"
5144}
5145
5146func (self *OxmIdCtTpDstMasked) MarshalJSON() ([]byte, error) {
5147 if self.TypeLen == 0 {
5148 return []byte("\"\""), nil
5149 } else {
5150 return []byte("\"" + self.GetOXMName() + "\""), nil
5151 }
5152}
5153
5154type OxmIdCtTpSrc struct {
5155 *OxmId
5156}
5157
5158type IOxmIdCtTpSrc interface {
5159 IOxmId
5160}
5161
5162func (self *OxmIdCtTpSrc) Serialize(encoder *goloxi.Encoder) error {
5163 if err := self.OxmId.Serialize(encoder); err != nil {
5164 return err
5165 }
5166
5167 return nil
5168}
5169
5170func DecodeOxmIdCtTpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpSrc, error) {
5171 _oxmidcttpsrc := &OxmIdCtTpSrc{OxmId: parent}
5172 return _oxmidcttpsrc, nil
5173}
5174
5175func NewOxmIdCtTpSrc() *OxmIdCtTpSrc {
5176 obj := &OxmIdCtTpSrc{
5177 OxmId: NewOxmId(129026),
5178 }
5179 return obj
5180}
5181func (self *OxmIdCtTpSrc) GetOXMName() string {
5182 return "ct_tp_src"
5183}
5184
5185func (self *OxmIdCtTpSrc) MarshalJSON() ([]byte, error) {
5186 if self.TypeLen == 0 {
5187 return []byte("\"\""), nil
5188 } else {
5189 return []byte("\"" + self.GetOXMName() + "\""), nil
5190 }
5191}
5192
5193type OxmIdCtTpSrcMasked struct {
5194 *OxmId
5195}
5196
5197type IOxmIdCtTpSrcMasked interface {
5198 IOxmId
5199}
5200
5201func (self *OxmIdCtTpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
5202 if err := self.OxmId.Serialize(encoder); err != nil {
5203 return err
5204 }
5205
5206 return nil
5207}
5208
5209func DecodeOxmIdCtTpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpSrcMasked, error) {
5210 _oxmidcttpsrcmasked := &OxmIdCtTpSrcMasked{OxmId: parent}
5211 return _oxmidcttpsrcmasked, nil
5212}
5213
5214func NewOxmIdCtTpSrcMasked() *OxmIdCtTpSrcMasked {
5215 obj := &OxmIdCtTpSrcMasked{
5216 OxmId: NewOxmId(129284),
5217 }
5218 return obj
5219}
5220func (self *OxmIdCtTpSrcMasked) GetOXMName() string {
5221 return "ct_tp_src_masked"
5222}
5223
5224func (self *OxmIdCtTpSrcMasked) MarshalJSON() ([]byte, error) {
5225 if self.TypeLen == 0 {
5226 return []byte("\"\""), nil
5227 } else {
5228 return []byte("\"" + self.GetOXMName() + "\""), nil
5229 }
5230}
5231
5232type OxmIdCtZone struct {
5233 *OxmId
5234}
5235
5236type IOxmIdCtZone interface {
5237 IOxmId
5238}
5239
5240func (self *OxmIdCtZone) Serialize(encoder *goloxi.Encoder) error {
5241 if err := self.OxmId.Serialize(encoder); err != nil {
5242 return err
5243 }
5244
5245 return nil
5246}
5247
5248func DecodeOxmIdCtZone(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtZone, error) {
5249 _oxmidctzone := &OxmIdCtZone{OxmId: parent}
5250 return _oxmidctzone, nil
5251}
5252
5253func NewOxmIdCtZone() *OxmIdCtZone {
5254 obj := &OxmIdCtZone{
5255 OxmId: NewOxmId(119810),
5256 }
5257 return obj
5258}
5259func (self *OxmIdCtZone) GetOXMName() string {
5260 return "ct_zone"
5261}
5262
5263func (self *OxmIdCtZone) MarshalJSON() ([]byte, error) {
5264 if self.TypeLen == 0 {
5265 return []byte("\"\""), nil
5266 } else {
5267 return []byte("\"" + self.GetOXMName() + "\""), nil
5268 }
5269}
5270
5271type OxmIdDpHash struct {
5272 *OxmId
5273}
5274
5275type IOxmIdDpHash interface {
5276 IOxmId
5277}
5278
5279func (self *OxmIdDpHash) Serialize(encoder *goloxi.Encoder) error {
5280 if err := self.OxmId.Serialize(encoder); err != nil {
5281 return err
5282 }
5283
5284 return nil
5285}
5286
5287func DecodeOxmIdDpHash(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdDpHash, error) {
5288 _oxmiddphash := &OxmIdDpHash{OxmId: parent}
5289 return _oxmiddphash, nil
5290}
5291
5292func NewOxmIdDpHash() *OxmIdDpHash {
5293 obj := &OxmIdDpHash{
5294 OxmId: NewOxmId(83460),
5295 }
5296 return obj
5297}
5298func (self *OxmIdDpHash) GetOXMName() string {
5299 return "dp_hash"
5300}
5301
5302func (self *OxmIdDpHash) MarshalJSON() ([]byte, error) {
5303 if self.TypeLen == 0 {
5304 return []byte("\"\""), nil
5305 } else {
5306 return []byte("\"" + self.GetOXMName() + "\""), nil
5307 }
5308}
5309
5310type OxmIdDpHashMasked struct {
5311 *OxmId
5312}
5313
5314type IOxmIdDpHashMasked interface {
5315 IOxmId
5316}
5317
5318func (self *OxmIdDpHashMasked) Serialize(encoder *goloxi.Encoder) error {
5319 if err := self.OxmId.Serialize(encoder); err != nil {
5320 return err
5321 }
5322
5323 return nil
5324}
5325
5326func DecodeOxmIdDpHashMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdDpHashMasked, error) {
5327 _oxmiddphashmasked := &OxmIdDpHashMasked{OxmId: parent}
5328 return _oxmiddphashmasked, nil
5329}
5330
5331func NewOxmIdDpHashMasked() *OxmIdDpHashMasked {
5332 obj := &OxmIdDpHashMasked{
5333 OxmId: NewOxmId(83720),
5334 }
5335 return obj
5336}
5337func (self *OxmIdDpHashMasked) GetOXMName() string {
5338 return "dp_hash_masked"
5339}
5340
5341func (self *OxmIdDpHashMasked) MarshalJSON() ([]byte, error) {
5342 if self.TypeLen == 0 {
5343 return []byte("\"\""), nil
5344 } else {
5345 return []byte("\"" + self.GetOXMName() + "\""), nil
5346 }
5347}
5348
5349type OxmIdEthDst struct {
5350 *OxmId
5351}
5352
5353type IOxmIdEthDst interface {
5354 IOxmId
5355}
5356
5357func (self *OxmIdEthDst) Serialize(encoder *goloxi.Encoder) error {
5358 if err := self.OxmId.Serialize(encoder); err != nil {
5359 return err
5360 }
5361
5362 return nil
5363}
5364
5365func DecodeOxmIdEthDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthDst, error) {
5366 _oxmidethdst := &OxmIdEthDst{OxmId: parent}
5367 return _oxmidethdst, nil
5368}
5369
5370func NewOxmIdEthDst() *OxmIdEthDst {
5371 obj := &OxmIdEthDst{
5372 OxmId: NewOxmId(518),
5373 }
5374 return obj
5375}
5376func (self *OxmIdEthDst) GetOXMName() string {
5377 return "eth_dst"
5378}
5379
5380func (self *OxmIdEthDst) MarshalJSON() ([]byte, error) {
5381 if self.TypeLen == 0 {
5382 return []byte("\"\""), nil
5383 } else {
5384 return []byte("\"" + self.GetOXMName() + "\""), nil
5385 }
5386}
5387
5388type OxmIdEthDstMasked struct {
5389 *OxmId
5390}
5391
5392type IOxmIdEthDstMasked interface {
5393 IOxmId
5394}
5395
5396func (self *OxmIdEthDstMasked) Serialize(encoder *goloxi.Encoder) error {
5397 if err := self.OxmId.Serialize(encoder); err != nil {
5398 return err
5399 }
5400
5401 return nil
5402}
5403
5404func DecodeOxmIdEthDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthDstMasked, error) {
5405 _oxmidethdstmasked := &OxmIdEthDstMasked{OxmId: parent}
5406 return _oxmidethdstmasked, nil
5407}
5408
5409func NewOxmIdEthDstMasked() *OxmIdEthDstMasked {
5410 obj := &OxmIdEthDstMasked{
5411 OxmId: NewOxmId(779),
5412 }
5413 return obj
5414}
5415func (self *OxmIdEthDstMasked) GetOXMName() string {
5416 return "eth_dst_masked"
5417}
5418
5419func (self *OxmIdEthDstMasked) MarshalJSON() ([]byte, error) {
5420 if self.TypeLen == 0 {
5421 return []byte("\"\""), nil
5422 } else {
5423 return []byte("\"" + self.GetOXMName() + "\""), nil
5424 }
5425}
5426
5427type OxmIdEthSrc struct {
5428 *OxmId
5429}
5430
5431type IOxmIdEthSrc interface {
5432 IOxmId
5433}
5434
5435func (self *OxmIdEthSrc) Serialize(encoder *goloxi.Encoder) error {
5436 if err := self.OxmId.Serialize(encoder); err != nil {
5437 return err
5438 }
5439
5440 return nil
5441}
5442
5443func DecodeOxmIdEthSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthSrc, error) {
5444 _oxmidethsrc := &OxmIdEthSrc{OxmId: parent}
5445 return _oxmidethsrc, nil
5446}
5447
5448func NewOxmIdEthSrc() *OxmIdEthSrc {
5449 obj := &OxmIdEthSrc{
5450 OxmId: NewOxmId(1030),
5451 }
5452 return obj
5453}
5454func (self *OxmIdEthSrc) GetOXMName() string {
5455 return "eth_src"
5456}
5457
5458func (self *OxmIdEthSrc) MarshalJSON() ([]byte, error) {
5459 if self.TypeLen == 0 {
5460 return []byte("\"\""), nil
5461 } else {
5462 return []byte("\"" + self.GetOXMName() + "\""), nil
5463 }
5464}
5465
5466type OxmIdEthSrcMasked struct {
5467 *OxmId
5468}
5469
5470type IOxmIdEthSrcMasked interface {
5471 IOxmId
5472}
5473
5474func (self *OxmIdEthSrcMasked) Serialize(encoder *goloxi.Encoder) error {
5475 if err := self.OxmId.Serialize(encoder); err != nil {
5476 return err
5477 }
5478
5479 return nil
5480}
5481
5482func DecodeOxmIdEthSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthSrcMasked, error) {
5483 _oxmidethsrcmasked := &OxmIdEthSrcMasked{OxmId: parent}
5484 return _oxmidethsrcmasked, nil
5485}
5486
5487func NewOxmIdEthSrcMasked() *OxmIdEthSrcMasked {
5488 obj := &OxmIdEthSrcMasked{
5489 OxmId: NewOxmId(1286),
5490 }
5491 return obj
5492}
5493func (self *OxmIdEthSrcMasked) GetOXMName() string {
5494 return "eth_src_masked"
5495}
5496
5497func (self *OxmIdEthSrcMasked) MarshalJSON() ([]byte, error) {
5498 if self.TypeLen == 0 {
5499 return []byte("\"\""), nil
5500 } else {
5501 return []byte("\"" + self.GetOXMName() + "\""), nil
5502 }
5503}
5504
5505type OxmIdEthType struct {
5506 *OxmId
5507}
5508
5509type IOxmIdEthType interface {
5510 IOxmId
5511}
5512
5513func (self *OxmIdEthType) Serialize(encoder *goloxi.Encoder) error {
5514 if err := self.OxmId.Serialize(encoder); err != nil {
5515 return err
5516 }
5517
5518 return nil
5519}
5520
5521func DecodeOxmIdEthType(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthType, error) {
5522 _oxmidethtype := &OxmIdEthType{OxmId: parent}
5523 return _oxmidethtype, nil
5524}
5525
5526func NewOxmIdEthType() *OxmIdEthType {
5527 obj := &OxmIdEthType{
5528 OxmId: NewOxmId(1538),
5529 }
5530 return obj
5531}
5532func (self *OxmIdEthType) GetOXMName() string {
5533 return "eth_type"
5534}
5535
5536func (self *OxmIdEthType) MarshalJSON() ([]byte, error) {
5537 if self.TypeLen == 0 {
5538 return []byte("\"\""), nil
5539 } else {
5540 return []byte("\"" + self.GetOXMName() + "\""), nil
5541 }
5542}
5543
5544type OxmIdIcmpCode struct {
5545 *OxmId
5546}
5547
5548type IOxmIdIcmpCode interface {
5549 IOxmId
5550}
5551
5552func (self *OxmIdIcmpCode) Serialize(encoder *goloxi.Encoder) error {
5553 if err := self.OxmId.Serialize(encoder); err != nil {
5554 return err
5555 }
5556
5557 return nil
5558}
5559
5560func DecodeOxmIdIcmpCode(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpCode, error) {
5561 _oxmidicmpcode := &OxmIdIcmpCode{OxmId: parent}
5562 return _oxmidicmpcode, nil
5563}
5564
5565func NewOxmIdIcmpCode() *OxmIdIcmpCode {
5566 obj := &OxmIdIcmpCode{
5567 OxmId: NewOxmId(7169),
5568 }
5569 return obj
5570}
5571func (self *OxmIdIcmpCode) GetOXMName() string {
5572 return "icmp_code"
5573}
5574
5575func (self *OxmIdIcmpCode) MarshalJSON() ([]byte, error) {
5576 if self.TypeLen == 0 {
5577 return []byte("\"\""), nil
5578 } else {
5579 return []byte("\"" + self.GetOXMName() + "\""), nil
5580 }
5581}
5582
5583type OxmIdIcmpType struct {
5584 *OxmId
5585}
5586
5587type IOxmIdIcmpType interface {
5588 IOxmId
5589}
5590
5591func (self *OxmIdIcmpType) Serialize(encoder *goloxi.Encoder) error {
5592 if err := self.OxmId.Serialize(encoder); err != nil {
5593 return err
5594 }
5595
5596 return nil
5597}
5598
5599func DecodeOxmIdIcmpType(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpType, error) {
5600 _oxmidicmptype := &OxmIdIcmpType{OxmId: parent}
5601 return _oxmidicmptype, nil
5602}
5603
5604func NewOxmIdIcmpType() *OxmIdIcmpType {
5605 obj := &OxmIdIcmpType{
5606 OxmId: NewOxmId(6657),
5607 }
5608 return obj
5609}
5610func (self *OxmIdIcmpType) GetOXMName() string {
5611 return "icmp_type"
5612}
5613
5614func (self *OxmIdIcmpType) MarshalJSON() ([]byte, error) {
5615 if self.TypeLen == 0 {
5616 return []byte("\"\""), nil
5617 } else {
5618 return []byte("\"" + self.GetOXMName() + "\""), nil
5619 }
5620}
5621
5622type OxmIdIcmpv6Code struct {
5623 *OxmId
5624}
5625
5626type IOxmIdIcmpv6Code interface {
5627 IOxmId
5628}
5629
5630func (self *OxmIdIcmpv6Code) Serialize(encoder *goloxi.Encoder) error {
5631 if err := self.OxmId.Serialize(encoder); err != nil {
5632 return err
5633 }
5634
5635 return nil
5636}
5637
5638func DecodeOxmIdIcmpv6Code(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6Code, error) {
5639 _oxmidicmpv6code := &OxmIdIcmpv6Code{OxmId: parent}
5640 return _oxmidicmpv6code, nil
5641}
5642
5643func NewOxmIdIcmpv6Code() *OxmIdIcmpv6Code {
5644 obj := &OxmIdIcmpv6Code{
5645 OxmId: NewOxmId(76801),
5646 }
5647 return obj
5648}
5649func (self *OxmIdIcmpv6Code) GetOXMName() string {
5650 return "icmpv6_code"
5651}
5652
5653func (self *OxmIdIcmpv6Code) MarshalJSON() ([]byte, error) {
5654 if self.TypeLen == 0 {
5655 return []byte("\"\""), nil
5656 } else {
5657 return []byte("\"" + self.GetOXMName() + "\""), nil
5658 }
5659}
5660
5661type OxmIdIcmpv6Type struct {
5662 *OxmId
5663}
5664
5665type IOxmIdIcmpv6Type interface {
5666 IOxmId
5667}
5668
5669func (self *OxmIdIcmpv6Type) Serialize(encoder *goloxi.Encoder) error {
5670 if err := self.OxmId.Serialize(encoder); err != nil {
5671 return err
5672 }
5673
5674 return nil
5675}
5676
5677func DecodeOxmIdIcmpv6Type(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6Type, error) {
5678 _oxmidicmpv6type := &OxmIdIcmpv6Type{OxmId: parent}
5679 return _oxmidicmpv6type, nil
5680}
5681
5682func NewOxmIdIcmpv6Type() *OxmIdIcmpv6Type {
5683 obj := &OxmIdIcmpv6Type{
5684 OxmId: NewOxmId(76289),
5685 }
5686 return obj
5687}
5688func (self *OxmIdIcmpv6Type) GetOXMName() string {
5689 return "icmpv6_type"
5690}
5691
5692func (self *OxmIdIcmpv6Type) MarshalJSON() ([]byte, error) {
5693 if self.TypeLen == 0 {
5694 return []byte("\"\""), nil
5695 } else {
5696 return []byte("\"" + self.GetOXMName() + "\""), nil
5697 }
5698}
5699
5700type OxmIdInPort struct {
5701 *OxmId
5702}
5703
5704type IOxmIdInPort interface {
5705 IOxmId
5706}
5707
5708func (self *OxmIdInPort) Serialize(encoder *goloxi.Encoder) error {
5709 if err := self.OxmId.Serialize(encoder); err != nil {
5710 return err
5711 }
5712
5713 return nil
5714}
5715
5716func DecodeOxmIdInPort(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPort, error) {
5717 _oxmidinport := &OxmIdInPort{OxmId: parent}
5718 return _oxmidinport, nil
5719}
5720
5721func NewOxmIdInPort() *OxmIdInPort {
5722 obj := &OxmIdInPort{
5723 OxmId: NewOxmId(2),
5724 }
5725 return obj
5726}
5727func (self *OxmIdInPort) GetOXMName() string {
5728 return "in_port"
5729}
5730
5731func (self *OxmIdInPort) MarshalJSON() ([]byte, error) {
5732 if self.TypeLen == 0 {
5733 return []byte("\"\""), nil
5734 } else {
5735 return []byte("\"" + self.GetOXMName() + "\""), nil
5736 }
5737}
5738
5739type OxmIdIpDst struct {
5740 *OxmId
5741}
5742
5743type IOxmIdIpDst interface {
5744 IOxmId
5745}
5746
5747func (self *OxmIdIpDst) Serialize(encoder *goloxi.Encoder) error {
5748 if err := self.OxmId.Serialize(encoder); err != nil {
5749 return err
5750 }
5751
5752 return nil
5753}
5754
5755func DecodeOxmIdIpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDst, error) {
5756 _oxmidipdst := &OxmIdIpDst{OxmId: parent}
5757 return _oxmidipdst, nil
5758}
5759
5760func NewOxmIdIpDst() *OxmIdIpDst {
5761 obj := &OxmIdIpDst{
5762 OxmId: NewOxmId(4100),
5763 }
5764 return obj
5765}
5766func (self *OxmIdIpDst) GetOXMName() string {
5767 return "ip_dst"
5768}
5769
5770func (self *OxmIdIpDst) MarshalJSON() ([]byte, error) {
5771 if self.TypeLen == 0 {
5772 return []byte("\"\""), nil
5773 } else {
5774 return []byte("\"" + self.GetOXMName() + "\""), nil
5775 }
5776}
5777
5778type OxmIdIpDstMasked struct {
5779 *OxmId
5780}
5781
5782type IOxmIdIpDstMasked interface {
5783 IOxmId
5784}
5785
5786func (self *OxmIdIpDstMasked) Serialize(encoder *goloxi.Encoder) error {
5787 if err := self.OxmId.Serialize(encoder); err != nil {
5788 return err
5789 }
5790
5791 return nil
5792}
5793
5794func DecodeOxmIdIpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDstMasked, error) {
5795 _oxmidipdstmasked := &OxmIdIpDstMasked{OxmId: parent}
5796 return _oxmidipdstmasked, nil
5797}
5798
5799func NewOxmIdIpDstMasked() *OxmIdIpDstMasked {
5800 obj := &OxmIdIpDstMasked{
5801 OxmId: NewOxmId(4360),
5802 }
5803 return obj
5804}
5805func (self *OxmIdIpDstMasked) GetOXMName() string {
5806 return "ip_dst_masked"
5807}
5808
5809func (self *OxmIdIpDstMasked) MarshalJSON() ([]byte, error) {
5810 if self.TypeLen == 0 {
5811 return []byte("\"\""), nil
5812 } else {
5813 return []byte("\"" + self.GetOXMName() + "\""), nil
5814 }
5815}
5816
5817type OxmIdIpFrag struct {
5818 *OxmId
5819}
5820
5821type IOxmIdIpFrag interface {
5822 IOxmId
5823}
5824
5825func (self *OxmIdIpFrag) Serialize(encoder *goloxi.Encoder) error {
5826 if err := self.OxmId.Serialize(encoder); err != nil {
5827 return err
5828 }
5829
5830 return nil
5831}
5832
5833func DecodeOxmIdIpFrag(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpFrag, error) {
5834 _oxmidipfrag := &OxmIdIpFrag{OxmId: parent}
5835 return _oxmidipfrag, nil
5836}
5837
5838func NewOxmIdIpFrag() *OxmIdIpFrag {
5839 obj := &OxmIdIpFrag{
5840 OxmId: NewOxmId(78849),
5841 }
5842 return obj
5843}
5844func (self *OxmIdIpFrag) GetOXMName() string {
5845 return "ip_frag"
5846}
5847
5848func (self *OxmIdIpFrag) MarshalJSON() ([]byte, error) {
5849 if self.TypeLen == 0 {
5850 return []byte("\"\""), nil
5851 } else {
5852 return []byte("\"" + self.GetOXMName() + "\""), nil
5853 }
5854}
5855
5856type OxmIdIpFragMasked struct {
5857 *OxmId
5858}
5859
5860type IOxmIdIpFragMasked interface {
5861 IOxmId
5862}
5863
5864func (self *OxmIdIpFragMasked) Serialize(encoder *goloxi.Encoder) error {
5865 if err := self.OxmId.Serialize(encoder); err != nil {
5866 return err
5867 }
5868
5869 return nil
5870}
5871
5872func DecodeOxmIdIpFragMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpFragMasked, error) {
5873 _oxmidipfragmasked := &OxmIdIpFragMasked{OxmId: parent}
5874 return _oxmidipfragmasked, nil
5875}
5876
5877func NewOxmIdIpFragMasked() *OxmIdIpFragMasked {
5878 obj := &OxmIdIpFragMasked{
5879 OxmId: NewOxmId(79106),
5880 }
5881 return obj
5882}
5883func (self *OxmIdIpFragMasked) GetOXMName() string {
5884 return "ip_frag_masked"
5885}
5886
5887func (self *OxmIdIpFragMasked) MarshalJSON() ([]byte, error) {
5888 if self.TypeLen == 0 {
5889 return []byte("\"\""), nil
5890 } else {
5891 return []byte("\"" + self.GetOXMName() + "\""), nil
5892 }
5893}
5894
5895type OxmIdIpSrc struct {
5896 *OxmId
5897}
5898
5899type IOxmIdIpSrc interface {
5900 IOxmId
5901}
5902
5903func (self *OxmIdIpSrc) Serialize(encoder *goloxi.Encoder) error {
5904 if err := self.OxmId.Serialize(encoder); err != nil {
5905 return err
5906 }
5907
5908 return nil
5909}
5910
5911func DecodeOxmIdIpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpSrc, error) {
5912 _oxmidipsrc := &OxmIdIpSrc{OxmId: parent}
5913 return _oxmidipsrc, nil
5914}
5915
5916func NewOxmIdIpSrc() *OxmIdIpSrc {
5917 obj := &OxmIdIpSrc{
5918 OxmId: NewOxmId(3588),
5919 }
5920 return obj
5921}
5922func (self *OxmIdIpSrc) GetOXMName() string {
5923 return "ip_src"
5924}
5925
5926func (self *OxmIdIpSrc) MarshalJSON() ([]byte, error) {
5927 if self.TypeLen == 0 {
5928 return []byte("\"\""), nil
5929 } else {
5930 return []byte("\"" + self.GetOXMName() + "\""), nil
5931 }
5932}
5933
5934type OxmIdIpSrcMasked struct {
5935 *OxmId
5936}
5937
5938type IOxmIdIpSrcMasked interface {
5939 IOxmId
5940}
5941
5942func (self *OxmIdIpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
5943 if err := self.OxmId.Serialize(encoder); err != nil {
5944 return err
5945 }
5946
5947 return nil
5948}
5949
5950func DecodeOxmIdIpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpSrcMasked, error) {
5951 _oxmidipsrcmasked := &OxmIdIpSrcMasked{OxmId: parent}
5952 return _oxmidipsrcmasked, nil
5953}
5954
5955func NewOxmIdIpSrcMasked() *OxmIdIpSrcMasked {
5956 obj := &OxmIdIpSrcMasked{
5957 OxmId: NewOxmId(3848),
5958 }
5959 return obj
5960}
5961func (self *OxmIdIpSrcMasked) GetOXMName() string {
5962 return "ip_src_masked"
5963}
5964
5965func (self *OxmIdIpSrcMasked) MarshalJSON() ([]byte, error) {
5966 if self.TypeLen == 0 {
5967 return []byte("\"\""), nil
5968 } else {
5969 return []byte("\"" + self.GetOXMName() + "\""), nil
5970 }
5971}
5972
5973type OxmIdIpv6Dst struct {
5974 *OxmId
5975}
5976
5977type IOxmIdIpv6Dst interface {
5978 IOxmId
5979}
5980
5981func (self *OxmIdIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
5982 if err := self.OxmId.Serialize(encoder); err != nil {
5983 return err
5984 }
5985
5986 return nil
5987}
5988
5989func DecodeOxmIdIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Dst, error) {
5990 _oxmidipv6dst := &OxmIdIpv6Dst{OxmId: parent}
5991 return _oxmidipv6dst, nil
5992}
5993
5994func NewOxmIdIpv6Dst() *OxmIdIpv6Dst {
5995 obj := &OxmIdIpv6Dst{
5996 OxmId: NewOxmId(75792),
5997 }
5998 return obj
5999}
6000func (self *OxmIdIpv6Dst) GetOXMName() string {
6001 return "ipv6_dst"
6002}
6003
6004func (self *OxmIdIpv6Dst) MarshalJSON() ([]byte, error) {
6005 if self.TypeLen == 0 {
6006 return []byte("\"\""), nil
6007 } else {
6008 return []byte("\"" + self.GetOXMName() + "\""), nil
6009 }
6010}
6011
6012type OxmIdIpv6DstMasked struct {
6013 *OxmId
6014}
6015
6016type IOxmIdIpv6DstMasked interface {
6017 IOxmId
6018}
6019
6020func (self *OxmIdIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
6021 if err := self.OxmId.Serialize(encoder); err != nil {
6022 return err
6023 }
6024
6025 return nil
6026}
6027
6028func DecodeOxmIdIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6DstMasked, error) {
6029 _oxmidipv6dstmasked := &OxmIdIpv6DstMasked{OxmId: parent}
6030 return _oxmidipv6dstmasked, nil
6031}
6032
6033func NewOxmIdIpv6DstMasked() *OxmIdIpv6DstMasked {
6034 obj := &OxmIdIpv6DstMasked{
6035 OxmId: NewOxmId(76064),
6036 }
6037 return obj
6038}
6039func (self *OxmIdIpv6DstMasked) GetOXMName() string {
6040 return "ipv6_dst_masked"
6041}
6042
6043func (self *OxmIdIpv6DstMasked) MarshalJSON() ([]byte, error) {
6044 if self.TypeLen == 0 {
6045 return []byte("\"\""), nil
6046 } else {
6047 return []byte("\"" + self.GetOXMName() + "\""), nil
6048 }
6049}
6050
6051type OxmIdIpv6Label struct {
6052 *OxmId
6053}
6054
6055type IOxmIdIpv6Label interface {
6056 IOxmId
6057}
6058
6059func (self *OxmIdIpv6Label) Serialize(encoder *goloxi.Encoder) error {
6060 if err := self.OxmId.Serialize(encoder); err != nil {
6061 return err
6062 }
6063
6064 return nil
6065}
6066
6067func DecodeOxmIdIpv6Label(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Label, error) {
6068 _oxmidipv6label := &OxmIdIpv6Label{OxmId: parent}
6069 return _oxmidipv6label, nil
6070}
6071
6072func NewOxmIdIpv6Label() *OxmIdIpv6Label {
6073 obj := &OxmIdIpv6Label{
6074 OxmId: NewOxmId(79364),
6075 }
6076 return obj
6077}
6078func (self *OxmIdIpv6Label) GetOXMName() string {
6079 return "ipv6_label"
6080}
6081
6082func (self *OxmIdIpv6Label) MarshalJSON() ([]byte, error) {
6083 if self.TypeLen == 0 {
6084 return []byte("\"\""), nil
6085 } else {
6086 return []byte("\"" + self.GetOXMName() + "\""), nil
6087 }
6088}
6089
6090type OxmIdIpv6LabelMasked struct {
6091 *OxmId
6092}
6093
6094type IOxmIdIpv6LabelMasked interface {
6095 IOxmId
6096}
6097
6098func (self *OxmIdIpv6LabelMasked) Serialize(encoder *goloxi.Encoder) error {
6099 if err := self.OxmId.Serialize(encoder); err != nil {
6100 return err
6101 }
6102
6103 return nil
6104}
6105
6106func DecodeOxmIdIpv6LabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6LabelMasked, error) {
6107 _oxmidipv6labelmasked := &OxmIdIpv6LabelMasked{OxmId: parent}
6108 return _oxmidipv6labelmasked, nil
6109}
6110
6111func NewOxmIdIpv6LabelMasked() *OxmIdIpv6LabelMasked {
6112 obj := &OxmIdIpv6LabelMasked{
6113 OxmId: NewOxmId(79624),
6114 }
6115 return obj
6116}
6117func (self *OxmIdIpv6LabelMasked) GetOXMName() string {
6118 return "ipv6_label_masked"
6119}
6120
6121func (self *OxmIdIpv6LabelMasked) MarshalJSON() ([]byte, error) {
6122 if self.TypeLen == 0 {
6123 return []byte("\"\""), nil
6124 } else {
6125 return []byte("\"" + self.GetOXMName() + "\""), nil
6126 }
6127}
6128
6129type OxmIdIpv6Src struct {
6130 *OxmId
6131}
6132
6133type IOxmIdIpv6Src interface {
6134 IOxmId
6135}
6136
6137func (self *OxmIdIpv6Src) Serialize(encoder *goloxi.Encoder) error {
6138 if err := self.OxmId.Serialize(encoder); err != nil {
6139 return err
6140 }
6141
6142 return nil
6143}
6144
6145func DecodeOxmIdIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Src, error) {
6146 _oxmidipv6src := &OxmIdIpv6Src{OxmId: parent}
6147 return _oxmidipv6src, nil
6148}
6149
6150func NewOxmIdIpv6Src() *OxmIdIpv6Src {
6151 obj := &OxmIdIpv6Src{
6152 OxmId: NewOxmId(75280),
6153 }
6154 return obj
6155}
6156func (self *OxmIdIpv6Src) GetOXMName() string {
6157 return "ipv6_src"
6158}
6159
6160func (self *OxmIdIpv6Src) MarshalJSON() ([]byte, error) {
6161 if self.TypeLen == 0 {
6162 return []byte("\"\""), nil
6163 } else {
6164 return []byte("\"" + self.GetOXMName() + "\""), nil
6165 }
6166}
6167
6168type OxmIdIpv6SrcMasked struct {
6169 *OxmId
6170}
6171
6172type IOxmIdIpv6SrcMasked interface {
6173 IOxmId
6174}
6175
6176func (self *OxmIdIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
6177 if err := self.OxmId.Serialize(encoder); err != nil {
6178 return err
6179 }
6180
6181 return nil
6182}
6183
6184func DecodeOxmIdIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6SrcMasked, error) {
6185 _oxmidipv6srcmasked := &OxmIdIpv6SrcMasked{OxmId: parent}
6186 return _oxmidipv6srcmasked, nil
6187}
6188
6189func NewOxmIdIpv6SrcMasked() *OxmIdIpv6SrcMasked {
6190 obj := &OxmIdIpv6SrcMasked{
6191 OxmId: NewOxmId(75552),
6192 }
6193 return obj
6194}
6195func (self *OxmIdIpv6SrcMasked) GetOXMName() string {
6196 return "ipv6_src_masked"
6197}
6198
6199func (self *OxmIdIpv6SrcMasked) MarshalJSON() ([]byte, error) {
6200 if self.TypeLen == 0 {
6201 return []byte("\"\""), nil
6202 } else {
6203 return []byte("\"" + self.GetOXMName() + "\""), nil
6204 }
6205}
6206
6207type OxmIdMplsTtl struct {
6208 *OxmId
6209}
6210
6211type IOxmIdMplsTtl interface {
6212 IOxmId
6213}
6214
6215func (self *OxmIdMplsTtl) Serialize(encoder *goloxi.Encoder) error {
6216 if err := self.OxmId.Serialize(encoder); err != nil {
6217 return err
6218 }
6219
6220 return nil
6221}
6222
6223func DecodeOxmIdMplsTtl(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsTtl, error) {
6224 _oxmidmplsttl := &OxmIdMplsTtl{OxmId: parent}
6225 return _oxmidmplsttl, nil
6226}
6227
6228func NewOxmIdMplsTtl() *OxmIdMplsTtl {
6229 obj := &OxmIdMplsTtl{
6230 OxmId: NewOxmId(80897),
6231 }
6232 return obj
6233}
6234func (self *OxmIdMplsTtl) GetOXMName() string {
6235 return "mpls_ttl"
6236}
6237
6238func (self *OxmIdMplsTtl) MarshalJSON() ([]byte, error) {
6239 if self.TypeLen == 0 {
6240 return []byte("\"\""), nil
6241 } else {
6242 return []byte("\"" + self.GetOXMName() + "\""), nil
6243 }
6244}
6245
6246type OxmIdNdSll struct {
6247 *OxmId
6248}
6249
6250type IOxmIdNdSll interface {
6251 IOxmId
6252}
6253
6254func (self *OxmIdNdSll) Serialize(encoder *goloxi.Encoder) error {
6255 if err := self.OxmId.Serialize(encoder); err != nil {
6256 return err
6257 }
6258
6259 return nil
6260}
6261
6262func DecodeOxmIdNdSll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdSll, error) {
6263 _oxmidndsll := &OxmIdNdSll{OxmId: parent}
6264 return _oxmidndsll, nil
6265}
6266
6267func NewOxmIdNdSll() *OxmIdNdSll {
6268 obj := &OxmIdNdSll{
6269 OxmId: NewOxmId(77830),
6270 }
6271 return obj
6272}
6273func (self *OxmIdNdSll) GetOXMName() string {
6274 return "nd_sll"
6275}
6276
6277func (self *OxmIdNdSll) MarshalJSON() ([]byte, error) {
6278 if self.TypeLen == 0 {
6279 return []byte("\"\""), nil
6280 } else {
6281 return []byte("\"" + self.GetOXMName() + "\""), nil
6282 }
6283}
6284
6285type OxmIdNdSllMasked struct {
6286 *OxmId
6287}
6288
6289type IOxmIdNdSllMasked interface {
6290 IOxmId
6291}
6292
6293func (self *OxmIdNdSllMasked) Serialize(encoder *goloxi.Encoder) error {
6294 if err := self.OxmId.Serialize(encoder); err != nil {
6295 return err
6296 }
6297
6298 return nil
6299}
6300
6301func DecodeOxmIdNdSllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdSllMasked, error) {
6302 _oxmidndsllmasked := &OxmIdNdSllMasked{OxmId: parent}
6303 return _oxmidndsllmasked, nil
6304}
6305
6306func NewOxmIdNdSllMasked() *OxmIdNdSllMasked {
6307 obj := &OxmIdNdSllMasked{
6308 OxmId: NewOxmId(78091),
6309 }
6310 return obj
6311}
6312func (self *OxmIdNdSllMasked) GetOXMName() string {
6313 return "nd_sll_masked"
6314}
6315
6316func (self *OxmIdNdSllMasked) MarshalJSON() ([]byte, error) {
6317 if self.TypeLen == 0 {
6318 return []byte("\"\""), nil
6319 } else {
6320 return []byte("\"" + self.GetOXMName() + "\""), nil
6321 }
6322}
6323
6324type OxmIdNdTarget struct {
6325 *OxmId
6326}
6327
6328type IOxmIdNdTarget interface {
6329 IOxmId
6330}
6331
6332func (self *OxmIdNdTarget) Serialize(encoder *goloxi.Encoder) error {
6333 if err := self.OxmId.Serialize(encoder); err != nil {
6334 return err
6335 }
6336
6337 return nil
6338}
6339
6340func DecodeOxmIdNdTarget(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTarget, error) {
6341 _oxmidndtarget := &OxmIdNdTarget{OxmId: parent}
6342 return _oxmidndtarget, nil
6343}
6344
6345func NewOxmIdNdTarget() *OxmIdNdTarget {
6346 obj := &OxmIdNdTarget{
6347 OxmId: NewOxmId(77328),
6348 }
6349 return obj
6350}
6351func (self *OxmIdNdTarget) GetOXMName() string {
6352 return "nd_target"
6353}
6354
6355func (self *OxmIdNdTarget) MarshalJSON() ([]byte, error) {
6356 if self.TypeLen == 0 {
6357 return []byte("\"\""), nil
6358 } else {
6359 return []byte("\"" + self.GetOXMName() + "\""), nil
6360 }
6361}
6362
6363type OxmIdNdTargetMasked struct {
6364 *OxmId
6365}
6366
6367type IOxmIdNdTargetMasked interface {
6368 IOxmId
6369}
6370
6371func (self *OxmIdNdTargetMasked) Serialize(encoder *goloxi.Encoder) error {
6372 if err := self.OxmId.Serialize(encoder); err != nil {
6373 return err
6374 }
6375
6376 return nil
6377}
6378
6379func DecodeOxmIdNdTargetMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTargetMasked, error) {
6380 _oxmidndtargetmasked := &OxmIdNdTargetMasked{OxmId: parent}
6381 return _oxmidndtargetmasked, nil
6382}
6383
6384func NewOxmIdNdTargetMasked() *OxmIdNdTargetMasked {
6385 obj := &OxmIdNdTargetMasked{
6386 OxmId: NewOxmId(77600),
6387 }
6388 return obj
6389}
6390func (self *OxmIdNdTargetMasked) GetOXMName() string {
6391 return "nd_target_masked"
6392}
6393
6394func (self *OxmIdNdTargetMasked) MarshalJSON() ([]byte, error) {
6395 if self.TypeLen == 0 {
6396 return []byte("\"\""), nil
6397 } else {
6398 return []byte("\"" + self.GetOXMName() + "\""), nil
6399 }
6400}
6401
6402type OxmIdNdTll struct {
6403 *OxmId
6404}
6405
6406type IOxmIdNdTll interface {
6407 IOxmId
6408}
6409
6410func (self *OxmIdNdTll) Serialize(encoder *goloxi.Encoder) error {
6411 if err := self.OxmId.Serialize(encoder); err != nil {
6412 return err
6413 }
6414
6415 return nil
6416}
6417
6418func DecodeOxmIdNdTll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTll, error) {
6419 _oxmidndtll := &OxmIdNdTll{OxmId: parent}
6420 return _oxmidndtll, nil
6421}
6422
6423func NewOxmIdNdTll() *OxmIdNdTll {
6424 obj := &OxmIdNdTll{
6425 OxmId: NewOxmId(78342),
6426 }
6427 return obj
6428}
6429func (self *OxmIdNdTll) GetOXMName() string {
6430 return "nd_tll"
6431}
6432
6433func (self *OxmIdNdTll) MarshalJSON() ([]byte, error) {
6434 if self.TypeLen == 0 {
6435 return []byte("\"\""), nil
6436 } else {
6437 return []byte("\"" + self.GetOXMName() + "\""), nil
6438 }
6439}
6440
6441type OxmIdNdTllMasked struct {
6442 *OxmId
6443}
6444
6445type IOxmIdNdTllMasked interface {
6446 IOxmId
6447}
6448
6449func (self *OxmIdNdTllMasked) Serialize(encoder *goloxi.Encoder) error {
6450 if err := self.OxmId.Serialize(encoder); err != nil {
6451 return err
6452 }
6453
6454 return nil
6455}
6456
6457func DecodeOxmIdNdTllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTllMasked, error) {
6458 _oxmidndtllmasked := &OxmIdNdTllMasked{OxmId: parent}
6459 return _oxmidndtllmasked, nil
6460}
6461
6462func NewOxmIdNdTllMasked() *OxmIdNdTllMasked {
6463 obj := &OxmIdNdTllMasked{
6464 OxmId: NewOxmId(78603),
6465 }
6466 return obj
6467}
6468func (self *OxmIdNdTllMasked) GetOXMName() string {
6469 return "nd_tll_masked"
6470}
6471
6472func (self *OxmIdNdTllMasked) MarshalJSON() ([]byte, error) {
6473 if self.TypeLen == 0 {
6474 return []byte("\"\""), nil
6475 } else {
6476 return []byte("\"" + self.GetOXMName() + "\""), nil
6477 }
6478}
6479
6480type OxmIdNwEcn struct {
6481 *OxmId
6482}
6483
6484type IOxmIdNwEcn interface {
6485 IOxmId
6486}
6487
6488func (self *OxmIdNwEcn) Serialize(encoder *goloxi.Encoder) error {
6489 if err := self.OxmId.Serialize(encoder); err != nil {
6490 return err
6491 }
6492
6493 return nil
6494}
6495
6496func DecodeOxmIdNwEcn(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwEcn, error) {
6497 _oxmidnwecn := &OxmIdNwEcn{OxmId: parent}
6498 return _oxmidnwecn, nil
6499}
6500
6501func NewOxmIdNwEcn() *OxmIdNwEcn {
6502 obj := &OxmIdNwEcn{
6503 OxmId: NewOxmId(79873),
6504 }
6505 return obj
6506}
6507func (self *OxmIdNwEcn) GetOXMName() string {
6508 return "nw_ecn"
6509}
6510
6511func (self *OxmIdNwEcn) MarshalJSON() ([]byte, error) {
6512 if self.TypeLen == 0 {
6513 return []byte("\"\""), nil
6514 } else {
6515 return []byte("\"" + self.GetOXMName() + "\""), nil
6516 }
6517}
6518
6519type OxmIdNwProto struct {
6520 *OxmId
6521}
6522
6523type IOxmIdNwProto interface {
6524 IOxmId
6525}
6526
6527func (self *OxmIdNwProto) Serialize(encoder *goloxi.Encoder) error {
6528 if err := self.OxmId.Serialize(encoder); err != nil {
6529 return err
6530 }
6531
6532 return nil
6533}
6534
6535func DecodeOxmIdNwProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwProto, error) {
6536 _oxmidnwproto := &OxmIdNwProto{OxmId: parent}
6537 return _oxmidnwproto, nil
6538}
6539
6540func NewOxmIdNwProto() *OxmIdNwProto {
6541 obj := &OxmIdNwProto{
6542 OxmId: NewOxmId(3073),
6543 }
6544 return obj
6545}
6546func (self *OxmIdNwProto) GetOXMName() string {
6547 return "nw_proto"
6548}
6549
6550func (self *OxmIdNwProto) MarshalJSON() ([]byte, error) {
6551 if self.TypeLen == 0 {
6552 return []byte("\"\""), nil
6553 } else {
6554 return []byte("\"" + self.GetOXMName() + "\""), nil
6555 }
6556}
6557
6558type OxmIdNwTos struct {
6559 *OxmId
6560}
6561
6562type IOxmIdNwTos interface {
6563 IOxmId
6564}
6565
6566func (self *OxmIdNwTos) Serialize(encoder *goloxi.Encoder) error {
6567 if err := self.OxmId.Serialize(encoder); err != nil {
6568 return err
6569 }
6570
6571 return nil
6572}
6573
6574func DecodeOxmIdNwTos(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwTos, error) {
6575 _oxmidnwtos := &OxmIdNwTos{OxmId: parent}
6576 return _oxmidnwtos, nil
6577}
6578
6579func NewOxmIdNwTos() *OxmIdNwTos {
6580 obj := &OxmIdNwTos{
6581 OxmId: NewOxmId(2561),
6582 }
6583 return obj
6584}
6585func (self *OxmIdNwTos) GetOXMName() string {
6586 return "nw_tos"
6587}
6588
6589func (self *OxmIdNwTos) MarshalJSON() ([]byte, error) {
6590 if self.TypeLen == 0 {
6591 return []byte("\"\""), nil
6592 } else {
6593 return []byte("\"" + self.GetOXMName() + "\""), nil
6594 }
6595}
6596
6597type OxmIdNwTtl struct {
6598 *OxmId
6599}
6600
6601type IOxmIdNwTtl interface {
6602 IOxmId
6603}
6604
6605func (self *OxmIdNwTtl) Serialize(encoder *goloxi.Encoder) error {
6606 if err := self.OxmId.Serialize(encoder); err != nil {
6607 return err
6608 }
6609
6610 return nil
6611}
6612
6613func DecodeOxmIdNwTtl(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwTtl, error) {
6614 _oxmidnwttl := &OxmIdNwTtl{OxmId: parent}
6615 return _oxmidnwttl, nil
6616}
6617
6618func NewOxmIdNwTtl() *OxmIdNwTtl {
6619 obj := &OxmIdNwTtl{
6620 OxmId: NewOxmId(80385),
6621 }
6622 return obj
6623}
6624func (self *OxmIdNwTtl) GetOXMName() string {
6625 return "nw_ttl"
6626}
6627
6628func (self *OxmIdNwTtl) MarshalJSON() ([]byte, error) {
6629 if self.TypeLen == 0 {
6630 return []byte("\"\""), nil
6631 } else {
6632 return []byte("\"" + self.GetOXMName() + "\""), nil
6633 }
6634}
6635
6636type OxmIdPktMark struct {
6637 *OxmId
6638}
6639
6640type IOxmIdPktMark interface {
6641 IOxmId
6642}
6643
6644func (self *OxmIdPktMark) Serialize(encoder *goloxi.Encoder) error {
6645 if err := self.OxmId.Serialize(encoder); err != nil {
6646 return err
6647 }
6648
6649 return nil
6650}
6651
6652func DecodeOxmIdPktMark(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdPktMark, error) {
6653 _oxmidpktmark := &OxmIdPktMark{OxmId: parent}
6654 return _oxmidpktmark, nil
6655}
6656
6657func NewOxmIdPktMark() *OxmIdPktMark {
6658 obj := &OxmIdPktMark{
6659 OxmId: NewOxmId(82436),
6660 }
6661 return obj
6662}
6663func (self *OxmIdPktMark) GetOXMName() string {
6664 return "pkt_mark"
6665}
6666
6667func (self *OxmIdPktMark) MarshalJSON() ([]byte, error) {
6668 if self.TypeLen == 0 {
6669 return []byte("\"\""), nil
6670 } else {
6671 return []byte("\"" + self.GetOXMName() + "\""), nil
6672 }
6673}
6674
6675type OxmIdPktMarkMasked struct {
6676 *OxmId
6677}
6678
6679type IOxmIdPktMarkMasked interface {
6680 IOxmId
6681}
6682
6683func (self *OxmIdPktMarkMasked) Serialize(encoder *goloxi.Encoder) error {
6684 if err := self.OxmId.Serialize(encoder); err != nil {
6685 return err
6686 }
6687
6688 return nil
6689}
6690
6691func DecodeOxmIdPktMarkMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdPktMarkMasked, error) {
6692 _oxmidpktmarkmasked := &OxmIdPktMarkMasked{OxmId: parent}
6693 return _oxmidpktmarkmasked, nil
6694}
6695
6696func NewOxmIdPktMarkMasked() *OxmIdPktMarkMasked {
6697 obj := &OxmIdPktMarkMasked{
6698 OxmId: NewOxmId(82696),
6699 }
6700 return obj
6701}
6702func (self *OxmIdPktMarkMasked) GetOXMName() string {
6703 return "pkt_mark_masked"
6704}
6705
6706func (self *OxmIdPktMarkMasked) MarshalJSON() ([]byte, error) {
6707 if self.TypeLen == 0 {
6708 return []byte("\"\""), nil
6709 } else {
6710 return []byte("\"" + self.GetOXMName() + "\""), nil
6711 }
6712}
6713
6714type OxmIdRecircId struct {
6715 *OxmId
6716}
6717
6718type IOxmIdRecircId interface {
6719 IOxmId
6720}
6721
6722func (self *OxmIdRecircId) Serialize(encoder *goloxi.Encoder) error {
6723 if err := self.OxmId.Serialize(encoder); err != nil {
6724 return err
6725 }
6726
6727 return nil
6728}
6729
6730func DecodeOxmIdRecircId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdRecircId, error) {
6731 _oxmidrecircid := &OxmIdRecircId{OxmId: parent}
6732 return _oxmidrecircid, nil
6733}
6734
6735func NewOxmIdRecircId() *OxmIdRecircId {
6736 obj := &OxmIdRecircId{
6737 OxmId: NewOxmId(83972),
6738 }
6739 return obj
6740}
6741func (self *OxmIdRecircId) GetOXMName() string {
6742 return "recirc_id"
6743}
6744
6745func (self *OxmIdRecircId) MarshalJSON() ([]byte, error) {
6746 if self.TypeLen == 0 {
6747 return []byte("\"\""), nil
6748 } else {
6749 return []byte("\"" + self.GetOXMName() + "\""), nil
6750 }
6751}
6752
6753type OxmIdReg0 struct {
6754 *OxmId
6755}
6756
6757type IOxmIdReg0 interface {
6758 IOxmId
6759}
6760
6761func (self *OxmIdReg0) Serialize(encoder *goloxi.Encoder) error {
6762 if err := self.OxmId.Serialize(encoder); err != nil {
6763 return err
6764 }
6765
6766 return nil
6767}
6768
6769func DecodeOxmIdReg0(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg0, error) {
6770 _oxmidreg0 := &OxmIdReg0{OxmId: parent}
6771 return _oxmidreg0, nil
6772}
6773
6774func NewOxmIdReg0() *OxmIdReg0 {
6775 obj := &OxmIdReg0{
6776 OxmId: NewOxmId(65540),
6777 }
6778 return obj
6779}
6780func (self *OxmIdReg0) GetOXMName() string {
6781 return "reg0"
6782}
6783
6784func (self *OxmIdReg0) MarshalJSON() ([]byte, error) {
6785 if self.TypeLen == 0 {
6786 return []byte("\"\""), nil
6787 } else {
6788 return []byte("\"" + self.GetOXMName() + "\""), nil
6789 }
6790}
6791
6792type OxmIdReg0Masked struct {
6793 *OxmId
6794}
6795
6796type IOxmIdReg0Masked interface {
6797 IOxmId
6798}
6799
6800func (self *OxmIdReg0Masked) Serialize(encoder *goloxi.Encoder) error {
6801 if err := self.OxmId.Serialize(encoder); err != nil {
6802 return err
6803 }
6804
6805 return nil
6806}
6807
6808func DecodeOxmIdReg0Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg0Masked, error) {
6809 _oxmidreg0masked := &OxmIdReg0Masked{OxmId: parent}
6810 return _oxmidreg0masked, nil
6811}
6812
6813func NewOxmIdReg0Masked() *OxmIdReg0Masked {
6814 obj := &OxmIdReg0Masked{
6815 OxmId: NewOxmId(65800),
6816 }
6817 return obj
6818}
6819func (self *OxmIdReg0Masked) GetOXMName() string {
6820 return "reg0_masked"
6821}
6822
6823func (self *OxmIdReg0Masked) MarshalJSON() ([]byte, error) {
6824 if self.TypeLen == 0 {
6825 return []byte("\"\""), nil
6826 } else {
6827 return []byte("\"" + self.GetOXMName() + "\""), nil
6828 }
6829}
6830
6831type OxmIdReg1 struct {
6832 *OxmId
6833}
6834
6835type IOxmIdReg1 interface {
6836 IOxmId
6837}
6838
6839func (self *OxmIdReg1) Serialize(encoder *goloxi.Encoder) error {
6840 if err := self.OxmId.Serialize(encoder); err != nil {
6841 return err
6842 }
6843
6844 return nil
6845}
6846
6847func DecodeOxmIdReg1(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg1, error) {
6848 _oxmidreg1 := &OxmIdReg1{OxmId: parent}
6849 return _oxmidreg1, nil
6850}
6851
6852func NewOxmIdReg1() *OxmIdReg1 {
6853 obj := &OxmIdReg1{
6854 OxmId: NewOxmId(66052),
6855 }
6856 return obj
6857}
6858func (self *OxmIdReg1) GetOXMName() string {
6859 return "reg1"
6860}
6861
6862func (self *OxmIdReg1) MarshalJSON() ([]byte, error) {
6863 if self.TypeLen == 0 {
6864 return []byte("\"\""), nil
6865 } else {
6866 return []byte("\"" + self.GetOXMName() + "\""), nil
6867 }
6868}
6869
6870type OxmIdReg10 struct {
6871 *OxmId
6872}
6873
6874type IOxmIdReg10 interface {
6875 IOxmId
6876}
6877
6878func (self *OxmIdReg10) Serialize(encoder *goloxi.Encoder) error {
6879 if err := self.OxmId.Serialize(encoder); err != nil {
6880 return err
6881 }
6882
6883 return nil
6884}
6885
6886func DecodeOxmIdReg10(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg10, error) {
6887 _oxmidreg10 := &OxmIdReg10{OxmId: parent}
6888 return _oxmidreg10, nil
6889}
6890
6891func NewOxmIdReg10() *OxmIdReg10 {
6892 obj := &OxmIdReg10{
6893 OxmId: NewOxmId(70660),
6894 }
6895 return obj
6896}
6897func (self *OxmIdReg10) GetOXMName() string {
6898 return "reg10"
6899}
6900
6901func (self *OxmIdReg10) MarshalJSON() ([]byte, error) {
6902 if self.TypeLen == 0 {
6903 return []byte("\"\""), nil
6904 } else {
6905 return []byte("\"" + self.GetOXMName() + "\""), nil
6906 }
6907}
6908
6909type OxmIdReg10Masked struct {
6910 *OxmId
6911}
6912
6913type IOxmIdReg10Masked interface {
6914 IOxmId
6915}
6916
6917func (self *OxmIdReg10Masked) Serialize(encoder *goloxi.Encoder) error {
6918 if err := self.OxmId.Serialize(encoder); err != nil {
6919 return err
6920 }
6921
6922 return nil
6923}
6924
6925func DecodeOxmIdReg10Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg10Masked, error) {
6926 _oxmidreg10masked := &OxmIdReg10Masked{OxmId: parent}
6927 return _oxmidreg10masked, nil
6928}
6929
6930func NewOxmIdReg10Masked() *OxmIdReg10Masked {
6931 obj := &OxmIdReg10Masked{
6932 OxmId: NewOxmId(70920),
6933 }
6934 return obj
6935}
6936func (self *OxmIdReg10Masked) GetOXMName() string {
6937 return "reg10_masked"
6938}
6939
6940func (self *OxmIdReg10Masked) MarshalJSON() ([]byte, error) {
6941 if self.TypeLen == 0 {
6942 return []byte("\"\""), nil
6943 } else {
6944 return []byte("\"" + self.GetOXMName() + "\""), nil
6945 }
6946}
6947
6948type OxmIdReg11 struct {
6949 *OxmId
6950}
6951
6952type IOxmIdReg11 interface {
6953 IOxmId
6954}
6955
6956func (self *OxmIdReg11) Serialize(encoder *goloxi.Encoder) error {
6957 if err := self.OxmId.Serialize(encoder); err != nil {
6958 return err
6959 }
6960
6961 return nil
6962}
6963
6964func DecodeOxmIdReg11(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg11, error) {
6965 _oxmidreg11 := &OxmIdReg11{OxmId: parent}
6966 return _oxmidreg11, nil
6967}
6968
6969func NewOxmIdReg11() *OxmIdReg11 {
6970 obj := &OxmIdReg11{
6971 OxmId: NewOxmId(71172),
6972 }
6973 return obj
6974}
6975func (self *OxmIdReg11) GetOXMName() string {
6976 return "reg11"
6977}
6978
6979func (self *OxmIdReg11) MarshalJSON() ([]byte, error) {
6980 if self.TypeLen == 0 {
6981 return []byte("\"\""), nil
6982 } else {
6983 return []byte("\"" + self.GetOXMName() + "\""), nil
6984 }
6985}
6986
6987type OxmIdReg11Masked struct {
6988 *OxmId
6989}
6990
6991type IOxmIdReg11Masked interface {
6992 IOxmId
6993}
6994
6995func (self *OxmIdReg11Masked) Serialize(encoder *goloxi.Encoder) error {
6996 if err := self.OxmId.Serialize(encoder); err != nil {
6997 return err
6998 }
6999
7000 return nil
7001}
7002
7003func DecodeOxmIdReg11Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg11Masked, error) {
7004 _oxmidreg11masked := &OxmIdReg11Masked{OxmId: parent}
7005 return _oxmidreg11masked, nil
7006}
7007
7008func NewOxmIdReg11Masked() *OxmIdReg11Masked {
7009 obj := &OxmIdReg11Masked{
7010 OxmId: NewOxmId(71432),
7011 }
7012 return obj
7013}
7014func (self *OxmIdReg11Masked) GetOXMName() string {
7015 return "reg11_masked"
7016}
7017
7018func (self *OxmIdReg11Masked) MarshalJSON() ([]byte, error) {
7019 if self.TypeLen == 0 {
7020 return []byte("\"\""), nil
7021 } else {
7022 return []byte("\"" + self.GetOXMName() + "\""), nil
7023 }
7024}
7025
7026type OxmIdReg12 struct {
7027 *OxmId
7028}
7029
7030type IOxmIdReg12 interface {
7031 IOxmId
7032}
7033
7034func (self *OxmIdReg12) Serialize(encoder *goloxi.Encoder) error {
7035 if err := self.OxmId.Serialize(encoder); err != nil {
7036 return err
7037 }
7038
7039 return nil
7040}
7041
7042func DecodeOxmIdReg12(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg12, error) {
7043 _oxmidreg12 := &OxmIdReg12{OxmId: parent}
7044 return _oxmidreg12, nil
7045}
7046
7047func NewOxmIdReg12() *OxmIdReg12 {
7048 obj := &OxmIdReg12{
7049 OxmId: NewOxmId(71684),
7050 }
7051 return obj
7052}
7053func (self *OxmIdReg12) GetOXMName() string {
7054 return "reg12"
7055}
7056
7057func (self *OxmIdReg12) MarshalJSON() ([]byte, error) {
7058 if self.TypeLen == 0 {
7059 return []byte("\"\""), nil
7060 } else {
7061 return []byte("\"" + self.GetOXMName() + "\""), nil
7062 }
7063}
7064
7065type OxmIdReg12Masked struct {
7066 *OxmId
7067}
7068
7069type IOxmIdReg12Masked interface {
7070 IOxmId
7071}
7072
7073func (self *OxmIdReg12Masked) Serialize(encoder *goloxi.Encoder) error {
7074 if err := self.OxmId.Serialize(encoder); err != nil {
7075 return err
7076 }
7077
7078 return nil
7079}
7080
7081func DecodeOxmIdReg12Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg12Masked, error) {
7082 _oxmidreg12masked := &OxmIdReg12Masked{OxmId: parent}
7083 return _oxmidreg12masked, nil
7084}
7085
7086func NewOxmIdReg12Masked() *OxmIdReg12Masked {
7087 obj := &OxmIdReg12Masked{
7088 OxmId: NewOxmId(71944),
7089 }
7090 return obj
7091}
7092func (self *OxmIdReg12Masked) GetOXMName() string {
7093 return "reg12_masked"
7094}
7095
7096func (self *OxmIdReg12Masked) MarshalJSON() ([]byte, error) {
7097 if self.TypeLen == 0 {
7098 return []byte("\"\""), nil
7099 } else {
7100 return []byte("\"" + self.GetOXMName() + "\""), nil
7101 }
7102}
7103
7104type OxmIdReg13 struct {
7105 *OxmId
7106}
7107
7108type IOxmIdReg13 interface {
7109 IOxmId
7110}
7111
7112func (self *OxmIdReg13) Serialize(encoder *goloxi.Encoder) error {
7113 if err := self.OxmId.Serialize(encoder); err != nil {
7114 return err
7115 }
7116
7117 return nil
7118}
7119
7120func DecodeOxmIdReg13(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg13, error) {
7121 _oxmidreg13 := &OxmIdReg13{OxmId: parent}
7122 return _oxmidreg13, nil
7123}
7124
7125func NewOxmIdReg13() *OxmIdReg13 {
7126 obj := &OxmIdReg13{
7127 OxmId: NewOxmId(72196),
7128 }
7129 return obj
7130}
7131func (self *OxmIdReg13) GetOXMName() string {
7132 return "reg13"
7133}
7134
7135func (self *OxmIdReg13) MarshalJSON() ([]byte, error) {
7136 if self.TypeLen == 0 {
7137 return []byte("\"\""), nil
7138 } else {
7139 return []byte("\"" + self.GetOXMName() + "\""), nil
7140 }
7141}
7142
7143type OxmIdReg13Masked struct {
7144 *OxmId
7145}
7146
7147type IOxmIdReg13Masked interface {
7148 IOxmId
7149}
7150
7151func (self *OxmIdReg13Masked) Serialize(encoder *goloxi.Encoder) error {
7152 if err := self.OxmId.Serialize(encoder); err != nil {
7153 return err
7154 }
7155
7156 return nil
7157}
7158
7159func DecodeOxmIdReg13Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg13Masked, error) {
7160 _oxmidreg13masked := &OxmIdReg13Masked{OxmId: parent}
7161 return _oxmidreg13masked, nil
7162}
7163
7164func NewOxmIdReg13Masked() *OxmIdReg13Masked {
7165 obj := &OxmIdReg13Masked{
7166 OxmId: NewOxmId(72456),
7167 }
7168 return obj
7169}
7170func (self *OxmIdReg13Masked) GetOXMName() string {
7171 return "reg13_masked"
7172}
7173
7174func (self *OxmIdReg13Masked) MarshalJSON() ([]byte, error) {
7175 if self.TypeLen == 0 {
7176 return []byte("\"\""), nil
7177 } else {
7178 return []byte("\"" + self.GetOXMName() + "\""), nil
7179 }
7180}
7181
7182type OxmIdReg14 struct {
7183 *OxmId
7184}
7185
7186type IOxmIdReg14 interface {
7187 IOxmId
7188}
7189
7190func (self *OxmIdReg14) Serialize(encoder *goloxi.Encoder) error {
7191 if err := self.OxmId.Serialize(encoder); err != nil {
7192 return err
7193 }
7194
7195 return nil
7196}
7197
7198func DecodeOxmIdReg14(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg14, error) {
7199 _oxmidreg14 := &OxmIdReg14{OxmId: parent}
7200 return _oxmidreg14, nil
7201}
7202
7203func NewOxmIdReg14() *OxmIdReg14 {
7204 obj := &OxmIdReg14{
7205 OxmId: NewOxmId(72708),
7206 }
7207 return obj
7208}
7209func (self *OxmIdReg14) GetOXMName() string {
7210 return "reg14"
7211}
7212
7213func (self *OxmIdReg14) MarshalJSON() ([]byte, error) {
7214 if self.TypeLen == 0 {
7215 return []byte("\"\""), nil
7216 } else {
7217 return []byte("\"" + self.GetOXMName() + "\""), nil
7218 }
7219}
7220
7221type OxmIdReg14Masked struct {
7222 *OxmId
7223}
7224
7225type IOxmIdReg14Masked interface {
7226 IOxmId
7227}
7228
7229func (self *OxmIdReg14Masked) Serialize(encoder *goloxi.Encoder) error {
7230 if err := self.OxmId.Serialize(encoder); err != nil {
7231 return err
7232 }
7233
7234 return nil
7235}
7236
7237func DecodeOxmIdReg14Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg14Masked, error) {
7238 _oxmidreg14masked := &OxmIdReg14Masked{OxmId: parent}
7239 return _oxmidreg14masked, nil
7240}
7241
7242func NewOxmIdReg14Masked() *OxmIdReg14Masked {
7243 obj := &OxmIdReg14Masked{
7244 OxmId: NewOxmId(72968),
7245 }
7246 return obj
7247}
7248func (self *OxmIdReg14Masked) GetOXMName() string {
7249 return "reg14_masked"
7250}
7251
7252func (self *OxmIdReg14Masked) MarshalJSON() ([]byte, error) {
7253 if self.TypeLen == 0 {
7254 return []byte("\"\""), nil
7255 } else {
7256 return []byte("\"" + self.GetOXMName() + "\""), nil
7257 }
7258}
7259
7260type OxmIdReg15 struct {
7261 *OxmId
7262}
7263
7264type IOxmIdReg15 interface {
7265 IOxmId
7266}
7267
7268func (self *OxmIdReg15) Serialize(encoder *goloxi.Encoder) error {
7269 if err := self.OxmId.Serialize(encoder); err != nil {
7270 return err
7271 }
7272
7273 return nil
7274}
7275
7276func DecodeOxmIdReg15(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg15, error) {
7277 _oxmidreg15 := &OxmIdReg15{OxmId: parent}
7278 return _oxmidreg15, nil
7279}
7280
7281func NewOxmIdReg15() *OxmIdReg15 {
7282 obj := &OxmIdReg15{
7283 OxmId: NewOxmId(73220),
7284 }
7285 return obj
7286}
7287func (self *OxmIdReg15) GetOXMName() string {
7288 return "reg15"
7289}
7290
7291func (self *OxmIdReg15) MarshalJSON() ([]byte, error) {
7292 if self.TypeLen == 0 {
7293 return []byte("\"\""), nil
7294 } else {
7295 return []byte("\"" + self.GetOXMName() + "\""), nil
7296 }
7297}
7298
7299type OxmIdReg15Masked struct {
7300 *OxmId
7301}
7302
7303type IOxmIdReg15Masked interface {
7304 IOxmId
7305}
7306
7307func (self *OxmIdReg15Masked) Serialize(encoder *goloxi.Encoder) error {
7308 if err := self.OxmId.Serialize(encoder); err != nil {
7309 return err
7310 }
7311
7312 return nil
7313}
7314
7315func DecodeOxmIdReg15Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg15Masked, error) {
7316 _oxmidreg15masked := &OxmIdReg15Masked{OxmId: parent}
7317 return _oxmidreg15masked, nil
7318}
7319
7320func NewOxmIdReg15Masked() *OxmIdReg15Masked {
7321 obj := &OxmIdReg15Masked{
7322 OxmId: NewOxmId(73480),
7323 }
7324 return obj
7325}
7326func (self *OxmIdReg15Masked) GetOXMName() string {
7327 return "reg15_masked"
7328}
7329
7330func (self *OxmIdReg15Masked) MarshalJSON() ([]byte, error) {
7331 if self.TypeLen == 0 {
7332 return []byte("\"\""), nil
7333 } else {
7334 return []byte("\"" + self.GetOXMName() + "\""), nil
7335 }
7336}
7337
7338type OxmIdReg1Masked struct {
7339 *OxmId
7340}
7341
7342type IOxmIdReg1Masked interface {
7343 IOxmId
7344}
7345
7346func (self *OxmIdReg1Masked) Serialize(encoder *goloxi.Encoder) error {
7347 if err := self.OxmId.Serialize(encoder); err != nil {
7348 return err
7349 }
7350
7351 return nil
7352}
7353
7354func DecodeOxmIdReg1Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg1Masked, error) {
7355 _oxmidreg1masked := &OxmIdReg1Masked{OxmId: parent}
7356 return _oxmidreg1masked, nil
7357}
7358
7359func NewOxmIdReg1Masked() *OxmIdReg1Masked {
7360 obj := &OxmIdReg1Masked{
7361 OxmId: NewOxmId(66312),
7362 }
7363 return obj
7364}
7365func (self *OxmIdReg1Masked) GetOXMName() string {
7366 return "reg1_masked"
7367}
7368
7369func (self *OxmIdReg1Masked) MarshalJSON() ([]byte, error) {
7370 if self.TypeLen == 0 {
7371 return []byte("\"\""), nil
7372 } else {
7373 return []byte("\"" + self.GetOXMName() + "\""), nil
7374 }
7375}
7376
7377type OxmIdReg2 struct {
7378 *OxmId
7379}
7380
7381type IOxmIdReg2 interface {
7382 IOxmId
7383}
7384
7385func (self *OxmIdReg2) Serialize(encoder *goloxi.Encoder) error {
7386 if err := self.OxmId.Serialize(encoder); err != nil {
7387 return err
7388 }
7389
7390 return nil
7391}
7392
7393func DecodeOxmIdReg2(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg2, error) {
7394 _oxmidreg2 := &OxmIdReg2{OxmId: parent}
7395 return _oxmidreg2, nil
7396}
7397
7398func NewOxmIdReg2() *OxmIdReg2 {
7399 obj := &OxmIdReg2{
7400 OxmId: NewOxmId(66564),
7401 }
7402 return obj
7403}
7404func (self *OxmIdReg2) GetOXMName() string {
7405 return "reg2"
7406}
7407
7408func (self *OxmIdReg2) MarshalJSON() ([]byte, error) {
7409 if self.TypeLen == 0 {
7410 return []byte("\"\""), nil
7411 } else {
7412 return []byte("\"" + self.GetOXMName() + "\""), nil
7413 }
7414}
7415
7416type OxmIdReg2Masked struct {
7417 *OxmId
7418}
7419
7420type IOxmIdReg2Masked interface {
7421 IOxmId
7422}
7423
7424func (self *OxmIdReg2Masked) Serialize(encoder *goloxi.Encoder) error {
7425 if err := self.OxmId.Serialize(encoder); err != nil {
7426 return err
7427 }
7428
7429 return nil
7430}
7431
7432func DecodeOxmIdReg2Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg2Masked, error) {
7433 _oxmidreg2masked := &OxmIdReg2Masked{OxmId: parent}
7434 return _oxmidreg2masked, nil
7435}
7436
7437func NewOxmIdReg2Masked() *OxmIdReg2Masked {
7438 obj := &OxmIdReg2Masked{
7439 OxmId: NewOxmId(66824),
7440 }
7441 return obj
7442}
7443func (self *OxmIdReg2Masked) GetOXMName() string {
7444 return "reg2_masked"
7445}
7446
7447func (self *OxmIdReg2Masked) MarshalJSON() ([]byte, error) {
7448 if self.TypeLen == 0 {
7449 return []byte("\"\""), nil
7450 } else {
7451 return []byte("\"" + self.GetOXMName() + "\""), nil
7452 }
7453}
7454
7455type OxmIdReg3 struct {
7456 *OxmId
7457}
7458
7459type IOxmIdReg3 interface {
7460 IOxmId
7461}
7462
7463func (self *OxmIdReg3) Serialize(encoder *goloxi.Encoder) error {
7464 if err := self.OxmId.Serialize(encoder); err != nil {
7465 return err
7466 }
7467
7468 return nil
7469}
7470
7471func DecodeOxmIdReg3(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg3, error) {
7472 _oxmidreg3 := &OxmIdReg3{OxmId: parent}
7473 return _oxmidreg3, nil
7474}
7475
7476func NewOxmIdReg3() *OxmIdReg3 {
7477 obj := &OxmIdReg3{
7478 OxmId: NewOxmId(67076),
7479 }
7480 return obj
7481}
7482func (self *OxmIdReg3) GetOXMName() string {
7483 return "reg3"
7484}
7485
7486func (self *OxmIdReg3) MarshalJSON() ([]byte, error) {
7487 if self.TypeLen == 0 {
7488 return []byte("\"\""), nil
7489 } else {
7490 return []byte("\"" + self.GetOXMName() + "\""), nil
7491 }
7492}
7493
7494type OxmIdReg3Masked struct {
7495 *OxmId
7496}
7497
7498type IOxmIdReg3Masked interface {
7499 IOxmId
7500}
7501
7502func (self *OxmIdReg3Masked) Serialize(encoder *goloxi.Encoder) error {
7503 if err := self.OxmId.Serialize(encoder); err != nil {
7504 return err
7505 }
7506
7507 return nil
7508}
7509
7510func DecodeOxmIdReg3Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg3Masked, error) {
7511 _oxmidreg3masked := &OxmIdReg3Masked{OxmId: parent}
7512 return _oxmidreg3masked, nil
7513}
7514
7515func NewOxmIdReg3Masked() *OxmIdReg3Masked {
7516 obj := &OxmIdReg3Masked{
7517 OxmId: NewOxmId(67336),
7518 }
7519 return obj
7520}
7521func (self *OxmIdReg3Masked) GetOXMName() string {
7522 return "reg3_masked"
7523}
7524
7525func (self *OxmIdReg3Masked) MarshalJSON() ([]byte, error) {
7526 if self.TypeLen == 0 {
7527 return []byte("\"\""), nil
7528 } else {
7529 return []byte("\"" + self.GetOXMName() + "\""), nil
7530 }
7531}
7532
7533type OxmIdReg4 struct {
7534 *OxmId
7535}
7536
7537type IOxmIdReg4 interface {
7538 IOxmId
7539}
7540
7541func (self *OxmIdReg4) Serialize(encoder *goloxi.Encoder) error {
7542 if err := self.OxmId.Serialize(encoder); err != nil {
7543 return err
7544 }
7545
7546 return nil
7547}
7548
7549func DecodeOxmIdReg4(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg4, error) {
7550 _oxmidreg4 := &OxmIdReg4{OxmId: parent}
7551 return _oxmidreg4, nil
7552}
7553
7554func NewOxmIdReg4() *OxmIdReg4 {
7555 obj := &OxmIdReg4{
7556 OxmId: NewOxmId(67588),
7557 }
7558 return obj
7559}
7560func (self *OxmIdReg4) GetOXMName() string {
7561 return "reg4"
7562}
7563
7564func (self *OxmIdReg4) MarshalJSON() ([]byte, error) {
7565 if self.TypeLen == 0 {
7566 return []byte("\"\""), nil
7567 } else {
7568 return []byte("\"" + self.GetOXMName() + "\""), nil
7569 }
7570}
7571
7572type OxmIdReg4Masked struct {
7573 *OxmId
7574}
7575
7576type IOxmIdReg4Masked interface {
7577 IOxmId
7578}
7579
7580func (self *OxmIdReg4Masked) Serialize(encoder *goloxi.Encoder) error {
7581 if err := self.OxmId.Serialize(encoder); err != nil {
7582 return err
7583 }
7584
7585 return nil
7586}
7587
7588func DecodeOxmIdReg4Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg4Masked, error) {
7589 _oxmidreg4masked := &OxmIdReg4Masked{OxmId: parent}
7590 return _oxmidreg4masked, nil
7591}
7592
7593func NewOxmIdReg4Masked() *OxmIdReg4Masked {
7594 obj := &OxmIdReg4Masked{
7595 OxmId: NewOxmId(67848),
7596 }
7597 return obj
7598}
7599func (self *OxmIdReg4Masked) GetOXMName() string {
7600 return "reg4_masked"
7601}
7602
7603func (self *OxmIdReg4Masked) MarshalJSON() ([]byte, error) {
7604 if self.TypeLen == 0 {
7605 return []byte("\"\""), nil
7606 } else {
7607 return []byte("\"" + self.GetOXMName() + "\""), nil
7608 }
7609}
7610
7611type OxmIdReg5 struct {
7612 *OxmId
7613}
7614
7615type IOxmIdReg5 interface {
7616 IOxmId
7617}
7618
7619func (self *OxmIdReg5) Serialize(encoder *goloxi.Encoder) error {
7620 if err := self.OxmId.Serialize(encoder); err != nil {
7621 return err
7622 }
7623
7624 return nil
7625}
7626
7627func DecodeOxmIdReg5(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg5, error) {
7628 _oxmidreg5 := &OxmIdReg5{OxmId: parent}
7629 return _oxmidreg5, nil
7630}
7631
7632func NewOxmIdReg5() *OxmIdReg5 {
7633 obj := &OxmIdReg5{
7634 OxmId: NewOxmId(68100),
7635 }
7636 return obj
7637}
7638func (self *OxmIdReg5) GetOXMName() string {
7639 return "reg5"
7640}
7641
7642func (self *OxmIdReg5) MarshalJSON() ([]byte, error) {
7643 if self.TypeLen == 0 {
7644 return []byte("\"\""), nil
7645 } else {
7646 return []byte("\"" + self.GetOXMName() + "\""), nil
7647 }
7648}
7649
7650type OxmIdReg5Masked struct {
7651 *OxmId
7652}
7653
7654type IOxmIdReg5Masked interface {
7655 IOxmId
7656}
7657
7658func (self *OxmIdReg5Masked) Serialize(encoder *goloxi.Encoder) error {
7659 if err := self.OxmId.Serialize(encoder); err != nil {
7660 return err
7661 }
7662
7663 return nil
7664}
7665
7666func DecodeOxmIdReg5Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg5Masked, error) {
7667 _oxmidreg5masked := &OxmIdReg5Masked{OxmId: parent}
7668 return _oxmidreg5masked, nil
7669}
7670
7671func NewOxmIdReg5Masked() *OxmIdReg5Masked {
7672 obj := &OxmIdReg5Masked{
7673 OxmId: NewOxmId(68360),
7674 }
7675 return obj
7676}
7677func (self *OxmIdReg5Masked) GetOXMName() string {
7678 return "reg5_masked"
7679}
7680
7681func (self *OxmIdReg5Masked) MarshalJSON() ([]byte, error) {
7682 if self.TypeLen == 0 {
7683 return []byte("\"\""), nil
7684 } else {
7685 return []byte("\"" + self.GetOXMName() + "\""), nil
7686 }
7687}
7688
7689type OxmIdReg6 struct {
7690 *OxmId
7691}
7692
7693type IOxmIdReg6 interface {
7694 IOxmId
7695}
7696
7697func (self *OxmIdReg6) Serialize(encoder *goloxi.Encoder) error {
7698 if err := self.OxmId.Serialize(encoder); err != nil {
7699 return err
7700 }
7701
7702 return nil
7703}
7704
7705func DecodeOxmIdReg6(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg6, error) {
7706 _oxmidreg6 := &OxmIdReg6{OxmId: parent}
7707 return _oxmidreg6, nil
7708}
7709
7710func NewOxmIdReg6() *OxmIdReg6 {
7711 obj := &OxmIdReg6{
7712 OxmId: NewOxmId(68612),
7713 }
7714 return obj
7715}
7716func (self *OxmIdReg6) GetOXMName() string {
7717 return "reg6"
7718}
7719
7720func (self *OxmIdReg6) MarshalJSON() ([]byte, error) {
7721 if self.TypeLen == 0 {
7722 return []byte("\"\""), nil
7723 } else {
7724 return []byte("\"" + self.GetOXMName() + "\""), nil
7725 }
7726}
7727
7728type OxmIdReg6Masked struct {
7729 *OxmId
7730}
7731
7732type IOxmIdReg6Masked interface {
7733 IOxmId
7734}
7735
7736func (self *OxmIdReg6Masked) Serialize(encoder *goloxi.Encoder) error {
7737 if err := self.OxmId.Serialize(encoder); err != nil {
7738 return err
7739 }
7740
7741 return nil
7742}
7743
7744func DecodeOxmIdReg6Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg6Masked, error) {
7745 _oxmidreg6masked := &OxmIdReg6Masked{OxmId: parent}
7746 return _oxmidreg6masked, nil
7747}
7748
7749func NewOxmIdReg6Masked() *OxmIdReg6Masked {
7750 obj := &OxmIdReg6Masked{
7751 OxmId: NewOxmId(68872),
7752 }
7753 return obj
7754}
7755func (self *OxmIdReg6Masked) GetOXMName() string {
7756 return "reg6_masked"
7757}
7758
7759func (self *OxmIdReg6Masked) MarshalJSON() ([]byte, error) {
7760 if self.TypeLen == 0 {
7761 return []byte("\"\""), nil
7762 } else {
7763 return []byte("\"" + self.GetOXMName() + "\""), nil
7764 }
7765}
7766
7767type OxmIdReg7 struct {
7768 *OxmId
7769}
7770
7771type IOxmIdReg7 interface {
7772 IOxmId
7773}
7774
7775func (self *OxmIdReg7) Serialize(encoder *goloxi.Encoder) error {
7776 if err := self.OxmId.Serialize(encoder); err != nil {
7777 return err
7778 }
7779
7780 return nil
7781}
7782
7783func DecodeOxmIdReg7(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg7, error) {
7784 _oxmidreg7 := &OxmIdReg7{OxmId: parent}
7785 return _oxmidreg7, nil
7786}
7787
7788func NewOxmIdReg7() *OxmIdReg7 {
7789 obj := &OxmIdReg7{
7790 OxmId: NewOxmId(69124),
7791 }
7792 return obj
7793}
7794func (self *OxmIdReg7) GetOXMName() string {
7795 return "reg7"
7796}
7797
7798func (self *OxmIdReg7) MarshalJSON() ([]byte, error) {
7799 if self.TypeLen == 0 {
7800 return []byte("\"\""), nil
7801 } else {
7802 return []byte("\"" + self.GetOXMName() + "\""), nil
7803 }
7804}
7805
7806type OxmIdReg7Masked struct {
7807 *OxmId
7808}
7809
7810type IOxmIdReg7Masked interface {
7811 IOxmId
7812}
7813
7814func (self *OxmIdReg7Masked) Serialize(encoder *goloxi.Encoder) error {
7815 if err := self.OxmId.Serialize(encoder); err != nil {
7816 return err
7817 }
7818
7819 return nil
7820}
7821
7822func DecodeOxmIdReg7Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg7Masked, error) {
7823 _oxmidreg7masked := &OxmIdReg7Masked{OxmId: parent}
7824 return _oxmidreg7masked, nil
7825}
7826
7827func NewOxmIdReg7Masked() *OxmIdReg7Masked {
7828 obj := &OxmIdReg7Masked{
7829 OxmId: NewOxmId(69384),
7830 }
7831 return obj
7832}
7833func (self *OxmIdReg7Masked) GetOXMName() string {
7834 return "reg7_masked"
7835}
7836
7837func (self *OxmIdReg7Masked) MarshalJSON() ([]byte, error) {
7838 if self.TypeLen == 0 {
7839 return []byte("\"\""), nil
7840 } else {
7841 return []byte("\"" + self.GetOXMName() + "\""), nil
7842 }
7843}
7844
7845type OxmIdReg8 struct {
7846 *OxmId
7847}
7848
7849type IOxmIdReg8 interface {
7850 IOxmId
7851}
7852
7853func (self *OxmIdReg8) Serialize(encoder *goloxi.Encoder) error {
7854 if err := self.OxmId.Serialize(encoder); err != nil {
7855 return err
7856 }
7857
7858 return nil
7859}
7860
7861func DecodeOxmIdReg8(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg8, error) {
7862 _oxmidreg8 := &OxmIdReg8{OxmId: parent}
7863 return _oxmidreg8, nil
7864}
7865
7866func NewOxmIdReg8() *OxmIdReg8 {
7867 obj := &OxmIdReg8{
7868 OxmId: NewOxmId(69636),
7869 }
7870 return obj
7871}
7872func (self *OxmIdReg8) GetOXMName() string {
7873 return "reg8"
7874}
7875
7876func (self *OxmIdReg8) MarshalJSON() ([]byte, error) {
7877 if self.TypeLen == 0 {
7878 return []byte("\"\""), nil
7879 } else {
7880 return []byte("\"" + self.GetOXMName() + "\""), nil
7881 }
7882}
7883
7884type OxmIdReg8Masked struct {
7885 *OxmId
7886}
7887
7888type IOxmIdReg8Masked interface {
7889 IOxmId
7890}
7891
7892func (self *OxmIdReg8Masked) Serialize(encoder *goloxi.Encoder) error {
7893 if err := self.OxmId.Serialize(encoder); err != nil {
7894 return err
7895 }
7896
7897 return nil
7898}
7899
7900func DecodeOxmIdReg8Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg8Masked, error) {
7901 _oxmidreg8masked := &OxmIdReg8Masked{OxmId: parent}
7902 return _oxmidreg8masked, nil
7903}
7904
7905func NewOxmIdReg8Masked() *OxmIdReg8Masked {
7906 obj := &OxmIdReg8Masked{
7907 OxmId: NewOxmId(69896),
7908 }
7909 return obj
7910}
7911func (self *OxmIdReg8Masked) GetOXMName() string {
7912 return "reg8_masked"
7913}
7914
7915func (self *OxmIdReg8Masked) MarshalJSON() ([]byte, error) {
7916 if self.TypeLen == 0 {
7917 return []byte("\"\""), nil
7918 } else {
7919 return []byte("\"" + self.GetOXMName() + "\""), nil
7920 }
7921}
7922
7923type OxmIdReg9 struct {
7924 *OxmId
7925}
7926
7927type IOxmIdReg9 interface {
7928 IOxmId
7929}
7930
7931func (self *OxmIdReg9) Serialize(encoder *goloxi.Encoder) error {
7932 if err := self.OxmId.Serialize(encoder); err != nil {
7933 return err
7934 }
7935
7936 return nil
7937}
7938
7939func DecodeOxmIdReg9(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg9, error) {
7940 _oxmidreg9 := &OxmIdReg9{OxmId: parent}
7941 return _oxmidreg9, nil
7942}
7943
7944func NewOxmIdReg9() *OxmIdReg9 {
7945 obj := &OxmIdReg9{
7946 OxmId: NewOxmId(70148),
7947 }
7948 return obj
7949}
7950func (self *OxmIdReg9) GetOXMName() string {
7951 return "reg9"
7952}
7953
7954func (self *OxmIdReg9) MarshalJSON() ([]byte, error) {
7955 if self.TypeLen == 0 {
7956 return []byte("\"\""), nil
7957 } else {
7958 return []byte("\"" + self.GetOXMName() + "\""), nil
7959 }
7960}
7961
7962type OxmIdReg9Masked struct {
7963 *OxmId
7964}
7965
7966type IOxmIdReg9Masked interface {
7967 IOxmId
7968}
7969
7970func (self *OxmIdReg9Masked) Serialize(encoder *goloxi.Encoder) error {
7971 if err := self.OxmId.Serialize(encoder); err != nil {
7972 return err
7973 }
7974
7975 return nil
7976}
7977
7978func DecodeOxmIdReg9Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg9Masked, error) {
7979 _oxmidreg9masked := &OxmIdReg9Masked{OxmId: parent}
7980 return _oxmidreg9masked, nil
7981}
7982
7983func NewOxmIdReg9Masked() *OxmIdReg9Masked {
7984 obj := &OxmIdReg9Masked{
7985 OxmId: NewOxmId(70408),
7986 }
7987 return obj
7988}
7989func (self *OxmIdReg9Masked) GetOXMName() string {
7990 return "reg9_masked"
7991}
7992
7993func (self *OxmIdReg9Masked) MarshalJSON() ([]byte, error) {
7994 if self.TypeLen == 0 {
7995 return []byte("\"\""), nil
7996 } else {
7997 return []byte("\"" + self.GetOXMName() + "\""), nil
7998 }
7999}
8000
8001type OxmIdTcpDst struct {
8002 *OxmId
8003}
8004
8005type IOxmIdTcpDst interface {
8006 IOxmId
8007}
8008
8009func (self *OxmIdTcpDst) Serialize(encoder *goloxi.Encoder) error {
8010 if err := self.OxmId.Serialize(encoder); err != nil {
8011 return err
8012 }
8013
8014 return nil
8015}
8016
8017func DecodeOxmIdTcpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpDst, error) {
8018 _oxmidtcpdst := &OxmIdTcpDst{OxmId: parent}
8019 return _oxmidtcpdst, nil
8020}
8021
8022func NewOxmIdTcpDst() *OxmIdTcpDst {
8023 obj := &OxmIdTcpDst{
8024 OxmId: NewOxmId(5122),
8025 }
8026 return obj
8027}
8028func (self *OxmIdTcpDst) GetOXMName() string {
8029 return "tcp_dst"
8030}
8031
8032func (self *OxmIdTcpDst) MarshalJSON() ([]byte, error) {
8033 if self.TypeLen == 0 {
8034 return []byte("\"\""), nil
8035 } else {
8036 return []byte("\"" + self.GetOXMName() + "\""), nil
8037 }
8038}
8039
8040type OxmIdTcpDstMasked struct {
8041 *OxmId
8042}
8043
8044type IOxmIdTcpDstMasked interface {
8045 IOxmId
8046}
8047
8048func (self *OxmIdTcpDstMasked) Serialize(encoder *goloxi.Encoder) error {
8049 if err := self.OxmId.Serialize(encoder); err != nil {
8050 return err
8051 }
8052
8053 return nil
8054}
8055
8056func DecodeOxmIdTcpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpDstMasked, error) {
8057 _oxmidtcpdstmasked := &OxmIdTcpDstMasked{OxmId: parent}
8058 return _oxmidtcpdstmasked, nil
8059}
8060
8061func NewOxmIdTcpDstMasked() *OxmIdTcpDstMasked {
8062 obj := &OxmIdTcpDstMasked{
8063 OxmId: NewOxmId(5378),
8064 }
8065 return obj
8066}
8067func (self *OxmIdTcpDstMasked) GetOXMName() string {
8068 return "tcp_dst_masked"
8069}
8070
8071func (self *OxmIdTcpDstMasked) MarshalJSON() ([]byte, error) {
8072 if self.TypeLen == 0 {
8073 return []byte("\"\""), nil
8074 } else {
8075 return []byte("\"" + self.GetOXMName() + "\""), nil
8076 }
8077}
8078
8079type OxmIdTcpFlags struct {
8080 *OxmId
8081}
8082
8083type IOxmIdTcpFlags interface {
8084 IOxmId
8085}
8086
8087func (self *OxmIdTcpFlags) Serialize(encoder *goloxi.Encoder) error {
8088 if err := self.OxmId.Serialize(encoder); err != nil {
8089 return err
8090 }
8091
8092 return nil
8093}
8094
8095func DecodeOxmIdTcpFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpFlags, error) {
8096 _oxmidtcpflags := &OxmIdTcpFlags{OxmId: parent}
8097 return _oxmidtcpflags, nil
8098}
8099
8100func NewOxmIdTcpFlags() *OxmIdTcpFlags {
8101 obj := &OxmIdTcpFlags{
8102 OxmId: NewOxmId(82946),
8103 }
8104 return obj
8105}
8106func (self *OxmIdTcpFlags) GetOXMName() string {
8107 return "tcp_flags"
8108}
8109
8110func (self *OxmIdTcpFlags) MarshalJSON() ([]byte, error) {
8111 if self.TypeLen == 0 {
8112 return []byte("\"\""), nil
8113 } else {
8114 return []byte("\"" + self.GetOXMName() + "\""), nil
8115 }
8116}
8117
8118type OxmIdTcpFlagsMasked struct {
8119 *OxmId
8120}
8121
8122type IOxmIdTcpFlagsMasked interface {
8123 IOxmId
8124}
8125
8126func (self *OxmIdTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
8127 if err := self.OxmId.Serialize(encoder); err != nil {
8128 return err
8129 }
8130
8131 return nil
8132}
8133
8134func DecodeOxmIdTcpFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpFlagsMasked, error) {
8135 _oxmidtcpflagsmasked := &OxmIdTcpFlagsMasked{OxmId: parent}
8136 return _oxmidtcpflagsmasked, nil
8137}
8138
8139func NewOxmIdTcpFlagsMasked() *OxmIdTcpFlagsMasked {
8140 obj := &OxmIdTcpFlagsMasked{
8141 OxmId: NewOxmId(83204),
8142 }
8143 return obj
8144}
8145func (self *OxmIdTcpFlagsMasked) GetOXMName() string {
8146 return "tcp_flags_masked"
8147}
8148
8149func (self *OxmIdTcpFlagsMasked) MarshalJSON() ([]byte, error) {
8150 if self.TypeLen == 0 {
8151 return []byte("\"\""), nil
8152 } else {
8153 return []byte("\"" + self.GetOXMName() + "\""), nil
8154 }
8155}
8156
8157type OxmIdTcpSrc struct {
8158 *OxmId
8159}
8160
8161type IOxmIdTcpSrc interface {
8162 IOxmId
8163}
8164
8165func (self *OxmIdTcpSrc) Serialize(encoder *goloxi.Encoder) error {
8166 if err := self.OxmId.Serialize(encoder); err != nil {
8167 return err
8168 }
8169
8170 return nil
8171}
8172
8173func DecodeOxmIdTcpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpSrc, error) {
8174 _oxmidtcpsrc := &OxmIdTcpSrc{OxmId: parent}
8175 return _oxmidtcpsrc, nil
8176}
8177
8178func NewOxmIdTcpSrc() *OxmIdTcpSrc {
8179 obj := &OxmIdTcpSrc{
8180 OxmId: NewOxmId(4610),
8181 }
8182 return obj
8183}
8184func (self *OxmIdTcpSrc) GetOXMName() string {
8185 return "tcp_src"
8186}
8187
8188func (self *OxmIdTcpSrc) MarshalJSON() ([]byte, error) {
8189 if self.TypeLen == 0 {
8190 return []byte("\"\""), nil
8191 } else {
8192 return []byte("\"" + self.GetOXMName() + "\""), nil
8193 }
8194}
8195
8196type OxmIdTcpSrcMasked struct {
8197 *OxmId
8198}
8199
8200type IOxmIdTcpSrcMasked interface {
8201 IOxmId
8202}
8203
8204func (self *OxmIdTcpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
8205 if err := self.OxmId.Serialize(encoder); err != nil {
8206 return err
8207 }
8208
8209 return nil
8210}
8211
8212func DecodeOxmIdTcpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpSrcMasked, error) {
8213 _oxmidtcpsrcmasked := &OxmIdTcpSrcMasked{OxmId: parent}
8214 return _oxmidtcpsrcmasked, nil
8215}
8216
8217func NewOxmIdTcpSrcMasked() *OxmIdTcpSrcMasked {
8218 obj := &OxmIdTcpSrcMasked{
8219 OxmId: NewOxmId(4868),
8220 }
8221 return obj
8222}
8223func (self *OxmIdTcpSrcMasked) GetOXMName() string {
8224 return "tcp_src_masked"
8225}
8226
8227func (self *OxmIdTcpSrcMasked) MarshalJSON() ([]byte, error) {
8228 if self.TypeLen == 0 {
8229 return []byte("\"\""), nil
8230 } else {
8231 return []byte("\"" + self.GetOXMName() + "\""), nil
8232 }
8233}
8234
8235type OxmIdTunDst struct {
8236 *OxmId
8237}
8238
8239type IOxmIdTunDst interface {
8240 IOxmId
8241}
8242
8243func (self *OxmIdTunDst) Serialize(encoder *goloxi.Encoder) error {
8244 if err := self.OxmId.Serialize(encoder); err != nil {
8245 return err
8246 }
8247
8248 return nil
8249}
8250
8251func DecodeOxmIdTunDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunDst, error) {
8252 _oxmidtundst := &OxmIdTunDst{OxmId: parent}
8253 return _oxmidtundst, nil
8254}
8255
8256func NewOxmIdTunDst() *OxmIdTunDst {
8257 obj := &OxmIdTunDst{
8258 OxmId: NewOxmId(81924),
8259 }
8260 return obj
8261}
8262func (self *OxmIdTunDst) GetOXMName() string {
8263 return "tun_dst"
8264}
8265
8266func (self *OxmIdTunDst) MarshalJSON() ([]byte, error) {
8267 if self.TypeLen == 0 {
8268 return []byte("\"\""), nil
8269 } else {
8270 return []byte("\"" + self.GetOXMName() + "\""), nil
8271 }
8272}
8273
8274type OxmIdTunDstMasked struct {
8275 *OxmId
8276}
8277
8278type IOxmIdTunDstMasked interface {
8279 IOxmId
8280}
8281
8282func (self *OxmIdTunDstMasked) Serialize(encoder *goloxi.Encoder) error {
8283 if err := self.OxmId.Serialize(encoder); err != nil {
8284 return err
8285 }
8286
8287 return nil
8288}
8289
8290func DecodeOxmIdTunDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunDstMasked, error) {
8291 _oxmidtundstmasked := &OxmIdTunDstMasked{OxmId: parent}
8292 return _oxmidtundstmasked, nil
8293}
8294
8295func NewOxmIdTunDstMasked() *OxmIdTunDstMasked {
8296 obj := &OxmIdTunDstMasked{
8297 OxmId: NewOxmId(82184),
8298 }
8299 return obj
8300}
8301func (self *OxmIdTunDstMasked) GetOXMName() string {
8302 return "tun_dst_masked"
8303}
8304
8305func (self *OxmIdTunDstMasked) MarshalJSON() ([]byte, error) {
8306 if self.TypeLen == 0 {
8307 return []byte("\"\""), nil
8308 } else {
8309 return []byte("\"" + self.GetOXMName() + "\""), nil
8310 }
8311}
8312
8313type OxmIdTunFlags struct {
8314 *OxmId
8315}
8316
8317type IOxmIdTunFlags interface {
8318 IOxmId
8319}
8320
8321func (self *OxmIdTunFlags) Serialize(encoder *goloxi.Encoder) error {
8322 if err := self.OxmId.Serialize(encoder); err != nil {
8323 return err
8324 }
8325
8326 return nil
8327}
8328
8329func DecodeOxmIdTunFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunFlags, error) {
8330 _oxmidtunflags := &OxmIdTunFlags{OxmId: parent}
8331 return _oxmidtunflags, nil
8332}
8333
8334func NewOxmIdTunFlags() *OxmIdTunFlags {
8335 obj := &OxmIdTunFlags{
8336 OxmId: NewOxmId(118786),
8337 }
8338 return obj
8339}
8340func (self *OxmIdTunFlags) GetOXMName() string {
8341 return "tun_flags"
8342}
8343
8344func (self *OxmIdTunFlags) MarshalJSON() ([]byte, error) {
8345 if self.TypeLen == 0 {
8346 return []byte("\"\""), nil
8347 } else {
8348 return []byte("\"" + self.GetOXMName() + "\""), nil
8349 }
8350}
8351
8352type OxmIdTunFlagsMasked struct {
8353 *OxmId
8354}
8355
8356type IOxmIdTunFlagsMasked interface {
8357 IOxmId
8358}
8359
8360func (self *OxmIdTunFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
8361 if err := self.OxmId.Serialize(encoder); err != nil {
8362 return err
8363 }
8364
8365 return nil
8366}
8367
8368func DecodeOxmIdTunFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunFlagsMasked, error) {
8369 _oxmidtunflagsmasked := &OxmIdTunFlagsMasked{OxmId: parent}
8370 return _oxmidtunflagsmasked, nil
8371}
8372
8373func NewOxmIdTunFlagsMasked() *OxmIdTunFlagsMasked {
8374 obj := &OxmIdTunFlagsMasked{
8375 OxmId: NewOxmId(119044),
8376 }
8377 return obj
8378}
8379func (self *OxmIdTunFlagsMasked) GetOXMName() string {
8380 return "tun_flags_masked"
8381}
8382
8383func (self *OxmIdTunFlagsMasked) MarshalJSON() ([]byte, error) {
8384 if self.TypeLen == 0 {
8385 return []byte("\"\""), nil
8386 } else {
8387 return []byte("\"" + self.GetOXMName() + "\""), nil
8388 }
8389}
8390
8391type OxmIdTunGbpFlags struct {
8392 *OxmId
8393}
8394
8395type IOxmIdTunGbpFlags interface {
8396 IOxmId
8397}
8398
8399func (self *OxmIdTunGbpFlags) Serialize(encoder *goloxi.Encoder) error {
8400 if err := self.OxmId.Serialize(encoder); err != nil {
8401 return err
8402 }
8403
8404 return nil
8405}
8406
8407func DecodeOxmIdTunGbpFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpFlags, error) {
8408 _oxmidtungbpflags := &OxmIdTunGbpFlags{OxmId: parent}
8409 return _oxmidtungbpflags, nil
8410}
8411
8412func NewOxmIdTunGbpFlags() *OxmIdTunGbpFlags {
8413 obj := &OxmIdTunGbpFlags{
8414 OxmId: NewOxmId(85505),
8415 }
8416 return obj
8417}
8418func (self *OxmIdTunGbpFlags) GetOXMName() string {
8419 return "tun_gbp_flags"
8420}
8421
8422func (self *OxmIdTunGbpFlags) MarshalJSON() ([]byte, error) {
8423 if self.TypeLen == 0 {
8424 return []byte("\"\""), nil
8425 } else {
8426 return []byte("\"" + self.GetOXMName() + "\""), nil
8427 }
8428}
8429
8430type OxmIdTunGbpFlagsMasked struct {
8431 *OxmId
8432}
8433
8434type IOxmIdTunGbpFlagsMasked interface {
8435 IOxmId
8436}
8437
8438func (self *OxmIdTunGbpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
8439 if err := self.OxmId.Serialize(encoder); err != nil {
8440 return err
8441 }
8442
8443 return nil
8444}
8445
8446func DecodeOxmIdTunGbpFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpFlagsMasked, error) {
8447 _oxmidtungbpflagsmasked := &OxmIdTunGbpFlagsMasked{OxmId: parent}
8448 return _oxmidtungbpflagsmasked, nil
8449}
8450
8451func NewOxmIdTunGbpFlagsMasked() *OxmIdTunGbpFlagsMasked {
8452 obj := &OxmIdTunGbpFlagsMasked{
8453 OxmId: NewOxmId(85762),
8454 }
8455 return obj
8456}
8457func (self *OxmIdTunGbpFlagsMasked) GetOXMName() string {
8458 return "tun_gbp_flags_masked"
8459}
8460
8461func (self *OxmIdTunGbpFlagsMasked) MarshalJSON() ([]byte, error) {
8462 if self.TypeLen == 0 {
8463 return []byte("\"\""), nil
8464 } else {
8465 return []byte("\"" + self.GetOXMName() + "\""), nil
8466 }
8467}
8468
8469type OxmIdTunGbpId struct {
8470 *OxmId
8471}
8472
8473type IOxmIdTunGbpId interface {
8474 IOxmId
8475}
8476
8477func (self *OxmIdTunGbpId) Serialize(encoder *goloxi.Encoder) error {
8478 if err := self.OxmId.Serialize(encoder); err != nil {
8479 return err
8480 }
8481
8482 return nil
8483}
8484
8485func DecodeOxmIdTunGbpId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpId, error) {
8486 _oxmidtungbpid := &OxmIdTunGbpId{OxmId: parent}
8487 return _oxmidtungbpid, nil
8488}
8489
8490func NewOxmIdTunGbpId() *OxmIdTunGbpId {
8491 obj := &OxmIdTunGbpId{
8492 OxmId: NewOxmId(84994),
8493 }
8494 return obj
8495}
8496func (self *OxmIdTunGbpId) GetOXMName() string {
8497 return "tun_gbp_id"
8498}
8499
8500func (self *OxmIdTunGbpId) MarshalJSON() ([]byte, error) {
8501 if self.TypeLen == 0 {
8502 return []byte("\"\""), nil
8503 } else {
8504 return []byte("\"" + self.GetOXMName() + "\""), nil
8505 }
8506}
8507
8508type OxmIdTunGbpIdMasked struct {
8509 *OxmId
8510}
8511
8512type IOxmIdTunGbpIdMasked interface {
8513 IOxmId
8514}
8515
8516func (self *OxmIdTunGbpIdMasked) Serialize(encoder *goloxi.Encoder) error {
8517 if err := self.OxmId.Serialize(encoder); err != nil {
8518 return err
8519 }
8520
8521 return nil
8522}
8523
8524func DecodeOxmIdTunGbpIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpIdMasked, error) {
8525 _oxmidtungbpidmasked := &OxmIdTunGbpIdMasked{OxmId: parent}
8526 return _oxmidtungbpidmasked, nil
8527}
8528
8529func NewOxmIdTunGbpIdMasked() *OxmIdTunGbpIdMasked {
8530 obj := &OxmIdTunGbpIdMasked{
8531 OxmId: NewOxmId(85252),
8532 }
8533 return obj
8534}
8535func (self *OxmIdTunGbpIdMasked) GetOXMName() string {
8536 return "tun_gbp_id_masked"
8537}
8538
8539func (self *OxmIdTunGbpIdMasked) MarshalJSON() ([]byte, error) {
8540 if self.TypeLen == 0 {
8541 return []byte("\"\""), nil
8542 } else {
8543 return []byte("\"" + self.GetOXMName() + "\""), nil
8544 }
8545}
8546
8547type OxmIdTunId struct {
8548 *OxmId
8549}
8550
8551type IOxmIdTunId interface {
8552 IOxmId
8553}
8554
8555func (self *OxmIdTunId) Serialize(encoder *goloxi.Encoder) error {
8556 if err := self.OxmId.Serialize(encoder); err != nil {
8557 return err
8558 }
8559
8560 return nil
8561}
8562
8563func DecodeOxmIdTunId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunId, error) {
8564 _oxmidtunid := &OxmIdTunId{OxmId: parent}
8565 return _oxmidtunid, nil
8566}
8567
8568func NewOxmIdTunId() *OxmIdTunId {
8569 obj := &OxmIdTunId{
8570 OxmId: NewOxmId(73736),
8571 }
8572 return obj
8573}
8574func (self *OxmIdTunId) GetOXMName() string {
8575 return "tun_id"
8576}
8577
8578func (self *OxmIdTunId) MarshalJSON() ([]byte, error) {
8579 if self.TypeLen == 0 {
8580 return []byte("\"\""), nil
8581 } else {
8582 return []byte("\"" + self.GetOXMName() + "\""), nil
8583 }
8584}
8585
8586type OxmIdTunIdMasked struct {
8587 *OxmId
8588}
8589
8590type IOxmIdTunIdMasked interface {
8591 IOxmId
8592}
8593
8594func (self *OxmIdTunIdMasked) Serialize(encoder *goloxi.Encoder) error {
8595 if err := self.OxmId.Serialize(encoder); err != nil {
8596 return err
8597 }
8598
8599 return nil
8600}
8601
8602func DecodeOxmIdTunIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIdMasked, error) {
8603 _oxmidtunidmasked := &OxmIdTunIdMasked{OxmId: parent}
8604 return _oxmidtunidmasked, nil
8605}
8606
8607func NewOxmIdTunIdMasked() *OxmIdTunIdMasked {
8608 obj := &OxmIdTunIdMasked{
8609 OxmId: NewOxmId(74000),
8610 }
8611 return obj
8612}
8613func (self *OxmIdTunIdMasked) GetOXMName() string {
8614 return "tun_id_masked"
8615}
8616
8617func (self *OxmIdTunIdMasked) MarshalJSON() ([]byte, error) {
8618 if self.TypeLen == 0 {
8619 return []byte("\"\""), nil
8620 } else {
8621 return []byte("\"" + self.GetOXMName() + "\""), nil
8622 }
8623}
8624
8625type OxmIdTunIpv6Dst struct {
8626 *OxmId
8627}
8628
8629type IOxmIdTunIpv6Dst interface {
8630 IOxmId
8631}
8632
8633func (self *OxmIdTunIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
8634 if err := self.OxmId.Serialize(encoder); err != nil {
8635 return err
8636 }
8637
8638 return nil
8639}
8640
8641func DecodeOxmIdTunIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6Dst, error) {
8642 _oxmidtunipv6dst := &OxmIdTunIpv6Dst{OxmId: parent}
8643 return _oxmidtunipv6dst, nil
8644}
8645
8646func NewOxmIdTunIpv6Dst() *OxmIdTunIpv6Dst {
8647 obj := &OxmIdTunIpv6Dst{
8648 OxmId: NewOxmId(121872),
8649 }
8650 return obj
8651}
8652func (self *OxmIdTunIpv6Dst) GetOXMName() string {
8653 return "tun_ipv6_dst"
8654}
8655
8656func (self *OxmIdTunIpv6Dst) MarshalJSON() ([]byte, error) {
8657 if self.TypeLen == 0 {
8658 return []byte("\"\""), nil
8659 } else {
8660 return []byte("\"" + self.GetOXMName() + "\""), nil
8661 }
8662}
8663
8664type OxmIdTunIpv6DstMasked struct {
8665 *OxmId
8666}
8667
8668type IOxmIdTunIpv6DstMasked interface {
8669 IOxmId
8670}
8671
8672func (self *OxmIdTunIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
8673 if err := self.OxmId.Serialize(encoder); err != nil {
8674 return err
8675 }
8676
8677 return nil
8678}
8679
8680func DecodeOxmIdTunIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6DstMasked, error) {
8681 _oxmidtunipv6dstmasked := &OxmIdTunIpv6DstMasked{OxmId: parent}
8682 return _oxmidtunipv6dstmasked, nil
8683}
8684
8685func NewOxmIdTunIpv6DstMasked() *OxmIdTunIpv6DstMasked {
8686 obj := &OxmIdTunIpv6DstMasked{
8687 OxmId: NewOxmId(122144),
8688 }
8689 return obj
8690}
8691func (self *OxmIdTunIpv6DstMasked) GetOXMName() string {
8692 return "tun_ipv6_dst_masked"
8693}
8694
8695func (self *OxmIdTunIpv6DstMasked) MarshalJSON() ([]byte, error) {
8696 if self.TypeLen == 0 {
8697 return []byte("\"\""), nil
8698 } else {
8699 return []byte("\"" + self.GetOXMName() + "\""), nil
8700 }
8701}
8702
8703type OxmIdTunIpv6Src struct {
8704 *OxmId
8705}
8706
8707type IOxmIdTunIpv6Src interface {
8708 IOxmId
8709}
8710
8711func (self *OxmIdTunIpv6Src) Serialize(encoder *goloxi.Encoder) error {
8712 if err := self.OxmId.Serialize(encoder); err != nil {
8713 return err
8714 }
8715
8716 return nil
8717}
8718
8719func DecodeOxmIdTunIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6Src, error) {
8720 _oxmidtunipv6src := &OxmIdTunIpv6Src{OxmId: parent}
8721 return _oxmidtunipv6src, nil
8722}
8723
8724func NewOxmIdTunIpv6Src() *OxmIdTunIpv6Src {
8725 obj := &OxmIdTunIpv6Src{
8726 OxmId: NewOxmId(121360),
8727 }
8728 return obj
8729}
8730func (self *OxmIdTunIpv6Src) GetOXMName() string {
8731 return "tun_ipv6_src"
8732}
8733
8734func (self *OxmIdTunIpv6Src) MarshalJSON() ([]byte, error) {
8735 if self.TypeLen == 0 {
8736 return []byte("\"\""), nil
8737 } else {
8738 return []byte("\"" + self.GetOXMName() + "\""), nil
8739 }
8740}
8741
8742type OxmIdTunIpv6SrcMasked struct {
8743 *OxmId
8744}
8745
8746type IOxmIdTunIpv6SrcMasked interface {
8747 IOxmId
8748}
8749
8750func (self *OxmIdTunIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
8751 if err := self.OxmId.Serialize(encoder); err != nil {
8752 return err
8753 }
8754
8755 return nil
8756}
8757
8758func DecodeOxmIdTunIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6SrcMasked, error) {
8759 _oxmidtunipv6srcmasked := &OxmIdTunIpv6SrcMasked{OxmId: parent}
8760 return _oxmidtunipv6srcmasked, nil
8761}
8762
8763func NewOxmIdTunIpv6SrcMasked() *OxmIdTunIpv6SrcMasked {
8764 obj := &OxmIdTunIpv6SrcMasked{
8765 OxmId: NewOxmId(121632),
8766 }
8767 return obj
8768}
8769func (self *OxmIdTunIpv6SrcMasked) GetOXMName() string {
8770 return "tun_ipv6_src_masked"
8771}
8772
8773func (self *OxmIdTunIpv6SrcMasked) MarshalJSON() ([]byte, error) {
8774 if self.TypeLen == 0 {
8775 return []byte("\"\""), nil
8776 } else {
8777 return []byte("\"" + self.GetOXMName() + "\""), nil
8778 }
8779}
8780
8781type OxmIdTunMetadata0 struct {
8782 *OxmId
8783}
8784
8785type IOxmIdTunMetadata0 interface {
8786 IOxmId
8787}
8788
8789func (self *OxmIdTunMetadata0) Serialize(encoder *goloxi.Encoder) error {
8790 if err := self.OxmId.Serialize(encoder); err != nil {
8791 return err
8792 }
8793
8794 return nil
8795}
8796
8797func DecodeOxmIdTunMetadata0(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata0, error) {
8798 _oxmidtunmetadata0 := &OxmIdTunMetadata0{OxmId: parent}
8799 return _oxmidtunmetadata0, nil
8800}
8801
8802func NewOxmIdTunMetadata0() *OxmIdTunMetadata0 {
8803 obj := &OxmIdTunMetadata0{
8804 OxmId: NewOxmId(86140),
8805 }
8806 return obj
8807}
8808func (self *OxmIdTunMetadata0) GetOXMName() string {
8809 return "tun_metadata0"
8810}
8811
8812func (self *OxmIdTunMetadata0) MarshalJSON() ([]byte, error) {
8813 if self.TypeLen == 0 {
8814 return []byte("\"\""), nil
8815 } else {
8816 return []byte("\"" + self.GetOXMName() + "\""), nil
8817 }
8818}
8819
8820type OxmIdTunMetadata0Masked struct {
8821 *OxmId
8822}
8823
8824type IOxmIdTunMetadata0Masked interface {
8825 IOxmId
8826}
8827
8828func (self *OxmIdTunMetadata0Masked) Serialize(encoder *goloxi.Encoder) error {
8829 if err := self.OxmId.Serialize(encoder); err != nil {
8830 return err
8831 }
8832
8833 return nil
8834}
8835
8836func DecodeOxmIdTunMetadata0Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata0Masked, error) {
8837 _oxmidtunmetadata0masked := &OxmIdTunMetadata0Masked{OxmId: parent}
8838 return _oxmidtunmetadata0masked, nil
8839}
8840
8841func NewOxmIdTunMetadata0Masked() *OxmIdTunMetadata0Masked {
8842 obj := &OxmIdTunMetadata0Masked{
8843 OxmId: NewOxmId(86520),
8844 }
8845 return obj
8846}
8847func (self *OxmIdTunMetadata0Masked) GetOXMName() string {
8848 return "tun_metadata0_masked"
8849}
8850
8851func (self *OxmIdTunMetadata0Masked) MarshalJSON() ([]byte, error) {
8852 if self.TypeLen == 0 {
8853 return []byte("\"\""), nil
8854 } else {
8855 return []byte("\"" + self.GetOXMName() + "\""), nil
8856 }
8857}
8858
8859type OxmIdTunMetadata1 struct {
8860 *OxmId
8861}
8862
8863type IOxmIdTunMetadata1 interface {
8864 IOxmId
8865}
8866
8867func (self *OxmIdTunMetadata1) Serialize(encoder *goloxi.Encoder) error {
8868 if err := self.OxmId.Serialize(encoder); err != nil {
8869 return err
8870 }
8871
8872 return nil
8873}
8874
8875func DecodeOxmIdTunMetadata1(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata1, error) {
8876 _oxmidtunmetadata1 := &OxmIdTunMetadata1{OxmId: parent}
8877 return _oxmidtunmetadata1, nil
8878}
8879
8880func NewOxmIdTunMetadata1() *OxmIdTunMetadata1 {
8881 obj := &OxmIdTunMetadata1{
8882 OxmId: NewOxmId(86652),
8883 }
8884 return obj
8885}
8886func (self *OxmIdTunMetadata1) GetOXMName() string {
8887 return "tun_metadata1"
8888}
8889
8890func (self *OxmIdTunMetadata1) MarshalJSON() ([]byte, error) {
8891 if self.TypeLen == 0 {
8892 return []byte("\"\""), nil
8893 } else {
8894 return []byte("\"" + self.GetOXMName() + "\""), nil
8895 }
8896}
8897
8898type OxmIdTunMetadata10 struct {
8899 *OxmId
8900}
8901
8902type IOxmIdTunMetadata10 interface {
8903 IOxmId
8904}
8905
8906func (self *OxmIdTunMetadata10) Serialize(encoder *goloxi.Encoder) error {
8907 if err := self.OxmId.Serialize(encoder); err != nil {
8908 return err
8909 }
8910
8911 return nil
8912}
8913
8914func DecodeOxmIdTunMetadata10(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata10, error) {
8915 _oxmidtunmetadata10 := &OxmIdTunMetadata10{OxmId: parent}
8916 return _oxmidtunmetadata10, nil
8917}
8918
8919func NewOxmIdTunMetadata10() *OxmIdTunMetadata10 {
8920 obj := &OxmIdTunMetadata10{
8921 OxmId: NewOxmId(91260),
8922 }
8923 return obj
8924}
8925func (self *OxmIdTunMetadata10) GetOXMName() string {
8926 return "tun_metadata10"
8927}
8928
8929func (self *OxmIdTunMetadata10) MarshalJSON() ([]byte, error) {
8930 if self.TypeLen == 0 {
8931 return []byte("\"\""), nil
8932 } else {
8933 return []byte("\"" + self.GetOXMName() + "\""), nil
8934 }
8935}
8936
8937type OxmIdTunMetadata10Masked struct {
8938 *OxmId
8939}
8940
8941type IOxmIdTunMetadata10Masked interface {
8942 IOxmId
8943}
8944
8945func (self *OxmIdTunMetadata10Masked) Serialize(encoder *goloxi.Encoder) error {
8946 if err := self.OxmId.Serialize(encoder); err != nil {
8947 return err
8948 }
8949
8950 return nil
8951}
8952
8953func DecodeOxmIdTunMetadata10Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata10Masked, error) {
8954 _oxmidtunmetadata10masked := &OxmIdTunMetadata10Masked{OxmId: parent}
8955 return _oxmidtunmetadata10masked, nil
8956}
8957
8958func NewOxmIdTunMetadata10Masked() *OxmIdTunMetadata10Masked {
8959 obj := &OxmIdTunMetadata10Masked{
8960 OxmId: NewOxmId(91640),
8961 }
8962 return obj
8963}
8964func (self *OxmIdTunMetadata10Masked) GetOXMName() string {
8965 return "tun_metadata10_masked"
8966}
8967
8968func (self *OxmIdTunMetadata10Masked) MarshalJSON() ([]byte, error) {
8969 if self.TypeLen == 0 {
8970 return []byte("\"\""), nil
8971 } else {
8972 return []byte("\"" + self.GetOXMName() + "\""), nil
8973 }
8974}
8975
8976type OxmIdTunMetadata11 struct {
8977 *OxmId
8978}
8979
8980type IOxmIdTunMetadata11 interface {
8981 IOxmId
8982}
8983
8984func (self *OxmIdTunMetadata11) Serialize(encoder *goloxi.Encoder) error {
8985 if err := self.OxmId.Serialize(encoder); err != nil {
8986 return err
8987 }
8988
8989 return nil
8990}
8991
8992func DecodeOxmIdTunMetadata11(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata11, error) {
8993 _oxmidtunmetadata11 := &OxmIdTunMetadata11{OxmId: parent}
8994 return _oxmidtunmetadata11, nil
8995}
8996
8997func NewOxmIdTunMetadata11() *OxmIdTunMetadata11 {
8998 obj := &OxmIdTunMetadata11{
8999 OxmId: NewOxmId(91772),
9000 }
9001 return obj
9002}
9003func (self *OxmIdTunMetadata11) GetOXMName() string {
9004 return "tun_metadata11"
9005}
9006
9007func (self *OxmIdTunMetadata11) MarshalJSON() ([]byte, error) {
9008 if self.TypeLen == 0 {
9009 return []byte("\"\""), nil
9010 } else {
9011 return []byte("\"" + self.GetOXMName() + "\""), nil
9012 }
9013}
9014
9015type OxmIdTunMetadata11Masked struct {
9016 *OxmId
9017}
9018
9019type IOxmIdTunMetadata11Masked interface {
9020 IOxmId
9021}
9022
9023func (self *OxmIdTunMetadata11Masked) Serialize(encoder *goloxi.Encoder) error {
9024 if err := self.OxmId.Serialize(encoder); err != nil {
9025 return err
9026 }
9027
9028 return nil
9029}
9030
9031func DecodeOxmIdTunMetadata11Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata11Masked, error) {
9032 _oxmidtunmetadata11masked := &OxmIdTunMetadata11Masked{OxmId: parent}
9033 return _oxmidtunmetadata11masked, nil
9034}
9035
9036func NewOxmIdTunMetadata11Masked() *OxmIdTunMetadata11Masked {
9037 obj := &OxmIdTunMetadata11Masked{
9038 OxmId: NewOxmId(92152),
9039 }
9040 return obj
9041}
9042func (self *OxmIdTunMetadata11Masked) GetOXMName() string {
9043 return "tun_metadata11_masked"
9044}
9045
9046func (self *OxmIdTunMetadata11Masked) MarshalJSON() ([]byte, error) {
9047 if self.TypeLen == 0 {
9048 return []byte("\"\""), nil
9049 } else {
9050 return []byte("\"" + self.GetOXMName() + "\""), nil
9051 }
9052}
9053
9054type OxmIdTunMetadata12 struct {
9055 *OxmId
9056}
9057
9058type IOxmIdTunMetadata12 interface {
9059 IOxmId
9060}
9061
9062func (self *OxmIdTunMetadata12) Serialize(encoder *goloxi.Encoder) error {
9063 if err := self.OxmId.Serialize(encoder); err != nil {
9064 return err
9065 }
9066
9067 return nil
9068}
9069
9070func DecodeOxmIdTunMetadata12(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata12, error) {
9071 _oxmidtunmetadata12 := &OxmIdTunMetadata12{OxmId: parent}
9072 return _oxmidtunmetadata12, nil
9073}
9074
9075func NewOxmIdTunMetadata12() *OxmIdTunMetadata12 {
9076 obj := &OxmIdTunMetadata12{
9077 OxmId: NewOxmId(92284),
9078 }
9079 return obj
9080}
9081func (self *OxmIdTunMetadata12) GetOXMName() string {
9082 return "tun_metadata12"
9083}
9084
9085func (self *OxmIdTunMetadata12) MarshalJSON() ([]byte, error) {
9086 if self.TypeLen == 0 {
9087 return []byte("\"\""), nil
9088 } else {
9089 return []byte("\"" + self.GetOXMName() + "\""), nil
9090 }
9091}
9092
9093type OxmIdTunMetadata12Masked struct {
9094 *OxmId
9095}
9096
9097type IOxmIdTunMetadata12Masked interface {
9098 IOxmId
9099}
9100
9101func (self *OxmIdTunMetadata12Masked) Serialize(encoder *goloxi.Encoder) error {
9102 if err := self.OxmId.Serialize(encoder); err != nil {
9103 return err
9104 }
9105
9106 return nil
9107}
9108
9109func DecodeOxmIdTunMetadata12Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata12Masked, error) {
9110 _oxmidtunmetadata12masked := &OxmIdTunMetadata12Masked{OxmId: parent}
9111 return _oxmidtunmetadata12masked, nil
9112}
9113
9114func NewOxmIdTunMetadata12Masked() *OxmIdTunMetadata12Masked {
9115 obj := &OxmIdTunMetadata12Masked{
9116 OxmId: NewOxmId(92664),
9117 }
9118 return obj
9119}
9120func (self *OxmIdTunMetadata12Masked) GetOXMName() string {
9121 return "tun_metadata12_masked"
9122}
9123
9124func (self *OxmIdTunMetadata12Masked) MarshalJSON() ([]byte, error) {
9125 if self.TypeLen == 0 {
9126 return []byte("\"\""), nil
9127 } else {
9128 return []byte("\"" + self.GetOXMName() + "\""), nil
9129 }
9130}
9131
9132type OxmIdTunMetadata13 struct {
9133 *OxmId
9134}
9135
9136type IOxmIdTunMetadata13 interface {
9137 IOxmId
9138}
9139
9140func (self *OxmIdTunMetadata13) Serialize(encoder *goloxi.Encoder) error {
9141 if err := self.OxmId.Serialize(encoder); err != nil {
9142 return err
9143 }
9144
9145 return nil
9146}
9147
9148func DecodeOxmIdTunMetadata13(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata13, error) {
9149 _oxmidtunmetadata13 := &OxmIdTunMetadata13{OxmId: parent}
9150 return _oxmidtunmetadata13, nil
9151}
9152
9153func NewOxmIdTunMetadata13() *OxmIdTunMetadata13 {
9154 obj := &OxmIdTunMetadata13{
9155 OxmId: NewOxmId(92796),
9156 }
9157 return obj
9158}
9159func (self *OxmIdTunMetadata13) GetOXMName() string {
9160 return "tun_metadata13"
9161}
9162
9163func (self *OxmIdTunMetadata13) MarshalJSON() ([]byte, error) {
9164 if self.TypeLen == 0 {
9165 return []byte("\"\""), nil
9166 } else {
9167 return []byte("\"" + self.GetOXMName() + "\""), nil
9168 }
9169}
9170
9171type OxmIdTunMetadata13Masked struct {
9172 *OxmId
9173}
9174
9175type IOxmIdTunMetadata13Masked interface {
9176 IOxmId
9177}
9178
9179func (self *OxmIdTunMetadata13Masked) Serialize(encoder *goloxi.Encoder) error {
9180 if err := self.OxmId.Serialize(encoder); err != nil {
9181 return err
9182 }
9183
9184 return nil
9185}
9186
9187func DecodeOxmIdTunMetadata13Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata13Masked, error) {
9188 _oxmidtunmetadata13masked := &OxmIdTunMetadata13Masked{OxmId: parent}
9189 return _oxmidtunmetadata13masked, nil
9190}
9191
9192func NewOxmIdTunMetadata13Masked() *OxmIdTunMetadata13Masked {
9193 obj := &OxmIdTunMetadata13Masked{
9194 OxmId: NewOxmId(93176),
9195 }
9196 return obj
9197}
9198func (self *OxmIdTunMetadata13Masked) GetOXMName() string {
9199 return "tun_metadata13_masked"
9200}
9201
9202func (self *OxmIdTunMetadata13Masked) MarshalJSON() ([]byte, error) {
9203 if self.TypeLen == 0 {
9204 return []byte("\"\""), nil
9205 } else {
9206 return []byte("\"" + self.GetOXMName() + "\""), nil
9207 }
9208}
9209
9210type OxmIdTunMetadata14 struct {
9211 *OxmId
9212}
9213
9214type IOxmIdTunMetadata14 interface {
9215 IOxmId
9216}
9217
9218func (self *OxmIdTunMetadata14) Serialize(encoder *goloxi.Encoder) error {
9219 if err := self.OxmId.Serialize(encoder); err != nil {
9220 return err
9221 }
9222
9223 return nil
9224}
9225
9226func DecodeOxmIdTunMetadata14(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata14, error) {
9227 _oxmidtunmetadata14 := &OxmIdTunMetadata14{OxmId: parent}
9228 return _oxmidtunmetadata14, nil
9229}
9230
9231func NewOxmIdTunMetadata14() *OxmIdTunMetadata14 {
9232 obj := &OxmIdTunMetadata14{
9233 OxmId: NewOxmId(93308),
9234 }
9235 return obj
9236}
9237func (self *OxmIdTunMetadata14) GetOXMName() string {
9238 return "tun_metadata14"
9239}
9240
9241func (self *OxmIdTunMetadata14) MarshalJSON() ([]byte, error) {
9242 if self.TypeLen == 0 {
9243 return []byte("\"\""), nil
9244 } else {
9245 return []byte("\"" + self.GetOXMName() + "\""), nil
9246 }
9247}
9248
9249type OxmIdTunMetadata14Masked struct {
9250 *OxmId
9251}
9252
9253type IOxmIdTunMetadata14Masked interface {
9254 IOxmId
9255}
9256
9257func (self *OxmIdTunMetadata14Masked) Serialize(encoder *goloxi.Encoder) error {
9258 if err := self.OxmId.Serialize(encoder); err != nil {
9259 return err
9260 }
9261
9262 return nil
9263}
9264
9265func DecodeOxmIdTunMetadata14Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata14Masked, error) {
9266 _oxmidtunmetadata14masked := &OxmIdTunMetadata14Masked{OxmId: parent}
9267 return _oxmidtunmetadata14masked, nil
9268}
9269
9270func NewOxmIdTunMetadata14Masked() *OxmIdTunMetadata14Masked {
9271 obj := &OxmIdTunMetadata14Masked{
9272 OxmId: NewOxmId(93688),
9273 }
9274 return obj
9275}
9276func (self *OxmIdTunMetadata14Masked) GetOXMName() string {
9277 return "tun_metadata14_masked"
9278}
9279
9280func (self *OxmIdTunMetadata14Masked) MarshalJSON() ([]byte, error) {
9281 if self.TypeLen == 0 {
9282 return []byte("\"\""), nil
9283 } else {
9284 return []byte("\"" + self.GetOXMName() + "\""), nil
9285 }
9286}
9287
9288type OxmIdTunMetadata15 struct {
9289 *OxmId
9290}
9291
9292type IOxmIdTunMetadata15 interface {
9293 IOxmId
9294}
9295
9296func (self *OxmIdTunMetadata15) Serialize(encoder *goloxi.Encoder) error {
9297 if err := self.OxmId.Serialize(encoder); err != nil {
9298 return err
9299 }
9300
9301 return nil
9302}
9303
9304func DecodeOxmIdTunMetadata15(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata15, error) {
9305 _oxmidtunmetadata15 := &OxmIdTunMetadata15{OxmId: parent}
9306 return _oxmidtunmetadata15, nil
9307}
9308
9309func NewOxmIdTunMetadata15() *OxmIdTunMetadata15 {
9310 obj := &OxmIdTunMetadata15{
9311 OxmId: NewOxmId(93820),
9312 }
9313 return obj
9314}
9315func (self *OxmIdTunMetadata15) GetOXMName() string {
9316 return "tun_metadata15"
9317}
9318
9319func (self *OxmIdTunMetadata15) MarshalJSON() ([]byte, error) {
9320 if self.TypeLen == 0 {
9321 return []byte("\"\""), nil
9322 } else {
9323 return []byte("\"" + self.GetOXMName() + "\""), nil
9324 }
9325}
9326
9327type OxmIdTunMetadata15Masked struct {
9328 *OxmId
9329}
9330
9331type IOxmIdTunMetadata15Masked interface {
9332 IOxmId
9333}
9334
9335func (self *OxmIdTunMetadata15Masked) Serialize(encoder *goloxi.Encoder) error {
9336 if err := self.OxmId.Serialize(encoder); err != nil {
9337 return err
9338 }
9339
9340 return nil
9341}
9342
9343func DecodeOxmIdTunMetadata15Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata15Masked, error) {
9344 _oxmidtunmetadata15masked := &OxmIdTunMetadata15Masked{OxmId: parent}
9345 return _oxmidtunmetadata15masked, nil
9346}
9347
9348func NewOxmIdTunMetadata15Masked() *OxmIdTunMetadata15Masked {
9349 obj := &OxmIdTunMetadata15Masked{
9350 OxmId: NewOxmId(94200),
9351 }
9352 return obj
9353}
9354func (self *OxmIdTunMetadata15Masked) GetOXMName() string {
9355 return "tun_metadata15_masked"
9356}
9357
9358func (self *OxmIdTunMetadata15Masked) MarshalJSON() ([]byte, error) {
9359 if self.TypeLen == 0 {
9360 return []byte("\"\""), nil
9361 } else {
9362 return []byte("\"" + self.GetOXMName() + "\""), nil
9363 }
9364}
9365
9366type OxmIdTunMetadata16 struct {
9367 *OxmId
9368}
9369
9370type IOxmIdTunMetadata16 interface {
9371 IOxmId
9372}
9373
9374func (self *OxmIdTunMetadata16) Serialize(encoder *goloxi.Encoder) error {
9375 if err := self.OxmId.Serialize(encoder); err != nil {
9376 return err
9377 }
9378
9379 return nil
9380}
9381
9382func DecodeOxmIdTunMetadata16(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata16, error) {
9383 _oxmidtunmetadata16 := &OxmIdTunMetadata16{OxmId: parent}
9384 return _oxmidtunmetadata16, nil
9385}
9386
9387func NewOxmIdTunMetadata16() *OxmIdTunMetadata16 {
9388 obj := &OxmIdTunMetadata16{
9389 OxmId: NewOxmId(94332),
9390 }
9391 return obj
9392}
9393func (self *OxmIdTunMetadata16) GetOXMName() string {
9394 return "tun_metadata16"
9395}
9396
9397func (self *OxmIdTunMetadata16) MarshalJSON() ([]byte, error) {
9398 if self.TypeLen == 0 {
9399 return []byte("\"\""), nil
9400 } else {
9401 return []byte("\"" + self.GetOXMName() + "\""), nil
9402 }
9403}
9404
9405type OxmIdTunMetadata16Masked struct {
9406 *OxmId
9407}
9408
9409type IOxmIdTunMetadata16Masked interface {
9410 IOxmId
9411}
9412
9413func (self *OxmIdTunMetadata16Masked) Serialize(encoder *goloxi.Encoder) error {
9414 if err := self.OxmId.Serialize(encoder); err != nil {
9415 return err
9416 }
9417
9418 return nil
9419}
9420
9421func DecodeOxmIdTunMetadata16Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata16Masked, error) {
9422 _oxmidtunmetadata16masked := &OxmIdTunMetadata16Masked{OxmId: parent}
9423 return _oxmidtunmetadata16masked, nil
9424}
9425
9426func NewOxmIdTunMetadata16Masked() *OxmIdTunMetadata16Masked {
9427 obj := &OxmIdTunMetadata16Masked{
9428 OxmId: NewOxmId(94712),
9429 }
9430 return obj
9431}
9432func (self *OxmIdTunMetadata16Masked) GetOXMName() string {
9433 return "tun_metadata16_masked"
9434}
9435
9436func (self *OxmIdTunMetadata16Masked) MarshalJSON() ([]byte, error) {
9437 if self.TypeLen == 0 {
9438 return []byte("\"\""), nil
9439 } else {
9440 return []byte("\"" + self.GetOXMName() + "\""), nil
9441 }
9442}
9443
9444type OxmIdTunMetadata17 struct {
9445 *OxmId
9446}
9447
9448type IOxmIdTunMetadata17 interface {
9449 IOxmId
9450}
9451
9452func (self *OxmIdTunMetadata17) Serialize(encoder *goloxi.Encoder) error {
9453 if err := self.OxmId.Serialize(encoder); err != nil {
9454 return err
9455 }
9456
9457 return nil
9458}
9459
9460func DecodeOxmIdTunMetadata17(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata17, error) {
9461 _oxmidtunmetadata17 := &OxmIdTunMetadata17{OxmId: parent}
9462 return _oxmidtunmetadata17, nil
9463}
9464
9465func NewOxmIdTunMetadata17() *OxmIdTunMetadata17 {
9466 obj := &OxmIdTunMetadata17{
9467 OxmId: NewOxmId(94844),
9468 }
9469 return obj
9470}
9471func (self *OxmIdTunMetadata17) GetOXMName() string {
9472 return "tun_metadata17"
9473}
9474
9475func (self *OxmIdTunMetadata17) MarshalJSON() ([]byte, error) {
9476 if self.TypeLen == 0 {
9477 return []byte("\"\""), nil
9478 } else {
9479 return []byte("\"" + self.GetOXMName() + "\""), nil
9480 }
9481}
9482
9483type OxmIdTunMetadata17Masked struct {
9484 *OxmId
9485}
9486
9487type IOxmIdTunMetadata17Masked interface {
9488 IOxmId
9489}
9490
9491func (self *OxmIdTunMetadata17Masked) Serialize(encoder *goloxi.Encoder) error {
9492 if err := self.OxmId.Serialize(encoder); err != nil {
9493 return err
9494 }
9495
9496 return nil
9497}
9498
9499func DecodeOxmIdTunMetadata17Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata17Masked, error) {
9500 _oxmidtunmetadata17masked := &OxmIdTunMetadata17Masked{OxmId: parent}
9501 return _oxmidtunmetadata17masked, nil
9502}
9503
9504func NewOxmIdTunMetadata17Masked() *OxmIdTunMetadata17Masked {
9505 obj := &OxmIdTunMetadata17Masked{
9506 OxmId: NewOxmId(95224),
9507 }
9508 return obj
9509}
9510func (self *OxmIdTunMetadata17Masked) GetOXMName() string {
9511 return "tun_metadata17_masked"
9512}
9513
9514func (self *OxmIdTunMetadata17Masked) MarshalJSON() ([]byte, error) {
9515 if self.TypeLen == 0 {
9516 return []byte("\"\""), nil
9517 } else {
9518 return []byte("\"" + self.GetOXMName() + "\""), nil
9519 }
9520}
9521
9522type OxmIdTunMetadata18 struct {
9523 *OxmId
9524}
9525
9526type IOxmIdTunMetadata18 interface {
9527 IOxmId
9528}
9529
9530func (self *OxmIdTunMetadata18) Serialize(encoder *goloxi.Encoder) error {
9531 if err := self.OxmId.Serialize(encoder); err != nil {
9532 return err
9533 }
9534
9535 return nil
9536}
9537
9538func DecodeOxmIdTunMetadata18(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata18, error) {
9539 _oxmidtunmetadata18 := &OxmIdTunMetadata18{OxmId: parent}
9540 return _oxmidtunmetadata18, nil
9541}
9542
9543func NewOxmIdTunMetadata18() *OxmIdTunMetadata18 {
9544 obj := &OxmIdTunMetadata18{
9545 OxmId: NewOxmId(95356),
9546 }
9547 return obj
9548}
9549func (self *OxmIdTunMetadata18) GetOXMName() string {
9550 return "tun_metadata18"
9551}
9552
9553func (self *OxmIdTunMetadata18) MarshalJSON() ([]byte, error) {
9554 if self.TypeLen == 0 {
9555 return []byte("\"\""), nil
9556 } else {
9557 return []byte("\"" + self.GetOXMName() + "\""), nil
9558 }
9559}
9560
9561type OxmIdTunMetadata18Masked struct {
9562 *OxmId
9563}
9564
9565type IOxmIdTunMetadata18Masked interface {
9566 IOxmId
9567}
9568
9569func (self *OxmIdTunMetadata18Masked) Serialize(encoder *goloxi.Encoder) error {
9570 if err := self.OxmId.Serialize(encoder); err != nil {
9571 return err
9572 }
9573
9574 return nil
9575}
9576
9577func DecodeOxmIdTunMetadata18Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata18Masked, error) {
9578 _oxmidtunmetadata18masked := &OxmIdTunMetadata18Masked{OxmId: parent}
9579 return _oxmidtunmetadata18masked, nil
9580}
9581
9582func NewOxmIdTunMetadata18Masked() *OxmIdTunMetadata18Masked {
9583 obj := &OxmIdTunMetadata18Masked{
9584 OxmId: NewOxmId(95736),
9585 }
9586 return obj
9587}
9588func (self *OxmIdTunMetadata18Masked) GetOXMName() string {
9589 return "tun_metadata18_masked"
9590}
9591
9592func (self *OxmIdTunMetadata18Masked) MarshalJSON() ([]byte, error) {
9593 if self.TypeLen == 0 {
9594 return []byte("\"\""), nil
9595 } else {
9596 return []byte("\"" + self.GetOXMName() + "\""), nil
9597 }
9598}
9599
9600type OxmIdTunMetadata19 struct {
9601 *OxmId
9602}
9603
9604type IOxmIdTunMetadata19 interface {
9605 IOxmId
9606}
9607
9608func (self *OxmIdTunMetadata19) Serialize(encoder *goloxi.Encoder) error {
9609 if err := self.OxmId.Serialize(encoder); err != nil {
9610 return err
9611 }
9612
9613 return nil
9614}
9615
9616func DecodeOxmIdTunMetadata19(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata19, error) {
9617 _oxmidtunmetadata19 := &OxmIdTunMetadata19{OxmId: parent}
9618 return _oxmidtunmetadata19, nil
9619}
9620
9621func NewOxmIdTunMetadata19() *OxmIdTunMetadata19 {
9622 obj := &OxmIdTunMetadata19{
9623 OxmId: NewOxmId(95868),
9624 }
9625 return obj
9626}
9627func (self *OxmIdTunMetadata19) GetOXMName() string {
9628 return "tun_metadata19"
9629}
9630
9631func (self *OxmIdTunMetadata19) MarshalJSON() ([]byte, error) {
9632 if self.TypeLen == 0 {
9633 return []byte("\"\""), nil
9634 } else {
9635 return []byte("\"" + self.GetOXMName() + "\""), nil
9636 }
9637}
9638
9639type OxmIdTunMetadata19Masked struct {
9640 *OxmId
9641}
9642
9643type IOxmIdTunMetadata19Masked interface {
9644 IOxmId
9645}
9646
9647func (self *OxmIdTunMetadata19Masked) Serialize(encoder *goloxi.Encoder) error {
9648 if err := self.OxmId.Serialize(encoder); err != nil {
9649 return err
9650 }
9651
9652 return nil
9653}
9654
9655func DecodeOxmIdTunMetadata19Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata19Masked, error) {
9656 _oxmidtunmetadata19masked := &OxmIdTunMetadata19Masked{OxmId: parent}
9657 return _oxmidtunmetadata19masked, nil
9658}
9659
9660func NewOxmIdTunMetadata19Masked() *OxmIdTunMetadata19Masked {
9661 obj := &OxmIdTunMetadata19Masked{
9662 OxmId: NewOxmId(96248),
9663 }
9664 return obj
9665}
9666func (self *OxmIdTunMetadata19Masked) GetOXMName() string {
9667 return "tun_metadata19_masked"
9668}
9669
9670func (self *OxmIdTunMetadata19Masked) MarshalJSON() ([]byte, error) {
9671 if self.TypeLen == 0 {
9672 return []byte("\"\""), nil
9673 } else {
9674 return []byte("\"" + self.GetOXMName() + "\""), nil
9675 }
9676}
9677
9678type OxmIdTunMetadata1Masked struct {
9679 *OxmId
9680}
9681
9682type IOxmIdTunMetadata1Masked interface {
9683 IOxmId
9684}
9685
9686func (self *OxmIdTunMetadata1Masked) Serialize(encoder *goloxi.Encoder) error {
9687 if err := self.OxmId.Serialize(encoder); err != nil {
9688 return err
9689 }
9690
9691 return nil
9692}
9693
9694func DecodeOxmIdTunMetadata1Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata1Masked, error) {
9695 _oxmidtunmetadata1masked := &OxmIdTunMetadata1Masked{OxmId: parent}
9696 return _oxmidtunmetadata1masked, nil
9697}
9698
9699func NewOxmIdTunMetadata1Masked() *OxmIdTunMetadata1Masked {
9700 obj := &OxmIdTunMetadata1Masked{
9701 OxmId: NewOxmId(87032),
9702 }
9703 return obj
9704}
9705func (self *OxmIdTunMetadata1Masked) GetOXMName() string {
9706 return "tun_metadata1_masked"
9707}
9708
9709func (self *OxmIdTunMetadata1Masked) MarshalJSON() ([]byte, error) {
9710 if self.TypeLen == 0 {
9711 return []byte("\"\""), nil
9712 } else {
9713 return []byte("\"" + self.GetOXMName() + "\""), nil
9714 }
9715}
9716
9717type OxmIdTunMetadata2 struct {
9718 *OxmId
9719}
9720
9721type IOxmIdTunMetadata2 interface {
9722 IOxmId
9723}
9724
9725func (self *OxmIdTunMetadata2) Serialize(encoder *goloxi.Encoder) error {
9726 if err := self.OxmId.Serialize(encoder); err != nil {
9727 return err
9728 }
9729
9730 return nil
9731}
9732
9733func DecodeOxmIdTunMetadata2(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata2, error) {
9734 _oxmidtunmetadata2 := &OxmIdTunMetadata2{OxmId: parent}
9735 return _oxmidtunmetadata2, nil
9736}
9737
9738func NewOxmIdTunMetadata2() *OxmIdTunMetadata2 {
9739 obj := &OxmIdTunMetadata2{
9740 OxmId: NewOxmId(87164),
9741 }
9742 return obj
9743}
9744func (self *OxmIdTunMetadata2) GetOXMName() string {
9745 return "tun_metadata2"
9746}
9747
9748func (self *OxmIdTunMetadata2) MarshalJSON() ([]byte, error) {
9749 if self.TypeLen == 0 {
9750 return []byte("\"\""), nil
9751 } else {
9752 return []byte("\"" + self.GetOXMName() + "\""), nil
9753 }
9754}
9755
9756type OxmIdTunMetadata20 struct {
9757 *OxmId
9758}
9759
9760type IOxmIdTunMetadata20 interface {
9761 IOxmId
9762}
9763
9764func (self *OxmIdTunMetadata20) Serialize(encoder *goloxi.Encoder) error {
9765 if err := self.OxmId.Serialize(encoder); err != nil {
9766 return err
9767 }
9768
9769 return nil
9770}
9771
9772func DecodeOxmIdTunMetadata20(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata20, error) {
9773 _oxmidtunmetadata20 := &OxmIdTunMetadata20{OxmId: parent}
9774 return _oxmidtunmetadata20, nil
9775}
9776
9777func NewOxmIdTunMetadata20() *OxmIdTunMetadata20 {
9778 obj := &OxmIdTunMetadata20{
9779 OxmId: NewOxmId(96380),
9780 }
9781 return obj
9782}
9783func (self *OxmIdTunMetadata20) GetOXMName() string {
9784 return "tun_metadata20"
9785}
9786
9787func (self *OxmIdTunMetadata20) MarshalJSON() ([]byte, error) {
9788 if self.TypeLen == 0 {
9789 return []byte("\"\""), nil
9790 } else {
9791 return []byte("\"" + self.GetOXMName() + "\""), nil
9792 }
9793}
9794
9795type OxmIdTunMetadata20Masked struct {
9796 *OxmId
9797}
9798
9799type IOxmIdTunMetadata20Masked interface {
9800 IOxmId
9801}
9802
9803func (self *OxmIdTunMetadata20Masked) Serialize(encoder *goloxi.Encoder) error {
9804 if err := self.OxmId.Serialize(encoder); err != nil {
9805 return err
9806 }
9807
9808 return nil
9809}
9810
9811func DecodeOxmIdTunMetadata20Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata20Masked, error) {
9812 _oxmidtunmetadata20masked := &OxmIdTunMetadata20Masked{OxmId: parent}
9813 return _oxmidtunmetadata20masked, nil
9814}
9815
9816func NewOxmIdTunMetadata20Masked() *OxmIdTunMetadata20Masked {
9817 obj := &OxmIdTunMetadata20Masked{
9818 OxmId: NewOxmId(96760),
9819 }
9820 return obj
9821}
9822func (self *OxmIdTunMetadata20Masked) GetOXMName() string {
9823 return "tun_metadata20_masked"
9824}
9825
9826func (self *OxmIdTunMetadata20Masked) MarshalJSON() ([]byte, error) {
9827 if self.TypeLen == 0 {
9828 return []byte("\"\""), nil
9829 } else {
9830 return []byte("\"" + self.GetOXMName() + "\""), nil
9831 }
9832}
9833
9834type OxmIdTunMetadata21 struct {
9835 *OxmId
9836}
9837
9838type IOxmIdTunMetadata21 interface {
9839 IOxmId
9840}
9841
9842func (self *OxmIdTunMetadata21) Serialize(encoder *goloxi.Encoder) error {
9843 if err := self.OxmId.Serialize(encoder); err != nil {
9844 return err
9845 }
9846
9847 return nil
9848}
9849
9850func DecodeOxmIdTunMetadata21(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata21, error) {
9851 _oxmidtunmetadata21 := &OxmIdTunMetadata21{OxmId: parent}
9852 return _oxmidtunmetadata21, nil
9853}
9854
9855func NewOxmIdTunMetadata21() *OxmIdTunMetadata21 {
9856 obj := &OxmIdTunMetadata21{
9857 OxmId: NewOxmId(96892),
9858 }
9859 return obj
9860}
9861func (self *OxmIdTunMetadata21) GetOXMName() string {
9862 return "tun_metadata21"
9863}
9864
9865func (self *OxmIdTunMetadata21) MarshalJSON() ([]byte, error) {
9866 if self.TypeLen == 0 {
9867 return []byte("\"\""), nil
9868 } else {
9869 return []byte("\"" + self.GetOXMName() + "\""), nil
9870 }
9871}
9872
9873type OxmIdTunMetadata21Masked struct {
9874 *OxmId
9875}
9876
9877type IOxmIdTunMetadata21Masked interface {
9878 IOxmId
9879}
9880
9881func (self *OxmIdTunMetadata21Masked) Serialize(encoder *goloxi.Encoder) error {
9882 if err := self.OxmId.Serialize(encoder); err != nil {
9883 return err
9884 }
9885
9886 return nil
9887}
9888
9889func DecodeOxmIdTunMetadata21Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata21Masked, error) {
9890 _oxmidtunmetadata21masked := &OxmIdTunMetadata21Masked{OxmId: parent}
9891 return _oxmidtunmetadata21masked, nil
9892}
9893
9894func NewOxmIdTunMetadata21Masked() *OxmIdTunMetadata21Masked {
9895 obj := &OxmIdTunMetadata21Masked{
9896 OxmId: NewOxmId(97272),
9897 }
9898 return obj
9899}
9900func (self *OxmIdTunMetadata21Masked) GetOXMName() string {
9901 return "tun_metadata21_masked"
9902}
9903
9904func (self *OxmIdTunMetadata21Masked) MarshalJSON() ([]byte, error) {
9905 if self.TypeLen == 0 {
9906 return []byte("\"\""), nil
9907 } else {
9908 return []byte("\"" + self.GetOXMName() + "\""), nil
9909 }
9910}
9911
9912type OxmIdTunMetadata22 struct {
9913 *OxmId
9914}
9915
9916type IOxmIdTunMetadata22 interface {
9917 IOxmId
9918}
9919
9920func (self *OxmIdTunMetadata22) Serialize(encoder *goloxi.Encoder) error {
9921 if err := self.OxmId.Serialize(encoder); err != nil {
9922 return err
9923 }
9924
9925 return nil
9926}
9927
9928func DecodeOxmIdTunMetadata22(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata22, error) {
9929 _oxmidtunmetadata22 := &OxmIdTunMetadata22{OxmId: parent}
9930 return _oxmidtunmetadata22, nil
9931}
9932
9933func NewOxmIdTunMetadata22() *OxmIdTunMetadata22 {
9934 obj := &OxmIdTunMetadata22{
9935 OxmId: NewOxmId(97404),
9936 }
9937 return obj
9938}
9939func (self *OxmIdTunMetadata22) GetOXMName() string {
9940 return "tun_metadata22"
9941}
9942
9943func (self *OxmIdTunMetadata22) MarshalJSON() ([]byte, error) {
9944 if self.TypeLen == 0 {
9945 return []byte("\"\""), nil
9946 } else {
9947 return []byte("\"" + self.GetOXMName() + "\""), nil
9948 }
9949}
9950
9951type OxmIdTunMetadata22Masked struct {
9952 *OxmId
9953}
9954
9955type IOxmIdTunMetadata22Masked interface {
9956 IOxmId
9957}
9958
9959func (self *OxmIdTunMetadata22Masked) Serialize(encoder *goloxi.Encoder) error {
9960 if err := self.OxmId.Serialize(encoder); err != nil {
9961 return err
9962 }
9963
9964 return nil
9965}
9966
9967func DecodeOxmIdTunMetadata22Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata22Masked, error) {
9968 _oxmidtunmetadata22masked := &OxmIdTunMetadata22Masked{OxmId: parent}
9969 return _oxmidtunmetadata22masked, nil
9970}
9971
9972func NewOxmIdTunMetadata22Masked() *OxmIdTunMetadata22Masked {
9973 obj := &OxmIdTunMetadata22Masked{
9974 OxmId: NewOxmId(97784),
9975 }
9976 return obj
9977}
9978func (self *OxmIdTunMetadata22Masked) GetOXMName() string {
9979 return "tun_metadata22_masked"
9980}
9981
9982func (self *OxmIdTunMetadata22Masked) MarshalJSON() ([]byte, error) {
9983 if self.TypeLen == 0 {
9984 return []byte("\"\""), nil
9985 } else {
9986 return []byte("\"" + self.GetOXMName() + "\""), nil
9987 }
9988}
9989
9990type OxmIdTunMetadata23 struct {
9991 *OxmId
9992}
9993
9994type IOxmIdTunMetadata23 interface {
9995 IOxmId
9996}
9997
9998func (self *OxmIdTunMetadata23) Serialize(encoder *goloxi.Encoder) error {
9999 if err := self.OxmId.Serialize(encoder); err != nil {
10000 return err
10001 }
10002
10003 return nil
10004}
10005
10006func DecodeOxmIdTunMetadata23(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata23, error) {
10007 _oxmidtunmetadata23 := &OxmIdTunMetadata23{OxmId: parent}
10008 return _oxmidtunmetadata23, nil
10009}
10010
10011func NewOxmIdTunMetadata23() *OxmIdTunMetadata23 {
10012 obj := &OxmIdTunMetadata23{
10013 OxmId: NewOxmId(97916),
10014 }
10015 return obj
10016}
10017func (self *OxmIdTunMetadata23) GetOXMName() string {
10018 return "tun_metadata23"
10019}
10020
10021func (self *OxmIdTunMetadata23) MarshalJSON() ([]byte, error) {
10022 if self.TypeLen == 0 {
10023 return []byte("\"\""), nil
10024 } else {
10025 return []byte("\"" + self.GetOXMName() + "\""), nil
10026 }
10027}
10028
10029type OxmIdTunMetadata23Masked struct {
10030 *OxmId
10031}
10032
10033type IOxmIdTunMetadata23Masked interface {
10034 IOxmId
10035}
10036
10037func (self *OxmIdTunMetadata23Masked) Serialize(encoder *goloxi.Encoder) error {
10038 if err := self.OxmId.Serialize(encoder); err != nil {
10039 return err
10040 }
10041
10042 return nil
10043}
10044
10045func DecodeOxmIdTunMetadata23Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata23Masked, error) {
10046 _oxmidtunmetadata23masked := &OxmIdTunMetadata23Masked{OxmId: parent}
10047 return _oxmidtunmetadata23masked, nil
10048}
10049
10050func NewOxmIdTunMetadata23Masked() *OxmIdTunMetadata23Masked {
10051 obj := &OxmIdTunMetadata23Masked{
10052 OxmId: NewOxmId(98296),
10053 }
10054 return obj
10055}
10056func (self *OxmIdTunMetadata23Masked) GetOXMName() string {
10057 return "tun_metadata23_masked"
10058}
10059
10060func (self *OxmIdTunMetadata23Masked) MarshalJSON() ([]byte, error) {
10061 if self.TypeLen == 0 {
10062 return []byte("\"\""), nil
10063 } else {
10064 return []byte("\"" + self.GetOXMName() + "\""), nil
10065 }
10066}
10067
10068type OxmIdTunMetadata24 struct {
10069 *OxmId
10070}
10071
10072type IOxmIdTunMetadata24 interface {
10073 IOxmId
10074}
10075
10076func (self *OxmIdTunMetadata24) Serialize(encoder *goloxi.Encoder) error {
10077 if err := self.OxmId.Serialize(encoder); err != nil {
10078 return err
10079 }
10080
10081 return nil
10082}
10083
10084func DecodeOxmIdTunMetadata24(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata24, error) {
10085 _oxmidtunmetadata24 := &OxmIdTunMetadata24{OxmId: parent}
10086 return _oxmidtunmetadata24, nil
10087}
10088
10089func NewOxmIdTunMetadata24() *OxmIdTunMetadata24 {
10090 obj := &OxmIdTunMetadata24{
10091 OxmId: NewOxmId(98428),
10092 }
10093 return obj
10094}
10095func (self *OxmIdTunMetadata24) GetOXMName() string {
10096 return "tun_metadata24"
10097}
10098
10099func (self *OxmIdTunMetadata24) MarshalJSON() ([]byte, error) {
10100 if self.TypeLen == 0 {
10101 return []byte("\"\""), nil
10102 } else {
10103 return []byte("\"" + self.GetOXMName() + "\""), nil
10104 }
10105}
10106
10107type OxmIdTunMetadata24Masked struct {
10108 *OxmId
10109}
10110
10111type IOxmIdTunMetadata24Masked interface {
10112 IOxmId
10113}
10114
10115func (self *OxmIdTunMetadata24Masked) Serialize(encoder *goloxi.Encoder) error {
10116 if err := self.OxmId.Serialize(encoder); err != nil {
10117 return err
10118 }
10119
10120 return nil
10121}
10122
10123func DecodeOxmIdTunMetadata24Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata24Masked, error) {
10124 _oxmidtunmetadata24masked := &OxmIdTunMetadata24Masked{OxmId: parent}
10125 return _oxmidtunmetadata24masked, nil
10126}
10127
10128func NewOxmIdTunMetadata24Masked() *OxmIdTunMetadata24Masked {
10129 obj := &OxmIdTunMetadata24Masked{
10130 OxmId: NewOxmId(98808),
10131 }
10132 return obj
10133}
10134func (self *OxmIdTunMetadata24Masked) GetOXMName() string {
10135 return "tun_metadata24_masked"
10136}
10137
10138func (self *OxmIdTunMetadata24Masked) MarshalJSON() ([]byte, error) {
10139 if self.TypeLen == 0 {
10140 return []byte("\"\""), nil
10141 } else {
10142 return []byte("\"" + self.GetOXMName() + "\""), nil
10143 }
10144}
10145
10146type OxmIdTunMetadata25 struct {
10147 *OxmId
10148}
10149
10150type IOxmIdTunMetadata25 interface {
10151 IOxmId
10152}
10153
10154func (self *OxmIdTunMetadata25) Serialize(encoder *goloxi.Encoder) error {
10155 if err := self.OxmId.Serialize(encoder); err != nil {
10156 return err
10157 }
10158
10159 return nil
10160}
10161
10162func DecodeOxmIdTunMetadata25(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata25, error) {
10163 _oxmidtunmetadata25 := &OxmIdTunMetadata25{OxmId: parent}
10164 return _oxmidtunmetadata25, nil
10165}
10166
10167func NewOxmIdTunMetadata25() *OxmIdTunMetadata25 {
10168 obj := &OxmIdTunMetadata25{
10169 OxmId: NewOxmId(98940),
10170 }
10171 return obj
10172}
10173func (self *OxmIdTunMetadata25) GetOXMName() string {
10174 return "tun_metadata25"
10175}
10176
10177func (self *OxmIdTunMetadata25) MarshalJSON() ([]byte, error) {
10178 if self.TypeLen == 0 {
10179 return []byte("\"\""), nil
10180 } else {
10181 return []byte("\"" + self.GetOXMName() + "\""), nil
10182 }
10183}
10184
10185type OxmIdTunMetadata25Masked struct {
10186 *OxmId
10187}
10188
10189type IOxmIdTunMetadata25Masked interface {
10190 IOxmId
10191}
10192
10193func (self *OxmIdTunMetadata25Masked) Serialize(encoder *goloxi.Encoder) error {
10194 if err := self.OxmId.Serialize(encoder); err != nil {
10195 return err
10196 }
10197
10198 return nil
10199}
10200
10201func DecodeOxmIdTunMetadata25Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata25Masked, error) {
10202 _oxmidtunmetadata25masked := &OxmIdTunMetadata25Masked{OxmId: parent}
10203 return _oxmidtunmetadata25masked, nil
10204}
10205
10206func NewOxmIdTunMetadata25Masked() *OxmIdTunMetadata25Masked {
10207 obj := &OxmIdTunMetadata25Masked{
10208 OxmId: NewOxmId(99320),
10209 }
10210 return obj
10211}
10212func (self *OxmIdTunMetadata25Masked) GetOXMName() string {
10213 return "tun_metadata25_masked"
10214}
10215
10216func (self *OxmIdTunMetadata25Masked) MarshalJSON() ([]byte, error) {
10217 if self.TypeLen == 0 {
10218 return []byte("\"\""), nil
10219 } else {
10220 return []byte("\"" + self.GetOXMName() + "\""), nil
10221 }
10222}
10223
10224type OxmIdTunMetadata26 struct {
10225 *OxmId
10226}
10227
10228type IOxmIdTunMetadata26 interface {
10229 IOxmId
10230}
10231
10232func (self *OxmIdTunMetadata26) Serialize(encoder *goloxi.Encoder) error {
10233 if err := self.OxmId.Serialize(encoder); err != nil {
10234 return err
10235 }
10236
10237 return nil
10238}
10239
10240func DecodeOxmIdTunMetadata26(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata26, error) {
10241 _oxmidtunmetadata26 := &OxmIdTunMetadata26{OxmId: parent}
10242 return _oxmidtunmetadata26, nil
10243}
10244
10245func NewOxmIdTunMetadata26() *OxmIdTunMetadata26 {
10246 obj := &OxmIdTunMetadata26{
10247 OxmId: NewOxmId(99452),
10248 }
10249 return obj
10250}
10251func (self *OxmIdTunMetadata26) GetOXMName() string {
10252 return "tun_metadata26"
10253}
10254
10255func (self *OxmIdTunMetadata26) MarshalJSON() ([]byte, error) {
10256 if self.TypeLen == 0 {
10257 return []byte("\"\""), nil
10258 } else {
10259 return []byte("\"" + self.GetOXMName() + "\""), nil
10260 }
10261}
10262
10263type OxmIdTunMetadata26Masked struct {
10264 *OxmId
10265}
10266
10267type IOxmIdTunMetadata26Masked interface {
10268 IOxmId
10269}
10270
10271func (self *OxmIdTunMetadata26Masked) Serialize(encoder *goloxi.Encoder) error {
10272 if err := self.OxmId.Serialize(encoder); err != nil {
10273 return err
10274 }
10275
10276 return nil
10277}
10278
10279func DecodeOxmIdTunMetadata26Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata26Masked, error) {
10280 _oxmidtunmetadata26masked := &OxmIdTunMetadata26Masked{OxmId: parent}
10281 return _oxmidtunmetadata26masked, nil
10282}
10283
10284func NewOxmIdTunMetadata26Masked() *OxmIdTunMetadata26Masked {
10285 obj := &OxmIdTunMetadata26Masked{
10286 OxmId: NewOxmId(99832),
10287 }
10288 return obj
10289}
10290func (self *OxmIdTunMetadata26Masked) GetOXMName() string {
10291 return "tun_metadata26_masked"
10292}
10293
10294func (self *OxmIdTunMetadata26Masked) MarshalJSON() ([]byte, error) {
10295 if self.TypeLen == 0 {
10296 return []byte("\"\""), nil
10297 } else {
10298 return []byte("\"" + self.GetOXMName() + "\""), nil
10299 }
10300}
10301
10302type OxmIdTunMetadata27 struct {
10303 *OxmId
10304}
10305
10306type IOxmIdTunMetadata27 interface {
10307 IOxmId
10308}
10309
10310func (self *OxmIdTunMetadata27) Serialize(encoder *goloxi.Encoder) error {
10311 if err := self.OxmId.Serialize(encoder); err != nil {
10312 return err
10313 }
10314
10315 return nil
10316}
10317
10318func DecodeOxmIdTunMetadata27(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata27, error) {
10319 _oxmidtunmetadata27 := &OxmIdTunMetadata27{OxmId: parent}
10320 return _oxmidtunmetadata27, nil
10321}
10322
10323func NewOxmIdTunMetadata27() *OxmIdTunMetadata27 {
10324 obj := &OxmIdTunMetadata27{
10325 OxmId: NewOxmId(99964),
10326 }
10327 return obj
10328}
10329func (self *OxmIdTunMetadata27) GetOXMName() string {
10330 return "tun_metadata27"
10331}
10332
10333func (self *OxmIdTunMetadata27) MarshalJSON() ([]byte, error) {
10334 if self.TypeLen == 0 {
10335 return []byte("\"\""), nil
10336 } else {
10337 return []byte("\"" + self.GetOXMName() + "\""), nil
10338 }
10339}
10340
10341type OxmIdTunMetadata27Masked struct {
10342 *OxmId
10343}
10344
10345type IOxmIdTunMetadata27Masked interface {
10346 IOxmId
10347}
10348
10349func (self *OxmIdTunMetadata27Masked) Serialize(encoder *goloxi.Encoder) error {
10350 if err := self.OxmId.Serialize(encoder); err != nil {
10351 return err
10352 }
10353
10354 return nil
10355}
10356
10357func DecodeOxmIdTunMetadata27Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata27Masked, error) {
10358 _oxmidtunmetadata27masked := &OxmIdTunMetadata27Masked{OxmId: parent}
10359 return _oxmidtunmetadata27masked, nil
10360}
10361
10362func NewOxmIdTunMetadata27Masked() *OxmIdTunMetadata27Masked {
10363 obj := &OxmIdTunMetadata27Masked{
10364 OxmId: NewOxmId(100344),
10365 }
10366 return obj
10367}
10368func (self *OxmIdTunMetadata27Masked) GetOXMName() string {
10369 return "tun_metadata27_masked"
10370}
10371
10372func (self *OxmIdTunMetadata27Masked) MarshalJSON() ([]byte, error) {
10373 if self.TypeLen == 0 {
10374 return []byte("\"\""), nil
10375 } else {
10376 return []byte("\"" + self.GetOXMName() + "\""), nil
10377 }
10378}
10379
10380type OxmIdTunMetadata28 struct {
10381 *OxmId
10382}
10383
10384type IOxmIdTunMetadata28 interface {
10385 IOxmId
10386}
10387
10388func (self *OxmIdTunMetadata28) Serialize(encoder *goloxi.Encoder) error {
10389 if err := self.OxmId.Serialize(encoder); err != nil {
10390 return err
10391 }
10392
10393 return nil
10394}
10395
10396func DecodeOxmIdTunMetadata28(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata28, error) {
10397 _oxmidtunmetadata28 := &OxmIdTunMetadata28{OxmId: parent}
10398 return _oxmidtunmetadata28, nil
10399}
10400
10401func NewOxmIdTunMetadata28() *OxmIdTunMetadata28 {
10402 obj := &OxmIdTunMetadata28{
10403 OxmId: NewOxmId(100476),
10404 }
10405 return obj
10406}
10407func (self *OxmIdTunMetadata28) GetOXMName() string {
10408 return "tun_metadata28"
10409}
10410
10411func (self *OxmIdTunMetadata28) MarshalJSON() ([]byte, error) {
10412 if self.TypeLen == 0 {
10413 return []byte("\"\""), nil
10414 } else {
10415 return []byte("\"" + self.GetOXMName() + "\""), nil
10416 }
10417}
10418
10419type OxmIdTunMetadata28Masked struct {
10420 *OxmId
10421}
10422
10423type IOxmIdTunMetadata28Masked interface {
10424 IOxmId
10425}
10426
10427func (self *OxmIdTunMetadata28Masked) Serialize(encoder *goloxi.Encoder) error {
10428 if err := self.OxmId.Serialize(encoder); err != nil {
10429 return err
10430 }
10431
10432 return nil
10433}
10434
10435func DecodeOxmIdTunMetadata28Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata28Masked, error) {
10436 _oxmidtunmetadata28masked := &OxmIdTunMetadata28Masked{OxmId: parent}
10437 return _oxmidtunmetadata28masked, nil
10438}
10439
10440func NewOxmIdTunMetadata28Masked() *OxmIdTunMetadata28Masked {
10441 obj := &OxmIdTunMetadata28Masked{
10442 OxmId: NewOxmId(100856),
10443 }
10444 return obj
10445}
10446func (self *OxmIdTunMetadata28Masked) GetOXMName() string {
10447 return "tun_metadata28_masked"
10448}
10449
10450func (self *OxmIdTunMetadata28Masked) MarshalJSON() ([]byte, error) {
10451 if self.TypeLen == 0 {
10452 return []byte("\"\""), nil
10453 } else {
10454 return []byte("\"" + self.GetOXMName() + "\""), nil
10455 }
10456}
10457
10458type OxmIdTunMetadata29 struct {
10459 *OxmId
10460}
10461
10462type IOxmIdTunMetadata29 interface {
10463 IOxmId
10464}
10465
10466func (self *OxmIdTunMetadata29) Serialize(encoder *goloxi.Encoder) error {
10467 if err := self.OxmId.Serialize(encoder); err != nil {
10468 return err
10469 }
10470
10471 return nil
10472}
10473
10474func DecodeOxmIdTunMetadata29(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata29, error) {
10475 _oxmidtunmetadata29 := &OxmIdTunMetadata29{OxmId: parent}
10476 return _oxmidtunmetadata29, nil
10477}
10478
10479func NewOxmIdTunMetadata29() *OxmIdTunMetadata29 {
10480 obj := &OxmIdTunMetadata29{
10481 OxmId: NewOxmId(100988),
10482 }
10483 return obj
10484}
10485func (self *OxmIdTunMetadata29) GetOXMName() string {
10486 return "tun_metadata29"
10487}
10488
10489func (self *OxmIdTunMetadata29) MarshalJSON() ([]byte, error) {
10490 if self.TypeLen == 0 {
10491 return []byte("\"\""), nil
10492 } else {
10493 return []byte("\"" + self.GetOXMName() + "\""), nil
10494 }
10495}
10496
10497type OxmIdTunMetadata29Masked struct {
10498 *OxmId
10499}
10500
10501type IOxmIdTunMetadata29Masked interface {
10502 IOxmId
10503}
10504
10505func (self *OxmIdTunMetadata29Masked) Serialize(encoder *goloxi.Encoder) error {
10506 if err := self.OxmId.Serialize(encoder); err != nil {
10507 return err
10508 }
10509
10510 return nil
10511}
10512
10513func DecodeOxmIdTunMetadata29Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata29Masked, error) {
10514 _oxmidtunmetadata29masked := &OxmIdTunMetadata29Masked{OxmId: parent}
10515 return _oxmidtunmetadata29masked, nil
10516}
10517
10518func NewOxmIdTunMetadata29Masked() *OxmIdTunMetadata29Masked {
10519 obj := &OxmIdTunMetadata29Masked{
10520 OxmId: NewOxmId(101368),
10521 }
10522 return obj
10523}
10524func (self *OxmIdTunMetadata29Masked) GetOXMName() string {
10525 return "tun_metadata29_masked"
10526}
10527
10528func (self *OxmIdTunMetadata29Masked) MarshalJSON() ([]byte, error) {
10529 if self.TypeLen == 0 {
10530 return []byte("\"\""), nil
10531 } else {
10532 return []byte("\"" + self.GetOXMName() + "\""), nil
10533 }
10534}
10535
10536type OxmIdTunMetadata2Masked struct {
10537 *OxmId
10538}
10539
10540type IOxmIdTunMetadata2Masked interface {
10541 IOxmId
10542}
10543
10544func (self *OxmIdTunMetadata2Masked) Serialize(encoder *goloxi.Encoder) error {
10545 if err := self.OxmId.Serialize(encoder); err != nil {
10546 return err
10547 }
10548
10549 return nil
10550}
10551
10552func DecodeOxmIdTunMetadata2Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata2Masked, error) {
10553 _oxmidtunmetadata2masked := &OxmIdTunMetadata2Masked{OxmId: parent}
10554 return _oxmidtunmetadata2masked, nil
10555}
10556
10557func NewOxmIdTunMetadata2Masked() *OxmIdTunMetadata2Masked {
10558 obj := &OxmIdTunMetadata2Masked{
10559 OxmId: NewOxmId(87544),
10560 }
10561 return obj
10562}
10563func (self *OxmIdTunMetadata2Masked) GetOXMName() string {
10564 return "tun_metadata2_masked"
10565}
10566
10567func (self *OxmIdTunMetadata2Masked) MarshalJSON() ([]byte, error) {
10568 if self.TypeLen == 0 {
10569 return []byte("\"\""), nil
10570 } else {
10571 return []byte("\"" + self.GetOXMName() + "\""), nil
10572 }
10573}
10574
10575type OxmIdTunMetadata3 struct {
10576 *OxmId
10577}
10578
10579type IOxmIdTunMetadata3 interface {
10580 IOxmId
10581}
10582
10583func (self *OxmIdTunMetadata3) Serialize(encoder *goloxi.Encoder) error {
10584 if err := self.OxmId.Serialize(encoder); err != nil {
10585 return err
10586 }
10587
10588 return nil
10589}
10590
10591func DecodeOxmIdTunMetadata3(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata3, error) {
10592 _oxmidtunmetadata3 := &OxmIdTunMetadata3{OxmId: parent}
10593 return _oxmidtunmetadata3, nil
10594}
10595
10596func NewOxmIdTunMetadata3() *OxmIdTunMetadata3 {
10597 obj := &OxmIdTunMetadata3{
10598 OxmId: NewOxmId(87676),
10599 }
10600 return obj
10601}
10602func (self *OxmIdTunMetadata3) GetOXMName() string {
10603 return "tun_metadata3"
10604}
10605
10606func (self *OxmIdTunMetadata3) MarshalJSON() ([]byte, error) {
10607 if self.TypeLen == 0 {
10608 return []byte("\"\""), nil
10609 } else {
10610 return []byte("\"" + self.GetOXMName() + "\""), nil
10611 }
10612}
10613
10614type OxmIdTunMetadata30 struct {
10615 *OxmId
10616}
10617
10618type IOxmIdTunMetadata30 interface {
10619 IOxmId
10620}
10621
10622func (self *OxmIdTunMetadata30) Serialize(encoder *goloxi.Encoder) error {
10623 if err := self.OxmId.Serialize(encoder); err != nil {
10624 return err
10625 }
10626
10627 return nil
10628}
10629
10630func DecodeOxmIdTunMetadata30(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata30, error) {
10631 _oxmidtunmetadata30 := &OxmIdTunMetadata30{OxmId: parent}
10632 return _oxmidtunmetadata30, nil
10633}
10634
10635func NewOxmIdTunMetadata30() *OxmIdTunMetadata30 {
10636 obj := &OxmIdTunMetadata30{
10637 OxmId: NewOxmId(101500),
10638 }
10639 return obj
10640}
10641func (self *OxmIdTunMetadata30) GetOXMName() string {
10642 return "tun_metadata30"
10643}
10644
10645func (self *OxmIdTunMetadata30) MarshalJSON() ([]byte, error) {
10646 if self.TypeLen == 0 {
10647 return []byte("\"\""), nil
10648 } else {
10649 return []byte("\"" + self.GetOXMName() + "\""), nil
10650 }
10651}
10652
10653type OxmIdTunMetadata30Masked struct {
10654 *OxmId
10655}
10656
10657type IOxmIdTunMetadata30Masked interface {
10658 IOxmId
10659}
10660
10661func (self *OxmIdTunMetadata30Masked) Serialize(encoder *goloxi.Encoder) error {
10662 if err := self.OxmId.Serialize(encoder); err != nil {
10663 return err
10664 }
10665
10666 return nil
10667}
10668
10669func DecodeOxmIdTunMetadata30Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata30Masked, error) {
10670 _oxmidtunmetadata30masked := &OxmIdTunMetadata30Masked{OxmId: parent}
10671 return _oxmidtunmetadata30masked, nil
10672}
10673
10674func NewOxmIdTunMetadata30Masked() *OxmIdTunMetadata30Masked {
10675 obj := &OxmIdTunMetadata30Masked{
10676 OxmId: NewOxmId(101880),
10677 }
10678 return obj
10679}
10680func (self *OxmIdTunMetadata30Masked) GetOXMName() string {
10681 return "tun_metadata30_masked"
10682}
10683
10684func (self *OxmIdTunMetadata30Masked) MarshalJSON() ([]byte, error) {
10685 if self.TypeLen == 0 {
10686 return []byte("\"\""), nil
10687 } else {
10688 return []byte("\"" + self.GetOXMName() + "\""), nil
10689 }
10690}
10691
10692type OxmIdTunMetadata31 struct {
10693 *OxmId
10694}
10695
10696type IOxmIdTunMetadata31 interface {
10697 IOxmId
10698}
10699
10700func (self *OxmIdTunMetadata31) Serialize(encoder *goloxi.Encoder) error {
10701 if err := self.OxmId.Serialize(encoder); err != nil {
10702 return err
10703 }
10704
10705 return nil
10706}
10707
10708func DecodeOxmIdTunMetadata31(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata31, error) {
10709 _oxmidtunmetadata31 := &OxmIdTunMetadata31{OxmId: parent}
10710 return _oxmidtunmetadata31, nil
10711}
10712
10713func NewOxmIdTunMetadata31() *OxmIdTunMetadata31 {
10714 obj := &OxmIdTunMetadata31{
10715 OxmId: NewOxmId(102012),
10716 }
10717 return obj
10718}
10719func (self *OxmIdTunMetadata31) GetOXMName() string {
10720 return "tun_metadata31"
10721}
10722
10723func (self *OxmIdTunMetadata31) MarshalJSON() ([]byte, error) {
10724 if self.TypeLen == 0 {
10725 return []byte("\"\""), nil
10726 } else {
10727 return []byte("\"" + self.GetOXMName() + "\""), nil
10728 }
10729}
10730
10731type OxmIdTunMetadata31Masked struct {
10732 *OxmId
10733}
10734
10735type IOxmIdTunMetadata31Masked interface {
10736 IOxmId
10737}
10738
10739func (self *OxmIdTunMetadata31Masked) Serialize(encoder *goloxi.Encoder) error {
10740 if err := self.OxmId.Serialize(encoder); err != nil {
10741 return err
10742 }
10743
10744 return nil
10745}
10746
10747func DecodeOxmIdTunMetadata31Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata31Masked, error) {
10748 _oxmidtunmetadata31masked := &OxmIdTunMetadata31Masked{OxmId: parent}
10749 return _oxmidtunmetadata31masked, nil
10750}
10751
10752func NewOxmIdTunMetadata31Masked() *OxmIdTunMetadata31Masked {
10753 obj := &OxmIdTunMetadata31Masked{
10754 OxmId: NewOxmId(102392),
10755 }
10756 return obj
10757}
10758func (self *OxmIdTunMetadata31Masked) GetOXMName() string {
10759 return "tun_metadata31_masked"
10760}
10761
10762func (self *OxmIdTunMetadata31Masked) MarshalJSON() ([]byte, error) {
10763 if self.TypeLen == 0 {
10764 return []byte("\"\""), nil
10765 } else {
10766 return []byte("\"" + self.GetOXMName() + "\""), nil
10767 }
10768}
10769
10770type OxmIdTunMetadata32 struct {
10771 *OxmId
10772}
10773
10774type IOxmIdTunMetadata32 interface {
10775 IOxmId
10776}
10777
10778func (self *OxmIdTunMetadata32) Serialize(encoder *goloxi.Encoder) error {
10779 if err := self.OxmId.Serialize(encoder); err != nil {
10780 return err
10781 }
10782
10783 return nil
10784}
10785
10786func DecodeOxmIdTunMetadata32(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata32, error) {
10787 _oxmidtunmetadata32 := &OxmIdTunMetadata32{OxmId: parent}
10788 return _oxmidtunmetadata32, nil
10789}
10790
10791func NewOxmIdTunMetadata32() *OxmIdTunMetadata32 {
10792 obj := &OxmIdTunMetadata32{
10793 OxmId: NewOxmId(102524),
10794 }
10795 return obj
10796}
10797func (self *OxmIdTunMetadata32) GetOXMName() string {
10798 return "tun_metadata32"
10799}
10800
10801func (self *OxmIdTunMetadata32) MarshalJSON() ([]byte, error) {
10802 if self.TypeLen == 0 {
10803 return []byte("\"\""), nil
10804 } else {
10805 return []byte("\"" + self.GetOXMName() + "\""), nil
10806 }
10807}
10808
10809type OxmIdTunMetadata32Masked struct {
10810 *OxmId
10811}
10812
10813type IOxmIdTunMetadata32Masked interface {
10814 IOxmId
10815}
10816
10817func (self *OxmIdTunMetadata32Masked) Serialize(encoder *goloxi.Encoder) error {
10818 if err := self.OxmId.Serialize(encoder); err != nil {
10819 return err
10820 }
10821
10822 return nil
10823}
10824
10825func DecodeOxmIdTunMetadata32Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata32Masked, error) {
10826 _oxmidtunmetadata32masked := &OxmIdTunMetadata32Masked{OxmId: parent}
10827 return _oxmidtunmetadata32masked, nil
10828}
10829
10830func NewOxmIdTunMetadata32Masked() *OxmIdTunMetadata32Masked {
10831 obj := &OxmIdTunMetadata32Masked{
10832 OxmId: NewOxmId(102904),
10833 }
10834 return obj
10835}
10836func (self *OxmIdTunMetadata32Masked) GetOXMName() string {
10837 return "tun_metadata32_masked"
10838}
10839
10840func (self *OxmIdTunMetadata32Masked) MarshalJSON() ([]byte, error) {
10841 if self.TypeLen == 0 {
10842 return []byte("\"\""), nil
10843 } else {
10844 return []byte("\"" + self.GetOXMName() + "\""), nil
10845 }
10846}
10847
10848type OxmIdTunMetadata33 struct {
10849 *OxmId
10850}
10851
10852type IOxmIdTunMetadata33 interface {
10853 IOxmId
10854}
10855
10856func (self *OxmIdTunMetadata33) Serialize(encoder *goloxi.Encoder) error {
10857 if err := self.OxmId.Serialize(encoder); err != nil {
10858 return err
10859 }
10860
10861 return nil
10862}
10863
10864func DecodeOxmIdTunMetadata33(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata33, error) {
10865 _oxmidtunmetadata33 := &OxmIdTunMetadata33{OxmId: parent}
10866 return _oxmidtunmetadata33, nil
10867}
10868
10869func NewOxmIdTunMetadata33() *OxmIdTunMetadata33 {
10870 obj := &OxmIdTunMetadata33{
10871 OxmId: NewOxmId(103036),
10872 }
10873 return obj
10874}
10875func (self *OxmIdTunMetadata33) GetOXMName() string {
10876 return "tun_metadata33"
10877}
10878
10879func (self *OxmIdTunMetadata33) MarshalJSON() ([]byte, error) {
10880 if self.TypeLen == 0 {
10881 return []byte("\"\""), nil
10882 } else {
10883 return []byte("\"" + self.GetOXMName() + "\""), nil
10884 }
10885}
10886
10887type OxmIdTunMetadata33Masked struct {
10888 *OxmId
10889}
10890
10891type IOxmIdTunMetadata33Masked interface {
10892 IOxmId
10893}
10894
10895func (self *OxmIdTunMetadata33Masked) Serialize(encoder *goloxi.Encoder) error {
10896 if err := self.OxmId.Serialize(encoder); err != nil {
10897 return err
10898 }
10899
10900 return nil
10901}
10902
10903func DecodeOxmIdTunMetadata33Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata33Masked, error) {
10904 _oxmidtunmetadata33masked := &OxmIdTunMetadata33Masked{OxmId: parent}
10905 return _oxmidtunmetadata33masked, nil
10906}
10907
10908func NewOxmIdTunMetadata33Masked() *OxmIdTunMetadata33Masked {
10909 obj := &OxmIdTunMetadata33Masked{
10910 OxmId: NewOxmId(103416),
10911 }
10912 return obj
10913}
10914func (self *OxmIdTunMetadata33Masked) GetOXMName() string {
10915 return "tun_metadata33_masked"
10916}
10917
10918func (self *OxmIdTunMetadata33Masked) MarshalJSON() ([]byte, error) {
10919 if self.TypeLen == 0 {
10920 return []byte("\"\""), nil
10921 } else {
10922 return []byte("\"" + self.GetOXMName() + "\""), nil
10923 }
10924}
10925
10926type OxmIdTunMetadata34 struct {
10927 *OxmId
10928}
10929
10930type IOxmIdTunMetadata34 interface {
10931 IOxmId
10932}
10933
10934func (self *OxmIdTunMetadata34) Serialize(encoder *goloxi.Encoder) error {
10935 if err := self.OxmId.Serialize(encoder); err != nil {
10936 return err
10937 }
10938
10939 return nil
10940}
10941
10942func DecodeOxmIdTunMetadata34(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata34, error) {
10943 _oxmidtunmetadata34 := &OxmIdTunMetadata34{OxmId: parent}
10944 return _oxmidtunmetadata34, nil
10945}
10946
10947func NewOxmIdTunMetadata34() *OxmIdTunMetadata34 {
10948 obj := &OxmIdTunMetadata34{
10949 OxmId: NewOxmId(103548),
10950 }
10951 return obj
10952}
10953func (self *OxmIdTunMetadata34) GetOXMName() string {
10954 return "tun_metadata34"
10955}
10956
10957func (self *OxmIdTunMetadata34) MarshalJSON() ([]byte, error) {
10958 if self.TypeLen == 0 {
10959 return []byte("\"\""), nil
10960 } else {
10961 return []byte("\"" + self.GetOXMName() + "\""), nil
10962 }
10963}
10964
10965type OxmIdTunMetadata34Masked struct {
10966 *OxmId
10967}
10968
10969type IOxmIdTunMetadata34Masked interface {
10970 IOxmId
10971}
10972
10973func (self *OxmIdTunMetadata34Masked) Serialize(encoder *goloxi.Encoder) error {
10974 if err := self.OxmId.Serialize(encoder); err != nil {
10975 return err
10976 }
10977
10978 return nil
10979}
10980
10981func DecodeOxmIdTunMetadata34Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata34Masked, error) {
10982 _oxmidtunmetadata34masked := &OxmIdTunMetadata34Masked{OxmId: parent}
10983 return _oxmidtunmetadata34masked, nil
10984}
10985
10986func NewOxmIdTunMetadata34Masked() *OxmIdTunMetadata34Masked {
10987 obj := &OxmIdTunMetadata34Masked{
10988 OxmId: NewOxmId(103928),
10989 }
10990 return obj
10991}
10992func (self *OxmIdTunMetadata34Masked) GetOXMName() string {
10993 return "tun_metadata34_masked"
10994}
10995
10996func (self *OxmIdTunMetadata34Masked) MarshalJSON() ([]byte, error) {
10997 if self.TypeLen == 0 {
10998 return []byte("\"\""), nil
10999 } else {
11000 return []byte("\"" + self.GetOXMName() + "\""), nil
11001 }
11002}
11003
11004type OxmIdTunMetadata35 struct {
11005 *OxmId
11006}
11007
11008type IOxmIdTunMetadata35 interface {
11009 IOxmId
11010}
11011
11012func (self *OxmIdTunMetadata35) Serialize(encoder *goloxi.Encoder) error {
11013 if err := self.OxmId.Serialize(encoder); err != nil {
11014 return err
11015 }
11016
11017 return nil
11018}
11019
11020func DecodeOxmIdTunMetadata35(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata35, error) {
11021 _oxmidtunmetadata35 := &OxmIdTunMetadata35{OxmId: parent}
11022 return _oxmidtunmetadata35, nil
11023}
11024
11025func NewOxmIdTunMetadata35() *OxmIdTunMetadata35 {
11026 obj := &OxmIdTunMetadata35{
11027 OxmId: NewOxmId(104060),
11028 }
11029 return obj
11030}
11031func (self *OxmIdTunMetadata35) GetOXMName() string {
11032 return "tun_metadata35"
11033}
11034
11035func (self *OxmIdTunMetadata35) MarshalJSON() ([]byte, error) {
11036 if self.TypeLen == 0 {
11037 return []byte("\"\""), nil
11038 } else {
11039 return []byte("\"" + self.GetOXMName() + "\""), nil
11040 }
11041}
11042
11043type OxmIdTunMetadata35Masked struct {
11044 *OxmId
11045}
11046
11047type IOxmIdTunMetadata35Masked interface {
11048 IOxmId
11049}
11050
11051func (self *OxmIdTunMetadata35Masked) Serialize(encoder *goloxi.Encoder) error {
11052 if err := self.OxmId.Serialize(encoder); err != nil {
11053 return err
11054 }
11055
11056 return nil
11057}
11058
11059func DecodeOxmIdTunMetadata35Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata35Masked, error) {
11060 _oxmidtunmetadata35masked := &OxmIdTunMetadata35Masked{OxmId: parent}
11061 return _oxmidtunmetadata35masked, nil
11062}
11063
11064func NewOxmIdTunMetadata35Masked() *OxmIdTunMetadata35Masked {
11065 obj := &OxmIdTunMetadata35Masked{
11066 OxmId: NewOxmId(104440),
11067 }
11068 return obj
11069}
11070func (self *OxmIdTunMetadata35Masked) GetOXMName() string {
11071 return "tun_metadata35_masked"
11072}
11073
11074func (self *OxmIdTunMetadata35Masked) MarshalJSON() ([]byte, error) {
11075 if self.TypeLen == 0 {
11076 return []byte("\"\""), nil
11077 } else {
11078 return []byte("\"" + self.GetOXMName() + "\""), nil
11079 }
11080}
11081
11082type OxmIdTunMetadata36 struct {
11083 *OxmId
11084}
11085
11086type IOxmIdTunMetadata36 interface {
11087 IOxmId
11088}
11089
11090func (self *OxmIdTunMetadata36) Serialize(encoder *goloxi.Encoder) error {
11091 if err := self.OxmId.Serialize(encoder); err != nil {
11092 return err
11093 }
11094
11095 return nil
11096}
11097
11098func DecodeOxmIdTunMetadata36(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata36, error) {
11099 _oxmidtunmetadata36 := &OxmIdTunMetadata36{OxmId: parent}
11100 return _oxmidtunmetadata36, nil
11101}
11102
11103func NewOxmIdTunMetadata36() *OxmIdTunMetadata36 {
11104 obj := &OxmIdTunMetadata36{
11105 OxmId: NewOxmId(104572),
11106 }
11107 return obj
11108}
11109func (self *OxmIdTunMetadata36) GetOXMName() string {
11110 return "tun_metadata36"
11111}
11112
11113func (self *OxmIdTunMetadata36) MarshalJSON() ([]byte, error) {
11114 if self.TypeLen == 0 {
11115 return []byte("\"\""), nil
11116 } else {
11117 return []byte("\"" + self.GetOXMName() + "\""), nil
11118 }
11119}
11120
11121type OxmIdTunMetadata36Masked struct {
11122 *OxmId
11123}
11124
11125type IOxmIdTunMetadata36Masked interface {
11126 IOxmId
11127}
11128
11129func (self *OxmIdTunMetadata36Masked) Serialize(encoder *goloxi.Encoder) error {
11130 if err := self.OxmId.Serialize(encoder); err != nil {
11131 return err
11132 }
11133
11134 return nil
11135}
11136
11137func DecodeOxmIdTunMetadata36Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata36Masked, error) {
11138 _oxmidtunmetadata36masked := &OxmIdTunMetadata36Masked{OxmId: parent}
11139 return _oxmidtunmetadata36masked, nil
11140}
11141
11142func NewOxmIdTunMetadata36Masked() *OxmIdTunMetadata36Masked {
11143 obj := &OxmIdTunMetadata36Masked{
11144 OxmId: NewOxmId(104952),
11145 }
11146 return obj
11147}
11148func (self *OxmIdTunMetadata36Masked) GetOXMName() string {
11149 return "tun_metadata36_masked"
11150}
11151
11152func (self *OxmIdTunMetadata36Masked) MarshalJSON() ([]byte, error) {
11153 if self.TypeLen == 0 {
11154 return []byte("\"\""), nil
11155 } else {
11156 return []byte("\"" + self.GetOXMName() + "\""), nil
11157 }
11158}
11159
11160type OxmIdTunMetadata37 struct {
11161 *OxmId
11162}
11163
11164type IOxmIdTunMetadata37 interface {
11165 IOxmId
11166}
11167
11168func (self *OxmIdTunMetadata37) Serialize(encoder *goloxi.Encoder) error {
11169 if err := self.OxmId.Serialize(encoder); err != nil {
11170 return err
11171 }
11172
11173 return nil
11174}
11175
11176func DecodeOxmIdTunMetadata37(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata37, error) {
11177 _oxmidtunmetadata37 := &OxmIdTunMetadata37{OxmId: parent}
11178 return _oxmidtunmetadata37, nil
11179}
11180
11181func NewOxmIdTunMetadata37() *OxmIdTunMetadata37 {
11182 obj := &OxmIdTunMetadata37{
11183 OxmId: NewOxmId(105084),
11184 }
11185 return obj
11186}
11187func (self *OxmIdTunMetadata37) GetOXMName() string {
11188 return "tun_metadata37"
11189}
11190
11191func (self *OxmIdTunMetadata37) MarshalJSON() ([]byte, error) {
11192 if self.TypeLen == 0 {
11193 return []byte("\"\""), nil
11194 } else {
11195 return []byte("\"" + self.GetOXMName() + "\""), nil
11196 }
11197}
11198
11199type OxmIdTunMetadata37Masked struct {
11200 *OxmId
11201}
11202
11203type IOxmIdTunMetadata37Masked interface {
11204 IOxmId
11205}
11206
11207func (self *OxmIdTunMetadata37Masked) Serialize(encoder *goloxi.Encoder) error {
11208 if err := self.OxmId.Serialize(encoder); err != nil {
11209 return err
11210 }
11211
11212 return nil
11213}
11214
11215func DecodeOxmIdTunMetadata37Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata37Masked, error) {
11216 _oxmidtunmetadata37masked := &OxmIdTunMetadata37Masked{OxmId: parent}
11217 return _oxmidtunmetadata37masked, nil
11218}
11219
11220func NewOxmIdTunMetadata37Masked() *OxmIdTunMetadata37Masked {
11221 obj := &OxmIdTunMetadata37Masked{
11222 OxmId: NewOxmId(105464),
11223 }
11224 return obj
11225}
11226func (self *OxmIdTunMetadata37Masked) GetOXMName() string {
11227 return "tun_metadata37_masked"
11228}
11229
11230func (self *OxmIdTunMetadata37Masked) MarshalJSON() ([]byte, error) {
11231 if self.TypeLen == 0 {
11232 return []byte("\"\""), nil
11233 } else {
11234 return []byte("\"" + self.GetOXMName() + "\""), nil
11235 }
11236}
11237
11238type OxmIdTunMetadata38 struct {
11239 *OxmId
11240}
11241
11242type IOxmIdTunMetadata38 interface {
11243 IOxmId
11244}
11245
11246func (self *OxmIdTunMetadata38) Serialize(encoder *goloxi.Encoder) error {
11247 if err := self.OxmId.Serialize(encoder); err != nil {
11248 return err
11249 }
11250
11251 return nil
11252}
11253
11254func DecodeOxmIdTunMetadata38(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata38, error) {
11255 _oxmidtunmetadata38 := &OxmIdTunMetadata38{OxmId: parent}
11256 return _oxmidtunmetadata38, nil
11257}
11258
11259func NewOxmIdTunMetadata38() *OxmIdTunMetadata38 {
11260 obj := &OxmIdTunMetadata38{
11261 OxmId: NewOxmId(105596),
11262 }
11263 return obj
11264}
11265func (self *OxmIdTunMetadata38) GetOXMName() string {
11266 return "tun_metadata38"
11267}
11268
11269func (self *OxmIdTunMetadata38) MarshalJSON() ([]byte, error) {
11270 if self.TypeLen == 0 {
11271 return []byte("\"\""), nil
11272 } else {
11273 return []byte("\"" + self.GetOXMName() + "\""), nil
11274 }
11275}
11276
11277type OxmIdTunMetadata38Masked struct {
11278 *OxmId
11279}
11280
11281type IOxmIdTunMetadata38Masked interface {
11282 IOxmId
11283}
11284
11285func (self *OxmIdTunMetadata38Masked) Serialize(encoder *goloxi.Encoder) error {
11286 if err := self.OxmId.Serialize(encoder); err != nil {
11287 return err
11288 }
11289
11290 return nil
11291}
11292
11293func DecodeOxmIdTunMetadata38Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata38Masked, error) {
11294 _oxmidtunmetadata38masked := &OxmIdTunMetadata38Masked{OxmId: parent}
11295 return _oxmidtunmetadata38masked, nil
11296}
11297
11298func NewOxmIdTunMetadata38Masked() *OxmIdTunMetadata38Masked {
11299 obj := &OxmIdTunMetadata38Masked{
11300 OxmId: NewOxmId(105976),
11301 }
11302 return obj
11303}
11304func (self *OxmIdTunMetadata38Masked) GetOXMName() string {
11305 return "tun_metadata38_masked"
11306}
11307
11308func (self *OxmIdTunMetadata38Masked) MarshalJSON() ([]byte, error) {
11309 if self.TypeLen == 0 {
11310 return []byte("\"\""), nil
11311 } else {
11312 return []byte("\"" + self.GetOXMName() + "\""), nil
11313 }
11314}
11315
11316type OxmIdTunMetadata39 struct {
11317 *OxmId
11318}
11319
11320type IOxmIdTunMetadata39 interface {
11321 IOxmId
11322}
11323
11324func (self *OxmIdTunMetadata39) Serialize(encoder *goloxi.Encoder) error {
11325 if err := self.OxmId.Serialize(encoder); err != nil {
11326 return err
11327 }
11328
11329 return nil
11330}
11331
11332func DecodeOxmIdTunMetadata39(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata39, error) {
11333 _oxmidtunmetadata39 := &OxmIdTunMetadata39{OxmId: parent}
11334 return _oxmidtunmetadata39, nil
11335}
11336
11337func NewOxmIdTunMetadata39() *OxmIdTunMetadata39 {
11338 obj := &OxmIdTunMetadata39{
11339 OxmId: NewOxmId(106108),
11340 }
11341 return obj
11342}
11343func (self *OxmIdTunMetadata39) GetOXMName() string {
11344 return "tun_metadata39"
11345}
11346
11347func (self *OxmIdTunMetadata39) MarshalJSON() ([]byte, error) {
11348 if self.TypeLen == 0 {
11349 return []byte("\"\""), nil
11350 } else {
11351 return []byte("\"" + self.GetOXMName() + "\""), nil
11352 }
11353}
11354
11355type OxmIdTunMetadata39Masked struct {
11356 *OxmId
11357}
11358
11359type IOxmIdTunMetadata39Masked interface {
11360 IOxmId
11361}
11362
11363func (self *OxmIdTunMetadata39Masked) Serialize(encoder *goloxi.Encoder) error {
11364 if err := self.OxmId.Serialize(encoder); err != nil {
11365 return err
11366 }
11367
11368 return nil
11369}
11370
11371func DecodeOxmIdTunMetadata39Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata39Masked, error) {
11372 _oxmidtunmetadata39masked := &OxmIdTunMetadata39Masked{OxmId: parent}
11373 return _oxmidtunmetadata39masked, nil
11374}
11375
11376func NewOxmIdTunMetadata39Masked() *OxmIdTunMetadata39Masked {
11377 obj := &OxmIdTunMetadata39Masked{
11378 OxmId: NewOxmId(106488),
11379 }
11380 return obj
11381}
11382func (self *OxmIdTunMetadata39Masked) GetOXMName() string {
11383 return "tun_metadata39_masked"
11384}
11385
11386func (self *OxmIdTunMetadata39Masked) MarshalJSON() ([]byte, error) {
11387 if self.TypeLen == 0 {
11388 return []byte("\"\""), nil
11389 } else {
11390 return []byte("\"" + self.GetOXMName() + "\""), nil
11391 }
11392}
11393
11394type OxmIdTunMetadata3Masked struct {
11395 *OxmId
11396}
11397
11398type IOxmIdTunMetadata3Masked interface {
11399 IOxmId
11400}
11401
11402func (self *OxmIdTunMetadata3Masked) Serialize(encoder *goloxi.Encoder) error {
11403 if err := self.OxmId.Serialize(encoder); err != nil {
11404 return err
11405 }
11406
11407 return nil
11408}
11409
11410func DecodeOxmIdTunMetadata3Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata3Masked, error) {
11411 _oxmidtunmetadata3masked := &OxmIdTunMetadata3Masked{OxmId: parent}
11412 return _oxmidtunmetadata3masked, nil
11413}
11414
11415func NewOxmIdTunMetadata3Masked() *OxmIdTunMetadata3Masked {
11416 obj := &OxmIdTunMetadata3Masked{
11417 OxmId: NewOxmId(88056),
11418 }
11419 return obj
11420}
11421func (self *OxmIdTunMetadata3Masked) GetOXMName() string {
11422 return "tun_metadata3_masked"
11423}
11424
11425func (self *OxmIdTunMetadata3Masked) MarshalJSON() ([]byte, error) {
11426 if self.TypeLen == 0 {
11427 return []byte("\"\""), nil
11428 } else {
11429 return []byte("\"" + self.GetOXMName() + "\""), nil
11430 }
11431}
11432
11433type OxmIdTunMetadata4 struct {
11434 *OxmId
11435}
11436
11437type IOxmIdTunMetadata4 interface {
11438 IOxmId
11439}
11440
11441func (self *OxmIdTunMetadata4) Serialize(encoder *goloxi.Encoder) error {
11442 if err := self.OxmId.Serialize(encoder); err != nil {
11443 return err
11444 }
11445
11446 return nil
11447}
11448
11449func DecodeOxmIdTunMetadata4(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata4, error) {
11450 _oxmidtunmetadata4 := &OxmIdTunMetadata4{OxmId: parent}
11451 return _oxmidtunmetadata4, nil
11452}
11453
11454func NewOxmIdTunMetadata4() *OxmIdTunMetadata4 {
11455 obj := &OxmIdTunMetadata4{
11456 OxmId: NewOxmId(88188),
11457 }
11458 return obj
11459}
11460func (self *OxmIdTunMetadata4) GetOXMName() string {
11461 return "tun_metadata4"
11462}
11463
11464func (self *OxmIdTunMetadata4) MarshalJSON() ([]byte, error) {
11465 if self.TypeLen == 0 {
11466 return []byte("\"\""), nil
11467 } else {
11468 return []byte("\"" + self.GetOXMName() + "\""), nil
11469 }
11470}
11471
11472type OxmIdTunMetadata40 struct {
11473 *OxmId
11474}
11475
11476type IOxmIdTunMetadata40 interface {
11477 IOxmId
11478}
11479
11480func (self *OxmIdTunMetadata40) Serialize(encoder *goloxi.Encoder) error {
11481 if err := self.OxmId.Serialize(encoder); err != nil {
11482 return err
11483 }
11484
11485 return nil
11486}
11487
11488func DecodeOxmIdTunMetadata40(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata40, error) {
11489 _oxmidtunmetadata40 := &OxmIdTunMetadata40{OxmId: parent}
11490 return _oxmidtunmetadata40, nil
11491}
11492
11493func NewOxmIdTunMetadata40() *OxmIdTunMetadata40 {
11494 obj := &OxmIdTunMetadata40{
11495 OxmId: NewOxmId(106620),
11496 }
11497 return obj
11498}
11499func (self *OxmIdTunMetadata40) GetOXMName() string {
11500 return "tun_metadata40"
11501}
11502
11503func (self *OxmIdTunMetadata40) MarshalJSON() ([]byte, error) {
11504 if self.TypeLen == 0 {
11505 return []byte("\"\""), nil
11506 } else {
11507 return []byte("\"" + self.GetOXMName() + "\""), nil
11508 }
11509}
11510
11511type OxmIdTunMetadata40Masked struct {
11512 *OxmId
11513}
11514
11515type IOxmIdTunMetadata40Masked interface {
11516 IOxmId
11517}
11518
11519func (self *OxmIdTunMetadata40Masked) Serialize(encoder *goloxi.Encoder) error {
11520 if err := self.OxmId.Serialize(encoder); err != nil {
11521 return err
11522 }
11523
11524 return nil
11525}
11526
11527func DecodeOxmIdTunMetadata40Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata40Masked, error) {
11528 _oxmidtunmetadata40masked := &OxmIdTunMetadata40Masked{OxmId: parent}
11529 return _oxmidtunmetadata40masked, nil
11530}
11531
11532func NewOxmIdTunMetadata40Masked() *OxmIdTunMetadata40Masked {
11533 obj := &OxmIdTunMetadata40Masked{
11534 OxmId: NewOxmId(107000),
11535 }
11536 return obj
11537}
11538func (self *OxmIdTunMetadata40Masked) GetOXMName() string {
11539 return "tun_metadata40_masked"
11540}
11541
11542func (self *OxmIdTunMetadata40Masked) MarshalJSON() ([]byte, error) {
11543 if self.TypeLen == 0 {
11544 return []byte("\"\""), nil
11545 } else {
11546 return []byte("\"" + self.GetOXMName() + "\""), nil
11547 }
11548}
11549
11550type OxmIdTunMetadata41 struct {
11551 *OxmId
11552}
11553
11554type IOxmIdTunMetadata41 interface {
11555 IOxmId
11556}
11557
11558func (self *OxmIdTunMetadata41) Serialize(encoder *goloxi.Encoder) error {
11559 if err := self.OxmId.Serialize(encoder); err != nil {
11560 return err
11561 }
11562
11563 return nil
11564}
11565
11566func DecodeOxmIdTunMetadata41(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata41, error) {
11567 _oxmidtunmetadata41 := &OxmIdTunMetadata41{OxmId: parent}
11568 return _oxmidtunmetadata41, nil
11569}
11570
11571func NewOxmIdTunMetadata41() *OxmIdTunMetadata41 {
11572 obj := &OxmIdTunMetadata41{
11573 OxmId: NewOxmId(107132),
11574 }
11575 return obj
11576}
11577func (self *OxmIdTunMetadata41) GetOXMName() string {
11578 return "tun_metadata41"
11579}
11580
11581func (self *OxmIdTunMetadata41) MarshalJSON() ([]byte, error) {
11582 if self.TypeLen == 0 {
11583 return []byte("\"\""), nil
11584 } else {
11585 return []byte("\"" + self.GetOXMName() + "\""), nil
11586 }
11587}
11588
11589type OxmIdTunMetadata41Masked struct {
11590 *OxmId
11591}
11592
11593type IOxmIdTunMetadata41Masked interface {
11594 IOxmId
11595}
11596
11597func (self *OxmIdTunMetadata41Masked) Serialize(encoder *goloxi.Encoder) error {
11598 if err := self.OxmId.Serialize(encoder); err != nil {
11599 return err
11600 }
11601
11602 return nil
11603}
11604
11605func DecodeOxmIdTunMetadata41Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata41Masked, error) {
11606 _oxmidtunmetadata41masked := &OxmIdTunMetadata41Masked{OxmId: parent}
11607 return _oxmidtunmetadata41masked, nil
11608}
11609
11610func NewOxmIdTunMetadata41Masked() *OxmIdTunMetadata41Masked {
11611 obj := &OxmIdTunMetadata41Masked{
11612 OxmId: NewOxmId(107512),
11613 }
11614 return obj
11615}
11616func (self *OxmIdTunMetadata41Masked) GetOXMName() string {
11617 return "tun_metadata41_masked"
11618}
11619
11620func (self *OxmIdTunMetadata41Masked) MarshalJSON() ([]byte, error) {
11621 if self.TypeLen == 0 {
11622 return []byte("\"\""), nil
11623 } else {
11624 return []byte("\"" + self.GetOXMName() + "\""), nil
11625 }
11626}
11627
11628type OxmIdTunMetadata42 struct {
11629 *OxmId
11630}
11631
11632type IOxmIdTunMetadata42 interface {
11633 IOxmId
11634}
11635
11636func (self *OxmIdTunMetadata42) Serialize(encoder *goloxi.Encoder) error {
11637 if err := self.OxmId.Serialize(encoder); err != nil {
11638 return err
11639 }
11640
11641 return nil
11642}
11643
11644func DecodeOxmIdTunMetadata42(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata42, error) {
11645 _oxmidtunmetadata42 := &OxmIdTunMetadata42{OxmId: parent}
11646 return _oxmidtunmetadata42, nil
11647}
11648
11649func NewOxmIdTunMetadata42() *OxmIdTunMetadata42 {
11650 obj := &OxmIdTunMetadata42{
11651 OxmId: NewOxmId(107644),
11652 }
11653 return obj
11654}
11655func (self *OxmIdTunMetadata42) GetOXMName() string {
11656 return "tun_metadata42"
11657}
11658
11659func (self *OxmIdTunMetadata42) MarshalJSON() ([]byte, error) {
11660 if self.TypeLen == 0 {
11661 return []byte("\"\""), nil
11662 } else {
11663 return []byte("\"" + self.GetOXMName() + "\""), nil
11664 }
11665}
11666
11667type OxmIdTunMetadata42Masked struct {
11668 *OxmId
11669}
11670
11671type IOxmIdTunMetadata42Masked interface {
11672 IOxmId
11673}
11674
11675func (self *OxmIdTunMetadata42Masked) Serialize(encoder *goloxi.Encoder) error {
11676 if err := self.OxmId.Serialize(encoder); err != nil {
11677 return err
11678 }
11679
11680 return nil
11681}
11682
11683func DecodeOxmIdTunMetadata42Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata42Masked, error) {
11684 _oxmidtunmetadata42masked := &OxmIdTunMetadata42Masked{OxmId: parent}
11685 return _oxmidtunmetadata42masked, nil
11686}
11687
11688func NewOxmIdTunMetadata42Masked() *OxmIdTunMetadata42Masked {
11689 obj := &OxmIdTunMetadata42Masked{
11690 OxmId: NewOxmId(108024),
11691 }
11692 return obj
11693}
11694func (self *OxmIdTunMetadata42Masked) GetOXMName() string {
11695 return "tun_metadata42_masked"
11696}
11697
11698func (self *OxmIdTunMetadata42Masked) MarshalJSON() ([]byte, error) {
11699 if self.TypeLen == 0 {
11700 return []byte("\"\""), nil
11701 } else {
11702 return []byte("\"" + self.GetOXMName() + "\""), nil
11703 }
11704}
11705
11706type OxmIdTunMetadata43 struct {
11707 *OxmId
11708}
11709
11710type IOxmIdTunMetadata43 interface {
11711 IOxmId
11712}
11713
11714func (self *OxmIdTunMetadata43) Serialize(encoder *goloxi.Encoder) error {
11715 if err := self.OxmId.Serialize(encoder); err != nil {
11716 return err
11717 }
11718
11719 return nil
11720}
11721
11722func DecodeOxmIdTunMetadata43(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata43, error) {
11723 _oxmidtunmetadata43 := &OxmIdTunMetadata43{OxmId: parent}
11724 return _oxmidtunmetadata43, nil
11725}
11726
11727func NewOxmIdTunMetadata43() *OxmIdTunMetadata43 {
11728 obj := &OxmIdTunMetadata43{
11729 OxmId: NewOxmId(108156),
11730 }
11731 return obj
11732}
11733func (self *OxmIdTunMetadata43) GetOXMName() string {
11734 return "tun_metadata43"
11735}
11736
11737func (self *OxmIdTunMetadata43) MarshalJSON() ([]byte, error) {
11738 if self.TypeLen == 0 {
11739 return []byte("\"\""), nil
11740 } else {
11741 return []byte("\"" + self.GetOXMName() + "\""), nil
11742 }
11743}
11744
11745type OxmIdTunMetadata43Masked struct {
11746 *OxmId
11747}
11748
11749type IOxmIdTunMetadata43Masked interface {
11750 IOxmId
11751}
11752
11753func (self *OxmIdTunMetadata43Masked) Serialize(encoder *goloxi.Encoder) error {
11754 if err := self.OxmId.Serialize(encoder); err != nil {
11755 return err
11756 }
11757
11758 return nil
11759}
11760
11761func DecodeOxmIdTunMetadata43Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata43Masked, error) {
11762 _oxmidtunmetadata43masked := &OxmIdTunMetadata43Masked{OxmId: parent}
11763 return _oxmidtunmetadata43masked, nil
11764}
11765
11766func NewOxmIdTunMetadata43Masked() *OxmIdTunMetadata43Masked {
11767 obj := &OxmIdTunMetadata43Masked{
11768 OxmId: NewOxmId(108536),
11769 }
11770 return obj
11771}
11772func (self *OxmIdTunMetadata43Masked) GetOXMName() string {
11773 return "tun_metadata43_masked"
11774}
11775
11776func (self *OxmIdTunMetadata43Masked) MarshalJSON() ([]byte, error) {
11777 if self.TypeLen == 0 {
11778 return []byte("\"\""), nil
11779 } else {
11780 return []byte("\"" + self.GetOXMName() + "\""), nil
11781 }
11782}
11783
11784type OxmIdTunMetadata44 struct {
11785 *OxmId
11786}
11787
11788type IOxmIdTunMetadata44 interface {
11789 IOxmId
11790}
11791
11792func (self *OxmIdTunMetadata44) Serialize(encoder *goloxi.Encoder) error {
11793 if err := self.OxmId.Serialize(encoder); err != nil {
11794 return err
11795 }
11796
11797 return nil
11798}
11799
11800func DecodeOxmIdTunMetadata44(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata44, error) {
11801 _oxmidtunmetadata44 := &OxmIdTunMetadata44{OxmId: parent}
11802 return _oxmidtunmetadata44, nil
11803}
11804
11805func NewOxmIdTunMetadata44() *OxmIdTunMetadata44 {
11806 obj := &OxmIdTunMetadata44{
11807 OxmId: NewOxmId(108668),
11808 }
11809 return obj
11810}
11811func (self *OxmIdTunMetadata44) GetOXMName() string {
11812 return "tun_metadata44"
11813}
11814
11815func (self *OxmIdTunMetadata44) MarshalJSON() ([]byte, error) {
11816 if self.TypeLen == 0 {
11817 return []byte("\"\""), nil
11818 } else {
11819 return []byte("\"" + self.GetOXMName() + "\""), nil
11820 }
11821}
11822
11823type OxmIdTunMetadata44Masked struct {
11824 *OxmId
11825}
11826
11827type IOxmIdTunMetadata44Masked interface {
11828 IOxmId
11829}
11830
11831func (self *OxmIdTunMetadata44Masked) Serialize(encoder *goloxi.Encoder) error {
11832 if err := self.OxmId.Serialize(encoder); err != nil {
11833 return err
11834 }
11835
11836 return nil
11837}
11838
11839func DecodeOxmIdTunMetadata44Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata44Masked, error) {
11840 _oxmidtunmetadata44masked := &OxmIdTunMetadata44Masked{OxmId: parent}
11841 return _oxmidtunmetadata44masked, nil
11842}
11843
11844func NewOxmIdTunMetadata44Masked() *OxmIdTunMetadata44Masked {
11845 obj := &OxmIdTunMetadata44Masked{
11846 OxmId: NewOxmId(109048),
11847 }
11848 return obj
11849}
11850func (self *OxmIdTunMetadata44Masked) GetOXMName() string {
11851 return "tun_metadata44_masked"
11852}
11853
11854func (self *OxmIdTunMetadata44Masked) MarshalJSON() ([]byte, error) {
11855 if self.TypeLen == 0 {
11856 return []byte("\"\""), nil
11857 } else {
11858 return []byte("\"" + self.GetOXMName() + "\""), nil
11859 }
11860}
11861
11862type OxmIdTunMetadata45 struct {
11863 *OxmId
11864}
11865
11866type IOxmIdTunMetadata45 interface {
11867 IOxmId
11868}
11869
11870func (self *OxmIdTunMetadata45) Serialize(encoder *goloxi.Encoder) error {
11871 if err := self.OxmId.Serialize(encoder); err != nil {
11872 return err
11873 }
11874
11875 return nil
11876}
11877
11878func DecodeOxmIdTunMetadata45(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata45, error) {
11879 _oxmidtunmetadata45 := &OxmIdTunMetadata45{OxmId: parent}
11880 return _oxmidtunmetadata45, nil
11881}
11882
11883func NewOxmIdTunMetadata45() *OxmIdTunMetadata45 {
11884 obj := &OxmIdTunMetadata45{
11885 OxmId: NewOxmId(109180),
11886 }
11887 return obj
11888}
11889func (self *OxmIdTunMetadata45) GetOXMName() string {
11890 return "tun_metadata45"
11891}
11892
11893func (self *OxmIdTunMetadata45) MarshalJSON() ([]byte, error) {
11894 if self.TypeLen == 0 {
11895 return []byte("\"\""), nil
11896 } else {
11897 return []byte("\"" + self.GetOXMName() + "\""), nil
11898 }
11899}
11900
11901type OxmIdTunMetadata45Masked struct {
11902 *OxmId
11903}
11904
11905type IOxmIdTunMetadata45Masked interface {
11906 IOxmId
11907}
11908
11909func (self *OxmIdTunMetadata45Masked) Serialize(encoder *goloxi.Encoder) error {
11910 if err := self.OxmId.Serialize(encoder); err != nil {
11911 return err
11912 }
11913
11914 return nil
11915}
11916
11917func DecodeOxmIdTunMetadata45Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata45Masked, error) {
11918 _oxmidtunmetadata45masked := &OxmIdTunMetadata45Masked{OxmId: parent}
11919 return _oxmidtunmetadata45masked, nil
11920}
11921
11922func NewOxmIdTunMetadata45Masked() *OxmIdTunMetadata45Masked {
11923 obj := &OxmIdTunMetadata45Masked{
11924 OxmId: NewOxmId(109560),
11925 }
11926 return obj
11927}
11928func (self *OxmIdTunMetadata45Masked) GetOXMName() string {
11929 return "tun_metadata45_masked"
11930}
11931
11932func (self *OxmIdTunMetadata45Masked) MarshalJSON() ([]byte, error) {
11933 if self.TypeLen == 0 {
11934 return []byte("\"\""), nil
11935 } else {
11936 return []byte("\"" + self.GetOXMName() + "\""), nil
11937 }
11938}
11939
11940type OxmIdTunMetadata46 struct {
11941 *OxmId
11942}
11943
11944type IOxmIdTunMetadata46 interface {
11945 IOxmId
11946}
11947
11948func (self *OxmIdTunMetadata46) Serialize(encoder *goloxi.Encoder) error {
11949 if err := self.OxmId.Serialize(encoder); err != nil {
11950 return err
11951 }
11952
11953 return nil
11954}
11955
11956func DecodeOxmIdTunMetadata46(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata46, error) {
11957 _oxmidtunmetadata46 := &OxmIdTunMetadata46{OxmId: parent}
11958 return _oxmidtunmetadata46, nil
11959}
11960
11961func NewOxmIdTunMetadata46() *OxmIdTunMetadata46 {
11962 obj := &OxmIdTunMetadata46{
11963 OxmId: NewOxmId(109692),
11964 }
11965 return obj
11966}
11967func (self *OxmIdTunMetadata46) GetOXMName() string {
11968 return "tun_metadata46"
11969}
11970
11971func (self *OxmIdTunMetadata46) MarshalJSON() ([]byte, error) {
11972 if self.TypeLen == 0 {
11973 return []byte("\"\""), nil
11974 } else {
11975 return []byte("\"" + self.GetOXMName() + "\""), nil
11976 }
11977}
11978
11979type OxmIdTunMetadata46Masked struct {
11980 *OxmId
11981}
11982
11983type IOxmIdTunMetadata46Masked interface {
11984 IOxmId
11985}
11986
11987func (self *OxmIdTunMetadata46Masked) Serialize(encoder *goloxi.Encoder) error {
11988 if err := self.OxmId.Serialize(encoder); err != nil {
11989 return err
11990 }
11991
11992 return nil
11993}
11994
11995func DecodeOxmIdTunMetadata46Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata46Masked, error) {
11996 _oxmidtunmetadata46masked := &OxmIdTunMetadata46Masked{OxmId: parent}
11997 return _oxmidtunmetadata46masked, nil
11998}
11999
12000func NewOxmIdTunMetadata46Masked() *OxmIdTunMetadata46Masked {
12001 obj := &OxmIdTunMetadata46Masked{
12002 OxmId: NewOxmId(110072),
12003 }
12004 return obj
12005}
12006func (self *OxmIdTunMetadata46Masked) GetOXMName() string {
12007 return "tun_metadata46_masked"
12008}
12009
12010func (self *OxmIdTunMetadata46Masked) MarshalJSON() ([]byte, error) {
12011 if self.TypeLen == 0 {
12012 return []byte("\"\""), nil
12013 } else {
12014 return []byte("\"" + self.GetOXMName() + "\""), nil
12015 }
12016}
12017
12018type OxmIdTunMetadata47 struct {
12019 *OxmId
12020}
12021
12022type IOxmIdTunMetadata47 interface {
12023 IOxmId
12024}
12025
12026func (self *OxmIdTunMetadata47) Serialize(encoder *goloxi.Encoder) error {
12027 if err := self.OxmId.Serialize(encoder); err != nil {
12028 return err
12029 }
12030
12031 return nil
12032}
12033
12034func DecodeOxmIdTunMetadata47(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata47, error) {
12035 _oxmidtunmetadata47 := &OxmIdTunMetadata47{OxmId: parent}
12036 return _oxmidtunmetadata47, nil
12037}
12038
12039func NewOxmIdTunMetadata47() *OxmIdTunMetadata47 {
12040 obj := &OxmIdTunMetadata47{
12041 OxmId: NewOxmId(110204),
12042 }
12043 return obj
12044}
12045func (self *OxmIdTunMetadata47) GetOXMName() string {
12046 return "tun_metadata47"
12047}
12048
12049func (self *OxmIdTunMetadata47) MarshalJSON() ([]byte, error) {
12050 if self.TypeLen == 0 {
12051 return []byte("\"\""), nil
12052 } else {
12053 return []byte("\"" + self.GetOXMName() + "\""), nil
12054 }
12055}
12056
12057type OxmIdTunMetadata47Masked struct {
12058 *OxmId
12059}
12060
12061type IOxmIdTunMetadata47Masked interface {
12062 IOxmId
12063}
12064
12065func (self *OxmIdTunMetadata47Masked) Serialize(encoder *goloxi.Encoder) error {
12066 if err := self.OxmId.Serialize(encoder); err != nil {
12067 return err
12068 }
12069
12070 return nil
12071}
12072
12073func DecodeOxmIdTunMetadata47Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata47Masked, error) {
12074 _oxmidtunmetadata47masked := &OxmIdTunMetadata47Masked{OxmId: parent}
12075 return _oxmidtunmetadata47masked, nil
12076}
12077
12078func NewOxmIdTunMetadata47Masked() *OxmIdTunMetadata47Masked {
12079 obj := &OxmIdTunMetadata47Masked{
12080 OxmId: NewOxmId(110584),
12081 }
12082 return obj
12083}
12084func (self *OxmIdTunMetadata47Masked) GetOXMName() string {
12085 return "tun_metadata47_masked"
12086}
12087
12088func (self *OxmIdTunMetadata47Masked) MarshalJSON() ([]byte, error) {
12089 if self.TypeLen == 0 {
12090 return []byte("\"\""), nil
12091 } else {
12092 return []byte("\"" + self.GetOXMName() + "\""), nil
12093 }
12094}
12095
12096type OxmIdTunMetadata48 struct {
12097 *OxmId
12098}
12099
12100type IOxmIdTunMetadata48 interface {
12101 IOxmId
12102}
12103
12104func (self *OxmIdTunMetadata48) Serialize(encoder *goloxi.Encoder) error {
12105 if err := self.OxmId.Serialize(encoder); err != nil {
12106 return err
12107 }
12108
12109 return nil
12110}
12111
12112func DecodeOxmIdTunMetadata48(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata48, error) {
12113 _oxmidtunmetadata48 := &OxmIdTunMetadata48{OxmId: parent}
12114 return _oxmidtunmetadata48, nil
12115}
12116
12117func NewOxmIdTunMetadata48() *OxmIdTunMetadata48 {
12118 obj := &OxmIdTunMetadata48{
12119 OxmId: NewOxmId(110716),
12120 }
12121 return obj
12122}
12123func (self *OxmIdTunMetadata48) GetOXMName() string {
12124 return "tun_metadata48"
12125}
12126
12127func (self *OxmIdTunMetadata48) MarshalJSON() ([]byte, error) {
12128 if self.TypeLen == 0 {
12129 return []byte("\"\""), nil
12130 } else {
12131 return []byte("\"" + self.GetOXMName() + "\""), nil
12132 }
12133}
12134
12135type OxmIdTunMetadata48Masked struct {
12136 *OxmId
12137}
12138
12139type IOxmIdTunMetadata48Masked interface {
12140 IOxmId
12141}
12142
12143func (self *OxmIdTunMetadata48Masked) Serialize(encoder *goloxi.Encoder) error {
12144 if err := self.OxmId.Serialize(encoder); err != nil {
12145 return err
12146 }
12147
12148 return nil
12149}
12150
12151func DecodeOxmIdTunMetadata48Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata48Masked, error) {
12152 _oxmidtunmetadata48masked := &OxmIdTunMetadata48Masked{OxmId: parent}
12153 return _oxmidtunmetadata48masked, nil
12154}
12155
12156func NewOxmIdTunMetadata48Masked() *OxmIdTunMetadata48Masked {
12157 obj := &OxmIdTunMetadata48Masked{
12158 OxmId: NewOxmId(111096),
12159 }
12160 return obj
12161}
12162func (self *OxmIdTunMetadata48Masked) GetOXMName() string {
12163 return "tun_metadata48_masked"
12164}
12165
12166func (self *OxmIdTunMetadata48Masked) MarshalJSON() ([]byte, error) {
12167 if self.TypeLen == 0 {
12168 return []byte("\"\""), nil
12169 } else {
12170 return []byte("\"" + self.GetOXMName() + "\""), nil
12171 }
12172}
12173
12174type OxmIdTunMetadata49 struct {
12175 *OxmId
12176}
12177
12178type IOxmIdTunMetadata49 interface {
12179 IOxmId
12180}
12181
12182func (self *OxmIdTunMetadata49) Serialize(encoder *goloxi.Encoder) error {
12183 if err := self.OxmId.Serialize(encoder); err != nil {
12184 return err
12185 }
12186
12187 return nil
12188}
12189
12190func DecodeOxmIdTunMetadata49(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata49, error) {
12191 _oxmidtunmetadata49 := &OxmIdTunMetadata49{OxmId: parent}
12192 return _oxmidtunmetadata49, nil
12193}
12194
12195func NewOxmIdTunMetadata49() *OxmIdTunMetadata49 {
12196 obj := &OxmIdTunMetadata49{
12197 OxmId: NewOxmId(111228),
12198 }
12199 return obj
12200}
12201func (self *OxmIdTunMetadata49) GetOXMName() string {
12202 return "tun_metadata49"
12203}
12204
12205func (self *OxmIdTunMetadata49) MarshalJSON() ([]byte, error) {
12206 if self.TypeLen == 0 {
12207 return []byte("\"\""), nil
12208 } else {
12209 return []byte("\"" + self.GetOXMName() + "\""), nil
12210 }
12211}
12212
12213type OxmIdTunMetadata49Masked struct {
12214 *OxmId
12215}
12216
12217type IOxmIdTunMetadata49Masked interface {
12218 IOxmId
12219}
12220
12221func (self *OxmIdTunMetadata49Masked) Serialize(encoder *goloxi.Encoder) error {
12222 if err := self.OxmId.Serialize(encoder); err != nil {
12223 return err
12224 }
12225
12226 return nil
12227}
12228
12229func DecodeOxmIdTunMetadata49Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata49Masked, error) {
12230 _oxmidtunmetadata49masked := &OxmIdTunMetadata49Masked{OxmId: parent}
12231 return _oxmidtunmetadata49masked, nil
12232}
12233
12234func NewOxmIdTunMetadata49Masked() *OxmIdTunMetadata49Masked {
12235 obj := &OxmIdTunMetadata49Masked{
12236 OxmId: NewOxmId(111608),
12237 }
12238 return obj
12239}
12240func (self *OxmIdTunMetadata49Masked) GetOXMName() string {
12241 return "tun_metadata49_masked"
12242}
12243
12244func (self *OxmIdTunMetadata49Masked) MarshalJSON() ([]byte, error) {
12245 if self.TypeLen == 0 {
12246 return []byte("\"\""), nil
12247 } else {
12248 return []byte("\"" + self.GetOXMName() + "\""), nil
12249 }
12250}
12251
12252type OxmIdTunMetadata4Masked struct {
12253 *OxmId
12254}
12255
12256type IOxmIdTunMetadata4Masked interface {
12257 IOxmId
12258}
12259
12260func (self *OxmIdTunMetadata4Masked) Serialize(encoder *goloxi.Encoder) error {
12261 if err := self.OxmId.Serialize(encoder); err != nil {
12262 return err
12263 }
12264
12265 return nil
12266}
12267
12268func DecodeOxmIdTunMetadata4Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata4Masked, error) {
12269 _oxmidtunmetadata4masked := &OxmIdTunMetadata4Masked{OxmId: parent}
12270 return _oxmidtunmetadata4masked, nil
12271}
12272
12273func NewOxmIdTunMetadata4Masked() *OxmIdTunMetadata4Masked {
12274 obj := &OxmIdTunMetadata4Masked{
12275 OxmId: NewOxmId(88568),
12276 }
12277 return obj
12278}
12279func (self *OxmIdTunMetadata4Masked) GetOXMName() string {
12280 return "tun_metadata4_masked"
12281}
12282
12283func (self *OxmIdTunMetadata4Masked) MarshalJSON() ([]byte, error) {
12284 if self.TypeLen == 0 {
12285 return []byte("\"\""), nil
12286 } else {
12287 return []byte("\"" + self.GetOXMName() + "\""), nil
12288 }
12289}
12290
12291type OxmIdTunMetadata5 struct {
12292 *OxmId
12293}
12294
12295type IOxmIdTunMetadata5 interface {
12296 IOxmId
12297}
12298
12299func (self *OxmIdTunMetadata5) Serialize(encoder *goloxi.Encoder) error {
12300 if err := self.OxmId.Serialize(encoder); err != nil {
12301 return err
12302 }
12303
12304 return nil
12305}
12306
12307func DecodeOxmIdTunMetadata5(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata5, error) {
12308 _oxmidtunmetadata5 := &OxmIdTunMetadata5{OxmId: parent}
12309 return _oxmidtunmetadata5, nil
12310}
12311
12312func NewOxmIdTunMetadata5() *OxmIdTunMetadata5 {
12313 obj := &OxmIdTunMetadata5{
12314 OxmId: NewOxmId(88700),
12315 }
12316 return obj
12317}
12318func (self *OxmIdTunMetadata5) GetOXMName() string {
12319 return "tun_metadata5"
12320}
12321
12322func (self *OxmIdTunMetadata5) MarshalJSON() ([]byte, error) {
12323 if self.TypeLen == 0 {
12324 return []byte("\"\""), nil
12325 } else {
12326 return []byte("\"" + self.GetOXMName() + "\""), nil
12327 }
12328}
12329
12330type OxmIdTunMetadata50 struct {
12331 *OxmId
12332}
12333
12334type IOxmIdTunMetadata50 interface {
12335 IOxmId
12336}
12337
12338func (self *OxmIdTunMetadata50) Serialize(encoder *goloxi.Encoder) error {
12339 if err := self.OxmId.Serialize(encoder); err != nil {
12340 return err
12341 }
12342
12343 return nil
12344}
12345
12346func DecodeOxmIdTunMetadata50(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata50, error) {
12347 _oxmidtunmetadata50 := &OxmIdTunMetadata50{OxmId: parent}
12348 return _oxmidtunmetadata50, nil
12349}
12350
12351func NewOxmIdTunMetadata50() *OxmIdTunMetadata50 {
12352 obj := &OxmIdTunMetadata50{
12353 OxmId: NewOxmId(111740),
12354 }
12355 return obj
12356}
12357func (self *OxmIdTunMetadata50) GetOXMName() string {
12358 return "tun_metadata50"
12359}
12360
12361func (self *OxmIdTunMetadata50) MarshalJSON() ([]byte, error) {
12362 if self.TypeLen == 0 {
12363 return []byte("\"\""), nil
12364 } else {
12365 return []byte("\"" + self.GetOXMName() + "\""), nil
12366 }
12367}
12368
12369type OxmIdTunMetadata50Masked struct {
12370 *OxmId
12371}
12372
12373type IOxmIdTunMetadata50Masked interface {
12374 IOxmId
12375}
12376
12377func (self *OxmIdTunMetadata50Masked) Serialize(encoder *goloxi.Encoder) error {
12378 if err := self.OxmId.Serialize(encoder); err != nil {
12379 return err
12380 }
12381
12382 return nil
12383}
12384
12385func DecodeOxmIdTunMetadata50Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata50Masked, error) {
12386 _oxmidtunmetadata50masked := &OxmIdTunMetadata50Masked{OxmId: parent}
12387 return _oxmidtunmetadata50masked, nil
12388}
12389
12390func NewOxmIdTunMetadata50Masked() *OxmIdTunMetadata50Masked {
12391 obj := &OxmIdTunMetadata50Masked{
12392 OxmId: NewOxmId(112120),
12393 }
12394 return obj
12395}
12396func (self *OxmIdTunMetadata50Masked) GetOXMName() string {
12397 return "tun_metadata50_masked"
12398}
12399
12400func (self *OxmIdTunMetadata50Masked) MarshalJSON() ([]byte, error) {
12401 if self.TypeLen == 0 {
12402 return []byte("\"\""), nil
12403 } else {
12404 return []byte("\"" + self.GetOXMName() + "\""), nil
12405 }
12406}
12407
12408type OxmIdTunMetadata51 struct {
12409 *OxmId
12410}
12411
12412type IOxmIdTunMetadata51 interface {
12413 IOxmId
12414}
12415
12416func (self *OxmIdTunMetadata51) Serialize(encoder *goloxi.Encoder) error {
12417 if err := self.OxmId.Serialize(encoder); err != nil {
12418 return err
12419 }
12420
12421 return nil
12422}
12423
12424func DecodeOxmIdTunMetadata51(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata51, error) {
12425 _oxmidtunmetadata51 := &OxmIdTunMetadata51{OxmId: parent}
12426 return _oxmidtunmetadata51, nil
12427}
12428
12429func NewOxmIdTunMetadata51() *OxmIdTunMetadata51 {
12430 obj := &OxmIdTunMetadata51{
12431 OxmId: NewOxmId(112252),
12432 }
12433 return obj
12434}
12435func (self *OxmIdTunMetadata51) GetOXMName() string {
12436 return "tun_metadata51"
12437}
12438
12439func (self *OxmIdTunMetadata51) MarshalJSON() ([]byte, error) {
12440 if self.TypeLen == 0 {
12441 return []byte("\"\""), nil
12442 } else {
12443 return []byte("\"" + self.GetOXMName() + "\""), nil
12444 }
12445}
12446
12447type OxmIdTunMetadata51Masked struct {
12448 *OxmId
12449}
12450
12451type IOxmIdTunMetadata51Masked interface {
12452 IOxmId
12453}
12454
12455func (self *OxmIdTunMetadata51Masked) Serialize(encoder *goloxi.Encoder) error {
12456 if err := self.OxmId.Serialize(encoder); err != nil {
12457 return err
12458 }
12459
12460 return nil
12461}
12462
12463func DecodeOxmIdTunMetadata51Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata51Masked, error) {
12464 _oxmidtunmetadata51masked := &OxmIdTunMetadata51Masked{OxmId: parent}
12465 return _oxmidtunmetadata51masked, nil
12466}
12467
12468func NewOxmIdTunMetadata51Masked() *OxmIdTunMetadata51Masked {
12469 obj := &OxmIdTunMetadata51Masked{
12470 OxmId: NewOxmId(112632),
12471 }
12472 return obj
12473}
12474func (self *OxmIdTunMetadata51Masked) GetOXMName() string {
12475 return "tun_metadata51_masked"
12476}
12477
12478func (self *OxmIdTunMetadata51Masked) MarshalJSON() ([]byte, error) {
12479 if self.TypeLen == 0 {
12480 return []byte("\"\""), nil
12481 } else {
12482 return []byte("\"" + self.GetOXMName() + "\""), nil
12483 }
12484}
12485
12486type OxmIdTunMetadata52 struct {
12487 *OxmId
12488}
12489
12490type IOxmIdTunMetadata52 interface {
12491 IOxmId
12492}
12493
12494func (self *OxmIdTunMetadata52) Serialize(encoder *goloxi.Encoder) error {
12495 if err := self.OxmId.Serialize(encoder); err != nil {
12496 return err
12497 }
12498
12499 return nil
12500}
12501
12502func DecodeOxmIdTunMetadata52(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata52, error) {
12503 _oxmidtunmetadata52 := &OxmIdTunMetadata52{OxmId: parent}
12504 return _oxmidtunmetadata52, nil
12505}
12506
12507func NewOxmIdTunMetadata52() *OxmIdTunMetadata52 {
12508 obj := &OxmIdTunMetadata52{
12509 OxmId: NewOxmId(112764),
12510 }
12511 return obj
12512}
12513func (self *OxmIdTunMetadata52) GetOXMName() string {
12514 return "tun_metadata52"
12515}
12516
12517func (self *OxmIdTunMetadata52) MarshalJSON() ([]byte, error) {
12518 if self.TypeLen == 0 {
12519 return []byte("\"\""), nil
12520 } else {
12521 return []byte("\"" + self.GetOXMName() + "\""), nil
12522 }
12523}
12524
12525type OxmIdTunMetadata52Masked struct {
12526 *OxmId
12527}
12528
12529type IOxmIdTunMetadata52Masked interface {
12530 IOxmId
12531}
12532
12533func (self *OxmIdTunMetadata52Masked) Serialize(encoder *goloxi.Encoder) error {
12534 if err := self.OxmId.Serialize(encoder); err != nil {
12535 return err
12536 }
12537
12538 return nil
12539}
12540
12541func DecodeOxmIdTunMetadata52Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata52Masked, error) {
12542 _oxmidtunmetadata52masked := &OxmIdTunMetadata52Masked{OxmId: parent}
12543 return _oxmidtunmetadata52masked, nil
12544}
12545
12546func NewOxmIdTunMetadata52Masked() *OxmIdTunMetadata52Masked {
12547 obj := &OxmIdTunMetadata52Masked{
12548 OxmId: NewOxmId(113144),
12549 }
12550 return obj
12551}
12552func (self *OxmIdTunMetadata52Masked) GetOXMName() string {
12553 return "tun_metadata52_masked"
12554}
12555
12556func (self *OxmIdTunMetadata52Masked) MarshalJSON() ([]byte, error) {
12557 if self.TypeLen == 0 {
12558 return []byte("\"\""), nil
12559 } else {
12560 return []byte("\"" + self.GetOXMName() + "\""), nil
12561 }
12562}
12563
12564type OxmIdTunMetadata53 struct {
12565 *OxmId
12566}
12567
12568type IOxmIdTunMetadata53 interface {
12569 IOxmId
12570}
12571
12572func (self *OxmIdTunMetadata53) Serialize(encoder *goloxi.Encoder) error {
12573 if err := self.OxmId.Serialize(encoder); err != nil {
12574 return err
12575 }
12576
12577 return nil
12578}
12579
12580func DecodeOxmIdTunMetadata53(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata53, error) {
12581 _oxmidtunmetadata53 := &OxmIdTunMetadata53{OxmId: parent}
12582 return _oxmidtunmetadata53, nil
12583}
12584
12585func NewOxmIdTunMetadata53() *OxmIdTunMetadata53 {
12586 obj := &OxmIdTunMetadata53{
12587 OxmId: NewOxmId(113276),
12588 }
12589 return obj
12590}
12591func (self *OxmIdTunMetadata53) GetOXMName() string {
12592 return "tun_metadata53"
12593}
12594
12595func (self *OxmIdTunMetadata53) MarshalJSON() ([]byte, error) {
12596 if self.TypeLen == 0 {
12597 return []byte("\"\""), nil
12598 } else {
12599 return []byte("\"" + self.GetOXMName() + "\""), nil
12600 }
12601}
12602
12603type OxmIdTunMetadata53Masked struct {
12604 *OxmId
12605}
12606
12607type IOxmIdTunMetadata53Masked interface {
12608 IOxmId
12609}
12610
12611func (self *OxmIdTunMetadata53Masked) Serialize(encoder *goloxi.Encoder) error {
12612 if err := self.OxmId.Serialize(encoder); err != nil {
12613 return err
12614 }
12615
12616 return nil
12617}
12618
12619func DecodeOxmIdTunMetadata53Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata53Masked, error) {
12620 _oxmidtunmetadata53masked := &OxmIdTunMetadata53Masked{OxmId: parent}
12621 return _oxmidtunmetadata53masked, nil
12622}
12623
12624func NewOxmIdTunMetadata53Masked() *OxmIdTunMetadata53Masked {
12625 obj := &OxmIdTunMetadata53Masked{
12626 OxmId: NewOxmId(113656),
12627 }
12628 return obj
12629}
12630func (self *OxmIdTunMetadata53Masked) GetOXMName() string {
12631 return "tun_metadata53_masked"
12632}
12633
12634func (self *OxmIdTunMetadata53Masked) MarshalJSON() ([]byte, error) {
12635 if self.TypeLen == 0 {
12636 return []byte("\"\""), nil
12637 } else {
12638 return []byte("\"" + self.GetOXMName() + "\""), nil
12639 }
12640}
12641
12642type OxmIdTunMetadata54 struct {
12643 *OxmId
12644}
12645
12646type IOxmIdTunMetadata54 interface {
12647 IOxmId
12648}
12649
12650func (self *OxmIdTunMetadata54) Serialize(encoder *goloxi.Encoder) error {
12651 if err := self.OxmId.Serialize(encoder); err != nil {
12652 return err
12653 }
12654
12655 return nil
12656}
12657
12658func DecodeOxmIdTunMetadata54(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata54, error) {
12659 _oxmidtunmetadata54 := &OxmIdTunMetadata54{OxmId: parent}
12660 return _oxmidtunmetadata54, nil
12661}
12662
12663func NewOxmIdTunMetadata54() *OxmIdTunMetadata54 {
12664 obj := &OxmIdTunMetadata54{
12665 OxmId: NewOxmId(113788),
12666 }
12667 return obj
12668}
12669func (self *OxmIdTunMetadata54) GetOXMName() string {
12670 return "tun_metadata54"
12671}
12672
12673func (self *OxmIdTunMetadata54) MarshalJSON() ([]byte, error) {
12674 if self.TypeLen == 0 {
12675 return []byte("\"\""), nil
12676 } else {
12677 return []byte("\"" + self.GetOXMName() + "\""), nil
12678 }
12679}
12680
12681type OxmIdTunMetadata54Masked struct {
12682 *OxmId
12683}
12684
12685type IOxmIdTunMetadata54Masked interface {
12686 IOxmId
12687}
12688
12689func (self *OxmIdTunMetadata54Masked) Serialize(encoder *goloxi.Encoder) error {
12690 if err := self.OxmId.Serialize(encoder); err != nil {
12691 return err
12692 }
12693
12694 return nil
12695}
12696
12697func DecodeOxmIdTunMetadata54Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata54Masked, error) {
12698 _oxmidtunmetadata54masked := &OxmIdTunMetadata54Masked{OxmId: parent}
12699 return _oxmidtunmetadata54masked, nil
12700}
12701
12702func NewOxmIdTunMetadata54Masked() *OxmIdTunMetadata54Masked {
12703 obj := &OxmIdTunMetadata54Masked{
12704 OxmId: NewOxmId(114168),
12705 }
12706 return obj
12707}
12708func (self *OxmIdTunMetadata54Masked) GetOXMName() string {
12709 return "tun_metadata54_masked"
12710}
12711
12712func (self *OxmIdTunMetadata54Masked) MarshalJSON() ([]byte, error) {
12713 if self.TypeLen == 0 {
12714 return []byte("\"\""), nil
12715 } else {
12716 return []byte("\"" + self.GetOXMName() + "\""), nil
12717 }
12718}
12719
12720type OxmIdTunMetadata55 struct {
12721 *OxmId
12722}
12723
12724type IOxmIdTunMetadata55 interface {
12725 IOxmId
12726}
12727
12728func (self *OxmIdTunMetadata55) Serialize(encoder *goloxi.Encoder) error {
12729 if err := self.OxmId.Serialize(encoder); err != nil {
12730 return err
12731 }
12732
12733 return nil
12734}
12735
12736func DecodeOxmIdTunMetadata55(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata55, error) {
12737 _oxmidtunmetadata55 := &OxmIdTunMetadata55{OxmId: parent}
12738 return _oxmidtunmetadata55, nil
12739}
12740
12741func NewOxmIdTunMetadata55() *OxmIdTunMetadata55 {
12742 obj := &OxmIdTunMetadata55{
12743 OxmId: NewOxmId(114300),
12744 }
12745 return obj
12746}
12747func (self *OxmIdTunMetadata55) GetOXMName() string {
12748 return "tun_metadata55"
12749}
12750
12751func (self *OxmIdTunMetadata55) MarshalJSON() ([]byte, error) {
12752 if self.TypeLen == 0 {
12753 return []byte("\"\""), nil
12754 } else {
12755 return []byte("\"" + self.GetOXMName() + "\""), nil
12756 }
12757}
12758
12759type OxmIdTunMetadata55Masked struct {
12760 *OxmId
12761}
12762
12763type IOxmIdTunMetadata55Masked interface {
12764 IOxmId
12765}
12766
12767func (self *OxmIdTunMetadata55Masked) Serialize(encoder *goloxi.Encoder) error {
12768 if err := self.OxmId.Serialize(encoder); err != nil {
12769 return err
12770 }
12771
12772 return nil
12773}
12774
12775func DecodeOxmIdTunMetadata55Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata55Masked, error) {
12776 _oxmidtunmetadata55masked := &OxmIdTunMetadata55Masked{OxmId: parent}
12777 return _oxmidtunmetadata55masked, nil
12778}
12779
12780func NewOxmIdTunMetadata55Masked() *OxmIdTunMetadata55Masked {
12781 obj := &OxmIdTunMetadata55Masked{
12782 OxmId: NewOxmId(114680),
12783 }
12784 return obj
12785}
12786func (self *OxmIdTunMetadata55Masked) GetOXMName() string {
12787 return "tun_metadata55_masked"
12788}
12789
12790func (self *OxmIdTunMetadata55Masked) MarshalJSON() ([]byte, error) {
12791 if self.TypeLen == 0 {
12792 return []byte("\"\""), nil
12793 } else {
12794 return []byte("\"" + self.GetOXMName() + "\""), nil
12795 }
12796}
12797
12798type OxmIdTunMetadata56 struct {
12799 *OxmId
12800}
12801
12802type IOxmIdTunMetadata56 interface {
12803 IOxmId
12804}
12805
12806func (self *OxmIdTunMetadata56) Serialize(encoder *goloxi.Encoder) error {
12807 if err := self.OxmId.Serialize(encoder); err != nil {
12808 return err
12809 }
12810
12811 return nil
12812}
12813
12814func DecodeOxmIdTunMetadata56(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata56, error) {
12815 _oxmidtunmetadata56 := &OxmIdTunMetadata56{OxmId: parent}
12816 return _oxmidtunmetadata56, nil
12817}
12818
12819func NewOxmIdTunMetadata56() *OxmIdTunMetadata56 {
12820 obj := &OxmIdTunMetadata56{
12821 OxmId: NewOxmId(114812),
12822 }
12823 return obj
12824}
12825func (self *OxmIdTunMetadata56) GetOXMName() string {
12826 return "tun_metadata56"
12827}
12828
12829func (self *OxmIdTunMetadata56) MarshalJSON() ([]byte, error) {
12830 if self.TypeLen == 0 {
12831 return []byte("\"\""), nil
12832 } else {
12833 return []byte("\"" + self.GetOXMName() + "\""), nil
12834 }
12835}
12836
12837type OxmIdTunMetadata56Masked struct {
12838 *OxmId
12839}
12840
12841type IOxmIdTunMetadata56Masked interface {
12842 IOxmId
12843}
12844
12845func (self *OxmIdTunMetadata56Masked) Serialize(encoder *goloxi.Encoder) error {
12846 if err := self.OxmId.Serialize(encoder); err != nil {
12847 return err
12848 }
12849
12850 return nil
12851}
12852
12853func DecodeOxmIdTunMetadata56Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata56Masked, error) {
12854 _oxmidtunmetadata56masked := &OxmIdTunMetadata56Masked{OxmId: parent}
12855 return _oxmidtunmetadata56masked, nil
12856}
12857
12858func NewOxmIdTunMetadata56Masked() *OxmIdTunMetadata56Masked {
12859 obj := &OxmIdTunMetadata56Masked{
12860 OxmId: NewOxmId(115192),
12861 }
12862 return obj
12863}
12864func (self *OxmIdTunMetadata56Masked) GetOXMName() string {
12865 return "tun_metadata56_masked"
12866}
12867
12868func (self *OxmIdTunMetadata56Masked) MarshalJSON() ([]byte, error) {
12869 if self.TypeLen == 0 {
12870 return []byte("\"\""), nil
12871 } else {
12872 return []byte("\"" + self.GetOXMName() + "\""), nil
12873 }
12874}
12875
12876type OxmIdTunMetadata57 struct {
12877 *OxmId
12878}
12879
12880type IOxmIdTunMetadata57 interface {
12881 IOxmId
12882}
12883
12884func (self *OxmIdTunMetadata57) Serialize(encoder *goloxi.Encoder) error {
12885 if err := self.OxmId.Serialize(encoder); err != nil {
12886 return err
12887 }
12888
12889 return nil
12890}
12891
12892func DecodeOxmIdTunMetadata57(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata57, error) {
12893 _oxmidtunmetadata57 := &OxmIdTunMetadata57{OxmId: parent}
12894 return _oxmidtunmetadata57, nil
12895}
12896
12897func NewOxmIdTunMetadata57() *OxmIdTunMetadata57 {
12898 obj := &OxmIdTunMetadata57{
12899 OxmId: NewOxmId(115324),
12900 }
12901 return obj
12902}
12903func (self *OxmIdTunMetadata57) GetOXMName() string {
12904 return "tun_metadata57"
12905}
12906
12907func (self *OxmIdTunMetadata57) MarshalJSON() ([]byte, error) {
12908 if self.TypeLen == 0 {
12909 return []byte("\"\""), nil
12910 } else {
12911 return []byte("\"" + self.GetOXMName() + "\""), nil
12912 }
12913}
12914
12915type OxmIdTunMetadata57Masked struct {
12916 *OxmId
12917}
12918
12919type IOxmIdTunMetadata57Masked interface {
12920 IOxmId
12921}
12922
12923func (self *OxmIdTunMetadata57Masked) Serialize(encoder *goloxi.Encoder) error {
12924 if err := self.OxmId.Serialize(encoder); err != nil {
12925 return err
12926 }
12927
12928 return nil
12929}
12930
12931func DecodeOxmIdTunMetadata57Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata57Masked, error) {
12932 _oxmidtunmetadata57masked := &OxmIdTunMetadata57Masked{OxmId: parent}
12933 return _oxmidtunmetadata57masked, nil
12934}
12935
12936func NewOxmIdTunMetadata57Masked() *OxmIdTunMetadata57Masked {
12937 obj := &OxmIdTunMetadata57Masked{
12938 OxmId: NewOxmId(115704),
12939 }
12940 return obj
12941}
12942func (self *OxmIdTunMetadata57Masked) GetOXMName() string {
12943 return "tun_metadata57_masked"
12944}
12945
12946func (self *OxmIdTunMetadata57Masked) MarshalJSON() ([]byte, error) {
12947 if self.TypeLen == 0 {
12948 return []byte("\"\""), nil
12949 } else {
12950 return []byte("\"" + self.GetOXMName() + "\""), nil
12951 }
12952}
12953
12954type OxmIdTunMetadata58 struct {
12955 *OxmId
12956}
12957
12958type IOxmIdTunMetadata58 interface {
12959 IOxmId
12960}
12961
12962func (self *OxmIdTunMetadata58) Serialize(encoder *goloxi.Encoder) error {
12963 if err := self.OxmId.Serialize(encoder); err != nil {
12964 return err
12965 }
12966
12967 return nil
12968}
12969
12970func DecodeOxmIdTunMetadata58(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata58, error) {
12971 _oxmidtunmetadata58 := &OxmIdTunMetadata58{OxmId: parent}
12972 return _oxmidtunmetadata58, nil
12973}
12974
12975func NewOxmIdTunMetadata58() *OxmIdTunMetadata58 {
12976 obj := &OxmIdTunMetadata58{
12977 OxmId: NewOxmId(115836),
12978 }
12979 return obj
12980}
12981func (self *OxmIdTunMetadata58) GetOXMName() string {
12982 return "tun_metadata58"
12983}
12984
12985func (self *OxmIdTunMetadata58) MarshalJSON() ([]byte, error) {
12986 if self.TypeLen == 0 {
12987 return []byte("\"\""), nil
12988 } else {
12989 return []byte("\"" + self.GetOXMName() + "\""), nil
12990 }
12991}
12992
12993type OxmIdTunMetadata58Masked struct {
12994 *OxmId
12995}
12996
12997type IOxmIdTunMetadata58Masked interface {
12998 IOxmId
12999}
13000
13001func (self *OxmIdTunMetadata58Masked) Serialize(encoder *goloxi.Encoder) error {
13002 if err := self.OxmId.Serialize(encoder); err != nil {
13003 return err
13004 }
13005
13006 return nil
13007}
13008
13009func DecodeOxmIdTunMetadata58Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata58Masked, error) {
13010 _oxmidtunmetadata58masked := &OxmIdTunMetadata58Masked{OxmId: parent}
13011 return _oxmidtunmetadata58masked, nil
13012}
13013
13014func NewOxmIdTunMetadata58Masked() *OxmIdTunMetadata58Masked {
13015 obj := &OxmIdTunMetadata58Masked{
13016 OxmId: NewOxmId(116216),
13017 }
13018 return obj
13019}
13020func (self *OxmIdTunMetadata58Masked) GetOXMName() string {
13021 return "tun_metadata58_masked"
13022}
13023
13024func (self *OxmIdTunMetadata58Masked) MarshalJSON() ([]byte, error) {
13025 if self.TypeLen == 0 {
13026 return []byte("\"\""), nil
13027 } else {
13028 return []byte("\"" + self.GetOXMName() + "\""), nil
13029 }
13030}
13031
13032type OxmIdTunMetadata59 struct {
13033 *OxmId
13034}
13035
13036type IOxmIdTunMetadata59 interface {
13037 IOxmId
13038}
13039
13040func (self *OxmIdTunMetadata59) Serialize(encoder *goloxi.Encoder) error {
13041 if err := self.OxmId.Serialize(encoder); err != nil {
13042 return err
13043 }
13044
13045 return nil
13046}
13047
13048func DecodeOxmIdTunMetadata59(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata59, error) {
13049 _oxmidtunmetadata59 := &OxmIdTunMetadata59{OxmId: parent}
13050 return _oxmidtunmetadata59, nil
13051}
13052
13053func NewOxmIdTunMetadata59() *OxmIdTunMetadata59 {
13054 obj := &OxmIdTunMetadata59{
13055 OxmId: NewOxmId(116348),
13056 }
13057 return obj
13058}
13059func (self *OxmIdTunMetadata59) GetOXMName() string {
13060 return "tun_metadata59"
13061}
13062
13063func (self *OxmIdTunMetadata59) MarshalJSON() ([]byte, error) {
13064 if self.TypeLen == 0 {
13065 return []byte("\"\""), nil
13066 } else {
13067 return []byte("\"" + self.GetOXMName() + "\""), nil
13068 }
13069}
13070
13071type OxmIdTunMetadata59Masked struct {
13072 *OxmId
13073}
13074
13075type IOxmIdTunMetadata59Masked interface {
13076 IOxmId
13077}
13078
13079func (self *OxmIdTunMetadata59Masked) Serialize(encoder *goloxi.Encoder) error {
13080 if err := self.OxmId.Serialize(encoder); err != nil {
13081 return err
13082 }
13083
13084 return nil
13085}
13086
13087func DecodeOxmIdTunMetadata59Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata59Masked, error) {
13088 _oxmidtunmetadata59masked := &OxmIdTunMetadata59Masked{OxmId: parent}
13089 return _oxmidtunmetadata59masked, nil
13090}
13091
13092func NewOxmIdTunMetadata59Masked() *OxmIdTunMetadata59Masked {
13093 obj := &OxmIdTunMetadata59Masked{
13094 OxmId: NewOxmId(116728),
13095 }
13096 return obj
13097}
13098func (self *OxmIdTunMetadata59Masked) GetOXMName() string {
13099 return "tun_metadata59_masked"
13100}
13101
13102func (self *OxmIdTunMetadata59Masked) MarshalJSON() ([]byte, error) {
13103 if self.TypeLen == 0 {
13104 return []byte("\"\""), nil
13105 } else {
13106 return []byte("\"" + self.GetOXMName() + "\""), nil
13107 }
13108}
13109
13110type OxmIdTunMetadata5Masked struct {
13111 *OxmId
13112}
13113
13114type IOxmIdTunMetadata5Masked interface {
13115 IOxmId
13116}
13117
13118func (self *OxmIdTunMetadata5Masked) Serialize(encoder *goloxi.Encoder) error {
13119 if err := self.OxmId.Serialize(encoder); err != nil {
13120 return err
13121 }
13122
13123 return nil
13124}
13125
13126func DecodeOxmIdTunMetadata5Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata5Masked, error) {
13127 _oxmidtunmetadata5masked := &OxmIdTunMetadata5Masked{OxmId: parent}
13128 return _oxmidtunmetadata5masked, nil
13129}
13130
13131func NewOxmIdTunMetadata5Masked() *OxmIdTunMetadata5Masked {
13132 obj := &OxmIdTunMetadata5Masked{
13133 OxmId: NewOxmId(89080),
13134 }
13135 return obj
13136}
13137func (self *OxmIdTunMetadata5Masked) GetOXMName() string {
13138 return "tun_metadata5_masked"
13139}
13140
13141func (self *OxmIdTunMetadata5Masked) MarshalJSON() ([]byte, error) {
13142 if self.TypeLen == 0 {
13143 return []byte("\"\""), nil
13144 } else {
13145 return []byte("\"" + self.GetOXMName() + "\""), nil
13146 }
13147}
13148
13149type OxmIdTunMetadata6 struct {
13150 *OxmId
13151}
13152
13153type IOxmIdTunMetadata6 interface {
13154 IOxmId
13155}
13156
13157func (self *OxmIdTunMetadata6) Serialize(encoder *goloxi.Encoder) error {
13158 if err := self.OxmId.Serialize(encoder); err != nil {
13159 return err
13160 }
13161
13162 return nil
13163}
13164
13165func DecodeOxmIdTunMetadata6(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata6, error) {
13166 _oxmidtunmetadata6 := &OxmIdTunMetadata6{OxmId: parent}
13167 return _oxmidtunmetadata6, nil
13168}
13169
13170func NewOxmIdTunMetadata6() *OxmIdTunMetadata6 {
13171 obj := &OxmIdTunMetadata6{
13172 OxmId: NewOxmId(89212),
13173 }
13174 return obj
13175}
13176func (self *OxmIdTunMetadata6) GetOXMName() string {
13177 return "tun_metadata6"
13178}
13179
13180func (self *OxmIdTunMetadata6) MarshalJSON() ([]byte, error) {
13181 if self.TypeLen == 0 {
13182 return []byte("\"\""), nil
13183 } else {
13184 return []byte("\"" + self.GetOXMName() + "\""), nil
13185 }
13186}
13187
13188type OxmIdTunMetadata60 struct {
13189 *OxmId
13190}
13191
13192type IOxmIdTunMetadata60 interface {
13193 IOxmId
13194}
13195
13196func (self *OxmIdTunMetadata60) Serialize(encoder *goloxi.Encoder) error {
13197 if err := self.OxmId.Serialize(encoder); err != nil {
13198 return err
13199 }
13200
13201 return nil
13202}
13203
13204func DecodeOxmIdTunMetadata60(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata60, error) {
13205 _oxmidtunmetadata60 := &OxmIdTunMetadata60{OxmId: parent}
13206 return _oxmidtunmetadata60, nil
13207}
13208
13209func NewOxmIdTunMetadata60() *OxmIdTunMetadata60 {
13210 obj := &OxmIdTunMetadata60{
13211 OxmId: NewOxmId(116860),
13212 }
13213 return obj
13214}
13215func (self *OxmIdTunMetadata60) GetOXMName() string {
13216 return "tun_metadata60"
13217}
13218
13219func (self *OxmIdTunMetadata60) MarshalJSON() ([]byte, error) {
13220 if self.TypeLen == 0 {
13221 return []byte("\"\""), nil
13222 } else {
13223 return []byte("\"" + self.GetOXMName() + "\""), nil
13224 }
13225}
13226
13227type OxmIdTunMetadata60Masked struct {
13228 *OxmId
13229}
13230
13231type IOxmIdTunMetadata60Masked interface {
13232 IOxmId
13233}
13234
13235func (self *OxmIdTunMetadata60Masked) Serialize(encoder *goloxi.Encoder) error {
13236 if err := self.OxmId.Serialize(encoder); err != nil {
13237 return err
13238 }
13239
13240 return nil
13241}
13242
13243func DecodeOxmIdTunMetadata60Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata60Masked, error) {
13244 _oxmidtunmetadata60masked := &OxmIdTunMetadata60Masked{OxmId: parent}
13245 return _oxmidtunmetadata60masked, nil
13246}
13247
13248func NewOxmIdTunMetadata60Masked() *OxmIdTunMetadata60Masked {
13249 obj := &OxmIdTunMetadata60Masked{
13250 OxmId: NewOxmId(117240),
13251 }
13252 return obj
13253}
13254func (self *OxmIdTunMetadata60Masked) GetOXMName() string {
13255 return "tun_metadata60_masked"
13256}
13257
13258func (self *OxmIdTunMetadata60Masked) MarshalJSON() ([]byte, error) {
13259 if self.TypeLen == 0 {
13260 return []byte("\"\""), nil
13261 } else {
13262 return []byte("\"" + self.GetOXMName() + "\""), nil
13263 }
13264}
13265
13266type OxmIdTunMetadata61 struct {
13267 *OxmId
13268}
13269
13270type IOxmIdTunMetadata61 interface {
13271 IOxmId
13272}
13273
13274func (self *OxmIdTunMetadata61) Serialize(encoder *goloxi.Encoder) error {
13275 if err := self.OxmId.Serialize(encoder); err != nil {
13276 return err
13277 }
13278
13279 return nil
13280}
13281
13282func DecodeOxmIdTunMetadata61(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata61, error) {
13283 _oxmidtunmetadata61 := &OxmIdTunMetadata61{OxmId: parent}
13284 return _oxmidtunmetadata61, nil
13285}
13286
13287func NewOxmIdTunMetadata61() *OxmIdTunMetadata61 {
13288 obj := &OxmIdTunMetadata61{
13289 OxmId: NewOxmId(117372),
13290 }
13291 return obj
13292}
13293func (self *OxmIdTunMetadata61) GetOXMName() string {
13294 return "tun_metadata61"
13295}
13296
13297func (self *OxmIdTunMetadata61) MarshalJSON() ([]byte, error) {
13298 if self.TypeLen == 0 {
13299 return []byte("\"\""), nil
13300 } else {
13301 return []byte("\"" + self.GetOXMName() + "\""), nil
13302 }
13303}
13304
13305type OxmIdTunMetadata61Masked struct {
13306 *OxmId
13307}
13308
13309type IOxmIdTunMetadata61Masked interface {
13310 IOxmId
13311}
13312
13313func (self *OxmIdTunMetadata61Masked) Serialize(encoder *goloxi.Encoder) error {
13314 if err := self.OxmId.Serialize(encoder); err != nil {
13315 return err
13316 }
13317
13318 return nil
13319}
13320
13321func DecodeOxmIdTunMetadata61Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata61Masked, error) {
13322 _oxmidtunmetadata61masked := &OxmIdTunMetadata61Masked{OxmId: parent}
13323 return _oxmidtunmetadata61masked, nil
13324}
13325
13326func NewOxmIdTunMetadata61Masked() *OxmIdTunMetadata61Masked {
13327 obj := &OxmIdTunMetadata61Masked{
13328 OxmId: NewOxmId(117752),
13329 }
13330 return obj
13331}
13332func (self *OxmIdTunMetadata61Masked) GetOXMName() string {
13333 return "tun_metadata61_masked"
13334}
13335
13336func (self *OxmIdTunMetadata61Masked) MarshalJSON() ([]byte, error) {
13337 if self.TypeLen == 0 {
13338 return []byte("\"\""), nil
13339 } else {
13340 return []byte("\"" + self.GetOXMName() + "\""), nil
13341 }
13342}
13343
13344type OxmIdTunMetadata62 struct {
13345 *OxmId
13346}
13347
13348type IOxmIdTunMetadata62 interface {
13349 IOxmId
13350}
13351
13352func (self *OxmIdTunMetadata62) Serialize(encoder *goloxi.Encoder) error {
13353 if err := self.OxmId.Serialize(encoder); err != nil {
13354 return err
13355 }
13356
13357 return nil
13358}
13359
13360func DecodeOxmIdTunMetadata62(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata62, error) {
13361 _oxmidtunmetadata62 := &OxmIdTunMetadata62{OxmId: parent}
13362 return _oxmidtunmetadata62, nil
13363}
13364
13365func NewOxmIdTunMetadata62() *OxmIdTunMetadata62 {
13366 obj := &OxmIdTunMetadata62{
13367 OxmId: NewOxmId(117884),
13368 }
13369 return obj
13370}
13371func (self *OxmIdTunMetadata62) GetOXMName() string {
13372 return "tun_metadata62"
13373}
13374
13375func (self *OxmIdTunMetadata62) MarshalJSON() ([]byte, error) {
13376 if self.TypeLen == 0 {
13377 return []byte("\"\""), nil
13378 } else {
13379 return []byte("\"" + self.GetOXMName() + "\""), nil
13380 }
13381}
13382
13383type OxmIdTunMetadata62Masked struct {
13384 *OxmId
13385}
13386
13387type IOxmIdTunMetadata62Masked interface {
13388 IOxmId
13389}
13390
13391func (self *OxmIdTunMetadata62Masked) Serialize(encoder *goloxi.Encoder) error {
13392 if err := self.OxmId.Serialize(encoder); err != nil {
13393 return err
13394 }
13395
13396 return nil
13397}
13398
13399func DecodeOxmIdTunMetadata62Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata62Masked, error) {
13400 _oxmidtunmetadata62masked := &OxmIdTunMetadata62Masked{OxmId: parent}
13401 return _oxmidtunmetadata62masked, nil
13402}
13403
13404func NewOxmIdTunMetadata62Masked() *OxmIdTunMetadata62Masked {
13405 obj := &OxmIdTunMetadata62Masked{
13406 OxmId: NewOxmId(118264),
13407 }
13408 return obj
13409}
13410func (self *OxmIdTunMetadata62Masked) GetOXMName() string {
13411 return "tun_metadata62_masked"
13412}
13413
13414func (self *OxmIdTunMetadata62Masked) MarshalJSON() ([]byte, error) {
13415 if self.TypeLen == 0 {
13416 return []byte("\"\""), nil
13417 } else {
13418 return []byte("\"" + self.GetOXMName() + "\""), nil
13419 }
13420}
13421
13422type OxmIdTunMetadata63 struct {
13423 *OxmId
13424}
13425
13426type IOxmIdTunMetadata63 interface {
13427 IOxmId
13428}
13429
13430func (self *OxmIdTunMetadata63) Serialize(encoder *goloxi.Encoder) error {
13431 if err := self.OxmId.Serialize(encoder); err != nil {
13432 return err
13433 }
13434
13435 return nil
13436}
13437
13438func DecodeOxmIdTunMetadata63(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata63, error) {
13439 _oxmidtunmetadata63 := &OxmIdTunMetadata63{OxmId: parent}
13440 return _oxmidtunmetadata63, nil
13441}
13442
13443func NewOxmIdTunMetadata63() *OxmIdTunMetadata63 {
13444 obj := &OxmIdTunMetadata63{
13445 OxmId: NewOxmId(118396),
13446 }
13447 return obj
13448}
13449func (self *OxmIdTunMetadata63) GetOXMName() string {
13450 return "tun_metadata63"
13451}
13452
13453func (self *OxmIdTunMetadata63) MarshalJSON() ([]byte, error) {
13454 if self.TypeLen == 0 {
13455 return []byte("\"\""), nil
13456 } else {
13457 return []byte("\"" + self.GetOXMName() + "\""), nil
13458 }
13459}
13460
13461type OxmIdTunMetadata63Masked struct {
13462 *OxmId
13463}
13464
13465type IOxmIdTunMetadata63Masked interface {
13466 IOxmId
13467}
13468
13469func (self *OxmIdTunMetadata63Masked) Serialize(encoder *goloxi.Encoder) error {
13470 if err := self.OxmId.Serialize(encoder); err != nil {
13471 return err
13472 }
13473
13474 return nil
13475}
13476
13477func DecodeOxmIdTunMetadata63Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata63Masked, error) {
13478 _oxmidtunmetadata63masked := &OxmIdTunMetadata63Masked{OxmId: parent}
13479 return _oxmidtunmetadata63masked, nil
13480}
13481
13482func NewOxmIdTunMetadata63Masked() *OxmIdTunMetadata63Masked {
13483 obj := &OxmIdTunMetadata63Masked{
13484 OxmId: NewOxmId(118776),
13485 }
13486 return obj
13487}
13488func (self *OxmIdTunMetadata63Masked) GetOXMName() string {
13489 return "tun_metadata63_masked"
13490}
13491
13492func (self *OxmIdTunMetadata63Masked) MarshalJSON() ([]byte, error) {
13493 if self.TypeLen == 0 {
13494 return []byte("\"\""), nil
13495 } else {
13496 return []byte("\"" + self.GetOXMName() + "\""), nil
13497 }
13498}
13499
13500type OxmIdTunMetadata6Masked struct {
13501 *OxmId
13502}
13503
13504type IOxmIdTunMetadata6Masked interface {
13505 IOxmId
13506}
13507
13508func (self *OxmIdTunMetadata6Masked) Serialize(encoder *goloxi.Encoder) error {
13509 if err := self.OxmId.Serialize(encoder); err != nil {
13510 return err
13511 }
13512
13513 return nil
13514}
13515
13516func DecodeOxmIdTunMetadata6Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata6Masked, error) {
13517 _oxmidtunmetadata6masked := &OxmIdTunMetadata6Masked{OxmId: parent}
13518 return _oxmidtunmetadata6masked, nil
13519}
13520
13521func NewOxmIdTunMetadata6Masked() *OxmIdTunMetadata6Masked {
13522 obj := &OxmIdTunMetadata6Masked{
13523 OxmId: NewOxmId(89592),
13524 }
13525 return obj
13526}
13527func (self *OxmIdTunMetadata6Masked) GetOXMName() string {
13528 return "tun_metadata6_masked"
13529}
13530
13531func (self *OxmIdTunMetadata6Masked) MarshalJSON() ([]byte, error) {
13532 if self.TypeLen == 0 {
13533 return []byte("\"\""), nil
13534 } else {
13535 return []byte("\"" + self.GetOXMName() + "\""), nil
13536 }
13537}
13538
13539type OxmIdTunMetadata7 struct {
13540 *OxmId
13541}
13542
13543type IOxmIdTunMetadata7 interface {
13544 IOxmId
13545}
13546
13547func (self *OxmIdTunMetadata7) Serialize(encoder *goloxi.Encoder) error {
13548 if err := self.OxmId.Serialize(encoder); err != nil {
13549 return err
13550 }
13551
13552 return nil
13553}
13554
13555func DecodeOxmIdTunMetadata7(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata7, error) {
13556 _oxmidtunmetadata7 := &OxmIdTunMetadata7{OxmId: parent}
13557 return _oxmidtunmetadata7, nil
13558}
13559
13560func NewOxmIdTunMetadata7() *OxmIdTunMetadata7 {
13561 obj := &OxmIdTunMetadata7{
13562 OxmId: NewOxmId(89724),
13563 }
13564 return obj
13565}
13566func (self *OxmIdTunMetadata7) GetOXMName() string {
13567 return "tun_metadata7"
13568}
13569
13570func (self *OxmIdTunMetadata7) MarshalJSON() ([]byte, error) {
13571 if self.TypeLen == 0 {
13572 return []byte("\"\""), nil
13573 } else {
13574 return []byte("\"" + self.GetOXMName() + "\""), nil
13575 }
13576}
13577
13578type OxmIdTunMetadata7Masked struct {
13579 *OxmId
13580}
13581
13582type IOxmIdTunMetadata7Masked interface {
13583 IOxmId
13584}
13585
13586func (self *OxmIdTunMetadata7Masked) Serialize(encoder *goloxi.Encoder) error {
13587 if err := self.OxmId.Serialize(encoder); err != nil {
13588 return err
13589 }
13590
13591 return nil
13592}
13593
13594func DecodeOxmIdTunMetadata7Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata7Masked, error) {
13595 _oxmidtunmetadata7masked := &OxmIdTunMetadata7Masked{OxmId: parent}
13596 return _oxmidtunmetadata7masked, nil
13597}
13598
13599func NewOxmIdTunMetadata7Masked() *OxmIdTunMetadata7Masked {
13600 obj := &OxmIdTunMetadata7Masked{
13601 OxmId: NewOxmId(90104),
13602 }
13603 return obj
13604}
13605func (self *OxmIdTunMetadata7Masked) GetOXMName() string {
13606 return "tun_metadata7_masked"
13607}
13608
13609func (self *OxmIdTunMetadata7Masked) MarshalJSON() ([]byte, error) {
13610 if self.TypeLen == 0 {
13611 return []byte("\"\""), nil
13612 } else {
13613 return []byte("\"" + self.GetOXMName() + "\""), nil
13614 }
13615}
13616
13617type OxmIdTunMetadata8 struct {
13618 *OxmId
13619}
13620
13621type IOxmIdTunMetadata8 interface {
13622 IOxmId
13623}
13624
13625func (self *OxmIdTunMetadata8) Serialize(encoder *goloxi.Encoder) error {
13626 if err := self.OxmId.Serialize(encoder); err != nil {
13627 return err
13628 }
13629
13630 return nil
13631}
13632
13633func DecodeOxmIdTunMetadata8(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata8, error) {
13634 _oxmidtunmetadata8 := &OxmIdTunMetadata8{OxmId: parent}
13635 return _oxmidtunmetadata8, nil
13636}
13637
13638func NewOxmIdTunMetadata8() *OxmIdTunMetadata8 {
13639 obj := &OxmIdTunMetadata8{
13640 OxmId: NewOxmId(90236),
13641 }
13642 return obj
13643}
13644func (self *OxmIdTunMetadata8) GetOXMName() string {
13645 return "tun_metadata8"
13646}
13647
13648func (self *OxmIdTunMetadata8) MarshalJSON() ([]byte, error) {
13649 if self.TypeLen == 0 {
13650 return []byte("\"\""), nil
13651 } else {
13652 return []byte("\"" + self.GetOXMName() + "\""), nil
13653 }
13654}
13655
13656type OxmIdTunMetadata8Masked struct {
13657 *OxmId
13658}
13659
13660type IOxmIdTunMetadata8Masked interface {
13661 IOxmId
13662}
13663
13664func (self *OxmIdTunMetadata8Masked) Serialize(encoder *goloxi.Encoder) error {
13665 if err := self.OxmId.Serialize(encoder); err != nil {
13666 return err
13667 }
13668
13669 return nil
13670}
13671
13672func DecodeOxmIdTunMetadata8Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata8Masked, error) {
13673 _oxmidtunmetadata8masked := &OxmIdTunMetadata8Masked{OxmId: parent}
13674 return _oxmidtunmetadata8masked, nil
13675}
13676
13677func NewOxmIdTunMetadata8Masked() *OxmIdTunMetadata8Masked {
13678 obj := &OxmIdTunMetadata8Masked{
13679 OxmId: NewOxmId(90616),
13680 }
13681 return obj
13682}
13683func (self *OxmIdTunMetadata8Masked) GetOXMName() string {
13684 return "tun_metadata8_masked"
13685}
13686
13687func (self *OxmIdTunMetadata8Masked) MarshalJSON() ([]byte, error) {
13688 if self.TypeLen == 0 {
13689 return []byte("\"\""), nil
13690 } else {
13691 return []byte("\"" + self.GetOXMName() + "\""), nil
13692 }
13693}
13694
13695type OxmIdTunMetadata9 struct {
13696 *OxmId
13697}
13698
13699type IOxmIdTunMetadata9 interface {
13700 IOxmId
13701}
13702
13703func (self *OxmIdTunMetadata9) Serialize(encoder *goloxi.Encoder) error {
13704 if err := self.OxmId.Serialize(encoder); err != nil {
13705 return err
13706 }
13707
13708 return nil
13709}
13710
13711func DecodeOxmIdTunMetadata9(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata9, error) {
13712 _oxmidtunmetadata9 := &OxmIdTunMetadata9{OxmId: parent}
13713 return _oxmidtunmetadata9, nil
13714}
13715
13716func NewOxmIdTunMetadata9() *OxmIdTunMetadata9 {
13717 obj := &OxmIdTunMetadata9{
13718 OxmId: NewOxmId(90748),
13719 }
13720 return obj
13721}
13722func (self *OxmIdTunMetadata9) GetOXMName() string {
13723 return "tun_metadata9"
13724}
13725
13726func (self *OxmIdTunMetadata9) MarshalJSON() ([]byte, error) {
13727 if self.TypeLen == 0 {
13728 return []byte("\"\""), nil
13729 } else {
13730 return []byte("\"" + self.GetOXMName() + "\""), nil
13731 }
13732}
13733
13734type OxmIdTunMetadata9Masked struct {
13735 *OxmId
13736}
13737
13738type IOxmIdTunMetadata9Masked interface {
13739 IOxmId
13740}
13741
13742func (self *OxmIdTunMetadata9Masked) Serialize(encoder *goloxi.Encoder) error {
13743 if err := self.OxmId.Serialize(encoder); err != nil {
13744 return err
13745 }
13746
13747 return nil
13748}
13749
13750func DecodeOxmIdTunMetadata9Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata9Masked, error) {
13751 _oxmidtunmetadata9masked := &OxmIdTunMetadata9Masked{OxmId: parent}
13752 return _oxmidtunmetadata9masked, nil
13753}
13754
13755func NewOxmIdTunMetadata9Masked() *OxmIdTunMetadata9Masked {
13756 obj := &OxmIdTunMetadata9Masked{
13757 OxmId: NewOxmId(91128),
13758 }
13759 return obj
13760}
13761func (self *OxmIdTunMetadata9Masked) GetOXMName() string {
13762 return "tun_metadata9_masked"
13763}
13764
13765func (self *OxmIdTunMetadata9Masked) MarshalJSON() ([]byte, error) {
13766 if self.TypeLen == 0 {
13767 return []byte("\"\""), nil
13768 } else {
13769 return []byte("\"" + self.GetOXMName() + "\""), nil
13770 }
13771}
13772
13773type OxmIdTunSrc struct {
13774 *OxmId
13775}
13776
13777type IOxmIdTunSrc interface {
13778 IOxmId
13779}
13780
13781func (self *OxmIdTunSrc) Serialize(encoder *goloxi.Encoder) error {
13782 if err := self.OxmId.Serialize(encoder); err != nil {
13783 return err
13784 }
13785
13786 return nil
13787}
13788
13789func DecodeOxmIdTunSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunSrc, error) {
13790 _oxmidtunsrc := &OxmIdTunSrc{OxmId: parent}
13791 return _oxmidtunsrc, nil
13792}
13793
13794func NewOxmIdTunSrc() *OxmIdTunSrc {
13795 obj := &OxmIdTunSrc{
13796 OxmId: NewOxmId(81412),
13797 }
13798 return obj
13799}
13800func (self *OxmIdTunSrc) GetOXMName() string {
13801 return "tun_src"
13802}
13803
13804func (self *OxmIdTunSrc) MarshalJSON() ([]byte, error) {
13805 if self.TypeLen == 0 {
13806 return []byte("\"\""), nil
13807 } else {
13808 return []byte("\"" + self.GetOXMName() + "\""), nil
13809 }
13810}
13811
13812type OxmIdTunSrcMasked struct {
13813 *OxmId
13814}
13815
13816type IOxmIdTunSrcMasked interface {
13817 IOxmId
13818}
13819
13820func (self *OxmIdTunSrcMasked) Serialize(encoder *goloxi.Encoder) error {
13821 if err := self.OxmId.Serialize(encoder); err != nil {
13822 return err
13823 }
13824
13825 return nil
13826}
13827
13828func DecodeOxmIdTunSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunSrcMasked, error) {
13829 _oxmidtunsrcmasked := &OxmIdTunSrcMasked{OxmId: parent}
13830 return _oxmidtunsrcmasked, nil
13831}
13832
13833func NewOxmIdTunSrcMasked() *OxmIdTunSrcMasked {
13834 obj := &OxmIdTunSrcMasked{
13835 OxmId: NewOxmId(81672),
13836 }
13837 return obj
13838}
13839func (self *OxmIdTunSrcMasked) GetOXMName() string {
13840 return "tun_src_masked"
13841}
13842
13843func (self *OxmIdTunSrcMasked) MarshalJSON() ([]byte, error) {
13844 if self.TypeLen == 0 {
13845 return []byte("\"\""), nil
13846 } else {
13847 return []byte("\"" + self.GetOXMName() + "\""), nil
13848 }
13849}
13850
13851type OxmIdUdpDst struct {
13852 *OxmId
13853}
13854
13855type IOxmIdUdpDst interface {
13856 IOxmId
13857}
13858
13859func (self *OxmIdUdpDst) Serialize(encoder *goloxi.Encoder) error {
13860 if err := self.OxmId.Serialize(encoder); err != nil {
13861 return err
13862 }
13863
13864 return nil
13865}
13866
13867func DecodeOxmIdUdpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpDst, error) {
13868 _oxmidudpdst := &OxmIdUdpDst{OxmId: parent}
13869 return _oxmidudpdst, nil
13870}
13871
13872func NewOxmIdUdpDst() *OxmIdUdpDst {
13873 obj := &OxmIdUdpDst{
13874 OxmId: NewOxmId(6146),
13875 }
13876 return obj
13877}
13878func (self *OxmIdUdpDst) GetOXMName() string {
13879 return "udp_dst"
13880}
13881
13882func (self *OxmIdUdpDst) MarshalJSON() ([]byte, error) {
13883 if self.TypeLen == 0 {
13884 return []byte("\"\""), nil
13885 } else {
13886 return []byte("\"" + self.GetOXMName() + "\""), nil
13887 }
13888}
13889
13890type OxmIdUdpDstMasked struct {
13891 *OxmId
13892}
13893
13894type IOxmIdUdpDstMasked interface {
13895 IOxmId
13896}
13897
13898func (self *OxmIdUdpDstMasked) Serialize(encoder *goloxi.Encoder) error {
13899 if err := self.OxmId.Serialize(encoder); err != nil {
13900 return err
13901 }
13902
13903 return nil
13904}
13905
13906func DecodeOxmIdUdpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpDstMasked, error) {
13907 _oxmidudpdstmasked := &OxmIdUdpDstMasked{OxmId: parent}
13908 return _oxmidudpdstmasked, nil
13909}
13910
13911func NewOxmIdUdpDstMasked() *OxmIdUdpDstMasked {
13912 obj := &OxmIdUdpDstMasked{
13913 OxmId: NewOxmId(6404),
13914 }
13915 return obj
13916}
13917func (self *OxmIdUdpDstMasked) GetOXMName() string {
13918 return "udp_dst_masked"
13919}
13920
13921func (self *OxmIdUdpDstMasked) MarshalJSON() ([]byte, error) {
13922 if self.TypeLen == 0 {
13923 return []byte("\"\""), nil
13924 } else {
13925 return []byte("\"" + self.GetOXMName() + "\""), nil
13926 }
13927}
13928
13929type OxmIdUdpSrc struct {
13930 *OxmId
13931}
13932
13933type IOxmIdUdpSrc interface {
13934 IOxmId
13935}
13936
13937func (self *OxmIdUdpSrc) Serialize(encoder *goloxi.Encoder) error {
13938 if err := self.OxmId.Serialize(encoder); err != nil {
13939 return err
13940 }
13941
13942 return nil
13943}
13944
13945func DecodeOxmIdUdpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpSrc, error) {
13946 _oxmidudpsrc := &OxmIdUdpSrc{OxmId: parent}
13947 return _oxmidudpsrc, nil
13948}
13949
13950func NewOxmIdUdpSrc() *OxmIdUdpSrc {
13951 obj := &OxmIdUdpSrc{
13952 OxmId: NewOxmId(5634),
13953 }
13954 return obj
13955}
13956func (self *OxmIdUdpSrc) GetOXMName() string {
13957 return "udp_src"
13958}
13959
13960func (self *OxmIdUdpSrc) MarshalJSON() ([]byte, error) {
13961 if self.TypeLen == 0 {
13962 return []byte("\"\""), nil
13963 } else {
13964 return []byte("\"" + self.GetOXMName() + "\""), nil
13965 }
13966}
13967
13968type OxmIdUdpSrcMasked struct {
13969 *OxmId
13970}
13971
13972type IOxmIdUdpSrcMasked interface {
13973 IOxmId
13974}
13975
13976func (self *OxmIdUdpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
13977 if err := self.OxmId.Serialize(encoder); err != nil {
13978 return err
13979 }
13980
13981 return nil
13982}
13983
13984func DecodeOxmIdUdpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpSrcMasked, error) {
13985 _oxmidudpsrcmasked := &OxmIdUdpSrcMasked{OxmId: parent}
13986 return _oxmidudpsrcmasked, nil
13987}
13988
13989func NewOxmIdUdpSrcMasked() *OxmIdUdpSrcMasked {
13990 obj := &OxmIdUdpSrcMasked{
13991 OxmId: NewOxmId(5892),
13992 }
13993 return obj
13994}
13995func (self *OxmIdUdpSrcMasked) GetOXMName() string {
13996 return "udp_src_masked"
13997}
13998
13999func (self *OxmIdUdpSrcMasked) MarshalJSON() ([]byte, error) {
14000 if self.TypeLen == 0 {
14001 return []byte("\"\""), nil
14002 } else {
14003 return []byte("\"" + self.GetOXMName() + "\""), nil
14004 }
14005}
14006
14007type OxmIdVlanTci struct {
14008 *OxmId
14009}
14010
14011type IOxmIdVlanTci interface {
14012 IOxmId
14013}
14014
14015func (self *OxmIdVlanTci) Serialize(encoder *goloxi.Encoder) error {
14016 if err := self.OxmId.Serialize(encoder); err != nil {
14017 return err
14018 }
14019
14020 return nil
14021}
14022
14023func DecodeOxmIdVlanTci(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanTci, error) {
14024 _oxmidvlantci := &OxmIdVlanTci{OxmId: parent}
14025 return _oxmidvlantci, nil
14026}
14027
14028func NewOxmIdVlanTci() *OxmIdVlanTci {
14029 obj := &OxmIdVlanTci{
14030 OxmId: NewOxmId(2050),
14031 }
14032 return obj
14033}
14034func (self *OxmIdVlanTci) GetOXMName() string {
14035 return "vlan_tci"
14036}
14037
14038func (self *OxmIdVlanTci) MarshalJSON() ([]byte, error) {
14039 if self.TypeLen == 0 {
14040 return []byte("\"\""), nil
14041 } else {
14042 return []byte("\"" + self.GetOXMName() + "\""), nil
14043 }
14044}
14045
14046type OxmIdVlanTciMasked struct {
14047 *OxmId
14048}
14049
14050type IOxmIdVlanTciMasked interface {
14051 IOxmId
14052}
14053
14054func (self *OxmIdVlanTciMasked) Serialize(encoder *goloxi.Encoder) error {
14055 if err := self.OxmId.Serialize(encoder); err != nil {
14056 return err
14057 }
14058
14059 return nil
14060}
14061
14062func DecodeOxmIdVlanTciMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanTciMasked, error) {
14063 _oxmidvlantcimasked := &OxmIdVlanTciMasked{OxmId: parent}
14064 return _oxmidvlantcimasked, nil
14065}
14066
14067func NewOxmIdVlanTciMasked() *OxmIdVlanTciMasked {
14068 obj := &OxmIdVlanTciMasked{
14069 OxmId: NewOxmId(2308),
14070 }
14071 return obj
14072}
14073func (self *OxmIdVlanTciMasked) GetOXMName() string {
14074 return "vlan_tci_masked"
14075}
14076
14077func (self *OxmIdVlanTciMasked) MarshalJSON() ([]byte, error) {
14078 if self.TypeLen == 0 {
14079 return []byte("\"\""), nil
14080 } else {
14081 return []byte("\"" + self.GetOXMName() + "\""), nil
14082 }
14083}
14084
14085type OxmIdXxreg0 struct {
14086 *OxmId
14087}
14088
14089type IOxmIdXxreg0 interface {
14090 IOxmId
14091}
14092
14093func (self *OxmIdXxreg0) Serialize(encoder *goloxi.Encoder) error {
14094 if err := self.OxmId.Serialize(encoder); err != nil {
14095 return err
14096 }
14097
14098 return nil
14099}
14100
14101func DecodeOxmIdXxreg0(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg0, error) {
14102 _oxmidxxreg0 := &OxmIdXxreg0{OxmId: parent}
14103 return _oxmidxxreg0, nil
14104}
14105
14106func NewOxmIdXxreg0() *OxmIdXxreg0 {
14107 obj := &OxmIdXxreg0{
14108 OxmId: NewOxmId(122384),
14109 }
14110 return obj
14111}
14112func (self *OxmIdXxreg0) GetOXMName() string {
14113 return "xxreg0"
14114}
14115
14116func (self *OxmIdXxreg0) MarshalJSON() ([]byte, error) {
14117 if self.TypeLen == 0 {
14118 return []byte("\"\""), nil
14119 } else {
14120 return []byte("\"" + self.GetOXMName() + "\""), nil
14121 }
14122}
14123
14124type OxmIdXxreg0Masked struct {
14125 *OxmId
14126}
14127
14128type IOxmIdXxreg0Masked interface {
14129 IOxmId
14130}
14131
14132func (self *OxmIdXxreg0Masked) Serialize(encoder *goloxi.Encoder) error {
14133 if err := self.OxmId.Serialize(encoder); err != nil {
14134 return err
14135 }
14136
14137 return nil
14138}
14139
14140func DecodeOxmIdXxreg0Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg0Masked, error) {
14141 _oxmidxxreg0masked := &OxmIdXxreg0Masked{OxmId: parent}
14142 return _oxmidxxreg0masked, nil
14143}
14144
14145func NewOxmIdXxreg0Masked() *OxmIdXxreg0Masked {
14146 obj := &OxmIdXxreg0Masked{
14147 OxmId: NewOxmId(122656),
14148 }
14149 return obj
14150}
14151func (self *OxmIdXxreg0Masked) GetOXMName() string {
14152 return "xxreg0_masked"
14153}
14154
14155func (self *OxmIdXxreg0Masked) MarshalJSON() ([]byte, error) {
14156 if self.TypeLen == 0 {
14157 return []byte("\"\""), nil
14158 } else {
14159 return []byte("\"" + self.GetOXMName() + "\""), nil
14160 }
14161}
14162
14163type OxmIdXxreg1 struct {
14164 *OxmId
14165}
14166
14167type IOxmIdXxreg1 interface {
14168 IOxmId
14169}
14170
14171func (self *OxmIdXxreg1) Serialize(encoder *goloxi.Encoder) error {
14172 if err := self.OxmId.Serialize(encoder); err != nil {
14173 return err
14174 }
14175
14176 return nil
14177}
14178
14179func DecodeOxmIdXxreg1(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg1, error) {
14180 _oxmidxxreg1 := &OxmIdXxreg1{OxmId: parent}
14181 return _oxmidxxreg1, nil
14182}
14183
14184func NewOxmIdXxreg1() *OxmIdXxreg1 {
14185 obj := &OxmIdXxreg1{
14186 OxmId: NewOxmId(122896),
14187 }
14188 return obj
14189}
14190func (self *OxmIdXxreg1) GetOXMName() string {
14191 return "xxreg1"
14192}
14193
14194func (self *OxmIdXxreg1) MarshalJSON() ([]byte, error) {
14195 if self.TypeLen == 0 {
14196 return []byte("\"\""), nil
14197 } else {
14198 return []byte("\"" + self.GetOXMName() + "\""), nil
14199 }
14200}
14201
14202type OxmIdXxreg1Masked struct {
14203 *OxmId
14204}
14205
14206type IOxmIdXxreg1Masked interface {
14207 IOxmId
14208}
14209
14210func (self *OxmIdXxreg1Masked) Serialize(encoder *goloxi.Encoder) error {
14211 if err := self.OxmId.Serialize(encoder); err != nil {
14212 return err
14213 }
14214
14215 return nil
14216}
14217
14218func DecodeOxmIdXxreg1Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg1Masked, error) {
14219 _oxmidxxreg1masked := &OxmIdXxreg1Masked{OxmId: parent}
14220 return _oxmidxxreg1masked, nil
14221}
14222
14223func NewOxmIdXxreg1Masked() *OxmIdXxreg1Masked {
14224 obj := &OxmIdXxreg1Masked{
14225 OxmId: NewOxmId(123168),
14226 }
14227 return obj
14228}
14229func (self *OxmIdXxreg1Masked) GetOXMName() string {
14230 return "xxreg1_masked"
14231}
14232
14233func (self *OxmIdXxreg1Masked) MarshalJSON() ([]byte, error) {
14234 if self.TypeLen == 0 {
14235 return []byte("\"\""), nil
14236 } else {
14237 return []byte("\"" + self.GetOXMName() + "\""), nil
14238 }
14239}
14240
14241type OxmIdXxreg2 struct {
14242 *OxmId
14243}
14244
14245type IOxmIdXxreg2 interface {
14246 IOxmId
14247}
14248
14249func (self *OxmIdXxreg2) Serialize(encoder *goloxi.Encoder) error {
14250 if err := self.OxmId.Serialize(encoder); err != nil {
14251 return err
14252 }
14253
14254 return nil
14255}
14256
14257func DecodeOxmIdXxreg2(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg2, error) {
14258 _oxmidxxreg2 := &OxmIdXxreg2{OxmId: parent}
14259 return _oxmidxxreg2, nil
14260}
14261
14262func NewOxmIdXxreg2() *OxmIdXxreg2 {
14263 obj := &OxmIdXxreg2{
14264 OxmId: NewOxmId(123408),
14265 }
14266 return obj
14267}
14268func (self *OxmIdXxreg2) GetOXMName() string {
14269 return "xxreg2"
14270}
14271
14272func (self *OxmIdXxreg2) MarshalJSON() ([]byte, error) {
14273 if self.TypeLen == 0 {
14274 return []byte("\"\""), nil
14275 } else {
14276 return []byte("\"" + self.GetOXMName() + "\""), nil
14277 }
14278}
14279
14280type OxmIdXxreg2Masked struct {
14281 *OxmId
14282}
14283
14284type IOxmIdXxreg2Masked interface {
14285 IOxmId
14286}
14287
14288func (self *OxmIdXxreg2Masked) Serialize(encoder *goloxi.Encoder) error {
14289 if err := self.OxmId.Serialize(encoder); err != nil {
14290 return err
14291 }
14292
14293 return nil
14294}
14295
14296func DecodeOxmIdXxreg2Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg2Masked, error) {
14297 _oxmidxxreg2masked := &OxmIdXxreg2Masked{OxmId: parent}
14298 return _oxmidxxreg2masked, nil
14299}
14300
14301func NewOxmIdXxreg2Masked() *OxmIdXxreg2Masked {
14302 obj := &OxmIdXxreg2Masked{
14303 OxmId: NewOxmId(123680),
14304 }
14305 return obj
14306}
14307func (self *OxmIdXxreg2Masked) GetOXMName() string {
14308 return "xxreg2_masked"
14309}
14310
14311func (self *OxmIdXxreg2Masked) MarshalJSON() ([]byte, error) {
14312 if self.TypeLen == 0 {
14313 return []byte("\"\""), nil
14314 } else {
14315 return []byte("\"" + self.GetOXMName() + "\""), nil
14316 }
14317}
14318
14319type OxmIdXxreg3 struct {
14320 *OxmId
14321}
14322
14323type IOxmIdXxreg3 interface {
14324 IOxmId
14325}
14326
14327func (self *OxmIdXxreg3) Serialize(encoder *goloxi.Encoder) error {
14328 if err := self.OxmId.Serialize(encoder); err != nil {
14329 return err
14330 }
14331
14332 return nil
14333}
14334
14335func DecodeOxmIdXxreg3(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg3, error) {
14336 _oxmidxxreg3 := &OxmIdXxreg3{OxmId: parent}
14337 return _oxmidxxreg3, nil
14338}
14339
14340func NewOxmIdXxreg3() *OxmIdXxreg3 {
14341 obj := &OxmIdXxreg3{
14342 OxmId: NewOxmId(123920),
14343 }
14344 return obj
14345}
14346func (self *OxmIdXxreg3) GetOXMName() string {
14347 return "xxreg3"
14348}
14349
14350func (self *OxmIdXxreg3) MarshalJSON() ([]byte, error) {
14351 if self.TypeLen == 0 {
14352 return []byte("\"\""), nil
14353 } else {
14354 return []byte("\"" + self.GetOXMName() + "\""), nil
14355 }
14356}
14357
14358type OxmIdXxreg3Masked struct {
14359 *OxmId
14360}
14361
14362type IOxmIdXxreg3Masked interface {
14363 IOxmId
14364}
14365
14366func (self *OxmIdXxreg3Masked) Serialize(encoder *goloxi.Encoder) error {
14367 if err := self.OxmId.Serialize(encoder); err != nil {
14368 return err
14369 }
14370
14371 return nil
14372}
14373
14374func DecodeOxmIdXxreg3Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg3Masked, error) {
14375 _oxmidxxreg3masked := &OxmIdXxreg3Masked{OxmId: parent}
14376 return _oxmidxxreg3masked, nil
14377}
14378
14379func NewOxmIdXxreg3Masked() *OxmIdXxreg3Masked {
14380 obj := &OxmIdXxreg3Masked{
14381 OxmId: NewOxmId(124192),
14382 }
14383 return obj
14384}
14385func (self *OxmIdXxreg3Masked) GetOXMName() string {
14386 return "xxreg3_masked"
14387}
14388
14389func (self *OxmIdXxreg3Masked) MarshalJSON() ([]byte, error) {
14390 if self.TypeLen == 0 {
14391 return []byte("\"\""), nil
14392 } else {
14393 return []byte("\"" + self.GetOXMName() + "\""), nil
14394 }
14395}
14396
14397type OxmIdArpOpMasked struct {
14398 *OxmId
14399}
14400
14401type IOxmIdArpOpMasked interface {
14402 IOxmId
14403}
14404
14405func (self *OxmIdArpOpMasked) Serialize(encoder *goloxi.Encoder) error {
14406 if err := self.OxmId.Serialize(encoder); err != nil {
14407 return err
14408 }
14409
14410 return nil
14411}
14412
14413func DecodeOxmIdArpOpMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpOpMasked, error) {
14414 _oxmidarpopmasked := &OxmIdArpOpMasked{OxmId: parent}
14415 return _oxmidarpopmasked, nil
14416}
14417
14418func NewOxmIdArpOpMasked() *OxmIdArpOpMasked {
14419 obj := &OxmIdArpOpMasked{
14420 OxmId: NewOxmId(2147494660),
14421 }
14422 return obj
14423}
14424func (self *OxmIdArpOpMasked) GetOXMName() string {
14425 return "arp_op_masked"
14426}
14427
14428func (self *OxmIdArpOpMasked) MarshalJSON() ([]byte, error) {
14429 if self.TypeLen == 0 {
14430 return []byte("\"\""), nil
14431 } else {
14432 return []byte("\"" + self.GetOXMName() + "\""), nil
14433 }
14434}
14435
14436type OxmIdBsnEgrPortGroupId struct {
14437 *OxmId
14438}
14439
14440type IOxmIdBsnEgrPortGroupId interface {
14441 IOxmId
14442}
14443
14444func (self *OxmIdBsnEgrPortGroupId) Serialize(encoder *goloxi.Encoder) error {
14445 if err := self.OxmId.Serialize(encoder); err != nil {
14446 return err
14447 }
14448
14449 return nil
14450}
14451
14452func DecodeOxmIdBsnEgrPortGroupId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnEgrPortGroupId, error) {
14453 _oxmidbsnegrportgroupid := &OxmIdBsnEgrPortGroupId{OxmId: parent}
14454 return _oxmidbsnegrportgroupid, nil
14455}
14456
14457func NewOxmIdBsnEgrPortGroupId() *OxmIdBsnEgrPortGroupId {
14458 obj := &OxmIdBsnEgrPortGroupId{
14459 OxmId: NewOxmId(200196),
14460 }
14461 return obj
14462}
14463func (self *OxmIdBsnEgrPortGroupId) GetOXMName() string {
14464 return "bsn_egr_port_group_id"
14465}
14466
14467func (self *OxmIdBsnEgrPortGroupId) MarshalJSON() ([]byte, error) {
14468 if self.TypeLen == 0 {
14469 return []byte("\"\""), nil
14470 } else {
14471 return []byte("\"" + self.GetOXMName() + "\""), nil
14472 }
14473}
14474
14475type OxmIdBsnEgrPortGroupIdMasked struct {
14476 *OxmId
14477}
14478
14479type IOxmIdBsnEgrPortGroupIdMasked interface {
14480 IOxmId
14481}
14482
14483func (self *OxmIdBsnEgrPortGroupIdMasked) Serialize(encoder *goloxi.Encoder) error {
14484 if err := self.OxmId.Serialize(encoder); err != nil {
14485 return err
14486 }
14487
14488 return nil
14489}
14490
14491func DecodeOxmIdBsnEgrPortGroupIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnEgrPortGroupIdMasked, error) {
14492 _oxmidbsnegrportgroupidmasked := &OxmIdBsnEgrPortGroupIdMasked{OxmId: parent}
14493 return _oxmidbsnegrportgroupidmasked, nil
14494}
14495
14496func NewOxmIdBsnEgrPortGroupIdMasked() *OxmIdBsnEgrPortGroupIdMasked {
14497 obj := &OxmIdBsnEgrPortGroupIdMasked{
14498 OxmId: NewOxmId(200456),
14499 }
14500 return obj
14501}
14502func (self *OxmIdBsnEgrPortGroupIdMasked) GetOXMName() string {
14503 return "bsn_egr_port_group_id_masked"
14504}
14505
14506func (self *OxmIdBsnEgrPortGroupIdMasked) MarshalJSON() ([]byte, error) {
14507 if self.TypeLen == 0 {
14508 return []byte("\"\""), nil
14509 } else {
14510 return []byte("\"" + self.GetOXMName() + "\""), nil
14511 }
14512}
14513
14514type OxmIdBsnGlobalVrfAllowed struct {
14515 *OxmId
14516}
14517
14518type IOxmIdBsnGlobalVrfAllowed interface {
14519 IOxmId
14520}
14521
14522func (self *OxmIdBsnGlobalVrfAllowed) Serialize(encoder *goloxi.Encoder) error {
14523 if err := self.OxmId.Serialize(encoder); err != nil {
14524 return err
14525 }
14526
14527 return nil
14528}
14529
14530func DecodeOxmIdBsnGlobalVrfAllowed(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnGlobalVrfAllowed, error) {
14531 _oxmidbsnglobalvrfallowed := &OxmIdBsnGlobalVrfAllowed{OxmId: parent}
14532 return _oxmidbsnglobalvrfallowed, nil
14533}
14534
14535func NewOxmIdBsnGlobalVrfAllowed() *OxmIdBsnGlobalVrfAllowed {
14536 obj := &OxmIdBsnGlobalVrfAllowed{
14537 OxmId: NewOxmId(198145),
14538 }
14539 return obj
14540}
14541func (self *OxmIdBsnGlobalVrfAllowed) GetOXMName() string {
14542 return "bsn_global_vrf_allowed"
14543}
14544
14545func (self *OxmIdBsnGlobalVrfAllowed) MarshalJSON() ([]byte, error) {
14546 if self.TypeLen == 0 {
14547 return []byte("\"\""), nil
14548 } else {
14549 return []byte("\"" + self.GetOXMName() + "\""), nil
14550 }
14551}
14552
14553type OxmIdBsnGlobalVrfAllowedMasked struct {
14554 *OxmId
14555}
14556
14557type IOxmIdBsnGlobalVrfAllowedMasked interface {
14558 IOxmId
14559}
14560
14561func (self *OxmIdBsnGlobalVrfAllowedMasked) Serialize(encoder *goloxi.Encoder) error {
14562 if err := self.OxmId.Serialize(encoder); err != nil {
14563 return err
14564 }
14565
14566 return nil
14567}
14568
14569func DecodeOxmIdBsnGlobalVrfAllowedMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnGlobalVrfAllowedMasked, error) {
14570 _oxmidbsnglobalvrfallowedmasked := &OxmIdBsnGlobalVrfAllowedMasked{OxmId: parent}
14571 return _oxmidbsnglobalvrfallowedmasked, nil
14572}
14573
14574func NewOxmIdBsnGlobalVrfAllowedMasked() *OxmIdBsnGlobalVrfAllowedMasked {
14575 obj := &OxmIdBsnGlobalVrfAllowedMasked{
14576 OxmId: NewOxmId(198402),
14577 }
14578 return obj
14579}
14580func (self *OxmIdBsnGlobalVrfAllowedMasked) GetOXMName() string {
14581 return "bsn_global_vrf_allowed_masked"
14582}
14583
14584func (self *OxmIdBsnGlobalVrfAllowedMasked) MarshalJSON() ([]byte, error) {
14585 if self.TypeLen == 0 {
14586 return []byte("\"\""), nil
14587 } else {
14588 return []byte("\"" + self.GetOXMName() + "\""), nil
14589 }
14590}
14591
14592type OxmIdBsnInPorts128 struct {
14593 *OxmId
14594}
14595
14596type IOxmIdBsnInPorts128 interface {
14597 IOxmId
14598}
14599
14600func (self *OxmIdBsnInPorts128) Serialize(encoder *goloxi.Encoder) error {
14601 if err := self.OxmId.Serialize(encoder); err != nil {
14602 return err
14603 }
14604
14605 return nil
14606}
14607
14608func DecodeOxmIdBsnInPorts128(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInPorts128, error) {
14609 _oxmidbsninports128 := &OxmIdBsnInPorts128{OxmId: parent}
14610 return _oxmidbsninports128, nil
14611}
14612
14613func NewOxmIdBsnInPorts128() *OxmIdBsnInPorts128 {
14614 obj := &OxmIdBsnInPorts128{
14615 OxmId: NewOxmId(196624),
14616 }
14617 return obj
14618}
14619func (self *OxmIdBsnInPorts128) GetOXMName() string {
14620 return "bsn_in_ports_128"
14621}
14622
14623func (self *OxmIdBsnInPorts128) MarshalJSON() ([]byte, error) {
14624 if self.TypeLen == 0 {
14625 return []byte("\"\""), nil
14626 } else {
14627 return []byte("\"" + self.GetOXMName() + "\""), nil
14628 }
14629}
14630
14631type OxmIdBsnInPorts128Masked struct {
14632 *OxmId
14633}
14634
14635type IOxmIdBsnInPorts128Masked interface {
14636 IOxmId
14637}
14638
14639func (self *OxmIdBsnInPorts128Masked) Serialize(encoder *goloxi.Encoder) error {
14640 if err := self.OxmId.Serialize(encoder); err != nil {
14641 return err
14642 }
14643
14644 return nil
14645}
14646
14647func DecodeOxmIdBsnInPorts128Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInPorts128Masked, error) {
14648 _oxmidbsninports128masked := &OxmIdBsnInPorts128Masked{OxmId: parent}
14649 return _oxmidbsninports128masked, nil
14650}
14651
14652func NewOxmIdBsnInPorts128Masked() *OxmIdBsnInPorts128Masked {
14653 obj := &OxmIdBsnInPorts128Masked{
14654 OxmId: NewOxmId(196896),
14655 }
14656 return obj
14657}
14658func (self *OxmIdBsnInPorts128Masked) GetOXMName() string {
14659 return "bsn_in_ports_128_masked"
14660}
14661
14662func (self *OxmIdBsnInPorts128Masked) MarshalJSON() ([]byte, error) {
14663 if self.TypeLen == 0 {
14664 return []byte("\"\""), nil
14665 } else {
14666 return []byte("\"" + self.GetOXMName() + "\""), nil
14667 }
14668}
14669
14670type OxmIdBsnInPorts512 struct {
14671 *OxmId
14672}
14673
14674type IOxmIdBsnInPorts512 interface {
14675 IOxmId
14676}
14677
14678func (self *OxmIdBsnInPorts512) Serialize(encoder *goloxi.Encoder) error {
14679 if err := self.OxmId.Serialize(encoder); err != nil {
14680 return err
14681 }
14682
14683 return nil
14684}
14685
14686func DecodeOxmIdBsnInPorts512(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInPorts512, error) {
14687 _oxmidbsninports512 := &OxmIdBsnInPorts512{OxmId: parent}
14688 return _oxmidbsninports512, nil
14689}
14690
14691func NewOxmIdBsnInPorts512() *OxmIdBsnInPorts512 {
14692 obj := &OxmIdBsnInPorts512{
14693 OxmId: NewOxmId(206400),
14694 }
14695 return obj
14696}
14697func (self *OxmIdBsnInPorts512) GetOXMName() string {
14698 return "bsn_in_ports_512"
14699}
14700
14701func (self *OxmIdBsnInPorts512) MarshalJSON() ([]byte, error) {
14702 if self.TypeLen == 0 {
14703 return []byte("\"\""), nil
14704 } else {
14705 return []byte("\"" + self.GetOXMName() + "\""), nil
14706 }
14707}
14708
14709type OxmIdBsnInPorts512Masked struct {
14710 *OxmId
14711}
14712
14713type IOxmIdBsnInPorts512Masked interface {
14714 IOxmId
14715}
14716
14717func (self *OxmIdBsnInPorts512Masked) Serialize(encoder *goloxi.Encoder) error {
14718 if err := self.OxmId.Serialize(encoder); err != nil {
14719 return err
14720 }
14721
14722 return nil
14723}
14724
14725func DecodeOxmIdBsnInPorts512Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnInPorts512Masked, error) {
14726 _oxmidbsninports512masked := &OxmIdBsnInPorts512Masked{OxmId: parent}
14727 return _oxmidbsninports512masked, nil
14728}
14729
14730func NewOxmIdBsnInPorts512Masked() *OxmIdBsnInPorts512Masked {
14731 obj := &OxmIdBsnInPorts512Masked{
14732 OxmId: NewOxmId(206720),
14733 }
14734 return obj
14735}
14736func (self *OxmIdBsnInPorts512Masked) GetOXMName() string {
14737 return "bsn_in_ports_512_masked"
14738}
14739
14740func (self *OxmIdBsnInPorts512Masked) MarshalJSON() ([]byte, error) {
14741 if self.TypeLen == 0 {
14742 return []byte("\"\""), nil
14743 } else {
14744 return []byte("\"" + self.GetOXMName() + "\""), nil
14745 }
14746}
14747
14748type OxmIdBsnIngressPortGroupId struct {
14749 *OxmId
14750}
14751
14752type IOxmIdBsnIngressPortGroupId interface {
14753 IOxmId
14754}
14755
14756func (self *OxmIdBsnIngressPortGroupId) Serialize(encoder *goloxi.Encoder) error {
14757 if err := self.OxmId.Serialize(encoder); err != nil {
14758 return err
14759 }
14760
14761 return nil
14762}
14763
14764func DecodeOxmIdBsnIngressPortGroupId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnIngressPortGroupId, error) {
14765 _oxmidbsningressportgroupid := &OxmIdBsnIngressPortGroupId{OxmId: parent}
14766 return _oxmidbsningressportgroupid, nil
14767}
14768
14769func NewOxmIdBsnIngressPortGroupId() *OxmIdBsnIngressPortGroupId {
14770 obj := &OxmIdBsnIngressPortGroupId{
14771 OxmId: NewOxmId(206852),
14772 }
14773 return obj
14774}
14775func (self *OxmIdBsnIngressPortGroupId) GetOXMName() string {
14776 return "bsn_ingress_port_group_id"
14777}
14778
14779func (self *OxmIdBsnIngressPortGroupId) MarshalJSON() ([]byte, error) {
14780 if self.TypeLen == 0 {
14781 return []byte("\"\""), nil
14782 } else {
14783 return []byte("\"" + self.GetOXMName() + "\""), nil
14784 }
14785}
14786
14787type OxmIdBsnIngressPortGroupIdMasked struct {
14788 *OxmId
14789}
14790
14791type IOxmIdBsnIngressPortGroupIdMasked interface {
14792 IOxmId
14793}
14794
14795func (self *OxmIdBsnIngressPortGroupIdMasked) Serialize(encoder *goloxi.Encoder) error {
14796 if err := self.OxmId.Serialize(encoder); err != nil {
14797 return err
14798 }
14799
14800 return nil
14801}
14802
14803func DecodeOxmIdBsnIngressPortGroupIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnIngressPortGroupIdMasked, error) {
14804 _oxmidbsningressportgroupidmasked := &OxmIdBsnIngressPortGroupIdMasked{OxmId: parent}
14805 return _oxmidbsningressportgroupidmasked, nil
14806}
14807
14808func NewOxmIdBsnIngressPortGroupIdMasked() *OxmIdBsnIngressPortGroupIdMasked {
14809 obj := &OxmIdBsnIngressPortGroupIdMasked{
14810 OxmId: NewOxmId(207112),
14811 }
14812 return obj
14813}
14814func (self *OxmIdBsnIngressPortGroupIdMasked) GetOXMName() string {
14815 return "bsn_ingress_port_group_id_masked"
14816}
14817
14818func (self *OxmIdBsnIngressPortGroupIdMasked) MarshalJSON() ([]byte, error) {
14819 if self.TypeLen == 0 {
14820 return []byte("\"\""), nil
14821 } else {
14822 return []byte("\"" + self.GetOXMName() + "\""), nil
14823 }
14824}
14825
14826type OxmIdBsnIpFragmentation struct {
14827 *OxmId
14828}
14829
14830type IOxmIdBsnIpFragmentation interface {
14831 IOxmId
14832}
14833
14834func (self *OxmIdBsnIpFragmentation) Serialize(encoder *goloxi.Encoder) error {
14835 if err := self.OxmId.Serialize(encoder); err != nil {
14836 return err
14837 }
14838
14839 return nil
14840}
14841
14842func DecodeOxmIdBsnIpFragmentation(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnIpFragmentation, error) {
14843 _oxmidbsnipfragmentation := &OxmIdBsnIpFragmentation{OxmId: parent}
14844 return _oxmidbsnipfragmentation, nil
14845}
14846
14847func NewOxmIdBsnIpFragmentation() *OxmIdBsnIpFragmentation {
14848 obj := &OxmIdBsnIpFragmentation{
14849 OxmId: NewOxmId(209921),
14850 }
14851 return obj
14852}
14853func (self *OxmIdBsnIpFragmentation) GetOXMName() string {
14854 return "bsn_ip_fragmentation"
14855}
14856
14857func (self *OxmIdBsnIpFragmentation) MarshalJSON() ([]byte, error) {
14858 if self.TypeLen == 0 {
14859 return []byte("\"\""), nil
14860 } else {
14861 return []byte("\"" + self.GetOXMName() + "\""), nil
14862 }
14863}
14864
14865type OxmIdBsnIpFragmentationMasked struct {
14866 *OxmId
14867}
14868
14869type IOxmIdBsnIpFragmentationMasked interface {
14870 IOxmId
14871}
14872
14873func (self *OxmIdBsnIpFragmentationMasked) Serialize(encoder *goloxi.Encoder) error {
14874 if err := self.OxmId.Serialize(encoder); err != nil {
14875 return err
14876 }
14877
14878 return nil
14879}
14880
14881func DecodeOxmIdBsnIpFragmentationMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnIpFragmentationMasked, error) {
14882 _oxmidbsnipfragmentationmasked := &OxmIdBsnIpFragmentationMasked{OxmId: parent}
14883 return _oxmidbsnipfragmentationmasked, nil
14884}
14885
14886func NewOxmIdBsnIpFragmentationMasked() *OxmIdBsnIpFragmentationMasked {
14887 obj := &OxmIdBsnIpFragmentationMasked{
14888 OxmId: NewOxmId(210178),
14889 }
14890 return obj
14891}
14892func (self *OxmIdBsnIpFragmentationMasked) GetOXMName() string {
14893 return "bsn_ip_fragmentation_masked"
14894}
14895
14896func (self *OxmIdBsnIpFragmentationMasked) MarshalJSON() ([]byte, error) {
14897 if self.TypeLen == 0 {
14898 return []byte("\"\""), nil
14899 } else {
14900 return []byte("\"" + self.GetOXMName() + "\""), nil
14901 }
14902}
14903
14904type OxmIdBsnL2CacheHit struct {
14905 *OxmId
14906}
14907
14908type IOxmIdBsnL2CacheHit interface {
14909 IOxmId
14910}
14911
14912func (self *OxmIdBsnL2CacheHit) Serialize(encoder *goloxi.Encoder) error {
14913 if err := self.OxmId.Serialize(encoder); err != nil {
14914 return err
14915 }
14916
14917 return nil
14918}
14919
14920func DecodeOxmIdBsnL2CacheHit(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL2CacheHit, error) {
14921 _oxmidbsnl2cachehit := &OxmIdBsnL2CacheHit{OxmId: parent}
14922 return _oxmidbsnl2cachehit, nil
14923}
14924
14925func NewOxmIdBsnL2CacheHit() *OxmIdBsnL2CacheHit {
14926 obj := &OxmIdBsnL2CacheHit{
14927 OxmId: NewOxmId(205825),
14928 }
14929 return obj
14930}
14931func (self *OxmIdBsnL2CacheHit) GetOXMName() string {
14932 return "bsn_l2_cache_hit"
14933}
14934
14935func (self *OxmIdBsnL2CacheHit) MarshalJSON() ([]byte, error) {
14936 if self.TypeLen == 0 {
14937 return []byte("\"\""), nil
14938 } else {
14939 return []byte("\"" + self.GetOXMName() + "\""), nil
14940 }
14941}
14942
14943type OxmIdBsnL2CacheHitMasked struct {
14944 *OxmId
14945}
14946
14947type IOxmIdBsnL2CacheHitMasked interface {
14948 IOxmId
14949}
14950
14951func (self *OxmIdBsnL2CacheHitMasked) Serialize(encoder *goloxi.Encoder) error {
14952 if err := self.OxmId.Serialize(encoder); err != nil {
14953 return err
14954 }
14955
14956 return nil
14957}
14958
14959func DecodeOxmIdBsnL2CacheHitMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL2CacheHitMasked, error) {
14960 _oxmidbsnl2cachehitmasked := &OxmIdBsnL2CacheHitMasked{OxmId: parent}
14961 return _oxmidbsnl2cachehitmasked, nil
14962}
14963
14964func NewOxmIdBsnL2CacheHitMasked() *OxmIdBsnL2CacheHitMasked {
14965 obj := &OxmIdBsnL2CacheHitMasked{
14966 OxmId: NewOxmId(206082),
14967 }
14968 return obj
14969}
14970func (self *OxmIdBsnL2CacheHitMasked) GetOXMName() string {
14971 return "bsn_l2_cache_hit_masked"
14972}
14973
14974func (self *OxmIdBsnL2CacheHitMasked) MarshalJSON() ([]byte, error) {
14975 if self.TypeLen == 0 {
14976 return []byte("\"\""), nil
14977 } else {
14978 return []byte("\"" + self.GetOXMName() + "\""), nil
14979 }
14980}
14981
14982type OxmIdBsnL3DstClassId struct {
14983 *OxmId
14984}
14985
14986type IOxmIdBsnL3DstClassId interface {
14987 IOxmId
14988}
14989
14990func (self *OxmIdBsnL3DstClassId) Serialize(encoder *goloxi.Encoder) error {
14991 if err := self.OxmId.Serialize(encoder); err != nil {
14992 return err
14993 }
14994
14995 return nil
14996}
14997
14998func DecodeOxmIdBsnL3DstClassId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL3DstClassId, error) {
14999 _oxmidbsnl3dstclassid := &OxmIdBsnL3DstClassId{OxmId: parent}
15000 return _oxmidbsnl3dstclassid, nil
15001}
15002
15003func NewOxmIdBsnL3DstClassId() *OxmIdBsnL3DstClassId {
15004 obj := &OxmIdBsnL3DstClassId{
15005 OxmId: NewOxmId(199684),
15006 }
15007 return obj
15008}
15009func (self *OxmIdBsnL3DstClassId) GetOXMName() string {
15010 return "bsn_l3_dst_class_id"
15011}
15012
15013func (self *OxmIdBsnL3DstClassId) MarshalJSON() ([]byte, error) {
15014 if self.TypeLen == 0 {
15015 return []byte("\"\""), nil
15016 } else {
15017 return []byte("\"" + self.GetOXMName() + "\""), nil
15018 }
15019}
15020
15021type OxmIdBsnL3DstClassIdMasked struct {
15022 *OxmId
15023}
15024
15025type IOxmIdBsnL3DstClassIdMasked interface {
15026 IOxmId
15027}
15028
15029func (self *OxmIdBsnL3DstClassIdMasked) Serialize(encoder *goloxi.Encoder) error {
15030 if err := self.OxmId.Serialize(encoder); err != nil {
15031 return err
15032 }
15033
15034 return nil
15035}
15036
15037func DecodeOxmIdBsnL3DstClassIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL3DstClassIdMasked, error) {
15038 _oxmidbsnl3dstclassidmasked := &OxmIdBsnL3DstClassIdMasked{OxmId: parent}
15039 return _oxmidbsnl3dstclassidmasked, nil
15040}
15041
15042func NewOxmIdBsnL3DstClassIdMasked() *OxmIdBsnL3DstClassIdMasked {
15043 obj := &OxmIdBsnL3DstClassIdMasked{
15044 OxmId: NewOxmId(199944),
15045 }
15046 return obj
15047}
15048func (self *OxmIdBsnL3DstClassIdMasked) GetOXMName() string {
15049 return "bsn_l3_dst_class_id_masked"
15050}
15051
15052func (self *OxmIdBsnL3DstClassIdMasked) MarshalJSON() ([]byte, error) {
15053 if self.TypeLen == 0 {
15054 return []byte("\"\""), nil
15055 } else {
15056 return []byte("\"" + self.GetOXMName() + "\""), nil
15057 }
15058}
15059
15060type OxmIdBsnL3InterfaceClassId struct {
15061 *OxmId
15062}
15063
15064type IOxmIdBsnL3InterfaceClassId interface {
15065 IOxmId
15066}
15067
15068func (self *OxmIdBsnL3InterfaceClassId) Serialize(encoder *goloxi.Encoder) error {
15069 if err := self.OxmId.Serialize(encoder); err != nil {
15070 return err
15071 }
15072
15073 return nil
15074}
15075
15076func DecodeOxmIdBsnL3InterfaceClassId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL3InterfaceClassId, error) {
15077 _oxmidbsnl3interfaceclassid := &OxmIdBsnL3InterfaceClassId{OxmId: parent}
15078 return _oxmidbsnl3interfaceclassid, nil
15079}
15080
15081func NewOxmIdBsnL3InterfaceClassId() *OxmIdBsnL3InterfaceClassId {
15082 obj := &OxmIdBsnL3InterfaceClassId{
15083 OxmId: NewOxmId(198660),
15084 }
15085 return obj
15086}
15087func (self *OxmIdBsnL3InterfaceClassId) GetOXMName() string {
15088 return "bsn_l3_interface_class_id"
15089}
15090
15091func (self *OxmIdBsnL3InterfaceClassId) MarshalJSON() ([]byte, error) {
15092 if self.TypeLen == 0 {
15093 return []byte("\"\""), nil
15094 } else {
15095 return []byte("\"" + self.GetOXMName() + "\""), nil
15096 }
15097}
15098
15099type OxmIdBsnL3InterfaceClassIdMasked struct {
15100 *OxmId
15101}
15102
15103type IOxmIdBsnL3InterfaceClassIdMasked interface {
15104 IOxmId
15105}
15106
15107func (self *OxmIdBsnL3InterfaceClassIdMasked) Serialize(encoder *goloxi.Encoder) error {
15108 if err := self.OxmId.Serialize(encoder); err != nil {
15109 return err
15110 }
15111
15112 return nil
15113}
15114
15115func DecodeOxmIdBsnL3InterfaceClassIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL3InterfaceClassIdMasked, error) {
15116 _oxmidbsnl3interfaceclassidmasked := &OxmIdBsnL3InterfaceClassIdMasked{OxmId: parent}
15117 return _oxmidbsnl3interfaceclassidmasked, nil
15118}
15119
15120func NewOxmIdBsnL3InterfaceClassIdMasked() *OxmIdBsnL3InterfaceClassIdMasked {
15121 obj := &OxmIdBsnL3InterfaceClassIdMasked{
15122 OxmId: NewOxmId(198920),
15123 }
15124 return obj
15125}
15126func (self *OxmIdBsnL3InterfaceClassIdMasked) GetOXMName() string {
15127 return "bsn_l3_interface_class_id_masked"
15128}
15129
15130func (self *OxmIdBsnL3InterfaceClassIdMasked) MarshalJSON() ([]byte, error) {
15131 if self.TypeLen == 0 {
15132 return []byte("\"\""), nil
15133 } else {
15134 return []byte("\"" + self.GetOXMName() + "\""), nil
15135 }
15136}
15137
15138type OxmIdBsnL3SrcClassId struct {
15139 *OxmId
15140}
15141
15142type IOxmIdBsnL3SrcClassId interface {
15143 IOxmId
15144}
15145
15146func (self *OxmIdBsnL3SrcClassId) Serialize(encoder *goloxi.Encoder) error {
15147 if err := self.OxmId.Serialize(encoder); err != nil {
15148 return err
15149 }
15150
15151 return nil
15152}
15153
15154func DecodeOxmIdBsnL3SrcClassId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL3SrcClassId, error) {
15155 _oxmidbsnl3srcclassid := &OxmIdBsnL3SrcClassId{OxmId: parent}
15156 return _oxmidbsnl3srcclassid, nil
15157}
15158
15159func NewOxmIdBsnL3SrcClassId() *OxmIdBsnL3SrcClassId {
15160 obj := &OxmIdBsnL3SrcClassId{
15161 OxmId: NewOxmId(199172),
15162 }
15163 return obj
15164}
15165func (self *OxmIdBsnL3SrcClassId) GetOXMName() string {
15166 return "bsn_l3_src_class_id"
15167}
15168
15169func (self *OxmIdBsnL3SrcClassId) MarshalJSON() ([]byte, error) {
15170 if self.TypeLen == 0 {
15171 return []byte("\"\""), nil
15172 } else {
15173 return []byte("\"" + self.GetOXMName() + "\""), nil
15174 }
15175}
15176
15177type OxmIdBsnL3SrcClassIdMasked struct {
15178 *OxmId
15179}
15180
15181type IOxmIdBsnL3SrcClassIdMasked interface {
15182 IOxmId
15183}
15184
15185func (self *OxmIdBsnL3SrcClassIdMasked) Serialize(encoder *goloxi.Encoder) error {
15186 if err := self.OxmId.Serialize(encoder); err != nil {
15187 return err
15188 }
15189
15190 return nil
15191}
15192
15193func DecodeOxmIdBsnL3SrcClassIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnL3SrcClassIdMasked, error) {
15194 _oxmidbsnl3srcclassidmasked := &OxmIdBsnL3SrcClassIdMasked{OxmId: parent}
15195 return _oxmidbsnl3srcclassidmasked, nil
15196}
15197
15198func NewOxmIdBsnL3SrcClassIdMasked() *OxmIdBsnL3SrcClassIdMasked {
15199 obj := &OxmIdBsnL3SrcClassIdMasked{
15200 OxmId: NewOxmId(199432),
15201 }
15202 return obj
15203}
15204func (self *OxmIdBsnL3SrcClassIdMasked) GetOXMName() string {
15205 return "bsn_l3_src_class_id_masked"
15206}
15207
15208func (self *OxmIdBsnL3SrcClassIdMasked) MarshalJSON() ([]byte, error) {
15209 if self.TypeLen == 0 {
15210 return []byte("\"\""), nil
15211 } else {
15212 return []byte("\"" + self.GetOXMName() + "\""), nil
15213 }
15214}
15215
15216type OxmIdBsnLagId struct {
15217 *OxmId
15218}
15219
15220type IOxmIdBsnLagId interface {
15221 IOxmId
15222}
15223
15224func (self *OxmIdBsnLagId) Serialize(encoder *goloxi.Encoder) error {
15225 if err := self.OxmId.Serialize(encoder); err != nil {
15226 return err
15227 }
15228
15229 return nil
15230}
15231
15232func DecodeOxmIdBsnLagId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnLagId, error) {
15233 _oxmidbsnlagid := &OxmIdBsnLagId{OxmId: parent}
15234 return _oxmidbsnlagid, nil
15235}
15236
15237func NewOxmIdBsnLagId() *OxmIdBsnLagId {
15238 obj := &OxmIdBsnLagId{
15239 OxmId: NewOxmId(197124),
15240 }
15241 return obj
15242}
15243func (self *OxmIdBsnLagId) GetOXMName() string {
15244 return "bsn_lag_id"
15245}
15246
15247func (self *OxmIdBsnLagId) MarshalJSON() ([]byte, error) {
15248 if self.TypeLen == 0 {
15249 return []byte("\"\""), nil
15250 } else {
15251 return []byte("\"" + self.GetOXMName() + "\""), nil
15252 }
15253}
15254
15255type OxmIdBsnLagIdMasked struct {
15256 *OxmId
15257}
15258
15259type IOxmIdBsnLagIdMasked interface {
15260 IOxmId
15261}
15262
15263func (self *OxmIdBsnLagIdMasked) Serialize(encoder *goloxi.Encoder) error {
15264 if err := self.OxmId.Serialize(encoder); err != nil {
15265 return err
15266 }
15267
15268 return nil
15269}
15270
15271func DecodeOxmIdBsnLagIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnLagIdMasked, error) {
15272 _oxmidbsnlagidmasked := &OxmIdBsnLagIdMasked{OxmId: parent}
15273 return _oxmidbsnlagidmasked, nil
15274}
15275
15276func NewOxmIdBsnLagIdMasked() *OxmIdBsnLagIdMasked {
15277 obj := &OxmIdBsnLagIdMasked{
15278 OxmId: NewOxmId(197384),
15279 }
15280 return obj
15281}
15282func (self *OxmIdBsnLagIdMasked) GetOXMName() string {
15283 return "bsn_lag_id_masked"
15284}
15285
15286func (self *OxmIdBsnLagIdMasked) MarshalJSON() ([]byte, error) {
15287 if self.TypeLen == 0 {
15288 return []byte("\"\""), nil
15289 } else {
15290 return []byte("\"" + self.GetOXMName() + "\""), nil
15291 }
15292}
15293
15294type OxmIdBsnTcpFlags struct {
15295 *OxmId
15296}
15297
15298type IOxmIdBsnTcpFlags interface {
15299 IOxmId
15300}
15301
15302func (self *OxmIdBsnTcpFlags) Serialize(encoder *goloxi.Encoder) error {
15303 if err := self.OxmId.Serialize(encoder); err != nil {
15304 return err
15305 }
15306
15307 return nil
15308}
15309
15310func DecodeOxmIdBsnTcpFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnTcpFlags, error) {
15311 _oxmidbsntcpflags := &OxmIdBsnTcpFlags{OxmId: parent}
15312 return _oxmidbsntcpflags, nil
15313}
15314
15315func NewOxmIdBsnTcpFlags() *OxmIdBsnTcpFlags {
15316 obj := &OxmIdBsnTcpFlags{
15317 OxmId: NewOxmId(204802),
15318 }
15319 return obj
15320}
15321func (self *OxmIdBsnTcpFlags) GetOXMName() string {
15322 return "bsn_tcp_flags"
15323}
15324
15325func (self *OxmIdBsnTcpFlags) MarshalJSON() ([]byte, error) {
15326 if self.TypeLen == 0 {
15327 return []byte("\"\""), nil
15328 } else {
15329 return []byte("\"" + self.GetOXMName() + "\""), nil
15330 }
15331}
15332
15333type OxmIdBsnTcpFlagsMasked struct {
15334 *OxmId
15335}
15336
15337type IOxmIdBsnTcpFlagsMasked interface {
15338 IOxmId
15339}
15340
15341func (self *OxmIdBsnTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
15342 if err := self.OxmId.Serialize(encoder); err != nil {
15343 return err
15344 }
15345
15346 return nil
15347}
15348
15349func DecodeOxmIdBsnTcpFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnTcpFlagsMasked, error) {
15350 _oxmidbsntcpflagsmasked := &OxmIdBsnTcpFlagsMasked{OxmId: parent}
15351 return _oxmidbsntcpflagsmasked, nil
15352}
15353
15354func NewOxmIdBsnTcpFlagsMasked() *OxmIdBsnTcpFlagsMasked {
15355 obj := &OxmIdBsnTcpFlagsMasked{
15356 OxmId: NewOxmId(205060),
15357 }
15358 return obj
15359}
15360func (self *OxmIdBsnTcpFlagsMasked) GetOXMName() string {
15361 return "bsn_tcp_flags_masked"
15362}
15363
15364func (self *OxmIdBsnTcpFlagsMasked) MarshalJSON() ([]byte, error) {
15365 if self.TypeLen == 0 {
15366 return []byte("\"\""), nil
15367 } else {
15368 return []byte("\"" + self.GetOXMName() + "\""), nil
15369 }
15370}
15371
15372type OxmIdBsnUdf0 struct {
15373 *OxmId
15374}
15375
15376type IOxmIdBsnUdf0 interface {
15377 IOxmId
15378}
15379
15380func (self *OxmIdBsnUdf0) Serialize(encoder *goloxi.Encoder) error {
15381 if err := self.OxmId.Serialize(encoder); err != nil {
15382 return err
15383 }
15384
15385 return nil
15386}
15387
15388func DecodeOxmIdBsnUdf0(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf0, error) {
15389 _oxmidbsnudf0 := &OxmIdBsnUdf0{OxmId: parent}
15390 return _oxmidbsnudf0, nil
15391}
15392
15393func NewOxmIdBsnUdf0() *OxmIdBsnUdf0 {
15394 obj := &OxmIdBsnUdf0{
15395 OxmId: NewOxmId(200708),
15396 }
15397 return obj
15398}
15399func (self *OxmIdBsnUdf0) GetOXMName() string {
15400 return "bsn_udf0"
15401}
15402
15403func (self *OxmIdBsnUdf0) MarshalJSON() ([]byte, error) {
15404 if self.TypeLen == 0 {
15405 return []byte("\"\""), nil
15406 } else {
15407 return []byte("\"" + self.GetOXMName() + "\""), nil
15408 }
15409}
15410
15411type OxmIdBsnUdf0Masked struct {
15412 *OxmId
15413}
15414
15415type IOxmIdBsnUdf0Masked interface {
15416 IOxmId
15417}
15418
15419func (self *OxmIdBsnUdf0Masked) Serialize(encoder *goloxi.Encoder) error {
15420 if err := self.OxmId.Serialize(encoder); err != nil {
15421 return err
15422 }
15423
15424 return nil
15425}
15426
15427func DecodeOxmIdBsnUdf0Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf0Masked, error) {
15428 _oxmidbsnudf0masked := &OxmIdBsnUdf0Masked{OxmId: parent}
15429 return _oxmidbsnudf0masked, nil
15430}
15431
15432func NewOxmIdBsnUdf0Masked() *OxmIdBsnUdf0Masked {
15433 obj := &OxmIdBsnUdf0Masked{
15434 OxmId: NewOxmId(200968),
15435 }
15436 return obj
15437}
15438func (self *OxmIdBsnUdf0Masked) GetOXMName() string {
15439 return "bsn_udf0_masked"
15440}
15441
15442func (self *OxmIdBsnUdf0Masked) MarshalJSON() ([]byte, error) {
15443 if self.TypeLen == 0 {
15444 return []byte("\"\""), nil
15445 } else {
15446 return []byte("\"" + self.GetOXMName() + "\""), nil
15447 }
15448}
15449
15450type OxmIdBsnUdf1 struct {
15451 *OxmId
15452}
15453
15454type IOxmIdBsnUdf1 interface {
15455 IOxmId
15456}
15457
15458func (self *OxmIdBsnUdf1) Serialize(encoder *goloxi.Encoder) error {
15459 if err := self.OxmId.Serialize(encoder); err != nil {
15460 return err
15461 }
15462
15463 return nil
15464}
15465
15466func DecodeOxmIdBsnUdf1(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf1, error) {
15467 _oxmidbsnudf1 := &OxmIdBsnUdf1{OxmId: parent}
15468 return _oxmidbsnudf1, nil
15469}
15470
15471func NewOxmIdBsnUdf1() *OxmIdBsnUdf1 {
15472 obj := &OxmIdBsnUdf1{
15473 OxmId: NewOxmId(201220),
15474 }
15475 return obj
15476}
15477func (self *OxmIdBsnUdf1) GetOXMName() string {
15478 return "bsn_udf1"
15479}
15480
15481func (self *OxmIdBsnUdf1) MarshalJSON() ([]byte, error) {
15482 if self.TypeLen == 0 {
15483 return []byte("\"\""), nil
15484 } else {
15485 return []byte("\"" + self.GetOXMName() + "\""), nil
15486 }
15487}
15488
15489type OxmIdBsnUdf1Masked struct {
15490 *OxmId
15491}
15492
15493type IOxmIdBsnUdf1Masked interface {
15494 IOxmId
15495}
15496
15497func (self *OxmIdBsnUdf1Masked) Serialize(encoder *goloxi.Encoder) error {
15498 if err := self.OxmId.Serialize(encoder); err != nil {
15499 return err
15500 }
15501
15502 return nil
15503}
15504
15505func DecodeOxmIdBsnUdf1Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf1Masked, error) {
15506 _oxmidbsnudf1masked := &OxmIdBsnUdf1Masked{OxmId: parent}
15507 return _oxmidbsnudf1masked, nil
15508}
15509
15510func NewOxmIdBsnUdf1Masked() *OxmIdBsnUdf1Masked {
15511 obj := &OxmIdBsnUdf1Masked{
15512 OxmId: NewOxmId(201480),
15513 }
15514 return obj
15515}
15516func (self *OxmIdBsnUdf1Masked) GetOXMName() string {
15517 return "bsn_udf1_masked"
15518}
15519
15520func (self *OxmIdBsnUdf1Masked) MarshalJSON() ([]byte, error) {
15521 if self.TypeLen == 0 {
15522 return []byte("\"\""), nil
15523 } else {
15524 return []byte("\"" + self.GetOXMName() + "\""), nil
15525 }
15526}
15527
15528type OxmIdBsnUdf2 struct {
15529 *OxmId
15530}
15531
15532type IOxmIdBsnUdf2 interface {
15533 IOxmId
15534}
15535
15536func (self *OxmIdBsnUdf2) Serialize(encoder *goloxi.Encoder) error {
15537 if err := self.OxmId.Serialize(encoder); err != nil {
15538 return err
15539 }
15540
15541 return nil
15542}
15543
15544func DecodeOxmIdBsnUdf2(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf2, error) {
15545 _oxmidbsnudf2 := &OxmIdBsnUdf2{OxmId: parent}
15546 return _oxmidbsnudf2, nil
15547}
15548
15549func NewOxmIdBsnUdf2() *OxmIdBsnUdf2 {
15550 obj := &OxmIdBsnUdf2{
15551 OxmId: NewOxmId(201732),
15552 }
15553 return obj
15554}
15555func (self *OxmIdBsnUdf2) GetOXMName() string {
15556 return "bsn_udf2"
15557}
15558
15559func (self *OxmIdBsnUdf2) MarshalJSON() ([]byte, error) {
15560 if self.TypeLen == 0 {
15561 return []byte("\"\""), nil
15562 } else {
15563 return []byte("\"" + self.GetOXMName() + "\""), nil
15564 }
15565}
15566
15567type OxmIdBsnUdf2Masked struct {
15568 *OxmId
15569}
15570
15571type IOxmIdBsnUdf2Masked interface {
15572 IOxmId
15573}
15574
15575func (self *OxmIdBsnUdf2Masked) Serialize(encoder *goloxi.Encoder) error {
15576 if err := self.OxmId.Serialize(encoder); err != nil {
15577 return err
15578 }
15579
15580 return nil
15581}
15582
15583func DecodeOxmIdBsnUdf2Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf2Masked, error) {
15584 _oxmidbsnudf2masked := &OxmIdBsnUdf2Masked{OxmId: parent}
15585 return _oxmidbsnudf2masked, nil
15586}
15587
15588func NewOxmIdBsnUdf2Masked() *OxmIdBsnUdf2Masked {
15589 obj := &OxmIdBsnUdf2Masked{
15590 OxmId: NewOxmId(201992),
15591 }
15592 return obj
15593}
15594func (self *OxmIdBsnUdf2Masked) GetOXMName() string {
15595 return "bsn_udf2_masked"
15596}
15597
15598func (self *OxmIdBsnUdf2Masked) MarshalJSON() ([]byte, error) {
15599 if self.TypeLen == 0 {
15600 return []byte("\"\""), nil
15601 } else {
15602 return []byte("\"" + self.GetOXMName() + "\""), nil
15603 }
15604}
15605
15606type OxmIdBsnUdf3 struct {
15607 *OxmId
15608}
15609
15610type IOxmIdBsnUdf3 interface {
15611 IOxmId
15612}
15613
15614func (self *OxmIdBsnUdf3) Serialize(encoder *goloxi.Encoder) error {
15615 if err := self.OxmId.Serialize(encoder); err != nil {
15616 return err
15617 }
15618
15619 return nil
15620}
15621
15622func DecodeOxmIdBsnUdf3(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf3, error) {
15623 _oxmidbsnudf3 := &OxmIdBsnUdf3{OxmId: parent}
15624 return _oxmidbsnudf3, nil
15625}
15626
15627func NewOxmIdBsnUdf3() *OxmIdBsnUdf3 {
15628 obj := &OxmIdBsnUdf3{
15629 OxmId: NewOxmId(202244),
15630 }
15631 return obj
15632}
15633func (self *OxmIdBsnUdf3) GetOXMName() string {
15634 return "bsn_udf3"
15635}
15636
15637func (self *OxmIdBsnUdf3) MarshalJSON() ([]byte, error) {
15638 if self.TypeLen == 0 {
15639 return []byte("\"\""), nil
15640 } else {
15641 return []byte("\"" + self.GetOXMName() + "\""), nil
15642 }
15643}
15644
15645type OxmIdBsnUdf3Masked struct {
15646 *OxmId
15647}
15648
15649type IOxmIdBsnUdf3Masked interface {
15650 IOxmId
15651}
15652
15653func (self *OxmIdBsnUdf3Masked) Serialize(encoder *goloxi.Encoder) error {
15654 if err := self.OxmId.Serialize(encoder); err != nil {
15655 return err
15656 }
15657
15658 return nil
15659}
15660
15661func DecodeOxmIdBsnUdf3Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf3Masked, error) {
15662 _oxmidbsnudf3masked := &OxmIdBsnUdf3Masked{OxmId: parent}
15663 return _oxmidbsnudf3masked, nil
15664}
15665
15666func NewOxmIdBsnUdf3Masked() *OxmIdBsnUdf3Masked {
15667 obj := &OxmIdBsnUdf3Masked{
15668 OxmId: NewOxmId(202504),
15669 }
15670 return obj
15671}
15672func (self *OxmIdBsnUdf3Masked) GetOXMName() string {
15673 return "bsn_udf3_masked"
15674}
15675
15676func (self *OxmIdBsnUdf3Masked) MarshalJSON() ([]byte, error) {
15677 if self.TypeLen == 0 {
15678 return []byte("\"\""), nil
15679 } else {
15680 return []byte("\"" + self.GetOXMName() + "\""), nil
15681 }
15682}
15683
15684type OxmIdBsnUdf4 struct {
15685 *OxmId
15686}
15687
15688type IOxmIdBsnUdf4 interface {
15689 IOxmId
15690}
15691
15692func (self *OxmIdBsnUdf4) Serialize(encoder *goloxi.Encoder) error {
15693 if err := self.OxmId.Serialize(encoder); err != nil {
15694 return err
15695 }
15696
15697 return nil
15698}
15699
15700func DecodeOxmIdBsnUdf4(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf4, error) {
15701 _oxmidbsnudf4 := &OxmIdBsnUdf4{OxmId: parent}
15702 return _oxmidbsnudf4, nil
15703}
15704
15705func NewOxmIdBsnUdf4() *OxmIdBsnUdf4 {
15706 obj := &OxmIdBsnUdf4{
15707 OxmId: NewOxmId(202756),
15708 }
15709 return obj
15710}
15711func (self *OxmIdBsnUdf4) GetOXMName() string {
15712 return "bsn_udf4"
15713}
15714
15715func (self *OxmIdBsnUdf4) MarshalJSON() ([]byte, error) {
15716 if self.TypeLen == 0 {
15717 return []byte("\"\""), nil
15718 } else {
15719 return []byte("\"" + self.GetOXMName() + "\""), nil
15720 }
15721}
15722
15723type OxmIdBsnUdf4Masked struct {
15724 *OxmId
15725}
15726
15727type IOxmIdBsnUdf4Masked interface {
15728 IOxmId
15729}
15730
15731func (self *OxmIdBsnUdf4Masked) Serialize(encoder *goloxi.Encoder) error {
15732 if err := self.OxmId.Serialize(encoder); err != nil {
15733 return err
15734 }
15735
15736 return nil
15737}
15738
15739func DecodeOxmIdBsnUdf4Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf4Masked, error) {
15740 _oxmidbsnudf4masked := &OxmIdBsnUdf4Masked{OxmId: parent}
15741 return _oxmidbsnudf4masked, nil
15742}
15743
15744func NewOxmIdBsnUdf4Masked() *OxmIdBsnUdf4Masked {
15745 obj := &OxmIdBsnUdf4Masked{
15746 OxmId: NewOxmId(203016),
15747 }
15748 return obj
15749}
15750func (self *OxmIdBsnUdf4Masked) GetOXMName() string {
15751 return "bsn_udf4_masked"
15752}
15753
15754func (self *OxmIdBsnUdf4Masked) MarshalJSON() ([]byte, error) {
15755 if self.TypeLen == 0 {
15756 return []byte("\"\""), nil
15757 } else {
15758 return []byte("\"" + self.GetOXMName() + "\""), nil
15759 }
15760}
15761
15762type OxmIdBsnUdf5 struct {
15763 *OxmId
15764}
15765
15766type IOxmIdBsnUdf5 interface {
15767 IOxmId
15768}
15769
15770func (self *OxmIdBsnUdf5) Serialize(encoder *goloxi.Encoder) error {
15771 if err := self.OxmId.Serialize(encoder); err != nil {
15772 return err
15773 }
15774
15775 return nil
15776}
15777
15778func DecodeOxmIdBsnUdf5(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf5, error) {
15779 _oxmidbsnudf5 := &OxmIdBsnUdf5{OxmId: parent}
15780 return _oxmidbsnudf5, nil
15781}
15782
15783func NewOxmIdBsnUdf5() *OxmIdBsnUdf5 {
15784 obj := &OxmIdBsnUdf5{
15785 OxmId: NewOxmId(203268),
15786 }
15787 return obj
15788}
15789func (self *OxmIdBsnUdf5) GetOXMName() string {
15790 return "bsn_udf5"
15791}
15792
15793func (self *OxmIdBsnUdf5) MarshalJSON() ([]byte, error) {
15794 if self.TypeLen == 0 {
15795 return []byte("\"\""), nil
15796 } else {
15797 return []byte("\"" + self.GetOXMName() + "\""), nil
15798 }
15799}
15800
15801type OxmIdBsnUdf5Masked struct {
15802 *OxmId
15803}
15804
15805type IOxmIdBsnUdf5Masked interface {
15806 IOxmId
15807}
15808
15809func (self *OxmIdBsnUdf5Masked) Serialize(encoder *goloxi.Encoder) error {
15810 if err := self.OxmId.Serialize(encoder); err != nil {
15811 return err
15812 }
15813
15814 return nil
15815}
15816
15817func DecodeOxmIdBsnUdf5Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf5Masked, error) {
15818 _oxmidbsnudf5masked := &OxmIdBsnUdf5Masked{OxmId: parent}
15819 return _oxmidbsnudf5masked, nil
15820}
15821
15822func NewOxmIdBsnUdf5Masked() *OxmIdBsnUdf5Masked {
15823 obj := &OxmIdBsnUdf5Masked{
15824 OxmId: NewOxmId(203528),
15825 }
15826 return obj
15827}
15828func (self *OxmIdBsnUdf5Masked) GetOXMName() string {
15829 return "bsn_udf5_masked"
15830}
15831
15832func (self *OxmIdBsnUdf5Masked) MarshalJSON() ([]byte, error) {
15833 if self.TypeLen == 0 {
15834 return []byte("\"\""), nil
15835 } else {
15836 return []byte("\"" + self.GetOXMName() + "\""), nil
15837 }
15838}
15839
15840type OxmIdBsnUdf6 struct {
15841 *OxmId
15842}
15843
15844type IOxmIdBsnUdf6 interface {
15845 IOxmId
15846}
15847
15848func (self *OxmIdBsnUdf6) Serialize(encoder *goloxi.Encoder) error {
15849 if err := self.OxmId.Serialize(encoder); err != nil {
15850 return err
15851 }
15852
15853 return nil
15854}
15855
15856func DecodeOxmIdBsnUdf6(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf6, error) {
15857 _oxmidbsnudf6 := &OxmIdBsnUdf6{OxmId: parent}
15858 return _oxmidbsnudf6, nil
15859}
15860
15861func NewOxmIdBsnUdf6() *OxmIdBsnUdf6 {
15862 obj := &OxmIdBsnUdf6{
15863 OxmId: NewOxmId(203780),
15864 }
15865 return obj
15866}
15867func (self *OxmIdBsnUdf6) GetOXMName() string {
15868 return "bsn_udf6"
15869}
15870
15871func (self *OxmIdBsnUdf6) MarshalJSON() ([]byte, error) {
15872 if self.TypeLen == 0 {
15873 return []byte("\"\""), nil
15874 } else {
15875 return []byte("\"" + self.GetOXMName() + "\""), nil
15876 }
15877}
15878
15879type OxmIdBsnUdf6Masked struct {
15880 *OxmId
15881}
15882
15883type IOxmIdBsnUdf6Masked interface {
15884 IOxmId
15885}
15886
15887func (self *OxmIdBsnUdf6Masked) Serialize(encoder *goloxi.Encoder) error {
15888 if err := self.OxmId.Serialize(encoder); err != nil {
15889 return err
15890 }
15891
15892 return nil
15893}
15894
15895func DecodeOxmIdBsnUdf6Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf6Masked, error) {
15896 _oxmidbsnudf6masked := &OxmIdBsnUdf6Masked{OxmId: parent}
15897 return _oxmidbsnudf6masked, nil
15898}
15899
15900func NewOxmIdBsnUdf6Masked() *OxmIdBsnUdf6Masked {
15901 obj := &OxmIdBsnUdf6Masked{
15902 OxmId: NewOxmId(204040),
15903 }
15904 return obj
15905}
15906func (self *OxmIdBsnUdf6Masked) GetOXMName() string {
15907 return "bsn_udf6_masked"
15908}
15909
15910func (self *OxmIdBsnUdf6Masked) MarshalJSON() ([]byte, error) {
15911 if self.TypeLen == 0 {
15912 return []byte("\"\""), nil
15913 } else {
15914 return []byte("\"" + self.GetOXMName() + "\""), nil
15915 }
15916}
15917
15918type OxmIdBsnUdf7 struct {
15919 *OxmId
15920}
15921
15922type IOxmIdBsnUdf7 interface {
15923 IOxmId
15924}
15925
15926func (self *OxmIdBsnUdf7) Serialize(encoder *goloxi.Encoder) error {
15927 if err := self.OxmId.Serialize(encoder); err != nil {
15928 return err
15929 }
15930
15931 return nil
15932}
15933
15934func DecodeOxmIdBsnUdf7(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf7, error) {
15935 _oxmidbsnudf7 := &OxmIdBsnUdf7{OxmId: parent}
15936 return _oxmidbsnudf7, nil
15937}
15938
15939func NewOxmIdBsnUdf7() *OxmIdBsnUdf7 {
15940 obj := &OxmIdBsnUdf7{
15941 OxmId: NewOxmId(204292),
15942 }
15943 return obj
15944}
15945func (self *OxmIdBsnUdf7) GetOXMName() string {
15946 return "bsn_udf7"
15947}
15948
15949func (self *OxmIdBsnUdf7) MarshalJSON() ([]byte, error) {
15950 if self.TypeLen == 0 {
15951 return []byte("\"\""), nil
15952 } else {
15953 return []byte("\"" + self.GetOXMName() + "\""), nil
15954 }
15955}
15956
15957type OxmIdBsnUdf7Masked struct {
15958 *OxmId
15959}
15960
15961type IOxmIdBsnUdf7Masked interface {
15962 IOxmId
15963}
15964
15965func (self *OxmIdBsnUdf7Masked) Serialize(encoder *goloxi.Encoder) error {
15966 if err := self.OxmId.Serialize(encoder); err != nil {
15967 return err
15968 }
15969
15970 return nil
15971}
15972
15973func DecodeOxmIdBsnUdf7Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnUdf7Masked, error) {
15974 _oxmidbsnudf7masked := &OxmIdBsnUdf7Masked{OxmId: parent}
15975 return _oxmidbsnudf7masked, nil
15976}
15977
15978func NewOxmIdBsnUdf7Masked() *OxmIdBsnUdf7Masked {
15979 obj := &OxmIdBsnUdf7Masked{
15980 OxmId: NewOxmId(204552),
15981 }
15982 return obj
15983}
15984func (self *OxmIdBsnUdf7Masked) GetOXMName() string {
15985 return "bsn_udf7_masked"
15986}
15987
15988func (self *OxmIdBsnUdf7Masked) MarshalJSON() ([]byte, error) {
15989 if self.TypeLen == 0 {
15990 return []byte("\"\""), nil
15991 } else {
15992 return []byte("\"" + self.GetOXMName() + "\""), nil
15993 }
15994}
15995
15996type OxmIdBsnVlanXlatePortGroupId struct {
15997 *OxmId
15998}
15999
16000type IOxmIdBsnVlanXlatePortGroupId interface {
16001 IOxmId
16002}
16003
16004func (self *OxmIdBsnVlanXlatePortGroupId) Serialize(encoder *goloxi.Encoder) error {
16005 if err := self.OxmId.Serialize(encoder); err != nil {
16006 return err
16007 }
16008
16009 return nil
16010}
16011
16012func DecodeOxmIdBsnVlanXlatePortGroupId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVlanXlatePortGroupId, error) {
16013 _oxmidbsnvlanxlateportgroupid := &OxmIdBsnVlanXlatePortGroupId{OxmId: parent}
16014 return _oxmidbsnvlanxlateportgroupid, nil
16015}
16016
16017func NewOxmIdBsnVlanXlatePortGroupId() *OxmIdBsnVlanXlatePortGroupId {
16018 obj := &OxmIdBsnVlanXlatePortGroupId{
16019 OxmId: NewOxmId(205316),
16020 }
16021 return obj
16022}
16023func (self *OxmIdBsnVlanXlatePortGroupId) GetOXMName() string {
16024 return "bsn_vlan_xlate_port_group_id"
16025}
16026
16027func (self *OxmIdBsnVlanXlatePortGroupId) MarshalJSON() ([]byte, error) {
16028 if self.TypeLen == 0 {
16029 return []byte("\"\""), nil
16030 } else {
16031 return []byte("\"" + self.GetOXMName() + "\""), nil
16032 }
16033}
16034
16035type OxmIdBsnVlanXlatePortGroupIdMasked struct {
16036 *OxmId
16037}
16038
16039type IOxmIdBsnVlanXlatePortGroupIdMasked interface {
16040 IOxmId
16041}
16042
16043func (self *OxmIdBsnVlanXlatePortGroupIdMasked) Serialize(encoder *goloxi.Encoder) error {
16044 if err := self.OxmId.Serialize(encoder); err != nil {
16045 return err
16046 }
16047
16048 return nil
16049}
16050
16051func DecodeOxmIdBsnVlanXlatePortGroupIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVlanXlatePortGroupIdMasked, error) {
16052 _oxmidbsnvlanxlateportgroupidmasked := &OxmIdBsnVlanXlatePortGroupIdMasked{OxmId: parent}
16053 return _oxmidbsnvlanxlateportgroupidmasked, nil
16054}
16055
16056func NewOxmIdBsnVlanXlatePortGroupIdMasked() *OxmIdBsnVlanXlatePortGroupIdMasked {
16057 obj := &OxmIdBsnVlanXlatePortGroupIdMasked{
16058 OxmId: NewOxmId(205576),
16059 }
16060 return obj
16061}
16062func (self *OxmIdBsnVlanXlatePortGroupIdMasked) GetOXMName() string {
16063 return "bsn_vlan_xlate_port_group_id_masked"
16064}
16065
16066func (self *OxmIdBsnVlanXlatePortGroupIdMasked) MarshalJSON() ([]byte, error) {
16067 if self.TypeLen == 0 {
16068 return []byte("\"\""), nil
16069 } else {
16070 return []byte("\"" + self.GetOXMName() + "\""), nil
16071 }
16072}
16073
16074type OxmIdBsnVrf struct {
16075 *OxmId
16076}
16077
16078type IOxmIdBsnVrf interface {
16079 IOxmId
16080}
16081
16082func (self *OxmIdBsnVrf) Serialize(encoder *goloxi.Encoder) error {
16083 if err := self.OxmId.Serialize(encoder); err != nil {
16084 return err
16085 }
16086
16087 return nil
16088}
16089
16090func DecodeOxmIdBsnVrf(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVrf, error) {
16091 _oxmidbsnvrf := &OxmIdBsnVrf{OxmId: parent}
16092 return _oxmidbsnvrf, nil
16093}
16094
16095func NewOxmIdBsnVrf() *OxmIdBsnVrf {
16096 obj := &OxmIdBsnVrf{
16097 OxmId: NewOxmId(197636),
16098 }
16099 return obj
16100}
16101func (self *OxmIdBsnVrf) GetOXMName() string {
16102 return "bsn_vrf"
16103}
16104
16105func (self *OxmIdBsnVrf) MarshalJSON() ([]byte, error) {
16106 if self.TypeLen == 0 {
16107 return []byte("\"\""), nil
16108 } else {
16109 return []byte("\"" + self.GetOXMName() + "\""), nil
16110 }
16111}
16112
16113type OxmIdBsnVrfMasked struct {
16114 *OxmId
16115}
16116
16117type IOxmIdBsnVrfMasked interface {
16118 IOxmId
16119}
16120
16121func (self *OxmIdBsnVrfMasked) Serialize(encoder *goloxi.Encoder) error {
16122 if err := self.OxmId.Serialize(encoder); err != nil {
16123 return err
16124 }
16125
16126 return nil
16127}
16128
16129func DecodeOxmIdBsnVrfMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdBsnVrfMasked, error) {
16130 _oxmidbsnvrfmasked := &OxmIdBsnVrfMasked{OxmId: parent}
16131 return _oxmidbsnvrfmasked, nil
16132}
16133
16134func NewOxmIdBsnVrfMasked() *OxmIdBsnVrfMasked {
16135 obj := &OxmIdBsnVrfMasked{
16136 OxmId: NewOxmId(197896),
16137 }
16138 return obj
16139}
16140func (self *OxmIdBsnVrfMasked) GetOXMName() string {
16141 return "bsn_vrf_masked"
16142}
16143
16144func (self *OxmIdBsnVrfMasked) MarshalJSON() ([]byte, error) {
16145 if self.TypeLen == 0 {
16146 return []byte("\"\""), nil
16147 } else {
16148 return []byte("\"" + self.GetOXMName() + "\""), nil
16149 }
16150}
16151
16152type OxmIdConnTrackingIpv6Dst struct {
16153 *OxmId
16154}
16155
16156type IOxmIdConnTrackingIpv6Dst interface {
16157 IOxmId
16158}
16159
16160func (self *OxmIdConnTrackingIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
16161 if err := self.OxmId.Serialize(encoder); err != nil {
16162 return err
16163 }
16164
16165 return nil
16166}
16167
16168func DecodeOxmIdConnTrackingIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6Dst, error) {
16169 _oxmidconntrackingipv6dst := &OxmIdConnTrackingIpv6Dst{OxmId: parent}
16170 return _oxmidconntrackingipv6dst, nil
16171}
16172
16173func NewOxmIdConnTrackingIpv6Dst() *OxmIdConnTrackingIpv6Dst {
16174 obj := &OxmIdConnTrackingIpv6Dst{
16175 OxmId: NewOxmId(128528),
16176 }
16177 return obj
16178}
16179func (self *OxmIdConnTrackingIpv6Dst) GetOXMName() string {
16180 return "conn_tracking_ipv6_dst"
16181}
16182
16183func (self *OxmIdConnTrackingIpv6Dst) MarshalJSON() ([]byte, error) {
16184 if self.TypeLen == 0 {
16185 return []byte("\"\""), nil
16186 } else {
16187 return []byte("\"" + self.GetOXMName() + "\""), nil
16188 }
16189}
16190
16191type OxmIdConnTrackingIpv6DstMasked struct {
16192 *OxmId
16193}
16194
16195type IOxmIdConnTrackingIpv6DstMasked interface {
16196 IOxmId
16197}
16198
16199func (self *OxmIdConnTrackingIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
16200 if err := self.OxmId.Serialize(encoder); err != nil {
16201 return err
16202 }
16203
16204 return nil
16205}
16206
16207func DecodeOxmIdConnTrackingIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6DstMasked, error) {
16208 _oxmidconntrackingipv6dstmasked := &OxmIdConnTrackingIpv6DstMasked{OxmId: parent}
16209 return _oxmidconntrackingipv6dstmasked, nil
16210}
16211
16212func NewOxmIdConnTrackingIpv6DstMasked() *OxmIdConnTrackingIpv6DstMasked {
16213 obj := &OxmIdConnTrackingIpv6DstMasked{
16214 OxmId: NewOxmId(128800),
16215 }
16216 return obj
16217}
16218func (self *OxmIdConnTrackingIpv6DstMasked) GetOXMName() string {
16219 return "conn_tracking_ipv6_dst_masked"
16220}
16221
16222func (self *OxmIdConnTrackingIpv6DstMasked) MarshalJSON() ([]byte, error) {
16223 if self.TypeLen == 0 {
16224 return []byte("\"\""), nil
16225 } else {
16226 return []byte("\"" + self.GetOXMName() + "\""), nil
16227 }
16228}
16229
16230type OxmIdConnTrackingIpv6Src struct {
16231 *OxmId
16232}
16233
16234type IOxmIdConnTrackingIpv6Src interface {
16235 IOxmId
16236}
16237
16238func (self *OxmIdConnTrackingIpv6Src) Serialize(encoder *goloxi.Encoder) error {
16239 if err := self.OxmId.Serialize(encoder); err != nil {
16240 return err
16241 }
16242
16243 return nil
16244}
16245
16246func DecodeOxmIdConnTrackingIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6Src, error) {
16247 _oxmidconntrackingipv6src := &OxmIdConnTrackingIpv6Src{OxmId: parent}
16248 return _oxmidconntrackingipv6src, nil
16249}
16250
16251func NewOxmIdConnTrackingIpv6Src() *OxmIdConnTrackingIpv6Src {
16252 obj := &OxmIdConnTrackingIpv6Src{
16253 OxmId: NewOxmId(128016),
16254 }
16255 return obj
16256}
16257func (self *OxmIdConnTrackingIpv6Src) GetOXMName() string {
16258 return "conn_tracking_ipv6_src"
16259}
16260
16261func (self *OxmIdConnTrackingIpv6Src) MarshalJSON() ([]byte, error) {
16262 if self.TypeLen == 0 {
16263 return []byte("\"\""), nil
16264 } else {
16265 return []byte("\"" + self.GetOXMName() + "\""), nil
16266 }
16267}
16268
16269type OxmIdConnTrackingIpv6SrcMasked struct {
16270 *OxmId
16271}
16272
16273type IOxmIdConnTrackingIpv6SrcMasked interface {
16274 IOxmId
16275}
16276
16277func (self *OxmIdConnTrackingIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
16278 if err := self.OxmId.Serialize(encoder); err != nil {
16279 return err
16280 }
16281
16282 return nil
16283}
16284
16285func DecodeOxmIdConnTrackingIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6SrcMasked, error) {
16286 _oxmidconntrackingipv6srcmasked := &OxmIdConnTrackingIpv6SrcMasked{OxmId: parent}
16287 return _oxmidconntrackingipv6srcmasked, nil
16288}
16289
16290func NewOxmIdConnTrackingIpv6SrcMasked() *OxmIdConnTrackingIpv6SrcMasked {
16291 obj := &OxmIdConnTrackingIpv6SrcMasked{
16292 OxmId: NewOxmId(128288),
16293 }
16294 return obj
16295}
16296func (self *OxmIdConnTrackingIpv6SrcMasked) GetOXMName() string {
16297 return "conn_tracking_ipv6_src_masked"
16298}
16299
16300func (self *OxmIdConnTrackingIpv6SrcMasked) MarshalJSON() ([]byte, error) {
16301 if self.TypeLen == 0 {
16302 return []byte("\"\""), nil
16303 } else {
16304 return []byte("\"" + self.GetOXMName() + "\""), nil
16305 }
16306}
16307
16308type OxmIdConnTrackingLabel struct {
16309 *OxmId
16310}
16311
16312type IOxmIdConnTrackingLabel interface {
16313 IOxmId
16314}
16315
16316func (self *OxmIdConnTrackingLabel) Serialize(encoder *goloxi.Encoder) error {
16317 if err := self.OxmId.Serialize(encoder); err != nil {
16318 return err
16319 }
16320
16321 return nil
16322}
16323
16324func DecodeOxmIdConnTrackingLabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingLabel, error) {
16325 _oxmidconntrackinglabel := &OxmIdConnTrackingLabel{OxmId: parent}
16326 return _oxmidconntrackinglabel, nil
16327}
16328
16329func NewOxmIdConnTrackingLabel() *OxmIdConnTrackingLabel {
16330 obj := &OxmIdConnTrackingLabel{
16331 OxmId: NewOxmId(120848),
16332 }
16333 return obj
16334}
16335func (self *OxmIdConnTrackingLabel) GetOXMName() string {
16336 return "conn_tracking_label"
16337}
16338
16339func (self *OxmIdConnTrackingLabel) MarshalJSON() ([]byte, error) {
16340 if self.TypeLen == 0 {
16341 return []byte("\"\""), nil
16342 } else {
16343 return []byte("\"" + self.GetOXMName() + "\""), nil
16344 }
16345}
16346
16347type OxmIdConnTrackingLabelMasked struct {
16348 *OxmId
16349}
16350
16351type IOxmIdConnTrackingLabelMasked interface {
16352 IOxmId
16353}
16354
16355func (self *OxmIdConnTrackingLabelMasked) Serialize(encoder *goloxi.Encoder) error {
16356 if err := self.OxmId.Serialize(encoder); err != nil {
16357 return err
16358 }
16359
16360 return nil
16361}
16362
16363func DecodeOxmIdConnTrackingLabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingLabelMasked, error) {
16364 _oxmidconntrackinglabelmasked := &OxmIdConnTrackingLabelMasked{OxmId: parent}
16365 return _oxmidconntrackinglabelmasked, nil
16366}
16367
16368func NewOxmIdConnTrackingLabelMasked() *OxmIdConnTrackingLabelMasked {
16369 obj := &OxmIdConnTrackingLabelMasked{
16370 OxmId: NewOxmId(121120),
16371 }
16372 return obj
16373}
16374func (self *OxmIdConnTrackingLabelMasked) GetOXMName() string {
16375 return "conn_tracking_label_masked"
16376}
16377
16378func (self *OxmIdConnTrackingLabelMasked) MarshalJSON() ([]byte, error) {
16379 if self.TypeLen == 0 {
16380 return []byte("\"\""), nil
16381 } else {
16382 return []byte("\"" + self.GetOXMName() + "\""), nil
16383 }
16384}
16385
16386type OxmIdConnTrackingMark struct {
16387 *OxmId
16388}
16389
16390type IOxmIdConnTrackingMark interface {
16391 IOxmId
16392}
16393
16394func (self *OxmIdConnTrackingMark) Serialize(encoder *goloxi.Encoder) error {
16395 if err := self.OxmId.Serialize(encoder); err != nil {
16396 return err
16397 }
16398
16399 return nil
16400}
16401
16402func DecodeOxmIdConnTrackingMark(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingMark, error) {
16403 _oxmidconntrackingmark := &OxmIdConnTrackingMark{OxmId: parent}
16404 return _oxmidconntrackingmark, nil
16405}
16406
16407func NewOxmIdConnTrackingMark() *OxmIdConnTrackingMark {
16408 obj := &OxmIdConnTrackingMark{
16409 OxmId: NewOxmId(120324),
16410 }
16411 return obj
16412}
16413func (self *OxmIdConnTrackingMark) GetOXMName() string {
16414 return "conn_tracking_mark"
16415}
16416
16417func (self *OxmIdConnTrackingMark) MarshalJSON() ([]byte, error) {
16418 if self.TypeLen == 0 {
16419 return []byte("\"\""), nil
16420 } else {
16421 return []byte("\"" + self.GetOXMName() + "\""), nil
16422 }
16423}
16424
16425type OxmIdConnTrackingMarkMasked struct {
16426 *OxmId
16427}
16428
16429type IOxmIdConnTrackingMarkMasked interface {
16430 IOxmId
16431}
16432
16433func (self *OxmIdConnTrackingMarkMasked) Serialize(encoder *goloxi.Encoder) error {
16434 if err := self.OxmId.Serialize(encoder); err != nil {
16435 return err
16436 }
16437
16438 return nil
16439}
16440
16441func DecodeOxmIdConnTrackingMarkMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingMarkMasked, error) {
16442 _oxmidconntrackingmarkmasked := &OxmIdConnTrackingMarkMasked{OxmId: parent}
16443 return _oxmidconntrackingmarkmasked, nil
16444}
16445
16446func NewOxmIdConnTrackingMarkMasked() *OxmIdConnTrackingMarkMasked {
16447 obj := &OxmIdConnTrackingMarkMasked{
16448 OxmId: NewOxmId(120584),
16449 }
16450 return obj
16451}
16452func (self *OxmIdConnTrackingMarkMasked) GetOXMName() string {
16453 return "conn_tracking_mark_masked"
16454}
16455
16456func (self *OxmIdConnTrackingMarkMasked) MarshalJSON() ([]byte, error) {
16457 if self.TypeLen == 0 {
16458 return []byte("\"\""), nil
16459 } else {
16460 return []byte("\"" + self.GetOXMName() + "\""), nil
16461 }
16462}
16463
16464type OxmIdConnTrackingNwDst struct {
16465 *OxmId
16466}
16467
16468type IOxmIdConnTrackingNwDst interface {
16469 IOxmId
16470}
16471
16472func (self *OxmIdConnTrackingNwDst) Serialize(encoder *goloxi.Encoder) error {
16473 if err := self.OxmId.Serialize(encoder); err != nil {
16474 return err
16475 }
16476
16477 return nil
16478}
16479
16480func DecodeOxmIdConnTrackingNwDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwDst, error) {
16481 _oxmidconntrackingnwdst := &OxmIdConnTrackingNwDst{OxmId: parent}
16482 return _oxmidconntrackingnwdst, nil
16483}
16484
16485func NewOxmIdConnTrackingNwDst() *OxmIdConnTrackingNwDst {
16486 obj := &OxmIdConnTrackingNwDst{
16487 OxmId: NewOxmId(127492),
16488 }
16489 return obj
16490}
16491func (self *OxmIdConnTrackingNwDst) GetOXMName() string {
16492 return "conn_tracking_nw_dst"
16493}
16494
16495func (self *OxmIdConnTrackingNwDst) MarshalJSON() ([]byte, error) {
16496 if self.TypeLen == 0 {
16497 return []byte("\"\""), nil
16498 } else {
16499 return []byte("\"" + self.GetOXMName() + "\""), nil
16500 }
16501}
16502
16503type OxmIdConnTrackingNwDstMasked struct {
16504 *OxmId
16505}
16506
16507type IOxmIdConnTrackingNwDstMasked interface {
16508 IOxmId
16509}
16510
16511func (self *OxmIdConnTrackingNwDstMasked) Serialize(encoder *goloxi.Encoder) error {
16512 if err := self.OxmId.Serialize(encoder); err != nil {
16513 return err
16514 }
16515
16516 return nil
16517}
16518
16519func DecodeOxmIdConnTrackingNwDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwDstMasked, error) {
16520 _oxmidconntrackingnwdstmasked := &OxmIdConnTrackingNwDstMasked{OxmId: parent}
16521 return _oxmidconntrackingnwdstmasked, nil
16522}
16523
16524func NewOxmIdConnTrackingNwDstMasked() *OxmIdConnTrackingNwDstMasked {
16525 obj := &OxmIdConnTrackingNwDstMasked{
16526 OxmId: NewOxmId(127752),
16527 }
16528 return obj
16529}
16530func (self *OxmIdConnTrackingNwDstMasked) GetOXMName() string {
16531 return "conn_tracking_nw_dst_masked"
16532}
16533
16534func (self *OxmIdConnTrackingNwDstMasked) MarshalJSON() ([]byte, error) {
16535 if self.TypeLen == 0 {
16536 return []byte("\"\""), nil
16537 } else {
16538 return []byte("\"" + self.GetOXMName() + "\""), nil
16539 }
16540}
16541
16542type OxmIdConnTrackingNwProto struct {
16543 *OxmId
16544}
16545
16546type IOxmIdConnTrackingNwProto interface {
16547 IOxmId
16548}
16549
16550func (self *OxmIdConnTrackingNwProto) Serialize(encoder *goloxi.Encoder) error {
16551 if err := self.OxmId.Serialize(encoder); err != nil {
16552 return err
16553 }
16554
16555 return nil
16556}
16557
16558func DecodeOxmIdConnTrackingNwProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwProto, error) {
16559 _oxmidconntrackingnwproto := &OxmIdConnTrackingNwProto{OxmId: parent}
16560 return _oxmidconntrackingnwproto, nil
16561}
16562
16563func NewOxmIdConnTrackingNwProto() *OxmIdConnTrackingNwProto {
16564 obj := &OxmIdConnTrackingNwProto{
16565 OxmId: NewOxmId(126465),
16566 }
16567 return obj
16568}
16569func (self *OxmIdConnTrackingNwProto) GetOXMName() string {
16570 return "conn_tracking_nw_proto"
16571}
16572
16573func (self *OxmIdConnTrackingNwProto) MarshalJSON() ([]byte, error) {
16574 if self.TypeLen == 0 {
16575 return []byte("\"\""), nil
16576 } else {
16577 return []byte("\"" + self.GetOXMName() + "\""), nil
16578 }
16579}
16580
16581type OxmIdConnTrackingNwProtoMasked struct {
16582 *OxmId
16583}
16584
16585type IOxmIdConnTrackingNwProtoMasked interface {
16586 IOxmId
16587}
16588
16589func (self *OxmIdConnTrackingNwProtoMasked) Serialize(encoder *goloxi.Encoder) error {
16590 if err := self.OxmId.Serialize(encoder); err != nil {
16591 return err
16592 }
16593
16594 return nil
16595}
16596
16597func DecodeOxmIdConnTrackingNwProtoMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwProtoMasked, error) {
16598 _oxmidconntrackingnwprotomasked := &OxmIdConnTrackingNwProtoMasked{OxmId: parent}
16599 return _oxmidconntrackingnwprotomasked, nil
16600}
16601
16602func NewOxmIdConnTrackingNwProtoMasked() *OxmIdConnTrackingNwProtoMasked {
16603 obj := &OxmIdConnTrackingNwProtoMasked{
16604 OxmId: NewOxmId(126722),
16605 }
16606 return obj
16607}
16608func (self *OxmIdConnTrackingNwProtoMasked) GetOXMName() string {
16609 return "conn_tracking_nw_proto_masked"
16610}
16611
16612func (self *OxmIdConnTrackingNwProtoMasked) MarshalJSON() ([]byte, error) {
16613 if self.TypeLen == 0 {
16614 return []byte("\"\""), nil
16615 } else {
16616 return []byte("\"" + self.GetOXMName() + "\""), nil
16617 }
16618}
16619
16620type OxmIdConnTrackingNwSrc struct {
16621 *OxmId
16622}
16623
16624type IOxmIdConnTrackingNwSrc interface {
16625 IOxmId
16626}
16627
16628func (self *OxmIdConnTrackingNwSrc) Serialize(encoder *goloxi.Encoder) error {
16629 if err := self.OxmId.Serialize(encoder); err != nil {
16630 return err
16631 }
16632
16633 return nil
16634}
16635
16636func DecodeOxmIdConnTrackingNwSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwSrc, error) {
16637 _oxmidconntrackingnwsrc := &OxmIdConnTrackingNwSrc{OxmId: parent}
16638 return _oxmidconntrackingnwsrc, nil
16639}
16640
16641func NewOxmIdConnTrackingNwSrc() *OxmIdConnTrackingNwSrc {
16642 obj := &OxmIdConnTrackingNwSrc{
16643 OxmId: NewOxmId(126980),
16644 }
16645 return obj
16646}
16647func (self *OxmIdConnTrackingNwSrc) GetOXMName() string {
16648 return "conn_tracking_nw_src"
16649}
16650
16651func (self *OxmIdConnTrackingNwSrc) MarshalJSON() ([]byte, error) {
16652 if self.TypeLen == 0 {
16653 return []byte("\"\""), nil
16654 } else {
16655 return []byte("\"" + self.GetOXMName() + "\""), nil
16656 }
16657}
16658
16659type OxmIdConnTrackingNwSrcMasked struct {
16660 *OxmId
16661}
16662
16663type IOxmIdConnTrackingNwSrcMasked interface {
16664 IOxmId
16665}
16666
16667func (self *OxmIdConnTrackingNwSrcMasked) Serialize(encoder *goloxi.Encoder) error {
16668 if err := self.OxmId.Serialize(encoder); err != nil {
16669 return err
16670 }
16671
16672 return nil
16673}
16674
16675func DecodeOxmIdConnTrackingNwSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwSrcMasked, error) {
16676 _oxmidconntrackingnwsrcmasked := &OxmIdConnTrackingNwSrcMasked{OxmId: parent}
16677 return _oxmidconntrackingnwsrcmasked, nil
16678}
16679
16680func NewOxmIdConnTrackingNwSrcMasked() *OxmIdConnTrackingNwSrcMasked {
16681 obj := &OxmIdConnTrackingNwSrcMasked{
16682 OxmId: NewOxmId(127240),
16683 }
16684 return obj
16685}
16686func (self *OxmIdConnTrackingNwSrcMasked) GetOXMName() string {
16687 return "conn_tracking_nw_src_masked"
16688}
16689
16690func (self *OxmIdConnTrackingNwSrcMasked) MarshalJSON() ([]byte, error) {
16691 if self.TypeLen == 0 {
16692 return []byte("\"\""), nil
16693 } else {
16694 return []byte("\"" + self.GetOXMName() + "\""), nil
16695 }
16696}
16697
16698type OxmIdConnTrackingState struct {
16699 *OxmId
16700}
16701
16702type IOxmIdConnTrackingState interface {
16703 IOxmId
16704}
16705
16706func (self *OxmIdConnTrackingState) Serialize(encoder *goloxi.Encoder) error {
16707 if err := self.OxmId.Serialize(encoder); err != nil {
16708 return err
16709 }
16710
16711 return nil
16712}
16713
16714func DecodeOxmIdConnTrackingState(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingState, error) {
16715 _oxmidconntrackingstate := &OxmIdConnTrackingState{OxmId: parent}
16716 return _oxmidconntrackingstate, nil
16717}
16718
16719func NewOxmIdConnTrackingState() *OxmIdConnTrackingState {
16720 obj := &OxmIdConnTrackingState{
16721 OxmId: NewOxmId(119300),
16722 }
16723 return obj
16724}
16725func (self *OxmIdConnTrackingState) GetOXMName() string {
16726 return "conn_tracking_state"
16727}
16728
16729func (self *OxmIdConnTrackingState) MarshalJSON() ([]byte, error) {
16730 if self.TypeLen == 0 {
16731 return []byte("\"\""), nil
16732 } else {
16733 return []byte("\"" + self.GetOXMName() + "\""), nil
16734 }
16735}
16736
16737type OxmIdConnTrackingStateMasked struct {
16738 *OxmId
16739}
16740
16741type IOxmIdConnTrackingStateMasked interface {
16742 IOxmId
16743}
16744
16745func (self *OxmIdConnTrackingStateMasked) Serialize(encoder *goloxi.Encoder) error {
16746 if err := self.OxmId.Serialize(encoder); err != nil {
16747 return err
16748 }
16749
16750 return nil
16751}
16752
16753func DecodeOxmIdConnTrackingStateMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingStateMasked, error) {
16754 _oxmidconntrackingstatemasked := &OxmIdConnTrackingStateMasked{OxmId: parent}
16755 return _oxmidconntrackingstatemasked, nil
16756}
16757
16758func NewOxmIdConnTrackingStateMasked() *OxmIdConnTrackingStateMasked {
16759 obj := &OxmIdConnTrackingStateMasked{
16760 OxmId: NewOxmId(119560),
16761 }
16762 return obj
16763}
16764func (self *OxmIdConnTrackingStateMasked) GetOXMName() string {
16765 return "conn_tracking_state_masked"
16766}
16767
16768func (self *OxmIdConnTrackingStateMasked) MarshalJSON() ([]byte, error) {
16769 if self.TypeLen == 0 {
16770 return []byte("\"\""), nil
16771 } else {
16772 return []byte("\"" + self.GetOXMName() + "\""), nil
16773 }
16774}
16775
16776type OxmIdConnTrackingTpDst struct {
16777 *OxmId
16778}
16779
16780type IOxmIdConnTrackingTpDst interface {
16781 IOxmId
16782}
16783
16784func (self *OxmIdConnTrackingTpDst) Serialize(encoder *goloxi.Encoder) error {
16785 if err := self.OxmId.Serialize(encoder); err != nil {
16786 return err
16787 }
16788
16789 return nil
16790}
16791
16792func DecodeOxmIdConnTrackingTpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpDst, error) {
16793 _oxmidconntrackingtpdst := &OxmIdConnTrackingTpDst{OxmId: parent}
16794 return _oxmidconntrackingtpdst, nil
16795}
16796
16797func NewOxmIdConnTrackingTpDst() *OxmIdConnTrackingTpDst {
16798 obj := &OxmIdConnTrackingTpDst{
16799 OxmId: NewOxmId(129538),
16800 }
16801 return obj
16802}
16803func (self *OxmIdConnTrackingTpDst) GetOXMName() string {
16804 return "conn_tracking_tp_dst"
16805}
16806
16807func (self *OxmIdConnTrackingTpDst) MarshalJSON() ([]byte, error) {
16808 if self.TypeLen == 0 {
16809 return []byte("\"\""), nil
16810 } else {
16811 return []byte("\"" + self.GetOXMName() + "\""), nil
16812 }
16813}
16814
16815type OxmIdConnTrackingTpDstMasked struct {
16816 *OxmId
16817}
16818
16819type IOxmIdConnTrackingTpDstMasked interface {
16820 IOxmId
16821}
16822
16823func (self *OxmIdConnTrackingTpDstMasked) Serialize(encoder *goloxi.Encoder) error {
16824 if err := self.OxmId.Serialize(encoder); err != nil {
16825 return err
16826 }
16827
16828 return nil
16829}
16830
16831func DecodeOxmIdConnTrackingTpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpDstMasked, error) {
16832 _oxmidconntrackingtpdstmasked := &OxmIdConnTrackingTpDstMasked{OxmId: parent}
16833 return _oxmidconntrackingtpdstmasked, nil
16834}
16835
16836func NewOxmIdConnTrackingTpDstMasked() *OxmIdConnTrackingTpDstMasked {
16837 obj := &OxmIdConnTrackingTpDstMasked{
16838 OxmId: NewOxmId(129796),
16839 }
16840 return obj
16841}
16842func (self *OxmIdConnTrackingTpDstMasked) GetOXMName() string {
16843 return "conn_tracking_tp_dst_masked"
16844}
16845
16846func (self *OxmIdConnTrackingTpDstMasked) MarshalJSON() ([]byte, error) {
16847 if self.TypeLen == 0 {
16848 return []byte("\"\""), nil
16849 } else {
16850 return []byte("\"" + self.GetOXMName() + "\""), nil
16851 }
16852}
16853
16854type OxmIdConnTrackingTpSrc struct {
16855 *OxmId
16856}
16857
16858type IOxmIdConnTrackingTpSrc interface {
16859 IOxmId
16860}
16861
16862func (self *OxmIdConnTrackingTpSrc) Serialize(encoder *goloxi.Encoder) error {
16863 if err := self.OxmId.Serialize(encoder); err != nil {
16864 return err
16865 }
16866
16867 return nil
16868}
16869
16870func DecodeOxmIdConnTrackingTpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpSrc, error) {
16871 _oxmidconntrackingtpsrc := &OxmIdConnTrackingTpSrc{OxmId: parent}
16872 return _oxmidconntrackingtpsrc, nil
16873}
16874
16875func NewOxmIdConnTrackingTpSrc() *OxmIdConnTrackingTpSrc {
16876 obj := &OxmIdConnTrackingTpSrc{
16877 OxmId: NewOxmId(129026),
16878 }
16879 return obj
16880}
16881func (self *OxmIdConnTrackingTpSrc) GetOXMName() string {
16882 return "conn_tracking_tp_src"
16883}
16884
16885func (self *OxmIdConnTrackingTpSrc) MarshalJSON() ([]byte, error) {
16886 if self.TypeLen == 0 {
16887 return []byte("\"\""), nil
16888 } else {
16889 return []byte("\"" + self.GetOXMName() + "\""), nil
16890 }
16891}
16892
16893type OxmIdConnTrackingTpSrcMasked struct {
16894 *OxmId
16895}
16896
16897type IOxmIdConnTrackingTpSrcMasked interface {
16898 IOxmId
16899}
16900
16901func (self *OxmIdConnTrackingTpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
16902 if err := self.OxmId.Serialize(encoder); err != nil {
16903 return err
16904 }
16905
16906 return nil
16907}
16908
16909func DecodeOxmIdConnTrackingTpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpSrcMasked, error) {
16910 _oxmidconntrackingtpsrcmasked := &OxmIdConnTrackingTpSrcMasked{OxmId: parent}
16911 return _oxmidconntrackingtpsrcmasked, nil
16912}
16913
16914func NewOxmIdConnTrackingTpSrcMasked() *OxmIdConnTrackingTpSrcMasked {
16915 obj := &OxmIdConnTrackingTpSrcMasked{
16916 OxmId: NewOxmId(129284),
16917 }
16918 return obj
16919}
16920func (self *OxmIdConnTrackingTpSrcMasked) GetOXMName() string {
16921 return "conn_tracking_tp_src_masked"
16922}
16923
16924func (self *OxmIdConnTrackingTpSrcMasked) MarshalJSON() ([]byte, error) {
16925 if self.TypeLen == 0 {
16926 return []byte("\"\""), nil
16927 } else {
16928 return []byte("\"" + self.GetOXMName() + "\""), nil
16929 }
16930}
16931
16932type OxmIdConnTrackingZone struct {
16933 *OxmId
16934}
16935
16936type IOxmIdConnTrackingZone interface {
16937 IOxmId
16938}
16939
16940func (self *OxmIdConnTrackingZone) Serialize(encoder *goloxi.Encoder) error {
16941 if err := self.OxmId.Serialize(encoder); err != nil {
16942 return err
16943 }
16944
16945 return nil
16946}
16947
16948func DecodeOxmIdConnTrackingZone(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingZone, error) {
16949 _oxmidconntrackingzone := &OxmIdConnTrackingZone{OxmId: parent}
16950 return _oxmidconntrackingzone, nil
16951}
16952
16953func NewOxmIdConnTrackingZone() *OxmIdConnTrackingZone {
16954 obj := &OxmIdConnTrackingZone{
16955 OxmId: NewOxmId(119810),
16956 }
16957 return obj
16958}
16959func (self *OxmIdConnTrackingZone) GetOXMName() string {
16960 return "conn_tracking_zone"
16961}
16962
16963func (self *OxmIdConnTrackingZone) MarshalJSON() ([]byte, error) {
16964 if self.TypeLen == 0 {
16965 return []byte("\"\""), nil
16966 } else {
16967 return []byte("\"" + self.GetOXMName() + "\""), nil
16968 }
16969}
16970
16971type OxmIdConnTrackingZoneMasked struct {
16972 *OxmId
16973}
16974
16975type IOxmIdConnTrackingZoneMasked interface {
16976 IOxmId
16977}
16978
16979func (self *OxmIdConnTrackingZoneMasked) Serialize(encoder *goloxi.Encoder) error {
16980 if err := self.OxmId.Serialize(encoder); err != nil {
16981 return err
16982 }
16983
16984 return nil
16985}
16986
16987func DecodeOxmIdConnTrackingZoneMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingZoneMasked, error) {
16988 _oxmidconntrackingzonemasked := &OxmIdConnTrackingZoneMasked{OxmId: parent}
16989 return _oxmidconntrackingzonemasked, nil
16990}
16991
16992func NewOxmIdConnTrackingZoneMasked() *OxmIdConnTrackingZoneMasked {
16993 obj := &OxmIdConnTrackingZoneMasked{
16994 OxmId: NewOxmId(120068),
16995 }
16996 return obj
16997}
16998func (self *OxmIdConnTrackingZoneMasked) GetOXMName() string {
16999 return "conn_tracking_zone_masked"
17000}
17001
17002func (self *OxmIdConnTrackingZoneMasked) MarshalJSON() ([]byte, error) {
17003 if self.TypeLen == 0 {
17004 return []byte("\"\""), nil
17005 } else {
17006 return []byte("\"" + self.GetOXMName() + "\""), nil
17007 }
17008}
17009
17010type OxmIdEthTypeMasked struct {
17011 *OxmId
17012}
17013
17014type IOxmIdEthTypeMasked interface {
17015 IOxmId
17016}
17017
17018func (self *OxmIdEthTypeMasked) Serialize(encoder *goloxi.Encoder) error {
17019 if err := self.OxmId.Serialize(encoder); err != nil {
17020 return err
17021 }
17022
17023 return nil
17024}
17025
17026func DecodeOxmIdEthTypeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthTypeMasked, error) {
17027 _oxmidethtypemasked := &OxmIdEthTypeMasked{OxmId: parent}
17028 return _oxmidethtypemasked, nil
17029}
17030
17031func NewOxmIdEthTypeMasked() *OxmIdEthTypeMasked {
17032 obj := &OxmIdEthTypeMasked{
17033 OxmId: NewOxmId(2147486468),
17034 }
17035 return obj
17036}
17037func (self *OxmIdEthTypeMasked) GetOXMName() string {
17038 return "eth_type_masked"
17039}
17040
17041func (self *OxmIdEthTypeMasked) MarshalJSON() ([]byte, error) {
17042 if self.TypeLen == 0 {
17043 return []byte("\"\""), nil
17044 } else {
17045 return []byte("\"" + self.GetOXMName() + "\""), nil
17046 }
17047}
17048
17049type OxmIdIcmpv4Code struct {
17050 *OxmId
17051}
17052
17053type IOxmIdIcmpv4Code interface {
17054 IOxmId
17055}
17056
17057func (self *OxmIdIcmpv4Code) Serialize(encoder *goloxi.Encoder) error {
17058 if err := self.OxmId.Serialize(encoder); err != nil {
17059 return err
17060 }
17061
17062 return nil
17063}
17064
17065func DecodeOxmIdIcmpv4Code(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4Code, error) {
17066 _oxmidicmpv4code := &OxmIdIcmpv4Code{OxmId: parent}
17067 return _oxmidicmpv4code, nil
17068}
17069
17070func NewOxmIdIcmpv4Code() *OxmIdIcmpv4Code {
17071 obj := &OxmIdIcmpv4Code{
17072 OxmId: NewOxmId(2147493889),
17073 }
17074 return obj
17075}
17076func (self *OxmIdIcmpv4Code) GetOXMName() string {
17077 return "icmpv4_code"
17078}
17079
17080func (self *OxmIdIcmpv4Code) MarshalJSON() ([]byte, error) {
17081 if self.TypeLen == 0 {
17082 return []byte("\"\""), nil
17083 } else {
17084 return []byte("\"" + self.GetOXMName() + "\""), nil
17085 }
17086}
17087
17088type OxmIdIcmpv4CodeMasked struct {
17089 *OxmId
17090}
17091
17092type IOxmIdIcmpv4CodeMasked interface {
17093 IOxmId
17094}
17095
17096func (self *OxmIdIcmpv4CodeMasked) Serialize(encoder *goloxi.Encoder) error {
17097 if err := self.OxmId.Serialize(encoder); err != nil {
17098 return err
17099 }
17100
17101 return nil
17102}
17103
17104func DecodeOxmIdIcmpv4CodeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4CodeMasked, error) {
17105 _oxmidicmpv4codemasked := &OxmIdIcmpv4CodeMasked{OxmId: parent}
17106 return _oxmidicmpv4codemasked, nil
17107}
17108
17109func NewOxmIdIcmpv4CodeMasked() *OxmIdIcmpv4CodeMasked {
17110 obj := &OxmIdIcmpv4CodeMasked{
17111 OxmId: NewOxmId(2147494146),
17112 }
17113 return obj
17114}
17115func (self *OxmIdIcmpv4CodeMasked) GetOXMName() string {
17116 return "icmpv4_code_masked"
17117}
17118
17119func (self *OxmIdIcmpv4CodeMasked) MarshalJSON() ([]byte, error) {
17120 if self.TypeLen == 0 {
17121 return []byte("\"\""), nil
17122 } else {
17123 return []byte("\"" + self.GetOXMName() + "\""), nil
17124 }
17125}
17126
17127type OxmIdIcmpv4Type struct {
17128 *OxmId
17129}
17130
17131type IOxmIdIcmpv4Type interface {
17132 IOxmId
17133}
17134
17135func (self *OxmIdIcmpv4Type) Serialize(encoder *goloxi.Encoder) error {
17136 if err := self.OxmId.Serialize(encoder); err != nil {
17137 return err
17138 }
17139
17140 return nil
17141}
17142
17143func DecodeOxmIdIcmpv4Type(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4Type, error) {
17144 _oxmidicmpv4type := &OxmIdIcmpv4Type{OxmId: parent}
17145 return _oxmidicmpv4type, nil
17146}
17147
17148func NewOxmIdIcmpv4Type() *OxmIdIcmpv4Type {
17149 obj := &OxmIdIcmpv4Type{
17150 OxmId: NewOxmId(2147493377),
17151 }
17152 return obj
17153}
17154func (self *OxmIdIcmpv4Type) GetOXMName() string {
17155 return "icmpv4_type"
17156}
17157
17158func (self *OxmIdIcmpv4Type) MarshalJSON() ([]byte, error) {
17159 if self.TypeLen == 0 {
17160 return []byte("\"\""), nil
17161 } else {
17162 return []byte("\"" + self.GetOXMName() + "\""), nil
17163 }
17164}
17165
17166type OxmIdIcmpv4TypeMasked struct {
17167 *OxmId
17168}
17169
17170type IOxmIdIcmpv4TypeMasked interface {
17171 IOxmId
17172}
17173
17174func (self *OxmIdIcmpv4TypeMasked) Serialize(encoder *goloxi.Encoder) error {
17175 if err := self.OxmId.Serialize(encoder); err != nil {
17176 return err
17177 }
17178
17179 return nil
17180}
17181
17182func DecodeOxmIdIcmpv4TypeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4TypeMasked, error) {
17183 _oxmidicmpv4typemasked := &OxmIdIcmpv4TypeMasked{OxmId: parent}
17184 return _oxmidicmpv4typemasked, nil
17185}
17186
17187func NewOxmIdIcmpv4TypeMasked() *OxmIdIcmpv4TypeMasked {
17188 obj := &OxmIdIcmpv4TypeMasked{
17189 OxmId: NewOxmId(2147493634),
17190 }
17191 return obj
17192}
17193func (self *OxmIdIcmpv4TypeMasked) GetOXMName() string {
17194 return "icmpv4_type_masked"
17195}
17196
17197func (self *OxmIdIcmpv4TypeMasked) MarshalJSON() ([]byte, error) {
17198 if self.TypeLen == 0 {
17199 return []byte("\"\""), nil
17200 } else {
17201 return []byte("\"" + self.GetOXMName() + "\""), nil
17202 }
17203}
17204
17205type OxmIdIcmpv6CodeMasked struct {
17206 *OxmId
17207}
17208
17209type IOxmIdIcmpv6CodeMasked interface {
17210 IOxmId
17211}
17212
17213func (self *OxmIdIcmpv6CodeMasked) Serialize(encoder *goloxi.Encoder) error {
17214 if err := self.OxmId.Serialize(encoder); err != nil {
17215 return err
17216 }
17217
17218 return nil
17219}
17220
17221func DecodeOxmIdIcmpv6CodeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6CodeMasked, error) {
17222 _oxmidicmpv6codemasked := &OxmIdIcmpv6CodeMasked{OxmId: parent}
17223 return _oxmidicmpv6codemasked, nil
17224}
17225
17226func NewOxmIdIcmpv6CodeMasked() *OxmIdIcmpv6CodeMasked {
17227 obj := &OxmIdIcmpv6CodeMasked{
17228 OxmId: NewOxmId(2147499266),
17229 }
17230 return obj
17231}
17232func (self *OxmIdIcmpv6CodeMasked) GetOXMName() string {
17233 return "icmpv6_code_masked"
17234}
17235
17236func (self *OxmIdIcmpv6CodeMasked) MarshalJSON() ([]byte, error) {
17237 if self.TypeLen == 0 {
17238 return []byte("\"\""), nil
17239 } else {
17240 return []byte("\"" + self.GetOXMName() + "\""), nil
17241 }
17242}
17243
17244type OxmIdIcmpv6TypeMasked struct {
17245 *OxmId
17246}
17247
17248type IOxmIdIcmpv6TypeMasked interface {
17249 IOxmId
17250}
17251
17252func (self *OxmIdIcmpv6TypeMasked) Serialize(encoder *goloxi.Encoder) error {
17253 if err := self.OxmId.Serialize(encoder); err != nil {
17254 return err
17255 }
17256
17257 return nil
17258}
17259
17260func DecodeOxmIdIcmpv6TypeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6TypeMasked, error) {
17261 _oxmidicmpv6typemasked := &OxmIdIcmpv6TypeMasked{OxmId: parent}
17262 return _oxmidicmpv6typemasked, nil
17263}
17264
17265func NewOxmIdIcmpv6TypeMasked() *OxmIdIcmpv6TypeMasked {
17266 obj := &OxmIdIcmpv6TypeMasked{
17267 OxmId: NewOxmId(2147498754),
17268 }
17269 return obj
17270}
17271func (self *OxmIdIcmpv6TypeMasked) GetOXMName() string {
17272 return "icmpv6_type_masked"
17273}
17274
17275func (self *OxmIdIcmpv6TypeMasked) MarshalJSON() ([]byte, error) {
17276 if self.TypeLen == 0 {
17277 return []byte("\"\""), nil
17278 } else {
17279 return []byte("\"" + self.GetOXMName() + "\""), nil
17280 }
17281}
17282
17283type OxmIdInPhyPort struct {
17284 *OxmId
17285}
17286
17287type IOxmIdInPhyPort interface {
17288 IOxmId
17289}
17290
17291func (self *OxmIdInPhyPort) Serialize(encoder *goloxi.Encoder) error {
17292 if err := self.OxmId.Serialize(encoder); err != nil {
17293 return err
17294 }
17295
17296 return nil
17297}
17298
17299func DecodeOxmIdInPhyPort(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPhyPort, error) {
17300 _oxmidinphyport := &OxmIdInPhyPort{OxmId: parent}
17301 return _oxmidinphyport, nil
17302}
17303
17304func NewOxmIdInPhyPort() *OxmIdInPhyPort {
17305 obj := &OxmIdInPhyPort{
17306 OxmId: NewOxmId(2147484164),
17307 }
17308 return obj
17309}
17310func (self *OxmIdInPhyPort) GetOXMName() string {
17311 return "in_phy_port"
17312}
17313
17314func (self *OxmIdInPhyPort) MarshalJSON() ([]byte, error) {
17315 if self.TypeLen == 0 {
17316 return []byte("\"\""), nil
17317 } else {
17318 return []byte("\"" + self.GetOXMName() + "\""), nil
17319 }
17320}
17321
17322type OxmIdInPhyPortMasked struct {
17323 *OxmId
17324}
17325
17326type IOxmIdInPhyPortMasked interface {
17327 IOxmId
17328}
17329
17330func (self *OxmIdInPhyPortMasked) Serialize(encoder *goloxi.Encoder) error {
17331 if err := self.OxmId.Serialize(encoder); err != nil {
17332 return err
17333 }
17334
17335 return nil
17336}
17337
17338func DecodeOxmIdInPhyPortMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPhyPortMasked, error) {
17339 _oxmidinphyportmasked := &OxmIdInPhyPortMasked{OxmId: parent}
17340 return _oxmidinphyportmasked, nil
17341}
17342
17343func NewOxmIdInPhyPortMasked() *OxmIdInPhyPortMasked {
17344 obj := &OxmIdInPhyPortMasked{
17345 OxmId: NewOxmId(2147484424),
17346 }
17347 return obj
17348}
17349func (self *OxmIdInPhyPortMasked) GetOXMName() string {
17350 return "in_phy_port_masked"
17351}
17352
17353func (self *OxmIdInPhyPortMasked) MarshalJSON() ([]byte, error) {
17354 if self.TypeLen == 0 {
17355 return []byte("\"\""), nil
17356 } else {
17357 return []byte("\"" + self.GetOXMName() + "\""), nil
17358 }
17359}
17360
17361type OxmIdInPortMasked struct {
17362 *OxmId
17363}
17364
17365type IOxmIdInPortMasked interface {
17366 IOxmId
17367}
17368
17369func (self *OxmIdInPortMasked) Serialize(encoder *goloxi.Encoder) error {
17370 if err := self.OxmId.Serialize(encoder); err != nil {
17371 return err
17372 }
17373
17374 return nil
17375}
17376
17377func DecodeOxmIdInPortMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPortMasked, error) {
17378 _oxmidinportmasked := &OxmIdInPortMasked{OxmId: parent}
17379 return _oxmidinportmasked, nil
17380}
17381
17382func NewOxmIdInPortMasked() *OxmIdInPortMasked {
17383 obj := &OxmIdInPortMasked{
17384 OxmId: NewOxmId(2147483912),
17385 }
17386 return obj
17387}
17388func (self *OxmIdInPortMasked) GetOXMName() string {
17389 return "in_port_masked"
17390}
17391
17392func (self *OxmIdInPortMasked) MarshalJSON() ([]byte, error) {
17393 if self.TypeLen == 0 {
17394 return []byte("\"\""), nil
17395 } else {
17396 return []byte("\"" + self.GetOXMName() + "\""), nil
17397 }
17398}
17399
17400type OxmIdIpDscp struct {
17401 *OxmId
17402}
17403
17404type IOxmIdIpDscp interface {
17405 IOxmId
17406}
17407
17408func (self *OxmIdIpDscp) Serialize(encoder *goloxi.Encoder) error {
17409 if err := self.OxmId.Serialize(encoder); err != nil {
17410 return err
17411 }
17412
17413 return nil
17414}
17415
17416func DecodeOxmIdIpDscp(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDscp, error) {
17417 _oxmidipdscp := &OxmIdIpDscp{OxmId: parent}
17418 return _oxmidipdscp, nil
17419}
17420
17421func NewOxmIdIpDscp() *OxmIdIpDscp {
17422 obj := &OxmIdIpDscp{
17423 OxmId: NewOxmId(2147487745),
17424 }
17425 return obj
17426}
17427func (self *OxmIdIpDscp) GetOXMName() string {
17428 return "ip_dscp"
17429}
17430
17431func (self *OxmIdIpDscp) MarshalJSON() ([]byte, error) {
17432 if self.TypeLen == 0 {
17433 return []byte("\"\""), nil
17434 } else {
17435 return []byte("\"" + self.GetOXMName() + "\""), nil
17436 }
17437}
17438
17439type OxmIdIpDscpMasked struct {
17440 *OxmId
17441}
17442
17443type IOxmIdIpDscpMasked interface {
17444 IOxmId
17445}
17446
17447func (self *OxmIdIpDscpMasked) Serialize(encoder *goloxi.Encoder) error {
17448 if err := self.OxmId.Serialize(encoder); err != nil {
17449 return err
17450 }
17451
17452 return nil
17453}
17454
17455func DecodeOxmIdIpDscpMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDscpMasked, error) {
17456 _oxmidipdscpmasked := &OxmIdIpDscpMasked{OxmId: parent}
17457 return _oxmidipdscpmasked, nil
17458}
17459
17460func NewOxmIdIpDscpMasked() *OxmIdIpDscpMasked {
17461 obj := &OxmIdIpDscpMasked{
17462 OxmId: NewOxmId(2147488002),
17463 }
17464 return obj
17465}
17466func (self *OxmIdIpDscpMasked) GetOXMName() string {
17467 return "ip_dscp_masked"
17468}
17469
17470func (self *OxmIdIpDscpMasked) MarshalJSON() ([]byte, error) {
17471 if self.TypeLen == 0 {
17472 return []byte("\"\""), nil
17473 } else {
17474 return []byte("\"" + self.GetOXMName() + "\""), nil
17475 }
17476}
17477
17478type OxmIdIpEcn struct {
17479 *OxmId
17480}
17481
17482type IOxmIdIpEcn interface {
17483 IOxmId
17484}
17485
17486func (self *OxmIdIpEcn) Serialize(encoder *goloxi.Encoder) error {
17487 if err := self.OxmId.Serialize(encoder); err != nil {
17488 return err
17489 }
17490
17491 return nil
17492}
17493
17494func DecodeOxmIdIpEcn(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpEcn, error) {
17495 _oxmidipecn := &OxmIdIpEcn{OxmId: parent}
17496 return _oxmidipecn, nil
17497}
17498
17499func NewOxmIdIpEcn() *OxmIdIpEcn {
17500 obj := &OxmIdIpEcn{
17501 OxmId: NewOxmId(2147488257),
17502 }
17503 return obj
17504}
17505func (self *OxmIdIpEcn) GetOXMName() string {
17506 return "ip_ecn"
17507}
17508
17509func (self *OxmIdIpEcn) MarshalJSON() ([]byte, error) {
17510 if self.TypeLen == 0 {
17511 return []byte("\"\""), nil
17512 } else {
17513 return []byte("\"" + self.GetOXMName() + "\""), nil
17514 }
17515}
17516
17517type OxmIdIpEcnMasked struct {
17518 *OxmId
17519}
17520
17521type IOxmIdIpEcnMasked interface {
17522 IOxmId
17523}
17524
17525func (self *OxmIdIpEcnMasked) Serialize(encoder *goloxi.Encoder) error {
17526 if err := self.OxmId.Serialize(encoder); err != nil {
17527 return err
17528 }
17529
17530 return nil
17531}
17532
17533func DecodeOxmIdIpEcnMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpEcnMasked, error) {
17534 _oxmidipecnmasked := &OxmIdIpEcnMasked{OxmId: parent}
17535 return _oxmidipecnmasked, nil
17536}
17537
17538func NewOxmIdIpEcnMasked() *OxmIdIpEcnMasked {
17539 obj := &OxmIdIpEcnMasked{
17540 OxmId: NewOxmId(2147488514),
17541 }
17542 return obj
17543}
17544func (self *OxmIdIpEcnMasked) GetOXMName() string {
17545 return "ip_ecn_masked"
17546}
17547
17548func (self *OxmIdIpEcnMasked) MarshalJSON() ([]byte, error) {
17549 if self.TypeLen == 0 {
17550 return []byte("\"\""), nil
17551 } else {
17552 return []byte("\"" + self.GetOXMName() + "\""), nil
17553 }
17554}
17555
17556type OxmIdIpProto struct {
17557 *OxmId
17558}
17559
17560type IOxmIdIpProto interface {
17561 IOxmId
17562}
17563
17564func (self *OxmIdIpProto) Serialize(encoder *goloxi.Encoder) error {
17565 if err := self.OxmId.Serialize(encoder); err != nil {
17566 return err
17567 }
17568
17569 return nil
17570}
17571
17572func DecodeOxmIdIpProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpProto, error) {
17573 _oxmidipproto := &OxmIdIpProto{OxmId: parent}
17574 return _oxmidipproto, nil
17575}
17576
17577func NewOxmIdIpProto() *OxmIdIpProto {
17578 obj := &OxmIdIpProto{
17579 OxmId: NewOxmId(2147488769),
17580 }
17581 return obj
17582}
17583func (self *OxmIdIpProto) GetOXMName() string {
17584 return "ip_proto"
17585}
17586
17587func (self *OxmIdIpProto) MarshalJSON() ([]byte, error) {
17588 if self.TypeLen == 0 {
17589 return []byte("\"\""), nil
17590 } else {
17591 return []byte("\"" + self.GetOXMName() + "\""), nil
17592 }
17593}
17594
17595type OxmIdIpProtoMasked struct {
17596 *OxmId
17597}
17598
17599type IOxmIdIpProtoMasked interface {
17600 IOxmId
17601}
17602
17603func (self *OxmIdIpProtoMasked) Serialize(encoder *goloxi.Encoder) error {
17604 if err := self.OxmId.Serialize(encoder); err != nil {
17605 return err
17606 }
17607
17608 return nil
17609}
17610
17611func DecodeOxmIdIpProtoMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpProtoMasked, error) {
17612 _oxmidipprotomasked := &OxmIdIpProtoMasked{OxmId: parent}
17613 return _oxmidipprotomasked, nil
17614}
17615
17616func NewOxmIdIpProtoMasked() *OxmIdIpProtoMasked {
17617 obj := &OxmIdIpProtoMasked{
17618 OxmId: NewOxmId(2147489026),
17619 }
17620 return obj
17621}
17622func (self *OxmIdIpProtoMasked) GetOXMName() string {
17623 return "ip_proto_masked"
17624}
17625
17626func (self *OxmIdIpProtoMasked) MarshalJSON() ([]byte, error) {
17627 if self.TypeLen == 0 {
17628 return []byte("\"\""), nil
17629 } else {
17630 return []byte("\"" + self.GetOXMName() + "\""), nil
17631 }
17632}
17633
17634type OxmIdIpv4Dst struct {
17635 *OxmId
17636}
17637
17638type IOxmIdIpv4Dst interface {
17639 IOxmId
17640}
17641
17642func (self *OxmIdIpv4Dst) Serialize(encoder *goloxi.Encoder) error {
17643 if err := self.OxmId.Serialize(encoder); err != nil {
17644 return err
17645 }
17646
17647 return nil
17648}
17649
17650func DecodeOxmIdIpv4Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4Dst, error) {
17651 _oxmidipv4dst := &OxmIdIpv4Dst{OxmId: parent}
17652 return _oxmidipv4dst, nil
17653}
17654
17655func NewOxmIdIpv4Dst() *OxmIdIpv4Dst {
17656 obj := &OxmIdIpv4Dst{
17657 OxmId: NewOxmId(2147489796),
17658 }
17659 return obj
17660}
17661func (self *OxmIdIpv4Dst) GetOXMName() string {
17662 return "ipv4_dst"
17663}
17664
17665func (self *OxmIdIpv4Dst) MarshalJSON() ([]byte, error) {
17666 if self.TypeLen == 0 {
17667 return []byte("\"\""), nil
17668 } else {
17669 return []byte("\"" + self.GetOXMName() + "\""), nil
17670 }
17671}
17672
17673type OxmIdIpv4DstMasked struct {
17674 *OxmId
17675}
17676
17677type IOxmIdIpv4DstMasked interface {
17678 IOxmId
17679}
17680
17681func (self *OxmIdIpv4DstMasked) Serialize(encoder *goloxi.Encoder) error {
17682 if err := self.OxmId.Serialize(encoder); err != nil {
17683 return err
17684 }
17685
17686 return nil
17687}
17688
17689func DecodeOxmIdIpv4DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4DstMasked, error) {
17690 _oxmidipv4dstmasked := &OxmIdIpv4DstMasked{OxmId: parent}
17691 return _oxmidipv4dstmasked, nil
17692}
17693
17694func NewOxmIdIpv4DstMasked() *OxmIdIpv4DstMasked {
17695 obj := &OxmIdIpv4DstMasked{
17696 OxmId: NewOxmId(2147490056),
17697 }
17698 return obj
17699}
17700func (self *OxmIdIpv4DstMasked) GetOXMName() string {
17701 return "ipv4_dst_masked"
17702}
17703
17704func (self *OxmIdIpv4DstMasked) MarshalJSON() ([]byte, error) {
17705 if self.TypeLen == 0 {
17706 return []byte("\"\""), nil
17707 } else {
17708 return []byte("\"" + self.GetOXMName() + "\""), nil
17709 }
17710}
17711
17712type OxmIdIpv4Src struct {
17713 *OxmId
17714}
17715
17716type IOxmIdIpv4Src interface {
17717 IOxmId
17718}
17719
17720func (self *OxmIdIpv4Src) Serialize(encoder *goloxi.Encoder) error {
17721 if err := self.OxmId.Serialize(encoder); err != nil {
17722 return err
17723 }
17724
17725 return nil
17726}
17727
17728func DecodeOxmIdIpv4Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4Src, error) {
17729 _oxmidipv4src := &OxmIdIpv4Src{OxmId: parent}
17730 return _oxmidipv4src, nil
17731}
17732
17733func NewOxmIdIpv4Src() *OxmIdIpv4Src {
17734 obj := &OxmIdIpv4Src{
17735 OxmId: NewOxmId(2147489284),
17736 }
17737 return obj
17738}
17739func (self *OxmIdIpv4Src) GetOXMName() string {
17740 return "ipv4_src"
17741}
17742
17743func (self *OxmIdIpv4Src) MarshalJSON() ([]byte, error) {
17744 if self.TypeLen == 0 {
17745 return []byte("\"\""), nil
17746 } else {
17747 return []byte("\"" + self.GetOXMName() + "\""), nil
17748 }
17749}
17750
17751type OxmIdIpv4SrcMasked struct {
17752 *OxmId
17753}
17754
17755type IOxmIdIpv4SrcMasked interface {
17756 IOxmId
17757}
17758
17759func (self *OxmIdIpv4SrcMasked) Serialize(encoder *goloxi.Encoder) error {
17760 if err := self.OxmId.Serialize(encoder); err != nil {
17761 return err
17762 }
17763
17764 return nil
17765}
17766
17767func DecodeOxmIdIpv4SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4SrcMasked, error) {
17768 _oxmidipv4srcmasked := &OxmIdIpv4SrcMasked{OxmId: parent}
17769 return _oxmidipv4srcmasked, nil
17770}
17771
17772func NewOxmIdIpv4SrcMasked() *OxmIdIpv4SrcMasked {
17773 obj := &OxmIdIpv4SrcMasked{
17774 OxmId: NewOxmId(2147489544),
17775 }
17776 return obj
17777}
17778func (self *OxmIdIpv4SrcMasked) GetOXMName() string {
17779 return "ipv4_src_masked"
17780}
17781
17782func (self *OxmIdIpv4SrcMasked) MarshalJSON() ([]byte, error) {
17783 if self.TypeLen == 0 {
17784 return []byte("\"\""), nil
17785 } else {
17786 return []byte("\"" + self.GetOXMName() + "\""), nil
17787 }
17788}
17789
17790type OxmIdIpv6Flabel struct {
17791 *OxmId
17792}
17793
17794type IOxmIdIpv6Flabel interface {
17795 IOxmId
17796}
17797
17798func (self *OxmIdIpv6Flabel) Serialize(encoder *goloxi.Encoder) error {
17799 if err := self.OxmId.Serialize(encoder); err != nil {
17800 return err
17801 }
17802
17803 return nil
17804}
17805
17806func DecodeOxmIdIpv6Flabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Flabel, error) {
17807 _oxmidipv6flabel := &OxmIdIpv6Flabel{OxmId: parent}
17808 return _oxmidipv6flabel, nil
17809}
17810
17811func NewOxmIdIpv6Flabel() *OxmIdIpv6Flabel {
17812 obj := &OxmIdIpv6Flabel{
17813 OxmId: NewOxmId(2147497988),
17814 }
17815 return obj
17816}
17817func (self *OxmIdIpv6Flabel) GetOXMName() string {
17818 return "ipv6_flabel"
17819}
17820
17821func (self *OxmIdIpv6Flabel) MarshalJSON() ([]byte, error) {
17822 if self.TypeLen == 0 {
17823 return []byte("\"\""), nil
17824 } else {
17825 return []byte("\"" + self.GetOXMName() + "\""), nil
17826 }
17827}
17828
17829type OxmIdIpv6FlabelMasked struct {
17830 *OxmId
17831}
17832
17833type IOxmIdIpv6FlabelMasked interface {
17834 IOxmId
17835}
17836
17837func (self *OxmIdIpv6FlabelMasked) Serialize(encoder *goloxi.Encoder) error {
17838 if err := self.OxmId.Serialize(encoder); err != nil {
17839 return err
17840 }
17841
17842 return nil
17843}
17844
17845func DecodeOxmIdIpv6FlabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6FlabelMasked, error) {
17846 _oxmidipv6flabelmasked := &OxmIdIpv6FlabelMasked{OxmId: parent}
17847 return _oxmidipv6flabelmasked, nil
17848}
17849
17850func NewOxmIdIpv6FlabelMasked() *OxmIdIpv6FlabelMasked {
17851 obj := &OxmIdIpv6FlabelMasked{
17852 OxmId: NewOxmId(2147498248),
17853 }
17854 return obj
17855}
17856func (self *OxmIdIpv6FlabelMasked) GetOXMName() string {
17857 return "ipv6_flabel_masked"
17858}
17859
17860func (self *OxmIdIpv6FlabelMasked) MarshalJSON() ([]byte, error) {
17861 if self.TypeLen == 0 {
17862 return []byte("\"\""), nil
17863 } else {
17864 return []byte("\"" + self.GetOXMName() + "\""), nil
17865 }
17866}
17867
17868type OxmIdIpv6NdSll struct {
17869 *OxmId
17870}
17871
17872type IOxmIdIpv6NdSll interface {
17873 IOxmId
17874}
17875
17876func (self *OxmIdIpv6NdSll) Serialize(encoder *goloxi.Encoder) error {
17877 if err := self.OxmId.Serialize(encoder); err != nil {
17878 return err
17879 }
17880
17881 return nil
17882}
17883
17884func DecodeOxmIdIpv6NdSll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdSll, error) {
17885 _oxmidipv6ndsll := &OxmIdIpv6NdSll{OxmId: parent}
17886 return _oxmidipv6ndsll, nil
17887}
17888
17889func NewOxmIdIpv6NdSll() *OxmIdIpv6NdSll {
17890 obj := &OxmIdIpv6NdSll{
17891 OxmId: NewOxmId(2147500038),
17892 }
17893 return obj
17894}
17895func (self *OxmIdIpv6NdSll) GetOXMName() string {
17896 return "ipv6_nd_sll"
17897}
17898
17899func (self *OxmIdIpv6NdSll) MarshalJSON() ([]byte, error) {
17900 if self.TypeLen == 0 {
17901 return []byte("\"\""), nil
17902 } else {
17903 return []byte("\"" + self.GetOXMName() + "\""), nil
17904 }
17905}
17906
17907type OxmIdIpv6NdSllMasked struct {
17908 *OxmId
17909}
17910
17911type IOxmIdIpv6NdSllMasked interface {
17912 IOxmId
17913}
17914
17915func (self *OxmIdIpv6NdSllMasked) Serialize(encoder *goloxi.Encoder) error {
17916 if err := self.OxmId.Serialize(encoder); err != nil {
17917 return err
17918 }
17919
17920 return nil
17921}
17922
17923func DecodeOxmIdIpv6NdSllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdSllMasked, error) {
17924 _oxmidipv6ndsllmasked := &OxmIdIpv6NdSllMasked{OxmId: parent}
17925 return _oxmidipv6ndsllmasked, nil
17926}
17927
17928func NewOxmIdIpv6NdSllMasked() *OxmIdIpv6NdSllMasked {
17929 obj := &OxmIdIpv6NdSllMasked{
17930 OxmId: NewOxmId(2147500300),
17931 }
17932 return obj
17933}
17934func (self *OxmIdIpv6NdSllMasked) GetOXMName() string {
17935 return "ipv6_nd_sll_masked"
17936}
17937
17938func (self *OxmIdIpv6NdSllMasked) MarshalJSON() ([]byte, error) {
17939 if self.TypeLen == 0 {
17940 return []byte("\"\""), nil
17941 } else {
17942 return []byte("\"" + self.GetOXMName() + "\""), nil
17943 }
17944}
17945
17946type OxmIdIpv6NdTarget struct {
17947 *OxmId
17948}
17949
17950type IOxmIdIpv6NdTarget interface {
17951 IOxmId
17952}
17953
17954func (self *OxmIdIpv6NdTarget) Serialize(encoder *goloxi.Encoder) error {
17955 if err := self.OxmId.Serialize(encoder); err != nil {
17956 return err
17957 }
17958
17959 return nil
17960}
17961
17962func DecodeOxmIdIpv6NdTarget(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTarget, error) {
17963 _oxmidipv6ndtarget := &OxmIdIpv6NdTarget{OxmId: parent}
17964 return _oxmidipv6ndtarget, nil
17965}
17966
17967func NewOxmIdIpv6NdTarget() *OxmIdIpv6NdTarget {
17968 obj := &OxmIdIpv6NdTarget{
17969 OxmId: NewOxmId(2147499536),
17970 }
17971 return obj
17972}
17973func (self *OxmIdIpv6NdTarget) GetOXMName() string {
17974 return "ipv6_nd_target"
17975}
17976
17977func (self *OxmIdIpv6NdTarget) MarshalJSON() ([]byte, error) {
17978 if self.TypeLen == 0 {
17979 return []byte("\"\""), nil
17980 } else {
17981 return []byte("\"" + self.GetOXMName() + "\""), nil
17982 }
17983}
17984
17985type OxmIdIpv6NdTargetMasked struct {
17986 *OxmId
17987}
17988
17989type IOxmIdIpv6NdTargetMasked interface {
17990 IOxmId
17991}
17992
17993func (self *OxmIdIpv6NdTargetMasked) Serialize(encoder *goloxi.Encoder) error {
17994 if err := self.OxmId.Serialize(encoder); err != nil {
17995 return err
17996 }
17997
17998 return nil
17999}
18000
18001func DecodeOxmIdIpv6NdTargetMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTargetMasked, error) {
18002 _oxmidipv6ndtargetmasked := &OxmIdIpv6NdTargetMasked{OxmId: parent}
18003 return _oxmidipv6ndtargetmasked, nil
18004}
18005
18006func NewOxmIdIpv6NdTargetMasked() *OxmIdIpv6NdTargetMasked {
18007 obj := &OxmIdIpv6NdTargetMasked{
18008 OxmId: NewOxmId(2147499808),
18009 }
18010 return obj
18011}
18012func (self *OxmIdIpv6NdTargetMasked) GetOXMName() string {
18013 return "ipv6_nd_target_masked"
18014}
18015
18016func (self *OxmIdIpv6NdTargetMasked) MarshalJSON() ([]byte, error) {
18017 if self.TypeLen == 0 {
18018 return []byte("\"\""), nil
18019 } else {
18020 return []byte("\"" + self.GetOXMName() + "\""), nil
18021 }
18022}
18023
18024type OxmIdIpv6NdTll struct {
18025 *OxmId
18026}
18027
18028type IOxmIdIpv6NdTll interface {
18029 IOxmId
18030}
18031
18032func (self *OxmIdIpv6NdTll) Serialize(encoder *goloxi.Encoder) error {
18033 if err := self.OxmId.Serialize(encoder); err != nil {
18034 return err
18035 }
18036
18037 return nil
18038}
18039
18040func DecodeOxmIdIpv6NdTll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTll, error) {
18041 _oxmidipv6ndtll := &OxmIdIpv6NdTll{OxmId: parent}
18042 return _oxmidipv6ndtll, nil
18043}
18044
18045func NewOxmIdIpv6NdTll() *OxmIdIpv6NdTll {
18046 obj := &OxmIdIpv6NdTll{
18047 OxmId: NewOxmId(2147500550),
18048 }
18049 return obj
18050}
18051func (self *OxmIdIpv6NdTll) GetOXMName() string {
18052 return "ipv6_nd_tll"
18053}
18054
18055func (self *OxmIdIpv6NdTll) MarshalJSON() ([]byte, error) {
18056 if self.TypeLen == 0 {
18057 return []byte("\"\""), nil
18058 } else {
18059 return []byte("\"" + self.GetOXMName() + "\""), nil
18060 }
18061}
18062
18063type OxmIdIpv6NdTllMasked struct {
18064 *OxmId
18065}
18066
18067type IOxmIdIpv6NdTllMasked interface {
18068 IOxmId
18069}
18070
18071func (self *OxmIdIpv6NdTllMasked) Serialize(encoder *goloxi.Encoder) error {
18072 if err := self.OxmId.Serialize(encoder); err != nil {
18073 return err
18074 }
18075
18076 return nil
18077}
18078
18079func DecodeOxmIdIpv6NdTllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTllMasked, error) {
18080 _oxmidipv6ndtllmasked := &OxmIdIpv6NdTllMasked{OxmId: parent}
18081 return _oxmidipv6ndtllmasked, nil
18082}
18083
18084func NewOxmIdIpv6NdTllMasked() *OxmIdIpv6NdTllMasked {
18085 obj := &OxmIdIpv6NdTllMasked{
18086 OxmId: NewOxmId(2147500812),
18087 }
18088 return obj
18089}
18090func (self *OxmIdIpv6NdTllMasked) GetOXMName() string {
18091 return "ipv6_nd_tll_masked"
18092}
18093
18094func (self *OxmIdIpv6NdTllMasked) MarshalJSON() ([]byte, error) {
18095 if self.TypeLen == 0 {
18096 return []byte("\"\""), nil
18097 } else {
18098 return []byte("\"" + self.GetOXMName() + "\""), nil
18099 }
18100}
18101
18102type OxmIdMetadata struct {
18103 *OxmId
18104}
18105
18106type IOxmIdMetadata interface {
18107 IOxmId
18108}
18109
18110func (self *OxmIdMetadata) Serialize(encoder *goloxi.Encoder) error {
18111 if err := self.OxmId.Serialize(encoder); err != nil {
18112 return err
18113 }
18114
18115 return nil
18116}
18117
18118func DecodeOxmIdMetadata(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMetadata, error) {
18119 _oxmidmetadata := &OxmIdMetadata{OxmId: parent}
18120 return _oxmidmetadata, nil
18121}
18122
18123func NewOxmIdMetadata() *OxmIdMetadata {
18124 obj := &OxmIdMetadata{
18125 OxmId: NewOxmId(2147484680),
18126 }
18127 return obj
18128}
18129func (self *OxmIdMetadata) GetOXMName() string {
18130 return "metadata"
18131}
18132
18133func (self *OxmIdMetadata) MarshalJSON() ([]byte, error) {
18134 if self.TypeLen == 0 {
18135 return []byte("\"\""), nil
18136 } else {
18137 return []byte("\"" + self.GetOXMName() + "\""), nil
18138 }
18139}
18140
18141type OxmIdMetadataMasked struct {
18142 *OxmId
18143}
18144
18145type IOxmIdMetadataMasked interface {
18146 IOxmId
18147}
18148
18149func (self *OxmIdMetadataMasked) Serialize(encoder *goloxi.Encoder) error {
18150 if err := self.OxmId.Serialize(encoder); err != nil {
18151 return err
18152 }
18153
18154 return nil
18155}
18156
18157func DecodeOxmIdMetadataMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMetadataMasked, error) {
18158 _oxmidmetadatamasked := &OxmIdMetadataMasked{OxmId: parent}
18159 return _oxmidmetadatamasked, nil
18160}
18161
18162func NewOxmIdMetadataMasked() *OxmIdMetadataMasked {
18163 obj := &OxmIdMetadataMasked{
18164 OxmId: NewOxmId(2147484944),
18165 }
18166 return obj
18167}
18168func (self *OxmIdMetadataMasked) GetOXMName() string {
18169 return "metadata_masked"
18170}
18171
18172func (self *OxmIdMetadataMasked) MarshalJSON() ([]byte, error) {
18173 if self.TypeLen == 0 {
18174 return []byte("\"\""), nil
18175 } else {
18176 return []byte("\"" + self.GetOXMName() + "\""), nil
18177 }
18178}
18179
18180type OxmIdMplsLabel struct {
18181 *OxmId
18182}
18183
18184type IOxmIdMplsLabel interface {
18185 IOxmId
18186}
18187
18188func (self *OxmIdMplsLabel) Serialize(encoder *goloxi.Encoder) error {
18189 if err := self.OxmId.Serialize(encoder); err != nil {
18190 return err
18191 }
18192
18193 return nil
18194}
18195
18196func DecodeOxmIdMplsLabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsLabel, error) {
18197 _oxmidmplslabel := &OxmIdMplsLabel{OxmId: parent}
18198 return _oxmidmplslabel, nil
18199}
18200
18201func NewOxmIdMplsLabel() *OxmIdMplsLabel {
18202 obj := &OxmIdMplsLabel{
18203 OxmId: NewOxmId(2147501060),
18204 }
18205 return obj
18206}
18207func (self *OxmIdMplsLabel) GetOXMName() string {
18208 return "mpls_label"
18209}
18210
18211func (self *OxmIdMplsLabel) MarshalJSON() ([]byte, error) {
18212 if self.TypeLen == 0 {
18213 return []byte("\"\""), nil
18214 } else {
18215 return []byte("\"" + self.GetOXMName() + "\""), nil
18216 }
18217}
18218
18219type OxmIdMplsLabelMasked struct {
18220 *OxmId
18221}
18222
18223type IOxmIdMplsLabelMasked interface {
18224 IOxmId
18225}
18226
18227func (self *OxmIdMplsLabelMasked) Serialize(encoder *goloxi.Encoder) error {
18228 if err := self.OxmId.Serialize(encoder); err != nil {
18229 return err
18230 }
18231
18232 return nil
18233}
18234
18235func DecodeOxmIdMplsLabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsLabelMasked, error) {
18236 _oxmidmplslabelmasked := &OxmIdMplsLabelMasked{OxmId: parent}
18237 return _oxmidmplslabelmasked, nil
18238}
18239
18240func NewOxmIdMplsLabelMasked() *OxmIdMplsLabelMasked {
18241 obj := &OxmIdMplsLabelMasked{
18242 OxmId: NewOxmId(2147501320),
18243 }
18244 return obj
18245}
18246func (self *OxmIdMplsLabelMasked) GetOXMName() string {
18247 return "mpls_label_masked"
18248}
18249
18250func (self *OxmIdMplsLabelMasked) MarshalJSON() ([]byte, error) {
18251 if self.TypeLen == 0 {
18252 return []byte("\"\""), nil
18253 } else {
18254 return []byte("\"" + self.GetOXMName() + "\""), nil
18255 }
18256}
18257
18258type OxmIdMplsTc struct {
18259 *OxmId
18260}
18261
18262type IOxmIdMplsTc interface {
18263 IOxmId
18264}
18265
18266func (self *OxmIdMplsTc) Serialize(encoder *goloxi.Encoder) error {
18267 if err := self.OxmId.Serialize(encoder); err != nil {
18268 return err
18269 }
18270
18271 return nil
18272}
18273
18274func DecodeOxmIdMplsTc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsTc, error) {
18275 _oxmidmplstc := &OxmIdMplsTc{OxmId: parent}
18276 return _oxmidmplstc, nil
18277}
18278
18279func NewOxmIdMplsTc() *OxmIdMplsTc {
18280 obj := &OxmIdMplsTc{
18281 OxmId: NewOxmId(2147501569),
18282 }
18283 return obj
18284}
18285func (self *OxmIdMplsTc) GetOXMName() string {
18286 return "mpls_tc"
18287}
18288
18289func (self *OxmIdMplsTc) MarshalJSON() ([]byte, error) {
18290 if self.TypeLen == 0 {
18291 return []byte("\"\""), nil
18292 } else {
18293 return []byte("\"" + self.GetOXMName() + "\""), nil
18294 }
18295}
18296
18297type OxmIdMplsTcMasked struct {
18298 *OxmId
18299}
18300
18301type IOxmIdMplsTcMasked interface {
18302 IOxmId
18303}
18304
18305func (self *OxmIdMplsTcMasked) Serialize(encoder *goloxi.Encoder) error {
18306 if err := self.OxmId.Serialize(encoder); err != nil {
18307 return err
18308 }
18309
18310 return nil
18311}
18312
18313func DecodeOxmIdMplsTcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsTcMasked, error) {
18314 _oxmidmplstcmasked := &OxmIdMplsTcMasked{OxmId: parent}
18315 return _oxmidmplstcmasked, nil
18316}
18317
18318func NewOxmIdMplsTcMasked() *OxmIdMplsTcMasked {
18319 obj := &OxmIdMplsTcMasked{
18320 OxmId: NewOxmId(2147501826),
18321 }
18322 return obj
18323}
18324func (self *OxmIdMplsTcMasked) GetOXMName() string {
18325 return "mpls_tc_masked"
18326}
18327
18328func (self *OxmIdMplsTcMasked) MarshalJSON() ([]byte, error) {
18329 if self.TypeLen == 0 {
18330 return []byte("\"\""), nil
18331 } else {
18332 return []byte("\"" + self.GetOXMName() + "\""), nil
18333 }
18334}
18335
18336type OxmIdOvsTcpFlags struct {
18337 *OxmId
18338 ExperimenterId uint32
18339}
18340
18341type IOxmIdOvsTcpFlags interface {
18342 IOxmId
18343 GetExperimenterId() uint32
18344}
18345
18346func (self *OxmIdOvsTcpFlags) GetExperimenterId() uint32 {
18347 return self.ExperimenterId
18348}
18349
18350func (self *OxmIdOvsTcpFlags) SetExperimenterId(v uint32) {
18351 self.ExperimenterId = v
18352}
18353
18354func (self *OxmIdOvsTcpFlags) Serialize(encoder *goloxi.Encoder) error {
18355 if err := self.OxmId.Serialize(encoder); err != nil {
18356 return err
18357 }
18358
18359 encoder.PutUint32(uint32(self.ExperimenterId))
18360
18361 return nil
18362}
18363
18364func DecodeOxmIdOvsTcpFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdOvsTcpFlags, error) {
18365 _oxmidovstcpflags := &OxmIdOvsTcpFlags{OxmId: parent}
18366 if decoder.Length() < 4 {
18367 return nil, fmt.Errorf("OxmIdOvsTcpFlags packet too short: %d < 4", decoder.Length())
18368 }
18369 _oxmidovstcpflags.ExperimenterId = uint32(decoder.ReadUint32())
18370 return _oxmidovstcpflags, nil
18371}
18372
18373func NewOxmIdOvsTcpFlags() *OxmIdOvsTcpFlags {
18374 obj := &OxmIdOvsTcpFlags{
18375 OxmId: NewOxmId(4294923270),
18376 }
18377 return obj
18378}
18379func (self *OxmIdOvsTcpFlags) GetOXMName() string {
18380 return "ovs_tcp_flags"
18381}
18382
18383func (self *OxmIdOvsTcpFlags) MarshalJSON() ([]byte, error) {
18384 if self.TypeLen == 0 {
18385 return []byte("\"\""), nil
18386 } else {
18387 return []byte("\"" + self.GetOXMName() + "\""), nil
18388 }
18389}
18390
18391type OxmIdOvsTcpFlagsMasked struct {
18392 *OxmId
18393 ExperimenterId uint32
18394}
18395
18396type IOxmIdOvsTcpFlagsMasked interface {
18397 IOxmId
18398 GetExperimenterId() uint32
18399}
18400
18401func (self *OxmIdOvsTcpFlagsMasked) GetExperimenterId() uint32 {
18402 return self.ExperimenterId
18403}
18404
18405func (self *OxmIdOvsTcpFlagsMasked) SetExperimenterId(v uint32) {
18406 self.ExperimenterId = v
18407}
18408
18409func (self *OxmIdOvsTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
18410 if err := self.OxmId.Serialize(encoder); err != nil {
18411 return err
18412 }
18413
18414 encoder.PutUint32(uint32(self.ExperimenterId))
18415
18416 return nil
18417}
18418
18419func DecodeOxmIdOvsTcpFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdOvsTcpFlagsMasked, error) {
18420 _oxmidovstcpflagsmasked := &OxmIdOvsTcpFlagsMasked{OxmId: parent}
18421 if decoder.Length() < 4 {
18422 return nil, fmt.Errorf("OxmIdOvsTcpFlagsMasked packet too short: %d < 4", decoder.Length())
18423 }
18424 _oxmidovstcpflagsmasked.ExperimenterId = uint32(decoder.ReadUint32())
18425 return _oxmidovstcpflagsmasked, nil
18426}
18427
18428func NewOxmIdOvsTcpFlagsMasked() *OxmIdOvsTcpFlagsMasked {
18429 obj := &OxmIdOvsTcpFlagsMasked{
18430 OxmId: NewOxmId(4294923528),
18431 }
18432 return obj
18433}
18434func (self *OxmIdOvsTcpFlagsMasked) GetOXMName() string {
18435 return "ovs_tcp_flags_masked"
18436}
18437
18438func (self *OxmIdOvsTcpFlagsMasked) MarshalJSON() ([]byte, error) {
18439 if self.TypeLen == 0 {
18440 return []byte("\"\""), nil
18441 } else {
18442 return []byte("\"" + self.GetOXMName() + "\""), nil
18443 }
18444}
18445
18446type OxmIdSctpDst struct {
18447 *OxmId
18448}
18449
18450type IOxmIdSctpDst interface {
18451 IOxmId
18452}
18453
18454func (self *OxmIdSctpDst) Serialize(encoder *goloxi.Encoder) error {
18455 if err := self.OxmId.Serialize(encoder); err != nil {
18456 return err
18457 }
18458
18459 return nil
18460}
18461
18462func DecodeOxmIdSctpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpDst, error) {
18463 _oxmidsctpdst := &OxmIdSctpDst{OxmId: parent}
18464 return _oxmidsctpdst, nil
18465}
18466
18467func NewOxmIdSctpDst() *OxmIdSctpDst {
18468 obj := &OxmIdSctpDst{
18469 OxmId: NewOxmId(2147492866),
18470 }
18471 return obj
18472}
18473func (self *OxmIdSctpDst) GetOXMName() string {
18474 return "sctp_dst"
18475}
18476
18477func (self *OxmIdSctpDst) MarshalJSON() ([]byte, error) {
18478 if self.TypeLen == 0 {
18479 return []byte("\"\""), nil
18480 } else {
18481 return []byte("\"" + self.GetOXMName() + "\""), nil
18482 }
18483}
18484
18485type OxmIdSctpDstMasked struct {
18486 *OxmId
18487}
18488
18489type IOxmIdSctpDstMasked interface {
18490 IOxmId
18491}
18492
18493func (self *OxmIdSctpDstMasked) Serialize(encoder *goloxi.Encoder) error {
18494 if err := self.OxmId.Serialize(encoder); err != nil {
18495 return err
18496 }
18497
18498 return nil
18499}
18500
18501func DecodeOxmIdSctpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpDstMasked, error) {
18502 _oxmidsctpdstmasked := &OxmIdSctpDstMasked{OxmId: parent}
18503 return _oxmidsctpdstmasked, nil
18504}
18505
18506func NewOxmIdSctpDstMasked() *OxmIdSctpDstMasked {
18507 obj := &OxmIdSctpDstMasked{
18508 OxmId: NewOxmId(2147493124),
18509 }
18510 return obj
18511}
18512func (self *OxmIdSctpDstMasked) GetOXMName() string {
18513 return "sctp_dst_masked"
18514}
18515
18516func (self *OxmIdSctpDstMasked) MarshalJSON() ([]byte, error) {
18517 if self.TypeLen == 0 {
18518 return []byte("\"\""), nil
18519 } else {
18520 return []byte("\"" + self.GetOXMName() + "\""), nil
18521 }
18522}
18523
18524type OxmIdSctpSrc struct {
18525 *OxmId
18526}
18527
18528type IOxmIdSctpSrc interface {
18529 IOxmId
18530}
18531
18532func (self *OxmIdSctpSrc) Serialize(encoder *goloxi.Encoder) error {
18533 if err := self.OxmId.Serialize(encoder); err != nil {
18534 return err
18535 }
18536
18537 return nil
18538}
18539
18540func DecodeOxmIdSctpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpSrc, error) {
18541 _oxmidsctpsrc := &OxmIdSctpSrc{OxmId: parent}
18542 return _oxmidsctpsrc, nil
18543}
18544
18545func NewOxmIdSctpSrc() *OxmIdSctpSrc {
18546 obj := &OxmIdSctpSrc{
18547 OxmId: NewOxmId(2147492354),
18548 }
18549 return obj
18550}
18551func (self *OxmIdSctpSrc) GetOXMName() string {
18552 return "sctp_src"
18553}
18554
18555func (self *OxmIdSctpSrc) MarshalJSON() ([]byte, error) {
18556 if self.TypeLen == 0 {
18557 return []byte("\"\""), nil
18558 } else {
18559 return []byte("\"" + self.GetOXMName() + "\""), nil
18560 }
18561}
18562
18563type OxmIdSctpSrcMasked struct {
18564 *OxmId
18565}
18566
18567type IOxmIdSctpSrcMasked interface {
18568 IOxmId
18569}
18570
18571func (self *OxmIdSctpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
18572 if err := self.OxmId.Serialize(encoder); err != nil {
18573 return err
18574 }
18575
18576 return nil
18577}
18578
18579func DecodeOxmIdSctpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpSrcMasked, error) {
18580 _oxmidsctpsrcmasked := &OxmIdSctpSrcMasked{OxmId: parent}
18581 return _oxmidsctpsrcmasked, nil
18582}
18583
18584func NewOxmIdSctpSrcMasked() *OxmIdSctpSrcMasked {
18585 obj := &OxmIdSctpSrcMasked{
18586 OxmId: NewOxmId(2147492612),
18587 }
18588 return obj
18589}
18590func (self *OxmIdSctpSrcMasked) GetOXMName() string {
18591 return "sctp_src_masked"
18592}
18593
18594func (self *OxmIdSctpSrcMasked) MarshalJSON() ([]byte, error) {
18595 if self.TypeLen == 0 {
18596 return []byte("\"\""), nil
18597 } else {
18598 return []byte("\"" + self.GetOXMName() + "\""), nil
18599 }
18600}
18601
18602type OxmIdTunnelIpv4Dst struct {
18603 *OxmId
18604}
18605
18606type IOxmIdTunnelIpv4Dst interface {
18607 IOxmId
18608}
18609
18610func (self *OxmIdTunnelIpv4Dst) Serialize(encoder *goloxi.Encoder) error {
18611 if err := self.OxmId.Serialize(encoder); err != nil {
18612 return err
18613 }
18614
18615 return nil
18616}
18617
18618func DecodeOxmIdTunnelIpv4Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelIpv4Dst, error) {
18619 _oxmidtunnelipv4dst := &OxmIdTunnelIpv4Dst{OxmId: parent}
18620 return _oxmidtunnelipv4dst, nil
18621}
18622
18623func NewOxmIdTunnelIpv4Dst() *OxmIdTunnelIpv4Dst {
18624 obj := &OxmIdTunnelIpv4Dst{
18625 OxmId: NewOxmId(81924),
18626 }
18627 return obj
18628}
18629func (self *OxmIdTunnelIpv4Dst) GetOXMName() string {
18630 return "tunnel_ipv4_dst"
18631}
18632
18633func (self *OxmIdTunnelIpv4Dst) MarshalJSON() ([]byte, error) {
18634 if self.TypeLen == 0 {
18635 return []byte("\"\""), nil
18636 } else {
18637 return []byte("\"" + self.GetOXMName() + "\""), nil
18638 }
18639}
18640
18641type OxmIdTunnelIpv4DstMasked struct {
18642 *OxmId
18643}
18644
18645type IOxmIdTunnelIpv4DstMasked interface {
18646 IOxmId
18647}
18648
18649func (self *OxmIdTunnelIpv4DstMasked) Serialize(encoder *goloxi.Encoder) error {
18650 if err := self.OxmId.Serialize(encoder); err != nil {
18651 return err
18652 }
18653
18654 return nil
18655}
18656
18657func DecodeOxmIdTunnelIpv4DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelIpv4DstMasked, error) {
18658 _oxmidtunnelipv4dstmasked := &OxmIdTunnelIpv4DstMasked{OxmId: parent}
18659 return _oxmidtunnelipv4dstmasked, nil
18660}
18661
18662func NewOxmIdTunnelIpv4DstMasked() *OxmIdTunnelIpv4DstMasked {
18663 obj := &OxmIdTunnelIpv4DstMasked{
18664 OxmId: NewOxmId(82184),
18665 }
18666 return obj
18667}
18668func (self *OxmIdTunnelIpv4DstMasked) GetOXMName() string {
18669 return "tunnel_ipv4_dst_masked"
18670}
18671
18672func (self *OxmIdTunnelIpv4DstMasked) MarshalJSON() ([]byte, error) {
18673 if self.TypeLen == 0 {
18674 return []byte("\"\""), nil
18675 } else {
18676 return []byte("\"" + self.GetOXMName() + "\""), nil
18677 }
18678}
18679
18680type OxmIdTunnelIpv4Src struct {
18681 *OxmId
18682}
18683
18684type IOxmIdTunnelIpv4Src interface {
18685 IOxmId
18686}
18687
18688func (self *OxmIdTunnelIpv4Src) Serialize(encoder *goloxi.Encoder) error {
18689 if err := self.OxmId.Serialize(encoder); err != nil {
18690 return err
18691 }
18692
18693 return nil
18694}
18695
18696func DecodeOxmIdTunnelIpv4Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelIpv4Src, error) {
18697 _oxmidtunnelipv4src := &OxmIdTunnelIpv4Src{OxmId: parent}
18698 return _oxmidtunnelipv4src, nil
18699}
18700
18701func NewOxmIdTunnelIpv4Src() *OxmIdTunnelIpv4Src {
18702 obj := &OxmIdTunnelIpv4Src{
18703 OxmId: NewOxmId(81412),
18704 }
18705 return obj
18706}
18707func (self *OxmIdTunnelIpv4Src) GetOXMName() string {
18708 return "tunnel_ipv4_src"
18709}
18710
18711func (self *OxmIdTunnelIpv4Src) MarshalJSON() ([]byte, error) {
18712 if self.TypeLen == 0 {
18713 return []byte("\"\""), nil
18714 } else {
18715 return []byte("\"" + self.GetOXMName() + "\""), nil
18716 }
18717}
18718
18719type OxmIdTunnelIpv4SrcMasked struct {
18720 *OxmId
18721}
18722
18723type IOxmIdTunnelIpv4SrcMasked interface {
18724 IOxmId
18725}
18726
18727func (self *OxmIdTunnelIpv4SrcMasked) Serialize(encoder *goloxi.Encoder) error {
18728 if err := self.OxmId.Serialize(encoder); err != nil {
18729 return err
18730 }
18731
18732 return nil
18733}
18734
18735func DecodeOxmIdTunnelIpv4SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunnelIpv4SrcMasked, error) {
18736 _oxmidtunnelipv4srcmasked := &OxmIdTunnelIpv4SrcMasked{OxmId: parent}
18737 return _oxmidtunnelipv4srcmasked, nil
18738}
18739
18740func NewOxmIdTunnelIpv4SrcMasked() *OxmIdTunnelIpv4SrcMasked {
18741 obj := &OxmIdTunnelIpv4SrcMasked{
18742 OxmId: NewOxmId(81672),
18743 }
18744 return obj
18745}
18746func (self *OxmIdTunnelIpv4SrcMasked) GetOXMName() string {
18747 return "tunnel_ipv4_src_masked"
18748}
18749
18750func (self *OxmIdTunnelIpv4SrcMasked) MarshalJSON() ([]byte, error) {
18751 if self.TypeLen == 0 {
18752 return []byte("\"\""), nil
18753 } else {
18754 return []byte("\"" + self.GetOXMName() + "\""), nil
18755 }
18756}
18757
18758type OxmIdVlanPcp struct {
18759 *OxmId
18760}
18761
18762type IOxmIdVlanPcp interface {
18763 IOxmId
18764}
18765
18766func (self *OxmIdVlanPcp) Serialize(encoder *goloxi.Encoder) error {
18767 if err := self.OxmId.Serialize(encoder); err != nil {
18768 return err
18769 }
18770
18771 return nil
18772}
18773
18774func DecodeOxmIdVlanPcp(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanPcp, error) {
18775 _oxmidvlanpcp := &OxmIdVlanPcp{OxmId: parent}
18776 return _oxmidvlanpcp, nil
18777}
18778
18779func NewOxmIdVlanPcp() *OxmIdVlanPcp {
18780 obj := &OxmIdVlanPcp{
18781 OxmId: NewOxmId(2147487233),
18782 }
18783 return obj
18784}
18785func (self *OxmIdVlanPcp) GetOXMName() string {
18786 return "vlan_pcp"
18787}
18788
18789func (self *OxmIdVlanPcp) MarshalJSON() ([]byte, error) {
18790 if self.TypeLen == 0 {
18791 return []byte("\"\""), nil
18792 } else {
18793 return []byte("\"" + self.GetOXMName() + "\""), nil
18794 }
18795}
18796
18797type OxmIdVlanPcpMasked struct {
18798 *OxmId
18799}
18800
18801type IOxmIdVlanPcpMasked interface {
18802 IOxmId
18803}
18804
18805func (self *OxmIdVlanPcpMasked) Serialize(encoder *goloxi.Encoder) error {
18806 if err := self.OxmId.Serialize(encoder); err != nil {
18807 return err
18808 }
18809
18810 return nil
18811}
18812
18813func DecodeOxmIdVlanPcpMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanPcpMasked, error) {
18814 _oxmidvlanpcpmasked := &OxmIdVlanPcpMasked{OxmId: parent}
18815 return _oxmidvlanpcpmasked, nil
18816}
18817
18818func NewOxmIdVlanPcpMasked() *OxmIdVlanPcpMasked {
18819 obj := &OxmIdVlanPcpMasked{
18820 OxmId: NewOxmId(2147487490),
18821 }
18822 return obj
18823}
18824func (self *OxmIdVlanPcpMasked) GetOXMName() string {
18825 return "vlan_pcp_masked"
18826}
18827
18828func (self *OxmIdVlanPcpMasked) MarshalJSON() ([]byte, error) {
18829 if self.TypeLen == 0 {
18830 return []byte("\"\""), nil
18831 } else {
18832 return []byte("\"" + self.GetOXMName() + "\""), nil
18833 }
18834}
18835
18836type OxmIdVlanVid struct {
18837 *OxmId
18838}
18839
18840type IOxmIdVlanVid interface {
18841 IOxmId
18842}
18843
18844func (self *OxmIdVlanVid) Serialize(encoder *goloxi.Encoder) error {
18845 if err := self.OxmId.Serialize(encoder); err != nil {
18846 return err
18847 }
18848
18849 return nil
18850}
18851
18852func DecodeOxmIdVlanVid(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanVid, error) {
18853 _oxmidvlanvid := &OxmIdVlanVid{OxmId: parent}
18854 return _oxmidvlanvid, nil
18855}
18856
18857func NewOxmIdVlanVid() *OxmIdVlanVid {
18858 obj := &OxmIdVlanVid{
18859 OxmId: NewOxmId(2147486722),
18860 }
18861 return obj
18862}
18863func (self *OxmIdVlanVid) GetOXMName() string {
18864 return "vlan_vid"
18865}
18866
18867func (self *OxmIdVlanVid) MarshalJSON() ([]byte, error) {
18868 if self.TypeLen == 0 {
18869 return []byte("\"\""), nil
18870 } else {
18871 return []byte("\"" + self.GetOXMName() + "\""), nil
18872 }
18873}
18874
18875type OxmIdVlanVidMasked struct {
18876 *OxmId
18877}
18878
18879type IOxmIdVlanVidMasked interface {
18880 IOxmId
18881}
18882
18883func (self *OxmIdVlanVidMasked) Serialize(encoder *goloxi.Encoder) error {
18884 if err := self.OxmId.Serialize(encoder); err != nil {
18885 return err
18886 }
18887
18888 return nil
18889}
18890
18891func DecodeOxmIdVlanVidMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanVidMasked, error) {
18892 _oxmidvlanvidmasked := &OxmIdVlanVidMasked{OxmId: parent}
18893 return _oxmidvlanvidmasked, nil
18894}
18895
18896func NewOxmIdVlanVidMasked() *OxmIdVlanVidMasked {
18897 obj := &OxmIdVlanVidMasked{
18898 OxmId: NewOxmId(2147486980),
18899 }
18900 return obj
18901}
18902func (self *OxmIdVlanVidMasked) GetOXMName() string {
18903 return "vlan_vid_masked"
18904}
18905
18906func (self *OxmIdVlanVidMasked) MarshalJSON() ([]byte, error) {
18907 if self.TypeLen == 0 {
18908 return []byte("\"\""), nil
18909 } else {
18910 return []byte("\"" + self.GetOXMName() + "\""), nil
18911 }
18912}
18913
18914type PacketQueue struct {
18915 QueueId uint32
18916 Port Port
18917 Len uint16
18918 Properties []IQueueProp
18919}
18920
18921type IPacketQueue interface {
18922 goloxi.Serializable
18923 GetQueueId() uint32
18924 GetPort() Port
18925 GetLen() uint16
18926 GetProperties() []IQueueProp
18927}
18928
18929func (self *PacketQueue) GetQueueId() uint32 {
18930 return self.QueueId
18931}
18932
18933func (self *PacketQueue) SetQueueId(v uint32) {
18934 self.QueueId = v
18935}
18936
18937func (self *PacketQueue) GetPort() Port {
18938 return self.Port
18939}
18940
18941func (self *PacketQueue) SetPort(v Port) {
18942 self.Port = v
18943}
18944
18945func (self *PacketQueue) GetLen() uint16 {
18946 return self.Len
18947}
18948
18949func (self *PacketQueue) SetLen(v uint16) {
18950 self.Len = v
18951}
18952
18953func (self *PacketQueue) GetProperties() []IQueueProp {
18954 return self.Properties
18955}
18956
18957func (self *PacketQueue) SetProperties(v []IQueueProp) {
18958 self.Properties = v
18959}
18960
18961func (self *PacketQueue) Serialize(encoder *goloxi.Encoder) error {
18962 startIndex := len(encoder.Bytes())
18963
18964 encoder.PutUint32(uint32(self.QueueId))
18965 self.Port.Serialize(encoder)
18966 encoder.PutUint16(uint16(self.Len))
18967 encoder.Write(bytes.Repeat([]byte{0}, 6))
18968 for _, obj := range self.Properties {
18969 if err := obj.Serialize(encoder); err != nil {
18970 return err
18971 }
18972 }
18973 length := len(encoder.Bytes()) - startIndex
18974
18975 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+8:startIndex+10], uint16(length))
18976
18977 return nil
18978}
18979
18980func DecodePacketQueue(decoder *goloxi.Decoder) (*PacketQueue, error) {
18981 _packetqueue := &PacketQueue{}
18982 if decoder.Length() < 16 {
18983 return nil, fmt.Errorf("PacketQueue packet too short: %d < 16", decoder.Length())
18984 }
18985 _packetqueue.QueueId = uint32(decoder.ReadUint32())
18986 _packetqueue.Port.Decode(decoder)
18987 _packetqueue.Len = uint16(decoder.ReadUint16())
18988 oldDecoder := decoder
18989 defer func() { decoder = oldDecoder }()
18990 decoder = decoder.SliceDecoder(int(_packetqueue.Len), 2+8)
18991 decoder.Skip(6)
18992
18993 for decoder.Length() >= 8 {
18994 item, err := DecodeQueueProp(decoder)
18995 if err != nil {
18996 return nil, err
18997 }
18998 if item != nil {
18999 _packetqueue.Properties = append(_packetqueue.Properties, item)
19000 }
19001 }
19002 return _packetqueue, nil
19003}
19004
19005func NewPacketQueue() *PacketQueue {
19006 obj := &PacketQueue{}
19007 return obj
19008}
19009
19010type PortDesc struct {
19011 PortNo Port
19012 HwAddr net.HardwareAddr
19013 Name string
19014 Config PortConfig
19015 State PortState
19016 Curr PortFeatures
19017 Advertised PortFeatures
19018 Supported PortFeatures
19019 Peer PortFeatures
19020 CurrSpeed uint32
19021 MaxSpeed uint32
19022}
19023
19024type IPortDesc interface {
19025 goloxi.Serializable
19026 GetPortNo() Port
19027 GetHwAddr() net.HardwareAddr
19028 GetName() string
19029 GetConfig() PortConfig
19030 GetState() PortState
19031 GetCurr() PortFeatures
19032 GetAdvertised() PortFeatures
19033 GetSupported() PortFeatures
19034 GetPeer() PortFeatures
19035 GetCurrSpeed() uint32
19036 GetMaxSpeed() uint32
19037}
19038
19039func (self *PortDesc) GetPortNo() Port {
19040 return self.PortNo
19041}
19042
19043func (self *PortDesc) SetPortNo(v Port) {
19044 self.PortNo = v
19045}
19046
19047func (self *PortDesc) GetHwAddr() net.HardwareAddr {
19048 return self.HwAddr
19049}
19050
19051func (self *PortDesc) SetHwAddr(v net.HardwareAddr) {
19052 self.HwAddr = v
19053}
19054
19055func (self *PortDesc) GetName() string {
19056 return self.Name
19057}
19058
19059func (self *PortDesc) SetName(v string) {
19060 self.Name = v
19061}
19062
19063func (self *PortDesc) GetConfig() PortConfig {
19064 return self.Config
19065}
19066
19067func (self *PortDesc) SetConfig(v PortConfig) {
19068 self.Config = v
19069}
19070
19071func (self *PortDesc) GetState() PortState {
19072 return self.State
19073}
19074
19075func (self *PortDesc) SetState(v PortState) {
19076 self.State = v
19077}
19078
19079func (self *PortDesc) GetCurr() PortFeatures {
19080 return self.Curr
19081}
19082
19083func (self *PortDesc) SetCurr(v PortFeatures) {
19084 self.Curr = v
19085}
19086
19087func (self *PortDesc) GetAdvertised() PortFeatures {
19088 return self.Advertised
19089}
19090
19091func (self *PortDesc) SetAdvertised(v PortFeatures) {
19092 self.Advertised = v
19093}
19094
19095func (self *PortDesc) GetSupported() PortFeatures {
19096 return self.Supported
19097}
19098
19099func (self *PortDesc) SetSupported(v PortFeatures) {
19100 self.Supported = v
19101}
19102
19103func (self *PortDesc) GetPeer() PortFeatures {
19104 return self.Peer
19105}
19106
19107func (self *PortDesc) SetPeer(v PortFeatures) {
19108 self.Peer = v
19109}
19110
19111func (self *PortDesc) GetCurrSpeed() uint32 {
19112 return self.CurrSpeed
19113}
19114
19115func (self *PortDesc) SetCurrSpeed(v uint32) {
19116 self.CurrSpeed = v
19117}
19118
19119func (self *PortDesc) GetMaxSpeed() uint32 {
19120 return self.MaxSpeed
19121}
19122
19123func (self *PortDesc) SetMaxSpeed(v uint32) {
19124 self.MaxSpeed = v
19125}
19126
19127func (self *PortDesc) Serialize(encoder *goloxi.Encoder) error {
19128
19129 self.PortNo.Serialize(encoder)
19130 encoder.Write(bytes.Repeat([]byte{0}, 4))
19131 encoder.Write(self.HwAddr)
19132 encoder.Write(bytes.Repeat([]byte{0}, 2))
19133 encoder.Write([]byte(self.Name))
19134 encoder.PutUint32(uint32(self.Config))
19135 encoder.PutUint32(uint32(self.State))
19136 encoder.PutUint32(uint32(self.Curr))
19137 encoder.PutUint32(uint32(self.Advertised))
19138 encoder.PutUint32(uint32(self.Supported))
19139 encoder.PutUint32(uint32(self.Peer))
19140 encoder.PutUint32(uint32(self.CurrSpeed))
19141 encoder.PutUint32(uint32(self.MaxSpeed))
19142
19143 return nil
19144}
19145func (self *PortDesc) Decode(decoder *goloxi.Decoder) error {
19146 if decoder.Length() < 64 {
19147 return fmt.Errorf("PortDesc packet too short: %d < 64", decoder.Length())
19148 }
19149
19150 self.PortNo.Decode(decoder)
19151 decoder.Skip(4)
19152 self.HwAddr = net.HardwareAddr(decoder.Read(6))
19153 decoder.Skip(2)
19154 self.Name = string(bytes.Trim(decoder.Read(16), "\x00"))
19155 self.Config = PortConfig(decoder.ReadUint32())
19156 self.State = PortState(decoder.ReadUint32())
19157 self.Curr = PortFeatures(decoder.ReadUint32())
19158 self.Advertised = PortFeatures(decoder.ReadUint32())
19159 self.Supported = PortFeatures(decoder.ReadUint32())
19160 self.Peer = PortFeatures(decoder.ReadUint32())
19161 self.CurrSpeed = uint32(decoder.ReadUint32())
19162 self.MaxSpeed = uint32(decoder.ReadUint32())
19163
19164 return nil
19165}
19166
19167func NewPortDesc() *PortDesc {
19168 obj := &PortDesc{}
19169 return obj
19170}
19171
19172type PortStatsEntry struct {
19173 PortNo Port
19174 RxPackets uint64
19175 TxPackets uint64
19176 RxBytes uint64
19177 TxBytes uint64
19178 RxDropped uint64
19179 TxDropped uint64
19180 RxErrors uint64
19181 TxErrors uint64
19182 RxFrameErr uint64
19183 RxOverErr uint64
19184 RxCrcErr uint64
19185 Collisions uint64
19186}
19187
19188type IPortStatsEntry interface {
19189 goloxi.Serializable
19190 GetPortNo() Port
19191 GetRxPackets() uint64
19192 GetTxPackets() uint64
19193 GetRxBytes() uint64
19194 GetTxBytes() uint64
19195 GetRxDropped() uint64
19196 GetTxDropped() uint64
19197 GetRxErrors() uint64
19198 GetTxErrors() uint64
19199 GetRxFrameErr() uint64
19200 GetRxOverErr() uint64
19201 GetRxCrcErr() uint64
19202 GetCollisions() uint64
19203}
19204
19205func (self *PortStatsEntry) GetPortNo() Port {
19206 return self.PortNo
19207}
19208
19209func (self *PortStatsEntry) SetPortNo(v Port) {
19210 self.PortNo = v
19211}
19212
19213func (self *PortStatsEntry) GetRxPackets() uint64 {
19214 return self.RxPackets
19215}
19216
19217func (self *PortStatsEntry) SetRxPackets(v uint64) {
19218 self.RxPackets = v
19219}
19220
19221func (self *PortStatsEntry) GetTxPackets() uint64 {
19222 return self.TxPackets
19223}
19224
19225func (self *PortStatsEntry) SetTxPackets(v uint64) {
19226 self.TxPackets = v
19227}
19228
19229func (self *PortStatsEntry) GetRxBytes() uint64 {
19230 return self.RxBytes
19231}
19232
19233func (self *PortStatsEntry) SetRxBytes(v uint64) {
19234 self.RxBytes = v
19235}
19236
19237func (self *PortStatsEntry) GetTxBytes() uint64 {
19238 return self.TxBytes
19239}
19240
19241func (self *PortStatsEntry) SetTxBytes(v uint64) {
19242 self.TxBytes = v
19243}
19244
19245func (self *PortStatsEntry) GetRxDropped() uint64 {
19246 return self.RxDropped
19247}
19248
19249func (self *PortStatsEntry) SetRxDropped(v uint64) {
19250 self.RxDropped = v
19251}
19252
19253func (self *PortStatsEntry) GetTxDropped() uint64 {
19254 return self.TxDropped
19255}
19256
19257func (self *PortStatsEntry) SetTxDropped(v uint64) {
19258 self.TxDropped = v
19259}
19260
19261func (self *PortStatsEntry) GetRxErrors() uint64 {
19262 return self.RxErrors
19263}
19264
19265func (self *PortStatsEntry) SetRxErrors(v uint64) {
19266 self.RxErrors = v
19267}
19268
19269func (self *PortStatsEntry) GetTxErrors() uint64 {
19270 return self.TxErrors
19271}
19272
19273func (self *PortStatsEntry) SetTxErrors(v uint64) {
19274 self.TxErrors = v
19275}
19276
19277func (self *PortStatsEntry) GetRxFrameErr() uint64 {
19278 return self.RxFrameErr
19279}
19280
19281func (self *PortStatsEntry) SetRxFrameErr(v uint64) {
19282 self.RxFrameErr = v
19283}
19284
19285func (self *PortStatsEntry) GetRxOverErr() uint64 {
19286 return self.RxOverErr
19287}
19288
19289func (self *PortStatsEntry) SetRxOverErr(v uint64) {
19290 self.RxOverErr = v
19291}
19292
19293func (self *PortStatsEntry) GetRxCrcErr() uint64 {
19294 return self.RxCrcErr
19295}
19296
19297func (self *PortStatsEntry) SetRxCrcErr(v uint64) {
19298 self.RxCrcErr = v
19299}
19300
19301func (self *PortStatsEntry) GetCollisions() uint64 {
19302 return self.Collisions
19303}
19304
19305func (self *PortStatsEntry) SetCollisions(v uint64) {
19306 self.Collisions = v
19307}
19308
19309func (self *PortStatsEntry) Serialize(encoder *goloxi.Encoder) error {
19310
19311 self.PortNo.Serialize(encoder)
19312 encoder.Write(bytes.Repeat([]byte{0}, 4))
19313 encoder.PutUint64(uint64(self.RxPackets))
19314 encoder.PutUint64(uint64(self.TxPackets))
19315 encoder.PutUint64(uint64(self.RxBytes))
19316 encoder.PutUint64(uint64(self.TxBytes))
19317 encoder.PutUint64(uint64(self.RxDropped))
19318 encoder.PutUint64(uint64(self.TxDropped))
19319 encoder.PutUint64(uint64(self.RxErrors))
19320 encoder.PutUint64(uint64(self.TxErrors))
19321 encoder.PutUint64(uint64(self.RxFrameErr))
19322 encoder.PutUint64(uint64(self.RxOverErr))
19323 encoder.PutUint64(uint64(self.RxCrcErr))
19324 encoder.PutUint64(uint64(self.Collisions))
19325
19326 return nil
19327}
19328
19329func DecodePortStatsEntry(decoder *goloxi.Decoder) (*PortStatsEntry, error) {
19330 _portstatsentry := &PortStatsEntry{}
19331 if decoder.Length() < 104 {
19332 return nil, fmt.Errorf("PortStatsEntry packet too short: %d < 104", decoder.Length())
19333 }
19334 _portstatsentry.PortNo.Decode(decoder)
19335 decoder.Skip(4)
19336 _portstatsentry.RxPackets = uint64(decoder.ReadUint64())
19337 _portstatsentry.TxPackets = uint64(decoder.ReadUint64())
19338 _portstatsentry.RxBytes = uint64(decoder.ReadUint64())
19339 _portstatsentry.TxBytes = uint64(decoder.ReadUint64())
19340 _portstatsentry.RxDropped = uint64(decoder.ReadUint64())
19341 _portstatsentry.TxDropped = uint64(decoder.ReadUint64())
19342 _portstatsentry.RxErrors = uint64(decoder.ReadUint64())
19343 _portstatsentry.TxErrors = uint64(decoder.ReadUint64())
19344 _portstatsentry.RxFrameErr = uint64(decoder.ReadUint64())
19345 _portstatsentry.RxOverErr = uint64(decoder.ReadUint64())
19346 _portstatsentry.RxCrcErr = uint64(decoder.ReadUint64())
19347 _portstatsentry.Collisions = uint64(decoder.ReadUint64())
19348 return _portstatsentry, nil
19349}
19350
19351func NewPortStatsEntry() *PortStatsEntry {
19352 obj := &PortStatsEntry{}
19353 return obj
19354}
19355
19356type QueueProp struct {
19357 Type uint16
19358 Len uint16
19359}
19360
19361type IQueueProp interface {
19362 goloxi.Serializable
19363 GetType() uint16
19364 GetLen() uint16
19365}
19366
19367func (self *QueueProp) GetType() uint16 {
19368 return self.Type
19369}
19370
19371func (self *QueueProp) SetType(v uint16) {
19372 self.Type = v
19373}
19374
19375func (self *QueueProp) GetLen() uint16 {
19376 return self.Len
19377}
19378
19379func (self *QueueProp) SetLen(v uint16) {
19380 self.Len = v
19381}
19382
19383func (self *QueueProp) Serialize(encoder *goloxi.Encoder) error {
19384
19385 encoder.PutUint16(uint16(self.Type))
19386 encoder.PutUint16(uint16(self.Len))
19387
19388 return nil
19389}
19390
19391func DecodeQueueProp(decoder *goloxi.Decoder) (IQueueProp, error) {
19392 _queueprop := &QueueProp{}
19393 if decoder.Length() < 4 {
19394 return nil, fmt.Errorf("QueueProp packet too short: %d < 4", decoder.Length())
19395 }
19396 _queueprop.Type = uint16(decoder.ReadUint16())
19397 _queueprop.Len = uint16(decoder.ReadUint16())
19398 oldDecoder := decoder
19399 defer func() { decoder = oldDecoder }()
19400 decoder = decoder.SliceDecoder(int(_queueprop.Len), 2+2)
19401
19402 switch _queueprop.Type {
19403 case 1:
19404 return DecodeQueuePropMinRate(_queueprop, decoder)
19405 case 2:
19406 return DecodeQueuePropMaxRate(_queueprop, decoder)
19407 case 65535:
19408 return DecodeQueuePropExperimenter(_queueprop, decoder)
19409 default:
19410 return nil, fmt.Errorf("Invalid type '%d' for 'QueueProp'", _queueprop.Type)
19411 }
19412}
19413
19414func NewQueueProp(_type uint16) *QueueProp {
19415 obj := &QueueProp{}
19416 obj.Type = _type
19417 return obj
19418}
19419
19420type QueuePropExperimenter struct {
19421 *QueueProp
19422 Experimenter uint32
19423}
19424
19425type IQueuePropExperimenter interface {
19426 IQueueProp
19427 GetExperimenter() uint32
19428}
19429
19430func (self *QueuePropExperimenter) GetExperimenter() uint32 {
19431 return self.Experimenter
19432}
19433
19434func (self *QueuePropExperimenter) SetExperimenter(v uint32) {
19435 self.Experimenter = v
19436}
19437
19438func (self *QueuePropExperimenter) Serialize(encoder *goloxi.Encoder) error {
19439 if err := self.QueueProp.Serialize(encoder); err != nil {
19440 return err
19441 }
19442
19443 encoder.Write(bytes.Repeat([]byte{0}, 4))
19444 encoder.PutUint32(uint32(self.Experimenter))
19445 encoder.Write(bytes.Repeat([]byte{0}, 4))
19446
19447 return nil
19448}
19449
19450func DecodeQueuePropExperimenter(parent *QueueProp, decoder *goloxi.Decoder) (IQueuePropExperimenter, error) {
19451 _queuepropexperimenter := &QueuePropExperimenter{QueueProp: parent}
19452 if decoder.Length() < 4 {
19453 return nil, fmt.Errorf("QueuePropExperimenter packet too short: %d < 4", decoder.Length())
19454 }
19455 decoder.Skip(4)
19456 _queuepropexperimenter.Experimenter = uint32(decoder.ReadUint32())
19457 decoder.Skip(4)
19458 return _queuepropexperimenter, nil
19459}
19460
19461func NewQueuePropExperimenter(_experimenter uint32) *QueuePropExperimenter {
19462 obj := &QueuePropExperimenter{
19463 QueueProp: NewQueueProp(65535),
19464 }
19465 obj.Experimenter = _experimenter
19466 return obj
19467}
19468
19469type QueuePropMaxRate struct {
19470 *QueueProp
19471 Rate uint16
19472}
19473
19474type IQueuePropMaxRate interface {
19475 IQueueProp
19476 GetRate() uint16
19477}
19478
19479func (self *QueuePropMaxRate) GetRate() uint16 {
19480 return self.Rate
19481}
19482
19483func (self *QueuePropMaxRate) SetRate(v uint16) {
19484 self.Rate = v
19485}
19486
19487func (self *QueuePropMaxRate) Serialize(encoder *goloxi.Encoder) error {
19488 startIndex := len(encoder.Bytes())
19489 if err := self.QueueProp.Serialize(encoder); err != nil {
19490 return err
19491 }
19492
19493 encoder.Write(bytes.Repeat([]byte{0}, 4))
19494 encoder.PutUint16(uint16(self.Rate))
19495 encoder.Write(bytes.Repeat([]byte{0}, 6))
19496 length := len(encoder.Bytes()) - startIndex
19497
19498 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
19499
19500 return nil
19501}
19502
19503func DecodeQueuePropMaxRate(parent *QueueProp, decoder *goloxi.Decoder) (*QueuePropMaxRate, error) {
19504 _queuepropmaxrate := &QueuePropMaxRate{QueueProp: parent}
19505 if decoder.Length() < 12 {
19506 return nil, fmt.Errorf("QueuePropMaxRate packet too short: %d < 12", decoder.Length())
19507 }
19508 decoder.Skip(4)
19509 _queuepropmaxrate.Rate = uint16(decoder.ReadUint16())
19510 decoder.Skip(6)
19511 return _queuepropmaxrate, nil
19512}
19513
19514func NewQueuePropMaxRate() *QueuePropMaxRate {
19515 obj := &QueuePropMaxRate{
19516 QueueProp: NewQueueProp(2),
19517 }
19518 return obj
19519}
19520
19521type QueuePropMinRate struct {
19522 *QueueProp
19523 Rate uint16
19524}
19525
19526type IQueuePropMinRate interface {
19527 IQueueProp
19528 GetRate() uint16
19529}
19530
19531func (self *QueuePropMinRate) GetRate() uint16 {
19532 return self.Rate
19533}
19534
19535func (self *QueuePropMinRate) SetRate(v uint16) {
19536 self.Rate = v
19537}
19538
19539func (self *QueuePropMinRate) Serialize(encoder *goloxi.Encoder) error {
19540 startIndex := len(encoder.Bytes())
19541 if err := self.QueueProp.Serialize(encoder); err != nil {
19542 return err
19543 }
19544
19545 encoder.Write(bytes.Repeat([]byte{0}, 4))
19546 encoder.PutUint16(uint16(self.Rate))
19547 encoder.Write(bytes.Repeat([]byte{0}, 6))
19548 length := len(encoder.Bytes()) - startIndex
19549
19550 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
19551
19552 return nil
19553}
19554
19555func DecodeQueuePropMinRate(parent *QueueProp, decoder *goloxi.Decoder) (*QueuePropMinRate, error) {
19556 _queuepropminrate := &QueuePropMinRate{QueueProp: parent}
19557 if decoder.Length() < 12 {
19558 return nil, fmt.Errorf("QueuePropMinRate packet too short: %d < 12", decoder.Length())
19559 }
19560 decoder.Skip(4)
19561 _queuepropminrate.Rate = uint16(decoder.ReadUint16())
19562 decoder.Skip(6)
19563 return _queuepropminrate, nil
19564}
19565
19566func NewQueuePropMinRate() *QueuePropMinRate {
19567 obj := &QueuePropMinRate{
19568 QueueProp: NewQueueProp(1),
19569 }
19570 return obj
19571}
19572
19573type QueueStatsEntry struct {
19574 PortNo Port
19575 QueueId uint32
19576 TxBytes uint64
19577 TxPackets uint64
19578 TxErrors uint64
19579}
19580
19581type IQueueStatsEntry interface {
19582 goloxi.Serializable
19583 GetPortNo() Port
19584 GetQueueId() uint32
19585 GetTxBytes() uint64
19586 GetTxPackets() uint64
19587 GetTxErrors() uint64
19588}
19589
19590func (self *QueueStatsEntry) GetPortNo() Port {
19591 return self.PortNo
19592}
19593
19594func (self *QueueStatsEntry) SetPortNo(v Port) {
19595 self.PortNo = v
19596}
19597
19598func (self *QueueStatsEntry) GetQueueId() uint32 {
19599 return self.QueueId
19600}
19601
19602func (self *QueueStatsEntry) SetQueueId(v uint32) {
19603 self.QueueId = v
19604}
19605
19606func (self *QueueStatsEntry) GetTxBytes() uint64 {
19607 return self.TxBytes
19608}
19609
19610func (self *QueueStatsEntry) SetTxBytes(v uint64) {
19611 self.TxBytes = v
19612}
19613
19614func (self *QueueStatsEntry) GetTxPackets() uint64 {
19615 return self.TxPackets
19616}
19617
19618func (self *QueueStatsEntry) SetTxPackets(v uint64) {
19619 self.TxPackets = v
19620}
19621
19622func (self *QueueStatsEntry) GetTxErrors() uint64 {
19623 return self.TxErrors
19624}
19625
19626func (self *QueueStatsEntry) SetTxErrors(v uint64) {
19627 self.TxErrors = v
19628}
19629
19630func (self *QueueStatsEntry) Serialize(encoder *goloxi.Encoder) error {
19631
19632 self.PortNo.Serialize(encoder)
19633 encoder.PutUint32(uint32(self.QueueId))
19634 encoder.PutUint64(uint64(self.TxBytes))
19635 encoder.PutUint64(uint64(self.TxPackets))
19636 encoder.PutUint64(uint64(self.TxErrors))
19637
19638 return nil
19639}
19640
19641func DecodeQueueStatsEntry(decoder *goloxi.Decoder) (*QueueStatsEntry, error) {
19642 _queuestatsentry := &QueueStatsEntry{}
19643 if decoder.Length() < 32 {
19644 return nil, fmt.Errorf("QueueStatsEntry packet too short: %d < 32", decoder.Length())
19645 }
19646 _queuestatsentry.PortNo.Decode(decoder)
19647 _queuestatsentry.QueueId = uint32(decoder.ReadUint32())
19648 _queuestatsentry.TxBytes = uint64(decoder.ReadUint64())
19649 _queuestatsentry.TxPackets = uint64(decoder.ReadUint64())
19650 _queuestatsentry.TxErrors = uint64(decoder.ReadUint64())
19651 return _queuestatsentry, nil
19652}
19653
19654func NewQueueStatsEntry() *QueueStatsEntry {
19655 obj := &QueueStatsEntry{}
19656 return obj
19657}
19658
19659type TableStatsEntry struct {
19660 TableId uint8
19661 Name string
19662 Match MatchBmap
19663 Wildcards WcBmap
19664 WriteActions uint32
19665 ApplyActions uint32
19666 WriteSetfields uint64
19667 ApplySetfields uint64
19668 MetadataMatch uint64
19669 MetadataWrite uint64
19670 Instructions uint32
19671 Config uint32
19672 MaxEntries uint32
19673 ActiveCount uint32
19674 LookupCount uint64
19675 MatchedCount uint64
19676}
19677
19678type ITableStatsEntry interface {
19679 goloxi.Serializable
19680 GetTableId() uint8
19681 GetName() string
19682 GetMatch() MatchBmap
19683 GetWildcards() WcBmap
19684 GetWriteActions() uint32
19685 GetApplyActions() uint32
19686 GetWriteSetfields() uint64
19687 GetApplySetfields() uint64
19688 GetMetadataMatch() uint64
19689 GetMetadataWrite() uint64
19690 GetInstructions() uint32
19691 GetConfig() uint32
19692 GetMaxEntries() uint32
19693 GetActiveCount() uint32
19694 GetLookupCount() uint64
19695 GetMatchedCount() uint64
19696}
19697
19698func (self *TableStatsEntry) GetTableId() uint8 {
19699 return self.TableId
19700}
19701
19702func (self *TableStatsEntry) SetTableId(v uint8) {
19703 self.TableId = v
19704}
19705
19706func (self *TableStatsEntry) GetName() string {
19707 return self.Name
19708}
19709
19710func (self *TableStatsEntry) SetName(v string) {
19711 self.Name = v
19712}
19713
19714func (self *TableStatsEntry) GetMatch() MatchBmap {
19715 return self.Match
19716}
19717
19718func (self *TableStatsEntry) SetMatch(v MatchBmap) {
19719 self.Match = v
19720}
19721
19722func (self *TableStatsEntry) GetWildcards() WcBmap {
19723 return self.Wildcards
19724}
19725
19726func (self *TableStatsEntry) SetWildcards(v WcBmap) {
19727 self.Wildcards = v
19728}
19729
19730func (self *TableStatsEntry) GetWriteActions() uint32 {
19731 return self.WriteActions
19732}
19733
19734func (self *TableStatsEntry) SetWriteActions(v uint32) {
19735 self.WriteActions = v
19736}
19737
19738func (self *TableStatsEntry) GetApplyActions() uint32 {
19739 return self.ApplyActions
19740}
19741
19742func (self *TableStatsEntry) SetApplyActions(v uint32) {
19743 self.ApplyActions = v
19744}
19745
19746func (self *TableStatsEntry) GetWriteSetfields() uint64 {
19747 return self.WriteSetfields
19748}
19749
19750func (self *TableStatsEntry) SetWriteSetfields(v uint64) {
19751 self.WriteSetfields = v
19752}
19753
19754func (self *TableStatsEntry) GetApplySetfields() uint64 {
19755 return self.ApplySetfields
19756}
19757
19758func (self *TableStatsEntry) SetApplySetfields(v uint64) {
19759 self.ApplySetfields = v
19760}
19761
19762func (self *TableStatsEntry) GetMetadataMatch() uint64 {
19763 return self.MetadataMatch
19764}
19765
19766func (self *TableStatsEntry) SetMetadataMatch(v uint64) {
19767 self.MetadataMatch = v
19768}
19769
19770func (self *TableStatsEntry) GetMetadataWrite() uint64 {
19771 return self.MetadataWrite
19772}
19773
19774func (self *TableStatsEntry) SetMetadataWrite(v uint64) {
19775 self.MetadataWrite = v
19776}
19777
19778func (self *TableStatsEntry) GetInstructions() uint32 {
19779 return self.Instructions
19780}
19781
19782func (self *TableStatsEntry) SetInstructions(v uint32) {
19783 self.Instructions = v
19784}
19785
19786func (self *TableStatsEntry) GetConfig() uint32 {
19787 return self.Config
19788}
19789
19790func (self *TableStatsEntry) SetConfig(v uint32) {
19791 self.Config = v
19792}
19793
19794func (self *TableStatsEntry) GetMaxEntries() uint32 {
19795 return self.MaxEntries
19796}
19797
19798func (self *TableStatsEntry) SetMaxEntries(v uint32) {
19799 self.MaxEntries = v
19800}
19801
19802func (self *TableStatsEntry) GetActiveCount() uint32 {
19803 return self.ActiveCount
19804}
19805
19806func (self *TableStatsEntry) SetActiveCount(v uint32) {
19807 self.ActiveCount = v
19808}
19809
19810func (self *TableStatsEntry) GetLookupCount() uint64 {
19811 return self.LookupCount
19812}
19813
19814func (self *TableStatsEntry) SetLookupCount(v uint64) {
19815 self.LookupCount = v
19816}
19817
19818func (self *TableStatsEntry) GetMatchedCount() uint64 {
19819 return self.MatchedCount
19820}
19821
19822func (self *TableStatsEntry) SetMatchedCount(v uint64) {
19823 self.MatchedCount = v
19824}
19825
19826func (self *TableStatsEntry) Serialize(encoder *goloxi.Encoder) error {
19827
19828 encoder.PutUint8(uint8(self.TableId))
19829 encoder.Write(bytes.Repeat([]byte{0}, 7))
19830 encoder.Write([]byte(self.Name))
19831 self.Match.Serialize(encoder)
19832 self.Wildcards.Serialize(encoder)
19833 encoder.PutUint32(uint32(self.WriteActions))
19834 encoder.PutUint32(uint32(self.ApplyActions))
19835 encoder.PutUint64(uint64(self.WriteSetfields))
19836 encoder.PutUint64(uint64(self.ApplySetfields))
19837 encoder.PutUint64(uint64(self.MetadataMatch))
19838 encoder.PutUint64(uint64(self.MetadataWrite))
19839 encoder.PutUint32(uint32(self.Instructions))
19840 encoder.PutUint32(uint32(self.Config))
19841 encoder.PutUint32(uint32(self.MaxEntries))
19842 encoder.PutUint32(uint32(self.ActiveCount))
19843 encoder.PutUint64(uint64(self.LookupCount))
19844 encoder.PutUint64(uint64(self.MatchedCount))
19845
19846 return nil
19847}
19848
19849func DecodeTableStatsEntry(decoder *goloxi.Decoder) (*TableStatsEntry, error) {
19850 _tablestatsentry := &TableStatsEntry{}
19851 if decoder.Length() < 128 {
19852 return nil, fmt.Errorf("TableStatsEntry packet too short: %d < 128", decoder.Length())
19853 }
19854 _tablestatsentry.TableId = uint8(decoder.ReadByte())
19855 decoder.Skip(7)
19856 _tablestatsentry.Name = string(bytes.Trim(decoder.Read(32), "\x00"))
19857 _tablestatsentry.Match.Decode(decoder)
19858 _tablestatsentry.Wildcards.Decode(decoder)
19859 _tablestatsentry.WriteActions = uint32(decoder.ReadUint32())
19860 _tablestatsentry.ApplyActions = uint32(decoder.ReadUint32())
19861 _tablestatsentry.WriteSetfields = uint64(decoder.ReadUint64())
19862 _tablestatsentry.ApplySetfields = uint64(decoder.ReadUint64())
19863 _tablestatsentry.MetadataMatch = uint64(decoder.ReadUint64())
19864 _tablestatsentry.MetadataWrite = uint64(decoder.ReadUint64())
19865 _tablestatsentry.Instructions = uint32(decoder.ReadUint32())
19866 _tablestatsentry.Config = uint32(decoder.ReadUint32())
19867 _tablestatsentry.MaxEntries = uint32(decoder.ReadUint32())
19868 _tablestatsentry.ActiveCount = uint32(decoder.ReadUint32())
19869 _tablestatsentry.LookupCount = uint64(decoder.ReadUint64())
19870 _tablestatsentry.MatchedCount = uint64(decoder.ReadUint64())
19871 return _tablestatsentry, nil
19872}
19873
19874func NewTableStatsEntry() *TableStatsEntry {
19875 obj := &TableStatsEntry{}
19876 return obj
19877}