Gitiles
Code Review Sign In
gerrit.opencord.org / goloxi / 44bdbfc319927fdbd8a09267da232ae09bc39962 / . / of10 / common.go
blob: fb4567251e2cf412b9645d2925e91a3a80a91c79 [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 of10
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.PutUint16(uint16(self.Port))
714
715 return nil
716}
717
718func DecodeActionNxBundleLoadSlave(decoder *goloxi.Decoder) (*ActionNxBundleLoadSlave, error) {
719 _actionnxbundleloadslave := &ActionNxBundleLoadSlave{}
720 if decoder.Length() < 2 {
721 return nil, fmt.Errorf("ActionNxBundleLoadSlave packet too short: %d < 2", decoder.Length())
722 }
723 _actionnxbundleloadslave.Port = Port(decoder.ReadUint16())
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() < 56 {
1381 return nil, fmt.Errorf("BsnVportL2Gre packet too short: %d < 56", 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 EdPropHeader struct {
1515 PropClass uint16
1516}
1517
1518type IEdPropHeader interface {
1519 goloxi.Serializable
1520 GetPropClass() uint16
1521}
1522
1523func (self *EdPropHeader) GetPropClass() uint16 {
1524 return self.PropClass
1525}
1526
1527func (self *EdPropHeader) SetPropClass(v uint16) {
1528 self.PropClass = v
1529}
1530
1531func (self *EdPropHeader) Serialize(encoder *goloxi.Encoder) error {
1532
1533 encoder.PutUint16(uint16(self.PropClass))
1534
1535 return nil
1536}
1537
1538func DecodeEdPropHeader(decoder *goloxi.Decoder) (IEdPropHeader, error) {
1539 _edpropheader := &EdPropHeader{}
1540 if decoder.Length() < 2 {
1541 return nil, fmt.Errorf("EdPropHeader packet too short: %d < 2", decoder.Length())
1542 }
1543 _edpropheader.PropClass = uint16(decoder.ReadUint16())
1544
1545 switch _edpropheader.PropClass {
1546 case 4:
1547 return DecodeEdPropNsh(_edpropheader, decoder)
1548 default:
1549 return nil, fmt.Errorf("Invalid type '%d' for 'EdPropHeader'", _edpropheader.PropClass)
1550 }
1551}
1552
1553func NewEdPropHeader(_prop_class uint16) *EdPropHeader {
1554 obj := &EdPropHeader{}
1555 obj.PropClass = _prop_class
1556 return obj
1557}
1558
1559type EdPropNsh struct {
1560 *EdPropHeader
1561 Type uint8
1562 Len uint8
1563}
1564
1565type IEdPropNsh interface {
1566 IEdPropHeader
1567 GetType() uint8
1568 GetLen() uint8
1569}
1570
1571func (self *EdPropNsh) GetType() uint8 {
1572 return self.Type
1573}
1574
1575func (self *EdPropNsh) SetType(v uint8) {
1576 self.Type = v
1577}
1578
1579func (self *EdPropNsh) GetLen() uint8 {
1580 return self.Len
1581}
1582
1583func (self *EdPropNsh) SetLen(v uint8) {
1584 self.Len = v
1585}
1586
1587func (self *EdPropNsh) Serialize(encoder *goloxi.Encoder) error {
1588 if err := self.EdPropHeader.Serialize(encoder); err != nil {
1589 return err
1590 }
1591
1592 encoder.PutUint8(uint8(self.Type))
1593 encoder.PutUint8(uint8(self.Len))
1594
1595 return nil
1596}
1597
1598func DecodeEdPropNsh(parent *EdPropHeader, decoder *goloxi.Decoder) (IEdPropNsh, error) {
1599 _edpropnsh := &EdPropNsh{EdPropHeader: parent}
1600 if decoder.Length() < 2 {
1601 return nil, fmt.Errorf("EdPropNsh packet too short: %d < 2", decoder.Length())
1602 }
1603 defer decoder.SkipAlign()
1604
1605 _edpropnsh.Type = uint8(decoder.ReadByte())
1606 _edpropnsh.Len = uint8(decoder.ReadByte())
1607 oldDecoder := decoder
1608 defer func() { decoder = oldDecoder }()
1609 decoder = decoder.SliceDecoder(int(((_edpropnsh.Len)+7)/8*8), 1+3)
1610
1611 switch _edpropnsh.Type {
1612 case 1:
1613 return DecodeEdPropNshMdType(_edpropnsh, decoder)
1614 case 2:
1615 return DecodeEdPropNshTlv(_edpropnsh, decoder)
1616 default:
1617 return nil, fmt.Errorf("Invalid type '%d' for 'EdPropNsh'", _edpropnsh.Type)
1618 }
1619}
1620
1621func NewEdPropNsh(_type uint8) *EdPropNsh {
1622 obj := &EdPropNsh{
1623 EdPropHeader: NewEdPropHeader(4),
1624 }
1625 obj.Type = _type
1626 return obj
1627}
1628
1629type EdPropNshMdType struct {
1630 *EdPropNsh
1631 MdType uint8
1632}
1633
1634type IEdPropNshMdType interface {
1635 IEdPropNsh
1636 GetMdType() uint8
1637}
1638
1639func (self *EdPropNshMdType) GetMdType() uint8 {
1640 return self.MdType
1641}
1642
1643func (self *EdPropNshMdType) SetMdType(v uint8) {
1644 self.MdType = v
1645}
1646
1647func (self *EdPropNshMdType) Serialize(encoder *goloxi.Encoder) error {
1648 startIndex := len(encoder.Bytes())
1649 if err := self.EdPropNsh.Serialize(encoder); err != nil {
1650 return err
1651 }
1652
1653 encoder.PutUint8(uint8(self.MdType))
1654 encoder.Write(bytes.Repeat([]byte{0}, 3))
1655 length := len(encoder.Bytes()) - startIndex
1656
1657 encoder.Bytes()[startIndex+3] = uint8(length)
1658
1659 return nil
1660}
1661
1662func DecodeEdPropNshMdType(parent *EdPropNsh, decoder *goloxi.Decoder) (*EdPropNshMdType, error) {
1663 _edpropnshmdtype := &EdPropNshMdType{EdPropNsh: parent}
1664 if decoder.Length() < 4 {
1665 return nil, fmt.Errorf("EdPropNshMdType packet too short: %d < 4", decoder.Length())
1666 }
1667 _edpropnshmdtype.MdType = uint8(decoder.ReadByte())
1668 decoder.Skip(3)
1669 return _edpropnshmdtype, nil
1670}
1671
1672func NewEdPropNshMdType() *EdPropNshMdType {
1673 obj := &EdPropNshMdType{
1674 EdPropNsh: NewEdPropNsh(1),
1675 }
1676 return obj
1677}
1678
1679type EdPropNshTlv struct {
1680 *EdPropNsh
1681 TlvClass uint16
1682 TlvType uint8
1683 TlvLen uint8
1684 Value []byte
1685}
1686
1687type IEdPropNshTlv interface {
1688 IEdPropNsh
1689 GetTlvClass() uint16
1690 GetTlvType() uint8
1691 GetTlvLen() uint8
1692 GetValue() []byte
1693}
1694
1695func (self *EdPropNshTlv) GetTlvClass() uint16 {
1696 return self.TlvClass
1697}
1698
1699func (self *EdPropNshTlv) SetTlvClass(v uint16) {
1700 self.TlvClass = v
1701}
1702
1703func (self *EdPropNshTlv) GetTlvType() uint8 {
1704 return self.TlvType
1705}
1706
1707func (self *EdPropNshTlv) SetTlvType(v uint8) {
1708 self.TlvType = v
1709}
1710
1711func (self *EdPropNshTlv) GetTlvLen() uint8 {
1712 return self.TlvLen
1713}
1714
1715func (self *EdPropNshTlv) SetTlvLen(v uint8) {
1716 self.TlvLen = v
1717}
1718
1719func (self *EdPropNshTlv) GetValue() []byte {
1720 return self.Value
1721}
1722
1723func (self *EdPropNshTlv) SetValue(v []byte) {
1724 self.Value = v
1725}
1726
1727func (self *EdPropNshTlv) Serialize(encoder *goloxi.Encoder) error {
1728 startIndex := len(encoder.Bytes())
1729 if err := self.EdPropNsh.Serialize(encoder); err != nil {
1730 return err
1731 }
1732
1733 encoder.PutUint16(uint16(self.TlvClass))
1734 encoder.PutUint8(uint8(self.TlvType))
1735 encoder.PutUint8(uint8(self.TlvLen))
1736 encoder.Write(self.Value)
1737 length := len(encoder.Bytes()) - startIndex
1738
1739 encoder.Bytes()[startIndex+3] = uint8(length)
1740
1741 return nil
1742}
1743
1744func DecodeEdPropNshTlv(parent *EdPropNsh, decoder *goloxi.Decoder) (*EdPropNshTlv, error) {
1745 _edpropnshtlv := &EdPropNshTlv{EdPropNsh: parent}
1746 if decoder.Length() < 4 {
1747 return nil, fmt.Errorf("EdPropNshTlv packet too short: %d < 4", decoder.Length())
1748 }
1749 _edpropnshtlv.TlvClass = uint16(decoder.ReadUint16())
1750 _edpropnshtlv.TlvType = uint8(decoder.ReadByte())
1751 _edpropnshtlv.TlvLen = uint8(decoder.ReadByte())
1752 _edpropnshtlv.Value = decoder.SliceDecoder(int(_edpropnshtlv.TlvLen), 0).Read(int(_edpropnshtlv.TlvLen))
1753 return _edpropnshtlv, nil
1754}
1755
1756func NewEdPropNshTlv() *EdPropNshTlv {
1757 obj := &EdPropNshTlv{
1758 EdPropNsh: NewEdPropNsh(2),
1759 }
1760 return obj
1761}
1762
1763type FlowModSpec struct {
1764 SrcDst uint8
1765 NBits uint8
1766}
1767
1768type IFlowModSpec interface {
1769 goloxi.Serializable
1770 GetSrcDst() uint8
1771 GetNBits() uint8
1772}
1773
1774func (self *FlowModSpec) GetSrcDst() uint8 {
1775 return self.SrcDst
1776}
1777
1778func (self *FlowModSpec) SetSrcDst(v uint8) {
1779 self.SrcDst = v
1780}
1781
1782func (self *FlowModSpec) GetNBits() uint8 {
1783 return self.NBits
1784}
1785
1786func (self *FlowModSpec) SetNBits(v uint8) {
1787 self.NBits = v
1788}
1789
1790func (self *FlowModSpec) Serialize(encoder *goloxi.Encoder) error {
1791
1792 encoder.PutUint8(uint8(self.SrcDst))
1793 encoder.PutUint8(uint8(self.NBits))
1794
1795 return nil
1796}
1797
1798func DecodeFlowModSpec(decoder *goloxi.Decoder) (IFlowModSpec, error) {
1799 _flowmodspec := &FlowModSpec{}
1800 if decoder.Length() < 2 {
1801 return nil, fmt.Errorf("FlowModSpec packet too short: %d < 2", decoder.Length())
1802 }
1803 _flowmodspec.SrcDst = uint8(decoder.ReadByte())
1804 _flowmodspec.NBits = uint8(decoder.ReadByte())
1805 if _flowmodspec.SrcDst == 0 && _flowmodspec.NBits == 0 {
1806 return nil, nil
1807 }
1808
1809 switch _flowmodspec.SrcDst {
1810 case 0:
1811 return DecodeFlowModSpecSrc0Dst0(_flowmodspec, decoder)
1812 case 8:
1813 return DecodeFlowModSpecSrc0Dst1(_flowmodspec, decoder)
1814 case 40:
1815 return DecodeFlowModSpecSrc1Dst1(_flowmodspec, decoder)
1816 case 16:
1817 return DecodeFlowModSpecSrc0Dst2(_flowmodspec, decoder)
1818 case 32:
1819 return DecodeFlowModSpecSrc1Dst0(_flowmodspec, decoder)
1820 default:
1821 return nil, fmt.Errorf("Invalid type '%d' for 'FlowModSpec'", _flowmodspec.SrcDst)
1822 }
1823}
1824
1825func NewFlowModSpec(_src_dst uint8) *FlowModSpec {
1826 obj := &FlowModSpec{}
1827 obj.SrcDst = _src_dst
1828 return obj
1829}
1830
1831type FlowModSpecSrc0Dst0 struct {
1832 *FlowModSpec
1833 Src goloxi.IOxmId
1834 SrcOfs uint16
1835 Dst goloxi.IOxmId
1836 DstOfs uint16
1837}
1838
1839type IFlowModSpecSrc0Dst0 interface {
1840 IFlowModSpec
1841 GetSrc() goloxi.IOxmId
1842 GetSrcOfs() uint16
1843 GetDst() goloxi.IOxmId
1844 GetDstOfs() uint16
1845}
1846
1847func (self *FlowModSpecSrc0Dst0) GetSrc() goloxi.IOxmId {
1848 return self.Src
1849}
1850
1851func (self *FlowModSpecSrc0Dst0) SetSrc(v goloxi.IOxmId) {
1852 self.Src = v
1853}
1854
1855func (self *FlowModSpecSrc0Dst0) GetSrcOfs() uint16 {
1856 return self.SrcOfs
1857}
1858
1859func (self *FlowModSpecSrc0Dst0) SetSrcOfs(v uint16) {
1860 self.SrcOfs = v
1861}
1862
1863func (self *FlowModSpecSrc0Dst0) GetDst() goloxi.IOxmId {
1864 return self.Dst
1865}
1866
1867func (self *FlowModSpecSrc0Dst0) SetDst(v goloxi.IOxmId) {
1868 self.Dst = v
1869}
1870
1871func (self *FlowModSpecSrc0Dst0) GetDstOfs() uint16 {
1872 return self.DstOfs
1873}
1874
1875func (self *FlowModSpecSrc0Dst0) SetDstOfs(v uint16) {
1876 self.DstOfs = v
1877}
1878
1879func (self *FlowModSpecSrc0Dst0) Serialize(encoder *goloxi.Encoder) error {
1880 if err := self.FlowModSpec.Serialize(encoder); err != nil {
1881 return err
1882 }
1883
1884 self.Src.Serialize(encoder)
1885 encoder.PutUint16(uint16(self.SrcOfs))
1886 self.Dst.Serialize(encoder)
1887 encoder.PutUint16(uint16(self.DstOfs))
1888
1889 return nil
1890}
1891
1892func DecodeFlowModSpecSrc0Dst0(parent *FlowModSpec, decoder *goloxi.Decoder) (IFlowModSpecSrc0Dst0, error) {
1893 _flowmodspecsrc0dst0 := &FlowModSpecSrc0Dst0{FlowModSpec: parent}
1894 if decoder.Length() < 12 {
1895 return nil, fmt.Errorf("FlowModSpecSrc0Dst0 packet too short: %d < 12", decoder.Length())
1896 }
1897 if obj, err := DecodeOxmId(decoder); err != nil {
1898 return nil, err
1899 } else {
1900 _flowmodspecsrc0dst0.Src = obj
1901 }
1902
1903 _flowmodspecsrc0dst0.SrcOfs = uint16(decoder.ReadUint16())
1904 if obj, err := DecodeOxmId(decoder); err != nil {
1905 return nil, err
1906 } else {
1907 _flowmodspecsrc0dst0.Dst = obj
1908 }
1909
1910 _flowmodspecsrc0dst0.DstOfs = uint16(decoder.ReadUint16())
1911 return _flowmodspecsrc0dst0, nil
1912}
1913
1914func NewFlowModSpecSrc0Dst0(_n_bits uint8) *FlowModSpecSrc0Dst0 {
1915 obj := &FlowModSpecSrc0Dst0{
1916 FlowModSpec: NewFlowModSpec(0),
1917 }
1918 obj.NBits = _n_bits
1919 return obj
1920}
1921
1922type FlowModSpecSrc0Dst1 struct {
1923 *FlowModSpec
1924 Src goloxi.IOxmId
1925 SrcOfs uint16
1926 Dst goloxi.IOxmId
1927 DstOfs uint16
1928}
1929
1930type IFlowModSpecSrc0Dst1 interface {
1931 IFlowModSpec
1932 GetSrc() goloxi.IOxmId
1933 GetSrcOfs() uint16
1934 GetDst() goloxi.IOxmId
1935 GetDstOfs() uint16
1936}
1937
1938func (self *FlowModSpecSrc0Dst1) GetSrc() goloxi.IOxmId {
1939 return self.Src
1940}
1941
1942func (self *FlowModSpecSrc0Dst1) SetSrc(v goloxi.IOxmId) {
1943 self.Src = v
1944}
1945
1946func (self *FlowModSpecSrc0Dst1) GetSrcOfs() uint16 {
1947 return self.SrcOfs
1948}
1949
1950func (self *FlowModSpecSrc0Dst1) SetSrcOfs(v uint16) {
1951 self.SrcOfs = v
1952}
1953
1954func (self *FlowModSpecSrc0Dst1) GetDst() goloxi.IOxmId {
1955 return self.Dst
1956}
1957
1958func (self *FlowModSpecSrc0Dst1) SetDst(v goloxi.IOxmId) {
1959 self.Dst = v
1960}
1961
1962func (self *FlowModSpecSrc0Dst1) GetDstOfs() uint16 {
1963 return self.DstOfs
1964}
1965
1966func (self *FlowModSpecSrc0Dst1) SetDstOfs(v uint16) {
1967 self.DstOfs = v
1968}
1969
1970func (self *FlowModSpecSrc0Dst1) Serialize(encoder *goloxi.Encoder) error {
1971 if err := self.FlowModSpec.Serialize(encoder); err != nil {
1972 return err
1973 }
1974
1975 self.Src.Serialize(encoder)
1976 encoder.PutUint16(uint16(self.SrcOfs))
1977 self.Dst.Serialize(encoder)
1978 encoder.PutUint16(uint16(self.DstOfs))
1979
1980 return nil
1981}
1982
1983func DecodeFlowModSpecSrc0Dst1(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc0Dst1, error) {
1984 _flowmodspecsrc0dst1 := &FlowModSpecSrc0Dst1{FlowModSpec: parent}
1985 if decoder.Length() < 12 {
1986 return nil, fmt.Errorf("FlowModSpecSrc0Dst1 packet too short: %d < 12", decoder.Length())
1987 }
1988 if obj, err := DecodeOxmId(decoder); err != nil {
1989 return nil, err
1990 } else {
1991 _flowmodspecsrc0dst1.Src = obj
1992 }
1993
1994 _flowmodspecsrc0dst1.SrcOfs = uint16(decoder.ReadUint16())
1995 if obj, err := DecodeOxmId(decoder); err != nil {
1996 return nil, err
1997 } else {
1998 _flowmodspecsrc0dst1.Dst = obj
1999 }
2000
2001 _flowmodspecsrc0dst1.DstOfs = uint16(decoder.ReadUint16())
2002 return _flowmodspecsrc0dst1, nil
2003}
2004
2005func NewFlowModSpecSrc0Dst1() *FlowModSpecSrc0Dst1 {
2006 obj := &FlowModSpecSrc0Dst1{
2007 FlowModSpec: NewFlowModSpec(8),
2008 }
2009 return obj
2010}
2011
2012type FlowModSpecSrc0Dst2 struct {
2013 *FlowModSpec
2014 Src goloxi.IOxmId
2015 SrcOfs uint16
2016}
2017
2018type IFlowModSpecSrc0Dst2 interface {
2019 IFlowModSpec
2020 GetSrc() goloxi.IOxmId
2021 GetSrcOfs() uint16
2022}
2023
2024func (self *FlowModSpecSrc0Dst2) GetSrc() goloxi.IOxmId {
2025 return self.Src
2026}
2027
2028func (self *FlowModSpecSrc0Dst2) SetSrc(v goloxi.IOxmId) {
2029 self.Src = v
2030}
2031
2032func (self *FlowModSpecSrc0Dst2) GetSrcOfs() uint16 {
2033 return self.SrcOfs
2034}
2035
2036func (self *FlowModSpecSrc0Dst2) SetSrcOfs(v uint16) {
2037 self.SrcOfs = v
2038}
2039
2040func (self *FlowModSpecSrc0Dst2) Serialize(encoder *goloxi.Encoder) error {
2041 if err := self.FlowModSpec.Serialize(encoder); err != nil {
2042 return err
2043 }
2044
2045 self.Src.Serialize(encoder)
2046 encoder.PutUint16(uint16(self.SrcOfs))
2047
2048 return nil
2049}
2050
2051func DecodeFlowModSpecSrc0Dst2(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc0Dst2, error) {
2052 _flowmodspecsrc0dst2 := &FlowModSpecSrc0Dst2{FlowModSpec: parent}
2053 if decoder.Length() < 6 {
2054 return nil, fmt.Errorf("FlowModSpecSrc0Dst2 packet too short: %d < 6", decoder.Length())
2055 }
2056 if obj, err := DecodeOxmId(decoder); err != nil {
2057 return nil, err
2058 } else {
2059 _flowmodspecsrc0dst2.Src = obj
2060 }
2061
2062 _flowmodspecsrc0dst2.SrcOfs = uint16(decoder.ReadUint16())
2063 return _flowmodspecsrc0dst2, nil
2064}
2065
2066func NewFlowModSpecSrc0Dst2() *FlowModSpecSrc0Dst2 {
2067 obj := &FlowModSpecSrc0Dst2{
2068 FlowModSpec: NewFlowModSpec(16),
2069 }
2070 return obj
2071}
2072
2073type FlowModSpecSrc1Dst0 struct {
2074 *FlowModSpec
2075 Src []byte
2076 Dst goloxi.IOxmId
2077 DstOfs uint16
2078}
2079
2080type IFlowModSpecSrc1Dst0 interface {
2081 IFlowModSpec
2082 GetSrc() []byte
2083 GetDst() goloxi.IOxmId
2084 GetDstOfs() uint16
2085}
2086
2087func (self *FlowModSpecSrc1Dst0) GetSrc() []byte {
2088 return self.Src
2089}
2090
2091func (self *FlowModSpecSrc1Dst0) SetSrc(v []byte) {
2092 self.Src = v
2093}
2094
2095func (self *FlowModSpecSrc1Dst0) GetDst() goloxi.IOxmId {
2096 return self.Dst
2097}
2098
2099func (self *FlowModSpecSrc1Dst0) SetDst(v goloxi.IOxmId) {
2100 self.Dst = v
2101}
2102
2103func (self *FlowModSpecSrc1Dst0) GetDstOfs() uint16 {
2104 return self.DstOfs
2105}
2106
2107func (self *FlowModSpecSrc1Dst0) SetDstOfs(v uint16) {
2108 self.DstOfs = v
2109}
2110
2111func (self *FlowModSpecSrc1Dst0) Serialize(encoder *goloxi.Encoder) error {
2112 if err := self.FlowModSpec.Serialize(encoder); err != nil {
2113 return err
2114 }
2115
2116 encoder.Write(self.Src)
2117 self.Dst.Serialize(encoder)
2118 encoder.PutUint16(uint16(self.DstOfs))
2119
2120 return nil
2121}
2122
2123func DecodeFlowModSpecSrc1Dst0(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc1Dst0, error) {
2124 _flowmodspecsrc1dst0 := &FlowModSpecSrc1Dst0{FlowModSpec: parent}
2125 if decoder.Length() < 6 {
2126 return nil, fmt.Errorf("FlowModSpecSrc1Dst0 packet too short: %d < 6", decoder.Length())
2127 }
2128 _flowmodspecsrc1dst0.Src = decoder.SliceDecoder(int((_flowmodspecsrc1dst0.NBits+15)/16*2), 0).Read(int(_flowmodspecsrc1dst0.NBits))
2129 if obj, err := DecodeOxmId(decoder); err != nil {
2130 return nil, err
2131 } else {
2132 _flowmodspecsrc1dst0.Dst = obj
2133 }
2134
2135 _flowmodspecsrc1dst0.DstOfs = uint16(decoder.ReadUint16())
2136 return _flowmodspecsrc1dst0, nil
2137}
2138
2139func NewFlowModSpecSrc1Dst0() *FlowModSpecSrc1Dst0 {
2140 obj := &FlowModSpecSrc1Dst0{
2141 FlowModSpec: NewFlowModSpec(32),
2142 }
2143 return obj
2144}
2145
2146type FlowModSpecSrc1Dst1 struct {
2147 *FlowModSpec
2148 Src []byte
2149 Dst goloxi.IOxmId
2150 DstOfs uint16
2151}
2152
2153type IFlowModSpecSrc1Dst1 interface {
2154 IFlowModSpec
2155 GetSrc() []byte
2156 GetDst() goloxi.IOxmId
2157 GetDstOfs() uint16
2158}
2159
2160func (self *FlowModSpecSrc1Dst1) GetSrc() []byte {
2161 return self.Src
2162}
2163
2164func (self *FlowModSpecSrc1Dst1) SetSrc(v []byte) {
2165 self.Src = v
2166}
2167
2168func (self *FlowModSpecSrc1Dst1) GetDst() goloxi.IOxmId {
2169 return self.Dst
2170}
2171
2172func (self *FlowModSpecSrc1Dst1) SetDst(v goloxi.IOxmId) {
2173 self.Dst = v
2174}
2175
2176func (self *FlowModSpecSrc1Dst1) GetDstOfs() uint16 {
2177 return self.DstOfs
2178}
2179
2180func (self *FlowModSpecSrc1Dst1) SetDstOfs(v uint16) {
2181 self.DstOfs = v
2182}
2183
2184func (self *FlowModSpecSrc1Dst1) Serialize(encoder *goloxi.Encoder) error {
2185 if err := self.FlowModSpec.Serialize(encoder); err != nil {
2186 return err
2187 }
2188
2189 encoder.Write(self.Src)
2190 self.Dst.Serialize(encoder)
2191 encoder.PutUint16(uint16(self.DstOfs))
2192
2193 return nil
2194}
2195
2196func DecodeFlowModSpecSrc1Dst1(parent *FlowModSpec, decoder *goloxi.Decoder) (*FlowModSpecSrc1Dst1, error) {
2197 _flowmodspecsrc1dst1 := &FlowModSpecSrc1Dst1{FlowModSpec: parent}
2198 if decoder.Length() < 6 {
2199 return nil, fmt.Errorf("FlowModSpecSrc1Dst1 packet too short: %d < 6", decoder.Length())
2200 }
2201 _flowmodspecsrc1dst1.Src = decoder.SliceDecoder(int((_flowmodspecsrc1dst1.NBits+15)/16*2), 0).Read(int(_flowmodspecsrc1dst1.NBits))
2202 if obj, err := DecodeOxmId(decoder); err != nil {
2203 return nil, err
2204 } else {
2205 _flowmodspecsrc1dst1.Dst = obj
2206 }
2207
2208 _flowmodspecsrc1dst1.DstOfs = uint16(decoder.ReadUint16())
2209 return _flowmodspecsrc1dst1, nil
2210}
2211
2212func NewFlowModSpecSrc1Dst1() *FlowModSpecSrc1Dst1 {
2213 obj := &FlowModSpecSrc1Dst1{
2214 FlowModSpec: NewFlowModSpec(40),
2215 }
2216 return obj
2217}
2218
2219type FlowStatsEntry struct {
2220 Length uint16
2221 TableId uint8
2222 Match Match
2223 DurationSec uint32
2224 DurationNsec uint32
2225 Priority uint16
2226 IdleTimeout uint16
2227 HardTimeout uint16
2228 Cookie uint64
2229 PacketCount uint64
2230 ByteCount uint64
2231 Actions []goloxi.IAction
2232}
2233
2234type IFlowStatsEntry interface {
2235 goloxi.Serializable
2236 GetLength() uint16
2237 GetTableId() uint8
2238 GetMatch() Match
2239 GetDurationSec() uint32
2240 GetDurationNsec() uint32
2241 GetPriority() uint16
2242 GetIdleTimeout() uint16
2243 GetHardTimeout() uint16
2244 GetCookie() uint64
2245 GetPacketCount() uint64
2246 GetByteCount() uint64
2247 GetActions() []goloxi.IAction
2248}
2249
2250func (self *FlowStatsEntry) GetLength() uint16 {
2251 return self.Length
2252}
2253
2254func (self *FlowStatsEntry) SetLength(v uint16) {
2255 self.Length = v
2256}
2257
2258func (self *FlowStatsEntry) GetTableId() uint8 {
2259 return self.TableId
2260}
2261
2262func (self *FlowStatsEntry) SetTableId(v uint8) {
2263 self.TableId = v
2264}
2265
2266func (self *FlowStatsEntry) GetMatch() Match {
2267 return self.Match
2268}
2269
2270func (self *FlowStatsEntry) SetMatch(v Match) {
2271 self.Match = v
2272}
2273
2274func (self *FlowStatsEntry) GetDurationSec() uint32 {
2275 return self.DurationSec
2276}
2277
2278func (self *FlowStatsEntry) SetDurationSec(v uint32) {
2279 self.DurationSec = v
2280}
2281
2282func (self *FlowStatsEntry) GetDurationNsec() uint32 {
2283 return self.DurationNsec
2284}
2285
2286func (self *FlowStatsEntry) SetDurationNsec(v uint32) {
2287 self.DurationNsec = v
2288}
2289
2290func (self *FlowStatsEntry) GetPriority() uint16 {
2291 return self.Priority
2292}
2293
2294func (self *FlowStatsEntry) SetPriority(v uint16) {
2295 self.Priority = v
2296}
2297
2298func (self *FlowStatsEntry) GetIdleTimeout() uint16 {
2299 return self.IdleTimeout
2300}
2301
2302func (self *FlowStatsEntry) SetIdleTimeout(v uint16) {
2303 self.IdleTimeout = v
2304}
2305
2306func (self *FlowStatsEntry) GetHardTimeout() uint16 {
2307 return self.HardTimeout
2308}
2309
2310func (self *FlowStatsEntry) SetHardTimeout(v uint16) {
2311 self.HardTimeout = v
2312}
2313
2314func (self *FlowStatsEntry) GetCookie() uint64 {
2315 return self.Cookie
2316}
2317
2318func (self *FlowStatsEntry) SetCookie(v uint64) {
2319 self.Cookie = v
2320}
2321
2322func (self *FlowStatsEntry) GetPacketCount() uint64 {
2323 return self.PacketCount
2324}
2325
2326func (self *FlowStatsEntry) SetPacketCount(v uint64) {
2327 self.PacketCount = v
2328}
2329
2330func (self *FlowStatsEntry) GetByteCount() uint64 {
2331 return self.ByteCount
2332}
2333
2334func (self *FlowStatsEntry) SetByteCount(v uint64) {
2335 self.ByteCount = v
2336}
2337
2338func (self *FlowStatsEntry) GetActions() []goloxi.IAction {
2339 return self.Actions
2340}
2341
2342func (self *FlowStatsEntry) SetActions(v []goloxi.IAction) {
2343 self.Actions = v
2344}
2345
2346func (self *FlowStatsEntry) Serialize(encoder *goloxi.Encoder) error {
2347 startIndex := len(encoder.Bytes())
2348
2349 encoder.PutUint16(uint16(self.Length))
2350 encoder.PutUint8(uint8(self.TableId))
2351 encoder.Write(bytes.Repeat([]byte{0}, 1))
2352 if err := self.Match.Serialize(encoder); err != nil {
2353 return err
2354 }
2355
2356 encoder.PutUint32(uint32(self.DurationSec))
2357 encoder.PutUint32(uint32(self.DurationNsec))
2358 encoder.PutUint16(uint16(self.Priority))
2359 encoder.PutUint16(uint16(self.IdleTimeout))
2360 encoder.PutUint16(uint16(self.HardTimeout))
2361 encoder.Write(bytes.Repeat([]byte{0}, 6))
2362 encoder.PutUint64(uint64(self.Cookie))
2363 encoder.PutUint64(uint64(self.PacketCount))
2364 encoder.PutUint64(uint64(self.ByteCount))
2365 for _, obj := range self.Actions {
2366 if err := obj.Serialize(encoder); err != nil {
2367 return err
2368 }
2369 }
2370 length := len(encoder.Bytes()) - startIndex
2371
2372 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
2373
2374 return nil
2375}
2376
2377func DecodeFlowStatsEntry(decoder *goloxi.Decoder) (*FlowStatsEntry, error) {
2378 _flowstatsentry := &FlowStatsEntry{}
2379 if decoder.Length() < 88 {
2380 return nil, fmt.Errorf("FlowStatsEntry packet too short: %d < 88", decoder.Length())
2381 }
2382 _flowstatsentry.Length = uint16(decoder.ReadUint16())
2383 oldDecoder := decoder
2384 defer func() { decoder = oldDecoder }()
2385 decoder = decoder.SliceDecoder(int(_flowstatsentry.Length), 2+0)
2386 _flowstatsentry.TableId = uint8(decoder.ReadByte())
2387 decoder.Skip(1)
2388 if err := _flowstatsentry.Match.Decode(decoder); err != nil {
2389 return nil, err
2390 }
2391
2392 _flowstatsentry.DurationSec = uint32(decoder.ReadUint32())
2393 _flowstatsentry.DurationNsec = uint32(decoder.ReadUint32())
2394 _flowstatsentry.Priority = uint16(decoder.ReadUint16())
2395 _flowstatsentry.IdleTimeout = uint16(decoder.ReadUint16())
2396 _flowstatsentry.HardTimeout = uint16(decoder.ReadUint16())
2397 decoder.Skip(6)
2398 _flowstatsentry.Cookie = uint64(decoder.ReadUint64())
2399 _flowstatsentry.PacketCount = uint64(decoder.ReadUint64())
2400 _flowstatsentry.ByteCount = uint64(decoder.ReadUint64())
2401
2402 for decoder.Length() >= 8 {
2403 item, err := DecodeAction(decoder)
2404 if err != nil {
2405 return nil, err
2406 }
2407 if item != nil {
2408 _flowstatsentry.Actions = append(_flowstatsentry.Actions, item)
2409 }
2410 }
2411 return _flowstatsentry, nil
2412}
2413
2414func NewFlowStatsEntry() *FlowStatsEntry {
2415 obj := &FlowStatsEntry{}
2416 return obj
2417}
2418
2419type MatchV1 struct {
2420 Wildcards WcBmap
2421 InPort Port
2422 EthSrc net.HardwareAddr
2423 EthDst net.HardwareAddr
2424 VlanVid uint16
2425 VlanPcp uint8
2426 EthType uint16
2427 IpDscp uint8
2428 IpProto uint8
2429 Ipv4Src net.IP
2430 Ipv4Dst net.IP
2431 TcpSrc uint16
2432 TcpDst uint16
2433}
2434
2435type IMatchV1 interface {
2436 goloxi.Serializable
2437 GetWildcards() WcBmap
2438 GetInPort() Port
2439 GetEthSrc() net.HardwareAddr
2440 GetEthDst() net.HardwareAddr
2441 GetVlanVid() uint16
2442 GetVlanPcp() uint8
2443 GetEthType() uint16
2444 GetIpDscp() uint8
2445 GetIpProto() uint8
2446 GetIpv4Src() net.IP
2447 GetIpv4Dst() net.IP
2448 GetTcpSrc() uint16
2449 GetTcpDst() uint16
2450}
2451
2452func (self *MatchV1) GetWildcards() WcBmap {
2453 return self.Wildcards
2454}
2455
2456func (self *MatchV1) SetWildcards(v WcBmap) {
2457 self.Wildcards = v
2458}
2459
2460func (self *MatchV1) GetInPort() Port {
2461 return self.InPort
2462}
2463
2464func (self *MatchV1) SetInPort(v Port) {
2465 self.InPort = v
2466}
2467
2468func (self *MatchV1) GetEthSrc() net.HardwareAddr {
2469 return self.EthSrc
2470}
2471
2472func (self *MatchV1) SetEthSrc(v net.HardwareAddr) {
2473 self.EthSrc = v
2474}
2475
2476func (self *MatchV1) GetEthDst() net.HardwareAddr {
2477 return self.EthDst
2478}
2479
2480func (self *MatchV1) SetEthDst(v net.HardwareAddr) {
2481 self.EthDst = v
2482}
2483
2484func (self *MatchV1) GetVlanVid() uint16 {
2485 return self.VlanVid
2486}
2487
2488func (self *MatchV1) SetVlanVid(v uint16) {
2489 self.VlanVid = v
2490}
2491
2492func (self *MatchV1) GetVlanPcp() uint8 {
2493 return self.VlanPcp
2494}
2495
2496func (self *MatchV1) SetVlanPcp(v uint8) {
2497 self.VlanPcp = v
2498}
2499
2500func (self *MatchV1) GetEthType() uint16 {
2501 return self.EthType
2502}
2503
2504func (self *MatchV1) SetEthType(v uint16) {
2505 self.EthType = v
2506}
2507
2508func (self *MatchV1) GetIpDscp() uint8 {
2509 return self.IpDscp
2510}
2511
2512func (self *MatchV1) SetIpDscp(v uint8) {
2513 self.IpDscp = v
2514}
2515
2516func (self *MatchV1) GetIpProto() uint8 {
2517 return self.IpProto
2518}
2519
2520func (self *MatchV1) SetIpProto(v uint8) {
2521 self.IpProto = v
2522}
2523
2524func (self *MatchV1) GetIpv4Src() net.IP {
2525 return self.Ipv4Src
2526}
2527
2528func (self *MatchV1) SetIpv4Src(v net.IP) {
2529 self.Ipv4Src = v
2530}
2531
2532func (self *MatchV1) GetIpv4Dst() net.IP {
2533 return self.Ipv4Dst
2534}
2535
2536func (self *MatchV1) SetIpv4Dst(v net.IP) {
2537 self.Ipv4Dst = v
2538}
2539
2540func (self *MatchV1) GetTcpSrc() uint16 {
2541 return self.TcpSrc
2542}
2543
2544func (self *MatchV1) SetTcpSrc(v uint16) {
2545 self.TcpSrc = v
2546}
2547
2548func (self *MatchV1) GetTcpDst() uint16 {
2549 return self.TcpDst
2550}
2551
2552func (self *MatchV1) SetTcpDst(v uint16) {
2553 self.TcpDst = v
2554}
2555
2556func (self *MatchV1) Serialize(encoder *goloxi.Encoder) error {
2557
2558 self.Wildcards.Serialize(encoder)
2559 self.InPort.Serialize(encoder)
2560 encoder.Write(self.EthSrc)
2561 encoder.Write(self.EthDst)
2562 encoder.PutUint16(uint16(self.VlanVid))
2563 encoder.PutUint8(uint8(self.VlanPcp))
2564 encoder.Write(bytes.Repeat([]byte{0}, 1))
2565 encoder.PutUint16(uint16(self.EthType))
2566 encoder.PutUint8(uint8(self.IpDscp))
2567 encoder.PutUint8(uint8(self.IpProto))
2568 encoder.Write(bytes.Repeat([]byte{0}, 2))
2569 encoder.Write(self.Ipv4Src.To4())
2570 encoder.Write(self.Ipv4Dst.To4())
2571 encoder.PutUint16(uint16(self.TcpSrc))
2572 encoder.PutUint16(uint16(self.TcpDst))
2573
2574 return nil
2575}
2576func (self *MatchV1) Decode(decoder *goloxi.Decoder) error {
2577 if decoder.Length() < 40 {
2578 return fmt.Errorf("MatchV1 packet too short: %d < 40", decoder.Length())
2579 }
2580
2581 self.Wildcards.Decode(decoder)
2582 self.InPort.Decode(decoder)
2583 self.EthSrc = net.HardwareAddr(decoder.Read(6))
2584 self.EthDst = net.HardwareAddr(decoder.Read(6))
2585 self.VlanVid = uint16(decoder.ReadUint16())
2586 self.VlanPcp = uint8(decoder.ReadByte())
2587 decoder.Skip(1)
2588 self.EthType = uint16(decoder.ReadUint16())
2589 self.IpDscp = uint8(decoder.ReadByte())
2590 self.IpProto = uint8(decoder.ReadByte())
2591 decoder.Skip(2)
2592 self.Ipv4Src = net.IP(decoder.Read(4))
2593 self.Ipv4Dst = net.IP(decoder.Read(4))
2594 self.TcpSrc = uint16(decoder.ReadUint16())
2595 self.TcpDst = uint16(decoder.ReadUint16())
2596
2597 return nil
2598}
2599
2600func NewMatchV1() *MatchV1 {
2601 obj := &MatchV1{}
2602 return obj
2603}
2604
2605type NiciraMatch struct {
2606 NxmEntries []goloxi.IOxm
2607}
2608
2609type INiciraMatch interface {
2610 goloxi.Serializable
2611 GetNxmEntries() []goloxi.IOxm
2612}
2613
2614func (self *NiciraMatch) GetNxmEntries() []goloxi.IOxm {
2615 return self.NxmEntries
2616}
2617
2618func (self *NiciraMatch) SetNxmEntries(v []goloxi.IOxm) {
2619 self.NxmEntries = v
2620}
2621
2622func (self *NiciraMatch) Serialize(encoder *goloxi.Encoder) error {
2623 startIndex := len(encoder.Bytes())
2624
2625 for _, obj := range self.NxmEntries {
2626 if err := obj.Serialize(encoder); err != nil {
2627 return err
2628 }
2629 }
2630 length := len(encoder.Bytes()) - startIndex
2631 alignedLength := ((length + 7) / 8 * 8)
2632
2633 encoder.Write(bytes.Repeat([]byte{0}, alignedLength-length))
2634
2635 return nil
2636}
2637func (self *NiciraMatch) Decode(decoder *goloxi.Decoder) error {
2638
2639 defer decoder.SkipAlign()
2640
2641 for decoder.Length() >= 4 {
2642 item, err := DecodeOxm(decoder)
2643 if err != nil {
2644 return err
2645 }
2646 if item != nil {
2647 self.NxmEntries = append(self.NxmEntries, item)
2648 }
2649 }
2650
2651 return nil
2652}
2653
2654func NewNiciraMatch() *NiciraMatch {
2655 obj := &NiciraMatch{}
2656 return obj
2657}
2658
2659type NiciraFlowStats struct {
2660 Length uint16
2661 TableId uint8
2662 DurationSec uint32
2663 DurationNsec uint32
2664 Priority uint16
2665 IdleTimeout uint16
2666 HardTimeout uint16
2667 MatchLen uint16
2668 IdleAge uint16
2669 HardAge uint16
2670 Cookie uint64
2671 PacketCount uint64
2672 ByteCount uint64
2673 Match NiciraMatch
2674 Actions []goloxi.IAction
2675}
2676
2677type INiciraFlowStats interface {
2678 goloxi.Serializable
2679 GetLength() uint16
2680 GetTableId() uint8
2681 GetDurationSec() uint32
2682 GetDurationNsec() uint32
2683 GetPriority() uint16
2684 GetIdleTimeout() uint16
2685 GetHardTimeout() uint16
2686 GetMatchLen() uint16
2687 GetIdleAge() uint16
2688 GetHardAge() uint16
2689 GetCookie() uint64
2690 GetPacketCount() uint64
2691 GetByteCount() uint64
2692 GetMatch() NiciraMatch
2693 GetActions() []goloxi.IAction
2694}
2695
2696func (self *NiciraFlowStats) GetLength() uint16 {
2697 return self.Length
2698}
2699
2700func (self *NiciraFlowStats) SetLength(v uint16) {
2701 self.Length = v
2702}
2703
2704func (self *NiciraFlowStats) GetTableId() uint8 {
2705 return self.TableId
2706}
2707
2708func (self *NiciraFlowStats) SetTableId(v uint8) {
2709 self.TableId = v
2710}
2711
2712func (self *NiciraFlowStats) GetDurationSec() uint32 {
2713 return self.DurationSec
2714}
2715
2716func (self *NiciraFlowStats) SetDurationSec(v uint32) {
2717 self.DurationSec = v
2718}
2719
2720func (self *NiciraFlowStats) GetDurationNsec() uint32 {
2721 return self.DurationNsec
2722}
2723
2724func (self *NiciraFlowStats) SetDurationNsec(v uint32) {
2725 self.DurationNsec = v
2726}
2727
2728func (self *NiciraFlowStats) GetPriority() uint16 {
2729 return self.Priority
2730}
2731
2732func (self *NiciraFlowStats) SetPriority(v uint16) {
2733 self.Priority = v
2734}
2735
2736func (self *NiciraFlowStats) GetIdleTimeout() uint16 {
2737 return self.IdleTimeout
2738}
2739
2740func (self *NiciraFlowStats) SetIdleTimeout(v uint16) {
2741 self.IdleTimeout = v
2742}
2743
2744func (self *NiciraFlowStats) GetHardTimeout() uint16 {
2745 return self.HardTimeout
2746}
2747
2748func (self *NiciraFlowStats) SetHardTimeout(v uint16) {
2749 self.HardTimeout = v
2750}
2751
2752func (self *NiciraFlowStats) GetMatchLen() uint16 {
2753 return self.MatchLen
2754}
2755
2756func (self *NiciraFlowStats) SetMatchLen(v uint16) {
2757 self.MatchLen = v
2758}
2759
2760func (self *NiciraFlowStats) GetIdleAge() uint16 {
2761 return self.IdleAge
2762}
2763
2764func (self *NiciraFlowStats) SetIdleAge(v uint16) {
2765 self.IdleAge = v
2766}
2767
2768func (self *NiciraFlowStats) GetHardAge() uint16 {
2769 return self.HardAge
2770}
2771
2772func (self *NiciraFlowStats) SetHardAge(v uint16) {
2773 self.HardAge = v
2774}
2775
2776func (self *NiciraFlowStats) GetCookie() uint64 {
2777 return self.Cookie
2778}
2779
2780func (self *NiciraFlowStats) SetCookie(v uint64) {
2781 self.Cookie = v
2782}
2783
2784func (self *NiciraFlowStats) GetPacketCount() uint64 {
2785 return self.PacketCount
2786}
2787
2788func (self *NiciraFlowStats) SetPacketCount(v uint64) {
2789 self.PacketCount = v
2790}
2791
2792func (self *NiciraFlowStats) GetByteCount() uint64 {
2793 return self.ByteCount
2794}
2795
2796func (self *NiciraFlowStats) SetByteCount(v uint64) {
2797 self.ByteCount = v
2798}
2799
2800func (self *NiciraFlowStats) GetMatch() NiciraMatch {
2801 return self.Match
2802}
2803
2804func (self *NiciraFlowStats) SetMatch(v NiciraMatch) {
2805 self.Match = v
2806}
2807
2808func (self *NiciraFlowStats) GetActions() []goloxi.IAction {
2809 return self.Actions
2810}
2811
2812func (self *NiciraFlowStats) SetActions(v []goloxi.IAction) {
2813 self.Actions = v
2814}
2815
2816func (self *NiciraFlowStats) Serialize(encoder *goloxi.Encoder) error {
2817 startIndex := len(encoder.Bytes())
2818
2819 encoder.PutUint16(uint16(self.Length))
2820 encoder.PutUint8(uint8(self.TableId))
2821 encoder.Write(bytes.Repeat([]byte{0}, 1))
2822 encoder.PutUint32(uint32(self.DurationSec))
2823 encoder.PutUint32(uint32(self.DurationNsec))
2824 encoder.PutUint16(uint16(self.Priority))
2825 encoder.PutUint16(uint16(self.IdleTimeout))
2826 encoder.PutUint16(uint16(self.HardTimeout))
2827 encoder.PutUint16(uint16(self.MatchLen))
2828 encoder.PutUint16(uint16(self.IdleAge))
2829 encoder.PutUint16(uint16(self.HardAge))
2830 encoder.PutUint64(uint64(self.Cookie))
2831 encoder.PutUint64(uint64(self.PacketCount))
2832 encoder.PutUint64(uint64(self.ByteCount))
2833 if err := self.Match.Serialize(encoder); err != nil {
2834 return err
2835 }
2836
2837 for _, obj := range self.Actions {
2838 if err := obj.Serialize(encoder); err != nil {
2839 return err
2840 }
2841 }
2842 length := len(encoder.Bytes()) - startIndex
2843
2844 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
2845
2846 return nil
2847}
2848
2849func DecodeNiciraFlowStats(decoder *goloxi.Decoder) (*NiciraFlowStats, error) {
2850 _niciraflowstats := &NiciraFlowStats{}
2851 if decoder.Length() < 48 {
2852 return nil, fmt.Errorf("NiciraFlowStats packet too short: %d < 48", decoder.Length())
2853 }
2854 _niciraflowstats.Length = uint16(decoder.ReadUint16())
2855 oldDecoder := decoder
2856 defer func() { decoder = oldDecoder }()
2857 decoder = decoder.SliceDecoder(int(_niciraflowstats.Length), 2+0)
2858 _niciraflowstats.TableId = uint8(decoder.ReadByte())
2859 decoder.Skip(1)
2860 _niciraflowstats.DurationSec = uint32(decoder.ReadUint32())
2861 _niciraflowstats.DurationNsec = uint32(decoder.ReadUint32())
2862 _niciraflowstats.Priority = uint16(decoder.ReadUint16())
2863 _niciraflowstats.IdleTimeout = uint16(decoder.ReadUint16())
2864 _niciraflowstats.HardTimeout = uint16(decoder.ReadUint16())
2865 _niciraflowstats.MatchLen = uint16(decoder.ReadUint16())
2866 _niciraflowstats.IdleAge = uint16(decoder.ReadUint16())
2867 _niciraflowstats.HardAge = uint16(decoder.ReadUint16())
2868 _niciraflowstats.Cookie = uint64(decoder.ReadUint64())
2869 _niciraflowstats.PacketCount = uint64(decoder.ReadUint64())
2870 _niciraflowstats.ByteCount = uint64(decoder.ReadUint64())
2871 if err := _niciraflowstats.Match.Decode(decoder.SliceDecoder(int(_niciraflowstats.MatchLen), 0)); err != nil {
2872 return nil, err
2873 }
2874
2875 decoder.SkipAlign()
2876
2877 for decoder.Length() >= 8 {
2878 item, err := DecodeAction(decoder)
2879 if err != nil {
2880 return nil, err
2881 }
2882 if item != nil {
2883 _niciraflowstats.Actions = append(_niciraflowstats.Actions, item)
2884 }
2885 }
2886 return _niciraflowstats, nil
2887}
2888
2889func NewNiciraFlowStats() *NiciraFlowStats {
2890 obj := &NiciraFlowStats{}
2891 return obj
2892}
2893
2894type NiciraFlowUpdateEvent struct {
2895 Length uint16
2896 Event uint16
2897}
2898
2899type INiciraFlowUpdateEvent interface {
2900 goloxi.Serializable
2901 GetLength() uint16
2902 GetEvent() uint16
2903}
2904
2905func (self *NiciraFlowUpdateEvent) GetLength() uint16 {
2906 return self.Length
2907}
2908
2909func (self *NiciraFlowUpdateEvent) SetLength(v uint16) {
2910 self.Length = v
2911}
2912
2913func (self *NiciraFlowUpdateEvent) GetEvent() uint16 {
2914 return self.Event
2915}
2916
2917func (self *NiciraFlowUpdateEvent) SetEvent(v uint16) {
2918 self.Event = v
2919}
2920
2921func (self *NiciraFlowUpdateEvent) Serialize(encoder *goloxi.Encoder) error {
2922
2923 encoder.PutUint16(uint16(self.Length))
2924 encoder.PutUint16(uint16(self.Event))
2925
2926 return nil
2927}
2928
2929func DecodeNiciraFlowUpdateEvent(decoder *goloxi.Decoder) (INiciraFlowUpdateEvent, error) {
2930 _niciraflowupdateevent := &NiciraFlowUpdateEvent{}
2931 if decoder.Length() < 4 {
2932 return nil, fmt.Errorf("NiciraFlowUpdateEvent packet too short: %d < 4", decoder.Length())
2933 }
2934 _niciraflowupdateevent.Length = uint16(decoder.ReadUint16())
2935 oldDecoder := decoder
2936 defer func() { decoder = oldDecoder }()
2937 decoder = decoder.SliceDecoder(int(_niciraflowupdateevent.Length), 2+0)
2938 _niciraflowupdateevent.Event = uint16(decoder.ReadUint16())
2939
2940 switch _niciraflowupdateevent.Event {
2941 case 0:
2942 return DecodeNiciraFlowUpdateFullAdd(_niciraflowupdateevent, decoder)
2943 case 1:
2944 return DecodeNiciraFlowUpdateFullDeleted(_niciraflowupdateevent, decoder)
2945 case 2:
2946 return DecodeNiciraFlowUpdateFullModified(_niciraflowupdateevent, decoder)
2947 default:
2948 return nil, fmt.Errorf("Invalid type '%d' for 'NiciraFlowUpdateEvent'", _niciraflowupdateevent.Event)
2949 }
2950}
2951
2952func NewNiciraFlowUpdateEvent(_event uint16) *NiciraFlowUpdateEvent {
2953 obj := &NiciraFlowUpdateEvent{}
2954 obj.Event = _event
2955 return obj
2956}
2957
2958type NiciraFlowUpdateFullAdd struct {
2959 *NiciraFlowUpdateEvent
2960 Reason uint16
2961 Priority uint16
2962 IdleTimeout uint16
2963 HardTimeout uint16
2964 MatchLen uint16
2965 TableId uint8
2966 Cookie uint64
2967 Match NiciraMatch
2968 Actions []goloxi.IAction
2969}
2970
2971type INiciraFlowUpdateFullAdd interface {
2972 INiciraFlowUpdateEvent
2973 GetReason() uint16
2974 GetPriority() uint16
2975 GetIdleTimeout() uint16
2976 GetHardTimeout() uint16
2977 GetMatchLen() uint16
2978 GetTableId() uint8
2979 GetCookie() uint64
2980 GetMatch() NiciraMatch
2981 GetActions() []goloxi.IAction
2982}
2983
2984func (self *NiciraFlowUpdateFullAdd) GetReason() uint16 {
2985 return self.Reason
2986}
2987
2988func (self *NiciraFlowUpdateFullAdd) SetReason(v uint16) {
2989 self.Reason = v
2990}
2991
2992func (self *NiciraFlowUpdateFullAdd) GetPriority() uint16 {
2993 return self.Priority
2994}
2995
2996func (self *NiciraFlowUpdateFullAdd) SetPriority(v uint16) {
2997 self.Priority = v
2998}
2999
3000func (self *NiciraFlowUpdateFullAdd) GetIdleTimeout() uint16 {
3001 return self.IdleTimeout
3002}
3003
3004func (self *NiciraFlowUpdateFullAdd) SetIdleTimeout(v uint16) {
3005 self.IdleTimeout = v
3006}
3007
3008func (self *NiciraFlowUpdateFullAdd) GetHardTimeout() uint16 {
3009 return self.HardTimeout
3010}
3011
3012func (self *NiciraFlowUpdateFullAdd) SetHardTimeout(v uint16) {
3013 self.HardTimeout = v
3014}
3015
3016func (self *NiciraFlowUpdateFullAdd) GetMatchLen() uint16 {
3017 return self.MatchLen
3018}
3019
3020func (self *NiciraFlowUpdateFullAdd) SetMatchLen(v uint16) {
3021 self.MatchLen = v
3022}
3023
3024func (self *NiciraFlowUpdateFullAdd) GetTableId() uint8 {
3025 return self.TableId
3026}
3027
3028func (self *NiciraFlowUpdateFullAdd) SetTableId(v uint8) {
3029 self.TableId = v
3030}
3031
3032func (self *NiciraFlowUpdateFullAdd) GetCookie() uint64 {
3033 return self.Cookie
3034}
3035
3036func (self *NiciraFlowUpdateFullAdd) SetCookie(v uint64) {
3037 self.Cookie = v
3038}
3039
3040func (self *NiciraFlowUpdateFullAdd) GetMatch() NiciraMatch {
3041 return self.Match
3042}
3043
3044func (self *NiciraFlowUpdateFullAdd) SetMatch(v NiciraMatch) {
3045 self.Match = v
3046}
3047
3048func (self *NiciraFlowUpdateFullAdd) GetActions() []goloxi.IAction {
3049 return self.Actions
3050}
3051
3052func (self *NiciraFlowUpdateFullAdd) SetActions(v []goloxi.IAction) {
3053 self.Actions = v
3054}
3055
3056func (self *NiciraFlowUpdateFullAdd) Serialize(encoder *goloxi.Encoder) error {
3057 startIndex := len(encoder.Bytes())
3058 if err := self.NiciraFlowUpdateEvent.Serialize(encoder); err != nil {
3059 return err
3060 }
3061
3062 encoder.PutUint16(uint16(self.Reason))
3063 encoder.PutUint16(uint16(self.Priority))
3064 encoder.PutUint16(uint16(self.IdleTimeout))
3065 encoder.PutUint16(uint16(self.HardTimeout))
3066 encoder.PutUint16(uint16(self.MatchLen))
3067 encoder.PutUint8(uint8(self.TableId))
3068 encoder.Write(bytes.Repeat([]byte{0}, 1))
3069 encoder.PutUint64(uint64(self.Cookie))
3070 if err := self.Match.Serialize(encoder); err != nil {
3071 return err
3072 }
3073
3074 for _, obj := range self.Actions {
3075 if err := obj.Serialize(encoder); err != nil {
3076 return err
3077 }
3078 }
3079 length := len(encoder.Bytes()) - startIndex
3080
3081 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
3082
3083 return nil
3084}
3085
3086func DecodeNiciraFlowUpdateFullAdd(parent *NiciraFlowUpdateEvent, decoder *goloxi.Decoder) (*NiciraFlowUpdateFullAdd, error) {
3087 _niciraflowupdatefulladd := &NiciraFlowUpdateFullAdd{NiciraFlowUpdateEvent: parent}
3088 if decoder.Length() < 20 {
3089 return nil, fmt.Errorf("NiciraFlowUpdateFullAdd packet too short: %d < 20", decoder.Length())
3090 }
3091 _niciraflowupdatefulladd.Reason = uint16(decoder.ReadUint16())
3092 _niciraflowupdatefulladd.Priority = uint16(decoder.ReadUint16())
3093 _niciraflowupdatefulladd.IdleTimeout = uint16(decoder.ReadUint16())
3094 _niciraflowupdatefulladd.HardTimeout = uint16(decoder.ReadUint16())
3095 _niciraflowupdatefulladd.MatchLen = uint16(decoder.ReadUint16())
3096 _niciraflowupdatefulladd.TableId = uint8(decoder.ReadByte())
3097 decoder.Skip(1)
3098 _niciraflowupdatefulladd.Cookie = uint64(decoder.ReadUint64())
3099 if err := _niciraflowupdatefulladd.Match.Decode(decoder.SliceDecoder(int(_niciraflowupdatefulladd.MatchLen), 0)); err != nil {
3100 return nil, err
3101 }
3102
3103 decoder.SkipAlign()
3104
3105 for decoder.Length() >= 8 {
3106 item, err := DecodeAction(decoder)
3107 if err != nil {
3108 return nil, err
3109 }
3110 if item != nil {
3111 _niciraflowupdatefulladd.Actions = append(_niciraflowupdatefulladd.Actions, item)
3112 }
3113 }
3114 return _niciraflowupdatefulladd, nil
3115}
3116
3117func NewNiciraFlowUpdateFullAdd() *NiciraFlowUpdateFullAdd {
3118 obj := &NiciraFlowUpdateFullAdd{
3119 NiciraFlowUpdateEvent: NewNiciraFlowUpdateEvent(0),
3120 }
3121 return obj
3122}
3123
3124type NiciraFlowUpdateFullDeleted struct {
3125 *NiciraFlowUpdateEvent
3126 Reason uint16
3127 Priority uint16
3128 IdleTimeout uint16
3129 HardTimeout uint16
3130 MatchLen uint16
3131 TableId uint8
3132 Cookie uint64
3133 Match NiciraMatch
3134 Actions []goloxi.IAction
3135}
3136
3137type INiciraFlowUpdateFullDeleted interface {
3138 INiciraFlowUpdateEvent
3139 GetReason() uint16
3140 GetPriority() uint16
3141 GetIdleTimeout() uint16
3142 GetHardTimeout() uint16
3143 GetMatchLen() uint16
3144 GetTableId() uint8
3145 GetCookie() uint64
3146 GetMatch() NiciraMatch
3147 GetActions() []goloxi.IAction
3148}
3149
3150func (self *NiciraFlowUpdateFullDeleted) GetReason() uint16 {
3151 return self.Reason
3152}
3153
3154func (self *NiciraFlowUpdateFullDeleted) SetReason(v uint16) {
3155 self.Reason = v
3156}
3157
3158func (self *NiciraFlowUpdateFullDeleted) GetPriority() uint16 {
3159 return self.Priority
3160}
3161
3162func (self *NiciraFlowUpdateFullDeleted) SetPriority(v uint16) {
3163 self.Priority = v
3164}
3165
3166func (self *NiciraFlowUpdateFullDeleted) GetIdleTimeout() uint16 {
3167 return self.IdleTimeout
3168}
3169
3170func (self *NiciraFlowUpdateFullDeleted) SetIdleTimeout(v uint16) {
3171 self.IdleTimeout = v
3172}
3173
3174func (self *NiciraFlowUpdateFullDeleted) GetHardTimeout() uint16 {
3175 return self.HardTimeout
3176}
3177
3178func (self *NiciraFlowUpdateFullDeleted) SetHardTimeout(v uint16) {
3179 self.HardTimeout = v
3180}
3181
3182func (self *NiciraFlowUpdateFullDeleted) GetMatchLen() uint16 {
3183 return self.MatchLen
3184}
3185
3186func (self *NiciraFlowUpdateFullDeleted) SetMatchLen(v uint16) {
3187 self.MatchLen = v
3188}
3189
3190func (self *NiciraFlowUpdateFullDeleted) GetTableId() uint8 {
3191 return self.TableId
3192}
3193
3194func (self *NiciraFlowUpdateFullDeleted) SetTableId(v uint8) {
3195 self.TableId = v
3196}
3197
3198func (self *NiciraFlowUpdateFullDeleted) GetCookie() uint64 {
3199 return self.Cookie
3200}
3201
3202func (self *NiciraFlowUpdateFullDeleted) SetCookie(v uint64) {
3203 self.Cookie = v
3204}
3205
3206func (self *NiciraFlowUpdateFullDeleted) GetMatch() NiciraMatch {
3207 return self.Match
3208}
3209
3210func (self *NiciraFlowUpdateFullDeleted) SetMatch(v NiciraMatch) {
3211 self.Match = v
3212}
3213
3214func (self *NiciraFlowUpdateFullDeleted) GetActions() []goloxi.IAction {
3215 return self.Actions
3216}
3217
3218func (self *NiciraFlowUpdateFullDeleted) SetActions(v []goloxi.IAction) {
3219 self.Actions = v
3220}
3221
3222func (self *NiciraFlowUpdateFullDeleted) Serialize(encoder *goloxi.Encoder) error {
3223 startIndex := len(encoder.Bytes())
3224 if err := self.NiciraFlowUpdateEvent.Serialize(encoder); err != nil {
3225 return err
3226 }
3227
3228 encoder.PutUint16(uint16(self.Reason))
3229 encoder.PutUint16(uint16(self.Priority))
3230 encoder.PutUint16(uint16(self.IdleTimeout))
3231 encoder.PutUint16(uint16(self.HardTimeout))
3232 encoder.PutUint16(uint16(self.MatchLen))
3233 encoder.PutUint8(uint8(self.TableId))
3234 encoder.Write(bytes.Repeat([]byte{0}, 1))
3235 encoder.PutUint64(uint64(self.Cookie))
3236 if err := self.Match.Serialize(encoder); err != nil {
3237 return err
3238 }
3239
3240 for _, obj := range self.Actions {
3241 if err := obj.Serialize(encoder); err != nil {
3242 return err
3243 }
3244 }
3245 length := len(encoder.Bytes()) - startIndex
3246
3247 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
3248
3249 return nil
3250}
3251
3252func DecodeNiciraFlowUpdateFullDeleted(parent *NiciraFlowUpdateEvent, decoder *goloxi.Decoder) (*NiciraFlowUpdateFullDeleted, error) {
3253 _niciraflowupdatefulldeleted := &NiciraFlowUpdateFullDeleted{NiciraFlowUpdateEvent: parent}
3254 if decoder.Length() < 20 {
3255 return nil, fmt.Errorf("NiciraFlowUpdateFullDeleted packet too short: %d < 20", decoder.Length())
3256 }
3257 _niciraflowupdatefulldeleted.Reason = uint16(decoder.ReadUint16())
3258 _niciraflowupdatefulldeleted.Priority = uint16(decoder.ReadUint16())
3259 _niciraflowupdatefulldeleted.IdleTimeout = uint16(decoder.ReadUint16())
3260 _niciraflowupdatefulldeleted.HardTimeout = uint16(decoder.ReadUint16())
3261 _niciraflowupdatefulldeleted.MatchLen = uint16(decoder.ReadUint16())
3262 _niciraflowupdatefulldeleted.TableId = uint8(decoder.ReadByte())
3263 decoder.Skip(1)
3264 _niciraflowupdatefulldeleted.Cookie = uint64(decoder.ReadUint64())
3265 if err := _niciraflowupdatefulldeleted.Match.Decode(decoder.SliceDecoder(int(_niciraflowupdatefulldeleted.MatchLen), 0)); err != nil {
3266 return nil, err
3267 }
3268
3269 decoder.SkipAlign()
3270
3271 for decoder.Length() >= 8 {
3272 item, err := DecodeAction(decoder)
3273 if err != nil {
3274 return nil, err
3275 }
3276 if item != nil {
3277 _niciraflowupdatefulldeleted.Actions = append(_niciraflowupdatefulldeleted.Actions, item)
3278 }
3279 }
3280 return _niciraflowupdatefulldeleted, nil
3281}
3282
3283func NewNiciraFlowUpdateFullDeleted() *NiciraFlowUpdateFullDeleted {
3284 obj := &NiciraFlowUpdateFullDeleted{
3285 NiciraFlowUpdateEvent: NewNiciraFlowUpdateEvent(1),
3286 }
3287 return obj
3288}
3289
3290type NiciraFlowUpdateFullModified struct {
3291 *NiciraFlowUpdateEvent
3292 Reason uint16
3293 Priority uint16
3294 IdleTimeout uint16
3295 HardTimeout uint16
3296 MatchLen uint16
3297 TableId uint8
3298 Cookie uint64
3299 Match NiciraMatch
3300 Actions []goloxi.IAction
3301}
3302
3303type INiciraFlowUpdateFullModified interface {
3304 INiciraFlowUpdateEvent
3305 GetReason() uint16
3306 GetPriority() uint16
3307 GetIdleTimeout() uint16
3308 GetHardTimeout() uint16
3309 GetMatchLen() uint16
3310 GetTableId() uint8
3311 GetCookie() uint64
3312 GetMatch() NiciraMatch
3313 GetActions() []goloxi.IAction
3314}
3315
3316func (self *NiciraFlowUpdateFullModified) GetReason() uint16 {
3317 return self.Reason
3318}
3319
3320func (self *NiciraFlowUpdateFullModified) SetReason(v uint16) {
3321 self.Reason = v
3322}
3323
3324func (self *NiciraFlowUpdateFullModified) GetPriority() uint16 {
3325 return self.Priority
3326}
3327
3328func (self *NiciraFlowUpdateFullModified) SetPriority(v uint16) {
3329 self.Priority = v
3330}
3331
3332func (self *NiciraFlowUpdateFullModified) GetIdleTimeout() uint16 {
3333 return self.IdleTimeout
3334}
3335
3336func (self *NiciraFlowUpdateFullModified) SetIdleTimeout(v uint16) {
3337 self.IdleTimeout = v
3338}
3339
3340func (self *NiciraFlowUpdateFullModified) GetHardTimeout() uint16 {
3341 return self.HardTimeout
3342}
3343
3344func (self *NiciraFlowUpdateFullModified) SetHardTimeout(v uint16) {
3345 self.HardTimeout = v
3346}
3347
3348func (self *NiciraFlowUpdateFullModified) GetMatchLen() uint16 {
3349 return self.MatchLen
3350}
3351
3352func (self *NiciraFlowUpdateFullModified) SetMatchLen(v uint16) {
3353 self.MatchLen = v
3354}
3355
3356func (self *NiciraFlowUpdateFullModified) GetTableId() uint8 {
3357 return self.TableId
3358}
3359
3360func (self *NiciraFlowUpdateFullModified) SetTableId(v uint8) {
3361 self.TableId = v
3362}
3363
3364func (self *NiciraFlowUpdateFullModified) GetCookie() uint64 {
3365 return self.Cookie
3366}
3367
3368func (self *NiciraFlowUpdateFullModified) SetCookie(v uint64) {
3369 self.Cookie = v
3370}
3371
3372func (self *NiciraFlowUpdateFullModified) GetMatch() NiciraMatch {
3373 return self.Match
3374}
3375
3376func (self *NiciraFlowUpdateFullModified) SetMatch(v NiciraMatch) {
3377 self.Match = v
3378}
3379
3380func (self *NiciraFlowUpdateFullModified) GetActions() []goloxi.IAction {
3381 return self.Actions
3382}
3383
3384func (self *NiciraFlowUpdateFullModified) SetActions(v []goloxi.IAction) {
3385 self.Actions = v
3386}
3387
3388func (self *NiciraFlowUpdateFullModified) Serialize(encoder *goloxi.Encoder) error {
3389 startIndex := len(encoder.Bytes())
3390 if err := self.NiciraFlowUpdateEvent.Serialize(encoder); err != nil {
3391 return err
3392 }
3393
3394 encoder.PutUint16(uint16(self.Reason))
3395 encoder.PutUint16(uint16(self.Priority))
3396 encoder.PutUint16(uint16(self.IdleTimeout))
3397 encoder.PutUint16(uint16(self.HardTimeout))
3398 encoder.PutUint16(uint16(self.MatchLen))
3399 encoder.PutUint8(uint8(self.TableId))
3400 encoder.Write(bytes.Repeat([]byte{0}, 1))
3401 encoder.PutUint64(uint64(self.Cookie))
3402 if err := self.Match.Serialize(encoder); err != nil {
3403 return err
3404 }
3405
3406 for _, obj := range self.Actions {
3407 if err := obj.Serialize(encoder); err != nil {
3408 return err
3409 }
3410 }
3411 length := len(encoder.Bytes()) - startIndex
3412
3413 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+0:startIndex+2], uint16(length))
3414
3415 return nil
3416}
3417
3418func DecodeNiciraFlowUpdateFullModified(parent *NiciraFlowUpdateEvent, decoder *goloxi.Decoder) (*NiciraFlowUpdateFullModified, error) {
3419 _niciraflowupdatefullmodified := &NiciraFlowUpdateFullModified{NiciraFlowUpdateEvent: parent}
3420 if decoder.Length() < 20 {
3421 return nil, fmt.Errorf("NiciraFlowUpdateFullModified packet too short: %d < 20", decoder.Length())
3422 }
3423 _niciraflowupdatefullmodified.Reason = uint16(decoder.ReadUint16())
3424 _niciraflowupdatefullmodified.Priority = uint16(decoder.ReadUint16())
3425 _niciraflowupdatefullmodified.IdleTimeout = uint16(decoder.ReadUint16())
3426 _niciraflowupdatefullmodified.HardTimeout = uint16(decoder.ReadUint16())
3427 _niciraflowupdatefullmodified.MatchLen = uint16(decoder.ReadUint16())
3428 _niciraflowupdatefullmodified.TableId = uint8(decoder.ReadByte())
3429 decoder.Skip(1)
3430 _niciraflowupdatefullmodified.Cookie = uint64(decoder.ReadUint64())
3431 if err := _niciraflowupdatefullmodified.Match.Decode(decoder.SliceDecoder(int(_niciraflowupdatefullmodified.MatchLen), 0)); err != nil {
3432 return nil, err
3433 }
3434
3435 decoder.SkipAlign()
3436
3437 for decoder.Length() >= 8 {
3438 item, err := DecodeAction(decoder)
3439 if err != nil {
3440 return nil, err
3441 }
3442 if item != nil {
3443 _niciraflowupdatefullmodified.Actions = append(_niciraflowupdatefullmodified.Actions, item)
3444 }
3445 }
3446 return _niciraflowupdatefullmodified, nil
3447}
3448
3449func NewNiciraFlowUpdateFullModified() *NiciraFlowUpdateFullModified {
3450 obj := &NiciraFlowUpdateFullModified{
3451 NiciraFlowUpdateEvent: NewNiciraFlowUpdateEvent(2),
3452 }
3453 return obj
3454}
3455
3456type OxmIdArpOp struct {
3457 *OxmId
3458}
3459
3460type IOxmIdArpOp interface {
3461 IOxmId
3462}
3463
3464func (self *OxmIdArpOp) Serialize(encoder *goloxi.Encoder) error {
3465 if err := self.OxmId.Serialize(encoder); err != nil {
3466 return err
3467 }
3468
3469 return nil
3470}
3471
3472func DecodeOxmIdArpOp(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpOp, error) {
3473 _oxmidarpop := &OxmIdArpOp{OxmId: parent}
3474 return _oxmidarpop, nil
3475}
3476
3477func NewOxmIdArpOp() *OxmIdArpOp {
3478 obj := &OxmIdArpOp{
3479 OxmId: NewOxmId(7682),
3480 }
3481 return obj
3482}
3483func (self *OxmIdArpOp) GetOXMName() string {
3484 return "arp_op"
3485}
3486
3487func (self *OxmIdArpOp) MarshalJSON() ([]byte, error) {
3488 if self.TypeLen == 0 {
3489 return []byte("\"\""), nil
3490 } else {
3491 return []byte("\"" + self.GetOXMName() + "\""), nil
3492 }
3493}
3494
3495type OxmIdArpSha struct {
3496 *OxmId
3497}
3498
3499type IOxmIdArpSha interface {
3500 IOxmId
3501}
3502
3503func (self *OxmIdArpSha) Serialize(encoder *goloxi.Encoder) error {
3504 if err := self.OxmId.Serialize(encoder); err != nil {
3505 return err
3506 }
3507
3508 return nil
3509}
3510
3511func DecodeOxmIdArpSha(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpSha, error) {
3512 _oxmidarpsha := &OxmIdArpSha{OxmId: parent}
3513 return _oxmidarpsha, nil
3514}
3515
3516func NewOxmIdArpSha() *OxmIdArpSha {
3517 obj := &OxmIdArpSha{
3518 OxmId: NewOxmId(74246),
3519 }
3520 return obj
3521}
3522func (self *OxmIdArpSha) GetOXMName() string {
3523 return "arp_sha"
3524}
3525
3526func (self *OxmIdArpSha) MarshalJSON() ([]byte, error) {
3527 if self.TypeLen == 0 {
3528 return []byte("\"\""), nil
3529 } else {
3530 return []byte("\"" + self.GetOXMName() + "\""), nil
3531 }
3532}
3533
3534type OxmIdArpShaMasked struct {
3535 *OxmId
3536}
3537
3538type IOxmIdArpShaMasked interface {
3539 IOxmId
3540}
3541
3542func (self *OxmIdArpShaMasked) Serialize(encoder *goloxi.Encoder) error {
3543 if err := self.OxmId.Serialize(encoder); err != nil {
3544 return err
3545 }
3546
3547 return nil
3548}
3549
3550func DecodeOxmIdArpShaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpShaMasked, error) {
3551 _oxmidarpshamasked := &OxmIdArpShaMasked{OxmId: parent}
3552 return _oxmidarpshamasked, nil
3553}
3554
3555func NewOxmIdArpShaMasked() *OxmIdArpShaMasked {
3556 obj := &OxmIdArpShaMasked{
3557 OxmId: NewOxmId(74507),
3558 }
3559 return obj
3560}
3561func (self *OxmIdArpShaMasked) GetOXMName() string {
3562 return "arp_sha_masked"
3563}
3564
3565func (self *OxmIdArpShaMasked) MarshalJSON() ([]byte, error) {
3566 if self.TypeLen == 0 {
3567 return []byte("\"\""), nil
3568 } else {
3569 return []byte("\"" + self.GetOXMName() + "\""), nil
3570 }
3571}
3572
3573type OxmIdArpSpa struct {
3574 *OxmId
3575}
3576
3577type IOxmIdArpSpa interface {
3578 IOxmId
3579}
3580
3581func (self *OxmIdArpSpa) Serialize(encoder *goloxi.Encoder) error {
3582 if err := self.OxmId.Serialize(encoder); err != nil {
3583 return err
3584 }
3585
3586 return nil
3587}
3588
3589func DecodeOxmIdArpSpa(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpSpa, error) {
3590 _oxmidarpspa := &OxmIdArpSpa{OxmId: parent}
3591 return _oxmidarpspa, nil
3592}
3593
3594func NewOxmIdArpSpa() *OxmIdArpSpa {
3595 obj := &OxmIdArpSpa{
3596 OxmId: NewOxmId(8196),
3597 }
3598 return obj
3599}
3600func (self *OxmIdArpSpa) GetOXMName() string {
3601 return "arp_spa"
3602}
3603
3604func (self *OxmIdArpSpa) MarshalJSON() ([]byte, error) {
3605 if self.TypeLen == 0 {
3606 return []byte("\"\""), nil
3607 } else {
3608 return []byte("\"" + self.GetOXMName() + "\""), nil
3609 }
3610}
3611
3612type OxmIdArpSpaMasked struct {
3613 *OxmId
3614}
3615
3616type IOxmIdArpSpaMasked interface {
3617 IOxmId
3618}
3619
3620func (self *OxmIdArpSpaMasked) Serialize(encoder *goloxi.Encoder) error {
3621 if err := self.OxmId.Serialize(encoder); err != nil {
3622 return err
3623 }
3624
3625 return nil
3626}
3627
3628func DecodeOxmIdArpSpaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpSpaMasked, error) {
3629 _oxmidarpspamasked := &OxmIdArpSpaMasked{OxmId: parent}
3630 return _oxmidarpspamasked, nil
3631}
3632
3633func NewOxmIdArpSpaMasked() *OxmIdArpSpaMasked {
3634 obj := &OxmIdArpSpaMasked{
3635 OxmId: NewOxmId(8452),
3636 }
3637 return obj
3638}
3639func (self *OxmIdArpSpaMasked) GetOXMName() string {
3640 return "arp_spa_masked"
3641}
3642
3643func (self *OxmIdArpSpaMasked) MarshalJSON() ([]byte, error) {
3644 if self.TypeLen == 0 {
3645 return []byte("\"\""), nil
3646 } else {
3647 return []byte("\"" + self.GetOXMName() + "\""), nil
3648 }
3649}
3650
3651type OxmIdArpTha struct {
3652 *OxmId
3653}
3654
3655type IOxmIdArpTha interface {
3656 IOxmId
3657}
3658
3659func (self *OxmIdArpTha) Serialize(encoder *goloxi.Encoder) error {
3660 if err := self.OxmId.Serialize(encoder); err != nil {
3661 return err
3662 }
3663
3664 return nil
3665}
3666
3667func DecodeOxmIdArpTha(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpTha, error) {
3668 _oxmidarptha := &OxmIdArpTha{OxmId: parent}
3669 return _oxmidarptha, nil
3670}
3671
3672func NewOxmIdArpTha() *OxmIdArpTha {
3673 obj := &OxmIdArpTha{
3674 OxmId: NewOxmId(74758),
3675 }
3676 return obj
3677}
3678func (self *OxmIdArpTha) GetOXMName() string {
3679 return "arp_tha"
3680}
3681
3682func (self *OxmIdArpTha) MarshalJSON() ([]byte, error) {
3683 if self.TypeLen == 0 {
3684 return []byte("\"\""), nil
3685 } else {
3686 return []byte("\"" + self.GetOXMName() + "\""), nil
3687 }
3688}
3689
3690type OxmIdArpThaMasked struct {
3691 *OxmId
3692}
3693
3694type IOxmIdArpThaMasked interface {
3695 IOxmId
3696}
3697
3698func (self *OxmIdArpThaMasked) Serialize(encoder *goloxi.Encoder) error {
3699 if err := self.OxmId.Serialize(encoder); err != nil {
3700 return err
3701 }
3702
3703 return nil
3704}
3705
3706func DecodeOxmIdArpThaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpThaMasked, error) {
3707 _oxmidarpthamasked := &OxmIdArpThaMasked{OxmId: parent}
3708 return _oxmidarpthamasked, nil
3709}
3710
3711func NewOxmIdArpThaMasked() *OxmIdArpThaMasked {
3712 obj := &OxmIdArpThaMasked{
3713 OxmId: NewOxmId(75019),
3714 }
3715 return obj
3716}
3717func (self *OxmIdArpThaMasked) GetOXMName() string {
3718 return "arp_tha_masked"
3719}
3720
3721func (self *OxmIdArpThaMasked) MarshalJSON() ([]byte, error) {
3722 if self.TypeLen == 0 {
3723 return []byte("\"\""), nil
3724 } else {
3725 return []byte("\"" + self.GetOXMName() + "\""), nil
3726 }
3727}
3728
3729type OxmIdArpTpa struct {
3730 *OxmId
3731}
3732
3733type IOxmIdArpTpa interface {
3734 IOxmId
3735}
3736
3737func (self *OxmIdArpTpa) Serialize(encoder *goloxi.Encoder) error {
3738 if err := self.OxmId.Serialize(encoder); err != nil {
3739 return err
3740 }
3741
3742 return nil
3743}
3744
3745func DecodeOxmIdArpTpa(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpTpa, error) {
3746 _oxmidarptpa := &OxmIdArpTpa{OxmId: parent}
3747 return _oxmidarptpa, nil
3748}
3749
3750func NewOxmIdArpTpa() *OxmIdArpTpa {
3751 obj := &OxmIdArpTpa{
3752 OxmId: NewOxmId(8708),
3753 }
3754 return obj
3755}
3756func (self *OxmIdArpTpa) GetOXMName() string {
3757 return "arp_tpa"
3758}
3759
3760func (self *OxmIdArpTpa) MarshalJSON() ([]byte, error) {
3761 if self.TypeLen == 0 {
3762 return []byte("\"\""), nil
3763 } else {
3764 return []byte("\"" + self.GetOXMName() + "\""), nil
3765 }
3766}
3767
3768type OxmIdArpTpaMasked struct {
3769 *OxmId
3770}
3771
3772type IOxmIdArpTpaMasked interface {
3773 IOxmId
3774}
3775
3776func (self *OxmIdArpTpaMasked) Serialize(encoder *goloxi.Encoder) error {
3777 if err := self.OxmId.Serialize(encoder); err != nil {
3778 return err
3779 }
3780
3781 return nil
3782}
3783
3784func DecodeOxmIdArpTpaMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpTpaMasked, error) {
3785 _oxmidarptpamasked := &OxmIdArpTpaMasked{OxmId: parent}
3786 return _oxmidarptpamasked, nil
3787}
3788
3789func NewOxmIdArpTpaMasked() *OxmIdArpTpaMasked {
3790 obj := &OxmIdArpTpaMasked{
3791 OxmId: NewOxmId(8968),
3792 }
3793 return obj
3794}
3795func (self *OxmIdArpTpaMasked) GetOXMName() string {
3796 return "arp_tpa_masked"
3797}
3798
3799func (self *OxmIdArpTpaMasked) MarshalJSON() ([]byte, error) {
3800 if self.TypeLen == 0 {
3801 return []byte("\"\""), nil
3802 } else {
3803 return []byte("\"" + self.GetOXMName() + "\""), nil
3804 }
3805}
3806
3807type OxmIdConjId struct {
3808 *OxmId
3809}
3810
3811type IOxmIdConjId interface {
3812 IOxmId
3813}
3814
3815func (self *OxmIdConjId) Serialize(encoder *goloxi.Encoder) error {
3816 if err := self.OxmId.Serialize(encoder); err != nil {
3817 return err
3818 }
3819
3820 return nil
3821}
3822
3823func DecodeOxmIdConjId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConjId, error) {
3824 _oxmidconjid := &OxmIdConjId{OxmId: parent}
3825 return _oxmidconjid, nil
3826}
3827
3828func NewOxmIdConjId() *OxmIdConjId {
3829 obj := &OxmIdConjId{
3830 OxmId: NewOxmId(84484),
3831 }
3832 return obj
3833}
3834func (self *OxmIdConjId) GetOXMName() string {
3835 return "conj_id"
3836}
3837
3838func (self *OxmIdConjId) MarshalJSON() ([]byte, error) {
3839 if self.TypeLen == 0 {
3840 return []byte("\"\""), nil
3841 } else {
3842 return []byte("\"" + self.GetOXMName() + "\""), nil
3843 }
3844}
3845
3846type OxmIdCtIpv6Dst struct {
3847 *OxmId
3848}
3849
3850type IOxmIdCtIpv6Dst interface {
3851 IOxmId
3852}
3853
3854func (self *OxmIdCtIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
3855 if err := self.OxmId.Serialize(encoder); err != nil {
3856 return err
3857 }
3858
3859 return nil
3860}
3861
3862func DecodeOxmIdCtIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6Dst, error) {
3863 _oxmidctipv6dst := &OxmIdCtIpv6Dst{OxmId: parent}
3864 return _oxmidctipv6dst, nil
3865}
3866
3867func NewOxmIdCtIpv6Dst() *OxmIdCtIpv6Dst {
3868 obj := &OxmIdCtIpv6Dst{
3869 OxmId: NewOxmId(128528),
3870 }
3871 return obj
3872}
3873func (self *OxmIdCtIpv6Dst) GetOXMName() string {
3874 return "ct_ipv6_dst"
3875}
3876
3877func (self *OxmIdCtIpv6Dst) MarshalJSON() ([]byte, error) {
3878 if self.TypeLen == 0 {
3879 return []byte("\"\""), nil
3880 } else {
3881 return []byte("\"" + self.GetOXMName() + "\""), nil
3882 }
3883}
3884
3885type OxmIdCtIpv6DstMasked struct {
3886 *OxmId
3887}
3888
3889type IOxmIdCtIpv6DstMasked interface {
3890 IOxmId
3891}
3892
3893func (self *OxmIdCtIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
3894 if err := self.OxmId.Serialize(encoder); err != nil {
3895 return err
3896 }
3897
3898 return nil
3899}
3900
3901func DecodeOxmIdCtIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6DstMasked, error) {
3902 _oxmidctipv6dstmasked := &OxmIdCtIpv6DstMasked{OxmId: parent}
3903 return _oxmidctipv6dstmasked, nil
3904}
3905
3906func NewOxmIdCtIpv6DstMasked() *OxmIdCtIpv6DstMasked {
3907 obj := &OxmIdCtIpv6DstMasked{
3908 OxmId: NewOxmId(128800),
3909 }
3910 return obj
3911}
3912func (self *OxmIdCtIpv6DstMasked) GetOXMName() string {
3913 return "ct_ipv6_dst_masked"
3914}
3915
3916func (self *OxmIdCtIpv6DstMasked) MarshalJSON() ([]byte, error) {
3917 if self.TypeLen == 0 {
3918 return []byte("\"\""), nil
3919 } else {
3920 return []byte("\"" + self.GetOXMName() + "\""), nil
3921 }
3922}
3923
3924type OxmIdCtIpv6Src struct {
3925 *OxmId
3926}
3927
3928type IOxmIdCtIpv6Src interface {
3929 IOxmId
3930}
3931
3932func (self *OxmIdCtIpv6Src) Serialize(encoder *goloxi.Encoder) error {
3933 if err := self.OxmId.Serialize(encoder); err != nil {
3934 return err
3935 }
3936
3937 return nil
3938}
3939
3940func DecodeOxmIdCtIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6Src, error) {
3941 _oxmidctipv6src := &OxmIdCtIpv6Src{OxmId: parent}
3942 return _oxmidctipv6src, nil
3943}
3944
3945func NewOxmIdCtIpv6Src() *OxmIdCtIpv6Src {
3946 obj := &OxmIdCtIpv6Src{
3947 OxmId: NewOxmId(128016),
3948 }
3949 return obj
3950}
3951func (self *OxmIdCtIpv6Src) GetOXMName() string {
3952 return "ct_ipv6_src"
3953}
3954
3955func (self *OxmIdCtIpv6Src) MarshalJSON() ([]byte, error) {
3956 if self.TypeLen == 0 {
3957 return []byte("\"\""), nil
3958 } else {
3959 return []byte("\"" + self.GetOXMName() + "\""), nil
3960 }
3961}
3962
3963type OxmIdCtIpv6SrcMasked struct {
3964 *OxmId
3965}
3966
3967type IOxmIdCtIpv6SrcMasked interface {
3968 IOxmId
3969}
3970
3971func (self *OxmIdCtIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
3972 if err := self.OxmId.Serialize(encoder); err != nil {
3973 return err
3974 }
3975
3976 return nil
3977}
3978
3979func DecodeOxmIdCtIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtIpv6SrcMasked, error) {
3980 _oxmidctipv6srcmasked := &OxmIdCtIpv6SrcMasked{OxmId: parent}
3981 return _oxmidctipv6srcmasked, nil
3982}
3983
3984func NewOxmIdCtIpv6SrcMasked() *OxmIdCtIpv6SrcMasked {
3985 obj := &OxmIdCtIpv6SrcMasked{
3986 OxmId: NewOxmId(128288),
3987 }
3988 return obj
3989}
3990func (self *OxmIdCtIpv6SrcMasked) GetOXMName() string {
3991 return "ct_ipv6_src_masked"
3992}
3993
3994func (self *OxmIdCtIpv6SrcMasked) MarshalJSON() ([]byte, error) {
3995 if self.TypeLen == 0 {
3996 return []byte("\"\""), nil
3997 } else {
3998 return []byte("\"" + self.GetOXMName() + "\""), nil
3999 }
4000}
4001
4002type OxmIdCtLabel struct {
4003 *OxmId
4004}
4005
4006type IOxmIdCtLabel interface {
4007 IOxmId
4008}
4009
4010func (self *OxmIdCtLabel) Serialize(encoder *goloxi.Encoder) error {
4011 if err := self.OxmId.Serialize(encoder); err != nil {
4012 return err
4013 }
4014
4015 return nil
4016}
4017
4018func DecodeOxmIdCtLabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtLabel, error) {
4019 _oxmidctlabel := &OxmIdCtLabel{OxmId: parent}
4020 return _oxmidctlabel, nil
4021}
4022
4023func NewOxmIdCtLabel() *OxmIdCtLabel {
4024 obj := &OxmIdCtLabel{
4025 OxmId: NewOxmId(120848),
4026 }
4027 return obj
4028}
4029func (self *OxmIdCtLabel) GetOXMName() string {
4030 return "ct_label"
4031}
4032
4033func (self *OxmIdCtLabel) MarshalJSON() ([]byte, error) {
4034 if self.TypeLen == 0 {
4035 return []byte("\"\""), nil
4036 } else {
4037 return []byte("\"" + self.GetOXMName() + "\""), nil
4038 }
4039}
4040
4041type OxmIdCtLabelMasked struct {
4042 *OxmId
4043}
4044
4045type IOxmIdCtLabelMasked interface {
4046 IOxmId
4047}
4048
4049func (self *OxmIdCtLabelMasked) Serialize(encoder *goloxi.Encoder) error {
4050 if err := self.OxmId.Serialize(encoder); err != nil {
4051 return err
4052 }
4053
4054 return nil
4055}
4056
4057func DecodeOxmIdCtLabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtLabelMasked, error) {
4058 _oxmidctlabelmasked := &OxmIdCtLabelMasked{OxmId: parent}
4059 return _oxmidctlabelmasked, nil
4060}
4061
4062func NewOxmIdCtLabelMasked() *OxmIdCtLabelMasked {
4063 obj := &OxmIdCtLabelMasked{
4064 OxmId: NewOxmId(121120),
4065 }
4066 return obj
4067}
4068func (self *OxmIdCtLabelMasked) GetOXMName() string {
4069 return "ct_label_masked"
4070}
4071
4072func (self *OxmIdCtLabelMasked) MarshalJSON() ([]byte, error) {
4073 if self.TypeLen == 0 {
4074 return []byte("\"\""), nil
4075 } else {
4076 return []byte("\"" + self.GetOXMName() + "\""), nil
4077 }
4078}
4079
4080type OxmIdCtMark struct {
4081 *OxmId
4082}
4083
4084type IOxmIdCtMark interface {
4085 IOxmId
4086}
4087
4088func (self *OxmIdCtMark) Serialize(encoder *goloxi.Encoder) error {
4089 if err := self.OxmId.Serialize(encoder); err != nil {
4090 return err
4091 }
4092
4093 return nil
4094}
4095
4096func DecodeOxmIdCtMark(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtMark, error) {
4097 _oxmidctmark := &OxmIdCtMark{OxmId: parent}
4098 return _oxmidctmark, nil
4099}
4100
4101func NewOxmIdCtMark() *OxmIdCtMark {
4102 obj := &OxmIdCtMark{
4103 OxmId: NewOxmId(120324),
4104 }
4105 return obj
4106}
4107func (self *OxmIdCtMark) GetOXMName() string {
4108 return "ct_mark"
4109}
4110
4111func (self *OxmIdCtMark) MarshalJSON() ([]byte, error) {
4112 if self.TypeLen == 0 {
4113 return []byte("\"\""), nil
4114 } else {
4115 return []byte("\"" + self.GetOXMName() + "\""), nil
4116 }
4117}
4118
4119type OxmIdCtMarkMasked struct {
4120 *OxmId
4121}
4122
4123type IOxmIdCtMarkMasked interface {
4124 IOxmId
4125}
4126
4127func (self *OxmIdCtMarkMasked) Serialize(encoder *goloxi.Encoder) error {
4128 if err := self.OxmId.Serialize(encoder); err != nil {
4129 return err
4130 }
4131
4132 return nil
4133}
4134
4135func DecodeOxmIdCtMarkMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtMarkMasked, error) {
4136 _oxmidctmarkmasked := &OxmIdCtMarkMasked{OxmId: parent}
4137 return _oxmidctmarkmasked, nil
4138}
4139
4140func NewOxmIdCtMarkMasked() *OxmIdCtMarkMasked {
4141 obj := &OxmIdCtMarkMasked{
4142 OxmId: NewOxmId(120584),
4143 }
4144 return obj
4145}
4146func (self *OxmIdCtMarkMasked) GetOXMName() string {
4147 return "ct_mark_masked"
4148}
4149
4150func (self *OxmIdCtMarkMasked) MarshalJSON() ([]byte, error) {
4151 if self.TypeLen == 0 {
4152 return []byte("\"\""), nil
4153 } else {
4154 return []byte("\"" + self.GetOXMName() + "\""), nil
4155 }
4156}
4157
4158type OxmIdCtNwDst struct {
4159 *OxmId
4160}
4161
4162type IOxmIdCtNwDst interface {
4163 IOxmId
4164}
4165
4166func (self *OxmIdCtNwDst) Serialize(encoder *goloxi.Encoder) error {
4167 if err := self.OxmId.Serialize(encoder); err != nil {
4168 return err
4169 }
4170
4171 return nil
4172}
4173
4174func DecodeOxmIdCtNwDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwDst, error) {
4175 _oxmidctnwdst := &OxmIdCtNwDst{OxmId: parent}
4176 return _oxmidctnwdst, nil
4177}
4178
4179func NewOxmIdCtNwDst() *OxmIdCtNwDst {
4180 obj := &OxmIdCtNwDst{
4181 OxmId: NewOxmId(127492),
4182 }
4183 return obj
4184}
4185func (self *OxmIdCtNwDst) GetOXMName() string {
4186 return "ct_nw_dst"
4187}
4188
4189func (self *OxmIdCtNwDst) MarshalJSON() ([]byte, error) {
4190 if self.TypeLen == 0 {
4191 return []byte("\"\""), nil
4192 } else {
4193 return []byte("\"" + self.GetOXMName() + "\""), nil
4194 }
4195}
4196
4197type OxmIdCtNwDstMasked struct {
4198 *OxmId
4199}
4200
4201type IOxmIdCtNwDstMasked interface {
4202 IOxmId
4203}
4204
4205func (self *OxmIdCtNwDstMasked) Serialize(encoder *goloxi.Encoder) error {
4206 if err := self.OxmId.Serialize(encoder); err != nil {
4207 return err
4208 }
4209
4210 return nil
4211}
4212
4213func DecodeOxmIdCtNwDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwDstMasked, error) {
4214 _oxmidctnwdstmasked := &OxmIdCtNwDstMasked{OxmId: parent}
4215 return _oxmidctnwdstmasked, nil
4216}
4217
4218func NewOxmIdCtNwDstMasked() *OxmIdCtNwDstMasked {
4219 obj := &OxmIdCtNwDstMasked{
4220 OxmId: NewOxmId(127752),
4221 }
4222 return obj
4223}
4224func (self *OxmIdCtNwDstMasked) GetOXMName() string {
4225 return "ct_nw_dst_masked"
4226}
4227
4228func (self *OxmIdCtNwDstMasked) MarshalJSON() ([]byte, error) {
4229 if self.TypeLen == 0 {
4230 return []byte("\"\""), nil
4231 } else {
4232 return []byte("\"" + self.GetOXMName() + "\""), nil
4233 }
4234}
4235
4236type OxmIdCtNwProto struct {
4237 *OxmId
4238}
4239
4240type IOxmIdCtNwProto interface {
4241 IOxmId
4242}
4243
4244func (self *OxmIdCtNwProto) Serialize(encoder *goloxi.Encoder) error {
4245 if err := self.OxmId.Serialize(encoder); err != nil {
4246 return err
4247 }
4248
4249 return nil
4250}
4251
4252func DecodeOxmIdCtNwProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwProto, error) {
4253 _oxmidctnwproto := &OxmIdCtNwProto{OxmId: parent}
4254 return _oxmidctnwproto, nil
4255}
4256
4257func NewOxmIdCtNwProto() *OxmIdCtNwProto {
4258 obj := &OxmIdCtNwProto{
4259 OxmId: NewOxmId(126465),
4260 }
4261 return obj
4262}
4263func (self *OxmIdCtNwProto) GetOXMName() string {
4264 return "ct_nw_proto"
4265}
4266
4267func (self *OxmIdCtNwProto) MarshalJSON() ([]byte, error) {
4268 if self.TypeLen == 0 {
4269 return []byte("\"\""), nil
4270 } else {
4271 return []byte("\"" + self.GetOXMName() + "\""), nil
4272 }
4273}
4274
4275type OxmIdCtNwSrc struct {
4276 *OxmId
4277}
4278
4279type IOxmIdCtNwSrc interface {
4280 IOxmId
4281}
4282
4283func (self *OxmIdCtNwSrc) Serialize(encoder *goloxi.Encoder) error {
4284 if err := self.OxmId.Serialize(encoder); err != nil {
4285 return err
4286 }
4287
4288 return nil
4289}
4290
4291func DecodeOxmIdCtNwSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwSrc, error) {
4292 _oxmidctnwsrc := &OxmIdCtNwSrc{OxmId: parent}
4293 return _oxmidctnwsrc, nil
4294}
4295
4296func NewOxmIdCtNwSrc() *OxmIdCtNwSrc {
4297 obj := &OxmIdCtNwSrc{
4298 OxmId: NewOxmId(126980),
4299 }
4300 return obj
4301}
4302func (self *OxmIdCtNwSrc) GetOXMName() string {
4303 return "ct_nw_src"
4304}
4305
4306func (self *OxmIdCtNwSrc) MarshalJSON() ([]byte, error) {
4307 if self.TypeLen == 0 {
4308 return []byte("\"\""), nil
4309 } else {
4310 return []byte("\"" + self.GetOXMName() + "\""), nil
4311 }
4312}
4313
4314type OxmIdCtNwSrcMasked struct {
4315 *OxmId
4316}
4317
4318type IOxmIdCtNwSrcMasked interface {
4319 IOxmId
4320}
4321
4322func (self *OxmIdCtNwSrcMasked) Serialize(encoder *goloxi.Encoder) error {
4323 if err := self.OxmId.Serialize(encoder); err != nil {
4324 return err
4325 }
4326
4327 return nil
4328}
4329
4330func DecodeOxmIdCtNwSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtNwSrcMasked, error) {
4331 _oxmidctnwsrcmasked := &OxmIdCtNwSrcMasked{OxmId: parent}
4332 return _oxmidctnwsrcmasked, nil
4333}
4334
4335func NewOxmIdCtNwSrcMasked() *OxmIdCtNwSrcMasked {
4336 obj := &OxmIdCtNwSrcMasked{
4337 OxmId: NewOxmId(127240),
4338 }
4339 return obj
4340}
4341func (self *OxmIdCtNwSrcMasked) GetOXMName() string {
4342 return "ct_nw_src_masked"
4343}
4344
4345func (self *OxmIdCtNwSrcMasked) MarshalJSON() ([]byte, error) {
4346 if self.TypeLen == 0 {
4347 return []byte("\"\""), nil
4348 } else {
4349 return []byte("\"" + self.GetOXMName() + "\""), nil
4350 }
4351}
4352
4353type OxmIdCtState struct {
4354 *OxmId
4355}
4356
4357type IOxmIdCtState interface {
4358 IOxmId
4359}
4360
4361func (self *OxmIdCtState) Serialize(encoder *goloxi.Encoder) error {
4362 if err := self.OxmId.Serialize(encoder); err != nil {
4363 return err
4364 }
4365
4366 return nil
4367}
4368
4369func DecodeOxmIdCtState(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtState, error) {
4370 _oxmidctstate := &OxmIdCtState{OxmId: parent}
4371 return _oxmidctstate, nil
4372}
4373
4374func NewOxmIdCtState() *OxmIdCtState {
4375 obj := &OxmIdCtState{
4376 OxmId: NewOxmId(119300),
4377 }
4378 return obj
4379}
4380func (self *OxmIdCtState) GetOXMName() string {
4381 return "ct_state"
4382}
4383
4384func (self *OxmIdCtState) MarshalJSON() ([]byte, error) {
4385 if self.TypeLen == 0 {
4386 return []byte("\"\""), nil
4387 } else {
4388 return []byte("\"" + self.GetOXMName() + "\""), nil
4389 }
4390}
4391
4392type OxmIdCtStateMasked struct {
4393 *OxmId
4394}
4395
4396type IOxmIdCtStateMasked interface {
4397 IOxmId
4398}
4399
4400func (self *OxmIdCtStateMasked) Serialize(encoder *goloxi.Encoder) error {
4401 if err := self.OxmId.Serialize(encoder); err != nil {
4402 return err
4403 }
4404
4405 return nil
4406}
4407
4408func DecodeOxmIdCtStateMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtStateMasked, error) {
4409 _oxmidctstatemasked := &OxmIdCtStateMasked{OxmId: parent}
4410 return _oxmidctstatemasked, nil
4411}
4412
4413func NewOxmIdCtStateMasked() *OxmIdCtStateMasked {
4414 obj := &OxmIdCtStateMasked{
4415 OxmId: NewOxmId(119560),
4416 }
4417 return obj
4418}
4419func (self *OxmIdCtStateMasked) GetOXMName() string {
4420 return "ct_state_masked"
4421}
4422
4423func (self *OxmIdCtStateMasked) MarshalJSON() ([]byte, error) {
4424 if self.TypeLen == 0 {
4425 return []byte("\"\""), nil
4426 } else {
4427 return []byte("\"" + self.GetOXMName() + "\""), nil
4428 }
4429}
4430
4431type OxmIdCtTpDst struct {
4432 *OxmId
4433}
4434
4435type IOxmIdCtTpDst interface {
4436 IOxmId
4437}
4438
4439func (self *OxmIdCtTpDst) Serialize(encoder *goloxi.Encoder) error {
4440 if err := self.OxmId.Serialize(encoder); err != nil {
4441 return err
4442 }
4443
4444 return nil
4445}
4446
4447func DecodeOxmIdCtTpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpDst, error) {
4448 _oxmidcttpdst := &OxmIdCtTpDst{OxmId: parent}
4449 return _oxmidcttpdst, nil
4450}
4451
4452func NewOxmIdCtTpDst() *OxmIdCtTpDst {
4453 obj := &OxmIdCtTpDst{
4454 OxmId: NewOxmId(129538),
4455 }
4456 return obj
4457}
4458func (self *OxmIdCtTpDst) GetOXMName() string {
4459 return "ct_tp_dst"
4460}
4461
4462func (self *OxmIdCtTpDst) MarshalJSON() ([]byte, error) {
4463 if self.TypeLen == 0 {
4464 return []byte("\"\""), nil
4465 } else {
4466 return []byte("\"" + self.GetOXMName() + "\""), nil
4467 }
4468}
4469
4470type OxmIdCtTpDstMasked struct {
4471 *OxmId
4472}
4473
4474type IOxmIdCtTpDstMasked interface {
4475 IOxmId
4476}
4477
4478func (self *OxmIdCtTpDstMasked) Serialize(encoder *goloxi.Encoder) error {
4479 if err := self.OxmId.Serialize(encoder); err != nil {
4480 return err
4481 }
4482
4483 return nil
4484}
4485
4486func DecodeOxmIdCtTpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpDstMasked, error) {
4487 _oxmidcttpdstmasked := &OxmIdCtTpDstMasked{OxmId: parent}
4488 return _oxmidcttpdstmasked, nil
4489}
4490
4491func NewOxmIdCtTpDstMasked() *OxmIdCtTpDstMasked {
4492 obj := &OxmIdCtTpDstMasked{
4493 OxmId: NewOxmId(129796),
4494 }
4495 return obj
4496}
4497func (self *OxmIdCtTpDstMasked) GetOXMName() string {
4498 return "ct_tp_dst_masked"
4499}
4500
4501func (self *OxmIdCtTpDstMasked) MarshalJSON() ([]byte, error) {
4502 if self.TypeLen == 0 {
4503 return []byte("\"\""), nil
4504 } else {
4505 return []byte("\"" + self.GetOXMName() + "\""), nil
4506 }
4507}
4508
4509type OxmIdCtTpSrc struct {
4510 *OxmId
4511}
4512
4513type IOxmIdCtTpSrc interface {
4514 IOxmId
4515}
4516
4517func (self *OxmIdCtTpSrc) Serialize(encoder *goloxi.Encoder) error {
4518 if err := self.OxmId.Serialize(encoder); err != nil {
4519 return err
4520 }
4521
4522 return nil
4523}
4524
4525func DecodeOxmIdCtTpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpSrc, error) {
4526 _oxmidcttpsrc := &OxmIdCtTpSrc{OxmId: parent}
4527 return _oxmidcttpsrc, nil
4528}
4529
4530func NewOxmIdCtTpSrc() *OxmIdCtTpSrc {
4531 obj := &OxmIdCtTpSrc{
4532 OxmId: NewOxmId(129026),
4533 }
4534 return obj
4535}
4536func (self *OxmIdCtTpSrc) GetOXMName() string {
4537 return "ct_tp_src"
4538}
4539
4540func (self *OxmIdCtTpSrc) MarshalJSON() ([]byte, error) {
4541 if self.TypeLen == 0 {
4542 return []byte("\"\""), nil
4543 } else {
4544 return []byte("\"" + self.GetOXMName() + "\""), nil
4545 }
4546}
4547
4548type OxmIdCtTpSrcMasked struct {
4549 *OxmId
4550}
4551
4552type IOxmIdCtTpSrcMasked interface {
4553 IOxmId
4554}
4555
4556func (self *OxmIdCtTpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
4557 if err := self.OxmId.Serialize(encoder); err != nil {
4558 return err
4559 }
4560
4561 return nil
4562}
4563
4564func DecodeOxmIdCtTpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtTpSrcMasked, error) {
4565 _oxmidcttpsrcmasked := &OxmIdCtTpSrcMasked{OxmId: parent}
4566 return _oxmidcttpsrcmasked, nil
4567}
4568
4569func NewOxmIdCtTpSrcMasked() *OxmIdCtTpSrcMasked {
4570 obj := &OxmIdCtTpSrcMasked{
4571 OxmId: NewOxmId(129284),
4572 }
4573 return obj
4574}
4575func (self *OxmIdCtTpSrcMasked) GetOXMName() string {
4576 return "ct_tp_src_masked"
4577}
4578
4579func (self *OxmIdCtTpSrcMasked) MarshalJSON() ([]byte, error) {
4580 if self.TypeLen == 0 {
4581 return []byte("\"\""), nil
4582 } else {
4583 return []byte("\"" + self.GetOXMName() + "\""), nil
4584 }
4585}
4586
4587type OxmIdCtZone struct {
4588 *OxmId
4589}
4590
4591type IOxmIdCtZone interface {
4592 IOxmId
4593}
4594
4595func (self *OxmIdCtZone) Serialize(encoder *goloxi.Encoder) error {
4596 if err := self.OxmId.Serialize(encoder); err != nil {
4597 return err
4598 }
4599
4600 return nil
4601}
4602
4603func DecodeOxmIdCtZone(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdCtZone, error) {
4604 _oxmidctzone := &OxmIdCtZone{OxmId: parent}
4605 return _oxmidctzone, nil
4606}
4607
4608func NewOxmIdCtZone() *OxmIdCtZone {
4609 obj := &OxmIdCtZone{
4610 OxmId: NewOxmId(119810),
4611 }
4612 return obj
4613}
4614func (self *OxmIdCtZone) GetOXMName() string {
4615 return "ct_zone"
4616}
4617
4618func (self *OxmIdCtZone) MarshalJSON() ([]byte, error) {
4619 if self.TypeLen == 0 {
4620 return []byte("\"\""), nil
4621 } else {
4622 return []byte("\"" + self.GetOXMName() + "\""), nil
4623 }
4624}
4625
4626type OxmIdDpHash struct {
4627 *OxmId
4628}
4629
4630type IOxmIdDpHash interface {
4631 IOxmId
4632}
4633
4634func (self *OxmIdDpHash) Serialize(encoder *goloxi.Encoder) error {
4635 if err := self.OxmId.Serialize(encoder); err != nil {
4636 return err
4637 }
4638
4639 return nil
4640}
4641
4642func DecodeOxmIdDpHash(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdDpHash, error) {
4643 _oxmiddphash := &OxmIdDpHash{OxmId: parent}
4644 return _oxmiddphash, nil
4645}
4646
4647func NewOxmIdDpHash() *OxmIdDpHash {
4648 obj := &OxmIdDpHash{
4649 OxmId: NewOxmId(83460),
4650 }
4651 return obj
4652}
4653func (self *OxmIdDpHash) GetOXMName() string {
4654 return "dp_hash"
4655}
4656
4657func (self *OxmIdDpHash) MarshalJSON() ([]byte, error) {
4658 if self.TypeLen == 0 {
4659 return []byte("\"\""), nil
4660 } else {
4661 return []byte("\"" + self.GetOXMName() + "\""), nil
4662 }
4663}
4664
4665type OxmIdDpHashMasked struct {
4666 *OxmId
4667}
4668
4669type IOxmIdDpHashMasked interface {
4670 IOxmId
4671}
4672
4673func (self *OxmIdDpHashMasked) Serialize(encoder *goloxi.Encoder) error {
4674 if err := self.OxmId.Serialize(encoder); err != nil {
4675 return err
4676 }
4677
4678 return nil
4679}
4680
4681func DecodeOxmIdDpHashMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdDpHashMasked, error) {
4682 _oxmiddphashmasked := &OxmIdDpHashMasked{OxmId: parent}
4683 return _oxmiddphashmasked, nil
4684}
4685
4686func NewOxmIdDpHashMasked() *OxmIdDpHashMasked {
4687 obj := &OxmIdDpHashMasked{
4688 OxmId: NewOxmId(83720),
4689 }
4690 return obj
4691}
4692func (self *OxmIdDpHashMasked) GetOXMName() string {
4693 return "dp_hash_masked"
4694}
4695
4696func (self *OxmIdDpHashMasked) MarshalJSON() ([]byte, error) {
4697 if self.TypeLen == 0 {
4698 return []byte("\"\""), nil
4699 } else {
4700 return []byte("\"" + self.GetOXMName() + "\""), nil
4701 }
4702}
4703
4704type OxmIdEthDst struct {
4705 *OxmId
4706}
4707
4708type IOxmIdEthDst interface {
4709 IOxmId
4710}
4711
4712func (self *OxmIdEthDst) Serialize(encoder *goloxi.Encoder) error {
4713 if err := self.OxmId.Serialize(encoder); err != nil {
4714 return err
4715 }
4716
4717 return nil
4718}
4719
4720func DecodeOxmIdEthDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthDst, error) {
4721 _oxmidethdst := &OxmIdEthDst{OxmId: parent}
4722 return _oxmidethdst, nil
4723}
4724
4725func NewOxmIdEthDst() *OxmIdEthDst {
4726 obj := &OxmIdEthDst{
4727 OxmId: NewOxmId(518),
4728 }
4729 return obj
4730}
4731func (self *OxmIdEthDst) GetOXMName() string {
4732 return "eth_dst"
4733}
4734
4735func (self *OxmIdEthDst) MarshalJSON() ([]byte, error) {
4736 if self.TypeLen == 0 {
4737 return []byte("\"\""), nil
4738 } else {
4739 return []byte("\"" + self.GetOXMName() + "\""), nil
4740 }
4741}
4742
4743type OxmIdEthDstMasked struct {
4744 *OxmId
4745}
4746
4747type IOxmIdEthDstMasked interface {
4748 IOxmId
4749}
4750
4751func (self *OxmIdEthDstMasked) Serialize(encoder *goloxi.Encoder) error {
4752 if err := self.OxmId.Serialize(encoder); err != nil {
4753 return err
4754 }
4755
4756 return nil
4757}
4758
4759func DecodeOxmIdEthDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthDstMasked, error) {
4760 _oxmidethdstmasked := &OxmIdEthDstMasked{OxmId: parent}
4761 return _oxmidethdstmasked, nil
4762}
4763
4764func NewOxmIdEthDstMasked() *OxmIdEthDstMasked {
4765 obj := &OxmIdEthDstMasked{
4766 OxmId: NewOxmId(779),
4767 }
4768 return obj
4769}
4770func (self *OxmIdEthDstMasked) GetOXMName() string {
4771 return "eth_dst_masked"
4772}
4773
4774func (self *OxmIdEthDstMasked) MarshalJSON() ([]byte, error) {
4775 if self.TypeLen == 0 {
4776 return []byte("\"\""), nil
4777 } else {
4778 return []byte("\"" + self.GetOXMName() + "\""), nil
4779 }
4780}
4781
4782type OxmIdEthSrc struct {
4783 *OxmId
4784}
4785
4786type IOxmIdEthSrc interface {
4787 IOxmId
4788}
4789
4790func (self *OxmIdEthSrc) Serialize(encoder *goloxi.Encoder) error {
4791 if err := self.OxmId.Serialize(encoder); err != nil {
4792 return err
4793 }
4794
4795 return nil
4796}
4797
4798func DecodeOxmIdEthSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthSrc, error) {
4799 _oxmidethsrc := &OxmIdEthSrc{OxmId: parent}
4800 return _oxmidethsrc, nil
4801}
4802
4803func NewOxmIdEthSrc() *OxmIdEthSrc {
4804 obj := &OxmIdEthSrc{
4805 OxmId: NewOxmId(1030),
4806 }
4807 return obj
4808}
4809func (self *OxmIdEthSrc) GetOXMName() string {
4810 return "eth_src"
4811}
4812
4813func (self *OxmIdEthSrc) MarshalJSON() ([]byte, error) {
4814 if self.TypeLen == 0 {
4815 return []byte("\"\""), nil
4816 } else {
4817 return []byte("\"" + self.GetOXMName() + "\""), nil
4818 }
4819}
4820
4821type OxmIdEthSrcMasked struct {
4822 *OxmId
4823}
4824
4825type IOxmIdEthSrcMasked interface {
4826 IOxmId
4827}
4828
4829func (self *OxmIdEthSrcMasked) Serialize(encoder *goloxi.Encoder) error {
4830 if err := self.OxmId.Serialize(encoder); err != nil {
4831 return err
4832 }
4833
4834 return nil
4835}
4836
4837func DecodeOxmIdEthSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthSrcMasked, error) {
4838 _oxmidethsrcmasked := &OxmIdEthSrcMasked{OxmId: parent}
4839 return _oxmidethsrcmasked, nil
4840}
4841
4842func NewOxmIdEthSrcMasked() *OxmIdEthSrcMasked {
4843 obj := &OxmIdEthSrcMasked{
4844 OxmId: NewOxmId(1286),
4845 }
4846 return obj
4847}
4848func (self *OxmIdEthSrcMasked) GetOXMName() string {
4849 return "eth_src_masked"
4850}
4851
4852func (self *OxmIdEthSrcMasked) MarshalJSON() ([]byte, error) {
4853 if self.TypeLen == 0 {
4854 return []byte("\"\""), nil
4855 } else {
4856 return []byte("\"" + self.GetOXMName() + "\""), nil
4857 }
4858}
4859
4860type OxmIdEthType struct {
4861 *OxmId
4862}
4863
4864type IOxmIdEthType interface {
4865 IOxmId
4866}
4867
4868func (self *OxmIdEthType) Serialize(encoder *goloxi.Encoder) error {
4869 if err := self.OxmId.Serialize(encoder); err != nil {
4870 return err
4871 }
4872
4873 return nil
4874}
4875
4876func DecodeOxmIdEthType(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthType, error) {
4877 _oxmidethtype := &OxmIdEthType{OxmId: parent}
4878 return _oxmidethtype, nil
4879}
4880
4881func NewOxmIdEthType() *OxmIdEthType {
4882 obj := &OxmIdEthType{
4883 OxmId: NewOxmId(1538),
4884 }
4885 return obj
4886}
4887func (self *OxmIdEthType) GetOXMName() string {
4888 return "eth_type"
4889}
4890
4891func (self *OxmIdEthType) MarshalJSON() ([]byte, error) {
4892 if self.TypeLen == 0 {
4893 return []byte("\"\""), nil
4894 } else {
4895 return []byte("\"" + self.GetOXMName() + "\""), nil
4896 }
4897}
4898
4899type OxmIdIcmpCode struct {
4900 *OxmId
4901}
4902
4903type IOxmIdIcmpCode interface {
4904 IOxmId
4905}
4906
4907func (self *OxmIdIcmpCode) Serialize(encoder *goloxi.Encoder) error {
4908 if err := self.OxmId.Serialize(encoder); err != nil {
4909 return err
4910 }
4911
4912 return nil
4913}
4914
4915func DecodeOxmIdIcmpCode(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpCode, error) {
4916 _oxmidicmpcode := &OxmIdIcmpCode{OxmId: parent}
4917 return _oxmidicmpcode, nil
4918}
4919
4920func NewOxmIdIcmpCode() *OxmIdIcmpCode {
4921 obj := &OxmIdIcmpCode{
4922 OxmId: NewOxmId(7169),
4923 }
4924 return obj
4925}
4926func (self *OxmIdIcmpCode) GetOXMName() string {
4927 return "icmp_code"
4928}
4929
4930func (self *OxmIdIcmpCode) MarshalJSON() ([]byte, error) {
4931 if self.TypeLen == 0 {
4932 return []byte("\"\""), nil
4933 } else {
4934 return []byte("\"" + self.GetOXMName() + "\""), nil
4935 }
4936}
4937
4938type OxmIdIcmpType struct {
4939 *OxmId
4940}
4941
4942type IOxmIdIcmpType interface {
4943 IOxmId
4944}
4945
4946func (self *OxmIdIcmpType) Serialize(encoder *goloxi.Encoder) error {
4947 if err := self.OxmId.Serialize(encoder); err != nil {
4948 return err
4949 }
4950
4951 return nil
4952}
4953
4954func DecodeOxmIdIcmpType(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpType, error) {
4955 _oxmidicmptype := &OxmIdIcmpType{OxmId: parent}
4956 return _oxmidicmptype, nil
4957}
4958
4959func NewOxmIdIcmpType() *OxmIdIcmpType {
4960 obj := &OxmIdIcmpType{
4961 OxmId: NewOxmId(6657),
4962 }
4963 return obj
4964}
4965func (self *OxmIdIcmpType) GetOXMName() string {
4966 return "icmp_type"
4967}
4968
4969func (self *OxmIdIcmpType) MarshalJSON() ([]byte, error) {
4970 if self.TypeLen == 0 {
4971 return []byte("\"\""), nil
4972 } else {
4973 return []byte("\"" + self.GetOXMName() + "\""), nil
4974 }
4975}
4976
4977type OxmIdIcmpv6Code struct {
4978 *OxmId
4979}
4980
4981type IOxmIdIcmpv6Code interface {
4982 IOxmId
4983}
4984
4985func (self *OxmIdIcmpv6Code) Serialize(encoder *goloxi.Encoder) error {
4986 if err := self.OxmId.Serialize(encoder); err != nil {
4987 return err
4988 }
4989
4990 return nil
4991}
4992
4993func DecodeOxmIdIcmpv6Code(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6Code, error) {
4994 _oxmidicmpv6code := &OxmIdIcmpv6Code{OxmId: parent}
4995 return _oxmidicmpv6code, nil
4996}
4997
4998func NewOxmIdIcmpv6Code() *OxmIdIcmpv6Code {
4999 obj := &OxmIdIcmpv6Code{
5000 OxmId: NewOxmId(76801),
5001 }
5002 return obj
5003}
5004func (self *OxmIdIcmpv6Code) GetOXMName() string {
5005 return "icmpv6_code"
5006}
5007
5008func (self *OxmIdIcmpv6Code) MarshalJSON() ([]byte, error) {
5009 if self.TypeLen == 0 {
5010 return []byte("\"\""), nil
5011 } else {
5012 return []byte("\"" + self.GetOXMName() + "\""), nil
5013 }
5014}
5015
5016type OxmIdIcmpv6Type struct {
5017 *OxmId
5018}
5019
5020type IOxmIdIcmpv6Type interface {
5021 IOxmId
5022}
5023
5024func (self *OxmIdIcmpv6Type) Serialize(encoder *goloxi.Encoder) error {
5025 if err := self.OxmId.Serialize(encoder); err != nil {
5026 return err
5027 }
5028
5029 return nil
5030}
5031
5032func DecodeOxmIdIcmpv6Type(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6Type, error) {
5033 _oxmidicmpv6type := &OxmIdIcmpv6Type{OxmId: parent}
5034 return _oxmidicmpv6type, nil
5035}
5036
5037func NewOxmIdIcmpv6Type() *OxmIdIcmpv6Type {
5038 obj := &OxmIdIcmpv6Type{
5039 OxmId: NewOxmId(76289),
5040 }
5041 return obj
5042}
5043func (self *OxmIdIcmpv6Type) GetOXMName() string {
5044 return "icmpv6_type"
5045}
5046
5047func (self *OxmIdIcmpv6Type) MarshalJSON() ([]byte, error) {
5048 if self.TypeLen == 0 {
5049 return []byte("\"\""), nil
5050 } else {
5051 return []byte("\"" + self.GetOXMName() + "\""), nil
5052 }
5053}
5054
5055type OxmIdInPort struct {
5056 *OxmId
5057}
5058
5059type IOxmIdInPort interface {
5060 IOxmId
5061}
5062
5063func (self *OxmIdInPort) Serialize(encoder *goloxi.Encoder) error {
5064 if err := self.OxmId.Serialize(encoder); err != nil {
5065 return err
5066 }
5067
5068 return nil
5069}
5070
5071func DecodeOxmIdInPort(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPort, error) {
5072 _oxmidinport := &OxmIdInPort{OxmId: parent}
5073 return _oxmidinport, nil
5074}
5075
5076func NewOxmIdInPort() *OxmIdInPort {
5077 obj := &OxmIdInPort{
5078 OxmId: NewOxmId(2),
5079 }
5080 return obj
5081}
5082func (self *OxmIdInPort) GetOXMName() string {
5083 return "in_port"
5084}
5085
5086func (self *OxmIdInPort) MarshalJSON() ([]byte, error) {
5087 if self.TypeLen == 0 {
5088 return []byte("\"\""), nil
5089 } else {
5090 return []byte("\"" + self.GetOXMName() + "\""), nil
5091 }
5092}
5093
5094type OxmIdIpDst struct {
5095 *OxmId
5096}
5097
5098type IOxmIdIpDst interface {
5099 IOxmId
5100}
5101
5102func (self *OxmIdIpDst) Serialize(encoder *goloxi.Encoder) error {
5103 if err := self.OxmId.Serialize(encoder); err != nil {
5104 return err
5105 }
5106
5107 return nil
5108}
5109
5110func DecodeOxmIdIpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDst, error) {
5111 _oxmidipdst := &OxmIdIpDst{OxmId: parent}
5112 return _oxmidipdst, nil
5113}
5114
5115func NewOxmIdIpDst() *OxmIdIpDst {
5116 obj := &OxmIdIpDst{
5117 OxmId: NewOxmId(4100),
5118 }
5119 return obj
5120}
5121func (self *OxmIdIpDst) GetOXMName() string {
5122 return "ip_dst"
5123}
5124
5125func (self *OxmIdIpDst) MarshalJSON() ([]byte, error) {
5126 if self.TypeLen == 0 {
5127 return []byte("\"\""), nil
5128 } else {
5129 return []byte("\"" + self.GetOXMName() + "\""), nil
5130 }
5131}
5132
5133type OxmIdIpDstMasked struct {
5134 *OxmId
5135}
5136
5137type IOxmIdIpDstMasked interface {
5138 IOxmId
5139}
5140
5141func (self *OxmIdIpDstMasked) Serialize(encoder *goloxi.Encoder) error {
5142 if err := self.OxmId.Serialize(encoder); err != nil {
5143 return err
5144 }
5145
5146 return nil
5147}
5148
5149func DecodeOxmIdIpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDstMasked, error) {
5150 _oxmidipdstmasked := &OxmIdIpDstMasked{OxmId: parent}
5151 return _oxmidipdstmasked, nil
5152}
5153
5154func NewOxmIdIpDstMasked() *OxmIdIpDstMasked {
5155 obj := &OxmIdIpDstMasked{
5156 OxmId: NewOxmId(4360),
5157 }
5158 return obj
5159}
5160func (self *OxmIdIpDstMasked) GetOXMName() string {
5161 return "ip_dst_masked"
5162}
5163
5164func (self *OxmIdIpDstMasked) MarshalJSON() ([]byte, error) {
5165 if self.TypeLen == 0 {
5166 return []byte("\"\""), nil
5167 } else {
5168 return []byte("\"" + self.GetOXMName() + "\""), nil
5169 }
5170}
5171
5172type OxmIdIpFrag struct {
5173 *OxmId
5174}
5175
5176type IOxmIdIpFrag interface {
5177 IOxmId
5178}
5179
5180func (self *OxmIdIpFrag) Serialize(encoder *goloxi.Encoder) error {
5181 if err := self.OxmId.Serialize(encoder); err != nil {
5182 return err
5183 }
5184
5185 return nil
5186}
5187
5188func DecodeOxmIdIpFrag(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpFrag, error) {
5189 _oxmidipfrag := &OxmIdIpFrag{OxmId: parent}
5190 return _oxmidipfrag, nil
5191}
5192
5193func NewOxmIdIpFrag() *OxmIdIpFrag {
5194 obj := &OxmIdIpFrag{
5195 OxmId: NewOxmId(78849),
5196 }
5197 return obj
5198}
5199func (self *OxmIdIpFrag) GetOXMName() string {
5200 return "ip_frag"
5201}
5202
5203func (self *OxmIdIpFrag) MarshalJSON() ([]byte, error) {
5204 if self.TypeLen == 0 {
5205 return []byte("\"\""), nil
5206 } else {
5207 return []byte("\"" + self.GetOXMName() + "\""), nil
5208 }
5209}
5210
5211type OxmIdIpFragMasked struct {
5212 *OxmId
5213}
5214
5215type IOxmIdIpFragMasked interface {
5216 IOxmId
5217}
5218
5219func (self *OxmIdIpFragMasked) Serialize(encoder *goloxi.Encoder) error {
5220 if err := self.OxmId.Serialize(encoder); err != nil {
5221 return err
5222 }
5223
5224 return nil
5225}
5226
5227func DecodeOxmIdIpFragMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpFragMasked, error) {
5228 _oxmidipfragmasked := &OxmIdIpFragMasked{OxmId: parent}
5229 return _oxmidipfragmasked, nil
5230}
5231
5232func NewOxmIdIpFragMasked() *OxmIdIpFragMasked {
5233 obj := &OxmIdIpFragMasked{
5234 OxmId: NewOxmId(79106),
5235 }
5236 return obj
5237}
5238func (self *OxmIdIpFragMasked) GetOXMName() string {
5239 return "ip_frag_masked"
5240}
5241
5242func (self *OxmIdIpFragMasked) MarshalJSON() ([]byte, error) {
5243 if self.TypeLen == 0 {
5244 return []byte("\"\""), nil
5245 } else {
5246 return []byte("\"" + self.GetOXMName() + "\""), nil
5247 }
5248}
5249
5250type OxmIdIpSrc struct {
5251 *OxmId
5252}
5253
5254type IOxmIdIpSrc interface {
5255 IOxmId
5256}
5257
5258func (self *OxmIdIpSrc) Serialize(encoder *goloxi.Encoder) error {
5259 if err := self.OxmId.Serialize(encoder); err != nil {
5260 return err
5261 }
5262
5263 return nil
5264}
5265
5266func DecodeOxmIdIpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpSrc, error) {
5267 _oxmidipsrc := &OxmIdIpSrc{OxmId: parent}
5268 return _oxmidipsrc, nil
5269}
5270
5271func NewOxmIdIpSrc() *OxmIdIpSrc {
5272 obj := &OxmIdIpSrc{
5273 OxmId: NewOxmId(3588),
5274 }
5275 return obj
5276}
5277func (self *OxmIdIpSrc) GetOXMName() string {
5278 return "ip_src"
5279}
5280
5281func (self *OxmIdIpSrc) MarshalJSON() ([]byte, error) {
5282 if self.TypeLen == 0 {
5283 return []byte("\"\""), nil
5284 } else {
5285 return []byte("\"" + self.GetOXMName() + "\""), nil
5286 }
5287}
5288
5289type OxmIdIpSrcMasked struct {
5290 *OxmId
5291}
5292
5293type IOxmIdIpSrcMasked interface {
5294 IOxmId
5295}
5296
5297func (self *OxmIdIpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
5298 if err := self.OxmId.Serialize(encoder); err != nil {
5299 return err
5300 }
5301
5302 return nil
5303}
5304
5305func DecodeOxmIdIpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpSrcMasked, error) {
5306 _oxmidipsrcmasked := &OxmIdIpSrcMasked{OxmId: parent}
5307 return _oxmidipsrcmasked, nil
5308}
5309
5310func NewOxmIdIpSrcMasked() *OxmIdIpSrcMasked {
5311 obj := &OxmIdIpSrcMasked{
5312 OxmId: NewOxmId(3848),
5313 }
5314 return obj
5315}
5316func (self *OxmIdIpSrcMasked) GetOXMName() string {
5317 return "ip_src_masked"
5318}
5319
5320func (self *OxmIdIpSrcMasked) MarshalJSON() ([]byte, error) {
5321 if self.TypeLen == 0 {
5322 return []byte("\"\""), nil
5323 } else {
5324 return []byte("\"" + self.GetOXMName() + "\""), nil
5325 }
5326}
5327
5328type OxmIdIpv6Dst struct {
5329 *OxmId
5330}
5331
5332type IOxmIdIpv6Dst interface {
5333 IOxmId
5334}
5335
5336func (self *OxmIdIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
5337 if err := self.OxmId.Serialize(encoder); err != nil {
5338 return err
5339 }
5340
5341 return nil
5342}
5343
5344func DecodeOxmIdIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Dst, error) {
5345 _oxmidipv6dst := &OxmIdIpv6Dst{OxmId: parent}
5346 return _oxmidipv6dst, nil
5347}
5348
5349func NewOxmIdIpv6Dst() *OxmIdIpv6Dst {
5350 obj := &OxmIdIpv6Dst{
5351 OxmId: NewOxmId(75792),
5352 }
5353 return obj
5354}
5355func (self *OxmIdIpv6Dst) GetOXMName() string {
5356 return "ipv6_dst"
5357}
5358
5359func (self *OxmIdIpv6Dst) MarshalJSON() ([]byte, error) {
5360 if self.TypeLen == 0 {
5361 return []byte("\"\""), nil
5362 } else {
5363 return []byte("\"" + self.GetOXMName() + "\""), nil
5364 }
5365}
5366
5367type OxmIdIpv6DstMasked struct {
5368 *OxmId
5369}
5370
5371type IOxmIdIpv6DstMasked interface {
5372 IOxmId
5373}
5374
5375func (self *OxmIdIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
5376 if err := self.OxmId.Serialize(encoder); err != nil {
5377 return err
5378 }
5379
5380 return nil
5381}
5382
5383func DecodeOxmIdIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6DstMasked, error) {
5384 _oxmidipv6dstmasked := &OxmIdIpv6DstMasked{OxmId: parent}
5385 return _oxmidipv6dstmasked, nil
5386}
5387
5388func NewOxmIdIpv6DstMasked() *OxmIdIpv6DstMasked {
5389 obj := &OxmIdIpv6DstMasked{
5390 OxmId: NewOxmId(76064),
5391 }
5392 return obj
5393}
5394func (self *OxmIdIpv6DstMasked) GetOXMName() string {
5395 return "ipv6_dst_masked"
5396}
5397
5398func (self *OxmIdIpv6DstMasked) MarshalJSON() ([]byte, error) {
5399 if self.TypeLen == 0 {
5400 return []byte("\"\""), nil
5401 } else {
5402 return []byte("\"" + self.GetOXMName() + "\""), nil
5403 }
5404}
5405
5406type OxmIdIpv6Label struct {
5407 *OxmId
5408}
5409
5410type IOxmIdIpv6Label interface {
5411 IOxmId
5412}
5413
5414func (self *OxmIdIpv6Label) Serialize(encoder *goloxi.Encoder) error {
5415 if err := self.OxmId.Serialize(encoder); err != nil {
5416 return err
5417 }
5418
5419 return nil
5420}
5421
5422func DecodeOxmIdIpv6Label(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Label, error) {
5423 _oxmidipv6label := &OxmIdIpv6Label{OxmId: parent}
5424 return _oxmidipv6label, nil
5425}
5426
5427func NewOxmIdIpv6Label() *OxmIdIpv6Label {
5428 obj := &OxmIdIpv6Label{
5429 OxmId: NewOxmId(79364),
5430 }
5431 return obj
5432}
5433func (self *OxmIdIpv6Label) GetOXMName() string {
5434 return "ipv6_label"
5435}
5436
5437func (self *OxmIdIpv6Label) MarshalJSON() ([]byte, error) {
5438 if self.TypeLen == 0 {
5439 return []byte("\"\""), nil
5440 } else {
5441 return []byte("\"" + self.GetOXMName() + "\""), nil
5442 }
5443}
5444
5445type OxmIdIpv6LabelMasked struct {
5446 *OxmId
5447}
5448
5449type IOxmIdIpv6LabelMasked interface {
5450 IOxmId
5451}
5452
5453func (self *OxmIdIpv6LabelMasked) Serialize(encoder *goloxi.Encoder) error {
5454 if err := self.OxmId.Serialize(encoder); err != nil {
5455 return err
5456 }
5457
5458 return nil
5459}
5460
5461func DecodeOxmIdIpv6LabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6LabelMasked, error) {
5462 _oxmidipv6labelmasked := &OxmIdIpv6LabelMasked{OxmId: parent}
5463 return _oxmidipv6labelmasked, nil
5464}
5465
5466func NewOxmIdIpv6LabelMasked() *OxmIdIpv6LabelMasked {
5467 obj := &OxmIdIpv6LabelMasked{
5468 OxmId: NewOxmId(79624),
5469 }
5470 return obj
5471}
5472func (self *OxmIdIpv6LabelMasked) GetOXMName() string {
5473 return "ipv6_label_masked"
5474}
5475
5476func (self *OxmIdIpv6LabelMasked) MarshalJSON() ([]byte, error) {
5477 if self.TypeLen == 0 {
5478 return []byte("\"\""), nil
5479 } else {
5480 return []byte("\"" + self.GetOXMName() + "\""), nil
5481 }
5482}
5483
5484type OxmIdIpv6Src struct {
5485 *OxmId
5486}
5487
5488type IOxmIdIpv6Src interface {
5489 IOxmId
5490}
5491
5492func (self *OxmIdIpv6Src) Serialize(encoder *goloxi.Encoder) error {
5493 if err := self.OxmId.Serialize(encoder); err != nil {
5494 return err
5495 }
5496
5497 return nil
5498}
5499
5500func DecodeOxmIdIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Src, error) {
5501 _oxmidipv6src := &OxmIdIpv6Src{OxmId: parent}
5502 return _oxmidipv6src, nil
5503}
5504
5505func NewOxmIdIpv6Src() *OxmIdIpv6Src {
5506 obj := &OxmIdIpv6Src{
5507 OxmId: NewOxmId(75280),
5508 }
5509 return obj
5510}
5511func (self *OxmIdIpv6Src) GetOXMName() string {
5512 return "ipv6_src"
5513}
5514
5515func (self *OxmIdIpv6Src) MarshalJSON() ([]byte, error) {
5516 if self.TypeLen == 0 {
5517 return []byte("\"\""), nil
5518 } else {
5519 return []byte("\"" + self.GetOXMName() + "\""), nil
5520 }
5521}
5522
5523type OxmIdIpv6SrcMasked struct {
5524 *OxmId
5525}
5526
5527type IOxmIdIpv6SrcMasked interface {
5528 IOxmId
5529}
5530
5531func (self *OxmIdIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
5532 if err := self.OxmId.Serialize(encoder); err != nil {
5533 return err
5534 }
5535
5536 return nil
5537}
5538
5539func DecodeOxmIdIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6SrcMasked, error) {
5540 _oxmidipv6srcmasked := &OxmIdIpv6SrcMasked{OxmId: parent}
5541 return _oxmidipv6srcmasked, nil
5542}
5543
5544func NewOxmIdIpv6SrcMasked() *OxmIdIpv6SrcMasked {
5545 obj := &OxmIdIpv6SrcMasked{
5546 OxmId: NewOxmId(75552),
5547 }
5548 return obj
5549}
5550func (self *OxmIdIpv6SrcMasked) GetOXMName() string {
5551 return "ipv6_src_masked"
5552}
5553
5554func (self *OxmIdIpv6SrcMasked) MarshalJSON() ([]byte, error) {
5555 if self.TypeLen == 0 {
5556 return []byte("\"\""), nil
5557 } else {
5558 return []byte("\"" + self.GetOXMName() + "\""), nil
5559 }
5560}
5561
5562type OxmIdMplsTtl struct {
5563 *OxmId
5564}
5565
5566type IOxmIdMplsTtl interface {
5567 IOxmId
5568}
5569
5570func (self *OxmIdMplsTtl) Serialize(encoder *goloxi.Encoder) error {
5571 if err := self.OxmId.Serialize(encoder); err != nil {
5572 return err
5573 }
5574
5575 return nil
5576}
5577
5578func DecodeOxmIdMplsTtl(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsTtl, error) {
5579 _oxmidmplsttl := &OxmIdMplsTtl{OxmId: parent}
5580 return _oxmidmplsttl, nil
5581}
5582
5583func NewOxmIdMplsTtl() *OxmIdMplsTtl {
5584 obj := &OxmIdMplsTtl{
5585 OxmId: NewOxmId(80897),
5586 }
5587 return obj
5588}
5589func (self *OxmIdMplsTtl) GetOXMName() string {
5590 return "mpls_ttl"
5591}
5592
5593func (self *OxmIdMplsTtl) MarshalJSON() ([]byte, error) {
5594 if self.TypeLen == 0 {
5595 return []byte("\"\""), nil
5596 } else {
5597 return []byte("\"" + self.GetOXMName() + "\""), nil
5598 }
5599}
5600
5601type OxmIdNdSll struct {
5602 *OxmId
5603}
5604
5605type IOxmIdNdSll interface {
5606 IOxmId
5607}
5608
5609func (self *OxmIdNdSll) Serialize(encoder *goloxi.Encoder) error {
5610 if err := self.OxmId.Serialize(encoder); err != nil {
5611 return err
5612 }
5613
5614 return nil
5615}
5616
5617func DecodeOxmIdNdSll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdSll, error) {
5618 _oxmidndsll := &OxmIdNdSll{OxmId: parent}
5619 return _oxmidndsll, nil
5620}
5621
5622func NewOxmIdNdSll() *OxmIdNdSll {
5623 obj := &OxmIdNdSll{
5624 OxmId: NewOxmId(77830),
5625 }
5626 return obj
5627}
5628func (self *OxmIdNdSll) GetOXMName() string {
5629 return "nd_sll"
5630}
5631
5632func (self *OxmIdNdSll) MarshalJSON() ([]byte, error) {
5633 if self.TypeLen == 0 {
5634 return []byte("\"\""), nil
5635 } else {
5636 return []byte("\"" + self.GetOXMName() + "\""), nil
5637 }
5638}
5639
5640type OxmIdNdSllMasked struct {
5641 *OxmId
5642}
5643
5644type IOxmIdNdSllMasked interface {
5645 IOxmId
5646}
5647
5648func (self *OxmIdNdSllMasked) Serialize(encoder *goloxi.Encoder) error {
5649 if err := self.OxmId.Serialize(encoder); err != nil {
5650 return err
5651 }
5652
5653 return nil
5654}
5655
5656func DecodeOxmIdNdSllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdSllMasked, error) {
5657 _oxmidndsllmasked := &OxmIdNdSllMasked{OxmId: parent}
5658 return _oxmidndsllmasked, nil
5659}
5660
5661func NewOxmIdNdSllMasked() *OxmIdNdSllMasked {
5662 obj := &OxmIdNdSllMasked{
5663 OxmId: NewOxmId(78091),
5664 }
5665 return obj
5666}
5667func (self *OxmIdNdSllMasked) GetOXMName() string {
5668 return "nd_sll_masked"
5669}
5670
5671func (self *OxmIdNdSllMasked) MarshalJSON() ([]byte, error) {
5672 if self.TypeLen == 0 {
5673 return []byte("\"\""), nil
5674 } else {
5675 return []byte("\"" + self.GetOXMName() + "\""), nil
5676 }
5677}
5678
5679type OxmIdNdTarget struct {
5680 *OxmId
5681}
5682
5683type IOxmIdNdTarget interface {
5684 IOxmId
5685}
5686
5687func (self *OxmIdNdTarget) Serialize(encoder *goloxi.Encoder) error {
5688 if err := self.OxmId.Serialize(encoder); err != nil {
5689 return err
5690 }
5691
5692 return nil
5693}
5694
5695func DecodeOxmIdNdTarget(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTarget, error) {
5696 _oxmidndtarget := &OxmIdNdTarget{OxmId: parent}
5697 return _oxmidndtarget, nil
5698}
5699
5700func NewOxmIdNdTarget() *OxmIdNdTarget {
5701 obj := &OxmIdNdTarget{
5702 OxmId: NewOxmId(77328),
5703 }
5704 return obj
5705}
5706func (self *OxmIdNdTarget) GetOXMName() string {
5707 return "nd_target"
5708}
5709
5710func (self *OxmIdNdTarget) MarshalJSON() ([]byte, error) {
5711 if self.TypeLen == 0 {
5712 return []byte("\"\""), nil
5713 } else {
5714 return []byte("\"" + self.GetOXMName() + "\""), nil
5715 }
5716}
5717
5718type OxmIdNdTargetMasked struct {
5719 *OxmId
5720}
5721
5722type IOxmIdNdTargetMasked interface {
5723 IOxmId
5724}
5725
5726func (self *OxmIdNdTargetMasked) Serialize(encoder *goloxi.Encoder) error {
5727 if err := self.OxmId.Serialize(encoder); err != nil {
5728 return err
5729 }
5730
5731 return nil
5732}
5733
5734func DecodeOxmIdNdTargetMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTargetMasked, error) {
5735 _oxmidndtargetmasked := &OxmIdNdTargetMasked{OxmId: parent}
5736 return _oxmidndtargetmasked, nil
5737}
5738
5739func NewOxmIdNdTargetMasked() *OxmIdNdTargetMasked {
5740 obj := &OxmIdNdTargetMasked{
5741 OxmId: NewOxmId(77600),
5742 }
5743 return obj
5744}
5745func (self *OxmIdNdTargetMasked) GetOXMName() string {
5746 return "nd_target_masked"
5747}
5748
5749func (self *OxmIdNdTargetMasked) MarshalJSON() ([]byte, error) {
5750 if self.TypeLen == 0 {
5751 return []byte("\"\""), nil
5752 } else {
5753 return []byte("\"" + self.GetOXMName() + "\""), nil
5754 }
5755}
5756
5757type OxmIdNdTll struct {
5758 *OxmId
5759}
5760
5761type IOxmIdNdTll interface {
5762 IOxmId
5763}
5764
5765func (self *OxmIdNdTll) Serialize(encoder *goloxi.Encoder) error {
5766 if err := self.OxmId.Serialize(encoder); err != nil {
5767 return err
5768 }
5769
5770 return nil
5771}
5772
5773func DecodeOxmIdNdTll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTll, error) {
5774 _oxmidndtll := &OxmIdNdTll{OxmId: parent}
5775 return _oxmidndtll, nil
5776}
5777
5778func NewOxmIdNdTll() *OxmIdNdTll {
5779 obj := &OxmIdNdTll{
5780 OxmId: NewOxmId(78342),
5781 }
5782 return obj
5783}
5784func (self *OxmIdNdTll) GetOXMName() string {
5785 return "nd_tll"
5786}
5787
5788func (self *OxmIdNdTll) MarshalJSON() ([]byte, error) {
5789 if self.TypeLen == 0 {
5790 return []byte("\"\""), nil
5791 } else {
5792 return []byte("\"" + self.GetOXMName() + "\""), nil
5793 }
5794}
5795
5796type OxmIdNdTllMasked struct {
5797 *OxmId
5798}
5799
5800type IOxmIdNdTllMasked interface {
5801 IOxmId
5802}
5803
5804func (self *OxmIdNdTllMasked) Serialize(encoder *goloxi.Encoder) error {
5805 if err := self.OxmId.Serialize(encoder); err != nil {
5806 return err
5807 }
5808
5809 return nil
5810}
5811
5812func DecodeOxmIdNdTllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNdTllMasked, error) {
5813 _oxmidndtllmasked := &OxmIdNdTllMasked{OxmId: parent}
5814 return _oxmidndtllmasked, nil
5815}
5816
5817func NewOxmIdNdTllMasked() *OxmIdNdTllMasked {
5818 obj := &OxmIdNdTllMasked{
5819 OxmId: NewOxmId(78603),
5820 }
5821 return obj
5822}
5823func (self *OxmIdNdTllMasked) GetOXMName() string {
5824 return "nd_tll_masked"
5825}
5826
5827func (self *OxmIdNdTllMasked) MarshalJSON() ([]byte, error) {
5828 if self.TypeLen == 0 {
5829 return []byte("\"\""), nil
5830 } else {
5831 return []byte("\"" + self.GetOXMName() + "\""), nil
5832 }
5833}
5834
5835type OxmIdNwEcn struct {
5836 *OxmId
5837}
5838
5839type IOxmIdNwEcn interface {
5840 IOxmId
5841}
5842
5843func (self *OxmIdNwEcn) Serialize(encoder *goloxi.Encoder) error {
5844 if err := self.OxmId.Serialize(encoder); err != nil {
5845 return err
5846 }
5847
5848 return nil
5849}
5850
5851func DecodeOxmIdNwEcn(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwEcn, error) {
5852 _oxmidnwecn := &OxmIdNwEcn{OxmId: parent}
5853 return _oxmidnwecn, nil
5854}
5855
5856func NewOxmIdNwEcn() *OxmIdNwEcn {
5857 obj := &OxmIdNwEcn{
5858 OxmId: NewOxmId(79873),
5859 }
5860 return obj
5861}
5862func (self *OxmIdNwEcn) GetOXMName() string {
5863 return "nw_ecn"
5864}
5865
5866func (self *OxmIdNwEcn) MarshalJSON() ([]byte, error) {
5867 if self.TypeLen == 0 {
5868 return []byte("\"\""), nil
5869 } else {
5870 return []byte("\"" + self.GetOXMName() + "\""), nil
5871 }
5872}
5873
5874type OxmIdNwProto struct {
5875 *OxmId
5876}
5877
5878type IOxmIdNwProto interface {
5879 IOxmId
5880}
5881
5882func (self *OxmIdNwProto) Serialize(encoder *goloxi.Encoder) error {
5883 if err := self.OxmId.Serialize(encoder); err != nil {
5884 return err
5885 }
5886
5887 return nil
5888}
5889
5890func DecodeOxmIdNwProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwProto, error) {
5891 _oxmidnwproto := &OxmIdNwProto{OxmId: parent}
5892 return _oxmidnwproto, nil
5893}
5894
5895func NewOxmIdNwProto() *OxmIdNwProto {
5896 obj := &OxmIdNwProto{
5897 OxmId: NewOxmId(3073),
5898 }
5899 return obj
5900}
5901func (self *OxmIdNwProto) GetOXMName() string {
5902 return "nw_proto"
5903}
5904
5905func (self *OxmIdNwProto) MarshalJSON() ([]byte, error) {
5906 if self.TypeLen == 0 {
5907 return []byte("\"\""), nil
5908 } else {
5909 return []byte("\"" + self.GetOXMName() + "\""), nil
5910 }
5911}
5912
5913type OxmIdNwTos struct {
5914 *OxmId
5915}
5916
5917type IOxmIdNwTos interface {
5918 IOxmId
5919}
5920
5921func (self *OxmIdNwTos) Serialize(encoder *goloxi.Encoder) error {
5922 if err := self.OxmId.Serialize(encoder); err != nil {
5923 return err
5924 }
5925
5926 return nil
5927}
5928
5929func DecodeOxmIdNwTos(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwTos, error) {
5930 _oxmidnwtos := &OxmIdNwTos{OxmId: parent}
5931 return _oxmidnwtos, nil
5932}
5933
5934func NewOxmIdNwTos() *OxmIdNwTos {
5935 obj := &OxmIdNwTos{
5936 OxmId: NewOxmId(2561),
5937 }
5938 return obj
5939}
5940func (self *OxmIdNwTos) GetOXMName() string {
5941 return "nw_tos"
5942}
5943
5944func (self *OxmIdNwTos) MarshalJSON() ([]byte, error) {
5945 if self.TypeLen == 0 {
5946 return []byte("\"\""), nil
5947 } else {
5948 return []byte("\"" + self.GetOXMName() + "\""), nil
5949 }
5950}
5951
5952type OxmIdNwTtl struct {
5953 *OxmId
5954}
5955
5956type IOxmIdNwTtl interface {
5957 IOxmId
5958}
5959
5960func (self *OxmIdNwTtl) Serialize(encoder *goloxi.Encoder) error {
5961 if err := self.OxmId.Serialize(encoder); err != nil {
5962 return err
5963 }
5964
5965 return nil
5966}
5967
5968func DecodeOxmIdNwTtl(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdNwTtl, error) {
5969 _oxmidnwttl := &OxmIdNwTtl{OxmId: parent}
5970 return _oxmidnwttl, nil
5971}
5972
5973func NewOxmIdNwTtl() *OxmIdNwTtl {
5974 obj := &OxmIdNwTtl{
5975 OxmId: NewOxmId(80385),
5976 }
5977 return obj
5978}
5979func (self *OxmIdNwTtl) GetOXMName() string {
5980 return "nw_ttl"
5981}
5982
5983func (self *OxmIdNwTtl) MarshalJSON() ([]byte, error) {
5984 if self.TypeLen == 0 {
5985 return []byte("\"\""), nil
5986 } else {
5987 return []byte("\"" + self.GetOXMName() + "\""), nil
5988 }
5989}
5990
5991type OxmIdPktMark struct {
5992 *OxmId
5993}
5994
5995type IOxmIdPktMark interface {
5996 IOxmId
5997}
5998
5999func (self *OxmIdPktMark) Serialize(encoder *goloxi.Encoder) error {
6000 if err := self.OxmId.Serialize(encoder); err != nil {
6001 return err
6002 }
6003
6004 return nil
6005}
6006
6007func DecodeOxmIdPktMark(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdPktMark, error) {
6008 _oxmidpktmark := &OxmIdPktMark{OxmId: parent}
6009 return _oxmidpktmark, nil
6010}
6011
6012func NewOxmIdPktMark() *OxmIdPktMark {
6013 obj := &OxmIdPktMark{
6014 OxmId: NewOxmId(82436),
6015 }
6016 return obj
6017}
6018func (self *OxmIdPktMark) GetOXMName() string {
6019 return "pkt_mark"
6020}
6021
6022func (self *OxmIdPktMark) MarshalJSON() ([]byte, error) {
6023 if self.TypeLen == 0 {
6024 return []byte("\"\""), nil
6025 } else {
6026 return []byte("\"" + self.GetOXMName() + "\""), nil
6027 }
6028}
6029
6030type OxmIdPktMarkMasked struct {
6031 *OxmId
6032}
6033
6034type IOxmIdPktMarkMasked interface {
6035 IOxmId
6036}
6037
6038func (self *OxmIdPktMarkMasked) Serialize(encoder *goloxi.Encoder) error {
6039 if err := self.OxmId.Serialize(encoder); err != nil {
6040 return err
6041 }
6042
6043 return nil
6044}
6045
6046func DecodeOxmIdPktMarkMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdPktMarkMasked, error) {
6047 _oxmidpktmarkmasked := &OxmIdPktMarkMasked{OxmId: parent}
6048 return _oxmidpktmarkmasked, nil
6049}
6050
6051func NewOxmIdPktMarkMasked() *OxmIdPktMarkMasked {
6052 obj := &OxmIdPktMarkMasked{
6053 OxmId: NewOxmId(82696),
6054 }
6055 return obj
6056}
6057func (self *OxmIdPktMarkMasked) GetOXMName() string {
6058 return "pkt_mark_masked"
6059}
6060
6061func (self *OxmIdPktMarkMasked) MarshalJSON() ([]byte, error) {
6062 if self.TypeLen == 0 {
6063 return []byte("\"\""), nil
6064 } else {
6065 return []byte("\"" + self.GetOXMName() + "\""), nil
6066 }
6067}
6068
6069type OxmIdRecircId struct {
6070 *OxmId
6071}
6072
6073type IOxmIdRecircId interface {
6074 IOxmId
6075}
6076
6077func (self *OxmIdRecircId) Serialize(encoder *goloxi.Encoder) error {
6078 if err := self.OxmId.Serialize(encoder); err != nil {
6079 return err
6080 }
6081
6082 return nil
6083}
6084
6085func DecodeOxmIdRecircId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdRecircId, error) {
6086 _oxmidrecircid := &OxmIdRecircId{OxmId: parent}
6087 return _oxmidrecircid, nil
6088}
6089
6090func NewOxmIdRecircId() *OxmIdRecircId {
6091 obj := &OxmIdRecircId{
6092 OxmId: NewOxmId(83972),
6093 }
6094 return obj
6095}
6096func (self *OxmIdRecircId) GetOXMName() string {
6097 return "recirc_id"
6098}
6099
6100func (self *OxmIdRecircId) MarshalJSON() ([]byte, error) {
6101 if self.TypeLen == 0 {
6102 return []byte("\"\""), nil
6103 } else {
6104 return []byte("\"" + self.GetOXMName() + "\""), nil
6105 }
6106}
6107
6108type OxmIdReg0 struct {
6109 *OxmId
6110}
6111
6112type IOxmIdReg0 interface {
6113 IOxmId
6114}
6115
6116func (self *OxmIdReg0) Serialize(encoder *goloxi.Encoder) error {
6117 if err := self.OxmId.Serialize(encoder); err != nil {
6118 return err
6119 }
6120
6121 return nil
6122}
6123
6124func DecodeOxmIdReg0(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg0, error) {
6125 _oxmidreg0 := &OxmIdReg0{OxmId: parent}
6126 return _oxmidreg0, nil
6127}
6128
6129func NewOxmIdReg0() *OxmIdReg0 {
6130 obj := &OxmIdReg0{
6131 OxmId: NewOxmId(65540),
6132 }
6133 return obj
6134}
6135func (self *OxmIdReg0) GetOXMName() string {
6136 return "reg0"
6137}
6138
6139func (self *OxmIdReg0) MarshalJSON() ([]byte, error) {
6140 if self.TypeLen == 0 {
6141 return []byte("\"\""), nil
6142 } else {
6143 return []byte("\"" + self.GetOXMName() + "\""), nil
6144 }
6145}
6146
6147type OxmIdReg0Masked struct {
6148 *OxmId
6149}
6150
6151type IOxmIdReg0Masked interface {
6152 IOxmId
6153}
6154
6155func (self *OxmIdReg0Masked) Serialize(encoder *goloxi.Encoder) error {
6156 if err := self.OxmId.Serialize(encoder); err != nil {
6157 return err
6158 }
6159
6160 return nil
6161}
6162
6163func DecodeOxmIdReg0Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg0Masked, error) {
6164 _oxmidreg0masked := &OxmIdReg0Masked{OxmId: parent}
6165 return _oxmidreg0masked, nil
6166}
6167
6168func NewOxmIdReg0Masked() *OxmIdReg0Masked {
6169 obj := &OxmIdReg0Masked{
6170 OxmId: NewOxmId(65800),
6171 }
6172 return obj
6173}
6174func (self *OxmIdReg0Masked) GetOXMName() string {
6175 return "reg0_masked"
6176}
6177
6178func (self *OxmIdReg0Masked) MarshalJSON() ([]byte, error) {
6179 if self.TypeLen == 0 {
6180 return []byte("\"\""), nil
6181 } else {
6182 return []byte("\"" + self.GetOXMName() + "\""), nil
6183 }
6184}
6185
6186type OxmIdReg1 struct {
6187 *OxmId
6188}
6189
6190type IOxmIdReg1 interface {
6191 IOxmId
6192}
6193
6194func (self *OxmIdReg1) Serialize(encoder *goloxi.Encoder) error {
6195 if err := self.OxmId.Serialize(encoder); err != nil {
6196 return err
6197 }
6198
6199 return nil
6200}
6201
6202func DecodeOxmIdReg1(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg1, error) {
6203 _oxmidreg1 := &OxmIdReg1{OxmId: parent}
6204 return _oxmidreg1, nil
6205}
6206
6207func NewOxmIdReg1() *OxmIdReg1 {
6208 obj := &OxmIdReg1{
6209 OxmId: NewOxmId(66052),
6210 }
6211 return obj
6212}
6213func (self *OxmIdReg1) GetOXMName() string {
6214 return "reg1"
6215}
6216
6217func (self *OxmIdReg1) MarshalJSON() ([]byte, error) {
6218 if self.TypeLen == 0 {
6219 return []byte("\"\""), nil
6220 } else {
6221 return []byte("\"" + self.GetOXMName() + "\""), nil
6222 }
6223}
6224
6225type OxmIdReg10 struct {
6226 *OxmId
6227}
6228
6229type IOxmIdReg10 interface {
6230 IOxmId
6231}
6232
6233func (self *OxmIdReg10) Serialize(encoder *goloxi.Encoder) error {
6234 if err := self.OxmId.Serialize(encoder); err != nil {
6235 return err
6236 }
6237
6238 return nil
6239}
6240
6241func DecodeOxmIdReg10(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg10, error) {
6242 _oxmidreg10 := &OxmIdReg10{OxmId: parent}
6243 return _oxmidreg10, nil
6244}
6245
6246func NewOxmIdReg10() *OxmIdReg10 {
6247 obj := &OxmIdReg10{
6248 OxmId: NewOxmId(70660),
6249 }
6250 return obj
6251}
6252func (self *OxmIdReg10) GetOXMName() string {
6253 return "reg10"
6254}
6255
6256func (self *OxmIdReg10) MarshalJSON() ([]byte, error) {
6257 if self.TypeLen == 0 {
6258 return []byte("\"\""), nil
6259 } else {
6260 return []byte("\"" + self.GetOXMName() + "\""), nil
6261 }
6262}
6263
6264type OxmIdReg10Masked struct {
6265 *OxmId
6266}
6267
6268type IOxmIdReg10Masked interface {
6269 IOxmId
6270}
6271
6272func (self *OxmIdReg10Masked) Serialize(encoder *goloxi.Encoder) error {
6273 if err := self.OxmId.Serialize(encoder); err != nil {
6274 return err
6275 }
6276
6277 return nil
6278}
6279
6280func DecodeOxmIdReg10Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg10Masked, error) {
6281 _oxmidreg10masked := &OxmIdReg10Masked{OxmId: parent}
6282 return _oxmidreg10masked, nil
6283}
6284
6285func NewOxmIdReg10Masked() *OxmIdReg10Masked {
6286 obj := &OxmIdReg10Masked{
6287 OxmId: NewOxmId(70920),
6288 }
6289 return obj
6290}
6291func (self *OxmIdReg10Masked) GetOXMName() string {
6292 return "reg10_masked"
6293}
6294
6295func (self *OxmIdReg10Masked) MarshalJSON() ([]byte, error) {
6296 if self.TypeLen == 0 {
6297 return []byte("\"\""), nil
6298 } else {
6299 return []byte("\"" + self.GetOXMName() + "\""), nil
6300 }
6301}
6302
6303type OxmIdReg11 struct {
6304 *OxmId
6305}
6306
6307type IOxmIdReg11 interface {
6308 IOxmId
6309}
6310
6311func (self *OxmIdReg11) Serialize(encoder *goloxi.Encoder) error {
6312 if err := self.OxmId.Serialize(encoder); err != nil {
6313 return err
6314 }
6315
6316 return nil
6317}
6318
6319func DecodeOxmIdReg11(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg11, error) {
6320 _oxmidreg11 := &OxmIdReg11{OxmId: parent}
6321 return _oxmidreg11, nil
6322}
6323
6324func NewOxmIdReg11() *OxmIdReg11 {
6325 obj := &OxmIdReg11{
6326 OxmId: NewOxmId(71172),
6327 }
6328 return obj
6329}
6330func (self *OxmIdReg11) GetOXMName() string {
6331 return "reg11"
6332}
6333
6334func (self *OxmIdReg11) MarshalJSON() ([]byte, error) {
6335 if self.TypeLen == 0 {
6336 return []byte("\"\""), nil
6337 } else {
6338 return []byte("\"" + self.GetOXMName() + "\""), nil
6339 }
6340}
6341
6342type OxmIdReg11Masked struct {
6343 *OxmId
6344}
6345
6346type IOxmIdReg11Masked interface {
6347 IOxmId
6348}
6349
6350func (self *OxmIdReg11Masked) Serialize(encoder *goloxi.Encoder) error {
6351 if err := self.OxmId.Serialize(encoder); err != nil {
6352 return err
6353 }
6354
6355 return nil
6356}
6357
6358func DecodeOxmIdReg11Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg11Masked, error) {
6359 _oxmidreg11masked := &OxmIdReg11Masked{OxmId: parent}
6360 return _oxmidreg11masked, nil
6361}
6362
6363func NewOxmIdReg11Masked() *OxmIdReg11Masked {
6364 obj := &OxmIdReg11Masked{
6365 OxmId: NewOxmId(71432),
6366 }
6367 return obj
6368}
6369func (self *OxmIdReg11Masked) GetOXMName() string {
6370 return "reg11_masked"
6371}
6372
6373func (self *OxmIdReg11Masked) MarshalJSON() ([]byte, error) {
6374 if self.TypeLen == 0 {
6375 return []byte("\"\""), nil
6376 } else {
6377 return []byte("\"" + self.GetOXMName() + "\""), nil
6378 }
6379}
6380
6381type OxmIdReg12 struct {
6382 *OxmId
6383}
6384
6385type IOxmIdReg12 interface {
6386 IOxmId
6387}
6388
6389func (self *OxmIdReg12) Serialize(encoder *goloxi.Encoder) error {
6390 if err := self.OxmId.Serialize(encoder); err != nil {
6391 return err
6392 }
6393
6394 return nil
6395}
6396
6397func DecodeOxmIdReg12(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg12, error) {
6398 _oxmidreg12 := &OxmIdReg12{OxmId: parent}
6399 return _oxmidreg12, nil
6400}
6401
6402func NewOxmIdReg12() *OxmIdReg12 {
6403 obj := &OxmIdReg12{
6404 OxmId: NewOxmId(71684),
6405 }
6406 return obj
6407}
6408func (self *OxmIdReg12) GetOXMName() string {
6409 return "reg12"
6410}
6411
6412func (self *OxmIdReg12) MarshalJSON() ([]byte, error) {
6413 if self.TypeLen == 0 {
6414 return []byte("\"\""), nil
6415 } else {
6416 return []byte("\"" + self.GetOXMName() + "\""), nil
6417 }
6418}
6419
6420type OxmIdReg12Masked struct {
6421 *OxmId
6422}
6423
6424type IOxmIdReg12Masked interface {
6425 IOxmId
6426}
6427
6428func (self *OxmIdReg12Masked) Serialize(encoder *goloxi.Encoder) error {
6429 if err := self.OxmId.Serialize(encoder); err != nil {
6430 return err
6431 }
6432
6433 return nil
6434}
6435
6436func DecodeOxmIdReg12Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg12Masked, error) {
6437 _oxmidreg12masked := &OxmIdReg12Masked{OxmId: parent}
6438 return _oxmidreg12masked, nil
6439}
6440
6441func NewOxmIdReg12Masked() *OxmIdReg12Masked {
6442 obj := &OxmIdReg12Masked{
6443 OxmId: NewOxmId(71944),
6444 }
6445 return obj
6446}
6447func (self *OxmIdReg12Masked) GetOXMName() string {
6448 return "reg12_masked"
6449}
6450
6451func (self *OxmIdReg12Masked) MarshalJSON() ([]byte, error) {
6452 if self.TypeLen == 0 {
6453 return []byte("\"\""), nil
6454 } else {
6455 return []byte("\"" + self.GetOXMName() + "\""), nil
6456 }
6457}
6458
6459type OxmIdReg13 struct {
6460 *OxmId
6461}
6462
6463type IOxmIdReg13 interface {
6464 IOxmId
6465}
6466
6467func (self *OxmIdReg13) Serialize(encoder *goloxi.Encoder) error {
6468 if err := self.OxmId.Serialize(encoder); err != nil {
6469 return err
6470 }
6471
6472 return nil
6473}
6474
6475func DecodeOxmIdReg13(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg13, error) {
6476 _oxmidreg13 := &OxmIdReg13{OxmId: parent}
6477 return _oxmidreg13, nil
6478}
6479
6480func NewOxmIdReg13() *OxmIdReg13 {
6481 obj := &OxmIdReg13{
6482 OxmId: NewOxmId(72196),
6483 }
6484 return obj
6485}
6486func (self *OxmIdReg13) GetOXMName() string {
6487 return "reg13"
6488}
6489
6490func (self *OxmIdReg13) MarshalJSON() ([]byte, error) {
6491 if self.TypeLen == 0 {
6492 return []byte("\"\""), nil
6493 } else {
6494 return []byte("\"" + self.GetOXMName() + "\""), nil
6495 }
6496}
6497
6498type OxmIdReg13Masked struct {
6499 *OxmId
6500}
6501
6502type IOxmIdReg13Masked interface {
6503 IOxmId
6504}
6505
6506func (self *OxmIdReg13Masked) Serialize(encoder *goloxi.Encoder) error {
6507 if err := self.OxmId.Serialize(encoder); err != nil {
6508 return err
6509 }
6510
6511 return nil
6512}
6513
6514func DecodeOxmIdReg13Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg13Masked, error) {
6515 _oxmidreg13masked := &OxmIdReg13Masked{OxmId: parent}
6516 return _oxmidreg13masked, nil
6517}
6518
6519func NewOxmIdReg13Masked() *OxmIdReg13Masked {
6520 obj := &OxmIdReg13Masked{
6521 OxmId: NewOxmId(72456),
6522 }
6523 return obj
6524}
6525func (self *OxmIdReg13Masked) GetOXMName() string {
6526 return "reg13_masked"
6527}
6528
6529func (self *OxmIdReg13Masked) MarshalJSON() ([]byte, error) {
6530 if self.TypeLen == 0 {
6531 return []byte("\"\""), nil
6532 } else {
6533 return []byte("\"" + self.GetOXMName() + "\""), nil
6534 }
6535}
6536
6537type OxmIdReg14 struct {
6538 *OxmId
6539}
6540
6541type IOxmIdReg14 interface {
6542 IOxmId
6543}
6544
6545func (self *OxmIdReg14) Serialize(encoder *goloxi.Encoder) error {
6546 if err := self.OxmId.Serialize(encoder); err != nil {
6547 return err
6548 }
6549
6550 return nil
6551}
6552
6553func DecodeOxmIdReg14(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg14, error) {
6554 _oxmidreg14 := &OxmIdReg14{OxmId: parent}
6555 return _oxmidreg14, nil
6556}
6557
6558func NewOxmIdReg14() *OxmIdReg14 {
6559 obj := &OxmIdReg14{
6560 OxmId: NewOxmId(72708),
6561 }
6562 return obj
6563}
6564func (self *OxmIdReg14) GetOXMName() string {
6565 return "reg14"
6566}
6567
6568func (self *OxmIdReg14) MarshalJSON() ([]byte, error) {
6569 if self.TypeLen == 0 {
6570 return []byte("\"\""), nil
6571 } else {
6572 return []byte("\"" + self.GetOXMName() + "\""), nil
6573 }
6574}
6575
6576type OxmIdReg14Masked struct {
6577 *OxmId
6578}
6579
6580type IOxmIdReg14Masked interface {
6581 IOxmId
6582}
6583
6584func (self *OxmIdReg14Masked) Serialize(encoder *goloxi.Encoder) error {
6585 if err := self.OxmId.Serialize(encoder); err != nil {
6586 return err
6587 }
6588
6589 return nil
6590}
6591
6592func DecodeOxmIdReg14Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg14Masked, error) {
6593 _oxmidreg14masked := &OxmIdReg14Masked{OxmId: parent}
6594 return _oxmidreg14masked, nil
6595}
6596
6597func NewOxmIdReg14Masked() *OxmIdReg14Masked {
6598 obj := &OxmIdReg14Masked{
6599 OxmId: NewOxmId(72968),
6600 }
6601 return obj
6602}
6603func (self *OxmIdReg14Masked) GetOXMName() string {
6604 return "reg14_masked"
6605}
6606
6607func (self *OxmIdReg14Masked) MarshalJSON() ([]byte, error) {
6608 if self.TypeLen == 0 {
6609 return []byte("\"\""), nil
6610 } else {
6611 return []byte("\"" + self.GetOXMName() + "\""), nil
6612 }
6613}
6614
6615type OxmIdReg15 struct {
6616 *OxmId
6617}
6618
6619type IOxmIdReg15 interface {
6620 IOxmId
6621}
6622
6623func (self *OxmIdReg15) Serialize(encoder *goloxi.Encoder) error {
6624 if err := self.OxmId.Serialize(encoder); err != nil {
6625 return err
6626 }
6627
6628 return nil
6629}
6630
6631func DecodeOxmIdReg15(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg15, error) {
6632 _oxmidreg15 := &OxmIdReg15{OxmId: parent}
6633 return _oxmidreg15, nil
6634}
6635
6636func NewOxmIdReg15() *OxmIdReg15 {
6637 obj := &OxmIdReg15{
6638 OxmId: NewOxmId(73220),
6639 }
6640 return obj
6641}
6642func (self *OxmIdReg15) GetOXMName() string {
6643 return "reg15"
6644}
6645
6646func (self *OxmIdReg15) MarshalJSON() ([]byte, error) {
6647 if self.TypeLen == 0 {
6648 return []byte("\"\""), nil
6649 } else {
6650 return []byte("\"" + self.GetOXMName() + "\""), nil
6651 }
6652}
6653
6654type OxmIdReg15Masked struct {
6655 *OxmId
6656}
6657
6658type IOxmIdReg15Masked interface {
6659 IOxmId
6660}
6661
6662func (self *OxmIdReg15Masked) Serialize(encoder *goloxi.Encoder) error {
6663 if err := self.OxmId.Serialize(encoder); err != nil {
6664 return err
6665 }
6666
6667 return nil
6668}
6669
6670func DecodeOxmIdReg15Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg15Masked, error) {
6671 _oxmidreg15masked := &OxmIdReg15Masked{OxmId: parent}
6672 return _oxmidreg15masked, nil
6673}
6674
6675func NewOxmIdReg15Masked() *OxmIdReg15Masked {
6676 obj := &OxmIdReg15Masked{
6677 OxmId: NewOxmId(73480),
6678 }
6679 return obj
6680}
6681func (self *OxmIdReg15Masked) GetOXMName() string {
6682 return "reg15_masked"
6683}
6684
6685func (self *OxmIdReg15Masked) MarshalJSON() ([]byte, error) {
6686 if self.TypeLen == 0 {
6687 return []byte("\"\""), nil
6688 } else {
6689 return []byte("\"" + self.GetOXMName() + "\""), nil
6690 }
6691}
6692
6693type OxmIdReg1Masked struct {
6694 *OxmId
6695}
6696
6697type IOxmIdReg1Masked interface {
6698 IOxmId
6699}
6700
6701func (self *OxmIdReg1Masked) Serialize(encoder *goloxi.Encoder) error {
6702 if err := self.OxmId.Serialize(encoder); err != nil {
6703 return err
6704 }
6705
6706 return nil
6707}
6708
6709func DecodeOxmIdReg1Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg1Masked, error) {
6710 _oxmidreg1masked := &OxmIdReg1Masked{OxmId: parent}
6711 return _oxmidreg1masked, nil
6712}
6713
6714func NewOxmIdReg1Masked() *OxmIdReg1Masked {
6715 obj := &OxmIdReg1Masked{
6716 OxmId: NewOxmId(66312),
6717 }
6718 return obj
6719}
6720func (self *OxmIdReg1Masked) GetOXMName() string {
6721 return "reg1_masked"
6722}
6723
6724func (self *OxmIdReg1Masked) MarshalJSON() ([]byte, error) {
6725 if self.TypeLen == 0 {
6726 return []byte("\"\""), nil
6727 } else {
6728 return []byte("\"" + self.GetOXMName() + "\""), nil
6729 }
6730}
6731
6732type OxmIdReg2 struct {
6733 *OxmId
6734}
6735
6736type IOxmIdReg2 interface {
6737 IOxmId
6738}
6739
6740func (self *OxmIdReg2) Serialize(encoder *goloxi.Encoder) error {
6741 if err := self.OxmId.Serialize(encoder); err != nil {
6742 return err
6743 }
6744
6745 return nil
6746}
6747
6748func DecodeOxmIdReg2(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg2, error) {
6749 _oxmidreg2 := &OxmIdReg2{OxmId: parent}
6750 return _oxmidreg2, nil
6751}
6752
6753func NewOxmIdReg2() *OxmIdReg2 {
6754 obj := &OxmIdReg2{
6755 OxmId: NewOxmId(66564),
6756 }
6757 return obj
6758}
6759func (self *OxmIdReg2) GetOXMName() string {
6760 return "reg2"
6761}
6762
6763func (self *OxmIdReg2) MarshalJSON() ([]byte, error) {
6764 if self.TypeLen == 0 {
6765 return []byte("\"\""), nil
6766 } else {
6767 return []byte("\"" + self.GetOXMName() + "\""), nil
6768 }
6769}
6770
6771type OxmIdReg2Masked struct {
6772 *OxmId
6773}
6774
6775type IOxmIdReg2Masked interface {
6776 IOxmId
6777}
6778
6779func (self *OxmIdReg2Masked) Serialize(encoder *goloxi.Encoder) error {
6780 if err := self.OxmId.Serialize(encoder); err != nil {
6781 return err
6782 }
6783
6784 return nil
6785}
6786
6787func DecodeOxmIdReg2Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg2Masked, error) {
6788 _oxmidreg2masked := &OxmIdReg2Masked{OxmId: parent}
6789 return _oxmidreg2masked, nil
6790}
6791
6792func NewOxmIdReg2Masked() *OxmIdReg2Masked {
6793 obj := &OxmIdReg2Masked{
6794 OxmId: NewOxmId(66824),
6795 }
6796 return obj
6797}
6798func (self *OxmIdReg2Masked) GetOXMName() string {
6799 return "reg2_masked"
6800}
6801
6802func (self *OxmIdReg2Masked) MarshalJSON() ([]byte, error) {
6803 if self.TypeLen == 0 {
6804 return []byte("\"\""), nil
6805 } else {
6806 return []byte("\"" + self.GetOXMName() + "\""), nil
6807 }
6808}
6809
6810type OxmIdReg3 struct {
6811 *OxmId
6812}
6813
6814type IOxmIdReg3 interface {
6815 IOxmId
6816}
6817
6818func (self *OxmIdReg3) Serialize(encoder *goloxi.Encoder) error {
6819 if err := self.OxmId.Serialize(encoder); err != nil {
6820 return err
6821 }
6822
6823 return nil
6824}
6825
6826func DecodeOxmIdReg3(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg3, error) {
6827 _oxmidreg3 := &OxmIdReg3{OxmId: parent}
6828 return _oxmidreg3, nil
6829}
6830
6831func NewOxmIdReg3() *OxmIdReg3 {
6832 obj := &OxmIdReg3{
6833 OxmId: NewOxmId(67076),
6834 }
6835 return obj
6836}
6837func (self *OxmIdReg3) GetOXMName() string {
6838 return "reg3"
6839}
6840
6841func (self *OxmIdReg3) MarshalJSON() ([]byte, error) {
6842 if self.TypeLen == 0 {
6843 return []byte("\"\""), nil
6844 } else {
6845 return []byte("\"" + self.GetOXMName() + "\""), nil
6846 }
6847}
6848
6849type OxmIdReg3Masked struct {
6850 *OxmId
6851}
6852
6853type IOxmIdReg3Masked interface {
6854 IOxmId
6855}
6856
6857func (self *OxmIdReg3Masked) Serialize(encoder *goloxi.Encoder) error {
6858 if err := self.OxmId.Serialize(encoder); err != nil {
6859 return err
6860 }
6861
6862 return nil
6863}
6864
6865func DecodeOxmIdReg3Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg3Masked, error) {
6866 _oxmidreg3masked := &OxmIdReg3Masked{OxmId: parent}
6867 return _oxmidreg3masked, nil
6868}
6869
6870func NewOxmIdReg3Masked() *OxmIdReg3Masked {
6871 obj := &OxmIdReg3Masked{
6872 OxmId: NewOxmId(67336),
6873 }
6874 return obj
6875}
6876func (self *OxmIdReg3Masked) GetOXMName() string {
6877 return "reg3_masked"
6878}
6879
6880func (self *OxmIdReg3Masked) MarshalJSON() ([]byte, error) {
6881 if self.TypeLen == 0 {
6882 return []byte("\"\""), nil
6883 } else {
6884 return []byte("\"" + self.GetOXMName() + "\""), nil
6885 }
6886}
6887
6888type OxmIdReg4 struct {
6889 *OxmId
6890}
6891
6892type IOxmIdReg4 interface {
6893 IOxmId
6894}
6895
6896func (self *OxmIdReg4) Serialize(encoder *goloxi.Encoder) error {
6897 if err := self.OxmId.Serialize(encoder); err != nil {
6898 return err
6899 }
6900
6901 return nil
6902}
6903
6904func DecodeOxmIdReg4(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg4, error) {
6905 _oxmidreg4 := &OxmIdReg4{OxmId: parent}
6906 return _oxmidreg4, nil
6907}
6908
6909func NewOxmIdReg4() *OxmIdReg4 {
6910 obj := &OxmIdReg4{
6911 OxmId: NewOxmId(67588),
6912 }
6913 return obj
6914}
6915func (self *OxmIdReg4) GetOXMName() string {
6916 return "reg4"
6917}
6918
6919func (self *OxmIdReg4) MarshalJSON() ([]byte, error) {
6920 if self.TypeLen == 0 {
6921 return []byte("\"\""), nil
6922 } else {
6923 return []byte("\"" + self.GetOXMName() + "\""), nil
6924 }
6925}
6926
6927type OxmIdReg4Masked struct {
6928 *OxmId
6929}
6930
6931type IOxmIdReg4Masked interface {
6932 IOxmId
6933}
6934
6935func (self *OxmIdReg4Masked) Serialize(encoder *goloxi.Encoder) error {
6936 if err := self.OxmId.Serialize(encoder); err != nil {
6937 return err
6938 }
6939
6940 return nil
6941}
6942
6943func DecodeOxmIdReg4Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg4Masked, error) {
6944 _oxmidreg4masked := &OxmIdReg4Masked{OxmId: parent}
6945 return _oxmidreg4masked, nil
6946}
6947
6948func NewOxmIdReg4Masked() *OxmIdReg4Masked {
6949 obj := &OxmIdReg4Masked{
6950 OxmId: NewOxmId(67848),
6951 }
6952 return obj
6953}
6954func (self *OxmIdReg4Masked) GetOXMName() string {
6955 return "reg4_masked"
6956}
6957
6958func (self *OxmIdReg4Masked) MarshalJSON() ([]byte, error) {
6959 if self.TypeLen == 0 {
6960 return []byte("\"\""), nil
6961 } else {
6962 return []byte("\"" + self.GetOXMName() + "\""), nil
6963 }
6964}
6965
6966type OxmIdReg5 struct {
6967 *OxmId
6968}
6969
6970type IOxmIdReg5 interface {
6971 IOxmId
6972}
6973
6974func (self *OxmIdReg5) Serialize(encoder *goloxi.Encoder) error {
6975 if err := self.OxmId.Serialize(encoder); err != nil {
6976 return err
6977 }
6978
6979 return nil
6980}
6981
6982func DecodeOxmIdReg5(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg5, error) {
6983 _oxmidreg5 := &OxmIdReg5{OxmId: parent}
6984 return _oxmidreg5, nil
6985}
6986
6987func NewOxmIdReg5() *OxmIdReg5 {
6988 obj := &OxmIdReg5{
6989 OxmId: NewOxmId(68100),
6990 }
6991 return obj
6992}
6993func (self *OxmIdReg5) GetOXMName() string {
6994 return "reg5"
6995}
6996
6997func (self *OxmIdReg5) MarshalJSON() ([]byte, error) {
6998 if self.TypeLen == 0 {
6999 return []byte("\"\""), nil
7000 } else {
7001 return []byte("\"" + self.GetOXMName() + "\""), nil
7002 }
7003}
7004
7005type OxmIdReg5Masked struct {
7006 *OxmId
7007}
7008
7009type IOxmIdReg5Masked interface {
7010 IOxmId
7011}
7012
7013func (self *OxmIdReg5Masked) Serialize(encoder *goloxi.Encoder) error {
7014 if err := self.OxmId.Serialize(encoder); err != nil {
7015 return err
7016 }
7017
7018 return nil
7019}
7020
7021func DecodeOxmIdReg5Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg5Masked, error) {
7022 _oxmidreg5masked := &OxmIdReg5Masked{OxmId: parent}
7023 return _oxmidreg5masked, nil
7024}
7025
7026func NewOxmIdReg5Masked() *OxmIdReg5Masked {
7027 obj := &OxmIdReg5Masked{
7028 OxmId: NewOxmId(68360),
7029 }
7030 return obj
7031}
7032func (self *OxmIdReg5Masked) GetOXMName() string {
7033 return "reg5_masked"
7034}
7035
7036func (self *OxmIdReg5Masked) MarshalJSON() ([]byte, error) {
7037 if self.TypeLen == 0 {
7038 return []byte("\"\""), nil
7039 } else {
7040 return []byte("\"" + self.GetOXMName() + "\""), nil
7041 }
7042}
7043
7044type OxmIdReg6 struct {
7045 *OxmId
7046}
7047
7048type IOxmIdReg6 interface {
7049 IOxmId
7050}
7051
7052func (self *OxmIdReg6) Serialize(encoder *goloxi.Encoder) error {
7053 if err := self.OxmId.Serialize(encoder); err != nil {
7054 return err
7055 }
7056
7057 return nil
7058}
7059
7060func DecodeOxmIdReg6(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg6, error) {
7061 _oxmidreg6 := &OxmIdReg6{OxmId: parent}
7062 return _oxmidreg6, nil
7063}
7064
7065func NewOxmIdReg6() *OxmIdReg6 {
7066 obj := &OxmIdReg6{
7067 OxmId: NewOxmId(68612),
7068 }
7069 return obj
7070}
7071func (self *OxmIdReg6) GetOXMName() string {
7072 return "reg6"
7073}
7074
7075func (self *OxmIdReg6) MarshalJSON() ([]byte, error) {
7076 if self.TypeLen == 0 {
7077 return []byte("\"\""), nil
7078 } else {
7079 return []byte("\"" + self.GetOXMName() + "\""), nil
7080 }
7081}
7082
7083type OxmIdReg6Masked struct {
7084 *OxmId
7085}
7086
7087type IOxmIdReg6Masked interface {
7088 IOxmId
7089}
7090
7091func (self *OxmIdReg6Masked) Serialize(encoder *goloxi.Encoder) error {
7092 if err := self.OxmId.Serialize(encoder); err != nil {
7093 return err
7094 }
7095
7096 return nil
7097}
7098
7099func DecodeOxmIdReg6Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg6Masked, error) {
7100 _oxmidreg6masked := &OxmIdReg6Masked{OxmId: parent}
7101 return _oxmidreg6masked, nil
7102}
7103
7104func NewOxmIdReg6Masked() *OxmIdReg6Masked {
7105 obj := &OxmIdReg6Masked{
7106 OxmId: NewOxmId(68872),
7107 }
7108 return obj
7109}
7110func (self *OxmIdReg6Masked) GetOXMName() string {
7111 return "reg6_masked"
7112}
7113
7114func (self *OxmIdReg6Masked) MarshalJSON() ([]byte, error) {
7115 if self.TypeLen == 0 {
7116 return []byte("\"\""), nil
7117 } else {
7118 return []byte("\"" + self.GetOXMName() + "\""), nil
7119 }
7120}
7121
7122type OxmIdReg7 struct {
7123 *OxmId
7124}
7125
7126type IOxmIdReg7 interface {
7127 IOxmId
7128}
7129
7130func (self *OxmIdReg7) Serialize(encoder *goloxi.Encoder) error {
7131 if err := self.OxmId.Serialize(encoder); err != nil {
7132 return err
7133 }
7134
7135 return nil
7136}
7137
7138func DecodeOxmIdReg7(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg7, error) {
7139 _oxmidreg7 := &OxmIdReg7{OxmId: parent}
7140 return _oxmidreg7, nil
7141}
7142
7143func NewOxmIdReg7() *OxmIdReg7 {
7144 obj := &OxmIdReg7{
7145 OxmId: NewOxmId(69124),
7146 }
7147 return obj
7148}
7149func (self *OxmIdReg7) GetOXMName() string {
7150 return "reg7"
7151}
7152
7153func (self *OxmIdReg7) MarshalJSON() ([]byte, error) {
7154 if self.TypeLen == 0 {
7155 return []byte("\"\""), nil
7156 } else {
7157 return []byte("\"" + self.GetOXMName() + "\""), nil
7158 }
7159}
7160
7161type OxmIdReg7Masked struct {
7162 *OxmId
7163}
7164
7165type IOxmIdReg7Masked interface {
7166 IOxmId
7167}
7168
7169func (self *OxmIdReg7Masked) Serialize(encoder *goloxi.Encoder) error {
7170 if err := self.OxmId.Serialize(encoder); err != nil {
7171 return err
7172 }
7173
7174 return nil
7175}
7176
7177func DecodeOxmIdReg7Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg7Masked, error) {
7178 _oxmidreg7masked := &OxmIdReg7Masked{OxmId: parent}
7179 return _oxmidreg7masked, nil
7180}
7181
7182func NewOxmIdReg7Masked() *OxmIdReg7Masked {
7183 obj := &OxmIdReg7Masked{
7184 OxmId: NewOxmId(69384),
7185 }
7186 return obj
7187}
7188func (self *OxmIdReg7Masked) GetOXMName() string {
7189 return "reg7_masked"
7190}
7191
7192func (self *OxmIdReg7Masked) MarshalJSON() ([]byte, error) {
7193 if self.TypeLen == 0 {
7194 return []byte("\"\""), nil
7195 } else {
7196 return []byte("\"" + self.GetOXMName() + "\""), nil
7197 }
7198}
7199
7200type OxmIdReg8 struct {
7201 *OxmId
7202}
7203
7204type IOxmIdReg8 interface {
7205 IOxmId
7206}
7207
7208func (self *OxmIdReg8) Serialize(encoder *goloxi.Encoder) error {
7209 if err := self.OxmId.Serialize(encoder); err != nil {
7210 return err
7211 }
7212
7213 return nil
7214}
7215
7216func DecodeOxmIdReg8(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg8, error) {
7217 _oxmidreg8 := &OxmIdReg8{OxmId: parent}
7218 return _oxmidreg8, nil
7219}
7220
7221func NewOxmIdReg8() *OxmIdReg8 {
7222 obj := &OxmIdReg8{
7223 OxmId: NewOxmId(69636),
7224 }
7225 return obj
7226}
7227func (self *OxmIdReg8) GetOXMName() string {
7228 return "reg8"
7229}
7230
7231func (self *OxmIdReg8) MarshalJSON() ([]byte, error) {
7232 if self.TypeLen == 0 {
7233 return []byte("\"\""), nil
7234 } else {
7235 return []byte("\"" + self.GetOXMName() + "\""), nil
7236 }
7237}
7238
7239type OxmIdReg8Masked struct {
7240 *OxmId
7241}
7242
7243type IOxmIdReg8Masked interface {
7244 IOxmId
7245}
7246
7247func (self *OxmIdReg8Masked) Serialize(encoder *goloxi.Encoder) error {
7248 if err := self.OxmId.Serialize(encoder); err != nil {
7249 return err
7250 }
7251
7252 return nil
7253}
7254
7255func DecodeOxmIdReg8Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg8Masked, error) {
7256 _oxmidreg8masked := &OxmIdReg8Masked{OxmId: parent}
7257 return _oxmidreg8masked, nil
7258}
7259
7260func NewOxmIdReg8Masked() *OxmIdReg8Masked {
7261 obj := &OxmIdReg8Masked{
7262 OxmId: NewOxmId(69896),
7263 }
7264 return obj
7265}
7266func (self *OxmIdReg8Masked) GetOXMName() string {
7267 return "reg8_masked"
7268}
7269
7270func (self *OxmIdReg8Masked) MarshalJSON() ([]byte, error) {
7271 if self.TypeLen == 0 {
7272 return []byte("\"\""), nil
7273 } else {
7274 return []byte("\"" + self.GetOXMName() + "\""), nil
7275 }
7276}
7277
7278type OxmIdReg9 struct {
7279 *OxmId
7280}
7281
7282type IOxmIdReg9 interface {
7283 IOxmId
7284}
7285
7286func (self *OxmIdReg9) Serialize(encoder *goloxi.Encoder) error {
7287 if err := self.OxmId.Serialize(encoder); err != nil {
7288 return err
7289 }
7290
7291 return nil
7292}
7293
7294func DecodeOxmIdReg9(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg9, error) {
7295 _oxmidreg9 := &OxmIdReg9{OxmId: parent}
7296 return _oxmidreg9, nil
7297}
7298
7299func NewOxmIdReg9() *OxmIdReg9 {
7300 obj := &OxmIdReg9{
7301 OxmId: NewOxmId(70148),
7302 }
7303 return obj
7304}
7305func (self *OxmIdReg9) GetOXMName() string {
7306 return "reg9"
7307}
7308
7309func (self *OxmIdReg9) MarshalJSON() ([]byte, error) {
7310 if self.TypeLen == 0 {
7311 return []byte("\"\""), nil
7312 } else {
7313 return []byte("\"" + self.GetOXMName() + "\""), nil
7314 }
7315}
7316
7317type OxmIdReg9Masked struct {
7318 *OxmId
7319}
7320
7321type IOxmIdReg9Masked interface {
7322 IOxmId
7323}
7324
7325func (self *OxmIdReg9Masked) Serialize(encoder *goloxi.Encoder) error {
7326 if err := self.OxmId.Serialize(encoder); err != nil {
7327 return err
7328 }
7329
7330 return nil
7331}
7332
7333func DecodeOxmIdReg9Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdReg9Masked, error) {
7334 _oxmidreg9masked := &OxmIdReg9Masked{OxmId: parent}
7335 return _oxmidreg9masked, nil
7336}
7337
7338func NewOxmIdReg9Masked() *OxmIdReg9Masked {
7339 obj := &OxmIdReg9Masked{
7340 OxmId: NewOxmId(70408),
7341 }
7342 return obj
7343}
7344func (self *OxmIdReg9Masked) GetOXMName() string {
7345 return "reg9_masked"
7346}
7347
7348func (self *OxmIdReg9Masked) MarshalJSON() ([]byte, error) {
7349 if self.TypeLen == 0 {
7350 return []byte("\"\""), nil
7351 } else {
7352 return []byte("\"" + self.GetOXMName() + "\""), nil
7353 }
7354}
7355
7356type OxmIdTcpDst struct {
7357 *OxmId
7358}
7359
7360type IOxmIdTcpDst interface {
7361 IOxmId
7362}
7363
7364func (self *OxmIdTcpDst) Serialize(encoder *goloxi.Encoder) error {
7365 if err := self.OxmId.Serialize(encoder); err != nil {
7366 return err
7367 }
7368
7369 return nil
7370}
7371
7372func DecodeOxmIdTcpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpDst, error) {
7373 _oxmidtcpdst := &OxmIdTcpDst{OxmId: parent}
7374 return _oxmidtcpdst, nil
7375}
7376
7377func NewOxmIdTcpDst() *OxmIdTcpDst {
7378 obj := &OxmIdTcpDst{
7379 OxmId: NewOxmId(5122),
7380 }
7381 return obj
7382}
7383func (self *OxmIdTcpDst) GetOXMName() string {
7384 return "tcp_dst"
7385}
7386
7387func (self *OxmIdTcpDst) MarshalJSON() ([]byte, error) {
7388 if self.TypeLen == 0 {
7389 return []byte("\"\""), nil
7390 } else {
7391 return []byte("\"" + self.GetOXMName() + "\""), nil
7392 }
7393}
7394
7395type OxmIdTcpDstMasked struct {
7396 *OxmId
7397}
7398
7399type IOxmIdTcpDstMasked interface {
7400 IOxmId
7401}
7402
7403func (self *OxmIdTcpDstMasked) Serialize(encoder *goloxi.Encoder) error {
7404 if err := self.OxmId.Serialize(encoder); err != nil {
7405 return err
7406 }
7407
7408 return nil
7409}
7410
7411func DecodeOxmIdTcpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpDstMasked, error) {
7412 _oxmidtcpdstmasked := &OxmIdTcpDstMasked{OxmId: parent}
7413 return _oxmidtcpdstmasked, nil
7414}
7415
7416func NewOxmIdTcpDstMasked() *OxmIdTcpDstMasked {
7417 obj := &OxmIdTcpDstMasked{
7418 OxmId: NewOxmId(5378),
7419 }
7420 return obj
7421}
7422func (self *OxmIdTcpDstMasked) GetOXMName() string {
7423 return "tcp_dst_masked"
7424}
7425
7426func (self *OxmIdTcpDstMasked) MarshalJSON() ([]byte, error) {
7427 if self.TypeLen == 0 {
7428 return []byte("\"\""), nil
7429 } else {
7430 return []byte("\"" + self.GetOXMName() + "\""), nil
7431 }
7432}
7433
7434type OxmIdTcpFlags struct {
7435 *OxmId
7436}
7437
7438type IOxmIdTcpFlags interface {
7439 IOxmId
7440}
7441
7442func (self *OxmIdTcpFlags) Serialize(encoder *goloxi.Encoder) error {
7443 if err := self.OxmId.Serialize(encoder); err != nil {
7444 return err
7445 }
7446
7447 return nil
7448}
7449
7450func DecodeOxmIdTcpFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpFlags, error) {
7451 _oxmidtcpflags := &OxmIdTcpFlags{OxmId: parent}
7452 return _oxmidtcpflags, nil
7453}
7454
7455func NewOxmIdTcpFlags() *OxmIdTcpFlags {
7456 obj := &OxmIdTcpFlags{
7457 OxmId: NewOxmId(82946),
7458 }
7459 return obj
7460}
7461func (self *OxmIdTcpFlags) GetOXMName() string {
7462 return "tcp_flags"
7463}
7464
7465func (self *OxmIdTcpFlags) MarshalJSON() ([]byte, error) {
7466 if self.TypeLen == 0 {
7467 return []byte("\"\""), nil
7468 } else {
7469 return []byte("\"" + self.GetOXMName() + "\""), nil
7470 }
7471}
7472
7473type OxmIdTcpFlagsMasked struct {
7474 *OxmId
7475}
7476
7477type IOxmIdTcpFlagsMasked interface {
7478 IOxmId
7479}
7480
7481func (self *OxmIdTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
7482 if err := self.OxmId.Serialize(encoder); err != nil {
7483 return err
7484 }
7485
7486 return nil
7487}
7488
7489func DecodeOxmIdTcpFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpFlagsMasked, error) {
7490 _oxmidtcpflagsmasked := &OxmIdTcpFlagsMasked{OxmId: parent}
7491 return _oxmidtcpflagsmasked, nil
7492}
7493
7494func NewOxmIdTcpFlagsMasked() *OxmIdTcpFlagsMasked {
7495 obj := &OxmIdTcpFlagsMasked{
7496 OxmId: NewOxmId(83204),
7497 }
7498 return obj
7499}
7500func (self *OxmIdTcpFlagsMasked) GetOXMName() string {
7501 return "tcp_flags_masked"
7502}
7503
7504func (self *OxmIdTcpFlagsMasked) MarshalJSON() ([]byte, error) {
7505 if self.TypeLen == 0 {
7506 return []byte("\"\""), nil
7507 } else {
7508 return []byte("\"" + self.GetOXMName() + "\""), nil
7509 }
7510}
7511
7512type OxmIdTcpSrc struct {
7513 *OxmId
7514}
7515
7516type IOxmIdTcpSrc interface {
7517 IOxmId
7518}
7519
7520func (self *OxmIdTcpSrc) Serialize(encoder *goloxi.Encoder) error {
7521 if err := self.OxmId.Serialize(encoder); err != nil {
7522 return err
7523 }
7524
7525 return nil
7526}
7527
7528func DecodeOxmIdTcpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpSrc, error) {
7529 _oxmidtcpsrc := &OxmIdTcpSrc{OxmId: parent}
7530 return _oxmidtcpsrc, nil
7531}
7532
7533func NewOxmIdTcpSrc() *OxmIdTcpSrc {
7534 obj := &OxmIdTcpSrc{
7535 OxmId: NewOxmId(4610),
7536 }
7537 return obj
7538}
7539func (self *OxmIdTcpSrc) GetOXMName() string {
7540 return "tcp_src"
7541}
7542
7543func (self *OxmIdTcpSrc) MarshalJSON() ([]byte, error) {
7544 if self.TypeLen == 0 {
7545 return []byte("\"\""), nil
7546 } else {
7547 return []byte("\"" + self.GetOXMName() + "\""), nil
7548 }
7549}
7550
7551type OxmIdTcpSrcMasked struct {
7552 *OxmId
7553}
7554
7555type IOxmIdTcpSrcMasked interface {
7556 IOxmId
7557}
7558
7559func (self *OxmIdTcpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
7560 if err := self.OxmId.Serialize(encoder); err != nil {
7561 return err
7562 }
7563
7564 return nil
7565}
7566
7567func DecodeOxmIdTcpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTcpSrcMasked, error) {
7568 _oxmidtcpsrcmasked := &OxmIdTcpSrcMasked{OxmId: parent}
7569 return _oxmidtcpsrcmasked, nil
7570}
7571
7572func NewOxmIdTcpSrcMasked() *OxmIdTcpSrcMasked {
7573 obj := &OxmIdTcpSrcMasked{
7574 OxmId: NewOxmId(4868),
7575 }
7576 return obj
7577}
7578func (self *OxmIdTcpSrcMasked) GetOXMName() string {
7579 return "tcp_src_masked"
7580}
7581
7582func (self *OxmIdTcpSrcMasked) MarshalJSON() ([]byte, error) {
7583 if self.TypeLen == 0 {
7584 return []byte("\"\""), nil
7585 } else {
7586 return []byte("\"" + self.GetOXMName() + "\""), nil
7587 }
7588}
7589
7590type OxmIdTunDst struct {
7591 *OxmId
7592}
7593
7594type IOxmIdTunDst interface {
7595 IOxmId
7596}
7597
7598func (self *OxmIdTunDst) Serialize(encoder *goloxi.Encoder) error {
7599 if err := self.OxmId.Serialize(encoder); err != nil {
7600 return err
7601 }
7602
7603 return nil
7604}
7605
7606func DecodeOxmIdTunDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunDst, error) {
7607 _oxmidtundst := &OxmIdTunDst{OxmId: parent}
7608 return _oxmidtundst, nil
7609}
7610
7611func NewOxmIdTunDst() *OxmIdTunDst {
7612 obj := &OxmIdTunDst{
7613 OxmId: NewOxmId(81924),
7614 }
7615 return obj
7616}
7617func (self *OxmIdTunDst) GetOXMName() string {
7618 return "tun_dst"
7619}
7620
7621func (self *OxmIdTunDst) MarshalJSON() ([]byte, error) {
7622 if self.TypeLen == 0 {
7623 return []byte("\"\""), nil
7624 } else {
7625 return []byte("\"" + self.GetOXMName() + "\""), nil
7626 }
7627}
7628
7629type OxmIdTunDstMasked struct {
7630 *OxmId
7631}
7632
7633type IOxmIdTunDstMasked interface {
7634 IOxmId
7635}
7636
7637func (self *OxmIdTunDstMasked) Serialize(encoder *goloxi.Encoder) error {
7638 if err := self.OxmId.Serialize(encoder); err != nil {
7639 return err
7640 }
7641
7642 return nil
7643}
7644
7645func DecodeOxmIdTunDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunDstMasked, error) {
7646 _oxmidtundstmasked := &OxmIdTunDstMasked{OxmId: parent}
7647 return _oxmidtundstmasked, nil
7648}
7649
7650func NewOxmIdTunDstMasked() *OxmIdTunDstMasked {
7651 obj := &OxmIdTunDstMasked{
7652 OxmId: NewOxmId(82184),
7653 }
7654 return obj
7655}
7656func (self *OxmIdTunDstMasked) GetOXMName() string {
7657 return "tun_dst_masked"
7658}
7659
7660func (self *OxmIdTunDstMasked) MarshalJSON() ([]byte, error) {
7661 if self.TypeLen == 0 {
7662 return []byte("\"\""), nil
7663 } else {
7664 return []byte("\"" + self.GetOXMName() + "\""), nil
7665 }
7666}
7667
7668type OxmIdTunFlags struct {
7669 *OxmId
7670}
7671
7672type IOxmIdTunFlags interface {
7673 IOxmId
7674}
7675
7676func (self *OxmIdTunFlags) Serialize(encoder *goloxi.Encoder) error {
7677 if err := self.OxmId.Serialize(encoder); err != nil {
7678 return err
7679 }
7680
7681 return nil
7682}
7683
7684func DecodeOxmIdTunFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunFlags, error) {
7685 _oxmidtunflags := &OxmIdTunFlags{OxmId: parent}
7686 return _oxmidtunflags, nil
7687}
7688
7689func NewOxmIdTunFlags() *OxmIdTunFlags {
7690 obj := &OxmIdTunFlags{
7691 OxmId: NewOxmId(118786),
7692 }
7693 return obj
7694}
7695func (self *OxmIdTunFlags) GetOXMName() string {
7696 return "tun_flags"
7697}
7698
7699func (self *OxmIdTunFlags) MarshalJSON() ([]byte, error) {
7700 if self.TypeLen == 0 {
7701 return []byte("\"\""), nil
7702 } else {
7703 return []byte("\"" + self.GetOXMName() + "\""), nil
7704 }
7705}
7706
7707type OxmIdTunFlagsMasked struct {
7708 *OxmId
7709}
7710
7711type IOxmIdTunFlagsMasked interface {
7712 IOxmId
7713}
7714
7715func (self *OxmIdTunFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
7716 if err := self.OxmId.Serialize(encoder); err != nil {
7717 return err
7718 }
7719
7720 return nil
7721}
7722
7723func DecodeOxmIdTunFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunFlagsMasked, error) {
7724 _oxmidtunflagsmasked := &OxmIdTunFlagsMasked{OxmId: parent}
7725 return _oxmidtunflagsmasked, nil
7726}
7727
7728func NewOxmIdTunFlagsMasked() *OxmIdTunFlagsMasked {
7729 obj := &OxmIdTunFlagsMasked{
7730 OxmId: NewOxmId(119044),
7731 }
7732 return obj
7733}
7734func (self *OxmIdTunFlagsMasked) GetOXMName() string {
7735 return "tun_flags_masked"
7736}
7737
7738func (self *OxmIdTunFlagsMasked) MarshalJSON() ([]byte, error) {
7739 if self.TypeLen == 0 {
7740 return []byte("\"\""), nil
7741 } else {
7742 return []byte("\"" + self.GetOXMName() + "\""), nil
7743 }
7744}
7745
7746type OxmIdTunGbpFlags struct {
7747 *OxmId
7748}
7749
7750type IOxmIdTunGbpFlags interface {
7751 IOxmId
7752}
7753
7754func (self *OxmIdTunGbpFlags) Serialize(encoder *goloxi.Encoder) error {
7755 if err := self.OxmId.Serialize(encoder); err != nil {
7756 return err
7757 }
7758
7759 return nil
7760}
7761
7762func DecodeOxmIdTunGbpFlags(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpFlags, error) {
7763 _oxmidtungbpflags := &OxmIdTunGbpFlags{OxmId: parent}
7764 return _oxmidtungbpflags, nil
7765}
7766
7767func NewOxmIdTunGbpFlags() *OxmIdTunGbpFlags {
7768 obj := &OxmIdTunGbpFlags{
7769 OxmId: NewOxmId(85505),
7770 }
7771 return obj
7772}
7773func (self *OxmIdTunGbpFlags) GetOXMName() string {
7774 return "tun_gbp_flags"
7775}
7776
7777func (self *OxmIdTunGbpFlags) MarshalJSON() ([]byte, error) {
7778 if self.TypeLen == 0 {
7779 return []byte("\"\""), nil
7780 } else {
7781 return []byte("\"" + self.GetOXMName() + "\""), nil
7782 }
7783}
7784
7785type OxmIdTunGbpFlagsMasked struct {
7786 *OxmId
7787}
7788
7789type IOxmIdTunGbpFlagsMasked interface {
7790 IOxmId
7791}
7792
7793func (self *OxmIdTunGbpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
7794 if err := self.OxmId.Serialize(encoder); err != nil {
7795 return err
7796 }
7797
7798 return nil
7799}
7800
7801func DecodeOxmIdTunGbpFlagsMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpFlagsMasked, error) {
7802 _oxmidtungbpflagsmasked := &OxmIdTunGbpFlagsMasked{OxmId: parent}
7803 return _oxmidtungbpflagsmasked, nil
7804}
7805
7806func NewOxmIdTunGbpFlagsMasked() *OxmIdTunGbpFlagsMasked {
7807 obj := &OxmIdTunGbpFlagsMasked{
7808 OxmId: NewOxmId(85762),
7809 }
7810 return obj
7811}
7812func (self *OxmIdTunGbpFlagsMasked) GetOXMName() string {
7813 return "tun_gbp_flags_masked"
7814}
7815
7816func (self *OxmIdTunGbpFlagsMasked) MarshalJSON() ([]byte, error) {
7817 if self.TypeLen == 0 {
7818 return []byte("\"\""), nil
7819 } else {
7820 return []byte("\"" + self.GetOXMName() + "\""), nil
7821 }
7822}
7823
7824type OxmIdTunGbpId struct {
7825 *OxmId
7826}
7827
7828type IOxmIdTunGbpId interface {
7829 IOxmId
7830}
7831
7832func (self *OxmIdTunGbpId) Serialize(encoder *goloxi.Encoder) error {
7833 if err := self.OxmId.Serialize(encoder); err != nil {
7834 return err
7835 }
7836
7837 return nil
7838}
7839
7840func DecodeOxmIdTunGbpId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpId, error) {
7841 _oxmidtungbpid := &OxmIdTunGbpId{OxmId: parent}
7842 return _oxmidtungbpid, nil
7843}
7844
7845func NewOxmIdTunGbpId() *OxmIdTunGbpId {
7846 obj := &OxmIdTunGbpId{
7847 OxmId: NewOxmId(84994),
7848 }
7849 return obj
7850}
7851func (self *OxmIdTunGbpId) GetOXMName() string {
7852 return "tun_gbp_id"
7853}
7854
7855func (self *OxmIdTunGbpId) MarshalJSON() ([]byte, error) {
7856 if self.TypeLen == 0 {
7857 return []byte("\"\""), nil
7858 } else {
7859 return []byte("\"" + self.GetOXMName() + "\""), nil
7860 }
7861}
7862
7863type OxmIdTunGbpIdMasked struct {
7864 *OxmId
7865}
7866
7867type IOxmIdTunGbpIdMasked interface {
7868 IOxmId
7869}
7870
7871func (self *OxmIdTunGbpIdMasked) Serialize(encoder *goloxi.Encoder) error {
7872 if err := self.OxmId.Serialize(encoder); err != nil {
7873 return err
7874 }
7875
7876 return nil
7877}
7878
7879func DecodeOxmIdTunGbpIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunGbpIdMasked, error) {
7880 _oxmidtungbpidmasked := &OxmIdTunGbpIdMasked{OxmId: parent}
7881 return _oxmidtungbpidmasked, nil
7882}
7883
7884func NewOxmIdTunGbpIdMasked() *OxmIdTunGbpIdMasked {
7885 obj := &OxmIdTunGbpIdMasked{
7886 OxmId: NewOxmId(85252),
7887 }
7888 return obj
7889}
7890func (self *OxmIdTunGbpIdMasked) GetOXMName() string {
7891 return "tun_gbp_id_masked"
7892}
7893
7894func (self *OxmIdTunGbpIdMasked) MarshalJSON() ([]byte, error) {
7895 if self.TypeLen == 0 {
7896 return []byte("\"\""), nil
7897 } else {
7898 return []byte("\"" + self.GetOXMName() + "\""), nil
7899 }
7900}
7901
7902type OxmIdTunId struct {
7903 *OxmId
7904}
7905
7906type IOxmIdTunId interface {
7907 IOxmId
7908}
7909
7910func (self *OxmIdTunId) Serialize(encoder *goloxi.Encoder) error {
7911 if err := self.OxmId.Serialize(encoder); err != nil {
7912 return err
7913 }
7914
7915 return nil
7916}
7917
7918func DecodeOxmIdTunId(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunId, error) {
7919 _oxmidtunid := &OxmIdTunId{OxmId: parent}
7920 return _oxmidtunid, nil
7921}
7922
7923func NewOxmIdTunId() *OxmIdTunId {
7924 obj := &OxmIdTunId{
7925 OxmId: NewOxmId(73736),
7926 }
7927 return obj
7928}
7929func (self *OxmIdTunId) GetOXMName() string {
7930 return "tun_id"
7931}
7932
7933func (self *OxmIdTunId) MarshalJSON() ([]byte, error) {
7934 if self.TypeLen == 0 {
7935 return []byte("\"\""), nil
7936 } else {
7937 return []byte("\"" + self.GetOXMName() + "\""), nil
7938 }
7939}
7940
7941type OxmIdTunIdMasked struct {
7942 *OxmId
7943}
7944
7945type IOxmIdTunIdMasked interface {
7946 IOxmId
7947}
7948
7949func (self *OxmIdTunIdMasked) Serialize(encoder *goloxi.Encoder) error {
7950 if err := self.OxmId.Serialize(encoder); err != nil {
7951 return err
7952 }
7953
7954 return nil
7955}
7956
7957func DecodeOxmIdTunIdMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIdMasked, error) {
7958 _oxmidtunidmasked := &OxmIdTunIdMasked{OxmId: parent}
7959 return _oxmidtunidmasked, nil
7960}
7961
7962func NewOxmIdTunIdMasked() *OxmIdTunIdMasked {
7963 obj := &OxmIdTunIdMasked{
7964 OxmId: NewOxmId(74000),
7965 }
7966 return obj
7967}
7968func (self *OxmIdTunIdMasked) GetOXMName() string {
7969 return "tun_id_masked"
7970}
7971
7972func (self *OxmIdTunIdMasked) MarshalJSON() ([]byte, error) {
7973 if self.TypeLen == 0 {
7974 return []byte("\"\""), nil
7975 } else {
7976 return []byte("\"" + self.GetOXMName() + "\""), nil
7977 }
7978}
7979
7980type OxmIdTunIpv6Dst struct {
7981 *OxmId
7982}
7983
7984type IOxmIdTunIpv6Dst interface {
7985 IOxmId
7986}
7987
7988func (self *OxmIdTunIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
7989 if err := self.OxmId.Serialize(encoder); err != nil {
7990 return err
7991 }
7992
7993 return nil
7994}
7995
7996func DecodeOxmIdTunIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6Dst, error) {
7997 _oxmidtunipv6dst := &OxmIdTunIpv6Dst{OxmId: parent}
7998 return _oxmidtunipv6dst, nil
7999}
8000
8001func NewOxmIdTunIpv6Dst() *OxmIdTunIpv6Dst {
8002 obj := &OxmIdTunIpv6Dst{
8003 OxmId: NewOxmId(121872),
8004 }
8005 return obj
8006}
8007func (self *OxmIdTunIpv6Dst) GetOXMName() string {
8008 return "tun_ipv6_dst"
8009}
8010
8011func (self *OxmIdTunIpv6Dst) MarshalJSON() ([]byte, error) {
8012 if self.TypeLen == 0 {
8013 return []byte("\"\""), nil
8014 } else {
8015 return []byte("\"" + self.GetOXMName() + "\""), nil
8016 }
8017}
8018
8019type OxmIdTunIpv6DstMasked struct {
8020 *OxmId
8021}
8022
8023type IOxmIdTunIpv6DstMasked interface {
8024 IOxmId
8025}
8026
8027func (self *OxmIdTunIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
8028 if err := self.OxmId.Serialize(encoder); err != nil {
8029 return err
8030 }
8031
8032 return nil
8033}
8034
8035func DecodeOxmIdTunIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6DstMasked, error) {
8036 _oxmidtunipv6dstmasked := &OxmIdTunIpv6DstMasked{OxmId: parent}
8037 return _oxmidtunipv6dstmasked, nil
8038}
8039
8040func NewOxmIdTunIpv6DstMasked() *OxmIdTunIpv6DstMasked {
8041 obj := &OxmIdTunIpv6DstMasked{
8042 OxmId: NewOxmId(122144),
8043 }
8044 return obj
8045}
8046func (self *OxmIdTunIpv6DstMasked) GetOXMName() string {
8047 return "tun_ipv6_dst_masked"
8048}
8049
8050func (self *OxmIdTunIpv6DstMasked) MarshalJSON() ([]byte, error) {
8051 if self.TypeLen == 0 {
8052 return []byte("\"\""), nil
8053 } else {
8054 return []byte("\"" + self.GetOXMName() + "\""), nil
8055 }
8056}
8057
8058type OxmIdTunIpv6Src struct {
8059 *OxmId
8060}
8061
8062type IOxmIdTunIpv6Src interface {
8063 IOxmId
8064}
8065
8066func (self *OxmIdTunIpv6Src) Serialize(encoder *goloxi.Encoder) error {
8067 if err := self.OxmId.Serialize(encoder); err != nil {
8068 return err
8069 }
8070
8071 return nil
8072}
8073
8074func DecodeOxmIdTunIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6Src, error) {
8075 _oxmidtunipv6src := &OxmIdTunIpv6Src{OxmId: parent}
8076 return _oxmidtunipv6src, nil
8077}
8078
8079func NewOxmIdTunIpv6Src() *OxmIdTunIpv6Src {
8080 obj := &OxmIdTunIpv6Src{
8081 OxmId: NewOxmId(121360),
8082 }
8083 return obj
8084}
8085func (self *OxmIdTunIpv6Src) GetOXMName() string {
8086 return "tun_ipv6_src"
8087}
8088
8089func (self *OxmIdTunIpv6Src) MarshalJSON() ([]byte, error) {
8090 if self.TypeLen == 0 {
8091 return []byte("\"\""), nil
8092 } else {
8093 return []byte("\"" + self.GetOXMName() + "\""), nil
8094 }
8095}
8096
8097type OxmIdTunIpv6SrcMasked struct {
8098 *OxmId
8099}
8100
8101type IOxmIdTunIpv6SrcMasked interface {
8102 IOxmId
8103}
8104
8105func (self *OxmIdTunIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
8106 if err := self.OxmId.Serialize(encoder); err != nil {
8107 return err
8108 }
8109
8110 return nil
8111}
8112
8113func DecodeOxmIdTunIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunIpv6SrcMasked, error) {
8114 _oxmidtunipv6srcmasked := &OxmIdTunIpv6SrcMasked{OxmId: parent}
8115 return _oxmidtunipv6srcmasked, nil
8116}
8117
8118func NewOxmIdTunIpv6SrcMasked() *OxmIdTunIpv6SrcMasked {
8119 obj := &OxmIdTunIpv6SrcMasked{
8120 OxmId: NewOxmId(121632),
8121 }
8122 return obj
8123}
8124func (self *OxmIdTunIpv6SrcMasked) GetOXMName() string {
8125 return "tun_ipv6_src_masked"
8126}
8127
8128func (self *OxmIdTunIpv6SrcMasked) MarshalJSON() ([]byte, error) {
8129 if self.TypeLen == 0 {
8130 return []byte("\"\""), nil
8131 } else {
8132 return []byte("\"" + self.GetOXMName() + "\""), nil
8133 }
8134}
8135
8136type OxmIdTunMetadata0 struct {
8137 *OxmId
8138}
8139
8140type IOxmIdTunMetadata0 interface {
8141 IOxmId
8142}
8143
8144func (self *OxmIdTunMetadata0) Serialize(encoder *goloxi.Encoder) error {
8145 if err := self.OxmId.Serialize(encoder); err != nil {
8146 return err
8147 }
8148
8149 return nil
8150}
8151
8152func DecodeOxmIdTunMetadata0(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata0, error) {
8153 _oxmidtunmetadata0 := &OxmIdTunMetadata0{OxmId: parent}
8154 return _oxmidtunmetadata0, nil
8155}
8156
8157func NewOxmIdTunMetadata0() *OxmIdTunMetadata0 {
8158 obj := &OxmIdTunMetadata0{
8159 OxmId: NewOxmId(86140),
8160 }
8161 return obj
8162}
8163func (self *OxmIdTunMetadata0) GetOXMName() string {
8164 return "tun_metadata0"
8165}
8166
8167func (self *OxmIdTunMetadata0) MarshalJSON() ([]byte, error) {
8168 if self.TypeLen == 0 {
8169 return []byte("\"\""), nil
8170 } else {
8171 return []byte("\"" + self.GetOXMName() + "\""), nil
8172 }
8173}
8174
8175type OxmIdTunMetadata0Masked struct {
8176 *OxmId
8177}
8178
8179type IOxmIdTunMetadata0Masked interface {
8180 IOxmId
8181}
8182
8183func (self *OxmIdTunMetadata0Masked) Serialize(encoder *goloxi.Encoder) error {
8184 if err := self.OxmId.Serialize(encoder); err != nil {
8185 return err
8186 }
8187
8188 return nil
8189}
8190
8191func DecodeOxmIdTunMetadata0Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata0Masked, error) {
8192 _oxmidtunmetadata0masked := &OxmIdTunMetadata0Masked{OxmId: parent}
8193 return _oxmidtunmetadata0masked, nil
8194}
8195
8196func NewOxmIdTunMetadata0Masked() *OxmIdTunMetadata0Masked {
8197 obj := &OxmIdTunMetadata0Masked{
8198 OxmId: NewOxmId(86520),
8199 }
8200 return obj
8201}
8202func (self *OxmIdTunMetadata0Masked) GetOXMName() string {
8203 return "tun_metadata0_masked"
8204}
8205
8206func (self *OxmIdTunMetadata0Masked) MarshalJSON() ([]byte, error) {
8207 if self.TypeLen == 0 {
8208 return []byte("\"\""), nil
8209 } else {
8210 return []byte("\"" + self.GetOXMName() + "\""), nil
8211 }
8212}
8213
8214type OxmIdTunMetadata1 struct {
8215 *OxmId
8216}
8217
8218type IOxmIdTunMetadata1 interface {
8219 IOxmId
8220}
8221
8222func (self *OxmIdTunMetadata1) Serialize(encoder *goloxi.Encoder) error {
8223 if err := self.OxmId.Serialize(encoder); err != nil {
8224 return err
8225 }
8226
8227 return nil
8228}
8229
8230func DecodeOxmIdTunMetadata1(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata1, error) {
8231 _oxmidtunmetadata1 := &OxmIdTunMetadata1{OxmId: parent}
8232 return _oxmidtunmetadata1, nil
8233}
8234
8235func NewOxmIdTunMetadata1() *OxmIdTunMetadata1 {
8236 obj := &OxmIdTunMetadata1{
8237 OxmId: NewOxmId(86652),
8238 }
8239 return obj
8240}
8241func (self *OxmIdTunMetadata1) GetOXMName() string {
8242 return "tun_metadata1"
8243}
8244
8245func (self *OxmIdTunMetadata1) MarshalJSON() ([]byte, error) {
8246 if self.TypeLen == 0 {
8247 return []byte("\"\""), nil
8248 } else {
8249 return []byte("\"" + self.GetOXMName() + "\""), nil
8250 }
8251}
8252
8253type OxmIdTunMetadata10 struct {
8254 *OxmId
8255}
8256
8257type IOxmIdTunMetadata10 interface {
8258 IOxmId
8259}
8260
8261func (self *OxmIdTunMetadata10) Serialize(encoder *goloxi.Encoder) error {
8262 if err := self.OxmId.Serialize(encoder); err != nil {
8263 return err
8264 }
8265
8266 return nil
8267}
8268
8269func DecodeOxmIdTunMetadata10(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata10, error) {
8270 _oxmidtunmetadata10 := &OxmIdTunMetadata10{OxmId: parent}
8271 return _oxmidtunmetadata10, nil
8272}
8273
8274func NewOxmIdTunMetadata10() *OxmIdTunMetadata10 {
8275 obj := &OxmIdTunMetadata10{
8276 OxmId: NewOxmId(91260),
8277 }
8278 return obj
8279}
8280func (self *OxmIdTunMetadata10) GetOXMName() string {
8281 return "tun_metadata10"
8282}
8283
8284func (self *OxmIdTunMetadata10) MarshalJSON() ([]byte, error) {
8285 if self.TypeLen == 0 {
8286 return []byte("\"\""), nil
8287 } else {
8288 return []byte("\"" + self.GetOXMName() + "\""), nil
8289 }
8290}
8291
8292type OxmIdTunMetadata10Masked struct {
8293 *OxmId
8294}
8295
8296type IOxmIdTunMetadata10Masked interface {
8297 IOxmId
8298}
8299
8300func (self *OxmIdTunMetadata10Masked) Serialize(encoder *goloxi.Encoder) error {
8301 if err := self.OxmId.Serialize(encoder); err != nil {
8302 return err
8303 }
8304
8305 return nil
8306}
8307
8308func DecodeOxmIdTunMetadata10Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata10Masked, error) {
8309 _oxmidtunmetadata10masked := &OxmIdTunMetadata10Masked{OxmId: parent}
8310 return _oxmidtunmetadata10masked, nil
8311}
8312
8313func NewOxmIdTunMetadata10Masked() *OxmIdTunMetadata10Masked {
8314 obj := &OxmIdTunMetadata10Masked{
8315 OxmId: NewOxmId(91640),
8316 }
8317 return obj
8318}
8319func (self *OxmIdTunMetadata10Masked) GetOXMName() string {
8320 return "tun_metadata10_masked"
8321}
8322
8323func (self *OxmIdTunMetadata10Masked) MarshalJSON() ([]byte, error) {
8324 if self.TypeLen == 0 {
8325 return []byte("\"\""), nil
8326 } else {
8327 return []byte("\"" + self.GetOXMName() + "\""), nil
8328 }
8329}
8330
8331type OxmIdTunMetadata11 struct {
8332 *OxmId
8333}
8334
8335type IOxmIdTunMetadata11 interface {
8336 IOxmId
8337}
8338
8339func (self *OxmIdTunMetadata11) Serialize(encoder *goloxi.Encoder) error {
8340 if err := self.OxmId.Serialize(encoder); err != nil {
8341 return err
8342 }
8343
8344 return nil
8345}
8346
8347func DecodeOxmIdTunMetadata11(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata11, error) {
8348 _oxmidtunmetadata11 := &OxmIdTunMetadata11{OxmId: parent}
8349 return _oxmidtunmetadata11, nil
8350}
8351
8352func NewOxmIdTunMetadata11() *OxmIdTunMetadata11 {
8353 obj := &OxmIdTunMetadata11{
8354 OxmId: NewOxmId(91772),
8355 }
8356 return obj
8357}
8358func (self *OxmIdTunMetadata11) GetOXMName() string {
8359 return "tun_metadata11"
8360}
8361
8362func (self *OxmIdTunMetadata11) MarshalJSON() ([]byte, error) {
8363 if self.TypeLen == 0 {
8364 return []byte("\"\""), nil
8365 } else {
8366 return []byte("\"" + self.GetOXMName() + "\""), nil
8367 }
8368}
8369
8370type OxmIdTunMetadata11Masked struct {
8371 *OxmId
8372}
8373
8374type IOxmIdTunMetadata11Masked interface {
8375 IOxmId
8376}
8377
8378func (self *OxmIdTunMetadata11Masked) Serialize(encoder *goloxi.Encoder) error {
8379 if err := self.OxmId.Serialize(encoder); err != nil {
8380 return err
8381 }
8382
8383 return nil
8384}
8385
8386func DecodeOxmIdTunMetadata11Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata11Masked, error) {
8387 _oxmidtunmetadata11masked := &OxmIdTunMetadata11Masked{OxmId: parent}
8388 return _oxmidtunmetadata11masked, nil
8389}
8390
8391func NewOxmIdTunMetadata11Masked() *OxmIdTunMetadata11Masked {
8392 obj := &OxmIdTunMetadata11Masked{
8393 OxmId: NewOxmId(92152),
8394 }
8395 return obj
8396}
8397func (self *OxmIdTunMetadata11Masked) GetOXMName() string {
8398 return "tun_metadata11_masked"
8399}
8400
8401func (self *OxmIdTunMetadata11Masked) MarshalJSON() ([]byte, error) {
8402 if self.TypeLen == 0 {
8403 return []byte("\"\""), nil
8404 } else {
8405 return []byte("\"" + self.GetOXMName() + "\""), nil
8406 }
8407}
8408
8409type OxmIdTunMetadata12 struct {
8410 *OxmId
8411}
8412
8413type IOxmIdTunMetadata12 interface {
8414 IOxmId
8415}
8416
8417func (self *OxmIdTunMetadata12) Serialize(encoder *goloxi.Encoder) error {
8418 if err := self.OxmId.Serialize(encoder); err != nil {
8419 return err
8420 }
8421
8422 return nil
8423}
8424
8425func DecodeOxmIdTunMetadata12(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata12, error) {
8426 _oxmidtunmetadata12 := &OxmIdTunMetadata12{OxmId: parent}
8427 return _oxmidtunmetadata12, nil
8428}
8429
8430func NewOxmIdTunMetadata12() *OxmIdTunMetadata12 {
8431 obj := &OxmIdTunMetadata12{
8432 OxmId: NewOxmId(92284),
8433 }
8434 return obj
8435}
8436func (self *OxmIdTunMetadata12) GetOXMName() string {
8437 return "tun_metadata12"
8438}
8439
8440func (self *OxmIdTunMetadata12) MarshalJSON() ([]byte, error) {
8441 if self.TypeLen == 0 {
8442 return []byte("\"\""), nil
8443 } else {
8444 return []byte("\"" + self.GetOXMName() + "\""), nil
8445 }
8446}
8447
8448type OxmIdTunMetadata12Masked struct {
8449 *OxmId
8450}
8451
8452type IOxmIdTunMetadata12Masked interface {
8453 IOxmId
8454}
8455
8456func (self *OxmIdTunMetadata12Masked) Serialize(encoder *goloxi.Encoder) error {
8457 if err := self.OxmId.Serialize(encoder); err != nil {
8458 return err
8459 }
8460
8461 return nil
8462}
8463
8464func DecodeOxmIdTunMetadata12Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata12Masked, error) {
8465 _oxmidtunmetadata12masked := &OxmIdTunMetadata12Masked{OxmId: parent}
8466 return _oxmidtunmetadata12masked, nil
8467}
8468
8469func NewOxmIdTunMetadata12Masked() *OxmIdTunMetadata12Masked {
8470 obj := &OxmIdTunMetadata12Masked{
8471 OxmId: NewOxmId(92664),
8472 }
8473 return obj
8474}
8475func (self *OxmIdTunMetadata12Masked) GetOXMName() string {
8476 return "tun_metadata12_masked"
8477}
8478
8479func (self *OxmIdTunMetadata12Masked) MarshalJSON() ([]byte, error) {
8480 if self.TypeLen == 0 {
8481 return []byte("\"\""), nil
8482 } else {
8483 return []byte("\"" + self.GetOXMName() + "\""), nil
8484 }
8485}
8486
8487type OxmIdTunMetadata13 struct {
8488 *OxmId
8489}
8490
8491type IOxmIdTunMetadata13 interface {
8492 IOxmId
8493}
8494
8495func (self *OxmIdTunMetadata13) Serialize(encoder *goloxi.Encoder) error {
8496 if err := self.OxmId.Serialize(encoder); err != nil {
8497 return err
8498 }
8499
8500 return nil
8501}
8502
8503func DecodeOxmIdTunMetadata13(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata13, error) {
8504 _oxmidtunmetadata13 := &OxmIdTunMetadata13{OxmId: parent}
8505 return _oxmidtunmetadata13, nil
8506}
8507
8508func NewOxmIdTunMetadata13() *OxmIdTunMetadata13 {
8509 obj := &OxmIdTunMetadata13{
8510 OxmId: NewOxmId(92796),
8511 }
8512 return obj
8513}
8514func (self *OxmIdTunMetadata13) GetOXMName() string {
8515 return "tun_metadata13"
8516}
8517
8518func (self *OxmIdTunMetadata13) MarshalJSON() ([]byte, error) {
8519 if self.TypeLen == 0 {
8520 return []byte("\"\""), nil
8521 } else {
8522 return []byte("\"" + self.GetOXMName() + "\""), nil
8523 }
8524}
8525
8526type OxmIdTunMetadata13Masked struct {
8527 *OxmId
8528}
8529
8530type IOxmIdTunMetadata13Masked interface {
8531 IOxmId
8532}
8533
8534func (self *OxmIdTunMetadata13Masked) Serialize(encoder *goloxi.Encoder) error {
8535 if err := self.OxmId.Serialize(encoder); err != nil {
8536 return err
8537 }
8538
8539 return nil
8540}
8541
8542func DecodeOxmIdTunMetadata13Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata13Masked, error) {
8543 _oxmidtunmetadata13masked := &OxmIdTunMetadata13Masked{OxmId: parent}
8544 return _oxmidtunmetadata13masked, nil
8545}
8546
8547func NewOxmIdTunMetadata13Masked() *OxmIdTunMetadata13Masked {
8548 obj := &OxmIdTunMetadata13Masked{
8549 OxmId: NewOxmId(93176),
8550 }
8551 return obj
8552}
8553func (self *OxmIdTunMetadata13Masked) GetOXMName() string {
8554 return "tun_metadata13_masked"
8555}
8556
8557func (self *OxmIdTunMetadata13Masked) MarshalJSON() ([]byte, error) {
8558 if self.TypeLen == 0 {
8559 return []byte("\"\""), nil
8560 } else {
8561 return []byte("\"" + self.GetOXMName() + "\""), nil
8562 }
8563}
8564
8565type OxmIdTunMetadata14 struct {
8566 *OxmId
8567}
8568
8569type IOxmIdTunMetadata14 interface {
8570 IOxmId
8571}
8572
8573func (self *OxmIdTunMetadata14) Serialize(encoder *goloxi.Encoder) error {
8574 if err := self.OxmId.Serialize(encoder); err != nil {
8575 return err
8576 }
8577
8578 return nil
8579}
8580
8581func DecodeOxmIdTunMetadata14(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata14, error) {
8582 _oxmidtunmetadata14 := &OxmIdTunMetadata14{OxmId: parent}
8583 return _oxmidtunmetadata14, nil
8584}
8585
8586func NewOxmIdTunMetadata14() *OxmIdTunMetadata14 {
8587 obj := &OxmIdTunMetadata14{
8588 OxmId: NewOxmId(93308),
8589 }
8590 return obj
8591}
8592func (self *OxmIdTunMetadata14) GetOXMName() string {
8593 return "tun_metadata14"
8594}
8595
8596func (self *OxmIdTunMetadata14) MarshalJSON() ([]byte, error) {
8597 if self.TypeLen == 0 {
8598 return []byte("\"\""), nil
8599 } else {
8600 return []byte("\"" + self.GetOXMName() + "\""), nil
8601 }
8602}
8603
8604type OxmIdTunMetadata14Masked struct {
8605 *OxmId
8606}
8607
8608type IOxmIdTunMetadata14Masked interface {
8609 IOxmId
8610}
8611
8612func (self *OxmIdTunMetadata14Masked) Serialize(encoder *goloxi.Encoder) error {
8613 if err := self.OxmId.Serialize(encoder); err != nil {
8614 return err
8615 }
8616
8617 return nil
8618}
8619
8620func DecodeOxmIdTunMetadata14Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata14Masked, error) {
8621 _oxmidtunmetadata14masked := &OxmIdTunMetadata14Masked{OxmId: parent}
8622 return _oxmidtunmetadata14masked, nil
8623}
8624
8625func NewOxmIdTunMetadata14Masked() *OxmIdTunMetadata14Masked {
8626 obj := &OxmIdTunMetadata14Masked{
8627 OxmId: NewOxmId(93688),
8628 }
8629 return obj
8630}
8631func (self *OxmIdTunMetadata14Masked) GetOXMName() string {
8632 return "tun_metadata14_masked"
8633}
8634
8635func (self *OxmIdTunMetadata14Masked) MarshalJSON() ([]byte, error) {
8636 if self.TypeLen == 0 {
8637 return []byte("\"\""), nil
8638 } else {
8639 return []byte("\"" + self.GetOXMName() + "\""), nil
8640 }
8641}
8642
8643type OxmIdTunMetadata15 struct {
8644 *OxmId
8645}
8646
8647type IOxmIdTunMetadata15 interface {
8648 IOxmId
8649}
8650
8651func (self *OxmIdTunMetadata15) Serialize(encoder *goloxi.Encoder) error {
8652 if err := self.OxmId.Serialize(encoder); err != nil {
8653 return err
8654 }
8655
8656 return nil
8657}
8658
8659func DecodeOxmIdTunMetadata15(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata15, error) {
8660 _oxmidtunmetadata15 := &OxmIdTunMetadata15{OxmId: parent}
8661 return _oxmidtunmetadata15, nil
8662}
8663
8664func NewOxmIdTunMetadata15() *OxmIdTunMetadata15 {
8665 obj := &OxmIdTunMetadata15{
8666 OxmId: NewOxmId(93820),
8667 }
8668 return obj
8669}
8670func (self *OxmIdTunMetadata15) GetOXMName() string {
8671 return "tun_metadata15"
8672}
8673
8674func (self *OxmIdTunMetadata15) MarshalJSON() ([]byte, error) {
8675 if self.TypeLen == 0 {
8676 return []byte("\"\""), nil
8677 } else {
8678 return []byte("\"" + self.GetOXMName() + "\""), nil
8679 }
8680}
8681
8682type OxmIdTunMetadata15Masked struct {
8683 *OxmId
8684}
8685
8686type IOxmIdTunMetadata15Masked interface {
8687 IOxmId
8688}
8689
8690func (self *OxmIdTunMetadata15Masked) Serialize(encoder *goloxi.Encoder) error {
8691 if err := self.OxmId.Serialize(encoder); err != nil {
8692 return err
8693 }
8694
8695 return nil
8696}
8697
8698func DecodeOxmIdTunMetadata15Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata15Masked, error) {
8699 _oxmidtunmetadata15masked := &OxmIdTunMetadata15Masked{OxmId: parent}
8700 return _oxmidtunmetadata15masked, nil
8701}
8702
8703func NewOxmIdTunMetadata15Masked() *OxmIdTunMetadata15Masked {
8704 obj := &OxmIdTunMetadata15Masked{
8705 OxmId: NewOxmId(94200),
8706 }
8707 return obj
8708}
8709func (self *OxmIdTunMetadata15Masked) GetOXMName() string {
8710 return "tun_metadata15_masked"
8711}
8712
8713func (self *OxmIdTunMetadata15Masked) MarshalJSON() ([]byte, error) {
8714 if self.TypeLen == 0 {
8715 return []byte("\"\""), nil
8716 } else {
8717 return []byte("\"" + self.GetOXMName() + "\""), nil
8718 }
8719}
8720
8721type OxmIdTunMetadata16 struct {
8722 *OxmId
8723}
8724
8725type IOxmIdTunMetadata16 interface {
8726 IOxmId
8727}
8728
8729func (self *OxmIdTunMetadata16) Serialize(encoder *goloxi.Encoder) error {
8730 if err := self.OxmId.Serialize(encoder); err != nil {
8731 return err
8732 }
8733
8734 return nil
8735}
8736
8737func DecodeOxmIdTunMetadata16(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata16, error) {
8738 _oxmidtunmetadata16 := &OxmIdTunMetadata16{OxmId: parent}
8739 return _oxmidtunmetadata16, nil
8740}
8741
8742func NewOxmIdTunMetadata16() *OxmIdTunMetadata16 {
8743 obj := &OxmIdTunMetadata16{
8744 OxmId: NewOxmId(94332),
8745 }
8746 return obj
8747}
8748func (self *OxmIdTunMetadata16) GetOXMName() string {
8749 return "tun_metadata16"
8750}
8751
8752func (self *OxmIdTunMetadata16) MarshalJSON() ([]byte, error) {
8753 if self.TypeLen == 0 {
8754 return []byte("\"\""), nil
8755 } else {
8756 return []byte("\"" + self.GetOXMName() + "\""), nil
8757 }
8758}
8759
8760type OxmIdTunMetadata16Masked struct {
8761 *OxmId
8762}
8763
8764type IOxmIdTunMetadata16Masked interface {
8765 IOxmId
8766}
8767
8768func (self *OxmIdTunMetadata16Masked) Serialize(encoder *goloxi.Encoder) error {
8769 if err := self.OxmId.Serialize(encoder); err != nil {
8770 return err
8771 }
8772
8773 return nil
8774}
8775
8776func DecodeOxmIdTunMetadata16Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata16Masked, error) {
8777 _oxmidtunmetadata16masked := &OxmIdTunMetadata16Masked{OxmId: parent}
8778 return _oxmidtunmetadata16masked, nil
8779}
8780
8781func NewOxmIdTunMetadata16Masked() *OxmIdTunMetadata16Masked {
8782 obj := &OxmIdTunMetadata16Masked{
8783 OxmId: NewOxmId(94712),
8784 }
8785 return obj
8786}
8787func (self *OxmIdTunMetadata16Masked) GetOXMName() string {
8788 return "tun_metadata16_masked"
8789}
8790
8791func (self *OxmIdTunMetadata16Masked) MarshalJSON() ([]byte, error) {
8792 if self.TypeLen == 0 {
8793 return []byte("\"\""), nil
8794 } else {
8795 return []byte("\"" + self.GetOXMName() + "\""), nil
8796 }
8797}
8798
8799type OxmIdTunMetadata17 struct {
8800 *OxmId
8801}
8802
8803type IOxmIdTunMetadata17 interface {
8804 IOxmId
8805}
8806
8807func (self *OxmIdTunMetadata17) Serialize(encoder *goloxi.Encoder) error {
8808 if err := self.OxmId.Serialize(encoder); err != nil {
8809 return err
8810 }
8811
8812 return nil
8813}
8814
8815func DecodeOxmIdTunMetadata17(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata17, error) {
8816 _oxmidtunmetadata17 := &OxmIdTunMetadata17{OxmId: parent}
8817 return _oxmidtunmetadata17, nil
8818}
8819
8820func NewOxmIdTunMetadata17() *OxmIdTunMetadata17 {
8821 obj := &OxmIdTunMetadata17{
8822 OxmId: NewOxmId(94844),
8823 }
8824 return obj
8825}
8826func (self *OxmIdTunMetadata17) GetOXMName() string {
8827 return "tun_metadata17"
8828}
8829
8830func (self *OxmIdTunMetadata17) MarshalJSON() ([]byte, error) {
8831 if self.TypeLen == 0 {
8832 return []byte("\"\""), nil
8833 } else {
8834 return []byte("\"" + self.GetOXMName() + "\""), nil
8835 }
8836}
8837
8838type OxmIdTunMetadata17Masked struct {
8839 *OxmId
8840}
8841
8842type IOxmIdTunMetadata17Masked interface {
8843 IOxmId
8844}
8845
8846func (self *OxmIdTunMetadata17Masked) Serialize(encoder *goloxi.Encoder) error {
8847 if err := self.OxmId.Serialize(encoder); err != nil {
8848 return err
8849 }
8850
8851 return nil
8852}
8853
8854func DecodeOxmIdTunMetadata17Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata17Masked, error) {
8855 _oxmidtunmetadata17masked := &OxmIdTunMetadata17Masked{OxmId: parent}
8856 return _oxmidtunmetadata17masked, nil
8857}
8858
8859func NewOxmIdTunMetadata17Masked() *OxmIdTunMetadata17Masked {
8860 obj := &OxmIdTunMetadata17Masked{
8861 OxmId: NewOxmId(95224),
8862 }
8863 return obj
8864}
8865func (self *OxmIdTunMetadata17Masked) GetOXMName() string {
8866 return "tun_metadata17_masked"
8867}
8868
8869func (self *OxmIdTunMetadata17Masked) MarshalJSON() ([]byte, error) {
8870 if self.TypeLen == 0 {
8871 return []byte("\"\""), nil
8872 } else {
8873 return []byte("\"" + self.GetOXMName() + "\""), nil
8874 }
8875}
8876
8877type OxmIdTunMetadata18 struct {
8878 *OxmId
8879}
8880
8881type IOxmIdTunMetadata18 interface {
8882 IOxmId
8883}
8884
8885func (self *OxmIdTunMetadata18) Serialize(encoder *goloxi.Encoder) error {
8886 if err := self.OxmId.Serialize(encoder); err != nil {
8887 return err
8888 }
8889
8890 return nil
8891}
8892
8893func DecodeOxmIdTunMetadata18(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata18, error) {
8894 _oxmidtunmetadata18 := &OxmIdTunMetadata18{OxmId: parent}
8895 return _oxmidtunmetadata18, nil
8896}
8897
8898func NewOxmIdTunMetadata18() *OxmIdTunMetadata18 {
8899 obj := &OxmIdTunMetadata18{
8900 OxmId: NewOxmId(95356),
8901 }
8902 return obj
8903}
8904func (self *OxmIdTunMetadata18) GetOXMName() string {
8905 return "tun_metadata18"
8906}
8907
8908func (self *OxmIdTunMetadata18) MarshalJSON() ([]byte, error) {
8909 if self.TypeLen == 0 {
8910 return []byte("\"\""), nil
8911 } else {
8912 return []byte("\"" + self.GetOXMName() + "\""), nil
8913 }
8914}
8915
8916type OxmIdTunMetadata18Masked struct {
8917 *OxmId
8918}
8919
8920type IOxmIdTunMetadata18Masked interface {
8921 IOxmId
8922}
8923
8924func (self *OxmIdTunMetadata18Masked) Serialize(encoder *goloxi.Encoder) error {
8925 if err := self.OxmId.Serialize(encoder); err != nil {
8926 return err
8927 }
8928
8929 return nil
8930}
8931
8932func DecodeOxmIdTunMetadata18Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata18Masked, error) {
8933 _oxmidtunmetadata18masked := &OxmIdTunMetadata18Masked{OxmId: parent}
8934 return _oxmidtunmetadata18masked, nil
8935}
8936
8937func NewOxmIdTunMetadata18Masked() *OxmIdTunMetadata18Masked {
8938 obj := &OxmIdTunMetadata18Masked{
8939 OxmId: NewOxmId(95736),
8940 }
8941 return obj
8942}
8943func (self *OxmIdTunMetadata18Masked) GetOXMName() string {
8944 return "tun_metadata18_masked"
8945}
8946
8947func (self *OxmIdTunMetadata18Masked) MarshalJSON() ([]byte, error) {
8948 if self.TypeLen == 0 {
8949 return []byte("\"\""), nil
8950 } else {
8951 return []byte("\"" + self.GetOXMName() + "\""), nil
8952 }
8953}
8954
8955type OxmIdTunMetadata19 struct {
8956 *OxmId
8957}
8958
8959type IOxmIdTunMetadata19 interface {
8960 IOxmId
8961}
8962
8963func (self *OxmIdTunMetadata19) Serialize(encoder *goloxi.Encoder) error {
8964 if err := self.OxmId.Serialize(encoder); err != nil {
8965 return err
8966 }
8967
8968 return nil
8969}
8970
8971func DecodeOxmIdTunMetadata19(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata19, error) {
8972 _oxmidtunmetadata19 := &OxmIdTunMetadata19{OxmId: parent}
8973 return _oxmidtunmetadata19, nil
8974}
8975
8976func NewOxmIdTunMetadata19() *OxmIdTunMetadata19 {
8977 obj := &OxmIdTunMetadata19{
8978 OxmId: NewOxmId(95868),
8979 }
8980 return obj
8981}
8982func (self *OxmIdTunMetadata19) GetOXMName() string {
8983 return "tun_metadata19"
8984}
8985
8986func (self *OxmIdTunMetadata19) MarshalJSON() ([]byte, error) {
8987 if self.TypeLen == 0 {
8988 return []byte("\"\""), nil
8989 } else {
8990 return []byte("\"" + self.GetOXMName() + "\""), nil
8991 }
8992}
8993
8994type OxmIdTunMetadata19Masked struct {
8995 *OxmId
8996}
8997
8998type IOxmIdTunMetadata19Masked interface {
8999 IOxmId
9000}
9001
9002func (self *OxmIdTunMetadata19Masked) Serialize(encoder *goloxi.Encoder) error {
9003 if err := self.OxmId.Serialize(encoder); err != nil {
9004 return err
9005 }
9006
9007 return nil
9008}
9009
9010func DecodeOxmIdTunMetadata19Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata19Masked, error) {
9011 _oxmidtunmetadata19masked := &OxmIdTunMetadata19Masked{OxmId: parent}
9012 return _oxmidtunmetadata19masked, nil
9013}
9014
9015func NewOxmIdTunMetadata19Masked() *OxmIdTunMetadata19Masked {
9016 obj := &OxmIdTunMetadata19Masked{
9017 OxmId: NewOxmId(96248),
9018 }
9019 return obj
9020}
9021func (self *OxmIdTunMetadata19Masked) GetOXMName() string {
9022 return "tun_metadata19_masked"
9023}
9024
9025func (self *OxmIdTunMetadata19Masked) MarshalJSON() ([]byte, error) {
9026 if self.TypeLen == 0 {
9027 return []byte("\"\""), nil
9028 } else {
9029 return []byte("\"" + self.GetOXMName() + "\""), nil
9030 }
9031}
9032
9033type OxmIdTunMetadata1Masked struct {
9034 *OxmId
9035}
9036
9037type IOxmIdTunMetadata1Masked interface {
9038 IOxmId
9039}
9040
9041func (self *OxmIdTunMetadata1Masked) Serialize(encoder *goloxi.Encoder) error {
9042 if err := self.OxmId.Serialize(encoder); err != nil {
9043 return err
9044 }
9045
9046 return nil
9047}
9048
9049func DecodeOxmIdTunMetadata1Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata1Masked, error) {
9050 _oxmidtunmetadata1masked := &OxmIdTunMetadata1Masked{OxmId: parent}
9051 return _oxmidtunmetadata1masked, nil
9052}
9053
9054func NewOxmIdTunMetadata1Masked() *OxmIdTunMetadata1Masked {
9055 obj := &OxmIdTunMetadata1Masked{
9056 OxmId: NewOxmId(87032),
9057 }
9058 return obj
9059}
9060func (self *OxmIdTunMetadata1Masked) GetOXMName() string {
9061 return "tun_metadata1_masked"
9062}
9063
9064func (self *OxmIdTunMetadata1Masked) MarshalJSON() ([]byte, error) {
9065 if self.TypeLen == 0 {
9066 return []byte("\"\""), nil
9067 } else {
9068 return []byte("\"" + self.GetOXMName() + "\""), nil
9069 }
9070}
9071
9072type OxmIdTunMetadata2 struct {
9073 *OxmId
9074}
9075
9076type IOxmIdTunMetadata2 interface {
9077 IOxmId
9078}
9079
9080func (self *OxmIdTunMetadata2) Serialize(encoder *goloxi.Encoder) error {
9081 if err := self.OxmId.Serialize(encoder); err != nil {
9082 return err
9083 }
9084
9085 return nil
9086}
9087
9088func DecodeOxmIdTunMetadata2(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata2, error) {
9089 _oxmidtunmetadata2 := &OxmIdTunMetadata2{OxmId: parent}
9090 return _oxmidtunmetadata2, nil
9091}
9092
9093func NewOxmIdTunMetadata2() *OxmIdTunMetadata2 {
9094 obj := &OxmIdTunMetadata2{
9095 OxmId: NewOxmId(87164),
9096 }
9097 return obj
9098}
9099func (self *OxmIdTunMetadata2) GetOXMName() string {
9100 return "tun_metadata2"
9101}
9102
9103func (self *OxmIdTunMetadata2) MarshalJSON() ([]byte, error) {
9104 if self.TypeLen == 0 {
9105 return []byte("\"\""), nil
9106 } else {
9107 return []byte("\"" + self.GetOXMName() + "\""), nil
9108 }
9109}
9110
9111type OxmIdTunMetadata20 struct {
9112 *OxmId
9113}
9114
9115type IOxmIdTunMetadata20 interface {
9116 IOxmId
9117}
9118
9119func (self *OxmIdTunMetadata20) Serialize(encoder *goloxi.Encoder) error {
9120 if err := self.OxmId.Serialize(encoder); err != nil {
9121 return err
9122 }
9123
9124 return nil
9125}
9126
9127func DecodeOxmIdTunMetadata20(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata20, error) {
9128 _oxmidtunmetadata20 := &OxmIdTunMetadata20{OxmId: parent}
9129 return _oxmidtunmetadata20, nil
9130}
9131
9132func NewOxmIdTunMetadata20() *OxmIdTunMetadata20 {
9133 obj := &OxmIdTunMetadata20{
9134 OxmId: NewOxmId(96380),
9135 }
9136 return obj
9137}
9138func (self *OxmIdTunMetadata20) GetOXMName() string {
9139 return "tun_metadata20"
9140}
9141
9142func (self *OxmIdTunMetadata20) MarshalJSON() ([]byte, error) {
9143 if self.TypeLen == 0 {
9144 return []byte("\"\""), nil
9145 } else {
9146 return []byte("\"" + self.GetOXMName() + "\""), nil
9147 }
9148}
9149
9150type OxmIdTunMetadata20Masked struct {
9151 *OxmId
9152}
9153
9154type IOxmIdTunMetadata20Masked interface {
9155 IOxmId
9156}
9157
9158func (self *OxmIdTunMetadata20Masked) Serialize(encoder *goloxi.Encoder) error {
9159 if err := self.OxmId.Serialize(encoder); err != nil {
9160 return err
9161 }
9162
9163 return nil
9164}
9165
9166func DecodeOxmIdTunMetadata20Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata20Masked, error) {
9167 _oxmidtunmetadata20masked := &OxmIdTunMetadata20Masked{OxmId: parent}
9168 return _oxmidtunmetadata20masked, nil
9169}
9170
9171func NewOxmIdTunMetadata20Masked() *OxmIdTunMetadata20Masked {
9172 obj := &OxmIdTunMetadata20Masked{
9173 OxmId: NewOxmId(96760),
9174 }
9175 return obj
9176}
9177func (self *OxmIdTunMetadata20Masked) GetOXMName() string {
9178 return "tun_metadata20_masked"
9179}
9180
9181func (self *OxmIdTunMetadata20Masked) MarshalJSON() ([]byte, error) {
9182 if self.TypeLen == 0 {
9183 return []byte("\"\""), nil
9184 } else {
9185 return []byte("\"" + self.GetOXMName() + "\""), nil
9186 }
9187}
9188
9189type OxmIdTunMetadata21 struct {
9190 *OxmId
9191}
9192
9193type IOxmIdTunMetadata21 interface {
9194 IOxmId
9195}
9196
9197func (self *OxmIdTunMetadata21) Serialize(encoder *goloxi.Encoder) error {
9198 if err := self.OxmId.Serialize(encoder); err != nil {
9199 return err
9200 }
9201
9202 return nil
9203}
9204
9205func DecodeOxmIdTunMetadata21(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata21, error) {
9206 _oxmidtunmetadata21 := &OxmIdTunMetadata21{OxmId: parent}
9207 return _oxmidtunmetadata21, nil
9208}
9209
9210func NewOxmIdTunMetadata21() *OxmIdTunMetadata21 {
9211 obj := &OxmIdTunMetadata21{
9212 OxmId: NewOxmId(96892),
9213 }
9214 return obj
9215}
9216func (self *OxmIdTunMetadata21) GetOXMName() string {
9217 return "tun_metadata21"
9218}
9219
9220func (self *OxmIdTunMetadata21) MarshalJSON() ([]byte, error) {
9221 if self.TypeLen == 0 {
9222 return []byte("\"\""), nil
9223 } else {
9224 return []byte("\"" + self.GetOXMName() + "\""), nil
9225 }
9226}
9227
9228type OxmIdTunMetadata21Masked struct {
9229 *OxmId
9230}
9231
9232type IOxmIdTunMetadata21Masked interface {
9233 IOxmId
9234}
9235
9236func (self *OxmIdTunMetadata21Masked) Serialize(encoder *goloxi.Encoder) error {
9237 if err := self.OxmId.Serialize(encoder); err != nil {
9238 return err
9239 }
9240
9241 return nil
9242}
9243
9244func DecodeOxmIdTunMetadata21Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata21Masked, error) {
9245 _oxmidtunmetadata21masked := &OxmIdTunMetadata21Masked{OxmId: parent}
9246 return _oxmidtunmetadata21masked, nil
9247}
9248
9249func NewOxmIdTunMetadata21Masked() *OxmIdTunMetadata21Masked {
9250 obj := &OxmIdTunMetadata21Masked{
9251 OxmId: NewOxmId(97272),
9252 }
9253 return obj
9254}
9255func (self *OxmIdTunMetadata21Masked) GetOXMName() string {
9256 return "tun_metadata21_masked"
9257}
9258
9259func (self *OxmIdTunMetadata21Masked) MarshalJSON() ([]byte, error) {
9260 if self.TypeLen == 0 {
9261 return []byte("\"\""), nil
9262 } else {
9263 return []byte("\"" + self.GetOXMName() + "\""), nil
9264 }
9265}
9266
9267type OxmIdTunMetadata22 struct {
9268 *OxmId
9269}
9270
9271type IOxmIdTunMetadata22 interface {
9272 IOxmId
9273}
9274
9275func (self *OxmIdTunMetadata22) Serialize(encoder *goloxi.Encoder) error {
9276 if err := self.OxmId.Serialize(encoder); err != nil {
9277 return err
9278 }
9279
9280 return nil
9281}
9282
9283func DecodeOxmIdTunMetadata22(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata22, error) {
9284 _oxmidtunmetadata22 := &OxmIdTunMetadata22{OxmId: parent}
9285 return _oxmidtunmetadata22, nil
9286}
9287
9288func NewOxmIdTunMetadata22() *OxmIdTunMetadata22 {
9289 obj := &OxmIdTunMetadata22{
9290 OxmId: NewOxmId(97404),
9291 }
9292 return obj
9293}
9294func (self *OxmIdTunMetadata22) GetOXMName() string {
9295 return "tun_metadata22"
9296}
9297
9298func (self *OxmIdTunMetadata22) MarshalJSON() ([]byte, error) {
9299 if self.TypeLen == 0 {
9300 return []byte("\"\""), nil
9301 } else {
9302 return []byte("\"" + self.GetOXMName() + "\""), nil
9303 }
9304}
9305
9306type OxmIdTunMetadata22Masked struct {
9307 *OxmId
9308}
9309
9310type IOxmIdTunMetadata22Masked interface {
9311 IOxmId
9312}
9313
9314func (self *OxmIdTunMetadata22Masked) Serialize(encoder *goloxi.Encoder) error {
9315 if err := self.OxmId.Serialize(encoder); err != nil {
9316 return err
9317 }
9318
9319 return nil
9320}
9321
9322func DecodeOxmIdTunMetadata22Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata22Masked, error) {
9323 _oxmidtunmetadata22masked := &OxmIdTunMetadata22Masked{OxmId: parent}
9324 return _oxmidtunmetadata22masked, nil
9325}
9326
9327func NewOxmIdTunMetadata22Masked() *OxmIdTunMetadata22Masked {
9328 obj := &OxmIdTunMetadata22Masked{
9329 OxmId: NewOxmId(97784),
9330 }
9331 return obj
9332}
9333func (self *OxmIdTunMetadata22Masked) GetOXMName() string {
9334 return "tun_metadata22_masked"
9335}
9336
9337func (self *OxmIdTunMetadata22Masked) MarshalJSON() ([]byte, error) {
9338 if self.TypeLen == 0 {
9339 return []byte("\"\""), nil
9340 } else {
9341 return []byte("\"" + self.GetOXMName() + "\""), nil
9342 }
9343}
9344
9345type OxmIdTunMetadata23 struct {
9346 *OxmId
9347}
9348
9349type IOxmIdTunMetadata23 interface {
9350 IOxmId
9351}
9352
9353func (self *OxmIdTunMetadata23) Serialize(encoder *goloxi.Encoder) error {
9354 if err := self.OxmId.Serialize(encoder); err != nil {
9355 return err
9356 }
9357
9358 return nil
9359}
9360
9361func DecodeOxmIdTunMetadata23(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata23, error) {
9362 _oxmidtunmetadata23 := &OxmIdTunMetadata23{OxmId: parent}
9363 return _oxmidtunmetadata23, nil
9364}
9365
9366func NewOxmIdTunMetadata23() *OxmIdTunMetadata23 {
9367 obj := &OxmIdTunMetadata23{
9368 OxmId: NewOxmId(97916),
9369 }
9370 return obj
9371}
9372func (self *OxmIdTunMetadata23) GetOXMName() string {
9373 return "tun_metadata23"
9374}
9375
9376func (self *OxmIdTunMetadata23) MarshalJSON() ([]byte, error) {
9377 if self.TypeLen == 0 {
9378 return []byte("\"\""), nil
9379 } else {
9380 return []byte("\"" + self.GetOXMName() + "\""), nil
9381 }
9382}
9383
9384type OxmIdTunMetadata23Masked struct {
9385 *OxmId
9386}
9387
9388type IOxmIdTunMetadata23Masked interface {
9389 IOxmId
9390}
9391
9392func (self *OxmIdTunMetadata23Masked) Serialize(encoder *goloxi.Encoder) error {
9393 if err := self.OxmId.Serialize(encoder); err != nil {
9394 return err
9395 }
9396
9397 return nil
9398}
9399
9400func DecodeOxmIdTunMetadata23Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata23Masked, error) {
9401 _oxmidtunmetadata23masked := &OxmIdTunMetadata23Masked{OxmId: parent}
9402 return _oxmidtunmetadata23masked, nil
9403}
9404
9405func NewOxmIdTunMetadata23Masked() *OxmIdTunMetadata23Masked {
9406 obj := &OxmIdTunMetadata23Masked{
9407 OxmId: NewOxmId(98296),
9408 }
9409 return obj
9410}
9411func (self *OxmIdTunMetadata23Masked) GetOXMName() string {
9412 return "tun_metadata23_masked"
9413}
9414
9415func (self *OxmIdTunMetadata23Masked) MarshalJSON() ([]byte, error) {
9416 if self.TypeLen == 0 {
9417 return []byte("\"\""), nil
9418 } else {
9419 return []byte("\"" + self.GetOXMName() + "\""), nil
9420 }
9421}
9422
9423type OxmIdTunMetadata24 struct {
9424 *OxmId
9425}
9426
9427type IOxmIdTunMetadata24 interface {
9428 IOxmId
9429}
9430
9431func (self *OxmIdTunMetadata24) Serialize(encoder *goloxi.Encoder) error {
9432 if err := self.OxmId.Serialize(encoder); err != nil {
9433 return err
9434 }
9435
9436 return nil
9437}
9438
9439func DecodeOxmIdTunMetadata24(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata24, error) {
9440 _oxmidtunmetadata24 := &OxmIdTunMetadata24{OxmId: parent}
9441 return _oxmidtunmetadata24, nil
9442}
9443
9444func NewOxmIdTunMetadata24() *OxmIdTunMetadata24 {
9445 obj := &OxmIdTunMetadata24{
9446 OxmId: NewOxmId(98428),
9447 }
9448 return obj
9449}
9450func (self *OxmIdTunMetadata24) GetOXMName() string {
9451 return "tun_metadata24"
9452}
9453
9454func (self *OxmIdTunMetadata24) MarshalJSON() ([]byte, error) {
9455 if self.TypeLen == 0 {
9456 return []byte("\"\""), nil
9457 } else {
9458 return []byte("\"" + self.GetOXMName() + "\""), nil
9459 }
9460}
9461
9462type OxmIdTunMetadata24Masked struct {
9463 *OxmId
9464}
9465
9466type IOxmIdTunMetadata24Masked interface {
9467 IOxmId
9468}
9469
9470func (self *OxmIdTunMetadata24Masked) Serialize(encoder *goloxi.Encoder) error {
9471 if err := self.OxmId.Serialize(encoder); err != nil {
9472 return err
9473 }
9474
9475 return nil
9476}
9477
9478func DecodeOxmIdTunMetadata24Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata24Masked, error) {
9479 _oxmidtunmetadata24masked := &OxmIdTunMetadata24Masked{OxmId: parent}
9480 return _oxmidtunmetadata24masked, nil
9481}
9482
9483func NewOxmIdTunMetadata24Masked() *OxmIdTunMetadata24Masked {
9484 obj := &OxmIdTunMetadata24Masked{
9485 OxmId: NewOxmId(98808),
9486 }
9487 return obj
9488}
9489func (self *OxmIdTunMetadata24Masked) GetOXMName() string {
9490 return "tun_metadata24_masked"
9491}
9492
9493func (self *OxmIdTunMetadata24Masked) MarshalJSON() ([]byte, error) {
9494 if self.TypeLen == 0 {
9495 return []byte("\"\""), nil
9496 } else {
9497 return []byte("\"" + self.GetOXMName() + "\""), nil
9498 }
9499}
9500
9501type OxmIdTunMetadata25 struct {
9502 *OxmId
9503}
9504
9505type IOxmIdTunMetadata25 interface {
9506 IOxmId
9507}
9508
9509func (self *OxmIdTunMetadata25) Serialize(encoder *goloxi.Encoder) error {
9510 if err := self.OxmId.Serialize(encoder); err != nil {
9511 return err
9512 }
9513
9514 return nil
9515}
9516
9517func DecodeOxmIdTunMetadata25(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata25, error) {
9518 _oxmidtunmetadata25 := &OxmIdTunMetadata25{OxmId: parent}
9519 return _oxmidtunmetadata25, nil
9520}
9521
9522func NewOxmIdTunMetadata25() *OxmIdTunMetadata25 {
9523 obj := &OxmIdTunMetadata25{
9524 OxmId: NewOxmId(98940),
9525 }
9526 return obj
9527}
9528func (self *OxmIdTunMetadata25) GetOXMName() string {
9529 return "tun_metadata25"
9530}
9531
9532func (self *OxmIdTunMetadata25) MarshalJSON() ([]byte, error) {
9533 if self.TypeLen == 0 {
9534 return []byte("\"\""), nil
9535 } else {
9536 return []byte("\"" + self.GetOXMName() + "\""), nil
9537 }
9538}
9539
9540type OxmIdTunMetadata25Masked struct {
9541 *OxmId
9542}
9543
9544type IOxmIdTunMetadata25Masked interface {
9545 IOxmId
9546}
9547
9548func (self *OxmIdTunMetadata25Masked) Serialize(encoder *goloxi.Encoder) error {
9549 if err := self.OxmId.Serialize(encoder); err != nil {
9550 return err
9551 }
9552
9553 return nil
9554}
9555
9556func DecodeOxmIdTunMetadata25Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata25Masked, error) {
9557 _oxmidtunmetadata25masked := &OxmIdTunMetadata25Masked{OxmId: parent}
9558 return _oxmidtunmetadata25masked, nil
9559}
9560
9561func NewOxmIdTunMetadata25Masked() *OxmIdTunMetadata25Masked {
9562 obj := &OxmIdTunMetadata25Masked{
9563 OxmId: NewOxmId(99320),
9564 }
9565 return obj
9566}
9567func (self *OxmIdTunMetadata25Masked) GetOXMName() string {
9568 return "tun_metadata25_masked"
9569}
9570
9571func (self *OxmIdTunMetadata25Masked) MarshalJSON() ([]byte, error) {
9572 if self.TypeLen == 0 {
9573 return []byte("\"\""), nil
9574 } else {
9575 return []byte("\"" + self.GetOXMName() + "\""), nil
9576 }
9577}
9578
9579type OxmIdTunMetadata26 struct {
9580 *OxmId
9581}
9582
9583type IOxmIdTunMetadata26 interface {
9584 IOxmId
9585}
9586
9587func (self *OxmIdTunMetadata26) Serialize(encoder *goloxi.Encoder) error {
9588 if err := self.OxmId.Serialize(encoder); err != nil {
9589 return err
9590 }
9591
9592 return nil
9593}
9594
9595func DecodeOxmIdTunMetadata26(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata26, error) {
9596 _oxmidtunmetadata26 := &OxmIdTunMetadata26{OxmId: parent}
9597 return _oxmidtunmetadata26, nil
9598}
9599
9600func NewOxmIdTunMetadata26() *OxmIdTunMetadata26 {
9601 obj := &OxmIdTunMetadata26{
9602 OxmId: NewOxmId(99452),
9603 }
9604 return obj
9605}
9606func (self *OxmIdTunMetadata26) GetOXMName() string {
9607 return "tun_metadata26"
9608}
9609
9610func (self *OxmIdTunMetadata26) MarshalJSON() ([]byte, error) {
9611 if self.TypeLen == 0 {
9612 return []byte("\"\""), nil
9613 } else {
9614 return []byte("\"" + self.GetOXMName() + "\""), nil
9615 }
9616}
9617
9618type OxmIdTunMetadata26Masked struct {
9619 *OxmId
9620}
9621
9622type IOxmIdTunMetadata26Masked interface {
9623 IOxmId
9624}
9625
9626func (self *OxmIdTunMetadata26Masked) Serialize(encoder *goloxi.Encoder) error {
9627 if err := self.OxmId.Serialize(encoder); err != nil {
9628 return err
9629 }
9630
9631 return nil
9632}
9633
9634func DecodeOxmIdTunMetadata26Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata26Masked, error) {
9635 _oxmidtunmetadata26masked := &OxmIdTunMetadata26Masked{OxmId: parent}
9636 return _oxmidtunmetadata26masked, nil
9637}
9638
9639func NewOxmIdTunMetadata26Masked() *OxmIdTunMetadata26Masked {
9640 obj := &OxmIdTunMetadata26Masked{
9641 OxmId: NewOxmId(99832),
9642 }
9643 return obj
9644}
9645func (self *OxmIdTunMetadata26Masked) GetOXMName() string {
9646 return "tun_metadata26_masked"
9647}
9648
9649func (self *OxmIdTunMetadata26Masked) MarshalJSON() ([]byte, error) {
9650 if self.TypeLen == 0 {
9651 return []byte("\"\""), nil
9652 } else {
9653 return []byte("\"" + self.GetOXMName() + "\""), nil
9654 }
9655}
9656
9657type OxmIdTunMetadata27 struct {
9658 *OxmId
9659}
9660
9661type IOxmIdTunMetadata27 interface {
9662 IOxmId
9663}
9664
9665func (self *OxmIdTunMetadata27) Serialize(encoder *goloxi.Encoder) error {
9666 if err := self.OxmId.Serialize(encoder); err != nil {
9667 return err
9668 }
9669
9670 return nil
9671}
9672
9673func DecodeOxmIdTunMetadata27(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata27, error) {
9674 _oxmidtunmetadata27 := &OxmIdTunMetadata27{OxmId: parent}
9675 return _oxmidtunmetadata27, nil
9676}
9677
9678func NewOxmIdTunMetadata27() *OxmIdTunMetadata27 {
9679 obj := &OxmIdTunMetadata27{
9680 OxmId: NewOxmId(99964),
9681 }
9682 return obj
9683}
9684func (self *OxmIdTunMetadata27) GetOXMName() string {
9685 return "tun_metadata27"
9686}
9687
9688func (self *OxmIdTunMetadata27) MarshalJSON() ([]byte, error) {
9689 if self.TypeLen == 0 {
9690 return []byte("\"\""), nil
9691 } else {
9692 return []byte("\"" + self.GetOXMName() + "\""), nil
9693 }
9694}
9695
9696type OxmIdTunMetadata27Masked struct {
9697 *OxmId
9698}
9699
9700type IOxmIdTunMetadata27Masked interface {
9701 IOxmId
9702}
9703
9704func (self *OxmIdTunMetadata27Masked) Serialize(encoder *goloxi.Encoder) error {
9705 if err := self.OxmId.Serialize(encoder); err != nil {
9706 return err
9707 }
9708
9709 return nil
9710}
9711
9712func DecodeOxmIdTunMetadata27Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata27Masked, error) {
9713 _oxmidtunmetadata27masked := &OxmIdTunMetadata27Masked{OxmId: parent}
9714 return _oxmidtunmetadata27masked, nil
9715}
9716
9717func NewOxmIdTunMetadata27Masked() *OxmIdTunMetadata27Masked {
9718 obj := &OxmIdTunMetadata27Masked{
9719 OxmId: NewOxmId(100344),
9720 }
9721 return obj
9722}
9723func (self *OxmIdTunMetadata27Masked) GetOXMName() string {
9724 return "tun_metadata27_masked"
9725}
9726
9727func (self *OxmIdTunMetadata27Masked) MarshalJSON() ([]byte, error) {
9728 if self.TypeLen == 0 {
9729 return []byte("\"\""), nil
9730 } else {
9731 return []byte("\"" + self.GetOXMName() + "\""), nil
9732 }
9733}
9734
9735type OxmIdTunMetadata28 struct {
9736 *OxmId
9737}
9738
9739type IOxmIdTunMetadata28 interface {
9740 IOxmId
9741}
9742
9743func (self *OxmIdTunMetadata28) Serialize(encoder *goloxi.Encoder) error {
9744 if err := self.OxmId.Serialize(encoder); err != nil {
9745 return err
9746 }
9747
9748 return nil
9749}
9750
9751func DecodeOxmIdTunMetadata28(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata28, error) {
9752 _oxmidtunmetadata28 := &OxmIdTunMetadata28{OxmId: parent}
9753 return _oxmidtunmetadata28, nil
9754}
9755
9756func NewOxmIdTunMetadata28() *OxmIdTunMetadata28 {
9757 obj := &OxmIdTunMetadata28{
9758 OxmId: NewOxmId(100476),
9759 }
9760 return obj
9761}
9762func (self *OxmIdTunMetadata28) GetOXMName() string {
9763 return "tun_metadata28"
9764}
9765
9766func (self *OxmIdTunMetadata28) MarshalJSON() ([]byte, error) {
9767 if self.TypeLen == 0 {
9768 return []byte("\"\""), nil
9769 } else {
9770 return []byte("\"" + self.GetOXMName() + "\""), nil
9771 }
9772}
9773
9774type OxmIdTunMetadata28Masked struct {
9775 *OxmId
9776}
9777
9778type IOxmIdTunMetadata28Masked interface {
9779 IOxmId
9780}
9781
9782func (self *OxmIdTunMetadata28Masked) Serialize(encoder *goloxi.Encoder) error {
9783 if err := self.OxmId.Serialize(encoder); err != nil {
9784 return err
9785 }
9786
9787 return nil
9788}
9789
9790func DecodeOxmIdTunMetadata28Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata28Masked, error) {
9791 _oxmidtunmetadata28masked := &OxmIdTunMetadata28Masked{OxmId: parent}
9792 return _oxmidtunmetadata28masked, nil
9793}
9794
9795func NewOxmIdTunMetadata28Masked() *OxmIdTunMetadata28Masked {
9796 obj := &OxmIdTunMetadata28Masked{
9797 OxmId: NewOxmId(100856),
9798 }
9799 return obj
9800}
9801func (self *OxmIdTunMetadata28Masked) GetOXMName() string {
9802 return "tun_metadata28_masked"
9803}
9804
9805func (self *OxmIdTunMetadata28Masked) MarshalJSON() ([]byte, error) {
9806 if self.TypeLen == 0 {
9807 return []byte("\"\""), nil
9808 } else {
9809 return []byte("\"" + self.GetOXMName() + "\""), nil
9810 }
9811}
9812
9813type OxmIdTunMetadata29 struct {
9814 *OxmId
9815}
9816
9817type IOxmIdTunMetadata29 interface {
9818 IOxmId
9819}
9820
9821func (self *OxmIdTunMetadata29) Serialize(encoder *goloxi.Encoder) error {
9822 if err := self.OxmId.Serialize(encoder); err != nil {
9823 return err
9824 }
9825
9826 return nil
9827}
9828
9829func DecodeOxmIdTunMetadata29(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata29, error) {
9830 _oxmidtunmetadata29 := &OxmIdTunMetadata29{OxmId: parent}
9831 return _oxmidtunmetadata29, nil
9832}
9833
9834func NewOxmIdTunMetadata29() *OxmIdTunMetadata29 {
9835 obj := &OxmIdTunMetadata29{
9836 OxmId: NewOxmId(100988),
9837 }
9838 return obj
9839}
9840func (self *OxmIdTunMetadata29) GetOXMName() string {
9841 return "tun_metadata29"
9842}
9843
9844func (self *OxmIdTunMetadata29) MarshalJSON() ([]byte, error) {
9845 if self.TypeLen == 0 {
9846 return []byte("\"\""), nil
9847 } else {
9848 return []byte("\"" + self.GetOXMName() + "\""), nil
9849 }
9850}
9851
9852type OxmIdTunMetadata29Masked struct {
9853 *OxmId
9854}
9855
9856type IOxmIdTunMetadata29Masked interface {
9857 IOxmId
9858}
9859
9860func (self *OxmIdTunMetadata29Masked) Serialize(encoder *goloxi.Encoder) error {
9861 if err := self.OxmId.Serialize(encoder); err != nil {
9862 return err
9863 }
9864
9865 return nil
9866}
9867
9868func DecodeOxmIdTunMetadata29Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata29Masked, error) {
9869 _oxmidtunmetadata29masked := &OxmIdTunMetadata29Masked{OxmId: parent}
9870 return _oxmidtunmetadata29masked, nil
9871}
9872
9873func NewOxmIdTunMetadata29Masked() *OxmIdTunMetadata29Masked {
9874 obj := &OxmIdTunMetadata29Masked{
9875 OxmId: NewOxmId(101368),
9876 }
9877 return obj
9878}
9879func (self *OxmIdTunMetadata29Masked) GetOXMName() string {
9880 return "tun_metadata29_masked"
9881}
9882
9883func (self *OxmIdTunMetadata29Masked) MarshalJSON() ([]byte, error) {
9884 if self.TypeLen == 0 {
9885 return []byte("\"\""), nil
9886 } else {
9887 return []byte("\"" + self.GetOXMName() + "\""), nil
9888 }
9889}
9890
9891type OxmIdTunMetadata2Masked struct {
9892 *OxmId
9893}
9894
9895type IOxmIdTunMetadata2Masked interface {
9896 IOxmId
9897}
9898
9899func (self *OxmIdTunMetadata2Masked) Serialize(encoder *goloxi.Encoder) error {
9900 if err := self.OxmId.Serialize(encoder); err != nil {
9901 return err
9902 }
9903
9904 return nil
9905}
9906
9907func DecodeOxmIdTunMetadata2Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata2Masked, error) {
9908 _oxmidtunmetadata2masked := &OxmIdTunMetadata2Masked{OxmId: parent}
9909 return _oxmidtunmetadata2masked, nil
9910}
9911
9912func NewOxmIdTunMetadata2Masked() *OxmIdTunMetadata2Masked {
9913 obj := &OxmIdTunMetadata2Masked{
9914 OxmId: NewOxmId(87544),
9915 }
9916 return obj
9917}
9918func (self *OxmIdTunMetadata2Masked) GetOXMName() string {
9919 return "tun_metadata2_masked"
9920}
9921
9922func (self *OxmIdTunMetadata2Masked) MarshalJSON() ([]byte, error) {
9923 if self.TypeLen == 0 {
9924 return []byte("\"\""), nil
9925 } else {
9926 return []byte("\"" + self.GetOXMName() + "\""), nil
9927 }
9928}
9929
9930type OxmIdTunMetadata3 struct {
9931 *OxmId
9932}
9933
9934type IOxmIdTunMetadata3 interface {
9935 IOxmId
9936}
9937
9938func (self *OxmIdTunMetadata3) Serialize(encoder *goloxi.Encoder) error {
9939 if err := self.OxmId.Serialize(encoder); err != nil {
9940 return err
9941 }
9942
9943 return nil
9944}
9945
9946func DecodeOxmIdTunMetadata3(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata3, error) {
9947 _oxmidtunmetadata3 := &OxmIdTunMetadata3{OxmId: parent}
9948 return _oxmidtunmetadata3, nil
9949}
9950
9951func NewOxmIdTunMetadata3() *OxmIdTunMetadata3 {
9952 obj := &OxmIdTunMetadata3{
9953 OxmId: NewOxmId(87676),
9954 }
9955 return obj
9956}
9957func (self *OxmIdTunMetadata3) GetOXMName() string {
9958 return "tun_metadata3"
9959}
9960
9961func (self *OxmIdTunMetadata3) MarshalJSON() ([]byte, error) {
9962 if self.TypeLen == 0 {
9963 return []byte("\"\""), nil
9964 } else {
9965 return []byte("\"" + self.GetOXMName() + "\""), nil
9966 }
9967}
9968
9969type OxmIdTunMetadata30 struct {
9970 *OxmId
9971}
9972
9973type IOxmIdTunMetadata30 interface {
9974 IOxmId
9975}
9976
9977func (self *OxmIdTunMetadata30) Serialize(encoder *goloxi.Encoder) error {
9978 if err := self.OxmId.Serialize(encoder); err != nil {
9979 return err
9980 }
9981
9982 return nil
9983}
9984
9985func DecodeOxmIdTunMetadata30(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata30, error) {
9986 _oxmidtunmetadata30 := &OxmIdTunMetadata30{OxmId: parent}
9987 return _oxmidtunmetadata30, nil
9988}
9989
9990func NewOxmIdTunMetadata30() *OxmIdTunMetadata30 {
9991 obj := &OxmIdTunMetadata30{
9992 OxmId: NewOxmId(101500),
9993 }
9994 return obj
9995}
9996func (self *OxmIdTunMetadata30) GetOXMName() string {
9997 return "tun_metadata30"
9998}
9999
10000func (self *OxmIdTunMetadata30) MarshalJSON() ([]byte, error) {
10001 if self.TypeLen == 0 {
10002 return []byte("\"\""), nil
10003 } else {
10004 return []byte("\"" + self.GetOXMName() + "\""), nil
10005 }
10006}
10007
10008type OxmIdTunMetadata30Masked struct {
10009 *OxmId
10010}
10011
10012type IOxmIdTunMetadata30Masked interface {
10013 IOxmId
10014}
10015
10016func (self *OxmIdTunMetadata30Masked) Serialize(encoder *goloxi.Encoder) error {
10017 if err := self.OxmId.Serialize(encoder); err != nil {
10018 return err
10019 }
10020
10021 return nil
10022}
10023
10024func DecodeOxmIdTunMetadata30Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata30Masked, error) {
10025 _oxmidtunmetadata30masked := &OxmIdTunMetadata30Masked{OxmId: parent}
10026 return _oxmidtunmetadata30masked, nil
10027}
10028
10029func NewOxmIdTunMetadata30Masked() *OxmIdTunMetadata30Masked {
10030 obj := &OxmIdTunMetadata30Masked{
10031 OxmId: NewOxmId(101880),
10032 }
10033 return obj
10034}
10035func (self *OxmIdTunMetadata30Masked) GetOXMName() string {
10036 return "tun_metadata30_masked"
10037}
10038
10039func (self *OxmIdTunMetadata30Masked) MarshalJSON() ([]byte, error) {
10040 if self.TypeLen == 0 {
10041 return []byte("\"\""), nil
10042 } else {
10043 return []byte("\"" + self.GetOXMName() + "\""), nil
10044 }
10045}
10046
10047type OxmIdTunMetadata31 struct {
10048 *OxmId
10049}
10050
10051type IOxmIdTunMetadata31 interface {
10052 IOxmId
10053}
10054
10055func (self *OxmIdTunMetadata31) Serialize(encoder *goloxi.Encoder) error {
10056 if err := self.OxmId.Serialize(encoder); err != nil {
10057 return err
10058 }
10059
10060 return nil
10061}
10062
10063func DecodeOxmIdTunMetadata31(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata31, error) {
10064 _oxmidtunmetadata31 := &OxmIdTunMetadata31{OxmId: parent}
10065 return _oxmidtunmetadata31, nil
10066}
10067
10068func NewOxmIdTunMetadata31() *OxmIdTunMetadata31 {
10069 obj := &OxmIdTunMetadata31{
10070 OxmId: NewOxmId(102012),
10071 }
10072 return obj
10073}
10074func (self *OxmIdTunMetadata31) GetOXMName() string {
10075 return "tun_metadata31"
10076}
10077
10078func (self *OxmIdTunMetadata31) MarshalJSON() ([]byte, error) {
10079 if self.TypeLen == 0 {
10080 return []byte("\"\""), nil
10081 } else {
10082 return []byte("\"" + self.GetOXMName() + "\""), nil
10083 }
10084}
10085
10086type OxmIdTunMetadata31Masked struct {
10087 *OxmId
10088}
10089
10090type IOxmIdTunMetadata31Masked interface {
10091 IOxmId
10092}
10093
10094func (self *OxmIdTunMetadata31Masked) Serialize(encoder *goloxi.Encoder) error {
10095 if err := self.OxmId.Serialize(encoder); err != nil {
10096 return err
10097 }
10098
10099 return nil
10100}
10101
10102func DecodeOxmIdTunMetadata31Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata31Masked, error) {
10103 _oxmidtunmetadata31masked := &OxmIdTunMetadata31Masked{OxmId: parent}
10104 return _oxmidtunmetadata31masked, nil
10105}
10106
10107func NewOxmIdTunMetadata31Masked() *OxmIdTunMetadata31Masked {
10108 obj := &OxmIdTunMetadata31Masked{
10109 OxmId: NewOxmId(102392),
10110 }
10111 return obj
10112}
10113func (self *OxmIdTunMetadata31Masked) GetOXMName() string {
10114 return "tun_metadata31_masked"
10115}
10116
10117func (self *OxmIdTunMetadata31Masked) MarshalJSON() ([]byte, error) {
10118 if self.TypeLen == 0 {
10119 return []byte("\"\""), nil
10120 } else {
10121 return []byte("\"" + self.GetOXMName() + "\""), nil
10122 }
10123}
10124
10125type OxmIdTunMetadata32 struct {
10126 *OxmId
10127}
10128
10129type IOxmIdTunMetadata32 interface {
10130 IOxmId
10131}
10132
10133func (self *OxmIdTunMetadata32) Serialize(encoder *goloxi.Encoder) error {
10134 if err := self.OxmId.Serialize(encoder); err != nil {
10135 return err
10136 }
10137
10138 return nil
10139}
10140
10141func DecodeOxmIdTunMetadata32(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata32, error) {
10142 _oxmidtunmetadata32 := &OxmIdTunMetadata32{OxmId: parent}
10143 return _oxmidtunmetadata32, nil
10144}
10145
10146func NewOxmIdTunMetadata32() *OxmIdTunMetadata32 {
10147 obj := &OxmIdTunMetadata32{
10148 OxmId: NewOxmId(102524),
10149 }
10150 return obj
10151}
10152func (self *OxmIdTunMetadata32) GetOXMName() string {
10153 return "tun_metadata32"
10154}
10155
10156func (self *OxmIdTunMetadata32) MarshalJSON() ([]byte, error) {
10157 if self.TypeLen == 0 {
10158 return []byte("\"\""), nil
10159 } else {
10160 return []byte("\"" + self.GetOXMName() + "\""), nil
10161 }
10162}
10163
10164type OxmIdTunMetadata32Masked struct {
10165 *OxmId
10166}
10167
10168type IOxmIdTunMetadata32Masked interface {
10169 IOxmId
10170}
10171
10172func (self *OxmIdTunMetadata32Masked) Serialize(encoder *goloxi.Encoder) error {
10173 if err := self.OxmId.Serialize(encoder); err != nil {
10174 return err
10175 }
10176
10177 return nil
10178}
10179
10180func DecodeOxmIdTunMetadata32Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata32Masked, error) {
10181 _oxmidtunmetadata32masked := &OxmIdTunMetadata32Masked{OxmId: parent}
10182 return _oxmidtunmetadata32masked, nil
10183}
10184
10185func NewOxmIdTunMetadata32Masked() *OxmIdTunMetadata32Masked {
10186 obj := &OxmIdTunMetadata32Masked{
10187 OxmId: NewOxmId(102904),
10188 }
10189 return obj
10190}
10191func (self *OxmIdTunMetadata32Masked) GetOXMName() string {
10192 return "tun_metadata32_masked"
10193}
10194
10195func (self *OxmIdTunMetadata32Masked) MarshalJSON() ([]byte, error) {
10196 if self.TypeLen == 0 {
10197 return []byte("\"\""), nil
10198 } else {
10199 return []byte("\"" + self.GetOXMName() + "\""), nil
10200 }
10201}
10202
10203type OxmIdTunMetadata33 struct {
10204 *OxmId
10205}
10206
10207type IOxmIdTunMetadata33 interface {
10208 IOxmId
10209}
10210
10211func (self *OxmIdTunMetadata33) Serialize(encoder *goloxi.Encoder) error {
10212 if err := self.OxmId.Serialize(encoder); err != nil {
10213 return err
10214 }
10215
10216 return nil
10217}
10218
10219func DecodeOxmIdTunMetadata33(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata33, error) {
10220 _oxmidtunmetadata33 := &OxmIdTunMetadata33{OxmId: parent}
10221 return _oxmidtunmetadata33, nil
10222}
10223
10224func NewOxmIdTunMetadata33() *OxmIdTunMetadata33 {
10225 obj := &OxmIdTunMetadata33{
10226 OxmId: NewOxmId(103036),
10227 }
10228 return obj
10229}
10230func (self *OxmIdTunMetadata33) GetOXMName() string {
10231 return "tun_metadata33"
10232}
10233
10234func (self *OxmIdTunMetadata33) MarshalJSON() ([]byte, error) {
10235 if self.TypeLen == 0 {
10236 return []byte("\"\""), nil
10237 } else {
10238 return []byte("\"" + self.GetOXMName() + "\""), nil
10239 }
10240}
10241
10242type OxmIdTunMetadata33Masked struct {
10243 *OxmId
10244}
10245
10246type IOxmIdTunMetadata33Masked interface {
10247 IOxmId
10248}
10249
10250func (self *OxmIdTunMetadata33Masked) Serialize(encoder *goloxi.Encoder) error {
10251 if err := self.OxmId.Serialize(encoder); err != nil {
10252 return err
10253 }
10254
10255 return nil
10256}
10257
10258func DecodeOxmIdTunMetadata33Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata33Masked, error) {
10259 _oxmidtunmetadata33masked := &OxmIdTunMetadata33Masked{OxmId: parent}
10260 return _oxmidtunmetadata33masked, nil
10261}
10262
10263func NewOxmIdTunMetadata33Masked() *OxmIdTunMetadata33Masked {
10264 obj := &OxmIdTunMetadata33Masked{
10265 OxmId: NewOxmId(103416),
10266 }
10267 return obj
10268}
10269func (self *OxmIdTunMetadata33Masked) GetOXMName() string {
10270 return "tun_metadata33_masked"
10271}
10272
10273func (self *OxmIdTunMetadata33Masked) MarshalJSON() ([]byte, error) {
10274 if self.TypeLen == 0 {
10275 return []byte("\"\""), nil
10276 } else {
10277 return []byte("\"" + self.GetOXMName() + "\""), nil
10278 }
10279}
10280
10281type OxmIdTunMetadata34 struct {
10282 *OxmId
10283}
10284
10285type IOxmIdTunMetadata34 interface {
10286 IOxmId
10287}
10288
10289func (self *OxmIdTunMetadata34) Serialize(encoder *goloxi.Encoder) error {
10290 if err := self.OxmId.Serialize(encoder); err != nil {
10291 return err
10292 }
10293
10294 return nil
10295}
10296
10297func DecodeOxmIdTunMetadata34(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata34, error) {
10298 _oxmidtunmetadata34 := &OxmIdTunMetadata34{OxmId: parent}
10299 return _oxmidtunmetadata34, nil
10300}
10301
10302func NewOxmIdTunMetadata34() *OxmIdTunMetadata34 {
10303 obj := &OxmIdTunMetadata34{
10304 OxmId: NewOxmId(103548),
10305 }
10306 return obj
10307}
10308func (self *OxmIdTunMetadata34) GetOXMName() string {
10309 return "tun_metadata34"
10310}
10311
10312func (self *OxmIdTunMetadata34) MarshalJSON() ([]byte, error) {
10313 if self.TypeLen == 0 {
10314 return []byte("\"\""), nil
10315 } else {
10316 return []byte("\"" + self.GetOXMName() + "\""), nil
10317 }
10318}
10319
10320type OxmIdTunMetadata34Masked struct {
10321 *OxmId
10322}
10323
10324type IOxmIdTunMetadata34Masked interface {
10325 IOxmId
10326}
10327
10328func (self *OxmIdTunMetadata34Masked) Serialize(encoder *goloxi.Encoder) error {
10329 if err := self.OxmId.Serialize(encoder); err != nil {
10330 return err
10331 }
10332
10333 return nil
10334}
10335
10336func DecodeOxmIdTunMetadata34Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata34Masked, error) {
10337 _oxmidtunmetadata34masked := &OxmIdTunMetadata34Masked{OxmId: parent}
10338 return _oxmidtunmetadata34masked, nil
10339}
10340
10341func NewOxmIdTunMetadata34Masked() *OxmIdTunMetadata34Masked {
10342 obj := &OxmIdTunMetadata34Masked{
10343 OxmId: NewOxmId(103928),
10344 }
10345 return obj
10346}
10347func (self *OxmIdTunMetadata34Masked) GetOXMName() string {
10348 return "tun_metadata34_masked"
10349}
10350
10351func (self *OxmIdTunMetadata34Masked) MarshalJSON() ([]byte, error) {
10352 if self.TypeLen == 0 {
10353 return []byte("\"\""), nil
10354 } else {
10355 return []byte("\"" + self.GetOXMName() + "\""), nil
10356 }
10357}
10358
10359type OxmIdTunMetadata35 struct {
10360 *OxmId
10361}
10362
10363type IOxmIdTunMetadata35 interface {
10364 IOxmId
10365}
10366
10367func (self *OxmIdTunMetadata35) Serialize(encoder *goloxi.Encoder) error {
10368 if err := self.OxmId.Serialize(encoder); err != nil {
10369 return err
10370 }
10371
10372 return nil
10373}
10374
10375func DecodeOxmIdTunMetadata35(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata35, error) {
10376 _oxmidtunmetadata35 := &OxmIdTunMetadata35{OxmId: parent}
10377 return _oxmidtunmetadata35, nil
10378}
10379
10380func NewOxmIdTunMetadata35() *OxmIdTunMetadata35 {
10381 obj := &OxmIdTunMetadata35{
10382 OxmId: NewOxmId(104060),
10383 }
10384 return obj
10385}
10386func (self *OxmIdTunMetadata35) GetOXMName() string {
10387 return "tun_metadata35"
10388}
10389
10390func (self *OxmIdTunMetadata35) MarshalJSON() ([]byte, error) {
10391 if self.TypeLen == 0 {
10392 return []byte("\"\""), nil
10393 } else {
10394 return []byte("\"" + self.GetOXMName() + "\""), nil
10395 }
10396}
10397
10398type OxmIdTunMetadata35Masked struct {
10399 *OxmId
10400}
10401
10402type IOxmIdTunMetadata35Masked interface {
10403 IOxmId
10404}
10405
10406func (self *OxmIdTunMetadata35Masked) Serialize(encoder *goloxi.Encoder) error {
10407 if err := self.OxmId.Serialize(encoder); err != nil {
10408 return err
10409 }
10410
10411 return nil
10412}
10413
10414func DecodeOxmIdTunMetadata35Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata35Masked, error) {
10415 _oxmidtunmetadata35masked := &OxmIdTunMetadata35Masked{OxmId: parent}
10416 return _oxmidtunmetadata35masked, nil
10417}
10418
10419func NewOxmIdTunMetadata35Masked() *OxmIdTunMetadata35Masked {
10420 obj := &OxmIdTunMetadata35Masked{
10421 OxmId: NewOxmId(104440),
10422 }
10423 return obj
10424}
10425func (self *OxmIdTunMetadata35Masked) GetOXMName() string {
10426 return "tun_metadata35_masked"
10427}
10428
10429func (self *OxmIdTunMetadata35Masked) MarshalJSON() ([]byte, error) {
10430 if self.TypeLen == 0 {
10431 return []byte("\"\""), nil
10432 } else {
10433 return []byte("\"" + self.GetOXMName() + "\""), nil
10434 }
10435}
10436
10437type OxmIdTunMetadata36 struct {
10438 *OxmId
10439}
10440
10441type IOxmIdTunMetadata36 interface {
10442 IOxmId
10443}
10444
10445func (self *OxmIdTunMetadata36) Serialize(encoder *goloxi.Encoder) error {
10446 if err := self.OxmId.Serialize(encoder); err != nil {
10447 return err
10448 }
10449
10450 return nil
10451}
10452
10453func DecodeOxmIdTunMetadata36(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata36, error) {
10454 _oxmidtunmetadata36 := &OxmIdTunMetadata36{OxmId: parent}
10455 return _oxmidtunmetadata36, nil
10456}
10457
10458func NewOxmIdTunMetadata36() *OxmIdTunMetadata36 {
10459 obj := &OxmIdTunMetadata36{
10460 OxmId: NewOxmId(104572),
10461 }
10462 return obj
10463}
10464func (self *OxmIdTunMetadata36) GetOXMName() string {
10465 return "tun_metadata36"
10466}
10467
10468func (self *OxmIdTunMetadata36) MarshalJSON() ([]byte, error) {
10469 if self.TypeLen == 0 {
10470 return []byte("\"\""), nil
10471 } else {
10472 return []byte("\"" + self.GetOXMName() + "\""), nil
10473 }
10474}
10475
10476type OxmIdTunMetadata36Masked struct {
10477 *OxmId
10478}
10479
10480type IOxmIdTunMetadata36Masked interface {
10481 IOxmId
10482}
10483
10484func (self *OxmIdTunMetadata36Masked) Serialize(encoder *goloxi.Encoder) error {
10485 if err := self.OxmId.Serialize(encoder); err != nil {
10486 return err
10487 }
10488
10489 return nil
10490}
10491
10492func DecodeOxmIdTunMetadata36Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata36Masked, error) {
10493 _oxmidtunmetadata36masked := &OxmIdTunMetadata36Masked{OxmId: parent}
10494 return _oxmidtunmetadata36masked, nil
10495}
10496
10497func NewOxmIdTunMetadata36Masked() *OxmIdTunMetadata36Masked {
10498 obj := &OxmIdTunMetadata36Masked{
10499 OxmId: NewOxmId(104952),
10500 }
10501 return obj
10502}
10503func (self *OxmIdTunMetadata36Masked) GetOXMName() string {
10504 return "tun_metadata36_masked"
10505}
10506
10507func (self *OxmIdTunMetadata36Masked) MarshalJSON() ([]byte, error) {
10508 if self.TypeLen == 0 {
10509 return []byte("\"\""), nil
10510 } else {
10511 return []byte("\"" + self.GetOXMName() + "\""), nil
10512 }
10513}
10514
10515type OxmIdTunMetadata37 struct {
10516 *OxmId
10517}
10518
10519type IOxmIdTunMetadata37 interface {
10520 IOxmId
10521}
10522
10523func (self *OxmIdTunMetadata37) Serialize(encoder *goloxi.Encoder) error {
10524 if err := self.OxmId.Serialize(encoder); err != nil {
10525 return err
10526 }
10527
10528 return nil
10529}
10530
10531func DecodeOxmIdTunMetadata37(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata37, error) {
10532 _oxmidtunmetadata37 := &OxmIdTunMetadata37{OxmId: parent}
10533 return _oxmidtunmetadata37, nil
10534}
10535
10536func NewOxmIdTunMetadata37() *OxmIdTunMetadata37 {
10537 obj := &OxmIdTunMetadata37{
10538 OxmId: NewOxmId(105084),
10539 }
10540 return obj
10541}
10542func (self *OxmIdTunMetadata37) GetOXMName() string {
10543 return "tun_metadata37"
10544}
10545
10546func (self *OxmIdTunMetadata37) MarshalJSON() ([]byte, error) {
10547 if self.TypeLen == 0 {
10548 return []byte("\"\""), nil
10549 } else {
10550 return []byte("\"" + self.GetOXMName() + "\""), nil
10551 }
10552}
10553
10554type OxmIdTunMetadata37Masked struct {
10555 *OxmId
10556}
10557
10558type IOxmIdTunMetadata37Masked interface {
10559 IOxmId
10560}
10561
10562func (self *OxmIdTunMetadata37Masked) Serialize(encoder *goloxi.Encoder) error {
10563 if err := self.OxmId.Serialize(encoder); err != nil {
10564 return err
10565 }
10566
10567 return nil
10568}
10569
10570func DecodeOxmIdTunMetadata37Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata37Masked, error) {
10571 _oxmidtunmetadata37masked := &OxmIdTunMetadata37Masked{OxmId: parent}
10572 return _oxmidtunmetadata37masked, nil
10573}
10574
10575func NewOxmIdTunMetadata37Masked() *OxmIdTunMetadata37Masked {
10576 obj := &OxmIdTunMetadata37Masked{
10577 OxmId: NewOxmId(105464),
10578 }
10579 return obj
10580}
10581func (self *OxmIdTunMetadata37Masked) GetOXMName() string {
10582 return "tun_metadata37_masked"
10583}
10584
10585func (self *OxmIdTunMetadata37Masked) MarshalJSON() ([]byte, error) {
10586 if self.TypeLen == 0 {
10587 return []byte("\"\""), nil
10588 } else {
10589 return []byte("\"" + self.GetOXMName() + "\""), nil
10590 }
10591}
10592
10593type OxmIdTunMetadata38 struct {
10594 *OxmId
10595}
10596
10597type IOxmIdTunMetadata38 interface {
10598 IOxmId
10599}
10600
10601func (self *OxmIdTunMetadata38) Serialize(encoder *goloxi.Encoder) error {
10602 if err := self.OxmId.Serialize(encoder); err != nil {
10603 return err
10604 }
10605
10606 return nil
10607}
10608
10609func DecodeOxmIdTunMetadata38(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata38, error) {
10610 _oxmidtunmetadata38 := &OxmIdTunMetadata38{OxmId: parent}
10611 return _oxmidtunmetadata38, nil
10612}
10613
10614func NewOxmIdTunMetadata38() *OxmIdTunMetadata38 {
10615 obj := &OxmIdTunMetadata38{
10616 OxmId: NewOxmId(105596),
10617 }
10618 return obj
10619}
10620func (self *OxmIdTunMetadata38) GetOXMName() string {
10621 return "tun_metadata38"
10622}
10623
10624func (self *OxmIdTunMetadata38) MarshalJSON() ([]byte, error) {
10625 if self.TypeLen == 0 {
10626 return []byte("\"\""), nil
10627 } else {
10628 return []byte("\"" + self.GetOXMName() + "\""), nil
10629 }
10630}
10631
10632type OxmIdTunMetadata38Masked struct {
10633 *OxmId
10634}
10635
10636type IOxmIdTunMetadata38Masked interface {
10637 IOxmId
10638}
10639
10640func (self *OxmIdTunMetadata38Masked) Serialize(encoder *goloxi.Encoder) error {
10641 if err := self.OxmId.Serialize(encoder); err != nil {
10642 return err
10643 }
10644
10645 return nil
10646}
10647
10648func DecodeOxmIdTunMetadata38Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata38Masked, error) {
10649 _oxmidtunmetadata38masked := &OxmIdTunMetadata38Masked{OxmId: parent}
10650 return _oxmidtunmetadata38masked, nil
10651}
10652
10653func NewOxmIdTunMetadata38Masked() *OxmIdTunMetadata38Masked {
10654 obj := &OxmIdTunMetadata38Masked{
10655 OxmId: NewOxmId(105976),
10656 }
10657 return obj
10658}
10659func (self *OxmIdTunMetadata38Masked) GetOXMName() string {
10660 return "tun_metadata38_masked"
10661}
10662
10663func (self *OxmIdTunMetadata38Masked) MarshalJSON() ([]byte, error) {
10664 if self.TypeLen == 0 {
10665 return []byte("\"\""), nil
10666 } else {
10667 return []byte("\"" + self.GetOXMName() + "\""), nil
10668 }
10669}
10670
10671type OxmIdTunMetadata39 struct {
10672 *OxmId
10673}
10674
10675type IOxmIdTunMetadata39 interface {
10676 IOxmId
10677}
10678
10679func (self *OxmIdTunMetadata39) Serialize(encoder *goloxi.Encoder) error {
10680 if err := self.OxmId.Serialize(encoder); err != nil {
10681 return err
10682 }
10683
10684 return nil
10685}
10686
10687func DecodeOxmIdTunMetadata39(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata39, error) {
10688 _oxmidtunmetadata39 := &OxmIdTunMetadata39{OxmId: parent}
10689 return _oxmidtunmetadata39, nil
10690}
10691
10692func NewOxmIdTunMetadata39() *OxmIdTunMetadata39 {
10693 obj := &OxmIdTunMetadata39{
10694 OxmId: NewOxmId(106108),
10695 }
10696 return obj
10697}
10698func (self *OxmIdTunMetadata39) GetOXMName() string {
10699 return "tun_metadata39"
10700}
10701
10702func (self *OxmIdTunMetadata39) MarshalJSON() ([]byte, error) {
10703 if self.TypeLen == 0 {
10704 return []byte("\"\""), nil
10705 } else {
10706 return []byte("\"" + self.GetOXMName() + "\""), nil
10707 }
10708}
10709
10710type OxmIdTunMetadata39Masked struct {
10711 *OxmId
10712}
10713
10714type IOxmIdTunMetadata39Masked interface {
10715 IOxmId
10716}
10717
10718func (self *OxmIdTunMetadata39Masked) Serialize(encoder *goloxi.Encoder) error {
10719 if err := self.OxmId.Serialize(encoder); err != nil {
10720 return err
10721 }
10722
10723 return nil
10724}
10725
10726func DecodeOxmIdTunMetadata39Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata39Masked, error) {
10727 _oxmidtunmetadata39masked := &OxmIdTunMetadata39Masked{OxmId: parent}
10728 return _oxmidtunmetadata39masked, nil
10729}
10730
10731func NewOxmIdTunMetadata39Masked() *OxmIdTunMetadata39Masked {
10732 obj := &OxmIdTunMetadata39Masked{
10733 OxmId: NewOxmId(106488),
10734 }
10735 return obj
10736}
10737func (self *OxmIdTunMetadata39Masked) GetOXMName() string {
10738 return "tun_metadata39_masked"
10739}
10740
10741func (self *OxmIdTunMetadata39Masked) MarshalJSON() ([]byte, error) {
10742 if self.TypeLen == 0 {
10743 return []byte("\"\""), nil
10744 } else {
10745 return []byte("\"" + self.GetOXMName() + "\""), nil
10746 }
10747}
10748
10749type OxmIdTunMetadata3Masked struct {
10750 *OxmId
10751}
10752
10753type IOxmIdTunMetadata3Masked interface {
10754 IOxmId
10755}
10756
10757func (self *OxmIdTunMetadata3Masked) Serialize(encoder *goloxi.Encoder) error {
10758 if err := self.OxmId.Serialize(encoder); err != nil {
10759 return err
10760 }
10761
10762 return nil
10763}
10764
10765func DecodeOxmIdTunMetadata3Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata3Masked, error) {
10766 _oxmidtunmetadata3masked := &OxmIdTunMetadata3Masked{OxmId: parent}
10767 return _oxmidtunmetadata3masked, nil
10768}
10769
10770func NewOxmIdTunMetadata3Masked() *OxmIdTunMetadata3Masked {
10771 obj := &OxmIdTunMetadata3Masked{
10772 OxmId: NewOxmId(88056),
10773 }
10774 return obj
10775}
10776func (self *OxmIdTunMetadata3Masked) GetOXMName() string {
10777 return "tun_metadata3_masked"
10778}
10779
10780func (self *OxmIdTunMetadata3Masked) MarshalJSON() ([]byte, error) {
10781 if self.TypeLen == 0 {
10782 return []byte("\"\""), nil
10783 } else {
10784 return []byte("\"" + self.GetOXMName() + "\""), nil
10785 }
10786}
10787
10788type OxmIdTunMetadata4 struct {
10789 *OxmId
10790}
10791
10792type IOxmIdTunMetadata4 interface {
10793 IOxmId
10794}
10795
10796func (self *OxmIdTunMetadata4) Serialize(encoder *goloxi.Encoder) error {
10797 if err := self.OxmId.Serialize(encoder); err != nil {
10798 return err
10799 }
10800
10801 return nil
10802}
10803
10804func DecodeOxmIdTunMetadata4(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata4, error) {
10805 _oxmidtunmetadata4 := &OxmIdTunMetadata4{OxmId: parent}
10806 return _oxmidtunmetadata4, nil
10807}
10808
10809func NewOxmIdTunMetadata4() *OxmIdTunMetadata4 {
10810 obj := &OxmIdTunMetadata4{
10811 OxmId: NewOxmId(88188),
10812 }
10813 return obj
10814}
10815func (self *OxmIdTunMetadata4) GetOXMName() string {
10816 return "tun_metadata4"
10817}
10818
10819func (self *OxmIdTunMetadata4) MarshalJSON() ([]byte, error) {
10820 if self.TypeLen == 0 {
10821 return []byte("\"\""), nil
10822 } else {
10823 return []byte("\"" + self.GetOXMName() + "\""), nil
10824 }
10825}
10826
10827type OxmIdTunMetadata40 struct {
10828 *OxmId
10829}
10830
10831type IOxmIdTunMetadata40 interface {
10832 IOxmId
10833}
10834
10835func (self *OxmIdTunMetadata40) Serialize(encoder *goloxi.Encoder) error {
10836 if err := self.OxmId.Serialize(encoder); err != nil {
10837 return err
10838 }
10839
10840 return nil
10841}
10842
10843func DecodeOxmIdTunMetadata40(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata40, error) {
10844 _oxmidtunmetadata40 := &OxmIdTunMetadata40{OxmId: parent}
10845 return _oxmidtunmetadata40, nil
10846}
10847
10848func NewOxmIdTunMetadata40() *OxmIdTunMetadata40 {
10849 obj := &OxmIdTunMetadata40{
10850 OxmId: NewOxmId(106620),
10851 }
10852 return obj
10853}
10854func (self *OxmIdTunMetadata40) GetOXMName() string {
10855 return "tun_metadata40"
10856}
10857
10858func (self *OxmIdTunMetadata40) MarshalJSON() ([]byte, error) {
10859 if self.TypeLen == 0 {
10860 return []byte("\"\""), nil
10861 } else {
10862 return []byte("\"" + self.GetOXMName() + "\""), nil
10863 }
10864}
10865
10866type OxmIdTunMetadata40Masked struct {
10867 *OxmId
10868}
10869
10870type IOxmIdTunMetadata40Masked interface {
10871 IOxmId
10872}
10873
10874func (self *OxmIdTunMetadata40Masked) Serialize(encoder *goloxi.Encoder) error {
10875 if err := self.OxmId.Serialize(encoder); err != nil {
10876 return err
10877 }
10878
10879 return nil
10880}
10881
10882func DecodeOxmIdTunMetadata40Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata40Masked, error) {
10883 _oxmidtunmetadata40masked := &OxmIdTunMetadata40Masked{OxmId: parent}
10884 return _oxmidtunmetadata40masked, nil
10885}
10886
10887func NewOxmIdTunMetadata40Masked() *OxmIdTunMetadata40Masked {
10888 obj := &OxmIdTunMetadata40Masked{
10889 OxmId: NewOxmId(107000),
10890 }
10891 return obj
10892}
10893func (self *OxmIdTunMetadata40Masked) GetOXMName() string {
10894 return "tun_metadata40_masked"
10895}
10896
10897func (self *OxmIdTunMetadata40Masked) MarshalJSON() ([]byte, error) {
10898 if self.TypeLen == 0 {
10899 return []byte("\"\""), nil
10900 } else {
10901 return []byte("\"" + self.GetOXMName() + "\""), nil
10902 }
10903}
10904
10905type OxmIdTunMetadata41 struct {
10906 *OxmId
10907}
10908
10909type IOxmIdTunMetadata41 interface {
10910 IOxmId
10911}
10912
10913func (self *OxmIdTunMetadata41) Serialize(encoder *goloxi.Encoder) error {
10914 if err := self.OxmId.Serialize(encoder); err != nil {
10915 return err
10916 }
10917
10918 return nil
10919}
10920
10921func DecodeOxmIdTunMetadata41(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata41, error) {
10922 _oxmidtunmetadata41 := &OxmIdTunMetadata41{OxmId: parent}
10923 return _oxmidtunmetadata41, nil
10924}
10925
10926func NewOxmIdTunMetadata41() *OxmIdTunMetadata41 {
10927 obj := &OxmIdTunMetadata41{
10928 OxmId: NewOxmId(107132),
10929 }
10930 return obj
10931}
10932func (self *OxmIdTunMetadata41) GetOXMName() string {
10933 return "tun_metadata41"
10934}
10935
10936func (self *OxmIdTunMetadata41) MarshalJSON() ([]byte, error) {
10937 if self.TypeLen == 0 {
10938 return []byte("\"\""), nil
10939 } else {
10940 return []byte("\"" + self.GetOXMName() + "\""), nil
10941 }
10942}
10943
10944type OxmIdTunMetadata41Masked struct {
10945 *OxmId
10946}
10947
10948type IOxmIdTunMetadata41Masked interface {
10949 IOxmId
10950}
10951
10952func (self *OxmIdTunMetadata41Masked) Serialize(encoder *goloxi.Encoder) error {
10953 if err := self.OxmId.Serialize(encoder); err != nil {
10954 return err
10955 }
10956
10957 return nil
10958}
10959
10960func DecodeOxmIdTunMetadata41Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata41Masked, error) {
10961 _oxmidtunmetadata41masked := &OxmIdTunMetadata41Masked{OxmId: parent}
10962 return _oxmidtunmetadata41masked, nil
10963}
10964
10965func NewOxmIdTunMetadata41Masked() *OxmIdTunMetadata41Masked {
10966 obj := &OxmIdTunMetadata41Masked{
10967 OxmId: NewOxmId(107512),
10968 }
10969 return obj
10970}
10971func (self *OxmIdTunMetadata41Masked) GetOXMName() string {
10972 return "tun_metadata41_masked"
10973}
10974
10975func (self *OxmIdTunMetadata41Masked) MarshalJSON() ([]byte, error) {
10976 if self.TypeLen == 0 {
10977 return []byte("\"\""), nil
10978 } else {
10979 return []byte("\"" + self.GetOXMName() + "\""), nil
10980 }
10981}
10982
10983type OxmIdTunMetadata42 struct {
10984 *OxmId
10985}
10986
10987type IOxmIdTunMetadata42 interface {
10988 IOxmId
10989}
10990
10991func (self *OxmIdTunMetadata42) Serialize(encoder *goloxi.Encoder) error {
10992 if err := self.OxmId.Serialize(encoder); err != nil {
10993 return err
10994 }
10995
10996 return nil
10997}
10998
10999func DecodeOxmIdTunMetadata42(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata42, error) {
11000 _oxmidtunmetadata42 := &OxmIdTunMetadata42{OxmId: parent}
11001 return _oxmidtunmetadata42, nil
11002}
11003
11004func NewOxmIdTunMetadata42() *OxmIdTunMetadata42 {
11005 obj := &OxmIdTunMetadata42{
11006 OxmId: NewOxmId(107644),
11007 }
11008 return obj
11009}
11010func (self *OxmIdTunMetadata42) GetOXMName() string {
11011 return "tun_metadata42"
11012}
11013
11014func (self *OxmIdTunMetadata42) MarshalJSON() ([]byte, error) {
11015 if self.TypeLen == 0 {
11016 return []byte("\"\""), nil
11017 } else {
11018 return []byte("\"" + self.GetOXMName() + "\""), nil
11019 }
11020}
11021
11022type OxmIdTunMetadata42Masked struct {
11023 *OxmId
11024}
11025
11026type IOxmIdTunMetadata42Masked interface {
11027 IOxmId
11028}
11029
11030func (self *OxmIdTunMetadata42Masked) Serialize(encoder *goloxi.Encoder) error {
11031 if err := self.OxmId.Serialize(encoder); err != nil {
11032 return err
11033 }
11034
11035 return nil
11036}
11037
11038func DecodeOxmIdTunMetadata42Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata42Masked, error) {
11039 _oxmidtunmetadata42masked := &OxmIdTunMetadata42Masked{OxmId: parent}
11040 return _oxmidtunmetadata42masked, nil
11041}
11042
11043func NewOxmIdTunMetadata42Masked() *OxmIdTunMetadata42Masked {
11044 obj := &OxmIdTunMetadata42Masked{
11045 OxmId: NewOxmId(108024),
11046 }
11047 return obj
11048}
11049func (self *OxmIdTunMetadata42Masked) GetOXMName() string {
11050 return "tun_metadata42_masked"
11051}
11052
11053func (self *OxmIdTunMetadata42Masked) MarshalJSON() ([]byte, error) {
11054 if self.TypeLen == 0 {
11055 return []byte("\"\""), nil
11056 } else {
11057 return []byte("\"" + self.GetOXMName() + "\""), nil
11058 }
11059}
11060
11061type OxmIdTunMetadata43 struct {
11062 *OxmId
11063}
11064
11065type IOxmIdTunMetadata43 interface {
11066 IOxmId
11067}
11068
11069func (self *OxmIdTunMetadata43) Serialize(encoder *goloxi.Encoder) error {
11070 if err := self.OxmId.Serialize(encoder); err != nil {
11071 return err
11072 }
11073
11074 return nil
11075}
11076
11077func DecodeOxmIdTunMetadata43(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata43, error) {
11078 _oxmidtunmetadata43 := &OxmIdTunMetadata43{OxmId: parent}
11079 return _oxmidtunmetadata43, nil
11080}
11081
11082func NewOxmIdTunMetadata43() *OxmIdTunMetadata43 {
11083 obj := &OxmIdTunMetadata43{
11084 OxmId: NewOxmId(108156),
11085 }
11086 return obj
11087}
11088func (self *OxmIdTunMetadata43) GetOXMName() string {
11089 return "tun_metadata43"
11090}
11091
11092func (self *OxmIdTunMetadata43) MarshalJSON() ([]byte, error) {
11093 if self.TypeLen == 0 {
11094 return []byte("\"\""), nil
11095 } else {
11096 return []byte("\"" + self.GetOXMName() + "\""), nil
11097 }
11098}
11099
11100type OxmIdTunMetadata43Masked struct {
11101 *OxmId
11102}
11103
11104type IOxmIdTunMetadata43Masked interface {
11105 IOxmId
11106}
11107
11108func (self *OxmIdTunMetadata43Masked) Serialize(encoder *goloxi.Encoder) error {
11109 if err := self.OxmId.Serialize(encoder); err != nil {
11110 return err
11111 }
11112
11113 return nil
11114}
11115
11116func DecodeOxmIdTunMetadata43Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata43Masked, error) {
11117 _oxmidtunmetadata43masked := &OxmIdTunMetadata43Masked{OxmId: parent}
11118 return _oxmidtunmetadata43masked, nil
11119}
11120
11121func NewOxmIdTunMetadata43Masked() *OxmIdTunMetadata43Masked {
11122 obj := &OxmIdTunMetadata43Masked{
11123 OxmId: NewOxmId(108536),
11124 }
11125 return obj
11126}
11127func (self *OxmIdTunMetadata43Masked) GetOXMName() string {
11128 return "tun_metadata43_masked"
11129}
11130
11131func (self *OxmIdTunMetadata43Masked) MarshalJSON() ([]byte, error) {
11132 if self.TypeLen == 0 {
11133 return []byte("\"\""), nil
11134 } else {
11135 return []byte("\"" + self.GetOXMName() + "\""), nil
11136 }
11137}
11138
11139type OxmIdTunMetadata44 struct {
11140 *OxmId
11141}
11142
11143type IOxmIdTunMetadata44 interface {
11144 IOxmId
11145}
11146
11147func (self *OxmIdTunMetadata44) Serialize(encoder *goloxi.Encoder) error {
11148 if err := self.OxmId.Serialize(encoder); err != nil {
11149 return err
11150 }
11151
11152 return nil
11153}
11154
11155func DecodeOxmIdTunMetadata44(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata44, error) {
11156 _oxmidtunmetadata44 := &OxmIdTunMetadata44{OxmId: parent}
11157 return _oxmidtunmetadata44, nil
11158}
11159
11160func NewOxmIdTunMetadata44() *OxmIdTunMetadata44 {
11161 obj := &OxmIdTunMetadata44{
11162 OxmId: NewOxmId(108668),
11163 }
11164 return obj
11165}
11166func (self *OxmIdTunMetadata44) GetOXMName() string {
11167 return "tun_metadata44"
11168}
11169
11170func (self *OxmIdTunMetadata44) MarshalJSON() ([]byte, error) {
11171 if self.TypeLen == 0 {
11172 return []byte("\"\""), nil
11173 } else {
11174 return []byte("\"" + self.GetOXMName() + "\""), nil
11175 }
11176}
11177
11178type OxmIdTunMetadata44Masked struct {
11179 *OxmId
11180}
11181
11182type IOxmIdTunMetadata44Masked interface {
11183 IOxmId
11184}
11185
11186func (self *OxmIdTunMetadata44Masked) Serialize(encoder *goloxi.Encoder) error {
11187 if err := self.OxmId.Serialize(encoder); err != nil {
11188 return err
11189 }
11190
11191 return nil
11192}
11193
11194func DecodeOxmIdTunMetadata44Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata44Masked, error) {
11195 _oxmidtunmetadata44masked := &OxmIdTunMetadata44Masked{OxmId: parent}
11196 return _oxmidtunmetadata44masked, nil
11197}
11198
11199func NewOxmIdTunMetadata44Masked() *OxmIdTunMetadata44Masked {
11200 obj := &OxmIdTunMetadata44Masked{
11201 OxmId: NewOxmId(109048),
11202 }
11203 return obj
11204}
11205func (self *OxmIdTunMetadata44Masked) GetOXMName() string {
11206 return "tun_metadata44_masked"
11207}
11208
11209func (self *OxmIdTunMetadata44Masked) MarshalJSON() ([]byte, error) {
11210 if self.TypeLen == 0 {
11211 return []byte("\"\""), nil
11212 } else {
11213 return []byte("\"" + self.GetOXMName() + "\""), nil
11214 }
11215}
11216
11217type OxmIdTunMetadata45 struct {
11218 *OxmId
11219}
11220
11221type IOxmIdTunMetadata45 interface {
11222 IOxmId
11223}
11224
11225func (self *OxmIdTunMetadata45) Serialize(encoder *goloxi.Encoder) error {
11226 if err := self.OxmId.Serialize(encoder); err != nil {
11227 return err
11228 }
11229
11230 return nil
11231}
11232
11233func DecodeOxmIdTunMetadata45(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata45, error) {
11234 _oxmidtunmetadata45 := &OxmIdTunMetadata45{OxmId: parent}
11235 return _oxmidtunmetadata45, nil
11236}
11237
11238func NewOxmIdTunMetadata45() *OxmIdTunMetadata45 {
11239 obj := &OxmIdTunMetadata45{
11240 OxmId: NewOxmId(109180),
11241 }
11242 return obj
11243}
11244func (self *OxmIdTunMetadata45) GetOXMName() string {
11245 return "tun_metadata45"
11246}
11247
11248func (self *OxmIdTunMetadata45) MarshalJSON() ([]byte, error) {
11249 if self.TypeLen == 0 {
11250 return []byte("\"\""), nil
11251 } else {
11252 return []byte("\"" + self.GetOXMName() + "\""), nil
11253 }
11254}
11255
11256type OxmIdTunMetadata45Masked struct {
11257 *OxmId
11258}
11259
11260type IOxmIdTunMetadata45Masked interface {
11261 IOxmId
11262}
11263
11264func (self *OxmIdTunMetadata45Masked) Serialize(encoder *goloxi.Encoder) error {
11265 if err := self.OxmId.Serialize(encoder); err != nil {
11266 return err
11267 }
11268
11269 return nil
11270}
11271
11272func DecodeOxmIdTunMetadata45Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata45Masked, error) {
11273 _oxmidtunmetadata45masked := &OxmIdTunMetadata45Masked{OxmId: parent}
11274 return _oxmidtunmetadata45masked, nil
11275}
11276
11277func NewOxmIdTunMetadata45Masked() *OxmIdTunMetadata45Masked {
11278 obj := &OxmIdTunMetadata45Masked{
11279 OxmId: NewOxmId(109560),
11280 }
11281 return obj
11282}
11283func (self *OxmIdTunMetadata45Masked) GetOXMName() string {
11284 return "tun_metadata45_masked"
11285}
11286
11287func (self *OxmIdTunMetadata45Masked) MarshalJSON() ([]byte, error) {
11288 if self.TypeLen == 0 {
11289 return []byte("\"\""), nil
11290 } else {
11291 return []byte("\"" + self.GetOXMName() + "\""), nil
11292 }
11293}
11294
11295type OxmIdTunMetadata46 struct {
11296 *OxmId
11297}
11298
11299type IOxmIdTunMetadata46 interface {
11300 IOxmId
11301}
11302
11303func (self *OxmIdTunMetadata46) Serialize(encoder *goloxi.Encoder) error {
11304 if err := self.OxmId.Serialize(encoder); err != nil {
11305 return err
11306 }
11307
11308 return nil
11309}
11310
11311func DecodeOxmIdTunMetadata46(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata46, error) {
11312 _oxmidtunmetadata46 := &OxmIdTunMetadata46{OxmId: parent}
11313 return _oxmidtunmetadata46, nil
11314}
11315
11316func NewOxmIdTunMetadata46() *OxmIdTunMetadata46 {
11317 obj := &OxmIdTunMetadata46{
11318 OxmId: NewOxmId(109692),
11319 }
11320 return obj
11321}
11322func (self *OxmIdTunMetadata46) GetOXMName() string {
11323 return "tun_metadata46"
11324}
11325
11326func (self *OxmIdTunMetadata46) MarshalJSON() ([]byte, error) {
11327 if self.TypeLen == 0 {
11328 return []byte("\"\""), nil
11329 } else {
11330 return []byte("\"" + self.GetOXMName() + "\""), nil
11331 }
11332}
11333
11334type OxmIdTunMetadata46Masked struct {
11335 *OxmId
11336}
11337
11338type IOxmIdTunMetadata46Masked interface {
11339 IOxmId
11340}
11341
11342func (self *OxmIdTunMetadata46Masked) Serialize(encoder *goloxi.Encoder) error {
11343 if err := self.OxmId.Serialize(encoder); err != nil {
11344 return err
11345 }
11346
11347 return nil
11348}
11349
11350func DecodeOxmIdTunMetadata46Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata46Masked, error) {
11351 _oxmidtunmetadata46masked := &OxmIdTunMetadata46Masked{OxmId: parent}
11352 return _oxmidtunmetadata46masked, nil
11353}
11354
11355func NewOxmIdTunMetadata46Masked() *OxmIdTunMetadata46Masked {
11356 obj := &OxmIdTunMetadata46Masked{
11357 OxmId: NewOxmId(110072),
11358 }
11359 return obj
11360}
11361func (self *OxmIdTunMetadata46Masked) GetOXMName() string {
11362 return "tun_metadata46_masked"
11363}
11364
11365func (self *OxmIdTunMetadata46Masked) MarshalJSON() ([]byte, error) {
11366 if self.TypeLen == 0 {
11367 return []byte("\"\""), nil
11368 } else {
11369 return []byte("\"" + self.GetOXMName() + "\""), nil
11370 }
11371}
11372
11373type OxmIdTunMetadata47 struct {
11374 *OxmId
11375}
11376
11377type IOxmIdTunMetadata47 interface {
11378 IOxmId
11379}
11380
11381func (self *OxmIdTunMetadata47) Serialize(encoder *goloxi.Encoder) error {
11382 if err := self.OxmId.Serialize(encoder); err != nil {
11383 return err
11384 }
11385
11386 return nil
11387}
11388
11389func DecodeOxmIdTunMetadata47(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata47, error) {
11390 _oxmidtunmetadata47 := &OxmIdTunMetadata47{OxmId: parent}
11391 return _oxmidtunmetadata47, nil
11392}
11393
11394func NewOxmIdTunMetadata47() *OxmIdTunMetadata47 {
11395 obj := &OxmIdTunMetadata47{
11396 OxmId: NewOxmId(110204),
11397 }
11398 return obj
11399}
11400func (self *OxmIdTunMetadata47) GetOXMName() string {
11401 return "tun_metadata47"
11402}
11403
11404func (self *OxmIdTunMetadata47) MarshalJSON() ([]byte, error) {
11405 if self.TypeLen == 0 {
11406 return []byte("\"\""), nil
11407 } else {
11408 return []byte("\"" + self.GetOXMName() + "\""), nil
11409 }
11410}
11411
11412type OxmIdTunMetadata47Masked struct {
11413 *OxmId
11414}
11415
11416type IOxmIdTunMetadata47Masked interface {
11417 IOxmId
11418}
11419
11420func (self *OxmIdTunMetadata47Masked) Serialize(encoder *goloxi.Encoder) error {
11421 if err := self.OxmId.Serialize(encoder); err != nil {
11422 return err
11423 }
11424
11425 return nil
11426}
11427
11428func DecodeOxmIdTunMetadata47Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata47Masked, error) {
11429 _oxmidtunmetadata47masked := &OxmIdTunMetadata47Masked{OxmId: parent}
11430 return _oxmidtunmetadata47masked, nil
11431}
11432
11433func NewOxmIdTunMetadata47Masked() *OxmIdTunMetadata47Masked {
11434 obj := &OxmIdTunMetadata47Masked{
11435 OxmId: NewOxmId(110584),
11436 }
11437 return obj
11438}
11439func (self *OxmIdTunMetadata47Masked) GetOXMName() string {
11440 return "tun_metadata47_masked"
11441}
11442
11443func (self *OxmIdTunMetadata47Masked) MarshalJSON() ([]byte, error) {
11444 if self.TypeLen == 0 {
11445 return []byte("\"\""), nil
11446 } else {
11447 return []byte("\"" + self.GetOXMName() + "\""), nil
11448 }
11449}
11450
11451type OxmIdTunMetadata48 struct {
11452 *OxmId
11453}
11454
11455type IOxmIdTunMetadata48 interface {
11456 IOxmId
11457}
11458
11459func (self *OxmIdTunMetadata48) Serialize(encoder *goloxi.Encoder) error {
11460 if err := self.OxmId.Serialize(encoder); err != nil {
11461 return err
11462 }
11463
11464 return nil
11465}
11466
11467func DecodeOxmIdTunMetadata48(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata48, error) {
11468 _oxmidtunmetadata48 := &OxmIdTunMetadata48{OxmId: parent}
11469 return _oxmidtunmetadata48, nil
11470}
11471
11472func NewOxmIdTunMetadata48() *OxmIdTunMetadata48 {
11473 obj := &OxmIdTunMetadata48{
11474 OxmId: NewOxmId(110716),
11475 }
11476 return obj
11477}
11478func (self *OxmIdTunMetadata48) GetOXMName() string {
11479 return "tun_metadata48"
11480}
11481
11482func (self *OxmIdTunMetadata48) MarshalJSON() ([]byte, error) {
11483 if self.TypeLen == 0 {
11484 return []byte("\"\""), nil
11485 } else {
11486 return []byte("\"" + self.GetOXMName() + "\""), nil
11487 }
11488}
11489
11490type OxmIdTunMetadata48Masked struct {
11491 *OxmId
11492}
11493
11494type IOxmIdTunMetadata48Masked interface {
11495 IOxmId
11496}
11497
11498func (self *OxmIdTunMetadata48Masked) Serialize(encoder *goloxi.Encoder) error {
11499 if err := self.OxmId.Serialize(encoder); err != nil {
11500 return err
11501 }
11502
11503 return nil
11504}
11505
11506func DecodeOxmIdTunMetadata48Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata48Masked, error) {
11507 _oxmidtunmetadata48masked := &OxmIdTunMetadata48Masked{OxmId: parent}
11508 return _oxmidtunmetadata48masked, nil
11509}
11510
11511func NewOxmIdTunMetadata48Masked() *OxmIdTunMetadata48Masked {
11512 obj := &OxmIdTunMetadata48Masked{
11513 OxmId: NewOxmId(111096),
11514 }
11515 return obj
11516}
11517func (self *OxmIdTunMetadata48Masked) GetOXMName() string {
11518 return "tun_metadata48_masked"
11519}
11520
11521func (self *OxmIdTunMetadata48Masked) MarshalJSON() ([]byte, error) {
11522 if self.TypeLen == 0 {
11523 return []byte("\"\""), nil
11524 } else {
11525 return []byte("\"" + self.GetOXMName() + "\""), nil
11526 }
11527}
11528
11529type OxmIdTunMetadata49 struct {
11530 *OxmId
11531}
11532
11533type IOxmIdTunMetadata49 interface {
11534 IOxmId
11535}
11536
11537func (self *OxmIdTunMetadata49) Serialize(encoder *goloxi.Encoder) error {
11538 if err := self.OxmId.Serialize(encoder); err != nil {
11539 return err
11540 }
11541
11542 return nil
11543}
11544
11545func DecodeOxmIdTunMetadata49(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata49, error) {
11546 _oxmidtunmetadata49 := &OxmIdTunMetadata49{OxmId: parent}
11547 return _oxmidtunmetadata49, nil
11548}
11549
11550func NewOxmIdTunMetadata49() *OxmIdTunMetadata49 {
11551 obj := &OxmIdTunMetadata49{
11552 OxmId: NewOxmId(111228),
11553 }
11554 return obj
11555}
11556func (self *OxmIdTunMetadata49) GetOXMName() string {
11557 return "tun_metadata49"
11558}
11559
11560func (self *OxmIdTunMetadata49) MarshalJSON() ([]byte, error) {
11561 if self.TypeLen == 0 {
11562 return []byte("\"\""), nil
11563 } else {
11564 return []byte("\"" + self.GetOXMName() + "\""), nil
11565 }
11566}
11567
11568type OxmIdTunMetadata49Masked struct {
11569 *OxmId
11570}
11571
11572type IOxmIdTunMetadata49Masked interface {
11573 IOxmId
11574}
11575
11576func (self *OxmIdTunMetadata49Masked) Serialize(encoder *goloxi.Encoder) error {
11577 if err := self.OxmId.Serialize(encoder); err != nil {
11578 return err
11579 }
11580
11581 return nil
11582}
11583
11584func DecodeOxmIdTunMetadata49Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata49Masked, error) {
11585 _oxmidtunmetadata49masked := &OxmIdTunMetadata49Masked{OxmId: parent}
11586 return _oxmidtunmetadata49masked, nil
11587}
11588
11589func NewOxmIdTunMetadata49Masked() *OxmIdTunMetadata49Masked {
11590 obj := &OxmIdTunMetadata49Masked{
11591 OxmId: NewOxmId(111608),
11592 }
11593 return obj
11594}
11595func (self *OxmIdTunMetadata49Masked) GetOXMName() string {
11596 return "tun_metadata49_masked"
11597}
11598
11599func (self *OxmIdTunMetadata49Masked) MarshalJSON() ([]byte, error) {
11600 if self.TypeLen == 0 {
11601 return []byte("\"\""), nil
11602 } else {
11603 return []byte("\"" + self.GetOXMName() + "\""), nil
11604 }
11605}
11606
11607type OxmIdTunMetadata4Masked struct {
11608 *OxmId
11609}
11610
11611type IOxmIdTunMetadata4Masked interface {
11612 IOxmId
11613}
11614
11615func (self *OxmIdTunMetadata4Masked) Serialize(encoder *goloxi.Encoder) error {
11616 if err := self.OxmId.Serialize(encoder); err != nil {
11617 return err
11618 }
11619
11620 return nil
11621}
11622
11623func DecodeOxmIdTunMetadata4Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata4Masked, error) {
11624 _oxmidtunmetadata4masked := &OxmIdTunMetadata4Masked{OxmId: parent}
11625 return _oxmidtunmetadata4masked, nil
11626}
11627
11628func NewOxmIdTunMetadata4Masked() *OxmIdTunMetadata4Masked {
11629 obj := &OxmIdTunMetadata4Masked{
11630 OxmId: NewOxmId(88568),
11631 }
11632 return obj
11633}
11634func (self *OxmIdTunMetadata4Masked) GetOXMName() string {
11635 return "tun_metadata4_masked"
11636}
11637
11638func (self *OxmIdTunMetadata4Masked) MarshalJSON() ([]byte, error) {
11639 if self.TypeLen == 0 {
11640 return []byte("\"\""), nil
11641 } else {
11642 return []byte("\"" + self.GetOXMName() + "\""), nil
11643 }
11644}
11645
11646type OxmIdTunMetadata5 struct {
11647 *OxmId
11648}
11649
11650type IOxmIdTunMetadata5 interface {
11651 IOxmId
11652}
11653
11654func (self *OxmIdTunMetadata5) Serialize(encoder *goloxi.Encoder) error {
11655 if err := self.OxmId.Serialize(encoder); err != nil {
11656 return err
11657 }
11658
11659 return nil
11660}
11661
11662func DecodeOxmIdTunMetadata5(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata5, error) {
11663 _oxmidtunmetadata5 := &OxmIdTunMetadata5{OxmId: parent}
11664 return _oxmidtunmetadata5, nil
11665}
11666
11667func NewOxmIdTunMetadata5() *OxmIdTunMetadata5 {
11668 obj := &OxmIdTunMetadata5{
11669 OxmId: NewOxmId(88700),
11670 }
11671 return obj
11672}
11673func (self *OxmIdTunMetadata5) GetOXMName() string {
11674 return "tun_metadata5"
11675}
11676
11677func (self *OxmIdTunMetadata5) MarshalJSON() ([]byte, error) {
11678 if self.TypeLen == 0 {
11679 return []byte("\"\""), nil
11680 } else {
11681 return []byte("\"" + self.GetOXMName() + "\""), nil
11682 }
11683}
11684
11685type OxmIdTunMetadata50 struct {
11686 *OxmId
11687}
11688
11689type IOxmIdTunMetadata50 interface {
11690 IOxmId
11691}
11692
11693func (self *OxmIdTunMetadata50) Serialize(encoder *goloxi.Encoder) error {
11694 if err := self.OxmId.Serialize(encoder); err != nil {
11695 return err
11696 }
11697
11698 return nil
11699}
11700
11701func DecodeOxmIdTunMetadata50(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata50, error) {
11702 _oxmidtunmetadata50 := &OxmIdTunMetadata50{OxmId: parent}
11703 return _oxmidtunmetadata50, nil
11704}
11705
11706func NewOxmIdTunMetadata50() *OxmIdTunMetadata50 {
11707 obj := &OxmIdTunMetadata50{
11708 OxmId: NewOxmId(111740),
11709 }
11710 return obj
11711}
11712func (self *OxmIdTunMetadata50) GetOXMName() string {
11713 return "tun_metadata50"
11714}
11715
11716func (self *OxmIdTunMetadata50) MarshalJSON() ([]byte, error) {
11717 if self.TypeLen == 0 {
11718 return []byte("\"\""), nil
11719 } else {
11720 return []byte("\"" + self.GetOXMName() + "\""), nil
11721 }
11722}
11723
11724type OxmIdTunMetadata50Masked struct {
11725 *OxmId
11726}
11727
11728type IOxmIdTunMetadata50Masked interface {
11729 IOxmId
11730}
11731
11732func (self *OxmIdTunMetadata50Masked) Serialize(encoder *goloxi.Encoder) error {
11733 if err := self.OxmId.Serialize(encoder); err != nil {
11734 return err
11735 }
11736
11737 return nil
11738}
11739
11740func DecodeOxmIdTunMetadata50Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata50Masked, error) {
11741 _oxmidtunmetadata50masked := &OxmIdTunMetadata50Masked{OxmId: parent}
11742 return _oxmidtunmetadata50masked, nil
11743}
11744
11745func NewOxmIdTunMetadata50Masked() *OxmIdTunMetadata50Masked {
11746 obj := &OxmIdTunMetadata50Masked{
11747 OxmId: NewOxmId(112120),
11748 }
11749 return obj
11750}
11751func (self *OxmIdTunMetadata50Masked) GetOXMName() string {
11752 return "tun_metadata50_masked"
11753}
11754
11755func (self *OxmIdTunMetadata50Masked) MarshalJSON() ([]byte, error) {
11756 if self.TypeLen == 0 {
11757 return []byte("\"\""), nil
11758 } else {
11759 return []byte("\"" + self.GetOXMName() + "\""), nil
11760 }
11761}
11762
11763type OxmIdTunMetadata51 struct {
11764 *OxmId
11765}
11766
11767type IOxmIdTunMetadata51 interface {
11768 IOxmId
11769}
11770
11771func (self *OxmIdTunMetadata51) Serialize(encoder *goloxi.Encoder) error {
11772 if err := self.OxmId.Serialize(encoder); err != nil {
11773 return err
11774 }
11775
11776 return nil
11777}
11778
11779func DecodeOxmIdTunMetadata51(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata51, error) {
11780 _oxmidtunmetadata51 := &OxmIdTunMetadata51{OxmId: parent}
11781 return _oxmidtunmetadata51, nil
11782}
11783
11784func NewOxmIdTunMetadata51() *OxmIdTunMetadata51 {
11785 obj := &OxmIdTunMetadata51{
11786 OxmId: NewOxmId(112252),
11787 }
11788 return obj
11789}
11790func (self *OxmIdTunMetadata51) GetOXMName() string {
11791 return "tun_metadata51"
11792}
11793
11794func (self *OxmIdTunMetadata51) MarshalJSON() ([]byte, error) {
11795 if self.TypeLen == 0 {
11796 return []byte("\"\""), nil
11797 } else {
11798 return []byte("\"" + self.GetOXMName() + "\""), nil
11799 }
11800}
11801
11802type OxmIdTunMetadata51Masked struct {
11803 *OxmId
11804}
11805
11806type IOxmIdTunMetadata51Masked interface {
11807 IOxmId
11808}
11809
11810func (self *OxmIdTunMetadata51Masked) Serialize(encoder *goloxi.Encoder) error {
11811 if err := self.OxmId.Serialize(encoder); err != nil {
11812 return err
11813 }
11814
11815 return nil
11816}
11817
11818func DecodeOxmIdTunMetadata51Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata51Masked, error) {
11819 _oxmidtunmetadata51masked := &OxmIdTunMetadata51Masked{OxmId: parent}
11820 return _oxmidtunmetadata51masked, nil
11821}
11822
11823func NewOxmIdTunMetadata51Masked() *OxmIdTunMetadata51Masked {
11824 obj := &OxmIdTunMetadata51Masked{
11825 OxmId: NewOxmId(112632),
11826 }
11827 return obj
11828}
11829func (self *OxmIdTunMetadata51Masked) GetOXMName() string {
11830 return "tun_metadata51_masked"
11831}
11832
11833func (self *OxmIdTunMetadata51Masked) MarshalJSON() ([]byte, error) {
11834 if self.TypeLen == 0 {
11835 return []byte("\"\""), nil
11836 } else {
11837 return []byte("\"" + self.GetOXMName() + "\""), nil
11838 }
11839}
11840
11841type OxmIdTunMetadata52 struct {
11842 *OxmId
11843}
11844
11845type IOxmIdTunMetadata52 interface {
11846 IOxmId
11847}
11848
11849func (self *OxmIdTunMetadata52) Serialize(encoder *goloxi.Encoder) error {
11850 if err := self.OxmId.Serialize(encoder); err != nil {
11851 return err
11852 }
11853
11854 return nil
11855}
11856
11857func DecodeOxmIdTunMetadata52(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata52, error) {
11858 _oxmidtunmetadata52 := &OxmIdTunMetadata52{OxmId: parent}
11859 return _oxmidtunmetadata52, nil
11860}
11861
11862func NewOxmIdTunMetadata52() *OxmIdTunMetadata52 {
11863 obj := &OxmIdTunMetadata52{
11864 OxmId: NewOxmId(112764),
11865 }
11866 return obj
11867}
11868func (self *OxmIdTunMetadata52) GetOXMName() string {
11869 return "tun_metadata52"
11870}
11871
11872func (self *OxmIdTunMetadata52) MarshalJSON() ([]byte, error) {
11873 if self.TypeLen == 0 {
11874 return []byte("\"\""), nil
11875 } else {
11876 return []byte("\"" + self.GetOXMName() + "\""), nil
11877 }
11878}
11879
11880type OxmIdTunMetadata52Masked struct {
11881 *OxmId
11882}
11883
11884type IOxmIdTunMetadata52Masked interface {
11885 IOxmId
11886}
11887
11888func (self *OxmIdTunMetadata52Masked) Serialize(encoder *goloxi.Encoder) error {
11889 if err := self.OxmId.Serialize(encoder); err != nil {
11890 return err
11891 }
11892
11893 return nil
11894}
11895
11896func DecodeOxmIdTunMetadata52Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata52Masked, error) {
11897 _oxmidtunmetadata52masked := &OxmIdTunMetadata52Masked{OxmId: parent}
11898 return _oxmidtunmetadata52masked, nil
11899}
11900
11901func NewOxmIdTunMetadata52Masked() *OxmIdTunMetadata52Masked {
11902 obj := &OxmIdTunMetadata52Masked{
11903 OxmId: NewOxmId(113144),
11904 }
11905 return obj
11906}
11907func (self *OxmIdTunMetadata52Masked) GetOXMName() string {
11908 return "tun_metadata52_masked"
11909}
11910
11911func (self *OxmIdTunMetadata52Masked) MarshalJSON() ([]byte, error) {
11912 if self.TypeLen == 0 {
11913 return []byte("\"\""), nil
11914 } else {
11915 return []byte("\"" + self.GetOXMName() + "\""), nil
11916 }
11917}
11918
11919type OxmIdTunMetadata53 struct {
11920 *OxmId
11921}
11922
11923type IOxmIdTunMetadata53 interface {
11924 IOxmId
11925}
11926
11927func (self *OxmIdTunMetadata53) Serialize(encoder *goloxi.Encoder) error {
11928 if err := self.OxmId.Serialize(encoder); err != nil {
11929 return err
11930 }
11931
11932 return nil
11933}
11934
11935func DecodeOxmIdTunMetadata53(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata53, error) {
11936 _oxmidtunmetadata53 := &OxmIdTunMetadata53{OxmId: parent}
11937 return _oxmidtunmetadata53, nil
11938}
11939
11940func NewOxmIdTunMetadata53() *OxmIdTunMetadata53 {
11941 obj := &OxmIdTunMetadata53{
11942 OxmId: NewOxmId(113276),
11943 }
11944 return obj
11945}
11946func (self *OxmIdTunMetadata53) GetOXMName() string {
11947 return "tun_metadata53"
11948}
11949
11950func (self *OxmIdTunMetadata53) MarshalJSON() ([]byte, error) {
11951 if self.TypeLen == 0 {
11952 return []byte("\"\""), nil
11953 } else {
11954 return []byte("\"" + self.GetOXMName() + "\""), nil
11955 }
11956}
11957
11958type OxmIdTunMetadata53Masked struct {
11959 *OxmId
11960}
11961
11962type IOxmIdTunMetadata53Masked interface {
11963 IOxmId
11964}
11965
11966func (self *OxmIdTunMetadata53Masked) Serialize(encoder *goloxi.Encoder) error {
11967 if err := self.OxmId.Serialize(encoder); err != nil {
11968 return err
11969 }
11970
11971 return nil
11972}
11973
11974func DecodeOxmIdTunMetadata53Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata53Masked, error) {
11975 _oxmidtunmetadata53masked := &OxmIdTunMetadata53Masked{OxmId: parent}
11976 return _oxmidtunmetadata53masked, nil
11977}
11978
11979func NewOxmIdTunMetadata53Masked() *OxmIdTunMetadata53Masked {
11980 obj := &OxmIdTunMetadata53Masked{
11981 OxmId: NewOxmId(113656),
11982 }
11983 return obj
11984}
11985func (self *OxmIdTunMetadata53Masked) GetOXMName() string {
11986 return "tun_metadata53_masked"
11987}
11988
11989func (self *OxmIdTunMetadata53Masked) MarshalJSON() ([]byte, error) {
11990 if self.TypeLen == 0 {
11991 return []byte("\"\""), nil
11992 } else {
11993 return []byte("\"" + self.GetOXMName() + "\""), nil
11994 }
11995}
11996
11997type OxmIdTunMetadata54 struct {
11998 *OxmId
11999}
12000
12001type IOxmIdTunMetadata54 interface {
12002 IOxmId
12003}
12004
12005func (self *OxmIdTunMetadata54) Serialize(encoder *goloxi.Encoder) error {
12006 if err := self.OxmId.Serialize(encoder); err != nil {
12007 return err
12008 }
12009
12010 return nil
12011}
12012
12013func DecodeOxmIdTunMetadata54(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata54, error) {
12014 _oxmidtunmetadata54 := &OxmIdTunMetadata54{OxmId: parent}
12015 return _oxmidtunmetadata54, nil
12016}
12017
12018func NewOxmIdTunMetadata54() *OxmIdTunMetadata54 {
12019 obj := &OxmIdTunMetadata54{
12020 OxmId: NewOxmId(113788),
12021 }
12022 return obj
12023}
12024func (self *OxmIdTunMetadata54) GetOXMName() string {
12025 return "tun_metadata54"
12026}
12027
12028func (self *OxmIdTunMetadata54) MarshalJSON() ([]byte, error) {
12029 if self.TypeLen == 0 {
12030 return []byte("\"\""), nil
12031 } else {
12032 return []byte("\"" + self.GetOXMName() + "\""), nil
12033 }
12034}
12035
12036type OxmIdTunMetadata54Masked struct {
12037 *OxmId
12038}
12039
12040type IOxmIdTunMetadata54Masked interface {
12041 IOxmId
12042}
12043
12044func (self *OxmIdTunMetadata54Masked) Serialize(encoder *goloxi.Encoder) error {
12045 if err := self.OxmId.Serialize(encoder); err != nil {
12046 return err
12047 }
12048
12049 return nil
12050}
12051
12052func DecodeOxmIdTunMetadata54Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata54Masked, error) {
12053 _oxmidtunmetadata54masked := &OxmIdTunMetadata54Masked{OxmId: parent}
12054 return _oxmidtunmetadata54masked, nil
12055}
12056
12057func NewOxmIdTunMetadata54Masked() *OxmIdTunMetadata54Masked {
12058 obj := &OxmIdTunMetadata54Masked{
12059 OxmId: NewOxmId(114168),
12060 }
12061 return obj
12062}
12063func (self *OxmIdTunMetadata54Masked) GetOXMName() string {
12064 return "tun_metadata54_masked"
12065}
12066
12067func (self *OxmIdTunMetadata54Masked) MarshalJSON() ([]byte, error) {
12068 if self.TypeLen == 0 {
12069 return []byte("\"\""), nil
12070 } else {
12071 return []byte("\"" + self.GetOXMName() + "\""), nil
12072 }
12073}
12074
12075type OxmIdTunMetadata55 struct {
12076 *OxmId
12077}
12078
12079type IOxmIdTunMetadata55 interface {
12080 IOxmId
12081}
12082
12083func (self *OxmIdTunMetadata55) Serialize(encoder *goloxi.Encoder) error {
12084 if err := self.OxmId.Serialize(encoder); err != nil {
12085 return err
12086 }
12087
12088 return nil
12089}
12090
12091func DecodeOxmIdTunMetadata55(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata55, error) {
12092 _oxmidtunmetadata55 := &OxmIdTunMetadata55{OxmId: parent}
12093 return _oxmidtunmetadata55, nil
12094}
12095
12096func NewOxmIdTunMetadata55() *OxmIdTunMetadata55 {
12097 obj := &OxmIdTunMetadata55{
12098 OxmId: NewOxmId(114300),
12099 }
12100 return obj
12101}
12102func (self *OxmIdTunMetadata55) GetOXMName() string {
12103 return "tun_metadata55"
12104}
12105
12106func (self *OxmIdTunMetadata55) MarshalJSON() ([]byte, error) {
12107 if self.TypeLen == 0 {
12108 return []byte("\"\""), nil
12109 } else {
12110 return []byte("\"" + self.GetOXMName() + "\""), nil
12111 }
12112}
12113
12114type OxmIdTunMetadata55Masked struct {
12115 *OxmId
12116}
12117
12118type IOxmIdTunMetadata55Masked interface {
12119 IOxmId
12120}
12121
12122func (self *OxmIdTunMetadata55Masked) Serialize(encoder *goloxi.Encoder) error {
12123 if err := self.OxmId.Serialize(encoder); err != nil {
12124 return err
12125 }
12126
12127 return nil
12128}
12129
12130func DecodeOxmIdTunMetadata55Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata55Masked, error) {
12131 _oxmidtunmetadata55masked := &OxmIdTunMetadata55Masked{OxmId: parent}
12132 return _oxmidtunmetadata55masked, nil
12133}
12134
12135func NewOxmIdTunMetadata55Masked() *OxmIdTunMetadata55Masked {
12136 obj := &OxmIdTunMetadata55Masked{
12137 OxmId: NewOxmId(114680),
12138 }
12139 return obj
12140}
12141func (self *OxmIdTunMetadata55Masked) GetOXMName() string {
12142 return "tun_metadata55_masked"
12143}
12144
12145func (self *OxmIdTunMetadata55Masked) MarshalJSON() ([]byte, error) {
12146 if self.TypeLen == 0 {
12147 return []byte("\"\""), nil
12148 } else {
12149 return []byte("\"" + self.GetOXMName() + "\""), nil
12150 }
12151}
12152
12153type OxmIdTunMetadata56 struct {
12154 *OxmId
12155}
12156
12157type IOxmIdTunMetadata56 interface {
12158 IOxmId
12159}
12160
12161func (self *OxmIdTunMetadata56) Serialize(encoder *goloxi.Encoder) error {
12162 if err := self.OxmId.Serialize(encoder); err != nil {
12163 return err
12164 }
12165
12166 return nil
12167}
12168
12169func DecodeOxmIdTunMetadata56(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata56, error) {
12170 _oxmidtunmetadata56 := &OxmIdTunMetadata56{OxmId: parent}
12171 return _oxmidtunmetadata56, nil
12172}
12173
12174func NewOxmIdTunMetadata56() *OxmIdTunMetadata56 {
12175 obj := &OxmIdTunMetadata56{
12176 OxmId: NewOxmId(114812),
12177 }
12178 return obj
12179}
12180func (self *OxmIdTunMetadata56) GetOXMName() string {
12181 return "tun_metadata56"
12182}
12183
12184func (self *OxmIdTunMetadata56) MarshalJSON() ([]byte, error) {
12185 if self.TypeLen == 0 {
12186 return []byte("\"\""), nil
12187 } else {
12188 return []byte("\"" + self.GetOXMName() + "\""), nil
12189 }
12190}
12191
12192type OxmIdTunMetadata56Masked struct {
12193 *OxmId
12194}
12195
12196type IOxmIdTunMetadata56Masked interface {
12197 IOxmId
12198}
12199
12200func (self *OxmIdTunMetadata56Masked) Serialize(encoder *goloxi.Encoder) error {
12201 if err := self.OxmId.Serialize(encoder); err != nil {
12202 return err
12203 }
12204
12205 return nil
12206}
12207
12208func DecodeOxmIdTunMetadata56Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata56Masked, error) {
12209 _oxmidtunmetadata56masked := &OxmIdTunMetadata56Masked{OxmId: parent}
12210 return _oxmidtunmetadata56masked, nil
12211}
12212
12213func NewOxmIdTunMetadata56Masked() *OxmIdTunMetadata56Masked {
12214 obj := &OxmIdTunMetadata56Masked{
12215 OxmId: NewOxmId(115192),
12216 }
12217 return obj
12218}
12219func (self *OxmIdTunMetadata56Masked) GetOXMName() string {
12220 return "tun_metadata56_masked"
12221}
12222
12223func (self *OxmIdTunMetadata56Masked) MarshalJSON() ([]byte, error) {
12224 if self.TypeLen == 0 {
12225 return []byte("\"\""), nil
12226 } else {
12227 return []byte("\"" + self.GetOXMName() + "\""), nil
12228 }
12229}
12230
12231type OxmIdTunMetadata57 struct {
12232 *OxmId
12233}
12234
12235type IOxmIdTunMetadata57 interface {
12236 IOxmId
12237}
12238
12239func (self *OxmIdTunMetadata57) Serialize(encoder *goloxi.Encoder) error {
12240 if err := self.OxmId.Serialize(encoder); err != nil {
12241 return err
12242 }
12243
12244 return nil
12245}
12246
12247func DecodeOxmIdTunMetadata57(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata57, error) {
12248 _oxmidtunmetadata57 := &OxmIdTunMetadata57{OxmId: parent}
12249 return _oxmidtunmetadata57, nil
12250}
12251
12252func NewOxmIdTunMetadata57() *OxmIdTunMetadata57 {
12253 obj := &OxmIdTunMetadata57{
12254 OxmId: NewOxmId(115324),
12255 }
12256 return obj
12257}
12258func (self *OxmIdTunMetadata57) GetOXMName() string {
12259 return "tun_metadata57"
12260}
12261
12262func (self *OxmIdTunMetadata57) MarshalJSON() ([]byte, error) {
12263 if self.TypeLen == 0 {
12264 return []byte("\"\""), nil
12265 } else {
12266 return []byte("\"" + self.GetOXMName() + "\""), nil
12267 }
12268}
12269
12270type OxmIdTunMetadata57Masked struct {
12271 *OxmId
12272}
12273
12274type IOxmIdTunMetadata57Masked interface {
12275 IOxmId
12276}
12277
12278func (self *OxmIdTunMetadata57Masked) Serialize(encoder *goloxi.Encoder) error {
12279 if err := self.OxmId.Serialize(encoder); err != nil {
12280 return err
12281 }
12282
12283 return nil
12284}
12285
12286func DecodeOxmIdTunMetadata57Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata57Masked, error) {
12287 _oxmidtunmetadata57masked := &OxmIdTunMetadata57Masked{OxmId: parent}
12288 return _oxmidtunmetadata57masked, nil
12289}
12290
12291func NewOxmIdTunMetadata57Masked() *OxmIdTunMetadata57Masked {
12292 obj := &OxmIdTunMetadata57Masked{
12293 OxmId: NewOxmId(115704),
12294 }
12295 return obj
12296}
12297func (self *OxmIdTunMetadata57Masked) GetOXMName() string {
12298 return "tun_metadata57_masked"
12299}
12300
12301func (self *OxmIdTunMetadata57Masked) MarshalJSON() ([]byte, error) {
12302 if self.TypeLen == 0 {
12303 return []byte("\"\""), nil
12304 } else {
12305 return []byte("\"" + self.GetOXMName() + "\""), nil
12306 }
12307}
12308
12309type OxmIdTunMetadata58 struct {
12310 *OxmId
12311}
12312
12313type IOxmIdTunMetadata58 interface {
12314 IOxmId
12315}
12316
12317func (self *OxmIdTunMetadata58) Serialize(encoder *goloxi.Encoder) error {
12318 if err := self.OxmId.Serialize(encoder); err != nil {
12319 return err
12320 }
12321
12322 return nil
12323}
12324
12325func DecodeOxmIdTunMetadata58(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata58, error) {
12326 _oxmidtunmetadata58 := &OxmIdTunMetadata58{OxmId: parent}
12327 return _oxmidtunmetadata58, nil
12328}
12329
12330func NewOxmIdTunMetadata58() *OxmIdTunMetadata58 {
12331 obj := &OxmIdTunMetadata58{
12332 OxmId: NewOxmId(115836),
12333 }
12334 return obj
12335}
12336func (self *OxmIdTunMetadata58) GetOXMName() string {
12337 return "tun_metadata58"
12338}
12339
12340func (self *OxmIdTunMetadata58) MarshalJSON() ([]byte, error) {
12341 if self.TypeLen == 0 {
12342 return []byte("\"\""), nil
12343 } else {
12344 return []byte("\"" + self.GetOXMName() + "\""), nil
12345 }
12346}
12347
12348type OxmIdTunMetadata58Masked struct {
12349 *OxmId
12350}
12351
12352type IOxmIdTunMetadata58Masked interface {
12353 IOxmId
12354}
12355
12356func (self *OxmIdTunMetadata58Masked) Serialize(encoder *goloxi.Encoder) error {
12357 if err := self.OxmId.Serialize(encoder); err != nil {
12358 return err
12359 }
12360
12361 return nil
12362}
12363
12364func DecodeOxmIdTunMetadata58Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata58Masked, error) {
12365 _oxmidtunmetadata58masked := &OxmIdTunMetadata58Masked{OxmId: parent}
12366 return _oxmidtunmetadata58masked, nil
12367}
12368
12369func NewOxmIdTunMetadata58Masked() *OxmIdTunMetadata58Masked {
12370 obj := &OxmIdTunMetadata58Masked{
12371 OxmId: NewOxmId(116216),
12372 }
12373 return obj
12374}
12375func (self *OxmIdTunMetadata58Masked) GetOXMName() string {
12376 return "tun_metadata58_masked"
12377}
12378
12379func (self *OxmIdTunMetadata58Masked) MarshalJSON() ([]byte, error) {
12380 if self.TypeLen == 0 {
12381 return []byte("\"\""), nil
12382 } else {
12383 return []byte("\"" + self.GetOXMName() + "\""), nil
12384 }
12385}
12386
12387type OxmIdTunMetadata59 struct {
12388 *OxmId
12389}
12390
12391type IOxmIdTunMetadata59 interface {
12392 IOxmId
12393}
12394
12395func (self *OxmIdTunMetadata59) Serialize(encoder *goloxi.Encoder) error {
12396 if err := self.OxmId.Serialize(encoder); err != nil {
12397 return err
12398 }
12399
12400 return nil
12401}
12402
12403func DecodeOxmIdTunMetadata59(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata59, error) {
12404 _oxmidtunmetadata59 := &OxmIdTunMetadata59{OxmId: parent}
12405 return _oxmidtunmetadata59, nil
12406}
12407
12408func NewOxmIdTunMetadata59() *OxmIdTunMetadata59 {
12409 obj := &OxmIdTunMetadata59{
12410 OxmId: NewOxmId(116348),
12411 }
12412 return obj
12413}
12414func (self *OxmIdTunMetadata59) GetOXMName() string {
12415 return "tun_metadata59"
12416}
12417
12418func (self *OxmIdTunMetadata59) MarshalJSON() ([]byte, error) {
12419 if self.TypeLen == 0 {
12420 return []byte("\"\""), nil
12421 } else {
12422 return []byte("\"" + self.GetOXMName() + "\""), nil
12423 }
12424}
12425
12426type OxmIdTunMetadata59Masked struct {
12427 *OxmId
12428}
12429
12430type IOxmIdTunMetadata59Masked interface {
12431 IOxmId
12432}
12433
12434func (self *OxmIdTunMetadata59Masked) Serialize(encoder *goloxi.Encoder) error {
12435 if err := self.OxmId.Serialize(encoder); err != nil {
12436 return err
12437 }
12438
12439 return nil
12440}
12441
12442func DecodeOxmIdTunMetadata59Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata59Masked, error) {
12443 _oxmidtunmetadata59masked := &OxmIdTunMetadata59Masked{OxmId: parent}
12444 return _oxmidtunmetadata59masked, nil
12445}
12446
12447func NewOxmIdTunMetadata59Masked() *OxmIdTunMetadata59Masked {
12448 obj := &OxmIdTunMetadata59Masked{
12449 OxmId: NewOxmId(116728),
12450 }
12451 return obj
12452}
12453func (self *OxmIdTunMetadata59Masked) GetOXMName() string {
12454 return "tun_metadata59_masked"
12455}
12456
12457func (self *OxmIdTunMetadata59Masked) MarshalJSON() ([]byte, error) {
12458 if self.TypeLen == 0 {
12459 return []byte("\"\""), nil
12460 } else {
12461 return []byte("\"" + self.GetOXMName() + "\""), nil
12462 }
12463}
12464
12465type OxmIdTunMetadata5Masked struct {
12466 *OxmId
12467}
12468
12469type IOxmIdTunMetadata5Masked interface {
12470 IOxmId
12471}
12472
12473func (self *OxmIdTunMetadata5Masked) Serialize(encoder *goloxi.Encoder) error {
12474 if err := self.OxmId.Serialize(encoder); err != nil {
12475 return err
12476 }
12477
12478 return nil
12479}
12480
12481func DecodeOxmIdTunMetadata5Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata5Masked, error) {
12482 _oxmidtunmetadata5masked := &OxmIdTunMetadata5Masked{OxmId: parent}
12483 return _oxmidtunmetadata5masked, nil
12484}
12485
12486func NewOxmIdTunMetadata5Masked() *OxmIdTunMetadata5Masked {
12487 obj := &OxmIdTunMetadata5Masked{
12488 OxmId: NewOxmId(89080),
12489 }
12490 return obj
12491}
12492func (self *OxmIdTunMetadata5Masked) GetOXMName() string {
12493 return "tun_metadata5_masked"
12494}
12495
12496func (self *OxmIdTunMetadata5Masked) MarshalJSON() ([]byte, error) {
12497 if self.TypeLen == 0 {
12498 return []byte("\"\""), nil
12499 } else {
12500 return []byte("\"" + self.GetOXMName() + "\""), nil
12501 }
12502}
12503
12504type OxmIdTunMetadata6 struct {
12505 *OxmId
12506}
12507
12508type IOxmIdTunMetadata6 interface {
12509 IOxmId
12510}
12511
12512func (self *OxmIdTunMetadata6) Serialize(encoder *goloxi.Encoder) error {
12513 if err := self.OxmId.Serialize(encoder); err != nil {
12514 return err
12515 }
12516
12517 return nil
12518}
12519
12520func DecodeOxmIdTunMetadata6(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata6, error) {
12521 _oxmidtunmetadata6 := &OxmIdTunMetadata6{OxmId: parent}
12522 return _oxmidtunmetadata6, nil
12523}
12524
12525func NewOxmIdTunMetadata6() *OxmIdTunMetadata6 {
12526 obj := &OxmIdTunMetadata6{
12527 OxmId: NewOxmId(89212),
12528 }
12529 return obj
12530}
12531func (self *OxmIdTunMetadata6) GetOXMName() string {
12532 return "tun_metadata6"
12533}
12534
12535func (self *OxmIdTunMetadata6) MarshalJSON() ([]byte, error) {
12536 if self.TypeLen == 0 {
12537 return []byte("\"\""), nil
12538 } else {
12539 return []byte("\"" + self.GetOXMName() + "\""), nil
12540 }
12541}
12542
12543type OxmIdTunMetadata60 struct {
12544 *OxmId
12545}
12546
12547type IOxmIdTunMetadata60 interface {
12548 IOxmId
12549}
12550
12551func (self *OxmIdTunMetadata60) Serialize(encoder *goloxi.Encoder) error {
12552 if err := self.OxmId.Serialize(encoder); err != nil {
12553 return err
12554 }
12555
12556 return nil
12557}
12558
12559func DecodeOxmIdTunMetadata60(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata60, error) {
12560 _oxmidtunmetadata60 := &OxmIdTunMetadata60{OxmId: parent}
12561 return _oxmidtunmetadata60, nil
12562}
12563
12564func NewOxmIdTunMetadata60() *OxmIdTunMetadata60 {
12565 obj := &OxmIdTunMetadata60{
12566 OxmId: NewOxmId(116860),
12567 }
12568 return obj
12569}
12570func (self *OxmIdTunMetadata60) GetOXMName() string {
12571 return "tun_metadata60"
12572}
12573
12574func (self *OxmIdTunMetadata60) MarshalJSON() ([]byte, error) {
12575 if self.TypeLen == 0 {
12576 return []byte("\"\""), nil
12577 } else {
12578 return []byte("\"" + self.GetOXMName() + "\""), nil
12579 }
12580}
12581
12582type OxmIdTunMetadata60Masked struct {
12583 *OxmId
12584}
12585
12586type IOxmIdTunMetadata60Masked interface {
12587 IOxmId
12588}
12589
12590func (self *OxmIdTunMetadata60Masked) Serialize(encoder *goloxi.Encoder) error {
12591 if err := self.OxmId.Serialize(encoder); err != nil {
12592 return err
12593 }
12594
12595 return nil
12596}
12597
12598func DecodeOxmIdTunMetadata60Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata60Masked, error) {
12599 _oxmidtunmetadata60masked := &OxmIdTunMetadata60Masked{OxmId: parent}
12600 return _oxmidtunmetadata60masked, nil
12601}
12602
12603func NewOxmIdTunMetadata60Masked() *OxmIdTunMetadata60Masked {
12604 obj := &OxmIdTunMetadata60Masked{
12605 OxmId: NewOxmId(117240),
12606 }
12607 return obj
12608}
12609func (self *OxmIdTunMetadata60Masked) GetOXMName() string {
12610 return "tun_metadata60_masked"
12611}
12612
12613func (self *OxmIdTunMetadata60Masked) MarshalJSON() ([]byte, error) {
12614 if self.TypeLen == 0 {
12615 return []byte("\"\""), nil
12616 } else {
12617 return []byte("\"" + self.GetOXMName() + "\""), nil
12618 }
12619}
12620
12621type OxmIdTunMetadata61 struct {
12622 *OxmId
12623}
12624
12625type IOxmIdTunMetadata61 interface {
12626 IOxmId
12627}
12628
12629func (self *OxmIdTunMetadata61) Serialize(encoder *goloxi.Encoder) error {
12630 if err := self.OxmId.Serialize(encoder); err != nil {
12631 return err
12632 }
12633
12634 return nil
12635}
12636
12637func DecodeOxmIdTunMetadata61(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata61, error) {
12638 _oxmidtunmetadata61 := &OxmIdTunMetadata61{OxmId: parent}
12639 return _oxmidtunmetadata61, nil
12640}
12641
12642func NewOxmIdTunMetadata61() *OxmIdTunMetadata61 {
12643 obj := &OxmIdTunMetadata61{
12644 OxmId: NewOxmId(117372),
12645 }
12646 return obj
12647}
12648func (self *OxmIdTunMetadata61) GetOXMName() string {
12649 return "tun_metadata61"
12650}
12651
12652func (self *OxmIdTunMetadata61) MarshalJSON() ([]byte, error) {
12653 if self.TypeLen == 0 {
12654 return []byte("\"\""), nil
12655 } else {
12656 return []byte("\"" + self.GetOXMName() + "\""), nil
12657 }
12658}
12659
12660type OxmIdTunMetadata61Masked struct {
12661 *OxmId
12662}
12663
12664type IOxmIdTunMetadata61Masked interface {
12665 IOxmId
12666}
12667
12668func (self *OxmIdTunMetadata61Masked) Serialize(encoder *goloxi.Encoder) error {
12669 if err := self.OxmId.Serialize(encoder); err != nil {
12670 return err
12671 }
12672
12673 return nil
12674}
12675
12676func DecodeOxmIdTunMetadata61Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata61Masked, error) {
12677 _oxmidtunmetadata61masked := &OxmIdTunMetadata61Masked{OxmId: parent}
12678 return _oxmidtunmetadata61masked, nil
12679}
12680
12681func NewOxmIdTunMetadata61Masked() *OxmIdTunMetadata61Masked {
12682 obj := &OxmIdTunMetadata61Masked{
12683 OxmId: NewOxmId(117752),
12684 }
12685 return obj
12686}
12687func (self *OxmIdTunMetadata61Masked) GetOXMName() string {
12688 return "tun_metadata61_masked"
12689}
12690
12691func (self *OxmIdTunMetadata61Masked) MarshalJSON() ([]byte, error) {
12692 if self.TypeLen == 0 {
12693 return []byte("\"\""), nil
12694 } else {
12695 return []byte("\"" + self.GetOXMName() + "\""), nil
12696 }
12697}
12698
12699type OxmIdTunMetadata62 struct {
12700 *OxmId
12701}
12702
12703type IOxmIdTunMetadata62 interface {
12704 IOxmId
12705}
12706
12707func (self *OxmIdTunMetadata62) Serialize(encoder *goloxi.Encoder) error {
12708 if err := self.OxmId.Serialize(encoder); err != nil {
12709 return err
12710 }
12711
12712 return nil
12713}
12714
12715func DecodeOxmIdTunMetadata62(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata62, error) {
12716 _oxmidtunmetadata62 := &OxmIdTunMetadata62{OxmId: parent}
12717 return _oxmidtunmetadata62, nil
12718}
12719
12720func NewOxmIdTunMetadata62() *OxmIdTunMetadata62 {
12721 obj := &OxmIdTunMetadata62{
12722 OxmId: NewOxmId(117884),
12723 }
12724 return obj
12725}
12726func (self *OxmIdTunMetadata62) GetOXMName() string {
12727 return "tun_metadata62"
12728}
12729
12730func (self *OxmIdTunMetadata62) MarshalJSON() ([]byte, error) {
12731 if self.TypeLen == 0 {
12732 return []byte("\"\""), nil
12733 } else {
12734 return []byte("\"" + self.GetOXMName() + "\""), nil
12735 }
12736}
12737
12738type OxmIdTunMetadata62Masked struct {
12739 *OxmId
12740}
12741
12742type IOxmIdTunMetadata62Masked interface {
12743 IOxmId
12744}
12745
12746func (self *OxmIdTunMetadata62Masked) Serialize(encoder *goloxi.Encoder) error {
12747 if err := self.OxmId.Serialize(encoder); err != nil {
12748 return err
12749 }
12750
12751 return nil
12752}
12753
12754func DecodeOxmIdTunMetadata62Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata62Masked, error) {
12755 _oxmidtunmetadata62masked := &OxmIdTunMetadata62Masked{OxmId: parent}
12756 return _oxmidtunmetadata62masked, nil
12757}
12758
12759func NewOxmIdTunMetadata62Masked() *OxmIdTunMetadata62Masked {
12760 obj := &OxmIdTunMetadata62Masked{
12761 OxmId: NewOxmId(118264),
12762 }
12763 return obj
12764}
12765func (self *OxmIdTunMetadata62Masked) GetOXMName() string {
12766 return "tun_metadata62_masked"
12767}
12768
12769func (self *OxmIdTunMetadata62Masked) MarshalJSON() ([]byte, error) {
12770 if self.TypeLen == 0 {
12771 return []byte("\"\""), nil
12772 } else {
12773 return []byte("\"" + self.GetOXMName() + "\""), nil
12774 }
12775}
12776
12777type OxmIdTunMetadata63 struct {
12778 *OxmId
12779}
12780
12781type IOxmIdTunMetadata63 interface {
12782 IOxmId
12783}
12784
12785func (self *OxmIdTunMetadata63) Serialize(encoder *goloxi.Encoder) error {
12786 if err := self.OxmId.Serialize(encoder); err != nil {
12787 return err
12788 }
12789
12790 return nil
12791}
12792
12793func DecodeOxmIdTunMetadata63(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata63, error) {
12794 _oxmidtunmetadata63 := &OxmIdTunMetadata63{OxmId: parent}
12795 return _oxmidtunmetadata63, nil
12796}
12797
12798func NewOxmIdTunMetadata63() *OxmIdTunMetadata63 {
12799 obj := &OxmIdTunMetadata63{
12800 OxmId: NewOxmId(118396),
12801 }
12802 return obj
12803}
12804func (self *OxmIdTunMetadata63) GetOXMName() string {
12805 return "tun_metadata63"
12806}
12807
12808func (self *OxmIdTunMetadata63) MarshalJSON() ([]byte, error) {
12809 if self.TypeLen == 0 {
12810 return []byte("\"\""), nil
12811 } else {
12812 return []byte("\"" + self.GetOXMName() + "\""), nil
12813 }
12814}
12815
12816type OxmIdTunMetadata63Masked struct {
12817 *OxmId
12818}
12819
12820type IOxmIdTunMetadata63Masked interface {
12821 IOxmId
12822}
12823
12824func (self *OxmIdTunMetadata63Masked) Serialize(encoder *goloxi.Encoder) error {
12825 if err := self.OxmId.Serialize(encoder); err != nil {
12826 return err
12827 }
12828
12829 return nil
12830}
12831
12832func DecodeOxmIdTunMetadata63Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata63Masked, error) {
12833 _oxmidtunmetadata63masked := &OxmIdTunMetadata63Masked{OxmId: parent}
12834 return _oxmidtunmetadata63masked, nil
12835}
12836
12837func NewOxmIdTunMetadata63Masked() *OxmIdTunMetadata63Masked {
12838 obj := &OxmIdTunMetadata63Masked{
12839 OxmId: NewOxmId(118776),
12840 }
12841 return obj
12842}
12843func (self *OxmIdTunMetadata63Masked) GetOXMName() string {
12844 return "tun_metadata63_masked"
12845}
12846
12847func (self *OxmIdTunMetadata63Masked) MarshalJSON() ([]byte, error) {
12848 if self.TypeLen == 0 {
12849 return []byte("\"\""), nil
12850 } else {
12851 return []byte("\"" + self.GetOXMName() + "\""), nil
12852 }
12853}
12854
12855type OxmIdTunMetadata6Masked struct {
12856 *OxmId
12857}
12858
12859type IOxmIdTunMetadata6Masked interface {
12860 IOxmId
12861}
12862
12863func (self *OxmIdTunMetadata6Masked) Serialize(encoder *goloxi.Encoder) error {
12864 if err := self.OxmId.Serialize(encoder); err != nil {
12865 return err
12866 }
12867
12868 return nil
12869}
12870
12871func DecodeOxmIdTunMetadata6Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata6Masked, error) {
12872 _oxmidtunmetadata6masked := &OxmIdTunMetadata6Masked{OxmId: parent}
12873 return _oxmidtunmetadata6masked, nil
12874}
12875
12876func NewOxmIdTunMetadata6Masked() *OxmIdTunMetadata6Masked {
12877 obj := &OxmIdTunMetadata6Masked{
12878 OxmId: NewOxmId(89592),
12879 }
12880 return obj
12881}
12882func (self *OxmIdTunMetadata6Masked) GetOXMName() string {
12883 return "tun_metadata6_masked"
12884}
12885
12886func (self *OxmIdTunMetadata6Masked) MarshalJSON() ([]byte, error) {
12887 if self.TypeLen == 0 {
12888 return []byte("\"\""), nil
12889 } else {
12890 return []byte("\"" + self.GetOXMName() + "\""), nil
12891 }
12892}
12893
12894type OxmIdTunMetadata7 struct {
12895 *OxmId
12896}
12897
12898type IOxmIdTunMetadata7 interface {
12899 IOxmId
12900}
12901
12902func (self *OxmIdTunMetadata7) Serialize(encoder *goloxi.Encoder) error {
12903 if err := self.OxmId.Serialize(encoder); err != nil {
12904 return err
12905 }
12906
12907 return nil
12908}
12909
12910func DecodeOxmIdTunMetadata7(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata7, error) {
12911 _oxmidtunmetadata7 := &OxmIdTunMetadata7{OxmId: parent}
12912 return _oxmidtunmetadata7, nil
12913}
12914
12915func NewOxmIdTunMetadata7() *OxmIdTunMetadata7 {
12916 obj := &OxmIdTunMetadata7{
12917 OxmId: NewOxmId(89724),
12918 }
12919 return obj
12920}
12921func (self *OxmIdTunMetadata7) GetOXMName() string {
12922 return "tun_metadata7"
12923}
12924
12925func (self *OxmIdTunMetadata7) MarshalJSON() ([]byte, error) {
12926 if self.TypeLen == 0 {
12927 return []byte("\"\""), nil
12928 } else {
12929 return []byte("\"" + self.GetOXMName() + "\""), nil
12930 }
12931}
12932
12933type OxmIdTunMetadata7Masked struct {
12934 *OxmId
12935}
12936
12937type IOxmIdTunMetadata7Masked interface {
12938 IOxmId
12939}
12940
12941func (self *OxmIdTunMetadata7Masked) Serialize(encoder *goloxi.Encoder) error {
12942 if err := self.OxmId.Serialize(encoder); err != nil {
12943 return err
12944 }
12945
12946 return nil
12947}
12948
12949func DecodeOxmIdTunMetadata7Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata7Masked, error) {
12950 _oxmidtunmetadata7masked := &OxmIdTunMetadata7Masked{OxmId: parent}
12951 return _oxmidtunmetadata7masked, nil
12952}
12953
12954func NewOxmIdTunMetadata7Masked() *OxmIdTunMetadata7Masked {
12955 obj := &OxmIdTunMetadata7Masked{
12956 OxmId: NewOxmId(90104),
12957 }
12958 return obj
12959}
12960func (self *OxmIdTunMetadata7Masked) GetOXMName() string {
12961 return "tun_metadata7_masked"
12962}
12963
12964func (self *OxmIdTunMetadata7Masked) MarshalJSON() ([]byte, error) {
12965 if self.TypeLen == 0 {
12966 return []byte("\"\""), nil
12967 } else {
12968 return []byte("\"" + self.GetOXMName() + "\""), nil
12969 }
12970}
12971
12972type OxmIdTunMetadata8 struct {
12973 *OxmId
12974}
12975
12976type IOxmIdTunMetadata8 interface {
12977 IOxmId
12978}
12979
12980func (self *OxmIdTunMetadata8) Serialize(encoder *goloxi.Encoder) error {
12981 if err := self.OxmId.Serialize(encoder); err != nil {
12982 return err
12983 }
12984
12985 return nil
12986}
12987
12988func DecodeOxmIdTunMetadata8(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata8, error) {
12989 _oxmidtunmetadata8 := &OxmIdTunMetadata8{OxmId: parent}
12990 return _oxmidtunmetadata8, nil
12991}
12992
12993func NewOxmIdTunMetadata8() *OxmIdTunMetadata8 {
12994 obj := &OxmIdTunMetadata8{
12995 OxmId: NewOxmId(90236),
12996 }
12997 return obj
12998}
12999func (self *OxmIdTunMetadata8) GetOXMName() string {
13000 return "tun_metadata8"
13001}
13002
13003func (self *OxmIdTunMetadata8) MarshalJSON() ([]byte, error) {
13004 if self.TypeLen == 0 {
13005 return []byte("\"\""), nil
13006 } else {
13007 return []byte("\"" + self.GetOXMName() + "\""), nil
13008 }
13009}
13010
13011type OxmIdTunMetadata8Masked struct {
13012 *OxmId
13013}
13014
13015type IOxmIdTunMetadata8Masked interface {
13016 IOxmId
13017}
13018
13019func (self *OxmIdTunMetadata8Masked) Serialize(encoder *goloxi.Encoder) error {
13020 if err := self.OxmId.Serialize(encoder); err != nil {
13021 return err
13022 }
13023
13024 return nil
13025}
13026
13027func DecodeOxmIdTunMetadata8Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata8Masked, error) {
13028 _oxmidtunmetadata8masked := &OxmIdTunMetadata8Masked{OxmId: parent}
13029 return _oxmidtunmetadata8masked, nil
13030}
13031
13032func NewOxmIdTunMetadata8Masked() *OxmIdTunMetadata8Masked {
13033 obj := &OxmIdTunMetadata8Masked{
13034 OxmId: NewOxmId(90616),
13035 }
13036 return obj
13037}
13038func (self *OxmIdTunMetadata8Masked) GetOXMName() string {
13039 return "tun_metadata8_masked"
13040}
13041
13042func (self *OxmIdTunMetadata8Masked) MarshalJSON() ([]byte, error) {
13043 if self.TypeLen == 0 {
13044 return []byte("\"\""), nil
13045 } else {
13046 return []byte("\"" + self.GetOXMName() + "\""), nil
13047 }
13048}
13049
13050type OxmIdTunMetadata9 struct {
13051 *OxmId
13052}
13053
13054type IOxmIdTunMetadata9 interface {
13055 IOxmId
13056}
13057
13058func (self *OxmIdTunMetadata9) Serialize(encoder *goloxi.Encoder) error {
13059 if err := self.OxmId.Serialize(encoder); err != nil {
13060 return err
13061 }
13062
13063 return nil
13064}
13065
13066func DecodeOxmIdTunMetadata9(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata9, error) {
13067 _oxmidtunmetadata9 := &OxmIdTunMetadata9{OxmId: parent}
13068 return _oxmidtunmetadata9, nil
13069}
13070
13071func NewOxmIdTunMetadata9() *OxmIdTunMetadata9 {
13072 obj := &OxmIdTunMetadata9{
13073 OxmId: NewOxmId(90748),
13074 }
13075 return obj
13076}
13077func (self *OxmIdTunMetadata9) GetOXMName() string {
13078 return "tun_metadata9"
13079}
13080
13081func (self *OxmIdTunMetadata9) MarshalJSON() ([]byte, error) {
13082 if self.TypeLen == 0 {
13083 return []byte("\"\""), nil
13084 } else {
13085 return []byte("\"" + self.GetOXMName() + "\""), nil
13086 }
13087}
13088
13089type OxmIdTunMetadata9Masked struct {
13090 *OxmId
13091}
13092
13093type IOxmIdTunMetadata9Masked interface {
13094 IOxmId
13095}
13096
13097func (self *OxmIdTunMetadata9Masked) Serialize(encoder *goloxi.Encoder) error {
13098 if err := self.OxmId.Serialize(encoder); err != nil {
13099 return err
13100 }
13101
13102 return nil
13103}
13104
13105func DecodeOxmIdTunMetadata9Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunMetadata9Masked, error) {
13106 _oxmidtunmetadata9masked := &OxmIdTunMetadata9Masked{OxmId: parent}
13107 return _oxmidtunmetadata9masked, nil
13108}
13109
13110func NewOxmIdTunMetadata9Masked() *OxmIdTunMetadata9Masked {
13111 obj := &OxmIdTunMetadata9Masked{
13112 OxmId: NewOxmId(91128),
13113 }
13114 return obj
13115}
13116func (self *OxmIdTunMetadata9Masked) GetOXMName() string {
13117 return "tun_metadata9_masked"
13118}
13119
13120func (self *OxmIdTunMetadata9Masked) MarshalJSON() ([]byte, error) {
13121 if self.TypeLen == 0 {
13122 return []byte("\"\""), nil
13123 } else {
13124 return []byte("\"" + self.GetOXMName() + "\""), nil
13125 }
13126}
13127
13128type OxmIdTunSrc struct {
13129 *OxmId
13130}
13131
13132type IOxmIdTunSrc interface {
13133 IOxmId
13134}
13135
13136func (self *OxmIdTunSrc) Serialize(encoder *goloxi.Encoder) error {
13137 if err := self.OxmId.Serialize(encoder); err != nil {
13138 return err
13139 }
13140
13141 return nil
13142}
13143
13144func DecodeOxmIdTunSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunSrc, error) {
13145 _oxmidtunsrc := &OxmIdTunSrc{OxmId: parent}
13146 return _oxmidtunsrc, nil
13147}
13148
13149func NewOxmIdTunSrc() *OxmIdTunSrc {
13150 obj := &OxmIdTunSrc{
13151 OxmId: NewOxmId(81412),
13152 }
13153 return obj
13154}
13155func (self *OxmIdTunSrc) GetOXMName() string {
13156 return "tun_src"
13157}
13158
13159func (self *OxmIdTunSrc) MarshalJSON() ([]byte, error) {
13160 if self.TypeLen == 0 {
13161 return []byte("\"\""), nil
13162 } else {
13163 return []byte("\"" + self.GetOXMName() + "\""), nil
13164 }
13165}
13166
13167type OxmIdTunSrcMasked struct {
13168 *OxmId
13169}
13170
13171type IOxmIdTunSrcMasked interface {
13172 IOxmId
13173}
13174
13175func (self *OxmIdTunSrcMasked) Serialize(encoder *goloxi.Encoder) error {
13176 if err := self.OxmId.Serialize(encoder); err != nil {
13177 return err
13178 }
13179
13180 return nil
13181}
13182
13183func DecodeOxmIdTunSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdTunSrcMasked, error) {
13184 _oxmidtunsrcmasked := &OxmIdTunSrcMasked{OxmId: parent}
13185 return _oxmidtunsrcmasked, nil
13186}
13187
13188func NewOxmIdTunSrcMasked() *OxmIdTunSrcMasked {
13189 obj := &OxmIdTunSrcMasked{
13190 OxmId: NewOxmId(81672),
13191 }
13192 return obj
13193}
13194func (self *OxmIdTunSrcMasked) GetOXMName() string {
13195 return "tun_src_masked"
13196}
13197
13198func (self *OxmIdTunSrcMasked) MarshalJSON() ([]byte, error) {
13199 if self.TypeLen == 0 {
13200 return []byte("\"\""), nil
13201 } else {
13202 return []byte("\"" + self.GetOXMName() + "\""), nil
13203 }
13204}
13205
13206type OxmIdUdpDst struct {
13207 *OxmId
13208}
13209
13210type IOxmIdUdpDst interface {
13211 IOxmId
13212}
13213
13214func (self *OxmIdUdpDst) Serialize(encoder *goloxi.Encoder) error {
13215 if err := self.OxmId.Serialize(encoder); err != nil {
13216 return err
13217 }
13218
13219 return nil
13220}
13221
13222func DecodeOxmIdUdpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpDst, error) {
13223 _oxmidudpdst := &OxmIdUdpDst{OxmId: parent}
13224 return _oxmidudpdst, nil
13225}
13226
13227func NewOxmIdUdpDst() *OxmIdUdpDst {
13228 obj := &OxmIdUdpDst{
13229 OxmId: NewOxmId(6146),
13230 }
13231 return obj
13232}
13233func (self *OxmIdUdpDst) GetOXMName() string {
13234 return "udp_dst"
13235}
13236
13237func (self *OxmIdUdpDst) MarshalJSON() ([]byte, error) {
13238 if self.TypeLen == 0 {
13239 return []byte("\"\""), nil
13240 } else {
13241 return []byte("\"" + self.GetOXMName() + "\""), nil
13242 }
13243}
13244
13245type OxmIdUdpDstMasked struct {
13246 *OxmId
13247}
13248
13249type IOxmIdUdpDstMasked interface {
13250 IOxmId
13251}
13252
13253func (self *OxmIdUdpDstMasked) Serialize(encoder *goloxi.Encoder) error {
13254 if err := self.OxmId.Serialize(encoder); err != nil {
13255 return err
13256 }
13257
13258 return nil
13259}
13260
13261func DecodeOxmIdUdpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpDstMasked, error) {
13262 _oxmidudpdstmasked := &OxmIdUdpDstMasked{OxmId: parent}
13263 return _oxmidudpdstmasked, nil
13264}
13265
13266func NewOxmIdUdpDstMasked() *OxmIdUdpDstMasked {
13267 obj := &OxmIdUdpDstMasked{
13268 OxmId: NewOxmId(6404),
13269 }
13270 return obj
13271}
13272func (self *OxmIdUdpDstMasked) GetOXMName() string {
13273 return "udp_dst_masked"
13274}
13275
13276func (self *OxmIdUdpDstMasked) MarshalJSON() ([]byte, error) {
13277 if self.TypeLen == 0 {
13278 return []byte("\"\""), nil
13279 } else {
13280 return []byte("\"" + self.GetOXMName() + "\""), nil
13281 }
13282}
13283
13284type OxmIdUdpSrc struct {
13285 *OxmId
13286}
13287
13288type IOxmIdUdpSrc interface {
13289 IOxmId
13290}
13291
13292func (self *OxmIdUdpSrc) Serialize(encoder *goloxi.Encoder) error {
13293 if err := self.OxmId.Serialize(encoder); err != nil {
13294 return err
13295 }
13296
13297 return nil
13298}
13299
13300func DecodeOxmIdUdpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpSrc, error) {
13301 _oxmidudpsrc := &OxmIdUdpSrc{OxmId: parent}
13302 return _oxmidudpsrc, nil
13303}
13304
13305func NewOxmIdUdpSrc() *OxmIdUdpSrc {
13306 obj := &OxmIdUdpSrc{
13307 OxmId: NewOxmId(5634),
13308 }
13309 return obj
13310}
13311func (self *OxmIdUdpSrc) GetOXMName() string {
13312 return "udp_src"
13313}
13314
13315func (self *OxmIdUdpSrc) MarshalJSON() ([]byte, error) {
13316 if self.TypeLen == 0 {
13317 return []byte("\"\""), nil
13318 } else {
13319 return []byte("\"" + self.GetOXMName() + "\""), nil
13320 }
13321}
13322
13323type OxmIdUdpSrcMasked struct {
13324 *OxmId
13325}
13326
13327type IOxmIdUdpSrcMasked interface {
13328 IOxmId
13329}
13330
13331func (self *OxmIdUdpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
13332 if err := self.OxmId.Serialize(encoder); err != nil {
13333 return err
13334 }
13335
13336 return nil
13337}
13338
13339func DecodeOxmIdUdpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdUdpSrcMasked, error) {
13340 _oxmidudpsrcmasked := &OxmIdUdpSrcMasked{OxmId: parent}
13341 return _oxmidudpsrcmasked, nil
13342}
13343
13344func NewOxmIdUdpSrcMasked() *OxmIdUdpSrcMasked {
13345 obj := &OxmIdUdpSrcMasked{
13346 OxmId: NewOxmId(5892),
13347 }
13348 return obj
13349}
13350func (self *OxmIdUdpSrcMasked) GetOXMName() string {
13351 return "udp_src_masked"
13352}
13353
13354func (self *OxmIdUdpSrcMasked) MarshalJSON() ([]byte, error) {
13355 if self.TypeLen == 0 {
13356 return []byte("\"\""), nil
13357 } else {
13358 return []byte("\"" + self.GetOXMName() + "\""), nil
13359 }
13360}
13361
13362type OxmIdVlanTci struct {
13363 *OxmId
13364}
13365
13366type IOxmIdVlanTci interface {
13367 IOxmId
13368}
13369
13370func (self *OxmIdVlanTci) Serialize(encoder *goloxi.Encoder) error {
13371 if err := self.OxmId.Serialize(encoder); err != nil {
13372 return err
13373 }
13374
13375 return nil
13376}
13377
13378func DecodeOxmIdVlanTci(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanTci, error) {
13379 _oxmidvlantci := &OxmIdVlanTci{OxmId: parent}
13380 return _oxmidvlantci, nil
13381}
13382
13383func NewOxmIdVlanTci() *OxmIdVlanTci {
13384 obj := &OxmIdVlanTci{
13385 OxmId: NewOxmId(2050),
13386 }
13387 return obj
13388}
13389func (self *OxmIdVlanTci) GetOXMName() string {
13390 return "vlan_tci"
13391}
13392
13393func (self *OxmIdVlanTci) MarshalJSON() ([]byte, error) {
13394 if self.TypeLen == 0 {
13395 return []byte("\"\""), nil
13396 } else {
13397 return []byte("\"" + self.GetOXMName() + "\""), nil
13398 }
13399}
13400
13401type OxmIdVlanTciMasked struct {
13402 *OxmId
13403}
13404
13405type IOxmIdVlanTciMasked interface {
13406 IOxmId
13407}
13408
13409func (self *OxmIdVlanTciMasked) Serialize(encoder *goloxi.Encoder) error {
13410 if err := self.OxmId.Serialize(encoder); err != nil {
13411 return err
13412 }
13413
13414 return nil
13415}
13416
13417func DecodeOxmIdVlanTciMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanTciMasked, error) {
13418 _oxmidvlantcimasked := &OxmIdVlanTciMasked{OxmId: parent}
13419 return _oxmidvlantcimasked, nil
13420}
13421
13422func NewOxmIdVlanTciMasked() *OxmIdVlanTciMasked {
13423 obj := &OxmIdVlanTciMasked{
13424 OxmId: NewOxmId(2308),
13425 }
13426 return obj
13427}
13428func (self *OxmIdVlanTciMasked) GetOXMName() string {
13429 return "vlan_tci_masked"
13430}
13431
13432func (self *OxmIdVlanTciMasked) MarshalJSON() ([]byte, error) {
13433 if self.TypeLen == 0 {
13434 return []byte("\"\""), nil
13435 } else {
13436 return []byte("\"" + self.GetOXMName() + "\""), nil
13437 }
13438}
13439
13440type OxmIdXxreg0 struct {
13441 *OxmId
13442}
13443
13444type IOxmIdXxreg0 interface {
13445 IOxmId
13446}
13447
13448func (self *OxmIdXxreg0) Serialize(encoder *goloxi.Encoder) error {
13449 if err := self.OxmId.Serialize(encoder); err != nil {
13450 return err
13451 }
13452
13453 return nil
13454}
13455
13456func DecodeOxmIdXxreg0(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg0, error) {
13457 _oxmidxxreg0 := &OxmIdXxreg0{OxmId: parent}
13458 return _oxmidxxreg0, nil
13459}
13460
13461func NewOxmIdXxreg0() *OxmIdXxreg0 {
13462 obj := &OxmIdXxreg0{
13463 OxmId: NewOxmId(122384),
13464 }
13465 return obj
13466}
13467func (self *OxmIdXxreg0) GetOXMName() string {
13468 return "xxreg0"
13469}
13470
13471func (self *OxmIdXxreg0) MarshalJSON() ([]byte, error) {
13472 if self.TypeLen == 0 {
13473 return []byte("\"\""), nil
13474 } else {
13475 return []byte("\"" + self.GetOXMName() + "\""), nil
13476 }
13477}
13478
13479type OxmIdXxreg0Masked struct {
13480 *OxmId
13481}
13482
13483type IOxmIdXxreg0Masked interface {
13484 IOxmId
13485}
13486
13487func (self *OxmIdXxreg0Masked) Serialize(encoder *goloxi.Encoder) error {
13488 if err := self.OxmId.Serialize(encoder); err != nil {
13489 return err
13490 }
13491
13492 return nil
13493}
13494
13495func DecodeOxmIdXxreg0Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg0Masked, error) {
13496 _oxmidxxreg0masked := &OxmIdXxreg0Masked{OxmId: parent}
13497 return _oxmidxxreg0masked, nil
13498}
13499
13500func NewOxmIdXxreg0Masked() *OxmIdXxreg0Masked {
13501 obj := &OxmIdXxreg0Masked{
13502 OxmId: NewOxmId(122656),
13503 }
13504 return obj
13505}
13506func (self *OxmIdXxreg0Masked) GetOXMName() string {
13507 return "xxreg0_masked"
13508}
13509
13510func (self *OxmIdXxreg0Masked) MarshalJSON() ([]byte, error) {
13511 if self.TypeLen == 0 {
13512 return []byte("\"\""), nil
13513 } else {
13514 return []byte("\"" + self.GetOXMName() + "\""), nil
13515 }
13516}
13517
13518type OxmIdXxreg1 struct {
13519 *OxmId
13520}
13521
13522type IOxmIdXxreg1 interface {
13523 IOxmId
13524}
13525
13526func (self *OxmIdXxreg1) Serialize(encoder *goloxi.Encoder) error {
13527 if err := self.OxmId.Serialize(encoder); err != nil {
13528 return err
13529 }
13530
13531 return nil
13532}
13533
13534func DecodeOxmIdXxreg1(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg1, error) {
13535 _oxmidxxreg1 := &OxmIdXxreg1{OxmId: parent}
13536 return _oxmidxxreg1, nil
13537}
13538
13539func NewOxmIdXxreg1() *OxmIdXxreg1 {
13540 obj := &OxmIdXxreg1{
13541 OxmId: NewOxmId(122896),
13542 }
13543 return obj
13544}
13545func (self *OxmIdXxreg1) GetOXMName() string {
13546 return "xxreg1"
13547}
13548
13549func (self *OxmIdXxreg1) MarshalJSON() ([]byte, error) {
13550 if self.TypeLen == 0 {
13551 return []byte("\"\""), nil
13552 } else {
13553 return []byte("\"" + self.GetOXMName() + "\""), nil
13554 }
13555}
13556
13557type OxmIdXxreg1Masked struct {
13558 *OxmId
13559}
13560
13561type IOxmIdXxreg1Masked interface {
13562 IOxmId
13563}
13564
13565func (self *OxmIdXxreg1Masked) Serialize(encoder *goloxi.Encoder) error {
13566 if err := self.OxmId.Serialize(encoder); err != nil {
13567 return err
13568 }
13569
13570 return nil
13571}
13572
13573func DecodeOxmIdXxreg1Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg1Masked, error) {
13574 _oxmidxxreg1masked := &OxmIdXxreg1Masked{OxmId: parent}
13575 return _oxmidxxreg1masked, nil
13576}
13577
13578func NewOxmIdXxreg1Masked() *OxmIdXxreg1Masked {
13579 obj := &OxmIdXxreg1Masked{
13580 OxmId: NewOxmId(123168),
13581 }
13582 return obj
13583}
13584func (self *OxmIdXxreg1Masked) GetOXMName() string {
13585 return "xxreg1_masked"
13586}
13587
13588func (self *OxmIdXxreg1Masked) MarshalJSON() ([]byte, error) {
13589 if self.TypeLen == 0 {
13590 return []byte("\"\""), nil
13591 } else {
13592 return []byte("\"" + self.GetOXMName() + "\""), nil
13593 }
13594}
13595
13596type OxmIdXxreg2 struct {
13597 *OxmId
13598}
13599
13600type IOxmIdXxreg2 interface {
13601 IOxmId
13602}
13603
13604func (self *OxmIdXxreg2) Serialize(encoder *goloxi.Encoder) error {
13605 if err := self.OxmId.Serialize(encoder); err != nil {
13606 return err
13607 }
13608
13609 return nil
13610}
13611
13612func DecodeOxmIdXxreg2(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg2, error) {
13613 _oxmidxxreg2 := &OxmIdXxreg2{OxmId: parent}
13614 return _oxmidxxreg2, nil
13615}
13616
13617func NewOxmIdXxreg2() *OxmIdXxreg2 {
13618 obj := &OxmIdXxreg2{
13619 OxmId: NewOxmId(123408),
13620 }
13621 return obj
13622}
13623func (self *OxmIdXxreg2) GetOXMName() string {
13624 return "xxreg2"
13625}
13626
13627func (self *OxmIdXxreg2) MarshalJSON() ([]byte, error) {
13628 if self.TypeLen == 0 {
13629 return []byte("\"\""), nil
13630 } else {
13631 return []byte("\"" + self.GetOXMName() + "\""), nil
13632 }
13633}
13634
13635type OxmIdXxreg2Masked struct {
13636 *OxmId
13637}
13638
13639type IOxmIdXxreg2Masked interface {
13640 IOxmId
13641}
13642
13643func (self *OxmIdXxreg2Masked) Serialize(encoder *goloxi.Encoder) error {
13644 if err := self.OxmId.Serialize(encoder); err != nil {
13645 return err
13646 }
13647
13648 return nil
13649}
13650
13651func DecodeOxmIdXxreg2Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg2Masked, error) {
13652 _oxmidxxreg2masked := &OxmIdXxreg2Masked{OxmId: parent}
13653 return _oxmidxxreg2masked, nil
13654}
13655
13656func NewOxmIdXxreg2Masked() *OxmIdXxreg2Masked {
13657 obj := &OxmIdXxreg2Masked{
13658 OxmId: NewOxmId(123680),
13659 }
13660 return obj
13661}
13662func (self *OxmIdXxreg2Masked) GetOXMName() string {
13663 return "xxreg2_masked"
13664}
13665
13666func (self *OxmIdXxreg2Masked) MarshalJSON() ([]byte, error) {
13667 if self.TypeLen == 0 {
13668 return []byte("\"\""), nil
13669 } else {
13670 return []byte("\"" + self.GetOXMName() + "\""), nil
13671 }
13672}
13673
13674type OxmIdXxreg3 struct {
13675 *OxmId
13676}
13677
13678type IOxmIdXxreg3 interface {
13679 IOxmId
13680}
13681
13682func (self *OxmIdXxreg3) Serialize(encoder *goloxi.Encoder) error {
13683 if err := self.OxmId.Serialize(encoder); err != nil {
13684 return err
13685 }
13686
13687 return nil
13688}
13689
13690func DecodeOxmIdXxreg3(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg3, error) {
13691 _oxmidxxreg3 := &OxmIdXxreg3{OxmId: parent}
13692 return _oxmidxxreg3, nil
13693}
13694
13695func NewOxmIdXxreg3() *OxmIdXxreg3 {
13696 obj := &OxmIdXxreg3{
13697 OxmId: NewOxmId(123920),
13698 }
13699 return obj
13700}
13701func (self *OxmIdXxreg3) GetOXMName() string {
13702 return "xxreg3"
13703}
13704
13705func (self *OxmIdXxreg3) MarshalJSON() ([]byte, error) {
13706 if self.TypeLen == 0 {
13707 return []byte("\"\""), nil
13708 } else {
13709 return []byte("\"" + self.GetOXMName() + "\""), nil
13710 }
13711}
13712
13713type OxmIdXxreg3Masked struct {
13714 *OxmId
13715}
13716
13717type IOxmIdXxreg3Masked interface {
13718 IOxmId
13719}
13720
13721func (self *OxmIdXxreg3Masked) Serialize(encoder *goloxi.Encoder) error {
13722 if err := self.OxmId.Serialize(encoder); err != nil {
13723 return err
13724 }
13725
13726 return nil
13727}
13728
13729func DecodeOxmIdXxreg3Masked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdXxreg3Masked, error) {
13730 _oxmidxxreg3masked := &OxmIdXxreg3Masked{OxmId: parent}
13731 return _oxmidxxreg3masked, nil
13732}
13733
13734func NewOxmIdXxreg3Masked() *OxmIdXxreg3Masked {
13735 obj := &OxmIdXxreg3Masked{
13736 OxmId: NewOxmId(124192),
13737 }
13738 return obj
13739}
13740func (self *OxmIdXxreg3Masked) GetOXMName() string {
13741 return "xxreg3_masked"
13742}
13743
13744func (self *OxmIdXxreg3Masked) MarshalJSON() ([]byte, error) {
13745 if self.TypeLen == 0 {
13746 return []byte("\"\""), nil
13747 } else {
13748 return []byte("\"" + self.GetOXMName() + "\""), nil
13749 }
13750}
13751
13752type OxmIdArpOpMasked struct {
13753 *OxmId
13754}
13755
13756type IOxmIdArpOpMasked interface {
13757 IOxmId
13758}
13759
13760func (self *OxmIdArpOpMasked) Serialize(encoder *goloxi.Encoder) error {
13761 if err := self.OxmId.Serialize(encoder); err != nil {
13762 return err
13763 }
13764
13765 return nil
13766}
13767
13768func DecodeOxmIdArpOpMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdArpOpMasked, error) {
13769 _oxmidarpopmasked := &OxmIdArpOpMasked{OxmId: parent}
13770 return _oxmidarpopmasked, nil
13771}
13772
13773func NewOxmIdArpOpMasked() *OxmIdArpOpMasked {
13774 obj := &OxmIdArpOpMasked{
13775 OxmId: NewOxmId(2147494660),
13776 }
13777 return obj
13778}
13779func (self *OxmIdArpOpMasked) GetOXMName() string {
13780 return "arp_op_masked"
13781}
13782
13783func (self *OxmIdArpOpMasked) MarshalJSON() ([]byte, error) {
13784 if self.TypeLen == 0 {
13785 return []byte("\"\""), nil
13786 } else {
13787 return []byte("\"" + self.GetOXMName() + "\""), nil
13788 }
13789}
13790
13791type OxmIdConnTrackingIpv6Dst struct {
13792 *OxmId
13793}
13794
13795type IOxmIdConnTrackingIpv6Dst interface {
13796 IOxmId
13797}
13798
13799func (self *OxmIdConnTrackingIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
13800 if err := self.OxmId.Serialize(encoder); err != nil {
13801 return err
13802 }
13803
13804 return nil
13805}
13806
13807func DecodeOxmIdConnTrackingIpv6Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6Dst, error) {
13808 _oxmidconntrackingipv6dst := &OxmIdConnTrackingIpv6Dst{OxmId: parent}
13809 return _oxmidconntrackingipv6dst, nil
13810}
13811
13812func NewOxmIdConnTrackingIpv6Dst() *OxmIdConnTrackingIpv6Dst {
13813 obj := &OxmIdConnTrackingIpv6Dst{
13814 OxmId: NewOxmId(128528),
13815 }
13816 return obj
13817}
13818func (self *OxmIdConnTrackingIpv6Dst) GetOXMName() string {
13819 return "conn_tracking_ipv6_dst"
13820}
13821
13822func (self *OxmIdConnTrackingIpv6Dst) MarshalJSON() ([]byte, error) {
13823 if self.TypeLen == 0 {
13824 return []byte("\"\""), nil
13825 } else {
13826 return []byte("\"" + self.GetOXMName() + "\""), nil
13827 }
13828}
13829
13830type OxmIdConnTrackingIpv6DstMasked struct {
13831 *OxmId
13832}
13833
13834type IOxmIdConnTrackingIpv6DstMasked interface {
13835 IOxmId
13836}
13837
13838func (self *OxmIdConnTrackingIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
13839 if err := self.OxmId.Serialize(encoder); err != nil {
13840 return err
13841 }
13842
13843 return nil
13844}
13845
13846func DecodeOxmIdConnTrackingIpv6DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6DstMasked, error) {
13847 _oxmidconntrackingipv6dstmasked := &OxmIdConnTrackingIpv6DstMasked{OxmId: parent}
13848 return _oxmidconntrackingipv6dstmasked, nil
13849}
13850
13851func NewOxmIdConnTrackingIpv6DstMasked() *OxmIdConnTrackingIpv6DstMasked {
13852 obj := &OxmIdConnTrackingIpv6DstMasked{
13853 OxmId: NewOxmId(128800),
13854 }
13855 return obj
13856}
13857func (self *OxmIdConnTrackingIpv6DstMasked) GetOXMName() string {
13858 return "conn_tracking_ipv6_dst_masked"
13859}
13860
13861func (self *OxmIdConnTrackingIpv6DstMasked) MarshalJSON() ([]byte, error) {
13862 if self.TypeLen == 0 {
13863 return []byte("\"\""), nil
13864 } else {
13865 return []byte("\"" + self.GetOXMName() + "\""), nil
13866 }
13867}
13868
13869type OxmIdConnTrackingIpv6Src struct {
13870 *OxmId
13871}
13872
13873type IOxmIdConnTrackingIpv6Src interface {
13874 IOxmId
13875}
13876
13877func (self *OxmIdConnTrackingIpv6Src) Serialize(encoder *goloxi.Encoder) error {
13878 if err := self.OxmId.Serialize(encoder); err != nil {
13879 return err
13880 }
13881
13882 return nil
13883}
13884
13885func DecodeOxmIdConnTrackingIpv6Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6Src, error) {
13886 _oxmidconntrackingipv6src := &OxmIdConnTrackingIpv6Src{OxmId: parent}
13887 return _oxmidconntrackingipv6src, nil
13888}
13889
13890func NewOxmIdConnTrackingIpv6Src() *OxmIdConnTrackingIpv6Src {
13891 obj := &OxmIdConnTrackingIpv6Src{
13892 OxmId: NewOxmId(128016),
13893 }
13894 return obj
13895}
13896func (self *OxmIdConnTrackingIpv6Src) GetOXMName() string {
13897 return "conn_tracking_ipv6_src"
13898}
13899
13900func (self *OxmIdConnTrackingIpv6Src) MarshalJSON() ([]byte, error) {
13901 if self.TypeLen == 0 {
13902 return []byte("\"\""), nil
13903 } else {
13904 return []byte("\"" + self.GetOXMName() + "\""), nil
13905 }
13906}
13907
13908type OxmIdConnTrackingIpv6SrcMasked struct {
13909 *OxmId
13910}
13911
13912type IOxmIdConnTrackingIpv6SrcMasked interface {
13913 IOxmId
13914}
13915
13916func (self *OxmIdConnTrackingIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
13917 if err := self.OxmId.Serialize(encoder); err != nil {
13918 return err
13919 }
13920
13921 return nil
13922}
13923
13924func DecodeOxmIdConnTrackingIpv6SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingIpv6SrcMasked, error) {
13925 _oxmidconntrackingipv6srcmasked := &OxmIdConnTrackingIpv6SrcMasked{OxmId: parent}
13926 return _oxmidconntrackingipv6srcmasked, nil
13927}
13928
13929func NewOxmIdConnTrackingIpv6SrcMasked() *OxmIdConnTrackingIpv6SrcMasked {
13930 obj := &OxmIdConnTrackingIpv6SrcMasked{
13931 OxmId: NewOxmId(128288),
13932 }
13933 return obj
13934}
13935func (self *OxmIdConnTrackingIpv6SrcMasked) GetOXMName() string {
13936 return "conn_tracking_ipv6_src_masked"
13937}
13938
13939func (self *OxmIdConnTrackingIpv6SrcMasked) MarshalJSON() ([]byte, error) {
13940 if self.TypeLen == 0 {
13941 return []byte("\"\""), nil
13942 } else {
13943 return []byte("\"" + self.GetOXMName() + "\""), nil
13944 }
13945}
13946
13947type OxmIdConnTrackingLabel struct {
13948 *OxmId
13949}
13950
13951type IOxmIdConnTrackingLabel interface {
13952 IOxmId
13953}
13954
13955func (self *OxmIdConnTrackingLabel) Serialize(encoder *goloxi.Encoder) error {
13956 if err := self.OxmId.Serialize(encoder); err != nil {
13957 return err
13958 }
13959
13960 return nil
13961}
13962
13963func DecodeOxmIdConnTrackingLabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingLabel, error) {
13964 _oxmidconntrackinglabel := &OxmIdConnTrackingLabel{OxmId: parent}
13965 return _oxmidconntrackinglabel, nil
13966}
13967
13968func NewOxmIdConnTrackingLabel() *OxmIdConnTrackingLabel {
13969 obj := &OxmIdConnTrackingLabel{
13970 OxmId: NewOxmId(120848),
13971 }
13972 return obj
13973}
13974func (self *OxmIdConnTrackingLabel) GetOXMName() string {
13975 return "conn_tracking_label"
13976}
13977
13978func (self *OxmIdConnTrackingLabel) MarshalJSON() ([]byte, error) {
13979 if self.TypeLen == 0 {
13980 return []byte("\"\""), nil
13981 } else {
13982 return []byte("\"" + self.GetOXMName() + "\""), nil
13983 }
13984}
13985
13986type OxmIdConnTrackingLabelMasked struct {
13987 *OxmId
13988}
13989
13990type IOxmIdConnTrackingLabelMasked interface {
13991 IOxmId
13992}
13993
13994func (self *OxmIdConnTrackingLabelMasked) Serialize(encoder *goloxi.Encoder) error {
13995 if err := self.OxmId.Serialize(encoder); err != nil {
13996 return err
13997 }
13998
13999 return nil
14000}
14001
14002func DecodeOxmIdConnTrackingLabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingLabelMasked, error) {
14003 _oxmidconntrackinglabelmasked := &OxmIdConnTrackingLabelMasked{OxmId: parent}
14004 return _oxmidconntrackinglabelmasked, nil
14005}
14006
14007func NewOxmIdConnTrackingLabelMasked() *OxmIdConnTrackingLabelMasked {
14008 obj := &OxmIdConnTrackingLabelMasked{
14009 OxmId: NewOxmId(121120),
14010 }
14011 return obj
14012}
14013func (self *OxmIdConnTrackingLabelMasked) GetOXMName() string {
14014 return "conn_tracking_label_masked"
14015}
14016
14017func (self *OxmIdConnTrackingLabelMasked) MarshalJSON() ([]byte, error) {
14018 if self.TypeLen == 0 {
14019 return []byte("\"\""), nil
14020 } else {
14021 return []byte("\"" + self.GetOXMName() + "\""), nil
14022 }
14023}
14024
14025type OxmIdConnTrackingMark struct {
14026 *OxmId
14027}
14028
14029type IOxmIdConnTrackingMark interface {
14030 IOxmId
14031}
14032
14033func (self *OxmIdConnTrackingMark) Serialize(encoder *goloxi.Encoder) error {
14034 if err := self.OxmId.Serialize(encoder); err != nil {
14035 return err
14036 }
14037
14038 return nil
14039}
14040
14041func DecodeOxmIdConnTrackingMark(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingMark, error) {
14042 _oxmidconntrackingmark := &OxmIdConnTrackingMark{OxmId: parent}
14043 return _oxmidconntrackingmark, nil
14044}
14045
14046func NewOxmIdConnTrackingMark() *OxmIdConnTrackingMark {
14047 obj := &OxmIdConnTrackingMark{
14048 OxmId: NewOxmId(120324),
14049 }
14050 return obj
14051}
14052func (self *OxmIdConnTrackingMark) GetOXMName() string {
14053 return "conn_tracking_mark"
14054}
14055
14056func (self *OxmIdConnTrackingMark) MarshalJSON() ([]byte, error) {
14057 if self.TypeLen == 0 {
14058 return []byte("\"\""), nil
14059 } else {
14060 return []byte("\"" + self.GetOXMName() + "\""), nil
14061 }
14062}
14063
14064type OxmIdConnTrackingMarkMasked struct {
14065 *OxmId
14066}
14067
14068type IOxmIdConnTrackingMarkMasked interface {
14069 IOxmId
14070}
14071
14072func (self *OxmIdConnTrackingMarkMasked) Serialize(encoder *goloxi.Encoder) error {
14073 if err := self.OxmId.Serialize(encoder); err != nil {
14074 return err
14075 }
14076
14077 return nil
14078}
14079
14080func DecodeOxmIdConnTrackingMarkMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingMarkMasked, error) {
14081 _oxmidconntrackingmarkmasked := &OxmIdConnTrackingMarkMasked{OxmId: parent}
14082 return _oxmidconntrackingmarkmasked, nil
14083}
14084
14085func NewOxmIdConnTrackingMarkMasked() *OxmIdConnTrackingMarkMasked {
14086 obj := &OxmIdConnTrackingMarkMasked{
14087 OxmId: NewOxmId(120584),
14088 }
14089 return obj
14090}
14091func (self *OxmIdConnTrackingMarkMasked) GetOXMName() string {
14092 return "conn_tracking_mark_masked"
14093}
14094
14095func (self *OxmIdConnTrackingMarkMasked) MarshalJSON() ([]byte, error) {
14096 if self.TypeLen == 0 {
14097 return []byte("\"\""), nil
14098 } else {
14099 return []byte("\"" + self.GetOXMName() + "\""), nil
14100 }
14101}
14102
14103type OxmIdConnTrackingNwDst struct {
14104 *OxmId
14105}
14106
14107type IOxmIdConnTrackingNwDst interface {
14108 IOxmId
14109}
14110
14111func (self *OxmIdConnTrackingNwDst) Serialize(encoder *goloxi.Encoder) error {
14112 if err := self.OxmId.Serialize(encoder); err != nil {
14113 return err
14114 }
14115
14116 return nil
14117}
14118
14119func DecodeOxmIdConnTrackingNwDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwDst, error) {
14120 _oxmidconntrackingnwdst := &OxmIdConnTrackingNwDst{OxmId: parent}
14121 return _oxmidconntrackingnwdst, nil
14122}
14123
14124func NewOxmIdConnTrackingNwDst() *OxmIdConnTrackingNwDst {
14125 obj := &OxmIdConnTrackingNwDst{
14126 OxmId: NewOxmId(127492),
14127 }
14128 return obj
14129}
14130func (self *OxmIdConnTrackingNwDst) GetOXMName() string {
14131 return "conn_tracking_nw_dst"
14132}
14133
14134func (self *OxmIdConnTrackingNwDst) MarshalJSON() ([]byte, error) {
14135 if self.TypeLen == 0 {
14136 return []byte("\"\""), nil
14137 } else {
14138 return []byte("\"" + self.GetOXMName() + "\""), nil
14139 }
14140}
14141
14142type OxmIdConnTrackingNwDstMasked struct {
14143 *OxmId
14144}
14145
14146type IOxmIdConnTrackingNwDstMasked interface {
14147 IOxmId
14148}
14149
14150func (self *OxmIdConnTrackingNwDstMasked) Serialize(encoder *goloxi.Encoder) error {
14151 if err := self.OxmId.Serialize(encoder); err != nil {
14152 return err
14153 }
14154
14155 return nil
14156}
14157
14158func DecodeOxmIdConnTrackingNwDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwDstMasked, error) {
14159 _oxmidconntrackingnwdstmasked := &OxmIdConnTrackingNwDstMasked{OxmId: parent}
14160 return _oxmidconntrackingnwdstmasked, nil
14161}
14162
14163func NewOxmIdConnTrackingNwDstMasked() *OxmIdConnTrackingNwDstMasked {
14164 obj := &OxmIdConnTrackingNwDstMasked{
14165 OxmId: NewOxmId(127752),
14166 }
14167 return obj
14168}
14169func (self *OxmIdConnTrackingNwDstMasked) GetOXMName() string {
14170 return "conn_tracking_nw_dst_masked"
14171}
14172
14173func (self *OxmIdConnTrackingNwDstMasked) MarshalJSON() ([]byte, error) {
14174 if self.TypeLen == 0 {
14175 return []byte("\"\""), nil
14176 } else {
14177 return []byte("\"" + self.GetOXMName() + "\""), nil
14178 }
14179}
14180
14181type OxmIdConnTrackingNwProto struct {
14182 *OxmId
14183}
14184
14185type IOxmIdConnTrackingNwProto interface {
14186 IOxmId
14187}
14188
14189func (self *OxmIdConnTrackingNwProto) Serialize(encoder *goloxi.Encoder) error {
14190 if err := self.OxmId.Serialize(encoder); err != nil {
14191 return err
14192 }
14193
14194 return nil
14195}
14196
14197func DecodeOxmIdConnTrackingNwProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwProto, error) {
14198 _oxmidconntrackingnwproto := &OxmIdConnTrackingNwProto{OxmId: parent}
14199 return _oxmidconntrackingnwproto, nil
14200}
14201
14202func NewOxmIdConnTrackingNwProto() *OxmIdConnTrackingNwProto {
14203 obj := &OxmIdConnTrackingNwProto{
14204 OxmId: NewOxmId(126465),
14205 }
14206 return obj
14207}
14208func (self *OxmIdConnTrackingNwProto) GetOXMName() string {
14209 return "conn_tracking_nw_proto"
14210}
14211
14212func (self *OxmIdConnTrackingNwProto) MarshalJSON() ([]byte, error) {
14213 if self.TypeLen == 0 {
14214 return []byte("\"\""), nil
14215 } else {
14216 return []byte("\"" + self.GetOXMName() + "\""), nil
14217 }
14218}
14219
14220type OxmIdConnTrackingNwProtoMasked struct {
14221 *OxmId
14222}
14223
14224type IOxmIdConnTrackingNwProtoMasked interface {
14225 IOxmId
14226}
14227
14228func (self *OxmIdConnTrackingNwProtoMasked) Serialize(encoder *goloxi.Encoder) error {
14229 if err := self.OxmId.Serialize(encoder); err != nil {
14230 return err
14231 }
14232
14233 return nil
14234}
14235
14236func DecodeOxmIdConnTrackingNwProtoMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwProtoMasked, error) {
14237 _oxmidconntrackingnwprotomasked := &OxmIdConnTrackingNwProtoMasked{OxmId: parent}
14238 return _oxmidconntrackingnwprotomasked, nil
14239}
14240
14241func NewOxmIdConnTrackingNwProtoMasked() *OxmIdConnTrackingNwProtoMasked {
14242 obj := &OxmIdConnTrackingNwProtoMasked{
14243 OxmId: NewOxmId(126722),
14244 }
14245 return obj
14246}
14247func (self *OxmIdConnTrackingNwProtoMasked) GetOXMName() string {
14248 return "conn_tracking_nw_proto_masked"
14249}
14250
14251func (self *OxmIdConnTrackingNwProtoMasked) MarshalJSON() ([]byte, error) {
14252 if self.TypeLen == 0 {
14253 return []byte("\"\""), nil
14254 } else {
14255 return []byte("\"" + self.GetOXMName() + "\""), nil
14256 }
14257}
14258
14259type OxmIdConnTrackingNwSrc struct {
14260 *OxmId
14261}
14262
14263type IOxmIdConnTrackingNwSrc interface {
14264 IOxmId
14265}
14266
14267func (self *OxmIdConnTrackingNwSrc) Serialize(encoder *goloxi.Encoder) error {
14268 if err := self.OxmId.Serialize(encoder); err != nil {
14269 return err
14270 }
14271
14272 return nil
14273}
14274
14275func DecodeOxmIdConnTrackingNwSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwSrc, error) {
14276 _oxmidconntrackingnwsrc := &OxmIdConnTrackingNwSrc{OxmId: parent}
14277 return _oxmidconntrackingnwsrc, nil
14278}
14279
14280func NewOxmIdConnTrackingNwSrc() *OxmIdConnTrackingNwSrc {
14281 obj := &OxmIdConnTrackingNwSrc{
14282 OxmId: NewOxmId(126980),
14283 }
14284 return obj
14285}
14286func (self *OxmIdConnTrackingNwSrc) GetOXMName() string {
14287 return "conn_tracking_nw_src"
14288}
14289
14290func (self *OxmIdConnTrackingNwSrc) MarshalJSON() ([]byte, error) {
14291 if self.TypeLen == 0 {
14292 return []byte("\"\""), nil
14293 } else {
14294 return []byte("\"" + self.GetOXMName() + "\""), nil
14295 }
14296}
14297
14298type OxmIdConnTrackingNwSrcMasked struct {
14299 *OxmId
14300}
14301
14302type IOxmIdConnTrackingNwSrcMasked interface {
14303 IOxmId
14304}
14305
14306func (self *OxmIdConnTrackingNwSrcMasked) Serialize(encoder *goloxi.Encoder) error {
14307 if err := self.OxmId.Serialize(encoder); err != nil {
14308 return err
14309 }
14310
14311 return nil
14312}
14313
14314func DecodeOxmIdConnTrackingNwSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingNwSrcMasked, error) {
14315 _oxmidconntrackingnwsrcmasked := &OxmIdConnTrackingNwSrcMasked{OxmId: parent}
14316 return _oxmidconntrackingnwsrcmasked, nil
14317}
14318
14319func NewOxmIdConnTrackingNwSrcMasked() *OxmIdConnTrackingNwSrcMasked {
14320 obj := &OxmIdConnTrackingNwSrcMasked{
14321 OxmId: NewOxmId(127240),
14322 }
14323 return obj
14324}
14325func (self *OxmIdConnTrackingNwSrcMasked) GetOXMName() string {
14326 return "conn_tracking_nw_src_masked"
14327}
14328
14329func (self *OxmIdConnTrackingNwSrcMasked) MarshalJSON() ([]byte, error) {
14330 if self.TypeLen == 0 {
14331 return []byte("\"\""), nil
14332 } else {
14333 return []byte("\"" + self.GetOXMName() + "\""), nil
14334 }
14335}
14336
14337type OxmIdConnTrackingState struct {
14338 *OxmId
14339}
14340
14341type IOxmIdConnTrackingState interface {
14342 IOxmId
14343}
14344
14345func (self *OxmIdConnTrackingState) Serialize(encoder *goloxi.Encoder) error {
14346 if err := self.OxmId.Serialize(encoder); err != nil {
14347 return err
14348 }
14349
14350 return nil
14351}
14352
14353func DecodeOxmIdConnTrackingState(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingState, error) {
14354 _oxmidconntrackingstate := &OxmIdConnTrackingState{OxmId: parent}
14355 return _oxmidconntrackingstate, nil
14356}
14357
14358func NewOxmIdConnTrackingState() *OxmIdConnTrackingState {
14359 obj := &OxmIdConnTrackingState{
14360 OxmId: NewOxmId(119300),
14361 }
14362 return obj
14363}
14364func (self *OxmIdConnTrackingState) GetOXMName() string {
14365 return "conn_tracking_state"
14366}
14367
14368func (self *OxmIdConnTrackingState) MarshalJSON() ([]byte, error) {
14369 if self.TypeLen == 0 {
14370 return []byte("\"\""), nil
14371 } else {
14372 return []byte("\"" + self.GetOXMName() + "\""), nil
14373 }
14374}
14375
14376type OxmIdConnTrackingStateMasked struct {
14377 *OxmId
14378}
14379
14380type IOxmIdConnTrackingStateMasked interface {
14381 IOxmId
14382}
14383
14384func (self *OxmIdConnTrackingStateMasked) Serialize(encoder *goloxi.Encoder) error {
14385 if err := self.OxmId.Serialize(encoder); err != nil {
14386 return err
14387 }
14388
14389 return nil
14390}
14391
14392func DecodeOxmIdConnTrackingStateMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingStateMasked, error) {
14393 _oxmidconntrackingstatemasked := &OxmIdConnTrackingStateMasked{OxmId: parent}
14394 return _oxmidconntrackingstatemasked, nil
14395}
14396
14397func NewOxmIdConnTrackingStateMasked() *OxmIdConnTrackingStateMasked {
14398 obj := &OxmIdConnTrackingStateMasked{
14399 OxmId: NewOxmId(119560),
14400 }
14401 return obj
14402}
14403func (self *OxmIdConnTrackingStateMasked) GetOXMName() string {
14404 return "conn_tracking_state_masked"
14405}
14406
14407func (self *OxmIdConnTrackingStateMasked) MarshalJSON() ([]byte, error) {
14408 if self.TypeLen == 0 {
14409 return []byte("\"\""), nil
14410 } else {
14411 return []byte("\"" + self.GetOXMName() + "\""), nil
14412 }
14413}
14414
14415type OxmIdConnTrackingTpDst struct {
14416 *OxmId
14417}
14418
14419type IOxmIdConnTrackingTpDst interface {
14420 IOxmId
14421}
14422
14423func (self *OxmIdConnTrackingTpDst) Serialize(encoder *goloxi.Encoder) error {
14424 if err := self.OxmId.Serialize(encoder); err != nil {
14425 return err
14426 }
14427
14428 return nil
14429}
14430
14431func DecodeOxmIdConnTrackingTpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpDst, error) {
14432 _oxmidconntrackingtpdst := &OxmIdConnTrackingTpDst{OxmId: parent}
14433 return _oxmidconntrackingtpdst, nil
14434}
14435
14436func NewOxmIdConnTrackingTpDst() *OxmIdConnTrackingTpDst {
14437 obj := &OxmIdConnTrackingTpDst{
14438 OxmId: NewOxmId(129538),
14439 }
14440 return obj
14441}
14442func (self *OxmIdConnTrackingTpDst) GetOXMName() string {
14443 return "conn_tracking_tp_dst"
14444}
14445
14446func (self *OxmIdConnTrackingTpDst) MarshalJSON() ([]byte, error) {
14447 if self.TypeLen == 0 {
14448 return []byte("\"\""), nil
14449 } else {
14450 return []byte("\"" + self.GetOXMName() + "\""), nil
14451 }
14452}
14453
14454type OxmIdConnTrackingTpDstMasked struct {
14455 *OxmId
14456}
14457
14458type IOxmIdConnTrackingTpDstMasked interface {
14459 IOxmId
14460}
14461
14462func (self *OxmIdConnTrackingTpDstMasked) Serialize(encoder *goloxi.Encoder) error {
14463 if err := self.OxmId.Serialize(encoder); err != nil {
14464 return err
14465 }
14466
14467 return nil
14468}
14469
14470func DecodeOxmIdConnTrackingTpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpDstMasked, error) {
14471 _oxmidconntrackingtpdstmasked := &OxmIdConnTrackingTpDstMasked{OxmId: parent}
14472 return _oxmidconntrackingtpdstmasked, nil
14473}
14474
14475func NewOxmIdConnTrackingTpDstMasked() *OxmIdConnTrackingTpDstMasked {
14476 obj := &OxmIdConnTrackingTpDstMasked{
14477 OxmId: NewOxmId(129796),
14478 }
14479 return obj
14480}
14481func (self *OxmIdConnTrackingTpDstMasked) GetOXMName() string {
14482 return "conn_tracking_tp_dst_masked"
14483}
14484
14485func (self *OxmIdConnTrackingTpDstMasked) MarshalJSON() ([]byte, error) {
14486 if self.TypeLen == 0 {
14487 return []byte("\"\""), nil
14488 } else {
14489 return []byte("\"" + self.GetOXMName() + "\""), nil
14490 }
14491}
14492
14493type OxmIdConnTrackingTpSrc struct {
14494 *OxmId
14495}
14496
14497type IOxmIdConnTrackingTpSrc interface {
14498 IOxmId
14499}
14500
14501func (self *OxmIdConnTrackingTpSrc) Serialize(encoder *goloxi.Encoder) error {
14502 if err := self.OxmId.Serialize(encoder); err != nil {
14503 return err
14504 }
14505
14506 return nil
14507}
14508
14509func DecodeOxmIdConnTrackingTpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpSrc, error) {
14510 _oxmidconntrackingtpsrc := &OxmIdConnTrackingTpSrc{OxmId: parent}
14511 return _oxmidconntrackingtpsrc, nil
14512}
14513
14514func NewOxmIdConnTrackingTpSrc() *OxmIdConnTrackingTpSrc {
14515 obj := &OxmIdConnTrackingTpSrc{
14516 OxmId: NewOxmId(129026),
14517 }
14518 return obj
14519}
14520func (self *OxmIdConnTrackingTpSrc) GetOXMName() string {
14521 return "conn_tracking_tp_src"
14522}
14523
14524func (self *OxmIdConnTrackingTpSrc) MarshalJSON() ([]byte, error) {
14525 if self.TypeLen == 0 {
14526 return []byte("\"\""), nil
14527 } else {
14528 return []byte("\"" + self.GetOXMName() + "\""), nil
14529 }
14530}
14531
14532type OxmIdConnTrackingTpSrcMasked struct {
14533 *OxmId
14534}
14535
14536type IOxmIdConnTrackingTpSrcMasked interface {
14537 IOxmId
14538}
14539
14540func (self *OxmIdConnTrackingTpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
14541 if err := self.OxmId.Serialize(encoder); err != nil {
14542 return err
14543 }
14544
14545 return nil
14546}
14547
14548func DecodeOxmIdConnTrackingTpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingTpSrcMasked, error) {
14549 _oxmidconntrackingtpsrcmasked := &OxmIdConnTrackingTpSrcMasked{OxmId: parent}
14550 return _oxmidconntrackingtpsrcmasked, nil
14551}
14552
14553func NewOxmIdConnTrackingTpSrcMasked() *OxmIdConnTrackingTpSrcMasked {
14554 obj := &OxmIdConnTrackingTpSrcMasked{
14555 OxmId: NewOxmId(129284),
14556 }
14557 return obj
14558}
14559func (self *OxmIdConnTrackingTpSrcMasked) GetOXMName() string {
14560 return "conn_tracking_tp_src_masked"
14561}
14562
14563func (self *OxmIdConnTrackingTpSrcMasked) MarshalJSON() ([]byte, error) {
14564 if self.TypeLen == 0 {
14565 return []byte("\"\""), nil
14566 } else {
14567 return []byte("\"" + self.GetOXMName() + "\""), nil
14568 }
14569}
14570
14571type OxmIdConnTrackingZone struct {
14572 *OxmId
14573}
14574
14575type IOxmIdConnTrackingZone interface {
14576 IOxmId
14577}
14578
14579func (self *OxmIdConnTrackingZone) Serialize(encoder *goloxi.Encoder) error {
14580 if err := self.OxmId.Serialize(encoder); err != nil {
14581 return err
14582 }
14583
14584 return nil
14585}
14586
14587func DecodeOxmIdConnTrackingZone(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingZone, error) {
14588 _oxmidconntrackingzone := &OxmIdConnTrackingZone{OxmId: parent}
14589 return _oxmidconntrackingzone, nil
14590}
14591
14592func NewOxmIdConnTrackingZone() *OxmIdConnTrackingZone {
14593 obj := &OxmIdConnTrackingZone{
14594 OxmId: NewOxmId(119810),
14595 }
14596 return obj
14597}
14598func (self *OxmIdConnTrackingZone) GetOXMName() string {
14599 return "conn_tracking_zone"
14600}
14601
14602func (self *OxmIdConnTrackingZone) MarshalJSON() ([]byte, error) {
14603 if self.TypeLen == 0 {
14604 return []byte("\"\""), nil
14605 } else {
14606 return []byte("\"" + self.GetOXMName() + "\""), nil
14607 }
14608}
14609
14610type OxmIdConnTrackingZoneMasked struct {
14611 *OxmId
14612}
14613
14614type IOxmIdConnTrackingZoneMasked interface {
14615 IOxmId
14616}
14617
14618func (self *OxmIdConnTrackingZoneMasked) Serialize(encoder *goloxi.Encoder) error {
14619 if err := self.OxmId.Serialize(encoder); err != nil {
14620 return err
14621 }
14622
14623 return nil
14624}
14625
14626func DecodeOxmIdConnTrackingZoneMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdConnTrackingZoneMasked, error) {
14627 _oxmidconntrackingzonemasked := &OxmIdConnTrackingZoneMasked{OxmId: parent}
14628 return _oxmidconntrackingzonemasked, nil
14629}
14630
14631func NewOxmIdConnTrackingZoneMasked() *OxmIdConnTrackingZoneMasked {
14632 obj := &OxmIdConnTrackingZoneMasked{
14633 OxmId: NewOxmId(120068),
14634 }
14635 return obj
14636}
14637func (self *OxmIdConnTrackingZoneMasked) GetOXMName() string {
14638 return "conn_tracking_zone_masked"
14639}
14640
14641func (self *OxmIdConnTrackingZoneMasked) MarshalJSON() ([]byte, error) {
14642 if self.TypeLen == 0 {
14643 return []byte("\"\""), nil
14644 } else {
14645 return []byte("\"" + self.GetOXMName() + "\""), nil
14646 }
14647}
14648
14649type OxmIdEthTypeMasked struct {
14650 *OxmId
14651}
14652
14653type IOxmIdEthTypeMasked interface {
14654 IOxmId
14655}
14656
14657func (self *OxmIdEthTypeMasked) Serialize(encoder *goloxi.Encoder) error {
14658 if err := self.OxmId.Serialize(encoder); err != nil {
14659 return err
14660 }
14661
14662 return nil
14663}
14664
14665func DecodeOxmIdEthTypeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdEthTypeMasked, error) {
14666 _oxmidethtypemasked := &OxmIdEthTypeMasked{OxmId: parent}
14667 return _oxmidethtypemasked, nil
14668}
14669
14670func NewOxmIdEthTypeMasked() *OxmIdEthTypeMasked {
14671 obj := &OxmIdEthTypeMasked{
14672 OxmId: NewOxmId(2147486468),
14673 }
14674 return obj
14675}
14676func (self *OxmIdEthTypeMasked) GetOXMName() string {
14677 return "eth_type_masked"
14678}
14679
14680func (self *OxmIdEthTypeMasked) MarshalJSON() ([]byte, error) {
14681 if self.TypeLen == 0 {
14682 return []byte("\"\""), nil
14683 } else {
14684 return []byte("\"" + self.GetOXMName() + "\""), nil
14685 }
14686}
14687
14688type OxmIdIcmpv4Code struct {
14689 *OxmId
14690}
14691
14692type IOxmIdIcmpv4Code interface {
14693 IOxmId
14694}
14695
14696func (self *OxmIdIcmpv4Code) Serialize(encoder *goloxi.Encoder) error {
14697 if err := self.OxmId.Serialize(encoder); err != nil {
14698 return err
14699 }
14700
14701 return nil
14702}
14703
14704func DecodeOxmIdIcmpv4Code(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4Code, error) {
14705 _oxmidicmpv4code := &OxmIdIcmpv4Code{OxmId: parent}
14706 return _oxmidicmpv4code, nil
14707}
14708
14709func NewOxmIdIcmpv4Code() *OxmIdIcmpv4Code {
14710 obj := &OxmIdIcmpv4Code{
14711 OxmId: NewOxmId(2147493889),
14712 }
14713 return obj
14714}
14715func (self *OxmIdIcmpv4Code) GetOXMName() string {
14716 return "icmpv4_code"
14717}
14718
14719func (self *OxmIdIcmpv4Code) MarshalJSON() ([]byte, error) {
14720 if self.TypeLen == 0 {
14721 return []byte("\"\""), nil
14722 } else {
14723 return []byte("\"" + self.GetOXMName() + "\""), nil
14724 }
14725}
14726
14727type OxmIdIcmpv4CodeMasked struct {
14728 *OxmId
14729}
14730
14731type IOxmIdIcmpv4CodeMasked interface {
14732 IOxmId
14733}
14734
14735func (self *OxmIdIcmpv4CodeMasked) Serialize(encoder *goloxi.Encoder) error {
14736 if err := self.OxmId.Serialize(encoder); err != nil {
14737 return err
14738 }
14739
14740 return nil
14741}
14742
14743func DecodeOxmIdIcmpv4CodeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4CodeMasked, error) {
14744 _oxmidicmpv4codemasked := &OxmIdIcmpv4CodeMasked{OxmId: parent}
14745 return _oxmidicmpv4codemasked, nil
14746}
14747
14748func NewOxmIdIcmpv4CodeMasked() *OxmIdIcmpv4CodeMasked {
14749 obj := &OxmIdIcmpv4CodeMasked{
14750 OxmId: NewOxmId(2147494146),
14751 }
14752 return obj
14753}
14754func (self *OxmIdIcmpv4CodeMasked) GetOXMName() string {
14755 return "icmpv4_code_masked"
14756}
14757
14758func (self *OxmIdIcmpv4CodeMasked) MarshalJSON() ([]byte, error) {
14759 if self.TypeLen == 0 {
14760 return []byte("\"\""), nil
14761 } else {
14762 return []byte("\"" + self.GetOXMName() + "\""), nil
14763 }
14764}
14765
14766type OxmIdIcmpv4Type struct {
14767 *OxmId
14768}
14769
14770type IOxmIdIcmpv4Type interface {
14771 IOxmId
14772}
14773
14774func (self *OxmIdIcmpv4Type) Serialize(encoder *goloxi.Encoder) error {
14775 if err := self.OxmId.Serialize(encoder); err != nil {
14776 return err
14777 }
14778
14779 return nil
14780}
14781
14782func DecodeOxmIdIcmpv4Type(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4Type, error) {
14783 _oxmidicmpv4type := &OxmIdIcmpv4Type{OxmId: parent}
14784 return _oxmidicmpv4type, nil
14785}
14786
14787func NewOxmIdIcmpv4Type() *OxmIdIcmpv4Type {
14788 obj := &OxmIdIcmpv4Type{
14789 OxmId: NewOxmId(2147493377),
14790 }
14791 return obj
14792}
14793func (self *OxmIdIcmpv4Type) GetOXMName() string {
14794 return "icmpv4_type"
14795}
14796
14797func (self *OxmIdIcmpv4Type) MarshalJSON() ([]byte, error) {
14798 if self.TypeLen == 0 {
14799 return []byte("\"\""), nil
14800 } else {
14801 return []byte("\"" + self.GetOXMName() + "\""), nil
14802 }
14803}
14804
14805type OxmIdIcmpv4TypeMasked struct {
14806 *OxmId
14807}
14808
14809type IOxmIdIcmpv4TypeMasked interface {
14810 IOxmId
14811}
14812
14813func (self *OxmIdIcmpv4TypeMasked) Serialize(encoder *goloxi.Encoder) error {
14814 if err := self.OxmId.Serialize(encoder); err != nil {
14815 return err
14816 }
14817
14818 return nil
14819}
14820
14821func DecodeOxmIdIcmpv4TypeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv4TypeMasked, error) {
14822 _oxmidicmpv4typemasked := &OxmIdIcmpv4TypeMasked{OxmId: parent}
14823 return _oxmidicmpv4typemasked, nil
14824}
14825
14826func NewOxmIdIcmpv4TypeMasked() *OxmIdIcmpv4TypeMasked {
14827 obj := &OxmIdIcmpv4TypeMasked{
14828 OxmId: NewOxmId(2147493634),
14829 }
14830 return obj
14831}
14832func (self *OxmIdIcmpv4TypeMasked) GetOXMName() string {
14833 return "icmpv4_type_masked"
14834}
14835
14836func (self *OxmIdIcmpv4TypeMasked) MarshalJSON() ([]byte, error) {
14837 if self.TypeLen == 0 {
14838 return []byte("\"\""), nil
14839 } else {
14840 return []byte("\"" + self.GetOXMName() + "\""), nil
14841 }
14842}
14843
14844type OxmIdIcmpv6CodeMasked struct {
14845 *OxmId
14846}
14847
14848type IOxmIdIcmpv6CodeMasked interface {
14849 IOxmId
14850}
14851
14852func (self *OxmIdIcmpv6CodeMasked) Serialize(encoder *goloxi.Encoder) error {
14853 if err := self.OxmId.Serialize(encoder); err != nil {
14854 return err
14855 }
14856
14857 return nil
14858}
14859
14860func DecodeOxmIdIcmpv6CodeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6CodeMasked, error) {
14861 _oxmidicmpv6codemasked := &OxmIdIcmpv6CodeMasked{OxmId: parent}
14862 return _oxmidicmpv6codemasked, nil
14863}
14864
14865func NewOxmIdIcmpv6CodeMasked() *OxmIdIcmpv6CodeMasked {
14866 obj := &OxmIdIcmpv6CodeMasked{
14867 OxmId: NewOxmId(2147499266),
14868 }
14869 return obj
14870}
14871func (self *OxmIdIcmpv6CodeMasked) GetOXMName() string {
14872 return "icmpv6_code_masked"
14873}
14874
14875func (self *OxmIdIcmpv6CodeMasked) MarshalJSON() ([]byte, error) {
14876 if self.TypeLen == 0 {
14877 return []byte("\"\""), nil
14878 } else {
14879 return []byte("\"" + self.GetOXMName() + "\""), nil
14880 }
14881}
14882
14883type OxmIdIcmpv6TypeMasked struct {
14884 *OxmId
14885}
14886
14887type IOxmIdIcmpv6TypeMasked interface {
14888 IOxmId
14889}
14890
14891func (self *OxmIdIcmpv6TypeMasked) Serialize(encoder *goloxi.Encoder) error {
14892 if err := self.OxmId.Serialize(encoder); err != nil {
14893 return err
14894 }
14895
14896 return nil
14897}
14898
14899func DecodeOxmIdIcmpv6TypeMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIcmpv6TypeMasked, error) {
14900 _oxmidicmpv6typemasked := &OxmIdIcmpv6TypeMasked{OxmId: parent}
14901 return _oxmidicmpv6typemasked, nil
14902}
14903
14904func NewOxmIdIcmpv6TypeMasked() *OxmIdIcmpv6TypeMasked {
14905 obj := &OxmIdIcmpv6TypeMasked{
14906 OxmId: NewOxmId(2147498754),
14907 }
14908 return obj
14909}
14910func (self *OxmIdIcmpv6TypeMasked) GetOXMName() string {
14911 return "icmpv6_type_masked"
14912}
14913
14914func (self *OxmIdIcmpv6TypeMasked) MarshalJSON() ([]byte, error) {
14915 if self.TypeLen == 0 {
14916 return []byte("\"\""), nil
14917 } else {
14918 return []byte("\"" + self.GetOXMName() + "\""), nil
14919 }
14920}
14921
14922type OxmIdInPhyPort struct {
14923 *OxmId
14924}
14925
14926type IOxmIdInPhyPort interface {
14927 IOxmId
14928}
14929
14930func (self *OxmIdInPhyPort) Serialize(encoder *goloxi.Encoder) error {
14931 if err := self.OxmId.Serialize(encoder); err != nil {
14932 return err
14933 }
14934
14935 return nil
14936}
14937
14938func DecodeOxmIdInPhyPort(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPhyPort, error) {
14939 _oxmidinphyport := &OxmIdInPhyPort{OxmId: parent}
14940 return _oxmidinphyport, nil
14941}
14942
14943func NewOxmIdInPhyPort() *OxmIdInPhyPort {
14944 obj := &OxmIdInPhyPort{
14945 OxmId: NewOxmId(2147484164),
14946 }
14947 return obj
14948}
14949func (self *OxmIdInPhyPort) GetOXMName() string {
14950 return "in_phy_port"
14951}
14952
14953func (self *OxmIdInPhyPort) MarshalJSON() ([]byte, error) {
14954 if self.TypeLen == 0 {
14955 return []byte("\"\""), nil
14956 } else {
14957 return []byte("\"" + self.GetOXMName() + "\""), nil
14958 }
14959}
14960
14961type OxmIdInPhyPortMasked struct {
14962 *OxmId
14963}
14964
14965type IOxmIdInPhyPortMasked interface {
14966 IOxmId
14967}
14968
14969func (self *OxmIdInPhyPortMasked) Serialize(encoder *goloxi.Encoder) error {
14970 if err := self.OxmId.Serialize(encoder); err != nil {
14971 return err
14972 }
14973
14974 return nil
14975}
14976
14977func DecodeOxmIdInPhyPortMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPhyPortMasked, error) {
14978 _oxmidinphyportmasked := &OxmIdInPhyPortMasked{OxmId: parent}
14979 return _oxmidinphyportmasked, nil
14980}
14981
14982func NewOxmIdInPhyPortMasked() *OxmIdInPhyPortMasked {
14983 obj := &OxmIdInPhyPortMasked{
14984 OxmId: NewOxmId(2147484424),
14985 }
14986 return obj
14987}
14988func (self *OxmIdInPhyPortMasked) GetOXMName() string {
14989 return "in_phy_port_masked"
14990}
14991
14992func (self *OxmIdInPhyPortMasked) MarshalJSON() ([]byte, error) {
14993 if self.TypeLen == 0 {
14994 return []byte("\"\""), nil
14995 } else {
14996 return []byte("\"" + self.GetOXMName() + "\""), nil
14997 }
14998}
14999
15000type OxmIdInPortMasked struct {
15001 *OxmId
15002}
15003
15004type IOxmIdInPortMasked interface {
15005 IOxmId
15006}
15007
15008func (self *OxmIdInPortMasked) Serialize(encoder *goloxi.Encoder) error {
15009 if err := self.OxmId.Serialize(encoder); err != nil {
15010 return err
15011 }
15012
15013 return nil
15014}
15015
15016func DecodeOxmIdInPortMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdInPortMasked, error) {
15017 _oxmidinportmasked := &OxmIdInPortMasked{OxmId: parent}
15018 return _oxmidinportmasked, nil
15019}
15020
15021func NewOxmIdInPortMasked() *OxmIdInPortMasked {
15022 obj := &OxmIdInPortMasked{
15023 OxmId: NewOxmId(2147483912),
15024 }
15025 return obj
15026}
15027func (self *OxmIdInPortMasked) GetOXMName() string {
15028 return "in_port_masked"
15029}
15030
15031func (self *OxmIdInPortMasked) MarshalJSON() ([]byte, error) {
15032 if self.TypeLen == 0 {
15033 return []byte("\"\""), nil
15034 } else {
15035 return []byte("\"" + self.GetOXMName() + "\""), nil
15036 }
15037}
15038
15039type OxmIdIpDscp struct {
15040 *OxmId
15041}
15042
15043type IOxmIdIpDscp interface {
15044 IOxmId
15045}
15046
15047func (self *OxmIdIpDscp) Serialize(encoder *goloxi.Encoder) error {
15048 if err := self.OxmId.Serialize(encoder); err != nil {
15049 return err
15050 }
15051
15052 return nil
15053}
15054
15055func DecodeOxmIdIpDscp(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDscp, error) {
15056 _oxmidipdscp := &OxmIdIpDscp{OxmId: parent}
15057 return _oxmidipdscp, nil
15058}
15059
15060func NewOxmIdIpDscp() *OxmIdIpDscp {
15061 obj := &OxmIdIpDscp{
15062 OxmId: NewOxmId(2147487745),
15063 }
15064 return obj
15065}
15066func (self *OxmIdIpDscp) GetOXMName() string {
15067 return "ip_dscp"
15068}
15069
15070func (self *OxmIdIpDscp) MarshalJSON() ([]byte, error) {
15071 if self.TypeLen == 0 {
15072 return []byte("\"\""), nil
15073 } else {
15074 return []byte("\"" + self.GetOXMName() + "\""), nil
15075 }
15076}
15077
15078type OxmIdIpDscpMasked struct {
15079 *OxmId
15080}
15081
15082type IOxmIdIpDscpMasked interface {
15083 IOxmId
15084}
15085
15086func (self *OxmIdIpDscpMasked) Serialize(encoder *goloxi.Encoder) error {
15087 if err := self.OxmId.Serialize(encoder); err != nil {
15088 return err
15089 }
15090
15091 return nil
15092}
15093
15094func DecodeOxmIdIpDscpMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpDscpMasked, error) {
15095 _oxmidipdscpmasked := &OxmIdIpDscpMasked{OxmId: parent}
15096 return _oxmidipdscpmasked, nil
15097}
15098
15099func NewOxmIdIpDscpMasked() *OxmIdIpDscpMasked {
15100 obj := &OxmIdIpDscpMasked{
15101 OxmId: NewOxmId(2147488002),
15102 }
15103 return obj
15104}
15105func (self *OxmIdIpDscpMasked) GetOXMName() string {
15106 return "ip_dscp_masked"
15107}
15108
15109func (self *OxmIdIpDscpMasked) MarshalJSON() ([]byte, error) {
15110 if self.TypeLen == 0 {
15111 return []byte("\"\""), nil
15112 } else {
15113 return []byte("\"" + self.GetOXMName() + "\""), nil
15114 }
15115}
15116
15117type OxmIdIpEcn struct {
15118 *OxmId
15119}
15120
15121type IOxmIdIpEcn interface {
15122 IOxmId
15123}
15124
15125func (self *OxmIdIpEcn) Serialize(encoder *goloxi.Encoder) error {
15126 if err := self.OxmId.Serialize(encoder); err != nil {
15127 return err
15128 }
15129
15130 return nil
15131}
15132
15133func DecodeOxmIdIpEcn(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpEcn, error) {
15134 _oxmidipecn := &OxmIdIpEcn{OxmId: parent}
15135 return _oxmidipecn, nil
15136}
15137
15138func NewOxmIdIpEcn() *OxmIdIpEcn {
15139 obj := &OxmIdIpEcn{
15140 OxmId: NewOxmId(2147488257),
15141 }
15142 return obj
15143}
15144func (self *OxmIdIpEcn) GetOXMName() string {
15145 return "ip_ecn"
15146}
15147
15148func (self *OxmIdIpEcn) MarshalJSON() ([]byte, error) {
15149 if self.TypeLen == 0 {
15150 return []byte("\"\""), nil
15151 } else {
15152 return []byte("\"" + self.GetOXMName() + "\""), nil
15153 }
15154}
15155
15156type OxmIdIpEcnMasked struct {
15157 *OxmId
15158}
15159
15160type IOxmIdIpEcnMasked interface {
15161 IOxmId
15162}
15163
15164func (self *OxmIdIpEcnMasked) Serialize(encoder *goloxi.Encoder) error {
15165 if err := self.OxmId.Serialize(encoder); err != nil {
15166 return err
15167 }
15168
15169 return nil
15170}
15171
15172func DecodeOxmIdIpEcnMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpEcnMasked, error) {
15173 _oxmidipecnmasked := &OxmIdIpEcnMasked{OxmId: parent}
15174 return _oxmidipecnmasked, nil
15175}
15176
15177func NewOxmIdIpEcnMasked() *OxmIdIpEcnMasked {
15178 obj := &OxmIdIpEcnMasked{
15179 OxmId: NewOxmId(2147488514),
15180 }
15181 return obj
15182}
15183func (self *OxmIdIpEcnMasked) GetOXMName() string {
15184 return "ip_ecn_masked"
15185}
15186
15187func (self *OxmIdIpEcnMasked) MarshalJSON() ([]byte, error) {
15188 if self.TypeLen == 0 {
15189 return []byte("\"\""), nil
15190 } else {
15191 return []byte("\"" + self.GetOXMName() + "\""), nil
15192 }
15193}
15194
15195type OxmIdIpProto struct {
15196 *OxmId
15197}
15198
15199type IOxmIdIpProto interface {
15200 IOxmId
15201}
15202
15203func (self *OxmIdIpProto) Serialize(encoder *goloxi.Encoder) error {
15204 if err := self.OxmId.Serialize(encoder); err != nil {
15205 return err
15206 }
15207
15208 return nil
15209}
15210
15211func DecodeOxmIdIpProto(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpProto, error) {
15212 _oxmidipproto := &OxmIdIpProto{OxmId: parent}
15213 return _oxmidipproto, nil
15214}
15215
15216func NewOxmIdIpProto() *OxmIdIpProto {
15217 obj := &OxmIdIpProto{
15218 OxmId: NewOxmId(2147488769),
15219 }
15220 return obj
15221}
15222func (self *OxmIdIpProto) GetOXMName() string {
15223 return "ip_proto"
15224}
15225
15226func (self *OxmIdIpProto) MarshalJSON() ([]byte, error) {
15227 if self.TypeLen == 0 {
15228 return []byte("\"\""), nil
15229 } else {
15230 return []byte("\"" + self.GetOXMName() + "\""), nil
15231 }
15232}
15233
15234type OxmIdIpProtoMasked struct {
15235 *OxmId
15236}
15237
15238type IOxmIdIpProtoMasked interface {
15239 IOxmId
15240}
15241
15242func (self *OxmIdIpProtoMasked) Serialize(encoder *goloxi.Encoder) error {
15243 if err := self.OxmId.Serialize(encoder); err != nil {
15244 return err
15245 }
15246
15247 return nil
15248}
15249
15250func DecodeOxmIdIpProtoMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpProtoMasked, error) {
15251 _oxmidipprotomasked := &OxmIdIpProtoMasked{OxmId: parent}
15252 return _oxmidipprotomasked, nil
15253}
15254
15255func NewOxmIdIpProtoMasked() *OxmIdIpProtoMasked {
15256 obj := &OxmIdIpProtoMasked{
15257 OxmId: NewOxmId(2147489026),
15258 }
15259 return obj
15260}
15261func (self *OxmIdIpProtoMasked) GetOXMName() string {
15262 return "ip_proto_masked"
15263}
15264
15265func (self *OxmIdIpProtoMasked) MarshalJSON() ([]byte, error) {
15266 if self.TypeLen == 0 {
15267 return []byte("\"\""), nil
15268 } else {
15269 return []byte("\"" + self.GetOXMName() + "\""), nil
15270 }
15271}
15272
15273type OxmIdIpv4Dst struct {
15274 *OxmId
15275}
15276
15277type IOxmIdIpv4Dst interface {
15278 IOxmId
15279}
15280
15281func (self *OxmIdIpv4Dst) Serialize(encoder *goloxi.Encoder) error {
15282 if err := self.OxmId.Serialize(encoder); err != nil {
15283 return err
15284 }
15285
15286 return nil
15287}
15288
15289func DecodeOxmIdIpv4Dst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4Dst, error) {
15290 _oxmidipv4dst := &OxmIdIpv4Dst{OxmId: parent}
15291 return _oxmidipv4dst, nil
15292}
15293
15294func NewOxmIdIpv4Dst() *OxmIdIpv4Dst {
15295 obj := &OxmIdIpv4Dst{
15296 OxmId: NewOxmId(2147489796),
15297 }
15298 return obj
15299}
15300func (self *OxmIdIpv4Dst) GetOXMName() string {
15301 return "ipv4_dst"
15302}
15303
15304func (self *OxmIdIpv4Dst) MarshalJSON() ([]byte, error) {
15305 if self.TypeLen == 0 {
15306 return []byte("\"\""), nil
15307 } else {
15308 return []byte("\"" + self.GetOXMName() + "\""), nil
15309 }
15310}
15311
15312type OxmIdIpv4DstMasked struct {
15313 *OxmId
15314}
15315
15316type IOxmIdIpv4DstMasked interface {
15317 IOxmId
15318}
15319
15320func (self *OxmIdIpv4DstMasked) Serialize(encoder *goloxi.Encoder) error {
15321 if err := self.OxmId.Serialize(encoder); err != nil {
15322 return err
15323 }
15324
15325 return nil
15326}
15327
15328func DecodeOxmIdIpv4DstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4DstMasked, error) {
15329 _oxmidipv4dstmasked := &OxmIdIpv4DstMasked{OxmId: parent}
15330 return _oxmidipv4dstmasked, nil
15331}
15332
15333func NewOxmIdIpv4DstMasked() *OxmIdIpv4DstMasked {
15334 obj := &OxmIdIpv4DstMasked{
15335 OxmId: NewOxmId(2147490056),
15336 }
15337 return obj
15338}
15339func (self *OxmIdIpv4DstMasked) GetOXMName() string {
15340 return "ipv4_dst_masked"
15341}
15342
15343func (self *OxmIdIpv4DstMasked) MarshalJSON() ([]byte, error) {
15344 if self.TypeLen == 0 {
15345 return []byte("\"\""), nil
15346 } else {
15347 return []byte("\"" + self.GetOXMName() + "\""), nil
15348 }
15349}
15350
15351type OxmIdIpv4Src struct {
15352 *OxmId
15353}
15354
15355type IOxmIdIpv4Src interface {
15356 IOxmId
15357}
15358
15359func (self *OxmIdIpv4Src) Serialize(encoder *goloxi.Encoder) error {
15360 if err := self.OxmId.Serialize(encoder); err != nil {
15361 return err
15362 }
15363
15364 return nil
15365}
15366
15367func DecodeOxmIdIpv4Src(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4Src, error) {
15368 _oxmidipv4src := &OxmIdIpv4Src{OxmId: parent}
15369 return _oxmidipv4src, nil
15370}
15371
15372func NewOxmIdIpv4Src() *OxmIdIpv4Src {
15373 obj := &OxmIdIpv4Src{
15374 OxmId: NewOxmId(2147489284),
15375 }
15376 return obj
15377}
15378func (self *OxmIdIpv4Src) GetOXMName() string {
15379 return "ipv4_src"
15380}
15381
15382func (self *OxmIdIpv4Src) MarshalJSON() ([]byte, error) {
15383 if self.TypeLen == 0 {
15384 return []byte("\"\""), nil
15385 } else {
15386 return []byte("\"" + self.GetOXMName() + "\""), nil
15387 }
15388}
15389
15390type OxmIdIpv4SrcMasked struct {
15391 *OxmId
15392}
15393
15394type IOxmIdIpv4SrcMasked interface {
15395 IOxmId
15396}
15397
15398func (self *OxmIdIpv4SrcMasked) Serialize(encoder *goloxi.Encoder) error {
15399 if err := self.OxmId.Serialize(encoder); err != nil {
15400 return err
15401 }
15402
15403 return nil
15404}
15405
15406func DecodeOxmIdIpv4SrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv4SrcMasked, error) {
15407 _oxmidipv4srcmasked := &OxmIdIpv4SrcMasked{OxmId: parent}
15408 return _oxmidipv4srcmasked, nil
15409}
15410
15411func NewOxmIdIpv4SrcMasked() *OxmIdIpv4SrcMasked {
15412 obj := &OxmIdIpv4SrcMasked{
15413 OxmId: NewOxmId(2147489544),
15414 }
15415 return obj
15416}
15417func (self *OxmIdIpv4SrcMasked) GetOXMName() string {
15418 return "ipv4_src_masked"
15419}
15420
15421func (self *OxmIdIpv4SrcMasked) MarshalJSON() ([]byte, error) {
15422 if self.TypeLen == 0 {
15423 return []byte("\"\""), nil
15424 } else {
15425 return []byte("\"" + self.GetOXMName() + "\""), nil
15426 }
15427}
15428
15429type OxmIdIpv6Flabel struct {
15430 *OxmId
15431}
15432
15433type IOxmIdIpv6Flabel interface {
15434 IOxmId
15435}
15436
15437func (self *OxmIdIpv6Flabel) Serialize(encoder *goloxi.Encoder) error {
15438 if err := self.OxmId.Serialize(encoder); err != nil {
15439 return err
15440 }
15441
15442 return nil
15443}
15444
15445func DecodeOxmIdIpv6Flabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6Flabel, error) {
15446 _oxmidipv6flabel := &OxmIdIpv6Flabel{OxmId: parent}
15447 return _oxmidipv6flabel, nil
15448}
15449
15450func NewOxmIdIpv6Flabel() *OxmIdIpv6Flabel {
15451 obj := &OxmIdIpv6Flabel{
15452 OxmId: NewOxmId(2147497988),
15453 }
15454 return obj
15455}
15456func (self *OxmIdIpv6Flabel) GetOXMName() string {
15457 return "ipv6_flabel"
15458}
15459
15460func (self *OxmIdIpv6Flabel) MarshalJSON() ([]byte, error) {
15461 if self.TypeLen == 0 {
15462 return []byte("\"\""), nil
15463 } else {
15464 return []byte("\"" + self.GetOXMName() + "\""), nil
15465 }
15466}
15467
15468type OxmIdIpv6FlabelMasked struct {
15469 *OxmId
15470}
15471
15472type IOxmIdIpv6FlabelMasked interface {
15473 IOxmId
15474}
15475
15476func (self *OxmIdIpv6FlabelMasked) Serialize(encoder *goloxi.Encoder) error {
15477 if err := self.OxmId.Serialize(encoder); err != nil {
15478 return err
15479 }
15480
15481 return nil
15482}
15483
15484func DecodeOxmIdIpv6FlabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6FlabelMasked, error) {
15485 _oxmidipv6flabelmasked := &OxmIdIpv6FlabelMasked{OxmId: parent}
15486 return _oxmidipv6flabelmasked, nil
15487}
15488
15489func NewOxmIdIpv6FlabelMasked() *OxmIdIpv6FlabelMasked {
15490 obj := &OxmIdIpv6FlabelMasked{
15491 OxmId: NewOxmId(2147498248),
15492 }
15493 return obj
15494}
15495func (self *OxmIdIpv6FlabelMasked) GetOXMName() string {
15496 return "ipv6_flabel_masked"
15497}
15498
15499func (self *OxmIdIpv6FlabelMasked) MarshalJSON() ([]byte, error) {
15500 if self.TypeLen == 0 {
15501 return []byte("\"\""), nil
15502 } else {
15503 return []byte("\"" + self.GetOXMName() + "\""), nil
15504 }
15505}
15506
15507type OxmIdIpv6NdSll struct {
15508 *OxmId
15509}
15510
15511type IOxmIdIpv6NdSll interface {
15512 IOxmId
15513}
15514
15515func (self *OxmIdIpv6NdSll) Serialize(encoder *goloxi.Encoder) error {
15516 if err := self.OxmId.Serialize(encoder); err != nil {
15517 return err
15518 }
15519
15520 return nil
15521}
15522
15523func DecodeOxmIdIpv6NdSll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdSll, error) {
15524 _oxmidipv6ndsll := &OxmIdIpv6NdSll{OxmId: parent}
15525 return _oxmidipv6ndsll, nil
15526}
15527
15528func NewOxmIdIpv6NdSll() *OxmIdIpv6NdSll {
15529 obj := &OxmIdIpv6NdSll{
15530 OxmId: NewOxmId(2147500038),
15531 }
15532 return obj
15533}
15534func (self *OxmIdIpv6NdSll) GetOXMName() string {
15535 return "ipv6_nd_sll"
15536}
15537
15538func (self *OxmIdIpv6NdSll) MarshalJSON() ([]byte, error) {
15539 if self.TypeLen == 0 {
15540 return []byte("\"\""), nil
15541 } else {
15542 return []byte("\"" + self.GetOXMName() + "\""), nil
15543 }
15544}
15545
15546type OxmIdIpv6NdSllMasked struct {
15547 *OxmId
15548}
15549
15550type IOxmIdIpv6NdSllMasked interface {
15551 IOxmId
15552}
15553
15554func (self *OxmIdIpv6NdSllMasked) Serialize(encoder *goloxi.Encoder) error {
15555 if err := self.OxmId.Serialize(encoder); err != nil {
15556 return err
15557 }
15558
15559 return nil
15560}
15561
15562func DecodeOxmIdIpv6NdSllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdSllMasked, error) {
15563 _oxmidipv6ndsllmasked := &OxmIdIpv6NdSllMasked{OxmId: parent}
15564 return _oxmidipv6ndsllmasked, nil
15565}
15566
15567func NewOxmIdIpv6NdSllMasked() *OxmIdIpv6NdSllMasked {
15568 obj := &OxmIdIpv6NdSllMasked{
15569 OxmId: NewOxmId(2147500300),
15570 }
15571 return obj
15572}
15573func (self *OxmIdIpv6NdSllMasked) GetOXMName() string {
15574 return "ipv6_nd_sll_masked"
15575}
15576
15577func (self *OxmIdIpv6NdSllMasked) MarshalJSON() ([]byte, error) {
15578 if self.TypeLen == 0 {
15579 return []byte("\"\""), nil
15580 } else {
15581 return []byte("\"" + self.GetOXMName() + "\""), nil
15582 }
15583}
15584
15585type OxmIdIpv6NdTarget struct {
15586 *OxmId
15587}
15588
15589type IOxmIdIpv6NdTarget interface {
15590 IOxmId
15591}
15592
15593func (self *OxmIdIpv6NdTarget) Serialize(encoder *goloxi.Encoder) error {
15594 if err := self.OxmId.Serialize(encoder); err != nil {
15595 return err
15596 }
15597
15598 return nil
15599}
15600
15601func DecodeOxmIdIpv6NdTarget(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTarget, error) {
15602 _oxmidipv6ndtarget := &OxmIdIpv6NdTarget{OxmId: parent}
15603 return _oxmidipv6ndtarget, nil
15604}
15605
15606func NewOxmIdIpv6NdTarget() *OxmIdIpv6NdTarget {
15607 obj := &OxmIdIpv6NdTarget{
15608 OxmId: NewOxmId(2147499536),
15609 }
15610 return obj
15611}
15612func (self *OxmIdIpv6NdTarget) GetOXMName() string {
15613 return "ipv6_nd_target"
15614}
15615
15616func (self *OxmIdIpv6NdTarget) MarshalJSON() ([]byte, error) {
15617 if self.TypeLen == 0 {
15618 return []byte("\"\""), nil
15619 } else {
15620 return []byte("\"" + self.GetOXMName() + "\""), nil
15621 }
15622}
15623
15624type OxmIdIpv6NdTargetMasked struct {
15625 *OxmId
15626}
15627
15628type IOxmIdIpv6NdTargetMasked interface {
15629 IOxmId
15630}
15631
15632func (self *OxmIdIpv6NdTargetMasked) Serialize(encoder *goloxi.Encoder) error {
15633 if err := self.OxmId.Serialize(encoder); err != nil {
15634 return err
15635 }
15636
15637 return nil
15638}
15639
15640func DecodeOxmIdIpv6NdTargetMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTargetMasked, error) {
15641 _oxmidipv6ndtargetmasked := &OxmIdIpv6NdTargetMasked{OxmId: parent}
15642 return _oxmidipv6ndtargetmasked, nil
15643}
15644
15645func NewOxmIdIpv6NdTargetMasked() *OxmIdIpv6NdTargetMasked {
15646 obj := &OxmIdIpv6NdTargetMasked{
15647 OxmId: NewOxmId(2147499808),
15648 }
15649 return obj
15650}
15651func (self *OxmIdIpv6NdTargetMasked) GetOXMName() string {
15652 return "ipv6_nd_target_masked"
15653}
15654
15655func (self *OxmIdIpv6NdTargetMasked) MarshalJSON() ([]byte, error) {
15656 if self.TypeLen == 0 {
15657 return []byte("\"\""), nil
15658 } else {
15659 return []byte("\"" + self.GetOXMName() + "\""), nil
15660 }
15661}
15662
15663type OxmIdIpv6NdTll struct {
15664 *OxmId
15665}
15666
15667type IOxmIdIpv6NdTll interface {
15668 IOxmId
15669}
15670
15671func (self *OxmIdIpv6NdTll) Serialize(encoder *goloxi.Encoder) error {
15672 if err := self.OxmId.Serialize(encoder); err != nil {
15673 return err
15674 }
15675
15676 return nil
15677}
15678
15679func DecodeOxmIdIpv6NdTll(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTll, error) {
15680 _oxmidipv6ndtll := &OxmIdIpv6NdTll{OxmId: parent}
15681 return _oxmidipv6ndtll, nil
15682}
15683
15684func NewOxmIdIpv6NdTll() *OxmIdIpv6NdTll {
15685 obj := &OxmIdIpv6NdTll{
15686 OxmId: NewOxmId(2147500550),
15687 }
15688 return obj
15689}
15690func (self *OxmIdIpv6NdTll) GetOXMName() string {
15691 return "ipv6_nd_tll"
15692}
15693
15694func (self *OxmIdIpv6NdTll) MarshalJSON() ([]byte, error) {
15695 if self.TypeLen == 0 {
15696 return []byte("\"\""), nil
15697 } else {
15698 return []byte("\"" + self.GetOXMName() + "\""), nil
15699 }
15700}
15701
15702type OxmIdIpv6NdTllMasked struct {
15703 *OxmId
15704}
15705
15706type IOxmIdIpv6NdTllMasked interface {
15707 IOxmId
15708}
15709
15710func (self *OxmIdIpv6NdTllMasked) Serialize(encoder *goloxi.Encoder) error {
15711 if err := self.OxmId.Serialize(encoder); err != nil {
15712 return err
15713 }
15714
15715 return nil
15716}
15717
15718func DecodeOxmIdIpv6NdTllMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdIpv6NdTllMasked, error) {
15719 _oxmidipv6ndtllmasked := &OxmIdIpv6NdTllMasked{OxmId: parent}
15720 return _oxmidipv6ndtllmasked, nil
15721}
15722
15723func NewOxmIdIpv6NdTllMasked() *OxmIdIpv6NdTllMasked {
15724 obj := &OxmIdIpv6NdTllMasked{
15725 OxmId: NewOxmId(2147500812),
15726 }
15727 return obj
15728}
15729func (self *OxmIdIpv6NdTllMasked) GetOXMName() string {
15730 return "ipv6_nd_tll_masked"
15731}
15732
15733func (self *OxmIdIpv6NdTllMasked) MarshalJSON() ([]byte, error) {
15734 if self.TypeLen == 0 {
15735 return []byte("\"\""), nil
15736 } else {
15737 return []byte("\"" + self.GetOXMName() + "\""), nil
15738 }
15739}
15740
15741type OxmIdMetadata struct {
15742 *OxmId
15743}
15744
15745type IOxmIdMetadata interface {
15746 IOxmId
15747}
15748
15749func (self *OxmIdMetadata) Serialize(encoder *goloxi.Encoder) error {
15750 if err := self.OxmId.Serialize(encoder); err != nil {
15751 return err
15752 }
15753
15754 return nil
15755}
15756
15757func DecodeOxmIdMetadata(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMetadata, error) {
15758 _oxmidmetadata := &OxmIdMetadata{OxmId: parent}
15759 return _oxmidmetadata, nil
15760}
15761
15762func NewOxmIdMetadata() *OxmIdMetadata {
15763 obj := &OxmIdMetadata{
15764 OxmId: NewOxmId(2147484680),
15765 }
15766 return obj
15767}
15768func (self *OxmIdMetadata) GetOXMName() string {
15769 return "metadata"
15770}
15771
15772func (self *OxmIdMetadata) MarshalJSON() ([]byte, error) {
15773 if self.TypeLen == 0 {
15774 return []byte("\"\""), nil
15775 } else {
15776 return []byte("\"" + self.GetOXMName() + "\""), nil
15777 }
15778}
15779
15780type OxmIdMetadataMasked struct {
15781 *OxmId
15782}
15783
15784type IOxmIdMetadataMasked interface {
15785 IOxmId
15786}
15787
15788func (self *OxmIdMetadataMasked) Serialize(encoder *goloxi.Encoder) error {
15789 if err := self.OxmId.Serialize(encoder); err != nil {
15790 return err
15791 }
15792
15793 return nil
15794}
15795
15796func DecodeOxmIdMetadataMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMetadataMasked, error) {
15797 _oxmidmetadatamasked := &OxmIdMetadataMasked{OxmId: parent}
15798 return _oxmidmetadatamasked, nil
15799}
15800
15801func NewOxmIdMetadataMasked() *OxmIdMetadataMasked {
15802 obj := &OxmIdMetadataMasked{
15803 OxmId: NewOxmId(2147484944),
15804 }
15805 return obj
15806}
15807func (self *OxmIdMetadataMasked) GetOXMName() string {
15808 return "metadata_masked"
15809}
15810
15811func (self *OxmIdMetadataMasked) MarshalJSON() ([]byte, error) {
15812 if self.TypeLen == 0 {
15813 return []byte("\"\""), nil
15814 } else {
15815 return []byte("\"" + self.GetOXMName() + "\""), nil
15816 }
15817}
15818
15819type OxmIdMplsLabel struct {
15820 *OxmId
15821}
15822
15823type IOxmIdMplsLabel interface {
15824 IOxmId
15825}
15826
15827func (self *OxmIdMplsLabel) Serialize(encoder *goloxi.Encoder) error {
15828 if err := self.OxmId.Serialize(encoder); err != nil {
15829 return err
15830 }
15831
15832 return nil
15833}
15834
15835func DecodeOxmIdMplsLabel(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsLabel, error) {
15836 _oxmidmplslabel := &OxmIdMplsLabel{OxmId: parent}
15837 return _oxmidmplslabel, nil
15838}
15839
15840func NewOxmIdMplsLabel() *OxmIdMplsLabel {
15841 obj := &OxmIdMplsLabel{
15842 OxmId: NewOxmId(2147501060),
15843 }
15844 return obj
15845}
15846func (self *OxmIdMplsLabel) GetOXMName() string {
15847 return "mpls_label"
15848}
15849
15850func (self *OxmIdMplsLabel) MarshalJSON() ([]byte, error) {
15851 if self.TypeLen == 0 {
15852 return []byte("\"\""), nil
15853 } else {
15854 return []byte("\"" + self.GetOXMName() + "\""), nil
15855 }
15856}
15857
15858type OxmIdMplsLabelMasked struct {
15859 *OxmId
15860}
15861
15862type IOxmIdMplsLabelMasked interface {
15863 IOxmId
15864}
15865
15866func (self *OxmIdMplsLabelMasked) Serialize(encoder *goloxi.Encoder) error {
15867 if err := self.OxmId.Serialize(encoder); err != nil {
15868 return err
15869 }
15870
15871 return nil
15872}
15873
15874func DecodeOxmIdMplsLabelMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsLabelMasked, error) {
15875 _oxmidmplslabelmasked := &OxmIdMplsLabelMasked{OxmId: parent}
15876 return _oxmidmplslabelmasked, nil
15877}
15878
15879func NewOxmIdMplsLabelMasked() *OxmIdMplsLabelMasked {
15880 obj := &OxmIdMplsLabelMasked{
15881 OxmId: NewOxmId(2147501320),
15882 }
15883 return obj
15884}
15885func (self *OxmIdMplsLabelMasked) GetOXMName() string {
15886 return "mpls_label_masked"
15887}
15888
15889func (self *OxmIdMplsLabelMasked) MarshalJSON() ([]byte, error) {
15890 if self.TypeLen == 0 {
15891 return []byte("\"\""), nil
15892 } else {
15893 return []byte("\"" + self.GetOXMName() + "\""), nil
15894 }
15895}
15896
15897type OxmIdMplsTc struct {
15898 *OxmId
15899}
15900
15901type IOxmIdMplsTc interface {
15902 IOxmId
15903}
15904
15905func (self *OxmIdMplsTc) Serialize(encoder *goloxi.Encoder) error {
15906 if err := self.OxmId.Serialize(encoder); err != nil {
15907 return err
15908 }
15909
15910 return nil
15911}
15912
15913func DecodeOxmIdMplsTc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsTc, error) {
15914 _oxmidmplstc := &OxmIdMplsTc{OxmId: parent}
15915 return _oxmidmplstc, nil
15916}
15917
15918func NewOxmIdMplsTc() *OxmIdMplsTc {
15919 obj := &OxmIdMplsTc{
15920 OxmId: NewOxmId(2147501569),
15921 }
15922 return obj
15923}
15924func (self *OxmIdMplsTc) GetOXMName() string {
15925 return "mpls_tc"
15926}
15927
15928func (self *OxmIdMplsTc) MarshalJSON() ([]byte, error) {
15929 if self.TypeLen == 0 {
15930 return []byte("\"\""), nil
15931 } else {
15932 return []byte("\"" + self.GetOXMName() + "\""), nil
15933 }
15934}
15935
15936type OxmIdMplsTcMasked struct {
15937 *OxmId
15938}
15939
15940type IOxmIdMplsTcMasked interface {
15941 IOxmId
15942}
15943
15944func (self *OxmIdMplsTcMasked) Serialize(encoder *goloxi.Encoder) error {
15945 if err := self.OxmId.Serialize(encoder); err != nil {
15946 return err
15947 }
15948
15949 return nil
15950}
15951
15952func DecodeOxmIdMplsTcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdMplsTcMasked, error) {
15953 _oxmidmplstcmasked := &OxmIdMplsTcMasked{OxmId: parent}
15954 return _oxmidmplstcmasked, nil
15955}
15956
15957func NewOxmIdMplsTcMasked() *OxmIdMplsTcMasked {
15958 obj := &OxmIdMplsTcMasked{
15959 OxmId: NewOxmId(2147501826),
15960 }
15961 return obj
15962}
15963func (self *OxmIdMplsTcMasked) GetOXMName() string {
15964 return "mpls_tc_masked"
15965}
15966
15967func (self *OxmIdMplsTcMasked) MarshalJSON() ([]byte, error) {
15968 if self.TypeLen == 0 {
15969 return []byte("\"\""), nil
15970 } else {
15971 return []byte("\"" + self.GetOXMName() + "\""), nil
15972 }
15973}
15974
15975type OxmIdSctpDst struct {
15976 *OxmId
15977}
15978
15979type IOxmIdSctpDst interface {
15980 IOxmId
15981}
15982
15983func (self *OxmIdSctpDst) Serialize(encoder *goloxi.Encoder) error {
15984 if err := self.OxmId.Serialize(encoder); err != nil {
15985 return err
15986 }
15987
15988 return nil
15989}
15990
15991func DecodeOxmIdSctpDst(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpDst, error) {
15992 _oxmidsctpdst := &OxmIdSctpDst{OxmId: parent}
15993 return _oxmidsctpdst, nil
15994}
15995
15996func NewOxmIdSctpDst() *OxmIdSctpDst {
15997 obj := &OxmIdSctpDst{
15998 OxmId: NewOxmId(2147492866),
15999 }
16000 return obj
16001}
16002func (self *OxmIdSctpDst) GetOXMName() string {
16003 return "sctp_dst"
16004}
16005
16006func (self *OxmIdSctpDst) MarshalJSON() ([]byte, error) {
16007 if self.TypeLen == 0 {
16008 return []byte("\"\""), nil
16009 } else {
16010 return []byte("\"" + self.GetOXMName() + "\""), nil
16011 }
16012}
16013
16014type OxmIdSctpDstMasked struct {
16015 *OxmId
16016}
16017
16018type IOxmIdSctpDstMasked interface {
16019 IOxmId
16020}
16021
16022func (self *OxmIdSctpDstMasked) Serialize(encoder *goloxi.Encoder) error {
16023 if err := self.OxmId.Serialize(encoder); err != nil {
16024 return err
16025 }
16026
16027 return nil
16028}
16029
16030func DecodeOxmIdSctpDstMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpDstMasked, error) {
16031 _oxmidsctpdstmasked := &OxmIdSctpDstMasked{OxmId: parent}
16032 return _oxmidsctpdstmasked, nil
16033}
16034
16035func NewOxmIdSctpDstMasked() *OxmIdSctpDstMasked {
16036 obj := &OxmIdSctpDstMasked{
16037 OxmId: NewOxmId(2147493124),
16038 }
16039 return obj
16040}
16041func (self *OxmIdSctpDstMasked) GetOXMName() string {
16042 return "sctp_dst_masked"
16043}
16044
16045func (self *OxmIdSctpDstMasked) MarshalJSON() ([]byte, error) {
16046 if self.TypeLen == 0 {
16047 return []byte("\"\""), nil
16048 } else {
16049 return []byte("\"" + self.GetOXMName() + "\""), nil
16050 }
16051}
16052
16053type OxmIdSctpSrc struct {
16054 *OxmId
16055}
16056
16057type IOxmIdSctpSrc interface {
16058 IOxmId
16059}
16060
16061func (self *OxmIdSctpSrc) Serialize(encoder *goloxi.Encoder) error {
16062 if err := self.OxmId.Serialize(encoder); err != nil {
16063 return err
16064 }
16065
16066 return nil
16067}
16068
16069func DecodeOxmIdSctpSrc(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpSrc, error) {
16070 _oxmidsctpsrc := &OxmIdSctpSrc{OxmId: parent}
16071 return _oxmidsctpsrc, nil
16072}
16073
16074func NewOxmIdSctpSrc() *OxmIdSctpSrc {
16075 obj := &OxmIdSctpSrc{
16076 OxmId: NewOxmId(2147492354),
16077 }
16078 return obj
16079}
16080func (self *OxmIdSctpSrc) GetOXMName() string {
16081 return "sctp_src"
16082}
16083
16084func (self *OxmIdSctpSrc) MarshalJSON() ([]byte, error) {
16085 if self.TypeLen == 0 {
16086 return []byte("\"\""), nil
16087 } else {
16088 return []byte("\"" + self.GetOXMName() + "\""), nil
16089 }
16090}
16091
16092type OxmIdSctpSrcMasked struct {
16093 *OxmId
16094}
16095
16096type IOxmIdSctpSrcMasked interface {
16097 IOxmId
16098}
16099
16100func (self *OxmIdSctpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
16101 if err := self.OxmId.Serialize(encoder); err != nil {
16102 return err
16103 }
16104
16105 return nil
16106}
16107
16108func DecodeOxmIdSctpSrcMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdSctpSrcMasked, error) {
16109 _oxmidsctpsrcmasked := &OxmIdSctpSrcMasked{OxmId: parent}
16110 return _oxmidsctpsrcmasked, nil
16111}
16112
16113func NewOxmIdSctpSrcMasked() *OxmIdSctpSrcMasked {
16114 obj := &OxmIdSctpSrcMasked{
16115 OxmId: NewOxmId(2147492612),
16116 }
16117 return obj
16118}
16119func (self *OxmIdSctpSrcMasked) GetOXMName() string {
16120 return "sctp_src_masked"
16121}
16122
16123func (self *OxmIdSctpSrcMasked) MarshalJSON() ([]byte, error) {
16124 if self.TypeLen == 0 {
16125 return []byte("\"\""), nil
16126 } else {
16127 return []byte("\"" + self.GetOXMName() + "\""), nil
16128 }
16129}
16130
16131type OxmIdVlanPcp struct {
16132 *OxmId
16133}
16134
16135type IOxmIdVlanPcp interface {
16136 IOxmId
16137}
16138
16139func (self *OxmIdVlanPcp) Serialize(encoder *goloxi.Encoder) error {
16140 if err := self.OxmId.Serialize(encoder); err != nil {
16141 return err
16142 }
16143
16144 return nil
16145}
16146
16147func DecodeOxmIdVlanPcp(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanPcp, error) {
16148 _oxmidvlanpcp := &OxmIdVlanPcp{OxmId: parent}
16149 return _oxmidvlanpcp, nil
16150}
16151
16152func NewOxmIdVlanPcp() *OxmIdVlanPcp {
16153 obj := &OxmIdVlanPcp{
16154 OxmId: NewOxmId(2147487233),
16155 }
16156 return obj
16157}
16158func (self *OxmIdVlanPcp) GetOXMName() string {
16159 return "vlan_pcp"
16160}
16161
16162func (self *OxmIdVlanPcp) MarshalJSON() ([]byte, error) {
16163 if self.TypeLen == 0 {
16164 return []byte("\"\""), nil
16165 } else {
16166 return []byte("\"" + self.GetOXMName() + "\""), nil
16167 }
16168}
16169
16170type OxmIdVlanPcpMasked struct {
16171 *OxmId
16172}
16173
16174type IOxmIdVlanPcpMasked interface {
16175 IOxmId
16176}
16177
16178func (self *OxmIdVlanPcpMasked) Serialize(encoder *goloxi.Encoder) error {
16179 if err := self.OxmId.Serialize(encoder); err != nil {
16180 return err
16181 }
16182
16183 return nil
16184}
16185
16186func DecodeOxmIdVlanPcpMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanPcpMasked, error) {
16187 _oxmidvlanpcpmasked := &OxmIdVlanPcpMasked{OxmId: parent}
16188 return _oxmidvlanpcpmasked, nil
16189}
16190
16191func NewOxmIdVlanPcpMasked() *OxmIdVlanPcpMasked {
16192 obj := &OxmIdVlanPcpMasked{
16193 OxmId: NewOxmId(2147487490),
16194 }
16195 return obj
16196}
16197func (self *OxmIdVlanPcpMasked) GetOXMName() string {
16198 return "vlan_pcp_masked"
16199}
16200
16201func (self *OxmIdVlanPcpMasked) MarshalJSON() ([]byte, error) {
16202 if self.TypeLen == 0 {
16203 return []byte("\"\""), nil
16204 } else {
16205 return []byte("\"" + self.GetOXMName() + "\""), nil
16206 }
16207}
16208
16209type OxmIdVlanVid struct {
16210 *OxmId
16211}
16212
16213type IOxmIdVlanVid interface {
16214 IOxmId
16215}
16216
16217func (self *OxmIdVlanVid) Serialize(encoder *goloxi.Encoder) error {
16218 if err := self.OxmId.Serialize(encoder); err != nil {
16219 return err
16220 }
16221
16222 return nil
16223}
16224
16225func DecodeOxmIdVlanVid(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanVid, error) {
16226 _oxmidvlanvid := &OxmIdVlanVid{OxmId: parent}
16227 return _oxmidvlanvid, nil
16228}
16229
16230func NewOxmIdVlanVid() *OxmIdVlanVid {
16231 obj := &OxmIdVlanVid{
16232 OxmId: NewOxmId(2147486722),
16233 }
16234 return obj
16235}
16236func (self *OxmIdVlanVid) GetOXMName() string {
16237 return "vlan_vid"
16238}
16239
16240func (self *OxmIdVlanVid) MarshalJSON() ([]byte, error) {
16241 if self.TypeLen == 0 {
16242 return []byte("\"\""), nil
16243 } else {
16244 return []byte("\"" + self.GetOXMName() + "\""), nil
16245 }
16246}
16247
16248type OxmIdVlanVidMasked struct {
16249 *OxmId
16250}
16251
16252type IOxmIdVlanVidMasked interface {
16253 IOxmId
16254}
16255
16256func (self *OxmIdVlanVidMasked) Serialize(encoder *goloxi.Encoder) error {
16257 if err := self.OxmId.Serialize(encoder); err != nil {
16258 return err
16259 }
16260
16261 return nil
16262}
16263
16264func DecodeOxmIdVlanVidMasked(parent *OxmId, decoder *goloxi.Decoder) (*OxmIdVlanVidMasked, error) {
16265 _oxmidvlanvidmasked := &OxmIdVlanVidMasked{OxmId: parent}
16266 return _oxmidvlanvidmasked, nil
16267}
16268
16269func NewOxmIdVlanVidMasked() *OxmIdVlanVidMasked {
16270 obj := &OxmIdVlanVidMasked{
16271 OxmId: NewOxmId(2147486980),
16272 }
16273 return obj
16274}
16275func (self *OxmIdVlanVidMasked) GetOXMName() string {
16276 return "vlan_vid_masked"
16277}
16278
16279func (self *OxmIdVlanVidMasked) MarshalJSON() ([]byte, error) {
16280 if self.TypeLen == 0 {
16281 return []byte("\"\""), nil
16282 } else {
16283 return []byte("\"" + self.GetOXMName() + "\""), nil
16284 }
16285}
16286
16287type PacketQueue struct {
16288 QueueId uint32
16289 Len uint16
16290 Properties []IQueueProp
16291}
16292
16293type IPacketQueue interface {
16294 goloxi.Serializable
16295 GetQueueId() uint32
16296 GetLen() uint16
16297 GetProperties() []IQueueProp
16298}
16299
16300func (self *PacketQueue) GetQueueId() uint32 {
16301 return self.QueueId
16302}
16303
16304func (self *PacketQueue) SetQueueId(v uint32) {
16305 self.QueueId = v
16306}
16307
16308func (self *PacketQueue) GetLen() uint16 {
16309 return self.Len
16310}
16311
16312func (self *PacketQueue) SetLen(v uint16) {
16313 self.Len = v
16314}
16315
16316func (self *PacketQueue) GetProperties() []IQueueProp {
16317 return self.Properties
16318}
16319
16320func (self *PacketQueue) SetProperties(v []IQueueProp) {
16321 self.Properties = v
16322}
16323
16324func (self *PacketQueue) Serialize(encoder *goloxi.Encoder) error {
16325 startIndex := len(encoder.Bytes())
16326
16327 encoder.PutUint32(uint32(self.QueueId))
16328 encoder.PutUint16(uint16(self.Len))
16329 encoder.Write(bytes.Repeat([]byte{0}, 2))
16330 for _, obj := range self.Properties {
16331 if err := obj.Serialize(encoder); err != nil {
16332 return err
16333 }
16334 }
16335 length := len(encoder.Bytes()) - startIndex
16336
16337 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+4:startIndex+6], uint16(length))
16338
16339 return nil
16340}
16341
16342func DecodePacketQueue(decoder *goloxi.Decoder) (*PacketQueue, error) {
16343 _packetqueue := &PacketQueue{}
16344 if decoder.Length() < 8 {
16345 return nil, fmt.Errorf("PacketQueue packet too short: %d < 8", decoder.Length())
16346 }
16347 _packetqueue.QueueId = uint32(decoder.ReadUint32())
16348 _packetqueue.Len = uint16(decoder.ReadUint16())
16349 oldDecoder := decoder
16350 defer func() { decoder = oldDecoder }()
16351 decoder = decoder.SliceDecoder(int(_packetqueue.Len), 2+4)
16352 decoder.Skip(2)
16353
16354 for decoder.Length() >= 8 {
16355 item, err := DecodeQueueProp(decoder)
16356 if err != nil {
16357 return nil, err
16358 }
16359 if item != nil {
16360 _packetqueue.Properties = append(_packetqueue.Properties, item)
16361 }
16362 }
16363 return _packetqueue, nil
16364}
16365
16366func NewPacketQueue() *PacketQueue {
16367 obj := &PacketQueue{}
16368 return obj
16369}
16370
16371type PortDesc struct {
16372 PortNo Port
16373 HwAddr net.HardwareAddr
16374 Name string
16375 Config PortConfig
16376 State PortState
16377 Curr PortFeatures
16378 Advertised PortFeatures
16379 Supported PortFeatures
16380 Peer PortFeatures
16381}
16382
16383type IPortDesc interface {
16384 goloxi.Serializable
16385 GetPortNo() Port
16386 GetHwAddr() net.HardwareAddr
16387 GetName() string
16388 GetConfig() PortConfig
16389 GetState() PortState
16390 GetCurr() PortFeatures
16391 GetAdvertised() PortFeatures
16392 GetSupported() PortFeatures
16393 GetPeer() PortFeatures
16394}
16395
16396func (self *PortDesc) GetPortNo() Port {
16397 return self.PortNo
16398}
16399
16400func (self *PortDesc) SetPortNo(v Port) {
16401 self.PortNo = v
16402}
16403
16404func (self *PortDesc) GetHwAddr() net.HardwareAddr {
16405 return self.HwAddr
16406}
16407
16408func (self *PortDesc) SetHwAddr(v net.HardwareAddr) {
16409 self.HwAddr = v
16410}
16411
16412func (self *PortDesc) GetName() string {
16413 return self.Name
16414}
16415
16416func (self *PortDesc) SetName(v string) {
16417 self.Name = v
16418}
16419
16420func (self *PortDesc) GetConfig() PortConfig {
16421 return self.Config
16422}
16423
16424func (self *PortDesc) SetConfig(v PortConfig) {
16425 self.Config = v
16426}
16427
16428func (self *PortDesc) GetState() PortState {
16429 return self.State
16430}
16431
16432func (self *PortDesc) SetState(v PortState) {
16433 self.State = v
16434}
16435
16436func (self *PortDesc) GetCurr() PortFeatures {
16437 return self.Curr
16438}
16439
16440func (self *PortDesc) SetCurr(v PortFeatures) {
16441 self.Curr = v
16442}
16443
16444func (self *PortDesc) GetAdvertised() PortFeatures {
16445 return self.Advertised
16446}
16447
16448func (self *PortDesc) SetAdvertised(v PortFeatures) {
16449 self.Advertised = v
16450}
16451
16452func (self *PortDesc) GetSupported() PortFeatures {
16453 return self.Supported
16454}
16455
16456func (self *PortDesc) SetSupported(v PortFeatures) {
16457 self.Supported = v
16458}
16459
16460func (self *PortDesc) GetPeer() PortFeatures {
16461 return self.Peer
16462}
16463
16464func (self *PortDesc) SetPeer(v PortFeatures) {
16465 self.Peer = v
16466}
16467
16468func (self *PortDesc) Serialize(encoder *goloxi.Encoder) error {
16469
16470 self.PortNo.Serialize(encoder)
16471 encoder.Write(self.HwAddr)
16472 encoder.Write([]byte(self.Name))
16473 encoder.PutUint32(uint32(self.Config))
16474 encoder.PutUint32(uint32(self.State))
16475 encoder.PutUint32(uint32(self.Curr))
16476 encoder.PutUint32(uint32(self.Advertised))
16477 encoder.PutUint32(uint32(self.Supported))
16478 encoder.PutUint32(uint32(self.Peer))
16479
16480 return nil
16481}
16482func (self *PortDesc) Decode(decoder *goloxi.Decoder) error {
16483 if decoder.Length() < 48 {
16484 return fmt.Errorf("PortDesc packet too short: %d < 48", decoder.Length())
16485 }
16486
16487 self.PortNo.Decode(decoder)
16488 self.HwAddr = net.HardwareAddr(decoder.Read(6))
16489 self.Name = string(bytes.Trim(decoder.Read(16), "\x00"))
16490 self.Config = PortConfig(decoder.ReadUint32())
16491 self.State = PortState(decoder.ReadUint32())
16492 self.Curr = PortFeatures(decoder.ReadUint32())
16493 self.Advertised = PortFeatures(decoder.ReadUint32())
16494 self.Supported = PortFeatures(decoder.ReadUint32())
16495 self.Peer = PortFeatures(decoder.ReadUint32())
16496
16497 return nil
16498}
16499
16500func NewPortDesc() *PortDesc {
16501 obj := &PortDesc{}
16502 return obj
16503}
16504
16505type PortStatsEntry struct {
16506 PortNo Port
16507 RxPackets uint64
16508 TxPackets uint64
16509 RxBytes uint64
16510 TxBytes uint64
16511 RxDropped uint64
16512 TxDropped uint64
16513 RxErrors uint64
16514 TxErrors uint64
16515 RxFrameErr uint64
16516 RxOverErr uint64
16517 RxCrcErr uint64
16518 Collisions uint64
16519}
16520
16521type IPortStatsEntry interface {
16522 goloxi.Serializable
16523 GetPortNo() Port
16524 GetRxPackets() uint64
16525 GetTxPackets() uint64
16526 GetRxBytes() uint64
16527 GetTxBytes() uint64
16528 GetRxDropped() uint64
16529 GetTxDropped() uint64
16530 GetRxErrors() uint64
16531 GetTxErrors() uint64
16532 GetRxFrameErr() uint64
16533 GetRxOverErr() uint64
16534 GetRxCrcErr() uint64
16535 GetCollisions() uint64
16536}
16537
16538func (self *PortStatsEntry) GetPortNo() Port {
16539 return self.PortNo
16540}
16541
16542func (self *PortStatsEntry) SetPortNo(v Port) {
16543 self.PortNo = v
16544}
16545
16546func (self *PortStatsEntry) GetRxPackets() uint64 {
16547 return self.RxPackets
16548}
16549
16550func (self *PortStatsEntry) SetRxPackets(v uint64) {
16551 self.RxPackets = v
16552}
16553
16554func (self *PortStatsEntry) GetTxPackets() uint64 {
16555 return self.TxPackets
16556}
16557
16558func (self *PortStatsEntry) SetTxPackets(v uint64) {
16559 self.TxPackets = v
16560}
16561
16562func (self *PortStatsEntry) GetRxBytes() uint64 {
16563 return self.RxBytes
16564}
16565
16566func (self *PortStatsEntry) SetRxBytes(v uint64) {
16567 self.RxBytes = v
16568}
16569
16570func (self *PortStatsEntry) GetTxBytes() uint64 {
16571 return self.TxBytes
16572}
16573
16574func (self *PortStatsEntry) SetTxBytes(v uint64) {
16575 self.TxBytes = v
16576}
16577
16578func (self *PortStatsEntry) GetRxDropped() uint64 {
16579 return self.RxDropped
16580}
16581
16582func (self *PortStatsEntry) SetRxDropped(v uint64) {
16583 self.RxDropped = v
16584}
16585
16586func (self *PortStatsEntry) GetTxDropped() uint64 {
16587 return self.TxDropped
16588}
16589
16590func (self *PortStatsEntry) SetTxDropped(v uint64) {
16591 self.TxDropped = v
16592}
16593
16594func (self *PortStatsEntry) GetRxErrors() uint64 {
16595 return self.RxErrors
16596}
16597
16598func (self *PortStatsEntry) SetRxErrors(v uint64) {
16599 self.RxErrors = v
16600}
16601
16602func (self *PortStatsEntry) GetTxErrors() uint64 {
16603 return self.TxErrors
16604}
16605
16606func (self *PortStatsEntry) SetTxErrors(v uint64) {
16607 self.TxErrors = v
16608}
16609
16610func (self *PortStatsEntry) GetRxFrameErr() uint64 {
16611 return self.RxFrameErr
16612}
16613
16614func (self *PortStatsEntry) SetRxFrameErr(v uint64) {
16615 self.RxFrameErr = v
16616}
16617
16618func (self *PortStatsEntry) GetRxOverErr() uint64 {
16619 return self.RxOverErr
16620}
16621
16622func (self *PortStatsEntry) SetRxOverErr(v uint64) {
16623 self.RxOverErr = v
16624}
16625
16626func (self *PortStatsEntry) GetRxCrcErr() uint64 {
16627 return self.RxCrcErr
16628}
16629
16630func (self *PortStatsEntry) SetRxCrcErr(v uint64) {
16631 self.RxCrcErr = v
16632}
16633
16634func (self *PortStatsEntry) GetCollisions() uint64 {
16635 return self.Collisions
16636}
16637
16638func (self *PortStatsEntry) SetCollisions(v uint64) {
16639 self.Collisions = v
16640}
16641
16642func (self *PortStatsEntry) Serialize(encoder *goloxi.Encoder) error {
16643
16644 self.PortNo.Serialize(encoder)
16645 encoder.Write(bytes.Repeat([]byte{0}, 6))
16646 encoder.PutUint64(uint64(self.RxPackets))
16647 encoder.PutUint64(uint64(self.TxPackets))
16648 encoder.PutUint64(uint64(self.RxBytes))
16649 encoder.PutUint64(uint64(self.TxBytes))
16650 encoder.PutUint64(uint64(self.RxDropped))
16651 encoder.PutUint64(uint64(self.TxDropped))
16652 encoder.PutUint64(uint64(self.RxErrors))
16653 encoder.PutUint64(uint64(self.TxErrors))
16654 encoder.PutUint64(uint64(self.RxFrameErr))
16655 encoder.PutUint64(uint64(self.RxOverErr))
16656 encoder.PutUint64(uint64(self.RxCrcErr))
16657 encoder.PutUint64(uint64(self.Collisions))
16658
16659 return nil
16660}
16661
16662func DecodePortStatsEntry(decoder *goloxi.Decoder) (*PortStatsEntry, error) {
16663 _portstatsentry := &PortStatsEntry{}
16664 if decoder.Length() < 104 {
16665 return nil, fmt.Errorf("PortStatsEntry packet too short: %d < 104", decoder.Length())
16666 }
16667 _portstatsentry.PortNo.Decode(decoder)
16668 decoder.Skip(6)
16669 _portstatsentry.RxPackets = uint64(decoder.ReadUint64())
16670 _portstatsentry.TxPackets = uint64(decoder.ReadUint64())
16671 _portstatsentry.RxBytes = uint64(decoder.ReadUint64())
16672 _portstatsentry.TxBytes = uint64(decoder.ReadUint64())
16673 _portstatsentry.RxDropped = uint64(decoder.ReadUint64())
16674 _portstatsentry.TxDropped = uint64(decoder.ReadUint64())
16675 _portstatsentry.RxErrors = uint64(decoder.ReadUint64())
16676 _portstatsentry.TxErrors = uint64(decoder.ReadUint64())
16677 _portstatsentry.RxFrameErr = uint64(decoder.ReadUint64())
16678 _portstatsentry.RxOverErr = uint64(decoder.ReadUint64())
16679 _portstatsentry.RxCrcErr = uint64(decoder.ReadUint64())
16680 _portstatsentry.Collisions = uint64(decoder.ReadUint64())
16681 return _portstatsentry, nil
16682}
16683
16684func NewPortStatsEntry() *PortStatsEntry {
16685 obj := &PortStatsEntry{}
16686 return obj
16687}
16688
16689type QueueProp struct {
16690 Type uint16
16691 Len uint16
16692}
16693
16694type IQueueProp interface {
16695 goloxi.Serializable
16696 GetType() uint16
16697 GetLen() uint16
16698}
16699
16700func (self *QueueProp) GetType() uint16 {
16701 return self.Type
16702}
16703
16704func (self *QueueProp) SetType(v uint16) {
16705 self.Type = v
16706}
16707
16708func (self *QueueProp) GetLen() uint16 {
16709 return self.Len
16710}
16711
16712func (self *QueueProp) SetLen(v uint16) {
16713 self.Len = v
16714}
16715
16716func (self *QueueProp) Serialize(encoder *goloxi.Encoder) error {
16717
16718 encoder.PutUint16(uint16(self.Type))
16719 encoder.PutUint16(uint16(self.Len))
16720
16721 return nil
16722}
16723
16724func DecodeQueueProp(decoder *goloxi.Decoder) (IQueueProp, error) {
16725 _queueprop := &QueueProp{}
16726 if decoder.Length() < 4 {
16727 return nil, fmt.Errorf("QueueProp packet too short: %d < 4", decoder.Length())
16728 }
16729 _queueprop.Type = uint16(decoder.ReadUint16())
16730 _queueprop.Len = uint16(decoder.ReadUint16())
16731 oldDecoder := decoder
16732 defer func() { decoder = oldDecoder }()
16733 decoder = decoder.SliceDecoder(int(_queueprop.Len), 2+2)
16734
16735 switch _queueprop.Type {
16736 case 1:
16737 return DecodeQueuePropMinRate(_queueprop, decoder)
16738 default:
16739 return nil, fmt.Errorf("Invalid type '%d' for 'QueueProp'", _queueprop.Type)
16740 }
16741}
16742
16743func NewQueueProp(_type uint16) *QueueProp {
16744 obj := &QueueProp{}
16745 obj.Type = _type
16746 return obj
16747}
16748
16749type QueuePropMinRate struct {
16750 *QueueProp
16751 Rate uint16
16752}
16753
16754type IQueuePropMinRate interface {
16755 IQueueProp
16756 GetRate() uint16
16757}
16758
16759func (self *QueuePropMinRate) GetRate() uint16 {
16760 return self.Rate
16761}
16762
16763func (self *QueuePropMinRate) SetRate(v uint16) {
16764 self.Rate = v
16765}
16766
16767func (self *QueuePropMinRate) Serialize(encoder *goloxi.Encoder) error {
16768 startIndex := len(encoder.Bytes())
16769 if err := self.QueueProp.Serialize(encoder); err != nil {
16770 return err
16771 }
16772
16773 encoder.Write(bytes.Repeat([]byte{0}, 4))
16774 encoder.PutUint16(uint16(self.Rate))
16775 encoder.Write(bytes.Repeat([]byte{0}, 6))
16776 length := len(encoder.Bytes()) - startIndex
16777
16778 binary.BigEndian.PutUint16(encoder.Bytes()[startIndex+2:startIndex+4], uint16(length))
16779
16780 return nil
16781}
16782
16783func DecodeQueuePropMinRate(parent *QueueProp, decoder *goloxi.Decoder) (*QueuePropMinRate, error) {
16784 _queuepropminrate := &QueuePropMinRate{QueueProp: parent}
16785 if decoder.Length() < 12 {
16786 return nil, fmt.Errorf("QueuePropMinRate packet too short: %d < 12", decoder.Length())
16787 }
16788 decoder.Skip(4)
16789 _queuepropminrate.Rate = uint16(decoder.ReadUint16())
16790 decoder.Skip(6)
16791 return _queuepropminrate, nil
16792}
16793
16794func NewQueuePropMinRate() *QueuePropMinRate {
16795 obj := &QueuePropMinRate{
16796 QueueProp: NewQueueProp(1),
16797 }
16798 return obj
16799}
16800
16801type QueueStatsEntry struct {
16802 PortNo Port
16803 QueueId uint32
16804 TxBytes uint64
16805 TxPackets uint64
16806 TxErrors uint64
16807}
16808
16809type IQueueStatsEntry interface {
16810 goloxi.Serializable
16811 GetPortNo() Port
16812 GetQueueId() uint32
16813 GetTxBytes() uint64
16814 GetTxPackets() uint64
16815 GetTxErrors() uint64
16816}
16817
16818func (self *QueueStatsEntry) GetPortNo() Port {
16819 return self.PortNo
16820}
16821
16822func (self *QueueStatsEntry) SetPortNo(v Port) {
16823 self.PortNo = v
16824}
16825
16826func (self *QueueStatsEntry) GetQueueId() uint32 {
16827 return self.QueueId
16828}
16829
16830func (self *QueueStatsEntry) SetQueueId(v uint32) {
16831 self.QueueId = v
16832}
16833
16834func (self *QueueStatsEntry) GetTxBytes() uint64 {
16835 return self.TxBytes
16836}
16837
16838func (self *QueueStatsEntry) SetTxBytes(v uint64) {
16839 self.TxBytes = v
16840}
16841
16842func (self *QueueStatsEntry) GetTxPackets() uint64 {
16843 return self.TxPackets
16844}
16845
16846func (self *QueueStatsEntry) SetTxPackets(v uint64) {
16847 self.TxPackets = v
16848}
16849
16850func (self *QueueStatsEntry) GetTxErrors() uint64 {
16851 return self.TxErrors
16852}
16853
16854func (self *QueueStatsEntry) SetTxErrors(v uint64) {
16855 self.TxErrors = v
16856}
16857
16858func (self *QueueStatsEntry) Serialize(encoder *goloxi.Encoder) error {
16859
16860 self.PortNo.Serialize(encoder)
16861 encoder.Write(bytes.Repeat([]byte{0}, 2))
16862 encoder.PutUint32(uint32(self.QueueId))
16863 encoder.PutUint64(uint64(self.TxBytes))
16864 encoder.PutUint64(uint64(self.TxPackets))
16865 encoder.PutUint64(uint64(self.TxErrors))
16866
16867 return nil
16868}
16869
16870func DecodeQueueStatsEntry(decoder *goloxi.Decoder) (*QueueStatsEntry, error) {
16871 _queuestatsentry := &QueueStatsEntry{}
16872 if decoder.Length() < 32 {
16873 return nil, fmt.Errorf("QueueStatsEntry packet too short: %d < 32", decoder.Length())
16874 }
16875 _queuestatsentry.PortNo.Decode(decoder)
16876 decoder.Skip(2)
16877 _queuestatsentry.QueueId = uint32(decoder.ReadUint32())
16878 _queuestatsentry.TxBytes = uint64(decoder.ReadUint64())
16879 _queuestatsentry.TxPackets = uint64(decoder.ReadUint64())
16880 _queuestatsentry.TxErrors = uint64(decoder.ReadUint64())
16881 return _queuestatsentry, nil
16882}
16883
16884func NewQueueStatsEntry() *QueueStatsEntry {
16885 obj := &QueueStatsEntry{}
16886 return obj
16887}
16888
16889type TableStatsEntry struct {
16890 TableId uint8
16891 Name string
16892 Wildcards WcBmap
16893 MaxEntries uint32
16894 ActiveCount uint32
16895 LookupCount uint64
16896 MatchedCount uint64
16897}
16898
16899type ITableStatsEntry interface {
16900 goloxi.Serializable
16901 GetTableId() uint8
16902 GetName() string
16903 GetWildcards() WcBmap
16904 GetMaxEntries() uint32
16905 GetActiveCount() uint32
16906 GetLookupCount() uint64
16907 GetMatchedCount() uint64
16908}
16909
16910func (self *TableStatsEntry) GetTableId() uint8 {
16911 return self.TableId
16912}
16913
16914func (self *TableStatsEntry) SetTableId(v uint8) {
16915 self.TableId = v
16916}
16917
16918func (self *TableStatsEntry) GetName() string {
16919 return self.Name
16920}
16921
16922func (self *TableStatsEntry) SetName(v string) {
16923 self.Name = v
16924}
16925
16926func (self *TableStatsEntry) GetWildcards() WcBmap {
16927 return self.Wildcards
16928}
16929
16930func (self *TableStatsEntry) SetWildcards(v WcBmap) {
16931 self.Wildcards = v
16932}
16933
16934func (self *TableStatsEntry) GetMaxEntries() uint32 {
16935 return self.MaxEntries
16936}
16937
16938func (self *TableStatsEntry) SetMaxEntries(v uint32) {
16939 self.MaxEntries = v
16940}
16941
16942func (self *TableStatsEntry) GetActiveCount() uint32 {
16943 return self.ActiveCount
16944}
16945
16946func (self *TableStatsEntry) SetActiveCount(v uint32) {
16947 self.ActiveCount = v
16948}
16949
16950func (self *TableStatsEntry) GetLookupCount() uint64 {
16951 return self.LookupCount
16952}
16953
16954func (self *TableStatsEntry) SetLookupCount(v uint64) {
16955 self.LookupCount = v
16956}
16957
16958func (self *TableStatsEntry) GetMatchedCount() uint64 {
16959 return self.MatchedCount
16960}
16961
16962func (self *TableStatsEntry) SetMatchedCount(v uint64) {
16963 self.MatchedCount = v
16964}
16965
16966func (self *TableStatsEntry) Serialize(encoder *goloxi.Encoder) error {
16967
16968 encoder.PutUint8(uint8(self.TableId))
16969 encoder.Write(bytes.Repeat([]byte{0}, 3))
16970 encoder.Write([]byte(self.Name))
16971 self.Wildcards.Serialize(encoder)
16972 encoder.PutUint32(uint32(self.MaxEntries))
16973 encoder.PutUint32(uint32(self.ActiveCount))
16974 encoder.PutUint64(uint64(self.LookupCount))
16975 encoder.PutUint64(uint64(self.MatchedCount))
16976
16977 return nil
16978}
16979
16980func DecodeTableStatsEntry(decoder *goloxi.Decoder) (*TableStatsEntry, error) {
16981 _tablestatsentry := &TableStatsEntry{}
16982 if decoder.Length() < 64 {
16983 return nil, fmt.Errorf("TableStatsEntry packet too short: %d < 64", decoder.Length())
16984 }
16985 _tablestatsentry.TableId = uint8(decoder.ReadByte())
16986 decoder.Skip(3)
16987 _tablestatsentry.Name = string(bytes.Trim(decoder.Read(32), "\x00"))
16988 _tablestatsentry.Wildcards.Decode(decoder)
16989 _tablestatsentry.MaxEntries = uint32(decoder.ReadUint32())
16990 _tablestatsentry.ActiveCount = uint32(decoder.ReadUint32())
16991 _tablestatsentry.LookupCount = uint64(decoder.ReadUint64())
16992 _tablestatsentry.MatchedCount = uint64(decoder.ReadUint64())
16993 return _tablestatsentry, nil
16994}
16995
16996func NewTableStatsEntry() *TableStatsEntry {
16997 obj := &TableStatsEntry{}
16998 return obj
16999}