Gitiles
Code Review Sign In
gerrit.opencord.org / goloxi / 44bdbfc319927fdbd8a09267da232ae09bc39962 / . / of10 / oxm.go
blob: 1a60627687e1499999edd223fea2c30f436804af [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 "fmt"
14 "net"
15
16 "github.com/opencord/goloxi"
17)
18
19type Oxm struct {
20 TypeLen uint32
21}
22
23type IOxm interface {
24 goloxi.Serializable
25 GetTypeLen() uint32
26 GetOXMName() string
27 GetOXMValue() interface{}
28}
29
30func (self *Oxm) GetTypeLen() uint32 {
31 return self.TypeLen
32}
33
34func (self *Oxm) SetTypeLen(v uint32) {
35 self.TypeLen = v
36}
37
38func (self *Oxm) Serialize(encoder *goloxi.Encoder) error {
39
40 encoder.PutUint32(uint32(self.TypeLen))
41
42 return nil
43}
44
45func DecodeOxm(decoder *goloxi.Decoder) (goloxi.IOxm, error) {
46 _oxm := &Oxm{}
47 if decoder.Length() < 4 {
48 return nil, fmt.Errorf("Oxm packet too short: %d < 4", decoder.Length())
49 }
50 _oxm.TypeLen = uint32(decoder.ReadUint32())
51
52 switch _oxm.TypeLen {
53 case 126465:
54 return DecodeOxmConnTrackingNwProto(_oxm, decoder)
55 case 7682:
56 return DecodeNxmArpOp(_oxm, decoder)
57 case 2147500550:
58 return DecodeOxmIpv6NdTll(_oxm, decoder)
59 case 84484:
60 return DecodeNxmConjId(_oxm, decoder)
61 case 105976:
62 return DecodeNxmTunMetadata38Masked(_oxm, decoder)
63 case 74246:
64 return DecodeNxmArpSha(_oxm, decoder)
65 case 7169:
66 return DecodeNxmIcmpCode(_oxm, decoder)
67 case 73736:
68 return DecodeNxmTunId(_oxm, decoder)
69 case 2147484424:
70 return DecodeOxmInPhyPortMasked(_oxm, decoder)
71 case 70408:
72 return DecodeNxmReg9Masked(_oxm, decoder)
73 case 129026:
74 return DecodeOxmConnTrackingTpSrc(_oxm, decoder)
75 case 127492:
76 return DecodeOxmConnTrackingNwDst(_oxm, decoder)
77 case 2147484680:
78 return DecodeOxmMetadata(_oxm, decoder)
79 case 128528:
80 return DecodeOxmConnTrackingIpv6Dst(_oxm, decoder)
81 case 94332:
82 return DecodeNxmTunMetadata16(_oxm, decoder)
83 case 129538:
84 return DecodeOxmConnTrackingTpDst(_oxm, decoder)
85 case 108536:
86 return DecodeNxmTunMetadata43Masked(_oxm, decoder)
87 case 106488:
88 return DecodeNxmTunMetadata39Masked(_oxm, decoder)
89 case 112764:
90 return DecodeNxmTunMetadata52(_oxm, decoder)
91 case 8708:
92 return DecodeNxmArpTpa(_oxm, decoder)
93 case 2147498754:
94 return DecodeOxmIcmpv6TypeMasked(_oxm, decoder)
95 case 2147493634:
96 return DecodeOxmIcmpv4TypeMasked(_oxm, decoder)
97 case 89080:
98 return DecodeNxmTunMetadata5Masked(_oxm, decoder)
99 case 94844:
100 return DecodeNxmTunMetadata17(_oxm, decoder)
101 case 2147499009:
102 return DecodeOxmIcmpv6Code(_oxm, decoder)
103 case 74758:
104 return DecodeNxmArpTha(_oxm, decoder)
105 case 2147498248:
106 return DecodeOxmIpv6FlabelMasked(_oxm, decoder)
107 case 99964:
108 return DecodeNxmTunMetadata27(_oxm, decoder)
109 case 67336:
110 return DecodeNxmReg3Masked(_oxm, decoder)
111 case 115192:
112 return DecodeNxmTunMetadata56Masked(_oxm, decoder)
113 case 71172:
114 return DecodeNxmReg11(_oxm, decoder)
115 case 79364:
116 return DecodeNxmIpv6Label(_oxm, decoder)
117 case 73480:
118 return DecodeNxmReg15Masked(_oxm, decoder)
119 case 2147495688:
120 return DecodeOxmArpTpaMasked(_oxm, decoder)
121 case 120068:
122 return DecodeOxmConnTrackingZoneMasked(_oxm, decoder)
123 case 107512:
124 return DecodeNxmTunMetadata41Masked(_oxm, decoder)
125 case 116348:
126 return DecodeNxmTunMetadata59(_oxm, decoder)
127 case 89592:
128 return DecodeNxmTunMetadata6Masked(_oxm, decoder)
129 case 110204:
130 return DecodeNxmTunMetadata47(_oxm, decoder)
131 case 77830:
132 return DecodeNxmNdSll(_oxm, decoder)
133 case 117372:
134 return DecodeNxmTunMetadata61(_oxm, decoder)
135 case 2147489796:
136 return DecodeOxmIpv4Dst(_oxm, decoder)
137 case 2147497988:
138 return DecodeOxmIpv6Flabel(_oxm, decoder)
139 case 103928:
140 return DecodeNxmTunMetadata34Masked(_oxm, decoder)
141 case 2147485452:
142 return DecodeOxmEthDstMasked(_oxm, decoder)
143 case 95868:
144 return DecodeNxmTunMetadata19(_oxm, decoder)
145 case 2:
146 return DecodeNxmInPort(_oxm, decoder)
147 case 74507:
148 return DecodeNxmArpShaMasked(_oxm, decoder)
149 case 96892:
150 return DecodeNxmTunMetadata21(_oxm, decoder)
151 case 108024:
152 return DecodeNxmTunMetadata42Masked(_oxm, decoder)
153 case 129284:
154 return DecodeOxmConnTrackingTpSrcMasked(_oxm, decoder)
155 case 112120:
156 return DecodeNxmTunMetadata50Masked(_oxm, decoder)
157 case 2147484944:
158 return DecodeOxmMetadataMasked(_oxm, decoder)
159 case 2147496716:
160 return DecodeOxmArpThaMasked(_oxm, decoder)
161 case 78342:
162 return DecodeNxmNdTll(_oxm, decoder)
163 case 2147486468:
164 return DecodeOxmEthTypeMasked(_oxm, decoder)
165 case 96380:
166 return DecodeNxmTunMetadata20(_oxm, decoder)
167 case 113276:
168 return DecodeNxmTunMetadata53(_oxm, decoder)
169 case 92152:
170 return DecodeNxmTunMetadata11Masked(_oxm, decoder)
171 case 129796:
172 return DecodeOxmConnTrackingTpDstMasked(_oxm, decoder)
173 case 103548:
174 return DecodeNxmTunMetadata34(_oxm, decoder)
175 case 120324:
176 return DecodeOxmConnTrackingMark(_oxm, decoder)
177 case 118776:
178 return DecodeNxmTunMetadata63Masked(_oxm, decoder)
179 case 90748:
180 return DecodeNxmTunMetadata9(_oxm, decoder)
181 case 128016:
182 return DecodeOxmConnTrackingIpv6Src(_oxm, decoder)
183 case 82946:
184 return DecodeNxmTcpFlags(_oxm, decoder)
185 case 2147483912:
186 return DecodeOxmInPortMasked(_oxm, decoder)
187 case 80897:
188 return DecodeNxmMplsTtl(_oxm, decoder)
189 case 92664:
190 return DecodeNxmTunMetadata12Masked(_oxm, decoder)
191 case 123408:
192 return DecodeNxmXxreg2(_oxm, decoder)
193 case 2147499266:
194 return DecodeOxmIcmpv6CodeMasked(_oxm, decoder)
195 case 2147489544:
196 return DecodeOxmIpv4SrcMasked(_oxm, decoder)
197 case 2147487490:
198 return DecodeOxmVlanPcpMasked(_oxm, decoder)
199 case 81412:
200 return DecodeNxmTunSrc(_oxm, decoder)
201 case 5122:
202 return DecodeNxmTcpDst(_oxm, decoder)
203 case 97404:
204 return DecodeNxmTunMetadata22(_oxm, decoder)
205 case 1538:
206 return DecodeNxmEthType(_oxm, decoder)
207 case 2561:
208 return DecodeNxmNwTos(_oxm, decoder)
209 case 93176:
210 return DecodeNxmTunMetadata13Masked(_oxm, decoder)
211 case 2147483652:
212 return DecodeOxmInPort(_oxm, decoder)
213 case 67848:
214 return DecodeNxmReg4Masked(_oxm, decoder)
215 case 115704:
216 return DecodeNxmTunMetadata57Masked(_oxm, decoder)
217 case 86140:
218 return DecodeNxmTunMetadata0(_oxm, decoder)
219 case 65540:
220 return DecodeNxmReg0(_oxm, decoder)
221 case 2147490306:
222 return DecodeOxmTcpSrc(_oxm, decoder)
223 case 2147500038:
224 return DecodeOxmIpv6NdSll(_oxm, decoder)
225 case 97916:
226 return DecodeNxmTunMetadata23(_oxm, decoder)
227 case 2050:
228 return DecodeNxmVlanTci(_oxm, decoder)
229 case 3073:
230 return DecodeNxmNwProto(_oxm, decoder)
231 case 93688:
232 return DecodeNxmTunMetadata14Masked(_oxm, decoder)
233 case 116860:
234 return DecodeNxmTunMetadata60(_oxm, decoder)
235 case 2147487233:
236 return DecodeOxmVlanPcp(_oxm, decoder)
237 case 2147484164:
238 return DecodeOxmInPhyPort(_oxm, decoder)
239 case 2147486980:
240 return DecodeOxmVlanVidMasked(_oxm, decoder)
241 case 113144:
242 return DecodeNxmTunMetadata52Masked(_oxm, decoder)
243 case 82436:
244 return DecodeNxmPktMark(_oxm, decoder)
245 case 121120:
246 return DecodeOxmConnTrackingLabelMasked(_oxm, decoder)
247 case 98428:
248 return DecodeNxmTunMetadata24(_oxm, decoder)
249 case 2147486210:
250 return DecodeOxmEthType(_oxm, decoder)
251 case 85505:
252 return DecodeNxmTunGbpFlags(_oxm, decoder)
253 case 94200:
254 return DecodeNxmTunMetadata15Masked(_oxm, decoder)
255 case 112632:
256 return DecodeNxmTunMetadata51Masked(_oxm, decoder)
257 case 5378:
258 return DecodeNxmTcpDstMasked(_oxm, decoder)
259 case 2147486722:
260 return DecodeOxmVlanVid(_oxm, decoder)
261 case 66564:
262 return DecodeNxmReg2(_oxm, decoder)
263 case 121632:
264 return DecodeNxmTunIpv6SrcMasked(_oxm, decoder)
265 case 103416:
266 return DecodeNxmTunMetadata33Masked(_oxm, decoder)
267 case 98940:
268 return DecodeNxmTunMetadata25(_oxm, decoder)
269 case 84994:
270 return DecodeNxmTunGbpId(_oxm, decoder)
271 case 2147485190:
272 return DecodeOxmEthDst(_oxm, decoder)
273 case 2147487745:
274 return DecodeOxmIpDscp(_oxm, decoder)
275 case 94712:
276 return DecodeNxmTunMetadata16Masked(_oxm, decoder)
277 case 120848:
278 return DecodeOxmConnTrackingLabel(_oxm, decoder)
279 case 109692:
280 return DecodeNxmTunMetadata46(_oxm, decoder)
281 case 69896:
282 return DecodeNxmReg8Masked(_oxm, decoder)
283 case 104060:
284 return DecodeNxmTunMetadata35(_oxm, decoder)
285 case 71432:
286 return DecodeNxmReg11Masked(_oxm, decoder)
287 case 110584:
288 return DecodeNxmTunMetadata47Masked(_oxm, decoder)
289 case 79624:
290 return DecodeNxmIpv6LabelMasked(_oxm, decoder)
291 case 122144:
292 return DecodeNxmTunIpv6DstMasked(_oxm, decoder)
293 case 99452:
294 return DecodeNxmTunMetadata26(_oxm, decoder)
295 case 109560:
296 return DecodeNxmTunMetadata45Masked(_oxm, decoder)
297 case 95224:
298 return DecodeNxmTunMetadata17Masked(_oxm, decoder)
299 case 121360:
300 return DecodeNxmTunIpv6Src(_oxm, decoder)
301 case 85762:
302 return DecodeNxmTunGbpFlagsMasked(_oxm, decoder)
303 case 2147490056:
304 return DecodeOxmIpv4DstMasked(_oxm, decoder)
305 case 83972:
306 return DecodeNxmRecircId(_oxm, decoder)
307 case 122656:
308 return DecodeNxmXxreg0Masked(_oxm, decoder)
309 case 2147490564:
310 return DecodeOxmTcpSrcMasked(_oxm, decoder)
311 case 128800:
312 return DecodeOxmConnTrackingIpv6DstMasked(_oxm, decoder)
313 case 118786:
314 return DecodeNxmTunFlags(_oxm, decoder)
315 case 2147488769:
316 return DecodeOxmIpProto(_oxm, decoder)
317 case 95736:
318 return DecodeNxmTunMetadata18Masked(_oxm, decoder)
319 case 121872:
320 return DecodeNxmTunIpv6Dst(_oxm, decoder)
321 case 81924:
322 return DecodeNxmTunDst(_oxm, decoder)
323 case 68360:
324 return DecodeNxmReg5Masked(_oxm, decoder)
325 case 518:
326 return DecodeNxmEthDst(_oxm, decoder)
327 case 116216:
328 return DecodeNxmTunMetadata58Masked(_oxm, decoder)
329 case 2147501569:
330 return DecodeOxmMplsTc(_oxm, decoder)
331 case 114300:
332 return DecodeNxmTunMetadata55(_oxm, decoder)
333 case 68100:
334 return DecodeNxmReg5(_oxm, decoder)
335 case 123168:
336 return DecodeNxmXxreg1Masked(_oxm, decoder)
337 case 100476:
338 return DecodeNxmTunMetadata28(_oxm, decoder)
339 case 4610:
340 return DecodeNxmTcpSrc(_oxm, decoder)
341 case 123680:
342 return DecodeNxmXxreg2Masked(_oxm, decoder)
343 case 96248:
344 return DecodeNxmTunMetadata19Masked(_oxm, decoder)
345 case 122384:
346 return DecodeNxmXxreg0(_oxm, decoder)
347 case 78091:
348 return DecodeNxmNdSllMasked(_oxm, decoder)
349 case 1030:
350 return DecodeNxmEthSrc(_oxm, decoder)
351 case 68612:
352 return DecodeNxmReg6(_oxm, decoder)
353 case 107644:
354 return DecodeNxmTunMetadata42(_oxm, decoder)
355 case 100988:
356 return DecodeNxmTunMetadata29(_oxm, decoder)
357 case 119810:
358 return DecodeOxmConnTrackingZone(_oxm, decoder)
359 case 96760:
360 return DecodeNxmTunMetadata20Masked(_oxm, decoder)
361 case 85252:
362 return DecodeNxmTunGbpIdMasked(_oxm, decoder)
363 case 78603:
364 return DecodeNxmNdTllMasked(_oxm, decoder)
365 case 86652:
366 return DecodeNxmTunMetadata1(_oxm, decoder)
367 case 69124:
368 return DecodeNxmReg7(_oxm, decoder)
369 case 2147494916:
370 return DecodeOxmArpSpa(_oxm, decoder)
371 case 88188:
372 return DecodeNxmTunMetadata4(_oxm, decoder)
373 case 3588:
374 return DecodeNxmIpSrc(_oxm, decoder)
375 case 124192:
376 return DecodeNxmXxreg3Masked(_oxm, decoder)
377 case 101500:
378 return DecodeNxmTunMetadata30(_oxm, decoder)
379 case 5634:
380 return DecodeNxmUdpSrc(_oxm, decoder)
381 case 127240:
382 return DecodeOxmConnTrackingNwSrcMasked(_oxm, decoder)
383 case 6657:
384 return DecodeNxmIcmpType(_oxm, decoder)
385 case 97272:
386 return DecodeNxmTunMetadata21Masked(_oxm, decoder)
387 case 81672:
388 return DecodeNxmTunSrcMasked(_oxm, decoder)
389 case 122896:
390 return DecodeNxmXxreg1(_oxm, decoder)
391 case 2147489026:
392 return DecodeOxmIpProtoMasked(_oxm, decoder)
393 case 2147485702:
394 return DecodeOxmEthSrc(_oxm, decoder)
395 case 4100:
396 return DecodeNxmIpDst(_oxm, decoder)
397 case 65800:
398 return DecodeNxmReg0Masked(_oxm, decoder)
399 case 75552:
400 return DecodeNxmIpv6SrcMasked(_oxm, decoder)
401 case 102012:
402 return DecodeNxmTunMetadata31(_oxm, decoder)
403 case 79106:
404 return DecodeNxmIpFragMasked(_oxm, decoder)
405 case 2147501826:
406 return DecodeOxmMplsTcMasked(_oxm, decoder)
407 case 8452:
408 return DecodeNxmArpSpaMasked(_oxm, decoder)
409 case 97784:
410 return DecodeNxmTunMetadata22Masked(_oxm, decoder)
411 case 1286:
412 return DecodeNxmEthSrcMasked(_oxm, decoder)
413 case 66052:
414 return DecodeNxmReg1(_oxm, decoder)
415 case 8968:
416 return DecodeNxmArpTpaMasked(_oxm, decoder)
417 case 2147488514:
418 return DecodeOxmIpEcnMasked(_oxm, decoder)
419 case 75019:
420 return DecodeNxmArpThaMasked(_oxm, decoder)
421 case 2147496204:
422 return DecodeOxmArpShaMasked(_oxm, decoder)
423 case 66312:
424 return DecodeNxmReg1Masked(_oxm, decoder)
425 case 74000:
426 return DecodeNxmTunIdMasked(_oxm, decoder)
427 case 102524:
428 return DecodeNxmTunMetadata32(_oxm, decoder)
429 case 111228:
430 return DecodeNxmTunMetadata49(_oxm, decoder)
431 case 88568:
432 return DecodeNxmTunMetadata4Masked(_oxm, decoder)
433 case 2147499536:
434 return DecodeOxmIpv6NdTarget(_oxm, decoder)
435 case 98296:
436 return DecodeNxmTunMetadata23Masked(_oxm, decoder)
437 case 75280:
438 return DecodeNxmIpv6Src(_oxm, decoder)
439 case 68872:
440 return DecodeNxmReg6Masked(_oxm, decoder)
441 case 116728:
442 return DecodeNxmTunMetadata59Masked(_oxm, decoder)
443 case 110072:
444 return DecodeNxmTunMetadata46Masked(_oxm, decoder)
445 case 70660:
446 return DecodeNxmReg10(_oxm, decoder)
447 case 2147491076:
448 return DecodeOxmTcpDstMasked(_oxm, decoder)
449 case 76064:
450 return DecodeNxmIpv6DstMasked(_oxm, decoder)
451 case 103036:
452 return DecodeNxmTunMetadata33(_oxm, decoder)
453 case 107000:
454 return DecodeNxmTunMetadata40Masked(_oxm, decoder)
455 case 110716:
456 return DecodeNxmTunMetadata48(_oxm, decoder)
457 case 98808:
458 return DecodeNxmTunMetadata24Masked(_oxm, decoder)
459 case 75792:
460 return DecodeNxmIpv6Dst(_oxm, decoder)
461 case 2147501060:
462 return DecodeOxmMplsLabel(_oxm, decoder)
463 case 73220:
464 return DecodeNxmReg15(_oxm, decoder)
465 case 117884:
466 return DecodeNxmTunMetadata62(_oxm, decoder)
467 case 83720:
468 return DecodeNxmDpHashMasked(_oxm, decoder)
469 case 108156:
470 return DecodeNxmTunMetadata43(_oxm, decoder)
471 case 87164:
472 return DecodeNxmTunMetadata2(_oxm, decoder)
473 case 2147491330:
474 return DecodeOxmUdpSrc(_oxm, decoder)
475 case 99320:
476 return DecodeNxmTunMetadata25Masked(_oxm, decoder)
477 case 5892:
478 return DecodeNxmUdpSrcMasked(_oxm, decoder)
479 case 113656:
480 return DecodeNxmTunMetadata53Masked(_oxm, decoder)
481 case 2147497248:
482 return DecodeOxmIpv6SrcMasked(_oxm, decoder)
483 case 69636:
484 return DecodeNxmReg8(_oxm, decoder)
485 case 88700:
486 return DecodeNxmTunMetadata5(_oxm, decoder)
487 case 113788:
488 return DecodeNxmTunMetadata54(_oxm, decoder)
489 case 71684:
490 return DecodeNxmReg12(_oxm, decoder)
491 case 77600:
492 return DecodeNxmNdTargetMasked(_oxm, decoder)
493 case 87676:
494 return DecodeNxmTunMetadata3(_oxm, decoder)
495 case 2147491842:
496 return DecodeOxmUdpDst(_oxm, decoder)
497 case 127752:
498 return DecodeOxmConnTrackingNwDstMasked(_oxm, decoder)
499 case 99832:
500 return DecodeNxmTunMetadata26Masked(_oxm, decoder)
501 case 114812:
502 return DecodeNxmTunMetadata56(_oxm, decoder)
503 case 82184:
504 return DecodeNxmTunDstMasked(_oxm, decoder)
505 case 90236:
506 return DecodeNxmTunMetadata8(_oxm, decoder)
507 case 72196:
508 return DecodeNxmReg13(_oxm, decoder)
509 case 104572:
510 return DecodeNxmTunMetadata36(_oxm, decoder)
511 case 2147492354:
512 return DecodeOxmSctpSrc(_oxm, decoder)
513 case 95356:
514 return DecodeNxmTunMetadata18(_oxm, decoder)
515 case 2147493377:
516 return DecodeOxmIcmpv4Type(_oxm, decoder)
517 case 100344:
518 return DecodeNxmTunMetadata27Masked(_oxm, decoder)
519 case 77328:
520 return DecodeNxmNdTarget(_oxm, decoder)
521 case 2147488257:
522 return DecodeOxmIpEcn(_oxm, decoder)
523 case 118264:
524 return DecodeNxmTunMetadata62Masked(_oxm, decoder)
525 case 90616:
526 return DecodeNxmTunMetadata8Masked(_oxm, decoder)
527 case 72708:
528 return DecodeNxmReg14(_oxm, decoder)
529 case 114680:
530 return DecodeNxmTunMetadata55Masked(_oxm, decoder)
531 case 105084:
532 return DecodeNxmTunMetadata37(_oxm, decoder)
533 case 91128:
534 return DecodeNxmTunMetadata9Masked(_oxm, decoder)
535 case 111740:
536 return DecodeNxmTunMetadata50(_oxm, decoder)
537 case 2147493889:
538 return DecodeOxmIcmpv4Code(_oxm, decoder)
539 case 100856:
540 return DecodeNxmTunMetadata28Masked(_oxm, decoder)
541 case 2308:
542 return DecodeNxmVlanTciMasked(_oxm, decoder)
543 case 2147501320:
544 return DecodeOxmMplsLabelMasked(_oxm, decoder)
545 case 779:
546 return DecodeNxmEthDstMasked(_oxm, decoder)
547 case 2147493124:
548 return DecodeOxmSctpDstMasked(_oxm, decoder)
549 case 69384:
550 return DecodeNxmReg7Masked(_oxm, decoder)
551 case 117240:
552 return DecodeNxmTunMetadata60Masked(_oxm, decoder)
553 case 3848:
554 return DecodeNxmIpSrcMasked(_oxm, decoder)
555 case 128288:
556 return DecodeOxmConnTrackingIpv6SrcMasked(_oxm, decoder)
557 case 92284:
558 return DecodeNxmTunMetadata12(_oxm, decoder)
559 case 105596:
560 return DecodeNxmTunMetadata38(_oxm, decoder)
561 case 4868:
562 return DecodeNxmTcpSrcMasked(_oxm, decoder)
563 case 76289:
564 return DecodeNxmIcmpv6Type(_oxm, decoder)
565 case 101368:
566 return DecodeNxmTunMetadata29Masked(_oxm, decoder)
567 case 2147500300:
568 return DecodeOxmIpv6NdSllMasked(_oxm, decoder)
569 case 88056:
570 return DecodeNxmTunMetadata3Masked(_oxm, decoder)
571 case 118396:
572 return DecodeNxmTunMetadata63(_oxm, decoder)
573 case 2147494402:
574 return DecodeOxmArpOp(_oxm, decoder)
575 case 2147496454:
576 return DecodeOxmArpTha(_oxm, decoder)
577 case 4360:
578 return DecodeNxmIpDstMasked(_oxm, decoder)
579 case 8196:
580 return DecodeNxmArpSpa(_oxm, decoder)
581 case 108668:
582 return DecodeNxmTunMetadata44(_oxm, decoder)
583 case 106108:
584 return DecodeNxmTunMetadata39(_oxm, decoder)
585 case 76801:
586 return DecodeNxmIcmpv6Code(_oxm, decoder)
587 case 101880:
588 return DecodeNxmTunMetadata30Masked(_oxm, decoder)
589 case 2147500812:
590 return DecodeOxmIpv6NdTllMasked(_oxm, decoder)
591 case 114168:
592 return DecodeNxmTunMetadata54Masked(_oxm, decoder)
593 case 2147494146:
594 return DecodeOxmIcmpv4CodeMasked(_oxm, decoder)
595 case 70148:
596 return DecodeNxmReg9(_oxm, decoder)
597 case 89212:
598 return DecodeNxmTunMetadata6(_oxm, decoder)
599 case 119560:
600 return DecodeOxmConnTrackingStateMasked(_oxm, decoder)
601 case 83204:
602 return DecodeNxmTcpFlagsMasked(_oxm, decoder)
603 case 106620:
604 return DecodeNxmTunMetadata40(_oxm, decoder)
605 case 6146:
606 return DecodeNxmUdpDst(_oxm, decoder)
607 case 119044:
608 return DecodeNxmTunFlagsMasked(_oxm, decoder)
609 case 102392:
610 return DecodeNxmTunMetadata31Masked(_oxm, decoder)
611 case 115324:
612 return DecodeNxmTunMetadata57(_oxm, decoder)
613 case 82696:
614 return DecodeNxmPktMarkMasked(_oxm, decoder)
615 case 123920:
616 return DecodeNxmXxreg3(_oxm, decoder)
617 case 2147497760:
618 return DecodeOxmIpv6DstMasked(_oxm, decoder)
619 case 2147489284:
620 return DecodeOxmIpv4Src(_oxm, decoder)
621 case 70920:
622 return DecodeNxmReg10Masked(_oxm, decoder)
623 case 107132:
624 return DecodeNxmTunMetadata41(_oxm, decoder)
625 case 2147491588:
626 return DecodeOxmUdpSrcMasked(_oxm, decoder)
627 case 102904:
628 return DecodeNxmTunMetadata32Masked(_oxm, decoder)
629 case 111096:
630 return DecodeNxmTunMetadata48Masked(_oxm, decoder)
631 case 2147492100:
632 return DecodeOxmUdpDstMasked(_oxm, decoder)
633 case 67076:
634 return DecodeNxmReg3(_oxm, decoder)
635 case 2147496976:
636 return DecodeOxmIpv6Src(_oxm, decoder)
637 case 120584:
638 return DecodeOxmConnTrackingMarkMasked(_oxm, decoder)
639 case 91260:
640 return DecodeNxmTunMetadata10(_oxm, decoder)
641 case 2147490818:
642 return DecodeOxmTcpDst(_oxm, decoder)
643 case 112252:
644 return DecodeNxmTunMetadata51(_oxm, decoder)
645 case 87032:
646 return DecodeNxmTunMetadata1Masked(_oxm, decoder)
647 case 2147485964:
648 return DecodeOxmEthSrcMasked(_oxm, decoder)
649 case 83460:
650 return DecodeNxmDpHash(_oxm, decoder)
651 case 126722:
652 return DecodeOxmConnTrackingNwProtoMasked(_oxm, decoder)
653 case 119300:
654 return DecodeOxmConnTrackingState(_oxm, decoder)
655 case 117752:
656 return DecodeNxmTunMetadata61Masked(_oxm, decoder)
657 case 71944:
658 return DecodeNxmReg12Masked(_oxm, decoder)
659 case 2147499808:
660 return DecodeOxmIpv6NdTargetMasked(_oxm, decoder)
661 case 91772:
662 return DecodeNxmTunMetadata11(_oxm, decoder)
663 case 78849:
664 return DecodeNxmIpFrag(_oxm, decoder)
665 case 87544:
666 return DecodeNxmTunMetadata2Masked(_oxm, decoder)
667 case 90104:
668 return DecodeNxmTunMetadata7Masked(_oxm, decoder)
669 case 72456:
670 return DecodeNxmReg13Masked(_oxm, decoder)
671 case 109180:
672 return DecodeNxmTunMetadata45(_oxm, decoder)
673 case 91640:
674 return DecodeNxmTunMetadata10Masked(_oxm, decoder)
675 case 2147498497:
676 return DecodeOxmIcmpv6Type(_oxm, decoder)
677 case 2147492612:
678 return DecodeOxmSctpSrcMasked(_oxm, decoder)
679 case 104440:
680 return DecodeNxmTunMetadata35Masked(_oxm, decoder)
681 case 2147494660:
682 return DecodeOxmArpOpMasked(_oxm, decoder)
683 case 66824:
684 return DecodeNxmReg2Masked(_oxm, decoder)
685 case 109048:
686 return DecodeNxmTunMetadata44Masked(_oxm, decoder)
687 case 2147492866:
688 return DecodeOxmSctpDst(_oxm, decoder)
689 case 89724:
690 return DecodeNxmTunMetadata7(_oxm, decoder)
691 case 72968:
692 return DecodeNxmReg14Masked(_oxm, decoder)
693 case 92796:
694 return DecodeNxmTunMetadata13(_oxm, decoder)
695 case 2147495176:
696 return DecodeOxmArpSpaMasked(_oxm, decoder)
697 case 79873:
698 return DecodeNxmNwEcn(_oxm, decoder)
699 case 104952:
700 return DecodeNxmTunMetadata36Masked(_oxm, decoder)
701 case 115836:
702 return DecodeNxmTunMetadata58(_oxm, decoder)
703 case 93820:
704 return DecodeNxmTunMetadata15(_oxm, decoder)
705 case 2147495942:
706 return DecodeOxmArpSha(_oxm, decoder)
707 case 2147495428:
708 return DecodeOxmArpTpa(_oxm, decoder)
709 case 93308:
710 return DecodeNxmTunMetadata14(_oxm, decoder)
711 case 80385:
712 return DecodeNxmNwTtl(_oxm, decoder)
713 case 105464:
714 return DecodeNxmTunMetadata37Masked(_oxm, decoder)
715 case 111608:
716 return DecodeNxmTunMetadata49Masked(_oxm, decoder)
717 case 2147488002:
718 return DecodeOxmIpDscpMasked(_oxm, decoder)
719 case 86520:
720 return DecodeNxmTunMetadata0Masked(_oxm, decoder)
721 case 67588:
722 return DecodeNxmReg4(_oxm, decoder)
723 case 6404:
724 return DecodeNxmUdpDstMasked(_oxm, decoder)
725 case 2147497488:
726 return DecodeOxmIpv6Dst(_oxm, decoder)
727 case 126980:
728 return DecodeOxmConnTrackingNwSrc(_oxm, decoder)
729 default:
730 return nil, nil
731 }
732}
733
734func NewOxm(_type_len uint32) *Oxm {
735 obj := &Oxm{}
736 obj.TypeLen = _type_len
737 return obj
738}
739
740type NxmArpOp struct {
741 *Oxm
742 Value uint16
743}
744
745type INxmArpOp interface {
746 goloxi.IOxm
747 GetValue() uint16
748}
749
750func (self *NxmArpOp) GetValue() uint16 {
751 return self.Value
752}
753
754func (self *NxmArpOp) SetValue(v uint16) {
755 self.Value = v
756}
757
758func (self *NxmArpOp) Serialize(encoder *goloxi.Encoder) error {
759 if err := self.Oxm.Serialize(encoder); err != nil {
760 return err
761 }
762
763 encoder.PutUint16(uint16(self.Value))
764
765 return nil
766}
767
768func DecodeNxmArpOp(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpOp, error) {
769 _nxmarpop := &NxmArpOp{Oxm: parent}
770 if decoder.Length() < 2 {
771 return nil, fmt.Errorf("NxmArpOp packet too short: %d < 2", decoder.Length())
772 }
773 _nxmarpop.Value = uint16(decoder.ReadUint16())
774 return _nxmarpop, nil
775}
776
777func NewNxmArpOp() *NxmArpOp {
778 obj := &NxmArpOp{
779 Oxm: NewOxm(7682),
780 }
781 return obj
782}
783func (self *NxmArpOp) GetOXMName() string {
784 return "arp_op"
785}
786
787func (self *NxmArpOp) GetOXMValue() interface{} {
788 return self.Value
789}
790
791func (self *NxmArpOp) MarshalJSON() ([]byte, error) {
792 value, err := jsonValue(self.GetOXMValue())
793 if err != nil {
794 return nil, err
795 }
796 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
797}
798
799type NxmArpSha struct {
800 *Oxm
801 Value net.HardwareAddr
802}
803
804type INxmArpSha interface {
805 goloxi.IOxm
806 GetValue() net.HardwareAddr
807}
808
809func (self *NxmArpSha) GetValue() net.HardwareAddr {
810 return self.Value
811}
812
813func (self *NxmArpSha) SetValue(v net.HardwareAddr) {
814 self.Value = v
815}
816
817func (self *NxmArpSha) Serialize(encoder *goloxi.Encoder) error {
818 if err := self.Oxm.Serialize(encoder); err != nil {
819 return err
820 }
821
822 encoder.Write(self.Value)
823
824 return nil
825}
826
827func DecodeNxmArpSha(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpSha, error) {
828 _nxmarpsha := &NxmArpSha{Oxm: parent}
829 if decoder.Length() < 6 {
830 return nil, fmt.Errorf("NxmArpSha packet too short: %d < 6", decoder.Length())
831 }
832 _nxmarpsha.Value = net.HardwareAddr(decoder.Read(6))
833 return _nxmarpsha, nil
834}
835
836func NewNxmArpSha() *NxmArpSha {
837 obj := &NxmArpSha{
838 Oxm: NewOxm(74246),
839 }
840 return obj
841}
842func (self *NxmArpSha) GetOXMName() string {
843 return "arp_sha"
844}
845
846func (self *NxmArpSha) GetOXMValue() interface{} {
847 return self.Value
848}
849
850func (self *NxmArpSha) MarshalJSON() ([]byte, error) {
851 value, err := jsonValue(self.GetOXMValue())
852 if err != nil {
853 return nil, err
854 }
855 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
856}
857
858type NxmArpShaMasked struct {
859 *Oxm
860 Value net.HardwareAddr
861 ValueMask net.HardwareAddr
862}
863
864type INxmArpShaMasked interface {
865 goloxi.IOxm
866 GetValue() net.HardwareAddr
867 GetValueMask() net.HardwareAddr
868}
869
870func (self *NxmArpShaMasked) GetValue() net.HardwareAddr {
871 return self.Value
872}
873
874func (self *NxmArpShaMasked) SetValue(v net.HardwareAddr) {
875 self.Value = v
876}
877
878func (self *NxmArpShaMasked) GetValueMask() net.HardwareAddr {
879 return self.ValueMask
880}
881
882func (self *NxmArpShaMasked) SetValueMask(v net.HardwareAddr) {
883 self.ValueMask = v
884}
885
886func (self *NxmArpShaMasked) Serialize(encoder *goloxi.Encoder) error {
887 if err := self.Oxm.Serialize(encoder); err != nil {
888 return err
889 }
890
891 encoder.Write(self.Value)
892 encoder.Write(self.ValueMask)
893
894 return nil
895}
896
897func DecodeNxmArpShaMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpShaMasked, error) {
898 _nxmarpshamasked := &NxmArpShaMasked{Oxm: parent}
899 if decoder.Length() < 12 {
900 return nil, fmt.Errorf("NxmArpShaMasked packet too short: %d < 12", decoder.Length())
901 }
902 _nxmarpshamasked.Value = net.HardwareAddr(decoder.Read(6))
903 _nxmarpshamasked.ValueMask = net.HardwareAddr(decoder.Read(6))
904 return _nxmarpshamasked, nil
905}
906
907func NewNxmArpShaMasked() *NxmArpShaMasked {
908 obj := &NxmArpShaMasked{
909 Oxm: NewOxm(74507),
910 }
911 return obj
912}
913func (self *NxmArpShaMasked) GetOXMName() string {
914 return "arp_sha_masked"
915}
916
917func (self *NxmArpShaMasked) GetOXMValue() interface{} {
918 return self.Value
919}
920
921func (self *NxmArpShaMasked) GetOXMValueMask() interface{} {
922 return self.ValueMask
923}
924
925func (self *NxmArpShaMasked) MarshalJSON() ([]byte, error) {
926 value, err := jsonValue(self.GetOXMValue())
927 if err != nil {
928 return nil, err
929 }
930 valueMask, err := jsonValue(self.GetOXMValueMask())
931 if err != nil {
932 return nil, err
933 }
934 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
935}
936
937type NxmArpSpa struct {
938 *Oxm
939 Value net.IP
940}
941
942type INxmArpSpa interface {
943 goloxi.IOxm
944 GetValue() net.IP
945}
946
947func (self *NxmArpSpa) GetValue() net.IP {
948 return self.Value
949}
950
951func (self *NxmArpSpa) SetValue(v net.IP) {
952 self.Value = v
953}
954
955func (self *NxmArpSpa) Serialize(encoder *goloxi.Encoder) error {
956 if err := self.Oxm.Serialize(encoder); err != nil {
957 return err
958 }
959
960 encoder.Write(self.Value.To4())
961
962 return nil
963}
964
965func DecodeNxmArpSpa(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpSpa, error) {
966 _nxmarpspa := &NxmArpSpa{Oxm: parent}
967 if decoder.Length() < 4 {
968 return nil, fmt.Errorf("NxmArpSpa packet too short: %d < 4", decoder.Length())
969 }
970 _nxmarpspa.Value = net.IP(decoder.Read(4))
971 return _nxmarpspa, nil
972}
973
974func NewNxmArpSpa() *NxmArpSpa {
975 obj := &NxmArpSpa{
976 Oxm: NewOxm(8196),
977 }
978 return obj
979}
980func (self *NxmArpSpa) GetOXMName() string {
981 return "arp_spa"
982}
983
984func (self *NxmArpSpa) GetOXMValue() interface{} {
985 return self.Value
986}
987
988func (self *NxmArpSpa) MarshalJSON() ([]byte, error) {
989 value, err := jsonValue(self.GetOXMValue())
990 if err != nil {
991 return nil, err
992 }
993 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
994}
995
996type NxmArpSpaMasked struct {
997 *Oxm
998 Value net.IP
999 ValueMask net.IP
1000}
1001
1002type INxmArpSpaMasked interface {
1003 goloxi.IOxm
1004 GetValue() net.IP
1005 GetValueMask() net.IP
1006}
1007
1008func (self *NxmArpSpaMasked) GetValue() net.IP {
1009 return self.Value
1010}
1011
1012func (self *NxmArpSpaMasked) SetValue(v net.IP) {
1013 self.Value = v
1014}
1015
1016func (self *NxmArpSpaMasked) GetValueMask() net.IP {
1017 return self.ValueMask
1018}
1019
1020func (self *NxmArpSpaMasked) SetValueMask(v net.IP) {
1021 self.ValueMask = v
1022}
1023
1024func (self *NxmArpSpaMasked) Serialize(encoder *goloxi.Encoder) error {
1025 if err := self.Oxm.Serialize(encoder); err != nil {
1026 return err
1027 }
1028
1029 encoder.Write(self.Value.To4())
1030 encoder.Write(self.ValueMask.To4())
1031
1032 return nil
1033}
1034
1035func DecodeNxmArpSpaMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpSpaMasked, error) {
1036 _nxmarpspamasked := &NxmArpSpaMasked{Oxm: parent}
1037 if decoder.Length() < 8 {
1038 return nil, fmt.Errorf("NxmArpSpaMasked packet too short: %d < 8", decoder.Length())
1039 }
1040 _nxmarpspamasked.Value = net.IP(decoder.Read(4))
1041 _nxmarpspamasked.ValueMask = net.IP(decoder.Read(4))
1042 return _nxmarpspamasked, nil
1043}
1044
1045func NewNxmArpSpaMasked() *NxmArpSpaMasked {
1046 obj := &NxmArpSpaMasked{
1047 Oxm: NewOxm(8452),
1048 }
1049 return obj
1050}
1051func (self *NxmArpSpaMasked) GetOXMName() string {
1052 return "arp_spa_masked"
1053}
1054
1055func (self *NxmArpSpaMasked) GetOXMValue() interface{} {
1056 return self.Value
1057}
1058
1059func (self *NxmArpSpaMasked) GetOXMValueMask() interface{} {
1060 return self.ValueMask
1061}
1062
1063func (self *NxmArpSpaMasked) MarshalJSON() ([]byte, error) {
1064 value, err := jsonValue(self.GetOXMValue())
1065 if err != nil {
1066 return nil, err
1067 }
1068 valueMask, err := jsonValue(self.GetOXMValueMask())
1069 if err != nil {
1070 return nil, err
1071 }
1072 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
1073}
1074
1075type NxmArpTha struct {
1076 *Oxm
1077 Value net.HardwareAddr
1078}
1079
1080type INxmArpTha interface {
1081 goloxi.IOxm
1082 GetValue() net.HardwareAddr
1083}
1084
1085func (self *NxmArpTha) GetValue() net.HardwareAddr {
1086 return self.Value
1087}
1088
1089func (self *NxmArpTha) SetValue(v net.HardwareAddr) {
1090 self.Value = v
1091}
1092
1093func (self *NxmArpTha) Serialize(encoder *goloxi.Encoder) error {
1094 if err := self.Oxm.Serialize(encoder); err != nil {
1095 return err
1096 }
1097
1098 encoder.Write(self.Value)
1099
1100 return nil
1101}
1102
1103func DecodeNxmArpTha(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpTha, error) {
1104 _nxmarptha := &NxmArpTha{Oxm: parent}
1105 if decoder.Length() < 6 {
1106 return nil, fmt.Errorf("NxmArpTha packet too short: %d < 6", decoder.Length())
1107 }
1108 _nxmarptha.Value = net.HardwareAddr(decoder.Read(6))
1109 return _nxmarptha, nil
1110}
1111
1112func NewNxmArpTha() *NxmArpTha {
1113 obj := &NxmArpTha{
1114 Oxm: NewOxm(74758),
1115 }
1116 return obj
1117}
1118func (self *NxmArpTha) GetOXMName() string {
1119 return "arp_tha"
1120}
1121
1122func (self *NxmArpTha) GetOXMValue() interface{} {
1123 return self.Value
1124}
1125
1126func (self *NxmArpTha) MarshalJSON() ([]byte, error) {
1127 value, err := jsonValue(self.GetOXMValue())
1128 if err != nil {
1129 return nil, err
1130 }
1131 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
1132}
1133
1134type NxmArpThaMasked struct {
1135 *Oxm
1136 Value net.HardwareAddr
1137 ValueMask net.HardwareAddr
1138}
1139
1140type INxmArpThaMasked interface {
1141 goloxi.IOxm
1142 GetValue() net.HardwareAddr
1143 GetValueMask() net.HardwareAddr
1144}
1145
1146func (self *NxmArpThaMasked) GetValue() net.HardwareAddr {
1147 return self.Value
1148}
1149
1150func (self *NxmArpThaMasked) SetValue(v net.HardwareAddr) {
1151 self.Value = v
1152}
1153
1154func (self *NxmArpThaMasked) GetValueMask() net.HardwareAddr {
1155 return self.ValueMask
1156}
1157
1158func (self *NxmArpThaMasked) SetValueMask(v net.HardwareAddr) {
1159 self.ValueMask = v
1160}
1161
1162func (self *NxmArpThaMasked) Serialize(encoder *goloxi.Encoder) error {
1163 if err := self.Oxm.Serialize(encoder); err != nil {
1164 return err
1165 }
1166
1167 encoder.Write(self.Value)
1168 encoder.Write(self.ValueMask)
1169
1170 return nil
1171}
1172
1173func DecodeNxmArpThaMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpThaMasked, error) {
1174 _nxmarpthamasked := &NxmArpThaMasked{Oxm: parent}
1175 if decoder.Length() < 12 {
1176 return nil, fmt.Errorf("NxmArpThaMasked packet too short: %d < 12", decoder.Length())
1177 }
1178 _nxmarpthamasked.Value = net.HardwareAddr(decoder.Read(6))
1179 _nxmarpthamasked.ValueMask = net.HardwareAddr(decoder.Read(6))
1180 return _nxmarpthamasked, nil
1181}
1182
1183func NewNxmArpThaMasked() *NxmArpThaMasked {
1184 obj := &NxmArpThaMasked{
1185 Oxm: NewOxm(75019),
1186 }
1187 return obj
1188}
1189func (self *NxmArpThaMasked) GetOXMName() string {
1190 return "arp_tha_masked"
1191}
1192
1193func (self *NxmArpThaMasked) GetOXMValue() interface{} {
1194 return self.Value
1195}
1196
1197func (self *NxmArpThaMasked) GetOXMValueMask() interface{} {
1198 return self.ValueMask
1199}
1200
1201func (self *NxmArpThaMasked) MarshalJSON() ([]byte, error) {
1202 value, err := jsonValue(self.GetOXMValue())
1203 if err != nil {
1204 return nil, err
1205 }
1206 valueMask, err := jsonValue(self.GetOXMValueMask())
1207 if err != nil {
1208 return nil, err
1209 }
1210 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
1211}
1212
1213type NxmArpTpa struct {
1214 *Oxm
1215 Value net.IP
1216}
1217
1218type INxmArpTpa interface {
1219 goloxi.IOxm
1220 GetValue() net.IP
1221}
1222
1223func (self *NxmArpTpa) GetValue() net.IP {
1224 return self.Value
1225}
1226
1227func (self *NxmArpTpa) SetValue(v net.IP) {
1228 self.Value = v
1229}
1230
1231func (self *NxmArpTpa) Serialize(encoder *goloxi.Encoder) error {
1232 if err := self.Oxm.Serialize(encoder); err != nil {
1233 return err
1234 }
1235
1236 encoder.Write(self.Value.To4())
1237
1238 return nil
1239}
1240
1241func DecodeNxmArpTpa(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpTpa, error) {
1242 _nxmarptpa := &NxmArpTpa{Oxm: parent}
1243 if decoder.Length() < 4 {
1244 return nil, fmt.Errorf("NxmArpTpa packet too short: %d < 4", decoder.Length())
1245 }
1246 _nxmarptpa.Value = net.IP(decoder.Read(4))
1247 return _nxmarptpa, nil
1248}
1249
1250func NewNxmArpTpa() *NxmArpTpa {
1251 obj := &NxmArpTpa{
1252 Oxm: NewOxm(8708),
1253 }
1254 return obj
1255}
1256func (self *NxmArpTpa) GetOXMName() string {
1257 return "arp_tpa"
1258}
1259
1260func (self *NxmArpTpa) GetOXMValue() interface{} {
1261 return self.Value
1262}
1263
1264func (self *NxmArpTpa) MarshalJSON() ([]byte, error) {
1265 value, err := jsonValue(self.GetOXMValue())
1266 if err != nil {
1267 return nil, err
1268 }
1269 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
1270}
1271
1272type NxmArpTpaMasked struct {
1273 *Oxm
1274 Value net.IP
1275 ValueMask net.IP
1276}
1277
1278type INxmArpTpaMasked interface {
1279 goloxi.IOxm
1280 GetValue() net.IP
1281 GetValueMask() net.IP
1282}
1283
1284func (self *NxmArpTpaMasked) GetValue() net.IP {
1285 return self.Value
1286}
1287
1288func (self *NxmArpTpaMasked) SetValue(v net.IP) {
1289 self.Value = v
1290}
1291
1292func (self *NxmArpTpaMasked) GetValueMask() net.IP {
1293 return self.ValueMask
1294}
1295
1296func (self *NxmArpTpaMasked) SetValueMask(v net.IP) {
1297 self.ValueMask = v
1298}
1299
1300func (self *NxmArpTpaMasked) Serialize(encoder *goloxi.Encoder) error {
1301 if err := self.Oxm.Serialize(encoder); err != nil {
1302 return err
1303 }
1304
1305 encoder.Write(self.Value.To4())
1306 encoder.Write(self.ValueMask.To4())
1307
1308 return nil
1309}
1310
1311func DecodeNxmArpTpaMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmArpTpaMasked, error) {
1312 _nxmarptpamasked := &NxmArpTpaMasked{Oxm: parent}
1313 if decoder.Length() < 8 {
1314 return nil, fmt.Errorf("NxmArpTpaMasked packet too short: %d < 8", decoder.Length())
1315 }
1316 _nxmarptpamasked.Value = net.IP(decoder.Read(4))
1317 _nxmarptpamasked.ValueMask = net.IP(decoder.Read(4))
1318 return _nxmarptpamasked, nil
1319}
1320
1321func NewNxmArpTpaMasked() *NxmArpTpaMasked {
1322 obj := &NxmArpTpaMasked{
1323 Oxm: NewOxm(8968),
1324 }
1325 return obj
1326}
1327func (self *NxmArpTpaMasked) GetOXMName() string {
1328 return "arp_tpa_masked"
1329}
1330
1331func (self *NxmArpTpaMasked) GetOXMValue() interface{} {
1332 return self.Value
1333}
1334
1335func (self *NxmArpTpaMasked) GetOXMValueMask() interface{} {
1336 return self.ValueMask
1337}
1338
1339func (self *NxmArpTpaMasked) MarshalJSON() ([]byte, error) {
1340 value, err := jsonValue(self.GetOXMValue())
1341 if err != nil {
1342 return nil, err
1343 }
1344 valueMask, err := jsonValue(self.GetOXMValueMask())
1345 if err != nil {
1346 return nil, err
1347 }
1348 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
1349}
1350
1351type NxmConjId struct {
1352 *Oxm
1353 Value uint32
1354}
1355
1356type INxmConjId interface {
1357 goloxi.IOxm
1358 GetValue() uint32
1359}
1360
1361func (self *NxmConjId) GetValue() uint32 {
1362 return self.Value
1363}
1364
1365func (self *NxmConjId) SetValue(v uint32) {
1366 self.Value = v
1367}
1368
1369func (self *NxmConjId) Serialize(encoder *goloxi.Encoder) error {
1370 if err := self.Oxm.Serialize(encoder); err != nil {
1371 return err
1372 }
1373
1374 encoder.PutUint32(uint32(self.Value))
1375
1376 return nil
1377}
1378
1379func DecodeNxmConjId(parent *Oxm, decoder *goloxi.Decoder) (*NxmConjId, error) {
1380 _nxmconjid := &NxmConjId{Oxm: parent}
1381 if decoder.Length() < 4 {
1382 return nil, fmt.Errorf("NxmConjId packet too short: %d < 4", decoder.Length())
1383 }
1384 _nxmconjid.Value = uint32(decoder.ReadUint32())
1385 return _nxmconjid, nil
1386}
1387
1388func NewNxmConjId() *NxmConjId {
1389 obj := &NxmConjId{
1390 Oxm: NewOxm(84484),
1391 }
1392 return obj
1393}
1394func (self *NxmConjId) GetOXMName() string {
1395 return "conj_id"
1396}
1397
1398func (self *NxmConjId) GetOXMValue() interface{} {
1399 return self.Value
1400}
1401
1402func (self *NxmConjId) MarshalJSON() ([]byte, error) {
1403 value, err := jsonValue(self.GetOXMValue())
1404 if err != nil {
1405 return nil, err
1406 }
1407 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
1408}
1409
1410type NxmCtIpv6Dst struct {
1411 *Oxm
1412 Value net.IP
1413}
1414
1415type INxmCtIpv6Dst interface {
1416 goloxi.IOxm
1417 GetValue() net.IP
1418}
1419
1420func (self *NxmCtIpv6Dst) GetValue() net.IP {
1421 return self.Value
1422}
1423
1424func (self *NxmCtIpv6Dst) SetValue(v net.IP) {
1425 self.Value = v
1426}
1427
1428func (self *NxmCtIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
1429 if err := self.Oxm.Serialize(encoder); err != nil {
1430 return err
1431 }
1432
1433 encoder.Write(self.Value.To16())
1434
1435 return nil
1436}
1437
1438func DecodeNxmCtIpv6Dst(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtIpv6Dst, error) {
1439 _nxmctipv6dst := &NxmCtIpv6Dst{Oxm: parent}
1440 if decoder.Length() < 16 {
1441 return nil, fmt.Errorf("NxmCtIpv6Dst packet too short: %d < 16", decoder.Length())
1442 }
1443 _nxmctipv6dst.Value = net.IP(decoder.Read(16))
1444 return _nxmctipv6dst, nil
1445}
1446
1447func NewNxmCtIpv6Dst() *NxmCtIpv6Dst {
1448 obj := &NxmCtIpv6Dst{
1449 Oxm: NewOxm(128528),
1450 }
1451 return obj
1452}
1453func (self *NxmCtIpv6Dst) GetOXMName() string {
1454 return "ct_ipv6_dst"
1455}
1456
1457func (self *NxmCtIpv6Dst) GetOXMValue() interface{} {
1458 return self.Value
1459}
1460
1461func (self *NxmCtIpv6Dst) MarshalJSON() ([]byte, error) {
1462 value, err := jsonValue(self.GetOXMValue())
1463 if err != nil {
1464 return nil, err
1465 }
1466 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
1467}
1468
1469type NxmCtIpv6DstMasked struct {
1470 *Oxm
1471 Value net.IP
1472 ValueMask net.IP
1473}
1474
1475type INxmCtIpv6DstMasked interface {
1476 goloxi.IOxm
1477 GetValue() net.IP
1478 GetValueMask() net.IP
1479}
1480
1481func (self *NxmCtIpv6DstMasked) GetValue() net.IP {
1482 return self.Value
1483}
1484
1485func (self *NxmCtIpv6DstMasked) SetValue(v net.IP) {
1486 self.Value = v
1487}
1488
1489func (self *NxmCtIpv6DstMasked) GetValueMask() net.IP {
1490 return self.ValueMask
1491}
1492
1493func (self *NxmCtIpv6DstMasked) SetValueMask(v net.IP) {
1494 self.ValueMask = v
1495}
1496
1497func (self *NxmCtIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
1498 if err := self.Oxm.Serialize(encoder); err != nil {
1499 return err
1500 }
1501
1502 encoder.Write(self.Value.To16())
1503 encoder.Write(self.ValueMask.To16())
1504
1505 return nil
1506}
1507
1508func DecodeNxmCtIpv6DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtIpv6DstMasked, error) {
1509 _nxmctipv6dstmasked := &NxmCtIpv6DstMasked{Oxm: parent}
1510 if decoder.Length() < 32 {
1511 return nil, fmt.Errorf("NxmCtIpv6DstMasked packet too short: %d < 32", decoder.Length())
1512 }
1513 _nxmctipv6dstmasked.Value = net.IP(decoder.Read(16))
1514 _nxmctipv6dstmasked.ValueMask = net.IP(decoder.Read(16))
1515 return _nxmctipv6dstmasked, nil
1516}
1517
1518func NewNxmCtIpv6DstMasked() *NxmCtIpv6DstMasked {
1519 obj := &NxmCtIpv6DstMasked{
1520 Oxm: NewOxm(128800),
1521 }
1522 return obj
1523}
1524func (self *NxmCtIpv6DstMasked) GetOXMName() string {
1525 return "ct_ipv6_dst_masked"
1526}
1527
1528func (self *NxmCtIpv6DstMasked) GetOXMValue() interface{} {
1529 return self.Value
1530}
1531
1532func (self *NxmCtIpv6DstMasked) GetOXMValueMask() interface{} {
1533 return self.ValueMask
1534}
1535
1536func (self *NxmCtIpv6DstMasked) MarshalJSON() ([]byte, error) {
1537 value, err := jsonValue(self.GetOXMValue())
1538 if err != nil {
1539 return nil, err
1540 }
1541 valueMask, err := jsonValue(self.GetOXMValueMask())
1542 if err != nil {
1543 return nil, err
1544 }
1545 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
1546}
1547
1548type NxmCtIpv6Src struct {
1549 *Oxm
1550 Value net.IP
1551}
1552
1553type INxmCtIpv6Src interface {
1554 goloxi.IOxm
1555 GetValue() net.IP
1556}
1557
1558func (self *NxmCtIpv6Src) GetValue() net.IP {
1559 return self.Value
1560}
1561
1562func (self *NxmCtIpv6Src) SetValue(v net.IP) {
1563 self.Value = v
1564}
1565
1566func (self *NxmCtIpv6Src) Serialize(encoder *goloxi.Encoder) error {
1567 if err := self.Oxm.Serialize(encoder); err != nil {
1568 return err
1569 }
1570
1571 encoder.Write(self.Value.To16())
1572
1573 return nil
1574}
1575
1576func DecodeNxmCtIpv6Src(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtIpv6Src, error) {
1577 _nxmctipv6src := &NxmCtIpv6Src{Oxm: parent}
1578 if decoder.Length() < 16 {
1579 return nil, fmt.Errorf("NxmCtIpv6Src packet too short: %d < 16", decoder.Length())
1580 }
1581 _nxmctipv6src.Value = net.IP(decoder.Read(16))
1582 return _nxmctipv6src, nil
1583}
1584
1585func NewNxmCtIpv6Src() *NxmCtIpv6Src {
1586 obj := &NxmCtIpv6Src{
1587 Oxm: NewOxm(128016),
1588 }
1589 return obj
1590}
1591func (self *NxmCtIpv6Src) GetOXMName() string {
1592 return "ct_ipv6_src"
1593}
1594
1595func (self *NxmCtIpv6Src) GetOXMValue() interface{} {
1596 return self.Value
1597}
1598
1599func (self *NxmCtIpv6Src) MarshalJSON() ([]byte, error) {
1600 value, err := jsonValue(self.GetOXMValue())
1601 if err != nil {
1602 return nil, err
1603 }
1604 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
1605}
1606
1607type NxmCtIpv6SrcMasked struct {
1608 *Oxm
1609 Value net.IP
1610 ValueMask net.IP
1611}
1612
1613type INxmCtIpv6SrcMasked interface {
1614 goloxi.IOxm
1615 GetValue() net.IP
1616 GetValueMask() net.IP
1617}
1618
1619func (self *NxmCtIpv6SrcMasked) GetValue() net.IP {
1620 return self.Value
1621}
1622
1623func (self *NxmCtIpv6SrcMasked) SetValue(v net.IP) {
1624 self.Value = v
1625}
1626
1627func (self *NxmCtIpv6SrcMasked) GetValueMask() net.IP {
1628 return self.ValueMask
1629}
1630
1631func (self *NxmCtIpv6SrcMasked) SetValueMask(v net.IP) {
1632 self.ValueMask = v
1633}
1634
1635func (self *NxmCtIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
1636 if err := self.Oxm.Serialize(encoder); err != nil {
1637 return err
1638 }
1639
1640 encoder.Write(self.Value.To16())
1641 encoder.Write(self.ValueMask.To16())
1642
1643 return nil
1644}
1645
1646func DecodeNxmCtIpv6SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtIpv6SrcMasked, error) {
1647 _nxmctipv6srcmasked := &NxmCtIpv6SrcMasked{Oxm: parent}
1648 if decoder.Length() < 32 {
1649 return nil, fmt.Errorf("NxmCtIpv6SrcMasked packet too short: %d < 32", decoder.Length())
1650 }
1651 _nxmctipv6srcmasked.Value = net.IP(decoder.Read(16))
1652 _nxmctipv6srcmasked.ValueMask = net.IP(decoder.Read(16))
1653 return _nxmctipv6srcmasked, nil
1654}
1655
1656func NewNxmCtIpv6SrcMasked() *NxmCtIpv6SrcMasked {
1657 obj := &NxmCtIpv6SrcMasked{
1658 Oxm: NewOxm(128288),
1659 }
1660 return obj
1661}
1662func (self *NxmCtIpv6SrcMasked) GetOXMName() string {
1663 return "ct_ipv6_src_masked"
1664}
1665
1666func (self *NxmCtIpv6SrcMasked) GetOXMValue() interface{} {
1667 return self.Value
1668}
1669
1670func (self *NxmCtIpv6SrcMasked) GetOXMValueMask() interface{} {
1671 return self.ValueMask
1672}
1673
1674func (self *NxmCtIpv6SrcMasked) MarshalJSON() ([]byte, error) {
1675 value, err := jsonValue(self.GetOXMValue())
1676 if err != nil {
1677 return nil, err
1678 }
1679 valueMask, err := jsonValue(self.GetOXMValueMask())
1680 if err != nil {
1681 return nil, err
1682 }
1683 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
1684}
1685
1686type NxmCtLabel struct {
1687 *Oxm
1688 Value uint128
1689}
1690
1691type INxmCtLabel interface {
1692 goloxi.IOxm
1693 GetValue() uint128
1694}
1695
1696func (self *NxmCtLabel) GetValue() uint128 {
1697 return self.Value
1698}
1699
1700func (self *NxmCtLabel) SetValue(v uint128) {
1701 self.Value = v
1702}
1703
1704func (self *NxmCtLabel) Serialize(encoder *goloxi.Encoder) error {
1705 if err := self.Oxm.Serialize(encoder); err != nil {
1706 return err
1707 }
1708
1709 encoder.PutUint128(uint128(self.Value))
1710
1711 return nil
1712}
1713
1714func DecodeNxmCtLabel(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtLabel, error) {
1715 _nxmctlabel := &NxmCtLabel{Oxm: parent}
1716 if decoder.Length() < 16 {
1717 return nil, fmt.Errorf("NxmCtLabel packet too short: %d < 16", decoder.Length())
1718 }
1719 _nxmctlabel.Value = uint128(decoder.ReadUint128())
1720 return _nxmctlabel, nil
1721}
1722
1723func NewNxmCtLabel() *NxmCtLabel {
1724 obj := &NxmCtLabel{
1725 Oxm: NewOxm(120848),
1726 }
1727 return obj
1728}
1729func (self *NxmCtLabel) GetOXMName() string {
1730 return "ct_label"
1731}
1732
1733func (self *NxmCtLabel) GetOXMValue() interface{} {
1734 return self.Value
1735}
1736
1737func (self *NxmCtLabel) MarshalJSON() ([]byte, error) {
1738 value, err := jsonValue(self.GetOXMValue())
1739 if err != nil {
1740 return nil, err
1741 }
1742 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
1743}
1744
1745type NxmCtLabelMasked struct {
1746 *Oxm
1747 Value uint128
1748 ValueMask uint128
1749}
1750
1751type INxmCtLabelMasked interface {
1752 goloxi.IOxm
1753 GetValue() uint128
1754 GetValueMask() uint128
1755}
1756
1757func (self *NxmCtLabelMasked) GetValue() uint128 {
1758 return self.Value
1759}
1760
1761func (self *NxmCtLabelMasked) SetValue(v uint128) {
1762 self.Value = v
1763}
1764
1765func (self *NxmCtLabelMasked) GetValueMask() uint128 {
1766 return self.ValueMask
1767}
1768
1769func (self *NxmCtLabelMasked) SetValueMask(v uint128) {
1770 self.ValueMask = v
1771}
1772
1773func (self *NxmCtLabelMasked) Serialize(encoder *goloxi.Encoder) error {
1774 if err := self.Oxm.Serialize(encoder); err != nil {
1775 return err
1776 }
1777
1778 encoder.PutUint128(uint128(self.Value))
1779 encoder.PutUint128(uint128(self.ValueMask))
1780
1781 return nil
1782}
1783
1784func DecodeNxmCtLabelMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtLabelMasked, error) {
1785 _nxmctlabelmasked := &NxmCtLabelMasked{Oxm: parent}
1786 if decoder.Length() < 32 {
1787 return nil, fmt.Errorf("NxmCtLabelMasked packet too short: %d < 32", decoder.Length())
1788 }
1789 _nxmctlabelmasked.Value = uint128(decoder.ReadUint128())
1790 _nxmctlabelmasked.ValueMask = uint128(decoder.ReadUint128())
1791 return _nxmctlabelmasked, nil
1792}
1793
1794func NewNxmCtLabelMasked() *NxmCtLabelMasked {
1795 obj := &NxmCtLabelMasked{
1796 Oxm: NewOxm(121120),
1797 }
1798 return obj
1799}
1800func (self *NxmCtLabelMasked) GetOXMName() string {
1801 return "ct_label_masked"
1802}
1803
1804func (self *NxmCtLabelMasked) GetOXMValue() interface{} {
1805 return self.Value
1806}
1807
1808func (self *NxmCtLabelMasked) GetOXMValueMask() interface{} {
1809 return self.ValueMask
1810}
1811
1812func (self *NxmCtLabelMasked) MarshalJSON() ([]byte, error) {
1813 value, err := jsonValue(self.GetOXMValue())
1814 if err != nil {
1815 return nil, err
1816 }
1817 valueMask, err := jsonValue(self.GetOXMValueMask())
1818 if err != nil {
1819 return nil, err
1820 }
1821 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
1822}
1823
1824type NxmCtMark struct {
1825 *Oxm
1826 Value uint32
1827}
1828
1829type INxmCtMark interface {
1830 goloxi.IOxm
1831 GetValue() uint32
1832}
1833
1834func (self *NxmCtMark) GetValue() uint32 {
1835 return self.Value
1836}
1837
1838func (self *NxmCtMark) SetValue(v uint32) {
1839 self.Value = v
1840}
1841
1842func (self *NxmCtMark) Serialize(encoder *goloxi.Encoder) error {
1843 if err := self.Oxm.Serialize(encoder); err != nil {
1844 return err
1845 }
1846
1847 encoder.PutUint32(uint32(self.Value))
1848
1849 return nil
1850}
1851
1852func DecodeNxmCtMark(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtMark, error) {
1853 _nxmctmark := &NxmCtMark{Oxm: parent}
1854 if decoder.Length() < 4 {
1855 return nil, fmt.Errorf("NxmCtMark packet too short: %d < 4", decoder.Length())
1856 }
1857 _nxmctmark.Value = uint32(decoder.ReadUint32())
1858 return _nxmctmark, nil
1859}
1860
1861func NewNxmCtMark() *NxmCtMark {
1862 obj := &NxmCtMark{
1863 Oxm: NewOxm(120324),
1864 }
1865 return obj
1866}
1867func (self *NxmCtMark) GetOXMName() string {
1868 return "ct_mark"
1869}
1870
1871func (self *NxmCtMark) GetOXMValue() interface{} {
1872 return self.Value
1873}
1874
1875func (self *NxmCtMark) MarshalJSON() ([]byte, error) {
1876 value, err := jsonValue(self.GetOXMValue())
1877 if err != nil {
1878 return nil, err
1879 }
1880 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
1881}
1882
1883type NxmCtMarkMasked struct {
1884 *Oxm
1885 Value uint32
1886 ValueMask uint32
1887}
1888
1889type INxmCtMarkMasked interface {
1890 goloxi.IOxm
1891 GetValue() uint32
1892 GetValueMask() uint32
1893}
1894
1895func (self *NxmCtMarkMasked) GetValue() uint32 {
1896 return self.Value
1897}
1898
1899func (self *NxmCtMarkMasked) SetValue(v uint32) {
1900 self.Value = v
1901}
1902
1903func (self *NxmCtMarkMasked) GetValueMask() uint32 {
1904 return self.ValueMask
1905}
1906
1907func (self *NxmCtMarkMasked) SetValueMask(v uint32) {
1908 self.ValueMask = v
1909}
1910
1911func (self *NxmCtMarkMasked) Serialize(encoder *goloxi.Encoder) error {
1912 if err := self.Oxm.Serialize(encoder); err != nil {
1913 return err
1914 }
1915
1916 encoder.PutUint32(uint32(self.Value))
1917 encoder.PutUint32(uint32(self.ValueMask))
1918
1919 return nil
1920}
1921
1922func DecodeNxmCtMarkMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtMarkMasked, error) {
1923 _nxmctmarkmasked := &NxmCtMarkMasked{Oxm: parent}
1924 if decoder.Length() < 8 {
1925 return nil, fmt.Errorf("NxmCtMarkMasked packet too short: %d < 8", decoder.Length())
1926 }
1927 _nxmctmarkmasked.Value = uint32(decoder.ReadUint32())
1928 _nxmctmarkmasked.ValueMask = uint32(decoder.ReadUint32())
1929 return _nxmctmarkmasked, nil
1930}
1931
1932func NewNxmCtMarkMasked() *NxmCtMarkMasked {
1933 obj := &NxmCtMarkMasked{
1934 Oxm: NewOxm(120584),
1935 }
1936 return obj
1937}
1938func (self *NxmCtMarkMasked) GetOXMName() string {
1939 return "ct_mark_masked"
1940}
1941
1942func (self *NxmCtMarkMasked) GetOXMValue() interface{} {
1943 return self.Value
1944}
1945
1946func (self *NxmCtMarkMasked) GetOXMValueMask() interface{} {
1947 return self.ValueMask
1948}
1949
1950func (self *NxmCtMarkMasked) MarshalJSON() ([]byte, error) {
1951 value, err := jsonValue(self.GetOXMValue())
1952 if err != nil {
1953 return nil, err
1954 }
1955 valueMask, err := jsonValue(self.GetOXMValueMask())
1956 if err != nil {
1957 return nil, err
1958 }
1959 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
1960}
1961
1962type NxmCtNwDst struct {
1963 *Oxm
1964 Value net.IP
1965}
1966
1967type INxmCtNwDst interface {
1968 goloxi.IOxm
1969 GetValue() net.IP
1970}
1971
1972func (self *NxmCtNwDst) GetValue() net.IP {
1973 return self.Value
1974}
1975
1976func (self *NxmCtNwDst) SetValue(v net.IP) {
1977 self.Value = v
1978}
1979
1980func (self *NxmCtNwDst) Serialize(encoder *goloxi.Encoder) error {
1981 if err := self.Oxm.Serialize(encoder); err != nil {
1982 return err
1983 }
1984
1985 encoder.Write(self.Value.To4())
1986
1987 return nil
1988}
1989
1990func DecodeNxmCtNwDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtNwDst, error) {
1991 _nxmctnwdst := &NxmCtNwDst{Oxm: parent}
1992 if decoder.Length() < 4 {
1993 return nil, fmt.Errorf("NxmCtNwDst packet too short: %d < 4", decoder.Length())
1994 }
1995 _nxmctnwdst.Value = net.IP(decoder.Read(4))
1996 return _nxmctnwdst, nil
1997}
1998
1999func NewNxmCtNwDst() *NxmCtNwDst {
2000 obj := &NxmCtNwDst{
2001 Oxm: NewOxm(127492),
2002 }
2003 return obj
2004}
2005func (self *NxmCtNwDst) GetOXMName() string {
2006 return "ct_nw_dst"
2007}
2008
2009func (self *NxmCtNwDst) GetOXMValue() interface{} {
2010 return self.Value
2011}
2012
2013func (self *NxmCtNwDst) MarshalJSON() ([]byte, error) {
2014 value, err := jsonValue(self.GetOXMValue())
2015 if err != nil {
2016 return nil, err
2017 }
2018 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
2019}
2020
2021type NxmCtNwDstMasked struct {
2022 *Oxm
2023 Value net.IP
2024 ValueMask net.IP
2025}
2026
2027type INxmCtNwDstMasked interface {
2028 goloxi.IOxm
2029 GetValue() net.IP
2030 GetValueMask() net.IP
2031}
2032
2033func (self *NxmCtNwDstMasked) GetValue() net.IP {
2034 return self.Value
2035}
2036
2037func (self *NxmCtNwDstMasked) SetValue(v net.IP) {
2038 self.Value = v
2039}
2040
2041func (self *NxmCtNwDstMasked) GetValueMask() net.IP {
2042 return self.ValueMask
2043}
2044
2045func (self *NxmCtNwDstMasked) SetValueMask(v net.IP) {
2046 self.ValueMask = v
2047}
2048
2049func (self *NxmCtNwDstMasked) Serialize(encoder *goloxi.Encoder) error {
2050 if err := self.Oxm.Serialize(encoder); err != nil {
2051 return err
2052 }
2053
2054 encoder.Write(self.Value.To4())
2055 encoder.Write(self.ValueMask.To4())
2056
2057 return nil
2058}
2059
2060func DecodeNxmCtNwDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtNwDstMasked, error) {
2061 _nxmctnwdstmasked := &NxmCtNwDstMasked{Oxm: parent}
2062 if decoder.Length() < 8 {
2063 return nil, fmt.Errorf("NxmCtNwDstMasked packet too short: %d < 8", decoder.Length())
2064 }
2065 _nxmctnwdstmasked.Value = net.IP(decoder.Read(4))
2066 _nxmctnwdstmasked.ValueMask = net.IP(decoder.Read(4))
2067 return _nxmctnwdstmasked, nil
2068}
2069
2070func NewNxmCtNwDstMasked() *NxmCtNwDstMasked {
2071 obj := &NxmCtNwDstMasked{
2072 Oxm: NewOxm(127752),
2073 }
2074 return obj
2075}
2076func (self *NxmCtNwDstMasked) GetOXMName() string {
2077 return "ct_nw_dst_masked"
2078}
2079
2080func (self *NxmCtNwDstMasked) GetOXMValue() interface{} {
2081 return self.Value
2082}
2083
2084func (self *NxmCtNwDstMasked) GetOXMValueMask() interface{} {
2085 return self.ValueMask
2086}
2087
2088func (self *NxmCtNwDstMasked) MarshalJSON() ([]byte, error) {
2089 value, err := jsonValue(self.GetOXMValue())
2090 if err != nil {
2091 return nil, err
2092 }
2093 valueMask, err := jsonValue(self.GetOXMValueMask())
2094 if err != nil {
2095 return nil, err
2096 }
2097 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
2098}
2099
2100type NxmCtNwProto struct {
2101 *Oxm
2102 Value uint8
2103}
2104
2105type INxmCtNwProto interface {
2106 goloxi.IOxm
2107 GetValue() uint8
2108}
2109
2110func (self *NxmCtNwProto) GetValue() uint8 {
2111 return self.Value
2112}
2113
2114func (self *NxmCtNwProto) SetValue(v uint8) {
2115 self.Value = v
2116}
2117
2118func (self *NxmCtNwProto) Serialize(encoder *goloxi.Encoder) error {
2119 if err := self.Oxm.Serialize(encoder); err != nil {
2120 return err
2121 }
2122
2123 encoder.PutUint8(uint8(self.Value))
2124
2125 return nil
2126}
2127
2128func DecodeNxmCtNwProto(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtNwProto, error) {
2129 _nxmctnwproto := &NxmCtNwProto{Oxm: parent}
2130 if decoder.Length() < 1 {
2131 return nil, fmt.Errorf("NxmCtNwProto packet too short: %d < 1", decoder.Length())
2132 }
2133 _nxmctnwproto.Value = uint8(decoder.ReadByte())
2134 return _nxmctnwproto, nil
2135}
2136
2137func NewNxmCtNwProto() *NxmCtNwProto {
2138 obj := &NxmCtNwProto{
2139 Oxm: NewOxm(126465),
2140 }
2141 return obj
2142}
2143func (self *NxmCtNwProto) GetOXMName() string {
2144 return "ct_nw_proto"
2145}
2146
2147func (self *NxmCtNwProto) GetOXMValue() interface{} {
2148 return self.Value
2149}
2150
2151func (self *NxmCtNwProto) MarshalJSON() ([]byte, error) {
2152 value, err := jsonValue(self.GetOXMValue())
2153 if err != nil {
2154 return nil, err
2155 }
2156 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
2157}
2158
2159type NxmCtNwSrc struct {
2160 *Oxm
2161 Value net.IP
2162}
2163
2164type INxmCtNwSrc interface {
2165 goloxi.IOxm
2166 GetValue() net.IP
2167}
2168
2169func (self *NxmCtNwSrc) GetValue() net.IP {
2170 return self.Value
2171}
2172
2173func (self *NxmCtNwSrc) SetValue(v net.IP) {
2174 self.Value = v
2175}
2176
2177func (self *NxmCtNwSrc) Serialize(encoder *goloxi.Encoder) error {
2178 if err := self.Oxm.Serialize(encoder); err != nil {
2179 return err
2180 }
2181
2182 encoder.Write(self.Value.To4())
2183
2184 return nil
2185}
2186
2187func DecodeNxmCtNwSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtNwSrc, error) {
2188 _nxmctnwsrc := &NxmCtNwSrc{Oxm: parent}
2189 if decoder.Length() < 4 {
2190 return nil, fmt.Errorf("NxmCtNwSrc packet too short: %d < 4", decoder.Length())
2191 }
2192 _nxmctnwsrc.Value = net.IP(decoder.Read(4))
2193 return _nxmctnwsrc, nil
2194}
2195
2196func NewNxmCtNwSrc() *NxmCtNwSrc {
2197 obj := &NxmCtNwSrc{
2198 Oxm: NewOxm(126980),
2199 }
2200 return obj
2201}
2202func (self *NxmCtNwSrc) GetOXMName() string {
2203 return "ct_nw_src"
2204}
2205
2206func (self *NxmCtNwSrc) GetOXMValue() interface{} {
2207 return self.Value
2208}
2209
2210func (self *NxmCtNwSrc) MarshalJSON() ([]byte, error) {
2211 value, err := jsonValue(self.GetOXMValue())
2212 if err != nil {
2213 return nil, err
2214 }
2215 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
2216}
2217
2218type NxmCtNwSrcMasked struct {
2219 *Oxm
2220 Value net.IP
2221 ValueMask net.IP
2222}
2223
2224type INxmCtNwSrcMasked interface {
2225 goloxi.IOxm
2226 GetValue() net.IP
2227 GetValueMask() net.IP
2228}
2229
2230func (self *NxmCtNwSrcMasked) GetValue() net.IP {
2231 return self.Value
2232}
2233
2234func (self *NxmCtNwSrcMasked) SetValue(v net.IP) {
2235 self.Value = v
2236}
2237
2238func (self *NxmCtNwSrcMasked) GetValueMask() net.IP {
2239 return self.ValueMask
2240}
2241
2242func (self *NxmCtNwSrcMasked) SetValueMask(v net.IP) {
2243 self.ValueMask = v
2244}
2245
2246func (self *NxmCtNwSrcMasked) Serialize(encoder *goloxi.Encoder) error {
2247 if err := self.Oxm.Serialize(encoder); err != nil {
2248 return err
2249 }
2250
2251 encoder.Write(self.Value.To4())
2252 encoder.Write(self.ValueMask.To4())
2253
2254 return nil
2255}
2256
2257func DecodeNxmCtNwSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtNwSrcMasked, error) {
2258 _nxmctnwsrcmasked := &NxmCtNwSrcMasked{Oxm: parent}
2259 if decoder.Length() < 8 {
2260 return nil, fmt.Errorf("NxmCtNwSrcMasked packet too short: %d < 8", decoder.Length())
2261 }
2262 _nxmctnwsrcmasked.Value = net.IP(decoder.Read(4))
2263 _nxmctnwsrcmasked.ValueMask = net.IP(decoder.Read(4))
2264 return _nxmctnwsrcmasked, nil
2265}
2266
2267func NewNxmCtNwSrcMasked() *NxmCtNwSrcMasked {
2268 obj := &NxmCtNwSrcMasked{
2269 Oxm: NewOxm(127240),
2270 }
2271 return obj
2272}
2273func (self *NxmCtNwSrcMasked) GetOXMName() string {
2274 return "ct_nw_src_masked"
2275}
2276
2277func (self *NxmCtNwSrcMasked) GetOXMValue() interface{} {
2278 return self.Value
2279}
2280
2281func (self *NxmCtNwSrcMasked) GetOXMValueMask() interface{} {
2282 return self.ValueMask
2283}
2284
2285func (self *NxmCtNwSrcMasked) MarshalJSON() ([]byte, error) {
2286 value, err := jsonValue(self.GetOXMValue())
2287 if err != nil {
2288 return nil, err
2289 }
2290 valueMask, err := jsonValue(self.GetOXMValueMask())
2291 if err != nil {
2292 return nil, err
2293 }
2294 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
2295}
2296
2297type NxmCtState struct {
2298 *Oxm
2299 Value []byte
2300}
2301
2302type INxmCtState interface {
2303 goloxi.IOxm
2304 GetValue() []byte
2305}
2306
2307func (self *NxmCtState) GetValue() []byte {
2308 return self.Value
2309}
2310
2311func (self *NxmCtState) SetValue(v []byte) {
2312 self.Value = v
2313}
2314
2315func (self *NxmCtState) Serialize(encoder *goloxi.Encoder) error {
2316 if err := self.Oxm.Serialize(encoder); err != nil {
2317 return err
2318 }
2319
2320 encoder.Write(self.Value)
2321
2322 return nil
2323}
2324
2325func DecodeNxmCtState(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtState, error) {
2326 _nxmctstate := &NxmCtState{Oxm: parent}
2327 _nxmctstate.Value = decoder.Read(int(_nxmctstate.TypeLen & 0xFF))
2328 return _nxmctstate, nil
2329}
2330
2331func NewNxmCtState() *NxmCtState {
2332 obj := &NxmCtState{
2333 Oxm: NewOxm(119300),
2334 }
2335 return obj
2336}
2337func (self *NxmCtState) GetOXMName() string {
2338 return "ct_state"
2339}
2340
2341func (self *NxmCtState) GetOXMValue() interface{} {
2342 return self.Value
2343}
2344
2345func (self *NxmCtState) MarshalJSON() ([]byte, error) {
2346 value, err := jsonValue(self.GetOXMValue())
2347 if err != nil {
2348 return nil, err
2349 }
2350 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
2351}
2352
2353type NxmCtStateMasked struct {
2354 *Oxm
2355 Value []byte
2356 ValueMask []byte
2357}
2358
2359type INxmCtStateMasked interface {
2360 goloxi.IOxm
2361 GetValue() []byte
2362 GetValueMask() []byte
2363}
2364
2365func (self *NxmCtStateMasked) GetValue() []byte {
2366 return self.Value
2367}
2368
2369func (self *NxmCtStateMasked) SetValue(v []byte) {
2370 self.Value = v
2371}
2372
2373func (self *NxmCtStateMasked) GetValueMask() []byte {
2374 return self.ValueMask
2375}
2376
2377func (self *NxmCtStateMasked) SetValueMask(v []byte) {
2378 self.ValueMask = v
2379}
2380
2381func (self *NxmCtStateMasked) Serialize(encoder *goloxi.Encoder) error {
2382 if err := self.Oxm.Serialize(encoder); err != nil {
2383 return err
2384 }
2385
2386 encoder.Write(self.Value)
2387 encoder.Write(self.ValueMask)
2388
2389 return nil
2390}
2391
2392func DecodeNxmCtStateMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtStateMasked, error) {
2393 _nxmctstatemasked := &NxmCtStateMasked{Oxm: parent}
2394 _nxmctstatemasked.Value = decoder.Read(int(_nxmctstatemasked.TypeLen & 0xFF))
2395 _nxmctstatemasked.ValueMask = decoder.Read(int(_nxmctstatemasked.TypeLen & 0xFF))
2396 return _nxmctstatemasked, nil
2397}
2398
2399func NewNxmCtStateMasked() *NxmCtStateMasked {
2400 obj := &NxmCtStateMasked{
2401 Oxm: NewOxm(119560),
2402 }
2403 return obj
2404}
2405func (self *NxmCtStateMasked) GetOXMName() string {
2406 return "ct_state_masked"
2407}
2408
2409func (self *NxmCtStateMasked) GetOXMValue() interface{} {
2410 return self.Value
2411}
2412
2413func (self *NxmCtStateMasked) GetOXMValueMask() interface{} {
2414 return self.ValueMask
2415}
2416
2417func (self *NxmCtStateMasked) MarshalJSON() ([]byte, error) {
2418 value, err := jsonValue(self.GetOXMValue())
2419 if err != nil {
2420 return nil, err
2421 }
2422 valueMask, err := jsonValue(self.GetOXMValueMask())
2423 if err != nil {
2424 return nil, err
2425 }
2426 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
2427}
2428
2429type NxmCtTpDst struct {
2430 *Oxm
2431 Value uint16
2432}
2433
2434type INxmCtTpDst interface {
2435 goloxi.IOxm
2436 GetValue() uint16
2437}
2438
2439func (self *NxmCtTpDst) GetValue() uint16 {
2440 return self.Value
2441}
2442
2443func (self *NxmCtTpDst) SetValue(v uint16) {
2444 self.Value = v
2445}
2446
2447func (self *NxmCtTpDst) Serialize(encoder *goloxi.Encoder) error {
2448 if err := self.Oxm.Serialize(encoder); err != nil {
2449 return err
2450 }
2451
2452 encoder.PutUint16(uint16(self.Value))
2453
2454 return nil
2455}
2456
2457func DecodeNxmCtTpDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtTpDst, error) {
2458 _nxmcttpdst := &NxmCtTpDst{Oxm: parent}
2459 if decoder.Length() < 2 {
2460 return nil, fmt.Errorf("NxmCtTpDst packet too short: %d < 2", decoder.Length())
2461 }
2462 _nxmcttpdst.Value = uint16(decoder.ReadUint16())
2463 return _nxmcttpdst, nil
2464}
2465
2466func NewNxmCtTpDst() *NxmCtTpDst {
2467 obj := &NxmCtTpDst{
2468 Oxm: NewOxm(129538),
2469 }
2470 return obj
2471}
2472func (self *NxmCtTpDst) GetOXMName() string {
2473 return "ct_tp_dst"
2474}
2475
2476func (self *NxmCtTpDst) GetOXMValue() interface{} {
2477 return self.Value
2478}
2479
2480func (self *NxmCtTpDst) MarshalJSON() ([]byte, error) {
2481 value, err := jsonValue(self.GetOXMValue())
2482 if err != nil {
2483 return nil, err
2484 }
2485 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
2486}
2487
2488type NxmCtTpDstMasked struct {
2489 *Oxm
2490 Value uint16
2491 ValueMask uint16
2492}
2493
2494type INxmCtTpDstMasked interface {
2495 goloxi.IOxm
2496 GetValue() uint16
2497 GetValueMask() uint16
2498}
2499
2500func (self *NxmCtTpDstMasked) GetValue() uint16 {
2501 return self.Value
2502}
2503
2504func (self *NxmCtTpDstMasked) SetValue(v uint16) {
2505 self.Value = v
2506}
2507
2508func (self *NxmCtTpDstMasked) GetValueMask() uint16 {
2509 return self.ValueMask
2510}
2511
2512func (self *NxmCtTpDstMasked) SetValueMask(v uint16) {
2513 self.ValueMask = v
2514}
2515
2516func (self *NxmCtTpDstMasked) Serialize(encoder *goloxi.Encoder) error {
2517 if err := self.Oxm.Serialize(encoder); err != nil {
2518 return err
2519 }
2520
2521 encoder.PutUint16(uint16(self.Value))
2522 encoder.PutUint16(uint16(self.ValueMask))
2523
2524 return nil
2525}
2526
2527func DecodeNxmCtTpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtTpDstMasked, error) {
2528 _nxmcttpdstmasked := &NxmCtTpDstMasked{Oxm: parent}
2529 if decoder.Length() < 4 {
2530 return nil, fmt.Errorf("NxmCtTpDstMasked packet too short: %d < 4", decoder.Length())
2531 }
2532 _nxmcttpdstmasked.Value = uint16(decoder.ReadUint16())
2533 _nxmcttpdstmasked.ValueMask = uint16(decoder.ReadUint16())
2534 return _nxmcttpdstmasked, nil
2535}
2536
2537func NewNxmCtTpDstMasked() *NxmCtTpDstMasked {
2538 obj := &NxmCtTpDstMasked{
2539 Oxm: NewOxm(129796),
2540 }
2541 return obj
2542}
2543func (self *NxmCtTpDstMasked) GetOXMName() string {
2544 return "ct_tp_dst_masked"
2545}
2546
2547func (self *NxmCtTpDstMasked) GetOXMValue() interface{} {
2548 return self.Value
2549}
2550
2551func (self *NxmCtTpDstMasked) GetOXMValueMask() interface{} {
2552 return self.ValueMask
2553}
2554
2555func (self *NxmCtTpDstMasked) MarshalJSON() ([]byte, error) {
2556 value, err := jsonValue(self.GetOXMValue())
2557 if err != nil {
2558 return nil, err
2559 }
2560 valueMask, err := jsonValue(self.GetOXMValueMask())
2561 if err != nil {
2562 return nil, err
2563 }
2564 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
2565}
2566
2567type NxmCtTpSrc struct {
2568 *Oxm
2569 Value uint16
2570}
2571
2572type INxmCtTpSrc interface {
2573 goloxi.IOxm
2574 GetValue() uint16
2575}
2576
2577func (self *NxmCtTpSrc) GetValue() uint16 {
2578 return self.Value
2579}
2580
2581func (self *NxmCtTpSrc) SetValue(v uint16) {
2582 self.Value = v
2583}
2584
2585func (self *NxmCtTpSrc) Serialize(encoder *goloxi.Encoder) error {
2586 if err := self.Oxm.Serialize(encoder); err != nil {
2587 return err
2588 }
2589
2590 encoder.PutUint16(uint16(self.Value))
2591
2592 return nil
2593}
2594
2595func DecodeNxmCtTpSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtTpSrc, error) {
2596 _nxmcttpsrc := &NxmCtTpSrc{Oxm: parent}
2597 if decoder.Length() < 2 {
2598 return nil, fmt.Errorf("NxmCtTpSrc packet too short: %d < 2", decoder.Length())
2599 }
2600 _nxmcttpsrc.Value = uint16(decoder.ReadUint16())
2601 return _nxmcttpsrc, nil
2602}
2603
2604func NewNxmCtTpSrc() *NxmCtTpSrc {
2605 obj := &NxmCtTpSrc{
2606 Oxm: NewOxm(129026),
2607 }
2608 return obj
2609}
2610func (self *NxmCtTpSrc) GetOXMName() string {
2611 return "ct_tp_src"
2612}
2613
2614func (self *NxmCtTpSrc) GetOXMValue() interface{} {
2615 return self.Value
2616}
2617
2618func (self *NxmCtTpSrc) MarshalJSON() ([]byte, error) {
2619 value, err := jsonValue(self.GetOXMValue())
2620 if err != nil {
2621 return nil, err
2622 }
2623 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
2624}
2625
2626type NxmCtTpSrcMasked struct {
2627 *Oxm
2628 Value uint16
2629 ValueMask uint16
2630}
2631
2632type INxmCtTpSrcMasked interface {
2633 goloxi.IOxm
2634 GetValue() uint16
2635 GetValueMask() uint16
2636}
2637
2638func (self *NxmCtTpSrcMasked) GetValue() uint16 {
2639 return self.Value
2640}
2641
2642func (self *NxmCtTpSrcMasked) SetValue(v uint16) {
2643 self.Value = v
2644}
2645
2646func (self *NxmCtTpSrcMasked) GetValueMask() uint16 {
2647 return self.ValueMask
2648}
2649
2650func (self *NxmCtTpSrcMasked) SetValueMask(v uint16) {
2651 self.ValueMask = v
2652}
2653
2654func (self *NxmCtTpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
2655 if err := self.Oxm.Serialize(encoder); err != nil {
2656 return err
2657 }
2658
2659 encoder.PutUint16(uint16(self.Value))
2660 encoder.PutUint16(uint16(self.ValueMask))
2661
2662 return nil
2663}
2664
2665func DecodeNxmCtTpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtTpSrcMasked, error) {
2666 _nxmcttpsrcmasked := &NxmCtTpSrcMasked{Oxm: parent}
2667 if decoder.Length() < 4 {
2668 return nil, fmt.Errorf("NxmCtTpSrcMasked packet too short: %d < 4", decoder.Length())
2669 }
2670 _nxmcttpsrcmasked.Value = uint16(decoder.ReadUint16())
2671 _nxmcttpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
2672 return _nxmcttpsrcmasked, nil
2673}
2674
2675func NewNxmCtTpSrcMasked() *NxmCtTpSrcMasked {
2676 obj := &NxmCtTpSrcMasked{
2677 Oxm: NewOxm(129284),
2678 }
2679 return obj
2680}
2681func (self *NxmCtTpSrcMasked) GetOXMName() string {
2682 return "ct_tp_src_masked"
2683}
2684
2685func (self *NxmCtTpSrcMasked) GetOXMValue() interface{} {
2686 return self.Value
2687}
2688
2689func (self *NxmCtTpSrcMasked) GetOXMValueMask() interface{} {
2690 return self.ValueMask
2691}
2692
2693func (self *NxmCtTpSrcMasked) MarshalJSON() ([]byte, error) {
2694 value, err := jsonValue(self.GetOXMValue())
2695 if err != nil {
2696 return nil, err
2697 }
2698 valueMask, err := jsonValue(self.GetOXMValueMask())
2699 if err != nil {
2700 return nil, err
2701 }
2702 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
2703}
2704
2705type NxmCtZone struct {
2706 *Oxm
2707 Value uint16
2708}
2709
2710type INxmCtZone interface {
2711 goloxi.IOxm
2712 GetValue() uint16
2713}
2714
2715func (self *NxmCtZone) GetValue() uint16 {
2716 return self.Value
2717}
2718
2719func (self *NxmCtZone) SetValue(v uint16) {
2720 self.Value = v
2721}
2722
2723func (self *NxmCtZone) Serialize(encoder *goloxi.Encoder) error {
2724 if err := self.Oxm.Serialize(encoder); err != nil {
2725 return err
2726 }
2727
2728 encoder.PutUint16(uint16(self.Value))
2729
2730 return nil
2731}
2732
2733func DecodeNxmCtZone(parent *Oxm, decoder *goloxi.Decoder) (*NxmCtZone, error) {
2734 _nxmctzone := &NxmCtZone{Oxm: parent}
2735 if decoder.Length() < 2 {
2736 return nil, fmt.Errorf("NxmCtZone packet too short: %d < 2", decoder.Length())
2737 }
2738 _nxmctzone.Value = uint16(decoder.ReadUint16())
2739 return _nxmctzone, nil
2740}
2741
2742func NewNxmCtZone() *NxmCtZone {
2743 obj := &NxmCtZone{
2744 Oxm: NewOxm(119810),
2745 }
2746 return obj
2747}
2748func (self *NxmCtZone) GetOXMName() string {
2749 return "ct_zone"
2750}
2751
2752func (self *NxmCtZone) GetOXMValue() interface{} {
2753 return self.Value
2754}
2755
2756func (self *NxmCtZone) MarshalJSON() ([]byte, error) {
2757 value, err := jsonValue(self.GetOXMValue())
2758 if err != nil {
2759 return nil, err
2760 }
2761 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
2762}
2763
2764type NxmDpHash struct {
2765 *Oxm
2766 Value uint32
2767}
2768
2769type INxmDpHash interface {
2770 goloxi.IOxm
2771 GetValue() uint32
2772}
2773
2774func (self *NxmDpHash) GetValue() uint32 {
2775 return self.Value
2776}
2777
2778func (self *NxmDpHash) SetValue(v uint32) {
2779 self.Value = v
2780}
2781
2782func (self *NxmDpHash) Serialize(encoder *goloxi.Encoder) error {
2783 if err := self.Oxm.Serialize(encoder); err != nil {
2784 return err
2785 }
2786
2787 encoder.PutUint32(uint32(self.Value))
2788
2789 return nil
2790}
2791
2792func DecodeNxmDpHash(parent *Oxm, decoder *goloxi.Decoder) (*NxmDpHash, error) {
2793 _nxmdphash := &NxmDpHash{Oxm: parent}
2794 if decoder.Length() < 4 {
2795 return nil, fmt.Errorf("NxmDpHash packet too short: %d < 4", decoder.Length())
2796 }
2797 _nxmdphash.Value = uint32(decoder.ReadUint32())
2798 return _nxmdphash, nil
2799}
2800
2801func NewNxmDpHash() *NxmDpHash {
2802 obj := &NxmDpHash{
2803 Oxm: NewOxm(83460),
2804 }
2805 return obj
2806}
2807func (self *NxmDpHash) GetOXMName() string {
2808 return "dp_hash"
2809}
2810
2811func (self *NxmDpHash) GetOXMValue() interface{} {
2812 return self.Value
2813}
2814
2815func (self *NxmDpHash) MarshalJSON() ([]byte, error) {
2816 value, err := jsonValue(self.GetOXMValue())
2817 if err != nil {
2818 return nil, err
2819 }
2820 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
2821}
2822
2823type NxmDpHashMasked struct {
2824 *Oxm
2825 Value uint32
2826 ValueMask uint32
2827}
2828
2829type INxmDpHashMasked interface {
2830 goloxi.IOxm
2831 GetValue() uint32
2832 GetValueMask() uint32
2833}
2834
2835func (self *NxmDpHashMasked) GetValue() uint32 {
2836 return self.Value
2837}
2838
2839func (self *NxmDpHashMasked) SetValue(v uint32) {
2840 self.Value = v
2841}
2842
2843func (self *NxmDpHashMasked) GetValueMask() uint32 {
2844 return self.ValueMask
2845}
2846
2847func (self *NxmDpHashMasked) SetValueMask(v uint32) {
2848 self.ValueMask = v
2849}
2850
2851func (self *NxmDpHashMasked) Serialize(encoder *goloxi.Encoder) error {
2852 if err := self.Oxm.Serialize(encoder); err != nil {
2853 return err
2854 }
2855
2856 encoder.PutUint32(uint32(self.Value))
2857 encoder.PutUint32(uint32(self.ValueMask))
2858
2859 return nil
2860}
2861
2862func DecodeNxmDpHashMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmDpHashMasked, error) {
2863 _nxmdphashmasked := &NxmDpHashMasked{Oxm: parent}
2864 if decoder.Length() < 8 {
2865 return nil, fmt.Errorf("NxmDpHashMasked packet too short: %d < 8", decoder.Length())
2866 }
2867 _nxmdphashmasked.Value = uint32(decoder.ReadUint32())
2868 _nxmdphashmasked.ValueMask = uint32(decoder.ReadUint32())
2869 return _nxmdphashmasked, nil
2870}
2871
2872func NewNxmDpHashMasked() *NxmDpHashMasked {
2873 obj := &NxmDpHashMasked{
2874 Oxm: NewOxm(83720),
2875 }
2876 return obj
2877}
2878func (self *NxmDpHashMasked) GetOXMName() string {
2879 return "dp_hash_masked"
2880}
2881
2882func (self *NxmDpHashMasked) GetOXMValue() interface{} {
2883 return self.Value
2884}
2885
2886func (self *NxmDpHashMasked) GetOXMValueMask() interface{} {
2887 return self.ValueMask
2888}
2889
2890func (self *NxmDpHashMasked) MarshalJSON() ([]byte, error) {
2891 value, err := jsonValue(self.GetOXMValue())
2892 if err != nil {
2893 return nil, err
2894 }
2895 valueMask, err := jsonValue(self.GetOXMValueMask())
2896 if err != nil {
2897 return nil, err
2898 }
2899 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
2900}
2901
2902type NxmEthDst struct {
2903 *Oxm
2904 Value net.HardwareAddr
2905}
2906
2907type INxmEthDst interface {
2908 goloxi.IOxm
2909 GetValue() net.HardwareAddr
2910}
2911
2912func (self *NxmEthDst) GetValue() net.HardwareAddr {
2913 return self.Value
2914}
2915
2916func (self *NxmEthDst) SetValue(v net.HardwareAddr) {
2917 self.Value = v
2918}
2919
2920func (self *NxmEthDst) Serialize(encoder *goloxi.Encoder) error {
2921 if err := self.Oxm.Serialize(encoder); err != nil {
2922 return err
2923 }
2924
2925 encoder.Write(self.Value)
2926
2927 return nil
2928}
2929
2930func DecodeNxmEthDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmEthDst, error) {
2931 _nxmethdst := &NxmEthDst{Oxm: parent}
2932 if decoder.Length() < 6 {
2933 return nil, fmt.Errorf("NxmEthDst packet too short: %d < 6", decoder.Length())
2934 }
2935 _nxmethdst.Value = net.HardwareAddr(decoder.Read(6))
2936 return _nxmethdst, nil
2937}
2938
2939func NewNxmEthDst() *NxmEthDst {
2940 obj := &NxmEthDst{
2941 Oxm: NewOxm(518),
2942 }
2943 return obj
2944}
2945func (self *NxmEthDst) GetOXMName() string {
2946 return "eth_dst"
2947}
2948
2949func (self *NxmEthDst) GetOXMValue() interface{} {
2950 return self.Value
2951}
2952
2953func (self *NxmEthDst) MarshalJSON() ([]byte, error) {
2954 value, err := jsonValue(self.GetOXMValue())
2955 if err != nil {
2956 return nil, err
2957 }
2958 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
2959}
2960
2961type NxmEthDstMasked struct {
2962 *Oxm
2963 Value net.HardwareAddr
2964 ValueMask net.HardwareAddr
2965}
2966
2967type INxmEthDstMasked interface {
2968 goloxi.IOxm
2969 GetValue() net.HardwareAddr
2970 GetValueMask() net.HardwareAddr
2971}
2972
2973func (self *NxmEthDstMasked) GetValue() net.HardwareAddr {
2974 return self.Value
2975}
2976
2977func (self *NxmEthDstMasked) SetValue(v net.HardwareAddr) {
2978 self.Value = v
2979}
2980
2981func (self *NxmEthDstMasked) GetValueMask() net.HardwareAddr {
2982 return self.ValueMask
2983}
2984
2985func (self *NxmEthDstMasked) SetValueMask(v net.HardwareAddr) {
2986 self.ValueMask = v
2987}
2988
2989func (self *NxmEthDstMasked) Serialize(encoder *goloxi.Encoder) error {
2990 if err := self.Oxm.Serialize(encoder); err != nil {
2991 return err
2992 }
2993
2994 encoder.Write(self.Value)
2995 encoder.Write(self.ValueMask)
2996
2997 return nil
2998}
2999
3000func DecodeNxmEthDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmEthDstMasked, error) {
3001 _nxmethdstmasked := &NxmEthDstMasked{Oxm: parent}
3002 if decoder.Length() < 12 {
3003 return nil, fmt.Errorf("NxmEthDstMasked packet too short: %d < 12", decoder.Length())
3004 }
3005 _nxmethdstmasked.Value = net.HardwareAddr(decoder.Read(6))
3006 _nxmethdstmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
3007 return _nxmethdstmasked, nil
3008}
3009
3010func NewNxmEthDstMasked() *NxmEthDstMasked {
3011 obj := &NxmEthDstMasked{
3012 Oxm: NewOxm(779),
3013 }
3014 return obj
3015}
3016func (self *NxmEthDstMasked) GetOXMName() string {
3017 return "eth_dst_masked"
3018}
3019
3020func (self *NxmEthDstMasked) GetOXMValue() interface{} {
3021 return self.Value
3022}
3023
3024func (self *NxmEthDstMasked) GetOXMValueMask() interface{} {
3025 return self.ValueMask
3026}
3027
3028func (self *NxmEthDstMasked) MarshalJSON() ([]byte, error) {
3029 value, err := jsonValue(self.GetOXMValue())
3030 if err != nil {
3031 return nil, err
3032 }
3033 valueMask, err := jsonValue(self.GetOXMValueMask())
3034 if err != nil {
3035 return nil, err
3036 }
3037 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
3038}
3039
3040type NxmEthSrc struct {
3041 *Oxm
3042 Value net.HardwareAddr
3043}
3044
3045type INxmEthSrc interface {
3046 goloxi.IOxm
3047 GetValue() net.HardwareAddr
3048}
3049
3050func (self *NxmEthSrc) GetValue() net.HardwareAddr {
3051 return self.Value
3052}
3053
3054func (self *NxmEthSrc) SetValue(v net.HardwareAddr) {
3055 self.Value = v
3056}
3057
3058func (self *NxmEthSrc) Serialize(encoder *goloxi.Encoder) error {
3059 if err := self.Oxm.Serialize(encoder); err != nil {
3060 return err
3061 }
3062
3063 encoder.Write(self.Value)
3064
3065 return nil
3066}
3067
3068func DecodeNxmEthSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmEthSrc, error) {
3069 _nxmethsrc := &NxmEthSrc{Oxm: parent}
3070 if decoder.Length() < 6 {
3071 return nil, fmt.Errorf("NxmEthSrc packet too short: %d < 6", decoder.Length())
3072 }
3073 _nxmethsrc.Value = net.HardwareAddr(decoder.Read(6))
3074 return _nxmethsrc, nil
3075}
3076
3077func NewNxmEthSrc() *NxmEthSrc {
3078 obj := &NxmEthSrc{
3079 Oxm: NewOxm(1030),
3080 }
3081 return obj
3082}
3083func (self *NxmEthSrc) GetOXMName() string {
3084 return "eth_src"
3085}
3086
3087func (self *NxmEthSrc) GetOXMValue() interface{} {
3088 return self.Value
3089}
3090
3091func (self *NxmEthSrc) MarshalJSON() ([]byte, error) {
3092 value, err := jsonValue(self.GetOXMValue())
3093 if err != nil {
3094 return nil, err
3095 }
3096 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3097}
3098
3099type NxmEthSrcMasked struct {
3100 *Oxm
3101 Value net.HardwareAddr
3102 ValueMask net.HardwareAddr
3103}
3104
3105type INxmEthSrcMasked interface {
3106 goloxi.IOxm
3107 GetValue() net.HardwareAddr
3108 GetValueMask() net.HardwareAddr
3109}
3110
3111func (self *NxmEthSrcMasked) GetValue() net.HardwareAddr {
3112 return self.Value
3113}
3114
3115func (self *NxmEthSrcMasked) SetValue(v net.HardwareAddr) {
3116 self.Value = v
3117}
3118
3119func (self *NxmEthSrcMasked) GetValueMask() net.HardwareAddr {
3120 return self.ValueMask
3121}
3122
3123func (self *NxmEthSrcMasked) SetValueMask(v net.HardwareAddr) {
3124 self.ValueMask = v
3125}
3126
3127func (self *NxmEthSrcMasked) Serialize(encoder *goloxi.Encoder) error {
3128 if err := self.Oxm.Serialize(encoder); err != nil {
3129 return err
3130 }
3131
3132 encoder.Write(self.Value)
3133 encoder.Write(self.ValueMask)
3134
3135 return nil
3136}
3137
3138func DecodeNxmEthSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmEthSrcMasked, error) {
3139 _nxmethsrcmasked := &NxmEthSrcMasked{Oxm: parent}
3140 if decoder.Length() < 12 {
3141 return nil, fmt.Errorf("NxmEthSrcMasked packet too short: %d < 12", decoder.Length())
3142 }
3143 _nxmethsrcmasked.Value = net.HardwareAddr(decoder.Read(6))
3144 _nxmethsrcmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
3145 return _nxmethsrcmasked, nil
3146}
3147
3148func NewNxmEthSrcMasked() *NxmEthSrcMasked {
3149 obj := &NxmEthSrcMasked{
3150 Oxm: NewOxm(1286),
3151 }
3152 return obj
3153}
3154func (self *NxmEthSrcMasked) GetOXMName() string {
3155 return "eth_src_masked"
3156}
3157
3158func (self *NxmEthSrcMasked) GetOXMValue() interface{} {
3159 return self.Value
3160}
3161
3162func (self *NxmEthSrcMasked) GetOXMValueMask() interface{} {
3163 return self.ValueMask
3164}
3165
3166func (self *NxmEthSrcMasked) MarshalJSON() ([]byte, error) {
3167 value, err := jsonValue(self.GetOXMValue())
3168 if err != nil {
3169 return nil, err
3170 }
3171 valueMask, err := jsonValue(self.GetOXMValueMask())
3172 if err != nil {
3173 return nil, err
3174 }
3175 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
3176}
3177
3178type NxmEthType struct {
3179 *Oxm
3180 Value uint16
3181}
3182
3183type INxmEthType interface {
3184 goloxi.IOxm
3185 GetValue() uint16
3186}
3187
3188func (self *NxmEthType) GetValue() uint16 {
3189 return self.Value
3190}
3191
3192func (self *NxmEthType) SetValue(v uint16) {
3193 self.Value = v
3194}
3195
3196func (self *NxmEthType) Serialize(encoder *goloxi.Encoder) error {
3197 if err := self.Oxm.Serialize(encoder); err != nil {
3198 return err
3199 }
3200
3201 encoder.PutUint16(uint16(self.Value))
3202
3203 return nil
3204}
3205
3206func DecodeNxmEthType(parent *Oxm, decoder *goloxi.Decoder) (*NxmEthType, error) {
3207 _nxmethtype := &NxmEthType{Oxm: parent}
3208 if decoder.Length() < 2 {
3209 return nil, fmt.Errorf("NxmEthType packet too short: %d < 2", decoder.Length())
3210 }
3211 _nxmethtype.Value = uint16(decoder.ReadUint16())
3212 return _nxmethtype, nil
3213}
3214
3215func NewNxmEthType() *NxmEthType {
3216 obj := &NxmEthType{
3217 Oxm: NewOxm(1538),
3218 }
3219 return obj
3220}
3221func (self *NxmEthType) GetOXMName() string {
3222 return "eth_type"
3223}
3224
3225func (self *NxmEthType) GetOXMValue() interface{} {
3226 return self.Value
3227}
3228
3229func (self *NxmEthType) MarshalJSON() ([]byte, error) {
3230 value, err := jsonValue(self.GetOXMValue())
3231 if err != nil {
3232 return nil, err
3233 }
3234 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3235}
3236
3237type NxmIcmpCode struct {
3238 *Oxm
3239 Value uint8
3240}
3241
3242type INxmIcmpCode interface {
3243 goloxi.IOxm
3244 GetValue() uint8
3245}
3246
3247func (self *NxmIcmpCode) GetValue() uint8 {
3248 return self.Value
3249}
3250
3251func (self *NxmIcmpCode) SetValue(v uint8) {
3252 self.Value = v
3253}
3254
3255func (self *NxmIcmpCode) Serialize(encoder *goloxi.Encoder) error {
3256 if err := self.Oxm.Serialize(encoder); err != nil {
3257 return err
3258 }
3259
3260 encoder.PutUint8(uint8(self.Value))
3261
3262 return nil
3263}
3264
3265func DecodeNxmIcmpCode(parent *Oxm, decoder *goloxi.Decoder) (*NxmIcmpCode, error) {
3266 _nxmicmpcode := &NxmIcmpCode{Oxm: parent}
3267 if decoder.Length() < 1 {
3268 return nil, fmt.Errorf("NxmIcmpCode packet too short: %d < 1", decoder.Length())
3269 }
3270 _nxmicmpcode.Value = uint8(decoder.ReadByte())
3271 return _nxmicmpcode, nil
3272}
3273
3274func NewNxmIcmpCode() *NxmIcmpCode {
3275 obj := &NxmIcmpCode{
3276 Oxm: NewOxm(7169),
3277 }
3278 return obj
3279}
3280func (self *NxmIcmpCode) GetOXMName() string {
3281 return "icmp_code"
3282}
3283
3284func (self *NxmIcmpCode) GetOXMValue() interface{} {
3285 return self.Value
3286}
3287
3288func (self *NxmIcmpCode) MarshalJSON() ([]byte, error) {
3289 value, err := jsonValue(self.GetOXMValue())
3290 if err != nil {
3291 return nil, err
3292 }
3293 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3294}
3295
3296type NxmIcmpType struct {
3297 *Oxm
3298 Value uint8
3299}
3300
3301type INxmIcmpType interface {
3302 goloxi.IOxm
3303 GetValue() uint8
3304}
3305
3306func (self *NxmIcmpType) GetValue() uint8 {
3307 return self.Value
3308}
3309
3310func (self *NxmIcmpType) SetValue(v uint8) {
3311 self.Value = v
3312}
3313
3314func (self *NxmIcmpType) Serialize(encoder *goloxi.Encoder) error {
3315 if err := self.Oxm.Serialize(encoder); err != nil {
3316 return err
3317 }
3318
3319 encoder.PutUint8(uint8(self.Value))
3320
3321 return nil
3322}
3323
3324func DecodeNxmIcmpType(parent *Oxm, decoder *goloxi.Decoder) (*NxmIcmpType, error) {
3325 _nxmicmptype := &NxmIcmpType{Oxm: parent}
3326 if decoder.Length() < 1 {
3327 return nil, fmt.Errorf("NxmIcmpType packet too short: %d < 1", decoder.Length())
3328 }
3329 _nxmicmptype.Value = uint8(decoder.ReadByte())
3330 return _nxmicmptype, nil
3331}
3332
3333func NewNxmIcmpType() *NxmIcmpType {
3334 obj := &NxmIcmpType{
3335 Oxm: NewOxm(6657),
3336 }
3337 return obj
3338}
3339func (self *NxmIcmpType) GetOXMName() string {
3340 return "icmp_type"
3341}
3342
3343func (self *NxmIcmpType) GetOXMValue() interface{} {
3344 return self.Value
3345}
3346
3347func (self *NxmIcmpType) MarshalJSON() ([]byte, error) {
3348 value, err := jsonValue(self.GetOXMValue())
3349 if err != nil {
3350 return nil, err
3351 }
3352 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3353}
3354
3355type NxmIcmpv6Code struct {
3356 *Oxm
3357 Value uint8
3358}
3359
3360type INxmIcmpv6Code interface {
3361 goloxi.IOxm
3362 GetValue() uint8
3363}
3364
3365func (self *NxmIcmpv6Code) GetValue() uint8 {
3366 return self.Value
3367}
3368
3369func (self *NxmIcmpv6Code) SetValue(v uint8) {
3370 self.Value = v
3371}
3372
3373func (self *NxmIcmpv6Code) Serialize(encoder *goloxi.Encoder) error {
3374 if err := self.Oxm.Serialize(encoder); err != nil {
3375 return err
3376 }
3377
3378 encoder.PutUint8(uint8(self.Value))
3379
3380 return nil
3381}
3382
3383func DecodeNxmIcmpv6Code(parent *Oxm, decoder *goloxi.Decoder) (*NxmIcmpv6Code, error) {
3384 _nxmicmpv6code := &NxmIcmpv6Code{Oxm: parent}
3385 if decoder.Length() < 1 {
3386 return nil, fmt.Errorf("NxmIcmpv6Code packet too short: %d < 1", decoder.Length())
3387 }
3388 _nxmicmpv6code.Value = uint8(decoder.ReadByte())
3389 return _nxmicmpv6code, nil
3390}
3391
3392func NewNxmIcmpv6Code() *NxmIcmpv6Code {
3393 obj := &NxmIcmpv6Code{
3394 Oxm: NewOxm(76801),
3395 }
3396 return obj
3397}
3398func (self *NxmIcmpv6Code) GetOXMName() string {
3399 return "icmpv6_code"
3400}
3401
3402func (self *NxmIcmpv6Code) GetOXMValue() interface{} {
3403 return self.Value
3404}
3405
3406func (self *NxmIcmpv6Code) MarshalJSON() ([]byte, error) {
3407 value, err := jsonValue(self.GetOXMValue())
3408 if err != nil {
3409 return nil, err
3410 }
3411 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3412}
3413
3414type NxmIcmpv6Type struct {
3415 *Oxm
3416 Value uint8
3417}
3418
3419type INxmIcmpv6Type interface {
3420 goloxi.IOxm
3421 GetValue() uint8
3422}
3423
3424func (self *NxmIcmpv6Type) GetValue() uint8 {
3425 return self.Value
3426}
3427
3428func (self *NxmIcmpv6Type) SetValue(v uint8) {
3429 self.Value = v
3430}
3431
3432func (self *NxmIcmpv6Type) Serialize(encoder *goloxi.Encoder) error {
3433 if err := self.Oxm.Serialize(encoder); err != nil {
3434 return err
3435 }
3436
3437 encoder.PutUint8(uint8(self.Value))
3438
3439 return nil
3440}
3441
3442func DecodeNxmIcmpv6Type(parent *Oxm, decoder *goloxi.Decoder) (*NxmIcmpv6Type, error) {
3443 _nxmicmpv6type := &NxmIcmpv6Type{Oxm: parent}
3444 if decoder.Length() < 1 {
3445 return nil, fmt.Errorf("NxmIcmpv6Type packet too short: %d < 1", decoder.Length())
3446 }
3447 _nxmicmpv6type.Value = uint8(decoder.ReadByte())
3448 return _nxmicmpv6type, nil
3449}
3450
3451func NewNxmIcmpv6Type() *NxmIcmpv6Type {
3452 obj := &NxmIcmpv6Type{
3453 Oxm: NewOxm(76289),
3454 }
3455 return obj
3456}
3457func (self *NxmIcmpv6Type) GetOXMName() string {
3458 return "icmpv6_type"
3459}
3460
3461func (self *NxmIcmpv6Type) GetOXMValue() interface{} {
3462 return self.Value
3463}
3464
3465func (self *NxmIcmpv6Type) MarshalJSON() ([]byte, error) {
3466 value, err := jsonValue(self.GetOXMValue())
3467 if err != nil {
3468 return nil, err
3469 }
3470 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3471}
3472
3473type NxmInPort struct {
3474 *Oxm
3475 Value Port
3476}
3477
3478type INxmInPort interface {
3479 goloxi.IOxm
3480 GetValue() Port
3481}
3482
3483func (self *NxmInPort) GetValue() Port {
3484 return self.Value
3485}
3486
3487func (self *NxmInPort) SetValue(v Port) {
3488 self.Value = v
3489}
3490
3491func (self *NxmInPort) Serialize(encoder *goloxi.Encoder) error {
3492 if err := self.Oxm.Serialize(encoder); err != nil {
3493 return err
3494 }
3495
3496 self.Value.Serialize(encoder)
3497
3498 return nil
3499}
3500
3501func DecodeNxmInPort(parent *Oxm, decoder *goloxi.Decoder) (*NxmInPort, error) {
3502 _nxminport := &NxmInPort{Oxm: parent}
3503 if decoder.Length() < 2 {
3504 return nil, fmt.Errorf("NxmInPort packet too short: %d < 2", decoder.Length())
3505 }
3506 _nxminport.Value.Decode(decoder)
3507 return _nxminport, nil
3508}
3509
3510func NewNxmInPort() *NxmInPort {
3511 obj := &NxmInPort{
3512 Oxm: NewOxm(2),
3513 }
3514 return obj
3515}
3516func (self *NxmInPort) GetOXMName() string {
3517 return "in_port"
3518}
3519
3520func (self *NxmInPort) GetOXMValue() interface{} {
3521 return self.Value
3522}
3523
3524func (self *NxmInPort) MarshalJSON() ([]byte, error) {
3525 value, err := jsonValue(self.GetOXMValue())
3526 if err != nil {
3527 return nil, err
3528 }
3529 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3530}
3531
3532type NxmIpDst struct {
3533 *Oxm
3534 Value net.IP
3535}
3536
3537type INxmIpDst interface {
3538 goloxi.IOxm
3539 GetValue() net.IP
3540}
3541
3542func (self *NxmIpDst) GetValue() net.IP {
3543 return self.Value
3544}
3545
3546func (self *NxmIpDst) SetValue(v net.IP) {
3547 self.Value = v
3548}
3549
3550func (self *NxmIpDst) Serialize(encoder *goloxi.Encoder) error {
3551 if err := self.Oxm.Serialize(encoder); err != nil {
3552 return err
3553 }
3554
3555 encoder.Write(self.Value.To4())
3556
3557 return nil
3558}
3559
3560func DecodeNxmIpDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpDst, error) {
3561 _nxmipdst := &NxmIpDst{Oxm: parent}
3562 if decoder.Length() < 4 {
3563 return nil, fmt.Errorf("NxmIpDst packet too short: %d < 4", decoder.Length())
3564 }
3565 _nxmipdst.Value = net.IP(decoder.Read(4))
3566 return _nxmipdst, nil
3567}
3568
3569func NewNxmIpDst() *NxmIpDst {
3570 obj := &NxmIpDst{
3571 Oxm: NewOxm(4100),
3572 }
3573 return obj
3574}
3575func (self *NxmIpDst) GetOXMName() string {
3576 return "ip_dst"
3577}
3578
3579func (self *NxmIpDst) GetOXMValue() interface{} {
3580 return self.Value
3581}
3582
3583func (self *NxmIpDst) MarshalJSON() ([]byte, error) {
3584 value, err := jsonValue(self.GetOXMValue())
3585 if err != nil {
3586 return nil, err
3587 }
3588 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3589}
3590
3591type NxmIpDstMasked struct {
3592 *Oxm
3593 Value net.IP
3594 ValueMask net.IP
3595}
3596
3597type INxmIpDstMasked interface {
3598 goloxi.IOxm
3599 GetValue() net.IP
3600 GetValueMask() net.IP
3601}
3602
3603func (self *NxmIpDstMasked) GetValue() net.IP {
3604 return self.Value
3605}
3606
3607func (self *NxmIpDstMasked) SetValue(v net.IP) {
3608 self.Value = v
3609}
3610
3611func (self *NxmIpDstMasked) GetValueMask() net.IP {
3612 return self.ValueMask
3613}
3614
3615func (self *NxmIpDstMasked) SetValueMask(v net.IP) {
3616 self.ValueMask = v
3617}
3618
3619func (self *NxmIpDstMasked) Serialize(encoder *goloxi.Encoder) error {
3620 if err := self.Oxm.Serialize(encoder); err != nil {
3621 return err
3622 }
3623
3624 encoder.Write(self.Value.To4())
3625 encoder.Write(self.ValueMask.To4())
3626
3627 return nil
3628}
3629
3630func DecodeNxmIpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpDstMasked, error) {
3631 _nxmipdstmasked := &NxmIpDstMasked{Oxm: parent}
3632 if decoder.Length() < 8 {
3633 return nil, fmt.Errorf("NxmIpDstMasked packet too short: %d < 8", decoder.Length())
3634 }
3635 _nxmipdstmasked.Value = net.IP(decoder.Read(4))
3636 _nxmipdstmasked.ValueMask = net.IP(decoder.Read(4))
3637 return _nxmipdstmasked, nil
3638}
3639
3640func NewNxmIpDstMasked() *NxmIpDstMasked {
3641 obj := &NxmIpDstMasked{
3642 Oxm: NewOxm(4360),
3643 }
3644 return obj
3645}
3646func (self *NxmIpDstMasked) GetOXMName() string {
3647 return "ip_dst_masked"
3648}
3649
3650func (self *NxmIpDstMasked) GetOXMValue() interface{} {
3651 return self.Value
3652}
3653
3654func (self *NxmIpDstMasked) GetOXMValueMask() interface{} {
3655 return self.ValueMask
3656}
3657
3658func (self *NxmIpDstMasked) MarshalJSON() ([]byte, error) {
3659 value, err := jsonValue(self.GetOXMValue())
3660 if err != nil {
3661 return nil, err
3662 }
3663 valueMask, err := jsonValue(self.GetOXMValueMask())
3664 if err != nil {
3665 return nil, err
3666 }
3667 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
3668}
3669
3670type NxmIpFrag struct {
3671 *Oxm
3672 Value []byte
3673}
3674
3675type INxmIpFrag interface {
3676 goloxi.IOxm
3677 GetValue() []byte
3678}
3679
3680func (self *NxmIpFrag) GetValue() []byte {
3681 return self.Value
3682}
3683
3684func (self *NxmIpFrag) SetValue(v []byte) {
3685 self.Value = v
3686}
3687
3688func (self *NxmIpFrag) Serialize(encoder *goloxi.Encoder) error {
3689 if err := self.Oxm.Serialize(encoder); err != nil {
3690 return err
3691 }
3692
3693 encoder.Write(self.Value)
3694
3695 return nil
3696}
3697
3698func DecodeNxmIpFrag(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpFrag, error) {
3699 _nxmipfrag := &NxmIpFrag{Oxm: parent}
3700 _nxmipfrag.Value = decoder.Read(int(_nxmipfrag.TypeLen & 0xFF))
3701 return _nxmipfrag, nil
3702}
3703
3704func NewNxmIpFrag() *NxmIpFrag {
3705 obj := &NxmIpFrag{
3706 Oxm: NewOxm(78849),
3707 }
3708 return obj
3709}
3710func (self *NxmIpFrag) GetOXMName() string {
3711 return "ip_frag"
3712}
3713
3714func (self *NxmIpFrag) GetOXMValue() interface{} {
3715 return self.Value
3716}
3717
3718func (self *NxmIpFrag) MarshalJSON() ([]byte, error) {
3719 value, err := jsonValue(self.GetOXMValue())
3720 if err != nil {
3721 return nil, err
3722 }
3723 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3724}
3725
3726type NxmIpFragMasked struct {
3727 *Oxm
3728 Value []byte
3729 ValueMask []byte
3730}
3731
3732type INxmIpFragMasked interface {
3733 goloxi.IOxm
3734 GetValue() []byte
3735 GetValueMask() []byte
3736}
3737
3738func (self *NxmIpFragMasked) GetValue() []byte {
3739 return self.Value
3740}
3741
3742func (self *NxmIpFragMasked) SetValue(v []byte) {
3743 self.Value = v
3744}
3745
3746func (self *NxmIpFragMasked) GetValueMask() []byte {
3747 return self.ValueMask
3748}
3749
3750func (self *NxmIpFragMasked) SetValueMask(v []byte) {
3751 self.ValueMask = v
3752}
3753
3754func (self *NxmIpFragMasked) Serialize(encoder *goloxi.Encoder) error {
3755 if err := self.Oxm.Serialize(encoder); err != nil {
3756 return err
3757 }
3758
3759 encoder.Write(self.Value)
3760 encoder.Write(self.ValueMask)
3761
3762 return nil
3763}
3764
3765func DecodeNxmIpFragMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpFragMasked, error) {
3766 _nxmipfragmasked := &NxmIpFragMasked{Oxm: parent}
3767 _nxmipfragmasked.Value = decoder.Read(int(_nxmipfragmasked.TypeLen & 0xFF))
3768 _nxmipfragmasked.ValueMask = decoder.Read(int(_nxmipfragmasked.TypeLen & 0xFF))
3769 return _nxmipfragmasked, nil
3770}
3771
3772func NewNxmIpFragMasked() *NxmIpFragMasked {
3773 obj := &NxmIpFragMasked{
3774 Oxm: NewOxm(79106),
3775 }
3776 return obj
3777}
3778func (self *NxmIpFragMasked) GetOXMName() string {
3779 return "ip_frag_masked"
3780}
3781
3782func (self *NxmIpFragMasked) GetOXMValue() interface{} {
3783 return self.Value
3784}
3785
3786func (self *NxmIpFragMasked) GetOXMValueMask() interface{} {
3787 return self.ValueMask
3788}
3789
3790func (self *NxmIpFragMasked) MarshalJSON() ([]byte, error) {
3791 value, err := jsonValue(self.GetOXMValue())
3792 if err != nil {
3793 return nil, err
3794 }
3795 valueMask, err := jsonValue(self.GetOXMValueMask())
3796 if err != nil {
3797 return nil, err
3798 }
3799 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
3800}
3801
3802type NxmIpSrc struct {
3803 *Oxm
3804 Value net.IP
3805}
3806
3807type INxmIpSrc interface {
3808 goloxi.IOxm
3809 GetValue() net.IP
3810}
3811
3812func (self *NxmIpSrc) GetValue() net.IP {
3813 return self.Value
3814}
3815
3816func (self *NxmIpSrc) SetValue(v net.IP) {
3817 self.Value = v
3818}
3819
3820func (self *NxmIpSrc) Serialize(encoder *goloxi.Encoder) error {
3821 if err := self.Oxm.Serialize(encoder); err != nil {
3822 return err
3823 }
3824
3825 encoder.Write(self.Value.To4())
3826
3827 return nil
3828}
3829
3830func DecodeNxmIpSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpSrc, error) {
3831 _nxmipsrc := &NxmIpSrc{Oxm: parent}
3832 if decoder.Length() < 4 {
3833 return nil, fmt.Errorf("NxmIpSrc packet too short: %d < 4", decoder.Length())
3834 }
3835 _nxmipsrc.Value = net.IP(decoder.Read(4))
3836 return _nxmipsrc, nil
3837}
3838
3839func NewNxmIpSrc() *NxmIpSrc {
3840 obj := &NxmIpSrc{
3841 Oxm: NewOxm(3588),
3842 }
3843 return obj
3844}
3845func (self *NxmIpSrc) GetOXMName() string {
3846 return "ip_src"
3847}
3848
3849func (self *NxmIpSrc) GetOXMValue() interface{} {
3850 return self.Value
3851}
3852
3853func (self *NxmIpSrc) MarshalJSON() ([]byte, error) {
3854 value, err := jsonValue(self.GetOXMValue())
3855 if err != nil {
3856 return nil, err
3857 }
3858 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3859}
3860
3861type NxmIpSrcMasked struct {
3862 *Oxm
3863 Value net.IP
3864 ValueMask net.IP
3865}
3866
3867type INxmIpSrcMasked interface {
3868 goloxi.IOxm
3869 GetValue() net.IP
3870 GetValueMask() net.IP
3871}
3872
3873func (self *NxmIpSrcMasked) GetValue() net.IP {
3874 return self.Value
3875}
3876
3877func (self *NxmIpSrcMasked) SetValue(v net.IP) {
3878 self.Value = v
3879}
3880
3881func (self *NxmIpSrcMasked) GetValueMask() net.IP {
3882 return self.ValueMask
3883}
3884
3885func (self *NxmIpSrcMasked) SetValueMask(v net.IP) {
3886 self.ValueMask = v
3887}
3888
3889func (self *NxmIpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
3890 if err := self.Oxm.Serialize(encoder); err != nil {
3891 return err
3892 }
3893
3894 encoder.Write(self.Value.To4())
3895 encoder.Write(self.ValueMask.To4())
3896
3897 return nil
3898}
3899
3900func DecodeNxmIpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpSrcMasked, error) {
3901 _nxmipsrcmasked := &NxmIpSrcMasked{Oxm: parent}
3902 if decoder.Length() < 8 {
3903 return nil, fmt.Errorf("NxmIpSrcMasked packet too short: %d < 8", decoder.Length())
3904 }
3905 _nxmipsrcmasked.Value = net.IP(decoder.Read(4))
3906 _nxmipsrcmasked.ValueMask = net.IP(decoder.Read(4))
3907 return _nxmipsrcmasked, nil
3908}
3909
3910func NewNxmIpSrcMasked() *NxmIpSrcMasked {
3911 obj := &NxmIpSrcMasked{
3912 Oxm: NewOxm(3848),
3913 }
3914 return obj
3915}
3916func (self *NxmIpSrcMasked) GetOXMName() string {
3917 return "ip_src_masked"
3918}
3919
3920func (self *NxmIpSrcMasked) GetOXMValue() interface{} {
3921 return self.Value
3922}
3923
3924func (self *NxmIpSrcMasked) GetOXMValueMask() interface{} {
3925 return self.ValueMask
3926}
3927
3928func (self *NxmIpSrcMasked) MarshalJSON() ([]byte, error) {
3929 value, err := jsonValue(self.GetOXMValue())
3930 if err != nil {
3931 return nil, err
3932 }
3933 valueMask, err := jsonValue(self.GetOXMValueMask())
3934 if err != nil {
3935 return nil, err
3936 }
3937 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
3938}
3939
3940type NxmIpv6Dst struct {
3941 *Oxm
3942 Value net.IP
3943}
3944
3945type INxmIpv6Dst interface {
3946 goloxi.IOxm
3947 GetValue() net.IP
3948}
3949
3950func (self *NxmIpv6Dst) GetValue() net.IP {
3951 return self.Value
3952}
3953
3954func (self *NxmIpv6Dst) SetValue(v net.IP) {
3955 self.Value = v
3956}
3957
3958func (self *NxmIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
3959 if err := self.Oxm.Serialize(encoder); err != nil {
3960 return err
3961 }
3962
3963 encoder.Write(self.Value.To16())
3964
3965 return nil
3966}
3967
3968func DecodeNxmIpv6Dst(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6Dst, error) {
3969 _nxmipv6dst := &NxmIpv6Dst{Oxm: parent}
3970 if decoder.Length() < 16 {
3971 return nil, fmt.Errorf("NxmIpv6Dst packet too short: %d < 16", decoder.Length())
3972 }
3973 _nxmipv6dst.Value = net.IP(decoder.Read(16))
3974 return _nxmipv6dst, nil
3975}
3976
3977func NewNxmIpv6Dst() *NxmIpv6Dst {
3978 obj := &NxmIpv6Dst{
3979 Oxm: NewOxm(75792),
3980 }
3981 return obj
3982}
3983func (self *NxmIpv6Dst) GetOXMName() string {
3984 return "ipv6_dst"
3985}
3986
3987func (self *NxmIpv6Dst) GetOXMValue() interface{} {
3988 return self.Value
3989}
3990
3991func (self *NxmIpv6Dst) MarshalJSON() ([]byte, error) {
3992 value, err := jsonValue(self.GetOXMValue())
3993 if err != nil {
3994 return nil, err
3995 }
3996 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
3997}
3998
3999type NxmIpv6DstMasked struct {
4000 *Oxm
4001 Value net.IP
4002 ValueMask net.IP
4003}
4004
4005type INxmIpv6DstMasked interface {
4006 goloxi.IOxm
4007 GetValue() net.IP
4008 GetValueMask() net.IP
4009}
4010
4011func (self *NxmIpv6DstMasked) GetValue() net.IP {
4012 return self.Value
4013}
4014
4015func (self *NxmIpv6DstMasked) SetValue(v net.IP) {
4016 self.Value = v
4017}
4018
4019func (self *NxmIpv6DstMasked) GetValueMask() net.IP {
4020 return self.ValueMask
4021}
4022
4023func (self *NxmIpv6DstMasked) SetValueMask(v net.IP) {
4024 self.ValueMask = v
4025}
4026
4027func (self *NxmIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
4028 if err := self.Oxm.Serialize(encoder); err != nil {
4029 return err
4030 }
4031
4032 encoder.Write(self.Value.To16())
4033 encoder.Write(self.ValueMask.To16())
4034
4035 return nil
4036}
4037
4038func DecodeNxmIpv6DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6DstMasked, error) {
4039 _nxmipv6dstmasked := &NxmIpv6DstMasked{Oxm: parent}
4040 if decoder.Length() < 32 {
4041 return nil, fmt.Errorf("NxmIpv6DstMasked packet too short: %d < 32", decoder.Length())
4042 }
4043 _nxmipv6dstmasked.Value = net.IP(decoder.Read(16))
4044 _nxmipv6dstmasked.ValueMask = net.IP(decoder.Read(16))
4045 return _nxmipv6dstmasked, nil
4046}
4047
4048func NewNxmIpv6DstMasked() *NxmIpv6DstMasked {
4049 obj := &NxmIpv6DstMasked{
4050 Oxm: NewOxm(76064),
4051 }
4052 return obj
4053}
4054func (self *NxmIpv6DstMasked) GetOXMName() string {
4055 return "ipv6_dst_masked"
4056}
4057
4058func (self *NxmIpv6DstMasked) GetOXMValue() interface{} {
4059 return self.Value
4060}
4061
4062func (self *NxmIpv6DstMasked) GetOXMValueMask() interface{} {
4063 return self.ValueMask
4064}
4065
4066func (self *NxmIpv6DstMasked) MarshalJSON() ([]byte, error) {
4067 value, err := jsonValue(self.GetOXMValue())
4068 if err != nil {
4069 return nil, err
4070 }
4071 valueMask, err := jsonValue(self.GetOXMValueMask())
4072 if err != nil {
4073 return nil, err
4074 }
4075 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
4076}
4077
4078type NxmIpv6Label struct {
4079 *Oxm
4080 Value uint32
4081}
4082
4083type INxmIpv6Label interface {
4084 goloxi.IOxm
4085 GetValue() uint32
4086}
4087
4088func (self *NxmIpv6Label) GetValue() uint32 {
4089 return self.Value
4090}
4091
4092func (self *NxmIpv6Label) SetValue(v uint32) {
4093 self.Value = v
4094}
4095
4096func (self *NxmIpv6Label) Serialize(encoder *goloxi.Encoder) error {
4097 if err := self.Oxm.Serialize(encoder); err != nil {
4098 return err
4099 }
4100
4101 encoder.PutUint32(uint32(self.Value))
4102
4103 return nil
4104}
4105
4106func DecodeNxmIpv6Label(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6Label, error) {
4107 _nxmipv6label := &NxmIpv6Label{Oxm: parent}
4108 if decoder.Length() < 4 {
4109 return nil, fmt.Errorf("NxmIpv6Label packet too short: %d < 4", decoder.Length())
4110 }
4111 _nxmipv6label.Value = uint32(decoder.ReadUint32())
4112 return _nxmipv6label, nil
4113}
4114
4115func NewNxmIpv6Label() *NxmIpv6Label {
4116 obj := &NxmIpv6Label{
4117 Oxm: NewOxm(79364),
4118 }
4119 return obj
4120}
4121func (self *NxmIpv6Label) GetOXMName() string {
4122 return "ipv6_label"
4123}
4124
4125func (self *NxmIpv6Label) GetOXMValue() interface{} {
4126 return self.Value
4127}
4128
4129func (self *NxmIpv6Label) MarshalJSON() ([]byte, error) {
4130 value, err := jsonValue(self.GetOXMValue())
4131 if err != nil {
4132 return nil, err
4133 }
4134 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
4135}
4136
4137type NxmIpv6LabelMasked struct {
4138 *Oxm
4139 Value uint32
4140 ValueMask uint32
4141}
4142
4143type INxmIpv6LabelMasked interface {
4144 goloxi.IOxm
4145 GetValue() uint32
4146 GetValueMask() uint32
4147}
4148
4149func (self *NxmIpv6LabelMasked) GetValue() uint32 {
4150 return self.Value
4151}
4152
4153func (self *NxmIpv6LabelMasked) SetValue(v uint32) {
4154 self.Value = v
4155}
4156
4157func (self *NxmIpv6LabelMasked) GetValueMask() uint32 {
4158 return self.ValueMask
4159}
4160
4161func (self *NxmIpv6LabelMasked) SetValueMask(v uint32) {
4162 self.ValueMask = v
4163}
4164
4165func (self *NxmIpv6LabelMasked) Serialize(encoder *goloxi.Encoder) error {
4166 if err := self.Oxm.Serialize(encoder); err != nil {
4167 return err
4168 }
4169
4170 encoder.PutUint32(uint32(self.Value))
4171 encoder.PutUint32(uint32(self.ValueMask))
4172
4173 return nil
4174}
4175
4176func DecodeNxmIpv6LabelMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6LabelMasked, error) {
4177 _nxmipv6labelmasked := &NxmIpv6LabelMasked{Oxm: parent}
4178 if decoder.Length() < 8 {
4179 return nil, fmt.Errorf("NxmIpv6LabelMasked packet too short: %d < 8", decoder.Length())
4180 }
4181 _nxmipv6labelmasked.Value = uint32(decoder.ReadUint32())
4182 _nxmipv6labelmasked.ValueMask = uint32(decoder.ReadUint32())
4183 return _nxmipv6labelmasked, nil
4184}
4185
4186func NewNxmIpv6LabelMasked() *NxmIpv6LabelMasked {
4187 obj := &NxmIpv6LabelMasked{
4188 Oxm: NewOxm(79624),
4189 }
4190 return obj
4191}
4192func (self *NxmIpv6LabelMasked) GetOXMName() string {
4193 return "ipv6_label_masked"
4194}
4195
4196func (self *NxmIpv6LabelMasked) GetOXMValue() interface{} {
4197 return self.Value
4198}
4199
4200func (self *NxmIpv6LabelMasked) GetOXMValueMask() interface{} {
4201 return self.ValueMask
4202}
4203
4204func (self *NxmIpv6LabelMasked) MarshalJSON() ([]byte, error) {
4205 value, err := jsonValue(self.GetOXMValue())
4206 if err != nil {
4207 return nil, err
4208 }
4209 valueMask, err := jsonValue(self.GetOXMValueMask())
4210 if err != nil {
4211 return nil, err
4212 }
4213 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
4214}
4215
4216type NxmIpv6Src struct {
4217 *Oxm
4218 Value net.IP
4219}
4220
4221type INxmIpv6Src interface {
4222 goloxi.IOxm
4223 GetValue() net.IP
4224}
4225
4226func (self *NxmIpv6Src) GetValue() net.IP {
4227 return self.Value
4228}
4229
4230func (self *NxmIpv6Src) SetValue(v net.IP) {
4231 self.Value = v
4232}
4233
4234func (self *NxmIpv6Src) Serialize(encoder *goloxi.Encoder) error {
4235 if err := self.Oxm.Serialize(encoder); err != nil {
4236 return err
4237 }
4238
4239 encoder.Write(self.Value.To16())
4240
4241 return nil
4242}
4243
4244func DecodeNxmIpv6Src(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6Src, error) {
4245 _nxmipv6src := &NxmIpv6Src{Oxm: parent}
4246 if decoder.Length() < 16 {
4247 return nil, fmt.Errorf("NxmIpv6Src packet too short: %d < 16", decoder.Length())
4248 }
4249 _nxmipv6src.Value = net.IP(decoder.Read(16))
4250 return _nxmipv6src, nil
4251}
4252
4253func NewNxmIpv6Src() *NxmIpv6Src {
4254 obj := &NxmIpv6Src{
4255 Oxm: NewOxm(75280),
4256 }
4257 return obj
4258}
4259func (self *NxmIpv6Src) GetOXMName() string {
4260 return "ipv6_src"
4261}
4262
4263func (self *NxmIpv6Src) GetOXMValue() interface{} {
4264 return self.Value
4265}
4266
4267func (self *NxmIpv6Src) MarshalJSON() ([]byte, error) {
4268 value, err := jsonValue(self.GetOXMValue())
4269 if err != nil {
4270 return nil, err
4271 }
4272 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
4273}
4274
4275type NxmIpv6SrcMasked struct {
4276 *Oxm
4277 Value net.IP
4278 ValueMask net.IP
4279}
4280
4281type INxmIpv6SrcMasked interface {
4282 goloxi.IOxm
4283 GetValue() net.IP
4284 GetValueMask() net.IP
4285}
4286
4287func (self *NxmIpv6SrcMasked) GetValue() net.IP {
4288 return self.Value
4289}
4290
4291func (self *NxmIpv6SrcMasked) SetValue(v net.IP) {
4292 self.Value = v
4293}
4294
4295func (self *NxmIpv6SrcMasked) GetValueMask() net.IP {
4296 return self.ValueMask
4297}
4298
4299func (self *NxmIpv6SrcMasked) SetValueMask(v net.IP) {
4300 self.ValueMask = v
4301}
4302
4303func (self *NxmIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
4304 if err := self.Oxm.Serialize(encoder); err != nil {
4305 return err
4306 }
4307
4308 encoder.Write(self.Value.To16())
4309 encoder.Write(self.ValueMask.To16())
4310
4311 return nil
4312}
4313
4314func DecodeNxmIpv6SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmIpv6SrcMasked, error) {
4315 _nxmipv6srcmasked := &NxmIpv6SrcMasked{Oxm: parent}
4316 if decoder.Length() < 32 {
4317 return nil, fmt.Errorf("NxmIpv6SrcMasked packet too short: %d < 32", decoder.Length())
4318 }
4319 _nxmipv6srcmasked.Value = net.IP(decoder.Read(16))
4320 _nxmipv6srcmasked.ValueMask = net.IP(decoder.Read(16))
4321 return _nxmipv6srcmasked, nil
4322}
4323
4324func NewNxmIpv6SrcMasked() *NxmIpv6SrcMasked {
4325 obj := &NxmIpv6SrcMasked{
4326 Oxm: NewOxm(75552),
4327 }
4328 return obj
4329}
4330func (self *NxmIpv6SrcMasked) GetOXMName() string {
4331 return "ipv6_src_masked"
4332}
4333
4334func (self *NxmIpv6SrcMasked) GetOXMValue() interface{} {
4335 return self.Value
4336}
4337
4338func (self *NxmIpv6SrcMasked) GetOXMValueMask() interface{} {
4339 return self.ValueMask
4340}
4341
4342func (self *NxmIpv6SrcMasked) MarshalJSON() ([]byte, error) {
4343 value, err := jsonValue(self.GetOXMValue())
4344 if err != nil {
4345 return nil, err
4346 }
4347 valueMask, err := jsonValue(self.GetOXMValueMask())
4348 if err != nil {
4349 return nil, err
4350 }
4351 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
4352}
4353
4354type NxmMplsTtl struct {
4355 *Oxm
4356 Value uint8
4357}
4358
4359type INxmMplsTtl interface {
4360 goloxi.IOxm
4361 GetValue() uint8
4362}
4363
4364func (self *NxmMplsTtl) GetValue() uint8 {
4365 return self.Value
4366}
4367
4368func (self *NxmMplsTtl) SetValue(v uint8) {
4369 self.Value = v
4370}
4371
4372func (self *NxmMplsTtl) Serialize(encoder *goloxi.Encoder) error {
4373 if err := self.Oxm.Serialize(encoder); err != nil {
4374 return err
4375 }
4376
4377 encoder.PutUint8(uint8(self.Value))
4378
4379 return nil
4380}
4381
4382func DecodeNxmMplsTtl(parent *Oxm, decoder *goloxi.Decoder) (*NxmMplsTtl, error) {
4383 _nxmmplsttl := &NxmMplsTtl{Oxm: parent}
4384 if decoder.Length() < 1 {
4385 return nil, fmt.Errorf("NxmMplsTtl packet too short: %d < 1", decoder.Length())
4386 }
4387 _nxmmplsttl.Value = uint8(decoder.ReadByte())
4388 return _nxmmplsttl, nil
4389}
4390
4391func NewNxmMplsTtl() *NxmMplsTtl {
4392 obj := &NxmMplsTtl{
4393 Oxm: NewOxm(80897),
4394 }
4395 return obj
4396}
4397func (self *NxmMplsTtl) GetOXMName() string {
4398 return "mpls_ttl"
4399}
4400
4401func (self *NxmMplsTtl) GetOXMValue() interface{} {
4402 return self.Value
4403}
4404
4405func (self *NxmMplsTtl) MarshalJSON() ([]byte, error) {
4406 value, err := jsonValue(self.GetOXMValue())
4407 if err != nil {
4408 return nil, err
4409 }
4410 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
4411}
4412
4413type NxmNdSll struct {
4414 *Oxm
4415 Value net.HardwareAddr
4416}
4417
4418type INxmNdSll interface {
4419 goloxi.IOxm
4420 GetValue() net.HardwareAddr
4421}
4422
4423func (self *NxmNdSll) GetValue() net.HardwareAddr {
4424 return self.Value
4425}
4426
4427func (self *NxmNdSll) SetValue(v net.HardwareAddr) {
4428 self.Value = v
4429}
4430
4431func (self *NxmNdSll) Serialize(encoder *goloxi.Encoder) error {
4432 if err := self.Oxm.Serialize(encoder); err != nil {
4433 return err
4434 }
4435
4436 encoder.Write(self.Value)
4437
4438 return nil
4439}
4440
4441func DecodeNxmNdSll(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdSll, error) {
4442 _nxmndsll := &NxmNdSll{Oxm: parent}
4443 if decoder.Length() < 6 {
4444 return nil, fmt.Errorf("NxmNdSll packet too short: %d < 6", decoder.Length())
4445 }
4446 _nxmndsll.Value = net.HardwareAddr(decoder.Read(6))
4447 return _nxmndsll, nil
4448}
4449
4450func NewNxmNdSll() *NxmNdSll {
4451 obj := &NxmNdSll{
4452 Oxm: NewOxm(77830),
4453 }
4454 return obj
4455}
4456func (self *NxmNdSll) GetOXMName() string {
4457 return "nd_sll"
4458}
4459
4460func (self *NxmNdSll) GetOXMValue() interface{} {
4461 return self.Value
4462}
4463
4464func (self *NxmNdSll) MarshalJSON() ([]byte, error) {
4465 value, err := jsonValue(self.GetOXMValue())
4466 if err != nil {
4467 return nil, err
4468 }
4469 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
4470}
4471
4472type NxmNdSllMasked struct {
4473 *Oxm
4474 Value net.HardwareAddr
4475 ValueMask net.HardwareAddr
4476}
4477
4478type INxmNdSllMasked interface {
4479 goloxi.IOxm
4480 GetValue() net.HardwareAddr
4481 GetValueMask() net.HardwareAddr
4482}
4483
4484func (self *NxmNdSllMasked) GetValue() net.HardwareAddr {
4485 return self.Value
4486}
4487
4488func (self *NxmNdSllMasked) SetValue(v net.HardwareAddr) {
4489 self.Value = v
4490}
4491
4492func (self *NxmNdSllMasked) GetValueMask() net.HardwareAddr {
4493 return self.ValueMask
4494}
4495
4496func (self *NxmNdSllMasked) SetValueMask(v net.HardwareAddr) {
4497 self.ValueMask = v
4498}
4499
4500func (self *NxmNdSllMasked) Serialize(encoder *goloxi.Encoder) error {
4501 if err := self.Oxm.Serialize(encoder); err != nil {
4502 return err
4503 }
4504
4505 encoder.Write(self.Value)
4506 encoder.Write(self.ValueMask)
4507
4508 return nil
4509}
4510
4511func DecodeNxmNdSllMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdSllMasked, error) {
4512 _nxmndsllmasked := &NxmNdSllMasked{Oxm: parent}
4513 if decoder.Length() < 12 {
4514 return nil, fmt.Errorf("NxmNdSllMasked packet too short: %d < 12", decoder.Length())
4515 }
4516 _nxmndsllmasked.Value = net.HardwareAddr(decoder.Read(6))
4517 _nxmndsllmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
4518 return _nxmndsllmasked, nil
4519}
4520
4521func NewNxmNdSllMasked() *NxmNdSllMasked {
4522 obj := &NxmNdSllMasked{
4523 Oxm: NewOxm(78091),
4524 }
4525 return obj
4526}
4527func (self *NxmNdSllMasked) GetOXMName() string {
4528 return "nd_sll_masked"
4529}
4530
4531func (self *NxmNdSllMasked) GetOXMValue() interface{} {
4532 return self.Value
4533}
4534
4535func (self *NxmNdSllMasked) GetOXMValueMask() interface{} {
4536 return self.ValueMask
4537}
4538
4539func (self *NxmNdSllMasked) MarshalJSON() ([]byte, error) {
4540 value, err := jsonValue(self.GetOXMValue())
4541 if err != nil {
4542 return nil, err
4543 }
4544 valueMask, err := jsonValue(self.GetOXMValueMask())
4545 if err != nil {
4546 return nil, err
4547 }
4548 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
4549}
4550
4551type NxmNdTarget struct {
4552 *Oxm
4553 Value net.IP
4554}
4555
4556type INxmNdTarget interface {
4557 goloxi.IOxm
4558 GetValue() net.IP
4559}
4560
4561func (self *NxmNdTarget) GetValue() net.IP {
4562 return self.Value
4563}
4564
4565func (self *NxmNdTarget) SetValue(v net.IP) {
4566 self.Value = v
4567}
4568
4569func (self *NxmNdTarget) Serialize(encoder *goloxi.Encoder) error {
4570 if err := self.Oxm.Serialize(encoder); err != nil {
4571 return err
4572 }
4573
4574 encoder.Write(self.Value.To16())
4575
4576 return nil
4577}
4578
4579func DecodeNxmNdTarget(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdTarget, error) {
4580 _nxmndtarget := &NxmNdTarget{Oxm: parent}
4581 if decoder.Length() < 16 {
4582 return nil, fmt.Errorf("NxmNdTarget packet too short: %d < 16", decoder.Length())
4583 }
4584 _nxmndtarget.Value = net.IP(decoder.Read(16))
4585 return _nxmndtarget, nil
4586}
4587
4588func NewNxmNdTarget() *NxmNdTarget {
4589 obj := &NxmNdTarget{
4590 Oxm: NewOxm(77328),
4591 }
4592 return obj
4593}
4594func (self *NxmNdTarget) GetOXMName() string {
4595 return "nd_target"
4596}
4597
4598func (self *NxmNdTarget) GetOXMValue() interface{} {
4599 return self.Value
4600}
4601
4602func (self *NxmNdTarget) MarshalJSON() ([]byte, error) {
4603 value, err := jsonValue(self.GetOXMValue())
4604 if err != nil {
4605 return nil, err
4606 }
4607 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
4608}
4609
4610type NxmNdTargetMasked struct {
4611 *Oxm
4612 Value net.IP
4613 ValueMask net.IP
4614}
4615
4616type INxmNdTargetMasked interface {
4617 goloxi.IOxm
4618 GetValue() net.IP
4619 GetValueMask() net.IP
4620}
4621
4622func (self *NxmNdTargetMasked) GetValue() net.IP {
4623 return self.Value
4624}
4625
4626func (self *NxmNdTargetMasked) SetValue(v net.IP) {
4627 self.Value = v
4628}
4629
4630func (self *NxmNdTargetMasked) GetValueMask() net.IP {
4631 return self.ValueMask
4632}
4633
4634func (self *NxmNdTargetMasked) SetValueMask(v net.IP) {
4635 self.ValueMask = v
4636}
4637
4638func (self *NxmNdTargetMasked) Serialize(encoder *goloxi.Encoder) error {
4639 if err := self.Oxm.Serialize(encoder); err != nil {
4640 return err
4641 }
4642
4643 encoder.Write(self.Value.To16())
4644 encoder.Write(self.ValueMask.To16())
4645
4646 return nil
4647}
4648
4649func DecodeNxmNdTargetMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdTargetMasked, error) {
4650 _nxmndtargetmasked := &NxmNdTargetMasked{Oxm: parent}
4651 if decoder.Length() < 32 {
4652 return nil, fmt.Errorf("NxmNdTargetMasked packet too short: %d < 32", decoder.Length())
4653 }
4654 _nxmndtargetmasked.Value = net.IP(decoder.Read(16))
4655 _nxmndtargetmasked.ValueMask = net.IP(decoder.Read(16))
4656 return _nxmndtargetmasked, nil
4657}
4658
4659func NewNxmNdTargetMasked() *NxmNdTargetMasked {
4660 obj := &NxmNdTargetMasked{
4661 Oxm: NewOxm(77600),
4662 }
4663 return obj
4664}
4665func (self *NxmNdTargetMasked) GetOXMName() string {
4666 return "nd_target_masked"
4667}
4668
4669func (self *NxmNdTargetMasked) GetOXMValue() interface{} {
4670 return self.Value
4671}
4672
4673func (self *NxmNdTargetMasked) GetOXMValueMask() interface{} {
4674 return self.ValueMask
4675}
4676
4677func (self *NxmNdTargetMasked) MarshalJSON() ([]byte, error) {
4678 value, err := jsonValue(self.GetOXMValue())
4679 if err != nil {
4680 return nil, err
4681 }
4682 valueMask, err := jsonValue(self.GetOXMValueMask())
4683 if err != nil {
4684 return nil, err
4685 }
4686 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
4687}
4688
4689type NxmNdTll struct {
4690 *Oxm
4691 Value net.HardwareAddr
4692}
4693
4694type INxmNdTll interface {
4695 goloxi.IOxm
4696 GetValue() net.HardwareAddr
4697}
4698
4699func (self *NxmNdTll) GetValue() net.HardwareAddr {
4700 return self.Value
4701}
4702
4703func (self *NxmNdTll) SetValue(v net.HardwareAddr) {
4704 self.Value = v
4705}
4706
4707func (self *NxmNdTll) Serialize(encoder *goloxi.Encoder) error {
4708 if err := self.Oxm.Serialize(encoder); err != nil {
4709 return err
4710 }
4711
4712 encoder.Write(self.Value)
4713
4714 return nil
4715}
4716
4717func DecodeNxmNdTll(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdTll, error) {
4718 _nxmndtll := &NxmNdTll{Oxm: parent}
4719 if decoder.Length() < 6 {
4720 return nil, fmt.Errorf("NxmNdTll packet too short: %d < 6", decoder.Length())
4721 }
4722 _nxmndtll.Value = net.HardwareAddr(decoder.Read(6))
4723 return _nxmndtll, nil
4724}
4725
4726func NewNxmNdTll() *NxmNdTll {
4727 obj := &NxmNdTll{
4728 Oxm: NewOxm(78342),
4729 }
4730 return obj
4731}
4732func (self *NxmNdTll) GetOXMName() string {
4733 return "nd_tll"
4734}
4735
4736func (self *NxmNdTll) GetOXMValue() interface{} {
4737 return self.Value
4738}
4739
4740func (self *NxmNdTll) MarshalJSON() ([]byte, error) {
4741 value, err := jsonValue(self.GetOXMValue())
4742 if err != nil {
4743 return nil, err
4744 }
4745 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
4746}
4747
4748type NxmNdTllMasked struct {
4749 *Oxm
4750 Value net.HardwareAddr
4751 ValueMask net.HardwareAddr
4752}
4753
4754type INxmNdTllMasked interface {
4755 goloxi.IOxm
4756 GetValue() net.HardwareAddr
4757 GetValueMask() net.HardwareAddr
4758}
4759
4760func (self *NxmNdTllMasked) GetValue() net.HardwareAddr {
4761 return self.Value
4762}
4763
4764func (self *NxmNdTllMasked) SetValue(v net.HardwareAddr) {
4765 self.Value = v
4766}
4767
4768func (self *NxmNdTllMasked) GetValueMask() net.HardwareAddr {
4769 return self.ValueMask
4770}
4771
4772func (self *NxmNdTllMasked) SetValueMask(v net.HardwareAddr) {
4773 self.ValueMask = v
4774}
4775
4776func (self *NxmNdTllMasked) Serialize(encoder *goloxi.Encoder) error {
4777 if err := self.Oxm.Serialize(encoder); err != nil {
4778 return err
4779 }
4780
4781 encoder.Write(self.Value)
4782 encoder.Write(self.ValueMask)
4783
4784 return nil
4785}
4786
4787func DecodeNxmNdTllMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmNdTllMasked, error) {
4788 _nxmndtllmasked := &NxmNdTllMasked{Oxm: parent}
4789 if decoder.Length() < 12 {
4790 return nil, fmt.Errorf("NxmNdTllMasked packet too short: %d < 12", decoder.Length())
4791 }
4792 _nxmndtllmasked.Value = net.HardwareAddr(decoder.Read(6))
4793 _nxmndtllmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
4794 return _nxmndtllmasked, nil
4795}
4796
4797func NewNxmNdTllMasked() *NxmNdTllMasked {
4798 obj := &NxmNdTllMasked{
4799 Oxm: NewOxm(78603),
4800 }
4801 return obj
4802}
4803func (self *NxmNdTllMasked) GetOXMName() string {
4804 return "nd_tll_masked"
4805}
4806
4807func (self *NxmNdTllMasked) GetOXMValue() interface{} {
4808 return self.Value
4809}
4810
4811func (self *NxmNdTllMasked) GetOXMValueMask() interface{} {
4812 return self.ValueMask
4813}
4814
4815func (self *NxmNdTllMasked) MarshalJSON() ([]byte, error) {
4816 value, err := jsonValue(self.GetOXMValue())
4817 if err != nil {
4818 return nil, err
4819 }
4820 valueMask, err := jsonValue(self.GetOXMValueMask())
4821 if err != nil {
4822 return nil, err
4823 }
4824 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
4825}
4826
4827type NxmNwEcn struct {
4828 *Oxm
4829 Value uint8
4830}
4831
4832type INxmNwEcn interface {
4833 goloxi.IOxm
4834 GetValue() uint8
4835}
4836
4837func (self *NxmNwEcn) GetValue() uint8 {
4838 return self.Value
4839}
4840
4841func (self *NxmNwEcn) SetValue(v uint8) {
4842 self.Value = v
4843}
4844
4845func (self *NxmNwEcn) Serialize(encoder *goloxi.Encoder) error {
4846 if err := self.Oxm.Serialize(encoder); err != nil {
4847 return err
4848 }
4849
4850 encoder.PutUint8(uint8(self.Value))
4851
4852 return nil
4853}
4854
4855func DecodeNxmNwEcn(parent *Oxm, decoder *goloxi.Decoder) (*NxmNwEcn, error) {
4856 _nxmnwecn := &NxmNwEcn{Oxm: parent}
4857 if decoder.Length() < 1 {
4858 return nil, fmt.Errorf("NxmNwEcn packet too short: %d < 1", decoder.Length())
4859 }
4860 _nxmnwecn.Value = uint8(decoder.ReadByte())
4861 return _nxmnwecn, nil
4862}
4863
4864func NewNxmNwEcn() *NxmNwEcn {
4865 obj := &NxmNwEcn{
4866 Oxm: NewOxm(79873),
4867 }
4868 return obj
4869}
4870func (self *NxmNwEcn) GetOXMName() string {
4871 return "nw_ecn"
4872}
4873
4874func (self *NxmNwEcn) GetOXMValue() interface{} {
4875 return self.Value
4876}
4877
4878func (self *NxmNwEcn) MarshalJSON() ([]byte, error) {
4879 value, err := jsonValue(self.GetOXMValue())
4880 if err != nil {
4881 return nil, err
4882 }
4883 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
4884}
4885
4886type NxmNwProto struct {
4887 *Oxm
4888 Value uint8
4889}
4890
4891type INxmNwProto interface {
4892 goloxi.IOxm
4893 GetValue() uint8
4894}
4895
4896func (self *NxmNwProto) GetValue() uint8 {
4897 return self.Value
4898}
4899
4900func (self *NxmNwProto) SetValue(v uint8) {
4901 self.Value = v
4902}
4903
4904func (self *NxmNwProto) Serialize(encoder *goloxi.Encoder) error {
4905 if err := self.Oxm.Serialize(encoder); err != nil {
4906 return err
4907 }
4908
4909 encoder.PutUint8(uint8(self.Value))
4910
4911 return nil
4912}
4913
4914func DecodeNxmNwProto(parent *Oxm, decoder *goloxi.Decoder) (*NxmNwProto, error) {
4915 _nxmnwproto := &NxmNwProto{Oxm: parent}
4916 if decoder.Length() < 1 {
4917 return nil, fmt.Errorf("NxmNwProto packet too short: %d < 1", decoder.Length())
4918 }
4919 _nxmnwproto.Value = uint8(decoder.ReadByte())
4920 return _nxmnwproto, nil
4921}
4922
4923func NewNxmNwProto() *NxmNwProto {
4924 obj := &NxmNwProto{
4925 Oxm: NewOxm(3073),
4926 }
4927 return obj
4928}
4929func (self *NxmNwProto) GetOXMName() string {
4930 return "nw_proto"
4931}
4932
4933func (self *NxmNwProto) GetOXMValue() interface{} {
4934 return self.Value
4935}
4936
4937func (self *NxmNwProto) MarshalJSON() ([]byte, error) {
4938 value, err := jsonValue(self.GetOXMValue())
4939 if err != nil {
4940 return nil, err
4941 }
4942 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
4943}
4944
4945type NxmNwTos struct {
4946 *Oxm
4947 Value uint8
4948}
4949
4950type INxmNwTos interface {
4951 goloxi.IOxm
4952 GetValue() uint8
4953}
4954
4955func (self *NxmNwTos) GetValue() uint8 {
4956 return self.Value
4957}
4958
4959func (self *NxmNwTos) SetValue(v uint8) {
4960 self.Value = v
4961}
4962
4963func (self *NxmNwTos) Serialize(encoder *goloxi.Encoder) error {
4964 if err := self.Oxm.Serialize(encoder); err != nil {
4965 return err
4966 }
4967
4968 encoder.PutUint8(uint8(self.Value))
4969
4970 return nil
4971}
4972
4973func DecodeNxmNwTos(parent *Oxm, decoder *goloxi.Decoder) (*NxmNwTos, error) {
4974 _nxmnwtos := &NxmNwTos{Oxm: parent}
4975 if decoder.Length() < 1 {
4976 return nil, fmt.Errorf("NxmNwTos packet too short: %d < 1", decoder.Length())
4977 }
4978 _nxmnwtos.Value = uint8(decoder.ReadByte())
4979 return _nxmnwtos, nil
4980}
4981
4982func NewNxmNwTos() *NxmNwTos {
4983 obj := &NxmNwTos{
4984 Oxm: NewOxm(2561),
4985 }
4986 return obj
4987}
4988func (self *NxmNwTos) GetOXMName() string {
4989 return "nw_tos"
4990}
4991
4992func (self *NxmNwTos) GetOXMValue() interface{} {
4993 return self.Value
4994}
4995
4996func (self *NxmNwTos) MarshalJSON() ([]byte, error) {
4997 value, err := jsonValue(self.GetOXMValue())
4998 if err != nil {
4999 return nil, err
5000 }
5001 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5002}
5003
5004type NxmNwTtl struct {
5005 *Oxm
5006 Value uint8
5007}
5008
5009type INxmNwTtl interface {
5010 goloxi.IOxm
5011 GetValue() uint8
5012}
5013
5014func (self *NxmNwTtl) GetValue() uint8 {
5015 return self.Value
5016}
5017
5018func (self *NxmNwTtl) SetValue(v uint8) {
5019 self.Value = v
5020}
5021
5022func (self *NxmNwTtl) Serialize(encoder *goloxi.Encoder) error {
5023 if err := self.Oxm.Serialize(encoder); err != nil {
5024 return err
5025 }
5026
5027 encoder.PutUint8(uint8(self.Value))
5028
5029 return nil
5030}
5031
5032func DecodeNxmNwTtl(parent *Oxm, decoder *goloxi.Decoder) (*NxmNwTtl, error) {
5033 _nxmnwttl := &NxmNwTtl{Oxm: parent}
5034 if decoder.Length() < 1 {
5035 return nil, fmt.Errorf("NxmNwTtl packet too short: %d < 1", decoder.Length())
5036 }
5037 _nxmnwttl.Value = uint8(decoder.ReadByte())
5038 return _nxmnwttl, nil
5039}
5040
5041func NewNxmNwTtl() *NxmNwTtl {
5042 obj := &NxmNwTtl{
5043 Oxm: NewOxm(80385),
5044 }
5045 return obj
5046}
5047func (self *NxmNwTtl) GetOXMName() string {
5048 return "nw_ttl"
5049}
5050
5051func (self *NxmNwTtl) GetOXMValue() interface{} {
5052 return self.Value
5053}
5054
5055func (self *NxmNwTtl) MarshalJSON() ([]byte, error) {
5056 value, err := jsonValue(self.GetOXMValue())
5057 if err != nil {
5058 return nil, err
5059 }
5060 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5061}
5062
5063type NxmPktMark struct {
5064 *Oxm
5065 Value uint32
5066}
5067
5068type INxmPktMark interface {
5069 goloxi.IOxm
5070 GetValue() uint32
5071}
5072
5073func (self *NxmPktMark) GetValue() uint32 {
5074 return self.Value
5075}
5076
5077func (self *NxmPktMark) SetValue(v uint32) {
5078 self.Value = v
5079}
5080
5081func (self *NxmPktMark) Serialize(encoder *goloxi.Encoder) error {
5082 if err := self.Oxm.Serialize(encoder); err != nil {
5083 return err
5084 }
5085
5086 encoder.PutUint32(uint32(self.Value))
5087
5088 return nil
5089}
5090
5091func DecodeNxmPktMark(parent *Oxm, decoder *goloxi.Decoder) (*NxmPktMark, error) {
5092 _nxmpktmark := &NxmPktMark{Oxm: parent}
5093 if decoder.Length() < 4 {
5094 return nil, fmt.Errorf("NxmPktMark packet too short: %d < 4", decoder.Length())
5095 }
5096 _nxmpktmark.Value = uint32(decoder.ReadUint32())
5097 return _nxmpktmark, nil
5098}
5099
5100func NewNxmPktMark() *NxmPktMark {
5101 obj := &NxmPktMark{
5102 Oxm: NewOxm(82436),
5103 }
5104 return obj
5105}
5106func (self *NxmPktMark) GetOXMName() string {
5107 return "pkt_mark"
5108}
5109
5110func (self *NxmPktMark) GetOXMValue() interface{} {
5111 return self.Value
5112}
5113
5114func (self *NxmPktMark) MarshalJSON() ([]byte, error) {
5115 value, err := jsonValue(self.GetOXMValue())
5116 if err != nil {
5117 return nil, err
5118 }
5119 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5120}
5121
5122type NxmPktMarkMasked struct {
5123 *Oxm
5124 Value uint32
5125 ValueMask uint32
5126}
5127
5128type INxmPktMarkMasked interface {
5129 goloxi.IOxm
5130 GetValue() uint32
5131 GetValueMask() uint32
5132}
5133
5134func (self *NxmPktMarkMasked) GetValue() uint32 {
5135 return self.Value
5136}
5137
5138func (self *NxmPktMarkMasked) SetValue(v uint32) {
5139 self.Value = v
5140}
5141
5142func (self *NxmPktMarkMasked) GetValueMask() uint32 {
5143 return self.ValueMask
5144}
5145
5146func (self *NxmPktMarkMasked) SetValueMask(v uint32) {
5147 self.ValueMask = v
5148}
5149
5150func (self *NxmPktMarkMasked) Serialize(encoder *goloxi.Encoder) error {
5151 if err := self.Oxm.Serialize(encoder); err != nil {
5152 return err
5153 }
5154
5155 encoder.PutUint32(uint32(self.Value))
5156 encoder.PutUint32(uint32(self.ValueMask))
5157
5158 return nil
5159}
5160
5161func DecodeNxmPktMarkMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmPktMarkMasked, error) {
5162 _nxmpktmarkmasked := &NxmPktMarkMasked{Oxm: parent}
5163 if decoder.Length() < 8 {
5164 return nil, fmt.Errorf("NxmPktMarkMasked packet too short: %d < 8", decoder.Length())
5165 }
5166 _nxmpktmarkmasked.Value = uint32(decoder.ReadUint32())
5167 _nxmpktmarkmasked.ValueMask = uint32(decoder.ReadUint32())
5168 return _nxmpktmarkmasked, nil
5169}
5170
5171func NewNxmPktMarkMasked() *NxmPktMarkMasked {
5172 obj := &NxmPktMarkMasked{
5173 Oxm: NewOxm(82696),
5174 }
5175 return obj
5176}
5177func (self *NxmPktMarkMasked) GetOXMName() string {
5178 return "pkt_mark_masked"
5179}
5180
5181func (self *NxmPktMarkMasked) GetOXMValue() interface{} {
5182 return self.Value
5183}
5184
5185func (self *NxmPktMarkMasked) GetOXMValueMask() interface{} {
5186 return self.ValueMask
5187}
5188
5189func (self *NxmPktMarkMasked) MarshalJSON() ([]byte, error) {
5190 value, err := jsonValue(self.GetOXMValue())
5191 if err != nil {
5192 return nil, err
5193 }
5194 valueMask, err := jsonValue(self.GetOXMValueMask())
5195 if err != nil {
5196 return nil, err
5197 }
5198 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
5199}
5200
5201type NxmRecircId struct {
5202 *Oxm
5203 Value uint32
5204}
5205
5206type INxmRecircId interface {
5207 goloxi.IOxm
5208 GetValue() uint32
5209}
5210
5211func (self *NxmRecircId) GetValue() uint32 {
5212 return self.Value
5213}
5214
5215func (self *NxmRecircId) SetValue(v uint32) {
5216 self.Value = v
5217}
5218
5219func (self *NxmRecircId) Serialize(encoder *goloxi.Encoder) error {
5220 if err := self.Oxm.Serialize(encoder); err != nil {
5221 return err
5222 }
5223
5224 encoder.PutUint32(uint32(self.Value))
5225
5226 return nil
5227}
5228
5229func DecodeNxmRecircId(parent *Oxm, decoder *goloxi.Decoder) (*NxmRecircId, error) {
5230 _nxmrecircid := &NxmRecircId{Oxm: parent}
5231 if decoder.Length() < 4 {
5232 return nil, fmt.Errorf("NxmRecircId packet too short: %d < 4", decoder.Length())
5233 }
5234 _nxmrecircid.Value = uint32(decoder.ReadUint32())
5235 return _nxmrecircid, nil
5236}
5237
5238func NewNxmRecircId() *NxmRecircId {
5239 obj := &NxmRecircId{
5240 Oxm: NewOxm(83972),
5241 }
5242 return obj
5243}
5244func (self *NxmRecircId) GetOXMName() string {
5245 return "recirc_id"
5246}
5247
5248func (self *NxmRecircId) GetOXMValue() interface{} {
5249 return self.Value
5250}
5251
5252func (self *NxmRecircId) MarshalJSON() ([]byte, error) {
5253 value, err := jsonValue(self.GetOXMValue())
5254 if err != nil {
5255 return nil, err
5256 }
5257 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5258}
5259
5260type NxmReg0 struct {
5261 *Oxm
5262 Value uint32
5263}
5264
5265type INxmReg0 interface {
5266 goloxi.IOxm
5267 GetValue() uint32
5268}
5269
5270func (self *NxmReg0) GetValue() uint32 {
5271 return self.Value
5272}
5273
5274func (self *NxmReg0) SetValue(v uint32) {
5275 self.Value = v
5276}
5277
5278func (self *NxmReg0) Serialize(encoder *goloxi.Encoder) error {
5279 if err := self.Oxm.Serialize(encoder); err != nil {
5280 return err
5281 }
5282
5283 encoder.PutUint32(uint32(self.Value))
5284
5285 return nil
5286}
5287
5288func DecodeNxmReg0(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg0, error) {
5289 _nxmreg0 := &NxmReg0{Oxm: parent}
5290 if decoder.Length() < 4 {
5291 return nil, fmt.Errorf("NxmReg0 packet too short: %d < 4", decoder.Length())
5292 }
5293 _nxmreg0.Value = uint32(decoder.ReadUint32())
5294 return _nxmreg0, nil
5295}
5296
5297func NewNxmReg0() *NxmReg0 {
5298 obj := &NxmReg0{
5299 Oxm: NewOxm(65540),
5300 }
5301 return obj
5302}
5303func (self *NxmReg0) GetOXMName() string {
5304 return "reg0"
5305}
5306
5307func (self *NxmReg0) GetOXMValue() interface{} {
5308 return self.Value
5309}
5310
5311func (self *NxmReg0) MarshalJSON() ([]byte, error) {
5312 value, err := jsonValue(self.GetOXMValue())
5313 if err != nil {
5314 return nil, err
5315 }
5316 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5317}
5318
5319type NxmReg0Masked struct {
5320 *Oxm
5321 Value uint32
5322 ValueMask uint32
5323}
5324
5325type INxmReg0Masked interface {
5326 goloxi.IOxm
5327 GetValue() uint32
5328 GetValueMask() uint32
5329}
5330
5331func (self *NxmReg0Masked) GetValue() uint32 {
5332 return self.Value
5333}
5334
5335func (self *NxmReg0Masked) SetValue(v uint32) {
5336 self.Value = v
5337}
5338
5339func (self *NxmReg0Masked) GetValueMask() uint32 {
5340 return self.ValueMask
5341}
5342
5343func (self *NxmReg0Masked) SetValueMask(v uint32) {
5344 self.ValueMask = v
5345}
5346
5347func (self *NxmReg0Masked) Serialize(encoder *goloxi.Encoder) error {
5348 if err := self.Oxm.Serialize(encoder); err != nil {
5349 return err
5350 }
5351
5352 encoder.PutUint32(uint32(self.Value))
5353 encoder.PutUint32(uint32(self.ValueMask))
5354
5355 return nil
5356}
5357
5358func DecodeNxmReg0Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg0Masked, error) {
5359 _nxmreg0masked := &NxmReg0Masked{Oxm: parent}
5360 if decoder.Length() < 8 {
5361 return nil, fmt.Errorf("NxmReg0Masked packet too short: %d < 8", decoder.Length())
5362 }
5363 _nxmreg0masked.Value = uint32(decoder.ReadUint32())
5364 _nxmreg0masked.ValueMask = uint32(decoder.ReadUint32())
5365 return _nxmreg0masked, nil
5366}
5367
5368func NewNxmReg0Masked() *NxmReg0Masked {
5369 obj := &NxmReg0Masked{
5370 Oxm: NewOxm(65800),
5371 }
5372 return obj
5373}
5374func (self *NxmReg0Masked) GetOXMName() string {
5375 return "reg0_masked"
5376}
5377
5378func (self *NxmReg0Masked) GetOXMValue() interface{} {
5379 return self.Value
5380}
5381
5382func (self *NxmReg0Masked) GetOXMValueMask() interface{} {
5383 return self.ValueMask
5384}
5385
5386func (self *NxmReg0Masked) MarshalJSON() ([]byte, error) {
5387 value, err := jsonValue(self.GetOXMValue())
5388 if err != nil {
5389 return nil, err
5390 }
5391 valueMask, err := jsonValue(self.GetOXMValueMask())
5392 if err != nil {
5393 return nil, err
5394 }
5395 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
5396}
5397
5398type NxmReg1 struct {
5399 *Oxm
5400 Value uint32
5401}
5402
5403type INxmReg1 interface {
5404 goloxi.IOxm
5405 GetValue() uint32
5406}
5407
5408func (self *NxmReg1) GetValue() uint32 {
5409 return self.Value
5410}
5411
5412func (self *NxmReg1) SetValue(v uint32) {
5413 self.Value = v
5414}
5415
5416func (self *NxmReg1) Serialize(encoder *goloxi.Encoder) error {
5417 if err := self.Oxm.Serialize(encoder); err != nil {
5418 return err
5419 }
5420
5421 encoder.PutUint32(uint32(self.Value))
5422
5423 return nil
5424}
5425
5426func DecodeNxmReg1(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg1, error) {
5427 _nxmreg1 := &NxmReg1{Oxm: parent}
5428 if decoder.Length() < 4 {
5429 return nil, fmt.Errorf("NxmReg1 packet too short: %d < 4", decoder.Length())
5430 }
5431 _nxmreg1.Value = uint32(decoder.ReadUint32())
5432 return _nxmreg1, nil
5433}
5434
5435func NewNxmReg1() *NxmReg1 {
5436 obj := &NxmReg1{
5437 Oxm: NewOxm(66052),
5438 }
5439 return obj
5440}
5441func (self *NxmReg1) GetOXMName() string {
5442 return "reg1"
5443}
5444
5445func (self *NxmReg1) GetOXMValue() interface{} {
5446 return self.Value
5447}
5448
5449func (self *NxmReg1) MarshalJSON() ([]byte, error) {
5450 value, err := jsonValue(self.GetOXMValue())
5451 if err != nil {
5452 return nil, err
5453 }
5454 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5455}
5456
5457type NxmReg10 struct {
5458 *Oxm
5459 Value uint32
5460}
5461
5462type INxmReg10 interface {
5463 goloxi.IOxm
5464 GetValue() uint32
5465}
5466
5467func (self *NxmReg10) GetValue() uint32 {
5468 return self.Value
5469}
5470
5471func (self *NxmReg10) SetValue(v uint32) {
5472 self.Value = v
5473}
5474
5475func (self *NxmReg10) Serialize(encoder *goloxi.Encoder) error {
5476 if err := self.Oxm.Serialize(encoder); err != nil {
5477 return err
5478 }
5479
5480 encoder.PutUint32(uint32(self.Value))
5481
5482 return nil
5483}
5484
5485func DecodeNxmReg10(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg10, error) {
5486 _nxmreg10 := &NxmReg10{Oxm: parent}
5487 if decoder.Length() < 4 {
5488 return nil, fmt.Errorf("NxmReg10 packet too short: %d < 4", decoder.Length())
5489 }
5490 _nxmreg10.Value = uint32(decoder.ReadUint32())
5491 return _nxmreg10, nil
5492}
5493
5494func NewNxmReg10() *NxmReg10 {
5495 obj := &NxmReg10{
5496 Oxm: NewOxm(70660),
5497 }
5498 return obj
5499}
5500func (self *NxmReg10) GetOXMName() string {
5501 return "reg10"
5502}
5503
5504func (self *NxmReg10) GetOXMValue() interface{} {
5505 return self.Value
5506}
5507
5508func (self *NxmReg10) MarshalJSON() ([]byte, error) {
5509 value, err := jsonValue(self.GetOXMValue())
5510 if err != nil {
5511 return nil, err
5512 }
5513 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5514}
5515
5516type NxmReg10Masked struct {
5517 *Oxm
5518 Value uint32
5519 ValueMask uint32
5520}
5521
5522type INxmReg10Masked interface {
5523 goloxi.IOxm
5524 GetValue() uint32
5525 GetValueMask() uint32
5526}
5527
5528func (self *NxmReg10Masked) GetValue() uint32 {
5529 return self.Value
5530}
5531
5532func (self *NxmReg10Masked) SetValue(v uint32) {
5533 self.Value = v
5534}
5535
5536func (self *NxmReg10Masked) GetValueMask() uint32 {
5537 return self.ValueMask
5538}
5539
5540func (self *NxmReg10Masked) SetValueMask(v uint32) {
5541 self.ValueMask = v
5542}
5543
5544func (self *NxmReg10Masked) Serialize(encoder *goloxi.Encoder) error {
5545 if err := self.Oxm.Serialize(encoder); err != nil {
5546 return err
5547 }
5548
5549 encoder.PutUint32(uint32(self.Value))
5550 encoder.PutUint32(uint32(self.ValueMask))
5551
5552 return nil
5553}
5554
5555func DecodeNxmReg10Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg10Masked, error) {
5556 _nxmreg10masked := &NxmReg10Masked{Oxm: parent}
5557 if decoder.Length() < 8 {
5558 return nil, fmt.Errorf("NxmReg10Masked packet too short: %d < 8", decoder.Length())
5559 }
5560 _nxmreg10masked.Value = uint32(decoder.ReadUint32())
5561 _nxmreg10masked.ValueMask = uint32(decoder.ReadUint32())
5562 return _nxmreg10masked, nil
5563}
5564
5565func NewNxmReg10Masked() *NxmReg10Masked {
5566 obj := &NxmReg10Masked{
5567 Oxm: NewOxm(70920),
5568 }
5569 return obj
5570}
5571func (self *NxmReg10Masked) GetOXMName() string {
5572 return "reg10_masked"
5573}
5574
5575func (self *NxmReg10Masked) GetOXMValue() interface{} {
5576 return self.Value
5577}
5578
5579func (self *NxmReg10Masked) GetOXMValueMask() interface{} {
5580 return self.ValueMask
5581}
5582
5583func (self *NxmReg10Masked) MarshalJSON() ([]byte, error) {
5584 value, err := jsonValue(self.GetOXMValue())
5585 if err != nil {
5586 return nil, err
5587 }
5588 valueMask, err := jsonValue(self.GetOXMValueMask())
5589 if err != nil {
5590 return nil, err
5591 }
5592 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
5593}
5594
5595type NxmReg11 struct {
5596 *Oxm
5597 Value uint32
5598}
5599
5600type INxmReg11 interface {
5601 goloxi.IOxm
5602 GetValue() uint32
5603}
5604
5605func (self *NxmReg11) GetValue() uint32 {
5606 return self.Value
5607}
5608
5609func (self *NxmReg11) SetValue(v uint32) {
5610 self.Value = v
5611}
5612
5613func (self *NxmReg11) Serialize(encoder *goloxi.Encoder) error {
5614 if err := self.Oxm.Serialize(encoder); err != nil {
5615 return err
5616 }
5617
5618 encoder.PutUint32(uint32(self.Value))
5619
5620 return nil
5621}
5622
5623func DecodeNxmReg11(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg11, error) {
5624 _nxmreg11 := &NxmReg11{Oxm: parent}
5625 if decoder.Length() < 4 {
5626 return nil, fmt.Errorf("NxmReg11 packet too short: %d < 4", decoder.Length())
5627 }
5628 _nxmreg11.Value = uint32(decoder.ReadUint32())
5629 return _nxmreg11, nil
5630}
5631
5632func NewNxmReg11() *NxmReg11 {
5633 obj := &NxmReg11{
5634 Oxm: NewOxm(71172),
5635 }
5636 return obj
5637}
5638func (self *NxmReg11) GetOXMName() string {
5639 return "reg11"
5640}
5641
5642func (self *NxmReg11) GetOXMValue() interface{} {
5643 return self.Value
5644}
5645
5646func (self *NxmReg11) MarshalJSON() ([]byte, error) {
5647 value, err := jsonValue(self.GetOXMValue())
5648 if err != nil {
5649 return nil, err
5650 }
5651 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5652}
5653
5654type NxmReg11Masked struct {
5655 *Oxm
5656 Value uint32
5657 ValueMask uint32
5658}
5659
5660type INxmReg11Masked interface {
5661 goloxi.IOxm
5662 GetValue() uint32
5663 GetValueMask() uint32
5664}
5665
5666func (self *NxmReg11Masked) GetValue() uint32 {
5667 return self.Value
5668}
5669
5670func (self *NxmReg11Masked) SetValue(v uint32) {
5671 self.Value = v
5672}
5673
5674func (self *NxmReg11Masked) GetValueMask() uint32 {
5675 return self.ValueMask
5676}
5677
5678func (self *NxmReg11Masked) SetValueMask(v uint32) {
5679 self.ValueMask = v
5680}
5681
5682func (self *NxmReg11Masked) Serialize(encoder *goloxi.Encoder) error {
5683 if err := self.Oxm.Serialize(encoder); err != nil {
5684 return err
5685 }
5686
5687 encoder.PutUint32(uint32(self.Value))
5688 encoder.PutUint32(uint32(self.ValueMask))
5689
5690 return nil
5691}
5692
5693func DecodeNxmReg11Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg11Masked, error) {
5694 _nxmreg11masked := &NxmReg11Masked{Oxm: parent}
5695 if decoder.Length() < 8 {
5696 return nil, fmt.Errorf("NxmReg11Masked packet too short: %d < 8", decoder.Length())
5697 }
5698 _nxmreg11masked.Value = uint32(decoder.ReadUint32())
5699 _nxmreg11masked.ValueMask = uint32(decoder.ReadUint32())
5700 return _nxmreg11masked, nil
5701}
5702
5703func NewNxmReg11Masked() *NxmReg11Masked {
5704 obj := &NxmReg11Masked{
5705 Oxm: NewOxm(71432),
5706 }
5707 return obj
5708}
5709func (self *NxmReg11Masked) GetOXMName() string {
5710 return "reg11_masked"
5711}
5712
5713func (self *NxmReg11Masked) GetOXMValue() interface{} {
5714 return self.Value
5715}
5716
5717func (self *NxmReg11Masked) GetOXMValueMask() interface{} {
5718 return self.ValueMask
5719}
5720
5721func (self *NxmReg11Masked) MarshalJSON() ([]byte, error) {
5722 value, err := jsonValue(self.GetOXMValue())
5723 if err != nil {
5724 return nil, err
5725 }
5726 valueMask, err := jsonValue(self.GetOXMValueMask())
5727 if err != nil {
5728 return nil, err
5729 }
5730 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
5731}
5732
5733type NxmReg12 struct {
5734 *Oxm
5735 Value uint32
5736}
5737
5738type INxmReg12 interface {
5739 goloxi.IOxm
5740 GetValue() uint32
5741}
5742
5743func (self *NxmReg12) GetValue() uint32 {
5744 return self.Value
5745}
5746
5747func (self *NxmReg12) SetValue(v uint32) {
5748 self.Value = v
5749}
5750
5751func (self *NxmReg12) Serialize(encoder *goloxi.Encoder) error {
5752 if err := self.Oxm.Serialize(encoder); err != nil {
5753 return err
5754 }
5755
5756 encoder.PutUint32(uint32(self.Value))
5757
5758 return nil
5759}
5760
5761func DecodeNxmReg12(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg12, error) {
5762 _nxmreg12 := &NxmReg12{Oxm: parent}
5763 if decoder.Length() < 4 {
5764 return nil, fmt.Errorf("NxmReg12 packet too short: %d < 4", decoder.Length())
5765 }
5766 _nxmreg12.Value = uint32(decoder.ReadUint32())
5767 return _nxmreg12, nil
5768}
5769
5770func NewNxmReg12() *NxmReg12 {
5771 obj := &NxmReg12{
5772 Oxm: NewOxm(71684),
5773 }
5774 return obj
5775}
5776func (self *NxmReg12) GetOXMName() string {
5777 return "reg12"
5778}
5779
5780func (self *NxmReg12) GetOXMValue() interface{} {
5781 return self.Value
5782}
5783
5784func (self *NxmReg12) MarshalJSON() ([]byte, error) {
5785 value, err := jsonValue(self.GetOXMValue())
5786 if err != nil {
5787 return nil, err
5788 }
5789 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5790}
5791
5792type NxmReg12Masked struct {
5793 *Oxm
5794 Value uint32
5795 ValueMask uint32
5796}
5797
5798type INxmReg12Masked interface {
5799 goloxi.IOxm
5800 GetValue() uint32
5801 GetValueMask() uint32
5802}
5803
5804func (self *NxmReg12Masked) GetValue() uint32 {
5805 return self.Value
5806}
5807
5808func (self *NxmReg12Masked) SetValue(v uint32) {
5809 self.Value = v
5810}
5811
5812func (self *NxmReg12Masked) GetValueMask() uint32 {
5813 return self.ValueMask
5814}
5815
5816func (self *NxmReg12Masked) SetValueMask(v uint32) {
5817 self.ValueMask = v
5818}
5819
5820func (self *NxmReg12Masked) Serialize(encoder *goloxi.Encoder) error {
5821 if err := self.Oxm.Serialize(encoder); err != nil {
5822 return err
5823 }
5824
5825 encoder.PutUint32(uint32(self.Value))
5826 encoder.PutUint32(uint32(self.ValueMask))
5827
5828 return nil
5829}
5830
5831func DecodeNxmReg12Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg12Masked, error) {
5832 _nxmreg12masked := &NxmReg12Masked{Oxm: parent}
5833 if decoder.Length() < 8 {
5834 return nil, fmt.Errorf("NxmReg12Masked packet too short: %d < 8", decoder.Length())
5835 }
5836 _nxmreg12masked.Value = uint32(decoder.ReadUint32())
5837 _nxmreg12masked.ValueMask = uint32(decoder.ReadUint32())
5838 return _nxmreg12masked, nil
5839}
5840
5841func NewNxmReg12Masked() *NxmReg12Masked {
5842 obj := &NxmReg12Masked{
5843 Oxm: NewOxm(71944),
5844 }
5845 return obj
5846}
5847func (self *NxmReg12Masked) GetOXMName() string {
5848 return "reg12_masked"
5849}
5850
5851func (self *NxmReg12Masked) GetOXMValue() interface{} {
5852 return self.Value
5853}
5854
5855func (self *NxmReg12Masked) GetOXMValueMask() interface{} {
5856 return self.ValueMask
5857}
5858
5859func (self *NxmReg12Masked) MarshalJSON() ([]byte, error) {
5860 value, err := jsonValue(self.GetOXMValue())
5861 if err != nil {
5862 return nil, err
5863 }
5864 valueMask, err := jsonValue(self.GetOXMValueMask())
5865 if err != nil {
5866 return nil, err
5867 }
5868 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
5869}
5870
5871type NxmReg13 struct {
5872 *Oxm
5873 Value uint32
5874}
5875
5876type INxmReg13 interface {
5877 goloxi.IOxm
5878 GetValue() uint32
5879}
5880
5881func (self *NxmReg13) GetValue() uint32 {
5882 return self.Value
5883}
5884
5885func (self *NxmReg13) SetValue(v uint32) {
5886 self.Value = v
5887}
5888
5889func (self *NxmReg13) Serialize(encoder *goloxi.Encoder) error {
5890 if err := self.Oxm.Serialize(encoder); err != nil {
5891 return err
5892 }
5893
5894 encoder.PutUint32(uint32(self.Value))
5895
5896 return nil
5897}
5898
5899func DecodeNxmReg13(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg13, error) {
5900 _nxmreg13 := &NxmReg13{Oxm: parent}
5901 if decoder.Length() < 4 {
5902 return nil, fmt.Errorf("NxmReg13 packet too short: %d < 4", decoder.Length())
5903 }
5904 _nxmreg13.Value = uint32(decoder.ReadUint32())
5905 return _nxmreg13, nil
5906}
5907
5908func NewNxmReg13() *NxmReg13 {
5909 obj := &NxmReg13{
5910 Oxm: NewOxm(72196),
5911 }
5912 return obj
5913}
5914func (self *NxmReg13) GetOXMName() string {
5915 return "reg13"
5916}
5917
5918func (self *NxmReg13) GetOXMValue() interface{} {
5919 return self.Value
5920}
5921
5922func (self *NxmReg13) MarshalJSON() ([]byte, error) {
5923 value, err := jsonValue(self.GetOXMValue())
5924 if err != nil {
5925 return nil, err
5926 }
5927 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
5928}
5929
5930type NxmReg13Masked struct {
5931 *Oxm
5932 Value uint32
5933 ValueMask uint32
5934}
5935
5936type INxmReg13Masked interface {
5937 goloxi.IOxm
5938 GetValue() uint32
5939 GetValueMask() uint32
5940}
5941
5942func (self *NxmReg13Masked) GetValue() uint32 {
5943 return self.Value
5944}
5945
5946func (self *NxmReg13Masked) SetValue(v uint32) {
5947 self.Value = v
5948}
5949
5950func (self *NxmReg13Masked) GetValueMask() uint32 {
5951 return self.ValueMask
5952}
5953
5954func (self *NxmReg13Masked) SetValueMask(v uint32) {
5955 self.ValueMask = v
5956}
5957
5958func (self *NxmReg13Masked) Serialize(encoder *goloxi.Encoder) error {
5959 if err := self.Oxm.Serialize(encoder); err != nil {
5960 return err
5961 }
5962
5963 encoder.PutUint32(uint32(self.Value))
5964 encoder.PutUint32(uint32(self.ValueMask))
5965
5966 return nil
5967}
5968
5969func DecodeNxmReg13Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg13Masked, error) {
5970 _nxmreg13masked := &NxmReg13Masked{Oxm: parent}
5971 if decoder.Length() < 8 {
5972 return nil, fmt.Errorf("NxmReg13Masked packet too short: %d < 8", decoder.Length())
5973 }
5974 _nxmreg13masked.Value = uint32(decoder.ReadUint32())
5975 _nxmreg13masked.ValueMask = uint32(decoder.ReadUint32())
5976 return _nxmreg13masked, nil
5977}
5978
5979func NewNxmReg13Masked() *NxmReg13Masked {
5980 obj := &NxmReg13Masked{
5981 Oxm: NewOxm(72456),
5982 }
5983 return obj
5984}
5985func (self *NxmReg13Masked) GetOXMName() string {
5986 return "reg13_masked"
5987}
5988
5989func (self *NxmReg13Masked) GetOXMValue() interface{} {
5990 return self.Value
5991}
5992
5993func (self *NxmReg13Masked) GetOXMValueMask() interface{} {
5994 return self.ValueMask
5995}
5996
5997func (self *NxmReg13Masked) MarshalJSON() ([]byte, error) {
5998 value, err := jsonValue(self.GetOXMValue())
5999 if err != nil {
6000 return nil, err
6001 }
6002 valueMask, err := jsonValue(self.GetOXMValueMask())
6003 if err != nil {
6004 return nil, err
6005 }
6006 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
6007}
6008
6009type NxmReg14 struct {
6010 *Oxm
6011 Value uint32
6012}
6013
6014type INxmReg14 interface {
6015 goloxi.IOxm
6016 GetValue() uint32
6017}
6018
6019func (self *NxmReg14) GetValue() uint32 {
6020 return self.Value
6021}
6022
6023func (self *NxmReg14) SetValue(v uint32) {
6024 self.Value = v
6025}
6026
6027func (self *NxmReg14) Serialize(encoder *goloxi.Encoder) error {
6028 if err := self.Oxm.Serialize(encoder); err != nil {
6029 return err
6030 }
6031
6032 encoder.PutUint32(uint32(self.Value))
6033
6034 return nil
6035}
6036
6037func DecodeNxmReg14(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg14, error) {
6038 _nxmreg14 := &NxmReg14{Oxm: parent}
6039 if decoder.Length() < 4 {
6040 return nil, fmt.Errorf("NxmReg14 packet too short: %d < 4", decoder.Length())
6041 }
6042 _nxmreg14.Value = uint32(decoder.ReadUint32())
6043 return _nxmreg14, nil
6044}
6045
6046func NewNxmReg14() *NxmReg14 {
6047 obj := &NxmReg14{
6048 Oxm: NewOxm(72708),
6049 }
6050 return obj
6051}
6052func (self *NxmReg14) GetOXMName() string {
6053 return "reg14"
6054}
6055
6056func (self *NxmReg14) GetOXMValue() interface{} {
6057 return self.Value
6058}
6059
6060func (self *NxmReg14) MarshalJSON() ([]byte, error) {
6061 value, err := jsonValue(self.GetOXMValue())
6062 if err != nil {
6063 return nil, err
6064 }
6065 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
6066}
6067
6068type NxmReg14Masked struct {
6069 *Oxm
6070 Value uint32
6071 ValueMask uint32
6072}
6073
6074type INxmReg14Masked interface {
6075 goloxi.IOxm
6076 GetValue() uint32
6077 GetValueMask() uint32
6078}
6079
6080func (self *NxmReg14Masked) GetValue() uint32 {
6081 return self.Value
6082}
6083
6084func (self *NxmReg14Masked) SetValue(v uint32) {
6085 self.Value = v
6086}
6087
6088func (self *NxmReg14Masked) GetValueMask() uint32 {
6089 return self.ValueMask
6090}
6091
6092func (self *NxmReg14Masked) SetValueMask(v uint32) {
6093 self.ValueMask = v
6094}
6095
6096func (self *NxmReg14Masked) Serialize(encoder *goloxi.Encoder) error {
6097 if err := self.Oxm.Serialize(encoder); err != nil {
6098 return err
6099 }
6100
6101 encoder.PutUint32(uint32(self.Value))
6102 encoder.PutUint32(uint32(self.ValueMask))
6103
6104 return nil
6105}
6106
6107func DecodeNxmReg14Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg14Masked, error) {
6108 _nxmreg14masked := &NxmReg14Masked{Oxm: parent}
6109 if decoder.Length() < 8 {
6110 return nil, fmt.Errorf("NxmReg14Masked packet too short: %d < 8", decoder.Length())
6111 }
6112 _nxmreg14masked.Value = uint32(decoder.ReadUint32())
6113 _nxmreg14masked.ValueMask = uint32(decoder.ReadUint32())
6114 return _nxmreg14masked, nil
6115}
6116
6117func NewNxmReg14Masked() *NxmReg14Masked {
6118 obj := &NxmReg14Masked{
6119 Oxm: NewOxm(72968),
6120 }
6121 return obj
6122}
6123func (self *NxmReg14Masked) GetOXMName() string {
6124 return "reg14_masked"
6125}
6126
6127func (self *NxmReg14Masked) GetOXMValue() interface{} {
6128 return self.Value
6129}
6130
6131func (self *NxmReg14Masked) GetOXMValueMask() interface{} {
6132 return self.ValueMask
6133}
6134
6135func (self *NxmReg14Masked) MarshalJSON() ([]byte, error) {
6136 value, err := jsonValue(self.GetOXMValue())
6137 if err != nil {
6138 return nil, err
6139 }
6140 valueMask, err := jsonValue(self.GetOXMValueMask())
6141 if err != nil {
6142 return nil, err
6143 }
6144 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
6145}
6146
6147type NxmReg15 struct {
6148 *Oxm
6149 Value uint32
6150}
6151
6152type INxmReg15 interface {
6153 goloxi.IOxm
6154 GetValue() uint32
6155}
6156
6157func (self *NxmReg15) GetValue() uint32 {
6158 return self.Value
6159}
6160
6161func (self *NxmReg15) SetValue(v uint32) {
6162 self.Value = v
6163}
6164
6165func (self *NxmReg15) Serialize(encoder *goloxi.Encoder) error {
6166 if err := self.Oxm.Serialize(encoder); err != nil {
6167 return err
6168 }
6169
6170 encoder.PutUint32(uint32(self.Value))
6171
6172 return nil
6173}
6174
6175func DecodeNxmReg15(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg15, error) {
6176 _nxmreg15 := &NxmReg15{Oxm: parent}
6177 if decoder.Length() < 4 {
6178 return nil, fmt.Errorf("NxmReg15 packet too short: %d < 4", decoder.Length())
6179 }
6180 _nxmreg15.Value = uint32(decoder.ReadUint32())
6181 return _nxmreg15, nil
6182}
6183
6184func NewNxmReg15() *NxmReg15 {
6185 obj := &NxmReg15{
6186 Oxm: NewOxm(73220),
6187 }
6188 return obj
6189}
6190func (self *NxmReg15) GetOXMName() string {
6191 return "reg15"
6192}
6193
6194func (self *NxmReg15) GetOXMValue() interface{} {
6195 return self.Value
6196}
6197
6198func (self *NxmReg15) MarshalJSON() ([]byte, error) {
6199 value, err := jsonValue(self.GetOXMValue())
6200 if err != nil {
6201 return nil, err
6202 }
6203 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
6204}
6205
6206type NxmReg15Masked struct {
6207 *Oxm
6208 Value uint32
6209 ValueMask uint32
6210}
6211
6212type INxmReg15Masked interface {
6213 goloxi.IOxm
6214 GetValue() uint32
6215 GetValueMask() uint32
6216}
6217
6218func (self *NxmReg15Masked) GetValue() uint32 {
6219 return self.Value
6220}
6221
6222func (self *NxmReg15Masked) SetValue(v uint32) {
6223 self.Value = v
6224}
6225
6226func (self *NxmReg15Masked) GetValueMask() uint32 {
6227 return self.ValueMask
6228}
6229
6230func (self *NxmReg15Masked) SetValueMask(v uint32) {
6231 self.ValueMask = v
6232}
6233
6234func (self *NxmReg15Masked) Serialize(encoder *goloxi.Encoder) error {
6235 if err := self.Oxm.Serialize(encoder); err != nil {
6236 return err
6237 }
6238
6239 encoder.PutUint32(uint32(self.Value))
6240 encoder.PutUint32(uint32(self.ValueMask))
6241
6242 return nil
6243}
6244
6245func DecodeNxmReg15Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg15Masked, error) {
6246 _nxmreg15masked := &NxmReg15Masked{Oxm: parent}
6247 if decoder.Length() < 8 {
6248 return nil, fmt.Errorf("NxmReg15Masked packet too short: %d < 8", decoder.Length())
6249 }
6250 _nxmreg15masked.Value = uint32(decoder.ReadUint32())
6251 _nxmreg15masked.ValueMask = uint32(decoder.ReadUint32())
6252 return _nxmreg15masked, nil
6253}
6254
6255func NewNxmReg15Masked() *NxmReg15Masked {
6256 obj := &NxmReg15Masked{
6257 Oxm: NewOxm(73480),
6258 }
6259 return obj
6260}
6261func (self *NxmReg15Masked) GetOXMName() string {
6262 return "reg15_masked"
6263}
6264
6265func (self *NxmReg15Masked) GetOXMValue() interface{} {
6266 return self.Value
6267}
6268
6269func (self *NxmReg15Masked) GetOXMValueMask() interface{} {
6270 return self.ValueMask
6271}
6272
6273func (self *NxmReg15Masked) MarshalJSON() ([]byte, error) {
6274 value, err := jsonValue(self.GetOXMValue())
6275 if err != nil {
6276 return nil, err
6277 }
6278 valueMask, err := jsonValue(self.GetOXMValueMask())
6279 if err != nil {
6280 return nil, err
6281 }
6282 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
6283}
6284
6285type NxmReg1Masked struct {
6286 *Oxm
6287 Value uint32
6288 ValueMask uint32
6289}
6290
6291type INxmReg1Masked interface {
6292 goloxi.IOxm
6293 GetValue() uint32
6294 GetValueMask() uint32
6295}
6296
6297func (self *NxmReg1Masked) GetValue() uint32 {
6298 return self.Value
6299}
6300
6301func (self *NxmReg1Masked) SetValue(v uint32) {
6302 self.Value = v
6303}
6304
6305func (self *NxmReg1Masked) GetValueMask() uint32 {
6306 return self.ValueMask
6307}
6308
6309func (self *NxmReg1Masked) SetValueMask(v uint32) {
6310 self.ValueMask = v
6311}
6312
6313func (self *NxmReg1Masked) Serialize(encoder *goloxi.Encoder) error {
6314 if err := self.Oxm.Serialize(encoder); err != nil {
6315 return err
6316 }
6317
6318 encoder.PutUint32(uint32(self.Value))
6319 encoder.PutUint32(uint32(self.ValueMask))
6320
6321 return nil
6322}
6323
6324func DecodeNxmReg1Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg1Masked, error) {
6325 _nxmreg1masked := &NxmReg1Masked{Oxm: parent}
6326 if decoder.Length() < 8 {
6327 return nil, fmt.Errorf("NxmReg1Masked packet too short: %d < 8", decoder.Length())
6328 }
6329 _nxmreg1masked.Value = uint32(decoder.ReadUint32())
6330 _nxmreg1masked.ValueMask = uint32(decoder.ReadUint32())
6331 return _nxmreg1masked, nil
6332}
6333
6334func NewNxmReg1Masked() *NxmReg1Masked {
6335 obj := &NxmReg1Masked{
6336 Oxm: NewOxm(66312),
6337 }
6338 return obj
6339}
6340func (self *NxmReg1Masked) GetOXMName() string {
6341 return "reg1_masked"
6342}
6343
6344func (self *NxmReg1Masked) GetOXMValue() interface{} {
6345 return self.Value
6346}
6347
6348func (self *NxmReg1Masked) GetOXMValueMask() interface{} {
6349 return self.ValueMask
6350}
6351
6352func (self *NxmReg1Masked) MarshalJSON() ([]byte, error) {
6353 value, err := jsonValue(self.GetOXMValue())
6354 if err != nil {
6355 return nil, err
6356 }
6357 valueMask, err := jsonValue(self.GetOXMValueMask())
6358 if err != nil {
6359 return nil, err
6360 }
6361 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
6362}
6363
6364type NxmReg2 struct {
6365 *Oxm
6366 Value uint32
6367}
6368
6369type INxmReg2 interface {
6370 goloxi.IOxm
6371 GetValue() uint32
6372}
6373
6374func (self *NxmReg2) GetValue() uint32 {
6375 return self.Value
6376}
6377
6378func (self *NxmReg2) SetValue(v uint32) {
6379 self.Value = v
6380}
6381
6382func (self *NxmReg2) Serialize(encoder *goloxi.Encoder) error {
6383 if err := self.Oxm.Serialize(encoder); err != nil {
6384 return err
6385 }
6386
6387 encoder.PutUint32(uint32(self.Value))
6388
6389 return nil
6390}
6391
6392func DecodeNxmReg2(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg2, error) {
6393 _nxmreg2 := &NxmReg2{Oxm: parent}
6394 if decoder.Length() < 4 {
6395 return nil, fmt.Errorf("NxmReg2 packet too short: %d < 4", decoder.Length())
6396 }
6397 _nxmreg2.Value = uint32(decoder.ReadUint32())
6398 return _nxmreg2, nil
6399}
6400
6401func NewNxmReg2() *NxmReg2 {
6402 obj := &NxmReg2{
6403 Oxm: NewOxm(66564),
6404 }
6405 return obj
6406}
6407func (self *NxmReg2) GetOXMName() string {
6408 return "reg2"
6409}
6410
6411func (self *NxmReg2) GetOXMValue() interface{} {
6412 return self.Value
6413}
6414
6415func (self *NxmReg2) MarshalJSON() ([]byte, error) {
6416 value, err := jsonValue(self.GetOXMValue())
6417 if err != nil {
6418 return nil, err
6419 }
6420 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
6421}
6422
6423type NxmReg2Masked struct {
6424 *Oxm
6425 Value uint32
6426 ValueMask uint32
6427}
6428
6429type INxmReg2Masked interface {
6430 goloxi.IOxm
6431 GetValue() uint32
6432 GetValueMask() uint32
6433}
6434
6435func (self *NxmReg2Masked) GetValue() uint32 {
6436 return self.Value
6437}
6438
6439func (self *NxmReg2Masked) SetValue(v uint32) {
6440 self.Value = v
6441}
6442
6443func (self *NxmReg2Masked) GetValueMask() uint32 {
6444 return self.ValueMask
6445}
6446
6447func (self *NxmReg2Masked) SetValueMask(v uint32) {
6448 self.ValueMask = v
6449}
6450
6451func (self *NxmReg2Masked) Serialize(encoder *goloxi.Encoder) error {
6452 if err := self.Oxm.Serialize(encoder); err != nil {
6453 return err
6454 }
6455
6456 encoder.PutUint32(uint32(self.Value))
6457 encoder.PutUint32(uint32(self.ValueMask))
6458
6459 return nil
6460}
6461
6462func DecodeNxmReg2Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg2Masked, error) {
6463 _nxmreg2masked := &NxmReg2Masked{Oxm: parent}
6464 if decoder.Length() < 8 {
6465 return nil, fmt.Errorf("NxmReg2Masked packet too short: %d < 8", decoder.Length())
6466 }
6467 _nxmreg2masked.Value = uint32(decoder.ReadUint32())
6468 _nxmreg2masked.ValueMask = uint32(decoder.ReadUint32())
6469 return _nxmreg2masked, nil
6470}
6471
6472func NewNxmReg2Masked() *NxmReg2Masked {
6473 obj := &NxmReg2Masked{
6474 Oxm: NewOxm(66824),
6475 }
6476 return obj
6477}
6478func (self *NxmReg2Masked) GetOXMName() string {
6479 return "reg2_masked"
6480}
6481
6482func (self *NxmReg2Masked) GetOXMValue() interface{} {
6483 return self.Value
6484}
6485
6486func (self *NxmReg2Masked) GetOXMValueMask() interface{} {
6487 return self.ValueMask
6488}
6489
6490func (self *NxmReg2Masked) MarshalJSON() ([]byte, error) {
6491 value, err := jsonValue(self.GetOXMValue())
6492 if err != nil {
6493 return nil, err
6494 }
6495 valueMask, err := jsonValue(self.GetOXMValueMask())
6496 if err != nil {
6497 return nil, err
6498 }
6499 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
6500}
6501
6502type NxmReg3 struct {
6503 *Oxm
6504 Value uint32
6505}
6506
6507type INxmReg3 interface {
6508 goloxi.IOxm
6509 GetValue() uint32
6510}
6511
6512func (self *NxmReg3) GetValue() uint32 {
6513 return self.Value
6514}
6515
6516func (self *NxmReg3) SetValue(v uint32) {
6517 self.Value = v
6518}
6519
6520func (self *NxmReg3) Serialize(encoder *goloxi.Encoder) error {
6521 if err := self.Oxm.Serialize(encoder); err != nil {
6522 return err
6523 }
6524
6525 encoder.PutUint32(uint32(self.Value))
6526
6527 return nil
6528}
6529
6530func DecodeNxmReg3(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg3, error) {
6531 _nxmreg3 := &NxmReg3{Oxm: parent}
6532 if decoder.Length() < 4 {
6533 return nil, fmt.Errorf("NxmReg3 packet too short: %d < 4", decoder.Length())
6534 }
6535 _nxmreg3.Value = uint32(decoder.ReadUint32())
6536 return _nxmreg3, nil
6537}
6538
6539func NewNxmReg3() *NxmReg3 {
6540 obj := &NxmReg3{
6541 Oxm: NewOxm(67076),
6542 }
6543 return obj
6544}
6545func (self *NxmReg3) GetOXMName() string {
6546 return "reg3"
6547}
6548
6549func (self *NxmReg3) GetOXMValue() interface{} {
6550 return self.Value
6551}
6552
6553func (self *NxmReg3) MarshalJSON() ([]byte, error) {
6554 value, err := jsonValue(self.GetOXMValue())
6555 if err != nil {
6556 return nil, err
6557 }
6558 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
6559}
6560
6561type NxmReg3Masked struct {
6562 *Oxm
6563 Value uint32
6564 ValueMask uint32
6565}
6566
6567type INxmReg3Masked interface {
6568 goloxi.IOxm
6569 GetValue() uint32
6570 GetValueMask() uint32
6571}
6572
6573func (self *NxmReg3Masked) GetValue() uint32 {
6574 return self.Value
6575}
6576
6577func (self *NxmReg3Masked) SetValue(v uint32) {
6578 self.Value = v
6579}
6580
6581func (self *NxmReg3Masked) GetValueMask() uint32 {
6582 return self.ValueMask
6583}
6584
6585func (self *NxmReg3Masked) SetValueMask(v uint32) {
6586 self.ValueMask = v
6587}
6588
6589func (self *NxmReg3Masked) Serialize(encoder *goloxi.Encoder) error {
6590 if err := self.Oxm.Serialize(encoder); err != nil {
6591 return err
6592 }
6593
6594 encoder.PutUint32(uint32(self.Value))
6595 encoder.PutUint32(uint32(self.ValueMask))
6596
6597 return nil
6598}
6599
6600func DecodeNxmReg3Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg3Masked, error) {
6601 _nxmreg3masked := &NxmReg3Masked{Oxm: parent}
6602 if decoder.Length() < 8 {
6603 return nil, fmt.Errorf("NxmReg3Masked packet too short: %d < 8", decoder.Length())
6604 }
6605 _nxmreg3masked.Value = uint32(decoder.ReadUint32())
6606 _nxmreg3masked.ValueMask = uint32(decoder.ReadUint32())
6607 return _nxmreg3masked, nil
6608}
6609
6610func NewNxmReg3Masked() *NxmReg3Masked {
6611 obj := &NxmReg3Masked{
6612 Oxm: NewOxm(67336),
6613 }
6614 return obj
6615}
6616func (self *NxmReg3Masked) GetOXMName() string {
6617 return "reg3_masked"
6618}
6619
6620func (self *NxmReg3Masked) GetOXMValue() interface{} {
6621 return self.Value
6622}
6623
6624func (self *NxmReg3Masked) GetOXMValueMask() interface{} {
6625 return self.ValueMask
6626}
6627
6628func (self *NxmReg3Masked) MarshalJSON() ([]byte, error) {
6629 value, err := jsonValue(self.GetOXMValue())
6630 if err != nil {
6631 return nil, err
6632 }
6633 valueMask, err := jsonValue(self.GetOXMValueMask())
6634 if err != nil {
6635 return nil, err
6636 }
6637 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
6638}
6639
6640type NxmReg4 struct {
6641 *Oxm
6642 Value uint32
6643}
6644
6645type INxmReg4 interface {
6646 goloxi.IOxm
6647 GetValue() uint32
6648}
6649
6650func (self *NxmReg4) GetValue() uint32 {
6651 return self.Value
6652}
6653
6654func (self *NxmReg4) SetValue(v uint32) {
6655 self.Value = v
6656}
6657
6658func (self *NxmReg4) Serialize(encoder *goloxi.Encoder) error {
6659 if err := self.Oxm.Serialize(encoder); err != nil {
6660 return err
6661 }
6662
6663 encoder.PutUint32(uint32(self.Value))
6664
6665 return nil
6666}
6667
6668func DecodeNxmReg4(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg4, error) {
6669 _nxmreg4 := &NxmReg4{Oxm: parent}
6670 if decoder.Length() < 4 {
6671 return nil, fmt.Errorf("NxmReg4 packet too short: %d < 4", decoder.Length())
6672 }
6673 _nxmreg4.Value = uint32(decoder.ReadUint32())
6674 return _nxmreg4, nil
6675}
6676
6677func NewNxmReg4() *NxmReg4 {
6678 obj := &NxmReg4{
6679 Oxm: NewOxm(67588),
6680 }
6681 return obj
6682}
6683func (self *NxmReg4) GetOXMName() string {
6684 return "reg4"
6685}
6686
6687func (self *NxmReg4) GetOXMValue() interface{} {
6688 return self.Value
6689}
6690
6691func (self *NxmReg4) MarshalJSON() ([]byte, error) {
6692 value, err := jsonValue(self.GetOXMValue())
6693 if err != nil {
6694 return nil, err
6695 }
6696 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
6697}
6698
6699type NxmReg4Masked struct {
6700 *Oxm
6701 Value uint32
6702 ValueMask uint32
6703}
6704
6705type INxmReg4Masked interface {
6706 goloxi.IOxm
6707 GetValue() uint32
6708 GetValueMask() uint32
6709}
6710
6711func (self *NxmReg4Masked) GetValue() uint32 {
6712 return self.Value
6713}
6714
6715func (self *NxmReg4Masked) SetValue(v uint32) {
6716 self.Value = v
6717}
6718
6719func (self *NxmReg4Masked) GetValueMask() uint32 {
6720 return self.ValueMask
6721}
6722
6723func (self *NxmReg4Masked) SetValueMask(v uint32) {
6724 self.ValueMask = v
6725}
6726
6727func (self *NxmReg4Masked) Serialize(encoder *goloxi.Encoder) error {
6728 if err := self.Oxm.Serialize(encoder); err != nil {
6729 return err
6730 }
6731
6732 encoder.PutUint32(uint32(self.Value))
6733 encoder.PutUint32(uint32(self.ValueMask))
6734
6735 return nil
6736}
6737
6738func DecodeNxmReg4Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg4Masked, error) {
6739 _nxmreg4masked := &NxmReg4Masked{Oxm: parent}
6740 if decoder.Length() < 8 {
6741 return nil, fmt.Errorf("NxmReg4Masked packet too short: %d < 8", decoder.Length())
6742 }
6743 _nxmreg4masked.Value = uint32(decoder.ReadUint32())
6744 _nxmreg4masked.ValueMask = uint32(decoder.ReadUint32())
6745 return _nxmreg4masked, nil
6746}
6747
6748func NewNxmReg4Masked() *NxmReg4Masked {
6749 obj := &NxmReg4Masked{
6750 Oxm: NewOxm(67848),
6751 }
6752 return obj
6753}
6754func (self *NxmReg4Masked) GetOXMName() string {
6755 return "reg4_masked"
6756}
6757
6758func (self *NxmReg4Masked) GetOXMValue() interface{} {
6759 return self.Value
6760}
6761
6762func (self *NxmReg4Masked) GetOXMValueMask() interface{} {
6763 return self.ValueMask
6764}
6765
6766func (self *NxmReg4Masked) MarshalJSON() ([]byte, error) {
6767 value, err := jsonValue(self.GetOXMValue())
6768 if err != nil {
6769 return nil, err
6770 }
6771 valueMask, err := jsonValue(self.GetOXMValueMask())
6772 if err != nil {
6773 return nil, err
6774 }
6775 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
6776}
6777
6778type NxmReg5 struct {
6779 *Oxm
6780 Value uint32
6781}
6782
6783type INxmReg5 interface {
6784 goloxi.IOxm
6785 GetValue() uint32
6786}
6787
6788func (self *NxmReg5) GetValue() uint32 {
6789 return self.Value
6790}
6791
6792func (self *NxmReg5) SetValue(v uint32) {
6793 self.Value = v
6794}
6795
6796func (self *NxmReg5) Serialize(encoder *goloxi.Encoder) error {
6797 if err := self.Oxm.Serialize(encoder); err != nil {
6798 return err
6799 }
6800
6801 encoder.PutUint32(uint32(self.Value))
6802
6803 return nil
6804}
6805
6806func DecodeNxmReg5(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg5, error) {
6807 _nxmreg5 := &NxmReg5{Oxm: parent}
6808 if decoder.Length() < 4 {
6809 return nil, fmt.Errorf("NxmReg5 packet too short: %d < 4", decoder.Length())
6810 }
6811 _nxmreg5.Value = uint32(decoder.ReadUint32())
6812 return _nxmreg5, nil
6813}
6814
6815func NewNxmReg5() *NxmReg5 {
6816 obj := &NxmReg5{
6817 Oxm: NewOxm(68100),
6818 }
6819 return obj
6820}
6821func (self *NxmReg5) GetOXMName() string {
6822 return "reg5"
6823}
6824
6825func (self *NxmReg5) GetOXMValue() interface{} {
6826 return self.Value
6827}
6828
6829func (self *NxmReg5) MarshalJSON() ([]byte, error) {
6830 value, err := jsonValue(self.GetOXMValue())
6831 if err != nil {
6832 return nil, err
6833 }
6834 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
6835}
6836
6837type NxmReg5Masked struct {
6838 *Oxm
6839 Value uint32
6840 ValueMask uint32
6841}
6842
6843type INxmReg5Masked interface {
6844 goloxi.IOxm
6845 GetValue() uint32
6846 GetValueMask() uint32
6847}
6848
6849func (self *NxmReg5Masked) GetValue() uint32 {
6850 return self.Value
6851}
6852
6853func (self *NxmReg5Masked) SetValue(v uint32) {
6854 self.Value = v
6855}
6856
6857func (self *NxmReg5Masked) GetValueMask() uint32 {
6858 return self.ValueMask
6859}
6860
6861func (self *NxmReg5Masked) SetValueMask(v uint32) {
6862 self.ValueMask = v
6863}
6864
6865func (self *NxmReg5Masked) Serialize(encoder *goloxi.Encoder) error {
6866 if err := self.Oxm.Serialize(encoder); err != nil {
6867 return err
6868 }
6869
6870 encoder.PutUint32(uint32(self.Value))
6871 encoder.PutUint32(uint32(self.ValueMask))
6872
6873 return nil
6874}
6875
6876func DecodeNxmReg5Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg5Masked, error) {
6877 _nxmreg5masked := &NxmReg5Masked{Oxm: parent}
6878 if decoder.Length() < 8 {
6879 return nil, fmt.Errorf("NxmReg5Masked packet too short: %d < 8", decoder.Length())
6880 }
6881 _nxmreg5masked.Value = uint32(decoder.ReadUint32())
6882 _nxmreg5masked.ValueMask = uint32(decoder.ReadUint32())
6883 return _nxmreg5masked, nil
6884}
6885
6886func NewNxmReg5Masked() *NxmReg5Masked {
6887 obj := &NxmReg5Masked{
6888 Oxm: NewOxm(68360),
6889 }
6890 return obj
6891}
6892func (self *NxmReg5Masked) GetOXMName() string {
6893 return "reg5_masked"
6894}
6895
6896func (self *NxmReg5Masked) GetOXMValue() interface{} {
6897 return self.Value
6898}
6899
6900func (self *NxmReg5Masked) GetOXMValueMask() interface{} {
6901 return self.ValueMask
6902}
6903
6904func (self *NxmReg5Masked) MarshalJSON() ([]byte, error) {
6905 value, err := jsonValue(self.GetOXMValue())
6906 if err != nil {
6907 return nil, err
6908 }
6909 valueMask, err := jsonValue(self.GetOXMValueMask())
6910 if err != nil {
6911 return nil, err
6912 }
6913 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
6914}
6915
6916type NxmReg6 struct {
6917 *Oxm
6918 Value uint32
6919}
6920
6921type INxmReg6 interface {
6922 goloxi.IOxm
6923 GetValue() uint32
6924}
6925
6926func (self *NxmReg6) GetValue() uint32 {
6927 return self.Value
6928}
6929
6930func (self *NxmReg6) SetValue(v uint32) {
6931 self.Value = v
6932}
6933
6934func (self *NxmReg6) Serialize(encoder *goloxi.Encoder) error {
6935 if err := self.Oxm.Serialize(encoder); err != nil {
6936 return err
6937 }
6938
6939 encoder.PutUint32(uint32(self.Value))
6940
6941 return nil
6942}
6943
6944func DecodeNxmReg6(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg6, error) {
6945 _nxmreg6 := &NxmReg6{Oxm: parent}
6946 if decoder.Length() < 4 {
6947 return nil, fmt.Errorf("NxmReg6 packet too short: %d < 4", decoder.Length())
6948 }
6949 _nxmreg6.Value = uint32(decoder.ReadUint32())
6950 return _nxmreg6, nil
6951}
6952
6953func NewNxmReg6() *NxmReg6 {
6954 obj := &NxmReg6{
6955 Oxm: NewOxm(68612),
6956 }
6957 return obj
6958}
6959func (self *NxmReg6) GetOXMName() string {
6960 return "reg6"
6961}
6962
6963func (self *NxmReg6) GetOXMValue() interface{} {
6964 return self.Value
6965}
6966
6967func (self *NxmReg6) MarshalJSON() ([]byte, error) {
6968 value, err := jsonValue(self.GetOXMValue())
6969 if err != nil {
6970 return nil, err
6971 }
6972 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
6973}
6974
6975type NxmReg6Masked struct {
6976 *Oxm
6977 Value uint32
6978 ValueMask uint32
6979}
6980
6981type INxmReg6Masked interface {
6982 goloxi.IOxm
6983 GetValue() uint32
6984 GetValueMask() uint32
6985}
6986
6987func (self *NxmReg6Masked) GetValue() uint32 {
6988 return self.Value
6989}
6990
6991func (self *NxmReg6Masked) SetValue(v uint32) {
6992 self.Value = v
6993}
6994
6995func (self *NxmReg6Masked) GetValueMask() uint32 {
6996 return self.ValueMask
6997}
6998
6999func (self *NxmReg6Masked) SetValueMask(v uint32) {
7000 self.ValueMask = v
7001}
7002
7003func (self *NxmReg6Masked) Serialize(encoder *goloxi.Encoder) error {
7004 if err := self.Oxm.Serialize(encoder); err != nil {
7005 return err
7006 }
7007
7008 encoder.PutUint32(uint32(self.Value))
7009 encoder.PutUint32(uint32(self.ValueMask))
7010
7011 return nil
7012}
7013
7014func DecodeNxmReg6Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg6Masked, error) {
7015 _nxmreg6masked := &NxmReg6Masked{Oxm: parent}
7016 if decoder.Length() < 8 {
7017 return nil, fmt.Errorf("NxmReg6Masked packet too short: %d < 8", decoder.Length())
7018 }
7019 _nxmreg6masked.Value = uint32(decoder.ReadUint32())
7020 _nxmreg6masked.ValueMask = uint32(decoder.ReadUint32())
7021 return _nxmreg6masked, nil
7022}
7023
7024func NewNxmReg6Masked() *NxmReg6Masked {
7025 obj := &NxmReg6Masked{
7026 Oxm: NewOxm(68872),
7027 }
7028 return obj
7029}
7030func (self *NxmReg6Masked) GetOXMName() string {
7031 return "reg6_masked"
7032}
7033
7034func (self *NxmReg6Masked) GetOXMValue() interface{} {
7035 return self.Value
7036}
7037
7038func (self *NxmReg6Masked) GetOXMValueMask() interface{} {
7039 return self.ValueMask
7040}
7041
7042func (self *NxmReg6Masked) MarshalJSON() ([]byte, error) {
7043 value, err := jsonValue(self.GetOXMValue())
7044 if err != nil {
7045 return nil, err
7046 }
7047 valueMask, err := jsonValue(self.GetOXMValueMask())
7048 if err != nil {
7049 return nil, err
7050 }
7051 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
7052}
7053
7054type NxmReg7 struct {
7055 *Oxm
7056 Value uint32
7057}
7058
7059type INxmReg7 interface {
7060 goloxi.IOxm
7061 GetValue() uint32
7062}
7063
7064func (self *NxmReg7) GetValue() uint32 {
7065 return self.Value
7066}
7067
7068func (self *NxmReg7) SetValue(v uint32) {
7069 self.Value = v
7070}
7071
7072func (self *NxmReg7) Serialize(encoder *goloxi.Encoder) error {
7073 if err := self.Oxm.Serialize(encoder); err != nil {
7074 return err
7075 }
7076
7077 encoder.PutUint32(uint32(self.Value))
7078
7079 return nil
7080}
7081
7082func DecodeNxmReg7(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg7, error) {
7083 _nxmreg7 := &NxmReg7{Oxm: parent}
7084 if decoder.Length() < 4 {
7085 return nil, fmt.Errorf("NxmReg7 packet too short: %d < 4", decoder.Length())
7086 }
7087 _nxmreg7.Value = uint32(decoder.ReadUint32())
7088 return _nxmreg7, nil
7089}
7090
7091func NewNxmReg7() *NxmReg7 {
7092 obj := &NxmReg7{
7093 Oxm: NewOxm(69124),
7094 }
7095 return obj
7096}
7097func (self *NxmReg7) GetOXMName() string {
7098 return "reg7"
7099}
7100
7101func (self *NxmReg7) GetOXMValue() interface{} {
7102 return self.Value
7103}
7104
7105func (self *NxmReg7) MarshalJSON() ([]byte, error) {
7106 value, err := jsonValue(self.GetOXMValue())
7107 if err != nil {
7108 return nil, err
7109 }
7110 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
7111}
7112
7113type NxmReg7Masked struct {
7114 *Oxm
7115 Value uint32
7116 ValueMask uint32
7117}
7118
7119type INxmReg7Masked interface {
7120 goloxi.IOxm
7121 GetValue() uint32
7122 GetValueMask() uint32
7123}
7124
7125func (self *NxmReg7Masked) GetValue() uint32 {
7126 return self.Value
7127}
7128
7129func (self *NxmReg7Masked) SetValue(v uint32) {
7130 self.Value = v
7131}
7132
7133func (self *NxmReg7Masked) GetValueMask() uint32 {
7134 return self.ValueMask
7135}
7136
7137func (self *NxmReg7Masked) SetValueMask(v uint32) {
7138 self.ValueMask = v
7139}
7140
7141func (self *NxmReg7Masked) Serialize(encoder *goloxi.Encoder) error {
7142 if err := self.Oxm.Serialize(encoder); err != nil {
7143 return err
7144 }
7145
7146 encoder.PutUint32(uint32(self.Value))
7147 encoder.PutUint32(uint32(self.ValueMask))
7148
7149 return nil
7150}
7151
7152func DecodeNxmReg7Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg7Masked, error) {
7153 _nxmreg7masked := &NxmReg7Masked{Oxm: parent}
7154 if decoder.Length() < 8 {
7155 return nil, fmt.Errorf("NxmReg7Masked packet too short: %d < 8", decoder.Length())
7156 }
7157 _nxmreg7masked.Value = uint32(decoder.ReadUint32())
7158 _nxmreg7masked.ValueMask = uint32(decoder.ReadUint32())
7159 return _nxmreg7masked, nil
7160}
7161
7162func NewNxmReg7Masked() *NxmReg7Masked {
7163 obj := &NxmReg7Masked{
7164 Oxm: NewOxm(69384),
7165 }
7166 return obj
7167}
7168func (self *NxmReg7Masked) GetOXMName() string {
7169 return "reg7_masked"
7170}
7171
7172func (self *NxmReg7Masked) GetOXMValue() interface{} {
7173 return self.Value
7174}
7175
7176func (self *NxmReg7Masked) GetOXMValueMask() interface{} {
7177 return self.ValueMask
7178}
7179
7180func (self *NxmReg7Masked) MarshalJSON() ([]byte, error) {
7181 value, err := jsonValue(self.GetOXMValue())
7182 if err != nil {
7183 return nil, err
7184 }
7185 valueMask, err := jsonValue(self.GetOXMValueMask())
7186 if err != nil {
7187 return nil, err
7188 }
7189 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
7190}
7191
7192type NxmReg8 struct {
7193 *Oxm
7194 Value uint32
7195}
7196
7197type INxmReg8 interface {
7198 goloxi.IOxm
7199 GetValue() uint32
7200}
7201
7202func (self *NxmReg8) GetValue() uint32 {
7203 return self.Value
7204}
7205
7206func (self *NxmReg8) SetValue(v uint32) {
7207 self.Value = v
7208}
7209
7210func (self *NxmReg8) Serialize(encoder *goloxi.Encoder) error {
7211 if err := self.Oxm.Serialize(encoder); err != nil {
7212 return err
7213 }
7214
7215 encoder.PutUint32(uint32(self.Value))
7216
7217 return nil
7218}
7219
7220func DecodeNxmReg8(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg8, error) {
7221 _nxmreg8 := &NxmReg8{Oxm: parent}
7222 if decoder.Length() < 4 {
7223 return nil, fmt.Errorf("NxmReg8 packet too short: %d < 4", decoder.Length())
7224 }
7225 _nxmreg8.Value = uint32(decoder.ReadUint32())
7226 return _nxmreg8, nil
7227}
7228
7229func NewNxmReg8() *NxmReg8 {
7230 obj := &NxmReg8{
7231 Oxm: NewOxm(69636),
7232 }
7233 return obj
7234}
7235func (self *NxmReg8) GetOXMName() string {
7236 return "reg8"
7237}
7238
7239func (self *NxmReg8) GetOXMValue() interface{} {
7240 return self.Value
7241}
7242
7243func (self *NxmReg8) MarshalJSON() ([]byte, error) {
7244 value, err := jsonValue(self.GetOXMValue())
7245 if err != nil {
7246 return nil, err
7247 }
7248 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
7249}
7250
7251type NxmReg8Masked struct {
7252 *Oxm
7253 Value uint32
7254 ValueMask uint32
7255}
7256
7257type INxmReg8Masked interface {
7258 goloxi.IOxm
7259 GetValue() uint32
7260 GetValueMask() uint32
7261}
7262
7263func (self *NxmReg8Masked) GetValue() uint32 {
7264 return self.Value
7265}
7266
7267func (self *NxmReg8Masked) SetValue(v uint32) {
7268 self.Value = v
7269}
7270
7271func (self *NxmReg8Masked) GetValueMask() uint32 {
7272 return self.ValueMask
7273}
7274
7275func (self *NxmReg8Masked) SetValueMask(v uint32) {
7276 self.ValueMask = v
7277}
7278
7279func (self *NxmReg8Masked) Serialize(encoder *goloxi.Encoder) error {
7280 if err := self.Oxm.Serialize(encoder); err != nil {
7281 return err
7282 }
7283
7284 encoder.PutUint32(uint32(self.Value))
7285 encoder.PutUint32(uint32(self.ValueMask))
7286
7287 return nil
7288}
7289
7290func DecodeNxmReg8Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg8Masked, error) {
7291 _nxmreg8masked := &NxmReg8Masked{Oxm: parent}
7292 if decoder.Length() < 8 {
7293 return nil, fmt.Errorf("NxmReg8Masked packet too short: %d < 8", decoder.Length())
7294 }
7295 _nxmreg8masked.Value = uint32(decoder.ReadUint32())
7296 _nxmreg8masked.ValueMask = uint32(decoder.ReadUint32())
7297 return _nxmreg8masked, nil
7298}
7299
7300func NewNxmReg8Masked() *NxmReg8Masked {
7301 obj := &NxmReg8Masked{
7302 Oxm: NewOxm(69896),
7303 }
7304 return obj
7305}
7306func (self *NxmReg8Masked) GetOXMName() string {
7307 return "reg8_masked"
7308}
7309
7310func (self *NxmReg8Masked) GetOXMValue() interface{} {
7311 return self.Value
7312}
7313
7314func (self *NxmReg8Masked) GetOXMValueMask() interface{} {
7315 return self.ValueMask
7316}
7317
7318func (self *NxmReg8Masked) MarshalJSON() ([]byte, error) {
7319 value, err := jsonValue(self.GetOXMValue())
7320 if err != nil {
7321 return nil, err
7322 }
7323 valueMask, err := jsonValue(self.GetOXMValueMask())
7324 if err != nil {
7325 return nil, err
7326 }
7327 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
7328}
7329
7330type NxmReg9 struct {
7331 *Oxm
7332 Value uint32
7333}
7334
7335type INxmReg9 interface {
7336 goloxi.IOxm
7337 GetValue() uint32
7338}
7339
7340func (self *NxmReg9) GetValue() uint32 {
7341 return self.Value
7342}
7343
7344func (self *NxmReg9) SetValue(v uint32) {
7345 self.Value = v
7346}
7347
7348func (self *NxmReg9) Serialize(encoder *goloxi.Encoder) error {
7349 if err := self.Oxm.Serialize(encoder); err != nil {
7350 return err
7351 }
7352
7353 encoder.PutUint32(uint32(self.Value))
7354
7355 return nil
7356}
7357
7358func DecodeNxmReg9(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg9, error) {
7359 _nxmreg9 := &NxmReg9{Oxm: parent}
7360 if decoder.Length() < 4 {
7361 return nil, fmt.Errorf("NxmReg9 packet too short: %d < 4", decoder.Length())
7362 }
7363 _nxmreg9.Value = uint32(decoder.ReadUint32())
7364 return _nxmreg9, nil
7365}
7366
7367func NewNxmReg9() *NxmReg9 {
7368 obj := &NxmReg9{
7369 Oxm: NewOxm(70148),
7370 }
7371 return obj
7372}
7373func (self *NxmReg9) GetOXMName() string {
7374 return "reg9"
7375}
7376
7377func (self *NxmReg9) GetOXMValue() interface{} {
7378 return self.Value
7379}
7380
7381func (self *NxmReg9) MarshalJSON() ([]byte, error) {
7382 value, err := jsonValue(self.GetOXMValue())
7383 if err != nil {
7384 return nil, err
7385 }
7386 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
7387}
7388
7389type NxmReg9Masked struct {
7390 *Oxm
7391 Value uint32
7392 ValueMask uint32
7393}
7394
7395type INxmReg9Masked interface {
7396 goloxi.IOxm
7397 GetValue() uint32
7398 GetValueMask() uint32
7399}
7400
7401func (self *NxmReg9Masked) GetValue() uint32 {
7402 return self.Value
7403}
7404
7405func (self *NxmReg9Masked) SetValue(v uint32) {
7406 self.Value = v
7407}
7408
7409func (self *NxmReg9Masked) GetValueMask() uint32 {
7410 return self.ValueMask
7411}
7412
7413func (self *NxmReg9Masked) SetValueMask(v uint32) {
7414 self.ValueMask = v
7415}
7416
7417func (self *NxmReg9Masked) Serialize(encoder *goloxi.Encoder) error {
7418 if err := self.Oxm.Serialize(encoder); err != nil {
7419 return err
7420 }
7421
7422 encoder.PutUint32(uint32(self.Value))
7423 encoder.PutUint32(uint32(self.ValueMask))
7424
7425 return nil
7426}
7427
7428func DecodeNxmReg9Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmReg9Masked, error) {
7429 _nxmreg9masked := &NxmReg9Masked{Oxm: parent}
7430 if decoder.Length() < 8 {
7431 return nil, fmt.Errorf("NxmReg9Masked packet too short: %d < 8", decoder.Length())
7432 }
7433 _nxmreg9masked.Value = uint32(decoder.ReadUint32())
7434 _nxmreg9masked.ValueMask = uint32(decoder.ReadUint32())
7435 return _nxmreg9masked, nil
7436}
7437
7438func NewNxmReg9Masked() *NxmReg9Masked {
7439 obj := &NxmReg9Masked{
7440 Oxm: NewOxm(70408),
7441 }
7442 return obj
7443}
7444func (self *NxmReg9Masked) GetOXMName() string {
7445 return "reg9_masked"
7446}
7447
7448func (self *NxmReg9Masked) GetOXMValue() interface{} {
7449 return self.Value
7450}
7451
7452func (self *NxmReg9Masked) GetOXMValueMask() interface{} {
7453 return self.ValueMask
7454}
7455
7456func (self *NxmReg9Masked) MarshalJSON() ([]byte, error) {
7457 value, err := jsonValue(self.GetOXMValue())
7458 if err != nil {
7459 return nil, err
7460 }
7461 valueMask, err := jsonValue(self.GetOXMValueMask())
7462 if err != nil {
7463 return nil, err
7464 }
7465 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
7466}
7467
7468type NxmTcpDst struct {
7469 *Oxm
7470 Value uint16
7471}
7472
7473type INxmTcpDst interface {
7474 goloxi.IOxm
7475 GetValue() uint16
7476}
7477
7478func (self *NxmTcpDst) GetValue() uint16 {
7479 return self.Value
7480}
7481
7482func (self *NxmTcpDst) SetValue(v uint16) {
7483 self.Value = v
7484}
7485
7486func (self *NxmTcpDst) Serialize(encoder *goloxi.Encoder) error {
7487 if err := self.Oxm.Serialize(encoder); err != nil {
7488 return err
7489 }
7490
7491 encoder.PutUint16(uint16(self.Value))
7492
7493 return nil
7494}
7495
7496func DecodeNxmTcpDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpDst, error) {
7497 _nxmtcpdst := &NxmTcpDst{Oxm: parent}
7498 if decoder.Length() < 2 {
7499 return nil, fmt.Errorf("NxmTcpDst packet too short: %d < 2", decoder.Length())
7500 }
7501 _nxmtcpdst.Value = uint16(decoder.ReadUint16())
7502 return _nxmtcpdst, nil
7503}
7504
7505func NewNxmTcpDst() *NxmTcpDst {
7506 obj := &NxmTcpDst{
7507 Oxm: NewOxm(5122),
7508 }
7509 return obj
7510}
7511func (self *NxmTcpDst) GetOXMName() string {
7512 return "tcp_dst"
7513}
7514
7515func (self *NxmTcpDst) GetOXMValue() interface{} {
7516 return self.Value
7517}
7518
7519func (self *NxmTcpDst) MarshalJSON() ([]byte, error) {
7520 value, err := jsonValue(self.GetOXMValue())
7521 if err != nil {
7522 return nil, err
7523 }
7524 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
7525}
7526
7527type NxmTcpDstMasked struct {
7528 *Oxm
7529 Value uint16
7530 ValueMask uint16
7531}
7532
7533type INxmTcpDstMasked interface {
7534 goloxi.IOxm
7535 GetValue() uint16
7536 GetValueMask() uint16
7537}
7538
7539func (self *NxmTcpDstMasked) GetValue() uint16 {
7540 return self.Value
7541}
7542
7543func (self *NxmTcpDstMasked) SetValue(v uint16) {
7544 self.Value = v
7545}
7546
7547func (self *NxmTcpDstMasked) GetValueMask() uint16 {
7548 return self.ValueMask
7549}
7550
7551func (self *NxmTcpDstMasked) SetValueMask(v uint16) {
7552 self.ValueMask = v
7553}
7554
7555func (self *NxmTcpDstMasked) Serialize(encoder *goloxi.Encoder) error {
7556 if err := self.Oxm.Serialize(encoder); err != nil {
7557 return err
7558 }
7559
7560 encoder.PutUint16(uint16(self.Value))
7561 encoder.PutUint16(uint16(self.ValueMask))
7562
7563 return nil
7564}
7565
7566func DecodeNxmTcpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpDstMasked, error) {
7567 _nxmtcpdstmasked := &NxmTcpDstMasked{Oxm: parent}
7568 if decoder.Length() < 4 {
7569 return nil, fmt.Errorf("NxmTcpDstMasked packet too short: %d < 4", decoder.Length())
7570 }
7571 _nxmtcpdstmasked.Value = uint16(decoder.ReadUint16())
7572 _nxmtcpdstmasked.ValueMask = uint16(decoder.ReadUint16())
7573 return _nxmtcpdstmasked, nil
7574}
7575
7576func NewNxmTcpDstMasked() *NxmTcpDstMasked {
7577 obj := &NxmTcpDstMasked{
7578 Oxm: NewOxm(5378),
7579 }
7580 return obj
7581}
7582func (self *NxmTcpDstMasked) GetOXMName() string {
7583 return "tcp_dst_masked"
7584}
7585
7586func (self *NxmTcpDstMasked) GetOXMValue() interface{} {
7587 return self.Value
7588}
7589
7590func (self *NxmTcpDstMasked) GetOXMValueMask() interface{} {
7591 return self.ValueMask
7592}
7593
7594func (self *NxmTcpDstMasked) MarshalJSON() ([]byte, error) {
7595 value, err := jsonValue(self.GetOXMValue())
7596 if err != nil {
7597 return nil, err
7598 }
7599 valueMask, err := jsonValue(self.GetOXMValueMask())
7600 if err != nil {
7601 return nil, err
7602 }
7603 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
7604}
7605
7606type NxmTcpFlags struct {
7607 *Oxm
7608 Value TcpFlags
7609}
7610
7611type INxmTcpFlags interface {
7612 goloxi.IOxm
7613 GetValue() TcpFlags
7614}
7615
7616func (self *NxmTcpFlags) GetValue() TcpFlags {
7617 return self.Value
7618}
7619
7620func (self *NxmTcpFlags) SetValue(v TcpFlags) {
7621 self.Value = v
7622}
7623
7624func (self *NxmTcpFlags) Serialize(encoder *goloxi.Encoder) error {
7625 if err := self.Oxm.Serialize(encoder); err != nil {
7626 return err
7627 }
7628
7629 encoder.PutUint16(uint16(self.Value))
7630
7631 return nil
7632}
7633
7634func DecodeNxmTcpFlags(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpFlags, error) {
7635 _nxmtcpflags := &NxmTcpFlags{Oxm: parent}
7636 if decoder.Length() < 2 {
7637 return nil, fmt.Errorf("NxmTcpFlags packet too short: %d < 2", decoder.Length())
7638 }
7639 _nxmtcpflags.Value = TcpFlags(decoder.ReadUint16())
7640 return _nxmtcpflags, nil
7641}
7642
7643func NewNxmTcpFlags() *NxmTcpFlags {
7644 obj := &NxmTcpFlags{
7645 Oxm: NewOxm(82946),
7646 }
7647 return obj
7648}
7649func (self *NxmTcpFlags) GetOXMName() string {
7650 return "tcp_flags"
7651}
7652
7653func (self *NxmTcpFlags) GetOXMValue() interface{} {
7654 return self.Value
7655}
7656
7657func (self *NxmTcpFlags) MarshalJSON() ([]byte, error) {
7658 value, err := jsonValue(self.GetOXMValue())
7659 if err != nil {
7660 return nil, err
7661 }
7662 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
7663}
7664
7665type NxmTcpFlagsMasked struct {
7666 *Oxm
7667 Value TcpFlags
7668 ValueMask uint16
7669}
7670
7671type INxmTcpFlagsMasked interface {
7672 goloxi.IOxm
7673 GetValue() TcpFlags
7674 GetValueMask() uint16
7675}
7676
7677func (self *NxmTcpFlagsMasked) GetValue() TcpFlags {
7678 return self.Value
7679}
7680
7681func (self *NxmTcpFlagsMasked) SetValue(v TcpFlags) {
7682 self.Value = v
7683}
7684
7685func (self *NxmTcpFlagsMasked) GetValueMask() uint16 {
7686 return self.ValueMask
7687}
7688
7689func (self *NxmTcpFlagsMasked) SetValueMask(v uint16) {
7690 self.ValueMask = v
7691}
7692
7693func (self *NxmTcpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
7694 if err := self.Oxm.Serialize(encoder); err != nil {
7695 return err
7696 }
7697
7698 encoder.PutUint16(uint16(self.Value))
7699 encoder.PutUint16(uint16(self.ValueMask))
7700
7701 return nil
7702}
7703
7704func DecodeNxmTcpFlagsMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpFlagsMasked, error) {
7705 _nxmtcpflagsmasked := &NxmTcpFlagsMasked{Oxm: parent}
7706 if decoder.Length() < 4 {
7707 return nil, fmt.Errorf("NxmTcpFlagsMasked packet too short: %d < 4", decoder.Length())
7708 }
7709 _nxmtcpflagsmasked.Value = TcpFlags(decoder.ReadUint16())
7710 _nxmtcpflagsmasked.ValueMask = uint16(decoder.ReadUint16())
7711 return _nxmtcpflagsmasked, nil
7712}
7713
7714func NewNxmTcpFlagsMasked() *NxmTcpFlagsMasked {
7715 obj := &NxmTcpFlagsMasked{
7716 Oxm: NewOxm(83204),
7717 }
7718 return obj
7719}
7720func (self *NxmTcpFlagsMasked) GetOXMName() string {
7721 return "tcp_flags_masked"
7722}
7723
7724func (self *NxmTcpFlagsMasked) GetOXMValue() interface{} {
7725 return self.Value
7726}
7727
7728func (self *NxmTcpFlagsMasked) GetOXMValueMask() interface{} {
7729 return self.ValueMask
7730}
7731
7732func (self *NxmTcpFlagsMasked) MarshalJSON() ([]byte, error) {
7733 value, err := jsonValue(self.GetOXMValue())
7734 if err != nil {
7735 return nil, err
7736 }
7737 valueMask, err := jsonValue(self.GetOXMValueMask())
7738 if err != nil {
7739 return nil, err
7740 }
7741 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
7742}
7743
7744type NxmTcpSrc struct {
7745 *Oxm
7746 Value uint16
7747}
7748
7749type INxmTcpSrc interface {
7750 goloxi.IOxm
7751 GetValue() uint16
7752}
7753
7754func (self *NxmTcpSrc) GetValue() uint16 {
7755 return self.Value
7756}
7757
7758func (self *NxmTcpSrc) SetValue(v uint16) {
7759 self.Value = v
7760}
7761
7762func (self *NxmTcpSrc) Serialize(encoder *goloxi.Encoder) error {
7763 if err := self.Oxm.Serialize(encoder); err != nil {
7764 return err
7765 }
7766
7767 encoder.PutUint16(uint16(self.Value))
7768
7769 return nil
7770}
7771
7772func DecodeNxmTcpSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpSrc, error) {
7773 _nxmtcpsrc := &NxmTcpSrc{Oxm: parent}
7774 if decoder.Length() < 2 {
7775 return nil, fmt.Errorf("NxmTcpSrc packet too short: %d < 2", decoder.Length())
7776 }
7777 _nxmtcpsrc.Value = uint16(decoder.ReadUint16())
7778 return _nxmtcpsrc, nil
7779}
7780
7781func NewNxmTcpSrc() *NxmTcpSrc {
7782 obj := &NxmTcpSrc{
7783 Oxm: NewOxm(4610),
7784 }
7785 return obj
7786}
7787func (self *NxmTcpSrc) GetOXMName() string {
7788 return "tcp_src"
7789}
7790
7791func (self *NxmTcpSrc) GetOXMValue() interface{} {
7792 return self.Value
7793}
7794
7795func (self *NxmTcpSrc) MarshalJSON() ([]byte, error) {
7796 value, err := jsonValue(self.GetOXMValue())
7797 if err != nil {
7798 return nil, err
7799 }
7800 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
7801}
7802
7803type NxmTcpSrcMasked struct {
7804 *Oxm
7805 Value uint16
7806 ValueMask uint16
7807}
7808
7809type INxmTcpSrcMasked interface {
7810 goloxi.IOxm
7811 GetValue() uint16
7812 GetValueMask() uint16
7813}
7814
7815func (self *NxmTcpSrcMasked) GetValue() uint16 {
7816 return self.Value
7817}
7818
7819func (self *NxmTcpSrcMasked) SetValue(v uint16) {
7820 self.Value = v
7821}
7822
7823func (self *NxmTcpSrcMasked) GetValueMask() uint16 {
7824 return self.ValueMask
7825}
7826
7827func (self *NxmTcpSrcMasked) SetValueMask(v uint16) {
7828 self.ValueMask = v
7829}
7830
7831func (self *NxmTcpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
7832 if err := self.Oxm.Serialize(encoder); err != nil {
7833 return err
7834 }
7835
7836 encoder.PutUint16(uint16(self.Value))
7837 encoder.PutUint16(uint16(self.ValueMask))
7838
7839 return nil
7840}
7841
7842func DecodeNxmTcpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTcpSrcMasked, error) {
7843 _nxmtcpsrcmasked := &NxmTcpSrcMasked{Oxm: parent}
7844 if decoder.Length() < 4 {
7845 return nil, fmt.Errorf("NxmTcpSrcMasked packet too short: %d < 4", decoder.Length())
7846 }
7847 _nxmtcpsrcmasked.Value = uint16(decoder.ReadUint16())
7848 _nxmtcpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
7849 return _nxmtcpsrcmasked, nil
7850}
7851
7852func NewNxmTcpSrcMasked() *NxmTcpSrcMasked {
7853 obj := &NxmTcpSrcMasked{
7854 Oxm: NewOxm(4868),
7855 }
7856 return obj
7857}
7858func (self *NxmTcpSrcMasked) GetOXMName() string {
7859 return "tcp_src_masked"
7860}
7861
7862func (self *NxmTcpSrcMasked) GetOXMValue() interface{} {
7863 return self.Value
7864}
7865
7866func (self *NxmTcpSrcMasked) GetOXMValueMask() interface{} {
7867 return self.ValueMask
7868}
7869
7870func (self *NxmTcpSrcMasked) MarshalJSON() ([]byte, error) {
7871 value, err := jsonValue(self.GetOXMValue())
7872 if err != nil {
7873 return nil, err
7874 }
7875 valueMask, err := jsonValue(self.GetOXMValueMask())
7876 if err != nil {
7877 return nil, err
7878 }
7879 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
7880}
7881
7882type NxmTunDst struct {
7883 *Oxm
7884 Value net.IP
7885}
7886
7887type INxmTunDst interface {
7888 goloxi.IOxm
7889 GetValue() net.IP
7890}
7891
7892func (self *NxmTunDst) GetValue() net.IP {
7893 return self.Value
7894}
7895
7896func (self *NxmTunDst) SetValue(v net.IP) {
7897 self.Value = v
7898}
7899
7900func (self *NxmTunDst) Serialize(encoder *goloxi.Encoder) error {
7901 if err := self.Oxm.Serialize(encoder); err != nil {
7902 return err
7903 }
7904
7905 encoder.Write(self.Value.To4())
7906
7907 return nil
7908}
7909
7910func DecodeNxmTunDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunDst, error) {
7911 _nxmtundst := &NxmTunDst{Oxm: parent}
7912 if decoder.Length() < 4 {
7913 return nil, fmt.Errorf("NxmTunDst packet too short: %d < 4", decoder.Length())
7914 }
7915 _nxmtundst.Value = net.IP(decoder.Read(4))
7916 return _nxmtundst, nil
7917}
7918
7919func NewNxmTunDst() *NxmTunDst {
7920 obj := &NxmTunDst{
7921 Oxm: NewOxm(81924),
7922 }
7923 return obj
7924}
7925func (self *NxmTunDst) GetOXMName() string {
7926 return "tun_dst"
7927}
7928
7929func (self *NxmTunDst) GetOXMValue() interface{} {
7930 return self.Value
7931}
7932
7933func (self *NxmTunDst) MarshalJSON() ([]byte, error) {
7934 value, err := jsonValue(self.GetOXMValue())
7935 if err != nil {
7936 return nil, err
7937 }
7938 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
7939}
7940
7941type NxmTunDstMasked struct {
7942 *Oxm
7943 Value net.IP
7944 ValueMask net.IP
7945}
7946
7947type INxmTunDstMasked interface {
7948 goloxi.IOxm
7949 GetValue() net.IP
7950 GetValueMask() net.IP
7951}
7952
7953func (self *NxmTunDstMasked) GetValue() net.IP {
7954 return self.Value
7955}
7956
7957func (self *NxmTunDstMasked) SetValue(v net.IP) {
7958 self.Value = v
7959}
7960
7961func (self *NxmTunDstMasked) GetValueMask() net.IP {
7962 return self.ValueMask
7963}
7964
7965func (self *NxmTunDstMasked) SetValueMask(v net.IP) {
7966 self.ValueMask = v
7967}
7968
7969func (self *NxmTunDstMasked) Serialize(encoder *goloxi.Encoder) error {
7970 if err := self.Oxm.Serialize(encoder); err != nil {
7971 return err
7972 }
7973
7974 encoder.Write(self.Value.To4())
7975 encoder.Write(self.ValueMask.To4())
7976
7977 return nil
7978}
7979
7980func DecodeNxmTunDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunDstMasked, error) {
7981 _nxmtundstmasked := &NxmTunDstMasked{Oxm: parent}
7982 if decoder.Length() < 8 {
7983 return nil, fmt.Errorf("NxmTunDstMasked packet too short: %d < 8", decoder.Length())
7984 }
7985 _nxmtundstmasked.Value = net.IP(decoder.Read(4))
7986 _nxmtundstmasked.ValueMask = net.IP(decoder.Read(4))
7987 return _nxmtundstmasked, nil
7988}
7989
7990func NewNxmTunDstMasked() *NxmTunDstMasked {
7991 obj := &NxmTunDstMasked{
7992 Oxm: NewOxm(82184),
7993 }
7994 return obj
7995}
7996func (self *NxmTunDstMasked) GetOXMName() string {
7997 return "tun_dst_masked"
7998}
7999
8000func (self *NxmTunDstMasked) GetOXMValue() interface{} {
8001 return self.Value
8002}
8003
8004func (self *NxmTunDstMasked) GetOXMValueMask() interface{} {
8005 return self.ValueMask
8006}
8007
8008func (self *NxmTunDstMasked) MarshalJSON() ([]byte, error) {
8009 value, err := jsonValue(self.GetOXMValue())
8010 if err != nil {
8011 return nil, err
8012 }
8013 valueMask, err := jsonValue(self.GetOXMValueMask())
8014 if err != nil {
8015 return nil, err
8016 }
8017 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
8018}
8019
8020type NxmTunFlags struct {
8021 *Oxm
8022 Value uint16
8023}
8024
8025type INxmTunFlags interface {
8026 goloxi.IOxm
8027 GetValue() uint16
8028}
8029
8030func (self *NxmTunFlags) GetValue() uint16 {
8031 return self.Value
8032}
8033
8034func (self *NxmTunFlags) SetValue(v uint16) {
8035 self.Value = v
8036}
8037
8038func (self *NxmTunFlags) Serialize(encoder *goloxi.Encoder) error {
8039 if err := self.Oxm.Serialize(encoder); err != nil {
8040 return err
8041 }
8042
8043 encoder.PutUint16(uint16(self.Value))
8044
8045 return nil
8046}
8047
8048func DecodeNxmTunFlags(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunFlags, error) {
8049 _nxmtunflags := &NxmTunFlags{Oxm: parent}
8050 if decoder.Length() < 2 {
8051 return nil, fmt.Errorf("NxmTunFlags packet too short: %d < 2", decoder.Length())
8052 }
8053 _nxmtunflags.Value = uint16(decoder.ReadUint16())
8054 return _nxmtunflags, nil
8055}
8056
8057func NewNxmTunFlags() *NxmTunFlags {
8058 obj := &NxmTunFlags{
8059 Oxm: NewOxm(118786),
8060 }
8061 return obj
8062}
8063func (self *NxmTunFlags) GetOXMName() string {
8064 return "tun_flags"
8065}
8066
8067func (self *NxmTunFlags) GetOXMValue() interface{} {
8068 return self.Value
8069}
8070
8071func (self *NxmTunFlags) MarshalJSON() ([]byte, error) {
8072 value, err := jsonValue(self.GetOXMValue())
8073 if err != nil {
8074 return nil, err
8075 }
8076 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
8077}
8078
8079type NxmTunFlagsMasked struct {
8080 *Oxm
8081 Value uint16
8082 ValueMask uint16
8083}
8084
8085type INxmTunFlagsMasked interface {
8086 goloxi.IOxm
8087 GetValue() uint16
8088 GetValueMask() uint16
8089}
8090
8091func (self *NxmTunFlagsMasked) GetValue() uint16 {
8092 return self.Value
8093}
8094
8095func (self *NxmTunFlagsMasked) SetValue(v uint16) {
8096 self.Value = v
8097}
8098
8099func (self *NxmTunFlagsMasked) GetValueMask() uint16 {
8100 return self.ValueMask
8101}
8102
8103func (self *NxmTunFlagsMasked) SetValueMask(v uint16) {
8104 self.ValueMask = v
8105}
8106
8107func (self *NxmTunFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
8108 if err := self.Oxm.Serialize(encoder); err != nil {
8109 return err
8110 }
8111
8112 encoder.PutUint16(uint16(self.Value))
8113 encoder.PutUint16(uint16(self.ValueMask))
8114
8115 return nil
8116}
8117
8118func DecodeNxmTunFlagsMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunFlagsMasked, error) {
8119 _nxmtunflagsmasked := &NxmTunFlagsMasked{Oxm: parent}
8120 if decoder.Length() < 4 {
8121 return nil, fmt.Errorf("NxmTunFlagsMasked packet too short: %d < 4", decoder.Length())
8122 }
8123 _nxmtunflagsmasked.Value = uint16(decoder.ReadUint16())
8124 _nxmtunflagsmasked.ValueMask = uint16(decoder.ReadUint16())
8125 return _nxmtunflagsmasked, nil
8126}
8127
8128func NewNxmTunFlagsMasked() *NxmTunFlagsMasked {
8129 obj := &NxmTunFlagsMasked{
8130 Oxm: NewOxm(119044),
8131 }
8132 return obj
8133}
8134func (self *NxmTunFlagsMasked) GetOXMName() string {
8135 return "tun_flags_masked"
8136}
8137
8138func (self *NxmTunFlagsMasked) GetOXMValue() interface{} {
8139 return self.Value
8140}
8141
8142func (self *NxmTunFlagsMasked) GetOXMValueMask() interface{} {
8143 return self.ValueMask
8144}
8145
8146func (self *NxmTunFlagsMasked) MarshalJSON() ([]byte, error) {
8147 value, err := jsonValue(self.GetOXMValue())
8148 if err != nil {
8149 return nil, err
8150 }
8151 valueMask, err := jsonValue(self.GetOXMValueMask())
8152 if err != nil {
8153 return nil, err
8154 }
8155 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
8156}
8157
8158type NxmTunGbpFlags struct {
8159 *Oxm
8160 Value uint8
8161}
8162
8163type INxmTunGbpFlags interface {
8164 goloxi.IOxm
8165 GetValue() uint8
8166}
8167
8168func (self *NxmTunGbpFlags) GetValue() uint8 {
8169 return self.Value
8170}
8171
8172func (self *NxmTunGbpFlags) SetValue(v uint8) {
8173 self.Value = v
8174}
8175
8176func (self *NxmTunGbpFlags) Serialize(encoder *goloxi.Encoder) error {
8177 if err := self.Oxm.Serialize(encoder); err != nil {
8178 return err
8179 }
8180
8181 encoder.PutUint8(uint8(self.Value))
8182
8183 return nil
8184}
8185
8186func DecodeNxmTunGbpFlags(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunGbpFlags, error) {
8187 _nxmtungbpflags := &NxmTunGbpFlags{Oxm: parent}
8188 if decoder.Length() < 1 {
8189 return nil, fmt.Errorf("NxmTunGbpFlags packet too short: %d < 1", decoder.Length())
8190 }
8191 _nxmtungbpflags.Value = uint8(decoder.ReadByte())
8192 return _nxmtungbpflags, nil
8193}
8194
8195func NewNxmTunGbpFlags() *NxmTunGbpFlags {
8196 obj := &NxmTunGbpFlags{
8197 Oxm: NewOxm(85505),
8198 }
8199 return obj
8200}
8201func (self *NxmTunGbpFlags) GetOXMName() string {
8202 return "tun_gbp_flags"
8203}
8204
8205func (self *NxmTunGbpFlags) GetOXMValue() interface{} {
8206 return self.Value
8207}
8208
8209func (self *NxmTunGbpFlags) MarshalJSON() ([]byte, error) {
8210 value, err := jsonValue(self.GetOXMValue())
8211 if err != nil {
8212 return nil, err
8213 }
8214 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
8215}
8216
8217type NxmTunGbpFlagsMasked struct {
8218 *Oxm
8219 Value uint8
8220 ValueMask uint8
8221}
8222
8223type INxmTunGbpFlagsMasked interface {
8224 goloxi.IOxm
8225 GetValue() uint8
8226 GetValueMask() uint8
8227}
8228
8229func (self *NxmTunGbpFlagsMasked) GetValue() uint8 {
8230 return self.Value
8231}
8232
8233func (self *NxmTunGbpFlagsMasked) SetValue(v uint8) {
8234 self.Value = v
8235}
8236
8237func (self *NxmTunGbpFlagsMasked) GetValueMask() uint8 {
8238 return self.ValueMask
8239}
8240
8241func (self *NxmTunGbpFlagsMasked) SetValueMask(v uint8) {
8242 self.ValueMask = v
8243}
8244
8245func (self *NxmTunGbpFlagsMasked) Serialize(encoder *goloxi.Encoder) error {
8246 if err := self.Oxm.Serialize(encoder); err != nil {
8247 return err
8248 }
8249
8250 encoder.PutUint8(uint8(self.Value))
8251 encoder.PutUint8(uint8(self.ValueMask))
8252
8253 return nil
8254}
8255
8256func DecodeNxmTunGbpFlagsMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunGbpFlagsMasked, error) {
8257 _nxmtungbpflagsmasked := &NxmTunGbpFlagsMasked{Oxm: parent}
8258 if decoder.Length() < 2 {
8259 return nil, fmt.Errorf("NxmTunGbpFlagsMasked packet too short: %d < 2", decoder.Length())
8260 }
8261 _nxmtungbpflagsmasked.Value = uint8(decoder.ReadByte())
8262 _nxmtungbpflagsmasked.ValueMask = uint8(decoder.ReadByte())
8263 return _nxmtungbpflagsmasked, nil
8264}
8265
8266func NewNxmTunGbpFlagsMasked() *NxmTunGbpFlagsMasked {
8267 obj := &NxmTunGbpFlagsMasked{
8268 Oxm: NewOxm(85762),
8269 }
8270 return obj
8271}
8272func (self *NxmTunGbpFlagsMasked) GetOXMName() string {
8273 return "tun_gbp_flags_masked"
8274}
8275
8276func (self *NxmTunGbpFlagsMasked) GetOXMValue() interface{} {
8277 return self.Value
8278}
8279
8280func (self *NxmTunGbpFlagsMasked) GetOXMValueMask() interface{} {
8281 return self.ValueMask
8282}
8283
8284func (self *NxmTunGbpFlagsMasked) MarshalJSON() ([]byte, error) {
8285 value, err := jsonValue(self.GetOXMValue())
8286 if err != nil {
8287 return nil, err
8288 }
8289 valueMask, err := jsonValue(self.GetOXMValueMask())
8290 if err != nil {
8291 return nil, err
8292 }
8293 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
8294}
8295
8296type NxmTunGbpId struct {
8297 *Oxm
8298 Value uint16
8299}
8300
8301type INxmTunGbpId interface {
8302 goloxi.IOxm
8303 GetValue() uint16
8304}
8305
8306func (self *NxmTunGbpId) GetValue() uint16 {
8307 return self.Value
8308}
8309
8310func (self *NxmTunGbpId) SetValue(v uint16) {
8311 self.Value = v
8312}
8313
8314func (self *NxmTunGbpId) Serialize(encoder *goloxi.Encoder) error {
8315 if err := self.Oxm.Serialize(encoder); err != nil {
8316 return err
8317 }
8318
8319 encoder.PutUint16(uint16(self.Value))
8320
8321 return nil
8322}
8323
8324func DecodeNxmTunGbpId(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunGbpId, error) {
8325 _nxmtungbpid := &NxmTunGbpId{Oxm: parent}
8326 if decoder.Length() < 2 {
8327 return nil, fmt.Errorf("NxmTunGbpId packet too short: %d < 2", decoder.Length())
8328 }
8329 _nxmtungbpid.Value = uint16(decoder.ReadUint16())
8330 return _nxmtungbpid, nil
8331}
8332
8333func NewNxmTunGbpId() *NxmTunGbpId {
8334 obj := &NxmTunGbpId{
8335 Oxm: NewOxm(84994),
8336 }
8337 return obj
8338}
8339func (self *NxmTunGbpId) GetOXMName() string {
8340 return "tun_gbp_id"
8341}
8342
8343func (self *NxmTunGbpId) GetOXMValue() interface{} {
8344 return self.Value
8345}
8346
8347func (self *NxmTunGbpId) MarshalJSON() ([]byte, error) {
8348 value, err := jsonValue(self.GetOXMValue())
8349 if err != nil {
8350 return nil, err
8351 }
8352 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
8353}
8354
8355type NxmTunGbpIdMasked struct {
8356 *Oxm
8357 Value uint16
8358 ValueMask uint16
8359}
8360
8361type INxmTunGbpIdMasked interface {
8362 goloxi.IOxm
8363 GetValue() uint16
8364 GetValueMask() uint16
8365}
8366
8367func (self *NxmTunGbpIdMasked) GetValue() uint16 {
8368 return self.Value
8369}
8370
8371func (self *NxmTunGbpIdMasked) SetValue(v uint16) {
8372 self.Value = v
8373}
8374
8375func (self *NxmTunGbpIdMasked) GetValueMask() uint16 {
8376 return self.ValueMask
8377}
8378
8379func (self *NxmTunGbpIdMasked) SetValueMask(v uint16) {
8380 self.ValueMask = v
8381}
8382
8383func (self *NxmTunGbpIdMasked) Serialize(encoder *goloxi.Encoder) error {
8384 if err := self.Oxm.Serialize(encoder); err != nil {
8385 return err
8386 }
8387
8388 encoder.PutUint16(uint16(self.Value))
8389 encoder.PutUint16(uint16(self.ValueMask))
8390
8391 return nil
8392}
8393
8394func DecodeNxmTunGbpIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunGbpIdMasked, error) {
8395 _nxmtungbpidmasked := &NxmTunGbpIdMasked{Oxm: parent}
8396 if decoder.Length() < 4 {
8397 return nil, fmt.Errorf("NxmTunGbpIdMasked packet too short: %d < 4", decoder.Length())
8398 }
8399 _nxmtungbpidmasked.Value = uint16(decoder.ReadUint16())
8400 _nxmtungbpidmasked.ValueMask = uint16(decoder.ReadUint16())
8401 return _nxmtungbpidmasked, nil
8402}
8403
8404func NewNxmTunGbpIdMasked() *NxmTunGbpIdMasked {
8405 obj := &NxmTunGbpIdMasked{
8406 Oxm: NewOxm(85252),
8407 }
8408 return obj
8409}
8410func (self *NxmTunGbpIdMasked) GetOXMName() string {
8411 return "tun_gbp_id_masked"
8412}
8413
8414func (self *NxmTunGbpIdMasked) GetOXMValue() interface{} {
8415 return self.Value
8416}
8417
8418func (self *NxmTunGbpIdMasked) GetOXMValueMask() interface{} {
8419 return self.ValueMask
8420}
8421
8422func (self *NxmTunGbpIdMasked) MarshalJSON() ([]byte, error) {
8423 value, err := jsonValue(self.GetOXMValue())
8424 if err != nil {
8425 return nil, err
8426 }
8427 valueMask, err := jsonValue(self.GetOXMValueMask())
8428 if err != nil {
8429 return nil, err
8430 }
8431 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
8432}
8433
8434type NxmTunId struct {
8435 *Oxm
8436 Value uint64
8437}
8438
8439type INxmTunId interface {
8440 goloxi.IOxm
8441 GetValue() uint64
8442}
8443
8444func (self *NxmTunId) GetValue() uint64 {
8445 return self.Value
8446}
8447
8448func (self *NxmTunId) SetValue(v uint64) {
8449 self.Value = v
8450}
8451
8452func (self *NxmTunId) Serialize(encoder *goloxi.Encoder) error {
8453 if err := self.Oxm.Serialize(encoder); err != nil {
8454 return err
8455 }
8456
8457 encoder.PutUint64(uint64(self.Value))
8458
8459 return nil
8460}
8461
8462func DecodeNxmTunId(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunId, error) {
8463 _nxmtunid := &NxmTunId{Oxm: parent}
8464 if decoder.Length() < 8 {
8465 return nil, fmt.Errorf("NxmTunId packet too short: %d < 8", decoder.Length())
8466 }
8467 _nxmtunid.Value = uint64(decoder.ReadUint64())
8468 return _nxmtunid, nil
8469}
8470
8471func NewNxmTunId() *NxmTunId {
8472 obj := &NxmTunId{
8473 Oxm: NewOxm(73736),
8474 }
8475 return obj
8476}
8477func (self *NxmTunId) GetOXMName() string {
8478 return "tun_id"
8479}
8480
8481func (self *NxmTunId) GetOXMValue() interface{} {
8482 return self.Value
8483}
8484
8485func (self *NxmTunId) MarshalJSON() ([]byte, error) {
8486 value, err := jsonValue(self.GetOXMValue())
8487 if err != nil {
8488 return nil, err
8489 }
8490 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
8491}
8492
8493type NxmTunIdMasked struct {
8494 *Oxm
8495 Value uint64
8496 ValueMask uint64
8497}
8498
8499type INxmTunIdMasked interface {
8500 goloxi.IOxm
8501 GetValue() uint64
8502 GetValueMask() uint64
8503}
8504
8505func (self *NxmTunIdMasked) GetValue() uint64 {
8506 return self.Value
8507}
8508
8509func (self *NxmTunIdMasked) SetValue(v uint64) {
8510 self.Value = v
8511}
8512
8513func (self *NxmTunIdMasked) GetValueMask() uint64 {
8514 return self.ValueMask
8515}
8516
8517func (self *NxmTunIdMasked) SetValueMask(v uint64) {
8518 self.ValueMask = v
8519}
8520
8521func (self *NxmTunIdMasked) Serialize(encoder *goloxi.Encoder) error {
8522 if err := self.Oxm.Serialize(encoder); err != nil {
8523 return err
8524 }
8525
8526 encoder.PutUint64(uint64(self.Value))
8527 encoder.PutUint64(uint64(self.ValueMask))
8528
8529 return nil
8530}
8531
8532func DecodeNxmTunIdMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunIdMasked, error) {
8533 _nxmtunidmasked := &NxmTunIdMasked{Oxm: parent}
8534 if decoder.Length() < 16 {
8535 return nil, fmt.Errorf("NxmTunIdMasked packet too short: %d < 16", decoder.Length())
8536 }
8537 _nxmtunidmasked.Value = uint64(decoder.ReadUint64())
8538 _nxmtunidmasked.ValueMask = uint64(decoder.ReadUint64())
8539 return _nxmtunidmasked, nil
8540}
8541
8542func NewNxmTunIdMasked() *NxmTunIdMasked {
8543 obj := &NxmTunIdMasked{
8544 Oxm: NewOxm(74000),
8545 }
8546 return obj
8547}
8548func (self *NxmTunIdMasked) GetOXMName() string {
8549 return "tun_id_masked"
8550}
8551
8552func (self *NxmTunIdMasked) GetOXMValue() interface{} {
8553 return self.Value
8554}
8555
8556func (self *NxmTunIdMasked) GetOXMValueMask() interface{} {
8557 return self.ValueMask
8558}
8559
8560func (self *NxmTunIdMasked) MarshalJSON() ([]byte, error) {
8561 value, err := jsonValue(self.GetOXMValue())
8562 if err != nil {
8563 return nil, err
8564 }
8565 valueMask, err := jsonValue(self.GetOXMValueMask())
8566 if err != nil {
8567 return nil, err
8568 }
8569 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
8570}
8571
8572type NxmTunIpv6Dst struct {
8573 *Oxm
8574 Value net.IP
8575}
8576
8577type INxmTunIpv6Dst interface {
8578 goloxi.IOxm
8579 GetValue() net.IP
8580}
8581
8582func (self *NxmTunIpv6Dst) GetValue() net.IP {
8583 return self.Value
8584}
8585
8586func (self *NxmTunIpv6Dst) SetValue(v net.IP) {
8587 self.Value = v
8588}
8589
8590func (self *NxmTunIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
8591 if err := self.Oxm.Serialize(encoder); err != nil {
8592 return err
8593 }
8594
8595 encoder.Write(self.Value.To16())
8596
8597 return nil
8598}
8599
8600func DecodeNxmTunIpv6Dst(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunIpv6Dst, error) {
8601 _nxmtunipv6dst := &NxmTunIpv6Dst{Oxm: parent}
8602 if decoder.Length() < 16 {
8603 return nil, fmt.Errorf("NxmTunIpv6Dst packet too short: %d < 16", decoder.Length())
8604 }
8605 _nxmtunipv6dst.Value = net.IP(decoder.Read(16))
8606 return _nxmtunipv6dst, nil
8607}
8608
8609func NewNxmTunIpv6Dst() *NxmTunIpv6Dst {
8610 obj := &NxmTunIpv6Dst{
8611 Oxm: NewOxm(121872),
8612 }
8613 return obj
8614}
8615func (self *NxmTunIpv6Dst) GetOXMName() string {
8616 return "tun_ipv6_dst"
8617}
8618
8619func (self *NxmTunIpv6Dst) GetOXMValue() interface{} {
8620 return self.Value
8621}
8622
8623func (self *NxmTunIpv6Dst) MarshalJSON() ([]byte, error) {
8624 value, err := jsonValue(self.GetOXMValue())
8625 if err != nil {
8626 return nil, err
8627 }
8628 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
8629}
8630
8631type NxmTunIpv6DstMasked struct {
8632 *Oxm
8633 Value net.IP
8634 ValueMask net.IP
8635}
8636
8637type INxmTunIpv6DstMasked interface {
8638 goloxi.IOxm
8639 GetValue() net.IP
8640 GetValueMask() net.IP
8641}
8642
8643func (self *NxmTunIpv6DstMasked) GetValue() net.IP {
8644 return self.Value
8645}
8646
8647func (self *NxmTunIpv6DstMasked) SetValue(v net.IP) {
8648 self.Value = v
8649}
8650
8651func (self *NxmTunIpv6DstMasked) GetValueMask() net.IP {
8652 return self.ValueMask
8653}
8654
8655func (self *NxmTunIpv6DstMasked) SetValueMask(v net.IP) {
8656 self.ValueMask = v
8657}
8658
8659func (self *NxmTunIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
8660 if err := self.Oxm.Serialize(encoder); err != nil {
8661 return err
8662 }
8663
8664 encoder.Write(self.Value.To16())
8665 encoder.Write(self.ValueMask.To16())
8666
8667 return nil
8668}
8669
8670func DecodeNxmTunIpv6DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunIpv6DstMasked, error) {
8671 _nxmtunipv6dstmasked := &NxmTunIpv6DstMasked{Oxm: parent}
8672 if decoder.Length() < 32 {
8673 return nil, fmt.Errorf("NxmTunIpv6DstMasked packet too short: %d < 32", decoder.Length())
8674 }
8675 _nxmtunipv6dstmasked.Value = net.IP(decoder.Read(16))
8676 _nxmtunipv6dstmasked.ValueMask = net.IP(decoder.Read(16))
8677 return _nxmtunipv6dstmasked, nil
8678}
8679
8680func NewNxmTunIpv6DstMasked() *NxmTunIpv6DstMasked {
8681 obj := &NxmTunIpv6DstMasked{
8682 Oxm: NewOxm(122144),
8683 }
8684 return obj
8685}
8686func (self *NxmTunIpv6DstMasked) GetOXMName() string {
8687 return "tun_ipv6_dst_masked"
8688}
8689
8690func (self *NxmTunIpv6DstMasked) GetOXMValue() interface{} {
8691 return self.Value
8692}
8693
8694func (self *NxmTunIpv6DstMasked) GetOXMValueMask() interface{} {
8695 return self.ValueMask
8696}
8697
8698func (self *NxmTunIpv6DstMasked) MarshalJSON() ([]byte, error) {
8699 value, err := jsonValue(self.GetOXMValue())
8700 if err != nil {
8701 return nil, err
8702 }
8703 valueMask, err := jsonValue(self.GetOXMValueMask())
8704 if err != nil {
8705 return nil, err
8706 }
8707 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
8708}
8709
8710type NxmTunIpv6Src struct {
8711 *Oxm
8712 Value net.IP
8713}
8714
8715type INxmTunIpv6Src interface {
8716 goloxi.IOxm
8717 GetValue() net.IP
8718}
8719
8720func (self *NxmTunIpv6Src) GetValue() net.IP {
8721 return self.Value
8722}
8723
8724func (self *NxmTunIpv6Src) SetValue(v net.IP) {
8725 self.Value = v
8726}
8727
8728func (self *NxmTunIpv6Src) Serialize(encoder *goloxi.Encoder) error {
8729 if err := self.Oxm.Serialize(encoder); err != nil {
8730 return err
8731 }
8732
8733 encoder.Write(self.Value.To16())
8734
8735 return nil
8736}
8737
8738func DecodeNxmTunIpv6Src(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunIpv6Src, error) {
8739 _nxmtunipv6src := &NxmTunIpv6Src{Oxm: parent}
8740 if decoder.Length() < 16 {
8741 return nil, fmt.Errorf("NxmTunIpv6Src packet too short: %d < 16", decoder.Length())
8742 }
8743 _nxmtunipv6src.Value = net.IP(decoder.Read(16))
8744 return _nxmtunipv6src, nil
8745}
8746
8747func NewNxmTunIpv6Src() *NxmTunIpv6Src {
8748 obj := &NxmTunIpv6Src{
8749 Oxm: NewOxm(121360),
8750 }
8751 return obj
8752}
8753func (self *NxmTunIpv6Src) GetOXMName() string {
8754 return "tun_ipv6_src"
8755}
8756
8757func (self *NxmTunIpv6Src) GetOXMValue() interface{} {
8758 return self.Value
8759}
8760
8761func (self *NxmTunIpv6Src) MarshalJSON() ([]byte, error) {
8762 value, err := jsonValue(self.GetOXMValue())
8763 if err != nil {
8764 return nil, err
8765 }
8766 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
8767}
8768
8769type NxmTunIpv6SrcMasked struct {
8770 *Oxm
8771 Value net.IP
8772 ValueMask net.IP
8773}
8774
8775type INxmTunIpv6SrcMasked interface {
8776 goloxi.IOxm
8777 GetValue() net.IP
8778 GetValueMask() net.IP
8779}
8780
8781func (self *NxmTunIpv6SrcMasked) GetValue() net.IP {
8782 return self.Value
8783}
8784
8785func (self *NxmTunIpv6SrcMasked) SetValue(v net.IP) {
8786 self.Value = v
8787}
8788
8789func (self *NxmTunIpv6SrcMasked) GetValueMask() net.IP {
8790 return self.ValueMask
8791}
8792
8793func (self *NxmTunIpv6SrcMasked) SetValueMask(v net.IP) {
8794 self.ValueMask = v
8795}
8796
8797func (self *NxmTunIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
8798 if err := self.Oxm.Serialize(encoder); err != nil {
8799 return err
8800 }
8801
8802 encoder.Write(self.Value.To16())
8803 encoder.Write(self.ValueMask.To16())
8804
8805 return nil
8806}
8807
8808func DecodeNxmTunIpv6SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunIpv6SrcMasked, error) {
8809 _nxmtunipv6srcmasked := &NxmTunIpv6SrcMasked{Oxm: parent}
8810 if decoder.Length() < 32 {
8811 return nil, fmt.Errorf("NxmTunIpv6SrcMasked packet too short: %d < 32", decoder.Length())
8812 }
8813 _nxmtunipv6srcmasked.Value = net.IP(decoder.Read(16))
8814 _nxmtunipv6srcmasked.ValueMask = net.IP(decoder.Read(16))
8815 return _nxmtunipv6srcmasked, nil
8816}
8817
8818func NewNxmTunIpv6SrcMasked() *NxmTunIpv6SrcMasked {
8819 obj := &NxmTunIpv6SrcMasked{
8820 Oxm: NewOxm(121632),
8821 }
8822 return obj
8823}
8824func (self *NxmTunIpv6SrcMasked) GetOXMName() string {
8825 return "tun_ipv6_src_masked"
8826}
8827
8828func (self *NxmTunIpv6SrcMasked) GetOXMValue() interface{} {
8829 return self.Value
8830}
8831
8832func (self *NxmTunIpv6SrcMasked) GetOXMValueMask() interface{} {
8833 return self.ValueMask
8834}
8835
8836func (self *NxmTunIpv6SrcMasked) MarshalJSON() ([]byte, error) {
8837 value, err := jsonValue(self.GetOXMValue())
8838 if err != nil {
8839 return nil, err
8840 }
8841 valueMask, err := jsonValue(self.GetOXMValueMask())
8842 if err != nil {
8843 return nil, err
8844 }
8845 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
8846}
8847
8848type NxmTunMetadata0 struct {
8849 *Oxm
8850 Value []byte
8851}
8852
8853type INxmTunMetadata0 interface {
8854 goloxi.IOxm
8855 GetValue() []byte
8856}
8857
8858func (self *NxmTunMetadata0) GetValue() []byte {
8859 return self.Value
8860}
8861
8862func (self *NxmTunMetadata0) SetValue(v []byte) {
8863 self.Value = v
8864}
8865
8866func (self *NxmTunMetadata0) Serialize(encoder *goloxi.Encoder) error {
8867 if err := self.Oxm.Serialize(encoder); err != nil {
8868 return err
8869 }
8870
8871 encoder.Write(self.Value)
8872
8873 return nil
8874}
8875
8876func DecodeNxmTunMetadata0(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata0, error) {
8877 _nxmtunmetadata0 := &NxmTunMetadata0{Oxm: parent}
8878 _nxmtunmetadata0.Value = decoder.Read(int(_nxmtunmetadata0.TypeLen & 0xFF))
8879 return _nxmtunmetadata0, nil
8880}
8881
8882func NewNxmTunMetadata0() *NxmTunMetadata0 {
8883 obj := &NxmTunMetadata0{
8884 Oxm: NewOxm(86140),
8885 }
8886 return obj
8887}
8888func (self *NxmTunMetadata0) GetOXMName() string {
8889 return "tun_metadata0"
8890}
8891
8892func (self *NxmTunMetadata0) GetOXMValue() interface{} {
8893 return self.Value
8894}
8895
8896func (self *NxmTunMetadata0) MarshalJSON() ([]byte, error) {
8897 value, err := jsonValue(self.GetOXMValue())
8898 if err != nil {
8899 return nil, err
8900 }
8901 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
8902}
8903
8904type NxmTunMetadata0Masked struct {
8905 *Oxm
8906 Value []byte
8907 ValueMask []byte
8908}
8909
8910type INxmTunMetadata0Masked interface {
8911 goloxi.IOxm
8912 GetValue() []byte
8913 GetValueMask() []byte
8914}
8915
8916func (self *NxmTunMetadata0Masked) GetValue() []byte {
8917 return self.Value
8918}
8919
8920func (self *NxmTunMetadata0Masked) SetValue(v []byte) {
8921 self.Value = v
8922}
8923
8924func (self *NxmTunMetadata0Masked) GetValueMask() []byte {
8925 return self.ValueMask
8926}
8927
8928func (self *NxmTunMetadata0Masked) SetValueMask(v []byte) {
8929 self.ValueMask = v
8930}
8931
8932func (self *NxmTunMetadata0Masked) Serialize(encoder *goloxi.Encoder) error {
8933 if err := self.Oxm.Serialize(encoder); err != nil {
8934 return err
8935 }
8936
8937 encoder.Write(self.Value)
8938 encoder.Write(self.ValueMask)
8939
8940 return nil
8941}
8942
8943func DecodeNxmTunMetadata0Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata0Masked, error) {
8944 _nxmtunmetadata0masked := &NxmTunMetadata0Masked{Oxm: parent}
8945 _nxmtunmetadata0masked.Value = decoder.Read(int(_nxmtunmetadata0masked.TypeLen & 0xFF))
8946 _nxmtunmetadata0masked.ValueMask = decoder.Read(int(_nxmtunmetadata0masked.TypeLen & 0xFF))
8947 return _nxmtunmetadata0masked, nil
8948}
8949
8950func NewNxmTunMetadata0Masked() *NxmTunMetadata0Masked {
8951 obj := &NxmTunMetadata0Masked{
8952 Oxm: NewOxm(86520),
8953 }
8954 return obj
8955}
8956func (self *NxmTunMetadata0Masked) GetOXMName() string {
8957 return "tun_metadata0_masked"
8958}
8959
8960func (self *NxmTunMetadata0Masked) GetOXMValue() interface{} {
8961 return self.Value
8962}
8963
8964func (self *NxmTunMetadata0Masked) GetOXMValueMask() interface{} {
8965 return self.ValueMask
8966}
8967
8968func (self *NxmTunMetadata0Masked) MarshalJSON() ([]byte, error) {
8969 value, err := jsonValue(self.GetOXMValue())
8970 if err != nil {
8971 return nil, err
8972 }
8973 valueMask, err := jsonValue(self.GetOXMValueMask())
8974 if err != nil {
8975 return nil, err
8976 }
8977 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
8978}
8979
8980type NxmTunMetadata1 struct {
8981 *Oxm
8982 Value []byte
8983}
8984
8985type INxmTunMetadata1 interface {
8986 goloxi.IOxm
8987 GetValue() []byte
8988}
8989
8990func (self *NxmTunMetadata1) GetValue() []byte {
8991 return self.Value
8992}
8993
8994func (self *NxmTunMetadata1) SetValue(v []byte) {
8995 self.Value = v
8996}
8997
8998func (self *NxmTunMetadata1) Serialize(encoder *goloxi.Encoder) error {
8999 if err := self.Oxm.Serialize(encoder); err != nil {
9000 return err
9001 }
9002
9003 encoder.Write(self.Value)
9004
9005 return nil
9006}
9007
9008func DecodeNxmTunMetadata1(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata1, error) {
9009 _nxmtunmetadata1 := &NxmTunMetadata1{Oxm: parent}
9010 _nxmtunmetadata1.Value = decoder.Read(int(_nxmtunmetadata1.TypeLen & 0xFF))
9011 return _nxmtunmetadata1, nil
9012}
9013
9014func NewNxmTunMetadata1() *NxmTunMetadata1 {
9015 obj := &NxmTunMetadata1{
9016 Oxm: NewOxm(86652),
9017 }
9018 return obj
9019}
9020func (self *NxmTunMetadata1) GetOXMName() string {
9021 return "tun_metadata1"
9022}
9023
9024func (self *NxmTunMetadata1) GetOXMValue() interface{} {
9025 return self.Value
9026}
9027
9028func (self *NxmTunMetadata1) MarshalJSON() ([]byte, error) {
9029 value, err := jsonValue(self.GetOXMValue())
9030 if err != nil {
9031 return nil, err
9032 }
9033 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
9034}
9035
9036type NxmTunMetadata10 struct {
9037 *Oxm
9038 Value []byte
9039}
9040
9041type INxmTunMetadata10 interface {
9042 goloxi.IOxm
9043 GetValue() []byte
9044}
9045
9046func (self *NxmTunMetadata10) GetValue() []byte {
9047 return self.Value
9048}
9049
9050func (self *NxmTunMetadata10) SetValue(v []byte) {
9051 self.Value = v
9052}
9053
9054func (self *NxmTunMetadata10) Serialize(encoder *goloxi.Encoder) error {
9055 if err := self.Oxm.Serialize(encoder); err != nil {
9056 return err
9057 }
9058
9059 encoder.Write(self.Value)
9060
9061 return nil
9062}
9063
9064func DecodeNxmTunMetadata10(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata10, error) {
9065 _nxmtunmetadata10 := &NxmTunMetadata10{Oxm: parent}
9066 _nxmtunmetadata10.Value = decoder.Read(int(_nxmtunmetadata10.TypeLen & 0xFF))
9067 return _nxmtunmetadata10, nil
9068}
9069
9070func NewNxmTunMetadata10() *NxmTunMetadata10 {
9071 obj := &NxmTunMetadata10{
9072 Oxm: NewOxm(91260),
9073 }
9074 return obj
9075}
9076func (self *NxmTunMetadata10) GetOXMName() string {
9077 return "tun_metadata10"
9078}
9079
9080func (self *NxmTunMetadata10) GetOXMValue() interface{} {
9081 return self.Value
9082}
9083
9084func (self *NxmTunMetadata10) MarshalJSON() ([]byte, error) {
9085 value, err := jsonValue(self.GetOXMValue())
9086 if err != nil {
9087 return nil, err
9088 }
9089 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
9090}
9091
9092type NxmTunMetadata10Masked struct {
9093 *Oxm
9094 Value []byte
9095 ValueMask []byte
9096}
9097
9098type INxmTunMetadata10Masked interface {
9099 goloxi.IOxm
9100 GetValue() []byte
9101 GetValueMask() []byte
9102}
9103
9104func (self *NxmTunMetadata10Masked) GetValue() []byte {
9105 return self.Value
9106}
9107
9108func (self *NxmTunMetadata10Masked) SetValue(v []byte) {
9109 self.Value = v
9110}
9111
9112func (self *NxmTunMetadata10Masked) GetValueMask() []byte {
9113 return self.ValueMask
9114}
9115
9116func (self *NxmTunMetadata10Masked) SetValueMask(v []byte) {
9117 self.ValueMask = v
9118}
9119
9120func (self *NxmTunMetadata10Masked) Serialize(encoder *goloxi.Encoder) error {
9121 if err := self.Oxm.Serialize(encoder); err != nil {
9122 return err
9123 }
9124
9125 encoder.Write(self.Value)
9126 encoder.Write(self.ValueMask)
9127
9128 return nil
9129}
9130
9131func DecodeNxmTunMetadata10Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata10Masked, error) {
9132 _nxmtunmetadata10masked := &NxmTunMetadata10Masked{Oxm: parent}
9133 _nxmtunmetadata10masked.Value = decoder.Read(int(_nxmtunmetadata10masked.TypeLen & 0xFF))
9134 _nxmtunmetadata10masked.ValueMask = decoder.Read(int(_nxmtunmetadata10masked.TypeLen & 0xFF))
9135 return _nxmtunmetadata10masked, nil
9136}
9137
9138func NewNxmTunMetadata10Masked() *NxmTunMetadata10Masked {
9139 obj := &NxmTunMetadata10Masked{
9140 Oxm: NewOxm(91640),
9141 }
9142 return obj
9143}
9144func (self *NxmTunMetadata10Masked) GetOXMName() string {
9145 return "tun_metadata10_masked"
9146}
9147
9148func (self *NxmTunMetadata10Masked) GetOXMValue() interface{} {
9149 return self.Value
9150}
9151
9152func (self *NxmTunMetadata10Masked) GetOXMValueMask() interface{} {
9153 return self.ValueMask
9154}
9155
9156func (self *NxmTunMetadata10Masked) MarshalJSON() ([]byte, error) {
9157 value, err := jsonValue(self.GetOXMValue())
9158 if err != nil {
9159 return nil, err
9160 }
9161 valueMask, err := jsonValue(self.GetOXMValueMask())
9162 if err != nil {
9163 return nil, err
9164 }
9165 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
9166}
9167
9168type NxmTunMetadata11 struct {
9169 *Oxm
9170 Value []byte
9171}
9172
9173type INxmTunMetadata11 interface {
9174 goloxi.IOxm
9175 GetValue() []byte
9176}
9177
9178func (self *NxmTunMetadata11) GetValue() []byte {
9179 return self.Value
9180}
9181
9182func (self *NxmTunMetadata11) SetValue(v []byte) {
9183 self.Value = v
9184}
9185
9186func (self *NxmTunMetadata11) Serialize(encoder *goloxi.Encoder) error {
9187 if err := self.Oxm.Serialize(encoder); err != nil {
9188 return err
9189 }
9190
9191 encoder.Write(self.Value)
9192
9193 return nil
9194}
9195
9196func DecodeNxmTunMetadata11(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata11, error) {
9197 _nxmtunmetadata11 := &NxmTunMetadata11{Oxm: parent}
9198 _nxmtunmetadata11.Value = decoder.Read(int(_nxmtunmetadata11.TypeLen & 0xFF))
9199 return _nxmtunmetadata11, nil
9200}
9201
9202func NewNxmTunMetadata11() *NxmTunMetadata11 {
9203 obj := &NxmTunMetadata11{
9204 Oxm: NewOxm(91772),
9205 }
9206 return obj
9207}
9208func (self *NxmTunMetadata11) GetOXMName() string {
9209 return "tun_metadata11"
9210}
9211
9212func (self *NxmTunMetadata11) GetOXMValue() interface{} {
9213 return self.Value
9214}
9215
9216func (self *NxmTunMetadata11) MarshalJSON() ([]byte, error) {
9217 value, err := jsonValue(self.GetOXMValue())
9218 if err != nil {
9219 return nil, err
9220 }
9221 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
9222}
9223
9224type NxmTunMetadata11Masked struct {
9225 *Oxm
9226 Value []byte
9227 ValueMask []byte
9228}
9229
9230type INxmTunMetadata11Masked interface {
9231 goloxi.IOxm
9232 GetValue() []byte
9233 GetValueMask() []byte
9234}
9235
9236func (self *NxmTunMetadata11Masked) GetValue() []byte {
9237 return self.Value
9238}
9239
9240func (self *NxmTunMetadata11Masked) SetValue(v []byte) {
9241 self.Value = v
9242}
9243
9244func (self *NxmTunMetadata11Masked) GetValueMask() []byte {
9245 return self.ValueMask
9246}
9247
9248func (self *NxmTunMetadata11Masked) SetValueMask(v []byte) {
9249 self.ValueMask = v
9250}
9251
9252func (self *NxmTunMetadata11Masked) Serialize(encoder *goloxi.Encoder) error {
9253 if err := self.Oxm.Serialize(encoder); err != nil {
9254 return err
9255 }
9256
9257 encoder.Write(self.Value)
9258 encoder.Write(self.ValueMask)
9259
9260 return nil
9261}
9262
9263func DecodeNxmTunMetadata11Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata11Masked, error) {
9264 _nxmtunmetadata11masked := &NxmTunMetadata11Masked{Oxm: parent}
9265 _nxmtunmetadata11masked.Value = decoder.Read(int(_nxmtunmetadata11masked.TypeLen & 0xFF))
9266 _nxmtunmetadata11masked.ValueMask = decoder.Read(int(_nxmtunmetadata11masked.TypeLen & 0xFF))
9267 return _nxmtunmetadata11masked, nil
9268}
9269
9270func NewNxmTunMetadata11Masked() *NxmTunMetadata11Masked {
9271 obj := &NxmTunMetadata11Masked{
9272 Oxm: NewOxm(92152),
9273 }
9274 return obj
9275}
9276func (self *NxmTunMetadata11Masked) GetOXMName() string {
9277 return "tun_metadata11_masked"
9278}
9279
9280func (self *NxmTunMetadata11Masked) GetOXMValue() interface{} {
9281 return self.Value
9282}
9283
9284func (self *NxmTunMetadata11Masked) GetOXMValueMask() interface{} {
9285 return self.ValueMask
9286}
9287
9288func (self *NxmTunMetadata11Masked) MarshalJSON() ([]byte, error) {
9289 value, err := jsonValue(self.GetOXMValue())
9290 if err != nil {
9291 return nil, err
9292 }
9293 valueMask, err := jsonValue(self.GetOXMValueMask())
9294 if err != nil {
9295 return nil, err
9296 }
9297 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
9298}
9299
9300type NxmTunMetadata12 struct {
9301 *Oxm
9302 Value []byte
9303}
9304
9305type INxmTunMetadata12 interface {
9306 goloxi.IOxm
9307 GetValue() []byte
9308}
9309
9310func (self *NxmTunMetadata12) GetValue() []byte {
9311 return self.Value
9312}
9313
9314func (self *NxmTunMetadata12) SetValue(v []byte) {
9315 self.Value = v
9316}
9317
9318func (self *NxmTunMetadata12) Serialize(encoder *goloxi.Encoder) error {
9319 if err := self.Oxm.Serialize(encoder); err != nil {
9320 return err
9321 }
9322
9323 encoder.Write(self.Value)
9324
9325 return nil
9326}
9327
9328func DecodeNxmTunMetadata12(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata12, error) {
9329 _nxmtunmetadata12 := &NxmTunMetadata12{Oxm: parent}
9330 _nxmtunmetadata12.Value = decoder.Read(int(_nxmtunmetadata12.TypeLen & 0xFF))
9331 return _nxmtunmetadata12, nil
9332}
9333
9334func NewNxmTunMetadata12() *NxmTunMetadata12 {
9335 obj := &NxmTunMetadata12{
9336 Oxm: NewOxm(92284),
9337 }
9338 return obj
9339}
9340func (self *NxmTunMetadata12) GetOXMName() string {
9341 return "tun_metadata12"
9342}
9343
9344func (self *NxmTunMetadata12) GetOXMValue() interface{} {
9345 return self.Value
9346}
9347
9348func (self *NxmTunMetadata12) MarshalJSON() ([]byte, error) {
9349 value, err := jsonValue(self.GetOXMValue())
9350 if err != nil {
9351 return nil, err
9352 }
9353 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
9354}
9355
9356type NxmTunMetadata12Masked struct {
9357 *Oxm
9358 Value []byte
9359 ValueMask []byte
9360}
9361
9362type INxmTunMetadata12Masked interface {
9363 goloxi.IOxm
9364 GetValue() []byte
9365 GetValueMask() []byte
9366}
9367
9368func (self *NxmTunMetadata12Masked) GetValue() []byte {
9369 return self.Value
9370}
9371
9372func (self *NxmTunMetadata12Masked) SetValue(v []byte) {
9373 self.Value = v
9374}
9375
9376func (self *NxmTunMetadata12Masked) GetValueMask() []byte {
9377 return self.ValueMask
9378}
9379
9380func (self *NxmTunMetadata12Masked) SetValueMask(v []byte) {
9381 self.ValueMask = v
9382}
9383
9384func (self *NxmTunMetadata12Masked) Serialize(encoder *goloxi.Encoder) error {
9385 if err := self.Oxm.Serialize(encoder); err != nil {
9386 return err
9387 }
9388
9389 encoder.Write(self.Value)
9390 encoder.Write(self.ValueMask)
9391
9392 return nil
9393}
9394
9395func DecodeNxmTunMetadata12Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata12Masked, error) {
9396 _nxmtunmetadata12masked := &NxmTunMetadata12Masked{Oxm: parent}
9397 _nxmtunmetadata12masked.Value = decoder.Read(int(_nxmtunmetadata12masked.TypeLen & 0xFF))
9398 _nxmtunmetadata12masked.ValueMask = decoder.Read(int(_nxmtunmetadata12masked.TypeLen & 0xFF))
9399 return _nxmtunmetadata12masked, nil
9400}
9401
9402func NewNxmTunMetadata12Masked() *NxmTunMetadata12Masked {
9403 obj := &NxmTunMetadata12Masked{
9404 Oxm: NewOxm(92664),
9405 }
9406 return obj
9407}
9408func (self *NxmTunMetadata12Masked) GetOXMName() string {
9409 return "tun_metadata12_masked"
9410}
9411
9412func (self *NxmTunMetadata12Masked) GetOXMValue() interface{} {
9413 return self.Value
9414}
9415
9416func (self *NxmTunMetadata12Masked) GetOXMValueMask() interface{} {
9417 return self.ValueMask
9418}
9419
9420func (self *NxmTunMetadata12Masked) MarshalJSON() ([]byte, error) {
9421 value, err := jsonValue(self.GetOXMValue())
9422 if err != nil {
9423 return nil, err
9424 }
9425 valueMask, err := jsonValue(self.GetOXMValueMask())
9426 if err != nil {
9427 return nil, err
9428 }
9429 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
9430}
9431
9432type NxmTunMetadata13 struct {
9433 *Oxm
9434 Value []byte
9435}
9436
9437type INxmTunMetadata13 interface {
9438 goloxi.IOxm
9439 GetValue() []byte
9440}
9441
9442func (self *NxmTunMetadata13) GetValue() []byte {
9443 return self.Value
9444}
9445
9446func (self *NxmTunMetadata13) SetValue(v []byte) {
9447 self.Value = v
9448}
9449
9450func (self *NxmTunMetadata13) Serialize(encoder *goloxi.Encoder) error {
9451 if err := self.Oxm.Serialize(encoder); err != nil {
9452 return err
9453 }
9454
9455 encoder.Write(self.Value)
9456
9457 return nil
9458}
9459
9460func DecodeNxmTunMetadata13(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata13, error) {
9461 _nxmtunmetadata13 := &NxmTunMetadata13{Oxm: parent}
9462 _nxmtunmetadata13.Value = decoder.Read(int(_nxmtunmetadata13.TypeLen & 0xFF))
9463 return _nxmtunmetadata13, nil
9464}
9465
9466func NewNxmTunMetadata13() *NxmTunMetadata13 {
9467 obj := &NxmTunMetadata13{
9468 Oxm: NewOxm(92796),
9469 }
9470 return obj
9471}
9472func (self *NxmTunMetadata13) GetOXMName() string {
9473 return "tun_metadata13"
9474}
9475
9476func (self *NxmTunMetadata13) GetOXMValue() interface{} {
9477 return self.Value
9478}
9479
9480func (self *NxmTunMetadata13) MarshalJSON() ([]byte, error) {
9481 value, err := jsonValue(self.GetOXMValue())
9482 if err != nil {
9483 return nil, err
9484 }
9485 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
9486}
9487
9488type NxmTunMetadata13Masked struct {
9489 *Oxm
9490 Value []byte
9491 ValueMask []byte
9492}
9493
9494type INxmTunMetadata13Masked interface {
9495 goloxi.IOxm
9496 GetValue() []byte
9497 GetValueMask() []byte
9498}
9499
9500func (self *NxmTunMetadata13Masked) GetValue() []byte {
9501 return self.Value
9502}
9503
9504func (self *NxmTunMetadata13Masked) SetValue(v []byte) {
9505 self.Value = v
9506}
9507
9508func (self *NxmTunMetadata13Masked) GetValueMask() []byte {
9509 return self.ValueMask
9510}
9511
9512func (self *NxmTunMetadata13Masked) SetValueMask(v []byte) {
9513 self.ValueMask = v
9514}
9515
9516func (self *NxmTunMetadata13Masked) Serialize(encoder *goloxi.Encoder) error {
9517 if err := self.Oxm.Serialize(encoder); err != nil {
9518 return err
9519 }
9520
9521 encoder.Write(self.Value)
9522 encoder.Write(self.ValueMask)
9523
9524 return nil
9525}
9526
9527func DecodeNxmTunMetadata13Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata13Masked, error) {
9528 _nxmtunmetadata13masked := &NxmTunMetadata13Masked{Oxm: parent}
9529 _nxmtunmetadata13masked.Value = decoder.Read(int(_nxmtunmetadata13masked.TypeLen & 0xFF))
9530 _nxmtunmetadata13masked.ValueMask = decoder.Read(int(_nxmtunmetadata13masked.TypeLen & 0xFF))
9531 return _nxmtunmetadata13masked, nil
9532}
9533
9534func NewNxmTunMetadata13Masked() *NxmTunMetadata13Masked {
9535 obj := &NxmTunMetadata13Masked{
9536 Oxm: NewOxm(93176),
9537 }
9538 return obj
9539}
9540func (self *NxmTunMetadata13Masked) GetOXMName() string {
9541 return "tun_metadata13_masked"
9542}
9543
9544func (self *NxmTunMetadata13Masked) GetOXMValue() interface{} {
9545 return self.Value
9546}
9547
9548func (self *NxmTunMetadata13Masked) GetOXMValueMask() interface{} {
9549 return self.ValueMask
9550}
9551
9552func (self *NxmTunMetadata13Masked) MarshalJSON() ([]byte, error) {
9553 value, err := jsonValue(self.GetOXMValue())
9554 if err != nil {
9555 return nil, err
9556 }
9557 valueMask, err := jsonValue(self.GetOXMValueMask())
9558 if err != nil {
9559 return nil, err
9560 }
9561 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
9562}
9563
9564type NxmTunMetadata14 struct {
9565 *Oxm
9566 Value []byte
9567}
9568
9569type INxmTunMetadata14 interface {
9570 goloxi.IOxm
9571 GetValue() []byte
9572}
9573
9574func (self *NxmTunMetadata14) GetValue() []byte {
9575 return self.Value
9576}
9577
9578func (self *NxmTunMetadata14) SetValue(v []byte) {
9579 self.Value = v
9580}
9581
9582func (self *NxmTunMetadata14) Serialize(encoder *goloxi.Encoder) error {
9583 if err := self.Oxm.Serialize(encoder); err != nil {
9584 return err
9585 }
9586
9587 encoder.Write(self.Value)
9588
9589 return nil
9590}
9591
9592func DecodeNxmTunMetadata14(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata14, error) {
9593 _nxmtunmetadata14 := &NxmTunMetadata14{Oxm: parent}
9594 _nxmtunmetadata14.Value = decoder.Read(int(_nxmtunmetadata14.TypeLen & 0xFF))
9595 return _nxmtunmetadata14, nil
9596}
9597
9598func NewNxmTunMetadata14() *NxmTunMetadata14 {
9599 obj := &NxmTunMetadata14{
9600 Oxm: NewOxm(93308),
9601 }
9602 return obj
9603}
9604func (self *NxmTunMetadata14) GetOXMName() string {
9605 return "tun_metadata14"
9606}
9607
9608func (self *NxmTunMetadata14) GetOXMValue() interface{} {
9609 return self.Value
9610}
9611
9612func (self *NxmTunMetadata14) MarshalJSON() ([]byte, error) {
9613 value, err := jsonValue(self.GetOXMValue())
9614 if err != nil {
9615 return nil, err
9616 }
9617 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
9618}
9619
9620type NxmTunMetadata14Masked struct {
9621 *Oxm
9622 Value []byte
9623 ValueMask []byte
9624}
9625
9626type INxmTunMetadata14Masked interface {
9627 goloxi.IOxm
9628 GetValue() []byte
9629 GetValueMask() []byte
9630}
9631
9632func (self *NxmTunMetadata14Masked) GetValue() []byte {
9633 return self.Value
9634}
9635
9636func (self *NxmTunMetadata14Masked) SetValue(v []byte) {
9637 self.Value = v
9638}
9639
9640func (self *NxmTunMetadata14Masked) GetValueMask() []byte {
9641 return self.ValueMask
9642}
9643
9644func (self *NxmTunMetadata14Masked) SetValueMask(v []byte) {
9645 self.ValueMask = v
9646}
9647
9648func (self *NxmTunMetadata14Masked) Serialize(encoder *goloxi.Encoder) error {
9649 if err := self.Oxm.Serialize(encoder); err != nil {
9650 return err
9651 }
9652
9653 encoder.Write(self.Value)
9654 encoder.Write(self.ValueMask)
9655
9656 return nil
9657}
9658
9659func DecodeNxmTunMetadata14Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata14Masked, error) {
9660 _nxmtunmetadata14masked := &NxmTunMetadata14Masked{Oxm: parent}
9661 _nxmtunmetadata14masked.Value = decoder.Read(int(_nxmtunmetadata14masked.TypeLen & 0xFF))
9662 _nxmtunmetadata14masked.ValueMask = decoder.Read(int(_nxmtunmetadata14masked.TypeLen & 0xFF))
9663 return _nxmtunmetadata14masked, nil
9664}
9665
9666func NewNxmTunMetadata14Masked() *NxmTunMetadata14Masked {
9667 obj := &NxmTunMetadata14Masked{
9668 Oxm: NewOxm(93688),
9669 }
9670 return obj
9671}
9672func (self *NxmTunMetadata14Masked) GetOXMName() string {
9673 return "tun_metadata14_masked"
9674}
9675
9676func (self *NxmTunMetadata14Masked) GetOXMValue() interface{} {
9677 return self.Value
9678}
9679
9680func (self *NxmTunMetadata14Masked) GetOXMValueMask() interface{} {
9681 return self.ValueMask
9682}
9683
9684func (self *NxmTunMetadata14Masked) MarshalJSON() ([]byte, error) {
9685 value, err := jsonValue(self.GetOXMValue())
9686 if err != nil {
9687 return nil, err
9688 }
9689 valueMask, err := jsonValue(self.GetOXMValueMask())
9690 if err != nil {
9691 return nil, err
9692 }
9693 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
9694}
9695
9696type NxmTunMetadata15 struct {
9697 *Oxm
9698 Value []byte
9699}
9700
9701type INxmTunMetadata15 interface {
9702 goloxi.IOxm
9703 GetValue() []byte
9704}
9705
9706func (self *NxmTunMetadata15) GetValue() []byte {
9707 return self.Value
9708}
9709
9710func (self *NxmTunMetadata15) SetValue(v []byte) {
9711 self.Value = v
9712}
9713
9714func (self *NxmTunMetadata15) Serialize(encoder *goloxi.Encoder) error {
9715 if err := self.Oxm.Serialize(encoder); err != nil {
9716 return err
9717 }
9718
9719 encoder.Write(self.Value)
9720
9721 return nil
9722}
9723
9724func DecodeNxmTunMetadata15(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata15, error) {
9725 _nxmtunmetadata15 := &NxmTunMetadata15{Oxm: parent}
9726 _nxmtunmetadata15.Value = decoder.Read(int(_nxmtunmetadata15.TypeLen & 0xFF))
9727 return _nxmtunmetadata15, nil
9728}
9729
9730func NewNxmTunMetadata15() *NxmTunMetadata15 {
9731 obj := &NxmTunMetadata15{
9732 Oxm: NewOxm(93820),
9733 }
9734 return obj
9735}
9736func (self *NxmTunMetadata15) GetOXMName() string {
9737 return "tun_metadata15"
9738}
9739
9740func (self *NxmTunMetadata15) GetOXMValue() interface{} {
9741 return self.Value
9742}
9743
9744func (self *NxmTunMetadata15) MarshalJSON() ([]byte, error) {
9745 value, err := jsonValue(self.GetOXMValue())
9746 if err != nil {
9747 return nil, err
9748 }
9749 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
9750}
9751
9752type NxmTunMetadata15Masked struct {
9753 *Oxm
9754 Value []byte
9755 ValueMask []byte
9756}
9757
9758type INxmTunMetadata15Masked interface {
9759 goloxi.IOxm
9760 GetValue() []byte
9761 GetValueMask() []byte
9762}
9763
9764func (self *NxmTunMetadata15Masked) GetValue() []byte {
9765 return self.Value
9766}
9767
9768func (self *NxmTunMetadata15Masked) SetValue(v []byte) {
9769 self.Value = v
9770}
9771
9772func (self *NxmTunMetadata15Masked) GetValueMask() []byte {
9773 return self.ValueMask
9774}
9775
9776func (self *NxmTunMetadata15Masked) SetValueMask(v []byte) {
9777 self.ValueMask = v
9778}
9779
9780func (self *NxmTunMetadata15Masked) Serialize(encoder *goloxi.Encoder) error {
9781 if err := self.Oxm.Serialize(encoder); err != nil {
9782 return err
9783 }
9784
9785 encoder.Write(self.Value)
9786 encoder.Write(self.ValueMask)
9787
9788 return nil
9789}
9790
9791func DecodeNxmTunMetadata15Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata15Masked, error) {
9792 _nxmtunmetadata15masked := &NxmTunMetadata15Masked{Oxm: parent}
9793 _nxmtunmetadata15masked.Value = decoder.Read(int(_nxmtunmetadata15masked.TypeLen & 0xFF))
9794 _nxmtunmetadata15masked.ValueMask = decoder.Read(int(_nxmtunmetadata15masked.TypeLen & 0xFF))
9795 return _nxmtunmetadata15masked, nil
9796}
9797
9798func NewNxmTunMetadata15Masked() *NxmTunMetadata15Masked {
9799 obj := &NxmTunMetadata15Masked{
9800 Oxm: NewOxm(94200),
9801 }
9802 return obj
9803}
9804func (self *NxmTunMetadata15Masked) GetOXMName() string {
9805 return "tun_metadata15_masked"
9806}
9807
9808func (self *NxmTunMetadata15Masked) GetOXMValue() interface{} {
9809 return self.Value
9810}
9811
9812func (self *NxmTunMetadata15Masked) GetOXMValueMask() interface{} {
9813 return self.ValueMask
9814}
9815
9816func (self *NxmTunMetadata15Masked) MarshalJSON() ([]byte, error) {
9817 value, err := jsonValue(self.GetOXMValue())
9818 if err != nil {
9819 return nil, err
9820 }
9821 valueMask, err := jsonValue(self.GetOXMValueMask())
9822 if err != nil {
9823 return nil, err
9824 }
9825 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
9826}
9827
9828type NxmTunMetadata16 struct {
9829 *Oxm
9830 Value []byte
9831}
9832
9833type INxmTunMetadata16 interface {
9834 goloxi.IOxm
9835 GetValue() []byte
9836}
9837
9838func (self *NxmTunMetadata16) GetValue() []byte {
9839 return self.Value
9840}
9841
9842func (self *NxmTunMetadata16) SetValue(v []byte) {
9843 self.Value = v
9844}
9845
9846func (self *NxmTunMetadata16) Serialize(encoder *goloxi.Encoder) error {
9847 if err := self.Oxm.Serialize(encoder); err != nil {
9848 return err
9849 }
9850
9851 encoder.Write(self.Value)
9852
9853 return nil
9854}
9855
9856func DecodeNxmTunMetadata16(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata16, error) {
9857 _nxmtunmetadata16 := &NxmTunMetadata16{Oxm: parent}
9858 _nxmtunmetadata16.Value = decoder.Read(int(_nxmtunmetadata16.TypeLen & 0xFF))
9859 return _nxmtunmetadata16, nil
9860}
9861
9862func NewNxmTunMetadata16() *NxmTunMetadata16 {
9863 obj := &NxmTunMetadata16{
9864 Oxm: NewOxm(94332),
9865 }
9866 return obj
9867}
9868func (self *NxmTunMetadata16) GetOXMName() string {
9869 return "tun_metadata16"
9870}
9871
9872func (self *NxmTunMetadata16) GetOXMValue() interface{} {
9873 return self.Value
9874}
9875
9876func (self *NxmTunMetadata16) MarshalJSON() ([]byte, error) {
9877 value, err := jsonValue(self.GetOXMValue())
9878 if err != nil {
9879 return nil, err
9880 }
9881 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
9882}
9883
9884type NxmTunMetadata16Masked struct {
9885 *Oxm
9886 Value []byte
9887 ValueMask []byte
9888}
9889
9890type INxmTunMetadata16Masked interface {
9891 goloxi.IOxm
9892 GetValue() []byte
9893 GetValueMask() []byte
9894}
9895
9896func (self *NxmTunMetadata16Masked) GetValue() []byte {
9897 return self.Value
9898}
9899
9900func (self *NxmTunMetadata16Masked) SetValue(v []byte) {
9901 self.Value = v
9902}
9903
9904func (self *NxmTunMetadata16Masked) GetValueMask() []byte {
9905 return self.ValueMask
9906}
9907
9908func (self *NxmTunMetadata16Masked) SetValueMask(v []byte) {
9909 self.ValueMask = v
9910}
9911
9912func (self *NxmTunMetadata16Masked) Serialize(encoder *goloxi.Encoder) error {
9913 if err := self.Oxm.Serialize(encoder); err != nil {
9914 return err
9915 }
9916
9917 encoder.Write(self.Value)
9918 encoder.Write(self.ValueMask)
9919
9920 return nil
9921}
9922
9923func DecodeNxmTunMetadata16Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata16Masked, error) {
9924 _nxmtunmetadata16masked := &NxmTunMetadata16Masked{Oxm: parent}
9925 _nxmtunmetadata16masked.Value = decoder.Read(int(_nxmtunmetadata16masked.TypeLen & 0xFF))
9926 _nxmtunmetadata16masked.ValueMask = decoder.Read(int(_nxmtunmetadata16masked.TypeLen & 0xFF))
9927 return _nxmtunmetadata16masked, nil
9928}
9929
9930func NewNxmTunMetadata16Masked() *NxmTunMetadata16Masked {
9931 obj := &NxmTunMetadata16Masked{
9932 Oxm: NewOxm(94712),
9933 }
9934 return obj
9935}
9936func (self *NxmTunMetadata16Masked) GetOXMName() string {
9937 return "tun_metadata16_masked"
9938}
9939
9940func (self *NxmTunMetadata16Masked) GetOXMValue() interface{} {
9941 return self.Value
9942}
9943
9944func (self *NxmTunMetadata16Masked) GetOXMValueMask() interface{} {
9945 return self.ValueMask
9946}
9947
9948func (self *NxmTunMetadata16Masked) MarshalJSON() ([]byte, error) {
9949 value, err := jsonValue(self.GetOXMValue())
9950 if err != nil {
9951 return nil, err
9952 }
9953 valueMask, err := jsonValue(self.GetOXMValueMask())
9954 if err != nil {
9955 return nil, err
9956 }
9957 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
9958}
9959
9960type NxmTunMetadata17 struct {
9961 *Oxm
9962 Value []byte
9963}
9964
9965type INxmTunMetadata17 interface {
9966 goloxi.IOxm
9967 GetValue() []byte
9968}
9969
9970func (self *NxmTunMetadata17) GetValue() []byte {
9971 return self.Value
9972}
9973
9974func (self *NxmTunMetadata17) SetValue(v []byte) {
9975 self.Value = v
9976}
9977
9978func (self *NxmTunMetadata17) Serialize(encoder *goloxi.Encoder) error {
9979 if err := self.Oxm.Serialize(encoder); err != nil {
9980 return err
9981 }
9982
9983 encoder.Write(self.Value)
9984
9985 return nil
9986}
9987
9988func DecodeNxmTunMetadata17(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata17, error) {
9989 _nxmtunmetadata17 := &NxmTunMetadata17{Oxm: parent}
9990 _nxmtunmetadata17.Value = decoder.Read(int(_nxmtunmetadata17.TypeLen & 0xFF))
9991 return _nxmtunmetadata17, nil
9992}
9993
9994func NewNxmTunMetadata17() *NxmTunMetadata17 {
9995 obj := &NxmTunMetadata17{
9996 Oxm: NewOxm(94844),
9997 }
9998 return obj
9999}
10000func (self *NxmTunMetadata17) GetOXMName() string {
10001 return "tun_metadata17"
10002}
10003
10004func (self *NxmTunMetadata17) GetOXMValue() interface{} {
10005 return self.Value
10006}
10007
10008func (self *NxmTunMetadata17) MarshalJSON() ([]byte, error) {
10009 value, err := jsonValue(self.GetOXMValue())
10010 if err != nil {
10011 return nil, err
10012 }
10013 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
10014}
10015
10016type NxmTunMetadata17Masked struct {
10017 *Oxm
10018 Value []byte
10019 ValueMask []byte
10020}
10021
10022type INxmTunMetadata17Masked interface {
10023 goloxi.IOxm
10024 GetValue() []byte
10025 GetValueMask() []byte
10026}
10027
10028func (self *NxmTunMetadata17Masked) GetValue() []byte {
10029 return self.Value
10030}
10031
10032func (self *NxmTunMetadata17Masked) SetValue(v []byte) {
10033 self.Value = v
10034}
10035
10036func (self *NxmTunMetadata17Masked) GetValueMask() []byte {
10037 return self.ValueMask
10038}
10039
10040func (self *NxmTunMetadata17Masked) SetValueMask(v []byte) {
10041 self.ValueMask = v
10042}
10043
10044func (self *NxmTunMetadata17Masked) Serialize(encoder *goloxi.Encoder) error {
10045 if err := self.Oxm.Serialize(encoder); err != nil {
10046 return err
10047 }
10048
10049 encoder.Write(self.Value)
10050 encoder.Write(self.ValueMask)
10051
10052 return nil
10053}
10054
10055func DecodeNxmTunMetadata17Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata17Masked, error) {
10056 _nxmtunmetadata17masked := &NxmTunMetadata17Masked{Oxm: parent}
10057 _nxmtunmetadata17masked.Value = decoder.Read(int(_nxmtunmetadata17masked.TypeLen & 0xFF))
10058 _nxmtunmetadata17masked.ValueMask = decoder.Read(int(_nxmtunmetadata17masked.TypeLen & 0xFF))
10059 return _nxmtunmetadata17masked, nil
10060}
10061
10062func NewNxmTunMetadata17Masked() *NxmTunMetadata17Masked {
10063 obj := &NxmTunMetadata17Masked{
10064 Oxm: NewOxm(95224),
10065 }
10066 return obj
10067}
10068func (self *NxmTunMetadata17Masked) GetOXMName() string {
10069 return "tun_metadata17_masked"
10070}
10071
10072func (self *NxmTunMetadata17Masked) GetOXMValue() interface{} {
10073 return self.Value
10074}
10075
10076func (self *NxmTunMetadata17Masked) GetOXMValueMask() interface{} {
10077 return self.ValueMask
10078}
10079
10080func (self *NxmTunMetadata17Masked) MarshalJSON() ([]byte, error) {
10081 value, err := jsonValue(self.GetOXMValue())
10082 if err != nil {
10083 return nil, err
10084 }
10085 valueMask, err := jsonValue(self.GetOXMValueMask())
10086 if err != nil {
10087 return nil, err
10088 }
10089 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
10090}
10091
10092type NxmTunMetadata18 struct {
10093 *Oxm
10094 Value []byte
10095}
10096
10097type INxmTunMetadata18 interface {
10098 goloxi.IOxm
10099 GetValue() []byte
10100}
10101
10102func (self *NxmTunMetadata18) GetValue() []byte {
10103 return self.Value
10104}
10105
10106func (self *NxmTunMetadata18) SetValue(v []byte) {
10107 self.Value = v
10108}
10109
10110func (self *NxmTunMetadata18) Serialize(encoder *goloxi.Encoder) error {
10111 if err := self.Oxm.Serialize(encoder); err != nil {
10112 return err
10113 }
10114
10115 encoder.Write(self.Value)
10116
10117 return nil
10118}
10119
10120func DecodeNxmTunMetadata18(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata18, error) {
10121 _nxmtunmetadata18 := &NxmTunMetadata18{Oxm: parent}
10122 _nxmtunmetadata18.Value = decoder.Read(int(_nxmtunmetadata18.TypeLen & 0xFF))
10123 return _nxmtunmetadata18, nil
10124}
10125
10126func NewNxmTunMetadata18() *NxmTunMetadata18 {
10127 obj := &NxmTunMetadata18{
10128 Oxm: NewOxm(95356),
10129 }
10130 return obj
10131}
10132func (self *NxmTunMetadata18) GetOXMName() string {
10133 return "tun_metadata18"
10134}
10135
10136func (self *NxmTunMetadata18) GetOXMValue() interface{} {
10137 return self.Value
10138}
10139
10140func (self *NxmTunMetadata18) MarshalJSON() ([]byte, error) {
10141 value, err := jsonValue(self.GetOXMValue())
10142 if err != nil {
10143 return nil, err
10144 }
10145 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
10146}
10147
10148type NxmTunMetadata18Masked struct {
10149 *Oxm
10150 Value []byte
10151 ValueMask []byte
10152}
10153
10154type INxmTunMetadata18Masked interface {
10155 goloxi.IOxm
10156 GetValue() []byte
10157 GetValueMask() []byte
10158}
10159
10160func (self *NxmTunMetadata18Masked) GetValue() []byte {
10161 return self.Value
10162}
10163
10164func (self *NxmTunMetadata18Masked) SetValue(v []byte) {
10165 self.Value = v
10166}
10167
10168func (self *NxmTunMetadata18Masked) GetValueMask() []byte {
10169 return self.ValueMask
10170}
10171
10172func (self *NxmTunMetadata18Masked) SetValueMask(v []byte) {
10173 self.ValueMask = v
10174}
10175
10176func (self *NxmTunMetadata18Masked) Serialize(encoder *goloxi.Encoder) error {
10177 if err := self.Oxm.Serialize(encoder); err != nil {
10178 return err
10179 }
10180
10181 encoder.Write(self.Value)
10182 encoder.Write(self.ValueMask)
10183
10184 return nil
10185}
10186
10187func DecodeNxmTunMetadata18Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata18Masked, error) {
10188 _nxmtunmetadata18masked := &NxmTunMetadata18Masked{Oxm: parent}
10189 _nxmtunmetadata18masked.Value = decoder.Read(int(_nxmtunmetadata18masked.TypeLen & 0xFF))
10190 _nxmtunmetadata18masked.ValueMask = decoder.Read(int(_nxmtunmetadata18masked.TypeLen & 0xFF))
10191 return _nxmtunmetadata18masked, nil
10192}
10193
10194func NewNxmTunMetadata18Masked() *NxmTunMetadata18Masked {
10195 obj := &NxmTunMetadata18Masked{
10196 Oxm: NewOxm(95736),
10197 }
10198 return obj
10199}
10200func (self *NxmTunMetadata18Masked) GetOXMName() string {
10201 return "tun_metadata18_masked"
10202}
10203
10204func (self *NxmTunMetadata18Masked) GetOXMValue() interface{} {
10205 return self.Value
10206}
10207
10208func (self *NxmTunMetadata18Masked) GetOXMValueMask() interface{} {
10209 return self.ValueMask
10210}
10211
10212func (self *NxmTunMetadata18Masked) MarshalJSON() ([]byte, error) {
10213 value, err := jsonValue(self.GetOXMValue())
10214 if err != nil {
10215 return nil, err
10216 }
10217 valueMask, err := jsonValue(self.GetOXMValueMask())
10218 if err != nil {
10219 return nil, err
10220 }
10221 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
10222}
10223
10224type NxmTunMetadata19 struct {
10225 *Oxm
10226 Value []byte
10227}
10228
10229type INxmTunMetadata19 interface {
10230 goloxi.IOxm
10231 GetValue() []byte
10232}
10233
10234func (self *NxmTunMetadata19) GetValue() []byte {
10235 return self.Value
10236}
10237
10238func (self *NxmTunMetadata19) SetValue(v []byte) {
10239 self.Value = v
10240}
10241
10242func (self *NxmTunMetadata19) Serialize(encoder *goloxi.Encoder) error {
10243 if err := self.Oxm.Serialize(encoder); err != nil {
10244 return err
10245 }
10246
10247 encoder.Write(self.Value)
10248
10249 return nil
10250}
10251
10252func DecodeNxmTunMetadata19(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata19, error) {
10253 _nxmtunmetadata19 := &NxmTunMetadata19{Oxm: parent}
10254 _nxmtunmetadata19.Value = decoder.Read(int(_nxmtunmetadata19.TypeLen & 0xFF))
10255 return _nxmtunmetadata19, nil
10256}
10257
10258func NewNxmTunMetadata19() *NxmTunMetadata19 {
10259 obj := &NxmTunMetadata19{
10260 Oxm: NewOxm(95868),
10261 }
10262 return obj
10263}
10264func (self *NxmTunMetadata19) GetOXMName() string {
10265 return "tun_metadata19"
10266}
10267
10268func (self *NxmTunMetadata19) GetOXMValue() interface{} {
10269 return self.Value
10270}
10271
10272func (self *NxmTunMetadata19) MarshalJSON() ([]byte, error) {
10273 value, err := jsonValue(self.GetOXMValue())
10274 if err != nil {
10275 return nil, err
10276 }
10277 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
10278}
10279
10280type NxmTunMetadata19Masked struct {
10281 *Oxm
10282 Value []byte
10283 ValueMask []byte
10284}
10285
10286type INxmTunMetadata19Masked interface {
10287 goloxi.IOxm
10288 GetValue() []byte
10289 GetValueMask() []byte
10290}
10291
10292func (self *NxmTunMetadata19Masked) GetValue() []byte {
10293 return self.Value
10294}
10295
10296func (self *NxmTunMetadata19Masked) SetValue(v []byte) {
10297 self.Value = v
10298}
10299
10300func (self *NxmTunMetadata19Masked) GetValueMask() []byte {
10301 return self.ValueMask
10302}
10303
10304func (self *NxmTunMetadata19Masked) SetValueMask(v []byte) {
10305 self.ValueMask = v
10306}
10307
10308func (self *NxmTunMetadata19Masked) Serialize(encoder *goloxi.Encoder) error {
10309 if err := self.Oxm.Serialize(encoder); err != nil {
10310 return err
10311 }
10312
10313 encoder.Write(self.Value)
10314 encoder.Write(self.ValueMask)
10315
10316 return nil
10317}
10318
10319func DecodeNxmTunMetadata19Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata19Masked, error) {
10320 _nxmtunmetadata19masked := &NxmTunMetadata19Masked{Oxm: parent}
10321 _nxmtunmetadata19masked.Value = decoder.Read(int(_nxmtunmetadata19masked.TypeLen & 0xFF))
10322 _nxmtunmetadata19masked.ValueMask = decoder.Read(int(_nxmtunmetadata19masked.TypeLen & 0xFF))
10323 return _nxmtunmetadata19masked, nil
10324}
10325
10326func NewNxmTunMetadata19Masked() *NxmTunMetadata19Masked {
10327 obj := &NxmTunMetadata19Masked{
10328 Oxm: NewOxm(96248),
10329 }
10330 return obj
10331}
10332func (self *NxmTunMetadata19Masked) GetOXMName() string {
10333 return "tun_metadata19_masked"
10334}
10335
10336func (self *NxmTunMetadata19Masked) GetOXMValue() interface{} {
10337 return self.Value
10338}
10339
10340func (self *NxmTunMetadata19Masked) GetOXMValueMask() interface{} {
10341 return self.ValueMask
10342}
10343
10344func (self *NxmTunMetadata19Masked) MarshalJSON() ([]byte, error) {
10345 value, err := jsonValue(self.GetOXMValue())
10346 if err != nil {
10347 return nil, err
10348 }
10349 valueMask, err := jsonValue(self.GetOXMValueMask())
10350 if err != nil {
10351 return nil, err
10352 }
10353 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
10354}
10355
10356type NxmTunMetadata1Masked struct {
10357 *Oxm
10358 Value []byte
10359 ValueMask []byte
10360}
10361
10362type INxmTunMetadata1Masked interface {
10363 goloxi.IOxm
10364 GetValue() []byte
10365 GetValueMask() []byte
10366}
10367
10368func (self *NxmTunMetadata1Masked) GetValue() []byte {
10369 return self.Value
10370}
10371
10372func (self *NxmTunMetadata1Masked) SetValue(v []byte) {
10373 self.Value = v
10374}
10375
10376func (self *NxmTunMetadata1Masked) GetValueMask() []byte {
10377 return self.ValueMask
10378}
10379
10380func (self *NxmTunMetadata1Masked) SetValueMask(v []byte) {
10381 self.ValueMask = v
10382}
10383
10384func (self *NxmTunMetadata1Masked) Serialize(encoder *goloxi.Encoder) error {
10385 if err := self.Oxm.Serialize(encoder); err != nil {
10386 return err
10387 }
10388
10389 encoder.Write(self.Value)
10390 encoder.Write(self.ValueMask)
10391
10392 return nil
10393}
10394
10395func DecodeNxmTunMetadata1Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata1Masked, error) {
10396 _nxmtunmetadata1masked := &NxmTunMetadata1Masked{Oxm: parent}
10397 _nxmtunmetadata1masked.Value = decoder.Read(int(_nxmtunmetadata1masked.TypeLen & 0xFF))
10398 _nxmtunmetadata1masked.ValueMask = decoder.Read(int(_nxmtunmetadata1masked.TypeLen & 0xFF))
10399 return _nxmtunmetadata1masked, nil
10400}
10401
10402func NewNxmTunMetadata1Masked() *NxmTunMetadata1Masked {
10403 obj := &NxmTunMetadata1Masked{
10404 Oxm: NewOxm(87032),
10405 }
10406 return obj
10407}
10408func (self *NxmTunMetadata1Masked) GetOXMName() string {
10409 return "tun_metadata1_masked"
10410}
10411
10412func (self *NxmTunMetadata1Masked) GetOXMValue() interface{} {
10413 return self.Value
10414}
10415
10416func (self *NxmTunMetadata1Masked) GetOXMValueMask() interface{} {
10417 return self.ValueMask
10418}
10419
10420func (self *NxmTunMetadata1Masked) MarshalJSON() ([]byte, error) {
10421 value, err := jsonValue(self.GetOXMValue())
10422 if err != nil {
10423 return nil, err
10424 }
10425 valueMask, err := jsonValue(self.GetOXMValueMask())
10426 if err != nil {
10427 return nil, err
10428 }
10429 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
10430}
10431
10432type NxmTunMetadata2 struct {
10433 *Oxm
10434 Value []byte
10435}
10436
10437type INxmTunMetadata2 interface {
10438 goloxi.IOxm
10439 GetValue() []byte
10440}
10441
10442func (self *NxmTunMetadata2) GetValue() []byte {
10443 return self.Value
10444}
10445
10446func (self *NxmTunMetadata2) SetValue(v []byte) {
10447 self.Value = v
10448}
10449
10450func (self *NxmTunMetadata2) Serialize(encoder *goloxi.Encoder) error {
10451 if err := self.Oxm.Serialize(encoder); err != nil {
10452 return err
10453 }
10454
10455 encoder.Write(self.Value)
10456
10457 return nil
10458}
10459
10460func DecodeNxmTunMetadata2(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata2, error) {
10461 _nxmtunmetadata2 := &NxmTunMetadata2{Oxm: parent}
10462 _nxmtunmetadata2.Value = decoder.Read(int(_nxmtunmetadata2.TypeLen & 0xFF))
10463 return _nxmtunmetadata2, nil
10464}
10465
10466func NewNxmTunMetadata2() *NxmTunMetadata2 {
10467 obj := &NxmTunMetadata2{
10468 Oxm: NewOxm(87164),
10469 }
10470 return obj
10471}
10472func (self *NxmTunMetadata2) GetOXMName() string {
10473 return "tun_metadata2"
10474}
10475
10476func (self *NxmTunMetadata2) GetOXMValue() interface{} {
10477 return self.Value
10478}
10479
10480func (self *NxmTunMetadata2) MarshalJSON() ([]byte, error) {
10481 value, err := jsonValue(self.GetOXMValue())
10482 if err != nil {
10483 return nil, err
10484 }
10485 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
10486}
10487
10488type NxmTunMetadata20 struct {
10489 *Oxm
10490 Value []byte
10491}
10492
10493type INxmTunMetadata20 interface {
10494 goloxi.IOxm
10495 GetValue() []byte
10496}
10497
10498func (self *NxmTunMetadata20) GetValue() []byte {
10499 return self.Value
10500}
10501
10502func (self *NxmTunMetadata20) SetValue(v []byte) {
10503 self.Value = v
10504}
10505
10506func (self *NxmTunMetadata20) Serialize(encoder *goloxi.Encoder) error {
10507 if err := self.Oxm.Serialize(encoder); err != nil {
10508 return err
10509 }
10510
10511 encoder.Write(self.Value)
10512
10513 return nil
10514}
10515
10516func DecodeNxmTunMetadata20(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata20, error) {
10517 _nxmtunmetadata20 := &NxmTunMetadata20{Oxm: parent}
10518 _nxmtunmetadata20.Value = decoder.Read(int(_nxmtunmetadata20.TypeLen & 0xFF))
10519 return _nxmtunmetadata20, nil
10520}
10521
10522func NewNxmTunMetadata20() *NxmTunMetadata20 {
10523 obj := &NxmTunMetadata20{
10524 Oxm: NewOxm(96380),
10525 }
10526 return obj
10527}
10528func (self *NxmTunMetadata20) GetOXMName() string {
10529 return "tun_metadata20"
10530}
10531
10532func (self *NxmTunMetadata20) GetOXMValue() interface{} {
10533 return self.Value
10534}
10535
10536func (self *NxmTunMetadata20) MarshalJSON() ([]byte, error) {
10537 value, err := jsonValue(self.GetOXMValue())
10538 if err != nil {
10539 return nil, err
10540 }
10541 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
10542}
10543
10544type NxmTunMetadata20Masked struct {
10545 *Oxm
10546 Value []byte
10547 ValueMask []byte
10548}
10549
10550type INxmTunMetadata20Masked interface {
10551 goloxi.IOxm
10552 GetValue() []byte
10553 GetValueMask() []byte
10554}
10555
10556func (self *NxmTunMetadata20Masked) GetValue() []byte {
10557 return self.Value
10558}
10559
10560func (self *NxmTunMetadata20Masked) SetValue(v []byte) {
10561 self.Value = v
10562}
10563
10564func (self *NxmTunMetadata20Masked) GetValueMask() []byte {
10565 return self.ValueMask
10566}
10567
10568func (self *NxmTunMetadata20Masked) SetValueMask(v []byte) {
10569 self.ValueMask = v
10570}
10571
10572func (self *NxmTunMetadata20Masked) Serialize(encoder *goloxi.Encoder) error {
10573 if err := self.Oxm.Serialize(encoder); err != nil {
10574 return err
10575 }
10576
10577 encoder.Write(self.Value)
10578 encoder.Write(self.ValueMask)
10579
10580 return nil
10581}
10582
10583func DecodeNxmTunMetadata20Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata20Masked, error) {
10584 _nxmtunmetadata20masked := &NxmTunMetadata20Masked{Oxm: parent}
10585 _nxmtunmetadata20masked.Value = decoder.Read(int(_nxmtunmetadata20masked.TypeLen & 0xFF))
10586 _nxmtunmetadata20masked.ValueMask = decoder.Read(int(_nxmtunmetadata20masked.TypeLen & 0xFF))
10587 return _nxmtunmetadata20masked, nil
10588}
10589
10590func NewNxmTunMetadata20Masked() *NxmTunMetadata20Masked {
10591 obj := &NxmTunMetadata20Masked{
10592 Oxm: NewOxm(96760),
10593 }
10594 return obj
10595}
10596func (self *NxmTunMetadata20Masked) GetOXMName() string {
10597 return "tun_metadata20_masked"
10598}
10599
10600func (self *NxmTunMetadata20Masked) GetOXMValue() interface{} {
10601 return self.Value
10602}
10603
10604func (self *NxmTunMetadata20Masked) GetOXMValueMask() interface{} {
10605 return self.ValueMask
10606}
10607
10608func (self *NxmTunMetadata20Masked) MarshalJSON() ([]byte, error) {
10609 value, err := jsonValue(self.GetOXMValue())
10610 if err != nil {
10611 return nil, err
10612 }
10613 valueMask, err := jsonValue(self.GetOXMValueMask())
10614 if err != nil {
10615 return nil, err
10616 }
10617 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
10618}
10619
10620type NxmTunMetadata21 struct {
10621 *Oxm
10622 Value []byte
10623}
10624
10625type INxmTunMetadata21 interface {
10626 goloxi.IOxm
10627 GetValue() []byte
10628}
10629
10630func (self *NxmTunMetadata21) GetValue() []byte {
10631 return self.Value
10632}
10633
10634func (self *NxmTunMetadata21) SetValue(v []byte) {
10635 self.Value = v
10636}
10637
10638func (self *NxmTunMetadata21) Serialize(encoder *goloxi.Encoder) error {
10639 if err := self.Oxm.Serialize(encoder); err != nil {
10640 return err
10641 }
10642
10643 encoder.Write(self.Value)
10644
10645 return nil
10646}
10647
10648func DecodeNxmTunMetadata21(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata21, error) {
10649 _nxmtunmetadata21 := &NxmTunMetadata21{Oxm: parent}
10650 _nxmtunmetadata21.Value = decoder.Read(int(_nxmtunmetadata21.TypeLen & 0xFF))
10651 return _nxmtunmetadata21, nil
10652}
10653
10654func NewNxmTunMetadata21() *NxmTunMetadata21 {
10655 obj := &NxmTunMetadata21{
10656 Oxm: NewOxm(96892),
10657 }
10658 return obj
10659}
10660func (self *NxmTunMetadata21) GetOXMName() string {
10661 return "tun_metadata21"
10662}
10663
10664func (self *NxmTunMetadata21) GetOXMValue() interface{} {
10665 return self.Value
10666}
10667
10668func (self *NxmTunMetadata21) MarshalJSON() ([]byte, error) {
10669 value, err := jsonValue(self.GetOXMValue())
10670 if err != nil {
10671 return nil, err
10672 }
10673 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
10674}
10675
10676type NxmTunMetadata21Masked struct {
10677 *Oxm
10678 Value []byte
10679 ValueMask []byte
10680}
10681
10682type INxmTunMetadata21Masked interface {
10683 goloxi.IOxm
10684 GetValue() []byte
10685 GetValueMask() []byte
10686}
10687
10688func (self *NxmTunMetadata21Masked) GetValue() []byte {
10689 return self.Value
10690}
10691
10692func (self *NxmTunMetadata21Masked) SetValue(v []byte) {
10693 self.Value = v
10694}
10695
10696func (self *NxmTunMetadata21Masked) GetValueMask() []byte {
10697 return self.ValueMask
10698}
10699
10700func (self *NxmTunMetadata21Masked) SetValueMask(v []byte) {
10701 self.ValueMask = v
10702}
10703
10704func (self *NxmTunMetadata21Masked) Serialize(encoder *goloxi.Encoder) error {
10705 if err := self.Oxm.Serialize(encoder); err != nil {
10706 return err
10707 }
10708
10709 encoder.Write(self.Value)
10710 encoder.Write(self.ValueMask)
10711
10712 return nil
10713}
10714
10715func DecodeNxmTunMetadata21Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata21Masked, error) {
10716 _nxmtunmetadata21masked := &NxmTunMetadata21Masked{Oxm: parent}
10717 _nxmtunmetadata21masked.Value = decoder.Read(int(_nxmtunmetadata21masked.TypeLen & 0xFF))
10718 _nxmtunmetadata21masked.ValueMask = decoder.Read(int(_nxmtunmetadata21masked.TypeLen & 0xFF))
10719 return _nxmtunmetadata21masked, nil
10720}
10721
10722func NewNxmTunMetadata21Masked() *NxmTunMetadata21Masked {
10723 obj := &NxmTunMetadata21Masked{
10724 Oxm: NewOxm(97272),
10725 }
10726 return obj
10727}
10728func (self *NxmTunMetadata21Masked) GetOXMName() string {
10729 return "tun_metadata21_masked"
10730}
10731
10732func (self *NxmTunMetadata21Masked) GetOXMValue() interface{} {
10733 return self.Value
10734}
10735
10736func (self *NxmTunMetadata21Masked) GetOXMValueMask() interface{} {
10737 return self.ValueMask
10738}
10739
10740func (self *NxmTunMetadata21Masked) MarshalJSON() ([]byte, error) {
10741 value, err := jsonValue(self.GetOXMValue())
10742 if err != nil {
10743 return nil, err
10744 }
10745 valueMask, err := jsonValue(self.GetOXMValueMask())
10746 if err != nil {
10747 return nil, err
10748 }
10749 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
10750}
10751
10752type NxmTunMetadata22 struct {
10753 *Oxm
10754 Value []byte
10755}
10756
10757type INxmTunMetadata22 interface {
10758 goloxi.IOxm
10759 GetValue() []byte
10760}
10761
10762func (self *NxmTunMetadata22) GetValue() []byte {
10763 return self.Value
10764}
10765
10766func (self *NxmTunMetadata22) SetValue(v []byte) {
10767 self.Value = v
10768}
10769
10770func (self *NxmTunMetadata22) Serialize(encoder *goloxi.Encoder) error {
10771 if err := self.Oxm.Serialize(encoder); err != nil {
10772 return err
10773 }
10774
10775 encoder.Write(self.Value)
10776
10777 return nil
10778}
10779
10780func DecodeNxmTunMetadata22(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata22, error) {
10781 _nxmtunmetadata22 := &NxmTunMetadata22{Oxm: parent}
10782 _nxmtunmetadata22.Value = decoder.Read(int(_nxmtunmetadata22.TypeLen & 0xFF))
10783 return _nxmtunmetadata22, nil
10784}
10785
10786func NewNxmTunMetadata22() *NxmTunMetadata22 {
10787 obj := &NxmTunMetadata22{
10788 Oxm: NewOxm(97404),
10789 }
10790 return obj
10791}
10792func (self *NxmTunMetadata22) GetOXMName() string {
10793 return "tun_metadata22"
10794}
10795
10796func (self *NxmTunMetadata22) GetOXMValue() interface{} {
10797 return self.Value
10798}
10799
10800func (self *NxmTunMetadata22) MarshalJSON() ([]byte, error) {
10801 value, err := jsonValue(self.GetOXMValue())
10802 if err != nil {
10803 return nil, err
10804 }
10805 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
10806}
10807
10808type NxmTunMetadata22Masked struct {
10809 *Oxm
10810 Value []byte
10811 ValueMask []byte
10812}
10813
10814type INxmTunMetadata22Masked interface {
10815 goloxi.IOxm
10816 GetValue() []byte
10817 GetValueMask() []byte
10818}
10819
10820func (self *NxmTunMetadata22Masked) GetValue() []byte {
10821 return self.Value
10822}
10823
10824func (self *NxmTunMetadata22Masked) SetValue(v []byte) {
10825 self.Value = v
10826}
10827
10828func (self *NxmTunMetadata22Masked) GetValueMask() []byte {
10829 return self.ValueMask
10830}
10831
10832func (self *NxmTunMetadata22Masked) SetValueMask(v []byte) {
10833 self.ValueMask = v
10834}
10835
10836func (self *NxmTunMetadata22Masked) Serialize(encoder *goloxi.Encoder) error {
10837 if err := self.Oxm.Serialize(encoder); err != nil {
10838 return err
10839 }
10840
10841 encoder.Write(self.Value)
10842 encoder.Write(self.ValueMask)
10843
10844 return nil
10845}
10846
10847func DecodeNxmTunMetadata22Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata22Masked, error) {
10848 _nxmtunmetadata22masked := &NxmTunMetadata22Masked{Oxm: parent}
10849 _nxmtunmetadata22masked.Value = decoder.Read(int(_nxmtunmetadata22masked.TypeLen & 0xFF))
10850 _nxmtunmetadata22masked.ValueMask = decoder.Read(int(_nxmtunmetadata22masked.TypeLen & 0xFF))
10851 return _nxmtunmetadata22masked, nil
10852}
10853
10854func NewNxmTunMetadata22Masked() *NxmTunMetadata22Masked {
10855 obj := &NxmTunMetadata22Masked{
10856 Oxm: NewOxm(97784),
10857 }
10858 return obj
10859}
10860func (self *NxmTunMetadata22Masked) GetOXMName() string {
10861 return "tun_metadata22_masked"
10862}
10863
10864func (self *NxmTunMetadata22Masked) GetOXMValue() interface{} {
10865 return self.Value
10866}
10867
10868func (self *NxmTunMetadata22Masked) GetOXMValueMask() interface{} {
10869 return self.ValueMask
10870}
10871
10872func (self *NxmTunMetadata22Masked) MarshalJSON() ([]byte, error) {
10873 value, err := jsonValue(self.GetOXMValue())
10874 if err != nil {
10875 return nil, err
10876 }
10877 valueMask, err := jsonValue(self.GetOXMValueMask())
10878 if err != nil {
10879 return nil, err
10880 }
10881 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
10882}
10883
10884type NxmTunMetadata23 struct {
10885 *Oxm
10886 Value []byte
10887}
10888
10889type INxmTunMetadata23 interface {
10890 goloxi.IOxm
10891 GetValue() []byte
10892}
10893
10894func (self *NxmTunMetadata23) GetValue() []byte {
10895 return self.Value
10896}
10897
10898func (self *NxmTunMetadata23) SetValue(v []byte) {
10899 self.Value = v
10900}
10901
10902func (self *NxmTunMetadata23) Serialize(encoder *goloxi.Encoder) error {
10903 if err := self.Oxm.Serialize(encoder); err != nil {
10904 return err
10905 }
10906
10907 encoder.Write(self.Value)
10908
10909 return nil
10910}
10911
10912func DecodeNxmTunMetadata23(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata23, error) {
10913 _nxmtunmetadata23 := &NxmTunMetadata23{Oxm: parent}
10914 _nxmtunmetadata23.Value = decoder.Read(int(_nxmtunmetadata23.TypeLen & 0xFF))
10915 return _nxmtunmetadata23, nil
10916}
10917
10918func NewNxmTunMetadata23() *NxmTunMetadata23 {
10919 obj := &NxmTunMetadata23{
10920 Oxm: NewOxm(97916),
10921 }
10922 return obj
10923}
10924func (self *NxmTunMetadata23) GetOXMName() string {
10925 return "tun_metadata23"
10926}
10927
10928func (self *NxmTunMetadata23) GetOXMValue() interface{} {
10929 return self.Value
10930}
10931
10932func (self *NxmTunMetadata23) MarshalJSON() ([]byte, error) {
10933 value, err := jsonValue(self.GetOXMValue())
10934 if err != nil {
10935 return nil, err
10936 }
10937 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
10938}
10939
10940type NxmTunMetadata23Masked struct {
10941 *Oxm
10942 Value []byte
10943 ValueMask []byte
10944}
10945
10946type INxmTunMetadata23Masked interface {
10947 goloxi.IOxm
10948 GetValue() []byte
10949 GetValueMask() []byte
10950}
10951
10952func (self *NxmTunMetadata23Masked) GetValue() []byte {
10953 return self.Value
10954}
10955
10956func (self *NxmTunMetadata23Masked) SetValue(v []byte) {
10957 self.Value = v
10958}
10959
10960func (self *NxmTunMetadata23Masked) GetValueMask() []byte {
10961 return self.ValueMask
10962}
10963
10964func (self *NxmTunMetadata23Masked) SetValueMask(v []byte) {
10965 self.ValueMask = v
10966}
10967
10968func (self *NxmTunMetadata23Masked) Serialize(encoder *goloxi.Encoder) error {
10969 if err := self.Oxm.Serialize(encoder); err != nil {
10970 return err
10971 }
10972
10973 encoder.Write(self.Value)
10974 encoder.Write(self.ValueMask)
10975
10976 return nil
10977}
10978
10979func DecodeNxmTunMetadata23Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata23Masked, error) {
10980 _nxmtunmetadata23masked := &NxmTunMetadata23Masked{Oxm: parent}
10981 _nxmtunmetadata23masked.Value = decoder.Read(int(_nxmtunmetadata23masked.TypeLen & 0xFF))
10982 _nxmtunmetadata23masked.ValueMask = decoder.Read(int(_nxmtunmetadata23masked.TypeLen & 0xFF))
10983 return _nxmtunmetadata23masked, nil
10984}
10985
10986func NewNxmTunMetadata23Masked() *NxmTunMetadata23Masked {
10987 obj := &NxmTunMetadata23Masked{
10988 Oxm: NewOxm(98296),
10989 }
10990 return obj
10991}
10992func (self *NxmTunMetadata23Masked) GetOXMName() string {
10993 return "tun_metadata23_masked"
10994}
10995
10996func (self *NxmTunMetadata23Masked) GetOXMValue() interface{} {
10997 return self.Value
10998}
10999
11000func (self *NxmTunMetadata23Masked) GetOXMValueMask() interface{} {
11001 return self.ValueMask
11002}
11003
11004func (self *NxmTunMetadata23Masked) MarshalJSON() ([]byte, error) {
11005 value, err := jsonValue(self.GetOXMValue())
11006 if err != nil {
11007 return nil, err
11008 }
11009 valueMask, err := jsonValue(self.GetOXMValueMask())
11010 if err != nil {
11011 return nil, err
11012 }
11013 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
11014}
11015
11016type NxmTunMetadata24 struct {
11017 *Oxm
11018 Value []byte
11019}
11020
11021type INxmTunMetadata24 interface {
11022 goloxi.IOxm
11023 GetValue() []byte
11024}
11025
11026func (self *NxmTunMetadata24) GetValue() []byte {
11027 return self.Value
11028}
11029
11030func (self *NxmTunMetadata24) SetValue(v []byte) {
11031 self.Value = v
11032}
11033
11034func (self *NxmTunMetadata24) Serialize(encoder *goloxi.Encoder) error {
11035 if err := self.Oxm.Serialize(encoder); err != nil {
11036 return err
11037 }
11038
11039 encoder.Write(self.Value)
11040
11041 return nil
11042}
11043
11044func DecodeNxmTunMetadata24(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata24, error) {
11045 _nxmtunmetadata24 := &NxmTunMetadata24{Oxm: parent}
11046 _nxmtunmetadata24.Value = decoder.Read(int(_nxmtunmetadata24.TypeLen & 0xFF))
11047 return _nxmtunmetadata24, nil
11048}
11049
11050func NewNxmTunMetadata24() *NxmTunMetadata24 {
11051 obj := &NxmTunMetadata24{
11052 Oxm: NewOxm(98428),
11053 }
11054 return obj
11055}
11056func (self *NxmTunMetadata24) GetOXMName() string {
11057 return "tun_metadata24"
11058}
11059
11060func (self *NxmTunMetadata24) GetOXMValue() interface{} {
11061 return self.Value
11062}
11063
11064func (self *NxmTunMetadata24) MarshalJSON() ([]byte, error) {
11065 value, err := jsonValue(self.GetOXMValue())
11066 if err != nil {
11067 return nil, err
11068 }
11069 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
11070}
11071
11072type NxmTunMetadata24Masked struct {
11073 *Oxm
11074 Value []byte
11075 ValueMask []byte
11076}
11077
11078type INxmTunMetadata24Masked interface {
11079 goloxi.IOxm
11080 GetValue() []byte
11081 GetValueMask() []byte
11082}
11083
11084func (self *NxmTunMetadata24Masked) GetValue() []byte {
11085 return self.Value
11086}
11087
11088func (self *NxmTunMetadata24Masked) SetValue(v []byte) {
11089 self.Value = v
11090}
11091
11092func (self *NxmTunMetadata24Masked) GetValueMask() []byte {
11093 return self.ValueMask
11094}
11095
11096func (self *NxmTunMetadata24Masked) SetValueMask(v []byte) {
11097 self.ValueMask = v
11098}
11099
11100func (self *NxmTunMetadata24Masked) Serialize(encoder *goloxi.Encoder) error {
11101 if err := self.Oxm.Serialize(encoder); err != nil {
11102 return err
11103 }
11104
11105 encoder.Write(self.Value)
11106 encoder.Write(self.ValueMask)
11107
11108 return nil
11109}
11110
11111func DecodeNxmTunMetadata24Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata24Masked, error) {
11112 _nxmtunmetadata24masked := &NxmTunMetadata24Masked{Oxm: parent}
11113 _nxmtunmetadata24masked.Value = decoder.Read(int(_nxmtunmetadata24masked.TypeLen & 0xFF))
11114 _nxmtunmetadata24masked.ValueMask = decoder.Read(int(_nxmtunmetadata24masked.TypeLen & 0xFF))
11115 return _nxmtunmetadata24masked, nil
11116}
11117
11118func NewNxmTunMetadata24Masked() *NxmTunMetadata24Masked {
11119 obj := &NxmTunMetadata24Masked{
11120 Oxm: NewOxm(98808),
11121 }
11122 return obj
11123}
11124func (self *NxmTunMetadata24Masked) GetOXMName() string {
11125 return "tun_metadata24_masked"
11126}
11127
11128func (self *NxmTunMetadata24Masked) GetOXMValue() interface{} {
11129 return self.Value
11130}
11131
11132func (self *NxmTunMetadata24Masked) GetOXMValueMask() interface{} {
11133 return self.ValueMask
11134}
11135
11136func (self *NxmTunMetadata24Masked) MarshalJSON() ([]byte, error) {
11137 value, err := jsonValue(self.GetOXMValue())
11138 if err != nil {
11139 return nil, err
11140 }
11141 valueMask, err := jsonValue(self.GetOXMValueMask())
11142 if err != nil {
11143 return nil, err
11144 }
11145 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
11146}
11147
11148type NxmTunMetadata25 struct {
11149 *Oxm
11150 Value []byte
11151}
11152
11153type INxmTunMetadata25 interface {
11154 goloxi.IOxm
11155 GetValue() []byte
11156}
11157
11158func (self *NxmTunMetadata25) GetValue() []byte {
11159 return self.Value
11160}
11161
11162func (self *NxmTunMetadata25) SetValue(v []byte) {
11163 self.Value = v
11164}
11165
11166func (self *NxmTunMetadata25) Serialize(encoder *goloxi.Encoder) error {
11167 if err := self.Oxm.Serialize(encoder); err != nil {
11168 return err
11169 }
11170
11171 encoder.Write(self.Value)
11172
11173 return nil
11174}
11175
11176func DecodeNxmTunMetadata25(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata25, error) {
11177 _nxmtunmetadata25 := &NxmTunMetadata25{Oxm: parent}
11178 _nxmtunmetadata25.Value = decoder.Read(int(_nxmtunmetadata25.TypeLen & 0xFF))
11179 return _nxmtunmetadata25, nil
11180}
11181
11182func NewNxmTunMetadata25() *NxmTunMetadata25 {
11183 obj := &NxmTunMetadata25{
11184 Oxm: NewOxm(98940),
11185 }
11186 return obj
11187}
11188func (self *NxmTunMetadata25) GetOXMName() string {
11189 return "tun_metadata25"
11190}
11191
11192func (self *NxmTunMetadata25) GetOXMValue() interface{} {
11193 return self.Value
11194}
11195
11196func (self *NxmTunMetadata25) MarshalJSON() ([]byte, error) {
11197 value, err := jsonValue(self.GetOXMValue())
11198 if err != nil {
11199 return nil, err
11200 }
11201 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
11202}
11203
11204type NxmTunMetadata25Masked struct {
11205 *Oxm
11206 Value []byte
11207 ValueMask []byte
11208}
11209
11210type INxmTunMetadata25Masked interface {
11211 goloxi.IOxm
11212 GetValue() []byte
11213 GetValueMask() []byte
11214}
11215
11216func (self *NxmTunMetadata25Masked) GetValue() []byte {
11217 return self.Value
11218}
11219
11220func (self *NxmTunMetadata25Masked) SetValue(v []byte) {
11221 self.Value = v
11222}
11223
11224func (self *NxmTunMetadata25Masked) GetValueMask() []byte {
11225 return self.ValueMask
11226}
11227
11228func (self *NxmTunMetadata25Masked) SetValueMask(v []byte) {
11229 self.ValueMask = v
11230}
11231
11232func (self *NxmTunMetadata25Masked) Serialize(encoder *goloxi.Encoder) error {
11233 if err := self.Oxm.Serialize(encoder); err != nil {
11234 return err
11235 }
11236
11237 encoder.Write(self.Value)
11238 encoder.Write(self.ValueMask)
11239
11240 return nil
11241}
11242
11243func DecodeNxmTunMetadata25Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata25Masked, error) {
11244 _nxmtunmetadata25masked := &NxmTunMetadata25Masked{Oxm: parent}
11245 _nxmtunmetadata25masked.Value = decoder.Read(int(_nxmtunmetadata25masked.TypeLen & 0xFF))
11246 _nxmtunmetadata25masked.ValueMask = decoder.Read(int(_nxmtunmetadata25masked.TypeLen & 0xFF))
11247 return _nxmtunmetadata25masked, nil
11248}
11249
11250func NewNxmTunMetadata25Masked() *NxmTunMetadata25Masked {
11251 obj := &NxmTunMetadata25Masked{
11252 Oxm: NewOxm(99320),
11253 }
11254 return obj
11255}
11256func (self *NxmTunMetadata25Masked) GetOXMName() string {
11257 return "tun_metadata25_masked"
11258}
11259
11260func (self *NxmTunMetadata25Masked) GetOXMValue() interface{} {
11261 return self.Value
11262}
11263
11264func (self *NxmTunMetadata25Masked) GetOXMValueMask() interface{} {
11265 return self.ValueMask
11266}
11267
11268func (self *NxmTunMetadata25Masked) MarshalJSON() ([]byte, error) {
11269 value, err := jsonValue(self.GetOXMValue())
11270 if err != nil {
11271 return nil, err
11272 }
11273 valueMask, err := jsonValue(self.GetOXMValueMask())
11274 if err != nil {
11275 return nil, err
11276 }
11277 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
11278}
11279
11280type NxmTunMetadata26 struct {
11281 *Oxm
11282 Value []byte
11283}
11284
11285type INxmTunMetadata26 interface {
11286 goloxi.IOxm
11287 GetValue() []byte
11288}
11289
11290func (self *NxmTunMetadata26) GetValue() []byte {
11291 return self.Value
11292}
11293
11294func (self *NxmTunMetadata26) SetValue(v []byte) {
11295 self.Value = v
11296}
11297
11298func (self *NxmTunMetadata26) Serialize(encoder *goloxi.Encoder) error {
11299 if err := self.Oxm.Serialize(encoder); err != nil {
11300 return err
11301 }
11302
11303 encoder.Write(self.Value)
11304
11305 return nil
11306}
11307
11308func DecodeNxmTunMetadata26(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata26, error) {
11309 _nxmtunmetadata26 := &NxmTunMetadata26{Oxm: parent}
11310 _nxmtunmetadata26.Value = decoder.Read(int(_nxmtunmetadata26.TypeLen & 0xFF))
11311 return _nxmtunmetadata26, nil
11312}
11313
11314func NewNxmTunMetadata26() *NxmTunMetadata26 {
11315 obj := &NxmTunMetadata26{
11316 Oxm: NewOxm(99452),
11317 }
11318 return obj
11319}
11320func (self *NxmTunMetadata26) GetOXMName() string {
11321 return "tun_metadata26"
11322}
11323
11324func (self *NxmTunMetadata26) GetOXMValue() interface{} {
11325 return self.Value
11326}
11327
11328func (self *NxmTunMetadata26) MarshalJSON() ([]byte, error) {
11329 value, err := jsonValue(self.GetOXMValue())
11330 if err != nil {
11331 return nil, err
11332 }
11333 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
11334}
11335
11336type NxmTunMetadata26Masked struct {
11337 *Oxm
11338 Value []byte
11339 ValueMask []byte
11340}
11341
11342type INxmTunMetadata26Masked interface {
11343 goloxi.IOxm
11344 GetValue() []byte
11345 GetValueMask() []byte
11346}
11347
11348func (self *NxmTunMetadata26Masked) GetValue() []byte {
11349 return self.Value
11350}
11351
11352func (self *NxmTunMetadata26Masked) SetValue(v []byte) {
11353 self.Value = v
11354}
11355
11356func (self *NxmTunMetadata26Masked) GetValueMask() []byte {
11357 return self.ValueMask
11358}
11359
11360func (self *NxmTunMetadata26Masked) SetValueMask(v []byte) {
11361 self.ValueMask = v
11362}
11363
11364func (self *NxmTunMetadata26Masked) Serialize(encoder *goloxi.Encoder) error {
11365 if err := self.Oxm.Serialize(encoder); err != nil {
11366 return err
11367 }
11368
11369 encoder.Write(self.Value)
11370 encoder.Write(self.ValueMask)
11371
11372 return nil
11373}
11374
11375func DecodeNxmTunMetadata26Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata26Masked, error) {
11376 _nxmtunmetadata26masked := &NxmTunMetadata26Masked{Oxm: parent}
11377 _nxmtunmetadata26masked.Value = decoder.Read(int(_nxmtunmetadata26masked.TypeLen & 0xFF))
11378 _nxmtunmetadata26masked.ValueMask = decoder.Read(int(_nxmtunmetadata26masked.TypeLen & 0xFF))
11379 return _nxmtunmetadata26masked, nil
11380}
11381
11382func NewNxmTunMetadata26Masked() *NxmTunMetadata26Masked {
11383 obj := &NxmTunMetadata26Masked{
11384 Oxm: NewOxm(99832),
11385 }
11386 return obj
11387}
11388func (self *NxmTunMetadata26Masked) GetOXMName() string {
11389 return "tun_metadata26_masked"
11390}
11391
11392func (self *NxmTunMetadata26Masked) GetOXMValue() interface{} {
11393 return self.Value
11394}
11395
11396func (self *NxmTunMetadata26Masked) GetOXMValueMask() interface{} {
11397 return self.ValueMask
11398}
11399
11400func (self *NxmTunMetadata26Masked) MarshalJSON() ([]byte, error) {
11401 value, err := jsonValue(self.GetOXMValue())
11402 if err != nil {
11403 return nil, err
11404 }
11405 valueMask, err := jsonValue(self.GetOXMValueMask())
11406 if err != nil {
11407 return nil, err
11408 }
11409 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
11410}
11411
11412type NxmTunMetadata27 struct {
11413 *Oxm
11414 Value []byte
11415}
11416
11417type INxmTunMetadata27 interface {
11418 goloxi.IOxm
11419 GetValue() []byte
11420}
11421
11422func (self *NxmTunMetadata27) GetValue() []byte {
11423 return self.Value
11424}
11425
11426func (self *NxmTunMetadata27) SetValue(v []byte) {
11427 self.Value = v
11428}
11429
11430func (self *NxmTunMetadata27) Serialize(encoder *goloxi.Encoder) error {
11431 if err := self.Oxm.Serialize(encoder); err != nil {
11432 return err
11433 }
11434
11435 encoder.Write(self.Value)
11436
11437 return nil
11438}
11439
11440func DecodeNxmTunMetadata27(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata27, error) {
11441 _nxmtunmetadata27 := &NxmTunMetadata27{Oxm: parent}
11442 _nxmtunmetadata27.Value = decoder.Read(int(_nxmtunmetadata27.TypeLen & 0xFF))
11443 return _nxmtunmetadata27, nil
11444}
11445
11446func NewNxmTunMetadata27() *NxmTunMetadata27 {
11447 obj := &NxmTunMetadata27{
11448 Oxm: NewOxm(99964),
11449 }
11450 return obj
11451}
11452func (self *NxmTunMetadata27) GetOXMName() string {
11453 return "tun_metadata27"
11454}
11455
11456func (self *NxmTunMetadata27) GetOXMValue() interface{} {
11457 return self.Value
11458}
11459
11460func (self *NxmTunMetadata27) MarshalJSON() ([]byte, error) {
11461 value, err := jsonValue(self.GetOXMValue())
11462 if err != nil {
11463 return nil, err
11464 }
11465 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
11466}
11467
11468type NxmTunMetadata27Masked struct {
11469 *Oxm
11470 Value []byte
11471 ValueMask []byte
11472}
11473
11474type INxmTunMetadata27Masked interface {
11475 goloxi.IOxm
11476 GetValue() []byte
11477 GetValueMask() []byte
11478}
11479
11480func (self *NxmTunMetadata27Masked) GetValue() []byte {
11481 return self.Value
11482}
11483
11484func (self *NxmTunMetadata27Masked) SetValue(v []byte) {
11485 self.Value = v
11486}
11487
11488func (self *NxmTunMetadata27Masked) GetValueMask() []byte {
11489 return self.ValueMask
11490}
11491
11492func (self *NxmTunMetadata27Masked) SetValueMask(v []byte) {
11493 self.ValueMask = v
11494}
11495
11496func (self *NxmTunMetadata27Masked) Serialize(encoder *goloxi.Encoder) error {
11497 if err := self.Oxm.Serialize(encoder); err != nil {
11498 return err
11499 }
11500
11501 encoder.Write(self.Value)
11502 encoder.Write(self.ValueMask)
11503
11504 return nil
11505}
11506
11507func DecodeNxmTunMetadata27Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata27Masked, error) {
11508 _nxmtunmetadata27masked := &NxmTunMetadata27Masked{Oxm: parent}
11509 _nxmtunmetadata27masked.Value = decoder.Read(int(_nxmtunmetadata27masked.TypeLen & 0xFF))
11510 _nxmtunmetadata27masked.ValueMask = decoder.Read(int(_nxmtunmetadata27masked.TypeLen & 0xFF))
11511 return _nxmtunmetadata27masked, nil
11512}
11513
11514func NewNxmTunMetadata27Masked() *NxmTunMetadata27Masked {
11515 obj := &NxmTunMetadata27Masked{
11516 Oxm: NewOxm(100344),
11517 }
11518 return obj
11519}
11520func (self *NxmTunMetadata27Masked) GetOXMName() string {
11521 return "tun_metadata27_masked"
11522}
11523
11524func (self *NxmTunMetadata27Masked) GetOXMValue() interface{} {
11525 return self.Value
11526}
11527
11528func (self *NxmTunMetadata27Masked) GetOXMValueMask() interface{} {
11529 return self.ValueMask
11530}
11531
11532func (self *NxmTunMetadata27Masked) MarshalJSON() ([]byte, error) {
11533 value, err := jsonValue(self.GetOXMValue())
11534 if err != nil {
11535 return nil, err
11536 }
11537 valueMask, err := jsonValue(self.GetOXMValueMask())
11538 if err != nil {
11539 return nil, err
11540 }
11541 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
11542}
11543
11544type NxmTunMetadata28 struct {
11545 *Oxm
11546 Value []byte
11547}
11548
11549type INxmTunMetadata28 interface {
11550 goloxi.IOxm
11551 GetValue() []byte
11552}
11553
11554func (self *NxmTunMetadata28) GetValue() []byte {
11555 return self.Value
11556}
11557
11558func (self *NxmTunMetadata28) SetValue(v []byte) {
11559 self.Value = v
11560}
11561
11562func (self *NxmTunMetadata28) Serialize(encoder *goloxi.Encoder) error {
11563 if err := self.Oxm.Serialize(encoder); err != nil {
11564 return err
11565 }
11566
11567 encoder.Write(self.Value)
11568
11569 return nil
11570}
11571
11572func DecodeNxmTunMetadata28(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata28, error) {
11573 _nxmtunmetadata28 := &NxmTunMetadata28{Oxm: parent}
11574 _nxmtunmetadata28.Value = decoder.Read(int(_nxmtunmetadata28.TypeLen & 0xFF))
11575 return _nxmtunmetadata28, nil
11576}
11577
11578func NewNxmTunMetadata28() *NxmTunMetadata28 {
11579 obj := &NxmTunMetadata28{
11580 Oxm: NewOxm(100476),
11581 }
11582 return obj
11583}
11584func (self *NxmTunMetadata28) GetOXMName() string {
11585 return "tun_metadata28"
11586}
11587
11588func (self *NxmTunMetadata28) GetOXMValue() interface{} {
11589 return self.Value
11590}
11591
11592func (self *NxmTunMetadata28) MarshalJSON() ([]byte, error) {
11593 value, err := jsonValue(self.GetOXMValue())
11594 if err != nil {
11595 return nil, err
11596 }
11597 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
11598}
11599
11600type NxmTunMetadata28Masked struct {
11601 *Oxm
11602 Value []byte
11603 ValueMask []byte
11604}
11605
11606type INxmTunMetadata28Masked interface {
11607 goloxi.IOxm
11608 GetValue() []byte
11609 GetValueMask() []byte
11610}
11611
11612func (self *NxmTunMetadata28Masked) GetValue() []byte {
11613 return self.Value
11614}
11615
11616func (self *NxmTunMetadata28Masked) SetValue(v []byte) {
11617 self.Value = v
11618}
11619
11620func (self *NxmTunMetadata28Masked) GetValueMask() []byte {
11621 return self.ValueMask
11622}
11623
11624func (self *NxmTunMetadata28Masked) SetValueMask(v []byte) {
11625 self.ValueMask = v
11626}
11627
11628func (self *NxmTunMetadata28Masked) Serialize(encoder *goloxi.Encoder) error {
11629 if err := self.Oxm.Serialize(encoder); err != nil {
11630 return err
11631 }
11632
11633 encoder.Write(self.Value)
11634 encoder.Write(self.ValueMask)
11635
11636 return nil
11637}
11638
11639func DecodeNxmTunMetadata28Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata28Masked, error) {
11640 _nxmtunmetadata28masked := &NxmTunMetadata28Masked{Oxm: parent}
11641 _nxmtunmetadata28masked.Value = decoder.Read(int(_nxmtunmetadata28masked.TypeLen & 0xFF))
11642 _nxmtunmetadata28masked.ValueMask = decoder.Read(int(_nxmtunmetadata28masked.TypeLen & 0xFF))
11643 return _nxmtunmetadata28masked, nil
11644}
11645
11646func NewNxmTunMetadata28Masked() *NxmTunMetadata28Masked {
11647 obj := &NxmTunMetadata28Masked{
11648 Oxm: NewOxm(100856),
11649 }
11650 return obj
11651}
11652func (self *NxmTunMetadata28Masked) GetOXMName() string {
11653 return "tun_metadata28_masked"
11654}
11655
11656func (self *NxmTunMetadata28Masked) GetOXMValue() interface{} {
11657 return self.Value
11658}
11659
11660func (self *NxmTunMetadata28Masked) GetOXMValueMask() interface{} {
11661 return self.ValueMask
11662}
11663
11664func (self *NxmTunMetadata28Masked) MarshalJSON() ([]byte, error) {
11665 value, err := jsonValue(self.GetOXMValue())
11666 if err != nil {
11667 return nil, err
11668 }
11669 valueMask, err := jsonValue(self.GetOXMValueMask())
11670 if err != nil {
11671 return nil, err
11672 }
11673 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
11674}
11675
11676type NxmTunMetadata29 struct {
11677 *Oxm
11678 Value []byte
11679}
11680
11681type INxmTunMetadata29 interface {
11682 goloxi.IOxm
11683 GetValue() []byte
11684}
11685
11686func (self *NxmTunMetadata29) GetValue() []byte {
11687 return self.Value
11688}
11689
11690func (self *NxmTunMetadata29) SetValue(v []byte) {
11691 self.Value = v
11692}
11693
11694func (self *NxmTunMetadata29) Serialize(encoder *goloxi.Encoder) error {
11695 if err := self.Oxm.Serialize(encoder); err != nil {
11696 return err
11697 }
11698
11699 encoder.Write(self.Value)
11700
11701 return nil
11702}
11703
11704func DecodeNxmTunMetadata29(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata29, error) {
11705 _nxmtunmetadata29 := &NxmTunMetadata29{Oxm: parent}
11706 _nxmtunmetadata29.Value = decoder.Read(int(_nxmtunmetadata29.TypeLen & 0xFF))
11707 return _nxmtunmetadata29, nil
11708}
11709
11710func NewNxmTunMetadata29() *NxmTunMetadata29 {
11711 obj := &NxmTunMetadata29{
11712 Oxm: NewOxm(100988),
11713 }
11714 return obj
11715}
11716func (self *NxmTunMetadata29) GetOXMName() string {
11717 return "tun_metadata29"
11718}
11719
11720func (self *NxmTunMetadata29) GetOXMValue() interface{} {
11721 return self.Value
11722}
11723
11724func (self *NxmTunMetadata29) MarshalJSON() ([]byte, error) {
11725 value, err := jsonValue(self.GetOXMValue())
11726 if err != nil {
11727 return nil, err
11728 }
11729 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
11730}
11731
11732type NxmTunMetadata29Masked struct {
11733 *Oxm
11734 Value []byte
11735 ValueMask []byte
11736}
11737
11738type INxmTunMetadata29Masked interface {
11739 goloxi.IOxm
11740 GetValue() []byte
11741 GetValueMask() []byte
11742}
11743
11744func (self *NxmTunMetadata29Masked) GetValue() []byte {
11745 return self.Value
11746}
11747
11748func (self *NxmTunMetadata29Masked) SetValue(v []byte) {
11749 self.Value = v
11750}
11751
11752func (self *NxmTunMetadata29Masked) GetValueMask() []byte {
11753 return self.ValueMask
11754}
11755
11756func (self *NxmTunMetadata29Masked) SetValueMask(v []byte) {
11757 self.ValueMask = v
11758}
11759
11760func (self *NxmTunMetadata29Masked) Serialize(encoder *goloxi.Encoder) error {
11761 if err := self.Oxm.Serialize(encoder); err != nil {
11762 return err
11763 }
11764
11765 encoder.Write(self.Value)
11766 encoder.Write(self.ValueMask)
11767
11768 return nil
11769}
11770
11771func DecodeNxmTunMetadata29Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata29Masked, error) {
11772 _nxmtunmetadata29masked := &NxmTunMetadata29Masked{Oxm: parent}
11773 _nxmtunmetadata29masked.Value = decoder.Read(int(_nxmtunmetadata29masked.TypeLen & 0xFF))
11774 _nxmtunmetadata29masked.ValueMask = decoder.Read(int(_nxmtunmetadata29masked.TypeLen & 0xFF))
11775 return _nxmtunmetadata29masked, nil
11776}
11777
11778func NewNxmTunMetadata29Masked() *NxmTunMetadata29Masked {
11779 obj := &NxmTunMetadata29Masked{
11780 Oxm: NewOxm(101368),
11781 }
11782 return obj
11783}
11784func (self *NxmTunMetadata29Masked) GetOXMName() string {
11785 return "tun_metadata29_masked"
11786}
11787
11788func (self *NxmTunMetadata29Masked) GetOXMValue() interface{} {
11789 return self.Value
11790}
11791
11792func (self *NxmTunMetadata29Masked) GetOXMValueMask() interface{} {
11793 return self.ValueMask
11794}
11795
11796func (self *NxmTunMetadata29Masked) MarshalJSON() ([]byte, error) {
11797 value, err := jsonValue(self.GetOXMValue())
11798 if err != nil {
11799 return nil, err
11800 }
11801 valueMask, err := jsonValue(self.GetOXMValueMask())
11802 if err != nil {
11803 return nil, err
11804 }
11805 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
11806}
11807
11808type NxmTunMetadata2Masked struct {
11809 *Oxm
11810 Value []byte
11811 ValueMask []byte
11812}
11813
11814type INxmTunMetadata2Masked interface {
11815 goloxi.IOxm
11816 GetValue() []byte
11817 GetValueMask() []byte
11818}
11819
11820func (self *NxmTunMetadata2Masked) GetValue() []byte {
11821 return self.Value
11822}
11823
11824func (self *NxmTunMetadata2Masked) SetValue(v []byte) {
11825 self.Value = v
11826}
11827
11828func (self *NxmTunMetadata2Masked) GetValueMask() []byte {
11829 return self.ValueMask
11830}
11831
11832func (self *NxmTunMetadata2Masked) SetValueMask(v []byte) {
11833 self.ValueMask = v
11834}
11835
11836func (self *NxmTunMetadata2Masked) Serialize(encoder *goloxi.Encoder) error {
11837 if err := self.Oxm.Serialize(encoder); err != nil {
11838 return err
11839 }
11840
11841 encoder.Write(self.Value)
11842 encoder.Write(self.ValueMask)
11843
11844 return nil
11845}
11846
11847func DecodeNxmTunMetadata2Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata2Masked, error) {
11848 _nxmtunmetadata2masked := &NxmTunMetadata2Masked{Oxm: parent}
11849 _nxmtunmetadata2masked.Value = decoder.Read(int(_nxmtunmetadata2masked.TypeLen & 0xFF))
11850 _nxmtunmetadata2masked.ValueMask = decoder.Read(int(_nxmtunmetadata2masked.TypeLen & 0xFF))
11851 return _nxmtunmetadata2masked, nil
11852}
11853
11854func NewNxmTunMetadata2Masked() *NxmTunMetadata2Masked {
11855 obj := &NxmTunMetadata2Masked{
11856 Oxm: NewOxm(87544),
11857 }
11858 return obj
11859}
11860func (self *NxmTunMetadata2Masked) GetOXMName() string {
11861 return "tun_metadata2_masked"
11862}
11863
11864func (self *NxmTunMetadata2Masked) GetOXMValue() interface{} {
11865 return self.Value
11866}
11867
11868func (self *NxmTunMetadata2Masked) GetOXMValueMask() interface{} {
11869 return self.ValueMask
11870}
11871
11872func (self *NxmTunMetadata2Masked) MarshalJSON() ([]byte, error) {
11873 value, err := jsonValue(self.GetOXMValue())
11874 if err != nil {
11875 return nil, err
11876 }
11877 valueMask, err := jsonValue(self.GetOXMValueMask())
11878 if err != nil {
11879 return nil, err
11880 }
11881 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
11882}
11883
11884type NxmTunMetadata3 struct {
11885 *Oxm
11886 Value []byte
11887}
11888
11889type INxmTunMetadata3 interface {
11890 goloxi.IOxm
11891 GetValue() []byte
11892}
11893
11894func (self *NxmTunMetadata3) GetValue() []byte {
11895 return self.Value
11896}
11897
11898func (self *NxmTunMetadata3) SetValue(v []byte) {
11899 self.Value = v
11900}
11901
11902func (self *NxmTunMetadata3) Serialize(encoder *goloxi.Encoder) error {
11903 if err := self.Oxm.Serialize(encoder); err != nil {
11904 return err
11905 }
11906
11907 encoder.Write(self.Value)
11908
11909 return nil
11910}
11911
11912func DecodeNxmTunMetadata3(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata3, error) {
11913 _nxmtunmetadata3 := &NxmTunMetadata3{Oxm: parent}
11914 _nxmtunmetadata3.Value = decoder.Read(int(_nxmtunmetadata3.TypeLen & 0xFF))
11915 return _nxmtunmetadata3, nil
11916}
11917
11918func NewNxmTunMetadata3() *NxmTunMetadata3 {
11919 obj := &NxmTunMetadata3{
11920 Oxm: NewOxm(87676),
11921 }
11922 return obj
11923}
11924func (self *NxmTunMetadata3) GetOXMName() string {
11925 return "tun_metadata3"
11926}
11927
11928func (self *NxmTunMetadata3) GetOXMValue() interface{} {
11929 return self.Value
11930}
11931
11932func (self *NxmTunMetadata3) MarshalJSON() ([]byte, error) {
11933 value, err := jsonValue(self.GetOXMValue())
11934 if err != nil {
11935 return nil, err
11936 }
11937 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
11938}
11939
11940type NxmTunMetadata30 struct {
11941 *Oxm
11942 Value []byte
11943}
11944
11945type INxmTunMetadata30 interface {
11946 goloxi.IOxm
11947 GetValue() []byte
11948}
11949
11950func (self *NxmTunMetadata30) GetValue() []byte {
11951 return self.Value
11952}
11953
11954func (self *NxmTunMetadata30) SetValue(v []byte) {
11955 self.Value = v
11956}
11957
11958func (self *NxmTunMetadata30) Serialize(encoder *goloxi.Encoder) error {
11959 if err := self.Oxm.Serialize(encoder); err != nil {
11960 return err
11961 }
11962
11963 encoder.Write(self.Value)
11964
11965 return nil
11966}
11967
11968func DecodeNxmTunMetadata30(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata30, error) {
11969 _nxmtunmetadata30 := &NxmTunMetadata30{Oxm: parent}
11970 _nxmtunmetadata30.Value = decoder.Read(int(_nxmtunmetadata30.TypeLen & 0xFF))
11971 return _nxmtunmetadata30, nil
11972}
11973
11974func NewNxmTunMetadata30() *NxmTunMetadata30 {
11975 obj := &NxmTunMetadata30{
11976 Oxm: NewOxm(101500),
11977 }
11978 return obj
11979}
11980func (self *NxmTunMetadata30) GetOXMName() string {
11981 return "tun_metadata30"
11982}
11983
11984func (self *NxmTunMetadata30) GetOXMValue() interface{} {
11985 return self.Value
11986}
11987
11988func (self *NxmTunMetadata30) MarshalJSON() ([]byte, error) {
11989 value, err := jsonValue(self.GetOXMValue())
11990 if err != nil {
11991 return nil, err
11992 }
11993 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
11994}
11995
11996type NxmTunMetadata30Masked struct {
11997 *Oxm
11998 Value []byte
11999 ValueMask []byte
12000}
12001
12002type INxmTunMetadata30Masked interface {
12003 goloxi.IOxm
12004 GetValue() []byte
12005 GetValueMask() []byte
12006}
12007
12008func (self *NxmTunMetadata30Masked) GetValue() []byte {
12009 return self.Value
12010}
12011
12012func (self *NxmTunMetadata30Masked) SetValue(v []byte) {
12013 self.Value = v
12014}
12015
12016func (self *NxmTunMetadata30Masked) GetValueMask() []byte {
12017 return self.ValueMask
12018}
12019
12020func (self *NxmTunMetadata30Masked) SetValueMask(v []byte) {
12021 self.ValueMask = v
12022}
12023
12024func (self *NxmTunMetadata30Masked) Serialize(encoder *goloxi.Encoder) error {
12025 if err := self.Oxm.Serialize(encoder); err != nil {
12026 return err
12027 }
12028
12029 encoder.Write(self.Value)
12030 encoder.Write(self.ValueMask)
12031
12032 return nil
12033}
12034
12035func DecodeNxmTunMetadata30Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata30Masked, error) {
12036 _nxmtunmetadata30masked := &NxmTunMetadata30Masked{Oxm: parent}
12037 _nxmtunmetadata30masked.Value = decoder.Read(int(_nxmtunmetadata30masked.TypeLen & 0xFF))
12038 _nxmtunmetadata30masked.ValueMask = decoder.Read(int(_nxmtunmetadata30masked.TypeLen & 0xFF))
12039 return _nxmtunmetadata30masked, nil
12040}
12041
12042func NewNxmTunMetadata30Masked() *NxmTunMetadata30Masked {
12043 obj := &NxmTunMetadata30Masked{
12044 Oxm: NewOxm(101880),
12045 }
12046 return obj
12047}
12048func (self *NxmTunMetadata30Masked) GetOXMName() string {
12049 return "tun_metadata30_masked"
12050}
12051
12052func (self *NxmTunMetadata30Masked) GetOXMValue() interface{} {
12053 return self.Value
12054}
12055
12056func (self *NxmTunMetadata30Masked) GetOXMValueMask() interface{} {
12057 return self.ValueMask
12058}
12059
12060func (self *NxmTunMetadata30Masked) MarshalJSON() ([]byte, error) {
12061 value, err := jsonValue(self.GetOXMValue())
12062 if err != nil {
12063 return nil, err
12064 }
12065 valueMask, err := jsonValue(self.GetOXMValueMask())
12066 if err != nil {
12067 return nil, err
12068 }
12069 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
12070}
12071
12072type NxmTunMetadata31 struct {
12073 *Oxm
12074 Value []byte
12075}
12076
12077type INxmTunMetadata31 interface {
12078 goloxi.IOxm
12079 GetValue() []byte
12080}
12081
12082func (self *NxmTunMetadata31) GetValue() []byte {
12083 return self.Value
12084}
12085
12086func (self *NxmTunMetadata31) SetValue(v []byte) {
12087 self.Value = v
12088}
12089
12090func (self *NxmTunMetadata31) Serialize(encoder *goloxi.Encoder) error {
12091 if err := self.Oxm.Serialize(encoder); err != nil {
12092 return err
12093 }
12094
12095 encoder.Write(self.Value)
12096
12097 return nil
12098}
12099
12100func DecodeNxmTunMetadata31(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata31, error) {
12101 _nxmtunmetadata31 := &NxmTunMetadata31{Oxm: parent}
12102 _nxmtunmetadata31.Value = decoder.Read(int(_nxmtunmetadata31.TypeLen & 0xFF))
12103 return _nxmtunmetadata31, nil
12104}
12105
12106func NewNxmTunMetadata31() *NxmTunMetadata31 {
12107 obj := &NxmTunMetadata31{
12108 Oxm: NewOxm(102012),
12109 }
12110 return obj
12111}
12112func (self *NxmTunMetadata31) GetOXMName() string {
12113 return "tun_metadata31"
12114}
12115
12116func (self *NxmTunMetadata31) GetOXMValue() interface{} {
12117 return self.Value
12118}
12119
12120func (self *NxmTunMetadata31) MarshalJSON() ([]byte, error) {
12121 value, err := jsonValue(self.GetOXMValue())
12122 if err != nil {
12123 return nil, err
12124 }
12125 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
12126}
12127
12128type NxmTunMetadata31Masked struct {
12129 *Oxm
12130 Value []byte
12131 ValueMask []byte
12132}
12133
12134type INxmTunMetadata31Masked interface {
12135 goloxi.IOxm
12136 GetValue() []byte
12137 GetValueMask() []byte
12138}
12139
12140func (self *NxmTunMetadata31Masked) GetValue() []byte {
12141 return self.Value
12142}
12143
12144func (self *NxmTunMetadata31Masked) SetValue(v []byte) {
12145 self.Value = v
12146}
12147
12148func (self *NxmTunMetadata31Masked) GetValueMask() []byte {
12149 return self.ValueMask
12150}
12151
12152func (self *NxmTunMetadata31Masked) SetValueMask(v []byte) {
12153 self.ValueMask = v
12154}
12155
12156func (self *NxmTunMetadata31Masked) Serialize(encoder *goloxi.Encoder) error {
12157 if err := self.Oxm.Serialize(encoder); err != nil {
12158 return err
12159 }
12160
12161 encoder.Write(self.Value)
12162 encoder.Write(self.ValueMask)
12163
12164 return nil
12165}
12166
12167func DecodeNxmTunMetadata31Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata31Masked, error) {
12168 _nxmtunmetadata31masked := &NxmTunMetadata31Masked{Oxm: parent}
12169 _nxmtunmetadata31masked.Value = decoder.Read(int(_nxmtunmetadata31masked.TypeLen & 0xFF))
12170 _nxmtunmetadata31masked.ValueMask = decoder.Read(int(_nxmtunmetadata31masked.TypeLen & 0xFF))
12171 return _nxmtunmetadata31masked, nil
12172}
12173
12174func NewNxmTunMetadata31Masked() *NxmTunMetadata31Masked {
12175 obj := &NxmTunMetadata31Masked{
12176 Oxm: NewOxm(102392),
12177 }
12178 return obj
12179}
12180func (self *NxmTunMetadata31Masked) GetOXMName() string {
12181 return "tun_metadata31_masked"
12182}
12183
12184func (self *NxmTunMetadata31Masked) GetOXMValue() interface{} {
12185 return self.Value
12186}
12187
12188func (self *NxmTunMetadata31Masked) GetOXMValueMask() interface{} {
12189 return self.ValueMask
12190}
12191
12192func (self *NxmTunMetadata31Masked) MarshalJSON() ([]byte, error) {
12193 value, err := jsonValue(self.GetOXMValue())
12194 if err != nil {
12195 return nil, err
12196 }
12197 valueMask, err := jsonValue(self.GetOXMValueMask())
12198 if err != nil {
12199 return nil, err
12200 }
12201 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
12202}
12203
12204type NxmTunMetadata32 struct {
12205 *Oxm
12206 Value []byte
12207}
12208
12209type INxmTunMetadata32 interface {
12210 goloxi.IOxm
12211 GetValue() []byte
12212}
12213
12214func (self *NxmTunMetadata32) GetValue() []byte {
12215 return self.Value
12216}
12217
12218func (self *NxmTunMetadata32) SetValue(v []byte) {
12219 self.Value = v
12220}
12221
12222func (self *NxmTunMetadata32) Serialize(encoder *goloxi.Encoder) error {
12223 if err := self.Oxm.Serialize(encoder); err != nil {
12224 return err
12225 }
12226
12227 encoder.Write(self.Value)
12228
12229 return nil
12230}
12231
12232func DecodeNxmTunMetadata32(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata32, error) {
12233 _nxmtunmetadata32 := &NxmTunMetadata32{Oxm: parent}
12234 _nxmtunmetadata32.Value = decoder.Read(int(_nxmtunmetadata32.TypeLen & 0xFF))
12235 return _nxmtunmetadata32, nil
12236}
12237
12238func NewNxmTunMetadata32() *NxmTunMetadata32 {
12239 obj := &NxmTunMetadata32{
12240 Oxm: NewOxm(102524),
12241 }
12242 return obj
12243}
12244func (self *NxmTunMetadata32) GetOXMName() string {
12245 return "tun_metadata32"
12246}
12247
12248func (self *NxmTunMetadata32) GetOXMValue() interface{} {
12249 return self.Value
12250}
12251
12252func (self *NxmTunMetadata32) MarshalJSON() ([]byte, error) {
12253 value, err := jsonValue(self.GetOXMValue())
12254 if err != nil {
12255 return nil, err
12256 }
12257 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
12258}
12259
12260type NxmTunMetadata32Masked struct {
12261 *Oxm
12262 Value []byte
12263 ValueMask []byte
12264}
12265
12266type INxmTunMetadata32Masked interface {
12267 goloxi.IOxm
12268 GetValue() []byte
12269 GetValueMask() []byte
12270}
12271
12272func (self *NxmTunMetadata32Masked) GetValue() []byte {
12273 return self.Value
12274}
12275
12276func (self *NxmTunMetadata32Masked) SetValue(v []byte) {
12277 self.Value = v
12278}
12279
12280func (self *NxmTunMetadata32Masked) GetValueMask() []byte {
12281 return self.ValueMask
12282}
12283
12284func (self *NxmTunMetadata32Masked) SetValueMask(v []byte) {
12285 self.ValueMask = v
12286}
12287
12288func (self *NxmTunMetadata32Masked) Serialize(encoder *goloxi.Encoder) error {
12289 if err := self.Oxm.Serialize(encoder); err != nil {
12290 return err
12291 }
12292
12293 encoder.Write(self.Value)
12294 encoder.Write(self.ValueMask)
12295
12296 return nil
12297}
12298
12299func DecodeNxmTunMetadata32Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata32Masked, error) {
12300 _nxmtunmetadata32masked := &NxmTunMetadata32Masked{Oxm: parent}
12301 _nxmtunmetadata32masked.Value = decoder.Read(int(_nxmtunmetadata32masked.TypeLen & 0xFF))
12302 _nxmtunmetadata32masked.ValueMask = decoder.Read(int(_nxmtunmetadata32masked.TypeLen & 0xFF))
12303 return _nxmtunmetadata32masked, nil
12304}
12305
12306func NewNxmTunMetadata32Masked() *NxmTunMetadata32Masked {
12307 obj := &NxmTunMetadata32Masked{
12308 Oxm: NewOxm(102904),
12309 }
12310 return obj
12311}
12312func (self *NxmTunMetadata32Masked) GetOXMName() string {
12313 return "tun_metadata32_masked"
12314}
12315
12316func (self *NxmTunMetadata32Masked) GetOXMValue() interface{} {
12317 return self.Value
12318}
12319
12320func (self *NxmTunMetadata32Masked) GetOXMValueMask() interface{} {
12321 return self.ValueMask
12322}
12323
12324func (self *NxmTunMetadata32Masked) MarshalJSON() ([]byte, error) {
12325 value, err := jsonValue(self.GetOXMValue())
12326 if err != nil {
12327 return nil, err
12328 }
12329 valueMask, err := jsonValue(self.GetOXMValueMask())
12330 if err != nil {
12331 return nil, err
12332 }
12333 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
12334}
12335
12336type NxmTunMetadata33 struct {
12337 *Oxm
12338 Value []byte
12339}
12340
12341type INxmTunMetadata33 interface {
12342 goloxi.IOxm
12343 GetValue() []byte
12344}
12345
12346func (self *NxmTunMetadata33) GetValue() []byte {
12347 return self.Value
12348}
12349
12350func (self *NxmTunMetadata33) SetValue(v []byte) {
12351 self.Value = v
12352}
12353
12354func (self *NxmTunMetadata33) Serialize(encoder *goloxi.Encoder) error {
12355 if err := self.Oxm.Serialize(encoder); err != nil {
12356 return err
12357 }
12358
12359 encoder.Write(self.Value)
12360
12361 return nil
12362}
12363
12364func DecodeNxmTunMetadata33(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata33, error) {
12365 _nxmtunmetadata33 := &NxmTunMetadata33{Oxm: parent}
12366 _nxmtunmetadata33.Value = decoder.Read(int(_nxmtunmetadata33.TypeLen & 0xFF))
12367 return _nxmtunmetadata33, nil
12368}
12369
12370func NewNxmTunMetadata33() *NxmTunMetadata33 {
12371 obj := &NxmTunMetadata33{
12372 Oxm: NewOxm(103036),
12373 }
12374 return obj
12375}
12376func (self *NxmTunMetadata33) GetOXMName() string {
12377 return "tun_metadata33"
12378}
12379
12380func (self *NxmTunMetadata33) GetOXMValue() interface{} {
12381 return self.Value
12382}
12383
12384func (self *NxmTunMetadata33) MarshalJSON() ([]byte, error) {
12385 value, err := jsonValue(self.GetOXMValue())
12386 if err != nil {
12387 return nil, err
12388 }
12389 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
12390}
12391
12392type NxmTunMetadata33Masked struct {
12393 *Oxm
12394 Value []byte
12395 ValueMask []byte
12396}
12397
12398type INxmTunMetadata33Masked interface {
12399 goloxi.IOxm
12400 GetValue() []byte
12401 GetValueMask() []byte
12402}
12403
12404func (self *NxmTunMetadata33Masked) GetValue() []byte {
12405 return self.Value
12406}
12407
12408func (self *NxmTunMetadata33Masked) SetValue(v []byte) {
12409 self.Value = v
12410}
12411
12412func (self *NxmTunMetadata33Masked) GetValueMask() []byte {
12413 return self.ValueMask
12414}
12415
12416func (self *NxmTunMetadata33Masked) SetValueMask(v []byte) {
12417 self.ValueMask = v
12418}
12419
12420func (self *NxmTunMetadata33Masked) Serialize(encoder *goloxi.Encoder) error {
12421 if err := self.Oxm.Serialize(encoder); err != nil {
12422 return err
12423 }
12424
12425 encoder.Write(self.Value)
12426 encoder.Write(self.ValueMask)
12427
12428 return nil
12429}
12430
12431func DecodeNxmTunMetadata33Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata33Masked, error) {
12432 _nxmtunmetadata33masked := &NxmTunMetadata33Masked{Oxm: parent}
12433 _nxmtunmetadata33masked.Value = decoder.Read(int(_nxmtunmetadata33masked.TypeLen & 0xFF))
12434 _nxmtunmetadata33masked.ValueMask = decoder.Read(int(_nxmtunmetadata33masked.TypeLen & 0xFF))
12435 return _nxmtunmetadata33masked, nil
12436}
12437
12438func NewNxmTunMetadata33Masked() *NxmTunMetadata33Masked {
12439 obj := &NxmTunMetadata33Masked{
12440 Oxm: NewOxm(103416),
12441 }
12442 return obj
12443}
12444func (self *NxmTunMetadata33Masked) GetOXMName() string {
12445 return "tun_metadata33_masked"
12446}
12447
12448func (self *NxmTunMetadata33Masked) GetOXMValue() interface{} {
12449 return self.Value
12450}
12451
12452func (self *NxmTunMetadata33Masked) GetOXMValueMask() interface{} {
12453 return self.ValueMask
12454}
12455
12456func (self *NxmTunMetadata33Masked) MarshalJSON() ([]byte, error) {
12457 value, err := jsonValue(self.GetOXMValue())
12458 if err != nil {
12459 return nil, err
12460 }
12461 valueMask, err := jsonValue(self.GetOXMValueMask())
12462 if err != nil {
12463 return nil, err
12464 }
12465 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
12466}
12467
12468type NxmTunMetadata34 struct {
12469 *Oxm
12470 Value []byte
12471}
12472
12473type INxmTunMetadata34 interface {
12474 goloxi.IOxm
12475 GetValue() []byte
12476}
12477
12478func (self *NxmTunMetadata34) GetValue() []byte {
12479 return self.Value
12480}
12481
12482func (self *NxmTunMetadata34) SetValue(v []byte) {
12483 self.Value = v
12484}
12485
12486func (self *NxmTunMetadata34) Serialize(encoder *goloxi.Encoder) error {
12487 if err := self.Oxm.Serialize(encoder); err != nil {
12488 return err
12489 }
12490
12491 encoder.Write(self.Value)
12492
12493 return nil
12494}
12495
12496func DecodeNxmTunMetadata34(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata34, error) {
12497 _nxmtunmetadata34 := &NxmTunMetadata34{Oxm: parent}
12498 _nxmtunmetadata34.Value = decoder.Read(int(_nxmtunmetadata34.TypeLen & 0xFF))
12499 return _nxmtunmetadata34, nil
12500}
12501
12502func NewNxmTunMetadata34() *NxmTunMetadata34 {
12503 obj := &NxmTunMetadata34{
12504 Oxm: NewOxm(103548),
12505 }
12506 return obj
12507}
12508func (self *NxmTunMetadata34) GetOXMName() string {
12509 return "tun_metadata34"
12510}
12511
12512func (self *NxmTunMetadata34) GetOXMValue() interface{} {
12513 return self.Value
12514}
12515
12516func (self *NxmTunMetadata34) MarshalJSON() ([]byte, error) {
12517 value, err := jsonValue(self.GetOXMValue())
12518 if err != nil {
12519 return nil, err
12520 }
12521 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
12522}
12523
12524type NxmTunMetadata34Masked struct {
12525 *Oxm
12526 Value []byte
12527 ValueMask []byte
12528}
12529
12530type INxmTunMetadata34Masked interface {
12531 goloxi.IOxm
12532 GetValue() []byte
12533 GetValueMask() []byte
12534}
12535
12536func (self *NxmTunMetadata34Masked) GetValue() []byte {
12537 return self.Value
12538}
12539
12540func (self *NxmTunMetadata34Masked) SetValue(v []byte) {
12541 self.Value = v
12542}
12543
12544func (self *NxmTunMetadata34Masked) GetValueMask() []byte {
12545 return self.ValueMask
12546}
12547
12548func (self *NxmTunMetadata34Masked) SetValueMask(v []byte) {
12549 self.ValueMask = v
12550}
12551
12552func (self *NxmTunMetadata34Masked) Serialize(encoder *goloxi.Encoder) error {
12553 if err := self.Oxm.Serialize(encoder); err != nil {
12554 return err
12555 }
12556
12557 encoder.Write(self.Value)
12558 encoder.Write(self.ValueMask)
12559
12560 return nil
12561}
12562
12563func DecodeNxmTunMetadata34Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata34Masked, error) {
12564 _nxmtunmetadata34masked := &NxmTunMetadata34Masked{Oxm: parent}
12565 _nxmtunmetadata34masked.Value = decoder.Read(int(_nxmtunmetadata34masked.TypeLen & 0xFF))
12566 _nxmtunmetadata34masked.ValueMask = decoder.Read(int(_nxmtunmetadata34masked.TypeLen & 0xFF))
12567 return _nxmtunmetadata34masked, nil
12568}
12569
12570func NewNxmTunMetadata34Masked() *NxmTunMetadata34Masked {
12571 obj := &NxmTunMetadata34Masked{
12572 Oxm: NewOxm(103928),
12573 }
12574 return obj
12575}
12576func (self *NxmTunMetadata34Masked) GetOXMName() string {
12577 return "tun_metadata34_masked"
12578}
12579
12580func (self *NxmTunMetadata34Masked) GetOXMValue() interface{} {
12581 return self.Value
12582}
12583
12584func (self *NxmTunMetadata34Masked) GetOXMValueMask() interface{} {
12585 return self.ValueMask
12586}
12587
12588func (self *NxmTunMetadata34Masked) MarshalJSON() ([]byte, error) {
12589 value, err := jsonValue(self.GetOXMValue())
12590 if err != nil {
12591 return nil, err
12592 }
12593 valueMask, err := jsonValue(self.GetOXMValueMask())
12594 if err != nil {
12595 return nil, err
12596 }
12597 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
12598}
12599
12600type NxmTunMetadata35 struct {
12601 *Oxm
12602 Value []byte
12603}
12604
12605type INxmTunMetadata35 interface {
12606 goloxi.IOxm
12607 GetValue() []byte
12608}
12609
12610func (self *NxmTunMetadata35) GetValue() []byte {
12611 return self.Value
12612}
12613
12614func (self *NxmTunMetadata35) SetValue(v []byte) {
12615 self.Value = v
12616}
12617
12618func (self *NxmTunMetadata35) Serialize(encoder *goloxi.Encoder) error {
12619 if err := self.Oxm.Serialize(encoder); err != nil {
12620 return err
12621 }
12622
12623 encoder.Write(self.Value)
12624
12625 return nil
12626}
12627
12628func DecodeNxmTunMetadata35(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata35, error) {
12629 _nxmtunmetadata35 := &NxmTunMetadata35{Oxm: parent}
12630 _nxmtunmetadata35.Value = decoder.Read(int(_nxmtunmetadata35.TypeLen & 0xFF))
12631 return _nxmtunmetadata35, nil
12632}
12633
12634func NewNxmTunMetadata35() *NxmTunMetadata35 {
12635 obj := &NxmTunMetadata35{
12636 Oxm: NewOxm(104060),
12637 }
12638 return obj
12639}
12640func (self *NxmTunMetadata35) GetOXMName() string {
12641 return "tun_metadata35"
12642}
12643
12644func (self *NxmTunMetadata35) GetOXMValue() interface{} {
12645 return self.Value
12646}
12647
12648func (self *NxmTunMetadata35) MarshalJSON() ([]byte, error) {
12649 value, err := jsonValue(self.GetOXMValue())
12650 if err != nil {
12651 return nil, err
12652 }
12653 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
12654}
12655
12656type NxmTunMetadata35Masked struct {
12657 *Oxm
12658 Value []byte
12659 ValueMask []byte
12660}
12661
12662type INxmTunMetadata35Masked interface {
12663 goloxi.IOxm
12664 GetValue() []byte
12665 GetValueMask() []byte
12666}
12667
12668func (self *NxmTunMetadata35Masked) GetValue() []byte {
12669 return self.Value
12670}
12671
12672func (self *NxmTunMetadata35Masked) SetValue(v []byte) {
12673 self.Value = v
12674}
12675
12676func (self *NxmTunMetadata35Masked) GetValueMask() []byte {
12677 return self.ValueMask
12678}
12679
12680func (self *NxmTunMetadata35Masked) SetValueMask(v []byte) {
12681 self.ValueMask = v
12682}
12683
12684func (self *NxmTunMetadata35Masked) Serialize(encoder *goloxi.Encoder) error {
12685 if err := self.Oxm.Serialize(encoder); err != nil {
12686 return err
12687 }
12688
12689 encoder.Write(self.Value)
12690 encoder.Write(self.ValueMask)
12691
12692 return nil
12693}
12694
12695func DecodeNxmTunMetadata35Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata35Masked, error) {
12696 _nxmtunmetadata35masked := &NxmTunMetadata35Masked{Oxm: parent}
12697 _nxmtunmetadata35masked.Value = decoder.Read(int(_nxmtunmetadata35masked.TypeLen & 0xFF))
12698 _nxmtunmetadata35masked.ValueMask = decoder.Read(int(_nxmtunmetadata35masked.TypeLen & 0xFF))
12699 return _nxmtunmetadata35masked, nil
12700}
12701
12702func NewNxmTunMetadata35Masked() *NxmTunMetadata35Masked {
12703 obj := &NxmTunMetadata35Masked{
12704 Oxm: NewOxm(104440),
12705 }
12706 return obj
12707}
12708func (self *NxmTunMetadata35Masked) GetOXMName() string {
12709 return "tun_metadata35_masked"
12710}
12711
12712func (self *NxmTunMetadata35Masked) GetOXMValue() interface{} {
12713 return self.Value
12714}
12715
12716func (self *NxmTunMetadata35Masked) GetOXMValueMask() interface{} {
12717 return self.ValueMask
12718}
12719
12720func (self *NxmTunMetadata35Masked) MarshalJSON() ([]byte, error) {
12721 value, err := jsonValue(self.GetOXMValue())
12722 if err != nil {
12723 return nil, err
12724 }
12725 valueMask, err := jsonValue(self.GetOXMValueMask())
12726 if err != nil {
12727 return nil, err
12728 }
12729 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
12730}
12731
12732type NxmTunMetadata36 struct {
12733 *Oxm
12734 Value []byte
12735}
12736
12737type INxmTunMetadata36 interface {
12738 goloxi.IOxm
12739 GetValue() []byte
12740}
12741
12742func (self *NxmTunMetadata36) GetValue() []byte {
12743 return self.Value
12744}
12745
12746func (self *NxmTunMetadata36) SetValue(v []byte) {
12747 self.Value = v
12748}
12749
12750func (self *NxmTunMetadata36) Serialize(encoder *goloxi.Encoder) error {
12751 if err := self.Oxm.Serialize(encoder); err != nil {
12752 return err
12753 }
12754
12755 encoder.Write(self.Value)
12756
12757 return nil
12758}
12759
12760func DecodeNxmTunMetadata36(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata36, error) {
12761 _nxmtunmetadata36 := &NxmTunMetadata36{Oxm: parent}
12762 _nxmtunmetadata36.Value = decoder.Read(int(_nxmtunmetadata36.TypeLen & 0xFF))
12763 return _nxmtunmetadata36, nil
12764}
12765
12766func NewNxmTunMetadata36() *NxmTunMetadata36 {
12767 obj := &NxmTunMetadata36{
12768 Oxm: NewOxm(104572),
12769 }
12770 return obj
12771}
12772func (self *NxmTunMetadata36) GetOXMName() string {
12773 return "tun_metadata36"
12774}
12775
12776func (self *NxmTunMetadata36) GetOXMValue() interface{} {
12777 return self.Value
12778}
12779
12780func (self *NxmTunMetadata36) MarshalJSON() ([]byte, error) {
12781 value, err := jsonValue(self.GetOXMValue())
12782 if err != nil {
12783 return nil, err
12784 }
12785 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
12786}
12787
12788type NxmTunMetadata36Masked struct {
12789 *Oxm
12790 Value []byte
12791 ValueMask []byte
12792}
12793
12794type INxmTunMetadata36Masked interface {
12795 goloxi.IOxm
12796 GetValue() []byte
12797 GetValueMask() []byte
12798}
12799
12800func (self *NxmTunMetadata36Masked) GetValue() []byte {
12801 return self.Value
12802}
12803
12804func (self *NxmTunMetadata36Masked) SetValue(v []byte) {
12805 self.Value = v
12806}
12807
12808func (self *NxmTunMetadata36Masked) GetValueMask() []byte {
12809 return self.ValueMask
12810}
12811
12812func (self *NxmTunMetadata36Masked) SetValueMask(v []byte) {
12813 self.ValueMask = v
12814}
12815
12816func (self *NxmTunMetadata36Masked) Serialize(encoder *goloxi.Encoder) error {
12817 if err := self.Oxm.Serialize(encoder); err != nil {
12818 return err
12819 }
12820
12821 encoder.Write(self.Value)
12822 encoder.Write(self.ValueMask)
12823
12824 return nil
12825}
12826
12827func DecodeNxmTunMetadata36Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata36Masked, error) {
12828 _nxmtunmetadata36masked := &NxmTunMetadata36Masked{Oxm: parent}
12829 _nxmtunmetadata36masked.Value = decoder.Read(int(_nxmtunmetadata36masked.TypeLen & 0xFF))
12830 _nxmtunmetadata36masked.ValueMask = decoder.Read(int(_nxmtunmetadata36masked.TypeLen & 0xFF))
12831 return _nxmtunmetadata36masked, nil
12832}
12833
12834func NewNxmTunMetadata36Masked() *NxmTunMetadata36Masked {
12835 obj := &NxmTunMetadata36Masked{
12836 Oxm: NewOxm(104952),
12837 }
12838 return obj
12839}
12840func (self *NxmTunMetadata36Masked) GetOXMName() string {
12841 return "tun_metadata36_masked"
12842}
12843
12844func (self *NxmTunMetadata36Masked) GetOXMValue() interface{} {
12845 return self.Value
12846}
12847
12848func (self *NxmTunMetadata36Masked) GetOXMValueMask() interface{} {
12849 return self.ValueMask
12850}
12851
12852func (self *NxmTunMetadata36Masked) MarshalJSON() ([]byte, error) {
12853 value, err := jsonValue(self.GetOXMValue())
12854 if err != nil {
12855 return nil, err
12856 }
12857 valueMask, err := jsonValue(self.GetOXMValueMask())
12858 if err != nil {
12859 return nil, err
12860 }
12861 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
12862}
12863
12864type NxmTunMetadata37 struct {
12865 *Oxm
12866 Value []byte
12867}
12868
12869type INxmTunMetadata37 interface {
12870 goloxi.IOxm
12871 GetValue() []byte
12872}
12873
12874func (self *NxmTunMetadata37) GetValue() []byte {
12875 return self.Value
12876}
12877
12878func (self *NxmTunMetadata37) SetValue(v []byte) {
12879 self.Value = v
12880}
12881
12882func (self *NxmTunMetadata37) Serialize(encoder *goloxi.Encoder) error {
12883 if err := self.Oxm.Serialize(encoder); err != nil {
12884 return err
12885 }
12886
12887 encoder.Write(self.Value)
12888
12889 return nil
12890}
12891
12892func DecodeNxmTunMetadata37(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata37, error) {
12893 _nxmtunmetadata37 := &NxmTunMetadata37{Oxm: parent}
12894 _nxmtunmetadata37.Value = decoder.Read(int(_nxmtunmetadata37.TypeLen & 0xFF))
12895 return _nxmtunmetadata37, nil
12896}
12897
12898func NewNxmTunMetadata37() *NxmTunMetadata37 {
12899 obj := &NxmTunMetadata37{
12900 Oxm: NewOxm(105084),
12901 }
12902 return obj
12903}
12904func (self *NxmTunMetadata37) GetOXMName() string {
12905 return "tun_metadata37"
12906}
12907
12908func (self *NxmTunMetadata37) GetOXMValue() interface{} {
12909 return self.Value
12910}
12911
12912func (self *NxmTunMetadata37) MarshalJSON() ([]byte, error) {
12913 value, err := jsonValue(self.GetOXMValue())
12914 if err != nil {
12915 return nil, err
12916 }
12917 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
12918}
12919
12920type NxmTunMetadata37Masked struct {
12921 *Oxm
12922 Value []byte
12923 ValueMask []byte
12924}
12925
12926type INxmTunMetadata37Masked interface {
12927 goloxi.IOxm
12928 GetValue() []byte
12929 GetValueMask() []byte
12930}
12931
12932func (self *NxmTunMetadata37Masked) GetValue() []byte {
12933 return self.Value
12934}
12935
12936func (self *NxmTunMetadata37Masked) SetValue(v []byte) {
12937 self.Value = v
12938}
12939
12940func (self *NxmTunMetadata37Masked) GetValueMask() []byte {
12941 return self.ValueMask
12942}
12943
12944func (self *NxmTunMetadata37Masked) SetValueMask(v []byte) {
12945 self.ValueMask = v
12946}
12947
12948func (self *NxmTunMetadata37Masked) Serialize(encoder *goloxi.Encoder) error {
12949 if err := self.Oxm.Serialize(encoder); err != nil {
12950 return err
12951 }
12952
12953 encoder.Write(self.Value)
12954 encoder.Write(self.ValueMask)
12955
12956 return nil
12957}
12958
12959func DecodeNxmTunMetadata37Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata37Masked, error) {
12960 _nxmtunmetadata37masked := &NxmTunMetadata37Masked{Oxm: parent}
12961 _nxmtunmetadata37masked.Value = decoder.Read(int(_nxmtunmetadata37masked.TypeLen & 0xFF))
12962 _nxmtunmetadata37masked.ValueMask = decoder.Read(int(_nxmtunmetadata37masked.TypeLen & 0xFF))
12963 return _nxmtunmetadata37masked, nil
12964}
12965
12966func NewNxmTunMetadata37Masked() *NxmTunMetadata37Masked {
12967 obj := &NxmTunMetadata37Masked{
12968 Oxm: NewOxm(105464),
12969 }
12970 return obj
12971}
12972func (self *NxmTunMetadata37Masked) GetOXMName() string {
12973 return "tun_metadata37_masked"
12974}
12975
12976func (self *NxmTunMetadata37Masked) GetOXMValue() interface{} {
12977 return self.Value
12978}
12979
12980func (self *NxmTunMetadata37Masked) GetOXMValueMask() interface{} {
12981 return self.ValueMask
12982}
12983
12984func (self *NxmTunMetadata37Masked) MarshalJSON() ([]byte, error) {
12985 value, err := jsonValue(self.GetOXMValue())
12986 if err != nil {
12987 return nil, err
12988 }
12989 valueMask, err := jsonValue(self.GetOXMValueMask())
12990 if err != nil {
12991 return nil, err
12992 }
12993 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
12994}
12995
12996type NxmTunMetadata38 struct {
12997 *Oxm
12998 Value []byte
12999}
13000
13001type INxmTunMetadata38 interface {
13002 goloxi.IOxm
13003 GetValue() []byte
13004}
13005
13006func (self *NxmTunMetadata38) GetValue() []byte {
13007 return self.Value
13008}
13009
13010func (self *NxmTunMetadata38) SetValue(v []byte) {
13011 self.Value = v
13012}
13013
13014func (self *NxmTunMetadata38) Serialize(encoder *goloxi.Encoder) error {
13015 if err := self.Oxm.Serialize(encoder); err != nil {
13016 return err
13017 }
13018
13019 encoder.Write(self.Value)
13020
13021 return nil
13022}
13023
13024func DecodeNxmTunMetadata38(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata38, error) {
13025 _nxmtunmetadata38 := &NxmTunMetadata38{Oxm: parent}
13026 _nxmtunmetadata38.Value = decoder.Read(int(_nxmtunmetadata38.TypeLen & 0xFF))
13027 return _nxmtunmetadata38, nil
13028}
13029
13030func NewNxmTunMetadata38() *NxmTunMetadata38 {
13031 obj := &NxmTunMetadata38{
13032 Oxm: NewOxm(105596),
13033 }
13034 return obj
13035}
13036func (self *NxmTunMetadata38) GetOXMName() string {
13037 return "tun_metadata38"
13038}
13039
13040func (self *NxmTunMetadata38) GetOXMValue() interface{} {
13041 return self.Value
13042}
13043
13044func (self *NxmTunMetadata38) MarshalJSON() ([]byte, error) {
13045 value, err := jsonValue(self.GetOXMValue())
13046 if err != nil {
13047 return nil, err
13048 }
13049 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
13050}
13051
13052type NxmTunMetadata38Masked struct {
13053 *Oxm
13054 Value []byte
13055 ValueMask []byte
13056}
13057
13058type INxmTunMetadata38Masked interface {
13059 goloxi.IOxm
13060 GetValue() []byte
13061 GetValueMask() []byte
13062}
13063
13064func (self *NxmTunMetadata38Masked) GetValue() []byte {
13065 return self.Value
13066}
13067
13068func (self *NxmTunMetadata38Masked) SetValue(v []byte) {
13069 self.Value = v
13070}
13071
13072func (self *NxmTunMetadata38Masked) GetValueMask() []byte {
13073 return self.ValueMask
13074}
13075
13076func (self *NxmTunMetadata38Masked) SetValueMask(v []byte) {
13077 self.ValueMask = v
13078}
13079
13080func (self *NxmTunMetadata38Masked) Serialize(encoder *goloxi.Encoder) error {
13081 if err := self.Oxm.Serialize(encoder); err != nil {
13082 return err
13083 }
13084
13085 encoder.Write(self.Value)
13086 encoder.Write(self.ValueMask)
13087
13088 return nil
13089}
13090
13091func DecodeNxmTunMetadata38Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata38Masked, error) {
13092 _nxmtunmetadata38masked := &NxmTunMetadata38Masked{Oxm: parent}
13093 _nxmtunmetadata38masked.Value = decoder.Read(int(_nxmtunmetadata38masked.TypeLen & 0xFF))
13094 _nxmtunmetadata38masked.ValueMask = decoder.Read(int(_nxmtunmetadata38masked.TypeLen & 0xFF))
13095 return _nxmtunmetadata38masked, nil
13096}
13097
13098func NewNxmTunMetadata38Masked() *NxmTunMetadata38Masked {
13099 obj := &NxmTunMetadata38Masked{
13100 Oxm: NewOxm(105976),
13101 }
13102 return obj
13103}
13104func (self *NxmTunMetadata38Masked) GetOXMName() string {
13105 return "tun_metadata38_masked"
13106}
13107
13108func (self *NxmTunMetadata38Masked) GetOXMValue() interface{} {
13109 return self.Value
13110}
13111
13112func (self *NxmTunMetadata38Masked) GetOXMValueMask() interface{} {
13113 return self.ValueMask
13114}
13115
13116func (self *NxmTunMetadata38Masked) MarshalJSON() ([]byte, error) {
13117 value, err := jsonValue(self.GetOXMValue())
13118 if err != nil {
13119 return nil, err
13120 }
13121 valueMask, err := jsonValue(self.GetOXMValueMask())
13122 if err != nil {
13123 return nil, err
13124 }
13125 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
13126}
13127
13128type NxmTunMetadata39 struct {
13129 *Oxm
13130 Value []byte
13131}
13132
13133type INxmTunMetadata39 interface {
13134 goloxi.IOxm
13135 GetValue() []byte
13136}
13137
13138func (self *NxmTunMetadata39) GetValue() []byte {
13139 return self.Value
13140}
13141
13142func (self *NxmTunMetadata39) SetValue(v []byte) {
13143 self.Value = v
13144}
13145
13146func (self *NxmTunMetadata39) Serialize(encoder *goloxi.Encoder) error {
13147 if err := self.Oxm.Serialize(encoder); err != nil {
13148 return err
13149 }
13150
13151 encoder.Write(self.Value)
13152
13153 return nil
13154}
13155
13156func DecodeNxmTunMetadata39(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata39, error) {
13157 _nxmtunmetadata39 := &NxmTunMetadata39{Oxm: parent}
13158 _nxmtunmetadata39.Value = decoder.Read(int(_nxmtunmetadata39.TypeLen & 0xFF))
13159 return _nxmtunmetadata39, nil
13160}
13161
13162func NewNxmTunMetadata39() *NxmTunMetadata39 {
13163 obj := &NxmTunMetadata39{
13164 Oxm: NewOxm(106108),
13165 }
13166 return obj
13167}
13168func (self *NxmTunMetadata39) GetOXMName() string {
13169 return "tun_metadata39"
13170}
13171
13172func (self *NxmTunMetadata39) GetOXMValue() interface{} {
13173 return self.Value
13174}
13175
13176func (self *NxmTunMetadata39) MarshalJSON() ([]byte, error) {
13177 value, err := jsonValue(self.GetOXMValue())
13178 if err != nil {
13179 return nil, err
13180 }
13181 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
13182}
13183
13184type NxmTunMetadata39Masked struct {
13185 *Oxm
13186 Value []byte
13187 ValueMask []byte
13188}
13189
13190type INxmTunMetadata39Masked interface {
13191 goloxi.IOxm
13192 GetValue() []byte
13193 GetValueMask() []byte
13194}
13195
13196func (self *NxmTunMetadata39Masked) GetValue() []byte {
13197 return self.Value
13198}
13199
13200func (self *NxmTunMetadata39Masked) SetValue(v []byte) {
13201 self.Value = v
13202}
13203
13204func (self *NxmTunMetadata39Masked) GetValueMask() []byte {
13205 return self.ValueMask
13206}
13207
13208func (self *NxmTunMetadata39Masked) SetValueMask(v []byte) {
13209 self.ValueMask = v
13210}
13211
13212func (self *NxmTunMetadata39Masked) Serialize(encoder *goloxi.Encoder) error {
13213 if err := self.Oxm.Serialize(encoder); err != nil {
13214 return err
13215 }
13216
13217 encoder.Write(self.Value)
13218 encoder.Write(self.ValueMask)
13219
13220 return nil
13221}
13222
13223func DecodeNxmTunMetadata39Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata39Masked, error) {
13224 _nxmtunmetadata39masked := &NxmTunMetadata39Masked{Oxm: parent}
13225 _nxmtunmetadata39masked.Value = decoder.Read(int(_nxmtunmetadata39masked.TypeLen & 0xFF))
13226 _nxmtunmetadata39masked.ValueMask = decoder.Read(int(_nxmtunmetadata39masked.TypeLen & 0xFF))
13227 return _nxmtunmetadata39masked, nil
13228}
13229
13230func NewNxmTunMetadata39Masked() *NxmTunMetadata39Masked {
13231 obj := &NxmTunMetadata39Masked{
13232 Oxm: NewOxm(106488),
13233 }
13234 return obj
13235}
13236func (self *NxmTunMetadata39Masked) GetOXMName() string {
13237 return "tun_metadata39_masked"
13238}
13239
13240func (self *NxmTunMetadata39Masked) GetOXMValue() interface{} {
13241 return self.Value
13242}
13243
13244func (self *NxmTunMetadata39Masked) GetOXMValueMask() interface{} {
13245 return self.ValueMask
13246}
13247
13248func (self *NxmTunMetadata39Masked) MarshalJSON() ([]byte, error) {
13249 value, err := jsonValue(self.GetOXMValue())
13250 if err != nil {
13251 return nil, err
13252 }
13253 valueMask, err := jsonValue(self.GetOXMValueMask())
13254 if err != nil {
13255 return nil, err
13256 }
13257 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
13258}
13259
13260type NxmTunMetadata3Masked struct {
13261 *Oxm
13262 Value []byte
13263 ValueMask []byte
13264}
13265
13266type INxmTunMetadata3Masked interface {
13267 goloxi.IOxm
13268 GetValue() []byte
13269 GetValueMask() []byte
13270}
13271
13272func (self *NxmTunMetadata3Masked) GetValue() []byte {
13273 return self.Value
13274}
13275
13276func (self *NxmTunMetadata3Masked) SetValue(v []byte) {
13277 self.Value = v
13278}
13279
13280func (self *NxmTunMetadata3Masked) GetValueMask() []byte {
13281 return self.ValueMask
13282}
13283
13284func (self *NxmTunMetadata3Masked) SetValueMask(v []byte) {
13285 self.ValueMask = v
13286}
13287
13288func (self *NxmTunMetadata3Masked) Serialize(encoder *goloxi.Encoder) error {
13289 if err := self.Oxm.Serialize(encoder); err != nil {
13290 return err
13291 }
13292
13293 encoder.Write(self.Value)
13294 encoder.Write(self.ValueMask)
13295
13296 return nil
13297}
13298
13299func DecodeNxmTunMetadata3Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata3Masked, error) {
13300 _nxmtunmetadata3masked := &NxmTunMetadata3Masked{Oxm: parent}
13301 _nxmtunmetadata3masked.Value = decoder.Read(int(_nxmtunmetadata3masked.TypeLen & 0xFF))
13302 _nxmtunmetadata3masked.ValueMask = decoder.Read(int(_nxmtunmetadata3masked.TypeLen & 0xFF))
13303 return _nxmtunmetadata3masked, nil
13304}
13305
13306func NewNxmTunMetadata3Masked() *NxmTunMetadata3Masked {
13307 obj := &NxmTunMetadata3Masked{
13308 Oxm: NewOxm(88056),
13309 }
13310 return obj
13311}
13312func (self *NxmTunMetadata3Masked) GetOXMName() string {
13313 return "tun_metadata3_masked"
13314}
13315
13316func (self *NxmTunMetadata3Masked) GetOXMValue() interface{} {
13317 return self.Value
13318}
13319
13320func (self *NxmTunMetadata3Masked) GetOXMValueMask() interface{} {
13321 return self.ValueMask
13322}
13323
13324func (self *NxmTunMetadata3Masked) MarshalJSON() ([]byte, error) {
13325 value, err := jsonValue(self.GetOXMValue())
13326 if err != nil {
13327 return nil, err
13328 }
13329 valueMask, err := jsonValue(self.GetOXMValueMask())
13330 if err != nil {
13331 return nil, err
13332 }
13333 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
13334}
13335
13336type NxmTunMetadata4 struct {
13337 *Oxm
13338 Value []byte
13339}
13340
13341type INxmTunMetadata4 interface {
13342 goloxi.IOxm
13343 GetValue() []byte
13344}
13345
13346func (self *NxmTunMetadata4) GetValue() []byte {
13347 return self.Value
13348}
13349
13350func (self *NxmTunMetadata4) SetValue(v []byte) {
13351 self.Value = v
13352}
13353
13354func (self *NxmTunMetadata4) Serialize(encoder *goloxi.Encoder) error {
13355 if err := self.Oxm.Serialize(encoder); err != nil {
13356 return err
13357 }
13358
13359 encoder.Write(self.Value)
13360
13361 return nil
13362}
13363
13364func DecodeNxmTunMetadata4(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata4, error) {
13365 _nxmtunmetadata4 := &NxmTunMetadata4{Oxm: parent}
13366 _nxmtunmetadata4.Value = decoder.Read(int(_nxmtunmetadata4.TypeLen & 0xFF))
13367 return _nxmtunmetadata4, nil
13368}
13369
13370func NewNxmTunMetadata4() *NxmTunMetadata4 {
13371 obj := &NxmTunMetadata4{
13372 Oxm: NewOxm(88188),
13373 }
13374 return obj
13375}
13376func (self *NxmTunMetadata4) GetOXMName() string {
13377 return "tun_metadata4"
13378}
13379
13380func (self *NxmTunMetadata4) GetOXMValue() interface{} {
13381 return self.Value
13382}
13383
13384func (self *NxmTunMetadata4) MarshalJSON() ([]byte, error) {
13385 value, err := jsonValue(self.GetOXMValue())
13386 if err != nil {
13387 return nil, err
13388 }
13389 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
13390}
13391
13392type NxmTunMetadata40 struct {
13393 *Oxm
13394 Value []byte
13395}
13396
13397type INxmTunMetadata40 interface {
13398 goloxi.IOxm
13399 GetValue() []byte
13400}
13401
13402func (self *NxmTunMetadata40) GetValue() []byte {
13403 return self.Value
13404}
13405
13406func (self *NxmTunMetadata40) SetValue(v []byte) {
13407 self.Value = v
13408}
13409
13410func (self *NxmTunMetadata40) Serialize(encoder *goloxi.Encoder) error {
13411 if err := self.Oxm.Serialize(encoder); err != nil {
13412 return err
13413 }
13414
13415 encoder.Write(self.Value)
13416
13417 return nil
13418}
13419
13420func DecodeNxmTunMetadata40(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata40, error) {
13421 _nxmtunmetadata40 := &NxmTunMetadata40{Oxm: parent}
13422 _nxmtunmetadata40.Value = decoder.Read(int(_nxmtunmetadata40.TypeLen & 0xFF))
13423 return _nxmtunmetadata40, nil
13424}
13425
13426func NewNxmTunMetadata40() *NxmTunMetadata40 {
13427 obj := &NxmTunMetadata40{
13428 Oxm: NewOxm(106620),
13429 }
13430 return obj
13431}
13432func (self *NxmTunMetadata40) GetOXMName() string {
13433 return "tun_metadata40"
13434}
13435
13436func (self *NxmTunMetadata40) GetOXMValue() interface{} {
13437 return self.Value
13438}
13439
13440func (self *NxmTunMetadata40) MarshalJSON() ([]byte, error) {
13441 value, err := jsonValue(self.GetOXMValue())
13442 if err != nil {
13443 return nil, err
13444 }
13445 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
13446}
13447
13448type NxmTunMetadata40Masked struct {
13449 *Oxm
13450 Value []byte
13451 ValueMask []byte
13452}
13453
13454type INxmTunMetadata40Masked interface {
13455 goloxi.IOxm
13456 GetValue() []byte
13457 GetValueMask() []byte
13458}
13459
13460func (self *NxmTunMetadata40Masked) GetValue() []byte {
13461 return self.Value
13462}
13463
13464func (self *NxmTunMetadata40Masked) SetValue(v []byte) {
13465 self.Value = v
13466}
13467
13468func (self *NxmTunMetadata40Masked) GetValueMask() []byte {
13469 return self.ValueMask
13470}
13471
13472func (self *NxmTunMetadata40Masked) SetValueMask(v []byte) {
13473 self.ValueMask = v
13474}
13475
13476func (self *NxmTunMetadata40Masked) Serialize(encoder *goloxi.Encoder) error {
13477 if err := self.Oxm.Serialize(encoder); err != nil {
13478 return err
13479 }
13480
13481 encoder.Write(self.Value)
13482 encoder.Write(self.ValueMask)
13483
13484 return nil
13485}
13486
13487func DecodeNxmTunMetadata40Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata40Masked, error) {
13488 _nxmtunmetadata40masked := &NxmTunMetadata40Masked{Oxm: parent}
13489 _nxmtunmetadata40masked.Value = decoder.Read(int(_nxmtunmetadata40masked.TypeLen & 0xFF))
13490 _nxmtunmetadata40masked.ValueMask = decoder.Read(int(_nxmtunmetadata40masked.TypeLen & 0xFF))
13491 return _nxmtunmetadata40masked, nil
13492}
13493
13494func NewNxmTunMetadata40Masked() *NxmTunMetadata40Masked {
13495 obj := &NxmTunMetadata40Masked{
13496 Oxm: NewOxm(107000),
13497 }
13498 return obj
13499}
13500func (self *NxmTunMetadata40Masked) GetOXMName() string {
13501 return "tun_metadata40_masked"
13502}
13503
13504func (self *NxmTunMetadata40Masked) GetOXMValue() interface{} {
13505 return self.Value
13506}
13507
13508func (self *NxmTunMetadata40Masked) GetOXMValueMask() interface{} {
13509 return self.ValueMask
13510}
13511
13512func (self *NxmTunMetadata40Masked) MarshalJSON() ([]byte, error) {
13513 value, err := jsonValue(self.GetOXMValue())
13514 if err != nil {
13515 return nil, err
13516 }
13517 valueMask, err := jsonValue(self.GetOXMValueMask())
13518 if err != nil {
13519 return nil, err
13520 }
13521 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
13522}
13523
13524type NxmTunMetadata41 struct {
13525 *Oxm
13526 Value []byte
13527}
13528
13529type INxmTunMetadata41 interface {
13530 goloxi.IOxm
13531 GetValue() []byte
13532}
13533
13534func (self *NxmTunMetadata41) GetValue() []byte {
13535 return self.Value
13536}
13537
13538func (self *NxmTunMetadata41) SetValue(v []byte) {
13539 self.Value = v
13540}
13541
13542func (self *NxmTunMetadata41) Serialize(encoder *goloxi.Encoder) error {
13543 if err := self.Oxm.Serialize(encoder); err != nil {
13544 return err
13545 }
13546
13547 encoder.Write(self.Value)
13548
13549 return nil
13550}
13551
13552func DecodeNxmTunMetadata41(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata41, error) {
13553 _nxmtunmetadata41 := &NxmTunMetadata41{Oxm: parent}
13554 _nxmtunmetadata41.Value = decoder.Read(int(_nxmtunmetadata41.TypeLen & 0xFF))
13555 return _nxmtunmetadata41, nil
13556}
13557
13558func NewNxmTunMetadata41() *NxmTunMetadata41 {
13559 obj := &NxmTunMetadata41{
13560 Oxm: NewOxm(107132),
13561 }
13562 return obj
13563}
13564func (self *NxmTunMetadata41) GetOXMName() string {
13565 return "tun_metadata41"
13566}
13567
13568func (self *NxmTunMetadata41) GetOXMValue() interface{} {
13569 return self.Value
13570}
13571
13572func (self *NxmTunMetadata41) MarshalJSON() ([]byte, error) {
13573 value, err := jsonValue(self.GetOXMValue())
13574 if err != nil {
13575 return nil, err
13576 }
13577 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
13578}
13579
13580type NxmTunMetadata41Masked struct {
13581 *Oxm
13582 Value []byte
13583 ValueMask []byte
13584}
13585
13586type INxmTunMetadata41Masked interface {
13587 goloxi.IOxm
13588 GetValue() []byte
13589 GetValueMask() []byte
13590}
13591
13592func (self *NxmTunMetadata41Masked) GetValue() []byte {
13593 return self.Value
13594}
13595
13596func (self *NxmTunMetadata41Masked) SetValue(v []byte) {
13597 self.Value = v
13598}
13599
13600func (self *NxmTunMetadata41Masked) GetValueMask() []byte {
13601 return self.ValueMask
13602}
13603
13604func (self *NxmTunMetadata41Masked) SetValueMask(v []byte) {
13605 self.ValueMask = v
13606}
13607
13608func (self *NxmTunMetadata41Masked) Serialize(encoder *goloxi.Encoder) error {
13609 if err := self.Oxm.Serialize(encoder); err != nil {
13610 return err
13611 }
13612
13613 encoder.Write(self.Value)
13614 encoder.Write(self.ValueMask)
13615
13616 return nil
13617}
13618
13619func DecodeNxmTunMetadata41Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata41Masked, error) {
13620 _nxmtunmetadata41masked := &NxmTunMetadata41Masked{Oxm: parent}
13621 _nxmtunmetadata41masked.Value = decoder.Read(int(_nxmtunmetadata41masked.TypeLen & 0xFF))
13622 _nxmtunmetadata41masked.ValueMask = decoder.Read(int(_nxmtunmetadata41masked.TypeLen & 0xFF))
13623 return _nxmtunmetadata41masked, nil
13624}
13625
13626func NewNxmTunMetadata41Masked() *NxmTunMetadata41Masked {
13627 obj := &NxmTunMetadata41Masked{
13628 Oxm: NewOxm(107512),
13629 }
13630 return obj
13631}
13632func (self *NxmTunMetadata41Masked) GetOXMName() string {
13633 return "tun_metadata41_masked"
13634}
13635
13636func (self *NxmTunMetadata41Masked) GetOXMValue() interface{} {
13637 return self.Value
13638}
13639
13640func (self *NxmTunMetadata41Masked) GetOXMValueMask() interface{} {
13641 return self.ValueMask
13642}
13643
13644func (self *NxmTunMetadata41Masked) MarshalJSON() ([]byte, error) {
13645 value, err := jsonValue(self.GetOXMValue())
13646 if err != nil {
13647 return nil, err
13648 }
13649 valueMask, err := jsonValue(self.GetOXMValueMask())
13650 if err != nil {
13651 return nil, err
13652 }
13653 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
13654}
13655
13656type NxmTunMetadata42 struct {
13657 *Oxm
13658 Value []byte
13659}
13660
13661type INxmTunMetadata42 interface {
13662 goloxi.IOxm
13663 GetValue() []byte
13664}
13665
13666func (self *NxmTunMetadata42) GetValue() []byte {
13667 return self.Value
13668}
13669
13670func (self *NxmTunMetadata42) SetValue(v []byte) {
13671 self.Value = v
13672}
13673
13674func (self *NxmTunMetadata42) Serialize(encoder *goloxi.Encoder) error {
13675 if err := self.Oxm.Serialize(encoder); err != nil {
13676 return err
13677 }
13678
13679 encoder.Write(self.Value)
13680
13681 return nil
13682}
13683
13684func DecodeNxmTunMetadata42(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata42, error) {
13685 _nxmtunmetadata42 := &NxmTunMetadata42{Oxm: parent}
13686 _nxmtunmetadata42.Value = decoder.Read(int(_nxmtunmetadata42.TypeLen & 0xFF))
13687 return _nxmtunmetadata42, nil
13688}
13689
13690func NewNxmTunMetadata42() *NxmTunMetadata42 {
13691 obj := &NxmTunMetadata42{
13692 Oxm: NewOxm(107644),
13693 }
13694 return obj
13695}
13696func (self *NxmTunMetadata42) GetOXMName() string {
13697 return "tun_metadata42"
13698}
13699
13700func (self *NxmTunMetadata42) GetOXMValue() interface{} {
13701 return self.Value
13702}
13703
13704func (self *NxmTunMetadata42) MarshalJSON() ([]byte, error) {
13705 value, err := jsonValue(self.GetOXMValue())
13706 if err != nil {
13707 return nil, err
13708 }
13709 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
13710}
13711
13712type NxmTunMetadata42Masked struct {
13713 *Oxm
13714 Value []byte
13715 ValueMask []byte
13716}
13717
13718type INxmTunMetadata42Masked interface {
13719 goloxi.IOxm
13720 GetValue() []byte
13721 GetValueMask() []byte
13722}
13723
13724func (self *NxmTunMetadata42Masked) GetValue() []byte {
13725 return self.Value
13726}
13727
13728func (self *NxmTunMetadata42Masked) SetValue(v []byte) {
13729 self.Value = v
13730}
13731
13732func (self *NxmTunMetadata42Masked) GetValueMask() []byte {
13733 return self.ValueMask
13734}
13735
13736func (self *NxmTunMetadata42Masked) SetValueMask(v []byte) {
13737 self.ValueMask = v
13738}
13739
13740func (self *NxmTunMetadata42Masked) Serialize(encoder *goloxi.Encoder) error {
13741 if err := self.Oxm.Serialize(encoder); err != nil {
13742 return err
13743 }
13744
13745 encoder.Write(self.Value)
13746 encoder.Write(self.ValueMask)
13747
13748 return nil
13749}
13750
13751func DecodeNxmTunMetadata42Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata42Masked, error) {
13752 _nxmtunmetadata42masked := &NxmTunMetadata42Masked{Oxm: parent}
13753 _nxmtunmetadata42masked.Value = decoder.Read(int(_nxmtunmetadata42masked.TypeLen & 0xFF))
13754 _nxmtunmetadata42masked.ValueMask = decoder.Read(int(_nxmtunmetadata42masked.TypeLen & 0xFF))
13755 return _nxmtunmetadata42masked, nil
13756}
13757
13758func NewNxmTunMetadata42Masked() *NxmTunMetadata42Masked {
13759 obj := &NxmTunMetadata42Masked{
13760 Oxm: NewOxm(108024),
13761 }
13762 return obj
13763}
13764func (self *NxmTunMetadata42Masked) GetOXMName() string {
13765 return "tun_metadata42_masked"
13766}
13767
13768func (self *NxmTunMetadata42Masked) GetOXMValue() interface{} {
13769 return self.Value
13770}
13771
13772func (self *NxmTunMetadata42Masked) GetOXMValueMask() interface{} {
13773 return self.ValueMask
13774}
13775
13776func (self *NxmTunMetadata42Masked) MarshalJSON() ([]byte, error) {
13777 value, err := jsonValue(self.GetOXMValue())
13778 if err != nil {
13779 return nil, err
13780 }
13781 valueMask, err := jsonValue(self.GetOXMValueMask())
13782 if err != nil {
13783 return nil, err
13784 }
13785 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
13786}
13787
13788type NxmTunMetadata43 struct {
13789 *Oxm
13790 Value []byte
13791}
13792
13793type INxmTunMetadata43 interface {
13794 goloxi.IOxm
13795 GetValue() []byte
13796}
13797
13798func (self *NxmTunMetadata43) GetValue() []byte {
13799 return self.Value
13800}
13801
13802func (self *NxmTunMetadata43) SetValue(v []byte) {
13803 self.Value = v
13804}
13805
13806func (self *NxmTunMetadata43) Serialize(encoder *goloxi.Encoder) error {
13807 if err := self.Oxm.Serialize(encoder); err != nil {
13808 return err
13809 }
13810
13811 encoder.Write(self.Value)
13812
13813 return nil
13814}
13815
13816func DecodeNxmTunMetadata43(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata43, error) {
13817 _nxmtunmetadata43 := &NxmTunMetadata43{Oxm: parent}
13818 _nxmtunmetadata43.Value = decoder.Read(int(_nxmtunmetadata43.TypeLen & 0xFF))
13819 return _nxmtunmetadata43, nil
13820}
13821
13822func NewNxmTunMetadata43() *NxmTunMetadata43 {
13823 obj := &NxmTunMetadata43{
13824 Oxm: NewOxm(108156),
13825 }
13826 return obj
13827}
13828func (self *NxmTunMetadata43) GetOXMName() string {
13829 return "tun_metadata43"
13830}
13831
13832func (self *NxmTunMetadata43) GetOXMValue() interface{} {
13833 return self.Value
13834}
13835
13836func (self *NxmTunMetadata43) MarshalJSON() ([]byte, error) {
13837 value, err := jsonValue(self.GetOXMValue())
13838 if err != nil {
13839 return nil, err
13840 }
13841 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
13842}
13843
13844type NxmTunMetadata43Masked struct {
13845 *Oxm
13846 Value []byte
13847 ValueMask []byte
13848}
13849
13850type INxmTunMetadata43Masked interface {
13851 goloxi.IOxm
13852 GetValue() []byte
13853 GetValueMask() []byte
13854}
13855
13856func (self *NxmTunMetadata43Masked) GetValue() []byte {
13857 return self.Value
13858}
13859
13860func (self *NxmTunMetadata43Masked) SetValue(v []byte) {
13861 self.Value = v
13862}
13863
13864func (self *NxmTunMetadata43Masked) GetValueMask() []byte {
13865 return self.ValueMask
13866}
13867
13868func (self *NxmTunMetadata43Masked) SetValueMask(v []byte) {
13869 self.ValueMask = v
13870}
13871
13872func (self *NxmTunMetadata43Masked) Serialize(encoder *goloxi.Encoder) error {
13873 if err := self.Oxm.Serialize(encoder); err != nil {
13874 return err
13875 }
13876
13877 encoder.Write(self.Value)
13878 encoder.Write(self.ValueMask)
13879
13880 return nil
13881}
13882
13883func DecodeNxmTunMetadata43Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata43Masked, error) {
13884 _nxmtunmetadata43masked := &NxmTunMetadata43Masked{Oxm: parent}
13885 _nxmtunmetadata43masked.Value = decoder.Read(int(_nxmtunmetadata43masked.TypeLen & 0xFF))
13886 _nxmtunmetadata43masked.ValueMask = decoder.Read(int(_nxmtunmetadata43masked.TypeLen & 0xFF))
13887 return _nxmtunmetadata43masked, nil
13888}
13889
13890func NewNxmTunMetadata43Masked() *NxmTunMetadata43Masked {
13891 obj := &NxmTunMetadata43Masked{
13892 Oxm: NewOxm(108536),
13893 }
13894 return obj
13895}
13896func (self *NxmTunMetadata43Masked) GetOXMName() string {
13897 return "tun_metadata43_masked"
13898}
13899
13900func (self *NxmTunMetadata43Masked) GetOXMValue() interface{} {
13901 return self.Value
13902}
13903
13904func (self *NxmTunMetadata43Masked) GetOXMValueMask() interface{} {
13905 return self.ValueMask
13906}
13907
13908func (self *NxmTunMetadata43Masked) MarshalJSON() ([]byte, error) {
13909 value, err := jsonValue(self.GetOXMValue())
13910 if err != nil {
13911 return nil, err
13912 }
13913 valueMask, err := jsonValue(self.GetOXMValueMask())
13914 if err != nil {
13915 return nil, err
13916 }
13917 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
13918}
13919
13920type NxmTunMetadata44 struct {
13921 *Oxm
13922 Value []byte
13923}
13924
13925type INxmTunMetadata44 interface {
13926 goloxi.IOxm
13927 GetValue() []byte
13928}
13929
13930func (self *NxmTunMetadata44) GetValue() []byte {
13931 return self.Value
13932}
13933
13934func (self *NxmTunMetadata44) SetValue(v []byte) {
13935 self.Value = v
13936}
13937
13938func (self *NxmTunMetadata44) Serialize(encoder *goloxi.Encoder) error {
13939 if err := self.Oxm.Serialize(encoder); err != nil {
13940 return err
13941 }
13942
13943 encoder.Write(self.Value)
13944
13945 return nil
13946}
13947
13948func DecodeNxmTunMetadata44(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata44, error) {
13949 _nxmtunmetadata44 := &NxmTunMetadata44{Oxm: parent}
13950 _nxmtunmetadata44.Value = decoder.Read(int(_nxmtunmetadata44.TypeLen & 0xFF))
13951 return _nxmtunmetadata44, nil
13952}
13953
13954func NewNxmTunMetadata44() *NxmTunMetadata44 {
13955 obj := &NxmTunMetadata44{
13956 Oxm: NewOxm(108668),
13957 }
13958 return obj
13959}
13960func (self *NxmTunMetadata44) GetOXMName() string {
13961 return "tun_metadata44"
13962}
13963
13964func (self *NxmTunMetadata44) GetOXMValue() interface{} {
13965 return self.Value
13966}
13967
13968func (self *NxmTunMetadata44) MarshalJSON() ([]byte, error) {
13969 value, err := jsonValue(self.GetOXMValue())
13970 if err != nil {
13971 return nil, err
13972 }
13973 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
13974}
13975
13976type NxmTunMetadata44Masked struct {
13977 *Oxm
13978 Value []byte
13979 ValueMask []byte
13980}
13981
13982type INxmTunMetadata44Masked interface {
13983 goloxi.IOxm
13984 GetValue() []byte
13985 GetValueMask() []byte
13986}
13987
13988func (self *NxmTunMetadata44Masked) GetValue() []byte {
13989 return self.Value
13990}
13991
13992func (self *NxmTunMetadata44Masked) SetValue(v []byte) {
13993 self.Value = v
13994}
13995
13996func (self *NxmTunMetadata44Masked) GetValueMask() []byte {
13997 return self.ValueMask
13998}
13999
14000func (self *NxmTunMetadata44Masked) SetValueMask(v []byte) {
14001 self.ValueMask = v
14002}
14003
14004func (self *NxmTunMetadata44Masked) Serialize(encoder *goloxi.Encoder) error {
14005 if err := self.Oxm.Serialize(encoder); err != nil {
14006 return err
14007 }
14008
14009 encoder.Write(self.Value)
14010 encoder.Write(self.ValueMask)
14011
14012 return nil
14013}
14014
14015func DecodeNxmTunMetadata44Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata44Masked, error) {
14016 _nxmtunmetadata44masked := &NxmTunMetadata44Masked{Oxm: parent}
14017 _nxmtunmetadata44masked.Value = decoder.Read(int(_nxmtunmetadata44masked.TypeLen & 0xFF))
14018 _nxmtunmetadata44masked.ValueMask = decoder.Read(int(_nxmtunmetadata44masked.TypeLen & 0xFF))
14019 return _nxmtunmetadata44masked, nil
14020}
14021
14022func NewNxmTunMetadata44Masked() *NxmTunMetadata44Masked {
14023 obj := &NxmTunMetadata44Masked{
14024 Oxm: NewOxm(109048),
14025 }
14026 return obj
14027}
14028func (self *NxmTunMetadata44Masked) GetOXMName() string {
14029 return "tun_metadata44_masked"
14030}
14031
14032func (self *NxmTunMetadata44Masked) GetOXMValue() interface{} {
14033 return self.Value
14034}
14035
14036func (self *NxmTunMetadata44Masked) GetOXMValueMask() interface{} {
14037 return self.ValueMask
14038}
14039
14040func (self *NxmTunMetadata44Masked) MarshalJSON() ([]byte, error) {
14041 value, err := jsonValue(self.GetOXMValue())
14042 if err != nil {
14043 return nil, err
14044 }
14045 valueMask, err := jsonValue(self.GetOXMValueMask())
14046 if err != nil {
14047 return nil, err
14048 }
14049 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
14050}
14051
14052type NxmTunMetadata45 struct {
14053 *Oxm
14054 Value []byte
14055}
14056
14057type INxmTunMetadata45 interface {
14058 goloxi.IOxm
14059 GetValue() []byte
14060}
14061
14062func (self *NxmTunMetadata45) GetValue() []byte {
14063 return self.Value
14064}
14065
14066func (self *NxmTunMetadata45) SetValue(v []byte) {
14067 self.Value = v
14068}
14069
14070func (self *NxmTunMetadata45) Serialize(encoder *goloxi.Encoder) error {
14071 if err := self.Oxm.Serialize(encoder); err != nil {
14072 return err
14073 }
14074
14075 encoder.Write(self.Value)
14076
14077 return nil
14078}
14079
14080func DecodeNxmTunMetadata45(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata45, error) {
14081 _nxmtunmetadata45 := &NxmTunMetadata45{Oxm: parent}
14082 _nxmtunmetadata45.Value = decoder.Read(int(_nxmtunmetadata45.TypeLen & 0xFF))
14083 return _nxmtunmetadata45, nil
14084}
14085
14086func NewNxmTunMetadata45() *NxmTunMetadata45 {
14087 obj := &NxmTunMetadata45{
14088 Oxm: NewOxm(109180),
14089 }
14090 return obj
14091}
14092func (self *NxmTunMetadata45) GetOXMName() string {
14093 return "tun_metadata45"
14094}
14095
14096func (self *NxmTunMetadata45) GetOXMValue() interface{} {
14097 return self.Value
14098}
14099
14100func (self *NxmTunMetadata45) MarshalJSON() ([]byte, error) {
14101 value, err := jsonValue(self.GetOXMValue())
14102 if err != nil {
14103 return nil, err
14104 }
14105 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
14106}
14107
14108type NxmTunMetadata45Masked struct {
14109 *Oxm
14110 Value []byte
14111 ValueMask []byte
14112}
14113
14114type INxmTunMetadata45Masked interface {
14115 goloxi.IOxm
14116 GetValue() []byte
14117 GetValueMask() []byte
14118}
14119
14120func (self *NxmTunMetadata45Masked) GetValue() []byte {
14121 return self.Value
14122}
14123
14124func (self *NxmTunMetadata45Masked) SetValue(v []byte) {
14125 self.Value = v
14126}
14127
14128func (self *NxmTunMetadata45Masked) GetValueMask() []byte {
14129 return self.ValueMask
14130}
14131
14132func (self *NxmTunMetadata45Masked) SetValueMask(v []byte) {
14133 self.ValueMask = v
14134}
14135
14136func (self *NxmTunMetadata45Masked) Serialize(encoder *goloxi.Encoder) error {
14137 if err := self.Oxm.Serialize(encoder); err != nil {
14138 return err
14139 }
14140
14141 encoder.Write(self.Value)
14142 encoder.Write(self.ValueMask)
14143
14144 return nil
14145}
14146
14147func DecodeNxmTunMetadata45Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata45Masked, error) {
14148 _nxmtunmetadata45masked := &NxmTunMetadata45Masked{Oxm: parent}
14149 _nxmtunmetadata45masked.Value = decoder.Read(int(_nxmtunmetadata45masked.TypeLen & 0xFF))
14150 _nxmtunmetadata45masked.ValueMask = decoder.Read(int(_nxmtunmetadata45masked.TypeLen & 0xFF))
14151 return _nxmtunmetadata45masked, nil
14152}
14153
14154func NewNxmTunMetadata45Masked() *NxmTunMetadata45Masked {
14155 obj := &NxmTunMetadata45Masked{
14156 Oxm: NewOxm(109560),
14157 }
14158 return obj
14159}
14160func (self *NxmTunMetadata45Masked) GetOXMName() string {
14161 return "tun_metadata45_masked"
14162}
14163
14164func (self *NxmTunMetadata45Masked) GetOXMValue() interface{} {
14165 return self.Value
14166}
14167
14168func (self *NxmTunMetadata45Masked) GetOXMValueMask() interface{} {
14169 return self.ValueMask
14170}
14171
14172func (self *NxmTunMetadata45Masked) MarshalJSON() ([]byte, error) {
14173 value, err := jsonValue(self.GetOXMValue())
14174 if err != nil {
14175 return nil, err
14176 }
14177 valueMask, err := jsonValue(self.GetOXMValueMask())
14178 if err != nil {
14179 return nil, err
14180 }
14181 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
14182}
14183
14184type NxmTunMetadata46 struct {
14185 *Oxm
14186 Value []byte
14187}
14188
14189type INxmTunMetadata46 interface {
14190 goloxi.IOxm
14191 GetValue() []byte
14192}
14193
14194func (self *NxmTunMetadata46) GetValue() []byte {
14195 return self.Value
14196}
14197
14198func (self *NxmTunMetadata46) SetValue(v []byte) {
14199 self.Value = v
14200}
14201
14202func (self *NxmTunMetadata46) Serialize(encoder *goloxi.Encoder) error {
14203 if err := self.Oxm.Serialize(encoder); err != nil {
14204 return err
14205 }
14206
14207 encoder.Write(self.Value)
14208
14209 return nil
14210}
14211
14212func DecodeNxmTunMetadata46(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata46, error) {
14213 _nxmtunmetadata46 := &NxmTunMetadata46{Oxm: parent}
14214 _nxmtunmetadata46.Value = decoder.Read(int(_nxmtunmetadata46.TypeLen & 0xFF))
14215 return _nxmtunmetadata46, nil
14216}
14217
14218func NewNxmTunMetadata46() *NxmTunMetadata46 {
14219 obj := &NxmTunMetadata46{
14220 Oxm: NewOxm(109692),
14221 }
14222 return obj
14223}
14224func (self *NxmTunMetadata46) GetOXMName() string {
14225 return "tun_metadata46"
14226}
14227
14228func (self *NxmTunMetadata46) GetOXMValue() interface{} {
14229 return self.Value
14230}
14231
14232func (self *NxmTunMetadata46) MarshalJSON() ([]byte, error) {
14233 value, err := jsonValue(self.GetOXMValue())
14234 if err != nil {
14235 return nil, err
14236 }
14237 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
14238}
14239
14240type NxmTunMetadata46Masked struct {
14241 *Oxm
14242 Value []byte
14243 ValueMask []byte
14244}
14245
14246type INxmTunMetadata46Masked interface {
14247 goloxi.IOxm
14248 GetValue() []byte
14249 GetValueMask() []byte
14250}
14251
14252func (self *NxmTunMetadata46Masked) GetValue() []byte {
14253 return self.Value
14254}
14255
14256func (self *NxmTunMetadata46Masked) SetValue(v []byte) {
14257 self.Value = v
14258}
14259
14260func (self *NxmTunMetadata46Masked) GetValueMask() []byte {
14261 return self.ValueMask
14262}
14263
14264func (self *NxmTunMetadata46Masked) SetValueMask(v []byte) {
14265 self.ValueMask = v
14266}
14267
14268func (self *NxmTunMetadata46Masked) Serialize(encoder *goloxi.Encoder) error {
14269 if err := self.Oxm.Serialize(encoder); err != nil {
14270 return err
14271 }
14272
14273 encoder.Write(self.Value)
14274 encoder.Write(self.ValueMask)
14275
14276 return nil
14277}
14278
14279func DecodeNxmTunMetadata46Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata46Masked, error) {
14280 _nxmtunmetadata46masked := &NxmTunMetadata46Masked{Oxm: parent}
14281 _nxmtunmetadata46masked.Value = decoder.Read(int(_nxmtunmetadata46masked.TypeLen & 0xFF))
14282 _nxmtunmetadata46masked.ValueMask = decoder.Read(int(_nxmtunmetadata46masked.TypeLen & 0xFF))
14283 return _nxmtunmetadata46masked, nil
14284}
14285
14286func NewNxmTunMetadata46Masked() *NxmTunMetadata46Masked {
14287 obj := &NxmTunMetadata46Masked{
14288 Oxm: NewOxm(110072),
14289 }
14290 return obj
14291}
14292func (self *NxmTunMetadata46Masked) GetOXMName() string {
14293 return "tun_metadata46_masked"
14294}
14295
14296func (self *NxmTunMetadata46Masked) GetOXMValue() interface{} {
14297 return self.Value
14298}
14299
14300func (self *NxmTunMetadata46Masked) GetOXMValueMask() interface{} {
14301 return self.ValueMask
14302}
14303
14304func (self *NxmTunMetadata46Masked) MarshalJSON() ([]byte, error) {
14305 value, err := jsonValue(self.GetOXMValue())
14306 if err != nil {
14307 return nil, err
14308 }
14309 valueMask, err := jsonValue(self.GetOXMValueMask())
14310 if err != nil {
14311 return nil, err
14312 }
14313 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
14314}
14315
14316type NxmTunMetadata47 struct {
14317 *Oxm
14318 Value []byte
14319}
14320
14321type INxmTunMetadata47 interface {
14322 goloxi.IOxm
14323 GetValue() []byte
14324}
14325
14326func (self *NxmTunMetadata47) GetValue() []byte {
14327 return self.Value
14328}
14329
14330func (self *NxmTunMetadata47) SetValue(v []byte) {
14331 self.Value = v
14332}
14333
14334func (self *NxmTunMetadata47) Serialize(encoder *goloxi.Encoder) error {
14335 if err := self.Oxm.Serialize(encoder); err != nil {
14336 return err
14337 }
14338
14339 encoder.Write(self.Value)
14340
14341 return nil
14342}
14343
14344func DecodeNxmTunMetadata47(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata47, error) {
14345 _nxmtunmetadata47 := &NxmTunMetadata47{Oxm: parent}
14346 _nxmtunmetadata47.Value = decoder.Read(int(_nxmtunmetadata47.TypeLen & 0xFF))
14347 return _nxmtunmetadata47, nil
14348}
14349
14350func NewNxmTunMetadata47() *NxmTunMetadata47 {
14351 obj := &NxmTunMetadata47{
14352 Oxm: NewOxm(110204),
14353 }
14354 return obj
14355}
14356func (self *NxmTunMetadata47) GetOXMName() string {
14357 return "tun_metadata47"
14358}
14359
14360func (self *NxmTunMetadata47) GetOXMValue() interface{} {
14361 return self.Value
14362}
14363
14364func (self *NxmTunMetadata47) MarshalJSON() ([]byte, error) {
14365 value, err := jsonValue(self.GetOXMValue())
14366 if err != nil {
14367 return nil, err
14368 }
14369 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
14370}
14371
14372type NxmTunMetadata47Masked struct {
14373 *Oxm
14374 Value []byte
14375 ValueMask []byte
14376}
14377
14378type INxmTunMetadata47Masked interface {
14379 goloxi.IOxm
14380 GetValue() []byte
14381 GetValueMask() []byte
14382}
14383
14384func (self *NxmTunMetadata47Masked) GetValue() []byte {
14385 return self.Value
14386}
14387
14388func (self *NxmTunMetadata47Masked) SetValue(v []byte) {
14389 self.Value = v
14390}
14391
14392func (self *NxmTunMetadata47Masked) GetValueMask() []byte {
14393 return self.ValueMask
14394}
14395
14396func (self *NxmTunMetadata47Masked) SetValueMask(v []byte) {
14397 self.ValueMask = v
14398}
14399
14400func (self *NxmTunMetadata47Masked) Serialize(encoder *goloxi.Encoder) error {
14401 if err := self.Oxm.Serialize(encoder); err != nil {
14402 return err
14403 }
14404
14405 encoder.Write(self.Value)
14406 encoder.Write(self.ValueMask)
14407
14408 return nil
14409}
14410
14411func DecodeNxmTunMetadata47Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata47Masked, error) {
14412 _nxmtunmetadata47masked := &NxmTunMetadata47Masked{Oxm: parent}
14413 _nxmtunmetadata47masked.Value = decoder.Read(int(_nxmtunmetadata47masked.TypeLen & 0xFF))
14414 _nxmtunmetadata47masked.ValueMask = decoder.Read(int(_nxmtunmetadata47masked.TypeLen & 0xFF))
14415 return _nxmtunmetadata47masked, nil
14416}
14417
14418func NewNxmTunMetadata47Masked() *NxmTunMetadata47Masked {
14419 obj := &NxmTunMetadata47Masked{
14420 Oxm: NewOxm(110584),
14421 }
14422 return obj
14423}
14424func (self *NxmTunMetadata47Masked) GetOXMName() string {
14425 return "tun_metadata47_masked"
14426}
14427
14428func (self *NxmTunMetadata47Masked) GetOXMValue() interface{} {
14429 return self.Value
14430}
14431
14432func (self *NxmTunMetadata47Masked) GetOXMValueMask() interface{} {
14433 return self.ValueMask
14434}
14435
14436func (self *NxmTunMetadata47Masked) MarshalJSON() ([]byte, error) {
14437 value, err := jsonValue(self.GetOXMValue())
14438 if err != nil {
14439 return nil, err
14440 }
14441 valueMask, err := jsonValue(self.GetOXMValueMask())
14442 if err != nil {
14443 return nil, err
14444 }
14445 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
14446}
14447
14448type NxmTunMetadata48 struct {
14449 *Oxm
14450 Value []byte
14451}
14452
14453type INxmTunMetadata48 interface {
14454 goloxi.IOxm
14455 GetValue() []byte
14456}
14457
14458func (self *NxmTunMetadata48) GetValue() []byte {
14459 return self.Value
14460}
14461
14462func (self *NxmTunMetadata48) SetValue(v []byte) {
14463 self.Value = v
14464}
14465
14466func (self *NxmTunMetadata48) Serialize(encoder *goloxi.Encoder) error {
14467 if err := self.Oxm.Serialize(encoder); err != nil {
14468 return err
14469 }
14470
14471 encoder.Write(self.Value)
14472
14473 return nil
14474}
14475
14476func DecodeNxmTunMetadata48(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata48, error) {
14477 _nxmtunmetadata48 := &NxmTunMetadata48{Oxm: parent}
14478 _nxmtunmetadata48.Value = decoder.Read(int(_nxmtunmetadata48.TypeLen & 0xFF))
14479 return _nxmtunmetadata48, nil
14480}
14481
14482func NewNxmTunMetadata48() *NxmTunMetadata48 {
14483 obj := &NxmTunMetadata48{
14484 Oxm: NewOxm(110716),
14485 }
14486 return obj
14487}
14488func (self *NxmTunMetadata48) GetOXMName() string {
14489 return "tun_metadata48"
14490}
14491
14492func (self *NxmTunMetadata48) GetOXMValue() interface{} {
14493 return self.Value
14494}
14495
14496func (self *NxmTunMetadata48) MarshalJSON() ([]byte, error) {
14497 value, err := jsonValue(self.GetOXMValue())
14498 if err != nil {
14499 return nil, err
14500 }
14501 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
14502}
14503
14504type NxmTunMetadata48Masked struct {
14505 *Oxm
14506 Value []byte
14507 ValueMask []byte
14508}
14509
14510type INxmTunMetadata48Masked interface {
14511 goloxi.IOxm
14512 GetValue() []byte
14513 GetValueMask() []byte
14514}
14515
14516func (self *NxmTunMetadata48Masked) GetValue() []byte {
14517 return self.Value
14518}
14519
14520func (self *NxmTunMetadata48Masked) SetValue(v []byte) {
14521 self.Value = v
14522}
14523
14524func (self *NxmTunMetadata48Masked) GetValueMask() []byte {
14525 return self.ValueMask
14526}
14527
14528func (self *NxmTunMetadata48Masked) SetValueMask(v []byte) {
14529 self.ValueMask = v
14530}
14531
14532func (self *NxmTunMetadata48Masked) Serialize(encoder *goloxi.Encoder) error {
14533 if err := self.Oxm.Serialize(encoder); err != nil {
14534 return err
14535 }
14536
14537 encoder.Write(self.Value)
14538 encoder.Write(self.ValueMask)
14539
14540 return nil
14541}
14542
14543func DecodeNxmTunMetadata48Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata48Masked, error) {
14544 _nxmtunmetadata48masked := &NxmTunMetadata48Masked{Oxm: parent}
14545 _nxmtunmetadata48masked.Value = decoder.Read(int(_nxmtunmetadata48masked.TypeLen & 0xFF))
14546 _nxmtunmetadata48masked.ValueMask = decoder.Read(int(_nxmtunmetadata48masked.TypeLen & 0xFF))
14547 return _nxmtunmetadata48masked, nil
14548}
14549
14550func NewNxmTunMetadata48Masked() *NxmTunMetadata48Masked {
14551 obj := &NxmTunMetadata48Masked{
14552 Oxm: NewOxm(111096),
14553 }
14554 return obj
14555}
14556func (self *NxmTunMetadata48Masked) GetOXMName() string {
14557 return "tun_metadata48_masked"
14558}
14559
14560func (self *NxmTunMetadata48Masked) GetOXMValue() interface{} {
14561 return self.Value
14562}
14563
14564func (self *NxmTunMetadata48Masked) GetOXMValueMask() interface{} {
14565 return self.ValueMask
14566}
14567
14568func (self *NxmTunMetadata48Masked) MarshalJSON() ([]byte, error) {
14569 value, err := jsonValue(self.GetOXMValue())
14570 if err != nil {
14571 return nil, err
14572 }
14573 valueMask, err := jsonValue(self.GetOXMValueMask())
14574 if err != nil {
14575 return nil, err
14576 }
14577 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
14578}
14579
14580type NxmTunMetadata49 struct {
14581 *Oxm
14582 Value []byte
14583}
14584
14585type INxmTunMetadata49 interface {
14586 goloxi.IOxm
14587 GetValue() []byte
14588}
14589
14590func (self *NxmTunMetadata49) GetValue() []byte {
14591 return self.Value
14592}
14593
14594func (self *NxmTunMetadata49) SetValue(v []byte) {
14595 self.Value = v
14596}
14597
14598func (self *NxmTunMetadata49) Serialize(encoder *goloxi.Encoder) error {
14599 if err := self.Oxm.Serialize(encoder); err != nil {
14600 return err
14601 }
14602
14603 encoder.Write(self.Value)
14604
14605 return nil
14606}
14607
14608func DecodeNxmTunMetadata49(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata49, error) {
14609 _nxmtunmetadata49 := &NxmTunMetadata49{Oxm: parent}
14610 _nxmtunmetadata49.Value = decoder.Read(int(_nxmtunmetadata49.TypeLen & 0xFF))
14611 return _nxmtunmetadata49, nil
14612}
14613
14614func NewNxmTunMetadata49() *NxmTunMetadata49 {
14615 obj := &NxmTunMetadata49{
14616 Oxm: NewOxm(111228),
14617 }
14618 return obj
14619}
14620func (self *NxmTunMetadata49) GetOXMName() string {
14621 return "tun_metadata49"
14622}
14623
14624func (self *NxmTunMetadata49) GetOXMValue() interface{} {
14625 return self.Value
14626}
14627
14628func (self *NxmTunMetadata49) MarshalJSON() ([]byte, error) {
14629 value, err := jsonValue(self.GetOXMValue())
14630 if err != nil {
14631 return nil, err
14632 }
14633 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
14634}
14635
14636type NxmTunMetadata49Masked struct {
14637 *Oxm
14638 Value []byte
14639 ValueMask []byte
14640}
14641
14642type INxmTunMetadata49Masked interface {
14643 goloxi.IOxm
14644 GetValue() []byte
14645 GetValueMask() []byte
14646}
14647
14648func (self *NxmTunMetadata49Masked) GetValue() []byte {
14649 return self.Value
14650}
14651
14652func (self *NxmTunMetadata49Masked) SetValue(v []byte) {
14653 self.Value = v
14654}
14655
14656func (self *NxmTunMetadata49Masked) GetValueMask() []byte {
14657 return self.ValueMask
14658}
14659
14660func (self *NxmTunMetadata49Masked) SetValueMask(v []byte) {
14661 self.ValueMask = v
14662}
14663
14664func (self *NxmTunMetadata49Masked) Serialize(encoder *goloxi.Encoder) error {
14665 if err := self.Oxm.Serialize(encoder); err != nil {
14666 return err
14667 }
14668
14669 encoder.Write(self.Value)
14670 encoder.Write(self.ValueMask)
14671
14672 return nil
14673}
14674
14675func DecodeNxmTunMetadata49Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata49Masked, error) {
14676 _nxmtunmetadata49masked := &NxmTunMetadata49Masked{Oxm: parent}
14677 _nxmtunmetadata49masked.Value = decoder.Read(int(_nxmtunmetadata49masked.TypeLen & 0xFF))
14678 _nxmtunmetadata49masked.ValueMask = decoder.Read(int(_nxmtunmetadata49masked.TypeLen & 0xFF))
14679 return _nxmtunmetadata49masked, nil
14680}
14681
14682func NewNxmTunMetadata49Masked() *NxmTunMetadata49Masked {
14683 obj := &NxmTunMetadata49Masked{
14684 Oxm: NewOxm(111608),
14685 }
14686 return obj
14687}
14688func (self *NxmTunMetadata49Masked) GetOXMName() string {
14689 return "tun_metadata49_masked"
14690}
14691
14692func (self *NxmTunMetadata49Masked) GetOXMValue() interface{} {
14693 return self.Value
14694}
14695
14696func (self *NxmTunMetadata49Masked) GetOXMValueMask() interface{} {
14697 return self.ValueMask
14698}
14699
14700func (self *NxmTunMetadata49Masked) MarshalJSON() ([]byte, error) {
14701 value, err := jsonValue(self.GetOXMValue())
14702 if err != nil {
14703 return nil, err
14704 }
14705 valueMask, err := jsonValue(self.GetOXMValueMask())
14706 if err != nil {
14707 return nil, err
14708 }
14709 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
14710}
14711
14712type NxmTunMetadata4Masked struct {
14713 *Oxm
14714 Value []byte
14715 ValueMask []byte
14716}
14717
14718type INxmTunMetadata4Masked interface {
14719 goloxi.IOxm
14720 GetValue() []byte
14721 GetValueMask() []byte
14722}
14723
14724func (self *NxmTunMetadata4Masked) GetValue() []byte {
14725 return self.Value
14726}
14727
14728func (self *NxmTunMetadata4Masked) SetValue(v []byte) {
14729 self.Value = v
14730}
14731
14732func (self *NxmTunMetadata4Masked) GetValueMask() []byte {
14733 return self.ValueMask
14734}
14735
14736func (self *NxmTunMetadata4Masked) SetValueMask(v []byte) {
14737 self.ValueMask = v
14738}
14739
14740func (self *NxmTunMetadata4Masked) Serialize(encoder *goloxi.Encoder) error {
14741 if err := self.Oxm.Serialize(encoder); err != nil {
14742 return err
14743 }
14744
14745 encoder.Write(self.Value)
14746 encoder.Write(self.ValueMask)
14747
14748 return nil
14749}
14750
14751func DecodeNxmTunMetadata4Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata4Masked, error) {
14752 _nxmtunmetadata4masked := &NxmTunMetadata4Masked{Oxm: parent}
14753 _nxmtunmetadata4masked.Value = decoder.Read(int(_nxmtunmetadata4masked.TypeLen & 0xFF))
14754 _nxmtunmetadata4masked.ValueMask = decoder.Read(int(_nxmtunmetadata4masked.TypeLen & 0xFF))
14755 return _nxmtunmetadata4masked, nil
14756}
14757
14758func NewNxmTunMetadata4Masked() *NxmTunMetadata4Masked {
14759 obj := &NxmTunMetadata4Masked{
14760 Oxm: NewOxm(88568),
14761 }
14762 return obj
14763}
14764func (self *NxmTunMetadata4Masked) GetOXMName() string {
14765 return "tun_metadata4_masked"
14766}
14767
14768func (self *NxmTunMetadata4Masked) GetOXMValue() interface{} {
14769 return self.Value
14770}
14771
14772func (self *NxmTunMetadata4Masked) GetOXMValueMask() interface{} {
14773 return self.ValueMask
14774}
14775
14776func (self *NxmTunMetadata4Masked) MarshalJSON() ([]byte, error) {
14777 value, err := jsonValue(self.GetOXMValue())
14778 if err != nil {
14779 return nil, err
14780 }
14781 valueMask, err := jsonValue(self.GetOXMValueMask())
14782 if err != nil {
14783 return nil, err
14784 }
14785 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
14786}
14787
14788type NxmTunMetadata5 struct {
14789 *Oxm
14790 Value []byte
14791}
14792
14793type INxmTunMetadata5 interface {
14794 goloxi.IOxm
14795 GetValue() []byte
14796}
14797
14798func (self *NxmTunMetadata5) GetValue() []byte {
14799 return self.Value
14800}
14801
14802func (self *NxmTunMetadata5) SetValue(v []byte) {
14803 self.Value = v
14804}
14805
14806func (self *NxmTunMetadata5) Serialize(encoder *goloxi.Encoder) error {
14807 if err := self.Oxm.Serialize(encoder); err != nil {
14808 return err
14809 }
14810
14811 encoder.Write(self.Value)
14812
14813 return nil
14814}
14815
14816func DecodeNxmTunMetadata5(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata5, error) {
14817 _nxmtunmetadata5 := &NxmTunMetadata5{Oxm: parent}
14818 _nxmtunmetadata5.Value = decoder.Read(int(_nxmtunmetadata5.TypeLen & 0xFF))
14819 return _nxmtunmetadata5, nil
14820}
14821
14822func NewNxmTunMetadata5() *NxmTunMetadata5 {
14823 obj := &NxmTunMetadata5{
14824 Oxm: NewOxm(88700),
14825 }
14826 return obj
14827}
14828func (self *NxmTunMetadata5) GetOXMName() string {
14829 return "tun_metadata5"
14830}
14831
14832func (self *NxmTunMetadata5) GetOXMValue() interface{} {
14833 return self.Value
14834}
14835
14836func (self *NxmTunMetadata5) MarshalJSON() ([]byte, error) {
14837 value, err := jsonValue(self.GetOXMValue())
14838 if err != nil {
14839 return nil, err
14840 }
14841 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
14842}
14843
14844type NxmTunMetadata50 struct {
14845 *Oxm
14846 Value []byte
14847}
14848
14849type INxmTunMetadata50 interface {
14850 goloxi.IOxm
14851 GetValue() []byte
14852}
14853
14854func (self *NxmTunMetadata50) GetValue() []byte {
14855 return self.Value
14856}
14857
14858func (self *NxmTunMetadata50) SetValue(v []byte) {
14859 self.Value = v
14860}
14861
14862func (self *NxmTunMetadata50) Serialize(encoder *goloxi.Encoder) error {
14863 if err := self.Oxm.Serialize(encoder); err != nil {
14864 return err
14865 }
14866
14867 encoder.Write(self.Value)
14868
14869 return nil
14870}
14871
14872func DecodeNxmTunMetadata50(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata50, error) {
14873 _nxmtunmetadata50 := &NxmTunMetadata50{Oxm: parent}
14874 _nxmtunmetadata50.Value = decoder.Read(int(_nxmtunmetadata50.TypeLen & 0xFF))
14875 return _nxmtunmetadata50, nil
14876}
14877
14878func NewNxmTunMetadata50() *NxmTunMetadata50 {
14879 obj := &NxmTunMetadata50{
14880 Oxm: NewOxm(111740),
14881 }
14882 return obj
14883}
14884func (self *NxmTunMetadata50) GetOXMName() string {
14885 return "tun_metadata50"
14886}
14887
14888func (self *NxmTunMetadata50) GetOXMValue() interface{} {
14889 return self.Value
14890}
14891
14892func (self *NxmTunMetadata50) MarshalJSON() ([]byte, error) {
14893 value, err := jsonValue(self.GetOXMValue())
14894 if err != nil {
14895 return nil, err
14896 }
14897 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
14898}
14899
14900type NxmTunMetadata50Masked struct {
14901 *Oxm
14902 Value []byte
14903 ValueMask []byte
14904}
14905
14906type INxmTunMetadata50Masked interface {
14907 goloxi.IOxm
14908 GetValue() []byte
14909 GetValueMask() []byte
14910}
14911
14912func (self *NxmTunMetadata50Masked) GetValue() []byte {
14913 return self.Value
14914}
14915
14916func (self *NxmTunMetadata50Masked) SetValue(v []byte) {
14917 self.Value = v
14918}
14919
14920func (self *NxmTunMetadata50Masked) GetValueMask() []byte {
14921 return self.ValueMask
14922}
14923
14924func (self *NxmTunMetadata50Masked) SetValueMask(v []byte) {
14925 self.ValueMask = v
14926}
14927
14928func (self *NxmTunMetadata50Masked) Serialize(encoder *goloxi.Encoder) error {
14929 if err := self.Oxm.Serialize(encoder); err != nil {
14930 return err
14931 }
14932
14933 encoder.Write(self.Value)
14934 encoder.Write(self.ValueMask)
14935
14936 return nil
14937}
14938
14939func DecodeNxmTunMetadata50Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata50Masked, error) {
14940 _nxmtunmetadata50masked := &NxmTunMetadata50Masked{Oxm: parent}
14941 _nxmtunmetadata50masked.Value = decoder.Read(int(_nxmtunmetadata50masked.TypeLen & 0xFF))
14942 _nxmtunmetadata50masked.ValueMask = decoder.Read(int(_nxmtunmetadata50masked.TypeLen & 0xFF))
14943 return _nxmtunmetadata50masked, nil
14944}
14945
14946func NewNxmTunMetadata50Masked() *NxmTunMetadata50Masked {
14947 obj := &NxmTunMetadata50Masked{
14948 Oxm: NewOxm(112120),
14949 }
14950 return obj
14951}
14952func (self *NxmTunMetadata50Masked) GetOXMName() string {
14953 return "tun_metadata50_masked"
14954}
14955
14956func (self *NxmTunMetadata50Masked) GetOXMValue() interface{} {
14957 return self.Value
14958}
14959
14960func (self *NxmTunMetadata50Masked) GetOXMValueMask() interface{} {
14961 return self.ValueMask
14962}
14963
14964func (self *NxmTunMetadata50Masked) MarshalJSON() ([]byte, error) {
14965 value, err := jsonValue(self.GetOXMValue())
14966 if err != nil {
14967 return nil, err
14968 }
14969 valueMask, err := jsonValue(self.GetOXMValueMask())
14970 if err != nil {
14971 return nil, err
14972 }
14973 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
14974}
14975
14976type NxmTunMetadata51 struct {
14977 *Oxm
14978 Value []byte
14979}
14980
14981type INxmTunMetadata51 interface {
14982 goloxi.IOxm
14983 GetValue() []byte
14984}
14985
14986func (self *NxmTunMetadata51) GetValue() []byte {
14987 return self.Value
14988}
14989
14990func (self *NxmTunMetadata51) SetValue(v []byte) {
14991 self.Value = v
14992}
14993
14994func (self *NxmTunMetadata51) Serialize(encoder *goloxi.Encoder) error {
14995 if err := self.Oxm.Serialize(encoder); err != nil {
14996 return err
14997 }
14998
14999 encoder.Write(self.Value)
15000
15001 return nil
15002}
15003
15004func DecodeNxmTunMetadata51(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata51, error) {
15005 _nxmtunmetadata51 := &NxmTunMetadata51{Oxm: parent}
15006 _nxmtunmetadata51.Value = decoder.Read(int(_nxmtunmetadata51.TypeLen & 0xFF))
15007 return _nxmtunmetadata51, nil
15008}
15009
15010func NewNxmTunMetadata51() *NxmTunMetadata51 {
15011 obj := &NxmTunMetadata51{
15012 Oxm: NewOxm(112252),
15013 }
15014 return obj
15015}
15016func (self *NxmTunMetadata51) GetOXMName() string {
15017 return "tun_metadata51"
15018}
15019
15020func (self *NxmTunMetadata51) GetOXMValue() interface{} {
15021 return self.Value
15022}
15023
15024func (self *NxmTunMetadata51) MarshalJSON() ([]byte, error) {
15025 value, err := jsonValue(self.GetOXMValue())
15026 if err != nil {
15027 return nil, err
15028 }
15029 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
15030}
15031
15032type NxmTunMetadata51Masked struct {
15033 *Oxm
15034 Value []byte
15035 ValueMask []byte
15036}
15037
15038type INxmTunMetadata51Masked interface {
15039 goloxi.IOxm
15040 GetValue() []byte
15041 GetValueMask() []byte
15042}
15043
15044func (self *NxmTunMetadata51Masked) GetValue() []byte {
15045 return self.Value
15046}
15047
15048func (self *NxmTunMetadata51Masked) SetValue(v []byte) {
15049 self.Value = v
15050}
15051
15052func (self *NxmTunMetadata51Masked) GetValueMask() []byte {
15053 return self.ValueMask
15054}
15055
15056func (self *NxmTunMetadata51Masked) SetValueMask(v []byte) {
15057 self.ValueMask = v
15058}
15059
15060func (self *NxmTunMetadata51Masked) Serialize(encoder *goloxi.Encoder) error {
15061 if err := self.Oxm.Serialize(encoder); err != nil {
15062 return err
15063 }
15064
15065 encoder.Write(self.Value)
15066 encoder.Write(self.ValueMask)
15067
15068 return nil
15069}
15070
15071func DecodeNxmTunMetadata51Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata51Masked, error) {
15072 _nxmtunmetadata51masked := &NxmTunMetadata51Masked{Oxm: parent}
15073 _nxmtunmetadata51masked.Value = decoder.Read(int(_nxmtunmetadata51masked.TypeLen & 0xFF))
15074 _nxmtunmetadata51masked.ValueMask = decoder.Read(int(_nxmtunmetadata51masked.TypeLen & 0xFF))
15075 return _nxmtunmetadata51masked, nil
15076}
15077
15078func NewNxmTunMetadata51Masked() *NxmTunMetadata51Masked {
15079 obj := &NxmTunMetadata51Masked{
15080 Oxm: NewOxm(112632),
15081 }
15082 return obj
15083}
15084func (self *NxmTunMetadata51Masked) GetOXMName() string {
15085 return "tun_metadata51_masked"
15086}
15087
15088func (self *NxmTunMetadata51Masked) GetOXMValue() interface{} {
15089 return self.Value
15090}
15091
15092func (self *NxmTunMetadata51Masked) GetOXMValueMask() interface{} {
15093 return self.ValueMask
15094}
15095
15096func (self *NxmTunMetadata51Masked) MarshalJSON() ([]byte, error) {
15097 value, err := jsonValue(self.GetOXMValue())
15098 if err != nil {
15099 return nil, err
15100 }
15101 valueMask, err := jsonValue(self.GetOXMValueMask())
15102 if err != nil {
15103 return nil, err
15104 }
15105 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
15106}
15107
15108type NxmTunMetadata52 struct {
15109 *Oxm
15110 Value []byte
15111}
15112
15113type INxmTunMetadata52 interface {
15114 goloxi.IOxm
15115 GetValue() []byte
15116}
15117
15118func (self *NxmTunMetadata52) GetValue() []byte {
15119 return self.Value
15120}
15121
15122func (self *NxmTunMetadata52) SetValue(v []byte) {
15123 self.Value = v
15124}
15125
15126func (self *NxmTunMetadata52) Serialize(encoder *goloxi.Encoder) error {
15127 if err := self.Oxm.Serialize(encoder); err != nil {
15128 return err
15129 }
15130
15131 encoder.Write(self.Value)
15132
15133 return nil
15134}
15135
15136func DecodeNxmTunMetadata52(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata52, error) {
15137 _nxmtunmetadata52 := &NxmTunMetadata52{Oxm: parent}
15138 _nxmtunmetadata52.Value = decoder.Read(int(_nxmtunmetadata52.TypeLen & 0xFF))
15139 return _nxmtunmetadata52, nil
15140}
15141
15142func NewNxmTunMetadata52() *NxmTunMetadata52 {
15143 obj := &NxmTunMetadata52{
15144 Oxm: NewOxm(112764),
15145 }
15146 return obj
15147}
15148func (self *NxmTunMetadata52) GetOXMName() string {
15149 return "tun_metadata52"
15150}
15151
15152func (self *NxmTunMetadata52) GetOXMValue() interface{} {
15153 return self.Value
15154}
15155
15156func (self *NxmTunMetadata52) MarshalJSON() ([]byte, error) {
15157 value, err := jsonValue(self.GetOXMValue())
15158 if err != nil {
15159 return nil, err
15160 }
15161 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
15162}
15163
15164type NxmTunMetadata52Masked struct {
15165 *Oxm
15166 Value []byte
15167 ValueMask []byte
15168}
15169
15170type INxmTunMetadata52Masked interface {
15171 goloxi.IOxm
15172 GetValue() []byte
15173 GetValueMask() []byte
15174}
15175
15176func (self *NxmTunMetadata52Masked) GetValue() []byte {
15177 return self.Value
15178}
15179
15180func (self *NxmTunMetadata52Masked) SetValue(v []byte) {
15181 self.Value = v
15182}
15183
15184func (self *NxmTunMetadata52Masked) GetValueMask() []byte {
15185 return self.ValueMask
15186}
15187
15188func (self *NxmTunMetadata52Masked) SetValueMask(v []byte) {
15189 self.ValueMask = v
15190}
15191
15192func (self *NxmTunMetadata52Masked) Serialize(encoder *goloxi.Encoder) error {
15193 if err := self.Oxm.Serialize(encoder); err != nil {
15194 return err
15195 }
15196
15197 encoder.Write(self.Value)
15198 encoder.Write(self.ValueMask)
15199
15200 return nil
15201}
15202
15203func DecodeNxmTunMetadata52Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata52Masked, error) {
15204 _nxmtunmetadata52masked := &NxmTunMetadata52Masked{Oxm: parent}
15205 _nxmtunmetadata52masked.Value = decoder.Read(int(_nxmtunmetadata52masked.TypeLen & 0xFF))
15206 _nxmtunmetadata52masked.ValueMask = decoder.Read(int(_nxmtunmetadata52masked.TypeLen & 0xFF))
15207 return _nxmtunmetadata52masked, nil
15208}
15209
15210func NewNxmTunMetadata52Masked() *NxmTunMetadata52Masked {
15211 obj := &NxmTunMetadata52Masked{
15212 Oxm: NewOxm(113144),
15213 }
15214 return obj
15215}
15216func (self *NxmTunMetadata52Masked) GetOXMName() string {
15217 return "tun_metadata52_masked"
15218}
15219
15220func (self *NxmTunMetadata52Masked) GetOXMValue() interface{} {
15221 return self.Value
15222}
15223
15224func (self *NxmTunMetadata52Masked) GetOXMValueMask() interface{} {
15225 return self.ValueMask
15226}
15227
15228func (self *NxmTunMetadata52Masked) MarshalJSON() ([]byte, error) {
15229 value, err := jsonValue(self.GetOXMValue())
15230 if err != nil {
15231 return nil, err
15232 }
15233 valueMask, err := jsonValue(self.GetOXMValueMask())
15234 if err != nil {
15235 return nil, err
15236 }
15237 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
15238}
15239
15240type NxmTunMetadata53 struct {
15241 *Oxm
15242 Value []byte
15243}
15244
15245type INxmTunMetadata53 interface {
15246 goloxi.IOxm
15247 GetValue() []byte
15248}
15249
15250func (self *NxmTunMetadata53) GetValue() []byte {
15251 return self.Value
15252}
15253
15254func (self *NxmTunMetadata53) SetValue(v []byte) {
15255 self.Value = v
15256}
15257
15258func (self *NxmTunMetadata53) Serialize(encoder *goloxi.Encoder) error {
15259 if err := self.Oxm.Serialize(encoder); err != nil {
15260 return err
15261 }
15262
15263 encoder.Write(self.Value)
15264
15265 return nil
15266}
15267
15268func DecodeNxmTunMetadata53(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata53, error) {
15269 _nxmtunmetadata53 := &NxmTunMetadata53{Oxm: parent}
15270 _nxmtunmetadata53.Value = decoder.Read(int(_nxmtunmetadata53.TypeLen & 0xFF))
15271 return _nxmtunmetadata53, nil
15272}
15273
15274func NewNxmTunMetadata53() *NxmTunMetadata53 {
15275 obj := &NxmTunMetadata53{
15276 Oxm: NewOxm(113276),
15277 }
15278 return obj
15279}
15280func (self *NxmTunMetadata53) GetOXMName() string {
15281 return "tun_metadata53"
15282}
15283
15284func (self *NxmTunMetadata53) GetOXMValue() interface{} {
15285 return self.Value
15286}
15287
15288func (self *NxmTunMetadata53) MarshalJSON() ([]byte, error) {
15289 value, err := jsonValue(self.GetOXMValue())
15290 if err != nil {
15291 return nil, err
15292 }
15293 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
15294}
15295
15296type NxmTunMetadata53Masked struct {
15297 *Oxm
15298 Value []byte
15299 ValueMask []byte
15300}
15301
15302type INxmTunMetadata53Masked interface {
15303 goloxi.IOxm
15304 GetValue() []byte
15305 GetValueMask() []byte
15306}
15307
15308func (self *NxmTunMetadata53Masked) GetValue() []byte {
15309 return self.Value
15310}
15311
15312func (self *NxmTunMetadata53Masked) SetValue(v []byte) {
15313 self.Value = v
15314}
15315
15316func (self *NxmTunMetadata53Masked) GetValueMask() []byte {
15317 return self.ValueMask
15318}
15319
15320func (self *NxmTunMetadata53Masked) SetValueMask(v []byte) {
15321 self.ValueMask = v
15322}
15323
15324func (self *NxmTunMetadata53Masked) Serialize(encoder *goloxi.Encoder) error {
15325 if err := self.Oxm.Serialize(encoder); err != nil {
15326 return err
15327 }
15328
15329 encoder.Write(self.Value)
15330 encoder.Write(self.ValueMask)
15331
15332 return nil
15333}
15334
15335func DecodeNxmTunMetadata53Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata53Masked, error) {
15336 _nxmtunmetadata53masked := &NxmTunMetadata53Masked{Oxm: parent}
15337 _nxmtunmetadata53masked.Value = decoder.Read(int(_nxmtunmetadata53masked.TypeLen & 0xFF))
15338 _nxmtunmetadata53masked.ValueMask = decoder.Read(int(_nxmtunmetadata53masked.TypeLen & 0xFF))
15339 return _nxmtunmetadata53masked, nil
15340}
15341
15342func NewNxmTunMetadata53Masked() *NxmTunMetadata53Masked {
15343 obj := &NxmTunMetadata53Masked{
15344 Oxm: NewOxm(113656),
15345 }
15346 return obj
15347}
15348func (self *NxmTunMetadata53Masked) GetOXMName() string {
15349 return "tun_metadata53_masked"
15350}
15351
15352func (self *NxmTunMetadata53Masked) GetOXMValue() interface{} {
15353 return self.Value
15354}
15355
15356func (self *NxmTunMetadata53Masked) GetOXMValueMask() interface{} {
15357 return self.ValueMask
15358}
15359
15360func (self *NxmTunMetadata53Masked) MarshalJSON() ([]byte, error) {
15361 value, err := jsonValue(self.GetOXMValue())
15362 if err != nil {
15363 return nil, err
15364 }
15365 valueMask, err := jsonValue(self.GetOXMValueMask())
15366 if err != nil {
15367 return nil, err
15368 }
15369 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
15370}
15371
15372type NxmTunMetadata54 struct {
15373 *Oxm
15374 Value []byte
15375}
15376
15377type INxmTunMetadata54 interface {
15378 goloxi.IOxm
15379 GetValue() []byte
15380}
15381
15382func (self *NxmTunMetadata54) GetValue() []byte {
15383 return self.Value
15384}
15385
15386func (self *NxmTunMetadata54) SetValue(v []byte) {
15387 self.Value = v
15388}
15389
15390func (self *NxmTunMetadata54) Serialize(encoder *goloxi.Encoder) error {
15391 if err := self.Oxm.Serialize(encoder); err != nil {
15392 return err
15393 }
15394
15395 encoder.Write(self.Value)
15396
15397 return nil
15398}
15399
15400func DecodeNxmTunMetadata54(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata54, error) {
15401 _nxmtunmetadata54 := &NxmTunMetadata54{Oxm: parent}
15402 _nxmtunmetadata54.Value = decoder.Read(int(_nxmtunmetadata54.TypeLen & 0xFF))
15403 return _nxmtunmetadata54, nil
15404}
15405
15406func NewNxmTunMetadata54() *NxmTunMetadata54 {
15407 obj := &NxmTunMetadata54{
15408 Oxm: NewOxm(113788),
15409 }
15410 return obj
15411}
15412func (self *NxmTunMetadata54) GetOXMName() string {
15413 return "tun_metadata54"
15414}
15415
15416func (self *NxmTunMetadata54) GetOXMValue() interface{} {
15417 return self.Value
15418}
15419
15420func (self *NxmTunMetadata54) MarshalJSON() ([]byte, error) {
15421 value, err := jsonValue(self.GetOXMValue())
15422 if err != nil {
15423 return nil, err
15424 }
15425 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
15426}
15427
15428type NxmTunMetadata54Masked struct {
15429 *Oxm
15430 Value []byte
15431 ValueMask []byte
15432}
15433
15434type INxmTunMetadata54Masked interface {
15435 goloxi.IOxm
15436 GetValue() []byte
15437 GetValueMask() []byte
15438}
15439
15440func (self *NxmTunMetadata54Masked) GetValue() []byte {
15441 return self.Value
15442}
15443
15444func (self *NxmTunMetadata54Masked) SetValue(v []byte) {
15445 self.Value = v
15446}
15447
15448func (self *NxmTunMetadata54Masked) GetValueMask() []byte {
15449 return self.ValueMask
15450}
15451
15452func (self *NxmTunMetadata54Masked) SetValueMask(v []byte) {
15453 self.ValueMask = v
15454}
15455
15456func (self *NxmTunMetadata54Masked) Serialize(encoder *goloxi.Encoder) error {
15457 if err := self.Oxm.Serialize(encoder); err != nil {
15458 return err
15459 }
15460
15461 encoder.Write(self.Value)
15462 encoder.Write(self.ValueMask)
15463
15464 return nil
15465}
15466
15467func DecodeNxmTunMetadata54Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata54Masked, error) {
15468 _nxmtunmetadata54masked := &NxmTunMetadata54Masked{Oxm: parent}
15469 _nxmtunmetadata54masked.Value = decoder.Read(int(_nxmtunmetadata54masked.TypeLen & 0xFF))
15470 _nxmtunmetadata54masked.ValueMask = decoder.Read(int(_nxmtunmetadata54masked.TypeLen & 0xFF))
15471 return _nxmtunmetadata54masked, nil
15472}
15473
15474func NewNxmTunMetadata54Masked() *NxmTunMetadata54Masked {
15475 obj := &NxmTunMetadata54Masked{
15476 Oxm: NewOxm(114168),
15477 }
15478 return obj
15479}
15480func (self *NxmTunMetadata54Masked) GetOXMName() string {
15481 return "tun_metadata54_masked"
15482}
15483
15484func (self *NxmTunMetadata54Masked) GetOXMValue() interface{} {
15485 return self.Value
15486}
15487
15488func (self *NxmTunMetadata54Masked) GetOXMValueMask() interface{} {
15489 return self.ValueMask
15490}
15491
15492func (self *NxmTunMetadata54Masked) MarshalJSON() ([]byte, error) {
15493 value, err := jsonValue(self.GetOXMValue())
15494 if err != nil {
15495 return nil, err
15496 }
15497 valueMask, err := jsonValue(self.GetOXMValueMask())
15498 if err != nil {
15499 return nil, err
15500 }
15501 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
15502}
15503
15504type NxmTunMetadata55 struct {
15505 *Oxm
15506 Value []byte
15507}
15508
15509type INxmTunMetadata55 interface {
15510 goloxi.IOxm
15511 GetValue() []byte
15512}
15513
15514func (self *NxmTunMetadata55) GetValue() []byte {
15515 return self.Value
15516}
15517
15518func (self *NxmTunMetadata55) SetValue(v []byte) {
15519 self.Value = v
15520}
15521
15522func (self *NxmTunMetadata55) Serialize(encoder *goloxi.Encoder) error {
15523 if err := self.Oxm.Serialize(encoder); err != nil {
15524 return err
15525 }
15526
15527 encoder.Write(self.Value)
15528
15529 return nil
15530}
15531
15532func DecodeNxmTunMetadata55(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata55, error) {
15533 _nxmtunmetadata55 := &NxmTunMetadata55{Oxm: parent}
15534 _nxmtunmetadata55.Value = decoder.Read(int(_nxmtunmetadata55.TypeLen & 0xFF))
15535 return _nxmtunmetadata55, nil
15536}
15537
15538func NewNxmTunMetadata55() *NxmTunMetadata55 {
15539 obj := &NxmTunMetadata55{
15540 Oxm: NewOxm(114300),
15541 }
15542 return obj
15543}
15544func (self *NxmTunMetadata55) GetOXMName() string {
15545 return "tun_metadata55"
15546}
15547
15548func (self *NxmTunMetadata55) GetOXMValue() interface{} {
15549 return self.Value
15550}
15551
15552func (self *NxmTunMetadata55) MarshalJSON() ([]byte, error) {
15553 value, err := jsonValue(self.GetOXMValue())
15554 if err != nil {
15555 return nil, err
15556 }
15557 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
15558}
15559
15560type NxmTunMetadata55Masked struct {
15561 *Oxm
15562 Value []byte
15563 ValueMask []byte
15564}
15565
15566type INxmTunMetadata55Masked interface {
15567 goloxi.IOxm
15568 GetValue() []byte
15569 GetValueMask() []byte
15570}
15571
15572func (self *NxmTunMetadata55Masked) GetValue() []byte {
15573 return self.Value
15574}
15575
15576func (self *NxmTunMetadata55Masked) SetValue(v []byte) {
15577 self.Value = v
15578}
15579
15580func (self *NxmTunMetadata55Masked) GetValueMask() []byte {
15581 return self.ValueMask
15582}
15583
15584func (self *NxmTunMetadata55Masked) SetValueMask(v []byte) {
15585 self.ValueMask = v
15586}
15587
15588func (self *NxmTunMetadata55Masked) Serialize(encoder *goloxi.Encoder) error {
15589 if err := self.Oxm.Serialize(encoder); err != nil {
15590 return err
15591 }
15592
15593 encoder.Write(self.Value)
15594 encoder.Write(self.ValueMask)
15595
15596 return nil
15597}
15598
15599func DecodeNxmTunMetadata55Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata55Masked, error) {
15600 _nxmtunmetadata55masked := &NxmTunMetadata55Masked{Oxm: parent}
15601 _nxmtunmetadata55masked.Value = decoder.Read(int(_nxmtunmetadata55masked.TypeLen & 0xFF))
15602 _nxmtunmetadata55masked.ValueMask = decoder.Read(int(_nxmtunmetadata55masked.TypeLen & 0xFF))
15603 return _nxmtunmetadata55masked, nil
15604}
15605
15606func NewNxmTunMetadata55Masked() *NxmTunMetadata55Masked {
15607 obj := &NxmTunMetadata55Masked{
15608 Oxm: NewOxm(114680),
15609 }
15610 return obj
15611}
15612func (self *NxmTunMetadata55Masked) GetOXMName() string {
15613 return "tun_metadata55_masked"
15614}
15615
15616func (self *NxmTunMetadata55Masked) GetOXMValue() interface{} {
15617 return self.Value
15618}
15619
15620func (self *NxmTunMetadata55Masked) GetOXMValueMask() interface{} {
15621 return self.ValueMask
15622}
15623
15624func (self *NxmTunMetadata55Masked) MarshalJSON() ([]byte, error) {
15625 value, err := jsonValue(self.GetOXMValue())
15626 if err != nil {
15627 return nil, err
15628 }
15629 valueMask, err := jsonValue(self.GetOXMValueMask())
15630 if err != nil {
15631 return nil, err
15632 }
15633 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
15634}
15635
15636type NxmTunMetadata56 struct {
15637 *Oxm
15638 Value []byte
15639}
15640
15641type INxmTunMetadata56 interface {
15642 goloxi.IOxm
15643 GetValue() []byte
15644}
15645
15646func (self *NxmTunMetadata56) GetValue() []byte {
15647 return self.Value
15648}
15649
15650func (self *NxmTunMetadata56) SetValue(v []byte) {
15651 self.Value = v
15652}
15653
15654func (self *NxmTunMetadata56) Serialize(encoder *goloxi.Encoder) error {
15655 if err := self.Oxm.Serialize(encoder); err != nil {
15656 return err
15657 }
15658
15659 encoder.Write(self.Value)
15660
15661 return nil
15662}
15663
15664func DecodeNxmTunMetadata56(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata56, error) {
15665 _nxmtunmetadata56 := &NxmTunMetadata56{Oxm: parent}
15666 _nxmtunmetadata56.Value = decoder.Read(int(_nxmtunmetadata56.TypeLen & 0xFF))
15667 return _nxmtunmetadata56, nil
15668}
15669
15670func NewNxmTunMetadata56() *NxmTunMetadata56 {
15671 obj := &NxmTunMetadata56{
15672 Oxm: NewOxm(114812),
15673 }
15674 return obj
15675}
15676func (self *NxmTunMetadata56) GetOXMName() string {
15677 return "tun_metadata56"
15678}
15679
15680func (self *NxmTunMetadata56) GetOXMValue() interface{} {
15681 return self.Value
15682}
15683
15684func (self *NxmTunMetadata56) MarshalJSON() ([]byte, error) {
15685 value, err := jsonValue(self.GetOXMValue())
15686 if err != nil {
15687 return nil, err
15688 }
15689 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
15690}
15691
15692type NxmTunMetadata56Masked struct {
15693 *Oxm
15694 Value []byte
15695 ValueMask []byte
15696}
15697
15698type INxmTunMetadata56Masked interface {
15699 goloxi.IOxm
15700 GetValue() []byte
15701 GetValueMask() []byte
15702}
15703
15704func (self *NxmTunMetadata56Masked) GetValue() []byte {
15705 return self.Value
15706}
15707
15708func (self *NxmTunMetadata56Masked) SetValue(v []byte) {
15709 self.Value = v
15710}
15711
15712func (self *NxmTunMetadata56Masked) GetValueMask() []byte {
15713 return self.ValueMask
15714}
15715
15716func (self *NxmTunMetadata56Masked) SetValueMask(v []byte) {
15717 self.ValueMask = v
15718}
15719
15720func (self *NxmTunMetadata56Masked) Serialize(encoder *goloxi.Encoder) error {
15721 if err := self.Oxm.Serialize(encoder); err != nil {
15722 return err
15723 }
15724
15725 encoder.Write(self.Value)
15726 encoder.Write(self.ValueMask)
15727
15728 return nil
15729}
15730
15731func DecodeNxmTunMetadata56Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata56Masked, error) {
15732 _nxmtunmetadata56masked := &NxmTunMetadata56Masked{Oxm: parent}
15733 _nxmtunmetadata56masked.Value = decoder.Read(int(_nxmtunmetadata56masked.TypeLen & 0xFF))
15734 _nxmtunmetadata56masked.ValueMask = decoder.Read(int(_nxmtunmetadata56masked.TypeLen & 0xFF))
15735 return _nxmtunmetadata56masked, nil
15736}
15737
15738func NewNxmTunMetadata56Masked() *NxmTunMetadata56Masked {
15739 obj := &NxmTunMetadata56Masked{
15740 Oxm: NewOxm(115192),
15741 }
15742 return obj
15743}
15744func (self *NxmTunMetadata56Masked) GetOXMName() string {
15745 return "tun_metadata56_masked"
15746}
15747
15748func (self *NxmTunMetadata56Masked) GetOXMValue() interface{} {
15749 return self.Value
15750}
15751
15752func (self *NxmTunMetadata56Masked) GetOXMValueMask() interface{} {
15753 return self.ValueMask
15754}
15755
15756func (self *NxmTunMetadata56Masked) MarshalJSON() ([]byte, error) {
15757 value, err := jsonValue(self.GetOXMValue())
15758 if err != nil {
15759 return nil, err
15760 }
15761 valueMask, err := jsonValue(self.GetOXMValueMask())
15762 if err != nil {
15763 return nil, err
15764 }
15765 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
15766}
15767
15768type NxmTunMetadata57 struct {
15769 *Oxm
15770 Value []byte
15771}
15772
15773type INxmTunMetadata57 interface {
15774 goloxi.IOxm
15775 GetValue() []byte
15776}
15777
15778func (self *NxmTunMetadata57) GetValue() []byte {
15779 return self.Value
15780}
15781
15782func (self *NxmTunMetadata57) SetValue(v []byte) {
15783 self.Value = v
15784}
15785
15786func (self *NxmTunMetadata57) Serialize(encoder *goloxi.Encoder) error {
15787 if err := self.Oxm.Serialize(encoder); err != nil {
15788 return err
15789 }
15790
15791 encoder.Write(self.Value)
15792
15793 return nil
15794}
15795
15796func DecodeNxmTunMetadata57(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata57, error) {
15797 _nxmtunmetadata57 := &NxmTunMetadata57{Oxm: parent}
15798 _nxmtunmetadata57.Value = decoder.Read(int(_nxmtunmetadata57.TypeLen & 0xFF))
15799 return _nxmtunmetadata57, nil
15800}
15801
15802func NewNxmTunMetadata57() *NxmTunMetadata57 {
15803 obj := &NxmTunMetadata57{
15804 Oxm: NewOxm(115324),
15805 }
15806 return obj
15807}
15808func (self *NxmTunMetadata57) GetOXMName() string {
15809 return "tun_metadata57"
15810}
15811
15812func (self *NxmTunMetadata57) GetOXMValue() interface{} {
15813 return self.Value
15814}
15815
15816func (self *NxmTunMetadata57) MarshalJSON() ([]byte, error) {
15817 value, err := jsonValue(self.GetOXMValue())
15818 if err != nil {
15819 return nil, err
15820 }
15821 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
15822}
15823
15824type NxmTunMetadata57Masked struct {
15825 *Oxm
15826 Value []byte
15827 ValueMask []byte
15828}
15829
15830type INxmTunMetadata57Masked interface {
15831 goloxi.IOxm
15832 GetValue() []byte
15833 GetValueMask() []byte
15834}
15835
15836func (self *NxmTunMetadata57Masked) GetValue() []byte {
15837 return self.Value
15838}
15839
15840func (self *NxmTunMetadata57Masked) SetValue(v []byte) {
15841 self.Value = v
15842}
15843
15844func (self *NxmTunMetadata57Masked) GetValueMask() []byte {
15845 return self.ValueMask
15846}
15847
15848func (self *NxmTunMetadata57Masked) SetValueMask(v []byte) {
15849 self.ValueMask = v
15850}
15851
15852func (self *NxmTunMetadata57Masked) Serialize(encoder *goloxi.Encoder) error {
15853 if err := self.Oxm.Serialize(encoder); err != nil {
15854 return err
15855 }
15856
15857 encoder.Write(self.Value)
15858 encoder.Write(self.ValueMask)
15859
15860 return nil
15861}
15862
15863func DecodeNxmTunMetadata57Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata57Masked, error) {
15864 _nxmtunmetadata57masked := &NxmTunMetadata57Masked{Oxm: parent}
15865 _nxmtunmetadata57masked.Value = decoder.Read(int(_nxmtunmetadata57masked.TypeLen & 0xFF))
15866 _nxmtunmetadata57masked.ValueMask = decoder.Read(int(_nxmtunmetadata57masked.TypeLen & 0xFF))
15867 return _nxmtunmetadata57masked, nil
15868}
15869
15870func NewNxmTunMetadata57Masked() *NxmTunMetadata57Masked {
15871 obj := &NxmTunMetadata57Masked{
15872 Oxm: NewOxm(115704),
15873 }
15874 return obj
15875}
15876func (self *NxmTunMetadata57Masked) GetOXMName() string {
15877 return "tun_metadata57_masked"
15878}
15879
15880func (self *NxmTunMetadata57Masked) GetOXMValue() interface{} {
15881 return self.Value
15882}
15883
15884func (self *NxmTunMetadata57Masked) GetOXMValueMask() interface{} {
15885 return self.ValueMask
15886}
15887
15888func (self *NxmTunMetadata57Masked) MarshalJSON() ([]byte, error) {
15889 value, err := jsonValue(self.GetOXMValue())
15890 if err != nil {
15891 return nil, err
15892 }
15893 valueMask, err := jsonValue(self.GetOXMValueMask())
15894 if err != nil {
15895 return nil, err
15896 }
15897 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
15898}
15899
15900type NxmTunMetadata58 struct {
15901 *Oxm
15902 Value []byte
15903}
15904
15905type INxmTunMetadata58 interface {
15906 goloxi.IOxm
15907 GetValue() []byte
15908}
15909
15910func (self *NxmTunMetadata58) GetValue() []byte {
15911 return self.Value
15912}
15913
15914func (self *NxmTunMetadata58) SetValue(v []byte) {
15915 self.Value = v
15916}
15917
15918func (self *NxmTunMetadata58) Serialize(encoder *goloxi.Encoder) error {
15919 if err := self.Oxm.Serialize(encoder); err != nil {
15920 return err
15921 }
15922
15923 encoder.Write(self.Value)
15924
15925 return nil
15926}
15927
15928func DecodeNxmTunMetadata58(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata58, error) {
15929 _nxmtunmetadata58 := &NxmTunMetadata58{Oxm: parent}
15930 _nxmtunmetadata58.Value = decoder.Read(int(_nxmtunmetadata58.TypeLen & 0xFF))
15931 return _nxmtunmetadata58, nil
15932}
15933
15934func NewNxmTunMetadata58() *NxmTunMetadata58 {
15935 obj := &NxmTunMetadata58{
15936 Oxm: NewOxm(115836),
15937 }
15938 return obj
15939}
15940func (self *NxmTunMetadata58) GetOXMName() string {
15941 return "tun_metadata58"
15942}
15943
15944func (self *NxmTunMetadata58) GetOXMValue() interface{} {
15945 return self.Value
15946}
15947
15948func (self *NxmTunMetadata58) MarshalJSON() ([]byte, error) {
15949 value, err := jsonValue(self.GetOXMValue())
15950 if err != nil {
15951 return nil, err
15952 }
15953 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
15954}
15955
15956type NxmTunMetadata58Masked struct {
15957 *Oxm
15958 Value []byte
15959 ValueMask []byte
15960}
15961
15962type INxmTunMetadata58Masked interface {
15963 goloxi.IOxm
15964 GetValue() []byte
15965 GetValueMask() []byte
15966}
15967
15968func (self *NxmTunMetadata58Masked) GetValue() []byte {
15969 return self.Value
15970}
15971
15972func (self *NxmTunMetadata58Masked) SetValue(v []byte) {
15973 self.Value = v
15974}
15975
15976func (self *NxmTunMetadata58Masked) GetValueMask() []byte {
15977 return self.ValueMask
15978}
15979
15980func (self *NxmTunMetadata58Masked) SetValueMask(v []byte) {
15981 self.ValueMask = v
15982}
15983
15984func (self *NxmTunMetadata58Masked) Serialize(encoder *goloxi.Encoder) error {
15985 if err := self.Oxm.Serialize(encoder); err != nil {
15986 return err
15987 }
15988
15989 encoder.Write(self.Value)
15990 encoder.Write(self.ValueMask)
15991
15992 return nil
15993}
15994
15995func DecodeNxmTunMetadata58Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata58Masked, error) {
15996 _nxmtunmetadata58masked := &NxmTunMetadata58Masked{Oxm: parent}
15997 _nxmtunmetadata58masked.Value = decoder.Read(int(_nxmtunmetadata58masked.TypeLen & 0xFF))
15998 _nxmtunmetadata58masked.ValueMask = decoder.Read(int(_nxmtunmetadata58masked.TypeLen & 0xFF))
15999 return _nxmtunmetadata58masked, nil
16000}
16001
16002func NewNxmTunMetadata58Masked() *NxmTunMetadata58Masked {
16003 obj := &NxmTunMetadata58Masked{
16004 Oxm: NewOxm(116216),
16005 }
16006 return obj
16007}
16008func (self *NxmTunMetadata58Masked) GetOXMName() string {
16009 return "tun_metadata58_masked"
16010}
16011
16012func (self *NxmTunMetadata58Masked) GetOXMValue() interface{} {
16013 return self.Value
16014}
16015
16016func (self *NxmTunMetadata58Masked) GetOXMValueMask() interface{} {
16017 return self.ValueMask
16018}
16019
16020func (self *NxmTunMetadata58Masked) MarshalJSON() ([]byte, error) {
16021 value, err := jsonValue(self.GetOXMValue())
16022 if err != nil {
16023 return nil, err
16024 }
16025 valueMask, err := jsonValue(self.GetOXMValueMask())
16026 if err != nil {
16027 return nil, err
16028 }
16029 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
16030}
16031
16032type NxmTunMetadata59 struct {
16033 *Oxm
16034 Value []byte
16035}
16036
16037type INxmTunMetadata59 interface {
16038 goloxi.IOxm
16039 GetValue() []byte
16040}
16041
16042func (self *NxmTunMetadata59) GetValue() []byte {
16043 return self.Value
16044}
16045
16046func (self *NxmTunMetadata59) SetValue(v []byte) {
16047 self.Value = v
16048}
16049
16050func (self *NxmTunMetadata59) Serialize(encoder *goloxi.Encoder) error {
16051 if err := self.Oxm.Serialize(encoder); err != nil {
16052 return err
16053 }
16054
16055 encoder.Write(self.Value)
16056
16057 return nil
16058}
16059
16060func DecodeNxmTunMetadata59(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata59, error) {
16061 _nxmtunmetadata59 := &NxmTunMetadata59{Oxm: parent}
16062 _nxmtunmetadata59.Value = decoder.Read(int(_nxmtunmetadata59.TypeLen & 0xFF))
16063 return _nxmtunmetadata59, nil
16064}
16065
16066func NewNxmTunMetadata59() *NxmTunMetadata59 {
16067 obj := &NxmTunMetadata59{
16068 Oxm: NewOxm(116348),
16069 }
16070 return obj
16071}
16072func (self *NxmTunMetadata59) GetOXMName() string {
16073 return "tun_metadata59"
16074}
16075
16076func (self *NxmTunMetadata59) GetOXMValue() interface{} {
16077 return self.Value
16078}
16079
16080func (self *NxmTunMetadata59) MarshalJSON() ([]byte, error) {
16081 value, err := jsonValue(self.GetOXMValue())
16082 if err != nil {
16083 return nil, err
16084 }
16085 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
16086}
16087
16088type NxmTunMetadata59Masked struct {
16089 *Oxm
16090 Value []byte
16091 ValueMask []byte
16092}
16093
16094type INxmTunMetadata59Masked interface {
16095 goloxi.IOxm
16096 GetValue() []byte
16097 GetValueMask() []byte
16098}
16099
16100func (self *NxmTunMetadata59Masked) GetValue() []byte {
16101 return self.Value
16102}
16103
16104func (self *NxmTunMetadata59Masked) SetValue(v []byte) {
16105 self.Value = v
16106}
16107
16108func (self *NxmTunMetadata59Masked) GetValueMask() []byte {
16109 return self.ValueMask
16110}
16111
16112func (self *NxmTunMetadata59Masked) SetValueMask(v []byte) {
16113 self.ValueMask = v
16114}
16115
16116func (self *NxmTunMetadata59Masked) Serialize(encoder *goloxi.Encoder) error {
16117 if err := self.Oxm.Serialize(encoder); err != nil {
16118 return err
16119 }
16120
16121 encoder.Write(self.Value)
16122 encoder.Write(self.ValueMask)
16123
16124 return nil
16125}
16126
16127func DecodeNxmTunMetadata59Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata59Masked, error) {
16128 _nxmtunmetadata59masked := &NxmTunMetadata59Masked{Oxm: parent}
16129 _nxmtunmetadata59masked.Value = decoder.Read(int(_nxmtunmetadata59masked.TypeLen & 0xFF))
16130 _nxmtunmetadata59masked.ValueMask = decoder.Read(int(_nxmtunmetadata59masked.TypeLen & 0xFF))
16131 return _nxmtunmetadata59masked, nil
16132}
16133
16134func NewNxmTunMetadata59Masked() *NxmTunMetadata59Masked {
16135 obj := &NxmTunMetadata59Masked{
16136 Oxm: NewOxm(116728),
16137 }
16138 return obj
16139}
16140func (self *NxmTunMetadata59Masked) GetOXMName() string {
16141 return "tun_metadata59_masked"
16142}
16143
16144func (self *NxmTunMetadata59Masked) GetOXMValue() interface{} {
16145 return self.Value
16146}
16147
16148func (self *NxmTunMetadata59Masked) GetOXMValueMask() interface{} {
16149 return self.ValueMask
16150}
16151
16152func (self *NxmTunMetadata59Masked) MarshalJSON() ([]byte, error) {
16153 value, err := jsonValue(self.GetOXMValue())
16154 if err != nil {
16155 return nil, err
16156 }
16157 valueMask, err := jsonValue(self.GetOXMValueMask())
16158 if err != nil {
16159 return nil, err
16160 }
16161 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
16162}
16163
16164type NxmTunMetadata5Masked struct {
16165 *Oxm
16166 Value []byte
16167 ValueMask []byte
16168}
16169
16170type INxmTunMetadata5Masked interface {
16171 goloxi.IOxm
16172 GetValue() []byte
16173 GetValueMask() []byte
16174}
16175
16176func (self *NxmTunMetadata5Masked) GetValue() []byte {
16177 return self.Value
16178}
16179
16180func (self *NxmTunMetadata5Masked) SetValue(v []byte) {
16181 self.Value = v
16182}
16183
16184func (self *NxmTunMetadata5Masked) GetValueMask() []byte {
16185 return self.ValueMask
16186}
16187
16188func (self *NxmTunMetadata5Masked) SetValueMask(v []byte) {
16189 self.ValueMask = v
16190}
16191
16192func (self *NxmTunMetadata5Masked) Serialize(encoder *goloxi.Encoder) error {
16193 if err := self.Oxm.Serialize(encoder); err != nil {
16194 return err
16195 }
16196
16197 encoder.Write(self.Value)
16198 encoder.Write(self.ValueMask)
16199
16200 return nil
16201}
16202
16203func DecodeNxmTunMetadata5Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata5Masked, error) {
16204 _nxmtunmetadata5masked := &NxmTunMetadata5Masked{Oxm: parent}
16205 _nxmtunmetadata5masked.Value = decoder.Read(int(_nxmtunmetadata5masked.TypeLen & 0xFF))
16206 _nxmtunmetadata5masked.ValueMask = decoder.Read(int(_nxmtunmetadata5masked.TypeLen & 0xFF))
16207 return _nxmtunmetadata5masked, nil
16208}
16209
16210func NewNxmTunMetadata5Masked() *NxmTunMetadata5Masked {
16211 obj := &NxmTunMetadata5Masked{
16212 Oxm: NewOxm(89080),
16213 }
16214 return obj
16215}
16216func (self *NxmTunMetadata5Masked) GetOXMName() string {
16217 return "tun_metadata5_masked"
16218}
16219
16220func (self *NxmTunMetadata5Masked) GetOXMValue() interface{} {
16221 return self.Value
16222}
16223
16224func (self *NxmTunMetadata5Masked) GetOXMValueMask() interface{} {
16225 return self.ValueMask
16226}
16227
16228func (self *NxmTunMetadata5Masked) MarshalJSON() ([]byte, error) {
16229 value, err := jsonValue(self.GetOXMValue())
16230 if err != nil {
16231 return nil, err
16232 }
16233 valueMask, err := jsonValue(self.GetOXMValueMask())
16234 if err != nil {
16235 return nil, err
16236 }
16237 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
16238}
16239
16240type NxmTunMetadata6 struct {
16241 *Oxm
16242 Value []byte
16243}
16244
16245type INxmTunMetadata6 interface {
16246 goloxi.IOxm
16247 GetValue() []byte
16248}
16249
16250func (self *NxmTunMetadata6) GetValue() []byte {
16251 return self.Value
16252}
16253
16254func (self *NxmTunMetadata6) SetValue(v []byte) {
16255 self.Value = v
16256}
16257
16258func (self *NxmTunMetadata6) Serialize(encoder *goloxi.Encoder) error {
16259 if err := self.Oxm.Serialize(encoder); err != nil {
16260 return err
16261 }
16262
16263 encoder.Write(self.Value)
16264
16265 return nil
16266}
16267
16268func DecodeNxmTunMetadata6(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata6, error) {
16269 _nxmtunmetadata6 := &NxmTunMetadata6{Oxm: parent}
16270 _nxmtunmetadata6.Value = decoder.Read(int(_nxmtunmetadata6.TypeLen & 0xFF))
16271 return _nxmtunmetadata6, nil
16272}
16273
16274func NewNxmTunMetadata6() *NxmTunMetadata6 {
16275 obj := &NxmTunMetadata6{
16276 Oxm: NewOxm(89212),
16277 }
16278 return obj
16279}
16280func (self *NxmTunMetadata6) GetOXMName() string {
16281 return "tun_metadata6"
16282}
16283
16284func (self *NxmTunMetadata6) GetOXMValue() interface{} {
16285 return self.Value
16286}
16287
16288func (self *NxmTunMetadata6) MarshalJSON() ([]byte, error) {
16289 value, err := jsonValue(self.GetOXMValue())
16290 if err != nil {
16291 return nil, err
16292 }
16293 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
16294}
16295
16296type NxmTunMetadata60 struct {
16297 *Oxm
16298 Value []byte
16299}
16300
16301type INxmTunMetadata60 interface {
16302 goloxi.IOxm
16303 GetValue() []byte
16304}
16305
16306func (self *NxmTunMetadata60) GetValue() []byte {
16307 return self.Value
16308}
16309
16310func (self *NxmTunMetadata60) SetValue(v []byte) {
16311 self.Value = v
16312}
16313
16314func (self *NxmTunMetadata60) Serialize(encoder *goloxi.Encoder) error {
16315 if err := self.Oxm.Serialize(encoder); err != nil {
16316 return err
16317 }
16318
16319 encoder.Write(self.Value)
16320
16321 return nil
16322}
16323
16324func DecodeNxmTunMetadata60(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata60, error) {
16325 _nxmtunmetadata60 := &NxmTunMetadata60{Oxm: parent}
16326 _nxmtunmetadata60.Value = decoder.Read(int(_nxmtunmetadata60.TypeLen & 0xFF))
16327 return _nxmtunmetadata60, nil
16328}
16329
16330func NewNxmTunMetadata60() *NxmTunMetadata60 {
16331 obj := &NxmTunMetadata60{
16332 Oxm: NewOxm(116860),
16333 }
16334 return obj
16335}
16336func (self *NxmTunMetadata60) GetOXMName() string {
16337 return "tun_metadata60"
16338}
16339
16340func (self *NxmTunMetadata60) GetOXMValue() interface{} {
16341 return self.Value
16342}
16343
16344func (self *NxmTunMetadata60) MarshalJSON() ([]byte, error) {
16345 value, err := jsonValue(self.GetOXMValue())
16346 if err != nil {
16347 return nil, err
16348 }
16349 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
16350}
16351
16352type NxmTunMetadata60Masked struct {
16353 *Oxm
16354 Value []byte
16355 ValueMask []byte
16356}
16357
16358type INxmTunMetadata60Masked interface {
16359 goloxi.IOxm
16360 GetValue() []byte
16361 GetValueMask() []byte
16362}
16363
16364func (self *NxmTunMetadata60Masked) GetValue() []byte {
16365 return self.Value
16366}
16367
16368func (self *NxmTunMetadata60Masked) SetValue(v []byte) {
16369 self.Value = v
16370}
16371
16372func (self *NxmTunMetadata60Masked) GetValueMask() []byte {
16373 return self.ValueMask
16374}
16375
16376func (self *NxmTunMetadata60Masked) SetValueMask(v []byte) {
16377 self.ValueMask = v
16378}
16379
16380func (self *NxmTunMetadata60Masked) Serialize(encoder *goloxi.Encoder) error {
16381 if err := self.Oxm.Serialize(encoder); err != nil {
16382 return err
16383 }
16384
16385 encoder.Write(self.Value)
16386 encoder.Write(self.ValueMask)
16387
16388 return nil
16389}
16390
16391func DecodeNxmTunMetadata60Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata60Masked, error) {
16392 _nxmtunmetadata60masked := &NxmTunMetadata60Masked{Oxm: parent}
16393 _nxmtunmetadata60masked.Value = decoder.Read(int(_nxmtunmetadata60masked.TypeLen & 0xFF))
16394 _nxmtunmetadata60masked.ValueMask = decoder.Read(int(_nxmtunmetadata60masked.TypeLen & 0xFF))
16395 return _nxmtunmetadata60masked, nil
16396}
16397
16398func NewNxmTunMetadata60Masked() *NxmTunMetadata60Masked {
16399 obj := &NxmTunMetadata60Masked{
16400 Oxm: NewOxm(117240),
16401 }
16402 return obj
16403}
16404func (self *NxmTunMetadata60Masked) GetOXMName() string {
16405 return "tun_metadata60_masked"
16406}
16407
16408func (self *NxmTunMetadata60Masked) GetOXMValue() interface{} {
16409 return self.Value
16410}
16411
16412func (self *NxmTunMetadata60Masked) GetOXMValueMask() interface{} {
16413 return self.ValueMask
16414}
16415
16416func (self *NxmTunMetadata60Masked) MarshalJSON() ([]byte, error) {
16417 value, err := jsonValue(self.GetOXMValue())
16418 if err != nil {
16419 return nil, err
16420 }
16421 valueMask, err := jsonValue(self.GetOXMValueMask())
16422 if err != nil {
16423 return nil, err
16424 }
16425 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
16426}
16427
16428type NxmTunMetadata61 struct {
16429 *Oxm
16430 Value []byte
16431}
16432
16433type INxmTunMetadata61 interface {
16434 goloxi.IOxm
16435 GetValue() []byte
16436}
16437
16438func (self *NxmTunMetadata61) GetValue() []byte {
16439 return self.Value
16440}
16441
16442func (self *NxmTunMetadata61) SetValue(v []byte) {
16443 self.Value = v
16444}
16445
16446func (self *NxmTunMetadata61) Serialize(encoder *goloxi.Encoder) error {
16447 if err := self.Oxm.Serialize(encoder); err != nil {
16448 return err
16449 }
16450
16451 encoder.Write(self.Value)
16452
16453 return nil
16454}
16455
16456func DecodeNxmTunMetadata61(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata61, error) {
16457 _nxmtunmetadata61 := &NxmTunMetadata61{Oxm: parent}
16458 _nxmtunmetadata61.Value = decoder.Read(int(_nxmtunmetadata61.TypeLen & 0xFF))
16459 return _nxmtunmetadata61, nil
16460}
16461
16462func NewNxmTunMetadata61() *NxmTunMetadata61 {
16463 obj := &NxmTunMetadata61{
16464 Oxm: NewOxm(117372),
16465 }
16466 return obj
16467}
16468func (self *NxmTunMetadata61) GetOXMName() string {
16469 return "tun_metadata61"
16470}
16471
16472func (self *NxmTunMetadata61) GetOXMValue() interface{} {
16473 return self.Value
16474}
16475
16476func (self *NxmTunMetadata61) MarshalJSON() ([]byte, error) {
16477 value, err := jsonValue(self.GetOXMValue())
16478 if err != nil {
16479 return nil, err
16480 }
16481 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
16482}
16483
16484type NxmTunMetadata61Masked struct {
16485 *Oxm
16486 Value []byte
16487 ValueMask []byte
16488}
16489
16490type INxmTunMetadata61Masked interface {
16491 goloxi.IOxm
16492 GetValue() []byte
16493 GetValueMask() []byte
16494}
16495
16496func (self *NxmTunMetadata61Masked) GetValue() []byte {
16497 return self.Value
16498}
16499
16500func (self *NxmTunMetadata61Masked) SetValue(v []byte) {
16501 self.Value = v
16502}
16503
16504func (self *NxmTunMetadata61Masked) GetValueMask() []byte {
16505 return self.ValueMask
16506}
16507
16508func (self *NxmTunMetadata61Masked) SetValueMask(v []byte) {
16509 self.ValueMask = v
16510}
16511
16512func (self *NxmTunMetadata61Masked) Serialize(encoder *goloxi.Encoder) error {
16513 if err := self.Oxm.Serialize(encoder); err != nil {
16514 return err
16515 }
16516
16517 encoder.Write(self.Value)
16518 encoder.Write(self.ValueMask)
16519
16520 return nil
16521}
16522
16523func DecodeNxmTunMetadata61Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata61Masked, error) {
16524 _nxmtunmetadata61masked := &NxmTunMetadata61Masked{Oxm: parent}
16525 _nxmtunmetadata61masked.Value = decoder.Read(int(_nxmtunmetadata61masked.TypeLen & 0xFF))
16526 _nxmtunmetadata61masked.ValueMask = decoder.Read(int(_nxmtunmetadata61masked.TypeLen & 0xFF))
16527 return _nxmtunmetadata61masked, nil
16528}
16529
16530func NewNxmTunMetadata61Masked() *NxmTunMetadata61Masked {
16531 obj := &NxmTunMetadata61Masked{
16532 Oxm: NewOxm(117752),
16533 }
16534 return obj
16535}
16536func (self *NxmTunMetadata61Masked) GetOXMName() string {
16537 return "tun_metadata61_masked"
16538}
16539
16540func (self *NxmTunMetadata61Masked) GetOXMValue() interface{} {
16541 return self.Value
16542}
16543
16544func (self *NxmTunMetadata61Masked) GetOXMValueMask() interface{} {
16545 return self.ValueMask
16546}
16547
16548func (self *NxmTunMetadata61Masked) MarshalJSON() ([]byte, error) {
16549 value, err := jsonValue(self.GetOXMValue())
16550 if err != nil {
16551 return nil, err
16552 }
16553 valueMask, err := jsonValue(self.GetOXMValueMask())
16554 if err != nil {
16555 return nil, err
16556 }
16557 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
16558}
16559
16560type NxmTunMetadata62 struct {
16561 *Oxm
16562 Value []byte
16563}
16564
16565type INxmTunMetadata62 interface {
16566 goloxi.IOxm
16567 GetValue() []byte
16568}
16569
16570func (self *NxmTunMetadata62) GetValue() []byte {
16571 return self.Value
16572}
16573
16574func (self *NxmTunMetadata62) SetValue(v []byte) {
16575 self.Value = v
16576}
16577
16578func (self *NxmTunMetadata62) Serialize(encoder *goloxi.Encoder) error {
16579 if err := self.Oxm.Serialize(encoder); err != nil {
16580 return err
16581 }
16582
16583 encoder.Write(self.Value)
16584
16585 return nil
16586}
16587
16588func DecodeNxmTunMetadata62(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata62, error) {
16589 _nxmtunmetadata62 := &NxmTunMetadata62{Oxm: parent}
16590 _nxmtunmetadata62.Value = decoder.Read(int(_nxmtunmetadata62.TypeLen & 0xFF))
16591 return _nxmtunmetadata62, nil
16592}
16593
16594func NewNxmTunMetadata62() *NxmTunMetadata62 {
16595 obj := &NxmTunMetadata62{
16596 Oxm: NewOxm(117884),
16597 }
16598 return obj
16599}
16600func (self *NxmTunMetadata62) GetOXMName() string {
16601 return "tun_metadata62"
16602}
16603
16604func (self *NxmTunMetadata62) GetOXMValue() interface{} {
16605 return self.Value
16606}
16607
16608func (self *NxmTunMetadata62) MarshalJSON() ([]byte, error) {
16609 value, err := jsonValue(self.GetOXMValue())
16610 if err != nil {
16611 return nil, err
16612 }
16613 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
16614}
16615
16616type NxmTunMetadata62Masked struct {
16617 *Oxm
16618 Value []byte
16619 ValueMask []byte
16620}
16621
16622type INxmTunMetadata62Masked interface {
16623 goloxi.IOxm
16624 GetValue() []byte
16625 GetValueMask() []byte
16626}
16627
16628func (self *NxmTunMetadata62Masked) GetValue() []byte {
16629 return self.Value
16630}
16631
16632func (self *NxmTunMetadata62Masked) SetValue(v []byte) {
16633 self.Value = v
16634}
16635
16636func (self *NxmTunMetadata62Masked) GetValueMask() []byte {
16637 return self.ValueMask
16638}
16639
16640func (self *NxmTunMetadata62Masked) SetValueMask(v []byte) {
16641 self.ValueMask = v
16642}
16643
16644func (self *NxmTunMetadata62Masked) Serialize(encoder *goloxi.Encoder) error {
16645 if err := self.Oxm.Serialize(encoder); err != nil {
16646 return err
16647 }
16648
16649 encoder.Write(self.Value)
16650 encoder.Write(self.ValueMask)
16651
16652 return nil
16653}
16654
16655func DecodeNxmTunMetadata62Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata62Masked, error) {
16656 _nxmtunmetadata62masked := &NxmTunMetadata62Masked{Oxm: parent}
16657 _nxmtunmetadata62masked.Value = decoder.Read(int(_nxmtunmetadata62masked.TypeLen & 0xFF))
16658 _nxmtunmetadata62masked.ValueMask = decoder.Read(int(_nxmtunmetadata62masked.TypeLen & 0xFF))
16659 return _nxmtunmetadata62masked, nil
16660}
16661
16662func NewNxmTunMetadata62Masked() *NxmTunMetadata62Masked {
16663 obj := &NxmTunMetadata62Masked{
16664 Oxm: NewOxm(118264),
16665 }
16666 return obj
16667}
16668func (self *NxmTunMetadata62Masked) GetOXMName() string {
16669 return "tun_metadata62_masked"
16670}
16671
16672func (self *NxmTunMetadata62Masked) GetOXMValue() interface{} {
16673 return self.Value
16674}
16675
16676func (self *NxmTunMetadata62Masked) GetOXMValueMask() interface{} {
16677 return self.ValueMask
16678}
16679
16680func (self *NxmTunMetadata62Masked) MarshalJSON() ([]byte, error) {
16681 value, err := jsonValue(self.GetOXMValue())
16682 if err != nil {
16683 return nil, err
16684 }
16685 valueMask, err := jsonValue(self.GetOXMValueMask())
16686 if err != nil {
16687 return nil, err
16688 }
16689 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
16690}
16691
16692type NxmTunMetadata63 struct {
16693 *Oxm
16694 Value []byte
16695}
16696
16697type INxmTunMetadata63 interface {
16698 goloxi.IOxm
16699 GetValue() []byte
16700}
16701
16702func (self *NxmTunMetadata63) GetValue() []byte {
16703 return self.Value
16704}
16705
16706func (self *NxmTunMetadata63) SetValue(v []byte) {
16707 self.Value = v
16708}
16709
16710func (self *NxmTunMetadata63) Serialize(encoder *goloxi.Encoder) error {
16711 if err := self.Oxm.Serialize(encoder); err != nil {
16712 return err
16713 }
16714
16715 encoder.Write(self.Value)
16716
16717 return nil
16718}
16719
16720func DecodeNxmTunMetadata63(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata63, error) {
16721 _nxmtunmetadata63 := &NxmTunMetadata63{Oxm: parent}
16722 _nxmtunmetadata63.Value = decoder.Read(int(_nxmtunmetadata63.TypeLen & 0xFF))
16723 return _nxmtunmetadata63, nil
16724}
16725
16726func NewNxmTunMetadata63() *NxmTunMetadata63 {
16727 obj := &NxmTunMetadata63{
16728 Oxm: NewOxm(118396),
16729 }
16730 return obj
16731}
16732func (self *NxmTunMetadata63) GetOXMName() string {
16733 return "tun_metadata63"
16734}
16735
16736func (self *NxmTunMetadata63) GetOXMValue() interface{} {
16737 return self.Value
16738}
16739
16740func (self *NxmTunMetadata63) MarshalJSON() ([]byte, error) {
16741 value, err := jsonValue(self.GetOXMValue())
16742 if err != nil {
16743 return nil, err
16744 }
16745 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
16746}
16747
16748type NxmTunMetadata63Masked struct {
16749 *Oxm
16750 Value []byte
16751 ValueMask []byte
16752}
16753
16754type INxmTunMetadata63Masked interface {
16755 goloxi.IOxm
16756 GetValue() []byte
16757 GetValueMask() []byte
16758}
16759
16760func (self *NxmTunMetadata63Masked) GetValue() []byte {
16761 return self.Value
16762}
16763
16764func (self *NxmTunMetadata63Masked) SetValue(v []byte) {
16765 self.Value = v
16766}
16767
16768func (self *NxmTunMetadata63Masked) GetValueMask() []byte {
16769 return self.ValueMask
16770}
16771
16772func (self *NxmTunMetadata63Masked) SetValueMask(v []byte) {
16773 self.ValueMask = v
16774}
16775
16776func (self *NxmTunMetadata63Masked) Serialize(encoder *goloxi.Encoder) error {
16777 if err := self.Oxm.Serialize(encoder); err != nil {
16778 return err
16779 }
16780
16781 encoder.Write(self.Value)
16782 encoder.Write(self.ValueMask)
16783
16784 return nil
16785}
16786
16787func DecodeNxmTunMetadata63Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata63Masked, error) {
16788 _nxmtunmetadata63masked := &NxmTunMetadata63Masked{Oxm: parent}
16789 _nxmtunmetadata63masked.Value = decoder.Read(int(_nxmtunmetadata63masked.TypeLen & 0xFF))
16790 _nxmtunmetadata63masked.ValueMask = decoder.Read(int(_nxmtunmetadata63masked.TypeLen & 0xFF))
16791 return _nxmtunmetadata63masked, nil
16792}
16793
16794func NewNxmTunMetadata63Masked() *NxmTunMetadata63Masked {
16795 obj := &NxmTunMetadata63Masked{
16796 Oxm: NewOxm(118776),
16797 }
16798 return obj
16799}
16800func (self *NxmTunMetadata63Masked) GetOXMName() string {
16801 return "tun_metadata63_masked"
16802}
16803
16804func (self *NxmTunMetadata63Masked) GetOXMValue() interface{} {
16805 return self.Value
16806}
16807
16808func (self *NxmTunMetadata63Masked) GetOXMValueMask() interface{} {
16809 return self.ValueMask
16810}
16811
16812func (self *NxmTunMetadata63Masked) MarshalJSON() ([]byte, error) {
16813 value, err := jsonValue(self.GetOXMValue())
16814 if err != nil {
16815 return nil, err
16816 }
16817 valueMask, err := jsonValue(self.GetOXMValueMask())
16818 if err != nil {
16819 return nil, err
16820 }
16821 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
16822}
16823
16824type NxmTunMetadata6Masked struct {
16825 *Oxm
16826 Value []byte
16827 ValueMask []byte
16828}
16829
16830type INxmTunMetadata6Masked interface {
16831 goloxi.IOxm
16832 GetValue() []byte
16833 GetValueMask() []byte
16834}
16835
16836func (self *NxmTunMetadata6Masked) GetValue() []byte {
16837 return self.Value
16838}
16839
16840func (self *NxmTunMetadata6Masked) SetValue(v []byte) {
16841 self.Value = v
16842}
16843
16844func (self *NxmTunMetadata6Masked) GetValueMask() []byte {
16845 return self.ValueMask
16846}
16847
16848func (self *NxmTunMetadata6Masked) SetValueMask(v []byte) {
16849 self.ValueMask = v
16850}
16851
16852func (self *NxmTunMetadata6Masked) Serialize(encoder *goloxi.Encoder) error {
16853 if err := self.Oxm.Serialize(encoder); err != nil {
16854 return err
16855 }
16856
16857 encoder.Write(self.Value)
16858 encoder.Write(self.ValueMask)
16859
16860 return nil
16861}
16862
16863func DecodeNxmTunMetadata6Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata6Masked, error) {
16864 _nxmtunmetadata6masked := &NxmTunMetadata6Masked{Oxm: parent}
16865 _nxmtunmetadata6masked.Value = decoder.Read(int(_nxmtunmetadata6masked.TypeLen & 0xFF))
16866 _nxmtunmetadata6masked.ValueMask = decoder.Read(int(_nxmtunmetadata6masked.TypeLen & 0xFF))
16867 return _nxmtunmetadata6masked, nil
16868}
16869
16870func NewNxmTunMetadata6Masked() *NxmTunMetadata6Masked {
16871 obj := &NxmTunMetadata6Masked{
16872 Oxm: NewOxm(89592),
16873 }
16874 return obj
16875}
16876func (self *NxmTunMetadata6Masked) GetOXMName() string {
16877 return "tun_metadata6_masked"
16878}
16879
16880func (self *NxmTunMetadata6Masked) GetOXMValue() interface{} {
16881 return self.Value
16882}
16883
16884func (self *NxmTunMetadata6Masked) GetOXMValueMask() interface{} {
16885 return self.ValueMask
16886}
16887
16888func (self *NxmTunMetadata6Masked) MarshalJSON() ([]byte, error) {
16889 value, err := jsonValue(self.GetOXMValue())
16890 if err != nil {
16891 return nil, err
16892 }
16893 valueMask, err := jsonValue(self.GetOXMValueMask())
16894 if err != nil {
16895 return nil, err
16896 }
16897 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
16898}
16899
16900type NxmTunMetadata7 struct {
16901 *Oxm
16902 Value []byte
16903}
16904
16905type INxmTunMetadata7 interface {
16906 goloxi.IOxm
16907 GetValue() []byte
16908}
16909
16910func (self *NxmTunMetadata7) GetValue() []byte {
16911 return self.Value
16912}
16913
16914func (self *NxmTunMetadata7) SetValue(v []byte) {
16915 self.Value = v
16916}
16917
16918func (self *NxmTunMetadata7) Serialize(encoder *goloxi.Encoder) error {
16919 if err := self.Oxm.Serialize(encoder); err != nil {
16920 return err
16921 }
16922
16923 encoder.Write(self.Value)
16924
16925 return nil
16926}
16927
16928func DecodeNxmTunMetadata7(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata7, error) {
16929 _nxmtunmetadata7 := &NxmTunMetadata7{Oxm: parent}
16930 _nxmtunmetadata7.Value = decoder.Read(int(_nxmtunmetadata7.TypeLen & 0xFF))
16931 return _nxmtunmetadata7, nil
16932}
16933
16934func NewNxmTunMetadata7() *NxmTunMetadata7 {
16935 obj := &NxmTunMetadata7{
16936 Oxm: NewOxm(89724),
16937 }
16938 return obj
16939}
16940func (self *NxmTunMetadata7) GetOXMName() string {
16941 return "tun_metadata7"
16942}
16943
16944func (self *NxmTunMetadata7) GetOXMValue() interface{} {
16945 return self.Value
16946}
16947
16948func (self *NxmTunMetadata7) MarshalJSON() ([]byte, error) {
16949 value, err := jsonValue(self.GetOXMValue())
16950 if err != nil {
16951 return nil, err
16952 }
16953 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
16954}
16955
16956type NxmTunMetadata7Masked struct {
16957 *Oxm
16958 Value []byte
16959 ValueMask []byte
16960}
16961
16962type INxmTunMetadata7Masked interface {
16963 goloxi.IOxm
16964 GetValue() []byte
16965 GetValueMask() []byte
16966}
16967
16968func (self *NxmTunMetadata7Masked) GetValue() []byte {
16969 return self.Value
16970}
16971
16972func (self *NxmTunMetadata7Masked) SetValue(v []byte) {
16973 self.Value = v
16974}
16975
16976func (self *NxmTunMetadata7Masked) GetValueMask() []byte {
16977 return self.ValueMask
16978}
16979
16980func (self *NxmTunMetadata7Masked) SetValueMask(v []byte) {
16981 self.ValueMask = v
16982}
16983
16984func (self *NxmTunMetadata7Masked) Serialize(encoder *goloxi.Encoder) error {
16985 if err := self.Oxm.Serialize(encoder); err != nil {
16986 return err
16987 }
16988
16989 encoder.Write(self.Value)
16990 encoder.Write(self.ValueMask)
16991
16992 return nil
16993}
16994
16995func DecodeNxmTunMetadata7Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata7Masked, error) {
16996 _nxmtunmetadata7masked := &NxmTunMetadata7Masked{Oxm: parent}
16997 _nxmtunmetadata7masked.Value = decoder.Read(int(_nxmtunmetadata7masked.TypeLen & 0xFF))
16998 _nxmtunmetadata7masked.ValueMask = decoder.Read(int(_nxmtunmetadata7masked.TypeLen & 0xFF))
16999 return _nxmtunmetadata7masked, nil
17000}
17001
17002func NewNxmTunMetadata7Masked() *NxmTunMetadata7Masked {
17003 obj := &NxmTunMetadata7Masked{
17004 Oxm: NewOxm(90104),
17005 }
17006 return obj
17007}
17008func (self *NxmTunMetadata7Masked) GetOXMName() string {
17009 return "tun_metadata7_masked"
17010}
17011
17012func (self *NxmTunMetadata7Masked) GetOXMValue() interface{} {
17013 return self.Value
17014}
17015
17016func (self *NxmTunMetadata7Masked) GetOXMValueMask() interface{} {
17017 return self.ValueMask
17018}
17019
17020func (self *NxmTunMetadata7Masked) MarshalJSON() ([]byte, error) {
17021 value, err := jsonValue(self.GetOXMValue())
17022 if err != nil {
17023 return nil, err
17024 }
17025 valueMask, err := jsonValue(self.GetOXMValueMask())
17026 if err != nil {
17027 return nil, err
17028 }
17029 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
17030}
17031
17032type NxmTunMetadata8 struct {
17033 *Oxm
17034 Value []byte
17035}
17036
17037type INxmTunMetadata8 interface {
17038 goloxi.IOxm
17039 GetValue() []byte
17040}
17041
17042func (self *NxmTunMetadata8) GetValue() []byte {
17043 return self.Value
17044}
17045
17046func (self *NxmTunMetadata8) SetValue(v []byte) {
17047 self.Value = v
17048}
17049
17050func (self *NxmTunMetadata8) Serialize(encoder *goloxi.Encoder) error {
17051 if err := self.Oxm.Serialize(encoder); err != nil {
17052 return err
17053 }
17054
17055 encoder.Write(self.Value)
17056
17057 return nil
17058}
17059
17060func DecodeNxmTunMetadata8(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata8, error) {
17061 _nxmtunmetadata8 := &NxmTunMetadata8{Oxm: parent}
17062 _nxmtunmetadata8.Value = decoder.Read(int(_nxmtunmetadata8.TypeLen & 0xFF))
17063 return _nxmtunmetadata8, nil
17064}
17065
17066func NewNxmTunMetadata8() *NxmTunMetadata8 {
17067 obj := &NxmTunMetadata8{
17068 Oxm: NewOxm(90236),
17069 }
17070 return obj
17071}
17072func (self *NxmTunMetadata8) GetOXMName() string {
17073 return "tun_metadata8"
17074}
17075
17076func (self *NxmTunMetadata8) GetOXMValue() interface{} {
17077 return self.Value
17078}
17079
17080func (self *NxmTunMetadata8) MarshalJSON() ([]byte, error) {
17081 value, err := jsonValue(self.GetOXMValue())
17082 if err != nil {
17083 return nil, err
17084 }
17085 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
17086}
17087
17088type NxmTunMetadata8Masked struct {
17089 *Oxm
17090 Value []byte
17091 ValueMask []byte
17092}
17093
17094type INxmTunMetadata8Masked interface {
17095 goloxi.IOxm
17096 GetValue() []byte
17097 GetValueMask() []byte
17098}
17099
17100func (self *NxmTunMetadata8Masked) GetValue() []byte {
17101 return self.Value
17102}
17103
17104func (self *NxmTunMetadata8Masked) SetValue(v []byte) {
17105 self.Value = v
17106}
17107
17108func (self *NxmTunMetadata8Masked) GetValueMask() []byte {
17109 return self.ValueMask
17110}
17111
17112func (self *NxmTunMetadata8Masked) SetValueMask(v []byte) {
17113 self.ValueMask = v
17114}
17115
17116func (self *NxmTunMetadata8Masked) Serialize(encoder *goloxi.Encoder) error {
17117 if err := self.Oxm.Serialize(encoder); err != nil {
17118 return err
17119 }
17120
17121 encoder.Write(self.Value)
17122 encoder.Write(self.ValueMask)
17123
17124 return nil
17125}
17126
17127func DecodeNxmTunMetadata8Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata8Masked, error) {
17128 _nxmtunmetadata8masked := &NxmTunMetadata8Masked{Oxm: parent}
17129 _nxmtunmetadata8masked.Value = decoder.Read(int(_nxmtunmetadata8masked.TypeLen & 0xFF))
17130 _nxmtunmetadata8masked.ValueMask = decoder.Read(int(_nxmtunmetadata8masked.TypeLen & 0xFF))
17131 return _nxmtunmetadata8masked, nil
17132}
17133
17134func NewNxmTunMetadata8Masked() *NxmTunMetadata8Masked {
17135 obj := &NxmTunMetadata8Masked{
17136 Oxm: NewOxm(90616),
17137 }
17138 return obj
17139}
17140func (self *NxmTunMetadata8Masked) GetOXMName() string {
17141 return "tun_metadata8_masked"
17142}
17143
17144func (self *NxmTunMetadata8Masked) GetOXMValue() interface{} {
17145 return self.Value
17146}
17147
17148func (self *NxmTunMetadata8Masked) GetOXMValueMask() interface{} {
17149 return self.ValueMask
17150}
17151
17152func (self *NxmTunMetadata8Masked) MarshalJSON() ([]byte, error) {
17153 value, err := jsonValue(self.GetOXMValue())
17154 if err != nil {
17155 return nil, err
17156 }
17157 valueMask, err := jsonValue(self.GetOXMValueMask())
17158 if err != nil {
17159 return nil, err
17160 }
17161 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
17162}
17163
17164type NxmTunMetadata9 struct {
17165 *Oxm
17166 Value []byte
17167}
17168
17169type INxmTunMetadata9 interface {
17170 goloxi.IOxm
17171 GetValue() []byte
17172}
17173
17174func (self *NxmTunMetadata9) GetValue() []byte {
17175 return self.Value
17176}
17177
17178func (self *NxmTunMetadata9) SetValue(v []byte) {
17179 self.Value = v
17180}
17181
17182func (self *NxmTunMetadata9) Serialize(encoder *goloxi.Encoder) error {
17183 if err := self.Oxm.Serialize(encoder); err != nil {
17184 return err
17185 }
17186
17187 encoder.Write(self.Value)
17188
17189 return nil
17190}
17191
17192func DecodeNxmTunMetadata9(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata9, error) {
17193 _nxmtunmetadata9 := &NxmTunMetadata9{Oxm: parent}
17194 _nxmtunmetadata9.Value = decoder.Read(int(_nxmtunmetadata9.TypeLen & 0xFF))
17195 return _nxmtunmetadata9, nil
17196}
17197
17198func NewNxmTunMetadata9() *NxmTunMetadata9 {
17199 obj := &NxmTunMetadata9{
17200 Oxm: NewOxm(90748),
17201 }
17202 return obj
17203}
17204func (self *NxmTunMetadata9) GetOXMName() string {
17205 return "tun_metadata9"
17206}
17207
17208func (self *NxmTunMetadata9) GetOXMValue() interface{} {
17209 return self.Value
17210}
17211
17212func (self *NxmTunMetadata9) MarshalJSON() ([]byte, error) {
17213 value, err := jsonValue(self.GetOXMValue())
17214 if err != nil {
17215 return nil, err
17216 }
17217 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
17218}
17219
17220type NxmTunMetadata9Masked struct {
17221 *Oxm
17222 Value []byte
17223 ValueMask []byte
17224}
17225
17226type INxmTunMetadata9Masked interface {
17227 goloxi.IOxm
17228 GetValue() []byte
17229 GetValueMask() []byte
17230}
17231
17232func (self *NxmTunMetadata9Masked) GetValue() []byte {
17233 return self.Value
17234}
17235
17236func (self *NxmTunMetadata9Masked) SetValue(v []byte) {
17237 self.Value = v
17238}
17239
17240func (self *NxmTunMetadata9Masked) GetValueMask() []byte {
17241 return self.ValueMask
17242}
17243
17244func (self *NxmTunMetadata9Masked) SetValueMask(v []byte) {
17245 self.ValueMask = v
17246}
17247
17248func (self *NxmTunMetadata9Masked) Serialize(encoder *goloxi.Encoder) error {
17249 if err := self.Oxm.Serialize(encoder); err != nil {
17250 return err
17251 }
17252
17253 encoder.Write(self.Value)
17254 encoder.Write(self.ValueMask)
17255
17256 return nil
17257}
17258
17259func DecodeNxmTunMetadata9Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunMetadata9Masked, error) {
17260 _nxmtunmetadata9masked := &NxmTunMetadata9Masked{Oxm: parent}
17261 _nxmtunmetadata9masked.Value = decoder.Read(int(_nxmtunmetadata9masked.TypeLen & 0xFF))
17262 _nxmtunmetadata9masked.ValueMask = decoder.Read(int(_nxmtunmetadata9masked.TypeLen & 0xFF))
17263 return _nxmtunmetadata9masked, nil
17264}
17265
17266func NewNxmTunMetadata9Masked() *NxmTunMetadata9Masked {
17267 obj := &NxmTunMetadata9Masked{
17268 Oxm: NewOxm(91128),
17269 }
17270 return obj
17271}
17272func (self *NxmTunMetadata9Masked) GetOXMName() string {
17273 return "tun_metadata9_masked"
17274}
17275
17276func (self *NxmTunMetadata9Masked) GetOXMValue() interface{} {
17277 return self.Value
17278}
17279
17280func (self *NxmTunMetadata9Masked) GetOXMValueMask() interface{} {
17281 return self.ValueMask
17282}
17283
17284func (self *NxmTunMetadata9Masked) MarshalJSON() ([]byte, error) {
17285 value, err := jsonValue(self.GetOXMValue())
17286 if err != nil {
17287 return nil, err
17288 }
17289 valueMask, err := jsonValue(self.GetOXMValueMask())
17290 if err != nil {
17291 return nil, err
17292 }
17293 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
17294}
17295
17296type NxmTunSrc struct {
17297 *Oxm
17298 Value net.IP
17299}
17300
17301type INxmTunSrc interface {
17302 goloxi.IOxm
17303 GetValue() net.IP
17304}
17305
17306func (self *NxmTunSrc) GetValue() net.IP {
17307 return self.Value
17308}
17309
17310func (self *NxmTunSrc) SetValue(v net.IP) {
17311 self.Value = v
17312}
17313
17314func (self *NxmTunSrc) Serialize(encoder *goloxi.Encoder) error {
17315 if err := self.Oxm.Serialize(encoder); err != nil {
17316 return err
17317 }
17318
17319 encoder.Write(self.Value.To4())
17320
17321 return nil
17322}
17323
17324func DecodeNxmTunSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunSrc, error) {
17325 _nxmtunsrc := &NxmTunSrc{Oxm: parent}
17326 if decoder.Length() < 4 {
17327 return nil, fmt.Errorf("NxmTunSrc packet too short: %d < 4", decoder.Length())
17328 }
17329 _nxmtunsrc.Value = net.IP(decoder.Read(4))
17330 return _nxmtunsrc, nil
17331}
17332
17333func NewNxmTunSrc() *NxmTunSrc {
17334 obj := &NxmTunSrc{
17335 Oxm: NewOxm(81412),
17336 }
17337 return obj
17338}
17339func (self *NxmTunSrc) GetOXMName() string {
17340 return "tun_src"
17341}
17342
17343func (self *NxmTunSrc) GetOXMValue() interface{} {
17344 return self.Value
17345}
17346
17347func (self *NxmTunSrc) MarshalJSON() ([]byte, error) {
17348 value, err := jsonValue(self.GetOXMValue())
17349 if err != nil {
17350 return nil, err
17351 }
17352 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
17353}
17354
17355type NxmTunSrcMasked struct {
17356 *Oxm
17357 Value net.IP
17358 ValueMask net.IP
17359}
17360
17361type INxmTunSrcMasked interface {
17362 goloxi.IOxm
17363 GetValue() net.IP
17364 GetValueMask() net.IP
17365}
17366
17367func (self *NxmTunSrcMasked) GetValue() net.IP {
17368 return self.Value
17369}
17370
17371func (self *NxmTunSrcMasked) SetValue(v net.IP) {
17372 self.Value = v
17373}
17374
17375func (self *NxmTunSrcMasked) GetValueMask() net.IP {
17376 return self.ValueMask
17377}
17378
17379func (self *NxmTunSrcMasked) SetValueMask(v net.IP) {
17380 self.ValueMask = v
17381}
17382
17383func (self *NxmTunSrcMasked) Serialize(encoder *goloxi.Encoder) error {
17384 if err := self.Oxm.Serialize(encoder); err != nil {
17385 return err
17386 }
17387
17388 encoder.Write(self.Value.To4())
17389 encoder.Write(self.ValueMask.To4())
17390
17391 return nil
17392}
17393
17394func DecodeNxmTunSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmTunSrcMasked, error) {
17395 _nxmtunsrcmasked := &NxmTunSrcMasked{Oxm: parent}
17396 if decoder.Length() < 8 {
17397 return nil, fmt.Errorf("NxmTunSrcMasked packet too short: %d < 8", decoder.Length())
17398 }
17399 _nxmtunsrcmasked.Value = net.IP(decoder.Read(4))
17400 _nxmtunsrcmasked.ValueMask = net.IP(decoder.Read(4))
17401 return _nxmtunsrcmasked, nil
17402}
17403
17404func NewNxmTunSrcMasked() *NxmTunSrcMasked {
17405 obj := &NxmTunSrcMasked{
17406 Oxm: NewOxm(81672),
17407 }
17408 return obj
17409}
17410func (self *NxmTunSrcMasked) GetOXMName() string {
17411 return "tun_src_masked"
17412}
17413
17414func (self *NxmTunSrcMasked) GetOXMValue() interface{} {
17415 return self.Value
17416}
17417
17418func (self *NxmTunSrcMasked) GetOXMValueMask() interface{} {
17419 return self.ValueMask
17420}
17421
17422func (self *NxmTunSrcMasked) MarshalJSON() ([]byte, error) {
17423 value, err := jsonValue(self.GetOXMValue())
17424 if err != nil {
17425 return nil, err
17426 }
17427 valueMask, err := jsonValue(self.GetOXMValueMask())
17428 if err != nil {
17429 return nil, err
17430 }
17431 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
17432}
17433
17434type NxmUdpDst struct {
17435 *Oxm
17436 Value uint16
17437}
17438
17439type INxmUdpDst interface {
17440 goloxi.IOxm
17441 GetValue() uint16
17442}
17443
17444func (self *NxmUdpDst) GetValue() uint16 {
17445 return self.Value
17446}
17447
17448func (self *NxmUdpDst) SetValue(v uint16) {
17449 self.Value = v
17450}
17451
17452func (self *NxmUdpDst) Serialize(encoder *goloxi.Encoder) error {
17453 if err := self.Oxm.Serialize(encoder); err != nil {
17454 return err
17455 }
17456
17457 encoder.PutUint16(uint16(self.Value))
17458
17459 return nil
17460}
17461
17462func DecodeNxmUdpDst(parent *Oxm, decoder *goloxi.Decoder) (*NxmUdpDst, error) {
17463 _nxmudpdst := &NxmUdpDst{Oxm: parent}
17464 if decoder.Length() < 2 {
17465 return nil, fmt.Errorf("NxmUdpDst packet too short: %d < 2", decoder.Length())
17466 }
17467 _nxmudpdst.Value = uint16(decoder.ReadUint16())
17468 return _nxmudpdst, nil
17469}
17470
17471func NewNxmUdpDst() *NxmUdpDst {
17472 obj := &NxmUdpDst{
17473 Oxm: NewOxm(6146),
17474 }
17475 return obj
17476}
17477func (self *NxmUdpDst) GetOXMName() string {
17478 return "udp_dst"
17479}
17480
17481func (self *NxmUdpDst) GetOXMValue() interface{} {
17482 return self.Value
17483}
17484
17485func (self *NxmUdpDst) MarshalJSON() ([]byte, error) {
17486 value, err := jsonValue(self.GetOXMValue())
17487 if err != nil {
17488 return nil, err
17489 }
17490 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
17491}
17492
17493type NxmUdpDstMasked struct {
17494 *Oxm
17495 Value uint16
17496 ValueMask uint16
17497}
17498
17499type INxmUdpDstMasked interface {
17500 goloxi.IOxm
17501 GetValue() uint16
17502 GetValueMask() uint16
17503}
17504
17505func (self *NxmUdpDstMasked) GetValue() uint16 {
17506 return self.Value
17507}
17508
17509func (self *NxmUdpDstMasked) SetValue(v uint16) {
17510 self.Value = v
17511}
17512
17513func (self *NxmUdpDstMasked) GetValueMask() uint16 {
17514 return self.ValueMask
17515}
17516
17517func (self *NxmUdpDstMasked) SetValueMask(v uint16) {
17518 self.ValueMask = v
17519}
17520
17521func (self *NxmUdpDstMasked) Serialize(encoder *goloxi.Encoder) error {
17522 if err := self.Oxm.Serialize(encoder); err != nil {
17523 return err
17524 }
17525
17526 encoder.PutUint16(uint16(self.Value))
17527 encoder.PutUint16(uint16(self.ValueMask))
17528
17529 return nil
17530}
17531
17532func DecodeNxmUdpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmUdpDstMasked, error) {
17533 _nxmudpdstmasked := &NxmUdpDstMasked{Oxm: parent}
17534 if decoder.Length() < 4 {
17535 return nil, fmt.Errorf("NxmUdpDstMasked packet too short: %d < 4", decoder.Length())
17536 }
17537 _nxmudpdstmasked.Value = uint16(decoder.ReadUint16())
17538 _nxmudpdstmasked.ValueMask = uint16(decoder.ReadUint16())
17539 return _nxmudpdstmasked, nil
17540}
17541
17542func NewNxmUdpDstMasked() *NxmUdpDstMasked {
17543 obj := &NxmUdpDstMasked{
17544 Oxm: NewOxm(6404),
17545 }
17546 return obj
17547}
17548func (self *NxmUdpDstMasked) GetOXMName() string {
17549 return "udp_dst_masked"
17550}
17551
17552func (self *NxmUdpDstMasked) GetOXMValue() interface{} {
17553 return self.Value
17554}
17555
17556func (self *NxmUdpDstMasked) GetOXMValueMask() interface{} {
17557 return self.ValueMask
17558}
17559
17560func (self *NxmUdpDstMasked) MarshalJSON() ([]byte, error) {
17561 value, err := jsonValue(self.GetOXMValue())
17562 if err != nil {
17563 return nil, err
17564 }
17565 valueMask, err := jsonValue(self.GetOXMValueMask())
17566 if err != nil {
17567 return nil, err
17568 }
17569 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
17570}
17571
17572type NxmUdpSrc struct {
17573 *Oxm
17574 Value uint16
17575}
17576
17577type INxmUdpSrc interface {
17578 goloxi.IOxm
17579 GetValue() uint16
17580}
17581
17582func (self *NxmUdpSrc) GetValue() uint16 {
17583 return self.Value
17584}
17585
17586func (self *NxmUdpSrc) SetValue(v uint16) {
17587 self.Value = v
17588}
17589
17590func (self *NxmUdpSrc) Serialize(encoder *goloxi.Encoder) error {
17591 if err := self.Oxm.Serialize(encoder); err != nil {
17592 return err
17593 }
17594
17595 encoder.PutUint16(uint16(self.Value))
17596
17597 return nil
17598}
17599
17600func DecodeNxmUdpSrc(parent *Oxm, decoder *goloxi.Decoder) (*NxmUdpSrc, error) {
17601 _nxmudpsrc := &NxmUdpSrc{Oxm: parent}
17602 if decoder.Length() < 2 {
17603 return nil, fmt.Errorf("NxmUdpSrc packet too short: %d < 2", decoder.Length())
17604 }
17605 _nxmudpsrc.Value = uint16(decoder.ReadUint16())
17606 return _nxmudpsrc, nil
17607}
17608
17609func NewNxmUdpSrc() *NxmUdpSrc {
17610 obj := &NxmUdpSrc{
17611 Oxm: NewOxm(5634),
17612 }
17613 return obj
17614}
17615func (self *NxmUdpSrc) GetOXMName() string {
17616 return "udp_src"
17617}
17618
17619func (self *NxmUdpSrc) GetOXMValue() interface{} {
17620 return self.Value
17621}
17622
17623func (self *NxmUdpSrc) MarshalJSON() ([]byte, error) {
17624 value, err := jsonValue(self.GetOXMValue())
17625 if err != nil {
17626 return nil, err
17627 }
17628 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
17629}
17630
17631type NxmUdpSrcMasked struct {
17632 *Oxm
17633 Value uint16
17634 ValueMask uint16
17635}
17636
17637type INxmUdpSrcMasked interface {
17638 goloxi.IOxm
17639 GetValue() uint16
17640 GetValueMask() uint16
17641}
17642
17643func (self *NxmUdpSrcMasked) GetValue() uint16 {
17644 return self.Value
17645}
17646
17647func (self *NxmUdpSrcMasked) SetValue(v uint16) {
17648 self.Value = v
17649}
17650
17651func (self *NxmUdpSrcMasked) GetValueMask() uint16 {
17652 return self.ValueMask
17653}
17654
17655func (self *NxmUdpSrcMasked) SetValueMask(v uint16) {
17656 self.ValueMask = v
17657}
17658
17659func (self *NxmUdpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
17660 if err := self.Oxm.Serialize(encoder); err != nil {
17661 return err
17662 }
17663
17664 encoder.PutUint16(uint16(self.Value))
17665 encoder.PutUint16(uint16(self.ValueMask))
17666
17667 return nil
17668}
17669
17670func DecodeNxmUdpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmUdpSrcMasked, error) {
17671 _nxmudpsrcmasked := &NxmUdpSrcMasked{Oxm: parent}
17672 if decoder.Length() < 4 {
17673 return nil, fmt.Errorf("NxmUdpSrcMasked packet too short: %d < 4", decoder.Length())
17674 }
17675 _nxmudpsrcmasked.Value = uint16(decoder.ReadUint16())
17676 _nxmudpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
17677 return _nxmudpsrcmasked, nil
17678}
17679
17680func NewNxmUdpSrcMasked() *NxmUdpSrcMasked {
17681 obj := &NxmUdpSrcMasked{
17682 Oxm: NewOxm(5892),
17683 }
17684 return obj
17685}
17686func (self *NxmUdpSrcMasked) GetOXMName() string {
17687 return "udp_src_masked"
17688}
17689
17690func (self *NxmUdpSrcMasked) GetOXMValue() interface{} {
17691 return self.Value
17692}
17693
17694func (self *NxmUdpSrcMasked) GetOXMValueMask() interface{} {
17695 return self.ValueMask
17696}
17697
17698func (self *NxmUdpSrcMasked) MarshalJSON() ([]byte, error) {
17699 value, err := jsonValue(self.GetOXMValue())
17700 if err != nil {
17701 return nil, err
17702 }
17703 valueMask, err := jsonValue(self.GetOXMValueMask())
17704 if err != nil {
17705 return nil, err
17706 }
17707 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
17708}
17709
17710type NxmVlanTci struct {
17711 *Oxm
17712 Value uint16
17713}
17714
17715type INxmVlanTci interface {
17716 goloxi.IOxm
17717 GetValue() uint16
17718}
17719
17720func (self *NxmVlanTci) GetValue() uint16 {
17721 return self.Value
17722}
17723
17724func (self *NxmVlanTci) SetValue(v uint16) {
17725 self.Value = v
17726}
17727
17728func (self *NxmVlanTci) Serialize(encoder *goloxi.Encoder) error {
17729 if err := self.Oxm.Serialize(encoder); err != nil {
17730 return err
17731 }
17732
17733 encoder.PutUint16(uint16(self.Value))
17734
17735 return nil
17736}
17737
17738func DecodeNxmVlanTci(parent *Oxm, decoder *goloxi.Decoder) (*NxmVlanTci, error) {
17739 _nxmvlantci := &NxmVlanTci{Oxm: parent}
17740 if decoder.Length() < 2 {
17741 return nil, fmt.Errorf("NxmVlanTci packet too short: %d < 2", decoder.Length())
17742 }
17743 _nxmvlantci.Value = uint16(decoder.ReadUint16())
17744 return _nxmvlantci, nil
17745}
17746
17747func NewNxmVlanTci() *NxmVlanTci {
17748 obj := &NxmVlanTci{
17749 Oxm: NewOxm(2050),
17750 }
17751 return obj
17752}
17753func (self *NxmVlanTci) GetOXMName() string {
17754 return "vlan_tci"
17755}
17756
17757func (self *NxmVlanTci) GetOXMValue() interface{} {
17758 return self.Value
17759}
17760
17761func (self *NxmVlanTci) MarshalJSON() ([]byte, error) {
17762 value, err := jsonValue(self.GetOXMValue())
17763 if err != nil {
17764 return nil, err
17765 }
17766 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
17767}
17768
17769type NxmVlanTciMasked struct {
17770 *Oxm
17771 Value uint16
17772 ValueMask uint16
17773}
17774
17775type INxmVlanTciMasked interface {
17776 goloxi.IOxm
17777 GetValue() uint16
17778 GetValueMask() uint16
17779}
17780
17781func (self *NxmVlanTciMasked) GetValue() uint16 {
17782 return self.Value
17783}
17784
17785func (self *NxmVlanTciMasked) SetValue(v uint16) {
17786 self.Value = v
17787}
17788
17789func (self *NxmVlanTciMasked) GetValueMask() uint16 {
17790 return self.ValueMask
17791}
17792
17793func (self *NxmVlanTciMasked) SetValueMask(v uint16) {
17794 self.ValueMask = v
17795}
17796
17797func (self *NxmVlanTciMasked) Serialize(encoder *goloxi.Encoder) error {
17798 if err := self.Oxm.Serialize(encoder); err != nil {
17799 return err
17800 }
17801
17802 encoder.PutUint16(uint16(self.Value))
17803 encoder.PutUint16(uint16(self.ValueMask))
17804
17805 return nil
17806}
17807
17808func DecodeNxmVlanTciMasked(parent *Oxm, decoder *goloxi.Decoder) (*NxmVlanTciMasked, error) {
17809 _nxmvlantcimasked := &NxmVlanTciMasked{Oxm: parent}
17810 if decoder.Length() < 4 {
17811 return nil, fmt.Errorf("NxmVlanTciMasked packet too short: %d < 4", decoder.Length())
17812 }
17813 _nxmvlantcimasked.Value = uint16(decoder.ReadUint16())
17814 _nxmvlantcimasked.ValueMask = uint16(decoder.ReadUint16())
17815 return _nxmvlantcimasked, nil
17816}
17817
17818func NewNxmVlanTciMasked() *NxmVlanTciMasked {
17819 obj := &NxmVlanTciMasked{
17820 Oxm: NewOxm(2308),
17821 }
17822 return obj
17823}
17824func (self *NxmVlanTciMasked) GetOXMName() string {
17825 return "vlan_tci_masked"
17826}
17827
17828func (self *NxmVlanTciMasked) GetOXMValue() interface{} {
17829 return self.Value
17830}
17831
17832func (self *NxmVlanTciMasked) GetOXMValueMask() interface{} {
17833 return self.ValueMask
17834}
17835
17836func (self *NxmVlanTciMasked) MarshalJSON() ([]byte, error) {
17837 value, err := jsonValue(self.GetOXMValue())
17838 if err != nil {
17839 return nil, err
17840 }
17841 valueMask, err := jsonValue(self.GetOXMValueMask())
17842 if err != nil {
17843 return nil, err
17844 }
17845 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
17846}
17847
17848type NxmXxreg0 struct {
17849 *Oxm
17850 Value uint128
17851}
17852
17853type INxmXxreg0 interface {
17854 goloxi.IOxm
17855 GetValue() uint128
17856}
17857
17858func (self *NxmXxreg0) GetValue() uint128 {
17859 return self.Value
17860}
17861
17862func (self *NxmXxreg0) SetValue(v uint128) {
17863 self.Value = v
17864}
17865
17866func (self *NxmXxreg0) Serialize(encoder *goloxi.Encoder) error {
17867 if err := self.Oxm.Serialize(encoder); err != nil {
17868 return err
17869 }
17870
17871 encoder.PutUint128(uint128(self.Value))
17872
17873 return nil
17874}
17875
17876func DecodeNxmXxreg0(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg0, error) {
17877 _nxmxxreg0 := &NxmXxreg0{Oxm: parent}
17878 if decoder.Length() < 16 {
17879 return nil, fmt.Errorf("NxmXxreg0 packet too short: %d < 16", decoder.Length())
17880 }
17881 _nxmxxreg0.Value = uint128(decoder.ReadUint128())
17882 return _nxmxxreg0, nil
17883}
17884
17885func NewNxmXxreg0() *NxmXxreg0 {
17886 obj := &NxmXxreg0{
17887 Oxm: NewOxm(122384),
17888 }
17889 return obj
17890}
17891func (self *NxmXxreg0) GetOXMName() string {
17892 return "xxreg0"
17893}
17894
17895func (self *NxmXxreg0) GetOXMValue() interface{} {
17896 return self.Value
17897}
17898
17899func (self *NxmXxreg0) MarshalJSON() ([]byte, error) {
17900 value, err := jsonValue(self.GetOXMValue())
17901 if err != nil {
17902 return nil, err
17903 }
17904 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
17905}
17906
17907type NxmXxreg0Masked struct {
17908 *Oxm
17909 Value uint128
17910 ValueMask uint128
17911}
17912
17913type INxmXxreg0Masked interface {
17914 goloxi.IOxm
17915 GetValue() uint128
17916 GetValueMask() uint128
17917}
17918
17919func (self *NxmXxreg0Masked) GetValue() uint128 {
17920 return self.Value
17921}
17922
17923func (self *NxmXxreg0Masked) SetValue(v uint128) {
17924 self.Value = v
17925}
17926
17927func (self *NxmXxreg0Masked) GetValueMask() uint128 {
17928 return self.ValueMask
17929}
17930
17931func (self *NxmXxreg0Masked) SetValueMask(v uint128) {
17932 self.ValueMask = v
17933}
17934
17935func (self *NxmXxreg0Masked) Serialize(encoder *goloxi.Encoder) error {
17936 if err := self.Oxm.Serialize(encoder); err != nil {
17937 return err
17938 }
17939
17940 encoder.PutUint128(uint128(self.Value))
17941 encoder.PutUint128(uint128(self.ValueMask))
17942
17943 return nil
17944}
17945
17946func DecodeNxmXxreg0Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg0Masked, error) {
17947 _nxmxxreg0masked := &NxmXxreg0Masked{Oxm: parent}
17948 if decoder.Length() < 32 {
17949 return nil, fmt.Errorf("NxmXxreg0Masked packet too short: %d < 32", decoder.Length())
17950 }
17951 _nxmxxreg0masked.Value = uint128(decoder.ReadUint128())
17952 _nxmxxreg0masked.ValueMask = uint128(decoder.ReadUint128())
17953 return _nxmxxreg0masked, nil
17954}
17955
17956func NewNxmXxreg0Masked() *NxmXxreg0Masked {
17957 obj := &NxmXxreg0Masked{
17958 Oxm: NewOxm(122656),
17959 }
17960 return obj
17961}
17962func (self *NxmXxreg0Masked) GetOXMName() string {
17963 return "xxreg0_masked"
17964}
17965
17966func (self *NxmXxreg0Masked) GetOXMValue() interface{} {
17967 return self.Value
17968}
17969
17970func (self *NxmXxreg0Masked) GetOXMValueMask() interface{} {
17971 return self.ValueMask
17972}
17973
17974func (self *NxmXxreg0Masked) MarshalJSON() ([]byte, error) {
17975 value, err := jsonValue(self.GetOXMValue())
17976 if err != nil {
17977 return nil, err
17978 }
17979 valueMask, err := jsonValue(self.GetOXMValueMask())
17980 if err != nil {
17981 return nil, err
17982 }
17983 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
17984}
17985
17986type NxmXxreg1 struct {
17987 *Oxm
17988 Value uint128
17989}
17990
17991type INxmXxreg1 interface {
17992 goloxi.IOxm
17993 GetValue() uint128
17994}
17995
17996func (self *NxmXxreg1) GetValue() uint128 {
17997 return self.Value
17998}
17999
18000func (self *NxmXxreg1) SetValue(v uint128) {
18001 self.Value = v
18002}
18003
18004func (self *NxmXxreg1) Serialize(encoder *goloxi.Encoder) error {
18005 if err := self.Oxm.Serialize(encoder); err != nil {
18006 return err
18007 }
18008
18009 encoder.PutUint128(uint128(self.Value))
18010
18011 return nil
18012}
18013
18014func DecodeNxmXxreg1(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg1, error) {
18015 _nxmxxreg1 := &NxmXxreg1{Oxm: parent}
18016 if decoder.Length() < 16 {
18017 return nil, fmt.Errorf("NxmXxreg1 packet too short: %d < 16", decoder.Length())
18018 }
18019 _nxmxxreg1.Value = uint128(decoder.ReadUint128())
18020 return _nxmxxreg1, nil
18021}
18022
18023func NewNxmXxreg1() *NxmXxreg1 {
18024 obj := &NxmXxreg1{
18025 Oxm: NewOxm(122896),
18026 }
18027 return obj
18028}
18029func (self *NxmXxreg1) GetOXMName() string {
18030 return "xxreg1"
18031}
18032
18033func (self *NxmXxreg1) GetOXMValue() interface{} {
18034 return self.Value
18035}
18036
18037func (self *NxmXxreg1) MarshalJSON() ([]byte, error) {
18038 value, err := jsonValue(self.GetOXMValue())
18039 if err != nil {
18040 return nil, err
18041 }
18042 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
18043}
18044
18045type NxmXxreg1Masked struct {
18046 *Oxm
18047 Value uint128
18048 ValueMask uint128
18049}
18050
18051type INxmXxreg1Masked interface {
18052 goloxi.IOxm
18053 GetValue() uint128
18054 GetValueMask() uint128
18055}
18056
18057func (self *NxmXxreg1Masked) GetValue() uint128 {
18058 return self.Value
18059}
18060
18061func (self *NxmXxreg1Masked) SetValue(v uint128) {
18062 self.Value = v
18063}
18064
18065func (self *NxmXxreg1Masked) GetValueMask() uint128 {
18066 return self.ValueMask
18067}
18068
18069func (self *NxmXxreg1Masked) SetValueMask(v uint128) {
18070 self.ValueMask = v
18071}
18072
18073func (self *NxmXxreg1Masked) Serialize(encoder *goloxi.Encoder) error {
18074 if err := self.Oxm.Serialize(encoder); err != nil {
18075 return err
18076 }
18077
18078 encoder.PutUint128(uint128(self.Value))
18079 encoder.PutUint128(uint128(self.ValueMask))
18080
18081 return nil
18082}
18083
18084func DecodeNxmXxreg1Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg1Masked, error) {
18085 _nxmxxreg1masked := &NxmXxreg1Masked{Oxm: parent}
18086 if decoder.Length() < 32 {
18087 return nil, fmt.Errorf("NxmXxreg1Masked packet too short: %d < 32", decoder.Length())
18088 }
18089 _nxmxxreg1masked.Value = uint128(decoder.ReadUint128())
18090 _nxmxxreg1masked.ValueMask = uint128(decoder.ReadUint128())
18091 return _nxmxxreg1masked, nil
18092}
18093
18094func NewNxmXxreg1Masked() *NxmXxreg1Masked {
18095 obj := &NxmXxreg1Masked{
18096 Oxm: NewOxm(123168),
18097 }
18098 return obj
18099}
18100func (self *NxmXxreg1Masked) GetOXMName() string {
18101 return "xxreg1_masked"
18102}
18103
18104func (self *NxmXxreg1Masked) GetOXMValue() interface{} {
18105 return self.Value
18106}
18107
18108func (self *NxmXxreg1Masked) GetOXMValueMask() interface{} {
18109 return self.ValueMask
18110}
18111
18112func (self *NxmXxreg1Masked) MarshalJSON() ([]byte, error) {
18113 value, err := jsonValue(self.GetOXMValue())
18114 if err != nil {
18115 return nil, err
18116 }
18117 valueMask, err := jsonValue(self.GetOXMValueMask())
18118 if err != nil {
18119 return nil, err
18120 }
18121 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
18122}
18123
18124type NxmXxreg2 struct {
18125 *Oxm
18126 Value uint128
18127}
18128
18129type INxmXxreg2 interface {
18130 goloxi.IOxm
18131 GetValue() uint128
18132}
18133
18134func (self *NxmXxreg2) GetValue() uint128 {
18135 return self.Value
18136}
18137
18138func (self *NxmXxreg2) SetValue(v uint128) {
18139 self.Value = v
18140}
18141
18142func (self *NxmXxreg2) Serialize(encoder *goloxi.Encoder) error {
18143 if err := self.Oxm.Serialize(encoder); err != nil {
18144 return err
18145 }
18146
18147 encoder.PutUint128(uint128(self.Value))
18148
18149 return nil
18150}
18151
18152func DecodeNxmXxreg2(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg2, error) {
18153 _nxmxxreg2 := &NxmXxreg2{Oxm: parent}
18154 if decoder.Length() < 16 {
18155 return nil, fmt.Errorf("NxmXxreg2 packet too short: %d < 16", decoder.Length())
18156 }
18157 _nxmxxreg2.Value = uint128(decoder.ReadUint128())
18158 return _nxmxxreg2, nil
18159}
18160
18161func NewNxmXxreg2() *NxmXxreg2 {
18162 obj := &NxmXxreg2{
18163 Oxm: NewOxm(123408),
18164 }
18165 return obj
18166}
18167func (self *NxmXxreg2) GetOXMName() string {
18168 return "xxreg2"
18169}
18170
18171func (self *NxmXxreg2) GetOXMValue() interface{} {
18172 return self.Value
18173}
18174
18175func (self *NxmXxreg2) MarshalJSON() ([]byte, error) {
18176 value, err := jsonValue(self.GetOXMValue())
18177 if err != nil {
18178 return nil, err
18179 }
18180 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
18181}
18182
18183type NxmXxreg2Masked struct {
18184 *Oxm
18185 Value uint128
18186 ValueMask uint128
18187}
18188
18189type INxmXxreg2Masked interface {
18190 goloxi.IOxm
18191 GetValue() uint128
18192 GetValueMask() uint128
18193}
18194
18195func (self *NxmXxreg2Masked) GetValue() uint128 {
18196 return self.Value
18197}
18198
18199func (self *NxmXxreg2Masked) SetValue(v uint128) {
18200 self.Value = v
18201}
18202
18203func (self *NxmXxreg2Masked) GetValueMask() uint128 {
18204 return self.ValueMask
18205}
18206
18207func (self *NxmXxreg2Masked) SetValueMask(v uint128) {
18208 self.ValueMask = v
18209}
18210
18211func (self *NxmXxreg2Masked) Serialize(encoder *goloxi.Encoder) error {
18212 if err := self.Oxm.Serialize(encoder); err != nil {
18213 return err
18214 }
18215
18216 encoder.PutUint128(uint128(self.Value))
18217 encoder.PutUint128(uint128(self.ValueMask))
18218
18219 return nil
18220}
18221
18222func DecodeNxmXxreg2Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg2Masked, error) {
18223 _nxmxxreg2masked := &NxmXxreg2Masked{Oxm: parent}
18224 if decoder.Length() < 32 {
18225 return nil, fmt.Errorf("NxmXxreg2Masked packet too short: %d < 32", decoder.Length())
18226 }
18227 _nxmxxreg2masked.Value = uint128(decoder.ReadUint128())
18228 _nxmxxreg2masked.ValueMask = uint128(decoder.ReadUint128())
18229 return _nxmxxreg2masked, nil
18230}
18231
18232func NewNxmXxreg2Masked() *NxmXxreg2Masked {
18233 obj := &NxmXxreg2Masked{
18234 Oxm: NewOxm(123680),
18235 }
18236 return obj
18237}
18238func (self *NxmXxreg2Masked) GetOXMName() string {
18239 return "xxreg2_masked"
18240}
18241
18242func (self *NxmXxreg2Masked) GetOXMValue() interface{} {
18243 return self.Value
18244}
18245
18246func (self *NxmXxreg2Masked) GetOXMValueMask() interface{} {
18247 return self.ValueMask
18248}
18249
18250func (self *NxmXxreg2Masked) MarshalJSON() ([]byte, error) {
18251 value, err := jsonValue(self.GetOXMValue())
18252 if err != nil {
18253 return nil, err
18254 }
18255 valueMask, err := jsonValue(self.GetOXMValueMask())
18256 if err != nil {
18257 return nil, err
18258 }
18259 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
18260}
18261
18262type NxmXxreg3 struct {
18263 *Oxm
18264 Value uint128
18265}
18266
18267type INxmXxreg3 interface {
18268 goloxi.IOxm
18269 GetValue() uint128
18270}
18271
18272func (self *NxmXxreg3) GetValue() uint128 {
18273 return self.Value
18274}
18275
18276func (self *NxmXxreg3) SetValue(v uint128) {
18277 self.Value = v
18278}
18279
18280func (self *NxmXxreg3) Serialize(encoder *goloxi.Encoder) error {
18281 if err := self.Oxm.Serialize(encoder); err != nil {
18282 return err
18283 }
18284
18285 encoder.PutUint128(uint128(self.Value))
18286
18287 return nil
18288}
18289
18290func DecodeNxmXxreg3(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg3, error) {
18291 _nxmxxreg3 := &NxmXxreg3{Oxm: parent}
18292 if decoder.Length() < 16 {
18293 return nil, fmt.Errorf("NxmXxreg3 packet too short: %d < 16", decoder.Length())
18294 }
18295 _nxmxxreg3.Value = uint128(decoder.ReadUint128())
18296 return _nxmxxreg3, nil
18297}
18298
18299func NewNxmXxreg3() *NxmXxreg3 {
18300 obj := &NxmXxreg3{
18301 Oxm: NewOxm(123920),
18302 }
18303 return obj
18304}
18305func (self *NxmXxreg3) GetOXMName() string {
18306 return "xxreg3"
18307}
18308
18309func (self *NxmXxreg3) GetOXMValue() interface{} {
18310 return self.Value
18311}
18312
18313func (self *NxmXxreg3) MarshalJSON() ([]byte, error) {
18314 value, err := jsonValue(self.GetOXMValue())
18315 if err != nil {
18316 return nil, err
18317 }
18318 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
18319}
18320
18321type NxmXxreg3Masked struct {
18322 *Oxm
18323 Value uint128
18324 ValueMask uint128
18325}
18326
18327type INxmXxreg3Masked interface {
18328 goloxi.IOxm
18329 GetValue() uint128
18330 GetValueMask() uint128
18331}
18332
18333func (self *NxmXxreg3Masked) GetValue() uint128 {
18334 return self.Value
18335}
18336
18337func (self *NxmXxreg3Masked) SetValue(v uint128) {
18338 self.Value = v
18339}
18340
18341func (self *NxmXxreg3Masked) GetValueMask() uint128 {
18342 return self.ValueMask
18343}
18344
18345func (self *NxmXxreg3Masked) SetValueMask(v uint128) {
18346 self.ValueMask = v
18347}
18348
18349func (self *NxmXxreg3Masked) Serialize(encoder *goloxi.Encoder) error {
18350 if err := self.Oxm.Serialize(encoder); err != nil {
18351 return err
18352 }
18353
18354 encoder.PutUint128(uint128(self.Value))
18355 encoder.PutUint128(uint128(self.ValueMask))
18356
18357 return nil
18358}
18359
18360func DecodeNxmXxreg3Masked(parent *Oxm, decoder *goloxi.Decoder) (*NxmXxreg3Masked, error) {
18361 _nxmxxreg3masked := &NxmXxreg3Masked{Oxm: parent}
18362 if decoder.Length() < 32 {
18363 return nil, fmt.Errorf("NxmXxreg3Masked packet too short: %d < 32", decoder.Length())
18364 }
18365 _nxmxxreg3masked.Value = uint128(decoder.ReadUint128())
18366 _nxmxxreg3masked.ValueMask = uint128(decoder.ReadUint128())
18367 return _nxmxxreg3masked, nil
18368}
18369
18370func NewNxmXxreg3Masked() *NxmXxreg3Masked {
18371 obj := &NxmXxreg3Masked{
18372 Oxm: NewOxm(124192),
18373 }
18374 return obj
18375}
18376func (self *NxmXxreg3Masked) GetOXMName() string {
18377 return "xxreg3_masked"
18378}
18379
18380func (self *NxmXxreg3Masked) GetOXMValue() interface{} {
18381 return self.Value
18382}
18383
18384func (self *NxmXxreg3Masked) GetOXMValueMask() interface{} {
18385 return self.ValueMask
18386}
18387
18388func (self *NxmXxreg3Masked) MarshalJSON() ([]byte, error) {
18389 value, err := jsonValue(self.GetOXMValue())
18390 if err != nil {
18391 return nil, err
18392 }
18393 valueMask, err := jsonValue(self.GetOXMValueMask())
18394 if err != nil {
18395 return nil, err
18396 }
18397 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
18398}
18399
18400type OxmArpOp struct {
18401 *Oxm
18402 Value uint16
18403}
18404
18405type IOxmArpOp interface {
18406 goloxi.IOxm
18407 GetValue() uint16
18408}
18409
18410func (self *OxmArpOp) GetValue() uint16 {
18411 return self.Value
18412}
18413
18414func (self *OxmArpOp) SetValue(v uint16) {
18415 self.Value = v
18416}
18417
18418func (self *OxmArpOp) Serialize(encoder *goloxi.Encoder) error {
18419 if err := self.Oxm.Serialize(encoder); err != nil {
18420 return err
18421 }
18422
18423 encoder.PutUint16(uint16(self.Value))
18424
18425 return nil
18426}
18427
18428func DecodeOxmArpOp(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpOp, error) {
18429 _oxmarpop := &OxmArpOp{Oxm: parent}
18430 if decoder.Length() < 2 {
18431 return nil, fmt.Errorf("OxmArpOp packet too short: %d < 2", decoder.Length())
18432 }
18433 _oxmarpop.Value = uint16(decoder.ReadUint16())
18434 return _oxmarpop, nil
18435}
18436
18437func NewOxmArpOp() *OxmArpOp {
18438 obj := &OxmArpOp{
18439 Oxm: NewOxm(2147494402),
18440 }
18441 return obj
18442}
18443func (self *OxmArpOp) GetOXMName() string {
18444 return "arp_op"
18445}
18446
18447func (self *OxmArpOp) GetOXMValue() interface{} {
18448 return self.Value
18449}
18450
18451func (self *OxmArpOp) MarshalJSON() ([]byte, error) {
18452 value, err := jsonValue(self.GetOXMValue())
18453 if err != nil {
18454 return nil, err
18455 }
18456 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
18457}
18458
18459type OxmArpOpMasked struct {
18460 *Oxm
18461 Value uint16
18462 ValueMask uint16
18463}
18464
18465type IOxmArpOpMasked interface {
18466 goloxi.IOxm
18467 GetValue() uint16
18468 GetValueMask() uint16
18469}
18470
18471func (self *OxmArpOpMasked) GetValue() uint16 {
18472 return self.Value
18473}
18474
18475func (self *OxmArpOpMasked) SetValue(v uint16) {
18476 self.Value = v
18477}
18478
18479func (self *OxmArpOpMasked) GetValueMask() uint16 {
18480 return self.ValueMask
18481}
18482
18483func (self *OxmArpOpMasked) SetValueMask(v uint16) {
18484 self.ValueMask = v
18485}
18486
18487func (self *OxmArpOpMasked) Serialize(encoder *goloxi.Encoder) error {
18488 if err := self.Oxm.Serialize(encoder); err != nil {
18489 return err
18490 }
18491
18492 encoder.PutUint16(uint16(self.Value))
18493 encoder.PutUint16(uint16(self.ValueMask))
18494
18495 return nil
18496}
18497
18498func DecodeOxmArpOpMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpOpMasked, error) {
18499 _oxmarpopmasked := &OxmArpOpMasked{Oxm: parent}
18500 if decoder.Length() < 4 {
18501 return nil, fmt.Errorf("OxmArpOpMasked packet too short: %d < 4", decoder.Length())
18502 }
18503 _oxmarpopmasked.Value = uint16(decoder.ReadUint16())
18504 _oxmarpopmasked.ValueMask = uint16(decoder.ReadUint16())
18505 return _oxmarpopmasked, nil
18506}
18507
18508func NewOxmArpOpMasked() *OxmArpOpMasked {
18509 obj := &OxmArpOpMasked{
18510 Oxm: NewOxm(2147494660),
18511 }
18512 return obj
18513}
18514func (self *OxmArpOpMasked) GetOXMName() string {
18515 return "arp_op_masked"
18516}
18517
18518func (self *OxmArpOpMasked) GetOXMValue() interface{} {
18519 return self.Value
18520}
18521
18522func (self *OxmArpOpMasked) GetOXMValueMask() interface{} {
18523 return self.ValueMask
18524}
18525
18526func (self *OxmArpOpMasked) MarshalJSON() ([]byte, error) {
18527 value, err := jsonValue(self.GetOXMValue())
18528 if err != nil {
18529 return nil, err
18530 }
18531 valueMask, err := jsonValue(self.GetOXMValueMask())
18532 if err != nil {
18533 return nil, err
18534 }
18535 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
18536}
18537
18538type OxmArpSha struct {
18539 *Oxm
18540 Value net.HardwareAddr
18541}
18542
18543type IOxmArpSha interface {
18544 goloxi.IOxm
18545 GetValue() net.HardwareAddr
18546}
18547
18548func (self *OxmArpSha) GetValue() net.HardwareAddr {
18549 return self.Value
18550}
18551
18552func (self *OxmArpSha) SetValue(v net.HardwareAddr) {
18553 self.Value = v
18554}
18555
18556func (self *OxmArpSha) Serialize(encoder *goloxi.Encoder) error {
18557 if err := self.Oxm.Serialize(encoder); err != nil {
18558 return err
18559 }
18560
18561 encoder.Write(self.Value)
18562
18563 return nil
18564}
18565
18566func DecodeOxmArpSha(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpSha, error) {
18567 _oxmarpsha := &OxmArpSha{Oxm: parent}
18568 if decoder.Length() < 6 {
18569 return nil, fmt.Errorf("OxmArpSha packet too short: %d < 6", decoder.Length())
18570 }
18571 _oxmarpsha.Value = net.HardwareAddr(decoder.Read(6))
18572 return _oxmarpsha, nil
18573}
18574
18575func NewOxmArpSha() *OxmArpSha {
18576 obj := &OxmArpSha{
18577 Oxm: NewOxm(2147495942),
18578 }
18579 return obj
18580}
18581func (self *OxmArpSha) GetOXMName() string {
18582 return "arp_sha"
18583}
18584
18585func (self *OxmArpSha) GetOXMValue() interface{} {
18586 return self.Value
18587}
18588
18589func (self *OxmArpSha) MarshalJSON() ([]byte, error) {
18590 value, err := jsonValue(self.GetOXMValue())
18591 if err != nil {
18592 return nil, err
18593 }
18594 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
18595}
18596
18597type OxmArpShaMasked struct {
18598 *Oxm
18599 Value net.HardwareAddr
18600 ValueMask net.HardwareAddr
18601}
18602
18603type IOxmArpShaMasked interface {
18604 goloxi.IOxm
18605 GetValue() net.HardwareAddr
18606 GetValueMask() net.HardwareAddr
18607}
18608
18609func (self *OxmArpShaMasked) GetValue() net.HardwareAddr {
18610 return self.Value
18611}
18612
18613func (self *OxmArpShaMasked) SetValue(v net.HardwareAddr) {
18614 self.Value = v
18615}
18616
18617func (self *OxmArpShaMasked) GetValueMask() net.HardwareAddr {
18618 return self.ValueMask
18619}
18620
18621func (self *OxmArpShaMasked) SetValueMask(v net.HardwareAddr) {
18622 self.ValueMask = v
18623}
18624
18625func (self *OxmArpShaMasked) Serialize(encoder *goloxi.Encoder) error {
18626 if err := self.Oxm.Serialize(encoder); err != nil {
18627 return err
18628 }
18629
18630 encoder.Write(self.Value)
18631 encoder.Write(self.ValueMask)
18632
18633 return nil
18634}
18635
18636func DecodeOxmArpShaMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpShaMasked, error) {
18637 _oxmarpshamasked := &OxmArpShaMasked{Oxm: parent}
18638 if decoder.Length() < 12 {
18639 return nil, fmt.Errorf("OxmArpShaMasked packet too short: %d < 12", decoder.Length())
18640 }
18641 _oxmarpshamasked.Value = net.HardwareAddr(decoder.Read(6))
18642 _oxmarpshamasked.ValueMask = net.HardwareAddr(decoder.Read(6))
18643 return _oxmarpshamasked, nil
18644}
18645
18646func NewOxmArpShaMasked() *OxmArpShaMasked {
18647 obj := &OxmArpShaMasked{
18648 Oxm: NewOxm(2147496204),
18649 }
18650 return obj
18651}
18652func (self *OxmArpShaMasked) GetOXMName() string {
18653 return "arp_sha_masked"
18654}
18655
18656func (self *OxmArpShaMasked) GetOXMValue() interface{} {
18657 return self.Value
18658}
18659
18660func (self *OxmArpShaMasked) GetOXMValueMask() interface{} {
18661 return self.ValueMask
18662}
18663
18664func (self *OxmArpShaMasked) MarshalJSON() ([]byte, error) {
18665 value, err := jsonValue(self.GetOXMValue())
18666 if err != nil {
18667 return nil, err
18668 }
18669 valueMask, err := jsonValue(self.GetOXMValueMask())
18670 if err != nil {
18671 return nil, err
18672 }
18673 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
18674}
18675
18676type OxmArpSpa struct {
18677 *Oxm
18678 Value uint32
18679}
18680
18681type IOxmArpSpa interface {
18682 goloxi.IOxm
18683 GetValue() uint32
18684}
18685
18686func (self *OxmArpSpa) GetValue() uint32 {
18687 return self.Value
18688}
18689
18690func (self *OxmArpSpa) SetValue(v uint32) {
18691 self.Value = v
18692}
18693
18694func (self *OxmArpSpa) Serialize(encoder *goloxi.Encoder) error {
18695 if err := self.Oxm.Serialize(encoder); err != nil {
18696 return err
18697 }
18698
18699 encoder.PutUint32(uint32(self.Value))
18700
18701 return nil
18702}
18703
18704func DecodeOxmArpSpa(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpSpa, error) {
18705 _oxmarpspa := &OxmArpSpa{Oxm: parent}
18706 if decoder.Length() < 4 {
18707 return nil, fmt.Errorf("OxmArpSpa packet too short: %d < 4", decoder.Length())
18708 }
18709 _oxmarpspa.Value = uint32(decoder.ReadUint32())
18710 return _oxmarpspa, nil
18711}
18712
18713func NewOxmArpSpa() *OxmArpSpa {
18714 obj := &OxmArpSpa{
18715 Oxm: NewOxm(2147494916),
18716 }
18717 return obj
18718}
18719func (self *OxmArpSpa) GetOXMName() string {
18720 return "arp_spa"
18721}
18722
18723func (self *OxmArpSpa) GetOXMValue() interface{} {
18724 return self.Value
18725}
18726
18727func (self *OxmArpSpa) MarshalJSON() ([]byte, error) {
18728 value, err := jsonValue(self.GetOXMValue())
18729 if err != nil {
18730 return nil, err
18731 }
18732 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
18733}
18734
18735type OxmArpSpaMasked struct {
18736 *Oxm
18737 Value uint32
18738 ValueMask uint32
18739}
18740
18741type IOxmArpSpaMasked interface {
18742 goloxi.IOxm
18743 GetValue() uint32
18744 GetValueMask() uint32
18745}
18746
18747func (self *OxmArpSpaMasked) GetValue() uint32 {
18748 return self.Value
18749}
18750
18751func (self *OxmArpSpaMasked) SetValue(v uint32) {
18752 self.Value = v
18753}
18754
18755func (self *OxmArpSpaMasked) GetValueMask() uint32 {
18756 return self.ValueMask
18757}
18758
18759func (self *OxmArpSpaMasked) SetValueMask(v uint32) {
18760 self.ValueMask = v
18761}
18762
18763func (self *OxmArpSpaMasked) Serialize(encoder *goloxi.Encoder) error {
18764 if err := self.Oxm.Serialize(encoder); err != nil {
18765 return err
18766 }
18767
18768 encoder.PutUint32(uint32(self.Value))
18769 encoder.PutUint32(uint32(self.ValueMask))
18770
18771 return nil
18772}
18773
18774func DecodeOxmArpSpaMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpSpaMasked, error) {
18775 _oxmarpspamasked := &OxmArpSpaMasked{Oxm: parent}
18776 if decoder.Length() < 8 {
18777 return nil, fmt.Errorf("OxmArpSpaMasked packet too short: %d < 8", decoder.Length())
18778 }
18779 _oxmarpspamasked.Value = uint32(decoder.ReadUint32())
18780 _oxmarpspamasked.ValueMask = uint32(decoder.ReadUint32())
18781 return _oxmarpspamasked, nil
18782}
18783
18784func NewOxmArpSpaMasked() *OxmArpSpaMasked {
18785 obj := &OxmArpSpaMasked{
18786 Oxm: NewOxm(2147495176),
18787 }
18788 return obj
18789}
18790func (self *OxmArpSpaMasked) GetOXMName() string {
18791 return "arp_spa_masked"
18792}
18793
18794func (self *OxmArpSpaMasked) GetOXMValue() interface{} {
18795 return self.Value
18796}
18797
18798func (self *OxmArpSpaMasked) GetOXMValueMask() interface{} {
18799 return self.ValueMask
18800}
18801
18802func (self *OxmArpSpaMasked) MarshalJSON() ([]byte, error) {
18803 value, err := jsonValue(self.GetOXMValue())
18804 if err != nil {
18805 return nil, err
18806 }
18807 valueMask, err := jsonValue(self.GetOXMValueMask())
18808 if err != nil {
18809 return nil, err
18810 }
18811 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
18812}
18813
18814type OxmArpTha struct {
18815 *Oxm
18816 Value net.HardwareAddr
18817}
18818
18819type IOxmArpTha interface {
18820 goloxi.IOxm
18821 GetValue() net.HardwareAddr
18822}
18823
18824func (self *OxmArpTha) GetValue() net.HardwareAddr {
18825 return self.Value
18826}
18827
18828func (self *OxmArpTha) SetValue(v net.HardwareAddr) {
18829 self.Value = v
18830}
18831
18832func (self *OxmArpTha) Serialize(encoder *goloxi.Encoder) error {
18833 if err := self.Oxm.Serialize(encoder); err != nil {
18834 return err
18835 }
18836
18837 encoder.Write(self.Value)
18838
18839 return nil
18840}
18841
18842func DecodeOxmArpTha(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpTha, error) {
18843 _oxmarptha := &OxmArpTha{Oxm: parent}
18844 if decoder.Length() < 6 {
18845 return nil, fmt.Errorf("OxmArpTha packet too short: %d < 6", decoder.Length())
18846 }
18847 _oxmarptha.Value = net.HardwareAddr(decoder.Read(6))
18848 return _oxmarptha, nil
18849}
18850
18851func NewOxmArpTha() *OxmArpTha {
18852 obj := &OxmArpTha{
18853 Oxm: NewOxm(2147496454),
18854 }
18855 return obj
18856}
18857func (self *OxmArpTha) GetOXMName() string {
18858 return "arp_tha"
18859}
18860
18861func (self *OxmArpTha) GetOXMValue() interface{} {
18862 return self.Value
18863}
18864
18865func (self *OxmArpTha) MarshalJSON() ([]byte, error) {
18866 value, err := jsonValue(self.GetOXMValue())
18867 if err != nil {
18868 return nil, err
18869 }
18870 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
18871}
18872
18873type OxmArpThaMasked struct {
18874 *Oxm
18875 Value net.HardwareAddr
18876 ValueMask net.HardwareAddr
18877}
18878
18879type IOxmArpThaMasked interface {
18880 goloxi.IOxm
18881 GetValue() net.HardwareAddr
18882 GetValueMask() net.HardwareAddr
18883}
18884
18885func (self *OxmArpThaMasked) GetValue() net.HardwareAddr {
18886 return self.Value
18887}
18888
18889func (self *OxmArpThaMasked) SetValue(v net.HardwareAddr) {
18890 self.Value = v
18891}
18892
18893func (self *OxmArpThaMasked) GetValueMask() net.HardwareAddr {
18894 return self.ValueMask
18895}
18896
18897func (self *OxmArpThaMasked) SetValueMask(v net.HardwareAddr) {
18898 self.ValueMask = v
18899}
18900
18901func (self *OxmArpThaMasked) Serialize(encoder *goloxi.Encoder) error {
18902 if err := self.Oxm.Serialize(encoder); err != nil {
18903 return err
18904 }
18905
18906 encoder.Write(self.Value)
18907 encoder.Write(self.ValueMask)
18908
18909 return nil
18910}
18911
18912func DecodeOxmArpThaMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpThaMasked, error) {
18913 _oxmarpthamasked := &OxmArpThaMasked{Oxm: parent}
18914 if decoder.Length() < 12 {
18915 return nil, fmt.Errorf("OxmArpThaMasked packet too short: %d < 12", decoder.Length())
18916 }
18917 _oxmarpthamasked.Value = net.HardwareAddr(decoder.Read(6))
18918 _oxmarpthamasked.ValueMask = net.HardwareAddr(decoder.Read(6))
18919 return _oxmarpthamasked, nil
18920}
18921
18922func NewOxmArpThaMasked() *OxmArpThaMasked {
18923 obj := &OxmArpThaMasked{
18924 Oxm: NewOxm(2147496716),
18925 }
18926 return obj
18927}
18928func (self *OxmArpThaMasked) GetOXMName() string {
18929 return "arp_tha_masked"
18930}
18931
18932func (self *OxmArpThaMasked) GetOXMValue() interface{} {
18933 return self.Value
18934}
18935
18936func (self *OxmArpThaMasked) GetOXMValueMask() interface{} {
18937 return self.ValueMask
18938}
18939
18940func (self *OxmArpThaMasked) MarshalJSON() ([]byte, error) {
18941 value, err := jsonValue(self.GetOXMValue())
18942 if err != nil {
18943 return nil, err
18944 }
18945 valueMask, err := jsonValue(self.GetOXMValueMask())
18946 if err != nil {
18947 return nil, err
18948 }
18949 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
18950}
18951
18952type OxmArpTpa struct {
18953 *Oxm
18954 Value uint32
18955}
18956
18957type IOxmArpTpa interface {
18958 goloxi.IOxm
18959 GetValue() uint32
18960}
18961
18962func (self *OxmArpTpa) GetValue() uint32 {
18963 return self.Value
18964}
18965
18966func (self *OxmArpTpa) SetValue(v uint32) {
18967 self.Value = v
18968}
18969
18970func (self *OxmArpTpa) Serialize(encoder *goloxi.Encoder) error {
18971 if err := self.Oxm.Serialize(encoder); err != nil {
18972 return err
18973 }
18974
18975 encoder.PutUint32(uint32(self.Value))
18976
18977 return nil
18978}
18979
18980func DecodeOxmArpTpa(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpTpa, error) {
18981 _oxmarptpa := &OxmArpTpa{Oxm: parent}
18982 if decoder.Length() < 4 {
18983 return nil, fmt.Errorf("OxmArpTpa packet too short: %d < 4", decoder.Length())
18984 }
18985 _oxmarptpa.Value = uint32(decoder.ReadUint32())
18986 return _oxmarptpa, nil
18987}
18988
18989func NewOxmArpTpa() *OxmArpTpa {
18990 obj := &OxmArpTpa{
18991 Oxm: NewOxm(2147495428),
18992 }
18993 return obj
18994}
18995func (self *OxmArpTpa) GetOXMName() string {
18996 return "arp_tpa"
18997}
18998
18999func (self *OxmArpTpa) GetOXMValue() interface{} {
19000 return self.Value
19001}
19002
19003func (self *OxmArpTpa) MarshalJSON() ([]byte, error) {
19004 value, err := jsonValue(self.GetOXMValue())
19005 if err != nil {
19006 return nil, err
19007 }
19008 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
19009}
19010
19011type OxmArpTpaMasked struct {
19012 *Oxm
19013 Value uint32
19014 ValueMask uint32
19015}
19016
19017type IOxmArpTpaMasked interface {
19018 goloxi.IOxm
19019 GetValue() uint32
19020 GetValueMask() uint32
19021}
19022
19023func (self *OxmArpTpaMasked) GetValue() uint32 {
19024 return self.Value
19025}
19026
19027func (self *OxmArpTpaMasked) SetValue(v uint32) {
19028 self.Value = v
19029}
19030
19031func (self *OxmArpTpaMasked) GetValueMask() uint32 {
19032 return self.ValueMask
19033}
19034
19035func (self *OxmArpTpaMasked) SetValueMask(v uint32) {
19036 self.ValueMask = v
19037}
19038
19039func (self *OxmArpTpaMasked) Serialize(encoder *goloxi.Encoder) error {
19040 if err := self.Oxm.Serialize(encoder); err != nil {
19041 return err
19042 }
19043
19044 encoder.PutUint32(uint32(self.Value))
19045 encoder.PutUint32(uint32(self.ValueMask))
19046
19047 return nil
19048}
19049
19050func DecodeOxmArpTpaMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmArpTpaMasked, error) {
19051 _oxmarptpamasked := &OxmArpTpaMasked{Oxm: parent}
19052 if decoder.Length() < 8 {
19053 return nil, fmt.Errorf("OxmArpTpaMasked packet too short: %d < 8", decoder.Length())
19054 }
19055 _oxmarptpamasked.Value = uint32(decoder.ReadUint32())
19056 _oxmarptpamasked.ValueMask = uint32(decoder.ReadUint32())
19057 return _oxmarptpamasked, nil
19058}
19059
19060func NewOxmArpTpaMasked() *OxmArpTpaMasked {
19061 obj := &OxmArpTpaMasked{
19062 Oxm: NewOxm(2147495688),
19063 }
19064 return obj
19065}
19066func (self *OxmArpTpaMasked) GetOXMName() string {
19067 return "arp_tpa_masked"
19068}
19069
19070func (self *OxmArpTpaMasked) GetOXMValue() interface{} {
19071 return self.Value
19072}
19073
19074func (self *OxmArpTpaMasked) GetOXMValueMask() interface{} {
19075 return self.ValueMask
19076}
19077
19078func (self *OxmArpTpaMasked) MarshalJSON() ([]byte, error) {
19079 value, err := jsonValue(self.GetOXMValue())
19080 if err != nil {
19081 return nil, err
19082 }
19083 valueMask, err := jsonValue(self.GetOXMValueMask())
19084 if err != nil {
19085 return nil, err
19086 }
19087 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
19088}
19089
19090type OxmConnTrackingIpv6Dst struct {
19091 *Oxm
19092 Value net.IP
19093}
19094
19095type IOxmConnTrackingIpv6Dst interface {
19096 goloxi.IOxm
19097 GetValue() net.IP
19098}
19099
19100func (self *OxmConnTrackingIpv6Dst) GetValue() net.IP {
19101 return self.Value
19102}
19103
19104func (self *OxmConnTrackingIpv6Dst) SetValue(v net.IP) {
19105 self.Value = v
19106}
19107
19108func (self *OxmConnTrackingIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
19109 if err := self.Oxm.Serialize(encoder); err != nil {
19110 return err
19111 }
19112
19113 encoder.Write(self.Value.To16())
19114
19115 return nil
19116}
19117
19118func DecodeOxmConnTrackingIpv6Dst(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingIpv6Dst, error) {
19119 _oxmconntrackingipv6dst := &OxmConnTrackingIpv6Dst{Oxm: parent}
19120 if decoder.Length() < 16 {
19121 return nil, fmt.Errorf("OxmConnTrackingIpv6Dst packet too short: %d < 16", decoder.Length())
19122 }
19123 _oxmconntrackingipv6dst.Value = net.IP(decoder.Read(16))
19124 return _oxmconntrackingipv6dst, nil
19125}
19126
19127func NewOxmConnTrackingIpv6Dst() *OxmConnTrackingIpv6Dst {
19128 obj := &OxmConnTrackingIpv6Dst{
19129 Oxm: NewOxm(128528),
19130 }
19131 return obj
19132}
19133func (self *OxmConnTrackingIpv6Dst) GetOXMName() string {
19134 return "conn_tracking_ipv6_dst"
19135}
19136
19137func (self *OxmConnTrackingIpv6Dst) GetOXMValue() interface{} {
19138 return self.Value
19139}
19140
19141func (self *OxmConnTrackingIpv6Dst) MarshalJSON() ([]byte, error) {
19142 value, err := jsonValue(self.GetOXMValue())
19143 if err != nil {
19144 return nil, err
19145 }
19146 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
19147}
19148
19149type OxmConnTrackingIpv6DstMasked struct {
19150 *Oxm
19151 Value net.IP
19152 ValueMask net.IP
19153}
19154
19155type IOxmConnTrackingIpv6DstMasked interface {
19156 goloxi.IOxm
19157 GetValue() net.IP
19158 GetValueMask() net.IP
19159}
19160
19161func (self *OxmConnTrackingIpv6DstMasked) GetValue() net.IP {
19162 return self.Value
19163}
19164
19165func (self *OxmConnTrackingIpv6DstMasked) SetValue(v net.IP) {
19166 self.Value = v
19167}
19168
19169func (self *OxmConnTrackingIpv6DstMasked) GetValueMask() net.IP {
19170 return self.ValueMask
19171}
19172
19173func (self *OxmConnTrackingIpv6DstMasked) SetValueMask(v net.IP) {
19174 self.ValueMask = v
19175}
19176
19177func (self *OxmConnTrackingIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
19178 if err := self.Oxm.Serialize(encoder); err != nil {
19179 return err
19180 }
19181
19182 encoder.Write(self.Value.To16())
19183 encoder.Write(self.ValueMask.To16())
19184
19185 return nil
19186}
19187
19188func DecodeOxmConnTrackingIpv6DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingIpv6DstMasked, error) {
19189 _oxmconntrackingipv6dstmasked := &OxmConnTrackingIpv6DstMasked{Oxm: parent}
19190 if decoder.Length() < 32 {
19191 return nil, fmt.Errorf("OxmConnTrackingIpv6DstMasked packet too short: %d < 32", decoder.Length())
19192 }
19193 _oxmconntrackingipv6dstmasked.Value = net.IP(decoder.Read(16))
19194 _oxmconntrackingipv6dstmasked.ValueMask = net.IP(decoder.Read(16))
19195 return _oxmconntrackingipv6dstmasked, nil
19196}
19197
19198func NewOxmConnTrackingIpv6DstMasked() *OxmConnTrackingIpv6DstMasked {
19199 obj := &OxmConnTrackingIpv6DstMasked{
19200 Oxm: NewOxm(128800),
19201 }
19202 return obj
19203}
19204func (self *OxmConnTrackingIpv6DstMasked) GetOXMName() string {
19205 return "conn_tracking_ipv6_dst_masked"
19206}
19207
19208func (self *OxmConnTrackingIpv6DstMasked) GetOXMValue() interface{} {
19209 return self.Value
19210}
19211
19212func (self *OxmConnTrackingIpv6DstMasked) GetOXMValueMask() interface{} {
19213 return self.ValueMask
19214}
19215
19216func (self *OxmConnTrackingIpv6DstMasked) MarshalJSON() ([]byte, error) {
19217 value, err := jsonValue(self.GetOXMValue())
19218 if err != nil {
19219 return nil, err
19220 }
19221 valueMask, err := jsonValue(self.GetOXMValueMask())
19222 if err != nil {
19223 return nil, err
19224 }
19225 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
19226}
19227
19228type OxmConnTrackingIpv6Src struct {
19229 *Oxm
19230 Value net.IP
19231}
19232
19233type IOxmConnTrackingIpv6Src interface {
19234 goloxi.IOxm
19235 GetValue() net.IP
19236}
19237
19238func (self *OxmConnTrackingIpv6Src) GetValue() net.IP {
19239 return self.Value
19240}
19241
19242func (self *OxmConnTrackingIpv6Src) SetValue(v net.IP) {
19243 self.Value = v
19244}
19245
19246func (self *OxmConnTrackingIpv6Src) Serialize(encoder *goloxi.Encoder) error {
19247 if err := self.Oxm.Serialize(encoder); err != nil {
19248 return err
19249 }
19250
19251 encoder.Write(self.Value.To16())
19252
19253 return nil
19254}
19255
19256func DecodeOxmConnTrackingIpv6Src(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingIpv6Src, error) {
19257 _oxmconntrackingipv6src := &OxmConnTrackingIpv6Src{Oxm: parent}
19258 if decoder.Length() < 16 {
19259 return nil, fmt.Errorf("OxmConnTrackingIpv6Src packet too short: %d < 16", decoder.Length())
19260 }
19261 _oxmconntrackingipv6src.Value = net.IP(decoder.Read(16))
19262 return _oxmconntrackingipv6src, nil
19263}
19264
19265func NewOxmConnTrackingIpv6Src() *OxmConnTrackingIpv6Src {
19266 obj := &OxmConnTrackingIpv6Src{
19267 Oxm: NewOxm(128016),
19268 }
19269 return obj
19270}
19271func (self *OxmConnTrackingIpv6Src) GetOXMName() string {
19272 return "conn_tracking_ipv6_src"
19273}
19274
19275func (self *OxmConnTrackingIpv6Src) GetOXMValue() interface{} {
19276 return self.Value
19277}
19278
19279func (self *OxmConnTrackingIpv6Src) MarshalJSON() ([]byte, error) {
19280 value, err := jsonValue(self.GetOXMValue())
19281 if err != nil {
19282 return nil, err
19283 }
19284 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
19285}
19286
19287type OxmConnTrackingIpv6SrcMasked struct {
19288 *Oxm
19289 Value net.IP
19290 ValueMask net.IP
19291}
19292
19293type IOxmConnTrackingIpv6SrcMasked interface {
19294 goloxi.IOxm
19295 GetValue() net.IP
19296 GetValueMask() net.IP
19297}
19298
19299func (self *OxmConnTrackingIpv6SrcMasked) GetValue() net.IP {
19300 return self.Value
19301}
19302
19303func (self *OxmConnTrackingIpv6SrcMasked) SetValue(v net.IP) {
19304 self.Value = v
19305}
19306
19307func (self *OxmConnTrackingIpv6SrcMasked) GetValueMask() net.IP {
19308 return self.ValueMask
19309}
19310
19311func (self *OxmConnTrackingIpv6SrcMasked) SetValueMask(v net.IP) {
19312 self.ValueMask = v
19313}
19314
19315func (self *OxmConnTrackingIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
19316 if err := self.Oxm.Serialize(encoder); err != nil {
19317 return err
19318 }
19319
19320 encoder.Write(self.Value.To16())
19321 encoder.Write(self.ValueMask.To16())
19322
19323 return nil
19324}
19325
19326func DecodeOxmConnTrackingIpv6SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingIpv6SrcMasked, error) {
19327 _oxmconntrackingipv6srcmasked := &OxmConnTrackingIpv6SrcMasked{Oxm: parent}
19328 if decoder.Length() < 32 {
19329 return nil, fmt.Errorf("OxmConnTrackingIpv6SrcMasked packet too short: %d < 32", decoder.Length())
19330 }
19331 _oxmconntrackingipv6srcmasked.Value = net.IP(decoder.Read(16))
19332 _oxmconntrackingipv6srcmasked.ValueMask = net.IP(decoder.Read(16))
19333 return _oxmconntrackingipv6srcmasked, nil
19334}
19335
19336func NewOxmConnTrackingIpv6SrcMasked() *OxmConnTrackingIpv6SrcMasked {
19337 obj := &OxmConnTrackingIpv6SrcMasked{
19338 Oxm: NewOxm(128288),
19339 }
19340 return obj
19341}
19342func (self *OxmConnTrackingIpv6SrcMasked) GetOXMName() string {
19343 return "conn_tracking_ipv6_src_masked"
19344}
19345
19346func (self *OxmConnTrackingIpv6SrcMasked) GetOXMValue() interface{} {
19347 return self.Value
19348}
19349
19350func (self *OxmConnTrackingIpv6SrcMasked) GetOXMValueMask() interface{} {
19351 return self.ValueMask
19352}
19353
19354func (self *OxmConnTrackingIpv6SrcMasked) MarshalJSON() ([]byte, error) {
19355 value, err := jsonValue(self.GetOXMValue())
19356 if err != nil {
19357 return nil, err
19358 }
19359 valueMask, err := jsonValue(self.GetOXMValueMask())
19360 if err != nil {
19361 return nil, err
19362 }
19363 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
19364}
19365
19366type OxmConnTrackingLabel struct {
19367 *Oxm
19368 Value uint128
19369}
19370
19371type IOxmConnTrackingLabel interface {
19372 goloxi.IOxm
19373 GetValue() uint128
19374}
19375
19376func (self *OxmConnTrackingLabel) GetValue() uint128 {
19377 return self.Value
19378}
19379
19380func (self *OxmConnTrackingLabel) SetValue(v uint128) {
19381 self.Value = v
19382}
19383
19384func (self *OxmConnTrackingLabel) Serialize(encoder *goloxi.Encoder) error {
19385 if err := self.Oxm.Serialize(encoder); err != nil {
19386 return err
19387 }
19388
19389 encoder.PutUint128(uint128(self.Value))
19390
19391 return nil
19392}
19393
19394func DecodeOxmConnTrackingLabel(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingLabel, error) {
19395 _oxmconntrackinglabel := &OxmConnTrackingLabel{Oxm: parent}
19396 if decoder.Length() < 16 {
19397 return nil, fmt.Errorf("OxmConnTrackingLabel packet too short: %d < 16", decoder.Length())
19398 }
19399 _oxmconntrackinglabel.Value = uint128(decoder.ReadUint128())
19400 return _oxmconntrackinglabel, nil
19401}
19402
19403func NewOxmConnTrackingLabel() *OxmConnTrackingLabel {
19404 obj := &OxmConnTrackingLabel{
19405 Oxm: NewOxm(120848),
19406 }
19407 return obj
19408}
19409func (self *OxmConnTrackingLabel) GetOXMName() string {
19410 return "conn_tracking_label"
19411}
19412
19413func (self *OxmConnTrackingLabel) GetOXMValue() interface{} {
19414 return self.Value
19415}
19416
19417func (self *OxmConnTrackingLabel) MarshalJSON() ([]byte, error) {
19418 value, err := jsonValue(self.GetOXMValue())
19419 if err != nil {
19420 return nil, err
19421 }
19422 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
19423}
19424
19425type OxmConnTrackingLabelMasked struct {
19426 *Oxm
19427 Value uint128
19428 ValueMask uint128
19429}
19430
19431type IOxmConnTrackingLabelMasked interface {
19432 goloxi.IOxm
19433 GetValue() uint128
19434 GetValueMask() uint128
19435}
19436
19437func (self *OxmConnTrackingLabelMasked) GetValue() uint128 {
19438 return self.Value
19439}
19440
19441func (self *OxmConnTrackingLabelMasked) SetValue(v uint128) {
19442 self.Value = v
19443}
19444
19445func (self *OxmConnTrackingLabelMasked) GetValueMask() uint128 {
19446 return self.ValueMask
19447}
19448
19449func (self *OxmConnTrackingLabelMasked) SetValueMask(v uint128) {
19450 self.ValueMask = v
19451}
19452
19453func (self *OxmConnTrackingLabelMasked) Serialize(encoder *goloxi.Encoder) error {
19454 if err := self.Oxm.Serialize(encoder); err != nil {
19455 return err
19456 }
19457
19458 encoder.PutUint128(uint128(self.Value))
19459 encoder.PutUint128(uint128(self.ValueMask))
19460
19461 return nil
19462}
19463
19464func DecodeOxmConnTrackingLabelMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingLabelMasked, error) {
19465 _oxmconntrackinglabelmasked := &OxmConnTrackingLabelMasked{Oxm: parent}
19466 if decoder.Length() < 32 {
19467 return nil, fmt.Errorf("OxmConnTrackingLabelMasked packet too short: %d < 32", decoder.Length())
19468 }
19469 _oxmconntrackinglabelmasked.Value = uint128(decoder.ReadUint128())
19470 _oxmconntrackinglabelmasked.ValueMask = uint128(decoder.ReadUint128())
19471 return _oxmconntrackinglabelmasked, nil
19472}
19473
19474func NewOxmConnTrackingLabelMasked() *OxmConnTrackingLabelMasked {
19475 obj := &OxmConnTrackingLabelMasked{
19476 Oxm: NewOxm(121120),
19477 }
19478 return obj
19479}
19480func (self *OxmConnTrackingLabelMasked) GetOXMName() string {
19481 return "conn_tracking_label_masked"
19482}
19483
19484func (self *OxmConnTrackingLabelMasked) GetOXMValue() interface{} {
19485 return self.Value
19486}
19487
19488func (self *OxmConnTrackingLabelMasked) GetOXMValueMask() interface{} {
19489 return self.ValueMask
19490}
19491
19492func (self *OxmConnTrackingLabelMasked) MarshalJSON() ([]byte, error) {
19493 value, err := jsonValue(self.GetOXMValue())
19494 if err != nil {
19495 return nil, err
19496 }
19497 valueMask, err := jsonValue(self.GetOXMValueMask())
19498 if err != nil {
19499 return nil, err
19500 }
19501 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
19502}
19503
19504type OxmConnTrackingMark struct {
19505 *Oxm
19506 Value uint32
19507}
19508
19509type IOxmConnTrackingMark interface {
19510 goloxi.IOxm
19511 GetValue() uint32
19512}
19513
19514func (self *OxmConnTrackingMark) GetValue() uint32 {
19515 return self.Value
19516}
19517
19518func (self *OxmConnTrackingMark) SetValue(v uint32) {
19519 self.Value = v
19520}
19521
19522func (self *OxmConnTrackingMark) Serialize(encoder *goloxi.Encoder) error {
19523 if err := self.Oxm.Serialize(encoder); err != nil {
19524 return err
19525 }
19526
19527 encoder.PutUint32(uint32(self.Value))
19528
19529 return nil
19530}
19531
19532func DecodeOxmConnTrackingMark(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingMark, error) {
19533 _oxmconntrackingmark := &OxmConnTrackingMark{Oxm: parent}
19534 if decoder.Length() < 4 {
19535 return nil, fmt.Errorf("OxmConnTrackingMark packet too short: %d < 4", decoder.Length())
19536 }
19537 _oxmconntrackingmark.Value = uint32(decoder.ReadUint32())
19538 return _oxmconntrackingmark, nil
19539}
19540
19541func NewOxmConnTrackingMark() *OxmConnTrackingMark {
19542 obj := &OxmConnTrackingMark{
19543 Oxm: NewOxm(120324),
19544 }
19545 return obj
19546}
19547func (self *OxmConnTrackingMark) GetOXMName() string {
19548 return "conn_tracking_mark"
19549}
19550
19551func (self *OxmConnTrackingMark) GetOXMValue() interface{} {
19552 return self.Value
19553}
19554
19555func (self *OxmConnTrackingMark) MarshalJSON() ([]byte, error) {
19556 value, err := jsonValue(self.GetOXMValue())
19557 if err != nil {
19558 return nil, err
19559 }
19560 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
19561}
19562
19563type OxmConnTrackingMarkMasked struct {
19564 *Oxm
19565 Value uint32
19566 ValueMask uint32
19567}
19568
19569type IOxmConnTrackingMarkMasked interface {
19570 goloxi.IOxm
19571 GetValue() uint32
19572 GetValueMask() uint32
19573}
19574
19575func (self *OxmConnTrackingMarkMasked) GetValue() uint32 {
19576 return self.Value
19577}
19578
19579func (self *OxmConnTrackingMarkMasked) SetValue(v uint32) {
19580 self.Value = v
19581}
19582
19583func (self *OxmConnTrackingMarkMasked) GetValueMask() uint32 {
19584 return self.ValueMask
19585}
19586
19587func (self *OxmConnTrackingMarkMasked) SetValueMask(v uint32) {
19588 self.ValueMask = v
19589}
19590
19591func (self *OxmConnTrackingMarkMasked) Serialize(encoder *goloxi.Encoder) error {
19592 if err := self.Oxm.Serialize(encoder); err != nil {
19593 return err
19594 }
19595
19596 encoder.PutUint32(uint32(self.Value))
19597 encoder.PutUint32(uint32(self.ValueMask))
19598
19599 return nil
19600}
19601
19602func DecodeOxmConnTrackingMarkMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingMarkMasked, error) {
19603 _oxmconntrackingmarkmasked := &OxmConnTrackingMarkMasked{Oxm: parent}
19604 if decoder.Length() < 8 {
19605 return nil, fmt.Errorf("OxmConnTrackingMarkMasked packet too short: %d < 8", decoder.Length())
19606 }
19607 _oxmconntrackingmarkmasked.Value = uint32(decoder.ReadUint32())
19608 _oxmconntrackingmarkmasked.ValueMask = uint32(decoder.ReadUint32())
19609 return _oxmconntrackingmarkmasked, nil
19610}
19611
19612func NewOxmConnTrackingMarkMasked() *OxmConnTrackingMarkMasked {
19613 obj := &OxmConnTrackingMarkMasked{
19614 Oxm: NewOxm(120584),
19615 }
19616 return obj
19617}
19618func (self *OxmConnTrackingMarkMasked) GetOXMName() string {
19619 return "conn_tracking_mark_masked"
19620}
19621
19622func (self *OxmConnTrackingMarkMasked) GetOXMValue() interface{} {
19623 return self.Value
19624}
19625
19626func (self *OxmConnTrackingMarkMasked) GetOXMValueMask() interface{} {
19627 return self.ValueMask
19628}
19629
19630func (self *OxmConnTrackingMarkMasked) MarshalJSON() ([]byte, error) {
19631 value, err := jsonValue(self.GetOXMValue())
19632 if err != nil {
19633 return nil, err
19634 }
19635 valueMask, err := jsonValue(self.GetOXMValueMask())
19636 if err != nil {
19637 return nil, err
19638 }
19639 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
19640}
19641
19642type OxmConnTrackingNwDst struct {
19643 *Oxm
19644 Value uint32
19645}
19646
19647type IOxmConnTrackingNwDst interface {
19648 goloxi.IOxm
19649 GetValue() uint32
19650}
19651
19652func (self *OxmConnTrackingNwDst) GetValue() uint32 {
19653 return self.Value
19654}
19655
19656func (self *OxmConnTrackingNwDst) SetValue(v uint32) {
19657 self.Value = v
19658}
19659
19660func (self *OxmConnTrackingNwDst) Serialize(encoder *goloxi.Encoder) error {
19661 if err := self.Oxm.Serialize(encoder); err != nil {
19662 return err
19663 }
19664
19665 encoder.PutUint32(uint32(self.Value))
19666
19667 return nil
19668}
19669
19670func DecodeOxmConnTrackingNwDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwDst, error) {
19671 _oxmconntrackingnwdst := &OxmConnTrackingNwDst{Oxm: parent}
19672 if decoder.Length() < 4 {
19673 return nil, fmt.Errorf("OxmConnTrackingNwDst packet too short: %d < 4", decoder.Length())
19674 }
19675 _oxmconntrackingnwdst.Value = uint32(decoder.ReadUint32())
19676 return _oxmconntrackingnwdst, nil
19677}
19678
19679func NewOxmConnTrackingNwDst() *OxmConnTrackingNwDst {
19680 obj := &OxmConnTrackingNwDst{
19681 Oxm: NewOxm(127492),
19682 }
19683 return obj
19684}
19685func (self *OxmConnTrackingNwDst) GetOXMName() string {
19686 return "conn_tracking_nw_dst"
19687}
19688
19689func (self *OxmConnTrackingNwDst) GetOXMValue() interface{} {
19690 return self.Value
19691}
19692
19693func (self *OxmConnTrackingNwDst) MarshalJSON() ([]byte, error) {
19694 value, err := jsonValue(self.GetOXMValue())
19695 if err != nil {
19696 return nil, err
19697 }
19698 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
19699}
19700
19701type OxmConnTrackingNwDstMasked struct {
19702 *Oxm
19703 Value uint32
19704 ValueMask uint32
19705}
19706
19707type IOxmConnTrackingNwDstMasked interface {
19708 goloxi.IOxm
19709 GetValue() uint32
19710 GetValueMask() uint32
19711}
19712
19713func (self *OxmConnTrackingNwDstMasked) GetValue() uint32 {
19714 return self.Value
19715}
19716
19717func (self *OxmConnTrackingNwDstMasked) SetValue(v uint32) {
19718 self.Value = v
19719}
19720
19721func (self *OxmConnTrackingNwDstMasked) GetValueMask() uint32 {
19722 return self.ValueMask
19723}
19724
19725func (self *OxmConnTrackingNwDstMasked) SetValueMask(v uint32) {
19726 self.ValueMask = v
19727}
19728
19729func (self *OxmConnTrackingNwDstMasked) Serialize(encoder *goloxi.Encoder) error {
19730 if err := self.Oxm.Serialize(encoder); err != nil {
19731 return err
19732 }
19733
19734 encoder.PutUint32(uint32(self.Value))
19735 encoder.PutUint32(uint32(self.ValueMask))
19736
19737 return nil
19738}
19739
19740func DecodeOxmConnTrackingNwDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwDstMasked, error) {
19741 _oxmconntrackingnwdstmasked := &OxmConnTrackingNwDstMasked{Oxm: parent}
19742 if decoder.Length() < 8 {
19743 return nil, fmt.Errorf("OxmConnTrackingNwDstMasked packet too short: %d < 8", decoder.Length())
19744 }
19745 _oxmconntrackingnwdstmasked.Value = uint32(decoder.ReadUint32())
19746 _oxmconntrackingnwdstmasked.ValueMask = uint32(decoder.ReadUint32())
19747 return _oxmconntrackingnwdstmasked, nil
19748}
19749
19750func NewOxmConnTrackingNwDstMasked() *OxmConnTrackingNwDstMasked {
19751 obj := &OxmConnTrackingNwDstMasked{
19752 Oxm: NewOxm(127752),
19753 }
19754 return obj
19755}
19756func (self *OxmConnTrackingNwDstMasked) GetOXMName() string {
19757 return "conn_tracking_nw_dst_masked"
19758}
19759
19760func (self *OxmConnTrackingNwDstMasked) GetOXMValue() interface{} {
19761 return self.Value
19762}
19763
19764func (self *OxmConnTrackingNwDstMasked) GetOXMValueMask() interface{} {
19765 return self.ValueMask
19766}
19767
19768func (self *OxmConnTrackingNwDstMasked) MarshalJSON() ([]byte, error) {
19769 value, err := jsonValue(self.GetOXMValue())
19770 if err != nil {
19771 return nil, err
19772 }
19773 valueMask, err := jsonValue(self.GetOXMValueMask())
19774 if err != nil {
19775 return nil, err
19776 }
19777 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
19778}
19779
19780type OxmConnTrackingNwProto struct {
19781 *Oxm
19782 Value uint8
19783}
19784
19785type IOxmConnTrackingNwProto interface {
19786 goloxi.IOxm
19787 GetValue() uint8
19788}
19789
19790func (self *OxmConnTrackingNwProto) GetValue() uint8 {
19791 return self.Value
19792}
19793
19794func (self *OxmConnTrackingNwProto) SetValue(v uint8) {
19795 self.Value = v
19796}
19797
19798func (self *OxmConnTrackingNwProto) Serialize(encoder *goloxi.Encoder) error {
19799 if err := self.Oxm.Serialize(encoder); err != nil {
19800 return err
19801 }
19802
19803 encoder.PutUint8(uint8(self.Value))
19804
19805 return nil
19806}
19807
19808func DecodeOxmConnTrackingNwProto(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwProto, error) {
19809 _oxmconntrackingnwproto := &OxmConnTrackingNwProto{Oxm: parent}
19810 if decoder.Length() < 1 {
19811 return nil, fmt.Errorf("OxmConnTrackingNwProto packet too short: %d < 1", decoder.Length())
19812 }
19813 _oxmconntrackingnwproto.Value = uint8(decoder.ReadByte())
19814 return _oxmconntrackingnwproto, nil
19815}
19816
19817func NewOxmConnTrackingNwProto() *OxmConnTrackingNwProto {
19818 obj := &OxmConnTrackingNwProto{
19819 Oxm: NewOxm(126465),
19820 }
19821 return obj
19822}
19823func (self *OxmConnTrackingNwProto) GetOXMName() string {
19824 return "conn_tracking_nw_proto"
19825}
19826
19827func (self *OxmConnTrackingNwProto) GetOXMValue() interface{} {
19828 return self.Value
19829}
19830
19831func (self *OxmConnTrackingNwProto) MarshalJSON() ([]byte, error) {
19832 value, err := jsonValue(self.GetOXMValue())
19833 if err != nil {
19834 return nil, err
19835 }
19836 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
19837}
19838
19839type OxmConnTrackingNwProtoMasked struct {
19840 *Oxm
19841 Value uint8
19842 ValueMask uint8
19843}
19844
19845type IOxmConnTrackingNwProtoMasked interface {
19846 goloxi.IOxm
19847 GetValue() uint8
19848 GetValueMask() uint8
19849}
19850
19851func (self *OxmConnTrackingNwProtoMasked) GetValue() uint8 {
19852 return self.Value
19853}
19854
19855func (self *OxmConnTrackingNwProtoMasked) SetValue(v uint8) {
19856 self.Value = v
19857}
19858
19859func (self *OxmConnTrackingNwProtoMasked) GetValueMask() uint8 {
19860 return self.ValueMask
19861}
19862
19863func (self *OxmConnTrackingNwProtoMasked) SetValueMask(v uint8) {
19864 self.ValueMask = v
19865}
19866
19867func (self *OxmConnTrackingNwProtoMasked) Serialize(encoder *goloxi.Encoder) error {
19868 if err := self.Oxm.Serialize(encoder); err != nil {
19869 return err
19870 }
19871
19872 encoder.PutUint8(uint8(self.Value))
19873 encoder.PutUint8(uint8(self.ValueMask))
19874
19875 return nil
19876}
19877
19878func DecodeOxmConnTrackingNwProtoMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwProtoMasked, error) {
19879 _oxmconntrackingnwprotomasked := &OxmConnTrackingNwProtoMasked{Oxm: parent}
19880 if decoder.Length() < 2 {
19881 return nil, fmt.Errorf("OxmConnTrackingNwProtoMasked packet too short: %d < 2", decoder.Length())
19882 }
19883 _oxmconntrackingnwprotomasked.Value = uint8(decoder.ReadByte())
19884 _oxmconntrackingnwprotomasked.ValueMask = uint8(decoder.ReadByte())
19885 return _oxmconntrackingnwprotomasked, nil
19886}
19887
19888func NewOxmConnTrackingNwProtoMasked() *OxmConnTrackingNwProtoMasked {
19889 obj := &OxmConnTrackingNwProtoMasked{
19890 Oxm: NewOxm(126722),
19891 }
19892 return obj
19893}
19894func (self *OxmConnTrackingNwProtoMasked) GetOXMName() string {
19895 return "conn_tracking_nw_proto_masked"
19896}
19897
19898func (self *OxmConnTrackingNwProtoMasked) GetOXMValue() interface{} {
19899 return self.Value
19900}
19901
19902func (self *OxmConnTrackingNwProtoMasked) GetOXMValueMask() interface{} {
19903 return self.ValueMask
19904}
19905
19906func (self *OxmConnTrackingNwProtoMasked) MarshalJSON() ([]byte, error) {
19907 value, err := jsonValue(self.GetOXMValue())
19908 if err != nil {
19909 return nil, err
19910 }
19911 valueMask, err := jsonValue(self.GetOXMValueMask())
19912 if err != nil {
19913 return nil, err
19914 }
19915 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
19916}
19917
19918type OxmConnTrackingNwSrc struct {
19919 *Oxm
19920 Value uint32
19921}
19922
19923type IOxmConnTrackingNwSrc interface {
19924 goloxi.IOxm
19925 GetValue() uint32
19926}
19927
19928func (self *OxmConnTrackingNwSrc) GetValue() uint32 {
19929 return self.Value
19930}
19931
19932func (self *OxmConnTrackingNwSrc) SetValue(v uint32) {
19933 self.Value = v
19934}
19935
19936func (self *OxmConnTrackingNwSrc) Serialize(encoder *goloxi.Encoder) error {
19937 if err := self.Oxm.Serialize(encoder); err != nil {
19938 return err
19939 }
19940
19941 encoder.PutUint32(uint32(self.Value))
19942
19943 return nil
19944}
19945
19946func DecodeOxmConnTrackingNwSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwSrc, error) {
19947 _oxmconntrackingnwsrc := &OxmConnTrackingNwSrc{Oxm: parent}
19948 if decoder.Length() < 4 {
19949 return nil, fmt.Errorf("OxmConnTrackingNwSrc packet too short: %d < 4", decoder.Length())
19950 }
19951 _oxmconntrackingnwsrc.Value = uint32(decoder.ReadUint32())
19952 return _oxmconntrackingnwsrc, nil
19953}
19954
19955func NewOxmConnTrackingNwSrc() *OxmConnTrackingNwSrc {
19956 obj := &OxmConnTrackingNwSrc{
19957 Oxm: NewOxm(126980),
19958 }
19959 return obj
19960}
19961func (self *OxmConnTrackingNwSrc) GetOXMName() string {
19962 return "conn_tracking_nw_src"
19963}
19964
19965func (self *OxmConnTrackingNwSrc) GetOXMValue() interface{} {
19966 return self.Value
19967}
19968
19969func (self *OxmConnTrackingNwSrc) MarshalJSON() ([]byte, error) {
19970 value, err := jsonValue(self.GetOXMValue())
19971 if err != nil {
19972 return nil, err
19973 }
19974 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
19975}
19976
19977type OxmConnTrackingNwSrcMasked struct {
19978 *Oxm
19979 Value uint32
19980 ValueMask uint32
19981}
19982
19983type IOxmConnTrackingNwSrcMasked interface {
19984 goloxi.IOxm
19985 GetValue() uint32
19986 GetValueMask() uint32
19987}
19988
19989func (self *OxmConnTrackingNwSrcMasked) GetValue() uint32 {
19990 return self.Value
19991}
19992
19993func (self *OxmConnTrackingNwSrcMasked) SetValue(v uint32) {
19994 self.Value = v
19995}
19996
19997func (self *OxmConnTrackingNwSrcMasked) GetValueMask() uint32 {
19998 return self.ValueMask
19999}
20000
20001func (self *OxmConnTrackingNwSrcMasked) SetValueMask(v uint32) {
20002 self.ValueMask = v
20003}
20004
20005func (self *OxmConnTrackingNwSrcMasked) Serialize(encoder *goloxi.Encoder) error {
20006 if err := self.Oxm.Serialize(encoder); err != nil {
20007 return err
20008 }
20009
20010 encoder.PutUint32(uint32(self.Value))
20011 encoder.PutUint32(uint32(self.ValueMask))
20012
20013 return nil
20014}
20015
20016func DecodeOxmConnTrackingNwSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingNwSrcMasked, error) {
20017 _oxmconntrackingnwsrcmasked := &OxmConnTrackingNwSrcMasked{Oxm: parent}
20018 if decoder.Length() < 8 {
20019 return nil, fmt.Errorf("OxmConnTrackingNwSrcMasked packet too short: %d < 8", decoder.Length())
20020 }
20021 _oxmconntrackingnwsrcmasked.Value = uint32(decoder.ReadUint32())
20022 _oxmconntrackingnwsrcmasked.ValueMask = uint32(decoder.ReadUint32())
20023 return _oxmconntrackingnwsrcmasked, nil
20024}
20025
20026func NewOxmConnTrackingNwSrcMasked() *OxmConnTrackingNwSrcMasked {
20027 obj := &OxmConnTrackingNwSrcMasked{
20028 Oxm: NewOxm(127240),
20029 }
20030 return obj
20031}
20032func (self *OxmConnTrackingNwSrcMasked) GetOXMName() string {
20033 return "conn_tracking_nw_src_masked"
20034}
20035
20036func (self *OxmConnTrackingNwSrcMasked) GetOXMValue() interface{} {
20037 return self.Value
20038}
20039
20040func (self *OxmConnTrackingNwSrcMasked) GetOXMValueMask() interface{} {
20041 return self.ValueMask
20042}
20043
20044func (self *OxmConnTrackingNwSrcMasked) MarshalJSON() ([]byte, error) {
20045 value, err := jsonValue(self.GetOXMValue())
20046 if err != nil {
20047 return nil, err
20048 }
20049 valueMask, err := jsonValue(self.GetOXMValueMask())
20050 if err != nil {
20051 return nil, err
20052 }
20053 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
20054}
20055
20056type OxmConnTrackingState struct {
20057 *Oxm
20058 Value CsStates
20059}
20060
20061type IOxmConnTrackingState interface {
20062 goloxi.IOxm
20063 GetValue() CsStates
20064}
20065
20066func (self *OxmConnTrackingState) GetValue() CsStates {
20067 return self.Value
20068}
20069
20070func (self *OxmConnTrackingState) SetValue(v CsStates) {
20071 self.Value = v
20072}
20073
20074func (self *OxmConnTrackingState) Serialize(encoder *goloxi.Encoder) error {
20075 if err := self.Oxm.Serialize(encoder); err != nil {
20076 return err
20077 }
20078
20079 encoder.PutUint32(uint32(self.Value))
20080
20081 return nil
20082}
20083
20084func DecodeOxmConnTrackingState(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingState, error) {
20085 _oxmconntrackingstate := &OxmConnTrackingState{Oxm: parent}
20086 if decoder.Length() < 4 {
20087 return nil, fmt.Errorf("OxmConnTrackingState packet too short: %d < 4", decoder.Length())
20088 }
20089 _oxmconntrackingstate.Value = CsStates(decoder.ReadUint32())
20090 return _oxmconntrackingstate, nil
20091}
20092
20093func NewOxmConnTrackingState() *OxmConnTrackingState {
20094 obj := &OxmConnTrackingState{
20095 Oxm: NewOxm(119300),
20096 }
20097 return obj
20098}
20099func (self *OxmConnTrackingState) GetOXMName() string {
20100 return "conn_tracking_state"
20101}
20102
20103func (self *OxmConnTrackingState) GetOXMValue() interface{} {
20104 return self.Value
20105}
20106
20107func (self *OxmConnTrackingState) MarshalJSON() ([]byte, error) {
20108 value, err := jsonValue(self.GetOXMValue())
20109 if err != nil {
20110 return nil, err
20111 }
20112 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
20113}
20114
20115type OxmConnTrackingStateMasked struct {
20116 *Oxm
20117 Value CsStates
20118 ValueMask CsStates
20119}
20120
20121type IOxmConnTrackingStateMasked interface {
20122 goloxi.IOxm
20123 GetValue() CsStates
20124 GetValueMask() CsStates
20125}
20126
20127func (self *OxmConnTrackingStateMasked) GetValue() CsStates {
20128 return self.Value
20129}
20130
20131func (self *OxmConnTrackingStateMasked) SetValue(v CsStates) {
20132 self.Value = v
20133}
20134
20135func (self *OxmConnTrackingStateMasked) GetValueMask() CsStates {
20136 return self.ValueMask
20137}
20138
20139func (self *OxmConnTrackingStateMasked) SetValueMask(v CsStates) {
20140 self.ValueMask = v
20141}
20142
20143func (self *OxmConnTrackingStateMasked) Serialize(encoder *goloxi.Encoder) error {
20144 if err := self.Oxm.Serialize(encoder); err != nil {
20145 return err
20146 }
20147
20148 encoder.PutUint32(uint32(self.Value))
20149 encoder.PutUint32(uint32(self.ValueMask))
20150
20151 return nil
20152}
20153
20154func DecodeOxmConnTrackingStateMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingStateMasked, error) {
20155 _oxmconntrackingstatemasked := &OxmConnTrackingStateMasked{Oxm: parent}
20156 if decoder.Length() < 8 {
20157 return nil, fmt.Errorf("OxmConnTrackingStateMasked packet too short: %d < 8", decoder.Length())
20158 }
20159 _oxmconntrackingstatemasked.Value = CsStates(decoder.ReadUint32())
20160 _oxmconntrackingstatemasked.ValueMask = CsStates(decoder.ReadUint32())
20161 return _oxmconntrackingstatemasked, nil
20162}
20163
20164func NewOxmConnTrackingStateMasked() *OxmConnTrackingStateMasked {
20165 obj := &OxmConnTrackingStateMasked{
20166 Oxm: NewOxm(119560),
20167 }
20168 return obj
20169}
20170func (self *OxmConnTrackingStateMasked) GetOXMName() string {
20171 return "conn_tracking_state_masked"
20172}
20173
20174func (self *OxmConnTrackingStateMasked) GetOXMValue() interface{} {
20175 return self.Value
20176}
20177
20178func (self *OxmConnTrackingStateMasked) GetOXMValueMask() interface{} {
20179 return self.ValueMask
20180}
20181
20182func (self *OxmConnTrackingStateMasked) MarshalJSON() ([]byte, error) {
20183 value, err := jsonValue(self.GetOXMValue())
20184 if err != nil {
20185 return nil, err
20186 }
20187 valueMask, err := jsonValue(self.GetOXMValueMask())
20188 if err != nil {
20189 return nil, err
20190 }
20191 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
20192}
20193
20194type OxmConnTrackingTpDst struct {
20195 *Oxm
20196 Value uint16
20197}
20198
20199type IOxmConnTrackingTpDst interface {
20200 goloxi.IOxm
20201 GetValue() uint16
20202}
20203
20204func (self *OxmConnTrackingTpDst) GetValue() uint16 {
20205 return self.Value
20206}
20207
20208func (self *OxmConnTrackingTpDst) SetValue(v uint16) {
20209 self.Value = v
20210}
20211
20212func (self *OxmConnTrackingTpDst) Serialize(encoder *goloxi.Encoder) error {
20213 if err := self.Oxm.Serialize(encoder); err != nil {
20214 return err
20215 }
20216
20217 encoder.PutUint16(uint16(self.Value))
20218
20219 return nil
20220}
20221
20222func DecodeOxmConnTrackingTpDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingTpDst, error) {
20223 _oxmconntrackingtpdst := &OxmConnTrackingTpDst{Oxm: parent}
20224 if decoder.Length() < 2 {
20225 return nil, fmt.Errorf("OxmConnTrackingTpDst packet too short: %d < 2", decoder.Length())
20226 }
20227 _oxmconntrackingtpdst.Value = uint16(decoder.ReadUint16())
20228 return _oxmconntrackingtpdst, nil
20229}
20230
20231func NewOxmConnTrackingTpDst() *OxmConnTrackingTpDst {
20232 obj := &OxmConnTrackingTpDst{
20233 Oxm: NewOxm(129538),
20234 }
20235 return obj
20236}
20237func (self *OxmConnTrackingTpDst) GetOXMName() string {
20238 return "conn_tracking_tp_dst"
20239}
20240
20241func (self *OxmConnTrackingTpDst) GetOXMValue() interface{} {
20242 return self.Value
20243}
20244
20245func (self *OxmConnTrackingTpDst) MarshalJSON() ([]byte, error) {
20246 value, err := jsonValue(self.GetOXMValue())
20247 if err != nil {
20248 return nil, err
20249 }
20250 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
20251}
20252
20253type OxmConnTrackingTpDstMasked struct {
20254 *Oxm
20255 Value uint16
20256 ValueMask uint16
20257}
20258
20259type IOxmConnTrackingTpDstMasked interface {
20260 goloxi.IOxm
20261 GetValue() uint16
20262 GetValueMask() uint16
20263}
20264
20265func (self *OxmConnTrackingTpDstMasked) GetValue() uint16 {
20266 return self.Value
20267}
20268
20269func (self *OxmConnTrackingTpDstMasked) SetValue(v uint16) {
20270 self.Value = v
20271}
20272
20273func (self *OxmConnTrackingTpDstMasked) GetValueMask() uint16 {
20274 return self.ValueMask
20275}
20276
20277func (self *OxmConnTrackingTpDstMasked) SetValueMask(v uint16) {
20278 self.ValueMask = v
20279}
20280
20281func (self *OxmConnTrackingTpDstMasked) Serialize(encoder *goloxi.Encoder) error {
20282 if err := self.Oxm.Serialize(encoder); err != nil {
20283 return err
20284 }
20285
20286 encoder.PutUint16(uint16(self.Value))
20287 encoder.PutUint16(uint16(self.ValueMask))
20288
20289 return nil
20290}
20291
20292func DecodeOxmConnTrackingTpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingTpDstMasked, error) {
20293 _oxmconntrackingtpdstmasked := &OxmConnTrackingTpDstMasked{Oxm: parent}
20294 if decoder.Length() < 4 {
20295 return nil, fmt.Errorf("OxmConnTrackingTpDstMasked packet too short: %d < 4", decoder.Length())
20296 }
20297 _oxmconntrackingtpdstmasked.Value = uint16(decoder.ReadUint16())
20298 _oxmconntrackingtpdstmasked.ValueMask = uint16(decoder.ReadUint16())
20299 return _oxmconntrackingtpdstmasked, nil
20300}
20301
20302func NewOxmConnTrackingTpDstMasked() *OxmConnTrackingTpDstMasked {
20303 obj := &OxmConnTrackingTpDstMasked{
20304 Oxm: NewOxm(129796),
20305 }
20306 return obj
20307}
20308func (self *OxmConnTrackingTpDstMasked) GetOXMName() string {
20309 return "conn_tracking_tp_dst_masked"
20310}
20311
20312func (self *OxmConnTrackingTpDstMasked) GetOXMValue() interface{} {
20313 return self.Value
20314}
20315
20316func (self *OxmConnTrackingTpDstMasked) GetOXMValueMask() interface{} {
20317 return self.ValueMask
20318}
20319
20320func (self *OxmConnTrackingTpDstMasked) MarshalJSON() ([]byte, error) {
20321 value, err := jsonValue(self.GetOXMValue())
20322 if err != nil {
20323 return nil, err
20324 }
20325 valueMask, err := jsonValue(self.GetOXMValueMask())
20326 if err != nil {
20327 return nil, err
20328 }
20329 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
20330}
20331
20332type OxmConnTrackingTpSrc struct {
20333 *Oxm
20334 Value uint16
20335}
20336
20337type IOxmConnTrackingTpSrc interface {
20338 goloxi.IOxm
20339 GetValue() uint16
20340}
20341
20342func (self *OxmConnTrackingTpSrc) GetValue() uint16 {
20343 return self.Value
20344}
20345
20346func (self *OxmConnTrackingTpSrc) SetValue(v uint16) {
20347 self.Value = v
20348}
20349
20350func (self *OxmConnTrackingTpSrc) Serialize(encoder *goloxi.Encoder) error {
20351 if err := self.Oxm.Serialize(encoder); err != nil {
20352 return err
20353 }
20354
20355 encoder.PutUint16(uint16(self.Value))
20356
20357 return nil
20358}
20359
20360func DecodeOxmConnTrackingTpSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingTpSrc, error) {
20361 _oxmconntrackingtpsrc := &OxmConnTrackingTpSrc{Oxm: parent}
20362 if decoder.Length() < 2 {
20363 return nil, fmt.Errorf("OxmConnTrackingTpSrc packet too short: %d < 2", decoder.Length())
20364 }
20365 _oxmconntrackingtpsrc.Value = uint16(decoder.ReadUint16())
20366 return _oxmconntrackingtpsrc, nil
20367}
20368
20369func NewOxmConnTrackingTpSrc() *OxmConnTrackingTpSrc {
20370 obj := &OxmConnTrackingTpSrc{
20371 Oxm: NewOxm(129026),
20372 }
20373 return obj
20374}
20375func (self *OxmConnTrackingTpSrc) GetOXMName() string {
20376 return "conn_tracking_tp_src"
20377}
20378
20379func (self *OxmConnTrackingTpSrc) GetOXMValue() interface{} {
20380 return self.Value
20381}
20382
20383func (self *OxmConnTrackingTpSrc) MarshalJSON() ([]byte, error) {
20384 value, err := jsonValue(self.GetOXMValue())
20385 if err != nil {
20386 return nil, err
20387 }
20388 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
20389}
20390
20391type OxmConnTrackingTpSrcMasked struct {
20392 *Oxm
20393 Value uint16
20394 ValueMask uint16
20395}
20396
20397type IOxmConnTrackingTpSrcMasked interface {
20398 goloxi.IOxm
20399 GetValue() uint16
20400 GetValueMask() uint16
20401}
20402
20403func (self *OxmConnTrackingTpSrcMasked) GetValue() uint16 {
20404 return self.Value
20405}
20406
20407func (self *OxmConnTrackingTpSrcMasked) SetValue(v uint16) {
20408 self.Value = v
20409}
20410
20411func (self *OxmConnTrackingTpSrcMasked) GetValueMask() uint16 {
20412 return self.ValueMask
20413}
20414
20415func (self *OxmConnTrackingTpSrcMasked) SetValueMask(v uint16) {
20416 self.ValueMask = v
20417}
20418
20419func (self *OxmConnTrackingTpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
20420 if err := self.Oxm.Serialize(encoder); err != nil {
20421 return err
20422 }
20423
20424 encoder.PutUint16(uint16(self.Value))
20425 encoder.PutUint16(uint16(self.ValueMask))
20426
20427 return nil
20428}
20429
20430func DecodeOxmConnTrackingTpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingTpSrcMasked, error) {
20431 _oxmconntrackingtpsrcmasked := &OxmConnTrackingTpSrcMasked{Oxm: parent}
20432 if decoder.Length() < 4 {
20433 return nil, fmt.Errorf("OxmConnTrackingTpSrcMasked packet too short: %d < 4", decoder.Length())
20434 }
20435 _oxmconntrackingtpsrcmasked.Value = uint16(decoder.ReadUint16())
20436 _oxmconntrackingtpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
20437 return _oxmconntrackingtpsrcmasked, nil
20438}
20439
20440func NewOxmConnTrackingTpSrcMasked() *OxmConnTrackingTpSrcMasked {
20441 obj := &OxmConnTrackingTpSrcMasked{
20442 Oxm: NewOxm(129284),
20443 }
20444 return obj
20445}
20446func (self *OxmConnTrackingTpSrcMasked) GetOXMName() string {
20447 return "conn_tracking_tp_src_masked"
20448}
20449
20450func (self *OxmConnTrackingTpSrcMasked) GetOXMValue() interface{} {
20451 return self.Value
20452}
20453
20454func (self *OxmConnTrackingTpSrcMasked) GetOXMValueMask() interface{} {
20455 return self.ValueMask
20456}
20457
20458func (self *OxmConnTrackingTpSrcMasked) MarshalJSON() ([]byte, error) {
20459 value, err := jsonValue(self.GetOXMValue())
20460 if err != nil {
20461 return nil, err
20462 }
20463 valueMask, err := jsonValue(self.GetOXMValueMask())
20464 if err != nil {
20465 return nil, err
20466 }
20467 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
20468}
20469
20470type OxmConnTrackingZone struct {
20471 *Oxm
20472 Value uint16
20473}
20474
20475type IOxmConnTrackingZone interface {
20476 goloxi.IOxm
20477 GetValue() uint16
20478}
20479
20480func (self *OxmConnTrackingZone) GetValue() uint16 {
20481 return self.Value
20482}
20483
20484func (self *OxmConnTrackingZone) SetValue(v uint16) {
20485 self.Value = v
20486}
20487
20488func (self *OxmConnTrackingZone) Serialize(encoder *goloxi.Encoder) error {
20489 if err := self.Oxm.Serialize(encoder); err != nil {
20490 return err
20491 }
20492
20493 encoder.PutUint16(uint16(self.Value))
20494
20495 return nil
20496}
20497
20498func DecodeOxmConnTrackingZone(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingZone, error) {
20499 _oxmconntrackingzone := &OxmConnTrackingZone{Oxm: parent}
20500 if decoder.Length() < 2 {
20501 return nil, fmt.Errorf("OxmConnTrackingZone packet too short: %d < 2", decoder.Length())
20502 }
20503 _oxmconntrackingzone.Value = uint16(decoder.ReadUint16())
20504 return _oxmconntrackingzone, nil
20505}
20506
20507func NewOxmConnTrackingZone() *OxmConnTrackingZone {
20508 obj := &OxmConnTrackingZone{
20509 Oxm: NewOxm(119810),
20510 }
20511 return obj
20512}
20513func (self *OxmConnTrackingZone) GetOXMName() string {
20514 return "conn_tracking_zone"
20515}
20516
20517func (self *OxmConnTrackingZone) GetOXMValue() interface{} {
20518 return self.Value
20519}
20520
20521func (self *OxmConnTrackingZone) MarshalJSON() ([]byte, error) {
20522 value, err := jsonValue(self.GetOXMValue())
20523 if err != nil {
20524 return nil, err
20525 }
20526 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
20527}
20528
20529type OxmConnTrackingZoneMasked struct {
20530 *Oxm
20531 Value uint16
20532 ValueMask uint16
20533}
20534
20535type IOxmConnTrackingZoneMasked interface {
20536 goloxi.IOxm
20537 GetValue() uint16
20538 GetValueMask() uint16
20539}
20540
20541func (self *OxmConnTrackingZoneMasked) GetValue() uint16 {
20542 return self.Value
20543}
20544
20545func (self *OxmConnTrackingZoneMasked) SetValue(v uint16) {
20546 self.Value = v
20547}
20548
20549func (self *OxmConnTrackingZoneMasked) GetValueMask() uint16 {
20550 return self.ValueMask
20551}
20552
20553func (self *OxmConnTrackingZoneMasked) SetValueMask(v uint16) {
20554 self.ValueMask = v
20555}
20556
20557func (self *OxmConnTrackingZoneMasked) Serialize(encoder *goloxi.Encoder) error {
20558 if err := self.Oxm.Serialize(encoder); err != nil {
20559 return err
20560 }
20561
20562 encoder.PutUint16(uint16(self.Value))
20563 encoder.PutUint16(uint16(self.ValueMask))
20564
20565 return nil
20566}
20567
20568func DecodeOxmConnTrackingZoneMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmConnTrackingZoneMasked, error) {
20569 _oxmconntrackingzonemasked := &OxmConnTrackingZoneMasked{Oxm: parent}
20570 if decoder.Length() < 4 {
20571 return nil, fmt.Errorf("OxmConnTrackingZoneMasked packet too short: %d < 4", decoder.Length())
20572 }
20573 _oxmconntrackingzonemasked.Value = uint16(decoder.ReadUint16())
20574 _oxmconntrackingzonemasked.ValueMask = uint16(decoder.ReadUint16())
20575 return _oxmconntrackingzonemasked, nil
20576}
20577
20578func NewOxmConnTrackingZoneMasked() *OxmConnTrackingZoneMasked {
20579 obj := &OxmConnTrackingZoneMasked{
20580 Oxm: NewOxm(120068),
20581 }
20582 return obj
20583}
20584func (self *OxmConnTrackingZoneMasked) GetOXMName() string {
20585 return "conn_tracking_zone_masked"
20586}
20587
20588func (self *OxmConnTrackingZoneMasked) GetOXMValue() interface{} {
20589 return self.Value
20590}
20591
20592func (self *OxmConnTrackingZoneMasked) GetOXMValueMask() interface{} {
20593 return self.ValueMask
20594}
20595
20596func (self *OxmConnTrackingZoneMasked) MarshalJSON() ([]byte, error) {
20597 value, err := jsonValue(self.GetOXMValue())
20598 if err != nil {
20599 return nil, err
20600 }
20601 valueMask, err := jsonValue(self.GetOXMValueMask())
20602 if err != nil {
20603 return nil, err
20604 }
20605 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
20606}
20607
20608type OxmEthDst struct {
20609 *Oxm
20610 Value net.HardwareAddr
20611}
20612
20613type IOxmEthDst interface {
20614 goloxi.IOxm
20615 GetValue() net.HardwareAddr
20616}
20617
20618func (self *OxmEthDst) GetValue() net.HardwareAddr {
20619 return self.Value
20620}
20621
20622func (self *OxmEthDst) SetValue(v net.HardwareAddr) {
20623 self.Value = v
20624}
20625
20626func (self *OxmEthDst) Serialize(encoder *goloxi.Encoder) error {
20627 if err := self.Oxm.Serialize(encoder); err != nil {
20628 return err
20629 }
20630
20631 encoder.Write(self.Value)
20632
20633 return nil
20634}
20635
20636func DecodeOxmEthDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthDst, error) {
20637 _oxmethdst := &OxmEthDst{Oxm: parent}
20638 if decoder.Length() < 6 {
20639 return nil, fmt.Errorf("OxmEthDst packet too short: %d < 6", decoder.Length())
20640 }
20641 _oxmethdst.Value = net.HardwareAddr(decoder.Read(6))
20642 return _oxmethdst, nil
20643}
20644
20645func NewOxmEthDst() *OxmEthDst {
20646 obj := &OxmEthDst{
20647 Oxm: NewOxm(2147485190),
20648 }
20649 return obj
20650}
20651func (self *OxmEthDst) GetOXMName() string {
20652 return "eth_dst"
20653}
20654
20655func (self *OxmEthDst) GetOXMValue() interface{} {
20656 return self.Value
20657}
20658
20659func (self *OxmEthDst) MarshalJSON() ([]byte, error) {
20660 value, err := jsonValue(self.GetOXMValue())
20661 if err != nil {
20662 return nil, err
20663 }
20664 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
20665}
20666
20667type OxmEthDstMasked struct {
20668 *Oxm
20669 Value net.HardwareAddr
20670 ValueMask net.HardwareAddr
20671}
20672
20673type IOxmEthDstMasked interface {
20674 goloxi.IOxm
20675 GetValue() net.HardwareAddr
20676 GetValueMask() net.HardwareAddr
20677}
20678
20679func (self *OxmEthDstMasked) GetValue() net.HardwareAddr {
20680 return self.Value
20681}
20682
20683func (self *OxmEthDstMasked) SetValue(v net.HardwareAddr) {
20684 self.Value = v
20685}
20686
20687func (self *OxmEthDstMasked) GetValueMask() net.HardwareAddr {
20688 return self.ValueMask
20689}
20690
20691func (self *OxmEthDstMasked) SetValueMask(v net.HardwareAddr) {
20692 self.ValueMask = v
20693}
20694
20695func (self *OxmEthDstMasked) Serialize(encoder *goloxi.Encoder) error {
20696 if err := self.Oxm.Serialize(encoder); err != nil {
20697 return err
20698 }
20699
20700 encoder.Write(self.Value)
20701 encoder.Write(self.ValueMask)
20702
20703 return nil
20704}
20705
20706func DecodeOxmEthDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthDstMasked, error) {
20707 _oxmethdstmasked := &OxmEthDstMasked{Oxm: parent}
20708 if decoder.Length() < 12 {
20709 return nil, fmt.Errorf("OxmEthDstMasked packet too short: %d < 12", decoder.Length())
20710 }
20711 _oxmethdstmasked.Value = net.HardwareAddr(decoder.Read(6))
20712 _oxmethdstmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
20713 return _oxmethdstmasked, nil
20714}
20715
20716func NewOxmEthDstMasked() *OxmEthDstMasked {
20717 obj := &OxmEthDstMasked{
20718 Oxm: NewOxm(2147485452),
20719 }
20720 return obj
20721}
20722func (self *OxmEthDstMasked) GetOXMName() string {
20723 return "eth_dst_masked"
20724}
20725
20726func (self *OxmEthDstMasked) GetOXMValue() interface{} {
20727 return self.Value
20728}
20729
20730func (self *OxmEthDstMasked) GetOXMValueMask() interface{} {
20731 return self.ValueMask
20732}
20733
20734func (self *OxmEthDstMasked) MarshalJSON() ([]byte, error) {
20735 value, err := jsonValue(self.GetOXMValue())
20736 if err != nil {
20737 return nil, err
20738 }
20739 valueMask, err := jsonValue(self.GetOXMValueMask())
20740 if err != nil {
20741 return nil, err
20742 }
20743 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
20744}
20745
20746type OxmEthSrc struct {
20747 *Oxm
20748 Value net.HardwareAddr
20749}
20750
20751type IOxmEthSrc interface {
20752 goloxi.IOxm
20753 GetValue() net.HardwareAddr
20754}
20755
20756func (self *OxmEthSrc) GetValue() net.HardwareAddr {
20757 return self.Value
20758}
20759
20760func (self *OxmEthSrc) SetValue(v net.HardwareAddr) {
20761 self.Value = v
20762}
20763
20764func (self *OxmEthSrc) Serialize(encoder *goloxi.Encoder) error {
20765 if err := self.Oxm.Serialize(encoder); err != nil {
20766 return err
20767 }
20768
20769 encoder.Write(self.Value)
20770
20771 return nil
20772}
20773
20774func DecodeOxmEthSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthSrc, error) {
20775 _oxmethsrc := &OxmEthSrc{Oxm: parent}
20776 if decoder.Length() < 6 {
20777 return nil, fmt.Errorf("OxmEthSrc packet too short: %d < 6", decoder.Length())
20778 }
20779 _oxmethsrc.Value = net.HardwareAddr(decoder.Read(6))
20780 return _oxmethsrc, nil
20781}
20782
20783func NewOxmEthSrc() *OxmEthSrc {
20784 obj := &OxmEthSrc{
20785 Oxm: NewOxm(2147485702),
20786 }
20787 return obj
20788}
20789func (self *OxmEthSrc) GetOXMName() string {
20790 return "eth_src"
20791}
20792
20793func (self *OxmEthSrc) GetOXMValue() interface{} {
20794 return self.Value
20795}
20796
20797func (self *OxmEthSrc) MarshalJSON() ([]byte, error) {
20798 value, err := jsonValue(self.GetOXMValue())
20799 if err != nil {
20800 return nil, err
20801 }
20802 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
20803}
20804
20805type OxmEthSrcMasked struct {
20806 *Oxm
20807 Value net.HardwareAddr
20808 ValueMask net.HardwareAddr
20809}
20810
20811type IOxmEthSrcMasked interface {
20812 goloxi.IOxm
20813 GetValue() net.HardwareAddr
20814 GetValueMask() net.HardwareAddr
20815}
20816
20817func (self *OxmEthSrcMasked) GetValue() net.HardwareAddr {
20818 return self.Value
20819}
20820
20821func (self *OxmEthSrcMasked) SetValue(v net.HardwareAddr) {
20822 self.Value = v
20823}
20824
20825func (self *OxmEthSrcMasked) GetValueMask() net.HardwareAddr {
20826 return self.ValueMask
20827}
20828
20829func (self *OxmEthSrcMasked) SetValueMask(v net.HardwareAddr) {
20830 self.ValueMask = v
20831}
20832
20833func (self *OxmEthSrcMasked) Serialize(encoder *goloxi.Encoder) error {
20834 if err := self.Oxm.Serialize(encoder); err != nil {
20835 return err
20836 }
20837
20838 encoder.Write(self.Value)
20839 encoder.Write(self.ValueMask)
20840
20841 return nil
20842}
20843
20844func DecodeOxmEthSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthSrcMasked, error) {
20845 _oxmethsrcmasked := &OxmEthSrcMasked{Oxm: parent}
20846 if decoder.Length() < 12 {
20847 return nil, fmt.Errorf("OxmEthSrcMasked packet too short: %d < 12", decoder.Length())
20848 }
20849 _oxmethsrcmasked.Value = net.HardwareAddr(decoder.Read(6))
20850 _oxmethsrcmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
20851 return _oxmethsrcmasked, nil
20852}
20853
20854func NewOxmEthSrcMasked() *OxmEthSrcMasked {
20855 obj := &OxmEthSrcMasked{
20856 Oxm: NewOxm(2147485964),
20857 }
20858 return obj
20859}
20860func (self *OxmEthSrcMasked) GetOXMName() string {
20861 return "eth_src_masked"
20862}
20863
20864func (self *OxmEthSrcMasked) GetOXMValue() interface{} {
20865 return self.Value
20866}
20867
20868func (self *OxmEthSrcMasked) GetOXMValueMask() interface{} {
20869 return self.ValueMask
20870}
20871
20872func (self *OxmEthSrcMasked) MarshalJSON() ([]byte, error) {
20873 value, err := jsonValue(self.GetOXMValue())
20874 if err != nil {
20875 return nil, err
20876 }
20877 valueMask, err := jsonValue(self.GetOXMValueMask())
20878 if err != nil {
20879 return nil, err
20880 }
20881 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
20882}
20883
20884type OxmEthType struct {
20885 *Oxm
20886 Value EthernetType
20887}
20888
20889type IOxmEthType interface {
20890 goloxi.IOxm
20891 GetValue() EthernetType
20892}
20893
20894func (self *OxmEthType) GetValue() EthernetType {
20895 return self.Value
20896}
20897
20898func (self *OxmEthType) SetValue(v EthernetType) {
20899 self.Value = v
20900}
20901
20902func (self *OxmEthType) Serialize(encoder *goloxi.Encoder) error {
20903 if err := self.Oxm.Serialize(encoder); err != nil {
20904 return err
20905 }
20906
20907 encoder.PutUint16(uint16(self.Value))
20908
20909 return nil
20910}
20911
20912func DecodeOxmEthType(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthType, error) {
20913 _oxmethtype := &OxmEthType{Oxm: parent}
20914 if decoder.Length() < 2 {
20915 return nil, fmt.Errorf("OxmEthType packet too short: %d < 2", decoder.Length())
20916 }
20917 _oxmethtype.Value = EthernetType(decoder.ReadUint16())
20918 return _oxmethtype, nil
20919}
20920
20921func NewOxmEthType() *OxmEthType {
20922 obj := &OxmEthType{
20923 Oxm: NewOxm(2147486210),
20924 }
20925 return obj
20926}
20927func (self *OxmEthType) GetOXMName() string {
20928 return "eth_type"
20929}
20930
20931func (self *OxmEthType) GetOXMValue() interface{} {
20932 return self.Value
20933}
20934
20935func (self *OxmEthType) MarshalJSON() ([]byte, error) {
20936 value, err := jsonValue(self.GetOXMValue())
20937 if err != nil {
20938 return nil, err
20939 }
20940 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
20941}
20942
20943type OxmEthTypeMasked struct {
20944 *Oxm
20945 Value EthernetType
20946 ValueMask uint16
20947}
20948
20949type IOxmEthTypeMasked interface {
20950 goloxi.IOxm
20951 GetValue() EthernetType
20952 GetValueMask() uint16
20953}
20954
20955func (self *OxmEthTypeMasked) GetValue() EthernetType {
20956 return self.Value
20957}
20958
20959func (self *OxmEthTypeMasked) SetValue(v EthernetType) {
20960 self.Value = v
20961}
20962
20963func (self *OxmEthTypeMasked) GetValueMask() uint16 {
20964 return self.ValueMask
20965}
20966
20967func (self *OxmEthTypeMasked) SetValueMask(v uint16) {
20968 self.ValueMask = v
20969}
20970
20971func (self *OxmEthTypeMasked) Serialize(encoder *goloxi.Encoder) error {
20972 if err := self.Oxm.Serialize(encoder); err != nil {
20973 return err
20974 }
20975
20976 encoder.PutUint16(uint16(self.Value))
20977 encoder.PutUint16(uint16(self.ValueMask))
20978
20979 return nil
20980}
20981
20982func DecodeOxmEthTypeMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmEthTypeMasked, error) {
20983 _oxmethtypemasked := &OxmEthTypeMasked{Oxm: parent}
20984 if decoder.Length() < 4 {
20985 return nil, fmt.Errorf("OxmEthTypeMasked packet too short: %d < 4", decoder.Length())
20986 }
20987 _oxmethtypemasked.Value = EthernetType(decoder.ReadUint16())
20988 _oxmethtypemasked.ValueMask = uint16(decoder.ReadUint16())
20989 return _oxmethtypemasked, nil
20990}
20991
20992func NewOxmEthTypeMasked() *OxmEthTypeMasked {
20993 obj := &OxmEthTypeMasked{
20994 Oxm: NewOxm(2147486468),
20995 }
20996 return obj
20997}
20998func (self *OxmEthTypeMasked) GetOXMName() string {
20999 return "eth_type_masked"
21000}
21001
21002func (self *OxmEthTypeMasked) GetOXMValue() interface{} {
21003 return self.Value
21004}
21005
21006func (self *OxmEthTypeMasked) GetOXMValueMask() interface{} {
21007 return self.ValueMask
21008}
21009
21010func (self *OxmEthTypeMasked) MarshalJSON() ([]byte, error) {
21011 value, err := jsonValue(self.GetOXMValue())
21012 if err != nil {
21013 return nil, err
21014 }
21015 valueMask, err := jsonValue(self.GetOXMValueMask())
21016 if err != nil {
21017 return nil, err
21018 }
21019 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
21020}
21021
21022type OxmIcmpv4Code struct {
21023 *Oxm
21024 Value uint8
21025}
21026
21027type IOxmIcmpv4Code interface {
21028 goloxi.IOxm
21029 GetValue() uint8
21030}
21031
21032func (self *OxmIcmpv4Code) GetValue() uint8 {
21033 return self.Value
21034}
21035
21036func (self *OxmIcmpv4Code) SetValue(v uint8) {
21037 self.Value = v
21038}
21039
21040func (self *OxmIcmpv4Code) Serialize(encoder *goloxi.Encoder) error {
21041 if err := self.Oxm.Serialize(encoder); err != nil {
21042 return err
21043 }
21044
21045 encoder.PutUint8(uint8(self.Value))
21046
21047 return nil
21048}
21049
21050func DecodeOxmIcmpv4Code(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv4Code, error) {
21051 _oxmicmpv4code := &OxmIcmpv4Code{Oxm: parent}
21052 if decoder.Length() < 1 {
21053 return nil, fmt.Errorf("OxmIcmpv4Code packet too short: %d < 1", decoder.Length())
21054 }
21055 _oxmicmpv4code.Value = uint8(decoder.ReadByte())
21056 return _oxmicmpv4code, nil
21057}
21058
21059func NewOxmIcmpv4Code() *OxmIcmpv4Code {
21060 obj := &OxmIcmpv4Code{
21061 Oxm: NewOxm(2147493889),
21062 }
21063 return obj
21064}
21065func (self *OxmIcmpv4Code) GetOXMName() string {
21066 return "icmpv4_code"
21067}
21068
21069func (self *OxmIcmpv4Code) GetOXMValue() interface{} {
21070 return self.Value
21071}
21072
21073func (self *OxmIcmpv4Code) MarshalJSON() ([]byte, error) {
21074 value, err := jsonValue(self.GetOXMValue())
21075 if err != nil {
21076 return nil, err
21077 }
21078 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
21079}
21080
21081type OxmIcmpv4CodeMasked struct {
21082 *Oxm
21083 Value uint8
21084 ValueMask uint8
21085}
21086
21087type IOxmIcmpv4CodeMasked interface {
21088 goloxi.IOxm
21089 GetValue() uint8
21090 GetValueMask() uint8
21091}
21092
21093func (self *OxmIcmpv4CodeMasked) GetValue() uint8 {
21094 return self.Value
21095}
21096
21097func (self *OxmIcmpv4CodeMasked) SetValue(v uint8) {
21098 self.Value = v
21099}
21100
21101func (self *OxmIcmpv4CodeMasked) GetValueMask() uint8 {
21102 return self.ValueMask
21103}
21104
21105func (self *OxmIcmpv4CodeMasked) SetValueMask(v uint8) {
21106 self.ValueMask = v
21107}
21108
21109func (self *OxmIcmpv4CodeMasked) Serialize(encoder *goloxi.Encoder) error {
21110 if err := self.Oxm.Serialize(encoder); err != nil {
21111 return err
21112 }
21113
21114 encoder.PutUint8(uint8(self.Value))
21115 encoder.PutUint8(uint8(self.ValueMask))
21116
21117 return nil
21118}
21119
21120func DecodeOxmIcmpv4CodeMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv4CodeMasked, error) {
21121 _oxmicmpv4codemasked := &OxmIcmpv4CodeMasked{Oxm: parent}
21122 if decoder.Length() < 2 {
21123 return nil, fmt.Errorf("OxmIcmpv4CodeMasked packet too short: %d < 2", decoder.Length())
21124 }
21125 _oxmicmpv4codemasked.Value = uint8(decoder.ReadByte())
21126 _oxmicmpv4codemasked.ValueMask = uint8(decoder.ReadByte())
21127 return _oxmicmpv4codemasked, nil
21128}
21129
21130func NewOxmIcmpv4CodeMasked() *OxmIcmpv4CodeMasked {
21131 obj := &OxmIcmpv4CodeMasked{
21132 Oxm: NewOxm(2147494146),
21133 }
21134 return obj
21135}
21136func (self *OxmIcmpv4CodeMasked) GetOXMName() string {
21137 return "icmpv4_code_masked"
21138}
21139
21140func (self *OxmIcmpv4CodeMasked) GetOXMValue() interface{} {
21141 return self.Value
21142}
21143
21144func (self *OxmIcmpv4CodeMasked) GetOXMValueMask() interface{} {
21145 return self.ValueMask
21146}
21147
21148func (self *OxmIcmpv4CodeMasked) MarshalJSON() ([]byte, error) {
21149 value, err := jsonValue(self.GetOXMValue())
21150 if err != nil {
21151 return nil, err
21152 }
21153 valueMask, err := jsonValue(self.GetOXMValueMask())
21154 if err != nil {
21155 return nil, err
21156 }
21157 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
21158}
21159
21160type OxmIcmpv4Type struct {
21161 *Oxm
21162 Value IcmpType
21163}
21164
21165type IOxmIcmpv4Type interface {
21166 goloxi.IOxm
21167 GetValue() IcmpType
21168}
21169
21170func (self *OxmIcmpv4Type) GetValue() IcmpType {
21171 return self.Value
21172}
21173
21174func (self *OxmIcmpv4Type) SetValue(v IcmpType) {
21175 self.Value = v
21176}
21177
21178func (self *OxmIcmpv4Type) Serialize(encoder *goloxi.Encoder) error {
21179 if err := self.Oxm.Serialize(encoder); err != nil {
21180 return err
21181 }
21182
21183 encoder.PutUint8(uint8(self.Value))
21184
21185 return nil
21186}
21187
21188func DecodeOxmIcmpv4Type(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv4Type, error) {
21189 _oxmicmpv4type := &OxmIcmpv4Type{Oxm: parent}
21190 if decoder.Length() < 1 {
21191 return nil, fmt.Errorf("OxmIcmpv4Type packet too short: %d < 1", decoder.Length())
21192 }
21193 _oxmicmpv4type.Value = IcmpType(decoder.ReadByte())
21194 return _oxmicmpv4type, nil
21195}
21196
21197func NewOxmIcmpv4Type() *OxmIcmpv4Type {
21198 obj := &OxmIcmpv4Type{
21199 Oxm: NewOxm(2147493377),
21200 }
21201 return obj
21202}
21203func (self *OxmIcmpv4Type) GetOXMName() string {
21204 return "icmpv4_type"
21205}
21206
21207func (self *OxmIcmpv4Type) GetOXMValue() interface{} {
21208 return self.Value
21209}
21210
21211func (self *OxmIcmpv4Type) MarshalJSON() ([]byte, error) {
21212 value, err := jsonValue(self.GetOXMValue())
21213 if err != nil {
21214 return nil, err
21215 }
21216 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
21217}
21218
21219type OxmIcmpv4TypeMasked struct {
21220 *Oxm
21221 Value IcmpType
21222 ValueMask uint8
21223}
21224
21225type IOxmIcmpv4TypeMasked interface {
21226 goloxi.IOxm
21227 GetValue() IcmpType
21228 GetValueMask() uint8
21229}
21230
21231func (self *OxmIcmpv4TypeMasked) GetValue() IcmpType {
21232 return self.Value
21233}
21234
21235func (self *OxmIcmpv4TypeMasked) SetValue(v IcmpType) {
21236 self.Value = v
21237}
21238
21239func (self *OxmIcmpv4TypeMasked) GetValueMask() uint8 {
21240 return self.ValueMask
21241}
21242
21243func (self *OxmIcmpv4TypeMasked) SetValueMask(v uint8) {
21244 self.ValueMask = v
21245}
21246
21247func (self *OxmIcmpv4TypeMasked) Serialize(encoder *goloxi.Encoder) error {
21248 if err := self.Oxm.Serialize(encoder); err != nil {
21249 return err
21250 }
21251
21252 encoder.PutUint8(uint8(self.Value))
21253 encoder.PutUint8(uint8(self.ValueMask))
21254
21255 return nil
21256}
21257
21258func DecodeOxmIcmpv4TypeMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv4TypeMasked, error) {
21259 _oxmicmpv4typemasked := &OxmIcmpv4TypeMasked{Oxm: parent}
21260 if decoder.Length() < 2 {
21261 return nil, fmt.Errorf("OxmIcmpv4TypeMasked packet too short: %d < 2", decoder.Length())
21262 }
21263 _oxmicmpv4typemasked.Value = IcmpType(decoder.ReadByte())
21264 _oxmicmpv4typemasked.ValueMask = uint8(decoder.ReadByte())
21265 return _oxmicmpv4typemasked, nil
21266}
21267
21268func NewOxmIcmpv4TypeMasked() *OxmIcmpv4TypeMasked {
21269 obj := &OxmIcmpv4TypeMasked{
21270 Oxm: NewOxm(2147493634),
21271 }
21272 return obj
21273}
21274func (self *OxmIcmpv4TypeMasked) GetOXMName() string {
21275 return "icmpv4_type_masked"
21276}
21277
21278func (self *OxmIcmpv4TypeMasked) GetOXMValue() interface{} {
21279 return self.Value
21280}
21281
21282func (self *OxmIcmpv4TypeMasked) GetOXMValueMask() interface{} {
21283 return self.ValueMask
21284}
21285
21286func (self *OxmIcmpv4TypeMasked) MarshalJSON() ([]byte, error) {
21287 value, err := jsonValue(self.GetOXMValue())
21288 if err != nil {
21289 return nil, err
21290 }
21291 valueMask, err := jsonValue(self.GetOXMValueMask())
21292 if err != nil {
21293 return nil, err
21294 }
21295 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
21296}
21297
21298type OxmIcmpv6Code struct {
21299 *Oxm
21300 Value uint8
21301}
21302
21303type IOxmIcmpv6Code interface {
21304 goloxi.IOxm
21305 GetValue() uint8
21306}
21307
21308func (self *OxmIcmpv6Code) GetValue() uint8 {
21309 return self.Value
21310}
21311
21312func (self *OxmIcmpv6Code) SetValue(v uint8) {
21313 self.Value = v
21314}
21315
21316func (self *OxmIcmpv6Code) Serialize(encoder *goloxi.Encoder) error {
21317 if err := self.Oxm.Serialize(encoder); err != nil {
21318 return err
21319 }
21320
21321 encoder.PutUint8(uint8(self.Value))
21322
21323 return nil
21324}
21325
21326func DecodeOxmIcmpv6Code(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv6Code, error) {
21327 _oxmicmpv6code := &OxmIcmpv6Code{Oxm: parent}
21328 if decoder.Length() < 1 {
21329 return nil, fmt.Errorf("OxmIcmpv6Code packet too short: %d < 1", decoder.Length())
21330 }
21331 _oxmicmpv6code.Value = uint8(decoder.ReadByte())
21332 return _oxmicmpv6code, nil
21333}
21334
21335func NewOxmIcmpv6Code() *OxmIcmpv6Code {
21336 obj := &OxmIcmpv6Code{
21337 Oxm: NewOxm(2147499009),
21338 }
21339 return obj
21340}
21341func (self *OxmIcmpv6Code) GetOXMName() string {
21342 return "icmpv6_code"
21343}
21344
21345func (self *OxmIcmpv6Code) GetOXMValue() interface{} {
21346 return self.Value
21347}
21348
21349func (self *OxmIcmpv6Code) MarshalJSON() ([]byte, error) {
21350 value, err := jsonValue(self.GetOXMValue())
21351 if err != nil {
21352 return nil, err
21353 }
21354 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
21355}
21356
21357type OxmIcmpv6CodeMasked struct {
21358 *Oxm
21359 Value uint8
21360 ValueMask uint8
21361}
21362
21363type IOxmIcmpv6CodeMasked interface {
21364 goloxi.IOxm
21365 GetValue() uint8
21366 GetValueMask() uint8
21367}
21368
21369func (self *OxmIcmpv6CodeMasked) GetValue() uint8 {
21370 return self.Value
21371}
21372
21373func (self *OxmIcmpv6CodeMasked) SetValue(v uint8) {
21374 self.Value = v
21375}
21376
21377func (self *OxmIcmpv6CodeMasked) GetValueMask() uint8 {
21378 return self.ValueMask
21379}
21380
21381func (self *OxmIcmpv6CodeMasked) SetValueMask(v uint8) {
21382 self.ValueMask = v
21383}
21384
21385func (self *OxmIcmpv6CodeMasked) Serialize(encoder *goloxi.Encoder) error {
21386 if err := self.Oxm.Serialize(encoder); err != nil {
21387 return err
21388 }
21389
21390 encoder.PutUint8(uint8(self.Value))
21391 encoder.PutUint8(uint8(self.ValueMask))
21392
21393 return nil
21394}
21395
21396func DecodeOxmIcmpv6CodeMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv6CodeMasked, error) {
21397 _oxmicmpv6codemasked := &OxmIcmpv6CodeMasked{Oxm: parent}
21398 if decoder.Length() < 2 {
21399 return nil, fmt.Errorf("OxmIcmpv6CodeMasked packet too short: %d < 2", decoder.Length())
21400 }
21401 _oxmicmpv6codemasked.Value = uint8(decoder.ReadByte())
21402 _oxmicmpv6codemasked.ValueMask = uint8(decoder.ReadByte())
21403 return _oxmicmpv6codemasked, nil
21404}
21405
21406func NewOxmIcmpv6CodeMasked() *OxmIcmpv6CodeMasked {
21407 obj := &OxmIcmpv6CodeMasked{
21408 Oxm: NewOxm(2147499266),
21409 }
21410 return obj
21411}
21412func (self *OxmIcmpv6CodeMasked) GetOXMName() string {
21413 return "icmpv6_code_masked"
21414}
21415
21416func (self *OxmIcmpv6CodeMasked) GetOXMValue() interface{} {
21417 return self.Value
21418}
21419
21420func (self *OxmIcmpv6CodeMasked) GetOXMValueMask() interface{} {
21421 return self.ValueMask
21422}
21423
21424func (self *OxmIcmpv6CodeMasked) MarshalJSON() ([]byte, error) {
21425 value, err := jsonValue(self.GetOXMValue())
21426 if err != nil {
21427 return nil, err
21428 }
21429 valueMask, err := jsonValue(self.GetOXMValueMask())
21430 if err != nil {
21431 return nil, err
21432 }
21433 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
21434}
21435
21436type OxmIcmpv6Type struct {
21437 *Oxm
21438 Value Icmpv6Type
21439}
21440
21441type IOxmIcmpv6Type interface {
21442 goloxi.IOxm
21443 GetValue() Icmpv6Type
21444}
21445
21446func (self *OxmIcmpv6Type) GetValue() Icmpv6Type {
21447 return self.Value
21448}
21449
21450func (self *OxmIcmpv6Type) SetValue(v Icmpv6Type) {
21451 self.Value = v
21452}
21453
21454func (self *OxmIcmpv6Type) Serialize(encoder *goloxi.Encoder) error {
21455 if err := self.Oxm.Serialize(encoder); err != nil {
21456 return err
21457 }
21458
21459 encoder.PutUint8(uint8(self.Value))
21460
21461 return nil
21462}
21463
21464func DecodeOxmIcmpv6Type(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv6Type, error) {
21465 _oxmicmpv6type := &OxmIcmpv6Type{Oxm: parent}
21466 if decoder.Length() < 1 {
21467 return nil, fmt.Errorf("OxmIcmpv6Type packet too short: %d < 1", decoder.Length())
21468 }
21469 _oxmicmpv6type.Value = Icmpv6Type(decoder.ReadByte())
21470 return _oxmicmpv6type, nil
21471}
21472
21473func NewOxmIcmpv6Type() *OxmIcmpv6Type {
21474 obj := &OxmIcmpv6Type{
21475 Oxm: NewOxm(2147498497),
21476 }
21477 return obj
21478}
21479func (self *OxmIcmpv6Type) GetOXMName() string {
21480 return "icmpv6_type"
21481}
21482
21483func (self *OxmIcmpv6Type) GetOXMValue() interface{} {
21484 return self.Value
21485}
21486
21487func (self *OxmIcmpv6Type) MarshalJSON() ([]byte, error) {
21488 value, err := jsonValue(self.GetOXMValue())
21489 if err != nil {
21490 return nil, err
21491 }
21492 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
21493}
21494
21495type OxmIcmpv6TypeMasked struct {
21496 *Oxm
21497 Value Icmpv6Type
21498 ValueMask uint8
21499}
21500
21501type IOxmIcmpv6TypeMasked interface {
21502 goloxi.IOxm
21503 GetValue() Icmpv6Type
21504 GetValueMask() uint8
21505}
21506
21507func (self *OxmIcmpv6TypeMasked) GetValue() Icmpv6Type {
21508 return self.Value
21509}
21510
21511func (self *OxmIcmpv6TypeMasked) SetValue(v Icmpv6Type) {
21512 self.Value = v
21513}
21514
21515func (self *OxmIcmpv6TypeMasked) GetValueMask() uint8 {
21516 return self.ValueMask
21517}
21518
21519func (self *OxmIcmpv6TypeMasked) SetValueMask(v uint8) {
21520 self.ValueMask = v
21521}
21522
21523func (self *OxmIcmpv6TypeMasked) Serialize(encoder *goloxi.Encoder) error {
21524 if err := self.Oxm.Serialize(encoder); err != nil {
21525 return err
21526 }
21527
21528 encoder.PutUint8(uint8(self.Value))
21529 encoder.PutUint8(uint8(self.ValueMask))
21530
21531 return nil
21532}
21533
21534func DecodeOxmIcmpv6TypeMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIcmpv6TypeMasked, error) {
21535 _oxmicmpv6typemasked := &OxmIcmpv6TypeMasked{Oxm: parent}
21536 if decoder.Length() < 2 {
21537 return nil, fmt.Errorf("OxmIcmpv6TypeMasked packet too short: %d < 2", decoder.Length())
21538 }
21539 _oxmicmpv6typemasked.Value = Icmpv6Type(decoder.ReadByte())
21540 _oxmicmpv6typemasked.ValueMask = uint8(decoder.ReadByte())
21541 return _oxmicmpv6typemasked, nil
21542}
21543
21544func NewOxmIcmpv6TypeMasked() *OxmIcmpv6TypeMasked {
21545 obj := &OxmIcmpv6TypeMasked{
21546 Oxm: NewOxm(2147498754),
21547 }
21548 return obj
21549}
21550func (self *OxmIcmpv6TypeMasked) GetOXMName() string {
21551 return "icmpv6_type_masked"
21552}
21553
21554func (self *OxmIcmpv6TypeMasked) GetOXMValue() interface{} {
21555 return self.Value
21556}
21557
21558func (self *OxmIcmpv6TypeMasked) GetOXMValueMask() interface{} {
21559 return self.ValueMask
21560}
21561
21562func (self *OxmIcmpv6TypeMasked) MarshalJSON() ([]byte, error) {
21563 value, err := jsonValue(self.GetOXMValue())
21564 if err != nil {
21565 return nil, err
21566 }
21567 valueMask, err := jsonValue(self.GetOXMValueMask())
21568 if err != nil {
21569 return nil, err
21570 }
21571 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
21572}
21573
21574type OxmInPhyPort struct {
21575 *Oxm
21576 Value Port
21577}
21578
21579type IOxmInPhyPort interface {
21580 goloxi.IOxm
21581 GetValue() Port
21582}
21583
21584func (self *OxmInPhyPort) GetValue() Port {
21585 return self.Value
21586}
21587
21588func (self *OxmInPhyPort) SetValue(v Port) {
21589 self.Value = v
21590}
21591
21592func (self *OxmInPhyPort) Serialize(encoder *goloxi.Encoder) error {
21593 if err := self.Oxm.Serialize(encoder); err != nil {
21594 return err
21595 }
21596
21597 self.Value.Serialize(encoder)
21598
21599 return nil
21600}
21601
21602func DecodeOxmInPhyPort(parent *Oxm, decoder *goloxi.Decoder) (*OxmInPhyPort, error) {
21603 _oxminphyport := &OxmInPhyPort{Oxm: parent}
21604 if decoder.Length() < 2 {
21605 return nil, fmt.Errorf("OxmInPhyPort packet too short: %d < 2", decoder.Length())
21606 }
21607 _oxminphyport.Value.Decode(decoder)
21608 return _oxminphyport, nil
21609}
21610
21611func NewOxmInPhyPort() *OxmInPhyPort {
21612 obj := &OxmInPhyPort{
21613 Oxm: NewOxm(2147484164),
21614 }
21615 return obj
21616}
21617func (self *OxmInPhyPort) GetOXMName() string {
21618 return "in_phy_port"
21619}
21620
21621func (self *OxmInPhyPort) GetOXMValue() interface{} {
21622 return self.Value
21623}
21624
21625func (self *OxmInPhyPort) MarshalJSON() ([]byte, error) {
21626 value, err := jsonValue(self.GetOXMValue())
21627 if err != nil {
21628 return nil, err
21629 }
21630 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
21631}
21632
21633type OxmInPhyPortMasked struct {
21634 *Oxm
21635 Value Port
21636 ValueMask Port
21637}
21638
21639type IOxmInPhyPortMasked interface {
21640 goloxi.IOxm
21641 GetValue() Port
21642 GetValueMask() Port
21643}
21644
21645func (self *OxmInPhyPortMasked) GetValue() Port {
21646 return self.Value
21647}
21648
21649func (self *OxmInPhyPortMasked) SetValue(v Port) {
21650 self.Value = v
21651}
21652
21653func (self *OxmInPhyPortMasked) GetValueMask() Port {
21654 return self.ValueMask
21655}
21656
21657func (self *OxmInPhyPortMasked) SetValueMask(v Port) {
21658 self.ValueMask = v
21659}
21660
21661func (self *OxmInPhyPortMasked) Serialize(encoder *goloxi.Encoder) error {
21662 if err := self.Oxm.Serialize(encoder); err != nil {
21663 return err
21664 }
21665
21666 self.Value.Serialize(encoder)
21667 self.ValueMask.Serialize(encoder)
21668
21669 return nil
21670}
21671
21672func DecodeOxmInPhyPortMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmInPhyPortMasked, error) {
21673 _oxminphyportmasked := &OxmInPhyPortMasked{Oxm: parent}
21674 if decoder.Length() < 4 {
21675 return nil, fmt.Errorf("OxmInPhyPortMasked packet too short: %d < 4", decoder.Length())
21676 }
21677 _oxminphyportmasked.Value.Decode(decoder)
21678 _oxminphyportmasked.ValueMask.Decode(decoder)
21679 return _oxminphyportmasked, nil
21680}
21681
21682func NewOxmInPhyPortMasked() *OxmInPhyPortMasked {
21683 obj := &OxmInPhyPortMasked{
21684 Oxm: NewOxm(2147484424),
21685 }
21686 return obj
21687}
21688func (self *OxmInPhyPortMasked) GetOXMName() string {
21689 return "in_phy_port_masked"
21690}
21691
21692func (self *OxmInPhyPortMasked) GetOXMValue() interface{} {
21693 return self.Value
21694}
21695
21696func (self *OxmInPhyPortMasked) GetOXMValueMask() interface{} {
21697 return self.ValueMask
21698}
21699
21700func (self *OxmInPhyPortMasked) MarshalJSON() ([]byte, error) {
21701 value, err := jsonValue(self.GetOXMValue())
21702 if err != nil {
21703 return nil, err
21704 }
21705 valueMask, err := jsonValue(self.GetOXMValueMask())
21706 if err != nil {
21707 return nil, err
21708 }
21709 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
21710}
21711
21712type OxmInPort struct {
21713 *Oxm
21714 Value Port
21715}
21716
21717type IOxmInPort interface {
21718 goloxi.IOxm
21719 GetValue() Port
21720}
21721
21722func (self *OxmInPort) GetValue() Port {
21723 return self.Value
21724}
21725
21726func (self *OxmInPort) SetValue(v Port) {
21727 self.Value = v
21728}
21729
21730func (self *OxmInPort) Serialize(encoder *goloxi.Encoder) error {
21731 if err := self.Oxm.Serialize(encoder); err != nil {
21732 return err
21733 }
21734
21735 self.Value.Serialize(encoder)
21736
21737 return nil
21738}
21739
21740func DecodeOxmInPort(parent *Oxm, decoder *goloxi.Decoder) (*OxmInPort, error) {
21741 _oxminport := &OxmInPort{Oxm: parent}
21742 if decoder.Length() < 2 {
21743 return nil, fmt.Errorf("OxmInPort packet too short: %d < 2", decoder.Length())
21744 }
21745 _oxminport.Value.Decode(decoder)
21746 return _oxminport, nil
21747}
21748
21749func NewOxmInPort() *OxmInPort {
21750 obj := &OxmInPort{
21751 Oxm: NewOxm(2147483652),
21752 }
21753 return obj
21754}
21755func (self *OxmInPort) GetOXMName() string {
21756 return "in_port"
21757}
21758
21759func (self *OxmInPort) GetOXMValue() interface{} {
21760 return self.Value
21761}
21762
21763func (self *OxmInPort) MarshalJSON() ([]byte, error) {
21764 value, err := jsonValue(self.GetOXMValue())
21765 if err != nil {
21766 return nil, err
21767 }
21768 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
21769}
21770
21771type OxmInPortMasked struct {
21772 *Oxm
21773 Value Port
21774 ValueMask Port
21775}
21776
21777type IOxmInPortMasked interface {
21778 goloxi.IOxm
21779 GetValue() Port
21780 GetValueMask() Port
21781}
21782
21783func (self *OxmInPortMasked) GetValue() Port {
21784 return self.Value
21785}
21786
21787func (self *OxmInPortMasked) SetValue(v Port) {
21788 self.Value = v
21789}
21790
21791func (self *OxmInPortMasked) GetValueMask() Port {
21792 return self.ValueMask
21793}
21794
21795func (self *OxmInPortMasked) SetValueMask(v Port) {
21796 self.ValueMask = v
21797}
21798
21799func (self *OxmInPortMasked) Serialize(encoder *goloxi.Encoder) error {
21800 if err := self.Oxm.Serialize(encoder); err != nil {
21801 return err
21802 }
21803
21804 self.Value.Serialize(encoder)
21805 self.ValueMask.Serialize(encoder)
21806
21807 return nil
21808}
21809
21810func DecodeOxmInPortMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmInPortMasked, error) {
21811 _oxminportmasked := &OxmInPortMasked{Oxm: parent}
21812 if decoder.Length() < 4 {
21813 return nil, fmt.Errorf("OxmInPortMasked packet too short: %d < 4", decoder.Length())
21814 }
21815 _oxminportmasked.Value.Decode(decoder)
21816 _oxminportmasked.ValueMask.Decode(decoder)
21817 return _oxminportmasked, nil
21818}
21819
21820func NewOxmInPortMasked() *OxmInPortMasked {
21821 obj := &OxmInPortMasked{
21822 Oxm: NewOxm(2147483912),
21823 }
21824 return obj
21825}
21826func (self *OxmInPortMasked) GetOXMName() string {
21827 return "in_port_masked"
21828}
21829
21830func (self *OxmInPortMasked) GetOXMValue() interface{} {
21831 return self.Value
21832}
21833
21834func (self *OxmInPortMasked) GetOXMValueMask() interface{} {
21835 return self.ValueMask
21836}
21837
21838func (self *OxmInPortMasked) MarshalJSON() ([]byte, error) {
21839 value, err := jsonValue(self.GetOXMValue())
21840 if err != nil {
21841 return nil, err
21842 }
21843 valueMask, err := jsonValue(self.GetOXMValueMask())
21844 if err != nil {
21845 return nil, err
21846 }
21847 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
21848}
21849
21850type OxmIpDscp struct {
21851 *Oxm
21852 Value uint8
21853}
21854
21855type IOxmIpDscp interface {
21856 goloxi.IOxm
21857 GetValue() uint8
21858}
21859
21860func (self *OxmIpDscp) GetValue() uint8 {
21861 return self.Value
21862}
21863
21864func (self *OxmIpDscp) SetValue(v uint8) {
21865 self.Value = v
21866}
21867
21868func (self *OxmIpDscp) Serialize(encoder *goloxi.Encoder) error {
21869 if err := self.Oxm.Serialize(encoder); err != nil {
21870 return err
21871 }
21872
21873 encoder.PutUint8(uint8(self.Value))
21874
21875 return nil
21876}
21877
21878func DecodeOxmIpDscp(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpDscp, error) {
21879 _oxmipdscp := &OxmIpDscp{Oxm: parent}
21880 if decoder.Length() < 1 {
21881 return nil, fmt.Errorf("OxmIpDscp packet too short: %d < 1", decoder.Length())
21882 }
21883 _oxmipdscp.Value = uint8(decoder.ReadByte())
21884 return _oxmipdscp, nil
21885}
21886
21887func NewOxmIpDscp() *OxmIpDscp {
21888 obj := &OxmIpDscp{
21889 Oxm: NewOxm(2147487745),
21890 }
21891 return obj
21892}
21893func (self *OxmIpDscp) GetOXMName() string {
21894 return "ip_dscp"
21895}
21896
21897func (self *OxmIpDscp) GetOXMValue() interface{} {
21898 return self.Value
21899}
21900
21901func (self *OxmIpDscp) MarshalJSON() ([]byte, error) {
21902 value, err := jsonValue(self.GetOXMValue())
21903 if err != nil {
21904 return nil, err
21905 }
21906 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
21907}
21908
21909type OxmIpDscpMasked struct {
21910 *Oxm
21911 Value uint8
21912 ValueMask uint8
21913}
21914
21915type IOxmIpDscpMasked interface {
21916 goloxi.IOxm
21917 GetValue() uint8
21918 GetValueMask() uint8
21919}
21920
21921func (self *OxmIpDscpMasked) GetValue() uint8 {
21922 return self.Value
21923}
21924
21925func (self *OxmIpDscpMasked) SetValue(v uint8) {
21926 self.Value = v
21927}
21928
21929func (self *OxmIpDscpMasked) GetValueMask() uint8 {
21930 return self.ValueMask
21931}
21932
21933func (self *OxmIpDscpMasked) SetValueMask(v uint8) {
21934 self.ValueMask = v
21935}
21936
21937func (self *OxmIpDscpMasked) Serialize(encoder *goloxi.Encoder) error {
21938 if err := self.Oxm.Serialize(encoder); err != nil {
21939 return err
21940 }
21941
21942 encoder.PutUint8(uint8(self.Value))
21943 encoder.PutUint8(uint8(self.ValueMask))
21944
21945 return nil
21946}
21947
21948func DecodeOxmIpDscpMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpDscpMasked, error) {
21949 _oxmipdscpmasked := &OxmIpDscpMasked{Oxm: parent}
21950 if decoder.Length() < 2 {
21951 return nil, fmt.Errorf("OxmIpDscpMasked packet too short: %d < 2", decoder.Length())
21952 }
21953 _oxmipdscpmasked.Value = uint8(decoder.ReadByte())
21954 _oxmipdscpmasked.ValueMask = uint8(decoder.ReadByte())
21955 return _oxmipdscpmasked, nil
21956}
21957
21958func NewOxmIpDscpMasked() *OxmIpDscpMasked {
21959 obj := &OxmIpDscpMasked{
21960 Oxm: NewOxm(2147488002),
21961 }
21962 return obj
21963}
21964func (self *OxmIpDscpMasked) GetOXMName() string {
21965 return "ip_dscp_masked"
21966}
21967
21968func (self *OxmIpDscpMasked) GetOXMValue() interface{} {
21969 return self.Value
21970}
21971
21972func (self *OxmIpDscpMasked) GetOXMValueMask() interface{} {
21973 return self.ValueMask
21974}
21975
21976func (self *OxmIpDscpMasked) MarshalJSON() ([]byte, error) {
21977 value, err := jsonValue(self.GetOXMValue())
21978 if err != nil {
21979 return nil, err
21980 }
21981 valueMask, err := jsonValue(self.GetOXMValueMask())
21982 if err != nil {
21983 return nil, err
21984 }
21985 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
21986}
21987
21988type OxmIpEcn struct {
21989 *Oxm
21990 Value uint8
21991}
21992
21993type IOxmIpEcn interface {
21994 goloxi.IOxm
21995 GetValue() uint8
21996}
21997
21998func (self *OxmIpEcn) GetValue() uint8 {
21999 return self.Value
22000}
22001
22002func (self *OxmIpEcn) SetValue(v uint8) {
22003 self.Value = v
22004}
22005
22006func (self *OxmIpEcn) Serialize(encoder *goloxi.Encoder) error {
22007 if err := self.Oxm.Serialize(encoder); err != nil {
22008 return err
22009 }
22010
22011 encoder.PutUint8(uint8(self.Value))
22012
22013 return nil
22014}
22015
22016func DecodeOxmIpEcn(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpEcn, error) {
22017 _oxmipecn := &OxmIpEcn{Oxm: parent}
22018 if decoder.Length() < 1 {
22019 return nil, fmt.Errorf("OxmIpEcn packet too short: %d < 1", decoder.Length())
22020 }
22021 _oxmipecn.Value = uint8(decoder.ReadByte())
22022 return _oxmipecn, nil
22023}
22024
22025func NewOxmIpEcn() *OxmIpEcn {
22026 obj := &OxmIpEcn{
22027 Oxm: NewOxm(2147488257),
22028 }
22029 return obj
22030}
22031func (self *OxmIpEcn) GetOXMName() string {
22032 return "ip_ecn"
22033}
22034
22035func (self *OxmIpEcn) GetOXMValue() interface{} {
22036 return self.Value
22037}
22038
22039func (self *OxmIpEcn) MarshalJSON() ([]byte, error) {
22040 value, err := jsonValue(self.GetOXMValue())
22041 if err != nil {
22042 return nil, err
22043 }
22044 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
22045}
22046
22047type OxmIpEcnMasked struct {
22048 *Oxm
22049 Value uint8
22050 ValueMask uint8
22051}
22052
22053type IOxmIpEcnMasked interface {
22054 goloxi.IOxm
22055 GetValue() uint8
22056 GetValueMask() uint8
22057}
22058
22059func (self *OxmIpEcnMasked) GetValue() uint8 {
22060 return self.Value
22061}
22062
22063func (self *OxmIpEcnMasked) SetValue(v uint8) {
22064 self.Value = v
22065}
22066
22067func (self *OxmIpEcnMasked) GetValueMask() uint8 {
22068 return self.ValueMask
22069}
22070
22071func (self *OxmIpEcnMasked) SetValueMask(v uint8) {
22072 self.ValueMask = v
22073}
22074
22075func (self *OxmIpEcnMasked) Serialize(encoder *goloxi.Encoder) error {
22076 if err := self.Oxm.Serialize(encoder); err != nil {
22077 return err
22078 }
22079
22080 encoder.PutUint8(uint8(self.Value))
22081 encoder.PutUint8(uint8(self.ValueMask))
22082
22083 return nil
22084}
22085
22086func DecodeOxmIpEcnMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpEcnMasked, error) {
22087 _oxmipecnmasked := &OxmIpEcnMasked{Oxm: parent}
22088 if decoder.Length() < 2 {
22089 return nil, fmt.Errorf("OxmIpEcnMasked packet too short: %d < 2", decoder.Length())
22090 }
22091 _oxmipecnmasked.Value = uint8(decoder.ReadByte())
22092 _oxmipecnmasked.ValueMask = uint8(decoder.ReadByte())
22093 return _oxmipecnmasked, nil
22094}
22095
22096func NewOxmIpEcnMasked() *OxmIpEcnMasked {
22097 obj := &OxmIpEcnMasked{
22098 Oxm: NewOxm(2147488514),
22099 }
22100 return obj
22101}
22102func (self *OxmIpEcnMasked) GetOXMName() string {
22103 return "ip_ecn_masked"
22104}
22105
22106func (self *OxmIpEcnMasked) GetOXMValue() interface{} {
22107 return self.Value
22108}
22109
22110func (self *OxmIpEcnMasked) GetOXMValueMask() interface{} {
22111 return self.ValueMask
22112}
22113
22114func (self *OxmIpEcnMasked) MarshalJSON() ([]byte, error) {
22115 value, err := jsonValue(self.GetOXMValue())
22116 if err != nil {
22117 return nil, err
22118 }
22119 valueMask, err := jsonValue(self.GetOXMValueMask())
22120 if err != nil {
22121 return nil, err
22122 }
22123 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
22124}
22125
22126type OxmIpProto struct {
22127 *Oxm
22128 Value IpPrototype
22129}
22130
22131type IOxmIpProto interface {
22132 goloxi.IOxm
22133 GetValue() IpPrototype
22134}
22135
22136func (self *OxmIpProto) GetValue() IpPrototype {
22137 return self.Value
22138}
22139
22140func (self *OxmIpProto) SetValue(v IpPrototype) {
22141 self.Value = v
22142}
22143
22144func (self *OxmIpProto) Serialize(encoder *goloxi.Encoder) error {
22145 if err := self.Oxm.Serialize(encoder); err != nil {
22146 return err
22147 }
22148
22149 encoder.PutUint8(uint8(self.Value))
22150
22151 return nil
22152}
22153
22154func DecodeOxmIpProto(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpProto, error) {
22155 _oxmipproto := &OxmIpProto{Oxm: parent}
22156 if decoder.Length() < 1 {
22157 return nil, fmt.Errorf("OxmIpProto packet too short: %d < 1", decoder.Length())
22158 }
22159 _oxmipproto.Value = IpPrototype(decoder.ReadByte())
22160 return _oxmipproto, nil
22161}
22162
22163func NewOxmIpProto() *OxmIpProto {
22164 obj := &OxmIpProto{
22165 Oxm: NewOxm(2147488769),
22166 }
22167 return obj
22168}
22169func (self *OxmIpProto) GetOXMName() string {
22170 return "ip_proto"
22171}
22172
22173func (self *OxmIpProto) GetOXMValue() interface{} {
22174 return self.Value
22175}
22176
22177func (self *OxmIpProto) MarshalJSON() ([]byte, error) {
22178 value, err := jsonValue(self.GetOXMValue())
22179 if err != nil {
22180 return nil, err
22181 }
22182 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
22183}
22184
22185type OxmIpProtoMasked struct {
22186 *Oxm
22187 Value IpPrototype
22188 ValueMask uint8
22189}
22190
22191type IOxmIpProtoMasked interface {
22192 goloxi.IOxm
22193 GetValue() IpPrototype
22194 GetValueMask() uint8
22195}
22196
22197func (self *OxmIpProtoMasked) GetValue() IpPrototype {
22198 return self.Value
22199}
22200
22201func (self *OxmIpProtoMasked) SetValue(v IpPrototype) {
22202 self.Value = v
22203}
22204
22205func (self *OxmIpProtoMasked) GetValueMask() uint8 {
22206 return self.ValueMask
22207}
22208
22209func (self *OxmIpProtoMasked) SetValueMask(v uint8) {
22210 self.ValueMask = v
22211}
22212
22213func (self *OxmIpProtoMasked) Serialize(encoder *goloxi.Encoder) error {
22214 if err := self.Oxm.Serialize(encoder); err != nil {
22215 return err
22216 }
22217
22218 encoder.PutUint8(uint8(self.Value))
22219 encoder.PutUint8(uint8(self.ValueMask))
22220
22221 return nil
22222}
22223
22224func DecodeOxmIpProtoMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpProtoMasked, error) {
22225 _oxmipprotomasked := &OxmIpProtoMasked{Oxm: parent}
22226 if decoder.Length() < 2 {
22227 return nil, fmt.Errorf("OxmIpProtoMasked packet too short: %d < 2", decoder.Length())
22228 }
22229 _oxmipprotomasked.Value = IpPrototype(decoder.ReadByte())
22230 _oxmipprotomasked.ValueMask = uint8(decoder.ReadByte())
22231 return _oxmipprotomasked, nil
22232}
22233
22234func NewOxmIpProtoMasked() *OxmIpProtoMasked {
22235 obj := &OxmIpProtoMasked{
22236 Oxm: NewOxm(2147489026),
22237 }
22238 return obj
22239}
22240func (self *OxmIpProtoMasked) GetOXMName() string {
22241 return "ip_proto_masked"
22242}
22243
22244func (self *OxmIpProtoMasked) GetOXMValue() interface{} {
22245 return self.Value
22246}
22247
22248func (self *OxmIpProtoMasked) GetOXMValueMask() interface{} {
22249 return self.ValueMask
22250}
22251
22252func (self *OxmIpProtoMasked) MarshalJSON() ([]byte, error) {
22253 value, err := jsonValue(self.GetOXMValue())
22254 if err != nil {
22255 return nil, err
22256 }
22257 valueMask, err := jsonValue(self.GetOXMValueMask())
22258 if err != nil {
22259 return nil, err
22260 }
22261 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
22262}
22263
22264type OxmIpv4Dst struct {
22265 *Oxm
22266 Value net.IP
22267}
22268
22269type IOxmIpv4Dst interface {
22270 goloxi.IOxm
22271 GetValue() net.IP
22272}
22273
22274func (self *OxmIpv4Dst) GetValue() net.IP {
22275 return self.Value
22276}
22277
22278func (self *OxmIpv4Dst) SetValue(v net.IP) {
22279 self.Value = v
22280}
22281
22282func (self *OxmIpv4Dst) Serialize(encoder *goloxi.Encoder) error {
22283 if err := self.Oxm.Serialize(encoder); err != nil {
22284 return err
22285 }
22286
22287 encoder.Write(self.Value.To4())
22288
22289 return nil
22290}
22291
22292func DecodeOxmIpv4Dst(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv4Dst, error) {
22293 _oxmipv4dst := &OxmIpv4Dst{Oxm: parent}
22294 if decoder.Length() < 4 {
22295 return nil, fmt.Errorf("OxmIpv4Dst packet too short: %d < 4", decoder.Length())
22296 }
22297 _oxmipv4dst.Value = net.IP(decoder.Read(4))
22298 return _oxmipv4dst, nil
22299}
22300
22301func NewOxmIpv4Dst() *OxmIpv4Dst {
22302 obj := &OxmIpv4Dst{
22303 Oxm: NewOxm(2147489796),
22304 }
22305 return obj
22306}
22307func (self *OxmIpv4Dst) GetOXMName() string {
22308 return "ipv4_dst"
22309}
22310
22311func (self *OxmIpv4Dst) GetOXMValue() interface{} {
22312 return self.Value
22313}
22314
22315func (self *OxmIpv4Dst) MarshalJSON() ([]byte, error) {
22316 value, err := jsonValue(self.GetOXMValue())
22317 if err != nil {
22318 return nil, err
22319 }
22320 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
22321}
22322
22323type OxmIpv4DstMasked struct {
22324 *Oxm
22325 Value net.IP
22326 ValueMask net.IP
22327}
22328
22329type IOxmIpv4DstMasked interface {
22330 goloxi.IOxm
22331 GetValue() net.IP
22332 GetValueMask() net.IP
22333}
22334
22335func (self *OxmIpv4DstMasked) GetValue() net.IP {
22336 return self.Value
22337}
22338
22339func (self *OxmIpv4DstMasked) SetValue(v net.IP) {
22340 self.Value = v
22341}
22342
22343func (self *OxmIpv4DstMasked) GetValueMask() net.IP {
22344 return self.ValueMask
22345}
22346
22347func (self *OxmIpv4DstMasked) SetValueMask(v net.IP) {
22348 self.ValueMask = v
22349}
22350
22351func (self *OxmIpv4DstMasked) Serialize(encoder *goloxi.Encoder) error {
22352 if err := self.Oxm.Serialize(encoder); err != nil {
22353 return err
22354 }
22355
22356 encoder.Write(self.Value.To4())
22357 encoder.Write(self.ValueMask.To4())
22358
22359 return nil
22360}
22361
22362func DecodeOxmIpv4DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv4DstMasked, error) {
22363 _oxmipv4dstmasked := &OxmIpv4DstMasked{Oxm: parent}
22364 if decoder.Length() < 8 {
22365 return nil, fmt.Errorf("OxmIpv4DstMasked packet too short: %d < 8", decoder.Length())
22366 }
22367 _oxmipv4dstmasked.Value = net.IP(decoder.Read(4))
22368 _oxmipv4dstmasked.ValueMask = net.IP(decoder.Read(4))
22369 return _oxmipv4dstmasked, nil
22370}
22371
22372func NewOxmIpv4DstMasked() *OxmIpv4DstMasked {
22373 obj := &OxmIpv4DstMasked{
22374 Oxm: NewOxm(2147490056),
22375 }
22376 return obj
22377}
22378func (self *OxmIpv4DstMasked) GetOXMName() string {
22379 return "ipv4_dst_masked"
22380}
22381
22382func (self *OxmIpv4DstMasked) GetOXMValue() interface{} {
22383 return self.Value
22384}
22385
22386func (self *OxmIpv4DstMasked) GetOXMValueMask() interface{} {
22387 return self.ValueMask
22388}
22389
22390func (self *OxmIpv4DstMasked) MarshalJSON() ([]byte, error) {
22391 value, err := jsonValue(self.GetOXMValue())
22392 if err != nil {
22393 return nil, err
22394 }
22395 valueMask, err := jsonValue(self.GetOXMValueMask())
22396 if err != nil {
22397 return nil, err
22398 }
22399 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
22400}
22401
22402type OxmIpv4Src struct {
22403 *Oxm
22404 Value net.IP
22405}
22406
22407type IOxmIpv4Src interface {
22408 goloxi.IOxm
22409 GetValue() net.IP
22410}
22411
22412func (self *OxmIpv4Src) GetValue() net.IP {
22413 return self.Value
22414}
22415
22416func (self *OxmIpv4Src) SetValue(v net.IP) {
22417 self.Value = v
22418}
22419
22420func (self *OxmIpv4Src) Serialize(encoder *goloxi.Encoder) error {
22421 if err := self.Oxm.Serialize(encoder); err != nil {
22422 return err
22423 }
22424
22425 encoder.Write(self.Value.To4())
22426
22427 return nil
22428}
22429
22430func DecodeOxmIpv4Src(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv4Src, error) {
22431 _oxmipv4src := &OxmIpv4Src{Oxm: parent}
22432 if decoder.Length() < 4 {
22433 return nil, fmt.Errorf("OxmIpv4Src packet too short: %d < 4", decoder.Length())
22434 }
22435 _oxmipv4src.Value = net.IP(decoder.Read(4))
22436 return _oxmipv4src, nil
22437}
22438
22439func NewOxmIpv4Src() *OxmIpv4Src {
22440 obj := &OxmIpv4Src{
22441 Oxm: NewOxm(2147489284),
22442 }
22443 return obj
22444}
22445func (self *OxmIpv4Src) GetOXMName() string {
22446 return "ipv4_src"
22447}
22448
22449func (self *OxmIpv4Src) GetOXMValue() interface{} {
22450 return self.Value
22451}
22452
22453func (self *OxmIpv4Src) MarshalJSON() ([]byte, error) {
22454 value, err := jsonValue(self.GetOXMValue())
22455 if err != nil {
22456 return nil, err
22457 }
22458 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
22459}
22460
22461type OxmIpv4SrcMasked struct {
22462 *Oxm
22463 Value net.IP
22464 ValueMask net.IP
22465}
22466
22467type IOxmIpv4SrcMasked interface {
22468 goloxi.IOxm
22469 GetValue() net.IP
22470 GetValueMask() net.IP
22471}
22472
22473func (self *OxmIpv4SrcMasked) GetValue() net.IP {
22474 return self.Value
22475}
22476
22477func (self *OxmIpv4SrcMasked) SetValue(v net.IP) {
22478 self.Value = v
22479}
22480
22481func (self *OxmIpv4SrcMasked) GetValueMask() net.IP {
22482 return self.ValueMask
22483}
22484
22485func (self *OxmIpv4SrcMasked) SetValueMask(v net.IP) {
22486 self.ValueMask = v
22487}
22488
22489func (self *OxmIpv4SrcMasked) Serialize(encoder *goloxi.Encoder) error {
22490 if err := self.Oxm.Serialize(encoder); err != nil {
22491 return err
22492 }
22493
22494 encoder.Write(self.Value.To4())
22495 encoder.Write(self.ValueMask.To4())
22496
22497 return nil
22498}
22499
22500func DecodeOxmIpv4SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv4SrcMasked, error) {
22501 _oxmipv4srcmasked := &OxmIpv4SrcMasked{Oxm: parent}
22502 if decoder.Length() < 8 {
22503 return nil, fmt.Errorf("OxmIpv4SrcMasked packet too short: %d < 8", decoder.Length())
22504 }
22505 _oxmipv4srcmasked.Value = net.IP(decoder.Read(4))
22506 _oxmipv4srcmasked.ValueMask = net.IP(decoder.Read(4))
22507 return _oxmipv4srcmasked, nil
22508}
22509
22510func NewOxmIpv4SrcMasked() *OxmIpv4SrcMasked {
22511 obj := &OxmIpv4SrcMasked{
22512 Oxm: NewOxm(2147489544),
22513 }
22514 return obj
22515}
22516func (self *OxmIpv4SrcMasked) GetOXMName() string {
22517 return "ipv4_src_masked"
22518}
22519
22520func (self *OxmIpv4SrcMasked) GetOXMValue() interface{} {
22521 return self.Value
22522}
22523
22524func (self *OxmIpv4SrcMasked) GetOXMValueMask() interface{} {
22525 return self.ValueMask
22526}
22527
22528func (self *OxmIpv4SrcMasked) MarshalJSON() ([]byte, error) {
22529 value, err := jsonValue(self.GetOXMValue())
22530 if err != nil {
22531 return nil, err
22532 }
22533 valueMask, err := jsonValue(self.GetOXMValueMask())
22534 if err != nil {
22535 return nil, err
22536 }
22537 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
22538}
22539
22540type OxmIpv6Dst struct {
22541 *Oxm
22542 Value net.IP
22543}
22544
22545type IOxmIpv6Dst interface {
22546 goloxi.IOxm
22547 GetValue() net.IP
22548}
22549
22550func (self *OxmIpv6Dst) GetValue() net.IP {
22551 return self.Value
22552}
22553
22554func (self *OxmIpv6Dst) SetValue(v net.IP) {
22555 self.Value = v
22556}
22557
22558func (self *OxmIpv6Dst) Serialize(encoder *goloxi.Encoder) error {
22559 if err := self.Oxm.Serialize(encoder); err != nil {
22560 return err
22561 }
22562
22563 encoder.Write(self.Value.To16())
22564
22565 return nil
22566}
22567
22568func DecodeOxmIpv6Dst(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6Dst, error) {
22569 _oxmipv6dst := &OxmIpv6Dst{Oxm: parent}
22570 if decoder.Length() < 16 {
22571 return nil, fmt.Errorf("OxmIpv6Dst packet too short: %d < 16", decoder.Length())
22572 }
22573 _oxmipv6dst.Value = net.IP(decoder.Read(16))
22574 return _oxmipv6dst, nil
22575}
22576
22577func NewOxmIpv6Dst() *OxmIpv6Dst {
22578 obj := &OxmIpv6Dst{
22579 Oxm: NewOxm(2147497488),
22580 }
22581 return obj
22582}
22583func (self *OxmIpv6Dst) GetOXMName() string {
22584 return "ipv6_dst"
22585}
22586
22587func (self *OxmIpv6Dst) GetOXMValue() interface{} {
22588 return self.Value
22589}
22590
22591func (self *OxmIpv6Dst) MarshalJSON() ([]byte, error) {
22592 value, err := jsonValue(self.GetOXMValue())
22593 if err != nil {
22594 return nil, err
22595 }
22596 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
22597}
22598
22599type OxmIpv6DstMasked struct {
22600 *Oxm
22601 Value net.IP
22602 ValueMask net.IP
22603}
22604
22605type IOxmIpv6DstMasked interface {
22606 goloxi.IOxm
22607 GetValue() net.IP
22608 GetValueMask() net.IP
22609}
22610
22611func (self *OxmIpv6DstMasked) GetValue() net.IP {
22612 return self.Value
22613}
22614
22615func (self *OxmIpv6DstMasked) SetValue(v net.IP) {
22616 self.Value = v
22617}
22618
22619func (self *OxmIpv6DstMasked) GetValueMask() net.IP {
22620 return self.ValueMask
22621}
22622
22623func (self *OxmIpv6DstMasked) SetValueMask(v net.IP) {
22624 self.ValueMask = v
22625}
22626
22627func (self *OxmIpv6DstMasked) Serialize(encoder *goloxi.Encoder) error {
22628 if err := self.Oxm.Serialize(encoder); err != nil {
22629 return err
22630 }
22631
22632 encoder.Write(self.Value.To16())
22633 encoder.Write(self.ValueMask.To16())
22634
22635 return nil
22636}
22637
22638func DecodeOxmIpv6DstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6DstMasked, error) {
22639 _oxmipv6dstmasked := &OxmIpv6DstMasked{Oxm: parent}
22640 if decoder.Length() < 32 {
22641 return nil, fmt.Errorf("OxmIpv6DstMasked packet too short: %d < 32", decoder.Length())
22642 }
22643 _oxmipv6dstmasked.Value = net.IP(decoder.Read(16))
22644 _oxmipv6dstmasked.ValueMask = net.IP(decoder.Read(16))
22645 return _oxmipv6dstmasked, nil
22646}
22647
22648func NewOxmIpv6DstMasked() *OxmIpv6DstMasked {
22649 obj := &OxmIpv6DstMasked{
22650 Oxm: NewOxm(2147497760),
22651 }
22652 return obj
22653}
22654func (self *OxmIpv6DstMasked) GetOXMName() string {
22655 return "ipv6_dst_masked"
22656}
22657
22658func (self *OxmIpv6DstMasked) GetOXMValue() interface{} {
22659 return self.Value
22660}
22661
22662func (self *OxmIpv6DstMasked) GetOXMValueMask() interface{} {
22663 return self.ValueMask
22664}
22665
22666func (self *OxmIpv6DstMasked) MarshalJSON() ([]byte, error) {
22667 value, err := jsonValue(self.GetOXMValue())
22668 if err != nil {
22669 return nil, err
22670 }
22671 valueMask, err := jsonValue(self.GetOXMValueMask())
22672 if err != nil {
22673 return nil, err
22674 }
22675 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
22676}
22677
22678type OxmIpv6Flabel struct {
22679 *Oxm
22680 Value uint32
22681}
22682
22683type IOxmIpv6Flabel interface {
22684 goloxi.IOxm
22685 GetValue() uint32
22686}
22687
22688func (self *OxmIpv6Flabel) GetValue() uint32 {
22689 return self.Value
22690}
22691
22692func (self *OxmIpv6Flabel) SetValue(v uint32) {
22693 self.Value = v
22694}
22695
22696func (self *OxmIpv6Flabel) Serialize(encoder *goloxi.Encoder) error {
22697 if err := self.Oxm.Serialize(encoder); err != nil {
22698 return err
22699 }
22700
22701 encoder.PutUint32(uint32(self.Value))
22702
22703 return nil
22704}
22705
22706func DecodeOxmIpv6Flabel(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6Flabel, error) {
22707 _oxmipv6flabel := &OxmIpv6Flabel{Oxm: parent}
22708 if decoder.Length() < 4 {
22709 return nil, fmt.Errorf("OxmIpv6Flabel packet too short: %d < 4", decoder.Length())
22710 }
22711 _oxmipv6flabel.Value = uint32(decoder.ReadUint32())
22712 return _oxmipv6flabel, nil
22713}
22714
22715func NewOxmIpv6Flabel() *OxmIpv6Flabel {
22716 obj := &OxmIpv6Flabel{
22717 Oxm: NewOxm(2147497988),
22718 }
22719 return obj
22720}
22721func (self *OxmIpv6Flabel) GetOXMName() string {
22722 return "ipv6_flabel"
22723}
22724
22725func (self *OxmIpv6Flabel) GetOXMValue() interface{} {
22726 return self.Value
22727}
22728
22729func (self *OxmIpv6Flabel) MarshalJSON() ([]byte, error) {
22730 value, err := jsonValue(self.GetOXMValue())
22731 if err != nil {
22732 return nil, err
22733 }
22734 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
22735}
22736
22737type OxmIpv6FlabelMasked struct {
22738 *Oxm
22739 Value uint32
22740 ValueMask uint32
22741}
22742
22743type IOxmIpv6FlabelMasked interface {
22744 goloxi.IOxm
22745 GetValue() uint32
22746 GetValueMask() uint32
22747}
22748
22749func (self *OxmIpv6FlabelMasked) GetValue() uint32 {
22750 return self.Value
22751}
22752
22753func (self *OxmIpv6FlabelMasked) SetValue(v uint32) {
22754 self.Value = v
22755}
22756
22757func (self *OxmIpv6FlabelMasked) GetValueMask() uint32 {
22758 return self.ValueMask
22759}
22760
22761func (self *OxmIpv6FlabelMasked) SetValueMask(v uint32) {
22762 self.ValueMask = v
22763}
22764
22765func (self *OxmIpv6FlabelMasked) Serialize(encoder *goloxi.Encoder) error {
22766 if err := self.Oxm.Serialize(encoder); err != nil {
22767 return err
22768 }
22769
22770 encoder.PutUint32(uint32(self.Value))
22771 encoder.PutUint32(uint32(self.ValueMask))
22772
22773 return nil
22774}
22775
22776func DecodeOxmIpv6FlabelMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6FlabelMasked, error) {
22777 _oxmipv6flabelmasked := &OxmIpv6FlabelMasked{Oxm: parent}
22778 if decoder.Length() < 8 {
22779 return nil, fmt.Errorf("OxmIpv6FlabelMasked packet too short: %d < 8", decoder.Length())
22780 }
22781 _oxmipv6flabelmasked.Value = uint32(decoder.ReadUint32())
22782 _oxmipv6flabelmasked.ValueMask = uint32(decoder.ReadUint32())
22783 return _oxmipv6flabelmasked, nil
22784}
22785
22786func NewOxmIpv6FlabelMasked() *OxmIpv6FlabelMasked {
22787 obj := &OxmIpv6FlabelMasked{
22788 Oxm: NewOxm(2147498248),
22789 }
22790 return obj
22791}
22792func (self *OxmIpv6FlabelMasked) GetOXMName() string {
22793 return "ipv6_flabel_masked"
22794}
22795
22796func (self *OxmIpv6FlabelMasked) GetOXMValue() interface{} {
22797 return self.Value
22798}
22799
22800func (self *OxmIpv6FlabelMasked) GetOXMValueMask() interface{} {
22801 return self.ValueMask
22802}
22803
22804func (self *OxmIpv6FlabelMasked) MarshalJSON() ([]byte, error) {
22805 value, err := jsonValue(self.GetOXMValue())
22806 if err != nil {
22807 return nil, err
22808 }
22809 valueMask, err := jsonValue(self.GetOXMValueMask())
22810 if err != nil {
22811 return nil, err
22812 }
22813 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
22814}
22815
22816type OxmIpv6NdSll struct {
22817 *Oxm
22818 Value net.HardwareAddr
22819}
22820
22821type IOxmIpv6NdSll interface {
22822 goloxi.IOxm
22823 GetValue() net.HardwareAddr
22824}
22825
22826func (self *OxmIpv6NdSll) GetValue() net.HardwareAddr {
22827 return self.Value
22828}
22829
22830func (self *OxmIpv6NdSll) SetValue(v net.HardwareAddr) {
22831 self.Value = v
22832}
22833
22834func (self *OxmIpv6NdSll) Serialize(encoder *goloxi.Encoder) error {
22835 if err := self.Oxm.Serialize(encoder); err != nil {
22836 return err
22837 }
22838
22839 encoder.Write(self.Value)
22840
22841 return nil
22842}
22843
22844func DecodeOxmIpv6NdSll(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdSll, error) {
22845 _oxmipv6ndsll := &OxmIpv6NdSll{Oxm: parent}
22846 if decoder.Length() < 6 {
22847 return nil, fmt.Errorf("OxmIpv6NdSll packet too short: %d < 6", decoder.Length())
22848 }
22849 _oxmipv6ndsll.Value = net.HardwareAddr(decoder.Read(6))
22850 return _oxmipv6ndsll, nil
22851}
22852
22853func NewOxmIpv6NdSll() *OxmIpv6NdSll {
22854 obj := &OxmIpv6NdSll{
22855 Oxm: NewOxm(2147500038),
22856 }
22857 return obj
22858}
22859func (self *OxmIpv6NdSll) GetOXMName() string {
22860 return "ipv6_nd_sll"
22861}
22862
22863func (self *OxmIpv6NdSll) GetOXMValue() interface{} {
22864 return self.Value
22865}
22866
22867func (self *OxmIpv6NdSll) MarshalJSON() ([]byte, error) {
22868 value, err := jsonValue(self.GetOXMValue())
22869 if err != nil {
22870 return nil, err
22871 }
22872 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
22873}
22874
22875type OxmIpv6NdSllMasked struct {
22876 *Oxm
22877 Value net.HardwareAddr
22878 ValueMask net.HardwareAddr
22879}
22880
22881type IOxmIpv6NdSllMasked interface {
22882 goloxi.IOxm
22883 GetValue() net.HardwareAddr
22884 GetValueMask() net.HardwareAddr
22885}
22886
22887func (self *OxmIpv6NdSllMasked) GetValue() net.HardwareAddr {
22888 return self.Value
22889}
22890
22891func (self *OxmIpv6NdSllMasked) SetValue(v net.HardwareAddr) {
22892 self.Value = v
22893}
22894
22895func (self *OxmIpv6NdSllMasked) GetValueMask() net.HardwareAddr {
22896 return self.ValueMask
22897}
22898
22899func (self *OxmIpv6NdSllMasked) SetValueMask(v net.HardwareAddr) {
22900 self.ValueMask = v
22901}
22902
22903func (self *OxmIpv6NdSllMasked) Serialize(encoder *goloxi.Encoder) error {
22904 if err := self.Oxm.Serialize(encoder); err != nil {
22905 return err
22906 }
22907
22908 encoder.Write(self.Value)
22909 encoder.Write(self.ValueMask)
22910
22911 return nil
22912}
22913
22914func DecodeOxmIpv6NdSllMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdSllMasked, error) {
22915 _oxmipv6ndsllmasked := &OxmIpv6NdSllMasked{Oxm: parent}
22916 if decoder.Length() < 12 {
22917 return nil, fmt.Errorf("OxmIpv6NdSllMasked packet too short: %d < 12", decoder.Length())
22918 }
22919 _oxmipv6ndsllmasked.Value = net.HardwareAddr(decoder.Read(6))
22920 _oxmipv6ndsllmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
22921 return _oxmipv6ndsllmasked, nil
22922}
22923
22924func NewOxmIpv6NdSllMasked() *OxmIpv6NdSllMasked {
22925 obj := &OxmIpv6NdSllMasked{
22926 Oxm: NewOxm(2147500300),
22927 }
22928 return obj
22929}
22930func (self *OxmIpv6NdSllMasked) GetOXMName() string {
22931 return "ipv6_nd_sll_masked"
22932}
22933
22934func (self *OxmIpv6NdSllMasked) GetOXMValue() interface{} {
22935 return self.Value
22936}
22937
22938func (self *OxmIpv6NdSllMasked) GetOXMValueMask() interface{} {
22939 return self.ValueMask
22940}
22941
22942func (self *OxmIpv6NdSllMasked) MarshalJSON() ([]byte, error) {
22943 value, err := jsonValue(self.GetOXMValue())
22944 if err != nil {
22945 return nil, err
22946 }
22947 valueMask, err := jsonValue(self.GetOXMValueMask())
22948 if err != nil {
22949 return nil, err
22950 }
22951 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
22952}
22953
22954type OxmIpv6NdTarget struct {
22955 *Oxm
22956 Value net.IP
22957}
22958
22959type IOxmIpv6NdTarget interface {
22960 goloxi.IOxm
22961 GetValue() net.IP
22962}
22963
22964func (self *OxmIpv6NdTarget) GetValue() net.IP {
22965 return self.Value
22966}
22967
22968func (self *OxmIpv6NdTarget) SetValue(v net.IP) {
22969 self.Value = v
22970}
22971
22972func (self *OxmIpv6NdTarget) Serialize(encoder *goloxi.Encoder) error {
22973 if err := self.Oxm.Serialize(encoder); err != nil {
22974 return err
22975 }
22976
22977 encoder.Write(self.Value.To16())
22978
22979 return nil
22980}
22981
22982func DecodeOxmIpv6NdTarget(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdTarget, error) {
22983 _oxmipv6ndtarget := &OxmIpv6NdTarget{Oxm: parent}
22984 if decoder.Length() < 16 {
22985 return nil, fmt.Errorf("OxmIpv6NdTarget packet too short: %d < 16", decoder.Length())
22986 }
22987 _oxmipv6ndtarget.Value = net.IP(decoder.Read(16))
22988 return _oxmipv6ndtarget, nil
22989}
22990
22991func NewOxmIpv6NdTarget() *OxmIpv6NdTarget {
22992 obj := &OxmIpv6NdTarget{
22993 Oxm: NewOxm(2147499536),
22994 }
22995 return obj
22996}
22997func (self *OxmIpv6NdTarget) GetOXMName() string {
22998 return "ipv6_nd_target"
22999}
23000
23001func (self *OxmIpv6NdTarget) GetOXMValue() interface{} {
23002 return self.Value
23003}
23004
23005func (self *OxmIpv6NdTarget) MarshalJSON() ([]byte, error) {
23006 value, err := jsonValue(self.GetOXMValue())
23007 if err != nil {
23008 return nil, err
23009 }
23010 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
23011}
23012
23013type OxmIpv6NdTargetMasked struct {
23014 *Oxm
23015 Value net.IP
23016 ValueMask net.IP
23017}
23018
23019type IOxmIpv6NdTargetMasked interface {
23020 goloxi.IOxm
23021 GetValue() net.IP
23022 GetValueMask() net.IP
23023}
23024
23025func (self *OxmIpv6NdTargetMasked) GetValue() net.IP {
23026 return self.Value
23027}
23028
23029func (self *OxmIpv6NdTargetMasked) SetValue(v net.IP) {
23030 self.Value = v
23031}
23032
23033func (self *OxmIpv6NdTargetMasked) GetValueMask() net.IP {
23034 return self.ValueMask
23035}
23036
23037func (self *OxmIpv6NdTargetMasked) SetValueMask(v net.IP) {
23038 self.ValueMask = v
23039}
23040
23041func (self *OxmIpv6NdTargetMasked) Serialize(encoder *goloxi.Encoder) error {
23042 if err := self.Oxm.Serialize(encoder); err != nil {
23043 return err
23044 }
23045
23046 encoder.Write(self.Value.To16())
23047 encoder.Write(self.ValueMask.To16())
23048
23049 return nil
23050}
23051
23052func DecodeOxmIpv6NdTargetMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdTargetMasked, error) {
23053 _oxmipv6ndtargetmasked := &OxmIpv6NdTargetMasked{Oxm: parent}
23054 if decoder.Length() < 32 {
23055 return nil, fmt.Errorf("OxmIpv6NdTargetMasked packet too short: %d < 32", decoder.Length())
23056 }
23057 _oxmipv6ndtargetmasked.Value = net.IP(decoder.Read(16))
23058 _oxmipv6ndtargetmasked.ValueMask = net.IP(decoder.Read(16))
23059 return _oxmipv6ndtargetmasked, nil
23060}
23061
23062func NewOxmIpv6NdTargetMasked() *OxmIpv6NdTargetMasked {
23063 obj := &OxmIpv6NdTargetMasked{
23064 Oxm: NewOxm(2147499808),
23065 }
23066 return obj
23067}
23068func (self *OxmIpv6NdTargetMasked) GetOXMName() string {
23069 return "ipv6_nd_target_masked"
23070}
23071
23072func (self *OxmIpv6NdTargetMasked) GetOXMValue() interface{} {
23073 return self.Value
23074}
23075
23076func (self *OxmIpv6NdTargetMasked) GetOXMValueMask() interface{} {
23077 return self.ValueMask
23078}
23079
23080func (self *OxmIpv6NdTargetMasked) MarshalJSON() ([]byte, error) {
23081 value, err := jsonValue(self.GetOXMValue())
23082 if err != nil {
23083 return nil, err
23084 }
23085 valueMask, err := jsonValue(self.GetOXMValueMask())
23086 if err != nil {
23087 return nil, err
23088 }
23089 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
23090}
23091
23092type OxmIpv6NdTll struct {
23093 *Oxm
23094 Value net.HardwareAddr
23095}
23096
23097type IOxmIpv6NdTll interface {
23098 goloxi.IOxm
23099 GetValue() net.HardwareAddr
23100}
23101
23102func (self *OxmIpv6NdTll) GetValue() net.HardwareAddr {
23103 return self.Value
23104}
23105
23106func (self *OxmIpv6NdTll) SetValue(v net.HardwareAddr) {
23107 self.Value = v
23108}
23109
23110func (self *OxmIpv6NdTll) Serialize(encoder *goloxi.Encoder) error {
23111 if err := self.Oxm.Serialize(encoder); err != nil {
23112 return err
23113 }
23114
23115 encoder.Write(self.Value)
23116
23117 return nil
23118}
23119
23120func DecodeOxmIpv6NdTll(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdTll, error) {
23121 _oxmipv6ndtll := &OxmIpv6NdTll{Oxm: parent}
23122 if decoder.Length() < 6 {
23123 return nil, fmt.Errorf("OxmIpv6NdTll packet too short: %d < 6", decoder.Length())
23124 }
23125 _oxmipv6ndtll.Value = net.HardwareAddr(decoder.Read(6))
23126 return _oxmipv6ndtll, nil
23127}
23128
23129func NewOxmIpv6NdTll() *OxmIpv6NdTll {
23130 obj := &OxmIpv6NdTll{
23131 Oxm: NewOxm(2147500550),
23132 }
23133 return obj
23134}
23135func (self *OxmIpv6NdTll) GetOXMName() string {
23136 return "ipv6_nd_tll"
23137}
23138
23139func (self *OxmIpv6NdTll) GetOXMValue() interface{} {
23140 return self.Value
23141}
23142
23143func (self *OxmIpv6NdTll) MarshalJSON() ([]byte, error) {
23144 value, err := jsonValue(self.GetOXMValue())
23145 if err != nil {
23146 return nil, err
23147 }
23148 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
23149}
23150
23151type OxmIpv6NdTllMasked struct {
23152 *Oxm
23153 Value net.HardwareAddr
23154 ValueMask net.HardwareAddr
23155}
23156
23157type IOxmIpv6NdTllMasked interface {
23158 goloxi.IOxm
23159 GetValue() net.HardwareAddr
23160 GetValueMask() net.HardwareAddr
23161}
23162
23163func (self *OxmIpv6NdTllMasked) GetValue() net.HardwareAddr {
23164 return self.Value
23165}
23166
23167func (self *OxmIpv6NdTllMasked) SetValue(v net.HardwareAddr) {
23168 self.Value = v
23169}
23170
23171func (self *OxmIpv6NdTllMasked) GetValueMask() net.HardwareAddr {
23172 return self.ValueMask
23173}
23174
23175func (self *OxmIpv6NdTllMasked) SetValueMask(v net.HardwareAddr) {
23176 self.ValueMask = v
23177}
23178
23179func (self *OxmIpv6NdTllMasked) Serialize(encoder *goloxi.Encoder) error {
23180 if err := self.Oxm.Serialize(encoder); err != nil {
23181 return err
23182 }
23183
23184 encoder.Write(self.Value)
23185 encoder.Write(self.ValueMask)
23186
23187 return nil
23188}
23189
23190func DecodeOxmIpv6NdTllMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6NdTllMasked, error) {
23191 _oxmipv6ndtllmasked := &OxmIpv6NdTllMasked{Oxm: parent}
23192 if decoder.Length() < 12 {
23193 return nil, fmt.Errorf("OxmIpv6NdTllMasked packet too short: %d < 12", decoder.Length())
23194 }
23195 _oxmipv6ndtllmasked.Value = net.HardwareAddr(decoder.Read(6))
23196 _oxmipv6ndtllmasked.ValueMask = net.HardwareAddr(decoder.Read(6))
23197 return _oxmipv6ndtllmasked, nil
23198}
23199
23200func NewOxmIpv6NdTllMasked() *OxmIpv6NdTllMasked {
23201 obj := &OxmIpv6NdTllMasked{
23202 Oxm: NewOxm(2147500812),
23203 }
23204 return obj
23205}
23206func (self *OxmIpv6NdTllMasked) GetOXMName() string {
23207 return "ipv6_nd_tll_masked"
23208}
23209
23210func (self *OxmIpv6NdTllMasked) GetOXMValue() interface{} {
23211 return self.Value
23212}
23213
23214func (self *OxmIpv6NdTllMasked) GetOXMValueMask() interface{} {
23215 return self.ValueMask
23216}
23217
23218func (self *OxmIpv6NdTllMasked) MarshalJSON() ([]byte, error) {
23219 value, err := jsonValue(self.GetOXMValue())
23220 if err != nil {
23221 return nil, err
23222 }
23223 valueMask, err := jsonValue(self.GetOXMValueMask())
23224 if err != nil {
23225 return nil, err
23226 }
23227 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
23228}
23229
23230type OxmIpv6Src struct {
23231 *Oxm
23232 Value net.IP
23233}
23234
23235type IOxmIpv6Src interface {
23236 goloxi.IOxm
23237 GetValue() net.IP
23238}
23239
23240func (self *OxmIpv6Src) GetValue() net.IP {
23241 return self.Value
23242}
23243
23244func (self *OxmIpv6Src) SetValue(v net.IP) {
23245 self.Value = v
23246}
23247
23248func (self *OxmIpv6Src) Serialize(encoder *goloxi.Encoder) error {
23249 if err := self.Oxm.Serialize(encoder); err != nil {
23250 return err
23251 }
23252
23253 encoder.Write(self.Value.To16())
23254
23255 return nil
23256}
23257
23258func DecodeOxmIpv6Src(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6Src, error) {
23259 _oxmipv6src := &OxmIpv6Src{Oxm: parent}
23260 if decoder.Length() < 16 {
23261 return nil, fmt.Errorf("OxmIpv6Src packet too short: %d < 16", decoder.Length())
23262 }
23263 _oxmipv6src.Value = net.IP(decoder.Read(16))
23264 return _oxmipv6src, nil
23265}
23266
23267func NewOxmIpv6Src() *OxmIpv6Src {
23268 obj := &OxmIpv6Src{
23269 Oxm: NewOxm(2147496976),
23270 }
23271 return obj
23272}
23273func (self *OxmIpv6Src) GetOXMName() string {
23274 return "ipv6_src"
23275}
23276
23277func (self *OxmIpv6Src) GetOXMValue() interface{} {
23278 return self.Value
23279}
23280
23281func (self *OxmIpv6Src) MarshalJSON() ([]byte, error) {
23282 value, err := jsonValue(self.GetOXMValue())
23283 if err != nil {
23284 return nil, err
23285 }
23286 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
23287}
23288
23289type OxmIpv6SrcMasked struct {
23290 *Oxm
23291 Value net.IP
23292 ValueMask net.IP
23293}
23294
23295type IOxmIpv6SrcMasked interface {
23296 goloxi.IOxm
23297 GetValue() net.IP
23298 GetValueMask() net.IP
23299}
23300
23301func (self *OxmIpv6SrcMasked) GetValue() net.IP {
23302 return self.Value
23303}
23304
23305func (self *OxmIpv6SrcMasked) SetValue(v net.IP) {
23306 self.Value = v
23307}
23308
23309func (self *OxmIpv6SrcMasked) GetValueMask() net.IP {
23310 return self.ValueMask
23311}
23312
23313func (self *OxmIpv6SrcMasked) SetValueMask(v net.IP) {
23314 self.ValueMask = v
23315}
23316
23317func (self *OxmIpv6SrcMasked) Serialize(encoder *goloxi.Encoder) error {
23318 if err := self.Oxm.Serialize(encoder); err != nil {
23319 return err
23320 }
23321
23322 encoder.Write(self.Value.To16())
23323 encoder.Write(self.ValueMask.To16())
23324
23325 return nil
23326}
23327
23328func DecodeOxmIpv6SrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmIpv6SrcMasked, error) {
23329 _oxmipv6srcmasked := &OxmIpv6SrcMasked{Oxm: parent}
23330 if decoder.Length() < 32 {
23331 return nil, fmt.Errorf("OxmIpv6SrcMasked packet too short: %d < 32", decoder.Length())
23332 }
23333 _oxmipv6srcmasked.Value = net.IP(decoder.Read(16))
23334 _oxmipv6srcmasked.ValueMask = net.IP(decoder.Read(16))
23335 return _oxmipv6srcmasked, nil
23336}
23337
23338func NewOxmIpv6SrcMasked() *OxmIpv6SrcMasked {
23339 obj := &OxmIpv6SrcMasked{
23340 Oxm: NewOxm(2147497248),
23341 }
23342 return obj
23343}
23344func (self *OxmIpv6SrcMasked) GetOXMName() string {
23345 return "ipv6_src_masked"
23346}
23347
23348func (self *OxmIpv6SrcMasked) GetOXMValue() interface{} {
23349 return self.Value
23350}
23351
23352func (self *OxmIpv6SrcMasked) GetOXMValueMask() interface{} {
23353 return self.ValueMask
23354}
23355
23356func (self *OxmIpv6SrcMasked) MarshalJSON() ([]byte, error) {
23357 value, err := jsonValue(self.GetOXMValue())
23358 if err != nil {
23359 return nil, err
23360 }
23361 valueMask, err := jsonValue(self.GetOXMValueMask())
23362 if err != nil {
23363 return nil, err
23364 }
23365 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
23366}
23367
23368type OxmMetadata struct {
23369 *Oxm
23370 Value uint64
23371}
23372
23373type IOxmMetadata interface {
23374 goloxi.IOxm
23375 GetValue() uint64
23376}
23377
23378func (self *OxmMetadata) GetValue() uint64 {
23379 return self.Value
23380}
23381
23382func (self *OxmMetadata) SetValue(v uint64) {
23383 self.Value = v
23384}
23385
23386func (self *OxmMetadata) Serialize(encoder *goloxi.Encoder) error {
23387 if err := self.Oxm.Serialize(encoder); err != nil {
23388 return err
23389 }
23390
23391 encoder.PutUint64(uint64(self.Value))
23392
23393 return nil
23394}
23395
23396func DecodeOxmMetadata(parent *Oxm, decoder *goloxi.Decoder) (*OxmMetadata, error) {
23397 _oxmmetadata := &OxmMetadata{Oxm: parent}
23398 if decoder.Length() < 8 {
23399 return nil, fmt.Errorf("OxmMetadata packet too short: %d < 8", decoder.Length())
23400 }
23401 _oxmmetadata.Value = uint64(decoder.ReadUint64())
23402 return _oxmmetadata, nil
23403}
23404
23405func NewOxmMetadata() *OxmMetadata {
23406 obj := &OxmMetadata{
23407 Oxm: NewOxm(2147484680),
23408 }
23409 return obj
23410}
23411func (self *OxmMetadata) GetOXMName() string {
23412 return "metadata"
23413}
23414
23415func (self *OxmMetadata) GetOXMValue() interface{} {
23416 return self.Value
23417}
23418
23419func (self *OxmMetadata) MarshalJSON() ([]byte, error) {
23420 value, err := jsonValue(self.GetOXMValue())
23421 if err != nil {
23422 return nil, err
23423 }
23424 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
23425}
23426
23427type OxmMetadataMasked struct {
23428 *Oxm
23429 Value uint64
23430 ValueMask uint64
23431}
23432
23433type IOxmMetadataMasked interface {
23434 goloxi.IOxm
23435 GetValue() uint64
23436 GetValueMask() uint64
23437}
23438
23439func (self *OxmMetadataMasked) GetValue() uint64 {
23440 return self.Value
23441}
23442
23443func (self *OxmMetadataMasked) SetValue(v uint64) {
23444 self.Value = v
23445}
23446
23447func (self *OxmMetadataMasked) GetValueMask() uint64 {
23448 return self.ValueMask
23449}
23450
23451func (self *OxmMetadataMasked) SetValueMask(v uint64) {
23452 self.ValueMask = v
23453}
23454
23455func (self *OxmMetadataMasked) Serialize(encoder *goloxi.Encoder) error {
23456 if err := self.Oxm.Serialize(encoder); err != nil {
23457 return err
23458 }
23459
23460 encoder.PutUint64(uint64(self.Value))
23461 encoder.PutUint64(uint64(self.ValueMask))
23462
23463 return nil
23464}
23465
23466func DecodeOxmMetadataMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmMetadataMasked, error) {
23467 _oxmmetadatamasked := &OxmMetadataMasked{Oxm: parent}
23468 if decoder.Length() < 16 {
23469 return nil, fmt.Errorf("OxmMetadataMasked packet too short: %d < 16", decoder.Length())
23470 }
23471 _oxmmetadatamasked.Value = uint64(decoder.ReadUint64())
23472 _oxmmetadatamasked.ValueMask = uint64(decoder.ReadUint64())
23473 return _oxmmetadatamasked, nil
23474}
23475
23476func NewOxmMetadataMasked() *OxmMetadataMasked {
23477 obj := &OxmMetadataMasked{
23478 Oxm: NewOxm(2147484944),
23479 }
23480 return obj
23481}
23482func (self *OxmMetadataMasked) GetOXMName() string {
23483 return "metadata_masked"
23484}
23485
23486func (self *OxmMetadataMasked) GetOXMValue() interface{} {
23487 return self.Value
23488}
23489
23490func (self *OxmMetadataMasked) GetOXMValueMask() interface{} {
23491 return self.ValueMask
23492}
23493
23494func (self *OxmMetadataMasked) MarshalJSON() ([]byte, error) {
23495 value, err := jsonValue(self.GetOXMValue())
23496 if err != nil {
23497 return nil, err
23498 }
23499 valueMask, err := jsonValue(self.GetOXMValueMask())
23500 if err != nil {
23501 return nil, err
23502 }
23503 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
23504}
23505
23506type OxmMplsLabel struct {
23507 *Oxm
23508 Value uint32
23509}
23510
23511type IOxmMplsLabel interface {
23512 goloxi.IOxm
23513 GetValue() uint32
23514}
23515
23516func (self *OxmMplsLabel) GetValue() uint32 {
23517 return self.Value
23518}
23519
23520func (self *OxmMplsLabel) SetValue(v uint32) {
23521 self.Value = v
23522}
23523
23524func (self *OxmMplsLabel) Serialize(encoder *goloxi.Encoder) error {
23525 if err := self.Oxm.Serialize(encoder); err != nil {
23526 return err
23527 }
23528
23529 encoder.PutUint32(uint32(self.Value))
23530
23531 return nil
23532}
23533
23534func DecodeOxmMplsLabel(parent *Oxm, decoder *goloxi.Decoder) (*OxmMplsLabel, error) {
23535 _oxmmplslabel := &OxmMplsLabel{Oxm: parent}
23536 if decoder.Length() < 4 {
23537 return nil, fmt.Errorf("OxmMplsLabel packet too short: %d < 4", decoder.Length())
23538 }
23539 _oxmmplslabel.Value = uint32(decoder.ReadUint32())
23540 return _oxmmplslabel, nil
23541}
23542
23543func NewOxmMplsLabel() *OxmMplsLabel {
23544 obj := &OxmMplsLabel{
23545 Oxm: NewOxm(2147501060),
23546 }
23547 return obj
23548}
23549func (self *OxmMplsLabel) GetOXMName() string {
23550 return "mpls_label"
23551}
23552
23553func (self *OxmMplsLabel) GetOXMValue() interface{} {
23554 return self.Value
23555}
23556
23557func (self *OxmMplsLabel) MarshalJSON() ([]byte, error) {
23558 value, err := jsonValue(self.GetOXMValue())
23559 if err != nil {
23560 return nil, err
23561 }
23562 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
23563}
23564
23565type OxmMplsLabelMasked struct {
23566 *Oxm
23567 Value uint32
23568 ValueMask uint32
23569}
23570
23571type IOxmMplsLabelMasked interface {
23572 goloxi.IOxm
23573 GetValue() uint32
23574 GetValueMask() uint32
23575}
23576
23577func (self *OxmMplsLabelMasked) GetValue() uint32 {
23578 return self.Value
23579}
23580
23581func (self *OxmMplsLabelMasked) SetValue(v uint32) {
23582 self.Value = v
23583}
23584
23585func (self *OxmMplsLabelMasked) GetValueMask() uint32 {
23586 return self.ValueMask
23587}
23588
23589func (self *OxmMplsLabelMasked) SetValueMask(v uint32) {
23590 self.ValueMask = v
23591}
23592
23593func (self *OxmMplsLabelMasked) Serialize(encoder *goloxi.Encoder) error {
23594 if err := self.Oxm.Serialize(encoder); err != nil {
23595 return err
23596 }
23597
23598 encoder.PutUint32(uint32(self.Value))
23599 encoder.PutUint32(uint32(self.ValueMask))
23600
23601 return nil
23602}
23603
23604func DecodeOxmMplsLabelMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmMplsLabelMasked, error) {
23605 _oxmmplslabelmasked := &OxmMplsLabelMasked{Oxm: parent}
23606 if decoder.Length() < 8 {
23607 return nil, fmt.Errorf("OxmMplsLabelMasked packet too short: %d < 8", decoder.Length())
23608 }
23609 _oxmmplslabelmasked.Value = uint32(decoder.ReadUint32())
23610 _oxmmplslabelmasked.ValueMask = uint32(decoder.ReadUint32())
23611 return _oxmmplslabelmasked, nil
23612}
23613
23614func NewOxmMplsLabelMasked() *OxmMplsLabelMasked {
23615 obj := &OxmMplsLabelMasked{
23616 Oxm: NewOxm(2147501320),
23617 }
23618 return obj
23619}
23620func (self *OxmMplsLabelMasked) GetOXMName() string {
23621 return "mpls_label_masked"
23622}
23623
23624func (self *OxmMplsLabelMasked) GetOXMValue() interface{} {
23625 return self.Value
23626}
23627
23628func (self *OxmMplsLabelMasked) GetOXMValueMask() interface{} {
23629 return self.ValueMask
23630}
23631
23632func (self *OxmMplsLabelMasked) MarshalJSON() ([]byte, error) {
23633 value, err := jsonValue(self.GetOXMValue())
23634 if err != nil {
23635 return nil, err
23636 }
23637 valueMask, err := jsonValue(self.GetOXMValueMask())
23638 if err != nil {
23639 return nil, err
23640 }
23641 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
23642}
23643
23644type OxmMplsTc struct {
23645 *Oxm
23646 Value uint8
23647}
23648
23649type IOxmMplsTc interface {
23650 goloxi.IOxm
23651 GetValue() uint8
23652}
23653
23654func (self *OxmMplsTc) GetValue() uint8 {
23655 return self.Value
23656}
23657
23658func (self *OxmMplsTc) SetValue(v uint8) {
23659 self.Value = v
23660}
23661
23662func (self *OxmMplsTc) Serialize(encoder *goloxi.Encoder) error {
23663 if err := self.Oxm.Serialize(encoder); err != nil {
23664 return err
23665 }
23666
23667 encoder.PutUint8(uint8(self.Value))
23668
23669 return nil
23670}
23671
23672func DecodeOxmMplsTc(parent *Oxm, decoder *goloxi.Decoder) (*OxmMplsTc, error) {
23673 _oxmmplstc := &OxmMplsTc{Oxm: parent}
23674 if decoder.Length() < 1 {
23675 return nil, fmt.Errorf("OxmMplsTc packet too short: %d < 1", decoder.Length())
23676 }
23677 _oxmmplstc.Value = uint8(decoder.ReadByte())
23678 return _oxmmplstc, nil
23679}
23680
23681func NewOxmMplsTc() *OxmMplsTc {
23682 obj := &OxmMplsTc{
23683 Oxm: NewOxm(2147501569),
23684 }
23685 return obj
23686}
23687func (self *OxmMplsTc) GetOXMName() string {
23688 return "mpls_tc"
23689}
23690
23691func (self *OxmMplsTc) GetOXMValue() interface{} {
23692 return self.Value
23693}
23694
23695func (self *OxmMplsTc) MarshalJSON() ([]byte, error) {
23696 value, err := jsonValue(self.GetOXMValue())
23697 if err != nil {
23698 return nil, err
23699 }
23700 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
23701}
23702
23703type OxmMplsTcMasked struct {
23704 *Oxm
23705 Value uint8
23706 ValueMask uint8
23707}
23708
23709type IOxmMplsTcMasked interface {
23710 goloxi.IOxm
23711 GetValue() uint8
23712 GetValueMask() uint8
23713}
23714
23715func (self *OxmMplsTcMasked) GetValue() uint8 {
23716 return self.Value
23717}
23718
23719func (self *OxmMplsTcMasked) SetValue(v uint8) {
23720 self.Value = v
23721}
23722
23723func (self *OxmMplsTcMasked) GetValueMask() uint8 {
23724 return self.ValueMask
23725}
23726
23727func (self *OxmMplsTcMasked) SetValueMask(v uint8) {
23728 self.ValueMask = v
23729}
23730
23731func (self *OxmMplsTcMasked) Serialize(encoder *goloxi.Encoder) error {
23732 if err := self.Oxm.Serialize(encoder); err != nil {
23733 return err
23734 }
23735
23736 encoder.PutUint8(uint8(self.Value))
23737 encoder.PutUint8(uint8(self.ValueMask))
23738
23739 return nil
23740}
23741
23742func DecodeOxmMplsTcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmMplsTcMasked, error) {
23743 _oxmmplstcmasked := &OxmMplsTcMasked{Oxm: parent}
23744 if decoder.Length() < 2 {
23745 return nil, fmt.Errorf("OxmMplsTcMasked packet too short: %d < 2", decoder.Length())
23746 }
23747 _oxmmplstcmasked.Value = uint8(decoder.ReadByte())
23748 _oxmmplstcmasked.ValueMask = uint8(decoder.ReadByte())
23749 return _oxmmplstcmasked, nil
23750}
23751
23752func NewOxmMplsTcMasked() *OxmMplsTcMasked {
23753 obj := &OxmMplsTcMasked{
23754 Oxm: NewOxm(2147501826),
23755 }
23756 return obj
23757}
23758func (self *OxmMplsTcMasked) GetOXMName() string {
23759 return "mpls_tc_masked"
23760}
23761
23762func (self *OxmMplsTcMasked) GetOXMValue() interface{} {
23763 return self.Value
23764}
23765
23766func (self *OxmMplsTcMasked) GetOXMValueMask() interface{} {
23767 return self.ValueMask
23768}
23769
23770func (self *OxmMplsTcMasked) MarshalJSON() ([]byte, error) {
23771 value, err := jsonValue(self.GetOXMValue())
23772 if err != nil {
23773 return nil, err
23774 }
23775 valueMask, err := jsonValue(self.GetOXMValueMask())
23776 if err != nil {
23777 return nil, err
23778 }
23779 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
23780}
23781
23782type OxmSctpDst struct {
23783 *Oxm
23784 Value uint16
23785}
23786
23787type IOxmSctpDst interface {
23788 goloxi.IOxm
23789 GetValue() uint16
23790}
23791
23792func (self *OxmSctpDst) GetValue() uint16 {
23793 return self.Value
23794}
23795
23796func (self *OxmSctpDst) SetValue(v uint16) {
23797 self.Value = v
23798}
23799
23800func (self *OxmSctpDst) Serialize(encoder *goloxi.Encoder) error {
23801 if err := self.Oxm.Serialize(encoder); err != nil {
23802 return err
23803 }
23804
23805 encoder.PutUint16(uint16(self.Value))
23806
23807 return nil
23808}
23809
23810func DecodeOxmSctpDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmSctpDst, error) {
23811 _oxmsctpdst := &OxmSctpDst{Oxm: parent}
23812 if decoder.Length() < 2 {
23813 return nil, fmt.Errorf("OxmSctpDst packet too short: %d < 2", decoder.Length())
23814 }
23815 _oxmsctpdst.Value = uint16(decoder.ReadUint16())
23816 return _oxmsctpdst, nil
23817}
23818
23819func NewOxmSctpDst() *OxmSctpDst {
23820 obj := &OxmSctpDst{
23821 Oxm: NewOxm(2147492866),
23822 }
23823 return obj
23824}
23825func (self *OxmSctpDst) GetOXMName() string {
23826 return "sctp_dst"
23827}
23828
23829func (self *OxmSctpDst) GetOXMValue() interface{} {
23830 return self.Value
23831}
23832
23833func (self *OxmSctpDst) MarshalJSON() ([]byte, error) {
23834 value, err := jsonValue(self.GetOXMValue())
23835 if err != nil {
23836 return nil, err
23837 }
23838 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
23839}
23840
23841type OxmSctpDstMasked struct {
23842 *Oxm
23843 Value uint16
23844 ValueMask uint16
23845}
23846
23847type IOxmSctpDstMasked interface {
23848 goloxi.IOxm
23849 GetValue() uint16
23850 GetValueMask() uint16
23851}
23852
23853func (self *OxmSctpDstMasked) GetValue() uint16 {
23854 return self.Value
23855}
23856
23857func (self *OxmSctpDstMasked) SetValue(v uint16) {
23858 self.Value = v
23859}
23860
23861func (self *OxmSctpDstMasked) GetValueMask() uint16 {
23862 return self.ValueMask
23863}
23864
23865func (self *OxmSctpDstMasked) SetValueMask(v uint16) {
23866 self.ValueMask = v
23867}
23868
23869func (self *OxmSctpDstMasked) Serialize(encoder *goloxi.Encoder) error {
23870 if err := self.Oxm.Serialize(encoder); err != nil {
23871 return err
23872 }
23873
23874 encoder.PutUint16(uint16(self.Value))
23875 encoder.PutUint16(uint16(self.ValueMask))
23876
23877 return nil
23878}
23879
23880func DecodeOxmSctpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmSctpDstMasked, error) {
23881 _oxmsctpdstmasked := &OxmSctpDstMasked{Oxm: parent}
23882 if decoder.Length() < 4 {
23883 return nil, fmt.Errorf("OxmSctpDstMasked packet too short: %d < 4", decoder.Length())
23884 }
23885 _oxmsctpdstmasked.Value = uint16(decoder.ReadUint16())
23886 _oxmsctpdstmasked.ValueMask = uint16(decoder.ReadUint16())
23887 return _oxmsctpdstmasked, nil
23888}
23889
23890func NewOxmSctpDstMasked() *OxmSctpDstMasked {
23891 obj := &OxmSctpDstMasked{
23892 Oxm: NewOxm(2147493124),
23893 }
23894 return obj
23895}
23896func (self *OxmSctpDstMasked) GetOXMName() string {
23897 return "sctp_dst_masked"
23898}
23899
23900func (self *OxmSctpDstMasked) GetOXMValue() interface{} {
23901 return self.Value
23902}
23903
23904func (self *OxmSctpDstMasked) GetOXMValueMask() interface{} {
23905 return self.ValueMask
23906}
23907
23908func (self *OxmSctpDstMasked) MarshalJSON() ([]byte, error) {
23909 value, err := jsonValue(self.GetOXMValue())
23910 if err != nil {
23911 return nil, err
23912 }
23913 valueMask, err := jsonValue(self.GetOXMValueMask())
23914 if err != nil {
23915 return nil, err
23916 }
23917 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
23918}
23919
23920type OxmSctpSrc struct {
23921 *Oxm
23922 Value uint16
23923}
23924
23925type IOxmSctpSrc interface {
23926 goloxi.IOxm
23927 GetValue() uint16
23928}
23929
23930func (self *OxmSctpSrc) GetValue() uint16 {
23931 return self.Value
23932}
23933
23934func (self *OxmSctpSrc) SetValue(v uint16) {
23935 self.Value = v
23936}
23937
23938func (self *OxmSctpSrc) Serialize(encoder *goloxi.Encoder) error {
23939 if err := self.Oxm.Serialize(encoder); err != nil {
23940 return err
23941 }
23942
23943 encoder.PutUint16(uint16(self.Value))
23944
23945 return nil
23946}
23947
23948func DecodeOxmSctpSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmSctpSrc, error) {
23949 _oxmsctpsrc := &OxmSctpSrc{Oxm: parent}
23950 if decoder.Length() < 2 {
23951 return nil, fmt.Errorf("OxmSctpSrc packet too short: %d < 2", decoder.Length())
23952 }
23953 _oxmsctpsrc.Value = uint16(decoder.ReadUint16())
23954 return _oxmsctpsrc, nil
23955}
23956
23957func NewOxmSctpSrc() *OxmSctpSrc {
23958 obj := &OxmSctpSrc{
23959 Oxm: NewOxm(2147492354),
23960 }
23961 return obj
23962}
23963func (self *OxmSctpSrc) GetOXMName() string {
23964 return "sctp_src"
23965}
23966
23967func (self *OxmSctpSrc) GetOXMValue() interface{} {
23968 return self.Value
23969}
23970
23971func (self *OxmSctpSrc) MarshalJSON() ([]byte, error) {
23972 value, err := jsonValue(self.GetOXMValue())
23973 if err != nil {
23974 return nil, err
23975 }
23976 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
23977}
23978
23979type OxmSctpSrcMasked struct {
23980 *Oxm
23981 Value uint16
23982 ValueMask uint16
23983}
23984
23985type IOxmSctpSrcMasked interface {
23986 goloxi.IOxm
23987 GetValue() uint16
23988 GetValueMask() uint16
23989}
23990
23991func (self *OxmSctpSrcMasked) GetValue() uint16 {
23992 return self.Value
23993}
23994
23995func (self *OxmSctpSrcMasked) SetValue(v uint16) {
23996 self.Value = v
23997}
23998
23999func (self *OxmSctpSrcMasked) GetValueMask() uint16 {
24000 return self.ValueMask
24001}
24002
24003func (self *OxmSctpSrcMasked) SetValueMask(v uint16) {
24004 self.ValueMask = v
24005}
24006
24007func (self *OxmSctpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
24008 if err := self.Oxm.Serialize(encoder); err != nil {
24009 return err
24010 }
24011
24012 encoder.PutUint16(uint16(self.Value))
24013 encoder.PutUint16(uint16(self.ValueMask))
24014
24015 return nil
24016}
24017
24018func DecodeOxmSctpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmSctpSrcMasked, error) {
24019 _oxmsctpsrcmasked := &OxmSctpSrcMasked{Oxm: parent}
24020 if decoder.Length() < 4 {
24021 return nil, fmt.Errorf("OxmSctpSrcMasked packet too short: %d < 4", decoder.Length())
24022 }
24023 _oxmsctpsrcmasked.Value = uint16(decoder.ReadUint16())
24024 _oxmsctpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
24025 return _oxmsctpsrcmasked, nil
24026}
24027
24028func NewOxmSctpSrcMasked() *OxmSctpSrcMasked {
24029 obj := &OxmSctpSrcMasked{
24030 Oxm: NewOxm(2147492612),
24031 }
24032 return obj
24033}
24034func (self *OxmSctpSrcMasked) GetOXMName() string {
24035 return "sctp_src_masked"
24036}
24037
24038func (self *OxmSctpSrcMasked) GetOXMValue() interface{} {
24039 return self.Value
24040}
24041
24042func (self *OxmSctpSrcMasked) GetOXMValueMask() interface{} {
24043 return self.ValueMask
24044}
24045
24046func (self *OxmSctpSrcMasked) MarshalJSON() ([]byte, error) {
24047 value, err := jsonValue(self.GetOXMValue())
24048 if err != nil {
24049 return nil, err
24050 }
24051 valueMask, err := jsonValue(self.GetOXMValueMask())
24052 if err != nil {
24053 return nil, err
24054 }
24055 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
24056}
24057
24058type OxmTcpDst struct {
24059 *Oxm
24060 Value uint16
24061}
24062
24063type IOxmTcpDst interface {
24064 goloxi.IOxm
24065 GetValue() uint16
24066}
24067
24068func (self *OxmTcpDst) GetValue() uint16 {
24069 return self.Value
24070}
24071
24072func (self *OxmTcpDst) SetValue(v uint16) {
24073 self.Value = v
24074}
24075
24076func (self *OxmTcpDst) Serialize(encoder *goloxi.Encoder) error {
24077 if err := self.Oxm.Serialize(encoder); err != nil {
24078 return err
24079 }
24080
24081 encoder.PutUint16(uint16(self.Value))
24082
24083 return nil
24084}
24085
24086func DecodeOxmTcpDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmTcpDst, error) {
24087 _oxmtcpdst := &OxmTcpDst{Oxm: parent}
24088 if decoder.Length() < 2 {
24089 return nil, fmt.Errorf("OxmTcpDst packet too short: %d < 2", decoder.Length())
24090 }
24091 _oxmtcpdst.Value = uint16(decoder.ReadUint16())
24092 return _oxmtcpdst, nil
24093}
24094
24095func NewOxmTcpDst() *OxmTcpDst {
24096 obj := &OxmTcpDst{
24097 Oxm: NewOxm(2147490818),
24098 }
24099 return obj
24100}
24101func (self *OxmTcpDst) GetOXMName() string {
24102 return "tcp_dst"
24103}
24104
24105func (self *OxmTcpDst) GetOXMValue() interface{} {
24106 return self.Value
24107}
24108
24109func (self *OxmTcpDst) MarshalJSON() ([]byte, error) {
24110 value, err := jsonValue(self.GetOXMValue())
24111 if err != nil {
24112 return nil, err
24113 }
24114 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
24115}
24116
24117type OxmTcpDstMasked struct {
24118 *Oxm
24119 Value uint16
24120 ValueMask uint16
24121}
24122
24123type IOxmTcpDstMasked interface {
24124 goloxi.IOxm
24125 GetValue() uint16
24126 GetValueMask() uint16
24127}
24128
24129func (self *OxmTcpDstMasked) GetValue() uint16 {
24130 return self.Value
24131}
24132
24133func (self *OxmTcpDstMasked) SetValue(v uint16) {
24134 self.Value = v
24135}
24136
24137func (self *OxmTcpDstMasked) GetValueMask() uint16 {
24138 return self.ValueMask
24139}
24140
24141func (self *OxmTcpDstMasked) SetValueMask(v uint16) {
24142 self.ValueMask = v
24143}
24144
24145func (self *OxmTcpDstMasked) Serialize(encoder *goloxi.Encoder) error {
24146 if err := self.Oxm.Serialize(encoder); err != nil {
24147 return err
24148 }
24149
24150 encoder.PutUint16(uint16(self.Value))
24151 encoder.PutUint16(uint16(self.ValueMask))
24152
24153 return nil
24154}
24155
24156func DecodeOxmTcpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmTcpDstMasked, error) {
24157 _oxmtcpdstmasked := &OxmTcpDstMasked{Oxm: parent}
24158 if decoder.Length() < 4 {
24159 return nil, fmt.Errorf("OxmTcpDstMasked packet too short: %d < 4", decoder.Length())
24160 }
24161 _oxmtcpdstmasked.Value = uint16(decoder.ReadUint16())
24162 _oxmtcpdstmasked.ValueMask = uint16(decoder.ReadUint16())
24163 return _oxmtcpdstmasked, nil
24164}
24165
24166func NewOxmTcpDstMasked() *OxmTcpDstMasked {
24167 obj := &OxmTcpDstMasked{
24168 Oxm: NewOxm(2147491076),
24169 }
24170 return obj
24171}
24172func (self *OxmTcpDstMasked) GetOXMName() string {
24173 return "tcp_dst_masked"
24174}
24175
24176func (self *OxmTcpDstMasked) GetOXMValue() interface{} {
24177 return self.Value
24178}
24179
24180func (self *OxmTcpDstMasked) GetOXMValueMask() interface{} {
24181 return self.ValueMask
24182}
24183
24184func (self *OxmTcpDstMasked) MarshalJSON() ([]byte, error) {
24185 value, err := jsonValue(self.GetOXMValue())
24186 if err != nil {
24187 return nil, err
24188 }
24189 valueMask, err := jsonValue(self.GetOXMValueMask())
24190 if err != nil {
24191 return nil, err
24192 }
24193 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
24194}
24195
24196type OxmTcpSrc struct {
24197 *Oxm
24198 Value uint16
24199}
24200
24201type IOxmTcpSrc interface {
24202 goloxi.IOxm
24203 GetValue() uint16
24204}
24205
24206func (self *OxmTcpSrc) GetValue() uint16 {
24207 return self.Value
24208}
24209
24210func (self *OxmTcpSrc) SetValue(v uint16) {
24211 self.Value = v
24212}
24213
24214func (self *OxmTcpSrc) Serialize(encoder *goloxi.Encoder) error {
24215 if err := self.Oxm.Serialize(encoder); err != nil {
24216 return err
24217 }
24218
24219 encoder.PutUint16(uint16(self.Value))
24220
24221 return nil
24222}
24223
24224func DecodeOxmTcpSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmTcpSrc, error) {
24225 _oxmtcpsrc := &OxmTcpSrc{Oxm: parent}
24226 if decoder.Length() < 2 {
24227 return nil, fmt.Errorf("OxmTcpSrc packet too short: %d < 2", decoder.Length())
24228 }
24229 _oxmtcpsrc.Value = uint16(decoder.ReadUint16())
24230 return _oxmtcpsrc, nil
24231}
24232
24233func NewOxmTcpSrc() *OxmTcpSrc {
24234 obj := &OxmTcpSrc{
24235 Oxm: NewOxm(2147490306),
24236 }
24237 return obj
24238}
24239func (self *OxmTcpSrc) GetOXMName() string {
24240 return "tcp_src"
24241}
24242
24243func (self *OxmTcpSrc) GetOXMValue() interface{} {
24244 return self.Value
24245}
24246
24247func (self *OxmTcpSrc) MarshalJSON() ([]byte, error) {
24248 value, err := jsonValue(self.GetOXMValue())
24249 if err != nil {
24250 return nil, err
24251 }
24252 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
24253}
24254
24255type OxmTcpSrcMasked struct {
24256 *Oxm
24257 Value uint16
24258 ValueMask uint16
24259}
24260
24261type IOxmTcpSrcMasked interface {
24262 goloxi.IOxm
24263 GetValue() uint16
24264 GetValueMask() uint16
24265}
24266
24267func (self *OxmTcpSrcMasked) GetValue() uint16 {
24268 return self.Value
24269}
24270
24271func (self *OxmTcpSrcMasked) SetValue(v uint16) {
24272 self.Value = v
24273}
24274
24275func (self *OxmTcpSrcMasked) GetValueMask() uint16 {
24276 return self.ValueMask
24277}
24278
24279func (self *OxmTcpSrcMasked) SetValueMask(v uint16) {
24280 self.ValueMask = v
24281}
24282
24283func (self *OxmTcpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
24284 if err := self.Oxm.Serialize(encoder); err != nil {
24285 return err
24286 }
24287
24288 encoder.PutUint16(uint16(self.Value))
24289 encoder.PutUint16(uint16(self.ValueMask))
24290
24291 return nil
24292}
24293
24294func DecodeOxmTcpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmTcpSrcMasked, error) {
24295 _oxmtcpsrcmasked := &OxmTcpSrcMasked{Oxm: parent}
24296 if decoder.Length() < 4 {
24297 return nil, fmt.Errorf("OxmTcpSrcMasked packet too short: %d < 4", decoder.Length())
24298 }
24299 _oxmtcpsrcmasked.Value = uint16(decoder.ReadUint16())
24300 _oxmtcpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
24301 return _oxmtcpsrcmasked, nil
24302}
24303
24304func NewOxmTcpSrcMasked() *OxmTcpSrcMasked {
24305 obj := &OxmTcpSrcMasked{
24306 Oxm: NewOxm(2147490564),
24307 }
24308 return obj
24309}
24310func (self *OxmTcpSrcMasked) GetOXMName() string {
24311 return "tcp_src_masked"
24312}
24313
24314func (self *OxmTcpSrcMasked) GetOXMValue() interface{} {
24315 return self.Value
24316}
24317
24318func (self *OxmTcpSrcMasked) GetOXMValueMask() interface{} {
24319 return self.ValueMask
24320}
24321
24322func (self *OxmTcpSrcMasked) MarshalJSON() ([]byte, error) {
24323 value, err := jsonValue(self.GetOXMValue())
24324 if err != nil {
24325 return nil, err
24326 }
24327 valueMask, err := jsonValue(self.GetOXMValueMask())
24328 if err != nil {
24329 return nil, err
24330 }
24331 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
24332}
24333
24334type OxmUdpDst struct {
24335 *Oxm
24336 Value uint16
24337}
24338
24339type IOxmUdpDst interface {
24340 goloxi.IOxm
24341 GetValue() uint16
24342}
24343
24344func (self *OxmUdpDst) GetValue() uint16 {
24345 return self.Value
24346}
24347
24348func (self *OxmUdpDst) SetValue(v uint16) {
24349 self.Value = v
24350}
24351
24352func (self *OxmUdpDst) Serialize(encoder *goloxi.Encoder) error {
24353 if err := self.Oxm.Serialize(encoder); err != nil {
24354 return err
24355 }
24356
24357 encoder.PutUint16(uint16(self.Value))
24358
24359 return nil
24360}
24361
24362func DecodeOxmUdpDst(parent *Oxm, decoder *goloxi.Decoder) (*OxmUdpDst, error) {
24363 _oxmudpdst := &OxmUdpDst{Oxm: parent}
24364 if decoder.Length() < 2 {
24365 return nil, fmt.Errorf("OxmUdpDst packet too short: %d < 2", decoder.Length())
24366 }
24367 _oxmudpdst.Value = uint16(decoder.ReadUint16())
24368 return _oxmudpdst, nil
24369}
24370
24371func NewOxmUdpDst() *OxmUdpDst {
24372 obj := &OxmUdpDst{
24373 Oxm: NewOxm(2147491842),
24374 }
24375 return obj
24376}
24377func (self *OxmUdpDst) GetOXMName() string {
24378 return "udp_dst"
24379}
24380
24381func (self *OxmUdpDst) GetOXMValue() interface{} {
24382 return self.Value
24383}
24384
24385func (self *OxmUdpDst) MarshalJSON() ([]byte, error) {
24386 value, err := jsonValue(self.GetOXMValue())
24387 if err != nil {
24388 return nil, err
24389 }
24390 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
24391}
24392
24393type OxmUdpDstMasked struct {
24394 *Oxm
24395 Value uint16
24396 ValueMask uint16
24397}
24398
24399type IOxmUdpDstMasked interface {
24400 goloxi.IOxm
24401 GetValue() uint16
24402 GetValueMask() uint16
24403}
24404
24405func (self *OxmUdpDstMasked) GetValue() uint16 {
24406 return self.Value
24407}
24408
24409func (self *OxmUdpDstMasked) SetValue(v uint16) {
24410 self.Value = v
24411}
24412
24413func (self *OxmUdpDstMasked) GetValueMask() uint16 {
24414 return self.ValueMask
24415}
24416
24417func (self *OxmUdpDstMasked) SetValueMask(v uint16) {
24418 self.ValueMask = v
24419}
24420
24421func (self *OxmUdpDstMasked) Serialize(encoder *goloxi.Encoder) error {
24422 if err := self.Oxm.Serialize(encoder); err != nil {
24423 return err
24424 }
24425
24426 encoder.PutUint16(uint16(self.Value))
24427 encoder.PutUint16(uint16(self.ValueMask))
24428
24429 return nil
24430}
24431
24432func DecodeOxmUdpDstMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmUdpDstMasked, error) {
24433 _oxmudpdstmasked := &OxmUdpDstMasked{Oxm: parent}
24434 if decoder.Length() < 4 {
24435 return nil, fmt.Errorf("OxmUdpDstMasked packet too short: %d < 4", decoder.Length())
24436 }
24437 _oxmudpdstmasked.Value = uint16(decoder.ReadUint16())
24438 _oxmudpdstmasked.ValueMask = uint16(decoder.ReadUint16())
24439 return _oxmudpdstmasked, nil
24440}
24441
24442func NewOxmUdpDstMasked() *OxmUdpDstMasked {
24443 obj := &OxmUdpDstMasked{
24444 Oxm: NewOxm(2147492100),
24445 }
24446 return obj
24447}
24448func (self *OxmUdpDstMasked) GetOXMName() string {
24449 return "udp_dst_masked"
24450}
24451
24452func (self *OxmUdpDstMasked) GetOXMValue() interface{} {
24453 return self.Value
24454}
24455
24456func (self *OxmUdpDstMasked) GetOXMValueMask() interface{} {
24457 return self.ValueMask
24458}
24459
24460func (self *OxmUdpDstMasked) MarshalJSON() ([]byte, error) {
24461 value, err := jsonValue(self.GetOXMValue())
24462 if err != nil {
24463 return nil, err
24464 }
24465 valueMask, err := jsonValue(self.GetOXMValueMask())
24466 if err != nil {
24467 return nil, err
24468 }
24469 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
24470}
24471
24472type OxmUdpSrc struct {
24473 *Oxm
24474 Value uint16
24475}
24476
24477type IOxmUdpSrc interface {
24478 goloxi.IOxm
24479 GetValue() uint16
24480}
24481
24482func (self *OxmUdpSrc) GetValue() uint16 {
24483 return self.Value
24484}
24485
24486func (self *OxmUdpSrc) SetValue(v uint16) {
24487 self.Value = v
24488}
24489
24490func (self *OxmUdpSrc) Serialize(encoder *goloxi.Encoder) error {
24491 if err := self.Oxm.Serialize(encoder); err != nil {
24492 return err
24493 }
24494
24495 encoder.PutUint16(uint16(self.Value))
24496
24497 return nil
24498}
24499
24500func DecodeOxmUdpSrc(parent *Oxm, decoder *goloxi.Decoder) (*OxmUdpSrc, error) {
24501 _oxmudpsrc := &OxmUdpSrc{Oxm: parent}
24502 if decoder.Length() < 2 {
24503 return nil, fmt.Errorf("OxmUdpSrc packet too short: %d < 2", decoder.Length())
24504 }
24505 _oxmudpsrc.Value = uint16(decoder.ReadUint16())
24506 return _oxmudpsrc, nil
24507}
24508
24509func NewOxmUdpSrc() *OxmUdpSrc {
24510 obj := &OxmUdpSrc{
24511 Oxm: NewOxm(2147491330),
24512 }
24513 return obj
24514}
24515func (self *OxmUdpSrc) GetOXMName() string {
24516 return "udp_src"
24517}
24518
24519func (self *OxmUdpSrc) GetOXMValue() interface{} {
24520 return self.Value
24521}
24522
24523func (self *OxmUdpSrc) MarshalJSON() ([]byte, error) {
24524 value, err := jsonValue(self.GetOXMValue())
24525 if err != nil {
24526 return nil, err
24527 }
24528 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
24529}
24530
24531type OxmUdpSrcMasked struct {
24532 *Oxm
24533 Value uint16
24534 ValueMask uint16
24535}
24536
24537type IOxmUdpSrcMasked interface {
24538 goloxi.IOxm
24539 GetValue() uint16
24540 GetValueMask() uint16
24541}
24542
24543func (self *OxmUdpSrcMasked) GetValue() uint16 {
24544 return self.Value
24545}
24546
24547func (self *OxmUdpSrcMasked) SetValue(v uint16) {
24548 self.Value = v
24549}
24550
24551func (self *OxmUdpSrcMasked) GetValueMask() uint16 {
24552 return self.ValueMask
24553}
24554
24555func (self *OxmUdpSrcMasked) SetValueMask(v uint16) {
24556 self.ValueMask = v
24557}
24558
24559func (self *OxmUdpSrcMasked) Serialize(encoder *goloxi.Encoder) error {
24560 if err := self.Oxm.Serialize(encoder); err != nil {
24561 return err
24562 }
24563
24564 encoder.PutUint16(uint16(self.Value))
24565 encoder.PutUint16(uint16(self.ValueMask))
24566
24567 return nil
24568}
24569
24570func DecodeOxmUdpSrcMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmUdpSrcMasked, error) {
24571 _oxmudpsrcmasked := &OxmUdpSrcMasked{Oxm: parent}
24572 if decoder.Length() < 4 {
24573 return nil, fmt.Errorf("OxmUdpSrcMasked packet too short: %d < 4", decoder.Length())
24574 }
24575 _oxmudpsrcmasked.Value = uint16(decoder.ReadUint16())
24576 _oxmudpsrcmasked.ValueMask = uint16(decoder.ReadUint16())
24577 return _oxmudpsrcmasked, nil
24578}
24579
24580func NewOxmUdpSrcMasked() *OxmUdpSrcMasked {
24581 obj := &OxmUdpSrcMasked{
24582 Oxm: NewOxm(2147491588),
24583 }
24584 return obj
24585}
24586func (self *OxmUdpSrcMasked) GetOXMName() string {
24587 return "udp_src_masked"
24588}
24589
24590func (self *OxmUdpSrcMasked) GetOXMValue() interface{} {
24591 return self.Value
24592}
24593
24594func (self *OxmUdpSrcMasked) GetOXMValueMask() interface{} {
24595 return self.ValueMask
24596}
24597
24598func (self *OxmUdpSrcMasked) MarshalJSON() ([]byte, error) {
24599 value, err := jsonValue(self.GetOXMValue())
24600 if err != nil {
24601 return nil, err
24602 }
24603 valueMask, err := jsonValue(self.GetOXMValueMask())
24604 if err != nil {
24605 return nil, err
24606 }
24607 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
24608}
24609
24610type OxmVlanPcp struct {
24611 *Oxm
24612 Value uint8
24613}
24614
24615type IOxmVlanPcp interface {
24616 goloxi.IOxm
24617 GetValue() uint8
24618}
24619
24620func (self *OxmVlanPcp) GetValue() uint8 {
24621 return self.Value
24622}
24623
24624func (self *OxmVlanPcp) SetValue(v uint8) {
24625 self.Value = v
24626}
24627
24628func (self *OxmVlanPcp) Serialize(encoder *goloxi.Encoder) error {
24629 if err := self.Oxm.Serialize(encoder); err != nil {
24630 return err
24631 }
24632
24633 encoder.PutUint8(uint8(self.Value))
24634
24635 return nil
24636}
24637
24638func DecodeOxmVlanPcp(parent *Oxm, decoder *goloxi.Decoder) (*OxmVlanPcp, error) {
24639 _oxmvlanpcp := &OxmVlanPcp{Oxm: parent}
24640 if decoder.Length() < 1 {
24641 return nil, fmt.Errorf("OxmVlanPcp packet too short: %d < 1", decoder.Length())
24642 }
24643 _oxmvlanpcp.Value = uint8(decoder.ReadByte())
24644 return _oxmvlanpcp, nil
24645}
24646
24647func NewOxmVlanPcp() *OxmVlanPcp {
24648 obj := &OxmVlanPcp{
24649 Oxm: NewOxm(2147487233),
24650 }
24651 return obj
24652}
24653func (self *OxmVlanPcp) GetOXMName() string {
24654 return "vlan_pcp"
24655}
24656
24657func (self *OxmVlanPcp) GetOXMValue() interface{} {
24658 return self.Value
24659}
24660
24661func (self *OxmVlanPcp) MarshalJSON() ([]byte, error) {
24662 value, err := jsonValue(self.GetOXMValue())
24663 if err != nil {
24664 return nil, err
24665 }
24666 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
24667}
24668
24669type OxmVlanPcpMasked struct {
24670 *Oxm
24671 Value uint8
24672 ValueMask uint8
24673}
24674
24675type IOxmVlanPcpMasked interface {
24676 goloxi.IOxm
24677 GetValue() uint8
24678 GetValueMask() uint8
24679}
24680
24681func (self *OxmVlanPcpMasked) GetValue() uint8 {
24682 return self.Value
24683}
24684
24685func (self *OxmVlanPcpMasked) SetValue(v uint8) {
24686 self.Value = v
24687}
24688
24689func (self *OxmVlanPcpMasked) GetValueMask() uint8 {
24690 return self.ValueMask
24691}
24692
24693func (self *OxmVlanPcpMasked) SetValueMask(v uint8) {
24694 self.ValueMask = v
24695}
24696
24697func (self *OxmVlanPcpMasked) Serialize(encoder *goloxi.Encoder) error {
24698 if err := self.Oxm.Serialize(encoder); err != nil {
24699 return err
24700 }
24701
24702 encoder.PutUint8(uint8(self.Value))
24703 encoder.PutUint8(uint8(self.ValueMask))
24704
24705 return nil
24706}
24707
24708func DecodeOxmVlanPcpMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmVlanPcpMasked, error) {
24709 _oxmvlanpcpmasked := &OxmVlanPcpMasked{Oxm: parent}
24710 if decoder.Length() < 2 {
24711 return nil, fmt.Errorf("OxmVlanPcpMasked packet too short: %d < 2", decoder.Length())
24712 }
24713 _oxmvlanpcpmasked.Value = uint8(decoder.ReadByte())
24714 _oxmvlanpcpmasked.ValueMask = uint8(decoder.ReadByte())
24715 return _oxmvlanpcpmasked, nil
24716}
24717
24718func NewOxmVlanPcpMasked() *OxmVlanPcpMasked {
24719 obj := &OxmVlanPcpMasked{
24720 Oxm: NewOxm(2147487490),
24721 }
24722 return obj
24723}
24724func (self *OxmVlanPcpMasked) GetOXMName() string {
24725 return "vlan_pcp_masked"
24726}
24727
24728func (self *OxmVlanPcpMasked) GetOXMValue() interface{} {
24729 return self.Value
24730}
24731
24732func (self *OxmVlanPcpMasked) GetOXMValueMask() interface{} {
24733 return self.ValueMask
24734}
24735
24736func (self *OxmVlanPcpMasked) MarshalJSON() ([]byte, error) {
24737 value, err := jsonValue(self.GetOXMValue())
24738 if err != nil {
24739 return nil, err
24740 }
24741 valueMask, err := jsonValue(self.GetOXMValueMask())
24742 if err != nil {
24743 return nil, err
24744 }
24745 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
24746}
24747
24748type OxmVlanVid struct {
24749 *Oxm
24750 Value uint16
24751}
24752
24753type IOxmVlanVid interface {
24754 goloxi.IOxm
24755 GetValue() uint16
24756}
24757
24758func (self *OxmVlanVid) GetValue() uint16 {
24759 return self.Value
24760}
24761
24762func (self *OxmVlanVid) SetValue(v uint16) {
24763 self.Value = v
24764}
24765
24766func (self *OxmVlanVid) Serialize(encoder *goloxi.Encoder) error {
24767 if err := self.Oxm.Serialize(encoder); err != nil {
24768 return err
24769 }
24770
24771 encoder.PutUint16(uint16(self.Value))
24772
24773 return nil
24774}
24775
24776func DecodeOxmVlanVid(parent *Oxm, decoder *goloxi.Decoder) (*OxmVlanVid, error) {
24777 _oxmvlanvid := &OxmVlanVid{Oxm: parent}
24778 if decoder.Length() < 2 {
24779 return nil, fmt.Errorf("OxmVlanVid packet too short: %d < 2", decoder.Length())
24780 }
24781 _oxmvlanvid.Value = uint16(decoder.ReadUint16())
24782 return _oxmvlanvid, nil
24783}
24784
24785func NewOxmVlanVid() *OxmVlanVid {
24786 obj := &OxmVlanVid{
24787 Oxm: NewOxm(2147486722),
24788 }
24789 return obj
24790}
24791func (self *OxmVlanVid) GetOXMName() string {
24792 return "vlan_vid"
24793}
24794
24795func (self *OxmVlanVid) GetOXMValue() interface{} {
24796 return self.Value
24797}
24798
24799func (self *OxmVlanVid) MarshalJSON() ([]byte, error) {
24800 value, err := jsonValue(self.GetOXMValue())
24801 if err != nil {
24802 return nil, err
24803 }
24804 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s}", self.GetOXMName(), string(value))), nil
24805}
24806
24807type OxmVlanVidMasked struct {
24808 *Oxm
24809 Value uint16
24810 ValueMask uint16
24811}
24812
24813type IOxmVlanVidMasked interface {
24814 goloxi.IOxm
24815 GetValue() uint16
24816 GetValueMask() uint16
24817}
24818
24819func (self *OxmVlanVidMasked) GetValue() uint16 {
24820 return self.Value
24821}
24822
24823func (self *OxmVlanVidMasked) SetValue(v uint16) {
24824 self.Value = v
24825}
24826
24827func (self *OxmVlanVidMasked) GetValueMask() uint16 {
24828 return self.ValueMask
24829}
24830
24831func (self *OxmVlanVidMasked) SetValueMask(v uint16) {
24832 self.ValueMask = v
24833}
24834
24835func (self *OxmVlanVidMasked) Serialize(encoder *goloxi.Encoder) error {
24836 if err := self.Oxm.Serialize(encoder); err != nil {
24837 return err
24838 }
24839
24840 encoder.PutUint16(uint16(self.Value))
24841 encoder.PutUint16(uint16(self.ValueMask))
24842
24843 return nil
24844}
24845
24846func DecodeOxmVlanVidMasked(parent *Oxm, decoder *goloxi.Decoder) (*OxmVlanVidMasked, error) {
24847 _oxmvlanvidmasked := &OxmVlanVidMasked{Oxm: parent}
24848 if decoder.Length() < 4 {
24849 return nil, fmt.Errorf("OxmVlanVidMasked packet too short: %d < 4", decoder.Length())
24850 }
24851 _oxmvlanvidmasked.Value = uint16(decoder.ReadUint16())
24852 _oxmvlanvidmasked.ValueMask = uint16(decoder.ReadUint16())
24853 return _oxmvlanvidmasked, nil
24854}
24855
24856func NewOxmVlanVidMasked() *OxmVlanVidMasked {
24857 obj := &OxmVlanVidMasked{
24858 Oxm: NewOxm(2147486980),
24859 }
24860 return obj
24861}
24862func (self *OxmVlanVidMasked) GetOXMName() string {
24863 return "vlan_vid_masked"
24864}
24865
24866func (self *OxmVlanVidMasked) GetOXMValue() interface{} {
24867 return self.Value
24868}
24869
24870func (self *OxmVlanVidMasked) GetOXMValueMask() interface{} {
24871 return self.ValueMask
24872}
24873
24874func (self *OxmVlanVidMasked) MarshalJSON() ([]byte, error) {
24875 value, err := jsonValue(self.GetOXMValue())
24876 if err != nil {
24877 return nil, err
24878 }
24879 valueMask, err := jsonValue(self.GetOXMValueMask())
24880 if err != nil {
24881 return nil, err
24882 }
24883 return []byte(fmt.Sprintf("{\"Type\":\"%s\",\"Value\":%s,\"Mask\":%s}", self.GetOXMName(), string(value), string(valueMask))), nil
24884}