Gitiles
Code Review Sign In
gerrit.opencord.org / goloxi / 4f3499b39cd8ca288932146f9b416a5372a81117 / . / of11 / common.go
blob: 7ee9e4ddf01d6f96bf716ab9c57f12903ad6191a [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 of11
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 126465:
55 return DecodeOxmIdConnTrackingNwProto(_oxmid, decoder)
56 case 7682:
57 return DecodeOxmIdArpOp(_oxmid, decoder)
58 case 2147500550:
59 return DecodeOxmIdIpv6NdTll(_oxmid, decoder)
60 case 84484:
61 return DecodeOxmIdConjId(_oxmid, decoder)
62 case 105976:
63 return DecodeOxmIdTunMetadata38Masked(_oxmid, decoder)
64 case 74246:
65 return DecodeOxmIdArpSha(_oxmid, decoder)
66 case 7169:
67 return DecodeOxmIdIcmpCode(_oxmid, decoder)
68 case 73736:
69 return DecodeOxmIdTunId(_oxmid, decoder)
70 case 2147484424:
71 return DecodeOxmIdInPhyPortMasked(_oxmid, decoder)
72 case 70408:
73 return DecodeOxmIdReg9Masked(_oxmid, decoder)
74 case 129026:
75 return DecodeOxmIdConnTrackingTpSrc(_oxmid, decoder)
76 case 127492:
77 return DecodeOxmIdConnTrackingNwDst(_oxmid, decoder)
78 case 2147484680:
79 return DecodeOxmIdMetadata(_oxmid, decoder)
80 case 128528:
81 return DecodeOxmIdConnTrackingIpv6Dst(_oxmid, decoder)
82 case 94332:
83 return DecodeOxmIdTunMetadata16(_oxmid, decoder)
84 case 129538:
85 return DecodeOxmIdConnTrackingTpDst(_oxmid, decoder)
86 case 108536:
87 return DecodeOxmIdTunMetadata43Masked(_oxmid, decoder)
88 case 106488:
89 return DecodeOxmIdTunMetadata39Masked(_oxmid, decoder)
90 case 112764:
91 return DecodeOxmIdTunMetadata52(_oxmid, decoder)
92 case 8708:
93 return DecodeOxmIdArpTpa(_oxmid, decoder)
94 case 2147498754:
95 return DecodeOxmIdIcmpv6TypeMasked(_oxmid, decoder)
96 case 89080:
97 return DecodeOxmIdTunMetadata5Masked(_oxmid, decoder)
98 case 94844:
99 return DecodeOxmIdTunMetadata17(_oxmid, decoder)
100 case 74758:
101 return DecodeOxmIdArpTha(_oxmid, decoder)
102 case 99964:
103 return DecodeOxmIdTunMetadata27(_oxmid, decoder)
104 case 67336:
105 return DecodeOxmIdReg3Masked(_oxmid, decoder)
106 case 115192:
107 return DecodeOxmIdTunMetadata56Masked(_oxmid, decoder)
108 case 71172:
109 return DecodeOxmIdReg11(_oxmid, decoder)
110 case 79364:
111 return DecodeOxmIdIpv6Label(_oxmid, decoder)
112 case 73480:
113 return DecodeOxmIdReg15Masked(_oxmid, decoder)
114 case 120068:
115 return DecodeOxmIdConnTrackingZoneMasked(_oxmid, decoder)
116 case 107512:
117 return DecodeOxmIdTunMetadata41Masked(_oxmid, decoder)
118 case 116348:
119 return DecodeOxmIdTunMetadata59(_oxmid, decoder)
120 case 89592:
121 return DecodeOxmIdTunMetadata6Masked(_oxmid, decoder)
122 case 110204:
123 return DecodeOxmIdTunMetadata47(_oxmid, decoder)
124 case 77830:
125 return DecodeOxmIdNdSll(_oxmid, decoder)
126 case 117372:
127 return DecodeOxmIdTunMetadata61(_oxmid, decoder)
128 case 2147489796:
129 return DecodeOxmIdIpv4Dst(_oxmid, decoder)
130 case 2147497988:
131 return DecodeOxmIdIpv6Flabel(_oxmid, decoder)
132 case 103928:
133 return DecodeOxmIdTunMetadata34Masked(_oxmid, decoder)
134 case 95868:
135 return DecodeOxmIdTunMetadata19(_oxmid, decoder)
136 case 2:
137 return DecodeOxmIdInPort(_oxmid, decoder)
138 case 74507:
139 return DecodeOxmIdArpShaMasked(_oxmid, decoder)
140 case 96892:
141 return DecodeOxmIdTunMetadata21(_oxmid, decoder)
142 case 108024:
143 return DecodeOxmIdTunMetadata42Masked(_oxmid, decoder)
144 case 129284:
145 return DecodeOxmIdConnTrackingTpSrcMasked(_oxmid, decoder)
146 case 112120:
147 return DecodeOxmIdTunMetadata50Masked(_oxmid, decoder)
148 case 2147484944:
149 return DecodeOxmIdMetadataMasked(_oxmid, decoder)
150 case 2147500812:
151 return DecodeOxmIdIpv6NdTllMasked(_oxmid, decoder)
152 case 78342:
153 return DecodeOxmIdNdTll(_oxmid, decoder)
154 case 2147486468:
155 return DecodeOxmIdEthTypeMasked(_oxmid, decoder)
156 case 96380:
157 return DecodeOxmIdTunMetadata20(_oxmid, decoder)
158 case 113276:
159 return DecodeOxmIdTunMetadata53(_oxmid, decoder)
160 case 92152:
161 return DecodeOxmIdTunMetadata11Masked(_oxmid, decoder)
162 case 129796:
163 return DecodeOxmIdConnTrackingTpDstMasked(_oxmid, decoder)
164 case 103548:
165 return DecodeOxmIdTunMetadata34(_oxmid, decoder)
166 case 120324:
167 return DecodeOxmIdConnTrackingMark(_oxmid, decoder)
168 case 118776:
169 return DecodeOxmIdTunMetadata63Masked(_oxmid, decoder)
170 case 90748:
171 return DecodeOxmIdTunMetadata9(_oxmid, decoder)
172 case 128016:
173 return DecodeOxmIdConnTrackingIpv6Src(_oxmid, decoder)
174 case 82946:
175 return DecodeOxmIdTcpFlags(_oxmid, decoder)
176 case 80897:
177 return DecodeOxmIdMplsTtl(_oxmid, decoder)
178 case 92664:
179 return DecodeOxmIdTunMetadata12Masked(_oxmid, decoder)
180 case 123408:
181 return DecodeOxmIdXxreg2(_oxmid, decoder)
182 case 2147499266:
183 return DecodeOxmIdIcmpv6CodeMasked(_oxmid, decoder)
184 case 2147489544:
185 return DecodeOxmIdIpv4SrcMasked(_oxmid, decoder)
186 case 2147487490:
187 return DecodeOxmIdVlanPcpMasked(_oxmid, decoder)
188 case 81412:
189 return DecodeOxmIdTunSrc(_oxmid, decoder)
190 case 5122:
191 return DecodeOxmIdTcpDst(_oxmid, decoder)
192 case 97404:
193 return DecodeOxmIdTunMetadata22(_oxmid, decoder)
194 case 1538:
195 return DecodeOxmIdEthType(_oxmid, decoder)
196 case 2561:
197 return DecodeOxmIdNwTos(_oxmid, decoder)
198 case 93176:
199 return DecodeOxmIdTunMetadata13Masked(_oxmid, decoder)
200 case 67848:
201 return DecodeOxmIdReg4Masked(_oxmid, decoder)
202 case 115704:
203 return DecodeOxmIdTunMetadata57Masked(_oxmid, decoder)
204 case 86140:
205 return DecodeOxmIdTunMetadata0(_oxmid, decoder)
206 case 65540:
207 return DecodeOxmIdReg0(_oxmid, decoder)
208 case 2147500038:
209 return DecodeOxmIdIpv6NdSll(_oxmid, decoder)
210 case 97916:
211 return DecodeOxmIdTunMetadata23(_oxmid, decoder)
212 case 2050:
213 return DecodeOxmIdVlanTci(_oxmid, decoder)
214 case 3073:
215 return DecodeOxmIdNwProto(_oxmid, decoder)
216 case 93688:
217 return DecodeOxmIdTunMetadata14Masked(_oxmid, decoder)
218 case 116860:
219 return DecodeOxmIdTunMetadata60(_oxmid, decoder)
220 case 2147487233:
221 return DecodeOxmIdVlanPcp(_oxmid, decoder)
222 case 2147484164:
223 return DecodeOxmIdInPhyPort(_oxmid, decoder)
224 case 2147486980:
225 return DecodeOxmIdVlanVidMasked(_oxmid, decoder)
226 case 113144:
227 return DecodeOxmIdTunMetadata52Masked(_oxmid, decoder)
228 case 82436:
229 return DecodeOxmIdPktMark(_oxmid, decoder)
230 case 121120:
231 return DecodeOxmIdConnTrackingLabelMasked(_oxmid, decoder)
232 case 98428:
233 return DecodeOxmIdTunMetadata24(_oxmid, decoder)
234 case 85505:
235 return DecodeOxmIdTunGbpFlags(_oxmid, decoder)
236 case 94200:
237 return DecodeOxmIdTunMetadata15Masked(_oxmid, decoder)
238 case 112632:
239 return DecodeOxmIdTunMetadata51Masked(_oxmid, decoder)
240 case 5378:
241 return DecodeOxmIdTcpDstMasked(_oxmid, decoder)
242 case 2147486722:
243 return DecodeOxmIdVlanVid(_oxmid, decoder)
244 case 66564:
245 return DecodeOxmIdReg2(_oxmid, decoder)
246 case 121632:
247 return DecodeOxmIdTunIpv6SrcMasked(_oxmid, decoder)
248 case 103416:
249 return DecodeOxmIdTunMetadata33Masked(_oxmid, decoder)
250 case 98940:
251 return DecodeOxmIdTunMetadata25(_oxmid, decoder)
252 case 84994:
253 return DecodeOxmIdTunGbpId(_oxmid, decoder)
254 case 2147487745:
255 return DecodeOxmIdIpDscp(_oxmid, decoder)
256 case 94712:
257 return DecodeOxmIdTunMetadata16Masked(_oxmid, decoder)
258 case 120848:
259 return DecodeOxmIdConnTrackingLabel(_oxmid, decoder)
260 case 109692:
261 return DecodeOxmIdTunMetadata46(_oxmid, decoder)
262 case 69896:
263 return DecodeOxmIdReg8Masked(_oxmid, decoder)
264 case 104060:
265 return DecodeOxmIdTunMetadata35(_oxmid, decoder)
266 case 71432:
267 return DecodeOxmIdReg11Masked(_oxmid, decoder)
268 case 110584:
269 return DecodeOxmIdTunMetadata47Masked(_oxmid, decoder)
270 case 79624:
271 return DecodeOxmIdIpv6LabelMasked(_oxmid, decoder)
272 case 122144:
273 return DecodeOxmIdTunIpv6DstMasked(_oxmid, decoder)
274 case 99452:
275 return DecodeOxmIdTunMetadata26(_oxmid, decoder)
276 case 109560:
277 return DecodeOxmIdTunMetadata45Masked(_oxmid, decoder)
278 case 95224:
279 return DecodeOxmIdTunMetadata17Masked(_oxmid, decoder)
280 case 121360:
281 return DecodeOxmIdTunIpv6Src(_oxmid, decoder)
282 case 85762:
283 return DecodeOxmIdTunGbpFlagsMasked(_oxmid, decoder)
284 case 2147490056:
285 return DecodeOxmIdIpv4DstMasked(_oxmid, decoder)
286 case 83972:
287 return DecodeOxmIdRecircId(_oxmid, decoder)
288 case 122656:
289 return DecodeOxmIdXxreg0Masked(_oxmid, decoder)
290 case 128800:
291 return DecodeOxmIdConnTrackingIpv6DstMasked(_oxmid, decoder)
292 case 118786:
293 return DecodeOxmIdTunFlags(_oxmid, decoder)
294 case 2147488769:
295 return DecodeOxmIdIpProto(_oxmid, decoder)
296 case 95736:
297 return DecodeOxmIdTunMetadata18Masked(_oxmid, decoder)
298 case 121872:
299 return DecodeOxmIdTunIpv6Dst(_oxmid, decoder)
300 case 81924:
301 return DecodeOxmIdTunDst(_oxmid, decoder)
302 case 68360:
303 return DecodeOxmIdReg5Masked(_oxmid, decoder)
304 case 518:
305 return DecodeOxmIdEthDst(_oxmid, decoder)
306 case 116216:
307 return DecodeOxmIdTunMetadata58Masked(_oxmid, decoder)
308 case 114300:
309 return DecodeOxmIdTunMetadata55(_oxmid, decoder)
310 case 68100:
311 return DecodeOxmIdReg5(_oxmid, decoder)
312 case 123168:
313 return DecodeOxmIdXxreg1Masked(_oxmid, decoder)
314 case 100476:
315 return DecodeOxmIdTunMetadata28(_oxmid, decoder)
316 case 4610:
317 return DecodeOxmIdTcpSrc(_oxmid, decoder)
318 case 123680:
319 return DecodeOxmIdXxreg2Masked(_oxmid, decoder)
320 case 96248:
321 return DecodeOxmIdTunMetadata19Masked(_oxmid, decoder)
322 case 122384:
323 return DecodeOxmIdXxreg0(_oxmid, decoder)
324 case 78091:
325 return DecodeOxmIdNdSllMasked(_oxmid, decoder)
326 case 1030:
327 return DecodeOxmIdEthSrc(_oxmid, decoder)
328 case 68612:
329 return DecodeOxmIdReg6(_oxmid, decoder)
330 case 107644:
331 return DecodeOxmIdTunMetadata42(_oxmid, decoder)
332 case 100988:
333 return DecodeOxmIdTunMetadata29(_oxmid, decoder)
334 case 119810:
335 return DecodeOxmIdConnTrackingZone(_oxmid, decoder)
336 case 96760:
337 return DecodeOxmIdTunMetadata20Masked(_oxmid, decoder)
338 case 85252:
339 return DecodeOxmIdTunGbpIdMasked(_oxmid, decoder)
340 case 78603:
341 return DecodeOxmIdNdTllMasked(_oxmid, decoder)
342 case 86652:
343 return DecodeOxmIdTunMetadata1(_oxmid, decoder)
344 case 69124:
345 return DecodeOxmIdReg7(_oxmid, decoder)
346 case 88188:
347 return DecodeOxmIdTunMetadata4(_oxmid, decoder)
348 case 3588:
349 return DecodeOxmIdIpSrc(_oxmid, decoder)
350 case 124192:
351 return DecodeOxmIdXxreg3Masked(_oxmid, decoder)
352 case 101500:
353 return DecodeOxmIdTunMetadata30(_oxmid, decoder)
354 case 5634:
355 return DecodeOxmIdUdpSrc(_oxmid, decoder)
356 case 127240:
357 return DecodeOxmIdConnTrackingNwSrcMasked(_oxmid, decoder)
358 case 6657:
359 return DecodeOxmIdIcmpType(_oxmid, decoder)
360 case 97272:
361 return DecodeOxmIdTunMetadata21Masked(_oxmid, decoder)
362 case 81672:
363 return DecodeOxmIdTunSrcMasked(_oxmid, decoder)
364 case 122896:
365 return DecodeOxmIdXxreg1(_oxmid, decoder)
366 case 2147489026:
367 return DecodeOxmIdIpProtoMasked(_oxmid, decoder)
368 case 2147483912:
369 return DecodeOxmIdInPortMasked(_oxmid, decoder)
370 case 4100:
371 return DecodeOxmIdIpDst(_oxmid, decoder)
372 case 65800:
373 return DecodeOxmIdReg0Masked(_oxmid, decoder)
374 case 75552:
375 return DecodeOxmIdIpv6SrcMasked(_oxmid, decoder)
376 case 102012:
377 return DecodeOxmIdTunMetadata31(_oxmid, decoder)
378 case 79106:
379 return DecodeOxmIdIpFragMasked(_oxmid, decoder)
380 case 2147501826:
381 return DecodeOxmIdMplsTcMasked(_oxmid, decoder)
382 case 8452:
383 return DecodeOxmIdArpSpaMasked(_oxmid, decoder)
384 case 97784:
385 return DecodeOxmIdTunMetadata22Masked(_oxmid, decoder)
386 case 1286:
387 return DecodeOxmIdEthSrcMasked(_oxmid, decoder)
388 case 66052:
389 return DecodeOxmIdReg1(_oxmid, decoder)
390 case 8968:
391 return DecodeOxmIdArpTpaMasked(_oxmid, decoder)
392 case 2147488514:
393 return DecodeOxmIdIpEcnMasked(_oxmid, decoder)
394 case 75019:
395 return DecodeOxmIdArpThaMasked(_oxmid, decoder)
396 case 2147500300:
397 return DecodeOxmIdIpv6NdSllMasked(_oxmid, decoder)
398 case 66312:
399 return DecodeOxmIdReg1Masked(_oxmid, decoder)
400 case 74000:
401 return DecodeOxmIdTunIdMasked(_oxmid, decoder)
402 case 102524:
403 return DecodeOxmIdTunMetadata32(_oxmid, decoder)
404 case 111228:
405 return DecodeOxmIdTunMetadata49(_oxmid, decoder)
406 case 88568:
407 return DecodeOxmIdTunMetadata4Masked(_oxmid, decoder)
408 case 2147499536:
409 return DecodeOxmIdIpv6NdTarget(_oxmid, decoder)
410 case 98296:
411 return DecodeOxmIdTunMetadata23Masked(_oxmid, decoder)
412 case 75280:
413 return DecodeOxmIdIpv6Src(_oxmid, decoder)
414 case 68872:
415 return DecodeOxmIdReg6Masked(_oxmid, decoder)
416 case 116728:
417 return DecodeOxmIdTunMetadata59Masked(_oxmid, decoder)
418 case 110072:
419 return DecodeOxmIdTunMetadata46Masked(_oxmid, decoder)
420 case 70660:
421 return DecodeOxmIdReg10(_oxmid, decoder)
422 case 76064:
423 return DecodeOxmIdIpv6DstMasked(_oxmid, decoder)
424 case 103036:
425 return DecodeOxmIdTunMetadata33(_oxmid, decoder)
426 case 107000:
427 return DecodeOxmIdTunMetadata40Masked(_oxmid, decoder)
428 case 110716:
429 return DecodeOxmIdTunMetadata48(_oxmid, decoder)
430 case 98808:
431 return DecodeOxmIdTunMetadata24Masked(_oxmid, decoder)
432 case 75792:
433 return DecodeOxmIdIpv6Dst(_oxmid, decoder)
434 case 2147501060:
435 return DecodeOxmIdMplsLabel(_oxmid, decoder)
436 case 73220:
437 return DecodeOxmIdReg15(_oxmid, decoder)
438 case 117884:
439 return DecodeOxmIdTunMetadata62(_oxmid, decoder)
440 case 83720:
441 return DecodeOxmIdDpHashMasked(_oxmid, decoder)
442 case 108156:
443 return DecodeOxmIdTunMetadata43(_oxmid, decoder)
444 case 87164:
445 return DecodeOxmIdTunMetadata2(_oxmid, decoder)
446 case 99320:
447 return DecodeOxmIdTunMetadata25Masked(_oxmid, decoder)
448 case 5892:
449 return DecodeOxmIdUdpSrcMasked(_oxmid, decoder)
450 case 113656:
451 return DecodeOxmIdTunMetadata53Masked(_oxmid, decoder)
452 case 69636:
453 return DecodeOxmIdReg8(_oxmid, decoder)
454 case 88700:
455 return DecodeOxmIdTunMetadata5(_oxmid, decoder)
456 case 113788:
457 return DecodeOxmIdTunMetadata54(_oxmid, decoder)
458 case 71684:
459 return DecodeOxmIdReg12(_oxmid, decoder)
460 case 77600:
461 return DecodeOxmIdNdTargetMasked(_oxmid, decoder)
462 case 87676:
463 return DecodeOxmIdTunMetadata3(_oxmid, decoder)
464 case 127752:
465 return DecodeOxmIdConnTrackingNwDstMasked(_oxmid, decoder)
466 case 99832:
467 return DecodeOxmIdTunMetadata26Masked(_oxmid, decoder)
468 case 114812:
469 return DecodeOxmIdTunMetadata56(_oxmid, decoder)
470 case 82184:
471 return DecodeOxmIdTunDstMasked(_oxmid, decoder)
472 case 90236:
473 return DecodeOxmIdTunMetadata8(_oxmid, decoder)
474 case 72196:
475 return DecodeOxmIdReg13(_oxmid, decoder)
476 case 104572:
477 return DecodeOxmIdTunMetadata36(_oxmid, decoder)
478 case 2147492354:
479 return DecodeOxmIdSctpSrc(_oxmid, decoder)
480 case 95356:
481 return DecodeOxmIdTunMetadata18(_oxmid, decoder)
482 case 2147493377:
483 return DecodeOxmIdIcmpv4Type(_oxmid, decoder)
484 case 100344:
485 return DecodeOxmIdTunMetadata27Masked(_oxmid, decoder)
486 case 77328:
487 return DecodeOxmIdNdTarget(_oxmid, decoder)
488 case 2147488257:
489 return DecodeOxmIdIpEcn(_oxmid, decoder)
490 case 118264:
491 return DecodeOxmIdTunMetadata62Masked(_oxmid, decoder)
492 case 90616:
493 return DecodeOxmIdTunMetadata8Masked(_oxmid, decoder)
494 case 72708:
495 return DecodeOxmIdReg14(_oxmid, decoder)
496 case 114680:
497 return DecodeOxmIdTunMetadata55Masked(_oxmid, decoder)
498 case 105084:
499 return DecodeOxmIdTunMetadata37(_oxmid, decoder)
500 case 91128:
501 return DecodeOxmIdTunMetadata9Masked(_oxmid, decoder)
502 case 111740:
503 return DecodeOxmIdTunMetadata50(_oxmid, decoder)
504 case 2147493889:
505 return DecodeOxmIdIcmpv4Code(_oxmid, decoder)
506 case 100856:
507 return DecodeOxmIdTunMetadata28Masked(_oxmid, decoder)
508 case 2308:
509 return DecodeOxmIdVlanTciMasked(_oxmid, decoder)
510 case 2147501320:
511 return DecodeOxmIdMplsLabelMasked(_oxmid, decoder)
512 case 779:
513 return DecodeOxmIdEthDstMasked(_oxmid, decoder)
514 case 2147493124:
515 return DecodeOxmIdSctpDstMasked(_oxmid, decoder)
516 case 69384:
517 return DecodeOxmIdReg7Masked(_oxmid, decoder)
518 case 117240:
519 return DecodeOxmIdTunMetadata60Masked(_oxmid, decoder)
520 case 3848:
521 return DecodeOxmIdIpSrcMasked(_oxmid, decoder)
522 case 128288:
523 return DecodeOxmIdConnTrackingIpv6SrcMasked(_oxmid, decoder)
524 case 92284:
525 return DecodeOxmIdTunMetadata12(_oxmid, decoder)
526 case 105596:
527 return DecodeOxmIdTunMetadata38(_oxmid, decoder)
528 case 4868:
529 return DecodeOxmIdTcpSrcMasked(_oxmid, decoder)
530 case 76289:
531 return DecodeOxmIdIcmpv6Type(_oxmid, decoder)
532 case 101368:
533 return DecodeOxmIdTunMetadata29Masked(_oxmid, decoder)
534 case 88056:
535 return DecodeOxmIdTunMetadata3Masked(_oxmid, decoder)
536 case 118396:
537 return DecodeOxmIdTunMetadata63(_oxmid, decoder)
538 case 2147493634:
539 return DecodeOxmIdIcmpv4TypeMasked(_oxmid, decoder)
540 case 4360:
541 return DecodeOxmIdIpDstMasked(_oxmid, decoder)
542 case 8196:
543 return DecodeOxmIdArpSpa(_oxmid, decoder)
544 case 108668:
545 return DecodeOxmIdTunMetadata44(_oxmid, decoder)
546 case 106108:
547 return DecodeOxmIdTunMetadata39(_oxmid, decoder)
548 case 76801:
549 return DecodeOxmIdIcmpv6Code(_oxmid, decoder)
550 case 101880:
551 return DecodeOxmIdTunMetadata30Masked(_oxmid, decoder)
552 case 114168:
553 return DecodeOxmIdTunMetadata54Masked(_oxmid, decoder)
554 case 2147494146:
555 return DecodeOxmIdIcmpv4CodeMasked(_oxmid, decoder)
556 case 70148:
557 return DecodeOxmIdReg9(_oxmid, decoder)
558 case 89212:
559 return DecodeOxmIdTunMetadata6(_oxmid, decoder)
560 case 119560:
561 return DecodeOxmIdConnTrackingStateMasked(_oxmid, decoder)
562 case 83204:
563 return DecodeOxmIdTcpFlagsMasked(_oxmid, decoder)
564 case 106620:
565 return DecodeOxmIdTunMetadata40(_oxmid, decoder)
566 case 6146:
567 return DecodeOxmIdUdpDst(_oxmid, decoder)
568 case 119044:
569 return DecodeOxmIdTunFlagsMasked(_oxmid, decoder)
570 case 102392:
571 return DecodeOxmIdTunMetadata31Masked(_oxmid, decoder)
572 case 115324:
573 return DecodeOxmIdTunMetadata57(_oxmid, decoder)
574 case 82696:
575 return DecodeOxmIdPktMarkMasked(_oxmid, decoder)
576 case 123920:
577 return DecodeOxmIdXxreg3(_oxmid, decoder)
578 case 70920:
579 return DecodeOxmIdReg10Masked(_oxmid, decoder)
580 case 107132:
581 return DecodeOxmIdTunMetadata41(_oxmid, decoder)
582 case 102904:
583 return DecodeOxmIdTunMetadata32Masked(_oxmid, decoder)
584 case 111096:
585 return DecodeOxmIdTunMetadata48Masked(_oxmid, decoder)
586 case 67076:
587 return DecodeOxmIdReg3(_oxmid, decoder)
588 case 120584:
589 return DecodeOxmIdConnTrackingMarkMasked(_oxmid, decoder)
590 case 91260:
591 return DecodeOxmIdTunMetadata10(_oxmid, decoder)
592 case 112252:
593 return DecodeOxmIdTunMetadata51(_oxmid, decoder)
594 case 87032:
595 return DecodeOxmIdTunMetadata1Masked(_oxmid, decoder)
596 case 2147501569:
597 return DecodeOxmIdMplsTc(_oxmid, decoder)
598 case 83460:
599 return DecodeOxmIdDpHash(_oxmid, decoder)
600 case 126722:
601 return DecodeOxmIdConnTrackingNwProtoMasked(_oxmid, decoder)
602 case 119300:
603 return DecodeOxmIdConnTrackingState(_oxmid, decoder)
604 case 117752:
605 return DecodeOxmIdTunMetadata61Masked(_oxmid, decoder)
606 case 71944:
607 return DecodeOxmIdReg12Masked(_oxmid, decoder)
608 case 2147499808:
609 return DecodeOxmIdIpv6NdTargetMasked(_oxmid, decoder)
610 case 91772:
611 return DecodeOxmIdTunMetadata11(_oxmid, decoder)
612 case 78849:
613 return DecodeOxmIdIpFrag(_oxmid, decoder)
614 case 87544:
615 return DecodeOxmIdTunMetadata2Masked(_oxmid, decoder)
616 case 90104:
617 return DecodeOxmIdTunMetadata7Masked(_oxmid, decoder)
618 case 72456:
619 return DecodeOxmIdReg13Masked(_oxmid, decoder)
620 case 109180:
621 return DecodeOxmIdTunMetadata45(_oxmid, decoder)
622 case 91640:
623 return DecodeOxmIdTunMetadata10Masked(_oxmid, decoder)
624 case 2147498248:
625 return DecodeOxmIdIpv6FlabelMasked(_oxmid, decoder)
626 case 2147492612:
627 return DecodeOxmIdSctpSrcMasked(_oxmid, decoder)
628 case 104440:
629 return DecodeOxmIdTunMetadata35Masked(_oxmid, decoder)
630 case 2147494660:
631 return DecodeOxmIdArpOpMasked(_oxmid, decoder)
632 case 66824:
633 return DecodeOxmIdReg2Masked(_oxmid, decoder)
634 case 109048:
635 return DecodeOxmIdTunMetadata44Masked(_oxmid, decoder)
636 case 2147492866:
637 return DecodeOxmIdSctpDst(_oxmid, decoder)
638 case 89724:
639 return DecodeOxmIdTunMetadata7(_oxmid, decoder)
640 case 72968:
641 return DecodeOxmIdReg14Masked(_oxmid, decoder)
642 case 92796:
643 return DecodeOxmIdTunMetadata13(_oxmid, decoder)
644 case 79873:
645 return DecodeOxmIdNwEcn(_oxmid, decoder)
646 case 104952:
647 return DecodeOxmIdTunMetadata36Masked(_oxmid, decoder)
648 case 115836:
649 return DecodeOxmIdTunMetadata58(_oxmid, decoder)
650 case 93820:
651 return DecodeOxmIdTunMetadata15(_oxmid, decoder)
652 case 2147489284:
653 return DecodeOxmIdIpv4Src(_oxmid, decoder)
654 case 93308:
655 return DecodeOxmIdTunMetadata14(_oxmid, decoder)
656 case 80385:
657 return DecodeOxmIdNwTtl(_oxmid, decoder)
658 case 105464:
659 return DecodeOxmIdTunMetadata37Masked(_oxmid, decoder)
660 case 111608:
661 return DecodeOxmIdTunMetadata49Masked(_oxmid, decoder)
662 case 2147488002:
663 return DecodeOxmIdIpDscpMasked(_oxmid, decoder)
664 case 86520:
665 return DecodeOxmIdTunMetadata0Masked(_oxmid, decoder)
666 case 67588:
667 return DecodeOxmIdReg4(_oxmid, decoder)
668 case 6404:
669 return DecodeOxmIdUdpDstMasked(_oxmid, decoder)
670 case 126980:
671 return DecodeOxmIdConnTrackingNwSrc(_oxmid, decoder)
672 default:
673 return _oxmid, nil
674 }
675}
676
677func NewOxmId(_type_len uint32) *OxmId {
678 obj := &OxmId{}
679 obj.TypeLen = _type_len
680 return obj
681}
682func (self *OxmId) GetOXMName() string {
683 return ""
684}
685
686func (self *OxmId) MarshalJSON() ([]byte, error) {
687 if self.TypeLen == 0 {
688 return []byte("\"\""), nil
689 } else {
690 return []byte("\"" + self.GetOXMName() + "\""), nil
691 }
692}
693
694type ActionNxBundleLoadSlave struct {
695 Port Port
696}
697
698type IActionNxBundleLoadSlave interface {
699 goloxi.Serializable
700 GetPort() Port
701}
702
703func (self *ActionNxBundleLoadSlave) GetPort() Port {
704 return self.Port
705}
706
707func (self *ActionNxBundleLoadSlave) SetPort(v Port) {
708 self.Port = v
709}
710
711func (self *ActionNxBundleLoadSlave) Serialize(encoder *goloxi.Encoder) error {
712
713 encoder.PutUint32(uint32(self.Port))
714
715 return nil
716}
717
718func DecodeActionNxBundleLoadSlave(decoder *goloxi.Decoder) (*ActionNxBundleLoadSlave, error) {
719 _actionnxbundleloadslave := &ActionNxBundleLoadSlave{}
720 if decoder.Length() < 4 {
721 return nil, fmt.Errorf("ActionNxBundleLoadSlave packet too short: %d < 4", decoder.Length())
722 }
723 _actionnxbundleloadslave.Port = Port(decoder.ReadUint32())
724 return _actionnxbundleloadslave, nil
725}
726
727func NewActionNxBundleLoadSlave() *ActionNxBundleLoadSlave {
728 obj := &ActionNxBundleLoadSlave{}
729 return obj
730}
731
732type ActionNxController2Property struct {
733 Type NxActionController2PropType
734}
735
736type IActionNxController2Property interface {
737 goloxi.Serializable
738 GetType() NxActionController2PropType
739}
740
741func (self *ActionNxController2Property) GetType() NxActionController2PropType {
742 return self.Type
743}
744
745func (self *ActionNxController2Property) SetType(v NxActionController2PropType) {
746 self.Type = v
747}
748
749func (self *ActionNxController2Property) Serialize(encoder *goloxi.Encoder) error {
750
751 encoder.PutUint16(uint16(self.Type))
752
753 return nil
754}
755
756func DecodeActionNxController2Property(decoder *goloxi.Decoder) (IActionNxController2Property, error) {
757 _actionnxcontroller2property := &ActionNxController2Property{}
758 if decoder.Length() < 2 {
759 return nil, fmt.Errorf("ActionNxController2Property packet too short: %d < 2", decoder.Length())
760 }
761 _actionnxcontroller2property.Type = NxActionController2PropType(decoder.ReadUint16())
762
763 switch _actionnxcontroller2property.Type {
764 case 0:
765 return DecodeActionNxController2PropertyMaxLen(_actionnxcontroller2property, decoder)
766 case 1:
767 return DecodeActionNxController2PropertyControllerId(_actionnxcontroller2property, decoder)
768 case 2:
769 return DecodeActionNxController2PropertyReason(_actionnxcontroller2property, decoder)
770 case 3:
771 return DecodeActionNxController2PropertyUserdata(_actionnxcontroller2property, decoder)
772 case 4:
773 return DecodeActionNxController2PropertyPause(_actionnxcontroller2property, decoder)
774 case 5:
775 return DecodeActionNxController2PropertyMeterId(_actionnxcontroller2property, decoder)
776 default:
777 return nil, fmt.Errorf("Invalid type '%d' for 'ActionNxController2Property'", _actionnxcontroller2property.Type)
778 }
779}
780
781func NewActionNxController2Property(_type NxActionController2PropType) *ActionNxController2Property {
782 obj := &ActionNxController2Property{}
783 obj.Type = _type
784 return obj
785}
786
787type ActionNxController2PropertyControllerId struct {
788 *ActionNxController2Property
789 ControllerId uint16
790}
791
792type IActionNxController2PropertyControllerId interface {
793 IActionNxController2Property
794 GetControllerId() uint16
795}
796
797func (self *ActionNxController2PropertyControllerId) GetControllerId() uint16 {
798 return self.ControllerId
799}
800
801func (self *ActionNxController2PropertyControllerId) SetControllerId(v uint16) {
802 self.ControllerId = v
803}
804
805func (self *ActionNxController2PropertyControllerId) Serialize(encoder *goloxi.Encoder) error {
806 startIndex := len(encoder.Bytes())
807 if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
808 return err
809 }
810
811 encoder.PutUint16(uint16(self.ControllerId))
812 length := len(encoder.Bytes()) - startIndex
813 alignedLength := ((length + 7) / 8 * 8)
814
815 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
816
817 return nil
818}
819
820func DecodeActionNxController2PropertyControllerId(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyControllerId, error) {
821 _actionnxcontroller2propertycontrollerid := &ActionNxController2PropertyControllerId{ActionNxController2Property: parent}
822 if decoder.Length() < 2 {
823 return nil, fmt.Errorf("ActionNxController2PropertyControllerId packet too short: %d < 2", decoder.Length())
824 }
825 defer decoder.SkipAlign()
826
827 _actionnxcontroller2propertycontrollerid.ControllerId = uint16(decoder.ReadUint16())
828 return _actionnxcontroller2propertycontrollerid, nil
829}
830
831func NewActionNxController2PropertyControllerId() *ActionNxController2PropertyControllerId {
832 obj := &ActionNxController2PropertyControllerId{
833 ActionNxController2Property: NewActionNxController2Property(1),
834 }
835 return obj
836}
837
838type ActionNxController2PropertyMaxLen struct {
839 *ActionNxController2Property
840 MaxLen uint16
841}
842
843type IActionNxController2PropertyMaxLen interface {
844 IActionNxController2Property
845 GetMaxLen() uint16
846}
847
848func (self *ActionNxController2PropertyMaxLen) GetMaxLen() uint16 {
849 return self.MaxLen
850}
851
852func (self *ActionNxController2PropertyMaxLen) SetMaxLen(v uint16) {
853 self.MaxLen = v
854}
855
856func (self *ActionNxController2PropertyMaxLen) Serialize(encoder *goloxi.Encoder) error {
857 startIndex := len(encoder.Bytes())
858 if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
859 return err
860 }
861
862 encoder.PutUint16(uint16(self.MaxLen))
863 length := len(encoder.Bytes()) - startIndex
864 alignedLength := ((length + 7) / 8 * 8)
865
866 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
867
868 return nil
869}
870
871func DecodeActionNxController2PropertyMaxLen(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyMaxLen, error) {
872 _actionnxcontroller2propertymaxlen := &ActionNxController2PropertyMaxLen{ActionNxController2Property: parent}
873 if decoder.Length() < 2 {
874 return nil, fmt.Errorf("ActionNxController2PropertyMaxLen packet too short: %d < 2", decoder.Length())
875 }
876 defer decoder.SkipAlign()
877
878 _actionnxcontroller2propertymaxlen.MaxLen = uint16(decoder.ReadUint16())
879 return _actionnxcontroller2propertymaxlen, nil
880}
881
882func NewActionNxController2PropertyMaxLen() *ActionNxController2PropertyMaxLen {
883 obj := &ActionNxController2PropertyMaxLen{
884 ActionNxController2Property: NewActionNxController2Property(0),
885 }
886 return obj
887}
888
889type ActionNxController2PropertyMeterId struct {
890 *ActionNxController2Property
891 MeterId uint32
892}
893
894type IActionNxController2PropertyMeterId interface {
895 IActionNxController2Property
896 GetMeterId() uint32
897}
898
899func (self *ActionNxController2PropertyMeterId) GetMeterId() uint32 {
900 return self.MeterId
901}
902
903func (self *ActionNxController2PropertyMeterId) SetMeterId(v uint32) {
904 self.MeterId = v
905}
906
907func (self *ActionNxController2PropertyMeterId) Serialize(encoder *goloxi.Encoder) error {
908 startIndex := len(encoder.Bytes())
909 if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
910 return err
911 }
912
913 encoder.PutUint32(uint32(self.MeterId))
914 length := len(encoder.Bytes()) - startIndex
915 alignedLength := ((length + 7) / 8 * 8)
916
917 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
918
919 return nil
920}
921
922func DecodeActionNxController2PropertyMeterId(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyMeterId, error) {
923 _actionnxcontroller2propertymeterid := &ActionNxController2PropertyMeterId{ActionNxController2Property: parent}
924 if decoder.Length() < 4 {
925 return nil, fmt.Errorf("ActionNxController2PropertyMeterId packet too short: %d < 4", decoder.Length())
926 }
927 defer decoder.SkipAlign()
928
929 _actionnxcontroller2propertymeterid.MeterId = uint32(decoder.ReadUint32())
930 return _actionnxcontroller2propertymeterid, nil
931}
932
933func NewActionNxController2PropertyMeterId() *ActionNxController2PropertyMeterId {
934 obj := &ActionNxController2PropertyMeterId{
935 ActionNxController2Property: NewActionNxController2Property(5),
936 }
937 return obj
938}
939
940type ActionNxController2PropertyPause struct {
941 *ActionNxController2Property
942}
943
944type IActionNxController2PropertyPause interface {
945 IActionNxController2Property
946}
947
948func (self *ActionNxController2PropertyPause) Serialize(encoder *goloxi.Encoder) error {
949 startIndex := len(encoder.Bytes())
950 if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
951 return err
952 }
953 length := len(encoder.Bytes()) - startIndex
954 alignedLength := ((length + 7) / 8 * 8)
955
956 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
957
958 return nil
959}
960
961func DecodeActionNxController2PropertyPause(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyPause, error) {
962 _actionnxcontroller2propertypause := &ActionNxController2PropertyPause{ActionNxController2Property: parent}
963 defer decoder.SkipAlign()
964
965 return _actionnxcontroller2propertypause, nil
966}
967
968func NewActionNxController2PropertyPause() *ActionNxController2PropertyPause {
969 obj := &ActionNxController2PropertyPause{
970 ActionNxController2Property: NewActionNxController2Property(4),
971 }
972 return obj
973}
974
975type ActionNxController2PropertyReason struct {
976 *ActionNxController2Property
977 Reason PacketInReason
978}
979
980type IActionNxController2PropertyReason interface {
981 IActionNxController2Property
982 GetReason() PacketInReason
983}
984
985func (self *ActionNxController2PropertyReason) GetReason() PacketInReason {
986 return self.Reason
987}
988
989func (self *ActionNxController2PropertyReason) SetReason(v PacketInReason) {
990 self.Reason = v
991}
992
993func (self *ActionNxController2PropertyReason) Serialize(encoder *goloxi.Encoder) error {
994 startIndex := len(encoder.Bytes())
995 if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
996 return err
997 }
998
999 encoder.PutUint8(uint8(self.Reason))
1000 length := len(encoder.Bytes()) - startIndex
1001 alignedLength := ((length + 7) / 8 * 8)
1002
1003 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
1004
1005 return nil
1006}
1007
1008func DecodeActionNxController2PropertyReason(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyReason, error) {
1009 _actionnxcontroller2propertyreason := &ActionNxController2PropertyReason{ActionNxController2Property: parent}
1010 if decoder.Length() < 1 {
1011 return nil, fmt.Errorf("ActionNxController2PropertyReason packet too short: %d < 1", decoder.Length())
1012 }
1013 defer decoder.SkipAlign()
1014
1015 _actionnxcontroller2propertyreason.Reason = PacketInReason(decoder.ReadByte())
1016 return _actionnxcontroller2propertyreason, nil
1017}
1018
1019func NewActionNxController2PropertyReason() *ActionNxController2PropertyReason {
1020 obj := &ActionNxController2PropertyReason{
1021 ActionNxController2Property: NewActionNxController2Property(2),
1022 }
1023 return obj
1024}
1025
1026type ActionNxController2PropertyUserdata struct {
1027 *ActionNxController2Property
1028 Length uint16
1029 Userdata []byte
1030}
1031
1032type IActionNxController2PropertyUserdata interface {
1033 IActionNxController2Property
1034 GetLength() uint16
1035 GetUserdata() []byte
1036}
1037
1038func (self *ActionNxController2PropertyUserdata) GetLength() uint16 {
1039 return self.Length
1040}
1041
1042func (self *ActionNxController2PropertyUserdata) SetLength(v uint16) {
1043 self.Length = v
1044}
1045
1046func (self *ActionNxController2PropertyUserdata) GetUserdata() []byte {
1047 return self.Userdata
1048}
1049
1050func (self *ActionNxController2PropertyUserdata) SetUserdata(v []byte) {
1051 self.Userdata = v
1052}
1053
1054func (self *ActionNxController2PropertyUserdata) Serialize(encoder *goloxi.Encoder) error {
1055 startIndex := len(encoder.Bytes())
1056 if err := self.ActionNxController2Property.Serialize(encoder); err != nil {
1057 return err
1058 }
1059
1060 encoder.PutUint16(uint16(self.Length))
1061 encoder.Write(self.Userdata)
1062 length := len(encoder.Bytes()) - startIndex
1063 alignedLength := ((length + 7) / 8 * 8)
1064
1065 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1066
1067 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
1068
1069 return nil
1070}
1071
1072func DecodeActionNxController2PropertyUserdata(parent *ActionNxController2Property, decoder *goloxi.Decoder) (*ActionNxController2PropertyUserdata, error) {
1073 _actionnxcontroller2propertyuserdata := &ActionNxController2PropertyUserdata{ActionNxController2Property: parent}
1074 if decoder.Length() < 2 {
1075 return nil, fmt.Errorf("ActionNxController2PropertyUserdata packet too short: %d < 2", decoder.Length())
1076 }
1077 defer decoder.SkipAlign()
1078
1079 _actionnxcontroller2propertyuserdata.Length = uint16(decoder.ReadUint16())
1080 oldDecoder := decoder
1081 defer func() { decoder = oldDecoder }()
1082 decoder = decoder.SliceDecoder(int(((_actionnxcontroller2propertyuserdata.Length)+7)/8*8), 2+2)
1083 _actionnxcontroller2propertyuserdata.Userdata = decoder.Read(int(decoder.Length()))
1084 return _actionnxcontroller2propertyuserdata, nil
1085}
1086
1087func NewActionNxController2PropertyUserdata() *ActionNxController2PropertyUserdata {
1088 obj := &ActionNxController2PropertyUserdata{
1089 ActionNxController2Property: NewActionNxController2Property(3),
1090 }
1091 return obj
1092}
1093
1094type BsnInterface struct {
1095 HwAddr net.HardwareAddr
1096 Name string
1097 Ipv4Addr net.IP
1098 Ipv4Netmask net.IP
1099}
1100
1101type IBsnInterface interface {
1102 goloxi.Serializable
1103 GetHwAddr() net.HardwareAddr
1104 GetName() string
1105 GetIpv4Addr() net.IP
1106 GetIpv4Netmask() net.IP
1107}
1108
1109func (self *BsnInterface) GetHwAddr() net.HardwareAddr {
1110 return self.HwAddr
1111}
1112
1113func (self *BsnInterface) SetHwAddr(v net.HardwareAddr) {
1114 self.HwAddr = v
1115}
1116
1117func (self *BsnInterface) GetName() string {
1118 return self.Name
1119}
1120
1121func (self *BsnInterface) SetName(v string) {
1122 self.Name = v
1123}
1124
1125func (self *BsnInterface) GetIpv4Addr() net.IP {
1126 return self.Ipv4Addr
1127}
1128
1129func (self *BsnInterface) SetIpv4Addr(v net.IP) {
1130 self.Ipv4Addr = v
1131}
1132
1133func (self *BsnInterface) GetIpv4Netmask() net.IP {
1134 return self.Ipv4Netmask
1135}
1136
1137func (self *BsnInterface) SetIpv4Netmask(v net.IP) {
1138 self.Ipv4Netmask = v
1139}
1140
1141func (self *BsnInterface) Serialize(encoder *goloxi.Encoder) error {
1142
1143 encoder.Write(self.HwAddr)
1144 encoder.Write(bytes.Repeat([]byte{0}, 2))
1145 encoder.Write([]byte(self.Name))
1146 encoder.Write(self.Ipv4Addr.To4())
1147 encoder.Write(self.Ipv4Netmask.To4())
1148
1149 return nil
1150}
1151
1152func DecodeBsnInterface(decoder *goloxi.Decoder) (*BsnInterface, error) {
1153 _bsninterface := &BsnInterface{}
1154 if decoder.Length() < 32 {
1155 return nil, fmt.Errorf("BsnInterface packet too short: %d < 32", decoder.Length())
1156 }
1157 _bsninterface.HwAddr = net.HardwareAddr(decoder.Read(6))
1158 decoder.Skip(2)
1159 _bsninterface.Name = string(bytes.Trim(decoder.Read(16), "\x00"))
1160 _bsninterface.Ipv4Addr = net.IP(decoder.Read(4))
1161 _bsninterface.Ipv4Netmask = net.IP(decoder.Read(4))
1162 return _bsninterface, nil
1163}
1164
1165func NewBsnInterface() *BsnInterface {
1166 obj := &BsnInterface{}
1167 return obj
1168}
1169
1170type BsnVport struct {
1171 Type uint16
1172 Length uint16
1173}
1174
1175type IBsnVport interface {
1176 goloxi.Serializable
1177 GetType() uint16
1178 GetLength() uint16
1179}
1180
1181func (self *BsnVport) GetType() uint16 {
1182 return self.Type
1183}
1184
1185func (self *BsnVport) SetType(v uint16) {
1186 self.Type = v
1187}
1188
1189func (self *BsnVport) GetLength() uint16 {
1190 return self.Length
1191}
1192
1193func (self *BsnVport) SetLength(v uint16) {
1194 self.Length = v
1195}
1196
1197func (self *BsnVport) Serialize(encoder *goloxi.Encoder) error {
1198
1199 encoder.PutUint16(uint16(self.Type))
1200 encoder.PutUint16(uint16(self.Length))
1201
1202 return nil
1203}
1204func (self *BsnVport) Decode(decoder *goloxi.Decoder) error {
1205 if decoder.Length() < 4 {
1206 return fmt.Errorf("BsnVport packet too short: %d < 4", decoder.Length())
1207 }
1208
1209 self.Type = uint16(decoder.ReadUint16())
1210 self.Length = uint16(decoder.ReadUint16())
1211 oldDecoder := decoder
1212 defer func() { decoder = oldDecoder }()
1213 decoder = decoder.SliceDecoder(int(self.Length), 2+2)
1214
1215 return nil
1216}
1217
1218func NewBsnVport(_type uint16) *BsnVport {
1219 obj := &BsnVport{}
1220 obj.Type = _type
1221 return obj
1222}
1223
1224type BsnVportL2Gre struct {
1225 *BsnVport
1226 Flags BsnVportL2GreFlags
1227 PortNo Port
1228 LoopbackPortNo Port
1229 LocalMac net.HardwareAddr
1230 NhMac net.HardwareAddr
1231 SrcIp net.IP
1232 DstIp net.IP
1233 Dscp uint8
1234 Ttl uint8
1235 Vpn uint32
1236 RateLimit uint32
1237 IfName string
1238}
1239
1240type IBsnVportL2Gre interface {
1241 IBsnVport
1242 GetFlags() BsnVportL2GreFlags
1243 GetPortNo() Port
1244 GetLoopbackPortNo() Port
1245 GetLocalMac() net.HardwareAddr
1246 GetNhMac() net.HardwareAddr
1247 GetSrcIp() net.IP
1248 GetDstIp() net.IP
1249 GetDscp() uint8
1250 GetTtl() uint8
1251 GetVpn() uint32
1252 GetRateLimit() uint32
1253 GetIfName() string
1254}
1255
1256func (self *BsnVportL2Gre) GetFlags() BsnVportL2GreFlags {
1257 return self.Flags
1258}
1259
1260func (self *BsnVportL2Gre) SetFlags(v BsnVportL2GreFlags) {
1261 self.Flags = v
1262}
1263
1264func (self *BsnVportL2Gre) GetPortNo() Port {
1265 return self.PortNo
1266}
1267
1268func (self *BsnVportL2Gre) SetPortNo(v Port) {
1269 self.PortNo = v
1270}
1271
1272func (self *BsnVportL2Gre) GetLoopbackPortNo() Port {
1273 return self.LoopbackPortNo
1274}
1275
1276func (self *BsnVportL2Gre) SetLoopbackPortNo(v Port) {
1277 self.LoopbackPortNo = v
1278}
1279
1280func (self *BsnVportL2Gre) GetLocalMac() net.HardwareAddr {
1281 return self.LocalMac
1282}
1283
1284func (self *BsnVportL2Gre) SetLocalMac(v net.HardwareAddr) {
1285 self.LocalMac = v
1286}
1287
1288func (self *BsnVportL2Gre) GetNhMac() net.HardwareAddr {
1289 return self.NhMac
1290}
1291
1292func (self *BsnVportL2Gre) SetNhMac(v net.HardwareAddr) {
1293 self.NhMac = v
1294}
1295
1296func (self *BsnVportL2Gre) GetSrcIp() net.IP {
1297 return self.SrcIp
1298}
1299
1300func (self *BsnVportL2Gre) SetSrcIp(v net.IP) {
1301 self.SrcIp = v
1302}
1303
1304func (self *BsnVportL2Gre) GetDstIp() net.IP {
1305 return self.DstIp
1306}
1307
1308func (self *BsnVportL2Gre) SetDstIp(v net.IP) {
1309 self.DstIp = v
1310}
1311
1312func (self *BsnVportL2Gre) GetDscp() uint8 {
1313 return self.Dscp
1314}
1315
1316func (self *BsnVportL2Gre) SetDscp(v uint8) {
1317 self.Dscp = v
1318}
1319
1320func (self *BsnVportL2Gre) GetTtl() uint8 {
1321 return self.Ttl
1322}
1323
1324func (self *BsnVportL2Gre) SetTtl(v uint8) {
1325 self.Ttl = v
1326}
1327
1328func (self *BsnVportL2Gre) GetVpn() uint32 {
1329 return self.Vpn
1330}
1331
1332func (self *BsnVportL2Gre) SetVpn(v uint32) {
1333 self.Vpn = v
1334}
1335
1336func (self *BsnVportL2Gre) GetRateLimit() uint32 {
1337 return self.RateLimit
1338}
1339
1340func (self *BsnVportL2Gre) SetRateLimit(v uint32) {
1341 self.RateLimit = v
1342}
1343
1344func (self *BsnVportL2Gre) GetIfName() string {
1345 return self.IfName
1346}
1347
1348func (self *BsnVportL2Gre) SetIfName(v string) {
1349 self.IfName = v
1350}
1351
1352func (self *BsnVportL2Gre) Serialize(encoder *goloxi.Encoder) error {
1353 startIndex := len(encoder.Bytes())
1354 if err := self.BsnVport.Serialize(encoder); err != nil {
1355 return err
1356 }
1357
1358 encoder.PutUint32(uint32(self.Flags))
1359 self.PortNo.Serialize(encoder)
1360 self.LoopbackPortNo.Serialize(encoder)
1361 encoder.Write(self.LocalMac)
1362 encoder.Write(self.NhMac)
1363 encoder.Write(self.SrcIp.To4())
1364 encoder.Write(self.DstIp.To4())
1365 encoder.PutUint8(uint8(self.Dscp))
1366 encoder.PutUint8(uint8(self.Ttl))
1367 encoder.Write(bytes.Repeat([]byte{0}, 2))
1368 encoder.PutUint32(uint32(self.Vpn))
1369 encoder.PutUint32(uint32(self.RateLimit))
1370 encoder.Write([]byte(self.IfName))
1371 length := len(encoder.Bytes()) - startIndex
1372
1373 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1374
1375 return nil
1376}
1377
1378func DecodeBsnVportL2Gre(parent *BsnVport, decoder *goloxi.Decoder) (*BsnVportL2Gre, error) {
1379 _bsnvportl2gre := &BsnVportL2Gre{BsnVport: parent}
1380 if decoder.Length() < 60 {
1381 return nil, fmt.Errorf("BsnVportL2Gre packet too short: %d < 60", decoder.Length())
1382 }
1383 _bsnvportl2gre.Flags = BsnVportL2GreFlags(decoder.ReadUint32())
1384 _bsnvportl2gre.PortNo.Decode(decoder)
1385 _bsnvportl2gre.LoopbackPortNo.Decode(decoder)
1386 _bsnvportl2gre.LocalMac = net.HardwareAddr(decoder.Read(6))
1387 _bsnvportl2gre.NhMac = net.HardwareAddr(decoder.Read(6))
1388 _bsnvportl2gre.SrcIp = net.IP(decoder.Read(4))
1389 _bsnvportl2gre.DstIp = net.IP(decoder.Read(4))
1390 _bsnvportl2gre.Dscp = uint8(decoder.ReadByte())
1391 _bsnvportl2gre.Ttl = uint8(decoder.ReadByte())
1392 decoder.Skip(2)
1393 _bsnvportl2gre.Vpn = uint32(decoder.ReadUint32())
1394 _bsnvportl2gre.RateLimit = uint32(decoder.ReadUint32())
1395 _bsnvportl2gre.IfName = string(bytes.Trim(decoder.Read(16), "\x00"))
1396 return _bsnvportl2gre, nil
1397}
1398
1399func NewBsnVportL2Gre() *BsnVportL2Gre {
1400 obj := &BsnVportL2Gre{
1401 BsnVport: NewBsnVport(1),
1402 }
1403 return obj
1404}
1405
1406type BsnVportQInQ struct {
1407 *BsnVport
1408 PortNo uint32
1409 IngressTpid uint16
1410 IngressVlanId uint16
1411 EgressTpid uint16
1412 EgressVlanId uint16
1413 IfName string
1414}
1415
1416type IBsnVportQInQ interface {
1417 IBsnVport
1418 GetPortNo() uint32
1419 GetIngressTpid() uint16
1420 GetIngressVlanId() uint16
1421 GetEgressTpid() uint16
1422 GetEgressVlanId() uint16
1423 GetIfName() string
1424}
1425
1426func (self *BsnVportQInQ) GetPortNo() uint32 {
1427 return self.PortNo
1428}
1429
1430func (self *BsnVportQInQ) SetPortNo(v uint32) {
1431 self.PortNo = v
1432}
1433
1434func (self *BsnVportQInQ) GetIngressTpid() uint16 {
1435 return self.IngressTpid
1436}
1437
1438func (self *BsnVportQInQ) SetIngressTpid(v uint16) {
1439 self.IngressTpid = v
1440}
1441
1442func (self *BsnVportQInQ) GetIngressVlanId() uint16 {
1443 return self.IngressVlanId
1444}
1445
1446func (self *BsnVportQInQ) SetIngressVlanId(v uint16) {
1447 self.IngressVlanId = v
1448}
1449
1450func (self *BsnVportQInQ) GetEgressTpid() uint16 {
1451 return self.EgressTpid
1452}
1453
1454func (self *BsnVportQInQ) SetEgressTpid(v uint16) {
1455 self.EgressTpid = v
1456}
1457
1458func (self *BsnVportQInQ) GetEgressVlanId() uint16 {
1459 return self.EgressVlanId
1460}
1461
1462func (self *BsnVportQInQ) SetEgressVlanId(v uint16) {
1463 self.EgressVlanId = v
1464}
1465
1466func (self *BsnVportQInQ) GetIfName() string {
1467 return self.IfName
1468}
1469
1470func (self *BsnVportQInQ) SetIfName(v string) {
1471 self.IfName = v
1472}
1473
1474func (self *BsnVportQInQ) Serialize(encoder *goloxi.Encoder) error {
1475 startIndex := len(encoder.Bytes())
1476 if err := self.BsnVport.Serialize(encoder); err != nil {
1477 return err
1478 }
1479
1480 encoder.PutUint32(uint32(self.PortNo))
1481 encoder.PutUint16(uint16(self.IngressTpid))
1482 encoder.PutUint16(uint16(self.IngressVlanId))
1483 encoder.PutUint16(uint16(self.EgressTpid))
1484 encoder.PutUint16(uint16(self.EgressVlanId))
1485 encoder.Write([]byte(self.IfName))
1486 length := len(encoder.Bytes()) - startIndex
1487
1488 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
1489
1490 return nil
1491}
1492
1493func DecodeBsnVportQInQ(parent *BsnVport, decoder *goloxi.Decoder) (*BsnVportQInQ, error) {
1494 _bsnvportqinq := &BsnVportQInQ{BsnVport: parent}
1495 if decoder.Length() < 28 {
1496 return nil, fmt.Errorf("BsnVportQInQ packet too short: %d < 28", decoder.Length())
1497 }
1498 _bsnvportqinq.PortNo = uint32(decoder.ReadUint32())
1499 _bsnvportqinq.IngressTpid = uint16(decoder.ReadUint16())
1500 _bsnvportqinq.IngressVlanId = uint16(decoder.ReadUint16())
1501 _bsnvportqinq.EgressTpid = uint16(decoder.ReadUint16())
1502 _bsnvportqinq.EgressVlanId = uint16(decoder.ReadUint16())
1503 _bsnvportqinq.IfName = string(bytes.Trim(decoder.Read(16), "\x00"))
1504 return _bsnvportqinq, nil
1505}
1506
1507func NewBsnVportQInQ() *BsnVportQInQ {
1508 obj := &BsnVportQInQ{
1509 BsnVport: NewBsnVport(0),
1510 }
1511 return obj
1512}
1513
1514type Bucket struct {
1515 Len uint16
1516 Weight uint16
1517 WatchPort Port
1518 WatchGroup uint32
1519 Actions []goloxi.IAction
1520}
1521
1522type IBucket interface {
1523 goloxi.Serializable
1524 GetLen() uint16
1525 GetWeight() uint16
1526 GetWatchPort() Port
1527 GetWatchGroup() uint32
1528 GetActions() []goloxi.IAction
1529}
1530
1531func (self *Bucket) GetLen() uint16 {
1532 return self.Len
1533}
1534
1535func (self *Bucket) SetLen(v uint16) {
1536 self.Len = v
1537}
1538
1539func (self *Bucket) GetWeight() uint16 {
1540 return self.Weight
1541}
1542
1543func (self *Bucket) SetWeight(v uint16) {
1544 self.Weight = v
1545}
1546
1547func (self *Bucket) GetWatchPort() Port {
1548 return self.WatchPort
1549}
1550
1551func (self *Bucket) SetWatchPort(v Port) {
1552 self.WatchPort = v
1553}
1554
1555func (self *Bucket) GetWatchGroup() uint32 {
1556 return self.WatchGroup
1557}
1558
1559func (self *Bucket) SetWatchGroup(v uint32) {
1560 self.WatchGroup = v
1561}
1562
1563func (self *Bucket) GetActions() []goloxi.IAction {
1564 return self.Actions
1565}
1566
1567func (self *Bucket) SetActions(v []goloxi.IAction) {
1568 self.Actions = v
1569}
1570
1571func (self *Bucket) Serialize(encoder *goloxi.Encoder) error {
1572 startIndex := len(encoder.Bytes())
1573
1574 encoder.PutUint16(uint16(self.Len))
1575 encoder.PutUint16(uint16(self.Weight))
1576 self.WatchPort.Serialize(encoder)
1577 encoder.PutUint32(uint32(self.WatchGroup))
1578 encoder.Write(bytes.Repeat([]byte{0}, 4))
1579 for _, obj := range self.Actions {
1580 if err := obj.Serialize(encoder); err != nil {
1581 return err
1582 }
1583 }
1584 length := len(encoder.Bytes()) - startIndex
1585
1586 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
1587
1588 return nil
1589}
1590
1591func DecodeBucket(decoder *goloxi.Decoder) (*Bucket, error) {
1592 _bucket := &Bucket{}
1593 if decoder.Length() < 16 {
1594 return nil, fmt.Errorf("Bucket packet too short: %d < 16", decoder.Length())
1595 }
1596 _bucket.Len = uint16(decoder.ReadUint16())
1597 oldDecoder := decoder
1598 defer func() { decoder = oldDecoder }()
1599 decoder = decoder.SliceDecoder(int(_bucket.Len), 2+0)
1600 _bucket.Weight = uint16(decoder.ReadUint16())
1601 _bucket.WatchPort.Decode(decoder)
1602 _bucket.WatchGroup = uint32(decoder.ReadUint32())
1603 decoder.Skip(4)
1604
1605 for decoder.Length() >= 8 {
1606 item, err := DecodeAction(decoder)
1607 if err != nil {
1608 return nil, err
1609 }
1610 if item != nil {
1611 _bucket.Actions = append(_bucket.Actions, item)
1612 }
1613 }
1614 return _bucket, nil
1615}
1616
1617func NewBucket() *Bucket {
1618 obj := &Bucket{}
1619 return obj
1620}
1621
1622type BucketCounter struct {
1623 PacketCount uint64
1624 ByteCount uint64
1625}
1626
1627type IBucketCounter interface {
1628 goloxi.Serializable
1629 GetPacketCount() uint64
1630 GetByteCount() uint64
1631}
1632
1633func (self *BucketCounter) GetPacketCount() uint64 {
1634 return self.PacketCount
1635}
1636
1637func (self *BucketCounter) SetPacketCount(v uint64) {
1638 self.PacketCount = v
1639}
1640
1641func (self *BucketCounter) GetByteCount() uint64 {
1642 return self.ByteCount
1643}
1644
1645func (self *BucketCounter) SetByteCount(v uint64) {
1646 self.ByteCount = v
1647}
1648
1649func (self *BucketCounter) Serialize(encoder *goloxi.Encoder) error {
1650
1651 encoder.PutUint64(uint64(self.PacketCount))
1652 encoder.PutUint64(uint64(self.ByteCount))
1653
1654 return nil
1655}
1656
1657func DecodeBucketCounter(decoder *goloxi.Decoder) (*BucketCounter, error) {
1658 _bucketcounter := &BucketCounter{}
1659 if decoder.Length() < 16 {
1660 return nil, fmt.Errorf("BucketCounter packet too short: %d < 16", decoder.Length())
1661 }
1662 _bucketcounter.PacketCount = uint64(decoder.ReadUint64())
1663 _bucketcounter.ByteCount = uint64(decoder.ReadUint64())
1664 return _bucketcounter, nil
1665}
1666
1667func NewBucketCounter() *BucketCounter {
1668 obj := &BucketCounter{}
1669 return obj
1670}
1671
1672type EdPropHeader struct {
1673 PropClass uint16
1674}
1675
1676type IEdPropHeader interface {
1677 goloxi.Serializable
1678 GetPropClass() uint16
1679}
1680
1681func (self *EdPropHeader) GetPropClass() uint16 {
1682 return self.PropClass
1683}
1684
1685func (self *EdPropHeader) SetPropClass(v uint16) {
1686 self.PropClass = v
1687}
1688
1689func (self *EdPropHeader) Serialize(encoder *goloxi.Encoder) error {
1690
1691 encoder.PutUint16(uint16(self.PropClass))
1692
1693 return nil
1694}
1695
1696func DecodeEdPropHeader(decoder *goloxi.Decoder) (IEdPropHeader, error) {
1697 _edpropheader := &EdPropHeader{}
1698 if decoder.Length() < 2 {
1699 return nil, fmt.Errorf("EdPropHeader packet too short: %d < 2", decoder.Length())
1700 }
1701 _edpropheader.PropClass = uint16(decoder.ReadUint16())
1702
1703 switch _edpropheader.PropClass {
1704 case 4:
1705 return DecodeEdPropNsh(_edpropheader, decoder)
1706 default:
1707 return nil, fmt.Errorf("Invalid type '%d' for 'EdPropHeader'", _edpropheader.PropClass)
1708 }
1709}
1710
1711func NewEdPropHeader(_prop_class uint16) *EdPropHeader {
1712 obj := &EdPropHeader{}
1713 obj.PropClass = _prop_class
1714 return obj
1715}
1716
1717type EdPropNsh struct {
1718 *EdPropHeader
1719 Type uint8
1720 Len uint8
1721}
1722
1723type IEdPropNsh interface {
1724 IEdPropHeader
1725 GetType() uint8
1726 GetLen() uint8
1727}
1728
1729func (self *EdPropNsh) GetType() uint8 {
1730 return self.Type
1731}
1732
1733func (self *EdPropNsh) SetType(v uint8) {
1734 self.Type = v
1735}
1736
1737func (self *EdPropNsh) GetLen() uint8 {
1738 return self.Len
1739}
1740
1741func (self *EdPropNsh) SetLen(v uint8) {
1742 self.Len = v
1743}
1744
1745func (self *EdPropNsh) Serialize(encoder *goloxi.Encoder) error {
1746 if err := self.EdPropHeader.Serialize(encoder); err != nil {
1747 return err
1748 }
1749
1750 encoder.PutUint8(uint8(self.Type))
1751 encoder.PutUint8(uint8(self.Len))
1752
1753 return nil
1754}
1755
1756func DecodeEdPropNsh(parent *EdPropHeader, decoder *goloxi.Decoder) (IEdPropNsh, error) {
1757 _edpropnsh := &EdPropNsh{EdPropHeader: parent}
1758 if decoder.Length() < 2 {
1759 return nil, fmt.Errorf("EdPropNsh packet too short: %d < 2", decoder.Length())
1760 }
1761 defer decoder.SkipAlign()
1762
1763 _edpropnsh.Type = uint8(decoder.ReadByte())
1764 _edpropnsh.Len = uint8(decoder.ReadByte())
1765 oldDecoder := decoder
1766 defer func() { decoder = oldDecoder }()
1767 decoder = decoder.SliceDecoder(int(((_edpropnsh.Len)+7)/8*8), 1+3)
1768
1769 switch _edpropnsh.Type {
1770 case 1:
1771 return DecodeEdPropNshMdType(_edpropnsh, decoder)
1772 case 2:
1773 return DecodeEdPropNshTlv(_edpropnsh, decoder)
1774 default:
1775 return nil, fmt.Errorf("Invalid type '%d' for 'EdPropNsh'", _edpropnsh.Type)
1776 }
1777}
1778
1779func NewEdPropNsh(_type uint8) *EdPropNsh {
1780 obj := &EdPropNsh{
1781 EdPropHeader: NewEdPropHeader(4),
1782 }
1783 obj.Type = _type
1784 return obj
1785}
1786
1787type EdPropNshMdType struct {
1788 *EdPropNsh
1789 MdType uint8
1790}
1791
1792type IEdPropNshMdType interface {
1793 IEdPropNsh
1794 GetMdType() uint8
1795}
1796
1797func (self *EdPropNshMdType) GetMdType() uint8 {
1798 return self.MdType
1799}
1800
1801func (self *EdPropNshMdType) SetMdType(v uint8) {
1802 self.MdType = v
1803}
1804
1805func (self *EdPropNshMdType) Serialize(encoder *goloxi.Encoder) error {
1806 startIndex := len(encoder.Bytes())
1807 if err := self.EdPropNsh.Serialize(encoder); err != nil {
1808 return err
1809 }
1810
1811 encoder.PutUint8(uint8(self.MdType))
1812 encoder.Write(bytes.Repeat([]byte{0}, 3))
1813 length := len(encoder.Bytes()) - startIndex
1814
1815 encoder.Bytes()[startIndex+3] = uint8(length)
1816
1817 return nil
1818}
1819
1820func DecodeEdPropNshMdType(parent *EdPropNsh, decoder *goloxi.Decoder) (*EdPropNshMdType, error) {
1821 _edpropnshmdtype := &EdPropNshMdType{EdPropNsh: parent}
1822 if decoder.Length() < 4 {
1823 return nil, fmt.Errorf("EdPropNshMdType packet too short: %d < 4", decoder.Length())
1824 }
1825 _edpropnshmdtype.MdType = uint8(decoder.ReadByte())
1826 decoder.Skip(3)
1827 return _edpropnshmdtype, nil
1828}
1829
1830func NewEdPropNshMdType() *EdPropNshMdType {
1831 obj := &EdPropNshMdType{
1832 EdPropNsh: NewEdPropNsh(1),
1833 }
1834 return obj
1835}
1836
1837type EdPropNshTlv struct {
1838 *EdPropNsh
1839 TlvClass uint16
1840 TlvType uint8
1841 TlvLen uint8
1842 Value []byte
1843}
1844
1845type IEdPropNshTlv interface {
1846 IEdPropNsh
1847 GetTlvClass() uint16
1848 GetTlvType() uint8
1849 GetTlvLen() uint8
1850 GetValue() []byte
1851}
1852
1853func (self *EdPropNshTlv) GetTlvClass() uint16 {
1854 return self.TlvClass
1855}
1856
1857func (self *EdPropNshTlv) SetTlvClass(v uint16) {
1858 self.TlvClass = v
1859}
1860
1861func (self *EdPropNshTlv) GetTlvType() uint8 {
1862 return self.TlvType
1863}
1864
1865func (self *EdPropNshTlv) SetTlvType(v uint8) {
1866 self.TlvType = v
1867}
1868
1869func (self *EdPropNshTlv) GetTlvLen() uint8 {
1870 return self.TlvLen
1871}
1872
1873func (self *EdPropNshTlv) SetTlvLen(v uint8) {
1874 self.TlvLen = v
1875}
1876
1877func (self *EdPropNshTlv) GetValue() []byte {
1878 return self.Value
1879}
1880
1881func (self *EdPropNshTlv) SetValue(v []byte) {
1882 self.Value = v
1883}
1884
1885func (self *EdPropNshTlv) Serialize(encoder *goloxi.Encoder) error {
1886 startIndex := len(encoder.Bytes())
1887 if err := self.EdPropNsh.Serialize(encoder); err != nil {
1888 return err
1889 }
1890
1891 encoder.PutUint16(uint16(self.TlvClass))
1892 encoder.PutUint8(uint8(self.TlvType))
1893 encoder.PutUint8(uint8(self.TlvLen))
1894 encoder.Write(self.Value)
1895 length := len(encoder.Bytes()) - startIndex
1896
1897 encoder.Bytes()[startIndex+3] = uint8(length)
1898
1899 return nil
1900}
1901
1902func DecodeEdPropNshTlv(parent *EdPropNsh, decoder *goloxi.Decoder) (*EdPropNshTlv, error) {
1903 _edpropnshtlv := &EdPropNshTlv{EdPropNsh: parent}
1904 if decoder.Length() < 4 {
1905 return nil, fmt.Errorf("EdPropNshTlv packet too short: %d < 4", decoder.Length())
1906 }
1907 _edpropnshtlv.TlvClass = uint16(decoder.ReadUint16())
1908 _edpropnshtlv.TlvType = uint8(decoder.ReadByte())
1909 _edpropnshtlv.TlvLen = uint8(decoder.ReadByte())
1910 _edpropnshtlv.Value = decoder.SliceDecoder(int(_edpropnshtlv.TlvLen), 0).Read(int(_edpropnshtlv.TlvLen))
1911 return _edpropnshtlv, nil
1912}
1913
1914func NewEdPropNshTlv() *EdPropNshTlv {
1915 obj := &EdPropNshTlv{
1916 EdPropNsh: NewEdPropNsh(2),
1917 }
1918 return obj
1919}
1920
1921type FlowModSpec struct {
1922 SrcDst uint8
1923 NBits uint8
1924}
1925
1926type IFlowModSpec interface {
1927 goloxi.Serializable
1928 GetSrcDst() uint8
1929 GetNBits() uint8
1930}
1931
1932func (self *FlowModSpec) GetSrcDst() uint8 {
1933 return self.SrcDst
1934}
1935
1936func (self *FlowModSpec) SetSrcDst(v uint8) {
1937 self.SrcDst = v
1938}
1939
1940func (self *FlowModSpec) GetNBits() uint8 {
1941 return self.NBits
1942}
1943
1944func (self *FlowModSpec) SetNBits(v uint8) {
1945 self.NBits = v
1946}
1947
1948func (self *FlowModSpec) Serialize(encoder *goloxi.Encoder) error {
1949
1950 encoder.PutUint8(uint8(self.SrcDst))
1951 encoder.PutUint8(uint8(self.NBits))
1952
1953 return nil
1954}
1955
1956func DecodeFlowModSpec(decoder *goloxi.Decoder) (IFlowModSpec, error) {
1957 _flowmodspec := &FlowModSpec{}
1958 if decoder.Length() < 2 {
1959 return nil, fmt.Errorf("FlowModSpec packet too short: %d < 2", decoder.Length())
1960 }
1961 _flowmodspec.SrcDst = uint8(decoder.ReadByte())
1962 _flowmodspec.NBits = uint8(decoder.ReadByte())
1963 if _flowmodspec.SrcDst == 0 && _flowmodspec.NBits == 0 {
1964 return nil, nil
1965 }
1966
1967 switch _flowmodspec.SrcDst {
1968 case 0:
1969 return DecodeFlowModSpecSrc0Dst0(_flowmodspec, decoder)
1970 case 8:
1971 return DecodeFlowModSpecSrc0Dst1(_flowmodspec, decoder)
1972 case 40:
1973 return DecodeFlowModSpecSrc1Dst1(_flowmodspec, decoder)
1974 case 16:
1975 return DecodeFlowModSpecSrc0Dst2(_flowmodspec, decoder)
1976 case 32:
1977 return DecodeFlowModSpecSrc1Dst0(_flowmodspec, decoder)
1978 default:
1979 return nil, fmt.Errorf("Invalid type '%d' for 'FlowModSpec'", _flowmodspec.SrcDst)
1980 }
1981}
1982
1983func NewFlowModSpec(_src_dst uint8) *FlowModSpec {
1984 obj := &FlowModSpec{}
1985 obj.SrcDst = _src_dst
1986 return obj
1987}
1988
1989type FlowModSpecSrc0Dst0 struct {
1990 *FlowModSpec
1991 Src goloxi.IOxmId
1992 SrcOfs uint16
1993 Dst goloxi.IOxmId
1994 DstOfs uint16
1995}
1996
1997type IFlowModSpecSrc0Dst0 interface {
1998 IFlowModSpec
1999 GetSrc() goloxi.IOxmId
2000 GetSrcOfs() uint16
2001 GetDst() goloxi.IOxmId
2002 GetDstOfs() uint16
2003}
2004
2005func (self *FlowModSpecSrc0Dst0) GetSrc() goloxi.IOxmId {
2006 return self.Src
2007}
2008
2009func (self *FlowModSpecSrc0Dst0) SetSrc(v goloxi.IOxmId) {
2010 self.Src = v
2011}
2012
2013func (self *FlowModSpecSrc0Dst0) GetSrcOfs() uint16 {
2014 return self.SrcOfs
2015}
2016
2017func (self *FlowModSpecSrc0Dst0) SetSrcOfs(v uint16) {
2018 self.SrcOfs = v
2019}
2020
2021func (self *FlowModSpecSrc0Dst0) GetDst() goloxi.IOxmId {
2022 return self.Dst
2023}
2024
2025func (self *FlowModSpecSrc0Dst0) SetDst(v goloxi.IOxmId) {
2026 self.Dst = v
2027}
2028
2029func (self *FlowModSpecSrc0Dst0) GetDstOfs() uint16 {
2030 return self.DstOfs
2031}
2032
2033func (self *FlowModSpecSrc0Dst0) SetDstOfs(v uint16) {
2034 self.DstOfs = v
2035}
2036
2037func (self *FlowModSpecSrc0Dst0) Serialize(encoder *goloxi.Encoder) error {
2038 if err := self.FlowModSpec.Serialize(encoder); err != nil {
2039 return err
2040 }
2041
2042 self.Src.Serialize(encoder)
2043 encoder.PutUint16(uint16(self.SrcOfs))
2044 self.Dst.Serialize(encoder)
2045 encoder.PutUint16(uint16(self.DstOfs))
2046
2047 return nil
2048}
2049
2050func DecodeFlowModSpecSrc0Dst0(parent *FlowModSpec, decoder *goloxi.Decoder) (IFlowModSpecSrc0Dst0, error) {
2051 _flowmodspecsrc0dst0 := &FlowModSpecSrc0Dst0{FlowModSpec: parent}
2052 if decoder.Length() < 12 {
2053 return nil, fmt.Errorf("FlowModSpecSrc0Dst0 packet too short: %d < 12", decoder.Length())
2054 }
2055 if obj, err := DecodeOxmId(decoder); err != nil {
2056 return nil, err
2057 } else {
2058 _flowmodspecsrc0dst0.Src = obj
2059 }
2060
2061 _flowmodspecsrc0dst0.SrcOfs = uint16(decoder.ReadUint16())
2062 if obj, err := DecodeOxmId(decoder); err != nil {
2063 return nil, err
2064 } else {
2065 _flowmodspecsrc0dst0.Dst = obj
2066 }
2067
2068 _flowmodspecsrc0dst0.DstOfs = uint16(decoder.ReadUint16())
2069 return _flowmodspecsrc0dst0, nil
2070}
2071
2072func NewFlowModSpecSrc0Dst0(_n_bits uint8) *FlowModSpecSrc0Dst0 {
2073 obj := &FlowModSpecSrc0Dst0{
2074 FlowModSpec: NewFlowModSpec(0),
2075 }
2076 obj.NBits = _n_bits
2077 return obj
2078}
2079
2080type FlowModSpecSrc0Dst1 struct {
2081 *FlowModSpec
2082 Src goloxi.IOxmId
2083 SrcOfs uint16
2084 Dst goloxi.IOxmId
2085 DstOfs uint16
2086}
2087
2088type IFlowModSpecSrc0Dst1 interface {
2089 IFlowModSpec
2090 GetSrc() goloxi.IOxmId
2091 GetSrcOfs() uint16
2092 GetDst() goloxi.IOxmId
2093 GetDstOfs() uint16
2094}
2095
2096func (self *FlowModSpecSrc0Dst1) GetSrc() goloxi.IOxmId {
2097 return self.Src
2098}
2099
2100func (self *FlowModSpecSrc0Dst1) SetSrc(v goloxi.IOxmId) {
2101 self.Src = v
2102}
2103
2104func (self *FlowModSpecSrc0Dst1) GetSrcOfs() uint16 {
2105 return self.SrcOfs
2106}
2107
2108func (self *FlowModSpecSrc0Dst1) SetSrcOfs(v uint16) {
2109 self.SrcOfs = v
2110}
2111
2112func (self *FlowModSpecSrc0Dst1) GetDst() goloxi.IOxmId {
2113 return self.Dst
2114}
2115
2116func (self *FlowModSpecSrc0Dst1) SetDst(v goloxi.IOxmId) {
2117 self.Dst = v
2118}
2119
2120func (self *FlowModSpecSrc0Dst1) GetDstOfs() uint16 {
2121 return self.DstOfs
2122}
2123
2124func (self *FlowModSpecSrc0Dst1) SetDstOfs(v uint16) {
2125 self.DstOfs = v
2126}
2127
2128func (self *FlowModSpecSrc0Dst1) Serialize(encoder *goloxi.Encoder) error {
2129 if err := self.FlowModSpec.Serialize(encoder); err != nil {
2130 return err
2131 }
2132
2133 self.Src.Serialize(encoder)
2134 encoder.PutUint16(uint16(self.SrcOfs))
2135 self.Dst.Serialize(encoder)
2136 encoder.PutUint16(uint16(self.DstOfs))
2137
2138 return nil
2139}
2140
2141func DecodeFlowModSpecSrc0Dst1(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc0Dst1, error) {
2142 _flowmodspecsrc0dst1 := &FlowModSpecSrc0Dst1{FlowModSpec: parent}
2143 if decoder.Length() < 12 {
2144 return nil, fmt.Errorf("FlowModSpecSrc0Dst1 packet too short: %d < 12", decoder.Length())
2145 }
2146 if obj, err := DecodeOxmId(decoder); err != nil {
2147 return nil, err
2148 } else {
2149 _flowmodspecsrc0dst1.Src = obj
2150 }
2151
2152 _flowmodspecsrc0dst1.SrcOfs = uint16(decoder.ReadUint16())
2153 if obj, err := DecodeOxmId(decoder); err != nil {
2154 return nil, err
2155 } else {
2156 _flowmodspecsrc0dst1.Dst = obj
2157 }
2158
2159 _flowmodspecsrc0dst1.DstOfs = uint16(decoder.ReadUint16())
2160 return _flowmodspecsrc0dst1, nil
2161}
2162
2163func NewFlowModSpecSrc0Dst1() *FlowModSpecSrc0Dst1 {
2164 obj := &FlowModSpecSrc0Dst1{
2165 FlowModSpec: NewFlowModSpec(8),
2166 }
2167 return obj
2168}
2169
2170type FlowModSpecSrc0Dst2 struct {
2171 *FlowModSpec
2172 Src goloxi.IOxmId
2173 SrcOfs uint16
2174}
2175
2176type IFlowModSpecSrc0Dst2 interface {
2177 IFlowModSpec
2178 GetSrc() goloxi.IOxmId
2179 GetSrcOfs() uint16
2180}
2181
2182func (self *FlowModSpecSrc0Dst2) GetSrc() goloxi.IOxmId {
2183 return self.Src
2184}
2185
2186func (self *FlowModSpecSrc0Dst2) SetSrc(v goloxi.IOxmId) {
2187 self.Src = v
2188}
2189
2190func (self *FlowModSpecSrc0Dst2) GetSrcOfs() uint16 {
2191 return self.SrcOfs
2192}
2193
2194func (self *FlowModSpecSrc0Dst2) SetSrcOfs(v uint16) {
2195 self.SrcOfs = v
2196}
2197
2198func (self *FlowModSpecSrc0Dst2) Serialize(encoder *goloxi.Encoder) error {
2199 if err := self.FlowModSpec.Serialize(encoder); err != nil {
2200 return err
2201 }
2202
2203 self.Src.Serialize(encoder)
2204 encoder.PutUint16(uint16(self.SrcOfs))
2205
2206 return nil
2207}
2208
2209func DecodeFlowModSpecSrc0Dst2(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc0Dst2, error) {
2210 _flowmodspecsrc0dst2 := &FlowModSpecSrc0Dst2{FlowModSpec: parent}
2211 if decoder.Length() < 6 {
2212 return nil, fmt.Errorf("FlowModSpecSrc0Dst2 packet too short: %d < 6", decoder.Length())
2213 }
2214 if obj, err := DecodeOxmId(decoder); err != nil {
2215 return nil, err
2216 } else {
2217 _flowmodspecsrc0dst2.Src = obj
2218 }
2219
2220 _flowmodspecsrc0dst2.SrcOfs = uint16(decoder.ReadUint16())
2221 return _flowmodspecsrc0dst2, nil
2222}
2223
2224func NewFlowModSpecSrc0Dst2() *FlowModSpecSrc0Dst2 {
2225 obj := &FlowModSpecSrc0Dst2{
2226 FlowModSpec: NewFlowModSpec(16),
2227 }
2228 return obj
2229}
2230
2231type FlowModSpecSrc1Dst0 struct {
2232 *FlowModSpec
2233 Src []byte
2234 Dst goloxi.IOxmId
2235 DstOfs uint16
2236}
2237
2238type IFlowModSpecSrc1Dst0 interface {
2239 IFlowModSpec
2240 GetSrc() []byte
2241 GetDst() goloxi.IOxmId
2242 GetDstOfs() uint16
2243}
2244
2245func (self *FlowModSpecSrc1Dst0) GetSrc() []byte {
2246 return self.Src
2247}
2248
2249func (self *FlowModSpecSrc1Dst0) SetSrc(v []byte) {
2250 self.Src = v
2251}
2252
2253func (self *FlowModSpecSrc1Dst0) GetDst() goloxi.IOxmId {
2254 return self.Dst
2255}
2256
2257func (self *FlowModSpecSrc1Dst0) SetDst(v goloxi.IOxmId) {
2258 self.Dst = v
2259}
2260
2261func (self *FlowModSpecSrc1Dst0) GetDstOfs() uint16 {
2262 return self.DstOfs
2263}
2264
2265func (self *FlowModSpecSrc1Dst0) SetDstOfs(v uint16) {
2266 self.DstOfs = v
2267}
2268
2269func (self *FlowModSpecSrc1Dst0) Serialize(encoder *goloxi.Encoder) error {
2270 if err := self.FlowModSpec.Serialize(encoder); err != nil {
2271 return err
2272 }
2273
2274 encoder.Write(self.Src)
2275 self.Dst.Serialize(encoder)
2276 encoder.PutUint16(uint16(self.DstOfs))
2277
2278 return nil
2279}
2280
2281func DecodeFlowModSpecSrc1Dst0(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc1Dst0, error) {
2282 _flowmodspecsrc1dst0 := &FlowModSpecSrc1Dst0{FlowModSpec: parent}
2283 if decoder.Length() < 6 {
2284 return nil, fmt.Errorf("FlowModSpecSrc1Dst0 packet too short: %d < 6", decoder.Length())
2285 }
2286 _flowmodspecsrc1dst0.Src = decoder.SliceDecoder(int((_flowmodspecsrc1dst0.NBits+15)/16*2), 0).Read(int(_flowmodspecsrc1dst0.NBits))
2287 if obj, err := DecodeOxmId(decoder); err != nil {
2288 return nil, err
2289 } else {
2290 _flowmodspecsrc1dst0.Dst = obj
2291 }
2292
2293 _flowmodspecsrc1dst0.DstOfs = uint16(decoder.ReadUint16())
2294 return _flowmodspecsrc1dst0, nil
2295}
2296
2297func NewFlowModSpecSrc1Dst0() *FlowModSpecSrc1Dst0 {
2298 obj := &FlowModSpecSrc1Dst0{
2299 FlowModSpec: NewFlowModSpec(32),
2300 }
2301 return obj
2302}
2303
2304type FlowModSpecSrc1Dst1 struct {
2305 *FlowModSpec
2306 Src []byte
2307 Dst goloxi.IOxmId
2308 DstOfs uint16
2309}
2310
2311type IFlowModSpecSrc1Dst1 interface {
2312 IFlowModSpec
2313 GetSrc() []byte
2314 GetDst() goloxi.IOxmId
2315 GetDstOfs() uint16
2316}
2317
2318func (self *FlowModSpecSrc1Dst1) GetSrc() []byte {
2319 return self.Src
2320}
2321
2322func (self *FlowModSpecSrc1Dst1) SetSrc(v []byte) {
2323 self.Src = v
2324}
2325
2326func (self *FlowModSpecSrc1Dst1) GetDst() goloxi.IOxmId {
2327 return self.Dst
2328}
2329
2330func (self *FlowModSpecSrc1Dst1) SetDst(v goloxi.IOxmId) {
2331 self.Dst = v
2332}
2333
2334func (self *FlowModSpecSrc1Dst1) GetDstOfs() uint16 {
2335 return self.DstOfs
2336}
2337
2338func (self *FlowModSpecSrc1Dst1) SetDstOfs(v uint16) {
2339 self.DstOfs = v
2340}
2341
2342func (self *FlowModSpecSrc1Dst1) Serialize(encoder *goloxi.Encoder) error {
2343 if err := self.FlowModSpec.Serialize(encoder); err != nil {
2344 return err
2345 }
2346
2347 encoder.Write(self.Src)
2348 self.Dst.Serialize(encoder)
2349 encoder.PutUint16(uint16(self.DstOfs))
2350
2351 return nil
2352}
2353
2354func DecodeFlowModSpecSrc1Dst1(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc1Dst1, error) {
2355 _flowmodspecsrc1dst1 := &FlowModSpecSrc1Dst1{FlowModSpec: parent}
2356 if decoder.Length() < 6 {
2357 return nil, fmt.Errorf("FlowModSpecSrc1Dst1 packet too short: %d < 6", decoder.Length())
2358 }
2359 _flowmodspecsrc1dst1.Src = decoder.SliceDecoder(int((_flowmodspecsrc1dst1.NBits+15)/16*2), 0).Read(int(_flowmodspecsrc1dst1.NBits))
2360 if obj, err := DecodeOxmId(decoder); err != nil {
2361 return nil, err
2362 } else {
2363 _flowmodspecsrc1dst1.Dst = obj
2364 }
2365
2366 _flowmodspecsrc1dst1.DstOfs = uint16(decoder.ReadUint16())
2367 return _flowmodspecsrc1dst1, nil
2368}
2369
2370func NewFlowModSpecSrc1Dst1() *FlowModSpecSrc1Dst1 {
2371 obj := &FlowModSpecSrc1Dst1{
2372 FlowModSpec: NewFlowModSpec(40),
2373 }
2374 return obj
2375}
2376
2377type FlowStatsEntry struct {
2378 Length uint16
2379 TableId uint8
2380 DurationSec uint32
2381 DurationNsec uint32
2382 Priority uint16
2383 IdleTimeout uint16
2384 HardTimeout uint16
2385 Cookie uint64
2386 PacketCount uint64
2387 ByteCount uint64
2388 Match Match
2389 Instructions []IInstruction
2390}
2391
2392type IFlowStatsEntry interface {
2393 goloxi.Serializable
2394 GetLength() uint16
2395 GetTableId() uint8
2396 GetDurationSec() uint32
2397 GetDurationNsec() uint32
2398 GetPriority() uint16
2399 GetIdleTimeout() uint16
2400 GetHardTimeout() uint16
2401 GetCookie() uint64
2402 GetPacketCount() uint64
2403 GetByteCount() uint64
2404 GetMatch() Match
2405 GetInstructions() []IInstruction
2406}
2407
2408func (self *FlowStatsEntry) GetLength() uint16 {
2409 return self.Length
2410}
2411
2412func (self *FlowStatsEntry) SetLength(v uint16) {
2413 self.Length = v
2414}
2415
2416func (self *FlowStatsEntry) GetTableId() uint8 {
2417 return self.TableId
2418}
2419
2420func (self *FlowStatsEntry) SetTableId(v uint8) {
2421 self.TableId = v
2422}
2423
2424func (self *FlowStatsEntry) GetDurationSec() uint32 {
2425 return self.DurationSec
2426}
2427
2428func (self *FlowStatsEntry) SetDurationSec(v uint32) {
2429 self.DurationSec = v
2430}
2431
2432func (self *FlowStatsEntry) GetDurationNsec() uint32 {
2433 return self.DurationNsec
2434}
2435
2436func (self *FlowStatsEntry) SetDurationNsec(v uint32) {
2437 self.DurationNsec = v
2438}
2439
2440func (self *FlowStatsEntry) GetPriority() uint16 {
2441 return self.Priority
2442}
2443
2444func (self *FlowStatsEntry) SetPriority(v uint16) {
2445 self.Priority = v
2446}
2447
2448func (self *FlowStatsEntry) GetIdleTimeout() uint16 {
2449 return self.IdleTimeout
2450}
2451
2452func (self *FlowStatsEntry) SetIdleTimeout(v uint16) {
2453 self.IdleTimeout = v
2454}
2455
2456func (self *FlowStatsEntry) GetHardTimeout() uint16 {
2457 return self.HardTimeout
2458}
2459
2460func (self *FlowStatsEntry) SetHardTimeout(v uint16) {
2461 self.HardTimeout = v
2462}
2463
2464func (self *FlowStatsEntry) GetCookie() uint64 {
2465 return self.Cookie
2466}
2467
2468func (self *FlowStatsEntry) SetCookie(v uint64) {
2469 self.Cookie = v
2470}
2471
2472func (self *FlowStatsEntry) GetPacketCount() uint64 {
2473 return self.PacketCount
2474}
2475
2476func (self *FlowStatsEntry) SetPacketCount(v uint64) {
2477 self.PacketCount = v
2478}
2479
2480func (self *FlowStatsEntry) GetByteCount() uint64 {
2481 return self.ByteCount
2482}
2483
2484func (self *FlowStatsEntry) SetByteCount(v uint64) {
2485 self.ByteCount = v
2486}
2487
2488func (self *FlowStatsEntry) GetMatch() Match {
2489 return self.Match
2490}
2491
2492func (self *FlowStatsEntry) SetMatch(v Match) {
2493 self.Match = v
2494}
2495
2496func (self *FlowStatsEntry) GetInstructions() []IInstruction {
2497 return self.Instructions
2498}
2499
2500func (self *FlowStatsEntry) SetInstructions(v []IInstruction) {
2501 self.Instructions = v
2502}
2503
2504func (self *FlowStatsEntry) Serialize(encoder *goloxi.Encoder) error {
2505 startIndex := len(encoder.Bytes())
2506
2507 encoder.PutUint16(uint16(self.Length))
2508 encoder.PutUint8(uint8(self.TableId))
2509 encoder.Write(bytes.Repeat([]byte{0}, 1))
2510 encoder.PutUint32(uint32(self.DurationSec))
2511 encoder.PutUint32(uint32(self.DurationNsec))
2512 encoder.PutUint16(uint16(self.Priority))
2513 encoder.PutUint16(uint16(self.IdleTimeout))
2514 encoder.PutUint16(uint16(self.HardTimeout))
2515 encoder.Write(bytes.Repeat([]byte{0}, 6))
2516 encoder.PutUint64(uint64(self.Cookie))
2517 encoder.PutUint64(uint64(self.PacketCount))
2518 encoder.PutUint64(uint64(self.ByteCount))
2519 if err := self.Match.Serialize(encoder); err != nil {
2520 return err
2521 }
2522
2523 for _, obj := range self.Instructions {
2524 if err := obj.Serialize(encoder); err != nil {
2525 return err
2526 }
2527 }
2528 length := len(encoder.Bytes()) - startIndex
2529
2530 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
2531
2532 return nil
2533}
2534
2535func DecodeFlowStatsEntry(decoder *goloxi.Decoder) (*FlowStatsEntry, error) {
2536 _flowstatsentry := &FlowStatsEntry{}
2537 if decoder.Length() < 136 {
2538 return nil, fmt.Errorf("FlowStatsEntry packet too short: %d < 136", decoder.Length())
2539 }
2540 _flowstatsentry.Length = uint16(decoder.ReadUint16())
2541 oldDecoder := decoder
2542 defer func() { decoder = oldDecoder }()
2543 decoder = decoder.SliceDecoder(int(_flowstatsentry.Length), 2+0)
2544 _flowstatsentry.TableId = uint8(decoder.ReadByte())
2545 decoder.Skip(1)
2546 _flowstatsentry.DurationSec = uint32(decoder.ReadUint32())
2547 _flowstatsentry.DurationNsec = uint32(decoder.ReadUint32())
2548 _flowstatsentry.Priority = uint16(decoder.ReadUint16())
2549 _flowstatsentry.IdleTimeout = uint16(decoder.ReadUint16())
2550 _flowstatsentry.HardTimeout = uint16(decoder.ReadUint16())
2551 decoder.Skip(6)
2552 _flowstatsentry.Cookie = uint64(decoder.ReadUint64())
2553 _flowstatsentry.PacketCount = uint64(decoder.ReadUint64())
2554 _flowstatsentry.ByteCount = uint64(decoder.ReadUint64())
2555 if err := _flowstatsentry.Match.Decode(decoder); err != nil {
2556 return nil, err
2557 }
2558
2559 for decoder.Length() >= 8 {
2560 item, err := DecodeInstruction(decoder)
2561 if err != nil {
2562 return nil, err
2563 }
2564 if item != nil {
2565 _flowstatsentry.Instructions = append(_flowstatsentry.Instructions, item)
2566 }
2567 }
2568 return _flowstatsentry, nil
2569}
2570
2571func NewFlowStatsEntry() *FlowStatsEntry {
2572 obj := &FlowStatsEntry{}
2573 return obj
2574}
2575
2576type GroupDescStatsEntry struct {
2577 Length uint16
2578 GroupType GroupType
2579 GroupId uint32
2580 Buckets []*Bucket
2581}
2582
2583type IGroupDescStatsEntry interface {
2584 goloxi.Serializable
2585 GetLength() uint16
2586 GetGroupType() GroupType
2587 GetGroupId() uint32
2588 GetBuckets() []*Bucket
2589}
2590
2591func (self *GroupDescStatsEntry) GetLength() uint16 {
2592 return self.Length
2593}
2594
2595func (self *GroupDescStatsEntry) SetLength(v uint16) {
2596 self.Length = v
2597}
2598
2599func (self *GroupDescStatsEntry) GetGroupType() GroupType {
2600 return self.GroupType
2601}
2602
2603func (self *GroupDescStatsEntry) SetGroupType(v GroupType) {
2604 self.GroupType = v
2605}
2606
2607func (self *GroupDescStatsEntry) GetGroupId() uint32 {
2608 return self.GroupId
2609}
2610
2611func (self *GroupDescStatsEntry) SetGroupId(v uint32) {
2612 self.GroupId = v
2613}
2614
2615func (self *GroupDescStatsEntry) GetBuckets() []*Bucket {
2616 return self.Buckets
2617}
2618
2619func (self *GroupDescStatsEntry) SetBuckets(v []*Bucket) {
2620 self.Buckets = v
2621}
2622
2623func (self *GroupDescStatsEntry) Serialize(encoder *goloxi.Encoder) error {
2624 startIndex := len(encoder.Bytes())
2625
2626 encoder.PutUint16(uint16(self.Length))
2627 encoder.PutUint8(uint8(self.GroupType))
2628 encoder.Write(bytes.Repeat([]byte{0}, 1))
2629 encoder.PutUint32(uint32(self.GroupId))
2630 for _, obj := range self.Buckets {
2631 if err := obj.Serialize(encoder); err != nil {
2632 return err
2633 }
2634 }
2635 length := len(encoder.Bytes()) - startIndex
2636
2637 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
2638
2639 return nil
2640}
2641
2642func DecodeGroupDescStatsEntry(decoder *goloxi.Decoder) (*GroupDescStatsEntry, error) {
2643 _groupdescstatsentry := &GroupDescStatsEntry{}
2644 if decoder.Length() < 8 {
2645 return nil, fmt.Errorf("GroupDescStatsEntry packet too short: %d < 8", decoder.Length())
2646 }
2647 _groupdescstatsentry.Length = uint16(decoder.ReadUint16())
2648 oldDecoder := decoder
2649 defer func() { decoder = oldDecoder }()
2650 decoder = decoder.SliceDecoder(int(_groupdescstatsentry.Length), 2+0)
2651 _groupdescstatsentry.GroupType = GroupType(decoder.ReadByte())
2652 decoder.Skip(1)
2653 _groupdescstatsentry.GroupId = uint32(decoder.ReadUint32())
2654
2655 for decoder.Length() >= 16 {
2656 item, err := DecodeBucket(decoder)
2657 if err != nil {
2658 return nil, err
2659 }
2660 if item != nil {
2661 _groupdescstatsentry.Buckets = append(_groupdescstatsentry.Buckets, item)
2662 }
2663 }
2664 return _groupdescstatsentry, nil
2665}
2666
2667func NewGroupDescStatsEntry() *GroupDescStatsEntry {
2668 obj := &GroupDescStatsEntry{}
2669 return obj
2670}
2671
2672type GroupStatsEntry struct {
2673 Length uint16
2674 GroupId uint32
2675 RefCount uint32
2676 PacketCount uint64
2677 ByteCount uint64
2678 BucketStats []*BucketCounter
2679}
2680
2681type IGroupStatsEntry interface {
2682 goloxi.Serializable
2683 GetLength() uint16
2684 GetGroupId() uint32
2685 GetRefCount() uint32
2686 GetPacketCount() uint64
2687 GetByteCount() uint64
2688 GetBucketStats() []*BucketCounter
2689}
2690
2691func (self *GroupStatsEntry) GetLength() uint16 {
2692 return self.Length
2693}
2694
2695func (self *GroupStatsEntry) SetLength(v uint16) {
2696 self.Length = v
2697}
2698
2699func (self *GroupStatsEntry) GetGroupId() uint32 {
2700 return self.GroupId
2701}
2702
2703func (self *GroupStatsEntry) SetGroupId(v uint32) {
2704 self.GroupId = v
2705}
2706
2707func (self *GroupStatsEntry) GetRefCount() uint32 {
2708 return self.RefCount
2709}
2710
2711func (self *GroupStatsEntry) SetRefCount(v uint32) {
2712 self.RefCount = v
2713}
2714
2715func (self *GroupStatsEntry) GetPacketCount() uint64 {
2716 return self.PacketCount
2717}
2718
2719func (self *GroupStatsEntry) SetPacketCount(v uint64) {
2720 self.PacketCount = v
2721}
2722
2723func (self *GroupStatsEntry) GetByteCount() uint64 {
2724 return self.ByteCount
2725}
2726
2727func (self *GroupStatsEntry) SetByteCount(v uint64) {
2728 self.ByteCount = v
2729}
2730
2731func (self *GroupStatsEntry) GetBucketStats() []*BucketCounter {
2732 return self.BucketStats
2733}
2734
2735func (self *GroupStatsEntry) SetBucketStats(v []*BucketCounter) {
2736 self.BucketStats = v
2737}
2738
2739func (self *GroupStatsEntry) Serialize(encoder *goloxi.Encoder) error {
2740 startIndex := len(encoder.Bytes())
2741
2742 encoder.PutUint16(uint16(self.Length))
2743 encoder.Write(bytes.Repeat([]byte{0}, 2))
2744 encoder.PutUint32(uint32(self.GroupId))
2745 encoder.PutUint32(uint32(self.RefCount))
2746 encoder.Write(bytes.Repeat([]byte{0}, 4))
2747 encoder.PutUint64(uint64(self.PacketCount))
2748 encoder.PutUint64(uint64(self.ByteCount))
2749 for _, obj := range self.BucketStats {
2750 if err := obj.Serialize(encoder); err != nil {
2751 return err
2752 }
2753 }
2754 length := len(encoder.Bytes()) - startIndex
2755
2756 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
2757
2758 return nil
2759}
2760
2761func DecodeGroupStatsEntry(decoder *goloxi.Decoder) (*GroupStatsEntry, error) {
2762 _groupstatsentry := &GroupStatsEntry{}
2763 if decoder.Length() < 32 {
2764 return nil, fmt.Errorf("GroupStatsEntry packet too short: %d < 32", decoder.Length())
2765 }
2766 _groupstatsentry.Length = uint16(decoder.ReadUint16())
2767 oldDecoder := decoder
2768 defer func() { decoder = oldDecoder }()
2769 decoder = decoder.SliceDecoder(int(_groupstatsentry.Length), 2+0)
2770 decoder.Skip(2)
2771 _groupstatsentry.GroupId = uint32(decoder.ReadUint32())
2772 _groupstatsentry.RefCount = uint32(decoder.ReadUint32())
2773 decoder.Skip(4)
2774 _groupstatsentry.PacketCount = uint64(decoder.ReadUint64())
2775 _groupstatsentry.ByteCount = uint64(decoder.ReadUint64())
2776
2777 for decoder.Length() >= 16 {
2778 item, err := DecodeBucketCounter(decoder)
2779 if err != nil {
2780 return nil, err
2781 }
2782 if item != nil {
2783 _groupstatsentry.BucketStats = append(_groupstatsentry.BucketStats, item)
2784 }
2785 }
2786 return _groupstatsentry, nil
2787}
2788
2789func NewGroupStatsEntry() *GroupStatsEntry {
2790 obj := &GroupStatsEntry{}
2791 return obj
2792}
2793
2794type InstructionId struct {
2795 Type uint16
2796 Len uint16
2797}
2798
2799type IInstructionId interface {
2800 goloxi.Serializable
2801 GetType() uint16
2802 GetLen() uint16
2803}
2804
2805func (self *InstructionId) GetType() uint16 {
2806 return self.Type
2807}
2808
2809func (self *InstructionId) SetType(v uint16) {
2810 self.Type = v
2811}
2812
2813func (self *InstructionId) GetLen() uint16 {
2814 return self.Len
2815}
2816
2817func (self *InstructionId) SetLen(v uint16) {
2818 self.Len = v
2819}
2820
2821func (self *InstructionId) Serialize(encoder *goloxi.Encoder) error {
2822
2823 encoder.PutUint16(uint16(self.Type))
2824 encoder.PutUint16(uint16(self.Len))
2825
2826 return nil
2827}
2828
2829func DecodeInstructionId(decoder *goloxi.Decoder) (IInstructionId, error) {
2830 _instructionid := &InstructionId{}
2831 if decoder.Length() < 4 {
2832 return nil, fmt.Errorf("InstructionId packet too short: %d < 4", decoder.Length())
2833 }
2834 _instructionid.Type = uint16(decoder.ReadUint16())
2835 _instructionid.Len = uint16(decoder.ReadUint16())
2836 oldDecoder := decoder
2837 defer func() { decoder = oldDecoder }()
2838 decoder = decoder.SliceDecoder(int(_instructionid.Len), 2+2)
2839
2840 switch _instructionid.Type {
2841 case 1:
2842 return DecodeInstructionIdGotoTable(_instructionid, decoder)
2843 case 2:
2844 return DecodeInstructionIdWriteMetadata(_instructionid, decoder)
2845 case 3:
2846 return DecodeInstructionIdWriteActions(_instructionid, decoder)
2847 case 4:
2848 return DecodeInstructionIdApplyActions(_instructionid, decoder)
2849 case 5:
2850 return DecodeInstructionIdClearActions(_instructionid, decoder)
2851 case 65535:
2852 return DecodeInstructionIdExperimenter(_instructionid, decoder)
2853 default:
2854 return nil, fmt.Errorf("Invalid type '%d' for 'InstructionId'", _instructionid.Type)
2855 }
2856}
2857
2858func NewInstructionId(_type uint16) *InstructionId {
2859 obj := &InstructionId{}
2860 obj.Type = _type
2861 return obj
2862}
2863
2864type InstructionIdApplyActions struct {
2865 *InstructionId
2866}
2867
2868type IInstructionIdApplyActions interface {
2869 IInstructionId
2870}
2871
2872func (self *InstructionIdApplyActions) Serialize(encoder *goloxi.Encoder) error {
2873 startIndex := len(encoder.Bytes())
2874 if err := self.InstructionId.Serialize(encoder); err != nil {
2875 return err
2876 }
2877 length := len(encoder.Bytes()) - startIndex
2878
2879 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
2880
2881 return nil
2882}
2883
2884func DecodeInstructionIdApplyActions(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdApplyActions, error) {
2885 _instructionidapplyactions := &InstructionIdApplyActions{InstructionId: parent}
2886 return _instructionidapplyactions, nil
2887}
2888
2889func NewInstructionIdApplyActions() *InstructionIdApplyActions {
2890 obj := &InstructionIdApplyActions{
2891 InstructionId: NewInstructionId(4),
2892 }
2893 return obj
2894}
2895
2896type InstructionIdClearActions struct {
2897 *InstructionId
2898}
2899
2900type IInstructionIdClearActions interface {
2901 IInstructionId
2902}
2903
2904func (self *InstructionIdClearActions) Serialize(encoder *goloxi.Encoder) error {
2905 startIndex := len(encoder.Bytes())
2906 if err := self.InstructionId.Serialize(encoder); err != nil {
2907 return err
2908 }
2909 length := len(encoder.Bytes()) - startIndex
2910
2911 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
2912
2913 return nil
2914}
2915
2916func DecodeInstructionIdClearActions(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdClearActions, error) {
2917 _instructionidclearactions := &InstructionIdClearActions{InstructionId: parent}
2918 return _instructionidclearactions, nil
2919}
2920
2921func NewInstructionIdClearActions() *InstructionIdClearActions {
2922 obj := &InstructionIdClearActions{
2923 InstructionId: NewInstructionId(5),
2924 }
2925 return obj
2926}
2927
2928type InstructionIdExperimenter struct {
2929 *InstructionId
2930 Experimenter uint32
2931}
2932
2933type IInstructionIdExperimenter interface {
2934 IInstructionId
2935 GetExperimenter() uint32
2936}
2937
2938func (self *InstructionIdExperimenter) GetExperimenter() uint32 {
2939 return self.Experimenter
2940}
2941
2942func (self *InstructionIdExperimenter) SetExperimenter(v uint32) {
2943 self.Experimenter = v
2944}
2945
2946func (self *InstructionIdExperimenter) Serialize(encoder *goloxi.Encoder) error {
2947 if err := self.InstructionId.Serialize(encoder); err != nil {
2948 return err
2949 }
2950
2951 encoder.PutUint32(uint32(self.Experimenter))
2952
2953 return nil
2954}
2955
2956func DecodeInstructionIdExperimenter(parent *InstructionId, decoder *goloxi.Decoder) (IInstructionIdExperimenter, error) {
2957 _instructionidexperimenter := &InstructionIdExperimenter{InstructionId: parent}
2958 if decoder.Length() < 4 {
2959 return nil, fmt.Errorf("InstructionIdExperimenter packet too short: %d < 4", decoder.Length())
2960 }
2961 _instructionidexperimenter.Experimenter = uint32(decoder.ReadUint32())
2962 return _instructionidexperimenter, nil
2963}
2964
2965func NewInstructionIdExperimenter(_experimenter uint32) *InstructionIdExperimenter {
2966 obj := &InstructionIdExperimenter{
2967 InstructionId: NewInstructionId(65535),
2968 }
2969 obj.Experimenter = _experimenter
2970 return obj
2971}
2972
2973type InstructionIdGotoTable struct {
2974 *InstructionId
2975}
2976
2977type IInstructionIdGotoTable interface {
2978 IInstructionId
2979}
2980
2981func (self *InstructionIdGotoTable) Serialize(encoder *goloxi.Encoder) error {
2982 startIndex := len(encoder.Bytes())
2983 if err := self.InstructionId.Serialize(encoder); err != nil {
2984 return err
2985 }
2986 length := len(encoder.Bytes()) - startIndex
2987
2988 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
2989
2990 return nil
2991}
2992
2993func DecodeInstructionIdGotoTable(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdGotoTable, error) {
2994 _instructionidgototable := &InstructionIdGotoTable{InstructionId: parent}
2995 return _instructionidgototable, nil
2996}
2997
2998func NewInstructionIdGotoTable() *InstructionIdGotoTable {
2999 obj := &InstructionIdGotoTable{
3000 InstructionId: NewInstructionId(1),
3001 }
3002 return obj
3003}
3004
3005type InstructionIdWriteActions struct {
3006 *InstructionId
3007}
3008
3009type IInstructionIdWriteActions interface {
3010 IInstructionId
3011}
3012
3013func (self *InstructionIdWriteActions) Serialize(encoder *goloxi.Encoder) error {
3014 startIndex := len(encoder.Bytes())
3015 if err := self.InstructionId.Serialize(encoder); err != nil {
3016 return err
3017 }
3018 length := len(encoder.Bytes()) - startIndex
3019
3020 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
3021
3022 return nil
3023}
3024
3025func DecodeInstructionIdWriteActions(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdWriteActions, error) {
3026 _instructionidwriteactions := &InstructionIdWriteActions{InstructionId: parent}
3027 return _instructionidwriteactions, nil
3028}
3029
3030func NewInstructionIdWriteActions() *InstructionIdWriteActions {
3031 obj := &InstructionIdWriteActions{
3032 InstructionId: NewInstructionId(3),
3033 }
3034 return obj
3035}
3036
3037type InstructionIdWriteMetadata struct {
3038 *InstructionId
3039}
3040
3041type IInstructionIdWriteMetadata interface {
3042 IInstructionId
3043}
3044
3045func (self *InstructionIdWriteMetadata) Serialize(encoder *goloxi.Encoder) error {
3046 startIndex := len(encoder.Bytes())
3047 if err := self.InstructionId.Serialize(encoder); err != nil {
3048 return err
3049 }
3050 length := len(encoder.Bytes()) - startIndex
3051
3052 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
3053
3054 return nil
3055}
3056
3057func DecodeInstructionIdWriteMetadata(parent *InstructionId, decoder *goloxi.Decoder) (*InstructionIdWriteMetadata, error) {
3058 _instructionidwritemetadata := &InstructionIdWriteMetadata{InstructionId: parent}
3059 return _instructionidwritemetadata, nil
3060}
3061
3062func NewInstructionIdWriteMetadata() *InstructionIdWriteMetadata {
3063 obj := &InstructionIdWriteMetadata{
3064 InstructionId: NewInstructionId(2),
3065 }
3066 return obj
3067}
3068
3069type MatchV2 struct {
3070 Type uint16
3071 Length uint16
3072 InPort Port
3073 Wildcards WcBmap
3074 EthSrc net.HardwareAddr
3075 EthSrcMask net.HardwareAddr
3076 EthDst net.HardwareAddr
3077 EthDstMask net.HardwareAddr
3078 VlanVid uint16
3079 VlanPcp uint8
3080 EthType uint16
3081 IpDscp uint8
3082 IpProto uint8
3083 Ipv4Src net.IP
3084 Ipv4SrcMask net.IP
3085 Ipv4Dst net.IP
3086 Ipv4DstMask net.IP
3087 TcpSrc uint16
3088 TcpDst uint16
3089 MplsLabel uint32
3090 MplsTc uint8
3091 Metadata uint64
3092 MetadataMask uint64
3093}
3094
3095type IMatchV2 interface {
3096 goloxi.Serializable
3097 GetType() uint16
3098 GetLength() uint16
3099 GetInPort() Port
3100 GetWildcards() WcBmap
3101 GetEthSrc() net.HardwareAddr
3102 GetEthSrcMask() net.HardwareAddr
3103 GetEthDst() net.HardwareAddr
3104 GetEthDstMask() net.HardwareAddr
3105 GetVlanVid() uint16
3106 GetVlanPcp() uint8
3107 GetEthType() uint16
3108 GetIpDscp() uint8
3109 GetIpProto() uint8
3110 GetIpv4Src() net.IP
3111 GetIpv4SrcMask() net.IP
3112 GetIpv4Dst() net.IP
3113 GetIpv4DstMask() net.IP
3114 GetTcpSrc() uint16
3115 GetTcpDst() uint16
3116 GetMplsLabel() uint32
3117 GetMplsTc() uint8
3118 GetMetadata() uint64
3119 GetMetadataMask() uint64
3120}
3121
3122func (self *MatchV2) GetType() uint16 {
3123 return self.Type
3124}
3125
3126func (self *MatchV2) SetType(v uint16) {
3127 self.Type = v
3128}
3129
3130func (self *MatchV2) GetLength() uint16 {
3131 return self.Length
3132}
3133
3134func (self *MatchV2) SetLength(v uint16) {
3135 self.Length = v
3136}
3137
3138func (self *MatchV2) GetInPort() Port {
3139 return self.InPort
3140}
3141
3142func (self *MatchV2) SetInPort(v Port) {
3143 self.InPort = v
3144}
3145
3146func (self *MatchV2) GetWildcards() WcBmap {
3147 return self.Wildcards
3148}
3149
3150func (self *MatchV2) SetWildcards(v WcBmap) {
3151 self.Wildcards = v
3152}
3153
3154func (self *MatchV2) GetEthSrc() net.HardwareAddr {
3155 return self.EthSrc
3156}
3157
3158func (self *MatchV2) SetEthSrc(v net.HardwareAddr) {
3159 self.EthSrc = v
3160}
3161
3162func (self *MatchV2) GetEthSrcMask() net.HardwareAddr {
3163 return self.EthSrcMask
3164}
3165
3166func (self *MatchV2) SetEthSrcMask(v net.HardwareAddr) {
3167 self.EthSrcMask = v
3168}
3169
3170func (self *MatchV2) GetEthDst() net.HardwareAddr {
3171 return self.EthDst
3172}
3173
3174func (self *MatchV2) SetEthDst(v net.HardwareAddr) {
3175 self.EthDst = v
3176}
3177
3178func (self *MatchV2) GetEthDstMask() net.HardwareAddr {
3179 return self.EthDstMask
3180}
3181
3182func (self *MatchV2) SetEthDstMask(v net.HardwareAddr) {
3183 self.EthDstMask = v
3184}
3185
3186func (self *MatchV2) GetVlanVid() uint16 {
3187 return self.VlanVid
3188}
3189
3190func (self *MatchV2) SetVlanVid(v uint16) {
3191 self.VlanVid = v
3192}
3193
3194func (self *MatchV2) GetVlanPcp() uint8 {
3195 return self.VlanPcp
3196}
3197
3198func (self *MatchV2) SetVlanPcp(v uint8) {
3199 self.VlanPcp = v
3200}
3201
3202func (self *MatchV2) GetEthType() uint16 {
3203 return self.EthType
3204}
3205
3206func (self *MatchV2) SetEthType(v uint16) {
3207 self.EthType = v
3208}
3209
3210func (self *MatchV2) GetIpDscp() uint8 {
3211 return self.IpDscp
3212}
3213
3214func (self *MatchV2) SetIpDscp(v uint8) {
3215 self.IpDscp = v
3216}
3217
3218func (self *MatchV2) GetIpProto() uint8 {
3219 return self.IpProto
3220}
3221
3222func (self *MatchV2) SetIpProto(v uint8) {
3223 self.IpProto = v
3224}
3225
3226func (self *MatchV2) GetIpv4Src() net.IP {
3227 return self.Ipv4Src
3228}
3229
3230func (self *MatchV2) SetIpv4Src(v net.IP) {
3231 self.Ipv4Src = v
3232}
3233
3234func (self *MatchV2) GetIpv4SrcMask() net.IP {
3235 return self.Ipv4SrcMask
3236}
3237
3238func (self *MatchV2) SetIpv4SrcMask(v net.IP) {
3239 self.Ipv4SrcMask = v
3240}
3241
3242func (self *MatchV2) GetIpv4Dst() net.IP {
3243 return self.Ipv4Dst
3244}
3245
3246func (self *MatchV2) SetIpv4Dst(v net.IP) {
3247 self.Ipv4Dst = v
3248}
3249
3250func (self *MatchV2) GetIpv4DstMask() net.IP {
3251 return self.Ipv4DstMask
3252}
3253
3254func (self *MatchV2) SetIpv4DstMask(v net.IP) {
3255 self.Ipv4DstMask = v
3256}
3257
3258func (self *MatchV2) GetTcpSrc() uint16 {
3259 return self.TcpSrc
3260}
3261
3262func (self *MatchV2) SetTcpSrc(v uint16) {
3263 self.TcpSrc = v
3264}
3265
3266func (self *MatchV2) GetTcpDst() uint16 {
3267 return self.TcpDst
3268}
3269
3270func (self *MatchV2) SetTcpDst(v uint16) {
3271 self.TcpDst = v
3272}
3273
3274func (self *MatchV2) GetMplsLabel() uint32 {
3275 return self.MplsLabel
3276}
3277
3278func (self *MatchV2) SetMplsLabel(v uint32) {
3279 self.MplsLabel = v
3280}
3281
3282func (self *MatchV2) GetMplsTc() uint8 {
3283 return self.MplsTc
3284}
3285
3286func (self *MatchV2) SetMplsTc(v uint8) {
3287 self.MplsTc = v
3288}
3289
3290func (self *MatchV2) GetMetadata() uint64 {
3291 return self.Metadata
3292}
3293
3294func (self *MatchV2) SetMetadata(v uint64) {
3295 self.Metadata = v
3296}
3297
3298func (self *MatchV2) GetMetadataMask() uint64 {
3299 return self.MetadataMask
3300}
3301
3302func (self *MatchV2) SetMetadataMask(v uint64) {
3303 self.MetadataMask = v
3304}
3305
3306func (self *MatchV2) Serialize(encoder *goloxi.Encoder) error {
3307 startIndex := len(encoder.Bytes())
3308
3309 encoder.PutUint16(uint16(self.Type))
3310 encoder.PutUint16(uint16(self.Length))
3311 self.InPort.Serialize(encoder)
3312 self.Wildcards.Serialize(encoder)
3313 encoder.Write(self.EthSrc)
3314 encoder.Write(self.EthSrcMask)
3315 encoder.Write(self.EthDst)
3316 encoder.Write(self.EthDstMask)
3317 encoder.PutUint16(uint16(self.VlanVid))
3318 encoder.PutUint8(uint8(self.VlanPcp))
3319 encoder.Write(bytes.Repeat([]byte{0}, 1))
3320 encoder.PutUint16(uint16(self.EthType))
3321 encoder.PutUint8(uint8(self.IpDscp))
3322 encoder.PutUint8(uint8(self.IpProto))
3323 encoder.Write(self.Ipv4Src.To4())
3324 encoder.Write(self.Ipv4SrcMask.To4())
3325 encoder.Write(self.Ipv4Dst.To4())
3326 encoder.Write(self.Ipv4DstMask.To4())
3327 encoder.PutUint16(uint16(self.TcpSrc))
3328 encoder.PutUint16(uint16(self.TcpDst))
3329 encoder.PutUint32(uint32(self.MplsLabel))
3330 encoder.PutUint8(uint8(self.MplsTc))
3331 encoder.Write(bytes.Repeat([]byte{0}, 3))
3332 encoder.PutUint64(uint64(self.Metadata))
3333 encoder.PutUint64(uint64(self.MetadataMask))
3334 length := len(encoder.Bytes()) - startIndex
3335
3336 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
3337
3338 return nil
3339}
3340func (self *MatchV2) Decode(decoder *goloxi.Decoder) error {
3341 if decoder.Length() < 88 {
3342 return fmt.Errorf("MatchV2 packet too short: %d < 88", decoder.Length())
3343 }
3344
3345 self.Type = uint16(decoder.ReadUint16())
3346 self.Length = uint16(decoder.ReadUint16())
3347 oldDecoder := decoder
3348 defer func() { decoder = oldDecoder }()
3349 decoder = decoder.SliceDecoder(int(self.Length), 2+2)
3350 self.InPort.Decode(decoder)
3351 self.Wildcards.Decode(decoder)
3352 self.EthSrc = net.HardwareAddr(decoder.Read(6))
3353 self.EthSrcMask = net.HardwareAddr(decoder.Read(6))
3354 self.EthDst = net.HardwareAddr(decoder.Read(6))
3355 self.EthDstMask = net.HardwareAddr(decoder.Read(6))
3356 self.VlanVid = uint16(decoder.ReadUint16())
3357 self.VlanPcp = uint8(decoder.ReadByte())
3358 decoder.Skip(1)
3359 self.EthType = uint16(decoder.ReadUint16())
3360 self.IpDscp = uint8(decoder.ReadByte())
3361 self.IpProto = uint8(decoder.ReadByte())
3362 self.Ipv4Src = net.IP(decoder.Read(4))
3363 self.Ipv4SrcMask = net.IP(decoder.Read(4))
3364 self.Ipv4Dst = net.IP(decoder.Read(4))
3365 self.Ipv4DstMask = net.IP(decoder.Read(4))
3366 self.TcpSrc = uint16(decoder.ReadUint16())
3367 self.TcpDst = uint16(decoder.ReadUint16())
3368 self.MplsLabel = uint32(decoder.ReadUint32())
3369 self.MplsTc = uint8(decoder.ReadByte())
3370 decoder.Skip(3)
3371 self.Metadata = uint64(decoder.ReadUint64())
3372 self.MetadataMask = uint64(decoder.ReadUint64())
3373
3374 return nil
3375}
3376
3377func NewMatchV2() *MatchV2 {
3378 obj := &MatchV2{}
3379 return obj
3380}
3381
3382type NiciraMatch struct {
3383 NxmEntries []goloxi.IOxm
3384}
3385
3386type INiciraMatch interface {
3387 goloxi.Serializable
3388 GetNxmEntries() []goloxi.IOxm
3389}
3390
3391func (self *NiciraMatch) GetNxmEntries() []goloxi.IOxm {
3392 return self.NxmEntries
3393}
3394
3395func (self *NiciraMatch) SetNxmEntries(v []goloxi.IOxm) {
3396 self.NxmEntries = v
3397}
3398
3399func (self *NiciraMatch) Serialize(encoder *goloxi.Encoder) error {
3400 startIndex := len(encoder.Bytes())
3401
3402 for _, obj := range self.NxmEntries {
3403 if err := obj.Serialize(encoder); err != nil {
3404 return err
3405 }
3406 }
3407 length := len(encoder.Bytes()) - startIndex
3408 alignedLength := ((length + 7) / 8 * 8)
3409
3410 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
3411
3412 return nil
3413}
3414func (self *NiciraMatch) Decode(decoder *goloxi.Decoder) error {
3415
3416 defer decoder.SkipAlign()
3417
3418 for decoder.Length() >= 4 {
3419 item, err := DecodeOxm(decoder)
3420 if err != nil {
3421 return err
3422 }
3423 if item != nil {
3424 self.NxmEntries = append(self.NxmEntries, item)
3425 }
3426 }
3427
3428 return nil
3429}
3430
3431func NewNiciraMatch() *NiciraMatch {
3432 obj := &NiciraMatch{}
3433 return obj
3434}
3435
3436type NiciraFlowStats struct {
3437 Length uint16
3438 TableId uint8
3439 DurationSec uint32
3440 DurationNsec uint32
3441 Priority uint16
3442 IdleTimeout uint16
3443 HardTimeout uint16
3444 MatchLen uint16
3445 IdleAge uint16
3446 HardAge uint16
3447 Cookie uint64
3448 PacketCount uint64
3449 ByteCount uint64
3450 Match NiciraMatch
3451 Actions []goloxi.IAction
3452}
3453
3454type INiciraFlowStats interface {
3455 goloxi.Serializable
3456 GetLength() uint16
3457 GetTableId() uint8
3458 GetDurationSec() uint32
3459 GetDurationNsec() uint32
3460 GetPriority() uint16
3461 GetIdleTimeout() uint16
3462 GetHardTimeout() uint16
3463 GetMatchLen() uint16
3464 GetIdleAge() uint16
3465 GetHardAge() uint16
3466 GetCookie() uint64
3467 GetPacketCount() uint64
3468 GetByteCount() uint64
3469 GetMatch() NiciraMatch
3470 GetActions() []goloxi.IAction
3471}
3472
3473func (self *NiciraFlowStats) GetLength() uint16 {
3474 return self.Length
3475}
3476
3477func (self *NiciraFlowStats) SetLength(v uint16) {
3478 self.Length = v
3479}
3480
3481func (self *NiciraFlowStats) GetTableId() uint8 {
3482 return self.TableId
3483}
3484
3485func (self *NiciraFlowStats) SetTableId(v uint8) {
3486 self.TableId = v
3487}
3488
3489func (self *NiciraFlowStats) GetDurationSec() uint32 {
3490 return self.DurationSec
3491}
3492
3493func (self *NiciraFlowStats) SetDurationSec(v uint32) {
3494 self.DurationSec = v
3495}
3496
3497func (self *NiciraFlowStats) GetDurationNsec() uint32 {
3498 return self.DurationNsec
3499}
3500
3501func (self *NiciraFlowStats) SetDurationNsec(v uint32) {
3502 self.DurationNsec = v
3503}
3504
3505func (self *NiciraFlowStats) GetPriority() uint16 {
3506 return self.Priority
3507}
3508
3509func (self *NiciraFlowStats) SetPriority(v uint16) {
3510 self.Priority = v
3511}
3512
3513func (self *NiciraFlowStats) GetIdleTimeout() uint16 {
3514 return self.IdleTimeout
3515}
3516
3517func (self *NiciraFlowStats) SetIdleTimeout(v uint16) {
3518 self.IdleTimeout = v
3519}
3520
3521func (self *NiciraFlowStats) GetHardTimeout() uint16 {
3522 return self.HardTimeout
3523}
3524
3525func (self *NiciraFlowStats) SetHardTimeout(v uint16) {
3526 self.HardTimeout = v
3527}
3528
3529func (self *NiciraFlowStats) GetMatchLen() uint16 {
3530 return self.MatchLen
3531}
3532
3533func (self *NiciraFlowStats) SetMatchLen(v uint16) {
3534 self.MatchLen = v
3535}
3536
3537func (self *NiciraFlowStats) GetIdleAge() uint16 {
3538 return self.IdleAge
3539}
3540
3541func (self *NiciraFlowStats) SetIdleAge(v uint16) {
3542 self.IdleAge = v
3543}
3544
3545func (self *NiciraFlowStats) GetHardAge() uint16 {
3546 return self.HardAge
3547}
3548
3549func (self *NiciraFlowStats) SetHardAge(v uint16) {
3550 self.HardAge = v
3551}
3552
3553func (self *NiciraFlowStats) GetCookie() uint64 {
3554 return self.Cookie
3555}
3556
3557func (self *NiciraFlowStats) SetCookie(v uint64) {
3558 self.Cookie = v
3559}
3560
3561func (self *NiciraFlowStats) GetPacketCount() uint64 {
3562 return self.PacketCount
3563}
3564
3565func (self *NiciraFlowStats) SetPacketCount(v uint64) {
3566 self.PacketCount = v
3567}
3568
3569func (self *NiciraFlowStats) GetByteCount() uint64 {
3570 return self.ByteCount
3571}
3572
3573func (self *NiciraFlowStats) SetByteCount(v uint64) {
3574 self.ByteCount = v
3575}
3576
3577func (self *NiciraFlowStats) GetMatch() NiciraMatch {
3578 return self.Match
3579}
3580
3581func (self *NiciraFlowStats) SetMatch(v NiciraMatch) {
3582 self.Match = v
3583}
3584
3585func (self *NiciraFlowStats) GetActions() []goloxi.IAction {
3586 return self.Actions
3587}
3588
3589func (self *NiciraFlowStats) SetActions(v []goloxi.IAction) {
3590 self.Actions = v
3591}
3592
3593func (self *NiciraFlowStats) Serialize(encoder *goloxi.Encoder) error {
3594 startIndex := len(encoder.Bytes())
3595
3596 encoder.PutUint16(uint16(self.Length))
3597 encoder.PutUint8(uint8(self.TableId))
3598 encoder.Write(bytes.Repeat([]byte{0}, 1))
3599 encoder.PutUint32(uint32(self.DurationSec))
3600 encoder.PutUint32(uint32(self.DurationNsec))
3601 encoder.PutUint16(uint16(self.Priority))
3602 encoder.PutUint16(uint16(self.IdleTimeout))
3603 encoder.PutUint16(uint16(self.HardTimeout))
3604 encoder.PutUint16(uint16(self.MatchLen))
3605 encoder.PutUint16(uint16(self.IdleAge))
3606 encoder.PutUint16(uint16(self.HardAge))
3607 encoder.PutUint64(uint64(self.Cookie))
3608 encoder.PutUint64(uint64(self.PacketCount))
3609 encoder.PutUint64(uint64(self.ByteCount))
3610 if err := self.Match.Serialize(encoder); err != nil {
3611 return err
3612 }
3613
3614 for _, obj := range self.Actions {
3615 if err := obj.Serialize(encoder); err != nil {
3616 return err
3617 }
3618 }
3619 length := len(encoder.Bytes()) - startIndex
3620
3621 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
3622
3623 return nil
3624}
3625
3626func DecodeNiciraFlowStats(decoder *goloxi.Decoder) (*NiciraFlowStats, error) {
3627 _niciraflowstats := &NiciraFlowStats{}
3628 if decoder.Length() < 48 {
3629 return nil, fmt.Errorf("NiciraFlowStats packet too short: %d < 48", decoder.Length())
3630 }
3631 _niciraflowstats.Length = uint16(decoder.ReadUint16())
3632 oldDecoder := decoder
3633 defer func() { decoder = oldDecoder }()
3634 decoder = decoder.SliceDecoder(int(_niciraflowstats.Length), 2+0)
3635 _niciraflowstats.TableId = uint8(decoder.ReadByte())
3636 decoder.Skip(1)
3637 _niciraflowstats.DurationSec = uint32(decoder.ReadUint32())
3638 _niciraflowstats.DurationNsec = uint32(decoder.ReadUint32())
3639 _niciraflowstats.Priority = uint16(decoder.ReadUint16())
3640 _niciraflowstats.IdleTimeout = uint16(decoder.ReadUint16())
3641 _niciraflowstats.HardTimeout = uint16(decoder.ReadUint16())
3642 _niciraflowstats.MatchLen = uint16(decoder.ReadUint16())
3643 _niciraflowstats.IdleAge = uint16(decoder.ReadUint16())
3644 _niciraflowstats.HardAge = uint16(decoder.ReadUint16())
3645 _niciraflowstats.Cookie = uint64(decoder.ReadUint64())
3646 _niciraflowstats.PacketCount = uint64(decoder.ReadUint64())
3647 _niciraflowstats.ByteCount = uint64(decoder.ReadUint64())
3648 if err := _niciraflowstats.Match.Decode(decoder.SliceDecoder(int(_niciraflowstats.MatchLen), 0)); err != nil {
3649 return nil, err
3650 }
3651
3652 decoder.SkipAlign()
3653
3654 for decoder.Length() >= 8 {
3655 item, err := DecodeAction(decoder)
3656 if err != nil {
3657 return nil, err
3658 }
3659 if item != nil {
3660 _niciraflowstats.Actions = append(_niciraflowstats.Actions, item)
3661 }
3662 }
3663 return _niciraflowstats, nil
3664}
3665
3666func NewNiciraFlowStats() *NiciraFlowStats {
3667 obj := &NiciraFlowStats{}
3668 return obj
3669}
3670
3671type NiciraFlowUpdateEvent struct {
3672 Length uint16
3673 Event uint16
3674}
3675
3676type INiciraFlowUpdateEvent interface {
3677 goloxi.Serializable
3678 GetLength() uint16
3679 GetEvent() uint16
3680}
3681
3682func (self *NiciraFlowUpdateEvent) GetLength() uint16 {
3683 return self.Length
3684}
3685
3686func (self *NiciraFlowUpdateEvent) SetLength(v uint16) {
3687 self.Length = v
3688}
3689
3690func (self *NiciraFlowUpdateEvent) GetEvent() uint16 {
3691 return self.Event
3692}
3693
3694func (self *NiciraFlowUpdateEvent) SetEvent(v uint16) {
3695 self.Event = v
3696}
3697
3698func (self *NiciraFlowUpdateEvent) Serialize(encoder *goloxi.Encoder) error {
3699
3700 encoder.PutUint16(uint16(self.Length))
3701 encoder.PutUint16(uint16(self.Event))
3702
3703 return nil
3704}
3705
3706func DecodeNiciraFlowUpdateEvent(decoder *goloxi.Decoder) (INiciraFlowUpdateEvent, error) {
3707 _niciraflowupdateevent := &NiciraFlowUpdateEvent{}
3708 if decoder.Length() < 4 {
3709 return nil, fmt.Errorf("NiciraFlowUpdateEvent packet too short: %d < 4", decoder.Length())
3710 }
3711 _niciraflowupdateevent.Length = uint16(decoder.ReadUint16())
3712 oldDecoder := decoder
3713 defer func() { decoder = oldDecoder }()
3714 decoder = decoder.SliceDecoder(int(_niciraflowupdateevent.Length), 2+0)
3715 _niciraflowupdateevent.Event = uint16(decoder.ReadUint16())
3716
3717 switch _niciraflowupdateevent.Event {
3718 case 0:
3719 return DecodeNiciraFlowUpdateFullAdd(_niciraflowupdateevent, decoder)
3720 case 1:
3721 return DecodeNiciraFlowUpdateFullDeleted(_niciraflowupdateevent, decoder)
3722 case 2:
3723 return DecodeNiciraFlowUpdateFullModified(_niciraflowupdateevent, decoder)
3724 default:
3725 return nil, fmt.Errorf("Invalid type '%d' for 'NiciraFlowUpdateEvent'", _niciraflowupdateevent.Event)
3726 }
3727}
3728
3729func NewNiciraFlowUpdateEvent(_event uint16) *NiciraFlowUpdateEvent {
3730 obj := &NiciraFlowUpdateEvent{}
3731 obj.Event = _event
3732 return obj
3733}
3734
3735type NiciraFlowUpdateFullAdd struct {
3736 *NiciraFlowUpdateEvent
3737 Reason uint16
3738 Priority uint16
3739 IdleTimeout uint16
3740 HardTimeout uint16
3741 MatchLen uint16
3742 TableId uint8
3743 Cookie uint64
3744 Match NiciraMatch
3745 Actions []goloxi.IAction
3746}
3747
3748type INiciraFlowUpdateFullAdd interface {
3749 INiciraFlowUpdateEvent
3750 GetReason() uint16
3751 GetPriority() uint16
3752 GetIdleTimeout() uint16
3753 GetHardTimeout() uint16
3754 GetMatchLen() uint16
3755 GetTableId() uint8
3756 GetCookie() uint64
3757 GetMatch() NiciraMatch
3758 GetActions() []goloxi.IAction
3759}
3760
3761func (self *NiciraFlowUpdateFullAdd) GetReason() uint16 {
3762 return self.Reason
3763}
3764
3765func (self *NiciraFlowUpdateFullAdd) SetReason(v uint16) {
3766 self.Reason = v
3767}
3768
3769func (self *NiciraFlowUpdateFullAdd) GetPriority() uint16 {
3770 return self.Priority
3771}
3772
3773func (self *NiciraFlowUpdateFullAdd) SetPriority(v uint16) {
3774 self.Priority = v
3775}
3776
3777func (self *NiciraFlowUpdateFullAdd) GetIdleTimeout() uint16 {
3778 return self.IdleTimeout
3779}
3780
3781func (self *NiciraFlowUpdateFullAdd) SetIdleTimeout(v uint16) {
3782 self.IdleTimeout = v
3783}
3784
3785func (self *NiciraFlowUpdateFullAdd) GetHardTimeout() uint16 {
3786 return self.HardTimeout
3787}
3788
3789func (self *NiciraFlowUpdateFullAdd) SetHardTimeout(v uint16) {
3790 self.HardTimeout = v
3791}
3792
3793func (self *NiciraFlowUpdateFullAdd) GetMatchLen() uint16 {
3794 return self.MatchLen
3795}
3796
3797func (self *NiciraFlowUpdateFullAdd) SetMatchLen(v uint16) {
3798 self.MatchLen = v
3799}
3800
3801func (self *NiciraFlowUpdateFullAdd) GetTableId() uint8 {
3802 return self.TableId
3803}
3804
3805func (self *NiciraFlowUpdateFullAdd) SetTableId(v uint8) {
3806 self.TableId = v
3807}
3808
3809func (self *NiciraFlowUpdateFullAdd) GetCookie() uint64 {
3810 return self.Cookie
3811}
3812
3813func (self *NiciraFlowUpdateFullAdd) SetCookie(v uint64) {
3814 self.Cookie = v
3815}
3816
3817func (self *NiciraFlowUpdateFullAdd) GetMatch() NiciraMatch {
3818 return self.Match
3819}
3820
3821func (self *NiciraFlowUpdateFullAdd) SetMatch(v NiciraMatch) {
3822 self.Match = v
3823}
3824
3825func (self *NiciraFlowUpdateFullAdd) GetActions() []goloxi.IAction {
3826 return self.Actions
3827}
3828
3829func (self *NiciraFlowUpdateFullAdd) SetActions(v []goloxi.IAction) {
3830 self.Actions = v
3831}
3832
3833func (self *NiciraFlowUpdateFullAdd) Serialize(encoder *goloxi.Encoder) error {
3834 startIndex := len(encoder.Bytes())
3835 if err := self.NiciraFlowUpdateEvent.Serialize(encoder); err != nil {
3836 return err
3837 }
3838
3839 encoder.PutUint16(uint16(self.Reason))
3840 encoder.PutUint16(uint16(self.Priority))
3841 encoder.PutUint16(uint16(self.IdleTimeout))
3842 encoder.PutUint16(uint16(self.HardTimeout))
3843 encoder.PutUint16(uint16(self.MatchLen))
3844 encoder.PutUint8(uint8(self.TableId))
3845 encoder.Write(bytes.Repeat([]byte{0}, 1))
3846 encoder.PutUint64(uint64(self.Cookie))
3847 if err := self.Match.Serialize(encoder); err != nil {
3848 return err
3849 }
3850
3851 for _, obj := range self.Actions {
3852 if err := obj.Serialize(encoder); err != nil {
3853 return err
3854 }
3855 }
3856 length := len(encoder.Bytes()) - startIndex
3857
3858 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
3859
3860 return nil
3861}
3862
3863func DecodeNiciraFlowUpdateFullAdd(parent *NiciraFlowUpdateEvent, decoder *goloxi.Decoder) (*NiciraFlowUpdateFullAdd, error) {
3864 _niciraflowupdatefulladd := &NiciraFlowUpdateFullAdd{NiciraFlowUpdateEvent: parent}
3865 if decoder.Length() < 20 {
3866 return nil, fmt.Errorf("NiciraFlowUpdateFullAdd packet too short: %d < 20", decoder.Length())
3867 }
3868 _niciraflowupdatefulladd.Reason = uint16(decoder.ReadUint16())
3869 _niciraflowupdatefulladd.Priority = uint16(decoder.ReadUint16())
3870 _niciraflowupdatefulladd.IdleTimeout = uint16(decoder.ReadUint16())
3871 _niciraflowupdatefulladd.HardTimeout = uint16(decoder.ReadUint16())
3872 _niciraflowupdatefulladd.MatchLen = uint16(decoder.ReadUint16())
3873 _niciraflowupdatefulladd.TableId = uint8(decoder.ReadByte())
3874 decoder.Skip(1)
3875 _niciraflowupdatefulladd.Cookie = uint64(decoder.ReadUint64())
3876 if err := _niciraflowupdatefulladd.Match.Decode(decoder.SliceDecoder(int(_niciraflowupdatefulladd.MatchLen), 0)); err != nil {
3877 return nil, err
3878 }
3879
3880 decoder.SkipAlign()
3881
3882 for decoder.Length() >= 8 {
3883 item, err := DecodeAction(decoder)
3884 if err != nil {
3885 return nil, err
3886 }
3887 if item != nil {
3888 _niciraflowupdatefulladd.Actions = append(_niciraflowupdatefulladd.Actions, item)
3889 }
3890 }
3891 return _niciraflowupdatefulladd, nil
3892}
3893
3894func NewNiciraFlowUpdateFullAdd() *NiciraFlowUpdateFullAdd {
3895 obj := &NiciraFlowUpdateFullAdd{
3896 NiciraFlowUpdateEvent: NewNiciraFlowUpdateEvent(0),
3897 }
3898 return obj
3899}
3900
3901type NiciraFlowUpdateFullDeleted struct {
3902 *NiciraFlowUpdateEvent
3903 Reason uint16
3904 Priority uint16
3905 IdleTimeout uint16
3906 HardTimeout uint16
3907 MatchLen uint16
3908 TableId uint8
3909 Cookie uint64
3910 Match NiciraMatch
3911 Actions []goloxi.IAction
3912}
3913
3914type INiciraFlowUpdateFullDeleted interface {
3915 INiciraFlowUpdateEvent
3916 GetReason() uint16
3917 GetPriority() uint16
3918 GetIdleTimeout() uint16
3919 GetHardTimeout() uint16
3920 GetMatchLen() uint16
3921 GetTableId() uint8
3922 GetCookie() uint64
3923 GetMatch() NiciraMatch
3924 GetActions() []goloxi.IAction
3925}
3926
3927func (self *NiciraFlowUpdateFullDeleted) GetReason() uint16 {
3928 return self.Reason
3929}
3930
3931func (self *NiciraFlowUpdateFullDeleted) SetReason(v uint16) {
3932 self.Reason = v
3933}
3934
3935func (self *NiciraFlowUpdateFullDeleted) GetPriority() uint16 {
3936 return self.Priority
3937}
3938
3939func (self *NiciraFlowUpdateFullDeleted) SetPriority(v uint16) {
3940 self.Priority = v
3941}
3942
3943func (self *NiciraFlowUpdateFullDeleted) GetIdleTimeout() uint16 {
3944 return self.IdleTimeout
3945}
3946
3947func (self *NiciraFlowUpdateFullDeleted) SetIdleTimeout(v uint16) {
3948 self.IdleTimeout = v
3949}
3950
3951func (self *NiciraFlowUpdateFullDeleted) GetHardTimeout() uint16 {
3952 return self.HardTimeout
3953}
3954
3955func (self *NiciraFlowUpdateFullDeleted) SetHardTimeout(v uint16) {
3956 self.HardTimeout = v
3957}
3958
3959func (self *NiciraFlowUpdateFullDeleted) GetMatchLen() uint16 {
3960 return self.MatchLen
3961}
3962
3963func (self *NiciraFlowUpdateFullDeleted) SetMatchLen(v uint16) {
3964 self.MatchLen = v
3965}
3966
3967func (self *NiciraFlowUpdateFullDeleted) GetTableId() uint8 {
3968 return self.TableId
3969}
3970
3971func (self *NiciraFlowUpdateFullDeleted) SetTableId(v uint8) {
3972 self.TableId = v
3973}
3974
3975func (self *NiciraFlowUpdateFullDeleted) GetCookie() uint64 {
3976 return self.Cookie
3977}
3978
3979func (self *NiciraFlowUpdateFullDeleted) SetCookie(v uint64) {
3980 self.Cookie = v
3981}
3982
3983func (self *NiciraFlowUpdateFullDeleted) GetMatch() NiciraMatch {
3984 return self.Match
3985}
3986
3987func (self *NiciraFlowUpdateFullDeleted) SetMatch(v NiciraMatch) {
3988 self.Match = v
3989}
3990
3991func (self *NiciraFlowUpdateFullDeleted) GetActions() []goloxi.IAction {
3992 return self.Actions
3993}
3994
3995func (self *NiciraFlowUpdateFullDeleted) SetActions(v []goloxi.IAction) {
3996 self.Actions = v
3997}
3998
3999func (self *NiciraFlowUpdateFullDeleted) Serialize(encoder *goloxi.Encoder) error {
4000 startIndex := len(encoder.Bytes())
4001 if err := self.NiciraFlowUpdateEvent.Serialize(encoder); err != nil {
4002 return err
4003 }
4004
4005 encoder.PutUint16(uint16(self.Reason))
4006 encoder.PutUint16(uint16(self.Priority))
4007 encoder.PutUint16(uint16(self.IdleTimeout))
4008 encoder.PutUint16(uint16(self.HardTimeout))
4009 encoder.PutUint16(uint16(self.MatchLen))
4010 encoder.PutUint8(uint8(self.TableId))
4011 encoder.Write(bytes.Repeat([]byte{0}, 1))
4012 encoder.PutUint64(uint64(self.Cookie))
4013 if err := self.Match.Serialize(encoder); err != nil {
4014 return err
4015 }
4016
4017 for _, obj := range self.Actions {
4018 if err := obj.Serialize(encoder); err != nil {
4019 return err
4020 }
4021 }
4022 length := len(encoder.Bytes()) - startIndex
4023
4024 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
4025
4026 return nil
4027}
4028
4029func DecodeNiciraFlowUpdateFullDeleted(parent *NiciraFlowUpdateEvent, decoder *goloxi.Decoder) (*NiciraFlowUpdateFullDeleted, error) {
4030 _niciraflowupdatefulldeleted := &NiciraFlowUpdateFullDeleted{NiciraFlowUpdateEvent: parent}
4031 if decoder.Length() < 20 {
4032 return nil, fmt.Errorf("NiciraFlowUpdateFullDeleted packet too short: %d < 20", decoder.Length())
4033 }
4034 _niciraflowupdatefulldeleted.Reason = uint16(decoder.ReadUint16())
4035 _niciraflowupdatefulldeleted.Priority = uint16(decoder.ReadUint16())
4036 _niciraflowupdatefulldeleted.IdleTimeout = uint16(decoder.ReadUint16())
4037 _niciraflowupdatefulldeleted.HardTimeout = uint16(decoder.ReadUint16())
4038 _niciraflowupdatefulldeleted.MatchLen = uint16(decoder.ReadUint16())
4039 _niciraflowupdatefulldeleted.TableId = uint8(decoder.ReadByte())
4040 decoder.Skip(1)
4041 _niciraflowupdatefulldeleted.Cookie = uint64(decoder.ReadUint64())
4042 if err := _niciraflowupdatefulldeleted.Match.Decode(decoder.SliceDecoder(int(_niciraflowupdatefulldeleted.MatchLen), 0)); err != nil {
4043 return nil, err
4044 }
4045
4046 decoder.SkipAlign()
4047
4048 for decoder.Length() >= 8 {
4049 item, err := DecodeAction(decoder)
4050 if err != nil {
4051 return nil, err
4052 }
4053 if item != nil {
4054 _niciraflowupdatefulldeleted.Actions = append(_niciraflowupdatefulldeleted.Actions, item)
4055 }
4056 }
4057 return _niciraflowupdatefulldeleted, nil
4058}
4059
4060func NewNiciraFlowUpdateFullDeleted() *NiciraFlowUpdateFullDeleted {
4061 obj := &NiciraFlowUpdateFullDeleted{
4062 NiciraFlowUpdateEvent: NewNiciraFlowUpdateEvent(1),
4063 }
4064 return obj
4065}
4066
4067type NiciraFlowUpdateFullModified struct {
4068 *NiciraFlowUpdateEvent
4069 Reason uint16
4070 Priority uint16
4071 IdleTimeout uint16
4072 HardTimeout uint16
4073 MatchLen uint16
4074 TableId uint8
4075 Cookie uint64
4076 Match NiciraMatch
4077 Actions []goloxi.IAction
4078}
4079
4080type INiciraFlowUpdateFullModified interface {
4081 INiciraFlowUpdateEvent
4082 GetReason() uint16
4083 GetPriority() uint16
4084 GetIdleTimeout() uint16
4085 GetHardTimeout() uint16
4086 GetMatchLen() uint16
4087 GetTableId() uint8
4088 GetCookie() uint64
4089 GetMatch() NiciraMatch
4090 GetActions() []goloxi.IAction
4091}
4092
4093func (self *NiciraFlowUpdateFullModified) GetReason() uint16 {
4094 return self.Reason
4095}
4096
4097func (self *NiciraFlowUpdateFullModified) SetReason(v uint16) {
4098 self.Reason = v
4099}
4100
4101func (self *NiciraFlowUpdateFullModified) GetPriority() uint16 {
4102 return self.Priority
4103}
4104
4105func (self *NiciraFlowUpdateFullModified) SetPriority(v uint16) {
4106 self.Priority = v
4107}
4108
4109func (self *NiciraFlowUpdateFullModified) GetIdleTimeout() uint16 {
4110 return self.IdleTimeout
4111}
4112
4113func (self *NiciraFlowUpdateFullModified) SetIdleTimeout(v uint16) {
4114 self.IdleTimeout = v
4115}
4116
4117func (self *NiciraFlowUpdateFullModified) GetHardTimeout() uint16 {
4118 return self.HardTimeout
4119}
4120
4121func (self *NiciraFlowUpdateFullModified) SetHardTimeout(v uint16) {
4122 self.HardTimeout = v
4123}
4124
4125func (self *NiciraFlowUpdateFullModified) GetMatchLen() uint16 {
4126 return self.MatchLen
4127}
4128
4129func (self *NiciraFlowUpdateFullModified) SetMatchLen(v uint16) {
4130 self.MatchLen = v
4131}
4132
4133func (self *NiciraFlowUpdateFullModified) GetTableId() uint8 {
4134 return self.TableId
4135}
4136
4137func (self *NiciraFlowUpdateFullModified) SetTableId(v uint8) {
4138 self.TableId = v
4139}
4140
4141func (self *NiciraFlowUpdateFullModified) GetCookie() uint64 {
4142 return self.Cookie
4143}
4144
4145func (self *NiciraFlowUpdateFullModified) SetCookie(v uint64) {
4146 self.Cookie = v
4147}
4148
4149func (self *NiciraFlowUpdateFullModified) GetMatch() NiciraMatch {
4150 return self.Match
4151}
4152
4153func (self *NiciraFlowUpdateFullModified) SetMatch(v NiciraMatch) {
4154 self.Match = v
4155}
4156
4157func (self *NiciraFlowUpdateFullModified) GetActions() []goloxi.IAction {
4158 return self.Actions
4159}
4160
4161func (self *NiciraFlowUpdateFullModified) SetActions(v []goloxi.IAction) {
4162 self.Actions = v
4163}
4164
4165func (self *NiciraFlowUpdateFullModified) Serialize(encoder *goloxi.Encoder) error {
4166 startIndex := len(encoder.Bytes())
4167 if err := self.NiciraFlowUpdateEvent.Serialize(encoder); err != nil {
4168 return err
4169 }
4170
4171 encoder.PutUint16(uint16(self.Reason))
4172 encoder.PutUint16(uint16(self.Priority))
4173 encoder.PutUint16(uint16(self.IdleTimeout))
4174 encoder.PutUint16(uint16(self.HardTimeout))
4175 encoder.PutUint16(uint16(self.MatchLen))
4176 encoder.PutUint8(uint8(self.TableId))
4177 encoder.Write(bytes.Repeat([]byte{0}, 1))
4178 encoder.PutUint64(uint64(self.Cookie))
4179 if err := self.Match.Serialize(encoder); err != nil {
4180 return err
4181 }
4182
4183 for _, obj := range self.Actions {
4184 if err := obj.Serialize(encoder); err != nil {
4185 return err
4186 }
4187 }
4188 length := len(encoder.Bytes()) - startIndex
4189
4190 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
4191
4192 return nil
4193}
4194
4195func DecodeNiciraFlowUpdateFullModified(parent *NiciraFlowUpdateEvent, decoder *goloxi.Decoder) (*NiciraFlowUpdateFullModified, error) {
4196 _niciraflowupdatefullmodified := &NiciraFlowUpdateFullModified{NiciraFlowUpdateEvent: parent}
4197 if decoder.Length() < 20 {
4198 return nil, fmt.Errorf("NiciraFlowUpdateFullModified packet too short: %d < 20", decoder.Length())
4199 }
4200 _niciraflowupdatefullmodified.Reason = uint16(decoder.ReadUint16())
4201 _niciraflowupdatefullmodified.Priority = uint16(decoder.ReadUint16())
4202 _niciraflowupdatefullmodified.IdleTimeout = uint16(decoder.ReadUint16())
4203 _niciraflowupdatefullmodified.HardTimeout = uint16(decoder.ReadUint16())
4204 _niciraflowupdatefullmodified.MatchLen = uint16(decoder.ReadUint16())
4205 _niciraflowupdatefullmodified.TableId = uint8(decoder.ReadByte())
4206 decoder.Skip(1)
4207 _niciraflowupdatefullmodified.Cookie = uint64(decoder.ReadUint64())
4208 if err := _niciraflowupdatefullmodified.Match.Decode(decoder.SliceDecoder(int(_niciraflowupdatefullmodified.MatchLen), 0)); err != nil {
4209 return nil, err
4210 }
4211
4212 decoder.SkipAlign()
4213
4214 for decoder.Length() >= 8 {
4215 item, err := DecodeAction(decoder)
4216 if err != nil {
4217 return nil, err
4218 }
4219 if item != nil {
4220 _niciraflowupdatefullmodified.Actions = append(_niciraflowupdatefullmodified.Actions, item)
4221 }
4222 }
4223 return _niciraflowupdatefullmodified, nil
4224}
4225
4226func NewNiciraFlowUpdateFullModified() *NiciraFlowUpdateFullModified {
4227 obj := &NiciraFlowUpdateFullModified{
4228 NiciraFlowUpdateEvent: NewNiciraFlowUpdateEvent(2),
4229 }
4230 return obj
4231}
4232
4233type OxmIdArpOp struct {
4234 *OxmId
4235}
4236
4237type IOxmIdArpOp interface {
4238 IOxmId
4239}
4240
4241func (self *OxmIdArpOp) Serialize(encoder *goloxi.Encoder) error {
4242 if err := self.OxmId.Serialize(encoder); err != nil {
4243 return err
4244 }
4245
4246 return nil
4247}
4248
4249func DecodeOxmIdArpOp(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpOp, error) {
4250 _oxmidarpop := &OxmIdArpOp{OxmId: parent}
4251 return _oxmidarpop, nil
4252}
4253
4254func NewOxmIdArpOp() *OxmIdArpOp {
4255 obj := &OxmIdArpOp{
4256 OxmId: NewOxmId(7682),
4257 }
4258 return obj
4259}
4260func (self *OxmIdArpOp) GetOXMName() string {
4261 return "arp_op"
4262}
4263
4264func (self *OxmIdArpOp) MarshalJSON() ([]byte, error) {
4265 if self.TypeLen == 0 {
4266 return []byte("\"\""), nil
4267 } else {
4268 return []byte("\"" + self.GetOXMName() + "\""), nil
4269 }
4270}
4271
4272type OxmIdArpSha struct {
4273 *OxmId
4274}
4275
4276type IOxmIdArpSha interface {
4277 IOxmId
4278}
4279
4280func (self *OxmIdArpSha) Serialize(encoder *goloxi.Encoder) error {
4281 if err := self.OxmId.Serialize(encoder); err != nil {
4282 return err
4283 }
4284
4285 return nil
4286}
4287
4288func DecodeOxmIdArpSha(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpSha, error) {
4289 _oxmidarpsha := &OxmIdArpSha{OxmId: parent}
4290 return _oxmidarpsha, nil
4291}
4292
4293func NewOxmIdArpSha() *OxmIdArpSha {
4294 obj := &OxmIdArpSha{
4295 OxmId: NewOxmId(74246),
4296 }
4297 return obj
4298}
4299func (self *OxmIdArpSha) GetOXMName() string {
4300 return "arp_sha"
4301}
4302
4303func (self *OxmIdArpSha) MarshalJSON() ([]byte, error) {
4304 if self.TypeLen == 0 {
4305 return []byte("\"\""), nil
4306 } else {
4307 return []byte("\"" + self.GetOXMName() + "\""), nil
4308 }
4309}
4310
4311type OxmIdArpShaMasked struct {
4312 *OxmId
4313}
4314
4315type IOxmIdArpShaMasked interface {
4316 IOxmId
4317}
4318
4319func (self *OxmIdArpShaMasked) Serialize(encoder *goloxi.Encoder) error {
4320 if err := self.OxmId.Serialize(encoder); err != nil {
4321 return err
4322 }
4323
4324 return nil
4325}
4326
4327func DecodeOxmIdArpShaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpShaMasked, error) {
4328 _oxmidarpshamasked := &OxmIdArpShaMasked{OxmId: parent}
4329 return _oxmidarpshamasked, nil
4330}
4331
4332func NewOxmIdArpShaMasked() *OxmIdArpShaMasked {
4333 obj := &OxmIdArpShaMasked{
4334 OxmId: NewOxmId(74507),
4335 }
4336 return obj
4337}
4338func (self *OxmIdArpShaMasked) GetOXMName() string {
4339 return "arp_sha_masked"
4340}
4341
4342func (self *OxmIdArpShaMasked) MarshalJSON() ([]byte, error) {
4343 if self.TypeLen == 0 {
4344 return []byte("\"\""), nil
4345 } else {
4346 return []byte("\"" + self.GetOXMName() + "\""), nil
4347 }
4348}
4349
4350type OxmIdArpSpa struct {
4351 *OxmId
4352}
4353
4354type IOxmIdArpSpa interface {
4355 IOxmId
4356}
4357
4358func (self *OxmIdArpSpa) Serialize(encoder *goloxi.Encoder) error {
4359 if err := self.OxmId.Serialize(encoder); err != nil {
4360 return err
4361 }
4362
4363 return nil
4364}
4365
4366func DecodeOxmIdArpSpa(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpSpa, error) {
4367 _oxmidarpspa := &OxmIdArpSpa{OxmId: parent}
4368 return _oxmidarpspa, nil
4369}
4370
4371func NewOxmIdArpSpa() *OxmIdArpSpa {
4372 obj := &OxmIdArpSpa{
4373 OxmId: NewOxmId(8196),
4374 }
4375 return obj
4376}
4377func (self *OxmIdArpSpa) GetOXMName() string {
4378 return "arp_spa"
4379}
4380
4381func (self *OxmIdArpSpa) MarshalJSON() ([]byte, error) {
4382 if self.TypeLen == 0 {
4383 return []byte("\"\""), nil
4384 } else {
4385 return []byte("\"" + self.GetOXMName() + "\""), nil
4386 }
4387}
4388
4389type OxmIdArpSpaMasked struct {
4390 *OxmId
4391}
4392
4393type IOxmIdArpSpaMasked interface {
4394 IOxmId
4395}
4396
4397func (self *OxmIdArpSpaMasked) Serialize(encoder *goloxi.Encoder) error {
4398 if err := self.OxmId.Serialize(encoder); err != nil {
4399 return err
4400 }
4401
4402 return nil
4403}
4404
4405func DecodeOxmIdArpSpaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpSpaMasked, error) {
4406 _oxmidarpspamasked := &OxmIdArpSpaMasked{OxmId: parent}
4407 return _oxmidarpspamasked, nil
4408}
4409
4410func NewOxmIdArpSpaMasked() *OxmIdArpSpaMasked {
4411 obj := &OxmIdArpSpaMasked{
4412 OxmId: NewOxmId(8452),
4413 }
4414 return obj
4415}
4416func (self *OxmIdArpSpaMasked) GetOXMName() string {
4417 return "arp_spa_masked"
4418}
4419
4420func (self *OxmIdArpSpaMasked) MarshalJSON() ([]byte, error) {
4421 if self.TypeLen == 0 {
4422 return []byte("\"\""), nil
4423 } else {
4424 return []byte("\"" + self.GetOXMName() + "\""), nil
4425 }
4426}
4427
4428type OxmIdArpTha struct {
4429 *OxmId
4430}
4431
4432type IOxmIdArpTha interface {
4433 IOxmId
4434}
4435
4436func (self *OxmIdArpTha) Serialize(encoder *goloxi.Encoder) error {
4437 if err := self.OxmId.Serialize(encoder); err != nil {
4438 return err
4439 }
4440
4441 return nil
4442}
4443
4444func DecodeOxmIdArpTha(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpTha, error) {
4445 _oxmidarptha := &OxmIdArpTha{OxmId: parent}
4446 return _oxmidarptha, nil
4447}
4448
4449func NewOxmIdArpTha() *OxmIdArpTha {
4450 obj := &OxmIdArpTha{
4451 OxmId: NewOxmId(74758),
4452 }
4453 return obj
4454}
4455func (self *OxmIdArpTha) GetOXMName() string {
4456 return "arp_tha"
4457}
4458
4459func (self *OxmIdArpTha) MarshalJSON() ([]byte, error) {
4460 if self.TypeLen == 0 {
4461 return []byte("\"\""), nil
4462 } else {
4463 return []byte("\"" + self.GetOXMName() + "\""), nil
4464 }
4465}
4466
4467type OxmIdArpThaMasked struct {
4468 *OxmId
4469}
4470
4471type IOxmIdArpThaMasked interface {
4472 IOxmId
4473}
4474
4475func (self *OxmIdArpThaMasked) Serialize(encoder *goloxi.Encoder) error {
4476 if err := self.OxmId.Serialize(encoder); err != nil {
4477 return err
4478 }
4479
4480 return nil
4481}
4482
4483func DecodeOxmIdArpThaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpThaMasked, error) {
4484 _oxmidarpthamasked := &OxmIdArpThaMasked{OxmId: parent}
4485 return _oxmidarpthamasked, nil
4486}
4487
4488func NewOxmIdArpThaMasked() *OxmIdArpThaMasked {
4489 obj := &OxmIdArpThaMasked{
4490 OxmId: NewOxmId(75019),
4491 }
4492 return obj
4493}
4494func (self *OxmIdArpThaMasked) GetOXMName() string {
4495 return "arp_tha_masked"
4496}
4497
4498func (self *OxmIdArpThaMasked) MarshalJSON() ([]byte, error) {
4499 if self.TypeLen == 0 {
4500 return []byte("\"\""), nil
4501 } else {
4502 return []byte("\"" + self.GetOXMName() + "\""), nil
4503 }
4504}
4505
4506type OxmIdArpTpa struct {
4507 *OxmId
4508}
4509
4510type IOxmIdArpTpa interface {
4511 IOxmId
4512}
4513
4514func (self *OxmIdArpTpa) Serialize(encoder *goloxi.Encoder) error {
4515 if err := self.OxmId.Serialize(encoder); err != nil {
4516 return err
4517 }
4518
4519 return nil
4520}
4521
4522func DecodeOxmIdArpTpa(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpTpa, error) {
4523 _oxmidarptpa := &OxmIdArpTpa{OxmId: parent}
4524 return _oxmidarptpa, nil
4525}
4526
4527func NewOxmIdArpTpa() *OxmIdArpTpa {
4528 obj := &OxmIdArpTpa{
4529 OxmId: NewOxmId(8708),
4530 }
4531 return obj
4532}
4533func (self *OxmIdArpTpa) GetOXMName() string {
4534 return "arp_tpa"
4535}
4536
4537func (self *OxmIdArpTpa) MarshalJSON() ([]byte, error) {
4538 if self.TypeLen == 0 {
4539 return []byte("\"\""), nil
4540 } else {
4541 return []byte("\"" + self.GetOXMName() + "\""), nil
4542 }
4543}
4544
4545type OxmIdArpTpaMasked struct {
4546 *OxmId
4547}
4548
4549type IOxmIdArpTpaMasked interface {
4550 IOxmId
4551}
4552
4553func (self *OxmIdArpTpaMasked) Serialize(encoder *goloxi.Encoder) error {
4554 if err := self.OxmId.Serialize(encoder); err != nil {
4555 return err
4556 }
4557
4558 return nil
4559}
4560
4561func DecodeOxmIdArpTpaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpTpaMasked, error) {
4562 _oxmidarptpamasked := &OxmIdArpTpaMasked{OxmId: parent}
4563 return _oxmidarptpamasked, nil
4564}
4565
4566func NewOxmIdArpTpaMasked() *OxmIdArpTpaMasked {
4567 obj := &OxmIdArpTpaMasked{
4568 OxmId: NewOxmId(8968),
4569 }
4570 return obj
4571}
4572func (self *OxmIdArpTpaMasked) GetOXMName() string {
4573 return "arp_tpa_masked"
4574}
4575
4576func (self *OxmIdArpTpaMasked) MarshalJSON() ([]byte, error) {
4577 if self.TypeLen == 0 {
4578 return []byte("\"\""), nil
4579 } else {
4580 return []byte("\"" + self.GetOXMName() + "\""), nil
4581 }
4582}
4583
4584type OxmIdConjId struct {
4585 *OxmId
4586}
4587
4588type IOxmIdConjId interface {
4589 IOxmId
4590}
4591
4592func (self *OxmIdConjId) Serialize(encoder *goloxi.Encoder) error {
4593 if err := self.OxmId.Serialize(encoder); err != nil {
4594 return err
4595 }
4596
4597 return nil
4598}
4599
4600func DecodeOxmIdConjId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConjId, error) {
4601 _oxmidconjid := &OxmIdConjId{OxmId: parent}
4602 return _oxmidconjid, nil
4603}
4604
4605func NewOxmIdConjId() *OxmIdConjId {
4606 obj := &OxmIdConjId{
4607 OxmId: NewOxmId(84484),
4608 }
4609 return obj
4610}
4611func (self *OxmIdConjId) GetOXMName() string {
4612 return "conj_id"
4613}
4614
4615func (self *OxmIdConjId) MarshalJSON() ([]byte, error) {
4616 if self.TypeLen == 0 {
4617 return []byte("\"\""), nil
4618 } else {
4619 return []byte("\"" + self.GetOXMName() + "\""), nil
4620 }
4621}
4622
4623type OxmIdCtIpv6Dst struct {
4624 *OxmId
4625}
4626
4627type IOxmIdCtIpv6Dst interface {
4628 IOxmId
4629}
4630
4631func (self *OxmIdCtIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
4632 if err := self.OxmId.Serialize(encoder); err != nil {
4633 return err
4634 }
4635
4636 return nil
4637}
4638
4639func DecodeOxmIdCtIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6Dst, error) {
4640 _oxmidctipv6dst := &OxmIdCtIpv6Dst{OxmId: parent}
4641 return _oxmidctipv6dst, nil
4642}
4643
4644func NewOxmIdCtIpv6Dst() *OxmIdCtIpv6Dst {
4645 obj := &OxmIdCtIpv6Dst{
4646 OxmId: NewOxmId(128528),
4647 }
4648 return obj
4649}
4650func (self *OxmIdCtIpv6Dst) GetOXMName() string {
4651 return "ct_ipv6_dst"
4652}
4653
4654func (self *OxmIdCtIpv6Dst) MarshalJSON() ([]byte, error) {
4655 if self.TypeLen == 0 {
4656 return []byte("\"\""), nil
4657 } else {
4658 return []byte("\"" + self.GetOXMName() + "\""), nil
4659 }
4660}
4661
4662type OxmIdCtIpv6DstMasked struct {
4663 *OxmId
4664}
4665
4666type IOxmIdCtIpv6DstMasked interface {
4667 IOxmId
4668}
4669
4670func (self *OxmIdCtIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
4671 if err := self.OxmId.Serialize(encoder); err != nil {
4672 return err
4673 }
4674
4675 return nil
4676}
4677
4678func DecodeOxmIdCtIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6DstMasked, error) {
4679 _oxmidctipv6dstmasked := &OxmIdCtIpv6DstMasked{OxmId: parent}
4680 return _oxmidctipv6dstmasked, nil
4681}
4682
4683func NewOxmIdCtIpv6DstMasked() *OxmIdCtIpv6DstMasked {
4684 obj := &OxmIdCtIpv6DstMasked{
4685 OxmId: NewOxmId(128800),
4686 }
4687 return obj
4688}
4689func (self *OxmIdCtIpv6DstMasked) GetOXMName() string {
4690 return "ct_ipv6_dst_masked"
4691}
4692
4693func (self *OxmIdCtIpv6DstMasked) MarshalJSON() ([]byte, error) {
4694 if self.TypeLen == 0 {
4695 return []byte("\"\""), nil
4696 } else {
4697 return []byte("\"" + self.GetOXMName() + "\""), nil
4698 }
4699}
4700
4701type OxmIdCtIpv6Src struct {
4702 *OxmId
4703}
4704
4705type IOxmIdCtIpv6Src interface {
4706 IOxmId
4707}
4708
4709func (self *OxmIdCtIpv6Src) Serialize(encoder *goloxi.Encoder) error {
4710 if err := self.OxmId.Serialize(encoder); err != nil {
4711 return err
4712 }
4713
4714 return nil
4715}
4716
4717func DecodeOxmIdCtIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6Src, error) {
4718 _oxmidctipv6src := &OxmIdCtIpv6Src{OxmId: parent}
4719 return _oxmidctipv6src, nil
4720}
4721
4722func NewOxmIdCtIpv6Src() *OxmIdCtIpv6Src {
4723 obj := &OxmIdCtIpv6Src{
4724 OxmId: NewOxmId(128016),
4725 }
4726 return obj
4727}
4728func (self *OxmIdCtIpv6Src) GetOXMName() string {
4729 return "ct_ipv6_src"
4730}
4731
4732func (self *OxmIdCtIpv6Src) MarshalJSON() ([]byte, error) {
4733 if self.TypeLen == 0 {
4734 return []byte("\"\""), nil
4735 } else {
4736 return []byte("\"" + self.GetOXMName() + "\""), nil
4737 }
4738}
4739
4740type OxmIdCtIpv6SrcMasked struct {
4741 *OxmId
4742}
4743
4744type IOxmIdCtIpv6SrcMasked interface {
4745 IOxmId
4746}
4747
4748func (self *OxmIdCtIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
4749 if err := self.OxmId.Serialize(encoder); err != nil {
4750 return err
4751 }
4752
4753 return nil
4754}
4755
4756func DecodeOxmIdCtIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6SrcMasked, error) {
4757 _oxmidctipv6srcmasked := &OxmIdCtIpv6SrcMasked{OxmId: parent}
4758 return _oxmidctipv6srcmasked, nil
4759}
4760
4761func NewOxmIdCtIpv6SrcMasked() *OxmIdCtIpv6SrcMasked {
4762 obj := &OxmIdCtIpv6SrcMasked{
4763 OxmId: NewOxmId(128288),
4764 }
4765 return obj
4766}
4767func (self *OxmIdCtIpv6SrcMasked) GetOXMName() string {
4768 return "ct_ipv6_src_masked"
4769}
4770
4771func (self *OxmIdCtIpv6SrcMasked) MarshalJSON() ([]byte, error) {
4772 if self.TypeLen == 0 {
4773 return []byte("\"\""), nil
4774 } else {
4775 return []byte("\"" + self.GetOXMName() + "\""), nil
4776 }
4777}
4778
4779type OxmIdCtLabel struct {
4780 *OxmId
4781}
4782
4783type IOxmIdCtLabel interface {
4784 IOxmId
4785}
4786
4787func (self *OxmIdCtLabel) Serialize(encoder *goloxi.Encoder) error {
4788 if err := self.OxmId.Serialize(encoder); err != nil {
4789 return err
4790 }
4791
4792 return nil
4793}
4794
4795func DecodeOxmIdCtLabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtLabel, error) {
4796 _oxmidctlabel := &OxmIdCtLabel{OxmId: parent}
4797 return _oxmidctlabel, nil
4798}
4799
4800func NewOxmIdCtLabel() *OxmIdCtLabel {
4801 obj := &OxmIdCtLabel{
4802 OxmId: NewOxmId(120848),
4803 }
4804 return obj
4805}
4806func (self *OxmIdCtLabel) GetOXMName() string {
4807 return "ct_label"
4808}
4809
4810func (self *OxmIdCtLabel) MarshalJSON() ([]byte, error) {
4811 if self.TypeLen == 0 {
4812 return []byte("\"\""), nil
4813 } else {
4814 return []byte("\"" + self.GetOXMName() + "\""), nil
4815 }
4816}
4817
4818type OxmIdCtLabelMasked struct {
4819 *OxmId
4820}
4821
4822type IOxmIdCtLabelMasked interface {
4823 IOxmId
4824}
4825
4826func (self *OxmIdCtLabelMasked) Serialize(encoder *goloxi.Encoder) error {
4827 if err := self.OxmId.Serialize(encoder); err != nil {
4828 return err
4829 }
4830
4831 return nil
4832}
4833
4834func DecodeOxmIdCtLabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtLabelMasked, error) {
4835 _oxmidctlabelmasked := &OxmIdCtLabelMasked{OxmId: parent}
4836 return _oxmidctlabelmasked, nil
4837}
4838
4839func NewOxmIdCtLabelMasked() *OxmIdCtLabelMasked {
4840 obj := &OxmIdCtLabelMasked{
4841 OxmId: NewOxmId(121120),
4842 }
4843 return obj
4844}
4845func (self *OxmIdCtLabelMasked) GetOXMName() string {
4846 return "ct_label_masked"
4847}
4848
4849func (self *OxmIdCtLabelMasked) MarshalJSON() ([]byte, error) {
4850 if self.TypeLen == 0 {
4851 return []byte("\"\""), nil
4852 } else {
4853 return []byte("\"" + self.GetOXMName() + "\""), nil
4854 }
4855}
4856
4857type OxmIdCtMark struct {
4858 *OxmId
4859}
4860
4861type IOxmIdCtMark interface {
4862 IOxmId
4863}
4864
4865func (self *OxmIdCtMark) Serialize(encoder *goloxi.Encoder) error {
4866 if err := self.OxmId.Serialize(encoder); err != nil {
4867 return err
4868 }
4869
4870 return nil
4871}
4872
4873func DecodeOxmIdCtMark(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtMark, error) {
4874 _oxmidctmark := &OxmIdCtMark{OxmId: parent}
4875 return _oxmidctmark, nil
4876}
4877
4878func NewOxmIdCtMark() *OxmIdCtMark {
4879 obj := &OxmIdCtMark{
4880 OxmId: NewOxmId(120324),
4881 }
4882 return obj
4883}
4884func (self *OxmIdCtMark) GetOXMName() string {
4885 return "ct_mark"
4886}
4887
4888func (self *OxmIdCtMark) MarshalJSON() ([]byte, error) {
4889 if self.TypeLen == 0 {
4890 return []byte("\"\""), nil
4891 } else {
4892 return []byte("\"" + self.GetOXMName() + "\""), nil
4893 }
4894}
4895
4896type OxmIdCtMarkMasked struct {
4897 *OxmId
4898}
4899
4900type IOxmIdCtMarkMasked interface {
4901 IOxmId
4902}
4903
4904func (self *OxmIdCtMarkMasked) Serialize(encoder *goloxi.Encoder) error {
4905 if err := self.OxmId.Serialize(encoder); err != nil {
4906 return err
4907 }
4908
4909 return nil
4910}
4911
4912func DecodeOxmIdCtMarkMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtMarkMasked, error) {
4913 _oxmidctmarkmasked := &OxmIdCtMarkMasked{OxmId: parent}
4914 return _oxmidctmarkmasked, nil
4915}
4916
4917func NewOxmIdCtMarkMasked() *OxmIdCtMarkMasked {
4918 obj := &OxmIdCtMarkMasked{
4919 OxmId: NewOxmId(120584),
4920 }
4921 return obj
4922}
4923func (self *OxmIdCtMarkMasked) GetOXMName() string {
4924 return "ct_mark_masked"
4925}
4926
4927func (self *OxmIdCtMarkMasked) MarshalJSON() ([]byte, error) {
4928 if self.TypeLen == 0 {
4929 return []byte("\"\""), nil
4930 } else {
4931 return []byte("\"" + self.GetOXMName() + "\""), nil
4932 }
4933}
4934
4935type OxmIdCtNwDst struct {
4936 *OxmId
4937}
4938
4939type IOxmIdCtNwDst interface {
4940 IOxmId
4941}
4942
4943func (self *OxmIdCtNwDst) Serialize(encoder *goloxi.Encoder) error {
4944 if err := self.OxmId.Serialize(encoder); err != nil {
4945 return err
4946 }
4947
4948 return nil
4949}
4950
4951func DecodeOxmIdCtNwDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwDst, error) {
4952 _oxmidctnwdst := &OxmIdCtNwDst{OxmId: parent}
4953 return _oxmidctnwdst, nil
4954}
4955
4956func NewOxmIdCtNwDst() *OxmIdCtNwDst {
4957 obj := &OxmIdCtNwDst{
4958 OxmId: NewOxmId(127492),
4959 }
4960 return obj
4961}
4962func (self *OxmIdCtNwDst) GetOXMName() string {
4963 return "ct_nw_dst"
4964}
4965
4966func (self *OxmIdCtNwDst) MarshalJSON() ([]byte, error) {
4967 if self.TypeLen == 0 {
4968 return []byte("\"\""), nil
4969 } else {
4970 return []byte("\"" + self.GetOXMName() + "\""), nil
4971 }
4972}
4973
4974type OxmIdCtNwDstMasked struct {
4975 *OxmId
4976}
4977
4978type IOxmIdCtNwDstMasked interface {
4979 IOxmId
4980}
4981
4982func (self *OxmIdCtNwDstMasked) Serialize(encoder *goloxi.Encoder) error {
4983 if err := self.OxmId.Serialize(encoder); err != nil {
4984 return err
4985 }
4986
4987 return nil
4988}
4989
4990func DecodeOxmIdCtNwDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwDstMasked, error) {
4991 _oxmidctnwdstmasked := &OxmIdCtNwDstMasked{OxmId: parent}
4992 return _oxmidctnwdstmasked, nil
4993}
4994
4995func NewOxmIdCtNwDstMasked() *OxmIdCtNwDstMasked {
4996 obj := &OxmIdCtNwDstMasked{
4997 OxmId: NewOxmId(127752),
4998 }
4999 return obj
5000}
5001func (self *OxmIdCtNwDstMasked) GetOXMName() string {
5002 return "ct_nw_dst_masked"
5003}
5004
5005func (self *OxmIdCtNwDstMasked) MarshalJSON() ([]byte, error) {
5006 if self.TypeLen == 0 {
5007 return []byte("\"\""), nil
5008 } else {
5009 return []byte("\"" + self.GetOXMName() + "\""), nil
5010 }
5011}
5012
5013type OxmIdCtNwProto struct {
5014 *OxmId
5015}
5016
5017type IOxmIdCtNwProto interface {
5018 IOxmId
5019}
5020
5021func (self *OxmIdCtNwProto) Serialize(encoder *goloxi.Encoder) error {
5022 if err := self.OxmId.Serialize(encoder); err != nil {
5023 return err
5024 }
5025
5026 return nil
5027}
5028
5029func DecodeOxmIdCtNwProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwProto, error) {
5030 _oxmidctnwproto := &OxmIdCtNwProto{OxmId: parent}
5031 return _oxmidctnwproto, nil
5032}
5033
5034func NewOxmIdCtNwProto() *OxmIdCtNwProto {
5035 obj := &OxmIdCtNwProto{
5036 OxmId: NewOxmId(126465),
5037 }
5038 return obj
5039}
5040func (self *OxmIdCtNwProto) GetOXMName() string {
5041 return "ct_nw_proto"
5042}
5043
5044func (self *OxmIdCtNwProto) MarshalJSON() ([]byte, error) {
5045 if self.TypeLen == 0 {
5046 return []byte("\"\""), nil
5047 } else {
5048 return []byte("\"" + self.GetOXMName() + "\""), nil
5049 }
5050}
5051
5052type OxmIdCtNwSrc struct {
5053 *OxmId
5054}
5055
5056type IOxmIdCtNwSrc interface {
5057 IOxmId
5058}
5059
5060func (self *OxmIdCtNwSrc) Serialize(encoder *goloxi.Encoder) error {
5061 if err := self.OxmId.Serialize(encoder); err != nil {
5062 return err
5063 }
5064
5065 return nil
5066}
5067
5068func DecodeOxmIdCtNwSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwSrc, error) {
5069 _oxmidctnwsrc := &OxmIdCtNwSrc{OxmId: parent}
5070 return _oxmidctnwsrc, nil
5071}
5072
5073func NewOxmIdCtNwSrc() *OxmIdCtNwSrc {
5074 obj := &OxmIdCtNwSrc{
5075 OxmId: NewOxmId(126980),
5076 }
5077 return obj
5078}
5079func (self *OxmIdCtNwSrc) GetOXMName() string {
5080 return "ct_nw_src"
5081}
5082
5083func (self *OxmIdCtNwSrc) MarshalJSON() ([]byte, error) {
5084 if self.TypeLen == 0 {
5085 return []byte("\"\""), nil
5086 } else {
5087 return []byte("\"" + self.GetOXMName() + "\""), nil
5088 }
5089}
5090
5091type OxmIdCtNwSrcMasked struct {
5092 *OxmId
5093}
5094
5095type IOxmIdCtNwSrcMasked interface {
5096 IOxmId
5097}
5098
5099func (self *OxmIdCtNwSrcMasked) Serialize(encoder *goloxi.Encoder) error {
5100 if err := self.OxmId.Serialize(encoder); err != nil {
5101 return err
5102 }
5103
5104 return nil
5105}
5106
5107func DecodeOxmIdCtNwSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwSrcMasked, error) {
5108 _oxmidctnwsrcmasked := &OxmIdCtNwSrcMasked{OxmId: parent}
5109 return _oxmidctnwsrcmasked, nil
5110}
5111
5112func NewOxmIdCtNwSrcMasked() *OxmIdCtNwSrcMasked {
5113 obj := &OxmIdCtNwSrcMasked{
5114 OxmId: NewOxmId(127240),
5115 }
5116 return obj
5117}
5118func (self *OxmIdCtNwSrcMasked) GetOXMName() string {
5119 return "ct_nw_src_masked"
5120}
5121
5122func (self *OxmIdCtNwSrcMasked) MarshalJSON() ([]byte, error) {
5123 if self.TypeLen == 0 {
5124 return []byte("\"\""), nil
5125 } else {
5126 return []byte("\"" + self.GetOXMName() + "\""), nil
5127 }
5128}
5129
5130type OxmIdCtState struct {
5131 *OxmId
5132}
5133
5134type IOxmIdCtState interface {
5135 IOxmId
5136}
5137
5138func (self *OxmIdCtState) Serialize(encoder *goloxi.Encoder) error {
5139 if err := self.OxmId.Serialize(encoder); err != nil {
5140 return err
5141 }
5142
5143 return nil
5144}
5145
5146func DecodeOxmIdCtState(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtState, error) {
5147 _oxmidctstate := &OxmIdCtState{OxmId: parent}
5148 return _oxmidctstate, nil
5149}
5150
5151func NewOxmIdCtState() *OxmIdCtState {
5152 obj := &OxmIdCtState{
5153 OxmId: NewOxmId(119300),
5154 }
5155 return obj
5156}
5157func (self *OxmIdCtState) GetOXMName() string {
5158 return "ct_state"
5159}
5160
5161func (self *OxmIdCtState) MarshalJSON() ([]byte, error) {
5162 if self.TypeLen == 0 {
5163 return []byte("\"\""), nil
5164 } else {
5165 return []byte("\"" + self.GetOXMName() + "\""), nil
5166 }
5167}
5168
5169type OxmIdCtStateMasked struct {
5170 *OxmId
5171}
5172
5173type IOxmIdCtStateMasked interface {
5174 IOxmId
5175}
5176
5177func (self *OxmIdCtStateMasked) Serialize(encoder *goloxi.Encoder) error {
5178 if err := self.OxmId.Serialize(encoder); err != nil {
5179 return err
5180 }
5181
5182 return nil
5183}
5184
5185func DecodeOxmIdCtStateMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtStateMasked, error) {
5186 _oxmidctstatemasked := &OxmIdCtStateMasked{OxmId: parent}
5187 return _oxmidctstatemasked, nil
5188}
5189
5190func NewOxmIdCtStateMasked() *OxmIdCtStateMasked {
5191 obj := &OxmIdCtStateMasked{
5192 OxmId: NewOxmId(119560),
5193 }
5194 return obj
5195}
5196func (self *OxmIdCtStateMasked) GetOXMName() string {
5197 return "ct_state_masked"
5198}
5199
5200func (self *OxmIdCtStateMasked) MarshalJSON() ([]byte, error) {
5201 if self.TypeLen == 0 {
5202 return []byte("\"\""), nil
5203 } else {
5204 return []byte("\"" + self.GetOXMName() + "\""), nil
5205 }
5206}
5207
5208type OxmIdCtTpDst struct {
5209 *OxmId
5210}
5211
5212type IOxmIdCtTpDst interface {
5213 IOxmId
5214}
5215
5216func (self *OxmIdCtTpDst) Serialize(encoder *goloxi.Encoder) error {
5217 if err := self.OxmId.Serialize(encoder); err != nil {
5218 return err
5219 }
5220
5221 return nil
5222}
5223
5224func DecodeOxmIdCtTpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpDst, error) {
5225 _oxmidcttpdst := &OxmIdCtTpDst{OxmId: parent}
5226 return _oxmidcttpdst, nil
5227}
5228
5229func NewOxmIdCtTpDst() *OxmIdCtTpDst {
5230 obj := &OxmIdCtTpDst{
5231 OxmId: NewOxmId(129538),
5232 }
5233 return obj
5234}
5235func (self *OxmIdCtTpDst) GetOXMName() string {
5236 return "ct_tp_dst"
5237}
5238
5239func (self *OxmIdCtTpDst) MarshalJSON() ([]byte, error) {
5240 if self.TypeLen == 0 {
5241 return []byte("\"\""), nil
5242 } else {
5243 return []byte("\"" + self.GetOXMName() + "\""), nil
5244 }
5245}
5246
5247type OxmIdCtTpDstMasked struct {
5248 *OxmId
5249}
5250
5251type IOxmIdCtTpDstMasked interface {
5252 IOxmId
5253}
5254
5255func (self *OxmIdCtTpDstMasked) Serialize(encoder *goloxi.Encoder) error {
5256 if err := self.OxmId.Serialize(encoder); err != nil {
5257 return err
5258 }
5259
5260 return nil
5261}
5262
5263func DecodeOxmIdCtTpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpDstMasked, error) {
5264 _oxmidcttpdstmasked := &OxmIdCtTpDstMasked{OxmId: parent}
5265 return _oxmidcttpdstmasked, nil
5266}
5267
5268func NewOxmIdCtTpDstMasked() *OxmIdCtTpDstMasked {
5269 obj := &OxmIdCtTpDstMasked{
5270 OxmId: NewOxmId(129796),
5271 }
5272 return obj
5273}
5274func (self *OxmIdCtTpDstMasked) GetOXMName() string {
5275 return "ct_tp_dst_masked"
5276}
5277
5278func (self *OxmIdCtTpDstMasked) MarshalJSON() ([]byte, error) {
5279 if self.TypeLen == 0 {
5280 return []byte("\"\""), nil
5281 } else {
5282 return []byte("\"" + self.GetOXMName() + "\""), nil
5283 }
5284}
5285
5286type OxmIdCtTpSrc struct {
5287 *OxmId
5288}
5289
5290type IOxmIdCtTpSrc interface {
5291 IOxmId
5292}
5293
5294func (self *OxmIdCtTpSrc) Serialize(encoder *goloxi.Encoder) error {
5295 if err := self.OxmId.Serialize(encoder); err != nil {
5296 return err
5297 }
5298
5299 return nil
5300}
5301
5302func DecodeOxmIdCtTpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpSrc, error) {
5303 _oxmidcttpsrc := &OxmIdCtTpSrc{OxmId: parent}
5304 return _oxmidcttpsrc, nil
5305}
5306
5307func NewOxmIdCtTpSrc() *OxmIdCtTpSrc {
5308 obj := &OxmIdCtTpSrc{
5309 OxmId: NewOxmId(129026),
5310 }
5311 return obj
5312}
5313func (self *OxmIdCtTpSrc) GetOXMName() string {
5314 return "ct_tp_src"
5315}
5316
5317func (self *OxmIdCtTpSrc) MarshalJSON() ([]byte, error) {
5318 if self.TypeLen == 0 {
5319 return []byte("\"\""), nil
5320 } else {
5321 return []byte("\"" + self.GetOXMName() + "\""), nil
5322 }
5323}
5324
5325type OxmIdCtTpSrcMasked struct {
5326 *OxmId
5327}
5328
5329type IOxmIdCtTpSrcMasked interface {
5330 IOxmId
5331}
5332
5333func (self *OxmIdCtTpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
5334 if err := self.OxmId.Serialize(encoder); err != nil {
5335 return err
5336 }
5337
5338 return nil
5339}
5340
5341func DecodeOxmIdCtTpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpSrcMasked, error) {
5342 _oxmidcttpsrcmasked := &OxmIdCtTpSrcMasked{OxmId: parent}
5343 return _oxmidcttpsrcmasked, nil
5344}
5345
5346func NewOxmIdCtTpSrcMasked() *OxmIdCtTpSrcMasked {
5347 obj := &OxmIdCtTpSrcMasked{
5348 OxmId: NewOxmId(129284),
5349 }
5350 return obj
5351}
5352func (self *OxmIdCtTpSrcMasked) GetOXMName() string {
5353 return "ct_tp_src_masked"
5354}
5355
5356func (self *OxmIdCtTpSrcMasked) MarshalJSON() ([]byte, error) {
5357 if self.TypeLen == 0 {
5358 return []byte("\"\""), nil
5359 } else {
5360 return []byte("\"" + self.GetOXMName() + "\""), nil
5361 }
5362}
5363
5364type OxmIdCtZone struct {
5365 *OxmId
5366}
5367
5368type IOxmIdCtZone interface {
5369 IOxmId
5370}
5371
5372func (self *OxmIdCtZone) Serialize(encoder *goloxi.Encoder) error {
5373 if err := self.OxmId.Serialize(encoder); err != nil {
5374 return err
5375 }
5376
5377 return nil
5378}
5379
5380func DecodeOxmIdCtZone(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtZone, error) {
5381 _oxmidctzone := &OxmIdCtZone{OxmId: parent}
5382 return _oxmidctzone, nil
5383}
5384
5385func NewOxmIdCtZone() *OxmIdCtZone {
5386 obj := &OxmIdCtZone{
5387 OxmId: NewOxmId(119810),
5388 }
5389 return obj
5390}
5391func (self *OxmIdCtZone) GetOXMName() string {
5392 return "ct_zone"
5393}
5394
5395func (self *OxmIdCtZone) MarshalJSON() ([]byte, error) {
5396 if self.TypeLen == 0 {
5397 return []byte("\"\""), nil
5398 } else {
5399 return []byte("\"" + self.GetOXMName() + "\""), nil
5400 }
5401}
5402
5403type OxmIdDpHash struct {
5404 *OxmId
5405}
5406
5407type IOxmIdDpHash interface {
5408 IOxmId
5409}
5410
5411func (self *OxmIdDpHash) Serialize(encoder *goloxi.Encoder) error {
5412 if err := self.OxmId.Serialize(encoder); err != nil {
5413 return err
5414 }
5415
5416 return nil
5417}
5418
5419func DecodeOxmIdDpHash(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdDpHash, error) {
5420 _oxmiddphash := &OxmIdDpHash{OxmId: parent}
5421 return _oxmiddphash, nil
5422}
5423
5424func NewOxmIdDpHash() *OxmIdDpHash {
5425 obj := &OxmIdDpHash{
5426 OxmId: NewOxmId(83460),
5427 }
5428 return obj
5429}
5430func (self *OxmIdDpHash) GetOXMName() string {
5431 return "dp_hash"
5432}
5433
5434func (self *OxmIdDpHash) MarshalJSON() ([]byte, error) {
5435 if self.TypeLen == 0 {
5436 return []byte("\"\""), nil
5437 } else {
5438 return []byte("\"" + self.GetOXMName() + "\""), nil
5439 }
5440}
5441
5442type OxmIdDpHashMasked struct {
5443 *OxmId
5444}
5445
5446type IOxmIdDpHashMasked interface {
5447 IOxmId
5448}
5449
5450func (self *OxmIdDpHashMasked) Serialize(encoder *goloxi.Encoder) error {
5451 if err := self.OxmId.Serialize(encoder); err != nil {
5452 return err
5453 }
5454
5455 return nil
5456}
5457
5458func DecodeOxmIdDpHashMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdDpHashMasked, error) {
5459 _oxmiddphashmasked := &OxmIdDpHashMasked{OxmId: parent}
5460 return _oxmiddphashmasked, nil
5461}
5462
5463func NewOxmIdDpHashMasked() *OxmIdDpHashMasked {
5464 obj := &OxmIdDpHashMasked{
5465 OxmId: NewOxmId(83720),
5466 }
5467 return obj
5468}
5469func (self *OxmIdDpHashMasked) GetOXMName() string {
5470 return "dp_hash_masked"
5471}
5472
5473func (self *OxmIdDpHashMasked) MarshalJSON() ([]byte, error) {
5474 if self.TypeLen == 0 {
5475 return []byte("\"\""), nil
5476 } else {
5477 return []byte("\"" + self.GetOXMName() + "\""), nil
5478 }
5479}
5480
5481type OxmIdEthDst struct {
5482 *OxmId
5483}
5484
5485type IOxmIdEthDst interface {
5486 IOxmId
5487}
5488
5489func (self *OxmIdEthDst) Serialize(encoder *goloxi.Encoder) error {
5490 if err := self.OxmId.Serialize(encoder); err != nil {
5491 return err
5492 }
5493
5494 return nil
5495}
5496
5497func DecodeOxmIdEthDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthDst, error) {
5498 _oxmidethdst := &OxmIdEthDst{OxmId: parent}
5499 return _oxmidethdst, nil
5500}
5501
5502func NewOxmIdEthDst() *OxmIdEthDst {
5503 obj := &OxmIdEthDst{
5504 OxmId: NewOxmId(518),
5505 }
5506 return obj
5507}
5508func (self *OxmIdEthDst) GetOXMName() string {
5509 return "eth_dst"
5510}
5511
5512func (self *OxmIdEthDst) MarshalJSON() ([]byte, error) {
5513 if self.TypeLen == 0 {
5514 return []byte("\"\""), nil
5515 } else {
5516 return []byte("\"" + self.GetOXMName() + "\""), nil
5517 }
5518}
5519
5520type OxmIdEthDstMasked struct {
5521 *OxmId
5522}
5523
5524type IOxmIdEthDstMasked interface {
5525 IOxmId
5526}
5527
5528func (self *OxmIdEthDstMasked) Serialize(encoder *goloxi.Encoder) error {
5529 if err := self.OxmId.Serialize(encoder); err != nil {
5530 return err
5531 }
5532
5533 return nil
5534}
5535
5536func DecodeOxmIdEthDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthDstMasked, error) {
5537 _oxmidethdstmasked := &OxmIdEthDstMasked{OxmId: parent}
5538 return _oxmidethdstmasked, nil
5539}
5540
5541func NewOxmIdEthDstMasked() *OxmIdEthDstMasked {
5542 obj := &OxmIdEthDstMasked{
5543 OxmId: NewOxmId(779),
5544 }
5545 return obj
5546}
5547func (self *OxmIdEthDstMasked) GetOXMName() string {
5548 return "eth_dst_masked"
5549}
5550
5551func (self *OxmIdEthDstMasked) MarshalJSON() ([]byte, error) {
5552 if self.TypeLen == 0 {
5553 return []byte("\"\""), nil
5554 } else {
5555 return []byte("\"" + self.GetOXMName() + "\""), nil
5556 }
5557}
5558
5559type OxmIdEthSrc struct {
5560 *OxmId
5561}
5562
5563type IOxmIdEthSrc interface {
5564 IOxmId
5565}
5566
5567func (self *OxmIdEthSrc) Serialize(encoder *goloxi.Encoder) error {
5568 if err := self.OxmId.Serialize(encoder); err != nil {
5569 return err
5570 }
5571
5572 return nil
5573}
5574
5575func DecodeOxmIdEthSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthSrc, error) {
5576 _oxmidethsrc := &OxmIdEthSrc{OxmId: parent}
5577 return _oxmidethsrc, nil
5578}
5579
5580func NewOxmIdEthSrc() *OxmIdEthSrc {
5581 obj := &OxmIdEthSrc{
5582 OxmId: NewOxmId(1030),
5583 }
5584 return obj
5585}
5586func (self *OxmIdEthSrc) GetOXMName() string {
5587 return "eth_src"
5588}
5589
5590func (self *OxmIdEthSrc) MarshalJSON() ([]byte, error) {
5591 if self.TypeLen == 0 {
5592 return []byte("\"\""), nil
5593 } else {
5594 return []byte("\"" + self.GetOXMName() + "\""), nil
5595 }
5596}
5597
5598type OxmIdEthSrcMasked struct {
5599 *OxmId
5600}
5601
5602type IOxmIdEthSrcMasked interface {
5603 IOxmId
5604}
5605
5606func (self *OxmIdEthSrcMasked) Serialize(encoder *goloxi.Encoder) error {
5607 if err := self.OxmId.Serialize(encoder); err != nil {
5608 return err
5609 }
5610
5611 return nil
5612}
5613
5614func DecodeOxmIdEthSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthSrcMasked, error) {
5615 _oxmidethsrcmasked := &OxmIdEthSrcMasked{OxmId: parent}
5616 return _oxmidethsrcmasked, nil
5617}
5618
5619func NewOxmIdEthSrcMasked() *OxmIdEthSrcMasked {
5620 obj := &OxmIdEthSrcMasked{
5621 OxmId: NewOxmId(1286),
5622 }
5623 return obj
5624}
5625func (self *OxmIdEthSrcMasked) GetOXMName() string {
5626 return "eth_src_masked"
5627}
5628
5629func (self *OxmIdEthSrcMasked) MarshalJSON() ([]byte, error) {
5630 if self.TypeLen == 0 {
5631 return []byte("\"\""), nil
5632 } else {
5633 return []byte("\"" + self.GetOXMName() + "\""), nil
5634 }
5635}
5636
5637type OxmIdEthType struct {
5638 *OxmId
5639}
5640
5641type IOxmIdEthType interface {
5642 IOxmId
5643}
5644
5645func (self *OxmIdEthType) Serialize(encoder *goloxi.Encoder) error {
5646 if err := self.OxmId.Serialize(encoder); err != nil {
5647 return err
5648 }
5649
5650 return nil
5651}
5652
5653func DecodeOxmIdEthType(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthType, error) {
5654 _oxmidethtype := &OxmIdEthType{OxmId: parent}
5655 return _oxmidethtype, nil
5656}
5657
5658func NewOxmIdEthType() *OxmIdEthType {
5659 obj := &OxmIdEthType{
5660 OxmId: NewOxmId(1538),
5661 }
5662 return obj
5663}
5664func (self *OxmIdEthType) GetOXMName() string {
5665 return "eth_type"
5666}
5667
5668func (self *OxmIdEthType) MarshalJSON() ([]byte, error) {
5669 if self.TypeLen == 0 {
5670 return []byte("\"\""), nil
5671 } else {
5672 return []byte("\"" + self.GetOXMName() + "\""), nil
5673 }
5674}
5675
5676type OxmIdIcmpCode struct {
5677 *OxmId
5678}
5679
5680type IOxmIdIcmpCode interface {
5681 IOxmId
5682}
5683
5684func (self *OxmIdIcmpCode) Serialize(encoder *goloxi.Encoder) error {
5685 if err := self.OxmId.Serialize(encoder); err != nil {
5686 return err
5687 }
5688
5689 return nil
5690}
5691
5692func DecodeOxmIdIcmpCode(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpCode, error) {
5693 _oxmidicmpcode := &OxmIdIcmpCode{OxmId: parent}
5694 return _oxmidicmpcode, nil
5695}
5696
5697func NewOxmIdIcmpCode() *OxmIdIcmpCode {
5698 obj := &OxmIdIcmpCode{
5699 OxmId: NewOxmId(7169),
5700 }
5701 return obj
5702}
5703func (self *OxmIdIcmpCode) GetOXMName() string {
5704 return "icmp_code"
5705}
5706
5707func (self *OxmIdIcmpCode) MarshalJSON() ([]byte, error) {
5708 if self.TypeLen == 0 {
5709 return []byte("\"\""), nil
5710 } else {
5711 return []byte("\"" + self.GetOXMName() + "\""), nil
5712 }
5713}
5714
5715type OxmIdIcmpType struct {
5716 *OxmId
5717}
5718
5719type IOxmIdIcmpType interface {
5720 IOxmId
5721}
5722
5723func (self *OxmIdIcmpType) Serialize(encoder *goloxi.Encoder) error {
5724 if err := self.OxmId.Serialize(encoder); err != nil {
5725 return err
5726 }
5727
5728 return nil
5729}
5730
5731func DecodeOxmIdIcmpType(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpType, error) {
5732 _oxmidicmptype := &OxmIdIcmpType{OxmId: parent}
5733 return _oxmidicmptype, nil
5734}
5735
5736func NewOxmIdIcmpType() *OxmIdIcmpType {
5737 obj := &OxmIdIcmpType{
5738 OxmId: NewOxmId(6657),
5739 }
5740 return obj
5741}
5742func (self *OxmIdIcmpType) GetOXMName() string {
5743 return "icmp_type"
5744}
5745
5746func (self *OxmIdIcmpType) MarshalJSON() ([]byte, error) {
5747 if self.TypeLen == 0 {
5748 return []byte("\"\""), nil
5749 } else {
5750 return []byte("\"" + self.GetOXMName() + "\""), nil
5751 }
5752}
5753
5754type OxmIdIcmpv6Code struct {
5755 *OxmId
5756}
5757
5758type IOxmIdIcmpv6Code interface {
5759 IOxmId
5760}
5761
5762func (self *OxmIdIcmpv6Code) Serialize(encoder *goloxi.Encoder) error {
5763 if err := self.OxmId.Serialize(encoder); err != nil {
5764 return err
5765 }
5766
5767 return nil
5768}
5769
5770func DecodeOxmIdIcmpv6Code(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6Code, error) {
5771 _oxmidicmpv6code := &OxmIdIcmpv6Code{OxmId: parent}
5772 return _oxmidicmpv6code, nil
5773}
5774
5775func NewOxmIdIcmpv6Code() *OxmIdIcmpv6Code {
5776 obj := &OxmIdIcmpv6Code{
5777 OxmId: NewOxmId(76801),
5778 }
5779 return obj
5780}
5781func (self *OxmIdIcmpv6Code) GetOXMName() string {
5782 return "icmpv6_code"
5783}
5784
5785func (self *OxmIdIcmpv6Code) MarshalJSON() ([]byte, error) {
5786 if self.TypeLen == 0 {
5787 return []byte("\"\""), nil
5788 } else {
5789 return []byte("\"" + self.GetOXMName() + "\""), nil
5790 }
5791}
5792
5793type OxmIdIcmpv6Type struct {
5794 *OxmId
5795}
5796
5797type IOxmIdIcmpv6Type interface {
5798 IOxmId
5799}
5800
5801func (self *OxmIdIcmpv6Type) Serialize(encoder *goloxi.Encoder) error {
5802 if err := self.OxmId.Serialize(encoder); err != nil {
5803 return err
5804 }
5805
5806 return nil
5807}
5808
5809func DecodeOxmIdIcmpv6Type(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6Type, error) {
5810 _oxmidicmpv6type := &OxmIdIcmpv6Type{OxmId: parent}
5811 return _oxmidicmpv6type, nil
5812}
5813
5814func NewOxmIdIcmpv6Type() *OxmIdIcmpv6Type {
5815 obj := &OxmIdIcmpv6Type{
5816 OxmId: NewOxmId(76289),
5817 }
5818 return obj
5819}
5820func (self *OxmIdIcmpv6Type) GetOXMName() string {
5821 return "icmpv6_type"
5822}
5823
5824func (self *OxmIdIcmpv6Type) MarshalJSON() ([]byte, error) {
5825 if self.TypeLen == 0 {
5826 return []byte("\"\""), nil
5827 } else {
5828 return []byte("\"" + self.GetOXMName() + "\""), nil
5829 }
5830}
5831
5832type OxmIdInPort struct {
5833 *OxmId
5834}
5835
5836type IOxmIdInPort interface {
5837 IOxmId
5838}
5839
5840func (self *OxmIdInPort) Serialize(encoder *goloxi.Encoder) error {
5841 if err := self.OxmId.Serialize(encoder); err != nil {
5842 return err
5843 }
5844
5845 return nil
5846}
5847
5848func DecodeOxmIdInPort(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPort, error) {
5849 _oxmidinport := &OxmIdInPort{OxmId: parent}
5850 return _oxmidinport, nil
5851}
5852
5853func NewOxmIdInPort() *OxmIdInPort {
5854 obj := &OxmIdInPort{
5855 OxmId: NewOxmId(2),
5856 }
5857 return obj
5858}
5859func (self *OxmIdInPort) GetOXMName() string {
5860 return "in_port"
5861}
5862
5863func (self *OxmIdInPort) MarshalJSON() ([]byte, error) {
5864 if self.TypeLen == 0 {
5865 return []byte("\"\""), nil
5866 } else {
5867 return []byte("\"" + self.GetOXMName() + "\""), nil
5868 }
5869}
5870
5871type OxmIdIpDst struct {
5872 *OxmId
5873}
5874
5875type IOxmIdIpDst interface {
5876 IOxmId
5877}
5878
5879func (self *OxmIdIpDst) Serialize(encoder *goloxi.Encoder) error {
5880 if err := self.OxmId.Serialize(encoder); err != nil {
5881 return err
5882 }
5883
5884 return nil
5885}
5886
5887func DecodeOxmIdIpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDst, error) {
5888 _oxmidipdst := &OxmIdIpDst{OxmId: parent}
5889 return _oxmidipdst, nil
5890}
5891
5892func NewOxmIdIpDst() *OxmIdIpDst {
5893 obj := &OxmIdIpDst{
5894 OxmId: NewOxmId(4100),
5895 }
5896 return obj
5897}
5898func (self *OxmIdIpDst) GetOXMName() string {
5899 return "ip_dst"
5900}
5901
5902func (self *OxmIdIpDst) MarshalJSON() ([]byte, error) {
5903 if self.TypeLen == 0 {
5904 return []byte("\"\""), nil
5905 } else {
5906 return []byte("\"" + self.GetOXMName() + "\""), nil
5907 }
5908}
5909
5910type OxmIdIpDstMasked struct {
5911 *OxmId
5912}
5913
5914type IOxmIdIpDstMasked interface {
5915 IOxmId
5916}
5917
5918func (self *OxmIdIpDstMasked) Serialize(encoder *goloxi.Encoder) error {
5919 if err := self.OxmId.Serialize(encoder); err != nil {
5920 return err
5921 }
5922
5923 return nil
5924}
5925
5926func DecodeOxmIdIpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDstMasked, error) {
5927 _oxmidipdstmasked := &OxmIdIpDstMasked{OxmId: parent}
5928 return _oxmidipdstmasked, nil
5929}
5930
5931func NewOxmIdIpDstMasked() *OxmIdIpDstMasked {
5932 obj := &OxmIdIpDstMasked{
5933 OxmId: NewOxmId(4360),
5934 }
5935 return obj
5936}
5937func (self *OxmIdIpDstMasked) GetOXMName() string {
5938 return "ip_dst_masked"
5939}
5940
5941func (self *OxmIdIpDstMasked) MarshalJSON() ([]byte, error) {
5942 if self.TypeLen == 0 {
5943 return []byte("\"\""), nil
5944 } else {
5945 return []byte("\"" + self.GetOXMName() + "\""), nil
5946 }
5947}
5948
5949type OxmIdIpFrag struct {
5950 *OxmId
5951}
5952
5953type IOxmIdIpFrag interface {
5954 IOxmId
5955}
5956
5957func (self *OxmIdIpFrag) Serialize(encoder *goloxi.Encoder) error {
5958 if err := self.OxmId.Serialize(encoder); err != nil {
5959 return err
5960 }
5961
5962 return nil
5963}
5964
5965func DecodeOxmIdIpFrag(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpFrag, error) {
5966 _oxmidipfrag := &OxmIdIpFrag{OxmId: parent}
5967 return _oxmidipfrag, nil
5968}
5969
5970func NewOxmIdIpFrag() *OxmIdIpFrag {
5971 obj := &OxmIdIpFrag{
5972 OxmId: NewOxmId(78849),
5973 }
5974 return obj
5975}
5976func (self *OxmIdIpFrag) GetOXMName() string {
5977 return "ip_frag"
5978}
5979
5980func (self *OxmIdIpFrag) MarshalJSON() ([]byte, error) {
5981 if self.TypeLen == 0 {
5982 return []byte("\"\""), nil
5983 } else {
5984 return []byte("\"" + self.GetOXMName() + "\""), nil
5985 }
5986}
5987
5988type OxmIdIpFragMasked struct {
5989 *OxmId
5990}
5991
5992type IOxmIdIpFragMasked interface {
5993 IOxmId
5994}
5995
5996func (self *OxmIdIpFragMasked) Serialize(encoder *goloxi.Encoder) error {
5997 if err := self.OxmId.Serialize(encoder); err != nil {
5998 return err
5999 }
6000
6001 return nil
6002}
6003
6004func DecodeOxmIdIpFragMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpFragMasked, error) {
6005 _oxmidipfragmasked := &OxmIdIpFragMasked{OxmId: parent}
6006 return _oxmidipfragmasked, nil
6007}
6008
6009func NewOxmIdIpFragMasked() *OxmIdIpFragMasked {
6010 obj := &OxmIdIpFragMasked{
6011 OxmId: NewOxmId(79106),
6012 }
6013 return obj
6014}
6015func (self *OxmIdIpFragMasked) GetOXMName() string {
6016 return "ip_frag_masked"
6017}
6018
6019func (self *OxmIdIpFragMasked) MarshalJSON() ([]byte, error) {
6020 if self.TypeLen == 0 {
6021 return []byte("\"\""), nil
6022 } else {
6023 return []byte("\"" + self.GetOXMName() + "\""), nil
6024 }
6025}
6026
6027type OxmIdIpSrc struct {
6028 *OxmId
6029}
6030
6031type IOxmIdIpSrc interface {
6032 IOxmId
6033}
6034
6035func (self *OxmIdIpSrc) Serialize(encoder *goloxi.Encoder) error {
6036 if err := self.OxmId.Serialize(encoder); err != nil {
6037 return err
6038 }
6039
6040 return nil
6041}
6042
6043func DecodeOxmIdIpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpSrc, error) {
6044 _oxmidipsrc := &OxmIdIpSrc{OxmId: parent}
6045 return _oxmidipsrc, nil
6046}
6047
6048func NewOxmIdIpSrc() *OxmIdIpSrc {
6049 obj := &OxmIdIpSrc{
6050 OxmId: NewOxmId(3588),
6051 }
6052 return obj
6053}
6054func (self *OxmIdIpSrc) GetOXMName() string {
6055 return "ip_src"
6056}
6057
6058func (self *OxmIdIpSrc) MarshalJSON() ([]byte, error) {
6059 if self.TypeLen == 0 {
6060 return []byte("\"\""), nil
6061 } else {
6062 return []byte("\"" + self.GetOXMName() + "\""), nil
6063 }
6064}
6065
6066type OxmIdIpSrcMasked struct {
6067 *OxmId
6068}
6069
6070type IOxmIdIpSrcMasked interface {
6071 IOxmId
6072}
6073
6074func (self *OxmIdIpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
6075 if err := self.OxmId.Serialize(encoder); err != nil {
6076 return err
6077 }
6078
6079 return nil
6080}
6081
6082func DecodeOxmIdIpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpSrcMasked, error) {
6083 _oxmidipsrcmasked := &OxmIdIpSrcMasked{OxmId: parent}
6084 return _oxmidipsrcmasked, nil
6085}
6086
6087func NewOxmIdIpSrcMasked() *OxmIdIpSrcMasked {
6088 obj := &OxmIdIpSrcMasked{
6089 OxmId: NewOxmId(3848),
6090 }
6091 return obj
6092}
6093func (self *OxmIdIpSrcMasked) GetOXMName() string {
6094 return "ip_src_masked"
6095}
6096
6097func (self *OxmIdIpSrcMasked) MarshalJSON() ([]byte, error) {
6098 if self.TypeLen == 0 {
6099 return []byte("\"\""), nil
6100 } else {
6101 return []byte("\"" + self.GetOXMName() + "\""), nil
6102 }
6103}
6104
6105type OxmIdIpv6Dst struct {
6106 *OxmId
6107}
6108
6109type IOxmIdIpv6Dst interface {
6110 IOxmId
6111}
6112
6113func (self *OxmIdIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
6114 if err := self.OxmId.Serialize(encoder); err != nil {
6115 return err
6116 }
6117
6118 return nil
6119}
6120
6121func DecodeOxmIdIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Dst, error) {
6122 _oxmidipv6dst := &OxmIdIpv6Dst{OxmId: parent}
6123 return _oxmidipv6dst, nil
6124}
6125
6126func NewOxmIdIpv6Dst() *OxmIdIpv6Dst {
6127 obj := &OxmIdIpv6Dst{
6128 OxmId: NewOxmId(75792),
6129 }
6130 return obj
6131}
6132func (self *OxmIdIpv6Dst) GetOXMName() string {
6133 return "ipv6_dst"
6134}
6135
6136func (self *OxmIdIpv6Dst) MarshalJSON() ([]byte, error) {
6137 if self.TypeLen == 0 {
6138 return []byte("\"\""), nil
6139 } else {
6140 return []byte("\"" + self.GetOXMName() + "\""), nil
6141 }
6142}
6143
6144type OxmIdIpv6DstMasked struct {
6145 *OxmId
6146}
6147
6148type IOxmIdIpv6DstMasked interface {
6149 IOxmId
6150}
6151
6152func (self *OxmIdIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
6153 if err := self.OxmId.Serialize(encoder); err != nil {
6154 return err
6155 }
6156
6157 return nil
6158}
6159
6160func DecodeOxmIdIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6DstMasked, error) {
6161 _oxmidipv6dstmasked := &OxmIdIpv6DstMasked{OxmId: parent}
6162 return _oxmidipv6dstmasked, nil
6163}
6164
6165func NewOxmIdIpv6DstMasked() *OxmIdIpv6DstMasked {
6166 obj := &OxmIdIpv6DstMasked{
6167 OxmId: NewOxmId(76064),
6168 }
6169 return obj
6170}
6171func (self *OxmIdIpv6DstMasked) GetOXMName() string {
6172 return "ipv6_dst_masked"
6173}
6174
6175func (self *OxmIdIpv6DstMasked) MarshalJSON() ([]byte, error) {
6176 if self.TypeLen == 0 {
6177 return []byte("\"\""), nil
6178 } else {
6179 return []byte("\"" + self.GetOXMName() + "\""), nil
6180 }
6181}
6182
6183type OxmIdIpv6Label struct {
6184 *OxmId
6185}
6186
6187type IOxmIdIpv6Label interface {
6188 IOxmId
6189}
6190
6191func (self *OxmIdIpv6Label) Serialize(encoder *goloxi.Encoder) error {
6192 if err := self.OxmId.Serialize(encoder); err != nil {
6193 return err
6194 }
6195
6196 return nil
6197}
6198
6199func DecodeOxmIdIpv6Label(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Label, error) {
6200 _oxmidipv6label := &OxmIdIpv6Label{OxmId: parent}
6201 return _oxmidipv6label, nil
6202}
6203
6204func NewOxmIdIpv6Label() *OxmIdIpv6Label {
6205 obj := &OxmIdIpv6Label{
6206 OxmId: NewOxmId(79364),
6207 }
6208 return obj
6209}
6210func (self *OxmIdIpv6Label) GetOXMName() string {
6211 return "ipv6_label"
6212}
6213
6214func (self *OxmIdIpv6Label) MarshalJSON() ([]byte, error) {
6215 if self.TypeLen == 0 {
6216 return []byte("\"\""), nil
6217 } else {
6218 return []byte("\"" + self.GetOXMName() + "\""), nil
6219 }
6220}
6221
6222type OxmIdIpv6LabelMasked struct {
6223 *OxmId
6224}
6225
6226type IOxmIdIpv6LabelMasked interface {
6227 IOxmId
6228}
6229
6230func (self *OxmIdIpv6LabelMasked) Serialize(encoder *goloxi.Encoder) error {
6231 if err := self.OxmId.Serialize(encoder); err != nil {
6232 return err
6233 }
6234
6235 return nil
6236}
6237
6238func DecodeOxmIdIpv6LabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6LabelMasked, error) {
6239 _oxmidipv6labelmasked := &OxmIdIpv6LabelMasked{OxmId: parent}
6240 return _oxmidipv6labelmasked, nil
6241}
6242
6243func NewOxmIdIpv6LabelMasked() *OxmIdIpv6LabelMasked {
6244 obj := &OxmIdIpv6LabelMasked{
6245 OxmId: NewOxmId(79624),
6246 }
6247 return obj
6248}
6249func (self *OxmIdIpv6LabelMasked) GetOXMName() string {
6250 return "ipv6_label_masked"
6251}
6252
6253func (self *OxmIdIpv6LabelMasked) MarshalJSON() ([]byte, error) {
6254 if self.TypeLen == 0 {
6255 return []byte("\"\""), nil
6256 } else {
6257 return []byte("\"" + self.GetOXMName() + "\""), nil
6258 }
6259}
6260
6261type OxmIdIpv6Src struct {
6262 *OxmId
6263}
6264
6265type IOxmIdIpv6Src interface {
6266 IOxmId
6267}
6268
6269func (self *OxmIdIpv6Src) Serialize(encoder *goloxi.Encoder) error {
6270 if err := self.OxmId.Serialize(encoder); err != nil {
6271 return err
6272 }
6273
6274 return nil
6275}
6276
6277func DecodeOxmIdIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Src, error) {
6278 _oxmidipv6src := &OxmIdIpv6Src{OxmId: parent}
6279 return _oxmidipv6src, nil
6280}
6281
6282func NewOxmIdIpv6Src() *OxmIdIpv6Src {
6283 obj := &OxmIdIpv6Src{
6284 OxmId: NewOxmId(75280),
6285 }
6286 return obj
6287}
6288func (self *OxmIdIpv6Src) GetOXMName() string {
6289 return "ipv6_src"
6290}
6291
6292func (self *OxmIdIpv6Src) MarshalJSON() ([]byte, error) {
6293 if self.TypeLen == 0 {
6294 return []byte("\"\""), nil
6295 } else {
6296 return []byte("\"" + self.GetOXMName() + "\""), nil
6297 }
6298}
6299
6300type OxmIdIpv6SrcMasked struct {
6301 *OxmId
6302}
6303
6304type IOxmIdIpv6SrcMasked interface {
6305 IOxmId
6306}
6307
6308func (self *OxmIdIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
6309 if err := self.OxmId.Serialize(encoder); err != nil {
6310 return err
6311 }
6312
6313 return nil
6314}
6315
6316func DecodeOxmIdIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6SrcMasked, error) {
6317 _oxmidipv6srcmasked := &OxmIdIpv6SrcMasked{OxmId: parent}
6318 return _oxmidipv6srcmasked, nil
6319}
6320
6321func NewOxmIdIpv6SrcMasked() *OxmIdIpv6SrcMasked {
6322 obj := &OxmIdIpv6SrcMasked{
6323 OxmId: NewOxmId(75552),
6324 }
6325 return obj
6326}
6327func (self *OxmIdIpv6SrcMasked) GetOXMName() string {
6328 return "ipv6_src_masked"
6329}
6330
6331func (self *OxmIdIpv6SrcMasked) MarshalJSON() ([]byte, error) {
6332 if self.TypeLen == 0 {
6333 return []byte("\"\""), nil
6334 } else {
6335 return []byte("\"" + self.GetOXMName() + "\""), nil
6336 }
6337}
6338
6339type OxmIdMplsTtl struct {
6340 *OxmId
6341}
6342
6343type IOxmIdMplsTtl interface {
6344 IOxmId
6345}
6346
6347func (self *OxmIdMplsTtl) Serialize(encoder *goloxi.Encoder) error {
6348 if err := self.OxmId.Serialize(encoder); err != nil {
6349 return err
6350 }
6351
6352 return nil
6353}
6354
6355func DecodeOxmIdMplsTtl(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsTtl, error) {
6356 _oxmidmplsttl := &OxmIdMplsTtl{OxmId: parent}
6357 return _oxmidmplsttl, nil
6358}
6359
6360func NewOxmIdMplsTtl() *OxmIdMplsTtl {
6361 obj := &OxmIdMplsTtl{
6362 OxmId: NewOxmId(80897),
6363 }
6364 return obj
6365}
6366func (self *OxmIdMplsTtl) GetOXMName() string {
6367 return "mpls_ttl"
6368}
6369
6370func (self *OxmIdMplsTtl) MarshalJSON() ([]byte, error) {
6371 if self.TypeLen == 0 {
6372 return []byte("\"\""), nil
6373 } else {
6374 return []byte("\"" + self.GetOXMName() + "\""), nil
6375 }
6376}
6377
6378type OxmIdNdSll struct {
6379 *OxmId
6380}
6381
6382type IOxmIdNdSll interface {
6383 IOxmId
6384}
6385
6386func (self *OxmIdNdSll) Serialize(encoder *goloxi.Encoder) error {
6387 if err := self.OxmId.Serialize(encoder); err != nil {
6388 return err
6389 }
6390
6391 return nil
6392}
6393
6394func DecodeOxmIdNdSll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdSll, error) {
6395 _oxmidndsll := &OxmIdNdSll{OxmId: parent}
6396 return _oxmidndsll, nil
6397}
6398
6399func NewOxmIdNdSll() *OxmIdNdSll {
6400 obj := &OxmIdNdSll{
6401 OxmId: NewOxmId(77830),
6402 }
6403 return obj
6404}
6405func (self *OxmIdNdSll) GetOXMName() string {
6406 return "nd_sll"
6407}
6408
6409func (self *OxmIdNdSll) MarshalJSON() ([]byte, error) {
6410 if self.TypeLen == 0 {
6411 return []byte("\"\""), nil
6412 } else {
6413 return []byte("\"" + self.GetOXMName() + "\""), nil
6414 }
6415}
6416
6417type OxmIdNdSllMasked struct {
6418 *OxmId
6419}
6420
6421type IOxmIdNdSllMasked interface {
6422 IOxmId
6423}
6424
6425func (self *OxmIdNdSllMasked) Serialize(encoder *goloxi.Encoder) error {
6426 if err := self.OxmId.Serialize(encoder); err != nil {
6427 return err
6428 }
6429
6430 return nil
6431}
6432
6433func DecodeOxmIdNdSllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdSllMasked, error) {
6434 _oxmidndsllmasked := &OxmIdNdSllMasked{OxmId: parent}
6435 return _oxmidndsllmasked, nil
6436}
6437
6438func NewOxmIdNdSllMasked() *OxmIdNdSllMasked {
6439 obj := &OxmIdNdSllMasked{
6440 OxmId: NewOxmId(78091),
6441 }
6442 return obj
6443}
6444func (self *OxmIdNdSllMasked) GetOXMName() string {
6445 return "nd_sll_masked"
6446}
6447
6448func (self *OxmIdNdSllMasked) MarshalJSON() ([]byte, error) {
6449 if self.TypeLen == 0 {
6450 return []byte("\"\""), nil
6451 } else {
6452 return []byte("\"" + self.GetOXMName() + "\""), nil
6453 }
6454}
6455
6456type OxmIdNdTarget struct {
6457 *OxmId
6458}
6459
6460type IOxmIdNdTarget interface {
6461 IOxmId
6462}
6463
6464func (self *OxmIdNdTarget) Serialize(encoder *goloxi.Encoder) error {
6465 if err := self.OxmId.Serialize(encoder); err != nil {
6466 return err
6467 }
6468
6469 return nil
6470}
6471
6472func DecodeOxmIdNdTarget(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTarget, error) {
6473 _oxmidndtarget := &OxmIdNdTarget{OxmId: parent}
6474 return _oxmidndtarget, nil
6475}
6476
6477func NewOxmIdNdTarget() *OxmIdNdTarget {
6478 obj := &OxmIdNdTarget{
6479 OxmId: NewOxmId(77328),
6480 }
6481 return obj
6482}
6483func (self *OxmIdNdTarget) GetOXMName() string {
6484 return "nd_target"
6485}
6486
6487func (self *OxmIdNdTarget) MarshalJSON() ([]byte, error) {
6488 if self.TypeLen == 0 {
6489 return []byte("\"\""), nil
6490 } else {
6491 return []byte("\"" + self.GetOXMName() + "\""), nil
6492 }
6493}
6494
6495type OxmIdNdTargetMasked struct {
6496 *OxmId
6497}
6498
6499type IOxmIdNdTargetMasked interface {
6500 IOxmId
6501}
6502
6503func (self *OxmIdNdTargetMasked) Serialize(encoder *goloxi.Encoder) error {
6504 if err := self.OxmId.Serialize(encoder); err != nil {
6505 return err
6506 }
6507
6508 return nil
6509}
6510
6511func DecodeOxmIdNdTargetMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTargetMasked, error) {
6512 _oxmidndtargetmasked := &OxmIdNdTargetMasked{OxmId: parent}
6513 return _oxmidndtargetmasked, nil
6514}
6515
6516func NewOxmIdNdTargetMasked() *OxmIdNdTargetMasked {
6517 obj := &OxmIdNdTargetMasked{
6518 OxmId: NewOxmId(77600),
6519 }
6520 return obj
6521}
6522func (self *OxmIdNdTargetMasked) GetOXMName() string {
6523 return "nd_target_masked"
6524}
6525
6526func (self *OxmIdNdTargetMasked) MarshalJSON() ([]byte, error) {
6527 if self.TypeLen == 0 {
6528 return []byte("\"\""), nil
6529 } else {
6530 return []byte("\"" + self.GetOXMName() + "\""), nil
6531 }
6532}
6533
6534type OxmIdNdTll struct {
6535 *OxmId
6536}
6537
6538type IOxmIdNdTll interface {
6539 IOxmId
6540}
6541
6542func (self *OxmIdNdTll) Serialize(encoder *goloxi.Encoder) error {
6543 if err := self.OxmId.Serialize(encoder); err != nil {
6544 return err
6545 }
6546
6547 return nil
6548}
6549
6550func DecodeOxmIdNdTll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTll, error) {
6551 _oxmidndtll := &OxmIdNdTll{OxmId: parent}
6552 return _oxmidndtll, nil
6553}
6554
6555func NewOxmIdNdTll() *OxmIdNdTll {
6556 obj := &OxmIdNdTll{
6557 OxmId: NewOxmId(78342),
6558 }
6559 return obj
6560}
6561func (self *OxmIdNdTll) GetOXMName() string {
6562 return "nd_tll"
6563}
6564
6565func (self *OxmIdNdTll) MarshalJSON() ([]byte, error) {
6566 if self.TypeLen == 0 {
6567 return []byte("\"\""), nil
6568 } else {
6569 return []byte("\"" + self.GetOXMName() + "\""), nil
6570 }
6571}
6572
6573type OxmIdNdTllMasked struct {
6574 *OxmId
6575}
6576
6577type IOxmIdNdTllMasked interface {
6578 IOxmId
6579}
6580
6581func (self *OxmIdNdTllMasked) Serialize(encoder *goloxi.Encoder) error {
6582 if err := self.OxmId.Serialize(encoder); err != nil {
6583 return err
6584 }
6585
6586 return nil
6587}
6588
6589func DecodeOxmIdNdTllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTllMasked, error) {
6590 _oxmidndtllmasked := &OxmIdNdTllMasked{OxmId: parent}
6591 return _oxmidndtllmasked, nil
6592}
6593
6594func NewOxmIdNdTllMasked() *OxmIdNdTllMasked {
6595 obj := &OxmIdNdTllMasked{
6596 OxmId: NewOxmId(78603),
6597 }
6598 return obj
6599}
6600func (self *OxmIdNdTllMasked) GetOXMName() string {
6601 return "nd_tll_masked"
6602}
6603
6604func (self *OxmIdNdTllMasked) MarshalJSON() ([]byte, error) {
6605 if self.TypeLen == 0 {
6606 return []byte("\"\""), nil
6607 } else {
6608 return []byte("\"" + self.GetOXMName() + "\""), nil
6609 }
6610}
6611
6612type OxmIdNwEcn struct {
6613 *OxmId
6614}
6615
6616type IOxmIdNwEcn interface {
6617 IOxmId
6618}
6619
6620func (self *OxmIdNwEcn) Serialize(encoder *goloxi.Encoder) error {
6621 if err := self.OxmId.Serialize(encoder); err != nil {
6622 return err
6623 }
6624
6625 return nil
6626}
6627
6628func DecodeOxmIdNwEcn(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwEcn, error) {
6629 _oxmidnwecn := &OxmIdNwEcn{OxmId: parent}
6630 return _oxmidnwecn, nil
6631}
6632
6633func NewOxmIdNwEcn() *OxmIdNwEcn {
6634 obj := &OxmIdNwEcn{
6635 OxmId: NewOxmId(79873),
6636 }
6637 return obj
6638}
6639func (self *OxmIdNwEcn) GetOXMName() string {
6640 return "nw_ecn"
6641}
6642
6643func (self *OxmIdNwEcn) MarshalJSON() ([]byte, error) {
6644 if self.TypeLen == 0 {
6645 return []byte("\"\""), nil
6646 } else {
6647 return []byte("\"" + self.GetOXMName() + "\""), nil
6648 }
6649}
6650
6651type OxmIdNwProto struct {
6652 *OxmId
6653}
6654
6655type IOxmIdNwProto interface {
6656 IOxmId
6657}
6658
6659func (self *OxmIdNwProto) Serialize(encoder *goloxi.Encoder) error {
6660 if err := self.OxmId.Serialize(encoder); err != nil {
6661 return err
6662 }
6663
6664 return nil
6665}
6666
6667func DecodeOxmIdNwProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwProto, error) {
6668 _oxmidnwproto := &OxmIdNwProto{OxmId: parent}
6669 return _oxmidnwproto, nil
6670}
6671
6672func NewOxmIdNwProto() *OxmIdNwProto {
6673 obj := &OxmIdNwProto{
6674 OxmId: NewOxmId(3073),
6675 }
6676 return obj
6677}
6678func (self *OxmIdNwProto) GetOXMName() string {
6679 return "nw_proto"
6680}
6681
6682func (self *OxmIdNwProto) MarshalJSON() ([]byte, error) {
6683 if self.TypeLen == 0 {
6684 return []byte("\"\""), nil
6685 } else {
6686 return []byte("\"" + self.GetOXMName() + "\""), nil
6687 }
6688}
6689
6690type OxmIdNwTos struct {
6691 *OxmId
6692}
6693
6694type IOxmIdNwTos interface {
6695 IOxmId
6696}
6697
6698func (self *OxmIdNwTos) Serialize(encoder *goloxi.Encoder) error {
6699 if err := self.OxmId.Serialize(encoder); err != nil {
6700 return err
6701 }
6702
6703 return nil
6704}
6705
6706func DecodeOxmIdNwTos(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwTos, error) {
6707 _oxmidnwtos := &OxmIdNwTos{OxmId: parent}
6708 return _oxmidnwtos, nil
6709}
6710
6711func NewOxmIdNwTos() *OxmIdNwTos {
6712 obj := &OxmIdNwTos{
6713 OxmId: NewOxmId(2561),
6714 }
6715 return obj
6716}
6717func (self *OxmIdNwTos) GetOXMName() string {
6718 return "nw_tos"
6719}
6720
6721func (self *OxmIdNwTos) MarshalJSON() ([]byte, error) {
6722 if self.TypeLen == 0 {
6723 return []byte("\"\""), nil
6724 } else {
6725 return []byte("\"" + self.GetOXMName() + "\""), nil
6726 }
6727}
6728
6729type OxmIdNwTtl struct {
6730 *OxmId
6731}
6732
6733type IOxmIdNwTtl interface {
6734 IOxmId
6735}
6736
6737func (self *OxmIdNwTtl) Serialize(encoder *goloxi.Encoder) error {
6738 if err := self.OxmId.Serialize(encoder); err != nil {
6739 return err
6740 }
6741
6742 return nil
6743}
6744
6745func DecodeOxmIdNwTtl(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwTtl, error) {
6746 _oxmidnwttl := &OxmIdNwTtl{OxmId: parent}
6747 return _oxmidnwttl, nil
6748}
6749
6750func NewOxmIdNwTtl() *OxmIdNwTtl {
6751 obj := &OxmIdNwTtl{
6752 OxmId: NewOxmId(80385),
6753 }
6754 return obj
6755}
6756func (self *OxmIdNwTtl) GetOXMName() string {
6757 return "nw_ttl"
6758}
6759
6760func (self *OxmIdNwTtl) MarshalJSON() ([]byte, error) {
6761 if self.TypeLen == 0 {
6762 return []byte("\"\""), nil
6763 } else {
6764 return []byte("\"" + self.GetOXMName() + "\""), nil
6765 }
6766}
6767
6768type OxmIdPktMark struct {
6769 *OxmId
6770}
6771
6772type IOxmIdPktMark interface {
6773 IOxmId
6774}
6775
6776func (self *OxmIdPktMark) Serialize(encoder *goloxi.Encoder) error {
6777 if err := self.OxmId.Serialize(encoder); err != nil {
6778 return err
6779 }
6780
6781 return nil
6782}
6783
6784func DecodeOxmIdPktMark(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdPktMark, error) {
6785 _oxmidpktmark := &OxmIdPktMark{OxmId: parent}
6786 return _oxmidpktmark, nil
6787}
6788
6789func NewOxmIdPktMark() *OxmIdPktMark {
6790 obj := &OxmIdPktMark{
6791 OxmId: NewOxmId(82436),
6792 }
6793 return obj
6794}
6795func (self *OxmIdPktMark) GetOXMName() string {
6796 return "pkt_mark"
6797}
6798
6799func (self *OxmIdPktMark) MarshalJSON() ([]byte, error) {
6800 if self.TypeLen == 0 {
6801 return []byte("\"\""), nil
6802 } else {
6803 return []byte("\"" + self.GetOXMName() + "\""), nil
6804 }
6805}
6806
6807type OxmIdPktMarkMasked struct {
6808 *OxmId
6809}
6810
6811type IOxmIdPktMarkMasked interface {
6812 IOxmId
6813}
6814
6815func (self *OxmIdPktMarkMasked) Serialize(encoder *goloxi.Encoder) error {
6816 if err := self.OxmId.Serialize(encoder); err != nil {
6817 return err
6818 }
6819
6820 return nil
6821}
6822
6823func DecodeOxmIdPktMarkMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdPktMarkMasked, error) {
6824 _oxmidpktmarkmasked := &OxmIdPktMarkMasked{OxmId: parent}
6825 return _oxmidpktmarkmasked, nil
6826}
6827
6828func NewOxmIdPktMarkMasked() *OxmIdPktMarkMasked {
6829 obj := &OxmIdPktMarkMasked{
6830 OxmId: NewOxmId(82696),
6831 }
6832 return obj
6833}
6834func (self *OxmIdPktMarkMasked) GetOXMName() string {
6835 return "pkt_mark_masked"
6836}
6837
6838func (self *OxmIdPktMarkMasked) MarshalJSON() ([]byte, error) {
6839 if self.TypeLen == 0 {
6840 return []byte("\"\""), nil
6841 } else {
6842 return []byte("\"" + self.GetOXMName() + "\""), nil
6843 }
6844}
6845
6846type OxmIdRecircId struct {
6847 *OxmId
6848}
6849
6850type IOxmIdRecircId interface {
6851 IOxmId
6852}
6853
6854func (self *OxmIdRecircId) Serialize(encoder *goloxi.Encoder) error {
6855 if err := self.OxmId.Serialize(encoder); err != nil {
6856 return err
6857 }
6858
6859 return nil
6860}
6861
6862func DecodeOxmIdRecircId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdRecircId, error) {
6863 _oxmidrecircid := &OxmIdRecircId{OxmId: parent}
6864 return _oxmidrecircid, nil
6865}
6866
6867func NewOxmIdRecircId() *OxmIdRecircId {
6868 obj := &OxmIdRecircId{
6869 OxmId: NewOxmId(83972),
6870 }
6871 return obj
6872}
6873func (self *OxmIdRecircId) GetOXMName() string {
6874 return "recirc_id"
6875}
6876
6877func (self *OxmIdRecircId) MarshalJSON() ([]byte, error) {
6878 if self.TypeLen == 0 {
6879 return []byte("\"\""), nil
6880 } else {
6881 return []byte("\"" + self.GetOXMName() + "\""), nil
6882 }
6883}
6884
6885type OxmIdReg0 struct {
6886 *OxmId
6887}
6888
6889type IOxmIdReg0 interface {
6890 IOxmId
6891}
6892
6893func (self *OxmIdReg0) Serialize(encoder *goloxi.Encoder) error {
6894 if err := self.OxmId.Serialize(encoder); err != nil {
6895 return err
6896 }
6897
6898 return nil
6899}
6900
6901func DecodeOxmIdReg0(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg0, error) {
6902 _oxmidreg0 := &OxmIdReg0{OxmId: parent}
6903 return _oxmidreg0, nil
6904}
6905
6906func NewOxmIdReg0() *OxmIdReg0 {
6907 obj := &OxmIdReg0{
6908 OxmId: NewOxmId(65540),
6909 }
6910 return obj
6911}
6912func (self *OxmIdReg0) GetOXMName() string {
6913 return "reg0"
6914}
6915
6916func (self *OxmIdReg0) MarshalJSON() ([]byte, error) {
6917 if self.TypeLen == 0 {
6918 return []byte("\"\""), nil
6919 } else {
6920 return []byte("\"" + self.GetOXMName() + "\""), nil
6921 }
6922}
6923
6924type OxmIdReg0Masked struct {
6925 *OxmId
6926}
6927
6928type IOxmIdReg0Masked interface {
6929 IOxmId
6930}
6931
6932func (self *OxmIdReg0Masked) Serialize(encoder *goloxi.Encoder) error {
6933 if err := self.OxmId.Serialize(encoder); err != nil {
6934 return err
6935 }
6936
6937 return nil
6938}
6939
6940func DecodeOxmIdReg0Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg0Masked, error) {
6941 _oxmidreg0masked := &OxmIdReg0Masked{OxmId: parent}
6942 return _oxmidreg0masked, nil
6943}
6944
6945func NewOxmIdReg0Masked() *OxmIdReg0Masked {
6946 obj := &OxmIdReg0Masked{
6947 OxmId: NewOxmId(65800),
6948 }
6949 return obj
6950}
6951func (self *OxmIdReg0Masked) GetOXMName() string {
6952 return "reg0_masked"
6953}
6954
6955func (self *OxmIdReg0Masked) MarshalJSON() ([]byte, error) {
6956 if self.TypeLen == 0 {
6957 return []byte("\"\""), nil
6958 } else {
6959 return []byte("\"" + self.GetOXMName() + "\""), nil
6960 }
6961}
6962
6963type OxmIdReg1 struct {
6964 *OxmId
6965}
6966
6967type IOxmIdReg1 interface {
6968 IOxmId
6969}
6970
6971func (self *OxmIdReg1) Serialize(encoder *goloxi.Encoder) error {
6972 if err := self.OxmId.Serialize(encoder); err != nil {
6973 return err
6974 }
6975
6976 return nil
6977}
6978
6979func DecodeOxmIdReg1(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg1, error) {
6980 _oxmidreg1 := &OxmIdReg1{OxmId: parent}
6981 return _oxmidreg1, nil
6982}
6983
6984func NewOxmIdReg1() *OxmIdReg1 {
6985 obj := &OxmIdReg1{
6986 OxmId: NewOxmId(66052),
6987 }
6988 return obj
6989}
6990func (self *OxmIdReg1) GetOXMName() string {
6991 return "reg1"
6992}
6993
6994func (self *OxmIdReg1) MarshalJSON() ([]byte, error) {
6995 if self.TypeLen == 0 {
6996 return []byte("\"\""), nil
6997 } else {
6998 return []byte("\"" + self.GetOXMName() + "\""), nil
6999 }
7000}
7001
7002type OxmIdReg10 struct {
7003 *OxmId
7004}
7005
7006type IOxmIdReg10 interface {
7007 IOxmId
7008}
7009
7010func (self *OxmIdReg10) Serialize(encoder *goloxi.Encoder) error {
7011 if err := self.OxmId.Serialize(encoder); err != nil {
7012 return err
7013 }
7014
7015 return nil
7016}
7017
7018func DecodeOxmIdReg10(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg10, error) {
7019 _oxmidreg10 := &OxmIdReg10{OxmId: parent}
7020 return _oxmidreg10, nil
7021}
7022
7023func NewOxmIdReg10() *OxmIdReg10 {
7024 obj := &OxmIdReg10{
7025 OxmId: NewOxmId(70660),
7026 }
7027 return obj
7028}
7029func (self *OxmIdReg10) GetOXMName() string {
7030 return "reg10"
7031}
7032
7033func (self *OxmIdReg10) MarshalJSON() ([]byte, error) {
7034 if self.TypeLen == 0 {
7035 return []byte("\"\""), nil
7036 } else {
7037 return []byte("\"" + self.GetOXMName() + "\""), nil
7038 }
7039}
7040
7041type OxmIdReg10Masked struct {
7042 *OxmId
7043}
7044
7045type IOxmIdReg10Masked interface {
7046 IOxmId
7047}
7048
7049func (self *OxmIdReg10Masked) Serialize(encoder *goloxi.Encoder) error {
7050 if err := self.OxmId.Serialize(encoder); err != nil {
7051 return err
7052 }
7053
7054 return nil
7055}
7056
7057func DecodeOxmIdReg10Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg10Masked, error) {
7058 _oxmidreg10masked := &OxmIdReg10Masked{OxmId: parent}
7059 return _oxmidreg10masked, nil
7060}
7061
7062func NewOxmIdReg10Masked() *OxmIdReg10Masked {
7063 obj := &OxmIdReg10Masked{
7064 OxmId: NewOxmId(70920),
7065 }
7066 return obj
7067}
7068func (self *OxmIdReg10Masked) GetOXMName() string {
7069 return "reg10_masked"
7070}
7071
7072func (self *OxmIdReg10Masked) MarshalJSON() ([]byte, error) {
7073 if self.TypeLen == 0 {
7074 return []byte("\"\""), nil
7075 } else {
7076 return []byte("\"" + self.GetOXMName() + "\""), nil
7077 }
7078}
7079
7080type OxmIdReg11 struct {
7081 *OxmId
7082}
7083
7084type IOxmIdReg11 interface {
7085 IOxmId
7086}
7087
7088func (self *OxmIdReg11) Serialize(encoder *goloxi.Encoder) error {
7089 if err := self.OxmId.Serialize(encoder); err != nil {
7090 return err
7091 }
7092
7093 return nil
7094}
7095
7096func DecodeOxmIdReg11(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg11, error) {
7097 _oxmidreg11 := &OxmIdReg11{OxmId: parent}
7098 return _oxmidreg11, nil
7099}
7100
7101func NewOxmIdReg11() *OxmIdReg11 {
7102 obj := &OxmIdReg11{
7103 OxmId: NewOxmId(71172),
7104 }
7105 return obj
7106}
7107func (self *OxmIdReg11) GetOXMName() string {
7108 return "reg11"
7109}
7110
7111func (self *OxmIdReg11) MarshalJSON() ([]byte, error) {
7112 if self.TypeLen == 0 {
7113 return []byte("\"\""), nil
7114 } else {
7115 return []byte("\"" + self.GetOXMName() + "\""), nil
7116 }
7117}
7118
7119type OxmIdReg11Masked struct {
7120 *OxmId
7121}
7122
7123type IOxmIdReg11Masked interface {
7124 IOxmId
7125}
7126
7127func (self *OxmIdReg11Masked) Serialize(encoder *goloxi.Encoder) error {
7128 if err := self.OxmId.Serialize(encoder); err != nil {
7129 return err
7130 }
7131
7132 return nil
7133}
7134
7135func DecodeOxmIdReg11Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg11Masked, error) {
7136 _oxmidreg11masked := &OxmIdReg11Masked{OxmId: parent}
7137 return _oxmidreg11masked, nil
7138}
7139
7140func NewOxmIdReg11Masked() *OxmIdReg11Masked {
7141 obj := &OxmIdReg11Masked{
7142 OxmId: NewOxmId(71432),
7143 }
7144 return obj
7145}
7146func (self *OxmIdReg11Masked) GetOXMName() string {
7147 return "reg11_masked"
7148}
7149
7150func (self *OxmIdReg11Masked) MarshalJSON() ([]byte, error) {
7151 if self.TypeLen == 0 {
7152 return []byte("\"\""), nil
7153 } else {
7154 return []byte("\"" + self.GetOXMName() + "\""), nil
7155 }
7156}
7157
7158type OxmIdReg12 struct {
7159 *OxmId
7160}
7161
7162type IOxmIdReg12 interface {
7163 IOxmId
7164}
7165
7166func (self *OxmIdReg12) Serialize(encoder *goloxi.Encoder) error {
7167 if err := self.OxmId.Serialize(encoder); err != nil {
7168 return err
7169 }
7170
7171 return nil
7172}
7173
7174func DecodeOxmIdReg12(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg12, error) {
7175 _oxmidreg12 := &OxmIdReg12{OxmId: parent}
7176 return _oxmidreg12, nil
7177}
7178
7179func NewOxmIdReg12() *OxmIdReg12 {
7180 obj := &OxmIdReg12{
7181 OxmId: NewOxmId(71684),
7182 }
7183 return obj
7184}
7185func (self *OxmIdReg12) GetOXMName() string {
7186 return "reg12"
7187}
7188
7189func (self *OxmIdReg12) MarshalJSON() ([]byte, error) {
7190 if self.TypeLen == 0 {
7191 return []byte("\"\""), nil
7192 } else {
7193 return []byte("\"" + self.GetOXMName() + "\""), nil
7194 }
7195}
7196
7197type OxmIdReg12Masked struct {
7198 *OxmId
7199}
7200
7201type IOxmIdReg12Masked interface {
7202 IOxmId
7203}
7204
7205func (self *OxmIdReg12Masked) Serialize(encoder *goloxi.Encoder) error {
7206 if err := self.OxmId.Serialize(encoder); err != nil {
7207 return err
7208 }
7209
7210 return nil
7211}
7212
7213func DecodeOxmIdReg12Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg12Masked, error) {
7214 _oxmidreg12masked := &OxmIdReg12Masked{OxmId: parent}
7215 return _oxmidreg12masked, nil
7216}
7217
7218func NewOxmIdReg12Masked() *OxmIdReg12Masked {
7219 obj := &OxmIdReg12Masked{
7220 OxmId: NewOxmId(71944),
7221 }
7222 return obj
7223}
7224func (self *OxmIdReg12Masked) GetOXMName() string {
7225 return "reg12_masked"
7226}
7227
7228func (self *OxmIdReg12Masked) MarshalJSON() ([]byte, error) {
7229 if self.TypeLen == 0 {
7230 return []byte("\"\""), nil
7231 } else {
7232 return []byte("\"" + self.GetOXMName() + "\""), nil
7233 }
7234}
7235
7236type OxmIdReg13 struct {
7237 *OxmId
7238}
7239
7240type IOxmIdReg13 interface {
7241 IOxmId
7242}
7243
7244func (self *OxmIdReg13) Serialize(encoder *goloxi.Encoder) error {
7245 if err := self.OxmId.Serialize(encoder); err != nil {
7246 return err
7247 }
7248
7249 return nil
7250}
7251
7252func DecodeOxmIdReg13(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg13, error) {
7253 _oxmidreg13 := &OxmIdReg13{OxmId: parent}
7254 return _oxmidreg13, nil
7255}
7256
7257func NewOxmIdReg13() *OxmIdReg13 {
7258 obj := &OxmIdReg13{
7259 OxmId: NewOxmId(72196),
7260 }
7261 return obj
7262}
7263func (self *OxmIdReg13) GetOXMName() string {
7264 return "reg13"
7265}
7266
7267func (self *OxmIdReg13) MarshalJSON() ([]byte, error) {
7268 if self.TypeLen == 0 {
7269 return []byte("\"\""), nil
7270 } else {
7271 return []byte("\"" + self.GetOXMName() + "\""), nil
7272 }
7273}
7274
7275type OxmIdReg13Masked struct {
7276 *OxmId
7277}
7278
7279type IOxmIdReg13Masked interface {
7280 IOxmId
7281}
7282
7283func (self *OxmIdReg13Masked) Serialize(encoder *goloxi.Encoder) error {
7284 if err := self.OxmId.Serialize(encoder); err != nil {
7285 return err
7286 }
7287
7288 return nil
7289}
7290
7291func DecodeOxmIdReg13Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg13Masked, error) {
7292 _oxmidreg13masked := &OxmIdReg13Masked{OxmId: parent}
7293 return _oxmidreg13masked, nil
7294}
7295
7296func NewOxmIdReg13Masked() *OxmIdReg13Masked {
7297 obj := &OxmIdReg13Masked{
7298 OxmId: NewOxmId(72456),
7299 }
7300 return obj
7301}
7302func (self *OxmIdReg13Masked) GetOXMName() string {
7303 return "reg13_masked"
7304}
7305
7306func (self *OxmIdReg13Masked) MarshalJSON() ([]byte, error) {
7307 if self.TypeLen == 0 {
7308 return []byte("\"\""), nil
7309 } else {
7310 return []byte("\"" + self.GetOXMName() + "\""), nil
7311 }
7312}
7313
7314type OxmIdReg14 struct {
7315 *OxmId
7316}
7317
7318type IOxmIdReg14 interface {
7319 IOxmId
7320}
7321
7322func (self *OxmIdReg14) Serialize(encoder *goloxi.Encoder) error {
7323 if err := self.OxmId.Serialize(encoder); err != nil {
7324 return err
7325 }
7326
7327 return nil
7328}
7329
7330func DecodeOxmIdReg14(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg14, error) {
7331 _oxmidreg14 := &OxmIdReg14{OxmId: parent}
7332 return _oxmidreg14, nil
7333}
7334
7335func NewOxmIdReg14() *OxmIdReg14 {
7336 obj := &OxmIdReg14{
7337 OxmId: NewOxmId(72708),
7338 }
7339 return obj
7340}
7341func (self *OxmIdReg14) GetOXMName() string {
7342 return "reg14"
7343}
7344
7345func (self *OxmIdReg14) MarshalJSON() ([]byte, error) {
7346 if self.TypeLen == 0 {
7347 return []byte("\"\""), nil
7348 } else {
7349 return []byte("\"" + self.GetOXMName() + "\""), nil
7350 }
7351}
7352
7353type OxmIdReg14Masked struct {
7354 *OxmId
7355}
7356
7357type IOxmIdReg14Masked interface {
7358 IOxmId
7359}
7360
7361func (self *OxmIdReg14Masked) Serialize(encoder *goloxi.Encoder) error {
7362 if err := self.OxmId.Serialize(encoder); err != nil {
7363 return err
7364 }
7365
7366 return nil
7367}
7368
7369func DecodeOxmIdReg14Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg14Masked, error) {
7370 _oxmidreg14masked := &OxmIdReg14Masked{OxmId: parent}
7371 return _oxmidreg14masked, nil
7372}
7373
7374func NewOxmIdReg14Masked() *OxmIdReg14Masked {
7375 obj := &OxmIdReg14Masked{
7376 OxmId: NewOxmId(72968),
7377 }
7378 return obj
7379}
7380func (self *OxmIdReg14Masked) GetOXMName() string {
7381 return "reg14_masked"
7382}
7383
7384func (self *OxmIdReg14Masked) MarshalJSON() ([]byte, error) {
7385 if self.TypeLen == 0 {
7386 return []byte("\"\""), nil
7387 } else {
7388 return []byte("\"" + self.GetOXMName() + "\""), nil
7389 }
7390}
7391
7392type OxmIdReg15 struct {
7393 *OxmId
7394}
7395
7396type IOxmIdReg15 interface {
7397 IOxmId
7398}
7399
7400func (self *OxmIdReg15) Serialize(encoder *goloxi.Encoder) error {
7401 if err := self.OxmId.Serialize(encoder); err != nil {
7402 return err
7403 }
7404
7405 return nil
7406}
7407
7408func DecodeOxmIdReg15(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg15, error) {
7409 _oxmidreg15 := &OxmIdReg15{OxmId: parent}
7410 return _oxmidreg15, nil
7411}
7412
7413func NewOxmIdReg15() *OxmIdReg15 {
7414 obj := &OxmIdReg15{
7415 OxmId: NewOxmId(73220),
7416 }
7417 return obj
7418}
7419func (self *OxmIdReg15) GetOXMName() string {
7420 return "reg15"
7421}
7422
7423func (self *OxmIdReg15) MarshalJSON() ([]byte, error) {
7424 if self.TypeLen == 0 {
7425 return []byte("\"\""), nil
7426 } else {
7427 return []byte("\"" + self.GetOXMName() + "\""), nil
7428 }
7429}
7430
7431type OxmIdReg15Masked struct {
7432 *OxmId
7433}
7434
7435type IOxmIdReg15Masked interface {
7436 IOxmId
7437}
7438
7439func (self *OxmIdReg15Masked) Serialize(encoder *goloxi.Encoder) error {
7440 if err := self.OxmId.Serialize(encoder); err != nil {
7441 return err
7442 }
7443
7444 return nil
7445}
7446
7447func DecodeOxmIdReg15Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg15Masked, error) {
7448 _oxmidreg15masked := &OxmIdReg15Masked{OxmId: parent}
7449 return _oxmidreg15masked, nil
7450}
7451
7452func NewOxmIdReg15Masked() *OxmIdReg15Masked {
7453 obj := &OxmIdReg15Masked{
7454 OxmId: NewOxmId(73480),
7455 }
7456 return obj
7457}
7458func (self *OxmIdReg15Masked) GetOXMName() string {
7459 return "reg15_masked"
7460}
7461
7462func (self *OxmIdReg15Masked) MarshalJSON() ([]byte, error) {
7463 if self.TypeLen == 0 {
7464 return []byte("\"\""), nil
7465 } else {
7466 return []byte("\"" + self.GetOXMName() + "\""), nil
7467 }
7468}
7469
7470type OxmIdReg1Masked struct {
7471 *OxmId
7472}
7473
7474type IOxmIdReg1Masked interface {
7475 IOxmId
7476}
7477
7478func (self *OxmIdReg1Masked) Serialize(encoder *goloxi.Encoder) error {
7479 if err := self.OxmId.Serialize(encoder); err != nil {
7480 return err
7481 }
7482
7483 return nil
7484}
7485
7486func DecodeOxmIdReg1Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg1Masked, error) {
7487 _oxmidreg1masked := &OxmIdReg1Masked{OxmId: parent}
7488 return _oxmidreg1masked, nil
7489}
7490
7491func NewOxmIdReg1Masked() *OxmIdReg1Masked {
7492 obj := &OxmIdReg1Masked{
7493 OxmId: NewOxmId(66312),
7494 }
7495 return obj
7496}
7497func (self *OxmIdReg1Masked) GetOXMName() string {
7498 return "reg1_masked"
7499}
7500
7501func (self *OxmIdReg1Masked) MarshalJSON() ([]byte, error) {
7502 if self.TypeLen == 0 {
7503 return []byte("\"\""), nil
7504 } else {
7505 return []byte("\"" + self.GetOXMName() + "\""), nil
7506 }
7507}
7508
7509type OxmIdReg2 struct {
7510 *OxmId
7511}
7512
7513type IOxmIdReg2 interface {
7514 IOxmId
7515}
7516
7517func (self *OxmIdReg2) Serialize(encoder *goloxi.Encoder) error {
7518 if err := self.OxmId.Serialize(encoder); err != nil {
7519 return err
7520 }
7521
7522 return nil
7523}
7524
7525func DecodeOxmIdReg2(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg2, error) {
7526 _oxmidreg2 := &OxmIdReg2{OxmId: parent}
7527 return _oxmidreg2, nil
7528}
7529
7530func NewOxmIdReg2() *OxmIdReg2 {
7531 obj := &OxmIdReg2{
7532 OxmId: NewOxmId(66564),
7533 }
7534 return obj
7535}
7536func (self *OxmIdReg2) GetOXMName() string {
7537 return "reg2"
7538}
7539
7540func (self *OxmIdReg2) MarshalJSON() ([]byte, error) {
7541 if self.TypeLen == 0 {
7542 return []byte("\"\""), nil
7543 } else {
7544 return []byte("\"" + self.GetOXMName() + "\""), nil
7545 }
7546}
7547
7548type OxmIdReg2Masked struct {
7549 *OxmId
7550}
7551
7552type IOxmIdReg2Masked interface {
7553 IOxmId
7554}
7555
7556func (self *OxmIdReg2Masked) Serialize(encoder *goloxi.Encoder) error {
7557 if err := self.OxmId.Serialize(encoder); err != nil {
7558 return err
7559 }
7560
7561 return nil
7562}
7563
7564func DecodeOxmIdReg2Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg2Masked, error) {
7565 _oxmidreg2masked := &OxmIdReg2Masked{OxmId: parent}
7566 return _oxmidreg2masked, nil
7567}
7568
7569func NewOxmIdReg2Masked() *OxmIdReg2Masked {
7570 obj := &OxmIdReg2Masked{
7571 OxmId: NewOxmId(66824),
7572 }
7573 return obj
7574}
7575func (self *OxmIdReg2Masked) GetOXMName() string {
7576 return "reg2_masked"
7577}
7578
7579func (self *OxmIdReg2Masked) MarshalJSON() ([]byte, error) {
7580 if self.TypeLen == 0 {
7581 return []byte("\"\""), nil
7582 } else {
7583 return []byte("\"" + self.GetOXMName() + "\""), nil
7584 }
7585}
7586
7587type OxmIdReg3 struct {
7588 *OxmId
7589}
7590
7591type IOxmIdReg3 interface {
7592 IOxmId
7593}
7594
7595func (self *OxmIdReg3) Serialize(encoder *goloxi.Encoder) error {
7596 if err := self.OxmId.Serialize(encoder); err != nil {
7597 return err
7598 }
7599
7600 return nil
7601}
7602
7603func DecodeOxmIdReg3(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg3, error) {
7604 _oxmidreg3 := &OxmIdReg3{OxmId: parent}
7605 return _oxmidreg3, nil
7606}
7607
7608func NewOxmIdReg3() *OxmIdReg3 {
7609 obj := &OxmIdReg3{
7610 OxmId: NewOxmId(67076),
7611 }
7612 return obj
7613}
7614func (self *OxmIdReg3) GetOXMName() string {
7615 return "reg3"
7616}
7617
7618func (self *OxmIdReg3) MarshalJSON() ([]byte, error) {
7619 if self.TypeLen == 0 {
7620 return []byte("\"\""), nil
7621 } else {
7622 return []byte("\"" + self.GetOXMName() + "\""), nil
7623 }
7624}
7625
7626type OxmIdReg3Masked struct {
7627 *OxmId
7628}
7629
7630type IOxmIdReg3Masked interface {
7631 IOxmId
7632}
7633
7634func (self *OxmIdReg3Masked) Serialize(encoder *goloxi.Encoder) error {
7635 if err := self.OxmId.Serialize(encoder); err != nil {
7636 return err
7637 }
7638
7639 return nil
7640}
7641
7642func DecodeOxmIdReg3Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg3Masked, error) {
7643 _oxmidreg3masked := &OxmIdReg3Masked{OxmId: parent}
7644 return _oxmidreg3masked, nil
7645}
7646
7647func NewOxmIdReg3Masked() *OxmIdReg3Masked {
7648 obj := &OxmIdReg3Masked{
7649 OxmId: NewOxmId(67336),
7650 }
7651 return obj
7652}
7653func (self *OxmIdReg3Masked) GetOXMName() string {
7654 return "reg3_masked"
7655}
7656
7657func (self *OxmIdReg3Masked) MarshalJSON() ([]byte, error) {
7658 if self.TypeLen == 0 {
7659 return []byte("\"\""), nil
7660 } else {
7661 return []byte("\"" + self.GetOXMName() + "\""), nil
7662 }
7663}
7664
7665type OxmIdReg4 struct {
7666 *OxmId
7667}
7668
7669type IOxmIdReg4 interface {
7670 IOxmId
7671}
7672
7673func (self *OxmIdReg4) Serialize(encoder *goloxi.Encoder) error {
7674 if err := self.OxmId.Serialize(encoder); err != nil {
7675 return err
7676 }
7677
7678 return nil
7679}
7680
7681func DecodeOxmIdReg4(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg4, error) {
7682 _oxmidreg4 := &OxmIdReg4{OxmId: parent}
7683 return _oxmidreg4, nil
7684}
7685
7686func NewOxmIdReg4() *OxmIdReg4 {
7687 obj := &OxmIdReg4{
7688 OxmId: NewOxmId(67588),
7689 }
7690 return obj
7691}
7692func (self *OxmIdReg4) GetOXMName() string {
7693 return "reg4"
7694}
7695
7696func (self *OxmIdReg4) MarshalJSON() ([]byte, error) {
7697 if self.TypeLen == 0 {
7698 return []byte("\"\""), nil
7699 } else {
7700 return []byte("\"" + self.GetOXMName() + "\""), nil
7701 }
7702}
7703
7704type OxmIdReg4Masked struct {
7705 *OxmId
7706}
7707
7708type IOxmIdReg4Masked interface {
7709 IOxmId
7710}
7711
7712func (self *OxmIdReg4Masked) Serialize(encoder *goloxi.Encoder) error {
7713 if err := self.OxmId.Serialize(encoder); err != nil {
7714 return err
7715 }
7716
7717 return nil
7718}
7719
7720func DecodeOxmIdReg4Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg4Masked, error) {
7721 _oxmidreg4masked := &OxmIdReg4Masked{OxmId: parent}
7722 return _oxmidreg4masked, nil
7723}
7724
7725func NewOxmIdReg4Masked() *OxmIdReg4Masked {
7726 obj := &OxmIdReg4Masked{
7727 OxmId: NewOxmId(67848),
7728 }
7729 return obj
7730}
7731func (self *OxmIdReg4Masked) GetOXMName() string {
7732 return "reg4_masked"
7733}
7734
7735func (self *OxmIdReg4Masked) MarshalJSON() ([]byte, error) {
7736 if self.TypeLen == 0 {
7737 return []byte("\"\""), nil
7738 } else {
7739 return []byte("\"" + self.GetOXMName() + "\""), nil
7740 }
7741}
7742
7743type OxmIdReg5 struct {
7744 *OxmId
7745}
7746
7747type IOxmIdReg5 interface {
7748 IOxmId
7749}
7750
7751func (self *OxmIdReg5) Serialize(encoder *goloxi.Encoder) error {
7752 if err := self.OxmId.Serialize(encoder); err != nil {
7753 return err
7754 }
7755
7756 return nil
7757}
7758
7759func DecodeOxmIdReg5(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg5, error) {
7760 _oxmidreg5 := &OxmIdReg5{OxmId: parent}
7761 return _oxmidreg5, nil
7762}
7763
7764func NewOxmIdReg5() *OxmIdReg5 {
7765 obj := &OxmIdReg5{
7766 OxmId: NewOxmId(68100),
7767 }
7768 return obj
7769}
7770func (self *OxmIdReg5) GetOXMName() string {
7771 return "reg5"
7772}
7773
7774func (self *OxmIdReg5) MarshalJSON() ([]byte, error) {
7775 if self.TypeLen == 0 {
7776 return []byte("\"\""), nil
7777 } else {
7778 return []byte("\"" + self.GetOXMName() + "\""), nil
7779 }
7780}
7781
7782type OxmIdReg5Masked struct {
7783 *OxmId
7784}
7785
7786type IOxmIdReg5Masked interface {
7787 IOxmId
7788}
7789
7790func (self *OxmIdReg5Masked) Serialize(encoder *goloxi.Encoder) error {
7791 if err := self.OxmId.Serialize(encoder); err != nil {
7792 return err
7793 }
7794
7795 return nil
7796}
7797
7798func DecodeOxmIdReg5Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg5Masked, error) {
7799 _oxmidreg5masked := &OxmIdReg5Masked{OxmId: parent}
7800 return _oxmidreg5masked, nil
7801}
7802
7803func NewOxmIdReg5Masked() *OxmIdReg5Masked {
7804 obj := &OxmIdReg5Masked{
7805 OxmId: NewOxmId(68360),
7806 }
7807 return obj
7808}
7809func (self *OxmIdReg5Masked) GetOXMName() string {
7810 return "reg5_masked"
7811}
7812
7813func (self *OxmIdReg5Masked) MarshalJSON() ([]byte, error) {
7814 if self.TypeLen == 0 {
7815 return []byte("\"\""), nil
7816 } else {
7817 return []byte("\"" + self.GetOXMName() + "\""), nil
7818 }
7819}
7820
7821type OxmIdReg6 struct {
7822 *OxmId
7823}
7824
7825type IOxmIdReg6 interface {
7826 IOxmId
7827}
7828
7829func (self *OxmIdReg6) Serialize(encoder *goloxi.Encoder) error {
7830 if err := self.OxmId.Serialize(encoder); err != nil {
7831 return err
7832 }
7833
7834 return nil
7835}
7836
7837func DecodeOxmIdReg6(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg6, error) {
7838 _oxmidreg6 := &OxmIdReg6{OxmId: parent}
7839 return _oxmidreg6, nil
7840}
7841
7842func NewOxmIdReg6() *OxmIdReg6 {
7843 obj := &OxmIdReg6{
7844 OxmId: NewOxmId(68612),
7845 }
7846 return obj
7847}
7848func (self *OxmIdReg6) GetOXMName() string {
7849 return "reg6"
7850}
7851
7852func (self *OxmIdReg6) MarshalJSON() ([]byte, error) {
7853 if self.TypeLen == 0 {
7854 return []byte("\"\""), nil
7855 } else {
7856 return []byte("\"" + self.GetOXMName() + "\""), nil
7857 }
7858}
7859
7860type OxmIdReg6Masked struct {
7861 *OxmId
7862}
7863
7864type IOxmIdReg6Masked interface {
7865 IOxmId
7866}
7867
7868func (self *OxmIdReg6Masked) Serialize(encoder *goloxi.Encoder) error {
7869 if err := self.OxmId.Serialize(encoder); err != nil {
7870 return err
7871 }
7872
7873 return nil
7874}
7875
7876func DecodeOxmIdReg6Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg6Masked, error) {
7877 _oxmidreg6masked := &OxmIdReg6Masked{OxmId: parent}
7878 return _oxmidreg6masked, nil
7879}
7880
7881func NewOxmIdReg6Masked() *OxmIdReg6Masked {
7882 obj := &OxmIdReg6Masked{
7883 OxmId: NewOxmId(68872),
7884 }
7885 return obj
7886}
7887func (self *OxmIdReg6Masked) GetOXMName() string {
7888 return "reg6_masked"
7889}
7890
7891func (self *OxmIdReg6Masked) MarshalJSON() ([]byte, error) {
7892 if self.TypeLen == 0 {
7893 return []byte("\"\""), nil
7894 } else {
7895 return []byte("\"" + self.GetOXMName() + "\""), nil
7896 }
7897}
7898
7899type OxmIdReg7 struct {
7900 *OxmId
7901}
7902
7903type IOxmIdReg7 interface {
7904 IOxmId
7905}
7906
7907func (self *OxmIdReg7) Serialize(encoder *goloxi.Encoder) error {
7908 if err := self.OxmId.Serialize(encoder); err != nil {
7909 return err
7910 }
7911
7912 return nil
7913}
7914
7915func DecodeOxmIdReg7(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg7, error) {
7916 _oxmidreg7 := &OxmIdReg7{OxmId: parent}
7917 return _oxmidreg7, nil
7918}
7919
7920func NewOxmIdReg7() *OxmIdReg7 {
7921 obj := &OxmIdReg7{
7922 OxmId: NewOxmId(69124),
7923 }
7924 return obj
7925}
7926func (self *OxmIdReg7) GetOXMName() string {
7927 return "reg7"
7928}
7929
7930func (self *OxmIdReg7) MarshalJSON() ([]byte, error) {
7931 if self.TypeLen == 0 {
7932 return []byte("\"\""), nil
7933 } else {
7934 return []byte("\"" + self.GetOXMName() + "\""), nil
7935 }
7936}
7937
7938type OxmIdReg7Masked struct {
7939 *OxmId
7940}
7941
7942type IOxmIdReg7Masked interface {
7943 IOxmId
7944}
7945
7946func (self *OxmIdReg7Masked) Serialize(encoder *goloxi.Encoder) error {
7947 if err := self.OxmId.Serialize(encoder); err != nil {
7948 return err
7949 }
7950
7951 return nil
7952}
7953
7954func DecodeOxmIdReg7Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg7Masked, error) {
7955 _oxmidreg7masked := &OxmIdReg7Masked{OxmId: parent}
7956 return _oxmidreg7masked, nil
7957}
7958
7959func NewOxmIdReg7Masked() *OxmIdReg7Masked {
7960 obj := &OxmIdReg7Masked{
7961 OxmId: NewOxmId(69384),
7962 }
7963 return obj
7964}
7965func (self *OxmIdReg7Masked) GetOXMName() string {
7966 return "reg7_masked"
7967}
7968
7969func (self *OxmIdReg7Masked) MarshalJSON() ([]byte, error) {
7970 if self.TypeLen == 0 {
7971 return []byte("\"\""), nil
7972 } else {
7973 return []byte("\"" + self.GetOXMName() + "\""), nil
7974 }
7975}
7976
7977type OxmIdReg8 struct {
7978 *OxmId
7979}
7980
7981type IOxmIdReg8 interface {
7982 IOxmId
7983}
7984
7985func (self *OxmIdReg8) Serialize(encoder *goloxi.Encoder) error {
7986 if err := self.OxmId.Serialize(encoder); err != nil {
7987 return err
7988 }
7989
7990 return nil
7991}
7992
7993func DecodeOxmIdReg8(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg8, error) {
7994 _oxmidreg8 := &OxmIdReg8{OxmId: parent}
7995 return _oxmidreg8, nil
7996}
7997
7998func NewOxmIdReg8() *OxmIdReg8 {
7999 obj := &OxmIdReg8{
8000 OxmId: NewOxmId(69636),
8001 }
8002 return obj
8003}
8004func (self *OxmIdReg8) GetOXMName() string {
8005 return "reg8"
8006}
8007
8008func (self *OxmIdReg8) MarshalJSON() ([]byte, error) {
8009 if self.TypeLen == 0 {
8010 return []byte("\"\""), nil
8011 } else {
8012 return []byte("\"" + self.GetOXMName() + "\""), nil
8013 }
8014}
8015
8016type OxmIdReg8Masked struct {
8017 *OxmId
8018}
8019
8020type IOxmIdReg8Masked interface {
8021 IOxmId
8022}
8023
8024func (self *OxmIdReg8Masked) Serialize(encoder *goloxi.Encoder) error {
8025 if err := self.OxmId.Serialize(encoder); err != nil {
8026 return err
8027 }
8028
8029 return nil
8030}
8031
8032func DecodeOxmIdReg8Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg8Masked, error) {
8033 _oxmidreg8masked := &OxmIdReg8Masked{OxmId: parent}
8034 return _oxmidreg8masked, nil
8035}
8036
8037func NewOxmIdReg8Masked() *OxmIdReg8Masked {
8038 obj := &OxmIdReg8Masked{
8039 OxmId: NewOxmId(69896),
8040 }
8041 return obj
8042}
8043func (self *OxmIdReg8Masked) GetOXMName() string {
8044 return "reg8_masked"
8045}
8046
8047func (self *OxmIdReg8Masked) MarshalJSON() ([]byte, error) {
8048 if self.TypeLen == 0 {
8049 return []byte("\"\""), nil
8050 } else {
8051 return []byte("\"" + self.GetOXMName() + "\""), nil
8052 }
8053}
8054
8055type OxmIdReg9 struct {
8056 *OxmId
8057}
8058
8059type IOxmIdReg9 interface {
8060 IOxmId
8061}
8062
8063func (self *OxmIdReg9) Serialize(encoder *goloxi.Encoder) error {
8064 if err := self.OxmId.Serialize(encoder); err != nil {
8065 return err
8066 }
8067
8068 return nil
8069}
8070
8071func DecodeOxmIdReg9(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg9, error) {
8072 _oxmidreg9 := &OxmIdReg9{OxmId: parent}
8073 return _oxmidreg9, nil
8074}
8075
8076func NewOxmIdReg9() *OxmIdReg9 {
8077 obj := &OxmIdReg9{
8078 OxmId: NewOxmId(70148),
8079 }
8080 return obj
8081}
8082func (self *OxmIdReg9) GetOXMName() string {
8083 return "reg9"
8084}
8085
8086func (self *OxmIdReg9) MarshalJSON() ([]byte, error) {
8087 if self.TypeLen == 0 {
8088 return []byte("\"\""), nil
8089 } else {
8090 return []byte("\"" + self.GetOXMName() + "\""), nil
8091 }
8092}
8093
8094type OxmIdReg9Masked struct {
8095 *OxmId
8096}
8097
8098type IOxmIdReg9Masked interface {
8099 IOxmId
8100}
8101
8102func (self *OxmIdReg9Masked) Serialize(encoder *goloxi.Encoder) error {
8103 if err := self.OxmId.Serialize(encoder); err != nil {
8104 return err
8105 }
8106
8107 return nil
8108}
8109
8110func DecodeOxmIdReg9Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg9Masked, error) {
8111 _oxmidreg9masked := &OxmIdReg9Masked{OxmId: parent}
8112 return _oxmidreg9masked, nil
8113}
8114
8115func NewOxmIdReg9Masked() *OxmIdReg9Masked {
8116 obj := &OxmIdReg9Masked{
8117 OxmId: NewOxmId(70408),
8118 }
8119 return obj
8120}
8121func (self *OxmIdReg9Masked) GetOXMName() string {
8122 return "reg9_masked"
8123}
8124
8125func (self *OxmIdReg9Masked) MarshalJSON() ([]byte, error) {
8126 if self.TypeLen == 0 {
8127 return []byte("\"\""), nil
8128 } else {
8129 return []byte("\"" + self.GetOXMName() + "\""), nil
8130 }
8131}
8132
8133type OxmIdTcpDst struct {
8134 *OxmId
8135}
8136
8137type IOxmIdTcpDst interface {
8138 IOxmId
8139}
8140
8141func (self *OxmIdTcpDst) Serialize(encoder *goloxi.Encoder) error {
8142 if err := self.OxmId.Serialize(encoder); err != nil {
8143 return err
8144 }
8145
8146 return nil
8147}
8148
8149func DecodeOxmIdTcpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpDst, error) {
8150 _oxmidtcpdst := &OxmIdTcpDst{OxmId: parent}
8151 return _oxmidtcpdst, nil
8152}
8153
8154func NewOxmIdTcpDst() *OxmIdTcpDst {
8155 obj := &OxmIdTcpDst{
8156 OxmId: NewOxmId(5122),
8157 }
8158 return obj
8159}
8160func (self *OxmIdTcpDst) GetOXMName() string {
8161 return "tcp_dst"
8162}
8163
8164func (self *OxmIdTcpDst) MarshalJSON() ([]byte, error) {
8165 if self.TypeLen == 0 {
8166 return []byte("\"\""), nil
8167 } else {
8168 return []byte("\"" + self.GetOXMName() + "\""), nil
8169 }
8170}
8171
8172type OxmIdTcpDstMasked struct {
8173 *OxmId
8174}
8175
8176type IOxmIdTcpDstMasked interface {
8177 IOxmId
8178}
8179
8180func (self *OxmIdTcpDstMasked) Serialize(encoder *goloxi.Encoder) error {
8181 if err := self.OxmId.Serialize(encoder); err != nil {
8182 return err
8183 }
8184
8185 return nil
8186}
8187
8188func DecodeOxmIdTcpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpDstMasked, error) {
8189 _oxmidtcpdstmasked := &OxmIdTcpDstMasked{OxmId: parent}
8190 return _oxmidtcpdstmasked, nil
8191}
8192
8193func NewOxmIdTcpDstMasked() *OxmIdTcpDstMasked {
8194 obj := &OxmIdTcpDstMasked{
8195 OxmId: NewOxmId(5378),
8196 }
8197 return obj
8198}
8199func (self *OxmIdTcpDstMasked) GetOXMName() string {
8200 return "tcp_dst_masked"
8201}
8202
8203func (self *OxmIdTcpDstMasked) MarshalJSON() ([]byte, error) {
8204 if self.TypeLen == 0 {
8205 return []byte("\"\""), nil
8206 } else {
8207 return []byte("\"" + self.GetOXMName() + "\""), nil
8208 }
8209}
8210
8211type OxmIdTcpFlags struct {
8212 *OxmId
8213}
8214
8215type IOxmIdTcpFlags interface {
8216 IOxmId
8217}
8218
8219func (self *OxmIdTcpFlags) Serialize(encoder *goloxi.Encoder) error {
8220 if err := self.OxmId.Serialize(encoder); err != nil {
8221 return err
8222 }
8223
8224 return nil
8225}
8226
8227func DecodeOxmIdTcpFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpFlags, error) {
8228 _oxmidtcpflags := &OxmIdTcpFlags{OxmId: parent}
8229 return _oxmidtcpflags, nil
8230}
8231
8232func NewOxmIdTcpFlags() *OxmIdTcpFlags {
8233 obj := &OxmIdTcpFlags{
8234 OxmId: NewOxmId(82946),
8235 }
8236 return obj
8237}
8238func (self *OxmIdTcpFlags) GetOXMName() string {
8239 return "tcp_flags"
8240}
8241
8242func (self *OxmIdTcpFlags) MarshalJSON() ([]byte, error) {
8243 if self.TypeLen == 0 {
8244 return []byte("\"\""), nil
8245 } else {
8246 return []byte("\"" + self.GetOXMName() + "\""), nil
8247 }
8248}
8249
8250type OxmIdTcpFlagsMasked struct {
8251 *OxmId
8252}
8253
8254type IOxmIdTcpFlagsMasked interface {
8255 IOxmId
8256}
8257
8258func (self *OxmIdTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
8259 if err := self.OxmId.Serialize(encoder); err != nil {
8260 return err
8261 }
8262
8263 return nil
8264}
8265
8266func DecodeOxmIdTcpFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpFlagsMasked, error) {
8267 _oxmidtcpflagsmasked := &OxmIdTcpFlagsMasked{OxmId: parent}
8268 return _oxmidtcpflagsmasked, nil
8269}
8270
8271func NewOxmIdTcpFlagsMasked() *OxmIdTcpFlagsMasked {
8272 obj := &OxmIdTcpFlagsMasked{
8273 OxmId: NewOxmId(83204),
8274 }
8275 return obj
8276}
8277func (self *OxmIdTcpFlagsMasked) GetOXMName() string {
8278 return "tcp_flags_masked"
8279}
8280
8281func (self *OxmIdTcpFlagsMasked) MarshalJSON() ([]byte, error) {
8282 if self.TypeLen == 0 {
8283 return []byte("\"\""), nil
8284 } else {
8285 return []byte("\"" + self.GetOXMName() + "\""), nil
8286 }
8287}
8288
8289type OxmIdTcpSrc struct {
8290 *OxmId
8291}
8292
8293type IOxmIdTcpSrc interface {
8294 IOxmId
8295}
8296
8297func (self *OxmIdTcpSrc) Serialize(encoder *goloxi.Encoder) error {
8298 if err := self.OxmId.Serialize(encoder); err != nil {
8299 return err
8300 }
8301
8302 return nil
8303}
8304
8305func DecodeOxmIdTcpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpSrc, error) {
8306 _oxmidtcpsrc := &OxmIdTcpSrc{OxmId: parent}
8307 return _oxmidtcpsrc, nil
8308}
8309
8310func NewOxmIdTcpSrc() *OxmIdTcpSrc {
8311 obj := &OxmIdTcpSrc{
8312 OxmId: NewOxmId(4610),
8313 }
8314 return obj
8315}
8316func (self *OxmIdTcpSrc) GetOXMName() string {
8317 return "tcp_src"
8318}
8319
8320func (self *OxmIdTcpSrc) MarshalJSON() ([]byte, error) {
8321 if self.TypeLen == 0 {
8322 return []byte("\"\""), nil
8323 } else {
8324 return []byte("\"" + self.GetOXMName() + "\""), nil
8325 }
8326}
8327
8328type OxmIdTcpSrcMasked struct {
8329 *OxmId
8330}
8331
8332type IOxmIdTcpSrcMasked interface {
8333 IOxmId
8334}
8335
8336func (self *OxmIdTcpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
8337 if err := self.OxmId.Serialize(encoder); err != nil {
8338 return err
8339 }
8340
8341 return nil
8342}
8343
8344func DecodeOxmIdTcpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpSrcMasked, error) {
8345 _oxmidtcpsrcmasked := &OxmIdTcpSrcMasked{OxmId: parent}
8346 return _oxmidtcpsrcmasked, nil
8347}
8348
8349func NewOxmIdTcpSrcMasked() *OxmIdTcpSrcMasked {
8350 obj := &OxmIdTcpSrcMasked{
8351 OxmId: NewOxmId(4868),
8352 }
8353 return obj
8354}
8355func (self *OxmIdTcpSrcMasked) GetOXMName() string {
8356 return "tcp_src_masked"
8357}
8358
8359func (self *OxmIdTcpSrcMasked) MarshalJSON() ([]byte, error) {
8360 if self.TypeLen == 0 {
8361 return []byte("\"\""), nil
8362 } else {
8363 return []byte("\"" + self.GetOXMName() + "\""), nil
8364 }
8365}
8366
8367type OxmIdTunDst struct {
8368 *OxmId
8369}
8370
8371type IOxmIdTunDst interface {
8372 IOxmId
8373}
8374
8375func (self *OxmIdTunDst) Serialize(encoder *goloxi.Encoder) error {
8376 if err := self.OxmId.Serialize(encoder); err != nil {
8377 return err
8378 }
8379
8380 return nil
8381}
8382
8383func DecodeOxmIdTunDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunDst, error) {
8384 _oxmidtundst := &OxmIdTunDst{OxmId: parent}
8385 return _oxmidtundst, nil
8386}
8387
8388func NewOxmIdTunDst() *OxmIdTunDst {
8389 obj := &OxmIdTunDst{
8390 OxmId: NewOxmId(81924),
8391 }
8392 return obj
8393}
8394func (self *OxmIdTunDst) GetOXMName() string {
8395 return "tun_dst"
8396}
8397
8398func (self *OxmIdTunDst) MarshalJSON() ([]byte, error) {
8399 if self.TypeLen == 0 {
8400 return []byte("\"\""), nil
8401 } else {
8402 return []byte("\"" + self.GetOXMName() + "\""), nil
8403 }
8404}
8405
8406type OxmIdTunDstMasked struct {
8407 *OxmId
8408}
8409
8410type IOxmIdTunDstMasked interface {
8411 IOxmId
8412}
8413
8414func (self *OxmIdTunDstMasked) Serialize(encoder *goloxi.Encoder) error {
8415 if err := self.OxmId.Serialize(encoder); err != nil {
8416 return err
8417 }
8418
8419 return nil
8420}
8421
8422func DecodeOxmIdTunDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunDstMasked, error) {
8423 _oxmidtundstmasked := &OxmIdTunDstMasked{OxmId: parent}
8424 return _oxmidtundstmasked, nil
8425}
8426
8427func NewOxmIdTunDstMasked() *OxmIdTunDstMasked {
8428 obj := &OxmIdTunDstMasked{
8429 OxmId: NewOxmId(82184),
8430 }
8431 return obj
8432}
8433func (self *OxmIdTunDstMasked) GetOXMName() string {
8434 return "tun_dst_masked"
8435}
8436
8437func (self *OxmIdTunDstMasked) MarshalJSON() ([]byte, error) {
8438 if self.TypeLen == 0 {
8439 return []byte("\"\""), nil
8440 } else {
8441 return []byte("\"" + self.GetOXMName() + "\""), nil
8442 }
8443}
8444
8445type OxmIdTunFlags struct {
8446 *OxmId
8447}
8448
8449type IOxmIdTunFlags interface {
8450 IOxmId
8451}
8452
8453func (self *OxmIdTunFlags) Serialize(encoder *goloxi.Encoder) error {
8454 if err := self.OxmId.Serialize(encoder); err != nil {
8455 return err
8456 }
8457
8458 return nil
8459}
8460
8461func DecodeOxmIdTunFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunFlags, error) {
8462 _oxmidtunflags := &OxmIdTunFlags{OxmId: parent}
8463 return _oxmidtunflags, nil
8464}
8465
8466func NewOxmIdTunFlags() *OxmIdTunFlags {
8467 obj := &OxmIdTunFlags{
8468 OxmId: NewOxmId(118786),
8469 }
8470 return obj
8471}
8472func (self *OxmIdTunFlags) GetOXMName() string {
8473 return "tun_flags"
8474}
8475
8476func (self *OxmIdTunFlags) MarshalJSON() ([]byte, error) {
8477 if self.TypeLen == 0 {
8478 return []byte("\"\""), nil
8479 } else {
8480 return []byte("\"" + self.GetOXMName() + "\""), nil
8481 }
8482}
8483
8484type OxmIdTunFlagsMasked struct {
8485 *OxmId
8486}
8487
8488type IOxmIdTunFlagsMasked interface {
8489 IOxmId
8490}
8491
8492func (self *OxmIdTunFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
8493 if err := self.OxmId.Serialize(encoder); err != nil {
8494 return err
8495 }
8496
8497 return nil
8498}
8499
8500func DecodeOxmIdTunFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunFlagsMasked, error) {
8501 _oxmidtunflagsmasked := &OxmIdTunFlagsMasked{OxmId: parent}
8502 return _oxmidtunflagsmasked, nil
8503}
8504
8505func NewOxmIdTunFlagsMasked() *OxmIdTunFlagsMasked {
8506 obj := &OxmIdTunFlagsMasked{
8507 OxmId: NewOxmId(119044),
8508 }
8509 return obj
8510}
8511func (self *OxmIdTunFlagsMasked) GetOXMName() string {
8512 return "tun_flags_masked"
8513}
8514
8515func (self *OxmIdTunFlagsMasked) MarshalJSON() ([]byte, error) {
8516 if self.TypeLen == 0 {
8517 return []byte("\"\""), nil
8518 } else {
8519 return []byte("\"" + self.GetOXMName() + "\""), nil
8520 }
8521}
8522
8523type OxmIdTunGbpFlags struct {
8524 *OxmId
8525}
8526
8527type IOxmIdTunGbpFlags interface {
8528 IOxmId
8529}
8530
8531func (self *OxmIdTunGbpFlags) Serialize(encoder *goloxi.Encoder) error {
8532 if err := self.OxmId.Serialize(encoder); err != nil {
8533 return err
8534 }
8535
8536 return nil
8537}
8538
8539func DecodeOxmIdTunGbpFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpFlags, error) {
8540 _oxmidtungbpflags := &OxmIdTunGbpFlags{OxmId: parent}
8541 return _oxmidtungbpflags, nil
8542}
8543
8544func NewOxmIdTunGbpFlags() *OxmIdTunGbpFlags {
8545 obj := &OxmIdTunGbpFlags{
8546 OxmId: NewOxmId(85505),
8547 }
8548 return obj
8549}
8550func (self *OxmIdTunGbpFlags) GetOXMName() string {
8551 return "tun_gbp_flags"
8552}
8553
8554func (self *OxmIdTunGbpFlags) MarshalJSON() ([]byte, error) {
8555 if self.TypeLen == 0 {
8556 return []byte("\"\""), nil
8557 } else {
8558 return []byte("\"" + self.GetOXMName() + "\""), nil
8559 }
8560}
8561
8562type OxmIdTunGbpFlagsMasked struct {
8563 *OxmId
8564}
8565
8566type IOxmIdTunGbpFlagsMasked interface {
8567 IOxmId
8568}
8569
8570func (self *OxmIdTunGbpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
8571 if err := self.OxmId.Serialize(encoder); err != nil {
8572 return err
8573 }
8574
8575 return nil
8576}
8577
8578func DecodeOxmIdTunGbpFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpFlagsMasked, error) {
8579 _oxmidtungbpflagsmasked := &OxmIdTunGbpFlagsMasked{OxmId: parent}
8580 return _oxmidtungbpflagsmasked, nil
8581}
8582
8583func NewOxmIdTunGbpFlagsMasked() *OxmIdTunGbpFlagsMasked {
8584 obj := &OxmIdTunGbpFlagsMasked{
8585 OxmId: NewOxmId(85762),
8586 }
8587 return obj
8588}
8589func (self *OxmIdTunGbpFlagsMasked) GetOXMName() string {
8590 return "tun_gbp_flags_masked"
8591}
8592
8593func (self *OxmIdTunGbpFlagsMasked) MarshalJSON() ([]byte, error) {
8594 if self.TypeLen == 0 {
8595 return []byte("\"\""), nil
8596 } else {
8597 return []byte("\"" + self.GetOXMName() + "\""), nil
8598 }
8599}
8600
8601type OxmIdTunGbpId struct {
8602 *OxmId
8603}
8604
8605type IOxmIdTunGbpId interface {
8606 IOxmId
8607}
8608
8609func (self *OxmIdTunGbpId) Serialize(encoder *goloxi.Encoder) error {
8610 if err := self.OxmId.Serialize(encoder); err != nil {
8611 return err
8612 }
8613
8614 return nil
8615}
8616
8617func DecodeOxmIdTunGbpId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpId, error) {
8618 _oxmidtungbpid := &OxmIdTunGbpId{OxmId: parent}
8619 return _oxmidtungbpid, nil
8620}
8621
8622func NewOxmIdTunGbpId() *OxmIdTunGbpId {
8623 obj := &OxmIdTunGbpId{
8624 OxmId: NewOxmId(84994),
8625 }
8626 return obj
8627}
8628func (self *OxmIdTunGbpId) GetOXMName() string {
8629 return "tun_gbp_id"
8630}
8631
8632func (self *OxmIdTunGbpId) MarshalJSON() ([]byte, error) {
8633 if self.TypeLen == 0 {
8634 return []byte("\"\""), nil
8635 } else {
8636 return []byte("\"" + self.GetOXMName() + "\""), nil
8637 }
8638}
8639
8640type OxmIdTunGbpIdMasked struct {
8641 *OxmId
8642}
8643
8644type IOxmIdTunGbpIdMasked interface {
8645 IOxmId
8646}
8647
8648func (self *OxmIdTunGbpIdMasked) Serialize(encoder *goloxi.Encoder) error {
8649 if err := self.OxmId.Serialize(encoder); err != nil {
8650 return err
8651 }
8652
8653 return nil
8654}
8655
8656func DecodeOxmIdTunGbpIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpIdMasked, error) {
8657 _oxmidtungbpidmasked := &OxmIdTunGbpIdMasked{OxmId: parent}
8658 return _oxmidtungbpidmasked, nil
8659}
8660
8661func NewOxmIdTunGbpIdMasked() *OxmIdTunGbpIdMasked {
8662 obj := &OxmIdTunGbpIdMasked{
8663 OxmId: NewOxmId(85252),
8664 }
8665 return obj
8666}
8667func (self *OxmIdTunGbpIdMasked) GetOXMName() string {
8668 return "tun_gbp_id_masked"
8669}
8670
8671func (self *OxmIdTunGbpIdMasked) MarshalJSON() ([]byte, error) {
8672 if self.TypeLen == 0 {
8673 return []byte("\"\""), nil
8674 } else {
8675 return []byte("\"" + self.GetOXMName() + "\""), nil
8676 }
8677}
8678
8679type OxmIdTunId struct {
8680 *OxmId
8681}
8682
8683type IOxmIdTunId interface {
8684 IOxmId
8685}
8686
8687func (self *OxmIdTunId) Serialize(encoder *goloxi.Encoder) error {
8688 if err := self.OxmId.Serialize(encoder); err != nil {
8689 return err
8690 }
8691
8692 return nil
8693}
8694
8695func DecodeOxmIdTunId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunId, error) {
8696 _oxmidtunid := &OxmIdTunId{OxmId: parent}
8697 return _oxmidtunid, nil
8698}
8699
8700func NewOxmIdTunId() *OxmIdTunId {
8701 obj := &OxmIdTunId{
8702 OxmId: NewOxmId(73736),
8703 }
8704 return obj
8705}
8706func (self *OxmIdTunId) GetOXMName() string {
8707 return "tun_id"
8708}
8709
8710func (self *OxmIdTunId) MarshalJSON() ([]byte, error) {
8711 if self.TypeLen == 0 {
8712 return []byte("\"\""), nil
8713 } else {
8714 return []byte("\"" + self.GetOXMName() + "\""), nil
8715 }
8716}
8717
8718type OxmIdTunIdMasked struct {
8719 *OxmId
8720}
8721
8722type IOxmIdTunIdMasked interface {
8723 IOxmId
8724}
8725
8726func (self *OxmIdTunIdMasked) Serialize(encoder *goloxi.Encoder) error {
8727 if err := self.OxmId.Serialize(encoder); err != nil {
8728 return err
8729 }
8730
8731 return nil
8732}
8733
8734func DecodeOxmIdTunIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIdMasked, error) {
8735 _oxmidtunidmasked := &OxmIdTunIdMasked{OxmId: parent}
8736 return _oxmidtunidmasked, nil
8737}
8738
8739func NewOxmIdTunIdMasked() *OxmIdTunIdMasked {
8740 obj := &OxmIdTunIdMasked{
8741 OxmId: NewOxmId(74000),
8742 }
8743 return obj
8744}
8745func (self *OxmIdTunIdMasked) GetOXMName() string {
8746 return "tun_id_masked"
8747}
8748
8749func (self *OxmIdTunIdMasked) MarshalJSON() ([]byte, error) {
8750 if self.TypeLen == 0 {
8751 return []byte("\"\""), nil
8752 } else {
8753 return []byte("\"" + self.GetOXMName() + "\""), nil
8754 }
8755}
8756
8757type OxmIdTunIpv6Dst struct {
8758 *OxmId
8759}
8760
8761type IOxmIdTunIpv6Dst interface {
8762 IOxmId
8763}
8764
8765func (self *OxmIdTunIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
8766 if err := self.OxmId.Serialize(encoder); err != nil {
8767 return err
8768 }
8769
8770 return nil
8771}
8772
8773func DecodeOxmIdTunIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6Dst, error) {
8774 _oxmidtunipv6dst := &OxmIdTunIpv6Dst{OxmId: parent}
8775 return _oxmidtunipv6dst, nil
8776}
8777
8778func NewOxmIdTunIpv6Dst() *OxmIdTunIpv6Dst {
8779 obj := &OxmIdTunIpv6Dst{
8780 OxmId: NewOxmId(121872),
8781 }
8782 return obj
8783}
8784func (self *OxmIdTunIpv6Dst) GetOXMName() string {
8785 return "tun_ipv6_dst"
8786}
8787
8788func (self *OxmIdTunIpv6Dst) MarshalJSON() ([]byte, error) {
8789 if self.TypeLen == 0 {
8790 return []byte("\"\""), nil
8791 } else {
8792 return []byte("\"" + self.GetOXMName() + "\""), nil
8793 }
8794}
8795
8796type OxmIdTunIpv6DstMasked struct {
8797 *OxmId
8798}
8799
8800type IOxmIdTunIpv6DstMasked interface {
8801 IOxmId
8802}
8803
8804func (self *OxmIdTunIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
8805 if err := self.OxmId.Serialize(encoder); err != nil {
8806 return err
8807 }
8808
8809 return nil
8810}
8811
8812func DecodeOxmIdTunIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6DstMasked, error) {
8813 _oxmidtunipv6dstmasked := &OxmIdTunIpv6DstMasked{OxmId: parent}
8814 return _oxmidtunipv6dstmasked, nil
8815}
8816
8817func NewOxmIdTunIpv6DstMasked() *OxmIdTunIpv6DstMasked {
8818 obj := &OxmIdTunIpv6DstMasked{
8819 OxmId: NewOxmId(122144),
8820 }
8821 return obj
8822}
8823func (self *OxmIdTunIpv6DstMasked) GetOXMName() string {
8824 return "tun_ipv6_dst_masked"
8825}
8826
8827func (self *OxmIdTunIpv6DstMasked) MarshalJSON() ([]byte, error) {
8828 if self.TypeLen == 0 {
8829 return []byte("\"\""), nil
8830 } else {
8831 return []byte("\"" + self.GetOXMName() + "\""), nil
8832 }
8833}
8834
8835type OxmIdTunIpv6Src struct {
8836 *OxmId
8837}
8838
8839type IOxmIdTunIpv6Src interface {
8840 IOxmId
8841}
8842
8843func (self *OxmIdTunIpv6Src) Serialize(encoder *goloxi.Encoder) error {
8844 if err := self.OxmId.Serialize(encoder); err != nil {
8845 return err
8846 }
8847
8848 return nil
8849}
8850
8851func DecodeOxmIdTunIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6Src, error) {
8852 _oxmidtunipv6src := &OxmIdTunIpv6Src{OxmId: parent}
8853 return _oxmidtunipv6src, nil
8854}
8855
8856func NewOxmIdTunIpv6Src() *OxmIdTunIpv6Src {
8857 obj := &OxmIdTunIpv6Src{
8858 OxmId: NewOxmId(121360),
8859 }
8860 return obj
8861}
8862func (self *OxmIdTunIpv6Src) GetOXMName() string {
8863 return "tun_ipv6_src"
8864}
8865
8866func (self *OxmIdTunIpv6Src) MarshalJSON() ([]byte, error) {
8867 if self.TypeLen == 0 {
8868 return []byte("\"\""), nil
8869 } else {
8870 return []byte("\"" + self.GetOXMName() + "\""), nil
8871 }
8872}
8873
8874type OxmIdTunIpv6SrcMasked struct {
8875 *OxmId
8876}
8877
8878type IOxmIdTunIpv6SrcMasked interface {
8879 IOxmId
8880}
8881
8882func (self *OxmIdTunIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
8883 if err := self.OxmId.Serialize(encoder); err != nil {
8884 return err
8885 }
8886
8887 return nil
8888}
8889
8890func DecodeOxmIdTunIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6SrcMasked, error) {
8891 _oxmidtunipv6srcmasked := &OxmIdTunIpv6SrcMasked{OxmId: parent}
8892 return _oxmidtunipv6srcmasked, nil
8893}
8894
8895func NewOxmIdTunIpv6SrcMasked() *OxmIdTunIpv6SrcMasked {
8896 obj := &OxmIdTunIpv6SrcMasked{
8897 OxmId: NewOxmId(121632),
8898 }
8899 return obj
8900}
8901func (self *OxmIdTunIpv6SrcMasked) GetOXMName() string {
8902 return "tun_ipv6_src_masked"
8903}
8904
8905func (self *OxmIdTunIpv6SrcMasked) MarshalJSON() ([]byte, error) {
8906 if self.TypeLen == 0 {
8907 return []byte("\"\""), nil
8908 } else {
8909 return []byte("\"" + self.GetOXMName() + "\""), nil
8910 }
8911}
8912
8913type OxmIdTunMetadata0 struct {
8914 *OxmId
8915}
8916
8917type IOxmIdTunMetadata0 interface {
8918 IOxmId
8919}
8920
8921func (self *OxmIdTunMetadata0) Serialize(encoder *goloxi.Encoder) error {
8922 if err := self.OxmId.Serialize(encoder); err != nil {
8923 return err
8924 }
8925
8926 return nil
8927}
8928
8929func DecodeOxmIdTunMetadata0(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata0, error) {
8930 _oxmidtunmetadata0 := &OxmIdTunMetadata0{OxmId: parent}
8931 return _oxmidtunmetadata0, nil
8932}
8933
8934func NewOxmIdTunMetadata0() *OxmIdTunMetadata0 {
8935 obj := &OxmIdTunMetadata0{
8936 OxmId: NewOxmId(86140),
8937 }
8938 return obj
8939}
8940func (self *OxmIdTunMetadata0) GetOXMName() string {
8941 return "tun_metadata0"
8942}
8943
8944func (self *OxmIdTunMetadata0) MarshalJSON() ([]byte, error) {
8945 if self.TypeLen == 0 {
8946 return []byte("\"\""), nil
8947 } else {
8948 return []byte("\"" + self.GetOXMName() + "\""), nil
8949 }
8950}
8951
8952type OxmIdTunMetadata0Masked struct {
8953 *OxmId
8954}
8955
8956type IOxmIdTunMetadata0Masked interface {
8957 IOxmId
8958}
8959
8960func (self *OxmIdTunMetadata0Masked) Serialize(encoder *goloxi.Encoder) error {
8961 if err := self.OxmId.Serialize(encoder); err != nil {
8962 return err
8963 }
8964
8965 return nil
8966}
8967
8968func DecodeOxmIdTunMetadata0Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata0Masked, error) {
8969 _oxmidtunmetadata0masked := &OxmIdTunMetadata0Masked{OxmId: parent}
8970 return _oxmidtunmetadata0masked, nil
8971}
8972
8973func NewOxmIdTunMetadata0Masked() *OxmIdTunMetadata0Masked {
8974 obj := &OxmIdTunMetadata0Masked{
8975 OxmId: NewOxmId(86520),
8976 }
8977 return obj
8978}
8979func (self *OxmIdTunMetadata0Masked) GetOXMName() string {
8980 return "tun_metadata0_masked"
8981}
8982
8983func (self *OxmIdTunMetadata0Masked) MarshalJSON() ([]byte, error) {
8984 if self.TypeLen == 0 {
8985 return []byte("\"\""), nil
8986 } else {
8987 return []byte("\"" + self.GetOXMName() + "\""), nil
8988 }
8989}
8990
8991type OxmIdTunMetadata1 struct {
8992 *OxmId
8993}
8994
8995type IOxmIdTunMetadata1 interface {
8996 IOxmId
8997}
8998
8999func (self *OxmIdTunMetadata1) Serialize(encoder *goloxi.Encoder) error {
9000 if err := self.OxmId.Serialize(encoder); err != nil {
9001 return err
9002 }
9003
9004 return nil
9005}
9006
9007func DecodeOxmIdTunMetadata1(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata1, error) {
9008 _oxmidtunmetadata1 := &OxmIdTunMetadata1{OxmId: parent}
9009 return _oxmidtunmetadata1, nil
9010}
9011
9012func NewOxmIdTunMetadata1() *OxmIdTunMetadata1 {
9013 obj := &OxmIdTunMetadata1{
9014 OxmId: NewOxmId(86652),
9015 }
9016 return obj
9017}
9018func (self *OxmIdTunMetadata1) GetOXMName() string {
9019 return "tun_metadata1"
9020}
9021
9022func (self *OxmIdTunMetadata1) MarshalJSON() ([]byte, error) {
9023 if self.TypeLen == 0 {
9024 return []byte("\"\""), nil
9025 } else {
9026 return []byte("\"" + self.GetOXMName() + "\""), nil
9027 }
9028}
9029
9030type OxmIdTunMetadata10 struct {
9031 *OxmId
9032}
9033
9034type IOxmIdTunMetadata10 interface {
9035 IOxmId
9036}
9037
9038func (self *OxmIdTunMetadata10) Serialize(encoder *goloxi.Encoder) error {
9039 if err := self.OxmId.Serialize(encoder); err != nil {
9040 return err
9041 }
9042
9043 return nil
9044}
9045
9046func DecodeOxmIdTunMetadata10(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata10, error) {
9047 _oxmidtunmetadata10 := &OxmIdTunMetadata10{OxmId: parent}
9048 return _oxmidtunmetadata10, nil
9049}
9050
9051func NewOxmIdTunMetadata10() *OxmIdTunMetadata10 {
9052 obj := &OxmIdTunMetadata10{
9053 OxmId: NewOxmId(91260),
9054 }
9055 return obj
9056}
9057func (self *OxmIdTunMetadata10) GetOXMName() string {
9058 return "tun_metadata10"
9059}
9060
9061func (self *OxmIdTunMetadata10) MarshalJSON() ([]byte, error) {
9062 if self.TypeLen == 0 {
9063 return []byte("\"\""), nil
9064 } else {
9065 return []byte("\"" + self.GetOXMName() + "\""), nil
9066 }
9067}
9068
9069type OxmIdTunMetadata10Masked struct {
9070 *OxmId
9071}
9072
9073type IOxmIdTunMetadata10Masked interface {
9074 IOxmId
9075}
9076
9077func (self *OxmIdTunMetadata10Masked) Serialize(encoder *goloxi.Encoder) error {
9078 if err := self.OxmId.Serialize(encoder); err != nil {
9079 return err
9080 }
9081
9082 return nil
9083}
9084
9085func DecodeOxmIdTunMetadata10Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata10Masked, error) {
9086 _oxmidtunmetadata10masked := &OxmIdTunMetadata10Masked{OxmId: parent}
9087 return _oxmidtunmetadata10masked, nil
9088}
9089
9090func NewOxmIdTunMetadata10Masked() *OxmIdTunMetadata10Masked {
9091 obj := &OxmIdTunMetadata10Masked{
9092 OxmId: NewOxmId(91640),
9093 }
9094 return obj
9095}
9096func (self *OxmIdTunMetadata10Masked) GetOXMName() string {
9097 return "tun_metadata10_masked"
9098}
9099
9100func (self *OxmIdTunMetadata10Masked) MarshalJSON() ([]byte, error) {
9101 if self.TypeLen == 0 {
9102 return []byte("\"\""), nil
9103 } else {
9104 return []byte("\"" + self.GetOXMName() + "\""), nil
9105 }
9106}
9107
9108type OxmIdTunMetadata11 struct {
9109 *OxmId
9110}
9111
9112type IOxmIdTunMetadata11 interface {
9113 IOxmId
9114}
9115
9116func (self *OxmIdTunMetadata11) Serialize(encoder *goloxi.Encoder) error {
9117 if err := self.OxmId.Serialize(encoder); err != nil {
9118 return err
9119 }
9120
9121 return nil
9122}
9123
9124func DecodeOxmIdTunMetadata11(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata11, error) {
9125 _oxmidtunmetadata11 := &OxmIdTunMetadata11{OxmId: parent}
9126 return _oxmidtunmetadata11, nil
9127}
9128
9129func NewOxmIdTunMetadata11() *OxmIdTunMetadata11 {
9130 obj := &OxmIdTunMetadata11{
9131 OxmId: NewOxmId(91772),
9132 }
9133 return obj
9134}
9135func (self *OxmIdTunMetadata11) GetOXMName() string {
9136 return "tun_metadata11"
9137}
9138
9139func (self *OxmIdTunMetadata11) MarshalJSON() ([]byte, error) {
9140 if self.TypeLen == 0 {
9141 return []byte("\"\""), nil
9142 } else {
9143 return []byte("\"" + self.GetOXMName() + "\""), nil
9144 }
9145}
9146
9147type OxmIdTunMetadata11Masked struct {
9148 *OxmId
9149}
9150
9151type IOxmIdTunMetadata11Masked interface {
9152 IOxmId
9153}
9154
9155func (self *OxmIdTunMetadata11Masked) Serialize(encoder *goloxi.Encoder) error {
9156 if err := self.OxmId.Serialize(encoder); err != nil {
9157 return err
9158 }
9159
9160 return nil
9161}
9162
9163func DecodeOxmIdTunMetadata11Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata11Masked, error) {
9164 _oxmidtunmetadata11masked := &OxmIdTunMetadata11Masked{OxmId: parent}
9165 return _oxmidtunmetadata11masked, nil
9166}
9167
9168func NewOxmIdTunMetadata11Masked() *OxmIdTunMetadata11Masked {
9169 obj := &OxmIdTunMetadata11Masked{
9170 OxmId: NewOxmId(92152),
9171 }
9172 return obj
9173}
9174func (self *OxmIdTunMetadata11Masked) GetOXMName() string {
9175 return "tun_metadata11_masked"
9176}
9177
9178func (self *OxmIdTunMetadata11Masked) MarshalJSON() ([]byte, error) {
9179 if self.TypeLen == 0 {
9180 return []byte("\"\""), nil
9181 } else {
9182 return []byte("\"" + self.GetOXMName() + "\""), nil
9183 }
9184}
9185
9186type OxmIdTunMetadata12 struct {
9187 *OxmId
9188}
9189
9190type IOxmIdTunMetadata12 interface {
9191 IOxmId
9192}
9193
9194func (self *OxmIdTunMetadata12) Serialize(encoder *goloxi.Encoder) error {
9195 if err := self.OxmId.Serialize(encoder); err != nil {
9196 return err
9197 }
9198
9199 return nil
9200}
9201
9202func DecodeOxmIdTunMetadata12(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata12, error) {
9203 _oxmidtunmetadata12 := &OxmIdTunMetadata12{OxmId: parent}
9204 return _oxmidtunmetadata12, nil
9205}
9206
9207func NewOxmIdTunMetadata12() *OxmIdTunMetadata12 {
9208 obj := &OxmIdTunMetadata12{
9209 OxmId: NewOxmId(92284),
9210 }
9211 return obj
9212}
9213func (self *OxmIdTunMetadata12) GetOXMName() string {
9214 return "tun_metadata12"
9215}
9216
9217func (self *OxmIdTunMetadata12) MarshalJSON() ([]byte, error) {
9218 if self.TypeLen == 0 {
9219 return []byte("\"\""), nil
9220 } else {
9221 return []byte("\"" + self.GetOXMName() + "\""), nil
9222 }
9223}
9224
9225type OxmIdTunMetadata12Masked struct {
9226 *OxmId
9227}
9228
9229type IOxmIdTunMetadata12Masked interface {
9230 IOxmId
9231}
9232
9233func (self *OxmIdTunMetadata12Masked) Serialize(encoder *goloxi.Encoder) error {
9234 if err := self.OxmId.Serialize(encoder); err != nil {
9235 return err
9236 }
9237
9238 return nil
9239}
9240
9241func DecodeOxmIdTunMetadata12Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata12Masked, error) {
9242 _oxmidtunmetadata12masked := &OxmIdTunMetadata12Masked{OxmId: parent}
9243 return _oxmidtunmetadata12masked, nil
9244}
9245
9246func NewOxmIdTunMetadata12Masked() *OxmIdTunMetadata12Masked {
9247 obj := &OxmIdTunMetadata12Masked{
9248 OxmId: NewOxmId(92664),
9249 }
9250 return obj
9251}
9252func (self *OxmIdTunMetadata12Masked) GetOXMName() string {
9253 return "tun_metadata12_masked"
9254}
9255
9256func (self *OxmIdTunMetadata12Masked) MarshalJSON() ([]byte, error) {
9257 if self.TypeLen == 0 {
9258 return []byte("\"\""), nil
9259 } else {
9260 return []byte("\"" + self.GetOXMName() + "\""), nil
9261 }
9262}
9263
9264type OxmIdTunMetadata13 struct {
9265 *OxmId
9266}
9267
9268type IOxmIdTunMetadata13 interface {
9269 IOxmId
9270}
9271
9272func (self *OxmIdTunMetadata13) Serialize(encoder *goloxi.Encoder) error {
9273 if err := self.OxmId.Serialize(encoder); err != nil {
9274 return err
9275 }
9276
9277 return nil
9278}
9279
9280func DecodeOxmIdTunMetadata13(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata13, error) {
9281 _oxmidtunmetadata13 := &OxmIdTunMetadata13{OxmId: parent}
9282 return _oxmidtunmetadata13, nil
9283}
9284
9285func NewOxmIdTunMetadata13() *OxmIdTunMetadata13 {
9286 obj := &OxmIdTunMetadata13{
9287 OxmId: NewOxmId(92796),
9288 }
9289 return obj
9290}
9291func (self *OxmIdTunMetadata13) GetOXMName() string {
9292 return "tun_metadata13"
9293}
9294
9295func (self *OxmIdTunMetadata13) MarshalJSON() ([]byte, error) {
9296 if self.TypeLen == 0 {
9297 return []byte("\"\""), nil
9298 } else {
9299 return []byte("\"" + self.GetOXMName() + "\""), nil
9300 }
9301}
9302
9303type OxmIdTunMetadata13Masked struct {
9304 *OxmId
9305}
9306
9307type IOxmIdTunMetadata13Masked interface {
9308 IOxmId
9309}
9310
9311func (self *OxmIdTunMetadata13Masked) Serialize(encoder *goloxi.Encoder) error {
9312 if err := self.OxmId.Serialize(encoder); err != nil {
9313 return err
9314 }
9315
9316 return nil
9317}
9318
9319func DecodeOxmIdTunMetadata13Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata13Masked, error) {
9320 _oxmidtunmetadata13masked := &OxmIdTunMetadata13Masked{OxmId: parent}
9321 return _oxmidtunmetadata13masked, nil
9322}
9323
9324func NewOxmIdTunMetadata13Masked() *OxmIdTunMetadata13Masked {
9325 obj := &OxmIdTunMetadata13Masked{
9326 OxmId: NewOxmId(93176),
9327 }
9328 return obj
9329}
9330func (self *OxmIdTunMetadata13Masked) GetOXMName() string {
9331 return "tun_metadata13_masked"
9332}
9333
9334func (self *OxmIdTunMetadata13Masked) MarshalJSON() ([]byte, error) {
9335 if self.TypeLen == 0 {
9336 return []byte("\"\""), nil
9337 } else {
9338 return []byte("\"" + self.GetOXMName() + "\""), nil
9339 }
9340}
9341
9342type OxmIdTunMetadata14 struct {
9343 *OxmId
9344}
9345
9346type IOxmIdTunMetadata14 interface {
9347 IOxmId
9348}
9349
9350func (self *OxmIdTunMetadata14) Serialize(encoder *goloxi.Encoder) error {
9351 if err := self.OxmId.Serialize(encoder); err != nil {
9352 return err
9353 }
9354
9355 return nil
9356}
9357
9358func DecodeOxmIdTunMetadata14(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata14, error) {
9359 _oxmidtunmetadata14 := &OxmIdTunMetadata14{OxmId: parent}
9360 return _oxmidtunmetadata14, nil
9361}
9362
9363func NewOxmIdTunMetadata14() *OxmIdTunMetadata14 {
9364 obj := &OxmIdTunMetadata14{
9365 OxmId: NewOxmId(93308),
9366 }
9367 return obj
9368}
9369func (self *OxmIdTunMetadata14) GetOXMName() string {
9370 return "tun_metadata14"
9371}
9372
9373func (self *OxmIdTunMetadata14) MarshalJSON() ([]byte, error) {
9374 if self.TypeLen == 0 {
9375 return []byte("\"\""), nil
9376 } else {
9377 return []byte("\"" + self.GetOXMName() + "\""), nil
9378 }
9379}
9380
9381type OxmIdTunMetadata14Masked struct {
9382 *OxmId
9383}
9384
9385type IOxmIdTunMetadata14Masked interface {
9386 IOxmId
9387}
9388
9389func (self *OxmIdTunMetadata14Masked) Serialize(encoder *goloxi.Encoder) error {
9390 if err := self.OxmId.Serialize(encoder); err != nil {
9391 return err
9392 }
9393
9394 return nil
9395}
9396
9397func DecodeOxmIdTunMetadata14Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata14Masked, error) {
9398 _oxmidtunmetadata14masked := &OxmIdTunMetadata14Masked{OxmId: parent}
9399 return _oxmidtunmetadata14masked, nil
9400}
9401
9402func NewOxmIdTunMetadata14Masked() *OxmIdTunMetadata14Masked {
9403 obj := &OxmIdTunMetadata14Masked{
9404 OxmId: NewOxmId(93688),
9405 }
9406 return obj
9407}
9408func (self *OxmIdTunMetadata14Masked) GetOXMName() string {
9409 return "tun_metadata14_masked"
9410}
9411
9412func (self *OxmIdTunMetadata14Masked) MarshalJSON() ([]byte, error) {
9413 if self.TypeLen == 0 {
9414 return []byte("\"\""), nil
9415 } else {
9416 return []byte("\"" + self.GetOXMName() + "\""), nil
9417 }
9418}
9419
9420type OxmIdTunMetadata15 struct {
9421 *OxmId
9422}
9423
9424type IOxmIdTunMetadata15 interface {
9425 IOxmId
9426}
9427
9428func (self *OxmIdTunMetadata15) Serialize(encoder *goloxi.Encoder) error {
9429 if err := self.OxmId.Serialize(encoder); err != nil {
9430 return err
9431 }
9432
9433 return nil
9434}
9435
9436func DecodeOxmIdTunMetadata15(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata15, error) {
9437 _oxmidtunmetadata15 := &OxmIdTunMetadata15{OxmId: parent}
9438 return _oxmidtunmetadata15, nil
9439}
9440
9441func NewOxmIdTunMetadata15() *OxmIdTunMetadata15 {
9442 obj := &OxmIdTunMetadata15{
9443 OxmId: NewOxmId(93820),
9444 }
9445 return obj
9446}
9447func (self *OxmIdTunMetadata15) GetOXMName() string {
9448 return "tun_metadata15"
9449}
9450
9451func (self *OxmIdTunMetadata15) MarshalJSON() ([]byte, error) {
9452 if self.TypeLen == 0 {
9453 return []byte("\"\""), nil
9454 } else {
9455 return []byte("\"" + self.GetOXMName() + "\""), nil
9456 }
9457}
9458
9459type OxmIdTunMetadata15Masked struct {
9460 *OxmId
9461}
9462
9463type IOxmIdTunMetadata15Masked interface {
9464 IOxmId
9465}
9466
9467func (self *OxmIdTunMetadata15Masked) Serialize(encoder *goloxi.Encoder) error {
9468 if err := self.OxmId.Serialize(encoder); err != nil {
9469 return err
9470 }
9471
9472 return nil
9473}
9474
9475func DecodeOxmIdTunMetadata15Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata15Masked, error) {
9476 _oxmidtunmetadata15masked := &OxmIdTunMetadata15Masked{OxmId: parent}
9477 return _oxmidtunmetadata15masked, nil
9478}
9479
9480func NewOxmIdTunMetadata15Masked() *OxmIdTunMetadata15Masked {
9481 obj := &OxmIdTunMetadata15Masked{
9482 OxmId: NewOxmId(94200),
9483 }
9484 return obj
9485}
9486func (self *OxmIdTunMetadata15Masked) GetOXMName() string {
9487 return "tun_metadata15_masked"
9488}
9489
9490func (self *OxmIdTunMetadata15Masked) MarshalJSON() ([]byte, error) {
9491 if self.TypeLen == 0 {
9492 return []byte("\"\""), nil
9493 } else {
9494 return []byte("\"" + self.GetOXMName() + "\""), nil
9495 }
9496}
9497
9498type OxmIdTunMetadata16 struct {
9499 *OxmId
9500}
9501
9502type IOxmIdTunMetadata16 interface {
9503 IOxmId
9504}
9505
9506func (self *OxmIdTunMetadata16) Serialize(encoder *goloxi.Encoder) error {
9507 if err := self.OxmId.Serialize(encoder); err != nil {
9508 return err
9509 }
9510
9511 return nil
9512}
9513
9514func DecodeOxmIdTunMetadata16(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata16, error) {
9515 _oxmidtunmetadata16 := &OxmIdTunMetadata16{OxmId: parent}
9516 return _oxmidtunmetadata16, nil
9517}
9518
9519func NewOxmIdTunMetadata16() *OxmIdTunMetadata16 {
9520 obj := &OxmIdTunMetadata16{
9521 OxmId: NewOxmId(94332),
9522 }
9523 return obj
9524}
9525func (self *OxmIdTunMetadata16) GetOXMName() string {
9526 return "tun_metadata16"
9527}
9528
9529func (self *OxmIdTunMetadata16) MarshalJSON() ([]byte, error) {
9530 if self.TypeLen == 0 {
9531 return []byte("\"\""), nil
9532 } else {
9533 return []byte("\"" + self.GetOXMName() + "\""), nil
9534 }
9535}
9536
9537type OxmIdTunMetadata16Masked struct {
9538 *OxmId
9539}
9540
9541type IOxmIdTunMetadata16Masked interface {
9542 IOxmId
9543}
9544
9545func (self *OxmIdTunMetadata16Masked) Serialize(encoder *goloxi.Encoder) error {
9546 if err := self.OxmId.Serialize(encoder); err != nil {
9547 return err
9548 }
9549
9550 return nil
9551}
9552
9553func DecodeOxmIdTunMetadata16Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata16Masked, error) {
9554 _oxmidtunmetadata16masked := &OxmIdTunMetadata16Masked{OxmId: parent}
9555 return _oxmidtunmetadata16masked, nil
9556}
9557
9558func NewOxmIdTunMetadata16Masked() *OxmIdTunMetadata16Masked {
9559 obj := &OxmIdTunMetadata16Masked{
9560 OxmId: NewOxmId(94712),
9561 }
9562 return obj
9563}
9564func (self *OxmIdTunMetadata16Masked) GetOXMName() string {
9565 return "tun_metadata16_masked"
9566}
9567
9568func (self *OxmIdTunMetadata16Masked) MarshalJSON() ([]byte, error) {
9569 if self.TypeLen == 0 {
9570 return []byte("\"\""), nil
9571 } else {
9572 return []byte("\"" + self.GetOXMName() + "\""), nil
9573 }
9574}
9575
9576type OxmIdTunMetadata17 struct {
9577 *OxmId
9578}
9579
9580type IOxmIdTunMetadata17 interface {
9581 IOxmId
9582}
9583
9584func (self *OxmIdTunMetadata17) Serialize(encoder *goloxi.Encoder) error {
9585 if err := self.OxmId.Serialize(encoder); err != nil {
9586 return err
9587 }
9588
9589 return nil
9590}
9591
9592func DecodeOxmIdTunMetadata17(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata17, error) {
9593 _oxmidtunmetadata17 := &OxmIdTunMetadata17{OxmId: parent}
9594 return _oxmidtunmetadata17, nil
9595}
9596
9597func NewOxmIdTunMetadata17() *OxmIdTunMetadata17 {
9598 obj := &OxmIdTunMetadata17{
9599 OxmId: NewOxmId(94844),
9600 }
9601 return obj
9602}
9603func (self *OxmIdTunMetadata17) GetOXMName() string {
9604 return "tun_metadata17"
9605}
9606
9607func (self *OxmIdTunMetadata17) MarshalJSON() ([]byte, error) {
9608 if self.TypeLen == 0 {
9609 return []byte("\"\""), nil
9610 } else {
9611 return []byte("\"" + self.GetOXMName() + "\""), nil
9612 }
9613}
9614
9615type OxmIdTunMetadata17Masked struct {
9616 *OxmId
9617}
9618
9619type IOxmIdTunMetadata17Masked interface {
9620 IOxmId
9621}
9622
9623func (self *OxmIdTunMetadata17Masked) Serialize(encoder *goloxi.Encoder) error {
9624 if err := self.OxmId.Serialize(encoder); err != nil {
9625 return err
9626 }
9627
9628 return nil
9629}
9630
9631func DecodeOxmIdTunMetadata17Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata17Masked, error) {
9632 _oxmidtunmetadata17masked := &OxmIdTunMetadata17Masked{OxmId: parent}
9633 return _oxmidtunmetadata17masked, nil
9634}
9635
9636func NewOxmIdTunMetadata17Masked() *OxmIdTunMetadata17Masked {
9637 obj := &OxmIdTunMetadata17Masked{
9638 OxmId: NewOxmId(95224),
9639 }
9640 return obj
9641}
9642func (self *OxmIdTunMetadata17Masked) GetOXMName() string {
9643 return "tun_metadata17_masked"
9644}
9645
9646func (self *OxmIdTunMetadata17Masked) MarshalJSON() ([]byte, error) {
9647 if self.TypeLen == 0 {
9648 return []byte("\"\""), nil
9649 } else {
9650 return []byte("\"" + self.GetOXMName() + "\""), nil
9651 }
9652}
9653
9654type OxmIdTunMetadata18 struct {
9655 *OxmId
9656}
9657
9658type IOxmIdTunMetadata18 interface {
9659 IOxmId
9660}
9661
9662func (self *OxmIdTunMetadata18) Serialize(encoder *goloxi.Encoder) error {
9663 if err := self.OxmId.Serialize(encoder); err != nil {
9664 return err
9665 }
9666
9667 return nil
9668}
9669
9670func DecodeOxmIdTunMetadata18(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata18, error) {
9671 _oxmidtunmetadata18 := &OxmIdTunMetadata18{OxmId: parent}
9672 return _oxmidtunmetadata18, nil
9673}
9674
9675func NewOxmIdTunMetadata18() *OxmIdTunMetadata18 {
9676 obj := &OxmIdTunMetadata18{
9677 OxmId: NewOxmId(95356),
9678 }
9679 return obj
9680}
9681func (self *OxmIdTunMetadata18) GetOXMName() string {
9682 return "tun_metadata18"
9683}
9684
9685func (self *OxmIdTunMetadata18) MarshalJSON() ([]byte, error) {
9686 if self.TypeLen == 0 {
9687 return []byte("\"\""), nil
9688 } else {
9689 return []byte("\"" + self.GetOXMName() + "\""), nil
9690 }
9691}
9692
9693type OxmIdTunMetadata18Masked struct {
9694 *OxmId
9695}
9696
9697type IOxmIdTunMetadata18Masked interface {
9698 IOxmId
9699}
9700
9701func (self *OxmIdTunMetadata18Masked) Serialize(encoder *goloxi.Encoder) error {
9702 if err := self.OxmId.Serialize(encoder); err != nil {
9703 return err
9704 }
9705
9706 return nil
9707}
9708
9709func DecodeOxmIdTunMetadata18Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata18Masked, error) {
9710 _oxmidtunmetadata18masked := &OxmIdTunMetadata18Masked{OxmId: parent}
9711 return _oxmidtunmetadata18masked, nil
9712}
9713
9714func NewOxmIdTunMetadata18Masked() *OxmIdTunMetadata18Masked {
9715 obj := &OxmIdTunMetadata18Masked{
9716 OxmId: NewOxmId(95736),
9717 }
9718 return obj
9719}
9720func (self *OxmIdTunMetadata18Masked) GetOXMName() string {
9721 return "tun_metadata18_masked"
9722}
9723
9724func (self *OxmIdTunMetadata18Masked) MarshalJSON() ([]byte, error) {
9725 if self.TypeLen == 0 {
9726 return []byte("\"\""), nil
9727 } else {
9728 return []byte("\"" + self.GetOXMName() + "\""), nil
9729 }
9730}
9731
9732type OxmIdTunMetadata19 struct {
9733 *OxmId
9734}
9735
9736type IOxmIdTunMetadata19 interface {
9737 IOxmId
9738}
9739
9740func (self *OxmIdTunMetadata19) Serialize(encoder *goloxi.Encoder) error {
9741 if err := self.OxmId.Serialize(encoder); err != nil {
9742 return err
9743 }
9744
9745 return nil
9746}
9747
9748func DecodeOxmIdTunMetadata19(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata19, error) {
9749 _oxmidtunmetadata19 := &OxmIdTunMetadata19{OxmId: parent}
9750 return _oxmidtunmetadata19, nil
9751}
9752
9753func NewOxmIdTunMetadata19() *OxmIdTunMetadata19 {
9754 obj := &OxmIdTunMetadata19{
9755 OxmId: NewOxmId(95868),
9756 }
9757 return obj
9758}
9759func (self *OxmIdTunMetadata19) GetOXMName() string {
9760 return "tun_metadata19"
9761}
9762
9763func (self *OxmIdTunMetadata19) MarshalJSON() ([]byte, error) {
9764 if self.TypeLen == 0 {
9765 return []byte("\"\""), nil
9766 } else {
9767 return []byte("\"" + self.GetOXMName() + "\""), nil
9768 }
9769}
9770
9771type OxmIdTunMetadata19Masked struct {
9772 *OxmId
9773}
9774
9775type IOxmIdTunMetadata19Masked interface {
9776 IOxmId
9777}
9778
9779func (self *OxmIdTunMetadata19Masked) Serialize(encoder *goloxi.Encoder) error {
9780 if err := self.OxmId.Serialize(encoder); err != nil {
9781 return err
9782 }
9783
9784 return nil
9785}
9786
9787func DecodeOxmIdTunMetadata19Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata19Masked, error) {
9788 _oxmidtunmetadata19masked := &OxmIdTunMetadata19Masked{OxmId: parent}
9789 return _oxmidtunmetadata19masked, nil
9790}
9791
9792func NewOxmIdTunMetadata19Masked() *OxmIdTunMetadata19Masked {
9793 obj := &OxmIdTunMetadata19Masked{
9794 OxmId: NewOxmId(96248),
9795 }
9796 return obj
9797}
9798func (self *OxmIdTunMetadata19Masked) GetOXMName() string {
9799 return "tun_metadata19_masked"
9800}
9801
9802func (self *OxmIdTunMetadata19Masked) MarshalJSON() ([]byte, error) {
9803 if self.TypeLen == 0 {
9804 return []byte("\"\""), nil
9805 } else {
9806 return []byte("\"" + self.GetOXMName() + "\""), nil
9807 }
9808}
9809
9810type OxmIdTunMetadata1Masked struct {
9811 *OxmId
9812}
9813
9814type IOxmIdTunMetadata1Masked interface {
9815 IOxmId
9816}
9817
9818func (self *OxmIdTunMetadata1Masked) Serialize(encoder *goloxi.Encoder) error {
9819 if err := self.OxmId.Serialize(encoder); err != nil {
9820 return err
9821 }
9822
9823 return nil
9824}
9825
9826func DecodeOxmIdTunMetadata1Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata1Masked, error) {
9827 _oxmidtunmetadata1masked := &OxmIdTunMetadata1Masked{OxmId: parent}
9828 return _oxmidtunmetadata1masked, nil
9829}
9830
9831func NewOxmIdTunMetadata1Masked() *OxmIdTunMetadata1Masked {
9832 obj := &OxmIdTunMetadata1Masked{
9833 OxmId: NewOxmId(87032),
9834 }
9835 return obj
9836}
9837func (self *OxmIdTunMetadata1Masked) GetOXMName() string {
9838 return "tun_metadata1_masked"
9839}
9840
9841func (self *OxmIdTunMetadata1Masked) MarshalJSON() ([]byte, error) {
9842 if self.TypeLen == 0 {
9843 return []byte("\"\""), nil
9844 } else {
9845 return []byte("\"" + self.GetOXMName() + "\""), nil
9846 }
9847}
9848
9849type OxmIdTunMetadata2 struct {
9850 *OxmId
9851}
9852
9853type IOxmIdTunMetadata2 interface {
9854 IOxmId
9855}
9856
9857func (self *OxmIdTunMetadata2) Serialize(encoder *goloxi.Encoder) error {
9858 if err := self.OxmId.Serialize(encoder); err != nil {
9859 return err
9860 }
9861
9862 return nil
9863}
9864
9865func DecodeOxmIdTunMetadata2(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata2, error) {
9866 _oxmidtunmetadata2 := &OxmIdTunMetadata2{OxmId: parent}
9867 return _oxmidtunmetadata2, nil
9868}
9869
9870func NewOxmIdTunMetadata2() *OxmIdTunMetadata2 {
9871 obj := &OxmIdTunMetadata2{
9872 OxmId: NewOxmId(87164),
9873 }
9874 return obj
9875}
9876func (self *OxmIdTunMetadata2) GetOXMName() string {
9877 return "tun_metadata2"
9878}
9879
9880func (self *OxmIdTunMetadata2) MarshalJSON() ([]byte, error) {
9881 if self.TypeLen == 0 {
9882 return []byte("\"\""), nil
9883 } else {
9884 return []byte("\"" + self.GetOXMName() + "\""), nil
9885 }
9886}
9887
9888type OxmIdTunMetadata20 struct {
9889 *OxmId
9890}
9891
9892type IOxmIdTunMetadata20 interface {
9893 IOxmId
9894}
9895
9896func (self *OxmIdTunMetadata20) Serialize(encoder *goloxi.Encoder) error {
9897 if err := self.OxmId.Serialize(encoder); err != nil {
9898 return err
9899 }
9900
9901 return nil
9902}
9903
9904func DecodeOxmIdTunMetadata20(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata20, error) {
9905 _oxmidtunmetadata20 := &OxmIdTunMetadata20{OxmId: parent}
9906 return _oxmidtunmetadata20, nil
9907}
9908
9909func NewOxmIdTunMetadata20() *OxmIdTunMetadata20 {
9910 obj := &OxmIdTunMetadata20{
9911 OxmId: NewOxmId(96380),
9912 }
9913 return obj
9914}
9915func (self *OxmIdTunMetadata20) GetOXMName() string {
9916 return "tun_metadata20"
9917}
9918
9919func (self *OxmIdTunMetadata20) MarshalJSON() ([]byte, error) {
9920 if self.TypeLen == 0 {
9921 return []byte("\"\""), nil
9922 } else {
9923 return []byte("\"" + self.GetOXMName() + "\""), nil
9924 }
9925}
9926
9927type OxmIdTunMetadata20Masked struct {
9928 *OxmId
9929}
9930
9931type IOxmIdTunMetadata20Masked interface {
9932 IOxmId
9933}
9934
9935func (self *OxmIdTunMetadata20Masked) Serialize(encoder *goloxi.Encoder) error {
9936 if err := self.OxmId.Serialize(encoder); err != nil {
9937 return err
9938 }
9939
9940 return nil
9941}
9942
9943func DecodeOxmIdTunMetadata20Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata20Masked, error) {
9944 _oxmidtunmetadata20masked := &OxmIdTunMetadata20Masked{OxmId: parent}
9945 return _oxmidtunmetadata20masked, nil
9946}
9947
9948func NewOxmIdTunMetadata20Masked() *OxmIdTunMetadata20Masked {
9949 obj := &OxmIdTunMetadata20Masked{
9950 OxmId: NewOxmId(96760),
9951 }
9952 return obj
9953}
9954func (self *OxmIdTunMetadata20Masked) GetOXMName() string {
9955 return "tun_metadata20_masked"
9956}
9957
9958func (self *OxmIdTunMetadata20Masked) MarshalJSON() ([]byte, error) {
9959 if self.TypeLen == 0 {
9960 return []byte("\"\""), nil
9961 } else {
9962 return []byte("\"" + self.GetOXMName() + "\""), nil
9963 }
9964}
9965
9966type OxmIdTunMetadata21 struct {
9967 *OxmId
9968}
9969
9970type IOxmIdTunMetadata21 interface {
9971 IOxmId
9972}
9973
9974func (self *OxmIdTunMetadata21) Serialize(encoder *goloxi.Encoder) error {
9975 if err := self.OxmId.Serialize(encoder); err != nil {
9976 return err
9977 }
9978
9979 return nil
9980}
9981
9982func DecodeOxmIdTunMetadata21(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata21, error) {
9983 _oxmidtunmetadata21 := &OxmIdTunMetadata21{OxmId: parent}
9984 return _oxmidtunmetadata21, nil
9985}
9986
9987func NewOxmIdTunMetadata21() *OxmIdTunMetadata21 {
9988 obj := &OxmIdTunMetadata21{
9989 OxmId: NewOxmId(96892),
9990 }
9991 return obj
9992}
9993func (self *OxmIdTunMetadata21) GetOXMName() string {
9994 return "tun_metadata21"
9995}
9996
9997func (self *OxmIdTunMetadata21) MarshalJSON() ([]byte, error) {
9998 if self.TypeLen == 0 {
9999 return []byte("\"\""), nil
10000 } else {
10001 return []byte("\"" + self.GetOXMName() + "\""), nil
10002 }
10003}
10004
10005type OxmIdTunMetadata21Masked struct {
10006 *OxmId
10007}
10008
10009type IOxmIdTunMetadata21Masked interface {
10010 IOxmId
10011}
10012
10013func (self *OxmIdTunMetadata21Masked) Serialize(encoder *goloxi.Encoder) error {
10014 if err := self.OxmId.Serialize(encoder); err != nil {
10015 return err
10016 }
10017
10018 return nil
10019}
10020
10021func DecodeOxmIdTunMetadata21Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata21Masked, error) {
10022 _oxmidtunmetadata21masked := &OxmIdTunMetadata21Masked{OxmId: parent}
10023 return _oxmidtunmetadata21masked, nil
10024}
10025
10026func NewOxmIdTunMetadata21Masked() *OxmIdTunMetadata21Masked {
10027 obj := &OxmIdTunMetadata21Masked{
10028 OxmId: NewOxmId(97272),
10029 }
10030 return obj
10031}
10032func (self *OxmIdTunMetadata21Masked) GetOXMName() string {
10033 return "tun_metadata21_masked"
10034}
10035
10036func (self *OxmIdTunMetadata21Masked) MarshalJSON() ([]byte, error) {
10037 if self.TypeLen == 0 {
10038 return []byte("\"\""), nil
10039 } else {
10040 return []byte("\"" + self.GetOXMName() + "\""), nil
10041 }
10042}
10043
10044type OxmIdTunMetadata22 struct {
10045 *OxmId
10046}
10047
10048type IOxmIdTunMetadata22 interface {
10049 IOxmId
10050}
10051
10052func (self *OxmIdTunMetadata22) Serialize(encoder *goloxi.Encoder) error {
10053 if err := self.OxmId.Serialize(encoder); err != nil {
10054 return err
10055 }
10056
10057 return nil
10058}
10059
10060func DecodeOxmIdTunMetadata22(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata22, error) {
10061 _oxmidtunmetadata22 := &OxmIdTunMetadata22{OxmId: parent}
10062 return _oxmidtunmetadata22, nil
10063}
10064
10065func NewOxmIdTunMetadata22() *OxmIdTunMetadata22 {
10066 obj := &OxmIdTunMetadata22{
10067 OxmId: NewOxmId(97404),
10068 }
10069 return obj
10070}
10071func (self *OxmIdTunMetadata22) GetOXMName() string {
10072 return "tun_metadata22"
10073}
10074
10075func (self *OxmIdTunMetadata22) MarshalJSON() ([]byte, error) {
10076 if self.TypeLen == 0 {
10077 return []byte("\"\""), nil
10078 } else {
10079 return []byte("\"" + self.GetOXMName() + "\""), nil
10080 }
10081}
10082
10083type OxmIdTunMetadata22Masked struct {
10084 *OxmId
10085}
10086
10087type IOxmIdTunMetadata22Masked interface {
10088 IOxmId
10089}
10090
10091func (self *OxmIdTunMetadata22Masked) Serialize(encoder *goloxi.Encoder) error {
10092 if err := self.OxmId.Serialize(encoder); err != nil {
10093 return err
10094 }
10095
10096 return nil
10097}
10098
10099func DecodeOxmIdTunMetadata22Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata22Masked, error) {
10100 _oxmidtunmetadata22masked := &OxmIdTunMetadata22Masked{OxmId: parent}
10101 return _oxmidtunmetadata22masked, nil
10102}
10103
10104func NewOxmIdTunMetadata22Masked() *OxmIdTunMetadata22Masked {
10105 obj := &OxmIdTunMetadata22Masked{
10106 OxmId: NewOxmId(97784),
10107 }
10108 return obj
10109}
10110func (self *OxmIdTunMetadata22Masked) GetOXMName() string {
10111 return "tun_metadata22_masked"
10112}
10113
10114func (self *OxmIdTunMetadata22Masked) MarshalJSON() ([]byte, error) {
10115 if self.TypeLen == 0 {
10116 return []byte("\"\""), nil
10117 } else {
10118 return []byte("\"" + self.GetOXMName() + "\""), nil
10119 }
10120}
10121
10122type OxmIdTunMetadata23 struct {
10123 *OxmId
10124}
10125
10126type IOxmIdTunMetadata23 interface {
10127 IOxmId
10128}
10129
10130func (self *OxmIdTunMetadata23) Serialize(encoder *goloxi.Encoder) error {
10131 if err := self.OxmId.Serialize(encoder); err != nil {
10132 return err
10133 }
10134
10135 return nil
10136}
10137
10138func DecodeOxmIdTunMetadata23(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata23, error) {
10139 _oxmidtunmetadata23 := &OxmIdTunMetadata23{OxmId: parent}
10140 return _oxmidtunmetadata23, nil
10141}
10142
10143func NewOxmIdTunMetadata23() *OxmIdTunMetadata23 {
10144 obj := &OxmIdTunMetadata23{
10145 OxmId: NewOxmId(97916),
10146 }
10147 return obj
10148}
10149func (self *OxmIdTunMetadata23) GetOXMName() string {
10150 return "tun_metadata23"
10151}
10152
10153func (self *OxmIdTunMetadata23) MarshalJSON() ([]byte, error) {
10154 if self.TypeLen == 0 {
10155 return []byte("\"\""), nil
10156 } else {
10157 return []byte("\"" + self.GetOXMName() + "\""), nil
10158 }
10159}
10160
10161type OxmIdTunMetadata23Masked struct {
10162 *OxmId
10163}
10164
10165type IOxmIdTunMetadata23Masked interface {
10166 IOxmId
10167}
10168
10169func (self *OxmIdTunMetadata23Masked) Serialize(encoder *goloxi.Encoder) error {
10170 if err := self.OxmId.Serialize(encoder); err != nil {
10171 return err
10172 }
10173
10174 return nil
10175}
10176
10177func DecodeOxmIdTunMetadata23Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata23Masked, error) {
10178 _oxmidtunmetadata23masked := &OxmIdTunMetadata23Masked{OxmId: parent}
10179 return _oxmidtunmetadata23masked, nil
10180}
10181
10182func NewOxmIdTunMetadata23Masked() *OxmIdTunMetadata23Masked {
10183 obj := &OxmIdTunMetadata23Masked{
10184 OxmId: NewOxmId(98296),
10185 }
10186 return obj
10187}
10188func (self *OxmIdTunMetadata23Masked) GetOXMName() string {
10189 return "tun_metadata23_masked"
10190}
10191
10192func (self *OxmIdTunMetadata23Masked) MarshalJSON() ([]byte, error) {
10193 if self.TypeLen == 0 {
10194 return []byte("\"\""), nil
10195 } else {
10196 return []byte("\"" + self.GetOXMName() + "\""), nil
10197 }
10198}
10199
10200type OxmIdTunMetadata24 struct {
10201 *OxmId
10202}
10203
10204type IOxmIdTunMetadata24 interface {
10205 IOxmId
10206}
10207
10208func (self *OxmIdTunMetadata24) Serialize(encoder *goloxi.Encoder) error {
10209 if err := self.OxmId.Serialize(encoder); err != nil {
10210 return err
10211 }
10212
10213 return nil
10214}
10215
10216func DecodeOxmIdTunMetadata24(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata24, error) {
10217 _oxmidtunmetadata24 := &OxmIdTunMetadata24{OxmId: parent}
10218 return _oxmidtunmetadata24, nil
10219}
10220
10221func NewOxmIdTunMetadata24() *OxmIdTunMetadata24 {
10222 obj := &OxmIdTunMetadata24{
10223 OxmId: NewOxmId(98428),
10224 }
10225 return obj
10226}
10227func (self *OxmIdTunMetadata24) GetOXMName() string {
10228 return "tun_metadata24"
10229}
10230
10231func (self *OxmIdTunMetadata24) MarshalJSON() ([]byte, error) {
10232 if self.TypeLen == 0 {
10233 return []byte("\"\""), nil
10234 } else {
10235 return []byte("\"" + self.GetOXMName() + "\""), nil
10236 }
10237}
10238
10239type OxmIdTunMetadata24Masked struct {
10240 *OxmId
10241}
10242
10243type IOxmIdTunMetadata24Masked interface {
10244 IOxmId
10245}
10246
10247func (self *OxmIdTunMetadata24Masked) Serialize(encoder *goloxi.Encoder) error {
10248 if err := self.OxmId.Serialize(encoder); err != nil {
10249 return err
10250 }
10251
10252 return nil
10253}
10254
10255func DecodeOxmIdTunMetadata24Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata24Masked, error) {
10256 _oxmidtunmetadata24masked := &OxmIdTunMetadata24Masked{OxmId: parent}
10257 return _oxmidtunmetadata24masked, nil
10258}
10259
10260func NewOxmIdTunMetadata24Masked() *OxmIdTunMetadata24Masked {
10261 obj := &OxmIdTunMetadata24Masked{
10262 OxmId: NewOxmId(98808),
10263 }
10264 return obj
10265}
10266func (self *OxmIdTunMetadata24Masked) GetOXMName() string {
10267 return "tun_metadata24_masked"
10268}
10269
10270func (self *OxmIdTunMetadata24Masked) MarshalJSON() ([]byte, error) {
10271 if self.TypeLen == 0 {
10272 return []byte("\"\""), nil
10273 } else {
10274 return []byte("\"" + self.GetOXMName() + "\""), nil
10275 }
10276}
10277
10278type OxmIdTunMetadata25 struct {
10279 *OxmId
10280}
10281
10282type IOxmIdTunMetadata25 interface {
10283 IOxmId
10284}
10285
10286func (self *OxmIdTunMetadata25) Serialize(encoder *goloxi.Encoder) error {
10287 if err := self.OxmId.Serialize(encoder); err != nil {
10288 return err
10289 }
10290
10291 return nil
10292}
10293
10294func DecodeOxmIdTunMetadata25(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata25, error) {
10295 _oxmidtunmetadata25 := &OxmIdTunMetadata25{OxmId: parent}
10296 return _oxmidtunmetadata25, nil
10297}
10298
10299func NewOxmIdTunMetadata25() *OxmIdTunMetadata25 {
10300 obj := &OxmIdTunMetadata25{
10301 OxmId: NewOxmId(98940),
10302 }
10303 return obj
10304}
10305func (self *OxmIdTunMetadata25) GetOXMName() string {
10306 return "tun_metadata25"
10307}
10308
10309func (self *OxmIdTunMetadata25) MarshalJSON() ([]byte, error) {
10310 if self.TypeLen == 0 {
10311 return []byte("\"\""), nil
10312 } else {
10313 return []byte("\"" + self.GetOXMName() + "\""), nil
10314 }
10315}
10316
10317type OxmIdTunMetadata25Masked struct {
10318 *OxmId
10319}
10320
10321type IOxmIdTunMetadata25Masked interface {
10322 IOxmId
10323}
10324
10325func (self *OxmIdTunMetadata25Masked) Serialize(encoder *goloxi.Encoder) error {
10326 if err := self.OxmId.Serialize(encoder); err != nil {
10327 return err
10328 }
10329
10330 return nil
10331}
10332
10333func DecodeOxmIdTunMetadata25Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata25Masked, error) {
10334 _oxmidtunmetadata25masked := &OxmIdTunMetadata25Masked{OxmId: parent}
10335 return _oxmidtunmetadata25masked, nil
10336}
10337
10338func NewOxmIdTunMetadata25Masked() *OxmIdTunMetadata25Masked {
10339 obj := &OxmIdTunMetadata25Masked{
10340 OxmId: NewOxmId(99320),
10341 }
10342 return obj
10343}
10344func (self *OxmIdTunMetadata25Masked) GetOXMName() string {
10345 return "tun_metadata25_masked"
10346}
10347
10348func (self *OxmIdTunMetadata25Masked) MarshalJSON() ([]byte, error) {
10349 if self.TypeLen == 0 {
10350 return []byte("\"\""), nil
10351 } else {
10352 return []byte("\"" + self.GetOXMName() + "\""), nil
10353 }
10354}
10355
10356type OxmIdTunMetadata26 struct {
10357 *OxmId
10358}
10359
10360type IOxmIdTunMetadata26 interface {
10361 IOxmId
10362}
10363
10364func (self *OxmIdTunMetadata26) Serialize(encoder *goloxi.Encoder) error {
10365 if err := self.OxmId.Serialize(encoder); err != nil {
10366 return err
10367 }
10368
10369 return nil
10370}
10371
10372func DecodeOxmIdTunMetadata26(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata26, error) {
10373 _oxmidtunmetadata26 := &OxmIdTunMetadata26{OxmId: parent}
10374 return _oxmidtunmetadata26, nil
10375}
10376
10377func NewOxmIdTunMetadata26() *OxmIdTunMetadata26 {
10378 obj := &OxmIdTunMetadata26{
10379 OxmId: NewOxmId(99452),
10380 }
10381 return obj
10382}
10383func (self *OxmIdTunMetadata26) GetOXMName() string {
10384 return "tun_metadata26"
10385}
10386
10387func (self *OxmIdTunMetadata26) MarshalJSON() ([]byte, error) {
10388 if self.TypeLen == 0 {
10389 return []byte("\"\""), nil
10390 } else {
10391 return []byte("\"" + self.GetOXMName() + "\""), nil
10392 }
10393}
10394
10395type OxmIdTunMetadata26Masked struct {
10396 *OxmId
10397}
10398
10399type IOxmIdTunMetadata26Masked interface {
10400 IOxmId
10401}
10402
10403func (self *OxmIdTunMetadata26Masked) Serialize(encoder *goloxi.Encoder) error {
10404 if err := self.OxmId.Serialize(encoder); err != nil {
10405 return err
10406 }
10407
10408 return nil
10409}
10410
10411func DecodeOxmIdTunMetadata26Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata26Masked, error) {
10412 _oxmidtunmetadata26masked := &OxmIdTunMetadata26Masked{OxmId: parent}
10413 return _oxmidtunmetadata26masked, nil
10414}
10415
10416func NewOxmIdTunMetadata26Masked() *OxmIdTunMetadata26Masked {
10417 obj := &OxmIdTunMetadata26Masked{
10418 OxmId: NewOxmId(99832),
10419 }
10420 return obj
10421}
10422func (self *OxmIdTunMetadata26Masked) GetOXMName() string {
10423 return "tun_metadata26_masked"
10424}
10425
10426func (self *OxmIdTunMetadata26Masked) MarshalJSON() ([]byte, error) {
10427 if self.TypeLen == 0 {
10428 return []byte("\"\""), nil
10429 } else {
10430 return []byte("\"" + self.GetOXMName() + "\""), nil
10431 }
10432}
10433
10434type OxmIdTunMetadata27 struct {
10435 *OxmId
10436}
10437
10438type IOxmIdTunMetadata27 interface {
10439 IOxmId
10440}
10441
10442func (self *OxmIdTunMetadata27) Serialize(encoder *goloxi.Encoder) error {
10443 if err := self.OxmId.Serialize(encoder); err != nil {
10444 return err
10445 }
10446
10447 return nil
10448}
10449
10450func DecodeOxmIdTunMetadata27(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata27, error) {
10451 _oxmidtunmetadata27 := &OxmIdTunMetadata27{OxmId: parent}
10452 return _oxmidtunmetadata27, nil
10453}
10454
10455func NewOxmIdTunMetadata27() *OxmIdTunMetadata27 {
10456 obj := &OxmIdTunMetadata27{
10457 OxmId: NewOxmId(99964),
10458 }
10459 return obj
10460}
10461func (self *OxmIdTunMetadata27) GetOXMName() string {
10462 return "tun_metadata27"
10463}
10464
10465func (self *OxmIdTunMetadata27) MarshalJSON() ([]byte, error) {
10466 if self.TypeLen == 0 {
10467 return []byte("\"\""), nil
10468 } else {
10469 return []byte("\"" + self.GetOXMName() + "\""), nil
10470 }
10471}
10472
10473type OxmIdTunMetadata27Masked struct {
10474 *OxmId
10475}
10476
10477type IOxmIdTunMetadata27Masked interface {
10478 IOxmId
10479}
10480
10481func (self *OxmIdTunMetadata27Masked) Serialize(encoder *goloxi.Encoder) error {
10482 if err := self.OxmId.Serialize(encoder); err != nil {
10483 return err
10484 }
10485
10486 return nil
10487}
10488
10489func DecodeOxmIdTunMetadata27Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata27Masked, error) {
10490 _oxmidtunmetadata27masked := &OxmIdTunMetadata27Masked{OxmId: parent}
10491 return _oxmidtunmetadata27masked, nil
10492}
10493
10494func NewOxmIdTunMetadata27Masked() *OxmIdTunMetadata27Masked {
10495 obj := &OxmIdTunMetadata27Masked{
10496 OxmId: NewOxmId(100344),
10497 }
10498 return obj
10499}
10500func (self *OxmIdTunMetadata27Masked) GetOXMName() string {
10501 return "tun_metadata27_masked"
10502}
10503
10504func (self *OxmIdTunMetadata27Masked) MarshalJSON() ([]byte, error) {
10505 if self.TypeLen == 0 {
10506 return []byte("\"\""), nil
10507 } else {
10508 return []byte("\"" + self.GetOXMName() + "\""), nil
10509 }
10510}
10511
10512type OxmIdTunMetadata28 struct {
10513 *OxmId
10514}
10515
10516type IOxmIdTunMetadata28 interface {
10517 IOxmId
10518}
10519
10520func (self *OxmIdTunMetadata28) Serialize(encoder *goloxi.Encoder) error {
10521 if err := self.OxmId.Serialize(encoder); err != nil {
10522 return err
10523 }
10524
10525 return nil
10526}
10527
10528func DecodeOxmIdTunMetadata28(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata28, error) {
10529 _oxmidtunmetadata28 := &OxmIdTunMetadata28{OxmId: parent}
10530 return _oxmidtunmetadata28, nil
10531}
10532
10533func NewOxmIdTunMetadata28() *OxmIdTunMetadata28 {
10534 obj := &OxmIdTunMetadata28{
10535 OxmId: NewOxmId(100476),
10536 }
10537 return obj
10538}
10539func (self *OxmIdTunMetadata28) GetOXMName() string {
10540 return "tun_metadata28"
10541}
10542
10543func (self *OxmIdTunMetadata28) MarshalJSON() ([]byte, error) {
10544 if self.TypeLen == 0 {
10545 return []byte("\"\""), nil
10546 } else {
10547 return []byte("\"" + self.GetOXMName() + "\""), nil
10548 }
10549}
10550
10551type OxmIdTunMetadata28Masked struct {
10552 *OxmId
10553}
10554
10555type IOxmIdTunMetadata28Masked interface {
10556 IOxmId
10557}
10558
10559func (self *OxmIdTunMetadata28Masked) Serialize(encoder *goloxi.Encoder) error {
10560 if err := self.OxmId.Serialize(encoder); err != nil {
10561 return err
10562 }
10563
10564 return nil
10565}
10566
10567func DecodeOxmIdTunMetadata28Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata28Masked, error) {
10568 _oxmidtunmetadata28masked := &OxmIdTunMetadata28Masked{OxmId: parent}
10569 return _oxmidtunmetadata28masked, nil
10570}
10571
10572func NewOxmIdTunMetadata28Masked() *OxmIdTunMetadata28Masked {
10573 obj := &OxmIdTunMetadata28Masked{
10574 OxmId: NewOxmId(100856),
10575 }
10576 return obj
10577}
10578func (self *OxmIdTunMetadata28Masked) GetOXMName() string {
10579 return "tun_metadata28_masked"
10580}
10581
10582func (self *OxmIdTunMetadata28Masked) MarshalJSON() ([]byte, error) {
10583 if self.TypeLen == 0 {
10584 return []byte("\"\""), nil
10585 } else {
10586 return []byte("\"" + self.GetOXMName() + "\""), nil
10587 }
10588}
10589
10590type OxmIdTunMetadata29 struct {
10591 *OxmId
10592}
10593
10594type IOxmIdTunMetadata29 interface {
10595 IOxmId
10596}
10597
10598func (self *OxmIdTunMetadata29) Serialize(encoder *goloxi.Encoder) error {
10599 if err := self.OxmId.Serialize(encoder); err != nil {
10600 return err
10601 }
10602
10603 return nil
10604}
10605
10606func DecodeOxmIdTunMetadata29(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata29, error) {
10607 _oxmidtunmetadata29 := &OxmIdTunMetadata29{OxmId: parent}
10608 return _oxmidtunmetadata29, nil
10609}
10610
10611func NewOxmIdTunMetadata29() *OxmIdTunMetadata29 {
10612 obj := &OxmIdTunMetadata29{
10613 OxmId: NewOxmId(100988),
10614 }
10615 return obj
10616}
10617func (self *OxmIdTunMetadata29) GetOXMName() string {
10618 return "tun_metadata29"
10619}
10620
10621func (self *OxmIdTunMetadata29) MarshalJSON() ([]byte, error) {
10622 if self.TypeLen == 0 {
10623 return []byte("\"\""), nil
10624 } else {
10625 return []byte("\"" + self.GetOXMName() + "\""), nil
10626 }
10627}
10628
10629type OxmIdTunMetadata29Masked struct {
10630 *OxmId
10631}
10632
10633type IOxmIdTunMetadata29Masked interface {
10634 IOxmId
10635}
10636
10637func (self *OxmIdTunMetadata29Masked) Serialize(encoder *goloxi.Encoder) error {
10638 if err := self.OxmId.Serialize(encoder); err != nil {
10639 return err
10640 }
10641
10642 return nil
10643}
10644
10645func DecodeOxmIdTunMetadata29Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata29Masked, error) {
10646 _oxmidtunmetadata29masked := &OxmIdTunMetadata29Masked{OxmId: parent}
10647 return _oxmidtunmetadata29masked, nil
10648}
10649
10650func NewOxmIdTunMetadata29Masked() *OxmIdTunMetadata29Masked {
10651 obj := &OxmIdTunMetadata29Masked{
10652 OxmId: NewOxmId(101368),
10653 }
10654 return obj
10655}
10656func (self *OxmIdTunMetadata29Masked) GetOXMName() string {
10657 return "tun_metadata29_masked"
10658}
10659
10660func (self *OxmIdTunMetadata29Masked) MarshalJSON() ([]byte, error) {
10661 if self.TypeLen == 0 {
10662 return []byte("\"\""), nil
10663 } else {
10664 return []byte("\"" + self.GetOXMName() + "\""), nil
10665 }
10666}
10667
10668type OxmIdTunMetadata2Masked struct {
10669 *OxmId
10670}
10671
10672type IOxmIdTunMetadata2Masked interface {
10673 IOxmId
10674}
10675
10676func (self *OxmIdTunMetadata2Masked) Serialize(encoder *goloxi.Encoder) error {
10677 if err := self.OxmId.Serialize(encoder); err != nil {
10678 return err
10679 }
10680
10681 return nil
10682}
10683
10684func DecodeOxmIdTunMetadata2Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata2Masked, error) {
10685 _oxmidtunmetadata2masked := &OxmIdTunMetadata2Masked{OxmId: parent}
10686 return _oxmidtunmetadata2masked, nil
10687}
10688
10689func NewOxmIdTunMetadata2Masked() *OxmIdTunMetadata2Masked {
10690 obj := &OxmIdTunMetadata2Masked{
10691 OxmId: NewOxmId(87544),
10692 }
10693 return obj
10694}
10695func (self *OxmIdTunMetadata2Masked) GetOXMName() string {
10696 return "tun_metadata2_masked"
10697}
10698
10699func (self *OxmIdTunMetadata2Masked) MarshalJSON() ([]byte, error) {
10700 if self.TypeLen == 0 {
10701 return []byte("\"\""), nil
10702 } else {
10703 return []byte("\"" + self.GetOXMName() + "\""), nil
10704 }
10705}
10706
10707type OxmIdTunMetadata3 struct {
10708 *OxmId
10709}
10710
10711type IOxmIdTunMetadata3 interface {
10712 IOxmId
10713}
10714
10715func (self *OxmIdTunMetadata3) Serialize(encoder *goloxi.Encoder) error {
10716 if err := self.OxmId.Serialize(encoder); err != nil {
10717 return err
10718 }
10719
10720 return nil
10721}
10722
10723func DecodeOxmIdTunMetadata3(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata3, error) {
10724 _oxmidtunmetadata3 := &OxmIdTunMetadata3{OxmId: parent}
10725 return _oxmidtunmetadata3, nil
10726}
10727
10728func NewOxmIdTunMetadata3() *OxmIdTunMetadata3 {
10729 obj := &OxmIdTunMetadata3{
10730 OxmId: NewOxmId(87676),
10731 }
10732 return obj
10733}
10734func (self *OxmIdTunMetadata3) GetOXMName() string {
10735 return "tun_metadata3"
10736}
10737
10738func (self *OxmIdTunMetadata3) MarshalJSON() ([]byte, error) {
10739 if self.TypeLen == 0 {
10740 return []byte("\"\""), nil
10741 } else {
10742 return []byte("\"" + self.GetOXMName() + "\""), nil
10743 }
10744}
10745
10746type OxmIdTunMetadata30 struct {
10747 *OxmId
10748}
10749
10750type IOxmIdTunMetadata30 interface {
10751 IOxmId
10752}
10753
10754func (self *OxmIdTunMetadata30) Serialize(encoder *goloxi.Encoder) error {
10755 if err := self.OxmId.Serialize(encoder); err != nil {
10756 return err
10757 }
10758
10759 return nil
10760}
10761
10762func DecodeOxmIdTunMetadata30(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata30, error) {
10763 _oxmidtunmetadata30 := &OxmIdTunMetadata30{OxmId: parent}
10764 return _oxmidtunmetadata30, nil
10765}
10766
10767func NewOxmIdTunMetadata30() *OxmIdTunMetadata30 {
10768 obj := &OxmIdTunMetadata30{
10769 OxmId: NewOxmId(101500),
10770 }
10771 return obj
10772}
10773func (self *OxmIdTunMetadata30) GetOXMName() string {
10774 return "tun_metadata30"
10775}
10776
10777func (self *OxmIdTunMetadata30) MarshalJSON() ([]byte, error) {
10778 if self.TypeLen == 0 {
10779 return []byte("\"\""), nil
10780 } else {
10781 return []byte("\"" + self.GetOXMName() + "\""), nil
10782 }
10783}
10784
10785type OxmIdTunMetadata30Masked struct {
10786 *OxmId
10787}
10788
10789type IOxmIdTunMetadata30Masked interface {
10790 IOxmId
10791}
10792
10793func (self *OxmIdTunMetadata30Masked) Serialize(encoder *goloxi.Encoder) error {
10794 if err := self.OxmId.Serialize(encoder); err != nil {
10795 return err
10796 }
10797
10798 return nil
10799}
10800
10801func DecodeOxmIdTunMetadata30Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata30Masked, error) {
10802 _oxmidtunmetadata30masked := &OxmIdTunMetadata30Masked{OxmId: parent}
10803 return _oxmidtunmetadata30masked, nil
10804}
10805
10806func NewOxmIdTunMetadata30Masked() *OxmIdTunMetadata30Masked {
10807 obj := &OxmIdTunMetadata30Masked{
10808 OxmId: NewOxmId(101880),
10809 }
10810 return obj
10811}
10812func (self *OxmIdTunMetadata30Masked) GetOXMName() string {
10813 return "tun_metadata30_masked"
10814}
10815
10816func (self *OxmIdTunMetadata30Masked) MarshalJSON() ([]byte, error) {
10817 if self.TypeLen == 0 {
10818 return []byte("\"\""), nil
10819 } else {
10820 return []byte("\"" + self.GetOXMName() + "\""), nil
10821 }
10822}
10823
10824type OxmIdTunMetadata31 struct {
10825 *OxmId
10826}
10827
10828type IOxmIdTunMetadata31 interface {
10829 IOxmId
10830}
10831
10832func (self *OxmIdTunMetadata31) Serialize(encoder *goloxi.Encoder) error {
10833 if err := self.OxmId.Serialize(encoder); err != nil {
10834 return err
10835 }
10836
10837 return nil
10838}
10839
10840func DecodeOxmIdTunMetadata31(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata31, error) {
10841 _oxmidtunmetadata31 := &OxmIdTunMetadata31{OxmId: parent}
10842 return _oxmidtunmetadata31, nil
10843}
10844
10845func NewOxmIdTunMetadata31() *OxmIdTunMetadata31 {
10846 obj := &OxmIdTunMetadata31{
10847 OxmId: NewOxmId(102012),
10848 }
10849 return obj
10850}
10851func (self *OxmIdTunMetadata31) GetOXMName() string {
10852 return "tun_metadata31"
10853}
10854
10855func (self *OxmIdTunMetadata31) MarshalJSON() ([]byte, error) {
10856 if self.TypeLen == 0 {
10857 return []byte("\"\""), nil
10858 } else {
10859 return []byte("\"" + self.GetOXMName() + "\""), nil
10860 }
10861}
10862
10863type OxmIdTunMetadata31Masked struct {
10864 *OxmId
10865}
10866
10867type IOxmIdTunMetadata31Masked interface {
10868 IOxmId
10869}
10870
10871func (self *OxmIdTunMetadata31Masked) Serialize(encoder *goloxi.Encoder) error {
10872 if err := self.OxmId.Serialize(encoder); err != nil {
10873 return err
10874 }
10875
10876 return nil
10877}
10878
10879func DecodeOxmIdTunMetadata31Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata31Masked, error) {
10880 _oxmidtunmetadata31masked := &OxmIdTunMetadata31Masked{OxmId: parent}
10881 return _oxmidtunmetadata31masked, nil
10882}
10883
10884func NewOxmIdTunMetadata31Masked() *OxmIdTunMetadata31Masked {
10885 obj := &OxmIdTunMetadata31Masked{
10886 OxmId: NewOxmId(102392),
10887 }
10888 return obj
10889}
10890func (self *OxmIdTunMetadata31Masked) GetOXMName() string {
10891 return "tun_metadata31_masked"
10892}
10893
10894func (self *OxmIdTunMetadata31Masked) MarshalJSON() ([]byte, error) {
10895 if self.TypeLen == 0 {
10896 return []byte("\"\""), nil
10897 } else {
10898 return []byte("\"" + self.GetOXMName() + "\""), nil
10899 }
10900}
10901
10902type OxmIdTunMetadata32 struct {
10903 *OxmId
10904}
10905
10906type IOxmIdTunMetadata32 interface {
10907 IOxmId
10908}
10909
10910func (self *OxmIdTunMetadata32) Serialize(encoder *goloxi.Encoder) error {
10911 if err := self.OxmId.Serialize(encoder); err != nil {
10912 return err
10913 }
10914
10915 return nil
10916}
10917
10918func DecodeOxmIdTunMetadata32(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata32, error) {
10919 _oxmidtunmetadata32 := &OxmIdTunMetadata32{OxmId: parent}
10920 return _oxmidtunmetadata32, nil
10921}
10922
10923func NewOxmIdTunMetadata32() *OxmIdTunMetadata32 {
10924 obj := &OxmIdTunMetadata32{
10925 OxmId: NewOxmId(102524),
10926 }
10927 return obj
10928}
10929func (self *OxmIdTunMetadata32) GetOXMName() string {
10930 return "tun_metadata32"
10931}
10932
10933func (self *OxmIdTunMetadata32) MarshalJSON() ([]byte, error) {
10934 if self.TypeLen == 0 {
10935 return []byte("\"\""), nil
10936 } else {
10937 return []byte("\"" + self.GetOXMName() + "\""), nil
10938 }
10939}
10940
10941type OxmIdTunMetadata32Masked struct {
10942 *OxmId
10943}
10944
10945type IOxmIdTunMetadata32Masked interface {
10946 IOxmId
10947}
10948
10949func (self *OxmIdTunMetadata32Masked) Serialize(encoder *goloxi.Encoder) error {
10950 if err := self.OxmId.Serialize(encoder); err != nil {
10951 return err
10952 }
10953
10954 return nil
10955}
10956
10957func DecodeOxmIdTunMetadata32Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata32Masked, error) {
10958 _oxmidtunmetadata32masked := &OxmIdTunMetadata32Masked{OxmId: parent}
10959 return _oxmidtunmetadata32masked, nil
10960}
10961
10962func NewOxmIdTunMetadata32Masked() *OxmIdTunMetadata32Masked {
10963 obj := &OxmIdTunMetadata32Masked{
10964 OxmId: NewOxmId(102904),
10965 }
10966 return obj
10967}
10968func (self *OxmIdTunMetadata32Masked) GetOXMName() string {
10969 return "tun_metadata32_masked"
10970}
10971
10972func (self *OxmIdTunMetadata32Masked) MarshalJSON() ([]byte, error) {
10973 if self.TypeLen == 0 {
10974 return []byte("\"\""), nil
10975 } else {
10976 return []byte("\"" + self.GetOXMName() + "\""), nil
10977 }
10978}
10979
10980type OxmIdTunMetadata33 struct {
10981 *OxmId
10982}
10983
10984type IOxmIdTunMetadata33 interface {
10985 IOxmId
10986}
10987
10988func (self *OxmIdTunMetadata33) Serialize(encoder *goloxi.Encoder) error {
10989 if err := self.OxmId.Serialize(encoder); err != nil {
10990 return err
10991 }
10992
10993 return nil
10994}
10995
10996func DecodeOxmIdTunMetadata33(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata33, error) {
10997 _oxmidtunmetadata33 := &OxmIdTunMetadata33{OxmId: parent}
10998 return _oxmidtunmetadata33, nil
10999}
11000
11001func NewOxmIdTunMetadata33() *OxmIdTunMetadata33 {
11002 obj := &OxmIdTunMetadata33{
11003 OxmId: NewOxmId(103036),
11004 }
11005 return obj
11006}
11007func (self *OxmIdTunMetadata33) GetOXMName() string {
11008 return "tun_metadata33"
11009}
11010
11011func (self *OxmIdTunMetadata33) MarshalJSON() ([]byte, error) {
11012 if self.TypeLen == 0 {
11013 return []byte("\"\""), nil
11014 } else {
11015 return []byte("\"" + self.GetOXMName() + "\""), nil
11016 }
11017}
11018
11019type OxmIdTunMetadata33Masked struct {
11020 *OxmId
11021}
11022
11023type IOxmIdTunMetadata33Masked interface {
11024 IOxmId
11025}
11026
11027func (self *OxmIdTunMetadata33Masked) Serialize(encoder *goloxi.Encoder) error {
11028 if err := self.OxmId.Serialize(encoder); err != nil {
11029 return err
11030 }
11031
11032 return nil
11033}
11034
11035func DecodeOxmIdTunMetadata33Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata33Masked, error) {
11036 _oxmidtunmetadata33masked := &OxmIdTunMetadata33Masked{OxmId: parent}
11037 return _oxmidtunmetadata33masked, nil
11038}
11039
11040func NewOxmIdTunMetadata33Masked() *OxmIdTunMetadata33Masked {
11041 obj := &OxmIdTunMetadata33Masked{
11042 OxmId: NewOxmId(103416),
11043 }
11044 return obj
11045}
11046func (self *OxmIdTunMetadata33Masked) GetOXMName() string {
11047 return "tun_metadata33_masked"
11048}
11049
11050func (self *OxmIdTunMetadata33Masked) MarshalJSON() ([]byte, error) {
11051 if self.TypeLen == 0 {
11052 return []byte("\"\""), nil
11053 } else {
11054 return []byte("\"" + self.GetOXMName() + "\""), nil
11055 }
11056}
11057
11058type OxmIdTunMetadata34 struct {
11059 *OxmId
11060}
11061
11062type IOxmIdTunMetadata34 interface {
11063 IOxmId
11064}
11065
11066func (self *OxmIdTunMetadata34) Serialize(encoder *goloxi.Encoder) error {
11067 if err := self.OxmId.Serialize(encoder); err != nil {
11068 return err
11069 }
11070
11071 return nil
11072}
11073
11074func DecodeOxmIdTunMetadata34(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata34, error) {
11075 _oxmidtunmetadata34 := &OxmIdTunMetadata34{OxmId: parent}
11076 return _oxmidtunmetadata34, nil
11077}
11078
11079func NewOxmIdTunMetadata34() *OxmIdTunMetadata34 {
11080 obj := &OxmIdTunMetadata34{
11081 OxmId: NewOxmId(103548),
11082 }
11083 return obj
11084}
11085func (self *OxmIdTunMetadata34) GetOXMName() string {
11086 return "tun_metadata34"
11087}
11088
11089func (self *OxmIdTunMetadata34) MarshalJSON() ([]byte, error) {
11090 if self.TypeLen == 0 {
11091 return []byte("\"\""), nil
11092 } else {
11093 return []byte("\"" + self.GetOXMName() + "\""), nil
11094 }
11095}
11096
11097type OxmIdTunMetadata34Masked struct {
11098 *OxmId
11099}
11100
11101type IOxmIdTunMetadata34Masked interface {
11102 IOxmId
11103}
11104
11105func (self *OxmIdTunMetadata34Masked) Serialize(encoder *goloxi.Encoder) error {
11106 if err := self.OxmId.Serialize(encoder); err != nil {
11107 return err
11108 }
11109
11110 return nil
11111}
11112
11113func DecodeOxmIdTunMetadata34Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata34Masked, error) {
11114 _oxmidtunmetadata34masked := &OxmIdTunMetadata34Masked{OxmId: parent}
11115 return _oxmidtunmetadata34masked, nil
11116}
11117
11118func NewOxmIdTunMetadata34Masked() *OxmIdTunMetadata34Masked {
11119 obj := &OxmIdTunMetadata34Masked{
11120 OxmId: NewOxmId(103928),
11121 }
11122 return obj
11123}
11124func (self *OxmIdTunMetadata34Masked) GetOXMName() string {
11125 return "tun_metadata34_masked"
11126}
11127
11128func (self *OxmIdTunMetadata34Masked) MarshalJSON() ([]byte, error) {
11129 if self.TypeLen == 0 {
11130 return []byte("\"\""), nil
11131 } else {
11132 return []byte("\"" + self.GetOXMName() + "\""), nil
11133 }
11134}
11135
11136type OxmIdTunMetadata35 struct {
11137 *OxmId
11138}
11139
11140type IOxmIdTunMetadata35 interface {
11141 IOxmId
11142}
11143
11144func (self *OxmIdTunMetadata35) Serialize(encoder *goloxi.Encoder) error {
11145 if err := self.OxmId.Serialize(encoder); err != nil {
11146 return err
11147 }
11148
11149 return nil
11150}
11151
11152func DecodeOxmIdTunMetadata35(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata35, error) {
11153 _oxmidtunmetadata35 := &OxmIdTunMetadata35{OxmId: parent}
11154 return _oxmidtunmetadata35, nil
11155}
11156
11157func NewOxmIdTunMetadata35() *OxmIdTunMetadata35 {
11158 obj := &OxmIdTunMetadata35{
11159 OxmId: NewOxmId(104060),
11160 }
11161 return obj
11162}
11163func (self *OxmIdTunMetadata35) GetOXMName() string {
11164 return "tun_metadata35"
11165}
11166
11167func (self *OxmIdTunMetadata35) MarshalJSON() ([]byte, error) {
11168 if self.TypeLen == 0 {
11169 return []byte("\"\""), nil
11170 } else {
11171 return []byte("\"" + self.GetOXMName() + "\""), nil
11172 }
11173}
11174
11175type OxmIdTunMetadata35Masked struct {
11176 *OxmId
11177}
11178
11179type IOxmIdTunMetadata35Masked interface {
11180 IOxmId
11181}
11182
11183func (self *OxmIdTunMetadata35Masked) Serialize(encoder *goloxi.Encoder) error {
11184 if err := self.OxmId.Serialize(encoder); err != nil {
11185 return err
11186 }
11187
11188 return nil
11189}
11190
11191func DecodeOxmIdTunMetadata35Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata35Masked, error) {
11192 _oxmidtunmetadata35masked := &OxmIdTunMetadata35Masked{OxmId: parent}
11193 return _oxmidtunmetadata35masked, nil
11194}
11195
11196func NewOxmIdTunMetadata35Masked() *OxmIdTunMetadata35Masked {
11197 obj := &OxmIdTunMetadata35Masked{
11198 OxmId: NewOxmId(104440),
11199 }
11200 return obj
11201}
11202func (self *OxmIdTunMetadata35Masked) GetOXMName() string {
11203 return "tun_metadata35_masked"
11204}
11205
11206func (self *OxmIdTunMetadata35Masked) MarshalJSON() ([]byte, error) {
11207 if self.TypeLen == 0 {
11208 return []byte("\"\""), nil
11209 } else {
11210 return []byte("\"" + self.GetOXMName() + "\""), nil
11211 }
11212}
11213
11214type OxmIdTunMetadata36 struct {
11215 *OxmId
11216}
11217
11218type IOxmIdTunMetadata36 interface {
11219 IOxmId
11220}
11221
11222func (self *OxmIdTunMetadata36) Serialize(encoder *goloxi.Encoder) error {
11223 if err := self.OxmId.Serialize(encoder); err != nil {
11224 return err
11225 }
11226
11227 return nil
11228}
11229
11230func DecodeOxmIdTunMetadata36(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata36, error) {
11231 _oxmidtunmetadata36 := &OxmIdTunMetadata36{OxmId: parent}
11232 return _oxmidtunmetadata36, nil
11233}
11234
11235func NewOxmIdTunMetadata36() *OxmIdTunMetadata36 {
11236 obj := &OxmIdTunMetadata36{
11237 OxmId: NewOxmId(104572),
11238 }
11239 return obj
11240}
11241func (self *OxmIdTunMetadata36) GetOXMName() string {
11242 return "tun_metadata36"
11243}
11244
11245func (self *OxmIdTunMetadata36) MarshalJSON() ([]byte, error) {
11246 if self.TypeLen == 0 {
11247 return []byte("\"\""), nil
11248 } else {
11249 return []byte("\"" + self.GetOXMName() + "\""), nil
11250 }
11251}
11252
11253type OxmIdTunMetadata36Masked struct {
11254 *OxmId
11255}
11256
11257type IOxmIdTunMetadata36Masked interface {
11258 IOxmId
11259}
11260
11261func (self *OxmIdTunMetadata36Masked) Serialize(encoder *goloxi.Encoder) error {
11262 if err := self.OxmId.Serialize(encoder); err != nil {
11263 return err
11264 }
11265
11266 return nil
11267}
11268
11269func DecodeOxmIdTunMetadata36Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata36Masked, error) {
11270 _oxmidtunmetadata36masked := &OxmIdTunMetadata36Masked{OxmId: parent}
11271 return _oxmidtunmetadata36masked, nil
11272}
11273
11274func NewOxmIdTunMetadata36Masked() *OxmIdTunMetadata36Masked {
11275 obj := &OxmIdTunMetadata36Masked{
11276 OxmId: NewOxmId(104952),
11277 }
11278 return obj
11279}
11280func (self *OxmIdTunMetadata36Masked) GetOXMName() string {
11281 return "tun_metadata36_masked"
11282}
11283
11284func (self *OxmIdTunMetadata36Masked) MarshalJSON() ([]byte, error) {
11285 if self.TypeLen == 0 {
11286 return []byte("\"\""), nil
11287 } else {
11288 return []byte("\"" + self.GetOXMName() + "\""), nil
11289 }
11290}
11291
11292type OxmIdTunMetadata37 struct {
11293 *OxmId
11294}
11295
11296type IOxmIdTunMetadata37 interface {
11297 IOxmId
11298}
11299
11300func (self *OxmIdTunMetadata37) Serialize(encoder *goloxi.Encoder) error {
11301 if err := self.OxmId.Serialize(encoder); err != nil {
11302 return err
11303 }
11304
11305 return nil
11306}
11307
11308func DecodeOxmIdTunMetadata37(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata37, error) {
11309 _oxmidtunmetadata37 := &OxmIdTunMetadata37{OxmId: parent}
11310 return _oxmidtunmetadata37, nil
11311}
11312
11313func NewOxmIdTunMetadata37() *OxmIdTunMetadata37 {
11314 obj := &OxmIdTunMetadata37{
11315 OxmId: NewOxmId(105084),
11316 }
11317 return obj
11318}
11319func (self *OxmIdTunMetadata37) GetOXMName() string {
11320 return "tun_metadata37"
11321}
11322
11323func (self *OxmIdTunMetadata37) MarshalJSON() ([]byte, error) {
11324 if self.TypeLen == 0 {
11325 return []byte("\"\""), nil
11326 } else {
11327 return []byte("\"" + self.GetOXMName() + "\""), nil
11328 }
11329}
11330
11331type OxmIdTunMetadata37Masked struct {
11332 *OxmId
11333}
11334
11335type IOxmIdTunMetadata37Masked interface {
11336 IOxmId
11337}
11338
11339func (self *OxmIdTunMetadata37Masked) Serialize(encoder *goloxi.Encoder) error {
11340 if err := self.OxmId.Serialize(encoder); err != nil {
11341 return err
11342 }
11343
11344 return nil
11345}
11346
11347func DecodeOxmIdTunMetadata37Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata37Masked, error) {
11348 _oxmidtunmetadata37masked := &OxmIdTunMetadata37Masked{OxmId: parent}
11349 return _oxmidtunmetadata37masked, nil
11350}
11351
11352func NewOxmIdTunMetadata37Masked() *OxmIdTunMetadata37Masked {
11353 obj := &OxmIdTunMetadata37Masked{
11354 OxmId: NewOxmId(105464),
11355 }
11356 return obj
11357}
11358func (self *OxmIdTunMetadata37Masked) GetOXMName() string {
11359 return "tun_metadata37_masked"
11360}
11361
11362func (self *OxmIdTunMetadata37Masked) MarshalJSON() ([]byte, error) {
11363 if self.TypeLen == 0 {
11364 return []byte("\"\""), nil
11365 } else {
11366 return []byte("\"" + self.GetOXMName() + "\""), nil
11367 }
11368}
11369
11370type OxmIdTunMetadata38 struct {
11371 *OxmId
11372}
11373
11374type IOxmIdTunMetadata38 interface {
11375 IOxmId
11376}
11377
11378func (self *OxmIdTunMetadata38) Serialize(encoder *goloxi.Encoder) error {
11379 if err := self.OxmId.Serialize(encoder); err != nil {
11380 return err
11381 }
11382
11383 return nil
11384}
11385
11386func DecodeOxmIdTunMetadata38(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata38, error) {
11387 _oxmidtunmetadata38 := &OxmIdTunMetadata38{OxmId: parent}
11388 return _oxmidtunmetadata38, nil
11389}
11390
11391func NewOxmIdTunMetadata38() *OxmIdTunMetadata38 {
11392 obj := &OxmIdTunMetadata38{
11393 OxmId: NewOxmId(105596),
11394 }
11395 return obj
11396}
11397func (self *OxmIdTunMetadata38) GetOXMName() string {
11398 return "tun_metadata38"
11399}
11400
11401func (self *OxmIdTunMetadata38) MarshalJSON() ([]byte, error) {
11402 if self.TypeLen == 0 {
11403 return []byte("\"\""), nil
11404 } else {
11405 return []byte("\"" + self.GetOXMName() + "\""), nil
11406 }
11407}
11408
11409type OxmIdTunMetadata38Masked struct {
11410 *OxmId
11411}
11412
11413type IOxmIdTunMetadata38Masked interface {
11414 IOxmId
11415}
11416
11417func (self *OxmIdTunMetadata38Masked) Serialize(encoder *goloxi.Encoder) error {
11418 if err := self.OxmId.Serialize(encoder); err != nil {
11419 return err
11420 }
11421
11422 return nil
11423}
11424
11425func DecodeOxmIdTunMetadata38Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata38Masked, error) {
11426 _oxmidtunmetadata38masked := &OxmIdTunMetadata38Masked{OxmId: parent}
11427 return _oxmidtunmetadata38masked, nil
11428}
11429
11430func NewOxmIdTunMetadata38Masked() *OxmIdTunMetadata38Masked {
11431 obj := &OxmIdTunMetadata38Masked{
11432 OxmId: NewOxmId(105976),
11433 }
11434 return obj
11435}
11436func (self *OxmIdTunMetadata38Masked) GetOXMName() string {
11437 return "tun_metadata38_masked"
11438}
11439
11440func (self *OxmIdTunMetadata38Masked) MarshalJSON() ([]byte, error) {
11441 if self.TypeLen == 0 {
11442 return []byte("\"\""), nil
11443 } else {
11444 return []byte("\"" + self.GetOXMName() + "\""), nil
11445 }
11446}
11447
11448type OxmIdTunMetadata39 struct {
11449 *OxmId
11450}
11451
11452type IOxmIdTunMetadata39 interface {
11453 IOxmId
11454}
11455
11456func (self *OxmIdTunMetadata39) Serialize(encoder *goloxi.Encoder) error {
11457 if err := self.OxmId.Serialize(encoder); err != nil {
11458 return err
11459 }
11460
11461 return nil
11462}
11463
11464func DecodeOxmIdTunMetadata39(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata39, error) {
11465 _oxmidtunmetadata39 := &OxmIdTunMetadata39{OxmId: parent}
11466 return _oxmidtunmetadata39, nil
11467}
11468
11469func NewOxmIdTunMetadata39() *OxmIdTunMetadata39 {
11470 obj := &OxmIdTunMetadata39{
11471 OxmId: NewOxmId(106108),
11472 }
11473 return obj
11474}
11475func (self *OxmIdTunMetadata39) GetOXMName() string {
11476 return "tun_metadata39"
11477}
11478
11479func (self *OxmIdTunMetadata39) MarshalJSON() ([]byte, error) {
11480 if self.TypeLen == 0 {
11481 return []byte("\"\""), nil
11482 } else {
11483 return []byte("\"" + self.GetOXMName() + "\""), nil
11484 }
11485}
11486
11487type OxmIdTunMetadata39Masked struct {
11488 *OxmId
11489}
11490
11491type IOxmIdTunMetadata39Masked interface {
11492 IOxmId
11493}
11494
11495func (self *OxmIdTunMetadata39Masked) Serialize(encoder *goloxi.Encoder) error {
11496 if err := self.OxmId.Serialize(encoder); err != nil {
11497 return err
11498 }
11499
11500 return nil
11501}
11502
11503func DecodeOxmIdTunMetadata39Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata39Masked, error) {
11504 _oxmidtunmetadata39masked := &OxmIdTunMetadata39Masked{OxmId: parent}
11505 return _oxmidtunmetadata39masked, nil
11506}
11507
11508func NewOxmIdTunMetadata39Masked() *OxmIdTunMetadata39Masked {
11509 obj := &OxmIdTunMetadata39Masked{
11510 OxmId: NewOxmId(106488),
11511 }
11512 return obj
11513}
11514func (self *OxmIdTunMetadata39Masked) GetOXMName() string {
11515 return "tun_metadata39_masked"
11516}
11517
11518func (self *OxmIdTunMetadata39Masked) MarshalJSON() ([]byte, error) {
11519 if self.TypeLen == 0 {
11520 return []byte("\"\""), nil
11521 } else {
11522 return []byte("\"" + self.GetOXMName() + "\""), nil
11523 }
11524}
11525
11526type OxmIdTunMetadata3Masked struct {
11527 *OxmId
11528}
11529
11530type IOxmIdTunMetadata3Masked interface {
11531 IOxmId
11532}
11533
11534func (self *OxmIdTunMetadata3Masked) Serialize(encoder *goloxi.Encoder) error {
11535 if err := self.OxmId.Serialize(encoder); err != nil {
11536 return err
11537 }
11538
11539 return nil
11540}
11541
11542func DecodeOxmIdTunMetadata3Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata3Masked, error) {
11543 _oxmidtunmetadata3masked := &OxmIdTunMetadata3Masked{OxmId: parent}
11544 return _oxmidtunmetadata3masked, nil
11545}
11546
11547func NewOxmIdTunMetadata3Masked() *OxmIdTunMetadata3Masked {
11548 obj := &OxmIdTunMetadata3Masked{
11549 OxmId: NewOxmId(88056),
11550 }
11551 return obj
11552}
11553func (self *OxmIdTunMetadata3Masked) GetOXMName() string {
11554 return "tun_metadata3_masked"
11555}
11556
11557func (self *OxmIdTunMetadata3Masked) MarshalJSON() ([]byte, error) {
11558 if self.TypeLen == 0 {
11559 return []byte("\"\""), nil
11560 } else {
11561 return []byte("\"" + self.GetOXMName() + "\""), nil
11562 }
11563}
11564
11565type OxmIdTunMetadata4 struct {
11566 *OxmId
11567}
11568
11569type IOxmIdTunMetadata4 interface {
11570 IOxmId
11571}
11572
11573func (self *OxmIdTunMetadata4) Serialize(encoder *goloxi.Encoder) error {
11574 if err := self.OxmId.Serialize(encoder); err != nil {
11575 return err
11576 }
11577
11578 return nil
11579}
11580
11581func DecodeOxmIdTunMetadata4(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata4, error) {
11582 _oxmidtunmetadata4 := &OxmIdTunMetadata4{OxmId: parent}
11583 return _oxmidtunmetadata4, nil
11584}
11585
11586func NewOxmIdTunMetadata4() *OxmIdTunMetadata4 {
11587 obj := &OxmIdTunMetadata4{
11588 OxmId: NewOxmId(88188),
11589 }
11590 return obj
11591}
11592func (self *OxmIdTunMetadata4) GetOXMName() string {
11593 return "tun_metadata4"
11594}
11595
11596func (self *OxmIdTunMetadata4) MarshalJSON() ([]byte, error) {
11597 if self.TypeLen == 0 {
11598 return []byte("\"\""), nil
11599 } else {
11600 return []byte("\"" + self.GetOXMName() + "\""), nil
11601 }
11602}
11603
11604type OxmIdTunMetadata40 struct {
11605 *OxmId
11606}
11607
11608type IOxmIdTunMetadata40 interface {
11609 IOxmId
11610}
11611
11612func (self *OxmIdTunMetadata40) Serialize(encoder *goloxi.Encoder) error {
11613 if err := self.OxmId.Serialize(encoder); err != nil {
11614 return err
11615 }
11616
11617 return nil
11618}
11619
11620func DecodeOxmIdTunMetadata40(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata40, error) {
11621 _oxmidtunmetadata40 := &OxmIdTunMetadata40{OxmId: parent}
11622 return _oxmidtunmetadata40, nil
11623}
11624
11625func NewOxmIdTunMetadata40() *OxmIdTunMetadata40 {
11626 obj := &OxmIdTunMetadata40{
11627 OxmId: NewOxmId(106620),
11628 }
11629 return obj
11630}
11631func (self *OxmIdTunMetadata40) GetOXMName() string {
11632 return "tun_metadata40"
11633}
11634
11635func (self *OxmIdTunMetadata40) MarshalJSON() ([]byte, error) {
11636 if self.TypeLen == 0 {
11637 return []byte("\"\""), nil
11638 } else {
11639 return []byte("\"" + self.GetOXMName() + "\""), nil
11640 }
11641}
11642
11643type OxmIdTunMetadata40Masked struct {
11644 *OxmId
11645}
11646
11647type IOxmIdTunMetadata40Masked interface {
11648 IOxmId
11649}
11650
11651func (self *OxmIdTunMetadata40Masked) Serialize(encoder *goloxi.Encoder) error {
11652 if err := self.OxmId.Serialize(encoder); err != nil {
11653 return err
11654 }
11655
11656 return nil
11657}
11658
11659func DecodeOxmIdTunMetadata40Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata40Masked, error) {
11660 _oxmidtunmetadata40masked := &OxmIdTunMetadata40Masked{OxmId: parent}
11661 return _oxmidtunmetadata40masked, nil
11662}
11663
11664func NewOxmIdTunMetadata40Masked() *OxmIdTunMetadata40Masked {
11665 obj := &OxmIdTunMetadata40Masked{
11666 OxmId: NewOxmId(107000),
11667 }
11668 return obj
11669}
11670func (self *OxmIdTunMetadata40Masked) GetOXMName() string {
11671 return "tun_metadata40_masked"
11672}
11673
11674func (self *OxmIdTunMetadata40Masked) MarshalJSON() ([]byte, error) {
11675 if self.TypeLen == 0 {
11676 return []byte("\"\""), nil
11677 } else {
11678 return []byte("\"" + self.GetOXMName() + "\""), nil
11679 }
11680}
11681
11682type OxmIdTunMetadata41 struct {
11683 *OxmId
11684}
11685
11686type IOxmIdTunMetadata41 interface {
11687 IOxmId
11688}
11689
11690func (self *OxmIdTunMetadata41) Serialize(encoder *goloxi.Encoder) error {
11691 if err := self.OxmId.Serialize(encoder); err != nil {
11692 return err
11693 }
11694
11695 return nil
11696}
11697
11698func DecodeOxmIdTunMetadata41(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata41, error) {
11699 _oxmidtunmetadata41 := &OxmIdTunMetadata41{OxmId: parent}
11700 return _oxmidtunmetadata41, nil
11701}
11702
11703func NewOxmIdTunMetadata41() *OxmIdTunMetadata41 {
11704 obj := &OxmIdTunMetadata41{
11705 OxmId: NewOxmId(107132),
11706 }
11707 return obj
11708}
11709func (self *OxmIdTunMetadata41) GetOXMName() string {
11710 return "tun_metadata41"
11711}
11712
11713func (self *OxmIdTunMetadata41) MarshalJSON() ([]byte, error) {
11714 if self.TypeLen == 0 {
11715 return []byte("\"\""), nil
11716 } else {
11717 return []byte("\"" + self.GetOXMName() + "\""), nil
11718 }
11719}
11720
11721type OxmIdTunMetadata41Masked struct {
11722 *OxmId
11723}
11724
11725type IOxmIdTunMetadata41Masked interface {
11726 IOxmId
11727}
11728
11729func (self *OxmIdTunMetadata41Masked) Serialize(encoder *goloxi.Encoder) error {
11730 if err := self.OxmId.Serialize(encoder); err != nil {
11731 return err
11732 }
11733
11734 return nil
11735}
11736
11737func DecodeOxmIdTunMetadata41Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata41Masked, error) {
11738 _oxmidtunmetadata41masked := &OxmIdTunMetadata41Masked{OxmId: parent}
11739 return _oxmidtunmetadata41masked, nil
11740}
11741
11742func NewOxmIdTunMetadata41Masked() *OxmIdTunMetadata41Masked {
11743 obj := &OxmIdTunMetadata41Masked{
11744 OxmId: NewOxmId(107512),
11745 }
11746 return obj
11747}
11748func (self *OxmIdTunMetadata41Masked) GetOXMName() string {
11749 return "tun_metadata41_masked"
11750}
11751
11752func (self *OxmIdTunMetadata41Masked) MarshalJSON() ([]byte, error) {
11753 if self.TypeLen == 0 {
11754 return []byte("\"\""), nil
11755 } else {
11756 return []byte("\"" + self.GetOXMName() + "\""), nil
11757 }
11758}
11759
11760type OxmIdTunMetadata42 struct {
11761 *OxmId
11762}
11763
11764type IOxmIdTunMetadata42 interface {
11765 IOxmId
11766}
11767
11768func (self *OxmIdTunMetadata42) Serialize(encoder *goloxi.Encoder) error {
11769 if err := self.OxmId.Serialize(encoder); err != nil {
11770 return err
11771 }
11772
11773 return nil
11774}
11775
11776func DecodeOxmIdTunMetadata42(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata42, error) {
11777 _oxmidtunmetadata42 := &OxmIdTunMetadata42{OxmId: parent}
11778 return _oxmidtunmetadata42, nil
11779}
11780
11781func NewOxmIdTunMetadata42() *OxmIdTunMetadata42 {
11782 obj := &OxmIdTunMetadata42{
11783 OxmId: NewOxmId(107644),
11784 }
11785 return obj
11786}
11787func (self *OxmIdTunMetadata42) GetOXMName() string {
11788 return "tun_metadata42"
11789}
11790
11791func (self *OxmIdTunMetadata42) MarshalJSON() ([]byte, error) {
11792 if self.TypeLen == 0 {
11793 return []byte("\"\""), nil
11794 } else {
11795 return []byte("\"" + self.GetOXMName() + "\""), nil
11796 }
11797}
11798
11799type OxmIdTunMetadata42Masked struct {
11800 *OxmId
11801}
11802
11803type IOxmIdTunMetadata42Masked interface {
11804 IOxmId
11805}
11806
11807func (self *OxmIdTunMetadata42Masked) Serialize(encoder *goloxi.Encoder) error {
11808 if err := self.OxmId.Serialize(encoder); err != nil {
11809 return err
11810 }
11811
11812 return nil
11813}
11814
11815func DecodeOxmIdTunMetadata42Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata42Masked, error) {
11816 _oxmidtunmetadata42masked := &OxmIdTunMetadata42Masked{OxmId: parent}
11817 return _oxmidtunmetadata42masked, nil
11818}
11819
11820func NewOxmIdTunMetadata42Masked() *OxmIdTunMetadata42Masked {
11821 obj := &OxmIdTunMetadata42Masked{
11822 OxmId: NewOxmId(108024),
11823 }
11824 return obj
11825}
11826func (self *OxmIdTunMetadata42Masked) GetOXMName() string {
11827 return "tun_metadata42_masked"
11828}
11829
11830func (self *OxmIdTunMetadata42Masked) MarshalJSON() ([]byte, error) {
11831 if self.TypeLen == 0 {
11832 return []byte("\"\""), nil
11833 } else {
11834 return []byte("\"" + self.GetOXMName() + "\""), nil
11835 }
11836}
11837
11838type OxmIdTunMetadata43 struct {
11839 *OxmId
11840}
11841
11842type IOxmIdTunMetadata43 interface {
11843 IOxmId
11844}
11845
11846func (self *OxmIdTunMetadata43) Serialize(encoder *goloxi.Encoder) error {
11847 if err := self.OxmId.Serialize(encoder); err != nil {
11848 return err
11849 }
11850
11851 return nil
11852}
11853
11854func DecodeOxmIdTunMetadata43(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata43, error) {
11855 _oxmidtunmetadata43 := &OxmIdTunMetadata43{OxmId: parent}
11856 return _oxmidtunmetadata43, nil
11857}
11858
11859func NewOxmIdTunMetadata43() *OxmIdTunMetadata43 {
11860 obj := &OxmIdTunMetadata43{
11861 OxmId: NewOxmId(108156),
11862 }
11863 return obj
11864}
11865func (self *OxmIdTunMetadata43) GetOXMName() string {
11866 return "tun_metadata43"
11867}
11868
11869func (self *OxmIdTunMetadata43) MarshalJSON() ([]byte, error) {
11870 if self.TypeLen == 0 {
11871 return []byte("\"\""), nil
11872 } else {
11873 return []byte("\"" + self.GetOXMName() + "\""), nil
11874 }
11875}
11876
11877type OxmIdTunMetadata43Masked struct {
11878 *OxmId
11879}
11880
11881type IOxmIdTunMetadata43Masked interface {
11882 IOxmId
11883}
11884
11885func (self *OxmIdTunMetadata43Masked) Serialize(encoder *goloxi.Encoder) error {
11886 if err := self.OxmId.Serialize(encoder); err != nil {
11887 return err
11888 }
11889
11890 return nil
11891}
11892
11893func DecodeOxmIdTunMetadata43Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata43Masked, error) {
11894 _oxmidtunmetadata43masked := &OxmIdTunMetadata43Masked{OxmId: parent}
11895 return _oxmidtunmetadata43masked, nil
11896}
11897
11898func NewOxmIdTunMetadata43Masked() *OxmIdTunMetadata43Masked {
11899 obj := &OxmIdTunMetadata43Masked{
11900 OxmId: NewOxmId(108536),
11901 }
11902 return obj
11903}
11904func (self *OxmIdTunMetadata43Masked) GetOXMName() string {
11905 return "tun_metadata43_masked"
11906}
11907
11908func (self *OxmIdTunMetadata43Masked) MarshalJSON() ([]byte, error) {
11909 if self.TypeLen == 0 {
11910 return []byte("\"\""), nil
11911 } else {
11912 return []byte("\"" + self.GetOXMName() + "\""), nil
11913 }
11914}
11915
11916type OxmIdTunMetadata44 struct {
11917 *OxmId
11918}
11919
11920type IOxmIdTunMetadata44 interface {
11921 IOxmId
11922}
11923
11924func (self *OxmIdTunMetadata44) Serialize(encoder *goloxi.Encoder) error {
11925 if err := self.OxmId.Serialize(encoder); err != nil {
11926 return err
11927 }
11928
11929 return nil
11930}
11931
11932func DecodeOxmIdTunMetadata44(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata44, error) {
11933 _oxmidtunmetadata44 := &OxmIdTunMetadata44{OxmId: parent}
11934 return _oxmidtunmetadata44, nil
11935}
11936
11937func NewOxmIdTunMetadata44() *OxmIdTunMetadata44 {
11938 obj := &OxmIdTunMetadata44{
11939 OxmId: NewOxmId(108668),
11940 }
11941 return obj
11942}
11943func (self *OxmIdTunMetadata44) GetOXMName() string {
11944 return "tun_metadata44"
11945}
11946
11947func (self *OxmIdTunMetadata44) MarshalJSON() ([]byte, error) {
11948 if self.TypeLen == 0 {
11949 return []byte("\"\""), nil
11950 } else {
11951 return []byte("\"" + self.GetOXMName() + "\""), nil
11952 }
11953}
11954
11955type OxmIdTunMetadata44Masked struct {
11956 *OxmId
11957}
11958
11959type IOxmIdTunMetadata44Masked interface {
11960 IOxmId
11961}
11962
11963func (self *OxmIdTunMetadata44Masked) Serialize(encoder *goloxi.Encoder) error {
11964 if err := self.OxmId.Serialize(encoder); err != nil {
11965 return err
11966 }
11967
11968 return nil
11969}
11970
11971func DecodeOxmIdTunMetadata44Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata44Masked, error) {
11972 _oxmidtunmetadata44masked := &OxmIdTunMetadata44Masked{OxmId: parent}
11973 return _oxmidtunmetadata44masked, nil
11974}
11975
11976func NewOxmIdTunMetadata44Masked() *OxmIdTunMetadata44Masked {
11977 obj := &OxmIdTunMetadata44Masked{
11978 OxmId: NewOxmId(109048),
11979 }
11980 return obj
11981}
11982func (self *OxmIdTunMetadata44Masked) GetOXMName() string {
11983 return "tun_metadata44_masked"
11984}
11985
11986func (self *OxmIdTunMetadata44Masked) MarshalJSON() ([]byte, error) {
11987 if self.TypeLen == 0 {
11988 return []byte("\"\""), nil
11989 } else {
11990 return []byte("\"" + self.GetOXMName() + "\""), nil
11991 }
11992}
11993
11994type OxmIdTunMetadata45 struct {
11995 *OxmId
11996}
11997
11998type IOxmIdTunMetadata45 interface {
11999 IOxmId
12000}
12001
12002func (self *OxmIdTunMetadata45) Serialize(encoder *goloxi.Encoder) error {
12003 if err := self.OxmId.Serialize(encoder); err != nil {
12004 return err
12005 }
12006
12007 return nil
12008}
12009
12010func DecodeOxmIdTunMetadata45(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata45, error) {
12011 _oxmidtunmetadata45 := &OxmIdTunMetadata45{OxmId: parent}
12012 return _oxmidtunmetadata45, nil
12013}
12014
12015func NewOxmIdTunMetadata45() *OxmIdTunMetadata45 {
12016 obj := &OxmIdTunMetadata45{
12017 OxmId: NewOxmId(109180),
12018 }
12019 return obj
12020}
12021func (self *OxmIdTunMetadata45) GetOXMName() string {
12022 return "tun_metadata45"
12023}
12024
12025func (self *OxmIdTunMetadata45) MarshalJSON() ([]byte, error) {
12026 if self.TypeLen == 0 {
12027 return []byte("\"\""), nil
12028 } else {
12029 return []byte("\"" + self.GetOXMName() + "\""), nil
12030 }
12031}
12032
12033type OxmIdTunMetadata45Masked struct {
12034 *OxmId
12035}
12036
12037type IOxmIdTunMetadata45Masked interface {
12038 IOxmId
12039}
12040
12041func (self *OxmIdTunMetadata45Masked) Serialize(encoder *goloxi.Encoder) error {
12042 if err := self.OxmId.Serialize(encoder); err != nil {
12043 return err
12044 }
12045
12046 return nil
12047}
12048
12049func DecodeOxmIdTunMetadata45Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata45Masked, error) {
12050 _oxmidtunmetadata45masked := &OxmIdTunMetadata45Masked{OxmId: parent}
12051 return _oxmidtunmetadata45masked, nil
12052}
12053
12054func NewOxmIdTunMetadata45Masked() *OxmIdTunMetadata45Masked {
12055 obj := &OxmIdTunMetadata45Masked{
12056 OxmId: NewOxmId(109560),
12057 }
12058 return obj
12059}
12060func (self *OxmIdTunMetadata45Masked) GetOXMName() string {
12061 return "tun_metadata45_masked"
12062}
12063
12064func (self *OxmIdTunMetadata45Masked) MarshalJSON() ([]byte, error) {
12065 if self.TypeLen == 0 {
12066 return []byte("\"\""), nil
12067 } else {
12068 return []byte("\"" + self.GetOXMName() + "\""), nil
12069 }
12070}
12071
12072type OxmIdTunMetadata46 struct {
12073 *OxmId
12074}
12075
12076type IOxmIdTunMetadata46 interface {
12077 IOxmId
12078}
12079
12080func (self *OxmIdTunMetadata46) Serialize(encoder *goloxi.Encoder) error {
12081 if err := self.OxmId.Serialize(encoder); err != nil {
12082 return err
12083 }
12084
12085 return nil
12086}
12087
12088func DecodeOxmIdTunMetadata46(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata46, error) {
12089 _oxmidtunmetadata46 := &OxmIdTunMetadata46{OxmId: parent}
12090 return _oxmidtunmetadata46, nil
12091}
12092
12093func NewOxmIdTunMetadata46() *OxmIdTunMetadata46 {
12094 obj := &OxmIdTunMetadata46{
12095 OxmId: NewOxmId(109692),
12096 }
12097 return obj
12098}
12099func (self *OxmIdTunMetadata46) GetOXMName() string {
12100 return "tun_metadata46"
12101}
12102
12103func (self *OxmIdTunMetadata46) MarshalJSON() ([]byte, error) {
12104 if self.TypeLen == 0 {
12105 return []byte("\"\""), nil
12106 } else {
12107 return []byte("\"" + self.GetOXMName() + "\""), nil
12108 }
12109}
12110
12111type OxmIdTunMetadata46Masked struct {
12112 *OxmId
12113}
12114
12115type IOxmIdTunMetadata46Masked interface {
12116 IOxmId
12117}
12118
12119func (self *OxmIdTunMetadata46Masked) Serialize(encoder *goloxi.Encoder) error {
12120 if err := self.OxmId.Serialize(encoder); err != nil {
12121 return err
12122 }
12123
12124 return nil
12125}
12126
12127func DecodeOxmIdTunMetadata46Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata46Masked, error) {
12128 _oxmidtunmetadata46masked := &OxmIdTunMetadata46Masked{OxmId: parent}
12129 return _oxmidtunmetadata46masked, nil
12130}
12131
12132func NewOxmIdTunMetadata46Masked() *OxmIdTunMetadata46Masked {
12133 obj := &OxmIdTunMetadata46Masked{
12134 OxmId: NewOxmId(110072),
12135 }
12136 return obj
12137}
12138func (self *OxmIdTunMetadata46Masked) GetOXMName() string {
12139 return "tun_metadata46_masked"
12140}
12141
12142func (self *OxmIdTunMetadata46Masked) MarshalJSON() ([]byte, error) {
12143 if self.TypeLen == 0 {
12144 return []byte("\"\""), nil
12145 } else {
12146 return []byte("\"" + self.GetOXMName() + "\""), nil
12147 }
12148}
12149
12150type OxmIdTunMetadata47 struct {
12151 *OxmId
12152}
12153
12154type IOxmIdTunMetadata47 interface {
12155 IOxmId
12156}
12157
12158func (self *OxmIdTunMetadata47) Serialize(encoder *goloxi.Encoder) error {
12159 if err := self.OxmId.Serialize(encoder); err != nil {
12160 return err
12161 }
12162
12163 return nil
12164}
12165
12166func DecodeOxmIdTunMetadata47(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata47, error) {
12167 _oxmidtunmetadata47 := &OxmIdTunMetadata47{OxmId: parent}
12168 return _oxmidtunmetadata47, nil
12169}
12170
12171func NewOxmIdTunMetadata47() *OxmIdTunMetadata47 {
12172 obj := &OxmIdTunMetadata47{
12173 OxmId: NewOxmId(110204),
12174 }
12175 return obj
12176}
12177func (self *OxmIdTunMetadata47) GetOXMName() string {
12178 return "tun_metadata47"
12179}
12180
12181func (self *OxmIdTunMetadata47) MarshalJSON() ([]byte, error) {
12182 if self.TypeLen == 0 {
12183 return []byte("\"\""), nil
12184 } else {
12185 return []byte("\"" + self.GetOXMName() + "\""), nil
12186 }
12187}
12188
12189type OxmIdTunMetadata47Masked struct {
12190 *OxmId
12191}
12192
12193type IOxmIdTunMetadata47Masked interface {
12194 IOxmId
12195}
12196
12197func (self *OxmIdTunMetadata47Masked) Serialize(encoder *goloxi.Encoder) error {
12198 if err := self.OxmId.Serialize(encoder); err != nil {
12199 return err
12200 }
12201
12202 return nil
12203}
12204
12205func DecodeOxmIdTunMetadata47Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata47Masked, error) {
12206 _oxmidtunmetadata47masked := &OxmIdTunMetadata47Masked{OxmId: parent}
12207 return _oxmidtunmetadata47masked, nil
12208}
12209
12210func NewOxmIdTunMetadata47Masked() *OxmIdTunMetadata47Masked {
12211 obj := &OxmIdTunMetadata47Masked{
12212 OxmId: NewOxmId(110584),
12213 }
12214 return obj
12215}
12216func (self *OxmIdTunMetadata47Masked) GetOXMName() string {
12217 return "tun_metadata47_masked"
12218}
12219
12220func (self *OxmIdTunMetadata47Masked) MarshalJSON() ([]byte, error) {
12221 if self.TypeLen == 0 {
12222 return []byte("\"\""), nil
12223 } else {
12224 return []byte("\"" + self.GetOXMName() + "\""), nil
12225 }
12226}
12227
12228type OxmIdTunMetadata48 struct {
12229 *OxmId
12230}
12231
12232type IOxmIdTunMetadata48 interface {
12233 IOxmId
12234}
12235
12236func (self *OxmIdTunMetadata48) Serialize(encoder *goloxi.Encoder) error {
12237 if err := self.OxmId.Serialize(encoder); err != nil {
12238 return err
12239 }
12240
12241 return nil
12242}
12243
12244func DecodeOxmIdTunMetadata48(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata48, error) {
12245 _oxmidtunmetadata48 := &OxmIdTunMetadata48{OxmId: parent}
12246 return _oxmidtunmetadata48, nil
12247}
12248
12249func NewOxmIdTunMetadata48() *OxmIdTunMetadata48 {
12250 obj := &OxmIdTunMetadata48{
12251 OxmId: NewOxmId(110716),
12252 }
12253 return obj
12254}
12255func (self *OxmIdTunMetadata48) GetOXMName() string {
12256 return "tun_metadata48"
12257}
12258
12259func (self *OxmIdTunMetadata48) MarshalJSON() ([]byte, error) {
12260 if self.TypeLen == 0 {
12261 return []byte("\"\""), nil
12262 } else {
12263 return []byte("\"" + self.GetOXMName() + "\""), nil
12264 }
12265}
12266
12267type OxmIdTunMetadata48Masked struct {
12268 *OxmId
12269}
12270
12271type IOxmIdTunMetadata48Masked interface {
12272 IOxmId
12273}
12274
12275func (self *OxmIdTunMetadata48Masked) Serialize(encoder *goloxi.Encoder) error {
12276 if err := self.OxmId.Serialize(encoder); err != nil {
12277 return err
12278 }
12279
12280 return nil
12281}
12282
12283func DecodeOxmIdTunMetadata48Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata48Masked, error) {
12284 _oxmidtunmetadata48masked := &OxmIdTunMetadata48Masked{OxmId: parent}
12285 return _oxmidtunmetadata48masked, nil
12286}
12287
12288func NewOxmIdTunMetadata48Masked() *OxmIdTunMetadata48Masked {
12289 obj := &OxmIdTunMetadata48Masked{
12290 OxmId: NewOxmId(111096),
12291 }
12292 return obj
12293}
12294func (self *OxmIdTunMetadata48Masked) GetOXMName() string {
12295 return "tun_metadata48_masked"
12296}
12297
12298func (self *OxmIdTunMetadata48Masked) MarshalJSON() ([]byte, error) {
12299 if self.TypeLen == 0 {
12300 return []byte("\"\""), nil
12301 } else {
12302 return []byte("\"" + self.GetOXMName() + "\""), nil
12303 }
12304}
12305
12306type OxmIdTunMetadata49 struct {
12307 *OxmId
12308}
12309
12310type IOxmIdTunMetadata49 interface {
12311 IOxmId
12312}
12313
12314func (self *OxmIdTunMetadata49) Serialize(encoder *goloxi.Encoder) error {
12315 if err := self.OxmId.Serialize(encoder); err != nil {
12316 return err
12317 }
12318
12319 return nil
12320}
12321
12322func DecodeOxmIdTunMetadata49(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata49, error) {
12323 _oxmidtunmetadata49 := &OxmIdTunMetadata49{OxmId: parent}
12324 return _oxmidtunmetadata49, nil
12325}
12326
12327func NewOxmIdTunMetadata49() *OxmIdTunMetadata49 {
12328 obj := &OxmIdTunMetadata49{
12329 OxmId: NewOxmId(111228),
12330 }
12331 return obj
12332}
12333func (self *OxmIdTunMetadata49) GetOXMName() string {
12334 return "tun_metadata49"
12335}
12336
12337func (self *OxmIdTunMetadata49) MarshalJSON() ([]byte, error) {
12338 if self.TypeLen == 0 {
12339 return []byte("\"\""), nil
12340 } else {
12341 return []byte("\"" + self.GetOXMName() + "\""), nil
12342 }
12343}
12344
12345type OxmIdTunMetadata49Masked struct {
12346 *OxmId
12347}
12348
12349type IOxmIdTunMetadata49Masked interface {
12350 IOxmId
12351}
12352
12353func (self *OxmIdTunMetadata49Masked) Serialize(encoder *goloxi.Encoder) error {
12354 if err := self.OxmId.Serialize(encoder); err != nil {
12355 return err
12356 }
12357
12358 return nil
12359}
12360
12361func DecodeOxmIdTunMetadata49Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata49Masked, error) {
12362 _oxmidtunmetadata49masked := &OxmIdTunMetadata49Masked{OxmId: parent}
12363 return _oxmidtunmetadata49masked, nil
12364}
12365
12366func NewOxmIdTunMetadata49Masked() *OxmIdTunMetadata49Masked {
12367 obj := &OxmIdTunMetadata49Masked{
12368 OxmId: NewOxmId(111608),
12369 }
12370 return obj
12371}
12372func (self *OxmIdTunMetadata49Masked) GetOXMName() string {
12373 return "tun_metadata49_masked"
12374}
12375
12376func (self *OxmIdTunMetadata49Masked) MarshalJSON() ([]byte, error) {
12377 if self.TypeLen == 0 {
12378 return []byte("\"\""), nil
12379 } else {
12380 return []byte("\"" + self.GetOXMName() + "\""), nil
12381 }
12382}
12383
12384type OxmIdTunMetadata4Masked struct {
12385 *OxmId
12386}
12387
12388type IOxmIdTunMetadata4Masked interface {
12389 IOxmId
12390}
12391
12392func (self *OxmIdTunMetadata4Masked) Serialize(encoder *goloxi.Encoder) error {
12393 if err := self.OxmId.Serialize(encoder); err != nil {
12394 return err
12395 }
12396
12397 return nil
12398}
12399
12400func DecodeOxmIdTunMetadata4Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata4Masked, error) {
12401 _oxmidtunmetadata4masked := &OxmIdTunMetadata4Masked{OxmId: parent}
12402 return _oxmidtunmetadata4masked, nil
12403}
12404
12405func NewOxmIdTunMetadata4Masked() *OxmIdTunMetadata4Masked {
12406 obj := &OxmIdTunMetadata4Masked{
12407 OxmId: NewOxmId(88568),
12408 }
12409 return obj
12410}
12411func (self *OxmIdTunMetadata4Masked) GetOXMName() string {
12412 return "tun_metadata4_masked"
12413}
12414
12415func (self *OxmIdTunMetadata4Masked) MarshalJSON() ([]byte, error) {
12416 if self.TypeLen == 0 {
12417 return []byte("\"\""), nil
12418 } else {
12419 return []byte("\"" + self.GetOXMName() + "\""), nil
12420 }
12421}
12422
12423type OxmIdTunMetadata5 struct {
12424 *OxmId
12425}
12426
12427type IOxmIdTunMetadata5 interface {
12428 IOxmId
12429}
12430
12431func (self *OxmIdTunMetadata5) Serialize(encoder *goloxi.Encoder) error {
12432 if err := self.OxmId.Serialize(encoder); err != nil {
12433 return err
12434 }
12435
12436 return nil
12437}
12438
12439func DecodeOxmIdTunMetadata5(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata5, error) {
12440 _oxmidtunmetadata5 := &OxmIdTunMetadata5{OxmId: parent}
12441 return _oxmidtunmetadata5, nil
12442}
12443
12444func NewOxmIdTunMetadata5() *OxmIdTunMetadata5 {
12445 obj := &OxmIdTunMetadata5{
12446 OxmId: NewOxmId(88700),
12447 }
12448 return obj
12449}
12450func (self *OxmIdTunMetadata5) GetOXMName() string {
12451 return "tun_metadata5"
12452}
12453
12454func (self *OxmIdTunMetadata5) MarshalJSON() ([]byte, error) {
12455 if self.TypeLen == 0 {
12456 return []byte("\"\""), nil
12457 } else {
12458 return []byte("\"" + self.GetOXMName() + "\""), nil
12459 }
12460}
12461
12462type OxmIdTunMetadata50 struct {
12463 *OxmId
12464}
12465
12466type IOxmIdTunMetadata50 interface {
12467 IOxmId
12468}
12469
12470func (self *OxmIdTunMetadata50) Serialize(encoder *goloxi.Encoder) error {
12471 if err := self.OxmId.Serialize(encoder); err != nil {
12472 return err
12473 }
12474
12475 return nil
12476}
12477
12478func DecodeOxmIdTunMetadata50(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata50, error) {
12479 _oxmidtunmetadata50 := &OxmIdTunMetadata50{OxmId: parent}
12480 return _oxmidtunmetadata50, nil
12481}
12482
12483func NewOxmIdTunMetadata50() *OxmIdTunMetadata50 {
12484 obj := &OxmIdTunMetadata50{
12485 OxmId: NewOxmId(111740),
12486 }
12487 return obj
12488}
12489func (self *OxmIdTunMetadata50) GetOXMName() string {
12490 return "tun_metadata50"
12491}
12492
12493func (self *OxmIdTunMetadata50) MarshalJSON() ([]byte, error) {
12494 if self.TypeLen == 0 {
12495 return []byte("\"\""), nil
12496 } else {
12497 return []byte("\"" + self.GetOXMName() + "\""), nil
12498 }
12499}
12500
12501type OxmIdTunMetadata50Masked struct {
12502 *OxmId
12503}
12504
12505type IOxmIdTunMetadata50Masked interface {
12506 IOxmId
12507}
12508
12509func (self *OxmIdTunMetadata50Masked) Serialize(encoder *goloxi.Encoder) error {
12510 if err := self.OxmId.Serialize(encoder); err != nil {
12511 return err
12512 }
12513
12514 return nil
12515}
12516
12517func DecodeOxmIdTunMetadata50Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata50Masked, error) {
12518 _oxmidtunmetadata50masked := &OxmIdTunMetadata50Masked{OxmId: parent}
12519 return _oxmidtunmetadata50masked, nil
12520}
12521
12522func NewOxmIdTunMetadata50Masked() *OxmIdTunMetadata50Masked {
12523 obj := &OxmIdTunMetadata50Masked{
12524 OxmId: NewOxmId(112120),
12525 }
12526 return obj
12527}
12528func (self *OxmIdTunMetadata50Masked) GetOXMName() string {
12529 return "tun_metadata50_masked"
12530}
12531
12532func (self *OxmIdTunMetadata50Masked) MarshalJSON() ([]byte, error) {
12533 if self.TypeLen == 0 {
12534 return []byte("\"\""), nil
12535 } else {
12536 return []byte("\"" + self.GetOXMName() + "\""), nil
12537 }
12538}
12539
12540type OxmIdTunMetadata51 struct {
12541 *OxmId
12542}
12543
12544type IOxmIdTunMetadata51 interface {
12545 IOxmId
12546}
12547
12548func (self *OxmIdTunMetadata51) Serialize(encoder *goloxi.Encoder) error {
12549 if err := self.OxmId.Serialize(encoder); err != nil {
12550 return err
12551 }
12552
12553 return nil
12554}
12555
12556func DecodeOxmIdTunMetadata51(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata51, error) {
12557 _oxmidtunmetadata51 := &OxmIdTunMetadata51{OxmId: parent}
12558 return _oxmidtunmetadata51, nil
12559}
12560
12561func NewOxmIdTunMetadata51() *OxmIdTunMetadata51 {
12562 obj := &OxmIdTunMetadata51{
12563 OxmId: NewOxmId(112252),
12564 }
12565 return obj
12566}
12567func (self *OxmIdTunMetadata51) GetOXMName() string {
12568 return "tun_metadata51"
12569}
12570
12571func (self *OxmIdTunMetadata51) MarshalJSON() ([]byte, error) {
12572 if self.TypeLen == 0 {
12573 return []byte("\"\""), nil
12574 } else {
12575 return []byte("\"" + self.GetOXMName() + "\""), nil
12576 }
12577}
12578
12579type OxmIdTunMetadata51Masked struct {
12580 *OxmId
12581}
12582
12583type IOxmIdTunMetadata51Masked interface {
12584 IOxmId
12585}
12586
12587func (self *OxmIdTunMetadata51Masked) Serialize(encoder *goloxi.Encoder) error {
12588 if err := self.OxmId.Serialize(encoder); err != nil {
12589 return err
12590 }
12591
12592 return nil
12593}
12594
12595func DecodeOxmIdTunMetadata51Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata51Masked, error) {
12596 _oxmidtunmetadata51masked := &OxmIdTunMetadata51Masked{OxmId: parent}
12597 return _oxmidtunmetadata51masked, nil
12598}
12599
12600func NewOxmIdTunMetadata51Masked() *OxmIdTunMetadata51Masked {
12601 obj := &OxmIdTunMetadata51Masked{
12602 OxmId: NewOxmId(112632),
12603 }
12604 return obj
12605}
12606func (self *OxmIdTunMetadata51Masked) GetOXMName() string {
12607 return "tun_metadata51_masked"
12608}
12609
12610func (self *OxmIdTunMetadata51Masked) MarshalJSON() ([]byte, error) {
12611 if self.TypeLen == 0 {
12612 return []byte("\"\""), nil
12613 } else {
12614 return []byte("\"" + self.GetOXMName() + "\""), nil
12615 }
12616}
12617
12618type OxmIdTunMetadata52 struct {
12619 *OxmId
12620}
12621
12622type IOxmIdTunMetadata52 interface {
12623 IOxmId
12624}
12625
12626func (self *OxmIdTunMetadata52) Serialize(encoder *goloxi.Encoder) error {
12627 if err := self.OxmId.Serialize(encoder); err != nil {
12628 return err
12629 }
12630
12631 return nil
12632}
12633
12634func DecodeOxmIdTunMetadata52(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata52, error) {
12635 _oxmidtunmetadata52 := &OxmIdTunMetadata52{OxmId: parent}
12636 return _oxmidtunmetadata52, nil
12637}
12638
12639func NewOxmIdTunMetadata52() *OxmIdTunMetadata52 {
12640 obj := &OxmIdTunMetadata52{
12641 OxmId: NewOxmId(112764),
12642 }
12643 return obj
12644}
12645func (self *OxmIdTunMetadata52) GetOXMName() string {
12646 return "tun_metadata52"
12647}
12648
12649func (self *OxmIdTunMetadata52) MarshalJSON() ([]byte, error) {
12650 if self.TypeLen == 0 {
12651 return []byte("\"\""), nil
12652 } else {
12653 return []byte("\"" + self.GetOXMName() + "\""), nil
12654 }
12655}
12656
12657type OxmIdTunMetadata52Masked struct {
12658 *OxmId
12659}
12660
12661type IOxmIdTunMetadata52Masked interface {
12662 IOxmId
12663}
12664
12665func (self *OxmIdTunMetadata52Masked) Serialize(encoder *goloxi.Encoder) error {
12666 if err := self.OxmId.Serialize(encoder); err != nil {
12667 return err
12668 }
12669
12670 return nil
12671}
12672
12673func DecodeOxmIdTunMetadata52Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata52Masked, error) {
12674 _oxmidtunmetadata52masked := &OxmIdTunMetadata52Masked{OxmId: parent}
12675 return _oxmidtunmetadata52masked, nil
12676}
12677
12678func NewOxmIdTunMetadata52Masked() *OxmIdTunMetadata52Masked {
12679 obj := &OxmIdTunMetadata52Masked{
12680 OxmId: NewOxmId(113144),
12681 }
12682 return obj
12683}
12684func (self *OxmIdTunMetadata52Masked) GetOXMName() string {
12685 return "tun_metadata52_masked"
12686}
12687
12688func (self *OxmIdTunMetadata52Masked) MarshalJSON() ([]byte, error) {
12689 if self.TypeLen == 0 {
12690 return []byte("\"\""), nil
12691 } else {
12692 return []byte("\"" + self.GetOXMName() + "\""), nil
12693 }
12694}
12695
12696type OxmIdTunMetadata53 struct {
12697 *OxmId
12698}
12699
12700type IOxmIdTunMetadata53 interface {
12701 IOxmId
12702}
12703
12704func (self *OxmIdTunMetadata53) Serialize(encoder *goloxi.Encoder) error {
12705 if err := self.OxmId.Serialize(encoder); err != nil {
12706 return err
12707 }
12708
12709 return nil
12710}
12711
12712func DecodeOxmIdTunMetadata53(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata53, error) {
12713 _oxmidtunmetadata53 := &OxmIdTunMetadata53{OxmId: parent}
12714 return _oxmidtunmetadata53, nil
12715}
12716
12717func NewOxmIdTunMetadata53() *OxmIdTunMetadata53 {
12718 obj := &OxmIdTunMetadata53{
12719 OxmId: NewOxmId(113276),
12720 }
12721 return obj
12722}
12723func (self *OxmIdTunMetadata53) GetOXMName() string {
12724 return "tun_metadata53"
12725}
12726
12727func (self *OxmIdTunMetadata53) MarshalJSON() ([]byte, error) {
12728 if self.TypeLen == 0 {
12729 return []byte("\"\""), nil
12730 } else {
12731 return []byte("\"" + self.GetOXMName() + "\""), nil
12732 }
12733}
12734
12735type OxmIdTunMetadata53Masked struct {
12736 *OxmId
12737}
12738
12739type IOxmIdTunMetadata53Masked interface {
12740 IOxmId
12741}
12742
12743func (self *OxmIdTunMetadata53Masked) Serialize(encoder *goloxi.Encoder) error {
12744 if err := self.OxmId.Serialize(encoder); err != nil {
12745 return err
12746 }
12747
12748 return nil
12749}
12750
12751func DecodeOxmIdTunMetadata53Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata53Masked, error) {
12752 _oxmidtunmetadata53masked := &OxmIdTunMetadata53Masked{OxmId: parent}
12753 return _oxmidtunmetadata53masked, nil
12754}
12755
12756func NewOxmIdTunMetadata53Masked() *OxmIdTunMetadata53Masked {
12757 obj := &OxmIdTunMetadata53Masked{
12758 OxmId: NewOxmId(113656),
12759 }
12760 return obj
12761}
12762func (self *OxmIdTunMetadata53Masked) GetOXMName() string {
12763 return "tun_metadata53_masked"
12764}
12765
12766func (self *OxmIdTunMetadata53Masked) MarshalJSON() ([]byte, error) {
12767 if self.TypeLen == 0 {
12768 return []byte("\"\""), nil
12769 } else {
12770 return []byte("\"" + self.GetOXMName() + "\""), nil
12771 }
12772}
12773
12774type OxmIdTunMetadata54 struct {
12775 *OxmId
12776}
12777
12778type IOxmIdTunMetadata54 interface {
12779 IOxmId
12780}
12781
12782func (self *OxmIdTunMetadata54) Serialize(encoder *goloxi.Encoder) error {
12783 if err := self.OxmId.Serialize(encoder); err != nil {
12784 return err
12785 }
12786
12787 return nil
12788}
12789
12790func DecodeOxmIdTunMetadata54(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata54, error) {
12791 _oxmidtunmetadata54 := &OxmIdTunMetadata54{OxmId: parent}
12792 return _oxmidtunmetadata54, nil
12793}
12794
12795func NewOxmIdTunMetadata54() *OxmIdTunMetadata54 {
12796 obj := &OxmIdTunMetadata54{
12797 OxmId: NewOxmId(113788),
12798 }
12799 return obj
12800}
12801func (self *OxmIdTunMetadata54) GetOXMName() string {
12802 return "tun_metadata54"
12803}
12804
12805func (self *OxmIdTunMetadata54) MarshalJSON() ([]byte, error) {
12806 if self.TypeLen == 0 {
12807 return []byte("\"\""), nil
12808 } else {
12809 return []byte("\"" + self.GetOXMName() + "\""), nil
12810 }
12811}
12812
12813type OxmIdTunMetadata54Masked struct {
12814 *OxmId
12815}
12816
12817type IOxmIdTunMetadata54Masked interface {
12818 IOxmId
12819}
12820
12821func (self *OxmIdTunMetadata54Masked) Serialize(encoder *goloxi.Encoder) error {
12822 if err := self.OxmId.Serialize(encoder); err != nil {
12823 return err
12824 }
12825
12826 return nil
12827}
12828
12829func DecodeOxmIdTunMetadata54Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata54Masked, error) {
12830 _oxmidtunmetadata54masked := &OxmIdTunMetadata54Masked{OxmId: parent}
12831 return _oxmidtunmetadata54masked, nil
12832}
12833
12834func NewOxmIdTunMetadata54Masked() *OxmIdTunMetadata54Masked {
12835 obj := &OxmIdTunMetadata54Masked{
12836 OxmId: NewOxmId(114168),
12837 }
12838 return obj
12839}
12840func (self *OxmIdTunMetadata54Masked) GetOXMName() string {
12841 return "tun_metadata54_masked"
12842}
12843
12844func (self *OxmIdTunMetadata54Masked) MarshalJSON() ([]byte, error) {
12845 if self.TypeLen == 0 {
12846 return []byte("\"\""), nil
12847 } else {
12848 return []byte("\"" + self.GetOXMName() + "\""), nil
12849 }
12850}
12851
12852type OxmIdTunMetadata55 struct {
12853 *OxmId
12854}
12855
12856type IOxmIdTunMetadata55 interface {
12857 IOxmId
12858}
12859
12860func (self *OxmIdTunMetadata55) Serialize(encoder *goloxi.Encoder) error {
12861 if err := self.OxmId.Serialize(encoder); err != nil {
12862 return err
12863 }
12864
12865 return nil
12866}
12867
12868func DecodeOxmIdTunMetadata55(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata55, error) {
12869 _oxmidtunmetadata55 := &OxmIdTunMetadata55{OxmId: parent}
12870 return _oxmidtunmetadata55, nil
12871}
12872
12873func NewOxmIdTunMetadata55() *OxmIdTunMetadata55 {
12874 obj := &OxmIdTunMetadata55{
12875 OxmId: NewOxmId(114300),
12876 }
12877 return obj
12878}
12879func (self *OxmIdTunMetadata55) GetOXMName() string {
12880 return "tun_metadata55"
12881}
12882
12883func (self *OxmIdTunMetadata55) MarshalJSON() ([]byte, error) {
12884 if self.TypeLen == 0 {
12885 return []byte("\"\""), nil
12886 } else {
12887 return []byte("\"" + self.GetOXMName() + "\""), nil
12888 }
12889}
12890
12891type OxmIdTunMetadata55Masked struct {
12892 *OxmId
12893}
12894
12895type IOxmIdTunMetadata55Masked interface {
12896 IOxmId
12897}
12898
12899func (self *OxmIdTunMetadata55Masked) Serialize(encoder *goloxi.Encoder) error {
12900 if err := self.OxmId.Serialize(encoder); err != nil {
12901 return err
12902 }
12903
12904 return nil
12905}
12906
12907func DecodeOxmIdTunMetadata55Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata55Masked, error) {
12908 _oxmidtunmetadata55masked := &OxmIdTunMetadata55Masked{OxmId: parent}
12909 return _oxmidtunmetadata55masked, nil
12910}
12911
12912func NewOxmIdTunMetadata55Masked() *OxmIdTunMetadata55Masked {
12913 obj := &OxmIdTunMetadata55Masked{
12914 OxmId: NewOxmId(114680),
12915 }
12916 return obj
12917}
12918func (self *OxmIdTunMetadata55Masked) GetOXMName() string {
12919 return "tun_metadata55_masked"
12920}
12921
12922func (self *OxmIdTunMetadata55Masked) MarshalJSON() ([]byte, error) {
12923 if self.TypeLen == 0 {
12924 return []byte("\"\""), nil
12925 } else {
12926 return []byte("\"" + self.GetOXMName() + "\""), nil
12927 }
12928}
12929
12930type OxmIdTunMetadata56 struct {
12931 *OxmId
12932}
12933
12934type IOxmIdTunMetadata56 interface {
12935 IOxmId
12936}
12937
12938func (self *OxmIdTunMetadata56) Serialize(encoder *goloxi.Encoder) error {
12939 if err := self.OxmId.Serialize(encoder); err != nil {
12940 return err
12941 }
12942
12943 return nil
12944}
12945
12946func DecodeOxmIdTunMetadata56(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata56, error) {
12947 _oxmidtunmetadata56 := &OxmIdTunMetadata56{OxmId: parent}
12948 return _oxmidtunmetadata56, nil
12949}
12950
12951func NewOxmIdTunMetadata56() *OxmIdTunMetadata56 {
12952 obj := &OxmIdTunMetadata56{
12953 OxmId: NewOxmId(114812),
12954 }
12955 return obj
12956}
12957func (self *OxmIdTunMetadata56) GetOXMName() string {
12958 return "tun_metadata56"
12959}
12960
12961func (self *OxmIdTunMetadata56) MarshalJSON() ([]byte, error) {
12962 if self.TypeLen == 0 {
12963 return []byte("\"\""), nil
12964 } else {
12965 return []byte("\"" + self.GetOXMName() + "\""), nil
12966 }
12967}
12968
12969type OxmIdTunMetadata56Masked struct {
12970 *OxmId
12971}
12972
12973type IOxmIdTunMetadata56Masked interface {
12974 IOxmId
12975}
12976
12977func (self *OxmIdTunMetadata56Masked) Serialize(encoder *goloxi.Encoder) error {
12978 if err := self.OxmId.Serialize(encoder); err != nil {
12979 return err
12980 }
12981
12982 return nil
12983}
12984
12985func DecodeOxmIdTunMetadata56Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata56Masked, error) {
12986 _oxmidtunmetadata56masked := &OxmIdTunMetadata56Masked{OxmId: parent}
12987 return _oxmidtunmetadata56masked, nil
12988}
12989
12990func NewOxmIdTunMetadata56Masked() *OxmIdTunMetadata56Masked {
12991 obj := &OxmIdTunMetadata56Masked{
12992 OxmId: NewOxmId(115192),
12993 }
12994 return obj
12995}
12996func (self *OxmIdTunMetadata56Masked) GetOXMName() string {
12997 return "tun_metadata56_masked"
12998}
12999
13000func (self *OxmIdTunMetadata56Masked) MarshalJSON() ([]byte, error) {
13001 if self.TypeLen == 0 {
13002 return []byte("\"\""), nil
13003 } else {
13004 return []byte("\"" + self.GetOXMName() + "\""), nil
13005 }
13006}
13007
13008type OxmIdTunMetadata57 struct {
13009 *OxmId
13010}
13011
13012type IOxmIdTunMetadata57 interface {
13013 IOxmId
13014}
13015
13016func (self *OxmIdTunMetadata57) Serialize(encoder *goloxi.Encoder) error {
13017 if err := self.OxmId.Serialize(encoder); err != nil {
13018 return err
13019 }
13020
13021 return nil
13022}
13023
13024func DecodeOxmIdTunMetadata57(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata57, error) {
13025 _oxmidtunmetadata57 := &OxmIdTunMetadata57{OxmId: parent}
13026 return _oxmidtunmetadata57, nil
13027}
13028
13029func NewOxmIdTunMetadata57() *OxmIdTunMetadata57 {
13030 obj := &OxmIdTunMetadata57{
13031 OxmId: NewOxmId(115324),
13032 }
13033 return obj
13034}
13035func (self *OxmIdTunMetadata57) GetOXMName() string {
13036 return "tun_metadata57"
13037}
13038
13039func (self *OxmIdTunMetadata57) MarshalJSON() ([]byte, error) {
13040 if self.TypeLen == 0 {
13041 return []byte("\"\""), nil
13042 } else {
13043 return []byte("\"" + self.GetOXMName() + "\""), nil
13044 }
13045}
13046
13047type OxmIdTunMetadata57Masked struct {
13048 *OxmId
13049}
13050
13051type IOxmIdTunMetadata57Masked interface {
13052 IOxmId
13053}
13054
13055func (self *OxmIdTunMetadata57Masked) Serialize(encoder *goloxi.Encoder) error {
13056 if err := self.OxmId.Serialize(encoder); err != nil {
13057 return err
13058 }
13059
13060 return nil
13061}
13062
13063func DecodeOxmIdTunMetadata57Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata57Masked, error) {
13064 _oxmidtunmetadata57masked := &OxmIdTunMetadata57Masked{OxmId: parent}
13065 return _oxmidtunmetadata57masked, nil
13066}
13067
13068func NewOxmIdTunMetadata57Masked() *OxmIdTunMetadata57Masked {
13069 obj := &OxmIdTunMetadata57Masked{
13070 OxmId: NewOxmId(115704),
13071 }
13072 return obj
13073}
13074func (self *OxmIdTunMetadata57Masked) GetOXMName() string {
13075 return "tun_metadata57_masked"
13076}
13077
13078func (self *OxmIdTunMetadata57Masked) MarshalJSON() ([]byte, error) {
13079 if self.TypeLen == 0 {
13080 return []byte("\"\""), nil
13081 } else {
13082 return []byte("\"" + self.GetOXMName() + "\""), nil
13083 }
13084}
13085
13086type OxmIdTunMetadata58 struct {
13087 *OxmId
13088}
13089
13090type IOxmIdTunMetadata58 interface {
13091 IOxmId
13092}
13093
13094func (self *OxmIdTunMetadata58) Serialize(encoder *goloxi.Encoder) error {
13095 if err := self.OxmId.Serialize(encoder); err != nil {
13096 return err
13097 }
13098
13099 return nil
13100}
13101
13102func DecodeOxmIdTunMetadata58(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata58, error) {
13103 _oxmidtunmetadata58 := &OxmIdTunMetadata58{OxmId: parent}
13104 return _oxmidtunmetadata58, nil
13105}
13106
13107func NewOxmIdTunMetadata58() *OxmIdTunMetadata58 {
13108 obj := &OxmIdTunMetadata58{
13109 OxmId: NewOxmId(115836),
13110 }
13111 return obj
13112}
13113func (self *OxmIdTunMetadata58) GetOXMName() string {
13114 return "tun_metadata58"
13115}
13116
13117func (self *OxmIdTunMetadata58) MarshalJSON() ([]byte, error) {
13118 if self.TypeLen == 0 {
13119 return []byte("\"\""), nil
13120 } else {
13121 return []byte("\"" + self.GetOXMName() + "\""), nil
13122 }
13123}
13124
13125type OxmIdTunMetadata58Masked struct {
13126 *OxmId
13127}
13128
13129type IOxmIdTunMetadata58Masked interface {
13130 IOxmId
13131}
13132
13133func (self *OxmIdTunMetadata58Masked) Serialize(encoder *goloxi.Encoder) error {
13134 if err := self.OxmId.Serialize(encoder); err != nil {
13135 return err
13136 }
13137
13138 return nil
13139}
13140
13141func DecodeOxmIdTunMetadata58Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata58Masked, error) {
13142 _oxmidtunmetadata58masked := &OxmIdTunMetadata58Masked{OxmId: parent}
13143 return _oxmidtunmetadata58masked, nil
13144}
13145
13146func NewOxmIdTunMetadata58Masked() *OxmIdTunMetadata58Masked {
13147 obj := &OxmIdTunMetadata58Masked{
13148 OxmId: NewOxmId(116216),
13149 }
13150 return obj
13151}
13152func (self *OxmIdTunMetadata58Masked) GetOXMName() string {
13153 return "tun_metadata58_masked"
13154}
13155
13156func (self *OxmIdTunMetadata58Masked) MarshalJSON() ([]byte, error) {
13157 if self.TypeLen == 0 {
13158 return []byte("\"\""), nil
13159 } else {
13160 return []byte("\"" + self.GetOXMName() + "\""), nil
13161 }
13162}
13163
13164type OxmIdTunMetadata59 struct {
13165 *OxmId
13166}
13167
13168type IOxmIdTunMetadata59 interface {
13169 IOxmId
13170}
13171
13172func (self *OxmIdTunMetadata59) Serialize(encoder *goloxi.Encoder) error {
13173 if err := self.OxmId.Serialize(encoder); err != nil {
13174 return err
13175 }
13176
13177 return nil
13178}
13179
13180func DecodeOxmIdTunMetadata59(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata59, error) {
13181 _oxmidtunmetadata59 := &OxmIdTunMetadata59{OxmId: parent}
13182 return _oxmidtunmetadata59, nil
13183}
13184
13185func NewOxmIdTunMetadata59() *OxmIdTunMetadata59 {
13186 obj := &OxmIdTunMetadata59{
13187 OxmId: NewOxmId(116348),
13188 }
13189 return obj
13190}
13191func (self *OxmIdTunMetadata59) GetOXMName() string {
13192 return "tun_metadata59"
13193}
13194
13195func (self *OxmIdTunMetadata59) MarshalJSON() ([]byte, error) {
13196 if self.TypeLen == 0 {
13197 return []byte("\"\""), nil
13198 } else {
13199 return []byte("\"" + self.GetOXMName() + "\""), nil
13200 }
13201}
13202
13203type OxmIdTunMetadata59Masked struct {
13204 *OxmId
13205}
13206
13207type IOxmIdTunMetadata59Masked interface {
13208 IOxmId
13209}
13210
13211func (self *OxmIdTunMetadata59Masked) Serialize(encoder *goloxi.Encoder) error {
13212 if err := self.OxmId.Serialize(encoder); err != nil {
13213 return err
13214 }
13215
13216 return nil
13217}
13218
13219func DecodeOxmIdTunMetadata59Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata59Masked, error) {
13220 _oxmidtunmetadata59masked := &OxmIdTunMetadata59Masked{OxmId: parent}
13221 return _oxmidtunmetadata59masked, nil
13222}
13223
13224func NewOxmIdTunMetadata59Masked() *OxmIdTunMetadata59Masked {
13225 obj := &OxmIdTunMetadata59Masked{
13226 OxmId: NewOxmId(116728),
13227 }
13228 return obj
13229}
13230func (self *OxmIdTunMetadata59Masked) GetOXMName() string {
13231 return "tun_metadata59_masked"
13232}
13233
13234func (self *OxmIdTunMetadata59Masked) MarshalJSON() ([]byte, error) {
13235 if self.TypeLen == 0 {
13236 return []byte("\"\""), nil
13237 } else {
13238 return []byte("\"" + self.GetOXMName() + "\""), nil
13239 }
13240}
13241
13242type OxmIdTunMetadata5Masked struct {
13243 *OxmId
13244}
13245
13246type IOxmIdTunMetadata5Masked interface {
13247 IOxmId
13248}
13249
13250func (self *OxmIdTunMetadata5Masked) Serialize(encoder *goloxi.Encoder) error {
13251 if err := self.OxmId.Serialize(encoder); err != nil {
13252 return err
13253 }
13254
13255 return nil
13256}
13257
13258func DecodeOxmIdTunMetadata5Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata5Masked, error) {
13259 _oxmidtunmetadata5masked := &OxmIdTunMetadata5Masked{OxmId: parent}
13260 return _oxmidtunmetadata5masked, nil
13261}
13262
13263func NewOxmIdTunMetadata5Masked() *OxmIdTunMetadata5Masked {
13264 obj := &OxmIdTunMetadata5Masked{
13265 OxmId: NewOxmId(89080),
13266 }
13267 return obj
13268}
13269func (self *OxmIdTunMetadata5Masked) GetOXMName() string {
13270 return "tun_metadata5_masked"
13271}
13272
13273func (self *OxmIdTunMetadata5Masked) MarshalJSON() ([]byte, error) {
13274 if self.TypeLen == 0 {
13275 return []byte("\"\""), nil
13276 } else {
13277 return []byte("\"" + self.GetOXMName() + "\""), nil
13278 }
13279}
13280
13281type OxmIdTunMetadata6 struct {
13282 *OxmId
13283}
13284
13285type IOxmIdTunMetadata6 interface {
13286 IOxmId
13287}
13288
13289func (self *OxmIdTunMetadata6) Serialize(encoder *goloxi.Encoder) error {
13290 if err := self.OxmId.Serialize(encoder); err != nil {
13291 return err
13292 }
13293
13294 return nil
13295}
13296
13297func DecodeOxmIdTunMetadata6(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata6, error) {
13298 _oxmidtunmetadata6 := &OxmIdTunMetadata6{OxmId: parent}
13299 return _oxmidtunmetadata6, nil
13300}
13301
13302func NewOxmIdTunMetadata6() *OxmIdTunMetadata6 {
13303 obj := &OxmIdTunMetadata6{
13304 OxmId: NewOxmId(89212),
13305 }
13306 return obj
13307}
13308func (self *OxmIdTunMetadata6) GetOXMName() string {
13309 return "tun_metadata6"
13310}
13311
13312func (self *OxmIdTunMetadata6) MarshalJSON() ([]byte, error) {
13313 if self.TypeLen == 0 {
13314 return []byte("\"\""), nil
13315 } else {
13316 return []byte("\"" + self.GetOXMName() + "\""), nil
13317 }
13318}
13319
13320type OxmIdTunMetadata60 struct {
13321 *OxmId
13322}
13323
13324type IOxmIdTunMetadata60 interface {
13325 IOxmId
13326}
13327
13328func (self *OxmIdTunMetadata60) Serialize(encoder *goloxi.Encoder) error {
13329 if err := self.OxmId.Serialize(encoder); err != nil {
13330 return err
13331 }
13332
13333 return nil
13334}
13335
13336func DecodeOxmIdTunMetadata60(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata60, error) {
13337 _oxmidtunmetadata60 := &OxmIdTunMetadata60{OxmId: parent}
13338 return _oxmidtunmetadata60, nil
13339}
13340
13341func NewOxmIdTunMetadata60() *OxmIdTunMetadata60 {
13342 obj := &OxmIdTunMetadata60{
13343 OxmId: NewOxmId(116860),
13344 }
13345 return obj
13346}
13347func (self *OxmIdTunMetadata60) GetOXMName() string {
13348 return "tun_metadata60"
13349}
13350
13351func (self *OxmIdTunMetadata60) MarshalJSON() ([]byte, error) {
13352 if self.TypeLen == 0 {
13353 return []byte("\"\""), nil
13354 } else {
13355 return []byte("\"" + self.GetOXMName() + "\""), nil
13356 }
13357}
13358
13359type OxmIdTunMetadata60Masked struct {
13360 *OxmId
13361}
13362
13363type IOxmIdTunMetadata60Masked interface {
13364 IOxmId
13365}
13366
13367func (self *OxmIdTunMetadata60Masked) Serialize(encoder *goloxi.Encoder) error {
13368 if err := self.OxmId.Serialize(encoder); err != nil {
13369 return err
13370 }
13371
13372 return nil
13373}
13374
13375func DecodeOxmIdTunMetadata60Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata60Masked, error) {
13376 _oxmidtunmetadata60masked := &OxmIdTunMetadata60Masked{OxmId: parent}
13377 return _oxmidtunmetadata60masked, nil
13378}
13379
13380func NewOxmIdTunMetadata60Masked() *OxmIdTunMetadata60Masked {
13381 obj := &OxmIdTunMetadata60Masked{
13382 OxmId: NewOxmId(117240),
13383 }
13384 return obj
13385}
13386func (self *OxmIdTunMetadata60Masked) GetOXMName() string {
13387 return "tun_metadata60_masked"
13388}
13389
13390func (self *OxmIdTunMetadata60Masked) MarshalJSON() ([]byte, error) {
13391 if self.TypeLen == 0 {
13392 return []byte("\"\""), nil
13393 } else {
13394 return []byte("\"" + self.GetOXMName() + "\""), nil
13395 }
13396}
13397
13398type OxmIdTunMetadata61 struct {
13399 *OxmId
13400}
13401
13402type IOxmIdTunMetadata61 interface {
13403 IOxmId
13404}
13405
13406func (self *OxmIdTunMetadata61) Serialize(encoder *goloxi.Encoder) error {
13407 if err := self.OxmId.Serialize(encoder); err != nil {
13408 return err
13409 }
13410
13411 return nil
13412}
13413
13414func DecodeOxmIdTunMetadata61(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata61, error) {
13415 _oxmidtunmetadata61 := &OxmIdTunMetadata61{OxmId: parent}
13416 return _oxmidtunmetadata61, nil
13417}
13418
13419func NewOxmIdTunMetadata61() *OxmIdTunMetadata61 {
13420 obj := &OxmIdTunMetadata61{
13421 OxmId: NewOxmId(117372),
13422 }
13423 return obj
13424}
13425func (self *OxmIdTunMetadata61) GetOXMName() string {
13426 return "tun_metadata61"
13427}
13428
13429func (self *OxmIdTunMetadata61) MarshalJSON() ([]byte, error) {
13430 if self.TypeLen == 0 {
13431 return []byte("\"\""), nil
13432 } else {
13433 return []byte("\"" + self.GetOXMName() + "\""), nil
13434 }
13435}
13436
13437type OxmIdTunMetadata61Masked struct {
13438 *OxmId
13439}
13440
13441type IOxmIdTunMetadata61Masked interface {
13442 IOxmId
13443}
13444
13445func (self *OxmIdTunMetadata61Masked) Serialize(encoder *goloxi.Encoder) error {
13446 if err := self.OxmId.Serialize(encoder); err != nil {
13447 return err
13448 }
13449
13450 return nil
13451}
13452
13453func DecodeOxmIdTunMetadata61Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata61Masked, error) {
13454 _oxmidtunmetadata61masked := &OxmIdTunMetadata61Masked{OxmId: parent}
13455 return _oxmidtunmetadata61masked, nil
13456}
13457
13458func NewOxmIdTunMetadata61Masked() *OxmIdTunMetadata61Masked {
13459 obj := &OxmIdTunMetadata61Masked{
13460 OxmId: NewOxmId(117752),
13461 }
13462 return obj
13463}
13464func (self *OxmIdTunMetadata61Masked) GetOXMName() string {
13465 return "tun_metadata61_masked"
13466}
13467
13468func (self *OxmIdTunMetadata61Masked) MarshalJSON() ([]byte, error) {
13469 if self.TypeLen == 0 {
13470 return []byte("\"\""), nil
13471 } else {
13472 return []byte("\"" + self.GetOXMName() + "\""), nil
13473 }
13474}
13475
13476type OxmIdTunMetadata62 struct {
13477 *OxmId
13478}
13479
13480type IOxmIdTunMetadata62 interface {
13481 IOxmId
13482}
13483
13484func (self *OxmIdTunMetadata62) Serialize(encoder *goloxi.Encoder) error {
13485 if err := self.OxmId.Serialize(encoder); err != nil {
13486 return err
13487 }
13488
13489 return nil
13490}
13491
13492func DecodeOxmIdTunMetadata62(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata62, error) {
13493 _oxmidtunmetadata62 := &OxmIdTunMetadata62{OxmId: parent}
13494 return _oxmidtunmetadata62, nil
13495}
13496
13497func NewOxmIdTunMetadata62() *OxmIdTunMetadata62 {
13498 obj := &OxmIdTunMetadata62{
13499 OxmId: NewOxmId(117884),
13500 }
13501 return obj
13502}
13503func (self *OxmIdTunMetadata62) GetOXMName() string {
13504 return "tun_metadata62"
13505}
13506
13507func (self *OxmIdTunMetadata62) MarshalJSON() ([]byte, error) {
13508 if self.TypeLen == 0 {
13509 return []byte("\"\""), nil
13510 } else {
13511 return []byte("\"" + self.GetOXMName() + "\""), nil
13512 }
13513}
13514
13515type OxmIdTunMetadata62Masked struct {
13516 *OxmId
13517}
13518
13519type IOxmIdTunMetadata62Masked interface {
13520 IOxmId
13521}
13522
13523func (self *OxmIdTunMetadata62Masked) Serialize(encoder *goloxi.Encoder) error {
13524 if err := self.OxmId.Serialize(encoder); err != nil {
13525 return err
13526 }
13527
13528 return nil
13529}
13530
13531func DecodeOxmIdTunMetadata62Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata62Masked, error) {
13532 _oxmidtunmetadata62masked := &OxmIdTunMetadata62Masked{OxmId: parent}
13533 return _oxmidtunmetadata62masked, nil
13534}
13535
13536func NewOxmIdTunMetadata62Masked() *OxmIdTunMetadata62Masked {
13537 obj := &OxmIdTunMetadata62Masked{
13538 OxmId: NewOxmId(118264),
13539 }
13540 return obj
13541}
13542func (self *OxmIdTunMetadata62Masked) GetOXMName() string {
13543 return "tun_metadata62_masked"
13544}
13545
13546func (self *OxmIdTunMetadata62Masked) MarshalJSON() ([]byte, error) {
13547 if self.TypeLen == 0 {
13548 return []byte("\"\""), nil
13549 } else {
13550 return []byte("\"" + self.GetOXMName() + "\""), nil
13551 }
13552}
13553
13554type OxmIdTunMetadata63 struct {
13555 *OxmId
13556}
13557
13558type IOxmIdTunMetadata63 interface {
13559 IOxmId
13560}
13561
13562func (self *OxmIdTunMetadata63) Serialize(encoder *goloxi.Encoder) error {
13563 if err := self.OxmId.Serialize(encoder); err != nil {
13564 return err
13565 }
13566
13567 return nil
13568}
13569
13570func DecodeOxmIdTunMetadata63(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata63, error) {
13571 _oxmidtunmetadata63 := &OxmIdTunMetadata63{OxmId: parent}
13572 return _oxmidtunmetadata63, nil
13573}
13574
13575func NewOxmIdTunMetadata63() *OxmIdTunMetadata63 {
13576 obj := &OxmIdTunMetadata63{
13577 OxmId: NewOxmId(118396),
13578 }
13579 return obj
13580}
13581func (self *OxmIdTunMetadata63) GetOXMName() string {
13582 return "tun_metadata63"
13583}
13584
13585func (self *OxmIdTunMetadata63) MarshalJSON() ([]byte, error) {
13586 if self.TypeLen == 0 {
13587 return []byte("\"\""), nil
13588 } else {
13589 return []byte("\"" + self.GetOXMName() + "\""), nil
13590 }
13591}
13592
13593type OxmIdTunMetadata63Masked struct {
13594 *OxmId
13595}
13596
13597type IOxmIdTunMetadata63Masked interface {
13598 IOxmId
13599}
13600
13601func (self *OxmIdTunMetadata63Masked) Serialize(encoder *goloxi.Encoder) error {
13602 if err := self.OxmId.Serialize(encoder); err != nil {
13603 return err
13604 }
13605
13606 return nil
13607}
13608
13609func DecodeOxmIdTunMetadata63Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata63Masked, error) {
13610 _oxmidtunmetadata63masked := &OxmIdTunMetadata63Masked{OxmId: parent}
13611 return _oxmidtunmetadata63masked, nil
13612}
13613
13614func NewOxmIdTunMetadata63Masked() *OxmIdTunMetadata63Masked {
13615 obj := &OxmIdTunMetadata63Masked{
13616 OxmId: NewOxmId(118776),
13617 }
13618 return obj
13619}
13620func (self *OxmIdTunMetadata63Masked) GetOXMName() string {
13621 return "tun_metadata63_masked"
13622}
13623
13624func (self *OxmIdTunMetadata63Masked) MarshalJSON() ([]byte, error) {
13625 if self.TypeLen == 0 {
13626 return []byte("\"\""), nil
13627 } else {
13628 return []byte("\"" + self.GetOXMName() + "\""), nil
13629 }
13630}
13631
13632type OxmIdTunMetadata6Masked struct {
13633 *OxmId
13634}
13635
13636type IOxmIdTunMetadata6Masked interface {
13637 IOxmId
13638}
13639
13640func (self *OxmIdTunMetadata6Masked) Serialize(encoder *goloxi.Encoder) error {
13641 if err := self.OxmId.Serialize(encoder); err != nil {
13642 return err
13643 }
13644
13645 return nil
13646}
13647
13648func DecodeOxmIdTunMetadata6Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata6Masked, error) {
13649 _oxmidtunmetadata6masked := &OxmIdTunMetadata6Masked{OxmId: parent}
13650 return _oxmidtunmetadata6masked, nil
13651}
13652
13653func NewOxmIdTunMetadata6Masked() *OxmIdTunMetadata6Masked {
13654 obj := &OxmIdTunMetadata6Masked{
13655 OxmId: NewOxmId(89592),
13656 }
13657 return obj
13658}
13659func (self *OxmIdTunMetadata6Masked) GetOXMName() string {
13660 return "tun_metadata6_masked"
13661}
13662
13663func (self *OxmIdTunMetadata6Masked) MarshalJSON() ([]byte, error) {
13664 if self.TypeLen == 0 {
13665 return []byte("\"\""), nil
13666 } else {
13667 return []byte("\"" + self.GetOXMName() + "\""), nil
13668 }
13669}
13670
13671type OxmIdTunMetadata7 struct {
13672 *OxmId
13673}
13674
13675type IOxmIdTunMetadata7 interface {
13676 IOxmId
13677}
13678
13679func (self *OxmIdTunMetadata7) Serialize(encoder *goloxi.Encoder) error {
13680 if err := self.OxmId.Serialize(encoder); err != nil {
13681 return err
13682 }
13683
13684 return nil
13685}
13686
13687func DecodeOxmIdTunMetadata7(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata7, error) {
13688 _oxmidtunmetadata7 := &OxmIdTunMetadata7{OxmId: parent}
13689 return _oxmidtunmetadata7, nil
13690}
13691
13692func NewOxmIdTunMetadata7() *OxmIdTunMetadata7 {
13693 obj := &OxmIdTunMetadata7{
13694 OxmId: NewOxmId(89724),
13695 }
13696 return obj
13697}
13698func (self *OxmIdTunMetadata7) GetOXMName() string {
13699 return "tun_metadata7"
13700}
13701
13702func (self *OxmIdTunMetadata7) MarshalJSON() ([]byte, error) {
13703 if self.TypeLen == 0 {
13704 return []byte("\"\""), nil
13705 } else {
13706 return []byte("\"" + self.GetOXMName() + "\""), nil
13707 }
13708}
13709
13710type OxmIdTunMetadata7Masked struct {
13711 *OxmId
13712}
13713
13714type IOxmIdTunMetadata7Masked interface {
13715 IOxmId
13716}
13717
13718func (self *OxmIdTunMetadata7Masked) Serialize(encoder *goloxi.Encoder) error {
13719 if err := self.OxmId.Serialize(encoder); err != nil {
13720 return err
13721 }
13722
13723 return nil
13724}
13725
13726func DecodeOxmIdTunMetadata7Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata7Masked, error) {
13727 _oxmidtunmetadata7masked := &OxmIdTunMetadata7Masked{OxmId: parent}
13728 return _oxmidtunmetadata7masked, nil
13729}
13730
13731func NewOxmIdTunMetadata7Masked() *OxmIdTunMetadata7Masked {
13732 obj := &OxmIdTunMetadata7Masked{
13733 OxmId: NewOxmId(90104),
13734 }
13735 return obj
13736}
13737func (self *OxmIdTunMetadata7Masked) GetOXMName() string {
13738 return "tun_metadata7_masked"
13739}
13740
13741func (self *OxmIdTunMetadata7Masked) MarshalJSON() ([]byte, error) {
13742 if self.TypeLen == 0 {
13743 return []byte("\"\""), nil
13744 } else {
13745 return []byte("\"" + self.GetOXMName() + "\""), nil
13746 }
13747}
13748
13749type OxmIdTunMetadata8 struct {
13750 *OxmId
13751}
13752
13753type IOxmIdTunMetadata8 interface {
13754 IOxmId
13755}
13756
13757func (self *OxmIdTunMetadata8) Serialize(encoder *goloxi.Encoder) error {
13758 if err := self.OxmId.Serialize(encoder); err != nil {
13759 return err
13760 }
13761
13762 return nil
13763}
13764
13765func DecodeOxmIdTunMetadata8(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata8, error) {
13766 _oxmidtunmetadata8 := &OxmIdTunMetadata8{OxmId: parent}
13767 return _oxmidtunmetadata8, nil
13768}
13769
13770func NewOxmIdTunMetadata8() *OxmIdTunMetadata8 {
13771 obj := &OxmIdTunMetadata8{
13772 OxmId: NewOxmId(90236),
13773 }
13774 return obj
13775}
13776func (self *OxmIdTunMetadata8) GetOXMName() string {
13777 return "tun_metadata8"
13778}
13779
13780func (self *OxmIdTunMetadata8) MarshalJSON() ([]byte, error) {
13781 if self.TypeLen == 0 {
13782 return []byte("\"\""), nil
13783 } else {
13784 return []byte("\"" + self.GetOXMName() + "\""), nil
13785 }
13786}
13787
13788type OxmIdTunMetadata8Masked struct {
13789 *OxmId
13790}
13791
13792type IOxmIdTunMetadata8Masked interface {
13793 IOxmId
13794}
13795
13796func (self *OxmIdTunMetadata8Masked) Serialize(encoder *goloxi.Encoder) error {
13797 if err := self.OxmId.Serialize(encoder); err != nil {
13798 return err
13799 }
13800
13801 return nil
13802}
13803
13804func DecodeOxmIdTunMetadata8Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata8Masked, error) {
13805 _oxmidtunmetadata8masked := &OxmIdTunMetadata8Masked{OxmId: parent}
13806 return _oxmidtunmetadata8masked, nil
13807}
13808
13809func NewOxmIdTunMetadata8Masked() *OxmIdTunMetadata8Masked {
13810 obj := &OxmIdTunMetadata8Masked{
13811 OxmId: NewOxmId(90616),
13812 }
13813 return obj
13814}
13815func (self *OxmIdTunMetadata8Masked) GetOXMName() string {
13816 return "tun_metadata8_masked"
13817}
13818
13819func (self *OxmIdTunMetadata8Masked) MarshalJSON() ([]byte, error) {
13820 if self.TypeLen == 0 {
13821 return []byte("\"\""), nil
13822 } else {
13823 return []byte("\"" + self.GetOXMName() + "\""), nil
13824 }
13825}
13826
13827type OxmIdTunMetadata9 struct {
13828 *OxmId
13829}
13830
13831type IOxmIdTunMetadata9 interface {
13832 IOxmId
13833}
13834
13835func (self *OxmIdTunMetadata9) Serialize(encoder *goloxi.Encoder) error {
13836 if err := self.OxmId.Serialize(encoder); err != nil {
13837 return err
13838 }
13839
13840 return nil
13841}
13842
13843func DecodeOxmIdTunMetadata9(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata9, error) {
13844 _oxmidtunmetadata9 := &OxmIdTunMetadata9{OxmId: parent}
13845 return _oxmidtunmetadata9, nil
13846}
13847
13848func NewOxmIdTunMetadata9() *OxmIdTunMetadata9 {
13849 obj := &OxmIdTunMetadata9{
13850 OxmId: NewOxmId(90748),
13851 }
13852 return obj
13853}
13854func (self *OxmIdTunMetadata9) GetOXMName() string {
13855 return "tun_metadata9"
13856}
13857
13858func (self *OxmIdTunMetadata9) MarshalJSON() ([]byte, error) {
13859 if self.TypeLen == 0 {
13860 return []byte("\"\""), nil
13861 } else {
13862 return []byte("\"" + self.GetOXMName() + "\""), nil
13863 }
13864}
13865
13866type OxmIdTunMetadata9Masked struct {
13867 *OxmId
13868}
13869
13870type IOxmIdTunMetadata9Masked interface {
13871 IOxmId
13872}
13873
13874func (self *OxmIdTunMetadata9Masked) Serialize(encoder *goloxi.Encoder) error {
13875 if err := self.OxmId.Serialize(encoder); err != nil {
13876 return err
13877 }
13878
13879 return nil
13880}
13881
13882func DecodeOxmIdTunMetadata9Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata9Masked, error) {
13883 _oxmidtunmetadata9masked := &OxmIdTunMetadata9Masked{OxmId: parent}
13884 return _oxmidtunmetadata9masked, nil
13885}
13886
13887func NewOxmIdTunMetadata9Masked() *OxmIdTunMetadata9Masked {
13888 obj := &OxmIdTunMetadata9Masked{
13889 OxmId: NewOxmId(91128),
13890 }
13891 return obj
13892}
13893func (self *OxmIdTunMetadata9Masked) GetOXMName() string {
13894 return "tun_metadata9_masked"
13895}
13896
13897func (self *OxmIdTunMetadata9Masked) MarshalJSON() ([]byte, error) {
13898 if self.TypeLen == 0 {
13899 return []byte("\"\""), nil
13900 } else {
13901 return []byte("\"" + self.GetOXMName() + "\""), nil
13902 }
13903}
13904
13905type OxmIdTunSrc struct {
13906 *OxmId
13907}
13908
13909type IOxmIdTunSrc interface {
13910 IOxmId
13911}
13912
13913func (self *OxmIdTunSrc) Serialize(encoder *goloxi.Encoder) error {
13914 if err := self.OxmId.Serialize(encoder); err != nil {
13915 return err
13916 }
13917
13918 return nil
13919}
13920
13921func DecodeOxmIdTunSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunSrc, error) {
13922 _oxmidtunsrc := &OxmIdTunSrc{OxmId: parent}
13923 return _oxmidtunsrc, nil
13924}
13925
13926func NewOxmIdTunSrc() *OxmIdTunSrc {
13927 obj := &OxmIdTunSrc{
13928 OxmId: NewOxmId(81412),
13929 }
13930 return obj
13931}
13932func (self *OxmIdTunSrc) GetOXMName() string {
13933 return "tun_src"
13934}
13935
13936func (self *OxmIdTunSrc) MarshalJSON() ([]byte, error) {
13937 if self.TypeLen == 0 {
13938 return []byte("\"\""), nil
13939 } else {
13940 return []byte("\"" + self.GetOXMName() + "\""), nil
13941 }
13942}
13943
13944type OxmIdTunSrcMasked struct {
13945 *OxmId
13946}
13947
13948type IOxmIdTunSrcMasked interface {
13949 IOxmId
13950}
13951
13952func (self *OxmIdTunSrcMasked) Serialize(encoder *goloxi.Encoder) error {
13953 if err := self.OxmId.Serialize(encoder); err != nil {
13954 return err
13955 }
13956
13957 return nil
13958}
13959
13960func DecodeOxmIdTunSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunSrcMasked, error) {
13961 _oxmidtunsrcmasked := &OxmIdTunSrcMasked{OxmId: parent}
13962 return _oxmidtunsrcmasked, nil
13963}
13964
13965func NewOxmIdTunSrcMasked() *OxmIdTunSrcMasked {
13966 obj := &OxmIdTunSrcMasked{
13967 OxmId: NewOxmId(81672),
13968 }
13969 return obj
13970}
13971func (self *OxmIdTunSrcMasked) GetOXMName() string {
13972 return "tun_src_masked"
13973}
13974
13975func (self *OxmIdTunSrcMasked) MarshalJSON() ([]byte, error) {
13976 if self.TypeLen == 0 {
13977 return []byte("\"\""), nil
13978 } else {
13979 return []byte("\"" + self.GetOXMName() + "\""), nil
13980 }
13981}
13982
13983type OxmIdUdpDst struct {
13984 *OxmId
13985}
13986
13987type IOxmIdUdpDst interface {
13988 IOxmId
13989}
13990
13991func (self *OxmIdUdpDst) Serialize(encoder *goloxi.Encoder) error {
13992 if err := self.OxmId.Serialize(encoder); err != nil {
13993 return err
13994 }
13995
13996 return nil
13997}
13998
13999func DecodeOxmIdUdpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpDst, error) {
14000 _oxmidudpdst := &OxmIdUdpDst{OxmId: parent}
14001 return _oxmidudpdst, nil
14002}
14003
14004func NewOxmIdUdpDst() *OxmIdUdpDst {
14005 obj := &OxmIdUdpDst{
14006 OxmId: NewOxmId(6146),
14007 }
14008 return obj
14009}
14010func (self *OxmIdUdpDst) GetOXMName() string {
14011 return "udp_dst"
14012}
14013
14014func (self *OxmIdUdpDst) MarshalJSON() ([]byte, error) {
14015 if self.TypeLen == 0 {
14016 return []byte("\"\""), nil
14017 } else {
14018 return []byte("\"" + self.GetOXMName() + "\""), nil
14019 }
14020}
14021
14022type OxmIdUdpDstMasked struct {
14023 *OxmId
14024}
14025
14026type IOxmIdUdpDstMasked interface {
14027 IOxmId
14028}
14029
14030func (self *OxmIdUdpDstMasked) Serialize(encoder *goloxi.Encoder) error {
14031 if err := self.OxmId.Serialize(encoder); err != nil {
14032 return err
14033 }
14034
14035 return nil
14036}
14037
14038func DecodeOxmIdUdpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpDstMasked, error) {
14039 _oxmidudpdstmasked := &OxmIdUdpDstMasked{OxmId: parent}
14040 return _oxmidudpdstmasked, nil
14041}
14042
14043func NewOxmIdUdpDstMasked() *OxmIdUdpDstMasked {
14044 obj := &OxmIdUdpDstMasked{
14045 OxmId: NewOxmId(6404),
14046 }
14047 return obj
14048}
14049func (self *OxmIdUdpDstMasked) GetOXMName() string {
14050 return "udp_dst_masked"
14051}
14052
14053func (self *OxmIdUdpDstMasked) MarshalJSON() ([]byte, error) {
14054 if self.TypeLen == 0 {
14055 return []byte("\"\""), nil
14056 } else {
14057 return []byte("\"" + self.GetOXMName() + "\""), nil
14058 }
14059}
14060
14061type OxmIdUdpSrc struct {
14062 *OxmId
14063}
14064
14065type IOxmIdUdpSrc interface {
14066 IOxmId
14067}
14068
14069func (self *OxmIdUdpSrc) Serialize(encoder *goloxi.Encoder) error {
14070 if err := self.OxmId.Serialize(encoder); err != nil {
14071 return err
14072 }
14073
14074 return nil
14075}
14076
14077func DecodeOxmIdUdpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpSrc, error) {
14078 _oxmidudpsrc := &OxmIdUdpSrc{OxmId: parent}
14079 return _oxmidudpsrc, nil
14080}
14081
14082func NewOxmIdUdpSrc() *OxmIdUdpSrc {
14083 obj := &OxmIdUdpSrc{
14084 OxmId: NewOxmId(5634),
14085 }
14086 return obj
14087}
14088func (self *OxmIdUdpSrc) GetOXMName() string {
14089 return "udp_src"
14090}
14091
14092func (self *OxmIdUdpSrc) MarshalJSON() ([]byte, error) {
14093 if self.TypeLen == 0 {
14094 return []byte("\"\""), nil
14095 } else {
14096 return []byte("\"" + self.GetOXMName() + "\""), nil
14097 }
14098}
14099
14100type OxmIdUdpSrcMasked struct {
14101 *OxmId
14102}
14103
14104type IOxmIdUdpSrcMasked interface {
14105 IOxmId
14106}
14107
14108func (self *OxmIdUdpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
14109 if err := self.OxmId.Serialize(encoder); err != nil {
14110 return err
14111 }
14112
14113 return nil
14114}
14115
14116func DecodeOxmIdUdpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpSrcMasked, error) {
14117 _oxmidudpsrcmasked := &OxmIdUdpSrcMasked{OxmId: parent}
14118 return _oxmidudpsrcmasked, nil
14119}
14120
14121func NewOxmIdUdpSrcMasked() *OxmIdUdpSrcMasked {
14122 obj := &OxmIdUdpSrcMasked{
14123 OxmId: NewOxmId(5892),
14124 }
14125 return obj
14126}
14127func (self *OxmIdUdpSrcMasked) GetOXMName() string {
14128 return "udp_src_masked"
14129}
14130
14131func (self *OxmIdUdpSrcMasked) MarshalJSON() ([]byte, error) {
14132 if self.TypeLen == 0 {
14133 return []byte("\"\""), nil
14134 } else {
14135 return []byte("\"" + self.GetOXMName() + "\""), nil
14136 }
14137}
14138
14139type OxmIdVlanTci struct {
14140 *OxmId
14141}
14142
14143type IOxmIdVlanTci interface {
14144 IOxmId
14145}
14146
14147func (self *OxmIdVlanTci) Serialize(encoder *goloxi.Encoder) error {
14148 if err := self.OxmId.Serialize(encoder); err != nil {
14149 return err
14150 }
14151
14152 return nil
14153}
14154
14155func DecodeOxmIdVlanTci(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanTci, error) {
14156 _oxmidvlantci := &OxmIdVlanTci{OxmId: parent}
14157 return _oxmidvlantci, nil
14158}
14159
14160func NewOxmIdVlanTci() *OxmIdVlanTci {
14161 obj := &OxmIdVlanTci{
14162 OxmId: NewOxmId(2050),
14163 }
14164 return obj
14165}
14166func (self *OxmIdVlanTci) GetOXMName() string {
14167 return "vlan_tci"
14168}
14169
14170func (self *OxmIdVlanTci) MarshalJSON() ([]byte, error) {
14171 if self.TypeLen == 0 {
14172 return []byte("\"\""), nil
14173 } else {
14174 return []byte("\"" + self.GetOXMName() + "\""), nil
14175 }
14176}
14177
14178type OxmIdVlanTciMasked struct {
14179 *OxmId
14180}
14181
14182type IOxmIdVlanTciMasked interface {
14183 IOxmId
14184}
14185
14186func (self *OxmIdVlanTciMasked) Serialize(encoder *goloxi.Encoder) error {
14187 if err := self.OxmId.Serialize(encoder); err != nil {
14188 return err
14189 }
14190
14191 return nil
14192}
14193
14194func DecodeOxmIdVlanTciMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanTciMasked, error) {
14195 _oxmidvlantcimasked := &OxmIdVlanTciMasked{OxmId: parent}
14196 return _oxmidvlantcimasked, nil
14197}
14198
14199func NewOxmIdVlanTciMasked() *OxmIdVlanTciMasked {
14200 obj := &OxmIdVlanTciMasked{
14201 OxmId: NewOxmId(2308),
14202 }
14203 return obj
14204}
14205func (self *OxmIdVlanTciMasked) GetOXMName() string {
14206 return "vlan_tci_masked"
14207}
14208
14209func (self *OxmIdVlanTciMasked) MarshalJSON() ([]byte, error) {
14210 if self.TypeLen == 0 {
14211 return []byte("\"\""), nil
14212 } else {
14213 return []byte("\"" + self.GetOXMName() + "\""), nil
14214 }
14215}
14216
14217type OxmIdXxreg0 struct {
14218 *OxmId
14219}
14220
14221type IOxmIdXxreg0 interface {
14222 IOxmId
14223}
14224
14225func (self *OxmIdXxreg0) Serialize(encoder *goloxi.Encoder) error {
14226 if err := self.OxmId.Serialize(encoder); err != nil {
14227 return err
14228 }
14229
14230 return nil
14231}
14232
14233func DecodeOxmIdXxreg0(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg0, error) {
14234 _oxmidxxreg0 := &OxmIdXxreg0{OxmId: parent}
14235 return _oxmidxxreg0, nil
14236}
14237
14238func NewOxmIdXxreg0() *OxmIdXxreg0 {
14239 obj := &OxmIdXxreg0{
14240 OxmId: NewOxmId(122384),
14241 }
14242 return obj
14243}
14244func (self *OxmIdXxreg0) GetOXMName() string {
14245 return "xxreg0"
14246}
14247
14248func (self *OxmIdXxreg0) MarshalJSON() ([]byte, error) {
14249 if self.TypeLen == 0 {
14250 return []byte("\"\""), nil
14251 } else {
14252 return []byte("\"" + self.GetOXMName() + "\""), nil
14253 }
14254}
14255
14256type OxmIdXxreg0Masked struct {
14257 *OxmId
14258}
14259
14260type IOxmIdXxreg0Masked interface {
14261 IOxmId
14262}
14263
14264func (self *OxmIdXxreg0Masked) Serialize(encoder *goloxi.Encoder) error {
14265 if err := self.OxmId.Serialize(encoder); err != nil {
14266 return err
14267 }
14268
14269 return nil
14270}
14271
14272func DecodeOxmIdXxreg0Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg0Masked, error) {
14273 _oxmidxxreg0masked := &OxmIdXxreg0Masked{OxmId: parent}
14274 return _oxmidxxreg0masked, nil
14275}
14276
14277func NewOxmIdXxreg0Masked() *OxmIdXxreg0Masked {
14278 obj := &OxmIdXxreg0Masked{
14279 OxmId: NewOxmId(122656),
14280 }
14281 return obj
14282}
14283func (self *OxmIdXxreg0Masked) GetOXMName() string {
14284 return "xxreg0_masked"
14285}
14286
14287func (self *OxmIdXxreg0Masked) MarshalJSON() ([]byte, error) {
14288 if self.TypeLen == 0 {
14289 return []byte("\"\""), nil
14290 } else {
14291 return []byte("\"" + self.GetOXMName() + "\""), nil
14292 }
14293}
14294
14295type OxmIdXxreg1 struct {
14296 *OxmId
14297}
14298
14299type IOxmIdXxreg1 interface {
14300 IOxmId
14301}
14302
14303func (self *OxmIdXxreg1) Serialize(encoder *goloxi.Encoder) error {
14304 if err := self.OxmId.Serialize(encoder); err != nil {
14305 return err
14306 }
14307
14308 return nil
14309}
14310
14311func DecodeOxmIdXxreg1(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg1, error) {
14312 _oxmidxxreg1 := &OxmIdXxreg1{OxmId: parent}
14313 return _oxmidxxreg1, nil
14314}
14315
14316func NewOxmIdXxreg1() *OxmIdXxreg1 {
14317 obj := &OxmIdXxreg1{
14318 OxmId: NewOxmId(122896),
14319 }
14320 return obj
14321}
14322func (self *OxmIdXxreg1) GetOXMName() string {
14323 return "xxreg1"
14324}
14325
14326func (self *OxmIdXxreg1) MarshalJSON() ([]byte, error) {
14327 if self.TypeLen == 0 {
14328 return []byte("\"\""), nil
14329 } else {
14330 return []byte("\"" + self.GetOXMName() + "\""), nil
14331 }
14332}
14333
14334type OxmIdXxreg1Masked struct {
14335 *OxmId
14336}
14337
14338type IOxmIdXxreg1Masked interface {
14339 IOxmId
14340}
14341
14342func (self *OxmIdXxreg1Masked) Serialize(encoder *goloxi.Encoder) error {
14343 if err := self.OxmId.Serialize(encoder); err != nil {
14344 return err
14345 }
14346
14347 return nil
14348}
14349
14350func DecodeOxmIdXxreg1Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg1Masked, error) {
14351 _oxmidxxreg1masked := &OxmIdXxreg1Masked{OxmId: parent}
14352 return _oxmidxxreg1masked, nil
14353}
14354
14355func NewOxmIdXxreg1Masked() *OxmIdXxreg1Masked {
14356 obj := &OxmIdXxreg1Masked{
14357 OxmId: NewOxmId(123168),
14358 }
14359 return obj
14360}
14361func (self *OxmIdXxreg1Masked) GetOXMName() string {
14362 return "xxreg1_masked"
14363}
14364
14365func (self *OxmIdXxreg1Masked) MarshalJSON() ([]byte, error) {
14366 if self.TypeLen == 0 {
14367 return []byte("\"\""), nil
14368 } else {
14369 return []byte("\"" + self.GetOXMName() + "\""), nil
14370 }
14371}
14372
14373type OxmIdXxreg2 struct {
14374 *OxmId
14375}
14376
14377type IOxmIdXxreg2 interface {
14378 IOxmId
14379}
14380
14381func (self *OxmIdXxreg2) Serialize(encoder *goloxi.Encoder) error {
14382 if err := self.OxmId.Serialize(encoder); err != nil {
14383 return err
14384 }
14385
14386 return nil
14387}
14388
14389func DecodeOxmIdXxreg2(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg2, error) {
14390 _oxmidxxreg2 := &OxmIdXxreg2{OxmId: parent}
14391 return _oxmidxxreg2, nil
14392}
14393
14394func NewOxmIdXxreg2() *OxmIdXxreg2 {
14395 obj := &OxmIdXxreg2{
14396 OxmId: NewOxmId(123408),
14397 }
14398 return obj
14399}
14400func (self *OxmIdXxreg2) GetOXMName() string {
14401 return "xxreg2"
14402}
14403
14404func (self *OxmIdXxreg2) MarshalJSON() ([]byte, error) {
14405 if self.TypeLen == 0 {
14406 return []byte("\"\""), nil
14407 } else {
14408 return []byte("\"" + self.GetOXMName() + "\""), nil
14409 }
14410}
14411
14412type OxmIdXxreg2Masked struct {
14413 *OxmId
14414}
14415
14416type IOxmIdXxreg2Masked interface {
14417 IOxmId
14418}
14419
14420func (self *OxmIdXxreg2Masked) Serialize(encoder *goloxi.Encoder) error {
14421 if err := self.OxmId.Serialize(encoder); err != nil {
14422 return err
14423 }
14424
14425 return nil
14426}
14427
14428func DecodeOxmIdXxreg2Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg2Masked, error) {
14429 _oxmidxxreg2masked := &OxmIdXxreg2Masked{OxmId: parent}
14430 return _oxmidxxreg2masked, nil
14431}
14432
14433func NewOxmIdXxreg2Masked() *OxmIdXxreg2Masked {
14434 obj := &OxmIdXxreg2Masked{
14435 OxmId: NewOxmId(123680),
14436 }
14437 return obj
14438}
14439func (self *OxmIdXxreg2Masked) GetOXMName() string {
14440 return "xxreg2_masked"
14441}
14442
14443func (self *OxmIdXxreg2Masked) MarshalJSON() ([]byte, error) {
14444 if self.TypeLen == 0 {
14445 return []byte("\"\""), nil
14446 } else {
14447 return []byte("\"" + self.GetOXMName() + "\""), nil
14448 }
14449}
14450
14451type OxmIdXxreg3 struct {
14452 *OxmId
14453}
14454
14455type IOxmIdXxreg3 interface {
14456 IOxmId
14457}
14458
14459func (self *OxmIdXxreg3) Serialize(encoder *goloxi.Encoder) error {
14460 if err := self.OxmId.Serialize(encoder); err != nil {
14461 return err
14462 }
14463
14464 return nil
14465}
14466
14467func DecodeOxmIdXxreg3(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg3, error) {
14468 _oxmidxxreg3 := &OxmIdXxreg3{OxmId: parent}
14469 return _oxmidxxreg3, nil
14470}
14471
14472func NewOxmIdXxreg3() *OxmIdXxreg3 {
14473 obj := &OxmIdXxreg3{
14474 OxmId: NewOxmId(123920),
14475 }
14476 return obj
14477}
14478func (self *OxmIdXxreg3) GetOXMName() string {
14479 return "xxreg3"
14480}
14481
14482func (self *OxmIdXxreg3) MarshalJSON() ([]byte, error) {
14483 if self.TypeLen == 0 {
14484 return []byte("\"\""), nil
14485 } else {
14486 return []byte("\"" + self.GetOXMName() + "\""), nil
14487 }
14488}
14489
14490type OxmIdXxreg3Masked struct {
14491 *OxmId
14492}
14493
14494type IOxmIdXxreg3Masked interface {
14495 IOxmId
14496}
14497
14498func (self *OxmIdXxreg3Masked) Serialize(encoder *goloxi.Encoder) error {
14499 if err := self.OxmId.Serialize(encoder); err != nil {
14500 return err
14501 }
14502
14503 return nil
14504}
14505
14506func DecodeOxmIdXxreg3Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg3Masked, error) {
14507 _oxmidxxreg3masked := &OxmIdXxreg3Masked{OxmId: parent}
14508 return _oxmidxxreg3masked, nil
14509}
14510
14511func NewOxmIdXxreg3Masked() *OxmIdXxreg3Masked {
14512 obj := &OxmIdXxreg3Masked{
14513 OxmId: NewOxmId(124192),
14514 }
14515 return obj
14516}
14517func (self *OxmIdXxreg3Masked) GetOXMName() string {
14518 return "xxreg3_masked"
14519}
14520
14521func (self *OxmIdXxreg3Masked) MarshalJSON() ([]byte, error) {
14522 if self.TypeLen == 0 {
14523 return []byte("\"\""), nil
14524 } else {
14525 return []byte("\"" + self.GetOXMName() + "\""), nil
14526 }
14527}
14528
14529type OxmIdArpOpMasked struct {
14530 *OxmId
14531}
14532
14533type IOxmIdArpOpMasked interface {
14534 IOxmId
14535}
14536
14537func (self *OxmIdArpOpMasked) Serialize(encoder *goloxi.Encoder) error {
14538 if err := self.OxmId.Serialize(encoder); err != nil {
14539 return err
14540 }
14541
14542 return nil
14543}
14544
14545func DecodeOxmIdArpOpMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpOpMasked, error) {
14546 _oxmidarpopmasked := &OxmIdArpOpMasked{OxmId: parent}
14547 return _oxmidarpopmasked, nil
14548}
14549
14550func NewOxmIdArpOpMasked() *OxmIdArpOpMasked {
14551 obj := &OxmIdArpOpMasked{
14552 OxmId: NewOxmId(2147494660),
14553 }
14554 return obj
14555}
14556func (self *OxmIdArpOpMasked) GetOXMName() string {
14557 return "arp_op_masked"
14558}
14559
14560func (self *OxmIdArpOpMasked) MarshalJSON() ([]byte, error) {
14561 if self.TypeLen == 0 {
14562 return []byte("\"\""), nil
14563 } else {
14564 return []byte("\"" + self.GetOXMName() + "\""), nil
14565 }
14566}
14567
14568type OxmIdConnTrackingIpv6Dst struct {
14569 *OxmId
14570}
14571
14572type IOxmIdConnTrackingIpv6Dst interface {
14573 IOxmId
14574}
14575
14576func (self *OxmIdConnTrackingIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
14577 if err := self.OxmId.Serialize(encoder); err != nil {
14578 return err
14579 }
14580
14581 return nil
14582}
14583
14584func DecodeOxmIdConnTrackingIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6Dst, error) {
14585 _oxmidconntrackingipv6dst := &OxmIdConnTrackingIpv6Dst{OxmId: parent}
14586 return _oxmidconntrackingipv6dst, nil
14587}
14588
14589func NewOxmIdConnTrackingIpv6Dst() *OxmIdConnTrackingIpv6Dst {
14590 obj := &OxmIdConnTrackingIpv6Dst{
14591 OxmId: NewOxmId(128528),
14592 }
14593 return obj
14594}
14595func (self *OxmIdConnTrackingIpv6Dst) GetOXMName() string {
14596 return "conn_tracking_ipv6_dst"
14597}
14598
14599func (self *OxmIdConnTrackingIpv6Dst) MarshalJSON() ([]byte, error) {
14600 if self.TypeLen == 0 {
14601 return []byte("\"\""), nil
14602 } else {
14603 return []byte("\"" + self.GetOXMName() + "\""), nil
14604 }
14605}
14606
14607type OxmIdConnTrackingIpv6DstMasked struct {
14608 *OxmId
14609}
14610
14611type IOxmIdConnTrackingIpv6DstMasked interface {
14612 IOxmId
14613}
14614
14615func (self *OxmIdConnTrackingIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
14616 if err := self.OxmId.Serialize(encoder); err != nil {
14617 return err
14618 }
14619
14620 return nil
14621}
14622
14623func DecodeOxmIdConnTrackingIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6DstMasked, error) {
14624 _oxmidconntrackingipv6dstmasked := &OxmIdConnTrackingIpv6DstMasked{OxmId: parent}
14625 return _oxmidconntrackingipv6dstmasked, nil
14626}
14627
14628func NewOxmIdConnTrackingIpv6DstMasked() *OxmIdConnTrackingIpv6DstMasked {
14629 obj := &OxmIdConnTrackingIpv6DstMasked{
14630 OxmId: NewOxmId(128800),
14631 }
14632 return obj
14633}
14634func (self *OxmIdConnTrackingIpv6DstMasked) GetOXMName() string {
14635 return "conn_tracking_ipv6_dst_masked"
14636}
14637
14638func (self *OxmIdConnTrackingIpv6DstMasked) MarshalJSON() ([]byte, error) {
14639 if self.TypeLen == 0 {
14640 return []byte("\"\""), nil
14641 } else {
14642 return []byte("\"" + self.GetOXMName() + "\""), nil
14643 }
14644}
14645
14646type OxmIdConnTrackingIpv6Src struct {
14647 *OxmId
14648}
14649
14650type IOxmIdConnTrackingIpv6Src interface {
14651 IOxmId
14652}
14653
14654func (self *OxmIdConnTrackingIpv6Src) Serialize(encoder *goloxi.Encoder) error {
14655 if err := self.OxmId.Serialize(encoder); err != nil {
14656 return err
14657 }
14658
14659 return nil
14660}
14661
14662func DecodeOxmIdConnTrackingIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6Src, error) {
14663 _oxmidconntrackingipv6src := &OxmIdConnTrackingIpv6Src{OxmId: parent}
14664 return _oxmidconntrackingipv6src, nil
14665}
14666
14667func NewOxmIdConnTrackingIpv6Src() *OxmIdConnTrackingIpv6Src {
14668 obj := &OxmIdConnTrackingIpv6Src{
14669 OxmId: NewOxmId(128016),
14670 }
14671 return obj
14672}
14673func (self *OxmIdConnTrackingIpv6Src) GetOXMName() string {
14674 return "conn_tracking_ipv6_src"
14675}
14676
14677func (self *OxmIdConnTrackingIpv6Src) MarshalJSON() ([]byte, error) {
14678 if self.TypeLen == 0 {
14679 return []byte("\"\""), nil
14680 } else {
14681 return []byte("\"" + self.GetOXMName() + "\""), nil
14682 }
14683}
14684
14685type OxmIdConnTrackingIpv6SrcMasked struct {
14686 *OxmId
14687}
14688
14689type IOxmIdConnTrackingIpv6SrcMasked interface {
14690 IOxmId
14691}
14692
14693func (self *OxmIdConnTrackingIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
14694 if err := self.OxmId.Serialize(encoder); err != nil {
14695 return err
14696 }
14697
14698 return nil
14699}
14700
14701func DecodeOxmIdConnTrackingIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6SrcMasked, error) {
14702 _oxmidconntrackingipv6srcmasked := &OxmIdConnTrackingIpv6SrcMasked{OxmId: parent}
14703 return _oxmidconntrackingipv6srcmasked, nil
14704}
14705
14706func NewOxmIdConnTrackingIpv6SrcMasked() *OxmIdConnTrackingIpv6SrcMasked {
14707 obj := &OxmIdConnTrackingIpv6SrcMasked{
14708 OxmId: NewOxmId(128288),
14709 }
14710 return obj
14711}
14712func (self *OxmIdConnTrackingIpv6SrcMasked) GetOXMName() string {
14713 return "conn_tracking_ipv6_src_masked"
14714}
14715
14716func (self *OxmIdConnTrackingIpv6SrcMasked) MarshalJSON() ([]byte, error) {
14717 if self.TypeLen == 0 {
14718 return []byte("\"\""), nil
14719 } else {
14720 return []byte("\"" + self.GetOXMName() + "\""), nil
14721 }
14722}
14723
14724type OxmIdConnTrackingLabel struct {
14725 *OxmId
14726}
14727
14728type IOxmIdConnTrackingLabel interface {
14729 IOxmId
14730}
14731
14732func (self *OxmIdConnTrackingLabel) Serialize(encoder *goloxi.Encoder) error {
14733 if err := self.OxmId.Serialize(encoder); err != nil {
14734 return err
14735 }
14736
14737 return nil
14738}
14739
14740func DecodeOxmIdConnTrackingLabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingLabel, error) {
14741 _oxmidconntrackinglabel := &OxmIdConnTrackingLabel{OxmId: parent}
14742 return _oxmidconntrackinglabel, nil
14743}
14744
14745func NewOxmIdConnTrackingLabel() *OxmIdConnTrackingLabel {
14746 obj := &OxmIdConnTrackingLabel{
14747 OxmId: NewOxmId(120848),
14748 }
14749 return obj
14750}
14751func (self *OxmIdConnTrackingLabel) GetOXMName() string {
14752 return "conn_tracking_label"
14753}
14754
14755func (self *OxmIdConnTrackingLabel) MarshalJSON() ([]byte, error) {
14756 if self.TypeLen == 0 {
14757 return []byte("\"\""), nil
14758 } else {
14759 return []byte("\"" + self.GetOXMName() + "\""), nil
14760 }
14761}
14762
14763type OxmIdConnTrackingLabelMasked struct {
14764 *OxmId
14765}
14766
14767type IOxmIdConnTrackingLabelMasked interface {
14768 IOxmId
14769}
14770
14771func (self *OxmIdConnTrackingLabelMasked) Serialize(encoder *goloxi.Encoder) error {
14772 if err := self.OxmId.Serialize(encoder); err != nil {
14773 return err
14774 }
14775
14776 return nil
14777}
14778
14779func DecodeOxmIdConnTrackingLabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingLabelMasked, error) {
14780 _oxmidconntrackinglabelmasked := &OxmIdConnTrackingLabelMasked{OxmId: parent}
14781 return _oxmidconntrackinglabelmasked, nil
14782}
14783
14784func NewOxmIdConnTrackingLabelMasked() *OxmIdConnTrackingLabelMasked {
14785 obj := &OxmIdConnTrackingLabelMasked{
14786 OxmId: NewOxmId(121120),
14787 }
14788 return obj
14789}
14790func (self *OxmIdConnTrackingLabelMasked) GetOXMName() string {
14791 return "conn_tracking_label_masked"
14792}
14793
14794func (self *OxmIdConnTrackingLabelMasked) MarshalJSON() ([]byte, error) {
14795 if self.TypeLen == 0 {
14796 return []byte("\"\""), nil
14797 } else {
14798 return []byte("\"" + self.GetOXMName() + "\""), nil
14799 }
14800}
14801
14802type OxmIdConnTrackingMark struct {
14803 *OxmId
14804}
14805
14806type IOxmIdConnTrackingMark interface {
14807 IOxmId
14808}
14809
14810func (self *OxmIdConnTrackingMark) Serialize(encoder *goloxi.Encoder) error {
14811 if err := self.OxmId.Serialize(encoder); err != nil {
14812 return err
14813 }
14814
14815 return nil
14816}
14817
14818func DecodeOxmIdConnTrackingMark(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingMark, error) {
14819 _oxmidconntrackingmark := &OxmIdConnTrackingMark{OxmId: parent}
14820 return _oxmidconntrackingmark, nil
14821}
14822
14823func NewOxmIdConnTrackingMark() *OxmIdConnTrackingMark {
14824 obj := &OxmIdConnTrackingMark{
14825 OxmId: NewOxmId(120324),
14826 }
14827 return obj
14828}
14829func (self *OxmIdConnTrackingMark) GetOXMName() string {
14830 return "conn_tracking_mark"
14831}
14832
14833func (self *OxmIdConnTrackingMark) MarshalJSON() ([]byte, error) {
14834 if self.TypeLen == 0 {
14835 return []byte("\"\""), nil
14836 } else {
14837 return []byte("\"" + self.GetOXMName() + "\""), nil
14838 }
14839}
14840
14841type OxmIdConnTrackingMarkMasked struct {
14842 *OxmId
14843}
14844
14845type IOxmIdConnTrackingMarkMasked interface {
14846 IOxmId
14847}
14848
14849func (self *OxmIdConnTrackingMarkMasked) Serialize(encoder *goloxi.Encoder) error {
14850 if err := self.OxmId.Serialize(encoder); err != nil {
14851 return err
14852 }
14853
14854 return nil
14855}
14856
14857func DecodeOxmIdConnTrackingMarkMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingMarkMasked, error) {
14858 _oxmidconntrackingmarkmasked := &OxmIdConnTrackingMarkMasked{OxmId: parent}
14859 return _oxmidconntrackingmarkmasked, nil
14860}
14861
14862func NewOxmIdConnTrackingMarkMasked() *OxmIdConnTrackingMarkMasked {
14863 obj := &OxmIdConnTrackingMarkMasked{
14864 OxmId: NewOxmId(120584),
14865 }
14866 return obj
14867}
14868func (self *OxmIdConnTrackingMarkMasked) GetOXMName() string {
14869 return "conn_tracking_mark_masked"
14870}
14871
14872func (self *OxmIdConnTrackingMarkMasked) MarshalJSON() ([]byte, error) {
14873 if self.TypeLen == 0 {
14874 return []byte("\"\""), nil
14875 } else {
14876 return []byte("\"" + self.GetOXMName() + "\""), nil
14877 }
14878}
14879
14880type OxmIdConnTrackingNwDst struct {
14881 *OxmId
14882}
14883
14884type IOxmIdConnTrackingNwDst interface {
14885 IOxmId
14886}
14887
14888func (self *OxmIdConnTrackingNwDst) Serialize(encoder *goloxi.Encoder) error {
14889 if err := self.OxmId.Serialize(encoder); err != nil {
14890 return err
14891 }
14892
14893 return nil
14894}
14895
14896func DecodeOxmIdConnTrackingNwDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwDst, error) {
14897 _oxmidconntrackingnwdst := &OxmIdConnTrackingNwDst{OxmId: parent}
14898 return _oxmidconntrackingnwdst, nil
14899}
14900
14901func NewOxmIdConnTrackingNwDst() *OxmIdConnTrackingNwDst {
14902 obj := &OxmIdConnTrackingNwDst{
14903 OxmId: NewOxmId(127492),
14904 }
14905 return obj
14906}
14907func (self *OxmIdConnTrackingNwDst) GetOXMName() string {
14908 return "conn_tracking_nw_dst"
14909}
14910
14911func (self *OxmIdConnTrackingNwDst) MarshalJSON() ([]byte, error) {
14912 if self.TypeLen == 0 {
14913 return []byte("\"\""), nil
14914 } else {
14915 return []byte("\"" + self.GetOXMName() + "\""), nil
14916 }
14917}
14918
14919type OxmIdConnTrackingNwDstMasked struct {
14920 *OxmId
14921}
14922
14923type IOxmIdConnTrackingNwDstMasked interface {
14924 IOxmId
14925}
14926
14927func (self *OxmIdConnTrackingNwDstMasked) Serialize(encoder *goloxi.Encoder) error {
14928 if err := self.OxmId.Serialize(encoder); err != nil {
14929 return err
14930 }
14931
14932 return nil
14933}
14934
14935func DecodeOxmIdConnTrackingNwDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwDstMasked, error) {
14936 _oxmidconntrackingnwdstmasked := &OxmIdConnTrackingNwDstMasked{OxmId: parent}
14937 return _oxmidconntrackingnwdstmasked, nil
14938}
14939
14940func NewOxmIdConnTrackingNwDstMasked() *OxmIdConnTrackingNwDstMasked {
14941 obj := &OxmIdConnTrackingNwDstMasked{
14942 OxmId: NewOxmId(127752),
14943 }
14944 return obj
14945}
14946func (self *OxmIdConnTrackingNwDstMasked) GetOXMName() string {
14947 return "conn_tracking_nw_dst_masked"
14948}
14949
14950func (self *OxmIdConnTrackingNwDstMasked) MarshalJSON() ([]byte, error) {
14951 if self.TypeLen == 0 {
14952 return []byte("\"\""), nil
14953 } else {
14954 return []byte("\"" + self.GetOXMName() + "\""), nil
14955 }
14956}
14957
14958type OxmIdConnTrackingNwProto struct {
14959 *OxmId
14960}
14961
14962type IOxmIdConnTrackingNwProto interface {
14963 IOxmId
14964}
14965
14966func (self *OxmIdConnTrackingNwProto) Serialize(encoder *goloxi.Encoder) error {
14967 if err := self.OxmId.Serialize(encoder); err != nil {
14968 return err
14969 }
14970
14971 return nil
14972}
14973
14974func DecodeOxmIdConnTrackingNwProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwProto, error) {
14975 _oxmidconntrackingnwproto := &OxmIdConnTrackingNwProto{OxmId: parent}
14976 return _oxmidconntrackingnwproto, nil
14977}
14978
14979func NewOxmIdConnTrackingNwProto() *OxmIdConnTrackingNwProto {
14980 obj := &OxmIdConnTrackingNwProto{
14981 OxmId: NewOxmId(126465),
14982 }
14983 return obj
14984}
14985func (self *OxmIdConnTrackingNwProto) GetOXMName() string {
14986 return "conn_tracking_nw_proto"
14987}
14988
14989func (self *OxmIdConnTrackingNwProto) MarshalJSON() ([]byte, error) {
14990 if self.TypeLen == 0 {
14991 return []byte("\"\""), nil
14992 } else {
14993 return []byte("\"" + self.GetOXMName() + "\""), nil
14994 }
14995}
14996
14997type OxmIdConnTrackingNwProtoMasked struct {
14998 *OxmId
14999}
15000
15001type IOxmIdConnTrackingNwProtoMasked interface {
15002 IOxmId
15003}
15004
15005func (self *OxmIdConnTrackingNwProtoMasked) Serialize(encoder *goloxi.Encoder) error {
15006 if err := self.OxmId.Serialize(encoder); err != nil {
15007 return err
15008 }
15009
15010 return nil
15011}
15012
15013func DecodeOxmIdConnTrackingNwProtoMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwProtoMasked, error) {
15014 _oxmidconntrackingnwprotomasked := &OxmIdConnTrackingNwProtoMasked{OxmId: parent}
15015 return _oxmidconntrackingnwprotomasked, nil
15016}
15017
15018func NewOxmIdConnTrackingNwProtoMasked() *OxmIdConnTrackingNwProtoMasked {
15019 obj := &OxmIdConnTrackingNwProtoMasked{
15020 OxmId: NewOxmId(126722),
15021 }
15022 return obj
15023}
15024func (self *OxmIdConnTrackingNwProtoMasked) GetOXMName() string {
15025 return "conn_tracking_nw_proto_masked"
15026}
15027
15028func (self *OxmIdConnTrackingNwProtoMasked) MarshalJSON() ([]byte, error) {
15029 if self.TypeLen == 0 {
15030 return []byte("\"\""), nil
15031 } else {
15032 return []byte("\"" + self.GetOXMName() + "\""), nil
15033 }
15034}
15035
15036type OxmIdConnTrackingNwSrc struct {
15037 *OxmId
15038}
15039
15040type IOxmIdConnTrackingNwSrc interface {
15041 IOxmId
15042}
15043
15044func (self *OxmIdConnTrackingNwSrc) Serialize(encoder *goloxi.Encoder) error {
15045 if err := self.OxmId.Serialize(encoder); err != nil {
15046 return err
15047 }
15048
15049 return nil
15050}
15051
15052func DecodeOxmIdConnTrackingNwSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwSrc, error) {
15053 _oxmidconntrackingnwsrc := &OxmIdConnTrackingNwSrc{OxmId: parent}
15054 return _oxmidconntrackingnwsrc, nil
15055}
15056
15057func NewOxmIdConnTrackingNwSrc() *OxmIdConnTrackingNwSrc {
15058 obj := &OxmIdConnTrackingNwSrc{
15059 OxmId: NewOxmId(126980),
15060 }
15061 return obj
15062}
15063func (self *OxmIdConnTrackingNwSrc) GetOXMName() string {
15064 return "conn_tracking_nw_src"
15065}
15066
15067func (self *OxmIdConnTrackingNwSrc) MarshalJSON() ([]byte, error) {
15068 if self.TypeLen == 0 {
15069 return []byte("\"\""), nil
15070 } else {
15071 return []byte("\"" + self.GetOXMName() + "\""), nil
15072 }
15073}
15074
15075type OxmIdConnTrackingNwSrcMasked struct {
15076 *OxmId
15077}
15078
15079type IOxmIdConnTrackingNwSrcMasked interface {
15080 IOxmId
15081}
15082
15083func (self *OxmIdConnTrackingNwSrcMasked) Serialize(encoder *goloxi.Encoder) error {
15084 if err := self.OxmId.Serialize(encoder); err != nil {
15085 return err
15086 }
15087
15088 return nil
15089}
15090
15091func DecodeOxmIdConnTrackingNwSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwSrcMasked, error) {
15092 _oxmidconntrackingnwsrcmasked := &OxmIdConnTrackingNwSrcMasked{OxmId: parent}
15093 return _oxmidconntrackingnwsrcmasked, nil
15094}
15095
15096func NewOxmIdConnTrackingNwSrcMasked() *OxmIdConnTrackingNwSrcMasked {
15097 obj := &OxmIdConnTrackingNwSrcMasked{
15098 OxmId: NewOxmId(127240),
15099 }
15100 return obj
15101}
15102func (self *OxmIdConnTrackingNwSrcMasked) GetOXMName() string {
15103 return "conn_tracking_nw_src_masked"
15104}
15105
15106func (self *OxmIdConnTrackingNwSrcMasked) MarshalJSON() ([]byte, error) {
15107 if self.TypeLen == 0 {
15108 return []byte("\"\""), nil
15109 } else {
15110 return []byte("\"" + self.GetOXMName() + "\""), nil
15111 }
15112}
15113
15114type OxmIdConnTrackingState struct {
15115 *OxmId
15116}
15117
15118type IOxmIdConnTrackingState interface {
15119 IOxmId
15120}
15121
15122func (self *OxmIdConnTrackingState) Serialize(encoder *goloxi.Encoder) error {
15123 if err := self.OxmId.Serialize(encoder); err != nil {
15124 return err
15125 }
15126
15127 return nil
15128}
15129
15130func DecodeOxmIdConnTrackingState(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingState, error) {
15131 _oxmidconntrackingstate := &OxmIdConnTrackingState{OxmId: parent}
15132 return _oxmidconntrackingstate, nil
15133}
15134
15135func NewOxmIdConnTrackingState() *OxmIdConnTrackingState {
15136 obj := &OxmIdConnTrackingState{
15137 OxmId: NewOxmId(119300),
15138 }
15139 return obj
15140}
15141func (self *OxmIdConnTrackingState) GetOXMName() string {
15142 return "conn_tracking_state"
15143}
15144
15145func (self *OxmIdConnTrackingState) MarshalJSON() ([]byte, error) {
15146 if self.TypeLen == 0 {
15147 return []byte("\"\""), nil
15148 } else {
15149 return []byte("\"" + self.GetOXMName() + "\""), nil
15150 }
15151}
15152
15153type OxmIdConnTrackingStateMasked struct {
15154 *OxmId
15155}
15156
15157type IOxmIdConnTrackingStateMasked interface {
15158 IOxmId
15159}
15160
15161func (self *OxmIdConnTrackingStateMasked) Serialize(encoder *goloxi.Encoder) error {
15162 if err := self.OxmId.Serialize(encoder); err != nil {
15163 return err
15164 }
15165
15166 return nil
15167}
15168
15169func DecodeOxmIdConnTrackingStateMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingStateMasked, error) {
15170 _oxmidconntrackingstatemasked := &OxmIdConnTrackingStateMasked{OxmId: parent}
15171 return _oxmidconntrackingstatemasked, nil
15172}
15173
15174func NewOxmIdConnTrackingStateMasked() *OxmIdConnTrackingStateMasked {
15175 obj := &OxmIdConnTrackingStateMasked{
15176 OxmId: NewOxmId(119560),
15177 }
15178 return obj
15179}
15180func (self *OxmIdConnTrackingStateMasked) GetOXMName() string {
15181 return "conn_tracking_state_masked"
15182}
15183
15184func (self *OxmIdConnTrackingStateMasked) MarshalJSON() ([]byte, error) {
15185 if self.TypeLen == 0 {
15186 return []byte("\"\""), nil
15187 } else {
15188 return []byte("\"" + self.GetOXMName() + "\""), nil
15189 }
15190}
15191
15192type OxmIdConnTrackingTpDst struct {
15193 *OxmId
15194}
15195
15196type IOxmIdConnTrackingTpDst interface {
15197 IOxmId
15198}
15199
15200func (self *OxmIdConnTrackingTpDst) Serialize(encoder *goloxi.Encoder) error {
15201 if err := self.OxmId.Serialize(encoder); err != nil {
15202 return err
15203 }
15204
15205 return nil
15206}
15207
15208func DecodeOxmIdConnTrackingTpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpDst, error) {
15209 _oxmidconntrackingtpdst := &OxmIdConnTrackingTpDst{OxmId: parent}
15210 return _oxmidconntrackingtpdst, nil
15211}
15212
15213func NewOxmIdConnTrackingTpDst() *OxmIdConnTrackingTpDst {
15214 obj := &OxmIdConnTrackingTpDst{
15215 OxmId: NewOxmId(129538),
15216 }
15217 return obj
15218}
15219func (self *OxmIdConnTrackingTpDst) GetOXMName() string {
15220 return "conn_tracking_tp_dst"
15221}
15222
15223func (self *OxmIdConnTrackingTpDst) MarshalJSON() ([]byte, error) {
15224 if self.TypeLen == 0 {
15225 return []byte("\"\""), nil
15226 } else {
15227 return []byte("\"" + self.GetOXMName() + "\""), nil
15228 }
15229}
15230
15231type OxmIdConnTrackingTpDstMasked struct {
15232 *OxmId
15233}
15234
15235type IOxmIdConnTrackingTpDstMasked interface {
15236 IOxmId
15237}
15238
15239func (self *OxmIdConnTrackingTpDstMasked) Serialize(encoder *goloxi.Encoder) error {
15240 if err := self.OxmId.Serialize(encoder); err != nil {
15241 return err
15242 }
15243
15244 return nil
15245}
15246
15247func DecodeOxmIdConnTrackingTpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpDstMasked, error) {
15248 _oxmidconntrackingtpdstmasked := &OxmIdConnTrackingTpDstMasked{OxmId: parent}
15249 return _oxmidconntrackingtpdstmasked, nil
15250}
15251
15252func NewOxmIdConnTrackingTpDstMasked() *OxmIdConnTrackingTpDstMasked {
15253 obj := &OxmIdConnTrackingTpDstMasked{
15254 OxmId: NewOxmId(129796),
15255 }
15256 return obj
15257}
15258func (self *OxmIdConnTrackingTpDstMasked) GetOXMName() string {
15259 return "conn_tracking_tp_dst_masked"
15260}
15261
15262func (self *OxmIdConnTrackingTpDstMasked) MarshalJSON() ([]byte, error) {
15263 if self.TypeLen == 0 {
15264 return []byte("\"\""), nil
15265 } else {
15266 return []byte("\"" + self.GetOXMName() + "\""), nil
15267 }
15268}
15269
15270type OxmIdConnTrackingTpSrc struct {
15271 *OxmId
15272}
15273
15274type IOxmIdConnTrackingTpSrc interface {
15275 IOxmId
15276}
15277
15278func (self *OxmIdConnTrackingTpSrc) Serialize(encoder *goloxi.Encoder) error {
15279 if err := self.OxmId.Serialize(encoder); err != nil {
15280 return err
15281 }
15282
15283 return nil
15284}
15285
15286func DecodeOxmIdConnTrackingTpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpSrc, error) {
15287 _oxmidconntrackingtpsrc := &OxmIdConnTrackingTpSrc{OxmId: parent}
15288 return _oxmidconntrackingtpsrc, nil
15289}
15290
15291func NewOxmIdConnTrackingTpSrc() *OxmIdConnTrackingTpSrc {
15292 obj := &OxmIdConnTrackingTpSrc{
15293 OxmId: NewOxmId(129026),
15294 }
15295 return obj
15296}
15297func (self *OxmIdConnTrackingTpSrc) GetOXMName() string {
15298 return "conn_tracking_tp_src"
15299}
15300
15301func (self *OxmIdConnTrackingTpSrc) MarshalJSON() ([]byte, error) {
15302 if self.TypeLen == 0 {
15303 return []byte("\"\""), nil
15304 } else {
15305 return []byte("\"" + self.GetOXMName() + "\""), nil
15306 }
15307}
15308
15309type OxmIdConnTrackingTpSrcMasked struct {
15310 *OxmId
15311}
15312
15313type IOxmIdConnTrackingTpSrcMasked interface {
15314 IOxmId
15315}
15316
15317func (self *OxmIdConnTrackingTpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
15318 if err := self.OxmId.Serialize(encoder); err != nil {
15319 return err
15320 }
15321
15322 return nil
15323}
15324
15325func DecodeOxmIdConnTrackingTpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpSrcMasked, error) {
15326 _oxmidconntrackingtpsrcmasked := &OxmIdConnTrackingTpSrcMasked{OxmId: parent}
15327 return _oxmidconntrackingtpsrcmasked, nil
15328}
15329
15330func NewOxmIdConnTrackingTpSrcMasked() *OxmIdConnTrackingTpSrcMasked {
15331 obj := &OxmIdConnTrackingTpSrcMasked{
15332 OxmId: NewOxmId(129284),
15333 }
15334 return obj
15335}
15336func (self *OxmIdConnTrackingTpSrcMasked) GetOXMName() string {
15337 return "conn_tracking_tp_src_masked"
15338}
15339
15340func (self *OxmIdConnTrackingTpSrcMasked) MarshalJSON() ([]byte, error) {
15341 if self.TypeLen == 0 {
15342 return []byte("\"\""), nil
15343 } else {
15344 return []byte("\"" + self.GetOXMName() + "\""), nil
15345 }
15346}
15347
15348type OxmIdConnTrackingZone struct {
15349 *OxmId
15350}
15351
15352type IOxmIdConnTrackingZone interface {
15353 IOxmId
15354}
15355
15356func (self *OxmIdConnTrackingZone) Serialize(encoder *goloxi.Encoder) error {
15357 if err := self.OxmId.Serialize(encoder); err != nil {
15358 return err
15359 }
15360
15361 return nil
15362}
15363
15364func DecodeOxmIdConnTrackingZone(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingZone, error) {
15365 _oxmidconntrackingzone := &OxmIdConnTrackingZone{OxmId: parent}
15366 return _oxmidconntrackingzone, nil
15367}
15368
15369func NewOxmIdConnTrackingZone() *OxmIdConnTrackingZone {
15370 obj := &OxmIdConnTrackingZone{
15371 OxmId: NewOxmId(119810),
15372 }
15373 return obj
15374}
15375func (self *OxmIdConnTrackingZone) GetOXMName() string {
15376 return "conn_tracking_zone"
15377}
15378
15379func (self *OxmIdConnTrackingZone) MarshalJSON() ([]byte, error) {
15380 if self.TypeLen == 0 {
15381 return []byte("\"\""), nil
15382 } else {
15383 return []byte("\"" + self.GetOXMName() + "\""), nil
15384 }
15385}
15386
15387type OxmIdConnTrackingZoneMasked struct {
15388 *OxmId
15389}
15390
15391type IOxmIdConnTrackingZoneMasked interface {
15392 IOxmId
15393}
15394
15395func (self *OxmIdConnTrackingZoneMasked) Serialize(encoder *goloxi.Encoder) error {
15396 if err := self.OxmId.Serialize(encoder); err != nil {
15397 return err
15398 }
15399
15400 return nil
15401}
15402
15403func DecodeOxmIdConnTrackingZoneMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingZoneMasked, error) {
15404 _oxmidconntrackingzonemasked := &OxmIdConnTrackingZoneMasked{OxmId: parent}
15405 return _oxmidconntrackingzonemasked, nil
15406}
15407
15408func NewOxmIdConnTrackingZoneMasked() *OxmIdConnTrackingZoneMasked {
15409 obj := &OxmIdConnTrackingZoneMasked{
15410 OxmId: NewOxmId(120068),
15411 }
15412 return obj
15413}
15414func (self *OxmIdConnTrackingZoneMasked) GetOXMName() string {
15415 return "conn_tracking_zone_masked"
15416}
15417
15418func (self *OxmIdConnTrackingZoneMasked) MarshalJSON() ([]byte, error) {
15419 if self.TypeLen == 0 {
15420 return []byte("\"\""), nil
15421 } else {
15422 return []byte("\"" + self.GetOXMName() + "\""), nil
15423 }
15424}
15425
15426type OxmIdEthTypeMasked struct {
15427 *OxmId
15428}
15429
15430type IOxmIdEthTypeMasked interface {
15431 IOxmId
15432}
15433
15434func (self *OxmIdEthTypeMasked) Serialize(encoder *goloxi.Encoder) error {
15435 if err := self.OxmId.Serialize(encoder); err != nil {
15436 return err
15437 }
15438
15439 return nil
15440}
15441
15442func DecodeOxmIdEthTypeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthTypeMasked, error) {
15443 _oxmidethtypemasked := &OxmIdEthTypeMasked{OxmId: parent}
15444 return _oxmidethtypemasked, nil
15445}
15446
15447func NewOxmIdEthTypeMasked() *OxmIdEthTypeMasked {
15448 obj := &OxmIdEthTypeMasked{
15449 OxmId: NewOxmId(2147486468),
15450 }
15451 return obj
15452}
15453func (self *OxmIdEthTypeMasked) GetOXMName() string {
15454 return "eth_type_masked"
15455}
15456
15457func (self *OxmIdEthTypeMasked) MarshalJSON() ([]byte, error) {
15458 if self.TypeLen == 0 {
15459 return []byte("\"\""), nil
15460 } else {
15461 return []byte("\"" + self.GetOXMName() + "\""), nil
15462 }
15463}
15464
15465type OxmIdIcmpv4Code struct {
15466 *OxmId
15467}
15468
15469type IOxmIdIcmpv4Code interface {
15470 IOxmId
15471}
15472
15473func (self *OxmIdIcmpv4Code) Serialize(encoder *goloxi.Encoder) error {
15474 if err := self.OxmId.Serialize(encoder); err != nil {
15475 return err
15476 }
15477
15478 return nil
15479}
15480
15481func DecodeOxmIdIcmpv4Code(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4Code, error) {
15482 _oxmidicmpv4code := &OxmIdIcmpv4Code{OxmId: parent}
15483 return _oxmidicmpv4code, nil
15484}
15485
15486func NewOxmIdIcmpv4Code() *OxmIdIcmpv4Code {
15487 obj := &OxmIdIcmpv4Code{
15488 OxmId: NewOxmId(2147493889),
15489 }
15490 return obj
15491}
15492func (self *OxmIdIcmpv4Code) GetOXMName() string {
15493 return "icmpv4_code"
15494}
15495
15496func (self *OxmIdIcmpv4Code) MarshalJSON() ([]byte, error) {
15497 if self.TypeLen == 0 {
15498 return []byte("\"\""), nil
15499 } else {
15500 return []byte("\"" + self.GetOXMName() + "\""), nil
15501 }
15502}
15503
15504type OxmIdIcmpv4CodeMasked struct {
15505 *OxmId
15506}
15507
15508type IOxmIdIcmpv4CodeMasked interface {
15509 IOxmId
15510}
15511
15512func (self *OxmIdIcmpv4CodeMasked) Serialize(encoder *goloxi.Encoder) error {
15513 if err := self.OxmId.Serialize(encoder); err != nil {
15514 return err
15515 }
15516
15517 return nil
15518}
15519
15520func DecodeOxmIdIcmpv4CodeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4CodeMasked, error) {
15521 _oxmidicmpv4codemasked := &OxmIdIcmpv4CodeMasked{OxmId: parent}
15522 return _oxmidicmpv4codemasked, nil
15523}
15524
15525func NewOxmIdIcmpv4CodeMasked() *OxmIdIcmpv4CodeMasked {
15526 obj := &OxmIdIcmpv4CodeMasked{
15527 OxmId: NewOxmId(2147494146),
15528 }
15529 return obj
15530}
15531func (self *OxmIdIcmpv4CodeMasked) GetOXMName() string {
15532 return "icmpv4_code_masked"
15533}
15534
15535func (self *OxmIdIcmpv4CodeMasked) MarshalJSON() ([]byte, error) {
15536 if self.TypeLen == 0 {
15537 return []byte("\"\""), nil
15538 } else {
15539 return []byte("\"" + self.GetOXMName() + "\""), nil
15540 }
15541}
15542
15543type OxmIdIcmpv4Type struct {
15544 *OxmId
15545}
15546
15547type IOxmIdIcmpv4Type interface {
15548 IOxmId
15549}
15550
15551func (self *OxmIdIcmpv4Type) Serialize(encoder *goloxi.Encoder) error {
15552 if err := self.OxmId.Serialize(encoder); err != nil {
15553 return err
15554 }
15555
15556 return nil
15557}
15558
15559func DecodeOxmIdIcmpv4Type(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4Type, error) {
15560 _oxmidicmpv4type := &OxmIdIcmpv4Type{OxmId: parent}
15561 return _oxmidicmpv4type, nil
15562}
15563
15564func NewOxmIdIcmpv4Type() *OxmIdIcmpv4Type {
15565 obj := &OxmIdIcmpv4Type{
15566 OxmId: NewOxmId(2147493377),
15567 }
15568 return obj
15569}
15570func (self *OxmIdIcmpv4Type) GetOXMName() string {
15571 return "icmpv4_type"
15572}
15573
15574func (self *OxmIdIcmpv4Type) MarshalJSON() ([]byte, error) {
15575 if self.TypeLen == 0 {
15576 return []byte("\"\""), nil
15577 } else {
15578 return []byte("\"" + self.GetOXMName() + "\""), nil
15579 }
15580}
15581
15582type OxmIdIcmpv4TypeMasked struct {
15583 *OxmId
15584}
15585
15586type IOxmIdIcmpv4TypeMasked interface {
15587 IOxmId
15588}
15589
15590func (self *OxmIdIcmpv4TypeMasked) Serialize(encoder *goloxi.Encoder) error {
15591 if err := self.OxmId.Serialize(encoder); err != nil {
15592 return err
15593 }
15594
15595 return nil
15596}
15597
15598func DecodeOxmIdIcmpv4TypeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4TypeMasked, error) {
15599 _oxmidicmpv4typemasked := &OxmIdIcmpv4TypeMasked{OxmId: parent}
15600 return _oxmidicmpv4typemasked, nil
15601}
15602
15603func NewOxmIdIcmpv4TypeMasked() *OxmIdIcmpv4TypeMasked {
15604 obj := &OxmIdIcmpv4TypeMasked{
15605 OxmId: NewOxmId(2147493634),
15606 }
15607 return obj
15608}
15609func (self *OxmIdIcmpv4TypeMasked) GetOXMName() string {
15610 return "icmpv4_type_masked"
15611}
15612
15613func (self *OxmIdIcmpv4TypeMasked) MarshalJSON() ([]byte, error) {
15614 if self.TypeLen == 0 {
15615 return []byte("\"\""), nil
15616 } else {
15617 return []byte("\"" + self.GetOXMName() + "\""), nil
15618 }
15619}
15620
15621type OxmIdIcmpv6CodeMasked struct {
15622 *OxmId
15623}
15624
15625type IOxmIdIcmpv6CodeMasked interface {
15626 IOxmId
15627}
15628
15629func (self *OxmIdIcmpv6CodeMasked) Serialize(encoder *goloxi.Encoder) error {
15630 if err := self.OxmId.Serialize(encoder); err != nil {
15631 return err
15632 }
15633
15634 return nil
15635}
15636
15637func DecodeOxmIdIcmpv6CodeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6CodeMasked, error) {
15638 _oxmidicmpv6codemasked := &OxmIdIcmpv6CodeMasked{OxmId: parent}
15639 return _oxmidicmpv6codemasked, nil
15640}
15641
15642func NewOxmIdIcmpv6CodeMasked() *OxmIdIcmpv6CodeMasked {
15643 obj := &OxmIdIcmpv6CodeMasked{
15644 OxmId: NewOxmId(2147499266),
15645 }
15646 return obj
15647}
15648func (self *OxmIdIcmpv6CodeMasked) GetOXMName() string {
15649 return "icmpv6_code_masked"
15650}
15651
15652func (self *OxmIdIcmpv6CodeMasked) MarshalJSON() ([]byte, error) {
15653 if self.TypeLen == 0 {
15654 return []byte("\"\""), nil
15655 } else {
15656 return []byte("\"" + self.GetOXMName() + "\""), nil
15657 }
15658}
15659
15660type OxmIdIcmpv6TypeMasked struct {
15661 *OxmId
15662}
15663
15664type IOxmIdIcmpv6TypeMasked interface {
15665 IOxmId
15666}
15667
15668func (self *OxmIdIcmpv6TypeMasked) Serialize(encoder *goloxi.Encoder) error {
15669 if err := self.OxmId.Serialize(encoder); err != nil {
15670 return err
15671 }
15672
15673 return nil
15674}
15675
15676func DecodeOxmIdIcmpv6TypeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6TypeMasked, error) {
15677 _oxmidicmpv6typemasked := &OxmIdIcmpv6TypeMasked{OxmId: parent}
15678 return _oxmidicmpv6typemasked, nil
15679}
15680
15681func NewOxmIdIcmpv6TypeMasked() *OxmIdIcmpv6TypeMasked {
15682 obj := &OxmIdIcmpv6TypeMasked{
15683 OxmId: NewOxmId(2147498754),
15684 }
15685 return obj
15686}
15687func (self *OxmIdIcmpv6TypeMasked) GetOXMName() string {
15688 return "icmpv6_type_masked"
15689}
15690
15691func (self *OxmIdIcmpv6TypeMasked) MarshalJSON() ([]byte, error) {
15692 if self.TypeLen == 0 {
15693 return []byte("\"\""), nil
15694 } else {
15695 return []byte("\"" + self.GetOXMName() + "\""), nil
15696 }
15697}
15698
15699type OxmIdInPhyPort struct {
15700 *OxmId
15701}
15702
15703type IOxmIdInPhyPort interface {
15704 IOxmId
15705}
15706
15707func (self *OxmIdInPhyPort) Serialize(encoder *goloxi.Encoder) error {
15708 if err := self.OxmId.Serialize(encoder); err != nil {
15709 return err
15710 }
15711
15712 return nil
15713}
15714
15715func DecodeOxmIdInPhyPort(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPhyPort, error) {
15716 _oxmidinphyport := &OxmIdInPhyPort{OxmId: parent}
15717 return _oxmidinphyport, nil
15718}
15719
15720func NewOxmIdInPhyPort() *OxmIdInPhyPort {
15721 obj := &OxmIdInPhyPort{
15722 OxmId: NewOxmId(2147484164),
15723 }
15724 return obj
15725}
15726func (self *OxmIdInPhyPort) GetOXMName() string {
15727 return "in_phy_port"
15728}
15729
15730func (self *OxmIdInPhyPort) MarshalJSON() ([]byte, error) {
15731 if self.TypeLen == 0 {
15732 return []byte("\"\""), nil
15733 } else {
15734 return []byte("\"" + self.GetOXMName() + "\""), nil
15735 }
15736}
15737
15738type OxmIdInPhyPortMasked struct {
15739 *OxmId
15740}
15741
15742type IOxmIdInPhyPortMasked interface {
15743 IOxmId
15744}
15745
15746func (self *OxmIdInPhyPortMasked) Serialize(encoder *goloxi.Encoder) error {
15747 if err := self.OxmId.Serialize(encoder); err != nil {
15748 return err
15749 }
15750
15751 return nil
15752}
15753
15754func DecodeOxmIdInPhyPortMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPhyPortMasked, error) {
15755 _oxmidinphyportmasked := &OxmIdInPhyPortMasked{OxmId: parent}
15756 return _oxmidinphyportmasked, nil
15757}
15758
15759func NewOxmIdInPhyPortMasked() *OxmIdInPhyPortMasked {
15760 obj := &OxmIdInPhyPortMasked{
15761 OxmId: NewOxmId(2147484424),
15762 }
15763 return obj
15764}
15765func (self *OxmIdInPhyPortMasked) GetOXMName() string {
15766 return "in_phy_port_masked"
15767}
15768
15769func (self *OxmIdInPhyPortMasked) MarshalJSON() ([]byte, error) {
15770 if self.TypeLen == 0 {
15771 return []byte("\"\""), nil
15772 } else {
15773 return []byte("\"" + self.GetOXMName() + "\""), nil
15774 }
15775}
15776
15777type OxmIdInPortMasked struct {
15778 *OxmId
15779}
15780
15781type IOxmIdInPortMasked interface {
15782 IOxmId
15783}
15784
15785func (self *OxmIdInPortMasked) Serialize(encoder *goloxi.Encoder) error {
15786 if err := self.OxmId.Serialize(encoder); err != nil {
15787 return err
15788 }
15789
15790 return nil
15791}
15792
15793func DecodeOxmIdInPortMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPortMasked, error) {
15794 _oxmidinportmasked := &OxmIdInPortMasked{OxmId: parent}
15795 return _oxmidinportmasked, nil
15796}
15797
15798func NewOxmIdInPortMasked() *OxmIdInPortMasked {
15799 obj := &OxmIdInPortMasked{
15800 OxmId: NewOxmId(2147483912),
15801 }
15802 return obj
15803}
15804func (self *OxmIdInPortMasked) GetOXMName() string {
15805 return "in_port_masked"
15806}
15807
15808func (self *OxmIdInPortMasked) MarshalJSON() ([]byte, error) {
15809 if self.TypeLen == 0 {
15810 return []byte("\"\""), nil
15811 } else {
15812 return []byte("\"" + self.GetOXMName() + "\""), nil
15813 }
15814}
15815
15816type OxmIdIpDscp struct {
15817 *OxmId
15818}
15819
15820type IOxmIdIpDscp interface {
15821 IOxmId
15822}
15823
15824func (self *OxmIdIpDscp) Serialize(encoder *goloxi.Encoder) error {
15825 if err := self.OxmId.Serialize(encoder); err != nil {
15826 return err
15827 }
15828
15829 return nil
15830}
15831
15832func DecodeOxmIdIpDscp(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDscp, error) {
15833 _oxmidipdscp := &OxmIdIpDscp{OxmId: parent}
15834 return _oxmidipdscp, nil
15835}
15836
15837func NewOxmIdIpDscp() *OxmIdIpDscp {
15838 obj := &OxmIdIpDscp{
15839 OxmId: NewOxmId(2147487745),
15840 }
15841 return obj
15842}
15843func (self *OxmIdIpDscp) GetOXMName() string {
15844 return "ip_dscp"
15845}
15846
15847func (self *OxmIdIpDscp) MarshalJSON() ([]byte, error) {
15848 if self.TypeLen == 0 {
15849 return []byte("\"\""), nil
15850 } else {
15851 return []byte("\"" + self.GetOXMName() + "\""), nil
15852 }
15853}
15854
15855type OxmIdIpDscpMasked struct {
15856 *OxmId
15857}
15858
15859type IOxmIdIpDscpMasked interface {
15860 IOxmId
15861}
15862
15863func (self *OxmIdIpDscpMasked) Serialize(encoder *goloxi.Encoder) error {
15864 if err := self.OxmId.Serialize(encoder); err != nil {
15865 return err
15866 }
15867
15868 return nil
15869}
15870
15871func DecodeOxmIdIpDscpMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDscpMasked, error) {
15872 _oxmidipdscpmasked := &OxmIdIpDscpMasked{OxmId: parent}
15873 return _oxmidipdscpmasked, nil
15874}
15875
15876func NewOxmIdIpDscpMasked() *OxmIdIpDscpMasked {
15877 obj := &OxmIdIpDscpMasked{
15878 OxmId: NewOxmId(2147488002),
15879 }
15880 return obj
15881}
15882func (self *OxmIdIpDscpMasked) GetOXMName() string {
15883 return "ip_dscp_masked"
15884}
15885
15886func (self *OxmIdIpDscpMasked) MarshalJSON() ([]byte, error) {
15887 if self.TypeLen == 0 {
15888 return []byte("\"\""), nil
15889 } else {
15890 return []byte("\"" + self.GetOXMName() + "\""), nil
15891 }
15892}
15893
15894type OxmIdIpEcn struct {
15895 *OxmId
15896}
15897
15898type IOxmIdIpEcn interface {
15899 IOxmId
15900}
15901
15902func (self *OxmIdIpEcn) Serialize(encoder *goloxi.Encoder) error {
15903 if err := self.OxmId.Serialize(encoder); err != nil {
15904 return err
15905 }
15906
15907 return nil
15908}
15909
15910func DecodeOxmIdIpEcn(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpEcn, error) {
15911 _oxmidipecn := &OxmIdIpEcn{OxmId: parent}
15912 return _oxmidipecn, nil
15913}
15914
15915func NewOxmIdIpEcn() *OxmIdIpEcn {
15916 obj := &OxmIdIpEcn{
15917 OxmId: NewOxmId(2147488257),
15918 }
15919 return obj
15920}
15921func (self *OxmIdIpEcn) GetOXMName() string {
15922 return "ip_ecn"
15923}
15924
15925func (self *OxmIdIpEcn) MarshalJSON() ([]byte, error) {
15926 if self.TypeLen == 0 {
15927 return []byte("\"\""), nil
15928 } else {
15929 return []byte("\"" + self.GetOXMName() + "\""), nil
15930 }
15931}
15932
15933type OxmIdIpEcnMasked struct {
15934 *OxmId
15935}
15936
15937type IOxmIdIpEcnMasked interface {
15938 IOxmId
15939}
15940
15941func (self *OxmIdIpEcnMasked) Serialize(encoder *goloxi.Encoder) error {
15942 if err := self.OxmId.Serialize(encoder); err != nil {
15943 return err
15944 }
15945
15946 return nil
15947}
15948
15949func DecodeOxmIdIpEcnMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpEcnMasked, error) {
15950 _oxmidipecnmasked := &OxmIdIpEcnMasked{OxmId: parent}
15951 return _oxmidipecnmasked, nil
15952}
15953
15954func NewOxmIdIpEcnMasked() *OxmIdIpEcnMasked {
15955 obj := &OxmIdIpEcnMasked{
15956 OxmId: NewOxmId(2147488514),
15957 }
15958 return obj
15959}
15960func (self *OxmIdIpEcnMasked) GetOXMName() string {
15961 return "ip_ecn_masked"
15962}
15963
15964func (self *OxmIdIpEcnMasked) MarshalJSON() ([]byte, error) {
15965 if self.TypeLen == 0 {
15966 return []byte("\"\""), nil
15967 } else {
15968 return []byte("\"" + self.GetOXMName() + "\""), nil
15969 }
15970}
15971
15972type OxmIdIpProto struct {
15973 *OxmId
15974}
15975
15976type IOxmIdIpProto interface {
15977 IOxmId
15978}
15979
15980func (self *OxmIdIpProto) Serialize(encoder *goloxi.Encoder) error {
15981 if err := self.OxmId.Serialize(encoder); err != nil {
15982 return err
15983 }
15984
15985 return nil
15986}
15987
15988func DecodeOxmIdIpProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpProto, error) {
15989 _oxmidipproto := &OxmIdIpProto{OxmId: parent}
15990 return _oxmidipproto, nil
15991}
15992
15993func NewOxmIdIpProto() *OxmIdIpProto {
15994 obj := &OxmIdIpProto{
15995 OxmId: NewOxmId(2147488769),
15996 }
15997 return obj
15998}
15999func (self *OxmIdIpProto) GetOXMName() string {
16000 return "ip_proto"
16001}
16002
16003func (self *OxmIdIpProto) MarshalJSON() ([]byte, error) {
16004 if self.TypeLen == 0 {
16005 return []byte("\"\""), nil
16006 } else {
16007 return []byte("\"" + self.GetOXMName() + "\""), nil
16008 }
16009}
16010
16011type OxmIdIpProtoMasked struct {
16012 *OxmId
16013}
16014
16015type IOxmIdIpProtoMasked interface {
16016 IOxmId
16017}
16018
16019func (self *OxmIdIpProtoMasked) Serialize(encoder *goloxi.Encoder) error {
16020 if err := self.OxmId.Serialize(encoder); err != nil {
16021 return err
16022 }
16023
16024 return nil
16025}
16026
16027func DecodeOxmIdIpProtoMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpProtoMasked, error) {
16028 _oxmidipprotomasked := &OxmIdIpProtoMasked{OxmId: parent}
16029 return _oxmidipprotomasked, nil
16030}
16031
16032func NewOxmIdIpProtoMasked() *OxmIdIpProtoMasked {
16033 obj := &OxmIdIpProtoMasked{
16034 OxmId: NewOxmId(2147489026),
16035 }
16036 return obj
16037}
16038func (self *OxmIdIpProtoMasked) GetOXMName() string {
16039 return "ip_proto_masked"
16040}
16041
16042func (self *OxmIdIpProtoMasked) MarshalJSON() ([]byte, error) {
16043 if self.TypeLen == 0 {
16044 return []byte("\"\""), nil
16045 } else {
16046 return []byte("\"" + self.GetOXMName() + "\""), nil
16047 }
16048}
16049
16050type OxmIdIpv4Dst struct {
16051 *OxmId
16052}
16053
16054type IOxmIdIpv4Dst interface {
16055 IOxmId
16056}
16057
16058func (self *OxmIdIpv4Dst) Serialize(encoder *goloxi.Encoder) error {
16059 if err := self.OxmId.Serialize(encoder); err != nil {
16060 return err
16061 }
16062
16063 return nil
16064}
16065
16066func DecodeOxmIdIpv4Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4Dst, error) {
16067 _oxmidipv4dst := &OxmIdIpv4Dst{OxmId: parent}
16068 return _oxmidipv4dst, nil
16069}
16070
16071func NewOxmIdIpv4Dst() *OxmIdIpv4Dst {
16072 obj := &OxmIdIpv4Dst{
16073 OxmId: NewOxmId(2147489796),
16074 }
16075 return obj
16076}
16077func (self *OxmIdIpv4Dst) GetOXMName() string {
16078 return "ipv4_dst"
16079}
16080
16081func (self *OxmIdIpv4Dst) MarshalJSON() ([]byte, error) {
16082 if self.TypeLen == 0 {
16083 return []byte("\"\""), nil
16084 } else {
16085 return []byte("\"" + self.GetOXMName() + "\""), nil
16086 }
16087}
16088
16089type OxmIdIpv4DstMasked struct {
16090 *OxmId
16091}
16092
16093type IOxmIdIpv4DstMasked interface {
16094 IOxmId
16095}
16096
16097func (self *OxmIdIpv4DstMasked) Serialize(encoder *goloxi.Encoder) error {
16098 if err := self.OxmId.Serialize(encoder); err != nil {
16099 return err
16100 }
16101
16102 return nil
16103}
16104
16105func DecodeOxmIdIpv4DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4DstMasked, error) {
16106 _oxmidipv4dstmasked := &OxmIdIpv4DstMasked{OxmId: parent}
16107 return _oxmidipv4dstmasked, nil
16108}
16109
16110func NewOxmIdIpv4DstMasked() *OxmIdIpv4DstMasked {
16111 obj := &OxmIdIpv4DstMasked{
16112 OxmId: NewOxmId(2147490056),
16113 }
16114 return obj
16115}
16116func (self *OxmIdIpv4DstMasked) GetOXMName() string {
16117 return "ipv4_dst_masked"
16118}
16119
16120func (self *OxmIdIpv4DstMasked) MarshalJSON() ([]byte, error) {
16121 if self.TypeLen == 0 {
16122 return []byte("\"\""), nil
16123 } else {
16124 return []byte("\"" + self.GetOXMName() + "\""), nil
16125 }
16126}
16127
16128type OxmIdIpv4Src struct {
16129 *OxmId
16130}
16131
16132type IOxmIdIpv4Src interface {
16133 IOxmId
16134}
16135
16136func (self *OxmIdIpv4Src) Serialize(encoder *goloxi.Encoder) error {
16137 if err := self.OxmId.Serialize(encoder); err != nil {
16138 return err
16139 }
16140
16141 return nil
16142}
16143
16144func DecodeOxmIdIpv4Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4Src, error) {
16145 _oxmidipv4src := &OxmIdIpv4Src{OxmId: parent}
16146 return _oxmidipv4src, nil
16147}
16148
16149func NewOxmIdIpv4Src() *OxmIdIpv4Src {
16150 obj := &OxmIdIpv4Src{
16151 OxmId: NewOxmId(2147489284),
16152 }
16153 return obj
16154}
16155func (self *OxmIdIpv4Src) GetOXMName() string {
16156 return "ipv4_src"
16157}
16158
16159func (self *OxmIdIpv4Src) MarshalJSON() ([]byte, error) {
16160 if self.TypeLen == 0 {
16161 return []byte("\"\""), nil
16162 } else {
16163 return []byte("\"" + self.GetOXMName() + "\""), nil
16164 }
16165}
16166
16167type OxmIdIpv4SrcMasked struct {
16168 *OxmId
16169}
16170
16171type IOxmIdIpv4SrcMasked interface {
16172 IOxmId
16173}
16174
16175func (self *OxmIdIpv4SrcMasked) Serialize(encoder *goloxi.Encoder) error {
16176 if err := self.OxmId.Serialize(encoder); err != nil {
16177 return err
16178 }
16179
16180 return nil
16181}
16182
16183func DecodeOxmIdIpv4SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4SrcMasked, error) {
16184 _oxmidipv4srcmasked := &OxmIdIpv4SrcMasked{OxmId: parent}
16185 return _oxmidipv4srcmasked, nil
16186}
16187
16188func NewOxmIdIpv4SrcMasked() *OxmIdIpv4SrcMasked {
16189 obj := &OxmIdIpv4SrcMasked{
16190 OxmId: NewOxmId(2147489544),
16191 }
16192 return obj
16193}
16194func (self *OxmIdIpv4SrcMasked) GetOXMName() string {
16195 return "ipv4_src_masked"
16196}
16197
16198func (self *OxmIdIpv4SrcMasked) MarshalJSON() ([]byte, error) {
16199 if self.TypeLen == 0 {
16200 return []byte("\"\""), nil
16201 } else {
16202 return []byte("\"" + self.GetOXMName() + "\""), nil
16203 }
16204}
16205
16206type OxmIdIpv6Flabel struct {
16207 *OxmId
16208}
16209
16210type IOxmIdIpv6Flabel interface {
16211 IOxmId
16212}
16213
16214func (self *OxmIdIpv6Flabel) Serialize(encoder *goloxi.Encoder) error {
16215 if err := self.OxmId.Serialize(encoder); err != nil {
16216 return err
16217 }
16218
16219 return nil
16220}
16221
16222func DecodeOxmIdIpv6Flabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Flabel, error) {
16223 _oxmidipv6flabel := &OxmIdIpv6Flabel{OxmId: parent}
16224 return _oxmidipv6flabel, nil
16225}
16226
16227func NewOxmIdIpv6Flabel() *OxmIdIpv6Flabel {
16228 obj := &OxmIdIpv6Flabel{
16229 OxmId: NewOxmId(2147497988),
16230 }
16231 return obj
16232}
16233func (self *OxmIdIpv6Flabel) GetOXMName() string {
16234 return "ipv6_flabel"
16235}
16236
16237func (self *OxmIdIpv6Flabel) MarshalJSON() ([]byte, error) {
16238 if self.TypeLen == 0 {
16239 return []byte("\"\""), nil
16240 } else {
16241 return []byte("\"" + self.GetOXMName() + "\""), nil
16242 }
16243}
16244
16245type OxmIdIpv6FlabelMasked struct {
16246 *OxmId
16247}
16248
16249type IOxmIdIpv6FlabelMasked interface {
16250 IOxmId
16251}
16252
16253func (self *OxmIdIpv6FlabelMasked) Serialize(encoder *goloxi.Encoder) error {
16254 if err := self.OxmId.Serialize(encoder); err != nil {
16255 return err
16256 }
16257
16258 return nil
16259}
16260
16261func DecodeOxmIdIpv6FlabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6FlabelMasked, error) {
16262 _oxmidipv6flabelmasked := &OxmIdIpv6FlabelMasked{OxmId: parent}
16263 return _oxmidipv6flabelmasked, nil
16264}
16265
16266func NewOxmIdIpv6FlabelMasked() *OxmIdIpv6FlabelMasked {
16267 obj := &OxmIdIpv6FlabelMasked{
16268 OxmId: NewOxmId(2147498248),
16269 }
16270 return obj
16271}
16272func (self *OxmIdIpv6FlabelMasked) GetOXMName() string {
16273 return "ipv6_flabel_masked"
16274}
16275
16276func (self *OxmIdIpv6FlabelMasked) MarshalJSON() ([]byte, error) {
16277 if self.TypeLen == 0 {
16278 return []byte("\"\""), nil
16279 } else {
16280 return []byte("\"" + self.GetOXMName() + "\""), nil
16281 }
16282}
16283
16284type OxmIdIpv6NdSll struct {
16285 *OxmId
16286}
16287
16288type IOxmIdIpv6NdSll interface {
16289 IOxmId
16290}
16291
16292func (self *OxmIdIpv6NdSll) Serialize(encoder *goloxi.Encoder) error {
16293 if err := self.OxmId.Serialize(encoder); err != nil {
16294 return err
16295 }
16296
16297 return nil
16298}
16299
16300func DecodeOxmIdIpv6NdSll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdSll, error) {
16301 _oxmidipv6ndsll := &OxmIdIpv6NdSll{OxmId: parent}
16302 return _oxmidipv6ndsll, nil
16303}
16304
16305func NewOxmIdIpv6NdSll() *OxmIdIpv6NdSll {
16306 obj := &OxmIdIpv6NdSll{
16307 OxmId: NewOxmId(2147500038),
16308 }
16309 return obj
16310}
16311func (self *OxmIdIpv6NdSll) GetOXMName() string {
16312 return "ipv6_nd_sll"
16313}
16314
16315func (self *OxmIdIpv6NdSll) MarshalJSON() ([]byte, error) {
16316 if self.TypeLen == 0 {
16317 return []byte("\"\""), nil
16318 } else {
16319 return []byte("\"" + self.GetOXMName() + "\""), nil
16320 }
16321}
16322
16323type OxmIdIpv6NdSllMasked struct {
16324 *OxmId
16325}
16326
16327type IOxmIdIpv6NdSllMasked interface {
16328 IOxmId
16329}
16330
16331func (self *OxmIdIpv6NdSllMasked) Serialize(encoder *goloxi.Encoder) error {
16332 if err := self.OxmId.Serialize(encoder); err != nil {
16333 return err
16334 }
16335
16336 return nil
16337}
16338
16339func DecodeOxmIdIpv6NdSllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdSllMasked, error) {
16340 _oxmidipv6ndsllmasked := &OxmIdIpv6NdSllMasked{OxmId: parent}
16341 return _oxmidipv6ndsllmasked, nil
16342}
16343
16344func NewOxmIdIpv6NdSllMasked() *OxmIdIpv6NdSllMasked {
16345 obj := &OxmIdIpv6NdSllMasked{
16346 OxmId: NewOxmId(2147500300),
16347 }
16348 return obj
16349}
16350func (self *OxmIdIpv6NdSllMasked) GetOXMName() string {
16351 return "ipv6_nd_sll_masked"
16352}
16353
16354func (self *OxmIdIpv6NdSllMasked) MarshalJSON() ([]byte, error) {
16355 if self.TypeLen == 0 {
16356 return []byte("\"\""), nil
16357 } else {
16358 return []byte("\"" + self.GetOXMName() + "\""), nil
16359 }
16360}
16361
16362type OxmIdIpv6NdTarget struct {
16363 *OxmId
16364}
16365
16366type IOxmIdIpv6NdTarget interface {
16367 IOxmId
16368}
16369
16370func (self *OxmIdIpv6NdTarget) Serialize(encoder *goloxi.Encoder) error {
16371 if err := self.OxmId.Serialize(encoder); err != nil {
16372 return err
16373 }
16374
16375 return nil
16376}
16377
16378func DecodeOxmIdIpv6NdTarget(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTarget, error) {
16379 _oxmidipv6ndtarget := &OxmIdIpv6NdTarget{OxmId: parent}
16380 return _oxmidipv6ndtarget, nil
16381}
16382
16383func NewOxmIdIpv6NdTarget() *OxmIdIpv6NdTarget {
16384 obj := &OxmIdIpv6NdTarget{
16385 OxmId: NewOxmId(2147499536),
16386 }
16387 return obj
16388}
16389func (self *OxmIdIpv6NdTarget) GetOXMName() string {
16390 return "ipv6_nd_target"
16391}
16392
16393func (self *OxmIdIpv6NdTarget) MarshalJSON() ([]byte, error) {
16394 if self.TypeLen == 0 {
16395 return []byte("\"\""), nil
16396 } else {
16397 return []byte("\"" + self.GetOXMName() + "\""), nil
16398 }
16399}
16400
16401type OxmIdIpv6NdTargetMasked struct {
16402 *OxmId
16403}
16404
16405type IOxmIdIpv6NdTargetMasked interface {
16406 IOxmId
16407}
16408
16409func (self *OxmIdIpv6NdTargetMasked) Serialize(encoder *goloxi.Encoder) error {
16410 if err := self.OxmId.Serialize(encoder); err != nil {
16411 return err
16412 }
16413
16414 return nil
16415}
16416
16417func DecodeOxmIdIpv6NdTargetMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTargetMasked, error) {
16418 _oxmidipv6ndtargetmasked := &OxmIdIpv6NdTargetMasked{OxmId: parent}
16419 return _oxmidipv6ndtargetmasked, nil
16420}
16421
16422func NewOxmIdIpv6NdTargetMasked() *OxmIdIpv6NdTargetMasked {
16423 obj := &OxmIdIpv6NdTargetMasked{
16424 OxmId: NewOxmId(2147499808),
16425 }
16426 return obj
16427}
16428func (self *OxmIdIpv6NdTargetMasked) GetOXMName() string {
16429 return "ipv6_nd_target_masked"
16430}
16431
16432func (self *OxmIdIpv6NdTargetMasked) MarshalJSON() ([]byte, error) {
16433 if self.TypeLen == 0 {
16434 return []byte("\"\""), nil
16435 } else {
16436 return []byte("\"" + self.GetOXMName() + "\""), nil
16437 }
16438}
16439
16440type OxmIdIpv6NdTll struct {
16441 *OxmId
16442}
16443
16444type IOxmIdIpv6NdTll interface {
16445 IOxmId
16446}
16447
16448func (self *OxmIdIpv6NdTll) Serialize(encoder *goloxi.Encoder) error {
16449 if err := self.OxmId.Serialize(encoder); err != nil {
16450 return err
16451 }
16452
16453 return nil
16454}
16455
16456func DecodeOxmIdIpv6NdTll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTll, error) {
16457 _oxmidipv6ndtll := &OxmIdIpv6NdTll{OxmId: parent}
16458 return _oxmidipv6ndtll, nil
16459}
16460
16461func NewOxmIdIpv6NdTll() *OxmIdIpv6NdTll {
16462 obj := &OxmIdIpv6NdTll{
16463 OxmId: NewOxmId(2147500550),
16464 }
16465 return obj
16466}
16467func (self *OxmIdIpv6NdTll) GetOXMName() string {
16468 return "ipv6_nd_tll"
16469}
16470
16471func (self *OxmIdIpv6NdTll) MarshalJSON() ([]byte, error) {
16472 if self.TypeLen == 0 {
16473 return []byte("\"\""), nil
16474 } else {
16475 return []byte("\"" + self.GetOXMName() + "\""), nil
16476 }
16477}
16478
16479type OxmIdIpv6NdTllMasked struct {
16480 *OxmId
16481}
16482
16483type IOxmIdIpv6NdTllMasked interface {
16484 IOxmId
16485}
16486
16487func (self *OxmIdIpv6NdTllMasked) Serialize(encoder *goloxi.Encoder) error {
16488 if err := self.OxmId.Serialize(encoder); err != nil {
16489 return err
16490 }
16491
16492 return nil
16493}
16494
16495func DecodeOxmIdIpv6NdTllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTllMasked, error) {
16496 _oxmidipv6ndtllmasked := &OxmIdIpv6NdTllMasked{OxmId: parent}
16497 return _oxmidipv6ndtllmasked, nil
16498}
16499
16500func NewOxmIdIpv6NdTllMasked() *OxmIdIpv6NdTllMasked {
16501 obj := &OxmIdIpv6NdTllMasked{
16502 OxmId: NewOxmId(2147500812),
16503 }
16504 return obj
16505}
16506func (self *OxmIdIpv6NdTllMasked) GetOXMName() string {
16507 return "ipv6_nd_tll_masked"
16508}
16509
16510func (self *OxmIdIpv6NdTllMasked) MarshalJSON() ([]byte, error) {
16511 if self.TypeLen == 0 {
16512 return []byte("\"\""), nil
16513 } else {
16514 return []byte("\"" + self.GetOXMName() + "\""), nil
16515 }
16516}
16517
16518type OxmIdMetadata struct {
16519 *OxmId
16520}
16521
16522type IOxmIdMetadata interface {
16523 IOxmId
16524}
16525
16526func (self *OxmIdMetadata) Serialize(encoder *goloxi.Encoder) error {
16527 if err := self.OxmId.Serialize(encoder); err != nil {
16528 return err
16529 }
16530
16531 return nil
16532}
16533
16534func DecodeOxmIdMetadata(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMetadata, error) {
16535 _oxmidmetadata := &OxmIdMetadata{OxmId: parent}
16536 return _oxmidmetadata, nil
16537}
16538
16539func NewOxmIdMetadata() *OxmIdMetadata {
16540 obj := &OxmIdMetadata{
16541 OxmId: NewOxmId(2147484680),
16542 }
16543 return obj
16544}
16545func (self *OxmIdMetadata) GetOXMName() string {
16546 return "metadata"
16547}
16548
16549func (self *OxmIdMetadata) MarshalJSON() ([]byte, error) {
16550 if self.TypeLen == 0 {
16551 return []byte("\"\""), nil
16552 } else {
16553 return []byte("\"" + self.GetOXMName() + "\""), nil
16554 }
16555}
16556
16557type OxmIdMetadataMasked struct {
16558 *OxmId
16559}
16560
16561type IOxmIdMetadataMasked interface {
16562 IOxmId
16563}
16564
16565func (self *OxmIdMetadataMasked) Serialize(encoder *goloxi.Encoder) error {
16566 if err := self.OxmId.Serialize(encoder); err != nil {
16567 return err
16568 }
16569
16570 return nil
16571}
16572
16573func DecodeOxmIdMetadataMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMetadataMasked, error) {
16574 _oxmidmetadatamasked := &OxmIdMetadataMasked{OxmId: parent}
16575 return _oxmidmetadatamasked, nil
16576}
16577
16578func NewOxmIdMetadataMasked() *OxmIdMetadataMasked {
16579 obj := &OxmIdMetadataMasked{
16580 OxmId: NewOxmId(2147484944),
16581 }
16582 return obj
16583}
16584func (self *OxmIdMetadataMasked) GetOXMName() string {
16585 return "metadata_masked"
16586}
16587
16588func (self *OxmIdMetadataMasked) MarshalJSON() ([]byte, error) {
16589 if self.TypeLen == 0 {
16590 return []byte("\"\""), nil
16591 } else {
16592 return []byte("\"" + self.GetOXMName() + "\""), nil
16593 }
16594}
16595
16596type OxmIdMplsLabel struct {
16597 *OxmId
16598}
16599
16600type IOxmIdMplsLabel interface {
16601 IOxmId
16602}
16603
16604func (self *OxmIdMplsLabel) Serialize(encoder *goloxi.Encoder) error {
16605 if err := self.OxmId.Serialize(encoder); err != nil {
16606 return err
16607 }
16608
16609 return nil
16610}
16611
16612func DecodeOxmIdMplsLabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsLabel, error) {
16613 _oxmidmplslabel := &OxmIdMplsLabel{OxmId: parent}
16614 return _oxmidmplslabel, nil
16615}
16616
16617func NewOxmIdMplsLabel() *OxmIdMplsLabel {
16618 obj := &OxmIdMplsLabel{
16619 OxmId: NewOxmId(2147501060),
16620 }
16621 return obj
16622}
16623func (self *OxmIdMplsLabel) GetOXMName() string {
16624 return "mpls_label"
16625}
16626
16627func (self *OxmIdMplsLabel) MarshalJSON() ([]byte, error) {
16628 if self.TypeLen == 0 {
16629 return []byte("\"\""), nil
16630 } else {
16631 return []byte("\"" + self.GetOXMName() + "\""), nil
16632 }
16633}
16634
16635type OxmIdMplsLabelMasked struct {
16636 *OxmId
16637}
16638
16639type IOxmIdMplsLabelMasked interface {
16640 IOxmId
16641}
16642
16643func (self *OxmIdMplsLabelMasked) Serialize(encoder *goloxi.Encoder) error {
16644 if err := self.OxmId.Serialize(encoder); err != nil {
16645 return err
16646 }
16647
16648 return nil
16649}
16650
16651func DecodeOxmIdMplsLabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsLabelMasked, error) {
16652 _oxmidmplslabelmasked := &OxmIdMplsLabelMasked{OxmId: parent}
16653 return _oxmidmplslabelmasked, nil
16654}
16655
16656func NewOxmIdMplsLabelMasked() *OxmIdMplsLabelMasked {
16657 obj := &OxmIdMplsLabelMasked{
16658 OxmId: NewOxmId(2147501320),
16659 }
16660 return obj
16661}
16662func (self *OxmIdMplsLabelMasked) GetOXMName() string {
16663 return "mpls_label_masked"
16664}
16665
16666func (self *OxmIdMplsLabelMasked) MarshalJSON() ([]byte, error) {
16667 if self.TypeLen == 0 {
16668 return []byte("\"\""), nil
16669 } else {
16670 return []byte("\"" + self.GetOXMName() + "\""), nil
16671 }
16672}
16673
16674type OxmIdMplsTc struct {
16675 *OxmId
16676}
16677
16678type IOxmIdMplsTc interface {
16679 IOxmId
16680}
16681
16682func (self *OxmIdMplsTc) Serialize(encoder *goloxi.Encoder) error {
16683 if err := self.OxmId.Serialize(encoder); err != nil {
16684 return err
16685 }
16686
16687 return nil
16688}
16689
16690func DecodeOxmIdMplsTc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsTc, error) {
16691 _oxmidmplstc := &OxmIdMplsTc{OxmId: parent}
16692 return _oxmidmplstc, nil
16693}
16694
16695func NewOxmIdMplsTc() *OxmIdMplsTc {
16696 obj := &OxmIdMplsTc{
16697 OxmId: NewOxmId(2147501569),
16698 }
16699 return obj
16700}
16701func (self *OxmIdMplsTc) GetOXMName() string {
16702 return "mpls_tc"
16703}
16704
16705func (self *OxmIdMplsTc) MarshalJSON() ([]byte, error) {
16706 if self.TypeLen == 0 {
16707 return []byte("\"\""), nil
16708 } else {
16709 return []byte("\"" + self.GetOXMName() + "\""), nil
16710 }
16711}
16712
16713type OxmIdMplsTcMasked struct {
16714 *OxmId
16715}
16716
16717type IOxmIdMplsTcMasked interface {
16718 IOxmId
16719}
16720
16721func (self *OxmIdMplsTcMasked) Serialize(encoder *goloxi.Encoder) error {
16722 if err := self.OxmId.Serialize(encoder); err != nil {
16723 return err
16724 }
16725
16726 return nil
16727}
16728
16729func DecodeOxmIdMplsTcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsTcMasked, error) {
16730 _oxmidmplstcmasked := &OxmIdMplsTcMasked{OxmId: parent}
16731 return _oxmidmplstcmasked, nil
16732}
16733
16734func NewOxmIdMplsTcMasked() *OxmIdMplsTcMasked {
16735 obj := &OxmIdMplsTcMasked{
16736 OxmId: NewOxmId(2147501826),
16737 }
16738 return obj
16739}
16740func (self *OxmIdMplsTcMasked) GetOXMName() string {
16741 return "mpls_tc_masked"
16742}
16743
16744func (self *OxmIdMplsTcMasked) MarshalJSON() ([]byte, error) {
16745 if self.TypeLen == 0 {
16746 return []byte("\"\""), nil
16747 } else {
16748 return []byte("\"" + self.GetOXMName() + "\""), nil
16749 }
16750}
16751
16752type OxmIdSctpDst struct {
16753 *OxmId
16754}
16755
16756type IOxmIdSctpDst interface {
16757 IOxmId
16758}
16759
16760func (self *OxmIdSctpDst) Serialize(encoder *goloxi.Encoder) error {
16761 if err := self.OxmId.Serialize(encoder); err != nil {
16762 return err
16763 }
16764
16765 return nil
16766}
16767
16768func DecodeOxmIdSctpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpDst, error) {
16769 _oxmidsctpdst := &OxmIdSctpDst{OxmId: parent}
16770 return _oxmidsctpdst, nil
16771}
16772
16773func NewOxmIdSctpDst() *OxmIdSctpDst {
16774 obj := &OxmIdSctpDst{
16775 OxmId: NewOxmId(2147492866),
16776 }
16777 return obj
16778}
16779func (self *OxmIdSctpDst) GetOXMName() string {
16780 return "sctp_dst"
16781}
16782
16783func (self *OxmIdSctpDst) MarshalJSON() ([]byte, error) {
16784 if self.TypeLen == 0 {
16785 return []byte("\"\""), nil
16786 } else {
16787 return []byte("\"" + self.GetOXMName() + "\""), nil
16788 }
16789}
16790
16791type OxmIdSctpDstMasked struct {
16792 *OxmId
16793}
16794
16795type IOxmIdSctpDstMasked interface {
16796 IOxmId
16797}
16798
16799func (self *OxmIdSctpDstMasked) Serialize(encoder *goloxi.Encoder) error {
16800 if err := self.OxmId.Serialize(encoder); err != nil {
16801 return err
16802 }
16803
16804 return nil
16805}
16806
16807func DecodeOxmIdSctpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpDstMasked, error) {
16808 _oxmidsctpdstmasked := &OxmIdSctpDstMasked{OxmId: parent}
16809 return _oxmidsctpdstmasked, nil
16810}
16811
16812func NewOxmIdSctpDstMasked() *OxmIdSctpDstMasked {
16813 obj := &OxmIdSctpDstMasked{
16814 OxmId: NewOxmId(2147493124),
16815 }
16816 return obj
16817}
16818func (self *OxmIdSctpDstMasked) GetOXMName() string {
16819 return "sctp_dst_masked"
16820}
16821
16822func (self *OxmIdSctpDstMasked) MarshalJSON() ([]byte, error) {
16823 if self.TypeLen == 0 {
16824 return []byte("\"\""), nil
16825 } else {
16826 return []byte("\"" + self.GetOXMName() + "\""), nil
16827 }
16828}
16829
16830type OxmIdSctpSrc struct {
16831 *OxmId
16832}
16833
16834type IOxmIdSctpSrc interface {
16835 IOxmId
16836}
16837
16838func (self *OxmIdSctpSrc) Serialize(encoder *goloxi.Encoder) error {
16839 if err := self.OxmId.Serialize(encoder); err != nil {
16840 return err
16841 }
16842
16843 return nil
16844}
16845
16846func DecodeOxmIdSctpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpSrc, error) {
16847 _oxmidsctpsrc := &OxmIdSctpSrc{OxmId: parent}
16848 return _oxmidsctpsrc, nil
16849}
16850
16851func NewOxmIdSctpSrc() *OxmIdSctpSrc {
16852 obj := &OxmIdSctpSrc{
16853 OxmId: NewOxmId(2147492354),
16854 }
16855 return obj
16856}
16857func (self *OxmIdSctpSrc) GetOXMName() string {
16858 return "sctp_src"
16859}
16860
16861func (self *OxmIdSctpSrc) MarshalJSON() ([]byte, error) {
16862 if self.TypeLen == 0 {
16863 return []byte("\"\""), nil
16864 } else {
16865 return []byte("\"" + self.GetOXMName() + "\""), nil
16866 }
16867}
16868
16869type OxmIdSctpSrcMasked struct {
16870 *OxmId
16871}
16872
16873type IOxmIdSctpSrcMasked interface {
16874 IOxmId
16875}
16876
16877func (self *OxmIdSctpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
16878 if err := self.OxmId.Serialize(encoder); err != nil {
16879 return err
16880 }
16881
16882 return nil
16883}
16884
16885func DecodeOxmIdSctpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpSrcMasked, error) {
16886 _oxmidsctpsrcmasked := &OxmIdSctpSrcMasked{OxmId: parent}
16887 return _oxmidsctpsrcmasked, nil
16888}
16889
16890func NewOxmIdSctpSrcMasked() *OxmIdSctpSrcMasked {
16891 obj := &OxmIdSctpSrcMasked{
16892 OxmId: NewOxmId(2147492612),
16893 }
16894 return obj
16895}
16896func (self *OxmIdSctpSrcMasked) GetOXMName() string {
16897 return "sctp_src_masked"
16898}
16899
16900func (self *OxmIdSctpSrcMasked) MarshalJSON() ([]byte, error) {
16901 if self.TypeLen == 0 {
16902 return []byte("\"\""), nil
16903 } else {
16904 return []byte("\"" + self.GetOXMName() + "\""), nil
16905 }
16906}
16907
16908type OxmIdVlanPcp struct {
16909 *OxmId
16910}
16911
16912type IOxmIdVlanPcp interface {
16913 IOxmId
16914}
16915
16916func (self *OxmIdVlanPcp) Serialize(encoder *goloxi.Encoder) error {
16917 if err := self.OxmId.Serialize(encoder); err != nil {
16918 return err
16919 }
16920
16921 return nil
16922}
16923
16924func DecodeOxmIdVlanPcp(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanPcp, error) {
16925 _oxmidvlanpcp := &OxmIdVlanPcp{OxmId: parent}
16926 return _oxmidvlanpcp, nil
16927}
16928
16929func NewOxmIdVlanPcp() *OxmIdVlanPcp {
16930 obj := &OxmIdVlanPcp{
16931 OxmId: NewOxmId(2147487233),
16932 }
16933 return obj
16934}
16935func (self *OxmIdVlanPcp) GetOXMName() string {
16936 return "vlan_pcp"
16937}
16938
16939func (self *OxmIdVlanPcp) MarshalJSON() ([]byte, error) {
16940 if self.TypeLen == 0 {
16941 return []byte("\"\""), nil
16942 } else {
16943 return []byte("\"" + self.GetOXMName() + "\""), nil
16944 }
16945}
16946
16947type OxmIdVlanPcpMasked struct {
16948 *OxmId
16949}
16950
16951type IOxmIdVlanPcpMasked interface {
16952 IOxmId
16953}
16954
16955func (self *OxmIdVlanPcpMasked) Serialize(encoder *goloxi.Encoder) error {
16956 if err := self.OxmId.Serialize(encoder); err != nil {
16957 return err
16958 }
16959
16960 return nil
16961}
16962
16963func DecodeOxmIdVlanPcpMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanPcpMasked, error) {
16964 _oxmidvlanpcpmasked := &OxmIdVlanPcpMasked{OxmId: parent}
16965 return _oxmidvlanpcpmasked, nil
16966}
16967
16968func NewOxmIdVlanPcpMasked() *OxmIdVlanPcpMasked {
16969 obj := &OxmIdVlanPcpMasked{
16970 OxmId: NewOxmId(2147487490),
16971 }
16972 return obj
16973}
16974func (self *OxmIdVlanPcpMasked) GetOXMName() string {
16975 return "vlan_pcp_masked"
16976}
16977
16978func (self *OxmIdVlanPcpMasked) MarshalJSON() ([]byte, error) {
16979 if self.TypeLen == 0 {
16980 return []byte("\"\""), nil
16981 } else {
16982 return []byte("\"" + self.GetOXMName() + "\""), nil
16983 }
16984}
16985
16986type OxmIdVlanVid struct {
16987 *OxmId
16988}
16989
16990type IOxmIdVlanVid interface {
16991 IOxmId
16992}
16993
16994func (self *OxmIdVlanVid) Serialize(encoder *goloxi.Encoder) error {
16995 if err := self.OxmId.Serialize(encoder); err != nil {
16996 return err
16997 }
16998
16999 return nil
17000}
17001
17002func DecodeOxmIdVlanVid(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanVid, error) {
17003 _oxmidvlanvid := &OxmIdVlanVid{OxmId: parent}
17004 return _oxmidvlanvid, nil
17005}
17006
17007func NewOxmIdVlanVid() *OxmIdVlanVid {
17008 obj := &OxmIdVlanVid{
17009 OxmId: NewOxmId(2147486722),
17010 }
17011 return obj
17012}
17013func (self *OxmIdVlanVid) GetOXMName() string {
17014 return "vlan_vid"
17015}
17016
17017func (self *OxmIdVlanVid) MarshalJSON() ([]byte, error) {
17018 if self.TypeLen == 0 {
17019 return []byte("\"\""), nil
17020 } else {
17021 return []byte("\"" + self.GetOXMName() + "\""), nil
17022 }
17023}
17024
17025type OxmIdVlanVidMasked struct {
17026 *OxmId
17027}
17028
17029type IOxmIdVlanVidMasked interface {
17030 IOxmId
17031}
17032
17033func (self *OxmIdVlanVidMasked) Serialize(encoder *goloxi.Encoder) error {
17034 if err := self.OxmId.Serialize(encoder); err != nil {
17035 return err
17036 }
17037
17038 return nil
17039}
17040
17041func DecodeOxmIdVlanVidMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanVidMasked, error) {
17042 _oxmidvlanvidmasked := &OxmIdVlanVidMasked{OxmId: parent}
17043 return _oxmidvlanvidmasked, nil
17044}
17045
17046func NewOxmIdVlanVidMasked() *OxmIdVlanVidMasked {
17047 obj := &OxmIdVlanVidMasked{
17048 OxmId: NewOxmId(2147486980),
17049 }
17050 return obj
17051}
17052func (self *OxmIdVlanVidMasked) GetOXMName() string {
17053 return "vlan_vid_masked"
17054}
17055
17056func (self *OxmIdVlanVidMasked) MarshalJSON() ([]byte, error) {
17057 if self.TypeLen == 0 {
17058 return []byte("\"\""), nil
17059 } else {
17060 return []byte("\"" + self.GetOXMName() + "\""), nil
17061 }
17062}
17063
17064type PacketQueue struct {
17065 QueueId uint32
17066 Len uint16
17067 Properties []IQueueProp
17068}
17069
17070type IPacketQueue interface {
17071 goloxi.Serializable
17072 GetQueueId() uint32
17073 GetLen() uint16
17074 GetProperties() []IQueueProp
17075}
17076
17077func (self *PacketQueue) GetQueueId() uint32 {
17078 return self.QueueId
17079}
17080
17081func (self *PacketQueue) SetQueueId(v uint32) {
17082 self.QueueId = v
17083}
17084
17085func (self *PacketQueue) GetLen() uint16 {
17086 return self.Len
17087}
17088
17089func (self *PacketQueue) SetLen(v uint16) {
17090 self.Len = v
17091}
17092
17093func (self *PacketQueue) GetProperties() []IQueueProp {
17094 return self.Properties
17095}
17096
17097func (self *PacketQueue) SetProperties(v []IQueueProp) {
17098 self.Properties = v
17099}
17100
17101func (self *PacketQueue) Serialize(encoder *goloxi.Encoder) error {
17102 startIndex := len(encoder.Bytes())
17103
17104 encoder.PutUint32(uint32(self.QueueId))
17105 encoder.PutUint16(uint16(self.Len))
17106 encoder.Write(bytes.Repeat([]byte{0}, 2))
17107 for _, obj := range self.Properties {
17108 if err := obj.Serialize(encoder); err != nil {
17109 return err
17110 }
17111 }
17112 length := len(encoder.Bytes()) - startIndex
17113
17114 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+4:startIndex+6], uint16(length))
17115
17116 return nil
17117}
17118
17119func DecodePacketQueue(decoder *goloxi.Decoder) (*PacketQueue, error) {
17120 _packetqueue := &PacketQueue{}
17121 if decoder.Length() < 8 {
17122 return nil, fmt.Errorf("PacketQueue packet too short: %d < 8", decoder.Length())
17123 }
17124 _packetqueue.QueueId = uint32(decoder.ReadUint32())
17125 _packetqueue.Len = uint16(decoder.ReadUint16())
17126 oldDecoder := decoder
17127 defer func() { decoder = oldDecoder }()
17128 decoder = decoder.SliceDecoder(int(_packetqueue.Len), 2+4)
17129 decoder.Skip(2)
17130
17131 for decoder.Length() >= 8 {
17132 item, err := DecodeQueueProp(decoder)
17133 if err != nil {
17134 return nil, err
17135 }
17136 if item != nil {
17137 _packetqueue.Properties = append(_packetqueue.Properties, item)
17138 }
17139 }
17140 return _packetqueue, nil
17141}
17142
17143func NewPacketQueue() *PacketQueue {
17144 obj := &PacketQueue{}
17145 return obj
17146}
17147
17148type PortDesc struct {
17149 PortNo Port
17150 HwAddr net.HardwareAddr
17151 Name string
17152 Config PortConfig
17153 State PortState
17154 Curr PortFeatures
17155 Advertised PortFeatures
17156 Supported PortFeatures
17157 Peer PortFeatures
17158 CurrSpeed uint32
17159 MaxSpeed uint32
17160}
17161
17162type IPortDesc interface {
17163 goloxi.Serializable
17164 GetPortNo() Port
17165 GetHwAddr() net.HardwareAddr
17166 GetName() string
17167 GetConfig() PortConfig
17168 GetState() PortState
17169 GetCurr() PortFeatures
17170 GetAdvertised() PortFeatures
17171 GetSupported() PortFeatures
17172 GetPeer() PortFeatures
17173 GetCurrSpeed() uint32
17174 GetMaxSpeed() uint32
17175}
17176
17177func (self *PortDesc) GetPortNo() Port {
17178 return self.PortNo
17179}
17180
17181func (self *PortDesc) SetPortNo(v Port) {
17182 self.PortNo = v
17183}
17184
17185func (self *PortDesc) GetHwAddr() net.HardwareAddr {
17186 return self.HwAddr
17187}
17188
17189func (self *PortDesc) SetHwAddr(v net.HardwareAddr) {
17190 self.HwAddr = v
17191}
17192
17193func (self *PortDesc) GetName() string {
17194 return self.Name
17195}
17196
17197func (self *PortDesc) SetName(v string) {
17198 self.Name = v
17199}
17200
17201func (self *PortDesc) GetConfig() PortConfig {
17202 return self.Config
17203}
17204
17205func (self *PortDesc) SetConfig(v PortConfig) {
17206 self.Config = v
17207}
17208
17209func (self *PortDesc) GetState() PortState {
17210 return self.State
17211}
17212
17213func (self *PortDesc) SetState(v PortState) {
17214 self.State = v
17215}
17216
17217func (self *PortDesc) GetCurr() PortFeatures {
17218 return self.Curr
17219}
17220
17221func (self *PortDesc) SetCurr(v PortFeatures) {
17222 self.Curr = v
17223}
17224
17225func (self *PortDesc) GetAdvertised() PortFeatures {
17226 return self.Advertised
17227}
17228
17229func (self *PortDesc) SetAdvertised(v PortFeatures) {
17230 self.Advertised = v
17231}
17232
17233func (self *PortDesc) GetSupported() PortFeatures {
17234 return self.Supported
17235}
17236
17237func (self *PortDesc) SetSupported(v PortFeatures) {
17238 self.Supported = v
17239}
17240
17241func (self *PortDesc) GetPeer() PortFeatures {
17242 return self.Peer
17243}
17244
17245func (self *PortDesc) SetPeer(v PortFeatures) {
17246 self.Peer = v
17247}
17248
17249func (self *PortDesc) GetCurrSpeed() uint32 {
17250 return self.CurrSpeed
17251}
17252
17253func (self *PortDesc) SetCurrSpeed(v uint32) {
17254 self.CurrSpeed = v
17255}
17256
17257func (self *PortDesc) GetMaxSpeed() uint32 {
17258 return self.MaxSpeed
17259}
17260
17261func (self *PortDesc) SetMaxSpeed(v uint32) {
17262 self.MaxSpeed = v
17263}
17264
17265func (self *PortDesc) Serialize(encoder *goloxi.Encoder) error {
17266
17267 self.PortNo.Serialize(encoder)
17268 encoder.Write(bytes.Repeat([]byte{0}, 4))
17269 encoder.Write(self.HwAddr)
17270 encoder.Write(bytes.Repeat([]byte{0}, 2))
17271 encoder.Write([]byte(self.Name))
17272 encoder.PutUint32(uint32(self.Config))
17273 encoder.PutUint32(uint32(self.State))
17274 encoder.PutUint32(uint32(self.Curr))
17275 encoder.PutUint32(uint32(self.Advertised))
17276 encoder.PutUint32(uint32(self.Supported))
17277 encoder.PutUint32(uint32(self.Peer))
17278 encoder.PutUint32(uint32(self.CurrSpeed))
17279 encoder.PutUint32(uint32(self.MaxSpeed))
17280
17281 return nil
17282}
17283func (self *PortDesc) Decode(decoder *goloxi.Decoder) error {
17284 if decoder.Length() < 64 {
17285 return fmt.Errorf("PortDesc packet too short: %d < 64", decoder.Length())
17286 }
17287
17288 self.PortNo.Decode(decoder)
17289 decoder.Skip(4)
17290 self.HwAddr = net.HardwareAddr(decoder.Read(6))
17291 decoder.Skip(2)
17292 self.Name = string(bytes.Trim(decoder.Read(16), "\x00"))
17293 self.Config = PortConfig(decoder.ReadUint32())
17294 self.State = PortState(decoder.ReadUint32())
17295 self.Curr = PortFeatures(decoder.ReadUint32())
17296 self.Advertised = PortFeatures(decoder.ReadUint32())
17297 self.Supported = PortFeatures(decoder.ReadUint32())
17298 self.Peer = PortFeatures(decoder.ReadUint32())
17299 self.CurrSpeed = uint32(decoder.ReadUint32())
17300 self.MaxSpeed = uint32(decoder.ReadUint32())
17301
17302 return nil
17303}
17304
17305func NewPortDesc() *PortDesc {
17306 obj := &PortDesc{}
17307 return obj
17308}
17309
17310type PortStatsEntry struct {
17311 PortNo Port
17312 RxPackets uint64
17313 TxPackets uint64
17314 RxBytes uint64
17315 TxBytes uint64
17316 RxDropped uint64
17317 TxDropped uint64
17318 RxErrors uint64
17319 TxErrors uint64
17320 RxFrameErr uint64
17321 RxOverErr uint64
17322 RxCrcErr uint64
17323 Collisions uint64
17324}
17325
17326type IPortStatsEntry interface {
17327 goloxi.Serializable
17328 GetPortNo() Port
17329 GetRxPackets() uint64
17330 GetTxPackets() uint64
17331 GetRxBytes() uint64
17332 GetTxBytes() uint64
17333 GetRxDropped() uint64
17334 GetTxDropped() uint64
17335 GetRxErrors() uint64
17336 GetTxErrors() uint64
17337 GetRxFrameErr() uint64
17338 GetRxOverErr() uint64
17339 GetRxCrcErr() uint64
17340 GetCollisions() uint64
17341}
17342
17343func (self *PortStatsEntry) GetPortNo() Port {
17344 return self.PortNo
17345}
17346
17347func (self *PortStatsEntry) SetPortNo(v Port) {
17348 self.PortNo = v
17349}
17350
17351func (self *PortStatsEntry) GetRxPackets() uint64 {
17352 return self.RxPackets
17353}
17354
17355func (self *PortStatsEntry) SetRxPackets(v uint64) {
17356 self.RxPackets = v
17357}
17358
17359func (self *PortStatsEntry) GetTxPackets() uint64 {
17360 return self.TxPackets
17361}
17362
17363func (self *PortStatsEntry) SetTxPackets(v uint64) {
17364 self.TxPackets = v
17365}
17366
17367func (self *PortStatsEntry) GetRxBytes() uint64 {
17368 return self.RxBytes
17369}
17370
17371func (self *PortStatsEntry) SetRxBytes(v uint64) {
17372 self.RxBytes = v
17373}
17374
17375func (self *PortStatsEntry) GetTxBytes() uint64 {
17376 return self.TxBytes
17377}
17378
17379func (self *PortStatsEntry) SetTxBytes(v uint64) {
17380 self.TxBytes = v
17381}
17382
17383func (self *PortStatsEntry) GetRxDropped() uint64 {
17384 return self.RxDropped
17385}
17386
17387func (self *PortStatsEntry) SetRxDropped(v uint64) {
17388 self.RxDropped = v
17389}
17390
17391func (self *PortStatsEntry) GetTxDropped() uint64 {
17392 return self.TxDropped
17393}
17394
17395func (self *PortStatsEntry) SetTxDropped(v uint64) {
17396 self.TxDropped = v
17397}
17398
17399func (self *PortStatsEntry) GetRxErrors() uint64 {
17400 return self.RxErrors
17401}
17402
17403func (self *PortStatsEntry) SetRxErrors(v uint64) {
17404 self.RxErrors = v
17405}
17406
17407func (self *PortStatsEntry) GetTxErrors() uint64 {
17408 return self.TxErrors
17409}
17410
17411func (self *PortStatsEntry) SetTxErrors(v uint64) {
17412 self.TxErrors = v
17413}
17414
17415func (self *PortStatsEntry) GetRxFrameErr() uint64 {
17416 return self.RxFrameErr
17417}
17418
17419func (self *PortStatsEntry) SetRxFrameErr(v uint64) {
17420 self.RxFrameErr = v
17421}
17422
17423func (self *PortStatsEntry) GetRxOverErr() uint64 {
17424 return self.RxOverErr
17425}
17426
17427func (self *PortStatsEntry) SetRxOverErr(v uint64) {
17428 self.RxOverErr = v
17429}
17430
17431func (self *PortStatsEntry) GetRxCrcErr() uint64 {
17432 return self.RxCrcErr
17433}
17434
17435func (self *PortStatsEntry) SetRxCrcErr(v uint64) {
17436 self.RxCrcErr = v
17437}
17438
17439func (self *PortStatsEntry) GetCollisions() uint64 {
17440 return self.Collisions
17441}
17442
17443func (self *PortStatsEntry) SetCollisions(v uint64) {
17444 self.Collisions = v
17445}
17446
17447func (self *PortStatsEntry) Serialize(encoder *goloxi.Encoder) error {
17448
17449 self.PortNo.Serialize(encoder)
17450 encoder.Write(bytes.Repeat([]byte{0}, 4))
17451 encoder.PutUint64(uint64(self.RxPackets))
17452 encoder.PutUint64(uint64(self.TxPackets))
17453 encoder.PutUint64(uint64(self.RxBytes))
17454 encoder.PutUint64(uint64(self.TxBytes))
17455 encoder.PutUint64(uint64(self.RxDropped))
17456 encoder.PutUint64(uint64(self.TxDropped))
17457 encoder.PutUint64(uint64(self.RxErrors))
17458 encoder.PutUint64(uint64(self.TxErrors))
17459 encoder.PutUint64(uint64(self.RxFrameErr))
17460 encoder.PutUint64(uint64(self.RxOverErr))
17461 encoder.PutUint64(uint64(self.RxCrcErr))
17462 encoder.PutUint64(uint64(self.Collisions))
17463
17464 return nil
17465}
17466
17467func DecodePortStatsEntry(decoder *goloxi.Decoder) (*PortStatsEntry, error) {
17468 _portstatsentry := &PortStatsEntry{}
17469 if decoder.Length() < 104 {
17470 return nil, fmt.Errorf("PortStatsEntry packet too short: %d < 104", decoder.Length())
17471 }
17472 _portstatsentry.PortNo.Decode(decoder)
17473 decoder.Skip(4)
17474 _portstatsentry.RxPackets = uint64(decoder.ReadUint64())
17475 _portstatsentry.TxPackets = uint64(decoder.ReadUint64())
17476 _portstatsentry.RxBytes = uint64(decoder.ReadUint64())
17477 _portstatsentry.TxBytes = uint64(decoder.ReadUint64())
17478 _portstatsentry.RxDropped = uint64(decoder.ReadUint64())
17479 _portstatsentry.TxDropped = uint64(decoder.ReadUint64())
17480 _portstatsentry.RxErrors = uint64(decoder.ReadUint64())
17481 _portstatsentry.TxErrors = uint64(decoder.ReadUint64())
17482 _portstatsentry.RxFrameErr = uint64(decoder.ReadUint64())
17483 _portstatsentry.RxOverErr = uint64(decoder.ReadUint64())
17484 _portstatsentry.RxCrcErr = uint64(decoder.ReadUint64())
17485 _portstatsentry.Collisions = uint64(decoder.ReadUint64())
17486 return _portstatsentry, nil
17487}
17488
17489func NewPortStatsEntry() *PortStatsEntry {
17490 obj := &PortStatsEntry{}
17491 return obj
17492}
17493
17494type QueueProp struct {
17495 Type uint16
17496 Len uint16
17497}
17498
17499type IQueueProp interface {
17500 goloxi.Serializable
17501 GetType() uint16
17502 GetLen() uint16
17503}
17504
17505func (self *QueueProp) GetType() uint16 {
17506 return self.Type
17507}
17508
17509func (self *QueueProp) SetType(v uint16) {
17510 self.Type = v
17511}
17512
17513func (self *QueueProp) GetLen() uint16 {
17514 return self.Len
17515}
17516
17517func (self *QueueProp) SetLen(v uint16) {
17518 self.Len = v
17519}
17520
17521func (self *QueueProp) Serialize(encoder *goloxi.Encoder) error {
17522
17523 encoder.PutUint16(uint16(self.Type))
17524 encoder.PutUint16(uint16(self.Len))
17525
17526 return nil
17527}
17528
17529func DecodeQueueProp(decoder *goloxi.Decoder) (IQueueProp, error) {
17530 _queueprop := &QueueProp{}
17531 if decoder.Length() < 4 {
17532 return nil, fmt.Errorf("QueueProp packet too short: %d < 4", decoder.Length())
17533 }
17534 _queueprop.Type = uint16(decoder.ReadUint16())
17535 _queueprop.Len = uint16(decoder.ReadUint16())
17536 oldDecoder := decoder
17537 defer func() { decoder = oldDecoder }()
17538 decoder = decoder.SliceDecoder(int(_queueprop.Len), 2+2)
17539
17540 switch _queueprop.Type {
17541 case 1:
17542 return DecodeQueuePropMinRate(_queueprop, decoder)
17543 default:
17544 return nil, fmt.Errorf("Invalid type '%d' for 'QueueProp'", _queueprop.Type)
17545 }
17546}
17547
17548func NewQueueProp(_type uint16) *QueueProp {
17549 obj := &QueueProp{}
17550 obj.Type = _type
17551 return obj
17552}
17553
17554type QueuePropMinRate struct {
17555 *QueueProp
17556 Rate uint16
17557}
17558
17559type IQueuePropMinRate interface {
17560 IQueueProp
17561 GetRate() uint16
17562}
17563
17564func (self *QueuePropMinRate) GetRate() uint16 {
17565 return self.Rate
17566}
17567
17568func (self *QueuePropMinRate) SetRate(v uint16) {
17569 self.Rate = v
17570}
17571
17572func (self *QueuePropMinRate) Serialize(encoder *goloxi.Encoder) error {
17573 startIndex := len(encoder.Bytes())
17574 if err := self.QueueProp.Serialize(encoder); err != nil {
17575 return err
17576 }
17577
17578 encoder.Write(bytes.Repeat([]byte{0}, 4))
17579 encoder.PutUint16(uint16(self.Rate))
17580 encoder.Write(bytes.Repeat([]byte{0}, 6))
17581 length := len(encoder.Bytes()) - startIndex
17582
17583 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
17584
17585 return nil
17586}
17587
17588func DecodeQueuePropMinRate(parent *QueueProp, decoder *goloxi.Decoder) (*QueuePropMinRate, error) {
17589 _queuepropminrate := &QueuePropMinRate{QueueProp: parent}
17590 if decoder.Length() < 12 {
17591 return nil, fmt.Errorf("QueuePropMinRate packet too short: %d < 12", decoder.Length())
17592 }
17593 decoder.Skip(4)
17594 _queuepropminrate.Rate = uint16(decoder.ReadUint16())
17595 decoder.Skip(6)
17596 return _queuepropminrate, nil
17597}
17598
17599func NewQueuePropMinRate() *QueuePropMinRate {
17600 obj := &QueuePropMinRate{
17601 QueueProp: NewQueueProp(1),
17602 }
17603 return obj
17604}
17605
17606type QueueStatsEntry struct {
17607 PortNo Port
17608 QueueId uint32
17609 TxBytes uint64
17610 TxPackets uint64
17611 TxErrors uint64
17612}
17613
17614type IQueueStatsEntry interface {
17615 goloxi.Serializable
17616 GetPortNo() Port
17617 GetQueueId() uint32
17618 GetTxBytes() uint64
17619 GetTxPackets() uint64
17620 GetTxErrors() uint64
17621}
17622
17623func (self *QueueStatsEntry) GetPortNo() Port {
17624 return self.PortNo
17625}
17626
17627func (self *QueueStatsEntry) SetPortNo(v Port) {
17628 self.PortNo = v
17629}
17630
17631func (self *QueueStatsEntry) GetQueueId() uint32 {
17632 return self.QueueId
17633}
17634
17635func (self *QueueStatsEntry) SetQueueId(v uint32) {
17636 self.QueueId = v
17637}
17638
17639func (self *QueueStatsEntry) GetTxBytes() uint64 {
17640 return self.TxBytes
17641}
17642
17643func (self *QueueStatsEntry) SetTxBytes(v uint64) {
17644 self.TxBytes = v
17645}
17646
17647func (self *QueueStatsEntry) GetTxPackets() uint64 {
17648 return self.TxPackets
17649}
17650
17651func (self *QueueStatsEntry) SetTxPackets(v uint64) {
17652 self.TxPackets = v
17653}
17654
17655func (self *QueueStatsEntry) GetTxErrors() uint64 {
17656 return self.TxErrors
17657}
17658
17659func (self *QueueStatsEntry) SetTxErrors(v uint64) {
17660 self.TxErrors = v
17661}
17662
17663func (self *QueueStatsEntry) Serialize(encoder *goloxi.Encoder) error {
17664
17665 self.PortNo.Serialize(encoder)
17666 encoder.PutUint32(uint32(self.QueueId))
17667 encoder.PutUint64(uint64(self.TxBytes))
17668 encoder.PutUint64(uint64(self.TxPackets))
17669 encoder.PutUint64(uint64(self.TxErrors))
17670
17671 return nil
17672}
17673
17674func DecodeQueueStatsEntry(decoder *goloxi.Decoder) (*QueueStatsEntry, error) {
17675 _queuestatsentry := &QueueStatsEntry{}
17676 if decoder.Length() < 32 {
17677 return nil, fmt.Errorf("QueueStatsEntry packet too short: %d < 32", decoder.Length())
17678 }
17679 _queuestatsentry.PortNo.Decode(decoder)
17680 _queuestatsentry.QueueId = uint32(decoder.ReadUint32())
17681 _queuestatsentry.TxBytes = uint64(decoder.ReadUint64())
17682 _queuestatsentry.TxPackets = uint64(decoder.ReadUint64())
17683 _queuestatsentry.TxErrors = uint64(decoder.ReadUint64())
17684 return _queuestatsentry, nil
17685}
17686
17687func NewQueueStatsEntry() *QueueStatsEntry {
17688 obj := &QueueStatsEntry{}
17689 return obj
17690}
17691
17692type TableStatsEntry struct {
17693 TableId uint8
17694 Name string
17695 Wildcards WcBmap
17696 Match MatchBmap
17697 Instructions uint32
17698 WriteActions uint32
17699 ApplyActions uint32
17700 Config uint32
17701 MaxEntries uint32
17702 ActiveCount uint32
17703 LookupCount uint64
17704 MatchedCount uint64
17705}
17706
17707type ITableStatsEntry interface {
17708 goloxi.Serializable
17709 GetTableId() uint8
17710 GetName() string
17711 GetWildcards() WcBmap
17712 GetMatch() MatchBmap
17713 GetInstructions() uint32
17714 GetWriteActions() uint32
17715 GetApplyActions() uint32
17716 GetConfig() uint32
17717 GetMaxEntries() uint32
17718 GetActiveCount() uint32
17719 GetLookupCount() uint64
17720 GetMatchedCount() uint64
17721}
17722
17723func (self *TableStatsEntry) GetTableId() uint8 {
17724 return self.TableId
17725}
17726
17727func (self *TableStatsEntry) SetTableId(v uint8) {
17728 self.TableId = v
17729}
17730
17731func (self *TableStatsEntry) GetName() string {
17732 return self.Name
17733}
17734
17735func (self *TableStatsEntry) SetName(v string) {
17736 self.Name = v
17737}
17738
17739func (self *TableStatsEntry) GetWildcards() WcBmap {
17740 return self.Wildcards
17741}
17742
17743func (self *TableStatsEntry) SetWildcards(v WcBmap) {
17744 self.Wildcards = v
17745}
17746
17747func (self *TableStatsEntry) GetMatch() MatchBmap {
17748 return self.Match
17749}
17750
17751func (self *TableStatsEntry) SetMatch(v MatchBmap) {
17752 self.Match = v
17753}
17754
17755func (self *TableStatsEntry) GetInstructions() uint32 {
17756 return self.Instructions
17757}
17758
17759func (self *TableStatsEntry) SetInstructions(v uint32) {
17760 self.Instructions = v
17761}
17762
17763func (self *TableStatsEntry) GetWriteActions() uint32 {
17764 return self.WriteActions
17765}
17766
17767func (self *TableStatsEntry) SetWriteActions(v uint32) {
17768 self.WriteActions = v
17769}
17770
17771func (self *TableStatsEntry) GetApplyActions() uint32 {
17772 return self.ApplyActions
17773}
17774
17775func (self *TableStatsEntry) SetApplyActions(v uint32) {
17776 self.ApplyActions = v
17777}
17778
17779func (self *TableStatsEntry) GetConfig() uint32 {
17780 return self.Config
17781}
17782
17783func (self *TableStatsEntry) SetConfig(v uint32) {
17784 self.Config = v
17785}
17786
17787func (self *TableStatsEntry) GetMaxEntries() uint32 {
17788 return self.MaxEntries
17789}
17790
17791func (self *TableStatsEntry) SetMaxEntries(v uint32) {
17792 self.MaxEntries = v
17793}
17794
17795func (self *TableStatsEntry) GetActiveCount() uint32 {
17796 return self.ActiveCount
17797}
17798
17799func (self *TableStatsEntry) SetActiveCount(v uint32) {
17800 self.ActiveCount = v
17801}
17802
17803func (self *TableStatsEntry) GetLookupCount() uint64 {
17804 return self.LookupCount
17805}
17806
17807func (self *TableStatsEntry) SetLookupCount(v uint64) {
17808 self.LookupCount = v
17809}
17810
17811func (self *TableStatsEntry) GetMatchedCount() uint64 {
17812 return self.MatchedCount
17813}
17814
17815func (self *TableStatsEntry) SetMatchedCount(v uint64) {
17816 self.MatchedCount = v
17817}
17818
17819func (self *TableStatsEntry) Serialize(encoder *goloxi.Encoder) error {
17820
17821 encoder.PutUint8(uint8(self.TableId))
17822 encoder.Write(bytes.Repeat([]byte{0}, 7))
17823 encoder.Write([]byte(self.Name))
17824 self.Wildcards.Serialize(encoder)
17825 self.Match.Serialize(encoder)
17826 encoder.PutUint32(uint32(self.Instructions))
17827 encoder.PutUint32(uint32(self.WriteActions))
17828 encoder.PutUint32(uint32(self.ApplyActions))
17829 encoder.PutUint32(uint32(self.Config))
17830 encoder.PutUint32(uint32(self.MaxEntries))
17831 encoder.PutUint32(uint32(self.ActiveCount))
17832 encoder.PutUint64(uint64(self.LookupCount))
17833 encoder.PutUint64(uint64(self.MatchedCount))
17834
17835 return nil
17836}
17837
17838func DecodeTableStatsEntry(decoder *goloxi.Decoder) (*TableStatsEntry, error) {
17839 _tablestatsentry := &TableStatsEntry{}
17840 if decoder.Length() < 88 {
17841 return nil, fmt.Errorf("TableStatsEntry packet too short: %d < 88", decoder.Length())
17842 }
17843 _tablestatsentry.TableId = uint8(decoder.ReadByte())
17844 decoder.Skip(7)
17845 _tablestatsentry.Name = string(bytes.Trim(decoder.Read(32), "\x00"))
17846 _tablestatsentry.Wildcards.Decode(decoder)
17847 _tablestatsentry.Match.Decode(decoder)
17848 _tablestatsentry.Instructions = uint32(decoder.ReadUint32())
17849 _tablestatsentry.WriteActions = uint32(decoder.ReadUint32())
17850 _tablestatsentry.ApplyActions = uint32(decoder.ReadUint32())
17851 _tablestatsentry.Config = uint32(decoder.ReadUint32())
17852 _tablestatsentry.MaxEntries = uint32(decoder.ReadUint32())
17853 _tablestatsentry.ActiveCount = uint32(decoder.ReadUint32())
17854 _tablestatsentry.LookupCount = uint64(decoder.ReadUint64())
17855 _tablestatsentry.MatchedCount = uint64(decoder.ReadUint64())
17856 return _tablestatsentry, nil
17857}
17858
17859func NewTableStatsEntry() *TableStatsEntry {
17860 obj := &TableStatsEntry{}
17861 return obj
17862}